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


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