xref: /xnu-10063.141.1/bsd/net/route.c (revision d8b80295118ef25ac3a784134bcf95cd8e88109f)

/*
 * Copyright (c) 2000-2023 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * Copyright (c) 1980, 1986, 1991, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	@(#)route.c	8.2 (Berkeley) 11/15/93
 * $FreeBSD: src/sys/net/route.c,v 1.59.2.3 2001/07/29 19:18:02 ume Exp $
 */

#include <sys/param.h>
#include <sys/sysctl.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/domain.h>
#include <sys/stat.h>
#include <sys/ubc.h>
#include <sys/vnode.h>
#include <sys/syslog.h>
#include <sys/queue.h>
#include <sys/mcache.h>
#include <sys/priv.h>
#include <sys/protosw.h>
#include <sys/sdt.h>
#include <sys/kernel.h>
#include <kern/locks.h>
#include <kern/zalloc.h>

#include <net/dlil.h>
#include <net/if.h>
#include <net/route.h>
#include <net/ntstat.h>
#include <net/nwk_wq.h>
#if NECP
#include <net/necp.h>
#endif /* NECP */

#include <netinet/in.h>
#include <netinet/in_var.h>
#include <netinet/ip_var.h>
#include <netinet/ip.h>
#include <netinet/ip6.h>
#include <netinet/in_arp.h>

#include <netinet6/ip6_var.h>
#include <netinet6/in6_var.h>
#include <netinet6/nd6.h>

#include <net/if_dl.h>

#include <net/sockaddr_utils.h>

#include <libkern/OSAtomic.h>
#include <libkern/OSDebug.h>

#include <pexpert/pexpert.h>

#if CONFIG_MACF
#include <sys/kauth.h>
#endif

#include <sys/constrained_ctypes.h>

/*
 * Synchronization notes:
 *
 * Routing entries fall under two locking domains: the global routing table
 * lock (rnh_lock) and the per-entry lock (rt_lock); the latter is a mutex that
 * resides (statically defined) in the rtentry structure.
 *
 * The locking domains for routing are defined as follows:
 *
 * The global routing lock is used to serialize all accesses to the radix
 * trees defined by rt_tables[], as well as the tree of masks.  This includes
 * lookups, insertions and removals of nodes to/from the respective tree.
 * It is also used to protect certain fields in the route entry that aren't
 * often modified and/or require global serialization (more details below.)
 *
 * The per-route entry lock is used to serialize accesses to several routing
 * entry fields (more details below.)  Acquiring and releasing this lock is
 * done via RT_LOCK() and RT_UNLOCK() routines.
 *
 * In cases where both rnh_lock and rt_lock must be held, the former must be
 * acquired first in order to maintain lock ordering.  It is not a requirement
 * that rnh_lock be acquired first before rt_lock, but in case both must be
 * acquired in succession, the correct lock ordering must be followed.
 *
 * The fields of the rtentry structure are protected in the following way:
 *
 * rt_nodes[]
 *
 *	- Routing table lock (rnh_lock).
 *
 * rt_parent, rt_mask, rt_llinfo_free, rt_tree_genid
 *
 *	- Set once during creation and never changes; no locks to read.
 *
 * rt_flags, rt_genmask, rt_llinfo, rt_rmx, rt_refcnt, rt_gwroute
 *
 *	- Routing entry lock (rt_lock) for read/write access.
 *
 *	- Some values of rt_flags are either set once at creation time,
 *	  or aren't currently used, and thus checking against them can
 *	  be done without rt_lock: RTF_GATEWAY, RTF_HOST, RTF_DYNAMIC,
 *	  RTF_DONE,  RTF_XRESOLVE, RTF_STATIC, RTF_BLACKHOLE, RTF_ANNOUNCE,
 *	  RTF_USETRAILERS, RTF_WASCLONED, RTF_PINNED, RTF_LOCAL,
 *	  RTF_BROADCAST, RTF_MULTICAST, RTF_IFSCOPE, RTF_IFREF.
 *
 * rt_key, rt_gateway, rt_ifp, rt_ifa
 *
 *	- Always written/modified with both rnh_lock and rt_lock held.
 *
 *	- May be read freely with rnh_lock held, else must hold rt_lock
 *	  for read access; holding both locks for read is also okay.
 *
 *	- In the event rnh_lock is not acquired, or is not possible to be
 *	  acquired across the operation, setting RTF_CONDEMNED on a route
 *	  entry will prevent its rt_key, rt_gateway, rt_ifp and rt_ifa
 *	  from being modified.  This is typically done on a route that
 *	  has been chosen for a removal (from the tree) prior to dropping
 *	  the rt_lock, so that those values will remain the same until
 *	  the route is freed.
 *
 *	  When rnh_lock is held rt_setgate(), rt_setif(), and rtsetifa() are
 *	  single-threaded, thus exclusive.  This flag will also prevent the
 *	  route from being looked up via rt_lookup().
 *
 * rt_genid
 *
 *	- Assumes that 32-bit writes are atomic; no locks.
 *
 * rt_dlt, rt_output
 *
 *	- Currently unused; no locks.
 *
 * Operations on a route entry can be described as follows:
 *
 * CREATE an entry with reference count set to 0 as part of RTM_ADD/RESOLVE.
 *
 * INSERTION of an entry into the radix tree holds the rnh_lock, checks
 * for duplicates and then adds the entry.  rtrequest returns the entry
 * after bumping up the reference count to 1 (for the caller).
 *
 * LOOKUP of an entry holds the rnh_lock and bumps up the reference count
 * before returning; it is valid to also bump up the reference count using
 * RT_ADDREF after the lookup has returned an entry.
 *
 * REMOVAL of an entry from the radix tree holds the rnh_lock, removes the
 * entry but does not decrement the reference count.  Removal happens when
 * the route is explicitly deleted (RTM_DELETE) or when it is in the cached
 * state and it expires.  The route is said to be "down" when it is no
 * longer present in the tree.  Freeing the entry will happen on the last
 * reference release of such a "down" route.
 *
 * RT_ADDREF/RT_REMREF operates on the routing entry which increments/
 * decrements the reference count, rt_refcnt, atomically on the rtentry.
 * rt_refcnt is modified only using this routine.  The general rule is to
 * do RT_ADDREF in the function that is passing the entry as an argument,
 * in order to prevent the entry from being freed by the callee.
 */
extern void kdp_set_gateway_mac(void *gatewaymac);

__private_extern__ struct rtstat rtstat  = {
	.rts_badredirect = 0,
	.rts_dynamic = 0,
	.rts_newgateway = 0,
	.rts_unreach = 0,
	.rts_wildcard = 0,
	.rts_badrtgwroute = 0
};
struct radix_node_head *rt_tables[AF_MAX + 1];

static LCK_GRP_DECLARE(rnh_lock_grp, "route");
LCK_MTX_DECLARE(rnh_lock_data, &rnh_lock_grp); /* global routing tables mutex */

int rttrash = 0;                /* routes not in table but not freed */

boolean_t trigger_v6_defrtr_select = FALSE;
unsigned int rte_debug = 0;

/* Possible flags for rte_debug */
#define RTD_DEBUG       0x1     /* enable or disable rtentry debug facility */
#define RTD_TRACE       0x2     /* trace alloc, free, refcnt and lock */
#define RTD_NO_FREE     0x4     /* don't free (good to catch corruptions) */

#define RTE_NAME                "rtentry"       /* name for zone and rt_lock */

static struct zone *rte_zone;                   /* special zone for rtentry */
#define RTE_ZONE_MAX            65536           /* maximum elements in zone */
#define RTE_ZONE_NAME           RTE_NAME        /* name of rtentry zone */

#define RTD_INUSE               0xFEEDFACE      /* entry is in use */
#define RTD_FREED               0xDEADBEEF      /* entry is freed */

#define MAX_SCOPE_ADDR_STR_LEN  (MAX_IPv6_STR_LEN + 6)

/* Lock group and attribute for routing entry locks */
static LCK_ATTR_DECLARE(rte_mtx_attr, 0, 0);
static LCK_GRP_DECLARE(rte_mtx_grp, RTE_NAME);

/* For gdb */
__private_extern__ unsigned int ctrace_stack_size = CTRACE_STACK_SIZE;
__private_extern__ unsigned int ctrace_hist_size = CTRACE_HIST_SIZE;

/*
 * Debug variant of rtentry structure.
 */
struct rtentry_dbg {
	struct rtentry  rtd_entry;                      /* rtentry */
	struct rtentry  rtd_entry_saved;                /* saved rtentry */
	uint32_t        rtd_inuse;                      /* in use pattern */
	uint16_t        rtd_refhold_cnt;                /* # of rtref */
	uint16_t        rtd_refrele_cnt;                /* # of rtunref */
	uint32_t        rtd_lock_cnt;                   /* # of locks */
	uint32_t        rtd_unlock_cnt;                 /* # of unlocks */
	/*
	 * Alloc and free callers.
	 */
	ctrace_t        rtd_alloc;
	ctrace_t        rtd_free;
	/*
	 * Circular lists of rtref and rtunref callers.
	 */
	ctrace_t        rtd_refhold[CTRACE_HIST_SIZE];
	ctrace_t        rtd_refrele[CTRACE_HIST_SIZE];
	/*
	 * Circular lists of locks and unlocks.
	 */
	ctrace_t        rtd_lock[CTRACE_HIST_SIZE];
	ctrace_t        rtd_unlock[CTRACE_HIST_SIZE];
	/*
	 * Trash list linkage
	 */
	TAILQ_ENTRY(rtentry_dbg) rtd_trash_link;
};
__CCT_DECLARE_CONSTRAINED_PTR_TYPES(struct rtentry_dbg, rtentry_dbg);

/* List of trash route entries protected by rnh_lock */
static TAILQ_HEAD(, rtentry_dbg) rttrash_head;

static void rte_lock_init(struct rtentry *);
static void rte_lock_destroy(struct rtentry *);
static inline struct rtentry *rte_alloc_debug(void);
static inline void rte_free_debug(struct rtentry *);
static inline void rte_lock_debug(struct rtentry_dbg *);
static inline void rte_unlock_debug(struct rtentry_dbg *);
static void rt_maskedcopy(const struct sockaddr *,
    struct sockaddr *, const struct sockaddr *);
static void rtable_init(void **);
static inline void rtref_audit(struct rtentry_dbg *);
static inline void rtunref_audit(struct rtentry_dbg *);
static struct rtentry *rtalloc1_common_locked(struct sockaddr *, int, uint32_t,
    unsigned int);
static int rtrequest_common_locked(int, struct sockaddr *,
    struct sockaddr *, struct sockaddr *, int, struct rtentry **,
    unsigned int);
static struct rtentry *rtalloc1_locked(struct sockaddr *, int, uint32_t);
static void rtalloc_ign_common_locked(struct route *, uint32_t, unsigned int);
static inline void sin6_set_ifscope(struct sockaddr *, unsigned int);
static inline void sin6_set_embedded_ifscope(struct sockaddr *, unsigned int);
static inline unsigned int sin6_get_embedded_ifscope(struct sockaddr *);
static struct sockaddr *ma_copy(int, struct sockaddr *,
    struct sockaddr_storage *, unsigned int);
static struct sockaddr *sa_trim(struct sockaddr *, uint8_t);
static struct radix_node *node_lookup(struct sockaddr *, struct sockaddr *,
    unsigned int);
static struct radix_node *node_lookup_default(int);
static struct rtentry *rt_lookup_common(boolean_t, boolean_t, struct sockaddr *,
    struct sockaddr *, struct radix_node_head *, unsigned int);
static int rn_match_ifscope(struct radix_node *, void *);
static struct ifaddr *ifa_ifwithroute_common_locked(int,
    const struct sockaddr *, const struct sockaddr *, unsigned int);
static struct rtentry *rte_alloc(void);
static void rte_free(struct rtentry *);
static void rtfree_common(struct rtentry *, boolean_t);
static void rte_if_ref(struct ifnet *, int);
static void rt_set_idleref(struct rtentry *);
static void rt_clear_idleref(struct rtentry *);
static void rt_str4(struct rtentry *, char *, uint32_t, char *, uint32_t);
static void rt_str6(struct rtentry *, char *, uint32_t, char *, uint32_t);
static boolean_t route_ignore_protocol_cloning_for_dst(struct rtentry *, struct sockaddr *);

uint32_t route_genid_inet = 0;
uint32_t route_genid_inet6 = 0;

#define ASSERT_SINIFSCOPE(sa) {                                         \
	if ((sa)->sa_family != AF_INET ||                               \
	    (sa)->sa_len < sizeof (struct sockaddr_in))                 \
	        panic("%s: bad sockaddr_in %p", __func__, sa);        \
}

#define ASSERT_SIN6IFSCOPE(sa) {                                        \
	if ((sa)->sa_family != AF_INET6 ||                              \
	    (sa)->sa_len < sizeof (struct sockaddr_in6))                \
	        panic("%s: bad sockaddr_in6 %p", __func__, sa);       \
}

/*
 * Argument to leaf-matching routine; at present it is scoped routing
 * specific but can be expanded in future to include other search filters.
 */
struct matchleaf_arg {
	unsigned int    ifscope;        /* interface scope */
};

/*
 * For looking up the non-scoped default route (sockaddr instead
 * of sockaddr_in for convenience).
 */
static struct sockaddr sin_def = {
	.sa_len = sizeof(struct sockaddr_in),
	.sa_family = AF_INET,
	.sa_data = { 0, }
};

static struct sockaddr_in6 sin6_def = {
	.sin6_len = sizeof(struct sockaddr_in6),
	.sin6_family = AF_INET6,
	.sin6_port = 0,
	.sin6_flowinfo = 0,
	.sin6_addr = IN6ADDR_ANY_INIT,
	.sin6_scope_id = 0
};

/*
 * Interface index (scope) of the primary interface; determined at
 * the time when the default, non-scoped route gets added, changed
 * or deleted.  Protected by rnh_lock.
 */
static unsigned int primary_ifscope = IFSCOPE_NONE;
static unsigned int primary6_ifscope = IFSCOPE_NONE;

#define INET_DEFAULT(sa)        \
	((sa)->sa_family == AF_INET && SIN(sa)->sin_addr.s_addr == 0)

#define INET6_DEFAULT(sa)                                               \
	((sa)->sa_family == AF_INET6 &&                                 \
	IN6_IS_ADDR_UNSPECIFIED(&SIN6(sa)->sin6_addr))

#define SA_DEFAULT(sa)  (INET_DEFAULT(sa) || INET6_DEFAULT(sa))
#define RT(r)           ((rtentry_ref_t)r)
#define RN(r)           ((struct radix_node *)r)
#define RT_HOST(r)      (RT(r)->rt_flags & RTF_HOST)

#define ROUTE_VERBOSE_LOGGING 0
unsigned int rt_verbose = ROUTE_VERBOSE_LOGGING;
SYSCTL_DECL(_net_route);
SYSCTL_UINT(_net_route, OID_AUTO, verbose, CTLFLAG_RW | CTLFLAG_LOCKED,
    &rt_verbose, ROUTE_VERBOSE_LOGGING, "");

static void
rtable_init(void **table)
{
	struct domain *dom;

	domain_proto_mtx_lock_assert_held();

	TAILQ_FOREACH(dom, &domains, dom_entry) {
		if (dom->dom_rtattach != NULL) {
			dom->dom_rtattach(&table[dom->dom_family],
			    dom->dom_rtoffset);
		}
	}
}

/*
 * Called by route_dinit().
 */
void
route_init(void)
{
	int size;

	_CASSERT(offsetof(struct route, ro_rt) ==
	    offsetof(struct route_in6, ro_rt));
	_CASSERT(offsetof(struct route, ro_srcia) ==
	    offsetof(struct route_in6, ro_srcia));
	_CASSERT(offsetof(struct route, ro_flags) ==
	    offsetof(struct route_in6, ro_flags));
	_CASSERT(offsetof(struct route, ro_dst) ==
	    offsetof(struct route_in6, ro_dst));

	PE_parse_boot_argn("rte_debug", &rte_debug, sizeof(rte_debug));
	if (rte_debug != 0) {
		rte_debug |= RTD_DEBUG;
	}

	lck_mtx_lock(rnh_lock);
	rn_init();      /* initialize all zeroes, all ones, mask table */
	lck_mtx_unlock(rnh_lock);
	rtable_init((void **)rt_tables);

	if (rte_debug & RTD_DEBUG) {
		size = sizeof(struct rtentry_dbg);
	} else {
		size = sizeof(struct rtentry);
	}

	rte_zone = zone_create(RTE_ZONE_NAME, size, ZC_NONE);

	TAILQ_INIT(&rttrash_head);
}

/*
 * Given a route, determine whether or not it is the non-scoped default
 * route; dst typically comes from rt_key(rt) but may be coming from
 * a separate place when rt is in the process of being created.
 */
boolean_t
rt_primary_default(struct rtentry *rt, struct sockaddr *dst)
{
	return SA_DEFAULT(dst) && !(rt->rt_flags & RTF_IFSCOPE);
}

/*
 * Set the ifscope of the primary interface; caller holds rnh_lock.
 */
void
set_primary_ifscope(int af, unsigned int ifscope)
{
	if (af == AF_INET) {
		primary_ifscope = ifscope;
	} else {
		primary6_ifscope = ifscope;
	}
}

/*
 * Return the ifscope of the primary interface; caller holds rnh_lock.
 */
unsigned int
get_primary_ifscope(int af)
{
	return af == AF_INET ? primary_ifscope : primary6_ifscope;
}

/*
 * Set the scope ID of a given a sockaddr_in.
 */
void
sin_set_ifscope(struct sockaddr *sa, unsigned int ifscope)
{
	/* Caller must pass in sockaddr_in */
	ASSERT_SINIFSCOPE(sa);

	SINIFSCOPE(sa)->sin_scope_id = ifscope;
}

/*
 * Set the scope ID of given a sockaddr_in6.
 */
static inline void
sin6_set_ifscope(struct sockaddr *sa, unsigned int ifscope)
{
	/* Caller must pass in sockaddr_in6 */
	ASSERT_SIN6IFSCOPE(sa);

	SIN6IFSCOPE(sa)->sin6_scope_id = ifscope;
}

/*
 * Given a sockaddr_in, return the scope ID to the caller.
 */
unsigned int
sin_get_ifscope(struct sockaddr *sa)
{
	/* Caller must pass in sockaddr_in */
	ASSERT_SINIFSCOPE(sa);

	return SINIFSCOPE(sa)->sin_scope_id;
}

/*
 * Given a sockaddr_in6, return the scope ID to the caller.
 */
unsigned int
sin6_get_ifscope(struct sockaddr *sa)
{
	/* Caller must pass in sockaddr_in6 */
	ASSERT_SIN6IFSCOPE(sa);

	return SIN6IFSCOPE(sa)->sin6_scope_id;
}

static inline void
sin6_set_embedded_ifscope(struct sockaddr *sa, unsigned int ifscope)
{
	if (!in6_embedded_scope) {
		SIN6(sa)->sin6_scope_id = ifscope;
		return;
	}

	/* Caller must pass in sockaddr_in6 */
	ASSERT_SIN6IFSCOPE(sa);
	VERIFY(IN6_IS_SCOPE_EMBED(&(SIN6(sa)->sin6_addr)));

	SIN6(sa)->sin6_addr.s6_addr16[1] = htons((uint16_t)ifscope);
}

static inline unsigned int
sin6_get_embedded_ifscope(struct sockaddr *sa)
{
	if (!in6_embedded_scope) {
		return SIN6(sa)->sin6_scope_id;
	}
	/* Caller must pass in sockaddr_in6 */
	ASSERT_SIN6IFSCOPE(sa);

	return ntohs(SIN6(sa)->sin6_addr.s6_addr16[1]);
}

/*
 * Copy a sockaddr_{in,in6} src to a dst storage and set scope ID into dst.
 *
 * To clear the scope ID, pass is a NULL pifscope.  To set the scope ID, pass
 * in a non-NULL pifscope with non-zero ifscope.  Otherwise if pifscope is
 * non-NULL and ifscope is IFSCOPE_NONE, the existing scope ID is left intact.
 * In any case, the effective scope ID value is returned to the caller via
 * pifscope, if it is non-NULL.
 */
