uci: copy permisions of /etc/config/ files for temp files
[project/uci.git] / ucimap-example.c
1 /*
2  * ucimap-example - sample code for the ucimap library
3  * Copyright (C) 2008-2009 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 #include "list.h"
20
21 struct list_head ifs;
22
23 struct uci_network {
24         struct ucimap_section_data map;
25         struct list_head list;
26         struct list_head alias;
27
28         const char *name;
29         const char *proto;
30         const char *ifname;
31         unsigned char *ipaddr;
32         int test;
33         bool enabled;
34         struct ucimap_list *aliases;
35 };
36
37 struct uci_alias {
38         struct ucimap_section_data map;
39         struct list_head list;
40
41         const char *name;
42         struct uci_network *interface;
43 };
44
45 static int
46 network_parse_ip(void *section, struct uci_optmap *om, union ucimap_data *data, const char *str)
47 {
48         unsigned char *target;
49         int tmp[4];
50         int i;
51
52         if (sscanf(str, "%d.%d.%d.%d", &tmp[0], &tmp[1], &tmp[2], &tmp[3]) != 4)
53                 return -1;
54
55         target = malloc(4);
56         if (!target)
57                 return -1;
58
59         data->ptr = target;
60         for (i = 0; i < 4; i++)
61                 target[i] = (char) tmp[i];
62
63         return 0;
64 }
65
66 static int
67 network_format_ip(void *section, struct uci_optmap *om, union ucimap_data *data, char **str)
68 {
69         static char buf[16];
70         unsigned char *ip = (unsigned char *) data->ptr;
71
72         if (ip) {
73                 sprintf(buf, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
74                 *str = buf;
75         } else {
76                 *str = NULL;
77         }
78
79         return 0;
80 }
81
82 static void
83 network_free_ip(void *section, struct uci_optmap *om, void *ptr)
84 {
85         free(ptr);
86 }
87
88 static int
89 network_init_interface(struct uci_map *map, void *section, struct uci_section *s)
90 {
91         struct uci_network *net = section;
92
93         INIT_LIST_HEAD(&net->list);
94         INIT_LIST_HEAD(&net->alias);
95         net->name = s->e.name;
96         net->test = -1;
97         return 0;
98 }
99
100 static int
101 network_init_alias(struct uci_map *map, void *section, struct uci_section *s)
102 {
103         struct uci_alias *alias = section;
104
105         INIT_LIST_HEAD(&alias->list);
106         alias->name = s->e.name;
107         return 0;
108 }
109
110 static int
111 network_add_interface(struct uci_map *map, void *section)
112 {
113         struct uci_network *net = section;
114
115         list_add_tail(&net->list, &ifs);
116
117         return 0;
118 }
119
120 static int
121 network_add_alias(struct uci_map *map, void *section)
122 {
123         struct uci_alias *a = section;
124
125         if (a->interface)
126                 list_add_tail(&a->list, &a->interface->alias);
127
128         return 0;
129 }
130
131 static struct ucimap_section_data *
132 network_allocate(struct uci_map *map, struct uci_sectionmap *sm, struct uci_section *s)
133 {
134         struct uci_network *p = malloc(sizeof(struct uci_network));
135         if (!p)
136                 return NULL;
137         memset(p, 0, sizeof(struct uci_network));
138         return &p->map;
139 }
140
141 struct my_optmap {
142         struct uci_optmap map;
143         int test;
144 };
145
146 static struct uci_sectionmap network_interface;
147 static struct uci_sectionmap network_alias;
148
149 static struct my_optmap network_interface_options[] = {
150         {
151                 .map = {
152                         UCIMAP_OPTION(struct uci_network, proto),
153                         .type = UCIMAP_STRING,
154                         .name = "proto",
155                         .data.s.maxlen = 32,
156                 }
157         },
158         {
159                 .map = {
160                         UCIMAP_OPTION(struct uci_network, ifname),
161                         .type = UCIMAP_STRING,
162                         .name = "ifname"
163                 }
164         },
165         {
166                 .map = {
167                         UCIMAP_OPTION(struct uci_network, ipaddr),
168                         .type = UCIMAP_CUSTOM,
169                         .name = "ipaddr",
170                         .parse = network_parse_ip,
171                         .format = network_format_ip,
172                         .free = network_free_ip,
173                 }
174         },
175         {
176                 .map = {
177                         UCIMAP_OPTION(struct uci_network, enabled),
178                         .type = UCIMAP_BOOL,
179                         .name = "enabled",
180                 }
181         },
182         {
183                 .map = {
184                         UCIMAP_OPTION(struct uci_network, test),
185                         .type = UCIMAP_INT,
186                         .name = "test"
187                 }
188         },
189         {
190                 .map = {
191                         UCIMAP_OPTION(struct uci_network, aliases),
192                         .type = UCIMAP_LIST | UCIMAP_SECTION | UCIMAP_LIST_AUTO,
193                         .data.sm = &network_alias
194                 }
195         }
196 };
197
198 static struct uci_sectionmap network_interface = {
199         UCIMAP_SECTION(struct uci_network, map),
200         .type = "interface",
201         .alloc = network_allocate,
202         .init = network_init_interface,
203         .add = network_add_interface,
204         .options = &network_interface_options[0].map,
205         .n_options = ARRAY_SIZE(network_interface_options),
206         .options_size = sizeof(struct my_optmap)
207 };
208
209 static struct uci_optmap network_alias_options[] = {
210         {
211                 UCIMAP_OPTION(struct uci_alias, interface),
212                 .type = UCIMAP_SECTION,
213                 .data.sm = &network_interface
214         }
215 };
216
217 static struct uci_sectionmap network_alias = {
218         UCIMAP_SECTION(struct uci_alias, map),
219         .type = "alias",
220         .options = network_alias_options,
221         .init = network_init_alias,
222         .add = network_add_alias,
223         .n_options = ARRAY_SIZE(network_alias_options),
224 };
225
226 static struct uci_sectionmap *network_smap[] = {
227         &network_interface,
228         &network_alias,
229 };
230
231 static struct uci_map network_map = {
232         .sections = network_smap,
233         .n_sections = ARRAY_SIZE(network_smap),
234 };
235
236
237 int main(int argc, char **argv)
238 {
239         struct uci_context *ctx;
240         struct uci_package *pkg;
241         struct list_head *p;
242         struct uci_network *net;
243         struct uci_alias *alias;
244         bool set = false;
245         int i;
246
247         INIT_LIST_HEAD(&ifs);
248         ctx = uci_alloc_context();
249         if (!ctx)
250                 return -1;
251         ucimap_init(&network_map);
252
253         if ((argc >= 2) && !strcmp(argv[1], "-s")) {
254                 uci_set_savedir(ctx, "./test/save");
255                 set = true;
256         }
257
258         uci_set_confdir(ctx, "./test/config");
259         uci_load(ctx, "network", &pkg);
260
261         ucimap_parse(&network_map, pkg);
262
263         list_for_each(p, &ifs) {
264                 const unsigned char *ipaddr;
265                 int n_aliases = 0;
266
267                 net = list_entry(p, struct uci_network, list);
268                 ipaddr = net->ipaddr;
269                 if (!ipaddr)
270                         ipaddr = (const unsigned char *) "\x00\x00\x00\x00";
271
272                 printf("New network section '%s'\n"
273                         "       type: %s\n"
274                         "       ifname: %s\n"
275                         "       ipaddr: %d.%d.%d.%d\n"
276                         "       test: %d\n"
277                         "       enabled: %s\n",
278                         net->name,
279                         net->proto,
280                         net->ifname,
281                         ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3],
282                         net->test,
283                         (net->enabled ? "on" : "off"));
284
285                 if (net->aliases->n_items > 0) {
286                         printf("Configured aliases:");
287                         for (i = 0; i < net->aliases->n_items; i++) {
288                                 alias = net->aliases->item[i].ptr;
289                                 printf(" %s", alias->name);
290                         }
291                         printf("\n");
292                 }
293                 list_for_each_entry(alias, &net->alias, list) {
294                         n_aliases++;
295                         for (i = 0; i < net->aliases->n_items; i++) {
296                                 if (alias == net->aliases->item[i].ptr)
297                                         goto next_alias;
298                         }
299                         printf("New alias: %s\n", alias->name);
300 next_alias:
301                         continue;
302                 }
303                 if (set && !strcmp(net->name, "lan")) {
304                         ucimap_free_item(&net->map, &net->ipaddr);
305                         ucimap_set_changed(&net->map, &net->ipaddr);
306                         ucimap_resize_list(&net->map, &net->aliases, n_aliases);
307                         net->aliases->n_items = 0;
308                         list_for_each_entry(alias, &net->alias, list) {
309                                 net->aliases->item[net->aliases->n_items++].ptr = alias;
310                         }
311                         ucimap_set_changed(&net->map, &net->aliases);
312                         ucimap_store_section(&network_map, pkg, &net->map);
313                         uci_save(ctx, pkg);
314                 }
315         }
316
317
318         ucimap_cleanup(&network_map);
319         uci_free_context(ctx);
320
321         return 0;
322 }