/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (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 2004 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #pragma ident "%Z%%M% %I% %E% SMI" #include "defs.h" #include "tables.h" #include #include struct phyint *phyints = NULL; static void phyint_print(struct phyint *pi); static void phyint_insert(struct phyint *pi); static boolean_t tmptoken_isvalid(struct in6_addr *token); static void prefix_print(struct prefix *pr); static void prefix_insert(struct phyint *pi, struct prefix *pr); static char *prefix_print_state(int state, char *buf, int buflen); static void prefix_set(struct in6_addr *prefix, struct in6_addr addr, int bits); static void adv_prefix_print(struct adv_prefix *adv_pr); static void adv_prefix_insert(struct phyint *pi, struct adv_prefix *adv_pr); static void adv_prefix_delete(struct adv_prefix *adv_pr); static void router_print(struct router *dr); static void router_insert(struct phyint *pi, struct router *dr); static void router_delete(struct router *dr); static void router_add_k(struct router *dr); static void router_delete_k(struct router *dr); static void router_delete_onlink(struct phyint *pi); static int rtmseq; /* rtm_seq sequence number */ /* 1 week in ms */ #define NDP_PREFIX_DEFAULT_LIFETIME (7*24*60*60*1000) struct phyint * phyint_lookup(char *name) { struct phyint *pi; if (debug & D_PHYINT) logmsg(LOG_DEBUG, "phyint_lookup(%s)\n", name); for (pi = phyints; pi != NULL; pi = pi->pi_next) { if (strcmp(pi->pi_name, name) == 0) break; } return (pi); } struct phyint * phyint_lookup_on_index(uint_t ifindex) { struct phyint *pi; if (debug & D_PHYINT) logmsg(LOG_DEBUG, "phyint_lookup_on_index(%d)\n", ifindex); for (pi = phyints; pi != NULL; pi = pi->pi_next) { if (pi->pi_index == ifindex) break; } return (pi); } struct phyint * phyint_create(char *name) { struct phyint *pi; int i; if (debug & D_PHYINT) logmsg(LOG_DEBUG, "phyint_create(%s)\n", name); pi = (struct phyint *)calloc(sizeof (struct phyint), 1); if (pi == NULL) { logmsg(LOG_ERR, "phyint_create: out of memory\n"); return (NULL); } (void) strncpy(pi->pi_name, name, sizeof (pi->pi_name)); pi->pi_name[sizeof (pi->pi_name) - 1] = '\0'; /* * Copy the defaults from the defaults array. * Do not copy the cf_notdefault fields since these have not * been explicitly set for the phyint. */ for (i = 0; i < I_IFSIZE; i++) pi->pi_config[i].cf_value = ifdefaults[i].cf_value; /* * TmpDesyncFactor is used to desynchronize temporary token * generation among systems; the actual preferred lifetime value * of a temporary address will be (TmpPreferredLifetime - * TmpDesyncFactor). It's a random value, with a user-configurable * maximum value. The value is constant throughout the lifetime * of the in.ndpd process, but can change if the daemon is restarted, * per RFC3041. */ if (pi->pi_TmpMaxDesyncFactor != 0) { time_t seed = time(NULL); srand((uint_t)seed); pi->pi_TmpDesyncFactor = rand() % pi->pi_TmpMaxDesyncFactor; /* we actually want [1,max], not [0,(max-1)] */ pi->pi_TmpDesyncFactor++; } pi->pi_TmpRegenCountdown = TIMER_INFINITY; pi->pi_sock = -1; if (phyint_init_from_k(pi) == -1) { if (pi->pi_group_name != NULL) free(pi->pi_group_name); free(pi); return (NULL); } phyint_insert(pi); if (pi->pi_sock != -1) { if (poll_add(pi->pi_sock) == -1) { phyint_delete(pi); return (NULL); } } return (pi); } /* Insert in linked list */ static void phyint_insert(struct phyint *pi) { /* Insert in list */ pi->pi_next = phyints; pi->pi_prev = NULL; if (phyints) phyints->pi_prev = pi; phyints = pi; } /* * Initialize both the phyint data structure and the pi_sock for * sending and receving on the interface. * Extract information from the kernel (if present) and set pi_kernel_state. */ int phyint_init_from_k(struct phyint *pi) { struct ipv6_mreq v6mcastr; struct lifreq lifr; int fd; boolean_t newsock; uint_t ttl; struct sockaddr_in6 *sin6; if (debug & D_PHYINT) logmsg(LOG_DEBUG, "phyint_init_from_k(%s)\n", pi->pi_name); start_over: if (pi->pi_sock < 0) { pi->pi_sock = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6); if (pi->pi_sock < 0) { logperror_pi(pi, "phyint_init_from_k: socket"); return (-1); } newsock = _B_TRUE; } else { newsock = _B_FALSE; } fd = pi->pi_sock; (void) strncpy(lifr.lifr_name, pi->pi_name, sizeof (lifr.lifr_name)); lifr.lifr_name[sizeof (lifr.lifr_name) - 1] = '\0'; if (ioctl(fd, SIOCGLIFINDEX, (char *)&lifr) < 0) { if (errno == ENXIO) { if (newsock) { (void) close(pi->pi_sock); pi->pi_sock = -1; } if (debug & D_PHYINT) { logmsg(LOG_DEBUG, "phyint_init_from_k(%s): " "not exist\n", pi->pi_name); } return (0); } logperror_pi(pi, "phyint_init_from_k: SIOCGLIFINDEX"); goto error; } if (!newsock && (pi->pi_index != lifr.lifr_index)) { /* * Interface has been re-plumbed, lets open a new socket. * This situation can occur if plumb/unplumb are happening * quite frequently. */ phyint_cleanup(pi); goto start_over; } pi->pi_index = lifr.lifr_index; if (ioctl(fd, SIOCGLIFFLAGS, (char *)&lifr) < 0) { logperror_pi(pi, "phyint_init_from_k: ioctl (get flags)"); goto error; } pi->pi_flags = lifr.lifr_flags; /* * If the link local interface is not up yet or it's IFF_UP * and the flag is set to IFF_NOLOCAL as Duplicate Address * Detection is in progress. * IFF_NOLOCAL is "normal" on other prefixes. */ if (!(pi->pi_flags & IFF_UP) || (pi->pi_flags & IFF_NOLOCAL)) { if (newsock) { (void) close(pi->pi_sock); pi->pi_sock = -1; } if (debug & D_PHYINT) { logmsg(LOG_DEBUG, "phyint_init_from_k(%s): " "not IFF_UP\n", pi->pi_name); } return (0); } pi->pi_kernel_state |= PI_PRESENT; bzero(lifr.lifr_groupname, sizeof (lifr.lifr_groupname)); if (ioctl(fd, SIOCGLIFGROUPNAME, (caddr_t)&lifr) < 0) { logperror_pi(pi, "phyint_init_from_k: ioctl (get group name)"); goto error; } if (lifr.lifr_groupname != NULL && strlen(lifr.lifr_groupname) != 0) { if (pi->pi_group_name == NULL) { pi->pi_group_name = malloc( sizeof (lifr.lifr_groupname)); if (pi->pi_group_name == NULL) { logperror_pi(pi, "phyint_init_from_k:" " malloc(group name)"); goto error; } } /* * Size of the group name can only be LIFNAMESZ -1 characters * which is ensured by kernel. Thus, we don't need strncpy. */ (void) strncpy(pi->pi_group_name, lifr.lifr_groupname, sizeof (lifr.lifr_name)); pi->pi_group_name[sizeof (pi->pi_group_name) - 1] = '\0'; } else if (pi->pi_group_name != NULL) { free(pi->pi_group_name); pi->pi_group_name = NULL; } if (ioctl(fd, SIOCGLIFMTU, (caddr_t)&lifr) < 0) { logperror_pi(pi, "phyint_init_from_k: ioctl (get mtu)"); goto error; } pi->pi_mtu = lifr.lifr_mtu; if (ioctl(fd, SIOCGLIFADDR, (char *)&lifr) < 0) { logperror_pi(pi, "phyint_init_from_k: SIOCGLIFADDR"); goto error; } sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr; pi->pi_ifaddr = sin6->sin6_addr; if (ioctl(fd, SIOCGLIFTOKEN, (char *)&lifr) < 0) { logperror_pi(pi, "phyint_init_from_k: SIOCGLIFTOKEN"); goto error; } /* Ignore interface if the token is all zeros */ sin6 = (struct sockaddr_in6 *)&lifr.lifr_token; if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) { logmsg(LOG_ERR, "ignoring interface %s: zero token\n", pi->pi_name); goto error; } pi->pi_token = sin6->sin6_addr; pi->pi_token_length = lifr.lifr_addrlen; /* * Guess a remote token for POINTOPOINT by looking at * the link-local destination address. */ if (pi->pi_flags & IFF_POINTOPOINT) { if (ioctl(fd, SIOCGLIFDSTADDR, (char *)&lifr) < 0) { logperror_pi(pi, "phyint_init_from_k: SIOCGLIFDSTADDR"); goto error; } sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr; if (sin6->sin6_family != AF_INET6 || IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) || !IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) { pi->pi_dst_token = in6addr_any; } else { pi->pi_dst_token = sin6->sin6_addr; /* Clear link-local prefix (first 10 bits) */ pi->pi_dst_token.s6_addr[0] = 0; pi->pi_dst_token.s6_addr[1] &= 0x3f; } } else { pi->pi_dst_token = in6addr_any; } /* Get link-layer address */ if (!(pi->pi_flags & IFF_MULTICAST) || (pi->pi_flags & IFF_POINTOPOINT)) { pi->pi_hdw_addr_len = 0; } else { sin6 = (struct sockaddr_in6 *)&lifr.lifr_nd.lnr_addr; bzero(sin6, sizeof (struct sockaddr_in6)); sin6->sin6_family = AF_INET6; sin6->sin6_addr = pi->pi_ifaddr; if (ioctl(fd, SIOCLIFGETND, (char *)&lifr) < 0) { logperror_pi(pi, "phyint_init_from_k: SIOCLIFGETND"); goto error; } pi->pi_hdw_addr_len = lifr.lifr_nd.lnr_hdw_len; if (lifr.lifr_nd.lnr_hdw_len != 0) { bcopy((char *)lifr.lifr_nd.lnr_hdw_addr, (char *)pi->pi_hdw_addr, lifr.lifr_nd.lnr_hdw_len); } } if (newsock) { icmp6_filter_t filter; int on = 1; /* Set default values */ pi->pi_LinkMTU = pi->pi_mtu; pi->pi_CurHopLimit = 0; pi->pi_BaseReachableTime = ND_REACHABLE_TIME; phyint_reach_random(pi, _B_FALSE); pi->pi_RetransTimer = ND_RETRANS_TIMER; /* Setup socket for transmission and reception */ if (setsockopt(fd, IPPROTO_IPV6, IPV6_BOUND_IF, (char *)&pi->pi_index, sizeof (pi->pi_index)) < 0) { logperror_pi(pi, "phyint_init_from_k: setsockopt " "IPV6_BOUND_IF"); goto error; } ttl = IPV6_MAX_HOPS; if (setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, (char *)&ttl, sizeof (ttl)) < 0) { logperror_pi(pi, "phyint_init_from_k: setsockopt " "IPV6_UNICAST_HOPS"); goto error; } if (setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *)&ttl, sizeof (ttl)) < 0) { logperror_pi(pi, "phyint_init_from_k: setsockopt " "IPV6_MULTICAST_HOPS"); goto error; } v6mcastr.ipv6mr_multiaddr = all_nodes_mcast; v6mcastr.ipv6mr_interface = pi->pi_index; if (setsockopt(fd, IPPROTO_IPV6, IPV6_JOIN_GROUP, (char *)&v6mcastr, sizeof (v6mcastr)) < 0) { logperror_pi(pi, "phyint_init_from_k: " "setsockopt IPV6_JOIN_GROUP"); goto error; } pi->pi_state |= PI_JOINED_ALLNODES; pi->pi_kernel_state |= PI_JOINED_ALLNODES; /* * Filter out so that we only receive router advertisements and * router solicitations. */ ICMP6_FILTER_SETBLOCKALL(&filter); ICMP6_FILTER_SETPASS(ND_ROUTER_SOLICIT, &filter); ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &filter); if (setsockopt(fd, IPPROTO_ICMPV6, ICMP6_FILTER, (char *)&filter, sizeof (filter)) < 0) { logperror_pi(pi, "phyint_init_from_k: setsockopt " "ICMP6_FILTER"); goto error; } /* Enable receipt of ancillary data */ if (setsockopt(fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, (char *)&on, sizeof (on)) < 0) { logperror_pi(pi, "phyint_init_from_k: setsockopt " "IPV6_RECVHOPLIMIT"); goto error; } if (setsockopt(fd, IPPROTO_IPV6, IPV6_RECVRTHDR, (char *)&on, sizeof (on)) < 0) { logperror_pi(pi, "phyint_init_from_k: setsockopt " "IPV6_RECVRTHDR"); goto error; } } if (pi->pi_AdvSendAdvertisements && !(pi->pi_kernel_state & PI_JOINED_ALLROUTERS)) { v6mcastr.ipv6mr_multiaddr = all_routers_mcast; v6mcastr.ipv6mr_interface = pi->pi_index; if (setsockopt(fd, IPPROTO_IPV6, IPV6_JOIN_GROUP, (char *)&v6mcastr, sizeof (v6mcastr)) < 0) { logperror_pi(pi, "phyint_init_from_k: setsockopt " "IPV6_JOIN_GROUP"); goto error; } pi->pi_state |= PI_JOINED_ALLROUTERS; pi->pi_kernel_state |= PI_JOINED_ALLROUTERS; } /* * If not already set, set the IFF_ROUTER interface flag based on * AdvSendAdvertisements. Note that this will also enable IPv6 * forwarding on the interface. We don't clear IFF_ROUTER if we're * not advertising on an interface, because we could still be * forwarding on those interfaces. */ (void) strncpy(lifr.lifr_name, pi->pi_name, sizeof (lifr.lifr_name)); lifr.lifr_name[sizeof (lifr.lifr_name) - 1] = '\0'; if (ioctl(fd, SIOCGLIFFLAGS, (char *)&lifr) < 0) { logperror_pi(pi, "phyint_init_from_k: SIOCGLIFFLAGS"); goto error; } if (!(lifr.lifr_flags & IFF_ROUTER) && pi->pi_AdvSendAdvertisements) { lifr.lifr_flags |= IFF_ROUTER; if (ioctl(fd, SIOCSLIFFLAGS, (char *)&lifr) < 0) { logperror_pi(pi, "phyint_init_from_k: SIOCSLIFFLAGS"); goto error; } pi->pi_flags = lifr.lifr_flags; } /* Set linkinfo parameters */ (void) strncpy(lifr.lifr_name, pi->pi_name, sizeof (lifr.lifr_name)); lifr.lifr_name[sizeof (lifr.lifr_name) - 1] = '\0'; if (ioctl(fd, SIOCGLIFLNKINFO, (char *)&lifr) < 0) { logperror_pi(pi, "phyint_init_from_k: SIOCGLIFLNKINFO"); goto error; } lifr.lifr_ifinfo.lir_maxhops = pi->pi_CurHopLimit; lifr.lifr_ifinfo.lir_reachtime = pi->pi_ReachableTime; lifr.lifr_ifinfo.lir_reachretrans = pi->pi_RetransTimer; if (ioctl(fd, SIOCSLIFLNKINFO, (char *)&lifr) < 0) { logperror_pi(pi, "phyint_init_from_k: SIOCSLIFLNKINFO"); goto error; } if (debug & D_PHYINT) { logmsg(LOG_DEBUG, "phyint_init_from_k(%s): done\n", pi->pi_name); } return (0); error: /* Pretend the interface does not exist in the kernel */ pi->pi_kernel_state &= ~PI_PRESENT; if (newsock) { (void) close(pi->pi_sock); pi->pi_sock = -1; } return (-1); } /* * Delete (unlink and free). * Handles delete of things that have not yet been inserted in the list. */ void phyint_delete(struct phyint *pi) { if (debug & D_PHYINT) logmsg(LOG_DEBUG, "phyint_delete(%s)\n", pi->pi_name); while (pi->pi_router_list) router_delete(pi->pi_router_list); while (pi->pi_prefix_list) prefix_delete(pi->pi_prefix_list); while (pi->pi_adv_prefix_list) adv_prefix_delete(pi->pi_adv_prefix_list); if (pi->pi_sock != -1) { (void) poll_remove(pi->pi_sock); if (close(pi->pi_sock) < 0) { logperror_pi(pi, "phyint_delete: close"); } pi->pi_sock = -1; } if (pi->pi_prev == NULL) { if (phyints == pi) phyints = pi->pi_next; } else { pi->pi_prev->pi_next = pi->pi_next; } if (pi->pi_next != NULL) pi->pi_next->pi_prev = pi->pi_prev; pi->pi_next = pi->pi_prev = NULL; if (pi->pi_group_name != NULL) free(pi->pi_group_name); free(pi); } /* * Called with the number of millseconds elapsed since the last call. * Determines if any timeout event has occurred and * returns the number of milliseconds until the next timeout event * for the phyint iself (excluding prefixes and routers). * Returns TIMER_INFINITY for "never". */ uint_t phyint_timer(struct phyint *pi, uint_t elapsed) { uint_t next = TIMER_INFINITY; if (pi->pi_AdvSendAdvertisements) { if (pi->pi_adv_state != NO_ADV) { int old_state = pi->pi_adv_state; if (debug & (D_STATE|D_PHYINT)) { logmsg(LOG_DEBUG, "phyint_timer ADV(%s) " "state %d\n", pi->pi_name, (int)old_state); } next = advertise_event(pi, ADV_TIMER, elapsed); if (debug & D_STATE) { logmsg(LOG_DEBUG, "phyint_timer ADV(%s) " "state %d -> %d\n", pi->pi_name, (int)old_state, (int)pi->pi_adv_state); } } } else { if (pi->pi_sol_state != NO_SOLICIT) { int old_state = pi->pi_sol_state; if (debug & (D_STATE|D_PHYINT)) { logmsg(LOG_DEBUG, "phyint_timer SOL(%s) " "state %d\n", pi->pi_name, (int)old_state); } next = solicit_event(pi, SOL_TIMER, elapsed); if (debug & D_STATE) { logmsg(LOG_DEBUG, "phyint_timer SOL(%s) " "state %d -> %d\n", pi->pi_name, (int)old_state, (int)pi->pi_sol_state); } } } /* * If the phyint has been unplumbed, we don't want to call * phyint_reach_random. We will be in the NO_ADV or NO_SOLICIT state. */ if ((pi->pi_AdvSendAdvertisements && (pi->pi_adv_state != NO_ADV)) || (!pi->pi_AdvSendAdvertisements && (pi->pi_sol_state != NO_SOLICIT))) { pi->pi_reach_time_since_random += elapsed; if (pi->pi_reach_time_since_random >= MAX_REACH_RANDOM_INTERVAL) phyint_reach_random(pi, _B_TRUE); } return (next); } static void phyint_print(struct phyint *pi) { struct prefix *pr; struct adv_prefix *adv_pr; struct router *dr; char abuf[INET6_ADDRSTRLEN]; char llabuf[BUFSIZ]; logmsg(LOG_DEBUG, "Phyint %s index %d state %x, kernel %x, " "onlink_def %d num routers %d\n", pi->pi_name, pi->pi_index, pi->pi_state, pi->pi_kernel_state, pi->pi_onlink_default ? 1 : 0, pi->pi_num_k_routers); logmsg(LOG_DEBUG, "\taddress: %s flags %x\n", inet_ntop(AF_INET6, (void *)&pi->pi_ifaddr, abuf, sizeof (abuf)), pi->pi_flags); logmsg(LOG_DEBUG, "\tsock %d mtu %d hdw_addr len %d <%s>\n", pi->pi_sock, pi->pi_mtu, pi->pi_hdw_addr_len, ((pi->pi_hdw_addr_len != 0) ? fmt_lla(llabuf, sizeof (llabuf), pi->pi_hdw_addr, pi->pi_hdw_addr_len) : "none")); logmsg(LOG_DEBUG, "\ttoken: len %d %s\n", pi->pi_token_length, inet_ntop(AF_INET6, (void *)&pi->pi_token, abuf, sizeof (abuf))); if (pi->pi_TmpAddrsEnabled) { logmsg(LOG_DEBUG, "\ttmp_token: %s\n", inet_ntop(AF_INET6, (void *)&pi->pi_tmp_token, abuf, sizeof (abuf))); logmsg(LOG_DEBUG, "\ttmp config: pref %d valid %d " "maxdesync %d desync %d regen %d\n", pi->pi_TmpPreferredLifetime, pi->pi_TmpValidLifetime, pi->pi_TmpMaxDesyncFactor, pi->pi_TmpDesyncFactor, pi->pi_TmpRegenAdvance); } if (pi->pi_flags & IFF_POINTOPOINT) { logmsg(LOG_DEBUG, "\tdst_token: %s\n", inet_ntop(AF_INET6, (void *)&pi->pi_dst_token, abuf, sizeof (abuf))); } logmsg(LOG_DEBUG, "\tLinkMTU %d CurHopLimit %d " "BaseReachableTime %d\n\tReachableTime %d RetransTimer %d\n", pi->pi_LinkMTU, pi->pi_CurHopLimit, pi->pi_BaseReachableTime, pi->pi_ReachableTime, pi->pi_RetransTimer); if (!pi->pi_AdvSendAdvertisements) { /* Solicit state */ logmsg(LOG_DEBUG, "\tSOLICIT: time_left %d state %d count %d\n", pi->pi_sol_time_left, pi->pi_sol_state, pi->pi_sol_count); } else { /* Advertise state */ logmsg(LOG_DEBUG, "\tADVERT: time_left %d state %d count %d " "since last %d\n", pi->pi_adv_time_left, pi->pi_adv_state, pi->pi_adv_count, pi->pi_adv_time_since_sent); print_iflist(pi->pi_config); } for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) prefix_print(pr); for (adv_pr = pi->pi_adv_prefix_list; adv_pr != NULL; adv_pr = adv_pr->adv_pr_next) { adv_prefix_print(adv_pr); } for (dr = pi->pi_router_list; dr != NULL; dr = dr->dr_next) router_print(dr); logmsg(LOG_DEBUG, "\n"); } /* * Randomize pi->pi_ReachableTime. * Done periodically when there are no RAs and at a maximum frequency when * RA's arrive. * Assumes that caller has determined that it is time to generate * a new random ReachableTime. */ void phyint_reach_random(struct phyint *pi, boolean_t set_needed) { pi->pi_ReachableTime = GET_RANDOM( (int)(ND_MIN_RANDOM_FACTOR * pi->pi_BaseReachableTime), (int)(ND_MAX_RANDOM_FACTOR * pi->pi_BaseReachableTime)); if (set_needed) { struct lifreq lifr; (void) strncpy(lifr.lifr_name, pi->pi_name, sizeof (lifr.lifr_name)); pi->pi_name[sizeof (pi->pi_name) - 1] = '\0'; if (ioctl(pi->pi_sock, SIOCGLIFLNKINFO, (char *)&lifr) < 0) { logperror_pi(pi, "phyint_reach_random: SIOCGLIFLNKINFO"); return; } lifr.lifr_ifinfo.lir_reachtime = pi->pi_ReachableTime; if (ioctl(pi->pi_sock, SIOCSLIFLNKINFO, (char *)&lifr) < 0) { logperror_pi(pi, "phyint_reach_random: SIOCSLIFLNKINFO"); return; } } pi->pi_reach_time_since_random = 0; } /* * Validate a temporary token against a list of known bad values. * Currently assumes that token is 8 bytes long! Current known * bad values include 0, reserved anycast tokens (RFC 2526), tokens * used by ISATAP (draft-ietf-ngtrans-isatap-N), any token already * assigned to this interface, or any token for which the global * bit is set. * * Called by tmptoken_create(). * * Return _B_TRUE if token is valid (no match), _B_FALSE if not. */ static boolean_t tmptoken_isvalid(struct in6_addr *token) { struct phyint *pi; struct in6_addr mask; struct in6_addr isatap = { 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0x5e, 0xfe, 0, 0, 0, 0 }; struct in6_addr anycast = { 0, 0, 0, 0, \ 0, 0, 0, 0, \ 0xfd, 0xff, 0xff, 0xff, \ 0xff, 0xff, 0xff, 0x80 }; if (IN6_IS_ADDR_UNSPECIFIED(token)) return (_B_FALSE); if (token->s6_addr[8] & 0x2) return (_B_FALSE); (void) memcpy(&mask, token, sizeof (mask)); mask._S6_un._S6_u32[3] = 0; if (IN6_ARE_ADDR_EQUAL(&isatap, token)) return (_B_FALSE); mask._S6_un._S6_u32[3] = token->_S6_un._S6_u32[3] & 0xffffff80; if (IN6_ARE_ADDR_EQUAL(&anycast, token)) return (_B_FALSE); for (pi = phyints; pi != NULL; pi = pi->pi_next) { if (((pi->pi_token_length == TMP_TOKEN_BITS) && IN6_ARE_ADDR_EQUAL(&pi->pi_token, token)) || IN6_ARE_ADDR_EQUAL(&pi->pi_tmp_token, token)) return (_B_FALSE); } /* none of our tests failed, must be a good one! */ return (_B_TRUE); } /* * Generate a temporary token and set up its timer * * Called from incoming_prefix_addrconf_process() (when token is first * needed) and from tmptoken_timer() (when current token expires). * * Returns _B_TRUE if a token was successfully generated, _B_FALSE if not. */ boolean_t tmptoken_create(struct phyint *pi) { int fd, i = 0, max_tries = 15; struct in6_addr token; uint32_t *tokenp = &(token._S6_un._S6_u32[2]); char buf[INET6_ADDRSTRLEN]; if ((fd = open("/dev/urandom", O_RDONLY)) == -1) { perror("open /dev/urandom"); goto no_token; } bzero((char *)&token, sizeof (token)); do { if (read(fd, (void *)tokenp, TMP_TOKEN_BYTES) == -1) { perror("read /dev/urandom"); (void) close(fd); goto no_token; } /* * Assume EUI-64 formatting, and thus 64-bit * token len; need to clear global bit. */ token.s6_addr[8] &= 0xfd; i++; } while (!tmptoken_isvalid(&token) && i < max_tries); (void) close(fd); if (i == max_tries) { no_token: logmsg(LOG_WARNING, "tmptoken_create(%s): failed to create " "token; disabling temporary addresses on %s\n", pi->pi_name, pi->pi_name); pi->pi_TmpAddrsEnabled = 0; return (_B_FALSE); } pi->pi_tmp_token = token; if (debug & D_TMP) logmsg(LOG_DEBUG, "tmptoken_create(%s): created temporary " "token %s\n", pi->pi_name, inet_ntop(AF_INET6, &pi->pi_tmp_token, buf, sizeof (buf))); pi->pi_TmpRegenCountdown = (pi->pi_TmpPreferredLifetime - pi->pi_TmpDesyncFactor - pi->pi_TmpRegenAdvance) * MILLISEC; if (pi->pi_TmpRegenCountdown != 0) timer_schedule(pi->pi_TmpRegenCountdown); return (_B_TRUE); } /* * Delete a temporary token. This is outside the normal timeout process, * so mark any existing addresses based on this token DEPRECATED and set * their preferred lifetime to 0. Don't tamper with valid lifetime, that * will be used to eventually remove the address. Also reset the current * pi_tmp_token value to 0. * * Called from incoming_prefix_addrconf_process() if DAD fails on a temp * addr. */ void tmptoken_delete(struct phyint *pi) { struct prefix *pr; for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) { if (!(pr->pr_flags & IFF_TEMPORARY) || (pr->pr_flags & IFF_DEPRECATED) || (!token_equal(pr->pr_address, pi->pi_tmp_token, TMP_TOKEN_BITS))) { continue; } pr->pr_PreferredLifetime = 0; pr->pr_state |= PR_DEPRECATED; prefix_update_k(pr); } (void) memset(&pi->pi_tmp_token, 0, sizeof (pi->pi_tmp_token)); } /* * Called from run_timeouts() with the number of milliseconds elapsed * since the last call. Determines if any timeout event has occurred * and returns the number of milliseconds until the next timeout event * for the tmp token. Returns TIMER_INFINITY for "never". */ uint_t tmptoken_timer(struct phyint *pi, uint_t elapsed) { struct nd_opt_prefix_info opt; struct sockaddr_in6 sin6; struct prefix *pr, *newpr; if (debug & D_TMP) { logmsg(LOG_DEBUG, "tmptoken_timer(%s, %d) regencountdown %d\n", pi->pi_name, (int)elapsed, pi->pi_TmpRegenCountdown); } if (!pi->pi_TmpAddrsEnabled || (pi->pi_TmpRegenCountdown == TIMER_INFINITY)) return (TIMER_INFINITY); if (pi->pi_TmpRegenCountdown > elapsed) { pi->pi_TmpRegenCountdown -= elapsed; return (pi->pi_TmpRegenCountdown); } /* * Tmp token timer has expired. Start by generating a new token. * If we can't get a new token, tmp addrs are disabled on this * interface, so there's no need to continue, or to set a timer. */ if (!tmptoken_create(pi)) return (TIMER_INFINITY); /* * Now that we have a new token, walk the list of prefixes to * find which ones need a corresponding tmp addr generated. */ for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) { if (!(pr->pr_state & PR_AUTO) || pr->pr_state & PR_STATIC || pr->pr_state & PR_DEPRECATED || pr->pr_flags & IFF_TEMPORARY) continue; newpr = prefix_create(pi, pr->pr_prefix, pr->pr_prefix_len, IFF_TEMPORARY); if (newpr == NULL) { char pbuf[INET6_ADDRSTRLEN]; char tbuf[INET6_ADDRSTRLEN]; (void) inet_ntop(AF_INET6, &pr->pr_prefix, pbuf, sizeof (pbuf)); (void) inet_ntop(AF_INET6, &pi->pi_tmp_token, tbuf, sizeof (tbuf)); logmsg(LOG_ERR, "can't create new tmp addr " "(%s, %s, %s)\n", pi->pi_name, pbuf, tbuf); continue; } /* * We want to use incoming_prefix_*_process() functions to * set up the new tmp addr, so cobble together a prefix * info option struct based on the existing prefix to pass * in. The lifetimes will be based on the current time * remaining. * * The "from" param is only used for messages; pass in * ::0 for that. */ opt.nd_opt_pi_type = ND_OPT_PREFIX_INFORMATION; opt.nd_opt_pi_len = sizeof (opt) / 8; opt.nd_opt_pi_prefix_len = pr->pr_prefix_len; opt.nd_opt_pi_flags_reserved = ND_OPT_PI_FLAG_AUTO; opt.nd_opt_pi_valid_time = htonl(pr->pr_ValidLifetime / 1000); opt.nd_opt_pi_preferred_time = htonl(pr->pr_PreferredLifetime / 1000); if (pr->pr_state & PR_ONLINK) opt.nd_opt_pi_flags_reserved &= ND_OPT_PI_FLAG_ONLINK; opt.nd_opt_pi_prefix = pr->pr_prefix; (void) memset(&sin6, 0, sizeof (sin6)); if (!incoming_prefix_addrconf_process(pi, newpr, (uchar_t *)&opt, &sin6, _B_FALSE, _B_TRUE)) { char pbuf[INET6_ADDRSTRLEN]; char tbuf[INET6_ADDRSTRLEN]; (void) inet_ntop(AF_INET6, &pr->pr_prefix, pbuf, sizeof (pbuf)); (void) inet_ntop(AF_INET6, &pi->pi_tmp_token, tbuf, sizeof (tbuf)); logmsg(LOG_ERR, "can't create new tmp addr " "(%s, %s, %s)\n", pi->pi_name, pbuf, tbuf); continue; } if (pr->pr_state & PR_ONLINK) { incoming_prefix_onlink_process(newpr, (uchar_t *)&opt); } } /* * appropriate timers were scheduled when * the token and addresses were created. */ return (TIMER_INFINITY); } /* * tlen specifies the token length in bits. Compares the lower * tlen bits of the two addresses provided and returns _B_TRUE if * they match, _B_FALSE if not. Also returns _B_FALSE for invalid * values of tlen. */ boolean_t token_equal(struct in6_addr t1, struct in6_addr t2, int tlen) { uchar_t mask; int j, abytes, tbytes, tbits; if (tlen < 0 || tlen > IPV6_ABITS) return (_B_FALSE); abytes = IPV6_ABITS >> 3; tbytes = tlen >> 3; tbits = tlen & 7; for (j = abytes - 1; j >= abytes - tbytes; j--) if (t1.s6_addr[j] != t2.s6_addr[j]) return (_B_FALSE); if (tbits == 0) return (_B_TRUE); /* We only care about the tbits rightmost bits */ mask = 0xff >> (8 - tbits); if ((t1.s6_addr[j] & mask) != (t2.s6_addr[j] & mask)) return (_B_FALSE); return (_B_TRUE); } /* * Lookup prefix structure that matches the prefix and prefix length. * Assumes that the bits after prefixlen might not be zero. */ static struct prefix * prefix_lookup(struct phyint *pi, struct in6_addr prefix, int prefixlen) { struct prefix *pr; char abuf[INET6_ADDRSTRLEN]; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_lookup(%s, %s/%u)\n", pi->pi_name, inet_ntop(AF_INET6, (void *)&prefix, abuf, sizeof (abuf)), prefixlen); } for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) { if (pr->pr_prefix_len == prefixlen && prefix_equal(prefix, pr->pr_prefix, prefixlen)) return (pr); } return (NULL); } /* * Compare two prefixes that have the same prefix length. * Fails if the prefix length is unreasonable. */ boolean_t prefix_equal(struct in6_addr p1, struct in6_addr p2, int plen) { uchar_t mask; int j, pbytes, pbits; if (plen < 0 || plen > IPV6_ABITS) return (_B_FALSE); pbytes = plen >> 3; pbits = plen & 7; for (j = 0; j < pbytes; j++) if (p1.s6_addr[j] != p2.s6_addr[j]) return (_B_FALSE); if (pbits == 0) return (_B_TRUE); /* Make the N leftmost bits one */ mask = 0xff << (8 - pbits); if ((p1.s6_addr[j] & mask) != (p2.s6_addr[j] & mask)) return (_B_FALSE); return (_B_TRUE); } /* * Set a prefix from an address and a prefix length. * Force all the bits after the prefix length to be zero. */ void prefix_set(struct in6_addr *prefix, struct in6_addr addr, int prefix_len) { uchar_t mask; int j; if (prefix_len < 0 || prefix_len > IPV6_ABITS) return; bzero((char *)prefix, sizeof (*prefix)); for (j = 0; prefix_len > 8; prefix_len -= 8, j++) prefix->s6_addr[j] = addr.s6_addr[j]; /* Make the N leftmost bits one */ mask = 0xff << (8 - prefix_len); prefix->s6_addr[j] = addr.s6_addr[j] & mask; } /* * Lookup a prefix based on the kernel's interface name. */ struct prefix * prefix_lookup_name(struct phyint *pi, char *name) { struct prefix *pr; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_lookup_name(%s, %s)\n", pi->pi_name, name); } if (name[0] == '\0') return (NULL); for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) { if (strcmp(name, pr->pr_name) == 0) return (pr); } return (NULL); } /* * Search the phyints list to make sure that this new prefix does * not already exist in any other physical interfaces that have * the same address as this one */ struct prefix * prefix_lookup_addr_match(struct prefix *pr) { char abuf[INET6_ADDRSTRLEN]; struct phyint *pi; struct prefix *otherpr = NULL; struct in6_addr prefix; int prefixlen; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_lookup_addr_match(%s/%u)\n", inet_ntop(AF_INET6, (void *)&pr->pr_address, abuf, sizeof (abuf)), pr->pr_prefix_len); } prefix = pr->pr_prefix; prefixlen = pr->pr_prefix_len; for (pi = phyints; pi != NULL; pi = pi->pi_next) { otherpr = prefix_lookup(pi, prefix, prefixlen); if (otherpr == pr) continue; if (otherpr != NULL && (otherpr->pr_state & PR_AUTO) && IN6_ARE_ADDR_EQUAL(&pr->pr_address, &otherpr->pr_address)) return (otherpr); } return (NULL); } /* * Initialize a new prefix without setting lifetimes etc. */ struct prefix * prefix_create(struct phyint *pi, struct in6_addr prefix, int prefixlen, uint64_t flags) { struct prefix *pr; char abuf[INET6_ADDRSTRLEN]; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_create(%s, %s/%u, 0x%llx)\n", pi->pi_name, inet_ntop(AF_INET6, (void *)&prefix, abuf, sizeof (abuf)), prefixlen, flags); } pr = (struct prefix *)calloc(sizeof (struct prefix), 1); if (pr == NULL) { logmsg(LOG_ERR, "prefix_create: out of memory\n"); return (NULL); } /* * The prefix might have non-zero bits after the prefix len bits. * Force them to be zero. */ prefix_set(&pr->pr_prefix, prefix, prefixlen); pr->pr_prefix_len = prefixlen; pr->pr_PreferredLifetime = PREFIX_INFINITY; pr->pr_ValidLifetime = PREFIX_INFINITY; pr->pr_OnLinkLifetime = PREFIX_INFINITY; pr->pr_kernel_state = 0; pr->pr_flags |= flags; prefix_insert(pi, pr); return (pr); } /* * Create a new named prefix. Caller should use prefix_init_from_k * to initialize the content. */ struct prefix * prefix_create_name(struct phyint *pi, char *name) { struct prefix *pr; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_create_name(%s, %s)\n", pi->pi_name, name); } pr = (struct prefix *)calloc(sizeof (struct prefix), 1); if (pr == NULL) { logmsg(LOG_ERR, "prefix_create_name: out of memory\n"); return (NULL); } (void) strncpy(pr->pr_name, name, sizeof (pr->pr_name)); pr->pr_name[sizeof (pr->pr_name) - 1] = '\0'; prefix_insert(pi, pr); return (pr); } /* Insert in linked list */ static void prefix_insert(struct phyint *pi, struct prefix *pr) { pr->pr_next = pi->pi_prefix_list; pr->pr_prev = NULL; if (pi->pi_prefix_list != NULL) pi->pi_prefix_list->pr_prev = pr; pi->pi_prefix_list = pr; pr->pr_physical = pi; } /* * Initialize the prefix from the content of the kernel. * If IFF_ADDRCONF is set we treat it as PR_AUTO (i.e. an addrconf * prefix). However, we not derive the lifetimes from * the kernel thus they are set to 1 week. * Ignore the prefix if the interface is not IFF_UP. */ int prefix_init_from_k(struct prefix *pr) { struct lifreq lifr; struct sockaddr_in6 *sin6; int sock = pr->pr_physical->pi_sock; (void) strncpy(lifr.lifr_name, pr->pr_name, sizeof (lifr.lifr_name)); lifr.lifr_name[sizeof (lifr.lifr_name) - 1] = '\0'; if (ioctl(sock, SIOCGLIFADDR, (char *)&lifr) < 0) { logperror_pr(pr, "prefix_init_from_k: ioctl (get addr)"); goto error; } if (lifr.lifr_addr.ss_family != AF_INET6) { logmsg(LOG_ERR, "ignoring interface %s: not AF_INET6\n", pr->pr_name); goto error; } sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr; pr->pr_address = sin6->sin6_addr; if (ioctl(sock, SIOCGLIFFLAGS, (char *)&lifr) < 0) { logperror_pr(pr, "prefix_init_from_k: ioctl (get flags)"); goto error; } pr->pr_flags = lifr.lifr_flags; if (ioctl(sock, SIOCGLIFSUBNET, (char *)&lifr) < 0) { logperror_pr(pr, "prefix_init_from_k: ioctl (get subnet)"); goto error; } if (lifr.lifr_subnet.ss_family != AF_INET6) { logmsg(LOG_ERR, "ignoring interface %s: not AF_INET6\n", pr->pr_name); goto error; } /* * Guard against the prefix having non-zero bits after the prefix * len bits. */ sin6 = (struct sockaddr_in6 *)&lifr.lifr_subnet; pr->pr_prefix_len = lifr.lifr_addrlen; prefix_set(&pr->pr_prefix, sin6->sin6_addr, pr->pr_prefix_len); if (pr->pr_prefix_len != IPV6_ABITS && (pr->pr_flags & IFF_UP) && IN6_ARE_ADDR_EQUAL(&pr->pr_address, &pr->pr_prefix)) { char abuf[INET6_ADDRSTRLEN]; logmsg(LOG_ERR, "ingoring interface %s: it appears to be " "configured with an invalid interface id (%s/%u)\n", pr->pr_name, inet_ntop(AF_INET6, (void *)&pr->pr_address, abuf, sizeof (abuf)), pr->pr_prefix_len); goto error; } pr->pr_kernel_state = 0; if (pr->pr_prefix_len != IPV6_ABITS) pr->pr_kernel_state |= PR_ONLINK; if (!(pr->pr_flags & IFF_NOLOCAL)) pr->pr_kernel_state |= PR_AUTO; if ((pr->pr_flags & IFF_DEPRECATED) && (pr->pr_kernel_state & PR_AUTO)) pr->pr_kernel_state |= PR_DEPRECATED; if (!(pr->pr_flags & IFF_ADDRCONF)) { /* Prevent ndpd from stepping on this prefix */ pr->pr_kernel_state |= PR_STATIC; } pr->pr_state = pr->pr_kernel_state; /* Adjust pr_prefix_len based if PR_AUTO is set */ if (pr->pr_state & PR_AUTO) { pr->pr_prefix_len = IPV6_ABITS - pr->pr_physical->pi_token_length; prefix_set(&pr->pr_prefix, pr->pr_prefix, pr->pr_prefix_len); } /* Can't extract lifetimes from the kernel - use 1 week */ pr->pr_ValidLifetime = NDP_PREFIX_DEFAULT_LIFETIME; pr->pr_PreferredLifetime = NDP_PREFIX_DEFAULT_LIFETIME; pr->pr_OnLinkLifetime = NDP_PREFIX_DEFAULT_LIFETIME; /* * If this is a temp addr, the creation time needs to be set. * Though it won't be entirely accurate, the current time is * an okay approximation. */ if (pr->pr_flags & IFF_TEMPORARY) pr->pr_CreateTime = getcurrenttime() / MILLISEC; if (pr->pr_kernel_state == 0) pr->pr_name[0] = '\0'; return (0); error: /* Pretend that the prefix does not exist in the kernel */ pr->pr_kernel_state = 0; pr->pr_name[0] = '\0'; return (-1); } /* * Delete (unlink and free) and remove from kernel if the prefix * was added by in.ndpd (i.e. PR_STATIC is not set). * Handles delete of things that have not yet been inserted in the list * i.e. pr_physical is NULL. */ void prefix_delete(struct prefix *pr) { struct phyint *pi; char abuf[INET6_ADDRSTRLEN]; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_delete(%s, %s, %s/%u)\n", pr->pr_physical->pi_name, pr->pr_name, inet_ntop(AF_INET6, (void *)&pr->pr_prefix, abuf, sizeof (abuf)), pr->pr_prefix_len); } /* Remove non-static prefixes from the kernel. */ pr->pr_state &= PR_STATIC; pi = pr->pr_physical; if (pr->pr_kernel_state != pr->pr_state) prefix_update_k(pr); if (pr->pr_prev == NULL) { if (pi != NULL) pi->pi_prefix_list = pr->pr_next; } else { pr->pr_prev->pr_next = pr->pr_next; } if (pr->pr_next != NULL) pr->pr_next->pr_prev = pr->pr_prev; pr->pr_next = pr->pr_prev = NULL; free(pr); } /* * Toggle one or more IFF_ flags for a prefix. Turn on 'onflags' and * turn off 'offflags'. */ static int prefix_modify_flags(struct prefix *pr, uint64_t onflags, uint64_t offflags) { struct lifreq lifr; struct phyint *pi = pr->pr_physical; uint64_t old_flags; char abuf[INET6_ADDRSTRLEN]; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_modify_flags(%s, %s, %s/%u) " "flags %llx on %llx off %llx\n", pr->pr_physical->pi_name, pr->pr_name, inet_ntop(AF_INET6, (void *)&pr->pr_prefix, abuf, sizeof (abuf)), pr->pr_prefix_len, pr->pr_flags, onflags, offflags); } /* Assumes that only the PR_STATIC link-local matches the pi_name */ if (!(pr->pr_state & PR_STATIC) && strcmp(pr->pr_name, pi->pi_name) == 0) { logmsg(LOG_ERR, "prefix_modify_flags(%s, on %llx, off %llx): " "name matches interface name\n", pi->pi_name, onflags, offflags); return (-1); } (void) strncpy(lifr.lifr_name, pr->pr_name, sizeof (lifr.lifr_name)); lifr.lifr_name[sizeof (lifr.lifr_name) - 1] = '\0'; if (ioctl(pi->pi_sock, SIOCGLIFFLAGS, (char *)&lifr) < 0) { logperror_pr(pr, "prefix_modify_flags: SIOCGLIFFLAGS"); logmsg(LOG_ERR, "prefix_modify_flags(%s, %s) old 0x%llx " "on 0x%llx off 0x%llx\n", pr->pr_physical->pi_name, pr->pr_name, pr->pr_flags, onflags, offflags); return (-1); } old_flags = lifr.lifr_flags; lifr.lifr_flags |= onflags; lifr.lifr_flags &= ~offflags; pr->pr_flags = lifr.lifr_flags; if (ioctl(pi->pi_sock, SIOCSLIFFLAGS, (char *)&lifr) < 0) { logperror_pr(pr, "prefix_modify_flags: SIOCSLIFFLAGS"); logmsg(LOG_ERR, "prefix_modify_flags(%s, %s) old 0x%llx " "new 0x%llx on 0x%llx off 0x%llx\n", pr->pr_physical->pi_name, pr->pr_name, old_flags, lifr.lifr_flags, onflags, offflags); return (-1); } return (0); } /* * Make the kernel state match what is in the prefix structure. * This includes creating the prefix (allocating a new interface name) * as well as setting the local address and on-link subnet prefix * and controlling the IFF_ADDRCONF and IFF_DEPRECATED flags. */ void prefix_update_k(struct prefix *pr) { struct lifreq lifr; char abuf[INET6_ADDRSTRLEN]; char buf1[PREFIX_STATESTRLEN], buf2[PREFIX_STATESTRLEN]; struct phyint *pi = pr->pr_physical; struct sockaddr_in6 *sin6; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_update_k(%s, %s, %s/%u) " "from %s to %s\n", pr->pr_physical->pi_name, pr->pr_name, inet_ntop(AF_INET6, (void *)&pr->pr_prefix, abuf, sizeof (abuf)), pr->pr_prefix_len, prefix_print_state(pr->pr_kernel_state, buf1, sizeof (buf1)), prefix_print_state(pr->pr_state, buf2, sizeof (buf2))); } if (pr->pr_kernel_state == pr->pr_state) return; /* No changes */ /* Skip static prefixes */ if (pr->pr_state & PR_STATIC) return; if (pr->pr_kernel_state == 0) { uint64_t onflags; /* * Create a new logical interface name and store in pr_name. * Set IFF_ADDRCONF. Do not set an address (yet). */ if (pr->pr_name[0] != '\0') { /* Name already set! */ logmsg(LOG_ERR, "prefix_update_k(%s, %s, %s/%u) " "from %s to %s name is already allocated\n", pr->pr_physical->pi_name, pr->pr_name, inet_ntop(AF_INET6, (void *)&pr->pr_prefix, abuf, sizeof (abuf)), pr->pr_prefix_len, prefix_print_state(pr->pr_kernel_state, buf1, sizeof (buf1)), prefix_print_state(pr->pr_state, buf2, sizeof (buf2))); return; } (void) strncpy(lifr.lifr_name, pi->pi_name, sizeof (lifr.lifr_name)); lifr.lifr_name[sizeof (lifr.lifr_name) - 1] = '\0'; lifr.lifr_addr.ss_family = AF_UNSPEC; if (ioctl(pi->pi_sock, SIOCLIFADDIF, (char *)&lifr) < 0) { logperror_pr(pr, "prefix_update_k: SIOCLIFADDIF"); return; } (void) strncpy(pr->pr_name, lifr.lifr_name, sizeof (pr->pr_name)); pr->pr_name[sizeof (pr->pr_name) - 1] = '\0'; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_update_k: new name %s\n", pr->pr_name); } /* * The IFF_TEMPORARY flag might have already been set; if * so, it needs to be or'd into the flags we're turning on. * But be careful, we might be re-creating a manually * removed interface, in which case we don't want to try * to set *all* the flags we might have in our copy of the * flags yet. */ onflags = IFF_ADDRCONF; if (pr->pr_flags & IFF_TEMPORARY) onflags |= IFF_TEMPORARY; if (prefix_modify_flags(pr, onflags, 0) == -1) return; } if ((pr->pr_state & (PR_ONLINK|PR_AUTO)) == 0) { /* Remove the interface */ if (prefix_modify_flags(pr, 0, IFF_UP|IFF_DEPRECATED) == -1) return; (void) strncpy(lifr.lifr_name, pr->pr_name, sizeof (lifr.lifr_name)); lifr.lifr_name[sizeof (lifr.lifr_name) - 1] = '\0'; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_update_k: remove name %s\n", pr->pr_name); } /* * Assumes that only the PR_STATIC link-local matches * the pi_name */ if (!(pr->pr_state & PR_STATIC) && strcmp(pr->pr_name, pi->pi_name) == 0) { logmsg(LOG_ERR, "prefix_update_k(%s): " "name matches if\n", pi->pi_name); return; } /* Remove logical interface based on pr_name */ lifr.lifr_addr.ss_family = AF_UNSPEC; if (ioctl(pi->pi_sock, SIOCLIFREMOVEIF, (char *)&lifr) < 0) { logperror_pr(pr, "prefix_update_k: SIOCLIFREMOVEIF"); } pr->pr_kernel_state = 0; pr->pr_name[0] = '\0'; return; } if ((pr->pr_state & PR_AUTO) && !(pr->pr_kernel_state & PR_AUTO)) { /* * Set local address and set the prefix length to 128. * Turn off IFF_NOLOCAL in case it was set. * Turn on IFF_UP. */ (void) strncpy(lifr.lifr_name, pr->pr_name, sizeof (lifr.lifr_name)); lifr.lifr_name[sizeof (lifr.lifr_name) - 1] = '\0'; sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr; bzero(sin6, sizeof (struct sockaddr_in6)); sin6->sin6_family = AF_INET6; sin6->sin6_addr = pr->pr_address; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_update_k(%s) set addr %s " "for PR_AUTO on\n", pr->pr_name, inet_ntop(AF_INET6, (void *)&pr->pr_address, abuf, sizeof (abuf))); } if (ioctl(pi->pi_sock, SIOCSLIFADDR, (char *)&lifr) < 0) { logperror_pr(pr, "prefix_update_k: SIOCSLIFADDR"); return; } if (pr->pr_state & PR_ONLINK) { sin6->sin6_addr = pr->pr_prefix; lifr.lifr_addrlen = pr->pr_prefix_len; } else { sin6->sin6_addr = pr->pr_address; lifr.lifr_addrlen = IPV6_ABITS; } if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_update_k(%s) set subnet " "%s/%u for PR_AUTO on\n", pr->pr_name, inet_ntop(AF_INET6, (void *)&sin6->sin6_addr, abuf, sizeof (abuf)), lifr.lifr_addrlen); } if (ioctl(pi->pi_sock, SIOCSLIFSUBNET, (char *)&lifr) < 0) { logperror_pr(pr, "prefix_update_k: SIOCSLIFSUBNET"); return; } /* * For ptp interfaces, create a destination based on * prefix and prefix len together with the remote token * extracted from the remote pt-pt address. This is used by * ip to choose a proper source for outgoing packets. */ if (pi->pi_flags & IFF_POINTOPOINT) { int i; sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr; bzero(sin6, sizeof (struct sockaddr_in6)); sin6->sin6_family = AF_INET6; sin6->sin6_addr = pr->pr_prefix; for (i = 0; i < 16; i++) { sin6->sin6_addr.s6_addr[i] |= pi->pi_dst_token.s6_addr[i]; } if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_update_k(%s) " "set dstaddr %s for PR_AUTO on\n", pr->pr_name, inet_ntop(AF_INET6, (void *)&sin6->sin6_addr, abuf, sizeof (abuf))); } if (ioctl(pi->pi_sock, SIOCSLIFDSTADDR, (char *)&lifr) < 0) { logperror_pr(pr, "prefix_update_k: SIOCSLIFDSTADDR"); return; } } if (prefix_modify_flags(pr, IFF_UP, IFF_NOLOCAL) == -1) return; pr->pr_kernel_state |= PR_AUTO; if (pr->pr_state & PR_ONLINK) pr->pr_kernel_state |= PR_ONLINK; else pr->pr_kernel_state &= ~PR_ONLINK; } if (!(pr->pr_state & PR_AUTO) && (pr->pr_kernel_state & PR_AUTO)) { /* Turn on IFF_NOLOCAL and set the local address to all zero */ if (prefix_modify_flags(pr, IFF_NOLOCAL, 0) == -1) return; (void) strncpy(lifr.lifr_name, pr->pr_name, sizeof (lifr.lifr_name)); lifr.lifr_name[sizeof (lifr.lifr_name) - 1] = '\0'; sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr; bzero(sin6, sizeof (struct sockaddr_in6)); sin6->sin6_family = AF_INET6; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_update_k(%s) set addr %s " "for PR_AUTO off\n", pr->pr_name, inet_ntop(AF_INET6, (void *)&sin6->sin6_addr, abuf, sizeof (abuf))); } if (ioctl(pi->pi_sock, SIOCSLIFADDR, (char *)&lifr) < 0) { logperror_pr(pr, "prefix_update_k: SIOCSLIFADDR"); return; } pr->pr_kernel_state &= ~PR_AUTO; } if ((pr->pr_state & PR_DEPRECATED) && !(pr->pr_kernel_state & PR_DEPRECATED) && (pr->pr_kernel_state & PR_AUTO)) { /* Only applies if PR_AUTO */ if (prefix_modify_flags(pr, IFF_DEPRECATED, 0) == -1) return; pr->pr_kernel_state |= PR_DEPRECATED; } if (!(pr->pr_state & PR_DEPRECATED) && (pr->pr_kernel_state & PR_DEPRECATED)) { if (prefix_modify_flags(pr, 0, IFF_DEPRECATED) == -1) return; pr->pr_kernel_state &= ~PR_DEPRECATED; } if ((pr->pr_state & PR_ONLINK) && !(pr->pr_kernel_state & PR_ONLINK)) { /* Set the subnet and set IFF_UP */ (void) strncpy(lifr.lifr_name, pr->pr_name, sizeof (lifr.lifr_name)); lifr.lifr_name[sizeof (lifr.lifr_name) - 1] = '\0'; sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr; bzero(sin6, sizeof (struct sockaddr_in6)); sin6->sin6_family = AF_INET6; sin6->sin6_addr = pr->pr_prefix; lifr.lifr_addrlen = pr->pr_prefix_len; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_update_k(%s) set subnet " "%s/%d for PR_ONLINK on\n", pr->pr_name, inet_ntop(AF_INET6, (void *)&sin6->sin6_addr, abuf, sizeof (abuf)), lifr.lifr_addrlen); } if (ioctl(pi->pi_sock, SIOCSLIFSUBNET, (char *)&lifr) < 0) { logperror_pr(pr, "prefix_update_k: SIOCSLIFSUBNET"); return; } if (!(pr->pr_state & PR_AUTO)) { if (prefix_modify_flags(pr, IFF_NOLOCAL, 0) == -1) return; } if (prefix_modify_flags(pr, IFF_UP, 0) == -1) return; pr->pr_kernel_state |= PR_ONLINK; } if (!(pr->pr_state & PR_ONLINK) && (pr->pr_kernel_state & PR_ONLINK)) { /* Set the prefixlen to 128 */ (void) strncpy(lifr.lifr_name, pr->pr_name, sizeof (lifr.lifr_name)); lifr.lifr_name[sizeof (lifr.lifr_name) - 1] = '\0'; sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr; bzero(sin6, sizeof (struct sockaddr_in6)); sin6->sin6_family = AF_INET6; sin6->sin6_addr = pr->pr_address; lifr.lifr_addrlen = IPV6_ABITS; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "prefix_update_k(%s) set subnet " "%s/%d for PR_ONLINK off\n", pr->pr_name, inet_ntop(AF_INET6, (void *)&sin6->sin6_addr, abuf, sizeof (abuf)), lifr.lifr_addrlen); } if (ioctl(pi->pi_sock, SIOCSLIFSUBNET, (char *)&lifr) < 0) { logperror_pr(pr, "prefix_update_k: SIOCSLIFSUBNET"); return; } pr->pr_kernel_state &= ~PR_ONLINK; } } /* * Called with the number of millseconds elapsed since the last call. * Determines if any timeout event has occurred and * returns the number of milliseconds until the next timeout event. * Returns TIMER_INFINITY for "never". */ uint_t prefix_timer(struct prefix *pr, uint_t elapsed) { uint_t next = TIMER_INFINITY; char abuf[INET6_ADDRSTRLEN]; if (debug & (D_PREFIX|D_TMP)) { logmsg(LOG_DEBUG, "prefix_timer(%s, %s/%u, %d) " "valid %d pref %d onlink %d\n", pr->pr_name, inet_ntop(AF_INET6, (void *)&pr->pr_prefix, abuf, sizeof (abuf)), pr->pr_prefix_len, elapsed, pr->pr_ValidLifetime, pr->pr_PreferredLifetime, pr->pr_OnLinkLifetime); } /* Exclude static prefixes */ if (pr->pr_state & PR_STATIC) return (next); if (pr->pr_AutonomousFlag && (pr->pr_PreferredLifetime != PREFIX_INFINITY)) { if (pr->pr_PreferredLifetime <= elapsed) { pr->pr_PreferredLifetime = 0; } else { pr->pr_PreferredLifetime -= elapsed; if (pr->pr_PreferredLifetime < next) next = pr->pr_PreferredLifetime; } } if (pr->pr_AutonomousFlag && (pr->pr_ValidLifetime != PREFIX_INFINITY)) { if (pr->pr_ValidLifetime <= elapsed) { pr->pr_ValidLifetime = 0; } else { pr->pr_ValidLifetime -= elapsed; if (pr->pr_ValidLifetime < next) next = pr->pr_ValidLifetime; } } if (pr->pr_OnLinkFlag && (pr->pr_OnLinkLifetime != PREFIX_INFINITY)) { if (pr->pr_OnLinkLifetime <= elapsed) { pr->pr_OnLinkLifetime = 0; } else { pr->pr_OnLinkLifetime -= elapsed; if (pr->pr_OnLinkLifetime < next) next = pr->pr_OnLinkLifetime; } } if (pr->pr_AutonomousFlag && pr->pr_ValidLifetime == 0) pr->pr_state &= ~(PR_AUTO|PR_DEPRECATED); if (pr->pr_AutonomousFlag && pr->pr_PreferredLifetime == 0 && (pr->pr_state & PR_AUTO)) { pr->pr_state |= PR_DEPRECATED; if (debug & D_TMP) logmsg(LOG_WARNING, "prefix_timer: deprecated " "prefix(%s)\n", pr->pr_name); } if (pr->pr_OnLinkFlag && pr->pr_OnLinkLifetime == 0) pr->pr_state &= ~PR_ONLINK; if (pr->pr_state != pr->pr_kernel_state) { /* Might cause prefix to be deleted! */ /* 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 timeout %s\n", inet_ntop(AF_INET6, (void *)&pr->pr_address, abuf, sizeof (abuf))); } prefix_update_k(pr); } return (next); } static char * prefix_print_state(int state, char *buf, int buflen) { char *cp; int cplen = buflen; cp = buf; cp[0] = '\0'; if (state & PR_ONLINK) { if (strlcat(cp, "ONLINK ", cplen) >= cplen) return (buf); cp += strlen(cp); cplen = buflen - (cp - buf); } if (state & PR_AUTO) { if (strlcat(cp, "AUTO ", cplen) >= cplen) return (buf); cp += strlen(cp); cplen = buflen - (cp - buf); } if (state & PR_DEPRECATED) { if (strlcat(cp, "DEPRECATED ", cplen) >= cplen) return (buf); cp += strlen(cp); cplen = buflen - (cp - buf); } if (state & PR_STATIC) { if (strlcat(cp, "STATIC ", cplen) >= cplen) return (buf); cp += strlen(cp); cplen = buflen - (cp - buf); } return (buf); } static void prefix_print(struct prefix *pr) { char abuf[INET6_ADDRSTRLEN]; char buf1[PREFIX_STATESTRLEN], buf2[PREFIX_STATESTRLEN]; logmsg(LOG_DEBUG, "Prefix name: %s prefix %s/%u state %s " "kernel_state %s\n", pr->pr_name, inet_ntop(AF_INET6, (void *)&pr->pr_prefix, abuf, sizeof (abuf)), pr->pr_prefix_len, prefix_print_state(pr->pr_state, buf2, sizeof (buf2)), prefix_print_state(pr->pr_kernel_state, buf1, sizeof (buf1))); logmsg(LOG_DEBUG, "\tAddress: %s flags %llx in_use %d\n", inet_ntop(AF_INET6, (void *)&pr->pr_address, abuf, sizeof (abuf)), pr->pr_flags, pr->pr_in_use); logmsg(LOG_DEBUG, "\tValidLifetime %u PreferredLifetime %u " "OnLinkLifetime %u\n", pr->pr_ValidLifetime, pr->pr_PreferredLifetime, pr->pr_OnLinkLifetime); logmsg(LOG_DEBUG, "\tOnLink %d Auto %d\n", pr->pr_OnLinkFlag, pr->pr_AutonomousFlag); logmsg(LOG_DEBUG, "\n"); } /* * Does the address formed by pr->pr_prefix and pi->pi_token match * pr->pr_address. It does not match if a failover has happened * earlier (done by in.mpathd) from a different pi. Should not * be called for onlink prefixes. */ boolean_t prefix_token_match(struct phyint *pi, struct prefix *pr, uint64_t flags) { int i; in6_addr_t addr, *token; if (flags & IFF_TEMPORARY) token = &pi->pi_tmp_token; else token = &pi->pi_token; for (i = 0; i < 16; i++) { /* * prefix_create ensures that pr_prefix has all-zero * bits after prefixlen. */ addr.s6_addr[i] = pr->pr_prefix.s6_addr[i] | token->s6_addr[i]; } if (IN6_ARE_ADDR_EQUAL(&pr->pr_address, &addr)) { return (_B_TRUE); } else { return (_B_FALSE); } } /* * Lookup advertisement prefix structure that matches the prefix and * prefix length. * Assumes that the bits after prefixlen might not be zero. */ struct adv_prefix * adv_prefix_lookup(struct phyint *pi, struct in6_addr prefix, int prefixlen) { struct adv_prefix *adv_pr; char abuf[INET6_ADDRSTRLEN]; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "adv_prefix_lookup(%s, %s/%u)\n", pi->pi_name, inet_ntop(AF_INET6, (void *)&prefix, abuf, sizeof (abuf)), prefixlen); } for (adv_pr = pi->pi_adv_prefix_list; adv_pr != NULL; adv_pr = adv_pr->adv_pr_next) { if (adv_pr->adv_pr_prefix_len == prefixlen && prefix_equal(prefix, adv_pr->adv_pr_prefix, prefixlen)) return (adv_pr); } return (NULL); } /* * Initialize a new advertisement prefix. */ struct adv_prefix * adv_prefix_create(struct phyint *pi, struct in6_addr prefix, int prefixlen) { struct adv_prefix *adv_pr; char abuf[INET6_ADDRSTRLEN]; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "adv_prefix_create(%s, %s/%u)\n", pi->pi_name, inet_ntop(AF_INET6, (void *)&prefix, abuf, sizeof (abuf)), prefixlen); } adv_pr = (struct adv_prefix *)calloc(sizeof (struct adv_prefix), 1); if (adv_pr == NULL) { logmsg(LOG_ERR, "adv_prefix_create: calloc\n"); return (NULL); } /* * The prefix might have non-zero bits after the prefix len bits. * Force them to be zero. */ prefix_set(&adv_pr->adv_pr_prefix, prefix, prefixlen); adv_pr->adv_pr_prefix_len = prefixlen; adv_prefix_insert(pi, adv_pr); return (adv_pr); } /* Insert in linked list */ static void adv_prefix_insert(struct phyint *pi, struct adv_prefix *adv_pr) { adv_pr->adv_pr_next = pi->pi_adv_prefix_list; adv_pr->adv_pr_prev = NULL; if (pi->pi_adv_prefix_list != NULL) pi->pi_adv_prefix_list->adv_pr_prev = adv_pr; pi->pi_adv_prefix_list = adv_pr; adv_pr->adv_pr_physical = pi; } /* * Delete (unlink and free) from our tables. There should be * a corresponding "struct prefix *" which will clean up the kernel * if necessary. adv_prefix is just used for sending out advertisements. */ static void adv_prefix_delete(struct adv_prefix *adv_pr) { struct phyint *pi; char abuf[INET6_ADDRSTRLEN]; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "adv_prefix_delete(%s, %s/%u)\n", adv_pr->adv_pr_physical->pi_name, inet_ntop(AF_INET6, (void *)&adv_pr->adv_pr_prefix, abuf, sizeof (abuf)), adv_pr->adv_pr_prefix_len); } pi = adv_pr->adv_pr_physical; if (adv_pr->adv_pr_prev == NULL) { if (pi != NULL) pi->pi_adv_prefix_list = adv_pr->adv_pr_next; } else { adv_pr->adv_pr_prev->adv_pr_next = adv_pr->adv_pr_next; } if (adv_pr->adv_pr_next != NULL) adv_pr->adv_pr_next->adv_pr_prev = adv_pr->adv_pr_prev; adv_pr->adv_pr_next = adv_pr->adv_pr_prev = NULL; free(adv_pr); } /* * Called with the number of millseconds elapsed since the last call. * Determines if any timeout event has occurred and * returns the number of milliseconds until the next timeout event. * Returns TIMER_INFINITY for "never". */ uint_t adv_prefix_timer(struct adv_prefix *adv_pr, uint_t elapsed) { int seconds_elapsed = (elapsed + 500) / 1000; /* Rounded */ char abuf[INET6_ADDRSTRLEN]; if (debug & D_PREFIX) { logmsg(LOG_DEBUG, "adv_prefix_timer(%s, %s/%u, %d)\n", adv_pr->adv_pr_physical->pi_name, inet_ntop(AF_INET6, (void *)&adv_pr->adv_pr_prefix, abuf, sizeof (abuf)), adv_pr->adv_pr_prefix_len, elapsed); } /* Decrement Expire time left for real-time lifetimes */ if (adv_pr->adv_pr_AdvValidRealTime) { if (adv_pr->adv_pr_AdvValidExpiration > seconds_elapsed) adv_pr->adv_pr_AdvValidExpiration -= seconds_elapsed; else adv_pr->adv_pr_AdvValidExpiration = 0; } if (adv_pr->adv_pr_AdvPreferredRealTime) { if (adv_pr->adv_pr_AdvPreferredExpiration > seconds_elapsed) { adv_pr->adv_pr_AdvPreferredExpiration -= seconds_elapsed; } else { adv_pr->adv_pr_AdvPreferredExpiration = 0; } } return (TIMER_INFINITY); } static void adv_prefix_print(struct adv_prefix *adv_pr) { print_prefixlist(adv_pr->adv_pr_config); } /* Lookup router on its link-local IPv6 address */ struct router * router_lookup(struct phyint *pi, struct in6_addr addr) { struct router *dr; char abuf[INET6_ADDRSTRLEN]; if (debug & D_ROUTER) { logmsg(LOG_DEBUG, "router_lookup(%s, %s)\n", pi->pi_name, inet_ntop(AF_INET6, (void *)&addr, abuf, sizeof (abuf))); } for (dr = pi->pi_router_list; dr != NULL; dr = dr->dr_next) { if (bcmp((char *)&addr, (char *)&dr->dr_address, sizeof (addr)) == 0) return (dr); } return (NULL); } /* * Create a default router entry. * The lifetime parameter is in seconds. */ struct router * router_create(struct phyint *pi, struct in6_addr addr, uint_t lifetime) { struct router *dr; char abuf[INET6_ADDRSTRLEN]; if (debug & D_ROUTER) { logmsg(LOG_DEBUG, "router_create(%s, %s, %u)\n", pi->pi_name, inet_ntop(AF_INET6, (void *)&addr, abuf, sizeof (abuf)), lifetime); } dr = (struct router *)calloc(sizeof (struct router), 1); if (dr == NULL) { logmsg(LOG_ERR, "router_create: out of memory\n"); return (NULL); } dr->dr_address = addr; dr->dr_lifetime = lifetime; router_insert(pi, dr); if (dr->dr_lifetime != 0) { /* * Delete an onlink default if it exists since we now have * at least one default router. */ if (pi->pi_onlink_default) router_delete_onlink(dr->dr_physical); router_add_k(dr); } return (dr); } /* Insert in linked list */ static void router_insert(struct phyint *pi, struct router *dr) { dr->dr_next = pi->pi_router_list; dr->dr_prev = NULL; if (pi->pi_router_list != NULL) pi->pi_router_list->dr_prev = dr; pi->pi_router_list = dr; dr->dr_physical = pi; } /* * Delete (unlink and free). * Handles delete of things that have not yet been inserted in the list * i.e. dr_physical is NULL. */ static void router_delete(struct router *dr) { struct phyint *pi; char abuf[INET6_ADDRSTRLEN]; if (debug & D_ROUTER) { logmsg(LOG_DEBUG, "router_delete(%s, %s, %u)\n", dr->dr_physical->pi_name, inet_ntop(AF_INET6, (void *)&dr->dr_address, abuf, sizeof (abuf)), dr->dr_lifetime); } pi = dr->dr_physical; if (dr->dr_inkernel) { /* * Create a on-link default route only if the interface * is present in the kernel. This function is called * to clean up the routes when the interface is * unplumbed. In that case, don't try to create one * in the kernel. */ if (pi->pi_kernel_state & PI_PRESENT) { if (!dr->dr_onlink && dr->dr_physical->pi_num_k_routers == 1) { (void) router_create_onlink(dr->dr_physical); } router_delete_k(dr); } } if (dr->dr_onlink) pi->pi_onlink_default = _B_FALSE; if (dr->dr_prev == NULL) { if (pi != NULL) pi->pi_router_list = dr->dr_next; } else { dr->dr_prev->dr_next = dr->dr_next; } if (dr->dr_next != NULL) dr->dr_next->dr_prev = dr->dr_prev; dr->dr_next = dr->dr_prev = NULL; free(dr); } /* Create an onlink default route */ struct router * router_create_onlink(struct phyint *pi) { struct router *dr; struct prefix *pr; if (debug & D_ROUTER) { logmsg(LOG_DEBUG, "router_create_onlink(%s)\n", pi->pi_name); } if (pi->pi_onlink_default) { logmsg(LOG_ERR, "router_create_onlink: already an onlink " "default: %s\n", pi->pi_name); return (NULL); } /* * Find the interface address to use for the route gateway. * We need to use the link-local since the others ones might be * deleted when the prefixes get invalidated. */ for (pr = pi->pi_prefix_list; pr != NULL; pr = pr->pr_next) { if ((pr->pr_state & PR_AUTO) && IN6_IS_ADDR_LINKLOCAL(&pr->pr_address)) break; } if (pr == NULL) { logmsg(LOG_ERR, "router_create_onlink: no source address\n"); return (NULL); } dr = (struct router *)calloc(sizeof (struct router), 1); if (dr == NULL) { logmsg(LOG_ERR, "router_create_onlink: out of memory\n"); return (NULL); } dr->dr_address = pr->pr_address; dr->dr_lifetime = 1; /* Not used */ dr->dr_onlink = _B_TRUE; router_insert(pi, dr); router_add_k(dr); pi->pi_onlink_default = _B_TRUE; return (dr); } /* Remove an onlink default route */ static void router_delete_onlink(struct phyint *pi) { struct router *dr, *next_dr; if (debug & D_ROUTER) { logmsg(LOG_DEBUG, "router_delete_onlink(%s)\n", pi->pi_name); } if (!pi->pi_onlink_default) { logmsg(LOG_ERR, "router_delete_onlink: no onlink default: " "%s\n", pi->pi_name); return; } /* Find all onlink routes */ for (dr = pi->pi_router_list; dr != NULL; dr = next_dr) { next_dr = dr->dr_next; if (dr->dr_onlink) router_delete(dr); } } /* * Update the kernel to match dr_lifetime */ void router_update_k(struct router *dr) { char abuf[INET6_ADDRSTRLEN]; if (debug & D_ROUTER) { logmsg(LOG_DEBUG, "router_update_k(%s, %s, %u)\n", dr->dr_physical->pi_name, inet_ntop(AF_INET6, (void *)&dr->dr_address, abuf, sizeof (abuf)), dr->dr_lifetime); } if (dr->dr_lifetime == 0 && dr->dr_inkernel) { /* Log a message when last router goes away */ if (dr->dr_physical->pi_num_k_routers == 1) { logmsg(LOG_WARNING, "Last default router (%s) removed on %s\n", inet_ntop(AF_INET6, (void *)&dr->dr_address, abuf, sizeof (abuf)), dr->dr_physical->pi_name); } router_delete(dr); } else if (dr->dr_lifetime != 0 && !dr->dr_inkernel) { /* * Delete an onlink default if it exists since we now have * at least one default router. */ if (dr->dr_physical->pi_onlink_default) router_delete_onlink(dr->dr_physical); router_add_k(dr); } } /* * Called with the number of millseconds elapsed since the last call. * Determines if any timeout event has occurred and * returns the number of milliseconds until the next timeout event. * Returns TIMER_INFINITY for "never". */ uint_t router_timer(struct router *dr, uint_t elapsed) { uint_t next = TIMER_INFINITY; char abuf[INET6_ADDRSTRLEN]; if (debug & D_ROUTER) { logmsg(LOG_DEBUG, "router_timer(%s, %s, %u, %d)\n", dr->dr_physical->pi_name, inet_ntop(AF_INET6, (void *)&dr->dr_address, abuf, sizeof (abuf)), dr->dr_lifetime, elapsed); } if (dr->dr_onlink) { /* No timeout */ return (next); } if (dr->dr_lifetime <= elapsed) { dr->dr_lifetime = 0; } else { dr->dr_lifetime -= elapsed; if (dr->dr_lifetime < next) next = dr->dr_lifetime; } if (dr->dr_lifetime == 0) { /* Log a message when last router goes away */ if (dr->dr_physical->pi_num_k_routers == 1) { logmsg(LOG_WARNING, "Last default router (%s) timed out on %s\n", inet_ntop(AF_INET6, (void *)&dr->dr_address, abuf, sizeof (abuf)), dr->dr_physical->pi_name); } router_delete(dr); } return (next); } /* * Add a default route to the kernel (unless the lifetime is zero) * Handles onlink default routes. */ static void router_add_k(struct router *dr) { struct phyint *pi = dr->dr_physical; char abuf[INET6_ADDRSTRLEN]; int rlen; if (debug & D_ROUTER) { logmsg(LOG_DEBUG, "router_add_k(%s, %s, %u)\n", dr->dr_physical->pi_name, inet_ntop(AF_INET6, (void *)&dr->dr_address, abuf, sizeof (abuf)), dr->dr_lifetime); } if (dr->dr_onlink) rt_msg->rtm_flags = 0; else rt_msg->rtm_flags = RTF_GATEWAY; rta_gateway->sin6_addr = dr->dr_address; rta_ifp->sdl_index = if_nametoindex(pi->pi_name); if (rta_ifp->sdl_index == 0) { logperror_pi(pi, "router_add_k: if_nametoindex"); return; } rt_msg->rtm_type = RTM_ADD; rt_msg->rtm_seq = ++rtmseq; rlen = write(rtsock, rt_msg, rt_msg->rtm_msglen); if (rlen < 0) { if (errno != EEXIST) { logperror_pi(pi, "router_add_k: RTM_ADD"); return; } } else if (rlen < rt_msg->rtm_msglen) { logmsg(LOG_ERR, "router_add_k: write to routing socket got " "only %d for rlen (interface %s)\n", rlen, pi->pi_name); return; } dr->dr_inkernel = _B_TRUE; if (!dr->dr_onlink) pi->pi_num_k_routers++; } /* * Delete a route from the kernel. * Handles onlink default routes. */ static void router_delete_k(struct router *dr) { struct phyint *pi = dr->dr_physical; char abuf[INET6_ADDRSTRLEN]; int rlen; if (debug & D_ROUTER) { logmsg(LOG_DEBUG, "router_delete_k(%s, %s, %u)\n", dr->dr_physical->pi_name, inet_ntop(AF_INET6, (void *)&dr->dr_address, abuf, sizeof (abuf)), dr->dr_lifetime); } if (dr->dr_onlink) rt_msg->rtm_flags = 0; else rt_msg->rtm_flags = RTF_GATEWAY; rta_gateway->sin6_addr = dr->dr_address; rta_ifp->sdl_index = if_nametoindex(pi->pi_name); if (rta_ifp->sdl_index == 0) { logperror_pi(pi, "router_delete_k: if_nametoindex"); return; } rt_msg->rtm_type = RTM_DELETE; rt_msg->rtm_seq = ++rtmseq; rlen = write(rtsock, rt_msg, rt_msg->rtm_msglen); if (rlen < 0) { if (errno != ESRCH) { logperror_pi(pi, "router_delete_k: RTM_DELETE"); } } else if (rlen < rt_msg->rtm_msglen) { logmsg(LOG_ERR, "router_delete_k: write to routing socket got " "only %d for rlen (interface %s)\n", rlen, pi->pi_name); } dr->dr_inkernel = _B_FALSE; if (!dr->dr_onlink) pi->pi_num_k_routers--; } static void router_print(struct router *dr) { char abuf[INET6_ADDRSTRLEN]; logmsg(LOG_DEBUG, "Router %s on %s inkernel %d onlink %d lifetime %u\n", inet_ntop(AF_INET6, (void *)&dr->dr_address, abuf, sizeof (abuf)), dr->dr_physical->pi_name, dr->dr_inkernel, dr->dr_onlink, dr->dr_lifetime); } void phyint_print_all(void) { struct phyint *pi; for (pi = phyints; pi != NULL; pi = pi->pi_next) { phyint_print(pi); } } void phyint_cleanup(pi) struct phyint *pi; { pi->pi_state = 0; pi->pi_kernel_state = 0; if (pi->pi_AdvSendAdvertisements) { check_to_advertise(pi, ADV_OFF); } else { check_to_solicit(pi, SOLICIT_OFF); } while (pi->pi_router_list) router_delete(pi->pi_router_list); (void) poll_remove(pi->pi_sock); (void) close(pi->pi_sock); pi->pi_sock = -1; }