/* * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if NECP #include #endif /* NECP */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if CONFIG_MACF #include #endif #include /* * 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: ; } }