1 /* SPDX-License-Identifier: BSD-2-Clause */ 2 /* 3 * dhcpcd - DHCP client daemon 4 * Copyright (c) 2006-2019 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 const char dhcpcd_copyright[] = "Copyright (c) 2006-2019 Roy Marples"; 30 31 #include <sys/file.h> 32 #include <sys/socket.h> 33 #include <sys/stat.h> 34 #include <sys/time.h> 35 #include <sys/types.h> 36 #include <sys/uio.h> 37 38 #include <ctype.h> 39 #include <errno.h> 40 #include <fcntl.h> 41 #include <getopt.h> 42 #include <limits.h> 43 #include <paths.h> 44 #include <signal.h> 45 #include <stdio.h> 46 #include <stdlib.h> 47 #include <string.h> 48 #include <unistd.h> 49 #include <time.h> 50 51 #include "config.h" 52 #include "arp.h" 53 #include "common.h" 54 #include "control.h" 55 #include "dev.h" 56 #include "dhcp-common.h" 57 #include "dhcpcd.h" 58 #include "dhcp.h" 59 #include "dhcp6.h" 60 #include "duid.h" 61 #include "eloop.h" 62 #include "if.h" 63 #include "if-options.h" 64 #include "ipv4.h" 65 #include "ipv4ll.h" 66 #include "ipv6.h" 67 #include "ipv6nd.h" 68 #include "logerr.h" 69 #include "script.h" 70 71 #ifdef HAVE_UTIL_H 72 #include <util.h> 73 #endif 74 75 #ifdef USE_SIGNALS 76 const int dhcpcd_signals[] = { 77 SIGTERM, 78 SIGINT, 79 SIGALRM, 80 SIGHUP, 81 SIGUSR1, 82 SIGUSR2, 83 SIGPIPE 84 }; 85 const size_t dhcpcd_signals_len = __arraycount(dhcpcd_signals); 86 #endif 87 88 #define IF_UPANDRUNNING(a) \ 89 (((a)->flags & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING)) 90 91 static void 92 usage(void) 93 { 94 95 printf("usage: "PACKAGE"\t[-146ABbDdEGgHJKLMNPpqTV]\n" 96 "\t\t[-C, --nohook hook] [-c, --script script]\n" 97 "\t\t[-e, --env value] [-F, --fqdn FQDN] [-f, --config file]\n" 98 "\t\t[-h, --hostname hostname] [-I, --clientid clientid]\n" 99 "\t\t[-i, --vendorclassid vendorclassid] [-j, --logfile logfile]\n" 100 "\t\t[-l, --leasetime seconds] [-m, --metric metric]\n" 101 "\t\t[-O, --nooption option] [-o, --option option]\n" 102 "\t\t[-Q, --require option] [-r, --request address]\n" 103 "\t\t[-S, --static value]\n" 104 "\t\t[-s, --inform address[/cidr[/broadcast_address]]]\n [--inform6]" 105 "\t\t[-t, --timeout seconds] [-u, --userclass class]\n" 106 "\t\t[-v, --vendor code, value] [-W, --whitelist address[/cidr]] [-w]\n" 107 "\t\t[--waitip [4 | 6]] [-y, --reboot seconds]\n" 108 "\t\t[-X, --blacklist address[/cidr]] [-Z, --denyinterfaces pattern]\n" 109 "\t\t[-z, --allowinterfaces pattern] [--inactive] [interface] [...]\n" 110 " "PACKAGE"\t-n, --rebind [interface]\n" 111 " "PACKAGE"\t-k, --release [interface]\n" 112 " "PACKAGE"\t-U, --dumplease interface\n" 113 " "PACKAGE"\t--version\n" 114 " "PACKAGE"\t-x, --exit [interface]\n"); 115 } 116 117 static void 118 free_globals(struct dhcpcd_ctx *ctx) 119 { 120 struct dhcp_opt *opt; 121 122 if (ctx->ifac) { 123 for (; ctx->ifac > 0; ctx->ifac--) 124 free(ctx->ifav[ctx->ifac - 1]); 125 free(ctx->ifav); 126 ctx->ifav = NULL; 127 } 128 if (ctx->ifdc) { 129 for (; ctx->ifdc > 0; ctx->ifdc--) 130 free(ctx->ifdv[ctx->ifdc - 1]); 131 free(ctx->ifdv); 132 ctx->ifdv = NULL; 133 } 134 if (ctx->ifcc) { 135 for (; ctx->ifcc > 0; ctx->ifcc--) 136 free(ctx->ifcv[ctx->ifcc - 1]); 137 free(ctx->ifcv); 138 ctx->ifcv = NULL; 139 } 140 141 #ifdef INET 142 if (ctx->dhcp_opts) { 143 for (opt = ctx->dhcp_opts; 144 ctx->dhcp_opts_len > 0; 145 opt++, ctx->dhcp_opts_len--) 146 free_dhcp_opt_embenc(opt); 147 free(ctx->dhcp_opts); 148 ctx->dhcp_opts = NULL; 149 } 150 #endif 151 #ifdef INET6 152 if (ctx->nd_opts) { 153 for (opt = ctx->nd_opts; 154 ctx->nd_opts_len > 0; 155 opt++, ctx->nd_opts_len--) 156 free_dhcp_opt_embenc(opt); 157 free(ctx->nd_opts); 158 ctx->nd_opts = NULL; 159 } 160 #ifdef DHCP6 161 if (ctx->dhcp6_opts) { 162 for (opt = ctx->dhcp6_opts; 163 ctx->dhcp6_opts_len > 0; 164 opt++, ctx->dhcp6_opts_len--) 165 free_dhcp_opt_embenc(opt); 166 free(ctx->dhcp6_opts); 167 ctx->dhcp6_opts = NULL; 168 } 169 #endif 170 #endif 171 if (ctx->vivso) { 172 for (opt = ctx->vivso; 173 ctx->vivso_len > 0; 174 opt++, ctx->vivso_len--) 175 free_dhcp_opt_embenc(opt); 176 free(ctx->vivso); 177 ctx->vivso = NULL; 178 } 179 } 180 181 static void 182 handle_exit_timeout(void *arg) 183 { 184 struct dhcpcd_ctx *ctx; 185 186 ctx = arg; 187 logerrx("timed out"); 188 if (!(ctx->options & DHCPCD_MASTER)) { 189 eloop_exit(ctx->eloop, EXIT_FAILURE); 190 return; 191 } 192 ctx->options |= DHCPCD_NOWAITIP; 193 dhcpcd_daemonise(ctx); 194 } 195 196 static const char * 197 dhcpcd_af(int af) 198 { 199 200 switch (af) { 201 case AF_UNSPEC: 202 return "IP"; 203 case AF_INET: 204 return "IPv4"; 205 case AF_INET6: 206 return "IPv6"; 207 default: 208 return NULL; 209 } 210 } 211 212 int 213 dhcpcd_ifafwaiting(const struct interface *ifp) 214 { 215 unsigned long long opts; 216 bool foundany = false; 217 218 if (ifp->active != IF_ACTIVE_USER) 219 return AF_MAX; 220 221 #define DHCPCD_WAITALL (DHCPCD_WAITIP4 | DHCPCD_WAITIP6) 222 opts = ifp->options->options; 223 #ifdef INET 224 if (opts & DHCPCD_WAITIP4 || 225 (opts & DHCPCD_WAITIP && !(opts & DHCPCD_WAITALL))) 226 { 227 bool foundaddr = ipv4_hasaddr(ifp); 228 229 if (opts & DHCPCD_WAITIP4 && !foundaddr) 230 return AF_INET; 231 if (foundaddr) 232 foundany = true; 233 } 234 #endif 235 #ifdef INET6 236 if (opts & DHCPCD_WAITIP6 || 237 (opts & DHCPCD_WAITIP && !(opts & DHCPCD_WAITALL))) 238 { 239 bool foundaddr = ipv6_hasaddr(ifp); 240 241 if (opts & DHCPCD_WAITIP6 && !foundaddr) 242 return AF_INET; 243 if (foundaddr) 244 foundany = true; 245 } 246 #endif 247 248 if (opts & DHCPCD_WAITIP && !(opts & DHCPCD_WAITALL) && !foundany) 249 return AF_UNSPEC; 250 return AF_MAX; 251 } 252 253 int 254 dhcpcd_afwaiting(const struct dhcpcd_ctx *ctx) 255 { 256 unsigned long long opts; 257 const struct interface *ifp; 258 int af; 259 260 if (!(ctx->options & DHCPCD_WAITOPTS)) 261 return AF_MAX; 262 263 opts = ctx->options; 264 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 265 #ifdef INET 266 if (opts & (DHCPCD_WAITIP | DHCPCD_WAITIP4) && 267 ipv4_hasaddr(ifp)) 268 opts &= ~(DHCPCD_WAITIP | DHCPCD_WAITIP4); 269 #endif 270 #ifdef INET6 271 if (opts & (DHCPCD_WAITIP | DHCPCD_WAITIP6) && 272 ipv6_hasaddr(ifp)) 273 opts &= ~(DHCPCD_WAITIP | DHCPCD_WAITIP6); 274 #endif 275 if (!(opts & DHCPCD_WAITOPTS)) 276 break; 277 } 278 if (opts & DHCPCD_WAITIP) 279 af = AF_UNSPEC; 280 else if (opts & DHCPCD_WAITIP4) 281 af = AF_INET; 282 else if (opts & DHCPCD_WAITIP6) 283 af = AF_INET6; 284 else 285 return AF_MAX; 286 return af; 287 } 288 289 static int 290 dhcpcd_ipwaited(struct dhcpcd_ctx *ctx) 291 { 292 struct interface *ifp; 293 int af; 294 295 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 296 if ((af = dhcpcd_ifafwaiting(ifp)) != AF_MAX) { 297 logdebugx("%s: waiting for an %s address", 298 ifp->name, dhcpcd_af(af)); 299 return 0; 300 } 301 } 302 303 if ((af = dhcpcd_afwaiting(ctx)) != AF_MAX) { 304 logdebugx("waiting for an %s address", 305 dhcpcd_af(af)); 306 return 0; 307 } 308 309 return 1; 310 } 311 312 /* Returns the pid of the child, otherwise 0. */ 313 pid_t 314 dhcpcd_daemonise(struct dhcpcd_ctx *ctx) 315 { 316 #ifdef THERE_IS_NO_FORK 317 eloop_timeout_delete(ctx->eloop, handle_exit_timeout, ctx); 318 errno = ENOSYS; 319 return 0; 320 #else 321 pid_t pid, lpid; 322 char buf = '\0'; 323 int sidpipe[2], fd; 324 325 if (ctx->options & DHCPCD_DAEMONISE && 326 !(ctx->options & (DHCPCD_DAEMONISED | DHCPCD_NOWAITIP))) 327 { 328 if (!dhcpcd_ipwaited(ctx)) 329 return 0; 330 } 331 332 if (ctx->options & DHCPCD_ONESHOT) { 333 loginfox("exiting due to oneshot"); 334 eloop_exit(ctx->eloop, EXIT_SUCCESS); 335 return 0; 336 } 337 338 eloop_timeout_delete(ctx->eloop, handle_exit_timeout, ctx); 339 if (ctx->options & DHCPCD_DAEMONISED || 340 !(ctx->options & DHCPCD_DAEMONISE)) 341 return 0; 342 logdebugx("forking to background"); 343 344 /* Setup a signal pipe so parent knows when to exit. */ 345 if (pipe(sidpipe) == -1) { 346 logerr("%s: pipe", __func__); 347 return 0; 348 } 349 350 switch (pid = fork()) { 351 case -1: 352 logerr("%s: fork", __func__); 353 return 0; 354 case 0: 355 if ((lpid = pidfile_lock(ctx->pidfile)) != 0) 356 logerr("%s: pidfile_lock %d", __func__, lpid); 357 setsid(); 358 /* Notify parent it's safe to exit as we've detached. */ 359 close(sidpipe[0]); 360 if (write(sidpipe[1], &buf, 1) == -1) 361 logerr("%s: write", __func__); 362 close(sidpipe[1]); 363 /* Some polling methods don't survive after forking, 364 * so ensure we can requeue all our events. */ 365 if (eloop_requeue(ctx->eloop) == -1) { 366 logerr("%s: eloop_requeue", __func__); 367 eloop_exit(ctx->eloop, EXIT_FAILURE); 368 } 369 if ((fd = open(_PATH_DEVNULL, O_RDWR, 0)) != -1) { 370 dup2(fd, STDIN_FILENO); 371 dup2(fd, STDOUT_FILENO); 372 dup2(fd, STDERR_FILENO); 373 close(fd); 374 } 375 ctx->options |= DHCPCD_DAEMONISED; 376 return 0; 377 default: 378 /* Wait for child to detach */ 379 close(sidpipe[1]); 380 if (read(sidpipe[0], &buf, 1) == -1) 381 logerr("%s: read", __func__); 382 close(sidpipe[0]); 383 loginfox("forked to background, child pid %d", pid); 384 ctx->options |= DHCPCD_FORKED; 385 eloop_exit(ctx->eloop, EXIT_SUCCESS); 386 return pid; 387 } 388 #endif 389 } 390 391 static void 392 dhcpcd_drop(struct interface *ifp, int stop) 393 { 394 395 #ifdef DHCP6 396 dhcp6_drop(ifp, stop ? NULL : "EXPIRE6"); 397 #endif 398 #ifdef INET6 399 ipv6nd_drop(ifp); 400 ipv6_drop(ifp); 401 #endif 402 #ifdef IPV4LL 403 ipv4ll_drop(ifp); 404 #endif 405 #ifdef INET 406 dhcp_drop(ifp, stop ? "STOP" : "EXPIRE"); 407 #endif 408 #ifdef ARP 409 arp_drop(ifp); 410 #endif 411 #if !defined(DHCP6) && !defined(DHCP) 412 UNUSED(stop); 413 #endif 414 } 415 416 static void 417 stop_interface(struct interface *ifp) 418 { 419 struct dhcpcd_ctx *ctx; 420 421 ctx = ifp->ctx; 422 loginfox("%s: removing interface", ifp->name); 423 ifp->options->options |= DHCPCD_STOPPING; 424 425 dhcpcd_drop(ifp, 1); 426 if (ifp->options->options & DHCPCD_DEPARTED) 427 script_runreason(ifp, "DEPARTED"); 428 else 429 script_runreason(ifp, "STOPPED"); 430 431 /* Delete all timeouts for the interfaces */ 432 eloop_q_timeout_delete(ctx->eloop, 0, NULL, ifp); 433 434 /* De-activate the interface */ 435 ifp->active = IF_INACTIVE; 436 ifp->options->options &= ~DHCPCD_STOPPING; 437 /* Set the link state to unknown as we're no longer tracking it. */ 438 ifp->carrier = LINK_UNKNOWN; 439 440 if (!(ctx->options & (DHCPCD_MASTER | DHCPCD_TEST))) 441 eloop_exit(ctx->eloop, EXIT_FAILURE); 442 } 443 444 static void 445 configure_interface1(struct interface *ifp) 446 { 447 struct if_options *ifo = ifp->options; 448 449 /* Do any platform specific configuration */ 450 if_conf(ifp); 451 452 /* If we want to release a lease, we can't really persist the 453 * address either. */ 454 if (ifo->options & DHCPCD_RELEASE) 455 ifo->options &= ~DHCPCD_PERSISTENT; 456 457 if (ifp->flags & (IFF_POINTOPOINT | IFF_LOOPBACK)) { 458 ifo->options &= ~DHCPCD_ARP; 459 if (!(ifp->flags & IFF_MULTICAST)) 460 ifo->options &= ~DHCPCD_IPV6RS; 461 if (!(ifo->options & (DHCPCD_INFORM | DHCPCD_WANTDHCP))) 462 ifo->options |= DHCPCD_STATIC; 463 } 464 if (!(ifo->options & DHCPCD_ARP) || 465 ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC)) 466 ifo->options &= ~DHCPCD_IPV4LL; 467 468 if (ifo->metric != -1) 469 ifp->metric = (unsigned int)ifo->metric; 470 471 if (!(ifo->options & DHCPCD_IPV4)) 472 ifo->options &= ~(DHCPCD_DHCP | DHCPCD_IPV4LL | DHCPCD_WAITIP4); 473 474 #ifdef INET6 475 if (!(ifo->options & DHCPCD_IPV6)) 476 ifo->options &= 477 ~(DHCPCD_IPV6RS | DHCPCD_DHCP6 | DHCPCD_WAITIP6); 478 479 if (!(ifo->options & DHCPCD_IPV6RS)) 480 ifo->options &= 481 ~(DHCPCD_IPV6RA_AUTOCONF | DHCPCD_IPV6RA_REQRDNSS); 482 483 /* We want to setup INET6 on the interface as soon as possible. */ 484 if (ifp->active == IF_ACTIVE_USER && 485 ifo->options & DHCPCD_IPV6 && 486 !(ifp->ctx->options & (DHCPCD_DUMPLEASE | DHCPCD_TEST))) 487 { 488 /* If not doing any DHCP, disable the RDNSS requirement. */ 489 if (!(ifo->options & (DHCPCD_DHCP | DHCPCD_DHCP6))) 490 ifo->options &= ~DHCPCD_IPV6RA_REQRDNSS; 491 if_setup_inet6(ifp); 492 } 493 #endif 494 495 if (!(ifo->options & DHCPCD_IAID)) { 496 /* 497 * An IAID is for identifying a unqiue interface within 498 * the client. It is 4 bytes long. Working out a default 499 * value is problematic. 500 * 501 * Interface name and number are not stable 502 * between different OS's. Some OS's also cannot make 503 * up their mind what the interface should be called 504 * (yes, udev, I'm looking at you). 505 * Also, the name could be longer than 4 bytes. 506 * Also, with pluggable interfaces the name and index 507 * could easily get swapped per actual interface. 508 * 509 * The MAC address is 6 bytes long, the final 3 510 * being unique to the manufacturer and the initial 3 511 * being unique to the organisation which makes it. 512 * We could use the last 4 bytes of the MAC address 513 * as the IAID as it's the most stable part given the 514 * above, but equally it's not guaranteed to be 515 * unique. 516 * 517 * Given the above, and our need to reliably work 518 * between reboots without persitent storage, 519 * generating the IAID from the MAC address is the only 520 * logical default. 521 * Saying that, if a VLANID has been specified then we 522 * can use that. It's possible that different interfaces 523 * can have the same VLANID, but this is no worse than 524 * generating the IAID from the duplicate MAC address. 525 * 526 * dhclient uses the last 4 bytes of the MAC address. 527 * dibbler uses an increamenting counter. 528 * wide-dhcpv6 uses 0 or a configured value. 529 * odhcp6c uses 1. 530 * Windows 7 uses the first 3 bytes of the MAC address 531 * and an unknown byte. 532 * dhcpcd-6.1.0 and earlier used the interface name, 533 * falling back to interface index if name > 4. 534 */ 535 if (ifp->vlanid != 0) { 536 uint32_t vlanid; 537 538 /* Maximal VLANID is 4095, so prefix with 0xff 539 * so we don't conflict with an interface index. */ 540 vlanid = htonl(ifp->vlanid | 0xff000000); 541 memcpy(ifo->iaid, &vlanid, sizeof(vlanid)); 542 } else if (ifp->hwlen >= sizeof(ifo->iaid)) { 543 memcpy(ifo->iaid, 544 ifp->hwaddr + ifp->hwlen - sizeof(ifo->iaid), 545 sizeof(ifo->iaid)); 546 } else { 547 uint32_t len; 548 549 len = (uint32_t)strlen(ifp->name); 550 if (len <= sizeof(ifo->iaid)) { 551 memcpy(ifo->iaid, ifp->name, len); 552 if (len < sizeof(ifo->iaid)) 553 memset(ifo->iaid + len, 0, 554 sizeof(ifo->iaid) - len); 555 } else { 556 /* IAID is the same size as a uint32_t */ 557 len = htonl(ifp->index); 558 memcpy(ifo->iaid, &len, sizeof(ifo->iaid)); 559 } 560 } 561 ifo->options |= DHCPCD_IAID; 562 } 563 564 #ifdef DHCP6 565 if (ifo->ia_len == 0 && ifo->options & DHCPCD_IPV6 && 566 ifp->name[0] != '\0') 567 { 568 ifo->ia = malloc(sizeof(*ifo->ia)); 569 if (ifo->ia == NULL) 570 logerr(__func__); 571 else { 572 ifo->ia_len = 1; 573 ifo->ia->ia_type = D6_OPTION_IA_NA; 574 memcpy(ifo->ia->iaid, ifo->iaid, sizeof(ifo->iaid)); 575 memset(&ifo->ia->addr, 0, sizeof(ifo->ia->addr)); 576 #ifndef SMALL 577 ifo->ia->sla = NULL; 578 ifo->ia->sla_len = 0; 579 #endif 580 } 581 } else { 582 size_t i; 583 584 for (i = 0; i < ifo->ia_len; i++) { 585 if (!ifo->ia[i].iaid_set) { 586 memcpy(&ifo->ia[i].iaid, ifo->iaid, 587 sizeof(ifo->ia[i].iaid)); 588 ifo->ia[i].iaid_set = 1; 589 } 590 } 591 } 592 #endif 593 } 594 595 int 596 dhcpcd_selectprofile(struct interface *ifp, const char *profile) 597 { 598 struct if_options *ifo; 599 char pssid[PROFILE_LEN]; 600 601 if (ifp->ssid_len) { 602 ssize_t r; 603 604 r = print_string(pssid, sizeof(pssid), OT_ESCSTRING, 605 ifp->ssid, ifp->ssid_len); 606 if (r == -1) { 607 logerr(__func__); 608 pssid[0] = '\0'; 609 } 610 } else 611 pssid[0] = '\0'; 612 ifo = read_config(ifp->ctx, ifp->name, pssid, profile); 613 if (ifo == NULL) { 614 logdebugx("%s: no profile %s", ifp->name, profile); 615 return -1; 616 } 617 if (profile != NULL) { 618 strlcpy(ifp->profile, profile, sizeof(ifp->profile)); 619 loginfox("%s: selected profile %s", ifp->name, profile); 620 } else 621 *ifp->profile = '\0'; 622 623 free_options(ifp->ctx, ifp->options); 624 ifp->options = ifo; 625 if (profile) { 626 add_options(ifp->ctx, ifp->name, ifp->options, 627 ifp->ctx->argc, ifp->ctx->argv); 628 configure_interface1(ifp); 629 } 630 return 1; 631 } 632 633 static void 634 configure_interface(struct interface *ifp, int argc, char **argv, 635 unsigned long long options) 636 { 637 time_t old; 638 639 old = ifp->options ? ifp->options->mtime : 0; 640 dhcpcd_selectprofile(ifp, NULL); 641 if (ifp->options == NULL) { 642 /* dhcpcd cannot continue with this interface. */ 643 ifp->active = IF_INACTIVE; 644 return; 645 } 646 add_options(ifp->ctx, ifp->name, ifp->options, argc, argv); 647 ifp->options->options |= options; 648 configure_interface1(ifp); 649 650 /* If the mtime has changed drop any old lease */ 651 if (old != 0 && ifp->options->mtime != old) { 652 logwarnx("%s: confile file changed, expiring leases", 653 ifp->name); 654 dhcpcd_drop(ifp, 0); 655 } 656 } 657 658 static void 659 dhcpcd_initstate2(struct interface *ifp, unsigned long long options) 660 { 661 struct if_options *ifo; 662 663 if (options) { 664 if ((ifo = default_config(ifp->ctx)) == NULL) { 665 logerr(__func__); 666 return; 667 } 668 ifo->options |= options; 669 free(ifp->options); 670 ifp->options = ifo; 671 } else 672 ifo = ifp->options; 673 674 #ifdef INET6 675 if (ifo->options & DHCPCD_IPV6 && ipv6_init(ifp->ctx) == -1) { 676 logerr(__func__); 677 ifo->options &= ~DHCPCD_IPV6; 678 } 679 #endif 680 } 681 682 static void 683 dhcpcd_initstate1(struct interface *ifp, int argc, char **argv, 684 unsigned long long options) 685 { 686 687 configure_interface(ifp, argc, argv, options); 688 if (ifp->active) 689 dhcpcd_initstate2(ifp, 0); 690 } 691 692 static void 693 dhcpcd_initstate(struct interface *ifp, unsigned long long options) 694 { 695 696 dhcpcd_initstate1(ifp, ifp->ctx->argc, ifp->ctx->argv, options); 697 } 698 699 void 700 dhcpcd_handlecarrier(struct dhcpcd_ctx *ctx, int carrier, unsigned int flags, 701 const char *ifname) 702 { 703 struct interface *ifp; 704 705 ifp = if_find(ctx->ifaces, ifname); 706 if (ifp == NULL || 707 ifp->options == NULL || !(ifp->options->options & DHCPCD_LINK) || 708 !ifp->active) 709 return; 710 711 if (carrier == LINK_UNKNOWN) { 712 if (ifp->wireless) { 713 carrier = LINK_DOWN; 714 ifp->flags = flags; 715 } else 716 carrier = if_carrier(ifp); 717 } else 718 ifp->flags = flags; 719 if (carrier == LINK_UNKNOWN) 720 carrier = IF_UPANDRUNNING(ifp) ? LINK_UP : LINK_DOWN; 721 722 if (carrier == LINK_DOWN || (ifp->flags & IFF_UP) == 0) { 723 if (ifp->carrier != LINK_DOWN) { 724 if (ifp->carrier == LINK_UP) 725 loginfox("%s: carrier lost", ifp->name); 726 #ifdef NOCARRIER_PRESERVE_IP 727 if (ifp->flags & IFF_UP) 728 ifp->carrier = LINK_DOWN_IFFUP; 729 else 730 #endif 731 ifp->carrier = LINK_DOWN; 732 script_runreason(ifp, "NOCARRIER"); 733 #ifdef NOCARRIER_PRESERVE_IP 734 if (ifp->flags & IFF_UP) { 735 #ifdef ARP 736 arp_drop(ifp); 737 #endif 738 #ifdef INET 739 dhcp_abort(ifp); 740 #endif 741 #ifdef DHCP6 742 dhcp6_abort(ifp); 743 #endif 744 } else 745 #endif 746 dhcpcd_drop(ifp, 0); 747 } 748 } else if (carrier == LINK_UP && ifp->flags & IFF_UP) { 749 if (ifp->carrier != LINK_UP) { 750 loginfox("%s: carrier acquired", ifp->name); 751 ifp->carrier = LINK_UP; 752 #if !defined(__linux__) && !defined(__NetBSD__) 753 /* BSD does not emit RTM_NEWADDR or RTM_CHGADDR when the 754 * hardware address changes so we have to go 755 * through the disovery process to work it out. */ 756 dhcpcd_handleinterface(ctx, 0, ifp->name); 757 #endif 758 if (ifp->wireless) { 759 uint8_t ossid[IF_SSIDLEN]; 760 size_t olen; 761 762 olen = ifp->ssid_len; 763 memcpy(ossid, ifp->ssid, ifp->ssid_len); 764 if_getssid(ifp); 765 766 /* If we changed SSID network, drop leases */ 767 if (ifp->ssid_len != olen || 768 memcmp(ifp->ssid, ossid, ifp->ssid_len)) 769 { 770 #ifdef NOCARRIER_PRESERVE_IP 771 dhcpcd_drop(ifp, 0); 772 #endif 773 #ifdef IPV4LL 774 ipv4ll_reset(ifp); 775 #endif 776 } 777 } 778 dhcpcd_initstate(ifp, 0); 779 script_runreason(ifp, "CARRIER"); 780 #ifdef INET6 781 #ifdef NOCARRIER_PRESERVE_IP 782 /* Set any IPv6 Routers we remembered to expire 783 * faster than they would normally as we 784 * maybe on a new network. */ 785 ipv6nd_startexpire(ifp); 786 #endif 787 /* RFC4941 Section 3.5 */ 788 ipv6_gentempifid(ifp); 789 #endif 790 dhcpcd_startinterface(ifp); 791 } 792 } 793 } 794 795 static void 796 warn_iaid_conflict(struct interface *ifp, uint16_t ia_type, uint8_t *iaid) 797 { 798 struct interface *ifn; 799 #ifdef INET6 800 size_t i; 801 struct if_ia *ia; 802 #endif 803 804 TAILQ_FOREACH(ifn, ifp->ctx->ifaces, next) { 805 if (ifn == ifp || !ifn->active) 806 continue; 807 if (ia_type == 0 && 808 memcmp(ifn->options->iaid, iaid, 809 sizeof(ifn->options->iaid)) == 0) 810 break; 811 #ifdef INET6 812 for (i = 0; i < ifn->options->ia_len; i++) { 813 ia = &ifn->options->ia[i]; 814 if (ia->ia_type == ia_type && 815 memcmp(ia->iaid, iaid, sizeof(ia->iaid)) == 0) 816 break; 817 } 818 #endif 819 } 820 821 /* This is only a problem if the interfaces are on the same network. */ 822 if (ifn) 823 logerrx("%s: IAID conflicts with one assigned to %s", 824 ifp->name, ifn->name); 825 } 826 827 void 828 dhcpcd_startinterface(void *arg) 829 { 830 struct interface *ifp = arg; 831 struct if_options *ifo = ifp->options; 832 char buf[DUID_LEN * 3]; 833 int carrier; 834 835 if (ifo->options & DHCPCD_LINK) { 836 switch (ifp->carrier) { 837 case LINK_UP: 838 break; 839 case LINK_DOWN: 840 loginfox("%s: waiting for carrier", ifp->name); 841 return; 842 case LINK_UNKNOWN: 843 /* No media state available. 844 * Loop until both IFF_UP and IFF_RUNNING are set */ 845 carrier = if_carrier(ifp); 846 if (carrier == LINK_UNKNOWN) { 847 if (IF_UPANDRUNNING(ifp)) 848 carrier = LINK_UP; 849 else { 850 struct timespec tv; 851 852 tv.tv_sec = 0; 853 tv.tv_nsec = IF_POLL_UP * NSEC_PER_MSEC; 854 eloop_timeout_add_tv(ifp->ctx->eloop, 855 &tv, dhcpcd_startinterface, ifp); 856 return; 857 } 858 } 859 dhcpcd_handlecarrier(ifp->ctx, carrier, 860 ifp->flags, ifp->name); 861 return; 862 } 863 } 864 865 if (ifo->options & (DHCPCD_DUID | DHCPCD_IPV6)) { 866 /* Report client DUID */ 867 if (ifp->ctx->duid == NULL) { 868 if (duid_init(ifp) == 0) 869 return; 870 loginfox("DUID %s", 871 hwaddr_ntoa(ifp->ctx->duid, 872 ifp->ctx->duid_len, 873 buf, sizeof(buf))); 874 } 875 } 876 877 if (ifo->options & (DHCPCD_DUID | DHCPCD_IPV6)) { 878 #ifdef INET6 879 size_t i; 880 struct if_ia *ia; 881 #endif 882 883 /* Report IAIDs */ 884 loginfox("%s: IAID %s", ifp->name, 885 hwaddr_ntoa(ifo->iaid, sizeof(ifo->iaid), 886 buf, sizeof(buf))); 887 warn_iaid_conflict(ifp, 0, ifo->iaid); 888 #ifdef INET6 889 for (i = 0; i < ifo->ia_len; i++) { 890 ia = &ifo->ia[i]; 891 if (memcmp(ifo->iaid, ia->iaid, sizeof(ifo->iaid))) { 892 loginfox("%s: IA type %u IAID %s", 893 ifp->name, ia->ia_type, 894 hwaddr_ntoa(ia->iaid, sizeof(ia->iaid), 895 buf, sizeof(buf))); 896 warn_iaid_conflict(ifp, ia->ia_type, ia->iaid); 897 } 898 } 899 #endif 900 } 901 902 #ifdef INET6 903 if (ifo->options & DHCPCD_IPV6 && ipv6_start(ifp) == -1) { 904 logerr("%s: ipv6_start", ifp->name); 905 ifo->options &= ~DHCPCD_IPV6; 906 } 907 908 if (ifo->options & DHCPCD_IPV6) { 909 if (ifp->active == IF_ACTIVE_USER) { 910 ipv6_startstatic(ifp); 911 912 if (ifo->options & DHCPCD_IPV6RS) 913 ipv6nd_startrs(ifp); 914 } 915 916 #ifdef DHCP6 917 if (ifo->options & DHCPCD_DHCP6) { 918 dhcp6_find_delegates(ifp); 919 920 if (ifp->active == IF_ACTIVE_USER) { 921 enum DH6S d6_state; 922 923 if (ifo->options & DHCPCD_IA_FORCED) 924 d6_state = DH6S_INIT; 925 else if (ifo->options & DHCPCD_INFORM6) 926 d6_state = DH6S_INFORM; 927 else 928 d6_state = DH6S_CONFIRM; 929 if (dhcp6_start(ifp, d6_state) == -1) 930 logerr("%s: dhcp6_start", ifp->name); 931 } 932 } 933 #endif 934 } 935 #endif 936 937 #ifdef INET 938 if (ifo->options & DHCPCD_IPV4 && ifp->active == IF_ACTIVE_USER) { 939 /* Ensure we have an IPv4 state before starting DHCP */ 940 if (ipv4_getstate(ifp) != NULL) 941 dhcp_start(ifp); 942 } 943 #endif 944 } 945 946 static void 947 dhcpcd_prestartinterface(void *arg) 948 { 949 struct interface *ifp = arg; 950 951 if ((!(ifp->ctx->options & DHCPCD_MASTER) || 952 ifp->options->options & DHCPCD_IF_UP) && 953 if_up(ifp) == -1) 954 logerr("%s: %s", __func__, ifp->name); 955 956 dhcpcd_startinterface(ifp); 957 } 958 959 static void 960 run_preinit(struct interface *ifp) 961 { 962 963 if (ifp->ctx->options & DHCPCD_TEST) 964 return; 965 966 script_runreason(ifp, "PREINIT"); 967 968 if (ifp->options->options & DHCPCD_LINK && ifp->carrier != LINK_UNKNOWN) 969 script_runreason(ifp, 970 ifp->carrier == LINK_UP ? "CARRIER" : "NOCARRIER"); 971 } 972 973 void 974 dhcpcd_activateinterface(struct interface *ifp, unsigned long long options) 975 { 976 977 if (!ifp->active) { 978 ifp->active = IF_ACTIVE; 979 dhcpcd_initstate2(ifp, options); 980 /* It's possible we might not have been able to load 981 * a config. */ 982 if (ifp->active) { 983 configure_interface1(ifp); 984 run_preinit(ifp); 985 dhcpcd_prestartinterface(ifp); 986 } 987 } 988 } 989 990 int 991 dhcpcd_handleinterface(void *arg, int action, const char *ifname) 992 { 993 struct dhcpcd_ctx *ctx; 994 struct ifaddrs *ifaddrs; 995 struct if_head *ifs; 996 struct interface *ifp, *iff; 997 const char * const argv[] = { ifname }; 998 int e; 999 1000 ctx = arg; 1001 if (action == -1) { 1002 ifp = if_find(ctx->ifaces, ifname); 1003 if (ifp == NULL) { 1004 errno = ESRCH; 1005 return -1; 1006 } 1007 if (ifp->active) { 1008 logdebugx("%s: interface departed", ifp->name); 1009 ifp->options->options |= DHCPCD_DEPARTED; 1010 stop_interface(ifp); 1011 } 1012 TAILQ_REMOVE(ctx->ifaces, ifp, next); 1013 if_free(ifp); 1014 return 0; 1015 } 1016 1017 ifs = if_discover(ctx, &ifaddrs, -1, UNCONST(argv)); 1018 if (ifs == NULL) { 1019 logerr(__func__); 1020 return -1; 1021 } 1022 1023 ifp = if_find(ifs, ifname); 1024 if (ifp == NULL) { 1025 /* This can happen if an interface is quickly added 1026 * and then removed. */ 1027 errno = ENOENT; 1028 e = -1; 1029 goto out; 1030 } 1031 e = 1; 1032 1033 /* Check if we already have the interface */ 1034 iff = if_find(ctx->ifaces, ifp->name); 1035 1036 if (iff != NULL) { 1037 if (iff->active) 1038 logdebugx("%s: interface updated", iff->name); 1039 /* The flags and hwaddr could have changed */ 1040 iff->flags = ifp->flags; 1041 iff->hwlen = ifp->hwlen; 1042 if (ifp->hwlen != 0) 1043 memcpy(iff->hwaddr, ifp->hwaddr, iff->hwlen); 1044 } else { 1045 TAILQ_REMOVE(ifs, ifp, next); 1046 TAILQ_INSERT_TAIL(ctx->ifaces, ifp, next); 1047 if (ifp->active) { 1048 logdebugx("%s: interface added", ifp->name); 1049 dhcpcd_initstate(ifp, 0); 1050 run_preinit(ifp); 1051 } 1052 iff = ifp; 1053 } 1054 1055 if (action > 0) { 1056 if_learnaddrs(ctx, ifs, &ifaddrs); 1057 if (iff->active) 1058 dhcpcd_prestartinterface(iff); 1059 } 1060 1061 out: 1062 /* Free our discovered list */ 1063 while ((ifp = TAILQ_FIRST(ifs))) { 1064 TAILQ_REMOVE(ifs, ifp, next); 1065 if_free(ifp); 1066 } 1067 free(ifs); 1068 1069 return e; 1070 } 1071 1072 static void 1073 dhcpcd_handlelink(void *arg) 1074 { 1075 struct dhcpcd_ctx *ctx = arg; 1076 1077 if (if_handlelink(ctx) == -1) { 1078 if (errno == ENOBUFS || errno == ENOMEM) { 1079 dhcpcd_linkoverflow(ctx); 1080 return; 1081 } 1082 if (errno != ENOTSUP) 1083 logerr(__func__); 1084 } 1085 } 1086 1087 static void 1088 dhcpcd_checkcarrier(void *arg) 1089 { 1090 struct interface *ifp = arg; 1091 1092 dhcpcd_handlecarrier(ifp->ctx, LINK_UNKNOWN, ifp->flags, ifp->name); 1093 } 1094 1095 #ifndef SMALL 1096 static void 1097 dhcpcd_setlinkrcvbuf(struct dhcpcd_ctx *ctx) 1098 { 1099 socklen_t socklen; 1100 1101 if (ctx->link_rcvbuf == 0) 1102 return; 1103 1104 socklen = sizeof(ctx->link_rcvbuf); 1105 if (setsockopt(ctx->link_fd, SOL_SOCKET, 1106 SO_RCVBUF, &ctx->link_rcvbuf, socklen) == -1) 1107 logerr(__func__); 1108 } 1109 #endif 1110 1111 void 1112 dhcpcd_linkoverflow(struct dhcpcd_ctx *ctx) 1113 { 1114 struct if_head *ifaces; 1115 struct ifaddrs *ifaddrs; 1116 struct interface *ifp, *ifn, *ifp1; 1117 1118 logerrx("route socket overflowed - learning interface state"); 1119 1120 /* Close the existing socket and open a new one. 1121 * This is easier than draining the kernel buffer of an 1122 * in-determinate size. */ 1123 eloop_event_delete(ctx->eloop, ctx->link_fd); 1124 close(ctx->link_fd); 1125 if_closesockets_os(ctx); 1126 if (if_opensockets_os(ctx) == -1) { 1127 logerr("%s: if_opensockets", __func__); 1128 eloop_exit(ctx->eloop, EXIT_FAILURE); 1129 return; 1130 } 1131 #ifndef SMALL 1132 dhcpcd_setlinkrcvbuf(ctx); 1133 #endif 1134 eloop_event_add(ctx->eloop, ctx->link_fd, dhcpcd_handlelink, ctx); 1135 1136 /* Work out the current interfaces. */ 1137 ifaces = if_discover(ctx, &ifaddrs, ctx->ifc, ctx->ifv); 1138 if (ifaces == NULL) { 1139 logerr(__func__); 1140 return; 1141 } 1142 1143 /* Punt departed interfaces */ 1144 TAILQ_FOREACH_SAFE(ifp, ctx->ifaces, next, ifn) { 1145 if (if_find(ifaces, ifp->name) != NULL) 1146 continue; 1147 dhcpcd_handleinterface(ctx, -1, ifp->name); 1148 } 1149 1150 /* Add new interfaces */ 1151 while ((ifp = TAILQ_FIRST(ifaces)) != NULL ) { 1152 TAILQ_REMOVE(ifaces, ifp, next); 1153 ifp1 = if_find(ctx->ifaces, ifp->name); 1154 if (ifp1 != NULL) { 1155 /* If the interface already exists, 1156 * check carrier state. */ 1157 eloop_timeout_add_sec(ctx->eloop, 0, 1158 dhcpcd_checkcarrier, ifp1); 1159 if_free(ifp); 1160 continue; 1161 } 1162 TAILQ_INSERT_TAIL(ctx->ifaces, ifp, next); 1163 if (ifp->active) 1164 eloop_timeout_add_sec(ctx->eloop, 0, 1165 dhcpcd_prestartinterface, ifp); 1166 } 1167 free(ifaces); 1168 1169 /* Update address state. */ 1170 if_markaddrsstale(ctx->ifaces); 1171 if_learnaddrs(ctx, ctx->ifaces, &ifaddrs); 1172 if_deletestaleaddrs(ctx->ifaces); 1173 } 1174 1175 void 1176 dhcpcd_handlehwaddr(struct dhcpcd_ctx *ctx, const char *ifname, 1177 const void *hwaddr, uint8_t hwlen) 1178 { 1179 struct interface *ifp; 1180 char buf[sizeof(ifp->hwaddr) * 3]; 1181 1182 ifp = if_find(ctx->ifaces, ifname); 1183 if (ifp == NULL) 1184 return; 1185 1186 if (!if_valid_hwaddr(hwaddr, hwlen)) 1187 hwlen = 0; 1188 1189 if (hwlen > sizeof(ifp->hwaddr)) { 1190 errno = ENOBUFS; 1191 logerr("%s: %s", __func__, ifp->name); 1192 return; 1193 } 1194 1195 if (ifp->hwlen == hwlen && memcmp(ifp->hwaddr, hwaddr, hwlen) == 0) 1196 return; 1197 1198 loginfox("%s: new hardware address: %s", ifp->name, 1199 hwaddr_ntoa(hwaddr, hwlen, buf, sizeof(buf))); 1200 ifp->hwlen = hwlen; 1201 memcpy(ifp->hwaddr, hwaddr, hwlen); 1202 } 1203 1204 static void 1205 if_reboot(struct interface *ifp, int argc, char **argv) 1206 { 1207 #ifdef INET 1208 unsigned long long oldopts; 1209 1210 oldopts = ifp->options->options; 1211 #endif 1212 script_runreason(ifp, "RECONFIGURE"); 1213 dhcpcd_initstate1(ifp, argc, argv, 0); 1214 #ifdef INET 1215 dhcp_reboot_newopts(ifp, oldopts); 1216 #endif 1217 #ifdef DHCP6 1218 dhcp6_reboot(ifp); 1219 #endif 1220 dhcpcd_prestartinterface(ifp); 1221 } 1222 1223 static void 1224 reload_config(struct dhcpcd_ctx *ctx) 1225 { 1226 struct if_options *ifo; 1227 1228 free_globals(ctx); 1229 if ((ifo = read_config(ctx, NULL, NULL, NULL)) == NULL) 1230 return; 1231 add_options(ctx, NULL, ifo, ctx->argc, ctx->argv); 1232 /* We need to preserve these two options. */ 1233 if (ctx->options & DHCPCD_MASTER) 1234 ifo->options |= DHCPCD_MASTER; 1235 if (ctx->options & DHCPCD_DAEMONISED) 1236 ifo->options |= DHCPCD_DAEMONISED; 1237 ctx->options = ifo->options; 1238 free_options(ctx, ifo); 1239 } 1240 1241 static void 1242 reconf_reboot(struct dhcpcd_ctx *ctx, int action, int argc, char **argv, int oi) 1243 { 1244 int i; 1245 struct interface *ifp; 1246 1247 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 1248 for (i = oi; i < argc; i++) { 1249 if (strcmp(ifp->name, argv[i]) == 0) 1250 break; 1251 } 1252 if (oi != argc && i == argc) 1253 continue; 1254 if (ifp->active == IF_ACTIVE_USER) { 1255 if (action) 1256 if_reboot(ifp, argc, argv); 1257 #ifdef INET 1258 else 1259 ipv4_applyaddr(ifp); 1260 #endif 1261 } else if (i != argc) { 1262 ifp->active = IF_ACTIVE_USER; 1263 dhcpcd_initstate1(ifp, argc, argv, 0); 1264 run_preinit(ifp); 1265 dhcpcd_prestartinterface(ifp); 1266 } 1267 } 1268 } 1269 1270 static void 1271 stop_all_interfaces(struct dhcpcd_ctx *ctx, unsigned long long opts) 1272 { 1273 struct interface *ifp; 1274 1275 ctx->options |= DHCPCD_EXITING; 1276 /* Drop the last interface first */ 1277 TAILQ_FOREACH_REVERSE(ifp, ctx->ifaces, if_head, next) { 1278 if (ifp->active) { 1279 ifp->options->options |= opts; 1280 if (ifp->options->options & DHCPCD_RELEASE) 1281 ifp->options->options &= ~DHCPCD_PERSISTENT; 1282 ifp->options->options |= DHCPCD_EXITING; 1283 stop_interface(ifp); 1284 } 1285 } 1286 } 1287 1288 static void 1289 dhcpcd_ifrenew(struct interface *ifp) 1290 { 1291 1292 if (!ifp->active) 1293 return; 1294 1295 if (ifp->options->options & DHCPCD_LINK && 1296 ifp->carrier == LINK_DOWN) 1297 return; 1298 1299 #ifdef INET 1300 dhcp_renew(ifp); 1301 #endif 1302 #ifdef INET6 1303 #define DHCPCD_RARENEW (DHCPCD_IPV6 | DHCPCD_IPV6RS) 1304 if ((ifp->options->options & DHCPCD_RARENEW) == DHCPCD_RARENEW) 1305 ipv6nd_startrs(ifp); 1306 #endif 1307 #ifdef DHCP6 1308 dhcp6_renew(ifp); 1309 #endif 1310 } 1311 1312 static void 1313 dhcpcd_renew(struct dhcpcd_ctx *ctx) 1314 { 1315 struct interface *ifp; 1316 1317 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 1318 dhcpcd_ifrenew(ifp); 1319 } 1320 } 1321 1322 #ifdef USE_SIGNALS 1323 #define sigmsg "received %s, %s" 1324 static void 1325 signal_cb(int sig, void *arg) 1326 { 1327 struct dhcpcd_ctx *ctx = arg; 1328 unsigned long long opts; 1329 int exit_code; 1330 1331 opts = 0; 1332 exit_code = EXIT_FAILURE; 1333 switch (sig) { 1334 case SIGINT: 1335 loginfox(sigmsg, "SIGINT", "stopping"); 1336 break; 1337 case SIGTERM: 1338 loginfox(sigmsg, "SIGTERM", "stopping"); 1339 exit_code = EXIT_SUCCESS; 1340 break; 1341 case SIGALRM: 1342 loginfox(sigmsg, "SIGALRM", "releasing"); 1343 opts |= DHCPCD_RELEASE; 1344 exit_code = EXIT_SUCCESS; 1345 break; 1346 case SIGHUP: 1347 loginfox(sigmsg, "SIGHUP", "rebinding"); 1348 reload_config(ctx); 1349 /* Preserve any options passed on the commandline 1350 * when we were started. */ 1351 reconf_reboot(ctx, 1, ctx->argc, ctx->argv, 1352 ctx->argc - ctx->ifc); 1353 return; 1354 case SIGUSR1: 1355 loginfox(sigmsg, "SIGUSR1", "renewing"); 1356 dhcpcd_renew(ctx); 1357 return; 1358 case SIGUSR2: 1359 loginfox(sigmsg, "SIGUSR2", "reopening log"); 1360 logclose(); 1361 if (logopen(ctx->logfile) == -1) 1362 logerr(__func__); 1363 return; 1364 case SIGPIPE: 1365 logwarnx("received SIGPIPE"); 1366 return; 1367 default: 1368 logerrx("received signal %d but don't know what to do with it", 1369 sig); 1370 return; 1371 } 1372 1373 if (!(ctx->options & DHCPCD_TEST)) 1374 stop_all_interfaces(ctx, opts); 1375 eloop_exit(ctx->eloop, exit_code); 1376 } 1377 #endif 1378 1379 static void 1380 dhcpcd_getinterfaces(void *arg) 1381 { 1382 struct fd_list *fd = arg; 1383 struct interface *ifp; 1384 size_t len; 1385 1386 len = 0; 1387 TAILQ_FOREACH(ifp, fd->ctx->ifaces, next) { 1388 if (!ifp->active) 1389 continue; 1390 len++; 1391 #ifdef INET 1392 if (D_STATE_RUNNING(ifp)) 1393 len++; 1394 #endif 1395 #ifdef IPV4LL 1396 if (IPV4LL_STATE_RUNNING(ifp)) 1397 len++; 1398 #endif 1399 #ifdef INET6 1400 if (IPV6_STATE_RUNNING(ifp)) 1401 len++; 1402 if (RS_STATE_RUNNING(ifp)) 1403 len++; 1404 #endif 1405 #ifdef DHCP6 1406 if (D6_STATE_RUNNING(ifp)) 1407 len++; 1408 #endif 1409 } 1410 if (write(fd->fd, &len, sizeof(len)) != sizeof(len)) 1411 return; 1412 eloop_event_remove_writecb(fd->ctx->eloop, fd->fd); 1413 TAILQ_FOREACH(ifp, fd->ctx->ifaces, next) { 1414 if (!ifp->active) 1415 continue; 1416 if (send_interface(fd, ifp) == -1) 1417 logerr(__func__); 1418 } 1419 } 1420 1421 int 1422 dhcpcd_handleargs(struct dhcpcd_ctx *ctx, struct fd_list *fd, 1423 int argc, char **argv) 1424 { 1425 struct interface *ifp; 1426 unsigned long long opts; 1427 int opt, oi, do_reboot, do_renew; 1428 size_t len, l; 1429 char *tmp, *p; 1430 1431 /* Special commands for our control socket 1432 * as the other end should be blocking until it gets the 1433 * expected reply we should be safely able just to change the 1434 * write callback on the fd */ 1435 if (strcmp(*argv, "--version") == 0) { 1436 return control_queue(fd, UNCONST(VERSION), 1437 strlen(VERSION) + 1, false); 1438 } else if (strcmp(*argv, "--getconfigfile") == 0) { 1439 return control_queue(fd, UNCONST(fd->ctx->cffile), 1440 strlen(fd->ctx->cffile) + 1, false); 1441 } else if (strcmp(*argv, "--getinterfaces") == 0) { 1442 eloop_event_add_w(fd->ctx->eloop, fd->fd, 1443 dhcpcd_getinterfaces, fd); 1444 return 0; 1445 } else if (strcmp(*argv, "--listen") == 0) { 1446 fd->flags |= FD_LISTEN; 1447 return 0; 1448 } 1449 1450 /* Only priviledged users can control dhcpcd via the socket. */ 1451 if (fd->flags & FD_UNPRIV) { 1452 errno = EPERM; 1453 return -1; 1454 } 1455 1456 /* Log the command */ 1457 len = 1; 1458 for (opt = 0; opt < argc; opt++) 1459 len += strlen(argv[opt]) + 1; 1460 tmp = malloc(len); 1461 if (tmp == NULL) 1462 return -1; 1463 p = tmp; 1464 for (opt = 0; opt < argc; opt++) { 1465 l = strlen(argv[opt]); 1466 strlcpy(p, argv[opt], len); 1467 len -= l + 1; 1468 p += l; 1469 *p++ = ' '; 1470 } 1471 *--p = '\0'; 1472 loginfox("control command: %s", tmp); 1473 free(tmp); 1474 1475 optind = 0; 1476 oi = 0; 1477 opts = 0; 1478 do_reboot = do_renew = 0; 1479 while ((opt = getopt_long(argc, argv, IF_OPTS, cf_options, &oi)) != -1) 1480 { 1481 switch (opt) { 1482 case 'g': 1483 /* Assumed if below not set */ 1484 break; 1485 case 'k': 1486 opts |= DHCPCD_RELEASE; 1487 break; 1488 case 'n': 1489 do_reboot = 1; 1490 break; 1491 case 'p': 1492 opts |= DHCPCD_PERSISTENT; 1493 break; 1494 case 'x': 1495 opts |= DHCPCD_EXITING; 1496 break; 1497 case 'N': 1498 do_renew = 1; 1499 break; 1500 } 1501 } 1502 1503 if (opts & (DHCPCD_EXITING | DHCPCD_RELEASE)) { 1504 if (optind == argc) { 1505 stop_all_interfaces(ctx, opts); 1506 eloop_exit(ctx->eloop, EXIT_SUCCESS); 1507 return 0; 1508 } 1509 for (oi = optind; oi < argc; oi++) { 1510 if ((ifp = if_find(ctx->ifaces, argv[oi])) == NULL) 1511 continue; 1512 if (!ifp->active) 1513 continue; 1514 ifp->options->options |= opts; 1515 if (opts & DHCPCD_RELEASE) 1516 ifp->options->options &= ~DHCPCD_PERSISTENT; 1517 stop_interface(ifp); 1518 } 1519 return 0; 1520 } 1521 1522 if (do_renew) { 1523 if (optind == argc) { 1524 dhcpcd_renew(ctx); 1525 return 0; 1526 } 1527 for (oi = optind; oi < argc; oi++) { 1528 if ((ifp = if_find(ctx->ifaces, argv[oi])) == NULL) 1529 continue; 1530 dhcpcd_ifrenew(ifp); 1531 } 1532 return 0; 1533 } 1534 1535 reload_config(ctx); 1536 /* XXX: Respect initial commandline options? */ 1537 reconf_reboot(ctx, do_reboot, argc, argv, optind - 1); 1538 return 0; 1539 } 1540 1541 int 1542 main(int argc, char **argv) 1543 { 1544 struct dhcpcd_ctx ctx; 1545 struct ifaddrs *ifaddrs = NULL; 1546 struct if_options *ifo; 1547 struct interface *ifp; 1548 uint16_t family = 0; 1549 int opt, oi = 0, i; 1550 unsigned int logopts; 1551 time_t t; 1552 ssize_t len; 1553 #if defined(USE_SIGNALS) || !defined(THERE_IS_NO_FORK) 1554 pid_t pid; 1555 #endif 1556 #ifdef USE_SIGNALS 1557 int sig = 0; 1558 const char *siga = NULL; 1559 #endif 1560 1561 /* Test for --help and --version */ 1562 if (argc > 1) { 1563 if (strcmp(argv[1], "--help") == 0) { 1564 usage(); 1565 return EXIT_SUCCESS; 1566 } else if (strcmp(argv[1], "--version") == 0) { 1567 printf(""PACKAGE" "VERSION"\n%s\n", dhcpcd_copyright); 1568 printf("Compiled in features:" 1569 #ifdef INET 1570 " INET" 1571 #endif 1572 #ifdef ARP 1573 " ARP" 1574 #endif 1575 #ifdef ARPING 1576 " ARPing" 1577 #endif 1578 #ifdef IPV4LL 1579 " IPv4LL" 1580 #endif 1581 #ifdef INET6 1582 " INET6" 1583 #endif 1584 #ifdef DHCP6 1585 " DHCPv6" 1586 #endif 1587 #ifdef AUTH 1588 " AUTH" 1589 #endif 1590 "\n"); 1591 return EXIT_SUCCESS; 1592 } 1593 } 1594 1595 memset(&ctx, 0, sizeof(ctx)); 1596 1597 ifo = NULL; 1598 ctx.cffile = CONFIG; 1599 ctx.control_fd = ctx.control_unpriv_fd = ctx.link_fd = -1; 1600 ctx.pf_inet_fd = -1; 1601 1602 TAILQ_INIT(&ctx.control_fds); 1603 #ifdef PLUGIN_DEV 1604 ctx.dev_fd = -1; 1605 #endif 1606 #ifdef INET 1607 ctx.udp_fd = -1; 1608 #endif 1609 rt_init(&ctx); 1610 1611 logopts = LOGERR_ERR|LOGERR_LOG|LOGERR_LOG_DATE|LOGERR_LOG_PID; 1612 i = 0; 1613 while ((opt = getopt_long(argc, argv, 1614 ctx.options & DHCPCD_PRINT_PIDFILE ? NOERR_IF_OPTS : IF_OPTS, 1615 cf_options, &oi)) != -1) 1616 { 1617 switch (opt) { 1618 case '4': 1619 family = AF_INET; 1620 break; 1621 case '6': 1622 family = AF_INET6; 1623 break; 1624 case 'f': 1625 ctx.cffile = optarg; 1626 break; 1627 case 'j': 1628 free(ctx.logfile); 1629 ctx.logfile = strdup(optarg); 1630 break; 1631 #ifdef USE_SIGNALS 1632 case 'k': 1633 sig = SIGALRM; 1634 siga = "ALRM"; 1635 break; 1636 case 'n': 1637 sig = SIGHUP; 1638 siga = "HUP"; 1639 break; 1640 case 'g': 1641 case 'p': 1642 /* Force going via command socket as we're 1643 * out of user definable signals. */ 1644 i = 4; 1645 break; 1646 case 'q': 1647 logopts |= LOGERR_QUIET; 1648 break; 1649 case 'x': 1650 sig = SIGTERM; 1651 siga = "TERM"; 1652 break; 1653 case 'N': 1654 sig = SIGUSR1; 1655 siga = "USR1"; 1656 break; 1657 #endif 1658 case 'P': 1659 ctx.options |= DHCPCD_PRINT_PIDFILE; 1660 logopts &= ~(LOGERR_LOG | LOGERR_ERR); 1661 break; 1662 case 'T': 1663 i = 1; 1664 logopts &= ~LOGERR_LOG; 1665 break; 1666 case 'U': 1667 i = 3; 1668 break; 1669 case 'V': 1670 i = 2; 1671 break; 1672 case '?': 1673 if (ctx.options & DHCPCD_PRINT_PIDFILE) 1674 continue; 1675 usage(); 1676 goto exit_failure; 1677 } 1678 } 1679 1680 logsetopts(logopts); 1681 logopen(ctx.logfile); 1682 1683 ctx.argv = argv; 1684 ctx.argc = argc; 1685 ctx.ifc = argc - optind; 1686 ctx.ifv = argv + optind; 1687 1688 ifo = read_config(&ctx, NULL, NULL, NULL); 1689 if (ifo == NULL) { 1690 if (ctx.options & DHCPCD_PRINT_PIDFILE) 1691 goto printpidfile; 1692 goto exit_failure; 1693 } 1694 opt = add_options(&ctx, NULL, ifo, argc, argv); 1695 if (opt != 1) { 1696 if (ctx.options & DHCPCD_PRINT_PIDFILE) 1697 goto printpidfile; 1698 if (opt == 0) 1699 usage(); 1700 goto exit_failure; 1701 } 1702 if (i == 2) { 1703 printf("Interface options:\n"); 1704 if (optind == argc - 1) { 1705 free_options(&ctx, ifo); 1706 ifo = read_config(&ctx, argv[optind], NULL, NULL); 1707 if (ifo == NULL) 1708 goto exit_failure; 1709 add_options(&ctx, NULL, ifo, argc, argv); 1710 } 1711 if_printoptions(); 1712 #ifdef INET 1713 if (family == 0 || family == AF_INET) { 1714 printf("\nDHCPv4 options:\n"); 1715 dhcp_printoptions(&ctx, 1716 ifo->dhcp_override, ifo->dhcp_override_len); 1717 } 1718 #endif 1719 #ifdef INET6 1720 if (family == 0 || family == AF_INET6) { 1721 printf("\nND options:\n"); 1722 ipv6nd_printoptions(&ctx, 1723 ifo->nd_override, ifo->nd_override_len); 1724 #ifdef DHCP6 1725 printf("\nDHCPv6 options:\n"); 1726 dhcp6_printoptions(&ctx, 1727 ifo->dhcp6_override, ifo->dhcp6_override_len); 1728 #endif 1729 } 1730 #endif 1731 goto exit_success; 1732 } 1733 ctx.options |= ifo->options; 1734 if (i == 1 || i == 3) { 1735 if (i == 1) 1736 ctx.options |= DHCPCD_TEST; 1737 else 1738 ctx.options |= DHCPCD_DUMPLEASE; 1739 ctx.options |= DHCPCD_PERSISTENT; 1740 ctx.options &= ~DHCPCD_DAEMONISE; 1741 } 1742 1743 #ifdef THERE_IS_NO_FORK 1744 ctx.options &= ~DHCPCD_DAEMONISE; 1745 #endif 1746 1747 if (ctx.options & DHCPCD_DEBUG) 1748 logsetopts(logopts | LOGERR_DEBUG); 1749 1750 if (!(ctx.options & (DHCPCD_TEST | DHCPCD_DUMPLEASE))) { 1751 printpidfile: 1752 /* If we have any other args, we should run as a single dhcpcd 1753 * instance for that interface. */ 1754 if (optind == argc - 1 && !(ctx.options & DHCPCD_MASTER)) { 1755 const char *per; 1756 const char *ifname; 1757 1758 ifname = *ctx.ifv; 1759 if (ifname == NULL || strlen(ifname) > IF_NAMESIZE) { 1760 errno = ifname == NULL ? EINVAL : E2BIG; 1761 logerr("%s: ", ifname); 1762 goto exit_failure; 1763 } 1764 /* Allow a dhcpcd interface per address family */ 1765 switch(family) { 1766 case AF_INET: 1767 per = "-4"; 1768 break; 1769 case AF_INET6: 1770 per = "-6"; 1771 break; 1772 default: 1773 per = ""; 1774 } 1775 snprintf(ctx.pidfile, sizeof(ctx.pidfile), 1776 PIDFILE, "-", ifname, per); 1777 } else { 1778 snprintf(ctx.pidfile, sizeof(ctx.pidfile), 1779 PIDFILE, "", "", ""); 1780 ctx.options |= DHCPCD_MASTER; 1781 } 1782 if (ctx.options & DHCPCD_PRINT_PIDFILE) { 1783 printf("%s\n", ctx.pidfile); 1784 goto exit_success; 1785 } 1786 } 1787 1788 if (chdir("/") == -1) 1789 logerr("%s: chdir `/'", __func__); 1790 1791 /* Freeing allocated addresses from dumping leases can trigger 1792 * eloop removals as well, so init here. */ 1793 if ((ctx.eloop = eloop_new()) == NULL) { 1794 logerr("%s: eloop_init", __func__); 1795 goto exit_failure; 1796 } 1797 #ifdef USE_SIGNALS 1798 /* Save signal mask, block and redirect signals to our handler */ 1799 if (eloop_signal_set_cb(ctx.eloop, 1800 dhcpcd_signals, dhcpcd_signals_len, 1801 signal_cb, &ctx) == -1) 1802 { 1803 logerr("%s: eloop_signal_set_cb", __func__); 1804 goto exit_failure; 1805 } 1806 if (eloop_signal_mask(ctx.eloop, &ctx.sigset) == -1) { 1807 logerr("%s: eloop_signal_mask", __func__); 1808 goto exit_failure; 1809 } 1810 #endif 1811 1812 if (ctx.options & DHCPCD_DUMPLEASE) { 1813 /* Open sockets so we can dump something about 1814 * valid interfaces. */ 1815 if (if_opensockets(&ctx) == -1) { 1816 logerr("%s: if_opensockets", __func__); 1817 goto exit_failure; 1818 } 1819 if (optind != argc) { 1820 /* We need to try and find the interface so we can load 1821 * the hardware address to compare automated IAID */ 1822 ctx.ifaces = if_discover(&ctx, &ifaddrs, 1823 argc - optind, argv + optind); 1824 } else { 1825 if ((ctx.ifaces = malloc(sizeof(*ctx.ifaces))) != NULL) 1826 TAILQ_INIT(ctx.ifaces); 1827 } 1828 if (ctx.ifaces == NULL) { 1829 logerr("%s: if_discover", __func__); 1830 goto exit_failure; 1831 } 1832 ifp = if_find(ctx.ifaces, argv[optind]); 1833 if (ifp == NULL) { 1834 ifp = calloc(1, sizeof(*ifp)); 1835 if (ifp == NULL) { 1836 logerr(__func__); 1837 goto exit_failure; 1838 } 1839 if (optind != argc) 1840 strlcpy(ctx.pidfile, argv[optind], 1841 sizeof(ctx.pidfile)); 1842 ifp->ctx = &ctx; 1843 TAILQ_INSERT_HEAD(ctx.ifaces, ifp, next); 1844 if (family == 0) { 1845 if (ctx.pidfile[0] != '\0' && 1846 ctx.pidfile[strlen(ctx.pidfile) - 1] == '6') 1847 family = AF_INET6; 1848 else 1849 family = AF_INET; 1850 } 1851 } 1852 configure_interface(ifp, ctx.argc, ctx.argv, 0); 1853 i = 0; 1854 if (family == 0 || family == AF_INET) { 1855 #ifdef INET 1856 if (dhcp_dump(ifp) == -1) 1857 i = -1; 1858 #else 1859 if (family == AF_INET) 1860 logerrx("No INET support"); 1861 #endif 1862 } 1863 if (family == 0 || family == AF_INET6) { 1864 #ifdef DHCP6 1865 if (dhcp6_dump(ifp) == -1) 1866 i = -1; 1867 #else 1868 if (family == AF_INET6) 1869 logerrx("No DHCP6 support"); 1870 #endif 1871 } 1872 if (i == -1) 1873 goto exit_failure; 1874 goto exit_success; 1875 } 1876 1877 #ifdef USE_SIGNALS 1878 /* Test against siga instead of sig to avoid gcc 1879 * warning about a bogus potential signed overflow. 1880 * The end result will be the same. */ 1881 if ((siga == NULL || i == 4 || ctx.ifc != 0) && 1882 !(ctx.options & DHCPCD_TEST)) 1883 { 1884 #endif 1885 if (!(ctx.options & DHCPCD_MASTER)) 1886 ctx.control_fd = control_open(argv[optind]); 1887 if (ctx.control_fd == -1) 1888 ctx.control_fd = control_open(NULL); 1889 if (ctx.control_fd != -1) { 1890 loginfox("sending commands to master dhcpcd process"); 1891 len = control_send(&ctx, argc, argv); 1892 control_close(&ctx); 1893 if (len > 0) { 1894 logdebugx("send OK"); 1895 goto exit_success; 1896 } else { 1897 logerr("%s: control_send", __func__); 1898 goto exit_failure; 1899 } 1900 } else { 1901 if (errno != ENOENT) 1902 logerr("%s: control_open", __func__); 1903 } 1904 #ifdef USE_SIGNALS 1905 } 1906 #endif 1907 1908 #ifdef USE_SIGNALS 1909 if (sig != 0) { 1910 pid = pidfile_read(ctx.pidfile); 1911 if (pid != 0 && pid != -1) 1912 loginfox("sending signal %s to pid %d", siga, pid); 1913 if (pid == 0 || pid == -1 || kill(pid, sig) != 0) { 1914 if (sig != SIGHUP && sig != SIGUSR1 && errno != EPERM) 1915 logerrx(PACKAGE" not running"); 1916 if (pid != 0 && pid != -1 && errno != ESRCH) { 1917 logerr("kill"); 1918 goto exit_failure; 1919 } 1920 unlink(ctx.pidfile); 1921 if (sig != SIGHUP && sig != SIGUSR1) 1922 goto exit_failure; 1923 } else { 1924 struct timespec ts; 1925 1926 if (sig == SIGHUP || sig == SIGUSR1) 1927 goto exit_success; 1928 /* Spin until it exits */ 1929 loginfox("waiting for pid %d to exit", pid); 1930 ts.tv_sec = 0; 1931 ts.tv_nsec = 100000000; /* 10th of a second */ 1932 for(i = 0; i < 100; i++) { 1933 nanosleep(&ts, NULL); 1934 if (pidfile_read(ctx.pidfile) == -1) 1935 goto exit_success; 1936 } 1937 logerrx("pid %d failed to exit", pid); 1938 goto exit_failure; 1939 } 1940 } 1941 1942 if (!(ctx.options & DHCPCD_TEST)) { 1943 /* Ensure we have the needed directories */ 1944 if (mkdir(RUNDIR, 0755) == -1 && errno != EEXIST) 1945 logerr("%s: mkdir `%s'", __func__, RUNDIR); 1946 if (mkdir(DBDIR, 0755) == -1 && errno != EEXIST) 1947 logerr("%s: mkdir `%s'", __func__, DBDIR); 1948 1949 if ((pid = pidfile_lock(ctx.pidfile)) != 0) { 1950 if (pid == -1) 1951 logerr("%s: pidfile_lock", __func__); 1952 else 1953 logerrx(PACKAGE 1954 " already running on pid %d (%s)", 1955 pid, ctx.pidfile); 1956 goto exit_failure; 1957 } 1958 } 1959 1960 if (ctx.options & DHCPCD_MASTER) { 1961 if (control_start(&ctx, NULL) == -1) 1962 logerr("%s: control_start", __func__); 1963 } 1964 #else 1965 if (control_start(&ctx, 1966 ctx.options & DHCPCD_MASTER ? NULL : argv[optind]) == -1) 1967 { 1968 logerr("%s: control_start", __func__); 1969 goto exit_failure; 1970 } 1971 #endif 1972 1973 logdebugx(PACKAGE "-" VERSION " starting"); 1974 ctx.options |= DHCPCD_STARTED; 1975 1976 #ifdef HAVE_SETPROCTITLE 1977 setproctitle("%s%s%s", 1978 ctx.options & DHCPCD_MASTER ? "[master]" : argv[optind], 1979 ctx.options & DHCPCD_IPV4 ? " [ip4]" : "", 1980 ctx.options & DHCPCD_IPV6 ? " [ip6]" : ""); 1981 #endif 1982 1983 if (if_opensockets(&ctx) == -1) { 1984 logerr("%s: if_opensockets", __func__); 1985 goto exit_failure; 1986 } 1987 #ifndef SMALL 1988 dhcpcd_setlinkrcvbuf(&ctx); 1989 #endif 1990 1991 /* When running dhcpcd against a single interface, we need to retain 1992 * the old behaviour of waiting for an IP address */ 1993 if (ctx.ifc == 1 && !(ctx.options & DHCPCD_BACKGROUND)) 1994 ctx.options |= DHCPCD_WAITIP; 1995 1996 /* Start handling kernel messages for interfaces, addresses and 1997 * routes. */ 1998 eloop_event_add(ctx.eloop, ctx.link_fd, dhcpcd_handlelink, &ctx); 1999 2000 /* Start any dev listening plugin which may want to 2001 * change the interface name provided by the kernel */ 2002 if ((ctx.options & (DHCPCD_MASTER | DHCPCD_DEV)) == 2003 (DHCPCD_MASTER | DHCPCD_DEV)) 2004 dev_start(&ctx); 2005 2006 ctx.ifaces = if_discover(&ctx, &ifaddrs, ctx.ifc, ctx.ifv); 2007 if (ctx.ifaces == NULL) { 2008 logerr("%s: if_discover", __func__); 2009 goto exit_failure; 2010 } 2011 for (i = 0; i < ctx.ifc; i++) { 2012 if ((ifp = if_find(ctx.ifaces, ctx.ifv[i])) == NULL || 2013 !ifp->active) 2014 logerrx("%s: interface not found or invalid", 2015 ctx.ifv[i]); 2016 } 2017 TAILQ_FOREACH(ifp, ctx.ifaces, next) { 2018 if (ifp->active == IF_ACTIVE_USER) 2019 break; 2020 } 2021 if (ifp == NULL) { 2022 if (ctx.ifc == 0) { 2023 logfunc_t *logfunc; 2024 2025 logfunc = ctx.options & DHCPCD_INACTIVE ? 2026 logdebugx : logerrx; 2027 logfunc("no valid interfaces found"); 2028 } else 2029 goto exit_failure; 2030 if (!(ctx.options & DHCPCD_LINK)) { 2031 logerrx("aborting as link detection is disabled"); 2032 goto exit_failure; 2033 } 2034 } 2035 2036 TAILQ_FOREACH(ifp, ctx.ifaces, next) { 2037 if (ifp->active) 2038 dhcpcd_initstate1(ifp, argc, argv, 0); 2039 } 2040 if_learnaddrs(&ctx, ctx.ifaces, &ifaddrs); 2041 2042 if (ctx.options & DHCPCD_BACKGROUND && dhcpcd_daemonise(&ctx)) 2043 goto exit_success; 2044 2045 opt = 0; 2046 TAILQ_FOREACH(ifp, ctx.ifaces, next) { 2047 if (ifp->active) { 2048 run_preinit(ifp); 2049 if (!(ifp->options->options & DHCPCD_LINK) || 2050 ifp->carrier != LINK_DOWN) 2051 opt = 1; 2052 } 2053 } 2054 2055 if (!(ctx.options & DHCPCD_BACKGROUND)) { 2056 if (ctx.options & DHCPCD_MASTER) 2057 t = ifo->timeout; 2058 else { 2059 t = 0; 2060 TAILQ_FOREACH(ifp, ctx.ifaces, next) { 2061 if (ifp->active) { 2062 t = ifp->options->timeout; 2063 break; 2064 } 2065 } 2066 } 2067 if (opt == 0 && 2068 ctx.options & DHCPCD_LINK && 2069 !(ctx.options & DHCPCD_WAITIP)) 2070 { 2071 logfunc_t *logfunc; 2072 2073 logfunc = ctx.options & DHCPCD_INACTIVE ? 2074 logdebugx : logwarnx; 2075 logfunc("no interfaces have a carrier"); 2076 if (dhcpcd_daemonise(&ctx)) 2077 goto exit_success; 2078 } else if (t > 0 && 2079 /* Test mode removes the daemonise bit, so check for both */ 2080 ctx.options & (DHCPCD_DAEMONISE | DHCPCD_TEST)) 2081 { 2082 eloop_timeout_add_sec(ctx.eloop, t, 2083 handle_exit_timeout, &ctx); 2084 } 2085 } 2086 free_options(&ctx, ifo); 2087 ifo = NULL; 2088 2089 TAILQ_FOREACH(ifp, ctx.ifaces, next) { 2090 if (ifp->active) 2091 eloop_timeout_add_sec(ctx.eloop, 0, 2092 dhcpcd_prestartinterface, ifp); 2093 } 2094 2095 i = eloop_start(ctx.eloop, &ctx.sigset); 2096 if (i < 0) { 2097 logerr("%s: eloop_start", __func__); 2098 goto exit_failure; 2099 } 2100 goto exit1; 2101 2102 exit_success: 2103 i = EXIT_SUCCESS; 2104 goto exit1; 2105 2106 exit_failure: 2107 i = EXIT_FAILURE; 2108 2109 exit1: 2110 if (ifaddrs != NULL) 2111 freeifaddrs(ifaddrs); 2112 if (control_stop(&ctx) == -1) 2113 logerr("%s: control_stop", __func__); 2114 /* Free memory and close fd's */ 2115 if (ctx.ifaces) { 2116 while ((ifp = TAILQ_FIRST(ctx.ifaces))) { 2117 TAILQ_REMOVE(ctx.ifaces, ifp, next); 2118 if_free(ifp); 2119 } 2120 free(ctx.ifaces); 2121 } 2122 free_options(&ctx, ifo); 2123 #ifdef HAVE_OPEN_MEMSTREAM 2124 if (ctx.script_fp) 2125 fclose(ctx.script_fp); 2126 #endif 2127 free(ctx.script_buf); 2128 free(ctx.script_env); 2129 rt_dispose(&ctx); 2130 free(ctx.duid); 2131 if (ctx.link_fd != -1) { 2132 eloop_event_delete(ctx.eloop, ctx.link_fd); 2133 close(ctx.link_fd); 2134 } 2135 if_closesockets(&ctx); 2136 free_globals(&ctx); 2137 #ifdef INET6 2138 ipv6_ctxfree(&ctx); 2139 #endif 2140 dev_stop(&ctx); 2141 eloop_free(ctx.eloop); 2142 2143 if (ctx.options & DHCPCD_STARTED && !(ctx.options & DHCPCD_FORKED)) 2144 loginfox(PACKAGE " exited"); 2145 logclose(); 2146 free(ctx.logfile); 2147 #ifdef USE_SIGNALS 2148 if (ctx.options & DHCPCD_FORKED) 2149 _exit(i); /* so atexit won't remove our pidfile */ 2150 #endif 2151 return i; 2152 } 2153