/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2008 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
#include <net/route.h>
#include <netinet/in.h>
+#include <netinet/in_var.h>
#include <netinet/ip_mroute.h>
+#include <netinet/ip_var.h>
#include <net/if_dl.h>
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, u_long,
+ unsigned int);
+static int rtrequest_common_locked(int, struct sockaddr *,
+ struct sockaddr *, struct sockaddr *, int, struct rtentry **,
+ unsigned int);
+static void rtalloc_ign_common_locked(struct route *, u_long, unsigned int);
+static inline void sa_set_ifscope(struct sockaddr *, unsigned int);
+static struct sockaddr *sin_copy(struct sockaddr_in *, struct sockaddr_in *,
+ unsigned int);
+static struct sockaddr *mask_copy(struct sockaddr *, struct sockaddr_in *,
+ unsigned int);
+static struct radix_node *node_lookup(struct sockaddr *, struct sockaddr *,
+ unsigned int);
+static struct radix_node *node_lookup_default(void);
+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);
__private_extern__ u_long route_generation = 0;
extern int use_routegenid;
+/*
+ * sockaddr_in with embedded interface scope; this is used internally
+ * to keep track of scoped route entries in the routing table. The
+ * fact that such a scope is embedded in the structure is an artifact
+ * of the current implementation which could change in future.
+ */
+struct sockaddr_inifscope {
+ __uint8_t sin_len;
+ sa_family_t sin_family;
+ in_port_t sin_port;
+ struct in_addr sin_addr;
+ /*
+ * To avoid possible conflict with an overlaid sockaddr_inarp
+ * having sin_other set to SIN_PROXY, we use the first 4-bytes
+ * of sin_zero since sin_srcaddr is one of the unused fields
+ * in sockaddr_inarp.
+ */
+ union {
+ char sin_zero[8];
+ struct {
+ __uint32_t ifscope;
+ } _in_index;
+ } un;
+#define sin_ifscope un._in_index.ifscope
+};
+
+#define SIN(sa) ((struct sockaddr_in *)(size_t)(sa))
+#define SINIFSCOPE(sa) ((struct sockaddr_inifscope *)(size_t)(sa))
+
+#define ASSERT_SINIFSCOPE(sa) { \
+ if ((sa)->sa_family != AF_INET || \
+ (sa)->sa_len < sizeof (struct sockaddr_in)) \
+ panic("%s: bad sockaddr_in %p\n", __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 = {
+ sizeof (struct sockaddr_in), AF_INET, { 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 rt_mtx.
+ */
+static unsigned int primary_ifscope = IFSCOPE_NONE;
+
+#define INET_DEFAULT(dst) \
+ ((dst)->sa_family == AF_INET && SIN(dst)->sin_addr.s_addr == 0)
+
+#define RT(r) ((struct rtentry *)r)
+#define RT_HOST(r) (RT(r)->rt_flags & RTF_HOST)
+
+/*
+ * 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_inet_default(struct rtentry *rt, struct sockaddr *dst)
+{
+ return (INET_DEFAULT(dst) && !(rt->rt_flags & RTF_IFSCOPE));
+}
+
+/*
+ * Set the ifscope of the primary interface; caller holds rt_mtx.
+ */
+void
+set_primary_ifscope(unsigned int ifscope)
+{
+ primary_ifscope = ifscope;
+}
+
+/*
+ * Return the ifscope of the primary interface; caller holds rt_mtx.
+ */
+unsigned int
+get_primary_ifscope(void)
+{
+ return (primary_ifscope);
+}
+
+/*
+ * Embed ifscope into a given a sockaddr_in.
+ */
+static inline void
+sa_set_ifscope(struct sockaddr *sa, unsigned int ifscope)
+{
+ /* Caller must pass in sockaddr_in */
+ ASSERT_SINIFSCOPE(sa);
+
+ SINIFSCOPE(sa)->sin_ifscope = ifscope;
+}
+
+/*
+ * Given a sockaddr_in, return the embedded ifscope to the caller.
+ */
+unsigned int
+sa_get_ifscope(struct sockaddr *sa)
+{
+ /* Caller must pass in sockaddr_in */
+ ASSERT_SINIFSCOPE(sa);
+
+ return (SINIFSCOPE(sa)->sin_ifscope);
+}
+
+/*
+ * Copy a sockaddr_in src to dst and embed ifscope into dst.
+ */
+static struct sockaddr *
+sin_copy(struct sockaddr_in *src, struct sockaddr_in *dst, unsigned int ifscope)
+{
+ *dst = *src;
+ sa_set_ifscope(SA(dst), ifscope);
+
+ return (SA(dst));
+}
+
+/*
+ * Copy a mask from src to a sockaddr_in dst and embed ifscope into dst.
+ */
+static struct sockaddr *
+mask_copy(struct sockaddr *src, struct sockaddr_in *dst, unsigned int ifscope)
+{
+ /* We know dst is at least the size of sockaddr{_in} */
+ 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_ifscope field; when ifscope is
+ * IFSCOPE_NONE, we'd end up clearing the embedded ifscope 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.
+ */
+ SINIFSCOPE(dst)->sin_ifscope = ifscope;
+ SINIFSCOPE(dst)->sin_len =
+ offsetof(struct sockaddr_inifscope, sin_ifscope) +
+ sizeof (SINIFSCOPE(dst)->sin_ifscope);
+
+ return (SA(dst));
+}
+
+/*
+ * 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)
+{
+ struct rtentry *rt = (struct rtentry *)rn;
+ struct matchleaf_arg *ma = arg;
+
+ if (!(rt->rt_flags & RTF_IFSCOPE) || rt_key(rt)->sa_family != AF_INET)
+ return (0);
+
+ return (SINIFSCOPE(rt_key(rt))->sin_ifscope == ma->ifscope);
+}
static void
rtable_init(void **table)
{
int size;
- PE_parse_boot_arg("rte_debug", &rte_debug);
+ PE_parse_boot_argn("rte_debug", &rte_debug, sizeof (rte_debug));
if (rte_debug != 0)
rte_debug |= RTD_DEBUG;
void
rtalloc_ign_locked(struct route *ro, u_long ignore)
+{
+ return (rtalloc_ign_common_locked(ro, ignore, IFSCOPE_NONE));
+}
+
+void
+rtalloc_scoped_ign_locked(struct route *ro, u_long ignore, unsigned int ifscope)
+{
+ return (rtalloc_ign_common_locked(ro, ignore, ifscope));
+}
+
+static void
+rtalloc_ign_common_locked(struct route *ro, u_long ignore,
+ unsigned int ifscope)
{
struct rtentry *rt;
if ((rt = ro->ro_rt) != NULL) {
if (rt->rt_ifp != NULL && rt->rt_flags & RTF_UP)
return;
- /* XXX - We are probably always at splnet here already. */
rtfree_locked(rt);
ro->ro_rt = NULL;
}
- ro->ro_rt = rtalloc1_locked(&ro->ro_dst, 1, ignore);
+ ro->ro_rt = rtalloc1_common_locked(&ro->ro_dst, 1, ignore, ifscope);
if (ro->ro_rt)
ro->ro_rt->generation_id = route_generation;
}
lck_mtx_unlock(rt_mtx);
}
+struct rtentry *
+rtalloc1_locked(struct sockaddr *dst, int report, u_long ignflags)
+{
+ return (rtalloc1_common_locked(dst, report, ignflags, IFSCOPE_NONE));
+}
+
+struct rtentry *
+rtalloc1_scoped_locked(struct sockaddr *dst, int report, u_long ignflags,
+ unsigned int ifscope)
+{
+ return (rtalloc1_common_locked(dst, report, ignflags, ifscope));
+}
+
/*
* Look up the route that matches the address given
* Or, at least try.. Create a cloned route if needed.
*/
-struct rtentry *
-rtalloc1_locked(struct sockaddr *dst, int report, u_long ignflags)
+static struct rtentry *
+rtalloc1_common_locked(struct sockaddr *dst, int report, u_long ignflags,
+ unsigned int ifscope)
{
struct radix_node_head *rnh = rt_tables[dst->sa_family];
- struct rtentry *rt;
- struct radix_node *rn;
- struct rtentry *newrt = 0;
+ struct rtentry *rt, *newrt = NULL;
struct rt_addrinfo info;
u_long nflags;
int err = 0, msgtype = RTM_MISS;
+
+ if (rnh == NULL)
+ goto unreachable;
+
/*
- * Look up the address in the table for that Address Family
+ * 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
*/
- if (rnh && (rn = rnh->rnh_matchaddr((caddr_t)dst, rnh)) &&
- ((rn->rn_flags & RNF_ROOT) == 0)) {
+ rt = rt_lookup(FALSE, dst, NULL, rnh, ifscope);
+ if (rt == NULL)
+ goto unreachable;
+
+ newrt = rt;
+ nflags = rt->rt_flags & ~ignflags;
+ if (report && (nflags & (RTF_CLONING | RTF_PRCLONING))) {
/*
- * If we find it and it's not the root node, then
- * get a refernce on the rtentry associated.
+ * 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.)
*/
- newrt = rt = (struct rtentry *)rn;
- nflags = rt->rt_flags & ~ignflags;
- if (report && (nflags & (RTF_CLONING | RTF_PRCLONING))) {
+ err = rtrequest_locked(RTM_RESOLVE, dst, NULL, NULL, 0, &newrt);
+ if (err) {
/*
- * 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.)
+ * 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.
*/
- err = rtrequest_locked(RTM_RESOLVE, dst, SA(0),
- SA(0), 0, &newrt);
- if (err) {
- /*
- * If the cloning didn't succeed, maybe
- * what we have will do. Return that.
- */
- newrt = rt;
- rtref(rt);
- goto miss;
- }
- 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;
- }
- } else
- rtref(rt);
- } else {
+ newrt = rt;
+ goto miss;
+ }
+
/*
- * Either we hit the root or couldn't find any match,
- * Which basically means
- * "caint get there frm here"
+ * We cloned it; drop the original route found during lookup.
+ * The resulted cloned route (newrt) would now have an extra
+ * reference held during rtrequest.
*/
- rtstat.rts_unreach++;
- miss: if (report) {
+ rtfree_locked(rt);
+ if ((rt = newrt) && (rt->rt_flags & RTF_XRESOLVE)) {
/*
- * If required, report the failure to the supervising
- * Authorities.
- * For a delete, this is not an error. (report == 0)
+ * If the new route specifies it be
+ * externally resolved, then go do that.
*/
- bzero((caddr_t)&info, sizeof(info));
- info.rti_info[RTAX_DST] = dst;
- rt_missmsg(msgtype, &info, 0, err);
+ 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);
}
if (rt->rt_refcnt > 0)
return;
- if ((rt->rt_flags & RTF_TRACKREFS) != 0)
- printf("%s rt(%p)->rt_refcnt(%d), caller=%p\n", __FUNCTION__,
- rt, rt->rt_refcnt, __builtin_return_address(0));
-
/*
* On last reference give the "close method" a chance to cleanup
* private state. This also permits (for IPv4 and IPv6) a chance
rtref_audit((struct rtentry_dbg *)p);
p->rt_refcnt++;
-
- if ((p->rt_flags & RTF_TRACKREFS) != 0)
- printf("%s rt(%p)->rt_refcnt(%d), caller=%p\n", __FUNCTION__,
- p, p->rt_refcnt, __builtin_return_address(0));
}
static inline void
* destination to go through the given gateway.
* Normally called as a result of a routing redirect
* message from the network layer.
- *
- * N.B.: must be called at splnet
- *
*/
void
-rtredirect(struct sockaddr *dst, struct sockaddr *gateway,
- struct sockaddr *netmask, int flags, struct sockaddr *src,
- struct rtentry **rtp)
+rtredirect(struct ifnet *ifp, struct sockaddr *dst, struct sockaddr *gateway,
+ struct sockaddr *netmask, int flags, struct sockaddr *src,
+ struct rtentry **rtp)
{
- struct rtentry *rt;
+ struct rtentry *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_in sin;
lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_NOTOWNED);
lck_mtx_lock(rt_mtx);
- /* verify the gateway is directly reachable */
- if ((ifa = ifa_ifwithnet(gateway)) == 0) {
+ /*
+ * 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;
}
- rt = rtalloc1_locked(dst, 0, RTF_CLONING | RTF_PRCLONING);
+ /* Lookup route to the destination (from the original IP header) */
+ rt = rtalloc1_scoped_locked(dst, 0, RTF_CLONING|RTF_PRCLONING, ifscope);
+
+ /* Embed scope in src for comparison against rt_gateway below */
+ if (ip_doscopedroute && src->sa_family == AF_INET)
+ src = sin_copy(SIN(src), &sin, ifscope);
+
/*
* If the redirect isn't from our current router for this dst,
* it's either old or wrong. If it redirects us to ourselves,
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.
+ * Create new route, rather than smashing route
+ * to net; similar to cloned routes, the newly
+ * created host route is scoped as well.
*/
create:
flags |= RTF_GATEWAY | RTF_DYNAMIC;
- error = rtrequest_locked((int)RTM_ADD, dst, gateway,
- netmask, flags,
- (struct rtentry **)0);
+ error = rtrequest_scoped_locked(RTM_ADD, dst,
+ gateway, netmask, flags, NULL, ifscope);
stat = &rtstat.rts_dynamic;
} else {
/*
/*
* add the key and gateway (in one malloc'd chunk).
*/
- rt_setgate(rt, rt_key(rt), gateway);
+ error = rt_setgate(rt, rt_key(rt), gateway);
}
- } else
+ } else {
error = EHOSTUNREACH;
+ }
done:
if (rt) {
if (rtp && !error)
rtfree_locked(rt);
}
out:
- if (error)
+ if (error) {
rtstat.rts_badredirect++;
- else if (stat != NULL)
- (*stat)++;
+ } else {
+ if (stat != NULL)
+ (*stat)++;
+ if (use_routegenid)
+ route_generation++;
+ }
bzero((caddr_t)&info, sizeof(info));
info.rti_info[RTAX_DST] = dst;
info.rti_info[RTAX_GATEWAY] = gateway;
}
struct ifaddr *
-ifa_ifwithroute_locked(
- int flags,
- const struct sockaddr *dst,
- const struct sockaddr *gateway)
+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 *gateway, unsigned int ifscope)
{
struct ifaddr *ifa = NULL;
struct rtentry *rt = NULL;
+ struct sockaddr_in dst_in, gw_in;
lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED);
+ if (ip_doscopedroute) {
+ /*
+ * Just in case the sockaddr passed in by the caller
+ * contains embedded scope, make sure to clear it since
+ * IPv4 interface addresses aren't scoped.
+ */
+ if (dst != NULL && dst->sa_family == AF_INET)
+ dst = sin_copy(SIN(dst), &dst_in, IFSCOPE_NONE);
+ if (gateway != NULL && gateway->sa_family == AF_INET)
+ gateway = sin_copy(SIN(gateway), &gw_in, IFSCOPE_NONE);
+ }
+
if (!(flags & RTF_GATEWAY)) {
/*
* If we are adding a route to an interface,
ifa = ifa_ifwithdstaddr(dst);
}
if (ifa == NULL)
- ifa = ifa_ifwithaddr(gateway);
+ ifa = ifa_ifwithaddr_scoped(gateway, ifscope);
} else {
/*
* If we are adding a route to a remote net
ifa = ifa_ifwithdstaddr(gateway);
}
if (ifa == NULL)
- ifa = ifa_ifwithnet(gateway);
+ ifa = ifa_ifwithnet_scoped(gateway, ifscope);
if (ifa == NULL) {
/* Workaround to avoid gcc warning regarding const variable */
- rt = rtalloc1_locked((struct sockaddr *)(size_t)dst, 0, 0UL);
+ rt = rtalloc1_scoped_locked((struct sockaddr *)(size_t)dst,
+ 0, 0UL, ifscope);
if (rt != NULL) {
ifa = rt->rt_ifa;
if (ifa != NULL)
*/
if ((ifa == NULL ||
!equal(ifa->ifa_addr, (struct sockaddr *)(size_t)gateway)) &&
- (rt = rtalloc1_locked((struct sockaddr *)(size_t)gateway,
- 0, 0UL)) != NULL) {
+ (rt = rtalloc1_scoped_locked((struct sockaddr *)(size_t)gateway,
+ 0, 0UL, ifscope)) != NULL) {
if (ifa != NULL)
ifafree(ifa);
ifa = rt->rt_ifa;
ifaref(ifa);
rtunref(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) {
+ ifafree(ifa);
+ ifa = NULL;
+ }
+
return (ifa);
}
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
+ * Do appropriate manipulations of a routing tree given all the bits of
+ * info needed.
+ *
+ * Embedding the scope 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.
*/
-int
-rtrequest_locked(
- int req,
- struct sockaddr *dst,
- struct sockaddr *gateway,
- struct sockaddr *netmask,
- int flags,
- struct rtentry **ret_nrt)
+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;
struct rtentry *rt;
struct radix_node *rn;
struct radix_node_head *rnh;
struct ifaddr *ifa = NULL;
- struct sockaddr *ndst;
+ struct sockaddr *ndst, *dst = dst0;
+ struct sockaddr_in sin, mask;
#define senderr(x) { error = x ; goto bad; }
lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED);
*/
if (flags & RTF_HOST)
netmask = 0;
+
+ /*
+ * If RTF_IFSCOPE is specified, use a local copy of the destination
+ * address to embed the scope into. This logic is repeated below
+ * in the RTM_RESOLVE handler since the caller does not normally
+ * specify such a flag during a resolve; 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 embedded scope 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 && (flags & RTF_IFSCOPE)) {
+ /* Scoped routing is for AF_INET only */
+ if (dst->sa_family != AF_INET ||
+ (req == RTM_ADD && !ip_doscopedroute))
+ senderr(EINVAL);
+
+ if (ifscope == IFSCOPE_NONE) {
+ flags &= ~RTF_IFSCOPE;
+ } else {
+ /* Embed ifscope into the key (local copy) */
+ dst = sin_copy(SIN(dst), &sin, ifscope);
+
+ /* Embed ifscope into netmask (local copy) */
+ if (netmask != NULL)
+ netmask = mask_copy(netmask, &mask, ifscope);
+ }
+ }
+
switch (req) {
case RTM_DELETE:
/*
(struct rtentry_dbg *)rt, rtd_trash_link);
}
+ /*
+ * If this is the (non-scoped) default route, clear
+ * the interface index used for the primary ifscope.
+ */
+ if (rt_inet_default(rt, rt_key(rt)))
+ set_primary_ifscope(IFSCOPE_NONE);
+
/*
* 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
gateway = rt->rt_gateway;
if ((netmask = rt->rt_genmask) == 0)
flags |= RTF_HOST;
+
+ if (!ip_doscopedroute || dst->sa_family != AF_INET)
+ 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.
+ */
+ if (!IN_LINKLOCAL(ntohl(SIN(dst)->sin_addr.s_addr))) {
+ if (flags & RTF_IFSCOPE) {
+ ifscope = sa_get_ifscope(rt_key(rt));
+ } else {
+ ifscope = rt->rt_ifp->if_index;
+ flags |= RTF_IFSCOPE;
+ }
+ } else {
+ ifscope = IFSCOPE_NONE;
+ flags &= ~RTF_IFSCOPE;
+ }
+
+ /* Embed or clear ifscope into/from the key (local copy) */
+ dst = sin_copy(SIN(dst), &sin, ifscope);
+
+ /* Embed or clear ifscope into/from netmask (local copy) */
+ if (netmask != NULL)
+ netmask = mask_copy(netmask, &mask, ifscope);
+
goto makeroute;
case RTM_ADD:
if ((flags & RTF_GATEWAY) && !gateway)
- panic("rtrequest: GATEWAY but no gateway");
+ panic("rtrequest: RTF_GATEWAY but no gateway");
- if ((ifa = ifa_ifwithroute_locked(flags, dst, gateway)) == 0)
+ 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:
+makeroute:
if ((rt = rte_alloc()) == NULL)
senderr(ENOBUFS);
Bzero(rt, sizeof(*rt));
rt->rt_flags = RTF_UP | flags;
+
/*
* Add the gateway. Possibly re-malloc-ing the storage for it
* also add the rt_gwroute if possible.
/*
* make sure it contains the value we want (masked if needed).
*/
- if (netmask) {
+ if (netmask)
rt_maskedcopy(dst, ndst, netmask);
- } else
+ else
Bcopy(dst, ndst, dst->sa_len);
/*
* mechanism, then we just blow it away and retry
* the insertion of the new one.
*/
- rt2 = rtalloc1_locked(dst, 0,
- RTF_CLONING | RTF_PRCLONING);
+ 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) {
rtrequest_locked(RTM_DELETE,
(struct sockaddr *)rt_key(rt2),
rt_fixchange, &arg);
}
+ /*
+ * If this is the (non-scoped) default route, record
+ * the interface index used for the primary ifscope.
+ */
+ if (rt_inet_default(rt, rt_key(rt)))
+ set_primary_ifscope(rt->rt_ifp->if_index);
+
/*
* actually return a resultant rtentry and
* give the caller a single reference.
* routine just for adds. I'm not sure why I thought it was necessary to do
* changes this way.
*/
-#ifdef DEBUG
-static int rtfcdebug = 0;
-#endif
-
static int
rt_fixchange(struct radix_node *rn, void *vp)
{
u_char *xk1, *xm1, *xk2, *xmp;
int i, len, mlen;
-#ifdef DEBUG
- if (rtfcdebug)
- printf("rt_fixchange: rt %p, rt0 %p\n", rt, rt0);
-#endif
-
lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED);
if (!rt->rt_parent ||
- (rt->rt_flags & (RTF_PINNED | RTF_CLONING | RTF_PRCLONING))) {
-#ifdef DEBUG
- if(rtfcdebug) printf("no parent or pinned\n");
-#endif
- return 0;
- }
+ (rt->rt_flags & (RTF_PINNED | RTF_CLONING | RTF_PRCLONING)))
+ return (0);
- if (rt->rt_parent == rt0) {
-#ifdef DEBUG
- if(rtfcdebug) printf("parent match\n");
-#endif
- return rtrequest_locked(RTM_DELETE, rt_key(rt),
- (struct sockaddr *)0, rt_mask(rt),
- rt->rt_flags, (struct rtentry **)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(((struct sockaddr *)rt_key(rt0))->sa_len,
- ((struct sockaddr *)rt_key(rt))->sa_len);
+ len = imin(rt_key(rt0)->sa_len, rt_key(rt)->sa_len);
xk1 = (u_char *)rt_key(rt0);
xm1 = (u_char *)rt_mask(rt0);
/* avoid applying a less specific route */
xmp = (u_char *)rt_mask(rt->rt_parent);
- mlen = ((struct sockaddr *)rt_key(rt->rt_parent))->sa_len;
- if (mlen > ((struct sockaddr *)rt_key(rt0))->sa_len) {
-#if DEBUG
- if (rtfcdebug)
- printf("rt_fixchange: inserting a less "
- "specific route\n");
-#endif
- return 0;
- }
+ mlen = rt_key(rt->rt_parent)->sa_len;
+ if (mlen > rt_key(rt0)->sa_len)
+ return (0);
+
for (i = rnh->rnh_treetop->rn_offset; i < mlen; i++) {
- if ((xmp[i] & ~(xmp[i] ^ xm1[i])) != xmp[i]) {
-#if DEBUG
- if (rtfcdebug)
- printf("rt_fixchange: inserting a less "
- "specific route\n");
-#endif
- return 0;
- }
+ if ((xmp[i] & ~(xmp[i] ^ xm1[i])) != xmp[i])
+ return (0);
}
for (i = rnh->rnh_treetop->rn_offset; i < len; i++) {
- if ((xk2[i] & xm1[i]) != xk1[i]) {
-#ifdef DEBUG
- if(rtfcdebug) printf("no match\n");
-#endif
- return 0;
- }
+ if ((xk2[i] & xm1[i]) != xk1[i])
+ 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.
*/
-#ifdef DEBUG
- if(rtfcdebug) printf("deleting\n");
-#endif
- return rtrequest_locked(RTM_DELETE, rt_key(rt), (struct sockaddr *)0,
- rt_mask(rt), rt->rt_flags, (struct rtentry **)0);
+delete_rt:
+ return (rtrequest_locked(RTM_DELETE, rt_key(rt), NULL,
+ rt_mask(rt), rt->rt_flags, NULL));
}
int
-rt_setgate(struct rtentry *rt0, struct sockaddr *dst, struct sockaddr *gate)
+rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate)
{
- caddr_t new, old;
int dlen = ROUNDUP(dst->sa_len), glen = ROUNDUP(gate->sa_len);
- struct rtentry *rt = rt0;
struct radix_node_head *rnh = rt_tables[dst->sa_family];
+
+ lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED);
+
/*
* A host route with the destination equal to the gateway
* will interfere with keeping LLINFO in the routing
* table, so disallow it.
*/
-
- lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED);
-
- if (((rt0->rt_flags & (RTF_HOST|RTF_GATEWAY|RTF_LLINFO)) ==
- (RTF_HOST|RTF_GATEWAY)) &&
- (dst->sa_len == gate->sa_len) &&
+ if (((rt->rt_flags & (RTF_HOST|RTF_GATEWAY|RTF_LLINFO)) ==
+ (RTF_HOST|RTF_GATEWAY)) && (dst->sa_len == gate->sa_len) &&
(bcmp(dst, gate, dst->sa_len) == 0)) {
/*
* The route might already exist if this is an RTM_CHANGE
* or a routing redirect, so try to delete it.
*/
- if (rt_key(rt0))
- rtrequest_locked(RTM_DELETE, (struct sockaddr *)rt_key(rt0),
- rt0->rt_gateway, rt_mask(rt0), rt0->rt_flags, 0);
- return EADDRNOTAVAIL;
+ if (rt_key(rt))
+ rtrequest_locked(RTM_DELETE, rt_key(rt),
+ rt->rt_gateway, rt_mask(rt), rt->rt_flags, NULL);
+ return (EADDRNOTAVAIL);
}
/*
- * Both dst and gateway are stored in the same malloc'd chunk
- * (If I ever get my hands on....)
- * if we need to malloc a new chunk, then keep the old one around
- * till we don't need it any more.
+ * The destination is not directly reachable. Get a route
+ * to the next-hop gateway and store it in rt_gwroute.
*/
- if (rt->rt_gateway == 0 || glen > ROUNDUP(rt->rt_gateway->sa_len)) {
- old = (caddr_t)rt_key(rt);
- R_Malloc(new, caddr_t, dlen + glen);
- if (new == 0)
- return ENOBUFS;
- rt->rt_nodes->rn_key = new;
- } else {
+ if (rt->rt_flags & RTF_GATEWAY) {
+ struct rtentry *gwrt;
+ unsigned int ifscope;
+
+ ifscope = (dst->sa_family == AF_INET) ?
+ sa_get_ifscope(dst) : IFSCOPE_NONE;
+
+ gwrt = rtalloc1_scoped_locked(gate, 1, RTF_PRCLONING, ifscope);
+
/*
- * otherwise just overwrite the old one
+ * 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.
*/
- new = rt->rt_nodes->rn_key;
- old = 0;
+ if (gwrt == rt) {
+ rtunref(gwrt);
+ return (EADDRINUSE); /* failure */
+ }
+
+ /* If scoped, the gateway route must use the same interface */
+ if (ifscope != IFSCOPE_NONE && (rt->rt_flags & RTF_IFSCOPE) &&
+ gwrt != NULL && gwrt->rt_ifp != NULL &&
+ gwrt->rt_ifp->if_index != ifscope) {
+ rtfree_locked(gwrt);
+ return ((rt->rt_flags & RTF_HOST) ?
+ EHOSTUNREACH : ENETUNREACH);
+ }
+
+ if (rt->rt_gwroute != NULL)
+ rtfree_locked(rt->rt_gwroute);
+ rt->rt_gwroute = 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_inet_default(rt, dst) && rt->rt_ifp != NULL)
+ set_primary_ifscope(rt->rt_ifp->if_index);
+
+ /*
+ * 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() ||
+ get_primary_ifscope() == IFSCOPE_NONE))
+ kdp_set_gateway_mac(SDL(gwrt->rt_gateway)->sdl_data);
}
/*
- * copy the new gateway value into the memory chunk
+ * 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.
*/
- Bcopy(gate, (rt->rt_gateway = (struct sockaddr *)(new + dlen)), glen);
+ if (rt->rt_gateway == NULL || glen > ROUNDUP(rt->rt_gateway->sa_len)) {
+ caddr_t new;
- /*
- * if we are replacing the chunk (or it's new) we need to
- * replace the dst as well
- */
- if (old) {
+ /* The underlying allocation is done with M_WAITOK set */
+ R_Malloc(new, caddr_t, dlen + glen);
+ if (new == NULL) {
+ if (rt->rt_gwroute != NULL)
+ rtfree_locked(rt->rt_gwroute);
+ rt->rt_gwroute = NULL;
+ 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).
+ */
Bcopy(dst, new, dlen);
- R_Free(old);
+ R_Free(rt_key(rt)); /* free old block; NULL is okay */
+ rt->rt_nodes->rn_key = new;
+ rt->rt_gateway = (struct sockaddr *)(new + dlen);
}
/*
- * If there is already a gwroute, it's now almost definitly wrong
- * so drop it.
+ * Copy the new gateway value into the memory chunk.
*/
- if (rt->rt_gwroute) {
- rt = rt->rt_gwroute; rtfree_locked(rt);
- rt = rt0; rt->rt_gwroute = 0;
- }
+ Bcopy(gate, rt->rt_gateway, glen);
+
/*
- * 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().
+ * For consistency between rt_gateway and rt_key(gwrt).
*/
- if (rt->rt_flags & RTF_GATEWAY) {
- rt->rt_gwroute = rtalloc1_locked(gate, 1, RTF_PRCLONING);
- if (rt->rt_gwroute == rt) {
- rtfree_locked(rt->rt_gwroute);
- rt->rt_gwroute = 0;
- return EDQUOT; /* failure */
- }
- /* Tell the kernel debugger about the new default gateway */
- if ((AF_INET == rt->rt_gateway->sa_family) &&
- rt->rt_gwroute && rt->rt_gwroute->rt_gateway &&
- (AF_LINK == rt->rt_gwroute->rt_gateway->sa_family)) {
- kdp_set_gateway_mac(((struct sockaddr_dl *)rt0->rt_gwroute->rt_gateway)->sdl_data);
- }
+ if ((rt->rt_flags & RTF_GATEWAY) && rt->rt_gwroute != NULL &&
+ (rt->rt_gwroute->rt_flags & RTF_IFSCOPE) &&
+ rt->rt_gateway->sa_family == AF_INET &&
+ rt_key(rt->rt_gwroute)->sa_family == AF_INET) {
+ sa_set_ifscope(rt->rt_gateway,
+ sa_get_ifscope(rt_key(rt->rt_gwroute)));
}
/*
arg.rnh = rnh;
arg.rt0 = rt;
rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt),
- rt_fixchange, &arg);
+ rt_fixchange, &arg);
}
- return 0;
+ return (0);
}
static void
bzero((caddr_t)cp2, (unsigned)(cplim2 - cp2));
}
+/*
+ * Lookup an AF_INET 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 = rt_tables[AF_INET];
+ struct radix_node *rn;
+ struct sockaddr_in sin, mask;
+ struct matchleaf_arg ma = { ifscope };
+ rn_matchf_t *f = rn_match_ifscope;
+ void *w = &ma;
+
+ if (dst->sa_family != AF_INET)
+ return (NULL);
+
+ /*
+ * Embed ifscope into the search key; for a non-scoped
+ * search this will clear out any embedded scope value.
+ */
+ dst = sin_copy(SIN(dst), &sin, ifscope);
+
+ /* Embed (or clear) ifscope into netmask */
+ if (netmask != NULL)
+ netmask = mask_copy(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 non-scoped default route.
+ */
+static struct radix_node *
+node_lookup_default(void)
+{
+ struct radix_node_head *rnh = rt_tables[AF_INET];
+ return (rnh->rnh_lookup(&sin_def, NULL, rnh));
+}
+
+/*
+ * 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 embedding the scope 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 (currently AF_INET only); 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.
+ */
+struct rtentry *
+rt_lookup(boolean_t lookup_only, struct sockaddr *dst, struct sockaddr *netmask,
+ struct radix_node_head *rnh, unsigned int ifscope)
+{
+ struct radix_node *rn0, *rn;
+ boolean_t dontcare = (ifscope == IFSCOPE_NONE);
+
+ lck_mtx_assert(rt_mtx, LCK_MTX_ASSERT_OWNED);
+
+ if (!lookup_only)
+ netmask = NULL;
+
+ /*
+ * Non-scoped route lookup.
+ */
+ if (!ip_doscopedroute || dst->sa_family != AF_INET) {
+ if (lookup_only)
+ rn = rnh->rnh_lookup(dst, netmask, rnh);
+ else
+ rn = rnh->rnh_matchaddr(dst, rnh);
+ goto done;
+ }
+
+ /*
+ * 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, return what we have.
+ */
+ if (dontcare && (ifscope = get_primary_ifscope()) == IFSCOPE_NONE)
+ goto validate;
+
+ /*
+ * 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.
+ */
+ if (rn != NULL) {
+ struct rtentry *rt = RT(rn);
+ if (rt->rt_ifp != lo_ifp) {
+ 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.
+ */
+ rn = NULL;
+ if (dontcare)
+ ifscope = rt->rt_ifp->if_index;
+ else
+ 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);
+
+ /*
+ * Use the original result if either of the following is true:
+ *
+ * 1) The scoped search did not yield any result.
+ * 2) The result from the scoped search is a scoped default route,
+ * and the original (non-scoped) result is not a default route,
+ * i.e. the original result is a more specific host/net route.
+ * 3) The scoped search yielded a net route but the original
+ * result is a host route, i.e. the original result is treated
+ * as a more specific route.
+ */
+ if (rn == NULL || (rn0 != NULL &&
+ ((INET_DEFAULT(rt_key(RT(rn))) && !INET_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()) != NULL &&
+ RT(rn)->rt_ifp->if_index != ifscope)
+ rn = NULL;
+
+validate:
+ if (rn != NULL && !lookup_only)
+ (void) in_validate(rn);
+
+done:
+ if (rn != NULL && (rn->rn_flags & RNF_ROOT))
+ rn = NULL;
+ else if (rn != NULL)
+ rtref(RT(rn));
+
+ return (RT(rn));
+}
+
/*
* Set up a routing table entry, normally
* for an interface.
projects / apple / xnu.git / blobdiff