luci2: add upgrade_test, upgrade_start and upgrade_abort calls
[project/rpcd.git] / 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, int index)
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         if (index >= 0)
368                 blobmsg_add_u32(&buf, ".index", index);
369
370         uci_foreach_element(&s->options, e)
371         {
372                 o = uci_to_option(e);
373                 rpc_uci_dump_option(o, o->e.name);
374         }
375
376         blobmsg_close_table(&buf, c);
377 }
378
379 /*
380  * Dump the given uci_package object into the global blobmsg buffer and use
381  * given "name" as key.
382  * Puts a table into the blob buffer and puts each package section member as
383  * value into the table using the section name as key.
384  * Only dumps sections matching the given "type" and "matches", see explaination
385  * of rpc_uci_match_section() for details.
386  */
387 static void
388 rpc_uci_dump_package(struct uci_package *p, const char *name,
389                      struct blob_attr *type, struct blob_attr *matches)
390 {
391         void *c;
392         struct uci_element *e;
393         int i = -1;
394
395         c = blobmsg_open_table(&buf, name);
396
397         uci_foreach_element(&p->sections, e)
398         {
399                 i++;
400
401                 if (!rpc_uci_match_section(uci_to_section(e), type, matches))
402                         continue;
403
404                 rpc_uci_dump_section(uci_to_section(e), e->name, i);
405         }
406
407         blobmsg_close_table(&buf, c);
408 }
409
410
411 static int
412 rpc_uci_get(struct ubus_context *ctx, struct ubus_object *obj,
413             struct ubus_request_data *req, const char *method,
414             struct blob_attr *msg)
415 {
416         struct blob_attr *tb[__RPC_G_MAX];
417         struct uci_package *p = NULL;
418         struct uci_ptr ptr = { 0 };
419
420         blobmsg_parse(rpc_uci_get_policy, __RPC_G_MAX, tb,
421                       blob_data(msg), blob_len(msg));
422
423         if (!tb[RPC_G_CONFIG])
424                 return UBUS_STATUS_INVALID_ARGUMENT;
425
426         ptr.package = blobmsg_data(tb[RPC_G_CONFIG]);
427         uci_load(cursor, ptr.package, &p);
428
429         if (!p)
430                 goto out;
431
432         if (tb[RPC_G_SECTION])
433         {
434                 ptr.section = blobmsg_data(tb[RPC_G_SECTION]);
435
436                 if (tb[RPC_G_OPTION])
437                         ptr.option = blobmsg_data(tb[RPC_G_OPTION]);
438         }
439
440         if (rpc_uci_lookup(&ptr) || !(ptr.flags & UCI_LOOKUP_COMPLETE))
441                 goto out;
442
443         blob_buf_init(&buf, 0);
444
445         switch (ptr.last->type)
446         {
447         case UCI_TYPE_PACKAGE:
448                 rpc_uci_dump_package(ptr.p, "values", tb[RPC_G_TYPE], tb[RPC_G_MATCH]);
449                 break;
450
451         case UCI_TYPE_SECTION:
452                 rpc_uci_dump_section(ptr.s, "values", -1);
453                 break;
454
455         case UCI_TYPE_OPTION:
456                 rpc_uci_dump_option(ptr.o, "value");
457                 break;
458
459         default:
460                 break;
461         }
462
463         ubus_send_reply(ctx, req, buf.head);
464
465 out:
466         if (p)
467                 uci_unload(cursor, p);
468
469         return rpc_uci_status();
470 }
471
472 static int
473 rpc_uci_add(struct ubus_context *ctx, struct ubus_object *obj,
474             struct ubus_request_data *req, const char *method,
475             struct blob_attr *msg)
476 {
477         struct blob_attr *tb[__RPC_A_MAX];
478         struct blob_attr *cur, *elem;
479         struct uci_package *p = NULL;
480         struct uci_section *s;
481         struct uci_ptr ptr = { 0 };
482         int rem, rem2;
483
484         blobmsg_parse(rpc_uci_add_policy, __RPC_A_MAX, tb,
485                       blob_data(msg), blob_len(msg));
486
487         if (!tb[RPC_A_CONFIG] || !tb[RPC_A_TYPE])
488                 return UBUS_STATUS_INVALID_ARGUMENT;
489
490         ptr.package = blobmsg_data(tb[RPC_A_CONFIG]);
491
492         uci_load(cursor, ptr.package, &p);
493
494         if (!p)
495                 goto out;
496
497         /* add named section */
498         if (tb[RPC_A_NAME])
499         {
500                 ptr.section = blobmsg_data(tb[RPC_A_NAME]);
501                 ptr.value   = blobmsg_data(tb[RPC_A_TYPE]);
502                 ptr.option  = NULL;
503
504                 if (rpc_uci_lookup(&ptr) || uci_set(cursor, &ptr))
505                         goto out;
506         }
507
508         /* add anon section */
509         else
510         {
511                 if (uci_add_section(cursor, p, blobmsg_data(tb[RPC_A_TYPE]), &s) || !s)
512                         goto out;
513
514                 ptr.section = s->e.name;
515         }
516
517         if (tb[RPC_A_VALUES])
518         {
519                 blobmsg_for_each_attr(cur, tb[RPC_A_VALUES], rem)
520                 {
521                         ptr.o = NULL;
522                         ptr.option = blobmsg_name(cur);
523
524                         if (rpc_uci_lookup(&ptr) || !ptr.s)
525                                 continue;
526
527                         switch (blobmsg_type(cur))
528                         {
529                         case BLOBMSG_TYPE_ARRAY:
530                                 blobmsg_for_each_attr(elem, cur, rem2)
531                                         if (rpc_uci_format_blob(elem, &ptr.value))
532                                                 uci_add_list(cursor, &ptr);
533                                 break;
534
535                         default:
536                                 if (rpc_uci_format_blob(cur, &ptr.value))
537                                         uci_set(cursor, &ptr);
538                                 break;
539                         }
540                 }
541         }
542
543         uci_save(cursor, p);
544
545         blob_buf_init(&buf, 0);
546         blobmsg_add_string(&buf, "section", ptr.section);
547         ubus_send_reply(ctx, req, buf.head);
548
549 out:
550         if (p)
551                 uci_unload(cursor, p);
552
553         return rpc_uci_status();
554 }
555
556 /*
557  * Turn value from a blob attribute into uci set operation
558  *  1) if the blob is of type array, delete existing option (if any) and
559  *     emit uci add_list operations for each element
560  *  2) if the blob is not an array but an option of type list exists,
561  *     delete existing list and emit uci set operation for the blob value
562  *  3) in all other cases only emit a set operation if there is no existing
563  *     option of if the existing options value differs from the blob value
564  */
565 static void
566 rpc_uci_merge_set(struct blob_attr *opt, struct uci_ptr *ptr)
567 {
568         struct blob_attr *cur;
569         int rem;
570
571         ptr->o = NULL;
572         ptr->option = blobmsg_name(opt);
573
574         if (rpc_uci_lookup(ptr) || !ptr->s)
575                 return;
576
577         if (blobmsg_type(opt) == BLOBMSG_TYPE_ARRAY)
578         {
579                 if (ptr->o)
580                         uci_delete(cursor, ptr);
581
582                 blobmsg_for_each_attr(cur, opt, rem)
583                         if (rpc_uci_format_blob(cur, &ptr->value))
584                                 uci_add_list(cursor, ptr);
585         }
586         else if (ptr->o && ptr->o->type == UCI_TYPE_LIST)
587         {
588                 uci_delete(cursor, ptr);
589
590                 if (rpc_uci_format_blob(opt, &ptr->value))
591                         uci_set(cursor, ptr);
592         }
593         else if (rpc_uci_format_blob(opt, &ptr->value))
594         {
595                 if (!ptr->o || !ptr->o->v.string || strcmp(ptr->o->v.string, ptr->value))
596                         uci_set(cursor, ptr);
597         }
598 }
599
600 static int
601 rpc_uci_set(struct ubus_context *ctx, struct ubus_object *obj,
602             struct ubus_request_data *req, const char *method,
603             struct blob_attr *msg)
604 {
605         struct blob_attr *tb[__RPC_S_MAX];
606         struct blob_attr *cur;
607         struct uci_package *p = NULL;
608         struct uci_element *e;
609         struct uci_ptr ptr = { 0 };
610         int rem;
611
612         blobmsg_parse(rpc_uci_set_policy, __RPC_S_MAX, tb,
613                       blob_data(msg), blob_len(msg));
614
615         if (!tb[RPC_S_CONFIG] || !tb[RPC_S_VALUES] ||
616                 (!tb[RPC_S_SECTION] && !tb[RPC_S_TYPE] && !tb[RPC_S_MATCH]))
617                 return UBUS_STATUS_INVALID_ARGUMENT;
618
619         ptr.package = blobmsg_data(tb[RPC_S_CONFIG]);
620         uci_load(cursor, ptr.package, &p);
621
622         if (!p)
623                 goto out;
624
625         if (tb[RPC_S_SECTION])
626         {
627                 ptr.section = blobmsg_data(tb[RPC_S_SECTION]);
628                 blobmsg_for_each_attr(cur, tb[RPC_S_VALUES], rem)
629                         rpc_uci_merge_set(cur, &ptr);
630         }
631         else
632         {
633                 uci_foreach_element(&p->sections, e)
634                 {
635                         if (!rpc_uci_match_section(uci_to_section(e),
636                                                    tb[RPC_S_TYPE], tb[RPC_S_MATCH]))
637                                 continue;
638
639                         ptr.s = NULL;
640                         ptr.section = e->name;
641
642                         blobmsg_for_each_attr(cur, tb[RPC_S_VALUES], rem)
643                                 rpc_uci_merge_set(cur, &ptr);
644                 }
645         }
646
647         uci_save(cursor, p);
648
649 out:
650         if (p)
651                 uci_unload(cursor, p);
652
653         return rpc_uci_status();
654 }
655
656 /*
657  * Delete option or section from uci specified by given blob attribute pointer
658  *  1) if the blob is of type array, delete any option named after each element
659  *  2) if the blob is of type string, delete the option named after its value
660  *  3) if the blob is NULL, delete entire section
661  */
662 static void
663 rpc_uci_merge_delete(struct blob_attr *opt, struct uci_ptr *ptr)
664 {
665         struct blob_attr *cur;
666         int rem;
667
668         if (rpc_uci_lookup(ptr) || !ptr->s)
669                 return;
670
671         if (!opt)
672         {
673                 ptr->o = NULL;
674                 ptr->option = NULL;
675
676                 uci_delete(cursor, ptr);
677         }
678         else if (blobmsg_type(opt) == BLOBMSG_TYPE_ARRAY)
679         {
680                 blobmsg_for_each_attr(cur, opt, rem)
681                 {
682                         if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
683                                 continue;
684
685                         ptr->o = NULL;
686                         ptr->option = blobmsg_data(cur);
687
688                         if (rpc_uci_lookup(ptr) || !ptr->o)
689                                 continue;
690
691                         uci_delete(cursor, ptr);
692                 }
693         }
694         else if (blobmsg_type(opt) == BLOBMSG_TYPE_STRING)
695         {
696                 ptr->o = NULL;
697                 ptr->option = blobmsg_data(opt);
698
699                 if (rpc_uci_lookup(ptr) || !ptr->o)
700                         return;
701
702                 uci_delete(cursor, ptr);
703         }
704 }
705
706 static int
707 rpc_uci_delete(struct ubus_context *ctx, struct ubus_object *obj,
708                struct ubus_request_data *req, const char *method,
709                struct blob_attr *msg)
710 {
711         struct blob_attr *tb[__RPC_D_MAX];
712         struct uci_package *p = NULL;
713         struct uci_element *e, *tmp;
714         struct uci_ptr ptr = { 0 };
715
716         blobmsg_parse(rpc_uci_delete_policy, __RPC_D_MAX, tb,
717                       blob_data(msg), blob_len(msg));
718
719         if (!tb[RPC_D_CONFIG] ||
720                 (!tb[RPC_D_SECTION] && !tb[RPC_D_TYPE] && !tb[RPC_D_MATCH]))
721                 return UBUS_STATUS_INVALID_ARGUMENT;
722
723         ptr.package = blobmsg_data(tb[RPC_D_CONFIG]);
724         uci_load(cursor, ptr.package, &p);
725
726         if (!p)
727                 goto out;
728
729         if (tb[RPC_D_SECTION])
730         {
731                 ptr.section = blobmsg_data(tb[RPC_D_SECTION]);
732
733                 if (tb[RPC_D_OPTIONS])
734                         rpc_uci_merge_delete(tb[RPC_D_OPTIONS], &ptr);
735                 else
736                         rpc_uci_merge_delete(tb[RPC_D_OPTION], &ptr);
737         }
738         else
739         {
740                 uci_foreach_element_safe(&p->sections, tmp, e)
741                 {
742                         if (!rpc_uci_match_section(uci_to_section(e),
743                                                    tb[RPC_D_TYPE], tb[RPC_D_MATCH]))
744                                 continue;
745
746                         ptr.s = NULL;
747                         ptr.section = e->name;
748
749                         if (tb[RPC_D_OPTIONS])
750                                 rpc_uci_merge_delete(tb[RPC_D_OPTIONS], &ptr);
751                         else
752                                 rpc_uci_merge_delete(tb[RPC_D_OPTION], &ptr);
753                 }
754         }
755
756         uci_save(cursor, p);
757
758 out:
759         if (p)
760                 uci_unload(cursor, p);
761
762         return rpc_uci_status();
763 }
764
765 static int
766 rpc_uci_rename(struct ubus_context *ctx, struct ubus_object *obj,
767                struct ubus_request_data *req, const char *method,
768                struct blob_attr *msg)
769 {
770         struct blob_attr *tb[__RPC_R_MAX];
771         struct uci_package *p = NULL;
772         struct uci_ptr ptr = { 0 };
773
774         blobmsg_parse(rpc_uci_rename_policy, __RPC_R_MAX, tb,
775                       blob_data(msg), blob_len(msg));
776
777         if (!tb[RPC_R_CONFIG] || !tb[RPC_R_SECTION] || !tb[RPC_R_NAME])
778                 return UBUS_STATUS_INVALID_ARGUMENT;
779
780         ptr.package = blobmsg_data(tb[RPC_R_CONFIG]);
781         ptr.section = blobmsg_data(tb[RPC_R_SECTION]);
782         ptr.value   = blobmsg_data(tb[RPC_R_NAME]);
783
784         if (tb[RPC_R_OPTION])
785                 ptr.option = blobmsg_data(tb[RPC_R_OPTION]);
786
787         uci_load(cursor, ptr.package, &p);
788
789         if (!p)
790                 goto out;
791
792         if (uci_lookup_ptr(cursor, &ptr, NULL, true))
793                 goto out;
794
795         if ((ptr.option && !ptr.o) || !ptr.s)
796         {
797                 cursor->err = UCI_ERR_NOTFOUND;
798                 goto out;
799         }
800
801         if (uci_rename(cursor, &ptr))
802                 goto out;
803
804         uci_save(cursor, p);
805
806 out:
807         if (p)
808                 uci_unload(cursor, p);
809
810         return rpc_uci_status();
811 }
812
813 static int
814 rpc_uci_order(struct ubus_context *ctx, struct ubus_object *obj,
815               struct ubus_request_data *req, const char *method,
816               struct blob_attr *msg)
817 {
818         struct blob_attr *tb[__RPC_O_MAX];
819         struct blob_attr *cur;
820         struct uci_package *p = NULL;
821         struct uci_ptr ptr = { 0 };
822         int rem, i = 1;
823
824         blobmsg_parse(rpc_uci_order_policy, __RPC_O_MAX, tb,
825                       blob_data(msg), blob_len(msg));
826
827         if (!tb[RPC_O_CONFIG] || !tb[RPC_O_SECTIONS])
828                 return UBUS_STATUS_INVALID_ARGUMENT;
829
830         ptr.package = blobmsg_data(tb[RPC_O_CONFIG]);
831
832         uci_load(cursor, ptr.package, &p);
833
834         if (!p)
835                 goto out;
836
837         blobmsg_for_each_attr(cur, tb[RPC_O_SECTIONS], rem)
838         {
839                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
840                         continue;
841
842                 ptr.s = NULL;
843                 ptr.section = blobmsg_data(cur);
844
845                 if (uci_lookup_ptr(cursor, &ptr, NULL, true) || !ptr.s)
846                         continue;
847
848                 uci_reorder_section(cursor, ptr.s, i++);
849         }
850
851         uci_save(cursor, p);
852
853 out:
854         if (p)
855                 uci_unload(cursor, p);
856
857         return rpc_uci_status();
858 }
859
860 static void
861 rpc_uci_dump_change(struct uci_delta *d)
862 {
863         void *c;
864         const char *types[] = {
865                 [UCI_CMD_REORDER]  = "order",
866                 [UCI_CMD_REMOVE]   = "remove",
867                 [UCI_CMD_RENAME]   = "rename",
868                 [UCI_CMD_ADD]      = "add",
869                 [UCI_CMD_LIST_ADD] = "list-add",
870                 [UCI_CMD_LIST_DEL] = "list-del",
871                 [UCI_CMD_CHANGE]   = "set",
872         };
873
874         if (!d->section)
875                 return;
876
877         c = blobmsg_open_array(&buf, NULL);
878
879         blobmsg_add_string(&buf, NULL, types[d->cmd]);
880         blobmsg_add_string(&buf, NULL, d->section);
881
882         if (d->e.name)
883                 blobmsg_add_string(&buf, NULL, d->e.name);
884
885         if (d->value)
886         {
887                 if (d->cmd == UCI_CMD_REORDER)
888                         blobmsg_add_u32(&buf, NULL, strtoul(d->value, NULL, 10));
889                 else
890                         blobmsg_add_string(&buf, NULL, d->value);
891         }
892
893         blobmsg_close_array(&buf, c);
894 }
895
896 static int
897 rpc_uci_changes(struct ubus_context *ctx, struct ubus_object *obj,
898                 struct ubus_request_data *req, const char *method,
899                 struct blob_attr *msg)
900 {
901         struct blob_attr *tb[__RPC_C_MAX];
902         struct uci_package *p = NULL;
903         struct uci_element *e;
904         void *c;
905
906         blobmsg_parse(rpc_uci_config_policy, __RPC_C_MAX, tb,
907                       blob_data(msg), blob_len(msg));
908
909         if (!tb[RPC_C_CONFIG])
910                 return UBUS_STATUS_INVALID_ARGUMENT;
911
912         uci_load(cursor, blobmsg_data(tb[RPC_C_CONFIG]), &p);
913
914         if (!p)
915                 goto out;
916
917         blob_buf_init(&buf, 0);
918         c = blobmsg_open_array(&buf, "changes");
919
920         uci_foreach_element(&p->saved_delta, e)
921                 rpc_uci_dump_change(uci_to_delta(e));
922
923         blobmsg_close_array(&buf, c);
924
925         ubus_send_reply(ctx, req, buf.head);
926
927 out:
928         if (p)
929                 uci_unload(cursor, p);
930
931         return rpc_uci_status();
932 }
933
934 static int
935 rpc_uci_revert_commit(struct blob_attr *msg, bool commit)
936 {
937         struct blob_attr *tb[__RPC_C_MAX];
938         struct uci_package *p = NULL;
939         struct uci_ptr ptr = { 0 };
940
941         blobmsg_parse(rpc_uci_config_policy, __RPC_C_MAX, tb,
942                       blob_data(msg), blob_len(msg));
943
944         if (!tb[RPC_C_CONFIG])
945                 return UBUS_STATUS_INVALID_ARGUMENT;
946
947         ptr.package = blobmsg_data(tb[RPC_C_CONFIG]);
948         uci_load(cursor, ptr.package, &p);
949
950         if (!p || uci_lookup_ptr(cursor, &ptr, NULL, true) || !ptr.p)
951                 goto out;
952
953         if (commit)
954                 uci_commit(cursor, &p, false);
955         else
956                 uci_revert(cursor, &ptr);
957
958 out:
959         if (p)
960                 uci_unload(cursor, p);
961
962         return rpc_uci_status();
963 }
964
965 static int
966 rpc_uci_revert(struct ubus_context *ctx, struct ubus_object *obj,
967                struct ubus_request_data *req, const char *method,
968                struct blob_attr *msg)
969 {
970         return rpc_uci_revert_commit(msg, false);
971 }
972
973 static int
974 rpc_uci_commit(struct ubus_context *ctx, struct ubus_object *obj,
975                struct ubus_request_data *req, const char *method,
976                struct blob_attr *msg)
977 {
978         return rpc_uci_revert_commit(msg, true);
979 }
980
981 static int
982 rpc_uci_configs(struct ubus_context *ctx, struct ubus_object *obj,
983                 struct ubus_request_data *req, const char *method,
984                 struct blob_attr *msg)
985 {
986         char **configs;
987         void *c;
988         int i;
989
990         if (uci_list_configs(cursor, &configs))
991                 goto out;
992
993         blob_buf_init(&buf, 0);
994
995         c = blobmsg_open_array(&buf, "configs");
996
997         for (i = 0; configs[i]; i++)
998                 blobmsg_add_string(&buf, NULL, configs[i]);
999
1000         blobmsg_close_array(&buf, c);
1001
1002         ubus_send_reply(ctx, req, buf.head);
1003
1004 out:
1005         return rpc_uci_status();
1006 }
1007
1008
1009 int rpc_uci_api_init(struct ubus_context *ctx)
1010 {
1011         static const struct ubus_method uci_methods[] = {
1012                 { .name = "configs", .handler = rpc_uci_configs },
1013                 UBUS_METHOD("get",     rpc_uci_get,     rpc_uci_get_policy),
1014                 UBUS_METHOD("add",     rpc_uci_add,     rpc_uci_add_policy),
1015                 UBUS_METHOD("set",     rpc_uci_set,     rpc_uci_set_policy),
1016                 UBUS_METHOD("delete",  rpc_uci_delete,  rpc_uci_delete_policy),
1017                 UBUS_METHOD("rename",  rpc_uci_rename,  rpc_uci_rename_policy),
1018                 UBUS_METHOD("order",   rpc_uci_order,   rpc_uci_order_policy),
1019                 UBUS_METHOD("changes", rpc_uci_changes, rpc_uci_config_policy),
1020                 UBUS_METHOD("revert",  rpc_uci_revert,  rpc_uci_config_policy),
1021                 UBUS_METHOD("commit",  rpc_uci_commit,  rpc_uci_config_policy),
1022         };
1023
1024         static struct ubus_object_type uci_type =
1025                 UBUS_OBJECT_TYPE("luci-rpc-uci", uci_methods);
1026
1027         static struct ubus_object obj = {
1028                 .name = "uci",
1029                 .type = &uci_type,
1030                 .methods = uci_methods,
1031                 .n_methods = ARRAY_SIZE(uci_methods),
1032         };
1033
1034         cursor = uci_alloc_context();
1035
1036         if (!cursor)
1037                 return UBUS_STATUS_UNKNOWN_ERROR;
1038
1039         return ubus_add_object(ctx, &obj);
1040 }