1 /* $FreeBSD: src/sys/netinet6/ip6_output.c,v 1.13.2.18 2003/01/24 05:11:35 sam Exp $ */
2 /* $KAME: ip6_output.c,v 1.279 2002/01/26 06:12:30 jinmei Exp $ */
5 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the project nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * Copyright (c) 1982, 1986, 1988, 1990, 1993
35 * The Regents of the University of California. All rights reserved.
37 * Redistribution and use in source and binary forms, with or without
38 * modification, are permitted provided that the following conditions
40 * 1. Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * 2. Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in the
44 * documentation and/or other materials provided with the distribution.
45 * 3. Neither the name of the University nor the names of its contributors
46 * may be used to endorse or promote products derived from this software
47 * without specific prior written permission.
49 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
61 * @(#)ip_output.c 8.3 (Berkeley) 1/21/94
64 #include "opt_ip6fw.h"
66 #include "opt_inet6.h"
68 #include <sys/param.h>
69 #include <sys/malloc.h>
71 #include <sys/errno.h>
72 #include <sys/protosw.h>
73 #include <sys/socket.h>
74 #include <sys/socketvar.h>
75 #include <sys/systm.h>
76 #include <sys/kernel.h>
80 #include <sys/msgport2.h>
83 #include <net/route.h>
86 #include <netinet/in.h>
87 #include <netinet/in_var.h>
88 #include <netinet6/in6_var.h>
89 #include <netinet/ip6.h>
90 #include <netinet/icmp6.h>
91 #include <netinet6/ip6_var.h>
92 #include <netinet/in_pcb.h>
93 #include <netinet6/nd6.h>
94 #include <netinet6/ip6protosw.h>
96 #include <net/ip6fw/ip6_fw.h>
98 #include <net/net_osdep.h>
100 static MALLOC_DEFINE(M_IPMOPTS, "ip6_moptions", "internet multicast options");
103 struct mbuf *ip6e_ip6;
104 struct mbuf *ip6e_hbh;
105 struct mbuf *ip6e_dest1;
106 struct mbuf *ip6e_rthdr;
107 struct mbuf *ip6e_dest2;
110 static int ip6_pcbopt (int, u_char *, int, struct ip6_pktopts **, int);
111 static int ip6_setpktoption (int, u_char *, int, struct ip6_pktopts *,
113 static int ip6_pcbopts(struct ip6_pktopts **, struct mbuf *, struct socket *,
115 static int ip6_getpcbopt(struct ip6_pktopts *, int, struct sockopt *);
116 static int ip6_setmoptions (int, struct ip6_moptions **, struct mbuf *);
117 static int ip6_getmoptions (int, struct ip6_moptions *, struct mbuf **);
118 static int ip6_getpmtu(struct route_in6 *, struct route_in6 *,
119 struct ifnet *, struct in6_addr *, u_long *, int *);
120 static int copyexthdr (void *, struct mbuf **);
121 static int ip6_insertfraghdr(struct mbuf *, struct mbuf *, int,
123 static int ip6_insert_jumboopt (struct ip6_exthdrs *, u_int32_t);
124 static struct mbuf *ip6_splithdr (struct mbuf *);
125 static int copypktopts(struct ip6_pktopts *, struct ip6_pktopts *, int);
128 * IP6 output. The packet in mbuf chain m contains a skeletal IP6
129 * header (with pri, len, nxt, hlim, src, dst).
130 * This function may modify ver and hlim only.
131 * The mbuf chain containing the packet will be freed.
132 * The mbuf opt, if present, will not be freed.
134 * type of "mtu": rt_rmx.rmx_mtu is u_long, ifnet.ifr_mtu is int, and
135 * nd_ifinfo.linkmtu is u_int32_t. so we use u_long to hold largest one,
136 * which is rt_rmx.rmx_mtu.
139 ip6_output(struct mbuf *m0, struct ip6_pktopts *opt, struct route_in6 *ro,
140 int flags, struct ip6_moptions *im6o,
141 struct ifnet **ifpp, /* XXX: just for statistics */
144 struct ip6_hdr *ip6, *mhip6;
145 struct ifnet *ifp, *origifp;
149 int hlen, tlen, len, off;
150 struct route_in6 ip6route;
151 struct sockaddr_in6 *dst;
153 struct in6_ifaddr *ia = NULL;
155 int alwaysfrag, dontfrag;
156 u_int32_t optlen, plen = 0, unfragpartlen;
157 struct ip6_exthdrs exthdrs;
158 struct in6_addr finaldst;
159 struct route_in6 *ro_pmtu = NULL;
160 boolean_t hdrsplit = FALSE;
162 bzero(&exthdrs, sizeof exthdrs);
165 if ((error = copyexthdr(opt->ip6po_hbh, &exthdrs.ip6e_hbh)))
167 if ((error = copyexthdr(opt->ip6po_dest1, &exthdrs.ip6e_dest1)))
169 if ((error = copyexthdr(opt->ip6po_rthdr, &exthdrs.ip6e_rthdr)))
171 if ((error = copyexthdr(opt->ip6po_dest2, &exthdrs.ip6e_dest2)))
176 * Calculate the total length of the extension header chain.
177 * Keep the length of the unfragmentable part for fragmentation.
179 optlen = m_lengthm(exthdrs.ip6e_hbh, NULL) +
180 m_lengthm(exthdrs.ip6e_dest1, NULL) +
181 m_lengthm(exthdrs.ip6e_rthdr, NULL);
183 unfragpartlen = optlen + sizeof(struct ip6_hdr);
185 /* NOTE: we don't add AH/ESP length here. do that later. */
186 optlen += m_lengthm(exthdrs.ip6e_dest2, NULL);
189 * If there is at least one extension header,
190 * separate IP6 header from the payload.
192 if (optlen && !hdrsplit) {
193 exthdrs.ip6e_ip6 = ip6_splithdr(m);
194 if (exthdrs.ip6e_ip6 == NULL) {
198 m = exthdrs.ip6e_ip6;
203 ip6 = mtod(m, struct ip6_hdr *);
205 /* adjust mbuf packet header length */
206 m->m_pkthdr.len += optlen;
207 plen = m->m_pkthdr.len - sizeof(*ip6);
209 /* If this is a jumbo payload, insert a jumbo payload option. */
210 if (plen > IPV6_MAXPACKET) {
212 exthdrs.ip6e_ip6 = ip6_splithdr(m);
213 if (exthdrs.ip6e_ip6 == NULL) {
217 m = exthdrs.ip6e_ip6;
221 ip6 = mtod(m, struct ip6_hdr *);
222 if ((error = ip6_insert_jumboopt(&exthdrs, plen)) != 0)
226 ip6->ip6_plen = htons(plen);
229 * Concatenate headers and fill in next header fields.
230 * Here we have, on "m"
232 * and we insert headers accordingly. Finally, we should be getting:
233 * IPv6 hbh dest1 rthdr ah* [esp* dest2 payload]
235 * during the header composing process, "m" points to IPv6 header.
236 * "mprev" points to an extension header prior to esp.
239 nexthdrp = &ip6->ip6_nxt;
243 * we treat dest2 specially. the goal here is to make mprev point the
244 * mbuf prior to dest2.
246 * result: IPv6 dest2 payload
247 * m and mprev will point to IPv6 header.
249 if (exthdrs.ip6e_dest2) {
251 panic("assumption failed: hdr not split");
252 exthdrs.ip6e_dest2->m_next = m->m_next;
253 m->m_next = exthdrs.ip6e_dest2;
254 *mtod(exthdrs.ip6e_dest2, u_char *) = ip6->ip6_nxt;
255 ip6->ip6_nxt = IPPROTO_DSTOPTS;
259 * Place m1 after mprev.
261 #define MAKE_CHAIN(m1, mprev, nexthdrp, i)\
265 panic("assumption failed: hdr not split");\
266 *mtod(m1, u_char *) = *nexthdrp;\
268 nexthdrp = mtod(m1, u_char *);\
269 m1->m_next = mprev->m_next;\
276 * result: IPv6 hbh dest1 rthdr dest2 payload
277 * m will point to IPv6 header. mprev will point to the
278 * extension header prior to dest2 (rthdr in the above case).
280 MAKE_CHAIN(exthdrs.ip6e_hbh, mprev, nexthdrp, IPPROTO_HOPOPTS);
281 MAKE_CHAIN(exthdrs.ip6e_dest1, mprev, nexthdrp, IPPROTO_DSTOPTS);
282 MAKE_CHAIN(exthdrs.ip6e_rthdr, mprev, nexthdrp, IPPROTO_ROUTING);
285 * If there is a routing header, replace the destination address field
286 * with the first hop of the routing header.
288 if (exthdrs.ip6e_rthdr) {
289 struct ip6_rthdr *rh;
291 finaldst = ip6->ip6_dst;
292 rh = mtod(exthdrs.ip6e_rthdr, struct ip6_rthdr *);
293 switch (rh->ip6r_type) {
294 default: /* is it possible? */
300 /* Source address validation */
301 if (IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src) &&
302 !(flags & IPV6_DADOUTPUT)) {
304 ip6stat.ip6s_badscope++;
307 if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_src)) {
309 ip6stat.ip6s_badscope++;
313 ip6stat.ip6s_localout++;
320 bzero(ro, sizeof(*ro));
323 if (opt && opt->ip6po_rthdr)
324 ro = &opt->ip6po_route;
325 dst = (struct sockaddr_in6 *)&ro->ro_dst;
328 * If there is a cached route,
329 * check that it is to the same destination
330 * and is still up. If not, free it and try again.
332 if (ro->ro_rt != NULL &&
333 (!(ro->ro_rt->rt_flags & RTF_UP) || dst->sin6_family != AF_INET6 ||
334 !IN6_ARE_ADDR_EQUAL(&dst->sin6_addr, &ip6->ip6_dst))) {
338 if (ro->ro_rt == NULL) {
339 bzero(dst, sizeof(*dst));
340 dst->sin6_family = AF_INET6;
341 dst->sin6_len = sizeof(struct sockaddr_in6);
342 dst->sin6_addr = ip6->ip6_dst;
344 if (!IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {
347 #define ifatoia6(ifa) ((struct in6_ifaddr *)(ifa))
348 #define sin6tosa(sin6) ((struct sockaddr *)(sin6))
350 * interface selection comes here
351 * if an interface is specified from an upper layer,
354 if (ro->ro_rt == NULL) {
356 * non-bsdi always clone routes, if parent is
359 rtalloc((struct route *)ro);
361 if (ro->ro_rt == NULL) {
362 ip6stat.ip6s_noroute++;
363 error = EHOSTUNREACH;
364 /* XXX in6_ifstat_inc(ifp, ifs6_out_discard); */
367 ia = ifatoia6(ro->ro_rt->rt_ifa);
368 ifp = ro->ro_rt->rt_ifp;
370 if (ro->ro_rt->rt_flags & RTF_GATEWAY)
371 dst = (struct sockaddr_in6 *)ro->ro_rt->rt_gateway;
372 m->m_flags &= ~(M_BCAST | M_MCAST); /* just in case */
374 in6_ifstat_inc(ifp, ifs6_out_request);
377 * Check if the outgoing interface conflicts with
378 * the interface specified by ifi6_ifindex (if specified).
379 * Note that loopback interface is always okay.
380 * (this may happen when we are sending a packet to one of
381 * our own addresses.)
383 if (opt && opt->ip6po_pktinfo
384 && opt->ip6po_pktinfo->ipi6_ifindex) {
385 if (!(ifp->if_flags & IFF_LOOPBACK)
386 && ifp->if_index != opt->ip6po_pktinfo->ipi6_ifindex) {
387 ip6stat.ip6s_noroute++;
388 in6_ifstat_inc(ifp, ifs6_out_discard);
389 error = EHOSTUNREACH;
394 if (opt && opt->ip6po_hlim != -1)
395 ip6->ip6_hlim = opt->ip6po_hlim & 0xff;
398 struct in6_multi *in6m;
400 m->m_flags = (m->m_flags & ~M_BCAST) | M_MCAST;
403 * See if the caller provided any multicast options
407 ip6->ip6_hlim = im6o->im6o_multicast_hlim;
408 if (im6o->im6o_multicast_ifp != NULL)
409 ifp = im6o->im6o_multicast_ifp;
411 ip6->ip6_hlim = ip6_defmcasthlim;
414 * See if the caller provided the outgoing interface
415 * as an ancillary data.
416 * Boundary check for ifindex is assumed to be already done.
418 if (opt && opt->ip6po_pktinfo && opt->ip6po_pktinfo->ipi6_ifindex)
419 ifp = ifindex2ifnet[opt->ip6po_pktinfo->ipi6_ifindex];
422 * If the destination is a node-local scope multicast,
423 * the packet should be loop-backed only.
425 if (IN6_IS_ADDR_MC_INTFACELOCAL(&ip6->ip6_dst)) {
427 * If the outgoing interface is already specified,
428 * it should be a loopback interface.
430 if (ifp && !(ifp->if_flags & IFF_LOOPBACK)) {
431 ip6stat.ip6s_badscope++;
432 error = ENETUNREACH; /* XXX: better error? */
433 /* XXX correct ifp? */
434 in6_ifstat_inc(ifp, ifs6_out_discard);
441 if (opt && opt->ip6po_hlim != -1)
442 ip6->ip6_hlim = opt->ip6po_hlim & 0xff;
445 * If caller did not provide an interface lookup a
446 * default in the routing table. This is either a
447 * default for the speicfied group (i.e. a host
448 * route), or a multicast default (a route for the
452 if (ro->ro_rt == NULL) {
454 rtpurelookup((struct sockaddr *)&ro->ro_dst);
456 if (ro->ro_rt == NULL) {
457 ip6stat.ip6s_noroute++;
458 error = EHOSTUNREACH;
459 /* XXX in6_ifstat_inc(ifp, ifs6_out_discard) */
462 ia = ifatoia6(ro->ro_rt->rt_ifa);
463 ifp = ro->ro_rt->rt_ifp;
467 if (!(flags & IPV6_FORWARDING))
468 in6_ifstat_inc(ifp, ifs6_out_request);
469 in6_ifstat_inc(ifp, ifs6_out_mcast);
472 * Confirm that the outgoing interface supports multicast.
474 if (!(ifp->if_flags & IFF_MULTICAST)) {
475 ip6stat.ip6s_noroute++;
476 in6_ifstat_inc(ifp, ifs6_out_discard);
480 in6m = IN6_LOOKUP_MULTI(&ip6->ip6_dst, ifp);
482 (im6o == NULL || im6o->im6o_multicast_loop)) {
484 * If we belong to the destination multicast group
485 * on the outgoing interface, and the caller did not
486 * forbid loopback, loop back a copy.
488 ip6_mloopback(ifp, m, dst);
491 * If we are acting as a multicast router, perform
492 * multicast forwarding as if the packet had just
493 * arrived on the interface to which we are about
494 * to send. The multicast forwarding function
495 * recursively calls this function, using the
496 * IPV6_FORWARDING flag to prevent infinite recursion.
498 * Multicasts that are looped back by ip6_mloopback(),
499 * above, will be forwarded by the ip6_input() routine,
502 if (ip6_mrouter && !(flags & IPV6_FORWARDING)) {
503 if (ip6_mforward(ip6, ifp, m) != 0) {
510 * Multicasts with a hoplimit of zero may be looped back,
511 * above, but must not be transmitted on a network.
512 * Also, multicasts addressed to the loopback interface
513 * are not sent -- the above call to ip6_mloopback() will
514 * loop back a copy if this host actually belongs to the
515 * destination group on the loopback interface.
517 if (ip6->ip6_hlim == 0 || (ifp->if_flags & IFF_LOOPBACK)) {
524 * Fill the outgoing inteface to tell the upper layer
525 * to increment per-interface statistics.
530 /* Determine path MTU. */
531 if ((error = ip6_getpmtu(ro_pmtu, ro, ifp, &finaldst, &mtu,
536 * The caller of this function may specify to use the minimum MTU
538 * An advanced API option (IPV6_USE_MIN_MTU) can also override MTU
539 * setting. The logic is a bit complicated; by default, unicast
540 * packets will follow path MTU while multicast packets will be sent at
541 * the minimum MTU. If IP6PO_MINMTU_ALL is specified, all packets
542 * including unicast ones will be sent at the minimum MTU. Multicast
543 * packets will always be sent at the minimum MTU unless
544 * IP6PO_MINMTU_DISABLE is explicitly specified.
545 * See RFC 3542 for more details.
547 if (mtu > IPV6_MMTU) {
548 if ((flags & IPV6_MINMTU))
550 else if (opt && opt->ip6po_minmtu == IP6PO_MINMTU_ALL)
552 else if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) &&
554 opt->ip6po_minmtu != IP6PO_MINMTU_DISABLE)) {
559 /* Fake scoped addresses */
560 if ((ifp->if_flags & IFF_LOOPBACK) != 0) {
562 * If source or destination address is a scoped address, and
563 * the packet is going to be sent to a loopback interface,
564 * we should keep the original interface.
568 * XXX: this is a very experimental and temporary solution.
569 * We eventually have sockaddr_in6 and use the sin6_scope_id
570 * field of the structure here.
571 * We rely on the consistency between two scope zone ids
572 * of source and destination, which should already be assured.
573 * Larger scopes than link will be supported in the future.
576 if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src))
577 origifp = ifindex2ifnet[ntohs(ip6->ip6_src.s6_addr16[1])];
578 else if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst))
579 origifp = ifindex2ifnet[ntohs(ip6->ip6_dst.s6_addr16[1])];
581 * XXX: origifp can be NULL even in those two cases above.
582 * For example, if we remove the (only) link-local address
583 * from the loopback interface, and try to send a link-local
584 * address without link-id information. Then the source
585 * address is ::1, and the destination address is the
586 * link-local address with its s6_addr16[1] being zero.
587 * What is worse, if the packet goes to the loopback interface
588 * by a default rejected route, the null pointer would be
589 * passed to looutput, and the kernel would hang.
590 * The following last resort would prevent such disaster.
598 * clear embedded scope identifiers if necessary.
599 * in6_clearscope will touch the addresses only when necessary.
601 in6_clearscope(&ip6->ip6_src);
602 in6_clearscope(&ip6->ip6_dst);
605 * Check with the firewall...
607 if (ip6_fw_enable && ip6_fw_chk_ptr) {
610 m->m_pkthdr.rcvif = NULL; /* XXX */
611 /* If ipfw says divert, we have to just drop packet */
612 if ((*ip6_fw_chk_ptr)(&ip6, ifp, &port, &m)) {
623 * If the outgoing packet contains a hop-by-hop options header,
624 * it must be examined and processed even by the source node.
625 * (RFC 2460, section 4.)
627 if (exthdrs.ip6e_hbh) {
628 struct ip6_hbh *hbh = mtod(exthdrs.ip6e_hbh, struct ip6_hbh *);
629 u_int32_t dummy1; /* XXX unused */
630 u_int32_t dummy2; /* XXX unused */
633 if ((hbh->ip6h_len + 1) << 3 > exthdrs.ip6e_hbh->m_len)
634 panic("ip6e_hbh is not continuous");
637 * XXX: if we have to send an ICMPv6 error to the sender,
638 * we need the M_LOOP flag since icmp6_error() expects
639 * the IPv6 and the hop-by-hop options header are
640 * continuous unless the flag is set.
642 m->m_flags |= M_LOOP;
643 m->m_pkthdr.rcvif = ifp;
644 if (ip6_process_hopopts(m, (u_int8_t *)(hbh + 1),
645 ((hbh->ip6h_len + 1) << 3) - sizeof(struct ip6_hbh),
646 &dummy1, &dummy2) < 0) {
647 /* m was already freed at this point */
648 error = EINVAL;/* better error? */
651 m->m_flags &= ~M_LOOP; /* XXX */
652 m->m_pkthdr.rcvif = NULL;
656 * Run through list of hooks for output packets.
658 if (pfil_has_hooks(&inet6_pfil_hook)) {
659 error = pfil_run_hooks(&inet6_pfil_hook, &m, ifp, PFIL_OUT);
660 if (error != 0 || m == NULL)
662 ip6 = mtod(m, struct ip6_hdr *);
666 * Send the packet to the outgoing interface.
667 * If necessary, do IPv6 fragmentation before sending.
669 * the logic here is rather complex:
670 * 1: normal case (dontfrag == 0, alwaysfrag == 0)
671 * 1-a: send as is if tlen <= path mtu
672 * 1-b: fragment if tlen > path mtu
674 * 2: if user asks us not to fragment (dontfrag == 1)
675 * 2-a: send as is if tlen <= interface mtu
676 * 2-b: error if tlen > interface mtu
678 * 3: if we always need to attach fragment header (alwaysfrag == 1)
681 * 4: if dontfrag == 1 && alwaysfrag == 1
682 * error, as we cannot handle this conflicting request
684 tlen = m->m_pkthdr.len;
686 if (opt && (opt->ip6po_flags & IP6PO_DONTFRAG))
690 if (dontfrag && alwaysfrag) { /* case 4 */
691 /* conflicting request - can't transmit */
695 if (dontfrag && tlen > IN6_LINKMTU(ifp)) { /* case 2-b */
697 * Even if the DONTFRAG option is specified, we cannot send the
698 * packet when the data length is larger than the MTU of the
699 * outgoing interface.
700 * Notify the error by sending IPV6_PATHMTU ancillary data as
701 * well as returning an error code (the latter is not described
705 struct ip6ctlparam ip6cp;
707 mtu32 = (u_int32_t)mtu;
708 bzero(&ip6cp, sizeof(ip6cp));
709 ip6cp.ip6c_cmdarg = (void *)&mtu32;
710 kpfctlinput2(PRC_MSGSIZE, (struct sockaddr *)&ro_pmtu->ro_dst,
718 * transmit packet without fragmentation
720 if (dontfrag || (!alwaysfrag && tlen <= mtu)) { /* case 1-a and 2-a */
721 struct in6_ifaddr *ia6;
723 ip6 = mtod(m, struct ip6_hdr *);
724 ia6 = in6_ifawithifp(ifp, &ip6->ip6_src);
726 /* Record statistics for this interface address. */
727 IFA_STAT_INC(&ia6->ia_ifa, opackets, 1);
728 IFA_STAT_INC(&ia6->ia_ifa, obytes, m->m_pkthdr.len);
730 error = nd6_output(ifp, origifp, m, dst, ro->ro_rt);
735 * try to fragment the packet. case 1-b and 3
737 if (mtu < IPV6_MMTU) {
739 * note that path MTU is never less than IPV6_MMTU
743 in6_ifstat_inc(ifp, ifs6_out_fragfail);
745 } else if (ip6->ip6_plen == 0) {
746 /* jumbo payload cannot be fragmented */
748 in6_ifstat_inc(ifp, ifs6_out_fragfail);
751 struct mbuf **mnext, *m_frgpart;
752 struct ip6_frag *ip6f;
753 u_int32_t id = htonl(ip6_id++);
757 * Too large for the destination or interface;
758 * fragment if possible.
759 * Must be able to put at least 8 bytes per fragment.
761 hlen = unfragpartlen;
762 if (mtu > IPV6_MAXPACKET)
763 mtu = IPV6_MAXPACKET;
765 len = (mtu - hlen - sizeof(struct ip6_frag)) & ~7;
768 in6_ifstat_inc(ifp, ifs6_out_fragfail);
772 mnext = &m->m_nextpkt;
775 * Change the next header field of the last header in the
776 * unfragmentable part.
778 if (exthdrs.ip6e_rthdr) {
779 nextproto = *mtod(exthdrs.ip6e_rthdr, u_char *);
780 *mtod(exthdrs.ip6e_rthdr, u_char *) = IPPROTO_FRAGMENT;
781 } else if (exthdrs.ip6e_dest1) {
782 nextproto = *mtod(exthdrs.ip6e_dest1, u_char *);
783 *mtod(exthdrs.ip6e_dest1, u_char *) = IPPROTO_FRAGMENT;
784 } else if (exthdrs.ip6e_hbh) {
785 nextproto = *mtod(exthdrs.ip6e_hbh, u_char *);
786 *mtod(exthdrs.ip6e_hbh, u_char *) = IPPROTO_FRAGMENT;
788 nextproto = ip6->ip6_nxt;
789 ip6->ip6_nxt = IPPROTO_FRAGMENT;
793 * Loop through length of segment after first fragment,
794 * make new header and copy data of each part and link onto
798 for (off = hlen; off < tlen; off += len) {
799 MGETHDR(m, M_NOWAIT, MT_HEADER);
802 ip6stat.ip6s_odropped++;
805 m->m_pkthdr.rcvif = NULL;
806 m->m_flags = m0->m_flags & M_COPYFLAGS;
808 mnext = &m->m_nextpkt;
809 m->m_data += max_linkhdr;
810 mhip6 = mtod(m, struct ip6_hdr *);
812 m->m_len = sizeof(*mhip6);
813 error = ip6_insertfraghdr(m0, m, hlen, &ip6f);
815 ip6stat.ip6s_odropped++;
818 ip6f->ip6f_offlg = htons((u_short)((off - hlen) & ~7));
819 if (off + len >= tlen)
822 ip6f->ip6f_offlg |= IP6F_MORE_FRAG;
823 mhip6->ip6_plen = htons((u_short)(len + hlen +
824 sizeof(*ip6f) - sizeof(struct ip6_hdr)));
825 if ((m_frgpart = m_copy(m0, off, len)) == NULL) {
827 ip6stat.ip6s_odropped++;
831 m->m_pkthdr.len = len + hlen + sizeof(*ip6f);
832 m->m_pkthdr.rcvif = NULL;
833 ip6f->ip6f_reserved = 0;
834 ip6f->ip6f_ident = id;
835 ip6f->ip6f_nxt = nextproto;
836 ip6stat.ip6s_ofragments++;
837 in6_ifstat_inc(ifp, ifs6_out_fragcreat);
840 in6_ifstat_inc(ifp, ifs6_out_fragok);
844 * Remove leading garbages.
848 m0->m_nextpkt = NULL;
850 for (m0 = m; m; m = m0) {
854 /* Record statistics for this interface address. */
856 IFA_STAT_INC(&ia->ia_ifa, opackets, 1);
857 IFA_STAT_INC(&ia->ia_ifa, obytes,
860 error = nd6_output(ifp, origifp, m, dst, ro->ro_rt);
866 ip6stat.ip6s_fragmented++;
869 if (ro == &ip6route && ro->ro_rt) { /* brace necessary for RTFREE */
871 } else if (ro_pmtu == &ip6route && ro_pmtu->ro_rt) {
872 RTFREE(ro_pmtu->ro_rt);
878 m_freem(exthdrs.ip6e_hbh); /* m_freem will check if mbuf is 0 */
879 m_freem(exthdrs.ip6e_dest1);
880 m_freem(exthdrs.ip6e_rthdr);
881 m_freem(exthdrs.ip6e_dest2);
889 copyexthdr(void *h, struct mbuf **mp)
891 struct ip6_ext *hdr = h;
898 hlen = (hdr->ip6e_len + 1) * 8;
900 return ENOBUFS; /* XXX */
902 m = m_getb(hlen, M_NOWAIT, MT_DATA, 0);
907 bcopy(hdr, mtod(m, caddr_t), hlen);
914 * Insert jumbo payload option.
917 ip6_insert_jumboopt(struct ip6_exthdrs *exthdrs, u_int32_t plen)
923 #define JUMBOOPTLEN 8 /* length of jumbo payload option and padding */
926 * If there is no hop-by-hop options header, allocate new one.
927 * If there is one but it doesn't have enough space to store the
928 * jumbo payload option, allocate a cluster to store the whole options.
929 * Otherwise, use it to store the options.
931 if (exthdrs->ip6e_hbh == NULL) {
932 MGET(mopt, M_NOWAIT, MT_DATA);
935 mopt->m_len = JUMBOOPTLEN;
936 optbuf = mtod(mopt, u_char *);
937 optbuf[1] = 0; /* = ((JUMBOOPTLEN) >> 3) - 1 */
938 exthdrs->ip6e_hbh = mopt;
942 mopt = exthdrs->ip6e_hbh;
943 if (M_TRAILINGSPACE(mopt) < JUMBOOPTLEN) {
946 * - exthdrs->ip6e_hbh is not referenced from places
947 * other than exthdrs.
948 * - exthdrs->ip6e_hbh is not an mbuf chain.
950 int oldoptlen = mopt->m_len;
954 * XXX: give up if the whole (new) hbh header does
955 * not fit even in an mbuf cluster.
957 if (oldoptlen + JUMBOOPTLEN > MCLBYTES)
961 * As a consequence, we must always prepare a cluster
964 n = m_getcl(M_NOWAIT, MT_DATA, 0);
967 n->m_len = oldoptlen + JUMBOOPTLEN;
968 bcopy(mtod(mopt, caddr_t), mtod(n, caddr_t), oldoptlen);
969 optbuf = mtod(n, caddr_t) + oldoptlen;
971 mopt = exthdrs->ip6e_hbh = n;
973 optbuf = mtod(mopt, u_char *) + mopt->m_len;
974 mopt->m_len += JUMBOOPTLEN;
976 optbuf[0] = IP6OPT_PADN;
980 * Adjust the header length according to the pad and
981 * the jumbo payload option.
983 hbh = mtod(mopt, struct ip6_hbh *);
984 hbh->ip6h_len += (JUMBOOPTLEN >> 3);
987 /* fill in the option. */
988 optbuf[2] = IP6OPT_JUMBO;
990 v = (u_int32_t)htonl(plen + JUMBOOPTLEN);
991 bcopy(&v, &optbuf[4], sizeof(u_int32_t));
993 /* finally, adjust the packet header length */
994 exthdrs->ip6e_ip6->m_pkthdr.len += JUMBOOPTLEN;
1001 * Insert fragment header and copy unfragmentable header portions.
1004 ip6_insertfraghdr(struct mbuf *m0, struct mbuf *m, int hlen,
1005 struct ip6_frag **frghdrp)
1007 struct mbuf *n, *mlast;
1009 if (hlen > sizeof(struct ip6_hdr)) {
1010 n = m_copym(m0, sizeof(struct ip6_hdr),
1011 hlen - sizeof(struct ip6_hdr), M_NOWAIT);
1018 /* Search for the last mbuf of unfragmentable part. */
1019 for (mlast = n; mlast->m_next; mlast = mlast->m_next)
1022 if (!(mlast->m_flags & M_EXT) &&
1023 M_TRAILINGSPACE(mlast) >= sizeof(struct ip6_frag)) {
1024 /* use the trailing space of the last mbuf for the fragment hdr */
1025 *frghdrp = (struct ip6_frag *)
1026 (mtod(mlast, caddr_t) + mlast->m_len);
1027 mlast->m_len += sizeof(struct ip6_frag);
1028 m->m_pkthdr.len += sizeof(struct ip6_frag);
1030 /* allocate a new mbuf for the fragment header */
1033 MGET(mfrg, M_NOWAIT, MT_DATA);
1036 mfrg->m_len = sizeof(struct ip6_frag);
1037 *frghdrp = mtod(mfrg, struct ip6_frag *);
1038 mlast->m_next = mfrg;
1045 ip6_getpmtu(struct route_in6 *ro_pmtu, struct route_in6 *ro,
1046 struct ifnet *ifp, struct in6_addr *dst, u_long *mtup,
1053 if (ro_pmtu != ro) {
1054 /* The first hop and the final destination may differ. */
1055 struct sockaddr_in6 *sa6_dst =
1056 (struct sockaddr_in6 *)&ro_pmtu->ro_dst;
1057 if (ro_pmtu->ro_rt &&
1058 ((ro_pmtu->ro_rt->rt_flags & RTF_UP) == 0 ||
1059 !IN6_ARE_ADDR_EQUAL(&sa6_dst->sin6_addr, dst))) {
1060 RTFREE(ro_pmtu->ro_rt);
1061 ro_pmtu->ro_rt = NULL;
1063 if (ro_pmtu->ro_rt == NULL) {
1064 bzero(sa6_dst, sizeof(*sa6_dst));
1065 sa6_dst->sin6_family = AF_INET6;
1066 sa6_dst->sin6_len = sizeof(struct sockaddr_in6);
1067 sa6_dst->sin6_addr = *dst;
1069 rtalloc((struct route *)ro_pmtu);
1072 if (ro_pmtu->ro_rt) {
1076 ifp = ro_pmtu->ro_rt->rt_ifp;
1077 ifmtu = IN6_LINKMTU(ifp);
1078 mtu = ro_pmtu->ro_rt->rt_rmx.rmx_mtu;
1081 } else if (mtu < IPV6_MMTU) {
1083 * RFC2460 section 5, last paragraph:
1084 * if we record ICMPv6 too big message with
1085 * mtu < IPV6_MMTU, transmit packets sized IPV6_MMTU
1086 * or smaller, with framgent header attached.
1087 * (fragment header is needed regardless from the
1088 * packet size, for translators to identify packets)
1092 } else if (mtu > ifmtu) {
1094 * The MTU on the route is larger than the MTU on
1095 * the interface! This shouldn't happen, unless the
1096 * MTU of the interface has been changed after the
1097 * interface was brought up. Change the MTU in the
1098 * route to match the interface MTU (as long as the
1099 * field isn't locked).
1102 ro_pmtu->ro_rt->rt_rmx.rmx_mtu = mtu;
1105 mtu = IN6_LINKMTU(ifp);
1107 error = EHOSTUNREACH; /* XXX */
1112 *alwaysfragp = alwaysfrag;
1117 * IP6 socket option processing.
1120 ip6_ctloutput_dispatch(netmsg_t msg)
1124 error = ip6_ctloutput(msg->ctloutput.base.nm_so,
1125 msg->ctloutput.nm_sopt);
1126 lwkt_replymsg(&msg->ctloutput.base.lmsg, error);
1130 ip6_ctloutput(struct socket *so, struct sockopt *sopt)
1132 int optdatalen,uproto;
1134 struct inpcb *in6p = so->so_pcb;
1137 int level, op, optname;
1142 level = sopt->sopt_level;
1143 op = sopt->sopt_dir;
1144 optname = sopt->sopt_name;
1145 optlen = sopt->sopt_valsize;
1148 panic("ip6_ctloutput: arg soopt is NULL");
1154 uproto = (int)so->so_proto->pr_protocol;
1155 privileged = (td == NULL || priv_check(td, PRIV_ROOT)) ? 0 : 1;
1157 if (level == IPPROTO_IPV6) {
1162 case IPV6_2292PKTOPTIONS:
1163 #ifdef IPV6_PKTOPTIONS
1164 case IPV6_PKTOPTIONS:
1169 error = soopt_getm(sopt, &m); /* XXX */
1172 soopt_to_mbuf(sopt, m); /* XXX */
1173 error = ip6_pcbopts(&in6p->in6p_outputopts,
1175 m_freem(m); /* XXX */
1180 * Use of some Hop-by-Hop options or some
1181 * Destination options, might require special
1182 * privilege. That is, normal applications
1183 * (without special privilege) might be forbidden
1184 * from setting certain options in outgoing packets,
1185 * and might never see certain options in received
1186 * packets. [RFC 2292 Section 6]
1187 * KAME specific note:
1188 * KAME prevents non-privileged users from sending or
1189 * receiving ANY hbh/dst options in order to avoid
1190 * overhead of parsing options in the kernel.
1192 case IPV6_RECVHOPOPTS:
1193 case IPV6_RECVDSTOPTS:
1194 case IPV6_RECVRTHDRDSTOPTS:
1197 case IPV6_RECVPKTINFO:
1198 case IPV6_RECVHOPLIMIT:
1199 case IPV6_RECVRTHDR:
1200 case IPV6_RECVPATHMTU:
1201 case IPV6_RECVTCLASS:
1202 case IPV6_AUTOFLOWLABEL:
1205 case IPV6_UNICAST_HOPS:
1208 if (optlen != sizeof(int)) {
1212 error = soopt_to_kbuf(sopt, &optval,
1213 sizeof optval, sizeof optval);
1218 case IPV6_UNICAST_HOPS:
1219 if (optval < -1 || optval >= 256)
1222 /* -1 = kernel default */
1223 in6p->in6p_hops = optval;
1226 #define OPTSET(bit) \
1229 in6p->in6p_flags |= (bit); \
1231 in6p->in6p_flags &= ~(bit); \
1233 #define OPTBIT(bit) (in6p->in6p_flags & (bit) ? 1 : 0)
1235 * Although changed to RFC3542, It's better to also support RFC2292 API
1237 #define OPTSET2292(bit) \
1239 in6p->in6p_flags |= IN6P_RFC2292; \
1241 in6p->in6p_flags |= (bit); \
1243 in6p->in6p_flags &= ~(bit); \
1244 } while (/*CONSTCOND*/ 0)
1246 case IPV6_RECVPKTINFO:
1247 /* cannot mix with RFC2292 */
1248 if (OPTBIT(IN6P_RFC2292)) {
1252 OPTSET(IN6P_PKTINFO);
1257 struct ip6_pktopts **optp;
1259 /* cannot mix with RFC2292 */
1260 if (OPTBIT(IN6P_RFC2292)) {
1264 optp = &in6p->in6p_outputopts;
1265 error = ip6_pcbopt(IPV6_HOPLIMIT,
1266 (u_char *)&optval, sizeof(optval),
1271 case IPV6_RECVHOPLIMIT:
1272 /* cannot mix with RFC2292 */
1273 if (OPTBIT(IN6P_RFC2292)) {
1277 OPTSET(IN6P_HOPLIMIT);
1280 case IPV6_RECVHOPOPTS:
1281 /* cannot mix with RFC2292 */
1282 if (OPTBIT(IN6P_RFC2292)) {
1286 OPTSET(IN6P_HOPOPTS);
1289 case IPV6_RECVDSTOPTS:
1290 /* cannot mix with RFC2292 */
1291 if (OPTBIT(IN6P_RFC2292)) {
1295 OPTSET(IN6P_DSTOPTS);
1298 case IPV6_RECVRTHDRDSTOPTS:
1299 /* cannot mix with RFC2292 */
1300 if (OPTBIT(IN6P_RFC2292)) {
1304 OPTSET(IN6P_RTHDRDSTOPTS);
1307 case IPV6_RECVRTHDR:
1308 /* cannot mix with RFC2292 */
1309 if (OPTBIT(IN6P_RFC2292)) {
1316 case IPV6_RECVPATHMTU:
1318 * We ignore this option for TCP
1320 * (RFC3542 leaves this case
1323 if (uproto != IPPROTO_TCP)
1327 case IPV6_RECVTCLASS:
1328 /* cannot mix with RFC2292 XXX */
1329 if (OPTBIT(IN6P_RFC2292)) {
1333 OPTSET(IN6P_TCLASS);
1336 case IPV6_AUTOFLOWLABEL:
1337 OPTSET(IN6P_AUTOFLOWLABEL);
1342 * make setsockopt(IPV6_V6ONLY)
1343 * available only prior to bind(2).
1345 if (in6p->in6p_lport ||
1346 !IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr))
1352 /* Don't allow v4-mapped */
1361 case IPV6_USE_MIN_MTU:
1362 case IPV6_PREFER_TEMPADDR:
1363 if (optlen != sizeof(optval)) {
1367 error = soopt_to_kbuf(sopt, &optval,
1368 sizeof optval, sizeof optval);
1372 struct ip6_pktopts **optp;
1373 optp = &in6p->in6p_outputopts;
1374 error = ip6_pcbopt(optname,
1375 (u_char *)&optval, sizeof(optval),
1380 case IPV6_2292PKTINFO:
1381 case IPV6_2292HOPLIMIT:
1382 case IPV6_2292HOPOPTS:
1383 case IPV6_2292DSTOPTS:
1384 case IPV6_2292RTHDR:
1386 if (optlen != sizeof(int)) {
1390 error = soopt_to_kbuf(sopt, &optval,
1391 sizeof optval, sizeof optval);
1395 case IPV6_2292PKTINFO:
1396 OPTSET2292(IN6P_PKTINFO);
1398 case IPV6_2292HOPLIMIT:
1399 OPTSET2292(IN6P_HOPLIMIT);
1401 case IPV6_2292HOPOPTS:
1403 * Check super-user privilege.
1404 * See comments for IPV6_RECVHOPOPTS.
1408 OPTSET2292(IN6P_HOPOPTS);
1410 case IPV6_2292DSTOPTS:
1413 OPTSET2292(IN6P_DSTOPTS|IN6P_RTHDRDSTOPTS); /* XXX */
1415 case IPV6_2292RTHDR:
1416 OPTSET2292(IN6P_RTHDR);
1425 case IPV6_RTHDRDSTOPTS:
1429 * New advanced API (RFC3542)
1432 u_char optbuf_storage[MCLBYTES];
1434 struct ip6_pktopts **optp;
1436 /* cannot mix with RFC2292 */
1437 if (OPTBIT(IN6P_RFC2292)) {
1443 * We only ensure valsize is not too large
1444 * here. Further validation will be done
1447 error = soopt_to_kbuf(sopt, optbuf_storage,
1448 sizeof(optbuf_storage), 0);
1451 optlen = sopt->sopt_valsize;
1452 optbuf = optbuf_storage;
1453 optp = &in6p->in6p_outputopts;
1454 error = ip6_pcbopt(optname, optbuf, optlen,
1460 case IPV6_MULTICAST_IF:
1461 case IPV6_MULTICAST_HOPS:
1462 case IPV6_MULTICAST_LOOP:
1463 case IPV6_JOIN_GROUP:
1464 case IPV6_LEAVE_GROUP:
1468 if (sopt->sopt_valsize > MLEN) {
1473 MGET(m, sopt->sopt_td ? M_WAITOK : M_NOWAIT, MT_HEADER);
1478 m->m_len = sopt->sopt_valsize;
1479 error = soopt_to_kbuf(sopt, mtod(m, char *),
1480 m->m_len, m->m_len);
1481 error = ip6_setmoptions(sopt->sopt_name,
1482 &in6p->in6p_moptions,
1488 case IPV6_PORTRANGE:
1489 error = soopt_to_kbuf(sopt, &optval,
1490 sizeof optval, sizeof optval);
1495 case IPV6_PORTRANGE_DEFAULT:
1496 in6p->in6p_flags &= ~(IN6P_LOWPORT);
1497 in6p->in6p_flags &= ~(IN6P_HIGHPORT);
1500 case IPV6_PORTRANGE_HIGH:
1501 in6p->in6p_flags &= ~(IN6P_LOWPORT);
1502 in6p->in6p_flags |= IN6P_HIGHPORT;
1505 case IPV6_PORTRANGE_LOW:
1506 in6p->in6p_flags &= ~(IN6P_HIGHPORT);
1507 in6p->in6p_flags |= IN6P_LOWPORT;
1522 struct mbuf **mp = &m;
1524 if (ip6_fw_ctl_ptr == NULL)
1527 if ((error = soopt_getm(sopt, &m)) != 0)
1530 soopt_to_mbuf(sopt, m);
1531 error = (*ip6_fw_ctl_ptr)(optname, mp);
1537 error = ENOPROTOOPT;
1544 case IPV6_2292PKTOPTIONS:
1545 #ifdef IPV6_PKTOPTIONS
1546 case IPV6_PKTOPTIONS:
1549 * RFC3542 (effectively) deprecated the
1550 * semantics of the 2292-style pktoptions.
1551 * Since it was not reliable in nature (i.e.,
1552 * applications had to expect the lack of some
1553 * information after all), it would make sense
1554 * to simplify this part by always returning
1557 if (in6p->in6p_options) {
1559 m = m_copym(in6p->in6p_options,
1560 0, M_COPYALL, M_WAITOK);
1561 error = soopt_from_mbuf(sopt, m);
1565 sopt->sopt_valsize = 0;
1568 case IPV6_RECVHOPOPTS:
1569 case IPV6_RECVDSTOPTS:
1570 case IPV6_RECVRTHDRDSTOPTS:
1571 case IPV6_UNICAST_HOPS:
1572 case IPV6_RECVPKTINFO:
1573 case IPV6_RECVHOPLIMIT:
1574 case IPV6_RECVRTHDR:
1575 case IPV6_RECVPATHMTU:
1576 case IPV6_RECVTCLASS:
1577 case IPV6_AUTOFLOWLABEL:
1579 case IPV6_PORTRANGE:
1582 case IPV6_RECVHOPOPTS:
1583 optval = OPTBIT(IN6P_HOPOPTS);
1586 case IPV6_RECVDSTOPTS:
1587 optval = OPTBIT(IN6P_DSTOPTS);
1590 case IPV6_RECVRTHDRDSTOPTS:
1591 optval = OPTBIT(IN6P_RTHDRDSTOPTS);
1594 case IPV6_RECVPKTINFO:
1595 optval = OPTBIT(IN6P_PKTINFO);
1598 case IPV6_RECVHOPLIMIT:
1599 optval = OPTBIT(IN6P_HOPLIMIT);
1602 case IPV6_RECVRTHDR:
1603 optval = OPTBIT(IN6P_RTHDR);
1606 case IPV6_RECVPATHMTU:
1607 optval = OPTBIT(IN6P_MTU);
1610 case IPV6_RECVTCLASS:
1611 optval = OPTBIT(IN6P_TCLASS);
1614 case IPV6_AUTOFLOWLABEL:
1615 optval = OPTBIT(IN6P_AUTOFLOWLABEL);
1619 case IPV6_UNICAST_HOPS:
1620 optval = in6p->in6p_hops;
1627 case IPV6_PORTRANGE:
1630 flags = in6p->in6p_flags;
1631 if (flags & IN6P_HIGHPORT)
1632 optval = IPV6_PORTRANGE_HIGH;
1633 else if (flags & IN6P_LOWPORT)
1634 optval = IPV6_PORTRANGE_LOW;
1640 soopt_from_kbuf(sopt, &optval,
1647 struct ip6_mtuinfo mtuinfo;
1648 struct route_in6 sro;
1650 bzero(&sro, sizeof(sro));
1652 if (!(so->so_state & SS_ISCONNECTED))
1655 * XXX: we dot not consider the case of source
1656 * routing, or optional information to specify
1657 * the outgoing interface.
1659 error = ip6_getpmtu(&sro, NULL, NULL,
1660 &in6p->in6p_faddr, &pmtu, NULL);
1665 if (pmtu > IPV6_MAXPACKET)
1666 pmtu = IPV6_MAXPACKET;
1668 bzero(&mtuinfo, sizeof(mtuinfo));
1669 mtuinfo.ip6m_mtu = (u_int32_t)pmtu;
1670 optdata = (void *)&mtuinfo;
1671 optdatalen = sizeof(mtuinfo);
1672 soopt_from_kbuf(sopt, optdata,
1677 case IPV6_2292PKTINFO:
1678 case IPV6_2292HOPLIMIT:
1679 case IPV6_2292HOPOPTS:
1680 case IPV6_2292RTHDR:
1681 case IPV6_2292DSTOPTS:
1682 if (optname == IPV6_2292HOPOPTS ||
1683 optname == IPV6_2292DSTOPTS ||
1687 case IPV6_2292PKTINFO:
1688 optval = OPTBIT(IN6P_PKTINFO);
1690 case IPV6_2292HOPLIMIT:
1691 optval = OPTBIT(IN6P_HOPLIMIT);
1693 case IPV6_2292HOPOPTS:
1696 optval = OPTBIT(IN6P_HOPOPTS);
1698 case IPV6_2292RTHDR:
1699 optval = OPTBIT(IN6P_RTHDR);
1701 case IPV6_2292DSTOPTS:
1704 optval = OPTBIT(IN6P_DSTOPTS|IN6P_RTHDRDSTOPTS);
1707 soopt_from_kbuf(sopt, &optval,
1715 case IPV6_RTHDRDSTOPTS:
1719 case IPV6_USE_MIN_MTU:
1720 case IPV6_PREFER_TEMPADDR:
1721 error = ip6_getpcbopt(in6p->in6p_outputopts,
1725 case IPV6_MULTICAST_IF:
1726 case IPV6_MULTICAST_HOPS:
1727 case IPV6_MULTICAST_LOOP:
1728 case IPV6_JOIN_GROUP:
1729 case IPV6_LEAVE_GROUP:
1732 error = ip6_getmoptions(sopt->sopt_name,
1733 in6p->in6p_moptions, &m);
1735 soopt_from_kbuf(sopt,
1736 mtod(m, char *), m->m_len);
1745 struct mbuf **mp = &m;
1747 if (ip6_fw_ctl_ptr == NULL)
1751 error = (*ip6_fw_ctl_ptr)(optname, mp);
1753 error = soopt_from_mbuf(sopt, m); /* XXX */
1754 if (error == 0 && m != NULL)
1760 error = ENOPROTOOPT;
1772 ip6_raw_ctloutput(struct socket *so, struct sockopt *sopt)
1774 int error = 0, optval, optlen;
1775 const int icmp6off = offsetof(struct icmp6_hdr, icmp6_cksum);
1776 struct in6pcb *in6p = sotoin6pcb(so);
1777 int level, op, optname;
1780 level = sopt->sopt_level;
1781 op = sopt->sopt_dir;
1782 optname = sopt->sopt_name;
1783 optlen = sopt->sopt_valsize;
1785 panic("ip6_raw_ctloutput: arg soopt is NULL");
1787 if (level != IPPROTO_IPV6) {
1794 * For ICMPv6 sockets, no modification allowed for checksum
1795 * offset, permit "no change" values to help existing apps.
1797 * RFC3542 says: "An attempt to set IPV6_CHECKSUM
1798 * for an ICMPv6 socket will fail."
1799 * The current behavior does not meet RFC3542.
1803 if (optlen != sizeof(int)) {
1807 error = soopt_to_kbuf(sopt, &optval,
1808 sizeof optval, sizeof optval);
1811 if ((optval % 2) != 0) {
1812 /* the API assumes even offset values */
1814 } else if (so->so_proto->pr_protocol ==
1816 if (optval != icmp6off)
1819 in6p->in6p_cksum = optval;
1823 if (so->so_proto->pr_protocol == IPPROTO_ICMPV6)
1826 optval = in6p->in6p_cksum;
1828 soopt_from_kbuf(sopt, &optval, sizeof(optval));
1838 error = ENOPROTOOPT;
1846 * Set up IP6 options in pcb for insertion in output packets or
1847 * specifying behavior of outgoing packets.
1850 ip6_pcbopts(struct ip6_pktopts **pktopt, struct mbuf *m,
1851 struct socket *so, struct sockopt *sopt)
1854 struct ip6_pktopts *opt = *pktopt;
1857 /* turn off any old options. */
1860 if (opt->ip6po_pktinfo || opt->ip6po_nexthop ||
1861 opt->ip6po_hbh || opt->ip6po_dest1 || opt->ip6po_dest2 ||
1862 opt->ip6po_rhinfo.ip6po_rhi_rthdr)
1863 kprintf("ip6_pcbopts: all specified options are cleared.\n");
1865 ip6_clearpktopts(opt, -1);
1867 opt = kmalloc(sizeof(*opt), M_IP6OPT, M_WAITOK);
1870 if (!m || m->m_len == 0) {
1872 * Only turning off any previous options, regardless of
1873 * whether the opt is just created or given.
1875 kfree(opt, M_IP6OPT);
1879 /* set options specified by user. */
1880 if ((error = ip6_setpktoptions(m, opt, NULL, so->so_proto->pr_protocol, priv)) != 0) {
1881 ip6_clearpktopts(opt, -1); /* XXX: discard all options */
1882 kfree(opt, M_IP6OPT);
1891 * Below three functions are introduced by merge to RFC3542
1895 ip6_getpcbopt(struct ip6_pktopts *pktopt, int optname, struct sockopt *sopt)
1897 void *optdata = NULL;
1899 struct ip6_ext *ip6e;
1901 struct in6_pktinfo null_pktinfo;
1902 int deftclass = 0, on;
1903 int defminmtu = IP6PO_MINMTU_MCASTONLY;
1904 int defpreftemp = IP6PO_TEMPADDR_SYSTEM;
1908 if (pktopt && pktopt->ip6po_pktinfo)
1909 optdata = (void *)pktopt->ip6po_pktinfo;
1911 /* XXX: we don't have to do this every time... */
1912 bzero(&null_pktinfo, sizeof(null_pktinfo));
1913 optdata = (void *)&null_pktinfo;
1915 optdatalen = sizeof(struct in6_pktinfo);
1918 if (pktopt && pktopt->ip6po_tclass >= 0)
1919 optdata = (void *)&pktopt->ip6po_tclass;
1921 optdata = (void *)&deftclass;
1922 optdatalen = sizeof(int);
1925 if (pktopt && pktopt->ip6po_hbh) {
1926 optdata = (void *)pktopt->ip6po_hbh;
1927 ip6e = (struct ip6_ext *)pktopt->ip6po_hbh;
1928 optdatalen = (ip6e->ip6e_len + 1) << 3;
1932 if (pktopt && pktopt->ip6po_rthdr) {
1933 optdata = (void *)pktopt->ip6po_rthdr;
1934 ip6e = (struct ip6_ext *)pktopt->ip6po_rthdr;
1935 optdatalen = (ip6e->ip6e_len + 1) << 3;
1938 case IPV6_RTHDRDSTOPTS:
1939 if (pktopt && pktopt->ip6po_dest1) {
1940 optdata = (void *)pktopt->ip6po_dest1;
1941 ip6e = (struct ip6_ext *)pktopt->ip6po_dest1;
1942 optdatalen = (ip6e->ip6e_len + 1) << 3;
1946 if (pktopt && pktopt->ip6po_dest2) {
1947 optdata = (void *)pktopt->ip6po_dest2;
1948 ip6e = (struct ip6_ext *)pktopt->ip6po_dest2;
1949 optdatalen = (ip6e->ip6e_len + 1) << 3;
1953 if (pktopt && pktopt->ip6po_nexthop) {
1954 optdata = (void *)pktopt->ip6po_nexthop;
1955 optdatalen = pktopt->ip6po_nexthop->sa_len;
1958 case IPV6_USE_MIN_MTU:
1960 optdata = (void *)&pktopt->ip6po_minmtu;
1962 optdata = (void *)&defminmtu;
1963 optdatalen = sizeof(int);
1966 if (pktopt && ((pktopt->ip6po_flags) & IP6PO_DONTFRAG))
1970 optdata = (void *)&on;
1971 optdatalen = sizeof(on);
1973 case IPV6_PREFER_TEMPADDR:
1975 optdata = (void *)&pktopt->ip6po_prefer_tempaddr;
1977 optdata = (void *)&defpreftemp;
1978 optdatalen = sizeof(int);
1980 default: /* should not happen */
1982 panic("ip6_getpcbopt: unexpected option");
1984 return (ENOPROTOOPT);
1987 soopt_from_kbuf(sopt, optdata, optdatalen);
1993 * initialize ip6_pktopts. beware that there are non-zero default values in
1998 ip6_pcbopt(int optname, u_char *buf, int len, struct ip6_pktopts **pktopt, int uproto)
2000 struct ip6_pktopts *opt;
2002 if (*pktopt == NULL) {
2003 *pktopt = kmalloc(sizeof(*opt), M_IP6OPT, M_WAITOK);
2004 init_ip6pktopts(*pktopt);
2008 return (ip6_setpktoption(optname, buf, len, opt, 1, 0, uproto, priv));
2012 * initialize ip6_pktopts. beware that there are non-zero default values in
2016 init_ip6pktopts(struct ip6_pktopts *opt)
2019 bzero(opt, sizeof(*opt));
2020 opt->ip6po_hlim = -1; /* -1 means default hop limit */
2021 opt->ip6po_tclass = -1; /* -1 means default traffic class */
2022 opt->ip6po_minmtu = IP6PO_MINMTU_MCASTONLY;
2023 opt->ip6po_prefer_tempaddr = IP6PO_TEMPADDR_SYSTEM;
2027 ip6_clearpktopts(struct ip6_pktopts *pktopt, int optname)
2032 if (optname == -1 || optname == IPV6_PKTINFO) {
2033 if (pktopt->ip6po_pktinfo)
2034 kfree(pktopt->ip6po_pktinfo, M_IP6OPT);
2035 pktopt->ip6po_pktinfo = NULL;
2037 if (optname == -1 || optname == IPV6_HOPLIMIT)
2038 pktopt->ip6po_hlim = -1;
2039 if (optname == -1 || optname == IPV6_TCLASS)
2040 pktopt->ip6po_tclass = -1;
2041 if (optname == -1 || optname == IPV6_NEXTHOP) {
2042 if (pktopt->ip6po_nextroute.ro_rt) {
2043 RTFREE(pktopt->ip6po_nextroute.ro_rt);
2044 pktopt->ip6po_nextroute.ro_rt = NULL;
2046 if (pktopt->ip6po_nexthop)
2047 kfree(pktopt->ip6po_nexthop, M_IP6OPT);
2048 pktopt->ip6po_nexthop = NULL;
2050 if (optname == -1 || optname == IPV6_HOPOPTS) {
2051 if (pktopt->ip6po_hbh)
2052 kfree(pktopt->ip6po_hbh, M_IP6OPT);
2053 pktopt->ip6po_hbh = NULL;
2055 if (optname == -1 || optname == IPV6_RTHDRDSTOPTS) {
2056 if (pktopt->ip6po_dest1)
2057 kfree(pktopt->ip6po_dest1, M_IP6OPT);
2058 pktopt->ip6po_dest1 = NULL;
2060 if (optname == -1 || optname == IPV6_RTHDR) {
2061 if (pktopt->ip6po_rhinfo.ip6po_rhi_rthdr)
2062 kfree(pktopt->ip6po_rhinfo.ip6po_rhi_rthdr, M_IP6OPT);
2063 pktopt->ip6po_rhinfo.ip6po_rhi_rthdr = NULL;
2064 if (pktopt->ip6po_route.ro_rt) {
2065 RTFREE(pktopt->ip6po_route.ro_rt);
2066 pktopt->ip6po_route.ro_rt = NULL;
2069 if (optname == -1 || optname == IPV6_DSTOPTS) {
2070 if (pktopt->ip6po_dest2)
2071 kfree(pktopt->ip6po_dest2, M_IP6OPT);
2072 pktopt->ip6po_dest2 = NULL;
2076 #define PKTOPT_EXTHDRCPY(type) \
2079 int hlen = (((struct ip6_ext *)src->type)->ip6e_len + 1) << 3;\
2080 dst->type = kmalloc(hlen, M_IP6OPT, canwait);\
2081 if (dst->type == NULL)\
2083 bcopy(src->type, dst->type, hlen);\
2087 struct ip6_pktopts *
2088 ip6_copypktopts(struct ip6_pktopts *src, int canwait)
2090 struct ip6_pktopts *dst;
2093 kprintf("ip6_clearpktopts: invalid argument\n");
2097 dst = kmalloc(sizeof(*dst), M_IP6OPT, canwait | M_ZERO);
2101 dst->ip6po_hlim = src->ip6po_hlim;
2102 if (src->ip6po_pktinfo) {
2103 dst->ip6po_pktinfo = kmalloc(sizeof(*dst->ip6po_pktinfo),
2105 if (dst->ip6po_pktinfo == NULL)
2107 *dst->ip6po_pktinfo = *src->ip6po_pktinfo;
2109 if (src->ip6po_nexthop) {
2110 dst->ip6po_nexthop = kmalloc(src->ip6po_nexthop->sa_len,
2112 if (dst->ip6po_nexthop == NULL)
2114 bcopy(src->ip6po_nexthop, dst->ip6po_nexthop,
2115 src->ip6po_nexthop->sa_len);
2117 PKTOPT_EXTHDRCPY(ip6po_hbh);
2118 PKTOPT_EXTHDRCPY(ip6po_dest1);
2119 PKTOPT_EXTHDRCPY(ip6po_dest2);
2120 PKTOPT_EXTHDRCPY(ip6po_rthdr); /* not copy the cached route */
2124 if (dst->ip6po_pktinfo) kfree(dst->ip6po_pktinfo, M_IP6OPT);
2125 if (dst->ip6po_nexthop) kfree(dst->ip6po_nexthop, M_IP6OPT);
2126 if (dst->ip6po_hbh) kfree(dst->ip6po_hbh, M_IP6OPT);
2127 if (dst->ip6po_dest1) kfree(dst->ip6po_dest1, M_IP6OPT);
2128 if (dst->ip6po_dest2) kfree(dst->ip6po_dest2, M_IP6OPT);
2129 if (dst->ip6po_rthdr) kfree(dst->ip6po_rthdr, M_IP6OPT);
2130 kfree(dst, M_IP6OPT);
2135 copypktopts(struct ip6_pktopts *dst, struct ip6_pktopts *src, int canwait)
2137 if (dst == NULL || src == NULL) {
2139 kprintf("ip6_clearpktopts: invalid argument\n");
2144 dst->ip6po_hlim = src->ip6po_hlim;
2145 dst->ip6po_tclass = src->ip6po_tclass;
2146 dst->ip6po_flags = src->ip6po_flags;
2147 if (src->ip6po_pktinfo) {
2148 dst->ip6po_pktinfo = kmalloc(sizeof(*dst->ip6po_pktinfo),
2150 if (dst->ip6po_pktinfo == NULL)
2152 *dst->ip6po_pktinfo = *src->ip6po_pktinfo;
2154 if (src->ip6po_nexthop) {
2155 dst->ip6po_nexthop = kmalloc(src->ip6po_nexthop->sa_len,
2157 if (dst->ip6po_nexthop == NULL)
2159 bcopy(src->ip6po_nexthop, dst->ip6po_nexthop,
2160 src->ip6po_nexthop->sa_len);
2162 PKTOPT_EXTHDRCPY(ip6po_hbh);
2163 PKTOPT_EXTHDRCPY(ip6po_dest1);
2164 PKTOPT_EXTHDRCPY(ip6po_dest2);
2165 PKTOPT_EXTHDRCPY(ip6po_rthdr); /* not copy the cached route */
2169 ip6_clearpktopts(dst, -1);
2172 #undef PKTOPT_EXTHDRCPY
2175 ip6_freepcbopts(struct ip6_pktopts *pktopt)
2180 ip6_clearpktopts(pktopt, -1);
2182 kfree(pktopt, M_IP6OPT);
2186 * Set the IP6 multicast options in response to user setsockopt().
2189 ip6_setmoptions(int optname, struct ip6_moptions **im6op, struct mbuf *m)
2192 u_int loop, ifindex;
2193 struct ipv6_mreq *mreq;
2195 struct ip6_moptions *im6o = *im6op;
2196 struct route_in6 ro;
2197 struct sockaddr_in6 *dst;
2198 struct in6_multi_mship *imm;
2199 struct thread *td = curthread;
2203 * No multicast option buffer attached to the pcb;
2204 * allocate one and initialize to default values.
2206 im6o = (struct ip6_moptions *)
2207 kmalloc(sizeof(*im6o), M_IPMOPTS, M_WAITOK);
2210 im6o->im6o_multicast_ifp = NULL;
2211 im6o->im6o_multicast_hlim = ip6_defmcasthlim;
2212 im6o->im6o_multicast_loop = IPV6_DEFAULT_MULTICAST_LOOP;
2213 LIST_INIT(&im6o->im6o_memberships);
2218 case IPV6_MULTICAST_IF:
2220 * Select the interface for outgoing multicast packets.
2222 if (m == NULL || m->m_len != sizeof(u_int)) {
2226 bcopy(mtod(m, u_int *), &ifindex, sizeof(ifindex));
2227 if (ifindex < 0 || if_index < ifindex) {
2228 error = ENXIO; /* XXX EINVAL? */
2231 ifp = ifindex2ifnet[ifindex];
2232 if (ifp == NULL || !(ifp->if_flags & IFF_MULTICAST)) {
2233 error = EADDRNOTAVAIL;
2236 im6o->im6o_multicast_ifp = ifp;
2239 case IPV6_MULTICAST_HOPS:
2242 * Set the IP6 hoplimit for outgoing multicast packets.
2245 if (m == NULL || m->m_len != sizeof(int)) {
2249 bcopy(mtod(m, u_int *), &optval, sizeof(optval));
2250 if (optval < -1 || optval >= 256)
2252 else if (optval == -1)
2253 im6o->im6o_multicast_hlim = ip6_defmcasthlim;
2255 im6o->im6o_multicast_hlim = optval;
2259 case IPV6_MULTICAST_LOOP:
2261 * Set the loopback flag for outgoing multicast packets.
2262 * Must be zero or one.
2264 if (m == NULL || m->m_len != sizeof(u_int)) {
2268 bcopy(mtod(m, u_int *), &loop, sizeof(loop));
2273 im6o->im6o_multicast_loop = loop;
2276 case IPV6_JOIN_GROUP:
2278 * Add a multicast group membership.
2279 * Group must be a valid IP6 multicast address.
2281 if (m == NULL || m->m_len != sizeof(struct ipv6_mreq)) {
2285 mreq = mtod(m, struct ipv6_mreq *);
2286 if (IN6_IS_ADDR_UNSPECIFIED(&mreq->ipv6mr_multiaddr)) {
2288 * We use the unspecified address to specify to accept
2289 * all multicast addresses. Only super user is allowed
2292 if (priv_check(td, PRIV_ROOT)) {
2296 } else if (!IN6_IS_ADDR_MULTICAST(&mreq->ipv6mr_multiaddr)) {
2302 * If the interface is specified, validate it.
2304 if (mreq->ipv6mr_interface < 0
2305 || if_index < mreq->ipv6mr_interface) {
2306 error = ENXIO; /* XXX EINVAL? */
2310 * If no interface was explicitly specified, choose an
2311 * appropriate one according to the given multicast address.
2313 if (mreq->ipv6mr_interface == 0) {
2315 * If the multicast address is in node-local scope,
2316 * the interface should be a loopback interface.
2317 * Otherwise, look up the routing table for the
2318 * address, and choose the outgoing interface.
2319 * XXX: is it a good approach?
2321 if (IN6_IS_ADDR_MC_INTFACELOCAL(&mreq->ipv6mr_multiaddr)) {
2325 dst = (struct sockaddr_in6 *)&ro.ro_dst;
2326 bzero(dst, sizeof(*dst));
2327 dst->sin6_len = sizeof(struct sockaddr_in6);
2328 dst->sin6_family = AF_INET6;
2329 dst->sin6_addr = mreq->ipv6mr_multiaddr;
2330 rtalloc((struct route *)&ro);
2331 if (ro.ro_rt == NULL) {
2332 error = EADDRNOTAVAIL;
2335 ifp = ro.ro_rt->rt_ifp;
2339 ifp = ifindex2ifnet[mreq->ipv6mr_interface];
2342 * See if we found an interface, and confirm that it
2343 * supports multicast
2345 if (ifp == NULL || !(ifp->if_flags & IFF_MULTICAST)) {
2346 error = EADDRNOTAVAIL;
2350 * Put interface index into the multicast address,
2351 * if the address has link-local scope.
2353 if (IN6_IS_ADDR_MC_LINKLOCAL(&mreq->ipv6mr_multiaddr)) {
2354 mreq->ipv6mr_multiaddr.s6_addr16[1]
2355 = htons(mreq->ipv6mr_interface);
2358 * See if the membership already exists.
2360 for (imm = im6o->im6o_memberships.lh_first;
2361 imm != NULL; imm = imm->i6mm_chain.le_next)
2362 if (imm->i6mm_maddr->in6m_ifp == ifp &&
2363 IN6_ARE_ADDR_EQUAL(&imm->i6mm_maddr->in6m_addr,
2364 &mreq->ipv6mr_multiaddr))
2371 * Everything looks good; add a new record to the multicast
2372 * address list for the given interface.
2374 imm = kmalloc(sizeof(*imm), M_IPMADDR, M_WAITOK);
2375 if ((imm->i6mm_maddr =
2376 in6_addmulti(&mreq->ipv6mr_multiaddr, ifp, &error)) == NULL) {
2377 kfree(imm, M_IPMADDR);
2380 LIST_INSERT_HEAD(&im6o->im6o_memberships, imm, i6mm_chain);
2383 case IPV6_LEAVE_GROUP:
2385 * Drop a multicast group membership.
2386 * Group must be a valid IP6 multicast address.
2388 if (m == NULL || m->m_len != sizeof(struct ipv6_mreq)) {
2392 mreq = mtod(m, struct ipv6_mreq *);
2393 if (IN6_IS_ADDR_UNSPECIFIED(&mreq->ipv6mr_multiaddr)) {
2394 if (priv_check(td, PRIV_ROOT)) {
2398 } else if (!IN6_IS_ADDR_MULTICAST(&mreq->ipv6mr_multiaddr)) {
2403 * If an interface address was specified, get a pointer
2404 * to its ifnet structure.
2406 if (mreq->ipv6mr_interface < 0
2407 || if_index < mreq->ipv6mr_interface) {
2408 error = ENXIO; /* XXX EINVAL? */
2411 ifp = ifindex2ifnet[mreq->ipv6mr_interface];
2413 * Put interface index into the multicast address,
2414 * if the address has link-local scope.
2416 if (IN6_IS_ADDR_MC_LINKLOCAL(&mreq->ipv6mr_multiaddr)) {
2417 mreq->ipv6mr_multiaddr.s6_addr16[1]
2418 = htons(mreq->ipv6mr_interface);
2422 * Find the membership in the membership list.
2424 for (imm = im6o->im6o_memberships.lh_first;
2425 imm != NULL; imm = imm->i6mm_chain.le_next) {
2426 if ((ifp == NULL || imm->i6mm_maddr->in6m_ifp == ifp) &&
2427 IN6_ARE_ADDR_EQUAL(&imm->i6mm_maddr->in6m_addr,
2428 &mreq->ipv6mr_multiaddr))
2432 /* Unable to resolve interface */
2433 error = EADDRNOTAVAIL;
2437 * Give up the multicast address record to which the
2438 * membership points.
2440 LIST_REMOVE(imm, i6mm_chain);
2441 in6_delmulti(imm->i6mm_maddr);
2442 kfree(imm, M_IPMADDR);
2451 * If all options have default values, no need to keep the mbuf.
2453 if (im6o->im6o_multicast_ifp == NULL &&
2454 im6o->im6o_multicast_hlim == ip6_defmcasthlim &&
2455 im6o->im6o_multicast_loop == IPV6_DEFAULT_MULTICAST_LOOP &&
2456 im6o->im6o_memberships.lh_first == NULL) {
2457 kfree(*im6op, M_IPMOPTS);
2465 * Return the IP6 multicast options in response to user getsockopt().
2468 ip6_getmoptions(int optname, struct ip6_moptions *im6o, struct mbuf **mp)
2470 u_int *hlim, *loop, *ifindex;
2472 *mp = m_get(M_WAITOK, MT_HEADER); /* XXX */
2476 case IPV6_MULTICAST_IF:
2477 ifindex = mtod(*mp, u_int *);
2478 (*mp)->m_len = sizeof(u_int);
2479 if (im6o == NULL || im6o->im6o_multicast_ifp == NULL)
2482 *ifindex = im6o->im6o_multicast_ifp->if_index;
2485 case IPV6_MULTICAST_HOPS:
2486 hlim = mtod(*mp, u_int *);
2487 (*mp)->m_len = sizeof(u_int);
2489 *hlim = ip6_defmcasthlim;
2491 *hlim = im6o->im6o_multicast_hlim;
2494 case IPV6_MULTICAST_LOOP:
2495 loop = mtod(*mp, u_int *);
2496 (*mp)->m_len = sizeof(u_int);
2498 *loop = ip6_defmcasthlim;
2500 *loop = im6o->im6o_multicast_loop;
2504 return (EOPNOTSUPP);
2509 * Discard the IP6 multicast options.
2512 ip6_freemoptions(struct ip6_moptions *im6o)
2514 struct in6_multi_mship *imm;
2519 while ((imm = im6o->im6o_memberships.lh_first) != NULL) {
2520 LIST_REMOVE(imm, i6mm_chain);
2521 if (imm->i6mm_maddr)
2522 in6_delmulti(imm->i6mm_maddr);
2523 kfree(imm, M_IPMADDR);
2525 kfree(im6o, M_IPMOPTS);
2529 * Set a particular packet option, as a sticky option or an ancillary data
2530 * item. "len" can be 0 only when it's a sticky option.
2531 * We have 4 cases of combination of "sticky" and "cmsg":
2532 * "sticky=0, cmsg=0": impossible
2533 * "sticky=0, cmsg=1": RFC2292 or RFC3542 ancillary data
2534 * "sticky=1, cmsg=0": RFC3542 socket option
2535 * "sticky=1, cmsg=1": RFC2292 socket option
2538 ip6_setpktoption(int optname, u_char *buf, int len, struct ip6_pktopts *opt,
2539 int sticky, int cmsg, int uproto, int priv)
2541 int minmtupolicy, preftemp;
2544 if (!sticky && !cmsg) {
2545 kprintf("ip6_setpktoption: impossible case\n");
2550 * IPV6_2292xxx is for backward compatibility to RFC2292, and should
2551 * not be specified in the context of RFC3542. Conversely,
2552 * RFC3542 types should not be specified in the context of RFC2292.
2556 case IPV6_2292PKTINFO:
2557 case IPV6_2292HOPLIMIT:
2558 case IPV6_2292NEXTHOP:
2559 case IPV6_2292HOPOPTS:
2560 case IPV6_2292DSTOPTS:
2561 case IPV6_2292RTHDR:
2562 case IPV6_2292PKTOPTIONS:
2563 return (ENOPROTOOPT);
2566 if (sticky && cmsg) {
2573 case IPV6_RTHDRDSTOPTS:
2575 case IPV6_USE_MIN_MTU:
2578 case IPV6_PREFER_TEMPADDR: /* XXX: not an RFC3542 option */
2579 return (ENOPROTOOPT);
2584 case IPV6_2292PKTINFO:
2587 struct in6_pktinfo *pktinfo;
2588 if (len != sizeof(struct in6_pktinfo))
2590 pktinfo = (struct in6_pktinfo *)buf;
2593 * An application can clear any sticky IPV6_PKTINFO option by
2594 * doing a "regular" setsockopt with ipi6_addr being
2595 * in6addr_any and ipi6_ifindex being zero.
2596 * [RFC 3542, Section 6]
2598 if (optname == IPV6_PKTINFO && opt->ip6po_pktinfo &&
2599 pktinfo->ipi6_ifindex == 0 &&
2600 IN6_IS_ADDR_UNSPECIFIED(&pktinfo->ipi6_addr)) {
2601 ip6_clearpktopts(opt, optname);
2605 if (uproto == IPPROTO_TCP && optname == IPV6_PKTINFO &&
2606 sticky && !IN6_IS_ADDR_UNSPECIFIED(&pktinfo->ipi6_addr)) {
2610 /* validate the interface index if specified. */
2611 if (pktinfo->ipi6_ifindex > if_index ||
2612 pktinfo->ipi6_ifindex < 0) {
2616 * Check if the requested source address is indeed a
2617 * unicast address assigned to the node, and can be
2618 * used as the packet's source address.
2620 if (opt->ip6po_pktinfo != NULL &&
2621 !IN6_IS_ADDR_UNSPECIFIED(&opt->ip6po_pktinfo->ipi6_addr)) {
2622 struct in6_ifaddr *ia6;
2623 struct sockaddr_in6 sin6;
2625 bzero(&sin6, sizeof(sin6));
2626 sin6.sin6_len = sizeof(sin6);
2627 sin6.sin6_family = AF_INET6;
2629 opt->ip6po_pktinfo->ipi6_addr;
2630 ia6 = (struct in6_ifaddr *)ifa_ifwithaddr(sin6tosa(&sin6));
2632 (ia6->ia6_flags & (IN6_IFF_ANYCAST |
2633 IN6_IFF_NOTREADY)) != 0)
2634 return (EADDRNOTAVAIL);
2638 * We store the address anyway, and let in6_selectsrc()
2639 * validate the specified address. This is because ipi6_addr
2640 * may not have enough information about its scope zone, and
2641 * we may need additional information (such as outgoing
2642 * interface or the scope zone of a destination address) to
2643 * disambiguate the scope.
2644 * XXX: the delay of the validation may confuse the
2645 * application when it is used as a sticky option.
2647 if (opt->ip6po_pktinfo == NULL) {
2648 opt->ip6po_pktinfo = kmalloc(sizeof(*pktinfo),
2649 M_IP6OPT, M_NOWAIT);
2650 if (opt->ip6po_pktinfo == NULL)
2653 bcopy(pktinfo, opt->ip6po_pktinfo, sizeof(*pktinfo));
2657 case IPV6_2292HOPLIMIT:
2663 * RFC 3542 deprecated the usage of sticky IPV6_HOPLIMIT
2664 * to simplify the ordering among hoplimit options.
2666 if (optname == IPV6_HOPLIMIT && sticky)
2667 return (ENOPROTOOPT);
2669 if (len != sizeof(int))
2672 if (*hlimp < -1 || *hlimp > 255)
2675 opt->ip6po_hlim = *hlimp;
2683 if (len != sizeof(int))
2685 tclass = *(int *)buf;
2686 if (tclass < -1 || tclass > 255)
2689 opt->ip6po_tclass = tclass;
2693 case IPV6_2292NEXTHOP:
2698 if (len == 0) { /* just remove the option */
2699 ip6_clearpktopts(opt, IPV6_NEXTHOP);
2703 /* check if cmsg_len is large enough for sa_len */
2704 if (len < sizeof(struct sockaddr) || len < *buf)
2707 switch (((struct sockaddr *)buf)->sa_family) {
2710 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)buf;
2713 if (sa6->sin6_len != sizeof(struct sockaddr_in6))
2716 if (IN6_IS_ADDR_UNSPECIFIED(&sa6->sin6_addr) ||
2717 IN6_IS_ADDR_MULTICAST(&sa6->sin6_addr)) {
2722 case AF_LINK: /* should eventually be supported */
2724 return (EAFNOSUPPORT);
2727 /* turn off the previous option, then set the new option. */
2728 ip6_clearpktopts(opt, IPV6_NEXTHOP);
2729 opt->ip6po_nexthop = kmalloc(*buf, M_IP6OPT, M_NOWAIT);
2730 if (opt->ip6po_nexthop == NULL)
2732 bcopy(buf, opt->ip6po_nexthop, *buf);
2735 case IPV6_2292HOPOPTS:
2738 struct ip6_hbh *hbh;
2742 * XXX: We don't allow a non-privileged user to set ANY HbH
2743 * options, since per-option restriction has too much
2749 ip6_clearpktopts(opt, IPV6_HOPOPTS);
2750 break; /* just remove the option */
2753 /* message length validation */
2754 if (len < sizeof(struct ip6_hbh))
2756 hbh = (struct ip6_hbh *)buf;
2757 hbhlen = (hbh->ip6h_len + 1) << 3;
2761 /* turn off the previous option, then set the new option. */
2762 ip6_clearpktopts(opt, IPV6_HOPOPTS);
2763 opt->ip6po_hbh = kmalloc(hbhlen, M_IP6OPT, M_NOWAIT);
2764 if (opt->ip6po_hbh == NULL)
2766 bcopy(hbh, opt->ip6po_hbh, hbhlen);
2771 case IPV6_2292DSTOPTS:
2773 case IPV6_RTHDRDSTOPTS:
2775 struct ip6_dest *dest, **newdest = NULL;
2781 ip6_clearpktopts(opt, optname);
2782 break; /* just remove the option */
2785 /* message length validation */
2786 if (len < sizeof(struct ip6_dest))
2788 dest = (struct ip6_dest *)buf;
2789 destlen = (dest->ip6d_len + 1) << 3;
2794 * Determine the position that the destination options header
2795 * should be inserted; before or after the routing header.
2798 case IPV6_2292DSTOPTS:
2800 * The old advacned API is ambiguous on this point.
2801 * Our approach is to determine the position based
2802 * according to the existence of a routing header.
2803 * Note, however, that this depends on the order of the
2804 * extension headers in the ancillary data; the 1st
2805 * part of the destination options header must appear
2806 * before the routing header in the ancillary data,
2808 * RFC3542 solved the ambiguity by introducing
2809 * separate ancillary data or option types.
2811 if (opt->ip6po_rthdr == NULL)
2812 newdest = &opt->ip6po_dest1;
2814 newdest = &opt->ip6po_dest2;
2816 case IPV6_RTHDRDSTOPTS:
2817 newdest = &opt->ip6po_dest1;
2820 newdest = &opt->ip6po_dest2;
2824 /* turn off the previous option, then set the new option. */
2825 ip6_clearpktopts(opt, optname);
2826 *newdest = kmalloc(destlen, M_IP6OPT, M_NOWAIT);
2827 if (*newdest == NULL)
2829 bcopy(dest, *newdest, destlen);
2834 case IPV6_2292RTHDR:
2837 struct ip6_rthdr *rth;
2841 ip6_clearpktopts(opt, IPV6_RTHDR);
2842 break; /* just remove the option */
2845 /* message length validation */
2846 if (len < sizeof(struct ip6_rthdr))
2848 rth = (struct ip6_rthdr *)buf;
2849 rthlen = (rth->ip6r_len + 1) << 3;
2853 switch (rth->ip6r_type) {
2855 return (EINVAL); /* not supported */
2858 /* turn off the previous option */
2859 ip6_clearpktopts(opt, IPV6_RTHDR);
2860 opt->ip6po_rthdr = kmalloc(rthlen, M_IP6OPT, M_NOWAIT);
2861 if (opt->ip6po_rthdr == NULL)
2863 bcopy(rth, opt->ip6po_rthdr, rthlen);
2868 case IPV6_USE_MIN_MTU:
2869 if (len != sizeof(int))
2871 minmtupolicy = *(int *)buf;
2872 if (minmtupolicy != IP6PO_MINMTU_MCASTONLY &&
2873 minmtupolicy != IP6PO_MINMTU_DISABLE &&
2874 minmtupolicy != IP6PO_MINMTU_ALL) {
2877 opt->ip6po_minmtu = minmtupolicy;
2881 if (len != sizeof(int))
2884 if (uproto == IPPROTO_TCP || *(int *)buf == 0) {
2886 * we ignore this option for TCP sockets.
2887 * (RFC3542 leaves this case unspecified.)
2889 opt->ip6po_flags &= ~IP6PO_DONTFRAG;
2891 opt->ip6po_flags |= IP6PO_DONTFRAG;
2894 case IPV6_PREFER_TEMPADDR:
2895 if (len != sizeof(int))
2897 preftemp = *(int *)buf;
2898 if (preftemp != IP6PO_TEMPADDR_SYSTEM &&
2899 preftemp != IP6PO_TEMPADDR_NOTPREFER &&
2900 preftemp != IP6PO_TEMPADDR_PREFER) {
2903 opt->ip6po_prefer_tempaddr = preftemp;
2907 return (ENOPROTOOPT);
2908 } /* end of switch */
2915 * Set IPv6 outgoing packet options based on advanced API.
2918 ip6_setpktoptions(struct mbuf *control, struct ip6_pktopts *opt,
2919 struct ip6_pktopts *stickyopt, int uproto, int priv)
2921 struct cmsghdr *cm = NULL;
2923 if (control == NULL || opt == NULL)
2926 init_ip6pktopts(opt);
2929 * XXX: Currently, we assume all the optional information is stored
2936 * If stickyopt is provided, make a local copy of the options
2937 * for this particular packet, then override them by ancillary
2939 * XXX: copypktopts() does not copy the cached route to a next
2940 * hop (if any). This is not very good in terms of efficiency,
2941 * but we can allow this since this option should be rarely
2944 if ((error = copypktopts(opt, stickyopt, M_NOWAIT)) != 0)
2949 * XXX: Currently, we assume all the optional information is stored
2952 if (control->m_next)
2958 if (control->m_len == 0)
2960 if (control->m_len < sizeof(*cm))
2963 cm = mtod(control, struct cmsghdr *);
2964 if (cm->cmsg_len == 0 || cm->cmsg_len > control->m_len)
2966 if (cm->cmsg_level == IPPROTO_IPV6) {
2967 error = ip6_setpktoption(cm->cmsg_type, CMSG_DATA(cm),
2968 cm->cmsg_len - CMSG_LEN(0),
2969 opt, 0, 1, uproto, priv);
2975 * The cmsg fit, but the aligned step for the next one might
2976 * not. Check the case and terminate normally (allows the
2977 * cmsg_len to not be aligned).
2979 if (CMSG_ALIGN(cm->cmsg_len) >= control->m_len) {
2980 control->m_data += control->m_len;
2984 control->m_data += CMSG_ALIGN(cm->cmsg_len);
2985 control->m_len -= CMSG_ALIGN(cm->cmsg_len);
2992 * Routine called from ip6_output() to loop back a copy of an IP6 multicast
2993 * packet to the input queue of a specified interface. Note that this
2994 * calls the output routine of the loopback "driver", but with an interface
2995 * pointer that might NOT be loif -- easier than replicating that code here.
2998 ip6_mloopback(struct ifnet *ifp, struct mbuf *m, struct sockaddr_in6 *dst)
3001 struct ip6_hdr *ip6;
3003 copym = m_copy(m, 0, M_COPYALL);
3008 * Make sure to deep-copy IPv6 header portion in case the data
3009 * is in an mbuf cluster, so that we can safely override the IPv6
3010 * header portion later.
3012 if ((copym->m_flags & M_EXT) != 0 ||
3013 copym->m_len < sizeof(struct ip6_hdr)) {
3014 copym = m_pullup(copym, sizeof(struct ip6_hdr));
3020 if (copym->m_len < sizeof(*ip6)) {
3026 ip6 = mtod(copym, struct ip6_hdr *);
3028 * clear embedded scope identifiers if necessary.
3029 * in6_clearscope will touch the addresses only when necessary.
3031 in6_clearscope(&ip6->ip6_src);
3032 in6_clearscope(&ip6->ip6_dst);
3034 if_simloop(ifp, copym, dst->sin6_family, 0);
3038 * Separate the IPv6 header from the payload into its own mbuf.
3040 * Returns the new mbuf chain or the original mbuf if no payload.
3041 * Returns NULL if can't allocate new mbuf for header.
3043 static struct mbuf *
3044 ip6_splithdr(struct mbuf *m)
3048 if (m->m_len <= sizeof(struct ip6_hdr)) /* no payload */
3051 MGETHDR(mh, M_NOWAIT, MT_HEADER);
3054 mh->m_len = sizeof(struct ip6_hdr);
3055 M_MOVE_PKTHDR(mh, m);
3056 MH_ALIGN(mh, sizeof(struct ip6_hdr));
3057 bcopy(mtod(m, caddr_t), mtod(mh, caddr_t), sizeof(struct ip6_hdr));
3058 m->m_data += sizeof(struct ip6_hdr);
3059 m->m_len -= sizeof(struct ip6_hdr);
3065 * Compute IPv6 extension header length.
3068 ip6_optlen(struct in6pcb *in6p)
3072 if (!in6p->in6p_outputopts)
3077 (((struct ip6_ext *)(x)) ? (((struct ip6_ext *)(x))->ip6e_len + 1) << 3 : 0)
3079 len += elen(in6p->in6p_outputopts->ip6po_hbh);
3080 if (in6p->in6p_outputopts->ip6po_rthdr)
3081 /* dest1 is valid with rthdr only */
3082 len += elen(in6p->in6p_outputopts->ip6po_dest1);
3083 len += elen(in6p->in6p_outputopts->ip6po_rthdr);
3084 len += elen(in6p->in6p_outputopts->ip6po_dest2);