1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * Copyright 2015, OmniTI Computer Consulting, Inc. All rights reserved. 29 */ 30 31 #include "defs.h" 32 #include "tables.h" 33 34 #include <sys/sysmacros.h> 35 36 #include <dhcpagent_ipc.h> 37 #include <dhcpagent_util.h> 38 39 static boolean_t verify_opt_len(struct nd_opt_hdr *opt, int optlen, 40 struct phyint *pi, struct sockaddr_in6 *from); 41 42 static void incoming_rs(struct phyint *pi, struct nd_router_solicit *rs, 43 int len, struct sockaddr_in6 *from); 44 45 void incoming_ra(struct phyint *pi, struct nd_router_advert *ra, 46 int len, struct sockaddr_in6 *from, boolean_t loopback); 47 static void incoming_prefix_opt(struct phyint *pi, uchar_t *opt, 48 struct sockaddr_in6 *from, boolean_t loopback); 49 static void incoming_prefix_onlink(struct phyint *pi, uchar_t *opt); 50 void incoming_prefix_onlink_process(struct prefix *pr, 51 uchar_t *opt); 52 static void incoming_prefix_stateful(struct phyint *, uchar_t *); 53 static boolean_t incoming_prefix_addrconf(struct phyint *pi, 54 uchar_t *opt, struct sockaddr_in6 *from, 55 boolean_t loopback); 56 boolean_t incoming_prefix_addrconf_process(struct phyint *pi, 57 struct prefix *pr, uchar_t *opt, 58 struct sockaddr_in6 *from, boolean_t loopback, 59 boolean_t new_prefix); 60 static void incoming_mtu_opt(struct phyint *pi, uchar_t *opt, 61 struct sockaddr_in6 *from); 62 static void incoming_lla_opt(struct phyint *pi, uchar_t *opt, 63 struct sockaddr_in6 *from, int isrouter); 64 65 static void verify_ra_consistency(struct phyint *pi, 66 struct nd_router_advert *ra, 67 int len, struct sockaddr_in6 *from); 68 static void verify_prefix_opt(struct phyint *pi, uchar_t *opt, 69 char *frombuf); 70 static void verify_mtu_opt(struct phyint *pi, uchar_t *opt, 71 char *frombuf); 72 73 static void update_ra_flag(const struct phyint *pi, 74 const struct sockaddr_in6 *from, int isrouter); 75 76 /* 77 * Return a pointer to the specified option buffer. 78 * If not found return NULL. 79 */ 80 static void * 81 find_ancillary(struct msghdr *msg, int cmsg_type) 82 { 83 struct cmsghdr *cmsg; 84 85 for (cmsg = CMSG_FIRSTHDR(msg); cmsg != NULL; 86 cmsg = CMSG_NXTHDR(msg, cmsg)) { 87 if (cmsg->cmsg_level == IPPROTO_IPV6 && 88 cmsg->cmsg_type == cmsg_type) { 89 return (CMSG_DATA(cmsg)); 90 } 91 } 92 return (NULL); 93 } 94 95 void 96 in_data(struct phyint *pi) 97 { 98 struct sockaddr_in6 from; 99 struct icmp6_hdr *icmp; 100 struct nd_router_solicit *rs; 101 struct nd_router_advert *ra; 102 static uint64_t in_packet[(IP_MAXPACKET + 1)/8]; 103 static uint64_t ancillary_data[(IP_MAXPACKET + 1)/8]; 104 int len; 105 char abuf[INET6_ADDRSTRLEN]; 106 const char *msgbuf; 107 struct msghdr msg; 108 struct iovec iov; 109 uchar_t *opt; 110 uint_t hoplimit; 111 112 iov.iov_base = (char *)in_packet; 113 iov.iov_len = sizeof (in_packet); 114 msg.msg_iov = &iov; 115 msg.msg_iovlen = 1; 116 msg.msg_name = (struct sockaddr *)&from; 117 msg.msg_namelen = sizeof (from); 118 msg.msg_control = ancillary_data; 119 msg.msg_controllen = sizeof (ancillary_data); 120 121 if ((len = recvmsg(pi->pi_sock, &msg, 0)) < 0) { 122 logperror_pi(pi, "in_data: recvfrom"); 123 return; 124 } 125 if (len == 0) 126 return; 127 128 if (inet_ntop(AF_INET6, (void *)&from.sin6_addr, 129 abuf, sizeof (abuf)) == NULL) 130 msgbuf = "Unspecified Router"; 131 else 132 msgbuf = abuf; 133 134 /* Ignore packets > 64k or control buffers that don't fit */ 135 if (msg.msg_flags & (MSG_TRUNC|MSG_CTRUNC)) { 136 if (debug & D_PKTBAD) { 137 logmsg(LOG_DEBUG, "Truncated message: msg_flags 0x%x " 138 "from %s\n", msg.msg_flags, msgbuf); 139 } 140 return; 141 } 142 143 icmp = (struct icmp6_hdr *)in_packet; 144 145 if (len < ICMP6_MINLEN) { 146 logmsg(LOG_INFO, "Too short ICMP packet: %d bytes " 147 "from %s on %s\n", 148 len, msgbuf, pi->pi_name); 149 return; 150 } 151 152 opt = find_ancillary(&msg, IPV6_HOPLIMIT); 153 if (opt == NULL) { 154 /* Unknown hoplimit - must drop */ 155 logmsg(LOG_INFO, "Unknown hop limit from %s on %s\n", 156 msgbuf, pi->pi_name); 157 return; 158 } 159 hoplimit = *(uint_t *)opt; 160 opt = find_ancillary(&msg, IPV6_RTHDR); 161 if (opt != NULL) { 162 /* Can't allow routing headers in ND messages */ 163 logmsg(LOG_INFO, "ND message with routing header " 164 "from %s on %s\n", 165 msgbuf, pi->pi_name); 166 return; 167 } 168 switch (icmp->icmp6_type) { 169 case ND_ROUTER_SOLICIT: 170 if (!pi->pi_AdvSendAdvertisements) 171 return; 172 if (pi->pi_flags & IFF_NORTEXCH) { 173 if (debug & D_PKTIN) { 174 logmsg(LOG_DEBUG, "Ignore received RS packet " 175 "on %s (no route exchange on interface)\n", 176 pi->pi_name); 177 } 178 return; 179 } 180 181 /* 182 * Assumes that the kernel has verified the AH (if present) 183 * and the ICMP checksum. 184 */ 185 if (hoplimit != IPV6_MAX_HOPS) { 186 logmsg(LOG_DEBUG, "RS hop limit: %d from %s on %s\n", 187 hoplimit, msgbuf, pi->pi_name); 188 return; 189 } 190 191 if (icmp->icmp6_code != 0) { 192 logmsg(LOG_INFO, "RS code: %d from %s on %s\n", 193 icmp->icmp6_code, msgbuf, pi->pi_name); 194 return; 195 } 196 197 if (len < sizeof (struct nd_router_solicit)) { 198 logmsg(LOG_INFO, "RS too short: %d bytes " 199 "from %s on %s\n", 200 len, msgbuf, pi->pi_name); 201 return; 202 } 203 rs = (struct nd_router_solicit *)icmp; 204 if (len > sizeof (struct nd_router_solicit)) { 205 if (!verify_opt_len((struct nd_opt_hdr *)&rs[1], 206 len - sizeof (struct nd_router_solicit), pi, &from)) 207 return; 208 } 209 if (debug & D_PKTIN) { 210 print_route_sol("Received valid solicit from ", pi, 211 rs, len, &from); 212 } 213 incoming_rs(pi, rs, len, &from); 214 break; 215 216 case ND_ROUTER_ADVERT: 217 if (IN6_IS_ADDR_UNSPECIFIED(&from.sin6_addr)) { 218 /* 219 * Router advt. must have address! 220 * Logging the news and returning. 221 */ 222 logmsg(LOG_DEBUG, 223 "Router's address unspecified in advertisement\n"); 224 return; 225 } 226 if (pi->pi_flags & IFF_NORTEXCH) { 227 if (debug & D_PKTIN) { 228 logmsg(LOG_DEBUG, "Ignore received RA packet " 229 "on %s (no route exchange on interface)\n", 230 pi->pi_name); 231 } 232 return; 233 } 234 235 /* 236 * Assumes that the kernel has verified the AH (if present) 237 * and the ICMP checksum. 238 */ 239 if (!IN6_IS_ADDR_LINKLOCAL(&from.sin6_addr)) { 240 logmsg(LOG_DEBUG, "RA from %s - not link local on %s\n", 241 msgbuf, pi->pi_name); 242 return; 243 } 244 245 if (hoplimit != IPV6_MAX_HOPS) { 246 logmsg(LOG_INFO, "RA hop limit: %d from %s on %s\n", 247 hoplimit, msgbuf, pi->pi_name); 248 return; 249 } 250 251 if (icmp->icmp6_code != 0) { 252 logmsg(LOG_INFO, "RA code: %d from %s on %s\n", 253 icmp->icmp6_code, msgbuf, pi->pi_name); 254 return; 255 } 256 257 if (len < sizeof (struct nd_router_advert)) { 258 logmsg(LOG_INFO, "RA too short: %d bytes " 259 "from %s on %s\n", 260 len, msgbuf, pi->pi_name); 261 return; 262 } 263 ra = (struct nd_router_advert *)icmp; 264 if (len > sizeof (struct nd_router_advert)) { 265 if (!verify_opt_len((struct nd_opt_hdr *)&ra[1], 266 len - sizeof (struct nd_router_advert), pi, &from)) 267 return; 268 } 269 if (debug & D_PKTIN) { 270 print_route_adv("Received valid advert from ", pi, 271 ra, len, &from); 272 } 273 if (pi->pi_AdvSendAdvertisements) 274 verify_ra_consistency(pi, ra, len, &from); 275 else 276 incoming_ra(pi, ra, len, &from, _B_FALSE); 277 break; 278 } 279 } 280 281 /* 282 * Process a received router solicitation. 283 * Check for source link-layer address option and check if it 284 * is time to advertise. 285 */ 286 static void 287 incoming_rs(struct phyint *pi, struct nd_router_solicit *rs, int len, 288 struct sockaddr_in6 *from) 289 { 290 struct nd_opt_hdr *opt; 291 int optlen; 292 293 /* Process any options */ 294 len -= sizeof (struct nd_router_solicit); 295 opt = (struct nd_opt_hdr *)&rs[1]; 296 while (len >= sizeof (struct nd_opt_hdr)) { 297 optlen = opt->nd_opt_len * 8; 298 switch (opt->nd_opt_type) { 299 case ND_OPT_SOURCE_LINKADDR: 300 incoming_lla_opt(pi, (uchar_t *)opt, 301 from, NDF_ISROUTER_OFF); 302 break; 303 default: 304 break; 305 } 306 opt = (struct nd_opt_hdr *)((char *)opt + optlen); 307 len -= optlen; 308 } 309 /* Simple algorithm: treat unicast and multicast RSs the same */ 310 check_to_advertise(pi, RECEIVED_SOLICIT); 311 } 312 313 /* 314 * Function that sends commands to dhcpagent daemon. 315 */ 316 int 317 dhcp_op(struct phyint *pi, int type) 318 { 319 dhcp_ipc_request_t *request; 320 dhcp_ipc_reply_t *reply = NULL; 321 int error; 322 323 request = dhcp_ipc_alloc_request(type | DHCP_V6, pi->pi_name, NULL, 0, 324 DHCP_TYPE_NONE); 325 if (request == NULL) { 326 logmsg(LOG_ERR, "dhcp_op: out of memory\n"); 327 /* make sure we try again next time there's a chance */ 328 if (type != DHCP_RELEASE) { 329 pi->pi_ra_flags &= 330 ~ND_RA_FLAG_MANAGED & ~ND_RA_FLAG_OTHER; 331 } 332 return (DHCP_IPC_E_MEMORY); 333 } 334 335 error = dhcp_ipc_make_request(request, &reply, 0); 336 free(request); 337 if (error != 0) { 338 logmsg(LOG_ERR, "could not send request to dhcpagent: " 339 "%s: %s\n", pi->pi_name, dhcp_ipc_strerror(error)); 340 return (error); 341 } 342 343 error = reply->return_code; 344 free(reply); 345 346 return (error); 347 } 348 349 /* 350 * Start up DHCPv6 on a given physical interface. Does not wait for 351 * a message to be returned from the daemon. 352 */ 353 void 354 start_dhcp(struct phyint *pi) 355 { 356 int error; 357 int type; 358 359 if (dhcp_start_agent(DHCP_IPC_MAX_WAIT) == -1) { 360 logmsg(LOG_ERR, "unable to start %s\n", DHCP_AGENT_PATH); 361 /* make sure we try again next time there's a chance */ 362 pi->pi_ra_flags &= ~ND_RA_FLAG_MANAGED & ~ND_RA_FLAG_OTHER; 363 return; 364 } 365 366 else if (pi->pi_ra_flags & ND_RA_FLAG_MANAGED) 367 type = DHCP_START; 368 else 369 type = DHCP_INFORM; 370 371 error = dhcp_op(pi, type); 372 /* 373 * Timeout is considered to be "success" because we don't wait for DHCP 374 * to do its exchange. 375 */ 376 if (error != DHCP_IPC_SUCCESS && error != DHCP_IPC_E_RUNNING && 377 error != DHCP_IPC_E_TIMEOUT) { 378 logmsg(LOG_ERR, "Error in dhcpagent: %s: %s\n", 379 pi->pi_name, dhcp_ipc_strerror(error)); 380 } 381 } 382 383 /* 384 * Release the acquired DHCPv6 lease on a given physical interface. 385 * Does not wait for a message to be returned from the daemon. 386 */ 387 void 388 release_dhcp(struct phyint *pi) 389 { 390 int error; 391 int type; 392 393 type = DHCP_RELEASE; 394 retry: 395 error = dhcp_op(pi, type); 396 if (error != DHCP_IPC_SUCCESS && error != DHCP_IPC_E_RUNNING && 397 error != DHCP_IPC_E_TIMEOUT) { 398 if (type == DHCP_RELEASE && error == DHCP_IPC_E_OUTSTATE) { 399 /* 400 * Drop the dhcp control if we cannot release it. 401 */ 402 type = DHCP_DROP; 403 goto retry; 404 } 405 logmsg(LOG_ERR, "Error in dhcpagent: %s: %s\n", 406 pi->pi_name, dhcp_ipc_strerror(error)); 407 } 408 } 409 410 /* 411 * Globals to check if we're seeing unusual hop counts in Router 412 * Advertisements (RAs). We record the hopcounts in the kernel using 413 * SIOCSLIFLNKINFO, but the kernel ignores these when actually setting IPv6 414 * hop counts for packets. 415 * 416 * RFC 3756 does mention the possibility of an adversary throttling down 417 * hopcounts using unsolicited RAs. These variables can be tuned with 'mdb -p' 418 * to reduce/increase our logging threshholds. 419 */ 420 /* Really a boolean... if set, also log the offending sending address. */ 421 int bad_hopcount_record_addr = 0; 422 /* Anything less triggers a warning. Set to 0 to disable. */ 423 int bad_hopcount_threshhold = 16; 424 /* Number of packets received below the threshhold. */ 425 uint64_t bad_hopcount_packets; 426 427 /* 428 * Process a received router advertisement. 429 * Called both when packets arrive as well as when we send RAs. 430 * In the latter case 'loopback' is set. 431 */ 432 void 433 incoming_ra(struct phyint *pi, struct nd_router_advert *ra, int len, 434 struct sockaddr_in6 *from, boolean_t loopback) 435 { 436 struct nd_opt_hdr *opt; 437 int optlen; 438 struct lifreq lifr; 439 boolean_t set_needed = _B_FALSE; 440 struct router *dr; 441 uint16_t router_lifetime; 442 uint_t reachable, retrans; 443 boolean_t reachable_time_changed = _B_FALSE; 444 boolean_t slla_opt_present = _B_FALSE; 445 446 if (no_loopback && loopback) 447 return; 448 449 bzero(&lifr, sizeof (lifr)); 450 (void) strlcpy(lifr.lifr_name, pi->pi_name, sizeof (lifr.lifr_name)); 451 452 if (ra->nd_ra_curhoplimit != CURHOP_UNSPECIFIED && 453 ra->nd_ra_curhoplimit != pi->pi_CurHopLimit) { 454 pi->pi_CurHopLimit = ra->nd_ra_curhoplimit; 455 lifr.lifr_ifinfo.lir_maxhops = pi->pi_CurHopLimit; 456 set_needed = _B_TRUE; 457 458 if (pi->pi_CurHopLimit < bad_hopcount_threshhold) { 459 char abuf[INET6_ADDRSTRLEN]; 460 461 bad_hopcount_packets++; 462 logmsg(LOG_ALERT, 463 "Low hopcount %d received on %s%s%s\n", 464 pi->pi_CurHopLimit, pi->pi_name, 465 bad_hopcount_record_addr ? " from " : "", 466 bad_hopcount_record_addr ? 467 inet_ntop(AF_INET6, &from->sin6_addr, abuf, 468 INET6_ADDRSTRLEN) : ""); 469 } 470 } 471 472 reachable = ntohl(ra->nd_ra_reachable); 473 if (reachable != 0 && 474 reachable != pi->pi_BaseReachableTime) { 475 pi->pi_BaseReachableTime = reachable; 476 reachable_time_changed = _B_TRUE; 477 } 478 479 if (pi->pi_reach_time_since_random < MIN_REACH_RANDOM_INTERVAL || 480 reachable_time_changed) { 481 phyint_reach_random(pi, _B_FALSE); 482 set_needed = _B_TRUE; 483 } 484 lifr.lifr_ifinfo.lir_reachtime = pi->pi_ReachableTime; 485 486 retrans = ntohl(ra->nd_ra_retransmit); 487 if (retrans != 0 && 488 pi->pi_RetransTimer != retrans) { 489 pi->pi_RetransTimer = retrans; 490 lifr.lifr_ifinfo.lir_reachretrans = pi->pi_RetransTimer; 491 set_needed = _B_TRUE; 492 } 493 494 if (set_needed) { 495 if (ioctl(pi->pi_sock, SIOCSLIFLNKINFO, (char *)&lifr) < 0) { 496 logperror_pi(pi, "incoming_ra: SIOCSLIFLNKINFO"); 497 return; 498 } 499 } 500 501 /* 502 * If the "managed" flag is set, then just assume that the "other" flag 503 * is set as well. It's not legal to get addresses alone without 504 * getting other data. 505 */ 506 if (ra->nd_ra_flags_reserved & ND_RA_FLAG_MANAGED) 507 ra->nd_ra_flags_reserved |= ND_RA_FLAG_OTHER; 508 509 /* 510 * If either the "managed" or "other" bits have turned on, then it's 511 * now time to invoke DHCP. If only the "other" bit is set, then don't 512 * get addresses via DHCP; only "other" data. If "managed" is set, 513 * then we must always get both addresses and "other" data. 514 */ 515 if (pi->pi_autoconf && pi->pi_stateful && 516 (ra->nd_ra_flags_reserved & ~pi->pi_ra_flags & 517 (ND_RA_FLAG_MANAGED | ND_RA_FLAG_OTHER))) { 518 if (debug & D_DHCP) { 519 logmsg(LOG_DEBUG, 520 "incoming_ra: trigger dhcp %s on %s\n", 521 (ra->nd_ra_flags_reserved & ~pi->pi_ra_flags & 522 ND_RA_FLAG_MANAGED) ? "MANAGED" : "OTHER", 523 pi->pi_name); 524 } 525 pi->pi_ra_flags |= ra->nd_ra_flags_reserved; 526 start_dhcp(pi); 527 } 528 529 /* Skip default router code if sent from ourselves */ 530 if (!loopback) { 531 /* Find and update or add default router in list */ 532 dr = router_lookup(pi, from->sin6_addr); 533 router_lifetime = ntohs(ra->nd_ra_router_lifetime); 534 if (dr == NULL) { 535 if (router_lifetime != 0) { 536 dr = router_create(pi, from->sin6_addr, 537 MILLISEC * router_lifetime); 538 timer_schedule(dr->dr_lifetime); 539 } 540 } else { 541 dr->dr_lifetime = MILLISEC * router_lifetime; 542 if (dr->dr_lifetime != 0) 543 timer_schedule(dr->dr_lifetime); 544 if ((dr->dr_lifetime != 0 && !dr->dr_inkernel) || 545 (dr->dr_lifetime == 0 && dr->dr_inkernel)) 546 router_update_k(dr); 547 } 548 } 549 /* Process any options */ 550 len -= sizeof (struct nd_router_advert); 551 opt = (struct nd_opt_hdr *)&ra[1]; 552 while (len >= sizeof (struct nd_opt_hdr)) { 553 optlen = opt->nd_opt_len * 8; 554 switch (opt->nd_opt_type) { 555 case ND_OPT_PREFIX_INFORMATION: 556 incoming_prefix_opt(pi, (uchar_t *)opt, from, 557 loopback); 558 break; 559 case ND_OPT_MTU: 560 incoming_mtu_opt(pi, (uchar_t *)opt, from); 561 break; 562 case ND_OPT_SOURCE_LINKADDR: 563 /* skip lla option if sent from ourselves! */ 564 if (!loopback) { 565 incoming_lla_opt(pi, (uchar_t *)opt, 566 from, NDF_ISROUTER_ON); 567 slla_opt_present = _B_TRUE; 568 } 569 break; 570 default: 571 break; 572 } 573 opt = (struct nd_opt_hdr *)((char *)opt + optlen); 574 len -= optlen; 575 } 576 if (!loopback && !slla_opt_present) 577 update_ra_flag(pi, from, NDF_ISROUTER_ON); 578 /* Stop sending solicitations */ 579 check_to_solicit(pi, SOLICIT_DONE); 580 } 581 582 /* 583 * Process a received prefix option. 584 * Unless addrconf is turned off we process both the addrconf and the 585 * onlink aspects of the prefix option. 586 * 587 * Note that when a flag (onlink or auto) is turned off we do nothing - 588 * the prefix will time out. 589 */ 590 static void 591 incoming_prefix_opt(struct phyint *pi, uchar_t *opt, 592 struct sockaddr_in6 *from, boolean_t loopback) 593 { 594 struct nd_opt_prefix_info *po = (struct nd_opt_prefix_info *)opt; 595 boolean_t good_prefix = _B_TRUE; 596 597 if (8 * po->nd_opt_pi_len != sizeof (*po)) { 598 char abuf[INET6_ADDRSTRLEN]; 599 600 (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, 601 abuf, sizeof (abuf)); 602 logmsg(LOG_INFO, "prefix option from %s on %s wrong size " 603 "(%d bytes)\n", 604 abuf, pi->pi_name, 605 8 * (int)po->nd_opt_pi_len); 606 return; 607 } 608 if (IN6_IS_ADDR_LINKLOCAL(&po->nd_opt_pi_prefix)) { 609 char abuf[INET6_ADDRSTRLEN]; 610 611 (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, 612 abuf, sizeof (abuf)); 613 logmsg(LOG_INFO, "RA from %s on %s contains link-local prefix " 614 "- ignored\n", 615 abuf, pi->pi_name); 616 return; 617 } 618 if ((po->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_AUTO) && 619 pi->pi_stateless && pi->pi_autoconf) { 620 good_prefix = incoming_prefix_addrconf(pi, opt, from, loopback); 621 } 622 if ((po->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_ONLINK) && 623 good_prefix) { 624 incoming_prefix_onlink(pi, opt); 625 } 626 if (pi->pi_stateful && pi->pi_autoconf) 627 incoming_prefix_stateful(pi, opt); 628 } 629 630 /* 631 * Process prefix options with the onlink flag set. 632 * 633 * If there are no routers ndpd will add an onlink 634 * default route which will allow communication 635 * between neighbors. 636 * 637 * This function needs to loop to find the same prefix multiple times 638 * as if a failover happened earlier, the addresses belonging to 639 * a different interface may be found here on this interface. 640 */ 641 static void 642 incoming_prefix_onlink(struct phyint *pi, uchar_t *opt) 643 { 644 struct nd_opt_prefix_info *po = (struct nd_opt_prefix_info *)opt; 645 int plen; 646 struct prefix *pr; 647 uint32_t validtime; /* Without 2 hour rule */ 648 boolean_t found_one = _B_FALSE; 649 650 plen = po->nd_opt_pi_prefix_len; 651 for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) { 652 if (pr->pr_prefix_len == plen && 653 prefix_equal(po->nd_opt_pi_prefix, pr->pr_prefix, plen)) { 654 /* Exclude static prefixes */ 655 if (pr->pr_state & PR_STATIC) 656 continue; 657 found_one = _B_TRUE; 658 incoming_prefix_onlink_process(pr, opt); 659 } 660 } 661 662 validtime = ntohl(po->nd_opt_pi_valid_time); 663 /* 664 * If we have found a matching prefix already or validtime 665 * is zero, we have nothing to do. 666 */ 667 if (validtime == 0 || found_one) 668 return; 669 pr = prefix_create(pi, po->nd_opt_pi_prefix, plen, 0); 670 if (pr == NULL) 671 return; 672 incoming_prefix_onlink_process(pr, opt); 673 } 674 675 void 676 incoming_prefix_onlink_process(struct prefix *pr, uchar_t *opt) 677 { 678 struct nd_opt_prefix_info *po = (struct nd_opt_prefix_info *)opt; 679 uint32_t validtime; /* Without 2 hour rule */ 680 char abuf[INET6_ADDRSTRLEN]; 681 682 validtime = ntohl(po->nd_opt_pi_valid_time); 683 if (validtime != 0) 684 pr->pr_state |= PR_ONLINK; 685 else 686 pr->pr_state &= ~PR_ONLINK; 687 688 /* 689 * Convert from seconds to milliseconds avoiding overflow. 690 * If the lifetime in the packet is e.g. PREFIX_INFINITY - 1 691 * (4 billion seconds - about 130 years) we will in fact time 692 * out the prefix after 4 billion milliseconds - 46 days). 693 * Thus the longest lifetime (apart from infinity) is 46 days. 694 * Note that this ensures that PREFIX_INFINITY still means "forever". 695 */ 696 if (pr->pr_flags & IFF_TEMPORARY) { 697 pr->pr_OnLinkLifetime = pr->pr_ValidLifetime; 698 } else { 699 if (validtime >= PREFIX_INFINITY / MILLISEC) 700 pr->pr_OnLinkLifetime = PREFIX_INFINITY - 1; 701 else 702 pr->pr_OnLinkLifetime = validtime * MILLISEC; 703 } 704 pr->pr_OnLinkFlag = _B_TRUE; 705 if (debug & (D_PREFIX|D_TMP)) { 706 logmsg(LOG_DEBUG, "incoming_prefix_onlink_process(%s, %s/%u) " 707 "onlink %u state 0x%x, kstate 0x%x\n", 708 pr->pr_name, inet_ntop(AF_INET6, (void *)&pr->pr_prefix, 709 abuf, sizeof (abuf)), pr->pr_prefix_len, 710 pr->pr_OnLinkLifetime, pr->pr_state, pr->pr_kernel_state); 711 } 712 713 if (pr->pr_kernel_state != pr->pr_state) { 714 prefix_update_k(pr); 715 } 716 717 if (pr->pr_OnLinkLifetime != 0) 718 timer_schedule(pr->pr_OnLinkLifetime); 719 } 720 721 /* 722 * Process all prefix options by locating the DHCPv6-configured interfaces, and 723 * applying the netmasks as needed. 724 */ 725 static void 726 incoming_prefix_stateful(struct phyint *pi, uchar_t *opt) 727 { 728 struct nd_opt_prefix_info *po = (struct nd_opt_prefix_info *)opt; 729 struct prefix *pr; 730 boolean_t foundpref; 731 char abuf[INET6_ADDRSTRLEN]; 732 733 /* Make sure it's a valid prefix. */ 734 if (ntohl(po->nd_opt_pi_valid_time) == 0) { 735 if (debug & D_DHCP) 736 logmsg(LOG_DEBUG, "incoming_prefix_stateful: ignoring " 737 "prefix with no valid time\n"); 738 return; 739 } 740 741 if (debug & D_DHCP) 742 logmsg(LOG_DEBUG, "incoming_prefix_stateful(%s, %s/%d)\n", 743 pi->pi_name, inet_ntop(AF_INET6, 744 (void *)&po->nd_opt_pi_prefix, abuf, sizeof (abuf)), 745 po->nd_opt_pi_prefix_len); 746 foundpref = _B_FALSE; 747 for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) { 748 if (prefix_equal(po->nd_opt_pi_prefix, pr->pr_prefix, 749 po->nd_opt_pi_prefix_len)) { 750 if ((pr->pr_flags & IFF_DHCPRUNNING) && 751 pr->pr_prefix_len != po->nd_opt_pi_prefix_len) { 752 pr->pr_prefix_len = po->nd_opt_pi_prefix_len; 753 if (pr->pr_flags & IFF_UP) { 754 if (debug & D_DHCP) 755 logmsg(LOG_DEBUG, 756 "incoming_prefix_stateful:" 757 " set mask on DHCP %s\n", 758 pr->pr_name); 759 prefix_update_dhcp(pr); 760 } 761 } 762 if (pr->pr_prefix_len == po->nd_opt_pi_prefix_len && 763 (!(pr->pr_state & PR_STATIC) || 764 (pr->pr_flags & IFF_DHCPRUNNING))) 765 foundpref = _B_TRUE; 766 } 767 } 768 /* 769 * If there's no matching DHCPv6 prefix present, then create an empty 770 * one so that we'll be able to configure it later. 771 */ 772 if (!foundpref) { 773 pr = prefix_create(pi, po->nd_opt_pi_prefix, 774 po->nd_opt_pi_prefix_len, IFF_DHCPRUNNING); 775 if (pr != NULL) { 776 pr->pr_state = PR_STATIC; 777 if (debug & D_DHCP) 778 logmsg(LOG_DEBUG, 779 "incoming_prefix_stateful: created dummy " 780 "prefix for later\n"); 781 } 782 } 783 } 784 785 /* 786 * Process prefix options with the autonomous flag set. 787 * Returns false if this prefix results in a bad address (duplicate) 788 * This function needs to loop to find the same prefix multiple times 789 * as if a failover happened earlier, the addresses belonging to 790 * a different interface may be found here on this interface. 791 */ 792 static boolean_t 793 incoming_prefix_addrconf(struct phyint *pi, uchar_t *opt, 794 struct sockaddr_in6 *from, boolean_t loopback) 795 { 796 struct nd_opt_prefix_info *po = (struct nd_opt_prefix_info *)opt; 797 int plen; 798 struct prefix *pr; 799 uint32_t validtime, preftime; /* In seconds */ 800 char abuf[INET6_ADDRSTRLEN]; 801 char pbuf[INET6_ADDRSTRLEN]; 802 boolean_t found_pub = _B_FALSE; 803 boolean_t found_tmp = _B_FALSE; 804 boolean_t ret; 805 806 validtime = ntohl(po->nd_opt_pi_valid_time); 807 preftime = ntohl(po->nd_opt_pi_preferred_time); 808 plen = po->nd_opt_pi_prefix_len; 809 810 /* Sanity checks */ 811 if (validtime < preftime) { 812 (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, 813 abuf, sizeof (abuf)); 814 (void) inet_ntop(AF_INET6, 815 (void *)&po->nd_opt_pi_prefix, 816 pbuf, sizeof (pbuf)); 817 logmsg(LOG_WARNING, "prefix option %s/%u from %s on %s: " 818 "valid %u < pref %u ignored\n", 819 pbuf, plen, abuf, pi->pi_name, 820 validtime, preftime); 821 return (_B_FALSE); 822 } 823 824 for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) { 825 if (pr->pr_prefix_len == plen && 826 prefix_equal(po->nd_opt_pi_prefix, pr->pr_prefix, plen)) { 827 828 /* Exclude static prefixes and DHCP */ 829 if ((pr->pr_state & PR_STATIC) || 830 (pr->pr_flags & IFF_DHCPRUNNING)) 831 continue; 832 if (pr->pr_flags & IFF_TEMPORARY) { 833 /* 834 * If this address is deprecated and its token 835 * doesn't match the current tmp token, we want 836 * to create a new address with the current 837 * token. So don't count this addr as a match. 838 */ 839 if (!((pr->pr_flags & IFF_DEPRECATED) && 840 !token_equal(pi->pi_tmp_token, 841 pr->pr_address, TMP_TOKEN_BITS))) 842 found_tmp = _B_TRUE; 843 } else { 844 found_pub = _B_TRUE; 845 } 846 (void) incoming_prefix_addrconf_process(pi, pr, opt, 847 from, loopback, _B_FALSE); 848 } 849 } 850 851 /* 852 * If we have found a matching prefix (for public and, if temp addrs 853 * are enabled, for temporary) already or validtime is zero, we have 854 * nothing to do. 855 */ 856 if (validtime == 0 || 857 (found_pub && (!pi->pi_TmpAddrsEnabled || found_tmp))) 858 return (_B_TRUE); 859 860 if (!found_pub) { 861 pr = prefix_create(pi, po->nd_opt_pi_prefix, plen, 0); 862 if (pr == NULL) 863 return (_B_TRUE); 864 ret = incoming_prefix_addrconf_process(pi, pr, opt, from, 865 loopback, _B_TRUE); 866 } 867 /* 868 * if processing of the public address failed, 869 * don't bother with the temporary address. 870 */ 871 if (ret == _B_FALSE) 872 return (_B_FALSE); 873 874 if (pi->pi_TmpAddrsEnabled && !found_tmp) { 875 pr = prefix_create(pi, po->nd_opt_pi_prefix, plen, 876 IFF_TEMPORARY); 877 if (pr == NULL) 878 return (_B_TRUE); 879 ret = incoming_prefix_addrconf_process(pi, pr, opt, from, 880 loopback, _B_TRUE); 881 } 882 883 return (ret); 884 } 885 886 boolean_t 887 incoming_prefix_addrconf_process(struct phyint *pi, struct prefix *pr, 888 uchar_t *opt, struct sockaddr_in6 *from, boolean_t loopback, 889 boolean_t new_prefix) 890 { 891 struct nd_opt_prefix_info *po = (struct nd_opt_prefix_info *)opt; 892 char abuf[INET6_ADDRSTRLEN]; 893 char pbuf[INET6_ADDRSTRLEN]; 894 uint32_t validtime, preftime; /* In seconds */ 895 uint32_t recorded_validtime; /* In seconds */ 896 int plen; 897 struct prefix *other_pr; 898 899 validtime = ntohl(po->nd_opt_pi_valid_time); 900 preftime = ntohl(po->nd_opt_pi_preferred_time); 901 plen = po->nd_opt_pi_prefix_len; 902 if (!new_prefix) { 903 /* 904 * Check 2 hour rule on valid lifetime. 905 * Follows: RFC 2462 906 * If we advertised this prefix ourselves we skip 907 * these checks. They are also skipped if we did not 908 * previously do addrconf on this prefix. 909 */ 910 recorded_validtime = pr->pr_ValidLifetime / MILLISEC; 911 912 if (loopback || !(pr->pr_state & PR_AUTO) || 913 validtime >= MIN_VALID_LIFETIME || 914 /* LINTED - statement has no consequent */ 915 validtime >= recorded_validtime) { 916 /* OK */ 917 } else if (recorded_validtime < MIN_VALID_LIFETIME && 918 validtime < recorded_validtime) { 919 /* Ignore the prefix */ 920 (void) inet_ntop(AF_INET6, 921 (void *)&from->sin6_addr, 922 abuf, sizeof (abuf)); 923 (void) inet_ntop(AF_INET6, 924 (void *)&po->nd_opt_pi_prefix, 925 pbuf, sizeof (pbuf)); 926 logmsg(LOG_INFO, "prefix option %s/%u from %s on %s: " 927 "too short valid lifetime %u stored %u " 928 "- ignored\n", 929 pbuf, plen, abuf, pi->pi_name, 930 validtime, recorded_validtime); 931 return (_B_TRUE); 932 } else { 933 /* 934 * If the router clock runs slower than the 935 * host by 1 second over 2 hours then this 936 * test will set the lifetime back to 2 hours 937 * once i.e. a lifetime decrementing in 938 * realtime might cause the prefix to live an 939 * extra 2 hours on the host. 940 */ 941 (void) inet_ntop(AF_INET6, 942 (void *)&from->sin6_addr, 943 abuf, sizeof (abuf)); 944 (void) inet_ntop(AF_INET6, 945 (void *)&po->nd_opt_pi_prefix, 946 pbuf, sizeof (pbuf)); 947 logmsg(LOG_INFO, "prefix option %s/%u from %s on %s: " 948 "valid time %u stored %u rounded up " 949 "to %u\n", 950 pbuf, plen, abuf, pi->pi_name, 951 validtime, recorded_validtime, 952 MIN_VALID_LIFETIME); 953 validtime = MIN_VALID_LIFETIME; 954 } 955 } 956 957 /* 958 * For RFC3041 addresses, need to take token lifetime 959 * into account, too. 960 */ 961 if (pr->pr_flags & IFF_TEMPORARY) { 962 uint_t cur_tpreftime = 963 pi->pi_TmpPreferredLifetime - pi->pi_TmpDesyncFactor; 964 965 if (new_prefix) { 966 validtime = MIN(validtime, pi->pi_TmpValidLifetime); 967 preftime = MIN(preftime, cur_tpreftime); 968 } else { 969 uint_t cur_vexp, cur_pexp, curtime; 970 curtime = getcurrenttime() / MILLISEC; 971 972 cur_vexp = pr->pr_CreateTime + pi->pi_TmpValidLifetime; 973 cur_pexp = pr->pr_CreateTime + cur_tpreftime; 974 if (curtime > cur_vexp) 975 validtime = 0; 976 else if ((curtime + validtime) > cur_vexp) 977 validtime = cur_vexp - curtime; 978 /* 979 * If this is an existing address which was deprecated 980 * because of a bad token, we don't want to update its 981 * preferred lifetime! 982 */ 983 if ((pr->pr_PreferredLifetime == 0) && 984 !token_equal(pr->pr_address, pi->pi_tmp_token, 985 TMP_TOKEN_BITS)) 986 preftime = 0; 987 else if (curtime > cur_pexp) 988 preftime = 0; 989 else if ((curtime + preftime) > cur_pexp) 990 preftime = cur_pexp - curtime; 991 } 992 if ((preftime != 0) && (preftime <= pi->pi_TmpRegenAdvance)) { 993 (void) inet_ntop(AF_INET6, 994 (void *)&from->sin6_addr, 995 abuf, sizeof (abuf)); 996 (void) inet_ntop(AF_INET6, 997 (void *)&po->nd_opt_pi_prefix, 998 pbuf, sizeof (pbuf)); 999 logmsg(LOG_WARNING, "prefix opt %s/%u from %s on %s: " 1000 "preferred lifetime(%d) <= TmpRegenAdvance(%d)\n", 1001 pbuf, plen, abuf, pi->pi_name, preftime, 1002 pi->pi_TmpRegenAdvance); 1003 if (new_prefix) { 1004 prefix_update_ipadm_addrobj(pr, _B_FALSE); 1005 prefix_delete(pr); 1006 } 1007 return (_B_TRUE); 1008 } 1009 } 1010 if (debug & D_TMP) 1011 logmsg(LOG_DEBUG, "calculated lifetimes(%s, 0x%llx): v %d, " 1012 "p %d\n", pr->pr_name, pr->pr_flags, validtime, preftime); 1013 1014 if (!(pr->pr_state & PR_AUTO)) { 1015 int i, tokenlen; 1016 in6_addr_t *token; 1017 /* 1018 * Form a new local address if the lengths match. 1019 */ 1020 if (pr->pr_flags & IFF_TEMPORARY) { 1021 if (IN6_IS_ADDR_UNSPECIFIED(&pi->pi_tmp_token)) { 1022 if (!tmptoken_create(pi)) { 1023 prefix_delete(pr); 1024 return (_B_TRUE); 1025 } 1026 } 1027 tokenlen = TMP_TOKEN_BITS; 1028 token = &pi->pi_tmp_token; 1029 } else { 1030 tokenlen = pi->pi_token_length; 1031 token = &pi->pi_token; 1032 } 1033 if (pr->pr_prefix_len + tokenlen != IPV6_ABITS) { 1034 (void) inet_ntop(AF_INET6, 1035 (void *)&from->sin6_addr, 1036 abuf, sizeof (abuf)); 1037 (void) inet_ntop(AF_INET6, 1038 (void *)&po->nd_opt_pi_prefix, 1039 pbuf, sizeof (pbuf)); 1040 logmsg(LOG_INFO, "prefix option %s/%u from %s on %s: " 1041 "mismatched length %d token length %d\n", 1042 pbuf, plen, abuf, pi->pi_name, 1043 pr->pr_prefix_len, tokenlen); 1044 return (_B_TRUE); 1045 } 1046 for (i = 0; i < 16; i++) { 1047 /* 1048 * prefix_create ensures that pr_prefix has all-zero 1049 * bits after prefixlen. 1050 */ 1051 pr->pr_address.s6_addr[i] = pr->pr_prefix.s6_addr[i] | 1052 token->s6_addr[i]; 1053 } 1054 /* 1055 * Check if any other physical interface has the same 1056 * address configured already 1057 */ 1058 if ((other_pr = prefix_lookup_addr_match(pr)) != NULL) { 1059 /* 1060 * Delete this prefix structure as kernel 1061 * does not allow duplicated addresses 1062 */ 1063 logmsg(LOG_ERR, "incoming_prefix_addrconf_process: " 1064 "Duplicate prefix %s received on interface %s\n", 1065 inet_ntop(AF_INET6, &po->nd_opt_pi_prefix, abuf, 1066 sizeof (abuf)), pi->pi_name); 1067 logmsg(LOG_ERR, "incoming_prefix_addrconf_process: " 1068 "Prefix already exists in interface %s\n", 1069 other_pr->pr_physical->pi_name); 1070 if (new_prefix) { 1071 prefix_update_ipadm_addrobj(pr, _B_FALSE); 1072 prefix_delete(pr); 1073 return (_B_FALSE); 1074 } 1075 /* Ignore for addrconf purposes */ 1076 validtime = preftime = 0; 1077 } 1078 if ((pr->pr_flags & IFF_TEMPORARY) && new_prefix) { 1079 pr->pr_CreateTime = getcurrenttime() / MILLISEC; 1080 if (debug & D_TMP) 1081 logmsg(LOG_DEBUG, 1082 "created tmp addr(%s v %d p %d)\n", 1083 pr->pr_name, validtime, preftime); 1084 } 1085 } 1086 1087 if (validtime != 0) 1088 pr->pr_state |= PR_AUTO; 1089 else 1090 pr->pr_state &= ~(PR_AUTO|PR_DEPRECATED); 1091 if (preftime != 0 || !(pr->pr_state & PR_AUTO)) 1092 pr->pr_state &= ~PR_DEPRECATED; 1093 else 1094 pr->pr_state |= PR_DEPRECATED; 1095 1096 /* 1097 * Convert from seconds to milliseconds avoiding overflow. 1098 * If the lifetime in the packet is e.g. PREFIX_INFINITY - 1 1099 * (4 billion seconds - about 130 years) we will in fact time 1100 * out the prefix after 4 billion milliseconds - 46 days). 1101 * Thus the longest lifetime (apart from infinity) is 46 days. 1102 * Note that this ensures that PREFIX_INFINITY still means "forever". 1103 */ 1104 if (validtime >= PREFIX_INFINITY / MILLISEC) 1105 pr->pr_ValidLifetime = PREFIX_INFINITY - 1; 1106 else 1107 pr->pr_ValidLifetime = validtime * MILLISEC; 1108 if (preftime >= PREFIX_INFINITY / MILLISEC) 1109 pr->pr_PreferredLifetime = PREFIX_INFINITY - 1; 1110 else 1111 pr->pr_PreferredLifetime = preftime * MILLISEC; 1112 pr->pr_AutonomousFlag = _B_TRUE; 1113 1114 if (debug & D_PREFIX) { 1115 logmsg(LOG_DEBUG, "incoming_prefix_addrconf_process(%s, %s/%u) " 1116 "valid %u pref %u\n", 1117 pr->pr_physical->pi_name, 1118 inet_ntop(AF_INET6, (void *)&pr->pr_prefix, 1119 abuf, sizeof (abuf)), pr->pr_prefix_len, 1120 pr->pr_ValidLifetime, pr->pr_PreferredLifetime); 1121 } 1122 1123 if (pr->pr_state & PR_AUTO) { 1124 /* Take the min of the two timeouts by calling it twice */ 1125 if (pr->pr_ValidLifetime != 0) 1126 timer_schedule(pr->pr_ValidLifetime); 1127 if (pr->pr_PreferredLifetime != 0) 1128 timer_schedule(pr->pr_PreferredLifetime); 1129 } 1130 if (pr->pr_kernel_state != pr->pr_state) { 1131 /* Log a message when an addrconf prefix goes away */ 1132 if ((pr->pr_kernel_state & PR_AUTO) && 1133 !(pr->pr_state & PR_AUTO)) { 1134 char abuf[INET6_ADDRSTRLEN]; 1135 1136 logmsg(LOG_WARNING, "Address removed due to zero " 1137 "valid lifetime %s\n", 1138 inet_ntop(AF_INET6, (void *)&pr->pr_address, 1139 abuf, sizeof (abuf))); 1140 } 1141 prefix_update_k(pr); 1142 } 1143 return (_B_TRUE); 1144 } 1145 1146 /* 1147 * Process an MTU option received in a router advertisement. 1148 */ 1149 static void 1150 incoming_mtu_opt(struct phyint *pi, uchar_t *opt, 1151 struct sockaddr_in6 *from) 1152 { 1153 struct nd_opt_mtu *mo = (struct nd_opt_mtu *)opt; 1154 struct lifreq lifr; 1155 uint32_t mtu; 1156 1157 if (8 * mo->nd_opt_mtu_len != sizeof (*mo)) { 1158 char abuf[INET6_ADDRSTRLEN]; 1159 1160 (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, 1161 abuf, sizeof (abuf)); 1162 logmsg(LOG_INFO, "mtu option from %s on %s wrong size " 1163 "(%d bytes)\n", 1164 abuf, pi->pi_name, 1165 8 * (int)mo->nd_opt_mtu_len); 1166 return; 1167 } 1168 mtu = ntohl(mo->nd_opt_mtu_mtu); 1169 if (pi->pi_LinkMTU == mtu) 1170 return; /* No change */ 1171 if (mtu > pi->pi_mtu) { 1172 /* Can't exceed physical MTU */ 1173 char abuf[INET6_ADDRSTRLEN]; 1174 1175 (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, 1176 abuf, sizeof (abuf)); 1177 logmsg(LOG_INFO, "mtu option from %s on %s too large " 1178 "MTU %d - %d\n", abuf, pi->pi_name, mtu, pi->pi_mtu); 1179 return; 1180 } 1181 if (mtu < IPV6_MIN_MTU) { 1182 char abuf[INET6_ADDRSTRLEN]; 1183 1184 (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, 1185 abuf, sizeof (abuf)); 1186 logmsg(LOG_INFO, "mtu option from %s on %s too small " 1187 "MTU (%d)\n", abuf, pi->pi_name, mtu); 1188 return; 1189 } 1190 1191 pi->pi_LinkMTU = mtu; 1192 bzero(&lifr, sizeof (lifr)); 1193 (void) strlcpy(lifr.lifr_name, pi->pi_name, sizeof (lifr.lifr_name)); 1194 lifr.lifr_ifinfo.lir_maxmtu = pi->pi_LinkMTU; 1195 if (ioctl(pi->pi_sock, SIOCSLIFLNKINFO, (char *)&lifr) < 0) { 1196 logperror_pi(pi, "incoming_mtu_opt: SIOCSLIFLNKINFO"); 1197 return; 1198 } 1199 } 1200 1201 /* 1202 * Process a source link-layer address option received in a router 1203 * advertisement or solicitation. 1204 */ 1205 static void 1206 incoming_lla_opt(struct phyint *pi, uchar_t *opt, 1207 struct sockaddr_in6 *from, int isrouter) 1208 { 1209 struct nd_opt_lla *lo = (struct nd_opt_lla *)opt; 1210 struct lifreq lifr; 1211 struct sockaddr_in6 *sin6; 1212 int max_content_len; 1213 1214 /* 1215 * Get our link-layer address length. We may not have one, in which 1216 * case we can just bail. 1217 */ 1218 if (phyint_get_lla(pi, &lifr) != 0) 1219 return; 1220 1221 /* 1222 * Can't remove padding since it is link type specific. 1223 * However, we check against the length of our link-layer address. 1224 * Note: assumes that all links have a fixed length address. 1225 */ 1226 max_content_len = lo->nd_opt_lla_len * 8 - sizeof (struct nd_opt_hdr); 1227 if (max_content_len < lifr.lifr_nd.lnr_hdw_len || 1228 (max_content_len >= 8 && 1229 max_content_len - 7 > lifr.lifr_nd.lnr_hdw_len)) { 1230 char abuf[INET6_ADDRSTRLEN]; 1231 1232 (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, 1233 abuf, sizeof (abuf)); 1234 logmsg(LOG_INFO, "lla option from %s on %s too long with bad " 1235 "physaddr length (%d vs. %d bytes)\n", abuf, pi->pi_name, 1236 max_content_len, lifr.lifr_nd.lnr_hdw_len); 1237 return; 1238 } 1239 1240 bcopy(lo->nd_opt_lla_hdw_addr, lifr.lifr_nd.lnr_hdw_addr, 1241 lifr.lifr_nd.lnr_hdw_len); 1242 1243 sin6 = (struct sockaddr_in6 *)&lifr.lifr_nd.lnr_addr; 1244 bzero(sin6, sizeof (struct sockaddr_in6)); 1245 sin6->sin6_family = AF_INET6; 1246 sin6->sin6_addr = from->sin6_addr; 1247 1248 /* 1249 * Set IsRouter flag if RA; clear if RS. 1250 */ 1251 lifr.lifr_nd.lnr_state_create = ND_STALE; 1252 lifr.lifr_nd.lnr_state_same_lla = ND_UNCHANGED; 1253 lifr.lifr_nd.lnr_state_diff_lla = ND_STALE; 1254 lifr.lifr_nd.lnr_flags = isrouter; 1255 (void) strlcpy(lifr.lifr_name, pi->pi_name, sizeof (lifr.lifr_name)); 1256 if (ioctl(pi->pi_sock, SIOCLIFSETND, (char *)&lifr) < 0) { 1257 logperror_pi(pi, "incoming_lla_opt: SIOCLIFSETND"); 1258 return; 1259 } 1260 } 1261 1262 /* 1263 * Verify the content of the received router advertisement against our 1264 * own configuration as specified in RFC 2461. 1265 */ 1266 static void 1267 verify_ra_consistency(struct phyint *pi, struct nd_router_advert *ra, int len, 1268 struct sockaddr_in6 *from) 1269 { 1270 char frombuf[INET6_ADDRSTRLEN]; 1271 struct nd_opt_hdr *opt; 1272 int optlen; 1273 uint_t reachable, retrans; 1274 boolean_t pktflag, myflag; 1275 1276 (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, 1277 frombuf, sizeof (frombuf)); 1278 1279 if (ra->nd_ra_curhoplimit != 0 && 1280 pi->pi_AdvCurHopLimit != 0 && 1281 ra->nd_ra_curhoplimit != pi->pi_AdvCurHopLimit) { 1282 logmsg(LOG_INFO, "RA from %s on %s inconsistent cur hop " 1283 "limit:\n\treceived %d configuration %d\n", 1284 frombuf, pi->pi_name, 1285 ra->nd_ra_curhoplimit, pi->pi_AdvCurHopLimit); 1286 } 1287 1288 reachable = ntohl(ra->nd_ra_reachable); 1289 if (reachable != 0 && pi->pi_AdvReachableTime != 0 && 1290 reachable != pi->pi_AdvReachableTime) { 1291 logmsg(LOG_INFO, "RA from %s on %s inconsistent reachable " 1292 "time:\n\treceived %d configuration %d\n", 1293 frombuf, pi->pi_name, 1294 reachable, pi->pi_AdvReachableTime); 1295 } 1296 1297 retrans = ntohl(ra->nd_ra_retransmit); 1298 if (retrans != 0 && pi->pi_AdvRetransTimer != 0 && 1299 retrans != pi->pi_AdvRetransTimer) { 1300 logmsg(LOG_INFO, "RA from %s on %s inconsistent retransmit " 1301 "timer:\n\treceived %d configuration %d\n", 1302 frombuf, pi->pi_name, 1303 retrans, pi->pi_AdvRetransTimer); 1304 } 1305 1306 pktflag = ((ra->nd_ra_flags_reserved & ND_RA_FLAG_MANAGED) != 0); 1307 myflag = (pi->pi_AdvManagedFlag != 0); 1308 if (pktflag != myflag) { 1309 logmsg(LOG_INFO, "RA from %s on %s inconsistent managed " 1310 "flag:\n\treceived %s configuration %s\n", 1311 frombuf, pi->pi_name, 1312 (pktflag ? "ON" : "OFF"), 1313 (myflag ? "ON" : "OFF")); 1314 } 1315 pktflag = ((ra->nd_ra_flags_reserved & ND_RA_FLAG_OTHER) != 0); 1316 myflag = (pi->pi_AdvOtherConfigFlag != 0); 1317 if (pktflag != myflag) { 1318 logmsg(LOG_INFO, "RA from %s on %s inconsistent other config " 1319 "flag:\n\treceived %s configuration %s\n", 1320 frombuf, pi->pi_name, 1321 (pktflag ? "ON" : "OFF"), 1322 (myflag ? "ON" : "OFF")); 1323 } 1324 1325 /* Process any options */ 1326 len -= sizeof (struct nd_router_advert); 1327 opt = (struct nd_opt_hdr *)&ra[1]; 1328 while (len >= sizeof (struct nd_opt_hdr)) { 1329 optlen = opt->nd_opt_len * 8; 1330 switch (opt->nd_opt_type) { 1331 case ND_OPT_PREFIX_INFORMATION: 1332 verify_prefix_opt(pi, (uchar_t *)opt, frombuf); 1333 break; 1334 case ND_OPT_MTU: 1335 verify_mtu_opt(pi, (uchar_t *)opt, frombuf); 1336 break; 1337 default: 1338 break; 1339 } 1340 opt = (struct nd_opt_hdr *)((char *)opt + optlen); 1341 len -= optlen; 1342 } 1343 } 1344 1345 /* 1346 * Verify that the lifetimes and onlink/auto flags are consistent 1347 * with our settings. 1348 */ 1349 static void 1350 verify_prefix_opt(struct phyint *pi, uchar_t *opt, char *frombuf) 1351 { 1352 struct nd_opt_prefix_info *po = (struct nd_opt_prefix_info *)opt; 1353 int plen; 1354 struct adv_prefix *adv_pr; 1355 uint32_t validtime, preftime; 1356 char prefixbuf[INET6_ADDRSTRLEN]; 1357 int pktflag, myflag; 1358 1359 if (8 * po->nd_opt_pi_len != sizeof (*po)) { 1360 logmsg(LOG_INFO, "RA prefix option from %s on %s wrong size " 1361 "(%d bytes)\n", 1362 frombuf, pi->pi_name, 1363 8 * (int)po->nd_opt_pi_len); 1364 return; 1365 } 1366 if (IN6_IS_ADDR_LINKLOCAL(&po->nd_opt_pi_prefix)) { 1367 logmsg(LOG_INFO, "RA from %s on %s contains link-local " 1368 "prefix - ignored\n", 1369 frombuf, pi->pi_name); 1370 return; 1371 } 1372 plen = po->nd_opt_pi_prefix_len; 1373 adv_pr = adv_prefix_lookup(pi, po->nd_opt_pi_prefix, plen); 1374 if (adv_pr == NULL) 1375 return; 1376 1377 /* Ignore prefixes which we do not advertise */ 1378 if (!adv_pr->adv_pr_AdvAutonomousFlag && !adv_pr->adv_pr_AdvOnLinkFlag) 1379 return; 1380 (void) inet_ntop(AF_INET6, (void *)&adv_pr->adv_pr_prefix, 1381 prefixbuf, sizeof (prefixbuf)); 1382 pktflag = ((po->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_AUTO) != 0); 1383 myflag = (adv_pr->adv_pr_AdvAutonomousFlag != 0); 1384 if (pktflag != myflag) { 1385 logmsg(LOG_INFO, 1386 "RA from %s on %s inconsistent autonomous flag for \n\t" 1387 "prefix %s/%u: received %s configuration %s\n", 1388 frombuf, pi->pi_name, prefixbuf, adv_pr->adv_pr_prefix_len, 1389 (pktflag ? "ON" : "OFF"), 1390 (myflag ? "ON" : "OFF")); 1391 } 1392 1393 pktflag = ((po->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_ONLINK) != 0); 1394 myflag = (adv_pr->adv_pr_AdvOnLinkFlag != 0); 1395 if (pktflag != myflag) { 1396 logmsg(LOG_INFO, "RA from %s on %s inconsistent on link flag " 1397 "for \n\tprefix %s/%u: received %s configuration %s\n", 1398 frombuf, pi->pi_name, prefixbuf, adv_pr->adv_pr_prefix_len, 1399 (pktflag ? "ON" : "OFF"), 1400 (myflag ? "ON" : "OFF")); 1401 } 1402 validtime = ntohl(po->nd_opt_pi_valid_time); 1403 preftime = ntohl(po->nd_opt_pi_preferred_time); 1404 1405 /* 1406 * Take into account variation for lifetimes decrementing 1407 * in real time. Allow +/- 10 percent and +/- 10 seconds. 1408 */ 1409 #define LOWER_LIMIT(val) ((val) - (val)/10 - 10) 1410 #define UPPER_LIMIT(val) ((val) + (val)/10 + 10) 1411 if (adv_pr->adv_pr_AdvValidRealTime) { 1412 if (adv_pr->adv_pr_AdvValidExpiration > 0 && 1413 (validtime < 1414 LOWER_LIMIT(adv_pr->adv_pr_AdvValidExpiration) || 1415 validtime > 1416 UPPER_LIMIT(adv_pr->adv_pr_AdvValidExpiration))) { 1417 logmsg(LOG_INFO, "RA from %s on %s inconsistent valid " 1418 "lifetime for\n\tprefix %s/%u: received %d " 1419 "configuration %d\n", 1420 frombuf, pi->pi_name, prefixbuf, 1421 adv_pr->adv_pr_prefix_len, 1422 validtime, adv_pr->adv_pr_AdvValidExpiration); 1423 } 1424 } else { 1425 if (validtime != adv_pr->adv_pr_AdvValidLifetime) { 1426 logmsg(LOG_INFO, "RA from %s on %s inconsistent valid " 1427 "lifetime for\n\tprefix %s/%u: received %d " 1428 "configuration %d\n", 1429 frombuf, pi->pi_name, prefixbuf, 1430 adv_pr->adv_pr_prefix_len, 1431 validtime, adv_pr->adv_pr_AdvValidLifetime); 1432 } 1433 } 1434 1435 if (adv_pr->adv_pr_AdvPreferredRealTime) { 1436 if (adv_pr->adv_pr_AdvPreferredExpiration > 0 && 1437 (preftime < 1438 LOWER_LIMIT(adv_pr->adv_pr_AdvPreferredExpiration) || 1439 preftime > 1440 UPPER_LIMIT(adv_pr->adv_pr_AdvPreferredExpiration))) { 1441 logmsg(LOG_INFO, "RA from %s on %s inconsistent " 1442 "preferred lifetime for\n\tprefix %s/%u: " 1443 "received %d configuration %d\n", 1444 frombuf, pi->pi_name, prefixbuf, 1445 adv_pr->adv_pr_prefix_len, 1446 preftime, adv_pr->adv_pr_AdvPreferredExpiration); 1447 } 1448 } else { 1449 if (preftime != adv_pr->adv_pr_AdvPreferredLifetime) { 1450 logmsg(LOG_INFO, "RA from %s on %s inconsistent " 1451 "preferred lifetime for\n\tprefix %s/%u: " 1452 "received %d configuration %d\n", 1453 frombuf, pi->pi_name, prefixbuf, 1454 adv_pr->adv_pr_prefix_len, 1455 preftime, adv_pr->adv_pr_AdvPreferredLifetime); 1456 } 1457 } 1458 } 1459 1460 /* 1461 * Verify the received MTU against our own configuration. 1462 */ 1463 static void 1464 verify_mtu_opt(struct phyint *pi, uchar_t *opt, char *frombuf) 1465 { 1466 struct nd_opt_mtu *mo = (struct nd_opt_mtu *)opt; 1467 uint32_t mtu; 1468 1469 if (8 * mo->nd_opt_mtu_len != sizeof (*mo)) { 1470 logmsg(LOG_INFO, "mtu option from %s on %s wrong size " 1471 "(%d bytes)\n", 1472 frombuf, pi->pi_name, 1473 8 * (int)mo->nd_opt_mtu_len); 1474 return; 1475 } 1476 mtu = ntohl(mo->nd_opt_mtu_mtu); 1477 if (pi->pi_AdvLinkMTU != 0 && 1478 pi->pi_AdvLinkMTU != mtu) { 1479 logmsg(LOG_INFO, "RA from %s on %s inconsistent MTU: " 1480 "received %d configuration %d\n", 1481 frombuf, pi->pi_name, 1482 mtu, pi->pi_AdvLinkMTU); 1483 } 1484 } 1485 1486 /* 1487 * Verify that all options have a non-zero length and that 1488 * the options fit within the total length of the packet (optlen). 1489 */ 1490 static boolean_t 1491 verify_opt_len(struct nd_opt_hdr *opt, int optlen, 1492 struct phyint *pi, struct sockaddr_in6 *from) 1493 { 1494 while (optlen > 0) { 1495 if (opt->nd_opt_len == 0) { 1496 char abuf[INET6_ADDRSTRLEN]; 1497 1498 (void) inet_ntop(AF_INET6, 1499 (void *)&from->sin6_addr, 1500 abuf, sizeof (abuf)); 1501 1502 logmsg(LOG_INFO, "Zero length option type 0x%x " 1503 "from %s on %s\n", 1504 opt->nd_opt_type, abuf, pi->pi_name); 1505 return (_B_FALSE); 1506 } 1507 optlen -= 8 * opt->nd_opt_len; 1508 if (optlen < 0) { 1509 char abuf[INET6_ADDRSTRLEN]; 1510 1511 (void) inet_ntop(AF_INET6, 1512 (void *)&from->sin6_addr, 1513 abuf, sizeof (abuf)); 1514 1515 logmsg(LOG_INFO, "Too large option: type 0x%x len %u " 1516 "from %s on %s\n", 1517 opt->nd_opt_type, opt->nd_opt_len, 1518 abuf, pi->pi_name); 1519 return (_B_FALSE); 1520 } 1521 opt = (struct nd_opt_hdr *)((char *)opt + 1522 8 * opt->nd_opt_len); 1523 } 1524 return (_B_TRUE); 1525 } 1526 1527 /* 1528 * Update IsRouter Flag for Host turning into a router or vice-versa. 1529 */ 1530 static void 1531 update_ra_flag(const struct phyint *pi, const struct sockaddr_in6 *from, 1532 int isrouter) 1533 { 1534 struct lifreq lifr; 1535 char abuf[INET6_ADDRSTRLEN]; 1536 struct sockaddr_in6 *sin6; 1537 1538 /* check if valid flag is being set */ 1539 if ((isrouter != NDF_ISROUTER_ON) && 1540 (isrouter != NDF_ISROUTER_OFF)) { 1541 logmsg(LOG_ERR, "update_ra_flag: Invalid IsRouter " 1542 "flag %d\n", isrouter); 1543 return; 1544 } 1545 1546 sin6 = (struct sockaddr_in6 *)&lifr.lifr_nd.lnr_addr; 1547 bzero(sin6, sizeof (*sin6)); 1548 sin6->sin6_family = AF_INET6; 1549 sin6->sin6_addr = from->sin6_addr; 1550 1551 (void) strlcpy(lifr.lifr_name, pi->pi_name, sizeof (lifr.lifr_name)); 1552 1553 if (ioctl(pi->pi_sock, SIOCLIFGETND, (char *)&lifr) < 0) { 1554 if (errno == ESRCH) { 1555 if (debug & D_IFSCAN) { 1556 logmsg(LOG_DEBUG, 1557 "update_ra_flag: SIOCLIFGETND: nce doesn't exist, not setting IFF_ROUTER\n"); 1558 } 1559 } else { 1560 logperror_pi(pi, "update_ra_flag: SIOCLIFGETND"); 1561 } 1562 } else { 1563 /* 1564 * The lif_nd_req structure has three state values to be used 1565 * when changing/updating nces : 1566 * lnr_state_create, lnr_state_same_lla, and lnr_state_diff_lla. 1567 * 1568 * In this case, we're updating an nce, without changing lla; 1569 * so we set lnr_state_same_lla to ND_UNCHANGED, indicating that 1570 * nce's state should not be affected by our flag change. 1571 * 1572 * The kernel implementation also expects the lnr_state_create 1573 * field be always set, before processing ioctl request for NCE 1574 * update. 1575 * We use the state as STALE, while addressing the possibility 1576 * of NCE deletion when ioctl with SIOCLIFGETND argument 1577 * in earlier step is returned - further in such case we don't 1578 * want to re-create the entry in the reachable state. 1579 */ 1580 lifr.lifr_nd.lnr_state_create = ND_STALE; 1581 lifr.lifr_nd.lnr_state_same_lla = ND_UNCHANGED; 1582 lifr.lifr_nd.lnr_flags = isrouter; 1583 if ((ioctl(pi->pi_sock, SIOCLIFSETND, (char *)&lifr)) < 0) { 1584 logperror_pi(pi, "update_ra_flag: SIOCLIFSETND"); 1585 } else { 1586 (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, 1587 abuf, sizeof (abuf)); 1588 logmsg(LOG_INFO, "update_ra_flag: IsRouter flag " 1589 "updated for %s\n", abuf); 1590 } 1591 } 1592 } 1593