]> git.saurik.com Git - apple/xnu.git/blob - bsd/netinet/udp_usrreq.c
projects / apple / xnu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
xnu-3248.50.21.tar.gz
[apple/xnu.git] / bsd / netinet / udp_usrreq.c
1 /*
2 * Copyright (c) 2000-2015 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
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.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
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.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28 /*
29 * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
30 * The Regents of the University of California. All rights reserved.
31 *
32 * Redistribution and use in source and binary forms, with or without
33 * modification, are permitted provided that the following conditions
34 * are met:
35 * 1. Redistributions of source code must retain the above copyright
36 * notice, this list of conditions and the following disclaimer.
37 * 2. Redistributions in binary form must reproduce the above copyright
38 * notice, this list of conditions and the following disclaimer in the
39 * documentation and/or other materials provided with the distribution.
40 * 3. All advertising materials mentioning features or use of this software
41 * must display the following acknowledgement:
42 * This product includes software developed by the University of
43 * California, Berkeley and its contributors.
44 * 4. Neither the name of the University 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.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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
58 * SUCH DAMAGE.
59 *
60 * @(#)udp_usrreq.c 8.6 (Berkeley) 5/23/95
61 * $FreeBSD: src/sys/netinet/udp_usrreq.c,v 1.64.2.13 2001/08/08 18:59:54 ghelmer Exp $
62 */
63
64 #include <sys/param.h>
65 #include <sys/systm.h>
66 #include <sys/kernel.h>
67 #include <sys/malloc.h>
68 #include <sys/mbuf.h>
69 #include <sys/domain.h>
70 #include <sys/protosw.h>
71 #include <sys/socket.h>
72 #include <sys/socketvar.h>
73 #include <sys/sysctl.h>
74 #include <sys/syslog.h>
75 #include <sys/mcache.h>
76 #include <net/ntstat.h>
77
78 #include <kern/zalloc.h>
79 #include <mach/boolean.h>
80
81 #include <net/if.h>
82 #include <net/if_types.h>
83 #include <net/route.h>
84 #include <net/dlil.h>
85
86 #include <netinet/in.h>
87 #include <netinet/in_systm.h>
88 #include <netinet/ip.h>
89 #if INET6
90 #include <netinet/ip6.h>
91 #endif /* INET6 */
92 #include <netinet/in_pcb.h>
93 #include <netinet/in_var.h>
94 #include <netinet/ip_var.h>
95 #if INET6
96 #include <netinet6/in6_pcb.h>
97 #include <netinet6/ip6_var.h>
98 #include <netinet6/udp6_var.h>
99 #endif /* INET6 */
100 #include <netinet/ip_icmp.h>
101 #include <netinet/icmp_var.h>
102 #include <netinet/udp.h>
103 #include <netinet/udp_var.h>
104 #include <sys/kdebug.h>
105
106 #if IPSEC
107 #include <netinet6/ipsec.h>
108 #include <netinet6/esp.h>
109 extern int ipsec_bypass;
110 extern int esp_udp_encap_port;
111 #endif /* IPSEC */
112
113 #if NECP
114 #include <net/necp.h>
115 #endif /* NECP */
116
117 #if FLOW_DIVERT
118 #include <netinet/flow_divert.h>
119 #endif /* FLOW_DIVERT */
120
121 #define DBG_LAYER_IN_BEG NETDBG_CODE(DBG_NETUDP, 0)
122 #define DBG_LAYER_IN_END NETDBG_CODE(DBG_NETUDP, 2)
123 #define DBG_LAYER_OUT_BEG NETDBG_CODE(DBG_NETUDP, 1)
124 #define DBG_LAYER_OUT_END NETDBG_CODE(DBG_NETUDP, 3)
125 #define DBG_FNC_UDP_INPUT NETDBG_CODE(DBG_NETUDP, (5 << 8))
126 #define DBG_FNC_UDP_OUTPUT NETDBG_CODE(DBG_NETUDP, (6 << 8) | 1)
127
128 /*
129 * UDP protocol implementation.
130 * Per RFC 768, August, 1980.
131 */
132 #ifndef COMPAT_42
133 static int udpcksum = 1;
134 #else
135 static int udpcksum = 0; /* XXX */
136 #endif
137 SYSCTL_INT(_net_inet_udp, UDPCTL_CHECKSUM, checksum,
138 CTLFLAG_RW | CTLFLAG_LOCKED, &udpcksum, 0, "");
139
140 int udp_log_in_vain = 0;
141 SYSCTL_INT(_net_inet_udp, OID_AUTO, log_in_vain, CTLFLAG_RW | CTLFLAG_LOCKED,
142 &udp_log_in_vain, 0, "Log all incoming UDP packets");
143
144 static int blackhole = 0;
145 SYSCTL_INT(_net_inet_udp, OID_AUTO, blackhole, CTLFLAG_RW | CTLFLAG_LOCKED,
146 &blackhole, 0, "Do not send port unreachables for refused connects");
147
148 struct inpcbhead udb; /* from udp_var.h */
149 #define udb6 udb /* for KAME src sync over BSD*'s */
150 struct inpcbinfo udbinfo;
151
152 #ifndef UDBHASHSIZE
153 #define UDBHASHSIZE 16
154 #endif
155
156 /* Garbage collection performed during most recent udp_gc() run */
157 static boolean_t udp_gc_done = FALSE;
158
159 #if IPFIREWALL
160 extern int fw_verbose;
161 extern void ipfwsyslog( int level, const char *format,...);
162 extern void ipfw_stealth_stats_incr_udp(void);
163
164 /* Apple logging, log to ipfw.log */
165 #define log_in_vain_log(a) { \
166 if ((udp_log_in_vain == 3) && (fw_verbose == 2)) { \
167 ipfwsyslog a; \
168 } else if ((udp_log_in_vain == 4) && (fw_verbose == 2)) { \
169 ipfw_stealth_stats_incr_udp(); \
170 } else { \
171 log a; \
172 } \
173 }
174 #else /* !IPFIREWALL */
175 #define log_in_vain_log( a ) { log a; }
176 #endif /* !IPFIREWALL */
177
178 static int udp_getstat SYSCTL_HANDLER_ARGS;
179 struct udpstat udpstat; /* from udp_var.h */
180 SYSCTL_PROC(_net_inet_udp, UDPCTL_STATS, stats,
181 CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_LOCKED,
182 0, 0, udp_getstat, "S,udpstat",
183 "UDP statistics (struct udpstat, netinet/udp_var.h)");
184
185 SYSCTL_INT(_net_inet_udp, OID_AUTO, pcbcount,
186 CTLFLAG_RD | CTLFLAG_LOCKED, &udbinfo.ipi_count, 0,
187 "Number of active PCBs");
188
189 __private_extern__ int udp_use_randomport = 1;
190 SYSCTL_INT(_net_inet_udp, OID_AUTO, randomize_ports,
191 CTLFLAG_RW | CTLFLAG_LOCKED, &udp_use_randomport, 0,
192 "Randomize UDP port numbers");
193
194 #if INET6
195 struct udp_in6 {
196 struct sockaddr_in6 uin6_sin;
197 u_char uin6_init_done : 1;
198 };
199 struct udp_ip6 {
200 struct ip6_hdr uip6_ip6;
201 u_char uip6_init_done : 1;
202 };
203
204 static int udp_abort(struct socket *);
205 static int udp_attach(struct socket *, int, struct proc *);
206 static int udp_bind(struct socket *, struct sockaddr *, struct proc *);
207 static int udp_connect(struct socket *, struct sockaddr *, struct proc *);
208 static int udp_connectx(struct socket *, struct sockaddr_list **,
209 struct sockaddr_list **, struct proc *, uint32_t, sae_associd_t,
210 sae_connid_t *, uint32_t, void *, uint32_t, struct uio *, user_ssize_t *);
211 static int udp_detach(struct socket *);
212 static int udp_disconnect(struct socket *);
213 static int udp_disconnectx(struct socket *, sae_associd_t, sae_connid_t);
214 static int udp_send(struct socket *, int, struct mbuf *, struct sockaddr *,
215 struct mbuf *, struct proc *);
216 static void udp_append(struct inpcb *, struct ip *, struct mbuf *, int,
217 struct sockaddr_in *, struct udp_in6 *, struct udp_ip6 *, struct ifnet *);
218 #else /* !INET6 */
219 static void udp_append(struct inpcb *, struct ip *, struct mbuf *, int,
220 struct sockaddr_in *, struct ifnet *);
221 #endif /* !INET6 */
222 static int udp_input_checksum(struct mbuf *, struct udphdr *, int, int);
223 static int udp_output(struct inpcb *, struct mbuf *, struct sockaddr *,
224 struct mbuf *, struct proc *);
225 static void ip_2_ip6_hdr(struct ip6_hdr *ip6, struct ip *ip);
226 static void udp_gc(struct inpcbinfo *);
227
228 struct pr_usrreqs udp_usrreqs = {
229 .pru_abort = udp_abort,
230 .pru_attach = udp_attach,
231 .pru_bind = udp_bind,
232 .pru_connect = udp_connect,
233 .pru_connectx = udp_connectx,
234 .pru_control = in_control,
235 .pru_detach = udp_detach,
236 .pru_disconnect = udp_disconnect,
237 .pru_disconnectx = udp_disconnectx,
238 .pru_peeraddr = in_getpeeraddr,
239 .pru_send = udp_send,
240 .pru_shutdown = udp_shutdown,
241 .pru_sockaddr = in_getsockaddr,
242 .pru_sosend = sosend,
243 .pru_soreceive = soreceive,
244 .pru_soreceive_list = soreceive_list,
245 };
246
247 void
248 udp_init(struct protosw *pp, struct domain *dp)
249 {
250 #pragma unused(dp)
251 static int udp_initialized = 0;
252 vm_size_t str_size;
253 struct inpcbinfo *pcbinfo;
254
255 VERIFY((pp->pr_flags & (PR_INITIALIZED|PR_ATTACHED)) == PR_ATTACHED);
256
257 if (udp_initialized)
258 return;
259 udp_initialized = 1;
260
261 LIST_INIT(&udb);
262 udbinfo.ipi_listhead = &udb;
263 udbinfo.ipi_hashbase = hashinit(UDBHASHSIZE, M_PCB,
264 &udbinfo.ipi_hashmask);
265 udbinfo.ipi_porthashbase = hashinit(UDBHASHSIZE, M_PCB,
266 &udbinfo.ipi_porthashmask);
267 str_size = (vm_size_t) sizeof (struct inpcb);
268 udbinfo.ipi_zone = zinit(str_size, 80000*str_size, 8192, "udpcb");
269
270 pcbinfo = &udbinfo;
271 /*
272 * allocate lock group attribute and group for udp pcb mutexes
273 */
274 pcbinfo->ipi_lock_grp_attr = lck_grp_attr_alloc_init();
275 pcbinfo->ipi_lock_grp = lck_grp_alloc_init("udppcb",
276 pcbinfo->ipi_lock_grp_attr);
277 pcbinfo->ipi_lock_attr = lck_attr_alloc_init();
278 if ((pcbinfo->ipi_lock = lck_rw_alloc_init(pcbinfo->ipi_lock_grp,
279 pcbinfo->ipi_lock_attr)) == NULL) {
280 panic("%s: unable to allocate PCB lock\n", __func__);
281 /* NOTREACHED */
282 }
283
284 udbinfo.ipi_gc = udp_gc;
285 in_pcbinfo_attach(&udbinfo);
286 }
287
288 void
289 udp_input(struct mbuf *m, int iphlen)
290 {
291 struct ip *ip;
292 struct udphdr *uh;
293 struct inpcb *inp;
294 struct mbuf *opts = NULL;
295 int len, isbroadcast;
296 struct ip save_ip;
297 struct sockaddr *append_sa;
298 struct inpcbinfo *pcbinfo = &udbinfo;
299 struct sockaddr_in udp_in;
300 struct ip_moptions *imo = NULL;
301 int foundmembership = 0, ret = 0;
302 #if INET6
303 struct udp_in6 udp_in6;
304 struct udp_ip6 udp_ip6;
305 #endif /* INET6 */
306 struct ifnet *ifp = m->m_pkthdr.rcvif;
307 boolean_t cell = IFNET_IS_CELLULAR(ifp);
308 boolean_t wifi = (!cell && IFNET_IS_WIFI(ifp));
309 boolean_t wired = (!wifi && IFNET_IS_WIRED(ifp));
310
311 bzero(&udp_in, sizeof (udp_in));
312 udp_in.sin_len = sizeof (struct sockaddr_in);
313 udp_in.sin_family = AF_INET;
314 #if INET6
315 bzero(&udp_in6, sizeof (udp_in6));
316 udp_in6.uin6_sin.sin6_len = sizeof (struct sockaddr_in6);
317 udp_in6.uin6_sin.sin6_family = AF_INET6;
318 #endif /* INET6 */
319
320 udpstat.udps_ipackets++;
321
322 KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_START, 0,0,0,0,0);
323
324 /* Expect 32-bit aligned data pointer on strict-align platforms */
325 MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m);
326
327 /*
328 * Strip IP options, if any; should skip this,
329 * make available to user, and use on returned packets,
330 * but we don't yet have a way to check the checksum
331 * with options still present.
332 */
333 if (iphlen > sizeof (struct ip)) {
334 ip_stripoptions(m, (struct mbuf *)0);
335 iphlen = sizeof (struct ip);
336 }
337
338 /*
339 * Get IP and UDP header together in first mbuf.
340 */
341 ip = mtod(m, struct ip *);
342 if (m->m_len < iphlen + sizeof (struct udphdr)) {
343 m = m_pullup(m, iphlen + sizeof (struct udphdr));
344 if (m == NULL) {
345 udpstat.udps_hdrops++;
346 KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END,
347 0,0,0,0,0);
348 return;
349 }
350 ip = mtod(m, struct ip *);
351 }
352 uh = (struct udphdr *)(void *)((caddr_t)ip + iphlen);
353
354 /* destination port of 0 is illegal, based on RFC768. */
355 if (uh->uh_dport == 0) {
356 IF_UDP_STATINC(ifp, port0);
357 goto bad;
358 }
359
360 KERNEL_DEBUG(DBG_LAYER_IN_BEG, uh->uh_dport, uh->uh_sport,
361 ip->ip_src.s_addr, ip->ip_dst.s_addr, uh->uh_ulen);
362
363 /*
364 * Make mbuf data length reflect UDP length.
365 * If not enough data to reflect UDP length, drop.
366 */
367 len = ntohs((u_short)uh->uh_ulen);
368 if (ip->ip_len != len) {
369 if (len > ip->ip_len || len < sizeof (struct udphdr)) {
370 udpstat.udps_badlen++;
371 IF_UDP_STATINC(ifp, badlength);
372 goto bad;
373 }
374 m_adj(m, len - ip->ip_len);
375 /* ip->ip_len = len; */
376 }
377 /*
378 * Save a copy of the IP header in case we want restore it
379 * for sending an ICMP error message in response.
380 */
381 save_ip = *ip;
382
383 /*
384 * Checksum extended UDP header and data.
385 */
386 if (udp_input_checksum(m, uh, iphlen, len))
387 goto bad;
388
389 isbroadcast = in_broadcast(ip->ip_dst, ifp);
390
391 if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) || isbroadcast) {
392 int reuse_sock = 0, mcast_delivered = 0;
393
394 lck_rw_lock_shared(pcbinfo->ipi_lock);
395 /*
396 * Deliver a multicast or broadcast datagram to *all* sockets
397 * for which the local and remote addresses and ports match
398 * those of the incoming datagram. This allows more than
399 * one process to receive multi/broadcasts on the same port.
400 * (This really ought to be done for unicast datagrams as
401 * well, but that would cause problems with existing
402 * applications that open both address-specific sockets and
403 * a wildcard socket listening to the same port -- they would
404 * end up receiving duplicates of every unicast datagram.
405 * Those applications open the multiple sockets to overcome an
406 * inadequacy of the UDP socket interface, but for backwards
407 * compatibility we avoid the problem here rather than
408 * fixing the interface. Maybe 4.5BSD will remedy this?)
409 */
410
411 /*
412 * Construct sockaddr format source address.
413 */
414 udp_in.sin_port = uh->uh_sport;
415 udp_in.sin_addr = ip->ip_src;
416 /*
417 * Locate pcb(s) for datagram.
418 * (Algorithm copied from raw_intr().)
419 */
420 #if INET6
421 udp_in6.uin6_init_done = udp_ip6.uip6_init_done = 0;
422 #endif /* INET6 */
423 LIST_FOREACH(inp, &udb, inp_list) {
424 #if IPSEC
425 int skipit;
426 #endif /* IPSEC */
427
428 if (inp->inp_socket == NULL)
429 continue;
430 if (inp != sotoinpcb(inp->inp_socket)) {
431 panic("%s: bad so back ptr inp=%p\n",
432 __func__, inp);
433 /* NOTREACHED */
434 }
435 #if INET6
436 if ((inp->inp_vflag & INP_IPV4) == 0)
437 continue;
438 #endif /* INET6 */
439 if (inp_restricted_recv(inp, ifp))
440 continue;
441
442 if ((inp->inp_moptions == NULL) &&
443 (ntohl(ip->ip_dst.s_addr) !=
444 INADDR_ALLHOSTS_GROUP) && (isbroadcast == 0))
445 continue;
446
447 if (in_pcb_checkstate(inp, WNT_ACQUIRE, 0) ==
448 WNT_STOPUSING)
449 continue;
450
451 udp_lock(inp->inp_socket, 1, 0);
452
453 if (in_pcb_checkstate(inp, WNT_RELEASE, 1) ==
454 WNT_STOPUSING) {
455 udp_unlock(inp->inp_socket, 1, 0);
456 continue;
457 }
458
459 if (inp->inp_lport != uh->uh_dport) {
460 udp_unlock(inp->inp_socket, 1, 0);
461 continue;
462 }
463 if (inp->inp_laddr.s_addr != INADDR_ANY) {
464 if (inp->inp_laddr.s_addr !=
465 ip->ip_dst.s_addr) {
466 udp_unlock(inp->inp_socket, 1, 0);
467 continue;
468 }
469 }
470 if (inp->inp_faddr.s_addr != INADDR_ANY) {
471 if (inp->inp_faddr.s_addr !=
472 ip->ip_src.s_addr ||
473 inp->inp_fport != uh->uh_sport) {
474 udp_unlock(inp->inp_socket, 1, 0);
475 continue;
476 }
477 }
478
479 if (isbroadcast == 0 && (ntohl(ip->ip_dst.s_addr) !=
480 INADDR_ALLHOSTS_GROUP)) {
481 struct sockaddr_in group;
482 int blocked;
483
484 if ((imo = inp->inp_moptions) == NULL) {
485 udp_unlock(inp->inp_socket, 1, 0);
486 continue;
487 }
488 IMO_LOCK(imo);
489
490 bzero(&group, sizeof (struct sockaddr_in));
491 group.sin_len = sizeof (struct sockaddr_in);
492 group.sin_family = AF_INET;
493 group.sin_addr = ip->ip_dst;
494
495 blocked = imo_multi_filter(imo, ifp,
496 (struct sockaddr *)&group,
497 (struct sockaddr *)&udp_in);
498 if (blocked == MCAST_PASS)
499 foundmembership = 1;
500
501 IMO_UNLOCK(imo);
502 if (!foundmembership) {
503 udp_unlock(inp->inp_socket, 1, 0);
504 if (blocked == MCAST_NOTSMEMBER ||
505 blocked == MCAST_MUTED)
506 udpstat.udps_filtermcast++;
507 continue;
508 }
509 foundmembership = 0;
510 }
511
512 reuse_sock = (inp->inp_socket->so_options &
513 (SO_REUSEPORT|SO_REUSEADDR));
514
515 #if NECP
516 skipit = 0;
517 if (!necp_socket_is_allowed_to_send_recv_v4(inp,
518 uh->uh_dport, uh->uh_sport, &ip->ip_dst,
519 &ip->ip_src, ifp, NULL, NULL)) {
520 /* do not inject data to pcb */
521 skipit = 1;
522 }
523 if (skipit == 0)
524 #endif /* NECP */
525 {
526 struct mbuf *n = NULL;
527
528 if (reuse_sock)
529 n = m_copy(m, 0, M_COPYALL);
530 #if INET6
531 udp_append(inp, ip, m,
532 iphlen + sizeof (struct udphdr),
533 &udp_in, &udp_in6, &udp_ip6, ifp);
534 #else /* !INET6 */
535 udp_append(inp, ip, m,
536 iphlen + sizeof (struct udphdr),
537 &udp_in, ifp);
538 #endif /* !INET6 */
539 mcast_delivered++;
540
541 m = n;
542 }
543 udp_unlock(inp->inp_socket, 1, 0);
544
545 /*
546 * Don't look for additional matches if this one does
547 * not have either the SO_REUSEPORT or SO_REUSEADDR
548 * socket options set. This heuristic avoids searching
549 * through all pcbs in the common case of a non-shared
550 * port. It assumes that an application will never
551 * clear these options after setting them.
552 */
553 if (reuse_sock == 0 || m == NULL)
554 break;
555
556 /*
557 * Expect 32-bit aligned data pointer on strict-align
558 * platforms.
559 */
560 MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m);
561 /*
562 * Recompute IP and UDP header pointers for new mbuf
563 */
564 ip = mtod(m, struct ip *);
565 uh = (struct udphdr *)(void *)((caddr_t)ip + iphlen);
566 }
567 lck_rw_done(pcbinfo->ipi_lock);
568
569 if (mcast_delivered == 0) {
570 /*
571 * No matching pcb found; discard datagram.
572 * (No need to send an ICMP Port Unreachable
573 * for a broadcast or multicast datgram.)
574 */
575 udpstat.udps_noportbcast++;
576 IF_UDP_STATINC(ifp, port_unreach);
577 goto bad;
578 }
579
580 /* free the extra copy of mbuf or skipped by IPSec */
581 if (m != NULL)
582 m_freem(m);
583 KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END, 0,0,0,0,0);
584 return;
585 }
586
587 #if IPSEC
588 /*
589 * UDP to port 4500 with a payload where the first four bytes are
590 * not zero is a UDP encapsulated IPSec packet. Packets where
591 * the payload is one byte and that byte is 0xFF are NAT keepalive
592 * packets. Decapsulate the ESP packet and carry on with IPSec input
593 * or discard the NAT keep-alive.
594 */
595 if (ipsec_bypass == 0 && (esp_udp_encap_port & 0xFFFF) != 0 &&
596 uh->uh_dport == ntohs((u_short)esp_udp_encap_port)) {
597 int payload_len = len - sizeof (struct udphdr) > 4 ? 4 :
598 len - sizeof (struct udphdr);
599
600 if (m->m_len < iphlen + sizeof (struct udphdr) + payload_len) {
601 if ((m = m_pullup(m, iphlen + sizeof (struct udphdr) +
602 payload_len)) == NULL) {
603 udpstat.udps_hdrops++;
604 KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END,
605 0,0,0,0,0);
606 return;
607 }
608 /*
609 * Expect 32-bit aligned data pointer on strict-align
610 * platforms.
611 */
612 MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m);
613
614 ip = mtod(m, struct ip *);
615 uh = (struct udphdr *)(void *)((caddr_t)ip + iphlen);
616 }
617 /* Check for NAT keepalive packet */
618 if (payload_len == 1 && *(u_int8_t*)
619 ((caddr_t)uh + sizeof (struct udphdr)) == 0xFF) {
620 m_freem(m);
621 KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END,
622 0,0,0,0,0);
623 return;
624 } else if (payload_len == 4 && *(u_int32_t*)(void *)
625 ((caddr_t)uh + sizeof (struct udphdr)) != 0) {
626 /* UDP encapsulated IPSec packet to pass through NAT */
627 KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END,
628 0,0,0,0,0);
629 /* preserve the udp header */
630 esp4_input(m, iphlen + sizeof (struct udphdr));
631 return;
632 }
633 }
634 #endif /* IPSEC */
635
636 /*
637 * Locate pcb for datagram.
638 */
639 inp = in_pcblookup_hash(&udbinfo, ip->ip_src, uh->uh_sport,
640 ip->ip_dst, uh->uh_dport, 1, ifp);
641 if (inp == NULL) {
642 IF_UDP_STATINC(ifp, port_unreach);
643
644 if (udp_log_in_vain) {
645 char buf[MAX_IPv4_STR_LEN];
646 char buf2[MAX_IPv4_STR_LEN];
647
648 /* check src and dst address */
649 if (udp_log_in_vain < 3) {
650 log(LOG_INFO, "Connection attempt to "
651 "UDP %s:%d from %s:%d\n", inet_ntop(AF_INET,
652 &ip->ip_dst, buf, sizeof (buf)),
653 ntohs(uh->uh_dport), inet_ntop(AF_INET,
654 &ip->ip_src, buf2, sizeof (buf2)),
655 ntohs(uh->uh_sport));
656 } else if (!(m->m_flags & (M_BCAST | M_MCAST)) &&
657 ip->ip_dst.s_addr != ip->ip_src.s_addr) {
658 log_in_vain_log((LOG_INFO,
659 "Stealth Mode connection attempt to "
660 "UDP %s:%d from %s:%d\n", inet_ntop(AF_INET,
661 &ip->ip_dst, buf, sizeof (buf)),
662 ntohs(uh->uh_dport), inet_ntop(AF_INET,
663 &ip->ip_src, buf2, sizeof (buf2)),
664 ntohs(uh->uh_sport)))
665 }
666 }
667 udpstat.udps_noport++;
668 if (m->m_flags & (M_BCAST | M_MCAST)) {
669 udpstat.udps_noportbcast++;
670 goto bad;
671 }
672 #if ICMP_BANDLIM
673 if (badport_bandlim(BANDLIM_ICMP_UNREACH) < 0)
674 goto bad;
675 #endif /* ICMP_BANDLIM */
676 if (blackhole)
677 if (ifp && ifp->if_type != IFT_LOOP)
678 goto bad;
679 *ip = save_ip;
680 ip->ip_len += iphlen;
681 icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_PORT, 0, 0);
682 KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END, 0,0,0,0,0);
683 return;
684 }
685 udp_lock(inp->inp_socket, 1, 0);
686
687 if (in_pcb_checkstate(inp, WNT_RELEASE, 1) == WNT_STOPUSING) {
688 udp_unlock(inp->inp_socket, 1, 0);
689 IF_UDP_STATINC(ifp, cleanup);
690 goto bad;
691 }
692 #if NECP
693 if (!necp_socket_is_allowed_to_send_recv_v4(inp, uh->uh_dport,
694 uh->uh_sport, &ip->ip_dst, &ip->ip_src, ifp, NULL, NULL)) {
695 udp_unlock(inp->inp_socket, 1, 0);
696 IF_UDP_STATINC(ifp, badipsec);
697 goto bad;
698 }
699 #endif /* NECP */
700
701 /*
702 * Construct sockaddr format source address.
703 * Stuff source address and datagram in user buffer.
704 */
705 udp_in.sin_port = uh->uh_sport;
706 udp_in.sin_addr = ip->ip_src;
707 if ((inp->inp_flags & INP_CONTROLOPTS) != 0 ||
708 (inp->inp_socket->so_options & SO_TIMESTAMP) != 0 ||
709 (inp->inp_socket->so_options & SO_TIMESTAMP_MONOTONIC) != 0) {
710 #if INET6
711 if (inp->inp_vflag & INP_IPV6) {
712 int savedflags;
713
714 ip_2_ip6_hdr(&udp_ip6.uip6_ip6, ip);
715 savedflags = inp->inp_flags;
716 inp->inp_flags &= ~INP_UNMAPPABLEOPTS;
717 ret = ip6_savecontrol(inp, m, &opts);
718 inp->inp_flags = savedflags;
719 } else
720 #endif /* INET6 */
721 {
722 ret = ip_savecontrol(inp, &opts, ip, m);
723 }
724 if (ret != 0) {
725 udp_unlock(inp->inp_socket, 1, 0);
726 goto bad;
727 }
728 }
729 m_adj(m, iphlen + sizeof (struct udphdr));
730
731 KERNEL_DEBUG(DBG_LAYER_IN_END, uh->uh_dport, uh->uh_sport,
732 save_ip.ip_src.s_addr, save_ip.ip_dst.s_addr, uh->uh_ulen);
733
734 #if INET6
735 if (inp->inp_vflag & INP_IPV6) {
736 in6_sin_2_v4mapsin6(&udp_in, &udp_in6.uin6_sin);
737 append_sa = (struct sockaddr *)&udp_in6.uin6_sin;
738 } else
739 #endif /* INET6 */
740 {
741 append_sa = (struct sockaddr *)&udp_in;
742 }
743 if (nstat_collect) {
744 INP_ADD_STAT(inp, cell, wifi, wired, rxpackets, 1);
745 INP_ADD_STAT(inp, cell, wifi, wired, rxbytes, m->m_pkthdr.len);
746 }
747 so_recv_data_stat(inp->inp_socket, m, 0);
748 if (sbappendaddr(&inp->inp_socket->so_rcv, append_sa,
749 m, opts, NULL) == 0) {
750 udpstat.udps_fullsock++;
751 } else {
752 sorwakeup(inp->inp_socket);
753 }
754 udp_unlock(inp->inp_socket, 1, 0);
755 KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END, 0,0,0,0,0);
756 return;
757 bad:
758 m_freem(m);
759 if (opts)
760 m_freem(opts);
761 KERNEL_DEBUG(DBG_FNC_UDP_INPUT | DBG_FUNC_END, 0,0,0,0,0);
762 }
763
764 #if INET6
765 static void
766 ip_2_ip6_hdr(struct ip6_hdr *ip6, struct ip *ip)
767 {
768 bzero(ip6, sizeof (*ip6));
769
770 ip6->ip6_vfc = IPV6_VERSION;
771 ip6->ip6_plen = ip->ip_len;
772 ip6->ip6_nxt = ip->ip_p;
773 ip6->ip6_hlim = ip->ip_ttl;
774 if (ip->ip_src.s_addr) {
775 ip6->ip6_src.s6_addr32[2] = IPV6_ADDR_INT32_SMP;
776 ip6->ip6_src.s6_addr32[3] = ip->ip_src.s_addr;
777 }
778 if (ip->ip_dst.s_addr) {
779 ip6->ip6_dst.s6_addr32[2] = IPV6_ADDR_INT32_SMP;
780 ip6->ip6_dst.s6_addr32[3] = ip->ip_dst.s_addr;
781 }
782 }
783 #endif /* INET6 */
784
785 /*
786 * subroutine of udp_input(), mainly for source code readability.
787 */
788 static void
789 #if INET6
790 udp_append(struct inpcb *last, struct ip *ip, struct mbuf *n, int off,
791 struct sockaddr_in *pudp_in, struct udp_in6 *pudp_in6,
792 struct udp_ip6 *pudp_ip6, struct ifnet *ifp)
793 #else /* !INET6 */
794 udp_append(struct inpcb *last, struct ip *ip, struct mbuf *n, int off,
795 struct sockaddr_in *pudp_in, struct ifnet *ifp)
796 #endif /* !INET6 */
797 {
798 struct sockaddr *append_sa;
799 struct mbuf *opts = 0;
800 boolean_t cell = IFNET_IS_CELLULAR(ifp);
801 boolean_t wifi = (!cell && IFNET_IS_WIFI(ifp));
802 boolean_t wired = (!wifi && IFNET_IS_WIRED(ifp));
803 int ret = 0;
804
805 #if CONFIG_MACF_NET
806 if (mac_inpcb_check_deliver(last, n, AF_INET, SOCK_DGRAM) != 0) {
807 m_freem(n);
808 return;
809 }
810 #endif /* CONFIG_MACF_NET */
811 if ((last->inp_flags & INP_CONTROLOPTS) != 0 ||
812 (last->inp_socket->so_options & SO_TIMESTAMP) != 0 ||
813 (last->inp_socket->so_options & SO_TIMESTAMP_MONOTONIC) != 0) {
814 #if INET6
815 if (last->inp_vflag & INP_IPV6) {
816 int savedflags;
817
818 if (pudp_ip6->uip6_init_done == 0) {
819 ip_2_ip6_hdr(&pudp_ip6->uip6_ip6, ip);
820 pudp_ip6->uip6_init_done = 1;
821 }
822 savedflags = last->inp_flags;
823 last->inp_flags &= ~INP_UNMAPPABLEOPTS;
824 ret = ip6_savecontrol(last, n, &opts);
825 if (ret != 0) {
826 last->inp_flags = savedflags;
827 goto error;
828 }
829 last->inp_flags = savedflags;
830 } else
831 #endif /* INET6 */
832 {
833 ret = ip_savecontrol(last, &opts, ip, n);
834 if (ret != 0) {
835 goto error;
836 }
837 }
838 }
839 #if INET6
840 if (last->inp_vflag & INP_IPV6) {
841 if (pudp_in6->uin6_init_done == 0) {
842 in6_sin_2_v4mapsin6(pudp_in, &pudp_in6->uin6_sin);
843 pudp_in6->uin6_init_done = 1;
844 }
845 append_sa = (struct sockaddr *)&pudp_in6->uin6_sin;
846 } else
847 #endif /* INET6 */
848 append_sa = (struct sockaddr *)pudp_in;
849 if (nstat_collect) {
850 INP_ADD_STAT(last, cell, wifi, wired, rxpackets, 1);
851 INP_ADD_STAT(last, cell, wifi, wired, rxbytes,
852 n->m_pkthdr.len);
853 }
854 so_recv_data_stat(last->inp_socket, n, 0);
855 m_adj(n, off);
856 if (sbappendaddr(&last->inp_socket->so_rcv, append_sa,
857 n, opts, NULL) == 0) {
858 udpstat.udps_fullsock++;
859 } else {
860 sorwakeup(last->inp_socket);
861 }
862 return;
863 error:
864 m_freem(n);
865 m_freem(opts);
866 return;
867 }
868
869 /*
870 * Notify a udp user of an asynchronous error;
871 * just wake up so that he can collect error status.
872 */
873 void
874 udp_notify(struct inpcb *inp, int errno)
875 {
876 inp->inp_socket->so_error = errno;
877 sorwakeup(inp->inp_socket);
878 sowwakeup(inp->inp_socket);
879 }
880
881 void
882 udp_ctlinput(int cmd, struct sockaddr *sa, void *vip)
883 {
884 struct ip *ip = vip;
885 void (*notify)(struct inpcb *, int) = udp_notify;
886 struct in_addr faddr;
887 struct inpcb *inp;
888
889 faddr = ((struct sockaddr_in *)(void *)sa)->sin_addr;
890 if (sa->sa_family != AF_INET || faddr.s_addr == INADDR_ANY)
891 return;
892
893 if (PRC_IS_REDIRECT(cmd)) {
894 ip = 0;
895 notify = in_rtchange;
896 } else if (cmd == PRC_HOSTDEAD) {
897 ip = 0;
898 } else if ((unsigned)cmd >= PRC_NCMDS || inetctlerrmap[cmd] == 0) {
899 return;
900 }
901 if (ip) {
902 struct udphdr uh;
903
904 bcopy(((caddr_t)ip + (ip->ip_hl << 2)), &uh, sizeof (uh));
905 inp = in_pcblookup_hash(&udbinfo, faddr, uh.uh_dport,
906 ip->ip_src, uh.uh_sport, 0, NULL);
907 if (inp != NULL && inp->inp_socket != NULL) {
908 udp_lock(inp->inp_socket, 1, 0);
909 if (in_pcb_checkstate(inp, WNT_RELEASE, 1) ==
910 WNT_STOPUSING) {
911 udp_unlock(inp->inp_socket, 1, 0);
912 return;
913 }
914 (*notify)(inp, inetctlerrmap[cmd]);
915 udp_unlock(inp->inp_socket, 1, 0);
916 }
917 } else {
918 in_pcbnotifyall(&udbinfo, faddr, inetctlerrmap[cmd], notify);
919 }
920 }
921
922 int
923 udp_ctloutput(struct socket *so, struct sockopt *sopt)
924 {
925 int error, optval;
926 struct inpcb *inp;
927
928 /* Allow <SOL_SOCKET,SO_FLUSH> at this level */
929 if (sopt->sopt_level != IPPROTO_UDP &&
930 !(sopt->sopt_level == SOL_SOCKET && sopt->sopt_name == SO_FLUSH))
931 return (ip_ctloutput(so, sopt));
932
933 error = 0;
934 inp = sotoinpcb(so);
935
936 switch (sopt->sopt_dir) {
937 case SOPT_SET:
938 switch (sopt->sopt_name) {
939 case UDP_NOCKSUM:
940 /* This option is settable only for UDP over IPv4 */
941 if (!(inp->inp_vflag & INP_IPV4)) {
942 error = EINVAL;
943 break;
944 }
945
946 if ((error = sooptcopyin(sopt, &optval, sizeof (optval),
947 sizeof (optval))) != 0)
948 break;
949
950 if (optval != 0)
951 inp->inp_flags |= INP_UDP_NOCKSUM;
952 else
953 inp->inp_flags &= ~INP_UDP_NOCKSUM;
954 break;
955 case UDP_KEEPALIVE_OFFLOAD:
956 {
957 struct udp_keepalive_offload ka;
958 /*
959 * If the socket is not connected, the stack will
960 * not know the destination address to put in the
961 * keepalive datagram. Return an error now instead
962 * of failing later.
963 */
964 if (!(so->so_state & SS_ISCONNECTED)) {
965 error = EINVAL;
966 break;
967 }
968 if (sopt->sopt_valsize != sizeof(ka)) {
969 error = EINVAL;
970 break;
971 }
972 if ((error = sooptcopyin(sopt, &ka, sizeof(ka),
973 sizeof(ka))) != 0)
974 break;
975
976 /* application should specify the type */
977 if (ka.ka_type == 0)
978 return (EINVAL);
979
980 if (ka.ka_interval == 0) {
981 /*
982 * if interval is 0, disable the offload
983 * mechanism
984 */
985 if (inp->inp_keepalive_data != NULL)
986 FREE(inp->inp_keepalive_data,
987 M_TEMP);
988 inp->inp_keepalive_data = NULL;
989 inp->inp_keepalive_datalen = 0;
990 inp->inp_keepalive_interval = 0;
991 inp->inp_keepalive_type = 0;
992 inp->inp_flags2 &= ~INP2_KEEPALIVE_OFFLOAD;
993 } else {
994 if (inp->inp_keepalive_data != NULL) {
995 FREE(inp->inp_keepalive_data,
996 M_TEMP);
997 inp->inp_keepalive_data = NULL;
998 }
999
1000 inp->inp_keepalive_datalen = min(
1001 ka.ka_data_len,
1002 UDP_KEEPALIVE_OFFLOAD_DATA_SIZE);
1003 if (inp->inp_keepalive_datalen > 0) {
1004 MALLOC(inp->inp_keepalive_data,
1005 u_int8_t *,
1006 inp->inp_keepalive_datalen,
1007 M_TEMP, M_WAITOK);
1008 if (inp->inp_keepalive_data == NULL) {
1009 inp->inp_keepalive_datalen = 0;
1010 error = ENOMEM;
1011 break;
1012 }
1013 bcopy(ka.ka_data,
1014 inp->inp_keepalive_data,
1015 inp->inp_keepalive_datalen);
1016 } else {
1017 inp->inp_keepalive_datalen = 0;
1018 }
1019 inp->inp_keepalive_interval =
1020 min(UDP_KEEPALIVE_INTERVAL_MAX_SECONDS,
1021 ka.ka_interval);
1022 inp->inp_keepalive_type = ka.ka_type;
1023 inp->inp_flags2 |= INP2_KEEPALIVE_OFFLOAD;
1024 }
1025 break;
1026 }
1027 case SO_FLUSH:
1028 if ((error = sooptcopyin(sopt, &optval, sizeof (optval),
1029 sizeof (optval))) != 0)
1030 break;
1031
1032 error = inp_flush(inp, optval);
1033 break;
1034
1035 default:
1036 error = ENOPROTOOPT;
1037 break;
1038 }
1039 break;
1040
1041 case SOPT_GET:
1042 switch (sopt->sopt_name) {
1043 case UDP_NOCKSUM:
1044 optval = inp->inp_flags & INP_UDP_NOCKSUM;
1045 break;
1046
1047 default:
1048 error = ENOPROTOOPT;
1049 break;
1050 }
1051 if (error == 0)
1052 error = sooptcopyout(sopt, &optval, sizeof (optval));
1053 break;
1054 }
1055 return (error);
1056 }
1057
1058 static int
1059 udp_pcblist SYSCTL_HANDLER_ARGS
1060 {
1061 #pragma unused(oidp, arg1, arg2)
1062 int error, i, n;
1063 struct inpcb *inp, **inp_list;
1064 inp_gen_t gencnt;
1065 struct xinpgen xig;
1066
1067 /*
1068 * The process of preparing the TCB list is too time-consuming and
1069 * resource-intensive to repeat twice on every request.
1070 */
1071 lck_rw_lock_exclusive(udbinfo.ipi_lock);
1072 if (req->oldptr == USER_ADDR_NULL) {
1073 n = udbinfo.ipi_count;
1074 req->oldidx = 2 * (sizeof (xig))
1075 + (n + n/8) * sizeof (struct xinpcb);
1076 lck_rw_done(udbinfo.ipi_lock);
1077 return (0);
1078 }
1079
1080 if (req->newptr != USER_ADDR_NULL) {
1081 lck_rw_done(udbinfo.ipi_lock);
1082 return (EPERM);
1083 }
1084
1085 /*
1086 * OK, now we're committed to doing something.
1087 */
1088 gencnt = udbinfo.ipi_gencnt;
1089 n = udbinfo.ipi_count;
1090
1091 bzero(&xig, sizeof (xig));
1092 xig.xig_len = sizeof (xig);
1093 xig.xig_count = n;
1094 xig.xig_gen = gencnt;
1095 xig.xig_sogen = so_gencnt;
1096 error = SYSCTL_OUT(req, &xig, sizeof (xig));
1097 if (error) {
1098 lck_rw_done(udbinfo.ipi_lock);
1099 return (error);
1100 }
1101 /*
1102 * We are done if there is no pcb
1103 */
1104 if (n == 0) {
1105 lck_rw_done(udbinfo.ipi_lock);
1106 return (0);
1107 }
1108
1109 inp_list = _MALLOC(n * sizeof (*inp_list), M_TEMP, M_WAITOK);
1110 if (inp_list == 0) {
1111 lck_rw_done(udbinfo.ipi_lock);
1112 return (ENOMEM);
1113 }
1114
1115 for (inp = LIST_FIRST(udbinfo.ipi_listhead), i = 0; inp && i < n;
1116 inp = LIST_NEXT(inp, inp_list)) {
1117 if (inp->inp_gencnt <= gencnt &&
1118 inp->inp_state != INPCB_STATE_DEAD)
1119 inp_list[i++] = inp;
1120 }
1121 n = i;
1122
1123 error = 0;
1124 for (i = 0; i < n; i++) {
1125 inp = inp_list[i];
1126 if (inp->inp_gencnt <= gencnt &&
1127 inp->inp_state != INPCB_STATE_DEAD) {
1128 struct xinpcb xi;
1129
1130 bzero(&xi, sizeof (xi));
1131 xi.xi_len = sizeof (xi);
1132 /* XXX should avoid extra copy */
1133 inpcb_to_compat(inp, &xi.xi_inp);
1134 if (inp->inp_socket)
1135 sotoxsocket(inp->inp_socket, &xi.xi_socket);
1136 error = SYSCTL_OUT(req, &xi, sizeof (xi));
1137 }
1138 }
1139 if (!error) {
1140 /*
1141 * Give the user an updated idea of our state.
1142 * If the generation differs from what we told
1143 * her before, she knows that something happened
1144 * while we were processing this request, and it
1145 * might be necessary to retry.
1146 */
1147 bzero(&xig, sizeof (xig));
1148 xig.xig_len = sizeof (xig);
1149 xig.xig_gen = udbinfo.ipi_gencnt;
1150 xig.xig_sogen = so_gencnt;
1151 xig.xig_count = udbinfo.ipi_count;
1152 error = SYSCTL_OUT(req, &xig, sizeof (xig));
1153 }
1154 FREE(inp_list, M_TEMP);
1155 lck_rw_done(udbinfo.ipi_lock);
1156 return (error);
1157 }
1158
1159 SYSCTL_PROC(_net_inet_udp, UDPCTL_PCBLIST, pcblist,
1160 CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0, udp_pcblist,
1161 "S,xinpcb", "List of active UDP sockets");
1162
1163
1164 static int
1165 udp_pcblist64 SYSCTL_HANDLER_ARGS
1166 {
1167 #pragma unused(oidp, arg1, arg2)
1168 int error, i, n;
1169 struct inpcb *inp, **inp_list;
1170 inp_gen_t gencnt;
1171 struct xinpgen xig;
1172
1173 /*
1174 * The process of preparing the TCB list is too time-consuming and
1175 * resource-intensive to repeat twice on every request.
1176 */
1177 lck_rw_lock_shared(udbinfo.ipi_lock);
1178 if (req->oldptr == USER_ADDR_NULL) {
1179 n = udbinfo.ipi_count;
1180 req->oldidx =
1181 2 * (sizeof (xig)) + (n + n/8) * sizeof (struct xinpcb64);
1182 lck_rw_done(udbinfo.ipi_lock);
1183 return (0);
1184 }
1185
1186 if (req->newptr != USER_ADDR_NULL) {
1187 lck_rw_done(udbinfo.ipi_lock);
1188 return (EPERM);
1189 }
1190
1191 /*
1192 * OK, now we're committed to doing something.
1193 */
1194 gencnt = udbinfo.ipi_gencnt;
1195 n = udbinfo.ipi_count;
1196
1197 bzero(&xig, sizeof (xig));
1198 xig.xig_len = sizeof (xig);
1199 xig.xig_count = n;
1200 xig.xig_gen = gencnt;
1201 xig.xig_sogen = so_gencnt;
1202 error = SYSCTL_OUT(req, &xig, sizeof (xig));
1203 if (error) {
1204 lck_rw_done(udbinfo.ipi_lock);
1205 return (error);
1206 }
1207 /*
1208 * We are done if there is no pcb
1209 */
1210 if (n == 0) {
1211 lck_rw_done(udbinfo.ipi_lock);
1212 return (0);
1213 }
1214
1215 inp_list = _MALLOC(n * sizeof (*inp_list), M_TEMP, M_WAITOK);
1216 if (inp_list == 0) {
1217 lck_rw_done(udbinfo.ipi_lock);
1218 return (ENOMEM);
1219 }
1220
1221 for (inp = LIST_FIRST(udbinfo.ipi_listhead), i = 0; inp && i < n;
1222 inp = LIST_NEXT(inp, inp_list)) {
1223 if (inp->inp_gencnt <= gencnt &&
1224 inp->inp_state != INPCB_STATE_DEAD)
1225 inp_list[i++] = inp;
1226 }
1227 n = i;
1228
1229 error = 0;
1230 for (i = 0; i < n; i++) {
1231 inp = inp_list[i];
1232 if (inp->inp_gencnt <= gencnt &&
1233 inp->inp_state != INPCB_STATE_DEAD) {
1234 struct xinpcb64 xi;
1235
1236 bzero(&xi, sizeof (xi));
1237 xi.xi_len = sizeof (xi);
1238 inpcb_to_xinpcb64(inp, &xi);
1239 if (inp->inp_socket)
1240 sotoxsocket64(inp->inp_socket, &xi.xi_socket);
1241 error = SYSCTL_OUT(req, &xi, sizeof (xi));
1242 }
1243 }
1244 if (!error) {
1245 /*
1246 * Give the user an updated idea of our state.
1247 * If the generation differs from what we told
1248 * her before, she knows that something happened
1249 * while we were processing this request, and it
1250 * might be necessary to retry.
1251 */
1252 bzero(&xig, sizeof (xig));
1253 xig.xig_len = sizeof (xig);
1254 xig.xig_gen = udbinfo.ipi_gencnt;
1255 xig.xig_sogen = so_gencnt;
1256 xig.xig_count = udbinfo.ipi_count;
1257 error = SYSCTL_OUT(req, &xig, sizeof (xig));
1258 }
1259 FREE(inp_list, M_TEMP);
1260 lck_rw_done(udbinfo.ipi_lock);
1261 return (error);
1262 }
1263
1264 SYSCTL_PROC(_net_inet_udp, OID_AUTO, pcblist64,
1265 CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0, udp_pcblist64,
1266 "S,xinpcb64", "List of active UDP sockets");
1267
1268
1269 static int
1270 udp_pcblist_n SYSCTL_HANDLER_ARGS
1271 {
1272 #pragma unused(oidp, arg1, arg2)
1273 return (get_pcblist_n(IPPROTO_UDP, req, &udbinfo));
1274 }
1275
1276 SYSCTL_PROC(_net_inet_udp, OID_AUTO, pcblist_n,
1277 CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0, udp_pcblist_n,
1278 "S,xinpcb_n", "List of active UDP sockets");
1279
1280 __private_extern__ void
1281 udp_get_ports_used(uint32_t ifindex, int protocol, uint32_t flags,
1282 bitstr_t *bitfield)
1283 {
1284 inpcb_get_ports_used(ifindex, protocol, flags, bitfield, &udbinfo);
1285 }
1286
1287 __private_extern__ uint32_t
1288 udp_count_opportunistic(unsigned int ifindex, u_int32_t flags)
1289 {
1290 return (inpcb_count_opportunistic(ifindex, &udbinfo, flags));
1291 }
1292
1293 __private_extern__ uint32_t
1294 udp_find_anypcb_byaddr(struct ifaddr *ifa)
1295 {
1296 return (inpcb_find_anypcb_byaddr(ifa, &udbinfo));
1297 }
1298
1299 static int
1300 udp_check_pktinfo(struct mbuf *control, struct ifnet **outif,
1301 struct in_addr *laddr)
1302 {
1303 struct cmsghdr *cm = 0;
1304 struct in_pktinfo *pktinfo;
1305 struct ifnet *ifp;
1306
1307 if (outif != NULL)
1308 *outif = NULL;
1309
1310 /*
1311 * XXX: Currently, we assume all the optional information is stored
1312 * in a single mbuf.
1313 */
1314 if (control->m_next)
1315 return (EINVAL);
1316
1317 if (control->m_len < CMSG_LEN(0))
1318 return (EINVAL);
1319
1320 for (cm = M_FIRST_CMSGHDR(control); cm;
1321 cm = M_NXT_CMSGHDR(control, cm)) {
1322 if (cm->cmsg_len < sizeof (struct cmsghdr) ||
1323 cm->cmsg_len > control->m_len)
1324 return (EINVAL);
1325
1326 if (cm->cmsg_level != IPPROTO_IP || cm->cmsg_type != IP_PKTINFO)
1327 continue;
1328
1329 if (cm->cmsg_len != CMSG_LEN(sizeof (struct in_pktinfo)))
1330 return (EINVAL);
1331
1332 pktinfo = (struct in_pktinfo *)(void *)CMSG_DATA(cm);
1333
1334 /* Check for a valid ifindex in pktinfo */
1335 ifnet_head_lock_shared();
1336
1337 if (pktinfo->ipi_ifindex > if_index) {
1338 ifnet_head_done();
1339 return (ENXIO);
1340 }
1341
1342 /*
1343 * If ipi_ifindex is specified it takes precedence
1344 * over ipi_spec_dst.
1345 */
1346 if (pktinfo->ipi_ifindex) {
1347 ifp = ifindex2ifnet[pktinfo->ipi_ifindex];
1348 if (ifp == NULL) {
1349 ifnet_head_done();
1350 return (ENXIO);
1351 }
1352 if (outif != NULL) {
1353 ifnet_reference(ifp);
1354 *outif = ifp;
1355 }
1356 ifnet_head_done();
1357 laddr->s_addr = INADDR_ANY;
1358 break;
1359 }
1360
1361 ifnet_head_done();
1362
1363 /*
1364 * Use the provided ipi_spec_dst address for temp
1365 * source address.
1366 */
1367 *laddr = pktinfo->ipi_spec_dst;
1368 break;
1369 }
1370 return (0);
1371 }
1372
1373 static int
1374 udp_output(struct inpcb *inp, struct mbuf *m, struct sockaddr *addr,
1375 struct mbuf *control, struct proc *p)
1376 {
1377 struct udpiphdr *ui;
1378 int len = m->m_pkthdr.len;
1379 struct sockaddr_in *sin;
1380 struct in_addr origladdr, laddr, faddr, pi_laddr;
1381 u_short lport, fport;
1382 int error = 0, udp_dodisconnect = 0, pktinfo = 0;
1383 struct socket *so = inp->inp_socket;
1384 int soopts = 0;
1385 struct mbuf *inpopts;
1386 struct ip_moptions *mopts;
1387 struct route ro;
1388 struct ip_out_args ipoa =
1389 { IFSCOPE_NONE, { 0 }, IPOAF_SELECT_SRCIF, 0 };
1390 struct ifnet *outif = NULL;
1391 struct flowadv *adv = &ipoa.ipoa_flowadv;
1392 mbuf_svc_class_t msc = MBUF_SC_UNSPEC;
1393 struct ifnet *origoutifp = NULL;
1394 int flowadv = 0;
1395
1396 /* Enable flow advisory only when connected */
1397 flowadv = (so->so_state & SS_ISCONNECTED) ? 1 : 0;
1398 pi_laddr.s_addr = INADDR_ANY;
1399
1400 KERNEL_DEBUG(DBG_FNC_UDP_OUTPUT | DBG_FUNC_START, 0,0,0,0,0);
1401
1402 lck_mtx_assert(&inp->inpcb_mtx, LCK_MTX_ASSERT_OWNED);
1403 if (control != NULL) {
1404 msc = mbuf_service_class_from_control(control);
1405 VERIFY(outif == NULL);
1406 error = udp_check_pktinfo(control, &outif, &pi_laddr);
1407 m_freem(control);
1408 control = NULL;
1409 if (error)
1410 goto release;
1411 pktinfo++;
1412 if (outif != NULL)
1413 ipoa.ipoa_boundif = outif->if_index;
1414 }
1415
1416 KERNEL_DEBUG(DBG_LAYER_OUT_BEG, inp->inp_fport, inp->inp_lport,
1417 inp->inp_laddr.s_addr, inp->inp_faddr.s_addr,
1418 (htons((u_short)len + sizeof (struct udphdr))));
1419
1420 if (len + sizeof (struct udpiphdr) > IP_MAXPACKET) {
1421 error = EMSGSIZE;
1422 goto release;
1423 }
1424
1425 if (flowadv && INP_WAIT_FOR_IF_FEEDBACK(inp)) {
1426 /*
1427 * The socket is flow-controlled, drop the packets
1428 * until the inp is not flow controlled
1429 */
1430 error = ENOBUFS;
1431 goto release;
1432 }
1433 /*
1434 * If socket was bound to an ifindex, tell ip_output about it.
1435 * If the ancillary IP_PKTINFO option contains an interface index,
1436 * it takes precedence over the one specified by IP_BOUND_IF.
1437 */
1438 if (ipoa.ipoa_boundif == IFSCOPE_NONE &&
1439 (inp->inp_flags & INP_BOUND_IF)) {
1440 VERIFY(inp->inp_boundifp != NULL);
1441 ifnet_reference(inp->inp_boundifp); /* for this routine */
1442 if (outif != NULL)
1443 ifnet_release(outif);
1444 outif = inp->inp_boundifp;
1445 ipoa.ipoa_boundif = outif->if_index;
1446 }
1447 if (INP_NO_CELLULAR(inp))
1448 ipoa.ipoa_flags |= IPOAF_NO_CELLULAR;
1449 if (INP_NO_EXPENSIVE(inp))
1450 ipoa.ipoa_flags |= IPOAF_NO_EXPENSIVE;
1451 if (INP_AWDL_UNRESTRICTED(inp))
1452 ipoa.ipoa_flags |= IPOAF_AWDL_UNRESTRICTED;
1453 soopts |= IP_OUTARGS;
1454
1455 /*
1456 * If there was a routing change, discard cached route and check
1457 * that we have a valid source address. Reacquire a new source
1458 * address if INADDR_ANY was specified.
1459 */
1460 if (ROUTE_UNUSABLE(&inp->inp_route)) {
1461 struct in_ifaddr *ia = NULL;
1462
1463 ROUTE_RELEASE(&inp->inp_route);
1464
1465 /* src address is gone? */
1466 if (inp->inp_laddr.s_addr != INADDR_ANY &&
1467 (ia = ifa_foraddr(inp->inp_laddr.s_addr)) == NULL) {
1468 if (!(inp->inp_flags & INP_INADDR_ANY) ||
1469 (so->so_state & SS_ISCONNECTED)) {
1470 /*
1471 * Rdar://5448998
1472 * If the source address is gone, return an
1473 * error if:
1474 * - the source was specified
1475 * - the socket was already connected
1476 */
1477 soevent(so, (SO_FILT_HINT_LOCKED |
1478 SO_FILT_HINT_NOSRCADDR));
1479 error = EADDRNOTAVAIL;
1480 goto release;
1481 } else {
1482 /* new src will be set later */
1483 inp->inp_laddr.s_addr = INADDR_ANY;
1484 inp->inp_last_outifp = NULL;
1485 }
1486 }
1487 if (ia != NULL)
1488 IFA_REMREF(&ia->ia_ifa);
1489 }
1490
1491 /*
1492 * IP_PKTINFO option check. If a temporary scope or src address
1493 * is provided, use it for this packet only and make sure we forget
1494 * it after sending this datagram.
1495 */
1496 if (pi_laddr.s_addr != INADDR_ANY ||
1497 (ipoa.ipoa_boundif != IFSCOPE_NONE && pktinfo)) {
1498 /* temp src address for this datagram only */
1499 laddr = pi_laddr;
1500 origladdr.s_addr = INADDR_ANY;
1501 /* we don't want to keep the laddr or route */
1502 udp_dodisconnect = 1;
1503 /* remember we don't care about src addr.*/
1504 inp->inp_flags |= INP_INADDR_ANY;
1505 } else {
1506 origladdr = laddr = inp->inp_laddr;
1507 }
1508
1509 origoutifp = inp->inp_last_outifp;
1510 faddr = inp->inp_faddr;
1511 lport = inp->inp_lport;
1512 fport = inp->inp_fport;
1513
1514 if (addr) {
1515 sin = (struct sockaddr_in *)(void *)addr;
1516 if (faddr.s_addr != INADDR_ANY) {
1517 error = EISCONN;
1518 goto release;
1519 }
1520 if (lport == 0) {
1521 /*
1522 * In case we don't have a local port set, go through
1523 * the full connect. We don't have a local port yet
1524 * (i.e., we can't be looked up), so it's not an issue
1525 * if the input runs at the same time we do this.
1526 */
1527 /* if we have a source address specified, use that */
1528 if (pi_laddr.s_addr != INADDR_ANY)
1529 inp->inp_laddr = pi_laddr;
1530 /*
1531 * If a scope is specified, use it. Scope from
1532 * IP_PKTINFO takes precendence over the the scope
1533 * set via INP_BOUND_IF.
1534 */
1535 error = in_pcbconnect(inp, addr, p, ipoa.ipoa_boundif,
1536 &outif);
1537 if (error)
1538 goto release;
1539
1540 laddr = inp->inp_laddr;
1541 lport = inp->inp_lport;
1542 faddr = inp->inp_faddr;
1543 fport = inp->inp_fport;
1544 udp_dodisconnect = 1;
1545
1546 /* synch up in case in_pcbladdr() overrides */
1547 if (outif != NULL && ipoa.ipoa_boundif != IFSCOPE_NONE)
1548 ipoa.ipoa_boundif = outif->if_index;
1549 }
1550 else {
1551 /*
1552 * Fast path case
1553 *
1554 * We have a full address and a local port; use those
1555 * info to build the packet without changing the pcb
1556 * and interfering with the input path. See 3851370.
1557 *
1558 * Scope from IP_PKTINFO takes precendence over the
1559 * the scope set via INP_BOUND_IF.
1560 */
1561 if (laddr.s_addr == INADDR_ANY) {
1562 if ((error = in_pcbladdr(inp, addr, &laddr,
1563 ipoa.ipoa_boundif, &outif)) != 0)
1564 goto release;
1565 /*
1566 * from pcbconnect: remember we don't
1567 * care about src addr.
1568 */
1569 inp->inp_flags |= INP_INADDR_ANY;
1570
1571 /* synch up in case in_pcbladdr() overrides */
1572 if (outif != NULL &&
1573 ipoa.ipoa_boundif != IFSCOPE_NONE)
1574 ipoa.ipoa_boundif = outif->if_index;
1575 }
1576
1577 faddr = sin->sin_addr;
1578 fport = sin->sin_port;
1579 }
1580 } else {
1581 if (faddr.s_addr == INADDR_ANY) {
1582 error = ENOTCONN;
1583 goto release;
1584 }
1585 }
1586
1587 #if CONFIG_MACF_NET
1588 mac_mbuf_label_associate_inpcb(inp, m);
1589 #endif /* CONFIG_MACF_NET */
1590
1591 if (inp->inp_flowhash == 0)
1592 inp->inp_flowhash = inp_calc_flowhash(inp);
1593
1594 /*
1595 * Calculate data length and get a mbuf
1596 * for UDP and IP headers.
1597 */
1598 M_PREPEND(m, sizeof (struct udpiphdr), M_DONTWAIT, 1);
1599 if (m == 0) {
1600 error = ENOBUFS;
1601 goto abort;
1602 }
1603
1604 /*
1605 * Fill in mbuf with extended UDP header
1606 * and addresses and length put into network format.
1607 */
1608 ui = mtod(m, struct udpiphdr *);
1609 bzero(ui->ui_x1, sizeof (ui->ui_x1)); /* XXX still needed? */
1610 ui->ui_pr = IPPROTO_UDP;
1611 ui->ui_src = laddr;
1612 ui->ui_dst = faddr;
1613 ui->ui_sport = lport;
1614 ui->ui_dport = fport;
1615 ui->ui_ulen = htons((u_short)len + sizeof (struct udphdr));
1616
1617 /*
1618 * Set up checksum and output datagram.
1619 */
1620 if (udpcksum && !(inp->inp_flags & INP_UDP_NOCKSUM)) {
1621 ui->ui_sum = in_pseudo(ui->ui_src.s_addr, ui->ui_dst.s_addr,
1622 htons((u_short)len + sizeof (struct udphdr) + IPPROTO_UDP));
1623 m->m_pkthdr.csum_flags = CSUM_UDP;
1624 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
1625 } else {
1626 ui->ui_sum = 0;
1627 }
1628 ((struct ip *)ui)->ip_len = sizeof (struct udpiphdr) + len;
1629 ((struct ip *)ui)->ip_ttl = inp->inp_ip_ttl; /* XXX */
1630 ((struct ip *)ui)->ip_tos = inp->inp_ip_tos; /* XXX */
1631 udpstat.udps_opackets++;
1632
1633 KERNEL_DEBUG(DBG_LAYER_OUT_END, ui->ui_dport, ui->ui_sport,
1634 ui->ui_src.s_addr, ui->ui_dst.s_addr, ui->ui_ulen);
1635
1636 #if NECP
1637 {
1638 necp_kernel_policy_id policy_id;
1639 u_int32_t route_rule_id;
1640 if (!necp_socket_is_allowed_to_send_recv_v4(inp, lport, fport,
1641 &laddr, &faddr, NULL, &policy_id, &route_rule_id)) {
1642 error = EHOSTUNREACH;
1643 goto abort;
1644 }
1645
1646 necp_mark_packet_from_socket(m, inp, policy_id, route_rule_id);
1647 }
1648 #endif /* NECP */
1649
1650 #if IPSEC
1651 if (inp->inp_sp != NULL && ipsec_setsocket(m, inp->inp_socket) != 0) {
1652 error = ENOBUFS;
1653 goto abort;
1654 }
1655 #endif /* IPSEC */
1656
1657 inpopts = inp->inp_options;
1658 soopts |= (inp->inp_socket->so_options & (SO_DONTROUTE | SO_BROADCAST));
1659 mopts = inp->inp_moptions;
1660 if (mopts != NULL) {
1661 IMO_LOCK(mopts);
1662 IMO_ADDREF_LOCKED(mopts);
1663 if (IN_MULTICAST(ntohl(ui->ui_dst.s_addr)) &&
1664 mopts->imo_multicast_ifp != NULL) {
1665 /* no reference needed */
1666 inp->inp_last_outifp = mopts->imo_multicast_ifp;
1667 }
1668 IMO_UNLOCK(mopts);
1669 }
1670
1671 /* Copy the cached route and take an extra reference */
1672 inp_route_copyout(inp, &ro);
1673
1674 set_packet_service_class(m, so, msc, 0);
1675 m->m_pkthdr.pkt_flowsrc = FLOWSRC_INPCB;
1676 m->m_pkthdr.pkt_flowid = inp->inp_flowhash;
1677 m->m_pkthdr.pkt_proto = IPPROTO_UDP;
1678 m->m_pkthdr.pkt_flags |= (PKTF_FLOW_ID | PKTF_FLOW_LOCALSRC);
1679 if (flowadv)
1680 m->m_pkthdr.pkt_flags |= PKTF_FLOW_ADV;
1681
1682 if (ipoa.ipoa_boundif != IFSCOPE_NONE)
1683 ipoa.ipoa_flags |= IPOAF_BOUND_IF;
1684
1685 if (laddr.s_addr != INADDR_ANY)
1686 ipoa.ipoa_flags |= IPOAF_BOUND_SRCADDR;
1687
1688 inp->inp_sndinprog_cnt++;
1689
1690 socket_unlock(so, 0);
1691 error = ip_output(m, inpopts, &ro, soopts, mopts, &ipoa);
1692 m = NULL;
1693 socket_lock(so, 0);
1694 if (mopts != NULL)
1695 IMO_REMREF(mopts);
1696
1697 if (error == 0 && nstat_collect) {
1698 boolean_t cell, wifi, wired;
1699
1700 if (ro.ro_rt != NULL) {
1701 cell = IFNET_IS_CELLULAR(ro.ro_rt->rt_ifp);
1702 wifi = (!cell && IFNET_IS_WIFI(ro.ro_rt->rt_ifp));
1703 wired = (!wifi && IFNET_IS_WIRED(ro.ro_rt->rt_ifp));
1704 } else {
1705 cell = wifi = wired = FALSE;
1706 }
1707 INP_ADD_STAT(inp, cell, wifi, wired, txpackets, 1);
1708 INP_ADD_STAT(inp, cell, wifi, wired, txbytes, len);
1709 }
1710
1711 if (flowadv && (adv->code == FADV_FLOW_CONTROLLED ||
1712 adv->code == FADV_SUSPENDED)) {
1713 /* return a hint to the application that
1714 * the packet has been dropped
1715 */
1716 error = ENOBUFS;
1717 inp_set_fc_state(inp, adv->code);
1718 }
1719
1720 VERIFY(inp->inp_sndinprog_cnt > 0);
1721 if ( --inp->inp_sndinprog_cnt == 0)
1722 inp->inp_flags &= ~(INP_FC_FEEDBACK);
1723
1724 /* Synchronize PCB cached route */
1725 inp_route_copyin(inp, &ro);
1726
1727 abort:
1728 if (udp_dodisconnect) {
1729 /* Always discard the cached route for unconnected socket */
1730 ROUTE_RELEASE(&inp->inp_route);
1731 in_pcbdisconnect(inp);
1732 inp->inp_laddr = origladdr; /* XXX rehash? */
1733 /* no reference needed */
1734 inp->inp_last_outifp = origoutifp;
1735 } else if (inp->inp_route.ro_rt != NULL) {
1736 struct rtentry *rt = inp->inp_route.ro_rt;
1737 struct ifnet *outifp;
1738
1739 if (rt->rt_flags & (RTF_MULTICAST|RTF_BROADCAST))
1740 rt = NULL; /* unusable */
1741 /*
1742 * Always discard if it is a multicast or broadcast route.
1743 */
1744 if (rt == NULL)
1745 ROUTE_RELEASE(&inp->inp_route);
1746
1747 /*
1748 * If the destination route is unicast, update outifp with
1749 * that of the route interface used by IP.
1750 */
1751 if (rt != NULL &&
1752 (outifp = rt->rt_ifp) != inp->inp_last_outifp) {
1753 inp->inp_last_outifp = outifp; /* no reference needed */
1754
1755 so->so_pktheadroom = P2ROUNDUP(
1756 sizeof(struct udphdr) +
1757 sizeof(struct ip) +
1758 ifnet_hdrlen(outifp) +
1759 ifnet_packetpreamblelen(outifp),
1760 sizeof(u_int32_t));
1761 }
1762 } else {
1763 ROUTE_RELEASE(&inp->inp_route);
1764 }
1765
1766 /*
1767 * If output interface was cellular/expensive, and this socket is
1768 * denied access to it, generate an event.
1769 */
1770 if (error != 0 && (ipoa.ipoa_retflags & IPOARF_IFDENIED) &&
1771 (INP_NO_CELLULAR(inp) || INP_NO_EXPENSIVE(inp)))
1772 soevent(so, (SO_FILT_HINT_LOCKED|SO_FILT_HINT_IFDENIED));
1773
1774 release:
1775 KERNEL_DEBUG(DBG_FNC_UDP_OUTPUT | DBG_FUNC_END, error, 0, 0, 0, 0);
1776
1777 if (m != NULL)
1778 m_freem(m);
1779
1780 if (outif != NULL)
1781 ifnet_release(outif);
1782
1783 return (error);
1784 }
1785
1786 u_int32_t udp_sendspace = 9216; /* really max datagram size */
1787 /* 187 1K datagrams (approx 192 KB) */
1788 u_int32_t udp_recvspace = 187 * (1024 +
1789 #if INET6
1790 sizeof (struct sockaddr_in6)
1791 #else /* !INET6 */
1792 sizeof (struct sockaddr_in)
1793 #endif /* !INET6 */
1794 );
1795
1796 /* Check that the values of udp send and recv space do not exceed sb_max */
1797 static int
1798 sysctl_udp_sospace(struct sysctl_oid *oidp, void *arg1, int arg2,
1799 struct sysctl_req *req)
1800 {
1801 #pragma unused(arg1, arg2)
1802 u_int32_t new_value = 0, *space_p = NULL;
1803 int changed = 0, error = 0;
1804 u_quad_t sb_effective_max = (sb_max/(MSIZE+MCLBYTES)) * MCLBYTES;
1805
1806 switch (oidp->oid_number) {
1807 case UDPCTL_RECVSPACE:
1808 space_p = &udp_recvspace;
1809 break;
1810 case UDPCTL_MAXDGRAM:
1811 space_p = &udp_sendspace;
1812 break;
1813 default:
1814 return EINVAL;
1815 }
1816 error = sysctl_io_number(req, *space_p, sizeof (u_int32_t),
1817 &new_value, &changed);
1818 if (changed) {
1819 if (new_value > 0 && new_value <= sb_effective_max)
1820 *space_p = new_value;
1821 else
1822 error = ERANGE;
1823 }
1824 return (error);
1825 }
1826
1827 SYSCTL_PROC(_net_inet_udp, UDPCTL_RECVSPACE, recvspace,
1828 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, &udp_recvspace, 0,
1829 &sysctl_udp_sospace, "IU", "Maximum incoming UDP datagram size");
1830
1831 SYSCTL_PROC(_net_inet_udp, UDPCTL_MAXDGRAM, maxdgram,
1832 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, &udp_sendspace, 0,
1833 &sysctl_udp_sospace, "IU", "Maximum outgoing UDP datagram size");
1834
1835 static int
1836 udp_abort(struct socket *so)
1837 {
1838 struct inpcb *inp;
1839
1840 inp = sotoinpcb(so);
1841 if (inp == NULL) {
1842 panic("%s: so=%p null inp\n", __func__, so);
1843 /* NOTREACHED */
1844 }
1845 soisdisconnected(so);
1846 in_pcbdetach(inp);
1847 return (0);
1848 }
1849
1850 static int
1851 udp_attach(struct socket *so, int proto, struct proc *p)
1852 {
1853 #pragma unused(proto)
1854 struct inpcb *inp;
1855 int error;
1856
1857 inp = sotoinpcb(so);
1858 if (inp != NULL) {
1859 panic ("%s so=%p inp=%p\n", __func__, so, inp);
1860 /* NOTREACHED */
1861 }
1862 error = in_pcballoc(so, &udbinfo, p);
1863 if (error != 0)
1864 return (error);
1865 error = soreserve(so, udp_sendspace, udp_recvspace);
1866 if (error != 0)
1867 return (error);
1868 inp = (struct inpcb *)so->so_pcb;
1869 inp->inp_vflag |= INP_IPV4;
1870 inp->inp_ip_ttl = ip_defttl;
1871 if (nstat_collect)
1872 nstat_udp_new_pcb(inp);
1873 return (0);
1874 }
1875
1876 static int
1877 udp_bind(struct socket *so, struct sockaddr *nam, struct proc *p)
1878 {
1879 struct inpcb *inp;
1880 int error;
1881
1882 if (nam->sa_family != 0 && nam->sa_family != AF_INET &&
1883 nam->sa_family != AF_INET6)
1884 return (EAFNOSUPPORT);
1885
1886 inp = sotoinpcb(so);
1887 if (inp == NULL)
1888 return (EINVAL);
1889 error = in_pcbbind(inp, nam, p);
1890 return (error);
1891 }
1892
1893 static int
1894 udp_connect(struct socket *so, struct sockaddr *nam, struct proc *p)
1895 {
1896 struct inpcb *inp;
1897 int error;
1898
1899 inp = sotoinpcb(so);
1900 if (inp == NULL)
1901 return (EINVAL);
1902 if (inp->inp_faddr.s_addr != INADDR_ANY)
1903 return (EISCONN);
1904
1905 #if NECP
1906 #if FLOW_DIVERT
1907 if (necp_socket_should_use_flow_divert(inp)) {
1908 uint32_t fd_ctl_unit =
1909 necp_socket_get_flow_divert_control_unit(inp);
1910 if (fd_ctl_unit > 0) {
1911 error = flow_divert_pcb_init(so, fd_ctl_unit);
1912 if (error == 0) {
1913 error = flow_divert_connect_out(so, nam, p);
1914 }
1915 } else {
1916 error = ENETDOWN;
1917 }
1918 return (error);
1919 }
1920 #endif /* FLOW_DIVERT */
1921 #endif /* NECP */
1922
1923 error = in_pcbconnect(inp, nam, p, IFSCOPE_NONE, NULL);
1924 if (error == 0) {
1925 soisconnected(so);
1926 if (inp->inp_flowhash == 0)
1927 inp->inp_flowhash = inp_calc_flowhash(inp);
1928 }
1929 return (error);
1930 }
1931
1932 int
1933 udp_connectx_common(struct socket *so, int af,
1934 struct sockaddr_list **src_sl, struct sockaddr_list **dst_sl,
1935 struct proc *p, uint32_t ifscope, sae_associd_t aid, sae_connid_t *pcid,
1936 uint32_t flags, void *arg, uint32_t arglen,
1937 struct uio *uio, user_ssize_t *bytes_written)
1938 {
1939 #pragma unused(aid, flags, arg, arglen)
1940 struct sockaddr_entry *src_se = NULL, *dst_se = NULL;
1941 struct inpcb *inp = sotoinpcb(so);
1942 int error;
1943 user_ssize_t datalen = 0;
1944
1945 if (inp == NULL)
1946 return (EINVAL);
1947
1948 VERIFY(dst_sl != NULL);
1949
1950 /* select source (if specified) and destination addresses */
1951 error = in_selectaddrs(af, src_sl, &src_se, dst_sl, &dst_se);
1952 if (error != 0)
1953 return (error);
1954
1955 VERIFY(*dst_sl != NULL && dst_se != NULL);
1956 VERIFY(src_se == NULL || *src_sl != NULL);
1957 VERIFY(dst_se->se_addr->sa_family == af);
1958 VERIFY(src_se == NULL || src_se->se_addr->sa_family == af);
1959
1960 #if NECP
1961 inp_update_necp_policy(inp, src_se ? src_se->se_addr : NULL,
1962 dst_se ? dst_se->se_addr : NULL, ifscope);
1963 #endif /* NECP */
1964
1965 /* bind socket to the specified interface, if requested */
1966 if (ifscope != IFSCOPE_NONE &&
1967 (error = inp_bindif(inp, ifscope, NULL)) != 0)
1968 return (error);
1969
1970 /* if source address and/or port is specified, bind to it */
1971 if (src_se != NULL) {
1972 struct sockaddr *sa = src_se->se_addr;
1973 error = sobindlock(so, sa, 0); /* already locked */
1974 if (error != 0)
1975 return (error);
1976 }
1977
1978 switch (af) {
1979 case AF_INET:
1980 error = udp_connect(so, dst_se->se_addr, p);
1981 break;
1982 #if INET6
1983 case AF_INET6:
1984 error = udp6_connect(so, dst_se->se_addr, p);
1985 break;
1986 #endif /* INET6 */
1987 default:
1988 VERIFY(0);
1989 /* NOTREACHED */
1990 }
1991
1992 if (error != 0)
1993 return (error);
1994
1995 /*
1996 * If there is data, copy it. DATA_IDEMPOTENT is ignored.
1997 * CONNECT_RESUME_ON_READ_WRITE is ignored.
1998 */
1999 if (uio != NULL) {
2000 socket_unlock(so, 0);
2001
2002 VERIFY(bytes_written != NULL);
2003
2004 datalen = uio_resid(uio);
2005 error = so->so_proto->pr_usrreqs->pru_sosend(so, NULL,
2006 (uio_t)uio, NULL, NULL, 0);
2007 socket_lock(so, 0);
2008
2009 /* If error returned is EMSGSIZE, for example, disconnect */
2010 if (error == 0 || error == EWOULDBLOCK)
2011 *bytes_written = datalen - uio_resid(uio);
2012 else
2013 (void)so->so_proto->pr_usrreqs->pru_disconnectx(so,
2014 SAE_ASSOCID_ANY, SAE_CONNID_ANY);
2015 /*
2016 * mask the EWOULDBLOCK error so that the caller
2017 * knows that atleast the connect was successful.
2018 */
2019 if (error == EWOULDBLOCK)
2020 error = 0;
2021 }
2022
2023 if (error == 0 && pcid != NULL)
2024 *pcid = 1; /* there is only 1 connection for UDP */
2025
2026 return (error);
2027 }
2028
2029 static int
2030 udp_connectx(struct socket *so, struct sockaddr_list **src_sl,
2031 struct sockaddr_list **dst_sl, struct proc *p, uint32_t ifscope,
2032 sae_associd_t aid, sae_connid_t *pcid, uint32_t flags, void *arg,
2033 uint32_t arglen, struct uio *uio, user_ssize_t *bytes_written)
2034 {
2035 return (udp_connectx_common(so, AF_INET, src_sl, dst_sl,
2036 p, ifscope, aid, pcid, flags, arg, arglen, uio, bytes_written));
2037 }
2038
2039 static int
2040 udp_detach(struct socket *so)
2041 {
2042 struct inpcb *inp;
2043
2044 inp = sotoinpcb(so);
2045 if (inp == NULL) {
2046 panic("%s: so=%p null inp\n", __func__, so);
2047 /* NOTREACHED */
2048 }
2049
2050 /*
2051 * If this is a socket that does not want to wakeup the device
2052 * for it's traffic, the application might be waiting for
2053 * close to complete before going to sleep. Send a notification
2054 * for this kind of sockets
2055 */
2056 if (so->so_options & SO_NOWAKEFROMSLEEP)
2057 socket_post_kev_msg_closed(so);
2058
2059 in_pcbdetach(inp);
2060 inp->inp_state = INPCB_STATE_DEAD;
2061 return (0);
2062 }
2063
2064 static int
2065 udp_disconnect(struct socket *so)
2066 {
2067 struct inpcb *inp;
2068
2069 inp = sotoinpcb(so);
2070 if (inp == NULL
2071 #if NECP
2072 || (necp_socket_should_use_flow_divert(inp))
2073 #endif /* NECP */
2074 )
2075 return (inp == NULL ? EINVAL : EPROTOTYPE);
2076 if (inp->inp_faddr.s_addr == INADDR_ANY)
2077 return (ENOTCONN);
2078
2079 in_pcbdisconnect(inp);
2080
2081 /* reset flow controlled state, just in case */
2082 inp_reset_fc_state(inp);
2083
2084 inp->inp_laddr.s_addr = INADDR_ANY;
2085 so->so_state &= ~SS_ISCONNECTED; /* XXX */
2086 inp->inp_last_outifp = NULL;
2087 return (0);
2088 }
2089
2090 static int
2091 udp_disconnectx(struct socket *so, sae_associd_t aid, sae_connid_t cid)
2092 {
2093 #pragma unused(cid)
2094 if (aid != SAE_ASSOCID_ANY && aid != SAE_ASSOCID_ALL)
2095 return (EINVAL);
2096
2097 return (udp_disconnect(so));
2098 }
2099
2100 static int
2101 udp_send(struct socket *so, int flags, struct mbuf *m,
2102 struct sockaddr *addr, struct mbuf *control, struct proc *p)
2103 {
2104 #ifndef FLOW_DIVERT
2105 #pragma unused(flags)
2106 #endif /* !(FLOW_DIVERT) */
2107 struct inpcb *inp;
2108
2109 inp = sotoinpcb(so);
2110 if (inp == NULL) {
2111 if (m != NULL)
2112 m_freem(m);
2113 if (control != NULL)
2114 m_freem(control);
2115 return (EINVAL);
2116 }
2117
2118 #if NECP
2119 #if FLOW_DIVERT
2120 if (necp_socket_should_use_flow_divert(inp)) {
2121 /* Implicit connect */
2122 return (flow_divert_implicit_data_out(so, flags, m, addr, control, p));
2123 }
2124 #endif /* FLOW_DIVERT */
2125 #endif /* NECP */
2126
2127 return (udp_output(inp, m, addr, control, p));
2128 }
2129
2130 int
2131 udp_shutdown(struct socket *so)
2132 {
2133 struct inpcb *inp;
2134
2135 inp = sotoinpcb(so);
2136 if (inp == NULL)
2137 return (EINVAL);
2138 socantsendmore(so);
2139 return (0);
2140 }
2141
2142 int
2143 udp_lock(struct socket *so, int refcount, void *debug)
2144 {
2145 void *lr_saved;
2146
2147 if (debug == NULL)
2148 lr_saved = __builtin_return_address(0);
2149 else
2150 lr_saved = debug;
2151
2152 if (so->so_pcb != NULL) {
2153 lck_mtx_assert(&((struct inpcb *)so->so_pcb)->inpcb_mtx,
2154 LCK_MTX_ASSERT_NOTOWNED);
2155 lck_mtx_lock(&((struct inpcb *)so->so_pcb)->inpcb_mtx);
2156 } else {
2157 panic("%s: so=%p NO PCB! lr=%p lrh= %s\n", __func__,
2158 so, lr_saved, solockhistory_nr(so));
2159 /* NOTREACHED */
2160 }
2161 if (refcount)
2162 so->so_usecount++;
2163
2164 so->lock_lr[so->next_lock_lr] = lr_saved;
2165 so->next_lock_lr = (so->next_lock_lr+1) % SO_LCKDBG_MAX;
2166 return (0);
2167 }
2168
2169 int
2170 udp_unlock(struct socket *so, int refcount, void *debug)
2171 {
2172 void *lr_saved;
2173
2174 if (debug == NULL)
2175 lr_saved = __builtin_return_address(0);
2176 else
2177 lr_saved = debug;
2178
2179 if (refcount)
2180 so->so_usecount--;
2181
2182 if (so->so_pcb == NULL) {
2183 panic("%s: so=%p NO PCB! lr=%p lrh= %s\n", __func__,
2184 so, lr_saved, solockhistory_nr(so));
2185 /* NOTREACHED */
2186 } else {
2187 lck_mtx_assert(&((struct inpcb *)so->so_pcb)->inpcb_mtx,
2188 LCK_MTX_ASSERT_OWNED);
2189 so->unlock_lr[so->next_unlock_lr] = lr_saved;
2190 so->next_unlock_lr = (so->next_unlock_lr+1) % SO_LCKDBG_MAX;
2191 lck_mtx_unlock(&((struct inpcb *)so->so_pcb)->inpcb_mtx);
2192 }
2193 return (0);
2194 }
2195
2196 lck_mtx_t *
2197 udp_getlock(struct socket *so, int locktype)
2198 {
2199 #pragma unused(locktype)
2200 struct inpcb *inp = sotoinpcb(so);
2201
2202 if (so->so_pcb == NULL) {
2203 panic("%s: so=%p NULL so_pcb lrh= %s\n", __func__,
2204 so, solockhistory_nr(so));
2205 /* NOTREACHED */
2206 }
2207 return (&inp->inpcb_mtx);
2208 }
2209
2210 /*
2211 * UDP garbage collector callback (inpcb_timer_func_t).
2212 *
2213 * Returns > 0 to keep timer active.
2214 */
2215 static void
2216 udp_gc(struct inpcbinfo *ipi)
2217 {
2218 struct inpcb *inp, *inpnxt;
2219 struct socket *so;
2220
2221 if (lck_rw_try_lock_exclusive(ipi->ipi_lock) == FALSE) {
2222 if (udp_gc_done == TRUE) {
2223 udp_gc_done = FALSE;
2224 /* couldn't get the lock, must lock next time */
2225 atomic_add_32(&ipi->ipi_gc_req.intimer_fast, 1);
2226 return;
2227 }
2228 lck_rw_lock_exclusive(ipi->ipi_lock);
2229 }
2230
2231 udp_gc_done = TRUE;
2232
2233 for (inp = udb.lh_first; inp != NULL; inp = inpnxt) {
2234 inpnxt = inp->inp_list.le_next;
2235
2236 /*
2237 * Skip unless it's STOPUSING; garbage collector will
2238 * be triggered by in_pcb_checkstate() upon setting
2239 * wantcnt to that value. If the PCB is already dead,
2240 * keep gc active to anticipate wantcnt changing.
2241 */
2242 if (inp->inp_wantcnt != WNT_STOPUSING)
2243 continue;
2244
2245 /*
2246 * Skip if busy, no hurry for cleanup. Keep gc active
2247 * and try the lock again during next round.
2248 */
2249 if (!lck_mtx_try_lock(&inp->inpcb_mtx)) {
2250 atomic_add_32(&ipi->ipi_gc_req.intimer_fast, 1);
2251 continue;
2252 }
2253
2254 /*
2255 * Keep gc active unless usecount is 0.
2256 */
2257 so = inp->inp_socket;
2258 if (so->so_usecount == 0) {
2259 if (inp->inp_state != INPCB_STATE_DEAD) {
2260 #if INET6
2261 if (SOCK_CHECK_DOM(so, PF_INET6))
2262 in6_pcbdetach(inp);
2263 else
2264 #endif /* INET6 */
2265 in_pcbdetach(inp);
2266 }
2267 in_pcbdispose(inp);
2268 } else {
2269 lck_mtx_unlock(&inp->inpcb_mtx);
2270 atomic_add_32(&ipi->ipi_gc_req.intimer_fast, 1);
2271 }
2272 }
2273 lck_rw_done(ipi->ipi_lock);
2274
2275 return;
2276 }
2277
2278 static int
2279 udp_getstat SYSCTL_HANDLER_ARGS
2280 {
2281 #pragma unused(oidp, arg1, arg2)
2282 if (req->oldptr == USER_ADDR_NULL)
2283 req->oldlen = (size_t)sizeof (struct udpstat);
2284
2285 return (SYSCTL_OUT(req, &udpstat, MIN(sizeof (udpstat), req->oldlen)));
2286 }
2287
2288 void
2289 udp_in_cksum_stats(u_int32_t len)
2290 {
2291 udpstat.udps_rcv_swcsum++;
2292 udpstat.udps_rcv_swcsum_bytes += len;
2293 }
2294
2295 void
2296 udp_out_cksum_stats(u_int32_t len)
2297 {
2298 udpstat.udps_snd_swcsum++;
2299 udpstat.udps_snd_swcsum_bytes += len;
2300 }
2301
2302 #if INET6
2303 void
2304 udp_in6_cksum_stats(u_int32_t len)
2305 {
2306 udpstat.udps_rcv6_swcsum++;
2307 udpstat.udps_rcv6_swcsum_bytes += len;
2308 }
2309
2310 void
2311 udp_out6_cksum_stats(u_int32_t len)
2312 {
2313 udpstat.udps_snd6_swcsum++;
2314 udpstat.udps_snd6_swcsum_bytes += len;
2315 }
2316 #endif /* INET6 */
2317
2318 /*
2319 * Checksum extended UDP header and data.
2320 */
2321 static int
2322 udp_input_checksum(struct mbuf *m, struct udphdr *uh, int off, int ulen)
2323 {
2324 struct ifnet *ifp = m->m_pkthdr.rcvif;
2325 struct ip *ip = mtod(m, struct ip *);
2326 struct ipovly *ipov = (struct ipovly *)ip;
2327
2328 if (uh->uh_sum == 0) {
2329 udpstat.udps_nosum++;
2330 return (0);
2331 }
2332
2333 if ((hwcksum_rx || (ifp->if_flags & IFF_LOOPBACK) ||
2334 (m->m_pkthdr.pkt_flags & PKTF_LOOP)) &&
2335 (m->m_pkthdr.csum_flags & CSUM_DATA_VALID)) {
2336 if (m->m_pkthdr.csum_flags & CSUM_PSEUDO_HDR) {
2337 uh->uh_sum = m->m_pkthdr.csum_rx_val;
2338 } else {
2339 uint16_t sum = m->m_pkthdr.csum_rx_val;
2340 uint16_t start = m->m_pkthdr.csum_rx_start;
2341
2342 /*
2343 * Perform 1's complement adjustment of octets
2344 * that got included/excluded in the hardware-
2345 * calculated checksum value. Ignore cases
2346 * where the value includes or excludes the
2347 * IP header span, as the sum for those octets
2348 * would already be 0xffff and thus no-op.
2349 */
2350 if ((m->m_pkthdr.csum_flags & CSUM_PARTIAL) &&
2351 start != 0 && (off - start) != off) {
2352 #if BYTE_ORDER != BIG_ENDIAN
2353 if (start < off) {
2354 HTONS(ip->ip_len);
2355 HTONS(ip->ip_off);
2356 }
2357 #endif /* BYTE_ORDER != BIG_ENDIAN */
2358 /* callee folds in sum */
2359 sum = m_adj_sum16(m, start, off, sum);
2360 #if BYTE_ORDER != BIG_ENDIAN
2361 if (start < off) {
2362 NTOHS(ip->ip_off);
2363 NTOHS(ip->ip_len);
2364 }
2365 #endif /* BYTE_ORDER != BIG_ENDIAN */
2366 }
2367
2368 /* callee folds in sum */
2369 uh->uh_sum = in_pseudo(ip->ip_src.s_addr,
2370 ip->ip_dst.s_addr, sum + htonl(ulen + IPPROTO_UDP));
2371 }
2372 uh->uh_sum ^= 0xffff;
2373 } else {
2374 uint16_t ip_sum;
2375 char b[9];
2376
2377 bcopy(ipov->ih_x1, b, sizeof (ipov->ih_x1));
2378 bzero(ipov->ih_x1, sizeof (ipov->ih_x1));
2379 ip_sum = ipov->ih_len;
2380 ipov->ih_len = uh->uh_ulen;
2381 uh->uh_sum = in_cksum(m, ulen + sizeof (struct ip));
2382 bcopy(b, ipov->ih_x1, sizeof (ipov->ih_x1));
2383 ipov->ih_len = ip_sum;
2384
2385 udp_in_cksum_stats(ulen);
2386 }
2387
2388 if (uh->uh_sum != 0) {
2389 udpstat.udps_badsum++;
2390 IF_UDP_STATINC(ifp, badchksum);
2391 return (-1);
2392 }
2393
2394 return (0);
2395 }
2396
2397 extern void
2398 udp_fill_keepalive_offload_frames(ifnet_t ifp,
2399 struct ifnet_keepalive_offload_frame *frames_array,
2400 u_int32_t frames_array_count, size_t frame_data_offset,
2401 u_int32_t *used_frames_count);
2402
2403 void
2404 udp_fill_keepalive_offload_frames(ifnet_t ifp,
2405 struct ifnet_keepalive_offload_frame *frames_array,
2406 u_int32_t frames_array_count, size_t frame_data_offset,
2407 u_int32_t *used_frames_count)
2408 {
2409 struct inpcb *inp;
2410 inp_gen_t gencnt;
2411 u_int32_t frame_index = *used_frames_count;
2412
2413 if (ifp == NULL || frames_array == NULL ||
2414 frames_array_count == 0 ||
2415 frame_index >= frames_array_count ||
2416 frame_data_offset >= IFNET_KEEPALIVE_OFFLOAD_FRAME_DATA_SIZE)
2417 return;
2418
2419 lck_rw_lock_shared(udbinfo.ipi_lock);
2420 gencnt = udbinfo.ipi_gencnt;
2421 LIST_FOREACH(inp, udbinfo.ipi_listhead, inp_list) {
2422 struct socket *so;
2423 u_int8_t *data;
2424 struct ifnet_keepalive_offload_frame *frame;
2425 struct mbuf *m = NULL;
2426
2427 if (frame_index >= frames_array_count)
2428 break;
2429
2430 if (inp->inp_gencnt > gencnt ||
2431 inp->inp_state == INPCB_STATE_DEAD)
2432 continue;
2433
2434 if ((so = inp->inp_socket) == NULL ||
2435 (so->so_state & SS_DEFUNCT))
2436 continue;
2437 /*
2438 * check for keepalive offload flag without socket
2439 * lock to avoid a deadlock
2440 */
2441 if (!(inp->inp_flags2 & INP2_KEEPALIVE_OFFLOAD)) {
2442 continue;
2443 }
2444
2445 udp_lock(so, 1, 0);
2446 if (!(inp->inp_vflag & (INP_IPV4 | INP_IPV6))) {
2447 udp_unlock(so, 1, 0);
2448 continue;
2449 }
2450 if ((inp->inp_vflag & INP_IPV4) &&
2451 (inp->inp_laddr.s_addr == INADDR_ANY ||
2452 inp->inp_faddr.s_addr == INADDR_ANY)) {
2453 udp_unlock(so, 1, 0);
2454 continue;
2455 }
2456 if ((inp->inp_vflag & INP_IPV6) &&
2457 (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr) ||
2458 IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr))) {
2459 udp_unlock(so, 1, 0);
2460 continue;
2461 }
2462 if (inp->inp_lport == 0 || inp->inp_fport == 0) {
2463 udp_unlock(so, 1, 0);
2464 continue;
2465 }
2466 if (inp->inp_last_outifp == NULL ||
2467 inp->inp_last_outifp->if_index != ifp->if_index) {
2468 udp_unlock(so, 1, 0);
2469 continue;
2470 }
2471 if ((inp->inp_vflag & INP_IPV4)) {
2472 if ((frame_data_offset + sizeof(struct udpiphdr) +
2473 inp->inp_keepalive_datalen) >
2474 IFNET_KEEPALIVE_OFFLOAD_FRAME_DATA_SIZE) {
2475 udp_unlock(so, 1, 0);
2476 continue;
2477 }
2478 if ((sizeof(struct udpiphdr) +
2479 inp->inp_keepalive_datalen) > _MHLEN) {
2480 udp_unlock(so, 1, 0);
2481 continue;
2482 }
2483 } else {
2484 if ((frame_data_offset + sizeof(struct ip6_hdr) +
2485 sizeof(struct udphdr) +
2486 inp->inp_keepalive_datalen) >
2487 IFNET_KEEPALIVE_OFFLOAD_FRAME_DATA_SIZE) {
2488 udp_unlock(so, 1, 0);
2489 continue;
2490 }
2491 if ((sizeof(struct ip6_hdr) + sizeof(struct udphdr) +
2492 inp->inp_keepalive_datalen) > _MHLEN) {
2493 udp_unlock(so, 1, 0);
2494 continue;
2495 }
2496 }
2497 MGETHDR(m, M_WAIT, MT_HEADER);
2498 if (m == NULL) {
2499 udp_unlock(so, 1, 0);
2500 continue;
2501 }
2502 /*
2503 * This inp has all the information that is needed to
2504 * generate an offload frame.
2505 */
2506 if (inp->inp_vflag & INP_IPV4) {
2507 struct ip *ip;
2508 struct udphdr *udp;
2509
2510 frame = &frames_array[frame_index];
2511 frame->length = frame_data_offset +
2512 sizeof(struct udpiphdr) +
2513 inp->inp_keepalive_datalen;
2514 frame->ether_type =
2515 IFNET_KEEPALIVE_OFFLOAD_FRAME_ETHERTYPE_IPV4;
2516 frame->interval = inp->inp_keepalive_interval;
2517 switch (inp->inp_keepalive_type) {
2518 case UDP_KEEPALIVE_OFFLOAD_TYPE_AIRPLAY:
2519 frame->type =
2520 IFNET_KEEPALIVE_OFFLOAD_FRAME_AIRPLAY;
2521 break;
2522 default:
2523 break;
2524 }
2525 data = mtod(m, u_int8_t *);
2526 bzero(data, sizeof(struct udpiphdr));
2527 ip = (__typeof__(ip))(void *)data;
2528 udp = (__typeof__(udp))(void *) (data +
2529 sizeof(struct ip));
2530 m->m_len = sizeof(struct udpiphdr);
2531 data = data + sizeof(struct udpiphdr);
2532 if (inp->inp_keepalive_datalen > 0 &&
2533 inp->inp_keepalive_data != NULL) {
2534 bcopy(inp->inp_keepalive_data, data,
2535 inp->inp_keepalive_datalen);
2536 m->m_len += inp->inp_keepalive_datalen;
2537 }
2538 m->m_pkthdr.len = m->m_len;
2539
2540 ip->ip_v = IPVERSION;
2541 ip->ip_hl = (sizeof(struct ip) >> 2);
2542 ip->ip_p = IPPROTO_UDP;
2543 ip->ip_len = htons(sizeof(struct udpiphdr) +
2544 (u_short)inp->inp_keepalive_datalen);
2545 ip->ip_ttl = inp->inp_ip_ttl;
2546 ip->ip_tos = inp->inp_ip_tos;
2547 ip->ip_src = inp->inp_laddr;
2548 ip->ip_dst = inp->inp_faddr;
2549 ip->ip_sum = in_cksum_hdr_opt(ip);
2550
2551 udp->uh_sport = inp->inp_lport;
2552 udp->uh_dport = inp->inp_fport;
2553 udp->uh_ulen = htons(sizeof(struct udphdr) +
2554 (u_short)inp->inp_keepalive_datalen);
2555
2556 if (!(inp->inp_flags & INP_UDP_NOCKSUM)) {
2557 udp->uh_sum = in_pseudo(ip->ip_src.s_addr,
2558 ip->ip_dst.s_addr,
2559 htons(sizeof(struct udphdr) +
2560 (u_short)inp->inp_keepalive_datalen +
2561 IPPROTO_UDP));
2562 m->m_pkthdr.csum_flags = CSUM_UDP;
2563 m->m_pkthdr.csum_data = offsetof(struct udphdr,
2564 uh_sum);
2565 }
2566 m->m_pkthdr.pkt_proto = IPPROTO_UDP;
2567 in_delayed_cksum(m);
2568 bcopy(m->m_data, frame->data + frame_data_offset,
2569 m->m_len);
2570 } else {
2571 struct ip6_hdr *ip6;
2572 struct udphdr *udp6;
2573
2574 VERIFY(inp->inp_vflag & INP_IPV6);
2575 frame = &frames_array[frame_index];
2576 frame->length = frame_data_offset +
2577 sizeof(struct ip6_hdr) +
2578 sizeof(struct udphdr) +
2579 inp->inp_keepalive_datalen;
2580 frame->ether_type =
2581 IFNET_KEEPALIVE_OFFLOAD_FRAME_ETHERTYPE_IPV6;
2582 frame->interval = inp->inp_keepalive_interval;
2583 switch (inp->inp_keepalive_type) {
2584 case UDP_KEEPALIVE_OFFLOAD_TYPE_AIRPLAY:
2585 frame->type =
2586 IFNET_KEEPALIVE_OFFLOAD_FRAME_AIRPLAY;
2587 break;
2588 default:
2589 break;
2590 }
2591 data = mtod(m, u_int8_t *);
2592 bzero(data, sizeof(struct ip6_hdr) + sizeof(struct udphdr));
2593 ip6 = (__typeof__(ip6))(void *)data;
2594 udp6 = (__typeof__(udp6))(void *)(data +
2595 sizeof(struct ip6_hdr));
2596 m->m_len = sizeof(struct ip6_hdr) +
2597 sizeof(struct udphdr);
2598 data = data + (sizeof(struct ip6_hdr) +
2599 sizeof(struct udphdr));
2600 if (inp->inp_keepalive_datalen > 0 &&
2601 inp->inp_keepalive_data != NULL) {
2602 bcopy(inp->inp_keepalive_data, data,
2603 inp->inp_keepalive_datalen);
2604 m->m_len += inp->inp_keepalive_datalen;
2605 }
2606 m->m_pkthdr.len = m->m_len;
2607 ip6->ip6_flow = inp->inp_flow & IPV6_FLOWINFO_MASK;
2608 ip6->ip6_vfc &= ~IPV6_VERSION_MASK;
2609 ip6->ip6_vfc |= IPV6_VERSION;
2610 ip6->ip6_nxt = IPPROTO_UDP;
2611 ip6->ip6_hlim = ip6_defhlim;
2612 ip6->ip6_plen = htons(sizeof(struct udphdr) +
2613 (u_short)inp->inp_keepalive_datalen);
2614 ip6->ip6_src = inp->in6p_laddr;
2615 if (IN6_IS_SCOPE_EMBED(&ip6->ip6_src))
2616 ip6->ip6_src.s6_addr16[1] = 0;
2617
2618 ip6->ip6_dst = inp->in6p_faddr;
2619 if (IN6_IS_SCOPE_EMBED(&ip6->ip6_dst))
2620 ip6->ip6_dst.s6_addr16[1] = 0;
2621
2622 udp6->uh_sport = inp->in6p_lport;
2623 udp6->uh_dport = inp->in6p_fport;
2624 udp6->uh_ulen = htons(sizeof(struct udphdr) +
2625 (u_short)inp->inp_keepalive_datalen);
2626 if (!(inp->inp_flags & INP_UDP_NOCKSUM)) {
2627 udp6->uh_sum = in6_pseudo(&ip6->ip6_src,
2628 &ip6->ip6_dst,
2629 htonl(sizeof(struct udphdr) +
2630 (u_short)inp->inp_keepalive_datalen +
2631 IPPROTO_UDP));
2632 m->m_pkthdr.csum_flags = CSUM_UDPIPV6;
2633 m->m_pkthdr.csum_data = offsetof(struct udphdr,
2634 uh_sum);
2635 }
2636 m->m_pkthdr.pkt_proto = IPPROTO_UDP;
2637 in6_delayed_cksum(m);
2638 bcopy(m->m_data, frame->data + frame_data_offset,
2639 m->m_len);
2640 }
2641 if (m != NULL) {
2642 m_freem(m);
2643 m = NULL;
2644 }
2645 frame_index++;
2646 udp_unlock(so, 1, 0);
2647 }
2648 lck_rw_done(udbinfo.ipi_lock);
2649 *used_frames_count = frame_index;
2650 }
mirror of XNU