contrib/dhcpcd/src/if.c

   1 /* SPDX-License-Identifier: BSD-2-Clause */
   2 /*
   3  * dhcpcd - DHCP client daemon
   4  * Copyright (c) 2006-2020 Roy Marples <roy@marples.name>
   5  * All rights reserved
   6
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/param.h>
  30 #include <sys/types.h>
  31 #include <sys/ioctl.h>
  32 #include <sys/socket.h>
  33
  34 #include <fcntl.h> /* Needs to be here for old Linux */
  35
  36 #include "config.h"
  37
  38 #include <net/if.h>
  39 #include <net/if_arp.h>
  40 #include <netinet/in.h>
  41 #ifdef AF_LINK
  42 #  include <net/if_dl.h>
  43 #  include <net/if_types.h>
  44 #  include <netinet/in_var.h>
  45 #  undef AF_PACKET      /* Newer Illumos defines this */
  46 #endif
  47 #ifdef AF_PACKET
  48 #  include <netpacket/packet.h>
  49 #endif
  50 #ifdef SIOCGIFMEDIA
  51 #  include <net/if_media.h>
  52 #endif
  53 #include <net/route.h>
  54
  55 #include <ctype.h>
  56 #include <errno.h>
  57 #include <ifaddrs.h>
  58 #include <inttypes.h>
  59 #include <fnmatch.h>
  60 #include <stddef.h>
  61 #include <stdio.h>
  62 #include <stdlib.h>
  63 #include <string.h>
  64 #include <syslog.h>
  65 #include <unistd.h>
  66
  67 #define ELOOP_QUEUE     ELOOP_IF
  68 #include "common.h"
  69 #include "eloop.h"
  70 #include "dev.h"
  71 #include "dhcp.h"
  72 #include "dhcp6.h"
  73 #include "if.h"
  74 #include "if-options.h"
  75 #include "ipv4.h"
  76 #include "ipv4ll.h"
  77 #include "ipv6nd.h"
  78 #include "logerr.h"
  79 #include "privsep.h"
  80
  81 void
  82 if_free(struct interface *ifp)
  83 {
  84
  85         if (ifp == NULL)
  86                 return;
  87 #ifdef IPV4LL
  88         ipv4ll_free(ifp);
  89 #endif
  90 #ifdef INET
  91         dhcp_free(ifp);
  92         ipv4_free(ifp);
  93 #endif
  94 #ifdef DHCP6
  95         dhcp6_free(ifp);
  96 #endif
  97 #ifdef INET6
  98         ipv6nd_free(ifp);
  99         ipv6_free(ifp);
 100 #endif
 101         rt_freeif(ifp);
 102         free_options(ifp->ctx, ifp->options);
 103         free(ifp);
 104 }
 105
 106 int
 107 if_opensockets(struct dhcpcd_ctx *ctx)
 108 {
 109
 110         if (if_opensockets_os(ctx) == -1)
 111                 return -1;
 112
 113 #ifdef IFLR_ACTIVE
 114         ctx->pf_link_fd = xsocket(PF_LINK, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 115         if (ctx->pf_link_fd == -1)
 116                 return -1;
 117 #ifdef HAVE_CAPSICUM
 118         if (ps_rights_limit_ioctl(ctx->pf_link_fd) == -1)
 119                 return -1;
 120 #endif
 121 #endif
 122
 123         /* We use this socket for some operations without INET. */
 124         ctx->pf_inet_fd = xsocket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 125         if (ctx->pf_inet_fd == -1)
 126                 return -1;
 127
 128         return 0;
 129 }
 130
 131 void
 132 if_closesockets(struct dhcpcd_ctx *ctx)
 133 {
 134
 135         if (ctx->pf_inet_fd != -1)
 136                 close(ctx->pf_inet_fd);
 137 #ifdef PF_LINK
 138         if (ctx->pf_link_fd != -1)
 139                 close(ctx->pf_link_fd);
 140 #endif
 141
 142         if (ctx->priv) {
 143                 if_closesockets_os(ctx);
 144                 free(ctx->priv);
 145         }
 146 }
 147
 148 int
 149 if_ioctl(struct dhcpcd_ctx *ctx, ioctl_request_t req, void *data, size_t len)
 150 {
 151
 152 #ifdef PRIVSEP
 153         if (ctx->options & DHCPCD_PRIVSEP)
 154                 return (int)ps_root_ioctl(ctx, req, data, len);
 155 #endif
 156         return ioctl(ctx->pf_inet_fd, req, data, len);
 157 }
 158
 159 int
 160 if_getflags(struct interface *ifp)
 161 {
 162         struct ifreq ifr = { .ifr_flags = 0 };
 163
 164         strlcpy(ifr.ifr_name, ifp->name, sizeof(ifr.ifr_name));
 165         if (ioctl(ifp->ctx->pf_inet_fd, SIOCGIFFLAGS, &ifr) == -1)
 166                 return -1;
 167         ifp->flags = (unsigned int)ifr.ifr_flags;
 168         return 0;
 169 }
 170
 171 int
 172 if_setflag(struct interface *ifp, short setflag, short unsetflag)
 173 {
 174         struct ifreq ifr = { .ifr_flags = 0 };
 175         short oflags;
 176
 177         strlcpy(ifr.ifr_name, ifp->name, sizeof(ifr.ifr_name));
 178         if (ioctl(ifp->ctx->pf_inet_fd, SIOCGIFFLAGS, &ifr) == -1)
 179                 return -1;
 180
 181         oflags = ifr.ifr_flags;
 182         ifr.ifr_flags |= setflag;
 183         ifr.ifr_flags &= (short)~unsetflag;
 184         if (ifr.ifr_flags != oflags &&
 185             if_ioctl(ifp->ctx, SIOCSIFFLAGS, &ifr, sizeof(ifr)) == -1)
 186                 return -1;
 187
 188         ifp->flags = (unsigned int)ifr.ifr_flags;
 189         return 0;
 190 }
 191
 192 int
 193 if_randomisemac(struct interface *ifp)
 194 {
 195         uint32_t randnum;
 196         size_t hwlen = ifp->hwlen, rlen = 0;
 197         uint8_t buf[HWADDR_LEN], *bp = buf, *rp = (uint8_t *)&randnum;
 198         char sbuf[HWADDR_LEN * 3];
 199         int retval;
 200
 201         if (hwlen == 0) {
 202                 errno = ENOTSUP;
 203                 return -1;
 204         }
 205         if (hwlen > sizeof(buf)) {
 206                 errno = ENOBUFS;
 207                 return -1;
 208         }
 209
 210         for (; hwlen != 0; hwlen--) {
 211                 if (rlen == 0) {
 212                         randnum = arc4random();
 213                         rp = (uint8_t *)&randnum;
 214                         rlen = sizeof(randnum);
 215                 }
 216                 *bp++ = *rp++;
 217                 rlen--;
 218         }
 219
 220         /* Unicast address and locally administered. */
 221         buf[0] &= 0xFC;
 222         buf[0] |= 0x02;
 223
 224         logdebugx("%s: hardware address randomised to %s",
 225             ifp->name,
 226             hwaddr_ntoa(buf, ifp->hwlen, sbuf, sizeof(sbuf)));
 227         retval = if_setmac(ifp, buf, ifp->hwlen);
 228         if (retval == 0)
 229                 memcpy(ifp->hwaddr, buf, ifp->hwlen);
 230         return retval;
 231 }
 232
 233 static int
 234 if_hasconf(struct dhcpcd_ctx *ctx, const char *ifname)
 235 {
 236         int i;
 237
 238         for (i = 0; i < ctx->ifcc; i++) {
 239                 if (strcmp(ctx->ifcv[i], ifname) == 0)
 240                         return 1;
 241         }
 242         return 0;
 243 }
 244
 245 void
 246 if_markaddrsstale(struct if_head *ifs)
 247 {
 248         struct interface *ifp;
 249
 250         TAILQ_FOREACH(ifp, ifs, next) {
 251 #ifdef INET
 252                 ipv4_markaddrsstale(ifp);
 253 #endif
 254 #ifdef INET6
 255                 ipv6_markaddrsstale(ifp, 0);
 256 #endif
 257         }
 258 }
 259
 260 void
 261 if_learnaddrs(struct dhcpcd_ctx *ctx, struct if_head *ifs,
 262     struct ifaddrs **ifaddrs)
 263 {
 264         struct ifaddrs *ifa;
 265         struct interface *ifp;
 266 #ifdef INET
 267         const struct sockaddr_in *addr, *net, *brd;
 268 #endif
 269 #ifdef INET6
 270         struct sockaddr_in6 *sin6, *net6;
 271 #endif
 272         int addrflags;
 273
 274         for (ifa = *ifaddrs; ifa; ifa = ifa->ifa_next) {
 275                 if (ifa->ifa_addr == NULL)
 276                         continue;
 277                 if ((ifp = if_find(ifs, ifa->ifa_name)) == NULL)
 278                         continue;
 279 #ifdef HAVE_IFADDRS_ADDRFLAGS
 280                 addrflags = (int)ifa->ifa_addrflags;
 281 #endif
 282                 switch(ifa->ifa_addr->sa_family) {
 283 #ifdef INET
 284                 case AF_INET:
 285                         addr = (void *)ifa->ifa_addr;
 286                         net = (void *)ifa->ifa_netmask;
 287                         if (ifa->ifa_flags & IFF_POINTOPOINT)
 288                                 brd = (void *)ifa->ifa_dstaddr;
 289                         else
 290                                 brd = (void *)ifa->ifa_broadaddr;
 291 #ifndef HAVE_IFADDRS_ADDRFLAGS
 292                         addrflags = if_addrflags(ifp, &addr->sin_addr,
 293                             ifa->ifa_name);
 294                         if (addrflags == -1) {
 295                                 if (errno != EEXIST && errno != EADDRNOTAVAIL) {
 296                                         char dbuf[INET_ADDRSTRLEN];
 297                                         const char *dbp;
 298
 299                                         dbp = inet_ntop(AF_INET, &addr->sin_addr,
 300                                             dbuf, sizeof(dbuf));
 301                                         logerr("%s: if_addrflags: %s%%%s",
 302                                             __func__, dbp, ifp->name);
 303                                 }
 304                                 continue;
 305                         }
 306 #endif
 307                         ipv4_handleifa(ctx, RTM_NEWADDR, ifs, ifa->ifa_name,
 308                                 &addr->sin_addr, &net->sin_addr,
 309                                 brd ? &brd->sin_addr : NULL, addrflags, 0);
 310                         break;
 311 #endif
 312 #ifdef INET6
 313                 case AF_INET6:
 314                         sin6 = (void *)ifa->ifa_addr;
 315                         net6 = (void *)ifa->ifa_netmask;
 316
 317 #ifdef __KAME__
 318                         if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr))
 319                                 /* Remove the scope from the address */
 320                                 sin6->sin6_addr.s6_addr[2] =
 321                                     sin6->sin6_addr.s6_addr[3] = '\0';
 322 #endif
 323 #ifndef HAVE_IFADDRS_ADDRFLAGS
 324                         addrflags = if_addrflags6(ifp, &sin6->sin6_addr,
 325                             ifa->ifa_name);
 326                         if (addrflags == -1) {
 327                                 if (errno != EEXIST && errno != EADDRNOTAVAIL) {
 328                                         char dbuf[INET6_ADDRSTRLEN];
 329                                         const char *dbp;
 330
 331                                         dbp = inet_ntop(AF_INET6, &sin6->sin6_addr,
 332                                             dbuf, sizeof(dbuf));
 333                                         logerr("%s: if_addrflags6: %s%%%s",
 334                                             __func__, dbp, ifp->name);
 335                                 }
 336                                 continue;
 337                         }
 338 #endif
 339                         ipv6_handleifa(ctx, RTM_NEWADDR, ifs,
 340                             ifa->ifa_name, &sin6->sin6_addr,
 341                             ipv6_prefixlen(&net6->sin6_addr), addrflags, 0);
 342                         break;
 343 #endif
 344                 }
 345         }
 346
 347 #ifdef PRIVSEP_GETIFADDRS
 348         if (IN_PRIVSEP(ctx))
 349                 free(*ifaddrs);
 350         else
 351 #endif
 352                 freeifaddrs(*ifaddrs);
 353         *ifaddrs = NULL;
 354 }
 355
 356 void
 357 if_deletestaleaddrs(struct if_head *ifs)
 358 {
 359         struct interface *ifp;
 360
 361         TAILQ_FOREACH(ifp, ifs, next) {
 362 #ifdef INET
 363                 ipv4_deletestaleaddrs(ifp);
 364 #endif
 365 #ifdef INET6
 366                 ipv6_deletestaleaddrs(ifp);
 367 #endif
 368         }
 369 }
 370
 371 bool
 372 if_valid_hwaddr(const uint8_t *hwaddr, size_t hwlen)
 373 {
 374         size_t i;
 375         bool all_zeros, all_ones;
 376
 377         all_zeros = all_ones = true;
 378         for (i = 0; i < hwlen; i++) {
 379                 if (hwaddr[i] != 0x00)
 380                         all_zeros = false;
 381                 if (hwaddr[i] != 0xff)
 382                         all_ones = false;
 383                 if (!all_zeros && !all_ones)
 384                         return true;
 385         }
 386         return false;
 387 }
 388
 389 #if defined(AF_PACKET) && !defined(AF_LINK)
 390 static unsigned int
 391 if_check_arphrd(struct interface *ifp, unsigned int active, bool if_noconf)
 392 {
 393
 394         switch(ifp->hwtype) {
 395         case ARPHRD_ETHER:      /* FALLTHROUGH */
 396         case ARPHRD_IEEE1394:   /* FALLTHROUGH */
 397         case ARPHRD_INFINIBAND: /* FALLTHROUGH */
 398         case ARPHRD_NONE:       /* FALLTHROUGH */
 399                 break;
 400         case ARPHRD_LOOPBACK:
 401         case ARPHRD_PPP:
 402                 if (if_noconf) {
 403                         logdebugx("%s: ignoring due to interface type and"
 404                             " no config",
 405                             ifp->name);
 406                         active = IF_INACTIVE;
 407                 }
 408                 break;
 409         default:
 410                 if (if_noconf)
 411                         active = IF_INACTIVE;
 412                 if (active)
 413                         logwarnx("%s: unsupported interface type 0x%.2x",
 414                             ifp->name, ifp->hwtype);
 415                 break;
 416         }
 417
 418         return active;
 419 }
 420 #endif
 421
 422 struct if_head *
 423 if_discover(struct dhcpcd_ctx *ctx, struct ifaddrs **ifaddrs,
 424     int argc, char * const *argv)
 425 {
 426         struct ifaddrs *ifa;
 427         int i;
 428         unsigned int active;
 429         struct if_head *ifs;
 430         struct interface *ifp;
 431         struct if_spec spec;
 432         bool if_noconf;
 433 #ifdef AF_LINK
 434         const struct sockaddr_dl *sdl;
 435 #ifdef IFLR_ACTIVE
 436         struct if_laddrreq iflr = { .flags = IFLR_PREFIX };
 437 #endif
 438 #elif defined(AF_PACKET)
 439         const struct sockaddr_ll *sll;
 440 #endif
 441 #if defined(SIOCGIFPRIORITY)
 442         struct ifreq ifr;
 443 #endif
 444
 445         if ((ifs = malloc(sizeof(*ifs))) == NULL) {
 446                 logerr(__func__);
 447                 return NULL;
 448         }
 449         TAILQ_INIT(ifs);
 450
 451 #ifdef PRIVSEP_GETIFADDRS
 452         if (ctx->options & DHCPCD_PRIVSEP) {
 453                 if (ps_root_getifaddrs(ctx, ifaddrs) == -1) {
 454                         logerr("ps_root_getifaddrs");
 455                         free(ifs);
 456                         return NULL;
 457                 }
 458         } else
 459 #endif
 460         if (getifaddrs(ifaddrs) == -1) {
 461                 logerr("getifaddrs");
 462                 free(ifs);
 463                 return NULL;
 464         }
 465
 466         for (ifa = *ifaddrs; ifa; ifa = ifa->ifa_next) {
 467                 if (ifa->ifa_addr != NULL) {
 468 #ifdef AF_LINK
 469                         if (ifa->ifa_addr->sa_family != AF_LINK)
 470                                 continue;
 471 #elif defined(AF_PACKET)
 472                         if (ifa->ifa_addr->sa_family != AF_PACKET)
 473                                 continue;
 474 #endif
 475                 }
 476                 if (if_nametospec(ifa->ifa_name, &spec) != 0)
 477                         continue;
 478
 479                 /* It's possible for an interface to have >1 AF_LINK.
 480                  * For our purposes, we use the first one. */
 481                 TAILQ_FOREACH(ifp, ifs, next) {
 482                         if (strcmp(ifp->name, spec.devname) == 0)
 483                                 break;
 484                 }
 485                 if (ifp)
 486                         continue;
 487
 488                 if (argc > 0) {
 489                         for (i = 0; i < argc; i++) {
 490                                 if (strcmp(argv[i], spec.devname) == 0)
 491                                         break;
 492                         }
 493                         active = (i == argc) ? IF_INACTIVE : IF_ACTIVE_USER;
 494                 } else {
 495                         /* -1 means we're discovering against a specific
 496                          * interface, but we still need the below rules
 497                          * to apply. */
 498                         if (argc == -1 && strcmp(argv[0], spec.devname) != 0)
 499                                 continue;
 500                         active = ctx->options & DHCPCD_INACTIVE ?
 501                             IF_INACTIVE: IF_ACTIVE_USER;
 502                 }
 503
 504                 for (i = 0; i < ctx->ifdc; i++)
 505                         if (fnmatch(ctx->ifdv[i], spec.devname, 0) == 0)
 506                                 break;
 507                 if (i < ctx->ifdc)
 508                         active = IF_INACTIVE;
 509                 for (i = 0; i < ctx->ifc; i++)
 510                         if (fnmatch(ctx->ifv[i], spec.devname, 0) == 0)
 511                                 break;
 512                 if (ctx->ifc && i == ctx->ifc)
 513                         active = IF_INACTIVE;
 514                 for (i = 0; i < ctx->ifac; i++)
 515                         if (fnmatch(ctx->ifav[i], spec.devname, 0) == 0)
 516                                 break;
 517                 if (ctx->ifac && i == ctx->ifac)
 518                         active = IF_INACTIVE;
 519
 520 #ifdef PLUGIN_DEV
 521                 /* Ensure that the interface name has settled */
 522                 if (!dev_initialized(ctx, spec.devname))
 523                         continue;
 524 #endif
 525
 526                 if (if_vimaster(ctx, spec.devname) == 1) {
 527                         int loglevel = argc != 0 ? LOG_ERR : LOG_DEBUG;
 528                         logmessage(loglevel,
 529                             "%s: is a Virtual Interface Master, skipping",
 530                             spec.devname);
 531                         continue;
 532                 }
 533
 534                 if_noconf = ((argc == 0 || argc == -1) && ctx->ifac == 0 &&
 535                     !if_hasconf(ctx, spec.devname));
 536
 537                 /* Don't allow some reserved interface names unless explicit. */
 538                 if (if_noconf && if_ignore(ctx, spec.devname))
 539                         active = IF_INACTIVE;
 540
 541                 ifp = calloc(1, sizeof(*ifp));
 542                 if (ifp == NULL) {
 543                         logerr(__func__);
 544                         break;
 545                 }
 546                 ifp->ctx = ctx;
 547                 strlcpy(ifp->name, spec.devname, sizeof(ifp->name));
 548                 ifp->flags = ifa->ifa_flags;
 549
 550                 if (ifa->ifa_addr != NULL) {
 551 #ifdef AF_LINK
 552                         sdl = (const void *)ifa->ifa_addr;
 553
 554 #ifdef IFLR_ACTIVE
 555                         /* We need to check for active address */
 556                         strlcpy(iflr.iflr_name, ifp->name,
 557                             sizeof(iflr.iflr_name));
 558                         memcpy(&iflr.addr, ifa->ifa_addr,
 559                             MIN(ifa->ifa_addr->sa_len, sizeof(iflr.addr)));
 560                         iflr.flags = IFLR_PREFIX;
 561                         iflr.prefixlen = (unsigned int)sdl->sdl_alen * NBBY;
 562                         if (ioctl(ctx->pf_link_fd, SIOCGLIFADDR, &iflr) == -1 ||
 563                             !(iflr.flags & IFLR_ACTIVE))
 564                         {
 565                                 if_free(ifp);
 566                                 continue;
 567                         }
 568 #endif
 569
 570                         ifp->index = sdl->sdl_index;
 571                         switch(sdl->sdl_type) {
 572 #ifdef IFT_BRIDGE
 573                         case IFT_BRIDGE: /* FALLTHROUGH */
 574 #endif
 575 #ifdef IFT_PROPVIRTUAL
 576                         case IFT_PROPVIRTUAL: /* FALLTHROUGH */
 577 #endif
 578 #ifdef IFT_TUNNEL
 579                         case IFT_TUNNEL: /* FALLTHROUGH */
 580 #endif
 581                         case IFT_LOOP: /* FALLTHROUGH */
 582                         case IFT_PPP:
 583                                 /* Don't allow unless explicit */
 584                                 if (if_noconf) {
 585                                         logdebugx("%s: ignoring due to"
 586                                             " interface type and"
 587                                             " no config",
 588                                             ifp->name);
 589                                         active = IF_INACTIVE;
 590                                 }
 591                                 __fallthrough; /* appease gcc */
 592                                 /* FALLTHROUGH */
 593 #ifdef IFT_L2VLAN
 594                         case IFT_L2VLAN: /* FALLTHROUGH */
 595 #endif
 596 #ifdef IFT_L3IPVLAN
 597                         case IFT_L3IPVLAN: /* FALLTHROUGH */
 598 #endif
 599                         case IFT_ETHER:
 600                                 ifp->hwtype = ARPHRD_ETHER;
 601                                 break;
 602 #ifdef IFT_IEEE1394
 603                         case IFT_IEEE1394:
 604                                 ifp->hwtype = ARPHRD_IEEE1394;
 605                                 break;
 606 #endif
 607 #ifdef IFT_INFINIBAND
 608                         case IFT_INFINIBAND:
 609                                 ifp->hwtype = ARPHRD_INFINIBAND;
 610                                 break;
 611 #endif
 612                         default:
 613                                 /* Don't allow unless explicit */
 614                                 if (if_noconf)
 615                                         active = IF_INACTIVE;
 616                                 if (active)
 617                                         logwarnx("%s: unsupported"
 618                                             " interface type 0x%.2x",
 619                                             ifp->name, sdl->sdl_type);
 620                                 /* Pretend it's ethernet */
 621                                 ifp->hwtype = ARPHRD_ETHER;
 622                                 break;
 623                         }
 624                         ifp->hwlen = sdl->sdl_alen;
 625                         memcpy(ifp->hwaddr, CLLADDR(sdl), ifp->hwlen);
 626 #elif defined(AF_PACKET)
 627                         sll = (const void *)ifa->ifa_addr;
 628                         ifp->index = (unsigned int)sll->sll_ifindex;
 629                         ifp->hwtype = sll->sll_hatype;
 630                         ifp->hwlen = sll->sll_halen;
 631                         if (ifp->hwlen != 0)
 632                                 memcpy(ifp->hwaddr, sll->sll_addr, ifp->hwlen);
 633                         active = if_check_arphrd(ifp, active, if_noconf);
 634 #endif
 635                 }
 636 #ifdef __linux__
 637                 else {
 638                         struct ifreq ifr = { .ifr_flags = 0 };
 639
 640                         /* This is a huge bug in getifaddrs(3) as there
 641                          * is no reason why this can't be returned in
 642                          * ifa_addr. */
 643                         strlcpy(ifr.ifr_name, ifa->ifa_name,
 644                             sizeof(ifr.ifr_name));
 645                         if (ioctl(ctx->pf_inet_fd, SIOCGIFHWADDR, &ifr) == -1)
 646                                 logerr("%s: SIOCGIFHWADDR", ifa->ifa_name);
 647                         ifp->hwtype = ifr.ifr_hwaddr.sa_family;
 648                         if (ioctl(ctx->pf_inet_fd, SIOCGIFINDEX, &ifr) == -1)
 649                                 logerr("%s: SIOCGIFINDEX", ifa->ifa_name);
 650                         ifp->index = (unsigned int)ifr.ifr_ifindex;
 651                         if_check_arphrd(ifp, active, if_noconf);
 652                 }
 653 #endif
 654
 655                 if (!(ctx->options & (DHCPCD_DUMPLEASE | DHCPCD_TEST))) {
 656                         /* Handle any platform init for the interface */
 657                         if (active != IF_INACTIVE && if_init(ifp) == -1) {
 658                                 logerr("%s: if_init", ifp->name);
 659                                 if_free(ifp);
 660                                 continue;
 661                         }
 662                 }
 663
 664                 ifp->vlanid = if_vlanid(ifp);
 665
 666 #ifdef SIOCGIFPRIORITY
 667                 /* Respect the interface priority */
 668                 memset(&ifr, 0, sizeof(ifr));
 669                 strlcpy(ifr.ifr_name, ifp->name, sizeof(ifr.ifr_name));
 670                 if (pioctl(ctx, SIOCGIFPRIORITY, &ifr, sizeof(ifr)) == 0)
 671                         ifp->metric = (unsigned int)ifr.ifr_metric;
 672                 if_getssid(ifp);
 673 #else
 674                 /* We reserve the 100 range for virtual interfaces, if and when
 675                  * we can work them out. */
 676                 ifp->metric = 200 + ifp->index;
 677                 if (if_getssid(ifp) != -1) {
 678                         ifp->wireless = true;
 679                         ifp->metric += 100;
 680                 }
 681 #endif
 682
 683                 ifp->active = active;
 684                 if (ifp->active)
 685                         ifp->carrier = if_carrier(ifp);
 686                 else
 687                         ifp->carrier = LINK_UNKNOWN;
 688                 TAILQ_INSERT_TAIL(ifs, ifp, next);
 689         }
 690
 691         return ifs;
 692 }
 693
 694 static void
 695 if_poll(void *arg)
 696 {
 697         struct interface *ifp = arg;
 698         unsigned int flags = ifp->flags;
 699         int carrier;
 700
 701         carrier = if_carrier(ifp); /* if_carrier will update ifp->flags */
 702         if (ifp->carrier != carrier || ifp->flags != flags)
 703                 dhcpcd_handlecarrier(ifp->ctx, carrier, ifp->flags, ifp->name);
 704
 705         if (ifp->options->poll != 0 || ifp->carrier != LINK_UP)
 706                 if_pollinit(ifp);
 707 }
 708
 709 int
 710 if_pollinit(struct interface *ifp)
 711 {
 712         unsigned long msec;
 713
 714         msec = ifp->options->poll != 0 ? ifp->options->poll : IF_POLL_UP;
 715         return eloop_timeout_add_msec(ifp->ctx->eloop, msec, if_poll, ifp);
 716 }
 717
 718 /*
 719  * eth0.100:2 OR eth0i100:2 (seems to be NetBSD xvif(4) only)
 720  *
 721  * drvname == eth
 722  * devname == eth0.100 OR eth0i100
 723  * ppa = 0
 724  * lun = 2
 725  */
 726 int
 727 if_nametospec(const char *ifname, struct if_spec *spec)
 728 {
 729         char *ep, *pp;
 730         int e;
 731
 732         if (ifname == NULL || *ifname == '\0' ||
 733             strlcpy(spec->ifname, ifname, sizeof(spec->ifname)) >=
 734             sizeof(spec->ifname) ||
 735             strlcpy(spec->drvname, ifname, sizeof(spec->drvname)) >=
 736             sizeof(spec->drvname))
 737         {
 738                 errno = EINVAL;
 739                 return -1;
 740         }
 741
 742         /* :N is an alias */
 743         ep = strchr(spec->drvname, ':');
 744         if (ep) {
 745                 spec->lun = (int)strtoi(ep + 1, NULL, 10, 0, INT_MAX, &e);
 746                 if (e != 0) {
 747                         errno = e;
 748                         return -1;
 749                 }
 750                 *ep = '\0';
 751 #ifdef __sun
 752                 ep--;
 753 #endif
 754         } else {
 755                 spec->lun = -1;
 756 #ifdef __sun
 757                 ep = spec->drvname + strlen(spec->drvname) - 1;
 758 #endif
 759         }
 760
 761         strlcpy(spec->devname, spec->drvname, sizeof(spec->devname));
 762 #ifdef __sun
 763         /* Solaris has numbers in the driver name, such as e1000g */
 764         while (ep > spec->drvname && isdigit((int)*ep))
 765                 ep--;
 766         if (*ep++ == ':') {
 767                 errno = EINVAL;
 768                 return -1;
 769         }
 770 #else
 771         /* BSD and Linux no not have numbers in the driver name */
 772         for (ep = spec->drvname; *ep != '\0' && !isdigit((int)*ep); ep++) {
 773                 if (*ep == ':') {
 774                         errno = EINVAL;
 775                         return -1;
 776                 }
 777         }
 778 #endif
 779         spec->ppa = (int)strtoi(ep, &pp, 10, 0, INT_MAX, &e);
 780         *ep = '\0';
 781
 782 #ifndef __sun
 783         /*
 784          * . is used for VLAN style names
 785          * i is used on NetBSD for xvif interfaces
 786          */
 787         if (pp != NULL && (*pp == '.' || *pp == 'i')) {
 788                 spec->vlid = (int)strtoi(pp + 1, NULL, 10, 0, INT_MAX, &e);
 789                 if (e)
 790                         spec->vlid = -1;
 791         } else
 792 #endif
 793                 spec->vlid = -1;
 794
 795         return 0;
 796 }
 797
 798 static struct interface *
 799 if_findindexname(struct if_head *ifaces, unsigned int idx, const char *name)
 800 {
 801
 802         if (ifaces != NULL) {
 803                 struct if_spec spec;
 804                 struct interface *ifp;
 805
 806                 if (name && if_nametospec(name, &spec) == -1)
 807                         return NULL;
 808
 809                 TAILQ_FOREACH(ifp, ifaces, next) {
 810                         if ((name && strcmp(ifp->name, spec.devname) == 0) ||
 811                             (!name && ifp->index == idx))
 812                                 return ifp;
 813                 }
 814         }
 815
 816         errno = ENXIO;
 817         return NULL;
 818 }
 819
 820 struct interface *
 821 if_find(struct if_head *ifaces, const char *name)
 822 {
 823
 824         return if_findindexname(ifaces, 0, name);
 825 }
 826
 827 struct interface *
 828 if_findindex(struct if_head *ifaces, unsigned int idx)
 829 {
 830
 831         return if_findindexname(ifaces, idx, NULL);
 832 }
 833
 834 struct interface *
 835 if_loopback(struct dhcpcd_ctx *ctx)
 836 {
 837         struct interface *ifp;
 838
 839         TAILQ_FOREACH(ifp, ctx->ifaces, next) {
 840                 if (ifp->flags & IFF_LOOPBACK)
 841                         return ifp;
 842         }
 843         return NULL;
 844 }
 845
 846 int
 847 if_domtu(const struct interface *ifp, short int mtu)
 848 {
 849         int r;
 850         struct ifreq ifr;
 851
 852 #ifdef __sun
 853         if (mtu == 0)
 854                 return if_mtu_os(ifp);
 855 #endif
 856
 857         memset(&ifr, 0, sizeof(ifr));
 858         strlcpy(ifr.ifr_name, ifp->name, sizeof(ifr.ifr_name));
 859         ifr.ifr_mtu = mtu;
 860         if (mtu != 0)
 861                 r = if_ioctl(ifp->ctx, SIOCSIFMTU, &ifr, sizeof(ifr));
 862         else
 863                 r = pioctl(ifp->ctx, SIOCGIFMTU, &ifr, sizeof(ifr));
 864
 865         if (r == -1)
 866                 return -1;
 867         return ifr.ifr_mtu;
 868 }
 869
 870 #ifdef ALIAS_ADDR
 871 int
 872 if_makealias(char *alias, size_t alias_len, const char *ifname, int lun)
 873 {
 874
 875         if (lun == 0)
 876                 return strlcpy(alias, ifname, alias_len);
 877         return snprintf(alias, alias_len, "%s:%u", ifname, lun);
 878 }
 879 #endif
 880
 881 struct interface *
 882 if_findifpfromcmsg(struct dhcpcd_ctx *ctx, struct msghdr *msg, int *hoplimit)
 883 {
 884         struct cmsghdr *cm;
 885         unsigned int ifindex = 0;
 886         struct interface *ifp;
 887 #ifdef INET
 888 #ifdef IP_RECVIF
 889         struct sockaddr_dl sdl;
 890 #else
 891         struct in_pktinfo ipi;
 892 #endif
 893 #endif
 894 #ifdef INET6
 895         struct in6_pktinfo ipi6;
 896 #else
 897         UNUSED(hoplimit);
 898 #endif
 899
 900         for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(msg);
 901              cm;
 902              cm = (struct cmsghdr *)CMSG_NXTHDR(msg, cm))
 903         {
 904 #ifdef INET
 905                 if (cm->cmsg_level == IPPROTO_IP) {
 906                         switch(cm->cmsg_type) {
 907 #ifdef IP_RECVIF
 908                         case IP_RECVIF:
 909                                 if (cm->cmsg_len <
 910                                     offsetof(struct sockaddr_dl, sdl_index) +
 911                                     sizeof(sdl.sdl_index))
 912                                         continue;
 913                                 memcpy(&sdl, CMSG_DATA(cm),
 914                                     MIN(sizeof(sdl), cm->cmsg_len));
 915                                 ifindex = sdl.sdl_index;
 916                                 break;
 917 #else
 918                         case IP_PKTINFO:
 919                                 if (cm->cmsg_len != CMSG_LEN(sizeof(ipi)))
 920                                         continue;
 921                                 memcpy(&ipi, CMSG_DATA(cm), sizeof(ipi));
 922                                 ifindex = (unsigned int)ipi.ipi_ifindex;
 923                                 break;
 924 #endif
 925                         }
 926                 }
 927 #endif
 928 #ifdef INET6
 929                 if (cm->cmsg_level == IPPROTO_IPV6) {
 930                         switch(cm->cmsg_type) {
 931                         case IPV6_PKTINFO:
 932                                 if (cm->cmsg_len != CMSG_LEN(sizeof(ipi6)))
 933                                         continue;
 934                                 memcpy(&ipi6, CMSG_DATA(cm), sizeof(ipi6));
 935                                 ifindex = (unsigned int)ipi6.ipi6_ifindex;
 936                                 break;
 937                         case IPV6_HOPLIMIT:
 938                                 if (cm->cmsg_len != CMSG_LEN(sizeof(int)))
 939                                         continue;
 940                                 if (hoplimit == NULL)
 941                                         break;
 942                                 memcpy(hoplimit, CMSG_DATA(cm), sizeof(int));
 943                                 break;
 944                         }
 945                 }
 946 #endif
 947         }
 948
 949         /* Find the receiving interface */
 950         TAILQ_FOREACH(ifp, ctx->ifaces, next) {
 951                 if (ifp->index == ifindex)
 952                         break;
 953         }
 954         if (ifp == NULL)
 955                 errno = ESRCH;
 956         return ifp;
 957 }
 958
 959 int
 960 xsocket(int domain, int type, int protocol)
 961 {
 962         int s;
 963 #if !defined(HAVE_SOCK_CLOEXEC) || !defined(HAVE_SOCK_NONBLOCK)
 964         int xflags, xtype = type;
 965 #endif
 966
 967 #ifndef HAVE_SOCK_CLOEXEC
 968         if (xtype & SOCK_CLOEXEC)
 969                 type &= ~SOCK_CLOEXEC;
 970 #endif
 971 #ifndef HAVE_SOCK_NONBLOCK
 972         if (xtype & SOCK_NONBLOCK)
 973                 type &= ~SOCK_NONBLOCK;
 974 #endif
 975
 976         if ((s = socket(domain, type, protocol)) == -1)
 977                 return -1;
 978
 979 #ifndef HAVE_SOCK_CLOEXEC
 980         if ((xtype & SOCK_CLOEXEC) && ((xflags = fcntl(s, F_GETFD)) == -1 ||
 981             fcntl(s, F_SETFD, xflags | FD_CLOEXEC) == -1))
 982                 goto out;
 983 #endif
 984 #ifndef HAVE_SOCK_NONBLOCK
 985         if ((xtype & SOCK_NONBLOCK) && ((xflags = fcntl(s, F_GETFL)) == -1 ||
 986             fcntl(s, F_SETFL, xflags | O_NONBLOCK) == -1))
 987                 goto out;
 988 #endif
 989
 990         return s;
 991
 992 #if !defined(HAVE_SOCK_CLOEXEC) || !defined(HAVE_SOCK_NONBLOCK)
 993 out:
 994         close(s);
 995         return -1;
 996 #endif
 997 }
 998
 999 int
