only use -g if debugging is requested
[project/uci.git] / list.c
1 /*
2  * libuci - Library for the Unified Configuration Interface
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 lesser general public license version 2.1
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
15 #include <glob.h>
16
17 /* initialize a list head/item */
18 static inline void uci_list_init(struct uci_list *ptr)
19 {
20         ptr->prev = ptr;
21         ptr->next = ptr;
22 }
23
24 /* inserts a new list entry between two consecutive entries */
25 static inline void __uci_list_add(struct uci_list *prev, struct uci_list *next, struct uci_list *ptr)
26 {
27         next->prev = ptr;
28         ptr->prev = prev;
29         ptr->next = next;
30         prev->next = ptr;
31 }
32
33 /* inserts a new list entry at the tail of the list */
34 static inline void uci_list_add(struct uci_list *head, struct uci_list *ptr)
35 {
36         /* NB: head->prev points at the tail */
37         __uci_list_add(head->prev, head, ptr);
38 }
39
40 static inline void uci_list_del(struct uci_list *ptr)
41 {
42         struct uci_list *next, *prev;
43
44         next = ptr->next;
45         prev = ptr->prev;
46
47         prev->next = next;
48         next->prev = prev;
49
50         uci_list_init(ptr);
51 }
52
53 static struct uci_element *
54 uci_alloc_generic(struct uci_context *ctx, int type, const char *name, int size)
55 {
56         struct uci_element *e;
57         void *ptr;
58
59         ptr = uci_malloc(ctx, size + strlen(name) + 1);
60         e = (struct uci_element *) ptr;
61         e->type = type;
62         e->name = (char *) ptr + size;
63         strcpy(e->name, name);
64         uci_list_init(&e->list);
65
66         return e;
67 }
68
69 static void
70 uci_free_element(struct uci_element *e)
71 {
72         if (!e)
73                 return;
74
75         if (!uci_list_empty(&e->list))
76                 uci_list_del(&e->list);
77         free(e);
78 }
79
80 static struct uci_option *
81 uci_alloc_option(struct uci_section *s, const char *name, const char *value)
82 {
83         struct uci_package *p = s->package;
84         struct uci_context *ctx = p->ctx;
85         struct uci_option *o;
86
87         o = uci_alloc_element(ctx, option, name, strlen(value) + 1);
88         o->value = uci_dataptr(o);
89         o->section = s;
90         strcpy(o->value, value);
91         uci_list_add(&s->options, &o->e.list);
92
93         return o;
94 }
95
96 static inline void
97 uci_free_option(struct uci_option *o)
98 {
99         uci_free_element(&o->e);
100 }
101
102 static struct uci_section *
103 uci_alloc_section(struct uci_package *p, const char *type, const char *name)
104 {
105         struct uci_context *ctx = p->ctx;
106         struct uci_section *s;
107         char buf[16];
108
109         if (!name || !name[0]) {
110                 snprintf(buf, 16, "cfg%d", p->n_section);
111                 name = buf;
112         }
113
114         s = uci_alloc_element(ctx, section, name, strlen(type) + 1);
115         s->type = uci_dataptr(s);
116         s->package = p;
117         strcpy(s->type, type);
118         uci_list_init(&s->options);
119         uci_list_add(&p->sections, &s->e.list);
120
121         return s;
122 }
123
124 static void
125 uci_free_section(struct uci_section *s)
126 {
127         struct uci_element *o, *tmp;
128
129         uci_foreach_element_safe(&s->options, tmp, o) {
130                 uci_free_option(uci_to_option(o));
131         }
132         uci_free_element(&s->e);
133 }
134
135 static struct uci_package *
136 uci_alloc_package(struct uci_context *ctx, const char *name)
137 {
138         struct uci_package *p;
139
140         p = uci_alloc_element(ctx, package, name, 0);
141         p->ctx = ctx;
142         uci_list_init(&p->sections);
143         return p;
144 }
145
146 static void
147 uci_free_package(struct uci_package *p)
148 {
149         struct uci_element *e, *tmp;
150
151         if(!p)
152                 return;
153
154         uci_foreach_element_safe(&p->sections, tmp, e) {
155                 uci_free_section(uci_to_section(e));
156         }
157         uci_free_element(&p->e);
158 }
159
160
161 int uci_unload(struct uci_context *ctx, const char *name)
162 {
163         struct uci_element *e;
164
165         UCI_HANDLE_ERR(ctx);
166         UCI_ASSERT(ctx, name != NULL);
167
168         uci_foreach_element(&ctx->root, e) {
169                 if (!strcmp(e->name, name))
170                         goto found;
171         }
172         UCI_THROW(ctx, UCI_ERR_NOTFOUND);
173
174 found:
175         uci_free_package(uci_to_package(e));
176
177         return 0;
178 }
179
180 static inline char *get_filename(char *path)
181 {
182         char *p;
183
184         p = strrchr(path, '/');
185         p++;
186         if (!*p)
187                 return NULL;
188         return p;
189 }
190
191 char **uci_list_configs(struct uci_context *ctx)
192 {
193         char **configs;
194         glob_t globbuf;
195         int size, i;
196         char *buf;
197
198         if (glob(UCI_CONFDIR "/*", GLOB_MARK, NULL, &globbuf) != 0)
199                 return NULL;
200
201         size = sizeof(char *) * (globbuf.gl_pathc + 1);
202         for(i = 0; i < globbuf.gl_pathc; i++) {
203                 char *p;
204
205                 p = get_filename(globbuf.gl_pathv[i]);
206                 if (!p)
207                         continue;
208
209                 size += strlen(p) + 1;
210         }
211
212         configs = malloc(size);
213         if (!configs)
214                 return NULL;
215
216         memset(configs, 0, size);
217         buf = (char *) &configs[globbuf.gl_pathc + 1];
218         for(i = 0; i < globbuf.gl_pathc; i++) {
219                 char *p;
220
221                 p = get_filename(globbuf.gl_pathv[i]);
222                 if (!p)
223                         continue;
224
225                 configs[i] = buf;
226                 strcpy(buf, p);
227                 buf += strlen(buf) + 1;
228         }
229         return configs;
230 }
231
232