projects / project / odhcpd.git / blob
? search:


30fdc309bbb9f03c8579a70deb5378e0be048c4f
[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 #include <libubox/avl.h>
16 #include <libubox/avl-cmp.h>
17 #include <libubox/list.h>
18 #include <libubox/vlist.h>
19
20 #include "odhcpd.h"
21
22 static struct blob_buf b;
23 static int reload_pipe[2] = { -1, -1 };
24
25 static int lease_cmp(const void *k1, const void *k2, void *ptr);
26 static void lease_update(struct vlist_tree *tree, struct vlist_node *node_new,
27 struct vlist_node *node_old);
28
29 struct vlist_tree leases = VLIST_TREE_INIT(leases, lease_cmp, lease_update, true, false);
30 AVL_TREE(interfaces, avl_strcmp, false, NULL);
31 struct config config = {.legacy = false, .main_dhcpv4 = false,
32 .dhcp_cb = NULL, .dhcp_statefile = NULL,
33 .log_level = LOG_WARNING};
34
35 #define START_DEFAULT 100
36 #define LIMIT_DEFAULT 150
37
38 #define HOSTID_LEN_MIN 12
39 #define HOSTID_LEN_MAX 64
40 #define HOSTID_LEN_DEFAULT HOSTID_LEN_MIN
41
42 #define OAF_DHCPV6 (OAF_DHCPV6_NA | OAF_DHCPV6_PD)
43
44 enum {
45 IFACE_ATTR_INTERFACE,
46 IFACE_ATTR_IFNAME,
47 IFACE_ATTR_NETWORKID,
48 IFACE_ATTR_DYNAMICDHCP,
49 IFACE_ATTR_LEASETIME,
50 IFACE_ATTR_LIMIT,
51 IFACE_ATTR_START,
52 IFACE_ATTR_MASTER,
53 IFACE_ATTR_UPSTREAM,
54 IFACE_ATTR_RA,
55 IFACE_ATTR_DHCPV4,
56 IFACE_ATTR_DHCPV6,
57 IFACE_ATTR_NDP,
58 IFACE_ATTR_ROUTER,
59 IFACE_ATTR_DNS,
60 IFACE_ATTR_DNS_SERVICE,
61 IFACE_ATTR_DOMAIN,
62 IFACE_ATTR_FILTER_CLASS,
63 IFACE_ATTR_DHCPV4_FORCERECONF,
64 IFACE_ATTR_DHCPV6_RAW,
65 IFACE_ATTR_DHCPV6_ASSIGNALL,
66 IFACE_ATTR_DHCPV6_PD,
67 IFACE_ATTR_DHCPV6_NA,
68 IFACE_ATTR_DHCPV6_HOSTID_LEN,
69 IFACE_ATTR_RA_DEFAULT,
70 IFACE_ATTR_RA_MANAGEMENT,
71 IFACE_ATTR_RA_FLAGS,
72 IFACE_ATTR_RA_SLAAC,
73 IFACE_ATTR_RA_OFFLINK,
74 IFACE_ATTR_RA_PREFERENCE,
75 IFACE_ATTR_RA_ADVROUTER,
76 IFACE_ATTR_RA_MININTERVAL,
77 IFACE_ATTR_RA_MAXINTERVAL,
78 IFACE_ATTR_RA_LIFETIME,
79 IFACE_ATTR_RA_USELEASETIME,
80 IFACE_ATTR_RA_REACHABLETIME,
81 IFACE_ATTR_RA_RETRANSTIME,
82 IFACE_ATTR_RA_HOPLIMIT,
83 IFACE_ATTR_RA_MTU,
84 IFACE_ATTR_RA_DNS,
85 IFACE_ATTR_PD_MANAGER,
86 IFACE_ATTR_PD_CER,
87 IFACE_ATTR_NDPROXY_ROUTING,
88 IFACE_ATTR_NDPROXY_SLAVE,
89 IFACE_ATTR_PREFIX_FILTER,
90 IFACE_ATTR_PREFERRED_LIFETIME,
91 IFACE_ATTR_NTP,
92 IFACE_ATTR_MAX
93 };
94
95 static const struct blobmsg_policy iface_attrs[IFACE_ATTR_MAX] = {
96 [IFACE_ATTR_INTERFACE] = { .name = "interface", .type = BLOBMSG_TYPE_STRING },
97 [IFACE_ATTR_IFNAME] = { .name = "ifname", .type = BLOBMSG_TYPE_STRING },
98 [IFACE_ATTR_NETWORKID] = { .name = "networkid", .type = BLOBMSG_TYPE_STRING },
99 [IFACE_ATTR_DYNAMICDHCP] = { .name = "dynamicdhcp", .type = BLOBMSG_TYPE_BOOL },
100 [IFACE_ATTR_LEASETIME] = { .name = "leasetime", .type = BLOBMSG_TYPE_STRING },
101 [IFACE_ATTR_START] = { .name = "start", .type = BLOBMSG_TYPE_INT32 },
102 [IFACE_ATTR_LIMIT] = { .name = "limit", .type = BLOBMSG_TYPE_INT32 },
103 [IFACE_ATTR_MASTER] = { .name = "master", .type = BLOBMSG_TYPE_BOOL },
104 [IFACE_ATTR_UPSTREAM] = { .name = "upstream", .type = BLOBMSG_TYPE_ARRAY },
105 [IFACE_ATTR_RA] = { .name = "ra", .type = BLOBMSG_TYPE_STRING },
106 [IFACE_ATTR_DHCPV4] = { .name = "dhcpv4", .type = BLOBMSG_TYPE_STRING },
107 [IFACE_ATTR_DHCPV6] = { .name = "dhcpv6", .type = BLOBMSG_TYPE_STRING },
108 [IFACE_ATTR_NDP] = { .name = "ndp", .type = BLOBMSG_TYPE_STRING },
109 [IFACE_ATTR_ROUTER] = { .name = "router", .type = BLOBMSG_TYPE_ARRAY },
110 [IFACE_ATTR_DNS] = { .name = "dns", .type = BLOBMSG_TYPE_ARRAY },
111 [IFACE_ATTR_DNS_SERVICE] = { .name = "dns_service", .type = BLOBMSG_TYPE_BOOL },
112 [IFACE_ATTR_DOMAIN] = { .name = "domain", .type = BLOBMSG_TYPE_ARRAY },
113 [IFACE_ATTR_FILTER_CLASS] = { .name = "filter_class", .type = BLOBMSG_TYPE_STRING },
114 [IFACE_ATTR_DHCPV4_FORCERECONF] = { .name = "dhcpv4_forcereconf", .type = BLOBMSG_TYPE_BOOL },
115 [IFACE_ATTR_DHCPV6_RAW] = { .name = "dhcpv6_raw", .type = BLOBMSG_TYPE_STRING },
116 [IFACE_ATTR_DHCPV6_ASSIGNALL] = { .name ="dhcpv6_assignall", .type = BLOBMSG_TYPE_BOOL },
117 [IFACE_ATTR_DHCPV6_PD] = { .name = "dhcpv6_pd", .type = BLOBMSG_TYPE_BOOL },
118 [IFACE_ATTR_DHCPV6_NA] = { .name = "dhcpv6_na", .type = BLOBMSG_TYPE_BOOL },
119 [IFACE_ATTR_DHCPV6_HOSTID_LEN] = { .name = "dhcpv6_hostidlength", .type = BLOBMSG_TYPE_INT32 },
120 [IFACE_ATTR_PD_MANAGER] = { .name = "pd_manager", .type = BLOBMSG_TYPE_STRING },
121 [IFACE_ATTR_PD_CER] = { .name = "pd_cer", .type = BLOBMSG_TYPE_STRING },
122 [IFACE_ATTR_RA_DEFAULT] = { .name = "ra_default", .type = BLOBMSG_TYPE_INT32 },
123 [IFACE_ATTR_RA_MANAGEMENT] = { .name = "ra_management", .type = BLOBMSG_TYPE_INT32 },
124 [IFACE_ATTR_RA_FLAGS] = { .name = "ra_flags", . type = BLOBMSG_TYPE_ARRAY },
125 [IFACE_ATTR_RA_SLAAC] = { .name = "ra_slaac", .type = BLOBMSG_TYPE_BOOL },
126 [IFACE_ATTR_RA_OFFLINK] = { .name = "ra_offlink", .type = BLOBMSG_TYPE_BOOL },
127 [IFACE_ATTR_RA_PREFERENCE] = { .name = "ra_preference", .type = BLOBMSG_TYPE_STRING },
128 [IFACE_ATTR_RA_ADVROUTER] = { .name = "ra_advrouter", .type = BLOBMSG_TYPE_BOOL },
129 [IFACE_ATTR_RA_MININTERVAL] = { .name = "ra_mininterval", .type = BLOBMSG_TYPE_INT32 },
130 [IFACE_ATTR_RA_MAXINTERVAL] = { .name = "ra_maxinterval", .type = BLOBMSG_TYPE_INT32 },
131 [IFACE_ATTR_RA_LIFETIME] = { .name = "ra_lifetime", .type = BLOBMSG_TYPE_INT32 },
132 [IFACE_ATTR_RA_USELEASETIME] = { .name = "ra_useleasetime", .type = BLOBMSG_TYPE_BOOL },
133 [IFACE_ATTR_RA_REACHABLETIME] = { .name = "ra_reachabletime", .type = BLOBMSG_TYPE_INT32 },
134 [IFACE_ATTR_RA_RETRANSTIME] = { .name = "ra_retranstime", .type = BLOBMSG_TYPE_INT32 },
135 [IFACE_ATTR_RA_HOPLIMIT] = { .name = "ra_hoplimit", .type = BLOBMSG_TYPE_INT32 },
136 [IFACE_ATTR_RA_MTU] = { .name = "ra_mtu", .type = BLOBMSG_TYPE_INT32 },
137 [IFACE_ATTR_RA_DNS] = { .name = "ra_dns", .type = BLOBMSG_TYPE_BOOL },
138 [IFACE_ATTR_NDPROXY_ROUTING] = { .name = "ndproxy_routing", .type = BLOBMSG_TYPE_BOOL },
139 [IFACE_ATTR_NDPROXY_SLAVE] = { .name = "ndproxy_slave", .type = BLOBMSG_TYPE_BOOL },
140 [IFACE_ATTR_PREFIX_FILTER] = { .name = "prefix_filter", .type = BLOBMSG_TYPE_STRING },
141 [IFACE_ATTR_PREFERRED_LIFETIME] = { .name = "preferred_lifetime", .type = BLOBMSG_TYPE_STRING },
142 [IFACE_ATTR_NTP] = { .name = "ntp", .type = BLOBMSG_TYPE_ARRAY },
143 };
144
145 static const struct uci_blob_param_info iface_attr_info[IFACE_ATTR_MAX] = {
146 [IFACE_ATTR_UPSTREAM] = { .type = BLOBMSG_TYPE_STRING },
147 [IFACE_ATTR_DNS] = { .type = BLOBMSG_TYPE_STRING },
148 [IFACE_ATTR_DOMAIN] = { .type = BLOBMSG_TYPE_STRING },
149 };
150
151 const struct uci_blob_param_list interface_attr_list = {
152 .n_params = IFACE_ATTR_MAX,
153 .params = iface_attrs,
154 .info = iface_attr_info,
155 };
156
157 const struct blobmsg_policy lease_attrs[LEASE_ATTR_MAX] = {
158 [LEASE_ATTR_IP] = { .name = "ip", .type = BLOBMSG_TYPE_STRING },
159 [LEASE_ATTR_MAC] = { .name = "mac", .type = BLOBMSG_TYPE_STRING },
160 [LEASE_ATTR_DUID] = { .name = "duid", .type = BLOBMSG_TYPE_STRING },
161 [LEASE_ATTR_HOSTID] = { .name = "hostid", .type = BLOBMSG_TYPE_STRING },
162 [LEASE_ATTR_LEASETIME] = { .name = "leasetime", .type = BLOBMSG_TYPE_STRING },
163 [LEASE_ATTR_NAME] = { .name = "name", .type = BLOBMSG_TYPE_STRING },
164 };
165
166 const struct uci_blob_param_list lease_attr_list = {
167 .n_params = LEASE_ATTR_MAX,
168 .params = lease_attrs,
169 };
170
171 enum {
172 ODHCPD_ATTR_LEGACY,
173 ODHCPD_ATTR_MAINDHCP,
174 ODHCPD_ATTR_LEASEFILE,
175 ODHCPD_ATTR_LEASETRIGGER,
176 ODHCPD_ATTR_LOGLEVEL,
177 ODHCPD_ATTR_MAX
178 };
179
180 static const struct blobmsg_policy odhcpd_attrs[ODHCPD_ATTR_MAX] = {
181 [ODHCPD_ATTR_LEGACY] = { .name = "legacy", .type = BLOBMSG_TYPE_BOOL },
182 [ODHCPD_ATTR_MAINDHCP] = { .name = "maindhcp", .type = BLOBMSG_TYPE_BOOL },
183 [ODHCPD_ATTR_LEASEFILE] = { .name = "leasefile", .type = BLOBMSG_TYPE_STRING },
184 [ODHCPD_ATTR_LEASETRIGGER] = { .name = "leasetrigger", .type = BLOBMSG_TYPE_STRING },
185 [ODHCPD_ATTR_LOGLEVEL] = { .name = "loglevel", .type = BLOBMSG_TYPE_INT32 },
186 };
187
188 const struct uci_blob_param_list odhcpd_attr_list = {
189 .n_params = ODHCPD_ATTR_MAX,
190 .params = odhcpd_attrs,
191 };
192
193 static const struct { const char *name; uint8_t flag; } ra_flags[] = {
194 { .name = "managed-config", .flag = ND_RA_FLAG_MANAGED },
195 { .name = "other-config", .flag = ND_RA_FLAG_OTHER },
196 { .name = "home-agent", .flag = ND_RA_FLAG_HOME_AGENT },
197 { .name = "none", . flag = 0 },
198 { .name = NULL, },
199 };
200
201 static void set_interface_defaults(struct interface *iface)
202 {
203 iface->ignore = true;
204 iface->dhcpv4 = MODE_DISABLED;
205 iface->dhcpv6 = MODE_DISABLED;
206 iface->ra = MODE_DISABLED;
207 iface->ndp = MODE_DISABLED;
208 iface->learn_routes = 1;
209 iface->dhcp_leasetime = 43200;
210 iface->preferred_lifetime = 43200;
211 iface->dhcpv4_start.s_addr = htonl(START_DEFAULT);
212 iface->dhcpv4_end.s_addr = htonl(START_DEFAULT + LIMIT_DEFAULT - 1);
213 iface->dhcpv6_assignall = true;
214 iface->dhcpv6_pd = true;
215 iface->dhcpv6_na = true;
216 iface->dhcpv6_hostid_len = HOSTID_LEN_DEFAULT;
217 iface->dns_service = true;
218 iface->ra_flags = ND_RA_FLAG_OTHER;
219 iface->ra_slaac = true;
220 iface->ra_maxinterval = 600;
221 iface->ra_mininterval = iface->ra_maxinterval/3;
222 iface->ra_lifetime = -1;
223 iface->ra_dns = true;
224 }
225
226 static void clean_interface(struct interface *iface)
227 {
228 free(iface->dns);
229 free(iface->search);
230 free(iface->upstream);
231 free(iface->dhcpv4_router);
232 free(iface->dhcpv4_dns);
233 free(iface->dhcpv6_raw);
234 free(iface->filter_class);
235 free(iface->dhcpv4_ntp);
236 free(iface->dhcpv6_ntp);
237 free(iface->dhcpv6_sntp);
238 memset(&iface->ra, 0, sizeof(*iface) - offsetof(struct interface, ra));
239 set_interface_defaults(iface);
240 }
241
242 static void close_interface(struct interface *iface)
243 {
244 avl_delete(&interfaces, &iface->avl);
245
246 router_setup_interface(iface, false);
247 dhcpv6_setup_interface(iface, false);
248 ndp_setup_interface(iface, false);
249 #ifdef DHCPV4_SUPPORT
250 dhcpv4_setup_interface(iface, false);
251 #endif
252
253 clean_interface(iface);
254 free(iface->addr4);
255 free(iface->addr6);
256 free(iface->invalid_addr6);
257 free(iface->ifname);
258 free(iface);
259 }
260
261 static int parse_mode(const char *mode)
262 {
263 if (!strcmp(mode, "disabled"))
264 return MODE_DISABLED;
265 else if (!strcmp(mode, "server"))
266 return MODE_SERVER;
267 else if (!strcmp(mode, "relay"))
268 return MODE_RELAY;
269 else if (!strcmp(mode, "hybrid"))
270 return MODE_HYBRID;
271 else
272 return -1;
273 }
274
275 static int parse_ra_flags(uint8_t *flags, struct blob_attr *attr)
276 {
277 struct blob_attr *cur;
278 unsigned rem;
279
280 blobmsg_for_each_attr(cur, attr, rem) {
281 int i;
282
283 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
284 continue;
285
286 if (!blobmsg_check_attr(cur, false))
287 continue;
288
289 for (i = 0; ra_flags[i].name; i++) {
290 if (!strcmp(ra_flags[i].name, blobmsg_get_string(cur))) {
291 *flags |= ra_flags[i].flag;
292 break;
293 }
294 }
295
296 if (!ra_flags[i].name)
297 return -1;
298 }
299
300 return 0;
301 }
302
303 static void set_config(struct uci_section *s)
304 {
305 struct blob_attr *tb[ODHCPD_ATTR_MAX], *c;
306
307 blob_buf_init(&b, 0);
308 uci_to_blob(&b, s, &odhcpd_attr_list);
309 blobmsg_parse(odhcpd_attrs, ODHCPD_ATTR_MAX, tb, blob_data(b.head), blob_len(b.head));
310
311 if ((c = tb[ODHCPD_ATTR_LEGACY]))
312 config.legacy = blobmsg_get_bool(c);
313
314 if ((c = tb[ODHCPD_ATTR_MAINDHCP]))
315 config.main_dhcpv4 = blobmsg_get_bool(c);
316
317 if ((c = tb[ODHCPD_ATTR_LEASEFILE])) {
318 free(config.dhcp_statefile);
319 config.dhcp_statefile = strdup(blobmsg_get_string(c));
320 }
321
322 if ((c = tb[ODHCPD_ATTR_LEASETRIGGER])) {
323 free(config.dhcp_cb);
324 config.dhcp_cb = strdup(blobmsg_get_string(c));
325 }
326
327 if ((c = tb[ODHCPD_ATTR_LOGLEVEL])) {
328 int log_level = (blobmsg_get_u32(c) & LOG_PRIMASK);
329
330 if (config.log_level != log_level) {
331 config.log_level = log_level;
332 setlogmask(LOG_UPTO(config.log_level));
333 }
334 }
335 }
336
337 static double parse_leasetime(struct blob_attr *c) {
338 char *val = blobmsg_get_string(c), *endptr = NULL;
339 double time = strcmp(val, "infinite") ? strtod(val, &endptr) : UINT32_MAX;
340
341 if (time && endptr && endptr[0]) {
342 if (endptr[0] == 's')
343 time *= 1;
344 else if (endptr[0] == 'm')
345 time *= 60;
346 else if (endptr[0] == 'h')
347 time *= 3600;
348 else if (endptr[0] == 'd')
349 time *= 24 * 3600;
350 else if (endptr[0] == 'w')
351 time *= 7 * 24 * 3600;
352 else
353 goto err;
354 }
355
356 if (time < 60)
357 time = 60;
358
359 return time;
360
361 err:
362 return -1;
363 }
364
365 static void free_lease(struct lease *l)
366 {
367 free(l->hostname);
368 free(l);
369 }
370
371
372 int set_lease_from_blobmsg(struct blob_attr *ba)
373 {
374 struct blob_attr *tb[LEASE_ATTR_MAX], *c;
375 struct lease *l;
376 size_t duidlen = 0;
377 uint8_t *duid;
378
379 blobmsg_parse(lease_attrs, LEASE_ATTR_MAX, tb, blob_data(ba), blob_len(ba));
380
381 if ((c = tb[LEASE_ATTR_DUID]))
382 duidlen = (blobmsg_data_len(c) - 1) / 2;
383
384 l = calloc_a(sizeof(*l), &duid, duidlen);
385 if (!l)
386 goto err;
387
388 if ((c = tb[LEASE_ATTR_MAC]))
389 if (!ether_aton_r(blobmsg_get_string(c), &l->mac))
390 goto err;
391
392 if ((c = tb[LEASE_ATTR_DUID])) {
393 ssize_t len;
394
395 l->duid = duid;
396 len = odhcpd_unhexlify(l->duid, duidlen, blobmsg_get_string(c));
397
398 if (len < 0)
399 goto err;
400
401 l->duid_len = len;
402 }
403
404 if ((c = tb[LEASE_ATTR_NAME])) {
405 l->hostname = strdup(blobmsg_get_string(c));
406 if (!l->hostname || !odhcpd_valid_hostname(l->hostname))
407 goto err;
408 }
409
410 if ((c = tb[LEASE_ATTR_IP]))
411 if (inet_pton(AF_INET, blobmsg_get_string(c), &l->ipaddr) < 0)
412 goto err;
413
414 if ((c = tb[LEASE_ATTR_HOSTID])) {
415 errno = 0;
416 l->hostid = strtoull(blobmsg_get_string(c), NULL, 16);
417 if (errno)
418 goto err;
419 } else {
420 uint32_t i4a = ntohl(l->ipaddr) & 0xff;
421 l->hostid = ((i4a / 100) << 8) | (((i4a % 100) / 10) << 4) | (i4a % 10);
422 }
423
424 if ((c = tb[LEASE_ATTR_LEASETIME])) {
425 double time = parse_leasetime(c);
426 if (time < 0)
427 goto err;
428
429 l->leasetime = time;
430 }
431
432 INIT_LIST_HEAD(&l->assignments);
433 vlist_add(&leases, &l->node, l);
434 return 0;
435
436 err:
437 if (l)
438 free_lease(l);
439
440 return -1;
441 }
442
443 static int set_lease_from_uci(struct uci_section *s)
444 {
445 blob_buf_init(&b, 0);
446 uci_to_blob(&b, s, &lease_attr_list);
447
448 return set_lease_from_blobmsg(b.head);
449 }
450
451 /* Parse NTP Options for DHCPv6 Address */
452 static int parse_ntp_options(uint16_t *dhcpv6_ntp_len, struct in6_addr addr6, uint8_t **dhcpv6_ntp)
453 {
454 uint16_t sub_opt = 0, sub_len = htons(IPV6_ADDR_LEN);
455 uint16_t ntp_len = IPV6_ADDR_LEN + 4;
456 uint8_t *ntp = *dhcpv6_ntp;
457 size_t pos = *dhcpv6_ntp_len;
458
459 ntp = realloc(ntp, pos + ntp_len);
460 if (!ntp)
461 return -1;
462
463 *dhcpv6_ntp = ntp;
464
465 if (IN6_IS_ADDR_MULTICAST(&addr6))
466 sub_opt = htons(NTP_SUBOPTION_MC_ADDR);
467 else
468 sub_opt = htons(NTP_SUBOPTION_SRV_ADDR);
469
470 memcpy(ntp + pos, &sub_opt, sizeof(sub_opt));
471 pos += sizeof(sub_opt);
472 memcpy(ntp + pos, &sub_len, sizeof(sub_len));
473 pos += sizeof(sub_len);
474 memcpy(ntp + pos, &addr6, IPV6_ADDR_LEN);
475
476 *dhcpv6_ntp_len += ntp_len;
477
478 return 0;
479 }
480
481 /* Parse NTP Options for FQDN */
482 static int parse_ntp_fqdn(uint16_t *dhcpv6_ntp_len, char *fqdn, uint8_t **dhcpv6_ntp)
483 {
484 size_t fqdn_len = strlen(fqdn);
485 uint16_t sub_opt = 0, sub_len = 0, ntp_len = 0;
486 uint8_t *ntp = *dhcpv6_ntp;
487 size_t pos = *dhcpv6_ntp_len;
488 uint8_t buf[256] = {0};
489
490 if (fqdn_len > 0 && fqdn[fqdn_len - 1] == '.')
491 fqdn[fqdn_len - 1] = 0;
492
493 int len = dn_comp(fqdn, buf, sizeof(buf), NULL, NULL);
494 if (len <= 0)
495 return -1;
496
497 ntp_len = len + 4;
498
499 ntp = realloc(ntp, pos + ntp_len);
500 if (!ntp)
501 return -1;
502
503 *dhcpv6_ntp = ntp;
504
505 sub_opt = htons(NTP_SUBOPTION_SRV_FQDN);
506 sub_len = htons(len);
507
508 memcpy(ntp + pos, &sub_opt, sizeof(sub_opt));
509 pos += sizeof(sub_opt);
510 memcpy(ntp + pos, &sub_len, sizeof(sub_len));
511 pos += sizeof(sub_len);
512 memcpy(ntp + pos, buf, len);
513
514 *dhcpv6_ntp_len += ntp_len;
515
516 return 0;
517 }
518
519 int config_parse_interface(void *data, size_t len, const char *name, bool overwrite)
520 {
521 struct odhcpd_ipaddr *addrs = NULL;
522 struct interface *iface;
523 struct blob_attr *tb[IFACE_ATTR_MAX], *c;
524 ssize_t addrs_len;
525 bool get_addrs = false;
526 int mode;
527 const char *ifname = NULL;
528
529 blobmsg_parse(iface_attrs, IFACE_ATTR_MAX, tb, data, len);
530
531 if (tb[IFACE_ATTR_INTERFACE])
532 name = blobmsg_get_string(tb[IFACE_ATTR_INTERFACE]);
533
534 if (!name)
535 return -1;
536
537 iface = avl_find_element(&interfaces, name, iface, avl);
538 if (!iface) {
539 char *new_name;
540
541 iface = calloc_a(sizeof(*iface), &new_name, strlen(name) + 1);
542 if (!iface)
543 return -1;
544
545 iface->name = strcpy(new_name, name);
546 iface->avl.key = iface->name;
547 iface->router_event.uloop.fd = -1;
548 iface->dhcpv6_event.uloop.fd = -1;
549 iface->ndp_event.uloop.fd = -1;
550 iface->ndp_ping_fd = -1;
551 iface->dhcpv4_event.uloop.fd = -1;
552 INIT_LIST_HEAD(&iface->ia_assignments);
553 INIT_LIST_HEAD(&iface->dhcpv4_assignments);
554 INIT_LIST_HEAD(&iface->dhcpv4_fr_ips);
555
556 set_interface_defaults(iface);
557
558 avl_insert(&interfaces, &iface->avl);
559 get_addrs = overwrite = true;
560 }
561
562 if (overwrite) {
563 if ((c = tb[IFACE_ATTR_IFNAME]))
564 ifname = blobmsg_get_string(c);
565 else if ((c = tb[IFACE_ATTR_NETWORKID]))
566 ifname = blobmsg_get_string(c);
567 }
568
569 #ifdef WITH_UBUS
570 if (overwrite || !iface->ifname)
571 ifname = ubus_get_ifname(name);
572 #endif
573
574 if (!iface->ifname && !ifname)
575 goto err;
576
577 if (ifname) {
578 free(iface->ifname);
579 iface->ifname = strdup(ifname);
580
581 if (!iface->ifname)
582 goto err;
583
584 if (!iface->ifindex &&
585 (iface->ifindex = if_nametoindex(iface->ifname)) <= 0)
586 goto err;
587
588 if ((iface->ifflags = odhcpd_get_flags(iface)) < 0)
589 goto err;
590 }
591
592 if (get_addrs) {
593 addrs_len = netlink_get_interface_addrs(iface->ifindex,
594 true, &iface->addr6);
595
596 if (addrs_len > 0)
597 iface->addr6_len = addrs_len;
598
599 addrs_len = netlink_get_interface_addrs(iface->ifindex,
600 false, &iface->addr4);
601 if (addrs_len > 0)
602 iface->addr4_len = addrs_len;
603 }
604
605 addrs_len = netlink_get_interface_linklocal(iface->ifindex, &addrs);
606 if (addrs_len > 0) {
607 for (ssize_t i = 0; i < addrs_len; i++) {
608 struct odhcpd_ipaddr *addr = &addrs[i];
609
610 if (!addr->tentative) {
611 iface->have_link_local = true;
612 break;
613 }
614 }
615 }
616
617 iface->inuse = true;
618
619 if ((c = tb[IFACE_ATTR_DYNAMICDHCP]))
620 iface->no_dynamic_dhcp = !blobmsg_get_bool(c);
621
622 if ((c = tb[IFACE_ATTR_LEASETIME])) {
623 double time = parse_leasetime(c);
624
625 if (time >= 0)
626 iface->dhcp_leasetime = time;
627 else
628 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
629 iface_attrs[IFACE_ATTR_LEASETIME].name, iface->name);
630
631 }
632
633 if ((c = tb[IFACE_ATTR_PREFERRED_LIFETIME])) {
634 double time = parse_leasetime(c);
635
636 if (time >= 0)
637 iface->preferred_lifetime = time;
638 else
639 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
640 iface_attrs[IFACE_ATTR_PREFERRED_LIFETIME].name, iface->name);
641
642 }
643
644 if ((c = tb[IFACE_ATTR_START])) {
645 iface->dhcpv4_start.s_addr = htonl(blobmsg_get_u32(c));
646 iface->dhcpv4_end.s_addr = htonl(ntohl(iface->dhcpv4_start.s_addr) +
647 LIMIT_DEFAULT - 1);
648
649 if (config.main_dhcpv4 && config.legacy)
650 iface->dhcpv4 = MODE_SERVER;
651 }
652
653 if ((c = tb[IFACE_ATTR_LIMIT]))
654 iface->dhcpv4_end.s_addr = htonl(ntohl(iface->dhcpv4_start.s_addr) +
655 blobmsg_get_u32(c) - 1);
656
657 if ((c = tb[IFACE_ATTR_MASTER]))
658 iface->master = blobmsg_get_bool(c);
659
660 if (overwrite && (c = tb[IFACE_ATTR_UPSTREAM])) {
661 struct blob_attr *cur;
662 unsigned rem;
663
664 blobmsg_for_each_attr(cur, c, rem) {
665 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
666 continue;
667
668 iface->upstream = realloc(iface->upstream,
669 iface->upstream_len + blobmsg_data_len(cur));
670 if (!iface->upstream)
671 goto err;
672
673 memcpy(iface->upstream + iface->upstream_len, blobmsg_get_string(cur), blobmsg_data_len(cur));
674 iface->upstream_len += blobmsg_data_len(cur);
675 }
676 }
677
678 if ((c = tb[IFACE_ATTR_RA])) {
679 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0) {
680 iface->ra = mode;
681
682 if (iface->ra != MODE_DISABLED)
683 iface->ignore = false;
684 } else
685 syslog(LOG_ERR, "Invalid %s mode configured for interface '%s'",
686 iface_attrs[IFACE_ATTR_RA].name, iface->name);
687 }
688
689 if ((c = tb[IFACE_ATTR_DHCPV4])) {
690 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0) {
691 if (config.main_dhcpv4) {
692 iface->dhcpv4 = mode;
693
694 if (iface->dhcpv4 != MODE_DISABLED)
695 iface->ignore = false;
696 }
697 } else
698 syslog(LOG_ERR, "Invalid %s mode configured for interface %s",
699 iface_attrs[IFACE_ATTR_DHCPV4].name, iface->name);
700 }
701
702 if ((c = tb[IFACE_ATTR_DHCPV6])) {
703 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0) {
704 iface->dhcpv6 = mode;
705
706 if (iface->dhcpv6 != MODE_DISABLED)
707 iface->ignore = false;
708 } else
709 syslog(LOG_ERR, "Invalid %s mode configured for interface '%s'",
710 iface_attrs[IFACE_ATTR_DHCPV6].name, iface->name);
711 }
712
713 if ((c = tb[IFACE_ATTR_NDP])) {
714 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0) {
715 iface->ndp = mode;
716
717 if (iface->ndp != MODE_DISABLED)
718 iface->ignore = false;
719 } else
720 syslog(LOG_ERR, "Invalid %s mode configured for interface '%s'",
721 iface_attrs[IFACE_ATTR_NDP].name, iface->name);
722 }
723
724 if ((c = tb[IFACE_ATTR_ROUTER])) {
725 struct blob_attr *cur;
726 unsigned rem;
727
728 blobmsg_for_each_attr(cur, c, rem) {
729 struct in_addr addr4;
730
731 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
732 continue;
733
734 if (inet_pton(AF_INET, blobmsg_get_string(cur), &addr4) == 1) {
735 iface->dhcpv4_router = realloc(iface->dhcpv4_router,
736 (++iface->dhcpv4_router_cnt) * sizeof(*iface->dhcpv4_router));
737 if (!iface->dhcpv4_router)
738 goto err;
739
740 iface->dhcpv4_router[iface->dhcpv4_router_cnt - 1] = addr4;
741 } else
742 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
743 iface_attrs[IFACE_ATTR_ROUTER].name, iface->name);
744 }
745 }
746
747 if ((c = tb[IFACE_ATTR_DNS])) {
748 struct blob_attr *cur;
749 unsigned rem;
750
751 iface->always_rewrite_dns = true;
752 blobmsg_for_each_attr(cur, c, rem) {
753 struct in_addr addr4;
754 struct in6_addr addr6;
755
756 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
757 continue;
758
759 if (inet_pton(AF_INET, blobmsg_get_string(cur), &addr4) == 1) {
760 if (addr4.s_addr == INADDR_ANY) {
761 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
762 iface_attrs[IFACE_ATTR_DNS].name, iface->name);
763
764 continue;
765 }
766
767 iface->dhcpv4_dns = realloc(iface->dhcpv4_dns,
768 (++iface->dhcpv4_dns_cnt) * sizeof(*iface->dhcpv4_dns));
769 if (!iface->dhcpv4_dns)
770 goto err;
771
772 iface->dhcpv4_dns[iface->dhcpv4_dns_cnt - 1] = addr4;
773 } else if (inet_pton(AF_INET6, blobmsg_get_string(cur), &addr6) == 1) {
774 if (IN6_IS_ADDR_UNSPECIFIED(&addr6)) {
775 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
776 iface_attrs[IFACE_ATTR_DNS].name, iface->name);
777
778 continue;
779 }
780
781 iface->dns = realloc(iface->dns,
782 (++iface->dns_cnt) * sizeof(*iface->dns));
783 if (!iface->dns)
784 goto err;
785
786 iface->dns[iface->dns_cnt - 1] = addr6;
787 } else
788 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
789 iface_attrs[IFACE_ATTR_DNS].name, iface->name);
790 }
791 }
792
793 if ((c = tb[IFACE_ATTR_DNS_SERVICE]))
794 iface->dns_service = blobmsg_get_bool(c);
795
796 if ((c = tb[IFACE_ATTR_DOMAIN])) {
797 struct blob_attr *cur;
798 unsigned rem;
799
800 blobmsg_for_each_attr(cur, c, rem) {
801 uint8_t buf[256];
802 char *domain = blobmsg_get_string(cur);
803 size_t domainlen = strlen(domain);
804 int len;
805
806 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
807 continue;
808
809 domain = blobmsg_get_string(cur);
810 domainlen = strlen(domain);
811
812 if (domainlen > 0 && domain[domainlen - 1] == '.')
813 domain[domainlen - 1] = 0;
814
815 len = dn_comp(domain, buf, sizeof(buf), NULL, NULL);
816 if (len <= 0) {
817 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
818 iface_attrs[IFACE_ATTR_DOMAIN].name, iface->name);
819
820 continue;
821 }
822
823 iface->search = realloc(iface->search, iface->search_len + len);
824 if (!iface->search)
825 goto err;
826
827 memcpy(&iface->search[iface->search_len], buf, len);
828 iface->search_len += len;
829 }
830 }
831
832 if ((c = tb[IFACE_ATTR_FILTER_CLASS])) {
833 iface->filter_class = realloc(iface->filter_class, blobmsg_data_len(c) + 1);
834 memcpy(iface->filter_class, blobmsg_get_string(c), blobmsg_data_len(c) + 1);
835 }
836
837 if ((c = tb[IFACE_ATTR_DHCPV4_FORCERECONF]))
838 iface->dhcpv4_forcereconf = blobmsg_get_bool(c);
839
840 if ((c = tb[IFACE_ATTR_DHCPV6_RAW])) {
841 iface->dhcpv6_raw_len = blobmsg_data_len(c) / 2;
842 iface->dhcpv6_raw = realloc(iface->dhcpv6_raw, iface->dhcpv6_raw_len);
843 odhcpd_unhexlify(iface->dhcpv6_raw, iface->dhcpv6_raw_len, blobmsg_get_string(c));
844 }
845
846 if ((c = tb[IFACE_ATTR_DHCPV6_ASSIGNALL]))
847 iface->dhcpv6_assignall = blobmsg_get_bool(c);
848
849 if ((c = tb[IFACE_ATTR_DHCPV6_PD]))
850 iface->dhcpv6_pd = blobmsg_get_bool(c);
851
852 if ((c = tb[IFACE_ATTR_DHCPV6_NA]))
853 iface->dhcpv6_na = blobmsg_get_bool(c);
854
855 if ((c = tb[IFACE_ATTR_DHCPV6_HOSTID_LEN])) {
856 uint32_t hostid_len = blobmsg_get_u32(c);
857
858 if (hostid_len >= HOSTID_LEN_MIN && hostid_len <= HOSTID_LEN_MAX)
859 iface->dhcpv6_hostid_len = hostid_len;
860 else
861 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
862 iface_attrs[IFACE_ATTR_DHCPV6_HOSTID_LEN].name, iface->name);
863
864 }
865
866 if ((c = tb[IFACE_ATTR_RA_DEFAULT]))
867 iface->default_router = blobmsg_get_u32(c);
868
869 if (!tb[IFACE_ATTR_RA_FLAGS] && !tb[IFACE_ATTR_RA_SLAAC] &&
870 (c = tb[IFACE_ATTR_RA_MANAGEMENT])) {
871 switch (blobmsg_get_u32(c)) {
872 case 0:
873 iface->ra_flags = ND_RA_FLAG_OTHER;
874 iface->ra_slaac = true;
875 break;
876 case 1:
877 iface->ra_flags = ND_RA_FLAG_OTHER|ND_RA_FLAG_MANAGED;
878 iface->ra_slaac = true;
879 break;
880 case 2:
881 iface->ra_flags = ND_RA_FLAG_OTHER|ND_RA_FLAG_MANAGED;
882 iface->ra_slaac = false;
883 break;
884 default:
885 break;
886 }
887 }
888
889 if ((c = tb[IFACE_ATTR_RA_FLAGS])) {
890 iface->ra_flags = 0;
891
892 if (parse_ra_flags(&iface->ra_flags, c) < 0)
893 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
894 iface_attrs[IFACE_ATTR_RA_FLAGS].name, iface->name);
895 }
896
897 if ((c = tb[IFACE_ATTR_RA_REACHABLETIME])) {
898 uint32_t ra_reachabletime = blobmsg_get_u32(c);
899
900 if (ra_reachabletime <= 3600000)
901 iface->ra_reachabletime = ra_reachabletime;
902 else
903 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
904 iface_attrs[IFACE_ATTR_RA_REACHABLETIME].name, iface->name);
905 }
906
907 if ((c = tb[IFACE_ATTR_RA_RETRANSTIME])) {
908 uint32_t ra_retranstime = blobmsg_get_u32(c);
909
910 if (ra_retranstime <= 60000)
911 iface->ra_retranstime = ra_retranstime;
912 else
913 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
914 iface_attrs[IFACE_ATTR_RA_RETRANSTIME].name, iface->name);
915 }
916
917 if ((c = tb[IFACE_ATTR_RA_HOPLIMIT])) {
918 uint32_t ra_hoplimit = blobmsg_get_u32(c);
919
920 if (ra_hoplimit <= 255)
921 iface->ra_hoplimit = ra_hoplimit;
922 else
923 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
924 iface_attrs[IFACE_ATTR_RA_HOPLIMIT].name, iface->name);
925 }
926
927 if ((c = tb[IFACE_ATTR_RA_MTU])) {
928 uint32_t ra_mtu = blobmsg_get_u32(c);
929
930 if (ra_mtu >= 1280 || ra_mtu <= 65535)
931 iface->ra_mtu = ra_mtu;
932 else
933 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
934 iface_attrs[IFACE_ATTR_RA_MTU].name, iface->name);
935 }
936
937 if ((c = tb[IFACE_ATTR_RA_SLAAC]))
938 iface->ra_slaac = blobmsg_get_bool(c);
939
940 if ((c = tb[IFACE_ATTR_RA_OFFLINK]))
941 iface->ra_not_onlink = blobmsg_get_bool(c);
942
943 if ((c = tb[IFACE_ATTR_RA_ADVROUTER]))
944 iface->ra_advrouter = blobmsg_get_bool(c);
945
946 if ((c = tb[IFACE_ATTR_RA_MININTERVAL]))
947 iface->ra_mininterval = blobmsg_get_u32(c);
948
949 if ((c = tb[IFACE_ATTR_RA_MAXINTERVAL]))
950 iface->ra_maxinterval = blobmsg_get_u32(c);
951
952 if ((c = tb[IFACE_ATTR_RA_LIFETIME]))
953 iface->ra_lifetime = blobmsg_get_u32(c);
954
955 if ((c = tb[IFACE_ATTR_RA_USELEASETIME]))
956 iface->ra_useleasetime = blobmsg_get_bool(c);
957
958 if ((c = tb[IFACE_ATTR_RA_DNS]))
959 iface->ra_dns = blobmsg_get_bool(c);
960
961 if ((c = tb[IFACE_ATTR_RA_PREFERENCE])) {
962 const char *prio = blobmsg_get_string(c);
963
964 if (!strcmp(prio, "high"))
965 iface->route_preference = 1;
966 else if (!strcmp(prio, "low"))
967 iface->route_preference = -1;
968 else if (!strcmp(prio, "medium") || !strcmp(prio, "default"))
969 iface->route_preference = 0;
970 else
971 syslog(LOG_ERR, "Invalid %s mode configured for interface '%s'",
972 iface_attrs[IFACE_ATTR_RA_PREFERENCE].name, iface->name);
973 }
974
975 if ((c = tb[IFACE_ATTR_PD_MANAGER]))
976 strncpy(iface->dhcpv6_pd_manager, blobmsg_get_string(c),
977 sizeof(iface->dhcpv6_pd_manager) - 1);
978
979 if ((c = tb[IFACE_ATTR_PD_CER]) &&
980 inet_pton(AF_INET6, blobmsg_get_string(c), &iface->dhcpv6_pd_cer) < 1)
981 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
982 iface_attrs[IFACE_ATTR_PD_CER].name, iface->name);
983
984 if ((c = tb[IFACE_ATTR_NDPROXY_ROUTING]))
985 iface->learn_routes = blobmsg_get_bool(c);
986
987 if ((c = tb[IFACE_ATTR_NDPROXY_SLAVE]))
988 iface->external = blobmsg_get_bool(c);
989
990 if ((c = tb[IFACE_ATTR_PREFIX_FILTER])) {
991 const char *str = blobmsg_get_string(c);
992 char *astr = malloc(strlen(str) + 1);
993 char *delim;
994 int l;
995
996 if (!astr || !strcpy(astr, str) ||
997 (delim = strchr(astr, '/')) == NULL || (*(delim++) = 0) ||
998 sscanf(delim, "%i", &l) == 0 || l > 128 ||
999 inet_pton(AF_INET6, astr, &iface->pio_filter_addr) == 0)
1000 iface->pio_filter_length = 0;
1001 else
1002 iface->pio_filter_length = l;
1003
1004 if (astr)
1005 free(astr);
1006 }
1007
1008 if (overwrite && (c = tb[IFACE_ATTR_NTP])) {
1009 struct blob_attr *cur;
1010 unsigned rem;
1011
1012 blobmsg_for_each_attr(cur, c, rem) {
1013 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
1014 continue;
1015
1016 char *str = blobmsg_get_string(cur);
1017 struct in_addr addr4;
1018 struct in6_addr addr6;
1019
1020 if (inet_pton(AF_INET, str, &addr4) == 1) {
1021 if (addr4.s_addr == INADDR_ANY)
1022 goto err;
1023
1024 iface->dhcpv4_ntp = realloc(iface->dhcpv4_ntp,
1025 (++iface->dhcpv4_ntp_cnt) * sizeof(*iface->dhcpv4_ntp));
1026 if (!iface->dhcpv4_ntp)
1027 goto err;
1028
1029 iface->dhcpv4_ntp[iface->dhcpv4_ntp_cnt - 1] = addr4;
1030 } else if (inet_pton(AF_INET6, str, &addr6) == 1) {
1031 if (IN6_IS_ADDR_UNSPECIFIED(&addr6))
1032 goto err;
1033
1034 iface->dhcpv6_sntp = realloc(iface->dhcpv6_sntp,
1035 (++iface->dhcpv6_sntp_cnt) * sizeof(*iface->dhcpv6_sntp));
1036 if (!iface->dhcpv6_sntp)
1037 goto err;
1038
1039 iface->dhcpv6_sntp[iface->dhcpv6_sntp_cnt - 1] = addr6;
1040
1041 if (!parse_ntp_options(&iface->dhcpv6_ntp_len, addr6, &iface->dhcpv6_ntp))
1042 iface->dhcpv6_ntp_cnt++;
1043 } else {
1044 if (!parse_ntp_fqdn(&iface->dhcpv6_ntp_len, str, &iface->dhcpv6_ntp))
1045 iface->dhcpv6_ntp_cnt++;
1046 }
1047 }
1048 }
1049
1050 return 0;
1051
1052 err:
1053 close_interface(iface);
1054 return -1;
1055 }
1056
1057 static int set_interface(struct uci_section *s)
1058 {
1059 blob_buf_init(&b, 0);
1060 uci_to_blob(&b, s, &interface_attr_list);
1061
1062 return config_parse_interface(blob_data(b.head), blob_len(b.head), s->e.name, true);
1063 }
1064
1065 static void lease_delete_assignments(struct lease *l, bool v6)
1066 {
1067 struct dhcp_assignment *a, *tmp;
1068 unsigned int flag = v6 ? OAF_DHCPV6 : OAF_DHCPV4;
1069
1070 list_for_each_entry_safe(a, tmp, &l->assignments, lease_list) {
1071 if (a->flags & flag)
1072 free_assignment(a);
1073 }
1074 }
1075
1076 static void lease_update_assignments(struct lease *l)
1077 {
1078 struct dhcp_assignment *a;
1079
1080 list_for_each_entry(a, &l->assignments, lease_list) {
1081 if (a->hostname)
1082 free(a->hostname);
1083 a->hostname = NULL;
1084
1085 if (l->hostname)
1086 a->hostname = strdup(l->hostname);
1087
1088 a->leasetime = l->leasetime;
1089 }
1090 }
1091
1092 static int lease_cmp(const void *k1, const void *k2, _unused void *ptr)
1093 {
1094 const struct lease *l1 = k1, *l2 = k2;
1095 int cmp = 0;
1096
1097 if (l1->duid_len != l2->duid_len)
1098 return l1->duid_len - l2->duid_len;
1099
1100 if (l1->duid_len && l2->duid_len)
1101 cmp = memcmp(l1->duid, l2->duid, l1->duid_len);
1102
1103 if (cmp)
1104 return cmp;
1105
1106 return memcmp(l1->mac.ether_addr_octet, l2->mac.ether_addr_octet,
1107 sizeof(l1->mac.ether_addr_octet));
1108 }
1109
1110 static void lease_change_config(struct lease *l_old, struct lease *l_new)
1111 {
1112 bool update = false;
1113
1114 if ((!!l_new->hostname != !!l_old->hostname) ||
1115 (l_new->hostname && strcmp(l_new->hostname, l_old->hostname))) {
1116 free(l_old->hostname);
1117 l_old->hostname = NULL;
1118
1119 if (l_new->hostname)
1120 l_old->hostname = strdup(l_new->hostname);
1121
1122 update = true;
1123 }
1124
1125 if (l_old->leasetime != l_new->leasetime) {
1126 l_old->leasetime = l_new->leasetime;
1127 update = true;
1128 }
1129
1130 if (l_old->ipaddr != l_new->ipaddr) {
1131 l_old->ipaddr = l_new->ipaddr;
1132 lease_delete_assignments(l_old, false);
1133 }
1134
1135 if (l_old->hostid != l_new->hostid) {
1136 l_old->hostid = l_new->hostid;
1137 lease_delete_assignments(l_old, true);
1138 }
1139
1140 if (update)
1141 lease_update_assignments(l_old);
1142
1143 free_lease(l_new);
1144 }
1145
1146 static void lease_delete(struct lease *l)
1147 {
1148 struct dhcp_assignment *a, *tmp;
1149
1150 list_for_each_entry_safe(a, tmp, &l->assignments, lease_list)
1151 free_assignment(a);
1152
1153 free_lease(l);
1154 }
1155
1156 static void lease_update(_unused struct vlist_tree *tree, struct vlist_node *node_new,
1157 struct vlist_node *node_old)
1158 {
1159 struct lease *lease_new = container_of(node_new, struct lease, node);
1160 struct lease *lease_old = container_of(node_old, struct lease, node);
1161
1162 if (node_old && node_new)
1163 lease_change_config(lease_old, lease_new);
1164 else if (node_old)
1165 lease_delete(lease_old);
1166 }
1167
1168 struct lease *config_find_lease_by_duid(const uint8_t *duid, const uint16_t len)
1169 {
1170 struct lease *l;
1171
1172 vlist_for_each_element(&leases, l, node) {
1173 if (l->duid_len == len && !memcmp(l->duid, duid, len))
1174 return l;
1175 }
1176
1177 return NULL;
1178 }
1179
1180 struct lease *config_find_lease_by_mac(const uint8_t *mac)
1181 {
1182 struct lease *l;
1183
1184 vlist_for_each_element(&leases, l, node) {
1185 if (!memcmp(l->mac.ether_addr_octet, mac,
1186 sizeof(l->mac.ether_addr_octet)))
1187 return l;
1188 }
1189
1190 return NULL;
1191 }
1192
1193 struct lease *config_find_lease_by_hostid(const uint64_t hostid)
1194 {
1195 struct lease *l;
1196
1197 vlist_for_each_element(&leases, l, node) {
1198 if (l->hostid == hostid)
1199 return l;
1200 }
1201
1202 return NULL;
1203 }
1204
1205 struct lease *config_find_lease_by_ipaddr(const uint32_t ipaddr)
1206 {
1207 struct lease *l;
1208
1209 vlist_for_each_element(&leases, l, node) {
1210 if (l->ipaddr == ipaddr)
1211 return l;
1212 }
1213
1214 return NULL;
1215 }
1216
1217 void reload_services(struct interface *iface)
1218 {
1219 if (iface->ifflags & IFF_RUNNING) {
1220 syslog(LOG_DEBUG, "Enabling services with %s running", iface->ifname);
1221 router_setup_interface(iface, iface->ra != MODE_DISABLED);
1222 dhcpv6_setup_interface(iface, iface->dhcpv6 != MODE_DISABLED);
1223 ndp_setup_interface(iface, iface->ndp != MODE_DISABLED);
1224 #ifdef DHCPV4_SUPPORT
1225 dhcpv4_setup_interface(iface, iface->dhcpv4 != MODE_DISABLED);
1226 #endif
1227 } else {
1228 syslog(LOG_DEBUG, "Disabling services with %s not running", iface->ifname);
1229 router_setup_interface(iface, false);
1230 dhcpv6_setup_interface(iface, false);
1231 ndp_setup_interface(iface, false);
1232 #ifdef DHCPV4_SUPPORT
1233 dhcpv4_setup_interface(iface, false);
1234 #endif
1235 }
1236 }
1237
1238 void odhcpd_reload(void)
1239 {
1240 struct uci_context *uci = uci_alloc_context();
1241 struct interface *master = NULL, *i, *tmp;
1242
1243 if (!uci)
1244 return;
1245
1246 vlist_update(&leases);
1247 avl_for_each_element(&interfaces, i, avl)
1248 clean_interface(i);
1249
1250 struct uci_package *dhcp = NULL;
1251 if (!uci_load(uci, "dhcp", &dhcp)) {
1252 struct uci_element *e;
1253
1254 /* 1. Global settings */
1255 uci_foreach_element(&dhcp->sections, e) {
1256 struct uci_section *s = uci_to_section(e);
1257 if (!strcmp(s->type, "odhcpd"))
1258 set_config(s);
1259 }
1260
1261 /* 2. DHCP pools */
1262 uci_foreach_element(&dhcp->sections, e) {
1263 struct uci_section *s = uci_to_section(e);
1264 if (!strcmp(s->type, "dhcp"))
1265 set_interface(s);
1266 }
1267
1268 /* 3. Static leases */
1269 uci_foreach_element(&dhcp->sections, e) {
1270 struct uci_section* s = uci_to_section(e);
1271 if (!strcmp(s->type, "host"))
1272 set_lease_from_uci(s);
1273 }
1274 }
1275
1276 if (config.dhcp_statefile) {
1277 char *path = strdup(config.dhcp_statefile);
1278
1279 mkdir_p(dirname(path), 0755);
1280 free(path);
1281 }
1282
1283 vlist_flush(&leases);
1284
1285 #ifdef WITH_UBUS
1286 ubus_apply_network();
1287 #endif
1288
1289 bool any_dhcpv6_slave = false, any_ra_slave = false, any_ndp_slave = false;
1290
1291 /* Test for */
1292 avl_for_each_element(&interfaces, i, avl) {
1293 if (i->master)
1294 continue;
1295
1296 if (i->dhcpv6 == MODE_HYBRID || i->dhcpv6 == MODE_RELAY)
1297 any_dhcpv6_slave = true;
1298
1299 if (i->ra == MODE_HYBRID || i->ra == MODE_RELAY)
1300 any_ra_slave = true;
1301
1302 if (i->ndp == MODE_HYBRID || i->ndp == MODE_RELAY)
1303 any_ndp_slave = true;
1304 }
1305
1306 /* Evaluate hybrid mode for master */
1307 avl_for_each_element(&interfaces, i, avl) {
1308 if (!i->master)
1309 continue;
1310
1311 enum odhcpd_mode hybrid_mode = MODE_DISABLED;
1312 #ifdef WITH_UBUS
1313 if (!ubus_has_prefix(i->name, i->ifname))
1314 hybrid_mode = MODE_RELAY;
1315 #endif
1316
1317 if (i->dhcpv6 == MODE_HYBRID)
1318 i->dhcpv6 = hybrid_mode;
1319
1320 if (i->dhcpv6 == MODE_RELAY && !any_dhcpv6_slave)
1321 i->dhcpv6 = MODE_DISABLED;
1322
1323 if (i->ra == MODE_HYBRID)
1324 i->ra = hybrid_mode;
1325
1326 if (i->ra == MODE_RELAY && !any_ra_slave)
1327 i->ra = MODE_DISABLED;
1328
1329 if (i->ndp == MODE_HYBRID)
1330 i->ndp = hybrid_mode;
1331
1332 if (i->ndp == MODE_RELAY && !any_ndp_slave)
1333 i->ndp = MODE_DISABLED;
1334
1335 if (i->dhcpv6 == MODE_RELAY || i->ra == MODE_RELAY || i->ndp == MODE_RELAY)
1336 master = i;
1337 }
1338
1339
1340 avl_for_each_element_safe(&interfaces, i, avl, tmp) {
1341 if (i->inuse && i->ifflags & IFF_RUNNING) {
1342 /* Resolve hybrid mode */
1343 if (i->dhcpv6 == MODE_HYBRID)
1344 i->dhcpv6 = (master && master->dhcpv6 == MODE_RELAY) ?
1345 MODE_RELAY : MODE_SERVER;
1346
1347 if (i->ra == MODE_HYBRID)
1348 i->ra = (master && master->ra == MODE_RELAY) ?
1349 MODE_RELAY : MODE_SERVER;
1350
1351 if (i->ndp == MODE_HYBRID)
1352 i->ndp = (master && master->ndp == MODE_RELAY) ?
1353 MODE_RELAY : MODE_DISABLED;
1354
1355 reload_services(i);
1356 } else
1357 close_interface(i);
1358 }
1359
1360 uci_unload(uci, dhcp);
1361 uci_free_context(uci);
1362 }
1363
1364 static void handle_signal(int signal)
1365 {
1366 char b[1] = {0};
1367
1368 if (signal == SIGHUP) {
1369 if (write(reload_pipe[1], b, sizeof(b)) < 0) {}
1370 } else
1371 uloop_end();
1372 }
1373
1374 static void reload_cb(struct uloop_fd *u, _unused unsigned int events)
1375 {
1376 char b[512];
1377 if (read(u->fd, b, sizeof(b)) < 0) {}
1378
1379 odhcpd_reload();
1380 }
1381
1382 static struct uloop_fd reload_fd = { .fd = -1, .cb = reload_cb };
1383
1384 void odhcpd_run(void)
1385 {
1386 if (pipe2(reload_pipe, O_NONBLOCK | O_CLOEXEC) < 0) {}
1387
1388 reload_fd.fd = reload_pipe[0];
1389 uloop_fd_add(&reload_fd, ULOOP_READ);
1390
1391 signal(SIGTERM, handle_signal);
1392 signal(SIGINT, handle_signal);
1393 signal(SIGHUP, handle_signal);
1394
1395 #ifdef WITH_UBUS
1396 while (ubus_init())
1397 sleep(1);
1398 #endif
1399
1400 odhcpd_reload();
1401 uloop_run();
1402 }
OpenWrt DHCP Server