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