Differential D26449 Diff 77809 head/sys/netinet/in_fib.c

Changeset View

Standalone View

head/sys/netinet/in_fib.c

	Show All 26 Lines
	* SUCH DAMAGE.			* SUCH DAMAGE.
	*/			*/

	#include <sys/cdefs.h>			#include <sys/cdefs.h>
	__FBSDID("$FreeBSD$");			__FBSDID("$FreeBSD$");

	#include "opt_inet.h"			#include "opt_inet.h"
	#include "opt_route.h"			#include "opt_route.h"
	#include "opt_mpath.h"

	#include <sys/param.h>			#include <sys/param.h>
	#include <sys/systm.h>			#include <sys/systm.h>
	#include <sys/lock.h>			#include <sys/lock.h>
	#include <sys/rmlock.h>			#include <sys/rmlock.h>
	#include <sys/malloc.h>			#include <sys/malloc.h>
	#include <sys/mbuf.h>			#include <sys/mbuf.h>
	#include <sys/socket.h>			#include <sys/socket.h>
	#include <sys/sysctl.h>			#include <sys/sysctl.h>
	#include <sys/kernel.h>			#include <sys/kernel.h>

	#include <net/if.h>			#include <net/if.h>
	#include <net/if_var.h>			#include <net/if_var.h>
	#include <net/if_dl.h>			#include <net/if_dl.h>
	#include <net/route.h>			#include <net/route.h>
				#include <net/route/route_ctl.h>
	#include <net/route/route_var.h>			#include <net/route/route_var.h>
	#include <net/route/nhop.h>			#include <net/route/nhop.h>
	#include <net/vnet.h>			#include <net/vnet.h>

	#ifdef RADIX_MPATH
	#include <net/radix_mpath.h>
	#endif

	#include <netinet/in.h>			#include <netinet/in.h>
	#include <netinet/in_var.h>			#include <netinet/in_var.h>
	#include <netinet/in_fib.h>			#include <netinet/in_fib.h>

	#ifdef INET			#ifdef INET

	/* Verify struct route compatiblity */			/* Verify struct route compatiblity */
	/* Assert 'struct route_in' is compatible with 'struct route' */			/* Assert 'struct route_in' is compatible with 'struct route' */
	CHK_STRUCT_ROUTE_COMPAT(struct route_in, ro_dst4);			CHK_STRUCT_ROUTE_COMPAT(struct route_in, ro_dst4);

	/*			/*
	* Looks up path in fib @fibnum specified by @dst.			* Looks up path in fib @fibnum specified by @dst.
	* Returns path nexthop on success. Nexthop is safe to use			* Returns path nexthop on success. Nexthop is safe to use
	* within the current network epoch. If longer lifetime is required,			* within the current network epoch. If longer lifetime is required,
	* one needs to pass NHR_REF as a flag. This will return referenced			* one needs to pass NHR_REF as a flag. This will return referenced
	* nexthop.			* nexthop.
	*/			*/
	struct nhop_object *			struct nhop_object *
	fib4_lookup(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,			fib4_lookup(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,
	uint32_t flags, uint32_t flowid)			uint32_t flags, uint32_t flowid)
	{			{
	RIB_RLOCK_TRACKER;			RIB_RLOCK_TRACKER;
	struct rib_head *rh;			struct rib_head *rh;
	struct radix_node *rn;			struct radix_node *rn;
	struct rtentry *rt;
	struct nhop_object *nh;			struct nhop_object *nh;

	KASSERT((fibnum < rt_numfibs), ("fib4_lookup: bad fibnum"));			KASSERT((fibnum < rt_numfibs), ("fib4_lookup: bad fibnum"));
	rh = rt_tables_get_rnh(fibnum, AF_INET);			rh = rt_tables_get_rnh(fibnum, AF_INET);
	if (rh == NULL)			if (rh == NULL)
	return (NULL);			return (NULL);

	/* Prepare lookup key */			/* Prepare lookup key */
	struct sockaddr_in sin4;			struct sockaddr_in sin4;
	memset(&sin4, 0, sizeof(sin4));			memset(&sin4, 0, sizeof(sin4));
	sin4.sin_family = AF_INET;			sin4.sin_family = AF_INET;
	sin4.sin_len = sizeof(struct sockaddr_in);			sin4.sin_len = sizeof(struct sockaddr_in);
	sin4.sin_addr = dst;			sin4.sin_addr = dst;

	nh = NULL;			nh = NULL;
	RIB_RLOCK(rh);			RIB_RLOCK(rh);
	rn = rh->rnh_matchaddr((void *)&sin4, &rh->head);			rn = rh->rnh_matchaddr((void *)&sin4, &rh->head);
	if (rn != NULL && ((rn->rn_flags & RNF_ROOT) == 0)) {			if (rn != NULL && ((rn->rn_flags & RNF_ROOT) == 0)) {
	rt = RNTORT(rn);			nh = nhop_select((RNTORT(rn))->rt_nhop, flowid);
	#ifdef RADIX_MPATH
	if (rt_mpath_next(rt) != NULL)
	rt = rt_mpath_selectrte(rt, flowid);
	#endif
	nh = rt->rt_nhop;
	/* Ensure route & ifp is UP */			/* Ensure route & ifp is UP */
	if (RT_LINK_IS_UP(nh->nh_ifp)) {			if (RT_LINK_IS_UP(nh->nh_ifp)) {
	if (flags & NHR_REF)			if (flags & NHR_REF)
	nhop_ref_object(nh);			nhop_ref_object(nh);
	RIB_RUNLOCK(rh);			RIB_RUNLOCK(rh);
	return (nh);			return (nh);
	}			}
	}			}
	RIB_RUNLOCK(rh);			RIB_RUNLOCK(rh);

	RTSTAT_INC(rts_unreach);			RTSTAT_INC(rts_unreach);
	return (NULL);			return (NULL);
	}			}

	inline static int			inline static int
	check_urpf(const struct nhop_object *nh, uint32_t flags,			check_urpf_nhop(const struct nhop_object *nh, uint32_t flags,
	const struct ifnet *src_if)			const struct ifnet *src_if)
	{			{

	if (src_if != NULL && nh->nh_aifp == src_if) {			if (src_if != NULL && nh->nh_aifp == src_if) {
	return (1);			return (1);
	}			}
	if (src_if == NULL) {			if (src_if == NULL) {
	if ((flags & NHR_NODEFAULT) == 0)			if ((flags & NHR_NODEFAULT) == 0)
	return (1);			return (1);
	else if ((nh->nh_flags & NHF_DEFAULT) == 0)			else if ((nh->nh_flags & NHF_DEFAULT) == 0)
	return (1);			return (1);
	}			}

	return (0);			return (0);
	}			}

	#ifdef RADIX_MPATH			static int
	inline static int			check_urpf(struct nhop_object *nh, uint32_t flags,
	check_urpf_mpath(struct rtentry *rt, uint32_t flags,
	const struct ifnet *src_if)			const struct ifnet *src_if)
	{			{
				#ifdef ROUTE_MPATH
	while (rt != NULL) {			if (NH_IS_NHGRP(nh)) {
	if (check_urpf(rt->rt_nhop, flags, src_if) != 0)			struct weightened_nhop *wn;
				uint32_t num_nhops;
				wn = nhgrp_get_nhops((struct nhgrp_object *)nh, &num_nhops);
				for (int i = 0; i < num_nhops; i++) {
				if (check_urpf_nhop(wn[i].nh, flags, src_if) != 0)
	return (1);			return (1);
	rt = rt_mpath_next(rt);
	}			}

	return (0);			return (0);
	}			} else
	#endif			#endif
				return (check_urpf_nhop(nh, flags, src_if));
				}

	/*			/*
	* Performs reverse path forwarding lookup.			* Performs reverse path forwarding lookup.
	* If @src_if is non-zero, verifies that at least 1 path goes via			* If @src_if is non-zero, verifies that at least 1 path goes via
	* this interface.			* this interface.
	* If @src_if is zero, verifies that route exist.			* If @src_if is zero, verifies that route exist.
	* if @flags contains NHR_NOTDEFAULT, do not consider default route.			* if @flags contains NHR_NOTDEFAULT, do not consider default route.
	*			*
	* Returns 1 if route matching conditions is found, 0 otherwise.			* Returns 1 if route matching conditions is found, 0 otherwise.
	*/			*/
	int			int
	fib4_check_urpf(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,			fib4_check_urpf(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,
	uint32_t flags, const struct ifnet *src_if)			uint32_t flags, const struct ifnet *src_if)
	{			{
	RIB_RLOCK_TRACKER;			RIB_RLOCK_TRACKER;
	struct rib_head *rh;			struct rib_head *rh;
	struct radix_node *rn;			struct radix_node *rn;
	struct rtentry *rt;
	int ret;			int ret;

	KASSERT((fibnum < rt_numfibs), ("fib4_check_urpf: bad fibnum"));			KASSERT((fibnum < rt_numfibs), ("fib4_check_urpf: bad fibnum"));
	rh = rt_tables_get_rnh(fibnum, AF_INET);			rh = rt_tables_get_rnh(fibnum, AF_INET);
	if (rh == NULL)			if (rh == NULL)
	return (0);			return (0);

	/* Prepare lookup key */			/* Prepare lookup key */
	struct sockaddr_in sin4;			struct sockaddr_in sin4;
	memset(&sin4, 0, sizeof(sin4));			memset(&sin4, 0, sizeof(sin4));
	sin4.sin_len = sizeof(struct sockaddr_in);			sin4.sin_len = sizeof(struct sockaddr_in);
	sin4.sin_addr = dst;			sin4.sin_addr = dst;

	RIB_RLOCK(rh);			RIB_RLOCK(rh);
	rn = rh->rnh_matchaddr((void *)&sin4, &rh->head);			rn = rh->rnh_matchaddr((void *)&sin4, &rh->head);
	if (rn != NULL && ((rn->rn_flags & RNF_ROOT) == 0)) {			if (rn != NULL && ((rn->rn_flags & RNF_ROOT) == 0)) {
	rt = RNTORT(rn);			ret = check_urpf(RNTORT(rn)->rt_nhop, flags, src_if);
	#ifdef RADIX_MPATH
	ret = check_urpf_mpath(rt, flags, src_if);
	#else
	ret = check_urpf(rt->rt_nhop, flags, src_if);
	#endif
	RIB_RUNLOCK(rh);			RIB_RUNLOCK(rh);
	return (ret);			return (ret);
	}			}
	RIB_RUNLOCK(rh);			RIB_RUNLOCK(rh);

	return (0);			return (0);
	}			}

	struct nhop_object *			struct nhop_object *
	fib4_lookup_debugnet(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,			fib4_lookup_debugnet(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,
	uint32_t flags)			uint32_t flags)
	{			{
	struct rib_head *rh;			struct rib_head *rh;
	struct radix_node *rn;			struct radix_node *rn;
	struct rtentry *rt;
	struct nhop_object *nh;			struct nhop_object *nh;

	KASSERT((fibnum < rt_numfibs), ("fib4_lookup_debugnet: bad fibnum"));			KASSERT((fibnum < rt_numfibs), ("fib4_lookup_debugnet: bad fibnum"));
	rh = rt_tables_get_rnh(fibnum, AF_INET);			rh = rt_tables_get_rnh(fibnum, AF_INET);
	if (rh == NULL)			if (rh == NULL)
	return (NULL);			return (NULL);

	/* Prepare lookup key */			/* Prepare lookup key */
	struct sockaddr_in sin4;			struct sockaddr_in sin4;
	memset(&sin4, 0, sizeof(sin4));			memset(&sin4, 0, sizeof(sin4));
	sin4.sin_family = AF_INET;			sin4.sin_family = AF_INET;
	sin4.sin_len = sizeof(struct sockaddr_in);			sin4.sin_len = sizeof(struct sockaddr_in);
	sin4.sin_addr = dst;			sin4.sin_addr = dst;

	nh = NULL;			nh = NULL;
	/* unlocked lookup */			/* unlocked lookup */
	rn = rh->rnh_matchaddr((void *)&sin4, &rh->head);			rn = rh->rnh_matchaddr((void *)&sin4, &rh->head);
	if (rn != NULL && ((rn->rn_flags & RNF_ROOT) == 0)) {			if (rn != NULL && ((rn->rn_flags & RNF_ROOT) == 0)) {
	rt = RNTORT(rn);			nh = nhop_select((RNTORT(rn))->rt_nhop, 0);
	#ifdef RADIX_MPATH
	if (rt_mpath_next(rt) != NULL)
	rt = rt_mpath_selectrte(rt, 0);
	#endif
	nh = rt->rt_nhop;
	/* Ensure route & ifp is UP */			/* Ensure route & ifp is UP */
	if (RT_LINK_IS_UP(nh->nh_ifp)) {			if (RT_LINK_IS_UP(nh->nh_ifp)) {
	if (flags & NHR_REF)			if (flags & NHR_REF)
	nhop_ref_object(nh);			nhop_ref_object(nh);
	return (nh);			return (nh);
	}			}
	}			}

	return (NULL);			return (NULL);
	}			}

	#endif			#endif