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