/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2010 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Copyright 2015, OmniTI Computer Consulting, Inc. All rights reserved. */ #include "defs.h" #include "tables.h" #include #include #include static boolean_t verify_opt_len(struct nd_opt_hdr *opt, int optlen, struct phyint *pi, struct sockaddr_in6 *from); static void incoming_rs(struct phyint *pi, struct nd_router_solicit *rs, int len, struct sockaddr_in6 *from); void incoming_ra(struct phyint *pi, struct nd_router_advert *ra, int len, struct sockaddr_in6 *from, boolean_t loopback); static void incoming_prefix_opt(struct phyint *pi, uchar_t *opt, struct sockaddr_in6 *from, boolean_t loopback); static void incoming_prefix_onlink(struct phyint *pi, uchar_t *opt); void incoming_prefix_onlink_process(struct prefix *pr, uchar_t *opt); static void incoming_prefix_stateful(struct phyint *, uchar_t *); static boolean_t incoming_prefix_addrconf(struct phyint *pi, uchar_t *opt, struct sockaddr_in6 *from, boolean_t loopback); boolean_t incoming_prefix_addrconf_process(struct phyint *pi, struct prefix *pr, uchar_t *opt, struct sockaddr_in6 *from, boolean_t loopback, boolean_t new_prefix); static void incoming_mtu_opt(struct phyint *pi, uchar_t *opt, struct sockaddr_in6 *from); static void incoming_lla_opt(struct phyint *pi, uchar_t *opt, struct sockaddr_in6 *from, int isrouter); static void verify_ra_consistency(struct phyint *pi, struct nd_router_advert *ra, int len, struct sockaddr_in6 *from); static void verify_prefix_opt(struct phyint *pi, uchar_t *opt, char *frombuf); static void verify_mtu_opt(struct phyint *pi, uchar_t *opt, char *frombuf); static void update_ra_flag(const struct phyint *pi, const struct sockaddr_in6 *from, int isrouter); /* * Return a pointer to the specified option buffer. * If not found return NULL. */ static void * find_ancillary(struct msghdr *msg, int cmsg_type) { struct cmsghdr *cmsg; for (cmsg = CMSG_FIRSTHDR(msg); cmsg != NULL; cmsg = CMSG_NXTHDR(msg, cmsg)) { if (cmsg->cmsg_level == IPPROTO_IPV6 && cmsg->cmsg_type == cmsg_type) { return (CMSG_DATA(cmsg)); } } return (NULL); } void in_data(struct phyint *pi) { struct sockaddr_in6 from; struct icmp6_hdr *icmp; struct nd_router_solicit *rs; struct nd_router_advert *ra; static uint64_t in_packet[(IP_MAXPACKET + 1)/8]; static uint64_t ancillary_data[(IP_MAXPACKET + 1)/8]; int len; char abuf[INET6_ADDRSTRLEN]; const char *msgbuf; struct msghdr msg; struct iovec iov; uchar_t *opt; uint_t hoplimit; iov.iov_base = (char *)in_packet; iov.iov_len = sizeof (in_packet); msg.msg_iov = &iov; msg.msg_iovlen = 1; msg.msg_name = (struct sockaddr *)&from; msg.msg_namelen = sizeof (from); msg.msg_control = ancillary_data; msg.msg_controllen = sizeof (ancillary_data); if ((len = recvmsg(pi->pi_sock, &msg, 0)) < 0) { logperror_pi(pi, "in_data: recvfrom"); return; } if (len == 0) return; if (inet_ntop(AF_INET6, (void *)&from.sin6_addr, abuf, sizeof (abuf)) == NULL) msgbuf = "Unspecified Router"; else msgbuf = abuf; /* Ignore packets > 64k or control buffers that don't fit */ if (msg.msg_flags & (MSG_TRUNC|MSG_CTRUNC)) { if (debug & D_PKTBAD) { logmsg(LOG_DEBUG, "Truncated message: msg_flags 0x%x " "from %s\n", msg.msg_flags, msgbuf); } return; } icmp = (struct icmp6_hdr *)in_packet; if (len < ICMP6_MINLEN) { logmsg(LOG_INFO, "Too short ICMP packet: %d bytes " "from %s on %s\n", len, msgbuf, pi->pi_name); return; } opt = find_ancillary(&msg, IPV6_HOPLIMIT); if (opt == NULL) { /* Unknown hoplimit - must drop */ logmsg(LOG_INFO, "Unknown hop limit from %s on %s\n", msgbuf, pi->pi_name); return; } hoplimit = *(uint_t *)opt; opt = find_ancillary(&msg, IPV6_RTHDR); if (opt != NULL) { /* Can't allow routing headers in ND messages */ logmsg(LOG_INFO, "ND message with routing header " "from %s on %s\n", msgbuf, pi->pi_name); return; } switch (icmp->icmp6_type) { case ND_ROUTER_SOLICIT: if (!pi->pi_AdvSendAdvertisements) return; if (pi->pi_flags & IFF_NORTEXCH) { if (debug & D_PKTIN) { logmsg(LOG_DEBUG, "Ignore received RS packet " "on %s (no route exchange on interface)\n", pi->pi_name); } return; } /* * Assumes that the kernel has verified the AH (if present) * and the ICMP checksum. */ if (hoplimit != IPV6_MAX_HOPS) { logmsg(LOG_DEBUG, "RS hop limit: %d from %s on %s\n", hoplimit, msgbuf, pi->pi_name); return; } if (icmp->icmp6_code != 0) { logmsg(LOG_INFO, "RS code: %d from %s on %s\n", icmp->icmp6_code, msgbuf, pi->pi_name); return; } if (len < sizeof (struct nd_router_solicit)) { logmsg(LOG_INFO, "RS too short: %d bytes " "from %s on %s\n", len, msgbuf, pi->pi_name); return; } rs = (struct nd_router_solicit *)icmp; if (len > sizeof (struct nd_router_solicit)) { if (!verify_opt_len((struct nd_opt_hdr *)&rs[1], len - sizeof (struct nd_router_solicit), pi, &from)) return; } if (debug & D_PKTIN) { print_route_sol("Received valid solicit from ", pi, rs, len, &from); } incoming_rs(pi, rs, len, &from); break; case ND_ROUTER_ADVERT: if (IN6_IS_ADDR_UNSPECIFIED(&from.sin6_addr)) { /* * Router advt. must have address! * Logging the news and returning. */ logmsg(LOG_DEBUG, "Router's address unspecified in advertisement\n"); return; } if (pi->pi_flags & IFF_NORTEXCH) { if (debug & D_PKTIN) { logmsg(LOG_DEBUG, "Ignore received RA packet " "on %s (no route exchange on interface)\n", pi->pi_name); } return; } /* * Assumes that the kernel has verified the AH (if present) * and the ICMP checksum. */ if (!IN6_IS_ADDR_LINKLOCAL(&from.sin6_addr)) { logmsg(LOG_DEBUG, "RA from %s - not link local on %s\n", msgbuf, pi->pi_name); return; } if (hoplimit != IPV6_MAX_HOPS) { logmsg(LOG_INFO, "RA hop limit: %d from %s on %s\n", hoplimit, msgbuf, pi->pi_name); return; } if (icmp->icmp6_code != 0) { logmsg(LOG_INFO, "RA code: %d from %s on %s\n", icmp->icmp6_code, msgbuf, pi->pi_name); return; } if (len < sizeof (struct nd_router_advert)) { logmsg(LOG_INFO, "RA too short: %d bytes " "from %s on %s\n", len, msgbuf, pi->pi_name); return; } ra = (struct nd_router_advert *)icmp; if (len > sizeof (struct nd_router_advert)) { if (!verify_opt_len((struct nd_opt_hdr *)&ra[1], len - sizeof (struct nd_router_advert), pi, &from)) return; } if (debug & D_PKTIN) { print_route_adv("Received valid advert from ", pi, ra, len, &from); } if (pi->pi_AdvSendAdvertisements) verify_ra_consistency(pi, ra, len, &from); else incoming_ra(pi, ra, len, &from, _B_FALSE); break; } } /* * Process a received router solicitation. * Check for source link-layer address option and check if it * is time to advertise. */ static void incoming_rs(struct phyint *pi, struct nd_router_solicit *rs, int len, struct sockaddr_in6 *from) { struct nd_opt_hdr *opt; int optlen; /* Process any options */ len -= sizeof (struct nd_router_solicit); opt = (struct nd_opt_hdr *)&rs[1]; while (len >= sizeof (struct nd_opt_hdr)) { optlen = opt->nd_opt_len * 8; switch (opt->nd_opt_type) { case ND_OPT_SOURCE_LINKADDR: incoming_lla_opt(pi, (uchar_t *)opt, from, NDF_ISROUTER_OFF); break; default: break; } opt = (struct nd_opt_hdr *)((char *)opt + optlen); len -= optlen; } /* Simple algorithm: treat unicast and multicast RSs the same */ check_to_advertise(pi, RECEIVED_SOLICIT); } /* * Function that sends commands to dhcpagent daemon. */ int dhcp_op(struct phyint *pi, int type) { dhcp_ipc_request_t *request; dhcp_ipc_reply_t *reply = NULL; int error; request = dhcp_ipc_alloc_request(type | DHCP_V6, pi->pi_name, NULL, 0, DHCP_TYPE_NONE); if (request == NULL) { logmsg(LOG_ERR, "dhcp_op: out of memory\n"); /* make sure we try again next time there's a chance */ if (type != DHCP_RELEASE) { pi->pi_ra_flags &= ~ND_RA_FLAG_MANAGED & ~ND_RA_FLAG_OTHER; } return (DHCP_IPC_E_MEMORY); } error = dhcp_ipc_make_request(request, &reply, 0); free(request); if (error != 0) { logmsg(LOG_ERR, "could not send request to dhcpagent: " "%s: %s\n", pi->pi_name, dhcp_ipc_strerror(error)); return (error); } error = reply->return_code; free(reply); return (error); } /* * Start up DHCPv6 on a given physical interface. Does not wait for * a message to be returned from the daemon. */ void start_dhcp(struct phyint *pi) { int error; int type; if (dhcp_start_agent(DHCP_IPC_MAX_WAIT) == -1) { logmsg(LOG_ERR, "unable to start %s\n", DHCP_AGENT_PATH); /* make sure we try again next time there's a chance */ pi->pi_ra_flags &= ~ND_RA_FLAG_MANAGED & ~ND_RA_FLAG_OTHER; return; } else if (pi->pi_ra_flags & ND_RA_FLAG_MANAGED) type = DHCP_START; else type = DHCP_INFORM; error = dhcp_op(pi, type); /* * Timeout is considered to be "success" because we don't wait for DHCP * to do its exchange. */ if (error != DHCP_IPC_SUCCESS && error != DHCP_IPC_E_RUNNING && error != DHCP_IPC_E_TIMEOUT) { logmsg(LOG_ERR, "Error in dhcpagent: %s: %s\n", pi->pi_name, dhcp_ipc_strerror(error)); } } /* * Release the acquired DHCPv6 lease on a given physical interface. * Does not wait for a message to be returned from the daemon. */ void release_dhcp(struct phyint *pi) { int error; int type; type = DHCP_RELEASE; retry: error = dhcp_op(pi, type); if (error != DHCP_IPC_SUCCESS && error != DHCP_IPC_E_RUNNING && error != DHCP_IPC_E_TIMEOUT) { if (type == DHCP_RELEASE && error == DHCP_IPC_E_OUTSTATE) { /* * Drop the dhcp control if we cannot release it. */ type = DHCP_DROP; goto retry; } logmsg(LOG_ERR, "Error in dhcpagent: %s: %s\n", pi->pi_name, dhcp_ipc_strerror(error)); } } /* * Globals to check if we're seeing unusual hop counts in Router * Advertisements (RAs). We record the hopcounts in the kernel using * SIOCSLIFLNKINFO, but the kernel ignores these when actually setting IPv6 * hop counts for packets. * * RFC 3756 does mention the possibility of an adversary throttling down * hopcounts using unsolicited RAs. These variables can be tuned with 'mdb -p' * to reduce/increase our logging threshholds. */ /* Really a boolean... if set, also log the offending sending address. */ int bad_hopcount_record_addr = 0; /* Anything less triggers a warning. Set to 0 to disable. */ int bad_hopcount_threshhold = 16; /* Number of packets received below the threshhold. */ uint64_t bad_hopcount_packets; /* * Process a received router advertisement. * Called both when packets arrive as well as when we send RAs. * In the latter case 'loopback' is set. */ void incoming_ra(struct phyint *pi, struct nd_router_advert *ra, int len, struct sockaddr_in6 *from, boolean_t loopback) { struct nd_opt_hdr *opt; int optlen; struct lifreq lifr; boolean_t set_needed = _B_FALSE; struct router *dr; uint16_t router_lifetime; uint_t reachable, retrans; boolean_t reachable_time_changed = _B_FALSE; boolean_t slla_opt_present = _B_FALSE; if (no_loopback && loopback) return; bzero(&lifr, sizeof (lifr)); (void) strlcpy(lifr.lifr_name, pi->pi_name, sizeof (lifr.lifr_name)); if (ra->nd_ra_curhoplimit != CURHOP_UNSPECIFIED && ra->nd_ra_curhoplimit != pi->pi_CurHopLimit) { pi->pi_CurHopLimit = ra->nd_ra_curhoplimit; lifr.lifr_ifinfo.lir_maxhops = pi->pi_CurHopLimit; set_needed = _B_TRUE; if (pi->pi_CurHopLimit < bad_hopcount_threshhold) { char abuf[INET6_ADDRSTRLEN]; bad_hopcount_packets++; logmsg(LOG_ALERT, "Low hopcount %d received on %s%s%s\n", pi->pi_CurHopLimit, pi->pi_name, bad_hopcount_record_addr ? " from " : "", bad_hopcount_record_addr ? inet_ntop(AF_INET6, &from->sin6_addr, abuf, INET6_ADDRSTRLEN) : ""); } } reachable = ntohl(ra->nd_ra_reachable); if (reachable != 0 && reachable != pi->pi_BaseReachableTime) { pi->pi_BaseReachableTime = reachable; reachable_time_changed = _B_TRUE; } if (pi->pi_reach_time_since_random < MIN_REACH_RANDOM_INTERVAL || reachable_time_changed) { phyint_reach_random(pi, _B_FALSE); set_needed = _B_TRUE; } lifr.lifr_ifinfo.lir_reachtime = pi->pi_ReachableTime; retrans = ntohl(ra->nd_ra_retransmit); if (retrans != 0 && pi->pi_RetransTimer != retrans) { pi->pi_RetransTimer = retrans; lifr.lifr_ifinfo.lir_reachretrans = pi->pi_RetransTimer; set_needed = _B_TRUE; } if (set_needed) { if (ioctl(pi->pi_sock, SIOCSLIFLNKINFO, (char *)&lifr) < 0) { logperror_pi(pi, "incoming_ra: SIOCSLIFLNKINFO"); return; } } /* * If the "managed" flag is set, then just assume that the "other" flag * is set as well. It's not legal to get addresses alone without * getting other data. */ if (ra->nd_ra_flags_reserved & ND_RA_FLAG_MANAGED) ra->nd_ra_flags_reserved |= ND_RA_FLAG_OTHER; /* * If either the "managed" or "other" bits have turned on, then it's * now time to invoke DHCP. If only the "other" bit is set, then don't * get addresses via DHCP; only "other" data. If "managed" is set, * then we must always get both addresses and "other" data. */ if (pi->pi_autoconf && pi->pi_stateful && (ra->nd_ra_flags_reserved & ~pi->pi_ra_flags & (ND_RA_FLAG_MANAGED | ND_RA_FLAG_OTHER))) { if (debug & D_DHCP) { logmsg(LOG_DEBUG, "incoming_ra: trigger dhcp %s on %s\n", (ra->nd_ra_flags_reserved & ~pi->pi_ra_flags & ND_RA_FLAG_MANAGED) ? "MANAGED" : "OTHER", pi->pi_name); } pi->pi_ra_flags |= ra->nd_ra_flags_reserved; start_dhcp(pi); } /* Skip default router code if sent from ourselves */ if (!loopback) { /* Find and update or add default router in list */ dr = router_lookup(pi, from->sin6_addr); router_lifetime = ntohs(ra->nd_ra_router_lifetime); if (dr == NULL) { if (router_lifetime != 0) { dr = router_create(pi, from->sin6_addr, MILLISEC * router_lifetime); timer_schedule(dr->dr_lifetime); } } else { dr->dr_lifetime = MILLISEC * router_lifetime; if (dr->dr_lifetime != 0) timer_schedule(dr->dr_lifetime); if ((dr->dr_lifetime != 0 && !dr->dr_inkernel) || (dr->dr_lifetime == 0 && dr->dr_inkernel)) router_update_k(dr); } } /* Process any options */ len -= sizeof (struct nd_router_advert); opt = (struct nd_opt_hdr *)&ra[1]; while (len >= sizeof (struct nd_opt_hdr)) { optlen = opt->nd_opt_len * 8; switch (opt->nd_opt_type) { case ND_OPT_PREFIX_INFORMATION: incoming_prefix_opt(pi, (uchar_t *)opt, from, loopback); break; case ND_OPT_MTU: incoming_mtu_opt(pi, (uchar_t *)opt, from); break; case ND_OPT_SOURCE_LINKADDR: /* skip lla option if sent from ourselves! */ if (!loopback) { incoming_lla_opt(pi, (uchar_t *)opt, from, NDF_ISROUTER_ON); slla_opt_present = _B_TRUE; } break; default: break; } opt = (struct nd_opt_hdr *)((char *)opt + optlen); len -= optlen; } if (!loopback && !slla_opt_present) update_ra_flag(pi, from, NDF_ISROUTER_ON); /* Stop sending solicitations */ check_to_solicit(pi, SOLICIT_DONE); } /* * Process a received prefix option. * Unless addrconf is turned off we process both the addrconf and the * onlink aspects of the prefix option. * * Note that when a flag (onlink or auto) is turned off we do nothing - * the prefix will time out. */ static void incoming_prefix_opt(struct phyint *pi, uchar_t *opt, struct sockaddr_in6 *from, boolean_t loopback) { struct nd_opt_prefix_info *po = (struct nd_opt_prefix_info *)opt; boolean_t good_prefix = _B_TRUE; if (8 * po->nd_opt_pi_len != sizeof (*po)) { char abuf[INET6_ADDRSTRLEN]; (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, abuf, sizeof (abuf)); logmsg(LOG_INFO, "prefix option from %s on %s wrong size " "(%d bytes)\n", abuf, pi->pi_name, 8 * (int)po->nd_opt_pi_len); return; } if (IN6_IS_ADDR_LINKLOCAL(&po->nd_opt_pi_prefix)) { char abuf[INET6_ADDRSTRLEN]; (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, abuf, sizeof (abuf)); logmsg(LOG_INFO, "RA from %s on %s contains link-local prefix " "- ignored\n", abuf, pi->pi_name); return; } if ((po->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_AUTO) && pi->pi_stateless && pi->pi_autoconf) { good_prefix = incoming_prefix_addrconf(pi, opt, from, loopback); } if ((po->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_ONLINK) && good_prefix) { incoming_prefix_onlink(pi, opt); } if (pi->pi_stateful && pi->pi_autoconf) incoming_prefix_stateful(pi, opt); } /* * Process prefix options with the onlink flag set. * * If there are no routers ndpd will add an onlink * default route which will allow communication * between neighbors. * * This function needs to loop to find the same prefix multiple times * as if a failover happened earlier, the addresses belonging to * a different interface may be found here on this interface. */ static void incoming_prefix_onlink(struct phyint *pi, uchar_t *opt) { struct nd_opt_prefix_info *po = (struct nd_opt_prefix_info *)opt; int plen; struct prefix *pr; uint32_t validtime; /* Without 2 hour rule */ boolean_t found_one = _B_FALSE; plen = po->nd_opt_pi_prefix_len; for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) { if (pr->pr_prefix_len == plen && prefix_equal(po->nd_opt_pi_prefix, pr->pr_prefix, plen)) { /* Exclude static prefixes */ if (pr->pr_state & PR_STATIC) continue; found_one = _B_TRUE; incoming_prefix_onlink_process(pr, opt); } } validtime = ntohl(po->nd_opt_pi_valid_time); /* * If we have found a matching prefix already or validtime * is zero, we have nothing to do. */ if (validtime == 0 || found_one) return; pr = prefix_create(pi, po->nd_opt_pi_prefix, plen, 0); if (pr == NULL) return; incoming_prefix_onlink_process(pr, opt); } void incoming_prefix_onlink_process(struct prefix *pr, uchar_t *opt) { struct nd_opt_prefix_info *po = (struct nd_opt_prefix_info *)opt; uint32_t validtime; /* Without 2 hour rule */ char abuf[INET6_ADDRSTRLEN]; validtime = ntohl(po->nd_opt_pi_valid_time); if (validtime != 0) pr->pr_state |= PR_ONLINK; else pr->pr_state &= ~PR_ONLINK; /* * Convert from seconds to milliseconds avoiding overflow. * If the lifetime in the packet is e.g. PREFIX_INFINITY - 1 * (4 billion seconds - about 130 years) we will in fact time * out the prefix after 4 billion milliseconds - 46 days). * Thus the longest lifetime (apart from infinity) is 46 days. * Note that this ensures that PREFIX_INFINITY still means "forever". */ if (pr->pr_flags & IFF_TEMPORARY) { pr->pr_OnLinkLifetime = pr->pr_ValidLifetime; } else { if (validtime >= PREFIX_INFINITY / MILLISEC) pr->pr_OnLinkLifetime = PREFIX_INFINITY - 1; else pr->pr_OnLinkLifetime = validtime * MILLISEC; } pr->pr_OnLinkFlag = _B_TRUE; if (debug & (D_PREFIX|D_TMP)) { logmsg(LOG_DEBUG, "incoming_prefix_onlink_process(%s, %s/%u) " "onlink %u state 0x%x, kstate 0x%x\n", pr->pr_name, inet_ntop(AF_INET6, (void *)&pr->pr_prefix, abuf, sizeof (abuf)), pr->pr_prefix_len, pr->pr_OnLinkLifetime, pr->pr_state, pr->pr_kernel_state); } if (pr->pr_kernel_state != pr->pr_state) { prefix_update_k(pr); } if (pr->pr_OnLinkLifetime != 0) timer_schedule(pr->pr_OnLinkLifetime); } /* * Process all prefix options by locating the DHCPv6-configured interfaces, and * applying the netmasks as needed. */ static void incoming_prefix_stateful(struct phyint *pi, uchar_t *opt) { struct nd_opt_prefix_info *po = (struct nd_opt_prefix_info *)opt; struct prefix *pr; boolean_t foundpref; char abuf[INET6_ADDRSTRLEN]; /* Make sure it's a valid prefix. */ if (ntohl(po->nd_opt_pi_valid_time) == 0) { if (debug & D_DHCP) logmsg(LOG_DEBUG, "incoming_prefix_stateful: ignoring " "prefix with no valid time\n"); return; } if (debug & D_DHCP) logmsg(LOG_DEBUG, "incoming_prefix_stateful(%s, %s/%d)\n", pi->pi_name, inet_ntop(AF_INET6, (void *)&po->nd_opt_pi_prefix, abuf, sizeof (abuf)), po->nd_opt_pi_prefix_len); foundpref = _B_FALSE; for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) { if (prefix_equal(po->nd_opt_pi_prefix, pr->pr_prefix, po->nd_opt_pi_prefix_len)) { if ((pr->pr_flags & IFF_DHCPRUNNING) && pr->pr_prefix_len != po->nd_opt_pi_prefix_len) { pr->pr_prefix_len = po->nd_opt_pi_prefix_len; if (pr->pr_flags & IFF_UP) { if (debug & D_DHCP) logmsg(LOG_DEBUG, "incoming_prefix_stateful:" " set mask on DHCP %s\n", pr->pr_name); prefix_update_dhcp(pr); } } if (pr->pr_prefix_len == po->nd_opt_pi_prefix_len && (!(pr->pr_state & PR_STATIC) || (pr->pr_flags & IFF_DHCPRUNNING))) foundpref = _B_TRUE; } } /* * If there's no matching DHCPv6 prefix present, then create an empty * one so that we'll be able to configure it later. */ if (!foundpref) { pr = prefix_create(pi, po->nd_opt_pi_prefix, po->nd_opt_pi_prefix_len, IFF_DHCPRUNNING); if (pr != NULL) { pr->pr_state = PR_STATIC; if (debug & D_DHCP) logmsg(LOG_DEBUG, "incoming_prefix_stateful: created dummy " "prefix for later\n"); } } } /* * Process prefix options with the autonomous flag set. * Returns false if this prefix results in a bad address (duplicate) * This function needs to loop to find the same prefix multiple times * as if a failover happened earlier, the addresses belonging to * a different interface may be found here on this interface. */ static boolean_t incoming_prefix_addrconf(struct phyint *pi, uchar_t *opt, struct sockaddr_in6 *from, boolean_t loopback) { struct nd_opt_prefix_info *po = (struct nd_opt_prefix_info *)opt; int plen; struct prefix *pr; uint32_t validtime, preftime; /* In seconds */ char abuf[INET6_ADDRSTRLEN]; char pbuf[INET6_ADDRSTRLEN]; boolean_t found_pub = _B_FALSE; boolean_t found_tmp = _B_FALSE; boolean_t ret; validtime = ntohl(po->nd_opt_pi_valid_time); preftime = ntohl(po->nd_opt_pi_preferred_time); plen = po->nd_opt_pi_prefix_len; /* Sanity checks */ if (validtime < preftime) { (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, abuf, sizeof (abuf)); (void) inet_ntop(AF_INET6, (void *)&po->nd_opt_pi_prefix, pbuf, sizeof (pbuf)); logmsg(LOG_WARNING, "prefix option %s/%u from %s on %s: " "valid %u < pref %u ignored\n", pbuf, plen, abuf, pi->pi_name, validtime, preftime); return (_B_FALSE); } for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) { if (pr->pr_prefix_len == plen && prefix_equal(po->nd_opt_pi_prefix, pr->pr_prefix, plen)) { /* Exclude static prefixes and DHCP */ if ((pr->pr_state & PR_STATIC) || (pr->pr_flags & IFF_DHCPRUNNING)) continue; if (pr->pr_flags & IFF_TEMPORARY) { /* * If this address is deprecated and its token * doesn't match the current tmp token, we want * to create a new address with the current * token. So don't count this addr as a match. */ if (!((pr->pr_flags & IFF_DEPRECATED) && !token_equal(pi->pi_tmp_token, pr->pr_address, TMP_TOKEN_BITS))) found_tmp = _B_TRUE; } else { found_pub = _B_TRUE; } (void) incoming_prefix_addrconf_process(pi, pr, opt, from, loopback, _B_FALSE); } } /* * If we have found a matching prefix (for public and, if temp addrs * are enabled, for temporary) already or validtime is zero, we have * nothing to do. */ if (validtime == 0 || (found_pub && (!pi->pi_TmpAddrsEnabled || found_tmp))) return (_B_TRUE); if (!found_pub) { pr = prefix_create(pi, po->nd_opt_pi_prefix, plen, 0); if (pr == NULL) return (_B_TRUE); ret = incoming_prefix_addrconf_process(pi, pr, opt, from, loopback, _B_TRUE); } /* * if processing of the public address failed, * don't bother with the temporary address. */ if (ret == _B_FALSE) return (_B_FALSE); if (pi->pi_TmpAddrsEnabled && !found_tmp) { pr = prefix_create(pi, po->nd_opt_pi_prefix, plen, IFF_TEMPORARY); if (pr == NULL) return (_B_TRUE); ret = incoming_prefix_addrconf_process(pi, pr, opt, from, loopback, _B_TRUE); } return (ret); } boolean_t incoming_prefix_addrconf_process(struct phyint *pi, struct prefix *pr, uchar_t *opt, struct sockaddr_in6 *from, boolean_t loopback, boolean_t new_prefix) { struct nd_opt_prefix_info *po = (struct nd_opt_prefix_info *)opt; char abuf[INET6_ADDRSTRLEN]; char pbuf[INET6_ADDRSTRLEN]; uint32_t validtime, preftime; /* In seconds */ uint32_t recorded_validtime; /* In seconds */ int plen; struct prefix *other_pr; validtime = ntohl(po->nd_opt_pi_valid_time); preftime = ntohl(po->nd_opt_pi_preferred_time); plen = po->nd_opt_pi_prefix_len; if (!new_prefix) { /* * Check 2 hour rule on valid lifetime. * Follows: RFC 2462 * If we advertised this prefix ourselves we skip * these checks. They are also skipped if we did not * previously do addrconf on this prefix. */ recorded_validtime = pr->pr_ValidLifetime / MILLISEC; if (loopback || !(pr->pr_state & PR_AUTO) || validtime >= MIN_VALID_LIFETIME || /* LINTED - statement has no consequent */ validtime >= recorded_validtime) { /* OK */ } else if (recorded_validtime < MIN_VALID_LIFETIME && validtime < recorded_validtime) { /* Ignore the prefix */ (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, abuf, sizeof (abuf)); (void) inet_ntop(AF_INET6, (void *)&po->nd_opt_pi_prefix, pbuf, sizeof (pbuf)); logmsg(LOG_INFO, "prefix option %s/%u from %s on %s: " "too short valid lifetime %u stored %u " "- ignored\n", pbuf, plen, abuf, pi->pi_name, validtime, recorded_validtime); return (_B_TRUE); } else { /* * If the router clock runs slower than the * host by 1 second over 2 hours then this * test will set the lifetime back to 2 hours * once i.e. a lifetime decrementing in * realtime might cause the prefix to live an * extra 2 hours on the host. */ (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, abuf, sizeof (abuf)); (void) inet_ntop(AF_INET6, (void *)&po->nd_opt_pi_prefix, pbuf, sizeof (pbuf)); logmsg(LOG_INFO, "prefix option %s/%u from %s on %s: " "valid time %u stored %u rounded up " "to %u\n", pbuf, plen, abuf, pi->pi_name, validtime, recorded_validtime, MIN_VALID_LIFETIME); validtime = MIN_VALID_LIFETIME; } } /* * For RFC3041 addresses, need to take token lifetime * into account, too. */ if (pr->pr_flags & IFF_TEMPORARY) { uint_t cur_tpreftime = pi->pi_TmpPreferredLifetime - pi->pi_TmpDesyncFactor; if (new_prefix) { validtime = MIN(validtime, pi->pi_TmpValidLifetime); preftime = MIN(preftime, cur_tpreftime); } else { uint_t cur_vexp, cur_pexp, curtime; curtime = getcurrenttime() / MILLISEC; cur_vexp = pr->pr_CreateTime + pi->pi_TmpValidLifetime; cur_pexp = pr->pr_CreateTime + cur_tpreftime; if (curtime > cur_vexp) validtime = 0; else if ((curtime + validtime) > cur_vexp) validtime = cur_vexp - curtime; /* * If this is an existing address which was deprecated * because of a bad token, we don't want to update its * preferred lifetime! */ if ((pr->pr_PreferredLifetime == 0) && !token_equal(pr->pr_address, pi->pi_tmp_token, TMP_TOKEN_BITS)) preftime = 0; else if (curtime > cur_pexp) preftime = 0; else if ((curtime + preftime) > cur_pexp) preftime = cur_pexp - curtime; } if ((preftime != 0) && (preftime <= pi->pi_TmpRegenAdvance)) { (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, abuf, sizeof (abuf)); (void) inet_ntop(AF_INET6, (void *)&po->nd_opt_pi_prefix, pbuf, sizeof (pbuf)); logmsg(LOG_WARNING, "prefix opt %s/%u from %s on %s: " "preferred lifetime(%d) <= TmpRegenAdvance(%d)\n", pbuf, plen, abuf, pi->pi_name, preftime, pi->pi_TmpRegenAdvance); if (new_prefix) { prefix_update_ipadm_addrobj(pr, _B_FALSE); prefix_delete(pr); } return (_B_TRUE); } } if (debug & D_TMP) logmsg(LOG_DEBUG, "calculated lifetimes(%s, 0x%llx): v %d, " "p %d\n", pr->pr_name, pr->pr_flags, validtime, preftime); if (!(pr->pr_state & PR_AUTO)) { int i, tokenlen; in6_addr_t *token; /* * Form a new local address if the lengths match. */ if (pr->pr_flags & IFF_TEMPORARY) { if (IN6_IS_ADDR_UNSPECIFIED(&pi->pi_tmp_token)) { if (!tmptoken_create(pi)) { prefix_delete(pr); return (_B_TRUE); } } tokenlen = TMP_TOKEN_BITS; token = &pi->pi_tmp_token; } else { tokenlen = pi->pi_token_length; token = &pi->pi_token; } if (pr->pr_prefix_len + tokenlen != IPV6_ABITS) { (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, abuf, sizeof (abuf)); (void) inet_ntop(AF_INET6, (void *)&po->nd_opt_pi_prefix, pbuf, sizeof (pbuf)); logmsg(LOG_INFO, "prefix option %s/%u from %s on %s: " "mismatched length %d token length %d\n", pbuf, plen, abuf, pi->pi_name, pr->pr_prefix_len, tokenlen); return (_B_TRUE); } for (i = 0; i < 16; i++) { /* * prefix_create ensures that pr_prefix has all-zero * bits after prefixlen. */ pr->pr_address.s6_addr[i] = pr->pr_prefix.s6_addr[i] | token->s6_addr[i]; } /* * Check if any other physical interface has the same * address configured already */ if ((other_pr = prefix_lookup_addr_match(pr)) != NULL) { /* * Delete this prefix structure as kernel * does not allow duplicated addresses */ logmsg(LOG_ERR, "incoming_prefix_addrconf_process: " "Duplicate prefix %s received on interface %s\n", inet_ntop(AF_INET6, &po->nd_opt_pi_prefix, abuf, sizeof (abuf)), pi->pi_name); logmsg(LOG_ERR, "incoming_prefix_addrconf_process: " "Prefix already exists in interface %s\n", other_pr->pr_physical->pi_name); if (new_prefix) { prefix_update_ipadm_addrobj(pr, _B_FALSE); prefix_delete(pr); return (_B_FALSE); } /* Ignore for addrconf purposes */ validtime = preftime = 0; } if ((pr->pr_flags & IFF_TEMPORARY) && new_prefix) { pr->pr_CreateTime = getcurrenttime() / MILLISEC; if (debug & D_TMP) logmsg(LOG_DEBUG, "created tmp addr(%s v %d p %d)\n", pr->pr_name, validtime, preftime); } } if (validtime != 0) pr->pr_state |= PR_AUTO; else pr->pr_state &= ~(PR_AUTO|PR_DEPRECATED); if (preftime != 0 || !(pr->pr_state & PR_AUTO)) pr->pr_state &= ~PR_DEPRECATED; else pr->pr_state |= PR_DEPRECATED; /* * Convert from seconds to milliseconds avoiding overflow. * If the lifetime in the packet is e.g. PREFIX_INFINITY - 1 * (4 billion seconds - about 130 years) we will in fact time * out the prefix after 4 billion milliseconds - 46 days). * Thus the longest lifetime (apart from infinity) is 46 days. * Note that this ensures that PREFIX_INFINITY still means "forever". */ if (validtime >= PREFIX_INFINITY / MILLISEC) pr->pr_ValidLifetime = PREFIX_INFINITY - 1; else pr->pr_ValidLifetime = validtime * MILLISEC; if (preftime >= PREFIX_INFINITY / MILLISEC) pr->pr_PreferredLifetime = PREFIX_INFINITY - 1; else pr->pr_PreferredLifetime = preftime * MILLISEC; pr->pr_AutonomousFlag = _B_TRUE; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "incoming_prefix_addrconf_process(%s, %s/%u) " "valid %u pref %u\n", pr->pr_physical->pi_name, inet_ntop(AF_INET6, (void *)&pr->pr_prefix, abuf, sizeof (abuf)), pr->pr_prefix_len, pr->pr_ValidLifetime, pr->pr_PreferredLifetime); } if (pr->pr_state & PR_AUTO) { /* Take the min of the two timeouts by calling it twice */ if (pr->pr_ValidLifetime != 0) timer_schedule(pr->pr_ValidLifetime); if (pr->pr_PreferredLifetime != 0) timer_schedule(pr->pr_PreferredLifetime); } if (pr->pr_kernel_state != pr->pr_state) { /* Log a message when an addrconf prefix goes away */ if ((pr->pr_kernel_state & PR_AUTO) && !(pr->pr_state & PR_AUTO)) { char abuf[INET6_ADDRSTRLEN]; logmsg(LOG_WARNING, "Address removed due to zero " "valid lifetime %s\n", inet_ntop(AF_INET6, (void *)&pr->pr_address, abuf, sizeof (abuf))); } prefix_update_k(pr); } return (_B_TRUE); } /* * Process an MTU option received in a router advertisement. */ static void incoming_mtu_opt(struct phyint *pi, uchar_t *opt, struct sockaddr_in6 *from) { struct nd_opt_mtu *mo = (struct nd_opt_mtu *)opt; struct lifreq lifr; uint32_t mtu; if (8 * mo->nd_opt_mtu_len != sizeof (*mo)) { char abuf[INET6_ADDRSTRLEN]; (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, abuf, sizeof (abuf)); logmsg(LOG_INFO, "mtu option from %s on %s wrong size " "(%d bytes)\n", abuf, pi->pi_name, 8 * (int)mo->nd_opt_mtu_len); return; } mtu = ntohl(mo->nd_opt_mtu_mtu); if (pi->pi_LinkMTU == mtu) return; /* No change */ if (mtu > pi->pi_mtu) { /* Can't exceed physical MTU */ char abuf[INET6_ADDRSTRLEN]; (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, abuf, sizeof (abuf)); logmsg(LOG_INFO, "mtu option from %s on %s too large " "MTU %d - %d\n", abuf, pi->pi_name, mtu, pi->pi_mtu); return; } if (mtu < IPV6_MIN_MTU) { char abuf[INET6_ADDRSTRLEN]; (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, abuf, sizeof (abuf)); logmsg(LOG_INFO, "mtu option from %s on %s too small " "MTU (%d)\n", abuf, pi->pi_name, mtu); return; } pi->pi_LinkMTU = mtu; bzero(&lifr, sizeof (lifr)); (void) strlcpy(lifr.lifr_name, pi->pi_name, sizeof (lifr.lifr_name)); lifr.lifr_ifinfo.lir_maxmtu = pi->pi_LinkMTU; if (ioctl(pi->pi_sock, SIOCSLIFLNKINFO, (char *)&lifr) < 0) { logperror_pi(pi, "incoming_mtu_opt: SIOCSLIFLNKINFO"); return; } } /* * Process a source link-layer address option received in a router * advertisement or solicitation. */ static void incoming_lla_opt(struct phyint *pi, uchar_t *opt, struct sockaddr_in6 *from, int isrouter) { struct nd_opt_lla *lo = (struct nd_opt_lla *)opt; struct lifreq lifr; struct sockaddr_in6 *sin6; int max_content_len; /* * Get our link-layer address length. We may not have one, in which * case we can just bail. */ if (phyint_get_lla(pi, &lifr) != 0) return; /* * Can't remove padding since it is link type specific. * However, we check against the length of our link-layer address. * Note: assumes that all links have a fixed length address. */ max_content_len = lo->nd_opt_lla_len * 8 - sizeof (struct nd_opt_hdr); if (max_content_len < lifr.lifr_nd.lnr_hdw_len || (max_content_len >= 8 && max_content_len - 7 > lifr.lifr_nd.lnr_hdw_len)) { char abuf[INET6_ADDRSTRLEN]; (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, abuf, sizeof (abuf)); logmsg(LOG_INFO, "lla option from %s on %s too long with bad " "physaddr length (%d vs. %d bytes)\n", abuf, pi->pi_name, max_content_len, lifr.lifr_nd.lnr_hdw_len); return; } bcopy(lo->nd_opt_lla_hdw_addr, lifr.lifr_nd.lnr_hdw_addr, lifr.lifr_nd.lnr_hdw_len); sin6 = (struct sockaddr_in6 *)&lifr.lifr_nd.lnr_addr; bzero(sin6, sizeof (struct sockaddr_in6)); sin6->sin6_family = AF_INET6; sin6->sin6_addr = from->sin6_addr; /* * Set IsRouter flag if RA; clear if RS. */ lifr.lifr_nd.lnr_state_create = ND_STALE; lifr.lifr_nd.lnr_state_same_lla = ND_UNCHANGED; lifr.lifr_nd.lnr_state_diff_lla = ND_STALE; lifr.lifr_nd.lnr_flags = isrouter; (void) strlcpy(lifr.lifr_name, pi->pi_name, sizeof (lifr.lifr_name)); if (ioctl(pi->pi_sock, SIOCLIFSETND, (char *)&lifr) < 0) { logperror_pi(pi, "incoming_lla_opt: SIOCLIFSETND"); return; } } /* * Verify the content of the received router advertisement against our * own configuration as specified in RFC 2461. */ static void verify_ra_consistency(struct phyint *pi, struct nd_router_advert *ra, int len, struct sockaddr_in6 *from) { char frombuf[INET6_ADDRSTRLEN]; struct nd_opt_hdr *opt; int optlen; uint_t reachable, retrans; boolean_t pktflag, myflag; (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, frombuf, sizeof (frombuf)); if (ra->nd_ra_curhoplimit != 0 && pi->pi_AdvCurHopLimit != 0 && ra->nd_ra_curhoplimit != pi->pi_AdvCurHopLimit) { logmsg(LOG_INFO, "RA from %s on %s inconsistent cur hop " "limit:\n\treceived %d configuration %d\n", frombuf, pi->pi_name, ra->nd_ra_curhoplimit, pi->pi_AdvCurHopLimit); } reachable = ntohl(ra->nd_ra_reachable); if (reachable != 0 && pi->pi_AdvReachableTime != 0 && reachable != pi->pi_AdvReachableTime) { logmsg(LOG_INFO, "RA from %s on %s inconsistent reachable " "time:\n\treceived %d configuration %d\n", frombuf, pi->pi_name, reachable, pi->pi_AdvReachableTime); } retrans = ntohl(ra->nd_ra_retransmit); if (retrans != 0 && pi->pi_AdvRetransTimer != 0 && retrans != pi->pi_AdvRetransTimer) { logmsg(LOG_INFO, "RA from %s on %s inconsistent retransmit " "timer:\n\treceived %d configuration %d\n", frombuf, pi->pi_name, retrans, pi->pi_AdvRetransTimer); } pktflag = ((ra->nd_ra_flags_reserved & ND_RA_FLAG_MANAGED) != 0); myflag = (pi->pi_AdvManagedFlag != 0); if (pktflag != myflag) { logmsg(LOG_INFO, "RA from %s on %s inconsistent managed " "flag:\n\treceived %s configuration %s\n", frombuf, pi->pi_name, (pktflag ? "ON" : "OFF"), (myflag ? "ON" : "OFF")); } pktflag = ((ra->nd_ra_flags_reserved & ND_RA_FLAG_OTHER) != 0); myflag = (pi->pi_AdvOtherConfigFlag != 0); if (pktflag != myflag) { logmsg(LOG_INFO, "RA from %s on %s inconsistent other config " "flag:\n\treceived %s configuration %s\n", frombuf, pi->pi_name, (pktflag ? "ON" : "OFF"), (myflag ? "ON" : "OFF")); } /* Process any options */ len -= sizeof (struct nd_router_advert); opt = (struct nd_opt_hdr *)&ra[1]; while (len >= sizeof (struct nd_opt_hdr)) { optlen = opt->nd_opt_len * 8; switch (opt->nd_opt_type) { case ND_OPT_PREFIX_INFORMATION: verify_prefix_opt(pi, (uchar_t *)opt, frombuf); break; case ND_OPT_MTU: verify_mtu_opt(pi, (uchar_t *)opt, frombuf); break; default: break; } opt = (struct nd_opt_hdr *)((char *)opt + optlen); len -= optlen; } } /* * Verify that the lifetimes and onlink/auto flags are consistent * with our settings. */ static void verify_prefix_opt(struct phyint *pi, uchar_t *opt, char *frombuf) { struct nd_opt_prefix_info *po = (struct nd_opt_prefix_info *)opt; int plen; struct adv_prefix *adv_pr; uint32_t validtime, preftime; char prefixbuf[INET6_ADDRSTRLEN]; int pktflag, myflag; if (8 * po->nd_opt_pi_len != sizeof (*po)) { logmsg(LOG_INFO, "RA prefix option from %s on %s wrong size " "(%d bytes)\n", frombuf, pi->pi_name, 8 * (int)po->nd_opt_pi_len); return; } if (IN6_IS_ADDR_LINKLOCAL(&po->nd_opt_pi_prefix)) { logmsg(LOG_INFO, "RA from %s on %s contains link-local " "prefix - ignored\n", frombuf, pi->pi_name); return; } plen = po->nd_opt_pi_prefix_len; adv_pr = adv_prefix_lookup(pi, po->nd_opt_pi_prefix, plen); if (adv_pr == NULL) return; /* Ignore prefixes which we do not advertise */ if (!adv_pr->adv_pr_AdvAutonomousFlag && !adv_pr->adv_pr_AdvOnLinkFlag) return; (void) inet_ntop(AF_INET6, (void *)&adv_pr->adv_pr_prefix, prefixbuf, sizeof (prefixbuf)); pktflag = ((po->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_AUTO) != 0); myflag = (adv_pr->adv_pr_AdvAutonomousFlag != 0); if (pktflag != myflag) { logmsg(LOG_INFO, "RA from %s on %s inconsistent autonomous flag for \n\t" "prefix %s/%u: received %s configuration %s\n", frombuf, pi->pi_name, prefixbuf, adv_pr->adv_pr_prefix_len, (pktflag ? "ON" : "OFF"), (myflag ? "ON" : "OFF")); } pktflag = ((po->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_ONLINK) != 0); myflag = (adv_pr->adv_pr_AdvOnLinkFlag != 0); if (pktflag != myflag) { logmsg(LOG_INFO, "RA from %s on %s inconsistent on link flag " "for \n\tprefix %s/%u: received %s configuration %s\n", frombuf, pi->pi_name, prefixbuf, adv_pr->adv_pr_prefix_len, (pktflag ? "ON" : "OFF"), (myflag ? "ON" : "OFF")); } validtime = ntohl(po->nd_opt_pi_valid_time); preftime = ntohl(po->nd_opt_pi_preferred_time); /* * Take into account variation for lifetimes decrementing * in real time. Allow +/- 10 percent and +/- 10 seconds. */ #define LOWER_LIMIT(val) ((val) - (val)/10 - 10) #define UPPER_LIMIT(val) ((val) + (val)/10 + 10) if (adv_pr->adv_pr_AdvValidRealTime) { if (adv_pr->adv_pr_AdvValidExpiration > 0 && (validtime < LOWER_LIMIT(adv_pr->adv_pr_AdvValidExpiration) || validtime > UPPER_LIMIT(adv_pr->adv_pr_AdvValidExpiration))) { logmsg(LOG_INFO, "RA from %s on %s inconsistent valid " "lifetime for\n\tprefix %s/%u: received %d " "configuration %d\n", frombuf, pi->pi_name, prefixbuf, adv_pr->adv_pr_prefix_len, validtime, adv_pr->adv_pr_AdvValidExpiration); } } else { if (validtime != adv_pr->adv_pr_AdvValidLifetime) { logmsg(LOG_INFO, "RA from %s on %s inconsistent valid " "lifetime for\n\tprefix %s/%u: received %d " "configuration %d\n", frombuf, pi->pi_name, prefixbuf, adv_pr->adv_pr_prefix_len, validtime, adv_pr->adv_pr_AdvValidLifetime); } } if (adv_pr->adv_pr_AdvPreferredRealTime) { if (adv_pr->adv_pr_AdvPreferredExpiration > 0 && (preftime < LOWER_LIMIT(adv_pr->adv_pr_AdvPreferredExpiration) || preftime > UPPER_LIMIT(adv_pr->adv_pr_AdvPreferredExpiration))) { logmsg(LOG_INFO, "RA from %s on %s inconsistent " "preferred lifetime for\n\tprefix %s/%u: " "received %d configuration %d\n", frombuf, pi->pi_name, prefixbuf, adv_pr->adv_pr_prefix_len, preftime, adv_pr->adv_pr_AdvPreferredExpiration); } } else { if (preftime != adv_pr->adv_pr_AdvPreferredLifetime) { logmsg(LOG_INFO, "RA from %s on %s inconsistent " "preferred lifetime for\n\tprefix %s/%u: " "received %d configuration %d\n", frombuf, pi->pi_name, prefixbuf, adv_pr->adv_pr_prefix_len, preftime, adv_pr->adv_pr_AdvPreferredLifetime); } } } /* * Verify the received MTU against our own configuration. */ static void verify_mtu_opt(struct phyint *pi, uchar_t *opt, char *frombuf) { struct nd_opt_mtu *mo = (struct nd_opt_mtu *)opt; uint32_t mtu; if (8 * mo->nd_opt_mtu_len != sizeof (*mo)) { logmsg(LOG_INFO, "mtu option from %s on %s wrong size " "(%d bytes)\n", frombuf, pi->pi_name, 8 * (int)mo->nd_opt_mtu_len); return; } mtu = ntohl(mo->nd_opt_mtu_mtu); if (pi->pi_AdvLinkMTU != 0 && pi->pi_AdvLinkMTU != mtu) { logmsg(LOG_INFO, "RA from %s on %s inconsistent MTU: " "received %d configuration %d\n", frombuf, pi->pi_name, mtu, pi->pi_AdvLinkMTU); } } /* * Verify that all options have a non-zero length and that * the options fit within the total length of the packet (optlen). */ static boolean_t verify_opt_len(struct nd_opt_hdr *opt, int optlen, struct phyint *pi, struct sockaddr_in6 *from) { while (optlen > 0) { if (opt->nd_opt_len == 0) { char abuf[INET6_ADDRSTRLEN]; (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, abuf, sizeof (abuf)); logmsg(LOG_INFO, "Zero length option type 0x%x " "from %s on %s\n", opt->nd_opt_type, abuf, pi->pi_name); return (_B_FALSE); } optlen -= 8 * opt->nd_opt_len; if (optlen < 0) { char abuf[INET6_ADDRSTRLEN]; (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, abuf, sizeof (abuf)); logmsg(LOG_INFO, "Too large option: type 0x%x len %u " "from %s on %s\n", opt->nd_opt_type, opt->nd_opt_len, abuf, pi->pi_name); return (_B_FALSE); } opt = (struct nd_opt_hdr *)((char *)opt + 8 * opt->nd_opt_len); } return (_B_TRUE); } /* * Update IsRouter Flag for Host turning into a router or vice-versa. */ static void update_ra_flag(const struct phyint *pi, const struct sockaddr_in6 *from, int isrouter) { struct lifreq lifr; char abuf[INET6_ADDRSTRLEN]; struct sockaddr_in6 *sin6; /* check if valid flag is being set */ if ((isrouter != NDF_ISROUTER_ON) && (isrouter != NDF_ISROUTER_OFF)) { logmsg(LOG_ERR, "update_ra_flag: Invalid IsRouter " "flag %d\n", isrouter); return; } sin6 = (struct sockaddr_in6 *)&lifr.lifr_nd.lnr_addr; bzero(sin6, sizeof (*sin6)); sin6->sin6_family = AF_INET6; sin6->sin6_addr = from->sin6_addr; (void) strlcpy(lifr.lifr_name, pi->pi_name, sizeof (lifr.lifr_name)); if (ioctl(pi->pi_sock, SIOCLIFGETND, (char *)&lifr) < 0) { if (errno == ESRCH) { if (debug & D_IFSCAN) { logmsg(LOG_DEBUG, "update_ra_flag: SIOCLIFGETND: nce doesn't exist, not setting IFF_ROUTER\n"); } } else { logperror_pi(pi, "update_ra_flag: SIOCLIFGETND"); } } else { /* * The lif_nd_req structure has three state values to be used * when changing/updating nces : * lnr_state_create, lnr_state_same_lla, and lnr_state_diff_lla. * * In this case, we're updating an nce, without changing lla; * so we set lnr_state_same_lla to ND_UNCHANGED, indicating that * nce's state should not be affected by our flag change. * * The kernel implementation also expects the lnr_state_create * field be always set, before processing ioctl request for NCE * update. * We use the state as STALE, while addressing the possibility * of NCE deletion when ioctl with SIOCLIFGETND argument * in earlier step is returned - further in such case we don't * want to re-create the entry in the reachable state. */ lifr.lifr_nd.lnr_state_create = ND_STALE; lifr.lifr_nd.lnr_state_same_lla = ND_UNCHANGED; lifr.lifr_nd.lnr_flags = isrouter; if ((ioctl(pi->pi_sock, SIOCLIFSETND, (char *)&lifr)) < 0) { logperror_pi(pi, "update_ra_flag: SIOCLIFSETND"); } else { (void) inet_ntop(AF_INET6, (void *)&from->sin6_addr, abuf, sizeof (abuf)); logmsg(LOG_INFO, "update_ra_flag: IsRouter flag " "updated for %s\n", abuf); } } }