interface: Fix triggering of interface update event
[project/netifd.git] / config.c
1 /*
2  * netifd - network interface daemon
3  * Copyright (C) 2012 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 #define _GNU_SOURCE
15 #include <string.h>
16 #include <stdlib.h>
17 #include <stdio.h>
18
19 #include <uci.h>
20
21 #include "netifd.h"
22 #include "interface.h"
23 #include "interface-ip.h"
24 #include "iprule.h"
25 #include "proto.h"
26 #include "wireless.h"
27 #include "config.h"
28
29 bool config_init = false;
30
31 static struct uci_context *uci_ctx;
32 static struct uci_package *uci_network;
33 static struct uci_package *uci_wireless;
34 static struct blob_buf b;
35
36 static int
37 config_section_idx(struct uci_section *s)
38 {
39         struct uci_element *e;
40         int idx = 0;
41
42         uci_foreach_element(&uci_wireless->sections, e) {
43                 struct uci_section *cur = uci_to_section(e);
44
45                 if (s == cur)
46                         return idx;
47
48                 if (!strcmp(cur->type, s->type))
49                         idx++;
50         }
51
52         return -1;
53 }
54
55 static int
56 config_parse_bridge_interface(struct uci_section *s, struct device_type *devtype)
57 {
58         char *name;
59
60         name = alloca(strlen(s->e.name) + strlen(devtype->name_prefix) + 2);
61         sprintf(name, "%s-%s", devtype->name_prefix, s->e.name);
62         blobmsg_add_string(&b, "name", name);
63
64         uci_to_blob(&b, s, devtype->config_params);
65         if (!device_create(name, devtype, b.head)) {
66                 D(INTERFACE, "Failed to create '%s' device for interface '%s'\n",
67                         devtype->name, s->e.name);
68         }
69
70         blob_buf_init(&b, 0);
71         blobmsg_add_string(&b, "ifname", name);
72         return 0;
73 }
74
75 static void
76 config_parse_interface(struct uci_section *s, bool alias)
77 {
78         struct interface *iface;
79         const char *type = NULL, *disabled;
80         struct blob_attr *config;
81         bool bridge = false;
82         struct device_type *devtype = NULL;
83
84         disabled = uci_lookup_option_string(uci_ctx, s, "disabled");
85         if (disabled && !strcmp(disabled, "1"))
86                 return;
87
88         blob_buf_init(&b, 0);
89
90         if (!alias)
91                 type = uci_lookup_option_string(uci_ctx, s, "type");
92
93         if (type)
94                 devtype = device_type_get(type);
95
96         if (devtype && devtype->bridge_capability) {
97                 if (config_parse_bridge_interface(s, devtype))
98                         return;
99
100                 bridge = true;
101         }
102
103         uci_to_blob(&b, s, &interface_attr_list);
104
105         iface = interface_alloc(s->e.name, b.head);
106         if (!iface)
107                 return;
108
109         if (iface->proto_handler && iface->proto_handler->config_params)
110                 uci_to_blob(&b, s, iface->proto_handler->config_params);
111
112         if (!bridge && uci_to_blob(&b, s, simple_device_type.config_params))
113                 iface->device_config = true;
114
115         config = blob_memdup(b.head);
116         if (!config)
117                 goto error;
118
119         if (alias) {
120                 if (!interface_add_alias(iface, config))
121                         goto error_free_config;
122         } else {
123                 interface_add(iface, config);
124         }
125         return;
126
127 error_free_config:
128         free(config);
129 error:
130         free(iface);
131 }
132
133 static void
134 config_parse_route(struct uci_section *s, bool v6)
135 {
136         void *route;
137
138         blob_buf_init(&b, 0);
139         route = blobmsg_open_array(&b, "route");
140         uci_to_blob(&b, s, &route_attr_list);
141         blobmsg_close_array(&b, route);
142         interface_ip_add_route(NULL, blob_data(b.head), v6);
143 }
144
145 static void
146 config_parse_rule(struct uci_section *s, bool v6)
147 {
148         void *rule;
149
150         blob_buf_init(&b, 0);
151         rule = blobmsg_open_array(&b, "rule");
152         uci_to_blob(&b, s, &rule_attr_list);
153         blobmsg_close_array(&b, rule);
154         iprule_add(blob_data(b.head), v6);
155 }
156
157 static void
158 config_init_devices(void)
159 {
160         struct uci_element *e;
161
162         uci_foreach_element(&uci_network->sections, e) {
163                 const struct uci_blob_param_list *params = NULL;
164                 struct uci_section *s = uci_to_section(e);
165                 struct device_type *devtype = NULL;
166                 struct device *dev;
167                 const char *type, *name;
168
169                 if (strcmp(s->type, "device") != 0)
170                         continue;
171
172                 name = uci_lookup_option_string(uci_ctx, s, "name");
173                 if (!name)
174                         continue;
175
176                 type = uci_lookup_option_string(uci_ctx, s, "type");
177                 if (type)
178                         devtype = device_type_get(type);
179
180                 if (devtype)
181                         params = devtype->config_params;
182                 if (!params)
183                         params = simple_device_type.config_params;
184
185                 blob_buf_init(&b, 0);
186                 uci_to_blob(&b, s, params);
187                 if (devtype) {
188                         dev = device_create(name, devtype, b.head);
189                         if (!dev)
190                                 continue;
191                 } else {
192                         dev = device_get(name, 1);
193                         if (!dev)
194                                 continue;
195
196                         dev->current_config = true;
197                         device_apply_config(dev, dev->type, b.head);
198                 }
199                 dev->default_config = false;
200         }
201 }
202
203 static struct uci_package *
204 config_init_package(const char *config)
205 {
206         struct uci_context *ctx = uci_ctx;
207         struct uci_package *p = NULL;
208
209         if (!ctx) {
210                 ctx = uci_alloc_context();
211                 uci_ctx = ctx;
212
213                 ctx->flags &= ~UCI_FLAG_STRICT;
214                 if (config_path)
215                         uci_set_confdir(ctx, config_path);
216
217 #ifdef DUMMY_MODE
218                 uci_set_savedir(ctx, "./tmp");
219 #endif
220         } else {
221                 p = uci_lookup_package(ctx, config);
222                 if (p)
223                         uci_unload(ctx, p);
224         }
225
226         if (uci_load(ctx, config, &p))
227                 return NULL;
228
229         return p;
230 }
231
232 static void
233 config_init_interfaces(void)
234 {
235         struct uci_element *e;
236
237         uci_foreach_element(&uci_network->sections, e) {
238                 struct uci_section *s = uci_to_section(e);
239
240                 if (!strcmp(s->type, "interface"))
241                         config_parse_interface(s, false);
242         }
243
244         uci_foreach_element(&uci_network->sections, e) {
245                 struct uci_section *s = uci_to_section(e);
246
247                 if (!strcmp(s->type, "alias"))
248                         config_parse_interface(s, true);
249         }
250 }
251
252 static void
253 config_init_routes(void)
254 {
255         struct interface *iface;
256         struct uci_element *e;
257
258         vlist_for_each_element(&interfaces, iface, node)
259                 interface_ip_update_start(&iface->config_ip);
260
261         uci_foreach_element(&uci_network->sections, e) {
262                 struct uci_section *s = uci_to_section(e);
263
264                 if (!strcmp(s->type, "route"))
265                         config_parse_route(s, false);
266                 else if (!strcmp(s->type, "route6"))
267                         config_parse_route(s, true);
268         }
269
270         vlist_for_each_element(&interfaces, iface, node)
271                 interface_ip_update_complete(&iface->config_ip);
272 }
273
274 static void
275 config_init_rules(void)
276 {
277         struct uci_element *e;
278
279         iprule_update_start();
280
281         uci_foreach_element(&uci_network->sections, e) {
282                 struct uci_section *s = uci_to_section(e);
283
284                 if (!strcmp(s->type, "rule"))
285                         config_parse_rule(s, false);
286                 else if (!strcmp(s->type, "rule6"))
287                         config_parse_rule(s, true);
288         }
289
290         iprule_update_complete();
291 }
292
293 static void
294 config_init_globals(void)
295 {
296         struct uci_section *globals = uci_lookup_section(
297                         uci_ctx, uci_network, "globals");
298         if (!globals)
299                 return;
300
301         const char *ula_prefix = uci_lookup_option_string(
302                         uci_ctx, globals, "ula_prefix");
303         interface_ip_set_ula_prefix(ula_prefix);
304
305         const char *default_ps = uci_lookup_option_string(
306                         uci_ctx, globals, "default_ps");
307
308         if (default_ps)
309                 device_set_default_ps(strcmp(default_ps, "1") ? false : true);
310 }
311
312 static void
313 config_parse_wireless_device(struct uci_section *s)
314 {
315         struct wireless_driver *drv;
316         const char *driver_name;
317
318         driver_name = uci_lookup_option_string(uci_ctx, s, "type");
319         if (!driver_name)
320                 return;
321
322         drv = avl_find_element(&wireless_drivers, driver_name, drv, node);
323         if (!drv)
324                 return;
325
326         blob_buf_init(&b, 0);
327         uci_to_blob(&b, s, drv->device.config);
328         wireless_device_create(drv, s->e.name, b.head);
329 }
330
331 static void
332 config_parse_wireless_interface(struct wireless_device *wdev, struct uci_section *s)
333 {
334         char *name;
335
336         name = alloca(strlen(s->type) + 16);
337         sprintf(name, "@%s[%d]", s->type, config_section_idx(s));
338
339         blob_buf_init(&b, 0);
340         uci_to_blob(&b, s, wdev->drv->interface.config);
341         wireless_interface_create(wdev, b.head, s->anonymous ? name : s->e.name);
342 }
343
344 static void
345 config_init_wireless(void)
346 {
347         struct wireless_device *wdev;
348         struct uci_element *e;
349         const char *dev_name;
350
351         if (!uci_wireless) {
352                 DPRINTF("No wireless configuration found\n");
353                 return;
354         }
355
356         vlist_update(&wireless_devices);
357
358         uci_foreach_element(&uci_wireless->sections, e) {
359                 struct uci_section *s = uci_to_section(e);
360                 if (strcmp(s->type, "wifi-device") != 0)
361                         continue;
362
363                 config_parse_wireless_device(s);
364         }
365
366         vlist_flush(&wireless_devices);
367
368         vlist_for_each_element(&wireless_devices, wdev, node) {
369                 wdev->vif_idx = 0;
370                 vlist_update(&wdev->interfaces);
371         }
372
373         uci_foreach_element(&uci_wireless->sections, e) {
374                 struct uci_section *s = uci_to_section(e);
375
376                 if (strcmp(s->type, "wifi-iface") != 0)
377                         continue;
378
379                 dev_name = uci_lookup_option_string(uci_ctx, s, "device");
380                 if (!dev_name)
381                         continue;
382
383                 wdev = vlist_find(&wireless_devices, dev_name, wdev, node);
384                 if (!wdev) {
385                         DPRINTF("device %s not found!\n", dev_name);
386                         continue;
387                 }
388
389                 config_parse_wireless_interface(wdev, s);
390         }
391
392         vlist_for_each_element(&wireless_devices, wdev, node)
393                 vlist_flush(&wdev->interfaces);
394 }
395
396 void
397 config_init_all(void)
398 {
399         uci_network = config_init_package("network");
400         if (!uci_network) {
401                 fprintf(stderr, "Failed to load network config\n");
402                 return;
403         }
404
405         uci_wireless = config_init_package("wireless");
406
407         vlist_update(&interfaces);
408         config_init = true;
409         device_lock();
410
411         device_reset_config();
412         config_init_devices();
413         config_init_interfaces();
414         config_init_routes();
415         config_init_rules();
416         config_init_globals();
417         config_init_wireless();
418
419         config_init = false;
420         device_unlock();
421
422         device_reset_old();
423         device_init_pending();
424         vlist_flush(&interfaces);
425         device_free_unused(NULL);
426         interface_refresh_assignments(false);
427         interface_start_pending();
428         wireless_start_pending();
429 }