struct sockaddr *
sa_copy(struct sockaddr *src, struct sockaddr_storage *dst,
    unsigned int *pifscope)
{
	int af = src->sa_family;
	unsigned int ifscope = (pifscope != NULL) ? *pifscope : IFSCOPE_NONE;

	VERIFY(af == AF_INET || af == AF_INET6);

	bzero(dst, sizeof(*dst));

	if (af == AF_INET) {
		SOCKADDR_COPY(src, dst, sizeof(struct sockaddr_in));
		dst->ss_len = sizeof(struct sockaddr_in);
		if (pifscope == NULL || ifscope != IFSCOPE_NONE) {
			sin_set_ifscope(SA(dst), ifscope);
		}
	} else {
		SOCKADDR_COPY(src, dst, sizeof(struct sockaddr_in6));
		dst->ss_len = sizeof(struct sockaddr_in6);
		if (pifscope != NULL &&
		    IN6_IS_SCOPE_EMBED(&SIN6(dst)->sin6_addr)) {
			unsigned int eifscope;
			/*
			 * If the address contains the embedded scope ID,
			 * use that as the value for sin6_scope_id as long
			 * the caller doesn't insist on clearing it (by
			 * passing NULL) or setting it.
			 */
			eifscope = sin6_get_embedded_ifscope(SA(dst));
			if (eifscope != IFSCOPE_NONE && ifscope == IFSCOPE_NONE) {
				ifscope = eifscope;
			}
			if (ifscope != IFSCOPE_NONE) {
				/* Set ifscope from pifscope or eifscope */
				sin6_set_ifscope(SA(dst), ifscope);
			} else {
				/* If sin6_scope_id has a value, use that one */
				ifscope = sin6_get_ifscope(SA(dst));
			}
			/*
			 * If sin6_scope_id is set but the address doesn't
			 * contain the equivalent embedded value, set it.
			 */
			if (ifscope != IFSCOPE_NONE && eifscope != ifscope) {
				sin6_set_embedded_ifscope(SA(dst), ifscope);
			}
		} else if (pifscope == NULL || ifscope != IFSCOPE_NONE) {
			sin6_set_ifscope(SA(dst), ifscope);
		}
	}

	if (pifscope != NULL) {
		*pifscope = (af == AF_INET) ? sin_get_ifscope(SA(dst)) :
		    sin6_get_ifscope(SA(dst));
	}

	return SA(dst);
}

/*
 * Copy a mask from src to a dst storage and set scope ID into dst.
 */
static struct sockaddr *
ma_copy(int af, struct sockaddr *src, struct sockaddr_storage *dst,
    unsigned int ifscope)
{
	VERIFY(af == AF_INET || af == AF_INET6);

	bzero(dst, sizeof(*dst));
	rt_maskedcopy(src, SA(dst), src);

	/*
	 * The length of the mask sockaddr would need to be adjusted
	 * to cover the additional {sin,sin6}_ifscope field; when ifscope
	 * is IFSCOPE_NONE, we'd end up clearing the scope ID field on
	 * the destination mask in addition to extending the length
	 * of the sockaddr, as a side effect.  This is okay, as any
	 * trailing zeroes would be skipped by rn_addmask prior to
	 * inserting or looking up the mask in the mask tree.
	 */
	if (af == AF_INET) {
		SINIFSCOPE(dst)->sin_scope_id = ifscope;
		SINIFSCOPE(dst)->sin_len =
		    offsetof(struct sockaddr_inifscope, sin_scope_id) +
		    sizeof(SINIFSCOPE(dst)->sin_scope_id);
	} else {
		SIN6IFSCOPE(dst)->sin6_scope_id = ifscope;
		SIN6IFSCOPE(dst)->sin6_len =
		    offsetof(struct sockaddr_in6, sin6_scope_id) +
		    sizeof(SIN6IFSCOPE(dst)->sin6_scope_id);
	}

	return SA(dst);
}

/*
 * Trim trailing zeroes on a sockaddr and update its length.
 */
static struct sockaddr *
sa_trim(struct sockaddr *sa, uint8_t skip)
{
	caddr_t cp;
	caddr_t base = (caddr_t)__SA_UTILS_CONV_TO_BYTES(sa) + skip;

	if (sa->sa_len <= skip) {
		return sa;
	}

	for (cp = base + (sa->sa_len - skip); cp > base && cp[-1] == 0;) {
		cp--;
	}

	sa->sa_len = (uint8_t)(cp - base) + skip;
	if (sa->sa_len < skip) {
		/* Must not happen, and if so, panic */
		panic("%s: broken logic (sa_len %d < skip %d )", __func__,
		    sa->sa_len, skip);
		/* NOTREACHED */
	} else if (sa->sa_len == skip) {
		/* If we end up with all zeroes, then there's no mask */
		sa->sa_len = 0;
	}

	return sa;
}

/*
 * Called by rtm_msg{1,2} routines to "scrub" socket address structures of
 * kernel private information, so that clients of the routing socket will
 * not be confused by the presence of the information, or the side effect of
 * the increased length due to that.  The source sockaddr is not modified;
 * instead, the scrubbing happens on the destination sockaddr storage that
 * is passed in by the caller.
 *
 * Scrubbing entails:
 *   - removing embedded scope identifiers from network mask and destination
 *     IPv4 and IPv6 socket addresses
 *   - optionally removing global scope interface hardware addresses from
 *     link-layer interface addresses when the MAC framework check fails.
 */
struct sockaddr *
rtm_scrub(int type, int idx, struct sockaddr *hint, struct sockaddr *sa,
    void *buf __sized_by(buflen), uint32_t buflen, kauth_cred_t *credp)
{
	struct sockaddr_storage *ss = (struct sockaddr_storage *)buf;
	struct sockaddr *ret = sa;

	VERIFY(buf != NULL && buflen >= sizeof(*ss));
	bzero(buf, buflen);

	switch (idx) {
	case RTAX_DST:
		/*
		 * If this is for an AF_INET/AF_INET6 destination address,
		 * call sa_copy() to clear the scope ID field.
		 */
		if (sa->sa_family == AF_INET &&
		    SINIFSCOPE(sa)->sin_scope_id != IFSCOPE_NONE) {
			ret = sa_copy(sa, ss, NULL);
		} else if (sa->sa_family == AF_INET6 &&
		    SIN6IFSCOPE(sa)->sin6_scope_id != IFSCOPE_NONE) {
			ret = sa_copy(sa, ss, NULL);
		}
		break;

	case RTAX_NETMASK: {
		uint8_t skip, af;
		/*
		 * If this is for a mask, we can't tell whether or not there
		 * is an valid scope ID value, as the span of bytes between
		 * sa_len and the beginning of the mask (offset of sin_addr in
		 * the case of AF_INET, or sin6_addr for AF_INET6) may be
		 * filled with all-ones by rn_addmask(), and hence we cannot
		 * rely on sa_family.  Because of this, we use the sa_family
		 * of the hint sockaddr (RTAX_{DST,IFA}) as indicator as to
		 * whether or not the mask is to be treated as one for AF_INET
		 * or AF_INET6.  Clearing the scope ID field involves setting
		 * it to IFSCOPE_NONE followed by calling sa_trim() to trim
		 * trailing zeroes from the storage sockaddr, which reverses
		 * what was done earlier by ma_copy() on the source sockaddr.
		 */
		if (hint == NULL ||
		    ((af = hint->sa_family) != AF_INET && af != AF_INET6)) {
			break;  /* nothing to do */
		}
		skip = (af == AF_INET) ?
		    offsetof(struct sockaddr_in, sin_addr) :
		    offsetof(struct sockaddr_in6, sin6_addr);

		if (sa->sa_len > skip && sa->sa_len <= sizeof(*ss)) {
			SOCKADDR_COPY(sa, ss, sa->sa_len);
			/*
			 * Don't use {sin,sin6}_set_ifscope() as sa_family
			 * and sa_len for the netmask might not be set to
			 * the corresponding expected values of the hint.
			 */
			if (hint->sa_family == AF_INET) {
				SINIFSCOPE(ss)->sin_scope_id = IFSCOPE_NONE;
			} else {
				SIN6IFSCOPE(ss)->sin6_scope_id = IFSCOPE_NONE;
			}
			ret = sa_trim(SA(ss), skip);

			/*
			 * For AF_INET6 mask, set sa_len appropriately unless
			 * this is requested via systl_dumpentry(), in which
			 * case we return the raw value.
			 */
			if (hint->sa_family == AF_INET6 &&
			    type != RTM_GET && type != RTM_GET2) {
				SA(ret)->sa_len = sizeof(struct sockaddr_in6);
			}
		}
		break;
	}
	case RTAX_GATEWAY: {
		/*
		 * Break if the gateway is not AF_LINK type (indirect routes)
		 *
		 * Else, if is, check if it is resolved. If not yet resolved
		 * simply break else scrub the link layer address.
		 */
		if ((sa->sa_family != AF_LINK) || (SDL(sa)->sdl_alen == 0)) {
			break;
		}
		OS_FALLTHROUGH;
	}

	case RTAX_IFP: {
		if (sa->sa_family == AF_LINK && credp) {
			struct sockaddr_dl *sdl = SDL(buf);
			const void *bytes;
			size_t size;

			/* caller should handle worst case: SOCK_MAXADDRLEN */
			VERIFY(buflen >= sa->sa_len);

			SOCKADDR_COPY(sa, sdl, sa->sa_len);
			bytes = dlil_ifaddr_bytes(sdl, &size, credp);
			if (bytes != CONST_LLADDR(sdl)) {
				VERIFY(sdl->sdl_alen == size);
				bcopy(bytes, LLADDR(sdl), size);
			}
			ret = SA(sdl);
		}
		break;
	}
	default:
		break;
	}

	return ret;
}

/*
 * Callback leaf-matching routine for rn_matchaddr_args used
 * for looking up an exact match for a scoped route entry.
 */
static int
rn_match_ifscope(struct radix_node *rn, void *arg)
{
	rtentry_ref_t rt = (rtentry_ref_t)rn;
	struct matchleaf_arg *ma = arg;
	int af = rt_key(rt)->sa_family;

	if (!(rt->rt_flags & RTF_IFSCOPE) || (af != AF_INET && af != AF_INET6)) {
		return 0;
	}

	return af == AF_INET ?
	       (SINIFSCOPE(rt_key(rt))->sin_scope_id == ma->ifscope) :
	       (SIN6IFSCOPE(rt_key(rt))->sin6_scope_id == ma->ifscope);
}

/*
 * Atomically increment route generation counter
 */
void
routegenid_update(void)
{
	routegenid_inet_update();
	routegenid_inet6_update();
}

void
routegenid_inet_update(void)
{
	os_atomic_inc(&route_genid_inet, relaxed);
}

void
routegenid_inet6_update(void)
{
	os_atomic_inc(&route_genid_inet6, relaxed);
}

/*
 * Packet routing routines.
 */
void
rtalloc(struct route *ro)
{
	rtalloc_ign(ro, 0);
}

void
rtalloc_scoped(struct route *ro, unsigned int ifscope)
{
	rtalloc_scoped_ign(ro, 0, ifscope);
}

static void
rtalloc_ign_common_locked(struct route *ro, uint32_t ignore,
    unsigned int ifscope)
{
	rtentry_ref_t rt;

	if ((rt = ro->ro_rt) != NULL) {
		RT_LOCK_SPIN(rt);
		if (rt->rt_ifp != NULL && !ROUTE_UNUSABLE(ro)) {
			RT_UNLOCK(rt);
			return;
		}
		RT_UNLOCK(rt);
		ROUTE_RELEASE_LOCKED(ro);       /* rnh_lock already held */
	}
	ro->ro_rt = rtalloc1_common_locked(SA(&ro->ro_dst), 1, ignore, ifscope);
	if (ro->ro_rt != NULL) {
		RT_GENID_SYNC(ro->ro_rt);
		RT_LOCK_ASSERT_NOTHELD(ro->ro_rt);
	}
}

void
rtalloc_ign(struct route *ro, uint32_t ignore)
{
	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED);
	lck_mtx_lock(rnh_lock);
	rtalloc_ign_common_locked(ro, ignore, IFSCOPE_NONE);
	lck_mtx_unlock(rnh_lock);
}

void
rtalloc_scoped_ign(struct route *ro, uint32_t ignore, unsigned int ifscope)
{
	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED);
	lck_mtx_lock(rnh_lock);
	rtalloc_ign_common_locked(ro, ignore, ifscope);
	lck_mtx_unlock(rnh_lock);
}

static struct rtentry *
rtalloc1_locked(struct sockaddr *dst, int report, uint32_t ignflags)
{
	return rtalloc1_common_locked(dst, report, ignflags, IFSCOPE_NONE);
}

struct rtentry *
rtalloc1_scoped_locked(struct sockaddr *dst, int report, uint32_t ignflags,
    unsigned int ifscope)
{
	return rtalloc1_common_locked(dst, report, ignflags, ifscope);
}

static boolean_t
route_ignore_protocol_cloning_for_dst(struct rtentry *rt, struct sockaddr *dst)
{
	/*
	 * For now keep protocol cloning for any type of IPv4
	 * destination.
	 */
	if (dst->sa_family != AF_INET6) {
		return FALSE;
	}

	/*
	 * Limit protocol route creation of IPv6 ULA destinations
	 * from default route,
	 * Just to be safe, even though it doesn't affect routability,
	 * still allow protocol cloned routes if we happen to hit
	 * default route over companion link for ULA destination.
	 */
	if (!IFNET_IS_COMPANION_LINK(rt->rt_ifp) &&
	    (rt->rt_flags & RTF_GATEWAY) &&
	    (rt->rt_flags & RTF_PRCLONING) &&
	    SA_DEFAULT(rt_key(rt)) &&
	    (IN6_IS_ADDR_UNIQUE_LOCAL(&SIN6(dst)->sin6_addr) || IN6_IS_SCOPE_EMBED(&SIN6(dst)->sin6_addr))) {
		return TRUE;
	}
	return FALSE;
}

struct rtentry *
rtalloc1_common_locked(struct sockaddr *dst, int report, uint32_t ignflags,
    unsigned int ifscope)
{
	struct radix_node_head *rnh = rt_tables[dst->sa_family];
	rtentry_ref_t rt = NULL;
	rtentry_ref_t newrt = NULL;
	struct rt_addrinfo info;
	uint32_t nflags;
	int  err = 0;
	u_char msgtype = RTM_MISS;

	if (rnh == NULL) {
		goto unreachable;
	}

	if (!in6_embedded_scope && dst->sa_family == AF_INET6) {
		if (IN6_IS_SCOPE_EMBED(&SIN6(dst)->sin6_addr) &&
			SIN6(dst)->sin6_scope_id == 0) {
			SIN6(dst)->sin6_scope_id = ifscope;
		}
	}

	/*
	 * Find the longest prefix or exact (in the scoped case) address match;
	 * callee adds a reference to entry and checks for root node as well
	 */
	rt = rt_lookup(FALSE, dst, NULL, rnh, ifscope);
	if (rt == NULL) {
		goto unreachable;
	}

	/*
	 * Explicitly ignore protocol cloning for certain destinations.
	 * Some checks below are kind of redundant, as for now, RTF_PRCLONING
	 * is only set on indirect (RTF_GATEWAY) routes.
	 * Also, we do this only when the route lookup above, resulted in default
	 * route.
	 * This is done to ensure, the resulting indirect host route doesn't
	 * interfere when routing table gets configured with a indirect subnet
	 * route/direct subnet route that is more specific than the current
	 * parent route of the resulting protocol cloned route.
	 *
	 * At the crux of it all, it is a problem that we maintain host cache
	 * in the routing table. We should revisit this for a generic solution.
	 */
	if (route_ignore_protocol_cloning_for_dst(rt, dst)) {
		ignflags |= RTF_PRCLONING;
	}

	RT_LOCK_SPIN(rt);
	newrt = rt;
	nflags = rt->rt_flags & ~ignflags;
	RT_UNLOCK(rt);

	if (report && (nflags & (RTF_CLONING | RTF_PRCLONING))) {
		/*
		 * We are apparently adding (report = 0 in delete).
		 * If it requires that it be cloned, do so.
		 * (This implies it wasn't a HOST route.)
		 */
		err = rtrequest_locked(RTM_RESOLVE, dst, NULL, NULL, 0, &newrt);
		if (err) {
			/*
			 * If the cloning didn't succeed, maybe what we
			 * have from lookup above will do.  Return that;
			 * no need to hold another reference since it's
			 * already done.
			 */
			newrt = rt;
			goto miss;
		}

		/*
		 * We cloned it; drop the original route found during lookup.
		 * The resulted cloned route (newrt) would now have an extra
		 * reference held during rtrequest.
		 */
		rtfree_locked(rt);

		/*
		 * If the newly created cloned route is a direct host route
		 * then also check if it is to a router or not.
		 * If it is, then set the RTF_ROUTER flag on the host route
		 * for the gateway.
		 *
		 * XXX It is possible for the default route to be created post
		 * cloned route creation of router's IP.
		 * We can handle that corner case by special handing for RTM_ADD
		 * of default route.
		 */
		if ((newrt->rt_flags & (RTF_HOST | RTF_LLINFO)) ==
		    (RTF_HOST | RTF_LLINFO)) {
			rtentry_ref_t defrt = NULL;
			struct sockaddr_storage def_key;

			bzero(&def_key, sizeof(def_key));
			def_key.ss_len = rt_key(newrt)->sa_len;
			def_key.ss_family = rt_key(newrt)->sa_family;

			defrt = rtalloc1_scoped_locked(SA(&def_key),
			    0, 0, newrt->rt_ifp->if_index);

			if (defrt) {
				if (sa_equal(rt_key(newrt), defrt->rt_gateway)) {
					newrt->rt_flags |= RTF_ROUTER;
				}
				rtfree_locked(defrt);
			}
		}

		if ((rt = newrt) && (rt->rt_flags & RTF_XRESOLVE)) {
			/*
			 * If the new route specifies it be
			 * externally resolved, then go do that.
			 */
			msgtype = RTM_RESOLVE;
			goto miss;
		}
	}
	goto done;

unreachable:
	/*
	 * Either we hit the root or couldn't find any match,
	 * Which basically means "cant get there from here"
	 */
	rtstat.rts_unreach++;

miss:
	if (report) {
		/*
		 * If required, report the failure to the supervising
		 * Authorities.
		 * For a delete, this is not an error. (report == 0)
		 */
		bzero((caddr_t)&info, sizeof(info));
		info.rti_info[RTAX_DST] = dst;
		rt_missmsg(msgtype, &info, 0, err);
	}
done:
	return newrt;
}

struct rtentry *
rtalloc1(struct sockaddr *dst, int report, uint32_t ignflags)
{
	rtentry_ref_t entry;
	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED);
	lck_mtx_lock(rnh_lock);
	entry = rtalloc1_locked(dst, report, ignflags);
	lck_mtx_unlock(rnh_lock);
	return entry;
}

struct rtentry *
rtalloc1_scoped(struct sockaddr *dst, int report, uint32_t ignflags,
    unsigned int ifscope)
{
	rtentry_ref_t entry;
	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED);
	lck_mtx_lock(rnh_lock);
	entry = rtalloc1_scoped_locked(dst, report, ignflags, ifscope);
	lck_mtx_unlock(rnh_lock);
	return entry;
}

/*
 * Remove a reference count from an rtentry.
 * If the count gets low enough, take it out of the routing table
 */
void
rtfree_locked(struct rtentry *rt)
{
	rtfree_common(rt, TRUE);
}

