1 /* 2 * dhcpcd - DHCP client daemon 3 * Copyright (c) 2006-2018 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 28 #include <sys/param.h> 29 #include <sys/types.h> 30 #include <sys/ioctl.h> 31 #include <sys/socket.h> 32 33 #include "config.h" 34 35 #include <net/if.h> 36 #include <net/if_arp.h> 37 #include <netinet/in.h> 38 #ifdef AF_LINK 39 # include <net/if_dl.h> 40 # include <net/if_types.h> 41 # include <netinet/in_var.h> 42 # undef AF_PACKET /* Newer Illumos defines this */ 43 #endif 44 #ifdef AF_PACKET 45 # include <netpacket/packet.h> 46 #endif 47 #ifdef SIOCGIFMEDIA 48 # include <net/if_media.h> 49 #endif 50 #include <net/route.h> 51 52 #include <ctype.h> 53 #include <errno.h> 54 #include <ifaddrs.h> 55 #include <inttypes.h> 56 #include <fnmatch.h> 57 #include <stddef.h> 58 #include <stdio.h> 59 #include <stdlib.h> 60 #include <string.h> 61 #include <unistd.h> 62 #include <fcntl.h> 63 64 #include "common.h" 65 #include "dev.h" 66 #include "dhcp.h" 67 #include "dhcp6.h" 68 #include "if.h" 69 #include "if-options.h" 70 #include "ipv4.h" 71 #include "ipv4ll.h" 72 #include "ipv6nd.h" 73 #include "logerr.h" 74 75 void 76 if_free(struct interface *ifp) 77 { 78 79 if (ifp == NULL) 80 return; 81 ipv4ll_free(ifp); 82 dhcp_free(ifp); 83 ipv4_free(ifp); 84 dhcp6_free(ifp); 85 ipv6nd_free(ifp); 86 ipv6_free(ifp); 87 rt_freeif(ifp); 88 free_options(ifp->ctx, ifp->options); 89 free(ifp); 90 } 91 92 int 93 if_opensockets(struct dhcpcd_ctx *ctx) 94 { 95 96 if (if_opensockets_os(ctx) == -1) 97 return -1; 98 99 /* We use this socket for some operations without INET. */ 100 ctx->pf_inet_fd = xsocket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0); 101 if (ctx->pf_inet_fd == -1) 102 return -1; 103 104 #ifdef IFLR_ACTIVE 105 ctx->pf_link_fd = xsocket(PF_LINK, SOCK_DGRAM | SOCK_CLOEXEC, 0); 106 if (ctx->pf_link_fd == -1) 107 return -1; 108 #endif 109 110 return 0; 111 } 112 113 void 114 if_closesockets(struct dhcpcd_ctx *ctx) 115 { 116 117 if (ctx->pf_inet_fd != -1) 118 close(ctx->pf_inet_fd); 119 #ifdef IFLR_ACTIVE 120 if (ctx->pf_link_fd != -1) 121 close(ctx->pf_link_fd); 122 #endif 123 124 if (ctx->priv) { 125 if_closesockets_os(ctx); 126 free(ctx->priv); 127 } 128 } 129 130 int 131 if_carrier(struct interface *ifp) 132 { 133 int r; 134 struct ifreq ifr; 135 #ifdef SIOCGIFMEDIA 136 struct ifmediareq ifmr; 137 #endif 138 139 memset(&ifr, 0, sizeof(ifr)); 140 strlcpy(ifr.ifr_name, ifp->name, sizeof(ifr.ifr_name)); 141 if (ioctl(ifp->ctx->pf_inet_fd, SIOCGIFFLAGS, &ifr) == -1) 142 return LINK_UNKNOWN; 143 ifp->flags = (unsigned int)ifr.ifr_flags; 144 145 #ifdef SIOCGIFMEDIA 146 memset(&ifmr, 0, sizeof(ifmr)); 147 strlcpy(ifmr.ifm_name, ifp->name, sizeof(ifmr.ifm_name)); 148 if (ioctl(ifp->ctx->pf_inet_fd, SIOCGIFMEDIA, &ifmr) != -1 && 149 ifmr.ifm_status & IFM_AVALID) 150 r = (ifmr.ifm_status & IFM_ACTIVE) ? LINK_UP : LINK_DOWN; 151 else 152 r = ifr.ifr_flags & IFF_RUNNING ? LINK_UP : LINK_UNKNOWN; 153 #else 154 r = ifr.ifr_flags & IFF_RUNNING ? LINK_UP : LINK_DOWN; 155 #endif 156 return r; 157 } 158 159 int 160 if_setflag(struct interface *ifp, short flag) 161 { 162 struct ifreq ifr; 163 int r; 164 165 memset(&ifr, 0, sizeof(ifr)); 166 strlcpy(ifr.ifr_name, ifp->name, sizeof(ifr.ifr_name)); 167 r = -1; 168 if (ioctl(ifp->ctx->pf_inet_fd, SIOCGIFFLAGS, &ifr) == 0) { 169 if (flag == 0 || (ifr.ifr_flags & flag) == flag) 170 r = 0; 171 else { 172 ifr.ifr_flags |= flag; 173 if (ioctl(ifp->ctx->pf_inet_fd, SIOCSIFFLAGS, &ifr) ==0) 174 r = 0; 175 } 176 ifp->flags = (unsigned int)ifr.ifr_flags; 177 } 178 return r; 179 } 180 181 static int 182 if_hasconf(struct dhcpcd_ctx *ctx, const char *ifname) 183 { 184 int i; 185 186 for (i = 0; i < ctx->ifcc; i++) { 187 if (strcmp(ctx->ifcv[i], ifname) == 0) 188 return 1; 189 } 190 return 0; 191 } 192 193 void 194 if_markaddrsstale(struct if_head *ifs) 195 { 196 struct interface *ifp; 197 198 TAILQ_FOREACH(ifp, ifs, next) { 199 #ifdef INET 200 ipv4_markaddrsstale(ifp); 201 #endif 202 #ifdef INET6 203 ipv6_markaddrsstale(ifp, 0); 204 #endif 205 } 206 } 207 208 void 209 if_learnaddrs(struct dhcpcd_ctx *ctx, struct if_head *ifs, 210 struct ifaddrs **ifaddrs) 211 { 212 struct ifaddrs *ifa; 213 struct interface *ifp; 214 #ifdef INET 215 const struct sockaddr_in *addr, *net, *brd; 216 #endif 217 #ifdef INET6 218 struct sockaddr_in6 *sin6, *net6; 219 #endif 220 int addrflags; 221 222 for (ifa = *ifaddrs; ifa; ifa = ifa->ifa_next) { 223 if (ifa->ifa_addr == NULL) 224 continue; 225 if ((ifp = if_find(ifs, ifa->ifa_name)) == NULL) 226 continue; 227 #ifdef HAVE_IFADDRS_ADDRFLAGS 228 addrflags = (int)ifa->ifa_addrflags; 229 #endif 230 switch(ifa->ifa_addr->sa_family) { 231 #ifdef INET 232 case AF_INET: 233 addr = (void *)ifa->ifa_addr; 234 net = (void *)ifa->ifa_netmask; 235 if (ifa->ifa_flags & IFF_POINTOPOINT) 236 brd = (void *)ifa->ifa_dstaddr; 237 else 238 brd = (void *)ifa->ifa_broadaddr; 239 #ifndef HAVE_IFADDRS_ADDRFLAGS 240 addrflags = if_addrflags(ifp, &addr->sin_addr, 241 ifa->ifa_name); 242 if (addrflags == -1) { 243 if (errno != EEXIST) 244 logerr("%s: if_addrflags: %s", 245 __func__, 246 inet_ntoa(addr->sin_addr)); 247 continue; 248 } 249 #endif 250 ipv4_handleifa(ctx, RTM_NEWADDR, ifs, ifa->ifa_name, 251 &addr->sin_addr, &net->sin_addr, 252 brd ? &brd->sin_addr : NULL, addrflags, 0); 253 break; 254 #endif 255 #ifdef INET6 256 case AF_INET6: 257 sin6 = (void *)ifa->ifa_addr; 258 net6 = (void *)ifa->ifa_netmask; 259 #ifdef __KAME__ 260 if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) 261 /* Remove the scope from the address */ 262 sin6->sin6_addr.s6_addr[2] = 263 sin6->sin6_addr.s6_addr[3] = '\0'; 264 #endif 265 #ifndef HAVE_IFADDRS_ADDRFLAGS 266 addrflags = if_addrflags6(ifp, &sin6->sin6_addr, 267 ifa->ifa_name); 268 if (addrflags == -1) { 269 if (errno != EEXIST) 270 logerr("%s: if_addrflags6", __func__); 271 continue; 272 } 273 #endif 274 ipv6_handleifa(ctx, RTM_NEWADDR, ifs, 275 ifa->ifa_name, &sin6->sin6_addr, 276 ipv6_prefixlen(&net6->sin6_addr), addrflags, 0); 277 break; 278 #endif 279 } 280 } 281 282 freeifaddrs(*ifaddrs); 283 *ifaddrs = NULL; 284 } 285 286 void 287 if_deletestaleaddrs(struct if_head *ifs) 288 { 289 struct interface *ifp; 290 291 TAILQ_FOREACH(ifp, ifs, next) { 292 #ifdef INET 293 ipv4_deletestaleaddrs(ifp); 294 #endif 295 #ifdef INET6 296 ipv6_deletestaleaddrs(ifp); 297 #endif 298 } 299 } 300 301 bool 302 if_valid_hwaddr(const uint8_t *hwaddr, size_t hwlen) 303 { 304 size_t i; 305 bool all_zeros, all_ones; 306 307 all_zeros = all_ones = true; 308 for (i = 0; i < hwlen; i++) { 309 if (hwaddr[i] != 0x00) 310 all_zeros = false; 311 if (hwaddr[i] != 0xff) 312 all_ones = false; 313 if (!all_zeros && !all_ones) 314 return true; 315 } 316 return false; 317 } 318 319 struct if_head * 320 if_discover(struct dhcpcd_ctx *ctx, struct ifaddrs **ifaddrs, 321 int argc, char * const *argv) 322 { 323 struct ifaddrs *ifa; 324 int i; 325 unsigned int active; 326 struct if_head *ifs; 327 struct interface *ifp; 328 struct if_spec spec; 329 #ifdef AF_LINK 330 const struct sockaddr_dl *sdl; 331 #ifdef SIOCGIFPRIORITY 332 struct ifreq ifr; 333 #endif 334 #ifdef IFLR_ACTIVE 335 struct if_laddrreq iflr; 336 #endif 337 338 #ifdef IFLR_ACTIVE 339 memset(&iflr, 0, sizeof(iflr)); 340 #endif 341 #elif AF_PACKET 342 const struct sockaddr_ll *sll; 343 #endif 344 345 if ((ifs = malloc(sizeof(*ifs))) == NULL) { 346 logerr(__func__); 347 return NULL; 348 } 349 TAILQ_INIT(ifs); 350 if (getifaddrs(ifaddrs) == -1) { 351 logerr(__func__); 352 goto out; 353 } 354 355 for (ifa = *ifaddrs; ifa; ifa = ifa->ifa_next) { 356 if (ifa->ifa_addr != NULL) { 357 #ifdef AF_LINK 358 if (ifa->ifa_addr->sa_family != AF_LINK) 359 continue; 360 #elif AF_PACKET 361 if (ifa->ifa_addr->sa_family != AF_PACKET) 362 continue; 363 #endif 364 } 365 if (if_nametospec(ifa->ifa_name, &spec) != 0) 366 continue; 367 368 /* It's possible for an interface to have >1 AF_LINK. 369 * For our purposes, we use the first one. */ 370 TAILQ_FOREACH(ifp, ifs, next) { 371 if (strcmp(ifp->name, spec.devname) == 0) 372 break; 373 } 374 if (ifp) 375 continue; 376 377 if (argc > 0) { 378 for (i = 0; i < argc; i++) { 379 if (strcmp(argv[i], spec.devname) == 0) 380 break; 381 } 382 active = (i == argc) ? IF_INACTIVE : IF_ACTIVE_USER; 383 } else { 384 /* -1 means we're discovering against a specific 385 * interface, but we still need the below rules 386 * to apply. */ 387 if (argc == -1 && strcmp(argv[0], spec.devname) != 0) 388 continue; 389 active = ctx->options & DHCPCD_INACTIVE ? 390 IF_INACTIVE: IF_ACTIVE_USER; 391 } 392 393 for (i = 0; i < ctx->ifdc; i++) 394 if (fnmatch(ctx->ifdv[i], spec.devname, 0) == 0) 395 break; 396 if (i < ctx->ifdc) 397 active = IF_INACTIVE; 398 for (i = 0; i < ctx->ifc; i++) 399 if (fnmatch(ctx->ifv[i], spec.devname, 0) == 0) 400 break; 401 if (ctx->ifc && i == ctx->ifc) 402 active = IF_INACTIVE; 403 for (i = 0; i < ctx->ifac; i++) 404 if (fnmatch(ctx->ifav[i], spec.devname, 0) == 0) 405 break; 406 if (ctx->ifac && i == ctx->ifac) 407 active = IF_INACTIVE; 408 409 #ifdef PLUGIN_DEV 410 /* Ensure that the interface name has settled */ 411 if (!dev_initialized(ctx, spec.devname)) 412 continue; 413 #endif 414 415 /* Don't allow loopback or pointopoint unless explicit */ 416 if (ifa->ifa_flags & (IFF_LOOPBACK | IFF_POINTOPOINT)) { 417 if ((argc == 0 || argc == -1) && 418 ctx->ifac == 0 && !if_hasconf(ctx, spec.devname)) 419 active = IF_INACTIVE; 420 } 421 422 if (if_vimaster(ctx, spec.devname) == 1) { 423 logfunc_t *logfunc = argc != 0 ? logerrx : logdebugx; 424 logfunc("%s: is a Virtual Interface Master, skipping", 425 spec.devname); 426 continue; 427 } 428 429 ifp = calloc(1, sizeof(*ifp)); 430 if (ifp == NULL) { 431 logerr(__func__); 432 break; 433 } 434 ifp->ctx = ctx; 435 strlcpy(ifp->name, spec.devname, sizeof(ifp->name)); 436 ifp->flags = ifa->ifa_flags; 437 438 if (ifa->ifa_addr != NULL) { 439 #ifdef AF_LINK 440 sdl = (const void *)ifa->ifa_addr; 441 442 #ifdef IFLR_ACTIVE 443 /* We need to check for active address */ 444 strlcpy(iflr.iflr_name, ifp->name, 445 sizeof(iflr.iflr_name)); 446 memcpy(&iflr.addr, ifa->ifa_addr, 447 MIN(ifa->ifa_addr->sa_len, sizeof(iflr.addr))); 448 iflr.flags = IFLR_PREFIX; 449 iflr.prefixlen = (unsigned int)sdl->sdl_alen * NBBY; 450 if (ioctl(ctx->pf_link_fd, SIOCGLIFADDR, &iflr) == -1 || 451 !(iflr.flags & IFLR_ACTIVE)) 452 { 453 if_free(ifp); 454 continue; 455 } 456 #endif 457 458 ifp->index = sdl->sdl_index; 459 switch(sdl->sdl_type) { 460 #ifdef IFT_BRIDGE 461 case IFT_BRIDGE: /* FALLTHROUGH */ 462 #endif 463 #ifdef IFT_PPP 464 case IFT_PPP: /* FALLTHROUGH */ 465 #endif 466 #ifdef IFT_PROPVIRTUAL 467 case IFT_PROPVIRTUAL: /* FALLTHROUGH */ 468 #endif 469 #if defined(IFT_BRIDGE) || defined(IFT_PPP) || defined(IFT_PROPVIRTUAL) 470 /* Don't allow unless explicit */ 471 if ((argc == 0 || argc == -1) && 472 ctx->ifac == 0 && active && 473 !if_hasconf(ctx, ifp->name)) 474 { 475 logdebugx("%s: ignoring due to" 476 " interface type and" 477 " no config", 478 ifp->name); 479 active = IF_INACTIVE; 480 } 481 /* FALLTHROUGH */ 482 #endif 483 #ifdef IFT_L2VLAN 484 case IFT_L2VLAN: /* FALLTHROUGH */ 485 #endif 486 #ifdef IFT_L3IPVLAN 487 case IFT_L3IPVLAN: /* FALLTHROUGH */ 488 #endif 489 case IFT_ETHER: 490 ifp->family = ARPHRD_ETHER; 491 break; 492 #ifdef IFT_IEEE1394 493 case IFT_IEEE1394: 494 ifp->family = ARPHRD_IEEE1394; 495 break; 496 #endif 497 #ifdef IFT_INFINIBAND 498 case IFT_INFINIBAND: 499 ifp->family = ARPHRD_INFINIBAND; 500 break; 501 #endif 502 default: 503 /* Don't allow unless explicit */ 504 if ((argc == 0 || argc == -1) && 505 ctx->ifac == 0 && 506 !if_hasconf(ctx, ifp->name)) 507 active = IF_INACTIVE; 508 if (active) 509 logwarnx("%s: unsupported" 510 " interface type %.2x", 511 ifp->name, sdl->sdl_type); 512 /* Pretend it's ethernet */ 513 ifp->family = ARPHRD_ETHER; 514 break; 515 } 516 ifp->hwlen = sdl->sdl_alen; 517 memcpy(ifp->hwaddr, CLLADDR(sdl), ifp->hwlen); 518 #elif AF_PACKET 519 sll = (const void *)ifa->ifa_addr; 520 ifp->index = (unsigned int)sll->sll_ifindex; 521 ifp->family = sll->sll_hatype; 522 ifp->hwlen = sll->sll_halen; 523 if (ifp->hwlen != 0) 524 memcpy(ifp->hwaddr, sll->sll_addr, ifp->hwlen); 525 #endif 526 } 527 #ifdef __linux__ 528 /* PPP addresses on Linux don't have hardware addresses */ 529 else 530 ifp->index = if_nametoindex(ifp->name); 531 #endif 532 533 /* Ensure hardware address is valid. */ 534 if (!if_valid_hwaddr(ifp->hwaddr, ifp->hwlen)) 535 ifp->hwlen = 0; 536 537 /* We only work on ethernet by default */ 538 if (ifp->family != ARPHRD_ETHER) { 539 if ((argc == 0 || argc == -1) && 540 ctx->ifac == 0 && !if_hasconf(ctx, ifp->name)) 541 active = IF_INACTIVE; 542 switch (ifp->family) { 543 case ARPHRD_IEEE1394: 544 case ARPHRD_INFINIBAND: 545 #ifdef ARPHRD_LOOPBACK 546 case ARPHRD_LOOPBACK: 547 #endif 548 #ifdef ARPHRD_PPP 549 case ARPHRD_PPP: 550 #endif 551 /* We don't warn for supported families */ 552 break; 553 554 /* IFT already checked */ 555 #ifndef AF_LINK 556 default: 557 if (active) 558 logwarnx("%s: unsupported" 559 " interface family %.2x", 560 ifp->name, ifp->family); 561 break; 562 #endif 563 } 564 } 565 566 if (!(ctx->options & (DHCPCD_DUMPLEASE | DHCPCD_TEST))) { 567 /* Handle any platform init for the interface */ 568 if (active != IF_INACTIVE && if_init(ifp) == -1) { 569 logerr("%s: if_init", ifp->name); 570 if_free(ifp); 571 continue; 572 } 573 } 574 575 ifp->vlanid = if_vlanid(ifp); 576 577 #ifdef SIOCGIFPRIORITY 578 /* Respect the interface priority */ 579 memset(&ifr, 0, sizeof(ifr)); 580 strlcpy(ifr.ifr_name, ifp->name, sizeof(ifr.ifr_name)); 581 if (ioctl(ctx->pf_inet_fd, SIOCGIFPRIORITY, &ifr) == 0) 582 ifp->metric = (unsigned int)ifr.ifr_metric; 583 if_getssid(ifp); 584 #else 585 /* We reserve the 100 range for virtual interfaces, if and when 586 * we can work them out. */ 587 ifp->metric = 200 + ifp->index; 588 if (if_getssid(ifp) != -1) { 589 ifp->wireless = 1; 590 ifp->metric += 100; 591 } 592 #endif 593 594 ifp->active = active; 595 if (ifp->active) 596 ifp->carrier = if_carrier(ifp); 597 else 598 ifp->carrier = LINK_UNKNOWN; 599 TAILQ_INSERT_TAIL(ifs, ifp, next); 600 } 601 602 out: 603 return ifs; 604 } 605 606 /* Decode bge0:1 as dev = bge, ppa = 0 and lun = 1 */ 607 int 608 if_nametospec(const char *ifname, struct if_spec *spec) 609 { 610 char *ep; 611 int e; 612 613 if (ifname == NULL || *ifname == '\0' || 614 strlcpy(spec->ifname, ifname, sizeof(spec->ifname)) >= 615 sizeof(spec->ifname) || 616 strlcpy(spec->drvname, ifname, sizeof(spec->drvname)) >= 617 sizeof(spec->drvname)) 618 { 619 errno = EINVAL; 620 return -1; 621 } 622 ep = strchr(spec->drvname, ':'); 623 if (ep) { 624 spec->lun = (int)strtoi(ep + 1, NULL, 10, 0, INT_MAX, &e); 625 if (e != 0) { 626 errno = e; 627 return -1; 628 } 629 *ep-- = '\0'; 630 } else { 631 spec->lun = -1; 632 ep = spec->drvname + strlen(spec->drvname) - 1; 633 } 634 strlcpy(spec->devname, spec->drvname, sizeof(spec->devname)); 635 while (ep > spec->drvname && isdigit((int)*ep)) 636 ep--; 637 if (*ep++ == ':') { 638 errno = EINVAL; 639 return -1; 640 } 641 spec->ppa = (int)strtoi(ep, NULL, 10, 0, INT_MAX, &e); 642 if (e != 0) 643 spec->ppa = -1; 644 *ep = '\0'; 645 646 return 0; 647 } 648 649 static struct interface * 650 if_findindexname(struct if_head *ifaces, unsigned int idx, const char *name) 651 { 652 653 if (ifaces != NULL) { 654 struct if_spec spec; 655 struct interface *ifp; 656 657 if (name && if_nametospec(name, &spec) == -1) 658 return NULL; 659 660 TAILQ_FOREACH(ifp, ifaces, next) { 661 if ((name && strcmp(ifp->name, spec.devname) == 0) || 662 (!name && ifp->index == idx)) 663 return ifp; 664 } 665 } 666 667 errno = ENXIO; 668 return NULL; 669 } 670 671 struct interface * 672 if_find(struct if_head *ifaces, const char *name) 673 { 674 675 return if_findindexname(ifaces, 0, name); 676 } 677 678 struct interface * 679 if_findindex(struct if_head *ifaces, unsigned int idx) 680 { 681 682 return if_findindexname(ifaces, idx, NULL); 683 } 684 685 struct interface * 686 if_loopback(struct dhcpcd_ctx *ctx) 687 { 688 struct interface *ifp; 689 690 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 691 if (ifp->flags & IFF_LOOPBACK) 692 return ifp; 693 } 694 return NULL; 695 } 696 697 int 698 if_domtu(const struct interface *ifp, short int mtu) 699 { 700 int r; 701 struct ifreq ifr; 702 703 memset(&ifr, 0, sizeof(ifr)); 704 strlcpy(ifr.ifr_name, ifp->name, sizeof(ifr.ifr_name)); 705 ifr.ifr_mtu = mtu; 706 r = ioctl(ifp->ctx->pf_inet_fd, mtu ? SIOCSIFMTU : SIOCGIFMTU, &ifr); 707 if (r == -1) 708 return -1; 709 return ifr.ifr_mtu; 710 } 711 712 /* Interface comparer for working out ordering. */ 713 static int 714 if_cmp(const struct interface *si, const struct interface *ti) 715 { 716 #ifdef INET 717 int r; 718 #endif 719 720 /* Check active first */ 721 if (si->active > ti->active) 722 return -1; 723 if (si->active < ti->active) 724 return 1; 725 726 /* Check carrier status next */ 727 if (si->carrier > ti->carrier) 728 return -1; 729 if (si->carrier < ti->carrier) 730 return 1; 731 732 if (D_STATE_RUNNING(si) && !D_STATE_RUNNING(ti)) 733 return -1; 734 if (!D_STATE_RUNNING(si) && D_STATE_RUNNING(ti)) 735 return 1; 736 if (RS_STATE_RUNNING(si) && !RS_STATE_RUNNING(ti)) 737 return -1; 738 if (!RS_STATE_RUNNING(si) && RS_STATE_RUNNING(ti)) 739 return 1; 740 if (D6_STATE_RUNNING(si) && !D6_STATE_RUNNING(ti)) 741 return -1; 742 if (!D6_STATE_RUNNING(si) && D6_STATE_RUNNING(ti)) 743 return 1; 744 745 #ifdef INET 746 /* Special attention needed here due to states and IPv4LL. */ 747 if ((r = ipv4_ifcmp(si, ti)) != 0) 748 return r; 749 #endif 750 751 /* Finally, metric */ 752 if (si->metric < ti->metric) 753 return -1; 754 if (si->metric > ti->metric) 755 return 1; 756 return 0; 757 } 758 759 /* Sort the interfaces into a preferred order - best first, worst last. */ 760 void 761 if_sortinterfaces(struct dhcpcd_ctx *ctx) 762 { 763 struct if_head sorted; 764 struct interface *ifp, *ift; 765 766 if (ctx->ifaces == NULL || 767 (ifp = TAILQ_FIRST(ctx->ifaces)) == NULL || 768 TAILQ_NEXT(ifp, next) == NULL) 769 return; 770 771 TAILQ_INIT(&sorted); 772 TAILQ_REMOVE(ctx->ifaces, ifp, next); 773 TAILQ_INSERT_HEAD(&sorted, ifp, next); 774 while ((ifp = TAILQ_FIRST(ctx->ifaces))) { 775 TAILQ_REMOVE(ctx->ifaces, ifp, next); 776 TAILQ_FOREACH(ift, &sorted, next) { 777 if (if_cmp(ifp, ift) == -1) { 778 TAILQ_INSERT_BEFORE(ift, ifp, next); 779 break; 780 } 781 } 782 if (ift == NULL) 783 TAILQ_INSERT_TAIL(&sorted, ifp, next); 784 } 785 TAILQ_CONCAT(ctx->ifaces, &sorted, next); 786 } 787 788 int 789 xsocket(int domain, int type, int protocol) 790 { 791 int s; 792 #if !defined(HAVE_SOCK_CLOEXEC) || !defined(HAVE_SOCK_NONBLOCK) 793 int xflags, xtype = type; 794 #endif 795 796 #ifndef HAVE_SOCK_CLOEXEC 797 if (xtype & SOCK_CLOEXEC) 798 type &= ~SOCK_CLOEXEC; 799 #endif 800 #ifndef HAVE_SOCK_NONBLOCK 801 if (xtype & SOCK_NONBLOCK) 802 type &= ~SOCK_NONBLOCK; 803 #endif 804 805 if ((s = socket(domain, type, protocol)) == -1) 806 return -1; 807 808 #ifndef HAVE_SOCK_CLOEXEC 809 if ((xtype & SOCK_CLOEXEC) && ((xflags = fcntl(s, F_GETFD)) == -1 || 810 fcntl(s, F_SETFD, xflags | FD_CLOEXEC) == -1)) 811 goto out; 812 #endif 813 #ifndef HAVE_SOCK_NONBLOCK 814 if ((xtype & SOCK_NONBLOCK) && ((xflags = fcntl(s, F_GETFL)) == -1 || 815 fcntl(s, F_SETFL, xflags | O_NONBLOCK) == -1)) 816 goto out; 817 #endif 818 819 return s; 820 821 #if !defined(HAVE_SOCK_CLOEXEC) || !defined(HAVE_SOCK_NONBLOCK) 822 out: 823 close(s); 824 return -1; 825 #endif 826 } 827