src/ipv4.c

   1 /* SPDX-License-Identifier: BSD-2-Clause */
   2 /*
   3  * dhcpcd - DHCP client daemon
   4  * Copyright (c) 2006-2021 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/socket.h>
  30 #include <sys/types.h>
  31
  32 #include <arpa/inet.h>
  33 #include <net/if.h>
  34 #include <net/route.h>
  35 #include <netinet/if_ether.h>
  36 #include <netinet/in.h>
  37
  38 #include <assert.h>
  39 #include <ctype.h>
  40 #include <errno.h>
  41 #include <stdbool.h>
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44 #include <string.h>
  45 #include <unistd.h>
  46
  47 #include "config.h"
  48 #include "arp.h"
  49 #include "common.h"
  50 #include "dhcpcd.h"
  51 #include "dhcp.h"
  52 #include "eloop.h"
  53 #include "if.h"
  54 #include "if-options.h"
  55 #include "ipv4.h"
  56 #include "ipv4ll.h"
  57 #include "logerr.h"
  58 #include "route.h"
  59 #include "script.h"
  60 #include "sa.h"
  61
  62 #define IPV4_LOOPBACK_ROUTE
  63 #if defined(__linux__) || defined(__sun) || (defined(BSD) && defined(RTF_LOCAL))
  64 /* Linux has had loopback routes in the local table since 2.2
  65  * Solaris does not seem to support loopback routes. */
  66 #undef IPV4_LOOPBACK_ROUTE
  67 #endif
  68
  69 uint8_t
  70 inet_ntocidr(struct in_addr address)
  71 {
  72         uint8_t cidr = 0;
  73         uint32_t mask = htonl(address.s_addr);
  74
  75         while (mask) {
  76                 cidr++;
  77                 mask <<= 1;
  78         }
  79         return cidr;
  80 }
  81
  82 int
  83 inet_cidrtoaddr(int cidr, struct in_addr *addr)
  84 {
  85         int ocets;
  86
  87         if (cidr < 1 || cidr > 32) {
  88                 errno = EINVAL;
  89                 return -1;
  90         }
  91         ocets = (cidr + 7) / NBBY;
  92
  93         addr->s_addr = 0;
  94         if (ocets > 0) {
  95                 memset(&addr->s_addr, 255, (size_t)ocets - 1);
  96                 memset((unsigned char *)&addr->s_addr + (ocets - 1),
  97                     (256 - (1 << (32 - cidr) % NBBY)), 1);
  98         }
  99
 100         return 0;
 101 }
 102
 103 uint32_t
 104 ipv4_getnetmask(uint32_t addr)
 105 {
 106         uint32_t dst;
 107
 108         if (addr == 0)
 109                 return 0;
 110
 111         dst = htonl(addr);
 112         if (IN_CLASSA(dst))
 113                 return ntohl(IN_CLASSA_NET);
 114         if (IN_CLASSB(dst))
 115                 return ntohl(IN_CLASSB_NET);
 116         if (IN_CLASSC(dst))
 117                 return ntohl(IN_CLASSC_NET);
 118
 119         return 0;
 120 }
 121
 122 struct ipv4_addr *
 123 ipv4_iffindaddr(struct interface *ifp,
 124     const struct in_addr *addr, const struct in_addr *mask)
 125 {
 126         struct ipv4_state *state;
 127         struct ipv4_addr *ap;
 128
 129         state = IPV4_STATE(ifp);
 130         if (state) {
 131                 TAILQ_FOREACH(ap, &state->addrs, next) {
 132                         if ((addr == NULL || ap->addr.s_addr == addr->s_addr) &&
 133                             (mask == NULL || ap->mask.s_addr == mask->s_addr))
 134                                 return ap;
 135                 }
 136         }
 137         return NULL;
 138 }
 139
 140 struct ipv4_addr *
 141 ipv4_iffindlladdr(struct interface *ifp)
 142 {
 143         struct ipv4_state *state;
 144         struct ipv4_addr *ap;
 145
 146         state = IPV4_STATE(ifp);
 147         if (state) {
 148                 TAILQ_FOREACH(ap, &state->addrs, next) {
 149                         if (IN_LINKLOCAL(ntohl(ap->addr.s_addr)))
 150                                 return ap;
 151                 }
 152         }
 153         return NULL;
 154 }
 155
 156 static struct ipv4_addr *
 157 ipv4_iffindmaskaddr(struct interface *ifp, const struct in_addr *addr)
 158 {
 159         struct ipv4_state *state;
 160         struct ipv4_addr *ap;
 161
 162         state = IPV4_STATE(ifp);
 163         if (state) {
 164                 TAILQ_FOREACH (ap, &state->addrs, next) {
 165                         if ((ap->addr.s_addr & ap->mask.s_addr) ==
 166                             (addr->s_addr & ap->mask.s_addr))
 167                                 return ap;
 168                 }
 169         }
 170         return NULL;
 171 }
 172
 173 static struct ipv4_addr *
 174 ipv4_iffindmaskbrd(struct interface *ifp, const struct in_addr *addr)
 175 {
 176         struct ipv4_state *state;
 177         struct ipv4_addr *ap;
 178
 179         state = IPV4_STATE(ifp);
 180         if (state) {
 181                 TAILQ_FOREACH (ap, &state->addrs, next) {
 182                         if ((ap->brd.s_addr & ap->mask.s_addr) ==
 183                             (addr->s_addr & ap->mask.s_addr))
 184                                 return ap;
 185                 }
 186         }
 187         return NULL;
 188 }
 189
 190 struct ipv4_addr *
 191 ipv4_findaddr(struct dhcpcd_ctx *ctx, const struct in_addr *addr)
 192 {
 193         struct interface *ifp;
 194         struct ipv4_addr *ap;
 195
 196         TAILQ_FOREACH(ifp, ctx->ifaces, next) {
 197                 ap = ipv4_iffindaddr(ifp, addr, NULL);
 198                 if (ap)
 199                         return ap;
 200         }
 201         return NULL;
 202 }
 203
 204 struct ipv4_addr *
 205 ipv4_findmaskaddr(struct dhcpcd_ctx *ctx, const struct in_addr *addr)
 206 {
 207         struct interface *ifp;
 208         struct ipv4_addr *ap;
 209
 210         TAILQ_FOREACH(ifp, ctx->ifaces, next) {
 211                 ap = ipv4_iffindmaskaddr(ifp, addr);
 212                 if (ap)
 213                         return ap;
 214         }
 215         return NULL;
 216 }
 217
 218 struct ipv4_addr *
 219 ipv4_findmaskbrd(struct dhcpcd_ctx *ctx, const struct in_addr *addr)
 220 {
 221         struct interface *ifp;
 222         struct ipv4_addr *ap;
 223
 224         TAILQ_FOREACH(ifp, ctx->ifaces, next) {
 225                 ap = ipv4_iffindmaskbrd(ifp, addr);
 226                 if (ap)
 227                         return ap;
 228         }
 229         return NULL;
 230 }
 231
 232 int
 233 ipv4_hasaddr(const struct interface *ifp)
 234 {
 235         const struct dhcp_state *dstate;
 236
 237 #ifdef IPV4LL
 238         if (IPV4LL_STATE_RUNNING(ifp))
 239                 return 1;
 240 #endif
 241
 242         dstate = D_CSTATE(ifp);
 243         return (dstate &&
 244             dstate->added == STATE_ADDED &&
 245             dstate->addr != NULL);
 246 }
 247
 248 /* Interface comparer for working out ordering. */
 249 int
 250 ipv4_ifcmp(const struct interface *si, const struct interface *ti)
 251 {
 252         const struct dhcp_state *sis, *tis;
 253
 254         sis = D_CSTATE(si);
 255         tis = D_CSTATE(ti);
 256         if (sis && !tis)
 257                 return -1;
 258         if (!sis && tis)
 259                 return 1;
 260         if (!sis && !tis)
 261                 return 0;
 262         /* If one has a lease and the other not, it takes precedence. */
 263         if (sis->new && !tis->new)
 264                 return -1;
 265         if (!sis->new && tis->new)
 266                 return 1;
 267         /* Always prefer proper leases */
 268         if (!(sis->added & STATE_FAKE) && (tis->added & STATE_FAKE))
 269                 return -1;
 270         if ((sis->added & STATE_FAKE) && !(tis->added & STATE_FAKE))
 271                 return 1;
 272         /* If we are either, they neither have a lease, or they both have.
 273          * We need to check for IPv4LL and make it non-preferred. */
 274         if (sis->new && tis->new) {
 275                 if (IS_DHCP(sis->new) && !IS_DHCP(tis->new))
 276                         return -1;
 277                 if (!IS_DHCP(sis->new) && IS_DHCP(tis->new))
 278                         return 1;
 279         }
 280         return 0;
 281 }
 282
 283 static int
 284 inet_dhcproutes(rb_tree_t *routes, struct interface *ifp, bool *have_default)
 285 {
 286         const struct dhcp_state *state;
 287         rb_tree_t nroutes;
 288         struct rt *rt, *r = NULL;
 289         struct in_addr in;
 290         uint16_t mtu;
 291         int n;
 292
 293         state = D_CSTATE(ifp);
 294         if (state == NULL || state->state != DHS_BOUND || !state->added)
 295                 return 0;
 296
 297         /* An address does have to exist. */
 298         assert(state->addr);
 299
 300         rb_tree_init(&nroutes, &rt_compare_proto_ops);
 301
 302         /* First, add a subnet route. */
 303         if (state->addr->mask.s_addr != INADDR_ANY
 304 #ifndef BSD
 305             /* BSD adds a route in this instance */
 306             && state->addr->mask.s_addr != INADDR_BROADCAST
 307 #endif
 308         ) {
 309                 if ((rt = rt_new(ifp)) == NULL)
 310                         return -1;
 311                 rt->rt_dflags |= RTDF_IFA_ROUTE;
 312                 in.s_addr = state->addr->addr.s_addr & state->addr->mask.s_addr;
 313                 sa_in_init(&rt->rt_dest, &in);
 314                 in.s_addr = state->addr->mask.s_addr;
 315                 sa_in_init(&rt->rt_netmask, &in);
 316                 //in.s_addr = INADDR_ANY;
 317                 //sa_in_init(&rt->rt_gateway, &in);
 318                 rt->rt_gateway.sa_family = AF_UNSPEC;
 319                 rt_proto_add(&nroutes, rt);
 320         }
 321
 322         /* If any set routes, grab them, otherwise DHCP routes. */
 323         if (RB_TREE_MIN(&ifp->options->routes)) {
 324                 RB_TREE_FOREACH(r, &ifp->options->routes) {
 325                         if (sa_is_unspecified(&r->rt_gateway))
 326                                 break;
 327                         if ((rt = rt_new0(ifp->ctx)) == NULL)
 328                                 return -1;
 329                         memcpy(rt, r, sizeof(*rt));
 330                         rt_setif(rt, ifp);
 331                         rt->rt_dflags = RTDF_STATIC;
 332                         rt_proto_add(&nroutes, rt);
 333                 }
 334         } else {
 335                 if (dhcp_get_routes(&nroutes, ifp) == -1)
 336                         return -1;
 337         }
 338
 339         /* If configured, install a gateway to the desintion
 340          * for P2P interfaces. */
 341         if (ifp->flags & IFF_POINTOPOINT &&
 342             has_option_mask(ifp->options->dstmask, DHO_ROUTER))
 343         {
 344                 if ((rt = rt_new(ifp)) == NULL)
 345                         return -1;
 346                 in.s_addr = INADDR_ANY;
 347                 sa_in_init(&rt->rt_dest, &in);
 348                 sa_in_init(&rt->rt_netmask, &in);
 349                 sa_in_init(&rt->rt_gateway, &state->addr->brd);
 350                 sa_in_init(&rt->rt_ifa, &state->addr->addr);
 351                 rt_proto_add(&nroutes, rt);
 352         }
 353
 354         /* Copy our address as the source address and set mtu */
 355         mtu = dhcp_get_mtu(ifp);
 356         n = 0;
 357         while ((rt = RB_TREE_MIN(&nroutes)) != NULL) {
 358                 rb_tree_remove_node(&nroutes, rt);
 359                 rt->rt_mtu = mtu;
 360                 if (!(rt->rt_dflags & RTDF_STATIC))
 361                         rt->rt_dflags |= RTDF_DHCP;
 362                 sa_in_init(&rt->rt_ifa, &state->addr->addr);
 363                 if (rb_tree_insert_node(routes, rt) != rt) {
 364                         rt_free(rt);
 365                         continue;
 366                 }
 367                 if (rt_is_default(rt))
 368                         *have_default = true;
 369                 n = 1;
 370         }
 371
 372         return n;
 373 }
 374
 375 /* We should check to ensure the routers are on the same subnet
 376  * OR supply a host route. If not, warn and add a host route. */
 377 static int
 378 inet_routerhostroute(rb_tree_t *routes, struct interface *ifp)
 379 {
 380         struct rt *rt, *rth, *rtp;
 381         struct sockaddr_in *dest, *netmask, *gateway;
 382         const char *cp, *cp2, *cp3, *cplim;
 383         struct if_options *ifo;
 384         const struct dhcp_state *state;
 385         struct in_addr in;
 386         rb_tree_t troutes;
 387
 388         /* Don't add a host route for these interfaces. */
 389         if (ifp->flags & (IFF_LOOPBACK | IFF_POINTOPOINT))
 390                 return 0;
 391
 392         rb_tree_init(&troutes, &rt_compare_proto_ops);
 393
 394         RB_TREE_FOREACH(rt, routes) {
 395                 if (rt->rt_dest.sa_family != AF_INET)
 396                         continue;
 397                 if (!sa_is_unspecified(&rt->rt_dest) ||
 398                     sa_is_unspecified(&rt->rt_gateway))
 399                         continue;
 400                 gateway = satosin(&rt->rt_gateway);
 401                 /* Scan for a route to match */
 402                 RB_TREE_FOREACH(rth, routes) {
 403                         if (rth == rt)
 404                                 break;
 405                         /* match host */
 406                         if (sa_cmp(&rth->rt_dest, &rt->rt_gateway) == 0)
 407                                 break;
 408                         /* match subnet */
 409                         /* XXX ADD TO RT_COMARE? XXX */
 410                         cp = (const char *)&gateway->sin_addr.s_addr;
 411                         dest = satosin(&rth->rt_dest);
 412                         cp2 = (const char *)&dest->sin_addr.s_addr;
 413                         netmask = satosin(&rth->rt_netmask);
 414                         cp3 = (const char *)&netmask->sin_addr.s_addr;
 415                         cplim = cp3 + sizeof(netmask->sin_addr.s_addr);
 416                         while (cp3 < cplim) {
 417                                 if ((*cp++ ^ *cp2++) & *cp3++)
 418                                         break;
 419                         }
 420                         if (cp3 == cplim)
 421                                 break;
 422                 }
 423                 if (rth != rt)
 424                         continue;
 425                 if ((state = D_CSTATE(ifp)) == NULL)
 426                         continue;
 427                 ifo = ifp->options;
 428                 if (ifp->flags & IFF_NOARP) {
 429                         if (!(ifo->options & DHCPCD_ROUTER_HOST_ROUTE_WARNED) &&
 430                             !(state->added & STATE_FAKE))
 431                         {
 432                                 char buf[INET_MAX_ADDRSTRLEN];
 433
 434                                 ifo->options |= DHCPCD_ROUTER_HOST_ROUTE_WARNED;
 435                                 logwarnx("%s: forcing router %s through "
 436                                     "interface",
 437                                     ifp->name,
 438                                     sa_addrtop(&rt->rt_gateway,
 439                                     buf, sizeof(buf)));
 440                         }
 441                         gateway->sin_addr.s_addr = INADDR_ANY;
 442                         continue;
 443                 }
 444                 if (!(ifo->options & DHCPCD_ROUTER_HOST_ROUTE_WARNED) &&
 445                     !(state->added & STATE_FAKE))
 446                 {
 447                         char buf[INET_MAX_ADDRSTRLEN];
 448
 449                         ifo->options |= DHCPCD_ROUTER_HOST_ROUTE_WARNED;
 450                         logwarnx("%s: router %s requires a host route",
 451                             ifp->name,
 452                             sa_addrtop(&rt->rt_gateway, buf, sizeof(buf)));
 453                 }
 454
 455                 if ((rth = rt_new(ifp)) == NULL)
 456                         return -1;
 457                 rth->rt_flags |= RTF_HOST;
 458                 sa_in_init(&rth->rt_dest, &gateway->sin_addr);
 459                 in.s_addr = INADDR_BROADCAST;
 460                 sa_in_init(&rth->rt_netmask, &in);
 461                 in.s_addr = INADDR_ANY;
 462                 sa_in_init(&rth->rt_gateway, &in);
 463                 rth->rt_mtu = dhcp_get_mtu(ifp);
 464                 if (state->addr != NULL)
 465                         sa_in_init(&rth->rt_ifa, &state->addr->addr);
 466                 else
 467                         rth->rt_ifa.sa_family = AF_UNSPEC;
 468
 469                 /* We need to insert the host route just before the router. */
 470                 while ((rtp = RB_TREE_MAX(routes)) != NULL) {
 471                         rb_tree_remove_node(routes, rtp);
 472                         rt_proto_add(&troutes, rtp);
 473                         if (rtp == rt)
 474                                 break;
 475                 }
 476                 rt_proto_add(routes, rth);
 477                 /* troutes is now reversed, so add backwards again. */
 478                 while ((rtp = RB_TREE_MAX(&troutes)) != NULL) {
 479                         rb_tree_remove_node(&troutes, rtp);
 480                         rt_proto_add(routes, rtp);
 481                 }
 482         }
 483         return 0;
 484 }
 485
 486 bool
 487 inet_getroutes(struct dhcpcd_ctx *ctx, rb_tree_t *routes)
 488 {
 489         struct interface *ifp;
 490         bool have_default = false;
 491
 492         TAILQ_FOREACH(ifp, ctx->ifaces, next) {
 493                 if (!ifp->active)
 494                         continue;
 495                 if (inet_dhcproutes(routes, ifp, &have_default) == -1)
 496                         return false;
 497 #ifdef IPV4LL
 498                 if (ipv4ll_subnetroute(routes, ifp) == -1)
 499                         return false;
 500 #endif
 501                 if (inet_routerhostroute(routes, ifp) == -1)
 502                         return false;
 503         }
 504
 505 #ifdef IPV4LL
 506         /* If there is no default route, see if we can use an IPv4LL one. */
 507         if (have_default)
 508                 return true;
 509
 510         TAILQ_FOREACH(ifp, ctx->ifaces, next) {
 511                 if (ifp->active &&
 512                     ipv4ll_defaultroute(routes, ifp) == 1)
 513                         break;
 514         }
 515 #endif
 516
 517         return true;
 518 }
 519
 520 int
 521 ipv4_deladdr(struct ipv4_addr *addr, int keeparp)
 522 {
 523         int r;
 524         struct ipv4_state *state;
 525         struct ipv4_addr *ap;
 526
 527         logdebugx("%s: deleting IP address %s",
 528             addr->iface->name, addr->saddr);
 529
 530         r = if_address(RTM_DELADDR, addr);
 531         if (r == -1 &&
 532             errno != EADDRNOTAVAIL && errno != ESRCH &&
 533             errno != ENXIO && errno != ENODEV)
 534                 logerr("%s: %s", addr->iface->name, __func__);
 535
 536 #ifdef ARP
 537         if (!keeparp)
 538                 arp_freeaddr(addr->iface, &addr->addr);
 539 #else
 540         UNUSED(keeparp);
 541 #endif
 542
 543         state = IPV4_STATE(addr->iface);
 544         TAILQ_FOREACH(ap, &state->addrs, next) {
 545                 if (IPV4_MASK_EQ(ap, addr)) {
 546                         struct dhcp_state *dstate;
 547
 548                         dstate = D_STATE(ap->iface);
 549                         TAILQ_REMOVE(&state->addrs, ap, next);
 550                         free(ap);
 551
 552                         if (dstate && dstate->addr == ap) {
 553                                 dstate->added = 0;
 554                                 dstate->addr = NULL;
 555                         }
 556                         break;
 557                 }
 558         }
 559
 560         return r;
 561 }
 562
 563 static int
 564 delete_address(struct interface *ifp)
 565 {
 566         int r;
 567         struct if_options *ifo;
 568         struct dhcp_state *state;
 569
 570         state = D_STATE(ifp);
 571         ifo = ifp->options;
 572         /* The lease could have been added, but the address deleted
 573          * by a 3rd party. */
 574         if (state->addr == NULL ||
 575             ifo->options & DHCPCD_INFORM ||
 576             (ifo->options & DHCPCD_STATIC && ifo->req_addr.s_addr == 0))
 577                 return 0;
 578 #ifdef ARP
 579         arp_freeaddr(ifp, &state->addr->addr);
 580 #endif
 581         r = ipv4_deladdr(state->addr, 0);
 582         return r;
 583 }
 584
 585 struct ipv4_state *
 586 ipv4_getstate(struct interface *ifp)
 587 {
 588         struct ipv4_state *state;
 589
 590         state = IPV4_STATE(ifp);
 591         if (state == NULL) {
 592                 ifp->if_data[IF_DATA_IPV4] = malloc(sizeof(*state));
 593                 state = IPV4_STATE(ifp);
 594                 if (state == NULL) {
 595                         logerr(__func__);
 596                         return NULL;
 597                 }
 598                 TAILQ_INIT(&state->addrs);
 599         }
 600         return state;
 601 }
 602
 603 #ifdef ALIAS_ADDR
 604 /* Find the next logical aliase address we can use. */
 605 static int
 606 ipv4_aliasaddr(struct ipv4_addr *ia, struct ipv4_addr **repl)
 607 {
 608         struct ipv4_state *state;
 609         struct ipv4_addr *iap;
 610         unsigned int lun;
 611         char alias[IF_NAMESIZE];
 612
 613         if (ia->alias[0] != '\0')
 614                 return 0;
 615
 616         lun = 0;
 617         state = IPV4_STATE(ia->iface);
 618 find_lun:
 619         if (if_makealias(alias, IF_NAMESIZE, ia->iface->name, lun) >=
 620             IF_NAMESIZE)
 621         {
 622                 errno = ENOMEM;
 623                 return -1;
 624         }
 625         TAILQ_FOREACH(iap, &state->addrs, next) {
 626                 if (iap->alias[0] != '\0' && iap->addr.s_addr == INADDR_ANY) {
 627                         /* No address assigned? Lets use it. */
 628                         strlcpy(ia->alias, iap->alias, sizeof(ia->alias));
 629                         if (repl)
 630                                 *repl = iap;
 631                         return 1;
 632                 }
 633                 if (strcmp(iap->alias, alias) == 0)
 634                         break;
 635         }
 636
 637         if (iap != NULL) {
 638                 if (lun == UINT_MAX) {
 639                         errno = ERANGE;
 640                         return -1;
 641                 }
 642                 lun++;
 643                 goto find_lun;
 644         }
 645
 646         strlcpy(ia->alias, alias, sizeof(ia->alias));
 647         return 0;
 648 }
 649 #endif
 650
 651 struct ipv4_addr *
 652 ipv4_addaddr(struct interface *ifp, const struct in_addr *addr,
 653     const struct in_addr *mask, const struct in_addr *bcast,
 654     uint32_t vltime, uint32_t pltime)
 655 {
 656         struct ipv4_state *state;
 657         struct ipv4_addr *ia;
 658 #ifdef ALIAS_ADDR
 659         int replaced, blank;
 660         struct ipv4_addr *replaced_ia;
 661 #endif
 662
 663         if ((state = ipv4_getstate(ifp)) == NULL) {
 664                 logerr(__func__);
 665                 return NULL;
 666         }
 667         if (ifp->options->options & DHCPCD_NOALIAS) {
 668                 struct ipv4_addr *ian;
 669
 670                 TAILQ_FOREACH_SAFE(ia, &state->addrs, next, ian) {
 671                         if (ia->addr.s_addr != addr->s_addr)
 672                                 ipv4_deladdr(ia, 0);
 673                 }
 674         }
 675
 676         ia = ipv4_iffindaddr(ifp, addr, NULL);
 677         if (ia == NULL) {
 678                 ia = malloc(sizeof(*ia));
 679                 if (ia == NULL) {
 680                         logerr(__func__);
 681                         return NULL;
 682                 }
 683                 ia->iface = ifp;
 684                 ia->addr = *addr;
 685 #ifdef IN_IFF_TENTATIVE
 686                 ia->addr_flags = IN_IFF_TENTATIVE;
 687 #endif
 688                 ia->flags = IPV4_AF_NEW;
 689         } else
 690                 ia->flags &= ~IPV4_AF_NEW;
 691
 692         ia->mask = *mask;
 693         ia->brd = *bcast;
 694 #ifdef IP_LIFETIME
 695         if (ifp->options->options & DHCPCD_LASTLEASE_EXTEND) {
 696                 /* We don't want the kernel to expire the address. */
 697                 ia->vltime = ia->pltime = DHCP_INFINITE_LIFETIME;
 698         } else {
 699                 ia->vltime = vltime;
 700                 ia->pltime = pltime;
 701         }
 702 #else
 703         UNUSED(vltime);
 704         UNUSED(pltime);
 705 #endif
 706         snprintf(ia->saddr, sizeof(ia->saddr), "%s/%d",
 707             inet_ntoa(*addr), inet_ntocidr(*mask));
 708
 709 #ifdef ALIAS_ADDR
 710         blank = (ia->alias[0] == '\0');
 711         if ((replaced = ipv4_aliasaddr(ia, &replaced_ia)) == -1) {
 712                 logerr("%s: ipv4_aliasaddr", ifp->name);
 713                 free(ia);
 714                 return NULL;
 715         }
 716         if (blank)
 717                 logdebugx("%s: aliased %s", ia->alias, ia->saddr);
 718 #endif
 719
 720         logdebugx("%s: adding IP address %s %s %s",
 721             ifp->name, ia->saddr,
 722             ifp->flags & IFF_POINTOPOINT ? "destination" : "broadcast",
 723             inet_ntoa(*bcast));
 724         if (if_address(RTM_NEWADDR, ia) == -1) {
 725                 if (errno != EEXIST)
 726                         logerr("%s: if_addaddress",
 727                             __func__);
 728                 if (ia->flags & IPV4_AF_NEW)
 729                         free(ia);
 730                 return NULL;
 731         }
 732
 733 #ifdef ALIAS_ADDR
 734         if (replaced) {
 735                 TAILQ_REMOVE(&state->addrs, replaced_ia, next);
 736                 free(replaced_ia);
 737         }
 738 #endif
 739
 740         if (ia->flags & IPV4_AF_NEW)
 741                 TAILQ_INSERT_TAIL(&state->addrs, ia, next);
 742         return ia;
 743 }
 744
 745 static int
 746 ipv4_daddaddr(struct interface *ifp, const struct dhcp_lease *lease)
 747 {
 748         struct dhcp_state *state;
 749         struct ipv4_addr *ia;
 750
 751         ia = ipv4_addaddr(ifp, &lease->addr, &lease->mask, &lease->brd,
 752             lease->leasetime, lease->rebindtime);
 753         if (ia == NULL)
 754                 return -1;
 755
 756         state = D_STATE(ifp);
 757         state->added = STATE_ADDED;
 758         state->addr = ia;
 759         return 0;
 760 }
 761
 762 struct ipv4_addr *
 763 ipv4_applyaddr(void *arg)
 764 {
 765         struct interface *ifp = arg;
 766         struct dhcp_state *state = D_STATE(ifp);
 767         struct dhcp_lease *lease;
 768         struct if_options *ifo = ifp->options;
 769         struct ipv4_addr *ia;
 770
 771         if (state == NULL)
 772                 return NULL;
 773
 774         lease = &state->lease;
 775         if (state->new == NULL) {
 776                 if ((ifo->options & (DHCPCD_EXITING | DHCPCD_PERSISTENT)) !=
 777                     (DHCPCD_EXITING | DHCPCD_PERSISTENT))
 778                 {
 779                         if (state->added) {
 780                                 delete_address(ifp);
 781                                 rt_build(ifp->ctx, AF_INET);
 782 #ifdef ARP
 783                                 /* Announce the preferred address to
 784                                  * kick ARP caches. */
 785                                 arp_announceaddr(ifp->ctx,&lease->addr);
 786 #endif
 787                         }
 788                         script_runreason(ifp, state->reason);
 789                 } else
 790                         rt_build(ifp->ctx, AF_INET);
 791                 return NULL;
 792         }
 793
 794         ia = ipv4_iffindaddr(ifp, &lease->addr, NULL);
 795         /* If the netmask or broadcast is different, re-add the addresss.
 796          * If IP addresses do not have lifetimes, there is a very real chance
 797          * that re-adding them will scrub the subnet route temporarily
 798          * which is a bad thing, so avoid it. */
 799         if (ia != NULL &&
 800             ia->mask.s_addr == lease->mask.s_addr &&
 801             ia->brd.s_addr == lease->brd.s_addr)
 802         {
 803 #ifndef IP_LIFETIME
 804                 logdebugx("%s: IP address %s already exists",
 805                     ifp->name, ia->saddr);
 806 #endif
 807         } else {
 808 #ifdef __linux__
 809                 /* Linux does not change netmask/broadcast address
 810                  * for re-added addresses, so we need to delete the old one
 811                  * first. */
 812                 if (ia != NULL)
 813                         ipv4_deladdr(ia, 0);
 814 #endif
 815 #ifndef IP_LIFETIME
 816                 if (ipv4_daddaddr(ifp, lease) == -1 && errno != EEXIST)
 817                         return NULL;
 818 #endif
 819         }
 820 #ifdef IP_LIFETIME
 821         if (ipv4_daddaddr(ifp, lease) == -1 && errno != EEXIST)
 822                 return NULL;
 823 #endif
 824
 825         ia = ipv4_iffindaddr(ifp, &lease->addr, NULL);
 826         if (ia == NULL) {
 827                 logerrx("%s: added address vanished", ifp->name);
 828                 return NULL;
 829         }
 830 #if defined(ARP) && defined(IN_IFF_NOTUSEABLE)
 831         if (ia->addr_flags & IN_IFF_NOTUSEABLE)
 832                 return NULL;
 833 #endif
 834
 835         /* Delete the old address if different */
 836         if (state->addr &&
 837             state->addr->addr.s_addr != lease->addr.s_addr &&
 838             ipv4_iffindaddr(ifp, &lease->addr, NULL))
 839                 delete_address(ifp);
 840
 841         state->addr = ia;
 842         state->added = STATE_ADDED;
 843
 844         rt_build(ifp->ctx, AF_INET);
 845
 846 #ifdef ARP
 847         arp_announceaddr(ifp->ctx, &state->addr->addr);
 848 #endif
 849
 850         if (state->state == DHS_BOUND) {
 851                 script_runreason(ifp, state->reason);
 852                 dhcpcd_daemonise(ifp->ctx);
 853         }
 854         return ia;
 855 }
 856
 857 void
 858 ipv4_markaddrsstale(struct interface *ifp)
 859 {
 860         struct ipv4_state *state;
 861         struct ipv4_addr *ia;
 862
 863         state = IPV4_STATE(ifp);
 864         if (state == NULL)
 865                 return;
 866
 867         TAILQ_FOREACH(ia, &state->addrs, next) {
 868                 ia->flags |= IPV4_AF_STALE;
 869         }
 870 }
 871
 872 void
 873 ipv4_deletestaleaddrs(struct interface *ifp)
 874 {
 875         struct ipv4_state *state;
 876         struct ipv4_addr *ia, *ia1;
 877
 878         state = IPV4_STATE(ifp);
 879         if (state == NULL)
 880                 return;
 881
 882         TAILQ_FOREACH_SAFE(ia, &state->addrs, next, ia1) {
 883                 if (!(ia->flags & IPV4_AF_STALE))
 884                         continue;
 885                 ipv4_handleifa(ifp->ctx, RTM_DELADDR,
 886                     ifp->ctx->ifaces, ifp->name,
 887                     &ia->addr, &ia->mask, &ia->brd, 0, getpid());
 888         }
 889 }
 890
 891 void
 892 ipv4_handleifa(struct dhcpcd_ctx *ctx,
 893     int cmd, struct if_head *ifs, const char *ifname,
 894     const struct in_addr *addr, const struct in_addr *mask,
 895     const struct in_addr *brd, int addrflags, pid_t pid)
 896 {
 897         struct interface *ifp;
 898         struct ipv4_state *state;
 899         struct ipv4_addr *ia;
 900         bool ia_is_new;
 901
 902 #if 0
 903         char sbrdbuf[INET_ADDRSTRLEN];
 904         const char *sbrd;
 905
 906         if (brd)
 907                 sbrd = inet_ntop(AF_INET, brd, sbrdbuf, sizeof(sbrdbuf));
 908         else
 909                 sbrd = NULL;
 910         logdebugx("%s: %s %s/%d %s %d", ifname,
 911             cmd == RTM_NEWADDR ? "RTM_NEWADDR" :
 912             cmd == RTM_DELADDR ? "RTM_DELADDR" : "???",
 913             inet_ntoa(*addr), inet_ntocidr(*mask), sbrd, addrflags);
 914 #endif
 915
 916         if (ifs == NULL)
 917                 ifs = ctx->ifaces;
 918         if (ifs == NULL) {
 919                 errno = ESRCH;
 920                 return;
 921         }
 922         if ((ifp = if_find(ifs, ifname)) == NULL)
 923                 return;
 924         if ((state = ipv4_getstate(ifp)) == NULL) {
 925                 errno = ENOENT;
 926                 return;
 927         }
 928
 929         ia = ipv4_iffindaddr(ifp, addr, NULL);
 930         switch (cmd) {
 931         case RTM_NEWADDR:
 932                 if (ia == NULL) {
 933                         if ((ia = malloc(sizeof(*ia))) == NULL) {
 934                                 logerr(__func__);
 935                                 return;
 936                         }
 937                         ia->iface = ifp;
 938                         ia->addr = *addr;
 939                         ia->mask = *mask;
 940                         ia->flags = 0;
 941                         ia_is_new = true;
 942 #ifdef ALIAS_ADDR
 943                         strlcpy(ia->alias, ifname, sizeof(ia->alias));
 944 #endif
 945                         TAILQ_INSERT_TAIL(&state->addrs, ia, next);
 946                 } else
 947                         ia_is_new = false;
 948                 /* Mask could have changed */
 949                 if (ia_is_new ||
 950                     (mask->s_addr != INADDR_ANY &&
 951                     mask->s_addr != ia->mask.s_addr))
 952                 {
 953                         ia->mask = *mask;
 954                         snprintf(ia->saddr, sizeof(ia->saddr), "%s/%d",
 955                             inet_ntoa(*addr), inet_ntocidr(*mask));
 956                 }
 957                 if (brd != NULL)
 958                         ia->brd = *brd;
 959                 else
 960                         ia->brd.s_addr = INADDR_ANY;
 961                 ia->addr_flags = addrflags;
 962                 ia->flags &= ~IPV4_AF_STALE;
 963                 break;
 964         case RTM_DELADDR:
 965                 if (ia == NULL)
 966                         return;
 967                 if (mask->s_addr != INADDR_ANY &&
 968                     mask->s_addr != ia->mask.s_addr)
 969                         return;
 970                 TAILQ_REMOVE(&state->addrs, ia, next);
 971                 break;
 972         default:
 973                 return;
 974         }
 975
 976         if (addr->s_addr != INADDR_ANY && addr->s_addr != INADDR_BROADCAST) {
 977                 ia = dhcp_handleifa(cmd, ia, pid);
 978 #ifdef IPV4LL
 979                 if (ia != NULL)
 980                         ipv4ll_handleifa(cmd, ia, pid);
 981 #endif
 982         }
 983
 984         if (cmd == RTM_DELADDR)
 985                 free(ia);
 986 }
 987
 988 void
 989 ipv4_free(struct interface *ifp)
 990 {
 991         struct ipv4_state *state;
 992         struct ipv4_addr *ia;
 993
 994         if (ifp == NULL || (state = IPV4_STATE(ifp)) == NULL)
 995                 return;
 996
 997         while ((ia = TAILQ_FIRST(&state->addrs))) {
 998                 TAILQ_REMOVE(&state->addrs, ia, next);
 999                 free(ia);
1000         }
1001         free(state);
1002 }