static void
rtfree_common(struct rtentry *rt, boolean_t locked)
{
	struct radix_node_head *rnh;

	LCK_MTX_ASSERT(rnh_lock, locked ?
	    LCK_MTX_ASSERT_OWNED : LCK_MTX_ASSERT_NOTOWNED);

	/*
	 * Atomically decrement the reference count and if it reaches 0,
	 * and there is a close function defined, call the close function.
	 */
	RT_LOCK_SPIN(rt);
	if (rtunref(rt) > 0) {
		RT_UNLOCK(rt);
		return;
	}

	/*
	 * To avoid violating lock ordering, we must drop rt_lock before
	 * trying to acquire the global rnh_lock.  If we are called with
	 * rnh_lock held, then we already have exclusive access; otherwise
	 * we do the lock dance.
	 */
	if (!locked) {
		/*
		 * Note that we check it again below after grabbing rnh_lock,
		 * since it is possible that another thread doing a lookup wins
		 * the race, grabs the rnh_lock first, and bumps up reference
		 * count in which case the route should be left alone as it is
		 * still in use.  It's also possible that another thread frees
		 * the route after we drop rt_lock; to prevent the route from
		 * being freed, we hold an extra reference.
		 */
		RT_ADDREF_LOCKED(rt);
		RT_UNLOCK(rt);
		lck_mtx_lock(rnh_lock);
		RT_LOCK_SPIN(rt);
		if (rtunref(rt) > 0) {
			/* We've lost the race, so abort */
			RT_UNLOCK(rt);
			goto done;
		}
	}

	/*
	 * We may be blocked on other lock(s) as part of freeing
	 * the entry below, so convert from spin to full mutex.
	 */
	RT_CONVERT_LOCK(rt);

	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);

	/* Negative refcnt must never happen */
	if (rt->rt_refcnt != 0) {
		panic("rt %p invalid refcnt %d", rt, rt->rt_refcnt);
		/* NOTREACHED */
	}
	/* Idle refcnt must have been dropped during rtunref() */
	VERIFY(!(rt->rt_flags & RTF_IFREF));

	/*
	 * find the tree for that address family
	 * Note: in the case of igmp packets, there might not be an rnh
	 */
	rnh = rt_tables[rt_key(rt)->sa_family];

	/*
	 * On last reference give the "close method" a chance to cleanup
	 * private state.  This also permits (for IPv4 and IPv6) a chance
	 * to decide if the routing table entry should be purged immediately
	 * or at a later time.  When an immediate purge is to happen the
	 * close routine typically issues RTM_DELETE which clears the RTF_UP
	 * flag on the entry so that the code below reclaims the storage.
	 */
	if (rnh != NULL && rnh->rnh_close != NULL) {
		rnh->rnh_close((struct radix_node *)rt, rnh);
	}

	/*
	 * If we are no longer "up" (and ref == 0) then we can free the
	 * resources associated with the route.
	 */
	if (!(rt->rt_flags & RTF_UP)) {
		rtentry_ref_t rt_parent;
		struct ifaddr *rt_ifa;

		rt->rt_flags |= RTF_DEAD;
		if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT)) {
			panic("rt %p freed while in radix tree", rt);
			/* NOTREACHED */
		}
		/*
		 * the rtentry must have been removed from the routing table
		 * so it is represented in rttrash; remove that now.
		 */
		(void) OSDecrementAtomic(&rttrash);
		if (rte_debug & RTD_DEBUG) {
			TAILQ_REMOVE(&rttrash_head, (rtentry_dbg_ref_t)rt,
			    rtd_trash_link);
		}

		/*
		 * release references on items we hold them on..
		 * e.g other routes and ifaddrs.
		 */
		if ((rt_parent = rt->rt_parent) != NULL) {
			rt->rt_parent = NULL;
		}

		if ((rt_ifa = rt->rt_ifa) != NULL) {
			rt->rt_ifa = NULL;
		}

		/*
		 * Now free any attached link-layer info.
		 */
		if (rt->rt_llinfo != NULL) {
			VERIFY(rt->rt_llinfo_free != NULL);
			(*rt->rt_llinfo_free)(rt->rt_llinfo);
			rt->rt_llinfo = NULL;
		}

		/* Destroy eventhandler lists context */
		eventhandler_lists_ctxt_destroy(&rt->rt_evhdlr_ctxt);

		/*
		 * Route is no longer in the tree and refcnt is 0;
		 * we have exclusive access, so destroy it.
		 */
		RT_UNLOCK(rt);
		rte_lock_destroy(rt);

		if (rt_parent != NULL) {
			rtfree_locked(rt_parent);
		}

		if (rt_ifa != NULL) {
			ifa_remref(rt_ifa);
		}

		/*
		 * The key is separately alloc'd so free it (see rt_setgate()).
		 * This also frees the gateway, as they are always malloc'd
		 * together.
		 */
		rt_key_free(rt);

		/*
		 * Free any statistics that may have been allocated
		 */
		nstat_route_detach(rt);

		/*
		 * and the rtentry itself of course
		 */
		rte_free(rt);
	} else {
		/*
		 * The "close method" has been called, but the route is
		 * still in the radix tree with zero refcnt, i.e. "up"
		 * and in the cached state.
		 */
		RT_UNLOCK(rt);
	}
done:
	if (!locked) {
		lck_mtx_unlock(rnh_lock);
	}
}

void
rtfree(struct rtentry *rt)
{
	rtfree_common(rt, FALSE);
}

/*
 * Decrements the refcount but does not free the route when
 * the refcount reaches zero. Unless you have really good reason,
 * use rtfree not rtunref.
 */
int
rtunref(struct rtentry *p)
{
	RT_LOCK_ASSERT_HELD(p);

	if (p->rt_refcnt == 0) {
		panic("%s(%p) bad refcnt", __func__, p);
		/* NOTREACHED */
	} else if (--p->rt_refcnt == 0) {
		/*
		 * Release any idle reference count held on the interface;
		 * if the route is eligible, still UP and the refcnt becomes
		 * non-zero at some point in future before it is purged from
		 * the routing table, rt_set_idleref() will undo this.
		 */
		rt_clear_idleref(p);
	}

	if (rte_debug & RTD_DEBUG) {
		rtunref_audit((rtentry_dbg_ref_t)p);
	}

	/* Return new value */
	return p->rt_refcnt;
}

static inline void
rtunref_audit(struct rtentry_dbg *rte)
{
	uint16_t idx;

	if (rte->rtd_inuse != RTD_INUSE) {
		panic("rtunref: on freed rte=%p", rte);
		/* NOTREACHED */
	}
	idx = os_atomic_inc_orig(&rte->rtd_refrele_cnt, relaxed) % CTRACE_HIST_SIZE;
	if (rte_debug & RTD_TRACE) {
		ctrace_record(&rte->rtd_refrele[idx]);
	}
}

/*
 * Add a reference count from an rtentry.
 */
void
rtref(struct rtentry *p)
{
	RT_LOCK_ASSERT_HELD(p);

	VERIFY((p->rt_flags & RTF_DEAD) == 0);
	if (++p->rt_refcnt == 0) {
		panic("%s(%p) bad refcnt", __func__, p);
		/* NOTREACHED */
	} else if (p->rt_refcnt == 1) {
		/*
		 * Hold an idle reference count on the interface,
		 * if the route is eligible for it.
		 */
		rt_set_idleref(p);
	}

	if (rte_debug & RTD_DEBUG) {
		rtref_audit((rtentry_dbg_ref_t)p);
	}
}

static inline void
rtref_audit(struct rtentry_dbg *rte)
{
	uint16_t idx;

	if (rte->rtd_inuse != RTD_INUSE) {
		panic("rtref_audit: on freed rte=%p", rte);
		/* NOTREACHED */
	}
	idx = os_atomic_inc_orig(&rte->rtd_refhold_cnt, relaxed) % CTRACE_HIST_SIZE;
	if (rte_debug & RTD_TRACE) {
		ctrace_record(&rte->rtd_refhold[idx]);
	}
}

void
rtsetifa(struct rtentry *rt, struct ifaddr *ifa)
{
	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);

	RT_LOCK_ASSERT_HELD(rt);

	if (rt->rt_ifa == ifa) {
		return;
	}

	/* Become a regular mutex, just in case */
	RT_CONVERT_LOCK(rt);

	/* Release the old ifa */
	if (rt->rt_ifa) {
		ifa_remref(rt->rt_ifa);
	}

	/* Set rt_ifa */
	rt->rt_ifa = ifa;

	/* Take a reference to the ifa */
	if (rt->rt_ifa) {
		ifa_addref(rt->rt_ifa);
	}
}

/*
 * Force a routing table entry to the specified
 * destination to go through the given gateway.
 * Normally called as a result of a routing redirect
 * message from the network layer.
 */
void
rtredirect(struct ifnet *ifp, struct sockaddr *dst, struct sockaddr *gateway,
    struct sockaddr *netmask, int flags, struct sockaddr *src,
    struct rtentry **rtp)
{
	rtentry_ref_t rt = NULL;
	int error = 0;
	short *stat = 0;
	struct rt_addrinfo info;
	struct ifaddr *ifa = NULL;
	unsigned int ifscope = (ifp != NULL) ? ifp->if_index : IFSCOPE_NONE;
	struct sockaddr_storage ss;
	int af = src->sa_family;

	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED);
	lck_mtx_lock(rnh_lock);

	/*
	 * Transform src into the internal routing table form for
	 * comparison against rt_gateway below.
	 */
	if ((af == AF_INET) || (af == AF_INET6)) {
		src = sa_copy(src, &ss, &ifscope);
	}

	/*
	 * Verify the gateway is directly reachable; if scoped routing
	 * is enabled, verify that it is reachable from the interface
	 * where the ICMP redirect arrived on.
	 */
	if ((ifa = ifa_ifwithnet_scoped(gateway, ifscope)) == NULL) {
		error = ENETUNREACH;
		goto out;
	}

	/* Lookup route to the destination (from the original IP header) */
	rt = rtalloc1_scoped_locked(dst, 0, RTF_CLONING | RTF_PRCLONING, ifscope);
	if (rt != NULL) {
		RT_LOCK(rt);
	}

	/*
	 * If the redirect isn't from our current router for this dst,
	 * it's either old or wrong.  If it redirects us to ourselves,
	 * we have a routing loop, perhaps as a result of an interface
	 * going down recently.  Holding rnh_lock here prevents the
	 * possibility of rt_ifa/ifa's ifa_addr from changing (e.g.
	 * in_ifinit), so okay to access ifa_addr without locking.
	 */
	if (!(flags & RTF_DONE) && rt != NULL &&
	    (!sa_equal(src, rt->rt_gateway) || !sa_equal(rt->rt_ifa->ifa_addr,
	    ifa->ifa_addr))) {
		error = EINVAL;
	} else {
		ifa_remref(ifa);
		if ((ifa = ifa_ifwithaddr(gateway))) {
			ifa_remref(ifa);
			ifa = NULL;
			error = EHOSTUNREACH;
		}
	}

	if (ifa) {
		ifa_remref(ifa);
		ifa = NULL;
	}

	if (error) {
		if (rt != NULL) {
			RT_UNLOCK(rt);
		}
		goto done;
	}

	/*
	 * Create a new entry if we just got back a wildcard entry
	 * or the the lookup failed.  This is necessary for hosts
	 * which use routing redirects generated by smart gateways
	 * to dynamically build the routing tables.
	 */
	if ((rt == NULL) || (rt_mask(rt) != NULL && rt_mask(rt)->sa_len < 2)) {
		goto create;
	}
	/*
	 * Don't listen to the redirect if it's
	 * for a route to an interface.
	 */
	RT_LOCK_ASSERT_HELD(rt);
	if (rt->rt_flags & RTF_GATEWAY) {
		if (((rt->rt_flags & RTF_HOST) == 0) && (flags & RTF_HOST)) {
			/*
			 * Changing from route to net => route to host.
			 * Create new route, rather than smashing route
			 * to net; similar to cloned routes, the newly
			 * created host route is scoped as well.
			 */
create:
			if (rt != NULL) {
				RT_UNLOCK(rt);
			}
			flags |=  RTF_GATEWAY | RTF_DYNAMIC;
			error = rtrequest_scoped_locked(RTM_ADD, dst,
			    gateway, netmask, flags, NULL, ifscope);
			stat = &rtstat.rts_dynamic;
		} else {
			/*
			 * Smash the current notion of the gateway to
			 * this destination.  Should check about netmask!!!
			 */
			rt->rt_flags |= RTF_MODIFIED;
			flags |= RTF_MODIFIED;
			stat = &rtstat.rts_newgateway;
			/*
			 * add the key and gateway (in one malloc'd chunk).
			 */
			error = rt_setgate(rt, rt_key(rt), gateway);
			RT_UNLOCK(rt);
		}
	} else {
		RT_UNLOCK(rt);
		error = EHOSTUNREACH;
	}
done:
	if (rt != NULL) {
		RT_LOCK_ASSERT_NOTHELD(rt);
		if (!error) {
			/* Enqueue event to refresh flow route entries */
			route_event_enqueue_nwk_wq_entry(rt, NULL, ROUTE_ENTRY_REFRESH, NULL, FALSE);
			if (rtp) {
				*rtp = rt;
			} else {
				rtfree_locked(rt);
			}
		} else {
			rtfree_locked(rt);
		}
	}
out:
	if (error) {
		rtstat.rts_badredirect++;
	} else {
		if (stat != NULL) {
			(*stat)++;
		}

		if (af == AF_INET) {
			routegenid_inet_update();
		} else if (af == AF_INET6) {
			routegenid_inet6_update();
		}
	}
	lck_mtx_unlock(rnh_lock);
	bzero((caddr_t)&info, sizeof(info));
	info.rti_info[RTAX_DST] = dst;
	info.rti_info[RTAX_GATEWAY] = gateway;
	info.rti_info[RTAX_NETMASK] = netmask;
	info.rti_info[RTAX_AUTHOR] = src;
	rt_missmsg(RTM_REDIRECT, &info, flags, error);
}

/*
 * Routing table ioctl interface.
 */
int
rtioctl(unsigned long req, caddr_t data, struct proc *p)
{
#pragma unused(p, req, data)
	return ENXIO;
}

struct ifaddr *
ifa_ifwithroute(
	int flags,
	const struct sockaddr   *dst,
	const struct sockaddr *gateway)
{
	struct ifaddr *ifa;

	lck_mtx_lock(rnh_lock);
	ifa = ifa_ifwithroute_locked(flags, dst, gateway);
	lck_mtx_unlock(rnh_lock);

	return ifa;
}

struct ifaddr *
ifa_ifwithroute_locked(int flags, const struct sockaddr *dst,
    const struct sockaddr *gateway)
{
	return ifa_ifwithroute_common_locked((flags & ~RTF_IFSCOPE), dst,
	           gateway, IFSCOPE_NONE);
}

struct ifaddr *
ifa_ifwithroute_scoped_locked(int flags, const struct sockaddr *dst,
    const struct sockaddr *gateway, unsigned int ifscope)
{
	if (ifscope != IFSCOPE_NONE) {
		flags |= RTF_IFSCOPE;
	} else {
		flags &= ~RTF_IFSCOPE;
	}

	return ifa_ifwithroute_common_locked(flags, dst, gateway, ifscope);
}

static struct ifaddr *
ifa_ifwithroute_common_locked(int flags, const struct sockaddr *dst,
    const struct sockaddr *gw, unsigned int ifscope)
{
	struct ifaddr *ifa = NULL;
	rtentry_ref_t rt = NULL;
	struct sockaddr_storage dst_ss, gw_ss;

	if (!in6_embedded_scope) {
		const struct sockaddr_in6 *dst_addr = SIN6(dst);
		if (dst->sa_family == AF_INET6 &&
			IN6_IS_SCOPE_EMBED(&dst_addr->sin6_addr) &&
			ifscope == IFSCOPE_NONE) {
			ifscope = dst_addr->sin6_scope_id;
			VERIFY(ifscope != IFSCOPE_NONE);
		}

		const struct sockaddr_in6 *gw_addr = SIN6(gw);
		if (dst->sa_family == AF_INET6 &&
			IN6_IS_SCOPE_EMBED(&gw_addr->sin6_addr) &&
			ifscope == IFSCOPE_NONE) {
			ifscope = gw_addr->sin6_scope_id;
			VERIFY(ifscope != IFSCOPE_NONE);
		}

		if (ifscope != IFSCOPE_NONE) {
			flags |= RTF_IFSCOPE;
		} else {
			flags &= ~RTF_IFSCOPE;
		}
	}

	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);

	/*
	 * Just in case the sockaddr passed in by the caller
	 * contains a scope ID, make sure to clear it since
	 * interface addresses aren't scoped.
	 */
	if (dst != NULL &&
	    ((dst->sa_family == AF_INET) ||
	    (dst->sa_family == AF_INET6))) {
		dst = sa_copy(__DECONST_SA(dst), &dst_ss, IN6_NULL_IF_EMBEDDED_SCOPE(&ifscope));
	}

	if (gw != NULL &&
	    ((gw->sa_family == AF_INET) ||
	    (gw->sa_family == AF_INET6))) {
		gw = sa_copy(__DECONST_SA(gw), &gw_ss, IN6_NULL_IF_EMBEDDED_SCOPE(&ifscope));
	}

	if (!(flags & RTF_GATEWAY)) {
		/*
		 * If we are adding a route to an interface,
		 * and the interface is a pt to pt link
		 * we should search for the destination
		 * as our clue to the interface.  Otherwise
		 * we can use the local address.
		 */
		if (flags & RTF_HOST) {
			ifa = ifa_ifwithdstaddr(dst);
		}
		if (ifa == NULL) {
			ifa = ifa_ifwithaddr_scoped(gw, ifscope);
		}
	} else {
		/*
		 * If we are adding a route to a remote net
		 * or host, the gateway may still be on the
		 * other end of a pt to pt link.
		 */
		if ((flags & RTF_IFSCOPE) != 0 && ifscope != IFSCOPE_NONE) {
			ifa = ifa_ifwithdstaddr_scoped(gw, ifscope);
		}
		if (ifa == NULL) {
			ifa = ifa_ifwithdstaddr(gw);
		}
	}
	if (ifa == NULL) {
		ifa = ifa_ifwithnet_scoped(gw, ifscope);
	}
	if (ifa == NULL) {
		/* Workaround to avoid gcc warning regarding const variable */
		rt = rtalloc1_scoped_locked(__DECONST_SA(dst),
		    0, 0, ifscope);
		if (rt != NULL) {
			RT_LOCK_SPIN(rt);
			ifa = rt->rt_ifa;
			if (ifa != NULL) {
				/* Become a regular mutex */
				RT_CONVERT_LOCK(rt);
				ifa_addref(ifa);
			}
			RT_REMREF_LOCKED(rt);
			RT_UNLOCK(rt);
			rt = NULL;
		}
	}
	/*
	 * Holding rnh_lock here prevents the possibility of ifa from
	 * changing (e.g. in_ifinit), so it is safe to access its
	 * ifa_addr (here and down below) without locking.
	 */
	if (ifa != NULL && ifa->ifa_addr->sa_family != dst->sa_family) {
		struct ifaddr *newifa;
		/* Callee adds reference to newifa upon success */
		newifa = ifaof_ifpforaddr(dst, ifa->ifa_ifp);
		if (newifa != NULL) {
			ifa_remref(ifa);
			ifa = newifa;
		}
	}
	/*
	 * If we are adding a gateway, it is quite possible that the
	 * routing table has a static entry in place for the gateway,
	 * that may not agree with info garnered from the interfaces.
	 * The routing table should carry more precedence than the
	 * interfaces in this matter.  Must be careful not to stomp
	 * on new entries from rtinit, hence (ifa->ifa_addr != gw).
	 */
	if ((ifa == NULL || (gw != NULL &&
	    !sa_equal(ifa->ifa_addr, __DECONST_SA(gw)))) &&
	    (rt = rtalloc1_scoped_locked(__DECONST_SA(gw),
	    0, 0, ifscope)) != NULL) {
		if (ifa != NULL) {
			ifa_remref(ifa);
		}
		RT_LOCK_SPIN(rt);
		ifa = rt->rt_ifa;
		if (ifa != NULL) {
			/* Become a regular mutex */
			RT_CONVERT_LOCK(rt);
			ifa_addref(ifa);
		}
		RT_REMREF_LOCKED(rt);
		RT_UNLOCK(rt);
	}
	/*
	 * If an interface scope was specified, the interface index of
	 * the found ifaddr must be equivalent to that of the scope;
	 * otherwise there is no match.
	 */
	if ((flags & RTF_IFSCOPE) &&
	    ifa != NULL && ifa->ifa_ifp->if_index != ifscope) {
		ifa_remref(ifa);
		ifa = NULL;
	}

	/*
	 * ifa's address family must match destination's address family
	 * after all is said and done.
	 */
	if (ifa != NULL &&
	    ifa->ifa_addr->sa_family != dst->sa_family) {
		ifa_remref(ifa);
		ifa = NULL;
	}

	return ifa;
}

