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


85d77b06986588dc55ceaf1ed9a8a774472e4953
[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 interface *iface;
522 struct blob_attr *tb[IFACE_ATTR_MAX], *c;
523 bool get_addrs = false;
524 int mode;
525 const char *ifname = NULL;
526
527 blobmsg_parse(iface_attrs, IFACE_ATTR_MAX, tb, data, len);
528
529 if (tb[IFACE_ATTR_INTERFACE])
530 name = blobmsg_get_string(tb[IFACE_ATTR_INTERFACE]);
531
532 if (!name)
533 return -1;
534
535 iface = avl_find_element(&interfaces, name, iface, avl);
536 if (!iface) {
537 char *new_name;
538
539 iface = calloc_a(sizeof(*iface), &new_name, strlen(name) + 1);
540 if (!iface)
541 return -1;
542
543 iface->name = strcpy(new_name, name);
544 iface->avl.key = iface->name;
545 iface->router_event.uloop.fd = -1;
546 iface->dhcpv6_event.uloop.fd = -1;
547 iface->ndp_event.uloop.fd = -1;
548 iface->ndp_ping_fd = -1;
549 iface->dhcpv4_event.uloop.fd = -1;
550 INIT_LIST_HEAD(&iface->ia_assignments);
551 INIT_LIST_HEAD(&iface->dhcpv4_assignments);
552 INIT_LIST_HEAD(&iface->dhcpv4_fr_ips);
553
554 set_interface_defaults(iface);
555
556 avl_insert(&interfaces, &iface->avl);
557 get_addrs = overwrite = true;
558 }
559
560 if (overwrite) {
561 if ((c = tb[IFACE_ATTR_IFNAME]))
562 ifname = blobmsg_get_string(c);
563 else if ((c = tb[IFACE_ATTR_NETWORKID]))
564 ifname = blobmsg_get_string(c);
565 }
566
567 #ifdef WITH_UBUS
568 if (overwrite || !iface->ifname)
569 ifname = ubus_get_ifname(name);
570 #endif
571
572 if (!iface->ifname && !ifname)
573 goto err;
574
575 if (ifname) {
576 free(iface->ifname);
577 iface->ifname = strdup(ifname);
578
579 if (!iface->ifname)
580 goto err;
581
582 if (!iface->ifindex &&
583 (iface->ifindex = if_nametoindex(iface->ifname)) <= 0)
584 goto err;
585
586 if ((iface->ifflags = odhcpd_get_flags(iface)) < 0)
587 goto err;
588 }
589
590 if (get_addrs) {
591 ssize_t len = netlink_get_interface_addrs(iface->ifindex,
592 true, &iface->addr6);
593
594 if (len > 0)
595 iface->addr6_len = len;
596
597 len = netlink_get_interface_addrs(iface->ifindex,
598 false, &iface->addr4);
599 if (len > 0)
600 iface->addr4_len = len;
601 }
602
603 for (size_t i = 0; i < iface->addr6_len; i++) {
604 struct odhcpd_ipaddr *addr = &iface->addr6[i];
605
606 if (!addr->tentative) {
607 iface->have_link_local = true;
608 break;
609 }
610 }
611
612 iface->inuse = true;
613
614 if ((c = tb[IFACE_ATTR_DYNAMICDHCP]))
615 iface->no_dynamic_dhcp = !blobmsg_get_bool(c);
616
617 if ((c = tb[IFACE_ATTR_LEASETIME])) {
618 double time = parse_leasetime(c);
619
620 if (time >= 0)
621 iface->dhcp_leasetime = time;
622 else
623 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
624 iface_attrs[IFACE_ATTR_LEASETIME].name, iface->name);
625
626 }
627
628 if ((c = tb[IFACE_ATTR_PREFERRED_LIFETIME])) {
629 double time = parse_leasetime(c);
630
631 if (time >= 0)
632 iface->preferred_lifetime = time;
633 else
634 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
635 iface_attrs[IFACE_ATTR_PREFERRED_LIFETIME].name, iface->name);
636
637 }
638
639 if ((c = tb[IFACE_ATTR_START])) {
640 iface->dhcpv4_start.s_addr = htonl(blobmsg_get_u32(c));
641 iface->dhcpv4_end.s_addr = htonl(ntohl(iface->dhcpv4_start.s_addr) +
642 LIMIT_DEFAULT - 1);
643
644 if (config.main_dhcpv4 && config.legacy)
645 iface->dhcpv4 = MODE_SERVER;
646 }
647
648 if ((c = tb[IFACE_ATTR_LIMIT]))
649 iface->dhcpv4_end.s_addr = htonl(ntohl(iface->dhcpv4_start.s_addr) +
650 blobmsg_get_u32(c) - 1);
651
652 if ((c = tb[IFACE_ATTR_MASTER]))
653 iface->master = blobmsg_get_bool(c);
654
655 if (overwrite && (c = tb[IFACE_ATTR_UPSTREAM])) {
656 struct blob_attr *cur;
657 unsigned rem;
658
659 blobmsg_for_each_attr(cur, c, rem) {
660 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
661 continue;
662
663 iface->upstream = realloc(iface->upstream,
664 iface->upstream_len + blobmsg_data_len(cur));
665 if (!iface->upstream)
666 goto err;
667
668 memcpy(iface->upstream + iface->upstream_len, blobmsg_get_string(cur), blobmsg_data_len(cur));
669 iface->upstream_len += blobmsg_data_len(cur);
670 }
671 }
672
673 if ((c = tb[IFACE_ATTR_RA])) {
674 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0) {
675 iface->ra = mode;
676
677 if (iface->ra != MODE_DISABLED)
678 iface->ignore = false;
679 } else
680 syslog(LOG_ERR, "Invalid %s mode configured for interface '%s'",
681 iface_attrs[IFACE_ATTR_RA].name, iface->name);
682 }
683
684 if ((c = tb[IFACE_ATTR_DHCPV4])) {
685 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0) {
686 if (config.main_dhcpv4) {
687 iface->dhcpv4 = mode;
688
689 if (iface->dhcpv4 != MODE_DISABLED)
690 iface->ignore = false;
691 }
692 } else
693 syslog(LOG_ERR, "Invalid %s mode configured for interface %s",
694 iface_attrs[IFACE_ATTR_DHCPV4].name, iface->name);
695 }
696
697 if ((c = tb[IFACE_ATTR_DHCPV6])) {
698 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0) {
699 iface->dhcpv6 = mode;
700
701 if (iface->dhcpv6 != MODE_DISABLED)
702 iface->ignore = false;
703 } else
704 syslog(LOG_ERR, "Invalid %s mode configured for interface '%s'",
705 iface_attrs[IFACE_ATTR_DHCPV6].name, iface->name);
706 }
707
708 if ((c = tb[IFACE_ATTR_NDP])) {
709 if ((mode = parse_mode(blobmsg_get_string(c))) >= 0) {
710 iface->ndp = mode;
711
712 if (iface->ndp != MODE_DISABLED)
713 iface->ignore = false;
714 } else
715 syslog(LOG_ERR, "Invalid %s mode configured for interface '%s'",
716 iface_attrs[IFACE_ATTR_NDP].name, iface->name);
717 }
718
719 if ((c = tb[IFACE_ATTR_ROUTER])) {
720 struct blob_attr *cur;
721 unsigned rem;
722
723 blobmsg_for_each_attr(cur, c, rem) {
724 struct in_addr addr4;
725
726 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
727 continue;
728
729 if (inet_pton(AF_INET, blobmsg_get_string(cur), &addr4) == 1) {
730 iface->dhcpv4_router = realloc(iface->dhcpv4_router,
731 (++iface->dhcpv4_router_cnt) * sizeof(*iface->dhcpv4_router));
732 if (!iface->dhcpv4_router)
733 goto err;
734
735 iface->dhcpv4_router[iface->dhcpv4_router_cnt - 1] = addr4;
736 } else
737 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
738 iface_attrs[IFACE_ATTR_ROUTER].name, iface->name);
739 }
740 }
741
742 if ((c = tb[IFACE_ATTR_DNS])) {
743 struct blob_attr *cur;
744 unsigned rem;
745
746 iface->always_rewrite_dns = true;
747 blobmsg_for_each_attr(cur, c, rem) {
748 struct in_addr addr4;
749 struct in6_addr addr6;
750
751 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
752 continue;
753
754 if (inet_pton(AF_INET, blobmsg_get_string(cur), &addr4) == 1) {
755 if (addr4.s_addr == INADDR_ANY) {
756 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
757 iface_attrs[IFACE_ATTR_DNS].name, iface->name);
758
759 continue;
760 }
761
762 iface->dhcpv4_dns = realloc(iface->dhcpv4_dns,
763 (++iface->dhcpv4_dns_cnt) * sizeof(*iface->dhcpv4_dns));
764 if (!iface->dhcpv4_dns)
765 goto err;
766
767 iface->dhcpv4_dns[iface->dhcpv4_dns_cnt - 1] = addr4;
768 } else if (inet_pton(AF_INET6, blobmsg_get_string(cur), &addr6) == 1) {
769 if (IN6_IS_ADDR_UNSPECIFIED(&addr6)) {
770 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
771 iface_attrs[IFACE_ATTR_DNS].name, iface->name);
772
773 continue;
774 }
775
776 iface->dns = realloc(iface->dns,
777 (++iface->dns_cnt) * sizeof(*iface->dns));
778 if (!iface->dns)
779 goto err;
780
781 iface->dns[iface->dns_cnt - 1] = addr6;
782 } else
783 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
784 iface_attrs[IFACE_ATTR_DNS].name, iface->name);
785 }
786 }
787
788 if ((c = tb[IFACE_ATTR_DNS_SERVICE]))
789 iface->dns_service = blobmsg_get_bool(c);
790
791 if ((c = tb[IFACE_ATTR_DOMAIN])) {
792 struct blob_attr *cur;
793 unsigned rem;
794
795 blobmsg_for_each_attr(cur, c, rem) {
796 uint8_t buf[256];
797 char *domain = blobmsg_get_string(cur);
798 size_t domainlen = strlen(domain);
799 int len;
800
801 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
802 continue;
803
804 domain = blobmsg_get_string(cur);
805 domainlen = strlen(domain);
806
807 if (domainlen > 0 && domain[domainlen - 1] == '.')
808 domain[domainlen - 1] = 0;
809
810 len = dn_comp(domain, buf, sizeof(buf), NULL, NULL);
811 if (len <= 0) {
812 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
813 iface_attrs[IFACE_ATTR_DOMAIN].name, iface->name);
814
815 continue;
816 }
817
818 iface->search = realloc(iface->search, iface->search_len + len);
819 if (!iface->search)
820 goto err;
821
822 memcpy(&iface->search[iface->search_len], buf, len);
823 iface->search_len += len;
824 }
825 }
826
827 if ((c = tb[IFACE_ATTR_FILTER_CLASS])) {
828 iface->filter_class = realloc(iface->filter_class, blobmsg_data_len(c) + 1);
829 memcpy(iface->filter_class, blobmsg_get_string(c), blobmsg_data_len(c) + 1);
830 }
831
832 if ((c = tb[IFACE_ATTR_DHCPV4_FORCERECONF]))
833 iface->dhcpv4_forcereconf = blobmsg_get_bool(c);
834
835 if ((c = tb[IFACE_ATTR_DHCPV6_RAW])) {
836 iface->dhcpv6_raw_len = blobmsg_data_len(c) / 2;
837 iface->dhcpv6_raw = realloc(iface->dhcpv6_raw, iface->dhcpv6_raw_len);
838 odhcpd_unhexlify(iface->dhcpv6_raw, iface->dhcpv6_raw_len, blobmsg_get_string(c));
839 }
840
841 if ((c = tb[IFACE_ATTR_DHCPV6_ASSIGNALL]))
842 iface->dhcpv6_assignall = blobmsg_get_bool(c);
843
844 if ((c = tb[IFACE_ATTR_DHCPV6_PD]))
845 iface->dhcpv6_pd = blobmsg_get_bool(c);
846
847 if ((c = tb[IFACE_ATTR_DHCPV6_NA]))
848 iface->dhcpv6_na = blobmsg_get_bool(c);
849
850 if ((c = tb[IFACE_ATTR_DHCPV6_HOSTID_LEN])) {
851 uint32_t hostid_len = blobmsg_get_u32(c);
852
853 if (hostid_len >= HOSTID_LEN_MIN && hostid_len <= HOSTID_LEN_MAX)
854 iface->dhcpv6_hostid_len = hostid_len;
855 else
856 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
857 iface_attrs[IFACE_ATTR_DHCPV6_HOSTID_LEN].name, iface->name);
858
859 }
860
861 if ((c = tb[IFACE_ATTR_RA_DEFAULT]))
862 iface->default_router = blobmsg_get_u32(c);
863
864 if (!tb[IFACE_ATTR_RA_FLAGS] && !tb[IFACE_ATTR_RA_SLAAC] &&
865 (c = tb[IFACE_ATTR_RA_MANAGEMENT])) {
866 switch (blobmsg_get_u32(c)) {
867 case 0:
868 iface->ra_flags = ND_RA_FLAG_OTHER;
869 iface->ra_slaac = true;
870 break;
871 case 1:
872 iface->ra_flags = ND_RA_FLAG_OTHER|ND_RA_FLAG_MANAGED;
873 iface->ra_slaac = true;
874 break;
875 case 2:
876 iface->ra_flags = ND_RA_FLAG_OTHER|ND_RA_FLAG_MANAGED;
877 iface->ra_slaac = false;
878 break;
879 default:
880 break;
881 }
882 }
883
884 if ((c = tb[IFACE_ATTR_RA_FLAGS])) {
885 iface->ra_flags = 0;
886
887 if (parse_ra_flags(&iface->ra_flags, c) < 0)
888 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
889 iface_attrs[IFACE_ATTR_RA_FLAGS].name, iface->name);
890 }
891
892 if ((c = tb[IFACE_ATTR_RA_REACHABLETIME])) {
893 uint32_t ra_reachabletime = blobmsg_get_u32(c);
894
895 if (ra_reachabletime <= 3600000)
896 iface->ra_reachabletime = ra_reachabletime;
897 else
898 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
899 iface_attrs[IFACE_ATTR_RA_REACHABLETIME].name, iface->name);
900 }
901
902 if ((c = tb[IFACE_ATTR_RA_RETRANSTIME])) {
903 uint32_t ra_retranstime = blobmsg_get_u32(c);
904
905 if (ra_retranstime <= 60000)
906 iface->ra_retranstime = ra_retranstime;
907 else
908 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
909 iface_attrs[IFACE_ATTR_RA_RETRANSTIME].name, iface->name);
910 }
911
912 if ((c = tb[IFACE_ATTR_RA_HOPLIMIT])) {
913 uint32_t ra_hoplimit = blobmsg_get_u32(c);
914
915 if (ra_hoplimit <= 255)
916 iface->ra_hoplimit = ra_hoplimit;
917 else
918 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
919 iface_attrs[IFACE_ATTR_RA_HOPLIMIT].name, iface->name);
920 }
921
922 if ((c = tb[IFACE_ATTR_RA_MTU])) {
923 uint32_t ra_mtu = blobmsg_get_u32(c);
924
925 if (ra_mtu >= 1280 || ra_mtu <= 65535)
926 iface->ra_mtu = ra_mtu;
927 else
928 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
929 iface_attrs[IFACE_ATTR_RA_MTU].name, iface->name);
930 }
931
932 if ((c = tb[IFACE_ATTR_RA_SLAAC]))
933 iface->ra_slaac = blobmsg_get_bool(c);
934
935 if ((c = tb[IFACE_ATTR_RA_OFFLINK]))
936 iface->ra_not_onlink = blobmsg_get_bool(c);
937
938 if ((c = tb[IFACE_ATTR_RA_ADVROUTER]))
939 iface->ra_advrouter = blobmsg_get_bool(c);
940
941 if ((c = tb[IFACE_ATTR_RA_MININTERVAL]))
942 iface->ra_mininterval = blobmsg_get_u32(c);
943
944 if ((c = tb[IFACE_ATTR_RA_MAXINTERVAL]))
945 iface->ra_maxinterval = blobmsg_get_u32(c);
946
947 if ((c = tb[IFACE_ATTR_RA_LIFETIME]))
948 iface->ra_lifetime = blobmsg_get_u32(c);
949
950 if ((c = tb[IFACE_ATTR_RA_USELEASETIME]))
951 iface->ra_useleasetime = blobmsg_get_bool(c);
952
953 if ((c = tb[IFACE_ATTR_RA_DNS]))
954 iface->ra_dns = blobmsg_get_bool(c);
955
956 if ((c = tb[IFACE_ATTR_RA_PREFERENCE])) {
957 const char *prio = blobmsg_get_string(c);
958
959 if (!strcmp(prio, "high"))
960 iface->route_preference = 1;
961 else if (!strcmp(prio, "low"))
962 iface->route_preference = -1;
963 else if (!strcmp(prio, "medium") || !strcmp(prio, "default"))
964 iface->route_preference = 0;
965 else
966 syslog(LOG_ERR, "Invalid %s mode configured for interface '%s'",
967 iface_attrs[IFACE_ATTR_RA_PREFERENCE].name, iface->name);
968 }
969
970 if ((c = tb[IFACE_ATTR_PD_MANAGER]))
971 strncpy(iface->dhcpv6_pd_manager, blobmsg_get_string(c),
972 sizeof(iface->dhcpv6_pd_manager) - 1);
973
974 if ((c = tb[IFACE_ATTR_PD_CER]) &&
975 inet_pton(AF_INET6, blobmsg_get_string(c), &iface->dhcpv6_pd_cer) < 1)
976 syslog(LOG_ERR, "Invalid %s value configured for interface '%s'",
977 iface_attrs[IFACE_ATTR_PD_CER].name, iface->name);
978
979 if ((c = tb[IFACE_ATTR_NDPROXY_ROUTING]))
980 iface->learn_routes = blobmsg_get_bool(c);
981
982 if ((c = tb[IFACE_ATTR_NDPROXY_SLAVE]))
983 iface->external = blobmsg_get_bool(c);
984
985 if ((c = tb[IFACE_ATTR_PREFIX_FILTER])) {
986 const char *str = blobmsg_get_string(c);
987 char *astr = malloc(strlen(str) + 1);
988 char *delim;
989 int l;
990
991 if (!astr || !strcpy(astr, str) ||
992 (delim = strchr(astr, '/')) == NULL || (*(delim++) = 0) ||
993 sscanf(delim, "%i", &l) == 0 || l > 128 ||
994 inet_pton(AF_INET6, astr, &iface->pio_filter_addr) == 0)
995 iface->pio_filter_length = 0;
996 else
997 iface->pio_filter_length = l;
998
999 if (astr)
1000 free(astr);
1001 }
1002
1003 if (overwrite && (c = tb[IFACE_ATTR_NTP])) {
1004 struct blob_attr *cur;
1005 unsigned rem;
1006
1007 blobmsg_for_each_attr(cur, c, rem) {
1008 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING || !blobmsg_check_attr(cur, false))
1009 continue;
1010
1011 char *str = blobmsg_get_string(cur);
1012 struct in_addr addr4;
1013 struct in6_addr addr6;
1014
1015 if (inet_pton(AF_INET, str, &addr4) == 1) {
1016 if (addr4.s_addr == INADDR_ANY)
1017 goto err;
1018
1019 iface->dhcpv4_ntp = realloc(iface->dhcpv4_ntp,
1020 (++iface->dhcpv4_ntp_cnt) * sizeof(*iface->dhcpv4_ntp));
1021 if (!iface->dhcpv4_ntp)
1022 goto err;
1023
1024 iface->dhcpv4_ntp[iface->dhcpv4_ntp_cnt - 1] = addr4;
1025 } else if (inet_pton(AF_INET6, str, &addr6) == 1) {
1026 if (IN6_IS_ADDR_UNSPECIFIED(&addr6))
1027 goto err;
1028
1029 iface->dhcpv6_sntp = realloc(iface->dhcpv6_sntp,
1030 (++iface->dhcpv6_sntp_cnt) * sizeof(*iface->dhcpv6_sntp));
1031 if (!iface->dhcpv6_sntp)
1032 goto err;
1033
1034 iface->dhcpv6_sntp[iface->dhcpv6_sntp_cnt - 1] = addr6;
1035
1036 if (!parse_ntp_options(&iface->dhcpv6_ntp_len, addr6, &iface->dhcpv6_ntp))
1037 iface->dhcpv6_ntp_cnt++;
1038 } else {
1039 if (!parse_ntp_fqdn(&iface->dhcpv6_ntp_len, str, &iface->dhcpv6_ntp))
1040 iface->dhcpv6_ntp_cnt++;
1041 }
1042 }
1043 }
1044
1045 return 0;
1046
1047 err:
1048 close_interface(iface);
1049 return -1;
1050 }
1051
1052 static int set_interface(struct uci_section *s)
1053 {
1054 blob_buf_init(&b, 0);
1055 uci_to_blob(&b, s, &interface_attr_list);
1056
1057 return config_parse_interface(blob_data(b.head), blob_len(b.head), s->e.name, true);
1058 }
1059
1060 static void lease_delete_assignments(struct lease *l, bool v6)
1061 {
1062 struct dhcp_assignment *a, *tmp;
1063 unsigned int flag = v6 ? OAF_DHCPV6 : OAF_DHCPV4;
1064
1065 list_for_each_entry_safe(a, tmp, &l->assignments, lease_list) {
1066 if (a->flags & flag)
1067 free_assignment(a);
1068 }
1069 }
1070
1071 static void lease_update_assignments(struct lease *l)
1072 {
1073 struct dhcp_assignment *a;
1074
1075 list_for_each_entry(a, &l->assignments, lease_list) {
1076 if (a->hostname)
1077 free(a->hostname);
1078 a->hostname = NULL;
1079
1080 if (l->hostname)
1081 a->hostname = strdup(l->hostname);
1082
1083 a->leasetime = l->leasetime;
1084 }
1085 }
1086
1087 static int lease_cmp(const void *k1, const void *k2, _unused void *ptr)
1088 {
1089 const struct lease *l1 = k1, *l2 = k2;
1090 int cmp = 0;
1091
1092 if (l1->duid_len != l2->duid_len)
1093 return l1->duid_len - l2->duid_len;
1094
1095 if (l1->duid_len && l2->duid_len)
1096 cmp = memcmp(l1->duid, l2->duid, l1->duid_len);
1097
1098 if (cmp)
1099 return cmp;
1100
1101 return memcmp(l1->mac.ether_addr_octet, l2->mac.ether_addr_octet,
1102 sizeof(l1->mac.ether_addr_octet));
1103 }
1104
1105 static void lease_change_config(struct lease *l_old, struct lease *l_new)
1106 {
1107 bool update = false;
1108
1109 if ((!!l_new->hostname != !!l_old->hostname) ||
1110 (l_new->hostname && strcmp(l_new->hostname, l_old->hostname))) {
1111 free(l_old->hostname);
1112 l_old->hostname = NULL;
1113
1114 if (l_new->hostname)
1115 l_old->hostname = strdup(l_new->hostname);
1116
1117 update = true;
1118 }
1119
1120 if (l_old->leasetime != l_new->leasetime) {
1121 l_old->leasetime = l_new->leasetime;
1122 update = true;
1123 }
1124
1125 if (l_old->ipaddr != l_new->ipaddr) {
1126 l_old->ipaddr = l_new->ipaddr;
1127 lease_delete_assignments(l_old, false);
1128 }
1129
1130 if (l_old->hostid != l_new->hostid) {
1131 l_old->hostid = l_new->hostid;
1132 lease_delete_assignments(l_old, true);
1133 }
1134
1135 if (update)
1136 lease_update_assignments(l_old);
1137
1138 free_lease(l_new);
1139 }
1140
1141 static void lease_delete(struct lease *l)
1142 {
1143 struct dhcp_assignment *a, *tmp;
1144
1145 list_for_each_entry_safe(a, tmp, &l->assignments, lease_list)
1146 free_assignment(a);
1147
1148 free_lease(l);
1149 }
1150
1151 static void lease_update(_unused struct vlist_tree *tree, struct vlist_node *node_new,
1152 struct vlist_node *node_old)
1153 {
1154 struct lease *lease_new = container_of(node_new, struct lease, node);
1155 struct lease *lease_old = container_of(node_old, struct lease, node);
1156
1157 if (node_old && node_new)
1158 lease_change_config(lease_old, lease_new);
1159 else if (node_old)
1160 lease_delete(lease_old);
1161 }
1162
1163 struct lease *config_find_lease_by_duid(const uint8_t *duid, const uint16_t len)
1164 {
1165 struct lease *l;
1166
1167 vlist_for_each_element(&leases, l, node) {
1168 if (l->duid_len == len && !memcmp(l->duid, duid, len))
1169 return l;
1170 }
1171
1172 return NULL;
1173 }
1174
1175 struct lease *config_find_lease_by_mac(const uint8_t *mac)
1176 {
1177 struct lease *l;
1178
1179 vlist_for_each_element(&leases, l, node) {
1180 if (!memcmp(l->mac.ether_addr_octet, mac,
1181 sizeof(l->mac.ether_addr_octet)))
1182 return l;
1183 }
1184
1185 return NULL;
1186 }
1187
1188 struct lease *config_find_lease_by_hostid(const uint64_t hostid)
1189 {
1190 struct lease *l;
1191
1192 vlist_for_each_element(&leases, l, node) {
1193 if (l->hostid == hostid)
1194 return l;
1195 }
1196
1197 return NULL;
1198 }
1199
1200 struct lease *config_find_lease_by_ipaddr(const uint32_t ipaddr)
1201 {
1202 struct lease *l;
1203
1204 vlist_for_each_element(&leases, l, node) {
1205 if (l->ipaddr == ipaddr)
1206 return l;
1207 }
1208
1209 return NULL;
1210 }
1211
1212 void reload_services(struct interface *iface)
1213 {
1214 if (iface->ifflags & IFF_RUNNING) {
1215 syslog(LOG_DEBUG, "Enabling services with %s running", iface->ifname);
1216 router_setup_interface(iface, iface->ra != MODE_DISABLED);
1217 dhcpv6_setup_interface(iface, iface->dhcpv6 != MODE_DISABLED);
1218 ndp_setup_interface(iface, iface->ndp != MODE_DISABLED);
1219 #ifdef DHCPV4_SUPPORT
1220 dhcpv4_setup_interface(iface, iface->dhcpv4 != MODE_DISABLED);
1221 #endif
1222 } else {
1223 syslog(LOG_DEBUG, "Disabling services with %s not running", iface->ifname);
1224 router_setup_interface(iface, false);
1225 dhcpv6_setup_interface(iface, false);
1226 ndp_setup_interface(iface, false);
1227 #ifdef DHCPV4_SUPPORT
1228 dhcpv4_setup_interface(iface, false);
1229 #endif
1230 }
1231 }
1232
1233 void odhcpd_reload(void)
1234 {
1235 struct uci_context *uci = uci_alloc_context();
1236 struct interface *master = NULL, *i, *tmp;
1237
1238 if (!uci)
1239 return;
1240
1241 vlist_update(&leases);
1242 avl_for_each_element(&interfaces, i, avl)
1243 clean_interface(i);
1244
1245 struct uci_package *dhcp = NULL;
1246 if (!uci_load(uci, "dhcp", &dhcp)) {
1247 struct uci_element *e;
1248
1249 /* 1. Global settings */
1250 uci_foreach_element(&dhcp->sections, e) {
1251 struct uci_section *s = uci_to_section(e);
1252 if (!strcmp(s->type, "odhcpd"))
1253 set_config(s);
1254 }
1255
1256 /* 2. DHCP pools */
1257 uci_foreach_element(&dhcp->sections, e) {
1258 struct uci_section *s = uci_to_section(e);
1259 if (!strcmp(s->type, "dhcp"))
1260 set_interface(s);
1261 }
1262
1263 /* 3. Static leases */
1264 uci_foreach_element(&dhcp->sections, e) {
1265 struct uci_section* s = uci_to_section(e);
1266 if (!strcmp(s->type, "host"))
1267 set_lease_from_uci(s);
1268 }
1269 }
1270
1271 if (config.dhcp_statefile) {
1272 char *path = strdup(config.dhcp_statefile);
1273
1274 mkdir_p(dirname(path), 0755);
1275 free(path);
1276 }
1277
1278 vlist_flush(&leases);
1279
1280 #ifdef WITH_UBUS
1281 ubus_apply_network();
1282 #endif
1283
1284 bool any_dhcpv6_slave = false, any_ra_slave = false, any_ndp_slave = false;
1285
1286 /* Test for */
1287 avl_for_each_element(&interfaces, i, avl) {
1288 if (i->master)
1289 continue;
1290
1291 if (i->dhcpv6 == MODE_HYBRID || i->dhcpv6 == MODE_RELAY)
1292 any_dhcpv6_slave = true;
1293
1294 if (i->ra == MODE_HYBRID || i->ra == MODE_RELAY)
1295 any_ra_slave = true;
1296
1297 if (i->ndp == MODE_HYBRID || i->ndp == MODE_RELAY)
1298 any_ndp_slave = true;
1299 }
1300
1301 /* Evaluate hybrid mode for master */
1302 avl_for_each_element(&interfaces, i, avl) {
1303 if (!i->master)
1304 continue;
1305
1306 enum odhcpd_mode hybrid_mode = MODE_DISABLED;
1307 #ifdef WITH_UBUS
1308 if (!ubus_has_prefix(i->name, i->ifname))
1309 hybrid_mode = MODE_RELAY;
1310 #endif
1311
1312 if (i->dhcpv6 == MODE_HYBRID)
1313 i->dhcpv6 = hybrid_mode;
1314
1315 if (i->dhcpv6 == MODE_RELAY && !any_dhcpv6_slave)
1316 i->dhcpv6 = MODE_DISABLED;
1317
1318 if (i->ra == MODE_HYBRID)
1319 i->ra = hybrid_mode;
1320
1321 if (i->ra == MODE_RELAY && !any_ra_slave)
1322 i->ra = MODE_DISABLED;
1323
1324 if (i->ndp == MODE_HYBRID)
1325 i->ndp = hybrid_mode;
1326
1327 if (i->ndp == MODE_RELAY && !any_ndp_slave)
1328 i->ndp = MODE_DISABLED;
1329
1330 if (i->dhcpv6 == MODE_RELAY || i->ra == MODE_RELAY || i->ndp == MODE_RELAY)
1331 master = i;
1332 }
1333
1334
1335 avl_for_each_element_safe(&interfaces, i, avl, tmp) {
1336 if (i->inuse && i->ifflags & IFF_RUNNING) {
1337 /* Resolve hybrid mode */
1338 if (i->dhcpv6 == MODE_HYBRID)
1339 i->dhcpv6 = (master && master->dhcpv6 == MODE_RELAY) ?
1340 MODE_RELAY : MODE_SERVER;
1341
1342 if (i->ra == MODE_HYBRID)
1343 i->ra = (master && master->ra == MODE_RELAY) ?
1344 MODE_RELAY : MODE_SERVER;
1345
1346 if (i->ndp == MODE_HYBRID)
1347 i->ndp = (master && master->ndp == MODE_RELAY) ?
1348 MODE_RELAY : MODE_DISABLED;
1349
1350 reload_services(i);
1351 } else
1352 close_interface(i);
1353 }
1354
1355 uci_unload(uci, dhcp);
1356 uci_free_context(uci);
1357 }
1358
1359 static void handle_signal(int signal)
1360 {
1361 char b[1] = {0};
1362
1363 if (signal == SIGHUP) {
1364 if (write(reload_pipe[1], b, sizeof(b)) < 0) {}
1365 } else
1366 uloop_end();
1367 }
1368
1369 static void reload_cb(struct uloop_fd *u, _unused unsigned int events)
1370 {
1371 char b[512];
1372 if (read(u->fd, b, sizeof(b)) < 0) {}
1373
1374 odhcpd_reload();
1375 }
1376
1377 static struct uloop_fd reload_fd = { .fd = -1, .cb = reload_cb };
1378
1379 void odhcpd_run(void)
1380 {
1381 if (pipe2(reload_pipe, O_NONBLOCK | O_CLOEXEC) < 0) {}
1382
1383 reload_fd.fd = reload_pipe[0];
1384 uloop_fd_add(&reload_fd, ULOOP_READ);
1385
1386 signal(SIGTERM, handle_signal);
1387 signal(SIGINT, handle_signal);
1388 signal(SIGHUP, handle_signal);
1389
1390 #ifdef WITH_UBUS
1391 while (ubus_init())
1392 sleep(1);
1393 #endif
1394
1395 odhcpd_reload();
1396 uloop_run();
1397 }
OpenWrt DHCP Server