projects / project / rpcd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
session: expose rpc_session_access() function for testing session ACLs in other rpcd...
[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 }
OpenWrt ubus RPC daemon