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