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/param.h> 30 #include <sys/types.h> 31 #include <sys/socket.h> 32 #include <sys/stat.h> 33 34 #include <arpa/inet.h> 35 #include <net/if.h> 36 #include <net/route.h> 37 #include <netinet/in.h> 38 #include <netinet/if_ether.h> 39 40 #include "config.h" 41 42 #ifdef HAVE_SYS_BITOPS_H 43 #include <sys/bitops.h> 44 #else 45 #include "compat/bitops.h" 46 #endif 47 48 #ifdef BSD 49 /* Purely for the ND6_IFF_AUTO_LINKLOCAL #define which is solely used 50 * to generate our CAN_ADD_LLADDR #define. */ 51 # include <netinet6/in6_var.h> 52 # include <netinet6/nd6.h> 53 #endif 54 55 #include <errno.h> 56 #include <ifaddrs.h> 57 #include <inttypes.h> 58 #include <stdlib.h> 59 #include <string.h> 60 #include <syslog.h> 61 #include <unistd.h> 62 63 #define ELOOP_QUEUE ELOOP_IPV6 64 #include "common.h" 65 #include "if.h" 66 #include "dhcpcd.h" 67 #include "dhcp6.h" 68 #include "eloop.h" 69 #include "ipv6.h" 70 #include "ipv6nd.h" 71 #include "logerr.h" 72 #include "privsep.h" 73 #include "sa.h" 74 #include "script.h" 75 76 #ifdef HAVE_MD5_H 77 # ifndef DEPGEN 78 # include <md5.h> 79 # endif 80 #endif 81 82 #ifdef SHA2_H 83 # include SHA2_H 84 #endif 85 86 #ifndef SHA256_DIGEST_LENGTH 87 # define SHA256_DIGEST_LENGTH 32 88 #endif 89 90 #ifdef IPV6_POLLADDRFLAG 91 # warning kernel does not report IPv6 address flag changes 92 # warning polling tentative address flags periodically 93 #endif 94 95 /* Hackery at it's finest. */ 96 #ifndef s6_addr32 97 # ifdef __sun 98 # define s6_addr32 _S6_un._S6_u32 99 # else 100 # define s6_addr32 __u6_addr.__u6_addr32 101 # endif 102 #endif 103 104 #if defined(HAVE_IN6_ADDR_GEN_MODE_NONE) || defined(ND6_IFF_AUTO_LINKLOCAL) || \ 105 defined(IFF_NOLINKLOCAL) 106 /* Only add the LL address if we have a carrier, so DaD works. */ 107 #define CAN_ADD_LLADDR(ifp) \ 108 (!((ifp)->options->options & DHCPCD_LINK) || if_is_link_up((ifp))) 109 #ifdef __sun 110 /* Although we can add our own LL address, we cannot drop it 111 * without unplumbing the if which is a lot of code. 112 * So just keep it for the time being. */ 113 #define CAN_DROP_LLADDR(ifp) (0) 114 #else 115 #define CAN_DROP_LLADDR(ifp) (1) 116 #endif 117 #else 118 /* We have no control over the OS adding the LLADDR, so just let it do it 119 * as we cannot force our own view on it. */ 120 #define CAN_ADD_LLADDR(ifp) (0) 121 #define CAN_DROP_LLADDR(ifp) (0) 122 #endif 123 124 #ifdef IPV6_MANAGETEMPADDR 125 static void ipv6_regentempaddr(void *); 126 #endif 127 128 int 129 ipv6_init(struct dhcpcd_ctx *ctx) 130 { 131 132 if (ctx->ra_routers != NULL) 133 return 0; 134 135 ctx->ra_routers = malloc(sizeof(*ctx->ra_routers)); 136 if (ctx->ra_routers == NULL) 137 return -1; 138 TAILQ_INIT(ctx->ra_routers); 139 140 #ifndef __sun 141 ctx->nd_fd = -1; 142 #endif 143 #ifdef DHCP6 144 ctx->dhcp6_rfd = -1; 145 ctx->dhcp6_wfd = -1; 146 #endif 147 return 0; 148 } 149 150 static ssize_t 151 ipv6_readsecret(struct dhcpcd_ctx *ctx) 152 { 153 char line[1024]; 154 unsigned char *p; 155 size_t len; 156 uint32_t r; 157 158 ctx->secret_len = dhcp_read_hwaddr_aton(ctx, &ctx->secret, SECRET); 159 if (ctx->secret_len != 0) 160 return (ssize_t)ctx->secret_len; 161 162 if (errno != ENOENT) 163 logerr("%s: cannot read secret", __func__); 164 165 /* Chaining arc4random should be good enough. 166 * RFC7217 section 5.1 states the key SHOULD be at least 128 bits. 167 * To attempt and future proof ourselves, we'll generate a key of 168 * 512 bits (64 bytes). */ 169 if (ctx->secret_len < 64) { 170 if ((ctx->secret = malloc(64)) == NULL) { 171 logerr(__func__); 172 return -1; 173 } 174 ctx->secret_len = 64; 175 } 176 p = ctx->secret; 177 for (len = 0; len < 512 / NBBY; len += sizeof(r)) { 178 r = arc4random(); 179 memcpy(p, &r, sizeof(r)); 180 p += sizeof(r); 181 } 182 183 hwaddr_ntoa(ctx->secret, ctx->secret_len, line, sizeof(line)); 184 len = strlen(line); 185 if (len < sizeof(line) - 2) { 186 line[len++] = '\n'; 187 line[len] = '\0'; 188 } 189 if (dhcp_writefile(ctx, SECRET, S_IRUSR, line, len) == -1) { 190 logerr("%s: cannot write secret", __func__); 191 ctx->secret_len = 0; 192 return -1; 193 } 194 return (ssize_t)ctx->secret_len; 195 } 196 197 /* http://www.iana.org/assignments/ipv6-interface-ids/ipv6-interface-ids.xhtml 198 * RFC5453 */ 199 static const struct reslowhigh { 200 const uint8_t high[8]; 201 const uint8_t low[8]; 202 } reslowhigh[] = { 203 /* RFC4291 + RFC6543 */ 204 { { 0x02, 0x00, 0x5e, 0xff, 0xfe, 0x00, 0x00, 0x00 }, 205 { 0x02, 0x00, 0x5e, 0xff, 0xfe, 0xff, 0xff, 0xff } }, 206 /* RFC2526 */ 207 { { 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80 }, 208 { 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } } 209 }; 210 211 static bool 212 ipv6_reserved(const struct in6_addr *addr) 213 { 214 uint64_t id, low, high; 215 size_t i; 216 const struct reslowhigh *r; 217 218 id = be64dec(addr->s6_addr + sizeof(id)); 219 if (id == 0) /* RFC4291 */ 220 return 1; 221 for (i = 0; i < __arraycount(reslowhigh); i++) { 222 r = &reslowhigh[i]; 223 low = be64dec(r->low); 224 high = be64dec(r->high); 225 if (id >= low && id <= high) 226 return true; 227 } 228 return false; 229 } 230 231 /* RFC7217 */ 232 static int 233 ipv6_makestableprivate1(struct dhcpcd_ctx *ctx, 234 struct in6_addr *addr, const struct in6_addr *prefix, int prefix_len, 235 const unsigned char *netiface, size_t netiface_len, 236 const unsigned char *netid, size_t netid_len, 237 unsigned short vlanid, 238 uint32_t *dad_counter) 239 { 240 unsigned char buf[2048], *p, digest[SHA256_DIGEST_LENGTH]; 241 size_t len, l; 242 SHA256_CTX sha_ctx; 243 244 if (prefix_len < 0 || prefix_len > 120) { 245 errno = EINVAL; 246 return -1; 247 } 248 249 if (ctx->secret_len == 0) { 250 if (ipv6_readsecret(ctx) == -1) 251 return -1; 252 } 253 254 l = (size_t)(ROUNDUP8(prefix_len) / NBBY); 255 len = l + netiface_len + netid_len + sizeof(*dad_counter) + 256 ctx->secret_len; 257 if (vlanid != 0) 258 len += sizeof(vlanid); 259 if (len > sizeof(buf)) { 260 errno = ENOBUFS; 261 return -1; 262 } 263 264 for (;; (*dad_counter)++) { 265 /* Combine all parameters into one buffer */ 266 p = buf; 267 memcpy(p, prefix, l); 268 p += l; 269 memcpy(p, netiface, netiface_len); 270 p += netiface_len; 271 memcpy(p, netid, netid_len); 272 p += netid_len; 273 /* Don't use a vlanid if not set. 274 * This ensures prior versions have the same unique address. */ 275 if (vlanid != 0) { 276 memcpy(p, &vlanid, sizeof(vlanid)); 277 p += sizeof(vlanid); 278 } 279 memcpy(p, dad_counter, sizeof(*dad_counter)); 280 p += sizeof(*dad_counter); 281 memcpy(p, ctx->secret, ctx->secret_len); 282 283 /* Make an address using the digest of the above. 284 * RFC7217 Section 5.1 states that we shouldn't use MD5. 285 * Pity as we use that for HMAC-MD5 which is still deemed OK. 286 * SHA-256 is recommended */ 287 SHA256_Init(&sha_ctx); 288 SHA256_Update(&sha_ctx, buf, len); 289 SHA256_Final(digest, &sha_ctx); 290 291 p = addr->s6_addr; 292 memcpy(p, prefix, l); 293 /* RFC7217 section 5.2 says we need to start taking the id from 294 * the least significant bit */ 295 len = sizeof(addr->s6_addr) - l; 296 memcpy(p + l, digest + (sizeof(digest) - len), len); 297 298 /* Ensure that the Interface ID does not match a reserved one, 299 * if it does then treat it as a DAD failure. 300 * RFC7217 section 5.2 */ 301 if (prefix_len != 64) 302 break; 303 if (!ipv6_reserved(addr)) 304 break; 305 } 306 307 return 0; 308 } 309 310 int 311 ipv6_makestableprivate(struct in6_addr *addr, 312 const struct in6_addr *prefix, int prefix_len, 313 const struct interface *ifp, 314 int *dad_counter) 315 { 316 uint32_t dad; 317 int r; 318 319 dad = (uint32_t)*dad_counter; 320 321 /* For our implementation, we shall set the hardware address 322 * as the interface identifier */ 323 r = ipv6_makestableprivate1(ifp->ctx, addr, prefix, prefix_len, 324 ifp->hwaddr, ifp->hwlen, 325 ifp->ssid, ifp->ssid_len, 326 ifp->vlanid, &dad); 327 328 if (r == 0) 329 *dad_counter = (int)dad; 330 return r; 331 } 332 333 #ifdef IPV6_AF_TEMPORARY 334 static int 335 ipv6_maketemporaryaddress(struct in6_addr *addr, 336 const struct in6_addr *prefix, int prefix_len, 337 const struct interface *ifp) 338 { 339 struct in6_addr mask; 340 struct interface *ifpn; 341 342 if (ipv6_mask(&mask, prefix_len) == -1) 343 return -1; 344 *addr = *prefix; 345 346 again: 347 addr->s6_addr32[2] |= (arc4random() & ~mask.s6_addr32[2]); 348 addr->s6_addr32[3] |= (arc4random() & ~mask.s6_addr32[3]); 349 350 TAILQ_FOREACH(ifpn, ifp->ctx->ifaces, next) { 351 if (ipv6_iffindaddr(ifpn, addr, 0) != NULL) 352 break; 353 } 354 if (ifpn != NULL) 355 goto again; 356 if (ipv6_reserved(addr)) 357 goto again; 358 return 0; 359 } 360 #endif 361 362 int 363 ipv6_makeaddr(struct in6_addr *addr, struct interface *ifp, 364 const struct in6_addr *prefix, int prefix_len, unsigned int flags) 365 { 366 const struct ipv6_addr *ap; 367 int dad; 368 369 if (prefix_len < 0 || prefix_len > 120) { 370 errno = EINVAL; 371 return -1; 372 } 373 374 #ifdef IPV6_AF_TEMPORARY 375 if (flags & IPV6_AF_TEMPORARY) 376 return ipv6_maketemporaryaddress(addr, prefix, prefix_len, ifp); 377 #else 378 UNUSED(flags); 379 #endif 380 381 if (ifp->options->options & DHCPCD_SLAACPRIVATE) { 382 dad = 0; 383 if (ipv6_makestableprivate(addr, 384 prefix, prefix_len, ifp, &dad) == -1) 385 return -1; 386 return dad; 387 } 388 389 if (prefix_len > 64) { 390 errno = EINVAL; 391 return -1; 392 } 393 if ((ap = ipv6_linklocal(ifp)) == NULL) { 394 /* We delay a few functions until we get a local-link address 395 * so this should never be hit. */ 396 errno = ENOENT; 397 return -1; 398 } 399 400 /* Make the address from the first local-link address */ 401 memcpy(addr, prefix, sizeof(*prefix)); 402 addr->s6_addr32[2] = ap->addr.s6_addr32[2]; 403 addr->s6_addr32[3] = ap->addr.s6_addr32[3]; 404 return 0; 405 } 406 407 static int 408 ipv6_makeprefix(struct in6_addr *prefix, const struct in6_addr *addr, int len) 409 { 410 struct in6_addr mask; 411 size_t i; 412 413 if (ipv6_mask(&mask, len) == -1) 414 return -1; 415 *prefix = *addr; 416 for (i = 0; i < sizeof(prefix->s6_addr); i++) 417 prefix->s6_addr[i] &= mask.s6_addr[i]; 418 return 0; 419 } 420 421 int 422 ipv6_mask(struct in6_addr *mask, int len) 423 { 424 static const unsigned char masks[NBBY] = 425 { 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff }; 426 int bytes, bits, i; 427 428 if (len < 0 || len > 128) { 429 errno = EINVAL; 430 return -1; 431 } 432 433 memset(mask, 0, sizeof(*mask)); 434 bytes = len / NBBY; 435 bits = len % NBBY; 436 for (i = 0; i < bytes; i++) 437 mask->s6_addr[i] = 0xff; 438 if (bits != 0) { 439 /* Coverify false positive. 440 * bytelen cannot be 16 if bitlen is non zero */ 441 /* coverity[overrun-local] */ 442 mask->s6_addr[bytes] = masks[bits - 1]; 443 } 444 return 0; 445 } 446 447 uint8_t 448 ipv6_prefixlen(const struct in6_addr *mask) 449 { 450 int x = 0, y; 451 const unsigned char *lim, *p; 452 453 lim = (const unsigned char *)mask + sizeof(*mask); 454 for (p = (const unsigned char *)mask; p < lim; x++, p++) { 455 if (*p != 0xff) 456 break; 457 } 458 y = 0; 459 if (p < lim) { 460 for (y = 0; y < NBBY; y++) { 461 if ((*p & (0x80 >> y)) == 0) 462 break; 463 } 464 } 465 466 /* 467 * when the limit pointer is given, do a stricter check on the 468 * remaining bits. 469 */ 470 if (p < lim) { 471 if (y != 0 && (*p & (0x00ff >> y)) != 0) 472 return 0; 473 for (p = p + 1; p < lim; p++) 474 if (*p != 0) 475 return 0; 476 } 477 478 return (uint8_t)(x * NBBY + y); 479 } 480 481 static void 482 in6_to_h64(uint64_t *vhigh, uint64_t *vlow, const struct in6_addr *addr) 483 { 484 485 *vhigh = be64dec(addr->s6_addr); 486 *vlow = be64dec(addr->s6_addr + 8); 487 } 488 489 static void 490 h64_to_in6(struct in6_addr *addr, uint64_t vhigh, uint64_t vlow) 491 { 492 493 be64enc(addr->s6_addr, vhigh); 494 be64enc(addr->s6_addr + 8, vlow); 495 } 496 497 int 498 ipv6_userprefix( 499 const struct in6_addr *prefix, // prefix from router 500 short prefix_len, // length of prefix received 501 uint64_t user_number, // "random" number from user 502 struct in6_addr *result, // resultant prefix 503 short result_len) // desired prefix length 504 { 505 uint64_t vh, vl, user_low, user_high; 506 507 if (prefix_len < 1 || prefix_len > 128 || 508 result_len < 1 || result_len > 128) 509 { 510 errno = EINVAL; 511 return -1; 512 } 513 514 /* Check that the user_number fits inside result_len less prefix_len */ 515 if (result_len < prefix_len || 516 fls64(user_number) > result_len - prefix_len) 517 { 518 errno = ERANGE; 519 return -1; 520 } 521 522 /* If user_number is zero, just copy the prefix into the result. */ 523 if (user_number == 0) { 524 *result = *prefix; 525 return 0; 526 } 527 528 /* Shift user_number so it fit's just inside result_len. 529 * Shifting by 0 or sizeof(user_number) is undefined, 530 * so we cater for that. */ 531 if (result_len == 128) { 532 user_high = 0; 533 user_low = user_number; 534 } else if (result_len > 64) { 535 if (prefix_len >= 64) 536 user_high = 0; 537 else 538 user_high = user_number >> (result_len - prefix_len); 539 user_low = user_number << (128 - result_len); 540 } else if (result_len == 64) { 541 user_high = user_number; 542 user_low = 0; 543 } else { 544 user_high = user_number << (64 - result_len); 545 user_low = 0; 546 } 547 548 /* convert to two 64bit host order values */ 549 in6_to_h64(&vh, &vl, prefix); 550 551 vh |= user_high; 552 vl |= user_low; 553 554 /* copy back result */ 555 h64_to_in6(result, vh, vl); 556 557 return 0; 558 } 559 560 #ifdef IPV6_POLLADDRFLAG 561 void 562 ipv6_checkaddrflags(void *arg) 563 { 564 struct ipv6_addr *ia; 565 int flags; 566 const char *alias; 567 568 ia = arg; 569 #ifdef ALIAS_ADDR 570 alias = ia->alias; 571 #else 572 alias = NULL; 573 #endif 574 if ((flags = if_addrflags6(ia->iface, &ia->addr, alias)) == -1) { 575 if (errno != EEXIST && errno != EADDRNOTAVAIL) 576 logerr("%s: if_addrflags6", __func__); 577 return; 578 } 579 580 if (!(flags & IN6_IFF_TENTATIVE)) { 581 /* Simulate the kernel announcing the new address. */ 582 ipv6_handleifa(ia->iface->ctx, RTM_NEWADDR, 583 ia->iface->ctx->ifaces, ia->iface->name, 584 &ia->addr, ia->prefix_len, flags, 0); 585 } else { 586 /* Still tentative? Check again in a bit. */ 587 eloop_timeout_add_msec(ia->iface->ctx->eloop, 588 RETRANS_TIMER / 2, ipv6_checkaddrflags, ia); 589 } 590 } 591 #endif 592 593 static void 594 ipv6_deletedaddr(struct ipv6_addr *ia) 595 { 596 597 #ifdef DHCP6 598 #ifdef PRIVSEP 599 if (!(ia->iface->ctx->options & DHCPCD_MANAGER)) 600 ps_inet_closedhcp6(ia); 601 #elif defined(SMALL) 602 UNUSED(ia); 603 #else 604 /* NOREJECT is set if we delegated exactly the prefix to another 605 * address. 606 * This can only be one address, so just clear the flag. 607 * This should ensure the reject route will be restored. */ 608 if (ia->delegating_prefix != NULL) 609 ia->delegating_prefix->flags &= ~IPV6_AF_NOREJECT; 610 #endif 611 #else 612 UNUSED(ia); 613 #endif 614 } 615 616 void 617 ipv6_deleteaddr(struct ipv6_addr *ia) 618 { 619 struct ipv6_state *state; 620 struct ipv6_addr *ap; 621 622 loginfox("%s: deleting address %s", ia->iface->name, ia->saddr); 623 if (if_address6(RTM_DELADDR, ia) == -1 && 624 errno != EADDRNOTAVAIL && errno != ESRCH && 625 errno != ENXIO && errno != ENODEV) 626 logerr(__func__); 627 628 ipv6_deletedaddr(ia); 629 630 state = IPV6_STATE(ia->iface); 631 TAILQ_FOREACH(ap, &state->addrs, next) { 632 if (IN6_ARE_ADDR_EQUAL(&ap->addr, &ia->addr)) { 633 TAILQ_REMOVE(&state->addrs, ap, next); 634 ipv6_freeaddr(ap); 635 break; 636 } 637 } 638 639 #ifdef ND6_ADVERTISE 640 /* Advertise the address if it exists on another interface. */ 641 ipv6nd_advertise(ia); 642 #endif 643 } 644 645 static int 646 ipv6_addaddr1(struct ipv6_addr *ia, const struct timespec *now) 647 { 648 struct interface *ifp; 649 uint32_t pltime, vltime; 650 int loglevel; 651 #ifdef ND6_ADVERTISE 652 bool vltime_was_zero = ia->prefix_vltime == 0; 653 #endif 654 #ifdef __sun 655 struct ipv6_state *state; 656 struct ipv6_addr *ia2; 657 658 /* If we re-add then address on Solaris then the prefix 659 * route will be scrubbed and re-added. Something might 660 * be using it, so let's avoid it. */ 661 if (ia->flags & IPV6_AF_DADCOMPLETED) { 662 logdebugx("%s: IP address %s already exists", 663 ia->iface->name, ia->saddr); 664 #ifdef ND6_ADVERTISE 665 goto advertise; 666 #else 667 return 0; 668 #endif 669 } 670 #endif 671 672 /* Remember the interface of the address. */ 673 ifp = ia->iface; 674 675 if (!(ia->flags & IPV6_AF_DADCOMPLETED) && 676 ipv6_iffindaddr(ifp, &ia->addr, IN6_IFF_NOTUSEABLE)) 677 ia->flags |= IPV6_AF_DADCOMPLETED; 678 679 /* Adjust plftime and vltime based on acquired time */ 680 pltime = ia->prefix_pltime; 681 vltime = ia->prefix_vltime; 682 683 if (ifp->options->options & DHCPCD_LASTLEASE_EXTEND) { 684 /* We don't want the kernel to expire the address. 685 * The saved times will be re-applied to the ia 686 * before exiting this function. */ 687 ia->prefix_vltime = ia->prefix_pltime = ND6_INFINITE_LIFETIME; 688 } 689 690 if (timespecisset(&ia->acquired) && 691 (ia->prefix_pltime != ND6_INFINITE_LIFETIME || 692 ia->prefix_vltime != ND6_INFINITE_LIFETIME)) 693 { 694 uint32_t elapsed; 695 struct timespec n; 696 697 if (now == NULL) { 698 clock_gettime(CLOCK_MONOTONIC, &n); 699 now = &n; 700 } 701 elapsed = (uint32_t)eloop_timespec_diff(now, &ia->acquired, 702 NULL); 703 if (ia->prefix_pltime != ND6_INFINITE_LIFETIME) { 704 if (elapsed > ia->prefix_pltime) 705 ia->prefix_pltime = 0; 706 else 707 ia->prefix_pltime -= elapsed; 708 } 709 if (ia->prefix_vltime != ND6_INFINITE_LIFETIME) { 710 if (elapsed > ia->prefix_vltime) 711 ia->prefix_vltime = 0; 712 else 713 ia->prefix_vltime -= elapsed; 714 } 715 } 716 717 loglevel = ia->flags & IPV6_AF_NEW ? LOG_INFO : LOG_DEBUG; 718 logmessage(loglevel, "%s: adding %saddress %s", ifp->name, 719 #ifdef IPV6_AF_TEMPORARY 720 ia->flags & IPV6_AF_TEMPORARY ? "temporary " : "", 721 #else 722 "", 723 #endif 724 ia->saddr); 725 if (ia->prefix_pltime == ND6_INFINITE_LIFETIME && 726 ia->prefix_vltime == ND6_INFINITE_LIFETIME) 727 logdebugx("%s: pltime infinity, vltime infinity", 728 ifp->name); 729 else if (ia->prefix_pltime == ND6_INFINITE_LIFETIME) 730 logdebugx("%s: pltime infinity, vltime %"PRIu32" seconds", 731 ifp->name, ia->prefix_vltime); 732 else if (ia->prefix_vltime == ND6_INFINITE_LIFETIME) 733 logdebugx("%s: pltime %"PRIu32"seconds, vltime infinity", 734 ifp->name, ia->prefix_pltime); 735 else 736 logdebugx("%s: pltime %"PRIu32" seconds, vltime %"PRIu32 737 " seconds", 738 ifp->name, ia->prefix_pltime, ia->prefix_vltime); 739 740 if (if_address6(RTM_NEWADDR, ia) == -1) { 741 logerr(__func__); 742 /* Restore real pltime and vltime */ 743 ia->prefix_pltime = pltime; 744 ia->prefix_vltime = vltime; 745 return -1; 746 } 747 748 #ifdef IPV6_MANAGETEMPADDR 749 /* RFC4941 Section 3.4 */ 750 if (ia->flags & IPV6_AF_TEMPORARY && 751 ia->prefix_pltime && 752 ia->prefix_vltime && 753 ifp->options->options & DHCPCD_SLAACTEMP) 754 eloop_timeout_add_sec(ifp->ctx->eloop, 755 ia->prefix_pltime - REGEN_ADVANCE, 756 ipv6_regentempaddr, ia); 757 #endif 758 759 /* Restore real pltime and vltime */ 760 ia->prefix_pltime = pltime; 761 ia->prefix_vltime = vltime; 762 763 ia->flags &= ~IPV6_AF_NEW; 764 ia->flags |= IPV6_AF_ADDED; 765 #ifndef SMALL 766 if (ia->delegating_prefix != NULL) 767 ia->flags |= IPV6_AF_DELEGATED; 768 #endif 769 770 #ifdef IPV6_POLLADDRFLAG 771 eloop_timeout_delete(ifp->ctx->eloop, 772 ipv6_checkaddrflags, ia); 773 if (!(ia->flags & IPV6_AF_DADCOMPLETED)) { 774 eloop_timeout_add_msec(ifp->ctx->eloop, 775 RETRANS_TIMER / 2, ipv6_checkaddrflags, ia); 776 } 777 #endif 778 779 #ifdef __sun 780 /* Solaris does not announce new addresses which need DaD 781 * so we need to take a copy and add it to our list. 782 * Otherwise aliasing gets confused if we add another 783 * address during DaD. */ 784 785 state = IPV6_STATE(ifp); 786 TAILQ_FOREACH(ia2, &state->addrs, next) { 787 if (IN6_ARE_ADDR_EQUAL(&ia2->addr, &ia->addr)) 788 break; 789 } 790 if (ia2 == NULL) { 791 if ((ia2 = malloc(sizeof(*ia2))) == NULL) { 792 logerr(__func__); 793 return 0; /* Well, we did add the address */ 794 } 795 memcpy(ia2, ia, sizeof(*ia2)); 796 TAILQ_INSERT_TAIL(&state->addrs, ia2, next); 797 } 798 #endif 799 800 #ifdef ND6_ADVERTISE 801 #ifdef __sun 802 advertise: 803 #endif 804 /* Re-advertise the preferred address to be safe. */ 805 if (!vltime_was_zero) 806 ipv6nd_advertise(ia); 807 #endif 808 809 return 0; 810 } 811 812 #ifdef ALIAS_ADDR 813 /* Find the next logical alias address we can use. */ 814 static int 815 ipv6_aliasaddr(struct ipv6_addr *ia, struct ipv6_addr **repl) 816 { 817 struct ipv6_state *state; 818 struct ipv6_addr *iap; 819 unsigned int lun; 820 char alias[IF_NAMESIZE]; 821 822 if (ia->alias[0] != '\0') 823 return 0; 824 state = IPV6_STATE(ia->iface); 825 826 /* First find an existng address. 827 * This can happen when dhcpcd restarts as ND and DHCPv6 828 * maintain their own lists of addresses. */ 829 TAILQ_FOREACH(iap, &state->addrs, next) { 830 if (iap->alias[0] != '\0' && 831 IN6_ARE_ADDR_EQUAL(&iap->addr, &ia->addr)) 832 { 833 strlcpy(ia->alias, iap->alias, sizeof(ia->alias)); 834 return 0; 835 } 836 } 837 838 lun = 0; 839 find_unit: 840 if (if_makealias(alias, IF_NAMESIZE, ia->iface->name, lun) >= 841 IF_NAMESIZE) 842 { 843 errno = ENOMEM; 844 return -1; 845 } 846 TAILQ_FOREACH(iap, &state->addrs, next) { 847 if (iap->alias[0] == '\0') 848 continue; 849 if (IN6_IS_ADDR_UNSPECIFIED(&iap->addr)) { 850 /* No address assigned? Lets use it. */ 851 strlcpy(ia->alias, iap->alias, sizeof(ia->alias)); 852 if (repl) 853 *repl = iap; 854 return 1; 855 } 856 if (strcmp(iap->alias, alias) == 0) 857 break; 858 } 859 860 if (iap != NULL) { 861 if (lun == UINT_MAX) { 862 errno = ERANGE; 863 return -1; 864 } 865 lun++; 866 goto find_unit; 867 } 868 869 strlcpy(ia->alias, alias, sizeof(ia->alias)); 870 return 0; 871 } 872 #endif 873 874 int 875 ipv6_addaddr(struct ipv6_addr *ia, const struct timespec *now) 876 { 877 int r; 878 #ifdef ALIAS_ADDR 879 int replaced, blank; 880 struct ipv6_addr *replaced_ia; 881 882 blank = (ia->alias[0] == '\0'); 883 if ((replaced = ipv6_aliasaddr(ia, &replaced_ia)) == -1) 884 return -1; 885 if (blank) 886 logdebugx("%s: aliased %s", ia->alias, ia->saddr); 887 #endif 888 889 if ((r = ipv6_addaddr1(ia, now)) == 0) { 890 #ifdef ALIAS_ADDR 891 if (replaced) { 892 struct ipv6_state *state; 893 894 state = IPV6_STATE(ia->iface); 895 TAILQ_REMOVE(&state->addrs, replaced_ia, next); 896 ipv6_freeaddr(replaced_ia); 897 } 898 #endif 899 } 900 return r; 901 } 902 903 int 904 ipv6_findaddrmatch(const struct ipv6_addr *addr, const struct in6_addr *match, 905 unsigned int flags) 906 { 907 908 if (match == NULL) { 909 if ((addr->flags & 910 (IPV6_AF_ADDED | IPV6_AF_DADCOMPLETED)) == 911 (IPV6_AF_ADDED | IPV6_AF_DADCOMPLETED)) 912 return 1; 913 } else if (addr->prefix_vltime && 914 IN6_ARE_ADDR_EQUAL(&addr->addr, match) && 915 (!flags || addr->flags & flags)) 916 return 1; 917 918 return 0; 919 } 920 921 struct ipv6_addr * 922 ipv6_findaddr(struct dhcpcd_ctx *ctx, const struct in6_addr *addr, unsigned int flags) 923 { 924 struct ipv6_addr *nap; 925 #ifdef DHCP6 926 struct ipv6_addr *dap; 927 #endif 928 929 nap = ipv6nd_findaddr(ctx, addr, flags); 930 #ifdef DHCP6 931 dap = dhcp6_findaddr(ctx, addr, flags); 932 if (!dap && !nap) 933 return NULL; 934 if (dap && !nap) 935 return dap; 936 if (nap && !dap) 937 return nap; 938 if (nap->iface->metric < dap->iface->metric) 939 return nap; 940 return dap; 941 #else 942 return nap; 943 #endif 944 } 945 946 int 947 ipv6_doaddr(struct ipv6_addr *ia, struct timespec *now) 948 { 949 950 /* A delegated prefix is not an address. */ 951 if (ia->flags & IPV6_AF_DELEGATEDPFX) 952 return 0; 953 954 if (ia->prefix_vltime == 0) { 955 if (ia->flags & IPV6_AF_ADDED) 956 ipv6_deleteaddr(ia); 957 eloop_q_timeout_delete(ia->iface->ctx->eloop, 958 ELOOP_QUEUE_ALL, NULL, ia); 959 if (ia->flags & IPV6_AF_REQUEST) { 960 ia->flags &= ~IPV6_AF_ADDED; 961 return 0; 962 } 963 return -1; 964 } 965 966 if (ia->flags & IPV6_AF_STALE || 967 IN6_IS_ADDR_UNSPECIFIED(&ia->addr)) 968 return 0; 969 970 if (!timespecisset(now)) 971 clock_gettime(CLOCK_MONOTONIC, now); 972 ipv6_addaddr(ia, now); 973 return ia->flags & IPV6_AF_NEW ? 1 : 0; 974 } 975 976 ssize_t 977 ipv6_addaddrs(struct ipv6_addrhead *iaddrs) 978 { 979 struct timespec now; 980 struct ipv6_addr *ia, *ian; 981 ssize_t i, r; 982 983 i = 0; 984 timespecclear(&now); 985 TAILQ_FOREACH_SAFE(ia, iaddrs, next, ian) { 986 r = ipv6_doaddr(ia, &now); 987 if (r != 0) 988 i++; 989 if (r == -1) { 990 TAILQ_REMOVE(iaddrs, ia, next); 991 ipv6_freeaddr(ia); 992 } 993 } 994 return i; 995 } 996 997 void 998 ipv6_freeaddr(struct ipv6_addr *ia) 999 { 1000 struct eloop *eloop = ia->iface->ctx->eloop; 1001 #ifndef SMALL 1002 struct ipv6_addr *iad; 1003 1004 /* Forget the reference */ 1005 if (ia->flags & IPV6_AF_DELEGATEDPFX) { 1006 TAILQ_FOREACH(iad, &ia->pd_pfxs, pd_next) { 1007 iad->delegating_prefix = NULL; 1008 } 1009 } else if (ia->delegating_prefix != NULL) { 1010 TAILQ_REMOVE(&ia->delegating_prefix->pd_pfxs, ia, pd_next); 1011 } 1012 #endif 1013 1014 if (ia->dhcp6_fd != -1) { 1015 close(ia->dhcp6_fd); 1016 eloop_event_delete(eloop, ia->dhcp6_fd); 1017 } 1018 1019 eloop_q_timeout_delete(eloop, ELOOP_QUEUE_ALL, NULL, ia); 1020 free(ia->na); 1021 free(ia); 1022 } 1023 1024 void 1025 ipv6_freedrop_addrs(struct ipv6_addrhead *addrs, int drop, 1026 const struct interface *ifd) 1027 { 1028 struct ipv6_addr *ap, *apn, *apf; 1029 struct timespec now; 1030 1031 #ifdef SMALL 1032 UNUSED(ifd); 1033 #endif 1034 timespecclear(&now); 1035 TAILQ_FOREACH_SAFE(ap, addrs, next, apn) { 1036 #ifndef SMALL 1037 if (ifd != NULL && 1038 (ap->delegating_prefix == NULL || 1039 ap->delegating_prefix->iface != ifd)) 1040 continue; 1041 #endif 1042 if (drop != 2) 1043 TAILQ_REMOVE(addrs, ap, next); 1044 if (drop && ap->flags & IPV6_AF_ADDED && 1045 (ap->iface->options->options & 1046 (DHCPCD_EXITING | DHCPCD_PERSISTENT)) != 1047 (DHCPCD_EXITING | DHCPCD_PERSISTENT)) 1048 { 1049 /* Don't drop link-local addresses. */ 1050 if (!IN6_IS_ADDR_LINKLOCAL(&ap->addr) || 1051 CAN_DROP_LLADDR(ap->iface)) 1052 { 1053 if (drop == 2) 1054 TAILQ_REMOVE(addrs, ap, next); 1055 /* Find the same address somewhere else */ 1056 apf = ipv6_findaddr(ap->iface->ctx, &ap->addr, 1057 0); 1058 if ((apf == NULL || 1059 (apf->iface != ap->iface))) 1060 ipv6_deleteaddr(ap); 1061 if (!(ap->iface->options->options & 1062 DHCPCD_EXITING) && apf) 1063 { 1064 if (!timespecisset(&now)) 1065 clock_gettime(CLOCK_MONOTONIC, 1066 &now); 1067 ipv6_addaddr(apf, &now); 1068 } 1069 if (drop == 2) 1070 ipv6_freeaddr(ap); 1071 } 1072 } 1073 if (drop != 2) 1074 ipv6_freeaddr(ap); 1075 } 1076 } 1077 1078 static struct ipv6_state * 1079 ipv6_getstate(struct interface *ifp) 1080 { 1081 struct ipv6_state *state; 1082 1083 state = IPV6_STATE(ifp); 1084 if (state == NULL) { 1085 ifp->if_data[IF_DATA_IPV6] = calloc(1, sizeof(*state)); 1086 state = IPV6_STATE(ifp); 1087 if (state == NULL) { 1088 logerr(__func__); 1089 return NULL; 1090 } 1091 TAILQ_INIT(&state->addrs); 1092 TAILQ_INIT(&state->ll_callbacks); 1093 } 1094 return state; 1095 } 1096 1097 struct ipv6_addr * 1098 ipv6_anyglobal(struct interface *sifp) 1099 { 1100 struct interface *ifp; 1101 struct ipv6_state *state; 1102 struct ipv6_addr *ia; 1103 bool forwarding; 1104 1105 /* BSD forwarding is either on or off. 1106 * Linux forwarding is technically the same as it's 1107 * configured by the "all" interface. 1108 * Per interface only affects IsRouter of NA messages. */ 1109 #if defined(PRIVSEP) && (defined(HAVE_PLEDGE) || defined(__linux__)) 1110 if (IN_PRIVSEP(sifp->ctx)) 1111 forwarding = ps_root_ip6forwarding(sifp->ctx, NULL) != 0; 1112 else 1113 #endif 1114 forwarding = ip6_forwarding(NULL) != 0; 1115 1116 TAILQ_FOREACH(ifp, sifp->ctx->ifaces, next) { 1117 if (ifp != sifp && !forwarding) 1118 continue; 1119 1120 state = IPV6_STATE(ifp); 1121 if (state == NULL) 1122 continue; 1123 1124 TAILQ_FOREACH(ia, &state->addrs, next) { 1125 if (IN6_IS_ADDR_LINKLOCAL(&ia->addr)) 1126 continue; 1127 /* Let's be optimistic. 1128 * Any decent OS won't forward or accept traffic 1129 * from/to tentative or detached addresses. */ 1130 if (!(ia->addr_flags & IN6_IFF_DUPLICATED)) 1131 return ia; 1132 } 1133 } 1134 return NULL; 1135 } 1136 1137 void 1138 ipv6_handleifa(struct dhcpcd_ctx *ctx, 1139 int cmd, struct if_head *ifs, const char *ifname, 1140 const struct in6_addr *addr, uint8_t prefix_len, int addrflags, pid_t pid) 1141 { 1142 struct interface *ifp; 1143 struct ipv6_state *state; 1144 struct ipv6_addr *ia; 1145 struct ll_callback *cb; 1146 bool anyglobal; 1147 1148 #ifdef __sun 1149 struct sockaddr_in6 subnet; 1150 1151 /* Solaris on-link route is an unspecified address! */ 1152 if (IN6_IS_ADDR_UNSPECIFIED(addr)) { 1153 if (if_getsubnet(ctx, ifname, AF_INET6, 1154 &subnet, sizeof(subnet)) == -1) 1155 { 1156 logerr(__func__); 1157 return; 1158 } 1159 addr = &subnet.sin6_addr; 1160 } 1161 #endif 1162 1163 #if 0 1164 char dbuf[INET6_ADDRSTRLEN]; 1165 const char *dbp; 1166 1167 dbp = inet_ntop(AF_INET6, &addr->s6_addr, 1168 dbuf, INET6_ADDRSTRLEN); 1169 loginfox("%s: cmd %d addr %s addrflags %d", 1170 ifname, cmd, dbp, addrflags); 1171 #endif 1172 1173 if (ifs == NULL) 1174 ifs = ctx->ifaces; 1175 if (ifs == NULL) 1176 return; 1177 if ((ifp = if_find(ifs, ifname)) == NULL) 1178 return; 1179 if ((state = ipv6_getstate(ifp)) == NULL) 1180 return; 1181 anyglobal = ipv6_anyglobal(ifp) != NULL; 1182 1183 TAILQ_FOREACH(ia, &state->addrs, next) { 1184 if (IN6_ARE_ADDR_EQUAL(&ia->addr, addr)) 1185 break; 1186 } 1187 1188 switch (cmd) { 1189 case RTM_DELADDR: 1190 if (ia != NULL) { 1191 TAILQ_REMOVE(&state->addrs, ia, next); 1192 #ifdef ND6_ADVERTISE 1193 /* Advertise the address if it exists on 1194 * another interface. */ 1195 ipv6nd_advertise(ia); 1196 #endif 1197 /* We'll free it at the end of the function. */ 1198 } 1199 break; 1200 case RTM_NEWADDR: 1201 if (ia == NULL) { 1202 ia = ipv6_newaddr(ifp, addr, prefix_len, 0); 1203 #ifdef ALIAS_ADDR 1204 strlcpy(ia->alias, ifname, sizeof(ia->alias)); 1205 #endif 1206 if (if_getlifetime6(ia) == -1) { 1207 /* No support or address vanished. 1208 * Either way, just set a deprecated 1209 * infinite time lifetime and continue. 1210 * This is fine because we only want 1211 * to know this when trying to extend 1212 * temporary addresses. 1213 * As we can't extend infinite, we'll 1214 * create a new temporary address. */ 1215 ia->prefix_pltime = 0; 1216 ia->prefix_vltime = 1217 ND6_INFINITE_LIFETIME; 1218 } 1219 /* This is a minor regression against RFC 4941 1220 * because the kernel only knows when the 1221 * lifetimes were last updated, not when the 1222 * address was initially created. 1223 * Provided dhcpcd is not restarted, this 1224 * won't be a problem. 1225 * If we don't like it, we can always 1226 * pretend lifetimes are infinite and always 1227 * generate a new temporary address on 1228 * restart. */ 1229 ia->acquired = ia->created; 1230 TAILQ_INSERT_TAIL(&state->addrs, ia, next); 1231 } 1232 ia->addr_flags = addrflags; 1233 ia->flags &= ~IPV6_AF_STALE; 1234 #ifdef IPV6_MANAGETEMPADDR 1235 if (ia->addr_flags & IN6_IFF_TEMPORARY) 1236 ia->flags |= IPV6_AF_TEMPORARY; 1237 #endif 1238 if (IN6_IS_ADDR_LINKLOCAL(&ia->addr) || ia->dadcallback) { 1239 #ifdef IPV6_POLLADDRFLAG 1240 if (ia->addr_flags & IN6_IFF_TENTATIVE) { 1241 eloop_timeout_add_msec( 1242 ia->iface->ctx->eloop, 1243 RETRANS_TIMER / 2, ipv6_checkaddrflags, ia); 1244 break; 1245 } 1246 #endif 1247 1248 if (ia->dadcallback) 1249 ia->dadcallback(ia); 1250 1251 if (IN6_IS_ADDR_LINKLOCAL(&ia->addr) && 1252 !(ia->addr_flags & IN6_IFF_NOTUSEABLE)) 1253 { 1254 /* Now run any callbacks. 1255 * Typically IPv6RS or DHCPv6 */ 1256 while ((cb = 1257 TAILQ_FIRST(&state->ll_callbacks))) 1258 { 1259 TAILQ_REMOVE( 1260 &state->ll_callbacks, 1261 cb, next); 1262 cb->callback(cb->arg); 1263 free(cb); 1264 } 1265 } 1266 } 1267 break; 1268 } 1269 1270 if (ia == NULL) 1271 return; 1272 1273 ctx->options &= ~DHCPCD_RTBUILD; 1274 ipv6nd_handleifa(cmd, ia, pid); 1275 #ifdef DHCP6 1276 dhcp6_handleifa(cmd, ia, pid); 1277 #endif 1278 1279 /* Done with the ia now, so free it. */ 1280 if (cmd == RTM_DELADDR) 1281 ipv6_freeaddr(ia); 1282 else if (!(ia->addr_flags & IN6_IFF_NOTUSEABLE)) 1283 ia->flags |= IPV6_AF_DADCOMPLETED; 1284 1285 /* If we've not already called rt_build via the IPv6ND 1286 * or DHCP6 handlers and the existance of any useable 1287 * global address on the interface has changed, 1288 * call rt_build to add/remove the default route. */ 1289 if (ifp->active && 1290 ((ifp->options != NULL && ifp->options->options & DHCPCD_IPV6) || 1291 (ifp->options == NULL && ctx->options & DHCPCD_IPV6)) && 1292 !(ctx->options & DHCPCD_RTBUILD) && 1293 (ipv6_anyglobal(ifp) != NULL) != anyglobal) 1294 rt_build(ctx, AF_INET6); 1295 } 1296 1297 int 1298 ipv6_hasaddr(const struct interface *ifp) 1299 { 1300 1301 if (ipv6nd_iffindaddr(ifp, NULL, 0) != NULL) 1302 return 1; 1303 #ifdef DHCP6 1304 if (dhcp6_iffindaddr(ifp, NULL, 0) != NULL) 1305 return 1; 1306 #endif 1307 return 0; 1308 } 1309 1310 struct ipv6_addr * 1311 ipv6_iffindaddr(struct interface *ifp, const struct in6_addr *addr, 1312 int revflags) 1313 { 1314 struct ipv6_state *state; 1315 struct ipv6_addr *ap; 1316 1317 state = IPV6_STATE(ifp); 1318 if (state) { 1319 TAILQ_FOREACH(ap, &state->addrs, next) { 1320 if (addr == NULL) { 1321 if (IN6_IS_ADDR_LINKLOCAL(&ap->addr) && 1322 (!revflags || !(ap->addr_flags & revflags))) 1323 return ap; 1324 } else { 1325 if (IN6_ARE_ADDR_EQUAL(&ap->addr, addr) && 1326 (!revflags || !(ap->addr_flags & revflags))) 1327 return ap; 1328 } 1329 } 1330 } 1331 return NULL; 1332 } 1333 1334 static struct ipv6_addr * 1335 ipv6_iffindmaskaddr(const struct interface *ifp, const struct in6_addr *addr) 1336 { 1337 struct ipv6_state *state; 1338 struct ipv6_addr *ap; 1339 struct in6_addr mask; 1340 1341 state = IPV6_STATE(ifp); 1342 if (state) { 1343 TAILQ_FOREACH(ap, &state->addrs, next) { 1344 if (ipv6_mask(&mask, ap->prefix_len) == -1) 1345 continue; 1346 if (IN6_ARE_MASKED_ADDR_EQUAL(&ap->addr, addr, &mask)) 1347 return ap; 1348 } 1349 } 1350 return NULL; 1351 } 1352 1353 struct ipv6_addr * 1354 ipv6_findmaskaddr(struct dhcpcd_ctx *ctx, const struct in6_addr *addr) 1355 { 1356 struct interface *ifp; 1357 struct ipv6_addr *ap; 1358 1359 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 1360 ap = ipv6_iffindmaskaddr(ifp, addr); 1361 if (ap != NULL) 1362 return ap; 1363 } 1364 return NULL; 1365 } 1366 1367 int 1368 ipv6_addlinklocalcallback(struct interface *ifp, 1369 void (*callback)(void *), void *arg) 1370 { 1371 struct ipv6_state *state; 1372 struct ll_callback *cb; 1373 1374 state = ipv6_getstate(ifp); 1375 TAILQ_FOREACH(cb, &state->ll_callbacks, next) { 1376 if (cb->callback == callback && cb->arg == arg) 1377 break; 1378 } 1379 if (cb == NULL) { 1380 cb = malloc(sizeof(*cb)); 1381 if (cb == NULL) { 1382 logerr(__func__); 1383 return -1; 1384 } 1385 cb->callback = callback; 1386 cb->arg = arg; 1387 TAILQ_INSERT_TAIL(&state->ll_callbacks, cb, next); 1388 } 1389 return 0; 1390 } 1391 1392 static struct ipv6_addr * 1393 ipv6_newlinklocal(struct interface *ifp) 1394 { 1395 struct ipv6_addr *ia; 1396 struct in6_addr in6; 1397 1398 memset(&in6, 0, sizeof(in6)); 1399 in6.s6_addr32[0] = htonl(0xfe800000); 1400 ia = ipv6_newaddr(ifp, &in6, 64, 0); 1401 if (ia != NULL) { 1402 ia->prefix_pltime = ND6_INFINITE_LIFETIME; 1403 ia->prefix_vltime = ND6_INFINITE_LIFETIME; 1404 } 1405 return ia; 1406 } 1407 1408 static const uint8_t allzero[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; 1409 static const uint8_t allone[8] = 1410 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 1411 1412 static int 1413 ipv6_addlinklocal(struct interface *ifp) 1414 { 1415 struct ipv6_state *state; 1416 struct ipv6_addr *ap, *ap2; 1417 int dadcounter; 1418 1419 if (!(ifp->options->options & DHCPCD_CONFIGURE)) 1420 return 0; 1421 1422 /* Check sanity before malloc */ 1423 if (!(ifp->options->options & DHCPCD_SLAACPRIVATE)) { 1424 switch (ifp->hwtype) { 1425 case ARPHRD_ETHER: 1426 /* Check for a valid hardware address */ 1427 if (ifp->hwlen != 6 && ifp->hwlen != 8) { 1428 errno = ENOTSUP; 1429 return -1; 1430 } 1431 if (memcmp(ifp->hwaddr, allzero, ifp->hwlen) == 0 || 1432 memcmp(ifp->hwaddr, allone, ifp->hwlen) == 0) 1433 { 1434 errno = EINVAL; 1435 return -1; 1436 } 1437 break; 1438 default: 1439 errno = ENOTSUP; 1440 return -1; 1441 } 1442 } 1443 1444 state = ipv6_getstate(ifp); 1445 if (state == NULL) 1446 return -1; 1447 1448 ap = ipv6_newlinklocal(ifp); 1449 if (ap == NULL) 1450 return -1; 1451 1452 dadcounter = 0; 1453 if (ifp->options->options & DHCPCD_SLAACPRIVATE) { 1454 nextslaacprivate: 1455 if (ipv6_makestableprivate(&ap->addr, 1456 &ap->prefix, ap->prefix_len, ifp, &dadcounter) == -1) 1457 { 1458 free(ap); 1459 return -1; 1460 } 1461 ap->dadcounter = dadcounter; 1462 } else { 1463 memcpy(ap->addr.s6_addr, ap->prefix.s6_addr, 8); 1464 switch (ifp->hwtype) { 1465 case ARPHRD_ETHER: 1466 if (ifp->hwlen == 6) { 1467 ap->addr.s6_addr[ 8] = ifp->hwaddr[0]; 1468 ap->addr.s6_addr[ 9] = ifp->hwaddr[1]; 1469 ap->addr.s6_addr[10] = ifp->hwaddr[2]; 1470 ap->addr.s6_addr[11] = 0xff; 1471 ap->addr.s6_addr[12] = 0xfe; 1472 ap->addr.s6_addr[13] = ifp->hwaddr[3]; 1473 ap->addr.s6_addr[14] = ifp->hwaddr[4]; 1474 ap->addr.s6_addr[15] = ifp->hwaddr[5]; 1475 } else if (ifp->hwlen == 8) 1476 memcpy(&ap->addr.s6_addr[8], ifp->hwaddr, 8); 1477 else { 1478 free(ap); 1479 errno = ENOTSUP; 1480 return -1; 1481 } 1482 break; 1483 } 1484 1485 /* Sanity check: g bit must not indciate "group" */ 1486 if (EUI64_GROUP(&ap->addr)) { 1487 free(ap); 1488 errno = EINVAL; 1489 return -1; 1490 } 1491 EUI64_TO_IFID(&ap->addr); 1492 } 1493 1494 /* Do we already have this address? */ 1495 TAILQ_FOREACH(ap2, &state->addrs, next) { 1496 if (IN6_ARE_ADDR_EQUAL(&ap->addr, &ap2->addr)) { 1497 if (ap2->addr_flags & IN6_IFF_DUPLICATED) { 1498 if (ifp->options->options & 1499 DHCPCD_SLAACPRIVATE) 1500 { 1501 dadcounter++; 1502 goto nextslaacprivate; 1503 } 1504 free(ap); 1505 errno = EADDRNOTAVAIL; 1506 return -1; 1507 } 1508 1509 logwarnx("%s: waiting for %s to complete", 1510 ap2->iface->name, ap2->saddr); 1511 free(ap); 1512 errno = EEXIST; 1513 return 0; 1514 } 1515 } 1516 1517 inet_ntop(AF_INET6, &ap->addr, ap->saddr, sizeof(ap->saddr)); 1518 TAILQ_INSERT_TAIL(&state->addrs, ap, next); 1519 ipv6_addaddr(ap, NULL); 1520 return 1; 1521 } 1522 1523 static int 1524 ipv6_tryaddlinklocal(struct interface *ifp) 1525 { 1526 struct ipv6_addr *ia; 1527 1528 /* We can't assign a link-locak address to this, 1529 * the ppp process has to. */ 1530 if (ifp->flags & IFF_POINTOPOINT) 1531 return 0; 1532 1533 ia = ipv6_iffindaddr(ifp, NULL, IN6_IFF_DUPLICATED); 1534 if (ia != NULL) { 1535 #ifdef IPV6_POLLADDRFLAG 1536 if (ia->addr_flags & IN6_IFF_TENTATIVE) { 1537 eloop_timeout_add_msec( 1538 ia->iface->ctx->eloop, 1539 RETRANS_TIMER / 2, ipv6_checkaddrflags, ia); 1540 } 1541 #endif 1542 return 0; 1543 } 1544 if (!CAN_ADD_LLADDR(ifp)) 1545 return 0; 1546 1547 return ipv6_addlinklocal(ifp); 1548 } 1549 1550 void 1551 ipv6_setscope(struct sockaddr_in6 *sin, unsigned int ifindex) 1552 { 1553 1554 #ifdef __KAME__ 1555 /* KAME based systems want to store the scope inside the sin6_addr 1556 * for link local addresses */ 1557 if (IN6_IS_ADDR_LINKLOCAL(&sin->sin6_addr)) { 1558 uint16_t scope = htons((uint16_t)ifindex); 1559 memcpy(&sin->sin6_addr.s6_addr[2], &scope, 1560 sizeof(scope)); 1561 } 1562 sin->sin6_scope_id = 0; 1563 #else 1564 if (IN6_IS_ADDR_LINKLOCAL(&sin->sin6_addr)) 1565 sin->sin6_scope_id = ifindex; 1566 else 1567 sin->sin6_scope_id = 0; 1568 #endif 1569 } 1570 1571 unsigned int 1572 ipv6_getscope(const struct sockaddr_in6 *sin) 1573 { 1574 #ifdef __KAME__ 1575 uint16_t scope; 1576 #endif 1577 1578 if (!IN6_IS_ADDR_LINKLOCAL(&sin->sin6_addr)) 1579 return 0; 1580 #ifdef __KAME__ 1581 memcpy(&scope, &sin->sin6_addr.s6_addr[2], sizeof(scope)); 1582 return (unsigned int)ntohs(scope); 1583 #else 1584 return (unsigned int)sin->sin6_scope_id; 1585 #endif 1586 } 1587 1588 struct ipv6_addr * 1589 ipv6_newaddr(struct interface *ifp, const struct in6_addr *addr, 1590 uint8_t prefix_len, unsigned int flags) 1591 { 1592 struct ipv6_addr *ia, *iaf; 1593 char buf[INET6_ADDRSTRLEN]; 1594 const char *cbp; 1595 bool tempaddr; 1596 int addr_flags; 1597 1598 #ifdef IPV6_AF_TEMPORARY 1599 tempaddr = flags & IPV6_AF_TEMPORARY; 1600 #else 1601 tempaddr = false; 1602 #endif 1603 1604 /* If adding a new DHCP / RA derived address, check current flags 1605 * from an existing address. */ 1606 if (tempaddr) 1607 iaf = NULL; 1608 else if (flags & IPV6_AF_AUTOCONF) 1609 iaf = ipv6nd_iffindprefix(ifp, addr, prefix_len); 1610 else 1611 iaf = ipv6_iffindaddr(ifp, addr, 0); 1612 if (iaf != NULL) { 1613 addr_flags = iaf->addr_flags; 1614 flags |= IPV6_AF_ADDED; 1615 } else 1616 addr_flags = IN6_IFF_TENTATIVE; 1617 1618 ia = calloc(1, sizeof(*ia)); 1619 if (ia == NULL) 1620 goto err; 1621 1622 ia->iface = ifp; 1623 ia->addr_flags = addr_flags; 1624 ia->flags = IPV6_AF_NEW | flags; 1625 if (!(ia->addr_flags & IN6_IFF_NOTUSEABLE)) 1626 ia->flags |= IPV6_AF_DADCOMPLETED; 1627 ia->prefix_len = prefix_len; 1628 ia->dhcp6_fd = -1; 1629 1630 #ifndef SMALL 1631 TAILQ_INIT(&ia->pd_pfxs); 1632 #endif 1633 1634 if (prefix_len == 128) 1635 goto makepfx; 1636 else if (ia->flags & IPV6_AF_AUTOCONF) { 1637 ia->prefix = *addr; 1638 if (iaf != NULL) 1639 memcpy(&ia->addr, &iaf->addr, sizeof(ia->addr)); 1640 else { 1641 ia->dadcounter = ipv6_makeaddr(&ia->addr, ifp, 1642 &ia->prefix, 1643 ia->prefix_len, 1644 ia->flags); 1645 if (ia->dadcounter == -1) 1646 goto err; 1647 } 1648 } else if (ia->flags & IPV6_AF_RAPFX) { 1649 ia->prefix = *addr; 1650 #ifdef __sun 1651 ia->addr = *addr; 1652 cbp = inet_ntop(AF_INET6, &ia->addr, buf, sizeof(buf)); 1653 goto paddr; 1654 #else 1655 return ia; 1656 #endif 1657 } else if (ia->flags & (IPV6_AF_REQUEST | IPV6_AF_DELEGATEDPFX)) { 1658 ia->prefix = *addr; 1659 cbp = inet_ntop(AF_INET6, &ia->prefix, buf, sizeof(buf)); 1660 goto paddr; 1661 } else { 1662 makepfx: 1663 ia->addr = *addr; 1664 if (ipv6_makeprefix(&ia->prefix, 1665 &ia->addr, ia->prefix_len) == -1) 1666 goto err; 1667 } 1668 1669 cbp = inet_ntop(AF_INET6, &ia->addr, buf, sizeof(buf)); 1670 paddr: 1671 if (cbp == NULL) 1672 goto err; 1673 snprintf(ia->saddr, sizeof(ia->saddr), "%s/%d", cbp, ia->prefix_len); 1674 1675 return ia; 1676 1677 err: 1678 logerr(__func__); 1679 free(ia); 1680 return NULL; 1681 } 1682 1683 static void 1684 ipv6_staticdadcallback(void *arg) 1685 { 1686 struct ipv6_addr *ia = arg; 1687 int wascompleted; 1688 1689 wascompleted = (ia->flags & IPV6_AF_DADCOMPLETED); 1690 ia->flags |= IPV6_AF_DADCOMPLETED; 1691 if (ia->addr_flags & IN6_IFF_DUPLICATED) 1692 logwarnx("%s: DAD detected %s", ia->iface->name, 1693 ia->saddr); 1694 else if (!wascompleted) { 1695 logdebugx("%s: IPv6 static DAD completed", 1696 ia->iface->name); 1697 } 1698 1699 #define FINISHED (IPV6_AF_ADDED | IPV6_AF_DADCOMPLETED) 1700 if (!wascompleted) { 1701 struct interface *ifp; 1702 struct ipv6_state *state; 1703 1704 ifp = ia->iface; 1705 state = IPV6_STATE(ifp); 1706 TAILQ_FOREACH(ia, &state->addrs, next) { 1707 if (ia->flags & IPV6_AF_STATIC && 1708 (ia->flags & FINISHED) != FINISHED) 1709 { 1710 wascompleted = 1; 1711 break; 1712 } 1713 } 1714 if (!wascompleted) 1715 script_runreason(ifp, "STATIC6"); 1716 } 1717 #undef FINISHED 1718 } 1719 1720 ssize_t 1721 ipv6_env(FILE *fp, const char *prefix, const struct interface *ifp) 1722 { 1723 struct ipv6_addr *ia; 1724 1725 ia = ipv6_iffindaddr(UNCONST(ifp), &ifp->options->req_addr6, 1726 IN6_IFF_NOTUSEABLE); 1727 if (ia == NULL) 1728 return 0; 1729 if (efprintf(fp, "%s_ip6_address=%s", prefix, ia->saddr) == -1) 1730 return -1; 1731 return 1; 1732 } 1733 1734 int 1735 ipv6_staticdadcompleted(const struct interface *ifp) 1736 { 1737 const struct ipv6_state *state; 1738 const struct ipv6_addr *ia; 1739 int n; 1740 1741 if ((state = IPV6_CSTATE(ifp)) == NULL) 1742 return 0; 1743 n = 0; 1744 #define COMPLETED (IPV6_AF_STATIC | IPV6_AF_ADDED | IPV6_AF_DADCOMPLETED) 1745 TAILQ_FOREACH(ia, &state->addrs, next) { 1746 if ((ia->flags & COMPLETED) == COMPLETED && 1747 !(ia->addr_flags & IN6_IFF_NOTUSEABLE)) 1748 n++; 1749 } 1750 return n; 1751 } 1752 1753 int 1754 ipv6_startstatic(struct interface *ifp) 1755 { 1756 struct ipv6_addr *ia; 1757 int run_script; 1758 1759 if (IN6_IS_ADDR_UNSPECIFIED(&ifp->options->req_addr6)) 1760 return 0; 1761 1762 ia = ipv6_iffindaddr(ifp, &ifp->options->req_addr6, 0); 1763 if (ia != NULL && 1764 (ia->prefix_len != ifp->options->req_prefix_len || 1765 ia->addr_flags & IN6_IFF_NOTUSEABLE)) 1766 { 1767 ipv6_deleteaddr(ia); 1768 ia = NULL; 1769 } 1770 if (ia == NULL) { 1771 struct ipv6_state *state; 1772 1773 ia = ipv6_newaddr(ifp, &ifp->options->req_addr6, 1774 ifp->options->req_prefix_len, 0); 1775 if (ia == NULL) 1776 return -1; 1777 state = IPV6_STATE(ifp); 1778 TAILQ_INSERT_TAIL(&state->addrs, ia, next); 1779 run_script = 0; 1780 } else 1781 run_script = 1; 1782 ia->flags |= IPV6_AF_STATIC | IPV6_AF_ONLINK; 1783 ia->prefix_vltime = ND6_INFINITE_LIFETIME; 1784 ia->prefix_pltime = ND6_INFINITE_LIFETIME; 1785 ia->dadcallback = ipv6_staticdadcallback; 1786 ipv6_addaddr(ia, NULL); 1787 rt_build(ifp->ctx, AF_INET6); 1788 if (run_script) 1789 script_runreason(ifp, "STATIC6"); 1790 return 1; 1791 } 1792 1793 /* Ensure the interface has a link-local address */ 1794 int 1795 ipv6_start(struct interface *ifp) 1796 { 1797 #ifdef IPV6_POLLADDRFLAG 1798 struct ipv6_state *state; 1799 1800 /* We need to update the address flags. */ 1801 if ((state = IPV6_STATE(ifp)) != NULL) { 1802 struct ipv6_addr *ia; 1803 const char *alias; 1804 int flags; 1805 1806 TAILQ_FOREACH(ia, &state->addrs, next) { 1807 #ifdef ALIAS_ADDR 1808 alias = ia->alias; 1809 #else 1810 alias = NULL; 1811 #endif 1812 flags = if_addrflags6(ia->iface, &ia->addr, alias); 1813 if (flags != -1) 1814 ia->addr_flags = flags; 1815 } 1816 } 1817 #endif 1818 1819 if (ipv6_tryaddlinklocal(ifp) == -1) 1820 return -1; 1821 1822 return 0; 1823 } 1824 1825 void 1826 ipv6_freedrop(struct interface *ifp, int drop) 1827 { 1828 struct ipv6_state *state; 1829 struct ll_callback *cb; 1830 1831 if (ifp == NULL) 1832 return; 1833 1834 if ((state = IPV6_STATE(ifp)) == NULL) 1835 return; 1836 1837 /* If we got here, we can get rid of any LL callbacks. */ 1838 while ((cb = TAILQ_FIRST(&state->ll_callbacks))) { 1839 TAILQ_REMOVE(&state->ll_callbacks, cb, next); 1840 free(cb); 1841 } 1842 1843 ipv6_freedrop_addrs(&state->addrs, drop ? 2 : 0, NULL); 1844 if (drop) { 1845 if (ifp->ctx->ra_routers != NULL) 1846 rt_build(ifp->ctx, AF_INET6); 1847 } else { 1848 /* Because we need to cache the addresses we don't control, 1849 * we only free the state on when NOT dropping addresses. */ 1850 free(state); 1851 ifp->if_data[IF_DATA_IPV6] = NULL; 1852 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 1853 } 1854 } 1855 1856 void 1857 ipv6_ctxfree(struct dhcpcd_ctx *ctx) 1858 { 1859 1860 free(ctx->ra_routers); 1861 free(ctx->secret); 1862 } 1863 1864 int 1865 ipv6_handleifa_addrs(int cmd, 1866 struct ipv6_addrhead *addrs, const struct ipv6_addr *addr, pid_t pid) 1867 { 1868 struct ipv6_addr *ia, *ian; 1869 uint8_t found, alldadcompleted; 1870 1871 alldadcompleted = 1; 1872 found = 0; 1873 TAILQ_FOREACH_SAFE(ia, addrs, next, ian) { 1874 if (!IN6_ARE_ADDR_EQUAL(&addr->addr, &ia->addr)) { 1875 if (ia->flags & IPV6_AF_ADDED && 1876 !(ia->flags & IPV6_AF_DADCOMPLETED)) 1877 alldadcompleted = 0; 1878 continue; 1879 } 1880 switch (cmd) { 1881 case RTM_DELADDR: 1882 if (ia->flags & IPV6_AF_ADDED) { 1883 logwarnx("%s: pid %d deleted address %s", 1884 ia->iface->name, pid, ia->saddr); 1885 ia->flags &= ~IPV6_AF_ADDED; 1886 } 1887 ipv6_deletedaddr(ia); 1888 if (ia->flags & IPV6_AF_DELEGATED) { 1889 TAILQ_REMOVE(addrs, ia, next); 1890 ipv6_freeaddr(ia); 1891 } 1892 break; 1893 case RTM_NEWADDR: 1894 ia->addr_flags = addr->addr_flags; 1895 /* Safety - ignore tentative announcements */ 1896 if (ia->addr_flags & 1897 (IN6_IFF_DETACHED | IN6_IFF_TENTATIVE)) 1898 break; 1899 if ((ia->flags & IPV6_AF_DADCOMPLETED) == 0) { 1900 found++; 1901 if (ia->dadcallback) 1902 ia->dadcallback(ia); 1903 /* We need to set this here in-case the 1904 * dadcallback function checks it */ 1905 ia->flags |= IPV6_AF_DADCOMPLETED; 1906 } 1907 break; 1908 } 1909 } 1910 1911 return alldadcompleted ? found : 0; 1912 } 1913 1914 #ifdef IPV6_MANAGETEMPADDR 1915 static void 1916 ipv6_regen_desync(struct interface *ifp, bool force) 1917 { 1918 struct ipv6_state *state; 1919 unsigned int max; 1920 1921 state = IPV6_STATE(ifp); 1922 1923 /* RFC4941 Section 5 states that DESYNC_FACTOR must never be 1924 * greater than TEMP_VALID_LIFETIME - REGEN_ADVANCE. 1925 * I believe this is an error and it should be never be greater than 1926 * TEMP_PREFERRED_LIFETIME - REGEN_ADVANCE. */ 1927 max = TEMP_PREFERRED_LIFETIME - REGEN_ADVANCE; 1928 if (state->desync_factor && !force && state->desync_factor < max) 1929 return; 1930 if (state->desync_factor == 0) 1931 state->desync_factor = 1932 arc4random_uniform(MIN(MAX_DESYNC_FACTOR, max)); 1933 max = TEMP_PREFERRED_LIFETIME - state->desync_factor - REGEN_ADVANCE; 1934 eloop_timeout_add_sec(ifp->ctx->eloop, max, ipv6_regentempaddrs, ifp); 1935 } 1936 1937 /* RFC4941 Section 3.3.7 */ 1938 static void 1939 ipv6_tempdadcallback(void *arg) 1940 { 1941 struct ipv6_addr *ia = arg; 1942 1943 if (ia->addr_flags & IN6_IFF_DUPLICATED) { 1944 struct ipv6_addr *ia1; 1945 struct timespec tv; 1946 1947 if (++ia->dadcounter == TEMP_IDGEN_RETRIES) { 1948 logerrx("%s: too many duplicate temporary addresses", 1949 ia->iface->name); 1950 return; 1951 } 1952 clock_gettime(CLOCK_MONOTONIC, &tv); 1953 if ((ia1 = ipv6_createtempaddr(ia, &tv)) == NULL) 1954 logerr(__func__); 1955 else 1956 ia1->dadcounter = ia->dadcounter; 1957 ipv6_deleteaddr(ia); 1958 if (ia1) 1959 ipv6_addaddr(ia1, &ia1->acquired); 1960 } 1961 } 1962 1963 struct ipv6_addr * 1964 ipv6_createtempaddr(struct ipv6_addr *ia0, const struct timespec *now) 1965 { 1966 struct ipv6_state *state; 1967 struct interface *ifp = ia0->iface; 1968 struct ipv6_addr *ia; 1969 1970 ia = ipv6_newaddr(ifp, &ia0->prefix, ia0->prefix_len, 1971 IPV6_AF_AUTOCONF | IPV6_AF_TEMPORARY); 1972 if (ia == NULL) 1973 return NULL; 1974 1975 ia->dadcallback = ipv6_tempdadcallback; 1976 ia->created = ia->acquired = now ? *now : ia0->acquired; 1977 1978 /* Ensure desync is still valid */ 1979 ipv6_regen_desync(ifp, false); 1980 1981 /* RFC4941 Section 3.3.4 */ 1982 state = IPV6_STATE(ia->iface); 1983 ia->prefix_pltime = MIN(ia0->prefix_pltime, 1984 TEMP_PREFERRED_LIFETIME - state->desync_factor); 1985 ia->prefix_vltime = MIN(ia0->prefix_vltime, TEMP_VALID_LIFETIME); 1986 if (ia->prefix_pltime <= REGEN_ADVANCE || 1987 ia->prefix_pltime > ia0->prefix_vltime) 1988 { 1989 errno = EINVAL; 1990 free(ia); 1991 return NULL; 1992 } 1993 1994 TAILQ_INSERT_TAIL(&state->addrs, ia, next); 1995 return ia; 1996 } 1997 1998 struct ipv6_addr * 1999 ipv6_settemptime(struct ipv6_addr *ia, int flags) 2000 { 2001 struct ipv6_state *state; 2002 struct ipv6_addr *ap, *first; 2003 2004 state = IPV6_STATE(ia->iface); 2005 first = NULL; 2006 TAILQ_FOREACH_REVERSE(ap, &state->addrs, ipv6_addrhead, next) { 2007 if (ap->flags & IPV6_AF_TEMPORARY && 2008 ap->prefix_pltime && 2009 IN6_ARE_ADDR_EQUAL(&ia->prefix, &ap->prefix)) 2010 { 2011 unsigned int max, ext; 2012 2013 if (flags == 0) { 2014 if (ap->prefix_pltime - 2015 (uint32_t)(ia->acquired.tv_sec - 2016 ap->acquired.tv_sec) 2017 < REGEN_ADVANCE) 2018 continue; 2019 2020 return ap; 2021 } 2022 2023 if (!(ap->flags & IPV6_AF_ADDED)) 2024 ap->flags |= IPV6_AF_NEW | IPV6_AF_AUTOCONF; 2025 ap->flags &= ~IPV6_AF_STALE; 2026 2027 /* RFC4941 Section 3.4 2028 * Deprecated prefix, deprecate the temporary address */ 2029 if (ia->prefix_pltime == 0) { 2030 ap->prefix_pltime = 0; 2031 goto valid; 2032 } 2033 2034 /* Ensure desync is still valid */ 2035 ipv6_regen_desync(ap->iface, false); 2036 2037 /* RFC4941 Section 3.3.2 2038 * Extend temporary times, but ensure that they 2039 * never last beyond the system limit. */ 2040 ext = (unsigned int)ia->acquired.tv_sec 2041 + ia->prefix_pltime; 2042 max = (unsigned int)(ap->created.tv_sec + 2043 TEMP_PREFERRED_LIFETIME - 2044 state->desync_factor); 2045 if (ext < max) 2046 ap->prefix_pltime = ia->prefix_pltime; 2047 else 2048 ap->prefix_pltime = 2049 (uint32_t)(max - ia->acquired.tv_sec); 2050 2051 valid: 2052 ext = (unsigned int)ia->acquired.tv_sec + 2053 ia->prefix_vltime; 2054 max = (unsigned int)(ap->created.tv_sec + 2055 TEMP_VALID_LIFETIME); 2056 if (ext < max) 2057 ap->prefix_vltime = ia->prefix_vltime; 2058 else 2059 ap->prefix_vltime = 2060 (uint32_t)(max - ia->acquired.tv_sec); 2061 2062 /* Just extend the latest matching prefix */ 2063 ap->acquired = ia->acquired; 2064 2065 /* If extending return the last match as 2066 * it's the most current. 2067 * If deprecating, deprecate any other addresses we 2068 * may have, although this should not be needed */ 2069 if (ia->prefix_pltime) 2070 return ap; 2071 if (first == NULL) 2072 first = ap; 2073 } 2074 } 2075 return first; 2076 } 2077 2078 void 2079 ipv6_addtempaddrs(struct interface *ifp, const struct timespec *now) 2080 { 2081 struct ipv6_state *state; 2082 struct ipv6_addr *ia; 2083 2084 state = IPV6_STATE(ifp); 2085 TAILQ_FOREACH(ia, &state->addrs, next) { 2086 if (ia->flags & IPV6_AF_TEMPORARY && 2087 !(ia->flags & IPV6_AF_STALE)) 2088 ipv6_addaddr(ia, now); 2089 } 2090 } 2091 2092 static void 2093 ipv6_regentempaddr0(struct ipv6_addr *ia, struct timespec *tv) 2094 { 2095 struct ipv6_addr *ia1; 2096 2097 logdebugx("%s: regen temp addr %s", ia->iface->name, ia->saddr); 2098 ia1 = ipv6_createtempaddr(ia, tv); 2099 if (ia1) 2100 ipv6_addaddr(ia1, tv); 2101 else 2102 logerr(__func__); 2103 } 2104 2105 static void 2106 ipv6_regentempaddr(void *arg) 2107 { 2108 struct timespec tv; 2109 2110 clock_gettime(CLOCK_MONOTONIC, &tv); 2111 ipv6_regentempaddr0(arg, &tv); 2112 } 2113 2114 void 2115 ipv6_regentempaddrs(void *arg) 2116 { 2117 struct interface *ifp = arg; 2118 struct timespec tv; 2119 struct ipv6_state *state; 2120 struct ipv6_addr *ia; 2121 2122 state = IPV6_STATE(ifp); 2123 if (state == NULL) 2124 return; 2125 2126 ipv6_regen_desync(ifp, true); 2127 2128 clock_gettime(CLOCK_MONOTONIC, &tv); 2129 2130 /* Mark addresses for regen so we don't infinite loop. */ 2131 TAILQ_FOREACH(ia, &state->addrs, next) { 2132 if (ia->flags & IPV6_AF_TEMPORARY && 2133 ia->flags & IPV6_AF_ADDED && 2134 !(ia->flags & IPV6_AF_STALE)) 2135 ia->flags |= IPV6_AF_REGEN; 2136 else 2137 ia->flags &= ~IPV6_AF_REGEN; 2138 } 2139 2140 /* Now regen temp addrs */ 2141 TAILQ_FOREACH(ia, &state->addrs, next) { 2142 if (ia->flags & IPV6_AF_REGEN) { 2143 ipv6_regentempaddr0(ia, &tv); 2144 ia->flags &= ~IPV6_AF_REGEN; 2145 } 2146 } 2147 } 2148 #endif /* IPV6_MANAGETEMPADDR */ 2149 2150 void 2151 ipv6_markaddrsstale(struct interface *ifp, unsigned int flags) 2152 { 2153 struct ipv6_state *state; 2154 struct ipv6_addr *ia; 2155 2156 state = IPV6_STATE(ifp); 2157 if (state == NULL) 2158 return; 2159 2160 TAILQ_FOREACH(ia, &state->addrs, next) { 2161 if (flags == 0 || ia->flags & flags) 2162 ia->flags |= IPV6_AF_STALE; 2163 } 2164 } 2165 2166 void 2167 ipv6_deletestaleaddrs(struct interface *ifp) 2168 { 2169 struct ipv6_state *state; 2170 struct ipv6_addr *ia, *ia1; 2171 2172 state = IPV6_STATE(ifp); 2173 if (state == NULL) 2174 return; 2175 2176 TAILQ_FOREACH_SAFE(ia, &state->addrs, next, ia1) { 2177 if (ia->flags & IPV6_AF_STALE) 2178 ipv6_handleifa(ifp->ctx, RTM_DELADDR, 2179 ifp->ctx->ifaces, ifp->name, 2180 &ia->addr, ia->prefix_len, 0, getpid()); 2181 } 2182 } 2183 2184 2185 static struct rt * 2186 inet6_makeroute(struct interface *ifp, const struct ra *rap) 2187 { 2188 struct rt *rt; 2189 2190 if ((rt = rt_new(ifp)) == NULL) 2191 return NULL; 2192 2193 #ifdef HAVE_ROUTE_METRIC 2194 rt->rt_metric = ifp->metric; 2195 #endif 2196 if (rap != NULL) 2197 rt->rt_mtu = rap->mtu; 2198 return rt; 2199 } 2200 2201 static struct rt * 2202 inet6_makeprefix(struct interface *ifp, const struct ra *rap, 2203 const struct ipv6_addr *addr) 2204 { 2205 struct rt *rt; 2206 struct in6_addr netmask; 2207 2208 if (addr == NULL || addr->prefix_len > 128) { 2209 errno = EINVAL; 2210 return NULL; 2211 } 2212 2213 /* There is no point in trying to manage a /128 prefix, 2214 * ones without a lifetime. */ 2215 if (addr->prefix_len == 128 || addr->prefix_vltime == 0) 2216 return NULL; 2217 2218 /* Don't install a reject route when not creating bigger prefixes. */ 2219 if (addr->flags & IPV6_AF_NOREJECT) 2220 return NULL; 2221 2222 /* This address is the delegated prefix, so add a reject route for 2223 * it via the loopback interface. */ 2224 if (addr->flags & IPV6_AF_DELEGATEDPFX) { 2225 struct interface *lo0; 2226 2227 TAILQ_FOREACH(lo0, ifp->ctx->ifaces, next) { 2228 if (lo0->flags & IFF_LOOPBACK) 2229 break; 2230 } 2231 if (lo0 == NULL) 2232 logwarnx("cannot find a loopback interface " 2233 "to reject via"); 2234 else 2235 ifp = lo0; 2236 } 2237 2238 if ((rt = inet6_makeroute(ifp, rap)) == NULL) 2239 return NULL; 2240 2241 sa_in6_init(&rt->rt_dest, &addr->prefix); 2242 ipv6_mask(&netmask, addr->prefix_len); 2243 sa_in6_init(&rt->rt_netmask, &netmask); 2244 if (addr->flags & IPV6_AF_DELEGATEDPFX) { 2245 rt->rt_flags |= RTF_REJECT; 2246 /* Linux does not like a gateway for a reject route. */ 2247 #ifndef __linux__ 2248 sa_in6_init(&rt->rt_gateway, &in6addr_loopback); 2249 #endif 2250 } else if (!(addr->flags & IPV6_AF_ONLINK)) 2251 sa_in6_init(&rt->rt_gateway, &rap->from); 2252 else 2253 rt->rt_gateway.sa_family = AF_UNSPEC; 2254 sa_in6_init(&rt->rt_ifa, &addr->addr); 2255 return rt; 2256 } 2257 2258 static struct rt * 2259 inet6_makerouter(struct ra *rap) 2260 { 2261 struct rt *rt; 2262 2263 if ((rt = inet6_makeroute(rap->iface, rap)) == NULL) 2264 return NULL; 2265 sa_in6_init(&rt->rt_dest, &in6addr_any); 2266 sa_in6_init(&rt->rt_netmask, &in6addr_any); 2267 sa_in6_init(&rt->rt_gateway, &rap->from); 2268 return rt; 2269 } 2270 2271 #define RT_IS_DEFAULT(rtp) \ 2272 (IN6_ARE_ADDR_EQUAL(&((rtp)->dest), &in6addr_any) && \ 2273 IN6_ARE_ADDR_EQUAL(&((rtp)->mask), &in6addr_any)) 2274 2275 static int 2276 inet6_staticroutes(rb_tree_t *routes, struct dhcpcd_ctx *ctx) 2277 { 2278 struct interface *ifp; 2279 struct ipv6_state *state; 2280 struct ipv6_addr *ia; 2281 struct rt *rt; 2282 2283 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 2284 if ((state = IPV6_STATE(ifp)) == NULL) 2285 continue; 2286 TAILQ_FOREACH(ia, &state->addrs, next) { 2287 if ((ia->flags & (IPV6_AF_ADDED | IPV6_AF_STATIC)) == 2288 (IPV6_AF_ADDED | IPV6_AF_STATIC)) 2289 { 2290 rt = inet6_makeprefix(ifp, NULL, ia); 2291 if (rt) 2292 rt_proto_add(routes, rt); 2293 } 2294 } 2295 } 2296 return 0; 2297 } 2298 2299 static int 2300 inet6_raroutes(rb_tree_t *routes, struct dhcpcd_ctx *ctx) 2301 { 2302 struct rt *rt; 2303 struct ra *rap; 2304 const struct ipv6_addr *addr; 2305 2306 if (ctx->ra_routers == NULL) 2307 return 0; 2308 2309 TAILQ_FOREACH(rap, ctx->ra_routers, next) { 2310 if (rap->expired) 2311 continue; 2312 TAILQ_FOREACH(addr, &rap->addrs, next) { 2313 if (addr->prefix_vltime == 0) 2314 continue; 2315 rt = inet6_makeprefix(rap->iface, rap, addr); 2316 if (rt) { 2317 rt->rt_dflags |= RTDF_RA; 2318 #ifdef HAVE_ROUTE_PREF 2319 rt->rt_pref = ipv6nd_rtpref(rap); 2320 #endif 2321 rt_proto_add(routes, rt); 2322 } 2323 } 2324 if (rap->lifetime == 0) 2325 continue; 2326 if (ipv6_anyglobal(rap->iface) == NULL) 2327 continue; 2328 rt = inet6_makerouter(rap); 2329 if (rt == NULL) 2330 continue; 2331 rt->rt_dflags |= RTDF_RA; 2332 #ifdef HAVE_ROUTE_PREF 2333 rt->rt_pref = ipv6nd_rtpref(rap); 2334 #endif 2335 rt_proto_add(routes, rt); 2336 } 2337 return 0; 2338 } 2339 2340 #ifdef DHCP6 2341 static int 2342 inet6_dhcproutes(rb_tree_t *routes, struct dhcpcd_ctx *ctx, 2343 enum DH6S dstate) 2344 { 2345 struct interface *ifp; 2346 const struct dhcp6_state *d6_state; 2347 const struct ipv6_addr *addr; 2348 struct rt *rt; 2349 2350 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 2351 d6_state = D6_CSTATE(ifp); 2352 if (d6_state && d6_state->state == dstate) { 2353 TAILQ_FOREACH(addr, &d6_state->addrs, next) { 2354 rt = inet6_makeprefix(ifp, NULL, addr); 2355 if (rt == NULL) 2356 continue; 2357 rt->rt_dflags |= RTDF_DHCP; 2358 rt_proto_add(routes, rt); 2359 } 2360 } 2361 } 2362 return 0; 2363 } 2364 #endif 2365 2366 bool 2367 inet6_getroutes(struct dhcpcd_ctx *ctx, rb_tree_t *routes) 2368 { 2369 2370 /* Should static take priority? */ 2371 if (inet6_staticroutes(routes, ctx) == -1) 2372 return false; 2373 2374 /* First add reachable routers and their prefixes */ 2375 if (inet6_raroutes(routes, ctx) == -1) 2376 return false; 2377 2378 #ifdef DHCP6 2379 /* We have no way of knowing if prefixes added by DHCP are reachable 2380 * or not, so we have to assume they are. 2381 * Add bound before delegated so we can prefer interfaces better. */ 2382 if (inet6_dhcproutes(routes, ctx, DH6S_BOUND) == -1) 2383 return false; 2384 if (inet6_dhcproutes(routes, ctx, DH6S_DELEGATED) == -1) 2385 return false; 2386 #endif 2387 2388 return true; 2389 } 2390