xref: /freebsd/sys/netinet/in_fib.c (revision ebacd8013fe5f7fdf9f6a5b286f6680dd2891036)
1 /*-
2  * Copyright (c) 2015
3  * 	Alexander V. Chernikov <melifaro@FreeBSD.org>
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the University nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
32 
33 #include "opt_inet.h"
34 #include "opt_route.h"
35 
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/lock.h>
39 #include <sys/rmlock.h>
40 #include <sys/malloc.h>
41 #include <sys/mbuf.h>
42 #include <sys/socket.h>
43 #include <sys/sysctl.h>
44 #include <sys/kernel.h>
45 
46 #include <net/if.h>
47 #include <net/if_var.h>
48 #include <net/if_dl.h>
49 #include <net/if_private.h>
50 #include <net/route.h>
51 #include <net/route/route_ctl.h>
52 #include <net/route/route_var.h>
53 #include <net/route/fib_algo.h>
54 #include <net/route/nhop.h>
55 #include <net/toeplitz.h>
56 #include <net/vnet.h>
57 
58 #include <netinet/in.h>
59 #include <netinet/in_var.h>
60 #include <netinet/in_fib.h>
61 
62 #ifdef INET
63 
64 /* Verify struct route compatibility */
65 /* Assert 'struct route_in' is compatible with 'struct route' */
66 CHK_STRUCT_ROUTE_COMPAT(struct route_in, ro_dst4);
67 
68 #ifdef FIB_ALGO
69 VNET_DEFINE(struct fib_dp *, inet_dp);
70 #endif
71 
72 #ifdef ROUTE_MPATH
73 struct _hash_5tuple_ipv4 {
74 	struct in_addr src;
75 	struct in_addr dst;
76 	unsigned short src_port;
77 	unsigned short dst_port;
78 	char proto;
79 	char spare[3];
80 };
81 _Static_assert(sizeof(struct _hash_5tuple_ipv4) == 16,
82     "_hash_5tuple_ipv4 size is wrong");
83 
84 uint32_t
85 fib4_calc_software_hash(struct in_addr src, struct in_addr dst,
86     unsigned short src_port, unsigned short dst_port, char proto,
87     uint32_t *phashtype)
88 {
89 	struct _hash_5tuple_ipv4 data;
90 
91 	data.src = src;
92 	data.dst = dst;
93 	data.src_port = src_port;
94 	data.dst_port = dst_port;
95 	data.proto = proto;
96 	data.spare[0] = data.spare[1] = data.spare[2] = 0;
97 
98 	*phashtype = M_HASHTYPE_OPAQUE;
99 
100 	return (toeplitz_hash(MPATH_ENTROPY_KEY_LEN, mpath_entropy_key,
101 	  sizeof(data), (uint8_t *)&data));
102 }
103 #endif
104 
105 /*
106  * Looks up path in fib @fibnum specified by @dst.
107  * Returns path nexthop on success. Nexthop is safe to use
108  *  within the current network epoch. If longer lifetime is required,
109  *  one needs to pass NHR_REF as a flag. This will return referenced
110  *  nexthop.
111  */
112 #ifdef FIB_ALGO
113 struct nhop_object *
114 fib4_lookup(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,
115     uint32_t flags, uint32_t flowid)
116 {
117 	struct nhop_object *nh;
118 	struct fib_dp *dp = &V_inet_dp[fibnum];
119 	struct flm_lookup_key key = {.addr4 = dst };
120 
121 	nh = dp->f(dp->arg, key, scopeid);
122 	if (nh != NULL) {
123 		nh = nhop_select(nh, flowid);
124 		/* Ensure route & ifp is UP */
125 		if (RT_LINK_IS_UP(nh->nh_ifp)) {
126 			if (flags & NHR_REF)
127 				nhop_ref_object(nh);
128 			return (nh);
129 		}
130 	}
131 	RTSTAT_INC(rts_unreach);
132 	return (NULL);
133 }
134 #else
135 struct nhop_object *
136 fib4_lookup(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,
137     uint32_t flags, uint32_t flowid)
138 {
139 	RIB_RLOCK_TRACKER;
140 	struct rib_head *rh;
141 	struct radix_node *rn;
142 	struct nhop_object *nh;
143 
144 	KASSERT((fibnum < rt_numfibs), ("fib4_lookup: bad fibnum"));
145 	rh = rt_tables_get_rnh(fibnum, AF_INET);
146 	if (rh == NULL)
147 		return (NULL);
148 
149 	/* Prepare lookup key */
150 	struct sockaddr_in sin4 = {
151 		.sin_family = AF_INET,
152 		.sin_len = sizeof(struct sockaddr_in),
153 		.sin_addr = dst,
154 	};
155 
156 	nh = NULL;
157 	RIB_RLOCK(rh);
158 	rn = rh->rnh_matchaddr((void *)&sin4, &rh->head);
159 	if (rn != NULL && ((rn->rn_flags & RNF_ROOT) == 0)) {
160 		nh = nhop_select((RNTORT(rn))->rt_nhop, flowid);
161 		/* Ensure route & ifp is UP */
162 		if (RT_LINK_IS_UP(nh->nh_ifp)) {
163 			if (flags & NHR_REF)
164 				nhop_ref_object(nh);
165 			RIB_RUNLOCK(rh);
166 			return (nh);
167 		}
168 	}
169 	RIB_RUNLOCK(rh);
170 
171 	RTSTAT_INC(rts_unreach);
172 	return (NULL);
173 }
174 #endif
175 
176 inline static int
177 check_urpf_nhop(const struct nhop_object *nh, uint32_t flags,
178     const struct ifnet *src_if)
179 {
180 
181 	if (src_if != NULL && nh->nh_aifp == src_if) {
182 		return (1);
183 	}
184 	if (src_if == NULL) {
185 		if ((flags & NHR_NODEFAULT) == 0)
186 			return (1);
187 		else if ((nh->nh_flags & NHF_DEFAULT) == 0)
188 			return (1);
189 	}
190 
191 	return (0);
192 }
193 
194 static int
195 check_urpf(struct nhop_object *nh, uint32_t flags,
196     const struct ifnet *src_if)
197 {
198 #ifdef ROUTE_MPATH
199 	if (NH_IS_NHGRP(nh)) {
200 		const struct weightened_nhop *wn;
201 		uint32_t num_nhops;
202 		wn = nhgrp_get_nhops((struct nhgrp_object *)nh, &num_nhops);
203 			for (int i = 0; i < num_nhops; i++) {
204 				if (check_urpf_nhop(wn[i].nh, flags, src_if) != 0)
205 				return (1);
206 		}
207 		return (0);
208 	} else
209 #endif
210 		return (check_urpf_nhop(nh, flags, src_if));
211 }
212 
213 #ifndef FIB_ALGO
214 static struct nhop_object *
215 lookup_nhop(uint32_t fibnum, struct in_addr dst, uint32_t scopeid)
216 {
217 	RIB_RLOCK_TRACKER;
218 	struct rib_head *rh;
219 	struct radix_node *rn;
220 	struct nhop_object *nh;
221 
222 	KASSERT((fibnum < rt_numfibs), ("fib4_check_urpf: bad fibnum"));
223 	rh = rt_tables_get_rnh(fibnum, AF_INET);
224 	if (rh == NULL)
225 		return (NULL);
226 
227 	/* Prepare lookup key */
228 	struct sockaddr_in sin4;
229 	memset(&sin4, 0, sizeof(sin4));
230 	sin4.sin_len = sizeof(struct sockaddr_in);
231 	sin4.sin_addr = dst;
232 
233 	nh = NULL;
234 	RIB_RLOCK(rh);
235 	rn = rh->rnh_matchaddr((void *)&sin4, &rh->head);
236 	if (rn != NULL && ((rn->rn_flags & RNF_ROOT) == 0))
237 		nh = RNTORT(rn)->rt_nhop;
238 	RIB_RUNLOCK(rh);
239 
240 	return (nh);
241 }
242 #endif
243 
244 /*
245  * Performs reverse path forwarding lookup.
246  * If @src_if is non-zero, verifies that at least 1 path goes via
247  *   this interface.
248  * If @src_if is zero, verifies that route exist.
249  * if @flags contains NHR_NOTDEFAULT, do not consider default route.
250  *
251  * Returns 1 if route matching conditions is found, 0 otherwise.
252  */
253 int
254 fib4_check_urpf(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,
255   uint32_t flags, const struct ifnet *src_if)
256 {
257 	struct nhop_object *nh;
258 #ifdef FIB_ALGO
259 	struct fib_dp *dp = &V_inet_dp[fibnum];
260 	struct flm_lookup_key key = {.addr4 = dst };
261 
262 	nh = dp->f(dp->arg, key, scopeid);
263 #else
264 	nh = lookup_nhop(fibnum, dst, scopeid);
265 #endif
266 	if (nh != NULL)
267 		return (check_urpf(nh, flags, src_if));
268 
269 	return (0);
270 }
271 
272 /*
273  * Function returning prefix match data along with the nexthop data.
274  * Intended to be used by the control plane code.
275  * Supported flags:
276  *  NHR_UNLOCKED: do not lock radix during lookup.
277  * Returns pointer to rtentry and raw nexthop in @rnd. Both rtentry
278  *  and nexthop are safe to use within current epoch. Note:
279  * Note: rnd_nhop can actually be the nexthop group.
280  */
281 struct rtentry *
282 fib4_lookup_rt(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,
283     uint32_t flags, struct route_nhop_data *rnd)
284 {
285 	RIB_RLOCK_TRACKER;
286 	struct rib_head *rh;
287 	struct radix_node *rn;
288 	struct rtentry *rt;
289 
290 	KASSERT((fibnum < rt_numfibs), ("fib4_lookup_rt: bad fibnum"));
291 	rh = rt_tables_get_rnh(fibnum, AF_INET);
292 	if (rh == NULL)
293 		return (NULL);
294 
295 	/* Prepare lookup key */
296 	struct sockaddr_in sin4 = {
297 		.sin_family = AF_INET,
298 		.sin_len = sizeof(struct sockaddr_in),
299 		.sin_addr = dst,
300 	};
301 
302 	rt = NULL;
303 	if (!(flags & NHR_UNLOCKED))
304 		RIB_RLOCK(rh);
305 	rn = rh->rnh_matchaddr((void *)&sin4, &rh->head);
306 	if (rn != NULL && ((rn->rn_flags & RNF_ROOT) == 0)) {
307 		rt = (struct rtentry *)rn;
308 		rnd->rnd_nhop = rt->rt_nhop;
309 		rnd->rnd_weight = rt->rt_weight;
310 	}
311 	if (!(flags & NHR_UNLOCKED))
312 		RIB_RUNLOCK(rh);
313 
314 	return (rt);
315 }
316 
317 struct nhop_object *
318 fib4_lookup_debugnet(uint32_t fibnum, struct in_addr dst, uint32_t scopeid,
319     uint32_t flags)
320 {
321 	struct rtentry *rt;
322 	struct route_nhop_data rnd;
323 
324 	rt = fib4_lookup_rt(fibnum, dst, scopeid, NHR_UNLOCKED, &rnd);
325 	if (rt != NULL) {
326 		struct nhop_object *nh = nhop_select(rnd.rnd_nhop, 0);
327 		/* Ensure route & ifp is UP */
328 		if (RT_LINK_IS_UP(nh->nh_ifp))
329 			return (nh);
330 	}
331 
332 	return (NULL);
333 }
334 
335 #endif
336