1 /*
2 * Copyright (c) 2000-2024 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
30 /* $FreeBSD: src/sys/netinet6/udp6_output.c,v 1.1.2.3 2001/08/31 13:49:58 jlemon Exp $ */
31 /* $KAME: udp6_output.c,v 1.31 2001/05/21 16:39:15 jinmei Exp $ */
32
33 /*
34 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
35 * All rights reserved.
36 *
37 * Redistribution and use in source and binary forms, with or without
38 * modification, are permitted provided that the following conditions
39 * are met:
40 * 1. Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * 2. Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in the
44 * documentation and/or other materials provided with the distribution.
45 * 3. Neither the name of the project nor the names of its contributors
46 * may be used to endorse or promote products derived from this software
47 * without specific prior written permission.
48 *
49 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
50 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
53 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59 * SUCH DAMAGE.
60 */
61
62 /*
63 * Copyright (c) 1982, 1986, 1989, 1993
64 * The Regents of the University of California. All rights reserved.
65 *
66 * Redistribution and use in source and binary forms, with or without
67 * modification, are permitted provided that the following conditions
68 * are met:
69 * 1. Redistributions of source code must retain the above copyright
70 * notice, this list of conditions and the following disclaimer.
71 * 2. Redistributions in binary form must reproduce the above copyright
72 * notice, this list of conditions and the following disclaimer in the
73 * documentation and/or other materials provided with the distribution.
74 * 3. All advertising materials mentioning features or use of this software
75 * must display the following acknowledgement:
76 * This product includes software developed by the University of
77 * California, Berkeley and its contributors.
78 * 4. Neither the name of the University nor the names of its contributors
79 * may be used to endorse or promote products derived from this software
80 * without specific prior written permission.
81 *
82 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
83 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
84 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
85 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
86 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
87 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
88 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
89 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
90 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
91 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
92 * SUCH DAMAGE.
93 *
94 * @(#)udp_var.h 8.1 (Berkeley) 6/10/93
95 */
96
97 #include <sys/param.h>
98 #include <sys/malloc.h>
99 #include <sys/mbuf.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/proc.h>
108 #include <sys/syslog.h>
109
110 #include <machine/endian.h>
111
112 #include <net/if.h>
113 #include <net/route.h>
114 #include <net/if_types.h>
115 #include <net/ntstat.h>
116 #include <net/droptap.h>
117
118 #include <netinet/in.h>
119 #include <netinet/in_var.h>
120 #include <netinet/in_systm.h>
121 #include <netinet/in_tclass.h>
122 #include <netinet/ip.h>
123 #include <netinet/ip_var.h>
124 #include <netinet/in_pcb.h>
125 #include <netinet/udp.h>
126 #include <netinet/udp_var.h>
127 #include <netinet/ip6.h>
128 #include <netinet6/ip6_var.h>
129 #include <netinet6/in6_pcb.h>
130 #include <netinet6/udp6_var.h>
131 #include <netinet/icmp6.h>
132 #include <netinet6/ip6protosw.h>
133
134 #if NECP
135 #include <net/necp.h>
136 #endif /* NECP */
137
138 #include <net/net_osdep.h>
139
140 #if CONTENT_FILTER
141 #include <net/content_filter.h>
142 #endif /* CONTENT_FILTER */
143
144 #include <net/sockaddr_utils.h>
145
146 /*
147 * UDP protocol inplementation.
148 * Per RFC 768, August, 1980.
149 */
150 int
udp6_output(struct in6pcb * in6p,struct mbuf * m,struct sockaddr * addr6,struct mbuf * control,struct proc * p)151 udp6_output(struct in6pcb *in6p, struct mbuf *m, struct sockaddr *addr6,
152 struct mbuf *control, struct proc *p)
153 {
154 u_int32_t ulen = m->m_pkthdr.len;
155 u_int32_t plen = sizeof(struct udphdr) + ulen;
156 struct ip6_hdr *ip6;
157 struct udphdr *__single udp6;
158 struct in6_addr *__single laddr, *__single faddr;
159 u_short fport;
160 int error = 0;
161 struct ip6_pktopts opt, *__single optp = NULL;
162 struct ip6_moptions *__single im6o;
163 int af = AF_INET6, hlen = sizeof(struct ip6_hdr);
164 int flags;
165 struct sockaddr_in6 tmp;
166 struct in6_addr storage;
167 int sotc = SO_TC_UNSPEC;
168 int netsvctype = _NET_SERVICE_TYPE_UNSPEC;
169 struct ip6_out_args ip6oa;
170 struct flowadv *__single adv = &ip6oa.ip6oa_flowadv;
171 struct socket *__single so = in6p->in6p_socket;
172 struct route_in6 ro;
173 int flowadv = 0;
174 bool sndinprog_cnt_used = false;
175 #if CONTENT_FILTER
176 struct m_tag *__single cfil_tag = NULL;
177 bool cfil_faddr_use = false;
178 uint32_t cfil_so_state_change_cnt = 0;
179 struct sockaddr *__single cfil_faddr = NULL;
180 struct sockaddr_in6 *__single cfil_sin6 = NULL;
181 #endif
182 bool check_qos_marking_again = (so->so_flags1 & SOF1_QOSMARKING_POLICY_OVERRIDE) ? FALSE : TRUE;
183 uint32_t lifscope = IFSCOPE_NONE, fifscope = IFSCOPE_NONE;
184 drop_reason_t drop_reason = DROP_REASON_UNSPECIFIED;
185
186 bzero(&ip6oa, sizeof(ip6oa));
187 ip6oa.ip6oa_boundif = IFSCOPE_NONE;
188 ip6oa.ip6oa_flags = IP6OAF_SELECT_SRCIF;
189
190 /* Enable flow advisory only when connected */
191 flowadv = (so->so_state & SS_ISCONNECTED) ? 1 : 0;
192
193 if (flowadv && INP_WAIT_FOR_IF_FEEDBACK(in6p)) {
194 error = ENOBUFS;
195 drop_reason = DROP_REASON_IP_ENOBUFS;
196 goto release;
197 }
198
199 if (in6p->inp_flags & INP_BOUND_IF) {
200 ip6oa.ip6oa_boundif = in6p->inp_boundifp->if_index;
201 ip6oa.ip6oa_flags |= IP6OAF_BOUND_IF;
202 } else if (!in6_embedded_scope && IN6_IS_SCOPE_EMBED(&in6p->in6p_faddr)) {
203 ip6oa.ip6oa_boundif = in6p->inp_fifscope;
204 ip6oa.ip6oa_flags |= IP6OAF_BOUND_IF;
205 }
206 if (INP_NO_CELLULAR(in6p)) {
207 ip6oa.ip6oa_flags |= IP6OAF_NO_CELLULAR;
208 }
209 if (INP_NO_EXPENSIVE(in6p)) {
210 ip6oa.ip6oa_flags |= IP6OAF_NO_EXPENSIVE;
211 }
212 if (INP_NO_CONSTRAINED(in6p)) {
213 ip6oa.ip6oa_flags |= IP6OAF_NO_CONSTRAINED;
214 }
215 if (INP_AWDL_UNRESTRICTED(in6p)) {
216 ip6oa.ip6oa_flags |= IP6OAF_AWDL_UNRESTRICTED;
217 }
218 if (INP_INTCOPROC_ALLOWED(in6p)) {
219 ip6oa.ip6oa_flags |= IP6OAF_INTCOPROC_ALLOWED;
220 }
221 if (INP_MANAGEMENT_ALLOWED(in6p)) {
222 ip6oa.ip6oa_flags |= IP6OAF_MANAGEMENT_ALLOWED;
223 }
224
225 #if CONTENT_FILTER
226 /*
227 * If socket is subject to UDP Content Filter and no addr is passed in,
228 * retrieve CFIL saved state from mbuf and use it if necessary.
229 */
230 if (CFIL_DGRAM_FILTERED(so) && !addr6) {
231 cfil_tag = cfil_dgram_get_socket_state(m, &cfil_so_state_change_cnt, NULL, &cfil_faddr, NULL);
232 if (cfil_tag) {
233 cfil_sin6 = SIN6(cfil_faddr);
234 if ((so->so_state_change_cnt != cfil_so_state_change_cnt) &&
235 (in6p->in6p_fport != cfil_sin6->sin6_port ||
236 !in6_are_addr_equal_scoped(&in6p->in6p_faddr, &cfil_sin6->sin6_addr, in6p->inp_fifscope, cfil_sin6->sin6_scope_id))) {
237 /*
238 * Socket is connected but socket state and dest addr/port changed.
239 * We need to use the saved faddr info.
240 */
241 cfil_faddr_use = true;
242 }
243 }
244 }
245 #endif
246
247 if (control) {
248 sotc = so_tc_from_control(control, &netsvctype);
249 if ((error = ip6_setpktopts(control, &opt,
250 in6p->in6p_outputopts, IPPROTO_UDP)) != 0) {
251 drop_reason = DROP_REASON_IP6_BAD_OPTION;
252 goto release;
253 }
254 optp = &opt;
255 } else {
256 optp = in6p->in6p_outputopts;
257 }
258
259 if (sotc == SO_TC_UNSPEC) {
260 sotc = so->so_traffic_class;
261 netsvctype = so->so_netsvctype;
262 }
263 ip6oa.ip6oa_sotc = sotc;
264 ip6oa.ip6oa_netsvctype = netsvctype;
265
266 in6p->inp_sndinprog_cnt++;
267 sndinprog_cnt_used = true;
268
269 if (addr6) {
270 /*
271 * IPv4 version of udp_output calls in_pcbconnect in this case,
272 * which has its costs.
273 *
274 * Since we saw no essential reason for calling in_pcbconnect,
275 * we get rid of such kind of logic, and call in6_selectsrc
276 * and in6_pcbsetport in order to fill in the local address
277 * and the local port.
278 */
279 struct sockaddr_in6 *__single sin6 = SIN6(addr6);
280
281 if (sin6->sin6_port == 0) {
282 error = EADDRNOTAVAIL;
283 drop_reason = DROP_REASON_IP_DST_ADDR_NO_AVAIL;
284 goto release;
285 }
286
287 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) {
288 /* how about ::ffff:0.0.0.0 case? */
289 error = EISCONN;
290 drop_reason = DROP_REASON_IP_EISCONN;
291 goto release;
292 }
293
294 /* protect *sin6 from overwrites */
295 tmp = *sin6;
296 sin6 = &tmp;
297
298 faddr = &sin6->sin6_addr;
299 fport = sin6->sin6_port; /* allow 0 port */
300
301 if (IN6_IS_ADDR_V4MAPPED(faddr)) {
302 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY)) {
303 /*
304 * I believe we should explicitly discard the
305 * packet when mapped addresses are disabled,
306 * rather than send the packet as an IPv6 one.
307 * If we chose the latter approach, the packet
308 * might be sent out on the wire based on the
309 * default route, the situation which we'd
310 * probably want to avoid.
311 * (20010421 [email protected])
312 */
313 error = EINVAL;
314 drop_reason = DROP_REASON_IP6_ONLY;
315 goto release;
316 } else {
317 af = AF_INET;
318 }
319 }
320
321 /* KAME hack: embed scopeid */
322 if (in6_embedscope(&sin6->sin6_addr, sin6, in6p, NULL,
323 optp, IN6_NULL_IF_EMBEDDED_SCOPE(&sin6->sin6_scope_id)) != 0) {
324 error = EINVAL;
325 drop_reason = DROP_REASON_IP6_BAD_SCOPE;
326 goto release;
327 }
328 fifscope = sin6->sin6_scope_id;
329
330 if (!IN6_IS_ADDR_V4MAPPED(faddr)) {
331 struct ifnet *__single src_ifp = NULL;
332 laddr = in6_selectsrc(sin6, optp,
333 in6p, &in6p->in6p_route, &src_ifp, &storage,
334 ip6oa.ip6oa_boundif, &error);
335 if (src_ifp != NULL) {
336 lifscope = src_ifp->if_index;
337 ifnet_release(src_ifp);
338 }
339 } else {
340 laddr = &in6p->in6p_laddr; /* XXX */
341 lifscope = in6p->inp_lifscope;
342 }
343 if (laddr == NULL) {
344 if (error == 0) {
345 error = EADDRNOTAVAIL;
346 }
347 drop_reason = DROP_REASON_IP_SRC_ADDR_NO_AVAIL;
348 goto release;
349 }
350 if (in6p->in6p_lport == 0 &&
351 (error = in6_pcbsetport(laddr, addr6, in6p, p, 0)) != 0) {
352 goto release;
353 }
354 } else {
355 if (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) {
356 error = ENOTCONN;
357 drop_reason = DROP_REASON_IP6_ADDR_UNSPECIFIED;
358 goto release;
359 }
360 laddr = &in6p->in6p_laddr;
361 faddr = &in6p->in6p_faddr;
362 fport = in6p->in6p_fport;
363 fifscope = in6p->inp_fifscope;
364 lifscope = in6p->inp_lifscope;
365 #if CONTENT_FILTER
366 if (cfil_faddr_use) {
367 faddr = &SIN6(cfil_faddr)->sin6_addr;
368 fport = SIN6(cfil_faddr)->sin6_port;
369 fifscope = SIN6(cfil_faddr)->sin6_scope_id;
370
371 /* Do not use cached route */
372 ROUTE_RELEASE(&in6p->in6p_route);
373 }
374 #endif
375 if (IN6_IS_ADDR_V4MAPPED(faddr)) {
376 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY)) {
377 /*
378 * XXX: this case would happen when the
379 * application sets the V6ONLY flag after
380 * connecting the foreign address.
381 * Such applications should be fixed,
382 * so we bark here.
383 */
384 log(LOG_INFO, "udp6_output: IPV6_V6ONLY "
385 "option was set for a connected socket\n");
386 error = EINVAL;
387 goto release;
388 } else {
389 af = AF_INET;
390 }
391 }
392 }
393
394 if (in6p->inp_flowhash == 0) {
395 inp_calc_flowhash(in6p);
396 ASSERT(in6p->inp_flowhash != 0);
397 }
398 /* update flowinfo - RFC 6437 */
399 if (in6p->inp_flow == 0 && in6p->in6p_flags & IN6P_AUTOFLOWLABEL) {
400 in6p->inp_flow &= ~IPV6_FLOWLABEL_MASK;
401 in6p->inp_flow |=
402 (htonl(ip6_randomflowlabel()) & IPV6_FLOWLABEL_MASK);
403 }
404
405 if (af == AF_INET) {
406 hlen = sizeof(struct ip);
407 }
408
409 if (fport == htons(53) && !(so->so_flags1 & SOF1_DNS_COUNTED)) {
410 so->so_flags1 |= SOF1_DNS_COUNTED;
411 INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_inet_dgram_dns);
412 }
413
414 /*
415 * Calculate data length and get a mbuf
416 * for UDP and IP6 headers.
417 */
418 M_PREPEND(m, hlen + sizeof(struct udphdr), M_DONTWAIT, 1);
419 if (m == 0) {
420 error = ENOBUFS;
421 drop_reason = DROP_REASON_IP_ENOBUFS;
422 goto release;
423 }
424
425 /*
426 * Stuff checksum and output datagram.
427 */
428 udp6 = (struct udphdr *)(void *)(mtod(m, caddr_t) + hlen);
429 udp6->uh_sport = in6p->in6p_lport; /* lport is always set in the PCB */
430 udp6->uh_dport = fport;
431 if (plen <= 0xffff) {
432 udp6->uh_ulen = htons((u_short)plen);
433 } else {
434 udp6->uh_ulen = 0;
435 }
436 udp6->uh_sum = 0;
437
438 switch (af) {
439 case AF_INET6:
440 ip6 = mtod(m, struct ip6_hdr *);
441 ip6->ip6_flow = in6p->inp_flow & IPV6_FLOWINFO_MASK;
442 ip6->ip6_vfc &= ~IPV6_VERSION_MASK;
443 ip6->ip6_vfc |= IPV6_VERSION;
444 #if 0 /* ip6_plen will be filled in ip6_output. */
445 ip6->ip6_plen = htons((u_short)plen);
446 #endif
447 ip6->ip6_nxt = IPPROTO_UDP;
448 ip6->ip6_hlim = in6_selecthlim(in6p, in6p->in6p_route.ro_rt ?
449 in6p->in6p_route.ro_rt->rt_ifp : NULL);
450 ip6->ip6_src = *laddr;
451 ip6->ip6_dst = *faddr;
452
453 udp6->uh_sum = in6_pseudo(laddr, faddr,
454 htonl(plen + IPPROTO_UDP));
455 m->m_pkthdr.csum_flags = (CSUM_UDPIPV6 | CSUM_ZERO_INVERT);
456 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
457
458 if (!IN6_IS_ADDR_UNSPECIFIED(laddr)) {
459 ip6oa.ip6oa_flags |= IP6OAF_BOUND_SRCADDR;
460 }
461
462 flags = IPV6_OUTARGS;
463
464 udp6stat.udp6s_opackets++;
465
466 #if NECP
467 {
468 necp_kernel_policy_id policy_id;
469 necp_kernel_policy_id skip_policy_id;
470 u_int32_t route_rule_id;
471 u_int32_t pass_flags;
472
473 /*
474 * We need a route to perform NECP route rule checks
475 */
476 if (net_qos_policy_restricted != 0 &&
477 ROUTE_UNUSABLE(&in6p->inp_route)) {
478 struct sockaddr_in6 to;
479 struct sockaddr_in6 from;
480
481 ROUTE_RELEASE(&in6p->inp_route);
482
483 SOCKADDR_ZERO(&from, sizeof(struct sockaddr_in6));
484 from.sin6_family = AF_INET6;
485 from.sin6_len = sizeof(struct sockaddr_in6);
486 from.sin6_addr = *laddr;
487
488 SOCKADDR_ZERO(&to, sizeof(struct sockaddr_in6));
489 to.sin6_family = AF_INET6;
490 to.sin6_len = sizeof(struct sockaddr_in6);
491 to.sin6_addr = *faddr;
492
493 in6p->inp_route.ro_dst.sa_family = AF_INET6;
494 in6p->inp_route.ro_dst.sa_len = sizeof(struct sockaddr_in6);
495 SIN6(&in6p->inp_route.ro_dst)->sin6_addr = *faddr;
496
497 if (!in6_embedded_scope) {
498 SIN6(&in6p->inp_route.ro_dst)->sin6_scope_id =
499 IN6_IS_SCOPE_EMBED(faddr) ? fifscope : IFSCOPE_NONE;
500 }
501 rtalloc_scoped(&in6p->inp_route, ip6oa.ip6oa_boundif);
502
503 inp_update_necp_policy(in6p, SA(&from),
504 SA(&to), ip6oa.ip6oa_boundif);
505 in6p->inp_policyresult.results.qos_marking_gencount = 0;
506 }
507
508 if (!necp_socket_is_allowed_to_send_recv_v6(in6p, in6p->in6p_lport, fport, laddr, faddr, NULL, 0, &policy_id, &route_rule_id, &skip_policy_id, &pass_flags)) {
509 error = EHOSTUNREACH;
510 drop_reason = DROP_REASON_IP_NECP_POLICY_DROP;
511 goto release;
512 }
513
514 necp_mark_packet_from_socket(m, in6p, policy_id, route_rule_id, skip_policy_id, pass_flags);
515
516 if (net_qos_policy_restricted != 0) {
517 necp_socket_update_qos_marking(in6p, in6p->in6p_route.ro_rt, route_rule_id);
518 }
519 }
520 #endif /* NECP */
521 if ((so->so_flags1 & SOF1_QOSMARKING_ALLOWED)) {
522 ip6oa.ip6oa_flags |= IP6OAF_QOSMARKING_ALLOWED;
523 }
524 if (check_qos_marking_again) {
525 ip6oa.ip6oa_flags |= IP6OAF_REDO_QOSMARKING_POLICY;
526 }
527 ip6oa.qos_marking_gencount = in6p->inp_policyresult.results.qos_marking_gencount;
528
529 #if IPSEC
530 if (in6p->in6p_sp != NULL && ipsec_setsocket(m, so) != 0) {
531 error = ENOBUFS;
532 drop_reason = DROP_REASON_IP_ENOBUFS;
533 goto release;
534 }
535 #endif /*IPSEC*/
536
537 /* In case of IPv4-mapped address used in previous send */
538 if (ROUTE_UNUSABLE(&in6p->in6p_route) ||
539 rt_key(in6p->in6p_route.ro_rt)->sa_family != AF_INET6) {
540 ROUTE_RELEASE(&in6p->in6p_route);
541 }
542
543 /* Copy the cached route and take an extra reference */
544 in6p_route_copyout(in6p, &ro);
545
546 set_packet_service_class(m, so, sotc, PKT_SCF_IPV6);
547
548 m->m_pkthdr.pkt_flowsrc = FLOWSRC_INPCB;
549 m->m_pkthdr.pkt_flowid = in6p->inp_flowhash;
550 m->m_pkthdr.pkt_proto = IPPROTO_UDP;
551 m->m_pkthdr.pkt_flags |= (PKTF_FLOW_ID | PKTF_FLOW_LOCALSRC);
552 if (flowadv) {
553 m->m_pkthdr.pkt_flags |= PKTF_FLOW_ADV;
554 }
555 m->m_pkthdr.tx_udp_pid = so->last_pid;
556 if (so->so_flags & SOF_DELEGATED) {
557 m->m_pkthdr.tx_udp_e_pid = so->e_pid;
558 } else {
559 m->m_pkthdr.tx_udp_e_pid = 0;
560 }
561 #if (DEBUG || DEVELOPMENT)
562 if (so->so_flags & SOF_MARK_WAKE_PKT) {
563 so->so_flags &= ~SOF_MARK_WAKE_PKT;
564 m->m_pkthdr.pkt_flags |= PKTF_WAKE_PKT;
565 }
566 #endif /* (DEBUG || DEVELOPMENT) */
567
568 im6o = in6p->in6p_moptions;
569 if (im6o != NULL) {
570 IM6O_LOCK(im6o);
571 IM6O_ADDREF_LOCKED(im6o);
572 if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) &&
573 im6o->im6o_multicast_ifp != NULL) {
574 in6p->in6p_last_outifp =
575 im6o->im6o_multicast_ifp;
576 #if SKYWALK
577 if (NETNS_TOKEN_VALID(&in6p->inp_netns_token)) {
578 netns_set_ifnet(&in6p->inp_netns_token,
579 in6p->in6p_last_outifp);
580 }
581 #endif /* SKYWALK */
582 }
583 IM6O_UNLOCK(im6o);
584 }
585
586 ip6_output_setdstifscope(m, fifscope, NULL);
587 ip6_output_setsrcifscope(m, lifscope, NULL);
588
589 socket_unlock(so, 0);
590 error = ip6_output(m, optp, &ro, flags, im6o, NULL, &ip6oa);
591 m = NULL;
592 socket_lock(so, 0);
593
594 if (im6o != NULL) {
595 IM6O_REMREF(im6o);
596 }
597
598 if (check_qos_marking_again) {
599 in6p->inp_policyresult.results.qos_marking_gencount = ip6oa.qos_marking_gencount;
600 if (ip6oa.ip6oa_flags & IP6OAF_QOSMARKING_ALLOWED) {
601 in6p->inp_socket->so_flags1 |= SOF1_QOSMARKING_ALLOWED;
602 } else {
603 in6p->inp_socket->so_flags1 &= ~SOF1_QOSMARKING_ALLOWED;
604 }
605 }
606
607 if (error == 0 && nstat_collect) {
608 stats_functional_type ifnet_count_type = stats_functional_type_none;
609
610 if (in6p->in6p_route.ro_rt != NULL) {
611 ifnet_count_type = IFNET_COUNT_TYPE(in6p->in6p_route.
612 ro_rt->rt_ifp);
613 }
614 INP_ADD_STAT(in6p, ifnet_count_type, txpackets, 1);
615 INP_ADD_STAT(in6p, ifnet_count_type, txbytes, ulen);
616 inp_set_activity_bitmap(in6p);
617 }
618
619 if (flowadv && (adv->code == FADV_FLOW_CONTROLLED ||
620 adv->code == FADV_SUSPENDED)) {
621 /*
622 * Return an error to indicate
623 * that the packet has been dropped.
624 */
625 error = ENOBUFS;
626 inp_set_fc_state(in6p, adv->code);
627 }
628
629 if (ro.ro_rt != NULL) {
630 struct ifnet *__single outif = ro.ro_rt->rt_ifp;
631
632 so->so_pktheadroom = (uint16_t)P2ROUNDUP(
633 sizeof(struct udphdr) +
634 hlen +
635 ifnet_hdrlen(outif) +
636 ifnet_mbuf_packetpreamblelen(outif),
637 sizeof(u_int32_t));
638 }
639
640 /* Synchronize PCB cached route */
641 in6p_route_copyin(in6p, &ro);
642
643 if (in6p->in6p_route.ro_rt != NULL) {
644 struct rtentry *__single rt = in6p->in6p_route.ro_rt;
645 struct ifnet *__single outif;
646
647 if (IS_LOCALNET_ROUTE(rt)) {
648 in6p->in6p_flags2 |= INP2_LAST_ROUTE_LOCAL;
649 } else {
650 in6p->in6p_flags2 &= ~INP2_LAST_ROUTE_LOCAL;
651 }
652
653 if (rt->rt_flags & RTF_MULTICAST) {
654 rt = NULL; /* unusable */
655 }
656 #if CONTENT_FILTER
657 /*
658 * Discard temporary route for cfil case
659 */
660 if (cfil_faddr_use) {
661 rt = NULL; /* unusable */
662 }
663 #endif
664
665 /*
666 * Always discard the cached route for unconnected
667 * socket or if it is a multicast route.
668 */
669 if (rt == NULL) {
670 ROUTE_RELEASE(&in6p->in6p_route);
671 }
672
673 /*
674 * If the destination route is unicast, update outif
675 * with that of the route interface used by IP.
676 */
677 if (rt != NULL) {
678 /*
679 * When an NECP IP tunnel policy forces the outbound interface,
680 * ip6_output_list() informs the transport layer what is the actual
681 * outgoing interface
682 */
683 if (ip6oa.ip6oa_flags & IP6OAF_BOUND_IF) {
684 outif = ifindex2ifnet[ip6oa.ip6oa_boundif];
685 } else {
686 outif = rt->rt_ifp;
687 }
688 if (outif != NULL && outif != in6p->in6p_last_outifp) {
689 in6p->in6p_last_outifp = outif;
690 #if SKYWALK
691 if (NETNS_TOKEN_VALID(&in6p->inp_netns_token)) {
692 netns_set_ifnet(&in6p->inp_netns_token,
693 in6p->in6p_last_outifp);
694 }
695 #endif /* SKYWALK */
696
697 so->so_pktheadroom = (uint16_t)P2ROUNDUP(
698 sizeof(struct udphdr) +
699 hlen +
700 ifnet_hdrlen(outif) +
701 ifnet_mbuf_packetpreamblelen(outif),
702 sizeof(u_int32_t));
703 }
704 }
705 } else {
706 ROUTE_RELEASE(&in6p->in6p_route);
707 }
708
709 /*
710 * If output interface was cellular/expensive, and this
711 * socket is denied access to it, generate an event.
712 */
713 if (error != 0 && (ip6oa.ip6oa_flags & IP6OAF_R_IFDENIED) &&
714 (INP_NO_CELLULAR(in6p) || INP_NO_EXPENSIVE(in6p) || INP_NO_CONSTRAINED(in6p))) {
715 soevent(in6p->inp_socket, (SO_FILT_HINT_LOCKED |
716 SO_FILT_HINT_IFDENIED));
717 }
718 break;
719 case AF_INET:
720 error = EAFNOSUPPORT;
721 drop_reason = DROP_REASON_IP_EAFNOSUPPORT;
722 goto release;
723 }
724 goto releaseopt;
725
726 release:
727
728 if (m != NULL) {
729 m_drop(m, DROPTAP_FLAG_DIR_OUT | DROPTAP_FLAG_L2_MISSING, drop_reason, NULL, 0);
730 }
731
732 releaseopt:
733 if (control != NULL) {
734 if (optp == &opt) {
735 ip6_clearpktopts(optp, -1);
736 }
737 m_freem(control);
738 }
739 #if CONTENT_FILTER
740 if (cfil_tag) {
741 m_tag_free(cfil_tag);
742 }
743 #endif
744 if (sndinprog_cnt_used) {
745 VERIFY(in6p->inp_sndinprog_cnt > 0);
746 if (--in6p->inp_sndinprog_cnt == 0) {
747 in6p->inp_flags &= ~(INP_FC_FEEDBACK);
748 if (in6p->inp_sndingprog_waiters > 0) {
749 wakeup(&in6p->inp_sndinprog_cnt);
750 }
751 }
752 sndinprog_cnt_used = false;
753 }
754
755 return error;
756 }
757