static int rt_fixdelete(struct radix_node *, void *);
static int rt_fixchange(struct radix_node *, void *);

struct rtfc_arg {
	struct rtentry *rt0;
	struct radix_node_head *rnh;
};

int
rtrequest_locked(int req, struct sockaddr *dst, struct sockaddr *gateway,
    struct sockaddr *netmask, int flags, struct rtentry **ret_nrt)
{
	return rtrequest_common_locked(req, dst, gateway, netmask,
	           (flags & ~RTF_IFSCOPE), ret_nrt, IFSCOPE_NONE);
}

int
rtrequest_scoped_locked(int req, struct sockaddr *dst,
    struct sockaddr *gateway, struct sockaddr *netmask, int flags,
    struct rtentry **ret_nrt, unsigned int ifscope)
{
	if (ifscope != IFSCOPE_NONE) {
		flags |= RTF_IFSCOPE;
	} else {
		flags &= ~RTF_IFSCOPE;
	}

	return rtrequest_common_locked(req, dst, gateway, netmask,
	           flags, ret_nrt, ifscope);
}

/*
 * Do appropriate manipulations of a routing tree given all the bits of
 * info needed.
 *
 * Storing the scope ID in the radix key is an internal job that should be
 * left to routines in this module.  Callers should specify the scope value
 * to the "scoped" variants of route routines instead of manipulating the
 * key itself.  This is typically done when creating a scoped route, e.g.
 * rtrequest(RTM_ADD).  Once such a route is created and marked with the
 * RTF_IFSCOPE flag, callers can simply use its rt_key(rt) to clone it
 * (RTM_RESOLVE) or to remove it (RTM_DELETE).  An exception to this is
 * during certain routing socket operations where the search key might be
 * derived from the routing message itself, in which case the caller must
 * specify the destination address and scope value for RTM_ADD/RTM_DELETE.
 */
static int
rtrequest_common_locked(int req, struct sockaddr *dst0,
    struct sockaddr *gateway, struct sockaddr *netmask, int flags,
    struct rtentry **ret_nrt, unsigned int ifscope)
{
	int error = 0;
	rtentry_ref_t rt;
	struct radix_node *rn;
	struct radix_node_head *rnh;
	struct ifaddr *ifa = NULL;
	struct sockaddr *ndst, *dst = dst0;
	struct sockaddr_storage ss, mask;
	struct timeval caltime;
	int af = dst->sa_family;
	void (*ifa_rtrequest)(int, struct rtentry *, struct sockaddr *);

#define senderr(x) { error = x; goto bad; }

	DTRACE_ROUTE6(rtrequest, int, req, struct sockaddr *, dst0,
	    struct sockaddr *, gateway, struct sockaddr *, netmask,
	    int, flags, unsigned int, ifscope);

	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);

#if !(DEVELOPMENT || DEBUG)
	/*
	 * Setting the global internet flag external is only for testing
	 */
	flags &= ~RTF_GLOBAL;
#endif /* !(DEVELOPMENT || DEBUG) */

	/*
	 * Find the correct routing tree to use for this Address Family
	 */
	if ((rnh = rt_tables[af]) == NULL) {
		senderr(ESRCH);
	}
	/*
	 * If we are adding a host route then we don't want to put
	 * a netmask in the tree
	 */
	if (flags & RTF_HOST) {
		netmask = NULL;
	}

	/*
	 * If Scoped Routing is enabled, use a local copy of the destination
	 * address to store the scope ID into.  This logic is repeated below
	 * in the RTM_RESOLVE handler since the caller does not normally
	 * specify such a flag during a resolve, as well as for the handling
	 * of IPv4 link-local address; instead, it passes in the route used for
	 * cloning for which the scope info is derived from.  Note also that
	 * in the case of RTM_DELETE, the address passed in by the caller
	 * might already contain the scope ID info when it is the key itself,
	 * thus making RTF_IFSCOPE unnecessary; one instance where it is
	 * explicitly set is inside route_output() as part of handling a
	 * routing socket request.
	 */
	if (req != RTM_RESOLVE && ((af == AF_INET) || (af == AF_INET6))) {
		/* Transform dst into the internal routing table form */
		dst = sa_copy(dst, &ss, &ifscope);

		/* Transform netmask into the internal routing table form */
		if (netmask != NULL) {
			netmask = ma_copy(af, netmask, &mask, ifscope);
		}

		if (ifscope != IFSCOPE_NONE) {
			flags |= RTF_IFSCOPE;
		}
	} else if ((flags & RTF_IFSCOPE) &&
	    (af != AF_INET && af != AF_INET6)) {
		senderr(EINVAL);
	}

	if (ifscope == IFSCOPE_NONE) {
		flags &= ~RTF_IFSCOPE;
	}

	if (!in6_embedded_scope) {
		if (af == AF_INET6 &&
			IN6_IS_SCOPE_EMBED(&SIN6(dst)->sin6_addr) &&
			SIN6(dst)->sin6_scope_id == IFSCOPE_NONE) {
			SIN6(dst)->sin6_scope_id = ifscope;
			if (in6_embedded_scope_debug) {
				VERIFY(SIN6(dst)->sin6_scope_id != IFSCOPE_NONE);
			}
		}

		if (af == AF_INET6 &&
			IN6_IS_SCOPE_EMBED(&SIN6(dst)->sin6_addr) &&
			ifscope == IFSCOPE_NONE) {
			ifscope = SIN6(dst)->sin6_scope_id;
			flags |= RTF_IFSCOPE;
			if (in6_embedded_scope_debug) {
				VERIFY(ifscope!= IFSCOPE_NONE);
			}
		}
	}

	switch (req) {
	case RTM_DELETE: {
		rtentry_ref_t gwrt = NULL;
		boolean_t was_router = FALSE;
		uint32_t old_rt_refcnt = 0;
		/*
		 * Remove the item from the tree and return it.
		 * Complain if it is not there and do no more processing.
		 */
		if ((rn = rnh->rnh_deladdr(dst, netmask, rnh)) == NULL) {
			senderr(ESRCH);
		}
		if (rn->rn_flags & (RNF_ACTIVE | RNF_ROOT)) {
			panic("rtrequest delete");
			/* NOTREACHED */
		}
		rt = RT(rn);

		RT_LOCK(rt);
		old_rt_refcnt = rt->rt_refcnt;
		rt->rt_flags &= ~RTF_UP;
		/*
		 * Release any idle reference count held on the interface
		 * as this route is no longer externally visible.
		 */
		rt_clear_idleref(rt);
		/*
		 * Take an extra reference to handle the deletion of a route
		 * entry whose reference count is already 0; e.g. an expiring
		 * cloned route entry or an entry that was added to the table
		 * with 0 reference. If the caller is interested in this route,
		 * we will return it with the reference intact. Otherwise we
		 * will decrement the reference via rtfree_locked() and then
		 * possibly deallocate it.
		 */
		RT_ADDREF_LOCKED(rt);

		/*
		 * For consistency, in case the caller didn't set the flag.
		 */
		rt->rt_flags |= RTF_CONDEMNED;

		/*
		 * Clear RTF_ROUTER if it's set.
		 */
		if (rt->rt_flags & RTF_ROUTER) {
			was_router = TRUE;
			VERIFY(rt->rt_flags & RTF_HOST);
			rt->rt_flags &= ~RTF_ROUTER;
		}

		/*
		 * Enqueue work item to invoke callback for this route entry
		 *
		 * If the old count is 0, it implies that last reference is being
		 * removed and there's no one listening for this route event.
		 */
		if (old_rt_refcnt != 0) {
			route_event_enqueue_nwk_wq_entry(rt, NULL,
			    ROUTE_ENTRY_DELETED, NULL, TRUE);
		}

		/*
		 * Now search what's left of the subtree for any cloned
		 * routes which might have been formed from this node.
		 */
		if ((rt->rt_flags & (RTF_CLONING | RTF_PRCLONING)) &&
		    rt_mask(rt)) {
			RT_UNLOCK(rt);
			rnh->rnh_walktree_from(rnh, dst, rt_mask(rt),
			    rt_fixdelete, rt);
			RT_LOCK(rt);
		}

		if (was_router) {
			struct route_event rt_ev;
			route_event_init(&rt_ev, rt, NULL, ROUTE_LLENTRY_DELETED);
			RT_UNLOCK(rt);
			(void) rnh->rnh_walktree(rnh,
			    route_event_walktree, (void *)&rt_ev);
			RT_LOCK(rt);
		}

		/*
		 * Remove any external references we may have.
		 */
		if ((gwrt = rt->rt_gwroute) != NULL) {
			rt->rt_gwroute = NULL;
		}

		/*
		 * give the protocol a chance to keep things in sync.
		 */
		if ((ifa = rt->rt_ifa) != NULL) {
			IFA_LOCK_SPIN(ifa);
			ifa_rtrequest = ifa->ifa_rtrequest;
			IFA_UNLOCK(ifa);
			if (ifa_rtrequest != NULL) {
				ifa_rtrequest(RTM_DELETE, rt, NULL);
			}
			/* keep reference on rt_ifa */
			ifa = NULL;
		}

		/*
		 * one more rtentry floating around that is not
		 * linked to the routing table.
		 */
		(void) OSIncrementAtomic(&rttrash);
		if (rte_debug & RTD_DEBUG) {
			TAILQ_INSERT_TAIL(&rttrash_head,
			    (rtentry_dbg_ref_t)rt, rtd_trash_link);
		}

		/*
		 * If this is the (non-scoped) default route, clear
		 * the interface index used for the primary ifscope.
		 */
		if (rt_primary_default(rt, rt_key(rt))) {
			set_primary_ifscope(rt_key(rt)->sa_family,
			    IFSCOPE_NONE);
			if ((rt->rt_flags & RTF_STATIC) &&
			    rt_key(rt)->sa_family == PF_INET6) {
				trigger_v6_defrtr_select = TRUE;
			}
		}

#if NECP
		/*
		 * If this is a change in a default route, update
		 * necp client watchers to re-evaluate
		 */
		if (SA_DEFAULT(rt_key(rt))) {
			if (rt->rt_ifp != NULL) {
				ifnet_touch_lastupdown(rt->rt_ifp);
			}
			necp_update_all_clients();
		}
#endif /* NECP */

		RT_UNLOCK(rt);

		/*
		 * This might result in another rtentry being freed if
		 * we held its last reference.  Do this after the rtentry
		 * lock is dropped above, as it could lead to the same
		 * lock being acquired if gwrt is a clone of rt.
		 */
		if (gwrt != NULL) {
			rtfree_locked(gwrt);
		}

		/*
		 * If the caller wants it, then it can have it,
		 * but it's up to it to free the rtentry as we won't be
		 * doing it.
		 */
		if (ret_nrt != NULL) {
			/* Return the route to caller with reference intact */
			*ret_nrt = rt;
		} else {
			/* Dereference or deallocate the route */
			rtfree_locked(rt);
		}
		if (af == AF_INET) {
			routegenid_inet_update();
		} else if (af == AF_INET6) {
			routegenid_inet6_update();
		}
		break;
	}
	case RTM_RESOLVE:
		if (ret_nrt == NULL || (rt = *ret_nrt) == NULL) {
			senderr(EINVAL);
		}
		/*
		 * According to the UNIX conformance tests, we need to return
		 * ENETUNREACH when the parent route is RTF_REJECT.
		 * However, there isn't any point in cloning RTF_REJECT
		 * routes, so we immediately return an error.
		 */
		if (rt->rt_flags & RTF_REJECT) {
			if (rt->rt_flags & RTF_HOST) {
				senderr(EHOSTUNREACH);
			} else {
				senderr(ENETUNREACH);
			}
		}
		/*
		 * If cloning, we have the parent route given by the caller
		 * and will use its rt_gateway, rt_rmx as part of the cloning
		 * process below.  Since rnh_lock is held at this point, the
		 * parent's rt_ifa and rt_gateway will not change, and its
		 * relevant rt_flags will not change as well.  The only thing
		 * that could change are the metrics, and thus we hold the
		 * parent route's rt_lock later on during the actual copying
		 * of rt_rmx.
		 */
		ifa = rt->rt_ifa;
		ifa_addref(ifa);
		flags = rt->rt_flags &
		    ~(RTF_CLONING | RTF_PRCLONING | RTF_STATIC);
		flags |= RTF_WASCLONED;
		gateway = rt->rt_gateway;
		if ((netmask = rt->rt_genmask) == NULL) {
			flags |= RTF_HOST;
		}

		if (af != AF_INET && af != AF_INET6) {
			goto makeroute;
		}

		/*
		 * When scoped routing is enabled, cloned entries are
		 * always scoped according to the interface portion of
		 * the parent route.  The exception to this are IPv4
		 * link local addresses, or those routes that are cloned
		 * from a RTF_PROXY route.  For the latter, the clone
		 * gets to keep the RTF_PROXY flag.
		 */
		if ((af == AF_INET &&
		    IN_LINKLOCAL(ntohl(SIN(dst)->sin_addr.s_addr))) ||
		    (rt->rt_flags & RTF_PROXY)) {
			ifscope = IFSCOPE_NONE;
			flags &= ~RTF_IFSCOPE;
			/*
			 * These types of cloned routes aren't currently
			 * eligible for idle interface reference counting.
			 */
			flags |= RTF_NOIFREF;
		} else {
			if (flags & RTF_IFSCOPE) {
				ifscope = (af == AF_INET) ?
				    sin_get_ifscope(rt_key(rt)) :
				    sin6_get_ifscope(rt_key(rt));
			} else {
				ifscope = rt->rt_ifp->if_index;
				flags |= RTF_IFSCOPE;
			}
			VERIFY(ifscope != IFSCOPE_NONE);
		}

		/*
		 * Transform dst into the internal routing table form,
		 * clearing out the scope ID field if ifscope isn't set.
		 */
		dst = sa_copy(dst, &ss, (ifscope == IFSCOPE_NONE) ?
		    NULL : &ifscope);

		/* Transform netmask into the internal routing table form */
		if (netmask != NULL) {
			netmask = ma_copy(af, netmask, &mask, ifscope);
		}

		goto makeroute;

	case RTM_ADD:
		if ((flags & RTF_GATEWAY) && !gateway) {
			panic("rtrequest: RTF_GATEWAY but no gateway");
			/* NOTREACHED */
		}
		if (flags & RTF_IFSCOPE) {
			ifa = ifa_ifwithroute_scoped_locked(flags, dst0,
			    gateway, ifscope);
		} else {
			ifa = ifa_ifwithroute_locked(flags, dst0, gateway);
		}
		if (ifa == NULL) {
			senderr(ENETUNREACH);
		}
makeroute:
		/*
		 * We land up here for both RTM_RESOLVE and RTM_ADD
		 * when we decide to create a route.
		 */
		if ((rt = rte_alloc()) == NULL) {
			senderr(ENOBUFS);
		}
		Bzero(rt, sizeof(*rt));
		rte_lock_init(rt);
		eventhandler_lists_ctxt_init(&rt->rt_evhdlr_ctxt);
		getmicrotime(&caltime);
		rt->base_calendartime = caltime.tv_sec;
		rt->base_uptime = net_uptime();
		RT_LOCK(rt);
		rt->rt_flags = RTF_UP | flags;

		/*
		 * Point the generation ID to the tree's.
		 */
		switch (af) {
		case AF_INET:
			rt->rt_tree_genid = &route_genid_inet;
			break;
		case AF_INET6:
			rt->rt_tree_genid = &route_genid_inet6;
			break;
		default:
			break;
		}

		/*
		 * Add the gateway. Possibly re-malloc-ing the storage for it
		 * also add the rt_gwroute if possible.
		 */
		if ((error = rt_setgate(rt, dst, gateway)) != 0) {
			int tmp = error;
			RT_UNLOCK(rt);
			nstat_route_detach(rt);
			rte_lock_destroy(rt);
			rte_free(rt);
			senderr(tmp);
		}

		/*
		 * point to the (possibly newly malloc'd) dest address.
		 */
		ndst = rt_key(rt);

		/*
		 * make sure it contains the value we want (masked if needed).
		 */
		if (netmask) {
			rt_maskedcopy(dst, ndst, netmask);
		} else {
			SOCKADDR_COPY(dst, ndst, dst->sa_len);
		}

		/*
		 * Note that we now have a reference to the ifa.
		 * This moved from below so that rnh->rnh_addaddr() can
		 * examine the ifa and  ifa->ifa_ifp if it so desires.
		 */
		rtsetifa(rt, ifa);
		rt->rt_ifp = rt->rt_ifa->ifa_ifp;

		/* XXX mtu manipulation will be done in rnh_addaddr -- itojun */

		rn = rnh->rnh_addaddr((caddr_t)ndst, (caddr_t)netmask,
		    rnh, rt->rt_nodes);
		if (rn == 0) {
			rtentry_ref_t rt2;
			/*
			 * Uh-oh, we already have one of these in the tree.
			 * We do a special hack: if the route that's already
			 * there was generated by the protocol-cloning
			 * mechanism, then we just blow it away and retry
			 * the insertion of the new one.
			 */
			if (flags & RTF_IFSCOPE) {
				rt2 = rtalloc1_scoped_locked(dst0, 0,
				    RTF_CLONING | RTF_PRCLONING, ifscope);
			} else {
				rt2 = rtalloc1_locked(dst, 0,
				    RTF_CLONING | RTF_PRCLONING);
			}
			if (rt2 && rt2->rt_parent) {
				/*
				 * rnh_lock is held here, so rt_key and
				 * rt_gateway of rt2 will not change.
				 */
				(void) rtrequest_locked(RTM_DELETE, rt_key(rt2),
				    rt2->rt_gateway, rt_mask(rt2),
				    rt2->rt_flags, 0);
				rtfree_locked(rt2);
				rn = rnh->rnh_addaddr((caddr_t)ndst,
				    (caddr_t)netmask, rnh, rt->rt_nodes);
			} else if (rt2) {
				/* undo the extra ref we got */
				rtfree_locked(rt2);
			}
		}

		/*
		 * If it still failed to go into the tree,
		 * then un-make it (this should be a function)
		 */
		if (rn == NULL) {
			char dbuf[MAX_IPv6_STR_LEN], gbuf[MAX_IPv6_STR_LEN];

			rt_str(rt, dbuf, sizeof(dbuf), gbuf, sizeof(gbuf));
			os_log_error(OS_LOG_DEFAULT, "%s: route already exists: "
					"%s->%s->%s",
					__func__, dbuf, gbuf,
					((rt->rt_ifp != NULL) ?
					 rt->rt_ifp->if_xname : ""));

			/* Clear gateway route */
			rt_set_gwroute(rt, rt_key(rt), NULL);
			if (rt->rt_ifa) {
				ifa_remref(rt->rt_ifa);
				rt->rt_ifa = NULL;
			}
			rt_key_free(rt);
			RT_UNLOCK(rt);
			nstat_route_detach(rt);
			rte_lock_destroy(rt);
			rte_free(rt);
			senderr(EEXIST);
		}

		rt->rt_parent = NULL;

		/*
		 * If we got here from RESOLVE, then we are cloning so clone
		 * the rest, and note that we are a clone (and increment the
		 * parent's references).  rnh_lock is still held, which prevents
		 * a lookup from returning the newly-created route.  Hence
		 * holding and releasing the parent's rt_lock while still
		 * holding the route's rt_lock is safe since the new route
		 * is not yet externally visible.
		 */
		if (req == RTM_RESOLVE) {
			RT_LOCK_SPIN(*ret_nrt);
			VERIFY((*ret_nrt)->rt_expire == 0 ||
			    (*ret_nrt)->rt_rmx.rmx_expire != 0);
			VERIFY((*ret_nrt)->rt_expire != 0 ||
			    (*ret_nrt)->rt_rmx.rmx_expire == 0);
			rt->rt_rmx = (*ret_nrt)->rt_rmx;
			rt_setexpire(rt, (*ret_nrt)->rt_expire);
			if ((*ret_nrt)->rt_flags &
			    (RTF_CLONING | RTF_PRCLONING)) {
				rt->rt_parent = (*ret_nrt);
				RT_ADDREF_LOCKED(*ret_nrt);
			}
			RT_UNLOCK(*ret_nrt);
		}

		/*
		 * if this protocol has something to add to this then
		 * allow it to do that as well.
		 */
		IFA_LOCK_SPIN(ifa);
		ifa_rtrequest = ifa->ifa_rtrequest;
		IFA_UNLOCK(ifa);
		if (ifa_rtrequest != NULL) {
			/*
			 * Can not use SA(ret_nrt ? *ret_nrt : NULL),
			 * because *ret_nrt is not a sockadr.
			 */
			ifa_rtrequest(req, rt,
				__unsafe_forge_single(struct sockaddr*, ret_nrt ? *ret_nrt : NULL));
		}
		ifa_remref(ifa);
		ifa = NULL;

		/*
		 * If this is the (non-scoped) default route, record
		 * the interface index used for the primary ifscope.
		 */
		if (rt_primary_default(rt, rt_key(rt))) {
			set_primary_ifscope(rt_key(rt)->sa_family,
			    rt->rt_ifp->if_index);
		}

#if NECP
		/*
		 * If this is a change in a default route, update
		 * necp client watchers to re-evaluate
		 */
		if (SA_DEFAULT(rt_key(rt))) {
			/*
			 * Mark default routes as (potentially) leading to the global internet
			 * this can be used for policy decisions.
			 * The clone routes will inherit this flag.
			 * We check against the host flag as this works for default routes that have
			 * a gateway and defaults routes when all subnets are local.
			 */
			if (req == RTM_ADD && (rt->rt_flags & RTF_HOST) == 0) {
				rt->rt_flags |= RTF_GLOBAL;
			}
			if (rt->rt_ifp != NULL) {
				ifnet_touch_lastupdown(rt->rt_ifp);
			}
			necp_update_all_clients();
		}
#endif /* NECP */

		/*
		 * actually return a resultant rtentry and
		 * give the caller a single reference.
		 */
		if (ret_nrt) {
			*ret_nrt = rt;
			RT_ADDREF_LOCKED(rt);
		}

		if (af == AF_INET) {
			routegenid_inet_update();
		} else if (af == AF_INET6) {
			routegenid_inet6_update();
		}

		RT_GENID_SYNC(rt);

		/*
		 * We repeat the same procedures from rt_setgate() here
		 * because they weren't completed when we called it earlier,
		 * since the node was embryonic.
		 */
		if ((rt->rt_flags & RTF_GATEWAY) && rt->rt_gwroute != NULL) {
			rt_set_gwroute(rt, rt_key(rt), rt->rt_gwroute);
		}

		if (req == RTM_ADD &&
		    !(rt->rt_flags & RTF_HOST) && rt_mask(rt) != NULL) {
			struct rtfc_arg arg;
			arg.rnh = rnh;
			arg.rt0 = rt;
			RT_UNLOCK(rt);
			rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt),
			    rt_fixchange, &arg);
		} else {
			RT_UNLOCK(rt);
		}

		nstat_route_new_entry(rt);
		break;
	}
