1/* 2 * dhcpcd - DHCP client daemon 3 * Copyright (c) 2006-2015 Roy Marples <roy@marples.name> 4 * All rights reserved 5 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28const char dhcpcd_copyright[] = "Copyright (c) 2006-2015 Roy Marples"; 29 30#define _WITH_DPRINTF /* Stop FreeBSD bitching */ 31 32#include <sys/file.h> 33#include <sys/socket.h> 34#include <sys/stat.h> 35#include <sys/time.h> 36#include <sys/types.h> 37#include <sys/uio.h> 38 39#include <ctype.h> 40#include <errno.h> 41#include <fcntl.h> 42#include <getopt.h> 43#include <limits.h> 44#include <paths.h> 45#include <signal.h> 46#include <stdio.h> 47#include <stdlib.h> 48#include <string.h> 49#include <unistd.h> 50#include <time.h> 51 52#if defined(__ANDROID__) 53#include <sys/capability.h> 54#include <sys/prctl.h> 55#include <private/android_filesystem_config.h> 56#endif /* __ANDROID__ */ 57 58#include "config.h" 59#include "arp.h" 60#include "common.h" 61#include "control.h" 62#include "dev.h" 63#include "dhcpcd.h" 64#include "dhcp6.h" 65#include "duid.h" 66#include "eloop.h" 67#include "if.h" 68#include "if-options.h" 69#include "ipv4.h" 70#include "ipv6.h" 71#include "ipv6nd.h" 72#include "rpc-interface.h" 73#include "script.h" 74 75#ifdef USE_SIGNALS 76const int dhcpcd_handlesigs[] = { 77 SIGTERM, 78 SIGINT, 79 SIGALRM, 80 SIGHUP, 81 SIGUSR1, 82 SIGUSR2, 83 SIGPIPE, 84 0 85}; 86 87/* Handling signals needs *some* context */ 88static struct dhcpcd_ctx *dhcpcd_ctx; 89#endif 90 91#if defined(USE_SIGNALS) || !defined(THERE_IS_NO_FORK) 92static pid_t 93read_pid(const char *pidfile) 94{ 95 FILE *fp; 96 pid_t pid; 97 98 if ((fp = fopen(pidfile, "r")) == NULL) { 99 errno = ENOENT; 100 return 0; 101 } 102 if (fscanf(fp, "%d", &pid) != 1) 103 pid = 0; 104 fclose(fp); 105 return pid; 106} 107 108static int 109write_pid(int fd, pid_t pid) 110{ 111 112 if (ftruncate(fd, (off_t)0) == -1) 113 return -1; 114 lseek(fd, (off_t)0, SEEK_SET); 115 return dprintf(fd, "%d\n", (int)pid); 116} 117#endif 118 119static void 120usage(void) 121{ 122 123printf("usage: "PACKAGE"\t[-46ABbDdEGgHJKkLnpqTVw]\n" 124 "\t\t[-C, --nohook hook] [-c, --script script]\n" 125 "\t\t[-e, --env value] [-F, --fqdn FQDN] [-f, --config file]\n" 126 "\t\t[-h, --hostname hostname] [-I, --clientid clientid]\n" 127 "\t\t[-i, --vendorclassid vendorclassid] [-l, --leasetime seconds]\n" 128 "\t\t[-m, --metric metric] [-O, --nooption option]\n" 129 "\t\t[-o, --option option] [-Q, --require option]\n" 130 "\t\t[-r, --request address] [-S, --static value]\n" 131 "\t\t[-s, --inform address[/cidr]] [-t, --timeout seconds]\n" 132 "\t\t[-u, --userclass class] [-v, --vendor code, value]\n" 133 "\t\t[-W, --whitelist address[/cidr]] [-y, --reboot seconds]\n" 134 "\t\t[-X, --blacklist address[/cidr]] [-Z, --denyinterfaces pattern]\n" 135 "\t\t[-z, --allowinterfaces pattern] [interface] [...]\n" 136 " "PACKAGE"\t-k, --release [interface]\n" 137 " "PACKAGE"\t-U, --dumplease interface\n" 138 " "PACKAGE"\t--version\n" 139 " "PACKAGE"\t-x, --exit [interface]\n"); 140} 141 142static void 143free_globals(struct dhcpcd_ctx *ctx) 144{ 145 struct dhcp_opt *opt; 146 147 if (ctx->ifac) { 148 for (; ctx->ifac > 0; ctx->ifac--) 149 free(ctx->ifav[ctx->ifac - 1]); 150 free(ctx->ifav); 151 ctx->ifav = NULL; 152 } 153 if (ctx->ifdc) { 154 for (; ctx->ifdc > 0; ctx->ifdc--) 155 free(ctx->ifdv[ctx->ifdc - 1]); 156 free(ctx->ifdv); 157 ctx->ifdv = NULL; 158 } 159 if (ctx->ifcc) { 160 for (; ctx->ifcc > 0; ctx->ifcc--) 161 free(ctx->ifcv[ctx->ifcc - 1]); 162 free(ctx->ifcv); 163 ctx->ifcv = NULL; 164 } 165 166#ifdef INET 167 if (ctx->dhcp_opts) { 168 for (opt = ctx->dhcp_opts; 169 ctx->dhcp_opts_len > 0; 170 opt++, ctx->dhcp_opts_len--) 171 free_dhcp_opt_embenc(opt); 172 free(ctx->dhcp_opts); 173 ctx->dhcp_opts = NULL; 174 } 175#endif 176#ifdef INET6 177 if (ctx->dhcp6_opts) { 178 for (opt = ctx->dhcp6_opts; 179 ctx->dhcp6_opts_len > 0; 180 opt++, ctx->dhcp6_opts_len--) 181 free_dhcp_opt_embenc(opt); 182 free(ctx->dhcp6_opts); 183 ctx->dhcp6_opts = NULL; 184 } 185#endif 186 if (ctx->vivso) { 187 for (opt = ctx->vivso; 188 ctx->vivso_len > 0; 189 opt++, ctx->vivso_len--) 190 free_dhcp_opt_embenc(opt); 191 free(ctx->vivso); 192 ctx->vivso = NULL; 193 } 194} 195 196static void 197handle_exit_timeout(void *arg) 198{ 199 struct dhcpcd_ctx *ctx; 200 201 ctx = arg; 202 logger(ctx, LOG_ERR, "timed out"); 203 if (!(ctx->options & DHCPCD_MASTER)) { 204 eloop_exit(ctx->eloop, EXIT_FAILURE); 205 return; 206 } 207 ctx->options |= DHCPCD_NOWAITIP; 208 dhcpcd_daemonise(ctx); 209} 210 211int 212dhcpcd_oneup(struct dhcpcd_ctx *ctx) 213{ 214 const struct interface *ifp; 215 216 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 217 if (D_STATE_RUNNING(ifp) || 218 RS_STATE_RUNNING(ifp) || 219 D6_STATE_RUNNING(ifp)) 220 return 1; 221 } 222 return 0; 223} 224 225int 226dhcpcd_ipwaited(struct dhcpcd_ctx *ctx) 227{ 228 229 if (ctx->options & DHCPCD_WAITIP4 && 230 !ipv4_addrexists(ctx, NULL)) 231 return 0; 232 if (ctx->options & DHCPCD_WAITIP6 && 233 !ipv6nd_findaddr(ctx, NULL, 0) && 234 !dhcp6_findaddr(ctx, NULL, 0)) 235 return 0; 236 if (ctx->options & DHCPCD_WAITIP && 237 !(ctx->options & (DHCPCD_WAITIP4 | DHCPCD_WAITIP6)) && 238 !ipv4_addrexists(ctx, NULL) && 239 !ipv6nd_findaddr(ctx, NULL, 0) && 240 !dhcp6_findaddr(ctx, NULL, 0)) 241 return 0; 242 return 1; 243} 244 245/* Returns the pid of the child, otherwise 0. */ 246pid_t 247dhcpcd_daemonise(struct dhcpcd_ctx *ctx) 248{ 249#ifdef THERE_IS_NO_FORK 250 eloop_timeout_delete(ctx->eloop, handle_exit_timeout, ctx); 251 errno = ENOSYS; 252 return 0; 253#else 254 pid_t pid; 255 char buf = '\0'; 256 int sidpipe[2], fd; 257 258 if (ctx->options & DHCPCD_DAEMONISE && 259 !(ctx->options & (DHCPCD_DAEMONISED | DHCPCD_NOWAITIP))) 260 { 261 if (!dhcpcd_ipwaited(ctx)) 262 return 0; 263 } 264 265 eloop_timeout_delete(ctx->eloop, handle_exit_timeout, ctx); 266 if (ctx->options & DHCPCD_DAEMONISED || 267 !(ctx->options & DHCPCD_DAEMONISE)) 268 return 0; 269 /* Setup a signal pipe so parent knows when to exit. */ 270 if (pipe(sidpipe) == -1) { 271 logger(ctx, LOG_ERR, "pipe: %m"); 272 return 0; 273 } 274 logger(ctx, LOG_DEBUG, "forking to background"); 275 switch (pid = fork()) { 276 case -1: 277 logger(ctx, LOG_ERR, "fork: %m"); 278 return 0; 279 case 0: 280 setsid(); 281 /* Some polling methods don't survive after forking, 282 * so ensure we can requeue all our events. */ 283 if (eloop_requeue(ctx->eloop) == -1) { 284 logger(ctx, LOG_ERR, "eloop_requeue: %m"); 285 eloop_exit(ctx->eloop, EXIT_FAILURE); 286 } 287 /* Notify parent it's safe to exit as we've detached. */ 288 close(sidpipe[0]); 289 if (write(sidpipe[1], &buf, 1) == -1) 290 logger(ctx, LOG_ERR, "failed to notify parent: %m"); 291 close(sidpipe[1]); 292 if ((fd = open(_PATH_DEVNULL, O_RDWR, 0)) != -1) { 293 dup2(fd, STDIN_FILENO); 294 dup2(fd, STDOUT_FILENO); 295 dup2(fd, STDERR_FILENO); 296 close(fd); 297 } 298 break; 299 default: 300 /* Wait for child to detach */ 301 close(sidpipe[1]); 302 if (read(sidpipe[0], &buf, 1) == -1) 303 logger(ctx, LOG_ERR, "failed to read child: %m"); 304 close(sidpipe[0]); 305 break; 306 } 307 /* Done with the fd now */ 308 if (pid != 0) { 309 logger(ctx, LOG_INFO, "forked to background, child pid %d", pid); 310 write_pid(ctx->pid_fd, pid); 311 close(ctx->pid_fd); 312 ctx->pid_fd = -1; 313 ctx->options |= DHCPCD_FORKED; 314 eloop_exit(ctx->eloop, EXIT_SUCCESS); 315 return pid; 316 } 317 ctx->options |= DHCPCD_DAEMONISED; 318 return pid; 319#endif 320} 321 322static void 323dhcpcd_drop(struct interface *ifp, int stop) 324{ 325 326 dhcp6_drop(ifp, stop ? NULL : "EXPIRE6"); 327 ipv6nd_drop(ifp); 328 ipv6_drop(ifp); 329 dhcp_drop(ifp, stop ? "STOP" : "EXPIRE"); 330 arp_close(ifp); 331} 332 333static void 334stop_interface(struct interface *ifp) 335{ 336 struct dhcpcd_ctx *ctx; 337 338 ctx = ifp->ctx; 339 logger(ctx, LOG_INFO, "%s: removing interface", ifp->name); 340 ifp->options->options |= DHCPCD_STOPPING; 341 342 dhcpcd_drop(ifp, 1); 343 if (ifp->options->options & DHCPCD_DEPARTED) 344 script_runreason(ifp, "DEPARTED"); 345 else 346 script_runreason(ifp, "STOPPED"); 347 348 /* Delete all timeouts for the interfaces */ 349 eloop_q_timeout_delete(ctx->eloop, 0, NULL, ifp); 350 351 /* Remove the interface from our list */ 352 TAILQ_REMOVE(ifp->ctx->ifaces, ifp, next); 353 if_free(ifp); 354 355 if (!(ctx->options & (DHCPCD_MASTER | DHCPCD_TEST))) 356 eloop_exit(ctx->eloop, EXIT_FAILURE); 357} 358 359static void 360configure_interface1(struct interface *ifp) 361{ 362 struct if_options *ifo = ifp->options; 363 int ra_global, ra_iface; 364#ifdef INET6 365 size_t i; 366#endif 367 368 /* Do any platform specific configuration */ 369 if_conf(ifp); 370 371 /* If we want to release a lease, we can't really persist the 372 * address either. */ 373 if (ifo->options & DHCPCD_RELEASE) 374 ifo->options &= ~DHCPCD_PERSISTENT; 375 376 if (ifp->flags & IFF_POINTOPOINT && !(ifo->options & DHCPCD_INFORM)) 377 ifo->options |= DHCPCD_STATIC; 378 if (ifp->flags & IFF_NOARP || 379 ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC)) 380 ifo->options &= ~(DHCPCD_ARP | DHCPCD_IPV4LL); 381 if (ifp->flags & (IFF_POINTOPOINT | IFF_LOOPBACK) || 382 !(ifp->flags & IFF_MULTICAST)) 383 ifo->options &= ~DHCPCD_IPV6RS; 384 385 if (ifo->metric != -1) 386 ifp->metric = (unsigned int)ifo->metric; 387 388 if (!(ifo->options & DHCPCD_IPV4)) 389 ifo->options &= ~(DHCPCD_DHCP | DHCPCD_IPV4LL); 390 391 if (!(ifo->options & DHCPCD_IPV6)) 392 ifo->options &= ~(DHCPCD_IPV6RS | DHCPCD_DHCP6); 393 394 if (ifo->options & DHCPCD_SLAACPRIVATE && 395 !(ifp->ctx->options & (DHCPCD_DUMPLEASE | DHCPCD_TEST))) 396 ifo->options |= DHCPCD_IPV6RA_OWN; 397 398 /* If we're a psuedo interface, ensure we disable as much as we can */ 399 if (ifp->options->options & DHCPCD_PFXDLGONLY) 400 ifp->options->options &= ~(DHCPCD_IPV4 | DHCPCD_IPV6RS); 401 402 /* We want to disable kernel interface RA as early as possible. */ 403 if (ifo->options & DHCPCD_IPV6RS && 404 !(ifp->ctx->options & DHCPCD_DUMPLEASE)) 405 { 406 /* If not doing any DHCP, disable the RDNSS requirement. */ 407 if (!(ifo->options & (DHCPCD_DHCP | DHCPCD_DHCP6))) 408 ifo->options &= ~DHCPCD_IPV6RA_REQRDNSS; 409 ra_global = if_checkipv6(ifp->ctx, NULL, 410 ifp->ctx->options & DHCPCD_IPV6RA_OWN ? 1 : 0); 411 ra_iface = if_checkipv6(ifp->ctx, ifp, 412 ifp->options->options & DHCPCD_IPV6RA_OWN ? 1 : 0); 413 if (ra_global == -1 || ra_iface == -1) 414 ifo->options &= ~DHCPCD_IPV6RS; 415 else if (ra_iface == 0 && 416 !(ifp->ctx->options & DHCPCD_TEST)) 417 ifo->options |= DHCPCD_IPV6RA_OWN; 418 } 419 420 /* If we haven't specified a ClientID and our hardware address 421 * length is greater than DHCP_CHADDR_LEN then we enforce a ClientID 422 * of the hardware address family and the hardware address. 423 * If there is no hardware address and no ClientID set, 424 * force a DUID based ClientID. */ 425 if (ifp->hwlen > DHCP_CHADDR_LEN) 426 ifo->options |= DHCPCD_CLIENTID; 427 else if (ifp->hwlen == 0 && !(ifo->options & DHCPCD_CLIENTID)) 428 ifo->options |= DHCPCD_CLIENTID | DHCPCD_DUID; 429 430 /* Firewire and InfiniBand interfaces require ClientID and 431 * the broadcast option being set. */ 432 switch (ifp->family) { 433 case ARPHRD_IEEE1394: /* FALLTHROUGH */ 434 case ARPHRD_INFINIBAND: 435 ifo->options |= DHCPCD_CLIENTID | DHCPCD_BROADCAST; 436 break; 437 } 438 439 if (!(ifo->options & DHCPCD_IAID)) { 440 /* 441 * An IAID is for identifying a unqiue interface within 442 * the client. It is 4 bytes long. Working out a default 443 * value is problematic. 444 * 445 * Interface name and number are not stable 446 * between different OS's. Some OS's also cannot make 447 * up their mind what the interface should be called 448 * (yes, udev, I'm looking at you). 449 * Also, the name could be longer than 4 bytes. 450 * Also, with pluggable interfaces the name and index 451 * could easily get swapped per actual interface. 452 * 453 * The MAC address is 6 bytes long, the final 3 454 * being unique to the manufacturer and the initial 3 455 * being unique to the organisation which makes it. 456 * We could use the last 4 bytes of the MAC address 457 * as the IAID as it's the most stable part given the 458 * above, but equally it's not guaranteed to be 459 * unique. 460 * 461 * Given the above, and our need to reliably work 462 * between reboots without persitent storage, 463 * generating the IAID from the MAC address is the only 464 * logical default. 465 * 466 * dhclient uses the last 4 bytes of the MAC address. 467 * dibbler uses an increamenting counter. 468 * wide-dhcpv6 uses 0 or a configured value. 469 * odhcp6c uses 1. 470 * Windows 7 uses the first 3 bytes of the MAC address 471 * and an unknown byte. 472 * dhcpcd-6.1.0 and earlier used the interface name, 473 * falling back to interface index if name > 4. 474 */ 475 if (ifp->hwlen >= sizeof(ifo->iaid)) 476 memcpy(ifo->iaid, 477 ifp->hwaddr + ifp->hwlen - sizeof(ifo->iaid), 478 sizeof(ifo->iaid)); 479 else { 480 uint32_t len; 481 482 len = (uint32_t)strlen(ifp->name); 483 if (len <= sizeof(ifo->iaid)) { 484 memcpy(ifo->iaid, ifp->name, len); 485 if (len < sizeof(ifo->iaid)) 486 memset(ifo->iaid + len, 0, 487 sizeof(ifo->iaid) - len); 488 } else { 489 /* IAID is the same size as a uint32_t */ 490 len = htonl(ifp->index); 491 memcpy(ifo->iaid, &len, sizeof(len)); 492 } 493 } 494 ifo->options |= DHCPCD_IAID; 495 } 496 497#ifdef INET6 498 if (ifo->ia_len == 0 && ifo->options & DHCPCD_IPV6 && 499 ifp->name[0] != '\0') 500 { 501 ifo->ia = malloc(sizeof(*ifo->ia)); 502 if (ifo->ia == NULL) 503 logger(ifp->ctx, LOG_ERR, "%s: %m", __func__); 504 else { 505 ifo->ia_len = 1; 506 ifo->ia->ia_type = D6_OPTION_IA_NA; 507 memcpy(ifo->ia->iaid, ifo->iaid, sizeof(ifo->iaid)); 508 memset(&ifo->ia->addr, 0, sizeof(ifo->ia->addr)); 509 ifo->ia->sla = NULL; 510 ifo->ia->sla_len = 0; 511 } 512 } else { 513 for (i = 0; i < ifo->ia_len; i++) { 514 if (!ifo->ia[i].iaid_set) { 515 memcpy(&ifo->ia[i].iaid, ifo->iaid, 516 sizeof(ifo->ia[i].iaid)); 517 ifo->ia[i].iaid_set = 1; 518 } 519 } 520 } 521#endif 522 523 /* If we are not sending an authentication option, don't require it */ 524 if (!(ifo->auth.options & DHCPCD_AUTH_SEND)) 525 ifo->auth.options &= ~DHCPCD_AUTH_REQUIRE; 526} 527 528int 529dhcpcd_selectprofile(struct interface *ifp, const char *profile) 530{ 531 struct if_options *ifo; 532 char pssid[PROFILE_LEN]; 533 534 if (ifp->ssid_len) { 535 ssize_t r; 536 537 r = print_string(pssid, sizeof(pssid), ESCSTRING, 538 ifp->ssid, ifp->ssid_len); 539 if (r == -1) { 540 logger(ifp->ctx, LOG_ERR, 541 "%s: %s: %m", ifp->name, __func__); 542 pssid[0] = '\0'; 543 } 544 } else 545 pssid[0] = '\0'; 546 ifo = read_config(ifp->ctx, ifp->name, pssid, profile); 547 if (ifo == NULL) { 548 logger(ifp->ctx, LOG_DEBUG, "%s: no profile %s", 549 ifp->name, profile); 550 return -1; 551 } 552 if (profile != NULL) { 553 strlcpy(ifp->profile, profile, sizeof(ifp->profile)); 554 logger(ifp->ctx, LOG_INFO, "%s: selected profile %s", 555 ifp->name, profile); 556 } else 557 *ifp->profile = '\0'; 558 559 free_options(ifp->options); 560 ifp->options = ifo; 561 if (profile) 562 configure_interface1(ifp); 563 return 1; 564} 565 566static void 567configure_interface(struct interface *ifp, int argc, char **argv, 568 unsigned long long options) 569{ 570 time_t old; 571 572 old = ifp->options ? ifp->options->mtime : 0; 573 dhcpcd_selectprofile(ifp, NULL); 574 add_options(ifp->ctx, ifp->name, ifp->options, argc, argv); 575 ifp->options->options |= options; 576 configure_interface1(ifp); 577 578 /* If the mtime has changed drop any old lease */ 579 if (ifp->options && old != 0 && ifp->options->mtime != old) { 580 logger(ifp->ctx, LOG_WARNING, 581 "%s: confile file changed, expiring leases", ifp->name); 582 dhcpcd_drop(ifp, 0); 583 } 584} 585 586static void 587dhcpcd_pollup(void *arg) 588{ 589 struct interface *ifp = arg; 590 int carrier; 591 592 carrier = if_carrier(ifp); /* will set ifp->flags */ 593 if (carrier == LINK_UP && !(ifp->flags & IFF_UP)) { 594 struct timespec tv; 595 596 tv.tv_sec = 0; 597 tv.tv_nsec = IF_POLL_UP * MSEC_PER_NSEC; 598 eloop_timeout_add_tv(ifp->ctx->eloop, &tv, dhcpcd_pollup, ifp); 599 return; 600 } 601 602 dhcpcd_handlecarrier(ifp->ctx, carrier, ifp->flags, ifp->name); 603} 604 605void 606dhcpcd_handlecarrier(struct dhcpcd_ctx *ctx, int carrier, unsigned int flags, 607 const char *ifname) 608{ 609 struct interface *ifp; 610 611 ifp = if_find(ctx->ifaces, ifname); 612 if (ifp == NULL || !(ifp->options->options & DHCPCD_LINK)) 613 return; 614 615 switch(carrier) { 616 case LINK_UNKNOWN: 617 carrier = if_carrier(ifp); /* will set ifp->flags */ 618 break; 619 case LINK_UP: 620 /* we have a carrier! Still need to check for IFF_UP */ 621 if (flags & IFF_UP) 622 ifp->flags = flags; 623 else { 624 /* So we need to poll for IFF_UP as there is no 625 * kernel notification when it's set. */ 626 dhcpcd_pollup(ifp); 627 return; 628 } 629 break; 630 default: 631 ifp->flags = flags; 632 } 633 634 /* If we here, we don't need to poll for IFF_UP any longer 635 * if generated by a kernel event. */ 636 eloop_timeout_delete(ifp->ctx->eloop, dhcpcd_pollup, ifp); 637 638 if (carrier == LINK_UNKNOWN) { 639 if (errno != ENOTTY) /* For example a PPP link on BSD */ 640 logger(ctx, LOG_ERR, "%s: carrier_status: %m", ifname); 641 } else if (carrier == LINK_DOWN || (ifp->flags & IFF_UP) == 0) { 642 if (ifp->carrier != LINK_DOWN) { 643 if (ifp->carrier == LINK_UP) 644 logger(ctx, LOG_INFO, "%s: carrier lost", 645 ifp->name); 646 ifp->carrier = LINK_DOWN; 647 script_runreason(ifp, "NOCARRIER"); 648#ifdef NOCARRIER_PRESERVE_IP 649 arp_close(ifp); 650 ipv4_buildroutes(ifp->ctx); 651 ipv6nd_expire(ifp, 0); 652#else 653 dhcpcd_drop(ifp, 0); 654#endif 655 } 656 } else if (carrier == LINK_UP && ifp->flags & IFF_UP) { 657 if (ifp->carrier != LINK_UP) { 658 logger(ctx, LOG_INFO, "%s: carrier acquired", 659 ifp->name); 660 ifp->carrier = LINK_UP; 661#if !defined(__linux__) && !defined(__NetBSD__) 662 /* BSD does not emit RTM_NEWADDR or RTM_CHGADDR when the 663 * hardware address changes so we have to go 664 * through the disovery process to work it out. */ 665 dhcpcd_handleinterface(ctx, 0, ifp->name); 666#endif 667 if (ifp->wireless) { 668 uint8_t ossid[IF_SSIDSIZE]; 669#ifdef NOCARRIER_PRESERVE_IP 670 size_t olen; 671 672 olen = ifp->ssid_len; 673#endif 674 memcpy(ossid, ifp->ssid, ifp->ssid_len); 675 if_getssid(ifp); 676#ifdef NOCARRIER_PRESERVE_IP 677 /* If we changed SSID network, drop leases */ 678 if (ifp->ssid_len != olen || 679 memcmp(ifp->ssid, ossid, ifp->ssid_len)) 680 dhcpcd_drop(ifp, 0); 681#endif 682 } 683 dhcpcd_initstate(ifp, 0); 684 script_runreason(ifp, "CARRIER"); 685#ifdef NOCARRIER_PRESERVE_IP 686 /* Set any IPv6 Routers we remembered to expire 687 * faster than they would normally as we 688 * maybe on a new network. */ 689 ipv6nd_expire(ifp, RTR_CARRIER_EXPIRE); 690#endif 691 /* RFC4941 Section 3.5 */ 692 if (ifp->options->options & DHCPCD_IPV6RA_OWN) 693 ipv6_gentempifid(ifp); 694 dhcpcd_startinterface(ifp); 695 } 696 } 697} 698 699static void 700warn_iaid_conflict(struct interface *ifp, uint8_t *iaid) 701{ 702 struct interface *ifn; 703 size_t i; 704 705 TAILQ_FOREACH(ifn, ifp->ctx->ifaces, next) { 706 if (ifn == ifp) 707 continue; 708 if (ifn->options->options & DHCPCD_PFXDLGONLY) 709 continue; 710 if (memcmp(ifn->options->iaid, iaid, 711 sizeof(ifn->options->iaid)) == 0) 712 break; 713 for (i = 0; i < ifn->options->ia_len; i++) { 714 if (memcmp(&ifn->options->ia[i].iaid, iaid, 715 sizeof(ifn->options->ia[i].iaid)) == 0) 716 break; 717 } 718 } 719 720 /* This is only a problem if the interfaces are on the same network. */ 721 if (ifn && strcmp(ifp->name, ifn->name)) 722 logger(ifp->ctx, LOG_ERR, 723 "%s: IAID conflicts with one assigned to %s", 724 ifp->name, ifn->name); 725} 726 727static void 728pre_start(struct interface *ifp) 729{ 730 731 /* Add our link-local address before upping the interface 732 * so our RFC7217 address beats the hwaddr based one. 733 * This is also a safety check incase it was ripped out 734 * from under us. */ 735 if (ifp->options->options & DHCPCD_IPV6 && ipv6_start(ifp) == -1) { 736 logger(ifp->ctx, LOG_ERR, "%s: ipv6_start: %m", ifp->name); 737 ifp->options->options &= ~DHCPCD_IPV6; 738 } 739} 740 741void 742dhcpcd_startinterface(void *arg) 743{ 744 struct interface *ifp = arg; 745 struct if_options *ifo = ifp->options; 746 size_t i; 747 char buf[DUID_LEN * 3]; 748 int carrier; 749 struct timespec tv; 750 751 if (ifo->options & DHCPCD_LINK) { 752 switch (ifp->carrier) { 753 case LINK_UP: 754 break; 755 case LINK_DOWN: 756 logger(ifp->ctx, LOG_INFO, "%s: waiting for carrier", 757 ifp->name); 758 return; 759 case LINK_UNKNOWN: 760 /* No media state available. 761 * Loop until both IFF_UP and IFF_RUNNING are set */ 762 if ((carrier = if_carrier(ifp)) == LINK_UNKNOWN) { 763 tv.tv_sec = 0; 764 tv.tv_nsec = IF_POLL_UP * MSEC_PER_NSEC; 765 eloop_timeout_add_tv(ifp->ctx->eloop, 766 &tv, dhcpcd_startinterface, ifp); 767 } else 768 dhcpcd_handlecarrier(ifp->ctx, carrier, 769 ifp->flags, ifp->name); 770 return; 771 } 772 } 773 774 if (ifo->options & (DHCPCD_DUID | DHCPCD_IPV6)) { 775 /* Report client DUID */ 776 if (ifp->ctx->duid == NULL) { 777 if (duid_init(ifp) == 0) 778 return; 779 if (!(ifo->options & DHCPCD_PFXDLGONLY)) 780 logger(ifp->ctx, LOG_INFO, "DUID %s", 781 hwaddr_ntoa(ifp->ctx->duid, 782 ifp->ctx->duid_len, 783 buf, sizeof(buf))); 784 } 785 } 786 787 if (ifo->options & (DHCPCD_DUID | DHCPCD_IPV6) && 788 !(ifo->options & DHCPCD_PFXDLGONLY)) 789 { 790 /* Report IAIDs */ 791 logger(ifp->ctx, LOG_INFO, "%s: IAID %s", ifp->name, 792 hwaddr_ntoa(ifo->iaid, sizeof(ifo->iaid), 793 buf, sizeof(buf))); 794 warn_iaid_conflict(ifp, ifo->iaid); 795 for (i = 0; i < ifo->ia_len; i++) { 796 if (memcmp(ifo->iaid, ifo->ia[i].iaid, 797 sizeof(ifo->iaid))) 798 { 799 logger(ifp->ctx, LOG_INFO, "%s: IAID %s", 800 ifp->name, hwaddr_ntoa(ifo->ia[i].iaid, 801 sizeof(ifo->ia[i].iaid), 802 buf, sizeof(buf))); 803 warn_iaid_conflict(ifp, ifo->ia[i].iaid); 804 } 805 } 806 } 807 808 if (ifo->options & DHCPCD_IPV6) { 809 if (ifo->options & DHCPCD_IPV6RS && 810 !(ifo->options & DHCPCD_INFORM)) 811 ipv6nd_startrs(ifp); 812 813 if (ifo->options & DHCPCD_DHCP6) 814 dhcp6_find_delegates(ifp); 815 816 if (!(ifo->options & DHCPCD_IPV6RS) || 817 ifo->options & DHCPCD_IA_FORCED) 818 { 819 ssize_t nolease; 820 821 if (ifo->options & DHCPCD_IA_FORCED) 822 nolease = dhcp6_start(ifp, DH6S_INIT); 823 else { 824 nolease = 0; 825 /* Enabling the below doesn't really make 826 * sense as there is currently no standard 827 * to push routes via DHCPv6. 828 * (There is an expired working draft, 829 * maybe abandoned?) 830 * You can also get it to work by forcing 831 * an IA as shown above. */ 832#if 0 833 /* With no RS or delegates we might 834 * as well try and solicit a DHCPv6 address */ 835 if (nolease == 0) 836 nolease = dhcp6_start(ifp, DH6S_INIT); 837#endif 838 } 839 if (nolease == -1) 840 logger(ifp->ctx, LOG_ERR, 841 "%s: dhcp6_start: %m", ifp->name); 842 } 843 } 844 845 if (ifo->options & DHCPCD_IPV4) 846 dhcp_start(ifp); 847} 848 849static void 850dhcpcd_prestartinterface(void *arg) 851{ 852 struct interface *ifp = arg; 853 854 pre_start(ifp); 855 if (if_up(ifp) == -1) 856 logger(ifp->ctx, LOG_ERR, "%s: if_up: %m", ifp->name); 857 858 if (ifp->options->options & DHCPCD_LINK && 859 ifp->carrier == LINK_UNKNOWN) 860 { 861 int carrier; 862 863 if ((carrier = if_carrier(ifp)) != LINK_UNKNOWN) { 864 dhcpcd_handlecarrier(ifp->ctx, carrier, 865 ifp->flags, ifp->name); 866 return; 867 } 868 logger(ifp->ctx, LOG_INFO, 869 "%s: unknown carrier, waiting for interface flags", 870 ifp->name); 871 } 872 873 dhcpcd_startinterface(ifp); 874} 875 876static void 877handle_link(void *arg) 878{ 879 struct dhcpcd_ctx *ctx; 880 881 ctx = arg; 882 if (if_managelink(ctx) == -1) { 883 logger(ctx, LOG_ERR, "if_managelink: %m"); 884 eloop_event_delete(ctx->eloop, ctx->link_fd, 0); 885 close(ctx->link_fd); 886 ctx->link_fd = -1; 887 } 888} 889 890static void 891dhcpcd_initstate1(struct interface *ifp, int argc, char **argv, 892 unsigned long long options) 893{ 894 struct if_options *ifo; 895 896 configure_interface(ifp, argc, argv, options); 897 ifo = ifp->options; 898 899 if (ifo->options & DHCPCD_IPV4 && ipv4_init(ifp->ctx) == -1) { 900 logger(ifp->ctx, LOG_ERR, "ipv4_init: %m"); 901 ifo->options &= ~DHCPCD_IPV4; 902 } 903 if (ifo->options & DHCPCD_IPV6 && ipv6_init(ifp->ctx) == NULL) { 904 logger(ifp->ctx, LOG_ERR, "ipv6_init: %m"); 905 ifo->options &= ~DHCPCD_IPV6RS; 906 } 907 908 /* Add our link-local address before upping the interface 909 * so our RFC7217 address beats the hwaddr based one. 910 * This needs to happen before PREINIT incase a hook script 911 * inadvertently ups the interface. */ 912 if (ifo->options & DHCPCD_IPV6 && ipv6_start(ifp) == -1) { 913 logger(ifp->ctx, LOG_ERR, "%s: ipv6_start: %m", ifp->name); 914 ifo->options &= ~DHCPCD_IPV6; 915 } 916} 917 918void 919dhcpcd_initstate(struct interface *ifp, unsigned long long options) 920{ 921 922 dhcpcd_initstate1(ifp, ifp->ctx->argc, ifp->ctx->argv, options); 923} 924 925static void 926run_preinit(struct interface *ifp) 927{ 928 929 pre_start(ifp); 930 if (ifp->ctx->options & DHCPCD_TEST) 931 return; 932 933 script_runreason(ifp, "PREINIT"); 934 935 if (ifp->options->options & DHCPCD_LINK && ifp->carrier != LINK_UNKNOWN) 936 script_runreason(ifp, 937 ifp->carrier == LINK_UP ? "CARRIER" : "NOCARRIER"); 938} 939 940int 941dhcpcd_handleinterface(void *arg, int action, const char *ifname) 942{ 943 struct dhcpcd_ctx *ctx; 944 struct if_head *ifs; 945 struct interface *ifp, *iff, *ifn; 946 const char * const argv[] = { ifname }; 947 int i; 948 949 ctx = arg; 950 if (action == -1) { 951 ifp = if_find(ctx->ifaces, ifname); 952 if (ifp == NULL) { 953 errno = ESRCH; 954 return -1; 955 } 956 logger(ctx, LOG_DEBUG, "%s: interface departed", ifp->name); 957 ifp->options->options |= DHCPCD_DEPARTED; 958 stop_interface(ifp); 959 return 0; 960 } 961 962 /* If running off an interface list, check it's in it. */ 963 if (ctx->ifc && action != 2) { 964 for (i = 0; i < ctx->ifc; i++) 965 if (strcmp(ctx->ifv[i], ifname) == 0) 966 break; 967 if (i >= ctx->ifc) 968 return 0; 969 } 970 971 i = -1; 972 ifs = if_discover(ctx, -1, UNCONST(argv)); 973 if (ifs == NULL) { 974 logger(ctx, LOG_ERR, "%s: if_discover: %m", __func__); 975 return -1; 976 } 977 TAILQ_FOREACH_SAFE(ifp, ifs, next, ifn) { 978 if (strcmp(ifp->name, ifname) != 0) 979 continue; 980 i = 0; 981 /* Check if we already have the interface */ 982 iff = if_find(ctx->ifaces, ifp->name); 983 if (iff) { 984 logger(ctx, LOG_DEBUG, "%s: interface updated", iff->name); 985 /* The flags and hwaddr could have changed */ 986 iff->flags = ifp->flags; 987 iff->hwlen = ifp->hwlen; 988 if (ifp->hwlen != 0) 989 memcpy(iff->hwaddr, ifp->hwaddr, iff->hwlen); 990 } else { 991 logger(ctx, LOG_DEBUG, "%s: interface added", ifp->name); 992 TAILQ_REMOVE(ifs, ifp, next); 993 TAILQ_INSERT_TAIL(ctx->ifaces, ifp, next); 994 dhcpcd_initstate(ifp, 0); 995 run_preinit(ifp); 996 iff = ifp; 997 } 998 if (action > 0) 999 dhcpcd_prestartinterface(iff); 1000 } 1001 1002 /* Free our discovered list */ 1003 while ((ifp = TAILQ_FIRST(ifs))) { 1004 TAILQ_REMOVE(ifs, ifp, next); 1005 if_free(ifp); 1006 } 1007 free(ifs); 1008 1009 if (i == -1) 1010 errno = ENOENT; 1011 return i; 1012} 1013 1014void 1015dhcpcd_handlehwaddr(struct dhcpcd_ctx *ctx, const char *ifname, 1016 const uint8_t *hwaddr, uint8_t hwlen) 1017{ 1018 struct interface *ifp; 1019 char buf[sizeof(ifp->hwaddr) * 3]; 1020 1021 ifp = if_find(ctx->ifaces, ifname); 1022 if (ifp == NULL) 1023 return; 1024 1025 if (hwlen > sizeof(ifp->hwaddr)) { 1026 errno = ENOBUFS; 1027 logger(ctx, LOG_ERR, "%s: %s: %m", ifp->name, __func__); 1028 return; 1029 } 1030 1031 if (ifp->hwlen == hwlen && memcmp(ifp->hwaddr, hwaddr, hwlen) == 0) 1032 return; 1033 1034 logger(ctx, LOG_INFO, "%s: new hardware address: %s", ifp->name, 1035 hwaddr_ntoa(hwaddr, hwlen, buf, sizeof(buf))); 1036 ifp->hwlen = hwlen; 1037 memcpy(ifp->hwaddr, hwaddr, hwlen); 1038} 1039 1040void 1041dhcpcd_start_interface(struct dhcpcd_ctx *ctx, const char *ifname) 1042{ 1043 struct interface *ifp; 1044 ifp = if_find(ctx->ifaces, ifname); 1045 if (ifp == NULL) 1046 { 1047 logger(ctx, LOG_ERR, "start_interface: %s not found", 1048 ifname); 1049 return; 1050 } 1051 dhcpcd_startinterface(ifp); 1052} 1053 1054void 1055dhcpcd_stop_interface(struct dhcpcd_ctx *ctx, const char *ifname) 1056{ 1057 struct interface *ifp; 1058 ifp = if_find(ctx->ifaces, ifname); 1059 if (ifp == NULL) 1060 { 1061 logger(ctx, LOG_ERR, "stop_interface: %s not found", 1062 ifname); 1063 return; 1064 } 1065 stop_interface(ifp); 1066} 1067 1068void 1069dhcpcd_stop_interfaces(struct dhcpcd_ctx *ctx) 1070{ 1071 struct interface *ifp; 1072 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 1073 stop_interface(ifp); 1074 } 1075} 1076 1077void 1078dhcpcd_release_ipv4(struct dhcpcd_ctx *ctx, const char *ifname) 1079{ 1080 struct interface *ifp; 1081 1082 ifp = if_find(ctx->ifaces, ifname); 1083 if (ifp == NULL) 1084 { 1085 logger(ctx, LOG_ERR, "IPv4 release: %s not found", 1086 ifname); 1087 return; 1088 } 1089 dhcp_drop(ifp, "RELEASE"); 1090} 1091 1092static void 1093if_reboot(struct interface *ifp, int argc, char **argv) 1094{ 1095 unsigned long long oldopts; 1096 1097 oldopts = ifp->options->options; 1098 script_runreason(ifp, "RECONFIGURE"); 1099 dhcpcd_initstate1(ifp, argc, argv, 0); 1100 dhcp_reboot_newopts(ifp, oldopts); 1101 dhcp6_reboot(ifp); 1102 dhcpcd_prestartinterface(ifp); 1103} 1104 1105static void 1106reload_config(struct dhcpcd_ctx *ctx) 1107{ 1108 struct if_options *ifo; 1109 1110 free_globals(ctx); 1111 ifo = read_config(ctx, NULL, NULL, NULL); 1112 add_options(ctx, NULL, ifo, ctx->argc, ctx->argv); 1113 /* We need to preserve these two options. */ 1114 if (ctx->options & DHCPCD_MASTER) 1115 ifo->options |= DHCPCD_MASTER; 1116 if (ctx->options & DHCPCD_DAEMONISED) 1117 ifo->options |= DHCPCD_DAEMONISED; 1118 ctx->options = ifo->options; 1119 free_options(ifo); 1120} 1121 1122static void 1123reconf_reboot(struct dhcpcd_ctx *ctx, int action, int argc, char **argv, int oi) 1124{ 1125 struct if_head *ifs; 1126 struct interface *ifn, *ifp; 1127 1128 ifs = if_discover(ctx, argc - oi, argv + oi); 1129 if (ifs == NULL) { 1130 logger(ctx, LOG_ERR, "%s: if_discover: %m", __func__); 1131 return; 1132 } 1133 1134 while ((ifp = TAILQ_FIRST(ifs))) { 1135 TAILQ_REMOVE(ifs, ifp, next); 1136 ifn = if_find(ctx->ifaces, ifp->name); 1137 if (ifn) { 1138 if (action) 1139 if_reboot(ifn, argc, argv); 1140 else 1141 ipv4_applyaddr(ifn); 1142 if_free(ifp); 1143 } else { 1144 TAILQ_INSERT_TAIL(ctx->ifaces, ifp, next); 1145 dhcpcd_initstate1(ifp, argc, argv, 0); 1146 run_preinit(ifp); 1147 dhcpcd_prestartinterface(ifp); 1148 } 1149 } 1150 free(ifs); 1151} 1152 1153static void 1154stop_all_interfaces(struct dhcpcd_ctx *ctx, int do_release) 1155{ 1156 struct interface *ifp; 1157 1158 /* drop_dhcp could change the order, so we do it like this. */ 1159 for (;;) { 1160 /* Be sane and drop the last config first, 1161 * skipping any pseudo interfaces */ 1162 TAILQ_FOREACH_REVERSE(ifp, ctx->ifaces, if_head, next) { 1163 if (!(ifp->options->options & DHCPCD_PFXDLGONLY)) 1164 break; 1165 } 1166 if (ifp == NULL) 1167 break; 1168 if (do_release) { 1169 ifp->options->options |= DHCPCD_RELEASE; 1170 ifp->options->options &= ~DHCPCD_PERSISTENT; 1171 } 1172 ifp->options->options |= DHCPCD_EXITING; 1173 stop_interface(ifp); 1174 } 1175} 1176 1177#ifdef USE_SIGNALS 1178struct dhcpcd_siginfo dhcpcd_siginfo; 1179#define sigmsg "received %s, %s" 1180void 1181dhcpcd_handle_signal(void *arg) 1182{ 1183 struct dhcpcd_ctx *ctx; 1184 struct dhcpcd_siginfo *si; 1185 struct interface *ifp; 1186 int do_release, exit_code;; 1187 1188 ctx = dhcpcd_ctx; 1189 si = arg; 1190 do_release = 0; 1191 exit_code = EXIT_FAILURE; 1192 switch (si->signo) { 1193 case SIGINT: 1194 logger(ctx, LOG_INFO, sigmsg, "SIGINT", "stopping"); 1195 break; 1196 case SIGTERM: 1197 logger(ctx, LOG_INFO, sigmsg, "SIGTERM", "stopping"); 1198 exit_code = EXIT_SUCCESS; 1199 break; 1200 case SIGALRM: 1201 logger(ctx, LOG_INFO, sigmsg, "SIGALRM", "releasing"); 1202 do_release = 1; 1203 exit_code = EXIT_SUCCESS; 1204 break; 1205 case SIGHUP: 1206 logger(ctx, LOG_INFO, sigmsg, "SIGHUP", "rebinding"); 1207 reload_config(ctx); 1208 /* Preserve any options passed on the commandline 1209 * when we were started. */ 1210 reconf_reboot(ctx, 1, ctx->argc, ctx->argv, 1211 ctx->argc - ctx->ifc); 1212 return; 1213 case SIGUSR1: 1214 logger(ctx, LOG_INFO, sigmsg, "SIGUSR1", "reconfiguring"); 1215 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 1216 ipv4_applyaddr(ifp); 1217 } 1218 return; 1219 case SIGUSR2: 1220 logger_close(ctx); 1221 logger_open(ctx); 1222 logger(ctx, LOG_INFO, sigmsg, "SIGUSR2", "reopened logfile"); 1223 return; 1224 case SIGPIPE: 1225 logger(ctx, LOG_WARNING, "received SIGPIPE"); 1226 return; 1227 default: 1228 logger(ctx, LOG_ERR, 1229 "received signal %d, " 1230 "but don't know what to do with it", 1231 si->signo); 1232 return; 1233 } 1234 1235 if (!(ctx->options & DHCPCD_TEST)) 1236 stop_all_interfaces(ctx, do_release); 1237 eloop_exit(ctx->eloop, exit_code); 1238} 1239 1240#ifndef HAVE_KQUEUE 1241static void 1242handle_signal(int sig, __unused siginfo_t *siginfo, __unused void *context) 1243{ 1244 1245 /* So that we can operate safely under a signal we instruct 1246 * eloop to pass a copy of the siginfo structure to handle_signal1 1247 * as the very first thing to do. */ 1248 dhcpcd_siginfo.signo = sig; 1249 eloop_timeout_add_now(dhcpcd_ctx->eloop, 1250 dhcpcd_handle_signal, &dhcpcd_siginfo); 1251} 1252#endif 1253 1254static int 1255signal_init(sigset_t *oldset) 1256{ 1257 sigset_t newset; 1258#ifndef HAVE_KQUEUE 1259 int i; 1260 struct sigaction sa; 1261#endif 1262 1263 sigfillset(&newset); 1264 if (sigprocmask(SIG_SETMASK, &newset, oldset) == -1) 1265 return -1; 1266 1267#ifndef HAVE_KQUEUE 1268 memset(&sa, 0, sizeof(sa)); 1269 sa.sa_sigaction = handle_signal; 1270 sa.sa_flags = SA_SIGINFO; 1271 sigemptyset(&sa.sa_mask); 1272 1273 for (i = 0; dhcpcd_handlesigs[i]; i++) { 1274 if (sigaction(dhcpcd_handlesigs[i], &sa, NULL) == -1) 1275 return -1; 1276 } 1277#endif 1278 return 0; 1279} 1280#endif 1281 1282static void 1283dhcpcd_getinterfaces(void *arg) 1284{ 1285 struct fd_list *fd = arg; 1286 struct interface *ifp; 1287 size_t len; 1288 1289 len = 0; 1290 TAILQ_FOREACH(ifp, fd->ctx->ifaces, next) { 1291 len++; 1292 if (D_STATE_RUNNING(ifp)) 1293 len++; 1294 if (RS_STATE_RUNNING(ifp)) 1295 len++; 1296 if (D6_STATE_RUNNING(ifp)) 1297 len++; 1298 } 1299 if (write(fd->fd, &len, sizeof(len)) != sizeof(len)) 1300 return; 1301 eloop_event_delete(fd->ctx->eloop, fd->fd, 1); 1302 TAILQ_FOREACH(ifp, fd->ctx->ifaces, next) { 1303 if (send_interface(fd, ifp) == -1) 1304 logger(ifp->ctx, LOG_ERR, 1305 "send_interface %d: %m", fd->fd); 1306 } 1307} 1308 1309int 1310dhcpcd_handleargs(struct dhcpcd_ctx *ctx, struct fd_list *fd, 1311 int argc, char **argv) 1312{ 1313 struct interface *ifp; 1314 int do_exit = 0, do_release = 0, do_reboot = 0; 1315 int opt, oi = 0; 1316 size_t len, l; 1317 char *tmp, *p; 1318 1319 /* Special commands for our control socket 1320 * as the other end should be blocking until it gets the 1321 * expected reply we should be safely able just to change the 1322 * write callback on the fd */ 1323 if (strcmp(*argv, "--version") == 0) { 1324 return control_queue(fd, UNCONST(VERSION), 1325 strlen(VERSION) + 1, 0); 1326 } else if (strcmp(*argv, "--getconfigfile") == 0) { 1327 return control_queue(fd, UNCONST(fd->ctx->cffile), 1328 strlen(fd->ctx->cffile) + 1, 0); 1329 } else if (strcmp(*argv, "--getinterfaces") == 0) { 1330 eloop_event_add(fd->ctx->eloop, fd->fd, NULL, NULL, 1331 dhcpcd_getinterfaces, fd); 1332 return 0; 1333 } else if (strcmp(*argv, "--listen") == 0) { 1334 fd->flags |= FD_LISTEN; 1335 return 0; 1336 } 1337 1338 /* Only priviledged users can control dhcpcd via the socket. */ 1339 if (fd->flags & FD_UNPRIV) { 1340 errno = EPERM; 1341 return -1; 1342 } 1343 1344 /* Log the command */ 1345 len = 1; 1346 for (opt = 0; opt < argc; opt++) 1347 len += strlen(argv[opt]) + 1; 1348 tmp = malloc(len); 1349 if (tmp == NULL) 1350 return -1; 1351 p = tmp; 1352 for (opt = 0; opt < argc; opt++) { 1353 l = strlen(argv[opt]); 1354 strlcpy(p, argv[opt], len); 1355 len -= l + 1; 1356 p += l; 1357 *p++ = ' '; 1358 } 1359 *--p = '\0'; 1360 logger(ctx, LOG_INFO, "control command: %s", tmp); 1361 free(tmp); 1362 1363 optind = 0; 1364 while ((opt = getopt_long(argc, argv, IF_OPTS, cf_options, &oi)) != -1) 1365 { 1366 switch (opt) { 1367 case 'g': 1368 /* Assumed if below not set */ 1369 break; 1370 case 'k': 1371 do_release = 1; 1372 break; 1373 case 'n': 1374 do_reboot = 1; 1375 break; 1376 case 'x': 1377 do_exit = 1; 1378 break; 1379 } 1380 } 1381 1382 if (do_release || do_exit) { 1383 if (optind == argc) { 1384 stop_all_interfaces(ctx, do_release); 1385 eloop_exit(ctx->eloop, EXIT_SUCCESS); 1386 return 0; 1387 } 1388 for (oi = optind; oi < argc; oi++) { 1389 if ((ifp = if_find(ctx->ifaces, argv[oi])) == NULL) 1390 continue; 1391 if (do_release) { 1392 ifp->options->options |= DHCPCD_RELEASE; 1393 ifp->options->options &= ~DHCPCD_PERSISTENT; 1394 } 1395 ifp->options->options |= DHCPCD_EXITING; 1396 stop_interface(ifp); 1397 } 1398 return 0; 1399 } 1400 1401 reload_config(ctx); 1402 /* XXX: Respect initial commandline options? */ 1403 reconf_reboot(ctx, do_reboot, argc, argv, optind); 1404 return 0; 1405} 1406 1407#if defined(__ANDROID__) 1408static void 1409switch_user(void) 1410{ 1411 gid_t groups[] = { AID_DBUS, AID_INET, AID_SHELL }; 1412 struct __user_cap_header_struct header; 1413 struct __user_cap_data_struct cap; 1414 1415 setgroups(sizeof(groups)/sizeof(groups[0]), groups); 1416 1417 prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0); 1418 1419 setgid(AID_DHCP); 1420 setuid(AID_DHCP); 1421 header.version = _LINUX_CAPABILITY_VERSION; 1422 header.pid = 0; 1423 cap.effective = cap.permitted = 1424 (1 << CAP_NET_ADMIN) | (1 << CAP_NET_RAW) | 1425 (1 << CAP_NET_BROADCAST) | (1 << CAP_NET_BIND_SERVICE); 1426 cap.inheritable = 0; 1427 capset(&header, &cap); 1428} 1429#endif /* __ANDROID__ */ 1430 1431int 1432main(int argc, char **argv) 1433{ 1434 struct dhcpcd_ctx ctx; 1435 struct if_options *ifo; 1436 struct interface *ifp; 1437 uint16_t family = 0; 1438 int opt, oi = 0, i; 1439 time_t t; 1440 ssize_t len; 1441#if defined(USE_SIGNALS) || !defined(THERE_IS_NO_FORK) 1442 pid_t pid; 1443#endif 1444#ifdef USE_SIGNALS 1445 int sig; 1446 const char *siga; 1447#endif 1448 char ifn[IF_NAMESIZE]; 1449 1450#if defined(__ANDROID__) && !defined(__BRILLO__) 1451 switch_user(); 1452#endif /* __ANDROID__ && !__BRILLO__ */ 1453 1454 /* Test for --help and --version */ 1455 if (argc > 1) { 1456 if (strcmp(argv[1], "--help") == 0) { 1457 usage(); 1458 return EXIT_SUCCESS; 1459 } else if (strcmp(argv[1], "--version") == 0) { 1460 printf(""PACKAGE" "VERSION"\n%s\n", dhcpcd_copyright); 1461 return EXIT_SUCCESS; 1462 } 1463 } 1464 1465 memset(&ctx, 0, sizeof(ctx)); 1466#ifdef USE_SIGNALS 1467 dhcpcd_ctx = &ctx; 1468 sig = 0; 1469 siga = NULL; 1470#endif 1471 closefrom(3); 1472 1473 ctx.log_fd = -1; 1474 logger_open(&ctx); 1475 logger_mask(&ctx, LOG_UPTO(LOG_INFO)); 1476 1477 ifo = NULL; 1478 ctx.cffile = CONFIG; 1479 ctx.pid_fd = ctx.control_fd = ctx.control_unpriv_fd = ctx.link_fd = -1; 1480 TAILQ_INIT(&ctx.control_fds); 1481#ifdef PLUGIN_DEV 1482 ctx.dev_fd = -1; 1483#endif 1484#ifdef INET 1485 ctx.udp_fd = -1; 1486#endif 1487 i = 0; 1488 while ((opt = getopt_long(argc, argv, IF_OPTS, cf_options, &oi)) != -1) 1489 { 1490 switch (opt) { 1491 case '4': 1492 family = AF_INET; 1493 break; 1494 case '6': 1495 family = AF_INET6; 1496 break; 1497 case 'f': 1498 ctx.cffile = optarg; 1499 break; 1500#ifdef USE_SIGNALS 1501 case 'g': 1502 sig = SIGUSR1; 1503 siga = "USR1"; 1504 break; 1505 case 'j': 1506 ctx.logfile = strdup(optarg); 1507 logger_close(&ctx); 1508 logger_open(&ctx); 1509 break; 1510 case 'k': 1511 sig = SIGALRM; 1512 siga = "ARLM"; 1513 break; 1514 case 'n': 1515 sig = SIGHUP; 1516 siga = "HUP"; 1517 break; 1518 case 'x': 1519 sig = SIGTERM; 1520 siga = "TERM";; 1521 break; 1522#endif 1523 case 'T': 1524 i = 1; 1525 break; 1526 case 'U': 1527 if (i == 3) 1528 i = 4; 1529 else if (i != 4) 1530 i = 3; 1531 break; 1532 case 'V': 1533 i = 2; 1534 break; 1535 case '?': 1536 usage(); 1537 goto exit_failure; 1538 } 1539 } 1540 1541 ctx.argv = argv; 1542 ctx.argc = argc; 1543 ctx.ifc = argc - optind; 1544 ctx.ifv = argv + optind; 1545 1546 ifo = read_config(&ctx, NULL, NULL, NULL); 1547 if (ifo == NULL) 1548 goto exit_failure; 1549 opt = add_options(&ctx, NULL, ifo, argc, argv); 1550 if (opt != 1) { 1551 if (opt == 0) 1552 usage(); 1553 goto exit_failure; 1554 } 1555 if (i == 2) { 1556 printf("Interface options:\n"); 1557 if (optind == argc - 1) { 1558 free_options(ifo); 1559 ifo = read_config(&ctx, argv[optind], NULL, NULL); 1560 if (ifo == NULL) 1561 goto exit_failure; 1562 add_options(&ctx, NULL, ifo, argc, argv); 1563 } 1564 if_printoptions(); 1565#ifdef INET 1566 if (family == 0 || family == AF_INET) { 1567 printf("\nDHCPv4 options:\n"); 1568 dhcp_printoptions(&ctx, 1569 ifo->dhcp_override, ifo->dhcp_override_len); 1570 } 1571#endif 1572#ifdef INET6 1573 if (family == 0 || family == AF_INET6) { 1574 printf("\nDHCPv6 options:\n"); 1575 dhcp6_printoptions(&ctx, 1576 ifo->dhcp6_override, ifo->dhcp6_override_len); 1577 } 1578#endif 1579 goto exit_success; 1580 } 1581 ctx.options = ifo->options; 1582 if (i != 0) { 1583 if (i == 1) 1584 ctx.options |= DHCPCD_TEST; 1585 else 1586 ctx.options |= DHCPCD_DUMPLEASE; 1587 if (i == 4) 1588 ctx.options |= DHCPCD_PFXDLGONLY; 1589 ctx.options |= DHCPCD_PERSISTENT; 1590 ctx.options &= ~DHCPCD_DAEMONISE; 1591 } 1592 1593#ifdef THERE_IS_NO_FORK 1594 ctx.options &= ~DHCPCD_DAEMONISE; 1595#endif 1596 1597 if (ctx.options & DHCPCD_DEBUG) 1598 logger_mask(&ctx, LOG_UPTO(LOG_DEBUG)); 1599 if (ctx.options & DHCPCD_QUIET) { 1600 i = open(_PATH_DEVNULL, O_RDWR); 1601 if (i == -1) 1602 logger(&ctx, LOG_ERR, "%s: open: %m", __func__); 1603 else { 1604 dup2(i, STDERR_FILENO); 1605 close(i); 1606 } 1607 } 1608 1609 if (!(ctx.options & (DHCPCD_TEST | DHCPCD_DUMPLEASE))) { 1610 /* If we have any other args, we should run as a single dhcpcd 1611 * instance for that interface. */ 1612 if (optind == argc - 1 && !(ctx.options & DHCPCD_MASTER)) { 1613 const char *per; 1614 int intf_len = strlen(argv[optind]); 1615 split_interface_lease(argv[optind], &intf_len, NULL); 1616 if (intf_len > IF_NAMESIZE) { 1617 logger(&ctx, LOG_ERR, 1618 "%s: interface name too long", 1619 argv[optind]); 1620 goto exit_failure; 1621 } 1622 strlcpy(ifn, argv[optind], intf_len + 1); 1623 /* Allow a dhcpcd interface per address family */ 1624 switch(family) { 1625 case AF_INET: 1626 per = "-4"; 1627 break; 1628 case AF_INET6: 1629 per = "-6"; 1630 break; 1631 default: 1632 per = ""; 1633 } 1634 snprintf(ctx.pidfile, sizeof(ctx.pidfile), 1635 PIDFILE, "-", ifn, per); 1636 } else { 1637 snprintf(ctx.pidfile, sizeof(ctx.pidfile), 1638 PIDFILE, "", "", ""); 1639 ctx.options |= DHCPCD_MASTER; 1640 } 1641 } 1642 1643 if (chdir("/") == -1) 1644 logger(&ctx, LOG_ERR, "chdir `/': %m"); 1645 1646 /* Freeing allocated addresses from dumping leases can trigger 1647 * eloop removals as well, so init here. */ 1648 ctx.eloop = eloop_init(&ctx); 1649 if (ctx.eloop == NULL) { 1650 logger(&ctx, LOG_ERR, "%s: eloop_init: %m", __func__); 1651 goto exit_failure; 1652 } 1653 1654 if (ctx.options & DHCPCD_DUMPLEASE) { 1655 if (optind != argc - 1) { 1656 logger(&ctx, LOG_ERR, 1657 "dumplease requires an interface"); 1658 goto exit_failure; 1659 } 1660 i = 0; 1661 /* We need to try and find the interface so we can 1662 * load the hardware address to compare automated IAID */ 1663 ctx.ifaces = if_discover(&ctx, 1, argv + optind); 1664 if (ctx.ifaces == NULL) { 1665 logger(&ctx, LOG_ERR, "if_discover: %m"); 1666 goto exit_failure; 1667 } 1668 ifp = TAILQ_FIRST(ctx.ifaces); 1669 if (ifp == NULL) { 1670 ifp = calloc(1, sizeof(*ifp)); 1671 if (ifp == NULL) { 1672 logger(&ctx, LOG_ERR, "%s: %m", __func__); 1673 goto exit_failure; 1674 } 1675 strlcpy(ctx.pidfile, argv[optind], sizeof(ctx.pidfile)); 1676 ifp->ctx = &ctx; 1677 TAILQ_INSERT_HEAD(ctx.ifaces, ifp, next); 1678 if (family == 0) { 1679 if (ctx.pidfile[strlen(ctx.pidfile) - 1] == '6') 1680 family = AF_INET6; 1681 else 1682 family = AF_INET; 1683 } 1684 } 1685 configure_interface(ifp, ctx.argc, ctx.argv, 0); 1686 if (ctx.options & DHCPCD_PFXDLGONLY) 1687 ifp->options->options |= DHCPCD_PFXDLGONLY; 1688 if (family == 0 || family == AF_INET) { 1689 if (dhcp_dump(ifp) == -1) 1690 i = 1; 1691 } 1692 if (family == 0 || family == AF_INET6) { 1693 if (dhcp6_dump(ifp) == -1) 1694 i = 1; 1695 } 1696 if (i == -1) 1697 goto exit_failure; 1698 goto exit_success; 1699 } 1700 1701#ifdef USE_SIGNALS 1702 if (!(ctx.options & DHCPCD_TEST) && 1703 (sig == 0 || ctx.ifc != 0)) 1704 { 1705#endif 1706 if (ctx.options & DHCPCD_MASTER) 1707 i = -1; 1708 else 1709 i = control_open(&ctx, argv[optind]); 1710 if (i == -1) 1711 i = control_open(&ctx, NULL); 1712 if (i != -1) { 1713 logger(&ctx, LOG_INFO, 1714 "sending commands to master dhcpcd process"); 1715 len = control_send(&ctx, argc, argv); 1716 control_close(&ctx); 1717 if (len > 0) { 1718 logger(&ctx, LOG_DEBUG, "send OK"); 1719 goto exit_success; 1720 } else { 1721 logger(&ctx, LOG_ERR, 1722 "failed to send commands"); 1723 goto exit_failure; 1724 } 1725 } else { 1726 if (errno != ENOENT) 1727 logger(&ctx, LOG_ERR, "control_open: %m"); 1728 } 1729#ifdef USE_SIGNALS 1730 } 1731#endif 1732 1733 if (geteuid()) 1734 logger(&ctx, LOG_NOTICE, 1735 PACKAGE " is running with reduced privileges"); 1736 1737#ifdef USE_SIGNALS 1738 if (sig != 0) { 1739 pid = read_pid(ctx.pidfile); 1740 if (pid != 0) 1741 logger(&ctx, LOG_INFO, "sending signal %s to pid %d", 1742 siga, pid); 1743 if (pid == 0 || kill(pid, sig) != 0) { 1744 if (sig != SIGHUP && errno != EPERM) 1745 logger(&ctx, LOG_ERR, ""PACKAGE" not running"); 1746 if (pid != 0 && errno != ESRCH) { 1747 logger(&ctx, LOG_ERR, "kill: %m"); 1748 goto exit_failure; 1749 } 1750 unlink(ctx.pidfile); 1751 if (sig != SIGHUP) 1752 goto exit_failure; 1753 } else { 1754 struct timespec ts; 1755 1756 if (sig == SIGHUP || sig == SIGUSR1) 1757 goto exit_success; 1758 /* Spin until it exits */ 1759 logger(&ctx, LOG_INFO, 1760 "waiting for pid %d to exit", pid); 1761 ts.tv_sec = 0; 1762 ts.tv_nsec = 100000000; /* 10th of a second */ 1763 for(i = 0; i < 100; i++) { 1764 nanosleep(&ts, NULL); 1765 if (read_pid(ctx.pidfile) == 0) 1766 goto exit_success; 1767 } 1768 logger(&ctx, LOG_ERR, "pid %d failed to exit", pid); 1769 goto exit_failure; 1770 } 1771 } 1772 1773 if (!(ctx.options & DHCPCD_TEST)) { 1774 if ((pid = read_pid(ctx.pidfile)) > 0 && 1775 kill(pid, 0) == 0) 1776 { 1777 logger(&ctx, LOG_ERR, ""PACKAGE 1778 " already running on pid %d (%s)", 1779 pid, ctx.pidfile); 1780 goto exit_failure; 1781 } 1782 1783#if !defined(__ANDROID__) 1784 /* Ensure we have the needed directories 1785 * On Android, we assume that these directories have been created 1786 * by calls to mkdir in an init.rc file. */ 1787 if (mkdir(RUNDIR, 0755) == -1 && errno != EEXIST) 1788 logger(&ctx, LOG_ERR, "mkdir `%s': %m", RUNDIR); 1789 if (mkdir(DBDIR, 0755) == -1 && errno != EEXIST) 1790 logger(&ctx, LOG_ERR, "mkdir `%s': %m", DBDIR); 1791#endif /* __ANDROID__ */ 1792 1793 opt = O_WRONLY | O_CREAT | O_NONBLOCK; 1794#ifdef O_CLOEXEC 1795 opt |= O_CLOEXEC; 1796#endif 1797 ctx.pid_fd = open(ctx.pidfile, opt, 0664); 1798 if (ctx.pid_fd == -1) 1799 logger(&ctx, LOG_ERR, "open `%s': %m", ctx.pidfile); 1800 else { 1801#ifdef LOCK_EX 1802 /* Lock the file so that only one instance of dhcpcd 1803 * runs on an interface */ 1804 if (flock(ctx.pid_fd, LOCK_EX | LOCK_NB) == -1) { 1805 logger(&ctx, LOG_ERR, "flock `%s': %m", ctx.pidfile); 1806 close(ctx.pid_fd); 1807 ctx.pid_fd = -1; 1808 goto exit_failure; 1809 } 1810#endif 1811#ifndef O_CLOEXEC 1812 if (fcntl(ctx.pid_fd, F_GETFD, &opt) == -1 || 1813 fcntl(ctx.pid_fd, F_SETFD, opt | FD_CLOEXEC) == -1) 1814 { 1815 logger(&ctx, LOG_ERR, "fcntl: %m"); 1816 close(ctx.pid_fd); 1817 ctx.pid_fd = -1; 1818 goto exit_failure; 1819 } 1820#endif 1821 write_pid(ctx.pid_fd, getpid()); 1822 } 1823 } 1824 1825 if (ctx.options & DHCPCD_MASTER) { 1826 if (control_start(&ctx, NULL) == -1) 1827 logger(&ctx, LOG_ERR, "control_start: %m"); 1828 } 1829#else 1830 if (control_start(&ctx, 1831 ctx.options & DHCPCD_MASTER ? NULL : argv[optind]) == -1) 1832 { 1833 logger(&ctx, LOG_ERR, "control_start: %m"); 1834 goto exit_failure; 1835 } 1836#endif 1837 1838 logger(&ctx, LOG_DEBUG, PACKAGE "-" VERSION " starting"); 1839 ctx.options |= DHCPCD_STARTED; 1840#ifdef USE_SIGNALS 1841 /* Save signal mask, block and redirect signals to our handler */ 1842 if (signal_init(&ctx.sigset) == -1) { 1843 logger(&ctx, LOG_ERR, "signal_setup: %m"); 1844 goto exit_failure; 1845 } 1846#endif 1847 1848 /* When running dhcpcd against a single interface, we need to retain 1849 * the old behaviour of waiting for an IP address */ 1850 if (ctx.ifc == 1 && !(ctx.options & DHCPCD_BACKGROUND)) 1851 ctx.options |= DHCPCD_WAITIP; 1852 1853 /* RTM_NEWADDR goes through the link socket as well which we 1854 * need for IPv6 DAD, so we check for DHCPCD_LINK in 1855 * dhcpcd_handlecarrier instead. 1856 * We also need to open this before checking for interfaces below 1857 * so that we pickup any new addresses during the discover phase. */ 1858 ctx.link_fd = if_openlinksocket(); 1859 if (ctx.link_fd == -1) 1860 logger(&ctx, LOG_ERR, "open_link_socket: %m"); 1861 else 1862 eloop_event_add(ctx.eloop, ctx.link_fd, 1863 handle_link, &ctx, NULL, NULL); 1864 1865 /* Start any dev listening plugin which may want to 1866 * change the interface name provided by the kernel */ 1867 if ((ctx.options & (DHCPCD_MASTER | DHCPCD_DEV)) == 1868 (DHCPCD_MASTER | DHCPCD_DEV)) 1869 dev_start(&ctx); 1870 1871 if (rpc_init(&ctx) == -1) { 1872 /* NB: rpc_init generates a syslog msg */ 1873 exit(EXIT_FAILURE); 1874 } 1875 rpc_signal_status("Init"); 1876 1877 ctx.ifaces = if_discover(&ctx, ctx.ifc, ctx.ifv); 1878 if (ctx.ifaces == NULL) { 1879 logger(&ctx, LOG_ERR, "if_discover: %m"); 1880 goto exit_failure; 1881 } 1882 for (i = 0; i < ctx.ifc; i++) { 1883 int intf_len = strlen(ctx.ifv[i]); 1884 split_interface_lease(ctx.ifv[i], &intf_len, NULL); 1885 if (intf_len > IF_NAMESIZE) { 1886 logger(&ctx, LOG_ERR, 1887 "%s: interface name too long", 1888 ctx.ifv[i]); 1889 continue; 1890 } 1891 strlcpy(ifn, ctx.ifv[i], intf_len + 1); 1892 if (if_find(ctx.ifaces, ifn) == NULL) 1893 logger(&ctx, LOG_ERR, 1894 "%s: interface not found or invalid", 1895 ifn); 1896 } 1897 if (TAILQ_FIRST(ctx.ifaces) == NULL) { 1898 if (ctx.ifc == 0) 1899 logger(&ctx, LOG_ERR, "no valid interfaces found"); 1900 else 1901 goto exit_failure; 1902 if (!(ctx.options & DHCPCD_LINK)) { 1903 logger(&ctx, LOG_ERR, 1904 "aborting as link detection is disabled"); 1905 goto exit_failure; 1906 } 1907 } 1908 1909 TAILQ_FOREACH(ifp, ctx.ifaces, next) { 1910 dhcpcd_initstate1(ifp, argc, argv, 0); 1911 } 1912 1913 if (ctx.options & DHCPCD_BACKGROUND && dhcpcd_daemonise(&ctx)) 1914 goto exit_success; 1915 1916 opt = 0; 1917 TAILQ_FOREACH(ifp, ctx.ifaces, next) { 1918 run_preinit(ifp); 1919 if (ifp->carrier != LINK_DOWN) 1920 opt = 1; 1921 } 1922 1923 if (!(ctx.options & DHCPCD_BACKGROUND)) { 1924 if (ctx.options & DHCPCD_MASTER) 1925 t = ifo->timeout; 1926 else if ((ifp = TAILQ_FIRST(ctx.ifaces))) 1927 t = ifp->options->timeout; 1928 else 1929 t = 0; 1930 if (opt == 0 && 1931 ctx.options & DHCPCD_LINK && 1932 !(ctx.options & DHCPCD_WAITIP)) 1933 { 1934 logger(&ctx, LOG_WARNING, 1935 "no interfaces have a carrier"); 1936 if (dhcpcd_daemonise(&ctx)) 1937 goto exit_success; 1938 } else if (t > 0 && 1939 /* Test mode removes the daemonise bit, so check for both */ 1940 ctx.options & (DHCPCD_DAEMONISE | DHCPCD_TEST)) 1941 { 1942 eloop_timeout_add_sec(ctx.eloop, t, 1943 handle_exit_timeout, &ctx); 1944 } 1945 } 1946 free_options(ifo); 1947 ifo = NULL; 1948 1949 if_sortinterfaces(&ctx); 1950 TAILQ_FOREACH(ifp, ctx.ifaces, next) { 1951 eloop_timeout_add_sec(ctx.eloop, 0, 1952 dhcpcd_prestartinterface, ifp); 1953 } 1954 1955 i = eloop_start(ctx.eloop); 1956 goto exit1; 1957 1958exit_success: 1959 i = EXIT_SUCCESS; 1960 goto exit1; 1961 1962exit_failure: 1963 i = EXIT_FAILURE; 1964 1965exit1: 1966 /* Free memory and close fd's */ 1967 if (ctx.ifaces) { 1968 while ((ifp = TAILQ_FIRST(ctx.ifaces))) { 1969 TAILQ_REMOVE(ctx.ifaces, ifp, next); 1970 if_free(ifp); 1971 } 1972 free(ctx.ifaces); 1973 } 1974 free(ctx.duid); 1975 if (ctx.link_fd != -1) { 1976 eloop_event_delete(ctx.eloop, ctx.link_fd, 0); 1977 close(ctx.link_fd); 1978 } 1979 1980 free_options(ifo); 1981 free_globals(&ctx); 1982 ipv4_ctxfree(&ctx); 1983 ipv6_ctxfree(&ctx); 1984 dev_stop(&ctx); 1985 if (control_stop(&ctx) == -1) 1986 logger(&ctx, LOG_ERR, "control_stop: %m:"); 1987 if (ctx.pid_fd != -1) { 1988 close(ctx.pid_fd); 1989 unlink(ctx.pidfile); 1990 } 1991 eloop_free(ctx.eloop); 1992 1993 if (ctx.options & DHCPCD_STARTED && !(ctx.options & DHCPCD_FORKED)) 1994 logger(&ctx, LOG_INFO, PACKAGE " exited"); 1995 logger_close(&ctx); 1996 free(ctx.logfile); 1997 return i; 1998} 1999