?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update to dhcpcd-9.2.0 with the following changes:
[dragonfly.git] / contrib / dhcpcd / src / if-options.c
blob213d05cc186b8265c54c390ee486a25492ab36dc
1 /* SPDX-License-Identifier: BSD-2-Clause */
2 /*
3 * dhcpcd - DHCP client daemon
4 * Copyright (c) 2006-2020 Roy Marples <roy@marples.name>
5 * All rights reserved
6
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <sys/param.h>
30 #include <sys/types.h>
31
32 #include <arpa/inet.h>
33
34 #include <ctype.h>
35 #include <errno.h>
36 #include <getopt.h>
37 #include <grp.h>
38 #include <inttypes.h>
39 #include <limits.h>
40 #include <paths.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <unistd.h>
45 #include <time.h>
46
47 #include "config.h"
48 #include "common.h"
49 #include "dhcp.h"
50 #include "dhcp6.h"
51 #include "dhcpcd-embedded.h"
52 #include "if.h"
53 #include "if-options.h"
54 #include "ipv4.h"
55 #include "logerr.h"
56 #include "sa.h"
57
58 #define IN_CONFIG_BLOCK(ifo) ((ifo)->options & DHCPCD_FORKED)
59 #define SET_CONFIG_BLOCK(ifo) ((ifo)->options |= DHCPCD_FORKED)
60 #define CLEAR_CONFIG_BLOCK(ifo) ((ifo)->options &= ~DHCPCD_FORKED)
61
62 static unsigned long long default_options;
63
64 const struct option cf_options[] = {
65 {"background", no_argument, NULL, 'b'},
66 {"script", required_argument, NULL, 'c'},
67 {"debug", no_argument, NULL, 'd'},
68 {"env", required_argument, NULL, 'e'},
69 {"config", required_argument, NULL, 'f'},
70 {"reconfigure", no_argument, NULL, 'g'},
71 {"hostname", optional_argument, NULL, 'h'},
72 {"vendorclassid", optional_argument, NULL, 'i'},
73 {"logfile", required_argument, NULL, 'j'},
74 {"release", no_argument, NULL, 'k'},
75 {"leasetime", required_argument, NULL, 'l'},
76 {"metric", required_argument, NULL, 'm'},
77 {"rebind", no_argument, NULL, 'n'},
78 {"option", required_argument, NULL, 'o'},
79 {"persistent", no_argument, NULL, 'p'},
80 {"quiet", no_argument, NULL, 'q'},
81 {"request", optional_argument, NULL, 'r'},
82 {"inform", optional_argument, NULL, 's'},
83 {"inform6", optional_argument, NULL, O_INFORM6},
84 {"timeout", required_argument, NULL, 't'},
85 {"userclass", required_argument, NULL, 'u'},
86 #ifndef SMALL
87 {"msuserclass", required_argument, NULL, O_MSUSERCLASS},
88 #endif
89 {"vendor", required_argument, NULL, 'v'},
90 {"waitip", optional_argument, NULL, 'w'},
91 {"exit", no_argument, NULL, 'x'},
92 {"allowinterfaces", required_argument, NULL, 'z'},
93 {"reboot", required_argument, NULL, 'y'},
94 {"noarp", no_argument, NULL, 'A'},
95 {"nobackground", no_argument, NULL, 'B'},
96 {"nohook", required_argument, NULL, 'C'},
97 {"duid", no_argument, NULL, 'D'},
98 {"lastlease", no_argument, NULL, 'E'},
99 {"fqdn", optional_argument, NULL, 'F'},
100 {"nogateway", no_argument, NULL, 'G'},
101 {"xidhwaddr", no_argument, NULL, 'H'},
102 {"clientid", optional_argument, NULL, 'I'},
103 {"broadcast", no_argument, NULL, 'J'},
104 {"nolink", no_argument, NULL, 'K'},
105 {"noipv4ll", no_argument, NULL, 'L'},
106 {"master", no_argument, NULL, 'M'},
107 {"renew", no_argument, NULL, 'N'},
108 {"nooption", required_argument, NULL, 'O'},
109 {"printpidfile", no_argument, NULL, 'P'},
110 {"require", required_argument, NULL, 'Q'},
111 {"static", required_argument, NULL, 'S'},
112 {"test", no_argument, NULL, 'T'},
113 {"dumplease", no_argument, NULL, 'U'},
114 {"variables", no_argument, NULL, 'V'},
115 {"whitelist", required_argument, NULL, 'W'},
116 {"blacklist", required_argument, NULL, 'X'},
117 {"denyinterfaces", required_argument, NULL, 'Z'},
118 {"oneshot", no_argument, NULL, '1'},
119 {"ipv4only", no_argument, NULL, '4'},
120 {"ipv6only", no_argument, NULL, '6'},
121 {"anonymous", no_argument, NULL, O_ANONYMOUS},
122 {"arping", required_argument, NULL, O_ARPING},
123 {"destination", required_argument, NULL, O_DESTINATION},
124 {"fallback", required_argument, NULL, O_FALLBACK},
125 {"ipv6rs", no_argument, NULL, O_IPV6RS},
126 {"noipv6rs", no_argument, NULL, O_NOIPV6RS},
127 {"ipv6ra_autoconf", no_argument, NULL, O_IPV6RA_AUTOCONF},
128 {"ipv6ra_noautoconf", no_argument, NULL, O_IPV6RA_NOAUTOCONF},
129 {"ipv6ra_fork", no_argument, NULL, O_IPV6RA_FORK},
130 {"ipv4", no_argument, NULL, O_IPV4},
131 {"noipv4", no_argument, NULL, O_NOIPV4},
132 {"ipv6", no_argument, NULL, O_IPV6},
133 {"noipv6", no_argument, NULL, O_NOIPV6},
134 {"noalias", no_argument, NULL, O_NOALIAS},
135 {"iaid", required_argument, NULL, O_IAID},
136 {"ia_na", no_argument, NULL, O_IA_NA},
137 {"ia_ta", no_argument, NULL, O_IA_TA},
138 {"ia_pd", no_argument, NULL, O_IA_PD},
139 {"hostname_short", no_argument, NULL, O_HOSTNAME_SHORT},
140 {"dev", required_argument, NULL, O_DEV},
141 {"nodev", no_argument, NULL, O_NODEV},
142 {"define", required_argument, NULL, O_DEFINE},
143 {"definend", required_argument, NULL, O_DEFINEND},
144 {"define6", required_argument, NULL, O_DEFINE6},
145 {"embed", required_argument, NULL, O_EMBED},
146 {"encap", required_argument, NULL, O_ENCAP},
147 {"vendopt", required_argument, NULL, O_VENDOPT},
148 {"vendclass", required_argument, NULL, O_VENDCLASS},
149 {"authprotocol", required_argument, NULL, O_AUTHPROTOCOL},
150 {"authtoken", required_argument, NULL, O_AUTHTOKEN},
151 {"noauthrequired", no_argument, NULL, O_AUTHNOTREQUIRED},
152 {"dhcp", no_argument, NULL, O_DHCP},
153 {"nodhcp", no_argument, NULL, O_NODHCP},
154 {"dhcp6", no_argument, NULL, O_DHCP6},
155 {"nodhcp6", no_argument, NULL, O_NODHCP6},
156 {"controlgroup", required_argument, NULL, O_CONTROLGRP},
157 {"slaac", required_argument, NULL, O_SLAAC},
158 {"gateway", no_argument, NULL, O_GATEWAY},
159 {"reject", required_argument, NULL, O_REJECT},
160 {"bootp", no_argument, NULL, O_BOOTP},
161 {"nodelay", no_argument, NULL, O_NODELAY},
162 {"noup", no_argument, NULL, O_NOUP},
163 {"lastleaseextend", no_argument, NULL, O_LASTLEASE_EXTEND},
164 {"inactive", no_argument, NULL, O_INACTIVE},
165 {"mudurl", required_argument, NULL, O_MUDURL},
166 {"link_rcvbuf", required_argument, NULL, O_LINK_RCVBUF},
167 {"poll", optional_argument, NULL, O_POLL},
168 {NULL, 0, NULL, '\0'}
169 };
170
171 static char *
172 add_environ(char ***array, const char *value, int uniq)
173 {
174 char **newlist, **list = *array;
175 size_t i = 0, l, lv;
176 char *match = NULL, *p, *n;
177
178 match = strdup(value);
179 if (match == NULL) {
180 logerr(__func__);
181 return NULL;
182 }
183 p = strchr(match, '=');
184 if (p == NULL) {
185 logerrx("%s: no assignment: %s", __func__, value);
186 free(match);
187 return NULL;
188 }
189 *p++ = '\0';
190 l = strlen(match);
191
192 while (list && list[i]) {
193 if (match && strncmp(list[i], match, l) == 0) {
194 if (uniq) {
195 n = strdup(value);
196 if (n == NULL) {
197 logerr(__func__);
198 free(match);
199 return NULL;
200 }
201 free(list[i]);
202 list[i] = n;
203 } else {
204 /* Append a space and the value to it */
205 l = strlen(list[i]);
206 lv = strlen(p);
207 n = realloc(list[i], l + lv + 2);
208 if (n == NULL) {
209 logerr(__func__);
210 free(match);
211 return NULL;
212 }
213 list[i] = n;
214 list[i][l] = ' ';
215 memcpy(list[i] + l + 1, p, lv);
216 list[i][l + lv + 1] = '\0';
217 }
218 free(match);
219 return list[i];
220 }
221 i++;
222 }
223
224 free(match);
225 n = strdup(value);
226 if (n == NULL) {
227 logerr(__func__);
228 return NULL;
229 }
230 newlist = reallocarray(list, i + 2, sizeof(char *));
231 if (newlist == NULL) {
232 logerr(__func__);
233 free(n);
234 return NULL;
235 }
236 newlist[i] = n;
237 newlist[i + 1] = NULL;
238 *array = newlist;
239 return newlist[i];
240 }
241
242 #define PARSE_STRING 0
243 #define PARSE_STRING_NULL 1
244 #define PARSE_HWADDR 2
245 #define parse_string(a, b, c) parse_str((a), (b), (c), PARSE_STRING)
246 #define parse_nstring(a, b, c) parse_str((a), (b), (c), PARSE_STRING_NULL)
247 #define parse_hwaddr(a, b, c) parse_str((a), (b), (c), PARSE_HWADDR)
248 static ssize_t
249 parse_str(char *sbuf, size_t slen, const char *str, int flags)
250 {
251 size_t l;
252 const char *p, *end;
253 int i;
254 char c[4], cmd;
255
256 end = str + strlen(str);
257 /* If surrounded by quotes then it's a string */
258 if (*str == '"') {
259 p = end - 1;
260 if (*p == '"') {
261 str++;
262 end = p;
263 }
264 } else {
265 l = (size_t)hwaddr_aton(NULL, str);
266 if ((ssize_t) l != -1 && l > 1) {
267 if (l > slen) {
268 errno = ENOBUFS;
269 return -1;
270 }
271 hwaddr_aton((uint8_t *)sbuf, str);
272 return (ssize_t)l;
273 }
274 }
275
276 /* Process escapes */
277 l = 0;
278 /* If processing a string on the clientid, first byte should be
279 * 0 to indicate a non hardware type */
280 if (flags == PARSE_HWADDR && *str) {
281 if (sbuf)
282 *sbuf++ = 0;
283 l++;
284 }
285 c[3] = '\0';
286 while (str < end) {
287 if (++l > slen && sbuf) {
288 errno = ENOBUFS;
289 return -1;
290 }
291 if (*str == '\\') {
292 str++;
293 switch((cmd = *str++)) {
294 case '\0':
295 str--;
296 break;
297 case 'b':
298 if (sbuf)
299 *sbuf++ = '\b';
300 break;
301 case 'n':
302 if (sbuf)
303 *sbuf++ = '\n';
304 break;
305 case 'r':
306 if (sbuf)
307 *sbuf++ = '\r';
308 break;
309 case 't':
310 if (sbuf)
311 *sbuf++ = '\t';
312 break;
313 case 'x':
314 /* Grab a hex code */
315 c[1] = '\0';
316 for (i = 0; i < 2; i++) {
317 if (isxdigit((unsigned char)*str) == 0)
318 break;
319 c[i] = *str++;
320 }
321 if (c[1] != '\0' && sbuf) {
322 c[2] = '\0';
323 *sbuf++ = (char)strtol(c, NULL, 16);
324 } else
325 l--;
326 break;
327 case '0':
328 /* Grab an octal code */
329 c[2] = '\0';
330 for (i = 0; i < 3; i++) {
331 if (*str < '0' || *str > '7')
332 break;
333 c[i] = *str++;
334 }
335 if (c[2] != '\0' && sbuf) {
336 i = (int)strtol(c, NULL, 8);
337 if (i > 255)
338 i = 255;
339 *sbuf ++= (char)i;
340 } else
341 l--;
342 break;
343 default:
344 if (sbuf)
345 *sbuf++ = cmd;
346 break;
347 }
348 } else {
349 if (sbuf)
350 *sbuf++ = *str;
351 str++;
352 }
353 }
354 if (flags == PARSE_STRING_NULL) {
355 l++;
356 if (sbuf != NULL) {
357 if (l > slen) {
358 errno = ENOBUFS;
359 return -1;
360 }
361 *sbuf = '\0';
362 }
363 }
364 return (ssize_t)l;
365 }
366
367 static int
368 parse_iaid1(uint8_t *iaid, const char *arg, size_t len, int n)
369 {
370 int e;
371 uint32_t narg;
372 ssize_t s;
373
374 narg = (uint32_t)strtou(arg, NULL, 0, 0, UINT32_MAX, &e);
375 if (e == 0) {
376 if (n)
377 narg = htonl(narg);
378 memcpy(iaid, &narg, sizeof(narg));
379 return 0;
380 }
381
382 if ((s = parse_string((char *)iaid, len, arg)) < 1)
383 return -1;
384 if (s < 4)
385 iaid[3] = '\0';
386 if (s < 3)
387 iaid[2] = '\0';
388 if (s < 2)
389 iaid[1] = '\0';
390 return 0;
391 }
392
393 static int
394 parse_iaid(uint8_t *iaid, const char *arg, size_t len)
395 {
396
397 return parse_iaid1(iaid, arg, len, 1);
398 }
399
400 #ifdef AUTH
401 static int
402 parse_uint32(uint32_t *i, const char *arg)
403 {
404
405 return parse_iaid1((uint8_t *)i, arg, sizeof(uint32_t), 0);
406 }
407 #endif
408
409 static char **
410 splitv(int *argc, char **argv, const char *arg)
411 {
412 char **n, **v = argv;
413 char *o = strdup(arg), *p, *t, *nt;
414
415 if (o == NULL) {
416 logerr(__func__);
417 return v;
418 }
419 p = o;
420 while ((t = strsep(&p, ", "))) {
421 nt = strdup(t);
422 if (nt == NULL) {
423 logerr(__func__);
424 free(o);
425 return v;
426 }
427 n = reallocarray(v, (size_t)(*argc) + 1, sizeof(char *));
428 if (n == NULL) {
429 logerr(__func__);
430 free(o);
431 free(nt);
432 return v;
433 }
434 v = n;
435 v[(*argc)++] = nt;
436 }
437 free(o);
438 return v;
439 }
440
441 #ifdef INET
442 static int
443 parse_addr(struct in_addr *addr, struct in_addr *net, const char *arg)
444 {
445 char *p;
446
447 if (arg == NULL || *arg == '\0') {
448 if (addr != NULL)
449 addr->s_addr = 0;
450 if (net != NULL)
451 net->s_addr = 0;
452 return 0;
453 }
454 if ((p = strchr(arg, '/')) != NULL) {
455 int e;
456 intmax_t i;
457
458 *p++ = '\0';
459 i = strtoi(p, NULL, 10, 0, 32, &e);
460 if (e != 0 ||
461 (net != NULL && inet_cidrtoaddr((int)i, net) != 0))
462 {
463 logerrx("`%s' is not a valid CIDR", p);
464 return -1;
465 }
466 }
467
468 if (addr != NULL && inet_aton(arg, addr) == 0) {
469 logerrx("`%s' is not a valid IP address", arg);
470 return -1;
471 }
472 if (p != NULL)
473 *--p = '/';
474 else if (net != NULL && addr != NULL)
475 net->s_addr = ipv4_getnetmask(addr->s_addr);
476 return 0;
477 }
478 #else
479 static int
480 parse_addr(__unused struct in_addr *addr, __unused struct in_addr *net,
481 __unused const char *arg)
482 {
483
484 logerrx("No IPv4 support");
485 return -1;
486 }
487 #endif
488
489 static void
490 set_option_space(struct dhcpcd_ctx *ctx,
491 const char *arg,
492 const struct dhcp_opt **d, size_t *dl,
493 const struct dhcp_opt **od, size_t *odl,
494 struct if_options *ifo,
495 uint8_t *request[], uint8_t *require[], uint8_t *no[], uint8_t *reject[])
496 {
497
498 #if !defined(INET) && !defined(INET6)
499 UNUSED(ctx);
500 #endif
501
502 #ifdef INET6
503 if (strncmp(arg, "nd_", strlen("nd_")) == 0) {
504 *d = ctx->nd_opts;
505 *dl = ctx->nd_opts_len;
506 *od = ifo->nd_override;
507 *odl = ifo->nd_override_len;
508 *request = ifo->requestmasknd;
509 *require = ifo->requiremasknd;
510 *no = ifo->nomasknd;
511 *reject = ifo->rejectmasknd;
512 return;
513 }
514
515 #ifdef DHCP6
516 if (strncmp(arg, "dhcp6_", strlen("dhcp6_")) == 0) {
517 *d = ctx->dhcp6_opts;
518 *dl = ctx->dhcp6_opts_len;
519 *od = ifo->dhcp6_override;
520 *odl = ifo->dhcp6_override_len;
521 *request = ifo->requestmask6;
522 *require = ifo->requiremask6;
523 *no = ifo->nomask6;
524 *reject = ifo->rejectmask6;
525 return;
526 }
527 #endif
528 #else
529 UNUSED(arg);
530 #endif
531
532 #ifdef INET
533 *d = ctx->dhcp_opts;
534 *dl = ctx->dhcp_opts_len;
535 *od = ifo->dhcp_override;
536 *odl = ifo->dhcp_override_len;
537 #else
538 *d = NULL;
539 *dl = 0;
540 *od = NULL;
541 *odl = 0;
542 #endif
543 *request = ifo->requestmask;
544 *require = ifo->requiremask;
545 *no = ifo->nomask;
546 *reject = ifo->rejectmask;
547 }
548
549 void
550 free_dhcp_opt_embenc(struct dhcp_opt *opt)
551 {
552 size_t i;
553 struct dhcp_opt *o;
554
555 free(opt->var);
556
557 for (i = 0, o = opt->embopts; i < opt->embopts_len; i++, o++)
558 free_dhcp_opt_embenc(o);
559 free(opt->embopts);
560 opt->embopts_len = 0;
561 opt->embopts = NULL;
562
563 for (i = 0, o = opt->encopts; i < opt->encopts_len; i++, o++)
564 free_dhcp_opt_embenc(o);
565 free(opt->encopts);
566 opt->encopts_len = 0;
567 opt->encopts = NULL;
568 }
569
570 static char *
571 strwhite(const char *s)
572 {
573
574 if (s == NULL)
575 return NULL;
576 while (*s != ' ' && *s != '\t') {
577 if (*s == '\0')
578 return NULL;
579 s++;
580 }
581 return UNCONST(s);
582 }
583
584 static char *
585 strskipwhite(const char *s)
586 {
587
588 if (s == NULL || *s == '\0')
589 return NULL;
590 while (*s == ' ' || *s == '\t') {
591 s++;
592 if (*s == '\0')
593 return NULL;
594 }
595 return UNCONST(s);
596 }
597
598 #ifdef AUTH
599 /* Find the end pointer of a string. */
600 static char *
601 strend(const char *s)
602 {
603
604 s = strskipwhite(s);
605 if (s == NULL)
606 return NULL;
607 if (*s != '"')
608 return strchr(s, ' ');
609 s++;
610 for (; *s != '"' ; s++) {
611 if (*s == '\0')
612 return NULL;
613 if (*s == '\\') {
614 if (*(++s) == '\0')
615 return NULL;
616 }
617 }
618 return UNCONST(++s);
619 }
620 #endif
621
622 static int
623 parse_option(struct dhcpcd_ctx *ctx, const char *ifname, struct if_options *ifo,
624 int opt, const char *arg, struct dhcp_opt **ldop, struct dhcp_opt **edop)
625 {
626 int e, i, t;
627 long l;
628 unsigned long u;
629 char *p = NULL, *bp, *fp, *np;
630 ssize_t s;
631 struct in_addr addr, addr2;
632 in_addr_t *naddr;
633 struct rt *rt;
634 const struct dhcp_opt *d, *od;
635 uint8_t *request, *require, *no, *reject;
636 struct dhcp_opt **dop, *ndop;
637 size_t *dop_len, dl, odl;
638 struct vivco *vivco;
639 struct group *grp;
640 #ifdef AUTH
641 struct token *token;
642 #endif
643 #ifdef _REENTRANT
644 struct group grpbuf;
645 #endif
646 #ifdef DHCP6
647 size_t sl;
648 struct if_ia *ia;
649 uint8_t iaid[4];
650 #ifndef SMALL
651 struct if_sla *sla, *slap;
652 #endif
653 #endif
654
655 dop = NULL;
656 dop_len = NULL;
657 #ifdef INET6
658 i = 0;
659 #endif
660
661 /* Add a guard for static analysers.
662 * This should not be needed really because of the argument_required option
663 * in the options declaration above. */
664 #define ARG_REQUIRED if (arg == NULL) goto arg_required
665
666 switch(opt) {
667 case 'f': /* FALLTHROUGH */
668 case 'g': /* FALLTHROUGH */
669 case 'n': /* FALLTHROUGH */
670 case 'q': /* FALLTHROUGH */
671 case 'x': /* FALLTHROUGH */
672 case 'N': /* FALLTHROUGH */
673 case 'P': /* FALLTHROUGH */
674 case 'T': /* FALLTHROUGH */
675 case 'U': /* FALLTHROUGH */
676 case 'V': /* We need to handle non interface options */
677 break;
678 case 'b':
679 ifo->options |= DHCPCD_BACKGROUND;
680 break;
681 case 'c':
682 ARG_REQUIRED;
683 if (IN_CONFIG_BLOCK(ifo)) {
684 logerrx("%s: per interface scripts"
685 " are no longer supported",
686 ifname);
687 return -1;
688 }
689 if (ctx->script != dhcpcd_default_script)
690 free(ctx->script);
691 s = parse_nstring(NULL, 0, arg);
692 if (s == 0) {
693 ctx->script = NULL;
694 break;
695 }
696 dl = (size_t)s;
697 if (s == -1 || (ctx->script = malloc(dl)) == NULL) {
698 ctx->script = NULL;
699 logerr(__func__);
700 return -1;
701 }
702 s = parse_nstring(ctx->script, dl, arg);
703 if (s == -1 ||
704 ctx->script[0] == '\0' ||
705 strcmp(ctx->script, "/dev/null") == 0)
706 {
707 free(ctx->script);
708 ctx->script = NULL;
709 }
710 break;
711 case 'd':
712 ifo->options |= DHCPCD_DEBUG;
713 break;
714 case 'e':
715 ARG_REQUIRED;
716 add_environ(&ifo->environ, arg, 1);
717 break;
718 case 'h':
719 if (!arg) {
720 ifo->options |= DHCPCD_HOSTNAME;
721 break;
722 }
723 s = parse_nstring(ifo->hostname, sizeof(ifo->hostname), arg);
724 if (s == -1) {
725 logerr("%s: hostname", __func__);
726 return -1;
727 }
728 if (s != 0 && ifo->hostname[0] == '.') {
729 logerrx("hostname cannot begin with .");
730 return -1;
731 }
732 if (ifo->hostname[0] == '\0')
733 ifo->options &= ~DHCPCD_HOSTNAME;
734 else
735 ifo->options |= DHCPCD_HOSTNAME;
736 break;
737 case 'i':
738 if (arg)
739 s = parse_string((char *)ifo->vendorclassid + 1,
740 VENDORCLASSID_MAX_LEN, arg);
741 else
742 s = 0;
743 if (s == -1) {
744 logerr("vendorclassid");
745 return -1;
746 }
747 *ifo->vendorclassid = (uint8_t)s;
748 break;
749 case 'j':
750 ARG_REQUIRED;
751 /* per interface logging is not supported
752 * don't want to overide the commandline */
753 if (!IN_CONFIG_BLOCK(ifo) && ctx->logfile == NULL) {
754 logclose();
755 ctx->logfile = strdup(arg);
756 logopen(ctx->logfile);
757 }
758 break;
759 case 'k':
760 ifo->options |= DHCPCD_RELEASE;
761 break;
762 case 'l':
763 ARG_REQUIRED;
764 if (strcmp(arg, "-1") == 0) {
765 ifo->leasetime = DHCP_INFINITE_LIFETIME;
766 break;
767 }
768 ifo->leasetime = (uint32_t)strtou(arg, NULL,
769 0, 0, UINT32_MAX, &e);
770 if (e) {
771 logerrx("failed to convert leasetime %s", arg);
772 return -1;
773 }
774 break;
775 case 'm':
776 ARG_REQUIRED;
777 ifo->metric = (int)strtoi(arg, NULL, 0, 0, INT32_MAX, &e);
778 if (e) {
779 logerrx("failed to convert metric %s", arg);
780 return -1;
781 }
782 break;
783 case 'o':
784 ARG_REQUIRED;
785 set_option_space(ctx, arg, &d, &dl, &od, &odl, ifo,
786 &request, &require, &no, &reject);
787 if (make_option_mask(d, dl, od, odl, request, arg, 1) != 0 ||
788 make_option_mask(d, dl, od, odl, no, arg, -1) != 0 ||
789 make_option_mask(d, dl, od, odl, reject, arg, -1) != 0)
790 {
791 logerrx("unknown option `%s'", arg);
792 return -1;
793 }
794 break;
795 case O_REJECT:
796 ARG_REQUIRED;
797 set_option_space(ctx, arg, &d, &dl, &od, &odl, ifo,
798 &request, &require, &no, &reject);
799 if (make_option_mask(d, dl, od, odl, reject, arg, 1) != 0 ||
800 make_option_mask(d, dl, od, odl, request, arg, -1) != 0 ||
801 make_option_mask(d, dl, od, odl, require, arg, -1) != 0)
802 {
803 logerrx("unknown option `%s'", arg);
804 return -1;
805 }
806 break;
807 case 'p':
808 ifo->options |= DHCPCD_PERSISTENT;
809 break;
810 case 'r':
811 if (parse_addr(&ifo->req_addr, NULL, arg) != 0)
812 return -1;
813 ifo->options |= DHCPCD_REQUEST;
814 ifo->req_mask.s_addr = 0;
815 break;
816 case 's':
817 if (arg && *arg != '\0') {
818 /* Strip out a broadcast address */
819 p = strchr(arg, '/');
820 if (p != NULL) {
821 p = strchr(p + 1, '/');
822 if (p != NULL)
823 *p = '\0';
824 }
825 i = parse_addr(&ifo->req_addr, &ifo->req_mask, arg);
826 if (p != NULL) {
827 /* Ensure the original string is preserved */
828 *p++ = '/';
829 if (i == 0)
830 i = parse_addr(&ifo->req_brd, NULL, p);
831 }
832 if (i != 0)
833 return -1;
834 } else {
835 ifo->req_addr.s_addr = 0;
836 ifo->req_mask.s_addr = 0;
837 }
838 ifo->options |= DHCPCD_INFORM | DHCPCD_PERSISTENT;
839 ifo->options &= ~DHCPCD_STATIC;
840 break;
841 case O_INFORM6:
842 ifo->options |= DHCPCD_INFORM6;
843 break;
844 case 't':
845 ARG_REQUIRED;
846 ifo->timeout = (uint32_t)strtou(arg, NULL, 0, 0, UINT32_MAX, &e);
847 if (e) {
848 logerrx("failed to convert timeout %s", arg);
849 return -1;
850 }
851 break;
852 case 'u':
853 dl = sizeof(ifo->userclass) - ifo->userclass[0] - 1;
854 s = parse_string((char *)ifo->userclass +
855 ifo->userclass[0] + 2, dl, arg);
856 if (s == -1) {
857 logerr("userclass");
858 return -1;
859 }
860 if (s != 0) {
861 ifo->userclass[ifo->userclass[0] + 1] = (uint8_t)s;
862 ifo->userclass[0] = (uint8_t)(ifo->userclass[0] + s +1);
863 }
864 break;
865 #ifndef SMALL
866 case O_MSUSERCLASS:
867 /* Some Microsoft DHCP servers expect userclass to be an
868 * opaque blob. This is not RFC 3004 compliant. */
869 s = parse_string((char *)ifo->userclass + 1,
870 sizeof(ifo->userclass) - 1, arg);
871 if (s == -1) {
872 logerr("msuserclass");
873 return -1;
874 }
875 ifo->userclass[0] = (uint8_t)s;
876 break;
877 #endif
878 case 'v':
879 ARG_REQUIRED;
880 p = strchr(arg, ',');
881 if (!p || !p[1]) {
882 logerrx("invalid vendor format: %s", arg);
883 return -1;
884 }
885
886 /* If vendor starts with , then it is not encapsulated */
887 if (p == arg) {
888 arg++;
889 s = parse_string((char *)ifo->vendor + 1,
890 VENDOR_MAX_LEN, arg);
891 if (s == -1) {
892 logerr("vendor");
893 return -1;
894 }
895 ifo->vendor[0] = (uint8_t)s;
896 ifo->options |= DHCPCD_VENDORRAW;
897 break;
898 }
899
900 /* Encapsulated vendor options */
901 if (ifo->options & DHCPCD_VENDORRAW) {
902 ifo->options &= ~DHCPCD_VENDORRAW;
903 ifo->vendor[0] = 0;
904 }
905
906 /* Strip and preserve the comma */
907 *p = '\0';
908 i = (int)strtoi(arg, NULL, 0, 1, 254, &e);
909 *p = ',';
910 if (e) {
911 logerrx("vendor option should be between"
912 " 1 and 254 inclusive");
913 return -1;
914 }
915
916 arg = p + 1;
917 s = VENDOR_MAX_LEN - ifo->vendor[0] - 2;
918 if (inet_aton(arg, &addr) == 1) {
919 if (s < 6) {
920 s = -1;
921 errno = ENOBUFS;
922 } else {
923 memcpy(ifo->vendor + ifo->vendor[0] + 3,
924 &addr.s_addr, sizeof(addr.s_addr));
925 s = sizeof(addr.s_addr);
926 }
927 } else {
928 s = parse_string((char *)ifo->vendor +
929 ifo->vendor[0] + 3, (size_t)s, arg);
930 }
931 if (s == -1) {
932 logerr("vendor");
933 return -1;
934 }
935 if (s != 0) {
936 ifo->vendor[ifo->vendor[0] + 1] = (uint8_t)i;
937 ifo->vendor[ifo->vendor[0] + 2] = (uint8_t)s;
938 ifo->vendor[0] = (uint8_t)(ifo->vendor[0] + s + 2);
939 }
940 break;
941 case 'w':
942 ifo->options |= DHCPCD_WAITIP;
943 if (arg != NULL && arg[0] != '\0') {
944 if (arg[0] == '4' || arg[1] == '4')
945 ifo->options |= DHCPCD_WAITIP4;
946 if (arg[0] == '6' || arg[1] == '6')
947 ifo->options |= DHCPCD_WAITIP6;
948 }
949 break;
950 case 'y':
951 ARG_REQUIRED;
952 ifo->reboot = (uint32_t)strtou(arg, NULL, 0, 0, UINT32_MAX, &e);
953 if (e) {
954 logerr("failed to convert reboot %s", arg);
955 return -1;
956 }
957 break;
958 case 'z':
959 ARG_REQUIRED;
960 if (!IN_CONFIG_BLOCK(ifo))
961 ctx->ifav = splitv(&ctx->ifac, ctx->ifav, arg);
962 break;
963 case 'A':
964 ifo->options &= ~DHCPCD_ARP;
965 /* IPv4LL requires ARP */
966 ifo->options &= ~DHCPCD_IPV4LL;
967 break;
968 case 'B':
969 ifo->options &= ~DHCPCD_DAEMONISE;
970 break;
971 case 'C':
972 ARG_REQUIRED;
973 /* Commas to spaces for shell */
974 while ((p = strchr(arg, ',')))
975 *p = ' ';
976 dl = strlen("skip_hooks=") + strlen(arg) + 1;
977 p = malloc(sizeof(char) * dl);
978 if (p == NULL) {
979 logerr(__func__);
980 return -1;
981 }
982 snprintf(p, dl, "skip_hooks=%s", arg);
983 add_environ(&ifo->environ, p, 0);
984 free(p);
985 break;
986 case 'D':
987 ifo->options |= DHCPCD_CLIENTID | DHCPCD_DUID;
988 break;
989 case 'E':
990 ifo->options |= DHCPCD_LASTLEASE;
991 break;
992 case 'F':
993 if (!arg) {
994 ifo->fqdn = FQDN_BOTH;
995 break;
996 }
997 if (strcmp(arg, "none") == 0)
998 ifo->fqdn = FQDN_NONE;
999 else if (strcmp(arg, "ptr") == 0)
1000 ifo->fqdn = FQDN_PTR;
1001 else if (strcmp(arg, "both") == 0)
1002 ifo->fqdn = FQDN_BOTH;
1003 else if (strcmp(arg, "disable") == 0)
1004 ifo->fqdn = FQDN_DISABLE;
1005 else {
1006 logerrx("invalid value `%s' for FQDN", arg);
1007 return -1;
1008 }
1009 break;
1010 case 'G':
1011 ifo->options &= ~DHCPCD_GATEWAY;
1012 break;
1013 case 'H':
1014 ifo->options |= DHCPCD_XID_HWADDR;
1015 break;
1016 case 'I':
1017 /* Strings have a type of 0 */;
1018 ifo->clientid[1] = 0;
1019 if (arg)
1020 s = parse_hwaddr((char *)ifo->clientid + 1,
1021 CLIENTID_MAX_LEN, arg);
1022 else
1023 s = 0;
1024 if (s == -1) {
1025 logerr("clientid");
1026 return -1;
1027 }
1028 ifo->options |= DHCPCD_CLIENTID;
1029 ifo->clientid[0] = (uint8_t)s;
1030 ifo->options &= ~DHCPCD_DUID;
1031 break;
1032 case 'J':
1033 ifo->options |= DHCPCD_BROADCAST;
1034 break;
1035 case 'K':
1036 ifo->options &= ~DHCPCD_LINK;
1037 break;
1038 case 'L':
1039 ifo->options &= ~DHCPCD_IPV4LL;
1040 break;
1041 case 'M':
1042 ifo->options |= DHCPCD_MASTER;
1043 break;
1044 case 'O':
1045 ARG_REQUIRED;
1046 set_option_space(ctx, arg, &d, &dl, &od, &odl, ifo,
1047 &request, &require, &no, &reject);
1048 if (make_option_mask(d, dl, od, odl, request, arg, -1) != 0 ||
1049 make_option_mask(d, dl, od, odl, require, arg, -1) != 0 ||
1050 make_option_mask(d, dl, od, odl, no, arg, 1) != 0)
1051 {
1052 logerrx("unknown option `%s'", arg);
1053 return -1;
1054 }
1055 break;
1056 case 'Q':
1057 ARG_REQUIRED;
1058 set_option_space(ctx, arg, &d, &dl, &od, &odl, ifo,
1059 &request, &require, &no, &reject);
1060 if (make_option_mask(d, dl, od, odl, require, arg, 1) != 0 ||
1061 make_option_mask(d, dl, od, odl, request, arg, 1) != 0 ||
1062 make_option_mask(d, dl, od, odl, no, arg, -1) != 0 ||
1063 make_option_mask(d, dl, od, odl, reject, arg, -1) != 0)
1064 {
1065 logerrx("unknown option `%s'", arg);
1066 return -1;
1067 }
1068 break;
1069 case 'S':
1070 ARG_REQUIRED;
1071 p = strchr(arg, '=');
1072 if (p == NULL) {
1073 logerrx("static assignment required");
1074 return -1;
1075 }
1076 p++;
1077 if (strncmp(arg, "ip_address=", strlen("ip_address=")) == 0) {
1078 if (parse_addr(&ifo->req_addr,
1079 ifo->req_mask.s_addr == 0 ? &ifo->req_mask : NULL,
1080 p) != 0)
1081 return -1;
1082
1083 ifo->options |= DHCPCD_STATIC;
1084 ifo->options &= ~DHCPCD_INFORM;
1085 } else if (strncmp(arg, "subnet_mask=",
1086 strlen("subnet_mask=")) == 0)
1087 {
1088 if (parse_addr(&ifo->req_mask, NULL, p) != 0)
1089 return -1;
1090 } else if (strncmp(arg, "broadcast_address=",
1091 strlen("broadcast_address=")) == 0)
1092 {
1093 if (parse_addr(&ifo->req_brd, NULL, p) != 0)
1094 return -1;
1095 } else if (strncmp(arg, "routes=", strlen("routes=")) == 0 ||
1096 strncmp(arg, "static_routes=",
1097 strlen("static_routes=")) == 0 ||
1098 strncmp(arg, "classless_static_routes=",
1099 strlen("classless_static_routes=")) == 0 ||
1100 strncmp(arg, "ms_classless_static_routes=",
1101 strlen("ms_classless_static_routes=")) == 0)
1102 {
1103 struct in_addr addr3;
1104
1105 fp = np = strwhite(p);
1106 if (np == NULL) {
1107 logerrx("all routes need a gateway");
1108 return -1;
1109 }
1110 *np++ = '\0';
1111 np = strskipwhite(np);
1112 if (parse_addr(&addr, &addr2, p) == -1 ||
1113 parse_addr(&addr3, NULL, np) == -1)
1114 {
1115 *fp = ' ';
1116 return -1;
1117 }
1118 *fp = ' ';
1119 if ((rt = rt_new0(ctx)) == NULL)
1120 return -1;
1121 sa_in_init(&rt->rt_dest, &addr);
1122 sa_in_init(&rt->rt_netmask, &addr2);
1123 sa_in_init(&rt->rt_gateway, &addr3);
1124 if (rt_proto_add_ctx(&ifo->routes, rt, ctx))
1125 add_environ(&ifo->config, arg, 0);
1126 } else if (strncmp(arg, "routers=", strlen("routers=")) == 0) {
1127 if (parse_addr(&addr, NULL, p) == -1)
1128 return -1;
1129 if ((rt = rt_new0(ctx)) == NULL)
1130 return -1;
1131 addr2.s_addr = INADDR_ANY;
1132 sa_in_init(&rt->rt_dest, &addr2);
1133 sa_in_init(&rt->rt_netmask, &addr2);
1134 sa_in_init(&rt->rt_gateway, &addr);
1135 if (rt_proto_add_ctx(&ifo->routes, rt, ctx))
1136 add_environ(&ifo->config, arg, 0);
1137 } else if (strncmp(arg, "interface_mtu=",
1138 strlen("interface_mtu=")) == 0 ||
1139 strncmp(arg, "mtu=", strlen("mtu=")) == 0)
1140 {
1141 ifo->mtu = (unsigned int)strtou(p, NULL, 0,
1142 MTU_MIN, MTU_MAX, &e);
1143 if (e) {
1144 logerrx("invalid MTU %s", p);
1145 return -1;
1146 }
1147 } else if (strncmp(arg, "ip6_address=", strlen("ip6_address=")) == 0) {
1148 np = strchr(p, '/');
1149 if (np)
1150 *np++ = '\0';
1151 if ((i = inet_pton(AF_INET6, p, &ifo->req_addr6)) == 1) {
1152 if (np) {
1153 ifo->req_prefix_len = (uint8_t)strtou(np,
1154 NULL, 0, 0, 128, &e);
1155 if (e) {
1156 logerrx("%s: failed to "
1157 "convert prefix len",
1158 ifname);
1159 return -1;
1160 }
1161 } else
1162 ifo->req_prefix_len = 128;
1163 }
1164 if (np)
1165 *(--np) = '\0';
1166 if (i != 1) {
1167 logerrx("invalid AF_INET6: %s", p);
1168 memset(&ifo->req_addr6, 0,
1169 sizeof(ifo->req_addr6));
1170 return -1;
1171 }
1172 } else
1173 add_environ(&ifo->config, arg, 1);
1174 break;
1175 case 'W':
1176 if (parse_addr(&addr, &addr2, arg) != 0)
1177 return -1;
1178 if (strchr(arg, '/') == NULL)
1179 addr2.s_addr = INADDR_BROADCAST;
1180 naddr = reallocarray(ifo->whitelist,
1181 ifo->whitelist_len + 2, sizeof(in_addr_t));
1182 if (naddr == NULL) {
1183 logerr(__func__);
1184 return -1;
1185 }
1186 ifo->whitelist = naddr;
1187 ifo->whitelist[ifo->whitelist_len++] = addr.s_addr;
1188 ifo->whitelist[ifo->whitelist_len++] = addr2.s_addr;
1189 break;
1190 case 'X':
1191 if (parse_addr(&addr, &addr2, arg) != 0)
1192 return -1;
1193 if (strchr(arg, '/') == NULL)
1194 addr2.s_addr = INADDR_BROADCAST;
1195 naddr = reallocarray(ifo->blacklist,
1196 ifo->blacklist_len + 2, sizeof(in_addr_t));
1197 if (naddr == NULL) {
1198 logerr(__func__);
1199 return -1;
1200 }
1201 ifo->blacklist = naddr;
1202 ifo->blacklist[ifo->blacklist_len++] = addr.s_addr;
1203 ifo->blacklist[ifo->blacklist_len++] = addr2.s_addr;
1204 break;
1205 case 'Z':
1206 ARG_REQUIRED;
1207 if (!IN_CONFIG_BLOCK(ifo))
1208 ctx->ifdv = splitv(&ctx->ifdc, ctx->ifdv, arg);
1209 break;
1210 case '1':
1211 ifo->options |= DHCPCD_ONESHOT;
1212 break;
1213 case '4':
1214 #ifdef INET
1215 ifo->options &= ~DHCPCD_IPV6;
1216 ifo->options |= DHCPCD_IPV4;
1217 break;
1218 #else
1219 logerrx("INET has been compiled out");
1220 return -1;
1221 #endif
1222 case '6':
1223 #ifdef INET6
1224 ifo->options &= ~DHCPCD_IPV4;
1225 ifo->options |= DHCPCD_IPV6;
1226 break;
1227 #else
1228 logerrx("INET6 has been compiled out");
1229 return -1;
1230 #endif
1231 case O_IPV4:
1232 ifo->options |= DHCPCD_IPV4;
1233 break;
1234 case O_NOIPV4:
1235 ifo->options &= ~DHCPCD_IPV4;
1236 break;
1237 case O_IPV6:
1238 ifo->options |= DHCPCD_IPV6;
1239 break;
1240 case O_NOIPV6:
1241 ifo->options &= ~DHCPCD_IPV6;
1242 break;
1243 case O_ANONYMOUS:
1244 ifo->options |= DHCPCD_ANONYMOUS;
1245 ifo->options &= ~DHCPCD_HOSTNAME;
1246 ifo->fqdn = FQDN_DISABLE;
1247
1248 /* Block everything */
1249 memset(ifo->nomask, 0xff, sizeof(ifo->nomask));
1250 memset(ifo->nomask6, 0xff, sizeof(ifo->nomask6));
1251
1252 /* Allow the bare minimum through */
1253 #ifdef INET
1254 del_option_mask(ifo->nomask, DHO_SUBNETMASK);
1255 del_option_mask(ifo->nomask, DHO_CSR);
1256 del_option_mask(ifo->nomask, DHO_ROUTER);
1257 del_option_mask(ifo->nomask, DHO_DNSSERVER);
1258 del_option_mask(ifo->nomask, DHO_DNSDOMAIN);
1259 del_option_mask(ifo->nomask, DHO_BROADCAST);
1260 del_option_mask(ifo->nomask, DHO_STATICROUTE);
1261 del_option_mask(ifo->nomask, DHO_SERVERID);
1262 del_option_mask(ifo->nomask, DHO_RENEWALTIME);
1263 del_option_mask(ifo->nomask, DHO_REBINDTIME);
1264 del_option_mask(ifo->nomask, DHO_DNSSEARCH);
1265 #endif
1266
1267 #ifdef DHCP6
1268 del_option_mask(ifo->nomask6, D6_OPTION_DNS_SERVERS);
1269 del_option_mask(ifo->nomask6, D6_OPTION_DOMAIN_LIST);
1270 del_option_mask(ifo->nomask6, D6_OPTION_SOL_MAX_RT);
1271 del_option_mask(ifo->nomask6, D6_OPTION_INF_MAX_RT);
1272 #endif
1273
1274 break;
1275 #ifdef INET
1276 case O_ARPING:
1277 while (arg != NULL) {
1278 fp = strwhite(arg);
1279 if (fp)
1280 *fp++ = '\0';
1281 if (parse_addr(&addr, NULL, arg) != 0)
1282 return -1;
1283 naddr = reallocarray(ifo->arping,
1284 (size_t)ifo->arping_len + 1, sizeof(in_addr_t));
1285 if (naddr == NULL) {
1286 logerr(__func__);
1287 return -1;
1288 }
1289 ifo->arping = naddr;
1290 ifo->arping[ifo->arping_len++] = addr.s_addr;
1291 arg = strskipwhite(fp);
1292 }
1293 break;
1294 case O_DESTINATION:
1295 ARG_REQUIRED;
1296 set_option_space(ctx, arg, &d, &dl, &od, &odl, ifo,
1297 &request, &require, &no, &reject);
1298 if (make_option_mask(d, dl, od, odl,
1299 ifo->dstmask, arg, 2) != 0)
1300 {
1301 if (errno == EINVAL)
1302 logerrx("option `%s' does not take"
1303 " an IPv4 address", arg);
1304 else
1305 logerrx("unknown option `%s'", arg);
1306 return -1;
1307 }
1308 break;
1309 case O_FALLBACK:
1310 ARG_REQUIRED;
1311 free(ifo->fallback);
1312 ifo->fallback = strdup(arg);
1313 if (ifo->fallback == NULL) {
1314 logerrx(__func__);
1315 return -1;
1316 }
1317 break;
1318 #endif
1319 case O_IAID:
1320 ARG_REQUIRED;
1321 if (!IN_CONFIG_BLOCK(ifo)) {
1322 logerrx("IAID must belong in an interface block");
1323 return -1;
1324 }
1325 if (parse_iaid(ifo->iaid, arg, sizeof(ifo->iaid)) == -1) {
1326 logerrx("invalid IAID %s", arg);
1327 return -1;
1328 }
1329 ifo->options |= DHCPCD_IAID;
1330 break;
1331 case O_IPV6RS:
1332 ifo->options |= DHCPCD_IPV6RS;
1333 break;
1334 case O_NOIPV6RS:
1335 ifo->options &= ~DHCPCD_IPV6RS;
1336 break;
1337 case O_IPV6RA_FORK:
1338 ifo->options &= ~DHCPCD_IPV6RA_REQRDNSS;
1339 break;
1340 case O_IPV6RA_AUTOCONF:
1341 ifo->options |= DHCPCD_IPV6RA_AUTOCONF;
1342 break;
1343 case O_IPV6RA_NOAUTOCONF:
1344 ifo->options &= ~DHCPCD_IPV6RA_AUTOCONF;
1345 break;
1346 case O_NOALIAS:
1347 ifo->options |= DHCPCD_NOALIAS;
1348 break;
1349 #ifdef DHCP6
1350 case O_IA_NA:
1351 i = D6_OPTION_IA_NA;
1352 /* FALLTHROUGH */
1353 case O_IA_TA:
1354 if (i == 0)
1355 i = D6_OPTION_IA_TA;
1356 /* FALLTHROUGH */
1357 case O_IA_PD:
1358 if (i == 0) {
1359 #ifdef SMALL
1360 logwarnx("%s: IA_PD not compiled in", ifname);
1361 return -1;
1362 #else
1363 if (!IN_CONFIG_BLOCK(ifo)) {
1364 logerrx("IA PD must belong in an "
1365 "interface block");
1366 return -1;
1367 }
1368 i = D6_OPTION_IA_PD;
1369 #endif
1370 }
1371 if (!IN_CONFIG_BLOCK(ifo) && arg) {
1372 logerrx("IA with IAID must belong in an "
1373 "interface block");
1374 return -1;
1375 }
1376 ifo->options |= DHCPCD_IA_FORCED;
1377 fp = strwhite(arg);
1378 if (fp) {
1379 *fp++ = '\0';
1380 fp = strskipwhite(fp);
1381 }
1382 if (arg) {
1383 p = strchr(arg, '/');
1384 if (p)
1385 *p++ = '\0';
1386 if (parse_iaid(iaid, arg, sizeof(iaid)) == -1) {
1387 logerr("invalid IAID: %s", arg);
1388 return -1;
1389 }
1390 }
1391 ia = NULL;
1392 for (sl = 0; sl < ifo->ia_len; sl++) {
1393 if ((arg == NULL && !ifo->ia[sl].iaid_set) ||
1394 (arg != NULL && ifo->ia[sl].iaid_set &&
1395 ifo->ia[sl].ia_type == (uint16_t)i &&
1396 ifo->ia[sl].iaid[0] == iaid[0] &&
1397 ifo->ia[sl].iaid[1] == iaid[1] &&
1398 ifo->ia[sl].iaid[2] == iaid[2] &&
1399 ifo->ia[sl].iaid[3] == iaid[3]))
1400 {
1401 ia = &ifo->ia[sl];
1402 break;
1403 }
1404 }
1405 if (ia == NULL) {
1406 ia = reallocarray(ifo->ia,
1407 ifo->ia_len + 1, sizeof(*ifo->ia));
1408 if (ia == NULL) {
1409 logerr(__func__);
1410 return -1;
1411 }
1412 ifo->ia = ia;
1413 ia = &ifo->ia[ifo->ia_len++];
1414 ia->ia_type = (uint16_t)i;
1415 if (arg) {
1416 ia->iaid[0] = iaid[0];
1417 ia->iaid[1] = iaid[1];
1418 ia->iaid[2] = iaid[2];
1419 ia->iaid[3] = iaid[3];
1420 ia->iaid_set = 1;
1421 } else
1422 ia->iaid_set = 0;
1423 if (!ia->iaid_set ||
1424 p == NULL ||
1425 ia->ia_type == D6_OPTION_IA_TA)
1426 {
1427 memset(&ia->addr, 0, sizeof(ia->addr));
1428 ia->prefix_len = 0;
1429 } else {
1430 arg = p;
1431 p = strchr(arg, '/');
1432 if (p)
1433 *p++ = '\0';
1434 if (inet_pton(AF_INET6, arg, &ia->addr) != 1) {
1435 logerrx("invalid AF_INET6: %s", arg);
1436 memset(&ia->addr, 0, sizeof(ia->addr));
1437 }
1438 if (p && ia->ia_type == D6_OPTION_IA_PD) {
1439 ia->prefix_len = (uint8_t)strtou(p,
1440 NULL, 0, 8, 120, &e);
1441 if (e) {
1442 logerrx("%s: failed to convert"
1443 " prefix len",
1444 p);
1445 ia->prefix_len = 0;
1446 }
1447 }
1448 }
1449 #ifndef SMALL
1450 ia->sla_max = 0;
1451 ia->sla_len = 0;
1452 ia->sla = NULL;
1453 #endif
1454 }
1455
1456 #ifdef SMALL
1457 break;
1458 #else
1459 if (ia->ia_type != D6_OPTION_IA_PD)
1460 break;
1461
1462 for (p = fp; p; p = fp) {
1463 fp = strwhite(p);
1464 if (fp) {
1465 *fp++ = '\0';
1466 fp = strskipwhite(fp);
1467 }
1468 sla = reallocarray(ia->sla,
1469 ia->sla_len + 1, sizeof(*ia->sla));
1470 if (sla == NULL) {
1471 logerr(__func__);
1472 return -1;
1473 }
1474 ia->sla = sla;
1475 sla = &ia->sla[ia->sla_len++];
1476 np = strchr(p, '/');
1477 if (np)
1478 *np++ = '\0';
1479 if (strlcpy(sla->ifname, p,
1480 sizeof(sla->ifname)) >= sizeof(sla->ifname))
1481 {
1482 logerrx("%s: interface name too long", arg);
1483 goto err_sla;
1484 }
1485 sla->sla_set = false;
1486 sla->prefix_len = 0;
1487 sla->suffix = 1;
1488 p = np;
1489 if (p) {
1490 np = strchr(p, '/');
1491 if (np)
1492 *np++ = '\0';
1493 if (*p != '\0') {
1494 sla->sla = (uint32_t)strtou(p, NULL,
1495 0, 0, UINT32_MAX, &e);
1496 sla->sla_set = true;
1497 if (e) {
1498 logerrx("%s: failed to convert "
1499 "sla",
1500 ifname);
1501 goto err_sla;
1502 }
1503 }
1504 p = np;
1505 }
1506 if (p) {
1507 np = strchr(p, '/');
1508 if (np)
1509 *np++ = '\0';
1510 if (*p != '\0') {
1511 sla->prefix_len = (uint8_t)strtou(p,
1512 NULL, 0, 0, 120, &e);
1513 if (e) {
1514 logerrx("%s: failed to "
1515 "convert prefix len",
1516 ifname);
1517 goto err_sla;
1518 }
1519 }
1520 p = np;
1521 }
1522 if (p) {
1523 np = strchr(p, '/');
1524 if (np)
1525 *np = '\0';
1526 if (*p != '\0') {
1527 sla->suffix = (uint64_t)strtou(p, NULL,
1528 0, 0, UINT64_MAX, &e);
1529 if (e) {
1530 logerrx("%s: failed to "
1531 "convert suffix",
1532 ifname);
1533 goto err_sla;
1534 }
1535 }
1536 }
1537 /* Sanity check */
1538 for (sl = 0; sl < ia->sla_len - 1; sl++) {
1539 slap = &ia->sla[sl];
1540 if (slap->sla_set != sla->sla_set) {
1541 logerrx("%s: cannot mix automatic "
1542 "and fixed SLA",
1543 sla->ifname);
1544 goto err_sla;
1545 }
1546 if (ia->prefix_len &&
1547 (sla->prefix_len == ia->prefix_len ||
1548 slap->prefix_len == ia->prefix_len))
1549 {
1550 logerrx("%s: cannot delegte the same"
1551 "prefix length more than once",
1552 sla->ifname);
1553 goto err_sla;
1554 }
1555 if (!sla->sla_set &&
1556 strcmp(slap->ifname, sla->ifname) == 0)
1557 {
1558 logwarnx("%s: cannot specify the "
1559 "same interface twice with "
1560 "an automatic SLA",
1561 sla->ifname);
1562 goto err_sla;
1563 }
1564 if (slap->sla_set && sla->sla_set &&
1565 slap->sla == sla->sla)
1566 {
1567 logerrx("%s: cannot"
1568 " assign the same SLA %u"
1569 " more than once",
1570 sla->ifname, sla->sla);
1571 goto err_sla;
1572 }
1573 }
1574 if (sla->sla_set && sla->sla > ia->sla_max)
1575 ia->sla_max = sla->sla;
1576 }
1577 break;
1578 err_sla:
1579 ia->sla_len--;
1580 return -1;
1581 #endif
1582 #endif
1583 case O_HOSTNAME_SHORT:
1584 ifo->options |= DHCPCD_HOSTNAME | DHCPCD_HOSTNAME_SHORT;
1585 break;
1586 case O_DEV:
1587 ARG_REQUIRED;
1588 #ifdef PLUGIN_DEV
1589 if (ctx->dev_load)
1590 free(ctx->dev_load);
1591 ctx->dev_load = strdup(arg);
1592 #endif
1593 break;
1594 case O_NODEV:
1595 ifo->options &= ~DHCPCD_DEV;
1596 break;
1597 case O_DEFINE:
1598 dop = &ifo->dhcp_override;
1599 dop_len = &ifo->dhcp_override_len;
1600 /* FALLTHROUGH */
1601 case O_DEFINEND:
1602 if (dop == NULL) {
1603 dop = &ifo->nd_override;
1604 dop_len = &ifo->nd_override_len;
1605 }
1606 /* FALLTHROUGH */
1607 case O_DEFINE6:
1608 if (dop == NULL) {
1609 dop = &ifo->dhcp6_override;
1610 dop_len = &ifo->dhcp6_override_len;
1611 }
1612 /* FALLTHROUGH */
1613 case O_VENDOPT:
1614 if (dop == NULL) {
1615 dop = &ifo->vivso_override;
1616 dop_len = &ifo->vivso_override_len;
1617 }
1618 *edop = *ldop = NULL;
1619 /* FALLTHROUGH */
1620 case O_EMBED:
1621 if (dop == NULL) {
1622 if (*edop) {
1623 dop = &(*edop)->embopts;
1624 dop_len = &(*edop)->embopts_len;
1625 } else if (ldop) {
1626 dop = &(*ldop)->embopts;
1627 dop_len = &(*ldop)->embopts_len;
1628 } else {
1629 logerrx("embed must be after a define "
1630 "or encap");
1631 return -1;
1632 }
1633 }
1634 /* FALLTHROUGH */
1635 case O_ENCAP:
1636 ARG_REQUIRED;
1637 if (dop == NULL) {
1638 if (*ldop == NULL) {
1639 logerrx("encap must be after a define");
1640 return -1;
1641 }
1642 dop = &(*ldop)->encopts;
1643 dop_len = &(*ldop)->encopts_len;
1644 }
1645
1646 /* Shared code for define, define6, embed and encap */
1647
1648 /* code */
1649 if (opt == O_EMBED) /* Embedded options don't have codes */
1650 u = 0;
1651 else {
1652 fp = strwhite(arg);
1653 if (fp == NULL) {
1654 logerrx("invalid syntax: %s", arg);
1655 return -1;
1656 }
1657 *fp++ = '\0';
1658 u = (uint32_t)strtou(arg, NULL, 0, 0, UINT32_MAX, &e);
1659 if (e) {
1660 logerrx("invalid code: %s", arg);
1661 return -1;
1662 }
1663 arg = strskipwhite(fp);
1664 if (arg == NULL) {
1665 logerrx("invalid syntax");
1666 return -1;
1667 }
1668 }
1669 /* type */
1670 fp = strwhite(arg);
1671 if (fp)
1672 *fp++ = '\0';
1673 np = strchr(arg, ':');
1674 /* length */
1675 if (np) {
1676 *np++ = '\0';
1677 bp = NULL; /* No bitflag */
1678 l = (long)strtou(np, NULL, 0, 0, LONG_MAX, &e);
1679 if (e) {
1680 logerrx("failed to convert length");
1681 return -1;
1682 }
1683 } else {
1684 l = 0;
1685 bp = strchr(arg, '='); /* bitflag assignment */
1686 if (bp)
1687 *bp++ = '\0';
1688 }
1689 t = 0;
1690 if (strcasecmp(arg, "request") == 0) {
1691 t |= OT_REQUEST;
1692 arg = strskipwhite(fp);
1693 fp = strwhite(arg);
1694 if (fp == NULL) {
1695 logerrx("incomplete request type");
1696 return -1;
1697 }
1698 *fp++ = '\0';
1699 } else if (strcasecmp(arg, "norequest") == 0) {
1700 t |= OT_NOREQ;
1701 arg = strskipwhite(fp);
1702 fp = strwhite(arg);
1703 if (fp == NULL) {
1704 logerrx("incomplete request type");
1705 return -1;
1706 }
1707 *fp++ = '\0';
1708 }
1709 if (strcasecmp(arg, "optional") == 0) {
1710 t |= OT_OPTIONAL;
1711 arg = strskipwhite(fp);
1712 fp = strwhite(arg);
1713 if (fp == NULL) {
1714 logerrx("incomplete optional type");
1715 return -1;
1716 }
1717 *fp++ = '\0';
1718 }
1719 if (strcasecmp(arg, "index") == 0) {
1720 t |= OT_INDEX;
1721 arg = strskipwhite(fp);
1722 fp = strwhite(arg);
1723 if (fp == NULL) {
1724 logerrx("incomplete index type");
1725 return -1;
1726 }
1727 *fp++ = '\0';
1728 }
1729 if (strcasecmp(arg, "array") == 0) {
1730 t |= OT_ARRAY;
1731 arg = strskipwhite(fp);
1732 fp = strwhite(arg);
1733 if (fp == NULL) {
1734 logerrx("incomplete array type");
1735 return -1;
1736 }
1737 *fp++ = '\0';
1738 }
1739 if (strcasecmp(arg, "ipaddress") == 0)
1740 t |= OT_ADDRIPV4;
1741 else if (strcasecmp(arg, "ip6address") == 0)
1742 t |= OT_ADDRIPV6;
1743 else if (strcasecmp(arg, "string") == 0)
1744 t |= OT_STRING;
1745 else if (strcasecmp(arg, "byte") == 0)
1746 t |= OT_UINT8;
1747 else if (strcasecmp(arg, "bitflags") == 0)
1748 t |= OT_BITFLAG;
1749 else if (strcasecmp(arg, "uint8") == 0)
1750 t |= OT_UINT8;
1751 else if (strcasecmp(arg, "int8") == 0)
1752 t |= OT_INT8;
1753 else if (strcasecmp(arg, "uint16") == 0)
1754 t |= OT_UINT16;
1755 else if (strcasecmp(arg, "int16") == 0)
1756 t |= OT_INT16;
1757 else if (strcasecmp(arg, "uint32") == 0)
1758 t |= OT_UINT32;
1759 else if (strcasecmp(arg, "int32") == 0)
1760 t |= OT_INT32;
1761 else if (strcasecmp(arg, "flag") == 0)
1762 t |= OT_FLAG;
1763 else if (strcasecmp(arg, "raw") == 0)
1764 t |= OT_STRING | OT_RAW;
1765 else if (strcasecmp(arg, "ascii") == 0)
1766 t |= OT_STRING | OT_ASCII;
1767 else if (strcasecmp(arg, "domain") == 0)
1768 t |= OT_STRING | OT_DOMAIN | OT_RFC1035;
1769 else if (strcasecmp(arg, "dname") == 0)
1770 t |= OT_STRING | OT_DOMAIN;
1771 else if (strcasecmp(arg, "binhex") == 0)
1772 t |= OT_STRING | OT_BINHEX;
1773 else if (strcasecmp(arg, "embed") == 0)
1774 t |= OT_EMBED;
1775 else if (strcasecmp(arg, "encap") == 0)
1776 t |= OT_ENCAP;
1777 else if (strcasecmp(arg, "rfc3361") ==0)
1778 t |= OT_STRING | OT_RFC3361;
1779 else if (strcasecmp(arg, "rfc3442") ==0)
1780 t |= OT_STRING | OT_RFC3442;
1781 else if (strcasecmp(arg, "option") == 0)
1782 t |= OT_OPTION;
1783 else {
1784 logerrx("unknown type: %s", arg);
1785 return -1;
1786 }
1787 if (l && !(t & (OT_STRING | OT_BINHEX))) {
1788 logwarnx("ignoring length for type `%s'", arg);
1789 l = 0;
1790 }
1791 if (t & OT_ARRAY && t & (OT_STRING | OT_BINHEX) &&
1792 !(t & (OT_RFC1035 | OT_DOMAIN)))
1793 {
1794 logwarnx("ignoring array for strings");
1795 t &= ~OT_ARRAY;
1796 }
1797 if (t & OT_BITFLAG) {
1798 if (bp == NULL)
1799 logwarnx("missing bitflag assignment");
1800 }
1801 /* variable */
1802 if (!fp) {
1803 if (!(t & OT_OPTION)) {
1804 logerrx("type %s requires a variable name",
1805 arg);
1806 return -1;
1807 }
1808 np = NULL;
1809 } else {
1810 arg = strskipwhite(fp);
1811 fp = strwhite(arg);
1812 if (fp)
1813 *fp++ = '\0';
1814 if (strcasecmp(arg, "reserved")) {
1815 np = strdup(arg);
1816 if (np == NULL) {
1817 logerr(__func__);
1818 return -1;
1819 }
1820 } else {
1821 np = NULL;
1822 t |= OT_RESERVED;
1823 }
1824 }
1825 if (opt != O_EMBED) {
1826 for (dl = 0, ndop = *dop; dl < *dop_len; dl++, ndop++)
1827 {
1828 /* type 0 seems freshly malloced struct
1829 * for us to use */
1830 if (ndop->option == u || ndop->type == 0)
1831 break;
1832 }
1833 if (dl == *dop_len)
1834 ndop = NULL;
1835 } else
1836 ndop = NULL;
1837 if (ndop == NULL) {
1838 ndop = reallocarray(*dop, *dop_len + 1, sizeof(**dop));
1839 if (ndop == NULL) {
1840 logerr(__func__);
1841 free(np);
1842 return -1;
1843 }
1844 *dop = ndop;
1845 ndop = &(*dop)[(*dop_len)++];
1846 ndop->embopts = NULL;
1847 ndop->embopts_len = 0;
1848 ndop->encopts = NULL;
1849 ndop->encopts_len = 0;
1850 } else
1851 free_dhcp_opt_embenc(ndop);
1852 ndop->option = (uint32_t)u; /* could have been 0 */
1853 ndop->type = t;
1854 ndop->len = (size_t)l;
1855 ndop->var = np;
1856 if (bp) {
1857 dl = strlen(bp);
1858 memcpy(ndop->bitflags, bp, dl);
1859 memset(ndop->bitflags + dl, 0,
1860 sizeof(ndop->bitflags) - dl);
1861 } else
1862 memset(ndop->bitflags, 0, sizeof(ndop->bitflags));
1863 /* Save the define for embed and encap options */
1864 switch (opt) {
1865 case O_DEFINE:
1866 case O_DEFINEND:
1867 case O_DEFINE6:
1868 case O_VENDOPT:
1869 *ldop = ndop;
1870 break;
1871 case O_ENCAP:
1872 *edop = ndop;
1873 break;
1874 }
1875 break;
1876 case O_VENDCLASS:
1877 ARG_REQUIRED;
1878 fp = strwhite(arg);
1879 if (fp)
1880 *fp++ = '\0';
1881 u = (uint32_t)strtou(arg, NULL, 0, 0, UINT32_MAX, &e);
1882 if (e) {
1883 logerrx("invalid code: %s", arg);
1884 return -1;
1885 }
1886 fp = strskipwhite(fp);
1887 if (fp) {
1888 s = parse_string(NULL, 0, fp);
1889 if (s == -1) {
1890 logerr(__func__);
1891 return -1;
1892 }
1893 dl = (size_t)s;
1894 if (dl + (sizeof(uint16_t) * 2) > UINT16_MAX) {
1895 logerrx("vendor class is too big");
1896 return -1;
1897 }
1898 np = malloc(dl);
1899 if (np == NULL) {
1900 logerr(__func__);
1901 return -1;
1902 }
1903 parse_string(np, dl, fp);
1904 } else {
1905 dl = 0;
1906 np = NULL;
1907 }
1908 vivco = reallocarray(ifo->vivco,
1909 ifo->vivco_len + 1, sizeof(*ifo->vivco));
1910 if (vivco == NULL) {
1911 logerr( __func__);
1912 free(np);
1913 return -1;
1914 }
1915 ifo->vivco = vivco;
1916 ifo->vivco_en = (uint32_t)u;
1917 vivco = &ifo->vivco[ifo->vivco_len++];
1918 vivco->len = dl;
1919 vivco->data = (uint8_t *)np;
1920 break;
1921 case O_AUTHPROTOCOL:
1922 ARG_REQUIRED;
1923 #ifdef AUTH
1924 fp = strwhite(arg);
1925 if (fp)
1926 *fp++ = '\0';
1927 if (strcasecmp(arg, "token") == 0)
1928 ifo->auth.protocol = AUTH_PROTO_TOKEN;
1929 else if (strcasecmp(arg, "delayed") == 0)
1930 ifo->auth.protocol = AUTH_PROTO_DELAYED;
1931 else if (strcasecmp(arg, "delayedrealm") == 0)
1932 ifo->auth.protocol = AUTH_PROTO_DELAYEDREALM;
1933 else {
1934 logerrx("%s: unsupported protocol", arg);
1935 return -1;
1936 }
1937 arg = strskipwhite(fp);
1938 fp = strwhite(arg);
1939 if (arg == NULL) {
1940 ifo->auth.options |= DHCPCD_AUTH_SEND;
1941 if (ifo->auth.protocol == AUTH_PROTO_TOKEN)
1942 ifo->auth.protocol = AUTH_ALG_NONE;
1943 else
1944 ifo->auth.algorithm = AUTH_ALG_HMAC_MD5;
1945 ifo->auth.rdm = AUTH_RDM_MONOTONIC;
1946 break;
1947 }
1948 if (fp)
1949 *fp++ = '\0';
1950 if (ifo->auth.protocol == AUTH_PROTO_TOKEN) {
1951 np = strchr(arg, '/');
1952 if (np) {
1953 if (fp == NULL || np < fp)
1954 *np++ = '\0';
1955 else
1956 np = NULL;
1957 }
1958 if (parse_uint32(&ifo->auth.token_snd_secretid,
1959 arg) == -1)
1960 logerrx("%s: not a number", arg);
1961 else
1962 ifo->auth.token_rcv_secretid =
1963 ifo->auth.token_snd_secretid;
1964 if (np &&
1965 parse_uint32(&ifo->auth.token_rcv_secretid,
1966 np) == -1)
1967 logerrx("%s: not a number", arg);
1968 } else {
1969 if (strcasecmp(arg, "hmacmd5") == 0 ||
1970 strcasecmp(arg, "hmac-md5") == 0)
1971 ifo->auth.algorithm = AUTH_ALG_HMAC_MD5;
1972 else {
1973 logerrx("%s: unsupported algorithm", arg);
1974 return 1;
1975 }
1976 }
1977 arg = fp;
1978 if (arg == NULL) {
1979 ifo->auth.options |= DHCPCD_AUTH_SEND;
1980 ifo->auth.rdm = AUTH_RDM_MONOTONIC;
1981 break;
1982 }
1983 if (strcasecmp(arg, "monocounter") == 0) {
1984 ifo->auth.rdm = AUTH_RDM_MONOTONIC;
1985 ifo->auth.options |= DHCPCD_AUTH_RDM_COUNTER;
1986 } else if (strcasecmp(arg, "monotonic") ==0 ||
1987 strcasecmp(arg, "monotime") == 0)
1988 ifo->auth.rdm = AUTH_RDM_MONOTONIC;
1989 else {
1990 logerrx("%s: unsupported RDM", arg);
1991 return -1;
1992 }
1993 ifo->auth.options |= DHCPCD_AUTH_SEND;
1994 break;
1995 #else
1996 logerrx("no authentication support");
1997 return -1;
1998 #endif
1999 case O_AUTHTOKEN:
2000 ARG_REQUIRED;
2001 #ifdef AUTH
2002 fp = strwhite(arg);
2003 if (fp == NULL) {
2004 logerrx("authtoken requires a realm");
2005 return -1;
2006 }
2007 *fp++ = '\0';
2008 token = calloc(1, sizeof(*token));
2009 if (token == NULL) {
2010 logerr(__func__);
2011 return -1;
2012 }
2013 if (parse_uint32(&token->secretid, arg) == -1) {
2014 logerrx("%s: not a number", arg);
2015 goto invalid_token;
2016 }
2017 arg = fp;
2018 fp = strend(arg);
2019 if (fp == NULL) {
2020 logerrx("authtoken requies an a key");
2021 goto invalid_token;
2022 }
2023 *fp++ = '\0';
2024 s = parse_string(NULL, 0, arg);
2025 if (s == -1) {
2026 logerr("realm_len");
2027 goto invalid_token;
2028 }
2029 if (s != 0) {
2030 token->realm_len = (size_t)s;
2031 token->realm = malloc(token->realm_len);
2032 if (token->realm == NULL) {
2033 logerr(__func__);
2034 goto invalid_token;
2035 }
2036 parse_string((char *)token->realm, token->realm_len,
2037 arg);
2038 }
2039 arg = fp;
2040 fp = strend(arg);
2041 if (fp == NULL) {
2042 logerrx("authtoken requies an expiry date");
2043 goto invalid_token;
2044 }
2045 *fp++ = '\0';
2046 if (*arg == '"') {
2047 arg++;
2048 np = strchr(arg, '"');
2049 if (np)
2050 *np = '\0';
2051 }
2052 if (strcmp(arg, "0") == 0 || strcasecmp(arg, "forever") == 0)
2053 token->expire =0;
2054 else {
2055 struct tm tm;
2056
2057 memset(&tm, 0, sizeof(tm));
2058 if (strptime(arg, "%Y-%m-%d %H:%M", &tm) == NULL) {
2059 logerrx("%s: invalid date time", arg);
2060 goto invalid_token;
2061 }
2062 if ((token->expire = mktime(&tm)) == (time_t)-1) {
2063 logerr("%s: mktime", __func__);
2064 goto invalid_token;
2065 }
2066 }
2067 arg = fp;
2068 s = parse_string(NULL, 0, arg);
2069 if (s == -1 || s == 0) {
2070 if (s == -1)
2071 logerr("token_len");
2072 else
2073 logerrx("authtoken needs a key");
2074 goto invalid_token;
2075 }
2076 token->key_len = (size_t)s;
2077 token->key = malloc(token->key_len);
2078 if (token->key == NULL) {
2079 logerr(__func__);
2080 goto invalid_token;
2081 }
2082 parse_string((char *)token->key, token->key_len, arg);
2083 TAILQ_INSERT_TAIL(&ifo->auth.tokens, token, next);
2084 break;
2085
2086 invalid_token:
2087 free(token->realm);
2088 free(token);
2089 #else
2090 logerrx("no authentication support");
2091 #endif
2092 return -1;
2093 case O_AUTHNOTREQUIRED:
2094 ifo->auth.options &= ~DHCPCD_AUTH_REQUIRE;
2095 break;
2096 case O_DHCP:
2097 ifo->options |= DHCPCD_DHCP | DHCPCD_WANTDHCP | DHCPCD_IPV4;
2098 break;
2099 case O_NODHCP:
2100 ifo->options &= ~DHCPCD_DHCP;
2101 break;
2102 case O_DHCP6:
2103 ifo->options |= DHCPCD_DHCP6 | DHCPCD_IPV6;
2104 break;
2105 case O_NODHCP6:
2106 ifo->options &= ~DHCPCD_DHCP6;
2107 break;
2108 case O_CONTROLGRP:
2109 ARG_REQUIRED;
2110 #ifdef PRIVSEP
2111 /* Control group is already set by this point.
2112 * We don't need to pledge getpw either with this. */
2113 if (IN_PRIVSEP(ctx))
2114 break;
2115 #endif
2116 #ifdef _REENTRANT
2117 l = sysconf(_SC_GETGR_R_SIZE_MAX);
2118 if (l == -1)
2119 dl = 1024;
2120 else
2121 dl = (size_t)l;
2122 p = malloc(dl);
2123 if (p == NULL) {
2124 logerr(__func__);
2125 return -1;
2126 }
2127 while ((i = getgrnam_r(arg, &grpbuf, p, dl, &grp)) ==
2128 ERANGE)
2129 {
2130 size_t nl = dl * 2;
2131 if (nl < dl) {
2132 logerrx("control_group: out of buffer");
2133 free(p);
2134 return -1;
2135 }
2136 dl = nl;
2137 np = realloc(p, dl);
2138 if (np == NULL) {
2139 logerr(__func__);
2140 free(p);
2141 return -1;
2142 }
2143 p = np;
2144 }
2145 if (i != 0) {
2146 errno = i;
2147 logerr("getgrnam_r");
2148 free(p);
2149 return -1;
2150 }
2151 if (grp == NULL) {
2152 if (!ctx->control_group)
2153 logerrx("controlgroup: %s: not found", arg);
2154 free(p);
2155 return -1;
2156 }
2157 ctx->control_group = grp->gr_gid;
2158 free(p);
2159 #else
2160 grp = getgrnam(arg);
2161 if (grp == NULL) {
2162 if (!ctx->control_group)
2163 logerrx("controlgroup: %s: not found", arg);
2164 return -1;
2165 }
2166 ctx->control_group = grp->gr_gid;
2167 #endif
2168 break;
2169 case O_GATEWAY:
2170 ifo->options |= DHCPCD_GATEWAY;
2171 break;
2172 case O_NOUP:
2173 ifo->options &= ~DHCPCD_IF_UP;
2174 break;
2175 case O_SLAAC:
2176 ARG_REQUIRED;
2177 np = strwhite(arg);
2178 if (np != NULL) {
2179 *np++ = '\0';
2180 np = strskipwhite(np);
2181 }
2182 if (strcmp(arg, "private") == 0 ||
2183 strcmp(arg, "stableprivate") == 0 ||
2184 strcmp(arg, "stable") == 0)
2185 ifo->options |= DHCPCD_SLAACPRIVATE;
2186 else
2187 ifo->options &= ~DHCPCD_SLAACPRIVATE;
2188 if (np != NULL &&
2189 (strcmp(np, "temp") == 0 || strcmp(np, "temporary") == 0))
2190 ifo->options |= DHCPCD_SLAACTEMP;
2191 break;
2192 case O_BOOTP:
2193 ifo->options |= DHCPCD_BOOTP;
2194 break;
2195 case O_NODELAY:
2196 ifo->options &= ~DHCPCD_INITIAL_DELAY;
2197 break;
2198 case O_LASTLEASE_EXTEND:
2199 ifo->options |= DHCPCD_LASTLEASE | DHCPCD_LASTLEASE_EXTEND;
2200 break;
2201 case O_INACTIVE:
2202 ifo->options |= DHCPCD_INACTIVE;
2203 break;
2204 case O_MUDURL:
2205 ARG_REQUIRED;
2206 s = parse_string((char *)ifo->mudurl + 1, MUDURL_MAX_LEN, arg);
2207 if (s == -1) {
2208 logerr("mudurl");
2209 return -1;
2210 }
2211 *ifo->mudurl = (uint8_t)s;
2212 break;
2213 case O_LINK_RCVBUF:
2214 #ifndef SMALL
2215 ARG_REQUIRED;
2216 ctx->link_rcvbuf = (int)strtoi(arg, NULL, 0, 0, INT32_MAX, &e);
2217 if (e) {
2218 logerrx("failed to convert link_rcvbuf %s", arg);
2219 return -1;
2220 }
2221 #endif
2222 break;
2223 case O_POLL:
2224 if (arg == NULL) {
2225 ifo->poll = IF_POLL_UP;
2226 break;
2227 }
2228 ifo->poll = (unsigned long)
2229 strtou(arg, NULL, 0, 0, ULONG_MAX, &e);
2230 if (e) {
2231 logerrx("failed to convert poll %s", arg);
2232 return -1;
2233 }
2234 break;
2235 default:
2236 return 0;
2237 }
2238
2239 return 1;
2240
2241 #ifdef ARG_REQUIRED
2242 arg_required:
2243 logerrx("option %d requires an argument", opt);
2244 return -1;
2245 #undef ARG_REQUIRED
2246 #endif
2247 }
2248
2249 static int
2250 parse_config_line(struct dhcpcd_ctx *ctx, const char *ifname,
2251 struct if_options *ifo, const char *opt, char *line,
2252 struct dhcp_opt **ldop, struct dhcp_opt **edop)
2253 {
2254 unsigned int i;
2255
2256 for (i = 0; i < sizeof(cf_options) / sizeof(cf_options[0]); i++) {
2257 if (!cf_options[i].name ||
2258 strcmp(cf_options[i].name, opt) != 0)
2259 continue;
2260
2261 if (cf_options[i].has_arg == required_argument && !line) {
2262 logerrx("option requires an argument -- %s", opt);
2263 return -1;
2264 }
2265
2266 return parse_option(ctx, ifname, ifo, cf_options[i].val, line,
2267 ldop, edop);
2268 }
2269
2270 logerrx("unknown option: %s", opt);
2271 return -1;
2272 }
2273
2274 static void
2275 finish_config(struct if_options *ifo)
2276 {
2277
2278 /* Terminate the encapsulated options */
2279 if (ifo->vendor[0] && !(ifo->options & DHCPCD_VENDORRAW)) {
2280 ifo->vendor[0]++;
2281 ifo->vendor[ifo->vendor[0]] = DHO_END;
2282 /* We are called twice.
2283 * This should be fixed, but in the meantime, this
2284 * guard should suffice */
2285 ifo->options |= DHCPCD_VENDORRAW;
2286 }
2287
2288 if (!(ifo->options & DHCPCD_ARP) ||
2289 ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC))
2290 ifo->options &= ~DHCPCD_IPV4LL;
2291
2292 if (!(ifo->options & DHCPCD_IPV4))
2293 ifo->options &= ~(DHCPCD_DHCP | DHCPCD_IPV4LL | DHCPCD_WAITIP4);
2294
2295 if (!(ifo->options & DHCPCD_IPV6))
2296 ifo->options &=
2297 ~(DHCPCD_IPV6RS | DHCPCD_DHCP6 | DHCPCD_WAITIP6);
2298
2299 if (!(ifo->options & DHCPCD_IPV6RS))
2300 ifo->options &=
2301 ~(DHCPCD_IPV6RA_AUTOCONF | DHCPCD_IPV6RA_REQRDNSS);
2302 }
2303
2304 struct if_options *
2305 default_config(struct dhcpcd_ctx *ctx)
2306 {
2307 struct if_options *ifo;
2308
2309 /* Seed our default options */
2310 if ((ifo = calloc(1, sizeof(*ifo))) == NULL) {
2311 logerr(__func__);
2312 return NULL;
2313 }
2314 ifo->options |= DHCPCD_IF_UP | DHCPCD_LINK | DHCPCD_INITIAL_DELAY;
2315 ifo->timeout = DEFAULT_TIMEOUT;
2316 ifo->reboot = DEFAULT_REBOOT;
2317 ifo->metric = -1;
2318 ifo->auth.options |= DHCPCD_AUTH_REQUIRE;
2319 rb_tree_init(&ifo->routes, &rt_compare_list_ops);
2320 #ifdef AUTH
2321 TAILQ_INIT(&ifo->auth.tokens);
2322 #endif
2323
2324 /* Inherit some global defaults */
2325 if (ctx->options & DHCPCD_PERSISTENT)
2326 ifo->options |= DHCPCD_PERSISTENT;
2327 if (ctx->options & DHCPCD_SLAACPRIVATE)
2328 ifo->options |= DHCPCD_SLAACPRIVATE;
2329
2330 return ifo;
2331 }
2332
2333 struct if_options *
2334 read_config(struct dhcpcd_ctx *ctx,
2335 const char *ifname, const char *ssid, const char *profile)
2336 {
2337 struct if_options *ifo;
2338 char buf[UDPLEN_MAX], *bp; /* 64k max config file size */
2339 char *line, *option, *p;
2340 ssize_t buflen;
2341 size_t vlen;
2342 int skip, have_profile, new_block, had_block;
2343 #if !defined(INET) || !defined(INET6)
2344 size_t i;
2345 struct dhcp_opt *opt;
2346 #endif
2347 struct dhcp_opt *ldop, *edop;
2348
2349 /* Seed our default options */
2350 if ((ifo = default_config(ctx)) == NULL)
2351 return NULL;
2352 if (default_options == 0) {
2353 default_options |= DHCPCD_DAEMONISE | DHCPCD_GATEWAY;
2354 #ifdef INET
2355 skip = socket(PF_INET, SOCK_DGRAM, 0);
2356 if (skip != -1) {
2357 close(skip);
2358 default_options |= DHCPCD_IPV4 | DHCPCD_ARP |
2359 DHCPCD_DHCP | DHCPCD_IPV4LL;
2360 }
2361 #endif
2362 #ifdef INET6
2363 skip = socket(PF_INET6, SOCK_DGRAM, 0);
2364 if (skip != -1) {
2365 close(skip);
2366 default_options |= DHCPCD_IPV6 | DHCPCD_IPV6RS |
2367 DHCPCD_IPV6RA_AUTOCONF | DHCPCD_IPV6RA_REQRDNSS |
2368 DHCPCD_DHCP6;
2369 }
2370 #endif
2371 #ifdef PLUGIN_DEV
2372 default_options |= DHCPCD_DEV;
2373 #endif
2374 }
2375 ifo->options |= default_options;
2376
2377 CLEAR_CONFIG_BLOCK(ifo);
2378
2379 vlen = strlcpy((char *)ifo->vendorclassid + 1, ctx->vendor,
2380 sizeof(ifo->vendorclassid) - 1);
2381 ifo->vendorclassid[0] = (uint8_t)(vlen > 255 ? 0 : vlen);
2382
2383 /* Reset route order */
2384 ctx->rt_order = 0;
2385
2386 /* Parse our embedded options file */
2387 if (ifname == NULL && !(ctx->options & DHCPCD_PRINT_PIDFILE)) {
2388 /* Space for initial estimates */
2389 #if defined(INET) && defined(INITDEFINES)
2390 ifo->dhcp_override =
2391 calloc(INITDEFINES, sizeof(*ifo->dhcp_override));
2392 if (ifo->dhcp_override == NULL)
2393 logerr(__func__);
2394 else
2395 ifo->dhcp_override_len = INITDEFINES;
2396 #endif
2397
2398 #if defined(INET6) && defined(INITDEFINENDS)
2399 ifo->nd_override =
2400 calloc(INITDEFINENDS, sizeof(*ifo->nd_override));
2401 if (ifo->nd_override == NULL)
2402 logerr(__func__);
2403 else
2404 ifo->nd_override_len = INITDEFINENDS;
2405 #endif
2406 #if defined(INET6) && defined(INITDEFINE6S)
2407 ifo->dhcp6_override =
2408 calloc(INITDEFINE6S, sizeof(*ifo->dhcp6_override));
2409 if (ifo->dhcp6_override == NULL)
2410 logerr(__func__);
2411 else
2412 ifo->dhcp6_override_len = INITDEFINE6S;
2413 #endif
2414
2415 /* Now load our embedded config */
2416 #ifdef EMBEDDED_CONFIG
2417 buflen = dhcp_readfile(ctx, EMBEDDED_CONFIG, buf, sizeof(buf));
2418 if (buflen == -1) {
2419 logerr("%s: %s", __func__, EMBEDDED_CONFIG);
2420 return ifo;
2421 }
2422 if (buf[buflen - 1] != '\0') {
2423 if ((size_t)buflen < sizeof(buf) - 1)
2424 buflen++;
2425 buf[buflen - 1] = '\0';
2426 }
2427 #else
2428 buflen = (ssize_t)strlcpy(buf, dhcpcd_embedded_conf,
2429 sizeof(buf));
2430 if ((size_t)buflen >= sizeof(buf)) {
2431 logerrx("%s: embedded config too big", __func__);
2432 return ifo;
2433 }
2434 /* Our embedded config is NULL terminated */
2435 #endif
2436 bp = buf;
2437 while ((line = get_line(&bp, &buflen)) != NULL) {
2438 option = strsep(&line, " \t");
2439 if (line)
2440 line = strskipwhite(line);
2441 /* Trim trailing whitespace */
2442 if (line) {
2443 p = line + strlen(line) - 1;
2444 while (p != line &&
2445 (*p == ' ' || *p == '\t') &&
2446 *(p - 1) != '\\')
2447 *p-- = '\0';
2448 }
2449 parse_config_line(ctx, NULL, ifo, option, line,
2450 &ldop, &edop);
2451 }
2452
2453 #ifdef INET
2454 ctx->dhcp_opts = ifo->dhcp_override;
2455 ctx->dhcp_opts_len = ifo->dhcp_override_len;
2456 #else
2457 for (i = 0, opt = ifo->dhcp_override;
2458 i < ifo->dhcp_override_len;
2459 i++, opt++)
2460 free_dhcp_opt_embenc(opt);
2461 free(ifo->dhcp_override);
2462 #endif
2463 ifo->dhcp_override = NULL;
2464 ifo->dhcp_override_len = 0;
2465
2466 #ifdef INET6
2467 ctx->nd_opts = ifo->nd_override;
2468 ctx->nd_opts_len = ifo->nd_override_len;
2469 #ifdef DHCP6
2470 ctx->dhcp6_opts = ifo->dhcp6_override;
2471 ctx->dhcp6_opts_len = ifo->dhcp6_override_len;
2472 #endif
2473 #else
2474 for (i = 0, opt = ifo->nd_override;
2475 i < ifo->nd_override_len;
2476 i++, opt++)
2477 free_dhcp_opt_embenc(opt);
2478 free(ifo->nd_override);
2479 for (i = 0, opt = ifo->dhcp6_override;
2480 i < ifo->dhcp6_override_len;
2481 i++, opt++)
2482 free_dhcp_opt_embenc(opt);
2483 free(ifo->dhcp6_override);
2484 #endif
2485 ifo->nd_override = NULL;
2486 ifo->nd_override_len = 0;
2487 ifo->dhcp6_override = NULL;
2488 ifo->dhcp6_override_len = 0;
2489
2490 ctx->vivso = ifo->vivso_override;
2491 ctx->vivso_len = ifo->vivso_override_len;
2492 ifo->vivso_override = NULL;
2493 ifo->vivso_override_len = 0;
2494 }
2495
2496 /* Parse our options file */
2497 buflen = dhcp_readfile(ctx, ctx->cffile, buf, sizeof(buf));
2498 if (buflen == -1) {
2499 /* dhcpcd can continue without it, but no DNS options
2500 * would be requested ... */
2501 logerr("%s: %s", __func__, ctx->cffile);
2502 return ifo;
2503 }
2504 if (buf[buflen - 1] != '\0') {
2505 if ((size_t)buflen < sizeof(buf) - 1)
2506 buflen++;
2507 buf[buflen - 1] = '\0';
2508 }
2509 dhcp_filemtime(ctx, ctx->cffile, &ifo->mtime);
2510
2511 ldop = edop = NULL;
2512 skip = have_profile = new_block = 0;
2513 had_block = ifname == NULL ? 1 : 0;
2514 bp = buf;
2515 while ((line = get_line(&bp, &buflen)) != NULL) {
2516 option = strsep(&line, " \t");
2517 if (line)
2518 line = strskipwhite(line);
2519 /* Trim trailing whitespace */
2520 if (line) {
2521 p = line + strlen(line) - 1;
2522 while (p != line &&
2523 (*p == ' ' || *p == '\t') &&
2524 *(p - 1) != '\\')
2525 *p-- = '\0';
2526 }
2527 if (skip == 0 && new_block) {
2528 had_block = 1;
2529 new_block = 0;
2530 ifo->options &= ~DHCPCD_WAITOPTS;
2531 SET_CONFIG_BLOCK(ifo);
2532 }
2533
2534 /* Start of an interface block, skip if not ours */
2535 if (strcmp(option, "interface") == 0) {
2536 char **n;
2537
2538 new_block = 1;
2539 if (line == NULL) {
2540 /* No interface given */
2541 skip = 1;
2542 continue;
2543 }
2544 if (ifname && strcmp(line, ifname) == 0)
2545 skip = 0;
2546 else
2547 skip = 1;
2548 if (ifname)
2549 continue;
2550
2551 n = reallocarray(ctx->ifcv,
2552 (size_t)ctx->ifcc + 1, sizeof(char *));
2553 if (n == NULL) {
2554 logerr(__func__);
2555 continue;
2556 }
2557 ctx->ifcv = n;
2558 ctx->ifcv[ctx->ifcc] = strdup(line);
2559 if (ctx->ifcv[ctx->ifcc] == NULL) {
2560 logerr(__func__);
2561 continue;
2562 }
2563 ctx->ifcc++;
2564 continue;
2565 }
2566 /* Start of an ssid block, skip if not ours */
2567 if (strcmp(option, "ssid") == 0) {
2568 new_block = 1;
2569 if (ssid && line && strcmp(line, ssid) == 0)
2570 skip = 0;
2571 else
2572 skip = 1;
2573 continue;
2574 }
2575 /* Start of a profile block, skip if not ours */
2576 if (strcmp(option, "profile") == 0) {
2577 new_block = 1;
2578 if (profile && line && strcmp(line, profile) == 0) {
2579 skip = 0;
2580 have_profile = 1;
2581 } else
2582 skip = 1;
2583 continue;
2584 }
2585 /* Skip arping if we have selected a profile but not parsing
2586 * one. */
2587 if (profile && !have_profile && strcmp(option, "arping") == 0)
2588 continue;
2589 if (skip)
2590 continue;
2591
2592 parse_config_line(ctx, ifname, ifo, option, line, &ldop, &edop);
2593 }
2594
2595 if (profile && !have_profile) {
2596 free_options(ctx, ifo);
2597 errno = ENOENT;
2598 return NULL;
2599 }
2600
2601 if (!had_block)
2602 ifo->options &= ~DHCPCD_WAITOPTS;
2603 CLEAR_CONFIG_BLOCK(ifo);
2604 finish_config(ifo);
2605 return ifo;
2606 }
2607
2608 int
2609 add_options(struct dhcpcd_ctx *ctx, const char *ifname,
2610 struct if_options *ifo, int argc, char **argv)
2611 {
2612 int oi, opt, r;
2613 unsigned long long wait_opts;
2614
2615 if (argc == 0)
2616 return 1;
2617
2618 optind = 0;
2619 r = 1;
2620 /* Don't apply the command line wait options to each interface,
2621 * only use the dhcpcd.conf entry for that. */
2622 if (ifname != NULL)
2623 wait_opts = ifo->options & DHCPCD_WAITOPTS;
2624 while ((opt = getopt_long(argc, argv,
2625 ctx->options & DHCPCD_PRINT_PIDFILE ? NOERR_IF_OPTS : IF_OPTS,
2626 cf_options, &oi)) != -1)
2627 {
2628 r = parse_option(ctx, ifname, ifo, opt, optarg, NULL, NULL);
2629 if (r != 1)
2630 break;
2631 }
2632 if (ifname != NULL) {
2633 ifo->options &= ~DHCPCD_WAITOPTS;
2634 ifo->options |= wait_opts;
2635 }
2636
2637 finish_config(ifo);
2638 return r;
2639 }
2640
2641 void
2642 free_options(struct dhcpcd_ctx *ctx, struct if_options *ifo)
2643 {
2644 size_t i;
2645 #ifdef RT_FREE_ROUTE_TABLE
2646 struct interface *ifp;
2647 struct rt *rt;
2648 #endif
2649 struct dhcp_opt *opt;
2650 struct vivco *vo;
2651 #ifdef AUTH
2652 struct token *token;
2653 #endif
2654
2655 if (ifo == NULL)
2656 return;
2657
2658 if (ifo->environ) {
2659 i = 0;
2660 while (ifo->environ[i])
2661 free(ifo->environ[i++]);
2662 free(ifo->environ);
2663 }
2664 if (ifo->config) {
2665 i = 0;
2666 while (ifo->config[i])
2667 free(ifo->config[i++]);
2668 free(ifo->config);
2669 }
2670
2671 #ifdef RT_FREE_ROUTE_TABLE
2672 /* Stupidly, we don't know the interface when creating the options.
2673 * As such, make sure each route has one so they can goto the
2674 * free list. */
2675 ifp = ctx->ifaces != NULL ? TAILQ_FIRST(ctx->ifaces) : NULL;
2676 if (ifp != NULL) {
2677 RB_TREE_FOREACH(rt, &ifo->routes) {
2678 if (rt->rt_ifp == NULL)
2679 rt->rt_ifp = ifp;
2680 }
2681 }
2682 #endif
2683 rt_headclear0(ctx, &ifo->routes, AF_UNSPEC);
2684
2685 free(ifo->arping);
2686 free(ifo->blacklist);
2687 free(ifo->fallback);
2688
2689 for (opt = ifo->dhcp_override;
2690 ifo->dhcp_override_len > 0;
2691 opt++, ifo->dhcp_override_len--)
2692 free_dhcp_opt_embenc(opt);
2693 free(ifo->dhcp_override);
2694 for (opt = ifo->nd_override;
2695 ifo->nd_override_len > 0;
2696 opt++, ifo->nd_override_len--)
2697 free_dhcp_opt_embenc(opt);
2698 free(ifo->nd_override);
2699 for (opt = ifo->dhcp6_override;
2700 ifo->dhcp6_override_len > 0;
2701 opt++, ifo->dhcp6_override_len--)
2702 free_dhcp_opt_embenc(opt);
2703 free(ifo->dhcp6_override);
2704 for (vo = ifo->vivco;
2705 ifo->vivco_len > 0;
2706 vo++, ifo->vivco_len--)
2707 free(vo->data);
2708 free(ifo->vivco);
2709 for (opt = ifo->vivso_override;
2710 ifo->vivso_override_len > 0;
2711 opt++, ifo->vivso_override_len--)
2712 free_dhcp_opt_embenc(opt);
2713 free(ifo->vivso_override);
2714
2715 #if defined(INET6) && !defined(SMALL)
2716 for (; ifo->ia_len > 0; ifo->ia_len--)
2717 free(ifo->ia[ifo->ia_len - 1].sla);
2718 #endif
2719 free(ifo->ia);
2720
2721 #ifdef AUTH
2722 while ((token = TAILQ_FIRST(&ifo->auth.tokens))) {
2723 TAILQ_REMOVE(&ifo->auth.tokens, token, next);
2724 if (token->realm_len)
2725 free(token->realm);
2726 free(token->key);
2727 free(token);
2728 }
2729 #endif
2730 free(ifo);
2731 }
DragonFly BSD