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