1 /*
2 * Copyright (c) 2000-2021 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
117 #include <netinet/in.h>
118 #include <netinet/in_var.h>
119 #include <netinet/in_systm.h>
120 #include <netinet/in_tclass.h>
121 #include <netinet/ip.h>
122 #include <netinet/ip_var.h>
123 #include <netinet/in_pcb.h>
124 #include <netinet/udp.h>
125 #include <netinet/udp_var.h>
126 #include <netinet/ip6.h>
127 #include <netinet6/ip6_var.h>
128 #include <netinet6/in6_pcb.h>
129 #include <netinet6/udp6_var.h>
130 #include <netinet/icmp6.h>
131 #include <netinet6/ip6protosw.h>
132
133 #if NECP
134 #include <net/necp.h>
135 #endif /* NECP */
136
137 #include <net/net_osdep.h>
138
139 #if CONTENT_FILTER
140 #include <net/content_filter.h>
141 #endif /* CONTENT_FILTER */
142
143 /*
144 * UDP protocol inplementation.
145 * Per RFC 768, August, 1980.
146 */
147 extern int soreserveheadroom;
148
149 int
udp6_output(struct in6pcb * in6p,struct mbuf * m,struct sockaddr * addr6,struct mbuf * control,struct proc * p)150 udp6_output(struct in6pcb *in6p, struct mbuf *m, struct sockaddr *addr6,
151 struct mbuf *control, struct proc *p)
152 {
153 u_int32_t ulen = m->m_pkthdr.len;
154 u_int32_t plen = sizeof(struct udphdr) + ulen;
155 struct ip6_hdr *ip6;
156 struct udphdr *udp6;
157 struct in6_addr *laddr, *faddr;
158 u_short fport;
159 int error = 0;
160 struct ip6_pktopts opt, *optp = NULL;
161 struct ip6_moptions *im6o;
162 int af = AF_INET6, hlen = sizeof(struct ip6_hdr);
163 int flags;
164 struct sockaddr_in6 tmp;
165 struct in6_addr storage;
166 int sotc = SO_TC_UNSPEC;
167 int netsvctype = _NET_SERVICE_TYPE_UNSPEC;
168 struct ip6_out_args ip6oa;
169 struct flowadv *adv = &ip6oa.ip6oa_flowadv;
170 struct socket *so = in6p->in6p_socket;
171 struct route_in6 ro;
172 int flowadv = 0;
173 bool sndinprog_cnt_used = false;
174 #if CONTENT_FILTER
175 struct m_tag *cfil_tag = NULL;
176 bool cfil_faddr_use = false;
177 uint32_t cfil_so_state_change_cnt = 0;
178 struct sockaddr *cfil_faddr = NULL;
179 struct sockaddr_in6 *cfil_sin6 = NULL;
180 #endif
181 bool check_qos_marking_again = (so->so_flags1 & SOF1_QOSMARKING_POLICY_OVERRIDE) ? FALSE : TRUE;
182 uint32_t lifscope = IFSCOPE_NONE, fifscope = IFSCOPE_NONE;
183
184 bzero(&ip6oa, sizeof(ip6oa));
185 ip6oa.ip6oa_boundif = IFSCOPE_NONE;
186 ip6oa.ip6oa_flags = IP6OAF_SELECT_SRCIF;
187
188 /* Enable flow advisory only when connected */
189 flowadv = (so->so_state & SS_ISCONNECTED) ? 1 : 0;
190
191 if (flowadv && INP_WAIT_FOR_IF_FEEDBACK(in6p)) {
192 error = ENOBUFS;
193 goto release;
194 }
195
196 if (in6p->inp_flags & INP_BOUND_IF) {
197 ip6oa.ip6oa_boundif = in6p->inp_boundifp->if_index;
198 ip6oa.ip6oa_flags |= IP6OAF_BOUND_IF;
199 } else if (!in6_embedded_scope && IN6_IS_SCOPE_EMBED(&in6p->in6p_faddr)) {
200 ip6oa.ip6oa_boundif = in6p->inp_fifscope;
201 ip6oa.ip6oa_flags |= IP6OAF_BOUND_IF;
202 }
203 if (INP_NO_CELLULAR(in6p)) {
204 ip6oa.ip6oa_flags |= IP6OAF_NO_CELLULAR;
205 }
206 if (INP_NO_EXPENSIVE(in6p)) {
207 ip6oa.ip6oa_flags |= IP6OAF_NO_EXPENSIVE;
208 }
209 if (INP_NO_CONSTRAINED(in6p)) {
210 ip6oa.ip6oa_flags |= IP6OAF_NO_CONSTRAINED;
211 }
212 if (INP_AWDL_UNRESTRICTED(in6p)) {
213 ip6oa.ip6oa_flags |= IP6OAF_AWDL_UNRESTRICTED;
214 }
215 if (INP_INTCOPROC_ALLOWED(in6p)) {
216 ip6oa.ip6oa_flags |= IP6OAF_INTCOPROC_ALLOWED;
217 }
218
219 #if CONTENT_FILTER
220 /*
221 * If socket is subject to UDP Content Filter and no addr is passed in,
222 * retrieve CFIL saved state from mbuf and use it if necessary.
223 */
224 if (CFIL_DGRAM_FILTERED(so) && !addr6) {
225 cfil_tag = cfil_dgram_get_socket_state(m, &cfil_so_state_change_cnt, NULL, &cfil_faddr, NULL);
226 if (cfil_tag) {
227 cfil_sin6 = (struct sockaddr_in6 *)(void *)cfil_faddr;
228 if ((so->so_state_change_cnt != cfil_so_state_change_cnt) &&
229 (in6p->in6p_fport != cfil_sin6->sin6_port ||
230 !in6_are_addr_equal_scoped(&in6p->in6p_faddr, &cfil_sin6->sin6_addr, in6p->inp_fifscope, cfil_sin6->sin6_scope_id))) {
231 /*
232 * Socket is connected but socket state and dest addr/port changed.
233 * We need to use the saved faddr info.
234 */
235 cfil_faddr_use = true;
236 }
237 }
238 }
239 #endif
240
241 if (control) {
242 sotc = so_tc_from_control(control, &netsvctype);
243 if ((error = ip6_setpktopts(control, &opt,
244 NULL, IPPROTO_UDP)) != 0) {
245 goto release;
246 }
247 optp = &opt;
248 } else {
249 optp = in6p->in6p_outputopts;
250 }
251
252 if (sotc == SO_TC_UNSPEC) {
253 sotc = so->so_traffic_class;
254 netsvctype = so->so_netsvctype;
255 }
256 ip6oa.ip6oa_sotc = sotc;
257 ip6oa.ip6oa_netsvctype = netsvctype;
258
259 in6p->inp_sndinprog_cnt++;
260 sndinprog_cnt_used = true;
261
262 if (addr6) {
263 /*
264 * IPv4 version of udp_output calls in_pcbconnect in this case,
265 * which has its costs.
266 *
267 * Since we saw no essential reason for calling in_pcbconnect,
268 * we get rid of such kind of logic, and call in6_selectsrc
269 * and in6_pcbsetport in order to fill in the local address
270 * and the local port.
271 */
272 struct sockaddr_in6 *sin6 =
273 (struct sockaddr_in6 *)(void *)addr6;
274
275 if (sin6->sin6_port == 0) {
276 error = EADDRNOTAVAIL;
277 goto release;
278 }
279
280 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) {
281 /* how about ::ffff:0.0.0.0 case? */
282 error = EISCONN;
283 goto release;
284 }
285
286 /* protect *sin6 from overwrites */
287 tmp = *sin6;
288 sin6 = &tmp;
289
290 faddr = &sin6->sin6_addr;
291 fport = sin6->sin6_port; /* allow 0 port */
292
293 if (IN6_IS_ADDR_V4MAPPED(faddr)) {
294 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY)) {
295 /*
296 * I believe we should explicitly discard the
297 * packet when mapped addresses are disabled,
298 * rather than send the packet as an IPv6 one.
299 * If we chose the latter approach, the packet
300 * might be sent out on the wire based on the
301 * default route, the situation which we'd
302 * probably want to avoid.
303 * (20010421 [email protected])
304 */
305 error = EINVAL;
306 goto release;
307 } else {
308 af = AF_INET;
309 }
310 }
311
312 /* KAME hack: embed scopeid */
313 if (in6_embedscope(&sin6->sin6_addr, sin6, in6p, NULL,
314 optp, IN6_NULL_IF_EMBEDDED_SCOPE(&sin6->sin6_scope_id)) != 0) {
315 error = EINVAL;
316 goto release;
317 }
318 fifscope = sin6->sin6_scope_id;
319
320 if (!IN6_IS_ADDR_V4MAPPED(faddr)) {
321 struct ifnet *src_ifp = NULL;
322 laddr = in6_selectsrc(sin6, optp,
323 in6p, &in6p->in6p_route, &src_ifp, &storage,
324 ip6oa.ip6oa_boundif, &error);
325 if (src_ifp != NULL) {
326 lifscope = src_ifp->if_index;
327 ifnet_release(src_ifp);
328 }
329 } else {
330 laddr = &in6p->in6p_laddr; /* XXX */
331 lifscope = in6p->inp_lifscope;
332 }
333 if (laddr == NULL) {
334 if (error == 0) {
335 error = EADDRNOTAVAIL;
336 }
337 goto release;
338 }
339 if (in6p->in6p_lport == 0 &&
340 (error = in6_pcbsetport(laddr, in6p, p, 0)) != 0) {
341 goto release;
342 }
343 } else {
344 if (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) {
345 error = ENOTCONN;
346 goto release;
347 }
348 laddr = &in6p->in6p_laddr;
349 faddr = &in6p->in6p_faddr;
350 fport = in6p->in6p_fport;
351 fifscope = in6p->inp_fifscope;
352 lifscope = in6p->inp_lifscope;
353 #if CONTENT_FILTER
354 if (cfil_faddr_use) {
355 faddr = &((struct sockaddr_in6 *)(void *)cfil_faddr)->sin6_addr;
356 fport = ((struct sockaddr_in6 *)(void *)cfil_faddr)->sin6_port;
357 fifscope = ((struct sockaddr_in6 *)(void *)cfil_faddr)->sin6_scope_id;
358
359 /* Do not use cached route */
360 ROUTE_RELEASE(&in6p->in6p_route);
361 }
362 #endif
363 if (IN6_IS_ADDR_V4MAPPED(faddr)) {
364 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY)) {
365 /*
366 * XXX: this case would happen when the
367 * application sets the V6ONLY flag after
368 * connecting the foreign address.
369 * Such applications should be fixed,
370 * so we bark here.
371 */
372 log(LOG_INFO, "udp6_output: IPV6_V6ONLY "
373 "option was set for a connected socket\n");
374 error = EINVAL;
375 goto release;
376 } else {
377 af = AF_INET;
378 }
379 }
380 }
381
382 if (in6p->inp_flowhash == 0) {
383 inp_calc_flowhash(in6p);
384 ASSERT(in6p->inp_flowhash != 0);
385 }
386 /* update flowinfo - RFC 6437 */
387 if (in6p->inp_flow == 0 && in6p->in6p_flags & IN6P_AUTOFLOWLABEL) {
388 in6p->inp_flow &= ~IPV6_FLOWLABEL_MASK;
389 in6p->inp_flow |=
390 (htonl(ip6_randomflowlabel()) & IPV6_FLOWLABEL_MASK);
391 }
392
393 if (af == AF_INET) {
394 hlen = sizeof(struct ip);
395 }
396
397 if (fport == htons(53) && !(so->so_flags1 & SOF1_DNS_COUNTED)) {
398 so->so_flags1 |= SOF1_DNS_COUNTED;
399 INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_inet_dgram_dns);
400 }
401
402 /*
403 * Calculate data length and get a mbuf
404 * for UDP and IP6 headers.
405 */
406 M_PREPEND(m, hlen + sizeof(struct udphdr), M_DONTWAIT, 1);
407 if (m == 0) {
408 error = ENOBUFS;
409 goto release;
410 }
411
412 /*
413 * Stuff checksum and output datagram.
414 */
415 udp6 = (struct udphdr *)(void *)(mtod(m, caddr_t) + hlen);
416 udp6->uh_sport = in6p->in6p_lport; /* lport is always set in the PCB */
417 udp6->uh_dport = fport;
418 if (plen <= 0xffff) {
419 udp6->uh_ulen = htons((u_short)plen);
420 } else {
421 udp6->uh_ulen = 0;
422 }
423 udp6->uh_sum = 0;
424
425 switch (af) {
426 case AF_INET6:
427 ip6 = mtod(m, struct ip6_hdr *);
428 ip6->ip6_flow = in6p->inp_flow & IPV6_FLOWINFO_MASK;
429 ip6->ip6_vfc &= ~IPV6_VERSION_MASK;
430 ip6->ip6_vfc |= IPV6_VERSION;
431 #if 0 /* ip6_plen will be filled in ip6_output. */
432 ip6->ip6_plen = htons((u_short)plen);
433 #endif
434 ip6->ip6_nxt = IPPROTO_UDP;
435 ip6->ip6_hlim = in6_selecthlim(in6p, in6p->in6p_route.ro_rt ?
436 in6p->in6p_route.ro_rt->rt_ifp : NULL);
437 ip6->ip6_src = *laddr;
438 ip6->ip6_dst = *faddr;
439
440 udp6->uh_sum = in6_pseudo(laddr, faddr,
441 htonl(plen + IPPROTO_UDP));
442 m->m_pkthdr.csum_flags = (CSUM_UDPIPV6 | CSUM_ZERO_INVERT);
443 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
444
445 if (!IN6_IS_ADDR_UNSPECIFIED(laddr)) {
446 ip6oa.ip6oa_flags |= IP6OAF_BOUND_SRCADDR;
447 }
448
449 flags = IPV6_OUTARGS;
450
451 udp6stat.udp6s_opackets++;
452
453 #if NECP
454 {
455 necp_kernel_policy_id policy_id;
456 necp_kernel_policy_id skip_policy_id;
457 u_int32_t route_rule_id;
458 u_int32_t pass_flags;
459
460 /*
461 * We need a route to perform NECP route rule checks
462 */
463 if (net_qos_policy_restricted != 0 &&
464 ROUTE_UNUSABLE(&in6p->inp_route)) {
465 struct sockaddr_in6 to;
466 struct sockaddr_in6 from;
467
468 ROUTE_RELEASE(&in6p->inp_route);
469
470 bzero(&from, sizeof(struct sockaddr_in6));
471 from.sin6_family = AF_INET6;
472 from.sin6_len = sizeof(struct sockaddr_in6);
473 from.sin6_addr = *laddr;
474
475 bzero(&to, sizeof(struct sockaddr_in6));
476 to.sin6_family = AF_INET6;
477 to.sin6_len = sizeof(struct sockaddr_in6);
478 to.sin6_addr = *faddr;
479
480 in6p->inp_route.ro_dst.sa_family = AF_INET6;
481 in6p->inp_route.ro_dst.sa_len = sizeof(struct sockaddr_in6);
482 ((struct sockaddr_in6 *)(void *)&in6p->inp_route.ro_dst)->sin6_addr =
483 *faddr;
484
485 if (!in6_embedded_scope) {
486 ((struct sockaddr_in6 *)(void *)&in6p->inp_route.ro_dst)->sin6_scope_id =
487 IN6_IS_SCOPE_EMBED(faddr) ? fifscope : IFSCOPE_NONE;
488 }
489 rtalloc_scoped(&in6p->inp_route, ip6oa.ip6oa_boundif);
490
491 inp_update_necp_policy(in6p, (struct sockaddr *)&from,
492 (struct sockaddr *)&to, ip6oa.ip6oa_boundif);
493 in6p->inp_policyresult.results.qos_marking_gencount = 0;
494 }
495
496 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)) {
497 error = EHOSTUNREACH;
498 goto release;
499 }
500
501 necp_mark_packet_from_socket(m, in6p, policy_id, route_rule_id, skip_policy_id, pass_flags);
502
503 if (net_qos_policy_restricted != 0) {
504 necp_socket_update_qos_marking(in6p, in6p->in6p_route.ro_rt, route_rule_id);
505 }
506 }
507 #endif /* NECP */
508 if ((so->so_flags1 & SOF1_QOSMARKING_ALLOWED)) {
509 ip6oa.ip6oa_flags |= IP6OAF_QOSMARKING_ALLOWED;
510 }
511 if (check_qos_marking_again) {
512 ip6oa.ip6oa_flags |= IP6OAF_REDO_QOSMARKING_POLICY;
513 }
514 ip6oa.qos_marking_gencount = in6p->inp_policyresult.results.qos_marking_gencount;
515
516 #if IPSEC
517 if (in6p->in6p_sp != NULL && ipsec_setsocket(m, so) != 0) {
518 error = ENOBUFS;
519 goto release;
520 }
521 #endif /*IPSEC*/
522
523 /* In case of IPv4-mapped address used in previous send */
524 if (ROUTE_UNUSABLE(&in6p->in6p_route) ||
525 rt_key(in6p->in6p_route.ro_rt)->sa_family != AF_INET6) {
526 ROUTE_RELEASE(&in6p->in6p_route);
527 }
528
529 /* Copy the cached route and take an extra reference */
530 in6p_route_copyout(in6p, &ro);
531
532 set_packet_service_class(m, so, sotc, PKT_SCF_IPV6);
533
534 m->m_pkthdr.pkt_flowsrc = FLOWSRC_INPCB;
535 m->m_pkthdr.pkt_flowid = in6p->inp_flowhash;
536 m->m_pkthdr.pkt_proto = IPPROTO_UDP;
537 m->m_pkthdr.pkt_flags |= (PKTF_FLOW_ID | PKTF_FLOW_LOCALSRC);
538 if (flowadv) {
539 m->m_pkthdr.pkt_flags |= PKTF_FLOW_ADV;
540 }
541 m->m_pkthdr.tx_udp_pid = so->last_pid;
542 if (so->so_flags & SOF_DELEGATED) {
543 m->m_pkthdr.tx_udp_e_pid = so->e_pid;
544 } else {
545 m->m_pkthdr.tx_udp_e_pid = 0;
546 }
547 #if (DEBUG || DEVELOPMENT)
548 if (so->so_flags & SOF_MARK_WAKE_PKT) {
549 so->so_flags &= ~SOF_MARK_WAKE_PKT;
550 m->m_pkthdr.pkt_flags |= PKTF_WAKE_PKT;
551 }
552 #endif /* (DEBUG || DEVELOPMENT) */
553
554 im6o = in6p->in6p_moptions;
555 if (im6o != NULL) {
556 IM6O_LOCK(im6o);
557 IM6O_ADDREF_LOCKED(im6o);
558 if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) &&
559 im6o->im6o_multicast_ifp != NULL) {
560 in6p->in6p_last_outifp =
561 im6o->im6o_multicast_ifp;
562 #if SKYWALK
563 if (NETNS_TOKEN_VALID(&in6p->inp_netns_token)) {
564 netns_set_ifnet(&in6p->inp_netns_token,
565 in6p->in6p_last_outifp);
566 }
567 #endif /* SKYWALK */
568 }
569 IM6O_UNLOCK(im6o);
570 }
571
572 ip6_output_setdstifscope(m, fifscope, NULL);
573 ip6_output_setsrcifscope(m, lifscope, NULL);
574
575 socket_unlock(so, 0);
576 error = ip6_output(m, optp, &ro, flags, im6o, NULL, &ip6oa);
577 m = NULL;
578 socket_lock(so, 0);
579
580 if (im6o != NULL) {
581 IM6O_REMREF(im6o);
582 }
583
584 if (check_qos_marking_again) {
585 in6p->inp_policyresult.results.qos_marking_gencount = ip6oa.qos_marking_gencount;
586 if (ip6oa.ip6oa_flags & IP6OAF_QOSMARKING_ALLOWED) {
587 in6p->inp_socket->so_flags1 |= SOF1_QOSMARKING_ALLOWED;
588 } else {
589 in6p->inp_socket->so_flags1 &= ~SOF1_QOSMARKING_ALLOWED;
590 }
591 }
592
593 if (error == 0 && nstat_collect) {
594 boolean_t cell, wifi, wired;
595
596 if (in6p->in6p_route.ro_rt != NULL) {
597 cell = IFNET_IS_CELLULAR(in6p->in6p_route.
598 ro_rt->rt_ifp);
599 wifi = (!cell && IFNET_IS_WIFI(in6p->in6p_route.
600 ro_rt->rt_ifp));
601 wired = (!wifi && IFNET_IS_WIRED(in6p->in6p_route.
602 ro_rt->rt_ifp));
603 } else {
604 cell = wifi = wired = FALSE;
605 }
606 INP_ADD_STAT(in6p, cell, wifi, wired, txpackets, 1);
607 INP_ADD_STAT(in6p, cell, wifi, wired, txbytes, ulen);
608 inp_set_activity_bitmap(in6p);
609 }
610
611 if (flowadv && (adv->code == FADV_FLOW_CONTROLLED ||
612 adv->code == FADV_SUSPENDED)) {
613 /*
614 * Return an error to indicate
615 * that the packet has been dropped.
616 */
617 error = ENOBUFS;
618 inp_set_fc_state(in6p, adv->code);
619 }
620
621 if (ro.ro_rt != NULL) {
622 struct ifnet *outif = ro.ro_rt->rt_ifp;
623
624 so->so_pktheadroom = (uint16_t)P2ROUNDUP(
625 sizeof(struct udphdr) +
626 hlen +
627 ifnet_hdrlen(outif) +
628 ifnet_mbuf_packetpreamblelen(outif),
629 sizeof(u_int32_t));
630 }
631
632 /* Synchronize PCB cached route */
633 in6p_route_copyin(in6p, &ro);
634
635 if (in6p->in6p_route.ro_rt != NULL) {
636 struct rtentry *rt = in6p->in6p_route.ro_rt;
637 struct ifnet *outif;
638
639 if (rt->rt_flags & RTF_MULTICAST) {
640 rt = NULL; /* unusable */
641 }
642 #if CONTENT_FILTER
643 /*
644 * Discard temporary route for cfil case
645 */
646 if (cfil_faddr_use) {
647 rt = NULL; /* unusable */
648 }
649 #endif
650
651 /*
652 * Always discard the cached route for unconnected
653 * socket or if it is a multicast route.
654 */
655 if (rt == NULL) {
656 ROUTE_RELEASE(&in6p->in6p_route);
657 }
658
659 /*
660 * If the destination route is unicast, update outif
661 * with that of the route interface used by IP.
662 */
663 if (rt != NULL) {
664 /*
665 * When an NECP IP tunnel policy forces the outbound interface,
666 * ip6_output_list() informs the transport layer what is the actual
667 * outgoing interface
668 */
669 if (ip6oa.ip6oa_flags & IP6OAF_BOUND_IF) {
670 outif = ifindex2ifnet[ip6oa.ip6oa_boundif];
671 } else {
672 outif = rt->rt_ifp;
673 }
674 if (outif != NULL && outif != in6p->in6p_last_outifp) {
675 in6p->in6p_last_outifp = outif;
676 #if SKYWALK
677 if (NETNS_TOKEN_VALID(&in6p->inp_netns_token)) {
678 netns_set_ifnet(&in6p->inp_netns_token,
679 in6p->in6p_last_outifp);
680 }
681 #endif /* SKYWALK */
682
683 so->so_pktheadroom = (uint16_t)P2ROUNDUP(
684 sizeof(struct udphdr) +
685 hlen +
686 ifnet_hdrlen(outif) +
687 ifnet_mbuf_packetpreamblelen(outif),
688 sizeof(u_int32_t));
689 }
690 }
691 } else {
692 ROUTE_RELEASE(&in6p->in6p_route);
693 }
694
695 /*
696 * If output interface was cellular/expensive, and this
697 * socket is denied access to it, generate an event.
698 */
699 if (error != 0 && (ip6oa.ip6oa_flags & IP6OAF_R_IFDENIED) &&
700 (INP_NO_CELLULAR(in6p) || INP_NO_EXPENSIVE(in6p) || INP_NO_CONSTRAINED(in6p))) {
701 soevent(in6p->inp_socket, (SO_FILT_HINT_LOCKED |
702 SO_FILT_HINT_IFDENIED));
703 }
704 break;
705 case AF_INET:
706 error = EAFNOSUPPORT;
707 goto release;
708 }
709 goto releaseopt;
710
711 release:
712
713 if (m != NULL) {
714 m_freem(m);
715 }
716
717 releaseopt:
718 if (control != NULL) {
719 if (optp == &opt) {
720 ip6_clearpktopts(optp, -1);
721 }
722 m_freem(control);
723 }
724 #if CONTENT_FILTER
725 if (cfil_tag) {
726 m_tag_free(cfil_tag);
727 }
728 #endif
729 if (sndinprog_cnt_used) {
730 VERIFY(in6p->inp_sndinprog_cnt > 0);
731 if (--in6p->inp_sndinprog_cnt == 0) {
732 in6p->inp_flags &= ~(INP_FC_FEEDBACK);
733 if (in6p->inp_sndingprog_waiters > 0) {
734 wakeup(&in6p->inp_sndinprog_cnt);
735 }
736 }
737 sndinprog_cnt_used = false;
738 }
739
740 return error;
741 }
742