/*
- * Copyright (c) 2000-2011 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2018 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
* 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,
* 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@
*/
/*
* @(#)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/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 <kern/lock.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_mroute.h>
#include <netinet/ip_var.h>
#include <netinet/ip6.h>
+#include <netinet/in_arp.h>
#if INET6
#include <netinet6/ip6_var.h>
#include <netinet6/in6_var.h>
+#include <netinet6/nd6.h>
#endif /* INET6 */
#include <net/if_dl.h>
#include <pexpert/pexpert.h>
+#if CONFIG_MACF
+#include <sys/kauth.h>
+#endif
+
/*
* Synchronization notes:
*
*
* - Routing table lock (rnh_lock).
*
- * rt_parent, rt_mask, rt_llinfo_free
+ * rt_parent, rt_mask, rt_llinfo_free, rt_tree_genid
*
* - Set once during creation and never changes; no locks to read.
*
* single-threaded, thus exclusive. This flag will also prevent the
* route from being looked up via rt_lookup().
*
- * generation_id
+ * rt_genid
*
* - Assumes that 32-bit writes are atomic; no locks.
*
#define equal(a1, a2) (bcmp((caddr_t)(a1), (caddr_t)(a2), (a1)->sa_len) == 0)
-extern void kdp_set_gateway_mac (void *gatewaymac);
+extern void kdp_set_gateway_mac(void *gatewaymac);
-extern struct domain routedomain;
-struct route_cb route_cb;
-__private_extern__ struct rtstat rtstat = { 0, 0, 0, 0, 0 };
+__private_extern__ struct rtstat rtstat = { 0, 0, 0, 0, 0, 0 };
struct radix_node_head *rt_tables[AF_MAX+1];
-lck_mtx_t *rnh_lock; /* global routing tables mutex */
+decl_lck_mtx_data(, rnh_lock_data); /* global routing tables mutex */
+lck_mtx_t *rnh_lock = &rnh_lock_data;
static lck_attr_t *rnh_lock_attr;
static lck_grp_t *rnh_lock_grp;
static lck_grp_attr_t *rnh_lock_grp_attr;
static lck_grp_t *rte_mtx_grp;
static lck_grp_attr_t *rte_mtx_grp_attr;
-lck_mtx_t *route_domain_mtx; /*### global routing tables mutex for now */
int rttrash = 0; /* routes not in table but not freed */
-unsigned int rte_debug;
+unsigned int rte_debug = 0;
/* Possible flags for rte_debug */
#define RTD_DEBUG 0x1 /* enable or disable rtentry debug facility */
#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)
+
/* For gdb */
__private_extern__ unsigned int ctrace_stack_size = CTRACE_STACK_SIZE;
__private_extern__ unsigned int ctrace_hist_size = CTRACE_HIST_SIZE;
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(struct sockaddr *,
- struct sockaddr *, struct sockaddr *);
+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 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 *sa_copy(struct sockaddr *, struct sockaddr_storage *,
- unsigned int *);
static struct sockaddr *ma_copy(int, struct sockaddr *,
struct sockaddr_storage *, unsigned int);
static struct sockaddr *sa_trim(struct sockaddr *, int);
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 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 route_event_callback(void *);
+static void rt_str4(struct rtentry *, char *, uint32_t, char *, uint32_t);
+#if INET6
+static void rt_str6(struct rtentry *, char *, uint32_t, char *, uint32_t);
+#endif /* INET6 */
-uint32_t route_generation = 0;
-
-/*
- * sockaddr_in with scope ID field; this is used internally to keep
- * track of scoped route entries in the routing table. The fact that
- * such a value is embedded in the structure is an artifact of the
- * current implementation which could change in future.
- */
-struct sockaddr_inifscope {
- __uint8_t sin_len;
- sa_family_t sin_family;
- in_port_t sin_port;
- struct in_addr sin_addr;
- /*
- * To avoid possible conflict with an overlaid sockaddr_inarp
- * having sin_other set to SIN_PROXY, we use the first 4-bytes
- * of sin_zero since sin_srcaddr is one of the unused fields
- * in sockaddr_inarp.
- */
- union {
- char sin_zero[8];
- struct {
- __uint32_t ifscope;
- } _in_index;
- } un;
-#define sin_scope_id un._in_index.ifscope
-};
-
-#define SA(sa) ((struct sockaddr *)(size_t)(sa))
-#define SIN(sa) ((struct sockaddr_in *)(size_t)(sa))
-#define SIN6(sa) ((struct sockaddr_in6 *)(size_t)(sa))
-#define SINIFSCOPE(sa) ((struct sockaddr_inifscope *)(size_t)(sa))
-#define SIN6IFSCOPE(sa) SIN6(sa)
+uint32_t route_genid_inet = 0;
+#if INET6
+uint32_t route_genid_inet6 = 0;
+#endif /* INET6 */
#define ASSERT_SINIFSCOPE(sa) { \
if ((sa)->sa_family != AF_INET || \
#define ASSERT_SIN6IFSCOPE(sa) { \
if ((sa)->sa_family != AF_INET6 || \
(sa)->sa_len < sizeof (struct sockaddr_in6)) \
- panic("%s: bad sockaddr_in %p\n", __func__, sa); \
+ panic("%s: bad sockaddr_in6 %p\n", __func__, sa); \
}
/*
#define RN(r) ((struct radix_node *)r)
#define RT_HOST(r) (RT(r)->rt_flags & RTF_HOST)
-SYSCTL_DECL(_net_idle_route);
+unsigned int rt_verbose = 0;
+#if (DEVELOPMENT || DEBUG)
+SYSCTL_DECL(_net_route);
+SYSCTL_UINT(_net_route, OID_AUTO, verbose, CTLFLAG_RW | CTLFLAG_LOCKED,
+ &rt_verbose, 0, "");
+#endif /* (DEVELOPMENT || DEBUG) */
+
+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;
+
+#if INET6
+ _CASSERT(offsetof(struct route, ro_rt) ==
+ offsetof(struct route_in6, ro_rt));
+ _CASSERT(offsetof(struct route, ro_lle) ==
+ offsetof(struct route_in6, ro_lle));
+ _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));
+#endif /* INET6 */
+
+ PE_parse_boot_argn("rte_debug", &rte_debug, sizeof (rte_debug));
+ if (rte_debug != 0)
+ rte_debug |= RTD_DEBUG;
+
+ rnh_lock_grp_attr = lck_grp_attr_alloc_init();
+ rnh_lock_grp = lck_grp_alloc_init("route", rnh_lock_grp_attr);
+ rnh_lock_attr = lck_attr_alloc_init();
+ lck_mtx_init(rnh_lock, rnh_lock_grp, rnh_lock_attr);
+
+ rte_mtx_grp_attr = lck_grp_attr_alloc_init();
+ rte_mtx_grp = lck_grp_alloc_init(RTE_NAME, rte_mtx_grp_attr);
+ rte_mtx_attr = lck_attr_alloc_init();
+
+ 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 = zinit(size, RTE_ZONE_MAX * size, 0, RTE_ZONE_NAME);
+ if (rte_zone == NULL) {
+ panic("%s: failed allocating rte_zone", __func__);
+ /* NOTREACHED */
+ }
+ zone_change(rte_zone, Z_EXPAND, TRUE);
+ zone_change(rte_zone, Z_CALLERACCT, FALSE);
+ zone_change(rte_zone, Z_NOENCRYPT, TRUE);
-static int rt_if_idle_expire_timeout = RT_IF_IDLE_EXPIRE_TIMEOUT;
-SYSCTL_INT(_net_idle_route, OID_AUTO, expire_timeout, CTLFLAG_RW,
- &rt_if_idle_expire_timeout, 0, "Default expiration time on routes for "
- "interface idle reference counting");
+ TAILQ_INIT(&rttrash_head);
+}
/*
* Given a route, determine whether or not it is the non-scoped default
* In any case, the effective scope ID value is returned to the caller via
* pifscope, if it is non-NULL.
*/
-static struct sockaddr *
+struct sockaddr *
sa_copy(struct sockaddr *src, struct sockaddr_storage *dst,
unsigned int *pifscope)
{
eifscope = sin6_get_embedded_ifscope(SA(dst));
if (eifscope != IFSCOPE_NONE && ifscope == IFSCOPE_NONE)
ifscope = eifscope;
- sin6_set_ifscope(SA(dst), ifscope);
+ 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 (sa->sa_len <= skip)
return (sa);
- for (cp = base + (sa->sa_len - skip); cp > base && cp[-1] == 0;)
+ for (cp = base + (sa->sa_len - skip); cp > base && cp[-1] == 0; )
cp--;
sa->sa_len = (cp - base) + skip;
}
/*
- * Called by rtm_msg{1,2} routines to "scrub" the scope ID field away from
- * the socket address structure, so that clients of the routing socket will
+ * 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_ifscope(int type, int idx, struct sockaddr *hint, struct sockaddr *sa,
- struct sockaddr_storage *ss)
+rtm_scrub(int type, int idx, struct sockaddr *hint, struct sockaddr *sa,
+ void *buf, 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:
/*
offsetof(struct sockaddr_in6, sin6_addr);
if (sa->sa_len > skip && sa->sa_len <= sizeof (*ss)) {
- bzero(ss, sizeof (*ss));
bcopy(sa, ss, sa->sa_len);
/*
* Don't use {sin,sin6}_set_ifscope() as sa_family
}
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;
+ /* 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);
+
+ bcopy(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 = (struct sockaddr *)sdl;
+ }
+ break;
+ }
default:
break;
}
(SIN6IFSCOPE(rt_key(rt))->sin6_scope_id == ma->ifscope));
}
-static void
-rtable_init(void **table)
+/*
+ * Atomically increment route generation counter
+ */
+void
+routegenid_update(void)
{
- struct domain *dom;
- for (dom = domains; dom; dom = dom->dom_next)
- if (dom->dom_rtattach)
- dom->dom_rtattach(&table[dom->dom_family],
- dom->dom_rtoffset);
+ routegenid_inet_update();
+#if INET6
+ routegenid_inet6_update();
+#endif /* INET6 */
}
void
-route_init(void)
+routegenid_inet_update(void)
{
- int size;
-
- PE_parse_boot_argn("rte_debug", &rte_debug, sizeof (rte_debug));
- if (rte_debug != 0)
- rte_debug |= RTD_DEBUG;
-
- rnh_lock_grp_attr = lck_grp_attr_alloc_init();
- rnh_lock_grp = lck_grp_alloc_init("route", rnh_lock_grp_attr);
- rnh_lock_attr = lck_attr_alloc_init();
- if ((rnh_lock = lck_mtx_alloc_init(rnh_lock_grp,
- rnh_lock_attr)) == NULL) {
- printf("route_init: can't alloc rnh_lock\n");
- return;
- }
-
- rte_mtx_grp_attr = lck_grp_attr_alloc_init();
- rte_mtx_grp = lck_grp_alloc_init(RTE_NAME, rte_mtx_grp_attr);
- rte_mtx_attr = lck_attr_alloc_init();
-
- lck_mtx_lock(rnh_lock);
- rn_init(); /* initialize all zeroes, all ones, mask table */
- lck_mtx_unlock(rnh_lock);
- rtable_init((void **)rt_tables);
- route_domain_mtx = routedomain.dom_mtx;
-
- if (rte_debug & RTD_DEBUG)
- size = sizeof (struct rtentry_dbg);
- else
- size = sizeof (struct rtentry);
-
- rte_zone = zinit(size, RTE_ZONE_MAX * size, 0, RTE_ZONE_NAME);
- if (rte_zone == NULL)
- panic("route_init: failed allocating rte_zone");
-
- zone_change(rte_zone, Z_EXPAND, TRUE);
- zone_change(rte_zone, Z_CALLERACCT, FALSE);
- zone_change(rte_zone, Z_NOENCRYPT, TRUE);
-
- TAILQ_INIT(&rttrash_head);
+ atomic_add_32(&route_genid_inet, 1);
}
-/*
- * Atomically increment route generation counter
- */
+#if INET6
void
-routegenid_update(void)
+routegenid_inet6_update(void)
{
- (void) atomic_add_32_ov(&route_generation, 1);
+ atomic_add_32(&route_genid_inet6, 1);
}
+#endif /* INET6 */
/*
* Packet routing routines.
if ((rt = ro->ro_rt) != NULL) {
RT_LOCK_SPIN(rt);
- if (rt->rt_ifp != NULL && (rt->rt_flags & RTF_UP) &&
- rt->generation_id == route_generation) {
+ if (rt->rt_ifp != NULL && !ROUTE_UNUSABLE(ro)) {
RT_UNLOCK(rt);
return;
}
RT_UNLOCK(rt);
- rtfree_locked(rt);
- ro->ro_rt = NULL;
+ ROUTE_RELEASE_LOCKED(ro); /* rnh_lock already held */
}
ro->ro_rt = rtalloc1_common_locked(&ro->ro_dst, 1, ignore, ifscope);
if (ro->ro_rt != NULL) {
- ro->ro_rt->generation_id = route_generation;
+ 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_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_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED);
lck_mtx_lock(rnh_lock);
rtalloc_ign_common_locked(ro, ignore, ifscope);
lck_mtx_unlock(rnh_lock);
return (rtalloc1_common_locked(dst, report, ignflags, ifscope));
}
-/*
- * Look up the route that matches the address given
- * Or, at least try.. Create a cloned route if needed.
- */
-static struct rtentry *
+struct rtentry *
rtalloc1_common_locked(struct sockaddr *dst, int report, uint32_t ignflags,
unsigned int ifscope)
{
* 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)) {
+ struct rtentry *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((struct sockaddr *)&def_key,
+ 0, 0, newrt->rt_ifp->if_index);
+
+ if (defrt) {
+ if (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
* Which basically means "cant get there from here"
*/
rtstat.rts_unreach++;
+
miss:
if (report) {
/*
struct rtentry *
rtalloc1(struct sockaddr *dst, int report, uint32_t ignflags)
{
- struct rtentry * entry;
- lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_NOTOWNED);
+ struct rtentry *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);
rtalloc1_scoped(struct sockaddr *dst, int report, uint32_t ignflags,
unsigned int ifscope)
{
- struct rtentry * entry;
- lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_NOTOWNED);
+ struct rtentry *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);
{
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.
*/
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 the 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.
- */
+ * 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);
- RT_REMREF_LOCKED(rt);
- if (rt->rt_refcnt > 0) {
+ if (rtunref(rt) > 0) {
/* We've lost the race, so abort */
RT_UNLOCK(rt);
goto done;
*/
RT_CONVERT_LOCK(rt);
- lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_OWNED);
+ LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);
/* Negative refcnt must never happen */
- if (rt->rt_refcnt != 0)
+ 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
struct rtentry *rt_parent;
struct ifaddr *rt_ifa;
- if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT))
+ rt->rt_flags |= RTF_DEAD;
+ if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT)) {
panic("rt %p freed while in radix tree\n", rt);
+ /* NOTREACHED */
+ }
/*
* the rtentry must have been removed from the routing table
* so it is represented in rttrash; remove that now.
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);
/*
* and the rtentry itself of course
*/
- rte_lock_destroy(rt);
rte_free(rt);
} else {
/*
{
RT_LOCK_ASSERT_HELD(p);
- if (p->rt_refcnt == 0)
+ if (p->rt_refcnt == 0) {
panic("%s(%p) bad refcnt\n", __func__, p);
-
- --p->rt_refcnt;
+ /* 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((struct rtentry_dbg *)p);
{
uint16_t idx;
- if (rte->rtd_inuse != RTD_INUSE)
+ if (rte->rtd_inuse != RTD_INUSE) {
panic("rtunref: on freed rte=%p\n", rte);
-
+ /* NOTREACHED */
+ }
idx = atomic_add_16_ov(&rte->rtd_refrele_cnt, 1) % CTRACE_HIST_SIZE;
if (rte_debug & RTD_TRACE)
ctrace_record(&rte->rtd_refrele[idx]);
{
RT_LOCK_ASSERT_HELD(p);
- if (++p->rt_refcnt == 0)
+ VERIFY((p->rt_flags & RTF_DEAD) == 0);
+ if (++p->rt_refcnt == 0) {
panic("%s(%p) bad refcnt\n", __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((struct rtentry_dbg *)p);
{
uint16_t idx;
- if (rte->rtd_inuse != RTD_INUSE)
+ if (rte->rtd_inuse != RTD_INUSE) {
panic("rtref_audit: on freed rte=%p\n", rte);
-
+ /* NOTREACHED */
+ }
idx = atomic_add_16_ov(&rte->rtd_refhold_cnt, 1) % CTRACE_HIST_SIZE;
if (rte_debug & RTD_TRACE)
ctrace_record(&rte->rtd_refhold[idx]);
}
void
-rtsetifa(struct rtentry *rt, struct ifaddr* ifa)
+rtsetifa(struct rtentry *rt, struct ifaddr *ifa)
{
- lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_OWNED);
+ LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);
RT_LOCK_ASSERT_HELD(rt);
*/
void
rtredirect(struct ifnet *ifp, struct sockaddr *dst, struct sockaddr *gateway,
- struct sockaddr *netmask, int flags, struct sockaddr *src,
- struct rtentry **rtp)
+ struct sockaddr *netmask, int flags, struct sockaddr *src,
+ struct rtentry **rtp)
{
struct rtentry *rt = NULL;
int error = 0;
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_ASSERT(rnh_lock, LCK_MTX_ASSERT_NOTOWNED);
lck_mtx_lock(rnh_lock);
/*
* comparison against rt_gateway below.
*/
#if INET6
- if ((src->sa_family == AF_INET && ip_doscopedroute) ||
- (src->sa_family == AF_INET6 && ip6_doscopedroute))
+ if ((af == AF_INET) || (af == AF_INET6))
#else
- if (src->sa_family == AF_INET && ip_doscopedroute)
+ if (af == AF_INET)
#endif /* !INET6 */
src = sa_copy(src, &ss, &ifscope);
* in_ifinit), so okay to access ifa_addr without locking.
*/
if (!(flags & RTF_DONE) && rt != NULL &&
- (!equal(src, rt->rt_gateway) || !equal(rt->rt_ifa->ifa_addr,
- ifa->ifa_addr))) {
+ (!equal(src, rt->rt_gateway) || !equal(rt->rt_ifa->ifa_addr,
+ ifa->ifa_addr))) {
error = EINVAL;
} else {
IFA_REMREF(ifa);
done:
if (rt != NULL) {
RT_LOCK_ASSERT_NOTHELD(rt);
- if (rtp && !error)
- *rtp = 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);
}
} else {
if (stat != NULL)
(*stat)++;
- if (use_routegenid)
- routegenid_update();
+
+ if (af == AF_INET)
+ routegenid_inet_update();
+#if INET6
+ else if (af == AF_INET6)
+ routegenid_inet6_update();
+#endif /* INET6 */
}
lck_mtx_unlock(rnh_lock);
bzero((caddr_t)&info, sizeof(info));
int
rtioctl(unsigned long req, caddr_t data, struct proc *p)
{
-#pragma unused(p)
-#if INET && MROUTING
- return mrt_ioctl(req, data);
-#else
-#pragma unused(req)
-#pragma unused(data)
- return ENXIO;
-#endif
+#pragma unused(p, req, data)
+ return (ENXIO);
}
struct ifaddr *
struct rtentry *rt = NULL;
struct sockaddr_storage dst_ss, gw_ss;
- lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_OWNED);
+ LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);
/*
* Just in case the sockaddr passed in by the caller
*/
#if INET6
if (dst != NULL &&
- ((dst->sa_family == AF_INET && ip_doscopedroute) ||
- (dst->sa_family == AF_INET6 && ip6_doscopedroute)))
+ ((dst->sa_family == AF_INET) ||
+ (dst->sa_family == AF_INET6)))
#else
- if (dst != NULL && dst->sa_family == AF_INET && ip_doscopedroute)
+ if (dst != NULL && dst->sa_family == AF_INET)
#endif /* !INET6 */
- dst = sa_copy(SA(dst), &dst_ss, NULL);
+ dst = sa_copy(SA((uintptr_t)dst), &dst_ss, NULL);
#if INET6
if (gw != NULL &&
- ((gw->sa_family == AF_INET && ip_doscopedroute) ||
- (gw->sa_family == AF_INET6 && ip6_doscopedroute)))
+ ((gw->sa_family == AF_INET) ||
+ (gw->sa_family == AF_INET6)))
#else
- if (gw != NULL && gw->sa_family == AF_INET && ip_doscopedroute)
+ if (gw != NULL && gw->sa_family == AF_INET)
#endif /* !INET6 */
- gw = sa_copy(SA(gw), &gw_ss, NULL);
+ gw = sa_copy(SA((uintptr_t)gw), &gw_ss, NULL);
if (!(flags & RTF_GATEWAY)) {
/*
struct ifaddr *ifa = NULL;
struct sockaddr *ndst, *dst = dst0;
struct sockaddr_storage ss, mask;
- struct timeval curr_calendartime;
+ struct timeval caltime;
int af = dst->sa_family;
void (*ifa_rtrequest)(int, struct rtentry *, struct sockaddr *);
-#define senderr(x) { error = x ; goto bad; }
+#define senderr(x) { error = x; goto bad; }
- lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_OWNED);
+ LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);
/*
* Find the correct routing tree to use for this Address Family
*/
* routing socket request.
*/
#if INET6
- if (req != RTM_RESOLVE &&
- ((af == AF_INET && ip_doscopedroute) ||
- (af == AF_INET6 && ip6_doscopedroute))) {
+ if (req != RTM_RESOLVE && ((af == AF_INET) || (af == AF_INET6))) {
#else
- if (req != RTM_RESOLVE && af == AF_INET && ip_doscopedroute) {
+ if (req != RTM_RESOLVE && af == AF_INET) {
#endif /* !INET6 */
/* Transform dst into the internal routing table form */
dst = sa_copy(dst, &ss, &ifscope);
if (ifscope != IFSCOPE_NONE)
flags |= RTF_IFSCOPE;
- } else {
- if ((flags & RTF_IFSCOPE) && (af != AF_INET && af != AF_INET6))
- senderr(EINVAL);
-
-#if INET6
- if ((af == AF_INET && !ip_doscopedroute) ||
- (af == AF_INET6 && !ip6_doscopedroute))
-#else
- if (af == AF_INET && !ip_doscopedroute)
-#endif /* !INET6 */
- ifscope = IFSCOPE_NONE;
+ } else if ((flags & RTF_IFSCOPE) &&
+ (af != AF_INET && af != AF_INET6)) {
+ senderr(EINVAL);
}
if (ifscope == IFSCOPE_NONE)
switch (req) {
case RTM_DELETE: {
struct rtentry *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");
+ if (rn->rn_flags & (RNF_ACTIVE | RNF_ROOT)) {
+ panic("rtrequest delete");
+ /* NOTREACHED */
+ }
rt = (struct rtentry *)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
* will decrement the reference via rtfree_locked() and then
* possibly deallocate it.
*/
- RT_LOCK(rt);
RT_ADDREF_LOCKED(rt);
- rt->rt_flags &= ~RTF_UP;
/*
* 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.
rt_mask(rt)) {
RT_UNLOCK(rt);
rnh->rnh_walktree_from(rnh, dst, rt_mask(rt),
- rt_fixdelete, 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);
}
set_primary_ifscope(rt_key(rt)->sa_family,
IFSCOPE_NONE);
}
- rt_clear_idleref(rt);
+
+#if NECP
+ /*
+ * If this is a change in a default route, update
+ * necp client watchers to re-evaluate
+ */
+ if (SA_DEFAULT(rt_key(rt))) {
+ necp_update_all_clients();
+ }
+#endif /* NECP */
RT_UNLOCK(rt);
/* Dereference or deallocate the route */
rtfree_locked(rt);
}
+ if (af == AF_INET)
+ routegenid_inet_update();
+#if INET6
+ else if (af == AF_INET6)
+ routegenid_inet6_update();
+#endif /* INET6 */
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
flags |= RTF_HOST;
#if INET6
- if ((af != AF_INET && af != AF_INET6) ||
- (af == AF_INET && !ip_doscopedroute) ||
- (af == AF_INET6 && !ip6_doscopedroute))
+ if (af != AF_INET && af != AF_INET6)
#else
- if (af != AF_INET || !ip_doscopedroute)
+ if (af != AF_INET)
#endif /* !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.
+ * 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))) {
+ 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) ?
goto makeroute;
case RTM_ADD:
- if ((flags & RTF_GATEWAY) && !gateway)
+ 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);
if (ifa == NULL)
senderr(ENETUNREACH);
makeroute:
- getmicrotime(&curr_calendartime);
+ /*
+ * 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);
- rt->base_calendartime = curr_calendartime.tv_sec;
+ 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;
+#if INET6
+ case AF_INET6:
+ rt->rt_tree_genid = &route_genid_inet6;
+ break;
+#endif /* INET6 */
+ 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(error);
+ senderr(tmp);
}
/*
/* XXX mtu manipulation will be done in rnh_addaddr -- itojun */
rn = rnh->rnh_addaddr((caddr_t)ndst, (caddr_t)netmask,
- rnh, rt->rt_nodes);
+ rnh, rt->rt_nodes);
if (rn == 0) {
struct rtentry *rt2;
/*
rt2->rt_flags, 0);
rtfree_locked(rt2);
rn = rnh->rnh_addaddr((caddr_t)ndst,
- (caddr_t)netmask,
- rnh, rt->rt_nodes);
+ (caddr_t)netmask, rnh, rt->rt_nodes);
} else if (rt2) {
/* undo the extra ref we got */
rtfree_locked(rt2);
* then un-make it (this should be a function)
*/
if (rn == NULL) {
- if (rt->rt_gwroute) {
- rtfree_locked(rt->rt_gwroute);
- rt->rt_gwroute = NULL;
- }
+ /* Clear gateway route */
+ rt_set_gwroute(rt, rt_key(rt), NULL);
if (rt->rt_ifa) {
IFA_REMREF(rt->rt_ifa);
rt->rt_ifa = NULL;
*/
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);
+ 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)) {
+ if ((*ret_nrt)->rt_flags &
+ (RTF_CLONING | RTF_PRCLONING)) {
rt->rt_parent = (*ret_nrt);
RT_ADDREF_LOCKED(*ret_nrt);
}
RT_UNLOCK(*ret_nrt);
-
- /*
- * Enable interface reference counting for unicast
- * cloned routes and bump up the reference count.
- */
- if (rt->rt_parent != NULL &&
- !(rt->rt_flags & (RTF_BROADCAST | RTF_MULTICAST))) {
- rt_set_idleref(rt);
- }
}
/*
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))) {
+ necp_update_all_clients();
+ }
+#endif /* NECP */
+
/*
* actually return a resultant rtentry and
* give the caller a single reference.
RT_ADDREF_LOCKED(rt);
}
- /*
- * We repeat the same procedure from rt_setgate() here because
- * it doesn't fire when we call it there because the node
- * hasn't been added to the tree yet.
- */
- if (req == RTM_ADD &&
+ if (af == AF_INET)
+ routegenid_inet_update();
+#if INET6
+ else if (af == AF_INET6)
+ routegenid_inet6_update();
+#endif /* INET6 */
+
+ 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);
+ rt_fixchange, &arg);
} else {
RT_UNLOCK(rt);
}
-
+
nstat_route_new_entry(rt);
break;
}
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_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);
unsigned int ifscope)
{
int error;
- lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_NOTOWNED);
+ 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);
struct rtentry *rt = (struct rtentry *)rn;
struct rtentry *rt0 = vp;
- lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_OWNED);
+ LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);
RT_LOCK(rt);
if (rt->rt_parent == rt0 &&
- !(rt->rt_flags & (RTF_PINNED | RTF_CLONING | RTF_PRCLONING))) {
+ !(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_mask(rt), rt->rt_flags, NULL));
}
RT_UNLOCK(rt);
- return 0;
+ return (0);
}
/*
u_char *xk1, *xm1, *xk2, *xmp;
int i, len;
- lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_OWNED);
+ LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);
RT_LOCK(rt);
if (!rt->rt_parent ||
- (rt->rt_flags & (RTF_PINNED | RTF_CLONING | RTF_PRCLONING))) {
+ (rt->rt_flags & (RTF_CLONING | RTF_PRCLONING))) {
RT_UNLOCK(rt);
return (0);
}
rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate)
{
int dlen = SA_SIZE(dst->sa_len), glen = SA_SIZE(gate->sa_len);
- struct radix_node_head *rnh = rt_tables[dst->sa_family];
+ struct radix_node_head *rnh = NULL;
+ boolean_t loop = FALSE;
+
+ if (dst->sa_family != AF_INET && dst->sa_family != AF_INET6) {
+ return (EINVAL);
+ }
- lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_OWNED);
+ 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)
+ 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 = equal(SA(&dst_ss), SA(&gate_ss));
+ } else {
+ loop = (dst->sa_len == gate->sa_len &&
+ 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)) && (dst->sa_len == gate->sa_len) &&
- (bcmp(dst, gate, dst->sa_len) == 0)) {
+ (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.
ifscope = IFSCOPE_NONE;
RT_UNLOCK(rt);
- gwrt = rtalloc1_scoped_locked(gate, 1,
- RTF_CLONING | RTF_PRCLONING, ifscope);
+ /*
+ * 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);
return (EBUSY);
}
- if (rt->rt_gwroute != NULL)
- rtfree_locked(rt->rt_gwroute);
- rt->rt_gwroute = gwrt;
+ /* 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
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 ((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);
+ get_primary_ifscope(AF_INET) == IFSCOPE_NONE)) {
+ kdp_set_gateway_mac(SDL((void *)gwrt->rt_gateway)->
+ sdl_data);
+ }
+
+ /* Release extra ref from rtalloc1() */
+ if (gwrt != NULL)
+ RT_REMREF(gwrt);
}
/*
/* The underlying allocation is done with M_WAITOK set */
R_Malloc(new, caddr_t, dlen + glen);
if (new == NULL) {
- if (rt->rt_gwroute != NULL)
- rtfree_locked(rt->rt_gwroute);
- rt->rt_gwroute = NULL;
+ /* Clear gateway route */
+ rt_set_gwroute(rt, dst, NULL);
/* Release extra ref */
RT_REMREF_LOCKED(rt);
return (ENOBUFS);
#undef SA_SIZE
-static void
-rt_maskedcopy(struct sockaddr *src, struct sockaddr *dst,
- struct sockaddr *netmask)
+void
+rt_set_gwroute(struct rtentry *rt, struct sockaddr *dst, struct rtentry *gwrt)
{
- u_char *cp1 = (u_char *)src;
- u_char *cp2 = (u_char *)dst;
- u_char *cp3 = (u_char *)netmask;
- u_char *cplim = cp2 + *cp3;
- u_char *cplim2 = cp2 + *cp1;
+ boolean_t gwrt_isrouter;
- *cp2++ = *cp1++; *cp2++ = *cp1++; /* copies sa_len & sa_family */
- cp3 += 2;
- if (cplim > cplim2)
- cplim = cplim2;
- while (cp2 < cplim)
- *cp2++ = *cp1++ & *cp3++;
- if (cp2 < cplim2)
- bzero((caddr_t)cp2, (unsigned)(cplim2 - cp2));
+ 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) {
+ struct rtentry *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));
}
/*
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
* to the loopback interface). The search rule follows the longest matching
* prefix with the additional interface constraint.
*/
-struct rtentry *
-rt_lookup(boolean_t lookup_only, struct sockaddr *dst, struct sockaddr *netmask,
- struct radix_node_head *rnh, unsigned int ifscope)
+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;
- boolean_t dontcare;
+ struct radix_node *rn0, *rn = NULL;
int af = dst->sa_family;
- struct sockaddr_storage dst_ss, mask_ss;
+ 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);
+ LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);
+#if INET6
+ /*
+ * While we have rnh_lock held, see if we need to schedule the timer.
+ */
+ if (nd6_sched_timeout_want)
+ nd6_sched_timeout(NULL, NULL);
+#endif /* INET6 */
if (!lookup_only)
netmask = NULL;
* Non-scoped route lookup.
*/
#if INET6
- if ((af != AF_INET && af != AF_INET6) ||
- (af == AF_INET && !ip_doscopedroute) ||
- (af == AF_INET6 && !ip6_doscopedroute)) {
+ if (af != AF_INET && af != AF_INET6) {
#else
- if (af != AF_INET || !ip_doscopedroute) {
+ if (af != AF_INET) {
#endif /* !INET6 */
rn = rnh->rnh_matchaddr(dst, rnh);
netmask = ma_copy(af, netmask, &mask_ss, ifscope);
dontcare = (ifscope == IFSCOPE_NONE);
+#if (DEVELOPMENT || DEBUG)
+ if (rt_verbose) {
+ 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';
+ printf("%s (%d, %d, %s, %s, %u)\n",
+ __func__, lookup_only, coarse, s_dst, s_netmask, ifscope);
+ }
+#endif
+
/*
* Scoped route lookup:
*
*/
if (rn != NULL) {
struct rtentry *rt = RT(rn);
- if (rt->rt_ifp != lo_ifp) {
+#if (DEVELOPMENT || DEBUG)
+ if (rt_verbose) {
+ rt_str(rt, dbuf, sizeof (dbuf), gbuf, sizeof (gbuf));
+ printf("%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
* 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
+ 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)) {
/*
* interface scope as the one requested. The following will result
* in searching for the longest prefix scoped match.
*/
- if (rn == NULL)
+ if (rn == NULL) {
rn = node_lookup(dst, netmask, ifscope);
-
+#if (DEVELOPMENT || DEBUG)
+ if (rt_verbose && rn != NULL) {
+ struct rtentry *rt = RT(rn);
+
+ rt_str(rt, dbuf, sizeof (dbuf), gbuf, sizeof (gbuf));
+ printf("%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 result from the scoped search is a scoped default route,
+ * 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.
- * 3) The scoped search yielded a net route but the original
+ * 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 || (rn0 != NULL &&
+ 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;
* 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)
+ RT(rn)->rt_ifp->if_index != ifscope) {
rn = NULL;
+ }
if (rn != NULL) {
/*
rn = NULL;
}
}
+#if (DEVELOPMENT || DEBUG)
+ if (rt_verbose) {
+ if (rn == NULL)
+ printf("%s %u return NULL\n", __func__, ifscope);
+ else {
+ struct rtentry *rt = RT(rn);
+
+ rt_str(rt, dbuf, sizeof (dbuf), gbuf, sizeof (gbuf));
+ printf("%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_CONDEMNED)) {
+ if ((rt->rt_flags & (RTF_UP | RTF_CONDEMNED)) == RTF_UP) {
int af = rt_key(rt)->sa_family;
if (af == AF_INET)
rtinit(struct ifaddr *ifa, int cmd, int flags)
{
int error;
- lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_NOTOWNED);
+
+ 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, int cmd, int flags)
{
- struct rtentry *rt;
+ struct radix_node_head *rnh;
+ uint8_t nbuf[128]; /* long enough for IPv6 */
+#if (DEVELOPMENT || DEBUG)
+ char dbuf[MAX_IPv6_STR_LEN], gbuf[MAX_IPv6_STR_LEN];
+ char abuf[MAX_IPv6_STR_LEN];
+#endif
+ struct rtentry *rt = NULL;
struct sockaddr *dst;
- struct sockaddr *deldst;
- struct mbuf *m = 0;
- struct rtentry *nrt = 0;
- u_int32_t ifa_flags;
- int error;
+ 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.
*/
- dst = flags & RTF_HOST ? ifa->ifa_dstaddr : ifa->ifa_addr;
+ 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 (DEVELOPMENT || DEBUG)
+ if (dst->sa_family == AF_INET) {
+ (void) inet_ntop(AF_INET, &SIN(dst)->sin_addr.s_addr,
+ abuf, sizeof (abuf));
+ }
+#if INET6
+ else if (dst->sa_family == AF_INET6) {
+ (void) inet_ntop(AF_INET6, &SIN6(dst)->sin6_addr,
+ abuf, sizeof (abuf));
+ }
+#endif /* INET6 */
+#endif /* (DEVELOPMENT || DEBUG) */
+
+ 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
* If it's a net, mask off the host bits
* (Assuming we have a mask)
*/
- if ((flags & RTF_HOST) == 0 && ifa->ifa_netmask) {
- m = m_get(M_DONTWAIT, MT_SONAME);
- if (m == NULL) {
- return(ENOBUFS);
- }
- deldst = mtod(m, struct sockaddr *);
- rt_maskedcopy(dst, deldst, ifa->ifa_netmask);
- dst = deldst;
+ 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. (if this fails, can't get there).
- * We set "report" to FALSE so that if it doesn't exist,
- * it doesn't report an error or clone a route, etc. etc.
+ * 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 = rtalloc1_locked(dst, 0, 0);
- if (rt) {
+ rt = rt_lookup_coarse(TRUE, dst, NULL, rnh);
+ if (rt != NULL) {
+#if (DEVELOPMENT || DEBUG)
+ rt_str(rt, dbuf, sizeof (dbuf), gbuf, sizeof (gbuf));
+#endif
/*
* 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_SPIN(rt);
+ 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 %b, "
+ "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, RTF_BITS, 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) {
/*
- * If the interface 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.
+ * Don't remove the subnet/prefix route if
+ * this was manually added from above.
*/
- if (m)
- (void) m_free(m);
- return (flags & RTF_HOST ? EHOSTUNREACH
- : ENETUNREACH);
- } else {
+#if (DEVELOPMENT || DEBUG)
+ if (rt_verbose) {
+ log(LOG_DEBUG, "%s: not removing "
+ "static route to %s->%s->%s, "
+ "flags %b, ifaddr %s\n", __func__,
+ dbuf, gbuf, ((rt->rt_ifp != NULL) ?
+ rt->rt_ifp->if_xname : ""),
+ rt->rt_flags, RTF_BITS, abuf);
+ }
+#endif /* (DEVELOPMENT || DEBUG) */
RT_REMREF_LOCKED(rt);
RT_UNLOCK(rt);
+ rt = NULL;
+ error = EBUSY;
+ goto done;
}
+#if (DEVELOPMENT || DEBUG)
+ if (rt_verbose) {
+ log(LOG_DEBUG, "%s: removing route to "
+ "%s->%s->%s, flags %b, ifaddr %s\n",
+ __func__, dbuf, gbuf,
+ ((rt->rt_ifp != NULL) ?
+ rt->rt_ifp->if_xname : ""),
+ rt->rt_flags, RTF_BITS, abuf);
+ }
+#endif /* (DEVELOPMENT || DEBUG) */
+ RT_REMREF_LOCKED(rt);
+ RT_UNLOCK(rt);
+ rt = NULL;
}
- /* XXX */
-#if 0
- else {
- /*
- * One would think that as we are deleting, and we know
- * it doesn't exist, we could just return at this point
- * with an "ELSE" clause, but apparently not..
- */
- lck_mtx_unlock(rnh_lock);
- return (flags & RTF_HOST ? EHOSTUNREACH
- : ENETUNREACH);
- }
-#endif
}
/*
* Do the actual request
*/
- IFA_LOCK_SPIN(ifa);
- ifa_flags = ifa->ifa_flags;
- IFA_UNLOCK(ifa);
- error = rtrequest_locked(cmd, dst, ifa->ifa_addr, ifa->ifa_netmask,
- flags | ifa_flags, &nrt);
- if (m)
- (void) m_free(m);
- /*
- * If we are deleting, and we found an entry, then
- * it's been removed from the tree.. now throw it away.
- */
- if (cmd == RTM_DELETE && error == 0 && (rt = nrt)) {
+ if ((error = rtrequest_locked(cmd, dst, ifa->ifa_addr, netmask,
+ flags | ifa->ifa_flags, &rt)) != 0)
+ goto done;
+
+ VERIFY(rt != NULL);
+#if (DEVELOPMENT || DEBUG)
+ rt_str(rt, dbuf, sizeof (dbuf), gbuf, sizeof (gbuf));
+#endif /* (DEVELOPMENT || DEBUG) */
+ switch (cmd) {
+ case RTM_DELETE:
/*
- * notify any listening routing agents of the change
+ * 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, nrt);
- if (use_routegenid)
- routegenid_update();
+ rt_newaddrmsg(cmd, ifa, error, rt);
RT_UNLOCK(rt);
+#if (DEVELOPMENT || DEBUG)
+ if (rt_verbose) {
+ log(LOG_DEBUG, "%s: removed route to %s->%s->%s, "
+ "flags %b, ifaddr %s\n", __func__, dbuf, gbuf,
+ ((rt->rt_ifp != NULL) ? rt->rt_ifp->if_xname : ""),
+ rt->rt_flags, RTF_BITS, abuf);
+ }
+#endif /* (DEVELOPMENT || DEBUG) */
rtfree_locked(rt);
- }
+ break;
- /*
- * We are adding, and we have a returned routing entry.
- * We need to sanity check the result.
- */
- if (cmd == RTM_ADD && error == 0 && (rt = nrt)) {
- RT_LOCK(rt);
+ case RTM_ADD:
/*
- * If it came back with an unexpected interface, then it must
- * have already existed or something. (XXX)
+ * 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 %b, 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,
+ RTF_BITS, 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 %b, 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,
+ RTF_BITS, abuf,
+ (uint64_t)VM_KERNEL_ADDRPERM(rt->rt_ifa),
+ (uint64_t)VM_KERNEL_ADDRPERM(ifa));
+ }
+#endif /* (DEVELOPMENT || DEBUG) */
- if (!(rt->rt_ifa->ifa_ifp->if_flags &
- (IFF_POINTOPOINT|IFF_LOOPBACK)))
- printf("rtinit: wrong ifa (%p) was (%p)\n",
- ifa, rt->rt_ifa);
/*
* Ask that the protocol in question
* remove anything it has associated with
* this route and ifaddr.
*/
- IFA_LOCK_SPIN(rt->rt_ifa);
ifa_rtrequest = rt->rt_ifa->ifa_rtrequest;
- IFA_UNLOCK(rt->rt_ifa);
if (ifa_rtrequest != NULL)
- ifa_rtrequest(RTM_DELETE, rt, SA(0));
+ ifa_rtrequest(RTM_DELETE, rt, NULL);
/*
* Set the route's ifa.
*/
* we are adding.
*/
rt->rt_ifp = ifa->ifa_ifp;
- rt->rt_rmx.rmx_mtu = ifa->ifa_ifp->if_mtu; /*XXX*/
+ /*
+ * 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;
+
/*
* Now ask the protocol to check if it needs
* any special processing in its new form.
*/
- IFA_LOCK_SPIN(ifa);
ifa_rtrequest = ifa->ifa_rtrequest;
- IFA_UNLOCK(ifa);
if (ifa_rtrequest != NULL)
- ifa_rtrequest(RTM_ADD, rt, SA(0));
+ ifa_rtrequest(RTM_ADD, rt, NULL);
+ } else {
+#if (DEVELOPMENT || DEBUG)
+ if (rt_verbose) {
+ log(LOG_DEBUG, "%s: added route to %s->%s->%s, "
+ "flags %b, ifaddr %s\n", __func__, dbuf,
+ gbuf, ((rt->rt_ifp != NULL) ?
+ rt->rt_ifp->if_xname : ""), rt->rt_flags,
+ RTF_BITS, abuf);
+ }
+#endif /* (DEVELOPMENT || DEBUG) */
}
/*
* notify any listenning routing agents of the change
*/
- rt_newaddrmsg(cmd, ifa, error, nrt);
- if (use_routegenid)
- routegenid_update();
+ 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
*/
RT_REMREF_LOCKED(rt);
RT_UNLOCK(rt);
+ break;
+
+ default:
+ VERIFY(0);
+ /* NOTREACHED */
}
+done:
return (error);
}
-u_int64_t
-rt_expiry(struct rtentry *rt, u_int64_t base, u_int32_t delta)
-{
- u_int64_t retval;
-
- /*
- * If the interface of the route doesn't demand aggressive draining,
- * return the expiration time based on the caller-supplied delta.
- * Otherwise use the more aggressive route expiration delta (or
- * the caller-supplied delta, whichever is less.)
- */
- if (rt->rt_ifp == NULL || rt->rt_ifp->if_want_aggressive_drain == 0)
- retval = base + delta;
- else
- retval = base + MIN(rt_if_idle_expire_timeout, delta);
-
- return (retval);
-}
-
-void
+static void
rt_set_idleref(struct rtentry *rt)
{
RT_LOCK_ASSERT_HELD(rt);
- rt_clear_idleref(rt);
- rt->rt_if_ref_fn = rte_if_ref;
- rt->rt_if_ref_fn(rt->rt_ifp, 1);
- rt->rt_flags |= RTF_IFREF;
+ /*
+ * 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_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)
{
void
rt_unlock(struct rtentry *rt)
{
- RT_LOCK_ASSERT_HELD(rt);
if (rte_debug & RTD_DEBUG)
rte_unlock_debug((struct rtentry_dbg *)rt);
lck_mtx_unlock(&rt->rt_lock);
{
uint32_t idx;
+ RT_LOCK_ASSERT_HELD((struct rtentry *)rte);
idx = atomic_add_32_ov(&rte->rtd_lock_cnt, 1) % CTRACE_HIST_SIZE;
if (rte_debug & RTD_TRACE)
ctrace_record(&rte->rtd_lock[idx]);
{
uint32_t idx;
+ RT_LOCK_ASSERT_HELD((struct rtentry *)rte);
idx = atomic_add_32_ov(&rte->rtd_unlock_cnt, 1) % CTRACE_HIST_SIZE;
if (rte_debug & RTD_TRACE)
ctrace_record(&rte->rtd_unlock[idx]);
return;
}
- if (p->rt_refcnt != 0)
+ if (p->rt_refcnt != 0) {
panic("rte_free: rte=%p refcnt=%d non-zero\n", p, p->rt_refcnt);
+ /* NOTREACHED */
+ }
zfree(rte_zone, p);
}
uint32_t old;
/* Force cnt to 1 increment/decrement */
- if (cnt < -1 || cnt > 1)
+ if (cnt < -1 || cnt > 1) {
panic("%s: invalid count argument (%d)", __func__, cnt);
-
+ /* NOTREACHED */
+ }
old = atomic_add_32_ov(&ifp->if_route_refcnt, cnt);
- if (cnt < 0 && old == 0)
+ 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
ev_msg.dv[0].data_length = sizeof (struct net_event_data);
ev_msg.dv[0].data_ptr = &ev_data;
- kev_post_msg(&ev_msg);
+ dlil_post_complete_msg(NULL, &ev_msg);
}
}
{
struct rtentry_dbg *rte = (struct rtentry_dbg *)p;
- if (p->rt_refcnt != 0)
+ if (p->rt_refcnt != 0) {
panic("rte_free: rte=%p refcnt=%d\n", p, p->rt_refcnt);
-
- if (rte->rtd_inuse == RTD_FREED)
+ /* NOTREACHED */
+ }
+ if (rte->rtd_inuse == RTD_FREED) {
panic("rte_free: double free rte=%p\n", rte);
- else if (rte->rtd_inuse != RTD_INUSE)
+ /* NOTREACHED */
+ } else if (rte->rtd_inuse != RTD_INUSE) {
panic("rte_free: corrupted rte=%p\n", 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));
(void) OSBacktrace(tr->pc, CTRACE_STACK_SIZE);
}
-__private_extern__ void
-route_copyout(
- struct route *dst,
- const struct route *src,
- size_t length)
+void
+route_copyout(struct route *dst, const struct route *src, size_t length)
{
- /* Copy everything (rt, dst, flags) from ifnet */
+ /* 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 lle */
+ if (dst->ro_lle != NULL)
+ LLE_ADDREF(dst->ro_lle);
+
+ /* Hold one reference for the local copy of struct ifaddr */
+ if (dst->ro_srcia != NULL)
+ IFA_ADDREF(dst->ro_srcia);
}
-__private_extern__ void
-route_copyin(
- struct route *src,
- struct route *dst,
- size_t length)
+void
+route_copyin(struct route *src, struct route *dst, size_t length)
{
- /* No cached route in the ifnet? */
+ /*
+ * No cached route at the destination?
+ * If none, then remove old references if present
+ * and copy entire src route.
+ */
if (dst->ro_rt == NULL) {
/*
- * Copy everything (rt, dst, flags) from ip_forward();
- * the reference to the route was held at the time
- * it was allocated and is kept intact.
+ * Ditch the cached link layer reference (dst)
+ * since we're about to take everything there is in src
+ */
+ if (dst->ro_lle != NULL)
+ LLE_REMREF(dst->ro_lle);
+ /*
+ * 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, ro_lle, 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);
- } else if (src->ro_rt != NULL) {
+ goto done;
+ }
+
+ /*
+ * We know dst->ro_rt is not NULL here.
+ * If the src->ro_rt is the same, update ro_lle, 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_lle != src->ro_lle) {
+ if (dst->ro_lle != NULL)
+ LLE_REMREF(dst->ro_lle);
+ dst->ro_lle = src->ro_lle;
+ } else if (src->ro_lle != NULL) {
+ LLE_REMREF(src->ro_lle);
+ }
+
+ 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_lle != NULL)
+ LLE_REMREF(dst->ro_lle);
+ 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) {
/*
- * If the same, update just the ro_flags and ditch the one
- * in the local copy. Else ditch the one that is currently
- * cached, and cache the new route.
+ * Ditch src address in the local copy (src) since we're
+ * not caching the route entry anyway (ro_rt is NULL).
*/
- if (dst->ro_rt == src->ro_rt) {
- dst->ro_flags = src->ro_flags;
- rtfree(src->ro_rt);
+ IFA_REMREF(src->ro_srcia);
+ }
+ if (src->ro_lle != NULL) {
+ /*
+ * Ditch cache lle in the local copy (src) since we're
+ * not caching the route anyway (ro_rt is NULL).
+ */
+ LLE_REMREF(src->ro_lle);
+ }
+done:
+ /* This function consumes the references on src */
+ src->ro_lle = NULL;
+ 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;
+ struct rtentry *rt = hint0, *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((struct sockaddr *)
+ (size_t)net_dest, 1, 0, ifindex);
+ if (hint != NULL) {
+ RT_LOCK_SPIN(rt);
+ ifindex = rt->rt_ifp->if_index;
} else {
- rtfree(dst->ro_rt);
- bcopy(src, dst, length);
+ senderr(EHOSTUNREACH);
}
}
- /* This function consumes the reference */
- src->ro_rt = NULL;
+ /*
+ * 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))) {
+ struct rtentry *gwrt = rt->rt_gwroute;
+ struct sockaddr_storage ss;
+ struct sockaddr *gw = (struct sockaddr *)&ss;
+
+ VERIFY(rt == hint);
+ RT_ADDREF_LOCKED(hint);
+
+ /* If there's no gateway rt, look it up */
+ if (gwrt == NULL) {
+ bcopy(rt->rt_gateway, gw, 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);
+ bcopy(rt->rt_gateway, gw, 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 || !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)) {
+ struct rtentry *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 = equal(SA(&key_ss), SA(&gw_ss));
+ } else {
+ isequal = 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");
+ }
+ }
+}
+
+#if INET6
+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");
+ }
+ }
+}
+#endif /* INET6 */
+
+
+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;
+#if INET6
+ case AF_INET6:
+ rt_str6(rt, ds, dslen, gs, gslen);
+ break;
+#endif /* INET6 */
+ 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;
+}
+
+static void
+route_event_callback(void *arg)
+{
+ struct route_event *p_rt_ev = (struct route_event *)arg;
+ struct rtentry *rt = p_rt_ev->rt;
+ eventhandler_tag evtag = p_rt_ev->evtag;
+ int route_ev_code = p_rt_ev->route_event_code;
+
+ if (route_ev_code == ROUTE_EVHDLR_DEREGISTER) {
+ VERIFY(evtag != NULL);
+ EVENTHANDLER_DEREGISTER(&rt->rt_evhdlr_ctxt, route_event,
+ evtag);
+ rtfree(rt);
+ return;
+ }
+
+ EVENTHANDLER_INVOKE(&rt->rt_evhdlr_ctxt, route_event, rt_key(rt),
+ route_ev_code, (struct sockaddr *)&p_rt_ev->rt_addr,
+ rt->rt_flags);
+
+ /* The code enqueuing the route event held a reference */
+ rtfree(rt);
+ /* XXX No reference is taken on gwrt */
+}
+
+int
+route_event_walktree(struct radix_node *rn, void *arg)
+{
+ struct route_event *p_route_ev = (struct route_event *)arg;
+ struct rtentry *rt = (struct rtentry *)rn;
+ struct rtentry *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);
+}
+
+struct route_event_nwk_wq_entry
+{
+ struct nwk_wq_entry nwk_wqe;
+ struct route_event rt_ev_arg;
+};
+
+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;
+
+ MALLOC(p_rt_ev, struct route_event_nwk_wq_entry *,
+ sizeof(struct route_event_nwk_wq_entry),
+ M_NWKWQ, M_WAITOK | M_ZERO);
+
+ /*
+ * 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));
+ bcopy(p_gw_saddr, &(p_rt_ev->rt_ev_arg.rt_addr), 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;
+ p_rt_ev->nwk_wqe.is_arg_managed = TRUE;
+ p_rt_ev->nwk_wqe.arg = &p_rt_ev->rt_ev_arg;
+ nwk_wq_enqueue((struct nwk_wq_entry*)p_rt_ev);
+}
+
+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) == 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);
}
projects / apple / xnu.git / blobdiff