1000 xsocketpair(int domain, int type, int protocol, int fd[2])
1001 {
1002         int s;
1003 #if !defined(HAVE_SOCK_CLOEXEC) || !defined(HAVE_SOCK_NONBLOCK)
1004         int xflags, xtype = type;
1005 #endif
1006
1007 #ifndef HAVE_SOCK_CLOEXEC
1008         if (xtype & SOCK_CLOEXEC)
1009                 type &= ~SOCK_CLOEXEC;
1010 #endif
1011 #ifndef HAVE_SOCK_NONBLOCK
1012         if (xtype & SOCK_NONBLOCK)
1013                 type &= ~SOCK_NONBLOCK;
1014 #endif
1015
1016         if ((s = socketpair(domain, type, protocol, fd)) == -1)
1017                 return -1;
1018
1019 #ifndef HAVE_SOCK_CLOEXEC
1020         if ((xtype & SOCK_CLOEXEC) && ((xflags = fcntl(fd[0], F_GETFD)) == -1 ||
1021             fcntl(fd[0], F_SETFD, xflags | FD_CLOEXEC) == -1))
1022                 goto out;
1023         if ((xtype & SOCK_CLOEXEC) && ((xflags = fcntl(fd[1], F_GETFD)) == -1 ||
1024             fcntl(fd[1], F_SETFD, xflags | FD_CLOEXEC) == -1))
1025                 goto out;
1026 #endif
1027 #ifndef HAVE_SOCK_NONBLOCK
1028         if ((xtype & SOCK_NONBLOCK) && ((xflags = fcntl(fd[0], F_GETFL)) == -1 ||
1029             fcntl(fd[0], F_SETFL, xflags | O_NONBLOCK) == -1))
1030                 goto out;
1031         if ((xtype & SOCK_NONBLOCK) && ((xflags = fcntl(fd[1], F_GETFL)) == -1 ||
1032             fcntl(fd[1], F_SETFL, xflags | O_NONBLOCK) == -1))
1033                 goto out;
1034 #endif
1035
1036         return s;
1037
1038 #if !defined(HAVE_SOCK_CLOEXEC) || !defined(HAVE_SOCK_NONBLOCK)
1039 out:
1040         close(fd[0]);
1041         close(fd[1]);
1042         return -1;
1043 #endif
1044 }