xref: /freebsd/sys/netinet6/udp6_usrreq.c (revision 25ecdc7d52770caf1c9b44b5ec11f468f6b636f3)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
5  * Copyright (c) 2010-2011 Juniper Networks, Inc.
6  * Copyright (c) 2014 Kevin Lo
7  * All rights reserved.
8  *
9  * Portions of this software were developed by Robert N. M. Watson under
10  * contract to Juniper Networks, Inc.
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions and the following disclaimer.
17  * 2. Redistributions in binary form must reproduce the above copyright
18  *    notice, this list of conditions and the following disclaimer in the
19  *    documentation and/or other materials provided with the distribution.
20  * 3. Neither the name of the project nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  *	$KAME: udp6_usrreq.c,v 1.27 2001/05/21 05:45:10 jinmei Exp $
37  *	$KAME: udp6_output.c,v 1.31 2001/05/21 16:39:15 jinmei Exp $
38  */
39 
40 /*-
41  * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
42  *	The Regents of the University of California.
43  * All rights reserved.
44  *
45  * Redistribution and use in source and binary forms, with or without
46  * modification, are permitted provided that the following conditions
47  * are met:
48  * 1. Redistributions of source code must retain the above copyright
49  *    notice, this list of conditions and the following disclaimer.
50  * 2. Redistributions in binary form must reproduce the above copyright
51  *    notice, this list of conditions and the following disclaimer in the
52  *    documentation and/or other materials provided with the distribution.
53  * 3. Neither the name of the University nor the names of its contributors
54  *    may be used to endorse or promote products derived from this software
55  *    without specific prior written permission.
56  *
57  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
58  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
59  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
60  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
61  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
62  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
63  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
64  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
65  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
66  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
67  * SUCH DAMAGE.
68  *
69  *	@(#)udp_usrreq.c	8.6 (Berkeley) 5/23/95
70  */
71 
72 #include <sys/cdefs.h>
73 __FBSDID("$FreeBSD$");
74 
75 #include "opt_inet.h"
76 #include "opt_inet6.h"
77 #include "opt_ipsec.h"
78 #include "opt_route.h"
79 #include "opt_rss.h"
80 
81 #include <sys/param.h>
82 #include <sys/jail.h>
83 #include <sys/kernel.h>
84 #include <sys/lock.h>
85 #include <sys/mbuf.h>
86 #include <sys/priv.h>
87 #include <sys/proc.h>
88 #include <sys/protosw.h>
89 #include <sys/sdt.h>
90 #include <sys/signalvar.h>
91 #include <sys/socket.h>
92 #include <sys/socketvar.h>
93 #include <sys/sx.h>
94 #include <sys/sysctl.h>
95 #include <sys/syslog.h>
96 #include <sys/systm.h>
97 
98 #include <net/if.h>
99 #include <net/if_var.h>
100 #include <net/if_types.h>
101 #include <net/route.h>
102 #include <net/rss_config.h>
103 
104 #include <netinet/in.h>
105 #include <netinet/in_kdtrace.h>
106 #include <netinet/in_pcb.h>
107 #include <netinet/in_systm.h>
108 #include <netinet/in_var.h>
109 #include <netinet/ip.h>
110 #include <netinet/ip6.h>
111 #include <netinet/icmp6.h>
112 #include <netinet/ip_var.h>
113 #include <netinet/udp.h>
114 #include <netinet/udp_var.h>
115 #include <netinet/udplite.h>
116 
117 #include <netinet6/ip6protosw.h>
118 #include <netinet6/ip6_var.h>
119 #include <netinet6/in6_fib.h>
120 #include <netinet6/in6_pcb.h>
121 #include <netinet6/in6_rss.h>
122 #include <netinet6/udp6_var.h>
123 #include <netinet6/scope6_var.h>
124 
125 #include <netipsec/ipsec_support.h>
126 
127 #include <security/mac/mac_framework.h>
128 
129 VNET_DEFINE(int, zero_checksum_port) = 0;
130 #define	V_zero_checksum_port	VNET(zero_checksum_port)
131 SYSCTL_INT(_net_inet6_udp6, OID_AUTO, rfc6935_port, CTLFLAG_VNET | CTLFLAG_RW,
132     &VNET_NAME(zero_checksum_port), 0,
133     "Zero UDP checksum allowed for traffic to/from this port.");
134 /*
135  * UDP protocol implementation.
136  * Per RFC 768, August, 1980.
137  */
138 
139 extern struct protosw	inetsw[];
140 static void		udp6_detach(struct socket *so);
141 
142 static int
143 udp6_append(struct inpcb *inp, struct mbuf *n, int off,
144     struct sockaddr_in6 *fromsa)
145 {
146 	struct socket *so;
147 	struct mbuf *opts = NULL, *tmp_opts;
148 	struct udpcb *up;
149 
150 	INP_LOCK_ASSERT(inp);
151 
152 	/*
153 	 * Engage the tunneling protocol.
154 	 */
155 	up = intoudpcb(inp);
156 	if (up->u_tun_func != NULL) {
157 		in_pcbref(inp);
158 		INP_RUNLOCK(inp);
159 		(*up->u_tun_func)(n, off, inp, (struct sockaddr *)&fromsa[0],
160 		    up->u_tun_ctx);
161 		INP_RLOCK(inp);
162 		return (in_pcbrele_rlocked(inp));
163 	}
164 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
165 	/* Check AH/ESP integrity. */
166 	if (IPSEC_ENABLED(ipv6)) {
167 		if (IPSEC_CHECK_POLICY(ipv6, n, inp) != 0) {
168 			m_freem(n);
169 			return (0);
170 		}
171 	}
172 #endif /* IPSEC */
173 #ifdef MAC
174 	if (mac_inpcb_check_deliver(inp, n) != 0) {
175 		m_freem(n);
176 		return (0);
177 	}
178 #endif
179 	opts = NULL;
180 	if (inp->inp_flags & INP_CONTROLOPTS ||
181 	    inp->inp_socket->so_options & SO_TIMESTAMP)
182 		ip6_savecontrol(inp, n, &opts);
183 	if ((inp->inp_vflag & INP_IPV6) && (inp->inp_flags2 & INP_ORIGDSTADDR)) {
184 		tmp_opts = sbcreatecontrol((caddr_t)&fromsa[1],
185                         sizeof(struct sockaddr_in6), IPV6_ORIGDSTADDR, IPPROTO_IPV6);
186                 if (tmp_opts) {
187                         if (opts) {
188                                 tmp_opts->m_next = opts;
189                                 opts = tmp_opts;
190                         } else
191                                 opts = tmp_opts;
192                 }
193 	}
194 	m_adj(n, off + sizeof(struct udphdr));
195 
196 	so = inp->inp_socket;
197 	SOCKBUF_LOCK(&so->so_rcv);
198 	if (sbappendaddr_locked(&so->so_rcv, (struct sockaddr *)&fromsa[0], n,
199 	    opts) == 0) {
200 		SOCKBUF_UNLOCK(&so->so_rcv);
201 		m_freem(n);
202 		if (opts)
203 			m_freem(opts);
204 		UDPSTAT_INC(udps_fullsock);
205 	} else
206 		sorwakeup_locked(so);
207 	return (0);
208 }
209 
210 int
211 udp6_input(struct mbuf **mp, int *offp, int proto)
212 {
213 	struct mbuf *m = *mp;
214 	struct ifnet *ifp;
215 	struct ip6_hdr *ip6;
216 	struct udphdr *uh;
217 	struct inpcb *inp;
218 	struct inpcbinfo *pcbinfo;
219 	struct udpcb *up;
220 	int off = *offp;
221 	int cscov_partial;
222 	int plen, ulen;
223 	struct sockaddr_in6 fromsa[2];
224 	struct m_tag *fwd_tag;
225 	uint16_t uh_sum;
226 	uint8_t nxt;
227 
228 	NET_EPOCH_ASSERT();
229 
230 	ifp = m->m_pkthdr.rcvif;
231 
232 	if (m->m_len < off + sizeof(struct udphdr)) {
233 		m = m_pullup(m, off + sizeof(struct udphdr));
234 		if (m == NULL) {
235 			IP6STAT_INC(ip6s_exthdrtoolong);
236 			*mp = NULL;
237 			return (IPPROTO_DONE);
238 		}
239 	}
240 	ip6 = mtod(m, struct ip6_hdr *);
241 	uh = (struct udphdr *)((caddr_t)ip6 + off);
242 
243 	UDPSTAT_INC(udps_ipackets);
244 
245 	/*
246 	 * Destination port of 0 is illegal, based on RFC768.
247 	 */
248 	if (uh->uh_dport == 0)
249 		goto badunlocked;
250 
251 	plen = ntohs(ip6->ip6_plen) - off + sizeof(*ip6);
252 	ulen = ntohs((u_short)uh->uh_ulen);
253 
254 	nxt = proto;
255 	cscov_partial = (nxt == IPPROTO_UDPLITE) ? 1 : 0;
256 	if (nxt == IPPROTO_UDPLITE) {
257 		/* Zero means checksum over the complete packet. */
258 		if (ulen == 0)
259 			ulen = plen;
260 		if (ulen == plen)
261 			cscov_partial = 0;
262 		if ((ulen < sizeof(struct udphdr)) || (ulen > plen)) {
263 			/* XXX: What is the right UDPLite MIB counter? */
264 			goto badunlocked;
265 		}
266 		if (uh->uh_sum == 0) {
267 			/* XXX: What is the right UDPLite MIB counter? */
268 			goto badunlocked;
269 		}
270 	} else {
271 		if ((ulen < sizeof(struct udphdr)) || (plen != ulen)) {
272 			UDPSTAT_INC(udps_badlen);
273 			goto badunlocked;
274 		}
275 		if (uh->uh_sum == 0) {
276 			UDPSTAT_INC(udps_nosum);
277 			/*
278 			 * dport 0 was rejected earlier so this is OK even if
279 			 * zero_checksum_port is 0 (which is its default value).
280 			 */
281 			if (ntohs(uh->uh_dport) == V_zero_checksum_port)
282 				goto skip_checksum;
283 			else
284 				goto badunlocked;
285 		}
286 	}
287 
288 	if ((m->m_pkthdr.csum_flags & CSUM_DATA_VALID_IPV6) &&
289 	    !cscov_partial) {
290 		if (m->m_pkthdr.csum_flags & CSUM_PSEUDO_HDR)
291 			uh_sum = m->m_pkthdr.csum_data;
292 		else
293 			uh_sum = in6_cksum_pseudo(ip6, ulen, nxt,
294 			    m->m_pkthdr.csum_data);
295 		uh_sum ^= 0xffff;
296 	} else
297 		uh_sum = in6_cksum_partial(m, nxt, off, plen, ulen);
298 
299 	if (uh_sum != 0) {
300 		UDPSTAT_INC(udps_badsum);
301 		goto badunlocked;
302 	}
303 
304 skip_checksum:
305 	/*
306 	 * Construct sockaddr format source address.
307 	 */
308 	init_sin6(&fromsa[0], m, 0);
309 	fromsa[0].sin6_port = uh->uh_sport;
310 	init_sin6(&fromsa[1], m, 1);
311 	fromsa[1].sin6_port = uh->uh_dport;
312 
313 	pcbinfo = udp_get_inpcbinfo(nxt);
314 	if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {
315 		struct inpcb *last;
316 		struct inpcbhead *pcblist;
317 		struct ip6_moptions *imo;
318 
319 		/*
320 		 * In the event that laddr should be set to the link-local
321 		 * address (this happens in RIPng), the multicast address
322 		 * specified in the received packet will not match laddr.  To
323 		 * handle this situation, matching is relaxed if the
324 		 * receiving interface is the same as one specified in the
325 		 * socket and if the destination multicast address matches
326 		 * one of the multicast groups specified in the socket.
327 		 */
328 
329 		/*
330 		 * KAME note: traditionally we dropped udpiphdr from mbuf
331 		 * here.  We need udphdr for IPsec processing so we do that
332 		 * later.
333 		 */
334 		pcblist = udp_get_pcblist(nxt);
335 		last = NULL;
336 		CK_LIST_FOREACH(inp, pcblist, inp_list) {
337 			if ((inp->inp_vflag & INP_IPV6) == 0)
338 				continue;
339 			if (inp->inp_lport != uh->uh_dport)
340 				continue;
341 			if (inp->inp_fport != 0 &&
342 			    inp->inp_fport != uh->uh_sport)
343 				continue;
344 			if (!IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)) {
345 				if (!IN6_ARE_ADDR_EQUAL(&inp->in6p_laddr,
346 							&ip6->ip6_dst))
347 					continue;
348 			}
349 			if (!IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr)) {
350 				if (!IN6_ARE_ADDR_EQUAL(&inp->in6p_faddr,
351 							&ip6->ip6_src) ||
352 				    inp->inp_fport != uh->uh_sport)
353 					continue;
354 			}
355 
356 			INP_RLOCK(inp);
357 
358 			if (__predict_false(inp->inp_flags2 & INP_FREED)) {
359 				INP_RUNLOCK(inp);
360 				continue;
361 			}
362 
363 			/*
364 			 * XXXRW: Because we weren't holding either the inpcb
365 			 * or the hash lock when we checked for a match
366 			 * before, we should probably recheck now that the
367 			 * inpcb lock is (supposed to be) held.
368 			 */
369 
370 			/*
371 			 * Handle socket delivery policy for any-source
372 			 * and source-specific multicast. [RFC3678]
373 			 */
374 			imo = inp->in6p_moptions;
375 			if (imo != NULL) {
376 				struct sockaddr_in6	 mcaddr;
377 				int			 blocked;
378 
379 				bzero(&mcaddr, sizeof(struct sockaddr_in6));
380 				mcaddr.sin6_len = sizeof(struct sockaddr_in6);
381 				mcaddr.sin6_family = AF_INET6;
382 				mcaddr.sin6_addr = ip6->ip6_dst;
383 
384 				blocked = im6o_mc_filter(imo, ifp,
385 					(struct sockaddr *)&mcaddr,
386 					(struct sockaddr *)&fromsa[0]);
387 				if (blocked != MCAST_PASS) {
388 					if (blocked == MCAST_NOTGMEMBER)
389 						IP6STAT_INC(ip6s_notmember);
390 					if (blocked == MCAST_NOTSMEMBER ||
391 					    blocked == MCAST_MUTED)
392 						UDPSTAT_INC(udps_filtermcast);
393 					INP_RUNLOCK(inp);
394 					continue;
395 				}
396 			}
397 
398 			if (last != NULL) {
399 				struct mbuf *n;
400 
401 				if ((n = m_copym(m, 0, M_COPYALL, M_NOWAIT)) !=
402 				    NULL) {
403 					if (nxt == IPPROTO_UDPLITE)
404 						UDPLITE_PROBE(receive, NULL,
405 						    last, ip6, last, uh);
406 					else
407 						UDP_PROBE(receive, NULL, last,
408 						    ip6, last, uh);
409 					if (udp6_append(last, n, off,
410 					    fromsa)) {
411 						INP_RUNLOCK(inp);
412 						goto badunlocked;
413 					}
414 				}
415 				/* Release PCB lock taken on previous pass. */
416 				INP_RUNLOCK(last);
417 			}
418 			last = inp;
419 			/*
420 			 * Don't look for additional matches if this one does
421 			 * not have either the SO_REUSEPORT or SO_REUSEADDR
422 			 * socket options set.  This heuristic avoids
423 			 * searching through all pcbs in the common case of a
424 			 * non-shared port.  It assumes that an application
425 			 * will never clear these options after setting them.
426 			 */
427 			if ((last->inp_socket->so_options &
428 			     (SO_REUSEPORT|SO_REUSEPORT_LB|SO_REUSEADDR)) == 0)
429 				break;
430 		}
431 
432 		if (last == NULL) {
433 			/*
434 			 * No matching pcb found; discard datagram.  (No need
435 			 * to send an ICMP Port Unreachable for a broadcast
436 			 * or multicast datgram.)
437 			 */
438 			UDPSTAT_INC(udps_noport);
439 			UDPSTAT_INC(udps_noportmcast);
440 			goto badunlocked;
441 		}
442 
443 		if (nxt == IPPROTO_UDPLITE)
444 			UDPLITE_PROBE(receive, NULL, last, ip6, last, uh);
445 		else
446 			UDP_PROBE(receive, NULL, last, ip6, last, uh);
447 		if (udp6_append(last, m, off, fromsa) == 0)
448 			INP_RUNLOCK(last);
449 		*mp = NULL;
450 		return (IPPROTO_DONE);
451 	}
452 	/*
453 	 * Locate pcb for datagram.
454 	 */
455 
456 	/*
457 	 * Grab info from PACKET_TAG_IPFORWARD tag prepended to the chain.
458 	 */
459 	if ((m->m_flags & M_IP6_NEXTHOP) &&
460 	    (fwd_tag = m_tag_find(m, PACKET_TAG_IPFORWARD, NULL)) != NULL) {
461 		struct sockaddr_in6 *next_hop6;
462 
463 		next_hop6 = (struct sockaddr_in6 *)(fwd_tag + 1);
464 
465 		/*
466 		 * Transparently forwarded. Pretend to be the destination.
467 		 * Already got one like this?
468 		 */
469 		inp = in6_pcblookup_mbuf(pcbinfo, &ip6->ip6_src,
470 		    uh->uh_sport, &ip6->ip6_dst, uh->uh_dport,
471 		    INPLOOKUP_RLOCKPCB, m->m_pkthdr.rcvif, m);
472 		if (!inp) {
473 			/*
474 			 * It's new.  Try to find the ambushing socket.
475 			 * Because we've rewritten the destination address,
476 			 * any hardware-generated hash is ignored.
477 			 */
478 			inp = in6_pcblookup(pcbinfo, &ip6->ip6_src,
479 			    uh->uh_sport, &next_hop6->sin6_addr,
480 			    next_hop6->sin6_port ? htons(next_hop6->sin6_port) :
481 			    uh->uh_dport, INPLOOKUP_WILDCARD |
482 			    INPLOOKUP_RLOCKPCB, m->m_pkthdr.rcvif);
483 		}
484 		/* Remove the tag from the packet. We don't need it anymore. */
485 		m_tag_delete(m, fwd_tag);
486 		m->m_flags &= ~M_IP6_NEXTHOP;
487 	} else
488 		inp = in6_pcblookup_mbuf(pcbinfo, &ip6->ip6_src,
489 		    uh->uh_sport, &ip6->ip6_dst, uh->uh_dport,
490 		    INPLOOKUP_WILDCARD | INPLOOKUP_RLOCKPCB,
491 		    m->m_pkthdr.rcvif, m);
492 	if (inp == NULL) {
493 		if (V_udp_log_in_vain) {
494 			char ip6bufs[INET6_ADDRSTRLEN];
495 			char ip6bufd[INET6_ADDRSTRLEN];
496 
497 			log(LOG_INFO,
498 			    "Connection attempt to UDP [%s]:%d from [%s]:%d\n",
499 			    ip6_sprintf(ip6bufd, &ip6->ip6_dst),
500 			    ntohs(uh->uh_dport),
501 			    ip6_sprintf(ip6bufs, &ip6->ip6_src),
502 			    ntohs(uh->uh_sport));
503 		}
504 		if (nxt == IPPROTO_UDPLITE)
505 			UDPLITE_PROBE(receive, NULL, NULL, ip6, NULL, uh);
506 		else
507 			UDP_PROBE(receive, NULL, NULL, ip6, NULL, uh);
508 		UDPSTAT_INC(udps_noport);
509 		if (m->m_flags & M_MCAST) {
510 			printf("UDP6: M_MCAST is set in a unicast packet.\n");
511 			UDPSTAT_INC(udps_noportmcast);
512 			goto badunlocked;
513 		}
514 		if (V_udp_blackhole)
515 			goto badunlocked;
516 		icmp6_error(m, ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_NOPORT, 0);
517 		*mp = NULL;
518 		return (IPPROTO_DONE);
519 	}
520 	INP_RLOCK_ASSERT(inp);
521 	up = intoudpcb(inp);
522 	if (cscov_partial) {
523 		if (up->u_rxcslen == 0 || up->u_rxcslen > ulen) {
524 			INP_RUNLOCK(inp);
525 			m_freem(m);
526 			*mp = NULL;
527 			return (IPPROTO_DONE);
528 		}
529 	}
530 	if (nxt == IPPROTO_UDPLITE)
531 		UDPLITE_PROBE(receive, NULL, inp, ip6, inp, uh);
532 	else
533 		UDP_PROBE(receive, NULL, inp, ip6, inp, uh);
534 	if (udp6_append(inp, m, off, fromsa) == 0)
535 		INP_RUNLOCK(inp);
536 	*mp = NULL;
537 	return (IPPROTO_DONE);
538 
539 badunlocked:
540 	m_freem(m);
541 	*mp = NULL;
542 	return (IPPROTO_DONE);
543 }
544 
545 static void
546 udp6_common_ctlinput(int cmd, struct sockaddr *sa, void *d,
547     struct inpcbinfo *pcbinfo)
548 {
549 	struct udphdr uh;
550 	struct ip6_hdr *ip6;
551 	struct mbuf *m;
552 	int off = 0;
553 	struct ip6ctlparam *ip6cp = NULL;
554 	const struct sockaddr_in6 *sa6_src = NULL;
555 	void *cmdarg;
556 	struct inpcb *(*notify)(struct inpcb *, int) = udp_notify;
557 	struct udp_portonly {
558 		u_int16_t uh_sport;
559 		u_int16_t uh_dport;
560 	} *uhp;
561 
562 	if (sa->sa_family != AF_INET6 ||
563 	    sa->sa_len != sizeof(struct sockaddr_in6))
564 		return;
565 
566 	if ((unsigned)cmd >= PRC_NCMDS)
567 		return;
568 	if (PRC_IS_REDIRECT(cmd))
569 		notify = in6_rtchange, d = NULL;
570 	else if (cmd == PRC_HOSTDEAD)
571 		d = NULL;
572 	else if (inet6ctlerrmap[cmd] == 0)
573 		return;
574 
575 	/* if the parameter is from icmp6, decode it. */
576 	if (d != NULL) {
577 		ip6cp = (struct ip6ctlparam *)d;
578 		m = ip6cp->ip6c_m;
579 		ip6 = ip6cp->ip6c_ip6;
580 		off = ip6cp->ip6c_off;
581 		cmdarg = ip6cp->ip6c_cmdarg;
582 		sa6_src = ip6cp->ip6c_src;
583 	} else {
584 		m = NULL;
585 		ip6 = NULL;
586 		cmdarg = NULL;
587 		sa6_src = &sa6_any;
588 	}
589 
590 	if (ip6) {
591 		/*
592 		 * XXX: We assume that when IPV6 is non NULL,
593 		 * M and OFF are valid.
594 		 */
595 
596 		/* Check if we can safely examine src and dst ports. */
597 		if (m->m_pkthdr.len < off + sizeof(*uhp))
598 			return;
599 
600 		bzero(&uh, sizeof(uh));
601 		m_copydata(m, off, sizeof(*uhp), (caddr_t)&uh);
602 
603 		if (!PRC_IS_REDIRECT(cmd)) {
604 			/* Check to see if its tunneled */
605 			struct inpcb *inp;
606 			inp = in6_pcblookup_mbuf(pcbinfo, &ip6->ip6_dst,
607 			    uh.uh_dport, &ip6->ip6_src, uh.uh_sport,
608 			    INPLOOKUP_WILDCARD | INPLOOKUP_RLOCKPCB,
609 			    m->m_pkthdr.rcvif, m);
610 			if (inp != NULL) {
611 				struct udpcb *up;
612 
613 				up = intoudpcb(inp);
614 				if (up->u_icmp_func) {
615 					/* Yes it is. */
616 					INP_RUNLOCK(inp);
617 					(*up->u_icmp_func)(cmd, (struct sockaddr *)ip6cp->ip6c_src,
618 					      d, up->u_tun_ctx);
619 					return;
620 				} else {
621 					/* Can't find it. */
622 					INP_RUNLOCK(inp);
623 				}
624 			}
625 		}
626 		(void)in6_pcbnotify(pcbinfo, sa, uh.uh_dport,
627 		    (struct sockaddr *)ip6cp->ip6c_src, uh.uh_sport, cmd,
628 		    cmdarg, notify);
629 	} else
630 		(void)in6_pcbnotify(pcbinfo, sa, 0,
631 		    (const struct sockaddr *)sa6_src, 0, cmd, cmdarg, notify);
632 }
633 
634 void
635 udp6_ctlinput(int cmd, struct sockaddr *sa, void *d)
636 {
637 
638 	return (udp6_common_ctlinput(cmd, sa, d, &V_udbinfo));
639 }
640 
641 void
642 udplite6_ctlinput(int cmd, struct sockaddr *sa, void *d)
643 {
644 
645 	return (udp6_common_ctlinput(cmd, sa, d, &V_ulitecbinfo));
646 }
647 
648 static int
649 udp6_getcred(SYSCTL_HANDLER_ARGS)
650 {
651 	struct xucred xuc;
652 	struct sockaddr_in6 addrs[2];
653 	struct epoch_tracker et;
654 	struct inpcb *inp;
655 	int error;
656 
657 	error = priv_check(req->td, PRIV_NETINET_GETCRED);
658 	if (error)
659 		return (error);
660 
661 	if (req->newlen != sizeof(addrs))
662 		return (EINVAL);
663 	if (req->oldlen != sizeof(struct xucred))
664 		return (EINVAL);
665 	error = SYSCTL_IN(req, addrs, sizeof(addrs));
666 	if (error)
667 		return (error);
668 	if ((error = sa6_embedscope(&addrs[0], V_ip6_use_defzone)) != 0 ||
669 	    (error = sa6_embedscope(&addrs[1], V_ip6_use_defzone)) != 0) {
670 		return (error);
671 	}
672 	NET_EPOCH_ENTER(et);
673 	inp = in6_pcblookup(&V_udbinfo, &addrs[1].sin6_addr,
674 	    addrs[1].sin6_port, &addrs[0].sin6_addr, addrs[0].sin6_port,
675 	    INPLOOKUP_WILDCARD | INPLOOKUP_RLOCKPCB, NULL);
676 	NET_EPOCH_EXIT(et);
677 	if (inp != NULL) {
678 		INP_RLOCK_ASSERT(inp);
679 		if (inp->inp_socket == NULL)
680 			error = ENOENT;
681 		if (error == 0)
682 			error = cr_canseesocket(req->td->td_ucred,
683 			    inp->inp_socket);
684 		if (error == 0)
685 			cru2x(inp->inp_cred, &xuc);
686 		INP_RUNLOCK(inp);
687 	} else
688 		error = ENOENT;
689 	if (error == 0)
690 		error = SYSCTL_OUT(req, &xuc, sizeof(struct xucred));
691 	return (error);
692 }
693 
694 SYSCTL_PROC(_net_inet6_udp6, OID_AUTO, getcred,
695     CTLTYPE_OPAQUE | CTLFLAG_RW | CTLFLAG_MPSAFE,
696     0, 0, udp6_getcred, "S,xucred",
697     "Get the xucred of a UDP6 connection");
698 
699 static int
700 udp6_output(struct socket *so, int flags_arg, struct mbuf *m,
701     struct sockaddr *addr6, struct mbuf *control, struct thread *td)
702 {
703 	struct inpcb *inp;
704 	struct ip6_hdr *ip6;
705 	struct udphdr *udp6;
706 	struct in6_addr *laddr, *faddr, in6a;
707 	struct ip6_pktopts *optp, opt;
708 	struct sockaddr_in6 *sin6, tmp;
709 	struct epoch_tracker et;
710 	int cscov_partial, error, flags, hlen, scope_ambiguous;
711 	u_int32_t ulen, plen;
712 	uint16_t cscov;
713 	u_short fport;
714 	uint8_t nxt;
715 
716 	/* addr6 has been validated in udp6_send(). */
717 	sin6 = (struct sockaddr_in6 *)addr6;
718 
719 	/*
720 	 * In contrast to to IPv4 we do not validate the max. packet length
721 	 * here due to IPv6 Jumbograms (RFC2675).
722 	 */
723 
724 	scope_ambiguous = 0;
725 	if (sin6) {
726 		/* Protect *addr6 from overwrites. */
727 		tmp = *sin6;
728 		sin6 = &tmp;
729 
730 		/*
731 		 * Application should provide a proper zone ID or the use of
732 		 * default zone IDs should be enabled.  Unfortunately, some
733 		 * applications do not behave as it should, so we need a
734 		 * workaround.  Even if an appropriate ID is not determined,
735 		 * we'll see if we can determine the outgoing interface.  If we
736 		 * can, determine the zone ID based on the interface below.
737 		 */
738 		if (sin6->sin6_scope_id == 0 && !V_ip6_use_defzone)
739 			scope_ambiguous = 1;
740 		if ((error = sa6_embedscope(sin6, V_ip6_use_defzone)) != 0) {
741 			if (control)
742 				m_freem(control);
743 			m_freem(m);
744 			return (error);
745 		}
746 	}
747 
748 	inp = sotoinpcb(so);
749 	KASSERT(inp != NULL, ("%s: inp == NULL", __func__));
750 	/*
751 	 * In the following cases we want a write lock on the inp for either
752 	 * local operations or for possible route cache updates in the IPv6
753 	 * output path:
754 	 * - on connected sockets (sin6 is NULL) for route cache updates,
755 	 * - when we are not bound to an address and source port (it is
756 	 *   in6_pcbsetport() which will require the write lock).
757 	 *
758 	 * We check the inp fields before actually locking the inp, so
759 	 * here exists a race, and we may WLOCK the inp and end with already
760 	 * bound one by other thread. This is fine.
761 	 */
762 	if (sin6 == NULL || (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr) &&
763 	    inp->inp_lport == 0))
764 		INP_WLOCK(inp);
765 	else
766 		INP_RLOCK(inp);
767 
768 	nxt = (inp->inp_socket->so_proto->pr_protocol == IPPROTO_UDP) ?
769 	    IPPROTO_UDP : IPPROTO_UDPLITE;
770 
771 #ifdef INET
772 	if ((inp->inp_flags & IN6P_IPV6_V6ONLY) == 0) {
773 		int hasv4addr;
774 
775 		if (sin6 == NULL)
776 			hasv4addr = (inp->inp_vflag & INP_IPV4);
777 		else
778 			hasv4addr = IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)
779 			    ? 1 : 0;
780 		if (hasv4addr) {
781 			struct pr_usrreqs *pru;
782 
783 			/*
784 			 * XXXRW: We release UDP-layer locks before calling
785 			 * udp_send() in order to avoid recursion.  However,
786 			 * this does mean there is a short window where inp's
787 			 * fields are unstable.  Could this lead to a
788 			 * potential race in which the factors causing us to
789 			 * select the UDPv4 output routine are invalidated?
790 			 */
791 			INP_UNLOCK(inp);
792 			if (sin6)
793 				in6_sin6_2_sin_in_sock((struct sockaddr *)sin6);
794 			pru = inetsw[ip_protox[nxt]].pr_usrreqs;
795 			/* addr will just be freed in sendit(). */
796 			return ((*pru->pru_send)(so, flags_arg | PRUS_IPV6, m,
797 			    (struct sockaddr *)sin6, control, td));
798 		}
799 	} else
800 #endif
801 	if (sin6 && IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
802 		/*
803 		 * Given this is either an IPv6-only socket or no INET is
804 		 * supported we will fail the send if the given destination
805 		 * address is a v4mapped address.
806 		 *
807 		 * XXXGL: do we leak m and control?
808 		 */
809 		INP_UNLOCK(inp);
810 		return (EINVAL);
811 	}
812 
813 	if (control) {
814 		if ((error = ip6_setpktopts(control, &opt,
815 		    inp->in6p_outputopts, td->td_ucred, nxt)) != 0) {
816 			INP_UNLOCK(inp);
817 			ip6_clearpktopts(&opt, -1);
818 			if (control)
819 				m_freem(control);
820 			m_freem(m);
821 			return (error);
822 		}
823 		optp = &opt;
824 	} else
825 		optp = inp->in6p_outputopts;
826 
827 	NET_EPOCH_ENTER(et);
828 	if (sin6) {
829 		/*
830 		 * Since we saw no essential reason for calling in_pcbconnect,
831 		 * we get rid of such kind of logic, and call in6_selectsrc
832 		 * and in6_pcbsetport in order to fill in the local address
833 		 * and the local port.
834 		 */
835 		if (sin6->sin6_port == 0) {
836 			error = EADDRNOTAVAIL;
837 			goto release;
838 		}
839 
840 		if (!IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr)) {
841 			/* how about ::ffff:0.0.0.0 case? */
842 			error = EISCONN;
843 			goto release;
844 		}
845 
846 		/*
847 		 * Given we handle the v4mapped case in the INET block above
848 		 * assert here that it must not happen anymore.
849 		 */
850 		KASSERT(!IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr),
851 		    ("%s: sin6(%p)->sin6_addr is v4mapped which we "
852 		    "should have handled.", __func__, sin6));
853 
854 		/* This only requires read-locking. */
855 		error = in6_selectsrc_socket(sin6, optp, inp,
856 		    td->td_ucred, scope_ambiguous, &in6a, NULL);
857 		if (error)
858 			goto release;
859 		laddr = &in6a;
860 
861 		if (inp->inp_lport == 0) {
862 			struct inpcbinfo *pcbinfo;
863 
864 			INP_WLOCK_ASSERT(inp);
865 
866 			pcbinfo = udp_get_inpcbinfo(so->so_proto->pr_protocol);
867 			INP_HASH_WLOCK(pcbinfo);
868 			error = in6_pcbsetport(laddr, inp, td->td_ucred);
869 			INP_HASH_WUNLOCK(pcbinfo);
870 			if (error != 0) {
871 				/* Undo an address bind that may have occurred. */
872 				inp->in6p_laddr = in6addr_any;
873 				goto release;
874 			}
875 		}
876 		faddr = &sin6->sin6_addr;
877 		fport = sin6->sin6_port; /* allow 0 port */
878 
879 	} else {
880 		if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr)) {
881 			error = ENOTCONN;
882 			goto release;
883 		}
884 		laddr = &inp->in6p_laddr;
885 		faddr = &inp->in6p_faddr;
886 		fport = inp->inp_fport;
887 	}
888 
889 	ulen = m->m_pkthdr.len;
890 	plen = sizeof(struct udphdr) + ulen;
891 	hlen = sizeof(struct ip6_hdr);
892 
893 	/*
894 	 * Calculate data length and get a mbuf
895 	 * for UDP and IP6 headers.
896 	 */
897 	M_PREPEND(m, hlen + sizeof(struct udphdr), M_NOWAIT);
898 	if (m == NULL) {
899 		error = ENOBUFS;
900 		goto release;
901 	}
902 
903 	/*
904 	 * Stuff checksum and output datagram.
905 	 */
906 	cscov = cscov_partial = 0;
907 	udp6 = (struct udphdr *)(mtod(m, caddr_t) + hlen);
908 	udp6->uh_sport = inp->inp_lport; /* lport is always set in the PCB */
909 	udp6->uh_dport = fport;
910 	if (nxt == IPPROTO_UDPLITE) {
911 		struct udpcb *up;
912 
913 		up = intoudpcb(inp);
914 		cscov = up->u_txcslen;
915 		if (cscov >= plen)
916 			cscov = 0;
917 		udp6->uh_ulen = htons(cscov);
918 		/*
919 		 * For UDP-Lite, checksum coverage length of zero means
920 		 * the entire UDPLite packet is covered by the checksum.
921 		 */
922 		cscov_partial = (cscov == 0) ? 0 : 1;
923 	} else if (plen <= 0xffff)
924 		udp6->uh_ulen = htons((u_short)plen);
925 	else
926 		udp6->uh_ulen = 0;
927 	udp6->uh_sum = 0;
928 
929 	ip6 = mtod(m, struct ip6_hdr *);
930 	ip6->ip6_flow	= inp->inp_flow & IPV6_FLOWINFO_MASK;
931 	ip6->ip6_vfc	&= ~IPV6_VERSION_MASK;
932 	ip6->ip6_vfc	|= IPV6_VERSION;
933 	ip6->ip6_plen	= htons((u_short)plen);
934 	ip6->ip6_nxt	= nxt;
935 	ip6->ip6_hlim	= in6_selecthlim(inp, NULL);
936 	ip6->ip6_src	= *laddr;
937 	ip6->ip6_dst	= *faddr;
938 
939 #ifdef MAC
940 	mac_inpcb_create_mbuf(inp, m);
941 #endif
942 
943 	if (cscov_partial) {
944 		if ((udp6->uh_sum = in6_cksum_partial(m, nxt,
945 		    sizeof(struct ip6_hdr), plen, cscov)) == 0)
946 			udp6->uh_sum = 0xffff;
947 	} else {
948 		udp6->uh_sum = in6_cksum_pseudo(ip6, plen, nxt, 0);
949 		m->m_pkthdr.csum_flags = CSUM_UDP_IPV6;
950 		m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
951 	}
952 
953 	flags = 0;
954 #if defined(ROUTE_MPATH) || defined(RSS)
955 	if (CALC_FLOWID_OUTBOUND_SENDTO) {
956 		uint32_t hash_type, hash_val;
957 		uint8_t pr;
958 
959 		pr = inp->inp_socket->so_proto->pr_protocol;
960 
961 		hash_val = fib6_calc_packet_hash(laddr, faddr,
962 		    inp->inp_lport, fport, pr, &hash_type);
963 		m->m_pkthdr.flowid = hash_val;
964 		M_HASHTYPE_SET(m, hash_type);
965 	}
966 	/* do not use inp flowid */
967 	flags |= IP_NODEFAULTFLOWID;
968 #endif
969 
970 	UDPSTAT_INC(udps_opackets);
971 	if (nxt == IPPROTO_UDPLITE)
972 		UDPLITE_PROBE(send, NULL, inp, ip6, inp, udp6);
973 	else
974 		UDP_PROBE(send, NULL, inp, ip6, inp, udp6);
975 	error = ip6_output(m, optp,
976 	    INP_WLOCKED(inp) ? &inp->inp_route6 : NULL, flags,
977 	    inp->in6p_moptions, NULL, inp);
978 	INP_UNLOCK(inp);
979 	NET_EPOCH_EXIT(et);
980 
981 	if (control) {
982 		ip6_clearpktopts(&opt, -1);
983 		m_freem(control);
984 	}
985 	return (error);
986 
987 release:
988 	INP_UNLOCK(inp);
989 	NET_EPOCH_EXIT(et);
990 	if (control) {
991 		ip6_clearpktopts(&opt, -1);
992 		m_freem(control);
993 	}
994 	m_freem(m);
995 
996 	return (error);
997 }
998 
999 static void
1000 udp6_abort(struct socket *so)
1001 {
1002 	struct inpcb *inp;
1003 	struct inpcbinfo *pcbinfo;
1004 
1005 	pcbinfo = udp_get_inpcbinfo(so->so_proto->pr_protocol);
1006 	inp = sotoinpcb(so);
1007 	KASSERT(inp != NULL, ("udp6_abort: inp == NULL"));
1008 
1009 	INP_WLOCK(inp);
1010 #ifdef INET
1011 	if (inp->inp_vflag & INP_IPV4) {
1012 		struct pr_usrreqs *pru;
1013 		uint8_t nxt;
1014 
1015 		nxt = (inp->inp_socket->so_proto->pr_protocol == IPPROTO_UDP) ?
1016 		    IPPROTO_UDP : IPPROTO_UDPLITE;
1017 		INP_WUNLOCK(inp);
1018 		pru = inetsw[ip_protox[nxt]].pr_usrreqs;
1019 		(*pru->pru_abort)(so);
1020 		return;
1021 	}
1022 #endif
1023 
1024 	if (!IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr)) {
1025 		INP_HASH_WLOCK(pcbinfo);
1026 		in6_pcbdisconnect(inp);
1027 		inp->in6p_laddr = in6addr_any;
1028 		INP_HASH_WUNLOCK(pcbinfo);
1029 		soisdisconnected(so);
1030 	}
1031 	INP_WUNLOCK(inp);
1032 }
1033 
1034 static int
1035 udp6_attach(struct socket *so, int proto, struct thread *td)
1036 {
1037 	struct inpcb *inp;
1038 	struct inpcbinfo *pcbinfo;
1039 	int error;
1040 
1041 	pcbinfo = udp_get_inpcbinfo(so->so_proto->pr_protocol);
1042 	inp = sotoinpcb(so);
1043 	KASSERT(inp == NULL, ("udp6_attach: inp != NULL"));
1044 
1045 	if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
1046 		error = soreserve(so, udp_sendspace, udp_recvspace);
1047 		if (error)
1048 			return (error);
1049 	}
1050 	INP_INFO_WLOCK(pcbinfo);
1051 	error = in_pcballoc(so, pcbinfo);
1052 	if (error) {
1053 		INP_INFO_WUNLOCK(pcbinfo);
1054 		return (error);
1055 	}
1056 	inp = (struct inpcb *)so->so_pcb;
1057 	inp->inp_vflag |= INP_IPV6;
1058 	if ((inp->inp_flags & IN6P_IPV6_V6ONLY) == 0)
1059 		inp->inp_vflag |= INP_IPV4;
1060 	inp->in6p_hops = -1;	/* use kernel default */
1061 	inp->in6p_cksum = -1;	/* just to be sure */
1062 	/*
1063 	 * XXX: ugly!!
1064 	 * IPv4 TTL initialization is necessary for an IPv6 socket as well,
1065 	 * because the socket may be bound to an IPv6 wildcard address,
1066 	 * which may match an IPv4-mapped IPv6 address.
1067 	 */
1068 	inp->inp_ip_ttl = V_ip_defttl;
1069 
1070 	error = udp_newudpcb(inp);
1071 	if (error) {
1072 		in_pcbdetach(inp);
1073 		in_pcbfree(inp);
1074 		INP_INFO_WUNLOCK(pcbinfo);
1075 		return (error);
1076 	}
1077 	INP_WUNLOCK(inp);
1078 	INP_INFO_WUNLOCK(pcbinfo);
1079 	return (0);
1080 }
1081 
1082 static int
1083 udp6_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
1084 {
1085 	struct inpcb *inp;
1086 	struct inpcbinfo *pcbinfo;
1087 	int error;
1088 	u_char vflagsav;
1089 
1090 	pcbinfo = udp_get_inpcbinfo(so->so_proto->pr_protocol);
1091 	inp = sotoinpcb(so);
1092 	KASSERT(inp != NULL, ("udp6_bind: inp == NULL"));
1093 
1094 	if (nam->sa_family != AF_INET6)
1095 		return (EAFNOSUPPORT);
1096 	if (nam->sa_len != sizeof(struct sockaddr_in6))
1097 		return (EINVAL);
1098 
1099 	INP_WLOCK(inp);
1100 	INP_HASH_WLOCK(pcbinfo);
1101 	vflagsav = inp->inp_vflag;
1102 	inp->inp_vflag &= ~INP_IPV4;
1103 	inp->inp_vflag |= INP_IPV6;
1104 	if ((inp->inp_flags & IN6P_IPV6_V6ONLY) == 0) {
1105 		struct sockaddr_in6 *sin6_p;
1106 
1107 		sin6_p = (struct sockaddr_in6 *)nam;
1108 
1109 		if (IN6_IS_ADDR_UNSPECIFIED(&sin6_p->sin6_addr))
1110 			inp->inp_vflag |= INP_IPV4;
1111 #ifdef INET
1112 		else if (IN6_IS_ADDR_V4MAPPED(&sin6_p->sin6_addr)) {
1113 			struct sockaddr_in sin;
1114 
1115 			in6_sin6_2_sin(&sin, sin6_p);
1116 			inp->inp_vflag |= INP_IPV4;
1117 			inp->inp_vflag &= ~INP_IPV6;
1118 			error = in_pcbbind(inp, (struct sockaddr *)&sin,
1119 			    td->td_ucred);
1120 			goto out;
1121 		}
1122 #endif
1123 	}
1124 
1125 	error = in6_pcbbind(inp, nam, td->td_ucred);
1126 #ifdef INET
1127 out:
1128 #endif
1129 	if (error != 0)
1130 		inp->inp_vflag = vflagsav;
1131 	INP_HASH_WUNLOCK(pcbinfo);
1132 	INP_WUNLOCK(inp);
1133 	return (error);
1134 }
1135 
1136 static void
1137 udp6_close(struct socket *so)
1138 {
1139 	struct inpcb *inp;
1140 	struct inpcbinfo *pcbinfo;
1141 
1142 	pcbinfo = udp_get_inpcbinfo(so->so_proto->pr_protocol);
1143 	inp = sotoinpcb(so);
1144 	KASSERT(inp != NULL, ("udp6_close: inp == NULL"));
1145 
1146 	INP_WLOCK(inp);
1147 #ifdef INET
1148 	if (inp->inp_vflag & INP_IPV4) {
1149 		struct pr_usrreqs *pru;
1150 		uint8_t nxt;
1151 
1152 		nxt = (inp->inp_socket->so_proto->pr_protocol == IPPROTO_UDP) ?
1153 		    IPPROTO_UDP : IPPROTO_UDPLITE;
1154 		INP_WUNLOCK(inp);
1155 		pru = inetsw[ip_protox[nxt]].pr_usrreqs;
1156 		(*pru->pru_disconnect)(so);
1157 		return;
1158 	}
1159 #endif
1160 	if (!IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr)) {
1161 		INP_HASH_WLOCK(pcbinfo);
1162 		in6_pcbdisconnect(inp);
1163 		inp->in6p_laddr = in6addr_any;
1164 		INP_HASH_WUNLOCK(pcbinfo);
1165 		soisdisconnected(so);
1166 	}
1167 	INP_WUNLOCK(inp);
1168 }
1169 
1170 static int
1171 udp6_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
1172 {
1173 #ifdef INET
1174 	struct epoch_tracker et;
1175 #endif
1176 	struct inpcb *inp;
1177 	struct inpcbinfo *pcbinfo;
1178 	struct sockaddr_in6 *sin6;
1179 	int error;
1180 	u_char vflagsav;
1181 
1182 	pcbinfo = udp_get_inpcbinfo(so->so_proto->pr_protocol);
1183 	inp = sotoinpcb(so);
1184 	KASSERT(inp != NULL, ("udp6_connect: inp == NULL"));
1185 
1186 	sin6 = (struct sockaddr_in6 *)nam;
1187 	if (sin6->sin6_family != AF_INET6)
1188 		return (EAFNOSUPPORT);
1189 	if (sin6->sin6_len != sizeof(*sin6))
1190 		return (EINVAL);
1191 
1192 	/*
1193 	 * XXXRW: Need to clarify locking of v4/v6 flags.
1194 	 */
1195 	INP_WLOCK(inp);
1196 #ifdef INET
1197 	if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
1198 		struct sockaddr_in sin;
1199 
1200 		if ((inp->inp_flags & IN6P_IPV6_V6ONLY) != 0) {
1201 			error = EINVAL;
1202 			goto out;
1203 		}
1204 		if ((inp->inp_vflag & INP_IPV4) == 0) {
1205 			error = EAFNOSUPPORT;
1206 			goto out;
1207 		}
1208 		if (inp->inp_faddr.s_addr != INADDR_ANY) {
1209 			error = EISCONN;
1210 			goto out;
1211 		}
1212 		in6_sin6_2_sin(&sin, sin6);
1213 		error = prison_remote_ip4(td->td_ucred, &sin.sin_addr);
1214 		if (error != 0)
1215 			goto out;
1216 		vflagsav = inp->inp_vflag;
1217 		inp->inp_vflag |= INP_IPV4;
1218 		inp->inp_vflag &= ~INP_IPV6;
1219 		NET_EPOCH_ENTER(et);
1220 		INP_HASH_WLOCK(pcbinfo);
1221 		error = in_pcbconnect(inp, (struct sockaddr *)&sin,
1222 		    td->td_ucred);
1223 		INP_HASH_WUNLOCK(pcbinfo);
1224 		NET_EPOCH_EXIT(et);
1225 		/*
1226 		 * If connect succeeds, mark socket as connected. If
1227 		 * connect fails and socket is unbound, reset inp_vflag
1228 		 * field.
1229 		 */
1230 		if (error == 0)
1231 			soisconnected(so);
1232 		else if (inp->inp_laddr.s_addr == INADDR_ANY &&
1233 		    inp->inp_lport == 0)
1234 			inp->inp_vflag = vflagsav;
1235 		goto out;
1236 	} else {
1237 		if ((inp->inp_vflag & INP_IPV6) == 0) {
1238 			error = EAFNOSUPPORT;
1239 			goto out;
1240 		}
1241 	}
1242 #endif
1243 	if (!IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr)) {
1244 		error = EISCONN;
1245 		goto out;
1246 	}
1247 	error = prison_remote_ip6(td->td_ucred, &sin6->sin6_addr);
1248 	if (error != 0)
1249 		goto out;
1250 	vflagsav = inp->inp_vflag;
1251 	inp->inp_vflag &= ~INP_IPV4;
1252 	inp->inp_vflag |= INP_IPV6;
1253 	INP_HASH_WLOCK(pcbinfo);
1254 	error = in6_pcbconnect(inp, nam, td->td_ucred);
1255 	INP_HASH_WUNLOCK(pcbinfo);
1256 	/*
1257 	 * If connect succeeds, mark socket as connected. If
1258 	 * connect fails and socket is unbound, reset inp_vflag
1259 	 * field.
1260 	 */
1261 	if (error == 0)
1262 		soisconnected(so);
1263 	else if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr) &&
1264 	    inp->inp_lport == 0)
1265 		inp->inp_vflag = vflagsav;
1266 out:
1267 	INP_WUNLOCK(inp);
1268 	return (error);
1269 }
1270 
1271 static void
1272 udp6_detach(struct socket *so)
1273 {
1274 	struct inpcb *inp;
1275 	struct inpcbinfo *pcbinfo;
1276 	struct udpcb *up;
1277 
1278 	pcbinfo = udp_get_inpcbinfo(so->so_proto->pr_protocol);
1279 	inp = sotoinpcb(so);
1280 	KASSERT(inp != NULL, ("udp6_detach: inp == NULL"));
1281 
1282 	INP_INFO_WLOCK(pcbinfo);
1283 	INP_WLOCK(inp);
1284 	up = intoudpcb(inp);
1285 	KASSERT(up != NULL, ("%s: up == NULL", __func__));
1286 	in_pcbdetach(inp);
1287 	in_pcbfree(inp);
1288 	INP_INFO_WUNLOCK(pcbinfo);
1289 	udp_discardcb(up);
1290 }
1291 
1292 static int
1293 udp6_disconnect(struct socket *so)
1294 {
1295 	struct inpcb *inp;
1296 	struct inpcbinfo *pcbinfo;
1297 
1298 	pcbinfo = udp_get_inpcbinfo(so->so_proto->pr_protocol);
1299 	inp = sotoinpcb(so);
1300 	KASSERT(inp != NULL, ("udp6_disconnect: inp == NULL"));
1301 
1302 	INP_WLOCK(inp);
1303 #ifdef INET
1304 	if (inp->inp_vflag & INP_IPV4) {
1305 		struct pr_usrreqs *pru;
1306 		uint8_t nxt;
1307 
1308 		nxt = (inp->inp_socket->so_proto->pr_protocol == IPPROTO_UDP) ?
1309 		    IPPROTO_UDP : IPPROTO_UDPLITE;
1310 		INP_WUNLOCK(inp);
1311 		pru = inetsw[ip_protox[nxt]].pr_usrreqs;
1312 		(void)(*pru->pru_disconnect)(so);
1313 		return (0);
1314 	}
1315 #endif
1316 
1317 	if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr)) {
1318 		INP_WUNLOCK(inp);
1319 		return (ENOTCONN);
1320 	}
1321 
1322 	INP_HASH_WLOCK(pcbinfo);
1323 	in6_pcbdisconnect(inp);
1324 	inp->in6p_laddr = in6addr_any;
1325 	INP_HASH_WUNLOCK(pcbinfo);
1326 	SOCK_LOCK(so);
1327 	so->so_state &= ~SS_ISCONNECTED;		/* XXX */
1328 	SOCK_UNLOCK(so);
1329 	INP_WUNLOCK(inp);
1330 	return (0);
1331 }
1332 
1333 static int
1334 udp6_send(struct socket *so, int flags, struct mbuf *m,
1335     struct sockaddr *addr, struct mbuf *control, struct thread *td)
1336 {
1337 	int error;
1338 
1339 	if (addr) {
1340 		if (addr->sa_len != sizeof(struct sockaddr_in6)) {
1341 			error = EINVAL;
1342 			goto bad;
1343 		}
1344 		if (addr->sa_family != AF_INET6) {
1345 			error = EAFNOSUPPORT;
1346 			goto bad;
1347 		}
1348 	}
1349 
1350 	return (udp6_output(so, flags, m, addr, control, td));
1351 
1352 bad:
1353 	if (control)
1354 		m_freem(control);
1355 	m_freem(m);
1356 	return (error);
1357 }
1358 
1359 struct pr_usrreqs udp6_usrreqs = {
1360 	.pru_abort =		udp6_abort,
1361 	.pru_attach =		udp6_attach,
1362 	.pru_bind =		udp6_bind,
1363 	.pru_connect =		udp6_connect,
1364 	.pru_control =		in6_control,
1365 	.pru_detach =		udp6_detach,
1366 	.pru_disconnect =	udp6_disconnect,
1367 	.pru_peeraddr =		in6_mapped_peeraddr,
1368 	.pru_send =		udp6_send,
1369 	.pru_shutdown =		udp_shutdown,
1370 	.pru_sockaddr =		in6_mapped_sockaddr,
1371 	.pru_soreceive =	soreceive_dgram,
1372 	.pru_sosend =		sosend_dgram,
1373 	.pru_sosetlabel =	in_pcbsosetlabel,
1374 	.pru_close =		udp6_close
1375 };
1376