]>
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);
168 struct pr_usrreqs udp6_usrreqs
= {
169 .pru_abort
= udp6_abort
,
170 .pru_attach
= udp6_attach
,
171 .pru_bind
= udp6_bind
,
172 .pru_connect
= udp6_connect
,
173 .pru_connectx
= udp6_connectx
,
174 .pru_control
= in6_control
,
175 .pru_detach
= udp6_detach
,
176 .pru_disconnect
= udp6_disconnect
,
177 .pru_disconnectx
= udp6_disconnectx
,
178 .pru_peeraddr
= in6_mapped_peeraddr
,
179 .pru_send
= udp6_send
,
180 .pru_shutdown
= udp_shutdown
,
181 .pru_sockaddr
= in6_mapped_sockaddr
,
182 .pru_sosend
= sosend
,
183 .pru_soreceive
= soreceive
,
184 .pru_soreceive_list
= soreceive_list
,
188 * subroutine of udp6_input(), mainly for source code readability.
191 udp6_append(struct inpcb
*last
, struct ip6_hdr
*ip6
,
192 struct sockaddr_in6
*udp_in6
, struct mbuf
*n
, int off
, struct ifnet
*ifp
)
195 struct mbuf
*opts
= NULL
;
197 boolean_t cell
= IFNET_IS_CELLULAR(ifp
);
198 boolean_t wifi
= (!cell
&& IFNET_IS_WIFI(ifp
));
199 boolean_t wired
= (!wifi
&& IFNET_IS_WIRED(ifp
));
202 if (mac_inpcb_check_deliver(last
, n
, AF_INET6
, SOCK_DGRAM
) != 0) {
206 #endif /* CONFIG_MACF_NET */
207 if ((last
->in6p_flags
& INP_CONTROLOPTS
) != 0 ||
208 (last
->in6p_socket
->so_options
& SO_TIMESTAMP
) != 0 ||
209 (last
->in6p_socket
->so_options
& SO_TIMESTAMP_MONOTONIC
) != 0) {
210 ret
= ip6_savecontrol(last
, n
, &opts
);
219 INP_ADD_STAT(last
, cell
, wifi
, wired
, rxpackets
, 1);
220 INP_ADD_STAT(last
, cell
, wifi
, wired
, rxbytes
, n
->m_pkthdr
.len
);
222 so_recv_data_stat(last
->in6p_socket
, n
, 0);
223 if (sbappendaddr(&last
->in6p_socket
->so_rcv
,
224 (struct sockaddr
*)udp_in6
, n
, opts
, NULL
) == 0)
225 udpstat
.udps_fullsock
++;
227 sorwakeup(last
->in6p_socket
);
231 udp6_input(struct mbuf
**mp
, int *offp
, int proto
)
233 #pragma unused(proto)
234 struct mbuf
*m
= *mp
;
239 struct mbuf
*opts
= NULL
;
241 int plen
, ulen
, ret
= 0;
242 boolean_t cell
, wifi
, wired
;
243 struct sockaddr_in6 udp_in6
;
244 struct inpcbinfo
*pcbinfo
= &udbinfo
;
245 struct sockaddr_in6 fromsa
;
247 IP6_EXTHDR_CHECK(m
, off
, sizeof (struct udphdr
), return IPPROTO_DONE
);
249 /* Expect 32-bit aligned data pointer on strict-align platforms */
250 MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m
);
252 ifp
= m
->m_pkthdr
.rcvif
;
253 ip6
= mtod(m
, struct ip6_hdr
*);
254 cell
= IFNET_IS_CELLULAR(ifp
);
255 wifi
= (!cell
&& IFNET_IS_WIFI(ifp
));
256 wired
= (!wifi
&& IFNET_IS_WIRED(ifp
));
258 udpstat
.udps_ipackets
++;
260 plen
= ntohs(ip6
->ip6_plen
) - off
+ sizeof (*ip6
);
261 uh
= (struct udphdr
*)(void *)((caddr_t
)ip6
+ off
);
262 ulen
= ntohs((u_short
)uh
->uh_ulen
);
265 udpstat
.udps_badlen
++;
266 IF_UDP_STATINC(ifp
, badlength
);
270 /* destination port of 0 is illegal, based on RFC768. */
271 if (uh
->uh_dport
== 0) {
272 IF_UDP_STATINC(ifp
, port0
);
277 * Checksum extended UDP header and data.
279 if (udp6_input_checksum(m
, uh
, off
, ulen
))
283 * Construct sockaddr format source address.
285 init_sin6(&fromsa
, m
);
286 fromsa
.sin6_port
= uh
->uh_sport
;
288 if (IN6_IS_ADDR_MULTICAST(&ip6
->ip6_dst
)) {
289 int reuse_sock
= 0, mcast_delivered
= 0;
290 struct ip6_moptions
*imo
;
293 * Deliver a multicast datagram to all sockets
294 * for which the local and remote addresses and ports match
295 * those of the incoming datagram. This allows more than
296 * one process to receive multicasts on the same port.
297 * (This really ought to be done for unicast datagrams as
298 * well, but that would cause problems with existing
299 * applications that open both address-specific sockets and
300 * a wildcard socket listening to the same port -- they would
301 * end up receiving duplicates of every unicast datagram.
302 * Those applications open the multiple sockets to overcome an
303 * inadequacy of the UDP socket interface, but for backwards
304 * compatibility we avoid the problem here rather than
305 * fixing the interface. Maybe 4.5BSD will remedy this?)
309 * In a case that laddr should be set to the link-local
310 * address (this happens in RIPng), the multicast address
311 * specified in the received packet does not match with
312 * laddr. To cure this situation, the matching is relaxed
313 * if the receiving interface is the same as one specified
314 * in the socket and if the destination multicast address
315 * matches one of the multicast groups specified in the socket.
319 * Construct sockaddr format source address.
321 init_sin6(&udp_in6
, m
); /* general init */
322 udp_in6
.sin6_port
= uh
->uh_sport
;
324 * KAME note: usually we drop udphdr from mbuf here.
325 * We need udphdr for IPsec processing so we do that later.
329 * Locate pcb(s) for datagram.
330 * (Algorithm copied from raw_intr().)
332 lck_rw_lock_shared(pcbinfo
->ipi_lock
);
334 LIST_FOREACH(in6p
, &udb
, inp_list
) {
339 if ((in6p
->inp_vflag
& INP_IPV6
) == 0)
342 if (inp_restricted_recv(in6p
, ifp
))
345 if (in_pcb_checkstate(in6p
, WNT_ACQUIRE
, 0) ==
349 udp_lock(in6p
->in6p_socket
, 1, 0);
351 if (in_pcb_checkstate(in6p
, WNT_RELEASE
, 1) ==
353 udp_unlock(in6p
->in6p_socket
, 1, 0);
356 if (in6p
->in6p_lport
!= uh
->uh_dport
) {
357 udp_unlock(in6p
->in6p_socket
, 1, 0);
362 * Handle socket delivery policy for any-source
363 * and source-specific multicast. [RFC3678]
365 imo
= in6p
->in6p_moptions
;
366 if (imo
&& IN6_IS_ADDR_MULTICAST(&ip6
->ip6_dst
)) {
367 struct sockaddr_in6 mcaddr
;
371 bzero(&mcaddr
, sizeof (struct sockaddr_in6
));
372 mcaddr
.sin6_len
= sizeof (struct sockaddr_in6
);
373 mcaddr
.sin6_family
= AF_INET6
;
374 mcaddr
.sin6_addr
= ip6
->ip6_dst
;
376 blocked
= im6o_mc_filter(imo
, ifp
,
377 (struct sockaddr
*)&mcaddr
,
378 (struct sockaddr
*)&fromsa
);
380 if (blocked
!= MCAST_PASS
) {
381 udp_unlock(in6p
->in6p_socket
, 1, 0);
382 if (blocked
== MCAST_NOTSMEMBER
||
383 blocked
== MCAST_MUTED
)
384 udpstat
.udps_filtermcast
++;
388 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p
->in6p_faddr
) &&
389 (!IN6_ARE_ADDR_EQUAL(&in6p
->in6p_faddr
,
391 in6p
->in6p_fport
!= uh
->uh_sport
)) {
392 udp_unlock(in6p
->in6p_socket
, 1, 0);
396 reuse_sock
= in6p
->inp_socket
->so_options
&
397 (SO_REUSEPORT
| SO_REUSEADDR
);
401 if (!necp_socket_is_allowed_to_send_recv_v6(in6p
,
402 uh
->uh_dport
, uh
->uh_sport
, &ip6
->ip6_dst
,
403 &ip6
->ip6_src
, ifp
, NULL
, NULL
)) {
404 /* do not inject data to pcb */
410 struct mbuf
*n
= NULL
;
413 * m_copy(m, offset, ...) below.
414 * sbappendaddr() expects M_PKTHDR,
415 * and m_copy() will copy M_PKTHDR
416 * only if offset is 0.
419 n
= m_copy(m
, 0, M_COPYALL
);
420 udp6_append(in6p
, ip6
, &udp_in6
, m
,
421 off
+ sizeof (struct udphdr
), ifp
);
425 udp_unlock(in6p
->in6p_socket
, 1, 0);
428 * Don't look for additional matches if this one does
429 * not have either the SO_REUSEPORT or SO_REUSEADDR
430 * socket options set. This heuristic avoids searching
431 * through all pcbs in the common case of a non-shared
432 * port. It assumes that an application will never
433 * clear these options after setting them.
435 if (reuse_sock
== 0 || m
== NULL
)
439 * Expect 32-bit aligned data pointer on strict-align
442 MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m
);
445 * Recompute IP and UDP header pointers for new mbuf
447 ip6
= mtod(m
, struct ip6_hdr
*);
448 uh
= (struct udphdr
*)(void *)((caddr_t
)ip6
+ off
);
450 lck_rw_done(pcbinfo
->ipi_lock
);
452 if (mcast_delivered
== 0) {
454 * No matching pcb found; discard datagram.
455 * (No need to send an ICMP Port Unreachable
456 * for a broadcast or multicast datgram.)
458 udpstat
.udps_noport
++;
459 udpstat
.udps_noportmcast
++;
460 IF_UDP_STATINC(ifp
, port_unreach
);
464 /* free the extra copy of mbuf or skipped by NECP */
467 return (IPPROTO_DONE
);
472 * UDP to port 4500 with a payload where the first four bytes are
473 * not zero is a UDP encapsulated IPSec packet. Packets where
474 * the payload is one byte and that byte is 0xFF are NAT keepalive
475 * packets. Decapsulate the ESP packet and carry on with IPSec input
476 * or discard the NAT keep-alive.
478 if (ipsec_bypass
== 0 && (esp_udp_encap_port
& 0xFFFF) != 0 &&
479 uh
->uh_dport
== ntohs((u_short
)esp_udp_encap_port
)) {
480 int payload_len
= ulen
- sizeof (struct udphdr
) > 4 ? 4 :
481 ulen
- sizeof (struct udphdr
);
483 if (m
->m_len
< off
+ sizeof (struct udphdr
) + payload_len
) {
484 if ((m
= m_pullup(m
, off
+ sizeof (struct udphdr
) +
485 payload_len
)) == NULL
) {
486 udpstat
.udps_hdrops
++;
490 * Expect 32-bit aligned data pointer on strict-align
493 MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m
);
495 ip6
= mtod(m
, struct ip6_hdr
*);
496 uh
= (struct udphdr
*)(void *)((caddr_t
)ip6
+ off
);
498 /* Check for NAT keepalive packet */
499 if (payload_len
== 1 && *(u_int8_t
*)
500 ((caddr_t
)uh
+ sizeof (struct udphdr
)) == 0xFF) {
502 } else if (payload_len
== 4 && *(u_int32_t
*)(void *)
503 ((caddr_t
)uh
+ sizeof (struct udphdr
)) != 0) {
504 /* UDP encapsulated IPSec packet to pass through NAT */
505 /* preserve the udp header */
506 *offp
= off
+ sizeof (struct udphdr
);
507 return (esp6_input(mp
, offp
, IPPROTO_UDP
));
513 * Locate pcb for datagram.
515 in6p
= in6_pcblookup_hash(&udbinfo
, &ip6
->ip6_src
, uh
->uh_sport
,
516 &ip6
->ip6_dst
, uh
->uh_dport
, 1, m
->m_pkthdr
.rcvif
);
518 IF_UDP_STATINC(ifp
, port_unreach
);
520 if (udp_log_in_vain
) {
521 char buf
[INET6_ADDRSTRLEN
];
523 strlcpy(buf
, ip6_sprintf(&ip6
->ip6_dst
), sizeof (buf
));
524 if (udp_log_in_vain
< 3) {
525 log(LOG_INFO
, "Connection attempt to UDP "
526 "%s:%d from %s:%d\n", buf
,
528 ip6_sprintf(&ip6
->ip6_src
),
529 ntohs(uh
->uh_sport
));
530 } else if (!(m
->m_flags
& (M_BCAST
| M_MCAST
)) &&
531 !IN6_ARE_ADDR_EQUAL(&ip6
->ip6_dst
, &ip6
->ip6_src
)) {
532 log(LOG_INFO
, "Connection attempt "
533 "to UDP %s:%d from %s:%d\n", buf
,
535 ip6_sprintf(&ip6
->ip6_src
),
536 ntohs(uh
->uh_sport
));
539 udpstat
.udps_noport
++;
540 if (m
->m_flags
& M_MCAST
) {
541 printf("UDP6: M_MCAST is set in a unicast packet.\n");
542 udpstat
.udps_noportmcast
++;
543 IF_UDP_STATINC(ifp
, badmcast
);
546 icmp6_error(m
, ICMP6_DST_UNREACH
, ICMP6_DST_UNREACH_NOPORT
, 0);
547 return (IPPROTO_DONE
);
550 if (!necp_socket_is_allowed_to_send_recv_v6(in6p
, uh
->uh_dport
,
551 uh
->uh_sport
, &ip6
->ip6_dst
, &ip6
->ip6_src
, ifp
, NULL
, NULL
)) {
552 in_pcb_checkstate(in6p
, WNT_RELEASE
, 0);
553 IF_UDP_STATINC(ifp
, badipsec
);
559 * Construct sockaddr format source address.
560 * Stuff source address and datagram in user buffer.
562 udp_lock(in6p
->in6p_socket
, 1, 0);
564 if (in_pcb_checkstate(in6p
, WNT_RELEASE
, 1) == WNT_STOPUSING
) {
565 udp_unlock(in6p
->in6p_socket
, 1, 0);
566 IF_UDP_STATINC(ifp
, cleanup
);
570 init_sin6(&udp_in6
, m
); /* general init */
571 udp_in6
.sin6_port
= uh
->uh_sport
;
572 if ((in6p
->in6p_flags
& INP_CONTROLOPTS
) != 0 ||
573 (in6p
->in6p_socket
->so_options
& SO_TIMESTAMP
) != 0 ||
574 (in6p
->in6p_socket
->so_options
& SO_TIMESTAMP_MONOTONIC
) != 0) {
575 ret
= ip6_savecontrol(in6p
, m
, &opts
);
577 udp_unlock(in6p
->in6p_socket
, 1, 0);
581 m_adj(m
, off
+ sizeof (struct udphdr
));
583 INP_ADD_STAT(in6p
, cell
, wifi
, wired
, rxpackets
, 1);
584 INP_ADD_STAT(in6p
, cell
, wifi
, wired
, rxbytes
, m
->m_pkthdr
.len
);
586 so_recv_data_stat(in6p
->in6p_socket
, m
, 0);
587 if (sbappendaddr(&in6p
->in6p_socket
->so_rcv
,
588 (struct sockaddr
*)&udp_in6
, m
, opts
, NULL
) == 0) {
591 udpstat
.udps_fullsock
++;
592 udp_unlock(in6p
->in6p_socket
, 1, 0);
595 sorwakeup(in6p
->in6p_socket
);
596 udp_unlock(in6p
->in6p_socket
, 1, 0);
597 return (IPPROTO_DONE
);
603 return (IPPROTO_DONE
);
607 udp6_ctlinput(int cmd
, struct sockaddr
*sa
, void *d
)
613 struct ip6ctlparam
*ip6cp
= NULL
;
614 const struct sockaddr_in6
*sa6_src
= NULL
;
615 void (*notify
)(struct inpcb
*, int) = udp_notify
;
616 struct udp_portonly
{
621 if (sa
->sa_family
!= AF_INET6
||
622 sa
->sa_len
!= sizeof (struct sockaddr_in6
))
625 if ((unsigned)cmd
>= PRC_NCMDS
)
627 if (PRC_IS_REDIRECT(cmd
)) {
628 notify
= in6_rtchange
;
630 } else if (cmd
== PRC_HOSTDEAD
)
632 else if (inet6ctlerrmap
[cmd
] == 0)
635 /* if the parameter is from icmp6, decode it. */
637 ip6cp
= (struct ip6ctlparam
*)d
;
639 ip6
= ip6cp
->ip6c_ip6
;
640 off
= ip6cp
->ip6c_off
;
641 sa6_src
= ip6cp
->ip6c_src
;
650 * XXX: We assume that when IPV6 is non NULL,
651 * M and OFF are valid.
654 /* check if we can safely examine src and dst ports */
655 if (m
->m_pkthdr
.len
< off
+ sizeof (*uhp
))
658 bzero(&uh
, sizeof (uh
));
659 m_copydata(m
, off
, sizeof (*uhp
), (caddr_t
)&uh
);
661 (void) in6_pcbnotify(&udbinfo
, sa
, uh
.uh_dport
,
662 (struct sockaddr
*)ip6cp
->ip6c_src
, uh
.uh_sport
,
665 (void) in6_pcbnotify(&udbinfo
, sa
, 0,
666 (struct sockaddr
*)&sa6_src
, 0, cmd
, NULL
, notify
);
671 udp6_abort(struct socket
*so
)
677 panic("%s: so=%p null inp\n", __func__
, so
);
680 soisdisconnected(so
);
686 udp6_attach(struct socket
*so
, int proto
, struct proc
*p
)
688 #pragma unused(proto)
696 error
= in_pcballoc(so
, &udbinfo
, p
);
700 if (so
->so_snd
.sb_hiwat
== 0 || so
->so_rcv
.sb_hiwat
== 0) {
701 error
= soreserve(so
, udp_sendspace
, udp_recvspace
);
705 inp
= (struct inpcb
*)so
->so_pcb
;
706 inp
->inp_vflag
|= INP_IPV6
;
707 if (ip6_mapped_addr_on
)
708 inp
->inp_vflag
|= INP_IPV4
;
709 inp
->in6p_hops
= -1; /* use kernel default */
710 inp
->in6p_cksum
= -1; /* just to be sure */
713 * IPv4 TTL initialization is necessary for an IPv6 socket as well,
714 * because the socket may be bound to an IPv6 wildcard address,
715 * which may match an IPv4-mapped IPv6 address.
717 inp
->inp_ip_ttl
= ip_defttl
;
719 nstat_udp_new_pcb(inp
);
724 udp6_bind(struct socket
*so
, struct sockaddr
*nam
, struct proc
*p
)
733 inp
->inp_vflag
&= ~INP_IPV4
;
734 inp
->inp_vflag
|= INP_IPV6
;
735 if ((inp
->inp_flags
& IN6P_IPV6_V6ONLY
) == 0) {
736 struct sockaddr_in6
*sin6_p
;
738 sin6_p
= (struct sockaddr_in6
*)(void *)nam
;
740 if (IN6_IS_ADDR_UNSPECIFIED(&sin6_p
->sin6_addr
)) {
741 inp
->inp_vflag
|= INP_IPV4
;
742 } else if (IN6_IS_ADDR_V4MAPPED(&sin6_p
->sin6_addr
)) {
743 struct sockaddr_in sin
;
745 in6_sin6_2_sin(&sin
, sin6_p
);
746 inp
->inp_vflag
|= INP_IPV4
;
747 inp
->inp_vflag
&= ~INP_IPV6
;
748 error
= in_pcbbind(inp
, (struct sockaddr
*)&sin
, p
);
753 error
= in6_pcbbind(inp
, nam
, p
);
758 udp6_connect(struct socket
*so
, struct sockaddr
*nam
, struct proc
*p
)
762 #if defined(NECP) && defined(FLOW_DIVERT)
763 int should_use_flow_divert
= 0;
764 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
770 #if defined(NECP) && defined(FLOW_DIVERT)
771 should_use_flow_divert
= necp_socket_should_use_flow_divert(inp
);
772 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
774 if ((inp
->inp_flags
& IN6P_IPV6_V6ONLY
) == 0) {
775 struct sockaddr_in6
*sin6_p
;
777 sin6_p
= (struct sockaddr_in6
*)(void *)nam
;
778 if (IN6_IS_ADDR_V4MAPPED(&sin6_p
->sin6_addr
)) {
779 struct sockaddr_in sin
;
781 if (inp
->inp_faddr
.s_addr
!= INADDR_ANY
)
783 in6_sin6_2_sin(&sin
, sin6_p
);
784 #if defined(NECP) && defined(FLOW_DIVERT)
785 if (should_use_flow_divert
) {
788 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
789 error
= in_pcbconnect(inp
, (struct sockaddr
*)&sin
,
790 p
, IFSCOPE_NONE
, NULL
);
792 inp
->inp_vflag
|= INP_IPV4
;
793 inp
->inp_vflag
&= ~INP_IPV6
;
800 if (!IN6_IS_ADDR_UNSPECIFIED(&inp
->in6p_faddr
))
803 #if defined(NECP) && defined(FLOW_DIVERT)
805 if (should_use_flow_divert
) {
806 uint32_t fd_ctl_unit
= necp_socket_get_flow_divert_control_unit(inp
);
807 if (fd_ctl_unit
> 0) {
808 error
= flow_divert_pcb_init(so
, fd_ctl_unit
);
810 error
= flow_divert_connect_out(so
, nam
, p
);
817 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
819 error
= in6_pcbconnect(inp
, nam
, p
);
821 /* should be non mapped addr */
822 if (ip6_mapped_addr_on
||
823 (inp
->inp_flags
& IN6P_IPV6_V6ONLY
) == 0) {
824 inp
->inp_vflag
&= ~INP_IPV4
;
825 inp
->inp_vflag
|= INP_IPV6
;
828 if (inp
->inp_flowhash
== 0)
829 inp
->inp_flowhash
= inp_calc_flowhash(inp
);
830 /* update flowinfo - RFC 6437 */
831 if (inp
->inp_flow
== 0 &&
832 inp
->in6p_flags
& IN6P_AUTOFLOWLABEL
) {
833 inp
->inp_flow
&= ~IPV6_FLOWLABEL_MASK
;
835 (htonl(inp
->inp_flowhash
) & IPV6_FLOWLABEL_MASK
);
842 udp6_connectx(struct socket
*so
, struct sockaddr_list
**src_sl
,
843 struct sockaddr_list
**dst_sl
, struct proc
*p
, uint32_t ifscope
,
844 sae_associd_t aid
, sae_connid_t
*pcid
, uint32_t flags
, void *arg
,
845 uint32_t arglen
, struct uio
*uio
, user_ssize_t
*bytes_written
)
847 return (udp_connectx_common(so
, AF_INET6
, src_sl
, dst_sl
,
848 p
, ifscope
, aid
, pcid
, flags
, arg
, arglen
, uio
, bytes_written
));
852 udp6_detach(struct socket
*so
)
864 udp6_disconnect(struct socket
*so
)
871 || (necp_socket_should_use_flow_divert(inp
))
874 return (inp
== NULL
? EINVAL
: EPROTOTYPE
);
876 if (inp
->inp_vflag
& INP_IPV4
) {
877 struct pr_usrreqs
*pru
;
879 pru
= ip_protox
[IPPROTO_UDP
]->pr_usrreqs
;
880 return ((*pru
->pru_disconnect
)(so
));
883 if (IN6_IS_ADDR_UNSPECIFIED(&inp
->in6p_faddr
))
886 in6_pcbdisconnect(inp
);
888 /* reset flow-controlled state, just in case */
889 inp_reset_fc_state(inp
);
891 inp
->in6p_laddr
= in6addr_any
;
892 inp
->in6p_last_outifp
= NULL
;
893 so
->so_state
&= ~SS_ISCONNECTED
; /* XXX */
898 udp6_disconnectx(struct socket
*so
, sae_associd_t aid
, sae_connid_t cid
)
901 if (aid
!= SAE_ASSOCID_ANY
&& aid
!= SAE_ASSOCID_ALL
)
904 return (udp6_disconnect(so
));
908 udp6_send(struct socket
*so
, int flags
, struct mbuf
*m
, struct sockaddr
*addr
,
909 struct mbuf
*control
, struct proc
*p
)
913 #if defined(NECP) && defined(FLOW_DIVERT)
914 int should_use_flow_divert
= 0;
915 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
923 #if defined(NECP) && defined(FLOW_DIVERT)
924 should_use_flow_divert
= necp_socket_should_use_flow_divert(inp
);
925 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
928 if (addr
->sa_len
!= sizeof (struct sockaddr_in6
)) {
932 if (addr
->sa_family
!= AF_INET6
) {
933 error
= EAFNOSUPPORT
;
938 if (ip6_mapped_addr_on
|| (inp
->inp_flags
& IN6P_IPV6_V6ONLY
) == 0) {
940 struct sockaddr_in6
*sin6
= NULL
;
943 hasv4addr
= (inp
->inp_vflag
& INP_IPV4
);
945 sin6
= (struct sockaddr_in6
*)(void *)addr
;
947 IN6_IS_ADDR_V4MAPPED(&sin6
->sin6_addr
) ? 1 : 0;
950 struct pr_usrreqs
*pru
;
953 in6_sin6_2_sin_in_sock(addr
);
954 #if defined(NECP) && defined(FLOW_DIVERT)
955 if (should_use_flow_divert
) {
958 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
959 pru
= ip_protox
[IPPROTO_UDP
]->pr_usrreqs
;
960 error
= ((*pru
->pru_send
)(so
, flags
, m
, addr
,
962 /* addr will just be freed in sendit(). */
967 #if defined(NECP) && defined(FLOW_DIVERT)
969 if (should_use_flow_divert
) {
970 /* Implicit connect */
971 return (flow_divert_implicit_data_out(so
, flags
, m
, addr
, control
, p
));
973 #endif /* defined(NECP) && defined(FLOW_DIVERT) */
975 return (udp6_output(inp
, m
, addr
, control
, p
));
989 * Checksum extended UDP header and data.
992 udp6_input_checksum(struct mbuf
*m
, struct udphdr
*uh
, int off
, int ulen
)
994 struct ifnet
*ifp
= m
->m_pkthdr
.rcvif
;
995 struct ip6_hdr
*ip6
= mtod(m
, struct ip6_hdr
*);
997 if (!(m
->m_pkthdr
.csum_flags
& CSUM_DATA_VALID
) &&
999 /* UDP/IPv6 checksum is mandatory (RFC2460) */
1002 * If checksum was already validated, ignore this check.
1003 * This is necessary for transport-mode ESP, which may be
1004 * getting UDP payloads without checksums when the network
1007 udpstat
.udps_nosum
++;
1011 if ((hwcksum_rx
|| (ifp
->if_flags
& IFF_LOOPBACK
) ||
1012 (m
->m_pkthdr
.pkt_flags
& PKTF_LOOP
)) &&
1013 (m
->m_pkthdr
.csum_flags
& CSUM_DATA_VALID
)) {
1014 if (m
->m_pkthdr
.csum_flags
& CSUM_PSEUDO_HDR
) {
1015 uh
->uh_sum
= m
->m_pkthdr
.csum_rx_val
;
1017 uint16_t sum
= m
->m_pkthdr
.csum_rx_val
;
1018 uint16_t start
= m
->m_pkthdr
.csum_rx_start
;
1021 * Perform 1's complement adjustment of octets
1022 * that got included/excluded in the hardware-
1023 * calculated checksum value.
1025 if ((m
->m_pkthdr
.csum_flags
& CSUM_PARTIAL
) &&
1029 if (IN6_IS_SCOPE_EMBED(&ip6
->ip6_src
)) {
1030 s
= ip6
->ip6_src
.s6_addr16
[1];
1031 ip6
->ip6_src
.s6_addr16
[1] = 0 ;
1033 if (IN6_IS_SCOPE_EMBED(&ip6
->ip6_dst
)) {
1034 d
= ip6
->ip6_dst
.s6_addr16
[1];
1035 ip6
->ip6_dst
.s6_addr16
[1] = 0;
1038 /* callee folds in sum */
1039 sum
= m_adj_sum16(m
, start
, off
, sum
);
1041 if (IN6_IS_SCOPE_EMBED(&ip6
->ip6_src
))
1042 ip6
->ip6_src
.s6_addr16
[1] = s
;
1043 if (IN6_IS_SCOPE_EMBED(&ip6
->ip6_dst
))
1044 ip6
->ip6_dst
.s6_addr16
[1] = d
;
1047 uh
->uh_sum
= in6_pseudo(&ip6
->ip6_src
, &ip6
->ip6_dst
,
1048 sum
+ htonl(ulen
+ IPPROTO_UDP
));
1050 uh
->uh_sum
^= 0xffff;
1052 udp_in6_cksum_stats(ulen
);
1053 uh
->uh_sum
= in6_cksum(m
, IPPROTO_UDP
, off
, ulen
);
1056 if (uh
->uh_sum
!= 0) {
1058 udpstat
.udps_badsum
++;
1059 IF_UDP_STATINC(ifp
, badchksum
);