ucimap: allow sectmaps to specify the option map data structure size (useful for...
[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 <string.h>
16 #include <stdlib.h>
17 #include <unistd.h>
18 #include "ucimap.h"
19
20 struct uci_alloc {
21 enum ucimap_type type;
22 union {
23 void **ptr;
24 struct list_head *list;
25 } data;
26 };
27
28 struct uci_fixup {
29 struct list_head list;
30 struct uci_sectmap *sm;
31 const char *name;
32 struct uci_alloc target;
33 };
34
35 struct uci_sectmap_data {
36 struct list_head list;
37 struct uci_map *map;
38 struct uci_sectmap *sm;
39 const char *section_name;
40
41 /* list of allocations done by ucimap */
42 struct uci_alloc *allocmap;
43 unsigned long allocmap_len;
44
45 /* map for changed fields */
46 unsigned char *cmap;
47 bool done;
48 };
49
50
51 int
52 ucimap_init(struct uci_map *map)
53 {
54 INIT_LIST_HEAD(&map->sdata);
55 INIT_LIST_HEAD(&map->fixup);
56 return 0;
57 }
58
59 static void
60 ucimap_free_item(struct uci_alloc *a)
61 {
62 struct list_head *p, *tmp;
63 switch(a->type & UCIMAP_TYPE) {
64 case UCIMAP_SIMPLE:
65 free(a->data.ptr);
66 break;
67 case UCIMAP_LIST:
68 list_for_each_safe(p, tmp, a->data.list) {
69 struct uci_listmap *l = list_entry(p, struct uci_listmap, list);
70 list_del(p);
71 free(l);
72 }
73 break;
74 }
75 }
76
77 static inline void
78 ucimap_add_alloc(struct uci_alloc *a, void *ptr)
79 {
80 a->type = UCIMAP_SIMPLE;
81 a->data.ptr = ptr;
82 }
83
84 static void
85 ucimap_free_section(struct uci_map *map, struct uci_sectmap_data *sd)
86 {
87 void *section = sd;
88 int i;
89
90 section = (char *) section + sizeof(struct uci_sectmap_data);
91 if (!list_empty(&sd->list))
92 list_del(&sd->list);
93
94 if (sd->sm->free_section)
95 sd->sm->free_section(map, section);
96
97 for (i = 0; i < sd->allocmap_len; i++) {
98 ucimap_free_item(&sd->allocmap[i]);
99 }
100
101 free(sd->allocmap);
102 free(sd);
103 }
104
105 void
106 ucimap_cleanup(struct uci_map *map)
107 {
108 struct list_head *ptr, *tmp;
109
110 list_for_each_safe(ptr, tmp, &map->sdata) {
111 struct uci_sectmap_data *sd = list_entry(ptr, struct uci_sectmap_data, list);
112 ucimap_free_section(map, sd);
113 }
114 }
115
116 static void
117 ucimap_add_fixup(struct uci_map *map, void *data, struct uci_optmap *om, const char *str)
118 {
119 struct uci_fixup *f;
120
121 f = malloc(sizeof(struct uci_fixup));
122 if (!f)
123 return;
124
125 INIT_LIST_HEAD(&f->list);
126 f->sm = om->data.sm;
127 f->name = str;
128 f->target.type = om->type;
129 f->target.data.ptr = data;
130 list_add(&f->list, &map->fixup);
131 }
132
133 static void
134 ucimap_add_value(union uci_datamap *data, struct uci_optmap *om, struct uci_sectmap_data *sd, const char *str)
135 {
136 union uci_datamap tdata;
137 struct list_head *list = NULL;
138 char *eptr = NULL;
139 char *s;
140 int val;
141
142 if ((om->type & UCIMAP_TYPE) == UCIMAP_LIST) {
143 if ((om->type & UCIMAP_SUBTYPE) == UCIMAP_SECTION) {
144 ucimap_add_fixup(sd->map, data, om, str);
145 return;
146 }
147 memset(&tdata, 0, sizeof(tdata));
148 list = &data->list;
149 data = &tdata;
150 }
151
152 switch(om->type & UCIMAP_SUBTYPE) {
153 case UCIMAP_STRING:
154 if ((om->data.s.maxlen > 0) &&
155 (strlen(str) > om->data.s.maxlen))
156 return;
157
158 s = strdup(str);
159 data->s = s;
160 ucimap_add_alloc(&sd->allocmap[sd->allocmap_len++], s);
161 break;
162 case UCIMAP_BOOL:
163 val = -1;
164 if (strcmp(str, "on"))
165 val = true;
166 else if (strcmp(str, "1"))
167 val = true;
168 else if (strcmp(str, "enabled"))
169 val = true;
170 else if (strcmp(str, "off"))
171 val = false;
172 else if (strcmp(str, "0"))
173 val = false;
174 else if (strcmp(str, "disabled"))
175 val = false;
176 if (val == -1)
177 return;
178
179 data->b = val;
180 break;
181 case UCIMAP_INT:
182 val = strtol(str, &eptr, om->data.i.base);
183 if (!eptr || *eptr == '\0')
184 data->i = val;
185 else
186 return;
187 break;
188 case UCIMAP_SECTION:
189 ucimap_add_fixup(sd->map, data, om, str);
190 break;
191 }
192
193 if ((om->type & UCIMAP_TYPE) == UCIMAP_LIST) {
194 struct uci_listmap *item;
195
196 item = malloc(sizeof(struct uci_listmap));
197 if (!item)
198 return;
199
200 INIT_LIST_HEAD(&item->list);
201 memcpy(&item->data, &tdata, sizeof(tdata));
202 list_add(&item->list, list);
203 }
204 }
205
206
207 static int
208 ucimap_parse_options(struct uci_map *map, struct uci_sectmap *sm, struct uci_sectmap_data *sd, struct uci_section *s)
209 {
210 struct uci_element *e, *l;
211 struct uci_option *o;
212 unsigned long section;
213 union uci_datamap *data;
214 int i;
215
216 section = (unsigned long) sd + sizeof(struct uci_sectmap_data);
217 uci_foreach_element(&s->options, e) {
218 struct uci_optmap *om = NULL;
219 void *ptr = sm->options;
220 int size = sm->options_size;
221
222 if (!size)
223 size = sizeof(struct uci_optmap);
224
225 for (i = 0; i < sm->n_options; i++) {
226 struct uci_optmap *tmp = ptr;
227
228 if (strcmp(e->name, tmp->name) == 0) {
229 om = ptr;
230 break;
231 }
232 ptr = (unsigned char *)ptr + size;
233 }
234 if (!om)
235 continue;
236
237 data = (union uci_datamap *) (section + om->offset);
238 o = uci_to_option(e);
239 if ((o->type == UCI_TYPE_STRING) && ((om->type & UCIMAP_TYPE) == UCIMAP_SIMPLE)) {
240 ucimap_add_value(data, om, sd, o->v.string);
241 continue;
242 }
243 if ((o->type == UCI_TYPE_LIST) && ((om->type & UCIMAP_TYPE) == UCIMAP_LIST)) {
244 struct list_head *list;
245
246 list = (struct list_head *) (section + om->offset);
247 INIT_LIST_HEAD(list);
248 sd->allocmap[sd->allocmap_len].type = UCIMAP_LIST;
249 sd->allocmap[sd->allocmap_len++].data.list = list;
250 uci_foreach_element(&o->v.list, l) {
251 ucimap_add_value(data, om, sd, l->name);
252 }
253 continue;
254 }
255 }
256
257 return 0;
258 }
259
260
261 static int
262 ucimap_parse_section(struct uci_map *map, struct uci_sectmap *sm, struct uci_section *s)
263 {
264 struct uci_sectmap_data *sd = NULL;
265 void *section = NULL;
266 char *section_name;
267 int err;
268
269 sd = malloc(sm->alloc_len + sizeof(struct uci_sectmap_data));
270 if (!sd)
271 return UCI_ERR_MEM;
272
273 memset(sd, 0, sm->alloc_len + sizeof(struct uci_sectmap_data));
274 INIT_LIST_HEAD(&sd->list);
275
276 sd->map = map;
277 sd->sm = sm;
278 sd->allocmap = malloc(sm->n_options * sizeof(struct uci_alloc));
279 if (!sd->allocmap)
280 goto error_mem;
281
282 section_name = strdup(s->e.name);
283 if (!section_name)
284 goto error_mem;
285
286 sd->section_name = section_name;
287
288 sd->cmap = malloc(BITFIELD_SIZE(sm->n_options));
289 if (!sd->cmap)
290 goto error_mem;
291
292 memset(sd->cmap, 0, BITFIELD_SIZE(sm->n_options));
293 ucimap_add_alloc(&sd->allocmap[sd->allocmap_len++], (void *)section_name);
294 ucimap_add_alloc(&sd->allocmap[sd->allocmap_len++], (void *)sd->cmap);
295
296 section = (char *)sd + sizeof(struct uci_sectmap_data);
297
298 err = sm->init_section(map, section, s);
299 if (err)
300 goto error;
301
302 list_add(&sd->list, &map->sdata);
303 err = ucimap_parse_options(map, sm, sd, s);
304 if (err)
305 goto error;
306
307 return 0;
308
309 error_mem:
310 if (sd->allocmap)
311 free(sd->allocmap);
312 free(sd);
313 return UCI_ERR_MEM;
314
315 error:
316 ucimap_free_section(map, sd);
317 return err;
318 }
319
320 static int
321 ucimap_fill_ptr(struct uci_ptr *ptr, struct uci_section *s, const char *option)
322 {
323 struct uci_package *p = s->package;
324
325 memset(ptr, 0, sizeof(struct uci_ptr));
326
327 ptr->package = p->e.name;
328 ptr->p = p;
329
330 ptr->section = s->e.name;
331 ptr->s = s;
332
333 ptr->option = option;
334 return uci_lookup_ptr(p->ctx, ptr, NULL, false);
335 }
336
337 void
338 ucimap_set_changed(void *section, void *field)
339 {
340 char *sptr = (char *)section - sizeof(struct uci_sectmap_data);
341 struct uci_sectmap_data *sd = (struct uci_sectmap_data *) sptr;
342 struct uci_sectmap *sm = sd->sm;
343 int ofs = (char *)field - (char *)section;
344 int i;
345
346 for (i = 0; i < sm->n_options; i++) {
347 if (sm->options[i].offset == ofs) {
348 SET_BIT(sd->cmap, i);
349 break;
350 }
351 }
352 }
353
354 int
355 ucimap_store_section(struct uci_map *map, struct uci_package *p, void *section)
356 {
357 char *sptr = (char *)section - sizeof(struct uci_sectmap_data);
358 struct uci_sectmap_data *sd = (struct uci_sectmap_data *) sptr;
359 struct uci_sectmap *sm = sd->sm;
360 struct uci_section *s = NULL;
361 struct uci_element *e;
362 struct uci_ptr ptr;
363 int i, ret;
364
365 uci_foreach_element(&p->sections, e) {
366 if (!strcmp(e->name, sd->section_name)) {
367 s = uci_to_section(e);
368 break;
369 }
370 }
371 if (!s)
372 return UCI_ERR_NOTFOUND;
373
374 for (i = 0; i < sm->n_options; i++) {
375 struct uci_optmap *om = &sm->options[i];
376 static char buf[32];
377 const char *str = NULL;
378 void *p = (char *)section + om->offset;
379
380 if (!TEST_BIT(sd->cmap, i))
381 continue;
382
383 ucimap_fill_ptr(&ptr, s, om->name);
384 switch(om->type & UCIMAP_SUBTYPE) {
385 case UCIMAP_STRING:
386 str = *((char **) p);
387 break;
388 case UCIMAP_INT:
389 sprintf(buf, "%d", *((int *) p));
390 str = buf;
391 break;
392 case UCIMAP_BOOL:
393 sprintf(buf, "%d", !!*((bool *)p));
394 str = buf;
395 break;
396 }
397 ptr.value = str;
398
399 ret = uci_set(s->package->ctx, &ptr);
400 if (ret)
401 return ret;
402
403 CLR_BIT(sd->cmap, i);
404 }
405
406 return 0;
407 }
408
409 void *
410 ucimap_find_section(struct uci_map *map, struct uci_fixup *f)
411 {
412 struct uci_sectmap_data *sd;
413 struct list_head *p;
414 void *ret;
415
416 list_for_each(p, &map->sdata) {
417 sd = list_entry(p, struct uci_sectmap_data, list);
418 if (sd->sm != f->sm)
419 continue;
420 if (strcmp(f->name, sd->section_name) != 0)
421 continue;
422 ret = (char *)sd + sizeof(struct uci_sectmap_data);
423 return ret;
424 }
425 return NULL;
426 }
427
428 void
429 ucimap_parse(struct uci_map *map, struct uci_package *pkg)
430 {
431 struct uci_element *e;
432 struct list_head *p, *tmp;
433 int i;
434
435 INIT_LIST_HEAD(&map->fixup);
436 uci_foreach_element(&pkg->sections, e) {
437 struct uci_section *s = uci_to_section(e);
438
439 for (i = 0; i < map->n_sections; i++) {
440 if (strcmp(s->type, map->sections[i]->type) != 0)
441 continue;
442 ucimap_parse_section(map, map->sections[i], s);
443 }
444 }
445 list_for_each_safe(p, tmp, &map->fixup) {
446 struct uci_fixup *f = list_entry(p, struct uci_fixup, list);
447 void *ptr = ucimap_find_section(map, f);
448 struct uci_listmap *li;
449
450 if (!ptr)
451 continue;
452
453 switch(f->target.type & UCIMAP_TYPE) {
454 case UCIMAP_SIMPLE:
455 *f->target.data.ptr = ptr;
456 break;
457 case UCIMAP_LIST:
458 li = malloc(sizeof(struct uci_listmap));
459 memset(li, 0, sizeof(struct uci_listmap));
460 INIT_LIST_HEAD(&li->list);
461 li->data.section = ptr;
462 list_add(&li->list, f->target.data.list);
463 break;
464 }
465 }
466 list_for_each_safe(p, tmp, &map->sdata) {
467 struct uci_sectmap_data *sd = list_entry(p, struct uci_sectmap_data, list);
468 void *section;
469
470 if (sd->done)
471 continue;
472
473 section = (char *) sd + sizeof(struct uci_sectmap_data);
474 if (sd->sm->add_section(map, section) != 0)
475 ucimap_free_section(map, sd);
476 }
477 }