router: use enum to specify order and index of iov struct
[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 #include <libgen.h>
7 #include <net/if.h>
8 #include <string.h>
9 #include <sys/stat.h>
10 #include <syslog.h>
11
12 #include <uci.h>
13 #include <uci_blob.h>
14 #include <libubox/utils.h>
15
16 #include "odhcpd.h"
17
18 static struct blob_buf b;
19 static int reload_pipe[2];
20 struct list_head leases = LIST_HEAD_INIT(leases);
21 struct list_head interfaces = LIST_HEAD_INIT(interfaces);
22 struct config config = {.legacy = false, .main_dhcpv4 = false,
23                         .dhcp_cb = NULL, .dhcp_statefile = NULL,
24                         .log_level = LOG_INFO};
25
26 enum {
27         IFACE_ATTR_INTERFACE,
28         IFACE_ATTR_IFNAME,
29         IFACE_ATTR_NETWORKID,
30         IFACE_ATTR_DYNAMICDHCP,
31         IFACE_ATTR_IGNORE,
32         IFACE_ATTR_LEASETIME,
33         IFACE_ATTR_LIMIT,
34         IFACE_ATTR_START,
35         IFACE_ATTR_MASTER,
36         IFACE_ATTR_UPSTREAM,
37         IFACE_ATTR_RA,
38         IFACE_ATTR_DHCPV4,
39         IFACE_ATTR_DHCPV6,
40         IFACE_ATTR_NDP,
41         IFACE_ATTR_ROUTER,
42         IFACE_ATTR_DNS,
43         IFACE_ATTR_DOMAIN,
44         IFACE_ATTR_FILTER_CLASS,
45         IFACE_ATTR_DHCPV6_RAW,
46         IFACE_ATTR_RA_DEFAULT,
47         IFACE_ATTR_RA_MANAGEMENT,
48         IFACE_ATTR_RA_OFFLINK,
49         IFACE_ATTR_RA_PREFERENCE,
50         IFACE_ATTR_RA_ADVROUTER,
51         IFACE_ATTR_RA_MININTERVAL,
52         IFACE_ATTR_RA_MAXINTERVAL,
53         IFACE_ATTR_RA_LIFETIME,
54         IFACE_ATTR_RA_USELEASETIME,
55         IFACE_ATTR_RA_REACHABLETIME,
56         IFACE_ATTR_RA_RETRANSTIME,
57         IFACE_ATTR_RA_HOPLIMIT,
58         IFACE_ATTR_RA_MTU,
59         IFACE_ATTR_PD_MANAGER,
60         IFACE_ATTR_PD_CER,
61         IFACE_ATTR_NDPROXY_ROUTING,
62         IFACE_ATTR_NDPROXY_SLAVE,
63         IFACE_ATTR_MAX
64 };
65
66 static const struct blobmsg_policy iface_attrs[IFACE_ATTR_MAX] = {
67         [IFACE_ATTR_INTERFACE] = { .name = "interface", .type = BLOBMSG_TYPE_STRING },
68         [IFACE_ATTR_IFNAME] = { .name = "ifname", .type = BLOBMSG_TYPE_STRING },
69         [IFACE_ATTR_NETWORKID] = { .name = "networkid", .type = BLOBMSG_TYPE_STRING },
70         [IFACE_ATTR_DYNAMICDHCP] = { .name = "dynamicdhcp", .type = BLOBMSG_TYPE_BOOL },
71         [IFACE_ATTR_IGNORE] = { .name = "ignore", .type = BLOBMSG_TYPE_BOOL },
72         [IFACE_ATTR_LEASETIME] = { .name = "leasetime", .type = BLOBMSG_TYPE_STRING },
73         [IFACE_ATTR_START] = { .name = "start", .type = BLOBMSG_TYPE_INT32 },
74         [IFACE_ATTR_LIMIT] = { .name = "limit", .type = BLOBMSG_TYPE_INT32 },
75         [IFACE_ATTR_MASTER] = { .name = "master", .type = BLOBMSG_TYPE_BOOL },
76         [IFACE_ATTR_UPSTREAM] = { .name = "upstream", .type = BLOBMSG_TYPE_ARRAY },
77         [IFACE_ATTR_RA] = { .name = "ra", .type = BLOBMSG_TYPE_STRING },
78         [IFACE_ATTR_DHCPV4] = { .name = "dhcpv4", .type = BLOBMSG_TYPE_STRING },
79         [IFACE_ATTR_DHCPV6] = { .name = "dhcpv6", .type = BLOBMSG_TYPE_STRING },
80         [IFACE_ATTR_NDP] = { .name = "ndp", .type = BLOBMSG_TYPE_STRING },
81         [IFACE_ATTR_ROUTER] = { .name = "router", .type = BLOBMSG_TYPE_ARRAY },
82         [IFACE_ATTR_DNS] = { .name = "dns", .type = BLOBMSG_TYPE_ARRAY },
83         [IFACE_ATTR_DOMAIN] = { .name = "domain", .type = BLOBMSG_TYPE_ARRAY },
84         [IFACE_ATTR_FILTER_CLASS] = { .name = "filter_class", .type = BLOBMSG_TYPE_STRING },
85         [IFACE_ATTR_DHCPV6_RAW] = { .name = "dhcpv6_raw", .type = BLOBMSG_TYPE_STRING },
86         [IFACE_ATTR_PD_MANAGER] = { .name = "pd_manager", .type = BLOBMSG_TYPE_STRING },
87         [IFACE_ATTR_PD_CER] = { .name = "pd_cer", .type = BLOBMSG_TYPE_STRING },
88         [IFACE_ATTR_RA_DEFAULT] = { .name = "ra_default", .type = BLOBMSG_TYPE_INT32 },
89         [IFACE_ATTR_RA_MANAGEMENT] = { .name = "ra_management", .type = BLOBMSG_TYPE_INT32 },
90         [IFACE_ATTR_RA_OFFLINK] = { .name = "ra_offlink", .type = BLOBMSG_TYPE_BOOL },
91         [IFACE_ATTR_RA_PREFERENCE] = { .name = "ra_preference", .type = BLOBMSG_TYPE_STRING },
92         [IFACE_ATTR_RA_ADVROUTER] = { .name = "ra_advrouter", .type = BLOBMSG_TYPE_BOOL },
93         [IFACE_ATTR_RA_MININTERVAL] = { .name = "ra_mininterval", .type = BLOBMSG_TYPE_INT32 },
94         [IFACE_ATTR_RA_MAXINTERVAL] = { .name = "ra_maxinterval", .type = BLOBMSG_TYPE_INT32 },
95         [IFACE_ATTR_RA_LIFETIME] = { .name = "ra_lifetime", .type = BLOBMSG_TYPE_INT32 },
96         [IFACE_ATTR_RA_USELEASETIME] = { .name = "ra_useleasetime", .type = BLOBMSG_TYPE_BOOL },
97         [IFACE_ATTR_RA_REACHABLETIME] = { .name = "ra_reachabletime", .type = BLOBMSG_TYPE_INT32 },
98         [IFACE_ATTR_RA_RETRANSTIME] = { .name = "ra_retranstime", .type = BLOBMSG_TYPE_INT32 },
99         [IFACE_ATTR_RA_HOPLIMIT] = { .name = "ra_hoplimit", .type = BLOBMSG_TYPE_INT32 },
100         [IFACE_ATTR_RA_MTU] = { .name = "ra_mtu", .type = BLOBMSG_TYPE_INT32 },
101         [IFACE_ATTR_NDPROXY_ROUTING] = { .name = "ndproxy_routing", .type = BLOBMSG_TYPE_BOOL },
102         [IFACE_ATTR_NDPROXY_SLAVE] = { .name = "ndproxy_slave", .type = BLOBMSG_TYPE_BOOL },
103 };
104
105 static const struct uci_blob_param_info iface_attr_info[IFACE_ATTR_MAX] = {
106         [IFACE_ATTR_UPSTREAM] = { .type = BLOBMSG_TYPE_STRING },
107         [IFACE_ATTR_DNS] = { .type = BLOBMSG_TYPE_STRING },
108         [IFACE_ATTR_DOMAIN] = { .type = BLOBMSG_TYPE_STRING },
109 };
110
111 const struct uci_blob_param_list interface_attr_list = {
112         .n_params = IFACE_ATTR_MAX,
113         .params = iface_attrs,
114         .info = iface_attr_info,
115 };
116
117 enum {
118         LEASE_ATTR_IP,
119         LEASE_ATTR_MAC,
120         LEASE_ATTR_DUID,
121         LEASE_ATTR_HOSTID,
122         LEASE_ATTR_LEASETIME,
123         LEASE_ATTR_NAME,
124         LEASE_ATTR_MAX
125 };
126
127 static const struct blobmsg_policy lease_attrs[LEASE_ATTR_MAX] = {
128         [LEASE_ATTR_IP] = { .name = "ip", .type = BLOBMSG_TYPE_STRING },
129         [LEASE_ATTR_MAC] = { .name = "mac", .type = BLOBMSG_TYPE_STRING },
130         [LEASE_ATTR_DUID] = { .name = "duid", .type = BLOBMSG_TYPE_STRING },
131         [LEASE_ATTR_HOSTID] = { .name = "hostid", .type = BLOBMSG_TYPE_STRING },
132         [LEASE_ATTR_LEASETIME] = { .name = "leasetime", .type = BLOBMSG_TYPE_STRING },
133         [LEASE_ATTR_NAME] = { .name = "name", .type = BLOBMSG_TYPE_STRING },
134 };
135
136 const struct uci_blob_param_list lease_attr_list = {
137         .n_params = LEASE_ATTR_MAX,
138         .params = lease_attrs,
139 };
140
141 enum {
142         ODHCPD_ATTR_LEGACY,
143         ODHCPD_ATTR_MAINDHCP,
144         ODHCPD_ATTR_LEASEFILE,
145         ODHCPD_ATTR_LEASETRIGGER,
146         ODHCPD_ATTR_LOGLEVEL,
147         ODHCPD_ATTR_MAX
148 };
149
150 static const struct blobmsg_policy odhcpd_attrs[LEASE_ATTR_MAX] = {
151         [ODHCPD_ATTR_LEGACY] = { .name = "legacy", .type = BLOBMSG_TYPE_BOOL },
152         [ODHCPD_ATTR_MAINDHCP] = { .name = "maindhcp", .type = BLOBMSG_TYPE_BOOL },
153         [ODHCPD_ATTR_LEASEFILE] = { .name = "leasefile", .type = BLOBMSG_TYPE_STRING },
154         [ODHCPD_ATTR_LEASETRIGGER] = { .name = "leasetrigger", .type = BLOBMSG_TYPE_STRING },
155         [ODHCPD_ATTR_LOGLEVEL] = { .name = "loglevel", .type = BLOBMSG_TYPE_INT32 },
156 };
157
158 const struct uci_blob_param_list odhcpd_attr_list = {
159         .n_params = ODHCPD_ATTR_MAX,
160         .params = odhcpd_attrs,
161 };
162
163 static int mkdir_p(char *dir, mode_t mask)
164 {
165         char *l = strrchr(dir, '/');
166         int ret;
167
168         if (!l)
169                 return 0;
170
171         *l = '\0';
172
173         if (mkdir_p(dir, mask))
174                 return -1;
175
176         *l = '/';
177
178         ret = mkdir(dir, mask);
179         if (ret && errno == EEXIST)
180                 return 0;
181
182         if (ret)
183                 syslog(LOG_ERR, "mkdir(%s, %d) failed: %s\n", dir, mask, strerror(errno));
184
185         return ret;
186 }
187
188 static void free_lease(struct lease *l)
189 {
190         if (l->head.next)
191                 list_del(&l->head);
192
193         free(l->duid);
194         free(l);
195 }
196
197 static struct interface* get_interface(const char *name)
198 {
199         struct interface *c;
200         list_for_each_entry(c, &interfaces, head)
201                 if (!strcmp(c->name, name))
202                         return c;
203         return NULL;
204 }
205
206 static void set_interface_defaults(struct interface *iface)
207 {
208         iface->managed = 1;
209         iface->learn_routes = 1;
210         iface->dhcpv4_leasetime = 43200;
211         iface->ra_maxinterval = 600;
212         iface->ra_mininterval = iface->ra_maxinterval/3;
213         iface->ra_lifetime = -1;
214 }
215
216 static void clean_interface(struct interface *iface)
217 {
218         free(iface->dns);
219         free(iface->search);
220         free(iface->upstream);
221         free(iface->dhcpv4_router);
222         free(iface->dhcpv4_dns);
223         free(iface->dhcpv6_raw);
224         free(iface->filter_class);
225         memset(&iface->ra, 0, sizeof(*iface) - offsetof(struct interface, ra));
226         set_interface_defaults(iface);
227 }
228
229 static void close_interface(struct interface *iface)
230 {
231         if (iface->head.next)
232                 list_del(&iface->head);
233
234         setup_router_interface(iface, false);
235         setup_dhcpv6_interface(iface, false);
236         setup_ndp_interface(iface, false);
237         setup_dhcpv4_interface(iface, false);
238
239         clean_interface(iface);
240         free(iface->ia_addr);
241         free(iface->ifname);
242         free(iface);
243 }
244
245 static int parse_mode(const char *mode)
246 {
247         if (!strcmp(mode, "disabled"))
248                 return RELAYD_DISABLED;
249         else if (!strcmp(mode, "server"))
250                 return RELAYD_SERVER;
251         else if (!strcmp(mode, "relay"))
252                 return RELAYD_RELAY;
253         else if (!strcmp(mode, "hybrid"))
254                 return RELAYD_HYBRID;
255         else
256                 return -1;
257 }
258
259 static void set_config(struct uci_section *s)
260 {
261         struct blob_attr *tb[ODHCPD_ATTR_MAX], *c;
262
263         blob_buf_init(&b, 0);
264         uci_to_blob(&b, s, &odhcpd_attr_list);
265         blobmsg_parse(odhcpd_attrs, ODHCPD_ATTR_MAX, tb, blob_data(b.head), blob_len(b.head));
266
267         if ((c = tb[ODHCPD_ATTR_LEGACY]))
268                 config.legacy = blobmsg_get_bool(c);
269
270         if ((c = tb[ODHCPD_ATTR_MAINDHCP]))
271                 config.main_dhcpv4 = blobmsg_get_bool(c);
272
273         if ((c = tb[ODHCPD_ATTR_LEASEFILE])) {
274                 free(config.dhcp_statefile);
275                 config.dhcp_statefile = strdup(blobmsg_get_string(c));
276         }
277
278         if ((c = tb[ODHCPD_ATTR_LEASETRIGGER])) {
279                 free(config.dhcp_cb);
280                 config.dhcp_cb = strdup(blobmsg_get_string(c));
281         }
282
283         if ((c = tb[ODHCPD_ATTR_LOGLEVEL])) {
284                 int log_level = (blobmsg_get_u32(c) & LOG_PRIMASK);
285
286                 if (config.log_level != log_level) {
287                         config.log_level = log_level;
288                         setlogmask(LOG_UPTO(config.log_level));
289                 }
290         }
291 }
292
293 static double parse_leasetime(struct blob_attr *c) {
294         char *val = blobmsg_get_string(c), *endptr = NULL;
295         double time = strcmp(val, "infinite") ? strtod(val, &endptr) : UINT32_MAX;
296
297         if (time && endptr && endptr[0]) {
298                 if (endptr[0] == 's')
299                         time *= 1;
300                 else if (endptr[0] == 'm')
301                         time *= 60;
302                 else if (endptr[0] == 'h')
303                         time *= 3600;
304                 else if (endptr[0] == 'd')
305                         time *= 24 * 3600;
306                 else if (endptr[0] == 'w')
307                         time *= 7 * 24 * 3600;
308                 else
309                         goto err;
310         }
311
312         if (time < 60)
313                 time = 60;
314
315         return time;
316
317 err:
318         return -1;
319 }
320
321 static int set_lease(struct uci_section *s)
322 {
323         struct blob_attr *tb[LEASE_ATTR_MAX], *c;
324
325         blob_buf_init(&b, 0);
326         uci_to_blob(&b, s, &lease_attr_list);
327         blobmsg_parse(lease_attrs, LEASE_ATTR_MAX, tb, blob_data(b.head), blob_len(b.head));
328
329         size_t hostlen = 1;
330         if ((c = tb[LEASE_ATTR_NAME]))
331                 hostlen = blobmsg_data_len(c);
332
333         struct lease *lease = calloc(1, sizeof(*lease) + hostlen);
334         if (!lease)
335                 goto err;
336
337         if (hostlen > 1)
338                 memcpy(lease->hostname, blobmsg_get_string(c), hostlen);
339
340         if ((c = tb[LEASE_ATTR_IP]))
341                 if (inet_pton(AF_INET, blobmsg_get_string(c), &lease->ipaddr) < 0)
342                         goto err;
343
344         if ((c = tb[LEASE_ATTR_MAC]))
345                 if (!ether_aton_r(blobmsg_get_string(c), &lease->mac))
346                         goto err;
347
348         if ((c = tb[LEASE_ATTR_DUID])) {
349                 size_t duidlen = (blobmsg_data_len(c) - 1) / 2;
350                 lease->duid = malloc(duidlen);
351                 if (!lease->duid)
352                         goto err;
353
354                 ssize_t len = odhcpd_unhexlify(lease->duid,
355                                 duidlen, blobmsg_get_string(c));
356
357                 if (len < 0)
358                         goto err;
359
360                 lease->duid_len = len;
361         }
362
363         if ((c = tb[LEASE_ATTR_HOSTID])) {
364                 errno = 0;
365                 lease->hostid = strtoul(blobmsg_get_string(c), NULL, 16);
366                 if (errno)
367                         goto err;
368         }
369
370         if ((c = tb[LEASE_ATTR_LEASETIME])) {
371                 double time = parse_leasetime(c);
372                 if (time < 0)
373                         goto err;
374
375                 lease->dhcpv4_leasetime = time;
376         }
377
378         list_add(&lease->head, &leases);
379         return 0;
380
381 err:
382         if (lease)
383                 free_lease(lease);
384
385         return -1;
386 }
387
388 int config_parse_interface(void *data, size_t len, const char *name, bool overwrite)
389 {
390         struct blob_attr *tb[IFACE_ATTR_MAX], *c;
391         blobmsg_parse(iface_attrs, IFACE_ATTR_MAX, tb, data, len);
392
393         if (tb[IFACE_ATTR_INTERFACE])
394                 name = blobmsg_get_string(tb[IFACE_ATTR_INTERFACE]);
395
396         if (!name)
397                 return -1;
398
399         struct interface *iface = get_interface(name);
400         if (!iface) {
401                 char *iface_name;
402
403                 iface = calloc_a(sizeof(*iface), &iface_name, strlen(name) + 1);
404                 if (!iface)
405                         return -1;
406
407                 iface->name = strcpy(iface_name, name);
408
409                 set_interface_defaults(iface);
410
411                 list_add(&iface->head, &interfaces);
412                 overwrite = true;
413         }
414
415         const char *ifname = NULL;
416         if (overwrite) {
417                 if ((c = tb[IFACE_ATTR_IFNAME]))
418                         ifname = blobmsg_get_string(c);
419                 else if ((c = tb[IFACE_ATTR_NETWORKID]))
420                         ifname = blobmsg_get_string(c);
421         }
422
423 #ifdef WITH_UBUS
424         if (overwrite || !iface->ifname)
425                 ifname = ubus_get_ifname(name);
426 #endif
427
428         if (!iface->ifname && !ifname)
429                 goto err;
430
431         if (ifname) {
432                 free(iface->ifname);
433                 iface->ifname = strdup(ifname);
434
435                 if (!iface->ifname)
436                         goto err;
437         }
438
439         if ((iface->ifindex = if_nametoindex(iface->ifname)) <= 0)
440                 goto err;
441
442         iface->inuse = true;
443
444         if ((c = tb[IFACE_ATTR_DYNAMICDHCP]))
445                 iface->no_dynamic_dhcp = !blobmsg_get_bool(c);
446
447         if (overwrite && (c = tb[IFACE_ATTR_IGNORE]))
448                 iface->ignore = blobmsg_get_bool(c);
449
450         if ((c = tb[IFACE_ATTR_LEASETIME])) {
451                 double time = parse_leasetime(c);
452                 if (time < 0)
453                         goto err;
454
455                 iface->dhcpv4_leasetime = time;
456         }
457
458         if ((c = tb[IFACE_ATTR_START])) {
459                 iface->dhcpv4_start.s_addr = htonl(blobmsg_get_u32(c));
460
461                 if (config.main_dhcpv4 && config.legacy)
462                         iface->dhcpv4 = RELAYD_SERVER;
463         }
464
465         if ((c = tb[IFACE_ATTR_LIMIT]))
466                 iface->dhcpv4_end.s_addr = htonl(
467                                 ntohl(iface->dhcpv4_start.s_addr) + blobmsg_get_u32(c));
468
469         if ((c = tb[IFACE_ATTR_MASTER]))
470                 iface->master = blobmsg_get_bool(c);
471
472         if (overwrite && (c = tb[IFACE_ATTR_UPSTREAM])) {
473                 struct blob_attr *cur;
474                 unsigned rem;
475
476                 blobmsg_for_each_attr(cur, c, rem) {
477                         if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
478                                 continue;
479
480                         iface->upstream = realloc(iface->upstream,
481                                         iface->upstream_len + blobmsg_data_len(cur));
482                         if (!iface->upstream)
483                                 goto err;
484
485                         memcpy(iface->upstream + iface->upstream_len, blobmsg_get_string(cur), blobmsg_data_len(cur));
486                         iface->upstream_len += blobmsg_data_len(cur);
487                 }
488         }
489
490         int mode;
491         if ((c = tb[IFACE_ATTR_RA])) {
492                 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0)
493                         iface->ra = mode;
494                 else
495                         goto err;
496         }
497
498         if ((c = tb[IFACE_ATTR_DHCPV4])) {
499                 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0) {
500                         if (config.main_dhcpv4)
501                                 iface->dhcpv4 = mode;
502                 }
503                 else
504                         goto err;
505         }
506
507         if ((c = tb[IFACE_ATTR_DHCPV6])) {
508                 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0)
509                         iface->dhcpv6 = mode;
510                 else
511                         goto err;
512         }
513
514         if ((c = tb[IFACE_ATTR_NDP])) {
515                 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0)
516                         iface->ndp = mode;
517                 else
518                         goto err;
519         }
520
521         if ((c = tb[IFACE_ATTR_ROUTER])) {
522                 struct blob_attr *cur;
523                 unsigned rem;
524
525                 blobmsg_for_each_attr(cur, c, rem) {
526                         if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
527                                 continue;
528
529                         struct in_addr addr4;
530                         if (inet_pton(AF_INET, blobmsg_get_string(cur), &addr4) == 1) {
531                                 iface->dhcpv4_router = realloc(iface->dhcpv4_router,
532                                                 (++iface->dhcpv4_router_cnt) * sizeof(*iface->dhcpv4_router));
533                                 if (!iface->dhcpv4_router)
534                                         goto err;
535
536                                 iface->dhcpv4_router[iface->dhcpv4_router_cnt - 1] = addr4;
537                         } else
538                                 goto err;
539                 }
540         }
541
542         if ((c = tb[IFACE_ATTR_DNS])) {
543                 struct blob_attr *cur;
544                 unsigned rem;
545
546                 iface->always_rewrite_dns = true;
547                 blobmsg_for_each_attr(cur, c, rem) {
548                         if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
549                                 continue;
550
551                         struct in_addr addr4;
552                         struct in6_addr addr6;
553                         if (inet_pton(AF_INET, blobmsg_get_string(cur), &addr4) == 1) {
554                                 iface->dhcpv4_dns = realloc(iface->dhcpv4_dns,
555                                                 (++iface->dhcpv4_dns_cnt) * sizeof(*iface->dhcpv4_dns));
556                                 if (!iface->dhcpv4_dns)
557                                         goto err;
558
559                                 iface->dhcpv4_dns[iface->dhcpv4_dns_cnt - 1] = addr4;
560                         } else if (inet_pton(AF_INET6, blobmsg_get_string(cur), &addr6) == 1) {
561                                 iface->dns = realloc(iface->dns,
562                                                 (++iface->dns_cnt) * sizeof(*iface->dns));
563                                 if (!iface->dns)
564                                         goto err;
565
566                                 iface->dns[iface->dns_cnt - 1] = addr6;
567                         } else
568                                 goto err;
569                 }
570         }
571
572         if ((c = tb[IFACE_ATTR_DOMAIN])) {
573                 struct blob_attr *cur;
574                 unsigned rem;
575
576                 blobmsg_for_each_attr(cur, c, rem) {
577                         if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
578                                 continue;
579
580                         uint8_t buf[256];
581                         char *domain = blobmsg_get_string(cur);
582                         size_t domainlen = strlen(domain);
583                         if (domainlen > 0 && domain[domainlen - 1] == '.')
584                                 domain[domainlen - 1] = 0;
585
586                         int len = dn_comp(domain, buf, sizeof(buf), NULL, NULL);
587                         if (len <= 0)
588                                 goto err;
589
590                         iface->search = realloc(iface->search, iface->search_len + len);
591                         if (!iface->search)
592                                 goto err;
593
594                         memcpy(&iface->search[iface->search_len], buf, len);
595                         iface->search_len += len;
596                 }
597         }
598
599         if ((c = tb[IFACE_ATTR_FILTER_CLASS])) {
600                 iface->filter_class = realloc(iface->filter_class, blobmsg_data_len(c) + 1);
601                 memcpy(iface->filter_class, blobmsg_get_string(c), blobmsg_data_len(c) + 1);
602         }
603
604         if ((c = tb[IFACE_ATTR_DHCPV6_RAW])) {
605                 iface->dhcpv6_raw_len = blobmsg_data_len(c) / 2;
606                 iface->dhcpv6_raw = realloc(iface->dhcpv6_raw, iface->dhcpv6_raw_len);
607                 odhcpd_unhexlify(iface->dhcpv6_raw, iface->dhcpv6_raw_len, blobmsg_get_string(c));
608         }
609
610         if ((c = tb[IFACE_ATTR_RA_DEFAULT]))
611                 iface->default_router = blobmsg_get_u32(c);
612
613         if ((c = tb[IFACE_ATTR_RA_MANAGEMENT]))
614                 iface->managed = blobmsg_get_u32(c);
615
616         if ((c = tb[IFACE_ATTR_RA_REACHABLETIME])) {
617                 uint32_t ra_reachabletime = blobmsg_get_u32(c);
618                 if (ra_reachabletime > 3600000)
619                         goto err;
620
621                 iface->ra_reachabletime = ra_reachabletime;
622         }
623
624         if ((c = tb[IFACE_ATTR_RA_RETRANSTIME])) {
625                 uint32_t ra_retranstime = blobmsg_get_u32(c);
626                 if (ra_retranstime > 60000)
627                         goto err;
628
629                 iface->ra_retranstime = ra_retranstime;
630         }
631
632         if ((c = tb[IFACE_ATTR_RA_HOPLIMIT])) {
633                 uint32_t ra_hoplimit = blobmsg_get_u32(c);
634                 if (ra_hoplimit > 255)
635                         goto err;
636
637                 iface->ra_hoplimit = ra_hoplimit;
638         }
639
640         if ((c = tb[IFACE_ATTR_RA_MTU])) {
641                 uint32_t ra_mtu = blobmsg_get_u32(c);
642                 if (ra_mtu < 1280 || ra_mtu > 65535)
643                         goto err;
644
645                 iface->ra_mtu = ra_mtu;
646         }
647
648         if ((c = tb[IFACE_ATTR_RA_OFFLINK]))
649                 iface->ra_not_onlink = blobmsg_get_bool(c);
650
651         if ((c = tb[IFACE_ATTR_RA_ADVROUTER]))
652                 iface->ra_advrouter = blobmsg_get_bool(c);
653
654         if ((c = tb[IFACE_ATTR_RA_MININTERVAL]))
655                 iface->ra_mininterval =  blobmsg_get_u32(c);
656
657         if ((c = tb[IFACE_ATTR_RA_MAXINTERVAL]))
658                 iface->ra_maxinterval = blobmsg_get_u32(c);
659
660         if ((c = tb[IFACE_ATTR_RA_LIFETIME]))
661                 iface->ra_lifetime = blobmsg_get_u32(c);
662
663         if ((c = tb[IFACE_ATTR_RA_USELEASETIME]))
664                 iface->ra_useleasetime = blobmsg_get_bool(c);
665
666         if ((c = tb[IFACE_ATTR_RA_PREFERENCE])) {
667                 const char *prio = blobmsg_get_string(c);
668
669                 if (!strcmp(prio, "high"))
670                         iface->route_preference = 1;
671                 else if (!strcmp(prio, "low"))
672                         iface->route_preference = -1;
673                 else if (!strcmp(prio, "medium") || !strcmp(prio, "default"))
674                         iface->route_preference = 0;
675                 else
676                         goto err;
677         }
678
679         if ((c = tb[IFACE_ATTR_PD_MANAGER]))
680                 strncpy(iface->dhcpv6_pd_manager, blobmsg_get_string(c),
681                                 sizeof(iface->dhcpv6_pd_manager) - 1);
682
683         if ((c = tb[IFACE_ATTR_PD_CER]) &&
684                         inet_pton(AF_INET6, blobmsg_get_string(c), &iface->dhcpv6_pd_cer) < 1)
685                 goto err;
686
687         if ((c = tb[IFACE_ATTR_NDPROXY_ROUTING]))
688                 iface->learn_routes = blobmsg_get_bool(c);
689
690         if ((c = tb[IFACE_ATTR_NDPROXY_SLAVE]))
691                 iface->external = blobmsg_get_bool(c);
692
693         return 0;
694
695 err:
696         close_interface(iface);
697         return -1;
698 }
699
700 static int set_interface(struct uci_section *s)
701 {
702         blob_buf_init(&b, 0);
703         uci_to_blob(&b, s, &interface_attr_list);
704
705         return config_parse_interface(blob_data(b.head), blob_len(b.head), s->e.name, true);
706 }
707
708 void odhcpd_reload(void)
709 {
710         struct uci_context *uci = uci_alloc_context();
711
712         while (!list_empty(&leases))
713                 free_lease(list_first_entry(&leases, struct lease, head));
714
715         struct interface *master = NULL, *i, *n;
716
717         if (!uci)
718                 return;
719
720         list_for_each_entry(i, &interfaces, head)
721                 clean_interface(i);
722
723         struct uci_package *dhcp = NULL;
724         if (!uci_load(uci, "dhcp", &dhcp)) {
725                 struct uci_element *e;
726                 uci_foreach_element(&dhcp->sections, e) {
727                         struct uci_section *s = uci_to_section(e);
728                         if (!strcmp(s->type, "host"))
729                                 set_lease(s);
730                         else if (!strcmp(s->type, "odhcpd"))
731                                 set_config(s);
732                 }
733
734                 uci_foreach_element(&dhcp->sections, e) {
735                         struct uci_section *s = uci_to_section(e);
736                         if (!strcmp(s->type, "dhcp"))
737                                 set_interface(s);
738                 }
739         }
740
741         if (config.dhcp_statefile) {
742                 char *path = strdup(config.dhcp_statefile);
743
744                 mkdir_p(dirname(path), 0755);
745                 free(path);
746         }
747
748 #ifdef WITH_UBUS
749         ubus_apply_network();
750 #endif
751
752         bool any_dhcpv6_slave = false, any_ra_slave = false, any_ndp_slave = false;
753
754         /* Test for */
755         list_for_each_entry(i, &interfaces, head) {
756                 if (i->master)
757                         continue;
758
759                 if (i->dhcpv6 == RELAYD_HYBRID || i->dhcpv6 == RELAYD_RELAY)
760                         any_dhcpv6_slave = true;
761
762                 if (i->ra == RELAYD_HYBRID || i->ra == RELAYD_RELAY)
763                         any_ra_slave = true;
764
765                 if (i->ndp == RELAYD_HYBRID || i->ndp == RELAYD_RELAY)
766                         any_ndp_slave = true;
767         }
768
769         /* Evaluate hybrid mode for master */
770         list_for_each_entry(i, &interfaces, head) {
771                 if (!i->master)
772                         continue;
773
774                 enum odhcpd_mode hybrid_mode = RELAYD_DISABLED;
775 #ifdef WITH_UBUS
776                 if (!ubus_has_prefix(i->name, i->ifname))
777                         hybrid_mode = RELAYD_RELAY;
778 #endif
779
780                 if (i->dhcpv6 == RELAYD_HYBRID)
781                         i->dhcpv6 = hybrid_mode;
782
783                 if (i->dhcpv6 == RELAYD_RELAY && !any_dhcpv6_slave)
784                         i->dhcpv6 = RELAYD_DISABLED;
785
786                 if (i->ra == RELAYD_HYBRID)
787                         i->ra = hybrid_mode;
788
789                 if (i->ra == RELAYD_RELAY && !any_ra_slave)
790                         i->ra = RELAYD_DISABLED;
791
792                 if (i->ndp == RELAYD_HYBRID)
793                         i->ndp = hybrid_mode;
794
795                 if (i->ndp == RELAYD_RELAY && !any_ndp_slave)
796                         i->ndp = RELAYD_DISABLED;
797
798                 if (i->dhcpv6 == RELAYD_RELAY || i->ra == RELAYD_RELAY || i->ndp == RELAYD_RELAY)
799                         master = i;
800         }
801
802
803         list_for_each_entry_safe(i, n, &interfaces, head) {
804                 if (i->inuse) {
805                         /* Resolve hybrid mode */
806                         if (i->dhcpv6 == RELAYD_HYBRID)
807                                 i->dhcpv6 = (master && master->dhcpv6 == RELAYD_RELAY) ?
808                                                 RELAYD_RELAY : RELAYD_SERVER;
809
810                         if (i->ra == RELAYD_HYBRID)
811                                 i->ra = (master && master->ra == RELAYD_RELAY) ?
812                                                 RELAYD_RELAY : RELAYD_SERVER;
813
814                         if (i->ndp == RELAYD_HYBRID)
815                                 i->ndp = (master && master->ndp == RELAYD_RELAY) ?
816                                                 RELAYD_RELAY : RELAYD_DISABLED;
817
818                         setup_router_interface(i, !i->ignore || i->ra != RELAYD_DISABLED);
819                         setup_dhcpv6_interface(i, !i->ignore || i->dhcpv6 != RELAYD_DISABLED);
820                         setup_ndp_interface(i, !i->ignore || i->ndp != RELAYD_DISABLED);
821                         setup_dhcpv4_interface(i, !i->ignore || i->dhcpv4 != RELAYD_DISABLED);
822                 } else
823                         close_interface(i);
824         }
825
826         ndp_handle_addr6_dump();
827         uci_unload(uci, dhcp);
828         uci_free_context(uci);
829 }
830
831 static void handle_signal(int signal)
832 {
833         char b[1] = {0};
834
835         if (signal == SIGHUP) {
836                 if (write(reload_pipe[1], b, sizeof(b)) < 0) {}
837         } else
838                 uloop_end();
839 }
840
841 static void reload_cb(struct uloop_fd *u, _unused unsigned int events)
842 {
843         char b[512];
844         if (read(u->fd, b, sizeof(b)) < 0) {}
845
846         odhcpd_reload();
847 }
848
849 static struct uloop_fd reload_fd = { .cb = reload_cb };
850
851 void odhcpd_run(void)
852 {
853         if (pipe2(reload_pipe, O_NONBLOCK | O_CLOEXEC) < 0) {}
854
855         reload_fd.fd = reload_pipe[0];
856         uloop_fd_add(&reload_fd, ULOOP_READ);
857
858         signal(SIGTERM, handle_signal);
859         signal(SIGINT, handle_signal);
860         signal(SIGHUP, handle_signal);
861
862 #ifdef WITH_UBUS
863         while (init_ubus())
864                 sleep(1);
865 #endif
866
867         odhcpd_reload();
868         uloop_run();
869
870         while (!list_empty(&interfaces))
871                 close_interface(list_first_entry(&interfaces, struct interface, head));
872 }
873