ubus: use safe iterator
[project/odhcpd.git] / src / config.c
1 #include <fcntl.h>
2 #include <resolv.h>
3 #include <signal.h>
4 #include <arpa/inet.h>
5 #include <unistd.h>
6
7 #include <uci.h>
8 #include <uci_blob.h>
9
10 #include "odhcpd.h"
11
12 static struct blob_buf b;
13 static int reload_pipe[2];
14 struct list_head leases = LIST_HEAD_INIT(leases);
15 struct list_head interfaces = LIST_HEAD_INIT(interfaces);
16 struct config config = {false, NULL, NULL};
17
18 enum {
19         IFACE_ATTR_INTERFACE,
20         IFACE_ATTR_IFNAME,
21         IFACE_ATTR_NETWORKID,
22         IFACE_ATTR_DYNAMICDHCP,
23         IFACE_ATTR_IGNORE,
24         IFACE_ATTR_LEASETIME,
25         IFACE_ATTR_LIMIT,
26         IFACE_ATTR_START,
27         IFACE_ATTR_MASTER,
28         IFACE_ATTR_UPSTREAM,
29         IFACE_ATTR_RA,
30         IFACE_ATTR_DHCPV4,
31         IFACE_ATTR_DHCPV6,
32         IFACE_ATTR_NDP,
33         IFACE_ATTR_DNS,
34         IFACE_ATTR_DOMAIN,
35         IFACE_ATTR_RA_DEFAULT,
36         IFACE_ATTR_RA_MANAGEMENT,
37         IFACE_ATTR_RA_OFFLINK,
38         IFACE_ATTR_RA_PREFERENCE,
39         IFACE_ATTR_NDPROXY_ROUTING,
40         IFACE_ATTR_NDPROXY_SLAVE,
41         IFACE_ATTR_NDPROXY_STATIC,
42         IFACE_ATTR_MAX
43 };
44
45 static const struct blobmsg_policy iface_attrs[IFACE_ATTR_MAX] = {
46         [IFACE_ATTR_INTERFACE] = { .name = "interface", .type = BLOBMSG_TYPE_STRING },
47         [IFACE_ATTR_IFNAME] = { .name = "ifname", .type = BLOBMSG_TYPE_STRING },
48         [IFACE_ATTR_NETWORKID] = { .name = "networkid", .type = BLOBMSG_TYPE_STRING },
49         [IFACE_ATTR_DYNAMICDHCP] = { .name = "dynamicdhcp", .type = BLOBMSG_TYPE_BOOL },
50         [IFACE_ATTR_IGNORE] = { .name = "ignore", .type = BLOBMSG_TYPE_BOOL },
51         [IFACE_ATTR_LEASETIME] = { .name = "leasetime", .type = BLOBMSG_TYPE_STRING },
52         [IFACE_ATTR_START] = { .name = "start", .type = BLOBMSG_TYPE_INT32 },
53         [IFACE_ATTR_LIMIT] = { .name = "limit", .type = BLOBMSG_TYPE_INT32 },
54         [IFACE_ATTR_MASTER] = { .name = "master", .type = BLOBMSG_TYPE_BOOL },
55         [IFACE_ATTR_UPSTREAM] = { .name = "upstream", .type = BLOBMSG_TYPE_ARRAY },
56         [IFACE_ATTR_RA] = { .name = "ra", .type = BLOBMSG_TYPE_STRING },
57         [IFACE_ATTR_DHCPV4] = { .name = "dhcpv4", .type = BLOBMSG_TYPE_STRING },
58         [IFACE_ATTR_DHCPV6] = { .name = "dhcpv6", .type = BLOBMSG_TYPE_STRING },
59         [IFACE_ATTR_NDP] = { .name = "ndp", .type = BLOBMSG_TYPE_STRING },
60         [IFACE_ATTR_DNS] = { .name = "dns", .type = BLOBMSG_TYPE_ARRAY },
61         [IFACE_ATTR_DOMAIN] = { .name = "domain", .type = BLOBMSG_TYPE_ARRAY },
62         [IFACE_ATTR_RA_DEFAULT] = { .name = "ra_default", .type = BLOBMSG_TYPE_INT32 },
63         [IFACE_ATTR_RA_MANAGEMENT] = { .name = "ra_management", .type = BLOBMSG_TYPE_INT32 },
64         [IFACE_ATTR_RA_OFFLINK] = { .name = "ra_offlink", .type = BLOBMSG_TYPE_BOOL },
65         [IFACE_ATTR_RA_PREFERENCE] = { .name = "ra_preference", .type = BLOBMSG_TYPE_STRING },
66         [IFACE_ATTR_NDPROXY_ROUTING] = { .name = "ndproxy_routing", .type = BLOBMSG_TYPE_BOOL },
67         [IFACE_ATTR_NDPROXY_SLAVE] = { .name = "ndproxy_slave", .type = BLOBMSG_TYPE_BOOL },
68         [IFACE_ATTR_NDPROXY_STATIC] = { .name = "ndproxy_static", .type = BLOBMSG_TYPE_ARRAY },
69 };
70
71 static const struct uci_blob_param_info iface_attr_info[IFACE_ATTR_MAX] = {
72         [IFACE_ATTR_UPSTREAM] = { .type = BLOBMSG_TYPE_STRING },
73         [IFACE_ATTR_DNS] = { .type = BLOBMSG_TYPE_STRING },
74         [IFACE_ATTR_DOMAIN] = { .type = BLOBMSG_TYPE_STRING },
75         [IFACE_ATTR_NDPROXY_STATIC] = { .type = BLOBMSG_TYPE_STRING },
76 };
77
78 const struct uci_blob_param_list interface_attr_list = {
79         .n_params = IFACE_ATTR_MAX,
80         .params = iface_attrs,
81         .info = iface_attr_info,
82 };
83
84
85 enum {
86         LEASE_ATTR_IP,
87         LEASE_ATTR_MAC,
88         LEASE_ATTR_DUID,
89         LEASE_ATTR_HOSTID,
90         LEASE_ATTR_NAME,
91         LEASE_ATTR_MAX
92 };
93
94
95 static const struct blobmsg_policy lease_attrs[LEASE_ATTR_MAX] = {
96         [LEASE_ATTR_IP] = { .name = "ip", .type = BLOBMSG_TYPE_STRING },
97         [LEASE_ATTR_MAC] = { .name = "mac", .type = BLOBMSG_TYPE_STRING },
98         [LEASE_ATTR_DUID] = { .name = "duid", .type = BLOBMSG_TYPE_STRING },
99         [LEASE_ATTR_HOSTID] = { .name = "hostid", .type = BLOBMSG_TYPE_STRING },
100         [LEASE_ATTR_NAME] = { .name = "name", .type = BLOBMSG_TYPE_STRING },
101 };
102
103
104 const struct uci_blob_param_list lease_attr_list = {
105         .n_params = LEASE_ATTR_MAX,
106         .params = lease_attrs,
107 };
108
109
110 enum {
111         ODHCPD_ATTR_MAINDHCP,
112         ODHCPD_ATTR_LEASEFILE,
113         ODHCPD_ATTR_LEASETRIGGER,
114         ODHCPD_ATTR_MAX
115 };
116
117
118 static const struct blobmsg_policy odhcpd_attrs[LEASE_ATTR_MAX] = {
119         [ODHCPD_ATTR_MAINDHCP] = { .name = "maindhcp", .type = BLOBMSG_TYPE_BOOL },
120         [ODHCPD_ATTR_LEASEFILE] = { .name = "leasefile", .type = BLOBMSG_TYPE_STRING },
121         [ODHCPD_ATTR_LEASETRIGGER] = { .name = "leasetrigger", .type = BLOBMSG_TYPE_STRING },
122 };
123
124
125 const struct uci_blob_param_list odhcpd_attr_list = {
126         .n_params = ODHCPD_ATTR_MAX,
127         .params = odhcpd_attrs,
128 };
129
130
131 static struct interface* get_interface(const char *name)
132 {
133         struct interface *c;
134         list_for_each_entry(c, &interfaces, head)
135                 if (!strcmp(c->name, name))
136                         return c;
137         return NULL;
138 }
139
140
141 static void clean_interface(struct interface *iface)
142 {
143         free(iface->dns);
144         free(iface->search);
145         free(iface->upstream);
146         free(iface->static_ndp);
147         free(iface->dhcpv4_dns);
148         memset(&iface->ra, 0, sizeof(*iface) - offsetof(struct interface, ra));
149 }
150
151
152 static void close_interface(struct interface *iface)
153 {
154         if (iface->head.next)
155                 list_del(&iface->head);
156
157         setup_router_interface(iface, false);
158         setup_dhcpv6_interface(iface, false);
159         setup_ndp_interface(iface, false);
160         setup_dhcpv4_interface(iface, false);
161
162         clean_interface(iface);
163         free(iface);
164 }
165
166
167 static int parse_mode(const char *mode)
168 {
169         if (!strcmp(mode, "disabled")) {
170                 return RELAYD_DISABLED;
171         } else if (!strcmp(mode, "server")) {
172                 return RELAYD_SERVER;
173         } else if (!strcmp(mode, "relay")) {
174                 return RELAYD_RELAY;
175         } else if (!strcmp(mode, "hybrid")) {
176                 return RELAYD_HYBRID;
177         } else {
178                 return -1;
179         }
180 }
181
182
183 static void set_config(struct uci_section *s)
184 {
185         struct blob_attr *tb[ODHCPD_ATTR_MAX], *c;
186
187         blob_buf_init(&b, 0);
188         uci_to_blob(&b, s, &odhcpd_attr_list);
189         blobmsg_parse(odhcpd_attrs, ODHCPD_ATTR_MAX, tb, blob_data(b.head), blob_len(b.head));
190
191         if ((c = tb[ODHCPD_ATTR_MAINDHCP]))
192                 config.legacy = blobmsg_get_bool(c);
193
194         if ((c = tb[ODHCPD_ATTR_LEASEFILE])) {
195                 free(config.dhcp_statefile);
196                 config.dhcp_statefile = strdup(blobmsg_get_string(c));
197         }
198
199         if ((c = tb[ODHCPD_ATTR_LEASETRIGGER])) {
200                 free(config.dhcp_cb);
201                 config.dhcp_cb = strdup(blobmsg_get_string(c));
202         }
203 }
204
205
206 static int set_lease(struct uci_section *s)
207 {
208         struct blob_attr *tb[LEASE_ATTR_MAX], *c;
209
210         blob_buf_init(&b, 0);
211         uci_to_blob(&b, s, &lease_attr_list);
212         blobmsg_parse(lease_attrs, LEASE_ATTR_MAX, tb, blob_data(b.head), blob_len(b.head));
213
214         size_t hostlen = 1;
215         if ((c = tb[LEASE_ATTR_NAME]))
216                 hostlen = blobmsg_data_len(c);
217
218         struct lease *lease = calloc(1, sizeof(*lease) + hostlen);
219         if (!lease)
220                 goto err;
221
222         if (hostlen > 1)
223                 memcpy(lease->hostname, blobmsg_get_string(c), hostlen);
224
225         if ((c = tb[LEASE_ATTR_IP]))
226                 if (inet_pton(AF_INET, blobmsg_get_string(c), &lease->ipaddr) < 0)
227                         goto err;
228
229         if ((c = tb[LEASE_ATTR_MAC]))
230                 if (!ether_aton_r(blobmsg_get_string(c), &lease->mac))
231                         goto err;
232
233         if ((c = tb[LEASE_ATTR_DUID])) {
234                 size_t duidlen = (blobmsg_data_len(c) - 1) / 2;
235                 lease->duid = malloc(duidlen);
236                 if (!lease->duid)
237                         goto err;
238
239                 ssize_t len = odhcpd_unhexlify(lease->duid,
240                                 duidlen, blobmsg_get_string(c));
241
242                 if (len < 0)
243                         goto err;
244
245                 lease->duid_len = len;
246         }
247
248         if ((c = tb[LEASE_ATTR_HOSTID]))
249                 if (odhcpd_unhexlify((uint8_t*)&lease->hostid, sizeof(lease->hostid),
250                                 blobmsg_get_string(c)) < 0)
251                         goto err;
252
253         list_add(&lease->head, &leases);
254         return 0;
255
256 err:
257         if (lease) {
258                 free(lease->duid);
259                 free(lease);
260         }
261         return -1;
262 }
263
264
265 int config_parse_interface(void *data, size_t len, const char *name, bool overwrite)
266 {
267         struct blob_attr *tb[IFACE_ATTR_MAX], *c;
268         blobmsg_parse(iface_attrs, IFACE_ATTR_MAX, tb, data, len);
269
270         if (tb[IFACE_ATTR_INTERFACE])
271                 name = blobmsg_get_string(tb[IFACE_ATTR_INTERFACE]);
272
273         if (!name)
274                 return -1;
275
276         struct interface *iface = get_interface(name);
277         if (!iface) {
278                 iface = calloc(1, sizeof(*iface));
279                 if (!iface)
280                         return -1;
281
282                 strncpy(iface->name, name, sizeof(iface->name) - 1);
283                 list_add(&iface->head, &interfaces);
284         }
285
286         const char *ifname = NULL;
287 #ifdef WITH_UBUS
288         if (overwrite || !iface->ifname[0])
289                 ifname = ubus_get_ifname(name);
290 #endif
291
292         if (overwrite) {
293                 if ((c = tb[IFACE_ATTR_IFNAME]))
294                         ifname = blobmsg_get_string(c);
295                 else if ((c = tb[IFACE_ATTR_NETWORKID]))
296                         ifname = blobmsg_get_string(c);
297         }
298
299         if (!iface->ifname[0] && !ifname)
300                 return -1;
301
302         if (ifname)
303                 strncpy(iface->ifname, ifname, sizeof(iface->ifname) - 1);
304
305         if ((iface->ifindex = if_nametoindex(iface->ifname)) <= 0)
306                 return -1;
307
308         iface->inuse = true;
309
310         if ((c = tb[IFACE_ATTR_DYNAMICDHCP]))
311                 iface->no_dynamic_dhcp = !blobmsg_get_bool(c);
312
313         if (overwrite && (c = tb[IFACE_ATTR_IGNORE]))
314                 iface->ignore = blobmsg_get_bool(c);
315
316         if ((c = tb[IFACE_ATTR_LEASETIME])) {
317                 char *val = blobmsg_get_string(c), *endptr;
318                 double time = strtod(val, &endptr);
319                 if (time && endptr[0]) {
320                         if (endptr[0] == 's')
321                                 time *= 1;
322                         else if (endptr[0] == 'm')
323                                 time *= 60;
324                         else if (endptr[0] == 'h')
325                                 time *= 3600;
326                         else if (endptr[0] == 'd')
327                                 time *= 24 * 3600;
328                         else if (endptr[0] == 'w')
329                                 time *= 7 * 24 * 3600;
330                         else
331                                 goto err;
332                 }
333
334                 if (time >= 60)
335                         iface->dhcpv4_leasetime = time;
336         }
337
338         if ((c = tb[IFACE_ATTR_START])) {
339                 iface->dhcpv4_start.s_addr = htonl(blobmsg_get_u32(c));
340
341                 if (config.legacy)
342                         iface->dhcpv4 = RELAYD_SERVER;
343         }
344
345         if ((c = tb[IFACE_ATTR_LIMIT]))
346                 iface->dhcpv4_end.s_addr = htonl(
347                                 ntohl(iface->dhcpv4_start.s_addr) + blobmsg_get_u32(c));
348
349         if ((c = tb[IFACE_ATTR_MASTER]))
350                 iface->master = blobmsg_get_bool(c);
351
352         if (overwrite && (c = tb[IFACE_ATTR_UPSTREAM])) {
353                 struct blob_attr *cur;
354                 unsigned rem;
355
356                 blobmsg_for_each_attr(cur, c, rem) {
357                         if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, NULL))
358                                 continue;
359
360                         iface->upstream = realloc(iface->upstream,
361                                         iface->upstream_len + blobmsg_data_len(cur));
362                         if (!iface->upstream)
363                                 goto err;
364
365                         memcpy(iface->upstream + iface->upstream_len, blobmsg_get_string(cur), blobmsg_data_len(cur));
366                         iface->upstream_len += blobmsg_data_len(cur);
367                 }
368         }
369
370         int mode;
371         if ((c = tb[IFACE_ATTR_RA])) {
372                 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0)
373                         iface->ra = mode;
374                 else
375                         goto err;
376         }
377
378         if ((c = tb[IFACE_ATTR_DHCPV4])) {
379                 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0)
380                         iface->dhcpv4 = mode;
381                 else
382                         goto err;
383         }
384
385         if ((c = tb[IFACE_ATTR_DHCPV6])) {
386                 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0)
387                         iface->dhcpv6 = mode;
388                 else
389                         goto err;
390         }
391
392         if ((c = tb[IFACE_ATTR_NDP])) {
393                 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0)
394                         iface->ndp = mode;
395                 else
396                         goto err;
397         }
398
399         if ((c = tb[IFACE_ATTR_DNS])) {
400                 struct blob_attr *cur;
401                 unsigned rem;
402
403                 iface->always_rewrite_dns = true;
404                 blobmsg_for_each_attr(cur, c, rem) {
405                         if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, NULL))
406                                 continue;
407
408                         struct in_addr addr4;
409                         struct in6_addr addr6;
410                         if (inet_pton(AF_INET, blobmsg_get_string(cur), &addr4) == 1) {
411                                 iface->dhcpv4_dns = realloc(iface->dhcpv4_dns,
412                                                 (++iface->dhcpv4_dns_cnt) * sizeof(*iface->dhcpv4_dns));
413                                 if (!iface->dhcpv4_dns)
414                                         goto err;
415
416                                 iface->dhcpv4_dns[iface->dhcpv4_dns_cnt - 1] = addr4;
417                         } else if (inet_pton(AF_INET6, blobmsg_get_string(cur), &addr6) == 1) {
418                                 iface->dns = realloc(iface->dns,
419                                                 (++iface->dns_cnt) * sizeof(*iface->dns));
420                                 if (!iface->dns)
421                                         goto err;
422
423                                 iface->dns[iface->dns_cnt - 1] = addr6;
424                         } else {
425                                 goto err;
426                         }
427                 }
428         }
429
430         if ((c = tb[IFACE_ATTR_DOMAIN])) {
431                 struct blob_attr *cur;
432                 unsigned rem;
433
434                 blobmsg_for_each_attr(cur, c, rem) {
435                         if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, NULL))
436                                 continue;
437
438                         uint8_t buf[256];
439                         int len = dn_comp(blobmsg_get_string(cur), buf, sizeof(buf), NULL, NULL);
440                         if (len <= 0)
441                                 goto err;
442
443                         iface->search = realloc(iface->search, iface->search_len + len);
444                         if (!iface->search)
445                                 goto err;
446
447                         memcpy(&iface->search[iface->search_len], buf, len);
448                         iface->search_len += len;
449                 }
450         }
451
452         if ((c = tb[IFACE_ATTR_RA_DEFAULT]))
453                 iface->default_router = blobmsg_get_u32(c);
454
455         if ((c = tb[IFACE_ATTR_RA_MANAGEMENT]))
456                 iface->managed = blobmsg_get_u32(c);
457         else if (overwrite)
458                 iface->managed = 1;
459
460         if ((c = tb[IFACE_ATTR_RA_OFFLINK]))
461                 iface->ra_not_onlink = blobmsg_get_bool(c);
462
463         if ((c = tb[IFACE_ATTR_RA_PREFERENCE])) {
464                 const char *prio = blobmsg_get_string(c);
465
466                 if (!strcmp(prio, "high"))
467                         iface->route_preference = 1;
468                 else if (!strcmp(prio, "low"))
469                         iface->route_preference = -1;
470                 else if (!strcmp(prio, "medium") || !strcmp(prio, "default"))
471                         iface->route_preference = 0;
472                 else
473                         goto err;
474         }
475
476         if ((c = tb[IFACE_ATTR_NDPROXY_ROUTING]))
477                 iface->learn_routes = blobmsg_get_bool(c);
478         else if (overwrite)
479                 iface->learn_routes = true;
480
481         if ((c = tb[IFACE_ATTR_NDPROXY_SLAVE]))
482                 iface->external = blobmsg_get_bool(c);
483
484         if ((c = tb[IFACE_ATTR_NDPROXY_STATIC])) {
485                 struct blob_attr *cur;
486                 unsigned rem;
487
488                 blobmsg_for_each_attr(cur, c, rem) {
489                         if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, NULL))
490                                 continue;
491
492                         int len = blobmsg_data_len(cur);
493                         iface->static_ndp = realloc(iface->static_ndp, iface->static_ndp_len + len);
494                         if (!iface->static_ndp)
495                                 goto err;
496
497                         if (iface->static_ndp_len)
498                                 iface->static_ndp[iface->static_ndp_len - 1] = ' ';
499
500                         memcpy(&iface->static_ndp[iface->static_ndp_len], blobmsg_get_string(cur), len);
501                         iface->static_ndp_len += len;
502                 }
503         }
504
505         return 0;
506
507 err:
508         close_interface(iface);
509         return -1;
510 }
511
512 static int set_interface(struct uci_section *s)
513 {
514         blob_buf_init(&b, 0);
515         uci_to_blob(&b, s, &interface_attr_list);
516         return config_parse_interface(blob_data(b.head), blob_len(b.head), s->e.name, true);
517 }
518
519
520 void odhcpd_reload(void)
521 {
522         struct uci_context *uci = uci_alloc_context();
523         while (!list_empty(&leases)) {
524                 struct lease *l = list_first_entry(&leases, struct lease, head);
525                 list_del(&l->head);
526                 free(l->duid);
527                 free(l);
528         }
529
530         struct interface *master = NULL, *i, *n;
531
532         if (!uci)
533                 return;
534
535         list_for_each_entry(i, &interfaces, head)
536                 clean_interface(i);
537
538         struct uci_package *dhcp = NULL;
539         if (!uci_load(uci, "dhcp", &dhcp)) {
540                 struct uci_element *e;
541                 uci_foreach_element(&dhcp->sections, e) {
542                         struct uci_section *s = uci_to_section(e);
543                         if (!strcmp(s->type, "host"))
544                                 set_lease(s);
545                         else if (!strcmp(s->type, "odhcpd"))
546                                 set_config(s);
547                 }
548
549                 uci_foreach_element(&dhcp->sections, e) {
550                         struct uci_section *s = uci_to_section(e);
551                         if (!strcmp(s->type, "dhcp"))
552                                 set_interface(s);
553                 }
554         }
555
556
557 #ifdef WITH_UBUS
558         ubus_apply_network();
559 #endif
560
561         bool any_dhcpv6_slave = false, any_ra_slave = false, any_ndp_slave = false;
562
563         // Test for
564         list_for_each_entry(i, &interfaces, head) {
565                 if (i->master)
566                         continue;
567
568                 if (i->dhcpv6 == RELAYD_HYBRID || i->dhcpv6 == RELAYD_RELAY)
569                         any_dhcpv6_slave = true;
570
571                 if (i->ra == RELAYD_HYBRID || i->ra == RELAYD_RELAY)
572                         any_ra_slave = true;
573
574                 if (i->ndp == RELAYD_HYBRID || i->ndp == RELAYD_RELAY)
575                         any_ndp_slave = true;
576         }
577
578         // Evaluate hybrid mode for master
579         list_for_each_entry(i, &interfaces, head) {
580                 if (!i->master)
581                         continue;
582
583                 enum odhcpd_mode hybrid_mode = RELAYD_DISABLED;
584 #ifdef WITH_UBUS
585                 if (!ubus_has_prefix(i->name, i->ifname))
586                         hybrid_mode = RELAYD_RELAY;
587 #endif
588
589                 if (i->dhcpv6 == RELAYD_HYBRID)
590                         i->dhcpv6 = hybrid_mode;
591
592                 if (i->dhcpv6 == RELAYD_RELAY && !any_dhcpv6_slave)
593                         i->dhcpv6 = RELAYD_DISABLED;
594
595                 if (i->ra == RELAYD_HYBRID)
596                         i->ra = hybrid_mode;
597
598                 if (i->ra == RELAYD_RELAY && !any_ra_slave)
599                         i->ra = RELAYD_DISABLED;
600
601                 if (i->ndp == RELAYD_HYBRID)
602                         i->ndp = hybrid_mode;
603
604                 if (i->ndp == RELAYD_RELAY && !any_ndp_slave)
605                         i->ndp = RELAYD_DISABLED;
606
607                 if (i->dhcpv6 == RELAYD_RELAY || i->ra == RELAYD_RELAY || i->ndp == RELAYD_RELAY)
608                         master = i;
609         }
610
611
612         list_for_each_entry_safe(i, n, &interfaces, head) {
613                 if (i->inuse) {
614                         // Resolve hybrid mode
615                         if (i->dhcpv6 == RELAYD_HYBRID)
616                                 i->dhcpv6 = (master && master->dhcpv6 == RELAYD_RELAY) ?
617                                                 RELAYD_RELAY : RELAYD_SERVER;
618
619                         if (i->ra == RELAYD_HYBRID)
620                                 i->ra = (master && master->ra == RELAYD_RELAY) ?
621                                                 RELAYD_RELAY : RELAYD_SERVER;
622
623                         if (i->ndp == RELAYD_HYBRID)
624                                 i->ndp = (master && master->ndp == RELAYD_RELAY) ?
625                                                 RELAYD_RELAY : RELAYD_DISABLED;
626
627                         setup_router_interface(i, true);
628                         setup_dhcpv6_interface(i, true);
629                         setup_ndp_interface(i, true);
630                         setup_dhcpv4_interface(i, true);
631                 } else {
632                         close_interface(i);
633                 }
634         }
635
636         uci_unload(uci, dhcp);
637         uci_free_context(uci);
638 }
639
640
641 static void handle_signal(int signal)
642 {
643         char b[1] = {0};
644         if (signal == SIGHUP)
645                 write(reload_pipe[1], b, sizeof(b));
646         else
647                 uloop_end();
648 }
649
650
651
652 static void reload_cb(struct uloop_fd *u, _unused unsigned int events)
653 {
654         char b[512];
655         read(u->fd, b, sizeof(b));
656         odhcpd_reload();
657 }
658
659 static struct uloop_fd reload_fd = { .cb = reload_cb };
660
661 void odhcpd_run(void)
662 {
663         pipe2(reload_pipe, O_NONBLOCK | O_CLOEXEC);
664         reload_fd.fd = reload_pipe[0];
665         uloop_fd_add(&reload_fd, ULOOP_READ);
666
667         signal(SIGTERM, handle_signal);
668         signal(SIGINT, handle_signal);
669         signal(SIGHUP, handle_signal);
670
671 #ifdef WITH_UBUS
672         while (init_ubus())
673                 sleep(1);
674 #endif
675
676         odhcpd_reload();
677         uloop_run();
678 }
679