xref: /freebsd/sys/netinet6/in6_src.c (revision 2f513db72b034fd5ef7f080b11be5c711c15186a)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. Neither the name of the project nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  *
31  *	$KAME: in6_src.c,v 1.132 2003/08/26 04:42:27 keiichi Exp $
32  */
33 
34 /*-
35  * Copyright (c) 1982, 1986, 1991, 1993
36  *	The Regents of the University of California.  All rights reserved.
37  *
38  * Redistribution and use in source and binary forms, with or without
39  * modification, are permitted provided that the following conditions
40  * are met:
41  * 1. Redistributions of source code must retain the above copyright
42  *    notice, this list of conditions and the following disclaimer.
43  * 2. Redistributions in binary form must reproduce the above copyright
44  *    notice, this list of conditions and the following disclaimer in the
45  *    documentation and/or other materials provided with the distribution.
46  * 3. Neither the name of the University nor the names of its contributors
47  *    may be used to endorse or promote products derived from this software
48  *    without specific prior written permission.
49  *
50  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
51  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
52  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
53  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
54  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
55  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
56  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
58  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
59  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
60  * SUCH DAMAGE.
61  *
62  *	@(#)in_pcb.c	8.2 (Berkeley) 1/4/94
63  */
64 
65 #include <sys/cdefs.h>
66 __FBSDID("$FreeBSD$");
67 
68 #include "opt_inet.h"
69 #include "opt_inet6.h"
70 #include "opt_mpath.h"
71 
72 #include <sys/param.h>
73 #include <sys/systm.h>
74 #include <sys/lock.h>
75 #include <sys/malloc.h>
76 #include <sys/mbuf.h>
77 #include <sys/priv.h>
78 #include <sys/protosw.h>
79 #include <sys/socket.h>
80 #include <sys/socketvar.h>
81 #include <sys/sockio.h>
82 #include <sys/sysctl.h>
83 #include <sys/errno.h>
84 #include <sys/time.h>
85 #include <sys/jail.h>
86 #include <sys/kernel.h>
87 #include <sys/rmlock.h>
88 #include <sys/sx.h>
89 
90 #include <net/if.h>
91 #include <net/if_var.h>
92 #include <net/if_dl.h>
93 #include <net/route.h>
94 #include <net/if_llatbl.h>
95 #ifdef RADIX_MPATH
96 #include <net/radix_mpath.h>
97 #endif
98 
99 #include <netinet/in.h>
100 #include <netinet/in_var.h>
101 #include <netinet/in_systm.h>
102 #include <netinet/ip.h>
103 #include <netinet/in_pcb.h>
104 #include <netinet/ip_var.h>
105 #include <netinet/udp.h>
106 #include <netinet/udp_var.h>
107 
108 #include <netinet6/in6_var.h>
109 #include <netinet/ip6.h>
110 #include <netinet6/in6_fib.h>
111 #include <netinet6/in6_pcb.h>
112 #include <netinet6/ip6_var.h>
113 #include <netinet6/scope6_var.h>
114 #include <netinet6/nd6.h>
115 
116 static struct mtx addrsel_lock;
117 #define	ADDRSEL_LOCK_INIT()	mtx_init(&addrsel_lock, "addrsel_lock", NULL, MTX_DEF)
118 #define	ADDRSEL_LOCK()		mtx_lock(&addrsel_lock)
119 #define	ADDRSEL_UNLOCK()	mtx_unlock(&addrsel_lock)
120 #define	ADDRSEL_LOCK_ASSERT()	mtx_assert(&addrsel_lock, MA_OWNED)
121 
122 static struct sx addrsel_sxlock;
123 #define	ADDRSEL_SXLOCK_INIT()	sx_init(&addrsel_sxlock, "addrsel_sxlock")
124 #define	ADDRSEL_SLOCK()		sx_slock(&addrsel_sxlock)
125 #define	ADDRSEL_SUNLOCK()	sx_sunlock(&addrsel_sxlock)
126 #define	ADDRSEL_XLOCK()		sx_xlock(&addrsel_sxlock)
127 #define	ADDRSEL_XUNLOCK()	sx_xunlock(&addrsel_sxlock)
128 
129 #define ADDR_LABEL_NOTAPP (-1)
130 VNET_DEFINE_STATIC(struct in6_addrpolicy, defaultaddrpolicy);
131 #define	V_defaultaddrpolicy		VNET(defaultaddrpolicy)
132 
133 VNET_DEFINE(int, ip6_prefer_tempaddr) = 0;
134 
135 static int selectroute(struct sockaddr_in6 *, struct ip6_pktopts *,
136 	struct ip6_moptions *, struct route_in6 *, struct ifnet **,
137 	struct rtentry **, int, u_int);
138 static int in6_selectif(struct sockaddr_in6 *, struct ip6_pktopts *,
139 	struct ip6_moptions *, struct ifnet **,
140 	struct ifnet *, u_int);
141 static int in6_selectsrc(uint32_t, struct sockaddr_in6 *,
142 	struct ip6_pktopts *, struct inpcb *, struct ucred *,
143 	struct ifnet **, struct in6_addr *);
144 
145 static struct in6_addrpolicy *lookup_addrsel_policy(struct sockaddr_in6 *);
146 
147 static void init_policy_queue(void);
148 static int add_addrsel_policyent(struct in6_addrpolicy *);
149 static int delete_addrsel_policyent(struct in6_addrpolicy *);
150 static int walk_addrsel_policy(int (*)(struct in6_addrpolicy *, void *),
151 	void *);
152 static int dump_addrsel_policyent(struct in6_addrpolicy *, void *);
153 static struct in6_addrpolicy *match_addrsel_policy(struct sockaddr_in6 *);
154 
155 /*
156  * Return an IPv6 address, which is the most appropriate for a given
157  * destination and user specified options.
158  * If necessary, this function lookups the routing table and returns
159  * an entry to the caller for later use.
160  */
161 #define REPLACE(r) do {\
162 	IP6STAT_INC(ip6s_sources_rule[(r)]); \
163 	/* { \
164 	char ip6buf[INET6_ADDRSTRLEN], ip6b[INET6_ADDRSTRLEN]; \
165 	printf("in6_selectsrc: replace %s with %s by %d\n", ia_best ? ip6_sprintf(ip6buf, &ia_best->ia_addr.sin6_addr) : "none", ip6_sprintf(ip6b, &ia->ia_addr.sin6_addr), (r)); \
166 	} */ \
167 	goto replace; \
168 } while(0)
169 #define NEXT(r) do {\
170 	/* { \
171 	char ip6buf[INET6_ADDRSTRLEN], ip6b[INET6_ADDRSTRLEN]; \
172 	printf("in6_selectsrc: keep %s against %s by %d\n", ia_best ? ip6_sprintf(ip6buf, &ia_best->ia_addr.sin6_addr) : "none", ip6_sprintf(ip6b, &ia->ia_addr.sin6_addr), (r)); \
173 	} */ \
174 	goto next;		/* XXX: we can't use 'continue' here */ \
175 } while(0)
176 #define BREAK(r) do { \
177 	IP6STAT_INC(ip6s_sources_rule[(r)]); \
178 	goto out;		/* XXX: we can't use 'break' here */ \
179 } while(0)
180 
181 static int
182 in6_selectsrc(uint32_t fibnum, struct sockaddr_in6 *dstsock,
183     struct ip6_pktopts *opts, struct inpcb *inp, struct ucred *cred,
184     struct ifnet **ifpp, struct in6_addr *srcp)
185 {
186 	struct rm_priotracker in6_ifa_tracker;
187 	struct in6_addr dst, tmp;
188 	struct ifnet *ifp = NULL, *oifp = NULL;
189 	struct in6_ifaddr *ia = NULL, *ia_best = NULL;
190 	struct in6_pktinfo *pi = NULL;
191 	int dst_scope = -1, best_scope = -1, best_matchlen = -1;
192 	struct in6_addrpolicy *dst_policy = NULL, *best_policy = NULL;
193 	u_int32_t odstzone;
194 	int prefer_tempaddr;
195 	int error;
196 	struct ip6_moptions *mopts;
197 
198 	KASSERT(srcp != NULL, ("%s: srcp is NULL", __func__));
199 
200 	dst = dstsock->sin6_addr; /* make a copy for local operation */
201 	if (ifpp) {
202 		/*
203 		 * Save a possibly passed in ifp for in6_selectsrc. Only
204 		 * neighbor discovery code should use this feature, where
205 		 * we may know the interface but not the FIB number holding
206 		 * the connected subnet in case someone deleted it from the
207 		 * default FIB and we need to check the interface.
208 		 */
209 		if (*ifpp != NULL)
210 			oifp = *ifpp;
211 		*ifpp = NULL;
212 	}
213 
214 	if (inp != NULL) {
215 		INP_LOCK_ASSERT(inp);
216 		mopts = inp->in6p_moptions;
217 	} else {
218 		mopts = NULL;
219 	}
220 
221 	/*
222 	 * If the source address is explicitly specified by the caller,
223 	 * check if the requested source address is indeed a unicast address
224 	 * assigned to the node, and can be used as the packet's source
225 	 * address.  If everything is okay, use the address as source.
226 	 */
227 	if (opts && (pi = opts->ip6po_pktinfo) &&
228 	    !IN6_IS_ADDR_UNSPECIFIED(&pi->ipi6_addr)) {
229 		/* get the outgoing interface */
230 		if ((error = in6_selectif(dstsock, opts, mopts, &ifp, oifp,
231 		    fibnum))
232 		    != 0)
233 			return (error);
234 
235 		/*
236 		 * determine the appropriate zone id of the source based on
237 		 * the zone of the destination and the outgoing interface.
238 		 * If the specified address is ambiguous wrt the scope zone,
239 		 * the interface must be specified; otherwise, ifa_ifwithaddr()
240 		 * will fail matching the address.
241 		 */
242 		tmp = pi->ipi6_addr;
243 		if (ifp) {
244 			error = in6_setscope(&tmp, ifp, &odstzone);
245 			if (error)
246 				return (error);
247 		}
248 		if (cred != NULL && (error = prison_local_ip6(cred,
249 		    &tmp, (inp->inp_flags & IN6P_IPV6_V6ONLY) != 0)) != 0)
250 			return (error);
251 
252 		/*
253 		 * If IPV6_BINDANY socket option is set, we allow to specify
254 		 * non local addresses as source address in IPV6_PKTINFO
255 		 * ancillary data.
256 		 */
257 		if ((inp->inp_flags & INP_BINDANY) == 0) {
258 			ia = in6ifa_ifwithaddr(&tmp, 0 /* XXX */);
259 			if (ia == NULL || (ia->ia6_flags & (IN6_IFF_ANYCAST |
260 			    IN6_IFF_NOTREADY))) {
261 				if (ia != NULL)
262 					ifa_free(&ia->ia_ifa);
263 				return (EADDRNOTAVAIL);
264 			}
265 			bcopy(&ia->ia_addr.sin6_addr, srcp, sizeof(*srcp));
266 			ifa_free(&ia->ia_ifa);
267 		} else
268 			bcopy(&tmp, srcp, sizeof(*srcp));
269 		pi->ipi6_addr = tmp; /* XXX: this overrides pi */
270 		if (ifpp)
271 			*ifpp = ifp;
272 		return (0);
273 	}
274 
275 	/*
276 	 * Otherwise, if the socket has already bound the source, just use it.
277 	 */
278 	if (inp != NULL && !IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)) {
279 		if (cred != NULL &&
280 		    (error = prison_local_ip6(cred, &inp->in6p_laddr,
281 		    ((inp->inp_flags & IN6P_IPV6_V6ONLY) != 0))) != 0)
282 			return (error);
283 		bcopy(&inp->in6p_laddr, srcp, sizeof(*srcp));
284 		return (0);
285 	}
286 
287 	/*
288 	 * Bypass source address selection and use the primary jail IP
289 	 * if requested.
290 	 */
291 	if (cred != NULL && !prison_saddrsel_ip6(cred, srcp))
292 		return (0);
293 
294 	/*
295 	 * If the address is not specified, choose the best one based on
296 	 * the outgoing interface and the destination address.
297 	 */
298 	/* get the outgoing interface */
299 	if ((error = in6_selectif(dstsock, opts, mopts, &ifp, oifp,
300 	    (inp != NULL) ? inp->inp_inc.inc_fibnum : fibnum)) != 0)
301 		return (error);
302 
303 #ifdef DIAGNOSTIC
304 	if (ifp == NULL)	/* this should not happen */
305 		panic("in6_selectsrc: NULL ifp");
306 #endif
307 	error = in6_setscope(&dst, ifp, &odstzone);
308 	if (error)
309 		return (error);
310 
311 	IN6_IFADDR_RLOCK(&in6_ifa_tracker);
312 	CK_STAILQ_FOREACH(ia, &V_in6_ifaddrhead, ia_link) {
313 		int new_scope = -1, new_matchlen = -1;
314 		struct in6_addrpolicy *new_policy = NULL;
315 		u_int32_t srczone, osrczone, dstzone;
316 		struct in6_addr src;
317 		struct ifnet *ifp1 = ia->ia_ifp;
318 
319 		/*
320 		 * We'll never take an address that breaks the scope zone
321 		 * of the destination.  We also skip an address if its zone
322 		 * does not contain the outgoing interface.
323 		 * XXX: we should probably use sin6_scope_id here.
324 		 */
325 		if (in6_setscope(&dst, ifp1, &dstzone) ||
326 		    odstzone != dstzone) {
327 			continue;
328 		}
329 		src = ia->ia_addr.sin6_addr;
330 		if (in6_setscope(&src, ifp, &osrczone) ||
331 		    in6_setscope(&src, ifp1, &srczone) ||
332 		    osrczone != srczone) {
333 			continue;
334 		}
335 
336 		/* avoid unusable addresses */
337 		if ((ia->ia6_flags &
338 		     (IN6_IFF_NOTREADY | IN6_IFF_ANYCAST | IN6_IFF_DETACHED))) {
339 				continue;
340 		}
341 		if (!V_ip6_use_deprecated && IFA6_IS_DEPRECATED(ia))
342 			continue;
343 
344 		/* If jailed only take addresses of the jail into account. */
345 		if (cred != NULL &&
346 		    prison_check_ip6(cred, &ia->ia_addr.sin6_addr) != 0)
347 			continue;
348 
349 		/* Rule 1: Prefer same address */
350 		if (IN6_ARE_ADDR_EQUAL(&dst, &ia->ia_addr.sin6_addr)) {
351 			ia_best = ia;
352 			BREAK(1); /* there should be no better candidate */
353 		}
354 
355 		if (ia_best == NULL)
356 			REPLACE(0);
357 
358 		/* Rule 2: Prefer appropriate scope */
359 		if (dst_scope < 0)
360 			dst_scope = in6_addrscope(&dst);
361 		new_scope = in6_addrscope(&ia->ia_addr.sin6_addr);
362 		if (IN6_ARE_SCOPE_CMP(best_scope, new_scope) < 0) {
363 			if (IN6_ARE_SCOPE_CMP(best_scope, dst_scope) < 0)
364 				REPLACE(2);
365 			NEXT(2);
366 		} else if (IN6_ARE_SCOPE_CMP(new_scope, best_scope) < 0) {
367 			if (IN6_ARE_SCOPE_CMP(new_scope, dst_scope) < 0)
368 				NEXT(2);
369 			REPLACE(2);
370 		}
371 
372 		/*
373 		 * Rule 3: Avoid deprecated addresses.  Note that the case of
374 		 * !ip6_use_deprecated is already rejected above.
375 		 */
376 		if (!IFA6_IS_DEPRECATED(ia_best) && IFA6_IS_DEPRECATED(ia))
377 			NEXT(3);
378 		if (IFA6_IS_DEPRECATED(ia_best) && !IFA6_IS_DEPRECATED(ia))
379 			REPLACE(3);
380 
381 		/* Rule 4: Prefer home addresses */
382 		/*
383 		 * XXX: This is a TODO.  We should probably merge the MIP6
384 		 * case above.
385 		 */
386 
387 		/* Rule 5: Prefer outgoing interface */
388 		if (!(ND_IFINFO(ifp)->flags & ND6_IFF_NO_PREFER_IFACE)) {
389 			if (ia_best->ia_ifp == ifp && ia->ia_ifp != ifp)
390 				NEXT(5);
391 			if (ia_best->ia_ifp != ifp && ia->ia_ifp == ifp)
392 				REPLACE(5);
393 		}
394 
395 		/*
396 		 * Rule 6: Prefer matching label
397 		 * Note that best_policy should be non-NULL here.
398 		 */
399 		if (dst_policy == NULL)
400 			dst_policy = lookup_addrsel_policy(dstsock);
401 		if (dst_policy->label != ADDR_LABEL_NOTAPP) {
402 			new_policy = lookup_addrsel_policy(&ia->ia_addr);
403 			if (dst_policy->label == best_policy->label &&
404 			    dst_policy->label != new_policy->label)
405 				NEXT(6);
406 			if (dst_policy->label != best_policy->label &&
407 			    dst_policy->label == new_policy->label)
408 				REPLACE(6);
409 		}
410 
411 		/*
412 		 * Rule 7: Prefer public addresses.
413 		 * We allow users to reverse the logic by configuring
414 		 * a sysctl variable, so that privacy conscious users can
415 		 * always prefer temporary addresses.
416 		 */
417 		if (opts == NULL ||
418 		    opts->ip6po_prefer_tempaddr == IP6PO_TEMPADDR_SYSTEM) {
419 			prefer_tempaddr = V_ip6_prefer_tempaddr;
420 		} else if (opts->ip6po_prefer_tempaddr ==
421 		    IP6PO_TEMPADDR_NOTPREFER) {
422 			prefer_tempaddr = 0;
423 		} else
424 			prefer_tempaddr = 1;
425 		if (!(ia_best->ia6_flags & IN6_IFF_TEMPORARY) &&
426 		    (ia->ia6_flags & IN6_IFF_TEMPORARY)) {
427 			if (prefer_tempaddr)
428 				REPLACE(7);
429 			else
430 				NEXT(7);
431 		}
432 		if ((ia_best->ia6_flags & IN6_IFF_TEMPORARY) &&
433 		    !(ia->ia6_flags & IN6_IFF_TEMPORARY)) {
434 			if (prefer_tempaddr)
435 				NEXT(7);
436 			else
437 				REPLACE(7);
438 		}
439 
440 		/*
441 		 * Rule 8: prefer addresses on alive interfaces.
442 		 * This is a KAME specific rule.
443 		 */
444 		if ((ia_best->ia_ifp->if_flags & IFF_UP) &&
445 		    !(ia->ia_ifp->if_flags & IFF_UP))
446 			NEXT(8);
447 		if (!(ia_best->ia_ifp->if_flags & IFF_UP) &&
448 		    (ia->ia_ifp->if_flags & IFF_UP))
449 			REPLACE(8);
450 
451 		/*
452 		 * Rule 9: prefer address with better virtual status.
453 		 */
454 		if (ifa_preferred(&ia_best->ia_ifa, &ia->ia_ifa))
455 			REPLACE(9);
456 		if (ifa_preferred(&ia->ia_ifa, &ia_best->ia_ifa))
457 			NEXT(9);
458 
459 		/*
460 		 * Rule 10: prefer address with `prefer_source' flag.
461 		 */
462 		if ((ia_best->ia6_flags & IN6_IFF_PREFER_SOURCE) == 0 &&
463 		    (ia->ia6_flags & IN6_IFF_PREFER_SOURCE) != 0)
464 			REPLACE(10);
465 		if ((ia_best->ia6_flags & IN6_IFF_PREFER_SOURCE) != 0 &&
466 		    (ia->ia6_flags & IN6_IFF_PREFER_SOURCE) == 0)
467 			NEXT(10);
468 
469 		/*
470 		 * Rule 14: Use longest matching prefix.
471 		 * Note: in the address selection draft, this rule is
472 		 * documented as "Rule 8".  However, since it is also
473 		 * documented that this rule can be overridden, we assign
474 		 * a large number so that it is easy to assign smaller numbers
475 		 * to more preferred rules.
476 		 */
477 		new_matchlen = in6_matchlen(&ia->ia_addr.sin6_addr, &dst);
478 		if (best_matchlen < new_matchlen)
479 			REPLACE(14);
480 		if (new_matchlen < best_matchlen)
481 			NEXT(14);
482 
483 		/* Rule 15 is reserved. */
484 
485 		/*
486 		 * Last resort: just keep the current candidate.
487 		 * Or, do we need more rules?
488 		 */
489 		continue;
490 
491 	  replace:
492 		ia_best = ia;
493 		best_scope = (new_scope >= 0 ? new_scope :
494 			      in6_addrscope(&ia_best->ia_addr.sin6_addr));
495 		best_policy = (new_policy ? new_policy :
496 			       lookup_addrsel_policy(&ia_best->ia_addr));
497 		best_matchlen = (new_matchlen >= 0 ? new_matchlen :
498 				 in6_matchlen(&ia_best->ia_addr.sin6_addr,
499 					      &dst));
500 
501 	  next:
502 		continue;
503 
504 	  out:
505 		break;
506 	}
507 
508 	if ((ia = ia_best) == NULL) {
509 		IN6_IFADDR_RUNLOCK(&in6_ifa_tracker);
510 		IP6STAT_INC(ip6s_sources_none);
511 		return (EADDRNOTAVAIL);
512 	}
513 
514 	/*
515 	 * At this point at least one of the addresses belonged to the jail
516 	 * but it could still be, that we want to further restrict it, e.g.
517 	 * theoratically IN6_IS_ADDR_LOOPBACK.
518 	 * It must not be IN6_IS_ADDR_UNSPECIFIED anymore.
519 	 * prison_local_ip6() will fix an IN6_IS_ADDR_LOOPBACK but should
520 	 * let all others previously selected pass.
521 	 * Use tmp to not change ::1 on lo0 to the primary jail address.
522 	 */
523 	tmp = ia->ia_addr.sin6_addr;
524 	if (cred != NULL && prison_local_ip6(cred, &tmp, (inp != NULL &&
525 	    (inp->inp_flags & IN6P_IPV6_V6ONLY) != 0)) != 0) {
526 		IN6_IFADDR_RUNLOCK(&in6_ifa_tracker);
527 		IP6STAT_INC(ip6s_sources_none);
528 		return (EADDRNOTAVAIL);
529 	}
530 
531 	if (ifpp)
532 		*ifpp = ifp;
533 
534 	bcopy(&tmp, srcp, sizeof(*srcp));
535 	if (ia->ia_ifp == ifp)
536 		IP6STAT_INC(ip6s_sources_sameif[best_scope]);
537 	else
538 		IP6STAT_INC(ip6s_sources_otherif[best_scope]);
539 	if (dst_scope == best_scope)
540 		IP6STAT_INC(ip6s_sources_samescope[best_scope]);
541 	else
542 		IP6STAT_INC(ip6s_sources_otherscope[best_scope]);
543 	if (IFA6_IS_DEPRECATED(ia))
544 		IP6STAT_INC(ip6s_sources_deprecated[best_scope]);
545 	IN6_IFADDR_RUNLOCK(&in6_ifa_tracker);
546 	return (0);
547 }
548 
549 /*
550  * Select source address based on @inp, @dstsock and @opts.
551  * Stores selected address to @srcp. If @scope_ambiguous is set,
552  * embed scope from selected outgoing interface. If @hlim pointer
553  * is provided, stores calculated hop limit there.
554  * Returns 0 on success.
555  */
556 int
557 in6_selectsrc_socket(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts,
558     struct inpcb *inp, struct ucred *cred, int scope_ambiguous,
559     struct in6_addr *srcp, int *hlim)
560 {
561 	struct ifnet *retifp;
562 	uint32_t fibnum;
563 	int error;
564 
565 	fibnum = inp->inp_inc.inc_fibnum;
566 	retifp = NULL;
567 
568 	error = in6_selectsrc(fibnum, dstsock, opts, inp, cred, &retifp, srcp);
569 	if (error != 0)
570 		return (error);
571 
572 	if (hlim != NULL)
573 		*hlim = in6_selecthlim(inp, retifp);
574 
575 	if (retifp == NULL || scope_ambiguous == 0)
576 		return (0);
577 
578 	/*
579 	 * Application should provide a proper zone ID or the use of
580 	 * default zone IDs should be enabled.  Unfortunately, some
581 	 * applications do not behave as it should, so we need a
582 	 * workaround.  Even if an appropriate ID is not determined
583 	 * (when it's required), if we can determine the outgoing
584 	 * interface. determine the zone ID based on the interface.
585 	 */
586 	error = in6_setscope(&dstsock->sin6_addr, retifp, NULL);
587 
588 	return (error);
589 }
590 
591 /*
592  * Select source address based on @fibnum, @dst and @scopeid.
593  * Stores selected address to @srcp.
594  * Returns 0 on success.
595  *
596  * Used by non-socket based consumers (ND code mostly)
597  */
598 int
599 in6_selectsrc_addr(uint32_t fibnum, const struct in6_addr *dst,
600     uint32_t scopeid, struct ifnet *ifp, struct in6_addr *srcp,
601     int *hlim)
602 {
603 	struct ifnet *retifp;
604 	struct sockaddr_in6 dst_sa;
605 	int error;
606 
607 	retifp = ifp;
608 	bzero(&dst_sa, sizeof(dst_sa));
609 	dst_sa.sin6_family = AF_INET6;
610 	dst_sa.sin6_len = sizeof(dst_sa);
611 	dst_sa.sin6_addr = *dst;
612 	dst_sa.sin6_scope_id = scopeid;
613 	sa6_embedscope(&dst_sa, 0);
614 
615 	error = in6_selectsrc(fibnum, &dst_sa, NULL, NULL, NULL, &retifp, srcp);
616 	if (hlim != NULL)
617 		*hlim = in6_selecthlim(NULL, retifp);
618 
619 	return (error);
620 }
621 
622 /*
623  * clone - meaningful only for bsdi and freebsd
624  */
625 static int
626 selectroute(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts,
627     struct ip6_moptions *mopts, struct route_in6 *ro,
628     struct ifnet **retifp, struct rtentry **retrt, int norouteok, u_int fibnum)
629 {
630 	int error = 0;
631 	struct ifnet *ifp = NULL;
632 	struct rtentry *rt = NULL;
633 	struct sockaddr_in6 *sin6_next;
634 	struct in6_pktinfo *pi = NULL;
635 	struct in6_addr *dst = &dstsock->sin6_addr;
636 	uint32_t zoneid;
637 #if 0
638 	char ip6buf[INET6_ADDRSTRLEN];
639 
640 	if (dstsock->sin6_addr.s6_addr32[0] == 0 &&
641 	    dstsock->sin6_addr.s6_addr32[1] == 0 &&
642 	    !IN6_IS_ADDR_LOOPBACK(&dstsock->sin6_addr)) {
643 		printf("in6_selectroute: strange destination %s\n",
644 		       ip6_sprintf(ip6buf, &dstsock->sin6_addr));
645 	} else {
646 		printf("in6_selectroute: destination = %s%%%d\n",
647 		       ip6_sprintf(ip6buf, &dstsock->sin6_addr),
648 		       dstsock->sin6_scope_id); /* for debug */
649 	}
650 #endif
651 
652 	/* If the caller specify the outgoing interface explicitly, use it. */
653 	if (opts && (pi = opts->ip6po_pktinfo) != NULL && pi->ipi6_ifindex) {
654 		/* XXX boundary check is assumed to be already done. */
655 		ifp = ifnet_byindex(pi->ipi6_ifindex);
656 		if (ifp != NULL &&
657 		    (norouteok || retrt == NULL ||
658 		    IN6_IS_ADDR_MULTICAST(dst))) {
659 			/*
660 			 * we do not have to check or get the route for
661 			 * multicast.
662 			 */
663 			goto done;
664 		} else
665 			goto getroute;
666 	}
667 	/*
668 	 * If the destination address is a multicast address and the outgoing
669 	 * interface for the address is specified by the caller, use it.
670 	 */
671 	if (IN6_IS_ADDR_MULTICAST(dst) &&
672 	    mopts != NULL && (ifp = mopts->im6o_multicast_ifp) != NULL) {
673 		goto done; /* we do not need a route for multicast. */
674 	}
675 	/*
676 	 * If destination address is LLA or link- or node-local multicast,
677 	 * use it's embedded scope zone id to determine outgoing interface.
678 	 */
679 	if (IN6_IS_ADDR_MC_LINKLOCAL(dst) ||
680 	    IN6_IS_ADDR_MC_NODELOCAL(dst)) {
681 		zoneid = ntohs(in6_getscope(dst));
682 		if (zoneid > 0) {
683 			ifp = in6_getlinkifnet(zoneid);
684 			goto done;
685 		}
686 	}
687 
688   getroute:
689 	/*
690 	 * If the next hop address for the packet is specified by the caller,
691 	 * use it as the gateway.
692 	 */
693 	if (opts && opts->ip6po_nexthop) {
694 		struct route_in6 *ron;
695 
696 		sin6_next = satosin6(opts->ip6po_nexthop);
697 		if (IN6_IS_ADDR_LINKLOCAL(&sin6_next->sin6_addr)) {
698 			/*
699 			 * Next hop is LLA, thus it should be neighbor.
700 			 * Determine outgoing interface by zone index.
701 			 */
702 			zoneid = ntohs(in6_getscope(&sin6_next->sin6_addr));
703 			if (zoneid > 0) {
704 				ifp = in6_getlinkifnet(zoneid);
705 				goto done;
706 			}
707 		}
708 		ron = &opts->ip6po_nextroute;
709 		/* Use a cached route if it exists and is valid. */
710 		if (ron->ro_rt != NULL && (
711 		    (ron->ro_rt->rt_flags & RTF_UP) == 0 ||
712 		    ron->ro_dst.sin6_family != AF_INET6 ||
713 		    !IN6_ARE_ADDR_EQUAL(&ron->ro_dst.sin6_addr,
714 			&sin6_next->sin6_addr)))
715 			RO_RTFREE(ron);
716 		if (ron->ro_rt == NULL) {
717 			ron->ro_dst = *sin6_next;
718 			in6_rtalloc(ron, fibnum); /* multi path case? */
719 		}
720 		/*
721 		 * The node identified by that address must be a
722 		 * neighbor of the sending host.
723 		 */
724 		if (ron->ro_rt == NULL ||
725 		    (ron->ro_rt->rt_flags & RTF_GATEWAY) != 0)
726 			error = EHOSTUNREACH;
727 		else {
728 			rt = ron->ro_rt;
729 			ifp = rt->rt_ifp;
730 		}
731 		goto done;
732 	}
733 
734 	/*
735 	 * Use a cached route if it exists and is valid, else try to allocate
736 	 * a new one.  Note that we should check the address family of the
737 	 * cached destination, in case of sharing the cache with IPv4.
738 	 */
739 	if (ro) {
740 		if (ro->ro_rt &&
741 		    (!(ro->ro_rt->rt_flags & RTF_UP) ||
742 		     ((struct sockaddr *)(&ro->ro_dst))->sa_family != AF_INET6 ||
743 		     !IN6_ARE_ADDR_EQUAL(&satosin6(&ro->ro_dst)->sin6_addr,
744 		     dst))) {
745 			RTFREE(ro->ro_rt);
746 			ro->ro_rt = (struct rtentry *)NULL;
747 		}
748 		if (ro->ro_rt == (struct rtentry *)NULL) {
749 			struct sockaddr_in6 *sa6;
750 
751 			/* No route yet, so try to acquire one */
752 			bzero(&ro->ro_dst, sizeof(struct sockaddr_in6));
753 			sa6 = (struct sockaddr_in6 *)&ro->ro_dst;
754 			*sa6 = *dstsock;
755 			sa6->sin6_scope_id = 0;
756 
757 #ifdef RADIX_MPATH
758 				rtalloc_mpath_fib((struct route *)ro,
759 				    ntohl(sa6->sin6_addr.s6_addr32[3]), fibnum);
760 #else
761 				ro->ro_rt = in6_rtalloc1((struct sockaddr *)
762 				    &ro->ro_dst, 0, 0UL, fibnum);
763 				if (ro->ro_rt)
764 					RT_UNLOCK(ro->ro_rt);
765 #endif
766 		}
767 
768 		/*
769 		 * do not care about the result if we have the nexthop
770 		 * explicitly specified.
771 		 */
772 		if (opts && opts->ip6po_nexthop)
773 			goto done;
774 
775 		if (ro->ro_rt) {
776 			ifp = ro->ro_rt->rt_ifp;
777 
778 			if (ifp == NULL) { /* can this really happen? */
779 				RTFREE(ro->ro_rt);
780 				ro->ro_rt = NULL;
781 			}
782 		}
783 		if (ro->ro_rt == NULL)
784 			error = EHOSTUNREACH;
785 		rt = ro->ro_rt;
786 
787 		/*
788 		 * Check if the outgoing interface conflicts with
789 		 * the interface specified by ipi6_ifindex (if specified).
790 		 * Note that loopback interface is always okay.
791 		 * (this may happen when we are sending a packet to one of
792 		 *  our own addresses.)
793 		 */
794 		if (ifp && opts && opts->ip6po_pktinfo &&
795 		    opts->ip6po_pktinfo->ipi6_ifindex) {
796 			if (!(ifp->if_flags & IFF_LOOPBACK) &&
797 			    ifp->if_index !=
798 			    opts->ip6po_pktinfo->ipi6_ifindex) {
799 				error = EHOSTUNREACH;
800 				goto done;
801 			}
802 		}
803 	}
804 
805   done:
806 	if (ifp == NULL && rt == NULL) {
807 		/*
808 		 * This can happen if the caller did not pass a cached route
809 		 * nor any other hints.  We treat this case an error.
810 		 */
811 		error = EHOSTUNREACH;
812 	}
813 	if (error == EHOSTUNREACH)
814 		IP6STAT_INC(ip6s_noroute);
815 
816 	if (retifp != NULL) {
817 		*retifp = ifp;
818 
819 		/*
820 		 * Adjust the "outgoing" interface.  If we're going to loop
821 		 * the packet back to ourselves, the ifp would be the loopback
822 		 * interface. However, we'd rather know the interface associated
823 		 * to the destination address (which should probably be one of
824 		 * our own addresses.)
825 		 */
826 		if (rt) {
827 			if ((rt->rt_ifp->if_flags & IFF_LOOPBACK) &&
828 			    (rt->rt_gateway->sa_family == AF_LINK))
829 				*retifp =
830 					ifnet_byindex(((struct sockaddr_dl *)
831 						       rt->rt_gateway)->sdl_index);
832 		}
833 	}
834 
835 	if (retrt != NULL)
836 		*retrt = rt;	/* rt may be NULL */
837 
838 	return (error);
839 }
840 
841 static int
842 in6_selectif(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts,
843     struct ip6_moptions *mopts, struct ifnet **retifp,
844     struct ifnet *oifp, u_int fibnum)
845 {
846 	int error;
847 	struct route_in6 sro;
848 	struct rtentry *rt = NULL;
849 	int rt_flags;
850 
851 	KASSERT(retifp != NULL, ("%s: retifp is NULL", __func__));
852 
853 	bzero(&sro, sizeof(sro));
854 	rt_flags = 0;
855 
856 	error = selectroute(dstsock, opts, mopts, &sro, retifp, &rt, 1, fibnum);
857 
858 	if (rt)
859 		rt_flags = rt->rt_flags;
860 	if (rt && rt == sro.ro_rt)
861 		RTFREE(rt);
862 
863 	if (error != 0) {
864 		/* Help ND. See oifp comment in in6_selectsrc(). */
865 		if (oifp != NULL && fibnum == RT_DEFAULT_FIB) {
866 			*retifp = oifp;
867 			error = 0;
868 		}
869 		return (error);
870 	}
871 
872 	/*
873 	 * do not use a rejected or black hole route.
874 	 * XXX: this check should be done in the L2 output routine.
875 	 * However, if we skipped this check here, we'd see the following
876 	 * scenario:
877 	 * - install a rejected route for a scoped address prefix
878 	 *   (like fe80::/10)
879 	 * - send a packet to a destination that matches the scoped prefix,
880 	 *   with ambiguity about the scope zone.
881 	 * - pick the outgoing interface from the route, and disambiguate the
882 	 *   scope zone with the interface.
883 	 * - ip6_output() would try to get another route with the "new"
884 	 *   destination, which may be valid.
885 	 * - we'd see no error on output.
886 	 * Although this may not be very harmful, it should still be confusing.
887 	 * We thus reject the case here.
888 	 */
889 
890 	if (rt_flags & (RTF_REJECT | RTF_BLACKHOLE)) {
891 		error = (rt_flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH);
892 		return (error);
893 	}
894 
895 	return (0);
896 }
897 
898 /*
899  * Public wrapper function to selectroute().
900  *
901  * XXX-BZ in6_selectroute() should and will grow the FIB argument. The
902  * in6_selectroute_fib() function is only there for backward compat on stable.
903  */
904 int
905 in6_selectroute(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts,
906     struct ip6_moptions *mopts, struct route_in6 *ro,
907     struct ifnet **retifp, struct rtentry **retrt)
908 {
909 
910 	return (selectroute(dstsock, opts, mopts, ro, retifp,
911 	    retrt, 0, RT_DEFAULT_FIB));
912 }
913 
914 #ifndef BURN_BRIDGES
915 int
916 in6_selectroute_fib(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts,
917     struct ip6_moptions *mopts, struct route_in6 *ro,
918     struct ifnet **retifp, struct rtentry **retrt, u_int fibnum)
919 {
920 
921 	return (selectroute(dstsock, opts, mopts, ro, retifp,
922 	    retrt, 0, fibnum));
923 }
924 #endif
925 
926 /*
927  * Default hop limit selection. The precedence is as follows:
928  * 1. Hoplimit value specified via ioctl.
929  * 2. (If the outgoing interface is detected) the current
930  *     hop limit of the interface specified by router advertisement.
931  * 3. The system default hoplimit.
932  */
933 int
934 in6_selecthlim(struct inpcb *inp, struct ifnet *ifp)
935 {
936 
937 	if (inp && inp->in6p_hops >= 0)
938 		return (inp->in6p_hops);
939 	else if (ifp)
940 		return (ND_IFINFO(ifp)->chlim);
941 	else if (inp && !IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr)) {
942 		struct nhop6_basic nh6;
943 		struct in6_addr dst;
944 		uint32_t fibnum, scopeid;
945 		int hlim;
946 
947 		fibnum = inp->inp_inc.inc_fibnum;
948 		in6_splitscope(&inp->in6p_faddr, &dst, &scopeid);
949 		if (fib6_lookup_nh_basic(fibnum, &dst, scopeid, 0, 0, &nh6)==0){
950 			hlim = ND_IFINFO(nh6.nh_ifp)->chlim;
951 			return (hlim);
952 		}
953 	}
954 	return (V_ip6_defhlim);
955 }
956 
957 /*
958  * XXX: this is borrowed from in6_pcbbind(). If possible, we should
959  * share this function by all *bsd*...
960  */
961 int
962 in6_pcbsetport(struct in6_addr *laddr, struct inpcb *inp, struct ucred *cred)
963 {
964 	struct socket *so = inp->inp_socket;
965 	u_int16_t lport = 0;
966 	int error, lookupflags = 0;
967 #ifdef INVARIANTS
968 	struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
969 #endif
970 
971 	INP_WLOCK_ASSERT(inp);
972 	INP_HASH_WLOCK_ASSERT(pcbinfo);
973 
974 	error = prison_local_ip6(cred, laddr,
975 	    ((inp->inp_flags & IN6P_IPV6_V6ONLY) != 0));
976 	if (error)
977 		return(error);
978 
979 	/* XXX: this is redundant when called from in6_pcbbind */
980 	if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT|SO_REUSEPORT_LB)) == 0)
981 		lookupflags = INPLOOKUP_WILDCARD;
982 
983 	inp->inp_flags |= INP_ANONPORT;
984 
985 	error = in_pcb_lport(inp, NULL, &lport, cred, lookupflags);
986 	if (error != 0)
987 		return (error);
988 
989 	inp->inp_lport = lport;
990 	if (in_pcbinshash(inp) != 0) {
991 		inp->in6p_laddr = in6addr_any;
992 		inp->inp_lport = 0;
993 		return (EAGAIN);
994 	}
995 
996 	return (0);
997 }
998 
999 void
1000 addrsel_policy_init(void)
1001 {
1002 
1003 	init_policy_queue();
1004 
1005 	/* initialize the "last resort" policy */
1006 	bzero(&V_defaultaddrpolicy, sizeof(V_defaultaddrpolicy));
1007 	V_defaultaddrpolicy.label = ADDR_LABEL_NOTAPP;
1008 
1009 	if (!IS_DEFAULT_VNET(curvnet))
1010 		return;
1011 
1012 	ADDRSEL_LOCK_INIT();
1013 	ADDRSEL_SXLOCK_INIT();
1014 }
1015 
1016 static struct in6_addrpolicy *
1017 lookup_addrsel_policy(struct sockaddr_in6 *key)
1018 {
1019 	struct in6_addrpolicy *match = NULL;
1020 
1021 	ADDRSEL_LOCK();
1022 	match = match_addrsel_policy(key);
1023 
1024 	if (match == NULL)
1025 		match = &V_defaultaddrpolicy;
1026 	else
1027 		match->use++;
1028 	ADDRSEL_UNLOCK();
1029 
1030 	return (match);
1031 }
1032 
1033 /*
1034  * Subroutines to manage the address selection policy table via sysctl.
1035  */
1036 struct walkarg {
1037 	struct sysctl_req *w_req;
1038 };
1039 
1040 static int in6_src_sysctl(SYSCTL_HANDLER_ARGS);
1041 SYSCTL_DECL(_net_inet6_ip6);
1042 static SYSCTL_NODE(_net_inet6_ip6, IPV6CTL_ADDRCTLPOLICY, addrctlpolicy,
1043 	CTLFLAG_RD, in6_src_sysctl, "");
1044 
1045 static int
1046 in6_src_sysctl(SYSCTL_HANDLER_ARGS)
1047 {
1048 	struct walkarg w;
1049 
1050 	if (req->newptr)
1051 		return EPERM;
1052 
1053 	bzero(&w, sizeof(w));
1054 	w.w_req = req;
1055 
1056 	return (walk_addrsel_policy(dump_addrsel_policyent, &w));
1057 }
1058 
1059 int
1060 in6_src_ioctl(u_long cmd, caddr_t data)
1061 {
1062 	struct in6_addrpolicy ent0;
1063 
1064 	if (cmd != SIOCAADDRCTL_POLICY && cmd != SIOCDADDRCTL_POLICY)
1065 		return (EOPNOTSUPP); /* check for safety */
1066 
1067 	ent0 = *(struct in6_addrpolicy *)data;
1068 
1069 	if (ent0.label == ADDR_LABEL_NOTAPP)
1070 		return (EINVAL);
1071 	/* check if the prefix mask is consecutive. */
1072 	if (in6_mask2len(&ent0.addrmask.sin6_addr, NULL) < 0)
1073 		return (EINVAL);
1074 	/* clear trailing garbages (if any) of the prefix address. */
1075 	IN6_MASK_ADDR(&ent0.addr.sin6_addr, &ent0.addrmask.sin6_addr);
1076 	ent0.use = 0;
1077 
1078 	switch (cmd) {
1079 	case SIOCAADDRCTL_POLICY:
1080 		return (add_addrsel_policyent(&ent0));
1081 	case SIOCDADDRCTL_POLICY:
1082 		return (delete_addrsel_policyent(&ent0));
1083 	}
1084 
1085 	return (0);		/* XXX: compromise compilers */
1086 }
1087 
1088 /*
1089  * The followings are implementation of the policy table using a
1090  * simple tail queue.
1091  * XXX such details should be hidden.
1092  * XXX implementation using binary tree should be more efficient.
1093  */
1094 struct addrsel_policyent {
1095 	TAILQ_ENTRY(addrsel_policyent) ape_entry;
1096 	struct in6_addrpolicy ape_policy;
1097 };
1098 
1099 TAILQ_HEAD(addrsel_policyhead, addrsel_policyent);
1100 
1101 VNET_DEFINE_STATIC(struct addrsel_policyhead, addrsel_policytab);
1102 #define	V_addrsel_policytab		VNET(addrsel_policytab)
1103 
1104 static void
1105 init_policy_queue(void)
1106 {
1107 
1108 	TAILQ_INIT(&V_addrsel_policytab);
1109 }
1110 
1111 static int
1112 add_addrsel_policyent(struct in6_addrpolicy *newpolicy)
1113 {
1114 	struct addrsel_policyent *new, *pol;
1115 
1116 	new = malloc(sizeof(*new), M_IFADDR,
1117 	       M_WAITOK);
1118 	ADDRSEL_XLOCK();
1119 	ADDRSEL_LOCK();
1120 
1121 	/* duplication check */
1122 	TAILQ_FOREACH(pol, &V_addrsel_policytab, ape_entry) {
1123 		if (IN6_ARE_ADDR_EQUAL(&newpolicy->addr.sin6_addr,
1124 				       &pol->ape_policy.addr.sin6_addr) &&
1125 		    IN6_ARE_ADDR_EQUAL(&newpolicy->addrmask.sin6_addr,
1126 				       &pol->ape_policy.addrmask.sin6_addr)) {
1127 			ADDRSEL_UNLOCK();
1128 			ADDRSEL_XUNLOCK();
1129 			free(new, M_IFADDR);
1130 			return (EEXIST);	/* or override it? */
1131 		}
1132 	}
1133 
1134 	bzero(new, sizeof(*new));
1135 
1136 	/* XXX: should validate entry */
1137 	new->ape_policy = *newpolicy;
1138 
1139 	TAILQ_INSERT_TAIL(&V_addrsel_policytab, new, ape_entry);
1140 	ADDRSEL_UNLOCK();
1141 	ADDRSEL_XUNLOCK();
1142 
1143 	return (0);
1144 }
1145 
1146 static int
1147 delete_addrsel_policyent(struct in6_addrpolicy *key)
1148 {
1149 	struct addrsel_policyent *pol;
1150 
1151 	ADDRSEL_XLOCK();
1152 	ADDRSEL_LOCK();
1153 
1154 	/* search for the entry in the table */
1155 	TAILQ_FOREACH(pol, &V_addrsel_policytab, ape_entry) {
1156 		if (IN6_ARE_ADDR_EQUAL(&key->addr.sin6_addr,
1157 		    &pol->ape_policy.addr.sin6_addr) &&
1158 		    IN6_ARE_ADDR_EQUAL(&key->addrmask.sin6_addr,
1159 		    &pol->ape_policy.addrmask.sin6_addr)) {
1160 			break;
1161 		}
1162 	}
1163 	if (pol == NULL) {
1164 		ADDRSEL_UNLOCK();
1165 		ADDRSEL_XUNLOCK();
1166 		return (ESRCH);
1167 	}
1168 
1169 	TAILQ_REMOVE(&V_addrsel_policytab, pol, ape_entry);
1170 	ADDRSEL_UNLOCK();
1171 	ADDRSEL_XUNLOCK();
1172 	free(pol, M_IFADDR);
1173 
1174 	return (0);
1175 }
1176 
1177 static int
1178 walk_addrsel_policy(int (*callback)(struct in6_addrpolicy *, void *), void *w)
1179 {
1180 	struct addrsel_policyent *pol;
1181 	int error = 0;
1182 
1183 	ADDRSEL_SLOCK();
1184 	TAILQ_FOREACH(pol, &V_addrsel_policytab, ape_entry) {
1185 		if ((error = (*callback)(&pol->ape_policy, w)) != 0) {
1186 			ADDRSEL_SUNLOCK();
1187 			return (error);
1188 		}
1189 	}
1190 	ADDRSEL_SUNLOCK();
1191 	return (error);
1192 }
1193 
1194 static int
1195 dump_addrsel_policyent(struct in6_addrpolicy *pol, void *arg)
1196 {
1197 	int error = 0;
1198 	struct walkarg *w = arg;
1199 
1200 	error = SYSCTL_OUT(w->w_req, pol, sizeof(*pol));
1201 
1202 	return (error);
1203 }
1204 
1205 static struct in6_addrpolicy *
1206 match_addrsel_policy(struct sockaddr_in6 *key)
1207 {
1208 	struct addrsel_policyent *pent;
1209 	struct in6_addrpolicy *bestpol = NULL, *pol;
1210 	int matchlen, bestmatchlen = -1;
1211 	u_char *mp, *ep, *k, *p, m;
1212 
1213 	TAILQ_FOREACH(pent, &V_addrsel_policytab, ape_entry) {
1214 		matchlen = 0;
1215 
1216 		pol = &pent->ape_policy;
1217 		mp = (u_char *)&pol->addrmask.sin6_addr;
1218 		ep = mp + 16;	/* XXX: scope field? */
1219 		k = (u_char *)&key->sin6_addr;
1220 		p = (u_char *)&pol->addr.sin6_addr;
1221 		for (; mp < ep && *mp; mp++, k++, p++) {
1222 			m = *mp;
1223 			if ((*k & m) != *p)
1224 				goto next; /* not match */
1225 			if (m == 0xff) /* short cut for a typical case */
1226 				matchlen += 8;
1227 			else {
1228 				while (m >= 0x80) {
1229 					matchlen++;
1230 					m <<= 1;
1231 				}
1232 			}
1233 		}
1234 
1235 		/* matched.  check if this is better than the current best. */
1236 		if (bestpol == NULL ||
1237 		    matchlen > bestmatchlen) {
1238 			bestpol = pol;
1239 			bestmatchlen = matchlen;
1240 		}
1241 
1242 	  next:
1243 		continue;
1244 	}
1245 
1246 	return (bestpol);
1247 }
1248