/*
 * 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 2008 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 <time.h>
#include <assert.h>

struct phyint *phyints = NULL;
int num_of_phyints = 0;

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 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) {
		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;
	num_of_phyints++;
}

/*
 * 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
	 * IFF_NOLOCAL flag is set, then ignore the interface.
	 */
	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): "
			    "IFF_NOLOCAL or not IFF_UP\n", pi->pi_name);
		}
		return (0);
	}
	pi->pi_kernel_state |= PI_PRESENT;

	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';
	lifr.lifr_ifinfo.lir_maxhops = pi->pi_CurHopLimit;
	lifr.lifr_ifinfo.lir_reachtime = pi->pi_ReachableTime;
	lifr.lifr_ifinfo.lir_reachretrans = pi->pi_RetransTimer;
	/* Setting maxmtu to 0 means that we're leaving the MTU alone */
	lifr.lifr_ifinfo.lir_maxmtu = 0;
	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);

	assert(num_of_phyints > 0);

	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;
	free(pi);
	num_of_phyints--;
}

/*
 * Called 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 phyint itself (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, "
	    "num routers %d\n",
	    pi->pi_name, pi->pi_index, pi->pi_state, pi->pi_kernel_state,
	    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 cannot derive the lifetime from
 * the kernel, thus it is set to 1 week.
 * Ignore the prefix if the interface is not IFF_UP.
 * If it's from DHCPv6, then we set the netmask.
 */
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 this is a DHCPv6 interface, then we control the netmask.
	 */
	if (lifr.lifr_flags & IFF_DHCPRUNNING) {
		struct phyint *pi = pr->pr_physical;
		struct prefix *pr2;

		pr->pr_prefix_len = IPV6_ABITS;
		if (!(lifr.lifr_flags & IFF_UP) ||
		    IN6_IS_ADDR_UNSPECIFIED(&pr->pr_address) ||
		    IN6_IS_ADDR_LINKLOCAL(&pr->pr_address)) {
			if (debug & D_DHCP)
				logmsg(LOG_DEBUG, "prefix_init_from_k: "
				    "ignoring DHCP %s not ready\n",
				    pr->pr_name);
			return (0);
		}

		for (pr2 = pi->pi_prefix_list; pr2 != NULL;
		    pr2 = pr2->pr_next) {
			/*
			 * Examine any non-static (autoconfigured) prefixes as
			 * well as existing DHCP-controlled prefixes for valid
			 * prefix length information.
			 */
			if (pr2->pr_prefix_len != IPV6_ABITS &&
			    (!(pr2->pr_state & PR_STATIC) ||
			    (pr2->pr_flags & IFF_DHCPRUNNING)) &&
			    prefix_equal(pr->pr_prefix, pr2->pr_prefix,
			    pr2->pr_prefix_len)) {
				pr->pr_prefix_len = pr2->pr_prefix_len;
				break;
			}
		}
		if (pr2 == NULL) {
			if (debug & D_DHCP)
				logmsg(LOG_DEBUG, "prefix_init_from_k: no "
				    "saved mask for DHCP %s; need to "
				    "resolicit\n", pr->pr_name);
			(void) check_to_solicit(pi, RESTART_INIT_SOLICIT);
		} else {
			if (debug & D_DHCP)
				logmsg(LOG_DEBUG, "prefix_init_from_k: using "
				    "%s mask for DHCP %s\n",
				    pr2->pr_name[0] == '\0' ? "saved" :
				    pr2->pr_name, pr->pr_name);
			prefix_update_dhcp(pr);
		}
	} else {
		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, "ignoring 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 | IFF_DHCPRUNNING)))
		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);
}

/*
 * Update the subnet mask for this interface under DHCPv6 control.
 */
void
prefix_update_dhcp(struct prefix *pr)
{
	struct lifreq lifr;

	(void) memset(&lifr, 0, sizeof (lifr));
	(void) strlcpy(lifr.lifr_name, pr->pr_name, sizeof (lifr.lifr_name));
	lifr.lifr_addr.ss_family = AF_INET6;
	prefix_set(&((struct sockaddr_in6 *)&lifr.lifr_addr)->sin6_addr,
	    pr->pr_address, pr->pr_prefix_len);
	lifr.lifr_addrlen = pr->pr_prefix_len;
	/*
	 * Ignore ENXIO, as the dhcpagent process is responsible for plumbing
	 * and unplumbing these.
	 */
	if (ioctl(pr->pr_physical->pi_sock, SIOCSLIFSUBNET, (char *)&lifr) ==
	    -1 && errno != ENXIO)
		logperror_pr(pr, "prefix_update_dhcp: ioctl (set subnet)");
}

/*
 * 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 we've previously marked the interface "up" while
		 * processing the PR_AUTO flag -- via incoming_prefix_addrconf
		 * -- then there's no need to set it "up" again.  We're done;
		 * just set PR_ONLINK to indicate that we've set the subnet.
		 */
		if (!(pr->pr_state & PR_AUTO) &&
		    prefix_modify_flags(pr, IFF_UP | IFF_NOLOCAL, 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)
		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 && (pi->pi_kernel_state & PI_PRESENT))
		router_delete_k(dr);

	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);
}

/*
 * 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)
		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_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);
	}

	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_flags = RTF_GATEWAY;
	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;
	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);
	}

	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_flags = RTF_GATEWAY;
	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;
	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 lifetime %u\n",
	    inet_ntop(AF_INET6, (void *)&dr->dr_address, abuf, sizeof (abuf)),
	    dr->dr_physical->pi_name, dr->dr_inkernel, 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;
}