xref: /freebsd/sys/netinet6/in6_pcb.c (revision bc96366c864c07ef352edb92017357917c75b36c)
1 /*-
2  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
3  * Copyright (c) 2010-2011 Juniper Networks, Inc.
4  * All rights reserved.
5  *
6  * Portions of this software were developed by Robert N. M. Watson under
7  * contract to Juniper Networks, Inc.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. Neither the name of the project nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  *	$KAME: in6_pcb.c,v 1.31 2001/05/21 05:45:10 jinmei Exp $
34  */
35 
36 /*-
37  * Copyright (c) 1982, 1986, 1991, 1993
38  *	The Regents of the University of California.  All rights reserved.
39  *
40  * Redistribution and use in source and binary forms, with or without
41  * modification, are permitted provided that the following conditions
42  * are met:
43  * 1. Redistributions of source code must retain the above copyright
44  *    notice, this list of conditions and the following disclaimer.
45  * 2. Redistributions in binary form must reproduce the above copyright
46  *    notice, this list of conditions and the following disclaimer in the
47  *    documentation and/or other materials provided with the distribution.
48  * 4. Neither the name of the University nor the names of its contributors
49  *    may be used to endorse or promote products derived from this software
50  *    without specific prior written permission.
51  *
52  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
53  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
54  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
55  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
56  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
57  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
58  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
59  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
60  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
61  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
62  * SUCH DAMAGE.
63  *
64  *	@(#)in_pcb.c	8.2 (Berkeley) 1/4/94
65  */
66 
67 #include <sys/cdefs.h>
68 __FBSDID("$FreeBSD$");
69 
70 #include "opt_inet.h"
71 #include "opt_inet6.h"
72 #include "opt_ipsec.h"
73 #include "opt_pcbgroup.h"
74 #include "opt_rss.h"
75 
76 #include <sys/param.h>
77 #include <sys/systm.h>
78 #include <sys/malloc.h>
79 #include <sys/mbuf.h>
80 #include <sys/domain.h>
81 #include <sys/protosw.h>
82 #include <sys/socket.h>
83 #include <sys/socketvar.h>
84 #include <sys/sockio.h>
85 #include <sys/errno.h>
86 #include <sys/time.h>
87 #include <sys/priv.h>
88 #include <sys/proc.h>
89 #include <sys/jail.h>
90 
91 #include <vm/uma.h>
92 
93 #include <net/if.h>
94 #include <net/if_var.h>
95 #include <net/if_types.h>
96 #include <net/route.h>
97 
98 #include <netinet/in.h>
99 #include <netinet/in_var.h>
100 #include <netinet/in_systm.h>
101 #include <netinet/tcp_var.h>
102 #include <netinet/ip6.h>
103 #include <netinet/ip_var.h>
104 
105 #include <netinet6/ip6_var.h>
106 #include <netinet6/nd6.h>
107 #include <netinet/in_pcb.h>
108 #include <netinet6/in6_pcb.h>
109 #include <netinet6/scope6_var.h>
110 
111 static struct inpcb *in6_pcblookup_hash_locked(struct inpcbinfo *,
112     struct in6_addr *, u_int, struct in6_addr *, u_int, int, struct ifnet *);
113 
114 int
115 in6_pcbbind(register struct inpcb *inp, struct sockaddr *nam,
116     struct ucred *cred)
117 {
118 	struct socket *so = inp->inp_socket;
119 	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)NULL;
120 	struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
121 	u_short	lport = 0;
122 	int error, lookupflags = 0;
123 	int reuseport = (so->so_options & SO_REUSEPORT);
124 
125 	INP_WLOCK_ASSERT(inp);
126 	INP_HASH_WLOCK_ASSERT(pcbinfo);
127 
128 	if (TAILQ_EMPTY(&V_in6_ifaddrhead))	/* XXX broken! */
129 		return (EADDRNOTAVAIL);
130 	if (inp->inp_lport || !IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr))
131 		return (EINVAL);
132 	if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) == 0)
133 		lookupflags = INPLOOKUP_WILDCARD;
134 	if (nam == NULL) {
135 		if ((error = prison_local_ip6(cred, &inp->in6p_laddr,
136 		    ((inp->inp_flags & IN6P_IPV6_V6ONLY) != 0))) != 0)
137 			return (error);
138 	} else {
139 		sin6 = (struct sockaddr_in6 *)nam;
140 		if (nam->sa_len != sizeof(*sin6))
141 			return (EINVAL);
142 		/*
143 		 * family check.
144 		 */
145 		if (nam->sa_family != AF_INET6)
146 			return (EAFNOSUPPORT);
147 
148 		if ((error = sa6_embedscope(sin6, V_ip6_use_defzone)) != 0)
149 			return(error);
150 
151 		if ((error = prison_local_ip6(cred, &sin6->sin6_addr,
152 		    ((inp->inp_flags & IN6P_IPV6_V6ONLY) != 0))) != 0)
153 			return (error);
154 
155 		lport = sin6->sin6_port;
156 		if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) {
157 			/*
158 			 * Treat SO_REUSEADDR as SO_REUSEPORT for multicast;
159 			 * allow compepte duplication of binding if
160 			 * SO_REUSEPORT is set, or if SO_REUSEADDR is set
161 			 * and a multicast address is bound on both
162 			 * new and duplicated sockets.
163 			 */
164 			if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) != 0)
165 				reuseport = SO_REUSEADDR|SO_REUSEPORT;
166 		} else if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
167 			struct ifaddr *ifa;
168 
169 			sin6->sin6_port = 0;		/* yech... */
170 			if ((ifa = ifa_ifwithaddr((struct sockaddr *)sin6)) ==
171 			    NULL &&
172 			    (inp->inp_flags & INP_BINDANY) == 0) {
173 				return (EADDRNOTAVAIL);
174 			}
175 
176 			/*
177 			 * XXX: bind to an anycast address might accidentally
178 			 * cause sending a packet with anycast source address.
179 			 * We should allow to bind to a deprecated address, since
180 			 * the application dares to use it.
181 			 */
182 			if (ifa != NULL &&
183 			    ((struct in6_ifaddr *)ifa)->ia6_flags &
184 			    (IN6_IFF_ANYCAST|IN6_IFF_NOTREADY|IN6_IFF_DETACHED)) {
185 				ifa_free(ifa);
186 				return (EADDRNOTAVAIL);
187 			}
188 			if (ifa != NULL)
189 				ifa_free(ifa);
190 		}
191 		if (lport) {
192 			struct inpcb *t;
193 			struct tcptw *tw;
194 
195 			/* GROSS */
196 			if (ntohs(lport) <= V_ipport_reservedhigh &&
197 			    ntohs(lport) >= V_ipport_reservedlow &&
198 			    priv_check_cred(cred, PRIV_NETINET_RESERVEDPORT,
199 			    0))
200 				return (EACCES);
201 			if (!IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr) &&
202 			    priv_check_cred(inp->inp_cred,
203 			    PRIV_NETINET_REUSEPORT, 0) != 0) {
204 				t = in6_pcblookup_local(pcbinfo,
205 				    &sin6->sin6_addr, lport,
206 				    INPLOOKUP_WILDCARD, cred);
207 				if (t &&
208 				    ((inp->inp_flags2 & INP_BINDMULTI) == 0) &&
209 				    ((t->inp_flags & INP_TIMEWAIT) == 0) &&
210 				    (so->so_type != SOCK_STREAM ||
211 				     IN6_IS_ADDR_UNSPECIFIED(&t->in6p_faddr)) &&
212 				    (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) ||
213 				     !IN6_IS_ADDR_UNSPECIFIED(&t->in6p_laddr) ||
214 				     (t->inp_flags2 & INP_REUSEPORT) == 0) &&
215 				    (inp->inp_cred->cr_uid !=
216 				     t->inp_cred->cr_uid))
217 					return (EADDRINUSE);
218 
219 				/*
220 				 * If the socket is a BINDMULTI socket, then
221 				 * the credentials need to match and the
222 				 * original socket also has to have been bound
223 				 * with BINDMULTI.
224 				 */
225 				if (t && (! in_pcbbind_check_bindmulti(inp, t)))
226 					return (EADDRINUSE);
227 
228 #ifdef INET
229 				if ((inp->inp_flags & IN6P_IPV6_V6ONLY) == 0 &&
230 				    IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
231 					struct sockaddr_in sin;
232 
233 					in6_sin6_2_sin(&sin, sin6);
234 					t = in_pcblookup_local(pcbinfo,
235 					    sin.sin_addr, lport,
236 					    INPLOOKUP_WILDCARD, cred);
237 					if (t &&
238 					    ((inp->inp_flags2 & INP_BINDMULTI) == 0) &&
239 					    ((t->inp_flags &
240 					      INP_TIMEWAIT) == 0) &&
241 					    (so->so_type != SOCK_STREAM ||
242 					     ntohl(t->inp_faddr.s_addr) ==
243 					      INADDR_ANY) &&
244 					    (inp->inp_cred->cr_uid !=
245 					     t->inp_cred->cr_uid))
246 						return (EADDRINUSE);
247 
248 					if (t && (! in_pcbbind_check_bindmulti(inp, t)))
249 						return (EADDRINUSE);
250 				}
251 #endif
252 			}
253 			t = in6_pcblookup_local(pcbinfo, &sin6->sin6_addr,
254 			    lport, lookupflags, cred);
255 			if (t && (t->inp_flags & INP_TIMEWAIT)) {
256 				/*
257 				 * XXXRW: If an incpb has had its timewait
258 				 * state recycled, we treat the address as
259 				 * being in use (for now).  This is better
260 				 * than a panic, but not desirable.
261 				 */
262 				tw = intotw(t);
263 				if (tw == NULL ||
264 				    (reuseport & tw->tw_so_options) == 0)
265 					return (EADDRINUSE);
266 			} else if (t && (reuseport & inp_so_options(t)) == 0) {
267 				return (EADDRINUSE);
268 			}
269 #ifdef INET
270 			if ((inp->inp_flags & IN6P_IPV6_V6ONLY) == 0 &&
271 			    IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
272 				struct sockaddr_in sin;
273 
274 				in6_sin6_2_sin(&sin, sin6);
275 				t = in_pcblookup_local(pcbinfo, sin.sin_addr,
276 				    lport, lookupflags, cred);
277 				if (t && t->inp_flags & INP_TIMEWAIT) {
278 					tw = intotw(t);
279 					if (tw == NULL)
280 						return (EADDRINUSE);
281 					if ((reuseport & tw->tw_so_options) == 0
282 					    && (ntohl(t->inp_laddr.s_addr) !=
283 					     INADDR_ANY || ((inp->inp_vflag &
284 					     INP_IPV6PROTO) ==
285 					     (t->inp_vflag & INP_IPV6PROTO))))
286 						return (EADDRINUSE);
287 				} else if (t &&
288 				    (reuseport & inp_so_options(t)) == 0 &&
289 				    (ntohl(t->inp_laddr.s_addr) != INADDR_ANY ||
290 				    (t->inp_vflag & INP_IPV6PROTO) != 0))
291 					return (EADDRINUSE);
292 			}
293 #endif
294 		}
295 		inp->in6p_laddr = sin6->sin6_addr;
296 	}
297 	if (lport == 0) {
298 		if ((error = in6_pcbsetport(&inp->in6p_laddr, inp, cred)) != 0) {
299 			/* Undo an address bind that may have occurred. */
300 			inp->in6p_laddr = in6addr_any;
301 			return (error);
302 		}
303 	} else {
304 		inp->inp_lport = lport;
305 		if (in_pcbinshash(inp) != 0) {
306 			inp->in6p_laddr = in6addr_any;
307 			inp->inp_lport = 0;
308 			return (EAGAIN);
309 		}
310 	}
311 	return (0);
312 }
313 
314 /*
315  *   Transform old in6_pcbconnect() into an inner subroutine for new
316  *   in6_pcbconnect(): Do some validity-checking on the remote
317  *   address (in mbuf 'nam') and then determine local host address
318  *   (i.e., which interface) to use to access that remote host.
319  *
320  *   This preserves definition of in6_pcbconnect(), while supporting a
321  *   slightly different version for T/TCP.  (This is more than
322  *   a bit of a kludge, but cleaning up the internal interfaces would
323  *   have forced minor changes in every protocol).
324  */
325 static int
326 in6_pcbladdr(register struct inpcb *inp, struct sockaddr *nam,
327     struct in6_addr *plocal_addr6)
328 {
329 	register struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)nam;
330 	int error = 0;
331 	struct ifnet *ifp = NULL;
332 	int scope_ambiguous = 0;
333 	struct in6_addr in6a;
334 
335 	INP_WLOCK_ASSERT(inp);
336 	INP_HASH_WLOCK_ASSERT(inp->inp_pcbinfo);	/* XXXRW: why? */
337 
338 	if (nam->sa_len != sizeof (*sin6))
339 		return (EINVAL);
340 	if (sin6->sin6_family != AF_INET6)
341 		return (EAFNOSUPPORT);
342 	if (sin6->sin6_port == 0)
343 		return (EADDRNOTAVAIL);
344 
345 	if (sin6->sin6_scope_id == 0 && !V_ip6_use_defzone)
346 		scope_ambiguous = 1;
347 	if ((error = sa6_embedscope(sin6, V_ip6_use_defzone)) != 0)
348 		return(error);
349 
350 	if (!TAILQ_EMPTY(&V_in6_ifaddrhead)) {
351 		/*
352 		 * If the destination address is UNSPECIFIED addr,
353 		 * use the loopback addr, e.g ::1.
354 		 */
355 		if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr))
356 			sin6->sin6_addr = in6addr_loopback;
357 	}
358 	if ((error = prison_remote_ip6(inp->inp_cred, &sin6->sin6_addr)) != 0)
359 		return (error);
360 
361 	error = in6_selectsrc(sin6, inp->in6p_outputopts,
362 	    inp, NULL, inp->inp_cred, &ifp, &in6a);
363 	if (error)
364 		return (error);
365 
366 	if (ifp && scope_ambiguous &&
367 	    (error = in6_setscope(&sin6->sin6_addr, ifp, NULL)) != 0) {
368 		return(error);
369 	}
370 
371 	/*
372 	 * Do not update this earlier, in case we return with an error.
373 	 *
374 	 * XXX: this in6_selectsrc result might replace the bound local
375 	 * address with the address specified by setsockopt(IPV6_PKTINFO).
376 	 * Is it the intended behavior?
377 	 */
378 	*plocal_addr6 = in6a;
379 
380 	/*
381 	 * Don't do pcblookup call here; return interface in
382 	 * plocal_addr6
383 	 * and exit to caller, that will do the lookup.
384 	 */
385 
386 	return (0);
387 }
388 
389 /*
390  * Outer subroutine:
391  * Connect from a socket to a specified address.
392  * Both address and port must be specified in argument sin.
393  * If don't have a local address for this socket yet,
394  * then pick one.
395  */
396 int
397 in6_pcbconnect_mbuf(register struct inpcb *inp, struct sockaddr *nam,
398     struct ucred *cred, struct mbuf *m)
399 {
400 	struct inpcbinfo *pcbinfo = inp->inp_pcbinfo;
401 	register struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)nam;
402 	struct in6_addr addr6;
403 	int error;
404 
405 	INP_WLOCK_ASSERT(inp);
406 	INP_HASH_WLOCK_ASSERT(pcbinfo);
407 
408 	/*
409 	 * Call inner routine, to assign local interface address.
410 	 * in6_pcbladdr() may automatically fill in sin6_scope_id.
411 	 */
412 	if ((error = in6_pcbladdr(inp, nam, &addr6)) != 0)
413 		return (error);
414 
415 	if (in6_pcblookup_hash_locked(pcbinfo, &sin6->sin6_addr,
416 			       sin6->sin6_port,
417 			      IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)
418 			      ? &addr6 : &inp->in6p_laddr,
419 			      inp->inp_lport, 0, NULL) != NULL) {
420 		return (EADDRINUSE);
421 	}
422 	if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)) {
423 		if (inp->inp_lport == 0) {
424 			error = in6_pcbbind(inp, (struct sockaddr *)0, cred);
425 			if (error)
426 				return (error);
427 		}
428 		inp->in6p_laddr = addr6;
429 	}
430 	inp->in6p_faddr = sin6->sin6_addr;
431 	inp->inp_fport = sin6->sin6_port;
432 	/* update flowinfo - draft-itojun-ipv6-flowlabel-api-00 */
433 	inp->inp_flow &= ~IPV6_FLOWLABEL_MASK;
434 	if (inp->inp_flags & IN6P_AUTOFLOWLABEL)
435 		inp->inp_flow |=
436 		    (htonl(ip6_randomflowlabel()) & IPV6_FLOWLABEL_MASK);
437 
438 	in_pcbrehash_mbuf(inp, m);
439 
440 	return (0);
441 }
442 
443 int
444 in6_pcbconnect(struct inpcb *inp, struct sockaddr *nam, struct ucred *cred)
445 {
446 
447 	return (in6_pcbconnect_mbuf(inp, nam, cred, NULL));
448 }
449 
450 void
451 in6_pcbdisconnect(struct inpcb *inp)
452 {
453 
454 	INP_WLOCK_ASSERT(inp);
455 	INP_HASH_WLOCK_ASSERT(inp->inp_pcbinfo);
456 
457 	bzero((caddr_t)&inp->in6p_faddr, sizeof(inp->in6p_faddr));
458 	inp->inp_fport = 0;
459 	/* clear flowinfo - draft-itojun-ipv6-flowlabel-api-00 */
460 	inp->inp_flow &= ~IPV6_FLOWLABEL_MASK;
461 	in_pcbrehash(inp);
462 }
463 
464 struct sockaddr *
465 in6_sockaddr(in_port_t port, struct in6_addr *addr_p)
466 {
467 	struct sockaddr_in6 *sin6;
468 
469 	sin6 = malloc(sizeof *sin6, M_SONAME, M_WAITOK);
470 	bzero(sin6, sizeof *sin6);
471 	sin6->sin6_family = AF_INET6;
472 	sin6->sin6_len = sizeof(*sin6);
473 	sin6->sin6_port = port;
474 	sin6->sin6_addr = *addr_p;
475 	(void)sa6_recoverscope(sin6); /* XXX: should catch errors */
476 
477 	return (struct sockaddr *)sin6;
478 }
479 
480 struct sockaddr *
481 in6_v4mapsin6_sockaddr(in_port_t port, struct in_addr *addr_p)
482 {
483 	struct sockaddr_in sin;
484 	struct sockaddr_in6 *sin6_p;
485 
486 	bzero(&sin, sizeof sin);
487 	sin.sin_family = AF_INET;
488 	sin.sin_len = sizeof(sin);
489 	sin.sin_port = port;
490 	sin.sin_addr = *addr_p;
491 
492 	sin6_p = malloc(sizeof *sin6_p, M_SONAME,
493 		M_WAITOK);
494 	in6_sin_2_v4mapsin6(&sin, sin6_p);
495 
496 	return (struct sockaddr *)sin6_p;
497 }
498 
499 int
500 in6_getsockaddr(struct socket *so, struct sockaddr **nam)
501 {
502 	register struct inpcb *inp;
503 	struct in6_addr addr;
504 	in_port_t port;
505 
506 	inp = sotoinpcb(so);
507 	KASSERT(inp != NULL, ("in6_getsockaddr: inp == NULL"));
508 
509 	INP_RLOCK(inp);
510 	port = inp->inp_lport;
511 	addr = inp->in6p_laddr;
512 	INP_RUNLOCK(inp);
513 
514 	*nam = in6_sockaddr(port, &addr);
515 	return 0;
516 }
517 
518 int
519 in6_getpeeraddr(struct socket *so, struct sockaddr **nam)
520 {
521 	struct inpcb *inp;
522 	struct in6_addr addr;
523 	in_port_t port;
524 
525 	inp = sotoinpcb(so);
526 	KASSERT(inp != NULL, ("in6_getpeeraddr: inp == NULL"));
527 
528 	INP_RLOCK(inp);
529 	port = inp->inp_fport;
530 	addr = inp->in6p_faddr;
531 	INP_RUNLOCK(inp);
532 
533 	*nam = in6_sockaddr(port, &addr);
534 	return 0;
535 }
536 
537 int
538 in6_mapped_sockaddr(struct socket *so, struct sockaddr **nam)
539 {
540 	struct	inpcb *inp;
541 	int	error;
542 
543 	inp = sotoinpcb(so);
544 	KASSERT(inp != NULL, ("in6_mapped_sockaddr: inp == NULL"));
545 
546 #ifdef INET
547 	if ((inp->inp_vflag & (INP_IPV4 | INP_IPV6)) == INP_IPV4) {
548 		error = in_getsockaddr(so, nam);
549 		if (error == 0)
550 			in6_sin_2_v4mapsin6_in_sock(nam);
551 	} else
552 #endif
553 	{
554 		/* scope issues will be handled in in6_getsockaddr(). */
555 		error = in6_getsockaddr(so, nam);
556 	}
557 
558 	return error;
559 }
560 
561 int
562 in6_mapped_peeraddr(struct socket *so, struct sockaddr **nam)
563 {
564 	struct	inpcb *inp;
565 	int	error;
566 
567 	inp = sotoinpcb(so);
568 	KASSERT(inp != NULL, ("in6_mapped_peeraddr: inp == NULL"));
569 
570 #ifdef INET
571 	if ((inp->inp_vflag & (INP_IPV4 | INP_IPV6)) == INP_IPV4) {
572 		error = in_getpeeraddr(so, nam);
573 		if (error == 0)
574 			in6_sin_2_v4mapsin6_in_sock(nam);
575 	} else
576 #endif
577 	/* scope issues will be handled in in6_getpeeraddr(). */
578 	error = in6_getpeeraddr(so, nam);
579 
580 	return error;
581 }
582 
583 /*
584  * Pass some notification to all connections of a protocol
585  * associated with address dst.  The local address and/or port numbers
586  * may be specified to limit the search.  The "usual action" will be
587  * taken, depending on the ctlinput cmd.  The caller must filter any
588  * cmds that are uninteresting (e.g., no error in the map).
589  * Call the protocol specific routine (if any) to report
590  * any errors for each matching socket.
591  */
592 void
593 in6_pcbnotify(struct inpcbinfo *pcbinfo, struct sockaddr *dst,
594     u_int fport_arg, const struct sockaddr *src, u_int lport_arg,
595     int cmd, void *cmdarg,
596     struct inpcb *(*notify)(struct inpcb *, int))
597 {
598 	struct inpcb *inp, *inp_temp;
599 	struct sockaddr_in6 sa6_src, *sa6_dst;
600 	u_short	fport = fport_arg, lport = lport_arg;
601 	u_int32_t flowinfo;
602 	int errno;
603 
604 	if ((unsigned)cmd >= PRC_NCMDS || dst->sa_family != AF_INET6)
605 		return;
606 
607 	sa6_dst = (struct sockaddr_in6 *)dst;
608 	if (IN6_IS_ADDR_UNSPECIFIED(&sa6_dst->sin6_addr))
609 		return;
610 
611 	/*
612 	 * note that src can be NULL when we get notify by local fragmentation.
613 	 */
614 	sa6_src = (src == NULL) ? sa6_any : *(const struct sockaddr_in6 *)src;
615 	flowinfo = sa6_src.sin6_flowinfo;
616 
617 	/*
618 	 * Redirects go to all references to the destination,
619 	 * and use in6_rtchange to invalidate the route cache.
620 	 * Dead host indications: also use in6_rtchange to invalidate
621 	 * the cache, and deliver the error to all the sockets.
622 	 * Otherwise, if we have knowledge of the local port and address,
623 	 * deliver only to that socket.
624 	 */
625 	if (PRC_IS_REDIRECT(cmd) || cmd == PRC_HOSTDEAD) {
626 		fport = 0;
627 		lport = 0;
628 		bzero((caddr_t)&sa6_src.sin6_addr, sizeof(sa6_src.sin6_addr));
629 
630 		if (cmd != PRC_HOSTDEAD)
631 			notify = in6_rtchange;
632 	}
633 	errno = inet6ctlerrmap[cmd];
634 	INP_INFO_WLOCK(pcbinfo);
635 	LIST_FOREACH_SAFE(inp, pcbinfo->ipi_listhead, inp_list, inp_temp) {
636 		INP_WLOCK(inp);
637 		if ((inp->inp_vflag & INP_IPV6) == 0) {
638 			INP_WUNLOCK(inp);
639 			continue;
640 		}
641 
642 		/*
643 		 * If the error designates a new path MTU for a destination
644 		 * and the application (associated with this socket) wanted to
645 		 * know the value, notify. Note that we notify for all
646 		 * disconnected sockets if the corresponding application
647 		 * wanted. This is because some UDP applications keep sending
648 		 * sockets disconnected.
649 		 * XXX: should we avoid to notify the value to TCP sockets?
650 		 */
651 		if (cmd == PRC_MSGSIZE && (inp->inp_flags & IN6P_MTU) != 0 &&
652 		    (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr) ||
653 		     IN6_ARE_ADDR_EQUAL(&inp->in6p_faddr, &sa6_dst->sin6_addr))) {
654 			ip6_notify_pmtu(inp, (struct sockaddr_in6 *)dst,
655 					(u_int32_t *)cmdarg);
656 		}
657 
658 		/*
659 		 * Detect if we should notify the error. If no source and
660 		 * destination ports are specifed, but non-zero flowinfo and
661 		 * local address match, notify the error. This is the case
662 		 * when the error is delivered with an encrypted buffer
663 		 * by ESP. Otherwise, just compare addresses and ports
664 		 * as usual.
665 		 */
666 		if (lport == 0 && fport == 0 && flowinfo &&
667 		    inp->inp_socket != NULL &&
668 		    flowinfo == (inp->inp_flow & IPV6_FLOWLABEL_MASK) &&
669 		    IN6_ARE_ADDR_EQUAL(&inp->in6p_laddr, &sa6_src.sin6_addr))
670 			goto do_notify;
671 		else if (!IN6_ARE_ADDR_EQUAL(&inp->in6p_faddr,
672 					     &sa6_dst->sin6_addr) ||
673 			 inp->inp_socket == 0 ||
674 			 (lport && inp->inp_lport != lport) ||
675 			 (!IN6_IS_ADDR_UNSPECIFIED(&sa6_src.sin6_addr) &&
676 			  !IN6_ARE_ADDR_EQUAL(&inp->in6p_laddr,
677 					      &sa6_src.sin6_addr)) ||
678 			 (fport && inp->inp_fport != fport)) {
679 			INP_WUNLOCK(inp);
680 			continue;
681 		}
682 
683 	  do_notify:
684 		if (notify) {
685 			if ((*notify)(inp, errno))
686 				INP_WUNLOCK(inp);
687 		} else
688 			INP_WUNLOCK(inp);
689 	}
690 	INP_INFO_WUNLOCK(pcbinfo);
691 }
692 
693 /*
694  * Lookup a PCB based on the local address and port.  Caller must hold the
695  * hash lock.  No inpcb locks or references are acquired.
696  */
697 struct inpcb *
698 in6_pcblookup_local(struct inpcbinfo *pcbinfo, struct in6_addr *laddr,
699     u_short lport, int lookupflags, struct ucred *cred)
700 {
701 	register struct inpcb *inp;
702 	int matchwild = 3, wildcard;
703 
704 	KASSERT((lookupflags & ~(INPLOOKUP_WILDCARD)) == 0,
705 	    ("%s: invalid lookup flags %d", __func__, lookupflags));
706 
707 	INP_HASH_WLOCK_ASSERT(pcbinfo);
708 
709 	if ((lookupflags & INPLOOKUP_WILDCARD) == 0) {
710 		struct inpcbhead *head;
711 		/*
712 		 * Look for an unconnected (wildcard foreign addr) PCB that
713 		 * matches the local address and port we're looking for.
714 		 */
715 		head = &pcbinfo->ipi_hashbase[INP_PCBHASH(
716 		    INP6_PCBHASHKEY(&in6addr_any), lport, 0,
717 		    pcbinfo->ipi_hashmask)];
718 		LIST_FOREACH(inp, head, inp_hash) {
719 			/* XXX inp locking */
720 			if ((inp->inp_vflag & INP_IPV6) == 0)
721 				continue;
722 			if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr) &&
723 			    IN6_ARE_ADDR_EQUAL(&inp->in6p_laddr, laddr) &&
724 			    inp->inp_lport == lport) {
725 				/* Found. */
726 				if (cred == NULL ||
727 				    prison_equal_ip6(cred->cr_prison,
728 					inp->inp_cred->cr_prison))
729 					return (inp);
730 			}
731 		}
732 		/*
733 		 * Not found.
734 		 */
735 		return (NULL);
736 	} else {
737 		struct inpcbporthead *porthash;
738 		struct inpcbport *phd;
739 		struct inpcb *match = NULL;
740 		/*
741 		 * Best fit PCB lookup.
742 		 *
743 		 * First see if this local port is in use by looking on the
744 		 * port hash list.
745 		 */
746 		porthash = &pcbinfo->ipi_porthashbase[INP_PCBPORTHASH(lport,
747 		    pcbinfo->ipi_porthashmask)];
748 		LIST_FOREACH(phd, porthash, phd_hash) {
749 			if (phd->phd_port == lport)
750 				break;
751 		}
752 		if (phd != NULL) {
753 			/*
754 			 * Port is in use by one or more PCBs. Look for best
755 			 * fit.
756 			 */
757 			LIST_FOREACH(inp, &phd->phd_pcblist, inp_portlist) {
758 				wildcard = 0;
759 				if (cred != NULL &&
760 				    !prison_equal_ip6(cred->cr_prison,
761 					inp->inp_cred->cr_prison))
762 					continue;
763 				/* XXX inp locking */
764 				if ((inp->inp_vflag & INP_IPV6) == 0)
765 					continue;
766 				if (!IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr))
767 					wildcard++;
768 				if (!IN6_IS_ADDR_UNSPECIFIED(
769 					&inp->in6p_laddr)) {
770 					if (IN6_IS_ADDR_UNSPECIFIED(laddr))
771 						wildcard++;
772 					else if (!IN6_ARE_ADDR_EQUAL(
773 					    &inp->in6p_laddr, laddr))
774 						continue;
775 				} else {
776 					if (!IN6_IS_ADDR_UNSPECIFIED(laddr))
777 						wildcard++;
778 				}
779 				if (wildcard < matchwild) {
780 					match = inp;
781 					matchwild = wildcard;
782 					if (matchwild == 0)
783 						break;
784 				}
785 			}
786 		}
787 		return (match);
788 	}
789 }
790 
791 void
792 in6_pcbpurgeif0(struct inpcbinfo *pcbinfo, struct ifnet *ifp)
793 {
794 	struct inpcb *in6p;
795 	struct ip6_moptions *im6o;
796 	int i, gap;
797 
798 	INP_INFO_RLOCK(pcbinfo);
799 	LIST_FOREACH(in6p, pcbinfo->ipi_listhead, inp_list) {
800 		INP_WLOCK(in6p);
801 		im6o = in6p->in6p_moptions;
802 		if ((in6p->inp_vflag & INP_IPV6) && im6o != NULL) {
803 			/*
804 			 * Unselect the outgoing ifp for multicast if it
805 			 * is being detached.
806 			 */
807 			if (im6o->im6o_multicast_ifp == ifp)
808 				im6o->im6o_multicast_ifp = NULL;
809 			/*
810 			 * Drop multicast group membership if we joined
811 			 * through the interface being detached.
812 			 */
813 			gap = 0;
814 			for (i = 0; i < im6o->im6o_num_memberships; i++) {
815 				if (im6o->im6o_membership[i]->in6m_ifp ==
816 				    ifp) {
817 					in6_mc_leave(im6o->im6o_membership[i],
818 					    NULL);
819 					gap++;
820 				} else if (gap != 0) {
821 					im6o->im6o_membership[i - gap] =
822 					    im6o->im6o_membership[i];
823 				}
824 			}
825 			im6o->im6o_num_memberships -= gap;
826 		}
827 		INP_WUNLOCK(in6p);
828 	}
829 	INP_INFO_RUNLOCK(pcbinfo);
830 }
831 
832 /*
833  * Check for alternatives when higher level complains
834  * about service problems.  For now, invalidate cached
835  * routing information.  If the route was created dynamically
836  * (by a redirect), time to try a default gateway again.
837  */
838 void
839 in6_losing(struct inpcb *in6p)
840 {
841 
842 	/*
843 	 * We don't store route pointers in the routing table anymore
844 	 */
845 	return;
846 }
847 
848 /*
849  * After a routing change, flush old routing
850  * and allocate a (hopefully) better one.
851  */
852 struct inpcb *
853 in6_rtchange(struct inpcb *inp, int errno)
854 {
855 	/*
856 	 * We don't store route pointers in the routing table anymore
857 	 */
858 	return inp;
859 }
860 
861 #ifdef PCBGROUP
862 /*
863  * Lookup PCB in hash list, using pcbgroup tables.
864  */
865 static struct inpcb *
866 in6_pcblookup_group(struct inpcbinfo *pcbinfo, struct inpcbgroup *pcbgroup,
867     struct in6_addr *faddr, u_int fport_arg, struct in6_addr *laddr,
868     u_int lport_arg, int lookupflags, struct ifnet *ifp)
869 {
870 	struct inpcbhead *head;
871 	struct inpcb *inp, *tmpinp;
872 	u_short fport = fport_arg, lport = lport_arg;
873 
874 	/*
875 	 * First look for an exact match.
876 	 */
877 	tmpinp = NULL;
878 	INP_GROUP_LOCK(pcbgroup);
879 	head = &pcbgroup->ipg_hashbase[INP_PCBHASH(
880 	    INP6_PCBHASHKEY(faddr), lport, fport, pcbgroup->ipg_hashmask)];
881 	LIST_FOREACH(inp, head, inp_pcbgrouphash) {
882 		/* XXX inp locking */
883 		if ((inp->inp_vflag & INP_IPV6) == 0)
884 			continue;
885 		if (IN6_ARE_ADDR_EQUAL(&inp->in6p_faddr, faddr) &&
886 		    IN6_ARE_ADDR_EQUAL(&inp->in6p_laddr, laddr) &&
887 		    inp->inp_fport == fport &&
888 		    inp->inp_lport == lport) {
889 			/*
890 			 * XXX We should be able to directly return
891 			 * the inp here, without any checks.
892 			 * Well unless both bound with SO_REUSEPORT?
893 			 */
894 			if (prison_flag(inp->inp_cred, PR_IP6))
895 				goto found;
896 			if (tmpinp == NULL)
897 				tmpinp = inp;
898 		}
899 	}
900 	if (tmpinp != NULL) {
901 		inp = tmpinp;
902 		goto found;
903 	}
904 
905 	/*
906 	 * Then look for a wildcard match in the pcbgroup.
907 	 */
908 	if ((lookupflags & INPLOOKUP_WILDCARD) != 0) {
909 		struct inpcb *local_wild = NULL, *local_exact = NULL;
910 		struct inpcb *jail_wild = NULL;
911 		int injail;
912 
913 		/*
914 		 * Order of socket selection - we always prefer jails.
915 		 *      1. jailed, non-wild.
916 		 *      2. jailed, wild.
917 		 *      3. non-jailed, non-wild.
918 		 *      4. non-jailed, wild.
919 		 */
920 		head = &pcbgroup->ipg_hashbase[
921 		    INP_PCBHASH(INADDR_ANY, lport, 0, pcbgroup->ipg_hashmask)];
922 		LIST_FOREACH(inp, head, inp_pcbgrouphash) {
923 			/* XXX inp locking */
924 			if ((inp->inp_vflag & INP_IPV6) == 0)
925 				continue;
926 
927 			if (!IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr) ||
928 			    inp->inp_lport != lport) {
929 				continue;
930 			}
931 
932 			injail = prison_flag(inp->inp_cred, PR_IP6);
933 			if (injail) {
934 				if (prison_check_ip6(inp->inp_cred,
935 				    laddr) != 0)
936 					continue;
937 			} else {
938 				if (local_exact != NULL)
939 					continue;
940 			}
941 
942 			if (IN6_ARE_ADDR_EQUAL(&inp->in6p_laddr, laddr)) {
943 				if (injail)
944 					goto found;
945 				else
946 					local_exact = inp;
947 			} else if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)) {
948 				if (injail)
949 					jail_wild = inp;
950 				else
951 					local_wild = inp;
952 			}
953 		} /* LIST_FOREACH */
954 
955 		inp = jail_wild;
956 		if (inp == NULL)
957 			inp = jail_wild;
958 		if (inp == NULL)
959 			inp = local_exact;
960 		if (inp == NULL)
961 			inp = local_wild;
962 		if (inp != NULL)
963 			goto found;
964 	}
965 
966 	/*
967 	 * Then look for a wildcard match, if requested.
968 	 */
969 	if ((lookupflags & INPLOOKUP_WILDCARD) != 0) {
970 		struct inpcb *local_wild = NULL, *local_exact = NULL;
971 		struct inpcb *jail_wild = NULL;
972 		int injail;
973 
974 		/*
975 		 * Order of socket selection - we always prefer jails.
976 		 *      1. jailed, non-wild.
977 		 *      2. jailed, wild.
978 		 *      3. non-jailed, non-wild.
979 		 *      4. non-jailed, wild.
980 		 */
981 		head = &pcbinfo->ipi_wildbase[INP_PCBHASH(
982 		    INP6_PCBHASHKEY(&in6addr_any), lport, 0,
983 		    pcbinfo->ipi_wildmask)];
984 		LIST_FOREACH(inp, head, inp_pcbgroup_wild) {
985 			/* XXX inp locking */
986 			if ((inp->inp_vflag & INP_IPV6) == 0)
987 				continue;
988 
989 			if (!IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr) ||
990 			    inp->inp_lport != lport) {
991 				continue;
992 			}
993 
994 			injail = prison_flag(inp->inp_cred, PR_IP6);
995 			if (injail) {
996 				if (prison_check_ip6(inp->inp_cred,
997 				    laddr) != 0)
998 					continue;
999 			} else {
1000 				if (local_exact != NULL)
1001 					continue;
1002 			}
1003 
1004 			if (IN6_ARE_ADDR_EQUAL(&inp->in6p_laddr, laddr)) {
1005 				if (injail)
1006 					goto found;
1007 				else
1008 					local_exact = inp;
1009 			} else if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)) {
1010 				if (injail)
1011 					jail_wild = inp;
1012 				else
1013 					local_wild = inp;
1014 			}
1015 		} /* LIST_FOREACH */
1016 
1017 		inp = jail_wild;
1018 		if (inp == NULL)
1019 			inp = jail_wild;
1020 		if (inp == NULL)
1021 			inp = local_exact;
1022 		if (inp == NULL)
1023 			inp = local_wild;
1024 		if (inp != NULL)
1025 			goto found;
1026 	} /* if ((lookupflags & INPLOOKUP_WILDCARD) != 0) */
1027 	INP_GROUP_UNLOCK(pcbgroup);
1028 	return (NULL);
1029 
1030 found:
1031 	in_pcbref(inp);
1032 	INP_GROUP_UNLOCK(pcbgroup);
1033 	if (lookupflags & INPLOOKUP_WLOCKPCB) {
1034 		INP_WLOCK(inp);
1035 		if (in_pcbrele_wlocked(inp))
1036 			return (NULL);
1037 	} else if (lookupflags & INPLOOKUP_RLOCKPCB) {
1038 		INP_RLOCK(inp);
1039 		if (in_pcbrele_rlocked(inp))
1040 			return (NULL);
1041 	} else
1042 		panic("%s: locking buf", __func__);
1043 	return (inp);
1044 }
1045 #endif /* PCBGROUP */
1046 
1047 /*
1048  * Lookup PCB in hash list.
1049  */
1050 static struct inpcb *
1051 in6_pcblookup_hash_locked(struct inpcbinfo *pcbinfo, struct in6_addr *faddr,
1052     u_int fport_arg, struct in6_addr *laddr, u_int lport_arg,
1053     int lookupflags, struct ifnet *ifp)
1054 {
1055 	struct inpcbhead *head;
1056 	struct inpcb *inp, *tmpinp;
1057 	u_short fport = fport_arg, lport = lport_arg;
1058 
1059 	KASSERT((lookupflags & ~(INPLOOKUP_WILDCARD)) == 0,
1060 	    ("%s: invalid lookup flags %d", __func__, lookupflags));
1061 
1062 	INP_HASH_LOCK_ASSERT(pcbinfo);
1063 
1064 	/*
1065 	 * First look for an exact match.
1066 	 */
1067 	tmpinp = NULL;
1068 	head = &pcbinfo->ipi_hashbase[INP_PCBHASH(
1069 	    INP6_PCBHASHKEY(faddr), lport, fport, pcbinfo->ipi_hashmask)];
1070 	LIST_FOREACH(inp, head, inp_hash) {
1071 		/* XXX inp locking */
1072 		if ((inp->inp_vflag & INP_IPV6) == 0)
1073 			continue;
1074 		if (IN6_ARE_ADDR_EQUAL(&inp->in6p_faddr, faddr) &&
1075 		    IN6_ARE_ADDR_EQUAL(&inp->in6p_laddr, laddr) &&
1076 		    inp->inp_fport == fport &&
1077 		    inp->inp_lport == lport) {
1078 			/*
1079 			 * XXX We should be able to directly return
1080 			 * the inp here, without any checks.
1081 			 * Well unless both bound with SO_REUSEPORT?
1082 			 */
1083 			if (prison_flag(inp->inp_cred, PR_IP6))
1084 				return (inp);
1085 			if (tmpinp == NULL)
1086 				tmpinp = inp;
1087 		}
1088 	}
1089 	if (tmpinp != NULL)
1090 		return (tmpinp);
1091 
1092 	/*
1093 	 * Then look for a wildcard match, if requested.
1094 	 */
1095 	if ((lookupflags & INPLOOKUP_WILDCARD) != 0) {
1096 		struct inpcb *local_wild = NULL, *local_exact = NULL;
1097 		struct inpcb *jail_wild = NULL;
1098 		int injail;
1099 
1100 		/*
1101 		 * Order of socket selection - we always prefer jails.
1102 		 *      1. jailed, non-wild.
1103 		 *      2. jailed, wild.
1104 		 *      3. non-jailed, non-wild.
1105 		 *      4. non-jailed, wild.
1106 		 */
1107 		head = &pcbinfo->ipi_hashbase[INP_PCBHASH(
1108 		    INP6_PCBHASHKEY(&in6addr_any), lport, 0,
1109 		    pcbinfo->ipi_hashmask)];
1110 		LIST_FOREACH(inp, head, inp_hash) {
1111 			/* XXX inp locking */
1112 			if ((inp->inp_vflag & INP_IPV6) == 0)
1113 				continue;
1114 
1115 			if (!IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr) ||
1116 			    inp->inp_lport != lport) {
1117 				continue;
1118 			}
1119 
1120 			injail = prison_flag(inp->inp_cred, PR_IP6);
1121 			if (injail) {
1122 				if (prison_check_ip6(inp->inp_cred,
1123 				    laddr) != 0)
1124 					continue;
1125 			} else {
1126 				if (local_exact != NULL)
1127 					continue;
1128 			}
1129 
1130 			if (IN6_ARE_ADDR_EQUAL(&inp->in6p_laddr, laddr)) {
1131 				if (injail)
1132 					return (inp);
1133 				else
1134 					local_exact = inp;
1135 			} else if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)) {
1136 				if (injail)
1137 					jail_wild = inp;
1138 				else
1139 					local_wild = inp;
1140 			}
1141 		} /* LIST_FOREACH */
1142 
1143 		if (jail_wild != NULL)
1144 			return (jail_wild);
1145 		if (local_exact != NULL)
1146 			return (local_exact);
1147 		if (local_wild != NULL)
1148 			return (local_wild);
1149 	} /* if ((lookupflags & INPLOOKUP_WILDCARD) != 0) */
1150 
1151 	/*
1152 	 * Not found.
1153 	 */
1154 	return (NULL);
1155 }
1156 
1157 /*
1158  * Lookup PCB in hash list, using pcbinfo tables.  This variation locks the
1159  * hash list lock, and will return the inpcb locked (i.e., requires
1160  * INPLOOKUP_LOCKPCB).
1161  */
1162 static struct inpcb *
1163 in6_pcblookup_hash(struct inpcbinfo *pcbinfo, struct in6_addr *faddr,
1164     u_int fport, struct in6_addr *laddr, u_int lport, int lookupflags,
1165     struct ifnet *ifp)
1166 {
1167 	struct inpcb *inp;
1168 
1169 	INP_HASH_RLOCK(pcbinfo);
1170 	inp = in6_pcblookup_hash_locked(pcbinfo, faddr, fport, laddr, lport,
1171 	    (lookupflags & ~(INPLOOKUP_RLOCKPCB | INPLOOKUP_WLOCKPCB)), ifp);
1172 	if (inp != NULL) {
1173 		in_pcbref(inp);
1174 		INP_HASH_RUNLOCK(pcbinfo);
1175 		if (lookupflags & INPLOOKUP_WLOCKPCB) {
1176 			INP_WLOCK(inp);
1177 			if (in_pcbrele_wlocked(inp))
1178 				return (NULL);
1179 		} else if (lookupflags & INPLOOKUP_RLOCKPCB) {
1180 			INP_RLOCK(inp);
1181 			if (in_pcbrele_rlocked(inp))
1182 				return (NULL);
1183 		} else
1184 			panic("%s: locking bug", __func__);
1185 	} else
1186 		INP_HASH_RUNLOCK(pcbinfo);
1187 	return (inp);
1188 }
1189 
1190 /*
1191  * Public inpcb lookup routines, accepting a 4-tuple, and optionally, an mbuf
1192  * from which a pre-calculated hash value may be extracted.
1193  *
1194  * Possibly more of this logic should be in in6_pcbgroup.c.
1195  */
1196 struct inpcb *
1197 in6_pcblookup(struct inpcbinfo *pcbinfo, struct in6_addr *faddr, u_int fport,
1198     struct in6_addr *laddr, u_int lport, int lookupflags, struct ifnet *ifp)
1199 {
1200 #if defined(PCBGROUP) && !defined(RSS)
1201 	struct inpcbgroup *pcbgroup;
1202 #endif
1203 
1204 	KASSERT((lookupflags & ~INPLOOKUP_MASK) == 0,
1205 	    ("%s: invalid lookup flags %d", __func__, lookupflags));
1206 	KASSERT((lookupflags & (INPLOOKUP_RLOCKPCB | INPLOOKUP_WLOCKPCB)) != 0,
1207 	    ("%s: LOCKPCB not set", __func__));
1208 
1209 	/*
1210 	 * When not using RSS, use connection groups in preference to the
1211 	 * reservation table when looking up 4-tuples.  When using RSS, just
1212 	 * use the reservation table, due to the cost of the Toeplitz hash
1213 	 * in software.
1214 	 *
1215 	 * XXXRW: This policy belongs in the pcbgroup code, as in principle
1216 	 * we could be doing RSS with a non-Toeplitz hash that is affordable
1217 	 * in software.
1218 	 */
1219 #if defined(PCBGROUP) && !defined(RSS)
1220 	if (in_pcbgroup_enabled(pcbinfo)) {
1221 		pcbgroup = in6_pcbgroup_bytuple(pcbinfo, laddr, lport, faddr,
1222 		    fport);
1223 		return (in6_pcblookup_group(pcbinfo, pcbgroup, faddr, fport,
1224 		    laddr, lport, lookupflags, ifp));
1225 	}
1226 #endif
1227 	return (in6_pcblookup_hash(pcbinfo, faddr, fport, laddr, lport,
1228 	    lookupflags, ifp));
1229 }
1230 
1231 struct inpcb *
1232 in6_pcblookup_mbuf(struct inpcbinfo *pcbinfo, struct in6_addr *faddr,
1233     u_int fport, struct in6_addr *laddr, u_int lport, int lookupflags,
1234     struct ifnet *ifp, struct mbuf *m)
1235 {
1236 #ifdef PCBGROUP
1237 	struct inpcbgroup *pcbgroup;
1238 #endif
1239 
1240 	KASSERT((lookupflags & ~INPLOOKUP_MASK) == 0,
1241 	    ("%s: invalid lookup flags %d", __func__, lookupflags));
1242 	KASSERT((lookupflags & (INPLOOKUP_RLOCKPCB | INPLOOKUP_WLOCKPCB)) != 0,
1243 	    ("%s: LOCKPCB not set", __func__));
1244 
1245 #ifdef PCBGROUP
1246 	/*
1247 	 * If we can use a hardware-generated hash to look up the connection
1248 	 * group, use that connection group to find the inpcb.  Otherwise
1249 	 * fall back on a software hash -- or the reservation table if we're
1250 	 * using RSS.
1251 	 *
1252 	 * XXXRW: As above, that policy belongs in the pcbgroup code.
1253 	 */
1254 	if (in_pcbgroup_enabled(pcbinfo) &&
1255 	    M_HASHTYPE_TEST(m, M_HASHTYPE_NONE) == 0) {
1256 		pcbgroup = in6_pcbgroup_byhash(pcbinfo, M_HASHTYPE_GET(m),
1257 		    m->m_pkthdr.flowid);
1258 		if (pcbgroup != NULL)
1259 			return (in6_pcblookup_group(pcbinfo, pcbgroup, faddr,
1260 			    fport, laddr, lport, lookupflags, ifp));
1261 #ifndef RSS
1262 		pcbgroup = in6_pcbgroup_bytuple(pcbinfo, laddr, lport, faddr,
1263 		    fport);
1264 		return (in6_pcblookup_group(pcbinfo, pcbgroup, faddr, fport,
1265 		    laddr, lport, lookupflags, ifp));
1266 #endif
1267 	}
1268 #endif
1269 	return (in6_pcblookup_hash(pcbinfo, faddr, fport, laddr, lport,
1270 	    lookupflags, ifp));
1271 }
1272 
1273 void
1274 init_sin6(struct sockaddr_in6 *sin6, struct mbuf *m)
1275 {
1276 	struct ip6_hdr *ip;
1277 
1278 	ip = mtod(m, struct ip6_hdr *);
1279 	bzero(sin6, sizeof(*sin6));
1280 	sin6->sin6_len = sizeof(*sin6);
1281 	sin6->sin6_family = AF_INET6;
1282 	sin6->sin6_addr = ip->ip6_src;
1283 
1284 	(void)sa6_recoverscope(sin6); /* XXX: should catch errors... */
1285 
1286 	return;
1287 }
1288