Home | History | Annotate | Line # | Download | only in netinet6
udp6_usrreq.c revision 1.154
      1  1.154     ozaki /* $NetBSD: udp6_usrreq.c,v 1.154 2022/11/04 09:01:53 ozaki-r Exp $ */
      2  1.132      maxv /* $KAME: udp6_usrreq.c,v 1.86 2001/05/27 17:33:00 itojun Exp $ */
      3  1.132      maxv /* $KAME: udp6_output.c,v 1.43 2001/10/15 09:19:52 itojun Exp $ */
      4    1.3   thorpej 
      5    1.2    itojun /*
      6    1.2    itojun  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
      7    1.2    itojun  * All rights reserved.
      8   1.27    itojun  *
      9    1.2    itojun  * Redistribution and use in source and binary forms, with or without
     10    1.2    itojun  * modification, are permitted provided that the following conditions
     11    1.2    itojun  * are met:
     12    1.2    itojun  * 1. Redistributions of source code must retain the above copyright
     13    1.2    itojun  *    notice, this list of conditions and the following disclaimer.
     14    1.2    itojun  * 2. Redistributions in binary form must reproduce the above copyright
     15    1.2    itojun  *    notice, this list of conditions and the following disclaimer in the
     16    1.2    itojun  *    documentation and/or other materials provided with the distribution.
     17    1.2    itojun  * 3. Neither the name of the project nor the names of its contributors
     18    1.2    itojun  *    may be used to endorse or promote products derived from this software
     19    1.2    itojun  *    without specific prior written permission.
     20   1.27    itojun  *
     21    1.2    itojun  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
     22    1.2    itojun  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     23    1.2    itojun  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24    1.2    itojun  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
     25    1.2    itojun  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     26    1.2    itojun  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     27    1.2    itojun  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     28    1.2    itojun  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     29    1.2    itojun  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     30    1.2    itojun  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     31    1.2    itojun  * SUCH DAMAGE.
     32    1.2    itojun  */
     33    1.2    itojun 
     34    1.2    itojun /*
     35    1.2    itojun  * Copyright (c) 1982, 1986, 1989, 1993
     36    1.2    itojun  *	The Regents of the University of California.  All rights reserved.
     37    1.2    itojun  *
     38    1.2    itojun  * Redistribution and use in source and binary forms, with or without
     39    1.2    itojun  * modification, are permitted provided that the following conditions
     40    1.2    itojun  * are met:
     41    1.2    itojun  * 1. Redistributions of source code must retain the above copyright
     42    1.2    itojun  *    notice, this list of conditions and the following disclaimer.
     43    1.2    itojun  * 2. Redistributions in binary form must reproduce the above copyright
     44    1.2    itojun  *    notice, this list of conditions and the following disclaimer in the
     45    1.2    itojun  *    documentation and/or other materials provided with the distribution.
     46   1.56       agc  * 3. Neither the name of the University nor the names of its contributors
     47    1.2    itojun  *    may be used to endorse or promote products derived from this software
     48    1.2    itojun  *    without specific prior written permission.
     49    1.2    itojun  *
     50    1.2    itojun  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     51    1.2    itojun  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     52    1.2    itojun  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     53    1.2    itojun  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     54    1.2    itojun  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     55    1.2    itojun  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     56    1.2    itojun  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     57    1.2    itojun  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     58    1.2    itojun  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     59    1.2    itojun  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     60    1.2    itojun  * SUCH DAMAGE.
     61    1.2    itojun  *
     62    1.2    itojun  *	@(#)udp_var.h	8.1 (Berkeley) 6/10/93
     63    1.2    itojun  */
     64   1.51     lukem 
     65   1.51     lukem #include <sys/cdefs.h>
     66  1.154     ozaki __KERNEL_RCSID(0, "$NetBSD: udp6_usrreq.c,v 1.154 2022/11/04 09:01:53 ozaki-r Exp $");
     67   1.90  christos 
     68  1.121     pooka #ifdef _KERNEL_OPT
     69   1.90  christos #include "opt_inet.h"
     70   1.97     rmind #include "opt_inet_csum.h"
     71  1.116     ozaki #include "opt_ipsec.h"
     72  1.126  knakahar #include "opt_net_mpsafe.h"
     73  1.121     pooka #endif
     74    1.2    itojun 
     75    1.2    itojun #include <sys/param.h>
     76    1.2    itojun #include <sys/mbuf.h>
     77    1.2    itojun #include <sys/protosw.h>
     78    1.2    itojun #include <sys/socket.h>
     79    1.2    itojun #include <sys/socketvar.h>
     80    1.2    itojun #include <sys/systm.h>
     81    1.2    itojun #include <sys/proc.h>
     82    1.8    itojun #include <sys/syslog.h>
     83   1.90  christos #include <sys/domain.h>
     84   1.50    simonb #include <sys/sysctl.h>
     85    1.2    itojun 
     86    1.2    itojun #include <net/if.h>
     87    1.2    itojun #include <net/if_types.h>
     88    1.2    itojun 
     89    1.2    itojun #include <netinet/in.h>
     90    1.2    itojun #include <netinet/in_var.h>
     91   1.14    itojun #include <netinet/in_systm.h>
     92   1.97     rmind #include <netinet/in_offload.h>
     93   1.14    itojun #include <netinet/ip.h>
     94   1.14    itojun #include <netinet/ip_var.h>
     95   1.14    itojun #include <netinet/in_pcb.h>
     96   1.14    itojun #include <netinet/udp.h>
     97   1.14    itojun #include <netinet/udp_var.h>
     98   1.97     rmind #include <netinet/udp_private.h>
     99   1.97     rmind 
    100   1.23    itojun #include <netinet/ip6.h>
    101   1.97     rmind #include <netinet/icmp6.h>
    102   1.27    itojun #include <netinet6/ip6_var.h>
    103   1.97     rmind #include <netinet6/ip6_private.h>
    104    1.2    itojun #include <netinet6/in6_pcb.h>
    105    1.2    itojun #include <netinet6/udp6_var.h>
    106   1.82   thorpej #include <netinet6/udp6_private.h>
    107   1.14    itojun #include <netinet6/ip6protosw.h>
    108   1.97     rmind #include <netinet6/scope6_var.h>
    109    1.2    itojun 
    110  1.116     ozaki #ifdef IPSEC
    111  1.116     ozaki #include <netipsec/ipsec.h>
    112  1.144  knakahar #include <netipsec/esp.h>
    113  1.116     ozaki #ifdef INET6
    114  1.116     ozaki #include <netipsec/ipsec6.h>
    115  1.116     ozaki #endif
    116  1.131      maxv #endif
    117  1.116     ozaki 
    118    1.2    itojun #include "faith.h"
    119   1.41    itojun #if defined(NFAITH) && NFAITH > 0
    120   1.41    itojun #include <net/if_faith.h>
    121   1.41    itojun #endif
    122    1.2    itojun 
    123    1.2    itojun /*
    124   1.73    rpaulo  * UDP protocol implementation.
    125    1.2    itojun  * Per RFC 768, August, 1980.
    126    1.2    itojun  */
    127    1.2    itojun 
    128   1.58    itojun extern struct inpcbtable udbtable;
    129   1.82   thorpej 
    130   1.82   thorpej percpu_t *udp6stat_percpu;
    131    1.2    itojun 
    132   1.97     rmind /* UDP on IP6 parameters */
    133  1.131      maxv static int udp6_sendspace = 9216;	/* really max datagram size */
    134  1.131      maxv static int udp6_recvspace = 40 * (1024 + sizeof(struct sockaddr_in6));
    135   1.97     rmind 					/* 40 1K datagrams */
    136   1.97     rmind 
    137  1.151     ozaki static void udp6_notify(struct inpcb *, int);
    138  1.131      maxv static void sysctl_net_inet6_udp6_setup(struct sysctllog **);
    139  1.144  knakahar #ifdef IPSEC
    140  1.145      maxv static int udp6_espinudp(struct mbuf **, int);
    141  1.144  knakahar #endif
    142    1.2    itojun 
    143   1.97     rmind #ifdef UDP_CSUM_COUNTERS
    144   1.97     rmind #include <sys/device.h>
    145   1.97     rmind struct evcnt udp6_hwcsum_bad = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    146   1.97     rmind     NULL, "udp6", "hwcsum bad");
    147   1.97     rmind struct evcnt udp6_hwcsum_ok = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    148   1.97     rmind     NULL, "udp6", "hwcsum ok");
    149   1.97     rmind struct evcnt udp6_hwcsum_data = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    150   1.97     rmind     NULL, "udp6", "hwcsum data");
    151   1.97     rmind struct evcnt udp6_swcsum = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    152   1.97     rmind     NULL, "udp6", "swcsum");
    153   1.97     rmind 
    154   1.97     rmind EVCNT_ATTACH_STATIC(udp6_hwcsum_bad);
    155   1.97     rmind EVCNT_ATTACH_STATIC(udp6_hwcsum_ok);
    156   1.97     rmind EVCNT_ATTACH_STATIC(udp6_hwcsum_data);
    157   1.97     rmind EVCNT_ATTACH_STATIC(udp6_swcsum);
    158   1.97     rmind 
    159   1.97     rmind #define	UDP_CSUM_COUNTER_INCR(ev)	(ev)->ev_count++
    160   1.97     rmind #else
    161   1.97     rmind #define	UDP_CSUM_COUNTER_INCR(ev)	/* nothing */
    162   1.97     rmind #endif
    163   1.97     rmind 
    164    1.2    itojun void
    165   1.81      matt udp6_init(void)
    166    1.2    itojun {
    167   1.88     pooka 	sysctl_net_inet6_udp6_setup(NULL);
    168   1.92     pooka 	udp6stat_percpu = percpu_alloc(sizeof(uint64_t) * UDP6_NSTATS);
    169   1.92     pooka 
    170   1.92     pooka 	udp_init_common();
    171    1.2    itojun }
    172    1.2    itojun 
    173    1.2    itojun /*
    174    1.2    itojun  * Notify a udp user of an asynchronous error;
    175   1.27    itojun  * just wake up so that he can collect error status.
    176    1.2    itojun  */
    177    1.2    itojun static	void
    178  1.151     ozaki udp6_notify(struct inpcb *inp, int errno)
    179    1.2    itojun {
    180  1.151     ozaki 	inp->inp_socket->so_error = errno;
    181  1.151     ozaki 	sorwakeup(inp->inp_socket);
    182  1.151     ozaki 	sowwakeup(inp->inp_socket);
    183    1.2    itojun }
    184    1.2    itojun 
    185   1.84        ad void *
    186   1.76    dyoung udp6_ctlinput(int cmd, const struct sockaddr *sa, void *d)
    187    1.2    itojun {
    188    1.2    itojun 	struct udphdr uh;
    189   1.39    itojun 	struct ip6_hdr *ip6;
    190   1.76    dyoung 	const struct sockaddr_in6 *sa6 = (const struct sockaddr_in6 *)sa;
    191   1.14    itojun 	struct mbuf *m;
    192   1.14    itojun 	int off;
    193   1.40    itojun 	void *cmdarg;
    194   1.40    itojun 	struct ip6ctlparam *ip6cp = NULL;
    195   1.40    itojun 	const struct sockaddr_in6 *sa6_src = NULL;
    196  1.151     ozaki 	void (*notify)(struct inpcb *, int) = udp6_notify;
    197   1.40    itojun 	struct udp_portonly {
    198   1.40    itojun 		u_int16_t uh_sport;
    199   1.40    itojun 		u_int16_t uh_dport;
    200   1.40    itojun 	} *uhp;
    201    1.2    itojun 
    202   1.10    itojun 	if (sa->sa_family != AF_INET6 ||
    203   1.10    itojun 	    sa->sa_len != sizeof(struct sockaddr_in6))
    204   1.84        ad 		return NULL;
    205   1.14    itojun 
    206   1.25    itojun 	if ((unsigned)cmd >= PRC_NCMDS)
    207   1.84        ad 		return NULL;
    208   1.25    itojun 	if (PRC_IS_REDIRECT(cmd))
    209  1.154     ozaki 		notify = in6pcb_rtchange, d = NULL;
    210   1.25    itojun 	else if (cmd == PRC_HOSTDEAD)
    211   1.25    itojun 		d = NULL;
    212   1.47    itojun 	else if (cmd == PRC_MSGSIZE) {
    213   1.47    itojun 		/* special code is present, see below */
    214  1.154     ozaki 		notify = in6pcb_rtchange;
    215   1.47    itojun 	}
    216   1.25    itojun 	else if (inet6ctlerrmap[cmd] == 0)
    217   1.84        ad 		return NULL;
    218    1.7    itojun 
    219   1.14    itojun 	/* if the parameter is from icmp6, decode it. */
    220   1.14    itojun 	if (d != NULL) {
    221   1.40    itojun 		ip6cp = (struct ip6ctlparam *)d;
    222   1.14    itojun 		m = ip6cp->ip6c_m;
    223   1.14    itojun 		ip6 = ip6cp->ip6c_ip6;
    224   1.14    itojun 		off = ip6cp->ip6c_off;
    225   1.40    itojun 		cmdarg = ip6cp->ip6c_cmdarg;
    226   1.40    itojun 		sa6_src = ip6cp->ip6c_src;
    227   1.14    itojun 	} else {
    228   1.14    itojun 		m = NULL;
    229   1.14    itojun 		ip6 = NULL;
    230   1.40    itojun 		cmdarg = NULL;
    231   1.40    itojun 		sa6_src = &sa6_any;
    232   1.60  christos 		off = 0;
    233   1.14    itojun 	}
    234   1.14    itojun 
    235    1.2    itojun 	if (ip6) {
    236   1.33    itojun 		/* check if we can safely examine src and dst ports */
    237   1.42    itojun 		if (m->m_pkthdr.len < off + sizeof(*uhp)) {
    238   1.42    itojun 			if (cmd == PRC_MSGSIZE)
    239   1.42    itojun 				icmp6_mtudisc_update((struct ip6ctlparam *)d, 0);
    240   1.84        ad 			return NULL;
    241   1.42    itojun 		}
    242    1.7    itojun 
    243   1.87    cegger 		memset(&uh, 0, sizeof(uh));
    244   1.77  christos 		m_copydata(m, off, sizeof(*uhp), (void *)&uh);
    245   1.34    itojun 
    246   1.34    itojun 		if (cmd == PRC_MSGSIZE) {
    247   1.36    itojun 			int valid = 0;
    248   1.40    itojun 
    249   1.34    itojun 			/*
    250   1.34    itojun 			 * Check to see if we have a valid UDP socket
    251   1.34    itojun 			 * corresponding to the address in the ICMPv6 message
    252   1.34    itojun 			 * payload.
    253   1.34    itojun 			 */
    254  1.154     ozaki 			if (in6pcb_lookup(&udbtable, &sa6->sin6_addr,
    255   1.68  christos 			    uh.uh_dport, (const struct in6_addr *)&sa6_src->sin6_addr,
    256  1.131      maxv 			    uh.uh_sport, 0, 0))
    257   1.36    itojun 				valid++;
    258   1.34    itojun #if 0
    259   1.34    itojun 			/*
    260   1.34    itojun 			 * As the use of sendto(2) is fairly popular,
    261   1.34    itojun 			 * we may want to allow non-connected pcb too.
    262   1.34    itojun 			 * But it could be too weak against attacks...
    263   1.34    itojun 			 * We should at least check if the local address (= s)
    264   1.34    itojun 			 * is really ours.
    265   1.34    itojun 			 */
    266  1.154     ozaki 			else if (in6pcb_lookup_bound(&udbtable, &sa6->sin6_addr,
    267   1.58    itojun 			    uh.uh_dport, 0))
    268   1.36    itojun 				valid++;
    269   1.34    itojun #endif
    270   1.34    itojun 
    271   1.34    itojun 			/*
    272   1.40    itojun 			 * Depending on the value of "valid" and routing table
    273   1.40    itojun 			 * size (mtudisc_{hi,lo}wat), we will:
    274   1.46    itojun 			 * - recalculate the new MTU and create the
    275   1.40    itojun 			 *   corresponding routing entry, or
    276   1.40    itojun 			 * - ignore the MTU change notification.
    277   1.34    itojun 			 */
    278   1.36    itojun 			icmp6_mtudisc_update((struct ip6ctlparam *)d, valid);
    279   1.34    itojun 
    280   1.40    itojun 			/*
    281   1.74    rpaulo 			 * regardless of if we called
    282   1.74    rpaulo 			 * icmp6_mtudisc_update(), we need to call
    283  1.154     ozaki 			 * in6pcb_notify(), to notify path MTU change
    284   1.74    rpaulo 			 * to the userland (RFC3542), because some
    285   1.74    rpaulo 			 * unconnected sockets may share the same
    286   1.40    itojun 			 * destination and want to know the path MTU.
    287   1.40    itojun 			 */
    288   1.34    itojun 		}
    289   1.34    itojun 
    290  1.154     ozaki 		(void)in6pcb_notify(&udbtable, sa, uh.uh_dport,
    291  1.124     ozaki 		    sin6tocsa(sa6_src), uh.uh_sport, cmd, cmdarg,
    292   1.40    itojun 		    notify);
    293    1.2    itojun 	} else {
    294  1.154     ozaki 		(void)in6pcb_notify(&udbtable, sa, 0,
    295  1.124     ozaki 		    sin6tocsa(sa6_src), 0, cmd, cmdarg, notify);
    296    1.2    itojun 	}
    297   1.84        ad 	return NULL;
    298    1.2    itojun }
    299    1.2    itojun 
    300   1.90  christos int
    301   1.90  christos udp6_ctloutput(int op, struct socket *so, struct sockopt *sopt)
    302   1.90  christos {
    303   1.90  christos 	int s;
    304   1.90  christos 	int error = 0;
    305  1.151     ozaki 	struct inpcb *inp;
    306   1.90  christos 	int family;
    307  1.144  knakahar 	int optval;
    308   1.90  christos 
    309   1.90  christos 	family = so->so_proto->pr_domain->dom_family;
    310   1.90  christos 
    311   1.90  christos 	s = splsoftnet();
    312   1.90  christos 	switch (family) {
    313   1.90  christos #ifdef INET
    314   1.90  christos 	case PF_INET:
    315   1.90  christos 		if (sopt->sopt_level != IPPROTO_UDP) {
    316   1.90  christos 			error = ip_ctloutput(op, so, sopt);
    317   1.90  christos 			goto end;
    318   1.90  christos 		}
    319   1.90  christos 		break;
    320   1.90  christos #endif
    321   1.90  christos #ifdef INET6
    322   1.90  christos 	case PF_INET6:
    323   1.90  christos 		if (sopt->sopt_level != IPPROTO_UDP) {
    324   1.90  christos 			error = ip6_ctloutput(op, so, sopt);
    325   1.90  christos 			goto end;
    326   1.90  christos 		}
    327   1.90  christos 		break;
    328   1.90  christos #endif
    329   1.90  christos 	default:
    330   1.90  christos 		error = EAFNOSUPPORT;
    331   1.90  christos 		goto end;
    332   1.90  christos 	}
    333  1.144  knakahar 
    334  1.144  knakahar 	switch (op) {
    335  1.144  knakahar 	case PRCO_SETOPT:
    336  1.151     ozaki 		inp = sotoinpcb(so);
    337  1.144  knakahar 
    338  1.144  knakahar 		switch (sopt->sopt_name) {
    339  1.144  knakahar 		case UDP_ENCAP:
    340  1.144  knakahar 			error = sockopt_getint(sopt, &optval);
    341  1.144  knakahar 			if (error)
    342  1.144  knakahar 				break;
    343  1.144  knakahar 
    344  1.144  knakahar 			switch(optval) {
    345  1.144  knakahar 			case 0:
    346  1.151     ozaki 				inp->inp_flags &= ~IN6P_ESPINUDP;
    347  1.144  knakahar 				break;
    348  1.144  knakahar 
    349  1.144  knakahar 			case UDP_ENCAP_ESPINUDP:
    350  1.151     ozaki 				inp->inp_flags |= IN6P_ESPINUDP;
    351  1.144  knakahar 				break;
    352  1.144  knakahar 
    353  1.144  knakahar 			default:
    354  1.144  knakahar 				error = EINVAL;
    355  1.144  knakahar 				break;
    356  1.144  knakahar 			}
    357  1.144  knakahar 			break;
    358  1.144  knakahar 
    359  1.144  knakahar 		default:
    360  1.144  knakahar 			error = ENOPROTOOPT;
    361  1.144  knakahar 			break;
    362  1.144  knakahar 		}
    363  1.144  knakahar 		break;
    364  1.144  knakahar 
    365  1.144  knakahar 	default:
    366  1.144  knakahar 		error = EINVAL;
    367  1.144  knakahar 		break;
    368  1.144  knakahar 	}
    369   1.90  christos 
    370   1.90  christos end:
    371   1.90  christos 	splx(s);
    372   1.90  christos 	return error;
    373   1.90  christos }
    374   1.90  christos 
    375   1.97     rmind static void
    376   1.97     rmind udp6_sendup(struct mbuf *m, int off /* offset of data portion */,
    377  1.131      maxv     struct sockaddr *src, struct socket *so)
    378   1.97     rmind {
    379   1.97     rmind 	struct mbuf *opts = NULL;
    380   1.97     rmind 	struct mbuf *n;
    381  1.151     ozaki 	struct inpcb *inp;
    382   1.97     rmind 
    383  1.128     ozaki 	KASSERT(so != NULL);
    384  1.128     ozaki 	KASSERT(so->so_proto->pr_domain->dom_family == AF_INET6);
    385  1.151     ozaki 	inp = sotoinpcb(so);
    386  1.151     ozaki 	KASSERT(inp != NULL);
    387   1.97     rmind 
    388   1.97     rmind #if defined(IPSEC)
    389  1.151     ozaki 	if (ipsec_used && ipsec_in_reject(m, inp)) {
    390   1.97     rmind 		if ((n = m_copypacket(m, M_DONTWAIT)) != NULL)
    391   1.97     rmind 			icmp6_error(n, ICMP6_DST_UNREACH,
    392   1.97     rmind 			    ICMP6_DST_UNREACH_ADMIN, 0);
    393   1.97     rmind 		return;
    394   1.97     rmind 	}
    395  1.131      maxv #endif
    396   1.97     rmind 
    397   1.97     rmind 	if ((n = m_copypacket(m, M_DONTWAIT)) != NULL) {
    398  1.151     ozaki 		if (inp->inp_flags & IN6P_CONTROLOPTS ||
    399  1.151     ozaki 		    SOOPT_TIMESTAMP(inp->inp_socket->so_options)) {
    400   1.97     rmind 			struct ip6_hdr *ip6 = mtod(n, struct ip6_hdr *);
    401  1.151     ozaki 			ip6_savecontrol(inp, &opts, ip6, n);
    402   1.97     rmind 		}
    403   1.97     rmind 
    404   1.97     rmind 		m_adj(n, off);
    405   1.97     rmind 		if (sbappendaddr(&so->so_rcv, src, n, opts) == 0) {
    406   1.97     rmind 			m_freem(n);
    407   1.97     rmind 			if (opts)
    408   1.97     rmind 				m_freem(opts);
    409   1.97     rmind 			UDP6_STATINC(UDP6_STAT_FULLSOCK);
    410  1.138       roy 			soroverflow(so);
    411   1.97     rmind 		} else
    412   1.97     rmind 			sorwakeup(so);
    413   1.97     rmind 	}
    414   1.97     rmind }
    415   1.97     rmind 
    416   1.97     rmind int
    417   1.97     rmind udp6_realinput(int af, struct sockaddr_in6 *src, struct sockaddr_in6 *dst,
    418  1.144  knakahar     struct mbuf **mp, int off)
    419   1.97     rmind {
    420   1.97     rmind 	u_int16_t sport, dport;
    421   1.97     rmind 	int rcvcnt;
    422   1.97     rmind 	struct in6_addr src6, *dst6;
    423   1.97     rmind 	const struct in_addr *dst4;
    424  1.151     ozaki 	struct inpcb *inp;
    425  1.144  knakahar 	struct mbuf *m = *mp;
    426   1.97     rmind 
    427   1.97     rmind 	rcvcnt = 0;
    428   1.97     rmind 	off += sizeof(struct udphdr);	/* now, offset of payload */
    429   1.97     rmind 
    430   1.97     rmind 	if (af != AF_INET && af != AF_INET6)
    431   1.97     rmind 		goto bad;
    432   1.97     rmind 	if (src->sin6_family != AF_INET6 || dst->sin6_family != AF_INET6)
    433   1.97     rmind 		goto bad;
    434   1.97     rmind 
    435   1.97     rmind 	src6 = src->sin6_addr;
    436   1.97     rmind 	if (sa6_recoverscope(src) != 0) {
    437   1.97     rmind 		/* XXX: should be impossible. */
    438   1.97     rmind 		goto bad;
    439   1.97     rmind 	}
    440   1.97     rmind 	sport = src->sin6_port;
    441   1.97     rmind 
    442   1.97     rmind 	dport = dst->sin6_port;
    443   1.97     rmind 	dst4 = (struct in_addr *)&dst->sin6_addr.s6_addr[12];
    444   1.97     rmind 	dst6 = &dst->sin6_addr;
    445   1.97     rmind 
    446   1.97     rmind 	if (IN6_IS_ADDR_MULTICAST(dst6) ||
    447   1.97     rmind 	    (af == AF_INET && IN_MULTICAST(dst4->s_addr))) {
    448   1.97     rmind 		/*
    449   1.97     rmind 		 * Deliver a multicast or broadcast datagram to *all* sockets
    450   1.97     rmind 		 * for which the local and remote addresses and ports match
    451   1.97     rmind 		 * those of the incoming datagram.  This allows more than
    452   1.97     rmind 		 * one process to receive multi/broadcasts on the same port.
    453   1.97     rmind 		 * (This really ought to be done for unicast datagrams as
    454   1.97     rmind 		 * well, but that would cause problems with existing
    455   1.97     rmind 		 * applications that open both address-specific sockets and
    456   1.97     rmind 		 * a wildcard socket listening to the same port -- they would
    457   1.97     rmind 		 * end up receiving duplicates of every unicast datagram.
    458   1.97     rmind 		 * Those applications open the multiple sockets to overcome an
    459   1.97     rmind 		 * inadequacy of the UDP socket interface, but for backwards
    460   1.97     rmind 		 * compatibility we avoid the problem here rather than
    461   1.97     rmind 		 * fixing the interface.  Maybe 4.5BSD will remedy this?)
    462   1.97     rmind 		 */
    463   1.97     rmind 
    464   1.97     rmind 		/*
    465   1.97     rmind 		 * KAME note: traditionally we dropped udpiphdr from mbuf here.
    466   1.97     rmind 		 * we need udpiphdr for IPsec processing so we do that later.
    467   1.97     rmind 		 */
    468   1.97     rmind 		/*
    469   1.97     rmind 		 * Locate pcb(s) for datagram.
    470   1.97     rmind 		 */
    471  1.151     ozaki 		TAILQ_FOREACH(inp, &udbtable.inpt_queue, inp_queue) {
    472  1.151     ozaki 			if (inp->inp_af != AF_INET6)
    473   1.97     rmind 				continue;
    474   1.97     rmind 
    475  1.151     ozaki 			if (inp->inp_lport != dport)
    476   1.97     rmind 				continue;
    477  1.152     ozaki 			if (!IN6_IS_ADDR_UNSPECIFIED(&in6p_laddr(inp))) {
    478  1.152     ozaki 				if (!IN6_ARE_ADDR_EQUAL(&in6p_laddr(inp),
    479   1.97     rmind 				    dst6))
    480   1.97     rmind 					continue;
    481   1.97     rmind 			} else {
    482   1.97     rmind 				if (IN6_IS_ADDR_V4MAPPED(dst6) &&
    483  1.151     ozaki 				    (inp->inp_flags & IN6P_IPV6_V6ONLY))
    484   1.97     rmind 					continue;
    485   1.97     rmind 			}
    486  1.152     ozaki 			if (!IN6_IS_ADDR_UNSPECIFIED(&in6p_faddr(inp))) {
    487  1.152     ozaki 				if (!IN6_ARE_ADDR_EQUAL(&in6p_faddr(inp),
    488  1.151     ozaki 				    &src6) || inp->inp_fport != sport)
    489   1.97     rmind 					continue;
    490   1.97     rmind 			} else {
    491   1.97     rmind 				if (IN6_IS_ADDR_V4MAPPED(&src6) &&
    492  1.151     ozaki 				    (inp->inp_flags & IN6P_IPV6_V6ONLY))
    493   1.97     rmind 					continue;
    494   1.97     rmind 			}
    495   1.97     rmind 
    496  1.151     ozaki 			udp6_sendup(m, off, sin6tosa(src), inp->inp_socket);
    497   1.97     rmind 			rcvcnt++;
    498   1.97     rmind 
    499   1.97     rmind 			/*
    500   1.97     rmind 			 * Don't look for additional matches if this one does
    501   1.97     rmind 			 * not have either the SO_REUSEPORT or SO_REUSEADDR
    502   1.97     rmind 			 * socket options set.  This heuristic avoids searching
    503   1.97     rmind 			 * through all pcbs in the common case of a non-shared
    504   1.97     rmind 			 * port.  It assumes that an application will never
    505   1.97     rmind 			 * clear these options after setting them.
    506   1.97     rmind 			 */
    507  1.151     ozaki 			if ((inp->inp_socket->so_options &
    508   1.97     rmind 			    (SO_REUSEPORT|SO_REUSEADDR)) == 0)
    509   1.97     rmind 				break;
    510   1.97     rmind 		}
    511   1.97     rmind 	} else {
    512   1.97     rmind 		/*
    513   1.97     rmind 		 * Locate pcb for datagram.
    514   1.97     rmind 		 */
    515  1.154     ozaki 		inp = in6pcb_lookup(&udbtable, &src6, sport, dst6,
    516   1.97     rmind 					     dport, 0, 0);
    517  1.151     ozaki 		if (inp == NULL) {
    518   1.97     rmind 			UDP_STATINC(UDP_STAT_PCBHASHMISS);
    519  1.154     ozaki 			inp = in6pcb_lookup_bound(&udbtable, dst6, dport, 0);
    520  1.151     ozaki 			if (inp == NULL)
    521   1.97     rmind 				return rcvcnt;
    522   1.97     rmind 		}
    523   1.97     rmind 
    524  1.144  knakahar #ifdef IPSEC
    525  1.144  knakahar 		/* Handle ESP over UDP */
    526  1.151     ozaki 		if (inp->inp_flags & IN6P_ESPINUDP) {
    527  1.145      maxv 			switch (udp6_espinudp(mp, off)) {
    528  1.144  knakahar 			case -1: /* Error, m was freed */
    529  1.144  knakahar 				rcvcnt = -1;
    530  1.144  knakahar 				goto bad;
    531  1.144  knakahar 
    532  1.144  knakahar 			case 1: /* ESP over UDP */
    533  1.144  knakahar 				rcvcnt++;
    534  1.144  knakahar 				goto bad;
    535  1.144  knakahar 
    536  1.144  knakahar 			case 0: /* plain UDP */
    537  1.144  knakahar 			default: /* Unexpected */
    538  1.144  knakahar 				/*
    539  1.144  knakahar 				 * Normal UDP processing will take place,
    540  1.144  knakahar 				 * m may have changed.
    541  1.144  knakahar 				 */
    542  1.144  knakahar 				m = *mp;
    543  1.144  knakahar 				break;
    544  1.144  knakahar 			}
    545  1.144  knakahar 		}
    546  1.144  knakahar #endif
    547  1.144  knakahar 
    548  1.151     ozaki 		if (inp->inp_overudp_cb != NULL) {
    549  1.148  riastrad 			int ret;
    550  1.151     ozaki 			ret = inp->inp_overudp_cb(mp, off, inp->inp_socket,
    551  1.151     ozaki 			    sin6tosa(src), inp->inp_overudp_arg);
    552  1.148  riastrad 			switch (ret) {
    553  1.148  riastrad 			case -1: /* Error, m was freed */
    554  1.148  riastrad 				rcvcnt = -1;
    555  1.148  riastrad 				goto bad;
    556  1.148  riastrad 
    557  1.148  riastrad 			case 1: /* Foo over UDP */
    558  1.148  riastrad 				KASSERT(*mp == NULL);
    559  1.148  riastrad 				rcvcnt++;
    560  1.148  riastrad 				goto bad;
    561  1.148  riastrad 
    562  1.148  riastrad 			case 0: /* plain UDP */
    563  1.148  riastrad 			default: /* Unexpected */
    564  1.148  riastrad 				/*
    565  1.148  riastrad 				 * Normal UDP processing will take place,
    566  1.148  riastrad 				 * m may have changed.
    567  1.148  riastrad 				 */
    568  1.148  riastrad 				break;
    569  1.148  riastrad 			}
    570  1.148  riastrad 		}
    571  1.148  riastrad 
    572  1.151     ozaki 		udp6_sendup(m, off, sin6tosa(src), inp->inp_socket);
    573   1.97     rmind 		rcvcnt++;
    574   1.97     rmind 	}
    575   1.97     rmind 
    576   1.97     rmind bad:
    577   1.97     rmind 	return rcvcnt;
    578   1.97     rmind }
    579   1.97     rmind 
    580   1.97     rmind int
    581   1.97     rmind udp6_input_checksum(struct mbuf *m, const struct udphdr *uh, int off, int len)
    582   1.97     rmind {
    583   1.97     rmind 
    584   1.97     rmind 	/*
    585   1.97     rmind 	 * XXX it's better to record and check if this mbuf is
    586   1.97     rmind 	 * already checked.
    587   1.97     rmind 	 */
    588   1.97     rmind 
    589   1.97     rmind 	if (__predict_false((m->m_flags & M_LOOP) && !udp_do_loopback_cksum)) {
    590   1.97     rmind 		goto good;
    591   1.97     rmind 	}
    592   1.97     rmind 	if (uh->uh_sum == 0) {
    593   1.97     rmind 		UDP6_STATINC(UDP6_STAT_NOSUM);
    594   1.97     rmind 		goto bad;
    595   1.97     rmind 	}
    596   1.97     rmind 
    597   1.97     rmind 	switch (m->m_pkthdr.csum_flags &
    598  1.123     ozaki 	    ((m_get_rcvif_NOMPSAFE(m)->if_csum_flags_rx & M_CSUM_UDPv6) |
    599   1.97     rmind 	    M_CSUM_TCP_UDP_BAD | M_CSUM_DATA)) {
    600   1.97     rmind 	case M_CSUM_UDPv6|M_CSUM_TCP_UDP_BAD:
    601   1.97     rmind 		UDP_CSUM_COUNTER_INCR(&udp6_hwcsum_bad);
    602   1.97     rmind 		UDP6_STATINC(UDP6_STAT_BADSUM);
    603   1.97     rmind 		goto bad;
    604   1.97     rmind 
    605   1.97     rmind #if 0 /* notyet */
    606   1.97     rmind 	case M_CSUM_UDPv6|M_CSUM_DATA:
    607   1.97     rmind #endif
    608   1.97     rmind 
    609   1.97     rmind 	case M_CSUM_UDPv6:
    610   1.97     rmind 		/* Checksum was okay. */
    611   1.97     rmind 		UDP_CSUM_COUNTER_INCR(&udp6_hwcsum_ok);
    612   1.97     rmind 		break;
    613   1.97     rmind 
    614   1.97     rmind 	default:
    615   1.97     rmind 		/*
    616   1.97     rmind 		 * Need to compute it ourselves.  Maybe skip checksum
    617   1.97     rmind 		 * on loopback interfaces.
    618   1.97     rmind 		 */
    619   1.97     rmind 		UDP_CSUM_COUNTER_INCR(&udp6_swcsum);
    620   1.97     rmind 		if (in6_cksum(m, IPPROTO_UDP, off, len) != 0) {
    621   1.97     rmind 			UDP6_STATINC(UDP6_STAT_BADSUM);
    622   1.97     rmind 			goto bad;
    623   1.97     rmind 		}
    624   1.97     rmind 	}
    625   1.97     rmind 
    626   1.97     rmind good:
    627   1.97     rmind 	return 0;
    628   1.97     rmind bad:
    629   1.97     rmind 	return -1;
    630   1.97     rmind }
    631   1.97     rmind 
    632   1.97     rmind int
    633   1.97     rmind udp6_input(struct mbuf **mp, int *offp, int proto)
    634   1.97     rmind {
    635   1.97     rmind 	struct mbuf *m = *mp;
    636   1.97     rmind 	int off = *offp;
    637   1.97     rmind 	struct sockaddr_in6 src, dst;
    638   1.97     rmind 	struct ip6_hdr *ip6;
    639   1.97     rmind 	struct udphdr *uh;
    640   1.97     rmind 	u_int32_t plen, ulen;
    641   1.97     rmind 
    642   1.97     rmind 	ip6 = mtod(m, struct ip6_hdr *);
    643   1.90  christos 
    644   1.97     rmind #if defined(NFAITH) && 0 < NFAITH
    645   1.97     rmind 	if (faithprefix(&ip6->ip6_dst)) {
    646   1.97     rmind 		/* send icmp6 host unreach? */
    647   1.97     rmind 		m_freem(m);
    648   1.97     rmind 		return IPPROTO_DONE;
    649   1.97     rmind 	}
    650   1.97     rmind #endif
    651   1.97     rmind 
    652   1.97     rmind 	UDP6_STATINC(UDP6_STAT_IPACKETS);
    653   1.97     rmind 
    654  1.131      maxv 	/* Check for jumbogram is done in ip6_input. We can trust pkthdr.len. */
    655   1.97     rmind 	plen = m->m_pkthdr.len - off;
    656   1.97     rmind 	IP6_EXTHDR_GET(uh, struct udphdr *, m, off, sizeof(struct udphdr));
    657   1.97     rmind 	if (uh == NULL) {
    658   1.97     rmind 		IP6_STATINC(IP6_STAT_TOOSHORT);
    659   1.97     rmind 		return IPPROTO_DONE;
    660   1.97     rmind 	}
    661  1.131      maxv 
    662  1.125   mlelstv 	/*
    663  1.125   mlelstv 	 * Enforce alignment requirements that are violated in
    664  1.125   mlelstv 	 * some cases, see kern/50766 for details.
    665  1.125   mlelstv 	 */
    666  1.150  christos 	if (ACCESSIBLE_POINTER(uh, struct udphdr) == 0) {
    667  1.131      maxv 		m = m_copyup(m, off + sizeof(struct udphdr), 0);
    668  1.131      maxv 		if (m == NULL) {
    669  1.131      maxv 			IP6_STATINC(IP6_STAT_TOOSHORT);
    670  1.131      maxv 			return IPPROTO_DONE;
    671  1.131      maxv 		}
    672  1.125   mlelstv 		ip6 = mtod(m, struct ip6_hdr *);
    673  1.131      maxv 		uh = (struct udphdr *)(mtod(m, char *) + off);
    674  1.131      maxv 	}
    675  1.150  christos 	KASSERT(ACCESSIBLE_POINTER(uh, struct udphdr));
    676   1.97     rmind 	ulen = ntohs((u_short)uh->uh_ulen);
    677  1.131      maxv 
    678   1.97     rmind 	/*
    679   1.97     rmind 	 * RFC2675 section 4: jumbograms will have 0 in the UDP header field,
    680   1.97     rmind 	 * iff payload length > 0xffff.
    681   1.97     rmind 	 */
    682   1.97     rmind 	if (ulen == 0 && plen > 0xffff)
    683   1.97     rmind 		ulen = plen;
    684   1.97     rmind 
    685   1.97     rmind 	if (plen != ulen) {
    686   1.97     rmind 		UDP6_STATINC(UDP6_STAT_BADLEN);
    687   1.97     rmind 		goto bad;
    688   1.97     rmind 	}
    689   1.97     rmind 
    690   1.97     rmind 	/* destination port of 0 is illegal, based on RFC768. */
    691   1.97     rmind 	if (uh->uh_dport == 0)
    692   1.97     rmind 		goto bad;
    693   1.97     rmind 
    694   1.97     rmind 	/*
    695   1.97     rmind 	 * Checksum extended UDP header and data.  Maybe skip checksum
    696   1.97     rmind 	 * on loopback interfaces.
    697   1.97     rmind 	 */
    698   1.97     rmind 	if (udp6_input_checksum(m, uh, off, ulen))
    699   1.97     rmind 		goto bad;
    700   1.97     rmind 
    701   1.97     rmind 	/*
    702   1.97     rmind 	 * Construct source and dst sockaddrs.
    703   1.97     rmind 	 */
    704   1.97     rmind 	memset(&src, 0, sizeof(src));
    705   1.97     rmind 	src.sin6_family = AF_INET6;
    706   1.97     rmind 	src.sin6_len = sizeof(struct sockaddr_in6);
    707   1.97     rmind 	src.sin6_addr = ip6->ip6_src;
    708   1.97     rmind 	src.sin6_port = uh->uh_sport;
    709   1.97     rmind 	memset(&dst, 0, sizeof(dst));
    710   1.97     rmind 	dst.sin6_family = AF_INET6;
    711   1.97     rmind 	dst.sin6_len = sizeof(struct sockaddr_in6);
    712   1.97     rmind 	dst.sin6_addr = ip6->ip6_dst;
    713   1.97     rmind 	dst.sin6_port = uh->uh_dport;
    714   1.97     rmind 
    715  1.144  knakahar 	if (udp6_realinput(AF_INET6, &src, &dst, &m, off) == 0) {
    716   1.97     rmind 		if (m->m_flags & M_MCAST) {
    717   1.97     rmind 			UDP6_STATINC(UDP6_STAT_NOPORTMCAST);
    718   1.97     rmind 			goto bad;
    719   1.97     rmind 		}
    720   1.97     rmind 		UDP6_STATINC(UDP6_STAT_NOPORT);
    721   1.97     rmind 		icmp6_error(m, ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_NOPORT, 0);
    722   1.97     rmind 		m = NULL;
    723   1.97     rmind 	}
    724   1.97     rmind 
    725   1.97     rmind bad:
    726   1.97     rmind 	if (m)
    727   1.97     rmind 		m_freem(m);
    728   1.97     rmind 	return IPPROTO_DONE;
    729   1.97     rmind }
    730    1.2    itojun 
    731  1.132      maxv int
    732  1.151     ozaki udp6_output(struct inpcb * const inp, struct mbuf *m,
    733  1.132      maxv     struct sockaddr_in6 * const addr6, struct mbuf * const control,
    734  1.132      maxv     struct lwp * const l)
    735  1.132      maxv {
    736  1.132      maxv 	u_int32_t ulen = m->m_pkthdr.len;
    737  1.132      maxv 	u_int32_t plen = sizeof(struct udphdr) + ulen;
    738  1.132      maxv 	struct ip6_hdr *ip6;
    739  1.132      maxv 	struct udphdr *udp6;
    740  1.132      maxv 	struct in6_addr _laddr, *laddr, *faddr;
    741  1.132      maxv 	struct in6_addr laddr_mapped; /* XXX ugly */
    742  1.132      maxv 	struct sockaddr_in6 *sin6 = NULL;
    743  1.132      maxv 	struct ifnet *oifp = NULL;
    744  1.132      maxv 	int scope_ambiguous = 0;
    745  1.132      maxv 	u_int16_t fport;
    746  1.132      maxv 	int error = 0;
    747  1.132      maxv 	struct ip6_pktopts *optp = NULL;
    748  1.132      maxv 	struct ip6_pktopts opt;
    749  1.132      maxv 	int af = AF_INET6, hlen = sizeof(struct ip6_hdr);
    750  1.132      maxv #ifdef INET
    751  1.132      maxv 	struct ip *ip;
    752  1.132      maxv 	struct udpiphdr *ui;
    753  1.132      maxv 	int flags = 0;
    754  1.132      maxv #endif
    755  1.132      maxv 	struct sockaddr_in6 tmp;
    756  1.132      maxv 
    757  1.132      maxv 	if (addr6) {
    758  1.132      maxv 		sin6 = addr6;
    759  1.143     ozaki 		if (sin6->sin6_len != sizeof(*sin6)) {
    760  1.143     ozaki 			error = EINVAL;
    761  1.143     ozaki 			goto release;
    762  1.143     ozaki 		}
    763  1.132      maxv 		if (sin6->sin6_family != AF_INET6) {
    764  1.132      maxv 			error = EAFNOSUPPORT;
    765  1.132      maxv 			goto release;
    766  1.132      maxv 		}
    767  1.132      maxv 
    768  1.132      maxv 		/* protect *sin6 from overwrites */
    769  1.132      maxv 		tmp = *sin6;
    770  1.132      maxv 		sin6 = &tmp;
    771  1.132      maxv 
    772  1.132      maxv 		/*
    773  1.132      maxv 		 * Application should provide a proper zone ID or the use of
    774  1.132      maxv 		 * default zone IDs should be enabled.  Unfortunately, some
    775  1.132      maxv 		 * applications do not behave as it should, so we need a
    776  1.132      maxv 		 * workaround.  Even if an appropriate ID is not determined,
    777  1.132      maxv 		 * we'll see if we can determine the outgoing interface.  If we
    778  1.132      maxv 		 * can, determine the zone ID based on the interface below.
    779  1.132      maxv 		 */
    780  1.132      maxv 		if (sin6->sin6_scope_id == 0 && !ip6_use_defzone)
    781  1.132      maxv 			scope_ambiguous = 1;
    782  1.132      maxv 		if ((error = sa6_embedscope(sin6, ip6_use_defzone)) != 0)
    783  1.132      maxv 			goto release;
    784  1.132      maxv 	}
    785  1.132      maxv 
    786  1.132      maxv 	if (control) {
    787  1.133      maxv 		if (__predict_false(l == NULL)) {
    788  1.133      maxv 			panic("%s: control but no lwp", __func__);
    789  1.133      maxv 		}
    790  1.132      maxv 		if ((error = ip6_setpktopts(control, &opt,
    791  1.152     ozaki 		    in6p_outputopts(inp), l->l_cred, IPPROTO_UDP)) != 0)
    792  1.132      maxv 			goto release;
    793  1.132      maxv 		optp = &opt;
    794  1.132      maxv 	} else
    795  1.152     ozaki 		optp = in6p_outputopts(inp);
    796  1.132      maxv 
    797  1.132      maxv 
    798  1.132      maxv 	if (sin6) {
    799  1.132      maxv 		/*
    800  1.132      maxv 		 * Slightly different than v4 version in that we call
    801  1.154     ozaki 		 * in6_selectsrc and in6pcb_set_port to fill in the local
    802  1.153     ozaki 		 * address and port rather than inpcb_connect. inpcb_connect
    803  1.151     ozaki 		 * sets inp_faddr which causes EISCONN below to be hit on
    804  1.132      maxv 		 * subsequent sendto.
    805  1.132      maxv 		 */
    806  1.132      maxv 		if (sin6->sin6_port == 0) {
    807  1.132      maxv 			error = EADDRNOTAVAIL;
    808  1.132      maxv 			goto release;
    809  1.132      maxv 		}
    810  1.132      maxv 
    811  1.152     ozaki 		if (!IN6_IS_ADDR_UNSPECIFIED(&in6p_faddr(inp))) {
    812  1.132      maxv 			/* how about ::ffff:0.0.0.0 case? */
    813  1.132      maxv 			error = EISCONN;
    814  1.132      maxv 			goto release;
    815  1.132      maxv 		}
    816  1.132      maxv 
    817  1.132      maxv 		faddr = &sin6->sin6_addr;
    818  1.132      maxv 		fport = sin6->sin6_port; /* allow 0 port */
    819  1.132      maxv 
    820  1.132      maxv 		if (IN6_IS_ADDR_V4MAPPED(faddr)) {
    821  1.151     ozaki 			if ((inp->inp_flags & IN6P_IPV6_V6ONLY)) {
    822  1.132      maxv 				/*
    823  1.132      maxv 				 * I believe we should explicitly discard the
    824  1.132      maxv 				 * packet when mapped addresses are disabled,
    825  1.132      maxv 				 * rather than send the packet as an IPv6 one.
    826  1.132      maxv 				 * If we chose the latter approach, the packet
    827  1.132      maxv 				 * might be sent out on the wire based on the
    828  1.132      maxv 				 * default route, the situation which we'd
    829  1.132      maxv 				 * probably want to avoid.
    830  1.132      maxv 				 * (20010421 jinmei (at) kame.net)
    831  1.132      maxv 				 */
    832  1.132      maxv 				error = EINVAL;
    833  1.132      maxv 				goto release;
    834  1.132      maxv 			}
    835  1.152     ozaki 			if (!IN6_IS_ADDR_UNSPECIFIED(&in6p_laddr(inp)) &&
    836  1.152     ozaki 			    !IN6_IS_ADDR_V4MAPPED(&in6p_laddr(inp))) {
    837  1.132      maxv 				/*
    838  1.132      maxv 				 * when remote addr is an IPv4-mapped address,
    839  1.132      maxv 				 * local addr should not be an IPv6 address,
    840  1.132      maxv 				 * since you cannot determine how to map IPv6
    841  1.132      maxv 				 * source address to IPv4.
    842  1.132      maxv 				 */
    843  1.132      maxv 				error = EINVAL;
    844  1.132      maxv 				goto release;
    845  1.132      maxv 			}
    846  1.132      maxv 
    847  1.132      maxv 			af = AF_INET;
    848  1.132      maxv 		}
    849  1.132      maxv 
    850  1.132      maxv 		if (!IN6_IS_ADDR_V4MAPPED(faddr)) {
    851  1.132      maxv 			struct psref psref;
    852  1.132      maxv 			int bound = curlwp_bind();
    853  1.132      maxv 
    854  1.132      maxv 			error = in6_selectsrc(sin6, optp,
    855  1.152     ozaki 			    in6p_moptions(inp),
    856  1.151     ozaki 			    &inp->inp_route,
    857  1.152     ozaki 			    &in6p_laddr(inp), &oifp, &psref, &_laddr);
    858  1.142   mlelstv 			if (error)
    859  1.142   mlelstv 				laddr = NULL;
    860  1.142   mlelstv 			else
    861  1.142   mlelstv 				laddr = &_laddr;
    862  1.132      maxv 			if (oifp && scope_ambiguous &&
    863  1.132      maxv 			    (error = in6_setscope(&sin6->sin6_addr,
    864  1.132      maxv 			    oifp, NULL))) {
    865  1.132      maxv 				if_put(oifp, &psref);
    866  1.132      maxv 				curlwp_bindx(bound);
    867  1.132      maxv 				goto release;
    868  1.132      maxv 			}
    869  1.132      maxv 			if_put(oifp, &psref);
    870  1.132      maxv 			curlwp_bindx(bound);
    871  1.132      maxv 		} else {
    872  1.132      maxv 			/*
    873  1.132      maxv 			 * XXX: freebsd[34] does not have in_selectsrc, but
    874  1.132      maxv 			 * we can omit the whole part because freebsd4 calls
    875  1.132      maxv 			 * udp_output() directly in this case, and thus we'll
    876  1.132      maxv 			 * never see this path.
    877  1.132      maxv 			 */
    878  1.152     ozaki 			if (IN6_IS_ADDR_UNSPECIFIED(&in6p_laddr(inp))) {
    879  1.132      maxv 				struct sockaddr_in sin_dst;
    880  1.132      maxv 				struct in_addr ina;
    881  1.132      maxv 				struct in_ifaddr *ia4;
    882  1.132      maxv 				struct psref _psref;
    883  1.132      maxv 				int bound;
    884  1.132      maxv 
    885  1.132      maxv 				memcpy(&ina, &faddr->s6_addr[12], sizeof(ina));
    886  1.132      maxv 				sockaddr_in_init(&sin_dst, &ina, 0);
    887  1.132      maxv 				bound = curlwp_bind();
    888  1.151     ozaki 				ia4 = in_selectsrc(&sin_dst, &inp->inp_route,
    889  1.151     ozaki 				    inp->inp_socket->so_options, NULL,
    890  1.132      maxv 				    &error, &_psref);
    891  1.132      maxv 				if (ia4 == NULL) {
    892  1.132      maxv 					curlwp_bindx(bound);
    893  1.132      maxv 					if (error == 0)
    894  1.132      maxv 						error = EADDRNOTAVAIL;
    895  1.132      maxv 					goto release;
    896  1.132      maxv 				}
    897  1.132      maxv 				memset(&laddr_mapped, 0, sizeof(laddr_mapped));
    898  1.132      maxv 				laddr_mapped.s6_addr16[5] = 0xffff; /* ugly */
    899  1.132      maxv 				memcpy(&laddr_mapped.s6_addr[12],
    900  1.132      maxv 				      &IA_SIN(ia4)->sin_addr,
    901  1.132      maxv 				      sizeof(IA_SIN(ia4)->sin_addr));
    902  1.132      maxv 				ia4_release(ia4, &_psref);
    903  1.132      maxv 				curlwp_bindx(bound);
    904  1.132      maxv 				laddr = &laddr_mapped;
    905  1.132      maxv 			} else
    906  1.132      maxv 			{
    907  1.152     ozaki 				laddr = &in6p_laddr(inp);	/* XXX */
    908  1.132      maxv 			}
    909  1.132      maxv 		}
    910  1.132      maxv 		if (laddr == NULL) {
    911  1.132      maxv 			if (error == 0)
    912  1.132      maxv 				error = EADDRNOTAVAIL;
    913  1.132      maxv 			goto release;
    914  1.132      maxv 		}
    915  1.151     ozaki 		if (inp->inp_lport == 0) {
    916  1.132      maxv 			/*
    917  1.132      maxv 			 * Craft a sockaddr_in6 for the local endpoint. Use the
    918  1.132      maxv 			 * "any" as a base, set the address, and recover the
    919  1.132      maxv 			 * scope.
    920  1.132      maxv 			 */
    921  1.132      maxv 			struct sockaddr_in6 lsin6 =
    922  1.151     ozaki 			    *((const struct sockaddr_in6 *)inp->inp_socket->so_proto->pr_domain->dom_sa_any);
    923  1.132      maxv 			lsin6.sin6_addr = *laddr;
    924  1.132      maxv 			error = sa6_recoverscope(&lsin6);
    925  1.132      maxv 			if (error)
    926  1.132      maxv 				goto release;
    927  1.132      maxv 
    928  1.154     ozaki 			error = in6pcb_set_port(&lsin6, inp, l);
    929  1.132      maxv 
    930  1.132      maxv 			if (error) {
    931  1.152     ozaki 				in6p_laddr(inp) = in6addr_any;
    932  1.132      maxv 				goto release;
    933  1.132      maxv 			}
    934  1.132      maxv 		}
    935  1.132      maxv 	} else {
    936  1.152     ozaki 		if (IN6_IS_ADDR_UNSPECIFIED(&in6p_faddr(inp))) {
    937  1.132      maxv 			error = ENOTCONN;
    938  1.132      maxv 			goto release;
    939  1.132      maxv 		}
    940  1.152     ozaki 		if (IN6_IS_ADDR_V4MAPPED(&in6p_faddr(inp))) {
    941  1.151     ozaki 			if ((inp->inp_flags & IN6P_IPV6_V6ONLY))
    942  1.132      maxv 			{
    943  1.132      maxv 				/*
    944  1.132      maxv 				 * XXX: this case would happen when the
    945  1.132      maxv 				 * application sets the V6ONLY flag after
    946  1.132      maxv 				 * connecting the foreign address.
    947  1.132      maxv 				 * Such applications should be fixed,
    948  1.132      maxv 				 * so we bark here.
    949  1.132      maxv 				 */
    950  1.132      maxv 				log(LOG_INFO, "udp6_output: IPV6_V6ONLY "
    951  1.132      maxv 				    "option was set for a connected socket\n");
    952  1.132      maxv 				error = EINVAL;
    953  1.132      maxv 				goto release;
    954  1.132      maxv 			} else
    955  1.132      maxv 				af = AF_INET;
    956  1.132      maxv 		}
    957  1.152     ozaki 		laddr = &in6p_laddr(inp);
    958  1.152     ozaki 		faddr = &in6p_faddr(inp);
    959  1.151     ozaki 		fport = inp->inp_fport;
    960  1.132      maxv 	}
    961  1.132      maxv 
    962  1.132      maxv 	if (af == AF_INET)
    963  1.132      maxv 		hlen = sizeof(struct ip);
    964  1.132      maxv 
    965  1.132      maxv 	/*
    966  1.132      maxv 	 * Calculate data length and get a mbuf
    967  1.132      maxv 	 * for UDP and IP6 headers.
    968  1.132      maxv 	 */
    969  1.132      maxv 	M_PREPEND(m, hlen + sizeof(struct udphdr), M_DONTWAIT);
    970  1.132      maxv 	if (m == NULL) {
    971  1.132      maxv 		error = ENOBUFS;
    972  1.132      maxv 		goto release;
    973  1.132      maxv 	}
    974  1.132      maxv 
    975  1.132      maxv 	/*
    976  1.132      maxv 	 * Stuff checksum and output datagram.
    977  1.132      maxv 	 */
    978  1.132      maxv 	udp6 = (struct udphdr *)(mtod(m, char *) + hlen);
    979  1.151     ozaki 	udp6->uh_sport = inp->inp_lport; /* lport is always set in the PCB */
    980  1.132      maxv 	udp6->uh_dport = fport;
    981  1.132      maxv 	if (plen <= 0xffff)
    982  1.132      maxv 		udp6->uh_ulen = htons((u_int16_t)plen);
    983  1.132      maxv 	else
    984  1.132      maxv 		udp6->uh_ulen = 0;
    985  1.132      maxv 	udp6->uh_sum = 0;
    986  1.132      maxv 
    987  1.132      maxv 	switch (af) {
    988  1.132      maxv 	case AF_INET6:
    989  1.132      maxv 		ip6 = mtod(m, struct ip6_hdr *);
    990  1.152     ozaki 		ip6->ip6_flow	= in6p_flowinfo(inp) & IPV6_FLOWINFO_MASK;
    991  1.132      maxv 		ip6->ip6_vfc 	&= ~IPV6_VERSION_MASK;
    992  1.132      maxv 		ip6->ip6_vfc 	|= IPV6_VERSION;
    993  1.132      maxv #if 0		/* ip6_plen will be filled in ip6_output. */
    994  1.132      maxv 		ip6->ip6_plen	= htons((u_int16_t)plen);
    995  1.132      maxv #endif
    996  1.132      maxv 		ip6->ip6_nxt	= IPPROTO_UDP;
    997  1.154     ozaki 		ip6->ip6_hlim	= in6pcb_selecthlim_rt(inp);
    998  1.132      maxv 		ip6->ip6_src	= *laddr;
    999  1.132      maxv 		ip6->ip6_dst	= *faddr;
   1000  1.132      maxv 
   1001  1.132      maxv 		udp6->uh_sum = in6_cksum_phdr(laddr, faddr,
   1002  1.132      maxv 		    htonl(plen), htonl(IPPROTO_UDP));
   1003  1.132      maxv 		m->m_pkthdr.csum_flags = M_CSUM_UDPv6;
   1004  1.132      maxv 		m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
   1005  1.132      maxv 
   1006  1.132      maxv 		UDP6_STATINC(UDP6_STAT_OPACKETS);
   1007  1.151     ozaki 		error = ip6_output(m, optp, &inp->inp_route, 0,
   1008  1.152     ozaki 		    in6p_moptions(inp), inp, NULL);
   1009  1.132      maxv 		break;
   1010  1.132      maxv 	case AF_INET:
   1011  1.132      maxv #ifdef INET
   1012  1.132      maxv 		/* can't transmit jumbogram over IPv4 */
   1013  1.132      maxv 		if (plen > 0xffff) {
   1014  1.132      maxv 			error = EMSGSIZE;
   1015  1.132      maxv 			goto release;
   1016  1.132      maxv 		}
   1017  1.132      maxv 
   1018  1.132      maxv 		ip = mtod(m, struct ip *);
   1019  1.132      maxv 		ui = (struct udpiphdr *)ip;
   1020  1.132      maxv 		memset(ui->ui_x1, 0, sizeof(ui->ui_x1));
   1021  1.132      maxv 		ui->ui_pr = IPPROTO_UDP;
   1022  1.132      maxv 		ui->ui_len = htons(plen);
   1023  1.132      maxv 		memcpy(&ui->ui_src, &laddr->s6_addr[12], sizeof(ui->ui_src));
   1024  1.132      maxv 		ui->ui_ulen = ui->ui_len;
   1025  1.132      maxv 
   1026  1.151     ozaki 		flags = (inp->inp_socket->so_options &
   1027  1.132      maxv 			 (SO_DONTROUTE | SO_BROADCAST));
   1028  1.132      maxv 		memcpy(&ui->ui_dst, &faddr->s6_addr[12], sizeof(ui->ui_dst));
   1029  1.132      maxv 
   1030  1.132      maxv 		udp6->uh_sum = in_cksum(m, hlen + plen);
   1031  1.132      maxv 		if (udp6->uh_sum == 0)
   1032  1.132      maxv 			udp6->uh_sum = 0xffff;
   1033  1.132      maxv 
   1034  1.132      maxv 		ip->ip_len = htons(hlen + plen);
   1035  1.154     ozaki 		ip->ip_ttl = in6pcb_selecthlim(inp, NULL); /* XXX */
   1036  1.132      maxv 		ip->ip_tos = 0;	/* XXX */
   1037  1.132      maxv 
   1038  1.132      maxv 		UDP_STATINC(UDP_STAT_OPACKETS);
   1039  1.151     ozaki 		error = ip_output(m, NULL, &inp->inp_route, flags /* XXX */,
   1040  1.151     ozaki 		    inp->inp_moptions, NULL);
   1041  1.132      maxv 		break;
   1042  1.132      maxv #else
   1043  1.132      maxv 		error = EAFNOSUPPORT;
   1044  1.132      maxv 		goto release;
   1045  1.132      maxv #endif
   1046  1.132      maxv 	}
   1047  1.132      maxv 	goto releaseopt;
   1048  1.132      maxv 
   1049  1.132      maxv release:
   1050  1.132      maxv 	m_freem(m);
   1051  1.132      maxv 
   1052  1.132      maxv releaseopt:
   1053  1.132      maxv 	if (control) {
   1054  1.132      maxv 		if (optp == &opt)
   1055  1.132      maxv 			ip6_clearpktopts(&opt, -1);
   1056  1.132      maxv 		m_freem(control);
   1057  1.132      maxv 	}
   1058  1.132      maxv 	return (error);
   1059  1.132      maxv }
   1060  1.132      maxv 
   1061   1.95     rmind static int
   1062   1.95     rmind udp6_attach(struct socket *so, int proto)
   1063   1.95     rmind {
   1064  1.151     ozaki 	struct inpcb *inp;
   1065   1.95     rmind 	int s, error;
   1066   1.95     rmind 
   1067  1.151     ozaki 	KASSERT(sotoinpcb(so) == NULL);
   1068   1.95     rmind 	sosetlock(so);
   1069   1.95     rmind 
   1070  1.147      maxv 	error = soreserve(so, udp6_sendspace, udp6_recvspace);
   1071  1.147      maxv 	if (error) {
   1072  1.147      maxv 		return error;
   1073  1.147      maxv 	}
   1074  1.147      maxv 
   1075   1.95     rmind 	/*
   1076   1.95     rmind 	 * MAPPED_ADDR implementation spec:
   1077   1.95     rmind 	 *  Always attach for IPv6, and only when necessary for IPv4.
   1078   1.95     rmind 	 */
   1079   1.95     rmind 	s = splsoftnet();
   1080  1.153     ozaki 	error = inpcb_create(so, &udbtable);
   1081   1.95     rmind 	splx(s);
   1082   1.95     rmind 	if (error) {
   1083   1.95     rmind 		return error;
   1084   1.95     rmind 	}
   1085  1.147      maxv 
   1086  1.151     ozaki 	inp = sotoinpcb(so);
   1087  1.152     ozaki 	in6p_cksum(inp) = -1;	/* just to be sure */
   1088   1.95     rmind 
   1089   1.95     rmind 	KASSERT(solocked(so));
   1090   1.95     rmind 	return 0;
   1091   1.95     rmind }
   1092   1.95     rmind 
   1093   1.95     rmind static void
   1094   1.95     rmind udp6_detach(struct socket *so)
   1095   1.95     rmind {
   1096  1.151     ozaki 	struct inpcb *inp = sotoinpcb(so);
   1097   1.95     rmind 	int s;
   1098   1.95     rmind 
   1099   1.95     rmind 	KASSERT(solocked(so));
   1100  1.151     ozaki 	KASSERT(inp != NULL);
   1101   1.95     rmind 
   1102   1.95     rmind 	s = splsoftnet();
   1103  1.153     ozaki 	inpcb_destroy(inp);
   1104   1.95     rmind 	splx(s);
   1105   1.95     rmind }
   1106   1.95     rmind 
   1107   1.99       rtr static int
   1108  1.118       rtr udp6_accept(struct socket *so, struct sockaddr *nam)
   1109  1.107       rtr {
   1110  1.107       rtr 	KASSERT(solocked(so));
   1111  1.107       rtr 
   1112  1.107       rtr 	return EOPNOTSUPP;
   1113  1.107       rtr }
   1114  1.107       rtr 
   1115  1.107       rtr static int
   1116  1.117       rtr udp6_bind(struct socket *so, struct sockaddr *nam, struct lwp *l)
   1117  1.109       rtr {
   1118  1.151     ozaki 	struct inpcb *inp = sotoinpcb(so);
   1119  1.117       rtr 	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)nam;
   1120  1.109       rtr 	int error = 0;
   1121  1.109       rtr 	int s;
   1122  1.109       rtr 
   1123  1.109       rtr 	KASSERT(solocked(so));
   1124  1.151     ozaki 	KASSERT(inp != NULL);
   1125  1.109       rtr 
   1126  1.109       rtr 	s = splsoftnet();
   1127  1.154     ozaki 	error = in6pcb_bind(inp, sin6, l);
   1128  1.109       rtr 	splx(s);
   1129  1.109       rtr 	return error;
   1130  1.109       rtr }
   1131  1.109       rtr 
   1132  1.109       rtr static int
   1133  1.112       rtr udp6_listen(struct socket *so, struct lwp *l)
   1134  1.109       rtr {
   1135  1.109       rtr 	KASSERT(solocked(so));
   1136  1.109       rtr 
   1137  1.109       rtr 	return EOPNOTSUPP;
   1138  1.109       rtr }
   1139  1.109       rtr 
   1140  1.109       rtr static int
   1141  1.120       rtr udp6_connect(struct socket *so, struct sockaddr *nam, struct lwp *l)
   1142  1.110       rtr {
   1143  1.151     ozaki 	struct inpcb *inp = sotoinpcb(so);
   1144  1.110       rtr 	int error = 0;
   1145  1.110       rtr 	int s;
   1146  1.110       rtr 
   1147  1.110       rtr 	KASSERT(solocked(so));
   1148  1.151     ozaki 	KASSERT(inp != NULL);
   1149  1.110       rtr 
   1150  1.152     ozaki 	if (!IN6_IS_ADDR_UNSPECIFIED(&in6p_faddr(inp)))
   1151  1.110       rtr 		return EISCONN;
   1152  1.110       rtr 	s = splsoftnet();
   1153  1.154     ozaki 	error = in6pcb_connect(inp, (struct sockaddr_in6 *)nam, l);
   1154  1.110       rtr 	splx(s);
   1155  1.110       rtr 	if (error == 0)
   1156  1.110       rtr 		soisconnected(so);
   1157  1.110       rtr 
   1158  1.110       rtr 	return error;
   1159  1.110       rtr }
   1160  1.110       rtr 
   1161  1.110       rtr static int
   1162  1.115       rtr udp6_connect2(struct socket *so, struct socket *so2)
   1163  1.115       rtr {
   1164  1.115       rtr 	KASSERT(solocked(so));
   1165  1.115       rtr 
   1166  1.115       rtr 	return EOPNOTSUPP;
   1167  1.115       rtr }
   1168  1.115       rtr 
   1169  1.115       rtr static int
   1170  1.111       rtr udp6_disconnect(struct socket *so)
   1171  1.111       rtr {
   1172  1.151     ozaki 	struct inpcb *inp = sotoinpcb(so);
   1173  1.111       rtr 	int s;
   1174  1.111       rtr 
   1175  1.111       rtr 	KASSERT(solocked(so));
   1176  1.151     ozaki 	KASSERT(inp != NULL);
   1177  1.111       rtr 
   1178  1.152     ozaki 	if (IN6_IS_ADDR_UNSPECIFIED(&in6p_faddr(inp)))
   1179  1.111       rtr 		return ENOTCONN;
   1180  1.111       rtr 
   1181  1.111       rtr 	s = splsoftnet();
   1182  1.154     ozaki 	in6pcb_disconnect(inp);
   1183  1.152     ozaki 	memset((void *)&in6p_laddr(inp), 0, sizeof(in6p_laddr(inp)));
   1184  1.111       rtr 	splx(s);
   1185  1.111       rtr 
   1186  1.111       rtr 	so->so_state &= ~SS_ISCONNECTED;	/* XXX */
   1187  1.154     ozaki 	in6pcb_set_state(inp, INP_BOUND);		/* XXX */
   1188  1.111       rtr 	return 0;
   1189  1.111       rtr }
   1190  1.111       rtr 
   1191  1.111       rtr static int
   1192  1.111       rtr udp6_shutdown(struct socket *so)
   1193  1.111       rtr {
   1194  1.111       rtr 	int s;
   1195  1.111       rtr 
   1196  1.111       rtr 	s = splsoftnet();
   1197  1.111       rtr 	socantsendmore(so);
   1198  1.111       rtr 	splx(s);
   1199  1.111       rtr 
   1200  1.111       rtr 	return 0;
   1201  1.111       rtr }
   1202  1.111       rtr 
   1203  1.111       rtr static int
   1204  1.111       rtr udp6_abort(struct socket *so)
   1205  1.111       rtr {
   1206  1.111       rtr 	int s;
   1207  1.111       rtr 
   1208  1.111       rtr 	KASSERT(solocked(so));
   1209  1.151     ozaki 	KASSERT(sotoinpcb(so) != NULL);
   1210  1.111       rtr 
   1211  1.111       rtr 	s = splsoftnet();
   1212  1.111       rtr 	soisdisconnected(so);
   1213  1.153     ozaki 	inpcb_destroy(sotoinpcb(so));
   1214  1.111       rtr 	splx(s);
   1215  1.111       rtr 
   1216  1.111       rtr 	return 0;
   1217  1.111       rtr }
   1218  1.111       rtr 
   1219  1.111       rtr static int
   1220  1.101       rtr udp6_ioctl(struct socket *so, u_long cmd, void *addr6, struct ifnet *ifp)
   1221    1.2    itojun {
   1222   1.27    itojun 	/*
   1223    1.2    itojun 	 * MAPPED_ADDR implementation info:
   1224    1.2    itojun 	 *  Mapped addr support for PRU_CONTROL is not necessary.
   1225    1.2    itojun 	 *  Because typical user of PRU_CONTROL is such as ifconfig,
   1226    1.2    itojun 	 *  and they don't associate any addr to their socket.  Then
   1227    1.2    itojun 	 *  socket family is only hint about the PRU_CONTROL'ed address
   1228    1.2    itojun 	 *  family, especially when getting addrs from kernel.
   1229    1.2    itojun 	 *  So AF_INET socket need to be used to control AF_INET addrs,
   1230    1.2    itojun 	 *  and AF_INET6 socket for AF_INET6 addrs.
   1231    1.2    itojun 	 */
   1232  1.101       rtr 	return in6_control(so, cmd, addr6, ifp);
   1233   1.99       rtr }
   1234   1.99       rtr 
   1235  1.102       rtr static int
   1236  1.102       rtr udp6_stat(struct socket *so, struct stat *ub)
   1237  1.102       rtr {
   1238  1.105       rtr 	KASSERT(solocked(so));
   1239  1.105       rtr 
   1240  1.104       rtr 	/* stat: don't bother with a blocksize */
   1241  1.104       rtr 	return 0;
   1242  1.102       rtr }
   1243  1.102       rtr 
   1244  1.106       rtr static int
   1245  1.118       rtr udp6_peeraddr(struct socket *so, struct sockaddr *nam)
   1246  1.106       rtr {
   1247  1.106       rtr 	KASSERT(solocked(so));
   1248  1.151     ozaki 	KASSERT(sotoinpcb(so) != NULL);
   1249  1.106       rtr 	KASSERT(nam != NULL);
   1250  1.106       rtr 
   1251  1.154     ozaki 	in6pcb_fetch_peeraddr(sotoinpcb(so), (struct sockaddr_in6 *)nam);
   1252  1.106       rtr 	return 0;
   1253  1.106       rtr }
   1254  1.106       rtr 
   1255  1.106       rtr static int
   1256  1.118       rtr udp6_sockaddr(struct socket *so, struct sockaddr *nam)
   1257  1.106       rtr {
   1258  1.106       rtr 	KASSERT(solocked(so));
   1259  1.151     ozaki 	KASSERT(sotoinpcb(so) != NULL);
   1260  1.106       rtr 	KASSERT(nam != NULL);
   1261  1.106       rtr 
   1262  1.154     ozaki 	in6pcb_fetch_sockaddr(sotoinpcb(so), (struct sockaddr_in6 *)nam);
   1263  1.106       rtr 	return 0;
   1264  1.106       rtr }
   1265  1.106       rtr 
   1266  1.108       rtr static int
   1267  1.114       rtr udp6_rcvd(struct socket *so, int flags, struct lwp *l)
   1268  1.114       rtr {
   1269  1.114       rtr 	KASSERT(solocked(so));
   1270  1.114       rtr 
   1271  1.114       rtr 	return EOPNOTSUPP;
   1272  1.114       rtr }
   1273  1.114       rtr 
   1274  1.114       rtr static int
   1275  1.108       rtr udp6_recvoob(struct socket *so, struct mbuf *m, int flags)
   1276  1.108       rtr {
   1277  1.108       rtr 	KASSERT(solocked(so));
   1278  1.108       rtr 
   1279  1.108       rtr 	return EOPNOTSUPP;
   1280  1.108       rtr }
   1281  1.108       rtr 
   1282  1.108       rtr static int
   1283  1.120       rtr udp6_send(struct socket *so, struct mbuf *m, struct sockaddr *nam,
   1284  1.113       rtr     struct mbuf *control, struct lwp *l)
   1285  1.113       rtr {
   1286  1.151     ozaki 	struct inpcb *inp = sotoinpcb(so);
   1287  1.113       rtr 	int error = 0;
   1288  1.113       rtr 	int s;
   1289  1.113       rtr 
   1290  1.113       rtr 	KASSERT(solocked(so));
   1291  1.151     ozaki 	KASSERT(inp != NULL);
   1292  1.113       rtr 	KASSERT(m != NULL);
   1293  1.113       rtr 
   1294  1.113       rtr 	s = splsoftnet();
   1295  1.151     ozaki 	error = udp6_output(inp, m, (struct sockaddr_in6 *)nam, control, l);
   1296  1.113       rtr 	splx(s);
   1297  1.113       rtr 
   1298  1.113       rtr 	return error;
   1299  1.113       rtr }
   1300  1.113       rtr 
   1301  1.113       rtr static int
   1302  1.108       rtr udp6_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control)
   1303  1.108       rtr {
   1304  1.108       rtr 	KASSERT(solocked(so));
   1305  1.108       rtr 
   1306  1.146    martin 	m_freem(m);
   1307  1.146    martin 	m_freem(control);
   1308  1.108       rtr 
   1309  1.108       rtr 	return EOPNOTSUPP;
   1310  1.108       rtr }
   1311  1.108       rtr 
   1312  1.115       rtr static int
   1313  1.115       rtr udp6_purgeif(struct socket *so, struct ifnet *ifp)
   1314  1.115       rtr {
   1315  1.115       rtr 
   1316  1.115       rtr 	mutex_enter(softnet_lock);
   1317  1.154     ozaki 	in6pcb_purgeif0(&udbtable, ifp);
   1318  1.127     ozaki #ifdef NET_MPSAFE
   1319  1.127     ozaki 	mutex_exit(softnet_lock);
   1320  1.126  knakahar #endif
   1321  1.115       rtr 	in6_purgeif(ifp);
   1322  1.127     ozaki #ifdef NET_MPSAFE
   1323  1.127     ozaki 	mutex_enter(softnet_lock);
   1324  1.127     ozaki #endif
   1325  1.154     ozaki 	in6pcb_purgeif(&udbtable, ifp);
   1326  1.115       rtr 	mutex_exit(softnet_lock);
   1327  1.115       rtr 
   1328  1.115       rtr 	return 0;
   1329  1.115       rtr }
   1330  1.115       rtr 
   1331   1.82   thorpej static int
   1332   1.82   thorpej sysctl_net_inet6_udp6_stats(SYSCTLFN_ARGS)
   1333   1.82   thorpej {
   1334   1.82   thorpej 
   1335   1.86   thorpej 	return (NETSTAT_SYSCTL(udp6stat_percpu, UDP6_NSTATS));
   1336   1.82   thorpej }
   1337   1.82   thorpej 
   1338   1.88     pooka static void
   1339   1.88     pooka sysctl_net_inet6_udp6_setup(struct sysctllog **clog)
   1340    1.2    itojun {
   1341   1.93     pooka 
   1342   1.62    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1343   1.62    atatat 		       CTLFLAG_PERMANENT,
   1344   1.61    atatat 		       CTLTYPE_NODE, "inet6", NULL,
   1345   1.61    atatat 		       NULL, 0, NULL, 0,
   1346   1.61    atatat 		       CTL_NET, PF_INET6, CTL_EOL);
   1347   1.62    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1348   1.62    atatat 		       CTLFLAG_PERMANENT,
   1349   1.63    atatat 		       CTLTYPE_NODE, "udp6",
   1350   1.63    atatat 		       SYSCTL_DESCR("UDPv6 related settings"),
   1351   1.61    atatat 		       NULL, 0, NULL, 0,
   1352   1.61    atatat 		       CTL_NET, PF_INET6, IPPROTO_UDP, CTL_EOL);
   1353   1.61    atatat 
   1354   1.62    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1355   1.62    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   1356   1.63    atatat 		       CTLTYPE_INT, "sendspace",
   1357   1.63    atatat 		       SYSCTL_DESCR("Default UDP send buffer size"),
   1358   1.61    atatat 		       NULL, 0, &udp6_sendspace, 0,
   1359   1.61    atatat 		       CTL_NET, PF_INET6, IPPROTO_UDP, UDP6CTL_SENDSPACE,
   1360   1.61    atatat 		       CTL_EOL);
   1361   1.62    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1362   1.62    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   1363   1.63    atatat 		       CTLTYPE_INT, "recvspace",
   1364   1.63    atatat 		       SYSCTL_DESCR("Default UDP receive buffer size"),
   1365   1.61    atatat 		       NULL, 0, &udp6_recvspace, 0,
   1366   1.61    atatat 		       CTL_NET, PF_INET6, IPPROTO_UDP, UDP6CTL_RECVSPACE,
   1367   1.61    atatat 		       CTL_EOL);
   1368   1.64   thorpej 	sysctl_createv(clog, 0, NULL, NULL,
   1369   1.64   thorpej 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   1370   1.64   thorpej 		       CTLTYPE_INT, "do_loopback_cksum",
   1371   1.64   thorpej 		       SYSCTL_DESCR("Perform UDP checksum on loopback"),
   1372   1.64   thorpej 		       NULL, 0, &udp_do_loopback_cksum, 0,
   1373   1.64   thorpej 		       CTL_NET, PF_INET6, IPPROTO_UDP, UDP6CTL_LOOPBACKCKSUM,
   1374   1.64   thorpej 		       CTL_EOL);
   1375   1.65    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1376   1.65    atatat 		       CTLFLAG_PERMANENT,
   1377   1.67    atatat 		       CTLTYPE_STRUCT, "pcblist",
   1378   1.65    atatat 		       SYSCTL_DESCR("UDP protocol control block list"),
   1379   1.65    atatat 		       sysctl_inpcblist, 0, &udbtable, 0,
   1380   1.65    atatat 		       CTL_NET, PF_INET6, IPPROTO_UDP, CTL_CREATE,
   1381   1.65    atatat 		       CTL_EOL);
   1382   1.70    rpaulo 	sysctl_createv(clog, 0, NULL, NULL,
   1383   1.70    rpaulo 		       CTLFLAG_PERMANENT,
   1384   1.70    rpaulo 		       CTLTYPE_STRUCT, "stats",
   1385   1.70    rpaulo 		       SYSCTL_DESCR("UDPv6 statistics"),
   1386   1.82   thorpej 		       sysctl_net_inet6_udp6_stats, 0, NULL, 0,
   1387   1.70    rpaulo 		       CTL_NET, PF_INET6, IPPROTO_UDP, UDP6CTL_STATS,
   1388   1.70    rpaulo 		       CTL_EOL);
   1389    1.2    itojun }
   1390   1.82   thorpej 
   1391   1.82   thorpej void
   1392   1.82   thorpej udp6_statinc(u_int stat)
   1393   1.82   thorpej {
   1394   1.82   thorpej 
   1395   1.82   thorpej 	KASSERT(stat < UDP6_NSTATS);
   1396   1.82   thorpej 	UDP6_STATINC(stat);
   1397   1.82   thorpej }
   1398   1.94     rmind 
   1399  1.144  knakahar #ifdef IPSEC
   1400  1.144  knakahar /*
   1401  1.144  knakahar  * Returns:
   1402  1.144  knakahar  *     1 if the packet was processed
   1403  1.144  knakahar  *     0 if normal UDP processing should take place
   1404  1.144  knakahar  *    -1 if an error occurred and m was freed
   1405  1.144  knakahar  */
   1406  1.144  knakahar static int
   1407  1.145      maxv udp6_espinudp(struct mbuf **mp, int off)
   1408  1.144  knakahar {
   1409  1.144  knakahar 	const size_t skip = sizeof(struct udphdr);
   1410  1.144  knakahar 	size_t len;
   1411  1.144  knakahar 	void *data;
   1412  1.144  knakahar 	size_t minlen;
   1413  1.144  knakahar 	int ip6hdrlen;
   1414  1.144  knakahar 	struct ip6_hdr *ip6;
   1415  1.144  knakahar 	struct m_tag *tag;
   1416  1.144  knakahar 	struct udphdr *udphdr;
   1417  1.144  knakahar 	u_int16_t sport, dport;
   1418  1.144  knakahar 	struct mbuf *m = *mp;
   1419  1.144  knakahar 	uint32_t *marker;
   1420  1.144  knakahar 
   1421  1.144  knakahar 	/*
   1422  1.144  knakahar 	 * Collapse the mbuf chain if the first mbuf is too short
   1423  1.144  knakahar 	 * The longest case is: UDP + non ESP marker + ESP
   1424  1.144  knakahar 	 */
   1425  1.144  knakahar 	minlen = off + sizeof(u_int64_t) + sizeof(struct esp);
   1426  1.144  knakahar 	if (minlen > m->m_pkthdr.len)
   1427  1.144  knakahar 		minlen = m->m_pkthdr.len;
   1428  1.144  knakahar 
   1429  1.144  knakahar 	if (m->m_len < minlen) {
   1430  1.144  knakahar 		if ((*mp = m_pullup(m, minlen)) == NULL) {
   1431  1.144  knakahar 			return -1;
   1432  1.144  knakahar 		}
   1433  1.144  knakahar 		m = *mp;
   1434  1.144  knakahar 	}
   1435  1.144  knakahar 
   1436  1.144  knakahar 	len = m->m_len - off;
   1437  1.144  knakahar 	data = mtod(m, char *) + off;
   1438  1.144  knakahar 
   1439  1.144  knakahar 	/* Ignore keepalive packets */
   1440  1.144  knakahar 	if ((len == 1) && (*(unsigned char *)data == 0xff)) {
   1441  1.144  knakahar 		m_freem(m);
   1442  1.144  knakahar 		*mp = NULL; /* avoid any further processing by caller ... */
   1443  1.144  knakahar 		return 1;
   1444  1.144  knakahar 	}
   1445  1.144  knakahar 
   1446  1.144  knakahar 	/* Handle Non-ESP marker (32bit). If zero, then IKE. */
   1447  1.144  knakahar 	marker = (uint32_t *)data;
   1448  1.144  knakahar 	if (len <= sizeof(uint32_t))
   1449  1.144  knakahar 		return 0;
   1450  1.144  knakahar 	if (marker[0] == 0)
   1451  1.144  knakahar 		return 0;
   1452  1.144  knakahar 
   1453  1.144  knakahar 	/*
   1454  1.144  knakahar 	 * Get the UDP ports. They are handled in network
   1455  1.144  knakahar 	 * order everywhere in IPSEC_NAT_T code.
   1456  1.144  knakahar 	 */
   1457  1.144  knakahar 	udphdr = (struct udphdr *)((char *)data - skip);
   1458  1.144  knakahar 	sport = udphdr->uh_sport;
   1459  1.144  knakahar 	dport = udphdr->uh_dport;
   1460  1.144  knakahar 
   1461  1.144  knakahar 	/*
   1462  1.144  knakahar 	 * Remove the UDP header (and possibly the non ESP marker)
   1463  1.144  knakahar 	 * IPv6 header length is ip6hdrlen
   1464  1.144  knakahar 	 * Before:
   1465  1.144  knakahar 	 *   <---- off --->
   1466  1.144  knakahar 	 *   +-----+------+-----+
   1467  1.144  knakahar 	 *   | IP6 |  UDP | ESP |
   1468  1.144  knakahar 	 *   +-----+------+-----+
   1469  1.144  knakahar 	 *         <-skip->
   1470  1.144  knakahar 	 * After:
   1471  1.144  knakahar 	 *          +-----+-----+
   1472  1.144  knakahar 	 *          | IP6 | ESP |
   1473  1.144  knakahar 	 *          +-----+-----+
   1474  1.144  knakahar 	 *   <-skip->
   1475  1.144  knakahar 	 */
   1476  1.144  knakahar 	ip6hdrlen = off - sizeof(struct udphdr);
   1477  1.144  knakahar 	memmove(mtod(m, char *) + skip, mtod(m, void *), ip6hdrlen);
   1478  1.144  knakahar 	m_adj(m, skip);
   1479  1.144  knakahar 
   1480  1.144  knakahar 	ip6 = mtod(m, struct ip6_hdr *);
   1481  1.144  knakahar 	ip6->ip6_plen = htons(ntohs(ip6->ip6_plen) - skip);
   1482  1.144  knakahar 	ip6->ip6_nxt = IPPROTO_ESP;
   1483  1.144  knakahar 
   1484  1.144  knakahar 	/*
   1485  1.144  knakahar 	 * We have modified the packet - it is now ESP, so we should not
   1486  1.144  knakahar 	 * return to UDP processing ...
   1487  1.144  knakahar 	 *
   1488  1.144  knakahar 	 * Add a PACKET_TAG_IPSEC_NAT_T_PORT tag to remember
   1489  1.144  knakahar 	 * the source UDP port. This is required if we want
   1490  1.144  knakahar 	 * to select the right SPD for multiple hosts behind
   1491  1.144  knakahar 	 * same NAT
   1492  1.144  knakahar 	 */
   1493  1.144  knakahar 	if ((tag = m_tag_get(PACKET_TAG_IPSEC_NAT_T_PORTS,
   1494  1.144  knakahar 	    sizeof(sport) + sizeof(dport), M_DONTWAIT)) == NULL) {
   1495  1.144  knakahar 		m_freem(m);
   1496  1.144  knakahar 		return -1;
   1497  1.144  knakahar 	}
   1498  1.144  knakahar 	((u_int16_t *)(tag + 1))[0] = sport;
   1499  1.144  knakahar 	((u_int16_t *)(tag + 1))[1] = dport;
   1500  1.144  knakahar 	m_tag_prepend(m, tag);
   1501  1.144  knakahar 
   1502  1.144  knakahar 	if (ipsec_used)
   1503  1.144  knakahar 		ipsec6_common_input(&m, &ip6hdrlen, IPPROTO_ESP);
   1504  1.144  knakahar 	else
   1505  1.144  knakahar 		m_freem(m);
   1506  1.144  knakahar 
   1507  1.144  knakahar 	/* We handled it, it shouldn't be handled by UDP */
   1508  1.144  knakahar 	*mp = NULL; /* avoid free by caller ... */
   1509  1.144  knakahar 	return 1;
   1510  1.144  knakahar }
   1511  1.144  knakahar #endif /* IPSEC */
   1512  1.144  knakahar 
   1513   1.96     rmind PR_WRAP_USRREQS(udp6)
   1514   1.96     rmind #define	udp6_attach	udp6_attach_wrapper
   1515   1.96     rmind #define	udp6_detach	udp6_detach_wrapper
   1516  1.107       rtr #define	udp6_accept	udp6_accept_wrapper
   1517  1.109       rtr #define	udp6_bind	udp6_bind_wrapper
   1518  1.109       rtr #define	udp6_listen	udp6_listen_wrapper
   1519  1.110       rtr #define	udp6_connect	udp6_connect_wrapper
   1520  1.115       rtr #define	udp6_connect2	udp6_connect2_wrapper
   1521  1.111       rtr #define	udp6_disconnect	udp6_disconnect_wrapper
   1522  1.111       rtr #define	udp6_shutdown	udp6_shutdown_wrapper
   1523  1.111       rtr #define	udp6_abort	udp6_abort_wrapper
   1524   1.99       rtr #define	udp6_ioctl	udp6_ioctl_wrapper
   1525  1.102       rtr #define	udp6_stat	udp6_stat_wrapper
   1526  1.106       rtr #define	udp6_peeraddr	udp6_peeraddr_wrapper
   1527  1.106       rtr #define	udp6_sockaddr	udp6_sockaddr_wrapper
   1528  1.114       rtr #define	udp6_rcvd	udp6_rcvd_wrapper
   1529  1.108       rtr #define	udp6_recvoob	udp6_recvoob_wrapper
   1530  1.113       rtr #define	udp6_send	udp6_send_wrapper
   1531  1.108       rtr #define	udp6_sendoob	udp6_sendoob_wrapper
   1532  1.115       rtr #define	udp6_purgeif	udp6_purgeif_wrapper
   1533   1.94     rmind 
   1534   1.94     rmind const struct pr_usrreqs udp6_usrreqs = {
   1535   1.95     rmind 	.pr_attach	= udp6_attach,
   1536   1.95     rmind 	.pr_detach	= udp6_detach,
   1537  1.107       rtr 	.pr_accept	= udp6_accept,
   1538  1.109       rtr 	.pr_bind	= udp6_bind,
   1539  1.109       rtr 	.pr_listen	= udp6_listen,
   1540  1.110       rtr 	.pr_connect	= udp6_connect,
   1541  1.115       rtr 	.pr_connect2	= udp6_connect2,
   1542  1.111       rtr 	.pr_disconnect	= udp6_disconnect,
   1543  1.111       rtr 	.pr_shutdown	= udp6_shutdown,
   1544  1.111       rtr 	.pr_abort	= udp6_abort,
   1545   1.99       rtr 	.pr_ioctl	= udp6_ioctl,
   1546  1.102       rtr 	.pr_stat	= udp6_stat,
   1547  1.106       rtr 	.pr_peeraddr	= udp6_peeraddr,
   1548  1.106       rtr 	.pr_sockaddr	= udp6_sockaddr,
   1549  1.114       rtr 	.pr_rcvd	= udp6_rcvd,
   1550  1.108       rtr 	.pr_recvoob	= udp6_recvoob,
   1551  1.113       rtr 	.pr_send	= udp6_send,
   1552  1.108       rtr 	.pr_sendoob	= udp6_sendoob,
   1553  1.115       rtr 	.pr_purgeif	= udp6_purgeif,
   1554   1.94     rmind };
   1555