bad:
	if (ifa) {
		ifa_remref(ifa);
	}
	return error;
}
#undef senderr

int
rtrequest(int req, struct sockaddr *dst, struct sockaddr *gateway,
    struct sockaddr *netmask, int flags, struct rtentry **ret_nrt)
{
	int error;
	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED);
	lck_mtx_lock(rnh_lock);
	error = rtrequest_locked(req, dst, gateway, netmask, flags, ret_nrt);
	lck_mtx_unlock(rnh_lock);
	return error;
}

int
rtrequest_scoped(int req, struct sockaddr *dst, struct sockaddr *gateway,
    struct sockaddr *netmask, int flags, struct rtentry **ret_nrt,
    unsigned int ifscope)
{
	int error;
	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED);
	lck_mtx_lock(rnh_lock);
	error = rtrequest_scoped_locked(req, dst, gateway, netmask, flags,
	    ret_nrt, ifscope);
	lck_mtx_unlock(rnh_lock);
	return error;
}

/*
 * Called from rtrequest(RTM_DELETE, ...) to fix up the route's ``family''
 * (i.e., the routes related to it by the operation of cloning).  This
 * routine is iterated over all potential former-child-routes by way of
 * rnh->rnh_walktree_from() above, and those that actually are children of
 * the late parent (passed in as VP here) are themselves deleted.
 */
static int
rt_fixdelete(struct radix_node *rn, void *vp)
{
	rtentry_ref_t rt = (rtentry_ref_t)rn;
	rtentry_ref_t rt0 = (rtentry_ref_t)vp;

	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);

	RT_LOCK(rt);
	if (rt->rt_parent == rt0 &&
	    !(rt->rt_flags & (RTF_CLONING | RTF_PRCLONING))) {
		/*
		 * Safe to drop rt_lock and use rt_key, since holding
		 * rnh_lock here prevents another thread from calling
		 * rt_setgate() on this route.
		 */
		RT_UNLOCK(rt);
		return rtrequest_locked(RTM_DELETE, rt_key(rt), NULL,
		           rt_mask(rt), rt->rt_flags, NULL);
	}
	RT_UNLOCK(rt);
	return 0;
}

/*
 * This routine is called from rt_setgate() to do the analogous thing for
 * adds and changes.  There is the added complication in this case of a
 * middle insert; i.e., insertion of a new network route between an older
 * network route and (cloned) host routes.  For this reason, a simple check
 * of rt->rt_parent is insufficient; each candidate route must be tested
 * against the (mask, value) of the new route (passed as before in vp)
 * to see if the new route matches it.
 *
 * XXX - it may be possible to do fixdelete() for changes and reserve this
 * routine just for adds.  I'm not sure why I thought it was necessary to do
 * changes this way.
 */
static int
rt_fixchange(struct radix_node *rn, void *vp)
{
	rtentry_ref_t rt = (rtentry_ref_t)rn;
	struct rtfc_arg *ap = vp;
	rtentry_ref_t rt0 = ap->rt0;
	struct radix_node_head *rnh = ap->rnh;
	u_char *xk1, *xm1, *xk2, *xmp;
	int i, len;

	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);

	RT_LOCK(rt);

	if (!rt->rt_parent ||
	    (rt->rt_flags & (RTF_CLONING | RTF_PRCLONING))) {
		RT_UNLOCK(rt);
		return 0;
	}

	if (rt->rt_parent == rt0) {
		goto delete_rt;
	}

	/*
	 * There probably is a function somewhere which does this...
	 * if not, there should be.
	 */
	len = imin(rt_key(rt0)->sa_len, rt_key(rt)->sa_len);

	xk1 = (u_char *)rt_key(rt0);
	xm1 = (u_char *)rt_mask(rt0);
	xk2 = (u_char *)rt_key(rt);

	/*
	 * Avoid applying a less specific route; do this only if the parent
	 * route (rt->rt_parent) is a network route, since otherwise its mask
	 * will be NULL if it is a cloning host route.
	 */
	if ((xmp = (u_char *)rt_mask(rt->rt_parent)) != NULL) {
		int mlen = rt_mask(rt->rt_parent)->sa_len;
		if (mlen > rt_mask(rt0)->sa_len) {
			RT_UNLOCK(rt);
			return 0;
		}

		for (i = rnh->rnh_treetop->rn_offset; i < mlen; i++) {
			if ((xmp[i] & ~(xmp[i] ^ xm1[i])) != xmp[i]) {
				RT_UNLOCK(rt);
				return 0;
			}
		}
	}

	for (i = rnh->rnh_treetop->rn_offset; i < len; i++) {
		if ((xk2[i] & xm1[i]) != xk1[i]) {
			RT_UNLOCK(rt);
			return 0;
		}
	}

	/*
	 * OK, this node is a clone, and matches the node currently being
	 * changed/added under the node's mask.  So, get rid of it.
	 */
delete_rt:
	/*
	 * Safe to drop rt_lock and use rt_key, since holding rnh_lock here
	 * prevents another thread from calling rt_setgate() on this route.
	 */
	RT_UNLOCK(rt);
	return rtrequest_locked(RTM_DELETE, rt_key(rt), NULL,
	           rt_mask(rt), rt->rt_flags, NULL);
}

/*
 * Round up sockaddr len to multiples of 32-bytes.  This will reduce
 * or even eliminate the need to re-allocate the chunk of memory used
 * for rt_key and rt_gateway in the event the gateway portion changes.
 * Certain code paths (e.g. IPsec) are notorious for caching the address
 * of rt_gateway; this rounding-up would help ensure that the gateway
 * portion never gets deallocated (though it may change contents) and
 * thus greatly simplifies things.
 */
#define SA_SIZE(x) (-(-((uintptr_t)(x)) & -(32)))

/*
 * Sets the gateway and/or gateway route portion of a route; may be
 * called on an existing route to modify the gateway portion.  Both
 * rt_key and rt_gateway are allocated out of the same memory chunk.
 * Route entry lock must be held by caller; this routine will return
 * with the lock held.
 */
int
rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate)
{
	int dlen = (int)SA_SIZE(dst->sa_len), glen = (int)SA_SIZE(gate->sa_len);
	struct radix_node_head *rnh = NULL;
	boolean_t loop = FALSE;

	if (dst->sa_family != AF_INET && dst->sa_family != AF_INET6) {
		return EINVAL;
	}

	rnh = rt_tables[dst->sa_family];
	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);
	RT_LOCK_ASSERT_HELD(rt);

	/*
	 * If this is for a route that is on its way of being removed,
	 * or is temporarily frozen, reject the modification request.
	 */
	if (rt->rt_flags & RTF_CONDEMNED) {
		return EBUSY;
	}

	/* Add an extra ref for ourselves */
	RT_ADDREF_LOCKED(rt);

	if (rt->rt_flags & RTF_GATEWAY) {
		if ((dst->sa_len == gate->sa_len) &&
		    (dst->sa_family == AF_INET || dst->sa_family == AF_INET6)) {
			struct sockaddr_storage dst_ss, gate_ss;

			(void) sa_copy(dst, &dst_ss, NULL);
			(void) sa_copy(gate, &gate_ss, NULL);

			loop = sa_equal(SA(&dst_ss), SA(&gate_ss));
		} else {
			loop = (dst->sa_len == gate->sa_len &&
			    sa_equal(dst, gate));
		}
	}

	/*
	 * A (cloning) network route with the destination equal to the gateway
	 * will create an endless loop (see notes below), so disallow it.
	 */
	if (((rt->rt_flags & (RTF_HOST | RTF_GATEWAY | RTF_LLINFO)) ==
	    RTF_GATEWAY) && loop) {
		/* Release extra ref */
		RT_REMREF_LOCKED(rt);
		return EADDRNOTAVAIL;
	}

	/*
	 * A host route with the destination equal to the gateway
	 * will interfere with keeping LLINFO in the routing
	 * table, so disallow it.
	 */
	if (((rt->rt_flags & (RTF_HOST | RTF_GATEWAY | RTF_LLINFO)) ==
	    (RTF_HOST | RTF_GATEWAY)) && loop) {
		/*
		 * The route might already exist if this is an RTM_CHANGE
		 * or a routing redirect, so try to delete it.
		 */
		if (rt_key(rt) != NULL) {
			/*
			 * Safe to drop rt_lock and use rt_key, rt_gateway,
			 * since holding rnh_lock here prevents another thread
			 * from calling rt_setgate() on this route.
			 */
			RT_UNLOCK(rt);
			(void) rtrequest_locked(RTM_DELETE, rt_key(rt),
			    rt->rt_gateway, rt_mask(rt), rt->rt_flags, NULL);
			RT_LOCK(rt);
		}
		/* Release extra ref */
		RT_REMREF_LOCKED(rt);
		return EADDRNOTAVAIL;
	}

	/*
	 * The destination is not directly reachable.  Get a route
	 * to the next-hop gateway and store it in rt_gwroute.
	 */
	if (rt->rt_flags & RTF_GATEWAY) {
		rtentry_ref_t gwrt;
		unsigned int ifscope;

		if (dst->sa_family == AF_INET) {
			ifscope = sin_get_ifscope(dst);
		} else if (dst->sa_family == AF_INET6) {
			ifscope = sin6_get_ifscope(dst);
		} else {
			ifscope = IFSCOPE_NONE;
		}

		RT_UNLOCK(rt);
		/*
		 * Don't ignore RTF_CLONING, since we prefer that rt_gwroute
		 * points to a clone rather than a cloning route; see above
		 * check for cloning loop avoidance (dst == gate).
		 */
		gwrt = rtalloc1_scoped_locked(gate, 1, RTF_PRCLONING, ifscope);
		if (gwrt != NULL) {
			RT_LOCK_ASSERT_NOTHELD(gwrt);
		}
		RT_LOCK(rt);

		/*
		 * Cloning loop avoidance:
		 *
		 * In the presence of protocol-cloning and bad configuration,
		 * it is possible to get stuck in bottomless mutual recursion
		 * (rtrequest rt_setgate rtalloc1).  We avoid this by not
		 * allowing protocol-cloning to operate for gateways (which
		 * is probably the correct choice anyway), and avoid the
		 * resulting reference loops by disallowing any route to run
		 * through itself as a gateway.  This is obviously mandatory
		 * when we get rt->rt_output().  It implies that a route to
		 * the gateway must already be present in the system in order
		 * for the gateway to be referred to by another route.
		 */
		if (gwrt == rt) {
			RT_REMREF_LOCKED(gwrt);
			/* Release extra ref */
			RT_REMREF_LOCKED(rt);
			return EADDRINUSE; /* failure */
		}

		/*
		 * If scoped, the gateway route must use the same interface;
		 * we're holding rnh_lock now, so rt_gateway and rt_ifp of gwrt
		 * should not change and are freely accessible.
		 */
		if (ifscope != IFSCOPE_NONE && (rt->rt_flags & RTF_IFSCOPE) &&
		    gwrt != NULL && gwrt->rt_ifp != NULL &&
		    gwrt->rt_ifp->if_index != ifscope) {
			rtfree_locked(gwrt);    /* rt != gwrt, no deadlock */
			/* Release extra ref */
			RT_REMREF_LOCKED(rt);
			return (rt->rt_flags & RTF_HOST) ?
			       EHOSTUNREACH : ENETUNREACH;
		}

		/* Check again since we dropped the lock above */
		if (rt->rt_flags & RTF_CONDEMNED) {
			if (gwrt != NULL) {
				rtfree_locked(gwrt);
			}
			/* Release extra ref */
			RT_REMREF_LOCKED(rt);
			return EBUSY;
		}

		/* Set gateway route; callee adds ref to gwrt if non-NULL */
		rt_set_gwroute(rt, dst, gwrt);

		/*
		 * In case the (non-scoped) default route gets modified via
		 * an ICMP redirect, record the interface index used for the
		 * primary ifscope.  Also done in rt_setif() to take care
		 * of the non-redirect cases.
		 */
		if (rt_primary_default(rt, dst) && rt->rt_ifp != NULL) {
			set_primary_ifscope(dst->sa_family,
			    rt->rt_ifp->if_index);
		}

#if NECP
		/*
		 * If this is a change in a default route, update
		 * necp client watchers to re-evaluate
		 */
		if (SA_DEFAULT(dst)) {
			necp_update_all_clients();
		}
#endif /* NECP */

		/*
		 * Tell the kernel debugger about the new default gateway
		 * if the gateway route uses the primary interface, or
		 * if we are in a transient state before the non-scoped
		 * default gateway is installed (similar to how the system
		 * was behaving in the past).  In future, it would be good
		 * to do all this only when KDP is enabled.
		 */
		if ((dst->sa_family == AF_INET) &&
		    gwrt != NULL && gwrt->rt_gateway->sa_family == AF_LINK &&
		    (gwrt->rt_ifp->if_index == get_primary_ifscope(AF_INET) ||
		    get_primary_ifscope(AF_INET) == IFSCOPE_NONE)) {
			kdp_set_gateway_mac(SDL(gwrt->rt_gateway)->
			    sdl_data);
		}

		/* Release extra ref from rtalloc1() */
		if (gwrt != NULL) {
			RT_REMREF(gwrt);
		}
	}

	/*
	 * Prepare to store the gateway in rt_gateway.  Both dst and gateway
	 * are stored one after the other in the same malloc'd chunk.  If we
	 * have room, reuse the old buffer since rt_gateway already points
	 * to the right place.  Otherwise, malloc a new block and update
	 * the 'dst' address and point rt_gateway to the right place.
	 */
	if (rt->rt_gateway == NULL || glen > SA_SIZE(rt->rt_gateway->sa_len)) {
		caddr_t new;

		/* The underlying allocation is done with M_WAITOK set */
		new = kalloc_data(dlen + glen, Z_WAITOK | Z_ZERO);
		if (new == NULL) {
			/* Clear gateway route */
			rt_set_gwroute(rt, dst, NULL);
			/* Release extra ref */
			RT_REMREF_LOCKED(rt);
			return ENOBUFS;
		}

		/*
		 * Copy from 'dst' and not rt_key(rt) because we can get
		 * here to initialize a newly allocated route entry, in
		 * which case rt_key(rt) is NULL (and so does rt_gateway).
		 */
		SOCKADDR_COPY(dst, new, dst->sa_len);
		rt_key_free(rt);     /* free old block; NULL is okay */
		rt->rt_nodes->rn_key = new;
		rt->rt_gateway = SA(new + dlen);
	}

	/*
	 * Copy the new gateway value into the memory chunk.
	 */
	SOCKADDR_COPY(gate, rt->rt_gateway, gate->sa_len);

	/*
	 * For consistency between rt_gateway and rt_key(gwrt).
	 */
	if ((rt->rt_flags & RTF_GATEWAY) && rt->rt_gwroute != NULL &&
	    (rt->rt_gwroute->rt_flags & RTF_IFSCOPE)) {
		if (rt->rt_gateway->sa_family == AF_INET &&
		    rt_key(rt->rt_gwroute)->sa_family == AF_INET) {
			sin_set_ifscope(rt->rt_gateway,
			    sin_get_ifscope(rt_key(rt->rt_gwroute)));
		} else if (rt->rt_gateway->sa_family == AF_INET6 &&
		    rt_key(rt->rt_gwroute)->sa_family == AF_INET6) {
			sin6_set_ifscope(rt->rt_gateway,
			    sin6_get_ifscope(rt_key(rt->rt_gwroute)));
		}
	}

	/*
	 * This isn't going to do anything useful for host routes, so
	 * don't bother.  Also make sure we have a reasonable mask
	 * (we don't yet have one during adds).
	 */
	if (!(rt->rt_flags & RTF_HOST) && rt_mask(rt) != 0) {
		struct rtfc_arg arg;
		arg.rnh = rnh;
		arg.rt0 = rt;
		RT_UNLOCK(rt);
		rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt),
		    rt_fixchange, &arg);
		RT_LOCK(rt);
	}

	/* Release extra ref */
	RT_REMREF_LOCKED(rt);
	return 0;
}

#undef SA_SIZE

void
rt_set_gwroute(struct rtentry *rt, struct sockaddr *dst, struct rtentry *gwrt)
{
	boolean_t gwrt_isrouter;

	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);
	RT_LOCK_ASSERT_HELD(rt);

	if (gwrt != NULL) {
		RT_ADDREF(gwrt);        /* for this routine */
	}
	/*
	 * Get rid of existing gateway route; if rt_gwroute is already
	 * set to gwrt, this is slightly redundant (though safe since
	 * we held an extra ref above) but makes the code simpler.
	 */
	if (rt->rt_gwroute != NULL) {
		rtentry_ref_t ogwrt = rt->rt_gwroute;

		VERIFY(rt != ogwrt);    /* sanity check */
		rt->rt_gwroute = NULL;
		RT_UNLOCK(rt);
		rtfree_locked(ogwrt);
		RT_LOCK(rt);
		VERIFY(rt->rt_gwroute == NULL);
	}

	/*
	 * And associate the new gateway route.
	 */
	if ((rt->rt_gwroute = gwrt) != NULL) {
		RT_ADDREF(gwrt);        /* for rt */

		if (rt->rt_flags & RTF_WASCLONED) {
			/* rt_parent might be NULL if rt is embryonic */
			gwrt_isrouter = (rt->rt_parent != NULL &&
			    SA_DEFAULT(rt_key(rt->rt_parent)) &&
			    !RT_HOST(rt->rt_parent));
		} else {
			gwrt_isrouter = (SA_DEFAULT(dst) && !RT_HOST(rt));
		}

		/* If gwrt points to a default router, mark it accordingly */
		if (gwrt_isrouter && RT_HOST(gwrt) &&
		    !(gwrt->rt_flags & RTF_ROUTER)) {
			RT_LOCK(gwrt);
			gwrt->rt_flags |= RTF_ROUTER;
			RT_UNLOCK(gwrt);
		}

		RT_REMREF(gwrt);        /* for this routine */
	}
}

