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