/*
- * ucimap - library for mapping uci sections into data structures
- * Copyright (C) 2008 Felix Fietkau <nbd@openwrt.org>
+ * ucimap.c - Library for the Unified Configuration Interface
+ * Copyright (C) 2008-2009 Felix Fietkau <nbd@openwrt.org>
*
* This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2
+ * it under the terms of the GNU Lesser General Public License version 2.1
* as published by the Free Software Foundation
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * GNU Lesser General Public License for more details.
*/
+
+/*
+ * This file contains ucimap, an API for mapping UCI to C data structures
+ */
+
#include <strings.h>
#include <stdbool.h>
#include <string.h>
#include "ucimap.h"
#include "uci_internal.h"
-struct uci_alloc {
+struct ucimap_alloc {
void *ptr;
};
-struct uci_alloc_custom {
+struct ucimap_alloc_custom {
void *section;
struct uci_optmap *om;
void *ptr;
};
-struct uci_fixup {
- struct list_head list;
+struct ucimap_fixup {
+ struct ucimap_fixup *next;
struct uci_sectionmap *sm;
const char *name;
enum ucimap_type type;
static inline bool
ucimap_is_alloc(enum ucimap_type type)
{
- switch(type & UCIMAP_SUBTYPE) {
- case UCIMAP_STRING:
- return true;
- default:
- return false;
- }
+ return (type & UCIMAP_SUBTYPE) == UCIMAP_STRING;
}
static inline bool
ucimap_is_fixup(enum ucimap_type type)
{
- switch(type & UCIMAP_SUBTYPE) {
- case UCIMAP_SECTION:
- return true;
- default:
- return false;
- }
+ return (type & UCIMAP_SUBTYPE) == UCIMAP_SECTION;
}
static inline bool
int
ucimap_init(struct uci_map *map)
{
- INIT_LIST_HEAD(&map->pending);
- INIT_LIST_HEAD(&map->sdata);
- INIT_LIST_HEAD(&map->fixup);
+ map->fixup = NULL;
+ map->sdata = NULL;
+ map->fixup_tail = &map->fixup;
+ map->sdata_tail = &map->sdata;
return 0;
}
static void
ucimap_add_alloc(struct ucimap_section_data *sd, void *ptr)
{
- struct uci_alloc *a = &sd->allocmap[sd->allocmap_len++];
+ struct ucimap_alloc *a = &sd->allocmap[sd->allocmap_len++];
a->ptr = ptr;
}
int i;
section = ucimap_section_ptr(sd);
- if (!list_empty(&sd->list))
- list_del(&sd->list);
+ if (sd->ref)
+ *sd->ref = sd->next;
if (sd->sm->free)
sd->sm->free(map, section);
if (sd->alloc_custom) {
for (i = 0; i < sd->alloc_custom_len; i++) {
- struct uci_alloc_custom *a = &sd->alloc_custom[i];
+ struct ucimap_alloc_custom *a = &sd->alloc_custom[i];
a->om->free(a->section, a->om, a->ptr);
}
free(sd->alloc_custom);
void
ucimap_cleanup(struct uci_map *map)
{
- struct list_head *ptr, *tmp;
+ struct ucimap_section_data *sd, *sd_next;
- list_for_each_safe(ptr, tmp, &map->sdata) {
- struct ucimap_section_data *sd = list_entry(ptr, struct ucimap_section_data, list);
+ for (sd = map->sdata; sd; sd = sd_next) {
+ sd_next = sd->next;
ucimap_free_section(map, sd);
}
}
static void *
-ucimap_find_section(struct uci_map *map, struct uci_fixup *f)
+ucimap_find_section(struct uci_map *map, struct ucimap_fixup *f)
{
struct ucimap_section_data *sd;
- struct list_head *p;
- list_for_each(p, &map->sdata) {
- sd = list_entry(p, struct ucimap_section_data, list);
+ for (sd = map->sdata; sd; sd = sd->next) {
if (sd->sm != f->sm)
continue;
if (strcmp(f->name, sd->section_name) != 0)
continue;
return ucimap_section_ptr(sd);
}
- list_for_each(p, &map->pending) {
- sd = list_entry(p, struct ucimap_section_data, list);
+ for (sd = map->pending; sd; sd = sd->next) {
if (sd->sm != f->sm)
continue;
if (strcmp(f->name, sd->section_name) != 0)
return NULL;
}
+static union ucimap_data *
+ucimap_list_append(struct ucimap_list *list)
+{
+ if (unlikely(list->size <= list->n_items)) {
+ /* should not happen */
+ DPRINTF("ERROR: overflow while filling a list (size=%d)\n", list->size);
+ return NULL;
+ }
+ return &list->item[list->n_items++];
+}
+
+
static bool
-ucimap_handle_fixup(struct uci_map *map, struct uci_fixup *f)
+ucimap_handle_fixup(struct uci_map *map, struct ucimap_fixup *f)
{
void *ptr = ucimap_find_section(map, f);
- struct ucimap_list *list;
+ union ucimap_data *data;
if (!ptr)
return false;
f->data->ptr = ptr;
break;
case UCIMAP_LIST:
- list = f->data->list;
- list->item[list->n_items++].ptr = ptr;
+ data = ucimap_list_append(f->data->list);
+ if (!data)
+ return false;
+
+ data->ptr = ptr;
break;
}
return true;
void
ucimap_free_item(struct ucimap_section_data *sd, void *item)
{
- struct uci_alloc_custom *ac;
- struct uci_alloc *a;
+ struct ucimap_alloc_custom *ac;
+ struct ucimap_alloc *a;
void *ptr = *((void **) item);
int i;
if (i != sd->alloc_custom_len - 1)
memcpy(ac, &sd->alloc_custom[sd->alloc_custom_len - 1],
- sizeof(struct uci_alloc_custom));
+ sizeof(struct ucimap_alloc_custom));
ac->om->free(ac->section, ac->om, ac->ptr);
sd->alloc_custom_len--;
ucimap_resize_list(struct ucimap_section_data *sd, struct ucimap_list **list, int items)
{
struct ucimap_list *new;
- struct uci_alloc *a;
+ struct ucimap_alloc *a;
int i, offset = 0;
int size = sizeof(struct ucimap_list) + items * sizeof(union ucimap_data);
if (!*list) {
new = calloc(1, size);
+ if (!new)
+ return -ENOMEM;
ucimap_add_alloc(sd, new);
goto set;
offset = (items - (*list)->size) * sizeof(union ucimap_data);
a->ptr = realloc(a->ptr, size);
+ if (!a->ptr)
+ return -ENOMEM;
+
if (offset)
memset((char *) a->ptr + offset, 0, size - offset);
new = a->ptr;
static void
ucimap_add_fixup(struct ucimap_section_data *sd, union ucimap_data *data, struct uci_optmap *om, const char *str)
{
- struct uci_fixup *f, tmp;
+ struct ucimap_fixup *f, tmp;
struct uci_map *map = sd->map;
- INIT_LIST_HEAD(&tmp.list);
+ tmp.next = NULL;
tmp.sm = om->data.sm;
tmp.name = str;
tmp.type = om->type;
if (ucimap_handle_fixup(map, &tmp))
return;
- f = malloc(sizeof(struct uci_fixup));
+ f = malloc(sizeof(struct ucimap_fixup));
if (!f)
return;
memcpy(f, &tmp, sizeof(tmp));
- list_add_tail(&f->list, &map->fixup);
+ f->next = NULL;
+ *map->fixup_tail = f;
+ map->fixup_tail = &f->next;
}
static void
ucimap_add_custom_alloc(struct ucimap_section_data *sd, struct uci_optmap *om, void *ptr)
{
- struct uci_alloc_custom *a = &sd->alloc_custom[sd->alloc_custom_len++];
+ struct ucimap_alloc_custom *a = &sd->alloc_custom[sd->alloc_custom_len++];
a->section = ucimap_section_ptr(sd);
a->om = om;
int val;
if (ucimap_is_list(om->type) && !ucimap_is_fixup(om->type)) {
- if (unlikely(data->list->size <= data->list->n_items)) {
- /* should not happen */
- DPRINTF("ERROR: overflow while filling a list\n");
+ data = ucimap_list_append(data->list);
+ if (!data)
return;
- }
-
- data = &data->list->item[data->list->n_items++];
}
switch(om->type & UCIMAP_SUBTYPE) {
ucimap_add_fixup(sd, data, om, str);
return;
case UCIMAP_CUSTOM:
- tdata.s = (char *) data;
break;
}
if (om->parse) {
- if (om->parse(ucimap_section_ptr(sd), om, &tdata, str) < 0)
+ if (om->parse(ucimap_section_ptr(sd), om, data, str) < 0)
return;
if (ucimap_is_custom(om->type) && om->free) {
if (tdata.ptr != data->ptr)
}
static void
+ucimap_add_section_list(struct uci_map *map, struct ucimap_section_data *sd)
+{
+ sd->ref = map->sdata_tail;
+ *sd->ref = sd;
+ map->sdata_tail = &sd->next;
+}
+
+static void
ucimap_add_section(struct ucimap_section_data *sd)
{
struct uci_map *map = sd->map;
+ sd->next = NULL;
if (sd->sm->add(map, ucimap_section_ptr(sd)) < 0)
ucimap_free_section(map, sd);
else
- list_add_tail(&sd->list, &map->sdata);
+ ucimap_add_section_list(map, sd);
}
+#ifdef UCI_DEBUG
static const char *ucimap_type_names[] = {
[UCIMAP_STRING] = "string",
[UCIMAP_INT] = "integer",
[UCIMAP_LIST] = "list",
};
-static inline const char *
+static const char *
ucimap_get_type_name(int type)
{
static char buf[32];
return name;
}
+#endif
static bool
ucimap_check_optmap_type(struct uci_sectionmap *sm, struct uci_optmap *om)
int n_alloc_custom = 0;
int err;
- INIT_LIST_HEAD(&sd->list);
sd->map = map;
sd->sm = sm;
union ucimap_data *data;
struct uci_element *e;
int n_elements = 0;
+ int n_elements_alloc = 0;
int n_elements_custom = 0;
int size;
if (o->type == UCI_TYPE_LIST) {
uci_foreach_element(&o->v.list, tmp) {
- ucimap_count_alloc(om, &n_elements, &n_elements_custom);
+ ucimap_count_alloc(om, &n_elements_alloc, &n_elements_custom);
+ n_elements++;
}
} else if ((o->type == UCI_TYPE_STRING) &&
ucimap_is_list_auto(om->type)) {
break;
n_elements++;
- ucimap_count_alloc(om, &n_elements, &n_elements_custom);
+ ucimap_count_alloc(om, &n_elements_alloc, &n_elements_custom);
while (*data && !isspace(*data))
data++;
break;
}
/* add one more for the ucimap_list */
- n_alloc += n_elements + 1;
+ n_alloc += n_elements_alloc + 1;
n_alloc_custom += n_elements_custom;
size = sizeof(struct ucimap_list) +
n_elements * sizeof(union ucimap_data);
if (!data->list)
goto error_mem;
- data->list->size = n_elements;
memset(data->list, 0, size);
+ data->list->size = n_elements;
} else {
ucimap_count_alloc(om, &n_alloc, &n_alloc_custom);
}
}
- sd->allocmap = calloc(n_alloc, sizeof(struct uci_alloc));
+ sd->allocmap = calloc(n_alloc, sizeof(struct ucimap_alloc));
if (!sd->allocmap)
goto error_mem;
if (n_alloc_custom > 0) {
- sd->alloc_custom = calloc(n_alloc_custom, sizeof(struct uci_alloc_custom));
+ sd->alloc_custom = calloc(n_alloc_custom, sizeof(struct ucimap_alloc_custom));
if (!sd->alloc_custom)
goto error_mem;
}
if (map->parsed) {
ucimap_add_section(sd);
} else {
- list_add_tail(&sd->list, &map->pending);
+ ucimap_add_section_list(map, sd);
}
err = ucimap_parse_options(map, sm, sd, s);
return 0;
error_mem:
- if (sd->allocmap)
- free(sd->allocmap);
+ free(sd->alloc_custom);
+ free(sd->allocmap);
free(sd);
return UCI_ERR_MEM;
}
if (om->format) {
- union ucimap_data tdata;
-
- if (ucimap_is_custom(om->type)) {
- tdata.s = (char *)data;
- data = &tdata;
- }
-
if (om->format(ucimap_section_ptr(sd), om, data, &str) < 0)
return NULL;
ucimap_parse(struct uci_map *map, struct uci_package *pkg)
{
struct uci_element *e;
- struct list_head *p, *tmp;
+ struct ucimap_section_data *sd, **sd_tail;
+ struct ucimap_fixup *f;
int i;
- INIT_LIST_HEAD(&map->fixup);
+ sd_tail = map->sdata_tail;
+ map->parsed = false;
+ map->sdata_tail = &map->pending;
uci_foreach_element(&pkg->sections, e) {
struct uci_section *s = uci_to_section(e);
} else {
sd = malloc(sm->alloc_len);
memset(sd, 0, sm->alloc_len);
+ sd = ucimap_ptr_section(sm, sd);
}
if (!sd)
continue;
ucimap_parse_section(map, sm, sd, s);
}
}
- map->parsed = true;
+ if (!map->parsed) {
+ map->parsed = true;
+ map->sdata_tail = sd_tail;
+ }
- list_for_each_safe(p, tmp, &map->fixup) {
- struct uci_fixup *f = list_entry(p, struct uci_fixup, list);
+ f = map->fixup;
+ while (f) {
+ struct ucimap_fixup *next = f->next;
ucimap_handle_fixup(map, f);
- list_del(&f->list);
free(f);
+ f = next;
}
+ map->fixup_tail = &map->fixup;
+ map->fixup = NULL;
- list_for_each_safe(p, tmp, &map->pending) {
- struct ucimap_section_data *sd;
- sd = list_entry(p, struct ucimap_section_data, list);
-
- list_del_init(&sd->list);
+ sd = map->pending;
+ while (sd) {
+ struct ucimap_section_data *next = sd->next;
ucimap_add_section(sd);
+ sd = next;
}
+ map->pending = NULL;
}
projects / project / uci.git / blobdiff