1 #include <sys/cdefs.h> 2 __RCSID("$NetBSD: ipv4.c,v 1.17 2015/08/21 10:39:00 roy Exp $"); 3 4 /* 5 * dhcpcd - DHCP client daemon 6 * Copyright (c) 2006-2015 Roy Marples <roy@marples.name> 7 * All rights reserved 8 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 #include <sys/socket.h> 32 #include <sys/types.h> 33 34 #include <arpa/inet.h> 35 #include <net/if.h> 36 #include <net/route.h> 37 #include <netinet/if_ether.h> 38 #include <netinet/in.h> 39 40 #include <assert.h> 41 #include <ctype.h> 42 #include <errno.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 "if.h" 53 #include "if-options.h" 54 #include "ipv4.h" 55 #include "ipv4ll.h" 56 #include "script.h" 57 58 #define IPV4_LOOPBACK_ROUTE 59 #if defined(__linux__) || (defined(BSD) && defined(RTF_LOCAL)) 60 /* Linux has had loopback routes in the local table since 2.2 */ 61 #undef IPV4_LOOPBACK_ROUTE 62 #endif 63 64 uint8_t 65 inet_ntocidr(struct in_addr address) 66 { 67 uint8_t cidr = 0; 68 uint32_t mask = htonl(address.s_addr); 69 70 while (mask) { 71 cidr++; 72 mask <<= 1; 73 } 74 return cidr; 75 } 76 77 int 78 inet_cidrtoaddr(int cidr, struct in_addr *addr) 79 { 80 int ocets; 81 82 if (cidr < 1 || cidr > 32) { 83 errno = EINVAL; 84 return -1; 85 } 86 ocets = (cidr + 7) / NBBY; 87 88 addr->s_addr = 0; 89 if (ocets > 0) { 90 memset(&addr->s_addr, 255, (size_t)ocets - 1); 91 memset((unsigned char *)&addr->s_addr + (ocets - 1), 92 (256 - (1 << (32 - cidr) % NBBY)), 1); 93 } 94 95 return 0; 96 } 97 98 uint32_t 99 ipv4_getnetmask(uint32_t addr) 100 { 101 uint32_t dst; 102 103 if (addr == 0) 104 return 0; 105 106 dst = htonl(addr); 107 if (IN_CLASSA(dst)) 108 return ntohl(IN_CLASSA_NET); 109 if (IN_CLASSB(dst)) 110 return ntohl(IN_CLASSB_NET); 111 if (IN_CLASSC(dst)) 112 return ntohl(IN_CLASSC_NET); 113 114 return 0; 115 } 116 117 struct ipv4_addr * 118 ipv4_iffindaddr(struct interface *ifp, 119 const struct in_addr *addr, const struct in_addr *net) 120 { 121 struct ipv4_state *state; 122 struct ipv4_addr *ap; 123 124 state = IPV4_STATE(ifp); 125 if (state) { 126 TAILQ_FOREACH(ap, &state->addrs, next) { 127 if ((addr == NULL || ap->addr.s_addr == addr->s_addr) && 128 (net == NULL || ap->net.s_addr == net->s_addr)) 129 return ap; 130 } 131 } 132 return NULL; 133 } 134 135 struct ipv4_addr * 136 ipv4_iffindlladdr(struct interface *ifp) 137 { 138 struct ipv4_state *state; 139 struct ipv4_addr *ap; 140 141 state = IPV4_STATE(ifp); 142 if (state) { 143 TAILQ_FOREACH(ap, &state->addrs, next) { 144 if (IN_LINKLOCAL(htonl(ap->addr.s_addr))) 145 return ap; 146 } 147 } 148 return NULL; 149 } 150 151 struct ipv4_addr * 152 ipv4_findaddr(struct dhcpcd_ctx *ctx, const struct in_addr *addr) 153 { 154 struct interface *ifp; 155 struct ipv4_addr *ap; 156 157 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 158 ap = ipv4_iffindaddr(ifp, addr, NULL); 159 if (ap) 160 return ap; 161 } 162 return NULL; 163 } 164 165 int 166 ipv4_hasaddr(const struct interface *ifp) 167 { 168 const struct dhcp_state *dstate; 169 const struct ipv4ll_state *istate; 170 171 dstate = D_CSTATE(ifp); 172 istate = IPV4LL_CSTATE(ifp); 173 return ((dstate && 174 dstate->added == STATE_ADDED && 175 dstate->addr.s_addr != INADDR_ANY) || 176 (istate && istate->addr.s_addr != INADDR_ANY)); 177 } 178 179 void 180 ipv4_freeroutes(struct rt_head *rts) 181 { 182 183 if (rts) { 184 ipv4_freerts(rts); 185 free(rts); 186 } 187 } 188 189 int 190 ipv4_init(struct dhcpcd_ctx *ctx) 191 { 192 193 if (ctx->ipv4_routes == NULL) { 194 ctx->ipv4_routes = malloc(sizeof(*ctx->ipv4_routes)); 195 if (ctx->ipv4_routes == NULL) 196 return -1; 197 TAILQ_INIT(ctx->ipv4_routes); 198 } 199 if (ctx->ipv4_kroutes == NULL) { 200 ctx->ipv4_kroutes = malloc(sizeof(*ctx->ipv4_kroutes)); 201 if (ctx->ipv4_kroutes == NULL) 202 return -1; 203 TAILQ_INIT(ctx->ipv4_kroutes); 204 } 205 return 0; 206 } 207 208 int 209 ipv4_protocol_fd(const struct interface *ifp, uint16_t protocol) 210 { 211 212 if (protocol == ETHERTYPE_ARP) { 213 const struct iarp_state *istate; 214 215 istate = ARP_CSTATE(ifp); 216 assert(istate != NULL); 217 return istate->fd; 218 } else { 219 const struct dhcp_state *dstate; 220 221 dstate = D_CSTATE(ifp); 222 assert(dstate != NULL); 223 return dstate->raw_fd; 224 } 225 } 226 227 /* Interface comparer for working out ordering. */ 228 int 229 ipv4_ifcmp(const struct interface *si, const struct interface *ti) 230 { 231 const struct dhcp_state *sis, *tis; 232 233 sis = D_CSTATE(si); 234 tis = D_CSTATE(ti); 235 if (sis && !tis) 236 return -1; 237 if (!sis && tis) 238 return 1; 239 if (!sis && !tis) 240 return 0; 241 /* If one has a lease and the other not, it takes precedence. */ 242 if (sis->new && !tis->new) 243 return -1; 244 if (!sis->new && tis->new) 245 return 1; 246 /* Always prefer proper leases */ 247 if (!(sis->added & STATE_FAKE) && (sis->added & STATE_FAKE)) 248 return -1; 249 if ((sis->added & STATE_FAKE) && !(sis->added & STATE_FAKE)) 250 return 1; 251 /* If we are either, they neither have a lease, or they both have. 252 * We need to check for IPv4LL and make it non-preferred. */ 253 if (sis->new && tis->new) { 254 int sill = (sis->new->cookie == htonl(MAGIC_COOKIE)); 255 int till = (tis->new->cookie == htonl(MAGIC_COOKIE)); 256 if (sill && !till) 257 return -1; 258 if (!sill && till) 259 return 1; 260 } 261 return 0; 262 } 263 264 static struct rt * 265 find_route(struct rt_head *rts, const struct rt *r, const struct rt *srt) 266 { 267 struct rt *rt; 268 269 if (rts == NULL) 270 return NULL; 271 TAILQ_FOREACH(rt, rts, next) { 272 if (rt->dest.s_addr == r->dest.s_addr && 273 #ifdef HAVE_ROUTE_METRIC 274 (srt || (r->iface == NULL || rt->iface == NULL || 275 rt->iface->metric == r->iface->metric)) && 276 #endif 277 (!srt || srt != rt) && 278 rt->net.s_addr == r->net.s_addr) 279 return rt; 280 } 281 return NULL; 282 } 283 284 static void 285 desc_route(const char *cmd, const struct rt *rt) 286 { 287 char addr[sizeof("000.000.000.000") + 1]; 288 struct dhcpcd_ctx *ctx = rt->iface ? rt->iface->ctx : NULL; 289 const char *ifname = rt->iface ? rt->iface->name : NULL; 290 291 strlcpy(addr, inet_ntoa(rt->dest), sizeof(addr)); 292 if (rt->net.s_addr == htonl(INADDR_BROADCAST) && 293 rt->gate.s_addr == htonl(INADDR_ANY)) 294 logger(ctx, LOG_INFO, "%s: %s host route to %s", 295 ifname, cmd, addr); 296 else if (rt->net.s_addr == htonl(INADDR_BROADCAST)) 297 logger(ctx, LOG_INFO, "%s: %s host route to %s via %s", 298 ifname, cmd, addr, inet_ntoa(rt->gate)); 299 else if (rt->dest.s_addr == htonl(INADDR_ANY) && 300 rt->net.s_addr == htonl(INADDR_ANY) && 301 rt->gate.s_addr == htonl(INADDR_ANY)) 302 logger(ctx, LOG_INFO, "%s: %s default route", 303 ifname, cmd); 304 else if (rt->gate.s_addr == htonl(INADDR_ANY)) 305 logger(ctx, LOG_INFO, "%s: %s route to %s/%d", 306 ifname, cmd, addr, inet_ntocidr(rt->net)); 307 else if (rt->dest.s_addr == htonl(INADDR_ANY) && 308 rt->net.s_addr == htonl(INADDR_ANY)) 309 logger(ctx, LOG_INFO, "%s: %s default route via %s", 310 ifname, cmd, inet_ntoa(rt->gate)); 311 else 312 logger(ctx, LOG_INFO, "%s: %s route to %s/%d via %s", 313 ifname, cmd, addr, inet_ntocidr(rt->net), 314 inet_ntoa(rt->gate)); 315 } 316 317 static struct rt * 318 ipv4_findrt(struct dhcpcd_ctx *ctx, const struct rt *rt, int flags) 319 { 320 struct rt *r; 321 322 if (ctx->ipv4_kroutes == NULL) 323 return NULL; 324 TAILQ_FOREACH(r, ctx->ipv4_kroutes, next) { 325 if (rt->dest.s_addr == r->dest.s_addr && 326 #ifdef HAVE_ROUTE_METRIC 327 rt->iface == r->iface && 328 (!flags || rt->metric == r->metric) && 329 #else 330 (!flags || rt->iface == r->iface) && 331 #endif 332 rt->net.s_addr == r->net.s_addr) 333 return r; 334 } 335 return NULL; 336 } 337 338 void 339 ipv4_freerts(struct rt_head *routes) 340 { 341 struct rt *rt; 342 343 while ((rt = TAILQ_FIRST(routes))) { 344 TAILQ_REMOVE(routes, rt, next); 345 free(rt); 346 } 347 } 348 349 /* If something other than dhcpcd removes a route, 350 * we need to remove it from our internal table. */ 351 int 352 ipv4_handlert(struct dhcpcd_ctx *ctx, int cmd, struct rt *rt) 353 { 354 struct rt *f; 355 356 if (ctx->ipv4_kroutes == NULL) 357 return 0; 358 359 f = ipv4_findrt(ctx, rt, 1); 360 switch (cmd) { 361 case RTM_ADD: 362 if (f == NULL) { 363 if ((f = malloc(sizeof(*f))) == NULL) 364 return -1; 365 *f = *rt; 366 TAILQ_INSERT_TAIL(ctx->ipv4_kroutes, f, next); 367 } 368 break; 369 case RTM_DELETE: 370 if (f) { 371 TAILQ_REMOVE(ctx->ipv4_kroutes, f, next); 372 free(f); 373 } 374 375 /* If we manage the route, remove it */ 376 if ((f = find_route(ctx->ipv4_routes, rt, NULL))) { 377 desc_route("removing", f); 378 TAILQ_REMOVE(ctx->ipv4_routes, f, next); 379 free(f); 380 } 381 break; 382 } 383 return 0; 384 } 385 386 #define n_route(a) nc_route(NULL, a) 387 #define c_route(a, b) nc_route(a, b) 388 static int 389 nc_route(struct rt *ort, struct rt *nrt) 390 { 391 int change; 392 393 /* Don't set default routes if not asked to */ 394 if (nrt->dest.s_addr == 0 && 395 nrt->net.s_addr == 0 && 396 !(nrt->iface->options->options & DHCPCD_GATEWAY)) 397 return -1; 398 399 desc_route(ort == NULL ? "adding" : "changing", nrt); 400 401 change = 0; 402 if (ort == NULL) { 403 ort = ipv4_findrt(nrt->iface->ctx, nrt, 0); 404 if (ort && 405 ((ort->flags & RTF_REJECT && nrt->flags & RTF_REJECT) || 406 (ort->iface == nrt->iface && 407 #ifdef HAVE_ROUTE_METRIC 408 ort->metric == nrt->metric && 409 #endif 410 ort->gate.s_addr == nrt->gate.s_addr))) 411 { 412 if (ort->mtu == nrt->mtu) 413 return 0; 414 change = 1; 415 } 416 } else if (ort->state & STATE_FAKE && !(nrt->state & STATE_FAKE) && 417 ort->iface == nrt->iface && 418 #ifdef HAVE_ROUTE_METRIC 419 ort->metric == nrt->metric && 420 #endif 421 ort->dest.s_addr == nrt->dest.s_addr && 422 ort->net.s_addr == nrt->net.s_addr && 423 ort->gate.s_addr == nrt->gate.s_addr) 424 { 425 if (ort->mtu == nrt->mtu) 426 return 0; 427 change = 1; 428 } 429 430 #ifdef RTF_CLONING 431 /* BSD can set routes to be cloning routes. 432 * Cloned routes inherit the parent flags. 433 * As such, we need to delete and re-add the route to flush children 434 * to correct the flags. */ 435 if (change && ort != NULL && ort->flags & RTF_CLONING) 436 change = 0; 437 #endif 438 439 if (change) { 440 if (if_route(RTM_CHANGE, nrt) == 0) 441 return 0; 442 if (errno != ESRCH) 443 logger(nrt->iface->ctx, LOG_ERR, "if_route (CHG): %m"); 444 } 445 446 #ifdef HAVE_ROUTE_METRIC 447 /* With route metrics, we can safely add the new route before 448 * deleting the old route. */ 449 if (if_route(RTM_ADD, nrt) == 0) { 450 if (ort && if_route(RTM_DELETE, ort) == -1 && errno != ESRCH) 451 logger(nrt->iface->ctx, LOG_ERR, "if_route (DEL): %m"); 452 return 0; 453 } 454 455 /* If the kernel claims the route exists we need to rip out the 456 * old one first. */ 457 if (errno != EEXIST || ort == NULL) 458 goto logerr; 459 #endif 460 461 /* No route metrics, we need to delete the old route before 462 * adding the new one. */ 463 if (ort && if_route(RTM_DELETE, ort) == -1 && errno != ESRCH) 464 logger(nrt->iface->ctx, LOG_ERR, "if_route (DEL): %m"); 465 if (if_route(RTM_ADD, nrt) == 0) 466 return 0; 467 #ifdef HAVE_ROUTE_METRIC 468 logerr: 469 #endif 470 logger(nrt->iface->ctx, LOG_ERR, "if_route (ADD): %m"); 471 return -1; 472 } 473 474 static int 475 d_route(struct rt *rt) 476 { 477 int retval; 478 479 desc_route("deleting", rt); 480 retval = if_route(RTM_DELETE, rt); 481 if (retval != 0 && errno != ENOENT && errno != ESRCH) 482 logger(rt->iface->ctx, LOG_ERR, 483 "%s: if_delroute: %m", rt->iface->name); 484 return retval; 485 } 486 487 static struct rt_head * 488 add_subnet_route(struct rt_head *rt, const struct interface *ifp) 489 { 490 const struct dhcp_state *s; 491 struct rt *r; 492 493 if (rt == NULL) /* earlier malloc failed */ 494 return NULL; 495 496 s = D_CSTATE(ifp); 497 /* Don't create a subnet route for these addresses */ 498 if (s->net.s_addr == INADDR_ANY) 499 return rt; 500 #ifndef BSD 501 /* BSD adds a route in this instance */ 502 if (s->net.s_addr == INADDR_BROADCAST) 503 return rt; 504 #endif 505 506 if ((r = calloc(1, sizeof(*r))) == NULL) { 507 logger(ifp->ctx, LOG_ERR, "%s: %m", __func__); 508 ipv4_freeroutes(rt); 509 return NULL; 510 } 511 r->dest.s_addr = s->addr.s_addr & s->net.s_addr; 512 r->net.s_addr = s->net.s_addr; 513 r->gate.s_addr = INADDR_ANY; 514 r->mtu = dhcp_get_mtu(ifp); 515 r->src = s->addr; 516 517 TAILQ_INSERT_HEAD(rt, r, next); 518 return rt; 519 } 520 521 #ifdef IPV4_LOOPBACK_ROUTE 522 static struct rt_head * 523 add_loopback_route(struct rt_head *rt, const struct interface *ifp) 524 { 525 struct rt *r; 526 const struct dhcp_state *s; 527 528 if (rt == NULL) /* earlier malloc failed */ 529 return NULL; 530 531 s = D_CSTATE(ifp); 532 if (s->addr.s_addr == INADDR_ANY) 533 return rt; 534 535 if ((r = calloc(1, sizeof(*r))) == NULL) { 536 logger(ifp->ctx, LOG_ERR, "%s: %m", __func__); 537 ipv4_freeroutes(rt); 538 return NULL; 539 } 540 r->dest = s->addr; 541 r->net.s_addr = INADDR_BROADCAST; 542 r->gate.s_addr = htonl(INADDR_LOOPBACK); 543 r->mtu = dhcp_get_mtu(ifp); 544 r->src = s->addr; 545 TAILQ_INSERT_HEAD(rt, r, next); 546 return rt; 547 } 548 #endif 549 550 static struct rt_head * 551 get_routes(struct interface *ifp) 552 { 553 struct rt_head *nrt; 554 struct rt *rt, *r = NULL; 555 const struct dhcp_state *state; 556 557 if (ifp->options->routes && TAILQ_FIRST(ifp->options->routes)) { 558 if ((nrt = malloc(sizeof(*nrt))) == NULL) 559 return NULL; 560 TAILQ_INIT(nrt); 561 TAILQ_FOREACH(rt, ifp->options->routes, next) { 562 if (rt->gate.s_addr == 0) 563 break; 564 if ((r = calloc(1, sizeof(*r))) == NULL) { 565 logger(ifp->ctx, LOG_ERR, "%s: %m", __func__); 566 ipv4_freeroutes(nrt); 567 return NULL; 568 } 569 memcpy(r, rt, sizeof(*r)); 570 TAILQ_INSERT_TAIL(nrt, r, next); 571 } 572 } else 573 nrt = dhcp_get_routes(ifp); 574 575 /* Copy our address as the source address */ 576 if (nrt) { 577 state = D_CSTATE(ifp); 578 TAILQ_FOREACH(rt, nrt, next) { 579 rt->src = state->addr; 580 } 581 } 582 583 return nrt; 584 } 585 586 static struct rt_head * 587 add_destination_route(struct rt_head *rt, const struct interface *ifp) 588 { 589 struct rt *r; 590 const struct dhcp_state *state; 591 592 if (rt == NULL || /* failed a malloc earlier probably */ 593 !(ifp->flags & IFF_POINTOPOINT) || 594 !has_option_mask(ifp->options->dstmask, DHO_ROUTER) || 595 (state = D_CSTATE(ifp)) == NULL) 596 return rt; 597 598 if ((r = calloc(1, sizeof(*r))) == NULL) { 599 logger(ifp->ctx, LOG_ERR, "%s: %m", __func__); 600 ipv4_freeroutes(rt); 601 return NULL; 602 } 603 r->dest.s_addr = INADDR_ANY; 604 r->net.s_addr = INADDR_ANY; 605 r->gate.s_addr = state->dst.s_addr; 606 r->mtu = dhcp_get_mtu(ifp); 607 r->src = state->addr; 608 TAILQ_INSERT_HEAD(rt, r, next); 609 return rt; 610 } 611 612 /* We should check to ensure the routers are on the same subnet 613 * OR supply a host route. If not, warn and add a host route. */ 614 static struct rt_head * 615 add_router_host_route(struct rt_head *rt, const struct interface *ifp) 616 { 617 struct rt *rtp, *rtn; 618 const char *cp, *cp2, *cp3, *cplim; 619 struct if_options *ifo; 620 const struct dhcp_state *state; 621 622 if (rt == NULL) /* earlier malloc failed */ 623 return NULL; 624 625 TAILQ_FOREACH(rtp, rt, next) { 626 if (rtp->dest.s_addr != INADDR_ANY) 627 continue; 628 /* Scan for a route to match */ 629 TAILQ_FOREACH(rtn, rt, next) { 630 if (rtn == rtp) 631 break; 632 /* match host */ 633 if (rtn->dest.s_addr == rtp->gate.s_addr) 634 break; 635 /* match subnet */ 636 cp = (const char *)&rtp->gate.s_addr; 637 cp2 = (const char *)&rtn->dest.s_addr; 638 cp3 = (const char *)&rtn->net.s_addr; 639 cplim = cp3 + sizeof(rtn->net.s_addr); 640 while (cp3 < cplim) { 641 if ((*cp++ ^ *cp2++) & *cp3++) 642 break; 643 } 644 if (cp3 == cplim) 645 break; 646 } 647 if (rtn != rtp) 648 continue; 649 if ((state = D_CSTATE(ifp)) == NULL) 650 continue; 651 ifo = ifp->options; 652 if (ifp->flags & IFF_NOARP) { 653 if (!(ifo->options & DHCPCD_ROUTER_HOST_ROUTE_WARNED) && 654 !(state->added & STATE_FAKE)) 655 { 656 ifo->options |= DHCPCD_ROUTER_HOST_ROUTE_WARNED; 657 logger(ifp->ctx, LOG_WARNING, 658 "%s: forcing router %s through interface", 659 ifp->name, inet_ntoa(rtp->gate)); 660 } 661 rtp->gate.s_addr = 0; 662 continue; 663 } 664 if (!(ifo->options & DHCPCD_ROUTER_HOST_ROUTE_WARNED) && 665 !(state->added & STATE_FAKE)) 666 { 667 ifo->options |= DHCPCD_ROUTER_HOST_ROUTE_WARNED; 668 logger(ifp->ctx, LOG_WARNING, 669 "%s: router %s requires a host route", 670 ifp->name, inet_ntoa(rtp->gate)); 671 } 672 if ((rtn = calloc(1, sizeof(*rtn))) == NULL) { 673 logger(ifp->ctx, LOG_ERR, "%s: %m", __func__); 674 ipv4_freeroutes(rt); 675 return NULL; 676 } 677 rtn->dest.s_addr = rtp->gate.s_addr; 678 rtn->net.s_addr = htonl(INADDR_BROADCAST); 679 rtn->gate.s_addr = htonl(INADDR_ANY); 680 rtn->mtu = dhcp_get_mtu(ifp); 681 rtn->src = state->addr; 682 TAILQ_INSERT_BEFORE(rtp, rtn, next); 683 } 684 return rt; 685 } 686 687 static int 688 ipv4_doroute(struct rt *rt, struct rt_head *nrs) 689 { 690 const struct dhcp_state *state; 691 struct rt *or; 692 693 state = D_CSTATE(rt->iface); 694 rt->state = state->added & STATE_FAKE; 695 #ifdef HAVE_ROUTE_METRIC 696 rt->metric = rt->iface->metric; 697 #endif 698 /* Is this route already in our table? */ 699 if ((find_route(nrs, rt, NULL)) != NULL) 700 return 0; 701 /* Do we already manage it? */ 702 if ((or = find_route(rt->iface->ctx->ipv4_routes, rt, NULL))) { 703 if (state->added & STATE_FAKE) 704 return 0; 705 if (or->state & STATE_FAKE || 706 or->iface != rt->iface || 707 #ifdef HAVE_ROUTE_METRIC 708 rt->metric != or->metric || 709 #endif 710 rt->src.s_addr != or->src.s_addr || 711 rt->gate.s_addr != or->gate.s_addr || 712 rt->mtu != or->mtu) 713 { 714 if (c_route(or, rt) != 0) 715 return 0; 716 } 717 TAILQ_REMOVE(rt->iface->ctx->ipv4_routes, or, next); 718 free(or); 719 } else { 720 if (state->added & STATE_FAKE) { 721 if ((or = ipv4_findrt(rt->iface->ctx, rt, 1)) == NULL) 722 return 0; 723 rt->iface = or->iface; 724 rt->gate.s_addr = or->gate.s_addr; 725 #ifdef HAVE_ROUTE_METRIC 726 rt->metric = or->metric; 727 #endif 728 rt->mtu = or->mtu; 729 rt->flags = or->flags; 730 } else { 731 if (n_route(rt) != 0) 732 return 0; 733 } 734 } 735 return 1; 736 } 737 738 void 739 ipv4_buildroutes(struct dhcpcd_ctx *ctx) 740 { 741 struct rt_head *nrs, *dnr; 742 struct rt *rt, *rtn; 743 struct interface *ifp; 744 const struct dhcp_state *state; 745 int has_default; 746 747 /* We need to have the interfaces in the correct order to ensure 748 * our routes are managed correctly. */ 749 if_sortinterfaces(ctx); 750 751 if ((nrs = malloc(sizeof(*nrs))) == NULL) { 752 logger(ctx, LOG_ERR, "%s: %m", __func__); 753 return; 754 } 755 TAILQ_INIT(nrs); 756 757 has_default = 0; 758 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 759 state = D_CSTATE(ifp); 760 if (state != NULL && state->new != NULL && state->added) { 761 dnr = get_routes(ifp); 762 dnr = add_subnet_route(dnr, ifp); 763 } else 764 dnr = NULL; 765 if ((rt = ipv4ll_subnet_route(ifp)) != NULL) { 766 if (dnr == NULL) { 767 if ((dnr = malloc(sizeof(*dnr))) == NULL) { 768 logger(ifp->ctx, LOG_ERR, 769 "%s: malloc %m", __func__); 770 continue; 771 } 772 TAILQ_INIT(dnr); 773 } 774 TAILQ_INSERT_HEAD(dnr, rt, next); 775 } 776 if (dnr == NULL) 777 continue; 778 #ifdef IPV4_LOOPBACK_ROUTE 779 dnr = add_loopback_route(dnr, ifp); 780 #endif 781 if (ifp->options->options & DHCPCD_GATEWAY) { 782 dnr = add_router_host_route(dnr, ifp); 783 dnr = add_destination_route(dnr, ifp); 784 } 785 if (dnr == NULL) 786 continue; 787 TAILQ_FOREACH_SAFE(rt, dnr, next, rtn) { 788 rt->iface = ifp; 789 if (ipv4_doroute(rt, nrs) == 1) { 790 TAILQ_REMOVE(dnr, rt, next); 791 TAILQ_INSERT_TAIL(nrs, rt, next); 792 if (rt->dest.s_addr == INADDR_ANY) 793 has_default = 1; 794 } 795 } 796 ipv4_freeroutes(dnr); 797 } 798 799 /* If we don't manage a default route, grab one without a 800 * gateway for any IPv4LL enabled interfaces. */ 801 if (!has_default) { 802 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 803 if ((rt = ipv4ll_default_route(ifp)) != NULL) { 804 if (ipv4_doroute(rt, nrs) == 1) 805 TAILQ_INSERT_TAIL(nrs, rt, next); 806 else 807 free(rt); 808 } 809 } 810 } 811 812 /* Remove old routes we used to manage */ 813 if (ctx->ipv4_routes) { 814 TAILQ_FOREACH(rt, ctx->ipv4_routes, next) { 815 if (find_route(nrs, rt, NULL) == NULL && 816 (rt->iface->options->options & 817 (DHCPCD_EXITING | DHCPCD_PERSISTENT)) != 818 (DHCPCD_EXITING | DHCPCD_PERSISTENT)) 819 d_route(rt); 820 } 821 } 822 ipv4_freeroutes(ctx->ipv4_routes); 823 ctx->ipv4_routes = nrs; 824 } 825 826 int 827 ipv4_deladdr(struct interface *ifp, 828 const struct in_addr *addr, const struct in_addr *net, int keeparp) 829 { 830 struct dhcp_state *dstate; 831 int r; 832 struct ipv4_state *state; 833 struct ipv4_addr *ap; 834 struct arp_state *astate; 835 836 logger(ifp->ctx, LOG_DEBUG, "%s: deleting IP address %s/%d", 837 ifp->name, inet_ntoa(*addr), inet_ntocidr(*net)); 838 839 r = if_deladdress(ifp, addr, net); 840 if (r == -1 && errno != EADDRNOTAVAIL && errno != ENXIO && 841 errno != ENODEV) 842 logger(ifp->ctx, LOG_ERR, "%s: %s: %m", ifp->name, __func__); 843 844 if (!keeparp && (astate = arp_find(ifp, addr)) != NULL) 845 arp_free(astate); 846 847 state = IPV4_STATE(ifp); 848 TAILQ_FOREACH(ap, &state->addrs, next) { 849 if (ap->addr.s_addr == addr->s_addr && 850 ap->net.s_addr == net->s_addr) 851 { 852 TAILQ_REMOVE(&state->addrs, ap, next); 853 free(ap); 854 break; 855 } 856 } 857 858 /* Have to do this last incase the function arguments 859 * were these very pointers. */ 860 dstate = D_STATE(ifp); 861 if (dstate && 862 dstate->addr.s_addr == addr->s_addr && 863 dstate->net.s_addr == net->s_addr) 864 { 865 dstate->added = 0; 866 dstate->addr.s_addr = 0; 867 dstate->net.s_addr = 0; 868 } 869 return r; 870 } 871 872 static int 873 delete_address(struct interface *ifp) 874 { 875 int r; 876 struct if_options *ifo; 877 struct dhcp_state *state; 878 879 state = D_STATE(ifp); 880 ifo = ifp->options; 881 if (ifo->options & DHCPCD_INFORM || 882 (ifo->options & DHCPCD_STATIC && ifo->req_addr.s_addr == 0)) 883 return 0; 884 r = ipv4_deladdr(ifp, &state->addr, &state->net, 0); 885 return r; 886 } 887 888 struct ipv4_state * 889 ipv4_getstate(struct interface *ifp) 890 { 891 struct ipv4_state *state; 892 893 state = IPV4_STATE(ifp); 894 if (state == NULL) { 895 ifp->if_data[IF_DATA_IPV4] = malloc(sizeof(*state)); 896 state = IPV4_STATE(ifp); 897 if (state == NULL) { 898 logger(ifp->ctx, LOG_ERR, "%s: %m", __func__); 899 return NULL; 900 } 901 TAILQ_INIT(&state->addrs); 902 TAILQ_INIT(&state->routes); 903 #ifdef BSD 904 state->buffer_size = state->buffer_len = state->buffer_pos = 0; 905 state->buffer = NULL; 906 #endif 907 } 908 return state; 909 } 910 911 struct ipv4_addr * 912 ipv4_addaddr(struct interface *ifp, const struct in_addr *addr, 913 const struct in_addr *mask, const struct in_addr *bcast) 914 { 915 struct ipv4_state *state; 916 struct ipv4_addr *ia; 917 918 if ((state = ipv4_getstate(ifp)) == NULL) { 919 logger(ifp->ctx, LOG_ERR, "%s: ipv4_getstate: %m", __func__); 920 return NULL; 921 } 922 if (ifp->options->options & DHCPCD_NOALIAS) { 923 struct ipv4_addr *ian; 924 925 TAILQ_FOREACH_SAFE(ia, &state->addrs, next, ian) { 926 if (ia->addr.s_addr != addr->s_addr) 927 ipv4_deladdr(ifp, &ia->addr, &ia->net, 0); 928 } 929 } 930 931 if ((ia = malloc(sizeof(*ia))) == NULL) { 932 logger(ifp->ctx, LOG_ERR, "%s: %m", __func__); 933 return NULL; 934 } 935 936 logger(ifp->ctx, LOG_DEBUG, "%s: adding IP address %s/%d", 937 ifp->name, inet_ntoa(*addr), inet_ntocidr(*mask)); 938 if (if_addaddress(ifp, addr, mask, bcast) == -1) { 939 if (errno != EEXIST) 940 logger(ifp->ctx, LOG_ERR, "%s: if_addaddress: %m", 941 __func__); 942 free(ia); 943 return NULL; 944 } 945 946 ia->iface = ifp; 947 ia->addr = *addr; 948 ia->net = *mask; 949 #ifdef IN_IFF_TENTATIVE 950 ia->addr_flags = IN_IFF_TENTATIVE; 951 #endif 952 TAILQ_INSERT_TAIL(&state->addrs, ia, next); 953 return ia; 954 } 955 956 static int 957 ipv4_daddaddr(struct interface *ifp, const struct dhcp_lease *lease) 958 { 959 struct dhcp_state *state; 960 961 if (ipv4_addaddr(ifp, &lease->addr, &lease->net, &lease->brd) == NULL) 962 return -1; 963 964 state = D_STATE(ifp); 965 state->added = STATE_ADDED; 966 967 state->addr.s_addr = lease->addr.s_addr; 968 state->net.s_addr = lease->net.s_addr; 969 970 return 0; 971 } 972 973 int 974 ipv4_preferanother(struct interface *ifp) 975 { 976 struct dhcp_state *state = D_STATE(ifp), *nstate; 977 struct interface *ifn; 978 int preferred; 979 980 if (state == NULL) 981 return 0; 982 983 preferred = 0; 984 if (!state->added) 985 goto out; 986 987 TAILQ_FOREACH(ifn, ifp->ctx->ifaces, next) { 988 if (ifn == ifp) 989 break; /* We are already the most preferred */ 990 nstate = D_STATE(ifn); 991 if (nstate && !nstate->added && 992 nstate->lease.addr.s_addr == state->addr.s_addr) 993 { 994 preferred = 1; 995 delete_address(ifp); 996 if (ifn->options->options & DHCPCD_ARP) 997 dhcp_bind(ifn); 998 else { 999 ipv4_daddaddr(ifn, &nstate->lease); 1000 nstate->added = STATE_ADDED; 1001 } 1002 break; 1003 } 1004 } 1005 1006 out: 1007 ipv4_buildroutes(ifp->ctx); 1008 return preferred; 1009 } 1010 1011 void 1012 ipv4_applyaddr(void *arg) 1013 { 1014 struct interface *ifp = arg, *ifn; 1015 struct dhcp_state *state = D_STATE(ifp), *nstate; 1016 struct dhcp_message *dhcp; 1017 struct dhcp_lease *lease; 1018 struct if_options *ifo = ifp->options; 1019 struct ipv4_addr *ap; 1020 int r; 1021 1022 if (state == NULL) 1023 return; 1024 dhcp = state->new; 1025 lease = &state->lease; 1026 1027 if_sortinterfaces(ifp->ctx); 1028 if (dhcp == NULL) { 1029 if ((ifo->options & (DHCPCD_EXITING | DHCPCD_PERSISTENT)) != 1030 (DHCPCD_EXITING | DHCPCD_PERSISTENT)) 1031 { 1032 if (state->added && !ipv4_preferanother(ifp)) { 1033 delete_address(ifp); 1034 ipv4_buildroutes(ifp->ctx); 1035 } 1036 script_runreason(ifp, state->reason); 1037 } else 1038 ipv4_buildroutes(ifp->ctx); 1039 return; 1040 } 1041 1042 /* Ensure only one interface has the address */ 1043 r = 0; 1044 TAILQ_FOREACH(ifn, ifp->ctx->ifaces, next) { 1045 if (ifn == ifp) { 1046 r = 1; /* past ourselves */ 1047 continue; 1048 } 1049 nstate = D_STATE(ifn); 1050 if (nstate && nstate->added && 1051 nstate->addr.s_addr == lease->addr.s_addr) 1052 { 1053 if (r == 0) { 1054 logger(ifp->ctx, LOG_INFO, 1055 "%s: preferring %s on %s", 1056 ifp->name, 1057 inet_ntoa(lease->addr), 1058 ifn->name); 1059 return; 1060 } 1061 logger(ifp->ctx, LOG_INFO, "%s: preferring %s on %s", 1062 ifn->name, 1063 inet_ntoa(lease->addr), 1064 ifp->name); 1065 ipv4_deladdr(ifn, &nstate->addr, &nstate->net, 0); 1066 break; 1067 } 1068 } 1069 1070 /* Does another interface already have the address from a prior boot? */ 1071 if (ifn == NULL) { 1072 TAILQ_FOREACH(ifn, ifp->ctx->ifaces, next) { 1073 if (ifn == ifp) 1074 continue; 1075 ap = ipv4_iffindaddr(ifn, &lease->addr, NULL); 1076 if (ap) 1077 ipv4_deladdr(ifn, &ap->addr, &ap->net, 0); 1078 } 1079 } 1080 1081 /* If the netmask is different, delete the addresss */ 1082 ap = ipv4_iffindaddr(ifp, &lease->addr, NULL); 1083 if (ap && ap->net.s_addr != lease->net.s_addr) 1084 ipv4_deladdr(ifp, &ap->addr, &ap->net, 0); 1085 1086 if (ipv4_iffindaddr(ifp, &lease->addr, &lease->net)) 1087 logger(ifp->ctx, LOG_DEBUG, 1088 "%s: IP address %s/%d already exists", 1089 ifp->name, inet_ntoa(lease->addr), 1090 inet_ntocidr(lease->net)); 1091 else { 1092 r = ipv4_daddaddr(ifp, lease); 1093 if (r == -1 && errno != EEXIST) 1094 return; 1095 } 1096 1097 #ifdef IN_IFF_NOTUSEABLE 1098 ap = ipv4_iffindaddr(ifp, &lease->addr, NULL); 1099 if (ap == NULL) { 1100 logger(ifp->ctx, LOG_ERR, "%s: added address vanished", 1101 ifp->name); 1102 return; 1103 } else if (ap->addr_flags & IN_IFF_NOTUSEABLE) 1104 return; 1105 #endif 1106 1107 /* Delete the old address if different */ 1108 if (state->addr.s_addr != lease->addr.s_addr && 1109 state->addr.s_addr != 0 && 1110 ipv4_iffindaddr(ifp, &lease->addr, NULL)) 1111 delete_address(ifp); 1112 1113 state->added = STATE_ADDED; 1114 state->addr.s_addr = lease->addr.s_addr; 1115 state->net.s_addr = lease->net.s_addr; 1116 1117 /* Find any freshly added routes, such as the subnet route. 1118 * We do this because we cannot rely on recieving the kernel 1119 * notification right now via our link socket. */ 1120 if_initrt(ifp); 1121 ipv4_buildroutes(ifp->ctx); 1122 script_runreason(ifp, state->reason); 1123 1124 dhcpcd_daemonise(ifp->ctx); 1125 } 1126 1127 void 1128 ipv4_handleifa(struct dhcpcd_ctx *ctx, 1129 int cmd, struct if_head *ifs, const char *ifname, 1130 const struct in_addr *addr, const struct in_addr *net, 1131 const struct in_addr *dst, int flags) 1132 { 1133 struct interface *ifp; 1134 struct ipv4_state *state; 1135 struct ipv4_addr *ap; 1136 1137 if (ifs == NULL) 1138 ifs = ctx->ifaces; 1139 if (ifs == NULL) { 1140 errno = ESRCH; 1141 return; 1142 } 1143 if (addr->s_addr == INADDR_ANY) { 1144 errno = EINVAL; 1145 return; 1146 } 1147 if ((ifp = if_find(ifs, ifname)) == NULL) 1148 return; 1149 if ((state = ipv4_getstate(ifp)) == NULL) { 1150 errno = ENOENT; 1151 return; 1152 } 1153 1154 ap = ipv4_iffindaddr(ifp, addr, net); 1155 if (cmd == RTM_NEWADDR) { 1156 if (ap == NULL) { 1157 if ((ap = malloc(sizeof(*ap))) == NULL) { 1158 logger(ifp->ctx, LOG_ERR, "%s: %m", __func__); 1159 return; 1160 } 1161 ap->iface = ifp; 1162 ap->addr = *addr; 1163 ap->net = *net; 1164 if (dst) 1165 ap->dst.s_addr = dst->s_addr; 1166 else 1167 ap->dst.s_addr = INADDR_ANY; 1168 TAILQ_INSERT_TAIL(&state->addrs, ap, next); 1169 } 1170 ap->addr_flags = flags; 1171 } else if (cmd == RTM_DELADDR) { 1172 if (ap) { 1173 TAILQ_REMOVE(&state->addrs, ap, next); 1174 free(ap); 1175 } 1176 } 1177 1178 dhcp_handleifa(cmd, ifp, addr, net, dst, flags); 1179 arp_handleifa(cmd, ifp, addr, flags); 1180 } 1181 1182 void 1183 ipv4_free(struct interface *ifp) 1184 { 1185 struct ipv4_state *state; 1186 struct ipv4_addr *addr; 1187 1188 if (ifp) { 1189 state = IPV4_STATE(ifp); 1190 if (state) { 1191 while ((addr = TAILQ_FIRST(&state->addrs))) { 1192 TAILQ_REMOVE(&state->addrs, addr, next); 1193 free(addr); 1194 } 1195 ipv4_freerts(&state->routes); 1196 #ifdef BSD 1197 free(state->buffer); 1198 #endif 1199 free(state); 1200 } 1201 } 1202 } 1203 1204 void 1205 ipv4_ctxfree(struct dhcpcd_ctx *ctx) 1206 { 1207 1208 ipv4_freeroutes(ctx->ipv4_routes); 1209 ipv4_freeroutes(ctx->ipv4_kroutes); 1210 } 1211