xref: /freebsd/sys/netinet6/in6_src.c (revision a55b8b206826407ced58569d0142c479273be3dc)
1caf43b02SWarner Losh /*-
2686cdd19SJun-ichiro itojun Hagino  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
3686cdd19SJun-ichiro itojun Hagino  * All rights reserved.
4686cdd19SJun-ichiro itojun Hagino  *
5686cdd19SJun-ichiro itojun Hagino  * Redistribution and use in source and binary forms, with or without
6686cdd19SJun-ichiro itojun Hagino  * modification, are permitted provided that the following conditions
7686cdd19SJun-ichiro itojun Hagino  * are met:
8686cdd19SJun-ichiro itojun Hagino  * 1. Redistributions of source code must retain the above copyright
9686cdd19SJun-ichiro itojun Hagino  *    notice, this list of conditions and the following disclaimer.
10686cdd19SJun-ichiro itojun Hagino  * 2. Redistributions in binary form must reproduce the above copyright
11686cdd19SJun-ichiro itojun Hagino  *    notice, this list of conditions and the following disclaimer in the
12686cdd19SJun-ichiro itojun Hagino  *    documentation and/or other materials provided with the distribution.
13686cdd19SJun-ichiro itojun Hagino  * 3. Neither the name of the project nor the names of its contributors
14686cdd19SJun-ichiro itojun Hagino  *    may be used to endorse or promote products derived from this software
15686cdd19SJun-ichiro itojun Hagino  *    without specific prior written permission.
16686cdd19SJun-ichiro itojun Hagino  *
17686cdd19SJun-ichiro itojun Hagino  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
18686cdd19SJun-ichiro itojun Hagino  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19686cdd19SJun-ichiro itojun Hagino  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20686cdd19SJun-ichiro itojun Hagino  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
21686cdd19SJun-ichiro itojun Hagino  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22686cdd19SJun-ichiro itojun Hagino  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23686cdd19SJun-ichiro itojun Hagino  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24686cdd19SJun-ichiro itojun Hagino  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25686cdd19SJun-ichiro itojun Hagino  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26686cdd19SJun-ichiro itojun Hagino  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27686cdd19SJun-ichiro itojun Hagino  * SUCH DAMAGE.
28b48287a3SDavid E. O'Brien  *
29b48287a3SDavid E. O'Brien  *	$KAME: in6_src.c,v 1.132 2003/08/26 04:42:27 keiichi Exp $
30686cdd19SJun-ichiro itojun Hagino  */
31686cdd19SJun-ichiro itojun Hagino 
32caf43b02SWarner Losh /*-
33686cdd19SJun-ichiro itojun Hagino  * Copyright (c) 1982, 1986, 1991, 1993
34686cdd19SJun-ichiro itojun Hagino  *	The Regents of the University of California.  All rights reserved.
35686cdd19SJun-ichiro itojun Hagino  *
36686cdd19SJun-ichiro itojun Hagino  * Redistribution and use in source and binary forms, with or without
37686cdd19SJun-ichiro itojun Hagino  * modification, are permitted provided that the following conditions
38686cdd19SJun-ichiro itojun Hagino  * are met:
39686cdd19SJun-ichiro itojun Hagino  * 1. Redistributions of source code must retain the above copyright
40686cdd19SJun-ichiro itojun Hagino  *    notice, this list of conditions and the following disclaimer.
41686cdd19SJun-ichiro itojun Hagino  * 2. Redistributions in binary form must reproduce the above copyright
42686cdd19SJun-ichiro itojun Hagino  *    notice, this list of conditions and the following disclaimer in the
43686cdd19SJun-ichiro itojun Hagino  *    documentation and/or other materials provided with the distribution.
44686cdd19SJun-ichiro itojun Hagino  * 4. Neither the name of the University nor the names of its contributors
45686cdd19SJun-ichiro itojun Hagino  *    may be used to endorse or promote products derived from this software
46686cdd19SJun-ichiro itojun Hagino  *    without specific prior written permission.
47686cdd19SJun-ichiro itojun Hagino  *
48686cdd19SJun-ichiro itojun Hagino  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49686cdd19SJun-ichiro itojun Hagino  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50686cdd19SJun-ichiro itojun Hagino  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51686cdd19SJun-ichiro itojun Hagino  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52686cdd19SJun-ichiro itojun Hagino  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53686cdd19SJun-ichiro itojun Hagino  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54686cdd19SJun-ichiro itojun Hagino  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55686cdd19SJun-ichiro itojun Hagino  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56686cdd19SJun-ichiro itojun Hagino  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57686cdd19SJun-ichiro itojun Hagino  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58686cdd19SJun-ichiro itojun Hagino  * SUCH DAMAGE.
59686cdd19SJun-ichiro itojun Hagino  *
60686cdd19SJun-ichiro itojun Hagino  *	@(#)in_pcb.c	8.2 (Berkeley) 1/4/94
61686cdd19SJun-ichiro itojun Hagino  */
62686cdd19SJun-ichiro itojun Hagino 
63b48287a3SDavid E. O'Brien #include <sys/cdefs.h>
64b48287a3SDavid E. O'Brien __FBSDID("$FreeBSD$");
65b48287a3SDavid E. O'Brien 
66686cdd19SJun-ichiro itojun Hagino #include "opt_inet.h"
67686cdd19SJun-ichiro itojun Hagino #include "opt_inet6.h"
68e440aed9SQing Li #include "opt_mpath.h"
69686cdd19SJun-ichiro itojun Hagino 
70686cdd19SJun-ichiro itojun Hagino #include <sys/param.h>
71686cdd19SJun-ichiro itojun Hagino #include <sys/systm.h>
724e7f640dSJohn Baldwin #include <sys/lock.h>
7333841545SHajimu UMEMOTO #include <sys/malloc.h>
74686cdd19SJun-ichiro itojun Hagino #include <sys/mbuf.h>
75acd3428bSRobert Watson #include <sys/priv.h>
76686cdd19SJun-ichiro itojun Hagino #include <sys/protosw.h>
77686cdd19SJun-ichiro itojun Hagino #include <sys/socket.h>
78686cdd19SJun-ichiro itojun Hagino #include <sys/socketvar.h>
797fc91b3fSHajimu UMEMOTO #include <sys/sockio.h>
807fc91b3fSHajimu UMEMOTO #include <sys/sysctl.h>
81686cdd19SJun-ichiro itojun Hagino #include <sys/errno.h>
82686cdd19SJun-ichiro itojun Hagino #include <sys/time.h>
834a201dfcSHajimu UMEMOTO #include <sys/kernel.h>
845d525653SHajimu UMEMOTO #include <sys/sx.h>
85686cdd19SJun-ichiro itojun Hagino 
86686cdd19SJun-ichiro itojun Hagino #include <net/if.h>
87686cdd19SJun-ichiro itojun Hagino #include <net/route.h>
88e440aed9SQing Li #ifdef RADIX_MPATH
89e440aed9SQing Li #include <net/radix_mpath.h>
90e440aed9SQing Li #endif
91686cdd19SJun-ichiro itojun Hagino 
92686cdd19SJun-ichiro itojun Hagino #include <netinet/in.h>
93686cdd19SJun-ichiro itojun Hagino #include <netinet/in_var.h>
94686cdd19SJun-ichiro itojun Hagino #include <netinet/in_systm.h>
95686cdd19SJun-ichiro itojun Hagino #include <netinet/ip.h>
96686cdd19SJun-ichiro itojun Hagino #include <netinet/in_pcb.h>
97686cdd19SJun-ichiro itojun Hagino #include <netinet6/in6_var.h>
98686cdd19SJun-ichiro itojun Hagino #include <netinet/ip6.h>
99686cdd19SJun-ichiro itojun Hagino #include <netinet6/in6_pcb.h>
100686cdd19SJun-ichiro itojun Hagino #include <netinet6/ip6_var.h>
101a1f7e5f8SHajimu UMEMOTO #include <netinet6/scope6_var.h>
102686cdd19SJun-ichiro itojun Hagino #include <netinet6/nd6.h>
103686cdd19SJun-ichiro itojun Hagino 
1047fc91b3fSHajimu UMEMOTO static struct mtx addrsel_lock;
1057fc91b3fSHajimu UMEMOTO #define	ADDRSEL_LOCK_INIT()	mtx_init(&addrsel_lock, "addrsel_lock", NULL, MTX_DEF)
1067fc91b3fSHajimu UMEMOTO #define	ADDRSEL_LOCK()		mtx_lock(&addrsel_lock)
1077fc91b3fSHajimu UMEMOTO #define	ADDRSEL_UNLOCK()	mtx_unlock(&addrsel_lock)
1087fc91b3fSHajimu UMEMOTO #define	ADDRSEL_LOCK_ASSERT()	mtx_assert(&addrsel_lock, MA_OWNED)
1097fc91b3fSHajimu UMEMOTO 
1105d525653SHajimu UMEMOTO static struct sx addrsel_sxlock;
1115d525653SHajimu UMEMOTO #define	ADDRSEL_SXLOCK_INIT()	sx_init(&addrsel_sxlock, "addrsel_sxlock")
1125d525653SHajimu UMEMOTO #define	ADDRSEL_SLOCK()		sx_slock(&addrsel_sxlock)
1135d525653SHajimu UMEMOTO #define	ADDRSEL_SUNLOCK()	sx_sunlock(&addrsel_sxlock)
1145d525653SHajimu UMEMOTO #define	ADDRSEL_XLOCK()		sx_xlock(&addrsel_sxlock)
1155d525653SHajimu UMEMOTO #define	ADDRSEL_XUNLOCK()	sx_xunlock(&addrsel_sxlock)
1165d525653SHajimu UMEMOTO 
1177fc91b3fSHajimu UMEMOTO #define ADDR_LABEL_NOTAPP (-1)
1187fc91b3fSHajimu UMEMOTO struct in6_addrpolicy defaultaddrpolicy;
1197fc91b3fSHajimu UMEMOTO 
120d6385b1cSHajimu UMEMOTO int ip6_prefer_tempaddr = 0;
121d6385b1cSHajimu UMEMOTO 
122a1f7e5f8SHajimu UMEMOTO static int selectroute __P((struct sockaddr_in6 *, struct ip6_pktopts *,
123a1f7e5f8SHajimu UMEMOTO 	struct ip6_moptions *, struct route_in6 *, struct ifnet **,
124a1f7e5f8SHajimu UMEMOTO 	struct rtentry **, int, int));
125d6385b1cSHajimu UMEMOTO static int in6_selectif __P((struct sockaddr_in6 *, struct ip6_pktopts *,
12668efda09SHajimu UMEMOTO 	struct ip6_moptions *, struct route_in6 *ro, struct ifnet **));
127d6385b1cSHajimu UMEMOTO 
1289233d8f3SDavid E. O'Brien static struct in6_addrpolicy *lookup_addrsel_policy(struct sockaddr_in6 *);
129d6385b1cSHajimu UMEMOTO 
1309233d8f3SDavid E. O'Brien static void init_policy_queue(void);
1319233d8f3SDavid E. O'Brien static int add_addrsel_policyent(struct in6_addrpolicy *);
1329233d8f3SDavid E. O'Brien static int delete_addrsel_policyent(struct in6_addrpolicy *);
1337fc91b3fSHajimu UMEMOTO static int walk_addrsel_policy __P((int (*)(struct in6_addrpolicy *, void *),
1347fc91b3fSHajimu UMEMOTO 				    void *));
1359233d8f3SDavid E. O'Brien static int dump_addrsel_policyent(struct in6_addrpolicy *, void *);
1369233d8f3SDavid E. O'Brien static struct in6_addrpolicy *match_addrsel_policy(struct sockaddr_in6 *);
1377fc91b3fSHajimu UMEMOTO 
138686cdd19SJun-ichiro itojun Hagino /*
13933841545SHajimu UMEMOTO  * Return an IPv6 address, which is the most appropriate for a given
140686cdd19SJun-ichiro itojun Hagino  * destination and user specified options.
14133841545SHajimu UMEMOTO  * If necessary, this function lookups the routing table and returns
142686cdd19SJun-ichiro itojun Hagino  * an entry to the caller for later use.
143686cdd19SJun-ichiro itojun Hagino  */
144d6385b1cSHajimu UMEMOTO #define REPLACE(r) do {\
145d6385b1cSHajimu UMEMOTO 	if ((r) < sizeof(ip6stat.ip6s_sources_rule) / \
146d6385b1cSHajimu UMEMOTO 		sizeof(ip6stat.ip6s_sources_rule[0])) /* check for safety */ \
147d6385b1cSHajimu UMEMOTO 		ip6stat.ip6s_sources_rule[(r)]++; \
148ab569b9cSBjoern A. Zeeb 	/* { \
149ab569b9cSBjoern A. Zeeb 	char ip6buf[INET6_ADDRSTRLEN], ip6b[INET6_ADDRSTRLEN]; \
150ab569b9cSBjoern A. Zeeb 	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)); \
151ab569b9cSBjoern A. Zeeb 	} */ \
152d6385b1cSHajimu UMEMOTO 	goto replace; \
153d6385b1cSHajimu UMEMOTO } while(0)
154d6385b1cSHajimu UMEMOTO #define NEXT(r) do {\
155d6385b1cSHajimu UMEMOTO 	if ((r) < sizeof(ip6stat.ip6s_sources_rule) / \
156d6385b1cSHajimu UMEMOTO 		sizeof(ip6stat.ip6s_sources_rule[0])) /* check for safety */ \
157d6385b1cSHajimu UMEMOTO 		ip6stat.ip6s_sources_rule[(r)]++; \
158ab569b9cSBjoern A. Zeeb 	/* { \
159ab569b9cSBjoern A. Zeeb 	char ip6buf[INET6_ADDRSTRLEN], ip6b[INET6_ADDRSTRLEN]; \
160ab569b9cSBjoern A. Zeeb 	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)); \
161ab569b9cSBjoern A. Zeeb 	} */ \
162d6385b1cSHajimu UMEMOTO 	goto next;		/* XXX: we can't use 'continue' here */ \
163d6385b1cSHajimu UMEMOTO } while(0)
164d6385b1cSHajimu UMEMOTO #define BREAK(r) do { \
165d6385b1cSHajimu UMEMOTO 	if ((r) < sizeof(ip6stat.ip6s_sources_rule) / \
166d6385b1cSHajimu UMEMOTO 		sizeof(ip6stat.ip6s_sources_rule[0])) /* check for safety */ \
167d6385b1cSHajimu UMEMOTO 		ip6stat.ip6s_sources_rule[(r)]++; \
168d6385b1cSHajimu UMEMOTO 	goto out;		/* XXX: we can't use 'break' here */ \
169d6385b1cSHajimu UMEMOTO } while(0)
170d6385b1cSHajimu UMEMOTO 
171686cdd19SJun-ichiro itojun Hagino struct in6_addr *
1721272577eSXin LI in6_selectsrc(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts,
173f2f877d3SBjoern A. Zeeb     struct inpcb *inp, struct route_in6 *ro, struct ucred *cred,
174f2f877d3SBjoern A. Zeeb     struct ifnet **ifpp, int *errorp)
175686cdd19SJun-ichiro itojun Hagino {
176a1f7e5f8SHajimu UMEMOTO 	struct in6_addr dst;
177d6385b1cSHajimu UMEMOTO 	struct ifnet *ifp = NULL;
178d6385b1cSHajimu UMEMOTO 	struct in6_ifaddr *ia = NULL, *ia_best = NULL;
179686cdd19SJun-ichiro itojun Hagino 	struct in6_pktinfo *pi = NULL;
180d6385b1cSHajimu UMEMOTO 	int dst_scope = -1, best_scope = -1, best_matchlen = -1;
181d6385b1cSHajimu UMEMOTO 	struct in6_addrpolicy *dst_policy = NULL, *best_policy = NULL;
182d6385b1cSHajimu UMEMOTO 	u_int32_t odstzone;
183d6385b1cSHajimu UMEMOTO 	int prefer_tempaddr;
184f2f877d3SBjoern A. Zeeb 	struct ip6_moptions *mopts;
185e6a27350SHajimu UMEMOTO 
186a1f7e5f8SHajimu UMEMOTO 	dst = dstsock->sin6_addr; /* make a copy for local operation */
187686cdd19SJun-ichiro itojun Hagino 	*errorp = 0;
188a1f7e5f8SHajimu UMEMOTO 	if (ifpp)
189a1f7e5f8SHajimu UMEMOTO 		*ifpp = NULL;
190686cdd19SJun-ichiro itojun Hagino 
191a55b8b20SBjoern A. Zeeb 	if (inp != NULL) {
192a55b8b20SBjoern A. Zeeb 		INP_LOCK_ASSERT(inp);
193f2f877d3SBjoern A. Zeeb 		mopts = inp->in6p_moptions;
194a55b8b20SBjoern A. Zeeb 	} else {
195f2f877d3SBjoern A. Zeeb 		mopts = NULL;
196a55b8b20SBjoern A. Zeeb 	}
197f2f877d3SBjoern A. Zeeb 
198686cdd19SJun-ichiro itojun Hagino 	/*
199686cdd19SJun-ichiro itojun Hagino 	 * If the source address is explicitly specified by the caller,
200d6385b1cSHajimu UMEMOTO 	 * check if the requested source address is indeed a unicast address
201d6385b1cSHajimu UMEMOTO 	 * assigned to the node, and can be used as the packet's source
202d6385b1cSHajimu UMEMOTO 	 * address.  If everything is okay, use the address as source.
203686cdd19SJun-ichiro itojun Hagino 	 */
204686cdd19SJun-ichiro itojun Hagino 	if (opts && (pi = opts->ip6po_pktinfo) &&
205d6385b1cSHajimu UMEMOTO 	    !IN6_IS_ADDR_UNSPECIFIED(&pi->ipi6_addr)) {
206d6385b1cSHajimu UMEMOTO 		struct sockaddr_in6 srcsock;
207d6385b1cSHajimu UMEMOTO 		struct in6_ifaddr *ia6;
208d6385b1cSHajimu UMEMOTO 
209d6385b1cSHajimu UMEMOTO 		/* get the outgoing interface */
210d6385b1cSHajimu UMEMOTO 		if ((*errorp = in6_selectif(dstsock, opts, mopts, ro, &ifp))
211d6385b1cSHajimu UMEMOTO 		    != 0) {
212d6385b1cSHajimu UMEMOTO 			return (NULL);
213d6385b1cSHajimu UMEMOTO 		}
21468efda09SHajimu UMEMOTO 
215686cdd19SJun-ichiro itojun Hagino 		/*
216d6385b1cSHajimu UMEMOTO 		 * determine the appropriate zone id of the source based on
217d6385b1cSHajimu UMEMOTO 		 * the zone of the destination and the outgoing interface.
218a1f7e5f8SHajimu UMEMOTO 		 * If the specified address is ambiguous wrt the scope zone,
219a1f7e5f8SHajimu UMEMOTO 		 * the interface must be specified; otherwise, ifa_ifwithaddr()
220a1f7e5f8SHajimu UMEMOTO 		 * will fail matching the address.
221d6385b1cSHajimu UMEMOTO 		 */
222d6385b1cSHajimu UMEMOTO 		bzero(&srcsock, sizeof(srcsock));
223d6385b1cSHajimu UMEMOTO 		srcsock.sin6_family = AF_INET6;
224d6385b1cSHajimu UMEMOTO 		srcsock.sin6_len = sizeof(srcsock);
225d6385b1cSHajimu UMEMOTO 		srcsock.sin6_addr = pi->ipi6_addr;
226d6385b1cSHajimu UMEMOTO 		if (ifp) {
227a1f7e5f8SHajimu UMEMOTO 			*errorp = in6_setscope(&srcsock.sin6_addr, ifp, NULL);
228a1f7e5f8SHajimu UMEMOTO 			if (*errorp != 0)
229d6385b1cSHajimu UMEMOTO 				return (NULL);
230d6385b1cSHajimu UMEMOTO 		}
231a1f7e5f8SHajimu UMEMOTO 
232d6385b1cSHajimu UMEMOTO 		ia6 = (struct in6_ifaddr *)ifa_ifwithaddr((struct sockaddr *)(&srcsock));
233d6385b1cSHajimu UMEMOTO 		if (ia6 == NULL ||
234d6385b1cSHajimu UMEMOTO 		    (ia6->ia6_flags & (IN6_IFF_ANYCAST | IN6_IFF_NOTREADY))) {
235d6385b1cSHajimu UMEMOTO 			*errorp = EADDRNOTAVAIL;
236d6385b1cSHajimu UMEMOTO 			return (NULL);
237d6385b1cSHajimu UMEMOTO 		}
238d6385b1cSHajimu UMEMOTO 		pi->ipi6_addr = srcsock.sin6_addr; /* XXX: this overrides pi */
239a1f7e5f8SHajimu UMEMOTO 		if (ifpp)
240a1f7e5f8SHajimu UMEMOTO 			*ifpp = ifp;
241d6385b1cSHajimu UMEMOTO 		return (&ia6->ia_addr.sin6_addr);
242d6385b1cSHajimu UMEMOTO 	}
243d6385b1cSHajimu UMEMOTO 
244d6385b1cSHajimu UMEMOTO 	/*
245d6385b1cSHajimu UMEMOTO 	 * Otherwise, if the socket has already bound the source, just use it.
246686cdd19SJun-ichiro itojun Hagino 	 */
247f2f877d3SBjoern A. Zeeb 	if (inp != NULL && !IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)) {
248f2f877d3SBjoern A. Zeeb 		return (&inp->in6p_laddr);
249f2f877d3SBjoern A. Zeeb 	}
250686cdd19SJun-ichiro itojun Hagino 
251686cdd19SJun-ichiro itojun Hagino 	/*
252d6385b1cSHajimu UMEMOTO 	 * If the address is not specified, choose the best one based on
253d6385b1cSHajimu UMEMOTO 	 * the outgoing interface and the destination address.
254686cdd19SJun-ichiro itojun Hagino 	 */
255d6385b1cSHajimu UMEMOTO 	/* get the outgoing interface */
256d6385b1cSHajimu UMEMOTO 	if ((*errorp = in6_selectif(dstsock, opts, mopts, ro, &ifp)) != 0)
257d6385b1cSHajimu UMEMOTO 		return (NULL);
258686cdd19SJun-ichiro itojun Hagino 
259d6385b1cSHajimu UMEMOTO #ifdef DIAGNOSTIC
260d6385b1cSHajimu UMEMOTO 	if (ifp == NULL)	/* this should not happen */
261d6385b1cSHajimu UMEMOTO 		panic("in6_selectsrc: NULL ifp");
262d6385b1cSHajimu UMEMOTO #endif
263a1f7e5f8SHajimu UMEMOTO 	*errorp = in6_setscope(&dst, ifp, &odstzone);
264a1f7e5f8SHajimu UMEMOTO 	if (*errorp != 0)
265d6385b1cSHajimu UMEMOTO 		return (NULL);
266a1f7e5f8SHajimu UMEMOTO 
267d6385b1cSHajimu UMEMOTO 	for (ia = in6_ifaddr; ia; ia = ia->ia_next) {
268d6385b1cSHajimu UMEMOTO 		int new_scope = -1, new_matchlen = -1;
269d6385b1cSHajimu UMEMOTO 		struct in6_addrpolicy *new_policy = NULL;
270d6385b1cSHajimu UMEMOTO 		u_int32_t srczone, osrczone, dstzone;
271a1f7e5f8SHajimu UMEMOTO 		struct in6_addr src;
272d6385b1cSHajimu UMEMOTO 		struct ifnet *ifp1 = ia->ia_ifp;
273d6385b1cSHajimu UMEMOTO 
274d6385b1cSHajimu UMEMOTO 		/*
275d6385b1cSHajimu UMEMOTO 		 * We'll never take an address that breaks the scope zone
276d6385b1cSHajimu UMEMOTO 		 * of the destination.  We also skip an address if its zone
277d6385b1cSHajimu UMEMOTO 		 * does not contain the outgoing interface.
278d6385b1cSHajimu UMEMOTO 		 * XXX: we should probably use sin6_scope_id here.
279d6385b1cSHajimu UMEMOTO 		 */
280a1f7e5f8SHajimu UMEMOTO 		if (in6_setscope(&dst, ifp1, &dstzone) ||
281d6385b1cSHajimu UMEMOTO 		    odstzone != dstzone) {
282d6385b1cSHajimu UMEMOTO 			continue;
283d6385b1cSHajimu UMEMOTO 		}
284a1f7e5f8SHajimu UMEMOTO 		src = ia->ia_addr.sin6_addr;
285a1f7e5f8SHajimu UMEMOTO 		if (in6_setscope(&src, ifp, &osrczone) ||
286a1f7e5f8SHajimu UMEMOTO 		    in6_setscope(&src, ifp1, &srczone) ||
287d6385b1cSHajimu UMEMOTO 		    osrczone != srczone) {
288d6385b1cSHajimu UMEMOTO 			continue;
289686cdd19SJun-ichiro itojun Hagino 		}
290686cdd19SJun-ichiro itojun Hagino 
291d6385b1cSHajimu UMEMOTO 		/* avoid unusable addresses */
292d6385b1cSHajimu UMEMOTO 		if ((ia->ia6_flags &
293d6385b1cSHajimu UMEMOTO 		     (IN6_IFF_NOTREADY | IN6_IFF_ANYCAST | IN6_IFF_DETACHED))) {
294d6385b1cSHajimu UMEMOTO 				continue;
295d6385b1cSHajimu UMEMOTO 		}
296d6385b1cSHajimu UMEMOTO 		if (!ip6_use_deprecated && IFA6_IS_DEPRECATED(ia))
297d6385b1cSHajimu UMEMOTO 			continue;
298d6385b1cSHajimu UMEMOTO 
299d6385b1cSHajimu UMEMOTO 		/* Rule 1: Prefer same address */
300a1f7e5f8SHajimu UMEMOTO 		if (IN6_ARE_ADDR_EQUAL(&dst, &ia->ia_addr.sin6_addr)) {
301d6385b1cSHajimu UMEMOTO 			ia_best = ia;
302d6385b1cSHajimu UMEMOTO 			BREAK(1); /* there should be no better candidate */
303d6385b1cSHajimu UMEMOTO 		}
304d6385b1cSHajimu UMEMOTO 
305d6385b1cSHajimu UMEMOTO 		if (ia_best == NULL)
306d6385b1cSHajimu UMEMOTO 			REPLACE(0);
307d6385b1cSHajimu UMEMOTO 
308d6385b1cSHajimu UMEMOTO 		/* Rule 2: Prefer appropriate scope */
309d6385b1cSHajimu UMEMOTO 		if (dst_scope < 0)
310a1f7e5f8SHajimu UMEMOTO 			dst_scope = in6_addrscope(&dst);
311d6385b1cSHajimu UMEMOTO 		new_scope = in6_addrscope(&ia->ia_addr.sin6_addr);
312d6385b1cSHajimu UMEMOTO 		if (IN6_ARE_SCOPE_CMP(best_scope, new_scope) < 0) {
313d6385b1cSHajimu UMEMOTO 			if (IN6_ARE_SCOPE_CMP(best_scope, dst_scope) < 0)
314d6385b1cSHajimu UMEMOTO 				REPLACE(2);
315d6385b1cSHajimu UMEMOTO 			NEXT(2);
316d6385b1cSHajimu UMEMOTO 		} else if (IN6_ARE_SCOPE_CMP(new_scope, best_scope) < 0) {
317d6385b1cSHajimu UMEMOTO 			if (IN6_ARE_SCOPE_CMP(new_scope, dst_scope) < 0)
318d6385b1cSHajimu UMEMOTO 				NEXT(2);
319d6385b1cSHajimu UMEMOTO 			REPLACE(2);
320d6385b1cSHajimu UMEMOTO 		}
321d6385b1cSHajimu UMEMOTO 
322d6385b1cSHajimu UMEMOTO 		/*
323d6385b1cSHajimu UMEMOTO 		 * Rule 3: Avoid deprecated addresses.  Note that the case of
324d6385b1cSHajimu UMEMOTO 		 * !ip6_use_deprecated is already rejected above.
325d6385b1cSHajimu UMEMOTO 		 */
326d6385b1cSHajimu UMEMOTO 		if (!IFA6_IS_DEPRECATED(ia_best) && IFA6_IS_DEPRECATED(ia))
327d6385b1cSHajimu UMEMOTO 			NEXT(3);
328d6385b1cSHajimu UMEMOTO 		if (IFA6_IS_DEPRECATED(ia_best) && !IFA6_IS_DEPRECATED(ia))
329d6385b1cSHajimu UMEMOTO 			REPLACE(3);
330d6385b1cSHajimu UMEMOTO 
331d6385b1cSHajimu UMEMOTO 		/* Rule 4: Prefer home addresses */
332d6385b1cSHajimu UMEMOTO 		/*
333d6385b1cSHajimu UMEMOTO 		 * XXX: This is a TODO.  We should probably merge the MIP6
334d6385b1cSHajimu UMEMOTO 		 * case above.
335d6385b1cSHajimu UMEMOTO 		 */
336d6385b1cSHajimu UMEMOTO 
337d6385b1cSHajimu UMEMOTO 		/* Rule 5: Prefer outgoing interface */
338d6385b1cSHajimu UMEMOTO 		if (ia_best->ia_ifp == ifp && ia->ia_ifp != ifp)
339d6385b1cSHajimu UMEMOTO 			NEXT(5);
340d6385b1cSHajimu UMEMOTO 		if (ia_best->ia_ifp != ifp && ia->ia_ifp == ifp)
341d6385b1cSHajimu UMEMOTO 			REPLACE(5);
342d6385b1cSHajimu UMEMOTO 
343d6385b1cSHajimu UMEMOTO 		/*
344d6385b1cSHajimu UMEMOTO 		 * Rule 6: Prefer matching label
345d6385b1cSHajimu UMEMOTO 		 * Note that best_policy should be non-NULL here.
346d6385b1cSHajimu UMEMOTO 		 */
347d6385b1cSHajimu UMEMOTO 		if (dst_policy == NULL)
348d6385b1cSHajimu UMEMOTO 			dst_policy = lookup_addrsel_policy(dstsock);
349d6385b1cSHajimu UMEMOTO 		if (dst_policy->label != ADDR_LABEL_NOTAPP) {
350d6385b1cSHajimu UMEMOTO 			new_policy = lookup_addrsel_policy(&ia->ia_addr);
351d6385b1cSHajimu UMEMOTO 			if (dst_policy->label == best_policy->label &&
352d6385b1cSHajimu UMEMOTO 			    dst_policy->label != new_policy->label)
353d6385b1cSHajimu UMEMOTO 				NEXT(6);
354d6385b1cSHajimu UMEMOTO 			if (dst_policy->label != best_policy->label &&
355d6385b1cSHajimu UMEMOTO 			    dst_policy->label == new_policy->label)
356d6385b1cSHajimu UMEMOTO 				REPLACE(6);
357d6385b1cSHajimu UMEMOTO 		}
358d6385b1cSHajimu UMEMOTO 
359d6385b1cSHajimu UMEMOTO 		/*
360d6385b1cSHajimu UMEMOTO 		 * Rule 7: Prefer public addresses.
361d6385b1cSHajimu UMEMOTO 		 * We allow users to reverse the logic by configuring
362d6385b1cSHajimu UMEMOTO 		 * a sysctl variable, so that privacy conscious users can
363d6385b1cSHajimu UMEMOTO 		 * always prefer temporary addresses.
364d6385b1cSHajimu UMEMOTO 		 */
365d6385b1cSHajimu UMEMOTO 		if (opts == NULL ||
366d6385b1cSHajimu UMEMOTO 		    opts->ip6po_prefer_tempaddr == IP6PO_TEMPADDR_SYSTEM) {
367d6385b1cSHajimu UMEMOTO 			prefer_tempaddr = ip6_prefer_tempaddr;
368d6385b1cSHajimu UMEMOTO 		} else if (opts->ip6po_prefer_tempaddr ==
369d6385b1cSHajimu UMEMOTO 		    IP6PO_TEMPADDR_NOTPREFER) {
370d6385b1cSHajimu UMEMOTO 			prefer_tempaddr = 0;
371d6385b1cSHajimu UMEMOTO 		} else
372d6385b1cSHajimu UMEMOTO 			prefer_tempaddr = 1;
373d6385b1cSHajimu UMEMOTO 		if (!(ia_best->ia6_flags & IN6_IFF_TEMPORARY) &&
374d6385b1cSHajimu UMEMOTO 		    (ia->ia6_flags & IN6_IFF_TEMPORARY)) {
375d6385b1cSHajimu UMEMOTO 			if (prefer_tempaddr)
376d6385b1cSHajimu UMEMOTO 				REPLACE(7);
377d6385b1cSHajimu UMEMOTO 			else
378d6385b1cSHajimu UMEMOTO 				NEXT(7);
379d6385b1cSHajimu UMEMOTO 		}
380d6385b1cSHajimu UMEMOTO 		if ((ia_best->ia6_flags & IN6_IFF_TEMPORARY) &&
381d6385b1cSHajimu UMEMOTO 		    !(ia->ia6_flags & IN6_IFF_TEMPORARY)) {
382d6385b1cSHajimu UMEMOTO 			if (prefer_tempaddr)
383d6385b1cSHajimu UMEMOTO 				NEXT(7);
384d6385b1cSHajimu UMEMOTO 			else
385d6385b1cSHajimu UMEMOTO 				REPLACE(7);
386d6385b1cSHajimu UMEMOTO 		}
387d6385b1cSHajimu UMEMOTO 
388d6385b1cSHajimu UMEMOTO 		/*
389d6385b1cSHajimu UMEMOTO 		 * Rule 8: prefer addresses on alive interfaces.
390d6385b1cSHajimu UMEMOTO 		 * This is a KAME specific rule.
391d6385b1cSHajimu UMEMOTO 		 */
392d6385b1cSHajimu UMEMOTO 		if ((ia_best->ia_ifp->if_flags & IFF_UP) &&
393d6385b1cSHajimu UMEMOTO 		    !(ia->ia_ifp->if_flags & IFF_UP))
394d6385b1cSHajimu UMEMOTO 			NEXT(8);
395d6385b1cSHajimu UMEMOTO 		if (!(ia_best->ia_ifp->if_flags & IFF_UP) &&
396d6385b1cSHajimu UMEMOTO 		    (ia->ia_ifp->if_flags & IFF_UP))
397d6385b1cSHajimu UMEMOTO 			REPLACE(8);
398d6385b1cSHajimu UMEMOTO 
399d6385b1cSHajimu UMEMOTO 		/*
400d6385b1cSHajimu UMEMOTO 		 * Rule 14: Use longest matching prefix.
401d6385b1cSHajimu UMEMOTO 		 * Note: in the address selection draft, this rule is
402d6385b1cSHajimu UMEMOTO 		 * documented as "Rule 8".  However, since it is also
403d6385b1cSHajimu UMEMOTO 		 * documented that this rule can be overridden, we assign
404d6385b1cSHajimu UMEMOTO 		 * a large number so that it is easy to assign smaller numbers
405d6385b1cSHajimu UMEMOTO 		 * to more preferred rules.
406d6385b1cSHajimu UMEMOTO 		 */
407a1f7e5f8SHajimu UMEMOTO 		new_matchlen = in6_matchlen(&ia->ia_addr.sin6_addr, &dst);
408d6385b1cSHajimu UMEMOTO 		if (best_matchlen < new_matchlen)
409d6385b1cSHajimu UMEMOTO 			REPLACE(14);
410d6385b1cSHajimu UMEMOTO 		if (new_matchlen < best_matchlen)
411d6385b1cSHajimu UMEMOTO 			NEXT(14);
412d6385b1cSHajimu UMEMOTO 
413d6385b1cSHajimu UMEMOTO 		/* Rule 15 is reserved. */
414d6385b1cSHajimu UMEMOTO 
415d6385b1cSHajimu UMEMOTO 		/*
416d6385b1cSHajimu UMEMOTO 		 * Last resort: just keep the current candidate.
417d6385b1cSHajimu UMEMOTO 		 * Or, do we need more rules?
418d6385b1cSHajimu UMEMOTO 		 */
419d6385b1cSHajimu UMEMOTO 		continue;
420d6385b1cSHajimu UMEMOTO 
421d6385b1cSHajimu UMEMOTO 	  replace:
422d6385b1cSHajimu UMEMOTO 		ia_best = ia;
423d6385b1cSHajimu UMEMOTO 		best_scope = (new_scope >= 0 ? new_scope :
424d6385b1cSHajimu UMEMOTO 			      in6_addrscope(&ia_best->ia_addr.sin6_addr));
425d6385b1cSHajimu UMEMOTO 		best_policy = (new_policy ? new_policy :
426d6385b1cSHajimu UMEMOTO 			       lookup_addrsel_policy(&ia_best->ia_addr));
427d6385b1cSHajimu UMEMOTO 		best_matchlen = (new_matchlen >= 0 ? new_matchlen :
428d6385b1cSHajimu UMEMOTO 				 in6_matchlen(&ia_best->ia_addr.sin6_addr,
429a1f7e5f8SHajimu UMEMOTO 					      &dst));
430d6385b1cSHajimu UMEMOTO 
431d6385b1cSHajimu UMEMOTO 	  next:
432d6385b1cSHajimu UMEMOTO 		continue;
433d6385b1cSHajimu UMEMOTO 
434d6385b1cSHajimu UMEMOTO 	  out:
435d6385b1cSHajimu UMEMOTO 		break;
436d6385b1cSHajimu UMEMOTO 	}
437d6385b1cSHajimu UMEMOTO 
438d6385b1cSHajimu UMEMOTO 	if ((ia = ia_best) == NULL) {
439686cdd19SJun-ichiro itojun Hagino 		*errorp = EADDRNOTAVAIL;
440d6385b1cSHajimu UMEMOTO 		return (NULL);
441686cdd19SJun-ichiro itojun Hagino 	}
442686cdd19SJun-ichiro itojun Hagino 
443a1f7e5f8SHajimu UMEMOTO 	if (ifpp)
444a1f7e5f8SHajimu UMEMOTO 		*ifpp = ifp;
445a1f7e5f8SHajimu UMEMOTO 
446d6385b1cSHajimu UMEMOTO 	return (&ia->ia_addr.sin6_addr);
447d6385b1cSHajimu UMEMOTO }
448d6385b1cSHajimu UMEMOTO 
4491272577eSXin LI /*
4501272577eSXin LI  * clone - meaningful only for bsdi and freebsd
4511272577eSXin LI  */
452d6385b1cSHajimu UMEMOTO static int
4531272577eSXin LI selectroute(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts,
4541272577eSXin LI     struct ip6_moptions *mopts, struct route_in6 *ro,
4551272577eSXin LI     struct ifnet **retifp, struct rtentry **retrt, int clone,
4561272577eSXin LI     int norouteok)
457d6385b1cSHajimu UMEMOTO {
458d6385b1cSHajimu UMEMOTO 	int error = 0;
459d6385b1cSHajimu UMEMOTO 	struct ifnet *ifp = NULL;
460d6385b1cSHajimu UMEMOTO 	struct rtentry *rt = NULL;
461d6385b1cSHajimu UMEMOTO 	struct sockaddr_in6 *sin6_next;
462d6385b1cSHajimu UMEMOTO 	struct in6_pktinfo *pi = NULL;
463d6385b1cSHajimu UMEMOTO 	struct in6_addr *dst = &dstsock->sin6_addr;
464d6385b1cSHajimu UMEMOTO #if 0
4651d54aa3bSBjoern A. Zeeb 	char ip6buf[INET6_ADDRSTRLEN];
4661d54aa3bSBjoern A. Zeeb 
467d6385b1cSHajimu UMEMOTO 	if (dstsock->sin6_addr.s6_addr32[0] == 0 &&
468d6385b1cSHajimu UMEMOTO 	    dstsock->sin6_addr.s6_addr32[1] == 0 &&
469d6385b1cSHajimu UMEMOTO 	    !IN6_IS_ADDR_LOOPBACK(&dstsock->sin6_addr)) {
470d6385b1cSHajimu UMEMOTO 		printf("in6_selectroute: strange destination %s\n",
4711d54aa3bSBjoern A. Zeeb 		       ip6_sprintf(ip6buf, &dstsock->sin6_addr));
472d6385b1cSHajimu UMEMOTO 	} else {
473d6385b1cSHajimu UMEMOTO 		printf("in6_selectroute: destination = %s%%%d\n",
4741d54aa3bSBjoern A. Zeeb 		       ip6_sprintf(ip6buf, &dstsock->sin6_addr),
475d6385b1cSHajimu UMEMOTO 		       dstsock->sin6_scope_id); /* for debug */
476d6385b1cSHajimu UMEMOTO 	}
477d6385b1cSHajimu UMEMOTO #endif
478d6385b1cSHajimu UMEMOTO 
479d6385b1cSHajimu UMEMOTO 	/* If the caller specify the outgoing interface explicitly, use it. */
480d6385b1cSHajimu UMEMOTO 	if (opts && (pi = opts->ip6po_pktinfo) != NULL && pi->ipi6_ifindex) {
481d6385b1cSHajimu UMEMOTO 		/* XXX boundary check is assumed to be already done. */
482d6385b1cSHajimu UMEMOTO 		ifp = ifnet_byindex(pi->ipi6_ifindex);
483d6385b1cSHajimu UMEMOTO 		if (ifp != NULL &&
484a1f7e5f8SHajimu UMEMOTO 		    (norouteok || retrt == NULL ||
485a1f7e5f8SHajimu UMEMOTO 		    IN6_IS_ADDR_MULTICAST(dst))) {
486d6385b1cSHajimu UMEMOTO 			/*
487cd0fdcf7SHajimu UMEMOTO 			 * we do not have to check or get the route for
488d6385b1cSHajimu UMEMOTO 			 * multicast.
489d6385b1cSHajimu UMEMOTO 			 */
490d6385b1cSHajimu UMEMOTO 			goto done;
491d6385b1cSHajimu UMEMOTO 		} else
492d6385b1cSHajimu UMEMOTO 			goto getroute;
493d6385b1cSHajimu UMEMOTO 	}
494d6385b1cSHajimu UMEMOTO 
495d6385b1cSHajimu UMEMOTO 	/*
496d6385b1cSHajimu UMEMOTO 	 * If the destination address is a multicast address and the outgoing
497d6385b1cSHajimu UMEMOTO 	 * interface for the address is specified by the caller, use it.
498d6385b1cSHajimu UMEMOTO 	 */
499d6385b1cSHajimu UMEMOTO 	if (IN6_IS_ADDR_MULTICAST(dst) &&
500d6385b1cSHajimu UMEMOTO 	    mopts != NULL && (ifp = mopts->im6o_multicast_ifp) != NULL) {
501d6385b1cSHajimu UMEMOTO 		goto done; /* we do not need a route for multicast. */
502d6385b1cSHajimu UMEMOTO 	}
503d6385b1cSHajimu UMEMOTO 
504d6385b1cSHajimu UMEMOTO   getroute:
505d6385b1cSHajimu UMEMOTO 	/*
506d6385b1cSHajimu UMEMOTO 	 * If the next hop address for the packet is specified by the caller,
507d6385b1cSHajimu UMEMOTO 	 * use it as the gateway.
508d6385b1cSHajimu UMEMOTO 	 */
509d6385b1cSHajimu UMEMOTO 	if (opts && opts->ip6po_nexthop) {
510d6385b1cSHajimu UMEMOTO 		struct route_in6 *ron;
511d6385b1cSHajimu UMEMOTO 
512d6385b1cSHajimu UMEMOTO 		sin6_next = satosin6(opts->ip6po_nexthop);
513d6385b1cSHajimu UMEMOTO 
514d6385b1cSHajimu UMEMOTO 		/* at this moment, we only support AF_INET6 next hops */
515d6385b1cSHajimu UMEMOTO 		if (sin6_next->sin6_family != AF_INET6) {
516d6385b1cSHajimu UMEMOTO 			error = EAFNOSUPPORT; /* or should we proceed? */
517d6385b1cSHajimu UMEMOTO 			goto done;
518d6385b1cSHajimu UMEMOTO 		}
519d6385b1cSHajimu UMEMOTO 
520d6385b1cSHajimu UMEMOTO 		/*
521d6385b1cSHajimu UMEMOTO 		 * If the next hop is an IPv6 address, then the node identified
522d6385b1cSHajimu UMEMOTO 		 * by that address must be a neighbor of the sending host.
523d6385b1cSHajimu UMEMOTO 		 */
524d6385b1cSHajimu UMEMOTO 		ron = &opts->ip6po_nextroute;
525d6385b1cSHajimu UMEMOTO 		if ((ron->ro_rt &&
526d6385b1cSHajimu UMEMOTO 		     (ron->ro_rt->rt_flags & (RTF_UP | RTF_LLINFO)) !=
527d6385b1cSHajimu UMEMOTO 		     (RTF_UP | RTF_LLINFO)) ||
528c1a049acSSUZUKI Shinsuke 		    !IN6_ARE_ADDR_EQUAL(&satosin6(&ron->ro_dst)->sin6_addr,
529c1a049acSSUZUKI Shinsuke 		    &sin6_next->sin6_addr)) {
530d6385b1cSHajimu UMEMOTO 			if (ron->ro_rt) {
531d6385b1cSHajimu UMEMOTO 				RTFREE(ron->ro_rt);
532d6385b1cSHajimu UMEMOTO 				ron->ro_rt = NULL;
533d6385b1cSHajimu UMEMOTO 			}
534d6385b1cSHajimu UMEMOTO 			*satosin6(&ron->ro_dst) = *sin6_next;
535d6385b1cSHajimu UMEMOTO 		}
536d6385b1cSHajimu UMEMOTO 		if (ron->ro_rt == NULL) {
537d6385b1cSHajimu UMEMOTO 			rtalloc((struct route *)ron); /* multi path case? */
538d6385b1cSHajimu UMEMOTO 			if (ron->ro_rt == NULL ||
539d6385b1cSHajimu UMEMOTO 			    !(ron->ro_rt->rt_flags & RTF_LLINFO)) {
540d6385b1cSHajimu UMEMOTO 				if (ron->ro_rt) {
541d6385b1cSHajimu UMEMOTO 					RTFREE(ron->ro_rt);
542d6385b1cSHajimu UMEMOTO 					ron->ro_rt = NULL;
543d6385b1cSHajimu UMEMOTO 				}
544d6385b1cSHajimu UMEMOTO 				error = EHOSTUNREACH;
545d6385b1cSHajimu UMEMOTO 				goto done;
546d6385b1cSHajimu UMEMOTO 			}
547d6385b1cSHajimu UMEMOTO 		}
548d6385b1cSHajimu UMEMOTO 		rt = ron->ro_rt;
549d6385b1cSHajimu UMEMOTO 		ifp = rt->rt_ifp;
550d6385b1cSHajimu UMEMOTO 
551d6385b1cSHajimu UMEMOTO 		/*
552d6385b1cSHajimu UMEMOTO 		 * When cloning is required, try to allocate a route to the
553d6385b1cSHajimu UMEMOTO 		 * destination so that the caller can store path MTU
554d6385b1cSHajimu UMEMOTO 		 * information.
555d6385b1cSHajimu UMEMOTO 		 */
556d6385b1cSHajimu UMEMOTO 		if (!clone)
557d6385b1cSHajimu UMEMOTO 			goto done;
558d6385b1cSHajimu UMEMOTO 	}
559d6385b1cSHajimu UMEMOTO 
560d6385b1cSHajimu UMEMOTO 	/*
561d6385b1cSHajimu UMEMOTO 	 * Use a cached route if it exists and is valid, else try to allocate
562d6385b1cSHajimu UMEMOTO 	 * a new one.  Note that we should check the address family of the
563d6385b1cSHajimu UMEMOTO 	 * cached destination, in case of sharing the cache with IPv4.
564686cdd19SJun-ichiro itojun Hagino 	 */
565686cdd19SJun-ichiro itojun Hagino 	if (ro) {
566686cdd19SJun-ichiro itojun Hagino 		if (ro->ro_rt &&
56754c1b882SHajimu UMEMOTO 		    (!(ro->ro_rt->rt_flags & RTF_UP) ||
568d6385b1cSHajimu UMEMOTO 		     ((struct sockaddr *)(&ro->ro_dst))->sa_family != AF_INET6 ||
56954c1b882SHajimu UMEMOTO 		     !IN6_ARE_ADDR_EQUAL(&satosin6(&ro->ro_dst)->sin6_addr,
57054c1b882SHajimu UMEMOTO 		     dst))) {
571686cdd19SJun-ichiro itojun Hagino 			RTFREE(ro->ro_rt);
572d6385b1cSHajimu UMEMOTO 			ro->ro_rt = (struct rtentry *)NULL;
573686cdd19SJun-ichiro itojun Hagino 		}
574d6385b1cSHajimu UMEMOTO 		if (ro->ro_rt == (struct rtentry *)NULL) {
57533841545SHajimu UMEMOTO 			struct sockaddr_in6 *sa6;
57633841545SHajimu UMEMOTO 
577686cdd19SJun-ichiro itojun Hagino 			/* No route yet, so try to acquire one */
578686cdd19SJun-ichiro itojun Hagino 			bzero(&ro->ro_dst, sizeof(struct sockaddr_in6));
57933841545SHajimu UMEMOTO 			sa6 = (struct sockaddr_in6 *)&ro->ro_dst;
580d6385b1cSHajimu UMEMOTO 			*sa6 = *dstsock;
581e6a27350SHajimu UMEMOTO 			sa6->sin6_scope_id = 0;
58297d8d152SAndre Oppermann 
583d6385b1cSHajimu UMEMOTO 			if (clone) {
584e440aed9SQing Li #ifdef RADIX_MPATH
585e440aed9SQing Li 				rtalloc_mpath((struct route *)ro,
586e440aed9SQing Li 				    ntohl(sa6->sin6_addr.s6_addr32[3]));
587e440aed9SQing Li #else
588d6385b1cSHajimu UMEMOTO 				rtalloc((struct route *)ro);
589e440aed9SQing Li #endif
590d6385b1cSHajimu UMEMOTO 			} else {
591686cdd19SJun-ichiro itojun Hagino 				ro->ro_rt = rtalloc1(&((struct route *)ro)
592a89ec05eSPeter Wemm 						     ->ro_dst, 0, 0UL);
59337bdc280SSam Leffler 				if (ro->ro_rt)
594d1dd20beSSam Leffler 					RT_UNLOCK(ro->ro_rt);
595686cdd19SJun-ichiro itojun Hagino 			}
596686cdd19SJun-ichiro itojun Hagino 		}
597686cdd19SJun-ichiro itojun Hagino 
598686cdd19SJun-ichiro itojun Hagino 		/*
599d6385b1cSHajimu UMEMOTO 		 * do not care about the result if we have the nexthop
600d6385b1cSHajimu UMEMOTO 		 * explicitly specified.
601686cdd19SJun-ichiro itojun Hagino 		 */
602d6385b1cSHajimu UMEMOTO 		if (opts && opts->ip6po_nexthop)
603d6385b1cSHajimu UMEMOTO 			goto done;
604686cdd19SJun-ichiro itojun Hagino 
605686cdd19SJun-ichiro itojun Hagino 		if (ro->ro_rt) {
606d6385b1cSHajimu UMEMOTO 			ifp = ro->ro_rt->rt_ifp;
607d6385b1cSHajimu UMEMOTO 
608d6385b1cSHajimu UMEMOTO 			if (ifp == NULL) { /* can this really happen? */
609d6385b1cSHajimu UMEMOTO 				RTFREE(ro->ro_rt);
610d6385b1cSHajimu UMEMOTO 				ro->ro_rt = NULL;
611686cdd19SJun-ichiro itojun Hagino 			}
612686cdd19SJun-ichiro itojun Hagino 		}
613d6385b1cSHajimu UMEMOTO 		if (ro->ro_rt == NULL)
614d6385b1cSHajimu UMEMOTO 			error = EHOSTUNREACH;
615d6385b1cSHajimu UMEMOTO 		rt = ro->ro_rt;
616d6385b1cSHajimu UMEMOTO 
617d6385b1cSHajimu UMEMOTO 		/*
618d6385b1cSHajimu UMEMOTO 		 * Check if the outgoing interface conflicts with
619d6385b1cSHajimu UMEMOTO 		 * the interface specified by ipi6_ifindex (if specified).
620d6385b1cSHajimu UMEMOTO 		 * Note that loopback interface is always okay.
621d6385b1cSHajimu UMEMOTO 		 * (this may happen when we are sending a packet to one of
622d6385b1cSHajimu UMEMOTO 		 *  our own addresses.)
623d6385b1cSHajimu UMEMOTO 		 */
624403cbcf5SGeorge V. Neville-Neil 		if (ifp && opts && opts->ip6po_pktinfo &&
62568efda09SHajimu UMEMOTO 		    opts->ip6po_pktinfo->ipi6_ifindex) {
626d6385b1cSHajimu UMEMOTO 			if (!(ifp->if_flags & IFF_LOOPBACK) &&
627d6385b1cSHajimu UMEMOTO 			    ifp->if_index !=
628d6385b1cSHajimu UMEMOTO 			    opts->ip6po_pktinfo->ipi6_ifindex) {
629d6385b1cSHajimu UMEMOTO 				error = EHOSTUNREACH;
630d6385b1cSHajimu UMEMOTO 				goto done;
631d6385b1cSHajimu UMEMOTO 			}
632d6385b1cSHajimu UMEMOTO 		}
633686cdd19SJun-ichiro itojun Hagino 	}
634686cdd19SJun-ichiro itojun Hagino 
635d6385b1cSHajimu UMEMOTO   done:
636d6385b1cSHajimu UMEMOTO 	if (ifp == NULL && rt == NULL) {
637d6385b1cSHajimu UMEMOTO 		/*
638d6385b1cSHajimu UMEMOTO 		 * This can happen if the caller did not pass a cached route
639d6385b1cSHajimu UMEMOTO 		 * nor any other hints.  We treat this case an error.
640d6385b1cSHajimu UMEMOTO 		 */
641d6385b1cSHajimu UMEMOTO 		error = EHOSTUNREACH;
642d6385b1cSHajimu UMEMOTO 	}
643d6385b1cSHajimu UMEMOTO 	if (error == EHOSTUNREACH)
644d6385b1cSHajimu UMEMOTO 		ip6stat.ip6s_noroute++;
645d6385b1cSHajimu UMEMOTO 
646d6385b1cSHajimu UMEMOTO 	if (retifp != NULL)
647d6385b1cSHajimu UMEMOTO 		*retifp = ifp;
648d6385b1cSHajimu UMEMOTO 	if (retrt != NULL)
649d6385b1cSHajimu UMEMOTO 		*retrt = rt;	/* rt may be NULL */
650d6385b1cSHajimu UMEMOTO 
651d6385b1cSHajimu UMEMOTO 	return (error);
652686cdd19SJun-ichiro itojun Hagino }
653686cdd19SJun-ichiro itojun Hagino 
654a1f7e5f8SHajimu UMEMOTO static int
6551272577eSXin LI in6_selectif(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts,
6561272577eSXin LI     struct ip6_moptions *mopts, struct route_in6 *ro, struct ifnet **retifp)
657a1f7e5f8SHajimu UMEMOTO {
658a1f7e5f8SHajimu UMEMOTO 	int error;
659a1f7e5f8SHajimu UMEMOTO 	struct route_in6 sro;
660a1f7e5f8SHajimu UMEMOTO 	struct rtentry *rt = NULL;
661a1f7e5f8SHajimu UMEMOTO 
662a1f7e5f8SHajimu UMEMOTO 	if (ro == NULL) {
663a1f7e5f8SHajimu UMEMOTO 		bzero(&sro, sizeof(sro));
664a1f7e5f8SHajimu UMEMOTO 		ro = &sro;
665a1f7e5f8SHajimu UMEMOTO 	}
666a1f7e5f8SHajimu UMEMOTO 
667a1f7e5f8SHajimu UMEMOTO 	if ((error = selectroute(dstsock, opts, mopts, ro, retifp,
668a1f7e5f8SHajimu UMEMOTO 				     &rt, 0, 1)) != 0) {
669f8366b03SSeigo Tanimura 		if (ro == &sro && rt && rt == sro.ro_rt)
670a1f7e5f8SHajimu UMEMOTO 			RTFREE(rt);
671a1f7e5f8SHajimu UMEMOTO 		return (error);
672a1f7e5f8SHajimu UMEMOTO 	}
673a1f7e5f8SHajimu UMEMOTO 
674a1f7e5f8SHajimu UMEMOTO 	/*
675a1f7e5f8SHajimu UMEMOTO 	 * do not use a rejected or black hole route.
676a1f7e5f8SHajimu UMEMOTO 	 * XXX: this check should be done in the L2 output routine.
677a1f7e5f8SHajimu UMEMOTO 	 * However, if we skipped this check here, we'd see the following
678a1f7e5f8SHajimu UMEMOTO 	 * scenario:
679a1f7e5f8SHajimu UMEMOTO 	 * - install a rejected route for a scoped address prefix
680a1f7e5f8SHajimu UMEMOTO 	 *   (like fe80::/10)
681a1f7e5f8SHajimu UMEMOTO 	 * - send a packet to a destination that matches the scoped prefix,
682a1f7e5f8SHajimu UMEMOTO 	 *   with ambiguity about the scope zone.
683a1f7e5f8SHajimu UMEMOTO 	 * - pick the outgoing interface from the route, and disambiguate the
684a1f7e5f8SHajimu UMEMOTO 	 *   scope zone with the interface.
685a1f7e5f8SHajimu UMEMOTO 	 * - ip6_output() would try to get another route with the "new"
686a1f7e5f8SHajimu UMEMOTO 	 *   destination, which may be valid.
687a1f7e5f8SHajimu UMEMOTO 	 * - we'd see no error on output.
688a1f7e5f8SHajimu UMEMOTO 	 * Although this may not be very harmful, it should still be confusing.
689a1f7e5f8SHajimu UMEMOTO 	 * We thus reject the case here.
690a1f7e5f8SHajimu UMEMOTO 	 */
691a1f7e5f8SHajimu UMEMOTO 	if (rt && (rt->rt_flags & (RTF_REJECT | RTF_BLACKHOLE))) {
692a1f7e5f8SHajimu UMEMOTO 		int flags = (rt->rt_flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH);
693a1f7e5f8SHajimu UMEMOTO 
694f8366b03SSeigo Tanimura 		if (ro == &sro && rt && rt == sro.ro_rt)
695a1f7e5f8SHajimu UMEMOTO 			RTFREE(rt);
696a1f7e5f8SHajimu UMEMOTO 		return (flags);
697a1f7e5f8SHajimu UMEMOTO 	}
698a1f7e5f8SHajimu UMEMOTO 
699a1f7e5f8SHajimu UMEMOTO 	/*
700a1f7e5f8SHajimu UMEMOTO 	 * Adjust the "outgoing" interface.  If we're going to loop the packet
701a1f7e5f8SHajimu UMEMOTO 	 * back to ourselves, the ifp would be the loopback interface.
702a1f7e5f8SHajimu UMEMOTO 	 * However, we'd rather know the interface associated to the
703a1f7e5f8SHajimu UMEMOTO 	 * destination address (which should probably be one of our own
704a1f7e5f8SHajimu UMEMOTO 	 * addresses.)
705a1f7e5f8SHajimu UMEMOTO 	 */
706a1f7e5f8SHajimu UMEMOTO 	if (rt && rt->rt_ifa && rt->rt_ifa->ifa_ifp)
707a1f7e5f8SHajimu UMEMOTO 		*retifp = rt->rt_ifa->ifa_ifp;
708a1f7e5f8SHajimu UMEMOTO 
709f8366b03SSeigo Tanimura 	if (ro == &sro && rt && rt == sro.ro_rt)
710a1f7e5f8SHajimu UMEMOTO 		RTFREE(rt);
711a1f7e5f8SHajimu UMEMOTO 	return (0);
712a1f7e5f8SHajimu UMEMOTO }
713a1f7e5f8SHajimu UMEMOTO 
7141272577eSXin LI /*
7151272577eSXin LI  * clone - meaningful only for bsdi and freebsd
7161272577eSXin LI  */
717a1f7e5f8SHajimu UMEMOTO int
7181272577eSXin LI in6_selectroute(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts,
7191272577eSXin LI     struct ip6_moptions *mopts, struct route_in6 *ro,
7201272577eSXin LI     struct ifnet **retifp, struct rtentry **retrt, int clone)
721a1f7e5f8SHajimu UMEMOTO {
7221272577eSXin LI 
723a1f7e5f8SHajimu UMEMOTO 	return (selectroute(dstsock, opts, mopts, ro, retifp,
724a1f7e5f8SHajimu UMEMOTO 	    retrt, clone, 0));
725a1f7e5f8SHajimu UMEMOTO }
726a1f7e5f8SHajimu UMEMOTO 
727686cdd19SJun-ichiro itojun Hagino /*
728686cdd19SJun-ichiro itojun Hagino  * Default hop limit selection. The precedence is as follows:
729686cdd19SJun-ichiro itojun Hagino  * 1. Hoplimit value specified via ioctl.
730686cdd19SJun-ichiro itojun Hagino  * 2. (If the outgoing interface is detected) the current
731686cdd19SJun-ichiro itojun Hagino  *     hop limit of the interface specified by router advertisement.
732686cdd19SJun-ichiro itojun Hagino  * 3. The system default hoplimit.
733686cdd19SJun-ichiro itojun Hagino  */
734686cdd19SJun-ichiro itojun Hagino int
7351272577eSXin LI in6_selecthlim(struct in6pcb *in6p, struct ifnet *ifp)
736686cdd19SJun-ichiro itojun Hagino {
7371272577eSXin LI 
738686cdd19SJun-ichiro itojun Hagino 	if (in6p && in6p->in6p_hops >= 0)
739686cdd19SJun-ichiro itojun Hagino 		return (in6p->in6p_hops);
740686cdd19SJun-ichiro itojun Hagino 	else if (ifp)
74131b1bfe1SHajimu UMEMOTO 		return (ND_IFINFO(ifp)->chlim);
74297d8d152SAndre Oppermann 	else if (in6p && !IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) {
74397d8d152SAndre Oppermann 		struct route_in6 ro6;
74497d8d152SAndre Oppermann 		struct ifnet *lifp;
74597d8d152SAndre Oppermann 
74697d8d152SAndre Oppermann 		bzero(&ro6, sizeof(ro6));
74797d8d152SAndre Oppermann 		ro6.ro_dst.sin6_family = AF_INET6;
74897d8d152SAndre Oppermann 		ro6.ro_dst.sin6_len = sizeof(struct sockaddr_in6);
74997d8d152SAndre Oppermann 		ro6.ro_dst.sin6_addr = in6p->in6p_faddr;
75097d8d152SAndre Oppermann 		rtalloc((struct route *)&ro6);
75197d8d152SAndre Oppermann 		if (ro6.ro_rt) {
75297d8d152SAndre Oppermann 			lifp = ro6.ro_rt->rt_ifp;
75397d8d152SAndre Oppermann 			RTFREE(ro6.ro_rt);
75497d8d152SAndre Oppermann 			if (lifp)
75597d8d152SAndre Oppermann 				return (ND_IFINFO(lifp)->chlim);
75697d8d152SAndre Oppermann 		} else
75797d8d152SAndre Oppermann 			return (ip6_defhlim);
75897d8d152SAndre Oppermann 	}
759686cdd19SJun-ichiro itojun Hagino 	return (ip6_defhlim);
760686cdd19SJun-ichiro itojun Hagino }
761686cdd19SJun-ichiro itojun Hagino 
762686cdd19SJun-ichiro itojun Hagino /*
763686cdd19SJun-ichiro itojun Hagino  * XXX: this is borrowed from in6_pcbbind(). If possible, we should
764686cdd19SJun-ichiro itojun Hagino  * share this function by all *bsd*...
765686cdd19SJun-ichiro itojun Hagino  */
766686cdd19SJun-ichiro itojun Hagino int
7671272577eSXin LI in6_pcbsetport(struct in6_addr *laddr, struct inpcb *inp, struct ucred *cred)
768686cdd19SJun-ichiro itojun Hagino {
769686cdd19SJun-ichiro itojun Hagino 	struct socket *so = inp->inp_socket;
770686cdd19SJun-ichiro itojun Hagino 	u_int16_t lport = 0, first, last, *lastport;
771686cdd19SJun-ichiro itojun Hagino 	int count, error = 0, wild = 0;
772686cdd19SJun-ichiro itojun Hagino 	struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
773686cdd19SJun-ichiro itojun Hagino 
7748deea4a8SRobert Watson 	INP_INFO_WLOCK_ASSERT(pcbinfo);
7758501a69cSRobert Watson 	INP_WLOCK_ASSERT(inp);
7768deea4a8SRobert Watson 
777686cdd19SJun-ichiro itojun Hagino 	/* XXX: this is redundant when called from in6_pcbbind */
778686cdd19SJun-ichiro itojun Hagino 	if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) == 0)
779686cdd19SJun-ichiro itojun Hagino 		wild = INPLOOKUP_WILDCARD;
780686cdd19SJun-ichiro itojun Hagino 
781686cdd19SJun-ichiro itojun Hagino 	inp->inp_flags |= INP_ANONPORT;
782686cdd19SJun-ichiro itojun Hagino 
783686cdd19SJun-ichiro itojun Hagino 	if (inp->inp_flags & INP_HIGHPORT) {
784686cdd19SJun-ichiro itojun Hagino 		first = ipport_hifirstauto;	/* sysctl */
785686cdd19SJun-ichiro itojun Hagino 		last  = ipport_hilastauto;
786712fc218SRobert Watson 		lastport = &pcbinfo->ipi_lasthi;
787686cdd19SJun-ichiro itojun Hagino 	} else if (inp->inp_flags & INP_LOWPORT) {
78832f9753cSRobert Watson 		error = priv_check_cred(cred, PRIV_NETINET_RESERVEDPORT, 0);
789acd3428bSRobert Watson 		if (error)
790686cdd19SJun-ichiro itojun Hagino 			return error;
791686cdd19SJun-ichiro itojun Hagino 		first = ipport_lowfirstauto;	/* 1023 */
792686cdd19SJun-ichiro itojun Hagino 		last  = ipport_lowlastauto;	/* 600 */
793712fc218SRobert Watson 		lastport = &pcbinfo->ipi_lastlow;
794686cdd19SJun-ichiro itojun Hagino 	} else {
795686cdd19SJun-ichiro itojun Hagino 		first = ipport_firstauto;	/* sysctl */
796686cdd19SJun-ichiro itojun Hagino 		last  = ipport_lastauto;
797712fc218SRobert Watson 		lastport = &pcbinfo->ipi_lastport;
798686cdd19SJun-ichiro itojun Hagino 	}
799686cdd19SJun-ichiro itojun Hagino 	/*
800686cdd19SJun-ichiro itojun Hagino 	 * Simple check to ensure all ports are not used up causing
801686cdd19SJun-ichiro itojun Hagino 	 * a deadlock here.
802686cdd19SJun-ichiro itojun Hagino 	 *
803686cdd19SJun-ichiro itojun Hagino 	 * We split the two cases (up and down) so that the direction
804686cdd19SJun-ichiro itojun Hagino 	 * is not being tested on each round of the loop.
805686cdd19SJun-ichiro itojun Hagino 	 */
806686cdd19SJun-ichiro itojun Hagino 	if (first > last) {
807686cdd19SJun-ichiro itojun Hagino 		/*
808686cdd19SJun-ichiro itojun Hagino 		 * counting down
809686cdd19SJun-ichiro itojun Hagino 		 */
810686cdd19SJun-ichiro itojun Hagino 		count = first - last;
811686cdd19SJun-ichiro itojun Hagino 
812686cdd19SJun-ichiro itojun Hagino 		do {
813686cdd19SJun-ichiro itojun Hagino 			if (count-- < 0) {	/* completely used? */
814686cdd19SJun-ichiro itojun Hagino 				/*
815686cdd19SJun-ichiro itojun Hagino 				 * Undo any address bind that may have
816686cdd19SJun-ichiro itojun Hagino 				 * occurred above.
817686cdd19SJun-ichiro itojun Hagino 				 */
818686cdd19SJun-ichiro itojun Hagino 				inp->in6p_laddr = in6addr_any;
819686cdd19SJun-ichiro itojun Hagino 				return (EAGAIN);
820686cdd19SJun-ichiro itojun Hagino 			}
821686cdd19SJun-ichiro itojun Hagino 			--*lastport;
822686cdd19SJun-ichiro itojun Hagino 			if (*lastport > first || *lastport < last)
823686cdd19SJun-ichiro itojun Hagino 				*lastport = first;
824686cdd19SJun-ichiro itojun Hagino 			lport = htons(*lastport);
82568efda09SHajimu UMEMOTO 		} while (in6_pcblookup_local(pcbinfo, &inp->in6p_laddr,
82668efda09SHajimu UMEMOTO 					     lport, wild));
827686cdd19SJun-ichiro itojun Hagino 	} else {
828686cdd19SJun-ichiro itojun Hagino 		/*
829686cdd19SJun-ichiro itojun Hagino 			 * counting up
830686cdd19SJun-ichiro itojun Hagino 			 */
831686cdd19SJun-ichiro itojun Hagino 		count = last - first;
832686cdd19SJun-ichiro itojun Hagino 
833686cdd19SJun-ichiro itojun Hagino 		do {
834686cdd19SJun-ichiro itojun Hagino 			if (count-- < 0) {	/* completely used? */
835686cdd19SJun-ichiro itojun Hagino 				/*
836686cdd19SJun-ichiro itojun Hagino 				 * Undo any address bind that may have
837686cdd19SJun-ichiro itojun Hagino 				 * occurred above.
838686cdd19SJun-ichiro itojun Hagino 				 */
839686cdd19SJun-ichiro itojun Hagino 				inp->in6p_laddr = in6addr_any;
840686cdd19SJun-ichiro itojun Hagino 				return (EAGAIN);
841686cdd19SJun-ichiro itojun Hagino 			}
842686cdd19SJun-ichiro itojun Hagino 			++*lastport;
843686cdd19SJun-ichiro itojun Hagino 			if (*lastport < first || *lastport > last)
844686cdd19SJun-ichiro itojun Hagino 				*lastport = first;
845686cdd19SJun-ichiro itojun Hagino 			lport = htons(*lastport);
846686cdd19SJun-ichiro itojun Hagino 		} while (in6_pcblookup_local(pcbinfo,
847686cdd19SJun-ichiro itojun Hagino 					     &inp->in6p_laddr, lport, wild));
848686cdd19SJun-ichiro itojun Hagino 	}
849686cdd19SJun-ichiro itojun Hagino 
850686cdd19SJun-ichiro itojun Hagino 	inp->inp_lport = lport;
851686cdd19SJun-ichiro itojun Hagino 	if (in_pcbinshash(inp) != 0) {
852686cdd19SJun-ichiro itojun Hagino 		inp->in6p_laddr = in6addr_any;
853686cdd19SJun-ichiro itojun Hagino 		inp->inp_lport = 0;
854686cdd19SJun-ichiro itojun Hagino 		return (EAGAIN);
855686cdd19SJun-ichiro itojun Hagino 	}
856686cdd19SJun-ichiro itojun Hagino 
857686cdd19SJun-ichiro itojun Hagino 	return (0);
858686cdd19SJun-ichiro itojun Hagino }
859686cdd19SJun-ichiro itojun Hagino 
8607fc91b3fSHajimu UMEMOTO void
8611272577eSXin LI addrsel_policy_init(void)
8627fc91b3fSHajimu UMEMOTO {
8637fc91b3fSHajimu UMEMOTO 	ADDRSEL_LOCK_INIT();
8645d525653SHajimu UMEMOTO 	ADDRSEL_SXLOCK_INIT();
8657fc91b3fSHajimu UMEMOTO 
8667fc91b3fSHajimu UMEMOTO 	init_policy_queue();
8677fc91b3fSHajimu UMEMOTO 
8687fc91b3fSHajimu UMEMOTO 	/* initialize the "last resort" policy */
8697fc91b3fSHajimu UMEMOTO 	bzero(&defaultaddrpolicy, sizeof(defaultaddrpolicy));
8707fc91b3fSHajimu UMEMOTO 	defaultaddrpolicy.label = ADDR_LABEL_NOTAPP;
8717fc91b3fSHajimu UMEMOTO }
8727fc91b3fSHajimu UMEMOTO 
873d6385b1cSHajimu UMEMOTO static struct in6_addrpolicy *
8741272577eSXin LI lookup_addrsel_policy(struct sockaddr_in6 *key)
875d6385b1cSHajimu UMEMOTO {
876d6385b1cSHajimu UMEMOTO 	struct in6_addrpolicy *match = NULL;
877d6385b1cSHajimu UMEMOTO 
878d6385b1cSHajimu UMEMOTO 	ADDRSEL_LOCK();
879d6385b1cSHajimu UMEMOTO 	match = match_addrsel_policy(key);
880d6385b1cSHajimu UMEMOTO 
881d6385b1cSHajimu UMEMOTO 	if (match == NULL)
882d6385b1cSHajimu UMEMOTO 		match = &defaultaddrpolicy;
883d6385b1cSHajimu UMEMOTO 	else
884d6385b1cSHajimu UMEMOTO 		match->use++;
885d6385b1cSHajimu UMEMOTO 	ADDRSEL_UNLOCK();
886d6385b1cSHajimu UMEMOTO 
887d6385b1cSHajimu UMEMOTO 	return (match);
888d6385b1cSHajimu UMEMOTO }
889d6385b1cSHajimu UMEMOTO 
8907fc91b3fSHajimu UMEMOTO /*
8917fc91b3fSHajimu UMEMOTO  * Subroutines to manage the address selection policy table via sysctl.
8927fc91b3fSHajimu UMEMOTO  */
8937fc91b3fSHajimu UMEMOTO struct walkarg {
8947fc91b3fSHajimu UMEMOTO 	struct sysctl_req *w_req;
8957fc91b3fSHajimu UMEMOTO };
8967fc91b3fSHajimu UMEMOTO 
8977fc91b3fSHajimu UMEMOTO static int in6_src_sysctl(SYSCTL_HANDLER_ARGS);
8987fc91b3fSHajimu UMEMOTO SYSCTL_DECL(_net_inet6_ip6);
8997fc91b3fSHajimu UMEMOTO SYSCTL_NODE(_net_inet6_ip6, IPV6CTL_ADDRCTLPOLICY, addrctlpolicy,
9007fc91b3fSHajimu UMEMOTO 	CTLFLAG_RD, in6_src_sysctl, "");
9017fc91b3fSHajimu UMEMOTO 
9027fc91b3fSHajimu UMEMOTO static int
9037fc91b3fSHajimu UMEMOTO in6_src_sysctl(SYSCTL_HANDLER_ARGS)
9047fc91b3fSHajimu UMEMOTO {
9057fc91b3fSHajimu UMEMOTO 	struct walkarg w;
9067fc91b3fSHajimu UMEMOTO 
9077fc91b3fSHajimu UMEMOTO 	if (req->newptr)
9087fc91b3fSHajimu UMEMOTO 		return EPERM;
9097fc91b3fSHajimu UMEMOTO 
9107fc91b3fSHajimu UMEMOTO 	bzero(&w, sizeof(w));
9117fc91b3fSHajimu UMEMOTO 	w.w_req = req;
9127fc91b3fSHajimu UMEMOTO 
9137fc91b3fSHajimu UMEMOTO 	return (walk_addrsel_policy(dump_addrsel_policyent, &w));
9147fc91b3fSHajimu UMEMOTO }
9157fc91b3fSHajimu UMEMOTO 
9167fc91b3fSHajimu UMEMOTO int
9171272577eSXin LI in6_src_ioctl(u_long cmd, caddr_t data)
9187fc91b3fSHajimu UMEMOTO {
9197fc91b3fSHajimu UMEMOTO 	int i;
9207fc91b3fSHajimu UMEMOTO 	struct in6_addrpolicy ent0;
9217fc91b3fSHajimu UMEMOTO 
9227fc91b3fSHajimu UMEMOTO 	if (cmd != SIOCAADDRCTL_POLICY && cmd != SIOCDADDRCTL_POLICY)
9237fc91b3fSHajimu UMEMOTO 		return (EOPNOTSUPP); /* check for safety */
9247fc91b3fSHajimu UMEMOTO 
9257fc91b3fSHajimu UMEMOTO 	ent0 = *(struct in6_addrpolicy *)data;
9267fc91b3fSHajimu UMEMOTO 
9277fc91b3fSHajimu UMEMOTO 	if (ent0.label == ADDR_LABEL_NOTAPP)
9287fc91b3fSHajimu UMEMOTO 		return (EINVAL);
9297fc91b3fSHajimu UMEMOTO 	/* check if the prefix mask is consecutive. */
9307fc91b3fSHajimu UMEMOTO 	if (in6_mask2len(&ent0.addrmask.sin6_addr, NULL) < 0)
9317fc91b3fSHajimu UMEMOTO 		return (EINVAL);
9327fc91b3fSHajimu UMEMOTO 	/* clear trailing garbages (if any) of the prefix address. */
9337fc91b3fSHajimu UMEMOTO 	for (i = 0; i < 4; i++) {
9347fc91b3fSHajimu UMEMOTO 		ent0.addr.sin6_addr.s6_addr32[i] &=
9357fc91b3fSHajimu UMEMOTO 			ent0.addrmask.sin6_addr.s6_addr32[i];
9367fc91b3fSHajimu UMEMOTO 	}
9377fc91b3fSHajimu UMEMOTO 	ent0.use = 0;
9387fc91b3fSHajimu UMEMOTO 
9397fc91b3fSHajimu UMEMOTO 	switch (cmd) {
9407fc91b3fSHajimu UMEMOTO 	case SIOCAADDRCTL_POLICY:
9417fc91b3fSHajimu UMEMOTO 		return (add_addrsel_policyent(&ent0));
9427fc91b3fSHajimu UMEMOTO 	case SIOCDADDRCTL_POLICY:
9437fc91b3fSHajimu UMEMOTO 		return (delete_addrsel_policyent(&ent0));
9447fc91b3fSHajimu UMEMOTO 	}
9457fc91b3fSHajimu UMEMOTO 
9467fc91b3fSHajimu UMEMOTO 	return (0);		/* XXX: compromise compilers */
9477fc91b3fSHajimu UMEMOTO }
9487fc91b3fSHajimu UMEMOTO 
9497fc91b3fSHajimu UMEMOTO /*
9507fc91b3fSHajimu UMEMOTO  * The followings are implementation of the policy table using a
9517fc91b3fSHajimu UMEMOTO  * simple tail queue.
9527fc91b3fSHajimu UMEMOTO  * XXX such details should be hidden.
9537fc91b3fSHajimu UMEMOTO  * XXX implementation using binary tree should be more efficient.
9547fc91b3fSHajimu UMEMOTO  */
9557fc91b3fSHajimu UMEMOTO struct addrsel_policyent {
9567fc91b3fSHajimu UMEMOTO 	TAILQ_ENTRY(addrsel_policyent) ape_entry;
9577fc91b3fSHajimu UMEMOTO 	struct in6_addrpolicy ape_policy;
9587fc91b3fSHajimu UMEMOTO };
9597fc91b3fSHajimu UMEMOTO 
9607fc91b3fSHajimu UMEMOTO TAILQ_HEAD(addrsel_policyhead, addrsel_policyent);
9617fc91b3fSHajimu UMEMOTO 
9627fc91b3fSHajimu UMEMOTO struct addrsel_policyhead addrsel_policytab;
9637fc91b3fSHajimu UMEMOTO 
9647fc91b3fSHajimu UMEMOTO static void
9651272577eSXin LI init_policy_queue(void)
9667fc91b3fSHajimu UMEMOTO {
9671272577eSXin LI 
9687fc91b3fSHajimu UMEMOTO 	TAILQ_INIT(&addrsel_policytab);
9697fc91b3fSHajimu UMEMOTO }
9707fc91b3fSHajimu UMEMOTO 
9717fc91b3fSHajimu UMEMOTO static int
9721272577eSXin LI add_addrsel_policyent(struct in6_addrpolicy *newpolicy)
9737fc91b3fSHajimu UMEMOTO {
9747fc91b3fSHajimu UMEMOTO 	struct addrsel_policyent *new, *pol;
9757fc91b3fSHajimu UMEMOTO 
976349b668aSHajimu UMEMOTO 	MALLOC(new, struct addrsel_policyent *, sizeof(*new), M_IFADDR,
977349b668aSHajimu UMEMOTO 	       M_WAITOK);
9785d525653SHajimu UMEMOTO 	ADDRSEL_XLOCK();
9797fc91b3fSHajimu UMEMOTO 	ADDRSEL_LOCK();
9807fc91b3fSHajimu UMEMOTO 
9817fc91b3fSHajimu UMEMOTO 	/* duplication check */
9825d525653SHajimu UMEMOTO 	TAILQ_FOREACH(pol, &addrsel_policytab, ape_entry) {
983c1a049acSSUZUKI Shinsuke 		if (IN6_ARE_ADDR_EQUAL(&newpolicy->addr.sin6_addr,
984c1a049acSSUZUKI Shinsuke 				       &pol->ape_policy.addr.sin6_addr) &&
985c1a049acSSUZUKI Shinsuke 		    IN6_ARE_ADDR_EQUAL(&newpolicy->addrmask.sin6_addr,
986c1a049acSSUZUKI Shinsuke 				       &pol->ape_policy.addrmask.sin6_addr)) {
987349b668aSHajimu UMEMOTO 			ADDRSEL_UNLOCK();
9885d525653SHajimu UMEMOTO 			ADDRSEL_XUNLOCK();
989349b668aSHajimu UMEMOTO 			FREE(new, M_IFADDR);
9907fc91b3fSHajimu UMEMOTO 			return (EEXIST);	/* or override it? */
9917fc91b3fSHajimu UMEMOTO 		}
9927fc91b3fSHajimu UMEMOTO 	}
9937fc91b3fSHajimu UMEMOTO 
9947fc91b3fSHajimu UMEMOTO 	bzero(new, sizeof(*new));
9957fc91b3fSHajimu UMEMOTO 
9967fc91b3fSHajimu UMEMOTO 	/* XXX: should validate entry */
9977fc91b3fSHajimu UMEMOTO 	new->ape_policy = *newpolicy;
9987fc91b3fSHajimu UMEMOTO 
9997fc91b3fSHajimu UMEMOTO 	TAILQ_INSERT_TAIL(&addrsel_policytab, new, ape_entry);
10007fc91b3fSHajimu UMEMOTO 	ADDRSEL_UNLOCK();
10015d525653SHajimu UMEMOTO 	ADDRSEL_XUNLOCK();
10027fc91b3fSHajimu UMEMOTO 
10037fc91b3fSHajimu UMEMOTO 	return (0);
10047fc91b3fSHajimu UMEMOTO }
10057fc91b3fSHajimu UMEMOTO 
10067fc91b3fSHajimu UMEMOTO static int
10071272577eSXin LI delete_addrsel_policyent(struct in6_addrpolicy *key)
10087fc91b3fSHajimu UMEMOTO {
10097fc91b3fSHajimu UMEMOTO 	struct addrsel_policyent *pol;
10107fc91b3fSHajimu UMEMOTO 
10115d525653SHajimu UMEMOTO 	ADDRSEL_XLOCK();
10127fc91b3fSHajimu UMEMOTO 	ADDRSEL_LOCK();
10137fc91b3fSHajimu UMEMOTO 
10147fc91b3fSHajimu UMEMOTO 	/* search for the entry in the table */
10155d525653SHajimu UMEMOTO 	TAILQ_FOREACH(pol, &addrsel_policytab, ape_entry) {
1016c1a049acSSUZUKI Shinsuke 		if (IN6_ARE_ADDR_EQUAL(&key->addr.sin6_addr,
1017c1a049acSSUZUKI Shinsuke 		    &pol->ape_policy.addr.sin6_addr) &&
1018c1a049acSSUZUKI Shinsuke 		    IN6_ARE_ADDR_EQUAL(&key->addrmask.sin6_addr,
1019c1a049acSSUZUKI Shinsuke 		    &pol->ape_policy.addrmask.sin6_addr)) {
10207fc91b3fSHajimu UMEMOTO 			break;
10217fc91b3fSHajimu UMEMOTO 		}
10227fc91b3fSHajimu UMEMOTO 	}
1023349b668aSHajimu UMEMOTO 	if (pol == NULL) {
1024349b668aSHajimu UMEMOTO 		ADDRSEL_UNLOCK();
10255d525653SHajimu UMEMOTO 		ADDRSEL_XUNLOCK();
10267fc91b3fSHajimu UMEMOTO 		return (ESRCH);
1027349b668aSHajimu UMEMOTO 	}
10287fc91b3fSHajimu UMEMOTO 
10297fc91b3fSHajimu UMEMOTO 	TAILQ_REMOVE(&addrsel_policytab, pol, ape_entry);
10307fc91b3fSHajimu UMEMOTO 	ADDRSEL_UNLOCK();
10315d525653SHajimu UMEMOTO 	ADDRSEL_XUNLOCK();
10327fc91b3fSHajimu UMEMOTO 
10337fc91b3fSHajimu UMEMOTO 	return (0);
10347fc91b3fSHajimu UMEMOTO }
10357fc91b3fSHajimu UMEMOTO 
10367fc91b3fSHajimu UMEMOTO static int
10379233d8f3SDavid E. O'Brien walk_addrsel_policy(int (*callback)(struct in6_addrpolicy *, void *),
10381272577eSXin LI     void *w)
10397fc91b3fSHajimu UMEMOTO {
10407fc91b3fSHajimu UMEMOTO 	struct addrsel_policyent *pol;
10417fc91b3fSHajimu UMEMOTO 	int error = 0;
10427fc91b3fSHajimu UMEMOTO 
10435d525653SHajimu UMEMOTO 	ADDRSEL_SLOCK();
10445d525653SHajimu UMEMOTO 	TAILQ_FOREACH(pol, &addrsel_policytab, ape_entry) {
10455d525653SHajimu UMEMOTO 		if ((error = (*callback)(&pol->ape_policy, w)) != 0) {
10465d525653SHajimu UMEMOTO 			ADDRSEL_SUNLOCK();
10477fc91b3fSHajimu UMEMOTO 			return (error);
1048349b668aSHajimu UMEMOTO 		}
10495d525653SHajimu UMEMOTO 	}
10505d525653SHajimu UMEMOTO 	ADDRSEL_SUNLOCK();
10517fc91b3fSHajimu UMEMOTO 	return (error);
10527fc91b3fSHajimu UMEMOTO }
10537fc91b3fSHajimu UMEMOTO 
10547fc91b3fSHajimu UMEMOTO static int
10551272577eSXin LI dump_addrsel_policyent(struct in6_addrpolicy *pol, void *arg)
10567fc91b3fSHajimu UMEMOTO {
10577fc91b3fSHajimu UMEMOTO 	int error = 0;
10587fc91b3fSHajimu UMEMOTO 	struct walkarg *w = arg;
10597fc91b3fSHajimu UMEMOTO 
10607fc91b3fSHajimu UMEMOTO 	error = SYSCTL_OUT(w->w_req, pol, sizeof(*pol));
10617fc91b3fSHajimu UMEMOTO 
10627fc91b3fSHajimu UMEMOTO 	return (error);
10637fc91b3fSHajimu UMEMOTO }
1064d6385b1cSHajimu UMEMOTO 
1065d6385b1cSHajimu UMEMOTO static struct in6_addrpolicy *
10661272577eSXin LI match_addrsel_policy(struct sockaddr_in6 *key)
1067d6385b1cSHajimu UMEMOTO {
1068d6385b1cSHajimu UMEMOTO 	struct addrsel_policyent *pent;
1069d6385b1cSHajimu UMEMOTO 	struct in6_addrpolicy *bestpol = NULL, *pol;
1070d6385b1cSHajimu UMEMOTO 	int matchlen, bestmatchlen = -1;
1071d6385b1cSHajimu UMEMOTO 	u_char *mp, *ep, *k, *p, m;
1072d6385b1cSHajimu UMEMOTO 
10735d525653SHajimu UMEMOTO 	TAILQ_FOREACH(pent, &addrsel_policytab, ape_entry) {
1074d6385b1cSHajimu UMEMOTO 		matchlen = 0;
1075d6385b1cSHajimu UMEMOTO 
1076d6385b1cSHajimu UMEMOTO 		pol = &pent->ape_policy;
1077d6385b1cSHajimu UMEMOTO 		mp = (u_char *)&pol->addrmask.sin6_addr;
1078d6385b1cSHajimu UMEMOTO 		ep = mp + 16;	/* XXX: scope field? */
1079d6385b1cSHajimu UMEMOTO 		k = (u_char *)&key->sin6_addr;
1080d6385b1cSHajimu UMEMOTO 		p = (u_char *)&pol->addr.sin6_addr;
1081d6385b1cSHajimu UMEMOTO 		for (; mp < ep && *mp; mp++, k++, p++) {
1082d6385b1cSHajimu UMEMOTO 			m = *mp;
1083d6385b1cSHajimu UMEMOTO 			if ((*k & m) != *p)
1084d6385b1cSHajimu UMEMOTO 				goto next; /* not match */
1085d6385b1cSHajimu UMEMOTO 			if (m == 0xff) /* short cut for a typical case */
1086d6385b1cSHajimu UMEMOTO 				matchlen += 8;
1087d6385b1cSHajimu UMEMOTO 			else {
1088d6385b1cSHajimu UMEMOTO 				while (m >= 0x80) {
1089d6385b1cSHajimu UMEMOTO 					matchlen++;
1090d6385b1cSHajimu UMEMOTO 					m <<= 1;
1091d6385b1cSHajimu UMEMOTO 				}
1092d6385b1cSHajimu UMEMOTO 			}
1093d6385b1cSHajimu UMEMOTO 		}
1094d6385b1cSHajimu UMEMOTO 
1095d6385b1cSHajimu UMEMOTO 		/* matched.  check if this is better than the current best. */
1096d6385b1cSHajimu UMEMOTO 		if (bestpol == NULL ||
1097d6385b1cSHajimu UMEMOTO 		    matchlen > bestmatchlen) {
1098d6385b1cSHajimu UMEMOTO 			bestpol = pol;
1099d6385b1cSHajimu UMEMOTO 			bestmatchlen = matchlen;
1100d6385b1cSHajimu UMEMOTO 		}
1101d6385b1cSHajimu UMEMOTO 
1102d6385b1cSHajimu UMEMOTO 	  next:
1103d6385b1cSHajimu UMEMOTO 		continue;
1104d6385b1cSHajimu UMEMOTO 	}
1105d6385b1cSHajimu UMEMOTO 
1106d6385b1cSHajimu UMEMOTO 	return (bestpol);
1107d6385b1cSHajimu UMEMOTO }
1108