static void
rt_maskedcopy(const struct sockaddr *src, struct sockaddr *dst,
    const struct sockaddr *netmask)
{
	const char *netmaskp = &netmask->sa_data[0];
	const char *srcp = &src->sa_data[0];
	char *dstp = &dst->sa_data[0];
	const char *maskend = (char *)dst
	    + MIN(netmask->sa_len, src->sa_len);
	const char *srcend = (char *)dst + src->sa_len;

	dst->sa_len = src->sa_len;
	dst->sa_family = src->sa_family;

	while (dstp < maskend) {
		*dstp++ = *srcp++ & *netmaskp++;
	}
	if (dstp < srcend) {
		memset(dstp, 0, (size_t)(srcend - dstp));
	}
}

/*
 * Lookup an AF_INET/AF_INET6 scoped or non-scoped route depending on the
 * ifscope value passed in by the caller (IFSCOPE_NONE implies non-scoped).
 */
static struct radix_node *
node_lookup(struct sockaddr *dst, struct sockaddr *netmask,
    unsigned int ifscope)
{
	struct radix_node_head *rnh;
	struct radix_node *rn;
	struct sockaddr_storage ss, mask;
	int af = dst->sa_family;
	struct matchleaf_arg ma = { .ifscope = ifscope };
	rn_matchf_t *f = rn_match_ifscope;
	void *w = &ma;

	if (af != AF_INET && af != AF_INET6) {
		return NULL;
	}

	rnh = rt_tables[af];

	/*
	 * Transform dst into the internal routing table form,
	 * clearing out the scope ID field if ifscope isn't set.
	 */
	dst = sa_copy(dst, &ss, (ifscope == IFSCOPE_NONE) ? NULL : &ifscope);

	/* Transform netmask into the internal routing table form */
	if (netmask != NULL) {
		netmask = ma_copy(af, netmask, &mask, ifscope);
	}

	if (ifscope == IFSCOPE_NONE) {
		f = w = NULL;
	}

	rn = rnh->rnh_lookup_args(dst, netmask, rnh, f, w);
	if (rn != NULL && (rn->rn_flags & RNF_ROOT)) {
		rn = NULL;
	}

	return rn;
}

/*
 * Lookup the AF_INET/AF_INET6 non-scoped default route.
 */
static struct radix_node *
node_lookup_default(int af)
{
	struct radix_node_head *rnh;

	VERIFY(af == AF_INET || af == AF_INET6);
	rnh = rt_tables[af];

	return af == AF_INET ? rnh->rnh_lookup(&sin_def, NULL, rnh) :
	       rnh->rnh_lookup(&sin6_def, NULL, rnh);
}

boolean_t
rt_ifa_is_dst(struct sockaddr *dst, struct ifaddr *ifa)
{
	boolean_t result = FALSE;

	if (ifa == NULL || ifa->ifa_addr == NULL) {
		return result;
	}

	IFA_LOCK_SPIN(ifa);

	if (dst->sa_family == ifa->ifa_addr->sa_family &&
	    ((dst->sa_family == AF_INET &&
	    SIN(dst)->sin_addr.s_addr ==
	    SIN(ifa->ifa_addr)->sin_addr.s_addr) ||
	    (dst->sa_family == AF_INET6 &&
	    SA6_ARE_ADDR_EQUAL(SIN6(dst), SIN6(ifa->ifa_addr))))) {
		result = TRUE;
	}

	IFA_UNLOCK(ifa);

	return result;
}

/*
 * Common routine to lookup/match a route.  It invokes the lookup/matchaddr
 * callback which could be address family-specific.  The main difference
 * between the two (at least for AF_INET/AF_INET6) is that a lookup does
 * not alter the expiring state of a route, whereas a match would unexpire
 * or revalidate the route.
 *
 * The optional scope or interface index property of a route allows for a
 * per-interface route instance.  This permits multiple route entries having
 * the same destination (but not necessarily the same gateway) to exist in
 * the routing table; each of these entries is specific to the corresponding
 * interface.  This is made possible by storing the scope ID value into the
 * radix key, thus making each route entry unique.  These scoped entries
 * exist along with the regular, non-scoped entries in the same radix tree
 * for a given address family (AF_INET/AF_INET6); the scope logically
 * partitions it into multiple per-interface sub-trees.
 *
 * When a scoped route lookup is performed, the routing table is searched for
 * the best match that would result in a route using the same interface as the
 * one associated with the scope (the exception to this are routes that point
 * to the loopback interface).  The search rule follows the longest matching
 * prefix with the additional interface constraint.
 */
static struct rtentry *
rt_lookup_common(boolean_t lookup_only, boolean_t coarse, struct sockaddr *dst,
    struct sockaddr *netmask, struct radix_node_head *rnh, unsigned int ifscope)
{
	struct radix_node *rn0, *rn = NULL;
	int af = dst->sa_family;
	struct sockaddr_storage dst_ss;
	struct sockaddr_storage mask_ss;
	boolean_t dontcare;
#if (DEVELOPMENT || DEBUG)
	char dbuf[MAX_SCOPE_ADDR_STR_LEN], gbuf[MAX_IPv6_STR_LEN];
	char s_dst[MAX_IPv6_STR_LEN], s_netmask[MAX_IPv6_STR_LEN];
#endif
	VERIFY(!coarse || ifscope == IFSCOPE_NONE);

	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);
	/*
	 * While we have rnh_lock held, see if we need to schedule the timer.
	 */
	if (nd6_sched_timeout_want) {
		nd6_sched_timeout(NULL, NULL);
	}

	if (!lookup_only) {
		netmask = NULL;
	}

	/*
	 * Non-scoped route lookup.
	 */
	if (af != AF_INET && af != AF_INET6) {
		rn = rnh->rnh_matchaddr(dst, rnh);

		/*
		 * Don't return a root node; also, rnh_matchaddr callback
		 * would have done the necessary work to clear RTPRF_OURS
		 * for certain protocol families.
		 */
		if (rn != NULL && (rn->rn_flags & RNF_ROOT)) {
			rn = NULL;
		}
		if (rn != NULL) {
			RT_LOCK_SPIN(RT(rn));
			if (!(RT(rn)->rt_flags & RTF_CONDEMNED)) {
				RT_ADDREF_LOCKED(RT(rn));
				RT_UNLOCK(RT(rn));
			} else {
				RT_UNLOCK(RT(rn));
				rn = NULL;
			}
		}
		return RT(rn);
	}

	/* Transform dst/netmask into the internal routing table form */
	dst = sa_copy(dst, &dst_ss, &ifscope);
	if (netmask != NULL) {
		netmask = ma_copy(af, netmask, &mask_ss, ifscope);
	}
	dontcare = (ifscope == IFSCOPE_NONE);

#if (DEVELOPMENT || DEBUG)
	if (rt_verbose > 2) {
		if (af == AF_INET) {
			(void) inet_ntop(af, &SIN(dst)->sin_addr.s_addr,
			    s_dst, sizeof(s_dst));
		} else {
			(void) inet_ntop(af, &SIN6(dst)->sin6_addr,
			    s_dst, sizeof(s_dst));
		}

		if (netmask != NULL && af == AF_INET) {
			(void) inet_ntop(af, &SIN(netmask)->sin_addr.s_addr,
			    s_netmask, sizeof(s_netmask));
		}
		if (netmask != NULL && af == AF_INET6) {
			(void) inet_ntop(af, &SIN6(netmask)->sin6_addr,
			    s_netmask, sizeof(s_netmask));
		} else {
			*s_netmask = '\0';
		}
		os_log(OS_LOG_DEFAULT, "%s:%d (%d, %d, %s, %s, %u)\n",
		    __func__, __LINE__, lookup_only, coarse, s_dst, s_netmask, ifscope);
	}
#endif

	/*
	 * Scoped route lookup:
	 *
	 * We first perform a non-scoped lookup for the original result.
	 * Afterwards, depending on whether or not the caller has specified
	 * a scope, we perform a more specific scoped search and fallback
	 * to this original result upon failure.
	 */
	rn0 = rn = node_lookup(dst, netmask, IFSCOPE_NONE);

	/*
	 * If the caller did not specify a scope, use the primary scope
	 * derived from the system's non-scoped default route.  If, for
	 * any reason, there is no primary interface, ifscope will be
	 * set to IFSCOPE_NONE; if the above lookup resulted in a route,
	 * we'll do a more-specific search below, scoped to the interface
	 * of that route.
	 */
	if (dontcare) {
		ifscope = get_primary_ifscope(af);
	}

	/*
	 * Keep the original result if either of the following is true:
	 *
	 *   1) The interface portion of the route has the same interface
	 *	index as the scope value and it is marked with RTF_IFSCOPE.
	 *   2) The route uses the loopback interface, in which case the
	 *	destination (host/net) is local/loopback.
	 *
	 * Otherwise, do a more specified search using the scope;
	 * we're holding rnh_lock now, so rt_ifp should not change.
	 */
	if (rn != NULL) {
		rtentry_ref_t rt = RT(rn);
#if (DEVELOPMENT || DEBUG)
		if (rt_verbose > 2) {
			rt_str(rt, dbuf, sizeof(dbuf), gbuf, sizeof(gbuf));
			os_log(OS_LOG_DEFAULT, "%s unscoped search %p to %s->%s->%s ifa_ifp %s\n",
			    __func__, rt,
			    dbuf, gbuf,
			    (rt->rt_ifp != NULL) ? rt->rt_ifp->if_xname : "",
			    (rt->rt_ifa->ifa_ifp != NULL) ?
			    rt->rt_ifa->ifa_ifp->if_xname : "");
		}
#endif
		if (!(rt->rt_ifp->if_flags & IFF_LOOPBACK) ||
		    (rt->rt_flags & RTF_GATEWAY)) {
			if (rt->rt_ifp->if_index != ifscope) {
				/*
				 * Wrong interface; keep the original result
				 * only if the caller did not specify a scope,
				 * and do a more specific scoped search using
				 * the scope of the found route.  Otherwise,
				 * start again from scratch.
				 *
				 * For loopback scope we keep the unscoped
				 * route for local addresses
				 */
				rn = NULL;
				if (dontcare) {
					ifscope = rt->rt_ifp->if_index;
				} else if (ifscope != lo_ifp->if_index ||
				    rt_ifa_is_dst(dst, rt->rt_ifa) == FALSE) {
					rn0 = NULL;
				}
			} else if (!(rt->rt_flags & RTF_IFSCOPE)) {
				/*
				 * Right interface, except that this route
				 * isn't marked with RTF_IFSCOPE.  Do a more
				 * specific scoped search.  Keep the original
				 * result and return it it in case the scoped
				 * search fails.
				 */
				rn = NULL;
			}
		}
	}

	/*
	 * Scoped search.  Find the most specific entry having the same
	 * interface scope as the one requested.  The following will result
	 * in searching for the longest prefix scoped match.
	 */
	if (rn == NULL) {
		rn = node_lookup(dst, netmask, ifscope);
#if (DEVELOPMENT || DEBUG)
		if (rt_verbose > 2 && rn != NULL) {
			rtentry_ref_t rt = RT(rn);
			rt_str(rt, dbuf, sizeof(dbuf), gbuf, sizeof(gbuf));
			os_log(OS_LOG_DEFAULT, "%s scoped search %p to %s->%s->%s ifa %s\n",
			    __func__, rt,
			    dbuf, gbuf,
			    (rt->rt_ifp != NULL) ? rt->rt_ifp->if_xname : "",
			    (rt->rt_ifa->ifa_ifp != NULL) ?
			    rt->rt_ifa->ifa_ifp->if_xname : "");
		}
#endif
	}
	/*
	 * Use the original result if either of the following is true:
	 *
	 *   1) The scoped search did not yield any result.
	 *   2) The caller insists on performing a coarse-grained lookup.
	 *   3) The result from the scoped search is a scoped default route,
	 *	and the original (non-scoped) result is not a default route,
	 *	i.e. the original result is a more specific host/net route.
	 *   4)	The scoped search yielded a net route but the original
	 *	result is a host route, i.e. the original result is treated
	 *	as a more specific route.
	 */
	if (rn == NULL || coarse || (rn0 != NULL &&
	    ((SA_DEFAULT(rt_key(RT(rn))) && !SA_DEFAULT(rt_key(RT(rn0)))) ||
	    (!RT_HOST(rn) && RT_HOST(rn0))))) {
		rn = rn0;
	}

	/*
	 * If we still don't have a route, use the non-scoped default
	 * route as long as the interface portion satistifes the scope.
	 */
	if (rn == NULL && (rn = node_lookup_default(af)) != NULL &&
	    RT(rn)->rt_ifp->if_index != ifscope) {
		rn = NULL;
	}

	if (rn != NULL) {
		/*
		 * Manually clear RTPRF_OURS using rt_validate() and
		 * bump up the reference count after, and not before;
		 * we only get here for AF_INET/AF_INET6.  node_lookup()
		 * has done the check against RNF_ROOT, so we can be sure
		 * that we're not returning a root node here.
		 */
		RT_LOCK_SPIN(RT(rn));
		if (rt_validate(RT(rn))) {
			RT_ADDREF_LOCKED(RT(rn));
			RT_UNLOCK(RT(rn));
		} else {
			RT_UNLOCK(RT(rn));
			rn = NULL;
		}
	}
#if (DEVELOPMENT || DEBUG)
	if (rt_verbose > 2) {
		if (rn == NULL) {
			os_log(OS_LOG_DEFAULT, "%s %u return NULL\n", __func__, ifscope);
		} else {
			rtentry_ref_t rt = RT(rn);

			rt_str(rt, dbuf, sizeof(dbuf), gbuf, sizeof(gbuf));

			os_log(OS_LOG_DEFAULT, "%s %u return %p to %s->%s->%s ifa_ifp %s\n",
			    __func__, ifscope, rt,
			    dbuf, gbuf,
			    (rt->rt_ifp != NULL) ? rt->rt_ifp->if_xname : "",
			    (rt->rt_ifa->ifa_ifp != NULL) ?
			    rt->rt_ifa->ifa_ifp->if_xname : "");
		}
	}
#endif
	return RT(rn);
}

struct rtentry *
rt_lookup(boolean_t lookup_only, struct sockaddr *dst, struct sockaddr *netmask,
    struct radix_node_head *rnh, unsigned int ifscope)
{
	return rt_lookup_common(lookup_only, FALSE, dst, netmask,
	           rnh, ifscope);
}

struct rtentry *
rt_lookup_coarse(boolean_t lookup_only, struct sockaddr *dst,
    struct sockaddr *netmask, struct radix_node_head *rnh)
{
	return rt_lookup_common(lookup_only, TRUE, dst, netmask,
	           rnh, IFSCOPE_NONE);
}

boolean_t
rt_validate(struct rtentry *rt)
{
	RT_LOCK_ASSERT_HELD(rt);

	if ((rt->rt_flags & (RTF_UP | RTF_CONDEMNED)) == RTF_UP) {
		int af = rt_key(rt)->sa_family;

		if (af == AF_INET) {
			(void) in_validate(RN(rt));
		} else if (af == AF_INET6) {
			(void) in6_validate(RN(rt));
		}
	} else {
		rt = NULL;
	}

	return rt != NULL;
}

/*
 * Set up a routing table entry, normally
 * for an interface.
 */
int
rtinit(struct ifaddr *ifa, uint8_t cmd, int flags)
{
	int error;

	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED);

	lck_mtx_lock(rnh_lock);
	error = rtinit_locked(ifa, cmd, flags);
	lck_mtx_unlock(rnh_lock);

	return error;
}

