]> git.saurik.com Git - apple/xnu.git/blob - bsd/netinet6/ip6_output.c
projects / apple / xnu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
xnu-7195.101.1.tar.gz
[apple/xnu.git] / bsd / netinet6 / ip6_output.c
1 /*
2 * Copyright (c) 2000-2020 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 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
31 * All rights reserved.
32 *
33 * Redistribution and use in source and binary forms, with or without
34 * modification, are permitted provided that the following conditions
35 * are met:
36 * 1. Redistributions of source code must retain the above copyright
37 * notice, this list of conditions and the following disclaimer.
38 * 2. Redistributions in binary form must reproduce the above copyright
39 * notice, this list of conditions and the following disclaimer in the
40 * documentation and/or other materials provided with the distribution.
41 * 3. Neither the name of the project nor the names of its contributors
42 * may be used to endorse or promote products derived from this software
43 * without specific prior written permission.
44 *
45 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
46 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
49 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
50 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
51 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
52 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
53 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
54 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
55 * SUCH DAMAGE.
56 */
57
58 /*
59 * Copyright (c) 1982, 1986, 1988, 1990, 1993
60 * The Regents of the University of California. All rights reserved.
61 *
62 * Redistribution and use in source and binary forms, with or without
63 * modification, are permitted provided that the following conditions
64 * are met:
65 * 1. Redistributions of source code must retain the above copyright
66 * notice, this list of conditions and the following disclaimer.
67 * 2. Redistributions in binary form must reproduce the above copyright
68 * notice, this list of conditions and the following disclaimer in the
69 * documentation and/or other materials provided with the distribution.
70 * 3. All advertising materials mentioning features or use of this software
71 * must display the following acknowledgement:
72 * This product includes software developed by the University of
73 * California, Berkeley and its contributors.
74 * 4. Neither the name of the University nor the names of its contributors
75 * may be used to endorse or promote products derived from this software
76 * without specific prior written permission.
77 *
78 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
79 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
80 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
81 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
82 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
83 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
84 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
85 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
86 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
87 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
88 * SUCH DAMAGE.
89 *
90 * @(#)ip_output.c 8.3 (Berkeley) 1/21/94
91 */
92 /*
93 * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
94 * support for mandatory and extensible security protections. This notice
95 * is included in support of clause 2.2 (b) of the Apple Public License,
96 * Version 2.0.
97 */
98
99 #include <sys/param.h>
100 #include <sys/malloc.h>
101 #include <sys/mbuf.h>
102 #include <sys/errno.h>
103 #include <sys/protosw.h>
104 #include <sys/socket.h>
105 #include <sys/socketvar.h>
106 #include <sys/systm.h>
107 #include <sys/kernel.h>
108 #include <sys/proc.h>
109 #include <sys/kauth.h>
110 #include <sys/mcache.h>
111 #include <sys/sysctl.h>
112 #include <kern/zalloc.h>
113 #include <libkern/OSByteOrder.h>
114
115 #include <pexpert/pexpert.h>
116 #include <mach/sdt.h>
117
118 #include <net/if.h>
119 #include <net/route.h>
120 #include <net/dlil.h>
121 #include <net/net_api_stats.h>
122 #include <net/net_osdep.h>
123 #include <net/net_perf.h>
124
125 #include <netinet/ip.h>
126 #include <netinet/in.h>
127 #include <netinet/in_var.h>
128 #include <netinet/ip_var.h>
129 #include <netinet6/in6_var.h>
130 #include <netinet/ip6.h>
131 #include <netinet/kpi_ipfilter_var.h>
132 #include <netinet/in_tclass.h>
133
134 #include <netinet6/ip6protosw.h>
135 #include <netinet/icmp6.h>
136 #include <netinet6/ip6_var.h>
137 #include <netinet/in_pcb.h>
138 #include <netinet6/nd6.h>
139 #include <netinet6/scope6_var.h>
140 #if IPSEC
141 #include <netinet6/ipsec.h>
142 #include <netinet6/ipsec6.h>
143 #include <netkey/key.h>
144 extern int ipsec_bypass;
145 #endif /* IPSEC */
146
147 #if NECP
148 #include <net/necp.h>
149 #endif /* NECP */
150
151 #if DUMMYNET
152 #include <netinet/ip_dummynet.h>
153 #endif /* DUMMYNET */
154
155 #if PF
156 #include <net/pfvar.h>
157 #endif /* PF */
158
159 static int sysctl_reset_ip6_output_stats SYSCTL_HANDLER_ARGS;
160 static int sysctl_ip6_output_measure_bins SYSCTL_HANDLER_ARGS;
161 static int sysctl_ip6_output_getperf SYSCTL_HANDLER_ARGS;
162 static int ip6_copyexthdr(struct mbuf **, caddr_t, int);
163 static void ip6_out_cksum_stats(int, u_int32_t);
164 static int ip6_insert_jumboopt(struct ip6_exthdrs *, u_int32_t);
165 static int ip6_insertfraghdr(struct mbuf *, struct mbuf *, int,
166 struct ip6_frag **);
167 static int ip6_getpmtu(struct route_in6 *, struct route_in6 *,
168 struct ifnet *, struct in6_addr *, u_int32_t *);
169 static int ip6_pcbopts(struct ip6_pktopts **, struct mbuf *, struct socket *,
170 struct sockopt *sopt);
171 static int ip6_pcbopt(int, u_char *, int, struct ip6_pktopts **, int);
172 static int ip6_getpcbopt(struct ip6_pktopts *, int, struct sockopt *);
173 static int copypktopts(struct ip6_pktopts *, struct ip6_pktopts *, int);
174 static void im6o_trace(struct ip6_moptions *, int);
175 static int ip6_setpktopt(int, u_char *, int, struct ip6_pktopts *, int,
176 int, int);
177 static int ip6_splithdr(struct mbuf *, struct ip6_exthdrs *);
178 static void ip6_output_checksum(struct ifnet *, uint32_t, struct mbuf *,
179 int, uint32_t, uint32_t);
180 extern int udp_ctloutput(struct socket *, struct sockopt *);
181 static int ip6_fragment_packet(struct mbuf **m,
182 struct ip6_pktopts *opt, struct ip6_out_args * ip6oa,
183 struct ip6_exthdrs *exthdrsp, struct ifnet *ifp,
184 uint32_t mtu, uint32_t unfragpartlen, struct route_in6 *ro_pmtu,
185 int nxt0, uint32_t optlen);
186
187 SYSCTL_DECL(_net_inet6_ip6);
188
189 static int ip6_output_measure = 0;
190 SYSCTL_PROC(_net_inet6_ip6, OID_AUTO, output_perf,
191 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
192 &ip6_output_measure, 0, sysctl_reset_ip6_output_stats, "I", "Do time measurement");
193
194 static uint64_t ip6_output_measure_bins = 0;
195 SYSCTL_PROC(_net_inet6_ip6, OID_AUTO, output_perf_bins,
196 CTLTYPE_QUAD | CTLFLAG_RW | CTLFLAG_LOCKED, &ip6_output_measure_bins, 0,
197 sysctl_ip6_output_measure_bins, "I",
198 "bins for chaining performance data histogram");
199
200 static net_perf_t net_perf;
201 SYSCTL_PROC(_net_inet6_ip6, OID_AUTO, output_perf_data,
202 CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_LOCKED,
203 0, 0, sysctl_ip6_output_getperf, "S,net_perf",
204 "IP6 output performance data (struct net_perf, net/net_perf.h)");
205
206 #define IM6O_TRACE_HIST_SIZE 32 /* size of trace history */
207
208 /* For gdb */
209 __private_extern__ unsigned int im6o_trace_hist_size = IM6O_TRACE_HIST_SIZE;
210
211 struct ip6_moptions_dbg {
212 struct ip6_moptions im6o; /* ip6_moptions */
213 u_int16_t im6o_refhold_cnt; /* # of IM6O_ADDREF */
214 u_int16_t im6o_refrele_cnt; /* # of IM6O_REMREF */
215 /*
216 * Alloc and free callers.
217 */
218 ctrace_t im6o_alloc;
219 ctrace_t im6o_free;
220 /*
221 * Circular lists of IM6O_ADDREF and IM6O_REMREF callers.
222 */
223 ctrace_t im6o_refhold[IM6O_TRACE_HIST_SIZE];
224 ctrace_t im6o_refrele[IM6O_TRACE_HIST_SIZE];
225 };
226
227 #if DEBUG
228 static unsigned int im6o_debug = 1; /* debugging (enabled) */
229 #else
230 static unsigned int im6o_debug; /* debugging (disabled) */
231 #endif /* !DEBUG */
232
233 static struct zone *im6o_zone; /* zone for ip6_moptions */
234 #define IM6O_ZONE_NAME "ip6_moptions" /* zone name */
235
236 /*
237 * ip6_output() calls ip6_output_list() to do the work
238 */
239 int
240 ip6_output(struct mbuf *m0, struct ip6_pktopts *opt,
241 struct route_in6 *ro, int flags, struct ip6_moptions *im6o,
242 struct ifnet **ifpp, struct ip6_out_args *ip6oa)
243 {
244 return ip6_output_list(m0, 0, opt, ro, flags, im6o, ifpp, ip6oa);
245 }
246
247 /*
248 * IP6 output. Each packet in mbuf chain m contains a skeletal IP6
249 * header (with pri, len, nxt, hlim, src, dst).
250 * This function may modify ver and hlim only.
251 * The mbuf chain containing the packet will be freed.
252 * The mbuf opt, if present, will not be freed.
253 *
254 * If ro is non-NULL and has valid ro->ro_rt, route lookup would be
255 * skipped and ro->ro_rt would be used. Otherwise the result of route
256 * lookup is stored in ro->ro_rt.
257 *
258 * type of "mtu": rt_rmx.rmx_mtu is u_int32_t, ifnet.ifr_mtu is int, and
259 * nd_ifinfo.linkmtu is u_int32_t. so we use u_int32_t to hold largest one,
260 * which is rt_rmx.rmx_mtu.
261 */
262 int
263 ip6_output_list(struct mbuf *m0, int packetchain, struct ip6_pktopts *opt,
264 struct route_in6 *ro, int flags, struct ip6_moptions *im6o,
265 struct ifnet **ifpp, struct ip6_out_args *ip6oa)
266 {
267 struct ip6_hdr *ip6;
268 u_char *nexthdrp;
269 struct ifnet *ifp = NULL, *origifp = NULL; /* refcnt'd */
270 struct ifnet **ifpp_save = ifpp;
271 struct mbuf *m, *mprev;
272 struct mbuf *sendchain = NULL, *sendchain_last = NULL;
273 struct mbuf *inputchain = NULL;
274 int nxt0 = 0;
275 struct route_in6 *ro_pmtu = NULL;
276 struct rtentry *rt = NULL;
277 struct sockaddr_in6 *dst = NULL, src_sa, dst_sa;
278 int error = 0;
279 struct in6_ifaddr *ia = NULL, *src_ia = NULL;
280 u_int32_t mtu = 0;
281 u_int32_t optlen = 0, plen = 0, unfragpartlen = 0;
282 struct ip6_rthdr *rh;
283 struct in6_addr finaldst;
284 ipfilter_t inject_filter_ref;
285 struct ipf_pktopts *ippo = NULL;
286 struct flowadv *adv = NULL;
287 uint32_t pktcnt = 0;
288 uint32_t packets_processed = 0;
289 struct timeval start_tv;
290 #if PF
291 boolean_t skip_pf = (ip6oa != NULL) &&
292 (ip6oa->ip6oa_flags & IP6OAF_SKIP_PF);
293 #endif
294
295 #if DUMMYNET
296 struct m_tag *tag;
297 struct ip6_out_args saved_ip6oa;
298 struct sockaddr_in6 dst_buf;
299 #endif /* DUMMYNET */
300 #if IPSEC
301 struct socket *so = NULL;
302 struct secpolicy *sp = NULL;
303 struct route_in6 *ipsec_saved_route = NULL;
304 boolean_t needipsectun = FALSE;
305 #endif /* IPSEC */
306 #if NECP
307 necp_kernel_policy_result necp_result = 0;
308 necp_kernel_policy_result_parameter necp_result_parameter;
309 necp_kernel_policy_id necp_matched_policy_id = 0;
310 #endif /* NECP */
311 struct {
312 struct ipf_pktopts ipf_pktopts;
313 struct ip6_exthdrs exthdrs;
314 struct route_in6 ip6route;
315 #if IPSEC
316 struct ipsec_output_state ipsec_state;
317 #endif /* IPSEC */
318 #if NECP
319 struct route_in6 necp_route;
320 #endif /* NECP */
321 #if DUMMYNET
322 struct route_in6 saved_route;
323 struct route_in6 saved_ro_pmtu;
324 struct ip_fw_args args;
325 #endif /* DUMMYNET */
326 } ip6obz;
327 #define ipf_pktopts ip6obz.ipf_pktopts
328 #define exthdrs ip6obz.exthdrs
329 #define ip6route ip6obz.ip6route
330 #define ipsec_state ip6obz.ipsec_state
331 #define necp_route ip6obz.necp_route
332 #define saved_route ip6obz.saved_route
333 #define saved_ro_pmtu ip6obz.saved_ro_pmtu
334 #define args ip6obz.args
335 union {
336 struct {
337 boolean_t select_srcif : 1;
338 boolean_t hdrsplit : 1;
339 boolean_t route_selected : 1;
340 boolean_t dontfrag : 1;
341 #if IPSEC
342 boolean_t needipsec : 1;
343 boolean_t noipsec : 1;
344 #endif /* IPSEC */
345 };
346 uint32_t raw;
347 } ip6obf = { .raw = 0 };
348
349 if (ip6_output_measure) {
350 net_perf_start_time(&net_perf, &start_tv);
351 }
352
353 VERIFY(m0->m_flags & M_PKTHDR);
354
355 /* zero out {saved_route, saved_ro_pmtu, ip6route, exthdrs, args} */
356 bzero(&ip6obz, sizeof(ip6obz));
357
358 #if DUMMYNET
359 if (SLIST_EMPTY(&m0->m_pkthdr.tags)) {
360 goto tags_done;
361 }
362
363 /* Grab info from mtags prepended to the chain */
364 if ((tag = m_tag_locate(m0, KERNEL_MODULE_TAG_ID,
365 KERNEL_TAG_TYPE_DUMMYNET, NULL)) != NULL) {
366 struct dn_pkt_tag *dn_tag;
367
368 /*
369 * ip6_output_list() cannot handle chains of packets reinjected
370 * by dummynet. The same restriction applies to
371 * ip_output_list().
372 */
373 VERIFY(0 == packetchain);
374
375 dn_tag = (struct dn_pkt_tag *)(tag + 1);
376 args.fwa_pf_rule = dn_tag->dn_pf_rule;
377
378 bcopy(&dn_tag->dn_dst6, &dst_buf, sizeof(dst_buf));
379 dst = &dst_buf;
380 ifp = dn_tag->dn_ifp;
381 if (ifp != NULL) {
382 ifnet_reference(ifp);
383 }
384 flags = dn_tag->dn_flags;
385 if (dn_tag->dn_flags & IPV6_OUTARGS) {
386 saved_ip6oa = dn_tag->dn_ip6oa;
387 ip6oa = &saved_ip6oa;
388 }
389
390 saved_route = dn_tag->dn_ro6;
391 ro = &saved_route;
392 saved_ro_pmtu = dn_tag->dn_ro6_pmtu;
393 ro_pmtu = &saved_ro_pmtu;
394 origifp = dn_tag->dn_origifp;
395 if (origifp != NULL) {
396 ifnet_reference(origifp);
397 }
398 mtu = dn_tag->dn_mtu;
399 unfragpartlen = dn_tag->dn_unfragpartlen;
400
401 bcopy(&dn_tag->dn_exthdrs, &exthdrs, sizeof(exthdrs));
402
403 m_tag_delete(m0, tag);
404 }
405
406 tags_done:
407 #endif /* DUMMYNET */
408
409 m = m0;
410
411 #if IPSEC
412 if (ipsec_bypass == 0) {
413 so = ipsec_getsocket(m);
414 if (so != NULL) {
415 (void) ipsec_setsocket(m, NULL);
416 }
417 /* If packet is bound to an interface, check bound policies */
418 if ((flags & IPV6_OUTARGS) &&
419 (ip6oa->ip6oa_flags & IP6OAF_BOUND_IF) &&
420 ip6oa->ip6oa_boundif != IFSCOPE_NONE) {
421 /* ip6obf.noipsec is a bitfield, use temp integer */
422 int noipsec = 0;
423
424 if (ipsec6_getpolicybyinterface(m, IPSEC_DIR_OUTBOUND,
425 flags, ip6oa, &noipsec, &sp) != 0) {
426 goto bad;
427 }
428
429 ip6obf.noipsec = (noipsec != 0);
430 }
431 }
432 #endif /* IPSEC */
433
434 ippo = &ipf_pktopts;
435
436 if (flags & IPV6_OUTARGS) {
437 /*
438 * In the forwarding case, only the ifscope value is used,
439 * as source interface selection doesn't take place.
440 */
441 if ((ip6obf.select_srcif = (!(flags & (IPV6_FORWARDING |
442 IPV6_UNSPECSRC | IPV6_FLAG_NOSRCIFSEL)) &&
443 (ip6oa->ip6oa_flags & IP6OAF_SELECT_SRCIF)))) {
444 ipf_pktopts.ippo_flags |= IPPOF_SELECT_SRCIF;
445 }
446
447 if ((ip6oa->ip6oa_flags & IP6OAF_BOUND_IF) &&
448 ip6oa->ip6oa_boundif != IFSCOPE_NONE) {
449 ipf_pktopts.ippo_flags |= (IPPOF_BOUND_IF |
450 (ip6oa->ip6oa_boundif << IPPOF_SHIFT_IFSCOPE));
451 }
452
453 if (ip6oa->ip6oa_flags & IP6OAF_BOUND_SRCADDR) {
454 ipf_pktopts.ippo_flags |= IPPOF_BOUND_SRCADDR;
455 }
456 } else {
457 ip6obf.select_srcif = FALSE;
458 if (flags & IPV6_OUTARGS) {
459 ip6oa->ip6oa_boundif = IFSCOPE_NONE;
460 ip6oa->ip6oa_flags &= ~(IP6OAF_SELECT_SRCIF |
461 IP6OAF_BOUND_IF | IP6OAF_BOUND_SRCADDR);
462 }
463 }
464
465 if (flags & IPV6_OUTARGS) {
466 if (ip6oa->ip6oa_flags & IP6OAF_NO_CELLULAR) {
467 ipf_pktopts.ippo_flags |= IPPOF_NO_IFT_CELLULAR;
468 }
469 if (ip6oa->ip6oa_flags & IP6OAF_NO_EXPENSIVE) {
470 ipf_pktopts.ippo_flags |= IPPOF_NO_IFF_EXPENSIVE;
471 }
472 if (ip6oa->ip6oa_flags & IP6OAF_NO_CONSTRAINED) {
473 ipf_pktopts.ippo_flags |= IPPOF_NO_IFF_CONSTRAINED;
474 }
475 adv = &ip6oa->ip6oa_flowadv;
476 adv->code = FADV_SUCCESS;
477 ip6oa->ip6oa_retflags = 0;
478 }
479
480 /*
481 * Clear out ifpp to be filled in after determining route. ifpp_save is
482 * used to keep old value to release reference properly and dtrace
483 * ipsec tunnel traffic properly.
484 */
485 if (ifpp != NULL && *ifpp != NULL) {
486 *ifpp = NULL;
487 }
488
489 #if DUMMYNET
490 if (args.fwa_pf_rule) {
491 ip6 = mtod(m, struct ip6_hdr *);
492 VERIFY(ro != NULL); /* ro == saved_route */
493 goto check_with_pf;
494 }
495 #endif /* DUMMYNET */
496
497 #if NECP
498 /*
499 * Since all packets are assumed to come from same socket, necp lookup
500 * only needs to happen once per function entry.
501 */
502 necp_matched_policy_id = necp_ip6_output_find_policy_match(m, flags,
503 (flags & IPV6_OUTARGS) ? ip6oa : NULL, ro ? ro->ro_rt : NULL, &necp_result,
504 &necp_result_parameter);
505 #endif /* NECP */
506
507 /*
508 * If a chain was passed in, prepare for ther first iteration. For all
509 * other iterations, this work will be done at evaluateloop: label.
510 */
511 if (packetchain) {
512 /*
513 * Remove m from the chain during processing to avoid
514 * accidental frees on entire list.
515 */
516 inputchain = m->m_nextpkt;
517 m->m_nextpkt = NULL;
518 }
519
520 loopit:
521 packets_processed++;
522 m->m_pkthdr.pkt_flags &= ~(PKTF_LOOP | PKTF_IFAINFO);
523 ip6 = mtod(m, struct ip6_hdr *);
524 nxt0 = ip6->ip6_nxt;
525 finaldst = ip6->ip6_dst;
526 ip6obf.hdrsplit = FALSE;
527 ro_pmtu = NULL;
528
529 if (!SLIST_EMPTY(&m->m_pkthdr.tags)) {
530 inject_filter_ref = ipf_get_inject_filter(m);
531 } else {
532 inject_filter_ref = NULL;
533 }
534
535 #define MAKE_EXTHDR(hp, mp) do { \
536 if (hp != NULL) { \
537 struct ip6_ext *eh = (struct ip6_ext *)(hp); \
538 error = ip6_copyexthdr((mp), (caddr_t)(hp), \
539 ((eh)->ip6e_len + 1) << 3); \
540 if (error) \
541 goto freehdrs; \
542 } \
543 } while (0)
544
545 if (opt != NULL) {
546 /* Hop-by-Hop options header */
547 MAKE_EXTHDR(opt->ip6po_hbh, &exthdrs.ip6e_hbh);
548 /* Destination options header(1st part) */
549 if (opt->ip6po_rthdr) {
550 /*
551 * Destination options header(1st part)
552 * This only makes sense with a routing header.
553 * See Section 9.2 of RFC 3542.
554 * Disabling this part just for MIP6 convenience is
555 * a bad idea. We need to think carefully about a
556 * way to make the advanced API coexist with MIP6
557 * options, which might automatically be inserted in
558 * the kernel.
559 */
560 MAKE_EXTHDR(opt->ip6po_dest1, &exthdrs.ip6e_dest1);
561 }
562 /* Routing header */
563 MAKE_EXTHDR(opt->ip6po_rthdr, &exthdrs.ip6e_rthdr);
564 /* Destination options header(2nd part) */
565 MAKE_EXTHDR(opt->ip6po_dest2, &exthdrs.ip6e_dest2);
566 }
567
568 #undef MAKE_EXTHDR
569
570 #if NECP
571 if (necp_matched_policy_id) {
572 necp_mark_packet_from_ip(m, necp_matched_policy_id);
573
574 switch (necp_result) {
575 case NECP_KERNEL_POLICY_RESULT_PASS:
576 if (necp_result_parameter.pass_flags & NECP_KERNEL_POLICY_PASS_NO_SKIP_IPSEC) {
577 break;
578 }
579 goto skip_ipsec;
580 case NECP_KERNEL_POLICY_RESULT_DROP:
581 error = EHOSTUNREACH;
582 ip6stat.ip6s_necp_policy_drop++;
583 goto freehdrs;
584 case NECP_KERNEL_POLICY_RESULT_SOCKET_DIVERT:
585 /*
586 * Flow divert packets should be blocked at the IP
587 * layer.
588 */
589 error = EHOSTUNREACH;
590 ip6stat.ip6s_necp_policy_drop++;
591 goto freehdrs;
592 case NECP_KERNEL_POLICY_RESULT_IP_TUNNEL: {
593 /*
594 * Verify that the packet is being routed to the tunnel
595 */
596 struct ifnet *policy_ifp =
597 necp_get_ifnet_from_result_parameter(
598 &necp_result_parameter);
599
600 /*
601 * Update the QOS marking policy if
602 * 1. upper layer asks it to do so
603 * 2. net_qos_policy_restricted is not set
604 * 3. qos_marking_gencount doesn't match necp_kernel_socket_policies_gencount (checked in necp_lookup_current_qos_marking)
605 */
606 if (ip6oa != NULL && (ip6oa->ip6oa_flags & IP6OAF_REDO_QOSMARKING_POLICY) &&
607 net_qos_policy_restricted != 0) {
608 bool qos_marking = (ip6oa->ip6oa_flags & IP6OAF_QOSMARKING_ALLOWED) != 0;
609 qos_marking = necp_lookup_current_qos_marking(&ip6oa->qos_marking_gencount, NULL, policy_ifp, necp_result_parameter.route_rule_id, qos_marking);
610 if (qos_marking) {
611 ip6oa->ip6oa_flags |= IP6OAF_QOSMARKING_ALLOWED;
612 } else {
613 ip6oa->ip6oa_flags &= ~IP6OAF_QOSMARKING_ALLOWED;
614 }
615 }
616
617 if (policy_ifp == ifp) {
618 goto skip_ipsec;
619 } else {
620 if (necp_packet_can_rebind_to_ifnet(m,
621 policy_ifp, (struct route *)&necp_route,
622 AF_INET6)) {
623 /*
624 * Set scoped index to the tunnel
625 * interface, since it is compatible
626 * with the packet. This will only work
627 * for callers who pass IPV6_OUTARGS,
628 * but that covers all of the clients
629 * we care about today.
630 */
631 if (flags & IPV6_OUTARGS) {
632 ip6oa->ip6oa_boundif =
633 policy_ifp->if_index;
634 ip6oa->ip6oa_flags |=
635 IP6OAF_BOUND_IF;
636 }
637 if (opt != NULL
638 && opt->ip6po_pktinfo != NULL) {
639 opt->ip6po_pktinfo->
640 ipi6_ifindex =
641 policy_ifp->if_index;
642 }
643 ro = &necp_route;
644 goto skip_ipsec;
645 } else {
646 error = ENETUNREACH;
647 ip6stat.ip6s_necp_policy_drop++;
648 goto freehdrs;
649 }
650 }
651 }
652 default:
653 break;
654 }
655 }
656 #endif /* NECP */
657
658 #if IPSEC
659 if (ipsec_bypass != 0 || ip6obf.noipsec) {
660 goto skip_ipsec;
661 }
662
663 if (sp == NULL) {
664 /* get a security policy for this packet */
665 if (so != NULL) {
666 sp = ipsec6_getpolicybysock(m, IPSEC_DIR_OUTBOUND,
667 so, &error);
668 } else {
669 sp = ipsec6_getpolicybyaddr(m, IPSEC_DIR_OUTBOUND,
670 0, &error);
671 }
672 if (sp == NULL) {
673 IPSEC_STAT_INCREMENT(ipsec6stat.out_inval);
674 goto freehdrs;
675 }
676 }
677
678 error = 0;
679
680 /* check policy */
681 switch (sp->policy) {
682 case IPSEC_POLICY_DISCARD:
683 case IPSEC_POLICY_GENERATE:
684 /*
685 * This packet is just discarded.
686 */
687 IPSEC_STAT_INCREMENT(ipsec6stat.out_polvio);
688 goto freehdrs;
689
690 case IPSEC_POLICY_BYPASS:
691 case IPSEC_POLICY_NONE:
692 /* no need to do IPsec. */
693 ip6obf.needipsec = FALSE;
694 break;
695
696 case IPSEC_POLICY_IPSEC:
697 if (sp->req == NULL) {
698 /* acquire a policy */
699 error = key_spdacquire(sp);
700 goto freehdrs;
701 }
702 if (sp->ipsec_if) {
703 goto skip_ipsec;
704 } else {
705 ip6obf.needipsec = TRUE;
706 }
707 break;
708
709 case IPSEC_POLICY_ENTRUST:
710 default:
711 printf("%s: Invalid policy found: %d\n", __func__, sp->policy);
712 break;
713 }
714 skip_ipsec:
715 #endif /* IPSEC */
716
717 /*
718 * Calculate the total length of the extension header chain.
719 * Keep the length of the unfragmentable part for fragmentation.
720 */
721 optlen = 0;
722 if (exthdrs.ip6e_hbh != NULL) {
723 optlen += exthdrs.ip6e_hbh->m_len;
724 }
725 if (exthdrs.ip6e_dest1 != NULL) {
726 optlen += exthdrs.ip6e_dest1->m_len;
727 }
728 if (exthdrs.ip6e_rthdr != NULL) {
729 optlen += exthdrs.ip6e_rthdr->m_len;
730 }
731 unfragpartlen = optlen + sizeof(struct ip6_hdr);
732
733 /* NOTE: we don't add AH/ESP length here. do that later. */
734 if (exthdrs.ip6e_dest2 != NULL) {
735 optlen += exthdrs.ip6e_dest2->m_len;
736 }
737
738 /*
739 * If we need IPsec, or there is at least one extension header,
740 * separate IP6 header from the payload.
741 */
742 if ((
743 #if IPSEC
744 ip6obf.needipsec ||
745 #endif /* IPSEC */
746 optlen) && !ip6obf.hdrsplit) {
747 if ((error = ip6_splithdr(m, &exthdrs)) != 0) {
748 m = NULL;
749 goto freehdrs;
750 }
751 m = exthdrs.ip6e_ip6;
752 ip6obf.hdrsplit = TRUE;
753 }
754
755 /* adjust pointer */
756 ip6 = mtod(m, struct ip6_hdr *);
757
758 /* adjust mbuf packet header length */
759 m->m_pkthdr.len += optlen;
760 plen = m->m_pkthdr.len - sizeof(*ip6);
761
762 /* If this is a jumbo payload, insert a jumbo payload option. */
763 if (plen > IPV6_MAXPACKET) {
764 if (!ip6obf.hdrsplit) {
765 if ((error = ip6_splithdr(m, &exthdrs)) != 0) {
766 m = NULL;
767 goto freehdrs;
768 }
769 m = exthdrs.ip6e_ip6;
770 ip6obf.hdrsplit = TRUE;
771 }
772 /* adjust pointer */
773 ip6 = mtod(m, struct ip6_hdr *);
774 if ((error = ip6_insert_jumboopt(&exthdrs, plen)) != 0) {
775 goto freehdrs;
776 }
777 ip6->ip6_plen = 0;
778 } else {
779 ip6->ip6_plen = htons((uint16_t)plen);
780 }
781 /*
782 * Concatenate headers and fill in next header fields.
783 * Here we have, on "m"
784 * IPv6 payload
785 * and we insert headers accordingly. Finally, we should be getting:
786 * IPv6 hbh dest1 rthdr ah* [esp* dest2 payload]
787 *
788 * during the header composing process, "m" points to IPv6 header.
789 * "mprev" points to an extension header prior to esp.
790 */
791 nexthdrp = &ip6->ip6_nxt;
792 mprev = m;
793
794 /*
795 * we treat dest2 specially. this makes IPsec processing
796 * much easier. the goal here is to make mprev point the
797 * mbuf prior to dest2.
798 *
799 * result: IPv6 dest2 payload
800 * m and mprev will point to IPv6 header.
801 */
802 if (exthdrs.ip6e_dest2 != NULL) {
803 if (!ip6obf.hdrsplit) {
804 panic("assumption failed: hdr not split");
805 /* NOTREACHED */
806 }
807 exthdrs.ip6e_dest2->m_next = m->m_next;
808 m->m_next = exthdrs.ip6e_dest2;
809 *mtod(exthdrs.ip6e_dest2, u_char *) = ip6->ip6_nxt;
810 ip6->ip6_nxt = IPPROTO_DSTOPTS;
811 }
812
813 #define MAKE_CHAIN(m, mp, p, i) do { \
814 if (m != NULL) { \
815 if (!ip6obf.hdrsplit) { \
816 panic("assumption failed: hdr not split"); \
817 /* NOTREACHED */ \
818 } \
819 *mtod((m), u_char *) = *(p); \
820 *(p) = (i); \
821 p = mtod((m), u_char *); \
822 (m)->m_next = (mp)->m_next; \
823 (mp)->m_next = (m); \
824 (mp) = (m); \
825 } \
826 } while (0)
827 /*
828 * result: IPv6 hbh dest1 rthdr dest2 payload
829 * m will point to IPv6 header. mprev will point to the
830 * extension header prior to dest2 (rthdr in the above case).
831 */
832 MAKE_CHAIN(exthdrs.ip6e_hbh, mprev, nexthdrp, IPPROTO_HOPOPTS);
833 MAKE_CHAIN(exthdrs.ip6e_dest1, mprev, nexthdrp, IPPROTO_DSTOPTS);
834 MAKE_CHAIN(exthdrs.ip6e_rthdr, mprev, nexthdrp, IPPROTO_ROUTING);
835
836 /* It is no longer safe to free the pointers in exthdrs. */
837 exthdrs.merged = TRUE;
838
839 #undef MAKE_CHAIN
840
841 #if IPSEC
842 if (ip6obf.needipsec && (m->m_pkthdr.csum_flags & CSUM_DELAY_IPV6_DATA)) {
843 in6_delayed_cksum_offset(m, 0, optlen, nxt0);
844 }
845 #endif /* IPSEC */
846
847 if (!TAILQ_EMPTY(&ipv6_filters) &&
848 !((flags & IPV6_OUTARGS) &&
849 (ip6oa->ip6oa_flags & IP6OAF_INTCOPROC_ALLOWED)
850 #if NECP
851 && !necp_packet_should_skip_filters(m)
852 #endif // NECP
853 )) {
854 struct ipfilter *filter;
855 int seen = (inject_filter_ref == NULL);
856 int fixscope = 0;
857
858 if (im6o != NULL && IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {
859 ippo->ippo_flags |= IPPOF_MCAST_OPTS;
860 IM6O_LOCK(im6o);
861 ippo->ippo_mcast_ifnet = im6o->im6o_multicast_ifp;
862 ippo->ippo_mcast_ttl = im6o->im6o_multicast_hlim;
863 ippo->ippo_mcast_loop = im6o->im6o_multicast_loop;
864 IM6O_UNLOCK(im6o);
865 }
866
867 /* Hack: embed the scope_id in the destination */
868 if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst) &&
869 (ip6->ip6_dst.s6_addr16[1] == 0) && (ro != NULL)) {
870 fixscope = 1;
871 ip6->ip6_dst.s6_addr16[1] =
872 htons((uint16_t)ro->ro_dst.sin6_scope_id);
873 }
874
875 ipf_ref();
876 TAILQ_FOREACH(filter, &ipv6_filters, ipf_link) {
877 /*
878 * Don't process packet twice if we've already seen it.
879 */
880 if (seen == 0) {
881 if ((struct ipfilter *)inject_filter_ref ==
882 filter) {
883 seen = 1;
884 }
885 } else if (filter->ipf_filter.ipf_output != NULL) {
886 errno_t result;
887
888 result = filter->ipf_filter.ipf_output(
889 filter->ipf_filter.cookie,
890 (mbuf_t *)&m, ippo);
891 if (result == EJUSTRETURN) {
892 ipf_unref();
893 m = NULL;
894 goto evaluateloop;
895 }
896 if (result != 0) {
897 ipf_unref();
898 goto bad;
899 }
900 }
901 }
902 ipf_unref();
903
904 ip6 = mtod(m, struct ip6_hdr *);
905 /* Hack: cleanup embedded scope_id if we put it there */
906 if (fixscope) {
907 ip6->ip6_dst.s6_addr16[1] = 0;
908 }
909 }
910
911 #if IPSEC
912 if (ip6obf.needipsec) {
913 uint8_t segleft_org;
914
915 /*
916 * pointers after IPsec headers are not valid any more.
917 * other pointers need a great care too.
918 * (IPsec routines should not mangle mbufs prior to AH/ESP)
919 */
920 exthdrs.ip6e_dest2 = NULL;
921
922 if (exthdrs.ip6e_rthdr != NULL) {
923 rh = mtod(exthdrs.ip6e_rthdr, struct ip6_rthdr *);
924 segleft_org = rh->ip6r_segleft;
925 rh->ip6r_segleft = 0;
926 } else {
927 rh = NULL;
928 segleft_org = 0;
929 }
930
931 ipsec_state.m = m;
932 error = ipsec6_output_trans(&ipsec_state, nexthdrp, mprev,
933 sp, flags, &needipsectun);
934 m = ipsec_state.m;
935 if (error) {
936 /* mbuf is already reclaimed in ipsec6_output_trans. */
937 m = NULL;
938 switch (error) {
939 case EHOSTUNREACH:
940 case ENETUNREACH:
941 case EMSGSIZE:
942 case ENOBUFS:
943 case ENOMEM:
944 break;
945 default:
946 printf("ip6_output (ipsec): error code %d\n",
947 error);
948 OS_FALLTHROUGH;
949 case ENOENT:
950 /* don't show these error codes to the user */
951 error = 0;
952 break;
953 }
954 goto bad;
955 }
956 if (exthdrs.ip6e_rthdr != NULL) {
957 /* ah6_output doesn't modify mbuf chain */
958 rh->ip6r_segleft = segleft_org;
959 }
960 }
961 #endif /* IPSEC */
962
963 /* If there is a routing header, discard the packet. */
964 if (exthdrs.ip6e_rthdr != NULL) {
965 error = EINVAL;
966 goto bad;
967 }
968
969 /* Source address validation */
970 if (IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src) &&
971 !(flags & IPV6_UNSPECSRC)) {
972 error = EOPNOTSUPP;
973 ip6stat.ip6s_badscope++;
974 goto bad;
975 }
976 if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_src)) {
977 error = EOPNOTSUPP;
978 ip6stat.ip6s_badscope++;
979 goto bad;
980 }
981
982 ip6stat.ip6s_localout++;
983
984 /*
985 * Route packet.
986 */
987 if (ro == NULL) {
988 ro = &ip6route;
989 bzero((caddr_t)ro, sizeof(*ro));
990 }
991 ro_pmtu = ro;
992 if (opt != NULL && opt->ip6po_rthdr) {
993 ro = &opt->ip6po_route;
994 }
995 dst = SIN6(&ro->ro_dst);
996
997 if (ro->ro_rt != NULL) {
998 RT_LOCK_ASSERT_NOTHELD(ro->ro_rt);
999 }
1000 /*
1001 * if specified, try to fill in the traffic class field.
1002 * do not override if a non-zero value is already set.
1003 * we check the diffserv field and the ecn field separately.
1004 */
1005 if (opt != NULL && opt->ip6po_tclass >= 0) {
1006 int mask = 0;
1007
1008 if ((ip6->ip6_flow & htonl(0xfc << 20)) == 0) {
1009 mask |= 0xfc;
1010 }
1011 if ((ip6->ip6_flow & htonl(0x03 << 20)) == 0) {
1012 mask |= 0x03;
1013 }
1014 if (mask != 0) {
1015 ip6->ip6_flow |=
1016 htonl((opt->ip6po_tclass & mask) << 20);
1017 }
1018 }
1019
1020 /* fill in or override the hop limit field, if necessary. */
1021 if (opt && opt->ip6po_hlim != -1) {
1022 ip6->ip6_hlim = opt->ip6po_hlim & 0xff;
1023 } else if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {
1024 if (im6o != NULL) {
1025 IM6O_LOCK(im6o);
1026 ip6->ip6_hlim = im6o->im6o_multicast_hlim;
1027 IM6O_UNLOCK(im6o);
1028 } else {
1029 ip6->ip6_hlim = (uint8_t)ip6_defmcasthlim;
1030 }
1031 }
1032
1033 /*
1034 * If there is a cached route, check that it is to the same
1035 * destination and is still up. If not, free it and try again.
1036 * Test rt_flags without holding rt_lock for performance reasons;
1037 * if the route is down it will hopefully be caught by the layer
1038 * below (since it uses this route as a hint) or during the
1039 * next transmit.
1040 */
1041 if (ROUTE_UNUSABLE(ro) || dst->sin6_family != AF_INET6 ||
1042 !IN6_ARE_ADDR_EQUAL(&dst->sin6_addr, &ip6->ip6_dst)) {
1043 ROUTE_RELEASE(ro);
1044 }
1045
1046 if (ro->ro_rt == NULL) {
1047 bzero(dst, sizeof(*dst));
1048 dst->sin6_family = AF_INET6;
1049 dst->sin6_len = sizeof(struct sockaddr_in6);
1050 dst->sin6_addr = ip6->ip6_dst;
1051 }
1052 #if IPSEC
1053 if (ip6obf.needipsec && needipsectun) {
1054 #if CONFIG_DTRACE
1055 struct ifnet *trace_ifp = (ifpp_save != NULL) ? (*ifpp_save) : NULL;
1056 #endif /* CONFIG_DTRACE */
1057 /*
1058 * All the extension headers will become inaccessible
1059 * (since they can be encrypted).
1060 * Don't panic, we need no more updates to extension headers
1061 * on inner IPv6 packet (since they are now encapsulated).
1062 *
1063 * IPv6 [ESP|AH] IPv6 [extension headers] payload
1064 */
1065 bzero(&exthdrs, sizeof(exthdrs));
1066 exthdrs.ip6e_ip6 = m;
1067
1068 ipsec_state.m = m;
1069 route_copyout((struct route *)&ipsec_state.ro, (struct route *)ro,
1070 sizeof(struct route_in6));
1071 ipsec_state.dst = SA(dst);
1072
1073 /* So that we can see packets inside the tunnel */
1074 DTRACE_IP6(send, struct mbuf *, m, struct inpcb *, NULL,
1075 struct ip6_hdr *, ip6, struct ifnet *, trace_ifp,
1076 struct ip *, NULL, struct ip6_hdr *, ip6);
1077
1078 error = ipsec6_output_tunnel(&ipsec_state, sp, flags);
1079 /* tunneled in IPv4? packet is gone */
1080 if (ipsec_state.tunneled == 4) {
1081 m = NULL;
1082 goto evaluateloop;
1083 }
1084 m = ipsec_state.m;
1085 ipsec_saved_route = ro;
1086 ro = (struct route_in6 *)&ipsec_state.ro;
1087 dst = SIN6(ipsec_state.dst);
1088 if (error) {
1089 /* mbuf is already reclaimed in ipsec6_output_tunnel. */
1090 m = NULL;
1091 switch (error) {
1092 case EHOSTUNREACH:
1093 case ENETUNREACH:
1094 case EMSGSIZE:
1095 case ENOBUFS:
1096 case ENOMEM:
1097 break;
1098 default:
1099 printf("ip6_output (ipsec): error code %d\n",
1100 error);
1101 OS_FALLTHROUGH;
1102 case ENOENT:
1103 /* don't show these error codes to the user */
1104 error = 0;
1105 break;
1106 }
1107 goto bad;
1108 }
1109 /*
1110 * The packet has been encapsulated so the ifscope
1111 * is no longer valid since it does not apply to the
1112 * outer address: ignore the ifscope.
1113 */
1114 if (flags & IPV6_OUTARGS) {
1115 ip6oa->ip6oa_boundif = IFSCOPE_NONE;
1116 ip6oa->ip6oa_flags &= ~IP6OAF_BOUND_IF;
1117 }
1118 if (opt != NULL && opt->ip6po_pktinfo != NULL) {
1119 if (opt->ip6po_pktinfo->ipi6_ifindex != IFSCOPE_NONE) {
1120 opt->ip6po_pktinfo->ipi6_ifindex = IFSCOPE_NONE;
1121 }
1122 }
1123 exthdrs.ip6e_ip6 = m;
1124 }
1125 #endif /* IPSEC */
1126
1127 /*
1128 * ifp should only be filled in for dummy net packets which will jump
1129 * to check_with_pf label.
1130 */
1131 if (ifp != NULL) {
1132 VERIFY(ip6obf.route_selected);
1133 }
1134
1135 /* adjust pointer */
1136 ip6 = mtod(m, struct ip6_hdr *);
1137
1138 if (ip6obf.select_srcif) {
1139 bzero(&src_sa, sizeof(src_sa));
1140 src_sa.sin6_family = AF_INET6;
1141 src_sa.sin6_len = sizeof(src_sa);
1142 src_sa.sin6_addr = ip6->ip6_src;
1143 }
1144 bzero(&dst_sa, sizeof(dst_sa));
1145 dst_sa.sin6_family = AF_INET6;
1146 dst_sa.sin6_len = sizeof(dst_sa);
1147 dst_sa.sin6_addr = ip6->ip6_dst;
1148
1149 /*
1150 * Only call in6_selectroute() on first iteration to avoid taking
1151 * multiple references on ifp and rt.
1152 *
1153 * in6_selectroute() might return an ifp with its reference held
1154 * even in the error case, so make sure to release its reference.
1155 * ip6oa may be NULL if IPV6_OUTARGS isn't set.
1156 */
1157 if (!ip6obf.route_selected) {
1158 error = in6_selectroute( ip6obf.select_srcif ? &src_sa : NULL,
1159 &dst_sa, opt, im6o, &src_ia, ro, &ifp, &rt, 0, ip6oa);
1160
1161 if (error != 0) {
1162 switch (error) {
1163 case EHOSTUNREACH:
1164 ip6stat.ip6s_noroute++;
1165 break;
1166 case EADDRNOTAVAIL:
1167 default:
1168 break; /* XXX statistics? */
1169 }
1170 if (ifp != NULL) {
1171 in6_ifstat_inc(ifp, ifs6_out_discard);
1172 }
1173 /* ifp (if non-NULL) will be released at the end */
1174 goto bad;
1175 }
1176 ip6obf.route_selected = TRUE;
1177 }
1178 if (rt == NULL) {
1179 /*
1180 * If in6_selectroute() does not return a route entry,
1181 * dst may not have been updated.
1182 */
1183 *dst = dst_sa; /* XXX */
1184 }
1185
1186 #if NECP
1187 /* Catch-all to check if the interface is allowed */
1188 if (!necp_packet_is_allowed_over_interface(m, ifp)) {
1189 error = EHOSTUNREACH;
1190 ip6stat.ip6s_necp_policy_drop++;
1191 goto bad;
1192 }
1193 #endif /* NECP */
1194
1195 /*
1196 * then rt (for unicast) and ifp must be non-NULL valid values.
1197 */
1198 if (!(flags & IPV6_FORWARDING)) {
1199 in6_ifstat_inc_na(ifp, ifs6_out_request);
1200 }
1201 if (rt != NULL) {
1202 RT_LOCK(rt);
1203 if (ia == NULL) {
1204 ia = (struct in6_ifaddr *)(rt->rt_ifa);
1205 if (ia != NULL) {
1206 IFA_ADDREF(&ia->ia_ifa);
1207 }
1208 }
1209 rt->rt_use++;
1210 RT_UNLOCK(rt);
1211 }
1212
1213 /*
1214 * The outgoing interface must be in the zone of source and
1215 * destination addresses (except local/loopback). We should
1216 * use ia_ifp to support the case of sending packets to an
1217 * address of our own.
1218 */
1219 if (ia != NULL && ia->ia_ifp) {
1220 ifnet_reference(ia->ia_ifp); /* for origifp */
1221 if (origifp != NULL) {
1222 ifnet_release(origifp);
1223 }
1224 origifp = ia->ia_ifp;
1225 } else {
1226 if (ifp != NULL) {
1227 ifnet_reference(ifp); /* for origifp */
1228 }
1229 if (origifp != NULL) {
1230 ifnet_release(origifp);
1231 }
1232 origifp = ifp;
1233 }
1234
1235 /* skip scope enforcements for local/loopback route */
1236 if (rt == NULL || !(rt->rt_ifp->if_flags & IFF_LOOPBACK)) {
1237 struct in6_addr src0, dst0;
1238 u_int32_t zone;
1239
1240 src0 = ip6->ip6_src;
1241 if (in6_setscope(&src0, origifp, &zone)) {
1242 goto badscope;
1243 }
1244 bzero(&src_sa, sizeof(src_sa));
1245 src_sa.sin6_family = AF_INET6;
1246 src_sa.sin6_len = sizeof(src_sa);
1247 src_sa.sin6_addr = ip6->ip6_src;
1248 if ((sa6_recoverscope(&src_sa, TRUE) ||
1249 zone != src_sa.sin6_scope_id)) {
1250 goto badscope;
1251 }
1252
1253 dst0 = ip6->ip6_dst;
1254 if ((in6_setscope(&dst0, origifp, &zone))) {
1255 goto badscope;
1256 }
1257 /* re-initialize to be sure */
1258 bzero(&dst_sa, sizeof(dst_sa));
1259 dst_sa.sin6_family = AF_INET6;
1260 dst_sa.sin6_len = sizeof(dst_sa);
1261 dst_sa.sin6_addr = ip6->ip6_dst;
1262 if ((sa6_recoverscope(&dst_sa, TRUE) ||
1263 zone != dst_sa.sin6_scope_id)) {
1264 goto badscope;
1265 }
1266
1267 /* scope check is done. */
1268 goto routefound;
1269
1270 badscope:
1271 ip6stat.ip6s_badscope++;
1272 in6_ifstat_inc(origifp, ifs6_out_discard);
1273 if (error == 0) {
1274 error = EHOSTUNREACH; /* XXX */
1275 }
1276 goto bad;
1277 }
1278
1279 routefound:
1280 if (rt != NULL && !IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {
1281 if (opt != NULL && opt->ip6po_nextroute.ro_rt) {
1282 /*
1283 * The nexthop is explicitly specified by the
1284 * application. We assume the next hop is an IPv6
1285 * address.
1286 */
1287 dst = SIN6(opt->ip6po_nexthop);
1288 } else if ((rt->rt_flags & RTF_GATEWAY)) {
1289 dst = SIN6(rt->rt_gateway);
1290 }
1291 /*
1292 * For packets destined to local/loopback, record the
1293 * source the source interface (which owns the source
1294 * address), as well as the output interface. This is
1295 * needed to reconstruct the embedded zone for the
1296 * link-local address case in ip6_input().
1297 */
1298 if (ia != NULL && (ifp->if_flags & IFF_LOOPBACK)) {
1299 uint32_t srcidx;
1300
1301 if (src_ia != NULL) {
1302 srcidx = src_ia->ia_ifp->if_index;
1303 } else if (ro->ro_srcia != NULL) {
1304 srcidx = ro->ro_srcia->ifa_ifp->if_index;
1305 } else {
1306 srcidx = 0;
1307 }
1308
1309 ip6_setsrcifaddr_info(m, srcidx, NULL);
1310 ip6_setdstifaddr_info(m, 0, ia);
1311 }
1312 }
1313
1314 if (!IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {
1315 m->m_flags &= ~(M_BCAST | M_MCAST); /* just in case */
1316 } else {
1317 struct in6_multi *in6m;
1318
1319 m->m_flags = (m->m_flags & ~M_BCAST) | M_MCAST;
1320 in6_ifstat_inc_na(ifp, ifs6_out_mcast);
1321
1322 /*
1323 * Confirm that the outgoing interface supports multicast.
1324 */
1325 if (!(ifp->if_flags & IFF_MULTICAST)) {
1326 ip6stat.ip6s_noroute++;
1327 in6_ifstat_inc(ifp, ifs6_out_discard);
1328 error = ENETUNREACH;
1329 goto bad;
1330 }
1331 in6_multihead_lock_shared();
1332 IN6_LOOKUP_MULTI(&ip6->ip6_dst, ifp, in6m);
1333 in6_multihead_lock_done();
1334 if (im6o != NULL) {
1335 IM6O_LOCK(im6o);
1336 }
1337 if (in6m != NULL &&
1338 (im6o == NULL || im6o->im6o_multicast_loop)) {
1339 if (im6o != NULL) {
1340 IM6O_UNLOCK(im6o);
1341 }
1342 /*
1343 * If we belong to the destination multicast group
1344 * on the outgoing interface, and the caller did not
1345 * forbid loopback, loop back a copy.
1346 */
1347 ip6_mloopback(NULL, ifp, m, dst, optlen, nxt0);
1348 } else if (im6o != NULL) {
1349 IM6O_UNLOCK(im6o);
1350 }
1351 if (in6m != NULL) {
1352 IN6M_REMREF(in6m);
1353 }
1354 /*
1355 * Multicasts with a hoplimit of zero may be looped back,
1356 * above, but must not be transmitted on a network.
1357 * Also, multicasts addressed to the loopback interface
1358 * are not sent -- the above call to ip6_mloopback() will
1359 * loop back a copy if this host actually belongs to the
1360 * destination group on the loopback interface.
1361 */
1362 if (ip6->ip6_hlim == 0 || (ifp->if_flags & IFF_LOOPBACK) ||
1363 IN6_IS_ADDR_MC_INTFACELOCAL(&ip6->ip6_dst)) {
1364 /* remove m from the packetchain and continue looping */
1365 if (m != NULL) {
1366 m_freem(m);
1367 }
1368 m = NULL;
1369 goto evaluateloop;
1370 }
1371 }
1372
1373 /*
1374 * Fill the outgoing inteface to tell the upper layer
1375 * to increment per-interface statistics.
1376 */
1377 if (ifpp != NULL && *ifpp == NULL) {
1378 ifnet_reference(ifp); /* for caller */
1379 *ifpp = ifp;
1380 }
1381
1382 /* Determine path MTU. */
1383 if ((error = ip6_getpmtu(ro_pmtu, ro, ifp, &finaldst, &mtu)) != 0) {
1384 goto bad;
1385 }
1386
1387 /*
1388 * The caller of this function may specify to use the minimum MTU
1389 * in some cases.
1390 * An advanced API option (IPV6_USE_MIN_MTU) can also override MTU
1391 * setting. The logic is a bit complicated; by default, unicast
1392 * packets will follow path MTU while multicast packets will be sent at
1393 * the minimum MTU. If IP6PO_MINMTU_ALL is specified, all packets
1394 * including unicast ones will be sent at the minimum MTU. Multicast
1395 * packets will always be sent at the minimum MTU unless
1396 * IP6PO_MINMTU_DISABLE is explicitly specified.
1397 * See RFC 3542 for more details.
1398 */
1399 if (mtu > IPV6_MMTU) {
1400 if ((flags & IPV6_MINMTU)) {
1401 mtu = IPV6_MMTU;
1402 } else if (opt && opt->ip6po_minmtu == IP6PO_MINMTU_ALL) {
1403 mtu = IPV6_MMTU;
1404 } else if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) &&
1405 (opt == NULL ||
1406 opt->ip6po_minmtu != IP6PO_MINMTU_DISABLE)) {
1407 mtu = IPV6_MMTU;
1408 }
1409 }
1410
1411 /*
1412 * clear embedded scope identifiers if necessary.
1413 * in6_clearscope will touch the addresses only when necessary.
1414 */
1415 in6_clearscope(&ip6->ip6_src);
1416 in6_clearscope(&ip6->ip6_dst);
1417 /*
1418 * If the outgoing packet contains a hop-by-hop options header,
1419 * it must be examined and processed even by the source node.
1420 * (RFC 2460, section 4.)
1421 */
1422 if (exthdrs.ip6e_hbh != NULL) {
1423 struct ip6_hbh *hbh = mtod(exthdrs.ip6e_hbh, struct ip6_hbh *);
1424 u_int32_t dummy; /* XXX unused */
1425 uint32_t oplen = 0; /* for ip6_process_hopopts() */
1426 #if DIAGNOSTIC
1427 if ((hbh->ip6h_len + 1) << 3 > exthdrs.ip6e_hbh->m_len) {
1428 panic("ip6e_hbh is not continuous");
1429 }
1430 #endif
1431 /*
1432 * XXX: If we have to send an ICMPv6 error to the sender,
1433 * we need the M_LOOP flag since icmp6_error() expects
1434 * the IPv6 and the hop-by-hop options header are
1435 * continuous unless the flag is set.
1436 */
1437 m->m_flags |= M_LOOP;
1438 m->m_pkthdr.rcvif = ifp;
1439 if (ip6_process_hopopts(m, (u_int8_t *)(hbh + 1),
1440 ((hbh->ip6h_len + 1) << 3) - sizeof(struct ip6_hbh),
1441 &dummy, &oplen) < 0) {
1442 /*
1443 * m was already freed at this point. Set to NULL so it
1444 * is not re-freed at end of ip6_output_list.
1445 */
1446 m = NULL;
1447 error = EINVAL; /* better error? */
1448 goto bad;
1449 }
1450 m->m_flags &= ~M_LOOP; /* XXX */
1451 m->m_pkthdr.rcvif = NULL;
1452 }
1453
1454 #if DUMMYNET
1455 check_with_pf:
1456 #endif /* DUMMYNET */
1457 #if PF
1458 if (PF_IS_ENABLED && !skip_pf) {
1459 #if DUMMYNET
1460
1461 /*
1462 * TODO: Need to save opt->ip6po_flags for reinjection
1463 * rdar://10434993
1464 */
1465 args.fwa_m = m;
1466 args.fwa_oif = ifp;
1467 args.fwa_oflags = flags;
1468 if (flags & IPV6_OUTARGS) {
1469 args.fwa_ip6oa = ip6oa;
1470 }
1471 args.fwa_ro6 = ro;
1472 args.fwa_dst6 = dst;
1473 args.fwa_ro6_pmtu = ro_pmtu;
1474 args.fwa_origifp = origifp;
1475 args.fwa_mtu = mtu;
1476 args.fwa_unfragpartlen = unfragpartlen;
1477 args.fwa_exthdrs = &exthdrs;
1478 /* Invoke outbound packet filter */
1479 error = pf_af_hook(ifp, NULL, &m, AF_INET6, FALSE, &args);
1480 #else /* !DUMMYNET */
1481 error = pf_af_hook(ifp, NULL, &m, AF_INET6, FALSE, NULL);
1482 #endif /* !DUMMYNET */
1483
1484 if (error != 0 || m == NULL) {
1485 if (m != NULL) {
1486 panic("%s: unexpected packet %p\n",
1487 __func__, m);
1488 /* NOTREACHED */
1489 }
1490 /* m was already freed by callee and is now NULL. */
1491 goto evaluateloop;
1492 }
1493 ip6 = mtod(m, struct ip6_hdr *);
1494 }
1495 #endif /* PF */
1496
1497 #ifdef IPSEC
1498 /* clean ipsec history before fragmentation */
1499 ipsec_delaux(m);
1500 #endif /* IPSEC */
1501
1502 if (ip6oa != NULL) {
1503 u_int8_t dscp;
1504
1505 dscp = (ntohl(ip6->ip6_flow) & IP6FLOW_DSCP_MASK) >> IP6FLOW_DSCP_SHIFT;
1506
1507 error = set_packet_qos(m, ifp,
1508 ip6oa->ip6oa_flags & IP6OAF_QOSMARKING_ALLOWED ? TRUE : FALSE,
1509 ip6oa->ip6oa_sotc, ip6oa->ip6oa_netsvctype, &dscp);
1510 if (error == 0) {
1511 ip6->ip6_flow &= ~htonl(IP6FLOW_DSCP_MASK);
1512 ip6->ip6_flow |= htonl((u_int32_t)dscp << IP6FLOW_DSCP_SHIFT);
1513 } else {
1514 printf("%s if_dscp_for_mbuf() error %d\n", __func__, error);
1515 error = 0;
1516 }
1517 }
1518 /*
1519 * Determine whether fragmentation is necessary. If so, m is passed
1520 * back as a chain of packets and original mbuf is freed. Otherwise, m
1521 * is unchanged.
1522 */
1523 error = ip6_fragment_packet(&m, opt, ip6oa,
1524 &exthdrs, ifp, mtu, unfragpartlen, ro_pmtu, nxt0,
1525 optlen);
1526
1527 if (error) {
1528 goto bad;
1529 }
1530
1531 /*
1532 * The evaluateloop label is where we decide whether to continue looping over
1533 * packets or call into nd code to send.
1534 */
1535 evaluateloop:
1536
1537 /*
1538 * m may be NULL when we jump to the evaluateloop label from PF or
1539 * other code that can drop packets.
1540 */
1541 if (m != NULL) {
1542 /*
1543 * If we already have a chain to send, tack m onto the end.
1544 * Otherwise make m the start and end of the to-be-sent chain.
1545 */
1546 if (sendchain != NULL) {
1547 sendchain_last->m_nextpkt = m;
1548 } else {
1549 sendchain = m;
1550 }
1551
1552 /* Fragmentation may mean m is a chain. Find the last packet. */
1553 while (m->m_nextpkt) {
1554 m = m->m_nextpkt;
1555 }
1556 sendchain_last = m;
1557 pktcnt++;
1558 }
1559
1560 /* Fill in next m from inputchain as appropriate. */
1561 m = inputchain;
1562 if (m != NULL) {
1563 /* Isolate m from rest of input chain. */
1564 inputchain = m->m_nextpkt;
1565 m->m_nextpkt = NULL;
1566
1567 /*
1568 * Clear exthdrs and ipsec_state so stale contents are not
1569 * reused. Note this also clears the exthdrs.merged flag.
1570 */
1571 bzero(&exthdrs, sizeof(exthdrs));
1572 bzero(&ipsec_state, sizeof(ipsec_state));
1573
1574 /* Continue looping. */
1575 goto loopit;
1576 }
1577
1578 /*
1579 * If we get here, there's no more mbufs in inputchain, so send the
1580 * sendchain if there is one.
1581 */
1582 if (pktcnt > 0) {
1583 error = nd6_output_list(ifp, origifp, sendchain, dst,
1584 ro->ro_rt, adv);
1585 /*
1586 * Fall through to done label even in error case because
1587 * nd6_output_list frees packetchain in both success and
1588 * failure cases.
1589 */
1590 }
1591
1592 done:
1593 if (ifpp_save != NULL && *ifpp_save != NULL) {
1594 ifnet_release(*ifpp_save);
1595 *ifpp_save = NULL;
1596 }
1597 ROUTE_RELEASE(&ip6route);
1598 #if IPSEC
1599 ROUTE_RELEASE(&ipsec_state.ro);
1600 if (sp != NULL) {
1601 key_freesp(sp, KEY_SADB_UNLOCKED);
1602 }
1603 #endif /* IPSEC */
1604 #if NECP
1605 ROUTE_RELEASE(&necp_route);
1606 #endif /* NECP */
1607 #if DUMMYNET
1608 ROUTE_RELEASE(&saved_route);
1609 ROUTE_RELEASE(&saved_ro_pmtu);
1610 #endif /* DUMMYNET */
1611
1612 if (ia != NULL) {
1613 IFA_REMREF(&ia->ia_ifa);
1614 }
1615 if (src_ia != NULL) {
1616 IFA_REMREF(&src_ia->ia_ifa);
1617 }
1618 if (ifp != NULL) {
1619 ifnet_release(ifp);
1620 }
1621 if (origifp != NULL) {
1622 ifnet_release(origifp);
1623 }
1624 if (ip6_output_measure) {
1625 net_perf_measure_time(&net_perf, &start_tv, packets_processed);
1626 net_perf_histogram(&net_perf, packets_processed);
1627 }
1628 return error;
1629
1630 freehdrs:
1631 if (exthdrs.ip6e_hbh != NULL) {
1632 if (exthdrs.merged) {
1633 panic("Double free of ip6e_hbh");
1634 }
1635 m_freem(exthdrs.ip6e_hbh);
1636 }
1637 if (exthdrs.ip6e_dest1 != NULL) {
1638 if (exthdrs.merged) {
1639 panic("Double free of ip6e_dest1");
1640 }
1641 m_freem(exthdrs.ip6e_dest1);
1642 }
1643 if (exthdrs.ip6e_rthdr != NULL) {
1644 if (exthdrs.merged) {
1645 panic("Double free of ip6e_rthdr");
1646 }
1647 m_freem(exthdrs.ip6e_rthdr);
1648 }
1649 if (exthdrs.ip6e_dest2 != NULL) {
1650 if (exthdrs.merged) {
1651 panic("Double free of ip6e_dest2");
1652 }
1653 m_freem(exthdrs.ip6e_dest2);
1654 }
1655 /* FALLTHRU */
1656 bad:
1657 if (inputchain != NULL) {
1658 m_freem_list(inputchain);
1659 }
1660 if (sendchain != NULL) {
1661 m_freem_list(sendchain);
1662 }
1663 if (m != NULL) {
1664 m_freem(m);
1665 }
1666
1667 goto done;
1668
1669 #undef ipf_pktopts
1670 #undef exthdrs
1671 #undef ip6route
1672 #undef ipsec_state
1673 #undef saved_route
1674 #undef saved_ro_pmtu
1675 #undef args
1676 }
1677
1678 /* ip6_fragment_packet
1679 *
1680 * The fragmentation logic is rather complex:
1681 * 1: normal case (dontfrag == 0)
1682 * 1-a: send as is if tlen <= path mtu
1683 * 1-b: fragment if tlen > path mtu
1684 *
1685 * 2: if user asks us not to fragment (dontfrag == 1)
1686 * 2-a: send as is if tlen <= interface mtu
1687 * 2-b: error if tlen > interface mtu
1688 */
1689
1690 static int
1691 ip6_fragment_packet(struct mbuf **mptr, struct ip6_pktopts *opt,
1692 struct ip6_out_args *ip6oa, struct ip6_exthdrs *exthdrsp,
1693 struct ifnet *ifp, uint32_t mtu, uint32_t unfragpartlen,
1694 struct route_in6 *ro_pmtu, int nxt0, uint32_t optlen)
1695 {
1696 VERIFY(NULL != mptr);
1697 struct mbuf *m = *mptr;
1698 int error = 0;
1699 uint32_t tlen = m->m_pkthdr.len;
1700 boolean_t dontfrag = (opt != NULL && (opt->ip6po_flags & IP6PO_DONTFRAG)) ||
1701 (ip6oa != NULL && (ip6oa->ip6oa_flags & IP6OAF_DONT_FRAG));
1702
1703 if (m->m_pkthdr.pkt_flags & PKTF_FORWARDED) {
1704 dontfrag = TRUE;
1705 /*
1706 * Discard partial sum information if this packet originated
1707 * from another interface; the packet would already have the
1708 * final checksum and we shouldn't recompute it.
1709 */
1710 if ((m->m_pkthdr.csum_flags & (CSUM_DATA_VALID | CSUM_PARTIAL)) ==
1711 (CSUM_DATA_VALID | CSUM_PARTIAL)) {
1712 m->m_pkthdr.csum_flags &= ~CSUM_TX_FLAGS;
1713 m->m_pkthdr.csum_data = 0;
1714 }
1715 }
1716
1717 /* Access without acquiring nd_ifinfo lock for performance */
1718 if (dontfrag && tlen > IN6_LINKMTU(ifp)) { /* case 2-b */
1719 /*
1720 * Even if the DONTFRAG option is specified, we cannot send the
1721 * packet when the data length is larger than the MTU of the
1722 * outgoing interface.
1723 * Notify the error by sending IPV6_PATHMTU ancillary data as
1724 * well as returning an error code (the latter is not described
1725 * in the API spec.)
1726 */
1727 u_int32_t mtu32;
1728 struct ip6ctlparam ip6cp;
1729
1730 mtu32 = (u_int32_t)mtu;
1731 bzero(&ip6cp, sizeof(ip6cp));
1732 ip6cp.ip6c_cmdarg = (void *)&mtu32;
1733 pfctlinput2(PRC_MSGSIZE, SA(&ro_pmtu->ro_dst), (void *)&ip6cp);
1734 return EMSGSIZE;
1735 }
1736
1737 /*
1738 * transmit packet without fragmentation
1739 */
1740 if (dontfrag ||
1741 (tlen <= mtu || TSO_IPV6_OK(ifp, m) ||
1742 (ifp->if_hwassist & CSUM_FRAGMENT_IPV6))) {
1743 /*
1744 * mppn not updated in this case because no new chain is formed
1745 * and inserted
1746 */
1747 ip6_output_checksum(ifp, mtu, m, nxt0, tlen, optlen);
1748 } else {
1749 /*
1750 * time to fragment - cases 1-b is handled inside
1751 * ip6_do_fragmentation().
1752 * mppn is passed down to be updated to point at fragment chain.
1753 */
1754 u_int8_t *lexthdrsp;
1755
1756 if (exthdrsp->ip6e_rthdr != NULL) {
1757 lexthdrsp = mtod(exthdrsp->ip6e_rthdr, uint8_t *);
1758 } else if (exthdrsp->ip6e_dest1 != NULL) {
1759 lexthdrsp = mtod(exthdrsp->ip6e_dest1, uint8_t *);
1760 } else if (exthdrsp->ip6e_hbh != NULL) {
1761 lexthdrsp = mtod(exthdrsp->ip6e_hbh, uint8_t *);
1762 } else {
1763 lexthdrsp = NULL;
1764 }
1765 error = ip6_do_fragmentation(mptr, optlen, ifp,
1766 unfragpartlen, mtod(m, struct ip6_hdr *), lexthdrsp, mtu,
1767 nxt0, htonl(ip6_randomid()));
1768 }
1769
1770 return error;
1771 }
1772
1773 /*
1774 * ip6_do_fragmentation() is called by ip6_fragment_packet() after determining
1775 * the packet needs to be fragmented. on success, morig is freed and a chain
1776 * of fragments is linked into the packet chain where morig existed. Otherwise,
1777 * an errno is returned.
1778 * optlen: total length of all extension headers (excludes the IPv6 header).
1779 * unfragpartlen: length of the per-fragment headers which consist of the IPv6
1780 * header plus any extension headers that must be processed by nodes
1781 * en route to the destination.
1782 * lexthdrsp: pointer to the last extension header in the unfragmentable part
1783 * or NULL.
1784 * nxt0: upper-layer protocol number.
1785 * id: Identification value to be used in the fragment header.
1786 */
1787 int
1788 ip6_do_fragmentation(struct mbuf **mptr, uint32_t optlen, struct ifnet *ifp,
1789 uint32_t unfragpartlen, struct ip6_hdr *ip6, uint8_t *lexthdrsp,
1790 uint32_t mtu, int nxt0, uint32_t id)
1791 {
1792 VERIFY(NULL != mptr);
1793 int error = 0;
1794
1795 struct mbuf *morig = *mptr;
1796 struct mbuf *first_mbufp = NULL;
1797 struct mbuf *last_mbufp = NULL;
1798
1799 uint32_t tlen = morig->m_pkthdr.len;
1800
1801 /* try to fragment the packet. case 1-b */
1802 if ((morig->m_pkthdr.csum_flags & CSUM_TSO_IPV6)) {
1803 /* TSO and fragment aren't compatible */
1804 in6_ifstat_inc(ifp, ifs6_out_fragfail);
1805 return EMSGSIZE;
1806 } else if (mtu < IPV6_MMTU) {
1807 /* path MTU cannot be less than IPV6_MMTU */
1808 in6_ifstat_inc(ifp, ifs6_out_fragfail);
1809 return EMSGSIZE;
1810 } else if (ip6->ip6_plen == 0) {
1811 /* jumbo payload cannot be fragmented */
1812 in6_ifstat_inc(ifp, ifs6_out_fragfail);
1813 return EMSGSIZE;
1814 } else {
1815 uint32_t hlen, off, len;
1816 struct mbuf **mnext = NULL;
1817 struct ip6_frag *ip6f;
1818 u_char nextproto;
1819
1820 /*
1821 * Too large for the destination or interface;
1822 * fragment if possible.
1823 * Must be able to put at least 8 bytes per fragment.
1824 */
1825 hlen = unfragpartlen;
1826 if (mtu > IPV6_MAXPACKET) {
1827 mtu = IPV6_MAXPACKET;
1828 }
1829
1830 len = (mtu - hlen - sizeof(struct ip6_frag)) & ~7;
1831 if (len < 8) {
1832 in6_ifstat_inc(ifp, ifs6_out_fragfail);
1833 return EMSGSIZE;
1834 }
1835
1836 /*
1837 * Change the next header field of the last header in the
1838 * unfragmentable part.
1839 */
1840 if (lexthdrsp != NULL) {
1841 nextproto = *lexthdrsp;
1842 *lexthdrsp = IPPROTO_FRAGMENT;
1843 } else {
1844 nextproto = ip6->ip6_nxt;
1845 ip6->ip6_nxt = IPPROTO_FRAGMENT;
1846 }
1847
1848 if (morig->m_pkthdr.csum_flags & CSUM_DELAY_IPV6_DATA) {
1849 in6_delayed_cksum_offset(morig, 0, optlen, nxt0);
1850 }
1851
1852 /*
1853 * Loop through length of segment after first fragment,
1854 * make new header and copy data of each part and link onto
1855 * chain.
1856 */
1857 for (off = hlen; off < tlen; off += len) {
1858 struct ip6_hdr *new_mhip6;
1859 struct mbuf *new_m;
1860 struct mbuf *m_frgpart;
1861
1862 MGETHDR(new_m, M_DONTWAIT, MT_HEADER); /* MAC-OK */
1863 if (new_m == NULL) {
1864 error = ENOBUFS;
1865 ip6stat.ip6s_odropped++;
1866 break;
1867 }
1868 new_m->m_pkthdr.rcvif = NULL;
1869 new_m->m_flags = morig->m_flags & M_COPYFLAGS;
1870
1871 if (first_mbufp != NULL) {
1872 /* Every pass through loop but first */
1873 *mnext = new_m;
1874 last_mbufp = new_m;
1875 } else {
1876 /* This is the first element of the fragment chain */
1877 first_mbufp = new_m;
1878 last_mbufp = new_m;
1879 }
1880 mnext = &new_m->m_nextpkt;
1881
1882 new_m->m_data += max_linkhdr;
1883 new_mhip6 = mtod(new_m, struct ip6_hdr *);
1884 *new_mhip6 = *ip6;
1885 new_m->m_len = sizeof(*new_mhip6);
1886
1887 error = ip6_insertfraghdr(morig, new_m, hlen, &ip6f);
1888 if (error) {
1889 ip6stat.ip6s_odropped++;
1890 break;
1891 }
1892
1893 ip6f->ip6f_offlg = htons((u_short)((off - hlen) & ~7));
1894 if (off + len >= tlen) {
1895 len = tlen - off;
1896 } else {
1897 ip6f->ip6f_offlg |= IP6F_MORE_FRAG;
1898 }
1899 new_mhip6->ip6_plen = htons((u_short)(len + hlen +
1900 sizeof(*ip6f) - sizeof(struct ip6_hdr)));
1901
1902 if ((m_frgpart = m_copy(morig, off, len)) == NULL) {
1903 error = ENOBUFS;
1904 ip6stat.ip6s_odropped++;
1905 break;
1906 }
1907 m_cat(new_m, m_frgpart);
1908 new_m->m_pkthdr.len = len + hlen + sizeof(*ip6f);
1909 new_m->m_pkthdr.rcvif = NULL;
1910
1911 M_COPY_CLASSIFIER(new_m, morig);
1912 M_COPY_PFTAG(new_m, morig);
1913 M_COPY_NECPTAG(new_m, morig);
1914
1915 ip6f->ip6f_reserved = 0;
1916 ip6f->ip6f_ident = id;
1917 ip6f->ip6f_nxt = nextproto;
1918 ip6stat.ip6s_ofragments++;
1919 in6_ifstat_inc(ifp, ifs6_out_fragcreat);
1920 }
1921
1922 if (error) {
1923 /* free all the fragments created */
1924 if (first_mbufp != NULL) {
1925 m_freem_list(first_mbufp);
1926 first_mbufp = NULL;
1927 }
1928 last_mbufp = NULL;
1929 } else {
1930 /* successful fragmenting */
1931 m_freem(morig);
1932 *mptr = first_mbufp;
1933 last_mbufp->m_nextpkt = NULL;
1934 ip6stat.ip6s_fragmented++;
1935 in6_ifstat_inc(ifp, ifs6_out_fragok);
1936 }
1937 }
1938 return error;
1939 }
1940
1941 static int
1942 ip6_copyexthdr(struct mbuf **mp, caddr_t hdr, int hlen)
1943 {
1944 struct mbuf *m;
1945
1946 if (hlen > MCLBYTES) {
1947 return ENOBUFS; /* XXX */
1948 }
1949 MGET(m, M_DONTWAIT, MT_DATA);
1950 if (m == NULL) {
1951 return ENOBUFS;
1952 }
1953
1954 if (hlen > MLEN) {
1955 MCLGET(m, M_DONTWAIT);
1956 if (!(m->m_flags & M_EXT)) {
1957 m_free(m);
1958 return ENOBUFS;
1959 }
1960 }
1961 m->m_len = hlen;
1962 if (hdr != NULL) {
1963 bcopy(hdr, mtod(m, caddr_t), hlen);
1964 }
1965
1966 *mp = m;
1967 return 0;
1968 }
1969
1970 static void
1971 ip6_out_cksum_stats(int proto, u_int32_t len)
1972 {
1973 switch (proto) {
1974 case IPPROTO_TCP:
1975 tcp_out6_cksum_stats(len);
1976 break;
1977 case IPPROTO_UDP:
1978 udp_out6_cksum_stats(len);
1979 break;
1980 default:
1981 /* keep only TCP or UDP stats for now */
1982 break;
1983 }
1984 }
1985
1986 /*
1987 * Process a delayed payload checksum calculation (outbound path.)
1988 *
1989 * hoff is the number of bytes beyond the mbuf data pointer which
1990 * points to the IPv6 header. optlen is the number of bytes, if any,
1991 * between the end of IPv6 header and the beginning of the ULP payload
1992 * header, which represents the extension headers. If optlen is less
1993 * than zero, this routine will bail when it detects extension headers.
1994 *
1995 * Returns a bitmask representing all the work done in software.
1996 */
1997 uint32_t
1998 in6_finalize_cksum(struct mbuf *m, uint32_t hoff, int32_t optlen,
1999 int32_t nxt0, uint32_t csum_flags)
2000 {
2001 unsigned char buf[sizeof(struct ip6_hdr)] __attribute__((aligned(8)));
2002 struct ip6_hdr *ip6;
2003 uint32_t offset, mlen, hlen, olen, sw_csum;
2004 uint16_t csum, ulpoff, plen;
2005 uint8_t nxt;
2006
2007 _CASSERT(sizeof(csum) == sizeof(uint16_t));
2008 VERIFY(m->m_flags & M_PKTHDR);
2009
2010 sw_csum = (csum_flags & m->m_pkthdr.csum_flags);
2011
2012 if ((sw_csum &= CSUM_DELAY_IPV6_DATA) == 0) {
2013 goto done;
2014 }
2015
2016 mlen = m->m_pkthdr.len; /* total mbuf len */
2017 hlen = sizeof(*ip6); /* IPv6 header len */
2018
2019 /* sanity check (need at least IPv6 header) */
2020 if (mlen < (hoff + hlen)) {
2021 panic("%s: mbuf %p pkt len (%u) < hoff+ip6_hdr "
2022 "(%u+%u)\n", __func__, m, mlen, hoff, hlen);
2023 /* NOTREACHED */
2024 }
2025
2026 /*
2027 * In case the IPv6 header is not contiguous, or not 32-bit
2028 * aligned, copy it to a local buffer.
2029 */
2030 if ((hoff + hlen) > m->m_len ||
2031 !IP6_HDR_ALIGNED_P(mtod(m, caddr_t) + hoff)) {
2032 m_copydata(m, hoff, hlen, (caddr_t)buf);
2033 ip6 = (struct ip6_hdr *)(void *)buf;
2034 } else {
2035 ip6 = (struct ip6_hdr *)(void *)(m->m_data + hoff);
2036 }
2037
2038 nxt = ip6->ip6_nxt;
2039 plen = ntohs(ip6->ip6_plen);
2040 if (plen != (mlen - (hoff + hlen))) {
2041 plen = OSSwapInt16(plen);
2042 if (plen != (mlen - (hoff + hlen))) {
2043 /* Don't complain for jumbograms */
2044 if (plen != 0 || nxt != IPPROTO_HOPOPTS) {
2045 printf("%s: mbuf 0x%llx proto %d IPv6 "
2046 "plen %d (%x) [swapped %d (%x)] doesn't "
2047 "match actual packet length; %d is used "
2048 "instead\n", __func__,
2049 (uint64_t)VM_KERNEL_ADDRPERM(m), nxt,
2050 ip6->ip6_plen, ip6->ip6_plen, plen, plen,
2051 (mlen - (hoff + hlen)));
2052 }
2053 plen = (uint16_t)(mlen - (hoff + hlen));
2054 }
2055 }
2056
2057 if (optlen < 0) {
2058 /* next header isn't TCP/UDP and we don't know optlen, bail */
2059 if (nxt != IPPROTO_TCP && nxt != IPPROTO_UDP) {
2060 sw_csum = 0;
2061 goto done;
2062 }
2063 olen = 0;
2064 } else {
2065 /* caller supplied the original transport number; use it */
2066 if (nxt0 >= 0) {
2067 nxt = (uint8_t)nxt0;
2068 }
2069 olen = optlen;
2070 }
2071
2072 offset = hoff + hlen + olen; /* ULP header */
2073
2074 /* sanity check */
2075 if (mlen < offset) {
2076 panic("%s: mbuf %p pkt len (%u) < hoff+ip6_hdr+ext_hdr "
2077 "(%u+%u+%u)\n", __func__, m, mlen, hoff, hlen, olen);
2078 /* NOTREACHED */
2079 }
2080
2081 /*
2082 * offset is added to the lower 16-bit value of csum_data,
2083 * which is expected to contain the ULP offset; therefore
2084 * CSUM_PARTIAL offset adjustment must be undone.
2085 */
2086 if ((m->m_pkthdr.csum_flags & (CSUM_PARTIAL | CSUM_DATA_VALID)) ==
2087 (CSUM_PARTIAL | CSUM_DATA_VALID)) {
2088 /*
2089 * Get back the original ULP offset (this will
2090 * undo the CSUM_PARTIAL logic in ip6_output.)
2091 */
2092 m->m_pkthdr.csum_data = (m->m_pkthdr.csum_tx_stuff -
2093 m->m_pkthdr.csum_tx_start);
2094 }
2095
2096 ulpoff = (m->m_pkthdr.csum_data & 0xffff); /* ULP csum offset */
2097
2098 if (mlen < (ulpoff + sizeof(csum))) {
2099 panic("%s: mbuf %p pkt len (%u) proto %d invalid ULP "
2100 "cksum offset (%u) cksum flags 0x%x\n", __func__,
2101 m, mlen, nxt, ulpoff, m->m_pkthdr.csum_flags);
2102 /* NOTREACHED */
2103 }
2104
2105 csum = inet6_cksum(m, 0, offset, plen - olen);
2106
2107 /* Update stats */
2108 ip6_out_cksum_stats(nxt, plen - olen);
2109
2110 /* RFC1122 4.1.3.4 */
2111 if (csum == 0 &&
2112 (m->m_pkthdr.csum_flags & (CSUM_UDPIPV6 | CSUM_ZERO_INVERT))) {
2113 csum = 0xffff;
2114 }
2115
2116 /* Insert the checksum in the ULP csum field */
2117 offset += ulpoff;
2118 if ((offset + sizeof(csum)) > m->m_len) {
2119 m_copyback(m, offset, sizeof(csum), &csum);
2120 } else if (IP6_HDR_ALIGNED_P(mtod(m, char *) + hoff)) {
2121 *(uint16_t *)(void *)(mtod(m, char *) + offset) = csum;
2122 } else {
2123 bcopy(&csum, (mtod(m, char *) + offset), sizeof(csum));
2124 }
2125 m->m_pkthdr.csum_flags &= ~(CSUM_DELAY_IPV6_DATA | CSUM_DATA_VALID |
2126 CSUM_PARTIAL | CSUM_ZERO_INVERT);
2127
2128 done:
2129 return sw_csum;
2130 }
2131
2132 /*
2133 * Insert jumbo payload option.
2134 */
2135 static int
2136 ip6_insert_jumboopt(struct ip6_exthdrs *exthdrs, u_int32_t plen)
2137 {
2138 struct mbuf *mopt;
2139 u_char *optbuf;
2140 u_int32_t v;
2141
2142 #define JUMBOOPTLEN 8 /* length of jumbo payload option and padding */
2143
2144 /*
2145 * If there is no hop-by-hop options header, allocate new one.
2146 * If there is one but it doesn't have enough space to store the
2147 * jumbo payload option, allocate a cluster to store the whole options.
2148 * Otherwise, use it to store the options.
2149 */
2150 if (exthdrs->ip6e_hbh == NULL) {
2151 MGET(mopt, M_DONTWAIT, MT_DATA);
2152 if (mopt == NULL) {
2153 return ENOBUFS;
2154 }
2155 mopt->m_len = JUMBOOPTLEN;
2156 optbuf = mtod(mopt, u_char *);
2157 optbuf[1] = 0; /* = ((JUMBOOPTLEN) >> 3) - 1 */
2158 exthdrs->ip6e_hbh = mopt;
2159 } else {
2160 struct ip6_hbh *hbh;
2161
2162 mopt = exthdrs->ip6e_hbh;
2163 if (M_TRAILINGSPACE(mopt) < JUMBOOPTLEN) {
2164 /*
2165 * XXX assumption:
2166 * - exthdrs->ip6e_hbh is not referenced from places
2167 * other than exthdrs.
2168 * - exthdrs->ip6e_hbh is not an mbuf chain.
2169 */
2170 u_int32_t oldoptlen = mopt->m_len;
2171 struct mbuf *n;
2172
2173 /*
2174 * XXX: give up if the whole (new) hbh header does
2175 * not fit even in an mbuf cluster.
2176 */
2177 if (oldoptlen + JUMBOOPTLEN > MCLBYTES) {
2178 return ENOBUFS;
2179 }
2180
2181 /*
2182 * As a consequence, we must always prepare a cluster
2183 * at this point.
2184 */
2185 MGET(n, M_DONTWAIT, MT_DATA);
2186 if (n != NULL) {
2187 MCLGET(n, M_DONTWAIT);
2188 if (!(n->m_flags & M_EXT)) {
2189 m_freem(n);
2190 n = NULL;
2191 }
2192 }
2193 if (n == NULL) {
2194 return ENOBUFS;
2195 }
2196 n->m_len = oldoptlen + JUMBOOPTLEN;
2197 bcopy(mtod(mopt, caddr_t), mtod(n, caddr_t),
2198 oldoptlen);
2199 optbuf = mtod(n, u_char *) + oldoptlen;
2200 m_freem(mopt);
2201 mopt = exthdrs->ip6e_hbh = n;
2202 } else {
2203 optbuf = mtod(mopt, u_char *) + mopt->m_len;
2204 mopt->m_len += JUMBOOPTLEN;
2205 }
2206 optbuf[0] = IP6OPT_PADN;
2207 optbuf[1] = 1;
2208
2209 /*
2210 * Adjust the header length according to the pad and
2211 * the jumbo payload option.
2212 */
2213 hbh = mtod(mopt, struct ip6_hbh *);
2214 hbh->ip6h_len += (JUMBOOPTLEN >> 3);
2215 }
2216
2217 /* fill in the option. */
2218 optbuf[2] = IP6OPT_JUMBO;
2219 optbuf[3] = 4;
2220 v = (u_int32_t)htonl(plen + JUMBOOPTLEN);
2221 bcopy(&v, &optbuf[4], sizeof(u_int32_t));
2222
2223 /* finally, adjust the packet header length */
2224 exthdrs->ip6e_ip6->m_pkthdr.len += JUMBOOPTLEN;
2225
2226 return 0;
2227 #undef JUMBOOPTLEN
2228 }
2229
2230 /*
2231 * Insert fragment header and copy unfragmentable header portions.
2232 */
2233 static int
2234 ip6_insertfraghdr(struct mbuf *m0, struct mbuf *m, int hlen,
2235 struct ip6_frag **frghdrp)
2236 {
2237 struct mbuf *n, *mlast;
2238
2239 if (hlen > sizeof(struct ip6_hdr)) {
2240 n = m_copym(m0, sizeof(struct ip6_hdr),
2241 hlen - sizeof(struct ip6_hdr), M_DONTWAIT);
2242 if (n == NULL) {
2243 return ENOBUFS;
2244 }
2245 m->m_next = n;
2246 } else {
2247 n = m;
2248 }
2249
2250 /* Search for the last mbuf of unfragmentable part. */
2251 for (mlast = n; mlast->m_next; mlast = mlast->m_next) {
2252 ;
2253 }
2254
2255 if (!(mlast->m_flags & M_EXT) &&
2256 M_TRAILINGSPACE(mlast) >= sizeof(struct ip6_frag)) {
2257 /* use the trailing space of the last mbuf for the frag hdr */
2258 *frghdrp = (struct ip6_frag *)(mtod(mlast, caddr_t) +
2259 mlast->m_len);
2260 mlast->m_len += sizeof(struct ip6_frag);
2261 m->m_pkthdr.len += sizeof(struct ip6_frag);
2262 } else {
2263 /* allocate a new mbuf for the fragment header */
2264 struct mbuf *mfrg;
2265
2266 MGET(mfrg, M_DONTWAIT, MT_DATA);
2267 if (mfrg == NULL) {
2268 return ENOBUFS;
2269 }
2270 mfrg->m_len = sizeof(struct ip6_frag);
2271 *frghdrp = mtod(mfrg, struct ip6_frag *);
2272 mlast->m_next = mfrg;
2273 }
2274
2275 return 0;
2276 }
2277
2278 static int
2279 ip6_getpmtu(struct route_in6 *ro_pmtu, struct route_in6 *ro,
2280 struct ifnet *ifp, struct in6_addr *dst, u_int32_t *mtup)
2281 {
2282 u_int32_t mtu = 0;
2283 int error = 0;
2284
2285
2286 if (ro_pmtu != ro) {
2287 /* The first hop and the final destination may differ. */
2288 struct sockaddr_in6 *sa6_dst = SIN6(&ro_pmtu->ro_dst);
2289 if (ROUTE_UNUSABLE(ro_pmtu) ||
2290 !IN6_ARE_ADDR_EQUAL(&sa6_dst->sin6_addr, dst)) {
2291 ROUTE_RELEASE(ro_pmtu);
2292 }
2293
2294 if (ro_pmtu->ro_rt == NULL) {
2295 bzero(sa6_dst, sizeof(*sa6_dst));
2296 sa6_dst->sin6_family = AF_INET6;
2297 sa6_dst->sin6_len = sizeof(struct sockaddr_in6);
2298 sa6_dst->sin6_addr = *dst;
2299
2300 rtalloc_scoped((struct route *)ro_pmtu,
2301 ifp != NULL ? ifp->if_index : IFSCOPE_NONE);
2302 }
2303 }
2304
2305 if (ro_pmtu->ro_rt != NULL) {
2306 u_int32_t ifmtu;
2307
2308 if (ifp == NULL) {
2309 ifp = ro_pmtu->ro_rt->rt_ifp;
2310 }
2311 /* Access without acquiring nd_ifinfo lock for performance */
2312 ifmtu = IN6_LINKMTU(ifp);
2313
2314 /*
2315 * Access rmx_mtu without holding the route entry lock,
2316 * for performance; this isn't something that changes
2317 * often, so optimize.
2318 */
2319 mtu = ro_pmtu->ro_rt->rt_rmx.rmx_mtu;
2320 if (mtu > ifmtu || mtu == 0) {
2321 /*
2322 * The MTU on the route is larger than the MTU on
2323 * the interface! This shouldn't happen, unless the
2324 * MTU of the interface has been changed after the
2325 * interface was brought up. Change the MTU in the
2326 * route to match the interface MTU (as long as the
2327 * field isn't locked).
2328 *
2329 * if MTU on the route is 0, we need to fix the MTU.
2330 * this case happens with path MTU discovery timeouts.
2331 */
2332 mtu = ifmtu;
2333 if (!(ro_pmtu->ro_rt->rt_rmx.rmx_locks & RTV_MTU)) {
2334 ro_pmtu->ro_rt->rt_rmx.rmx_mtu = mtu; /* XXX */
2335 }
2336 }
2337 } else {
2338 if (ifp) {
2339 /* Don't hold nd_ifinfo lock for performance */
2340 mtu = IN6_LINKMTU(ifp);
2341 } else {
2342 error = EHOSTUNREACH; /* XXX */
2343 }
2344 }
2345
2346 *mtup = mtu;
2347 return error;
2348 }
2349
2350 /*
2351 * IP6 socket option processing.
2352 */
2353 int
2354 ip6_ctloutput(struct socket *so, struct sockopt *sopt)
2355 {
2356 int optdatalen, uproto;
2357 void *optdata;
2358 int privileged;
2359 struct inpcb *in6p = sotoinpcb(so);
2360 int error = 0, optval = 0;
2361 int level, op = -1, optname = 0;
2362 size_t optlen = 0;
2363 struct proc *p;
2364 lck_mtx_t *mutex_held = NULL;
2365
2366 VERIFY(sopt != NULL);
2367
2368 level = sopt->sopt_level;
2369 op = sopt->sopt_dir;
2370 optname = sopt->sopt_name;
2371 optlen = sopt->sopt_valsize;
2372 p = sopt->sopt_p;
2373 uproto = (int)SOCK_PROTO(so);
2374
2375 privileged = (proc_suser(p) == 0);
2376
2377 if (level == IPPROTO_IPV6) {
2378 boolean_t capture_exthdrstat_in = FALSE;
2379 switch (op) {
2380 case SOPT_SET:
2381 mutex_held = socket_getlock(so, PR_F_WILLUNLOCK);
2382 /*
2383 * Wait if we are in the middle of ip6_output
2384 * as we unlocked the socket there and don't
2385 * want to overwrite the IP options
2386 */
2387 if (in6p->inp_sndinprog_cnt > 0) {
2388 in6p->inp_sndingprog_waiters++;
2389
2390 while (in6p->inp_sndinprog_cnt > 0) {
2391 msleep(&in6p->inp_sndinprog_cnt, mutex_held,
2392 PSOCK | PCATCH, "inp_sndinprog_cnt",
2393 NULL);
2394 }
2395 in6p->inp_sndingprog_waiters--;
2396 }
2397 switch (optname) {
2398 case IPV6_2292PKTOPTIONS: {
2399 struct mbuf *m;
2400
2401 error = soopt_getm(sopt, &m);
2402 if (error != 0) {
2403 break;
2404 }
2405 error = soopt_mcopyin(sopt, m);
2406 if (error != 0) {
2407 break;
2408 }
2409 error = ip6_pcbopts(&in6p->in6p_outputopts,
2410 m, so, sopt);
2411 m_freem(m);
2412 break;
2413 }
2414
2415 /*
2416 * Use of some Hop-by-Hop options or some
2417 * Destination options, might require special
2418 * privilege. That is, normal applications
2419 * (without special privilege) might be forbidden
2420 * from setting certain options in outgoing packets,
2421 * and might never see certain options in received
2422 * packets. [RFC 2292 Section 6]
2423 * KAME specific note:
2424 * KAME prevents non-privileged users from sending or
2425 * receiving ANY hbh/dst options in order to avoid
2426 * overhead of parsing options in the kernel.
2427 */
2428 case IPV6_RECVHOPOPTS:
2429 case IPV6_RECVDSTOPTS:
2430 case IPV6_RECVRTHDRDSTOPTS:
2431 if (!privileged) {
2432 break;
2433 }
2434 OS_FALLTHROUGH;
2435 case IPV6_UNICAST_HOPS:
2436 case IPV6_HOPLIMIT:
2437 case IPV6_RECVPKTINFO:
2438 case IPV6_RECVHOPLIMIT:
2439 case IPV6_RECVRTHDR:
2440 case IPV6_RECVPATHMTU:
2441 case IPV6_RECVTCLASS:
2442 case IPV6_V6ONLY:
2443 case IPV6_AUTOFLOWLABEL:
2444 if (optlen != sizeof(int)) {
2445 error = EINVAL;
2446 break;
2447 }
2448 error = sooptcopyin(sopt, &optval,
2449 sizeof(optval), sizeof(optval));
2450 if (error) {
2451 break;
2452 }
2453
2454 switch (optname) {
2455 case IPV6_UNICAST_HOPS:
2456 if (optval < -1 || optval >= 256) {
2457 error = EINVAL;
2458 } else {
2459 /* -1 = kernel default */
2460 in6p->in6p_hops = (short)optval;
2461 if (in6p->inp_vflag &
2462 INP_IPV4) {
2463 in6p->inp_ip_ttl =
2464 (uint8_t)optval;
2465 }
2466 }
2467 break;
2468 #define OPTSET(bit) do { \
2469 if (optval) \
2470 in6p->inp_flags |= (bit); \
2471 else \
2472 in6p->inp_flags &= ~(bit); \
2473 } while (0)
2474
2475 #define OPTSET2292(bit) do { \
2476 in6p->inp_flags |= IN6P_RFC2292; \
2477 if (optval) \
2478 in6p->inp_flags |= (bit); \
2479 else \
2480 in6p->inp_flags &= ~(bit); \
2481 } while (0)
2482
2483 #define OPTBIT(bit) (in6p->inp_flags & (bit) ? 1 : 0)
2484
2485 case IPV6_RECVPKTINFO:
2486 /* cannot mix with RFC2292 */
2487 if (OPTBIT(IN6P_RFC2292)) {
2488 error = EINVAL;
2489 break;
2490 }
2491 OPTSET(IN6P_PKTINFO);
2492 break;
2493
2494 case IPV6_HOPLIMIT: {
2495 struct ip6_pktopts **optp;
2496
2497 /* cannot mix with RFC2292 */
2498 if (OPTBIT(IN6P_RFC2292)) {
2499 error = EINVAL;
2500 break;
2501 }
2502 optp = &in6p->in6p_outputopts;
2503 error = ip6_pcbopt(IPV6_HOPLIMIT,
2504 (u_char *)&optval, sizeof(optval),
2505 optp, uproto);
2506 break;
2507 }
2508
2509 case IPV6_RECVHOPLIMIT:
2510 /* cannot mix with RFC2292 */
2511 if (OPTBIT(IN6P_RFC2292)) {
2512 error = EINVAL;
2513 break;
2514 }
2515 OPTSET(IN6P_HOPLIMIT);
2516 break;
2517
2518 case IPV6_RECVHOPOPTS:
2519 /* cannot mix with RFC2292 */
2520 if (OPTBIT(IN6P_RFC2292)) {
2521 error = EINVAL;
2522 break;
2523 }
2524 OPTSET(IN6P_HOPOPTS);
2525 capture_exthdrstat_in = TRUE;
2526 break;
2527
2528 case IPV6_RECVDSTOPTS:
2529 /* cannot mix with RFC2292 */
2530 if (OPTBIT(IN6P_RFC2292)) {
2531 error = EINVAL;
2532 break;
2533 }
2534 OPTSET(IN6P_DSTOPTS);
2535 capture_exthdrstat_in = TRUE;
2536 break;
2537
2538 case IPV6_RECVRTHDRDSTOPTS:
2539 /* cannot mix with RFC2292 */
2540 if (OPTBIT(IN6P_RFC2292)) {
2541 error = EINVAL;
2542 break;
2543 }
2544 OPTSET(IN6P_RTHDRDSTOPTS);
2545 capture_exthdrstat_in = TRUE;
2546 break;
2547
2548 case IPV6_RECVRTHDR:
2549 /* cannot mix with RFC2292 */
2550 if (OPTBIT(IN6P_RFC2292)) {
2551 error = EINVAL;
2552 break;
2553 }
2554 OPTSET(IN6P_RTHDR);
2555 capture_exthdrstat_in = TRUE;
2556 break;
2557
2558 case IPV6_RECVPATHMTU:
2559 /*
2560 * We ignore this option for TCP
2561 * sockets.
2562 * (RFC3542 leaves this case
2563 * unspecified.)
2564 */
2565 if (uproto != IPPROTO_TCP) {
2566 OPTSET(IN6P_MTU);
2567 }
2568 break;
2569
2570 case IPV6_V6ONLY:
2571 /*
2572 * make setsockopt(IPV6_V6ONLY)
2573 * available only prior to bind(2).
2574 * see ipng mailing list, Jun 22 2001.
2575 */
2576 if (in6p->inp_lport ||
2577 !IN6_IS_ADDR_UNSPECIFIED(
2578 &in6p->in6p_laddr)) {
2579 error = EINVAL;
2580 break;
2581 }
2582 OPTSET(IN6P_IPV6_V6ONLY);
2583 if (optval) {
2584 in6p->inp_vflag &= ~INP_IPV4;
2585 } else {
2586 in6p->inp_vflag |= INP_IPV4;
2587 }
2588 break;
2589
2590 case IPV6_RECVTCLASS:
2591 /* we can mix with RFC2292 */
2592 OPTSET(IN6P_TCLASS);
2593 break;
2594
2595 case IPV6_AUTOFLOWLABEL:
2596 OPTSET(IN6P_AUTOFLOWLABEL);
2597 break;
2598 }
2599 break;
2600
2601 case IPV6_TCLASS:
2602 case IPV6_DONTFRAG:
2603 case IPV6_USE_MIN_MTU:
2604 case IPV6_PREFER_TEMPADDR: {
2605 struct ip6_pktopts **optp;
2606
2607 if (optlen != sizeof(optval)) {
2608 error = EINVAL;
2609 break;
2610 }
2611 error = sooptcopyin(sopt, &optval,
2612 sizeof(optval), sizeof(optval));
2613 if (error) {
2614 break;
2615 }
2616
2617 optp = &in6p->in6p_outputopts;
2618 error = ip6_pcbopt(optname, (u_char *)&optval,
2619 sizeof(optval), optp, uproto);
2620
2621 if (optname == IPV6_TCLASS) {
2622 // Add in the ECN flags
2623 u_int8_t tos = (in6p->inp_ip_tos & ~IPTOS_ECN_MASK);
2624 u_int8_t ecn = optval & IPTOS_ECN_MASK;
2625 in6p->inp_ip_tos = tos | ecn;
2626 }
2627 break;
2628 }
2629
2630 case IPV6_2292PKTINFO:
2631 case IPV6_2292HOPLIMIT:
2632 case IPV6_2292HOPOPTS:
2633 case IPV6_2292DSTOPTS:
2634 case IPV6_2292RTHDR:
2635 /* RFC 2292 */
2636 if (optlen != sizeof(int)) {
2637 error = EINVAL;
2638 break;
2639 }
2640 error = sooptcopyin(sopt, &optval,
2641 sizeof(optval), sizeof(optval));
2642 if (error) {
2643 break;
2644 }
2645 switch (optname) {
2646 case IPV6_2292PKTINFO:
2647 OPTSET2292(IN6P_PKTINFO);
2648 break;
2649 case IPV6_2292HOPLIMIT:
2650 OPTSET2292(IN6P_HOPLIMIT);
2651 break;
2652 case IPV6_2292HOPOPTS:
2653 /*
2654 * Check super-user privilege.
2655 * See comments for IPV6_RECVHOPOPTS.
2656 */
2657 if (!privileged) {
2658 return EPERM;
2659 }
2660 OPTSET2292(IN6P_HOPOPTS);
2661 capture_exthdrstat_in = TRUE;
2662 break;
2663 case IPV6_2292DSTOPTS:
2664 if (!privileged) {
2665 return EPERM;
2666 }
2667 OPTSET2292(IN6P_DSTOPTS |
2668 IN6P_RTHDRDSTOPTS); /* XXX */
2669 capture_exthdrstat_in = TRUE;
2670 break;
2671 case IPV6_2292RTHDR:
2672 OPTSET2292(IN6P_RTHDR);
2673 capture_exthdrstat_in = TRUE;
2674 break;
2675 }
2676 break;
2677
2678 case IPV6_3542PKTINFO:
2679 case IPV6_3542HOPOPTS:
2680 case IPV6_3542RTHDR:
2681 case IPV6_3542DSTOPTS:
2682 case IPV6_RTHDRDSTOPTS:
2683 case IPV6_3542NEXTHOP: {
2684 struct ip6_pktopts **optp;
2685 /* new advanced API (RFC3542) */
2686 struct mbuf *m;
2687
2688 /* cannot mix with RFC2292 */
2689 if (OPTBIT(IN6P_RFC2292)) {
2690 error = EINVAL;
2691 break;
2692 }
2693 error = soopt_getm(sopt, &m);
2694 if (error != 0) {
2695 break;
2696 }
2697 error = soopt_mcopyin(sopt, m);
2698 if (error != 0) {
2699 break;
2700 }
2701
2702 optp = &in6p->in6p_outputopts;
2703 error = ip6_pcbopt(optname, mtod(m, u_char *),
2704 m->m_len, optp, uproto);
2705 m_freem(m);
2706 break;
2707 }
2708 #undef OPTSET
2709 case IPV6_MULTICAST_IF:
2710 case IPV6_MULTICAST_HOPS:
2711 case IPV6_MULTICAST_LOOP:
2712 case IPV6_JOIN_GROUP:
2713 case IPV6_LEAVE_GROUP:
2714 case IPV6_MSFILTER:
2715 case MCAST_BLOCK_SOURCE:
2716 case MCAST_UNBLOCK_SOURCE:
2717 case MCAST_JOIN_GROUP:
2718 case MCAST_LEAVE_GROUP:
2719 case MCAST_JOIN_SOURCE_GROUP:
2720 case MCAST_LEAVE_SOURCE_GROUP:
2721 error = ip6_setmoptions(in6p, sopt);
2722 break;
2723
2724 case IPV6_PORTRANGE:
2725 error = sooptcopyin(sopt, &optval,
2726 sizeof(optval), sizeof(optval));
2727 if (error) {
2728 break;
2729 }
2730
2731 switch (optval) {
2732 case IPV6_PORTRANGE_DEFAULT:
2733 in6p->inp_flags &= ~(INP_LOWPORT);
2734 in6p->inp_flags &= ~(INP_HIGHPORT);
2735 break;
2736
2737 case IPV6_PORTRANGE_HIGH:
2738 in6p->inp_flags &= ~(INP_LOWPORT);
2739 in6p->inp_flags |= INP_HIGHPORT;
2740 break;
2741
2742 case IPV6_PORTRANGE_LOW:
2743 in6p->inp_flags &= ~(INP_HIGHPORT);
2744 in6p->inp_flags |= INP_LOWPORT;
2745 break;
2746
2747 default:
2748 error = EINVAL;
2749 break;
2750 }
2751 break;
2752 #if IPSEC
2753 case IPV6_IPSEC_POLICY: {
2754 caddr_t req = NULL;
2755 size_t len = 0;
2756 struct mbuf *m;
2757
2758 if ((error = soopt_getm(sopt, &m)) != 0) {
2759 break;
2760 }
2761 if ((error = soopt_mcopyin(sopt, m)) != 0) {
2762 break;
2763 }
2764
2765 req = mtod(m, caddr_t);
2766 len = m->m_len;
2767 error = ipsec6_set_policy(in6p, optname, req,
2768 len, privileged);
2769 m_freem(m);
2770 break;
2771 }
2772 #endif /* IPSEC */
2773 /*
2774 * IPv6 variant of IP_BOUND_IF; for details see
2775 * comments on IP_BOUND_IF in ip_ctloutput().
2776 */
2777 case IPV6_BOUND_IF:
2778 /* This option is settable only on IPv6 */
2779 if (!(in6p->inp_vflag & INP_IPV6)) {
2780 error = EINVAL;
2781 break;
2782 }
2783
2784 error = sooptcopyin(sopt, &optval,
2785 sizeof(optval), sizeof(optval));
2786
2787 if (error) {
2788 break;
2789 }
2790
2791 error = inp_bindif(in6p, optval, NULL);
2792 break;
2793
2794 case IPV6_NO_IFT_CELLULAR:
2795 /* This option is settable only for IPv6 */
2796 if (!(in6p->inp_vflag & INP_IPV6)) {
2797 error = EINVAL;
2798 break;
2799 }
2800
2801 error = sooptcopyin(sopt, &optval,
2802 sizeof(optval), sizeof(optval));
2803
2804 if (error) {
2805 break;
2806 }
2807
2808 /* once set, it cannot be unset */
2809 if (!optval && INP_NO_CELLULAR(in6p)) {
2810 error = EINVAL;
2811 break;
2812 }
2813
2814 error = so_set_restrictions(so,
2815 SO_RESTRICT_DENY_CELLULAR);
2816 break;
2817
2818 case IPV6_OUT_IF:
2819 /* This option is not settable */
2820 error = EINVAL;
2821 break;
2822
2823 default:
2824 error = ENOPROTOOPT;
2825 break;
2826 }
2827 if (capture_exthdrstat_in) {
2828 if (uproto == IPPROTO_TCP) {
2829 INC_ATOMIC_INT64_LIM(net_api_stats.nas_sock_inet6_stream_exthdr_in);
2830 } else if (uproto == IPPROTO_UDP) {
2831 INC_ATOMIC_INT64_LIM(net_api_stats.nas_sock_inet6_dgram_exthdr_in);
2832 }
2833 }
2834 break;
2835
2836 case SOPT_GET:
2837 switch (optname) {
2838 case IPV6_2292PKTOPTIONS:
2839 /*
2840 * RFC3542 (effectively) deprecated the
2841 * semantics of the 2292-style pktoptions.
2842 * Since it was not reliable in nature (i.e.,
2843 * applications had to expect the lack of some
2844 * information after all), it would make sense
2845 * to simplify this part by always returning
2846 * empty data.
2847 */
2848 sopt->sopt_valsize = 0;
2849 break;
2850
2851 case IPV6_RECVHOPOPTS:
2852 case IPV6_RECVDSTOPTS:
2853 case IPV6_RECVRTHDRDSTOPTS:
2854 case IPV6_UNICAST_HOPS:
2855 case IPV6_RECVPKTINFO:
2856 case IPV6_RECVHOPLIMIT:
2857 case IPV6_RECVRTHDR:
2858 case IPV6_RECVPATHMTU:
2859 case IPV6_V6ONLY:
2860 case IPV6_PORTRANGE:
2861 case IPV6_RECVTCLASS:
2862 case IPV6_AUTOFLOWLABEL:
2863 switch (optname) {
2864 case IPV6_RECVHOPOPTS:
2865 optval = OPTBIT(IN6P_HOPOPTS);
2866 break;
2867
2868 case IPV6_RECVDSTOPTS:
2869 optval = OPTBIT(IN6P_DSTOPTS);
2870 break;
2871
2872 case IPV6_RECVRTHDRDSTOPTS:
2873 optval = OPTBIT(IN6P_RTHDRDSTOPTS);
2874 break;
2875
2876 case IPV6_UNICAST_HOPS:
2877 optval = in6p->in6p_hops;
2878 break;
2879
2880 case IPV6_RECVPKTINFO:
2881 optval = OPTBIT(IN6P_PKTINFO);
2882 break;
2883
2884 case IPV6_RECVHOPLIMIT:
2885 optval = OPTBIT(IN6P_HOPLIMIT);
2886 break;
2887
2888 case IPV6_RECVRTHDR:
2889 optval = OPTBIT(IN6P_RTHDR);
2890 break;
2891
2892 case IPV6_RECVPATHMTU:
2893 optval = OPTBIT(IN6P_MTU);
2894 break;
2895
2896 case IPV6_V6ONLY:
2897 optval = OPTBIT(IN6P_IPV6_V6ONLY);
2898 break;
2899
2900 case IPV6_PORTRANGE: {
2901 int flags;
2902 flags = in6p->inp_flags;
2903 if (flags & INP_HIGHPORT) {
2904 optval = IPV6_PORTRANGE_HIGH;
2905 } else if (flags & INP_LOWPORT) {
2906 optval = IPV6_PORTRANGE_LOW;
2907 } else {
2908 optval = 0;
2909 }
2910 break;
2911 }
2912 case IPV6_RECVTCLASS:
2913 optval = OPTBIT(IN6P_TCLASS);
2914 break;
2915
2916 case IPV6_AUTOFLOWLABEL:
2917 optval = OPTBIT(IN6P_AUTOFLOWLABEL);
2918 break;
2919 }
2920 if (error) {
2921 break;
2922 }
2923 error = sooptcopyout(sopt, &optval,
2924 sizeof(optval));
2925 break;
2926
2927 case IPV6_PATHMTU: {
2928 u_int32_t pmtu = 0;
2929 struct ip6_mtuinfo mtuinfo;
2930 struct route_in6 sro;
2931
2932 bzero(&sro, sizeof(sro));
2933
2934 if (!(so->so_state & SS_ISCONNECTED)) {
2935 return ENOTCONN;
2936 }
2937 /*
2938 * XXX: we dot not consider the case of source
2939 * routing, or optional information to specify
2940 * the outgoing interface.
2941 */
2942 error = ip6_getpmtu(&sro, NULL, NULL,
2943 &in6p->in6p_faddr, &pmtu);
2944 ROUTE_RELEASE(&sro);
2945 if (error) {
2946 break;
2947 }
2948 if (pmtu > IPV6_MAXPACKET) {
2949 pmtu = IPV6_MAXPACKET;
2950 }
2951
2952 bzero(&mtuinfo, sizeof(mtuinfo));
2953 mtuinfo.ip6m_mtu = (u_int32_t)pmtu;
2954 optdata = (void *)&mtuinfo;
2955 optdatalen = sizeof(mtuinfo);
2956 error = sooptcopyout(sopt, optdata,
2957 optdatalen);
2958 break;
2959 }
2960
2961 case IPV6_2292PKTINFO:
2962 case IPV6_2292HOPLIMIT:
2963 case IPV6_2292HOPOPTS:
2964 case IPV6_2292RTHDR:
2965 case IPV6_2292DSTOPTS:
2966 switch (optname) {
2967 case IPV6_2292PKTINFO:
2968 optval = OPTBIT(IN6P_PKTINFO);
2969 break;
2970 case IPV6_2292HOPLIMIT:
2971 optval = OPTBIT(IN6P_HOPLIMIT);
2972 break;
2973 case IPV6_2292HOPOPTS:
2974 optval = OPTBIT(IN6P_HOPOPTS);
2975 break;
2976 case IPV6_2292RTHDR:
2977 optval = OPTBIT(IN6P_RTHDR);
2978 break;
2979 case IPV6_2292DSTOPTS:
2980 optval = OPTBIT(IN6P_DSTOPTS |
2981 IN6P_RTHDRDSTOPTS);
2982 break;
2983 }
2984 error = sooptcopyout(sopt, &optval,
2985 sizeof(optval));
2986 break;
2987
2988 case IPV6_PKTINFO:
2989 case IPV6_HOPOPTS:
2990 case IPV6_RTHDR:
2991 case IPV6_DSTOPTS:
2992 case IPV6_RTHDRDSTOPTS:
2993 case IPV6_NEXTHOP:
2994 case IPV6_TCLASS:
2995 case IPV6_DONTFRAG:
2996 case IPV6_USE_MIN_MTU:
2997 case IPV6_PREFER_TEMPADDR:
2998 error = ip6_getpcbopt(in6p->in6p_outputopts,
2999 optname, sopt);
3000 break;
3001
3002 case IPV6_MULTICAST_IF:
3003 case IPV6_MULTICAST_HOPS:
3004 case IPV6_MULTICAST_LOOP:
3005 case IPV6_MSFILTER:
3006 error = ip6_getmoptions(in6p, sopt);
3007 break;
3008 #if IPSEC
3009 case IPV6_IPSEC_POLICY: {
3010 error = 0; /* This option is no longer supported */
3011 break;
3012 }
3013 #endif /* IPSEC */
3014 case IPV6_BOUND_IF:
3015 if (in6p->inp_flags & INP_BOUND_IF) {
3016 optval = in6p->inp_boundifp->if_index;
3017 }
3018 error = sooptcopyout(sopt, &optval,
3019 sizeof(optval));
3020 break;
3021
3022 case IPV6_NO_IFT_CELLULAR:
3023 optval = INP_NO_CELLULAR(in6p) ? 1 : 0;
3024 error = sooptcopyout(sopt, &optval,
3025 sizeof(optval));
3026 break;
3027
3028 case IPV6_OUT_IF:
3029 optval = (in6p->in6p_last_outifp != NULL) ?
3030 in6p->in6p_last_outifp->if_index : 0;
3031 error = sooptcopyout(sopt, &optval,
3032 sizeof(optval));
3033 break;
3034
3035 default:
3036 error = ENOPROTOOPT;
3037 break;
3038 }
3039 break;
3040 }
3041 } else if (level == IPPROTO_UDP) {
3042 error = udp_ctloutput(so, sopt);
3043 } else {
3044 error = EINVAL;
3045 }
3046 return error;
3047 }
3048
3049 int
3050 ip6_raw_ctloutput(struct socket *so, struct sockopt *sopt)
3051 {
3052 int error = 0, optval;
3053 size_t optlen;
3054 const int icmp6off = offsetof(struct icmp6_hdr, icmp6_cksum);
3055 struct inpcb *in6p = sotoinpcb(so);
3056 int level, op, optname;
3057
3058 level = sopt->sopt_level;
3059 op = sopt->sopt_dir;
3060 optname = sopt->sopt_name;
3061 optlen = sopt->sopt_valsize;
3062
3063 if (level != IPPROTO_IPV6) {
3064 return EINVAL;
3065 }
3066
3067 switch (optname) {
3068 case IPV6_CHECKSUM:
3069 /*
3070 * For ICMPv6 sockets, no modification allowed for checksum
3071 * offset, permit "no change" values to help existing apps.
3072 *
3073 * RFC3542 says: "An attempt to set IPV6_CHECKSUM
3074 * for an ICMPv6 socket will fail."
3075 * The current behavior does not meet RFC3542.
3076 */
3077 switch (op) {
3078 case SOPT_SET:
3079 if (optlen != sizeof(int)) {
3080 error = EINVAL;
3081 break;
3082 }
3083 error = sooptcopyin(sopt, &optval, sizeof(optval),
3084 sizeof(optval));
3085 if (error) {
3086 break;
3087 }
3088 if ((optval % 2) != 0) {
3089 /* the API assumes even offset values */
3090 error = EINVAL;
3091 } else if (SOCK_PROTO(so) == IPPROTO_ICMPV6) {
3092 if (optval != icmp6off) {
3093 error = EINVAL;
3094 }
3095 } else {
3096 in6p->in6p_cksum = optval;
3097 }
3098 break;
3099
3100 case SOPT_GET:
3101 if (SOCK_PROTO(so) == IPPROTO_ICMPV6) {
3102 optval = icmp6off;
3103 } else {
3104 optval = in6p->in6p_cksum;
3105 }
3106
3107 error = sooptcopyout(sopt, &optval, sizeof(optval));
3108 break;
3109
3110 default:
3111 error = EINVAL;
3112 break;
3113 }
3114 break;
3115
3116 default:
3117 error = ENOPROTOOPT;
3118 break;
3119 }
3120
3121 return error;
3122 }
3123
3124 /*
3125 * Set up IP6 options in pcb for insertion in output packets or
3126 * specifying behavior of outgoing packets.
3127 */
3128 static int
3129 ip6_pcbopts(struct ip6_pktopts **pktopt, struct mbuf *m, struct socket *so,
3130 struct sockopt *sopt)
3131 {
3132 #pragma unused(sopt)
3133 struct ip6_pktopts *opt = *pktopt;
3134 int error = 0;
3135
3136 /* turn off any old options. */
3137 if (opt != NULL) {
3138 #if DIAGNOSTIC
3139 if (opt->ip6po_pktinfo || opt->ip6po_nexthop ||
3140 opt->ip6po_hbh || opt->ip6po_dest1 || opt->ip6po_dest2 ||
3141 opt->ip6po_rhinfo.ip6po_rhi_rthdr) {
3142 printf("%s: all specified options are cleared.\n",
3143 __func__);
3144 }
3145 #endif
3146 ip6_clearpktopts(opt, -1);
3147 } else {
3148 opt = _MALLOC(sizeof(*opt), M_IP6OPT, M_WAITOK);
3149 if (opt == NULL) {
3150 return ENOBUFS;
3151 }
3152 }
3153 *pktopt = NULL;
3154
3155 if (m == NULL || m->m_len == 0) {
3156 /*
3157 * Only turning off any previous options, regardless of
3158 * whether the opt is just created or given.
3159 */
3160 if (opt != NULL) {
3161 FREE(opt, M_IP6OPT);
3162 }
3163 return 0;
3164 }
3165
3166 /* set options specified by user. */
3167 if ((error = ip6_setpktopts(m, opt, NULL, SOCK_PROTO(so))) != 0) {
3168 ip6_clearpktopts(opt, -1); /* XXX: discard all options */
3169 FREE(opt, M_IP6OPT);
3170 return error;
3171 }
3172 *pktopt = opt;
3173 return 0;
3174 }
3175
3176 /*
3177 * initialize ip6_pktopts. beware that there are non-zero default values in
3178 * the struct.
3179 */
3180 void
3181 ip6_initpktopts(struct ip6_pktopts *opt)
3182 {
3183 bzero(opt, sizeof(*opt));
3184 opt->ip6po_hlim = -1; /* -1 means default hop limit */
3185 opt->ip6po_tclass = -1; /* -1 means default traffic class */
3186 opt->ip6po_minmtu = IP6PO_MINMTU_MCASTONLY;
3187 opt->ip6po_prefer_tempaddr = IP6PO_TEMPADDR_SYSTEM;
3188 }
3189
3190 static int
3191 ip6_pcbopt(int optname, u_char *buf, int len, struct ip6_pktopts **pktopt,
3192 int uproto)
3193 {
3194 struct ip6_pktopts *opt;
3195
3196 opt = *pktopt;
3197 if (opt == NULL) {
3198 opt = _MALLOC(sizeof(*opt), M_IP6OPT, M_WAITOK);
3199 if (opt == NULL) {
3200 return ENOBUFS;
3201 }
3202 ip6_initpktopts(opt);
3203 *pktopt = opt;
3204 }
3205
3206 return ip6_setpktopt(optname, buf, len, opt, 1, 0, uproto);
3207 }
3208
3209 static int
3210 ip6_getpcbopt(struct ip6_pktopts *pktopt, int optname, struct sockopt *sopt)
3211 {
3212 void *optdata = NULL;
3213 int optdatalen = 0;
3214 struct ip6_ext *ip6e;
3215 struct in6_pktinfo null_pktinfo;
3216 int deftclass = 0, on;
3217 int defminmtu = IP6PO_MINMTU_MCASTONLY;
3218 int defpreftemp = IP6PO_TEMPADDR_SYSTEM;
3219
3220
3221 switch (optname) {
3222 case IPV6_PKTINFO:
3223 if (pktopt && pktopt->ip6po_pktinfo) {
3224 optdata = (void *)pktopt->ip6po_pktinfo;
3225 } else {
3226 /* XXX: we don't have to do this every time... */
3227 bzero(&null_pktinfo, sizeof(null_pktinfo));
3228 optdata = (void *)&null_pktinfo;
3229 }
3230 optdatalen = sizeof(struct in6_pktinfo);
3231 break;
3232
3233 case IPV6_TCLASS:
3234 if (pktopt && pktopt->ip6po_tclass >= 0) {
3235 optdata = (void *)&pktopt->ip6po_tclass;
3236 } else {
3237 optdata = (void *)&deftclass;
3238 }
3239 optdatalen = sizeof(int);
3240 break;
3241
3242 case IPV6_HOPOPTS:
3243 if (pktopt && pktopt->ip6po_hbh) {
3244 optdata = (void *)pktopt->ip6po_hbh;
3245 ip6e = (struct ip6_ext *)pktopt->ip6po_hbh;
3246 optdatalen = (ip6e->ip6e_len + 1) << 3;
3247 }
3248 break;
3249
3250 case IPV6_RTHDR:
3251 if (pktopt && pktopt->ip6po_rthdr) {
3252 optdata = (void *)pktopt->ip6po_rthdr;
3253 ip6e = (struct ip6_ext *)pktopt->ip6po_rthdr;
3254 optdatalen = (ip6e->ip6e_len + 1) << 3;
3255 }
3256 break;
3257
3258 case IPV6_RTHDRDSTOPTS:
3259 if (pktopt && pktopt->ip6po_dest1) {
3260 optdata = (void *)pktopt->ip6po_dest1;
3261 ip6e = (struct ip6_ext *)pktopt->ip6po_dest1;
3262 optdatalen = (ip6e->ip6e_len + 1) << 3;
3263 }
3264 break;
3265
3266 case IPV6_DSTOPTS:
3267 if (pktopt && pktopt->ip6po_dest2) {
3268 optdata = (void *)pktopt->ip6po_dest2;
3269 ip6e = (struct ip6_ext *)pktopt->ip6po_dest2;
3270 optdatalen = (ip6e->ip6e_len + 1) << 3;
3271 }
3272 break;
3273
3274 case IPV6_NEXTHOP:
3275 if (pktopt && pktopt->ip6po_nexthop) {
3276 optdata = (void *)pktopt->ip6po_nexthop;
3277 optdatalen = pktopt->ip6po_nexthop->sa_len;
3278 }
3279 break;
3280
3281 case IPV6_USE_MIN_MTU:
3282 if (pktopt) {
3283 optdata = (void *)&pktopt->ip6po_minmtu;
3284 } else {
3285 optdata = (void *)&defminmtu;
3286 }
3287 optdatalen = sizeof(int);
3288 break;
3289
3290 case IPV6_DONTFRAG:
3291 if (pktopt && ((pktopt->ip6po_flags) & IP6PO_DONTFRAG)) {
3292 on = 1;
3293 } else {
3294 on = 0;
3295 }
3296 optdata = (void *)&on;
3297 optdatalen = sizeof(on);
3298 break;
3299
3300 case IPV6_PREFER_TEMPADDR:
3301 if (pktopt) {
3302 optdata = (void *)&pktopt->ip6po_prefer_tempaddr;
3303 } else {
3304 optdata = (void *)&defpreftemp;
3305 }
3306 optdatalen = sizeof(int);
3307 break;
3308
3309 default: /* should not happen */
3310 #ifdef DIAGNOSTIC
3311 panic("ip6_getpcbopt: unexpected option\n");
3312 #endif
3313 return ENOPROTOOPT;
3314 }
3315
3316 return sooptcopyout(sopt, optdata, optdatalen);
3317 }
3318
3319 void
3320 ip6_clearpktopts(struct ip6_pktopts *pktopt, int optname)
3321 {
3322 if (pktopt == NULL) {
3323 return;
3324 }
3325
3326 if (optname == -1 || optname == IPV6_PKTINFO) {
3327 if (pktopt->ip6po_pktinfo) {
3328 FREE(pktopt->ip6po_pktinfo, M_IP6OPT);
3329 }
3330 pktopt->ip6po_pktinfo = NULL;
3331 }
3332 if (optname == -1 || optname == IPV6_HOPLIMIT) {
3333 pktopt->ip6po_hlim = -1;
3334 }
3335 if (optname == -1 || optname == IPV6_TCLASS) {
3336 pktopt->ip6po_tclass = -1;
3337 }
3338 if (optname == -1 || optname == IPV6_NEXTHOP) {
3339 ROUTE_RELEASE(&pktopt->ip6po_nextroute);
3340 if (pktopt->ip6po_nexthop) {
3341 FREE(pktopt->ip6po_nexthop, M_IP6OPT);
3342 }
3343 pktopt->ip6po_nexthop = NULL;
3344 }
3345 if (optname == -1 || optname == IPV6_HOPOPTS) {
3346 if (pktopt->ip6po_hbh) {
3347 FREE(pktopt->ip6po_hbh, M_IP6OPT);
3348 }
3349 pktopt->ip6po_hbh = NULL;
3350 }
3351 if (optname == -1 || optname == IPV6_RTHDRDSTOPTS) {
3352 if (pktopt->ip6po_dest1) {
3353 FREE(pktopt->ip6po_dest1, M_IP6OPT);
3354 }
3355 pktopt->ip6po_dest1 = NULL;
3356 }
3357 if (optname == -1 || optname == IPV6_RTHDR) {
3358 if (pktopt->ip6po_rhinfo.ip6po_rhi_rthdr) {
3359 FREE(pktopt->ip6po_rhinfo.ip6po_rhi_rthdr, M_IP6OPT);
3360 }
3361 pktopt->ip6po_rhinfo.ip6po_rhi_rthdr = NULL;
3362 ROUTE_RELEASE(&pktopt->ip6po_route);
3363 }
3364 if (optname == -1 || optname == IPV6_DSTOPTS) {
3365 if (pktopt->ip6po_dest2) {
3366 FREE(pktopt->ip6po_dest2, M_IP6OPT);
3367 }
3368 pktopt->ip6po_dest2 = NULL;
3369 }
3370 }
3371
3372 #define PKTOPT_EXTHDRCPY(type) do { \
3373 if (src->type) { \
3374 int hlen = \
3375 (((struct ip6_ext *)src->type)->ip6e_len + 1) << 3; \
3376 dst->type = _MALLOC(hlen, M_IP6OPT, canwait); \
3377 if (dst->type == NULL && canwait == M_NOWAIT) \
3378 goto bad; \
3379 bcopy(src->type, dst->type, hlen); \
3380 } \
3381 } while (0)
3382
3383 static int
3384 copypktopts(struct ip6_pktopts *dst, struct ip6_pktopts *src, int canwait)
3385 {
3386 if (dst == NULL || src == NULL) {
3387 printf("copypktopts: invalid argument\n");
3388 return EINVAL;
3389 }
3390
3391 dst->ip6po_hlim = src->ip6po_hlim;
3392 dst->ip6po_tclass = src->ip6po_tclass;
3393 dst->ip6po_flags = src->ip6po_flags;
3394 if (src->ip6po_pktinfo) {
3395 dst->ip6po_pktinfo = _MALLOC(sizeof(*dst->ip6po_pktinfo),
3396 M_IP6OPT, canwait);
3397 if (dst->ip6po_pktinfo == NULL && canwait == M_NOWAIT) {
3398 goto bad;
3399 }
3400 *dst->ip6po_pktinfo = *src->ip6po_pktinfo;
3401 }
3402 if (src->ip6po_nexthop) {
3403 dst->ip6po_nexthop = _MALLOC(src->ip6po_nexthop->sa_len,
3404 M_IP6OPT, canwait);
3405 if (dst->ip6po_nexthop == NULL && canwait == M_NOWAIT) {
3406 goto bad;
3407 }
3408 bcopy(src->ip6po_nexthop, dst->ip6po_nexthop,
3409 src->ip6po_nexthop->sa_len);
3410 }
3411 PKTOPT_EXTHDRCPY(ip6po_hbh);
3412 PKTOPT_EXTHDRCPY(ip6po_dest1);
3413 PKTOPT_EXTHDRCPY(ip6po_dest2);
3414 PKTOPT_EXTHDRCPY(ip6po_rthdr); /* not copy the cached route */
3415 return 0;
3416
3417 bad:
3418 ip6_clearpktopts(dst, -1);
3419 return ENOBUFS;
3420 }
3421 #undef PKTOPT_EXTHDRCPY
3422
3423 struct ip6_pktopts *
3424 ip6_copypktopts(struct ip6_pktopts *src, int canwait)
3425 {
3426 int error;
3427 struct ip6_pktopts *dst;
3428
3429 dst = _MALLOC(sizeof(*dst), M_IP6OPT, canwait);
3430 if (dst == NULL) {
3431 return NULL;
3432 }
3433 ip6_initpktopts(dst);
3434
3435 if ((error = copypktopts(dst, src, canwait)) != 0) {
3436 FREE(dst, M_IP6OPT);
3437 return NULL;
3438 }
3439
3440 return dst;
3441 }
3442
3443 void
3444 ip6_freepcbopts(struct ip6_pktopts *pktopt)
3445 {
3446 if (pktopt == NULL) {
3447 return;
3448 }
3449
3450 ip6_clearpktopts(pktopt, -1);
3451
3452 FREE(pktopt, M_IP6OPT);
3453 }
3454
3455 void
3456 ip6_moptions_init(void)
3457 {
3458 PE_parse_boot_argn("ifa_debug", &im6o_debug, sizeof(im6o_debug));
3459
3460 vm_size_t im6o_size = (im6o_debug == 0) ? sizeof(struct ip6_moptions) :
3461 sizeof(struct ip6_moptions_dbg);
3462
3463 im6o_zone = zone_create(IM6O_ZONE_NAME, im6o_size, ZC_ZFREE_CLEARMEM);
3464 }
3465
3466 void
3467 im6o_addref(struct ip6_moptions *im6o, int locked)
3468 {
3469 if (!locked) {
3470 IM6O_LOCK(im6o);
3471 } else {
3472 IM6O_LOCK_ASSERT_HELD(im6o);
3473 }
3474
3475 if (++im6o->im6o_refcnt == 0) {
3476 panic("%s: im6o %p wraparound refcnt\n", __func__, im6o);
3477 /* NOTREACHED */
3478 } else if (im6o->im6o_trace != NULL) {
3479 (*im6o->im6o_trace)(im6o, TRUE);
3480 }
3481
3482 if (!locked) {
3483 IM6O_UNLOCK(im6o);
3484 }
3485 }
3486
3487 void
3488 im6o_remref(struct ip6_moptions *im6o)
3489 {
3490 int i;
3491
3492 IM6O_LOCK(im6o);
3493 if (im6o->im6o_refcnt == 0) {
3494 panic("%s: im6o %p negative refcnt", __func__, im6o);
3495 /* NOTREACHED */
3496 } else if (im6o->im6o_trace != NULL) {
3497 (*im6o->im6o_trace)(im6o, FALSE);
3498 }
3499
3500 --im6o->im6o_refcnt;
3501 if (im6o->im6o_refcnt > 0) {
3502 IM6O_UNLOCK(im6o);
3503 return;
3504 }
3505
3506 for (i = 0; i < im6o->im6o_num_memberships; ++i) {
3507 struct in6_mfilter *imf;
3508
3509 imf = im6o->im6o_mfilters ? &im6o->im6o_mfilters[i] : NULL;
3510 if (imf != NULL) {
3511 im6f_leave(imf);
3512 }
3513
3514 (void) in6_mc_leave(im6o->im6o_membership[i], imf);
3515
3516 if (imf != NULL) {
3517 im6f_purge(imf);
3518 }
3519
3520 IN6M_REMREF(im6o->im6o_membership[i]);
3521 im6o->im6o_membership[i] = NULL;
3522 }
3523 im6o->im6o_num_memberships = 0;
3524 if (im6o->im6o_mfilters != NULL) {
3525 FREE(im6o->im6o_mfilters, M_IN6MFILTER);
3526 im6o->im6o_mfilters = NULL;
3527 }
3528 if (im6o->im6o_membership != NULL) {
3529 FREE(im6o->im6o_membership, M_IP6MOPTS);
3530 im6o->im6o_membership = NULL;
3531 }
3532 IM6O_UNLOCK(im6o);
3533
3534 lck_mtx_destroy(&im6o->im6o_lock, ifa_mtx_grp);
3535
3536 if (!(im6o->im6o_debug & IFD_ALLOC)) {
3537 panic("%s: im6o %p cannot be freed", __func__, im6o);
3538 /* NOTREACHED */
3539 }
3540 zfree(im6o_zone, im6o);
3541 }
3542
3543 static void
3544 im6o_trace(struct ip6_moptions *im6o, int refhold)
3545 {
3546 struct ip6_moptions_dbg *im6o_dbg = (struct ip6_moptions_dbg *)im6o;
3547 ctrace_t *tr;
3548 u_int32_t idx;
3549 u_int16_t *cnt;
3550
3551 if (!(im6o->im6o_debug & IFD_DEBUG)) {
3552 panic("%s: im6o %p has no debug structure", __func__, im6o);
3553 /* NOTREACHED */
3554 }
3555 if (refhold) {
3556 cnt = &im6o_dbg->im6o_refhold_cnt;
3557 tr = im6o_dbg->im6o_refhold;
3558 } else {
3559 cnt = &im6o_dbg->im6o_refrele_cnt;
3560 tr = im6o_dbg->im6o_refrele;
3561 }
3562
3563 idx = atomic_add_16_ov(cnt, 1) % IM6O_TRACE_HIST_SIZE;
3564 ctrace_record(&tr[idx]);
3565 }
3566
3567 struct ip6_moptions *
3568 ip6_allocmoptions(zalloc_flags_t how)
3569 {
3570 struct ip6_moptions *im6o;
3571
3572 im6o = zalloc_flags(im6o_zone, how | Z_ZERO);
3573 if (im6o != NULL) {
3574 lck_mtx_init(&im6o->im6o_lock, ifa_mtx_grp, ifa_mtx_attr);
3575 im6o->im6o_debug |= IFD_ALLOC;
3576 if (im6o_debug != 0) {
3577 im6o->im6o_debug |= IFD_DEBUG;
3578 im6o->im6o_trace = im6o_trace;
3579 }
3580 IM6O_ADDREF(im6o);
3581 }
3582
3583 return im6o;
3584 }
3585
3586 /*
3587 * Set IPv6 outgoing packet options based on advanced API.
3588 */
3589 int
3590 ip6_setpktopts(struct mbuf *control, struct ip6_pktopts *opt,
3591 struct ip6_pktopts *stickyopt, int uproto)
3592 {
3593 struct cmsghdr *cm = NULL;
3594
3595 if (control == NULL || opt == NULL) {
3596 return EINVAL;
3597 }
3598
3599 ip6_initpktopts(opt);
3600 if (stickyopt) {
3601 int error;
3602
3603 /*
3604 * If stickyopt is provided, make a local copy of the options
3605 * for this particular packet, then override them by ancillary
3606 * objects.
3607 * XXX: copypktopts() does not copy the cached route to a next
3608 * hop (if any). This is not very good in terms of efficiency,
3609 * but we can allow this since this option should be rarely
3610 * used.
3611 */
3612 if ((error = copypktopts(opt, stickyopt, M_NOWAIT)) != 0) {
3613 return error;
3614 }
3615 }
3616
3617 /*
3618 * XXX: Currently, we assume all the optional information is stored
3619 * in a single mbuf.
3620 */
3621 if (control->m_next) {
3622 return EINVAL;
3623 }
3624
3625 if (control->m_len < CMSG_LEN(0)) {
3626 return EINVAL;
3627 }
3628
3629 for (cm = M_FIRST_CMSGHDR(control);
3630 is_cmsg_valid(control, cm);
3631 cm = M_NXT_CMSGHDR(control, cm)) {
3632 int error;
3633
3634 if (cm->cmsg_level != IPPROTO_IPV6) {
3635 continue;
3636 }
3637
3638 error = ip6_setpktopt(cm->cmsg_type, CMSG_DATA(cm),
3639 cm->cmsg_len - CMSG_LEN(0), opt, 0, 1, uproto);
3640 if (error) {
3641 return error;
3642 }
3643 }
3644
3645 return 0;
3646 }
3647 /*
3648 * Set a particular packet option, as a sticky option or an ancillary data
3649 * item. "len" can be 0 only when it's a sticky option.
3650 * We have 4 cases of combination of "sticky" and "cmsg":
3651 * "sticky=0, cmsg=0": impossible
3652 * "sticky=0, cmsg=1": RFC2292 or RFC3542 ancillary data
3653 * "sticky=1, cmsg=0": RFC3542 socket option
3654 * "sticky=1, cmsg=1": RFC2292 socket option
3655 */
3656 static int
3657 ip6_setpktopt(int optname, u_char *buf, int len, struct ip6_pktopts *opt,
3658 int sticky, int cmsg, int uproto)
3659 {
3660 int minmtupolicy, preftemp;
3661 int error;
3662 boolean_t capture_exthdrstat_out = FALSE;
3663
3664 if (!sticky && !cmsg) {
3665 #ifdef DIAGNOSTIC
3666 printf("ip6_setpktopt: impossible case\n");
3667 #endif
3668 return EINVAL;
3669 }
3670
3671 /*
3672 * Caller must have ensured that the buffer is at least
3673 * aligned on 32-bit boundary.
3674 */
3675 VERIFY(IS_P2ALIGNED(buf, sizeof(u_int32_t)));
3676
3677 /*
3678 * IPV6_2292xxx is for backward compatibility to RFC2292, and should
3679 * not be specified in the context of RFC3542. Conversely,
3680 * RFC3542 types should not be specified in the context of RFC2292.
3681 */
3682 if (!cmsg) {
3683 switch (optname) {
3684 case IPV6_2292PKTINFO:
3685 case IPV6_2292HOPLIMIT:
3686 case IPV6_2292NEXTHOP:
3687 case IPV6_2292HOPOPTS:
3688 case IPV6_2292DSTOPTS:
3689 case IPV6_2292RTHDR:
3690 case IPV6_2292PKTOPTIONS:
3691 return ENOPROTOOPT;
3692 }
3693 }
3694 if (sticky && cmsg) {
3695 switch (optname) {
3696 case IPV6_PKTINFO:
3697 case IPV6_HOPLIMIT:
3698 case IPV6_NEXTHOP:
3699 case IPV6_HOPOPTS:
3700 case IPV6_DSTOPTS:
3701 case IPV6_RTHDRDSTOPTS:
3702 case IPV6_RTHDR:
3703 case IPV6_USE_MIN_MTU:
3704 case IPV6_DONTFRAG:
3705 case IPV6_TCLASS:
3706 case IPV6_PREFER_TEMPADDR: /* XXX: not an RFC3542 option */
3707 return ENOPROTOOPT;
3708 }
3709 }
3710
3711 switch (optname) {
3712 case IPV6_2292PKTINFO:
3713 case IPV6_PKTINFO: {
3714 struct ifnet *ifp = NULL;
3715 struct in6_pktinfo *pktinfo;
3716
3717 if (len != sizeof(struct in6_pktinfo)) {
3718 return EINVAL;
3719 }
3720
3721 pktinfo = (struct in6_pktinfo *)(void *)buf;
3722
3723 /*
3724 * An application can clear any sticky IPV6_PKTINFO option by
3725 * doing a "regular" setsockopt with ipi6_addr being
3726 * in6addr_any and ipi6_ifindex being zero.
3727 * [RFC 3542, Section 6]
3728 */
3729 if (optname == IPV6_PKTINFO && opt->ip6po_pktinfo &&
3730 pktinfo->ipi6_ifindex == 0 &&
3731 IN6_IS_ADDR_UNSPECIFIED(&pktinfo->ipi6_addr)) {
3732 ip6_clearpktopts(opt, optname);
3733 break;
3734 }
3735
3736 if (uproto == IPPROTO_TCP && optname == IPV6_PKTINFO &&
3737 sticky && !IN6_IS_ADDR_UNSPECIFIED(&pktinfo->ipi6_addr)) {
3738 return EINVAL;
3739 }
3740
3741 /* validate the interface index if specified. */
3742 ifnet_head_lock_shared();
3743
3744 if (pktinfo->ipi6_ifindex > if_index) {
3745 ifnet_head_done();
3746 return ENXIO;
3747 }
3748
3749 if (pktinfo->ipi6_ifindex) {
3750 ifp = ifindex2ifnet[pktinfo->ipi6_ifindex];
3751 if (ifp == NULL) {
3752 ifnet_head_done();
3753 return ENXIO;
3754 }
3755 }
3756
3757 ifnet_head_done();
3758
3759 /*
3760 * We store the address anyway, and let in6_selectsrc()
3761 * validate the specified address. This is because ipi6_addr
3762 * may not have enough information about its scope zone, and
3763 * we may need additional information (such as outgoing
3764 * interface or the scope zone of a destination address) to
3765 * disambiguate the scope.
3766 * XXX: the delay of the validation may confuse the
3767 * application when it is used as a sticky option.
3768 */
3769 if (opt->ip6po_pktinfo == NULL) {
3770 opt->ip6po_pktinfo = _MALLOC(sizeof(*pktinfo),
3771 M_IP6OPT, M_NOWAIT);
3772 if (opt->ip6po_pktinfo == NULL) {
3773 return ENOBUFS;
3774 }
3775 }
3776 bcopy(pktinfo, opt->ip6po_pktinfo, sizeof(*pktinfo));
3777 break;
3778 }
3779
3780 case IPV6_2292HOPLIMIT:
3781 case IPV6_HOPLIMIT: {
3782 int *hlimp;
3783
3784 /*
3785 * RFC 3542 deprecated the usage of sticky IPV6_HOPLIMIT
3786 * to simplify the ordering among hoplimit options.
3787 */
3788 if (optname == IPV6_HOPLIMIT && sticky) {
3789 return ENOPROTOOPT;
3790 }
3791
3792 if (len != sizeof(int)) {
3793 return EINVAL;
3794 }
3795 hlimp = (int *)(void *)buf;
3796 if (*hlimp < -1 || *hlimp > IPV6_MAXHLIM) {
3797 return EINVAL;
3798 }
3799
3800 opt->ip6po_hlim = *hlimp;
3801 break;
3802 }
3803
3804 case IPV6_TCLASS: {
3805 int tclass;
3806
3807 if (len != sizeof(int)) {
3808 return EINVAL;
3809 }
3810 tclass = *(int *)(void *)buf;
3811 if (tclass < -1 || tclass > 255) {
3812 return EINVAL;
3813 }
3814
3815 opt->ip6po_tclass = tclass;
3816 break;
3817 }
3818
3819 case IPV6_2292NEXTHOP:
3820 case IPV6_NEXTHOP:
3821 error = suser(kauth_cred_get(), 0);
3822 if (error) {
3823 return EACCES;
3824 }
3825
3826 if (len == 0) { /* just remove the option */
3827 ip6_clearpktopts(opt, IPV6_NEXTHOP);
3828 break;
3829 }
3830
3831 /* check if cmsg_len is large enough for sa_len */
3832 if (len < sizeof(struct sockaddr) || len < *buf) {
3833 return EINVAL;
3834 }
3835
3836 switch (SA(buf)->sa_family) {
3837 case AF_INET6: {
3838 struct sockaddr_in6 *sa6 = SIN6(buf);
3839
3840 if (sa6->sin6_len != sizeof(struct sockaddr_in6)) {
3841 return EINVAL;
3842 }
3843
3844 if (IN6_IS_ADDR_UNSPECIFIED(&sa6->sin6_addr) ||
3845 IN6_IS_ADDR_MULTICAST(&sa6->sin6_addr)) {
3846 return EINVAL;
3847 }
3848 if ((error = sa6_embedscope(sa6, ip6_use_defzone))
3849 != 0) {
3850 return error;
3851 }
3852 break;
3853 }
3854 case AF_LINK: /* should eventually be supported */
3855 default:
3856 return EAFNOSUPPORT;
3857 }
3858
3859 /* turn off the previous option, then set the new option. */
3860 ip6_clearpktopts(opt, IPV6_NEXTHOP);
3861 opt->ip6po_nexthop = _MALLOC(*buf, M_IP6OPT, M_NOWAIT);
3862 if (opt->ip6po_nexthop == NULL) {
3863 return ENOBUFS;
3864 }
3865 bcopy(buf, opt->ip6po_nexthop, *buf);
3866 break;
3867
3868 case IPV6_2292HOPOPTS:
3869 case IPV6_HOPOPTS: {
3870 struct ip6_hbh *hbh;
3871 int hbhlen;
3872
3873 /*
3874 * XXX: We don't allow a non-privileged user to set ANY HbH
3875 * options, since per-option restriction has too much
3876 * overhead.
3877 */
3878 error = suser(kauth_cred_get(), 0);
3879 if (error) {
3880 return EACCES;
3881 }
3882
3883 if (len == 0) {
3884 ip6_clearpktopts(opt, IPV6_HOPOPTS);
3885 break; /* just remove the option */
3886 }
3887
3888 /* message length validation */
3889 if (len < sizeof(struct ip6_hbh)) {
3890 return EINVAL;
3891 }
3892 hbh = (struct ip6_hbh *)(void *)buf;
3893 hbhlen = (hbh->ip6h_len + 1) << 3;
3894 if (len != hbhlen) {
3895 return EINVAL;
3896 }
3897
3898 /* turn off the previous option, then set the new option. */
3899 ip6_clearpktopts(opt, IPV6_HOPOPTS);
3900 opt->ip6po_hbh = _MALLOC(hbhlen, M_IP6OPT, M_NOWAIT);
3901 if (opt->ip6po_hbh == NULL) {
3902 return ENOBUFS;
3903 }
3904 bcopy(hbh, opt->ip6po_hbh, hbhlen);
3905 capture_exthdrstat_out = TRUE;
3906 break;
3907 }
3908
3909 case IPV6_2292DSTOPTS:
3910 case IPV6_DSTOPTS:
3911 case IPV6_RTHDRDSTOPTS: {
3912 struct ip6_dest *dest, **newdest = NULL;
3913 int destlen;
3914
3915 error = suser(kauth_cred_get(), 0);
3916 if (error) {
3917 return EACCES;
3918 }
3919
3920 if (len == 0) {
3921 ip6_clearpktopts(opt, optname);
3922 break; /* just remove the option */
3923 }
3924
3925 /* message length validation */
3926 if (len < sizeof(struct ip6_dest)) {
3927 return EINVAL;
3928 }
3929 dest = (struct ip6_dest *)(void *)buf;
3930 destlen = (dest->ip6d_len + 1) << 3;
3931 if (len != destlen) {
3932 return EINVAL;
3933 }
3934
3935 /*
3936 * Determine the position that the destination options header
3937 * should be inserted; before or after the routing header.
3938 */
3939 switch (optname) {
3940 case IPV6_2292DSTOPTS:
3941 /*
3942 * The old advacned API is ambiguous on this point.
3943 * Our approach is to determine the position based
3944 * according to the existence of a routing header.
3945 * Note, however, that this depends on the order of the
3946 * extension headers in the ancillary data; the 1st
3947 * part of the destination options header must appear
3948 * before the routing header in the ancillary data,
3949 * too.
3950 * RFC3542 solved the ambiguity by introducing
3951 * separate ancillary data or option types.
3952 */
3953 if (opt->ip6po_rthdr == NULL) {
3954 newdest = &opt->ip6po_dest1;
3955 } else {
3956 newdest = &opt->ip6po_dest2;
3957 }
3958 break;
3959 case IPV6_RTHDRDSTOPTS:
3960 newdest = &opt->ip6po_dest1;
3961 break;
3962 case IPV6_DSTOPTS:
3963 newdest = &opt->ip6po_dest2;
3964 break;
3965 }
3966
3967 /* turn off the previous option, then set the new option. */
3968 ip6_clearpktopts(opt, optname);
3969 *newdest = _MALLOC(destlen, M_IP6OPT, M_NOWAIT);
3970 if (*newdest == NULL) {
3971 return ENOBUFS;
3972 }
3973 bcopy(dest, *newdest, destlen);
3974 capture_exthdrstat_out = TRUE;
3975 break;
3976 }
3977
3978 case IPV6_2292RTHDR:
3979 case IPV6_RTHDR: {
3980 struct ip6_rthdr *rth;
3981 int rthlen;
3982
3983 if (len == 0) {
3984 ip6_clearpktopts(opt, IPV6_RTHDR);
3985 break; /* just remove the option */
3986 }
3987
3988 /* message length validation */
3989 if (len < sizeof(struct ip6_rthdr)) {
3990 return EINVAL;
3991 }
3992 rth = (struct ip6_rthdr *)(void *)buf;
3993 rthlen = (rth->ip6r_len + 1) << 3;
3994 if (len != rthlen) {
3995 return EINVAL;
3996 }
3997
3998 switch (rth->ip6r_type) {
3999 case IPV6_RTHDR_TYPE_0:
4000 if (rth->ip6r_len == 0) { /* must contain one addr */
4001 return EINVAL;
4002 }
4003 if (rth->ip6r_len % 2) { /* length must be even */
4004 return EINVAL;
4005 }
4006 if (rth->ip6r_len / 2 != rth->ip6r_segleft) {
4007 return EINVAL;
4008 }
4009 break;
4010 default:
4011 return EINVAL; /* not supported */
4012 }
4013
4014 /* turn off the previous option */
4015 ip6_clearpktopts(opt, IPV6_RTHDR);
4016 opt->ip6po_rthdr = _MALLOC(rthlen, M_IP6OPT, M_NOWAIT);
4017 if (opt->ip6po_rthdr == NULL) {
4018 return ENOBUFS;
4019 }
4020 bcopy(rth, opt->ip6po_rthdr, rthlen);
4021 capture_exthdrstat_out = TRUE;
4022 break;
4023 }
4024
4025 case IPV6_USE_MIN_MTU:
4026 if (len != sizeof(int)) {
4027 return EINVAL;
4028 }
4029 minmtupolicy = *(int *)(void *)buf;
4030 if (minmtupolicy != IP6PO_MINMTU_MCASTONLY &&
4031 minmtupolicy != IP6PO_MINMTU_DISABLE &&
4032 minmtupolicy != IP6PO_MINMTU_ALL) {
4033 return EINVAL;
4034 }
4035 opt->ip6po_minmtu = minmtupolicy;
4036 break;
4037
4038 case IPV6_DONTFRAG:
4039 if (len != sizeof(int)) {
4040 return EINVAL;
4041 }
4042
4043 if (uproto == IPPROTO_TCP || *(int *)(void *)buf == 0) {
4044 /*
4045 * we ignore this option for TCP sockets.
4046 * (RFC3542 leaves this case unspecified.)
4047 */
4048 opt->ip6po_flags &= ~IP6PO_DONTFRAG;
4049 } else {
4050 opt->ip6po_flags |= IP6PO_DONTFRAG;
4051 }
4052 break;
4053
4054 case IPV6_PREFER_TEMPADDR:
4055 if (len != sizeof(int)) {
4056 return EINVAL;
4057 }
4058 preftemp = *(int *)(void *)buf;
4059 if (preftemp != IP6PO_TEMPADDR_SYSTEM &&
4060 preftemp != IP6PO_TEMPADDR_NOTPREFER &&
4061 preftemp != IP6PO_TEMPADDR_PREFER) {
4062 return EINVAL;
4063 }
4064 opt->ip6po_prefer_tempaddr = preftemp;
4065 break;
4066
4067 default:
4068 return ENOPROTOOPT;
4069 } /* end of switch */
4070
4071 if (capture_exthdrstat_out) {
4072 if (uproto == IPPROTO_TCP) {
4073 INC_ATOMIC_INT64_LIM(net_api_stats.nas_sock_inet6_stream_exthdr_out);
4074 } else if (uproto == IPPROTO_UDP) {
4075 INC_ATOMIC_INT64_LIM(net_api_stats.nas_sock_inet6_dgram_exthdr_out);
4076 }
4077 }
4078
4079 return 0;
4080 }
4081
4082 /*
4083 * Routine called from ip6_output() to loop back a copy of an IP6 multicast
4084 * packet to the input queue of a specified interface. Note that this
4085 * calls the output routine of the loopback "driver", but with an interface
4086 * pointer that might NOT be &loif -- easier than replicating that code here.
4087 */
4088 void
4089 ip6_mloopback(struct ifnet *srcifp, struct ifnet *origifp, struct mbuf *m,
4090 struct sockaddr_in6 *dst, uint32_t optlen, int32_t nxt0)
4091 {
4092 struct mbuf *copym;
4093 struct ip6_hdr *ip6;
4094 struct in6_addr src;
4095
4096 if (lo_ifp == NULL) {
4097 return;
4098 }
4099
4100 /*
4101 * Copy the packet header as it's needed for the checksum.
4102 * Make sure to deep-copy IPv6 header portion in case the data
4103 * is in an mbuf cluster, so that we can safely override the IPv6
4104 * header portion later.
4105 */
4106 copym = m_copym_mode(m, 0, M_COPYALL, M_DONTWAIT, M_COPYM_COPY_HDR);
4107 if (copym != NULL && ((copym->m_flags & M_EXT) ||
4108 copym->m_len < sizeof(struct ip6_hdr))) {
4109 copym = m_pullup(copym, sizeof(struct ip6_hdr));
4110 }
4111
4112 if (copym == NULL) {
4113 return;
4114 }
4115
4116 ip6 = mtod(copym, struct ip6_hdr *);
4117 src = ip6->ip6_src;
4118 /*
4119 * clear embedded scope identifiers if necessary.
4120 * in6_clearscope will touch the addresses only when necessary.
4121 */
4122 in6_clearscope(&ip6->ip6_src);
4123 in6_clearscope(&ip6->ip6_dst);
4124
4125 if (copym->m_pkthdr.csum_flags & CSUM_DELAY_IPV6_DATA) {
4126 in6_delayed_cksum_offset(copym, 0, optlen, nxt0);
4127 }
4128
4129 /*
4130 * Stuff the 'real' ifp into the pkthdr, to be used in matching
4131 * in ip6_input(); we need the loopback ifp/dl_tag passed as args
4132 * to make the loopback driver compliant with the data link
4133 * requirements.
4134 */
4135 copym->m_pkthdr.rcvif = origifp;
4136
4137 /*
4138 * Also record the source interface (which owns the source address).
4139 * This is basically a stripped down version of ifa_foraddr6().
4140 */
4141 if (srcifp == NULL) {
4142 struct in6_ifaddr *ia;
4143
4144 lck_rw_lock_shared(&in6_ifaddr_rwlock);
4145 TAILQ_FOREACH(ia, IN6ADDR_HASH(&src), ia6_hash) {
4146 IFA_LOCK_SPIN(&ia->ia_ifa);
4147 /* compare against src addr with embedded scope */
4148 if (IN6_ARE_ADDR_EQUAL(&ia->ia_addr.sin6_addr, &src)) {
4149 srcifp = ia->ia_ifp;
4150 IFA_UNLOCK(&ia->ia_ifa);
4151 break;
4152 }
4153 IFA_UNLOCK(&ia->ia_ifa);
4154 }
4155 lck_rw_done(&in6_ifaddr_rwlock);
4156 }
4157 if (srcifp != NULL) {
4158 ip6_setsrcifaddr_info(copym, srcifp->if_index, NULL);
4159 }
4160 ip6_setdstifaddr_info(copym, origifp->if_index, NULL);
4161
4162 dlil_output(lo_ifp, PF_INET6, copym, NULL, SA(dst), 0, NULL);
4163 }
4164
4165 /*
4166 * Chop IPv6 header off from the payload.
4167 */
4168 static int
4169 ip6_splithdr(struct mbuf *m, struct ip6_exthdrs *exthdrs)
4170 {
4171 struct mbuf *mh;
4172 struct ip6_hdr *ip6;
4173
4174 ip6 = mtod(m, struct ip6_hdr *);
4175 if (m->m_len > sizeof(*ip6)) {
4176 MGETHDR(mh, M_DONTWAIT, MT_HEADER); /* MAC-OK */
4177 if (mh == NULL) {
4178 m_freem(m);
4179 return ENOBUFS;
4180 }
4181 M_COPY_PKTHDR(mh, m);
4182 MH_ALIGN(mh, sizeof(*ip6));
4183 m->m_flags &= ~M_PKTHDR;
4184 m->m_len -= sizeof(*ip6);
4185 m->m_data += sizeof(*ip6);
4186 mh->m_next = m;
4187 m = mh;
4188 m->m_len = sizeof(*ip6);
4189 bcopy((caddr_t)ip6, mtod(m, caddr_t), sizeof(*ip6));
4190 }
4191 exthdrs->ip6e_ip6 = m;
4192 return 0;
4193 }
4194
4195 static void
4196 ip6_output_checksum(struct ifnet *ifp, uint32_t mtu, struct mbuf *m,
4197 int nxt0, uint32_t tlen, uint32_t optlen)
4198 {
4199 uint32_t sw_csum, hwcap = ifp->if_hwassist;
4200 int tso = TSO_IPV6_OK(ifp, m);
4201
4202 if (!hwcksum_tx) {
4203 /* do all in software; checksum offload is disabled */
4204 sw_csum = CSUM_DELAY_IPV6_DATA & m->m_pkthdr.csum_flags;
4205 } else {
4206 /* do in software what the hardware cannot */
4207 sw_csum = m->m_pkthdr.csum_flags &
4208 ~IF_HWASSIST_CSUM_FLAGS(hwcap);
4209 }
4210
4211 if (optlen != 0) {
4212 sw_csum |= (CSUM_DELAY_IPV6_DATA &
4213 m->m_pkthdr.csum_flags);
4214 } else if (!(sw_csum & CSUM_DELAY_IPV6_DATA) &&
4215 (hwcap & CSUM_PARTIAL)) {
4216 /*
4217 * Partial checksum offload, ere), if no extension headers,
4218 * and TCP only (no UDP support, as the hardware may not be
4219 * able to convert +0 to -0 (0xffff) per RFC1122 4.1.3.4.
4220 * unless the interface supports "invert zero" capability.)
4221 */
4222 if (hwcksum_tx && !tso &&
4223 ((m->m_pkthdr.csum_flags & CSUM_TCPIPV6) ||
4224 ((hwcap & CSUM_ZERO_INVERT) &&
4225 (m->m_pkthdr.csum_flags & CSUM_ZERO_INVERT))) &&
4226 tlen <= mtu) {
4227 uint16_t start = sizeof(struct ip6_hdr);
4228 uint16_t ulpoff =
4229 m->m_pkthdr.csum_data & 0xffff;
4230 m->m_pkthdr.csum_flags |=
4231 (CSUM_DATA_VALID | CSUM_PARTIAL);
4232 m->m_pkthdr.csum_tx_stuff = (ulpoff + start);
4233 m->m_pkthdr.csum_tx_start = start;
4234 sw_csum = 0;
4235 } else {
4236 sw_csum |= (CSUM_DELAY_IPV6_DATA &
4237 m->m_pkthdr.csum_flags);
4238 }
4239 }
4240
4241 if (sw_csum & CSUM_DELAY_IPV6_DATA) {
4242 in6_delayed_cksum_offset(m, 0, optlen, nxt0);
4243 sw_csum &= ~CSUM_DELAY_IPV6_DATA;
4244 }
4245
4246 if (hwcksum_tx) {
4247 /*
4248 * Drop off bits that aren't supported by hardware;
4249 * also make sure to preserve non-checksum related bits.
4250 */
4251 m->m_pkthdr.csum_flags =
4252 ((m->m_pkthdr.csum_flags &
4253 (IF_HWASSIST_CSUM_FLAGS(hwcap) | CSUM_DATA_VALID)) |
4254 (m->m_pkthdr.csum_flags & ~IF_HWASSIST_CSUM_MASK));
4255 } else {
4256 /* drop all bits; checksum offload is disabled */
4257 m->m_pkthdr.csum_flags = 0;
4258 }
4259 }
4260
4261 /*
4262 * Compute IPv6 extension header length.
4263 */
4264 int
4265 ip6_optlen(struct in6pcb *in6p)
4266 {
4267 int len;
4268
4269 if (!in6p->in6p_outputopts) {
4270 return 0;
4271 }
4272
4273 len = 0;
4274 #define elen(x) \
4275 (((struct ip6_ext *)(x)) ? \
4276 (((struct ip6_ext *)(x))->ip6e_len + 1) << 3 : 0)
4277
4278 len += elen(in6p->in6p_outputopts->ip6po_hbh);
4279 if (in6p->in6p_outputopts->ip6po_rthdr) {
4280 /* dest1 is valid with rthdr only */
4281 len += elen(in6p->in6p_outputopts->ip6po_dest1);
4282 }
4283 len += elen(in6p->in6p_outputopts->ip6po_rthdr);
4284 len += elen(in6p->in6p_outputopts->ip6po_dest2);
4285 return len;
4286 #undef elen
4287 }
4288
4289 static int
4290 sysctl_reset_ip6_output_stats SYSCTL_HANDLER_ARGS
4291 {
4292 #pragma unused(arg1, arg2)
4293 int error, i;
4294
4295 i = ip6_output_measure;
4296 error = sysctl_handle_int(oidp, &i, 0, req);
4297 if (error || req->newptr == USER_ADDR_NULL) {
4298 goto done;
4299 }
4300 /* impose bounds */
4301 if (i < 0 || i > 1) {
4302 error = EINVAL;
4303 goto done;
4304 }
4305 if (ip6_output_measure != i && i == 1) {
4306 net_perf_initialize(&net_perf, ip6_output_measure_bins);
4307 }
4308 ip6_output_measure = i;
4309 done:
4310 return error;
4311 }
4312
4313 static int
4314 sysctl_ip6_output_measure_bins SYSCTL_HANDLER_ARGS
4315 {
4316 #pragma unused(arg1, arg2)
4317 int error;
4318 uint64_t i;
4319
4320 i = ip6_output_measure_bins;
4321 error = sysctl_handle_quad(oidp, &i, 0, req);
4322 if (error || req->newptr == USER_ADDR_NULL) {
4323 goto done;
4324 }
4325 /* validate data */
4326 if (!net_perf_validate_bins(i)) {
4327 error = EINVAL;
4328 goto done;
4329 }
4330 ip6_output_measure_bins = i;
4331 done:
4332 return error;
4333 }
4334
4335 static int
4336 sysctl_ip6_output_getperf SYSCTL_HANDLER_ARGS
4337 {
4338 #pragma unused(oidp, arg1, arg2)
4339 if (req->oldptr == USER_ADDR_NULL) {
4340 req->oldlen = (size_t)sizeof(struct ipstat);
4341 }
4342
4343 return SYSCTL_OUT(req, &net_perf, MIN(sizeof(net_perf), req->oldlen));
4344 }
mirror of XNU