uci.c

   1 /*
   2  * luci-rpcd - LuCI UBUS RPC server
   3  *
   4  *   Copyright (C) 2013 Jo-Philipp Wich <jow@openwrt.org>
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include "uci.h"
  20
  21 static struct blob_buf buf;
  22 static struct uci_context *cursor;
  23
  24 enum {
  25         RPC_G_CONFIG,
  26         RPC_G_SECTION,
  27         RPC_G_OPTION,
  28         RPC_G_TYPE,
  29         RPC_G_MATCH,
  30         __RPC_G_MAX,
  31 };
  32
  33 static const struct blobmsg_policy rpc_uci_get_policy[__RPC_G_MAX] = {
  34         [RPC_G_CONFIG]  = { .name = "config",  .type = BLOBMSG_TYPE_STRING },
  35         [RPC_G_SECTION] = { .name = "section", .type = BLOBMSG_TYPE_STRING },
  36         [RPC_G_OPTION]  = { .name = "option",  .type = BLOBMSG_TYPE_STRING },
  37         [RPC_G_TYPE]    = { .name = "type",    .type = BLOBMSG_TYPE_STRING },
  38         [RPC_G_MATCH]   = { .name = "match",   .type = BLOBMSG_TYPE_TABLE  },
  39 };
  40
  41 enum {
  42         RPC_A_CONFIG,
  43         RPC_A_TYPE,
  44         RPC_A_NAME,
  45         RPC_A_VALUES,
  46         __RPC_A_MAX,
  47 };
  48
  49 static const struct blobmsg_policy rpc_uci_add_policy[__RPC_A_MAX] = {
  50         [RPC_A_CONFIG]  = { .name = "config",  .type = BLOBMSG_TYPE_STRING },
  51         [RPC_A_TYPE]    = { .name = "type",    .type = BLOBMSG_TYPE_STRING },
  52         [RPC_A_NAME]    = { .name = "name",    .type = BLOBMSG_TYPE_STRING },
  53         [RPC_A_VALUES]  = { .name = "values",  .type = BLOBMSG_TYPE_TABLE  },
  54 };
  55
  56 enum {
  57         RPC_S_CONFIG,
  58         RPC_S_SECTION,
  59         RPC_S_TYPE,
  60         RPC_S_MATCH,
  61         RPC_S_VALUES,
  62         __RPC_S_MAX,
  63 };
  64
  65 static const struct blobmsg_policy rpc_uci_set_policy[__RPC_S_MAX] = {
  66         [RPC_S_CONFIG]  = { .name = "config",   .type = BLOBMSG_TYPE_STRING },
  67         [RPC_S_SECTION] = { .name = "section",  .type = BLOBMSG_TYPE_STRING },
  68         [RPC_S_TYPE]    = { .name = "type",     .type = BLOBMSG_TYPE_STRING },
  69         [RPC_S_MATCH]   = { .name = "match",    .type = BLOBMSG_TYPE_TABLE  },
  70         [RPC_S_VALUES]  = { .name = "values",   .type = BLOBMSG_TYPE_TABLE  },
  71 };
  72
  73 enum {
  74         RPC_D_CONFIG,
  75         RPC_D_SECTION,
  76         RPC_D_TYPE,
  77         RPC_D_MATCH,
  78         RPC_D_OPTION,
  79         RPC_D_OPTIONS,
  80         __RPC_D_MAX,
  81 };
  82
  83 static const struct blobmsg_policy rpc_uci_delete_policy[__RPC_D_MAX] = {
  84         [RPC_D_CONFIG]  = { .name = "config",   .type = BLOBMSG_TYPE_STRING },
  85         [RPC_D_SECTION] = { .name = "section",  .type = BLOBMSG_TYPE_STRING },
  86         [RPC_D_TYPE]    = { .name = "type",     .type = BLOBMSG_TYPE_STRING },
  87         [RPC_D_MATCH]   = { .name = "match",    .type = BLOBMSG_TYPE_TABLE  },
  88         [RPC_D_OPTION]  = { .name = "option",   .type = BLOBMSG_TYPE_STRING },
  89         [RPC_D_OPTIONS] = { .name = "options",  .type = BLOBMSG_TYPE_ARRAY  },
  90 };
  91
  92 enum {
  93         RPC_R_CONFIG,
  94         RPC_R_SECTION,
  95         RPC_R_OPTION,
  96         RPC_R_NAME,
  97         __RPC_R_MAX,
  98 };
  99
 100 static const struct blobmsg_policy rpc_uci_rename_policy[__RPC_R_MAX] = {
 101         [RPC_R_CONFIG]  = { .name = "config",   .type = BLOBMSG_TYPE_STRING },
 102         [RPC_R_SECTION] = { .name = "section",  .type = BLOBMSG_TYPE_STRING },
 103         [RPC_R_OPTION]  = { .name = "option",   .type = BLOBMSG_TYPE_STRING },
 104         [RPC_R_NAME]    = { .name = "name",     .type = BLOBMSG_TYPE_STRING },
 105 };
 106
 107 enum {
 108         RPC_O_CONFIG,
 109         RPC_O_SECTIONS,
 110         __RPC_O_MAX,
 111 };
 112
 113 static const struct blobmsg_policy rpc_uci_order_policy[__RPC_O_MAX] = {
 114         [RPC_O_CONFIG]   = { .name = "config",   .type = BLOBMSG_TYPE_STRING },
 115         [RPC_O_SECTIONS] = { .name = "sections", .type = BLOBMSG_TYPE_ARRAY  },
 116 };
 117
 118 enum {
 119         RPC_C_CONFIG,
 120         __RPC_C_MAX,
 121 };
 122
 123 static const struct blobmsg_policy rpc_uci_config_policy[__RPC_C_MAX] = {
 124         [RPC_C_CONFIG]   = { .name = "config",  .type = BLOBMSG_TYPE_STRING },
 125 };
 126
 127 /*
 128  * Turn uci error state into ubus return code
 129  */
 130 static int
 131 rpc_uci_status(void)
 132 {
 133         switch (cursor->err)
 134         {
 135         case UCI_OK:
 136                 return UBUS_STATUS_OK;
 137
 138         case UCI_ERR_INVAL:
 139                 return UBUS_STATUS_INVALID_ARGUMENT;
 140
 141         case UCI_ERR_NOTFOUND:
 142                 return UBUS_STATUS_NOT_FOUND;
 143
 144         default:
 145                 return UBUS_STATUS_UNKNOWN_ERROR;
 146         }
 147 }
 148
 149 /*
 150  * Format applicable blob value as string and place a pointer to the string
 151  * buffer in "p". Uses a static string buffer.
 152  */
 153 static bool
 154 rpc_uci_format_blob(struct blob_attr *v, const char **p)
 155 {
 156         static char buf[21];
 157
 158         *p = NULL;
 159
 160         switch (blobmsg_type(v))
 161         {
 162         case BLOBMSG_TYPE_STRING:
 163                 if (blobmsg_data_len(v) > 1)
 164                         *p = blobmsg_data(v);
 165                 break;
 166
 167         case BLOBMSG_TYPE_INT64:
 168                 snprintf(buf, sizeof(buf), "%"PRIu64, blobmsg_get_u64(v));
 169                 *p = buf;
 170                 break;
 171
 172         case BLOBMSG_TYPE_INT32:
 173                 snprintf(buf, sizeof(buf), "%u", blobmsg_get_u32(v));
 174                 *p = buf;
 175                 break;
 176
 177         case BLOBMSG_TYPE_INT16:
 178                 snprintf(buf, sizeof(buf), "%u", blobmsg_get_u16(v));
 179                 *p = buf;
 180                 break;
 181
 182         case BLOBMSG_TYPE_INT8:
 183                 snprintf(buf, sizeof(buf), "%u", !!blobmsg_get_u8(v));
 184                 *p = buf;
 185                 break;
 186
 187         default:
 188                 break;
 189         }
 190
 191         return !!*p;
 192 }
 193
 194 /*
 195  * Lookup the given uci_ptr and enable extended lookup format if the .section
 196  * value of the uci_ptr looks like extended syntax. Uses an internal copy
 197  * of the given uci_ptr to perform the lookup as failing extended section
 198  * lookup operations in libuci will zero our the uci_ptr struct.
 199  * Copies the internal uci_ptr back to given the uci_ptr on success.
 200  */
 201 static int
 202 rpc_uci_lookup(struct uci_ptr *ptr)
 203 {
 204         int rv;
 205         struct uci_ptr lookup = *ptr;
 206
 207         if (!lookup.s && lookup.section && *lookup.section == '@')
 208                 lookup.flags |= UCI_LOOKUP_EXTENDED;
 209
 210         rv = uci_lookup_ptr(cursor, &lookup, NULL, true);
 211
 212         if (!rv)
 213                 *ptr = lookup;
 214
 215         return rv;
 216 }
 217
 218 /*
 219  * Checks whether the given uci_option object matches the given string value.
 220  *  1) If the uci_option is of type list, check whether any of the list elements
 221  *     equals to the given string
 222  *  2) If the uci_option is of type string, parse it into space separated tokens
 223  *     and check if any of the tokens equals to the given string.
 224  *  Returns true if a list element or token matched the given string.
 225  */
 226 static bool
 227 rpc_uci_match_option(struct uci_option *o, const char *cmp)
 228 {
 229         struct uci_element *e;
 230         char *s, *p;
 231
 232         if (o->type == UCI_TYPE_LIST)
 233         {
 234                 uci_foreach_element(&o->v.list, e)
 235                         if (e->name && !strcmp(e->name, cmp))
 236                                 return true;
 237
 238                 return false;
 239         }
 240
 241         if (!o->v.string)
 242                 return false;
 243
 244         s = strdup(o->v.string);
 245
 246         if (!s)
 247                 return false;
 248
 249         for (p = strtok(s, " \t"); p; p = strtok(NULL, " \t"))
 250         {
 251                 if (!strcmp(p, cmp))
 252                 {
 253                         free(s);
 254                         return true;
 255                 }
 256         }
 257
 258         free(s);
 259         return false;
 260 }
 261
 262 /*
 263  * Checks whether the given uci_section matches the type and value blob attrs.
 264  *  1) Returns false if "type" is given and the section type does not match
 265  *     the value specified in the "type" string blob attribute, else continue.
 266  *  2) Tests whether any key in the "matches" table blob attribute exists in
 267  *     the given uci_section and whether each value is contained in the
 268  *     corresponding uci option value (see rpc_uci_match_option()).
 269  *  3) A missing or empty "matches" table blob attribute is always considered
 270  *     to be a match.
 271  * Returns true if "type" matches or is NULL and "matches" matches or is NULL.
 272  */
 273 static bool
 274 rpc_uci_match_section(struct uci_section *s,
 275                       struct blob_attr *type, struct blob_attr *matches)
 276 {
 277         struct uci_element *e;
 278         struct blob_attr *cur;
 279         const char *cmp;
 280         bool match = false;
 281         bool empty = true;
 282         int rem;
 283
 284         if (type && strcmp(s->type, blobmsg_data(type)))
 285                 return false;
 286
 287         if (!matches)
 288                 return true;
 289
 290         blobmsg_for_each_attr(cur, matches, rem)
 291         {
 292                 if (!rpc_uci_format_blob(cur, &cmp))
 293                         continue;
 294
 295                 uci_foreach_element(&s->options, e)
 296                 {
 297                         if (strcmp(e->name, blobmsg_name(cur)))
 298                                 continue;
 299
 300                         if (!rpc_uci_match_option(uci_to_option(e), cmp))
 301                                 return false;
 302
 303                         match = true;
 304                 }
 305
 306                 empty = false;
 307         }
 308
 309         return (empty || match);
 310 }
 311
 312 /*
 313  * Dump the given uci_option value into the global blobmsg buffer and use
 314  * given "name" as key.
 315  *  1) If the uci_option is of type list, put a table into the blob buffer and
 316  *     add each list item as string to it.
 317  *  2) If the uci_option is of type string, put its value directly into the blob
 318  *     buffer.
 319  */
 320 static void
 321 rpc_uci_dump_option(struct uci_option *o, const char *name)
 322 {
 323         void *c;
 324         struct uci_element *e;
 325
 326         switch (o->type)
 327         {
 328         case UCI_TYPE_STRING:
 329                 blobmsg_add_string(&buf, name, o->v.string);
 330                 break;
 331
 332         case UCI_TYPE_LIST:
 333                 c = blobmsg_open_array(&buf, name);
 334
 335                 uci_foreach_element(&o->v.list, e)
 336                         blobmsg_add_string(&buf, NULL, e->name);
 337
 338                 blobmsg_close_array(&buf, c);
 339                 break;
 340
 341         default:
 342                 break;
 343         }
 344 }
 345
 346 /*
 347  * Dump the given uci_section object into the global blobmsg buffer and use
 348  * given "name" as key.
 349  * Puts a table into the blob buffer and puts each section option member value
 350  * as value into the table using the option name as key.
 351  * Adds three special keys ".anonymous", ".type" and ".name" which specify the
 352  * corresponding section properties.
 353  */
 354 static void
 355 rpc_uci_dump_section(struct uci_section *s, const char *name)
 356 {
 357         void *c;
 358         struct uci_option *o;
 359         struct uci_element *e;
 360
 361         c = blobmsg_open_table(&buf, name);
 362
 363         blobmsg_add_u8(&buf, ".anonymous", s->anonymous);
 364         blobmsg_add_string(&buf, ".type", s->type);
 365         blobmsg_add_string(&buf, ".name", s->e.name);
 366
 367         uci_foreach_element(&s->options, e)
 368         {
 369                 o = uci_to_option(e);
 370                 rpc_uci_dump_option(o, o->e.name);
 371         }
 372
 373         blobmsg_close_table(&buf, c);
 374 }
 375
 376 /*
 377  * Dump the given uci_package object into the global blobmsg buffer and use
 378  * given "name" as key.
 379  * Puts a table into the blob buffer and puts each package section member as
 380  * value into the table using the section name as key.
 381  * Only dumps sections matching the given "type" and "matches", see explaination
 382  * of rpc_uci_match_section() for details.
 383  */
 384 static void
 385 rpc_uci_dump_package(struct uci_package *p, const char *name,
 386                      struct blob_attr *type, struct blob_attr *matches)
 387 {
 388         void *c;
 389         struct uci_element *e;
 390
 391         c = blobmsg_open_table(&buf, name);
 392
 393         uci_foreach_element(&p->sections, e)
 394         {
 395                 if (!rpc_uci_match_section(uci_to_section(e), type, matches))
 396                         continue;
 397
 398                 rpc_uci_dump_section(uci_to_section(e), e->name);
 399         }
 400
 401         blobmsg_close_table(&buf, c);
 402 }
 403
 404
 405 static int
 406 rpc_uci_get(struct ubus_context *ctx, struct ubus_object *obj,
 407             struct ubus_request_data *req, const char *method,
 408             struct blob_attr *msg)
 409 {
 410         struct blob_attr *tb[__RPC_G_MAX];
 411         struct uci_package *p = NULL;
 412         struct uci_ptr ptr = { 0 };
 413
 414         blobmsg_parse(rpc_uci_get_policy, __RPC_G_MAX, tb,
 415                       blob_data(msg), blob_len(msg));
 416
 417         if (!tb[RPC_G_CONFIG])
 418                 return UBUS_STATUS_INVALID_ARGUMENT;
 419
 420         ptr.package = blobmsg_data(tb[RPC_G_CONFIG]);
 421         uci_load(cursor, ptr.package, &p);
 422
 423         if (!p)
 424                 goto out;
 425
 426         if (tb[RPC_G_SECTION])
 427         {
 428                 ptr.section = blobmsg_data(tb[RPC_G_SECTION]);
 429
 430                 if (tb[RPC_G_OPTION])
 431                         ptr.option = blobmsg_data(tb[RPC_G_OPTION]);
 432         }
 433
 434         if (rpc_uci_lookup(&ptr) || !(ptr.flags & UCI_LOOKUP_COMPLETE))
 435                 goto out;
 436
 437         blob_buf_init(&buf, 0);
 438
 439         switch (ptr.last->type)
 440         {
 441         case UCI_TYPE_PACKAGE:
 442                 rpc_uci_dump_package(ptr.p, "values", tb[RPC_G_TYPE], tb[RPC_G_MATCH]);
 443                 break;
 444
 445         case UCI_TYPE_SECTION:
 446                 rpc_uci_dump_section(ptr.s, "values");
 447                 break;
 448
 449         case UCI_TYPE_OPTION:
 450                 rpc_uci_dump_option(ptr.o, "value");
 451                 break;
 452
 453         default:
 454                 break;
 455         }
 456
 457         ubus_send_reply(ctx, req, buf.head);
 458
 459 out:
 460         if (p)
 461                 uci_unload(cursor, p);
 462
 463         return rpc_uci_status();
 464 }
 465
 466 static int
 467 rpc_uci_add(struct ubus_context *ctx, struct ubus_object *obj,
 468             struct ubus_request_data *req, const char *method,
 469             struct blob_attr *msg)
 470 {
 471         struct blob_attr *tb[__RPC_A_MAX];
 472         struct blob_attr *cur, *elem;
 473         struct uci_package *p = NULL;
 474         struct uci_section *s;
 475         struct uci_ptr ptr = { 0 };
 476         int rem, rem2;
 477
 478         blobmsg_parse(rpc_uci_add_policy, __RPC_A_MAX, tb,
 479                       blob_data(msg), blob_len(msg));
 480
 481         if (!tb[RPC_A_CONFIG] || !tb[RPC_A_TYPE])
 482                 return UBUS_STATUS_INVALID_ARGUMENT;
 483
 484         ptr.package = blobmsg_data(tb[RPC_A_CONFIG]);
 485
 486         uci_load(cursor, ptr.package, &p);
 487
 488         if (!p)
 489                 goto out;
 490
 491         /* add named section */
 492         if (tb[RPC_A_NAME])
 493         {
 494                 ptr.section = blobmsg_data(tb[RPC_A_NAME]);
 495                 ptr.value   = blobmsg_data(tb[RPC_A_TYPE]);
 496                 ptr.option  = NULL;
 497
 498                 if (rpc_uci_lookup(&ptr) || uci_set(cursor, &ptr))
 499                         goto out;
 500         }
 501
 502         /* add anon section */
 503         else
 504         {
 505                 if (uci_add_section(cursor, p, blobmsg_data(tb[RPC_A_TYPE]), &s) || !s)
 506                         goto out;
 507
 508                 ptr.section = s->e.name;
 509         }
 510
 511         if (tb[RPC_A_VALUES])
 512         {
 513                 blobmsg_for_each_attr(cur, tb[RPC_A_VALUES], rem)
 514                 {
 515                         ptr.o = NULL;
 516                         ptr.option = blobmsg_name(cur);
 517
 518                         if (rpc_uci_lookup(&ptr) || !ptr.s)
 519                                 continue;
 520
 521                         switch (blobmsg_type(cur))
 522                         {
 523                         case BLOBMSG_TYPE_ARRAY:
 524                                 blobmsg_for_each_attr(elem, cur, rem2)
 525                                         if (rpc_uci_format_blob(elem, &ptr.value))
 526                                                 uci_add_list(cursor, &ptr);
 527                                 break;
 528
 529                         default:
 530                                 if (rpc_uci_format_blob(cur, &ptr.value))
 531                                         uci_set(cursor, &ptr);
 532                                 break;
 533                         }
 534                 }
 535         }
 536
 537         uci_save(cursor, p);
 538
 539         blob_buf_init(&buf, 0);
 540         blobmsg_add_string(&buf, "section", ptr.section);
 541         ubus_send_reply(ctx, req, buf.head);
 542
 543 out:
 544         if (p)
 545                 uci_unload(cursor, p);
 546
 547         return rpc_uci_status();
 548 }
 549
 550 /*
 551  * Turn value from a blob attribute into uci set operation
 552  *  1) if the blob is of type array, delete existing option (if any) and
 553  *     emit uci add_list operations for each element
 554  *  2) if the blob is not an array but an option of type list exists,
 555  *     delete existing list and emit uci set operation for the blob value
 556  *  3) in all other cases only emit a set operation if there is no existing
 557  *     option of if the existing options value differs from the blob value
 558  */
 559 static void
 560 rpc_uci_merge_set(struct blob_attr *opt, struct uci_ptr *ptr)
 561 {
 562         struct blob_attr *cur;
 563         int rem;
 564
 565         ptr->o = NULL;
 566         ptr->option = blobmsg_name(opt);
 567
 568         if (rpc_uci_lookup(ptr) || !ptr->s)
 569                 return;
 570
 571         if (blobmsg_type(opt) == BLOBMSG_TYPE_ARRAY)
 572         {
 573                 if (ptr->o)
 574                         uci_delete(cursor, ptr);
 575
 576                 blobmsg_for_each_attr(cur, opt, rem)
 577                         if (rpc_uci_format_blob(cur, &ptr->value))
 578                                 uci_add_list(cursor, ptr);
 579         }
 580         else if (ptr->o && ptr->o->type == UCI_TYPE_LIST)
 581         {
 582                 uci_delete(cursor, ptr);
 583
 584                 if (rpc_uci_format_blob(opt, &ptr->value))
 585                         uci_set(cursor, ptr);
 586         }
 587         else if (rpc_uci_format_blob(opt, &ptr->value))
 588         {
 589                 if (!ptr->o || !ptr->o->v.string || strcmp(ptr->o->v.string, ptr->value))
 590                         uci_set(cursor, ptr);
 591         }
 592 }
 593
 594 static int
 595 rpc_uci_set(struct ubus_context *ctx, struct ubus_object *obj,
 596             struct ubus_request_data *req, const char *method,
 597             struct blob_attr *msg)
 598 {
 599         struct blob_attr *tb[__RPC_S_MAX];
 600         struct blob_attr *cur;
 601         struct uci_package *p = NULL;
 602         struct uci_element *e;
 603         struct uci_ptr ptr = { 0 };
 604         int rem;
 605
 606         blobmsg_parse(rpc_uci_set_policy, __RPC_S_MAX, tb,
 607                       blob_data(msg), blob_len(msg));
 608
 609         if (!tb[RPC_S_CONFIG] || !tb[RPC_S_VALUES] ||
 610                 (!tb[RPC_S_SECTION] && !tb[RPC_S_TYPE] && !tb[RPC_S_MATCH]))
 611                 return UBUS_STATUS_INVALID_ARGUMENT;
 612
 613         ptr.package = blobmsg_data(tb[RPC_S_CONFIG]);
 614         uci_load(cursor, ptr.package, &p);
 615
 616         if (!p)
 617                 goto out;
 618
 619         if (tb[RPC_S_SECTION])
 620         {
 621                 ptr.section = blobmsg_data(tb[RPC_S_SECTION]);
 622                 blobmsg_for_each_attr(cur, tb[RPC_S_VALUES], rem)
 623                         rpc_uci_merge_set(cur, &ptr);
 624         }
 625         else
 626         {
 627                 uci_foreach_element(&p->sections, e)
 628                 {
 629                         if (!rpc_uci_match_section(uci_to_section(e),
 630                                                    tb[RPC_S_TYPE], tb[RPC_S_MATCH]))
 631                                 continue;
 632
 633                         ptr.s = NULL;
 634                         ptr.section = e->name;
 635
 636                         blobmsg_for_each_attr(cur, tb[RPC_S_VALUES], rem)
 637                                 rpc_uci_merge_set(cur, &ptr);
 638                 }
 639         }
 640
 641         uci_save(cursor, p);
 642
 643 out:
 644         if (p)
 645                 uci_unload(cursor, p);
 646
 647         return rpc_uci_status();
 648 }
 649
 650 /*
 651  * Delete option or section from uci specified by given blob attribute pointer
 652  *  1) if the blob is of type array, delete any option named after each element
 653  *  2) if the blob is of type string, delete the option named after its value
 654  *  3) if the blob is NULL, delete entire section
 655  */
 656 static void
 657 rpc_uci_merge_delete(struct blob_attr *opt, struct uci_ptr *ptr)
 658 {
 659         struct blob_attr *cur;
 660         int rem;
 661
 662         if (rpc_uci_lookup(ptr) || !ptr->s)
 663                 return;
 664
 665         if (!opt)
 666         {
 667                 ptr->o = NULL;
 668                 ptr->option = NULL;
 669
 670                 uci_delete(cursor, ptr);
 671         }
 672         else if (blobmsg_type(opt) == BLOBMSG_TYPE_ARRAY)
 673         {
 674                 blobmsg_for_each_attr(cur, opt, rem)
 675                 {
 676                         if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
 677                                 continue;
 678
 679                         ptr->o = NULL;
 680                         ptr->option = blobmsg_data(cur);
 681
 682                         if (rpc_uci_lookup(ptr) || !ptr->o)
 683                                 continue;
 684
 685                         uci_delete(cursor, ptr);
 686                 }
 687         }
 688         else if (blobmsg_type(opt) == BLOBMSG_TYPE_STRING)
 689         {
 690                 ptr->o = NULL;
 691                 ptr->option = blobmsg_data(opt);
 692
 693                 if (rpc_uci_lookup(ptr) || !ptr->o)
 694                         return;
 695
 696                 uci_delete(cursor, ptr);
 697         }
 698 }
 699
 700 static int
 701 rpc_uci_delete(struct ubus_context *ctx, struct ubus_object *obj,
 702                struct ubus_request_data *req, const char *method,
 703                struct blob_attr *msg)
 704 {
 705         struct blob_attr *tb[__RPC_D_MAX];
 706         struct uci_package *p = NULL;
 707         struct uci_element *e, *tmp;
 708         struct uci_ptr ptr = { 0 };
 709
 710         blobmsg_parse(rpc_uci_delete_policy, __RPC_D_MAX, tb,
 711                       blob_data(msg), blob_len(msg));
 712
 713         if (!tb[RPC_D_CONFIG] ||
 714                 (!tb[RPC_D_SECTION] && !tb[RPC_D_TYPE] && !tb[RPC_D_MATCH]))
 715                 return UBUS_STATUS_INVALID_ARGUMENT;
 716
 717         ptr.package = blobmsg_data(tb[RPC_D_CONFIG]);
 718         uci_load(cursor, ptr.package, &p);
 719
 720         if (!p)
 721                 goto out;
 722
 723         if (tb[RPC_D_SECTION])
 724         {
 725                 ptr.section = blobmsg_data(tb[RPC_D_SECTION]);
 726
 727                 if (tb[RPC_D_OPTIONS])
 728                         rpc_uci_merge_delete(tb[RPC_D_OPTIONS], &ptr);
 729                 else
 730                         rpc_uci_merge_delete(tb[RPC_D_OPTION], &ptr);
 731         }
 732         else
 733         {
 734                 uci_foreach_element_safe(&p->sections, tmp, e)
 735                 {
 736                         if (!rpc_uci_match_section(uci_to_section(e),
 737                                                    tb[RPC_D_TYPE], tb[RPC_D_MATCH]))
 738                                 continue;
 739
 740                         ptr.s = NULL;
 741                         ptr.section = e->name;
 742
 743                         if (tb[RPC_D_OPTIONS])
 744                                 rpc_uci_merge_delete(tb[RPC_D_OPTIONS], &ptr);
 745                         else
 746                                 rpc_uci_merge_delete(tb[RPC_D_OPTION], &ptr);
 747                 }
 748         }
 749
 750         uci_save(cursor, p);
 751
 752 out:
 753         if (p)
 754                 uci_unload(cursor, p);
 755
 756         return rpc_uci_status();
 757 }
 758
 759 static int
 760 rpc_uci_rename(struct ubus_context *ctx, struct ubus_object *obj,
 761                struct ubus_request_data *req, const char *method,
 762                struct blob_attr *msg)
 763 {
 764         struct blob_attr *tb[__RPC_R_MAX];
 765         struct uci_package *p = NULL;
 766         struct uci_ptr ptr = { 0 };
 767
 768         blobmsg_parse(rpc_uci_rename_policy, __RPC_R_MAX, tb,
 769                       blob_data(msg), blob_len(msg));
 770
 771         if (!tb[RPC_R_CONFIG] || !tb[RPC_R_SECTION] || !tb[RPC_R_NAME])
 772                 return UBUS_STATUS_INVALID_ARGUMENT;
 773
 774         ptr.package = blobmsg_data(tb[RPC_R_CONFIG]);
 775         ptr.section = blobmsg_data(tb[RPC_R_SECTION]);
 776         ptr.value   = blobmsg_data(tb[RPC_R_NAME]);
 777
 778         if (tb[RPC_R_OPTION])
 779                 ptr.option = blobmsg_data(tb[RPC_R_OPTION]);
 780
 781         uci_load(cursor, ptr.package, &p);
 782
 783         if (!p)
 784                 goto out;
 785
 786         if (uci_lookup_ptr(cursor, &ptr, NULL, true))
 787                 goto out;
 788
 789         if ((ptr.option && !ptr.o) || !ptr.s)
 790         {
 791                 cursor->err = UCI_ERR_NOTFOUND;
 792                 goto out;
 793         }
 794
 795         if (uci_rename(cursor, &ptr))
 796                 goto out;
 797
 798         uci_save(cursor, p);
 799
 800 out:
 801         if (p)
 802                 uci_unload(cursor, p);
 803
 804         return rpc_uci_status();
 805 }
 806
 807 static int
 808 rpc_uci_order(struct ubus_context *ctx, struct ubus_object *obj,
 809               struct ubus_request_data *req, const char *method,
 810               struct blob_attr *msg)
 811 {
 812         struct blob_attr *tb[__RPC_O_MAX];
 813         struct blob_attr *cur;
 814         struct uci_package *p = NULL;
 815         struct uci_ptr ptr = { 0 };
 816         int rem, i = 1;
 817
 818         blobmsg_parse(rpc_uci_order_policy, __RPC_O_MAX, tb,
 819                       blob_data(msg), blob_len(msg));
 820
 821         if (!tb[RPC_O_CONFIG] || !tb[RPC_O_SECTIONS])
 822                 return UBUS_STATUS_INVALID_ARGUMENT;
 823
 824         ptr.package = blobmsg_data(tb[RPC_O_CONFIG]);
 825
 826         uci_load(cursor, ptr.package, &p);
 827
 828         if (!p)
 829                 goto out;
 830
 831         blobmsg_for_each_attr(cur, tb[RPC_O_SECTIONS], rem)
 832         {
 833                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
 834                         continue;
 835
 836                 ptr.s = NULL;
 837                 ptr.section = blobmsg_data(cur);
 838
 839                 if (uci_lookup_ptr(cursor, &ptr, NULL, true) || !ptr.s)
 840                         continue;
 841
 842                 uci_reorder_section(cursor, ptr.s, i++);
 843         }
 844
 845         uci_save(cursor, p);
 846
 847 out:
 848         if (p)
 849                 uci_unload(cursor, p);
 850
 851         return rpc_uci_status();
 852 }
 853
 854 static void
 855 rpc_uci_dump_change(struct uci_delta *d)
 856 {
 857         void *c;
 858         const char *types[] = {
 859                 [UCI_CMD_REORDER]  = "order",
 860                 [UCI_CMD_REMOVE]   = "remove",
 861                 [UCI_CMD_RENAME]   = "rename",
 862                 [UCI_CMD_ADD]      = "add",
 863                 [UCI_CMD_LIST_ADD] = "list-add",
 864                 [UCI_CMD_LIST_DEL] = "list-del",
 865                 [UCI_CMD_CHANGE]   = "set",
 866         };
 867
 868         if (!d->section)
 869                 return;
 870
 871         c = blobmsg_open_array(&buf, NULL);
 872
 873         blobmsg_add_string(&buf, NULL, types[d->cmd]);
 874         blobmsg_add_string(&buf, NULL, d->section);
 875
 876         if (d->e.name)
 877                 blobmsg_add_string(&buf, NULL, d->e.name);
 878
 879         if (d->value)
 880         {
 881                 if (d->cmd == UCI_CMD_REORDER)
 882                         blobmsg_add_u32(&buf, NULL, strtoul(d->value, NULL, 10));
 883                 else
 884                         blobmsg_add_string(&buf, NULL, d->value);
 885         }
 886
 887         blobmsg_close_array(&buf, c);
 888 }
 889
 890 static int
 891 rpc_uci_changes(struct ubus_context *ctx, struct ubus_object *obj,
 892                 struct ubus_request_data *req, const char *method,
 893                 struct blob_attr *msg)
 894 {
 895         struct blob_attr *tb[__RPC_C_MAX];
 896         struct uci_package *p = NULL;
 897         struct uci_element *e;
 898         void *c;
 899
 900         blobmsg_parse(rpc_uci_config_policy, __RPC_C_MAX, tb,
 901                       blob_data(msg), blob_len(msg));
 902
 903         if (!tb[RPC_C_CONFIG])
 904                 return UBUS_STATUS_INVALID_ARGUMENT;
 905
 906         uci_load(cursor, blobmsg_data(tb[RPC_C_CONFIG]), &p);
 907
 908         if (!p)
 909                 goto out;
 910
 911         blob_buf_init(&buf, 0);
 912         c = blobmsg_open_array(&buf, "changes");
 913
 914         uci_foreach_element(&p->saved_delta, e)
 915                 rpc_uci_dump_change(uci_to_delta(e));
 916
 917         blobmsg_close_array(&buf, c);
 918
 919         ubus_send_reply(ctx, req, buf.head);
 920
 921 out:
 922         if (p)
 923                 uci_unload(cursor, p);
 924
 925         return rpc_uci_status();
 926 }
 927
 928 static int
 929 rpc_uci_revert_commit(struct blob_attr *msg, bool commit)
 930 {
 931         struct blob_attr *tb[__RPC_C_MAX];
 932         struct uci_package *p = NULL;
 933         struct uci_ptr ptr = { 0 };
 934
 935         blobmsg_parse(rpc_uci_config_policy, __RPC_C_MAX, tb,
 936                       blob_data(msg), blob_len(msg));
 937
 938         if (!tb[RPC_C_CONFIG])
 939                 return UBUS_STATUS_INVALID_ARGUMENT;
 940
 941         ptr.package = blobmsg_data(tb[RPC_C_CONFIG]);
 942         uci_load(cursor, ptr.package, &p);
 943
 944         if (!p || uci_lookup_ptr(cursor, &ptr, NULL, true) || !ptr.p)
 945                 goto out;
 946
 947         if (commit)
 948                 uci_commit(cursor, &p, false);
 949         else
 950                 uci_revert(cursor, &ptr);
 951
 952 out:
 953         if (p)
 954                 uci_unload(cursor, p);
 955
 956         return rpc_uci_status();
 957 }
 958
 959 static int
 960 rpc_uci_revert(struct ubus_context *ctx, struct ubus_object *obj,
 961                struct ubus_request_data *req, const char *method,
 962                struct blob_attr *msg)
 963 {
 964         return rpc_uci_revert_commit(msg, false);
 965 }
 966
 967 static int
 968 rpc_uci_commit(struct ubus_context *ctx, struct ubus_object *obj,
 969                struct ubus_request_data *req, const char *method,
 970                struct blob_attr *msg)
 971 {
 972         return rpc_uci_revert_commit(msg, true);
 973 }
 974
 975 static int
 976 rpc_uci_configs(struct ubus_context *ctx, struct ubus_object *obj,
 977                 struct ubus_request_data *req, const char *method,
 978                 struct blob_attr *msg)
 979 {
 980         char **configs;
 981         void *c;
 982         int i;
 983
 984         if (uci_list_configs(cursor, &configs))
 985                 goto out;
 986
 987         blob_buf_init(&buf, 0);
 988
 989         c = blobmsg_open_array(&buf, "configs");
 990
 991         for (i = 0; configs[i]; i++)
 992                 blobmsg_add_string(&buf, NULL, configs[i]);
 993
 994         blobmsg_close_array(&buf, c);
 995
 996         ubus_send_reply(ctx, req, buf.head);
 997
 998 out:
 999         return rpc_uci_status();
1000 }
1001
1002
1003 int rpc_uci_api_init(struct ubus_context *ctx)
1004 {
1005         static const struct ubus_method uci_methods[] = {
1006                 { .name = "configs", .handler = rpc_uci_configs },
1007                 UBUS_METHOD("get",     rpc_uci_get,     rpc_uci_get_policy),
1008                 UBUS_METHOD("add",     rpc_uci_add,     rpc_uci_add_policy),
1009                 UBUS_METHOD("set",     rpc_uci_set,     rpc_uci_set_policy),
1010                 UBUS_METHOD("delete",  rpc_uci_delete,  rpc_uci_delete_policy),
1011                 UBUS_METHOD("rename",  rpc_uci_rename,  rpc_uci_rename_policy),
1012                 UBUS_METHOD("order",   rpc_uci_order,   rpc_uci_order_policy),
1013                 UBUS_METHOD("changes", rpc_uci_changes, rpc_uci_config_policy),
1014                 UBUS_METHOD("revert",  rpc_uci_revert,  rpc_uci_config_policy),
1015                 UBUS_METHOD("commit",  rpc_uci_commit,  rpc_uci_config_policy),
1016         };
1017
1018         static struct ubus_object_type uci_type =
1019                 UBUS_OBJECT_TYPE("luci-rpc-uci", uci_methods);
1020
1021         static struct ubus_object obj = {
1022                 .name = "uci",
1023                 .type = &uci_type,
1024                 .methods = uci_methods,
1025                 .n_methods = ARRAY_SIZE(uci_methods),
1026         };
1027
1028         cursor = uci_alloc_context();
1029
1030         if (!cursor)
1031                 return UBUS_STATUS_UNKNOWN_ERROR;
1032
1033         return ubus_add_object(ctx, &obj);
1034 }