2 * libuci - Library for the Unified Configuration Interface
3 * Copyright (C) 2008 Felix Fietkau <nbd@openwrt.org>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU Lesser General Public License version 2.1
7 * as published by the Free Software Foundation
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
15 /* initialize a list head/item */
16 static inline void uci_list_init(struct uci_list *ptr)
22 /* inserts a new list entry after a given entry */
23 static inline void uci_list_insert(struct uci_list *list, struct uci_list *ptr)
25 list->next->prev = ptr;
27 ptr->next = list->next;
31 /* inserts a new list entry at the tail of the list */
32 static inline void uci_list_add(struct uci_list *head, struct uci_list *ptr)
34 /* NB: head->prev points at the tail */
35 uci_list_insert(head->prev, ptr);
38 static inline void uci_list_del(struct uci_list *ptr)
40 struct uci_list *next, *prev;
52 * uci_alloc_generic allocates a new uci_element with payload
53 * payload is appended to the struct to save memory and reduce fragmentation
55 static struct uci_element *
56 uci_alloc_generic(struct uci_context *ctx, int type, const char *name, int size)
58 struct uci_element *e;
62 ptr = uci_malloc(ctx, datalen);
63 e = (struct uci_element *) ptr;
66 UCI_TRAP_SAVE(ctx, error);
67 e->name = uci_strdup(ctx, name);
68 UCI_TRAP_RESTORE(ctx);
70 uci_list_init(&e->list);
75 UCI_THROW(ctx, ctx->err);
82 uci_free_element(struct uci_element *e)
86 if (!uci_list_empty(&e->list))
87 uci_list_del(&e->list);
91 static struct uci_option *
92 uci_alloc_option(struct uci_section *s, const char *name, const char *value)
94 struct uci_package *p = s->package;
95 struct uci_context *ctx = p->ctx;
98 o = uci_alloc_element(ctx, option, name, strlen(value) + 1);
99 o->type = UCI_TYPE_STRING;
100 o->v.string = uci_dataptr(o);
102 strcpy(o->v.string, value);
103 uci_list_add(&s->options, &o->e.list);
109 uci_free_option(struct uci_option *o)
111 struct uci_element *e, *tmp;
114 case UCI_TYPE_STRING:
115 if ((o->v.string != uci_dataptr(o)) &&
116 (o->v.string != NULL))
120 uci_foreach_element_safe(&o->v.list, tmp, e) {
127 uci_free_element(&o->e);
130 static struct uci_option *
131 uci_alloc_list(struct uci_section *s, const char *name)
133 struct uci_package *p = s->package;
134 struct uci_context *ctx = p->ctx;
135 struct uci_option *o;
137 o = uci_alloc_element(ctx, option, name, 0);
138 o->type = UCI_TYPE_LIST;
140 uci_list_init(&o->v.list);
141 uci_list_add(&s->options, &o->e.list);
146 /* fix up an unnamed section, e.g. after adding options to it */
147 static void uci_fixup_section(struct uci_context *ctx, struct uci_section *s)
149 unsigned int hash = ~0;
150 struct uci_element *e;
157 * Generate a name for unnamed sections. This is used as reference
158 * when locating or updating the section from apps/scripts.
159 * To make multiple concurrent versions somewhat safe for updating,
160 * the name is generated from a hash of its type and name/value
161 * pairs of its option, and it is prefixed by a counter value.
162 * If the order of the unnamed sections changes for some reason,
163 * updates to them will be rejected.
165 hash = djbhash(hash, s->type);
166 uci_foreach_element(&s->options, e) {
167 struct uci_option *o;
168 hash = djbhash(hash, e->name);
169 o = uci_to_option(e);
171 case UCI_TYPE_STRING:
172 hash = djbhash(hash, o->v.string);
178 sprintf(buf, "cfg%02x%04x", ++s->package->n_section, hash % (1 << 16));
179 s->e.name = uci_strdup(ctx, buf);
182 static struct uci_section *
183 uci_alloc_section(struct uci_package *p, const char *type, const char *name)
185 struct uci_context *ctx = p->ctx;
186 struct uci_section *s;
188 if (name && !name[0])
191 s = uci_alloc_element(ctx, section, name, strlen(type) + 1);
192 uci_list_init(&s->options);
193 s->type = uci_dataptr(s);
195 strcpy(s->type, type);
200 uci_list_add(&p->sections, &s->e.list);
206 uci_free_section(struct uci_section *s)
208 struct uci_element *o, *tmp;
210 uci_foreach_element_safe(&s->options, tmp, o) {
211 uci_free_option(uci_to_option(o));
213 if ((s->type != uci_dataptr(s)) &&
216 uci_free_element(&s->e);
219 __plugin struct uci_package *
220 uci_alloc_package(struct uci_context *ctx, const char *name)
222 struct uci_package *p;
224 p = uci_alloc_element(ctx, package, name, 0);
226 uci_list_init(&p->sections);
227 uci_list_init(&p->history);
228 uci_list_init(&p->saved_history);
233 uci_free_package(struct uci_package **package)
235 struct uci_element *e, *tmp;
236 struct uci_package *p = *package;
243 uci_foreach_element_safe(&p->sections, tmp, e) {
244 uci_free_section(uci_to_section(e));
246 uci_foreach_element_safe(&p->history, tmp, e) {
247 uci_free_history(uci_to_history(e));
249 uci_foreach_element_safe(&p->saved_history, tmp, e) {
250 uci_free_history(uci_to_history(e));
252 uci_free_element(&p->e);
257 uci_free_any(struct uci_element **e)
260 case UCI_TYPE_SECTION:
261 uci_free_section(uci_to_section(*e));
263 case UCI_TYPE_OPTION:
264 uci_free_option(uci_to_option(*e));
272 static inline struct uci_element *
273 uci_lookup_list(struct uci_list *list, const char *name)
275 struct uci_element *e;
277 uci_foreach_element(list, e) {
278 if (!strcmp(e->name, name))
284 static struct uci_element *
285 uci_lookup_ext_section(struct uci_context *ctx, struct uci_ptr *ptr)
287 char *idxstr, *t, *section, *name;
288 struct uci_element *e = NULL;
289 struct uci_section *s;
292 section = uci_strdup(ctx, ptr->section);
293 name = idxstr = section + 1;
295 if (section[0] != '@')
298 /* parse the section index part */
299 idxstr = strchr(idxstr, '[');
305 t = strchr(idxstr, ']');
313 idx = strtol(idxstr, &t, 10);
319 else if (!uci_validate_str(name, false))
322 /* if the given index is negative, it specifies the section number from
323 * the end of the list */
326 uci_foreach_element(&ptr->p->sections, e) {
327 s = uci_to_section(e);
328 if (name && (strcmp(s->type, name) != 0))
337 uci_foreach_element(&ptr->p->sections, e) {
338 s = uci_to_section(e);
339 if (name && (strcmp(s->type, name) != 0))
351 memset(ptr, 0, sizeof(struct uci_ptr));
352 UCI_THROW(ctx, UCI_ERR_INVAL);
355 ptr->section = e->name;
360 uci_lookup_ptr(struct uci_context *ctx, struct uci_ptr *ptr, char *str, bool extended)
362 struct uci_element *e;
365 UCI_ASSERT(ctx, ptr != NULL);
368 UCI_INTERNAL(uci_parse_ptr, ctx, ptr, str);
370 ptr->flags |= UCI_LOOKUP_DONE;
372 /* look up the package first */
373 e = uci_lookup_list(&ctx->root, ptr->package);
375 UCI_INTERNAL(uci_load, ctx, ptr->package, &ptr->p);
378 ptr->last = &ptr->p->e;
380 ptr->p = uci_to_package(e);
387 /* if the section name validates as a regular name, pass through
388 * to the regular uci_lookup function call */
389 if (ptr->flags & UCI_LOOKUP_EXTENDED)
390 e = uci_lookup_ext_section(ctx, ptr);
392 e = uci_lookup_list(&ptr->p->sections, ptr->section);
398 ptr->s = uci_to_section(e);
401 e = uci_lookup_list(&ptr->s->options, ptr->option);
405 ptr->o = uci_to_option(e);
410 ptr->flags |= UCI_LOOKUP_COMPLETE;
415 UCI_THROW(ctx, UCI_ERR_NOTFOUND);
420 uci_fill_ptr(struct uci_context *ctx, struct uci_ptr *ptr, struct uci_element *e, bool complete)
423 UCI_ASSERT(ctx, ptr != NULL);
424 UCI_ASSERT(ctx, e != NULL);
426 memset(ptr, 0, sizeof(struct uci_ptr));
428 case UCI_TYPE_OPTION:
429 ptr->o = uci_to_option(e);
431 case UCI_TYPE_SECTION:
432 ptr->s = uci_to_section(e);
434 case UCI_TYPE_PACKAGE:
435 ptr->p = uci_to_package(e);
438 UCI_THROW(ctx, UCI_ERR_INVAL);
442 ptr->option = ptr->o->e.name;
443 ptr->s = ptr->o->section;
445 ptr->section = ptr->s->e.name;
446 ptr->p = ptr->s->package;
448 ptr->package = ptr->p->e.name;
450 ptr->flags |= UCI_LOOKUP_DONE;
452 ptr->flags |= UCI_LOOKUP_COMPLETE;
457 static struct uci_element *
458 expand_ptr(struct uci_context *ctx, struct uci_ptr *ptr, bool complete)
460 UCI_ASSERT(ctx, ptr != NULL);
462 if (!(ptr->flags & UCI_LOOKUP_DONE))
463 uci_lookup_ptr(ctx, ptr, NULL, 1);
464 if (complete && !(ptr->flags & UCI_LOOKUP_COMPLETE))
465 UCI_THROW(ctx, UCI_ERR_NOTFOUND);
466 UCI_ASSERT(ctx, ptr->p != NULL);
468 /* fill in missing string info */
469 if (ptr->p && !ptr->package)
470 ptr->package = ptr->p->e.name;
471 if (ptr->s && !ptr->section)
472 ptr->section = ptr->s->e.name;
473 if (ptr->o && !ptr->option)
474 ptr->option = ptr->o->e.name;
486 static void uci_add_element_list(struct uci_context *ctx, struct uci_ptr *ptr, bool internal)
488 struct uci_element *e;
489 struct uci_package *p;
492 if (!internal && p->has_history)
493 uci_add_history(ctx, &p->history, UCI_CMD_LIST_ADD, ptr->section, ptr->option, ptr->value);
495 e = uci_alloc_generic(ctx, UCI_TYPE_ITEM, ptr->value, sizeof(struct uci_option));
496 uci_list_add(&ptr->o->v.list, &e->list);
499 int uci_set_element_value(struct uci_context *ctx, struct uci_element **element, const char *value)
501 /* NB: UCI_INTERNAL use means without history tracking */
502 bool internal = ctx->internal;
503 struct uci_list *list;
504 struct uci_element *e;
505 struct uci_package *p;
506 struct uci_section *s;
507 struct uci_option *o;
514 UCI_ASSERT(ctx, (element != NULL) && (*element != NULL));
516 /* what the 'value' of an element means depends on the type
517 * for a section, the 'value' means its type
518 * for an option, the 'value' means its value string
519 * when changing the value, shrink the element to its actual size
520 * (it may have been allocated with a bigger size, to include
522 * then duplicate the string passed on the command line and
523 * insert it into the structure.
529 case UCI_TYPE_SECTION:
530 UCI_ASSERT(ctx, uci_validate_str(value, false));
531 size = sizeof(struct uci_section);
532 s = uci_to_section(e);
535 /* matches the currently set value */
536 if (!strcmp(value, s->type))
540 case UCI_TYPE_OPTION:
541 UCI_ASSERT(ctx, value != NULL);
542 o = uci_to_option(e);
547 case UCI_TYPE_STRING:
548 size = sizeof(struct uci_option);
549 /* matches the currently set value */
550 if (!strcmp(value, o->v.string))
554 /* default action for non-string datatypes is to delete
555 * the existing entry, then re-create it as a string */
561 UCI_THROW(ctx, UCI_ERR_INVAL);
565 if (!internal && p->has_history)
566 uci_add_history(ctx, &p->history, UCI_CMD_CHANGE, section, option, value);
568 if ((e->type == UCI_TYPE_OPTION) && (size == 0)) {
569 o = uci_alloc_option(s, option, value);
575 uci_list_del(&e->list);
576 e = uci_realloc(ctx, e, size);
577 str = uci_strdup(ctx, value);
578 uci_list_insert(list, &e->list);
582 case UCI_TYPE_SECTION:
583 uci_to_section(e)->type = str;
585 case UCI_TYPE_OPTION:
586 uci_to_option(e)->v.string = str;
596 int uci_rename(struct uci_context *ctx, struct uci_ptr *ptr)
598 /* NB: UCI_INTERNAL use means without history tracking */
599 bool internal = ctx->internal;
600 struct uci_element *e;
601 struct uci_package *p;
606 e = expand_ptr(ctx, ptr, true);
609 UCI_ASSERT(ctx, ptr->s);
610 UCI_ASSERT(ctx, ptr->value);
612 if (!internal && p->has_history)
613 uci_add_history(ctx, &p->history, UCI_CMD_RENAME, ptr->section, ptr->option, ptr->value);
615 n = uci_strdup(ctx, ptr->value);
623 int uci_add_section(struct uci_context *ctx, struct uci_package *p, const char *type, struct uci_section **res)
625 bool internal = ctx->internal;
626 struct uci_section *s;
629 UCI_ASSERT(ctx, p != NULL);
630 s = uci_alloc_section(p, type, NULL);
631 uci_fixup_section(ctx, s);
633 if (!internal && p->has_history)
634 uci_add_history(ctx, &p->history, UCI_CMD_ADD, s->e.name, NULL, type);
639 int uci_delete(struct uci_context *ctx, struct uci_ptr *ptr)
641 /* NB: pass on internal flag to uci_del_element */
642 bool internal = ctx->internal;
643 struct uci_package *p;
644 struct uci_element *e;
648 e = expand_ptr(ctx, ptr, true);
651 UCI_ASSERT(ctx, ptr->s);
653 if (!internal && p->has_history)
654 uci_add_history(ctx, &p->history, UCI_CMD_REMOVE, ptr->section, ptr->option, NULL);
660 int uci_add_list(struct uci_context *ctx, struct uci_ptr *ptr)
662 /* NB: UCI_INTERNAL use means without history tracking */
663 bool internal = ctx->internal;
664 struct uci_option *prev = NULL;
665 const char *value2 = NULL;
669 expand_ptr(ctx, ptr, false);
670 UCI_ASSERT(ctx, ptr->s);
671 UCI_ASSERT(ctx, ptr->value);
674 switch (ptr->o->type) {
675 case UCI_TYPE_STRING:
676 /* we already have a string value, convert that to a list */
679 ptr->value = ptr->o->v.string;
682 uci_add_element_list(ctx, ptr, internal);
685 UCI_THROW(ctx, UCI_ERR_INVAL);
690 ptr->o = uci_alloc_list(ptr->s, ptr->option);
692 uci_add_element_list(ctx, ptr, true);
693 uci_free_option(prev);
696 uci_add_element_list(ctx, ptr, internal);
701 int uci_set(struct uci_context *ctx, struct uci_package *p, const char *section, const char *option, const char *value, struct uci_element **result)
703 /* NB: UCI_INTERNAL use means without history tracking */
704 bool internal = ctx->internal;
705 struct uci_element *e = NULL;
706 struct uci_section *s = NULL;
707 struct uci_option *o = NULL;
710 UCI_ASSERT(ctx, p != NULL);
711 UCI_ASSERT(ctx, uci_validate_name(section));
713 UCI_ASSERT(ctx, uci_validate_name(option));
714 UCI_ASSERT(ctx, value != NULL);
716 UCI_ASSERT(ctx, uci_validate_str(value, false));
720 * look up the package, section and option (if set)
721 * if the section/option is to be modified and it is not found
722 * create a new element in the appropriate list
724 e = uci_lookup_list(&p->sections, section);
728 s = uci_to_section(e);
729 if (ctx->pctx && ctx->pctx->merge)
730 ctx->pctx->section = s;
733 e = uci_lookup_list(&s->options, option);
736 o = uci_to_option(e);
740 * no unknown element was supplied, assume that we can just update
752 ctx->internal = internal;
753 return uci_set_element_value(ctx, result, value);
757 * the entry that we need to update was not found,
758 * check if the search failed prematurely.
759 * this can happen if the package was not found, or if
760 * an option was supplied, but the section wasn't found
762 if (!p || (!s && option))
763 UCI_THROW(ctx, UCI_ERR_NOTFOUND);
765 /* now add the missing entry */
766 if (!internal && p->has_history)
767 uci_add_history(ctx, &p->history, UCI_CMD_CHANGE, section, option, value);
769 o = uci_alloc_option(s, option, value);
773 s = uci_alloc_section(p, value, section);
776 if (ctx->pctx && ctx->pctx->merge)
777 ctx->pctx->section = s;
783 int uci_unload(struct uci_context *ctx, struct uci_package *p)
786 UCI_ASSERT(ctx, p != NULL);
788 uci_free_package(&p);