xref: /freebsd/sys/netinet/udp_usrreq.c (revision 1ad19fb657c83ba4da7f1703c152af7a02d0d386)
1c398230bSWarner Losh /*-
26dfab5b1SGarrett Wollman  * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
33329b236SRobert Watson  *	The Regents of the University of California.
43144b7d3SRobert Watson  * Copyright (c) 2008 Robert N. M. Watson
5fa046d87SRobert Watson  * Copyright (c) 2010-2011 Juniper Networks, Inc.
63329b236SRobert Watson  * All rights reserved.
7df8bae1dSRodney W. Grimes  *
8fa046d87SRobert Watson  * Portions of this software were developed by Robert N. M. Watson under
9fa046d87SRobert Watson  * contract to Juniper Networks, Inc.
10fa046d87SRobert Watson  *
11df8bae1dSRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
12df8bae1dSRodney W. Grimes  * modification, are permitted provided that the following conditions
13df8bae1dSRodney W. Grimes  * are met:
14df8bae1dSRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
15df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
16df8bae1dSRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
17df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
18df8bae1dSRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
19df8bae1dSRodney W. Grimes  * 4. Neither the name of the University nor the names of its contributors
20df8bae1dSRodney W. Grimes  *    may be used to endorse or promote products derived from this software
21df8bae1dSRodney W. Grimes  *    without specific prior written permission.
22df8bae1dSRodney W. Grimes  *
23df8bae1dSRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24df8bae1dSRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25df8bae1dSRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26df8bae1dSRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27df8bae1dSRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28df8bae1dSRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29df8bae1dSRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30df8bae1dSRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31df8bae1dSRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32df8bae1dSRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33df8bae1dSRodney W. Grimes  * SUCH DAMAGE.
34df8bae1dSRodney W. Grimes  *
356dfab5b1SGarrett Wollman  *	@(#)udp_usrreq.c	8.6 (Berkeley) 5/23/95
36df8bae1dSRodney W. Grimes  */
37df8bae1dSRodney W. Grimes 
384b421e2dSMike Silbersack #include <sys/cdefs.h>
394b421e2dSMike Silbersack __FBSDID("$FreeBSD$");
404b421e2dSMike Silbersack 
410b4ae859SGleb Smirnoff #include "opt_ipfw.h"
4279288c11SBjoern A. Zeeb #include "opt_inet.h"
43cfa1ca9dSYoshinobu Inoue #include "opt_inet6.h"
44f5514f08SRobert Watson #include "opt_ipsec.h"
4557f60867SMark Johnston #include "opt_kdtrace.h"
46cfa1ca9dSYoshinobu Inoue 
47df8bae1dSRodney W. Grimes #include <sys/param.h>
48960ed29cSSeigo Tanimura #include <sys/domain.h>
494f590175SPaul Saab #include <sys/eventhandler.h>
50960ed29cSSeigo Tanimura #include <sys/jail.h>
51b110a8a2SGarrett Wollman #include <sys/kernel.h>
52960ed29cSSeigo Tanimura #include <sys/lock.h>
53df8bae1dSRodney W. Grimes #include <sys/malloc.h>
54df8bae1dSRodney W. Grimes #include <sys/mbuf.h>
55acd3428bSRobert Watson #include <sys/priv.h>
56490d50b6SBrian Feldman #include <sys/proc.h>
57df8bae1dSRodney W. Grimes #include <sys/protosw.h>
5857f60867SMark Johnston #include <sys/sdt.h>
59960ed29cSSeigo Tanimura #include <sys/signalvar.h>
60df8bae1dSRodney W. Grimes #include <sys/socket.h>
61df8bae1dSRodney W. Grimes #include <sys/socketvar.h>
62960ed29cSSeigo Tanimura #include <sys/sx.h>
63b5e8ce9fSBruce Evans #include <sys/sysctl.h>
64816a3d83SPoul-Henning Kamp #include <sys/syslog.h>
65f5514f08SRobert Watson #include <sys/systm.h>
668781d8e9SBruce Evans 
6769c2d429SJeff Roberson #include <vm/uma.h>
68df8bae1dSRodney W. Grimes 
69df8bae1dSRodney W. Grimes #include <net/if.h>
70df8bae1dSRodney W. Grimes #include <net/route.h>
71df8bae1dSRodney W. Grimes 
72df8bae1dSRodney W. Grimes #include <netinet/in.h>
7357f60867SMark Johnston #include <netinet/in_kdtrace.h>
74960ed29cSSeigo Tanimura #include <netinet/in_pcb.h>
75f5514f08SRobert Watson #include <netinet/in_systm.h>
76960ed29cSSeigo Tanimura #include <netinet/in_var.h>
77df8bae1dSRodney W. Grimes #include <netinet/ip.h>
78cfa1ca9dSYoshinobu Inoue #ifdef INET6
79cfa1ca9dSYoshinobu Inoue #include <netinet/ip6.h>
80cfa1ca9dSYoshinobu Inoue #endif
81960ed29cSSeigo Tanimura #include <netinet/ip_icmp.h>
82960ed29cSSeigo Tanimura #include <netinet/icmp_var.h>
83df8bae1dSRodney W. Grimes #include <netinet/ip_var.h>
84ef39adf0SAndre Oppermann #include <netinet/ip_options.h>
85cfa1ca9dSYoshinobu Inoue #ifdef INET6
86cfa1ca9dSYoshinobu Inoue #include <netinet6/ip6_var.h>
87cfa1ca9dSYoshinobu Inoue #endif
88df8bae1dSRodney W. Grimes #include <netinet/udp.h>
89df8bae1dSRodney W. Grimes #include <netinet/udp_var.h>
90df8bae1dSRodney W. Grimes 
91b2630c29SGeorge V. Neville-Neil #ifdef IPSEC
92b9234fafSSam Leffler #include <netipsec/ipsec.h>
937b495c44SVANHULLEBUS Yvan #include <netipsec/esp.h>
943329b236SRobert Watson #endif
95b9234fafSSam Leffler 
96db4f9cc7SJonathan Lemon #include <machine/in_cksum.h>
97db4f9cc7SJonathan Lemon 
98aed55708SRobert Watson #include <security/mac/mac_framework.h>
99aed55708SRobert Watson 
100df8bae1dSRodney W. Grimes /*
101df8bae1dSRodney W. Grimes  * UDP protocol implementation.
102df8bae1dSRodney W. Grimes  * Per RFC 768, August, 1980.
103df8bae1dSRodney W. Grimes  */
10474eb3236SWarner Losh 
10574eb3236SWarner Losh /*
1063329b236SRobert Watson  * BSD 4.2 defaulted the udp checksum to be off.  Turning off udp checksums
1073329b236SRobert Watson  * removes the only data integrity mechanism for packets and malformed
108f5514f08SRobert Watson  * packets that would otherwise be discarded due to bad checksums, and may
109f5514f08SRobert Watson  * cause problems (especially for NFS data blocks).
11074eb3236SWarner Losh  */
11140b676beSBjoern A. Zeeb VNET_DEFINE(int, udp_cksum) = 1;
11240b676beSBjoern A. Zeeb SYSCTL_VNET_INT(_net_inet_udp, UDPCTL_CHECKSUM, checksum, CTLFLAG_RW,
11340b676beSBjoern A. Zeeb     &VNET_NAME(udp_cksum), 0, "compute udp checksum");
114df8bae1dSRodney W. Grimes 
115afdb4274SRobert Watson int	udp_log_in_vain = 0;
116816a3d83SPoul-Henning Kamp SYSCTL_INT(_net_inet_udp, OID_AUTO, log_in_vain, CTLFLAG_RW,
117afdb4274SRobert Watson     &udp_log_in_vain, 0, "Log all incoming UDP packets");
118816a3d83SPoul-Henning Kamp 
11982cea7e6SBjoern A. Zeeb VNET_DEFINE(int, udp_blackhole) = 0;
120eddfbb76SRobert Watson SYSCTL_VNET_INT(_net_inet_udp, OID_AUTO, blackhole, CTLFLAG_RW,
121eddfbb76SRobert Watson     &VNET_NAME(udp_blackhole), 0,
1223329b236SRobert Watson     "Do not send port unreachables for refused connects");
12316f7f31fSGeoff Rehmet 
12443bbb6aaSRobert Watson u_long	udp_sendspace = 9216;		/* really max datagram size */
12543bbb6aaSRobert Watson 					/* 40 1K datagrams */
12643bbb6aaSRobert Watson SYSCTL_ULONG(_net_inet_udp, UDPCTL_MAXDGRAM, maxdgram, CTLFLAG_RW,
12743bbb6aaSRobert Watson     &udp_sendspace, 0, "Maximum outgoing UDP datagram size");
12843bbb6aaSRobert Watson 
12943bbb6aaSRobert Watson u_long	udp_recvspace = 40 * (1024 +
13043bbb6aaSRobert Watson #ifdef INET6
13143bbb6aaSRobert Watson 				      sizeof(struct sockaddr_in6)
13243bbb6aaSRobert Watson #else
13343bbb6aaSRobert Watson 				      sizeof(struct sockaddr_in)
13443bbb6aaSRobert Watson #endif
13543bbb6aaSRobert Watson 				      );
13643bbb6aaSRobert Watson 
13743bbb6aaSRobert Watson SYSCTL_ULONG(_net_inet_udp, UDPCTL_RECVSPACE, recvspace, CTLFLAG_RW,
13843bbb6aaSRobert Watson     &udp_recvspace, 0, "Maximum space for incoming UDP datagrams");
13943bbb6aaSRobert Watson 
140eddfbb76SRobert Watson VNET_DEFINE(struct inpcbhead, udb);		/* from udp_var.h */
141eddfbb76SRobert Watson VNET_DEFINE(struct inpcbinfo, udbinfo);
1423e288e62SDimitry Andric static VNET_DEFINE(uma_zone_t, udpcb_zone);
1431e77c105SRobert Watson #define	V_udpcb_zone			VNET(udpcb_zone)
14415bd2b43SDavid Greenman 
14515bd2b43SDavid Greenman #ifndef UDBHASHSIZE
146e2ed8f35SAlexander Motin #define	UDBHASHSIZE	128
14715bd2b43SDavid Greenman #endif
14815bd2b43SDavid Greenman 
1495b7cb97cSAndrey V. Elsukov VNET_PCPUSTAT_DEFINE(struct udpstat, udpstat);		/* from udp_var.h */
1505b7cb97cSAndrey V. Elsukov VNET_PCPUSTAT_SYSINIT(udpstat);
1515b7cb97cSAndrey V. Elsukov SYSCTL_VNET_PCPUSTAT(_net_inet_udp, UDPCTL_STATS, stats, struct udpstat,
1525b7cb97cSAndrey V. Elsukov     udpstat, "UDP statistics (struct udpstat, netinet/udp_var.h)");
153f2ea20e6SGarrett Wollman 
1545b7cb97cSAndrey V. Elsukov #ifdef VIMAGE
1555b7cb97cSAndrey V. Elsukov VNET_PCPUSTAT_SYSUNINIT(udpstat);
1565b7cb97cSAndrey V. Elsukov #endif /* VIMAGE */
15779288c11SBjoern A. Zeeb #ifdef INET
158bc725eafSRobert Watson static void	udp_detach(struct socket *so);
1594d77a549SAlfred Perlstein static int	udp_output(struct inpcb *, struct mbuf *, struct sockaddr *,
1604d77a549SAlfred Perlstein 		    struct mbuf *, struct thread *);
16179288c11SBjoern A. Zeeb #endif
16279288c11SBjoern A. Zeeb 
1637b495c44SVANHULLEBUS Yvan #ifdef IPSEC
1647b495c44SVANHULLEBUS Yvan #ifdef IPSEC_NAT_T
1657b495c44SVANHULLEBUS Yvan #define	UF_ESPINUDP_ALL	(UF_ESPINUDP_NON_IKE|UF_ESPINUDP)
1667b495c44SVANHULLEBUS Yvan #ifdef INET
1677b495c44SVANHULLEBUS Yvan static struct mbuf *udp4_espdecap(struct inpcb *, struct mbuf *, int);
1687b495c44SVANHULLEBUS Yvan #endif
1697b495c44SVANHULLEBUS Yvan #endif /* IPSEC_NAT_T */
1707b495c44SVANHULLEBUS Yvan #endif /* IPSEC */
171df8bae1dSRodney W. Grimes 
1724f590175SPaul Saab static void
1734f590175SPaul Saab udp_zone_change(void *tag)
1744f590175SPaul Saab {
1754f590175SPaul Saab 
176603724d3SBjoern A. Zeeb 	uma_zone_set_max(V_udbinfo.ipi_zone, maxsockets);
1776a9148feSBjoern A. Zeeb 	uma_zone_set_max(V_udpcb_zone, maxsockets);
1784f590175SPaul Saab }
1794f590175SPaul Saab 
180d915b280SStephan Uphoff static int
181d915b280SStephan Uphoff udp_inpcb_init(void *mem, int size, int flags)
182d915b280SStephan Uphoff {
183af1ee11dSRobert Watson 	struct inpcb *inp;
18408651e1fSJohn Baldwin 
185af1ee11dSRobert Watson 	inp = mem;
186d915b280SStephan Uphoff 	INP_LOCK_INIT(inp, "inp", "udpinp");
187d915b280SStephan Uphoff 	return (0);
188d915b280SStephan Uphoff }
189d915b280SStephan Uphoff 
190df8bae1dSRodney W. Grimes void
191af1ee11dSRobert Watson udp_init(void)
192df8bae1dSRodney W. Grimes {
193af1ee11dSRobert Watson 
1949bcd427bSRobert Watson 	in_pcbinfo_init(&V_udbinfo, "udp", &V_udb, UDBHASHSIZE, UDBHASHSIZE,
19552cd27cbSRobert Watson 	    "udp_inpcb", udp_inpcb_init, NULL, UMA_ZONE_NOFREE,
19652cd27cbSRobert Watson 	    IPI_HASHFIELDS_2TUPLE);
1976a9148feSBjoern A. Zeeb 	V_udpcb_zone = uma_zcreate("udpcb", sizeof(struct udpcb),
1986a9148feSBjoern A. Zeeb 	    NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
1996a9148feSBjoern A. Zeeb 	uma_zone_set_max(V_udpcb_zone, maxsockets);
2006acd596eSPawel Jakub Dawidek 	uma_zone_set_warning(V_udpcb_zone, "kern.ipc.maxsockets limit reached");
2014f590175SPaul Saab 	EVENTHANDLER_REGISTER(maxsockets_change, udp_zone_change, NULL,
2024f590175SPaul Saab 	    EVENTHANDLER_PRI_ANY);
203df8bae1dSRodney W. Grimes }
204df8bae1dSRodney W. Grimes 
205315e3e38SRobert Watson /*
206315e3e38SRobert Watson  * Kernel module interface for updating udpstat.  The argument is an index
207315e3e38SRobert Watson  * into udpstat treated as an array of u_long.  While this encodes the
208315e3e38SRobert Watson  * general layout of udpstat into the caller, it doesn't encode its location,
209315e3e38SRobert Watson  * so that future changes to add, for example, per-CPU stats support won't
210315e3e38SRobert Watson  * cause binary compatibility problems for kernel modules.
211315e3e38SRobert Watson  */
212315e3e38SRobert Watson void
213315e3e38SRobert Watson kmod_udpstat_inc(int statnum)
214315e3e38SRobert Watson {
215315e3e38SRobert Watson 
2165b7cb97cSAndrey V. Elsukov 	counter_u64_add(VNET(udpstat)[statnum], 1);
217315e3e38SRobert Watson }
218315e3e38SRobert Watson 
2196a9148feSBjoern A. Zeeb int
2206a9148feSBjoern A. Zeeb udp_newudpcb(struct inpcb *inp)
2216a9148feSBjoern A. Zeeb {
2226a9148feSBjoern A. Zeeb 	struct udpcb *up;
2236a9148feSBjoern A. Zeeb 
2246a9148feSBjoern A. Zeeb 	up = uma_zalloc(V_udpcb_zone, M_NOWAIT | M_ZERO);
2256a9148feSBjoern A. Zeeb 	if (up == NULL)
2266a9148feSBjoern A. Zeeb 		return (ENOBUFS);
2276a9148feSBjoern A. Zeeb 	inp->inp_ppcb = up;
2286a9148feSBjoern A. Zeeb 	return (0);
2296a9148feSBjoern A. Zeeb }
2306a9148feSBjoern A. Zeeb 
2316a9148feSBjoern A. Zeeb void
2326a9148feSBjoern A. Zeeb udp_discardcb(struct udpcb *up)
2336a9148feSBjoern A. Zeeb {
2346a9148feSBjoern A. Zeeb 
2356a9148feSBjoern A. Zeeb 	uma_zfree(V_udpcb_zone, up);
2366a9148feSBjoern A. Zeeb }
2376a9148feSBjoern A. Zeeb 
238bc29160dSMarko Zec #ifdef VIMAGE
239bc29160dSMarko Zec void
240bc29160dSMarko Zec udp_destroy(void)
241bc29160dSMarko Zec {
242bc29160dSMarko Zec 
2439bcd427bSRobert Watson 	in_pcbinfo_destroy(&V_udbinfo);
244391dab1cSBjoern A. Zeeb 	uma_zdestroy(V_udpcb_zone);
245bc29160dSMarko Zec }
246bc29160dSMarko Zec #endif
247bc29160dSMarko Zec 
24879288c11SBjoern A. Zeeb #ifdef INET
24943bbb6aaSRobert Watson /*
25043bbb6aaSRobert Watson  * Subroutine of udp_input(), which appends the provided mbuf chain to the
25143bbb6aaSRobert Watson  * passed pcb/socket.  The caller must provide a sockaddr_in via udp_in that
25243bbb6aaSRobert Watson  * contains the source address.  If the socket ends up being an IPv6 socket,
25343bbb6aaSRobert Watson  * udp_append() will convert to a sockaddr_in6 before passing the address
25443bbb6aaSRobert Watson  * into the socket code.
25543bbb6aaSRobert Watson  */
25643bbb6aaSRobert Watson static void
25743bbb6aaSRobert Watson udp_append(struct inpcb *inp, struct ip *ip, struct mbuf *n, int off,
25843bbb6aaSRobert Watson     struct sockaddr_in *udp_in)
25943bbb6aaSRobert Watson {
26043bbb6aaSRobert Watson 	struct sockaddr *append_sa;
26143bbb6aaSRobert Watson 	struct socket *so;
26243bbb6aaSRobert Watson 	struct mbuf *opts = 0;
26343bbb6aaSRobert Watson #ifdef INET6
26443bbb6aaSRobert Watson 	struct sockaddr_in6 udp_in6;
26543bbb6aaSRobert Watson #endif
2667b495c44SVANHULLEBUS Yvan 	struct udpcb *up;
26743bbb6aaSRobert Watson 
268fa046d87SRobert Watson 	INP_LOCK_ASSERT(inp);
26943bbb6aaSRobert Watson 
27079bb84fbSEdward Tomasz Napierala 	/*
27179bb84fbSEdward Tomasz Napierala 	 * Engage the tunneling protocol.
27279bb84fbSEdward Tomasz Napierala 	 */
27379bb84fbSEdward Tomasz Napierala 	up = intoudpcb(inp);
27479bb84fbSEdward Tomasz Napierala 	if (up->u_tun_func != NULL) {
27579bb84fbSEdward Tomasz Napierala 		(*up->u_tun_func)(n, off, inp);
27679bb84fbSEdward Tomasz Napierala 		return;
27779bb84fbSEdward Tomasz Napierala 	}
27879bb84fbSEdward Tomasz Napierala 
27979bb84fbSEdward Tomasz Napierala 	if (n == NULL)
28079bb84fbSEdward Tomasz Napierala 		return;
28179bb84fbSEdward Tomasz Napierala 
28279bb84fbSEdward Tomasz Napierala 	off += sizeof(struct udphdr);
28379bb84fbSEdward Tomasz Napierala 
28443bbb6aaSRobert Watson #ifdef IPSEC
28543bbb6aaSRobert Watson 	/* Check AH/ESP integrity. */
28643bbb6aaSRobert Watson 	if (ipsec4_in_reject(n, inp)) {
28743bbb6aaSRobert Watson 		m_freem(n);
2886794f460SAndrey V. Elsukov 		IPSECSTAT_INC(ips_in_polvio);
28943bbb6aaSRobert Watson 		return;
29043bbb6aaSRobert Watson 	}
2917b495c44SVANHULLEBUS Yvan #ifdef IPSEC_NAT_T
2927b495c44SVANHULLEBUS Yvan 	up = intoudpcb(inp);
2937b495c44SVANHULLEBUS Yvan 	KASSERT(up != NULL, ("%s: udpcb NULL", __func__));
2947b495c44SVANHULLEBUS Yvan 	if (up->u_flags & UF_ESPINUDP_ALL) {	/* IPSec UDP encaps. */
2957b495c44SVANHULLEBUS Yvan 		n = udp4_espdecap(inp, n, off);
2967b495c44SVANHULLEBUS Yvan 		if (n == NULL)				/* Consumed. */
2977b495c44SVANHULLEBUS Yvan 			return;
2987b495c44SVANHULLEBUS Yvan 	}
2997b495c44SVANHULLEBUS Yvan #endif /* IPSEC_NAT_T */
30043bbb6aaSRobert Watson #endif /* IPSEC */
30143bbb6aaSRobert Watson #ifdef MAC
30230d239bcSRobert Watson 	if (mac_inpcb_check_deliver(inp, n) != 0) {
30343bbb6aaSRobert Watson 		m_freem(n);
30443bbb6aaSRobert Watson 		return;
30543bbb6aaSRobert Watson 	}
30679288c11SBjoern A. Zeeb #endif /* MAC */
30743bbb6aaSRobert Watson 	if (inp->inp_flags & INP_CONTROLOPTS ||
30843bbb6aaSRobert Watson 	    inp->inp_socket->so_options & (SO_TIMESTAMP | SO_BINTIME)) {
30943bbb6aaSRobert Watson #ifdef INET6
3109a38ba81SBjoern A. Zeeb 		if (inp->inp_vflag & INP_IPV6)
31148d48eb9SBjoern A. Zeeb 			(void)ip6_savecontrol_v4(inp, n, &opts, NULL);
3129a38ba81SBjoern A. Zeeb 		else
31379288c11SBjoern A. Zeeb #endif /* INET6 */
31443bbb6aaSRobert Watson 			ip_savecontrol(inp, &opts, ip, n);
31543bbb6aaSRobert Watson 	}
31643bbb6aaSRobert Watson #ifdef INET6
31743bbb6aaSRobert Watson 	if (inp->inp_vflag & INP_IPV6) {
31843bbb6aaSRobert Watson 		bzero(&udp_in6, sizeof(udp_in6));
31943bbb6aaSRobert Watson 		udp_in6.sin6_len = sizeof(udp_in6);
32043bbb6aaSRobert Watson 		udp_in6.sin6_family = AF_INET6;
32143bbb6aaSRobert Watson 		in6_sin_2_v4mapsin6(udp_in, &udp_in6);
32243bbb6aaSRobert Watson 		append_sa = (struct sockaddr *)&udp_in6;
32343bbb6aaSRobert Watson 	} else
32479288c11SBjoern A. Zeeb #endif /* INET6 */
32543bbb6aaSRobert Watson 		append_sa = (struct sockaddr *)udp_in;
32643bbb6aaSRobert Watson 	m_adj(n, off);
32743bbb6aaSRobert Watson 
32843bbb6aaSRobert Watson 	so = inp->inp_socket;
32943bbb6aaSRobert Watson 	SOCKBUF_LOCK(&so->so_rcv);
33043bbb6aaSRobert Watson 	if (sbappendaddr_locked(&so->so_rcv, append_sa, n, opts) == 0) {
33143bbb6aaSRobert Watson 		SOCKBUF_UNLOCK(&so->so_rcv);
33243bbb6aaSRobert Watson 		m_freem(n);
33343bbb6aaSRobert Watson 		if (opts)
33443bbb6aaSRobert Watson 			m_freem(opts);
335026decb8SRobert Watson 		UDPSTAT_INC(udps_fullsock);
33643bbb6aaSRobert Watson 	} else
33743bbb6aaSRobert Watson 		sorwakeup_locked(so);
33843bbb6aaSRobert Watson }
33943bbb6aaSRobert Watson 
340df8bae1dSRodney W. Grimes void
3413329b236SRobert Watson udp_input(struct mbuf *m, int off)
342df8bae1dSRodney W. Grimes {
343cfa1ca9dSYoshinobu Inoue 	int iphlen = off;
3443329b236SRobert Watson 	struct ip *ip;
3453329b236SRobert Watson 	struct udphdr *uh;
34671498f30SBruce M Simpson 	struct ifnet *ifp;
3473329b236SRobert Watson 	struct inpcb *inp;
3488f134647SGleb Smirnoff 	uint16_t len, ip_len;
349df8bae1dSRodney W. Grimes 	struct ip save_ip;
350d4b509bdSRobert Watson 	struct sockaddr_in udp_in;
3510b4ae859SGleb Smirnoff 	struct m_tag *fwd_tag;
352df8bae1dSRodney W. Grimes 
35371498f30SBruce M Simpson 	ifp = m->m_pkthdr.rcvif;
354026decb8SRobert Watson 	UDPSTAT_INC(udps_ipackets);
355df8bae1dSRodney W. Grimes 
356df8bae1dSRodney W. Grimes 	/*
3573329b236SRobert Watson 	 * Strip IP options, if any; should skip this, make available to
3583329b236SRobert Watson 	 * user, and use on returned packets, but we don't yet have a way to
3593329b236SRobert Watson 	 * check the checksum with options still present.
360df8bae1dSRodney W. Grimes 	 */
361df8bae1dSRodney W. Grimes 	if (iphlen > sizeof (struct ip)) {
362105bd211SGleb Smirnoff 		ip_stripoptions(m);
363df8bae1dSRodney W. Grimes 		iphlen = sizeof(struct ip);
364df8bae1dSRodney W. Grimes 	}
365df8bae1dSRodney W. Grimes 
366df8bae1dSRodney W. Grimes 	/*
367df8bae1dSRodney W. Grimes 	 * Get IP and UDP header together in first mbuf.
368df8bae1dSRodney W. Grimes 	 */
369df8bae1dSRodney W. Grimes 	ip = mtod(m, struct ip *);
370df8bae1dSRodney W. Grimes 	if (m->m_len < iphlen + sizeof(struct udphdr)) {
371df8bae1dSRodney W. Grimes 		if ((m = m_pullup(m, iphlen + sizeof(struct udphdr))) == 0) {
372026decb8SRobert Watson 			UDPSTAT_INC(udps_hdrops);
373df8bae1dSRodney W. Grimes 			return;
374df8bae1dSRodney W. Grimes 		}
375df8bae1dSRodney W. Grimes 		ip = mtod(m, struct ip *);
376df8bae1dSRodney W. Grimes 	}
377df8bae1dSRodney W. Grimes 	uh = (struct udphdr *)((caddr_t)ip + iphlen);
378df8bae1dSRodney W. Grimes 
3793329b236SRobert Watson 	/*
3803329b236SRobert Watson 	 * Destination port of 0 is illegal, based on RFC768.
3813329b236SRobert Watson 	 */
382686cdd19SJun-ichiro itojun Hagino 	if (uh->uh_dport == 0)
383f76fcf6dSJeffrey Hsu 		goto badunlocked;
384686cdd19SJun-ichiro itojun Hagino 
385df8bae1dSRodney W. Grimes 	/*
3863329b236SRobert Watson 	 * Construct sockaddr format source address.  Stuff source address
3873329b236SRobert Watson 	 * and datagram in user buffer.
388b9234fafSSam Leffler 	 */
389d4b509bdSRobert Watson 	bzero(&udp_in, sizeof(udp_in));
390d4b509bdSRobert Watson 	udp_in.sin_len = sizeof(udp_in);
391d4b509bdSRobert Watson 	udp_in.sin_family = AF_INET;
392b9234fafSSam Leffler 	udp_in.sin_port = uh->uh_sport;
393b9234fafSSam Leffler 	udp_in.sin_addr = ip->ip_src;
394b9234fafSSam Leffler 
395b9234fafSSam Leffler 	/*
396af1ee11dSRobert Watson 	 * Make mbuf data length reflect UDP length.  If not enough data to
397af1ee11dSRobert Watson 	 * reflect UDP length, drop.
398df8bae1dSRodney W. Grimes 	 */
399df8bae1dSRodney W. Grimes 	len = ntohs((u_short)uh->uh_ulen);
4008ad458a4SGleb Smirnoff 	ip_len = ntohs(ip->ip_len) - iphlen;
4018f134647SGleb Smirnoff 	if (ip_len != len) {
4028f134647SGleb Smirnoff 		if (len > ip_len || len < sizeof(struct udphdr)) {
403026decb8SRobert Watson 			UDPSTAT_INC(udps_badlen);
404f76fcf6dSJeffrey Hsu 			goto badunlocked;
405df8bae1dSRodney W. Grimes 		}
4068f134647SGleb Smirnoff 		m_adj(m, len - ip_len);
407df8bae1dSRodney W. Grimes 	}
4083329b236SRobert Watson 
409df8bae1dSRodney W. Grimes 	/*
4103329b236SRobert Watson 	 * Save a copy of the IP header in case we want restore it for
4113329b236SRobert Watson 	 * sending an ICMP error message in response.
412df8bae1dSRodney W. Grimes 	 */
413603724d3SBjoern A. Zeeb 	if (!V_udp_blackhole)
414df8bae1dSRodney W. Grimes 		save_ip = *ip;
415cce418d3SMatt Jacob 	else
416cce418d3SMatt Jacob 		memset(&save_ip, 0, sizeof(save_ip));
417df8bae1dSRodney W. Grimes 
418df8bae1dSRodney W. Grimes 	/*
419df8bae1dSRodney W. Grimes 	 * Checksum extended UDP header and data.
420df8bae1dSRodney W. Grimes 	 */
4216dfab5b1SGarrett Wollman 	if (uh->uh_sum) {
42239629c92SDavid Malone 		u_short uh_sum;
42339629c92SDavid Malone 
424db4f9cc7SJonathan Lemon 		if (m->m_pkthdr.csum_flags & CSUM_DATA_VALID) {
425db4f9cc7SJonathan Lemon 			if (m->m_pkthdr.csum_flags & CSUM_PSEUDO_HDR)
42639629c92SDavid Malone 				uh_sum = m->m_pkthdr.csum_data;
427db4f9cc7SJonathan Lemon 			else
42839629c92SDavid Malone 				uh_sum = in_pseudo(ip->ip_src.s_addr,
429506f4949SRuslan Ermilov 				    ip->ip_dst.s_addr, htonl((u_short)len +
430db4f9cc7SJonathan Lemon 				    m->m_pkthdr.csum_data + IPPROTO_UDP));
43139629c92SDavid Malone 			uh_sum ^= 0xffff;
432db4f9cc7SJonathan Lemon 		} else {
433cb342100SHajimu UMEMOTO 			char b[9];
434af1ee11dSRobert Watson 
435cb342100SHajimu UMEMOTO 			bcopy(((struct ipovly *)ip)->ih_x1, b, 9);
4366effc713SDoug Rabson 			bzero(((struct ipovly *)ip)->ih_x1, 9);
437df8bae1dSRodney W. Grimes 			((struct ipovly *)ip)->ih_len = uh->uh_ulen;
43839629c92SDavid Malone 			uh_sum = in_cksum(m, len + sizeof (struct ip));
439cb342100SHajimu UMEMOTO 			bcopy(b, ((struct ipovly *)ip)->ih_x1, 9);
440db4f9cc7SJonathan Lemon 		}
44139629c92SDavid Malone 		if (uh_sum) {
442026decb8SRobert Watson 			UDPSTAT_INC(udps_badsum);
443df8bae1dSRodney W. Grimes 			m_freem(m);
444df8bae1dSRodney W. Grimes 			return;
445df8bae1dSRodney W. Grimes 		}
446fb9aaba0SRuslan Ermilov 	} else
447026decb8SRobert Watson 		UDPSTAT_INC(udps_nosum);
448df8bae1dSRodney W. Grimes 
449df8bae1dSRodney W. Grimes 	if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) ||
45071498f30SBruce M Simpson 	    in_broadcast(ip->ip_dst, ifp)) {
45182c23ebaSBill Fenner 		struct inpcb *last;
45271498f30SBruce M Simpson 		struct ip_moptions *imo;
4533329b236SRobert Watson 
454fa046d87SRobert Watson 		INP_INFO_RLOCK(&V_udbinfo);
455df8bae1dSRodney W. Grimes 		last = NULL;
456603724d3SBjoern A. Zeeb 		LIST_FOREACH(inp, &V_udb, inp_list) {
4579c1df695SRobert Watson 			if (inp->inp_lport != uh->uh_dport)
458f76fcf6dSJeffrey Hsu 				continue;
459cfa1ca9dSYoshinobu Inoue #ifdef INET6
460369dc8ceSEivind Eklund 			if ((inp->inp_vflag & INP_IPV4) == 0)
4619c1df695SRobert Watson 				continue;
462cfa1ca9dSYoshinobu Inoue #endif
46371498f30SBruce M Simpson 			if (inp->inp_laddr.s_addr != INADDR_ANY &&
46471498f30SBruce M Simpson 			    inp->inp_laddr.s_addr != ip->ip_dst.s_addr)
4659c1df695SRobert Watson 				continue;
46671498f30SBruce M Simpson 			if (inp->inp_faddr.s_addr != INADDR_ANY &&
46771498f30SBruce M Simpson 			    inp->inp_faddr.s_addr != ip->ip_src.s_addr)
46871498f30SBruce M Simpson 				continue;
46971498f30SBruce M Simpson 			if (inp->inp_fport != 0 &&
470df8bae1dSRodney W. Grimes 			    inp->inp_fport != uh->uh_sport)
4719c1df695SRobert Watson 				continue;
47271498f30SBruce M Simpson 
473119d85f6SRobert Watson 			INP_RLOCK(inp);
474df8bae1dSRodney W. Grimes 
47583453a06SBruce M Simpson 			/*
476fa046d87SRobert Watson 			 * XXXRW: Because we weren't holding either the inpcb
477fa046d87SRobert Watson 			 * or the hash lock when we checked for a match
478fa046d87SRobert Watson 			 * before, we should probably recheck now that the
479fa046d87SRobert Watson 			 * inpcb lock is held.
480fa046d87SRobert Watson 			 */
481fa046d87SRobert Watson 
482fa046d87SRobert Watson 			/*
48371498f30SBruce M Simpson 			 * Handle socket delivery policy for any-source
48471498f30SBruce M Simpson 			 * and source-specific multicast. [RFC3678]
48583453a06SBruce M Simpson 			 */
48671498f30SBruce M Simpson 			imo = inp->inp_moptions;
487a38b1c8cSRandall Stewart 			if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) {
488d10910e6SBruce M Simpson 				struct sockaddr_in	 group;
489d10910e6SBruce M Simpson 				int			 blocked;
490a38b1c8cSRandall Stewart 				if (imo == NULL) {
491a38b1c8cSRandall Stewart 					INP_RUNLOCK(inp);
492a38b1c8cSRandall Stewart 					continue;
493a38b1c8cSRandall Stewart 				}
494d10910e6SBruce M Simpson 				bzero(&group, sizeof(struct sockaddr_in));
495d10910e6SBruce M Simpson 				group.sin_len = sizeof(struct sockaddr_in);
496d10910e6SBruce M Simpson 				group.sin_family = AF_INET;
497d10910e6SBruce M Simpson 				group.sin_addr = ip->ip_dst;
49871498f30SBruce M Simpson 
499d10910e6SBruce M Simpson 				blocked = imo_multi_filter(imo, ifp,
500d10910e6SBruce M Simpson 					(struct sockaddr *)&group,
50171498f30SBruce M Simpson 					(struct sockaddr *)&udp_in);
502d10910e6SBruce M Simpson 				if (blocked != MCAST_PASS) {
503d10910e6SBruce M Simpson 					if (blocked == MCAST_NOTGMEMBER)
50486425c62SRobert Watson 						IPSTAT_INC(ips_notmember);
505d10910e6SBruce M Simpson 					if (blocked == MCAST_NOTSMEMBER ||
506d10910e6SBruce M Simpson 					    blocked == MCAST_MUTED)
507026decb8SRobert Watson 						UDPSTAT_INC(udps_filtermcast);
508119d85f6SRobert Watson 					INP_RUNLOCK(inp);
5099c1df695SRobert Watson 					continue;
5109c1df695SRobert Watson 				}
51183453a06SBruce M Simpson 			}
512df8bae1dSRodney W. Grimes 			if (last != NULL) {
513df8bae1dSRodney W. Grimes 				struct mbuf *n;
514df8bae1dSRodney W. Grimes 
515032dcc76SLuigi Rizzo 				n = m_copy(m, 0, M_COPYALL);
51679bb84fbSEdward Tomasz Napierala 				udp_append(last, ip, n, iphlen, &udp_in);
5176a9148feSBjoern A. Zeeb 				INP_RUNLOCK(last);
518df8bae1dSRodney W. Grimes 			}
51982c23ebaSBill Fenner 			last = inp;
520df8bae1dSRodney W. Grimes 			/*
521df8bae1dSRodney W. Grimes 			 * Don't look for additional matches if this one does
522df8bae1dSRodney W. Grimes 			 * not have either the SO_REUSEPORT or SO_REUSEADDR
5233329b236SRobert Watson 			 * socket options set.  This heuristic avoids
5243329b236SRobert Watson 			 * searching through all pcbs in the common case of a
5253329b236SRobert Watson 			 * non-shared port.  It assumes that an application
5263329b236SRobert Watson 			 * will never clear these options after setting them.
527df8bae1dSRodney W. Grimes 			 */
5283329b236SRobert Watson 			if ((last->inp_socket->so_options &
5293329b236SRobert Watson 			    (SO_REUSEPORT|SO_REUSEADDR)) == 0)
530df8bae1dSRodney W. Grimes 				break;
531df8bae1dSRodney W. Grimes 		}
532df8bae1dSRodney W. Grimes 
533df8bae1dSRodney W. Grimes 		if (last == NULL) {
534df8bae1dSRodney W. Grimes 			/*
5353329b236SRobert Watson 			 * No matching pcb found; discard datagram.  (No need
5363329b236SRobert Watson 			 * to send an ICMP Port Unreachable for a broadcast
5373329b236SRobert Watson 			 * or multicast datgram.)
538df8bae1dSRodney W. Grimes 			 */
539026decb8SRobert Watson 			UDPSTAT_INC(udps_noportbcast);
540fa046d87SRobert Watson 			if (inp)
541fa046d87SRobert Watson 				INP_RUNLOCK(inp);
542fa046d87SRobert Watson 			INP_INFO_RUNLOCK(&V_udbinfo);
543fa046d87SRobert Watson 			goto badunlocked;
544df8bae1dSRodney W. Grimes 		}
54579bb84fbSEdward Tomasz Napierala 		udp_append(last, ip, m, iphlen, &udp_in);
546c7c7ea4bSRandall Stewart 		INP_RUNLOCK(last);
547c7c7ea4bSRandall Stewart 		INP_INFO_RUNLOCK(&V_udbinfo);
548df8bae1dSRodney W. Grimes 		return;
549df8bae1dSRodney W. Grimes 	}
5503329b236SRobert Watson 
551df8bae1dSRodney W. Grimes 	/*
5526d6a026bSDavid Greenman 	 * Locate pcb for datagram.
553df8bae1dSRodney W. Grimes 	 */
554c1de64a4SAndrey V. Elsukov 
5558a006adbSBjoern A. Zeeb 	/*
5568a006adbSBjoern A. Zeeb 	 * Grab info from PACKET_TAG_IPFORWARD tag prepended to the chain.
5578a006adbSBjoern A. Zeeb 	 */
558ffdbf9daSAndrey V. Elsukov 	if ((m->m_flags & M_IP_NEXTHOP) &&
559c1de64a4SAndrey V. Elsukov 	    (fwd_tag = m_tag_find(m, PACKET_TAG_IPFORWARD, NULL)) != NULL) {
5608a006adbSBjoern A. Zeeb 		struct sockaddr_in *next_hop;
5618a006adbSBjoern A. Zeeb 
5628a006adbSBjoern A. Zeeb 		next_hop = (struct sockaddr_in *)(fwd_tag + 1);
5638a006adbSBjoern A. Zeeb 
5648a006adbSBjoern A. Zeeb 		/*
5658a006adbSBjoern A. Zeeb 		 * Transparently forwarded. Pretend to be the destination.
5668a006adbSBjoern A. Zeeb 		 * Already got one like this?
5678a006adbSBjoern A. Zeeb 		 */
568d3c1f003SRobert Watson 		inp = in_pcblookup_mbuf(&V_udbinfo, ip->ip_src, uh->uh_sport,
5698a006adbSBjoern A. Zeeb 		    ip->ip_dst, uh->uh_dport, INPLOOKUP_RLOCKPCB, ifp, m);
5708a006adbSBjoern A. Zeeb 		if (!inp) {
5718a006adbSBjoern A. Zeeb 			/*
5728a006adbSBjoern A. Zeeb 			 * It's new.  Try to find the ambushing socket.
5738a006adbSBjoern A. Zeeb 			 * Because we've rewritten the destination address,
5748a006adbSBjoern A. Zeeb 			 * any hardware-generated hash is ignored.
5758a006adbSBjoern A. Zeeb 			 */
5768a006adbSBjoern A. Zeeb 			inp = in_pcblookup(&V_udbinfo, ip->ip_src,
5778a006adbSBjoern A. Zeeb 			    uh->uh_sport, next_hop->sin_addr,
5788a006adbSBjoern A. Zeeb 			    next_hop->sin_port ? htons(next_hop->sin_port) :
5798a006adbSBjoern A. Zeeb 			    uh->uh_dport, INPLOOKUP_WILDCARD |
5808a006adbSBjoern A. Zeeb 			    INPLOOKUP_RLOCKPCB, ifp);
5818a006adbSBjoern A. Zeeb 		}
5828a006adbSBjoern A. Zeeb 		/* Remove the tag from the packet. We don't need it anymore. */
5838a006adbSBjoern A. Zeeb 		m_tag_delete(m, fwd_tag);
584ffdbf9daSAndrey V. Elsukov 		m->m_flags &= ~M_IP_NEXTHOP;
5858a006adbSBjoern A. Zeeb 	} else
5868a006adbSBjoern A. Zeeb 		inp = in_pcblookup_mbuf(&V_udbinfo, ip->ip_src, uh->uh_sport,
5878a006adbSBjoern A. Zeeb 		    ip->ip_dst, uh->uh_dport, INPLOOKUP_WILDCARD |
5888a006adbSBjoern A. Zeeb 		    INPLOOKUP_RLOCKPCB, ifp, m);
58915bd2b43SDavid Greenman 	if (inp == NULL) {
590afdb4274SRobert Watson 		if (udp_log_in_vain) {
591df5c0b8aSBill Fenner 			char buf[4*sizeof "123"];
59275cfc95fSAndrey A. Chernov 
59375cfc95fSAndrey A. Chernov 			strcpy(buf, inet_ntoa(ip->ip_dst));
594592071e8SBruce Evans 			log(LOG_INFO,
595592071e8SBruce Evans 			    "Connection attempt to UDP %s:%d from %s:%d\n",
596592071e8SBruce Evans 			    buf, ntohs(uh->uh_dport), inet_ntoa(ip->ip_src),
597592071e8SBruce Evans 			    ntohs(uh->uh_sport));
59875cfc95fSAndrey A. Chernov 		}
599026decb8SRobert Watson 		UDPSTAT_INC(udps_noport);
600df8bae1dSRodney W. Grimes 		if (m->m_flags & (M_BCAST | M_MCAST)) {
601026decb8SRobert Watson 			UDPSTAT_INC(udps_noportbcast);
602fa046d87SRobert Watson 			goto badunlocked;
603df8bae1dSRodney W. Grimes 		}
604603724d3SBjoern A. Zeeb 		if (V_udp_blackhole)
605fa046d87SRobert Watson 			goto badunlocked;
6061cbd978eSLuigi Rizzo 		if (badport_bandlim(BANDLIM_ICMP_UNREACH) < 0)
607fa046d87SRobert Watson 			goto badunlocked;
60804287599SRuslan Ermilov 		*ip = save_ip;
609582a7760SBruce Evans 		icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_PORT, 0, 0);
610df8bae1dSRodney W. Grimes 		return;
611df8bae1dSRodney W. Grimes 	}
6123329b236SRobert Watson 
6133329b236SRobert Watson 	/*
6143329b236SRobert Watson 	 * Check the minimum TTL for socket.
6153329b236SRobert Watson 	 */
616fa046d87SRobert Watson 	INP_RLOCK_ASSERT(inp);
61710cc62b7SRobert Watson 	if (inp->inp_ip_minttl && inp->inp_ip_minttl > ip->ip_ttl) {
61810cc62b7SRobert Watson 		INP_RUNLOCK(inp);
619fa046d87SRobert Watson 		m_freem(m);
620fa046d87SRobert Watson 		return;
62110cc62b7SRobert Watson 	}
62257f60867SMark Johnston 
623*1ad19fb6SMark Johnston 	UDP_PROBE(receive, NULL, inp, ip, inp, uh);
62479bb84fbSEdward Tomasz Napierala 	udp_append(inp, ip, m, iphlen, &udp_in);
625119d85f6SRobert Watson 	INP_RUNLOCK(inp);
626df8bae1dSRodney W. Grimes 	return;
62761ffc0b1SJeffrey Hsu 
628f76fcf6dSJeffrey Hsu badunlocked:
629df8bae1dSRodney W. Grimes 	m_freem(m);
630cfa1ca9dSYoshinobu Inoue }
63179288c11SBjoern A. Zeeb #endif /* INET */
632cfa1ca9dSYoshinobu Inoue 
633cfa1ca9dSYoshinobu Inoue /*
6343329b236SRobert Watson  * Notify a udp user of an asynchronous error; just wake up so that they can
6353329b236SRobert Watson  * collect error status.
636df8bae1dSRodney W. Grimes  */
6373ce144eaSJeffrey Hsu struct inpcb *
6383329b236SRobert Watson udp_notify(struct inpcb *inp, int errno)
639df8bae1dSRodney W. Grimes {
6403329b236SRobert Watson 
641ac9ae279SRobert Watson 	/*
642ac9ae279SRobert Watson 	 * While udp_ctlinput() always calls udp_notify() with a read lock
643ac9ae279SRobert Watson 	 * when invoking it directly, in_pcbnotifyall() currently uses write
644ac9ae279SRobert Watson 	 * locks due to sharing code with TCP.  For now, accept either a read
645ac9ae279SRobert Watson 	 * or a write lock, but a read lock is sufficient.
646ac9ae279SRobert Watson 	 */
647ac9ae279SRobert Watson 	INP_LOCK_ASSERT(inp);
6488501a69cSRobert Watson 
649df8bae1dSRodney W. Grimes 	inp->inp_socket->so_error = errno;
650df8bae1dSRodney W. Grimes 	sorwakeup(inp->inp_socket);
651df8bae1dSRodney W. Grimes 	sowwakeup(inp->inp_socket);
6523329b236SRobert Watson 	return (inp);
653df8bae1dSRodney W. Grimes }
654df8bae1dSRodney W. Grimes 
65579288c11SBjoern A. Zeeb #ifdef INET
656df8bae1dSRodney W. Grimes void
6573329b236SRobert Watson udp_ctlinput(int cmd, struct sockaddr *sa, void *vip)
658df8bae1dSRodney W. Grimes {
659c693a045SJonathan Lemon 	struct ip *ip = vip;
660c693a045SJonathan Lemon 	struct udphdr *uh;
661c693a045SJonathan Lemon 	struct in_addr faddr;
662c693a045SJonathan Lemon 	struct inpcb *inp;
663c693a045SJonathan Lemon 
664c693a045SJonathan Lemon 	faddr = ((struct sockaddr_in *)sa)->sin_addr;
665c693a045SJonathan Lemon 	if (sa->sa_family != AF_INET || faddr.s_addr == INADDR_ANY)
666c693a045SJonathan Lemon 		return;
667df8bae1dSRodney W. Grimes 
66897d8d152SAndre Oppermann 	/*
66997d8d152SAndre Oppermann 	 * Redirects don't need to be handled up here.
67097d8d152SAndre Oppermann 	 */
67197d8d152SAndre Oppermann 	if (PRC_IS_REDIRECT(cmd))
67297d8d152SAndre Oppermann 		return;
6733329b236SRobert Watson 
67497d8d152SAndre Oppermann 	/*
67597d8d152SAndre Oppermann 	 * Hostdead is ugly because it goes linearly through all PCBs.
6763329b236SRobert Watson 	 *
6773329b236SRobert Watson 	 * XXX: We never get this from ICMP, otherwise it makes an excellent
6783329b236SRobert Watson 	 * DoS attack on machines with many connections.
67997d8d152SAndre Oppermann 	 */
68097d8d152SAndre Oppermann 	if (cmd == PRC_HOSTDEAD)
681af1ee11dSRobert Watson 		ip = NULL;
682d1c54148SJesper Skriver 	else if ((unsigned)cmd >= PRC_NCMDS || inetctlerrmap[cmd] == 0)
683df8bae1dSRodney W. Grimes 		return;
684af1ee11dSRobert Watson 	if (ip != NULL) {
685df8bae1dSRodney W. Grimes 		uh = (struct udphdr *)((caddr_t)ip + (ip->ip_hl << 2));
686fa046d87SRobert Watson 		inp = in_pcblookup(&V_udbinfo, faddr, uh->uh_dport,
687fa046d87SRobert Watson 		    ip->ip_src, uh->uh_sport, INPLOOKUP_RLOCKPCB, NULL);
688f76fcf6dSJeffrey Hsu 		if (inp != NULL) {
689fa046d87SRobert Watson 			INP_RLOCK_ASSERT(inp);
690f76fcf6dSJeffrey Hsu 			if (inp->inp_socket != NULL) {
691f5514f08SRobert Watson 				udp_notify(inp, inetctlerrmap[cmd]);
692f76fcf6dSJeffrey Hsu 			}
693ac9ae279SRobert Watson 			INP_RUNLOCK(inp);
694f76fcf6dSJeffrey Hsu 		}
695df8bae1dSRodney W. Grimes 	} else
696603724d3SBjoern A. Zeeb 		in_pcbnotifyall(&V_udbinfo, faddr, inetctlerrmap[cmd],
697f5514f08SRobert Watson 		    udp_notify);
698df8bae1dSRodney W. Grimes }
69979288c11SBjoern A. Zeeb #endif /* INET */
700df8bae1dSRodney W. Grimes 
7010312fbe9SPoul-Henning Kamp static int
70282d9ae4eSPoul-Henning Kamp udp_pcblist(SYSCTL_HANDLER_ARGS)
70398271db4SGarrett Wollman {
704277afaffSRobert Watson 	int error, i, n;
70598271db4SGarrett Wollman 	struct inpcb *inp, **inp_list;
70698271db4SGarrett Wollman 	inp_gen_t gencnt;
70798271db4SGarrett Wollman 	struct xinpgen xig;
70898271db4SGarrett Wollman 
70998271db4SGarrett Wollman 	/*
710f5514f08SRobert Watson 	 * The process of preparing the PCB list is too time-consuming and
71198271db4SGarrett Wollman 	 * resource-intensive to repeat twice on every request.
71298271db4SGarrett Wollman 	 */
71398271db4SGarrett Wollman 	if (req->oldptr == 0) {
714603724d3SBjoern A. Zeeb 		n = V_udbinfo.ipi_count;
715c007b96aSJohn Baldwin 		n += imax(n / 8, 10);
716c007b96aSJohn Baldwin 		req->oldidx = 2 * (sizeof xig) + n * sizeof(struct xinpcb);
7173329b236SRobert Watson 		return (0);
71898271db4SGarrett Wollman 	}
71998271db4SGarrett Wollman 
72098271db4SGarrett Wollman 	if (req->newptr != 0)
7213329b236SRobert Watson 		return (EPERM);
72298271db4SGarrett Wollman 
72398271db4SGarrett Wollman 	/*
72498271db4SGarrett Wollman 	 * OK, now we're committed to doing something.
72598271db4SGarrett Wollman 	 */
726603724d3SBjoern A. Zeeb 	INP_INFO_RLOCK(&V_udbinfo);
727603724d3SBjoern A. Zeeb 	gencnt = V_udbinfo.ipi_gencnt;
728603724d3SBjoern A. Zeeb 	n = V_udbinfo.ipi_count;
729603724d3SBjoern A. Zeeb 	INP_INFO_RUNLOCK(&V_udbinfo);
73098271db4SGarrett Wollman 
73147934cefSDon Lewis 	error = sysctl_wire_old_buffer(req, 2 * (sizeof xig)
7325c38b6dbSDon Lewis 		+ n * sizeof(struct xinpcb));
73347934cefSDon Lewis 	if (error != 0)
73447934cefSDon Lewis 		return (error);
7355c38b6dbSDon Lewis 
73698271db4SGarrett Wollman 	xig.xig_len = sizeof xig;
73798271db4SGarrett Wollman 	xig.xig_count = n;
73898271db4SGarrett Wollman 	xig.xig_gen = gencnt;
73998271db4SGarrett Wollman 	xig.xig_sogen = so_gencnt;
74098271db4SGarrett Wollman 	error = SYSCTL_OUT(req, &xig, sizeof xig);
74198271db4SGarrett Wollman 	if (error)
7423329b236SRobert Watson 		return (error);
74398271db4SGarrett Wollman 
744a163d034SWarner Losh 	inp_list = malloc(n * sizeof *inp_list, M_TEMP, M_WAITOK);
74598271db4SGarrett Wollman 	if (inp_list == 0)
7463329b236SRobert Watson 		return (ENOMEM);
74798271db4SGarrett Wollman 
748603724d3SBjoern A. Zeeb 	INP_INFO_RLOCK(&V_udbinfo);
749603724d3SBjoern A. Zeeb 	for (inp = LIST_FIRST(V_udbinfo.ipi_listhead), i = 0; inp && i < n;
750fc2ffbe6SPoul-Henning Kamp 	     inp = LIST_NEXT(inp, inp_list)) {
751d0e157f6SBjoern A. Zeeb 		INP_WLOCK(inp);
7522ded288cSJeffrey Hsu 		if (inp->inp_gencnt <= gencnt &&
753d0e157f6SBjoern A. Zeeb 		    cr_canseeinpcb(req->td->td_ucred, inp) == 0) {
754d0e157f6SBjoern A. Zeeb 			in_pcbref(inp);
75598271db4SGarrett Wollman 			inp_list[i++] = inp;
756d0e157f6SBjoern A. Zeeb 		}
757d0e157f6SBjoern A. Zeeb 		INP_WUNLOCK(inp);
7584787fd37SPaul Saab 	}
759603724d3SBjoern A. Zeeb 	INP_INFO_RUNLOCK(&V_udbinfo);
76098271db4SGarrett Wollman 	n = i;
76198271db4SGarrett Wollman 
76298271db4SGarrett Wollman 	error = 0;
76398271db4SGarrett Wollman 	for (i = 0; i < n; i++) {
76498271db4SGarrett Wollman 		inp = inp_list[i];
7659622e84fSRobert Watson 		INP_RLOCK(inp);
76698271db4SGarrett Wollman 		if (inp->inp_gencnt <= gencnt) {
76798271db4SGarrett Wollman 			struct xinpcb xi;
768d0e157f6SBjoern A. Zeeb 
769fd94099eSColin Percival 			bzero(&xi, sizeof(xi));
77098271db4SGarrett Wollman 			xi.xi_len = sizeof xi;
77198271db4SGarrett Wollman 			/* XXX should avoid extra copy */
77298271db4SGarrett Wollman 			bcopy(inp, &xi.xi_inp, sizeof *inp);
77398271db4SGarrett Wollman 			if (inp->inp_socket)
77498271db4SGarrett Wollman 				sotoxsocket(inp->inp_socket, &xi.xi_socket);
7754b40c56cSJeffrey Hsu 			xi.xi_inp.inp_gencnt = inp->inp_gencnt;
7769622e84fSRobert Watson 			INP_RUNLOCK(inp);
77798271db4SGarrett Wollman 			error = SYSCTL_OUT(req, &xi, sizeof xi);
778d915b280SStephan Uphoff 		} else
7799622e84fSRobert Watson 			INP_RUNLOCK(inp);
78098271db4SGarrett Wollman 	}
781d0e157f6SBjoern A. Zeeb 	INP_INFO_WLOCK(&V_udbinfo);
782d0e157f6SBjoern A. Zeeb 	for (i = 0; i < n; i++) {
783d0e157f6SBjoern A. Zeeb 		inp = inp_list[i];
784fa046d87SRobert Watson 		INP_RLOCK(inp);
785fa046d87SRobert Watson 		if (!in_pcbrele_rlocked(inp))
786fa046d87SRobert Watson 			INP_RUNLOCK(inp);
787d0e157f6SBjoern A. Zeeb 	}
788d0e157f6SBjoern A. Zeeb 	INP_INFO_WUNLOCK(&V_udbinfo);
789d0e157f6SBjoern A. Zeeb 
79098271db4SGarrett Wollman 	if (!error) {
79198271db4SGarrett Wollman 		/*
7923329b236SRobert Watson 		 * Give the user an updated idea of our state.  If the
7933329b236SRobert Watson 		 * generation differs from what we told her before, she knows
7943329b236SRobert Watson 		 * that something happened while we were processing this
7953329b236SRobert Watson 		 * request, and it might be necessary to retry.
79698271db4SGarrett Wollman 		 */
797603724d3SBjoern A. Zeeb 		INP_INFO_RLOCK(&V_udbinfo);
798603724d3SBjoern A. Zeeb 		xig.xig_gen = V_udbinfo.ipi_gencnt;
79998271db4SGarrett Wollman 		xig.xig_sogen = so_gencnt;
800603724d3SBjoern A. Zeeb 		xig.xig_count = V_udbinfo.ipi_count;
801603724d3SBjoern A. Zeeb 		INP_INFO_RUNLOCK(&V_udbinfo);
80298271db4SGarrett Wollman 		error = SYSCTL_OUT(req, &xig, sizeof xig);
80398271db4SGarrett Wollman 	}
80498271db4SGarrett Wollman 	free(inp_list, M_TEMP);
8053329b236SRobert Watson 	return (error);
80698271db4SGarrett Wollman }
80798271db4SGarrett Wollman 
80879c3d51bSMatthew D Fleming SYSCTL_PROC(_net_inet_udp, UDPCTL_PCBLIST, pcblist,
80979c3d51bSMatthew D Fleming     CTLTYPE_OPAQUE | CTLFLAG_RD, NULL, 0,
81098271db4SGarrett Wollman     udp_pcblist, "S,xinpcb", "List of active UDP sockets");
81198271db4SGarrett Wollman 
81279288c11SBjoern A. Zeeb #ifdef INET
81398271db4SGarrett Wollman static int
81482d9ae4eSPoul-Henning Kamp udp_getcred(SYSCTL_HANDLER_ARGS)
815490d50b6SBrian Feldman {
816c0511d3bSBrian Feldman 	struct xucred xuc;
817490d50b6SBrian Feldman 	struct sockaddr_in addrs[2];
818490d50b6SBrian Feldman 	struct inpcb *inp;
819277afaffSRobert Watson 	int error;
820490d50b6SBrian Feldman 
82132f9753cSRobert Watson 	error = priv_check(req->td, PRIV_NETINET_GETCRED);
822490d50b6SBrian Feldman 	if (error)
823490d50b6SBrian Feldman 		return (error);
824490d50b6SBrian Feldman 	error = SYSCTL_IN(req, addrs, sizeof(addrs));
825490d50b6SBrian Feldman 	if (error)
826490d50b6SBrian Feldman 		return (error);
827fa046d87SRobert Watson 	inp = in_pcblookup(&V_udbinfo, addrs[1].sin_addr, addrs[1].sin_port,
828fa046d87SRobert Watson 	    addrs[0].sin_addr, addrs[0].sin_port,
829fa046d87SRobert Watson 	    INPLOOKUP_WILDCARD | INPLOOKUP_RLOCKPCB, NULL);
8309622e84fSRobert Watson 	if (inp != NULL) {
831fa046d87SRobert Watson 		INP_RLOCK_ASSERT(inp);
8329622e84fSRobert Watson 		if (inp->inp_socket == NULL)
8339622e84fSRobert Watson 			error = ENOENT;
8349622e84fSRobert Watson 		if (error == 0)
835f08ef6c5SBjoern A. Zeeb 			error = cr_canseeinpcb(req->td->td_ucred, inp);
8369622e84fSRobert Watson 		if (error == 0)
83786d02c5cSBjoern A. Zeeb 			cru2x(inp->inp_cred, &xuc);
8389622e84fSRobert Watson 		INP_RUNLOCK(inp);
839fa046d87SRobert Watson 	} else
8409622e84fSRobert Watson 		error = ENOENT;
8410e1eebb8SDon Lewis 	if (error == 0)
8420e1eebb8SDon Lewis 		error = SYSCTL_OUT(req, &xuc, sizeof(struct xucred));
843490d50b6SBrian Feldman 	return (error);
844490d50b6SBrian Feldman }
845490d50b6SBrian Feldman 
8467ce87f12SDavid Malone SYSCTL_PROC(_net_inet_udp, OID_AUTO, getcred,
8477ce87f12SDavid Malone     CTLTYPE_OPAQUE|CTLFLAG_RW|CTLFLAG_PRISON, 0, 0,
8487ce87f12SDavid Malone     udp_getcred, "S,xucred", "Get the xucred of a UDP connection");
84979288c11SBjoern A. Zeeb #endif /* INET */
850490d50b6SBrian Feldman 
8517b495c44SVANHULLEBUS Yvan int
8527b495c44SVANHULLEBUS Yvan udp_ctloutput(struct socket *so, struct sockopt *sopt)
8537b495c44SVANHULLEBUS Yvan {
8547b495c44SVANHULLEBUS Yvan 	int error = 0, optval;
8557b495c44SVANHULLEBUS Yvan 	struct inpcb *inp;
8567b495c44SVANHULLEBUS Yvan #ifdef IPSEC_NAT_T
8577b495c44SVANHULLEBUS Yvan 	struct udpcb *up;
8587b495c44SVANHULLEBUS Yvan #endif
8597b495c44SVANHULLEBUS Yvan 
8607b495c44SVANHULLEBUS Yvan 	inp = sotoinpcb(so);
8617b495c44SVANHULLEBUS Yvan 	KASSERT(inp != NULL, ("%s: inp == NULL", __func__));
8627b495c44SVANHULLEBUS Yvan 	INP_WLOCK(inp);
8637b495c44SVANHULLEBUS Yvan 	if (sopt->sopt_level != IPPROTO_UDP) {
8647b495c44SVANHULLEBUS Yvan #ifdef INET6
8657b495c44SVANHULLEBUS Yvan 		if (INP_CHECK_SOCKAF(so, AF_INET6)) {
8667b495c44SVANHULLEBUS Yvan 			INP_WUNLOCK(inp);
8677b495c44SVANHULLEBUS Yvan 			error = ip6_ctloutput(so, sopt);
86879288c11SBjoern A. Zeeb 		}
8697b495c44SVANHULLEBUS Yvan #endif
87079288c11SBjoern A. Zeeb #if defined(INET) && defined(INET6)
87179288c11SBjoern A. Zeeb 		else
87279288c11SBjoern A. Zeeb #endif
87379288c11SBjoern A. Zeeb #ifdef INET
87479288c11SBjoern A. Zeeb 		{
8757b495c44SVANHULLEBUS Yvan 			INP_WUNLOCK(inp);
8767b495c44SVANHULLEBUS Yvan 			error = ip_ctloutput(so, sopt);
8777b495c44SVANHULLEBUS Yvan 		}
8787b495c44SVANHULLEBUS Yvan #endif
8797b495c44SVANHULLEBUS Yvan 		return (error);
8807b495c44SVANHULLEBUS Yvan 	}
8817b495c44SVANHULLEBUS Yvan 
8827b495c44SVANHULLEBUS Yvan 	switch (sopt->sopt_dir) {
8837b495c44SVANHULLEBUS Yvan 	case SOPT_SET:
8847b495c44SVANHULLEBUS Yvan 		switch (sopt->sopt_name) {
8857b495c44SVANHULLEBUS Yvan 		case UDP_ENCAP:
8867b495c44SVANHULLEBUS Yvan 			INP_WUNLOCK(inp);
8877b495c44SVANHULLEBUS Yvan 			error = sooptcopyin(sopt, &optval, sizeof optval,
8887b495c44SVANHULLEBUS Yvan 					    sizeof optval);
8897b495c44SVANHULLEBUS Yvan 			if (error)
8907b495c44SVANHULLEBUS Yvan 				break;
8917b495c44SVANHULLEBUS Yvan 			inp = sotoinpcb(so);
8927b495c44SVANHULLEBUS Yvan 			KASSERT(inp != NULL, ("%s: inp == NULL", __func__));
8937b495c44SVANHULLEBUS Yvan 			INP_WLOCK(inp);
8947b495c44SVANHULLEBUS Yvan #ifdef IPSEC_NAT_T
8957b495c44SVANHULLEBUS Yvan 			up = intoudpcb(inp);
8967b495c44SVANHULLEBUS Yvan 			KASSERT(up != NULL, ("%s: up == NULL", __func__));
8977b495c44SVANHULLEBUS Yvan #endif
8987b495c44SVANHULLEBUS Yvan 			switch (optval) {
8997b495c44SVANHULLEBUS Yvan 			case 0:
9007b495c44SVANHULLEBUS Yvan 				/* Clear all UDP encap. */
9017b495c44SVANHULLEBUS Yvan #ifdef IPSEC_NAT_T
9027b495c44SVANHULLEBUS Yvan 				up->u_flags &= ~UF_ESPINUDP_ALL;
9037b495c44SVANHULLEBUS Yvan #endif
9047b495c44SVANHULLEBUS Yvan 				break;
9057b495c44SVANHULLEBUS Yvan #ifdef IPSEC_NAT_T
9067b495c44SVANHULLEBUS Yvan 			case UDP_ENCAP_ESPINUDP:
9077b495c44SVANHULLEBUS Yvan 			case UDP_ENCAP_ESPINUDP_NON_IKE:
9087b495c44SVANHULLEBUS Yvan 				up->u_flags &= ~UF_ESPINUDP_ALL;
9097b495c44SVANHULLEBUS Yvan 				if (optval == UDP_ENCAP_ESPINUDP)
9107b495c44SVANHULLEBUS Yvan 					up->u_flags |= UF_ESPINUDP;
9117b495c44SVANHULLEBUS Yvan 				else if (optval == UDP_ENCAP_ESPINUDP_NON_IKE)
9127b495c44SVANHULLEBUS Yvan 					up->u_flags |= UF_ESPINUDP_NON_IKE;
9137b495c44SVANHULLEBUS Yvan 				break;
9147b495c44SVANHULLEBUS Yvan #endif
9157b495c44SVANHULLEBUS Yvan 			default:
9167b495c44SVANHULLEBUS Yvan 				error = EINVAL;
9177b495c44SVANHULLEBUS Yvan 				break;
9187b495c44SVANHULLEBUS Yvan 			}
9197b495c44SVANHULLEBUS Yvan 			INP_WUNLOCK(inp);
9207b495c44SVANHULLEBUS Yvan 			break;
9217b495c44SVANHULLEBUS Yvan 		default:
9227b495c44SVANHULLEBUS Yvan 			INP_WUNLOCK(inp);
9237b495c44SVANHULLEBUS Yvan 			error = ENOPROTOOPT;
9247b495c44SVANHULLEBUS Yvan 			break;
9257b495c44SVANHULLEBUS Yvan 		}
9267b495c44SVANHULLEBUS Yvan 		break;
9277b495c44SVANHULLEBUS Yvan 	case SOPT_GET:
9287b495c44SVANHULLEBUS Yvan 		switch (sopt->sopt_name) {
9297b495c44SVANHULLEBUS Yvan #ifdef IPSEC_NAT_T
9307b495c44SVANHULLEBUS Yvan 		case UDP_ENCAP:
9317b495c44SVANHULLEBUS Yvan 			up = intoudpcb(inp);
9327b495c44SVANHULLEBUS Yvan 			KASSERT(up != NULL, ("%s: up == NULL", __func__));
9337b495c44SVANHULLEBUS Yvan 			optval = up->u_flags & UF_ESPINUDP_ALL;
9347b495c44SVANHULLEBUS Yvan 			INP_WUNLOCK(inp);
9357b495c44SVANHULLEBUS Yvan 			error = sooptcopyout(sopt, &optval, sizeof optval);
9367b495c44SVANHULLEBUS Yvan 			break;
9377b495c44SVANHULLEBUS Yvan #endif
9387b495c44SVANHULLEBUS Yvan 		default:
9397b495c44SVANHULLEBUS Yvan 			INP_WUNLOCK(inp);
9407b495c44SVANHULLEBUS Yvan 			error = ENOPROTOOPT;
9417b495c44SVANHULLEBUS Yvan 			break;
9427b495c44SVANHULLEBUS Yvan 		}
9437b495c44SVANHULLEBUS Yvan 		break;
9447b495c44SVANHULLEBUS Yvan 	}
9457b495c44SVANHULLEBUS Yvan 	return (error);
9467b495c44SVANHULLEBUS Yvan }
9477b495c44SVANHULLEBUS Yvan 
94879288c11SBjoern A. Zeeb #ifdef INET
949fa046d87SRobert Watson #define	UH_WLOCKED	2
950fa046d87SRobert Watson #define	UH_RLOCKED	1
951fa046d87SRobert Watson #define	UH_UNLOCKED	0
952490d50b6SBrian Feldman static int
9533329b236SRobert Watson udp_output(struct inpcb *inp, struct mbuf *m, struct sockaddr *addr,
9543329b236SRobert Watson     struct mbuf *control, struct thread *td)
955df8bae1dSRodney W. Grimes {
9563329b236SRobert Watson 	struct udpiphdr *ui;
9573329b236SRobert Watson 	int len = m->m_pkthdr.len;
95890162a4eSIan Dowse 	struct in_addr faddr, laddr;
959c557ae16SIan Dowse 	struct cmsghdr *cm;
960c557ae16SIan Dowse 	struct sockaddr_in *sin, src;
96190162a4eSIan Dowse 	int error = 0;
9628afa2304SBruce M Simpson 	int ipflags;
96390162a4eSIan Dowse 	u_short fport, lport;
9645c32ea65SRobert Watson 	int unlock_udbinfo;
965f584d74bSMichael Tuexen 	u_char tos;
966df8bae1dSRodney W. Grimes 
9675c32ea65SRobert Watson 	/*
9685c32ea65SRobert Watson 	 * udp_output() may need to temporarily bind or connect the current
969f5514f08SRobert Watson 	 * inpcb.  As such, we don't know up front whether we will need the
970f5514f08SRobert Watson 	 * pcbinfo lock or not.  Do any work to decide what is needed up
971f5514f08SRobert Watson 	 * front before acquiring any locks.
9725c32ea65SRobert Watson 	 */
973430d30d8SBill Fenner 	if (len + sizeof(struct udpiphdr) > IP_MAXPACKET) {
974c557ae16SIan Dowse 		if (control)
975c557ae16SIan Dowse 			m_freem(control);
9765c32ea65SRobert Watson 		m_freem(m);
9773329b236SRobert Watson 		return (EMSGSIZE);
978430d30d8SBill Fenner 	}
979430d30d8SBill Fenner 
9801b7f0384SBruce M Simpson 	src.sin_family = 0;
9810cfdff24SBjoern A. Zeeb 	INP_RLOCK(inp);
982f584d74bSMichael Tuexen 	tos = inp->inp_ip_tos;
983c557ae16SIan Dowse 	if (control != NULL) {
984c557ae16SIan Dowse 		/*
9853329b236SRobert Watson 		 * XXX: Currently, we assume all the optional information is
9863329b236SRobert Watson 		 * stored in a single mbuf.
987c557ae16SIan Dowse 		 */
988c557ae16SIan Dowse 		if (control->m_next) {
9890cfdff24SBjoern A. Zeeb 			INP_RUNLOCK(inp);
990c557ae16SIan Dowse 			m_freem(control);
9915c32ea65SRobert Watson 			m_freem(m);
9923329b236SRobert Watson 			return (EINVAL);
993c557ae16SIan Dowse 		}
994c557ae16SIan Dowse 		for (; control->m_len > 0;
995c557ae16SIan Dowse 		    control->m_data += CMSG_ALIGN(cm->cmsg_len),
996c557ae16SIan Dowse 		    control->m_len -= CMSG_ALIGN(cm->cmsg_len)) {
997c557ae16SIan Dowse 			cm = mtod(control, struct cmsghdr *);
998af1ee11dSRobert Watson 			if (control->m_len < sizeof(*cm) || cm->cmsg_len == 0
999af1ee11dSRobert Watson 			    || cm->cmsg_len > control->m_len) {
1000c557ae16SIan Dowse 				error = EINVAL;
1001c557ae16SIan Dowse 				break;
1002c557ae16SIan Dowse 			}
1003c557ae16SIan Dowse 			if (cm->cmsg_level != IPPROTO_IP)
1004c557ae16SIan Dowse 				continue;
1005c557ae16SIan Dowse 
1006c557ae16SIan Dowse 			switch (cm->cmsg_type) {
1007c557ae16SIan Dowse 			case IP_SENDSRCADDR:
1008c557ae16SIan Dowse 				if (cm->cmsg_len !=
1009c557ae16SIan Dowse 				    CMSG_LEN(sizeof(struct in_addr))) {
1010c557ae16SIan Dowse 					error = EINVAL;
1011c557ae16SIan Dowse 					break;
1012c557ae16SIan Dowse 				}
1013c557ae16SIan Dowse 				bzero(&src, sizeof(src));
1014c557ae16SIan Dowse 				src.sin_family = AF_INET;
1015c557ae16SIan Dowse 				src.sin_len = sizeof(src);
1016c557ae16SIan Dowse 				src.sin_port = inp->inp_lport;
1017af1ee11dSRobert Watson 				src.sin_addr =
1018af1ee11dSRobert Watson 				    *(struct in_addr *)CMSG_DATA(cm);
1019c557ae16SIan Dowse 				break;
1020af1ee11dSRobert Watson 
1021f584d74bSMichael Tuexen 			case IP_TOS:
1022f584d74bSMichael Tuexen 				if (cm->cmsg_len != CMSG_LEN(sizeof(u_char))) {
1023f584d74bSMichael Tuexen 					error = EINVAL;
1024f584d74bSMichael Tuexen 					break;
1025f584d74bSMichael Tuexen 				}
1026f584d74bSMichael Tuexen 				tos = *(u_char *)CMSG_DATA(cm);
1027f584d74bSMichael Tuexen 				break;
1028f584d74bSMichael Tuexen 
1029c557ae16SIan Dowse 			default:
1030c557ae16SIan Dowse 				error = ENOPROTOOPT;
1031c557ae16SIan Dowse 				break;
1032c557ae16SIan Dowse 			}
1033c557ae16SIan Dowse 			if (error)
1034c557ae16SIan Dowse 				break;
1035c557ae16SIan Dowse 		}
1036c557ae16SIan Dowse 		m_freem(control);
1037c557ae16SIan Dowse 	}
10385c32ea65SRobert Watson 	if (error) {
10390cfdff24SBjoern A. Zeeb 		INP_RUNLOCK(inp);
10405c32ea65SRobert Watson 		m_freem(m);
10413329b236SRobert Watson 		return (error);
10425c32ea65SRobert Watson 	}
10435c32ea65SRobert Watson 
104443cc0bc1SRobert Watson 	/*
104543cc0bc1SRobert Watson 	 * Depending on whether or not the application has bound or connected
1046ca528788SRobert Watson 	 * the socket, we may have to do varying levels of work.  The optimal
1047ca528788SRobert Watson 	 * case is for a connected UDP socket, as a global lock isn't
1048ca528788SRobert Watson 	 * required at all.
104943cc0bc1SRobert Watson 	 *
105043cc0bc1SRobert Watson 	 * In order to decide which we need, we require stability of the
105143cc0bc1SRobert Watson 	 * inpcb binding, which we ensure by acquiring a read lock on the
105243cc0bc1SRobert Watson 	 * inpcb.  This doesn't strictly follow the lock order, so we play
105343cc0bc1SRobert Watson 	 * the trylock and retry game; note that we may end up with more
105443cc0bc1SRobert Watson 	 * conservative locks than required the second time around, so later
105543cc0bc1SRobert Watson 	 * assertions have to accept that.  Further analysis of the number of
105643cc0bc1SRobert Watson 	 * misses under contention is required.
1057fa046d87SRobert Watson 	 *
1058fa046d87SRobert Watson 	 * XXXRW: Check that hash locking update here is correct.
105943cc0bc1SRobert Watson 	 */
106043cc0bc1SRobert Watson 	sin = (struct sockaddr_in *)addr;
106143cc0bc1SRobert Watson 	if (sin != NULL &&
106243cc0bc1SRobert Watson 	    (inp->inp_laddr.s_addr == INADDR_ANY && inp->inp_lport == 0)) {
106343cc0bc1SRobert Watson 		INP_RUNLOCK(inp);
10648501a69cSRobert Watson 		INP_WLOCK(inp);
1065fa046d87SRobert Watson 		INP_HASH_WLOCK(&V_udbinfo);
1066fa046d87SRobert Watson 		unlock_udbinfo = UH_WLOCKED;
106743cc0bc1SRobert Watson 	} else if ((sin != NULL && (
106843cc0bc1SRobert Watson 	    (sin->sin_addr.s_addr == INADDR_ANY) ||
106943cc0bc1SRobert Watson 	    (sin->sin_addr.s_addr == INADDR_BROADCAST) ||
107043cc0bc1SRobert Watson 	    (inp->inp_laddr.s_addr == INADDR_ANY) ||
107143cc0bc1SRobert Watson 	    (inp->inp_lport == 0))) ||
107243cc0bc1SRobert Watson 	    (src.sin_family == AF_INET)) {
1073fa046d87SRobert Watson 		INP_HASH_RLOCK(&V_udbinfo);
1074fa046d87SRobert Watson 		unlock_udbinfo = UH_RLOCKED;
107543cc0bc1SRobert Watson 	} else
1076fa046d87SRobert Watson 		unlock_udbinfo = UH_UNLOCKED;
10775c32ea65SRobert Watson 
10781b7f0384SBruce M Simpson 	/*
10791b7f0384SBruce M Simpson 	 * If the IP_SENDSRCADDR control message was specified, override the
10801b7f0384SBruce M Simpson 	 * source address for this datagram.  Its use is invalidated if the
10811b7f0384SBruce M Simpson 	 * address thus specified is incomplete or clobbers other inpcbs.
10821b7f0384SBruce M Simpson 	 */
108390162a4eSIan Dowse 	laddr = inp->inp_laddr;
108490162a4eSIan Dowse 	lport = inp->inp_lport;
10851b7f0384SBruce M Simpson 	if (src.sin_family == AF_INET) {
1086fa046d87SRobert Watson 		INP_HASH_LOCK_ASSERT(&V_udbinfo);
10871b7f0384SBruce M Simpson 		if ((lport == 0) ||
10881b7f0384SBruce M Simpson 		    (laddr.s_addr == INADDR_ANY &&
10891b7f0384SBruce M Simpson 		     src.sin_addr.s_addr == INADDR_ANY)) {
1090c557ae16SIan Dowse 			error = EINVAL;
1091c557ae16SIan Dowse 			goto release;
1092c557ae16SIan Dowse 		}
1093c557ae16SIan Dowse 		error = in_pcbbind_setup(inp, (struct sockaddr *)&src,
1094b0330ed9SPawel Jakub Dawidek 		    &laddr.s_addr, &lport, td->td_ucred);
1095c557ae16SIan Dowse 		if (error)
1096c557ae16SIan Dowse 			goto release;
1097c557ae16SIan Dowse 	}
1098c557ae16SIan Dowse 
10993144b7d3SRobert Watson 	/*
11003144b7d3SRobert Watson 	 * If a UDP socket has been connected, then a local address/port will
11013144b7d3SRobert Watson 	 * have been selected and bound.
11023144b7d3SRobert Watson 	 *
110343cc0bc1SRobert Watson 	 * If a UDP socket has not been connected to, then an explicit
11043144b7d3SRobert Watson 	 * destination address must be used, in which case a local
11053144b7d3SRobert Watson 	 * address/port may not have been selected and bound.
11063144b7d3SRobert Watson 	 */
110743cc0bc1SRobert Watson 	if (sin != NULL) {
1108c4d585aeSRobert Watson 		INP_LOCK_ASSERT(inp);
1109df8bae1dSRodney W. Grimes 		if (inp->inp_faddr.s_addr != INADDR_ANY) {
1110df8bae1dSRodney W. Grimes 			error = EISCONN;
1111df8bae1dSRodney W. Grimes 			goto release;
1112df8bae1dSRodney W. Grimes 		}
11133144b7d3SRobert Watson 
11143144b7d3SRobert Watson 		/*
11153144b7d3SRobert Watson 		 * Jail may rewrite the destination address, so let it do
11163144b7d3SRobert Watson 		 * that before we use it.
11173144b7d3SRobert Watson 		 */
1118b89e82ddSJamie Gritton 		error = prison_remote_ip4(td->td_ucred, &sin->sin_addr);
1119b89e82ddSJamie Gritton 		if (error)
1120413628a7SBjoern A. Zeeb 			goto release;
11213144b7d3SRobert Watson 
11223144b7d3SRobert Watson 		/*
112343cc0bc1SRobert Watson 		 * If a local address or port hasn't yet been selected, or if
112443cc0bc1SRobert Watson 		 * the destination address needs to be rewritten due to using
112543cc0bc1SRobert Watson 		 * a special INADDR_ constant, invoke in_pcbconnect_setup()
112643cc0bc1SRobert Watson 		 * to do the heavy lifting.  Once a port is selected, we
112743cc0bc1SRobert Watson 		 * commit the binding back to the socket; we also commit the
112843cc0bc1SRobert Watson 		 * binding of the address if in jail.
112943cc0bc1SRobert Watson 		 *
113043cc0bc1SRobert Watson 		 * If we already have a valid binding and we're not
113143cc0bc1SRobert Watson 		 * requesting a destination address rewrite, use a fast path.
11323144b7d3SRobert Watson 		 */
113343cc0bc1SRobert Watson 		if (inp->inp_laddr.s_addr == INADDR_ANY ||
113443cc0bc1SRobert Watson 		    inp->inp_lport == 0 ||
113543cc0bc1SRobert Watson 		    sin->sin_addr.s_addr == INADDR_ANY ||
113643cc0bc1SRobert Watson 		    sin->sin_addr.s_addr == INADDR_BROADCAST) {
1137fa046d87SRobert Watson 			INP_HASH_LOCK_ASSERT(&V_udbinfo);
113843cc0bc1SRobert Watson 			error = in_pcbconnect_setup(inp, addr, &laddr.s_addr,
113943cc0bc1SRobert Watson 			    &lport, &faddr.s_addr, &fport, NULL,
114043cc0bc1SRobert Watson 			    td->td_ucred);
114190162a4eSIan Dowse 			if (error)
114290162a4eSIan Dowse 				goto release;
114390162a4eSIan Dowse 
114443cc0bc1SRobert Watson 			/*
114543cc0bc1SRobert Watson 			 * XXXRW: Why not commit the port if the address is
114643cc0bc1SRobert Watson 			 * !INADDR_ANY?
114743cc0bc1SRobert Watson 			 */
114890162a4eSIan Dowse 			/* Commit the local port if newly assigned. */
114990162a4eSIan Dowse 			if (inp->inp_laddr.s_addr == INADDR_ANY &&
115090162a4eSIan Dowse 			    inp->inp_lport == 0) {
1151c4d585aeSRobert Watson 				INP_WLOCK_ASSERT(inp);
1152fa046d87SRobert Watson 				INP_HASH_WLOCK_ASSERT(&V_udbinfo);
11533a1757b9SGleb Smirnoff 				/*
115443cc0bc1SRobert Watson 				 * Remember addr if jailed, to prevent
115543cc0bc1SRobert Watson 				 * rebinding.
11563a1757b9SGleb Smirnoff 				 */
11570304c731SJamie Gritton 				if (prison_flag(td->td_ucred, PR_IP4))
11583a1757b9SGleb Smirnoff 					inp->inp_laddr = laddr;
115990162a4eSIan Dowse 				inp->inp_lport = lport;
116090162a4eSIan Dowse 				if (in_pcbinshash(inp) != 0) {
116190162a4eSIan Dowse 					inp->inp_lport = 0;
116290162a4eSIan Dowse 					error = EAGAIN;
1163df8bae1dSRodney W. Grimes 					goto release;
1164df8bae1dSRodney W. Grimes 				}
116590162a4eSIan Dowse 				inp->inp_flags |= INP_ANONPORT;
116690162a4eSIan Dowse 			}
1167df8bae1dSRodney W. Grimes 		} else {
116843cc0bc1SRobert Watson 			faddr = sin->sin_addr;
116943cc0bc1SRobert Watson 			fport = sin->sin_port;
117043cc0bc1SRobert Watson 		}
117143cc0bc1SRobert Watson 	} else {
1172c4d585aeSRobert Watson 		INP_LOCK_ASSERT(inp);
117390162a4eSIan Dowse 		faddr = inp->inp_faddr;
117490162a4eSIan Dowse 		fport = inp->inp_fport;
117590162a4eSIan Dowse 		if (faddr.s_addr == INADDR_ANY) {
1176df8bae1dSRodney W. Grimes 			error = ENOTCONN;
1177df8bae1dSRodney W. Grimes 			goto release;
1178df8bae1dSRodney W. Grimes 		}
1179df8bae1dSRodney W. Grimes 	}
1180e6ccd709SRobert Watson 
1181df8bae1dSRodney W. Grimes 	/*
1182e6ccd709SRobert Watson 	 * Calculate data length and get a mbuf for UDP, IP, and possible
1183392e8407SRobert Watson 	 * link-layer headers.  Immediate slide the data pointer back forward
1184392e8407SRobert Watson 	 * since we won't use that space at this layer.
1185df8bae1dSRodney W. Grimes 	 */
1186eb1b1807SGleb Smirnoff 	M_PREPEND(m, sizeof(struct udpiphdr) + max_linkhdr, M_NOWAIT);
1187e6ccd709SRobert Watson 	if (m == NULL) {
1188df8bae1dSRodney W. Grimes 		error = ENOBUFS;
118949b19bfcSBruce M Simpson 		goto release;
1190df8bae1dSRodney W. Grimes 	}
1191e6ccd709SRobert Watson 	m->m_data += max_linkhdr;
1192e6ccd709SRobert Watson 	m->m_len -= max_linkhdr;
1193392e8407SRobert Watson 	m->m_pkthdr.len -= max_linkhdr;
1194df8bae1dSRodney W. Grimes 
1195df8bae1dSRodney W. Grimes 	/*
11963329b236SRobert Watson 	 * Fill in mbuf with extended UDP header and addresses and length put
11973329b236SRobert Watson 	 * into network format.
1198df8bae1dSRodney W. Grimes 	 */
1199df8bae1dSRodney W. Grimes 	ui = mtod(m, struct udpiphdr *);
1200db4f9cc7SJonathan Lemon 	bzero(ui->ui_x1, sizeof(ui->ui_x1));	/* XXX still needed? */
120157f60867SMark Johnston 	ui->ui_v = IPVERSION << 4;
1202df8bae1dSRodney W. Grimes 	ui->ui_pr = IPPROTO_UDP;
120390162a4eSIan Dowse 	ui->ui_src = laddr;
120490162a4eSIan Dowse 	ui->ui_dst = faddr;
120590162a4eSIan Dowse 	ui->ui_sport = lport;
120690162a4eSIan Dowse 	ui->ui_dport = fport;
1207db4f9cc7SJonathan Lemon 	ui->ui_ulen = htons((u_short)len + sizeof(struct udphdr));
1208df8bae1dSRodney W. Grimes 
1209b2828ad2SAndre Oppermann 	/*
1210b2828ad2SAndre Oppermann 	 * Set the Don't Fragment bit in the IP header.
1211b2828ad2SAndre Oppermann 	 */
1212b2828ad2SAndre Oppermann 	if (inp->inp_flags & INP_DONTFRAG) {
1213b2828ad2SAndre Oppermann 		struct ip *ip;
12143329b236SRobert Watson 
1215b2828ad2SAndre Oppermann 		ip = (struct ip *)&ui->ui_i;
12168f134647SGleb Smirnoff 		ip->ip_off |= htons(IP_DF);
1217b2828ad2SAndre Oppermann 	}
1218b2828ad2SAndre Oppermann 
1219b5d47ff5SJohn-Mark Gurney 	ipflags = 0;
1220b5d47ff5SJohn-Mark Gurney 	if (inp->inp_socket->so_options & SO_DONTROUTE)
1221b5d47ff5SJohn-Mark Gurney 		ipflags |= IP_ROUTETOIF;
1222b5d47ff5SJohn-Mark Gurney 	if (inp->inp_socket->so_options & SO_BROADCAST)
1223b5d47ff5SJohn-Mark Gurney 		ipflags |= IP_ALLOWBROADCAST;
12246fbfd582SAndre Oppermann 	if (inp->inp_flags & INP_ONESBCAST)
12258afa2304SBruce M Simpson 		ipflags |= IP_SENDONES;
12268afa2304SBruce M Simpson 
12271175d9d5SRobert Watson #ifdef MAC
12281175d9d5SRobert Watson 	mac_inpcb_create_mbuf(inp, m);
12291175d9d5SRobert Watson #endif
12301175d9d5SRobert Watson 
1231df8bae1dSRodney W. Grimes 	/*
1232db4f9cc7SJonathan Lemon 	 * Set up checksum and output datagram.
1233df8bae1dSRodney W. Grimes 	 */
123440b676beSBjoern A. Zeeb 	if (V_udp_cksum) {
12356fbfd582SAndre Oppermann 		if (inp->inp_flags & INP_ONESBCAST)
12368a538743SBruce M Simpson 			faddr.s_addr = INADDR_BROADCAST;
12378a538743SBruce M Simpson 		ui->ui_sum = in_pseudo(ui->ui_src.s_addr, faddr.s_addr,
1238db4f9cc7SJonathan Lemon 		    htons((u_short)len + sizeof(struct udphdr) + IPPROTO_UDP));
1239db4f9cc7SJonathan Lemon 		m->m_pkthdr.csum_flags = CSUM_UDP;
1240db4f9cc7SJonathan Lemon 		m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
12413329b236SRobert Watson 	} else
1242db4f9cc7SJonathan Lemon 		ui->ui_sum = 0;
12438f134647SGleb Smirnoff 	((struct ip *)ui)->ip_len = htons(sizeof(struct udpiphdr) + len);
1244ca98b82cSDavid Greenman 	((struct ip *)ui)->ip_ttl = inp->inp_ip_ttl;	/* XXX */
1245f584d74bSMichael Tuexen 	((struct ip *)ui)->ip_tos = tos;		/* XXX */
1246026decb8SRobert Watson 	UDPSTAT_INC(udps_opackets);
1247cfa1ca9dSYoshinobu Inoue 
1248fa046d87SRobert Watson 	if (unlock_udbinfo == UH_WLOCKED)
1249fa046d87SRobert Watson 		INP_HASH_WUNLOCK(&V_udbinfo);
1250fa046d87SRobert Watson 	else if (unlock_udbinfo == UH_RLOCKED)
1251fa046d87SRobert Watson 		INP_HASH_RUNLOCK(&V_udbinfo);
125257f60867SMark Johnston 	UDP_PROBE(send, NULL, inp, &ui->ui_i, inp, &ui->ui_u);
125397d8d152SAndre Oppermann 	error = ip_output(m, inp->inp_options, NULL, ipflags,
12545d846453SSam Leffler 	    inp->inp_moptions, inp);
1255fa046d87SRobert Watson 	if (unlock_udbinfo == UH_WLOCKED)
12568501a69cSRobert Watson 		INP_WUNLOCK(inp);
1257948d0fc9SRobert Watson 	else
1258948d0fc9SRobert Watson 		INP_RUNLOCK(inp);
1259df8bae1dSRodney W. Grimes 	return (error);
1260df8bae1dSRodney W. Grimes 
1261df8bae1dSRodney W. Grimes release:
1262fa046d87SRobert Watson 	if (unlock_udbinfo == UH_WLOCKED) {
1263fa046d87SRobert Watson 		INP_HASH_WUNLOCK(&V_udbinfo);
1264948d0fc9SRobert Watson 		INP_WUNLOCK(inp);
1265fa046d87SRobert Watson 	} else if (unlock_udbinfo == UH_RLOCKED) {
1266fa046d87SRobert Watson 		INP_HASH_RUNLOCK(&V_udbinfo);
126743cc0bc1SRobert Watson 		INP_RUNLOCK(inp);
1268948d0fc9SRobert Watson 	} else
1269948d0fc9SRobert Watson 		INP_RUNLOCK(inp);
1270df8bae1dSRodney W. Grimes 	m_freem(m);
1271df8bae1dSRodney W. Grimes 	return (error);
1272df8bae1dSRodney W. Grimes }
1273df8bae1dSRodney W. Grimes 
12747b495c44SVANHULLEBUS Yvan 
12757b495c44SVANHULLEBUS Yvan #if defined(IPSEC) && defined(IPSEC_NAT_T)
12767b495c44SVANHULLEBUS Yvan /*
12777b495c44SVANHULLEBUS Yvan  * Potentially decap ESP in UDP frame.  Check for an ESP header
12787b495c44SVANHULLEBUS Yvan  * and optional marker; if present, strip the UDP header and
12797b495c44SVANHULLEBUS Yvan  * push the result through IPSec.
12807b495c44SVANHULLEBUS Yvan  *
12817b495c44SVANHULLEBUS Yvan  * Returns mbuf to be processed (potentially re-allocated) or
12827b495c44SVANHULLEBUS Yvan  * NULL if consumed and/or processed.
12837b495c44SVANHULLEBUS Yvan  */
12847b495c44SVANHULLEBUS Yvan static struct mbuf *
12857b495c44SVANHULLEBUS Yvan udp4_espdecap(struct inpcb *inp, struct mbuf *m, int off)
12867b495c44SVANHULLEBUS Yvan {
12877b495c44SVANHULLEBUS Yvan 	size_t minlen, payload, skip, iphlen;
12887b495c44SVANHULLEBUS Yvan 	caddr_t data;
12897b495c44SVANHULLEBUS Yvan 	struct udpcb *up;
12907b495c44SVANHULLEBUS Yvan 	struct m_tag *tag;
12917b495c44SVANHULLEBUS Yvan 	struct udphdr *udphdr;
12927b495c44SVANHULLEBUS Yvan 	struct ip *ip;
12937b495c44SVANHULLEBUS Yvan 
12947b495c44SVANHULLEBUS Yvan 	INP_RLOCK_ASSERT(inp);
12957b495c44SVANHULLEBUS Yvan 
12967b495c44SVANHULLEBUS Yvan 	/*
12977b495c44SVANHULLEBUS Yvan 	 * Pull up data so the longest case is contiguous:
12987b495c44SVANHULLEBUS Yvan 	 *    IP/UDP hdr + non ESP marker + ESP hdr.
12997b495c44SVANHULLEBUS Yvan 	 */
13007b495c44SVANHULLEBUS Yvan 	minlen = off + sizeof(uint64_t) + sizeof(struct esp);
13017b495c44SVANHULLEBUS Yvan 	if (minlen > m->m_pkthdr.len)
13027b495c44SVANHULLEBUS Yvan 		minlen = m->m_pkthdr.len;
13037b495c44SVANHULLEBUS Yvan 	if ((m = m_pullup(m, minlen)) == NULL) {
13046794f460SAndrey V. Elsukov 		IPSECSTAT_INC(ips_in_inval);
13057b495c44SVANHULLEBUS Yvan 		return (NULL);		/* Bypass caller processing. */
13067b495c44SVANHULLEBUS Yvan 	}
13077b495c44SVANHULLEBUS Yvan 	data = mtod(m, caddr_t);	/* Points to ip header. */
13087b495c44SVANHULLEBUS Yvan 	payload = m->m_len - off;	/* Size of payload. */
13097b495c44SVANHULLEBUS Yvan 
13107b495c44SVANHULLEBUS Yvan 	if (payload == 1 && data[off] == '\xff')
13117b495c44SVANHULLEBUS Yvan 		return (m);		/* NB: keepalive packet, no decap. */
13127b495c44SVANHULLEBUS Yvan 
13137b495c44SVANHULLEBUS Yvan 	up = intoudpcb(inp);
13147b495c44SVANHULLEBUS Yvan 	KASSERT(up != NULL, ("%s: udpcb NULL", __func__));
13157b495c44SVANHULLEBUS Yvan 	KASSERT((up->u_flags & UF_ESPINUDP_ALL) != 0,
13167b495c44SVANHULLEBUS Yvan 	    ("u_flags 0x%x", up->u_flags));
13177b495c44SVANHULLEBUS Yvan 
13187b495c44SVANHULLEBUS Yvan 	/*
13197b495c44SVANHULLEBUS Yvan 	 * Check that the payload is large enough to hold an
13207b495c44SVANHULLEBUS Yvan 	 * ESP header and compute the amount of data to remove.
13217b495c44SVANHULLEBUS Yvan 	 *
13227b495c44SVANHULLEBUS Yvan 	 * NB: the caller has already done a pullup for us.
13237b495c44SVANHULLEBUS Yvan 	 * XXX can we assume alignment and eliminate bcopys?
13247b495c44SVANHULLEBUS Yvan 	 */
13257b495c44SVANHULLEBUS Yvan 	if (up->u_flags & UF_ESPINUDP_NON_IKE) {
13267b495c44SVANHULLEBUS Yvan 		/*
13277b495c44SVANHULLEBUS Yvan 		 * draft-ietf-ipsec-nat-t-ike-0[01].txt and
13287b495c44SVANHULLEBUS Yvan 		 * draft-ietf-ipsec-udp-encaps-(00/)01.txt, ignoring
13297b495c44SVANHULLEBUS Yvan 		 * possible AH mode non-IKE marker+non-ESP marker
13307b495c44SVANHULLEBUS Yvan 		 * from draft-ietf-ipsec-udp-encaps-00.txt.
13317b495c44SVANHULLEBUS Yvan 		 */
13327b495c44SVANHULLEBUS Yvan 		uint64_t marker;
13337b495c44SVANHULLEBUS Yvan 
13347b495c44SVANHULLEBUS Yvan 		if (payload <= sizeof(uint64_t) + sizeof(struct esp))
13357b495c44SVANHULLEBUS Yvan 			return (m);	/* NB: no decap. */
13367b495c44SVANHULLEBUS Yvan 		bcopy(data + off, &marker, sizeof(uint64_t));
13377b495c44SVANHULLEBUS Yvan 		if (marker != 0)	/* Non-IKE marker. */
13387b495c44SVANHULLEBUS Yvan 			return (m);	/* NB: no decap. */
13397b495c44SVANHULLEBUS Yvan 		skip = sizeof(uint64_t) + sizeof(struct udphdr);
13407b495c44SVANHULLEBUS Yvan 	} else {
13417b495c44SVANHULLEBUS Yvan 		uint32_t spi;
13427b495c44SVANHULLEBUS Yvan 
13437b495c44SVANHULLEBUS Yvan 		if (payload <= sizeof(struct esp)) {
13446794f460SAndrey V. Elsukov 			IPSECSTAT_INC(ips_in_inval);
13457b495c44SVANHULLEBUS Yvan 			m_freem(m);
13467b495c44SVANHULLEBUS Yvan 			return (NULL);	/* Discard. */
13477b495c44SVANHULLEBUS Yvan 		}
13487b495c44SVANHULLEBUS Yvan 		bcopy(data + off, &spi, sizeof(uint32_t));
13497b495c44SVANHULLEBUS Yvan 		if (spi == 0)		/* Non-ESP marker. */
13507b495c44SVANHULLEBUS Yvan 			return (m);	/* NB: no decap. */
13517b495c44SVANHULLEBUS Yvan 		skip = sizeof(struct udphdr);
13527b495c44SVANHULLEBUS Yvan 	}
13537b495c44SVANHULLEBUS Yvan 
13547b495c44SVANHULLEBUS Yvan 	/*
13557b495c44SVANHULLEBUS Yvan 	 * Setup a PACKET_TAG_IPSEC_NAT_T_PORT tag to remember
13567b495c44SVANHULLEBUS Yvan 	 * the UDP ports. This is required if we want to select
13577b495c44SVANHULLEBUS Yvan 	 * the right SPD for multiple hosts behind same NAT.
13587b495c44SVANHULLEBUS Yvan 	 *
13597b495c44SVANHULLEBUS Yvan 	 * NB: ports are maintained in network byte order everywhere
13607b495c44SVANHULLEBUS Yvan 	 *     in the NAT-T code.
13617b495c44SVANHULLEBUS Yvan 	 */
13627b495c44SVANHULLEBUS Yvan 	tag = m_tag_get(PACKET_TAG_IPSEC_NAT_T_PORTS,
13637b495c44SVANHULLEBUS Yvan 		2 * sizeof(uint16_t), M_NOWAIT);
13647b495c44SVANHULLEBUS Yvan 	if (tag == NULL) {
13656794f460SAndrey V. Elsukov 		IPSECSTAT_INC(ips_in_nomem);
13667b495c44SVANHULLEBUS Yvan 		m_freem(m);
13677b495c44SVANHULLEBUS Yvan 		return (NULL);		/* Discard. */
13687b495c44SVANHULLEBUS Yvan 	}
13697b495c44SVANHULLEBUS Yvan 	iphlen = off - sizeof(struct udphdr);
13707b495c44SVANHULLEBUS Yvan 	udphdr = (struct udphdr *)(data + iphlen);
13717b495c44SVANHULLEBUS Yvan 	((uint16_t *)(tag + 1))[0] = udphdr->uh_sport;
13727b495c44SVANHULLEBUS Yvan 	((uint16_t *)(tag + 1))[1] = udphdr->uh_dport;
13737b495c44SVANHULLEBUS Yvan 	m_tag_prepend(m, tag);
13747b495c44SVANHULLEBUS Yvan 
13757b495c44SVANHULLEBUS Yvan 	/*
13767b495c44SVANHULLEBUS Yvan 	 * Remove the UDP header (and possibly the non ESP marker)
13777b495c44SVANHULLEBUS Yvan 	 * IP header length is iphlen
13787b495c44SVANHULLEBUS Yvan 	 * Before:
13797b495c44SVANHULLEBUS Yvan 	 *   <--- off --->
13807b495c44SVANHULLEBUS Yvan 	 *   +----+------+-----+
13817b495c44SVANHULLEBUS Yvan 	 *   | IP |  UDP | ESP |
13827b495c44SVANHULLEBUS Yvan 	 *   +----+------+-----+
13837b495c44SVANHULLEBUS Yvan 	 *        <-skip->
13847b495c44SVANHULLEBUS Yvan 	 * After:
13857b495c44SVANHULLEBUS Yvan 	 *          +----+-----+
13867b495c44SVANHULLEBUS Yvan 	 *          | IP | ESP |
13877b495c44SVANHULLEBUS Yvan 	 *          +----+-----+
13887b495c44SVANHULLEBUS Yvan 	 *   <-skip->
13897b495c44SVANHULLEBUS Yvan 	 */
13907b495c44SVANHULLEBUS Yvan 	ovbcopy(data, data + skip, iphlen);
13917b495c44SVANHULLEBUS Yvan 	m_adj(m, skip);
13927b495c44SVANHULLEBUS Yvan 
13937b495c44SVANHULLEBUS Yvan 	ip = mtod(m, struct ip *);
13948f134647SGleb Smirnoff 	ip->ip_len = htons(ntohs(ip->ip_len) - skip);
13957b495c44SVANHULLEBUS Yvan 	ip->ip_p = IPPROTO_ESP;
13967b495c44SVANHULLEBUS Yvan 
13977b495c44SVANHULLEBUS Yvan 	/*
13987b495c44SVANHULLEBUS Yvan 	 * We cannot yet update the cksums so clear any
13997b495c44SVANHULLEBUS Yvan 	 * h/w cksum flags as they are no longer valid.
14007b495c44SVANHULLEBUS Yvan 	 */
14017b495c44SVANHULLEBUS Yvan 	if (m->m_pkthdr.csum_flags & CSUM_DATA_VALID)
14027b495c44SVANHULLEBUS Yvan 		m->m_pkthdr.csum_flags &= ~(CSUM_DATA_VALID|CSUM_PSEUDO_HDR);
14037b495c44SVANHULLEBUS Yvan 
14047b495c44SVANHULLEBUS Yvan 	(void) ipsec4_common_input(m, iphlen, ip->ip_p);
14057b495c44SVANHULLEBUS Yvan 	return (NULL);			/* NB: consumed, bypass processing. */
14067b495c44SVANHULLEBUS Yvan }
14077b495c44SVANHULLEBUS Yvan #endif /* defined(IPSEC) && defined(IPSEC_NAT_T) */
14087b495c44SVANHULLEBUS Yvan 
1409ac45e92fSRobert Watson static void
1410d0390e05SGarrett Wollman udp_abort(struct socket *so)
1411df8bae1dSRodney W. Grimes {
1412d0390e05SGarrett Wollman 	struct inpcb *inp;
1413df8bae1dSRodney W. Grimes 
1414d0390e05SGarrett Wollman 	inp = sotoinpcb(so);
141514ba8addSRobert Watson 	KASSERT(inp != NULL, ("udp_abort: inp == NULL"));
14168501a69cSRobert Watson 	INP_WLOCK(inp);
1417a152f8a3SRobert Watson 	if (inp->inp_faddr.s_addr != INADDR_ANY) {
1418fa046d87SRobert Watson 		INP_HASH_WLOCK(&V_udbinfo);
1419a152f8a3SRobert Watson 		in_pcbdisconnect(inp);
1420a152f8a3SRobert Watson 		inp->inp_laddr.s_addr = INADDR_ANY;
1421fa046d87SRobert Watson 		INP_HASH_WUNLOCK(&V_udbinfo);
1422d0390e05SGarrett Wollman 		soisdisconnected(so);
1423a152f8a3SRobert Watson 	}
14248501a69cSRobert Watson 	INP_WUNLOCK(inp);
1425df8bae1dSRodney W. Grimes }
1426df8bae1dSRodney W. Grimes 
1427d0390e05SGarrett Wollman static int
1428b40ce416SJulian Elischer udp_attach(struct socket *so, int proto, struct thread *td)
1429d0390e05SGarrett Wollman {
1430d0390e05SGarrett Wollman 	struct inpcb *inp;
1431277afaffSRobert Watson 	int error;
1432d0390e05SGarrett Wollman 
1433d0390e05SGarrett Wollman 	inp = sotoinpcb(so);
143414ba8addSRobert Watson 	KASSERT(inp == NULL, ("udp_attach: inp != NULL"));
1435cfa1ca9dSYoshinobu Inoue 	error = soreserve(so, udp_sendspace, udp_recvspace);
1436f24618aaSRobert Watson 	if (error)
14373329b236SRobert Watson 		return (error);
1438603724d3SBjoern A. Zeeb 	INP_INFO_WLOCK(&V_udbinfo);
1439603724d3SBjoern A. Zeeb 	error = in_pcballoc(so, &V_udbinfo);
144053b57cd1SSam Leffler 	if (error) {
1441603724d3SBjoern A. Zeeb 		INP_INFO_WUNLOCK(&V_udbinfo);
14423329b236SRobert Watson 		return (error);
144353b57cd1SSam Leffler 	}
1444cfa1ca9dSYoshinobu Inoue 
144568b5629bSRobert Watson 	inp = sotoinpcb(so);
1446cfa1ca9dSYoshinobu Inoue 	inp->inp_vflag |= INP_IPV4;
1447603724d3SBjoern A. Zeeb 	inp->inp_ip_ttl = V_ip_defttl;
14486a9148feSBjoern A. Zeeb 
14496a9148feSBjoern A. Zeeb 	error = udp_newudpcb(inp);
14506a9148feSBjoern A. Zeeb 	if (error) {
14516a9148feSBjoern A. Zeeb 		in_pcbdetach(inp);
14526a9148feSBjoern A. Zeeb 		in_pcbfree(inp);
14536a9148feSBjoern A. Zeeb 		INP_INFO_WUNLOCK(&V_udbinfo);
14546a9148feSBjoern A. Zeeb 		return (error);
14556a9148feSBjoern A. Zeeb 	}
14566a9148feSBjoern A. Zeeb 
1457c7c7ea4bSRandall Stewart 	INP_WUNLOCK(inp);
14586a9148feSBjoern A. Zeeb 	INP_INFO_WUNLOCK(&V_udbinfo);
1459c7c7ea4bSRandall Stewart 	return (0);
1460c7c7ea4bSRandall Stewart }
146179288c11SBjoern A. Zeeb #endif /* INET */
1462c7c7ea4bSRandall Stewart 
1463c7c7ea4bSRandall Stewart int
1464c7c7ea4bSRandall Stewart udp_set_kernel_tunneling(struct socket *so, udp_tun_func_t f)
1465c7c7ea4bSRandall Stewart {
1466c7c7ea4bSRandall Stewart 	struct inpcb *inp;
14676a9148feSBjoern A. Zeeb 	struct udpcb *up;
1468c7c7ea4bSRandall Stewart 
146968b5629bSRobert Watson 	KASSERT(so->so_type == SOCK_DGRAM,
147068b5629bSRobert Watson 	    ("udp_set_kernel_tunneling: !dgram"));
147168b5629bSRobert Watson 	inp = sotoinpcb(so);
147268b5629bSRobert Watson 	KASSERT(inp != NULL, ("udp_set_kernel_tunneling: inp == NULL"));
1473c7c7ea4bSRandall Stewart 	INP_WLOCK(inp);
14746a9148feSBjoern A. Zeeb 	up = intoudpcb(inp);
14756a9148feSBjoern A. Zeeb 	if (up->u_tun_func != NULL) {
1476bbb0e3d9SRandall Stewart 		INP_WUNLOCK(inp);
1477bbb0e3d9SRandall Stewart 		return (EBUSY);
1478bbb0e3d9SRandall Stewart 	}
14796a9148feSBjoern A. Zeeb 	up->u_tun_func = f;
14808501a69cSRobert Watson 	INP_WUNLOCK(inp);
14813329b236SRobert Watson 	return (0);
1482df8bae1dSRodney W. Grimes }
1483d0390e05SGarrett Wollman 
148479288c11SBjoern A. Zeeb #ifdef INET
1485d0390e05SGarrett Wollman static int
1486b40ce416SJulian Elischer udp_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
1487d0390e05SGarrett Wollman {
1488d0390e05SGarrett Wollman 	struct inpcb *inp;
1489277afaffSRobert Watson 	int error;
1490d0390e05SGarrett Wollman 
1491d0390e05SGarrett Wollman 	inp = sotoinpcb(so);
149214ba8addSRobert Watson 	KASSERT(inp != NULL, ("udp_bind: inp == NULL"));
14938501a69cSRobert Watson 	INP_WLOCK(inp);
1494fa046d87SRobert Watson 	INP_HASH_WLOCK(&V_udbinfo);
1495b0330ed9SPawel Jakub Dawidek 	error = in_pcbbind(inp, nam, td->td_ucred);
1496fa046d87SRobert Watson 	INP_HASH_WUNLOCK(&V_udbinfo);
14978501a69cSRobert Watson 	INP_WUNLOCK(inp);
14983329b236SRobert Watson 	return (error);
1499d0390e05SGarrett Wollman }
1500d0390e05SGarrett Wollman 
1501a152f8a3SRobert Watson static void
1502a152f8a3SRobert Watson udp_close(struct socket *so)
1503a152f8a3SRobert Watson {
1504a152f8a3SRobert Watson 	struct inpcb *inp;
1505a152f8a3SRobert Watson 
1506a152f8a3SRobert Watson 	inp = sotoinpcb(so);
1507a152f8a3SRobert Watson 	KASSERT(inp != NULL, ("udp_close: inp == NULL"));
15088501a69cSRobert Watson 	INP_WLOCK(inp);
1509a152f8a3SRobert Watson 	if (inp->inp_faddr.s_addr != INADDR_ANY) {
1510fa046d87SRobert Watson 		INP_HASH_WLOCK(&V_udbinfo);
1511a152f8a3SRobert Watson 		in_pcbdisconnect(inp);
1512a152f8a3SRobert Watson 		inp->inp_laddr.s_addr = INADDR_ANY;
1513fa046d87SRobert Watson 		INP_HASH_WUNLOCK(&V_udbinfo);
1514a152f8a3SRobert Watson 		soisdisconnected(so);
1515a152f8a3SRobert Watson 	}
15168501a69cSRobert Watson 	INP_WUNLOCK(inp);
1517a152f8a3SRobert Watson }
1518a152f8a3SRobert Watson 
1519d0390e05SGarrett Wollman static int
1520b40ce416SJulian Elischer udp_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
1521d0390e05SGarrett Wollman {
1522d0390e05SGarrett Wollman 	struct inpcb *inp;
1523277afaffSRobert Watson 	int error;
152475c13541SPoul-Henning Kamp 	struct sockaddr_in *sin;
1525d0390e05SGarrett Wollman 
1526d0390e05SGarrett Wollman 	inp = sotoinpcb(so);
152714ba8addSRobert Watson 	KASSERT(inp != NULL, ("udp_connect: inp == NULL"));
15288501a69cSRobert Watson 	INP_WLOCK(inp);
1529f76fcf6dSJeffrey Hsu 	if (inp->inp_faddr.s_addr != INADDR_ANY) {
15308501a69cSRobert Watson 		INP_WUNLOCK(inp);
15313329b236SRobert Watson 		return (EISCONN);
1532f76fcf6dSJeffrey Hsu 	}
153375c13541SPoul-Henning Kamp 	sin = (struct sockaddr_in *)nam;
1534b89e82ddSJamie Gritton 	error = prison_remote_ip4(td->td_ucred, &sin->sin_addr);
1535b89e82ddSJamie Gritton 	if (error != 0) {
1536413628a7SBjoern A. Zeeb 		INP_WUNLOCK(inp);
1537b89e82ddSJamie Gritton 		return (error);
1538413628a7SBjoern A. Zeeb 	}
1539fa046d87SRobert Watson 	INP_HASH_WLOCK(&V_udbinfo);
1540b0330ed9SPawel Jakub Dawidek 	error = in_pcbconnect(inp, nam, td->td_ucred);
1541fa046d87SRobert Watson 	INP_HASH_WUNLOCK(&V_udbinfo);
15424cc20ab1SSeigo Tanimura 	if (error == 0)
1543df8bae1dSRodney W. Grimes 		soisconnected(so);
15448501a69cSRobert Watson 	INP_WUNLOCK(inp);
15453329b236SRobert Watson 	return (error);
1546df8bae1dSRodney W. Grimes }
1547d0390e05SGarrett Wollman 
1548bc725eafSRobert Watson static void
1549d0390e05SGarrett Wollman udp_detach(struct socket *so)
1550d0390e05SGarrett Wollman {
1551d0390e05SGarrett Wollman 	struct inpcb *inp;
15526a9148feSBjoern A. Zeeb 	struct udpcb *up;
1553d0390e05SGarrett Wollman 
1554d0390e05SGarrett Wollman 	inp = sotoinpcb(so);
155514ba8addSRobert Watson 	KASSERT(inp != NULL, ("udp_detach: inp == NULL"));
1556a152f8a3SRobert Watson 	KASSERT(inp->inp_faddr.s_addr == INADDR_ANY,
1557a152f8a3SRobert Watson 	    ("udp_detach: not disconnected"));
1558603724d3SBjoern A. Zeeb 	INP_INFO_WLOCK(&V_udbinfo);
15598501a69cSRobert Watson 	INP_WLOCK(inp);
15606a9148feSBjoern A. Zeeb 	up = intoudpcb(inp);
15616a9148feSBjoern A. Zeeb 	KASSERT(up != NULL, ("%s: up == NULL", __func__));
15626a9148feSBjoern A. Zeeb 	inp->inp_ppcb = NULL;
1563d0390e05SGarrett Wollman 	in_pcbdetach(inp);
156414ba8addSRobert Watson 	in_pcbfree(inp);
1565603724d3SBjoern A. Zeeb 	INP_INFO_WUNLOCK(&V_udbinfo);
15666a9148feSBjoern A. Zeeb 	udp_discardcb(up);
1567d0390e05SGarrett Wollman }
1568d0390e05SGarrett Wollman 
1569d0390e05SGarrett Wollman static int
1570d0390e05SGarrett Wollman udp_disconnect(struct socket *so)
1571d0390e05SGarrett Wollman {
1572d0390e05SGarrett Wollman 	struct inpcb *inp;
1573d0390e05SGarrett Wollman 
1574d0390e05SGarrett Wollman 	inp = sotoinpcb(so);
157514ba8addSRobert Watson 	KASSERT(inp != NULL, ("udp_disconnect: inp == NULL"));
15768501a69cSRobert Watson 	INP_WLOCK(inp);
1577f76fcf6dSJeffrey Hsu 	if (inp->inp_faddr.s_addr == INADDR_ANY) {
15788501a69cSRobert Watson 		INP_WUNLOCK(inp);
15793329b236SRobert Watson 		return (ENOTCONN);
1580f76fcf6dSJeffrey Hsu 	}
1581fa046d87SRobert Watson 	INP_HASH_WLOCK(&V_udbinfo);
1582df8bae1dSRodney W. Grimes 	in_pcbdisconnect(inp);
1583df8bae1dSRodney W. Grimes 	inp->inp_laddr.s_addr = INADDR_ANY;
1584fa046d87SRobert Watson 	INP_HASH_WUNLOCK(&V_udbinfo);
1585d45e4f99SMaxim Konovalov 	SOCK_LOCK(so);
1586d45e4f99SMaxim Konovalov 	so->so_state &= ~SS_ISCONNECTED;		/* XXX */
1587d45e4f99SMaxim Konovalov 	SOCK_UNLOCK(so);
15888501a69cSRobert Watson 	INP_WUNLOCK(inp);
15893329b236SRobert Watson 	return (0);
1590df8bae1dSRodney W. Grimes }
1591df8bae1dSRodney W. Grimes 
1592d0390e05SGarrett Wollman static int
159357bf258eSGarrett Wollman udp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
1594b40ce416SJulian Elischer     struct mbuf *control, struct thread *td)
1595d0390e05SGarrett Wollman {
1596d0390e05SGarrett Wollman 	struct inpcb *inp;
1597d0390e05SGarrett Wollman 
1598d0390e05SGarrett Wollman 	inp = sotoinpcb(so);
159914ba8addSRobert Watson 	KASSERT(inp != NULL, ("udp_send: inp == NULL"));
16003329b236SRobert Watson 	return (udp_output(inp, m, addr, control, td));
1601d0390e05SGarrett Wollman }
160279288c11SBjoern A. Zeeb #endif /* INET */
1603d0390e05SGarrett Wollman 
160476429de4SYoshinobu Inoue int
1605d0390e05SGarrett Wollman udp_shutdown(struct socket *so)
1606d0390e05SGarrett Wollman {
1607d0390e05SGarrett Wollman 	struct inpcb *inp;
1608d0390e05SGarrett Wollman 
1609d0390e05SGarrett Wollman 	inp = sotoinpcb(so);
161014ba8addSRobert Watson 	KASSERT(inp != NULL, ("udp_shutdown: inp == NULL"));
16118501a69cSRobert Watson 	INP_WLOCK(inp);
1612d0390e05SGarrett Wollman 	socantsendmore(so);
16138501a69cSRobert Watson 	INP_WUNLOCK(inp);
16143329b236SRobert Watson 	return (0);
1615d0390e05SGarrett Wollman }
1616d0390e05SGarrett Wollman 
161779288c11SBjoern A. Zeeb #ifdef INET
1618d0390e05SGarrett Wollman struct pr_usrreqs udp_usrreqs = {
1619756d52a1SPoul-Henning Kamp 	.pru_abort =		udp_abort,
1620756d52a1SPoul-Henning Kamp 	.pru_attach =		udp_attach,
1621756d52a1SPoul-Henning Kamp 	.pru_bind =		udp_bind,
1622756d52a1SPoul-Henning Kamp 	.pru_connect =		udp_connect,
1623756d52a1SPoul-Henning Kamp 	.pru_control =		in_control,
1624756d52a1SPoul-Henning Kamp 	.pru_detach =		udp_detach,
1625756d52a1SPoul-Henning Kamp 	.pru_disconnect =	udp_disconnect,
162654d642bbSRobert Watson 	.pru_peeraddr =		in_getpeeraddr,
1627756d52a1SPoul-Henning Kamp 	.pru_send =		udp_send,
16285df3e839SRobert Watson 	.pru_soreceive =	soreceive_dgram,
162959b8854eSRobert Watson 	.pru_sosend =		sosend_dgram,
1630756d52a1SPoul-Henning Kamp 	.pru_shutdown =		udp_shutdown,
163154d642bbSRobert Watson 	.pru_sockaddr =		in_getsockaddr,
1632a152f8a3SRobert Watson 	.pru_sosetlabel =	in_pcbsosetlabel,
1633a152f8a3SRobert Watson 	.pru_close =		udp_close,
1634d0390e05SGarrett Wollman };
163579288c11SBjoern A. Zeeb #endif /* INET */
1636