projects / project / uci.git / blob
? search:


0d16bb469d672fa8ab0f787524d3b1f9a1f93d12
[project/uci.git] / ucimap.c
1 /*
2 * ucimap - library for mapping uci sections into data structures
3 * Copyright (C) 2008 Felix Fietkau <nbd@openwrt.org>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2
7 * as published by the Free Software Foundation
8 *
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.
13 */
14 #include <strings.h>
15 #include <stdbool.h>
16 #include <string.h>
17 #include <stdlib.h>
18 #include <unistd.h>
19 #include <limits.h>
20 #include <stdio.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include "ucimap.h"
24 #include "uci_internal.h"
25
26 struct uci_alloc {
27 void *ptr;
28 };
29
30 struct uci_alloc_custom {
31 void *section;
32 struct uci_optmap *om;
33 void *ptr;
34 };
35
36 struct uci_fixup {
37 struct list_head list;
38 struct uci_sectionmap *sm;
39 const char *name;
40 enum ucimap_type type;
41 union ucimap_data *data;
42 };
43
44 #define ucimap_foreach_option(_sm, _o) \
45 if (!(_sm)->options_size) \
46 (_sm)->options_size = sizeof(struct uci_optmap); \
47 for (_o = &(_sm)->options[0]; \
48 ((char *)(_o)) < ((char *) &(_sm)->options[0] + \
49 (_sm)->options_size * (_sm)->n_options); \
50 _o = (struct uci_optmap *) ((char *)(_o) + \
51 (_sm)->options_size))
52
53
54 static inline bool
55 ucimap_is_alloc(enum ucimap_type type)
56 {
57 switch(type & UCIMAP_SUBTYPE) {
58 case UCIMAP_STRING:
59 return true;
60 default:
61 return false;
62 }
63 }
64
65 static inline bool
66 ucimap_is_fixup(enum ucimap_type type)
67 {
68 switch(type & UCIMAP_SUBTYPE) {
69 case UCIMAP_SECTION:
70 return true;
71 default:
72 return false;
73 }
74 }
75
76 static inline bool
77 ucimap_is_simple(enum ucimap_type type)
78 {
79 return ((type & UCIMAP_TYPE) == UCIMAP_SIMPLE);
80 }
81
82 static inline bool
83 ucimap_is_list(enum ucimap_type type)
84 {
85 return ((type & UCIMAP_TYPE) == UCIMAP_LIST);
86 }
87
88 static inline bool
89 ucimap_is_list_auto(enum ucimap_type type)
90 {
91 return ucimap_is_list(type) && !!(type & UCIMAP_LIST_AUTO);
92 }
93
94 static inline bool
95 ucimap_is_custom(enum ucimap_type type)
96 {
97 return ((type & UCIMAP_SUBTYPE) == UCIMAP_CUSTOM);
98 }
99
100 static inline void *
101 ucimap_section_ptr(struct ucimap_section_data *sd)
102 {
103 return ((char *) sd - sd->sm->smap_offset);
104 }
105
106 static inline union ucimap_data *
107 ucimap_get_data(struct ucimap_section_data *sd, struct uci_optmap *om)
108 {
109 void *data;
110
111 data = (char *) ucimap_section_ptr(sd) + om->offset;
112 return data;
113 }
114
115 int
116 ucimap_init(struct uci_map *map)
117 {
118 INIT_LIST_HEAD(&map->pending);
119 INIT_LIST_HEAD(&map->sdata);
120 INIT_LIST_HEAD(&map->fixup);
121 return 0;
122 }
123
124 static void
125 ucimap_add_alloc(struct ucimap_section_data *sd, void *ptr)
126 {
127 struct uci_alloc *a = &sd->allocmap[sd->allocmap_len++];
128 a->ptr = ptr;
129 }
130
131 void
132 ucimap_free_section(struct uci_map *map, struct ucimap_section_data *sd)
133 {
134 void *section;
135 int i;
136
137 section = ucimap_section_ptr(sd);
138 if (!list_empty(&sd->list))
139 list_del(&sd->list);
140
141 if (sd->sm->free)
142 sd->sm->free(map, section);
143
144 for (i = 0; i < sd->allocmap_len; i++) {
145 free(sd->allocmap[i].ptr);
146 }
147
148 if (sd->alloc_custom) {
149 for (i = 0; i < sd->alloc_custom_len; i++) {
150 struct uci_alloc_custom *a = &sd->alloc_custom[i];
151 a->om->free(a->section, a->om, a->ptr);
152 }
153 free(sd->alloc_custom);
154 }
155
156 free(sd->allocmap);
157 free(sd);
158 }
159
160 void
161 ucimap_cleanup(struct uci_map *map)
162 {
163 struct list_head *ptr, *tmp;
164
165 list_for_each_safe(ptr, tmp, &map->sdata) {
166 struct ucimap_section_data *sd = list_entry(ptr, struct ucimap_section_data, list);
167 ucimap_free_section(map, sd);
168 }
169 }
170
171 static void *
172 ucimap_find_section(struct uci_map *map, struct uci_fixup *f)
173 {
174 struct ucimap_section_data *sd;
175 struct list_head *p;
176
177 list_for_each(p, &map->sdata) {
178 sd = list_entry(p, struct ucimap_section_data, list);
179 if (sd->sm != f->sm)
180 continue;
181 if (strcmp(f->name, sd->section_name) != 0)
182 continue;
183 return ucimap_section_ptr(sd);
184 }
185 list_for_each(p, &map->pending) {
186 sd = list_entry(p, struct ucimap_section_data, list);
187 if (sd->sm != f->sm)
188 continue;
189 if (strcmp(f->name, sd->section_name) != 0)
190 continue;
191 return ucimap_section_ptr(sd);
192 }
193 return NULL;
194 }
195
196 static bool
197 ucimap_handle_fixup(struct uci_map *map, struct uci_fixup *f)
198 {
199 void *ptr = ucimap_find_section(map, f);
200 struct ucimap_list *list;
201
202 if (!ptr)
203 return false;
204
205 switch(f->type & UCIMAP_TYPE) {
206 case UCIMAP_SIMPLE:
207 f->data->ptr = ptr;
208 break;
209 case UCIMAP_LIST:
210 list = f->data->list;
211 list->item[list->n_items++].ptr = ptr;
212 break;
213 }
214 return true;
215 }
216
217 void
218 ucimap_free_item(struct ucimap_section_data *sd, void *item)
219 {
220 struct uci_alloc_custom *ac;
221 struct uci_alloc *a;
222 void *ptr = *((void **) item);
223 int i;
224
225 if (!ptr)
226 return;
227
228 *((void **)item) = NULL;
229 for (i = 0, a = sd->allocmap; i < sd->allocmap_len; i++, a++) {
230 if (a->ptr != ptr)
231 continue;
232
233 if (i != sd->allocmap_len - 1)
234 a->ptr = sd->allocmap[sd->allocmap_len - 1].ptr;
235
236 sd->allocmap_len--;
237 return;
238 }
239
240 for (i = 0, ac = sd->alloc_custom; i < sd->alloc_custom_len; i++, ac++) {
241 if (ac->ptr != ptr)
242 continue;
243
244 if (i != sd->alloc_custom_len - 1)
245 memcpy(ac, &sd->alloc_custom[sd->alloc_custom_len - 1],
246 sizeof(struct uci_alloc_custom));
247
248 ac->om->free(ac->section, ac->om, ac->ptr);
249 sd->alloc_custom_len--;
250 return;
251 }
252 }
253
254 int
255 ucimap_resize_list(struct ucimap_section_data *sd, struct ucimap_list **list, int items)
256 {
257 struct ucimap_list *new;
258 struct uci_alloc *a;
259 int i, offset = 0;
260 int size = sizeof(struct ucimap_list) + items * sizeof(union ucimap_data);
261
262 if (!*list) {
263 new = calloc(1, size);
264
265 ucimap_add_alloc(sd, new);
266 goto set;
267 }
268
269 for (i = 0, a = sd->allocmap; i < sd->allocmap_len; i++, a++) {
270 if (a->ptr != *list)
271 continue;
272
273 goto realloc;
274 }
275 return -ENOENT;
276
277 realloc:
278 if (items > (*list)->size)
279 offset = (items - (*list)->size) * sizeof(union ucimap_data);
280
281 a->ptr = realloc(a->ptr, size);
282 if (offset)
283 memset((char *) a->ptr + offset, 0, size - offset);
284 new = a->ptr;
285
286 set:
287 new->size = items;
288 *list = new;
289 return 0;
290 }
291
292 static void
293 ucimap_add_fixup(struct ucimap_section_data *sd, union ucimap_data *data, struct uci_optmap *om, const char *str)
294 {
295 struct uci_fixup *f, tmp;
296 struct uci_map *map = sd->map;
297
298 INIT_LIST_HEAD(&tmp.list);
299 tmp.sm = om->data.sm;
300 tmp.name = str;
301 tmp.type = om->type;
302 tmp.data = data;
303 if (ucimap_handle_fixup(map, &tmp))
304 return;
305
306 f = malloc(sizeof(struct uci_fixup));
307 if (!f)
308 return;
309
310 memcpy(f, &tmp, sizeof(tmp));
311 list_add_tail(&f->list, &map->fixup);
312 }
313
314 static void
315 ucimap_add_custom_alloc(struct ucimap_section_data *sd, struct uci_optmap *om, void *ptr)
316 {
317 struct uci_alloc_custom *a = &sd->alloc_custom[sd->alloc_custom_len++];
318
319 a->section = ucimap_section_ptr(sd);
320 a->om = om;
321 a->ptr = ptr;
322 }
323
324 static void
325 ucimap_add_value(union ucimap_data *data, struct uci_optmap *om, struct ucimap_section_data *sd, const char *str)
326 {
327 union ucimap_data tdata = *data;
328 char *eptr = NULL;
329 long lval;
330 char *s;
331 int val;
332
333 if (ucimap_is_list(om->type) && !ucimap_is_fixup(om->type)) {
334 if (unlikely(data->list->size <= data->list->n_items)) {
335 /* should not happen */
336 DPRINTF("ERROR: overflow while filling a list\n");
337 return;
338 }
339
340 data = &data->list->item[data->list->n_items++];
341 }
342
343 switch(om->type & UCIMAP_SUBTYPE) {
344 case UCIMAP_STRING:
345 if ((om->data.s.maxlen > 0) &&
346 (strlen(str) > om->data.s.maxlen))
347 return;
348
349 s = strdup(str);
350 tdata.s = s;
351 ucimap_add_alloc(sd, s);
352 break;
353 case UCIMAP_BOOL:
354 if (!strcmp(str, "on"))
355 val = true;
356 else if (!strcmp(str, "1"))
357 val = true;
358 else if (!strcmp(str, "enabled"))
359 val = true;
360 else if (!strcmp(str, "off"))
361 val = false;
362 else if (!strcmp(str, "0"))
363 val = false;
364 else if (!strcmp(str, "disabled"))
365 val = false;
366 else
367 return;
368
369 tdata.b = val;
370 break;
371 case UCIMAP_INT:
372 lval = strtol(str, &eptr, om->data.i.base);
373 if (lval < INT_MIN || lval > INT_MAX)
374 return;
375
376 if (!eptr || *eptr == '\0')
377 tdata.i = (int) lval;
378 else
379 return;
380 break;
381 case UCIMAP_SECTION:
382 ucimap_add_fixup(sd, data, om, str);
383 return;
384 case UCIMAP_CUSTOM:
385 tdata.s = (char *) data;
386 break;
387 }
388 if (om->parse) {
389 if (om->parse(ucimap_section_ptr(sd), om, &tdata, str) < 0)
390 return;
391 if (ucimap_is_custom(om->type) && om->free) {
392 if (tdata.ptr != data->ptr)
393 ucimap_add_custom_alloc(sd, om, data->ptr);
394 }
395 }
396 if (ucimap_is_custom(om->type))
397 return;
398 memcpy(data, &tdata, sizeof(union ucimap_data));
399 }
400
401
402 static void
403 ucimap_convert_list(union ucimap_data *data, struct uci_optmap *om, struct ucimap_section_data *sd, const char *str)
404 {
405 char *s, *p;
406
407 s = strdup(str);
408 if (!s)
409 return;
410
411 ucimap_add_alloc(sd, s);
412
413 do {
414 while (isspace(*s))
415 s++;
416
417 if (!*s)
418 break;
419
420 p = s;
421 while (*s && !isspace(*s))
422 s++;
423
424 if (isspace(*s)) {
425 *s = 0;
426 s++;
427 }
428
429 ucimap_add_value(data, om, sd, p);
430 } while (*s);
431 }
432
433 static int
434 ucimap_parse_options(struct uci_map *map, struct uci_sectionmap *sm, struct ucimap_section_data *sd, struct uci_section *s)
435 {
436 struct uci_element *e, *l;
437 struct uci_option *o;
438 union ucimap_data *data;
439
440 uci_foreach_element(&s->options, e) {
441 struct uci_optmap *om = NULL, *tmp;
442
443 ucimap_foreach_option(sm, tmp) {
444 if (strcmp(e->name, tmp->name) == 0) {
445 om = tmp;
446 break;
447 }
448 }
449 if (!om)
450 continue;
451
452 data = ucimap_get_data(sd, om);
453 o = uci_to_option(e);
454 if ((o->type == UCI_TYPE_STRING) && ucimap_is_simple(om->type)) {
455 ucimap_add_value(data, om, sd, o->v.string);
456 } else if ((o->type == UCI_TYPE_LIST) && ucimap_is_list(om->type)) {
457 uci_foreach_element(&o->v.list, l) {
458 ucimap_add_value(data, om, sd, l->name);
459 }
460 } else if ((o->type == UCI_TYPE_STRING) && ucimap_is_list_auto(om->type)) {
461 ucimap_convert_list(data, om, sd, o->v.string);
462 }
463 }
464
465 return 0;
466 }
467
468 static void
469 ucimap_add_section(struct ucimap_section_data *sd)
470 {
471 struct uci_map *map = sd->map;
472
473 if (sd->sm->add(map, ucimap_section_ptr(sd)) < 0)
474 ucimap_free_section(map, sd);
475 else
476 list_add_tail(&sd->list, &map->sdata);
477 }
478
479 static const char *ucimap_type_names[] = {
480 [UCIMAP_STRING] = "string",
481 [UCIMAP_INT] = "integer",
482 [UCIMAP_BOOL] = "boolean",
483 [UCIMAP_SECTION] = "section",
484 [UCIMAP_LIST] = "list",
485 };
486
487 static inline const char *
488 ucimap_get_type_name(int type)
489 {
490 static char buf[32];
491 const char *name;
492
493 if (ucimap_is_list(type))
494 return ucimap_type_names[UCIMAP_LIST];
495
496 name = ucimap_type_names[type & UCIMAP_SUBTYPE];
497 if (!name) {
498 sprintf(buf, "Unknown (%d)", type & UCIMAP_SUBTYPE);
499 name = buf;
500 }
501
502 return name;
503 }
504
505 static bool
506 ucimap_check_optmap_type(struct uci_sectionmap *sm, struct uci_optmap *om)
507 {
508 unsigned int type;
509
510 if (unlikely(sm->type_name != om->type_name) &&
511 unlikely(strcmp(sm->type_name, om->type_name) != 0)) {
512 DPRINTF("Option '%s' of section type '%s' refereces unknown "
513 "section type '%s', should be '%s'.\n",
514 om->name, sm->type, om->type_name, sm->type_name);
515 return false;
516 }
517
518 if (om->detected_type < 0)
519 return true;
520
521 if (ucimap_is_custom(om->type))
522 return true;
523
524 if (ucimap_is_list(om->type) !=
525 ucimap_is_list(om->detected_type))
526 goto failed;
527
528 if (ucimap_is_list(om->type))
529 return true;
530
531 type = om->type & UCIMAP_SUBTYPE;
532 switch(type) {
533 case UCIMAP_STRING:
534 case UCIMAP_INT:
535 case UCIMAP_BOOL:
536 if (type != om->detected_type)
537 goto failed;
538 break;
539 case UCIMAP_SECTION:
540 goto failed;
541 default:
542 break;
543 }
544 return true;
545
546 failed:
547 DPRINTF("Invalid type in option '%s' of section type '%s', "
548 "declared type is %s, detected type is %s\n",
549 om->name, sm->type,
550 ucimap_get_type_name(om->type),
551 ucimap_get_type_name(om->detected_type));
552 return false;
553 }
554
555 static void
556 ucimap_count_alloc(struct uci_optmap *om, int *n_alloc, int *n_custom)
557 {
558 if (ucimap_is_alloc(om->type))
559 (*n_alloc)++;
560 else if (ucimap_is_custom(om->type) && om->free)
561 (*n_custom)++;
562 }
563
564 int
565 ucimap_parse_section(struct uci_map *map, struct uci_sectionmap *sm, struct ucimap_section_data *sd, struct uci_section *s)
566 {
567 struct uci_optmap *om;
568 char *section_name;
569 void *section;
570 int n_alloc = 2;
571 int n_alloc_custom = 0;
572 int err;
573
574 INIT_LIST_HEAD(&sd->list);
575 sd->map = map;
576 sd->sm = sm;
577
578 ucimap_foreach_option(sm, om) {
579 if (!ucimap_check_optmap_type(sm, om))
580 continue;
581
582 if (ucimap_is_list(om->type)) {
583 union ucimap_data *data;
584 struct uci_element *e;
585 int n_elements = 0;
586 int n_elements_custom = 0;
587 int size;
588
589 data = ucimap_get_data(sd, om);
590 uci_foreach_element(&s->options, e) {
591 struct uci_option *o = uci_to_option(e);
592 struct uci_element *tmp;
593
594 if (strcmp(e->name, om->name) != 0)
595 continue;
596
597 if (o->type == UCI_TYPE_LIST) {
598 uci_foreach_element(&o->v.list, tmp) {
599 ucimap_count_alloc(om, &n_elements, &n_elements_custom);
600 }
601 } else if ((o->type == UCI_TYPE_STRING) &&
602 ucimap_is_list_auto(om->type)) {
603 const char *data = o->v.string;
604 do {
605 while (isspace(*data))
606 data++;
607
608 if (!*data)
609 break;
610
611 n_elements++;
612 ucimap_count_alloc(om, &n_elements, &n_elements_custom);
613
614 while (*data && !isspace(*data))
615 data++;
616 } while (*data);
617
618 /* for the duplicated data string */
619 if (n_elements)
620 n_alloc++;
621 }
622 break;
623 }
624 /* add one more for the ucimap_list */
625 n_alloc += n_elements + 1;
626 n_alloc_custom += n_elements_custom;
627 size = sizeof(struct ucimap_list) +
628 n_elements * sizeof(union ucimap_data);
629
630 data->list = malloc(size);
631 if (!data->list)
632 goto error_mem;
633
634 data->list->size = n_elements;
635 memset(data->list, 0, size);
636 } else {
637 ucimap_count_alloc(om, &n_alloc, &n_alloc_custom);
638 }
639 }
640
641 sd->allocmap = calloc(n_alloc, sizeof(struct uci_alloc));
642 if (!sd->allocmap)
643 goto error_mem;
644
645 if (n_alloc_custom > 0) {
646 sd->alloc_custom = calloc(n_alloc_custom, sizeof(struct uci_alloc_custom));
647 if (!sd->alloc_custom)
648 goto error_mem;
649 }
650
651 section_name = strdup(s->e.name);
652 if (!section_name)
653 goto error_mem;
654
655 sd->section_name = section_name;
656
657 sd->cmap = calloc(1, BITFIELD_SIZE(sm->n_options));
658 if (!sd->cmap)
659 goto error_mem;
660
661 ucimap_add_alloc(sd, (void *)section_name);
662 ucimap_add_alloc(sd, (void *)sd->cmap);
663 ucimap_foreach_option(sm, om) {
664 if (!ucimap_is_list(om->type))
665 continue;
666
667 ucimap_add_alloc(sd, ucimap_get_data(sd, om)->list);
668 }
669
670 section = ucimap_section_ptr(sd);
671 err = sm->init(map, section, s);
672 if (err)
673 goto error;
674
675 if (map->parsed) {
676 ucimap_add_section(sd);
677 } else {
678 list_add_tail(&sd->list, &map->pending);
679 }
680
681 err = ucimap_parse_options(map, sm, sd, s);
682 if (err)
683 goto error;
684
685 return 0;
686
687 error_mem:
688 if (sd->allocmap)
689 free(sd->allocmap);
690 free(sd);
691 return UCI_ERR_MEM;
692
693 error:
694 ucimap_free_section(map, sd);
695 return err;
696 }
697
698 static int
699 ucimap_fill_ptr(struct uci_ptr *ptr, struct uci_section *s, const char *option)
700 {
701 struct uci_package *p = s->package;
702
703 memset(ptr, 0, sizeof(struct uci_ptr));
704
705 ptr->package = p->e.name;
706 ptr->p = p;
707
708 ptr->section = s->e.name;
709 ptr->s = s;
710
711 ptr->option = option;
712 return uci_lookup_ptr(p->ctx, ptr, NULL, false);
713 }
714
715 void
716 ucimap_set_changed(struct ucimap_section_data *sd, void *field)
717 {
718 void *section = ucimap_section_ptr(sd);
719 struct uci_sectionmap *sm = sd->sm;
720 struct uci_optmap *om;
721 int ofs = (char *)field - (char *)section;
722 int i = 0;
723
724 ucimap_foreach_option(sm, om) {
725 if (om->offset == ofs) {
726 SET_BIT(sd->cmap, i);
727 break;
728 }
729 i++;
730 }
731 }
732
733 int
734 ucimap_store_section(struct uci_map *map, struct uci_package *p, struct ucimap_section_data *sd)
735 {
736 struct uci_sectionmap *sm = sd->sm;
737 struct uci_section *s = NULL;
738 struct uci_optmap *om;
739 struct uci_element *e;
740 struct uci_ptr ptr;
741 int i = 0;
742 int ret;
743
744 uci_foreach_element(&p->sections, e) {
745 if (!strcmp(e->name, sd->section_name)) {
746 s = uci_to_section(e);
747 break;
748 }
749 }
750 if (!s)
751 return UCI_ERR_NOTFOUND;
752
753 ucimap_foreach_option(sm, om) {
754 union ucimap_data *data;
755 static char buf[32];
756 char *str = NULL;
757
758 i++;
759 if (ucimap_is_list(om->type))
760 continue;
761
762 data = ucimap_get_data(sd, om);
763 if (!TEST_BIT(sd->cmap, i - 1))
764 continue;
765
766 ucimap_fill_ptr(&ptr, s, om->name);
767 switch(om->type & UCIMAP_SUBTYPE) {
768 case UCIMAP_STRING:
769 str = data->s;
770 break;
771 case UCIMAP_INT:
772 sprintf(buf, "%d", data->i);
773 str = buf;
774 break;
775 case UCIMAP_BOOL:
776 sprintf(buf, "%d", !!data->b);
777 str = buf;
778 break;
779 case UCIMAP_CUSTOM:
780 break;
781 default:
782 continue;
783 }
784 if (om->format) {
785 union ucimap_data tdata, *data;
786
787 data = ucimap_get_data(sd, om);
788 if (ucimap_is_custom(om->type)) {
789 tdata.s = (char *)data;
790 data = &tdata;
791 }
792
793 if (om->format(ucimap_section_ptr(sd), om, data, &str) < 0)
794 continue;
795
796 if (!str)
797 str = "";
798 }
799 if (!str)
800 continue;
801 ptr.value = str;
802
803 ret = uci_set(s->package->ctx, &ptr);
804 if (ret)
805 return ret;
806
807 CLR_BIT(sd->cmap, i - 1);
808 }
809
810 return 0;
811 }
812
813 void
814 ucimap_parse(struct uci_map *map, struct uci_package *pkg)
815 {
816 struct uci_element *e;
817 struct list_head *p, *tmp;
818 int i;
819
820 INIT_LIST_HEAD(&map->fixup);
821 uci_foreach_element(&pkg->sections, e) {
822 struct uci_section *s = uci_to_section(e);
823
824 for (i = 0; i < map->n_sections; i++) {
825 struct uci_sectionmap *sm = map->sections[i];
826 struct ucimap_section_data *sd;
827
828 if (strcmp(s->type, map->sections[i]->type) != 0)
829 continue;
830
831 if (sm->alloc) {
832 sd = sm->alloc(map, sm, s);
833 memset(sd, 0, sizeof(struct ucimap_section_data));
834 } else {
835 sd = malloc(sm->alloc_len);
836 memset(sd, 0, sm->alloc_len);
837 }
838 if (!sd)
839 continue;
840
841 ucimap_parse_section(map, sm, sd, s);
842 }
843 }
844 map->parsed = true;
845
846 list_for_each_safe(p, tmp, &map->fixup) {
847 struct uci_fixup *f = list_entry(p, struct uci_fixup, list);
848 ucimap_handle_fixup(map, f);
849 list_del(&f->list);
850 free(f);
851 }
852
853 list_for_each_safe(p, tmp, &map->pending) {
854 struct ucimap_section_data *sd;
855 sd = list_entry(p, struct ucimap_section_data, list);
856
857 list_del_init(&sd->list);
858 ucimap_add_section(sd);
859 }
860 }
OpenWrt Unified Configuration Interface