int
rtinit_locked(struct ifaddr *ifa, uint8_t cmd, int flags)
{
	struct radix_node_head *rnh;
	uint8_t nbuf[128];      /* long enough for IPv6 */
	char dbuf[MAX_IPv6_STR_LEN], gbuf[MAX_IPv6_STR_LEN];
	char abuf[MAX_IPv6_STR_LEN];
	rtentry_ref_t rt = NULL;
	struct sockaddr *dst;
	struct sockaddr *netmask;
	int error = 0;

	/*
	 * Holding rnh_lock here prevents the possibility of ifa from
	 * changing (e.g. in_ifinit), so it is safe to access its
	 * ifa_{dst}addr (here and down below) without locking.
	 */
	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);

	if (flags & RTF_HOST) {
		dst = ifa->ifa_dstaddr;
		netmask = NULL;
	} else {
		dst = ifa->ifa_addr;
		netmask = ifa->ifa_netmask;
	}

	if (dst->sa_len == 0) {
		log(LOG_ERR, "%s: %s failed, invalid dst sa_len %d\n",
		    __func__, rtm2str(cmd), dst->sa_len);
		error = EINVAL;
		goto done;
	}
	if (netmask != NULL && netmask->sa_len > sizeof(nbuf)) {
		log(LOG_ERR, "%s: %s failed, mask sa_len %d too large\n",
		    __func__, rtm2str(cmd), dst->sa_len);
		error = EINVAL;
		goto done;
	}

	if (rt_verbose) {
		if (dst->sa_family == AF_INET) {
			(void) inet_ntop(AF_INET, &SIN(dst)->sin_addr.s_addr,
					abuf, sizeof(abuf));
		} else if (dst->sa_family == AF_INET6) {
			(void) inet_ntop(AF_INET6, &SIN6(dst)->sin6_addr,
					abuf, sizeof(abuf));
		}
	}

	if ((rnh = rt_tables[dst->sa_family]) == NULL) {
		error = EINVAL;
		goto done;
	}

	/*
	 * If it's a delete, check that if it exists, it's on the correct
	 * interface or we might scrub a route to another ifa which would
	 * be confusing at best and possibly worse.
	 */
	if (cmd == RTM_DELETE) {
		/*
		 * It's a delete, so it should already exist..
		 * If it's a net, mask off the host bits
		 * (Assuming we have a mask)
		 */
		if (netmask != NULL) {
			rt_maskedcopy(dst, SA(nbuf), netmask);
			dst = SA(nbuf);
		}
		/*
		 * Get an rtentry that is in the routing tree and contains
		 * the correct info.  Note that we perform a coarse-grained
		 * lookup here, in case there is a scoped variant of the
		 * subnet/prefix route which we should ignore, as we never
		 * add a scoped subnet/prefix route as part of adding an
		 * interface address.
		 */
		rt = rt_lookup_coarse(TRUE, dst, NULL, rnh);
		if (rt != NULL) {
			if (rt_verbose) {
				rt_str(rt, dbuf, sizeof(dbuf), gbuf, sizeof(gbuf));
			}

			/*
			 * Ok so we found the rtentry. it has an extra reference
			 * for us at this stage. we won't need that so
			 * lop that off now.
			 */
			RT_LOCK(rt);
			if (rt->rt_ifa != ifa) {
				/*
				 * If the interface address in the rtentry
				 * doesn't match the interface we are using,
				 * then we don't want to delete it, so return
				 * an error.  This seems to be the only point
				 * of this whole RTM_DELETE clause.
				 */
#if (DEVELOPMENT || DEBUG)
				if (rt_verbose) {
					log(LOG_DEBUG, "%s: not removing "
					    "route to %s->%s->%s, flags 0x%x, "
					    "ifaddr %s, rt_ifa 0x%llx != "
					    "ifa 0x%llx\n", __func__, dbuf,
					    gbuf, ((rt->rt_ifp != NULL) ?
					    rt->rt_ifp->if_xname : ""),
					    rt->rt_flags, abuf,
					    (uint64_t)VM_KERNEL_ADDRPERM(
						    rt->rt_ifa),
					    (uint64_t)VM_KERNEL_ADDRPERM(ifa));
				}
#endif /* (DEVELOPMENT || DEBUG) */
				RT_REMREF_LOCKED(rt);
				RT_UNLOCK(rt);
				rt = NULL;
				error = ((flags & RTF_HOST) ?
				    EHOSTUNREACH : ENETUNREACH);
				goto done;
			} else if (rt->rt_flags & RTF_STATIC) {
				/*
				 * Don't remove the subnet/prefix route if
				 * this was manually added from above.
				 */
#if (DEVELOPMENT || DEBUG)
				if (rt_verbose) {
					log(LOG_DEBUG, "%s: not removing "
					    "static route to %s->%s->%s, "
					    "flags 0x%x, ifaddr %s\n", __func__,
					    dbuf, gbuf, ((rt->rt_ifp != NULL) ?
					    rt->rt_ifp->if_xname : ""),
					    rt->rt_flags, abuf);
				}
#endif /* (DEVELOPMENT || DEBUG) */
				RT_REMREF_LOCKED(rt);
				RT_UNLOCK(rt);
				rt = NULL;
				error = EBUSY;
				goto done;
			}
			if (rt_verbose) {
				log(LOG_INFO, "%s: removing route to "
				    "%s->%s->%s, flags 0x%x, ifaddr %s\n",
				    __func__, dbuf, gbuf,
				    ((rt->rt_ifp != NULL) ?
				    rt->rt_ifp->if_xname : ""),
				    rt->rt_flags, abuf);
			}
			RT_REMREF_LOCKED(rt);
			RT_UNLOCK(rt);
			rt = NULL;
		}
	}
	/*
	 * Do the actual request
	 */
	if ((error = rtrequest_locked(cmd, dst, ifa->ifa_addr, netmask,
	    flags | ifa->ifa_flags, &rt)) != 0) {
		goto done;
	}

	VERIFY(rt != NULL);

	if (rt_verbose) {
		rt_str(rt, dbuf, sizeof(dbuf), gbuf, sizeof(gbuf));
	}

	switch (cmd) {
	case RTM_DELETE:
		/*
		 * If we are deleting, and we found an entry, then it's
		 * been removed from the tree.   Notify any listening
		 * routing agents of the change and throw it away.
		 */
		RT_LOCK(rt);
		rt_newaddrmsg(cmd, ifa, error, rt);
		RT_UNLOCK(rt);
		if (rt_verbose) {
			log(LOG_INFO, "%s: removed route to %s->%s->%s, "
			    "flags 0x%x, ifaddr %s\n", __func__, dbuf, gbuf,
			    ((rt->rt_ifp != NULL) ? rt->rt_ifp->if_xname : ""),
			    rt->rt_flags, abuf);
		}
		rtfree_locked(rt);
		break;

	case RTM_ADD:
		/*
		 * We are adding, and we have a returned routing entry.
		 * We need to sanity check the result.  If it came back
		 * with an unexpected interface, then it must have already
		 * existed or something.
		 */
		RT_LOCK(rt);
		if (rt->rt_ifa != ifa) {
			void (*ifa_rtrequest)
			(int, struct rtentry *, struct sockaddr *);
#if (DEVELOPMENT || DEBUG)
			if (rt_verbose) {
				if (!(rt->rt_ifa->ifa_ifp->if_flags &
				    (IFF_POINTOPOINT | IFF_LOOPBACK))) {
					log(LOG_ERR, "%s: %s route to %s->%s->%s, "
					    "flags 0x%x, ifaddr %s, rt_ifa 0x%llx != "
					    "ifa 0x%llx\n", __func__, rtm2str(cmd),
					    dbuf, gbuf, ((rt->rt_ifp != NULL) ?
					    rt->rt_ifp->if_xname : ""), rt->rt_flags,
					    abuf,
					    (uint64_t)VM_KERNEL_ADDRPERM(rt->rt_ifa),
					    (uint64_t)VM_KERNEL_ADDRPERM(ifa));
				}

				log(LOG_DEBUG, "%s: %s route to %s->%s->%s, "
				    "flags 0x%x, ifaddr %s, rt_ifa was 0x%llx "
				    "now 0x%llx\n", __func__, rtm2str(cmd),
				    dbuf, gbuf, ((rt->rt_ifp != NULL) ?
				    rt->rt_ifp->if_xname : ""), rt->rt_flags,
				    abuf,
				    (uint64_t)VM_KERNEL_ADDRPERM(rt->rt_ifa),
				    (uint64_t)VM_KERNEL_ADDRPERM(ifa));
			}
#endif /* (DEVELOPMENT || DEBUG) */

			/*
			 * Ask that the protocol in question
			 * remove anything it has associated with
			 * this route and ifaddr.
			 */
			ifa_rtrequest = rt->rt_ifa->ifa_rtrequest;
			if (ifa_rtrequest != NULL) {
				ifa_rtrequest(RTM_DELETE, rt, NULL);
			}
			/*
			 * Set the route's ifa.
			 */
			rtsetifa(rt, ifa);

			if (rt->rt_ifp != ifa->ifa_ifp) {
				/*
				 * Purge any link-layer info caching.
				 */
				if (rt->rt_llinfo_purge != NULL) {
					rt->rt_llinfo_purge(rt);
				}
				/*
				 * Adjust route ref count for the interfaces.
				 */
				if (rt->rt_if_ref_fn != NULL) {
					rt->rt_if_ref_fn(ifa->ifa_ifp, 1);
					rt->rt_if_ref_fn(rt->rt_ifp, -1);
				}
			}

			/*
			 * And substitute in references to the ifaddr
			 * we are adding.
			 */
			rt->rt_ifp = ifa->ifa_ifp;
			/*
			 * If rmx_mtu is not locked, update it
			 * to the MTU used by the new interface.
			 */
			if (!(rt->rt_rmx.rmx_locks & RTV_MTU)) {
				rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu;
				if (dst->sa_family == AF_INET &&
				    INTF_ADJUST_MTU_FOR_CLAT46(rt->rt_ifp)) {
					rt->rt_rmx.rmx_mtu = IN6_LINKMTU(rt->rt_ifp);
					/* Further adjust the size for CLAT46 expansion */
					rt->rt_rmx.rmx_mtu -= CLAT46_HDR_EXPANSION_OVERHD;
				}
			}

			/*
			 * Now ask the protocol to check if it needs
			 * any special processing in its new form.
			 */
			ifa_rtrequest = ifa->ifa_rtrequest;
			if (ifa_rtrequest != NULL) {
				ifa_rtrequest(RTM_ADD, rt, NULL);
			}
		} else {
			if (rt_verbose) {
				log(LOG_INFO, "%s: added route to %s->%s->%s, "
				    "flags 0x%x, ifaddr %s\n", __func__, dbuf,
				    gbuf, ((rt->rt_ifp != NULL) ?
				    rt->rt_ifp->if_xname : ""), rt->rt_flags,
				    abuf);
			}
		}
		/*
		 * notify any listening routing agents of the change
		 */
		rt_newaddrmsg(cmd, ifa, error, rt);
		/*
		 * We just wanted to add it; we don't actually need a
		 * reference.  This will result in a route that's added
		 * to the routing table without a reference count.  The
		 * RTM_DELETE code will do the necessary step to adjust
		 * the reference count at deletion time.
		 */
		RT_REMREF_LOCKED(rt);
		RT_UNLOCK(rt);
		break;

	default:
		VERIFY(0);
		/* NOTREACHED */
	}
done:
	return error;
}

static void
rt_set_idleref(struct rtentry *rt)
{
	RT_LOCK_ASSERT_HELD(rt);

	/*
	 * We currently keep idle refcnt only on unicast cloned routes
	 * that aren't marked with RTF_NOIFREF.
	 */
	if (rt->rt_parent != NULL && !(rt->rt_flags &
	    (RTF_NOIFREF | RTF_BROADCAST | RTF_MULTICAST)) &&
	    (rt->rt_flags & (RTF_UP | RTF_WASCLONED | RTF_IFREF)) ==
	    (RTF_UP | RTF_WASCLONED)) {
		rt_clear_idleref(rt);   /* drop existing refcnt if any  */
		rt->rt_if_ref_fn = rte_if_ref;
		/* Become a regular mutex, just in case */
		RT_CONVERT_LOCK(rt);
		rt->rt_if_ref_fn(rt->rt_ifp, 1);
		rt->rt_flags |= RTF_IFREF;
	}
}

void
rt_clear_idleref(struct rtentry *rt)
{
	RT_LOCK_ASSERT_HELD(rt);

	if (rt->rt_if_ref_fn != NULL) {
		VERIFY((rt->rt_flags & (RTF_NOIFREF | RTF_IFREF)) == RTF_IFREF);
		/* Become a regular mutex, just in case */
		RT_CONVERT_LOCK(rt);
		rt->rt_if_ref_fn(rt->rt_ifp, -1);
		rt->rt_flags &= ~RTF_IFREF;
		rt->rt_if_ref_fn = NULL;
	}
}

void
rt_set_proxy(struct rtentry *rt, boolean_t set)
{
	lck_mtx_lock(rnh_lock);
	RT_LOCK(rt);
	/*
	 * Search for any cloned routes which might have
	 * been formed from this node, and delete them.
	 */
	if (rt->rt_flags & (RTF_CLONING | RTF_PRCLONING)) {
		struct radix_node_head *rnh = rt_tables[rt_key(rt)->sa_family];

		if (set) {
			rt->rt_flags |= RTF_PROXY;
		} else {
			rt->rt_flags &= ~RTF_PROXY;
		}

		RT_UNLOCK(rt);
		if (rnh != NULL && rt_mask(rt)) {
			rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt),
			    rt_fixdelete, rt);
		}
	} else {
		RT_UNLOCK(rt);
	}
	lck_mtx_unlock(rnh_lock);
}

static void
rte_lock_init(struct rtentry *rt)
{
	lck_mtx_init(&rt->rt_lock, &rte_mtx_grp, &rte_mtx_attr);
}

static void
rte_lock_destroy(struct rtentry *rt)
{
	RT_LOCK_ASSERT_NOTHELD(rt);
	lck_mtx_destroy(&rt->rt_lock, &rte_mtx_grp);
}

void
rt_lock(struct rtentry *rt, boolean_t spin)
{
	RT_LOCK_ASSERT_NOTHELD(rt);
	if (spin) {
		lck_mtx_lock_spin(&rt->rt_lock);
	} else {
		lck_mtx_lock(&rt->rt_lock);
	}
	if (rte_debug & RTD_DEBUG) {
		rte_lock_debug((rtentry_dbg_ref_t)rt);
	}
}

void
rt_unlock(struct rtentry *rt)
{
	if (rte_debug & RTD_DEBUG) {
		rte_unlock_debug((rtentry_dbg_ref_t)rt);
	}
	lck_mtx_unlock(&rt->rt_lock);
}

static inline void
rte_lock_debug(struct rtentry_dbg *rte)
{
	uint32_t idx;

	RT_LOCK_ASSERT_HELD((rtentry_ref_t)rte);
	idx = os_atomic_inc_orig(&rte->rtd_lock_cnt, relaxed) % CTRACE_HIST_SIZE;
	if (rte_debug & RTD_TRACE) {
		ctrace_record(&rte->rtd_lock[idx]);
	}
}

static inline void
rte_unlock_debug(struct rtentry_dbg *rte)
{
	uint32_t idx;

	RT_LOCK_ASSERT_HELD((rtentry_ref_t)rte);
	idx = os_atomic_inc_orig(&rte->rtd_unlock_cnt, relaxed) % CTRACE_HIST_SIZE;
	if (rte_debug & RTD_TRACE) {
		ctrace_record(&rte->rtd_unlock[idx]);
	}
}

static struct rtentry *
rte_alloc(void)
{
	if (rte_debug & RTD_DEBUG) {
		return rte_alloc_debug();
	}

	return (rtentry_ref_t)zalloc(rte_zone);
}

static void
rte_free(struct rtentry *p)
{
	if (rte_debug & RTD_DEBUG) {
		rte_free_debug(p);
		return;
	}

	if (p->rt_refcnt != 0) {
		panic("rte_free: rte=%p refcnt=%d non-zero", p, p->rt_refcnt);
		/* NOTREACHED */
	}

	zfree(rte_zone, p);
}

static void
rte_if_ref(struct ifnet *ifp, int cnt)
{
	struct kev_msg ev_msg;
	struct net_event_data ev_data;
	uint32_t old;

	/* Force cnt to 1 increment/decrement */
	if (cnt < -1 || cnt > 1) {
		panic("%s: invalid count argument (%d)", __func__, cnt);
		/* NOTREACHED */
	}
	old = os_atomic_add_orig(&ifp->if_route_refcnt, cnt, relaxed);
	if (cnt < 0 && old == 0) {
		panic("%s: ifp=%p negative route refcnt!", __func__, ifp);
		/* NOTREACHED */
	}
	/*
	 * The following is done without first holding the ifnet lock,
	 * for performance reasons.  The relevant ifnet fields, with
	 * the exception of the if_idle_flags, are never changed
	 * during the lifetime of the ifnet.  The if_idle_flags
	 * may possibly be modified, so in the event that the value
	 * is stale because IFRF_IDLE_NOTIFY was cleared, we'd end up
	 * sending the event anyway.  This is harmless as it is just
	 * a notification to the monitoring agent in user space, and
	 * it is expected to check via SIOCGIFGETRTREFCNT again anyway.
	 */
	if ((ifp->if_idle_flags & IFRF_IDLE_NOTIFY) && cnt < 0 && old == 1) {
		bzero(&ev_msg, sizeof(ev_msg));
		bzero(&ev_data, sizeof(ev_data));

		ev_msg.vendor_code      = KEV_VENDOR_APPLE;
		ev_msg.kev_class        = KEV_NETWORK_CLASS;
		ev_msg.kev_subclass     = KEV_DL_SUBCLASS;
		ev_msg.event_code       = KEV_DL_IF_IDLE_ROUTE_REFCNT;

		strlcpy(&ev_data.if_name[0], ifp->if_name, IFNAMSIZ);

		ev_data.if_family       = ifp->if_family;
		ev_data.if_unit         = ifp->if_unit;
		ev_msg.dv[0].data_length = sizeof(struct net_event_data);
		ev_msg.dv[0].data_ptr   = &ev_data;

		dlil_post_complete_msg(NULL, &ev_msg);
	}
}

static inline struct rtentry *
rte_alloc_debug(void)
{
	rtentry_dbg_ref_t rte;

	rte = ((rtentry_dbg_ref_t)zalloc(rte_zone));
	if (rte != NULL) {
		bzero(rte, sizeof(*rte));
		if (rte_debug & RTD_TRACE) {
			ctrace_record(&rte->rtd_alloc);
		}
		rte->rtd_inuse = RTD_INUSE;
	}
	return (rtentry_ref_t)rte;
}

static inline void
rte_free_debug(struct rtentry *p)
{
	rtentry_dbg_ref_t rte = (rtentry_dbg_ref_t)p;

	if (p->rt_refcnt != 0) {
		panic("rte_free: rte=%p refcnt=%d", p, p->rt_refcnt);
		/* NOTREACHED */
	}
	if (rte->rtd_inuse == RTD_FREED) {
		panic("rte_free: double free rte=%p", rte);
		/* NOTREACHED */
	} else if (rte->rtd_inuse != RTD_INUSE) {
		panic("rte_free: corrupted rte=%p", rte);
		/* NOTREACHED */
	}
	bcopy((caddr_t)p, (caddr_t)&rte->rtd_entry_saved, sizeof(*p));
	/* Preserve rt_lock to help catch use-after-free cases */
	bzero((caddr_t)p, offsetof(struct rtentry, rt_lock));

	rte->rtd_inuse = RTD_FREED;

	if (rte_debug & RTD_TRACE) {
		ctrace_record(&rte->rtd_free);
	}

	if (!(rte_debug & RTD_NO_FREE)) {
		zfree(rte_zone, p);
	}
}

void
ctrace_record(ctrace_t *tr)
{
	tr->th = current_thread();
	bzero(tr->pc, sizeof(tr->pc));
	(void) OSBacktrace(tr->pc, CTRACE_STACK_SIZE);
}

void
route_clear(struct route *ro)
{
	if (ro == NULL) {
		return;
	}

	if (ro->ro_rt != NULL) {
		rtfree(ro->ro_rt);
		ro->ro_rt = NULL;
	}

	if (ro->ro_srcia != NULL) {
		ifa_remref(ro->ro_srcia);
		ro->ro_srcia = NULL;
	}
	return;
}


void
route_copyout(struct route *dst, const struct route *src, size_t length)
{
	/* Copy everything (rt, srcif, flags, dst) from src */
	bcopy(src, dst, length);

	/* Hold one reference for the local copy of struct route */
	if (dst->ro_rt != NULL) {
		RT_ADDREF(dst->ro_rt);
	}

	/* Hold one reference for the local copy of struct ifaddr */
	if (dst->ro_srcia != NULL) {
		ifa_addref(dst->ro_srcia);
	}
}

void
route_copyin(struct route *src, struct route *dst, size_t length)
{
	/*
	 * No cached route at the destination?
	 * If none, then remove old references if present
	 * and copy entire src route.
	 */
	if (dst->ro_rt == NULL) {
		/*
		 * Ditch the address in the cached copy (dst) since
		 * we're about to take everything there is in src.
		 */
		if (dst->ro_srcia != NULL) {
			ifa_remref(dst->ro_srcia);
		}
		/*
		 * Copy everything (rt, srcia, flags, dst) from src; the
		 * references to rt and/or srcia were held at the time
		 * of storage and are kept intact.
		 */
		bcopy(src, dst, length);
		goto done;
	}

	/*
	 * We know dst->ro_rt is not NULL here.
	 * If the src->ro_rt is the same, update srcia and flags
	 * and ditch the route in the local copy.
	 */
	if (dst->ro_rt == src->ro_rt) {
		dst->ro_flags = src->ro_flags;

		if (dst->ro_srcia != src->ro_srcia) {
			if (dst->ro_srcia != NULL) {
				ifa_remref(dst->ro_srcia);
			}
			dst->ro_srcia = src->ro_srcia;
		} else if (src->ro_srcia != NULL) {
			ifa_remref(src->ro_srcia);
		}
		rtfree(src->ro_rt);
		goto done;
	}

	/*
	 * If they are dst's ro_rt is not equal to src's,
	 * and src'd rt is not NULL, then remove old references
	 * if present and copy entire src route.
	 */
	if (src->ro_rt != NULL) {
		rtfree(dst->ro_rt);

		if (dst->ro_srcia != NULL) {
			ifa_remref(dst->ro_srcia);
		}
		bcopy(src, dst, length);
		goto done;
	}

	/*
	 * Here, dst's cached route is not NULL but source's is.
	 * Just get rid of all the other cached reference in src.
	 */
	if (src->ro_srcia != NULL) {
		/*
		 * Ditch src address in the local copy (src) since we're
		 * not caching the route entry anyway (ro_rt is NULL).
		 */
		ifa_remref(src->ro_srcia);
	}
done:
	/* This function consumes the references on src */
	src->ro_rt = NULL;
	src->ro_srcia = NULL;
}

/*
 * route_to_gwroute will find the gateway route for a given route.
 *
 * If the route is down, look the route up again.
 * If the route goes through a gateway, get the route to the gateway.
 * If the gateway route is down, look it up again.
 * If the route is set to reject, verify it hasn't expired.
 *
 * If the returned route is non-NULL, the caller is responsible for
 * releasing the reference and unlocking the route.
 */
#define senderr(e) { error = (e); goto bad; }
errno_t
route_to_gwroute(const struct sockaddr *net_dest, struct rtentry *hint0,
    struct rtentry **out_route)
{
	uint64_t timenow;
	rtentry_ref_t rt = hint0;
	rtentry_ref_t hint = hint0;
	errno_t error = 0;
	unsigned int ifindex;
	boolean_t gwroute;

	*out_route = NULL;

	if (rt == NULL) {
		return 0;
	}

