]>
git.saurik.com Git - apple/xnu.git/blob - bsd/netinet6/udp6_usrreq.c
2 * Copyright (c) 2000-2015 Apple Inc. All rights reserved.
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
29 /* $FreeBSD: src/sys/netinet6/udp6_usrreq.c,v 1.6.2.6 2001/07/29 19:32:40 ume Exp $ */
30 /* $KAME: udp6_usrreq.c,v 1.27 2001/05/21 05:45:10 jinmei Exp $ */
33 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
34 * All rights reserved.
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 * 2. Redistributions in binary form must reproduce the above copyright
42 * notice, this list of conditions and the following disclaimer in the
43 * documentation and/or other materials provided with the distribution.
44 * 3. Neither the name of the project nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
48 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
62 * Copyright (c) 1982, 1986, 1989, 1993
63 * The Regents of the University of California. All rights reserved.
65 * Redistribution and use in source and binary forms, with or without
66 * modification, are permitted provided that the following conditions
68 * 1. Redistributions of source code must retain the above copyright
69 * notice, this list of conditions and the following disclaimer.
70 * 2. Redistributions in binary form must reproduce the above copyright
71 * notice, this list of conditions and the following disclaimer in the
72 * documentation and/or other materials provided with the distribution.
73 * 3. All advertising materials mentioning features or use of this software
74 * must display the following acknowledgement:
75 * This product includes software developed by the University of
76 * California, Berkeley and its contributors.
77 * 4. Neither the name of the University nor the names of its contributors
78 * may be used to endorse or promote products derived from this software
79 * without specific prior written permission.
81 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
82 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
83 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
84 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
85 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
86 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
87 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
88 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
89 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
90 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
93 * @(#)udp_var.h 8.1 (Berkeley) 6/10/93
96 #include <sys/param.h>
97 #include <sys/kernel.h>
98 #include <sys/malloc.h>
100 #include <sys/protosw.h>
101 #include <sys/socket.h>
102 #include <sys/socketvar.h>
103 #include <sys/sysctl.h>
104 #include <sys/errno.h>
105 #include <sys/stat.h>
106 #include <sys/systm.h>
107 #include <sys/syslog.h>
108 #include <sys/proc.h>
109 #include <sys/kauth.h>
112 #include <net/route.h>
113 #include <net/if_types.h>
114 #include <net/ntstat.h>
115 #include <net/dlil.h>
117 #include <netinet/in.h>
118 #include <netinet/in_systm.h>
119 #include <netinet/ip.h>
120 #include <netinet/in_pcb.h>
121 #include <netinet/in_var.h>
122 #include <netinet/ip_var.h>
123 #include <netinet/udp.h>
124 #include <netinet/udp_var.h>
125 #include <netinet/ip6.h>
126 #include <netinet6/ip6_var.h>
127 #include <netinet6/in6_pcb.h>
128 #include <netinet/icmp6.h>
129 #include <netinet6/udp6_var.h>
130 #include <netinet6/ip6protosw.h>
133 #include <netinet6/ipsec.h>
134 #include <netinet6/ipsec6.h>
135 #include <netinet6/esp6.h>
136 extern int ipsec_bypass
;
137 extern int esp_udp_encap_port
;
141 #include <net/necp.h>
145 #include <netinet/flow_divert.h>
146 #endif /* FLOW_DIVERT */
149 * UDP protocol inplementation.
150 * Per RFC 768, August, 1980.
153 static int udp6_abort(struct socket
*);
154 static int udp6_attach(struct socket
*, int, struct proc
*);
155 static int udp6_bind(struct socket
*, struct sockaddr
*, struct proc
*);
156 static int udp6_connectx(struct socket
*, struct sockaddr_list
**,
157 struct sockaddr_list
**, struct proc
*, uint32_t, sae_associd_t
,
158 sae_connid_t
*, uint32_t, void *, uint32_t, struct uio
*, user_ssize_t
*);
159 static int udp6_detach(struct socket
*);
160 static int udp6_disconnect(struct socket
*);
161 static int udp6_disconnectx(struct socket
*, sae_associd_t
, sae_connid_t
);
162 static int udp6_send(struct socket
*, int, struct mbuf
*, struct sockaddr
*,
163 struct mbuf
*, struct proc
*);
164 static void udp6_append(struct inpcb
*, struct ip6_hdr
*,
165 struct sockaddr_in6
*, struct mbuf
*, int, struct ifnet
*);
166 static int udp6_input_checksum(struct mbuf
*, struct udphdr
*, int, int);
169 extern int fw_verbose
;
170 extern void ipfwsyslog( int level
, const char *format
,...);
171 extern void ipfw_stealth_stats_incr_udpv6(void);
173 /* Apple logging, log to ipfw.log */
174 #define log_in_vain_log(a) { \
175 if ((udp_log_in_vain == 3) && (fw_verbose == 2)) { \
177 } else if ((udp_log_in_vain == 4) && (fw_verbose == 2)) { \
178 ipfw_stealth_stats_incr_udpv6(); \
183 #else /* !IPFIREWALL */
184 #define log_in_vain_log( a ) { log a; }
185 #endif /* !IPFIREWALL */
187 struct pr_usrreqs udp6_usrreqs
= {
188 .pru_abort
= udp6_abort
,
189 .pru_attach
= udp6_attach
,
190 .pru_bind
= udp6_bind
,
191 .pru_connect
= udp6_connect
,
192 .pru_connectx
= udp6_connectx
,
193 .pru_control
= in6_control
,
194 .pru_detach
= udp6_detach
,
195 .pru_disconnect
= udp6_disconnect
,
196 .pru_disconnectx
= udp6_disconnectx
,
197 .pru_peeraddr
= in6_mapped_peeraddr
,
198 .pru_send
= udp6_send
,
199 .pru_shutdown
= udp_shutdown
,
200 .pru_sockaddr
= in6_mapped_sockaddr
,
201 .pru_sosend
= sosend
,
202 .pru_soreceive
= soreceive
,
203 .pru_soreceive_list
= soreceive_list
,
207 * subroutine of udp6_input(), mainly for source code readability.
210 udp6_append(struct inpcb
*last
, struct ip6_hdr
*ip6
,
211 struct sockaddr_in6
*udp_in6
, struct mbuf
*n
, int off
, struct ifnet
*ifp
)
214 struct mbuf
*opts
= NULL
;
216 boolean_t cell
= IFNET_IS_CELLULAR(ifp
);
217 boolean_t wifi
= (!cell
&& IFNET_IS_WIFI(ifp
));
218 boolean_t wired
= (!wifi
&& IFNET_IS_WIRED(ifp
));
221 if (mac_inpcb_check_deliver(last
, n
, AF_INET6
, SOCK_DGRAM
) != 0) {
225 #endif /* CONFIG_MACF_NET */
226 if ((last
->in6p_flags
& INP_CONTROLOPTS
) != 0 ||
227 (last
->in6p_socket
->so_options
& SO_TIMESTAMP
) != 0 ||
228 (last
->in6p_socket
->so_options
& SO_TIMESTAMP_MONOTONIC
) != 0) {
229 ret
= ip6_savecontrol(last
, n
, &opts
);
238 INP_ADD_STAT(last
, cell
, wifi
, wired
, rxpackets
, 1);
239 INP_ADD_STAT(last
, cell
, wifi
, wired
, rxbytes
, n
->m_pkthdr
.len
);
241 so_recv_data_stat(last
->in6p_socket
, n
, 0);
242 if (sbappendaddr(&last
->in6p_socket
->so_rcv
,
243 (struct sockaddr
*)udp_in6
, n
, opts
, NULL
) == 0)
244 udpstat
.udps_fullsock
++;
246 sorwakeup(last
->in6p_socket
);
250 udp6_input(struct mbuf
**mp
, int *offp
, int proto
)
252 #pragma unused(proto)
253 struct mbuf
*m
= *mp
;
258 struct mbuf
*opts
= NULL
;
260 int plen
, ulen
, ret
= 0;
261 boolean_t cell
, wifi
, wired
;
262 struct sockaddr_in6 udp_in6
;
263 struct inpcbinfo
*pcbinfo
= &udbinfo
;
264 struct sockaddr_in6 fromsa
;
266 IP6_EXTHDR_CHECK(m
, off
, sizeof (struct udphdr
), return IPPROTO_DONE
);
268 /* Expect 32-bit aligned data pointer on strict-align platforms */
269 MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m
);
271 ifp
= m
->m_pkthdr
.rcvif
;
272 ip6
= mtod(m
, struct ip6_hdr
*);
273 cell
= IFNET_IS_CELLULAR(ifp
);
274 wifi
= (!cell
&& IFNET_IS_WIFI(ifp
));
275 wired
= (!wifi
&& IFNET_IS_WIRED(ifp
));
277 udpstat
.udps_ipackets
++;
279 plen
= ntohs(ip6
->ip6_plen
) - off
+ sizeof (*ip6
);
280 uh
= (struct udphdr
*)(void *)((caddr_t
)ip6
+ off
);
281 ulen
= ntohs((u_short
)uh
->uh_ulen
);
284 udpstat
.udps_badlen
++;
285 IF_UDP_STATINC(ifp
, badlength
);
289 /* destination port of 0 is illegal, based on RFC768. */
290 if (uh
->uh_dport
== 0) {
291 IF_UDP_STATINC(ifp
, port0
);
296 * Checksum extended UDP header and data.
298 if (udp6_input_checksum(m
, uh
, off
, ulen
))
302 * Construct sockaddr format source address.
304 init_sin6(&fromsa
, m
);
305 fromsa
.sin6_port
= uh
->uh_sport
;
307 if (IN6_IS_ADDR_MULTICAST(&ip6
->ip6_dst
)) {
308 int reuse_sock
= 0, mcast_delivered
= 0;
309 struct ip6_moptions
*imo
;
312 * Deliver a multicast datagram to all sockets
313 * for which the local and remote addresses and ports match
314 * those of the incoming datagram. This allows more than
315 * one process to receive multicasts on the same port.
316 * (This really ought to be done for unicast datagrams as
317 * well, but that would cause problems with existing
318 * applications that open both address-specific sockets and
319 * a wildcard socket listening to the same port -- they would
320 * end up receiving duplicates of every unicast datagram.
321 * Those applications open the multiple sockets to overcome an
322 * inadequacy of the UDP socket interface, but for backwards
323 * compatibility we avoid the problem here rather than
324 * fixing the interface. Maybe 4.5BSD will remedy this?)
328 * In a case that laddr should be set to the link-local
329 * address (this happens in RIPng), the multicast address
330 * specified in the received packet does not match with
331 * laddr. To cure this situation, the matching is relaxed
332 * if the receiving interface is the same as one specified
333 * in the socket and if the destination multicast address
334 * matches one of the multicast groups specified in the socket.
338 * Construct sockaddr format source address.
340 init_sin6(&udp_in6
, m
); /* general init */
341 udp_in6
.sin6_port
= uh
->uh_sport
;
343 * KAME note: usually we drop udphdr from mbuf here.
344 * We need udphdr for IPsec processing so we do that later.
348 * Locate pcb(s) for datagram.
349 * (Algorithm copied from raw_intr().)
351 lck_rw_lock_shared(pcbinfo
->ipi_lock
);
353 LIST_FOREACH(in6p
, &udb
, inp_list
) {
358 if ((in6p
->inp_vflag
& INP_IPV6
) == 0)
361 if (inp_restricted_recv(in6p
, ifp
))
364 if (in_pcb_checkstate(in6p
, WNT_ACQUIRE
, 0) ==
368 udp_lock(in6p
->in6p_socket
, 1, 0);
370 if (in_pcb_checkstate(in6p
, WNT_RELEASE
, 1) ==
372 udp_unlock(in6p
->in6p_socket
, 1, 0);
375 if (in6p
->in6p_lport
!= uh
->uh_dport
) {
376 udp_unlock(in6p
->in6p_socket
, 1, 0);
381 * Handle socket delivery policy for any-source
382 * and source-specific multicast. [RFC3678]
384 imo
= in6p
->in6p_moptions
;
385 if (imo
&& IN6_IS_ADDR_MULTICAST(&ip6
->ip6_dst
)) {
386 struct sockaddr_in6 mcaddr
;
390 bzero(&mcaddr
, sizeof (struct sockaddr_in6
));
391 mcaddr
.sin6_len
= sizeof (struct sockaddr_in6
);
392 mcaddr
.sin6_family
= AF_INET6
;
393 mcaddr
.sin6_addr
= ip6
->ip6_dst
;
395 blocked
= im6o_mc_filter(imo
, ifp
,
396 (struct sockaddr
*)&mcaddr
,
397 (struct sockaddr
*)&fromsa
);
399 if (blocked
!= MCAST_PASS
) {
400 udp_unlock(in6p
->in6p_socket
, 1, 0);
401 if (blocked
== MCAST_NOTSMEMBER
||
402 blocked
== MCAST_MUTED
)
403 udpstat
.udps_filtermcast
++;
407 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p
->in6p_faddr
) &&
408 (!IN6_ARE_ADDR_EQUAL(&in6p
->in6p_faddr
,
410 in6p
->in6p_fport
!= uh
->uh_sport
)) {
411 udp_unlock(in6p
->in6p_socket
, 1, 0);
415 reuse_sock
= in6p
->inp_socket
->so_options
&
416 (SO_REUSEPORT
| SO_REUSEADDR
);
420 if (!necp_socket_is_allowed_to_send_recv_v6(in6p
,
421 uh
->uh_dport
, uh
->uh_sport
, &ip6
->ip6_dst
,
422 &ip6
->ip6_src
, ifp
, NULL
, NULL
)) {
423 /* do not inject data to pcb */
429 struct mbuf
*n
= NULL
;
432 * m_copy(m, offset, ...) below.
433 * sbappendaddr() expects M_PKTHDR,
434 * and m_copy() will copy M_PKTHDR
435 * only if offset is 0.
438 n
= m_copy(m
, 0, M_COPYALL
);
439 udp6_append(in6p
, ip6
, &udp_in6
, m
,
440 off
+ sizeof (struct udphdr
), ifp
);
444 udp_unlock(in6p
->in6p_socket
, 1, 0);
447 * Don't look for additional matches if this one does
448 * not have either the SO_REUSEPORT or SO_REUSEADDR
449 * socket options set. This heuristic avoids searching
450 * through all pcbs in the common case of a non-shared
451 * port. It assumes that an application will never
452 * clear these options after setting them.
454 if (reuse_sock
== 0 || m
== NULL
)
458 * Expect 32-bit aligned data pointer on strict-align
461 MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m
);
464 * Recompute IP and UDP header pointers for new mbuf
466 ip6
= mtod(m
, struct ip6_hdr
*);
467 uh
= (struct udphdr
*)(void *)((caddr_t
)ip6
+ off
);
469 lck_rw_done(pcbinfo
->ipi_lock
);
471 if (mcast_delivered
== 0) {
473 * No matching pcb found; discard datagram.
474 * (No need to send an ICMP Port Unreachable
475 * for a broadcast or multicast datgram.)
477 udpstat
.udps_noport
++;
478 udpstat
.udps_noportmcast
++;
479 IF_UDP_STATINC(ifp
, port_unreach
);
483 /* free the extra copy of mbuf or skipped by NECP */
486 return (IPPROTO_DONE
);
491 * UDP to port 4500 with a payload where the first four bytes are
492 * not zero is a UDP encapsulated IPSec packet. Packets where
493 * the payload is one byte and that byte is 0xFF are NAT keepalive
494 * packets. Decapsulate the ESP packet and carry on with IPSec input
495 * or discard the NAT keep-alive.
497 if (ipsec_bypass
== 0 && (esp_udp_encap_port
& 0xFFFF) != 0 &&
498 uh
->uh_dport
== ntohs((u_short
)esp_udp_encap_port
)) {
499 int payload_len
= ulen
- sizeof (struct udphdr
) > 4 ? 4 :
500 ulen
- sizeof (struct udphdr
);
502 if (m
->m_len
< off
+ sizeof (struct udphdr
) + payload_len
) {
503 if ((m
= m_pullup(m
, off
+ sizeof (struct udphdr
) +
504 payload_len
)) == NULL
) {
505 udpstat
.udps_hdrops
++;
509 * Expect 32-bit aligned data pointer on strict-align
512 MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m
);
514 ip6
= mtod(m
, struct ip6_hdr
*);
515 uh
= (struct udphdr
*)(void *)((caddr_t
)ip6
+ off
);
517 /* Check for NAT keepalive packet */
518 if (payload_len
== 1 && *(u_int8_t
*)
519 ((caddr_t
)uh
+ sizeof (struct udphdr
)) == 0xFF) {
521 } else if (payload_len
== 4 && *(u_int32_t
*)(void *)
522 ((caddr_t
)uh
+ sizeof (struct udphdr
)) != 0) {
523 /* UDP encapsulated IPSec packet to pass through NAT */
524 /* preserve the udp header */
525 *offp
= off
+ sizeof (struct udphdr
);
526 return (esp6_input(mp
, offp
, IPPROTO_UDP
));
532 * Locate pcb for datagram.
534 in6p
= in6_pcblookup_hash(&udbinfo
, &ip6
->ip6_src
, uh
->uh_sport
,
535 &ip6
->ip6_dst
, uh
->uh_dport
, 1, m
->m_pkthdr
.rcvif
);
537 IF_UDP_STATINC(ifp
, port_unreach
);
539 if (udp_log_in_vain
) {
540 char buf
[INET6_ADDRSTRLEN
];
542 strlcpy(buf
, ip6_sprintf(&ip6
->ip6_dst
), sizeof (buf
));
543 if (udp_log_in_vain
< 3) {
544 log(LOG_INFO
, "Connection attempt to UDP "
545 "%s:%d from %s:%d\n", buf
,
547 ip6_sprintf(&ip6
->ip6_src
),
548 ntohs(uh
->uh_sport
));
549 } else if (!(m
->m_flags
& (M_BCAST
| M_MCAST
)) &&
550 !IN6_ARE_ADDR_EQUAL(&ip6
->ip6_dst
, &ip6
->ip6_src
)) {
551 log_in_vain_log((LOG_INFO
, "Connection attempt "
552 "to UDP %s:%d from %s:%d\n", buf
,
554 ip6_sprintf(&ip6
->ip6_src
),
555 ntohs(uh
->uh_sport
)));
558 udpstat
.udps_noport
++;
559 if (m
->m_flags
& M_MCAST
) {
560 printf("UDP6: M_MCAST is set in a unicast packet.\n");
561 udpstat
.udps_noportmcast
++;
562 IF_UDP_STATINC(ifp
, badmcast
);
565 icmp6_error(m
, ICMP6_DST_UNREACH
, ICMP6_DST_UNREACH_NOPORT
, 0);
566 return (IPPROTO_DONE
);
569 if (!necp_socket_is_allowed_to_send_recv_v6(in6p
, uh
->uh_dport
,
570 uh
->uh_sport
, &ip6
->ip6_dst
, &ip6
->ip6_src
, ifp
, NULL
, NULL
)) {
571 in_pcb_checkstate(in6p
, WNT_RELEASE
, 0);
572 IF_UDP_STATINC(ifp
, badipsec
);
578 * Construct sockaddr format source address.
579 * Stuff source address and datagram in user buffer.
581 udp_lock(in6p
->in6p_socket
, 1, 0);
583 if (in_pcb_checkstate(in6p
, WNT_RELEASE
, 1) == WNT_STOPUSING
) {
584 udp_unlock(in6p
->in6p_socket
, 1, 0);
585 IF_UDP_STATINC(ifp
, cleanup
);
589 init_sin6(&udp_in6
, m
); /* general init */
590 udp_in6
.sin6_port
= uh
->uh_sport
;
591 if ((in6p
->in6p_flags
& INP_CONTROLOPTS
) != 0 ||
592 (in6p
->in6p_socket
->so_options
& SO_TIMESTAMP
) != 0 ||
593 (in6p
->in6p_socket
->so_options
& SO_TIMESTAMP_MONOTONIC
) != 0) {
594 ret
= ip6_savecontrol(in6p
, m
, &opts
);
596 udp_unlock(in6p
->in6p_socket
, 1, 0);
600 m_adj(m
, off
+ sizeof (struct udphdr
));
602 INP_ADD_STAT(in6p
, cell
, wifi
, wired
, rxpackets
, 1);
603 INP_ADD_STAT(in6p
, cell
, wifi
, wired
, rxbytes
, m
->m_pkthdr
.len
);
605 so_recv_data_stat(in6p
->in6p_socket
, m
, 0);
606 if (sbappendaddr(&in6p
->in6p_socket
->so_rcv
,
607 (struct sockaddr
*)&udp_in6
, m
, opts
, NULL
) == 0) {
610 udpstat
.udps_fullsock
++;
611 udp_unlock(in6p
->in6p_socket
, 1, 0);
614 sorwakeup(in6p
->in6p_socket
);
615 udp_unlock(in6p
->in6p_socket
, 1, 0);
616 return (IPPROTO_DONE
);
622 return (IPPROTO_DONE
);
626 udp6_ctlinput(int cmd
, struct sockaddr
*sa
, void *d
)
632 struct ip6ctlparam
*ip6cp
= NULL
;
633 const struct sockaddr_in6
*sa6_src
= NULL
;
634 void (*notify
)(struct inpcb
*, int) = udp_notify
;
635 struct udp_portonly
{
640 if (sa
->sa_family
!= AF_INET6
||
641 sa
->sa_len
!= sizeof (struct sockaddr_in6
))
644 if ((unsigned)cmd
>= PRC_NCMDS
)
646 if (PRC_IS_REDIRECT(cmd
))
647 notify
= in6_rtchange
, d
= NULL
;
648 else if (cmd
== PRC_HOSTDEAD
)
650 else if (inet6ctlerrmap
[cmd
] == 0)
653 /* if the parameter is from icmp6, decode it. */
655 ip6cp
= (struct ip6ctlparam
*)d
;
657 ip6
= ip6cp
->ip6c_ip6
;
658 off
= ip6cp
->ip6c_off
;
659 sa6_src
= ip6cp
->ip6c_src
;
668 * XXX: We assume that when IPV6 is non NULL,
669 * M and OFF are valid.
672 /* check if we can safely examine src and dst ports */
673 if (m
->m_pkthdr
.len
< off
+ sizeof (*uhp
))
676 bzero(&uh
, sizeof (uh
));
677 m_copydata(m
, off
, sizeof (*uhp
), (caddr_t
)&uh
);
679 (void) in6_pcbnotify(&udbinfo
, sa
, uh
.uh_dport
,
680 (struct sockaddr
*)ip6cp
->ip6c_src
, uh
.uh_sport
,
683 (void) in6_pcbnotify(&udbinfo
, sa
, 0,
684 (struct sockaddr
*)&sa6_src
, 0, cmd
, NULL
, notify
);
689 udp6_abort(struct socket
*so
)
695 panic("%s: so=%p null inp\n", __func__
, so
);
698 soisdisconnected(so
);
704 udp6_attach(struct socket
*so
, int proto
, struct proc
*p
)
706 #pragma unused(proto)
714 error
= in_pcballoc(so
, &udbinfo
, p
);
718 if (so
->so_snd
.sb_hiwat
== 0 || so
->so_rcv
.sb_hiwat
== 0) {
719 error
= soreserve(so
, udp_sendspace
, udp_recvspace
);
723 inp
= (struct inpcb
*)so
->so_pcb
;
724 inp
->inp_vflag
|= INP_IPV6
;
725 if (ip6_mapped_addr_on
)
726 inp
->inp_vflag
|= INP_IPV4
;
727 inp
->in6p_hops
= -1; /* use kernel default */
728 inp
->in6p_cksum
= -1; /* just to be sure */
731 * IPv4 TTL initialization is necessary for an IPv6 socket as well,
732 * because the socket may be bound to an IPv6 wildcard address,
733 * which may match an IPv4-mapped IPv6 address.
735 inp
->inp_ip_ttl
= ip_defttl
;
737 nstat_udp_new_pcb(inp
);
742 udp6_bind(struct socket
*so
, struct sockaddr
*nam
, struct proc
*p
)
751 inp
->inp_vflag
&= ~INP_IPV4
;
752 inp
->inp_vflag
|= INP_IPV6
;
753 if ((inp
->inp_flags
& IN6P_IPV6_V6ONLY
) == 0) {
754 struct sockaddr_in6
*sin6_p
;
756 sin6_p
= (struct sockaddr_in6
*)(void *)nam
;
758 if (IN6_IS_ADDR_UNSPECIFIED(&sin6_p
->sin6_addr
)) {
759 inp
->inp_vflag
|= INP_IPV4
;
760 } else if (IN6_IS_ADDR_V4MAPPED(&sin6_p
->sin6_addr
)) {
761 struct sockaddr_in sin
;
763 in6_sin6_2_sin(&sin
, sin6_p
);
764 inp
->inp_vflag
|= INP_IPV4
;
765 inp
->inp_vflag
&= ~INP_IPV6
;
766 error
= in_pcbbind(inp
, (struct sockaddr
*)&sin
, p
);
771 error
= in6_pcbbind(inp
, nam
, p
);
776 udp6_connect(struct socket
*so
, struct sockaddr
*nam
, struct proc
*p
)
780 #if defined(NECP) && defined(FLOW_DIVERT)
781 int should_use_flow_divert
= 0;
782 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
788 #if defined(NECP) && defined(FLOW_DIVERT)
789 should_use_flow_divert
= necp_socket_should_use_flow_divert(inp
);
790 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
792 if ((inp
->inp_flags
& IN6P_IPV6_V6ONLY
) == 0) {
793 struct sockaddr_in6
*sin6_p
;
795 sin6_p
= (struct sockaddr_in6
*)(void *)nam
;
796 if (IN6_IS_ADDR_V4MAPPED(&sin6_p
->sin6_addr
)) {
797 struct sockaddr_in sin
;
799 if (inp
->inp_faddr
.s_addr
!= INADDR_ANY
)
801 in6_sin6_2_sin(&sin
, sin6_p
);
802 #if defined(NECP) && defined(FLOW_DIVERT)
803 if (should_use_flow_divert
) {
806 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
807 error
= in_pcbconnect(inp
, (struct sockaddr
*)&sin
,
808 p
, IFSCOPE_NONE
, NULL
);
810 inp
->inp_vflag
|= INP_IPV4
;
811 inp
->inp_vflag
&= ~INP_IPV6
;
818 if (!IN6_IS_ADDR_UNSPECIFIED(&inp
->in6p_faddr
))
821 #if defined(NECP) && defined(FLOW_DIVERT)
823 if (should_use_flow_divert
) {
824 uint32_t fd_ctl_unit
= necp_socket_get_flow_divert_control_unit(inp
);
825 if (fd_ctl_unit
> 0) {
826 error
= flow_divert_pcb_init(so
, fd_ctl_unit
);
828 error
= flow_divert_connect_out(so
, nam
, p
);
835 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
837 error
= in6_pcbconnect(inp
, nam
, p
);
839 /* should be non mapped addr */
840 if (ip6_mapped_addr_on
||
841 (inp
->inp_flags
& IN6P_IPV6_V6ONLY
) == 0) {
842 inp
->inp_vflag
&= ~INP_IPV4
;
843 inp
->inp_vflag
|= INP_IPV6
;
846 if (inp
->inp_flowhash
== 0)
847 inp
->inp_flowhash
= inp_calc_flowhash(inp
);
848 /* update flowinfo - RFC 6437 */
849 if (inp
->inp_flow
== 0 &&
850 inp
->in6p_flags
& IN6P_AUTOFLOWLABEL
) {
851 inp
->inp_flow
&= ~IPV6_FLOWLABEL_MASK
;
853 (htonl(inp
->inp_flowhash
) & IPV6_FLOWLABEL_MASK
);
860 udp6_connectx(struct socket
*so
, struct sockaddr_list
**src_sl
,
861 struct sockaddr_list
**dst_sl
, struct proc
*p
, uint32_t ifscope
,
862 sae_associd_t aid
, sae_connid_t
*pcid
, uint32_t flags
, void *arg
,
863 uint32_t arglen
, struct uio
*uio
, user_ssize_t
*bytes_written
)
865 return (udp_connectx_common(so
, AF_INET6
, src_sl
, dst_sl
,
866 p
, ifscope
, aid
, pcid
, flags
, arg
, arglen
, uio
, bytes_written
));
870 udp6_detach(struct socket
*so
)
882 udp6_disconnect(struct socket
*so
)
889 || (necp_socket_should_use_flow_divert(inp
))
892 return (inp
== NULL
? EINVAL
: EPROTOTYPE
);
894 if (inp
->inp_vflag
& INP_IPV4
) {
895 struct pr_usrreqs
*pru
;
897 pru
= ip_protox
[IPPROTO_UDP
]->pr_usrreqs
;
898 return ((*pru
->pru_disconnect
)(so
));
901 if (IN6_IS_ADDR_UNSPECIFIED(&inp
->in6p_faddr
))
904 in6_pcbdisconnect(inp
);
906 /* reset flow-controlled state, just in case */
907 inp_reset_fc_state(inp
);
909 inp
->in6p_laddr
= in6addr_any
;
910 inp
->in6p_last_outifp
= NULL
;
911 so
->so_state
&= ~SS_ISCONNECTED
; /* XXX */
916 udp6_disconnectx(struct socket
*so
, sae_associd_t aid
, sae_connid_t cid
)
919 if (aid
!= SAE_ASSOCID_ANY
&& aid
!= SAE_ASSOCID_ALL
)
922 return (udp6_disconnect(so
));
926 udp6_send(struct socket
*so
, int flags
, struct mbuf
*m
, struct sockaddr
*addr
,
927 struct mbuf
*control
, struct proc
*p
)
931 #if defined(NECP) && defined(FLOW_DIVERT)
932 int should_use_flow_divert
= 0;
933 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
941 #if defined(NECP) && defined(FLOW_DIVERT)
942 should_use_flow_divert
= necp_socket_should_use_flow_divert(inp
);
943 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
946 if (addr
->sa_len
!= sizeof (struct sockaddr_in6
)) {
950 if (addr
->sa_family
!= AF_INET6
) {
951 error
= EAFNOSUPPORT
;
956 if (ip6_mapped_addr_on
|| (inp
->inp_flags
& IN6P_IPV6_V6ONLY
) == 0) {
958 struct sockaddr_in6
*sin6
= NULL
;
961 hasv4addr
= (inp
->inp_vflag
& INP_IPV4
);
963 sin6
= (struct sockaddr_in6
*)(void *)addr
;
965 IN6_IS_ADDR_V4MAPPED(&sin6
->sin6_addr
) ? 1 : 0;
968 struct pr_usrreqs
*pru
;
971 in6_sin6_2_sin_in_sock(addr
);
972 #if defined(NECP) && defined(FLOW_DIVERT)
973 if (should_use_flow_divert
) {
976 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
977 pru
= ip_protox
[IPPROTO_UDP
]->pr_usrreqs
;
978 error
= ((*pru
->pru_send
)(so
, flags
, m
, addr
,
980 /* addr will just be freed in sendit(). */
985 #if defined(NECP) && defined(FLOW_DIVERT)
987 if (should_use_flow_divert
) {
988 /* Implicit connect */
989 return (flow_divert_implicit_data_out(so
, flags
, m
, addr
, control
, p
));
991 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
993 return (udp6_output(inp
, m
, addr
, control
, p
));
1000 if (control
!= NULL
)
1007 * Checksum extended UDP header and data.
1010 udp6_input_checksum(struct mbuf
*m
, struct udphdr
*uh
, int off
, int ulen
)
1012 struct ifnet
*ifp
= m
->m_pkthdr
.rcvif
;
1013 struct ip6_hdr
*ip6
= mtod(m
, struct ip6_hdr
*);
1015 if (uh
->uh_sum
== 0) {
1016 /* UDP/IPv6 checksum is mandatory (RFC2460) */
1017 udpstat
.udps_nosum
++;
1021 if ((hwcksum_rx
|| (ifp
->if_flags
& IFF_LOOPBACK
) ||
1022 (m
->m_pkthdr
.pkt_flags
& PKTF_LOOP
)) &&
1023 (m
->m_pkthdr
.csum_flags
& CSUM_DATA_VALID
)) {
1024 if (m
->m_pkthdr
.csum_flags
& CSUM_PSEUDO_HDR
) {
1025 uh
->uh_sum
= m
->m_pkthdr
.csum_rx_val
;
1027 uint16_t sum
= m
->m_pkthdr
.csum_rx_val
;
1028 uint16_t start
= m
->m_pkthdr
.csum_rx_start
;
1031 * Perform 1's complement adjustment of octets
1032 * that got included/excluded in the hardware-
1033 * calculated checksum value.
1035 if ((m
->m_pkthdr
.csum_flags
& CSUM_PARTIAL
) &&
1039 if (IN6_IS_SCOPE_EMBED(&ip6
->ip6_src
)) {
1040 s
= ip6
->ip6_src
.s6_addr16
[1];
1041 ip6
->ip6_src
.s6_addr16
[1] = 0 ;
1043 if (IN6_IS_SCOPE_EMBED(&ip6
->ip6_dst
)) {
1044 d
= ip6
->ip6_dst
.s6_addr16
[1];
1045 ip6
->ip6_dst
.s6_addr16
[1] = 0;
1048 /* callee folds in sum */
1049 sum
= m_adj_sum16(m
, start
, off
, sum
);
1051 if (IN6_IS_SCOPE_EMBED(&ip6
->ip6_src
))
1052 ip6
->ip6_src
.s6_addr16
[1] = s
;
1053 if (IN6_IS_SCOPE_EMBED(&ip6
->ip6_dst
))
1054 ip6
->ip6_dst
.s6_addr16
[1] = d
;
1057 uh
->uh_sum
= in6_pseudo(&ip6
->ip6_src
, &ip6
->ip6_dst
,
1058 sum
+ htonl(ulen
+ IPPROTO_UDP
));
1060 uh
->uh_sum
^= 0xffff;
1062 udp_in6_cksum_stats(ulen
);
1063 uh
->uh_sum
= in6_cksum(m
, IPPROTO_UDP
, off
, ulen
);
1066 if (uh
->uh_sum
!= 0) {
1068 udpstat
.udps_badsum
++;
1069 IF_UDP_STATINC(ifp
, badchksum
);