	/*
	 * Next hop determination.  Because we may involve the gateway route
	 * in addition to the original route, locking is rather complicated.
	 * The general concept is that regardless of whether the route points
	 * to the original route or to the gateway route, this routine takes
	 * an extra reference on such a route.  This extra reference will be
	 * released at the end.
	 *
	 * Care must be taken to ensure that the "hint0" route never gets freed
	 * via rtfree(), since the caller may have stored it inside a struct
	 * route with a reference held for that placeholder.
	 */
	RT_LOCK_SPIN(rt);
	ifindex = rt->rt_ifp->if_index;
	RT_ADDREF_LOCKED(rt);
	if (!(rt->rt_flags & RTF_UP)) {
		RT_REMREF_LOCKED(rt);
		RT_UNLOCK(rt);
		/* route is down, find a new one */
		hint = rt = rtalloc1_scoped(
		    __DECONST_SA(net_dest), 1, 0, ifindex);
		if (hint != NULL) {
			RT_LOCK_SPIN(rt);
			ifindex = rt->rt_ifp->if_index;
		} else {
			senderr(EHOSTUNREACH);
		}
	}

	/*
	 * We have a reference to "rt" by now; it will either
	 * be released or freed at the end of this routine.
	 */
	RT_LOCK_ASSERT_HELD(rt);
	if ((gwroute = (rt->rt_flags & RTF_GATEWAY))) {
		rtentry_ref_t gwrt = rt->rt_gwroute;
		struct sockaddr_storage ss;
		struct sockaddr *gw = SA(&ss);

		VERIFY(rt == hint);
		RT_ADDREF_LOCKED(hint);

		/* If there's no gateway rt, look it up */
		if (gwrt == NULL) {
			SOCKADDR_COPY(rt->rt_gateway, gw, MIN(sizeof(ss),
			    rt->rt_gateway->sa_len));
			gw->sa_len = MIN(sizeof(ss), rt->rt_gateway->sa_len);
			RT_UNLOCK(rt);
			goto lookup;
		}
		/* Become a regular mutex */
		RT_CONVERT_LOCK(rt);

		/*
		 * Take gwrt's lock while holding route's lock;
		 * this is okay since gwrt never points back
		 * to "rt", so no lock ordering issues.
		 */
		RT_LOCK_SPIN(gwrt);
		if (!(gwrt->rt_flags & RTF_UP)) {
			rt->rt_gwroute = NULL;
			RT_UNLOCK(gwrt);
			SOCKADDR_COPY(rt->rt_gateway, gw, MIN(sizeof(ss),
			    rt->rt_gateway->sa_len));
			gw->sa_len = MIN(sizeof(ss), rt->rt_gateway->sa_len);
			RT_UNLOCK(rt);
			rtfree(gwrt);
lookup:
			lck_mtx_lock(rnh_lock);
			gwrt = rtalloc1_scoped_locked(gw, 1, 0, ifindex);

			RT_LOCK(rt);
			/*
			 * Bail out if the route is down, no route
			 * to gateway, circular route, or if the
			 * gateway portion of "rt" has changed.
			 */
			if (!(rt->rt_flags & RTF_UP) || gwrt == NULL ||
			    gwrt == rt || !sa_equal(gw, rt->rt_gateway)) {
				if (gwrt == rt) {
					RT_REMREF_LOCKED(gwrt);
					gwrt = NULL;
				}
				VERIFY(rt == hint);
				RT_REMREF_LOCKED(hint);
				hint = NULL;
				RT_UNLOCK(rt);
				if (gwrt != NULL) {
					rtfree_locked(gwrt);
				}
				lck_mtx_unlock(rnh_lock);
				senderr(EHOSTUNREACH);
			}
			VERIFY(gwrt != NULL);
			/*
			 * Set gateway route; callee adds ref to gwrt;
			 * gwrt has an extra ref from rtalloc1() for
			 * this routine.
			 */
			rt_set_gwroute(rt, rt_key(rt), gwrt);
			VERIFY(rt == hint);
			RT_REMREF_LOCKED(rt);   /* hint still holds a refcnt */
			RT_UNLOCK(rt);
			lck_mtx_unlock(rnh_lock);
			rt = gwrt;
		} else {
			RT_ADDREF_LOCKED(gwrt);
			RT_UNLOCK(gwrt);
			VERIFY(rt == hint);
			RT_REMREF_LOCKED(rt);   /* hint still holds a refcnt */
			RT_UNLOCK(rt);
			rt = gwrt;
		}
		VERIFY(rt == gwrt && rt != hint);

		/*
		 * This is an opportunity to revalidate the parent route's
		 * rt_gwroute, in case it now points to a dead route entry.
		 * Parent route won't go away since the clone (hint) holds
		 * a reference to it.  rt == gwrt.
		 */
		RT_LOCK_SPIN(hint);
		if ((hint->rt_flags & (RTF_WASCLONED | RTF_UP)) ==
		    (RTF_WASCLONED | RTF_UP)) {
			rtentry_ref_t prt = hint->rt_parent;
			VERIFY(prt != NULL);

			RT_CONVERT_LOCK(hint);
			RT_ADDREF(prt);
			RT_UNLOCK(hint);
			rt_revalidate_gwroute(prt, rt);
			RT_REMREF(prt);
		} else {
			RT_UNLOCK(hint);
		}

		/* Clean up "hint" now; see notes above regarding hint0 */
		if (hint == hint0) {
			RT_REMREF(hint);
		} else {
			rtfree(hint);
		}
		hint = NULL;

		/* rt == gwrt; if it is now down, give up */
		RT_LOCK_SPIN(rt);
		if (!(rt->rt_flags & RTF_UP)) {
			RT_UNLOCK(rt);
			senderr(EHOSTUNREACH);
		}
	}

	if (rt->rt_flags & RTF_REJECT) {
		VERIFY(rt->rt_expire == 0 || rt->rt_rmx.rmx_expire != 0);
		VERIFY(rt->rt_expire != 0 || rt->rt_rmx.rmx_expire == 0);
		timenow = net_uptime();
		if (rt->rt_expire == 0 || timenow < rt->rt_expire) {
			RT_UNLOCK(rt);
			senderr(!gwroute ? EHOSTDOWN : EHOSTUNREACH);
		}
	}

	/* Become a regular mutex */
	RT_CONVERT_LOCK(rt);

	/* Caller is responsible for cleaning up "rt" */
	*out_route = rt;
	return 0;

bad:
	/* Clean up route (either it is "rt" or "gwrt") */
	if (rt != NULL) {
		RT_LOCK_SPIN(rt);
		if (rt == hint0) {
			RT_REMREF_LOCKED(rt);
			RT_UNLOCK(rt);
		} else {
			RT_UNLOCK(rt);
			rtfree(rt);
		}
	}
	return error;
}
#undef senderr

void
rt_revalidate_gwroute(struct rtentry *rt, struct rtentry *gwrt)
{
	VERIFY(gwrt != NULL);

	RT_LOCK_SPIN(rt);
	if ((rt->rt_flags & (RTF_GATEWAY | RTF_UP)) == (RTF_GATEWAY | RTF_UP) &&
	    rt->rt_ifp == gwrt->rt_ifp && rt->rt_gateway->sa_family ==
	    rt_key(gwrt)->sa_family && (rt->rt_gwroute == NULL ||
	    !(rt->rt_gwroute->rt_flags & RTF_UP))) {
		boolean_t isequal;
		VERIFY(rt->rt_flags & (RTF_CLONING | RTF_PRCLONING));

		if (rt->rt_gateway->sa_family == AF_INET ||
		    rt->rt_gateway->sa_family == AF_INET6) {
			struct sockaddr_storage key_ss, gw_ss;
			/*
			 * We need to compare rt_key and rt_gateway; create
			 * local copies to get rid of any ifscope association.
			 */
			(void) sa_copy(rt_key(gwrt), &key_ss, NULL);
			(void) sa_copy(rt->rt_gateway, &gw_ss, NULL);

			isequal = sa_equal(SA(&key_ss), SA(&gw_ss));
		} else {
			isequal = sa_equal(rt_key(gwrt), rt->rt_gateway);
		}

		/* If they are the same, update gwrt */
		if (isequal) {
			RT_UNLOCK(rt);
			lck_mtx_lock(rnh_lock);
			RT_LOCK(rt);
			rt_set_gwroute(rt, rt_key(rt), gwrt);
			RT_UNLOCK(rt);
			lck_mtx_unlock(rnh_lock);
		} else {
			RT_UNLOCK(rt);
		}
	} else {
		RT_UNLOCK(rt);
	}
}

static void
rt_str4(struct rtentry *rt, char *ds, uint32_t dslen, char *gs, uint32_t gslen)
{
	VERIFY(rt_key(rt)->sa_family == AF_INET);

	if (ds != NULL) {
		(void) inet_ntop(AF_INET,
		    &SIN(rt_key(rt))->sin_addr.s_addr, ds, dslen);
		if (dslen >= MAX_SCOPE_ADDR_STR_LEN &&
		    SINIFSCOPE(rt_key(rt))->sin_scope_id != IFSCOPE_NONE) {
			char scpstr[16];

			snprintf(scpstr, sizeof(scpstr), "@%u",
			    SINIFSCOPE(rt_key(rt))->sin_scope_id);

			strlcat(ds, scpstr, dslen);
		}
	}

	if (gs != NULL) {
		if (rt->rt_flags & RTF_GATEWAY) {
			(void) inet_ntop(AF_INET,
			    &SIN(rt->rt_gateway)->sin_addr.s_addr, gs, gslen);
		} else if (rt->rt_ifp != NULL) {
			snprintf(gs, gslen, "link#%u", rt->rt_ifp->if_unit);
		} else {
			snprintf(gs, gslen, "%s", "link");
		}
	}
}

static void
rt_str6(struct rtentry *rt, char *ds, uint32_t dslen, char *gs, uint32_t gslen)
{
	VERIFY(rt_key(rt)->sa_family == AF_INET6);

	if (ds != NULL) {
		(void) inet_ntop(AF_INET6,
		    &SIN6(rt_key(rt))->sin6_addr, ds, dslen);
		if (dslen >= MAX_SCOPE_ADDR_STR_LEN &&
		    SIN6IFSCOPE(rt_key(rt))->sin6_scope_id != IFSCOPE_NONE) {
			char scpstr[16];

			snprintf(scpstr, sizeof(scpstr), "@%u",
			    SIN6IFSCOPE(rt_key(rt))->sin6_scope_id);

			strlcat(ds, scpstr, dslen);
		}
	}

	if (gs != NULL) {
		if (rt->rt_flags & RTF_GATEWAY) {
			(void) inet_ntop(AF_INET6,
			    &SIN6(rt->rt_gateway)->sin6_addr, gs, gslen);
		} else if (rt->rt_ifp != NULL) {
			snprintf(gs, gslen, "link#%u", rt->rt_ifp->if_unit);
		} else {
			snprintf(gs, gslen, "%s", "link");
		}
	}
}

void
rt_str(struct rtentry *rt, char *ds, uint32_t dslen, char *gs, uint32_t gslen)
{
	switch (rt_key(rt)->sa_family) {
	case AF_INET:
		rt_str4(rt, ds, dslen, gs, gslen);
		break;
	case AF_INET6:
		rt_str6(rt, ds, dslen, gs, gslen);
		break;
	default:
		if (ds != NULL) {
			bzero(ds, dslen);
		}
		if (gs != NULL) {
			bzero(gs, gslen);
		}
		break;
	}
}

void
route_event_init(struct route_event *p_route_ev, struct rtentry *rt,
    struct rtentry *gwrt, int route_ev_code)
{
	VERIFY(p_route_ev != NULL);
	bzero(p_route_ev, sizeof(*p_route_ev));

	p_route_ev->rt = rt;
	p_route_ev->gwrt = gwrt;
	p_route_ev->route_event_code = route_ev_code;
}

struct route_event_nwk_wq_entry {
	struct nwk_wq_entry nwk_wqe;
	struct route_event rt_ev_arg;
};

static void
route_event_callback(struct nwk_wq_entry *nwk_item)
{
	struct route_event_nwk_wq_entry *p_ev = __container_of(nwk_item,
	    struct route_event_nwk_wq_entry, nwk_wqe);

	rtentry_ref_t rt = p_ev->rt_ev_arg.rt;
	eventhandler_tag evtag = p_ev->rt_ev_arg.evtag;
	int route_ev_code = p_ev->rt_ev_arg.route_event_code;

	if (route_ev_code == ROUTE_EVHDLR_DEREGISTER) {
		VERIFY(evtag != NULL);
		EVENTHANDLER_DEREGISTER(&rt->rt_evhdlr_ctxt, route_event,
		    evtag);
		rtfree(rt);
		kfree_type(struct route_event_nwk_wq_entry, p_ev);
		return;
	}

	EVENTHANDLER_INVOKE(&rt->rt_evhdlr_ctxt, route_event, rt_key(rt),
	    route_ev_code, SA(&p_ev->rt_ev_arg.rtev_ipaddr),
	    rt->rt_flags);

	/* The code enqueuing the route event held a reference */
	rtfree(rt);
	/* XXX No reference is taken on gwrt */
	kfree_type(struct route_event_nwk_wq_entry, p_ev);
}

int
route_event_walktree(struct radix_node *rn, void *arg)
{
	struct route_event *p_route_ev = (struct route_event *)arg;
	rtentry_ref_t rt = (rtentry_ref_t)rn;
	rtentry_ref_t gwrt = p_route_ev->rt;

	LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);

	RT_LOCK(rt);

	/* Return if the entry is pending cleanup */
	if (rt->rt_flags & RTPRF_OURS) {
		RT_UNLOCK(rt);
		return 0;
	}

	/* Return if it is not an indirect route */
	if (!(rt->rt_flags & RTF_GATEWAY)) {
		RT_UNLOCK(rt);
		return 0;
	}

	if (rt->rt_gwroute != gwrt) {
		RT_UNLOCK(rt);
		return 0;
	}

	route_event_enqueue_nwk_wq_entry(rt, gwrt, p_route_ev->route_event_code,
	    NULL, TRUE);
	RT_UNLOCK(rt);

	return 0;
}

void
route_event_enqueue_nwk_wq_entry(struct rtentry *rt, struct rtentry *gwrt,
    uint32_t route_event_code, eventhandler_tag evtag, boolean_t rt_locked)
{
	struct route_event_nwk_wq_entry *p_rt_ev = NULL;
	struct sockaddr *p_gw_saddr = NULL;

	p_rt_ev = kalloc_type(struct route_event_nwk_wq_entry,
	    Z_WAITOK | Z_ZERO | Z_NOFAIL);

	/*
	 * If the intent is to de-register, don't take
	 * reference, route event registration already takes
	 * a reference on route.
	 */
	if (route_event_code != ROUTE_EVHDLR_DEREGISTER) {
		/* The reference is released by route_event_callback */
		if (rt_locked) {
			RT_ADDREF_LOCKED(rt);
		} else {
			RT_ADDREF(rt);
		}
	}

	p_rt_ev->rt_ev_arg.rt = rt;
	p_rt_ev->rt_ev_arg.gwrt = gwrt;
	p_rt_ev->rt_ev_arg.evtag = evtag;

	if (gwrt != NULL) {
		p_gw_saddr = gwrt->rt_gateway;
	} else {
		p_gw_saddr = rt->rt_gateway;
	}

	VERIFY(p_gw_saddr->sa_len <= sizeof(p_rt_ev->rt_ev_arg.rt_addr));
	SOCKADDR_COPY(p_gw_saddr, &(p_rt_ev->rt_ev_arg.rtev_ipaddr), p_gw_saddr->sa_len);

	p_rt_ev->rt_ev_arg.route_event_code = route_event_code;
	p_rt_ev->nwk_wqe.func = route_event_callback;
	nwk_wq_enqueue(&p_rt_ev->nwk_wqe);
}

const char *
route_event2str(int route_event)
{
	const char *route_event_str = "ROUTE_EVENT_UNKNOWN";
	switch (route_event) {
	case ROUTE_STATUS_UPDATE:
		route_event_str = "ROUTE_STATUS_UPDATE";
		break;
	case ROUTE_ENTRY_REFRESH:
		route_event_str = "ROUTE_ENTRY_REFRESH";
		break;
	case ROUTE_ENTRY_DELETED:
		route_event_str = "ROUTE_ENTRY_DELETED";
		break;
	case ROUTE_LLENTRY_RESOLVED:
		route_event_str = "ROUTE_LLENTRY_RESOLVED";
		break;
	case ROUTE_LLENTRY_UNREACH:
		route_event_str = "ROUTE_LLENTRY_UNREACH";
		break;
	case ROUTE_LLENTRY_CHANGED:
		route_event_str = "ROUTE_LLENTRY_CHANGED";
		break;
	case ROUTE_LLENTRY_STALE:
		route_event_str = "ROUTE_LLENTRY_STALE";
		break;
	case ROUTE_LLENTRY_TIMEDOUT:
		route_event_str = "ROUTE_LLENTRY_TIMEDOUT";
		break;
	case ROUTE_LLENTRY_DELETED:
		route_event_str = "ROUTE_LLENTRY_DELETED";
		break;
	case ROUTE_LLENTRY_EXPIRED:
		route_event_str = "ROUTE_LLENTRY_EXPIRED";
		break;
	case ROUTE_LLENTRY_PROBED:
		route_event_str = "ROUTE_LLENTRY_PROBED";
		break;
	case ROUTE_EVHDLR_DEREGISTER:
		route_event_str = "ROUTE_EVHDLR_DEREGISTER";
		break;
	default:
		/* Init'd to ROUTE_EVENT_UNKNOWN */
		break;
	}
	return route_event_str;
}

int
route_op_entitlement_check(struct socket *so,
    kauth_cred_t cred,
    int route_op_type,
    boolean_t allow_root)
{
	if (so != NULL) {
		if (route_op_type == ROUTE_OP_READ) {
			/*
			 * If needed we can later extend this for more
			 * granular entitlements and return a bit set of
			 * allowed accesses.
			 */
			if (soopt_cred_check(so, PRIV_NET_RESTRICTED_ROUTE_NC_READ,
			    allow_root, false) == 0) {
				return 0;
			} else {
				return -1;
			}
		}
	} else if (cred != NULL) {
		uid_t uid = kauth_cred_getuid(cred);

		/* uid is 0 for root */
		if (uid != 0 || !allow_root) {
			if (route_op_type == ROUTE_OP_READ) {
				if (priv_check_cred(cred,
				    PRIV_NET_RESTRICTED_ROUTE_NC_READ, 0) == 0) {
					return 0;
				} else {
					return -1;
				}
			}
		}
	}
	return -1;
}

/*
 * RTM_xxx.
 *
 * The switch statement below does nothing at runtime, as it serves as a
 * compile time check to ensure that all of the RTM_xxx constants are
 * unique.  This works as long as this routine gets updated each time a
 * new RTM_xxx constant gets added.
 *
 * Any failures at compile time indicates duplicated RTM_xxx values.
 */
static __attribute__((unused)) void
rtm_cassert(void)
{
    /*
     * This is equivalent to _CASSERT() and the compiler wouldn't
     * generate any instructions, thus for compile time only.
     */
    switch ((u_int16_t)0) {
    case 0:

    /* bsd/net/route.h */
    case RTM_ADD:
    case RTM_DELETE:
    case RTM_CHANGE:
    case RTM_GET:
    case RTM_LOSING:
    case RTM_REDIRECT:
    case RTM_MISS:
    case RTM_LOCK:
    case RTM_OLDADD:
    case RTM_OLDDEL:
    case RTM_RESOLVE:
    case RTM_NEWADDR:
    case RTM_DELADDR:
    case RTM_IFINFO:
    case RTM_NEWMADDR:
    case RTM_DELMADDR:
    case RTM_IFINFO2:
    case RTM_NEWMADDR2:
    case RTM_GET2:

    /* bsd/net/route_private.h */
    case RTM_GET_SILENT:
    case RTM_GET_EXT:
        ;
    }
}

static __attribute__((unused)) void
rtv_cassert(void)
{
    switch ((u_int16_t)0) {
    case 0:

    /* bsd/net/route.h */
    case RTV_MTU:
    case RTV_HOPCOUNT:
    case RTV_EXPIRE:
    case RTV_RPIPE:
    case RTV_SPIPE:
    case RTV_SSTHRESH:
    case RTV_RTT:
    case RTV_RTTVAR:

    /* net/route_private.h */
    case RTV_REFRESH_HOST:
        ;
    }
}