1686cdd19SJun-ichiro itojun Hagino /* $FreeBSD$ */ 288ff5695SSUZUKI Shinsuke /* $KAME: ip6_output.c,v 1.279 2002/01/26 06:12:30 jinmei Exp $ */ 3686cdd19SJun-ichiro itojun Hagino 4caf43b02SWarner Losh /*- 582cd038dSYoshinobu Inoue * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. 682cd038dSYoshinobu Inoue * All rights reserved. 782cd038dSYoshinobu Inoue * 882cd038dSYoshinobu Inoue * Redistribution and use in source and binary forms, with or without 982cd038dSYoshinobu Inoue * modification, are permitted provided that the following conditions 1082cd038dSYoshinobu Inoue * are met: 1182cd038dSYoshinobu Inoue * 1. Redistributions of source code must retain the above copyright 1282cd038dSYoshinobu Inoue * notice, this list of conditions and the following disclaimer. 1382cd038dSYoshinobu Inoue * 2. Redistributions in binary form must reproduce the above copyright 1482cd038dSYoshinobu Inoue * notice, this list of conditions and the following disclaimer in the 1582cd038dSYoshinobu Inoue * documentation and/or other materials provided with the distribution. 1682cd038dSYoshinobu Inoue * 3. Neither the name of the project nor the names of its contributors 1782cd038dSYoshinobu Inoue * may be used to endorse or promote products derived from this software 1882cd038dSYoshinobu Inoue * without specific prior written permission. 1982cd038dSYoshinobu Inoue * 2082cd038dSYoshinobu Inoue * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 2182cd038dSYoshinobu Inoue * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 2282cd038dSYoshinobu Inoue * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 2382cd038dSYoshinobu Inoue * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 2482cd038dSYoshinobu Inoue * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2582cd038dSYoshinobu Inoue * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2682cd038dSYoshinobu Inoue * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2782cd038dSYoshinobu Inoue * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2882cd038dSYoshinobu Inoue * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2982cd038dSYoshinobu Inoue * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 3082cd038dSYoshinobu Inoue * SUCH DAMAGE. 3182cd038dSYoshinobu Inoue */ 3282cd038dSYoshinobu Inoue 33caf43b02SWarner Losh /*- 3482cd038dSYoshinobu Inoue * Copyright (c) 1982, 1986, 1988, 1990, 1993 3582cd038dSYoshinobu Inoue * The Regents of the University of California. All rights reserved. 3682cd038dSYoshinobu Inoue * 3782cd038dSYoshinobu Inoue * Redistribution and use in source and binary forms, with or without 3882cd038dSYoshinobu Inoue * modification, are permitted provided that the following conditions 3982cd038dSYoshinobu Inoue * are met: 4082cd038dSYoshinobu Inoue * 1. Redistributions of source code must retain the above copyright 4182cd038dSYoshinobu Inoue * notice, this list of conditions and the following disclaimer. 4282cd038dSYoshinobu Inoue * 2. Redistributions in binary form must reproduce the above copyright 4382cd038dSYoshinobu Inoue * notice, this list of conditions and the following disclaimer in the 4482cd038dSYoshinobu Inoue * documentation and/or other materials provided with the distribution. 4582cd038dSYoshinobu Inoue * 4. Neither the name of the University nor the names of its contributors 4682cd038dSYoshinobu Inoue * may be used to endorse or promote products derived from this software 4782cd038dSYoshinobu Inoue * without specific prior written permission. 4882cd038dSYoshinobu Inoue * 4982cd038dSYoshinobu Inoue * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 5082cd038dSYoshinobu Inoue * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 5182cd038dSYoshinobu Inoue * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 5282cd038dSYoshinobu Inoue * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 5382cd038dSYoshinobu Inoue * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 5482cd038dSYoshinobu Inoue * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 5582cd038dSYoshinobu Inoue * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 5682cd038dSYoshinobu Inoue * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 5782cd038dSYoshinobu Inoue * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 5882cd038dSYoshinobu Inoue * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 5982cd038dSYoshinobu Inoue * SUCH DAMAGE. 6082cd038dSYoshinobu Inoue * 6182cd038dSYoshinobu Inoue * @(#)ip_output.c 8.3 (Berkeley) 1/21/94 6282cd038dSYoshinobu Inoue */ 6382cd038dSYoshinobu Inoue 64686cdd19SJun-ichiro itojun Hagino #include "opt_inet.h" 65686cdd19SJun-ichiro itojun Hagino #include "opt_inet6.h" 66686cdd19SJun-ichiro itojun Hagino #include "opt_ipsec.h" 6782cd038dSYoshinobu Inoue 6882cd038dSYoshinobu Inoue #include <sys/param.h> 6982cd038dSYoshinobu Inoue #include <sys/malloc.h> 7082cd038dSYoshinobu Inoue #include <sys/mbuf.h> 71b40ce416SJulian Elischer #include <sys/proc.h> 7282cd038dSYoshinobu Inoue #include <sys/errno.h> 73c2259ba4SRobert Watson #include <sys/priv.h> 7482cd038dSYoshinobu Inoue #include <sys/protosw.h> 7582cd038dSYoshinobu Inoue #include <sys/socket.h> 7682cd038dSYoshinobu Inoue #include <sys/socketvar.h> 7782cd038dSYoshinobu Inoue #include <sys/kernel.h> 7882cd038dSYoshinobu Inoue 7982cd038dSYoshinobu Inoue #include <net/if.h> 808195404bSBrooks Davis #include <net/netisr.h> 8182cd038dSYoshinobu Inoue #include <net/route.h> 82c4ac87eaSDarren Reed #include <net/pfil.h> 8382cd038dSYoshinobu Inoue 8482cd038dSYoshinobu Inoue #include <netinet/in.h> 8582cd038dSYoshinobu Inoue #include <netinet/in_var.h> 8633841545SHajimu UMEMOTO #include <netinet6/in6_var.h> 87686cdd19SJun-ichiro itojun Hagino #include <netinet/ip6.h> 88686cdd19SJun-ichiro itojun Hagino #include <netinet/icmp6.h> 8982cd038dSYoshinobu Inoue #include <netinet6/ip6_var.h> 90686cdd19SJun-ichiro itojun Hagino #include <netinet/in_pcb.h> 9197d8d152SAndre Oppermann #include <netinet/tcp_var.h> 9282cd038dSYoshinobu Inoue #include <netinet6/nd6.h> 9382cd038dSYoshinobu Inoue 94b2630c29SGeorge V. Neville-Neil #ifdef IPSEC 95b9234fafSSam Leffler #include <netipsec/ipsec.h> 96b9234fafSSam Leffler #include <netipsec/ipsec6.h> 97b9234fafSSam Leffler #include <netipsec/key.h> 982cb64cb2SGeorge V. Neville-Neil #include <netinet6/ip6_ipsec.h> 99b2630c29SGeorge V. Neville-Neil #endif /* IPSEC */ 100b9234fafSSam Leffler 1011469c434SHajimu UMEMOTO #include <netinet6/ip6protosw.h> 102a1f7e5f8SHajimu UMEMOTO #include <netinet6/scope6_var.h> 1031469c434SHajimu UMEMOTO 1047ba26d99SDavid E. O'Brien static MALLOC_DEFINE(M_IP6MOPTS, "ip6_moptions", "internet multicast options"); 10582cd038dSYoshinobu Inoue 10682cd038dSYoshinobu Inoue struct ip6_exthdrs { 10782cd038dSYoshinobu Inoue struct mbuf *ip6e_ip6; 10882cd038dSYoshinobu Inoue struct mbuf *ip6e_hbh; 10982cd038dSYoshinobu Inoue struct mbuf *ip6e_dest1; 11082cd038dSYoshinobu Inoue struct mbuf *ip6e_rthdr; 11182cd038dSYoshinobu Inoue struct mbuf *ip6e_dest2; 11282cd038dSYoshinobu Inoue }; 11382cd038dSYoshinobu Inoue 114f95d4633SHajimu UMEMOTO static int ip6_pcbopt __P((int, u_char *, int, struct ip6_pktopts **, 115f95d4633SHajimu UMEMOTO int, int)); 11682cd038dSYoshinobu Inoue static int ip6_pcbopts __P((struct ip6_pktopts **, struct mbuf *, 1177efe5d92SHajimu UMEMOTO struct socket *, struct sockopt *)); 118f95d4633SHajimu UMEMOTO static int ip6_getpcbopt __P((struct ip6_pktopts *, int, struct sockopt *)); 119d5e3406dSHajimu UMEMOTO static int ip6_setpktopt __P((int, u_char *, int, struct ip6_pktopts *, int, 120f95d4633SHajimu UMEMOTO int, int, int)); 121f95d4633SHajimu UMEMOTO 12282cd038dSYoshinobu Inoue static int ip6_setmoptions __P((int, struct ip6_moptions **, struct mbuf *)); 12382cd038dSYoshinobu Inoue static int ip6_getmoptions __P((int, struct ip6_moptions *, struct mbuf **)); 12482cd038dSYoshinobu Inoue static int ip6_copyexthdr __P((struct mbuf **, caddr_t, int)); 12582cd038dSYoshinobu Inoue static int ip6_insertfraghdr __P((struct mbuf *, struct mbuf *, int, 12682cd038dSYoshinobu Inoue struct ip6_frag **)); 12782cd038dSYoshinobu Inoue static int ip6_insert_jumboopt __P((struct ip6_exthdrs *, u_int32_t)); 12882cd038dSYoshinobu Inoue static int ip6_splithdr __P((struct mbuf *, struct ip6_exthdrs *)); 12931b3783cSHajimu UMEMOTO static int ip6_getpmtu __P((struct route_in6 *, struct route_in6 *, 130f95d4633SHajimu UMEMOTO struct ifnet *, struct in6_addr *, u_long *, int *)); 131885adbfaSHajimu UMEMOTO static int copypktopts __P((struct ip6_pktopts *, struct ip6_pktopts *, int)); 13282cd038dSYoshinobu Inoue 1337efe5d92SHajimu UMEMOTO 13482cd038dSYoshinobu Inoue /* 1352cb64cb2SGeorge V. Neville-Neil * Make an extension header from option data. hp is the source, and 1362cb64cb2SGeorge V. Neville-Neil * mp is the destination. 1372cb64cb2SGeorge V. Neville-Neil */ 1382cb64cb2SGeorge V. Neville-Neil #define MAKE_EXTHDR(hp, mp) \ 1392cb64cb2SGeorge V. Neville-Neil do { \ 1402cb64cb2SGeorge V. Neville-Neil if (hp) { \ 1412cb64cb2SGeorge V. Neville-Neil struct ip6_ext *eh = (struct ip6_ext *)(hp); \ 1422cb64cb2SGeorge V. Neville-Neil error = ip6_copyexthdr((mp), (caddr_t)(hp), \ 1432cb64cb2SGeorge V. Neville-Neil ((eh)->ip6e_len + 1) << 3); \ 1442cb64cb2SGeorge V. Neville-Neil if (error) \ 1452cb64cb2SGeorge V. Neville-Neil goto freehdrs; \ 1462cb64cb2SGeorge V. Neville-Neil } \ 1472cb64cb2SGeorge V. Neville-Neil } while (/*CONSTCOND*/ 0) 1482cb64cb2SGeorge V. Neville-Neil 1492cb64cb2SGeorge V. Neville-Neil /* 1502cb64cb2SGeorge V. Neville-Neil * Form a chain of extension headers. 1512cb64cb2SGeorge V. Neville-Neil * m is the extension header mbuf 1522cb64cb2SGeorge V. Neville-Neil * mp is the previous mbuf in the chain 1532cb64cb2SGeorge V. Neville-Neil * p is the next header 1542cb64cb2SGeorge V. Neville-Neil * i is the type of option. 1552cb64cb2SGeorge V. Neville-Neil */ 1562cb64cb2SGeorge V. Neville-Neil #define MAKE_CHAIN(m, mp, p, i)\ 1572cb64cb2SGeorge V. Neville-Neil do {\ 1582cb64cb2SGeorge V. Neville-Neil if (m) {\ 1592cb64cb2SGeorge V. Neville-Neil if (!hdrsplit) \ 1602cb64cb2SGeorge V. Neville-Neil panic("assumption failed: hdr not split"); \ 1612cb64cb2SGeorge V. Neville-Neil *mtod((m), u_char *) = *(p);\ 1622cb64cb2SGeorge V. Neville-Neil *(p) = (i);\ 1632cb64cb2SGeorge V. Neville-Neil p = mtod((m), u_char *);\ 1642cb64cb2SGeorge V. Neville-Neil (m)->m_next = (mp)->m_next;\ 1652cb64cb2SGeorge V. Neville-Neil (mp)->m_next = (m);\ 1662cb64cb2SGeorge V. Neville-Neil (mp) = (m);\ 1672cb64cb2SGeorge V. Neville-Neil }\ 1682cb64cb2SGeorge V. Neville-Neil } while (/*CONSTCOND*/ 0) 1692cb64cb2SGeorge V. Neville-Neil 1702cb64cb2SGeorge V. Neville-Neil /* 17182cd038dSYoshinobu Inoue * IP6 output. The packet in mbuf chain m contains a skeletal IP6 17282cd038dSYoshinobu Inoue * header (with pri, len, nxt, hlim, src, dst). 17382cd038dSYoshinobu Inoue * This function may modify ver and hlim only. 17482cd038dSYoshinobu Inoue * The mbuf chain containing the packet will be freed. 17582cd038dSYoshinobu Inoue * The mbuf opt, if present, will not be freed. 17633841545SHajimu UMEMOTO * 17733841545SHajimu UMEMOTO * type of "mtu": rt_rmx.rmx_mtu is u_long, ifnet.ifr_mtu is int, and 17833841545SHajimu UMEMOTO * nd_ifinfo.linkmtu is u_int32_t. so we use u_long to hold largest one, 17933841545SHajimu UMEMOTO * which is rt_rmx.rmx_mtu. 1801272577eSXin LI * 1811272577eSXin LI * ifpp - XXX: just for statistics 18282cd038dSYoshinobu Inoue */ 18382cd038dSYoshinobu Inoue int 1841272577eSXin LI ip6_output(struct mbuf *m0, struct ip6_pktopts *opt, 1851272577eSXin LI struct route_in6 *ro, int flags, struct ip6_moptions *im6o, 1861272577eSXin LI struct ifnet **ifpp, struct inpcb *inp) 18782cd038dSYoshinobu Inoue { 18882cd038dSYoshinobu Inoue struct ip6_hdr *ip6, *mhip6; 189686cdd19SJun-ichiro itojun Hagino struct ifnet *ifp, *origifp; 19082cd038dSYoshinobu Inoue struct mbuf *m = m0; 1912cb64cb2SGeorge V. Neville-Neil struct mbuf *mprev = NULL; 19282cd038dSYoshinobu Inoue int hlen, tlen, len, off; 19382cd038dSYoshinobu Inoue struct route_in6 ip6route; 194a1f7e5f8SHajimu UMEMOTO struct rtentry *rt = NULL; 195a1f7e5f8SHajimu UMEMOTO struct sockaddr_in6 *dst, src_sa, dst_sa; 1968195404bSBrooks Davis struct in6_addr odst; 19782cd038dSYoshinobu Inoue int error = 0; 1985da9f8faSJosef Karthauser struct in6_ifaddr *ia = NULL; 19982cd038dSYoshinobu Inoue u_long mtu; 200f95d4633SHajimu UMEMOTO int alwaysfrag, dontfrag; 20182cd038dSYoshinobu Inoue u_int32_t optlen = 0, plen = 0, unfragpartlen = 0; 20282cd038dSYoshinobu Inoue struct ip6_exthdrs exthdrs; 203a1f7e5f8SHajimu UMEMOTO struct in6_addr finaldst, src0, dst0; 204a1f7e5f8SHajimu UMEMOTO u_int32_t zone; 20582cd038dSYoshinobu Inoue struct route_in6 *ro_pmtu = NULL; 20682cd038dSYoshinobu Inoue int hdrsplit = 0; 20782cd038dSYoshinobu Inoue int needipsec = 0; 208b2630c29SGeorge V. Neville-Neil #ifdef IPSEC 2092cb64cb2SGeorge V. Neville-Neil struct ipsec_output_state state; 2102cb64cb2SGeorge V. Neville-Neil struct ip6_rthdr *rh = NULL; 211b9234fafSSam Leffler int needipsectun = 0; 2122cb64cb2SGeorge V. Neville-Neil int segleft_org = 0; 213b9234fafSSam Leffler struct secpolicy *sp = NULL; 214b2630c29SGeorge V. Neville-Neil #endif /* IPSEC */ 215b9234fafSSam Leffler 216b9234fafSSam Leffler ip6 = mtod(m, struct ip6_hdr *); 2172cb64cb2SGeorge V. Neville-Neil if (ip6 == NULL) { 2182cb64cb2SGeorge V. Neville-Neil printf ("ip6 is NULL"); 2192cb64cb2SGeorge V. Neville-Neil goto bad; 2202cb64cb2SGeorge V. Neville-Neil } 22182cd038dSYoshinobu Inoue 2222cb64cb2SGeorge V. Neville-Neil finaldst = ip6->ip6_dst; 22382cd038dSYoshinobu Inoue 22482cd038dSYoshinobu Inoue bzero(&exthdrs, sizeof(exthdrs)); 225686cdd19SJun-ichiro itojun Hagino 22682cd038dSYoshinobu Inoue if (opt) { 22782cd038dSYoshinobu Inoue /* Hop-by-Hop options header */ 22882cd038dSYoshinobu Inoue MAKE_EXTHDR(opt->ip6po_hbh, &exthdrs.ip6e_hbh); 22982cd038dSYoshinobu Inoue /* Destination options header(1st part) */ 23029bc2c48SHajimu UMEMOTO if (opt->ip6po_rthdr) { 23129bc2c48SHajimu UMEMOTO /* 23229bc2c48SHajimu UMEMOTO * Destination options header(1st part) 2332cb64cb2SGeorge V. Neville-Neil * This only makes sense with a routing header. 23429bc2c48SHajimu UMEMOTO * See Section 9.2 of RFC 3542. 23529bc2c48SHajimu UMEMOTO * Disabling this part just for MIP6 convenience is 23629bc2c48SHajimu UMEMOTO * a bad idea. We need to think carefully about a 23729bc2c48SHajimu UMEMOTO * way to make the advanced API coexist with MIP6 23829bc2c48SHajimu UMEMOTO * options, which might automatically be inserted in 23929bc2c48SHajimu UMEMOTO * the kernel. 24029bc2c48SHajimu UMEMOTO */ 24182cd038dSYoshinobu Inoue MAKE_EXTHDR(opt->ip6po_dest1, &exthdrs.ip6e_dest1); 24229bc2c48SHajimu UMEMOTO } 24382cd038dSYoshinobu Inoue /* Routing header */ 24482cd038dSYoshinobu Inoue MAKE_EXTHDR(opt->ip6po_rthdr, &exthdrs.ip6e_rthdr); 24582cd038dSYoshinobu Inoue /* Destination options header(2nd part) */ 24682cd038dSYoshinobu Inoue MAKE_EXTHDR(opt->ip6po_dest2, &exthdrs.ip6e_dest2); 24782cd038dSYoshinobu Inoue } 24882cd038dSYoshinobu Inoue 24982cd038dSYoshinobu Inoue /* 2502cb64cb2SGeorge V. Neville-Neil * IPSec checking which handles several cases. 2512cb64cb2SGeorge V. Neville-Neil * FAST IPSEC: We re-injected the packet. 25282cd038dSYoshinobu Inoue */ 253b2630c29SGeorge V. Neville-Neil #ifdef IPSEC 2542cb64cb2SGeorge V. Neville-Neil switch(ip6_ipsec_output(&m, inp, &flags, &error, &ifp, &sp)) 2552cb64cb2SGeorge V. Neville-Neil { 2562cb64cb2SGeorge V. Neville-Neil case 1: /* Bad packet */ 257b9234fafSSam Leffler goto freehdrs; 2582cb64cb2SGeorge V. Neville-Neil case -1: /* Do IPSec */ 259b9234fafSSam Leffler needipsec = 1; 2602cb64cb2SGeorge V. Neville-Neil case 0: /* No IPSec */ 261b9234fafSSam Leffler default: 2622cb64cb2SGeorge V. Neville-Neil break; 263b9234fafSSam Leffler } 264b2630c29SGeorge V. Neville-Neil #endif /* IPSEC */ 26582cd038dSYoshinobu Inoue 26682cd038dSYoshinobu Inoue /* 26782cd038dSYoshinobu Inoue * Calculate the total length of the extension header chain. 26882cd038dSYoshinobu Inoue * Keep the length of the unfragmentable part for fragmentation. 26982cd038dSYoshinobu Inoue */ 27082cd038dSYoshinobu Inoue optlen = 0; 2712cb64cb2SGeorge V. Neville-Neil if (exthdrs.ip6e_hbh) 2722cb64cb2SGeorge V. Neville-Neil optlen += exthdrs.ip6e_hbh->m_len; 2732cb64cb2SGeorge V. Neville-Neil if (exthdrs.ip6e_dest1) 2742cb64cb2SGeorge V. Neville-Neil optlen += exthdrs.ip6e_dest1->m_len; 2752cb64cb2SGeorge V. Neville-Neil if (exthdrs.ip6e_rthdr) 2762cb64cb2SGeorge V. Neville-Neil optlen += exthdrs.ip6e_rthdr->m_len; 27782cd038dSYoshinobu Inoue unfragpartlen = optlen + sizeof(struct ip6_hdr); 2782cb64cb2SGeorge V. Neville-Neil 27982cd038dSYoshinobu Inoue /* NOTE: we don't add AH/ESP length here. do that later. */ 2802cb64cb2SGeorge V. Neville-Neil if (exthdrs.ip6e_dest2) 2812cb64cb2SGeorge V. Neville-Neil optlen += exthdrs.ip6e_dest2->m_len; 28282cd038dSYoshinobu Inoue 28382cd038dSYoshinobu Inoue /* 28482cd038dSYoshinobu Inoue * If we need IPsec, or there is at least one extension header, 28582cd038dSYoshinobu Inoue * separate IP6 header from the payload. 28682cd038dSYoshinobu Inoue */ 28782cd038dSYoshinobu Inoue if ((needipsec || optlen) && !hdrsplit) { 28882cd038dSYoshinobu Inoue if ((error = ip6_splithdr(m, &exthdrs)) != 0) { 28982cd038dSYoshinobu Inoue m = NULL; 29082cd038dSYoshinobu Inoue goto freehdrs; 29182cd038dSYoshinobu Inoue } 29282cd038dSYoshinobu Inoue m = exthdrs.ip6e_ip6; 29382cd038dSYoshinobu Inoue hdrsplit++; 29482cd038dSYoshinobu Inoue } 29582cd038dSYoshinobu Inoue 29682cd038dSYoshinobu Inoue /* adjust pointer */ 29782cd038dSYoshinobu Inoue ip6 = mtod(m, struct ip6_hdr *); 29882cd038dSYoshinobu Inoue 29982cd038dSYoshinobu Inoue /* adjust mbuf packet header length */ 30082cd038dSYoshinobu Inoue m->m_pkthdr.len += optlen; 30182cd038dSYoshinobu Inoue plen = m->m_pkthdr.len - sizeof(*ip6); 30282cd038dSYoshinobu Inoue 30382cd038dSYoshinobu Inoue /* If this is a jumbo payload, insert a jumbo payload option. */ 30482cd038dSYoshinobu Inoue if (plen > IPV6_MAXPACKET) { 30582cd038dSYoshinobu Inoue if (!hdrsplit) { 30682cd038dSYoshinobu Inoue if ((error = ip6_splithdr(m, &exthdrs)) != 0) { 30782cd038dSYoshinobu Inoue m = NULL; 30882cd038dSYoshinobu Inoue goto freehdrs; 30982cd038dSYoshinobu Inoue } 31082cd038dSYoshinobu Inoue m = exthdrs.ip6e_ip6; 31182cd038dSYoshinobu Inoue hdrsplit++; 31282cd038dSYoshinobu Inoue } 31382cd038dSYoshinobu Inoue /* adjust pointer */ 31482cd038dSYoshinobu Inoue ip6 = mtod(m, struct ip6_hdr *); 31582cd038dSYoshinobu Inoue if ((error = ip6_insert_jumboopt(&exthdrs, plen)) != 0) 31682cd038dSYoshinobu Inoue goto freehdrs; 31782cd038dSYoshinobu Inoue ip6->ip6_plen = 0; 31882cd038dSYoshinobu Inoue } else 31982cd038dSYoshinobu Inoue ip6->ip6_plen = htons(plen); 32082cd038dSYoshinobu Inoue 32182cd038dSYoshinobu Inoue /* 32282cd038dSYoshinobu Inoue * Concatenate headers and fill in next header fields. 32382cd038dSYoshinobu Inoue * Here we have, on "m" 32482cd038dSYoshinobu Inoue * IPv6 payload 32582cd038dSYoshinobu Inoue * and we insert headers accordingly. Finally, we should be getting: 32682cd038dSYoshinobu Inoue * IPv6 hbh dest1 rthdr ah* [esp* dest2 payload] 32782cd038dSYoshinobu Inoue * 32882cd038dSYoshinobu Inoue * during the header composing process, "m" points to IPv6 header. 32982cd038dSYoshinobu Inoue * "mprev" points to an extension header prior to esp. 33082cd038dSYoshinobu Inoue */ 33182cd038dSYoshinobu Inoue u_char *nexthdrp = &ip6->ip6_nxt; 3322cb64cb2SGeorge V. Neville-Neil mprev = m; 33382cd038dSYoshinobu Inoue 33482cd038dSYoshinobu Inoue /* 33582cd038dSYoshinobu Inoue * we treat dest2 specially. this makes IPsec processing 33688ff5695SSUZUKI Shinsuke * much easier. the goal here is to make mprev point the 33788ff5695SSUZUKI Shinsuke * mbuf prior to dest2. 33882cd038dSYoshinobu Inoue * 33982cd038dSYoshinobu Inoue * result: IPv6 dest2 payload 34082cd038dSYoshinobu Inoue * m and mprev will point to IPv6 header. 34182cd038dSYoshinobu Inoue */ 34282cd038dSYoshinobu Inoue if (exthdrs.ip6e_dest2) { 34382cd038dSYoshinobu Inoue if (!hdrsplit) 34482cd038dSYoshinobu Inoue panic("assumption failed: hdr not split"); 34582cd038dSYoshinobu Inoue exthdrs.ip6e_dest2->m_next = m->m_next; 34682cd038dSYoshinobu Inoue m->m_next = exthdrs.ip6e_dest2; 34782cd038dSYoshinobu Inoue *mtod(exthdrs.ip6e_dest2, u_char *) = ip6->ip6_nxt; 34882cd038dSYoshinobu Inoue ip6->ip6_nxt = IPPROTO_DSTOPTS; 34982cd038dSYoshinobu Inoue } 35082cd038dSYoshinobu Inoue 35182cd038dSYoshinobu Inoue /* 35282cd038dSYoshinobu Inoue * result: IPv6 hbh dest1 rthdr dest2 payload 35382cd038dSYoshinobu Inoue * m will point to IPv6 header. mprev will point to the 35482cd038dSYoshinobu Inoue * extension header prior to dest2 (rthdr in the above case). 35582cd038dSYoshinobu Inoue */ 3567efe5d92SHajimu UMEMOTO MAKE_CHAIN(exthdrs.ip6e_hbh, mprev, nexthdrp, IPPROTO_HOPOPTS); 3577efe5d92SHajimu UMEMOTO MAKE_CHAIN(exthdrs.ip6e_dest1, mprev, nexthdrp, 3587efe5d92SHajimu UMEMOTO IPPROTO_DSTOPTS); 3597efe5d92SHajimu UMEMOTO MAKE_CHAIN(exthdrs.ip6e_rthdr, mprev, nexthdrp, 3607efe5d92SHajimu UMEMOTO IPPROTO_ROUTING); 36182cd038dSYoshinobu Inoue 362b2630c29SGeorge V. Neville-Neil #ifdef IPSEC 36382cd038dSYoshinobu Inoue if (!needipsec) 36482cd038dSYoshinobu Inoue goto skip_ipsec2; 36582cd038dSYoshinobu Inoue 36682cd038dSYoshinobu Inoue /* 36782cd038dSYoshinobu Inoue * pointers after IPsec headers are not valid any more. 36882cd038dSYoshinobu Inoue * other pointers need a great care too. 36982cd038dSYoshinobu Inoue * (IPsec routines should not mangle mbufs prior to AH/ESP) 37082cd038dSYoshinobu Inoue */ 37182cd038dSYoshinobu Inoue exthdrs.ip6e_dest2 = NULL; 37282cd038dSYoshinobu Inoue 37382cd038dSYoshinobu Inoue if (exthdrs.ip6e_rthdr) { 37482cd038dSYoshinobu Inoue rh = mtod(exthdrs.ip6e_rthdr, struct ip6_rthdr *); 37582cd038dSYoshinobu Inoue segleft_org = rh->ip6r_segleft; 37682cd038dSYoshinobu Inoue rh->ip6r_segleft = 0; 37782cd038dSYoshinobu Inoue } 37882cd038dSYoshinobu Inoue 37982cd038dSYoshinobu Inoue bzero(&state, sizeof(state)); 38082cd038dSYoshinobu Inoue state.m = m; 38182cd038dSYoshinobu Inoue error = ipsec6_output_trans(&state, nexthdrp, mprev, sp, flags, 38282cd038dSYoshinobu Inoue &needipsectun); 38382cd038dSYoshinobu Inoue m = state.m; 38482cd038dSYoshinobu Inoue if (error) { 38582cd038dSYoshinobu Inoue /* mbuf is already reclaimed in ipsec6_output_trans. */ 38682cd038dSYoshinobu Inoue m = NULL; 38782cd038dSYoshinobu Inoue switch (error) { 38882cd038dSYoshinobu Inoue case EHOSTUNREACH: 38982cd038dSYoshinobu Inoue case ENETUNREACH: 39082cd038dSYoshinobu Inoue case EMSGSIZE: 39182cd038dSYoshinobu Inoue case ENOBUFS: 39282cd038dSYoshinobu Inoue case ENOMEM: 39382cd038dSYoshinobu Inoue break; 39482cd038dSYoshinobu Inoue default: 39582cd038dSYoshinobu Inoue printf("ip6_output (ipsec): error code %d\n", error); 3967efe5d92SHajimu UMEMOTO /* FALLTHROUGH */ 39782cd038dSYoshinobu Inoue case ENOENT: 39882cd038dSYoshinobu Inoue /* don't show these error codes to the user */ 39982cd038dSYoshinobu Inoue error = 0; 40082cd038dSYoshinobu Inoue break; 40182cd038dSYoshinobu Inoue } 40282cd038dSYoshinobu Inoue goto bad; 4032cb64cb2SGeorge V. Neville-Neil } else if (!needipsectun) { 4042cb64cb2SGeorge V. Neville-Neil /* 4052cb64cb2SGeorge V. Neville-Neil * In the FAST IPSec case we have already 4062cb64cb2SGeorge V. Neville-Neil * re-injected the packet and it has been freed 4072cb64cb2SGeorge V. Neville-Neil * by the ipsec_done() function. So, just clean 4082cb64cb2SGeorge V. Neville-Neil * up after ourselves. 4092cb64cb2SGeorge V. Neville-Neil */ 4102cb64cb2SGeorge V. Neville-Neil m = NULL; 4112cb64cb2SGeorge V. Neville-Neil goto done; 41282cd038dSYoshinobu Inoue } 41382cd038dSYoshinobu Inoue if (exthdrs.ip6e_rthdr) { 41482cd038dSYoshinobu Inoue /* ah6_output doesn't modify mbuf chain */ 41582cd038dSYoshinobu Inoue rh->ip6r_segleft = segleft_org; 41682cd038dSYoshinobu Inoue } 41782cd038dSYoshinobu Inoue skip_ipsec2:; 418b2630c29SGeorge V. Neville-Neil #endif /* IPSEC */ 41982cd038dSYoshinobu Inoue 42082cd038dSYoshinobu Inoue /* 4217efe5d92SHajimu UMEMOTO * If there is a routing header, replace the destination address field 42282cd038dSYoshinobu Inoue * with the first hop of the routing header. 42382cd038dSYoshinobu Inoue */ 42482cd038dSYoshinobu Inoue if (exthdrs.ip6e_rthdr) { 42582cd038dSYoshinobu Inoue struct ip6_rthdr *rh = 42682cd038dSYoshinobu Inoue (struct ip6_rthdr *)(mtod(exthdrs.ip6e_rthdr, 42782cd038dSYoshinobu Inoue struct ip6_rthdr *)); 42882cd038dSYoshinobu Inoue struct ip6_rthdr0 *rh0; 429a1f7e5f8SHajimu UMEMOTO struct in6_addr *addr; 430a1f7e5f8SHajimu UMEMOTO struct sockaddr_in6 sa; 43182cd038dSYoshinobu Inoue 43282cd038dSYoshinobu Inoue switch (rh->ip6r_type) { 43382cd038dSYoshinobu Inoue case IPV6_RTHDR_TYPE_0: 43482cd038dSYoshinobu Inoue rh0 = (struct ip6_rthdr0 *)rh; 435a1f7e5f8SHajimu UMEMOTO addr = (struct in6_addr *)(rh0 + 1); 436c302f5bcSHajimu UMEMOTO 437a1f7e5f8SHajimu UMEMOTO /* 438a1f7e5f8SHajimu UMEMOTO * construct a sockaddr_in6 form of 439a1f7e5f8SHajimu UMEMOTO * the first hop. 440a1f7e5f8SHajimu UMEMOTO * 441a1f7e5f8SHajimu UMEMOTO * XXX: we may not have enough 442a1f7e5f8SHajimu UMEMOTO * information about its scope zone; 443a1f7e5f8SHajimu UMEMOTO * there is no standard API to pass 444a1f7e5f8SHajimu UMEMOTO * the information from the 445a1f7e5f8SHajimu UMEMOTO * application. 446a1f7e5f8SHajimu UMEMOTO */ 447a1f7e5f8SHajimu UMEMOTO bzero(&sa, sizeof(sa)); 448a1f7e5f8SHajimu UMEMOTO sa.sin6_family = AF_INET6; 449a1f7e5f8SHajimu UMEMOTO sa.sin6_len = sizeof(sa); 450a1f7e5f8SHajimu UMEMOTO sa.sin6_addr = addr[0]; 451a1f7e5f8SHajimu UMEMOTO if ((error = sa6_embedscope(&sa, 452a1f7e5f8SHajimu UMEMOTO ip6_use_defzone)) != 0) { 453a1f7e5f8SHajimu UMEMOTO goto bad; 454a1f7e5f8SHajimu UMEMOTO } 455a1f7e5f8SHajimu UMEMOTO ip6->ip6_dst = sa.sin6_addr; 456a1f7e5f8SHajimu UMEMOTO bcopy(&addr[1], &addr[0], sizeof(struct in6_addr) 457a1f7e5f8SHajimu UMEMOTO * (rh0->ip6r0_segleft - 1)); 458a1f7e5f8SHajimu UMEMOTO addr[rh0->ip6r0_segleft - 1] = finaldst; 459a1f7e5f8SHajimu UMEMOTO /* XXX */ 460a1f7e5f8SHajimu UMEMOTO in6_clearscope(addr + rh0->ip6r0_segleft - 1); 46182cd038dSYoshinobu Inoue break; 46282cd038dSYoshinobu Inoue default: /* is it possible? */ 46382cd038dSYoshinobu Inoue error = EINVAL; 46482cd038dSYoshinobu Inoue goto bad; 46582cd038dSYoshinobu Inoue } 46682cd038dSYoshinobu Inoue } 46782cd038dSYoshinobu Inoue 46882cd038dSYoshinobu Inoue /* Source address validation */ 46982cd038dSYoshinobu Inoue if (IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src) && 4704ecbe331SSUZUKI Shinsuke (flags & IPV6_UNSPECSRC) == 0) { 47182cd038dSYoshinobu Inoue error = EOPNOTSUPP; 47282cd038dSYoshinobu Inoue ip6stat.ip6s_badscope++; 47382cd038dSYoshinobu Inoue goto bad; 47482cd038dSYoshinobu Inoue } 47582cd038dSYoshinobu Inoue if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_src)) { 47682cd038dSYoshinobu Inoue error = EOPNOTSUPP; 47782cd038dSYoshinobu Inoue ip6stat.ip6s_badscope++; 47882cd038dSYoshinobu Inoue goto bad; 47982cd038dSYoshinobu Inoue } 48082cd038dSYoshinobu Inoue 48182cd038dSYoshinobu Inoue ip6stat.ip6s_localout++; 48282cd038dSYoshinobu Inoue 48382cd038dSYoshinobu Inoue /* 48482cd038dSYoshinobu Inoue * Route packet. 48582cd038dSYoshinobu Inoue */ 48682cd038dSYoshinobu Inoue if (ro == 0) { 48782cd038dSYoshinobu Inoue ro = &ip6route; 48882cd038dSYoshinobu Inoue bzero((caddr_t)ro, sizeof(*ro)); 48982cd038dSYoshinobu Inoue } 49082cd038dSYoshinobu Inoue ro_pmtu = ro; 49182cd038dSYoshinobu Inoue if (opt && opt->ip6po_rthdr) 49282cd038dSYoshinobu Inoue ro = &opt->ip6po_route; 49382cd038dSYoshinobu Inoue dst = (struct sockaddr_in6 *)&ro->ro_dst; 4947efe5d92SHajimu UMEMOTO 4958195404bSBrooks Davis again: 49682cd038dSYoshinobu Inoue /* 497f95d4633SHajimu UMEMOTO * if specified, try to fill in the traffic class field. 498f95d4633SHajimu UMEMOTO * do not override if a non-zero value is already set. 499f95d4633SHajimu UMEMOTO * we check the diffserv field and the ecn field separately. 500f95d4633SHajimu UMEMOTO */ 501f95d4633SHajimu UMEMOTO if (opt && opt->ip6po_tclass >= 0) { 502f95d4633SHajimu UMEMOTO int mask = 0; 503f95d4633SHajimu UMEMOTO 504f95d4633SHajimu UMEMOTO if ((ip6->ip6_flow & htonl(0xfc << 20)) == 0) 505f95d4633SHajimu UMEMOTO mask |= 0xfc; 506f95d4633SHajimu UMEMOTO if ((ip6->ip6_flow & htonl(0x03 << 20)) == 0) 507f95d4633SHajimu UMEMOTO mask |= 0x03; 508f95d4633SHajimu UMEMOTO if (mask != 0) 509f95d4633SHajimu UMEMOTO ip6->ip6_flow |= htonl((opt->ip6po_tclass & mask) << 20); 510f95d4633SHajimu UMEMOTO } 511f95d4633SHajimu UMEMOTO 512f95d4633SHajimu UMEMOTO /* fill in or override the hop limit field, if necessary. */ 513f95d4633SHajimu UMEMOTO if (opt && opt->ip6po_hlim != -1) 514f95d4633SHajimu UMEMOTO ip6->ip6_hlim = opt->ip6po_hlim & 0xff; 515f95d4633SHajimu UMEMOTO else if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) { 516f95d4633SHajimu UMEMOTO if (im6o != NULL) 517f95d4633SHajimu UMEMOTO ip6->ip6_hlim = im6o->im6o_multicast_hlim; 518f95d4633SHajimu UMEMOTO else 519f95d4633SHajimu UMEMOTO ip6->ip6_hlim = ip6_defmcasthlim; 520f95d4633SHajimu UMEMOTO } 521f95d4633SHajimu UMEMOTO 522b2630c29SGeorge V. Neville-Neil #ifdef IPSEC 5232cb64cb2SGeorge V. Neville-Neil /* 524b2630c29SGeorge V. Neville-Neil * We may re-inject packets into the stack here. 5252cb64cb2SGeorge V. Neville-Neil */ 52682cd038dSYoshinobu Inoue if (needipsec && needipsectun) { 52782cd038dSYoshinobu Inoue struct ipsec_output_state state; 52882cd038dSYoshinobu Inoue 52982cd038dSYoshinobu Inoue /* 53082cd038dSYoshinobu Inoue * All the extension headers will become inaccessible 53182cd038dSYoshinobu Inoue * (since they can be encrypted). 53282cd038dSYoshinobu Inoue * Don't panic, we need no more updates to extension headers 53382cd038dSYoshinobu Inoue * on inner IPv6 packet (since they are now encapsulated). 53482cd038dSYoshinobu Inoue * 53582cd038dSYoshinobu Inoue * IPv6 [ESP|AH] IPv6 [extension headers] payload 53682cd038dSYoshinobu Inoue */ 53782cd038dSYoshinobu Inoue bzero(&exthdrs, sizeof(exthdrs)); 53882cd038dSYoshinobu Inoue exthdrs.ip6e_ip6 = m; 53982cd038dSYoshinobu Inoue 54082cd038dSYoshinobu Inoue bzero(&state, sizeof(state)); 54182cd038dSYoshinobu Inoue state.m = m; 54282cd038dSYoshinobu Inoue state.ro = (struct route *)ro; 54382cd038dSYoshinobu Inoue state.dst = (struct sockaddr *)dst; 54482cd038dSYoshinobu Inoue 54582cd038dSYoshinobu Inoue error = ipsec6_output_tunnel(&state, sp, flags); 54682cd038dSYoshinobu Inoue 54782cd038dSYoshinobu Inoue m = state.m; 54882cd038dSYoshinobu Inoue ro = (struct route_in6 *)state.ro; 54982cd038dSYoshinobu Inoue dst = (struct sockaddr_in6 *)state.dst; 55082cd038dSYoshinobu Inoue if (error) { 55182cd038dSYoshinobu Inoue /* mbuf is already reclaimed in ipsec6_output_tunnel. */ 55282cd038dSYoshinobu Inoue m0 = m = NULL; 55382cd038dSYoshinobu Inoue m = NULL; 55482cd038dSYoshinobu Inoue switch (error) { 55582cd038dSYoshinobu Inoue case EHOSTUNREACH: 55682cd038dSYoshinobu Inoue case ENETUNREACH: 55782cd038dSYoshinobu Inoue case EMSGSIZE: 55882cd038dSYoshinobu Inoue case ENOBUFS: 55982cd038dSYoshinobu Inoue case ENOMEM: 56082cd038dSYoshinobu Inoue break; 56182cd038dSYoshinobu Inoue default: 56282cd038dSYoshinobu Inoue printf("ip6_output (ipsec): error code %d\n", error); 5637efe5d92SHajimu UMEMOTO /* FALLTHROUGH */ 56482cd038dSYoshinobu Inoue case ENOENT: 56582cd038dSYoshinobu Inoue /* don't show these error codes to the user */ 56682cd038dSYoshinobu Inoue error = 0; 56782cd038dSYoshinobu Inoue break; 56882cd038dSYoshinobu Inoue } 56982cd038dSYoshinobu Inoue goto bad; 5702cb64cb2SGeorge V. Neville-Neil } else { 5712cb64cb2SGeorge V. Neville-Neil /* 5722cb64cb2SGeorge V. Neville-Neil * In the FAST IPSec case we have already 5732cb64cb2SGeorge V. Neville-Neil * re-injected the packet and it has been freed 5742cb64cb2SGeorge V. Neville-Neil * by the ipsec_done() function. So, just clean 5752cb64cb2SGeorge V. Neville-Neil * up after ourselves. 5762cb64cb2SGeorge V. Neville-Neil */ 5772cb64cb2SGeorge V. Neville-Neil m = NULL; 5782cb64cb2SGeorge V. Neville-Neil goto done; 57982cd038dSYoshinobu Inoue } 58082cd038dSYoshinobu Inoue 58182cd038dSYoshinobu Inoue exthdrs.ip6e_ip6 = m; 58282cd038dSYoshinobu Inoue } 583b2630c29SGeorge V. Neville-Neil #endif /* IPSEC */ 58482cd038dSYoshinobu Inoue 585a1f7e5f8SHajimu UMEMOTO /* adjust pointer */ 586a1f7e5f8SHajimu UMEMOTO ip6 = mtod(m, struct ip6_hdr *); 58782cd038dSYoshinobu Inoue 588a1f7e5f8SHajimu UMEMOTO bzero(&dst_sa, sizeof(dst_sa)); 589a1f7e5f8SHajimu UMEMOTO dst_sa.sin6_family = AF_INET6; 590a1f7e5f8SHajimu UMEMOTO dst_sa.sin6_len = sizeof(dst_sa); 591a1f7e5f8SHajimu UMEMOTO dst_sa.sin6_addr = ip6->ip6_dst; 592a1f7e5f8SHajimu UMEMOTO if ((error = in6_selectroute(&dst_sa, opt, im6o, ro, 593a1f7e5f8SHajimu UMEMOTO &ifp, &rt, 0)) != 0) { 594a1f7e5f8SHajimu UMEMOTO switch (error) { 595a1f7e5f8SHajimu UMEMOTO case EHOSTUNREACH: 59682cd038dSYoshinobu Inoue ip6stat.ip6s_noroute++; 597a1f7e5f8SHajimu UMEMOTO break; 598a1f7e5f8SHajimu UMEMOTO case EADDRNOTAVAIL: 599a1f7e5f8SHajimu UMEMOTO default: 600a1f7e5f8SHajimu UMEMOTO break; /* XXX statistics? */ 60182cd038dSYoshinobu Inoue } 602a1f7e5f8SHajimu UMEMOTO if (ifp != NULL) 60382cd038dSYoshinobu Inoue in6_ifstat_inc(ifp, ifs6_out_discard); 60482cd038dSYoshinobu Inoue goto bad; 60582cd038dSYoshinobu Inoue } 606a1f7e5f8SHajimu UMEMOTO if (rt == NULL) { 607a1f7e5f8SHajimu UMEMOTO /* 608a1f7e5f8SHajimu UMEMOTO * If in6_selectroute() does not return a route entry, 609a1f7e5f8SHajimu UMEMOTO * dst may not have been updated. 610a1f7e5f8SHajimu UMEMOTO */ 611a1f7e5f8SHajimu UMEMOTO *dst = dst_sa; /* XXX */ 61282cd038dSYoshinobu Inoue } 61382cd038dSYoshinobu Inoue 614a1f7e5f8SHajimu UMEMOTO /* 615a1f7e5f8SHajimu UMEMOTO * then rt (for unicast) and ifp must be non-NULL valid values. 616a1f7e5f8SHajimu UMEMOTO */ 617a1f7e5f8SHajimu UMEMOTO if ((flags & IPV6_FORWARDING) == 0) { 618a1f7e5f8SHajimu UMEMOTO /* XXX: the FORWARDING flag can be set for mrouting. */ 619a1f7e5f8SHajimu UMEMOTO in6_ifstat_inc(ifp, ifs6_out_request); 620a1f7e5f8SHajimu UMEMOTO } 621a1f7e5f8SHajimu UMEMOTO if (rt != NULL) { 622a1f7e5f8SHajimu UMEMOTO ia = (struct in6_ifaddr *)(rt->rt_ifa); 623a1f7e5f8SHajimu UMEMOTO rt->rt_use++; 624a1f7e5f8SHajimu UMEMOTO } 625a1f7e5f8SHajimu UMEMOTO 626a1f7e5f8SHajimu UMEMOTO /* 627a1f7e5f8SHajimu UMEMOTO * The outgoing interface must be in the zone of source and 628a1f7e5f8SHajimu UMEMOTO * destination addresses. We should use ia_ifp to support the 629a1f7e5f8SHajimu UMEMOTO * case of sending packets to an address of our own. 630a1f7e5f8SHajimu UMEMOTO */ 631a1f7e5f8SHajimu UMEMOTO if (ia != NULL && ia->ia_ifp) 632a1f7e5f8SHajimu UMEMOTO origifp = ia->ia_ifp; 633a1f7e5f8SHajimu UMEMOTO else 634a1f7e5f8SHajimu UMEMOTO origifp = ifp; 635a1f7e5f8SHajimu UMEMOTO 636a1f7e5f8SHajimu UMEMOTO src0 = ip6->ip6_src; 637a1f7e5f8SHajimu UMEMOTO if (in6_setscope(&src0, origifp, &zone)) 638a1f7e5f8SHajimu UMEMOTO goto badscope; 639a1f7e5f8SHajimu UMEMOTO bzero(&src_sa, sizeof(src_sa)); 640a1f7e5f8SHajimu UMEMOTO src_sa.sin6_family = AF_INET6; 641a1f7e5f8SHajimu UMEMOTO src_sa.sin6_len = sizeof(src_sa); 642a1f7e5f8SHajimu UMEMOTO src_sa.sin6_addr = ip6->ip6_src; 643a1f7e5f8SHajimu UMEMOTO if (sa6_recoverscope(&src_sa) || zone != src_sa.sin6_scope_id) 644a1f7e5f8SHajimu UMEMOTO goto badscope; 645a1f7e5f8SHajimu UMEMOTO 646a1f7e5f8SHajimu UMEMOTO dst0 = ip6->ip6_dst; 647a1f7e5f8SHajimu UMEMOTO if (in6_setscope(&dst0, origifp, &zone)) 648a1f7e5f8SHajimu UMEMOTO goto badscope; 649a1f7e5f8SHajimu UMEMOTO /* re-initialize to be sure */ 650a1f7e5f8SHajimu UMEMOTO bzero(&dst_sa, sizeof(dst_sa)); 651a1f7e5f8SHajimu UMEMOTO dst_sa.sin6_family = AF_INET6; 652a1f7e5f8SHajimu UMEMOTO dst_sa.sin6_len = sizeof(dst_sa); 653a1f7e5f8SHajimu UMEMOTO dst_sa.sin6_addr = ip6->ip6_dst; 654a1f7e5f8SHajimu UMEMOTO if (sa6_recoverscope(&dst_sa) || zone != dst_sa.sin6_scope_id) { 655a1f7e5f8SHajimu UMEMOTO goto badscope; 656a1f7e5f8SHajimu UMEMOTO } 657a1f7e5f8SHajimu UMEMOTO 658a1f7e5f8SHajimu UMEMOTO /* scope check is done. */ 659a1f7e5f8SHajimu UMEMOTO goto routefound; 660a1f7e5f8SHajimu UMEMOTO 661a1f7e5f8SHajimu UMEMOTO badscope: 662a1f7e5f8SHajimu UMEMOTO ip6stat.ip6s_badscope++; 663a1f7e5f8SHajimu UMEMOTO in6_ifstat_inc(origifp, ifs6_out_discard); 664a1f7e5f8SHajimu UMEMOTO if (error == 0) 665a1f7e5f8SHajimu UMEMOTO error = EHOSTUNREACH; /* XXX */ 666a1f7e5f8SHajimu UMEMOTO goto bad; 667a1f7e5f8SHajimu UMEMOTO 668a1f7e5f8SHajimu UMEMOTO routefound: 669a1f7e5f8SHajimu UMEMOTO if (rt && !IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) { 670a1f7e5f8SHajimu UMEMOTO if (opt && opt->ip6po_nextroute.ro_rt) { 671a1f7e5f8SHajimu UMEMOTO /* 672a1f7e5f8SHajimu UMEMOTO * The nexthop is explicitly specified by the 673a1f7e5f8SHajimu UMEMOTO * application. We assume the next hop is an IPv6 674a1f7e5f8SHajimu UMEMOTO * address. 675a1f7e5f8SHajimu UMEMOTO */ 676a1f7e5f8SHajimu UMEMOTO dst = (struct sockaddr_in6 *)opt->ip6po_nexthop; 677a1f7e5f8SHajimu UMEMOTO } 678a1f7e5f8SHajimu UMEMOTO else if ((rt->rt_flags & RTF_GATEWAY)) 679a1f7e5f8SHajimu UMEMOTO dst = (struct sockaddr_in6 *)rt->rt_gateway; 680a1f7e5f8SHajimu UMEMOTO } 681a1f7e5f8SHajimu UMEMOTO 682a1f7e5f8SHajimu UMEMOTO if (!IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) { 683a1f7e5f8SHajimu UMEMOTO m->m_flags &= ~(M_BCAST | M_MCAST); /* just in case */ 68482cd038dSYoshinobu Inoue } else { 68582cd038dSYoshinobu Inoue struct in6_multi *in6m; 68682cd038dSYoshinobu Inoue 68782cd038dSYoshinobu Inoue m->m_flags = (m->m_flags & ~M_BCAST) | M_MCAST; 68882cd038dSYoshinobu Inoue 68982cd038dSYoshinobu Inoue in6_ifstat_inc(ifp, ifs6_out_mcast); 69082cd038dSYoshinobu Inoue 69182cd038dSYoshinobu Inoue /* 69282cd038dSYoshinobu Inoue * Confirm that the outgoing interface supports multicast. 69382cd038dSYoshinobu Inoue */ 694a1f7e5f8SHajimu UMEMOTO if (!(ifp->if_flags & IFF_MULTICAST)) { 69582cd038dSYoshinobu Inoue ip6stat.ip6s_noroute++; 69682cd038dSYoshinobu Inoue in6_ifstat_inc(ifp, ifs6_out_discard); 69782cd038dSYoshinobu Inoue error = ENETUNREACH; 69882cd038dSYoshinobu Inoue goto bad; 69982cd038dSYoshinobu Inoue } 70082cd038dSYoshinobu Inoue IN6_LOOKUP_MULTI(ip6->ip6_dst, ifp, in6m); 70182cd038dSYoshinobu Inoue if (in6m != NULL && 70282cd038dSYoshinobu Inoue (im6o == NULL || im6o->im6o_multicast_loop)) { 70382cd038dSYoshinobu Inoue /* 70482cd038dSYoshinobu Inoue * If we belong to the destination multicast group 70582cd038dSYoshinobu Inoue * on the outgoing interface, and the caller did not 70682cd038dSYoshinobu Inoue * forbid loopback, loop back a copy. 70782cd038dSYoshinobu Inoue */ 70882cd038dSYoshinobu Inoue ip6_mloopback(ifp, m, dst); 70991ec0a1eSYoshinobu Inoue } else { 71091ec0a1eSYoshinobu Inoue /* 71191ec0a1eSYoshinobu Inoue * If we are acting as a multicast router, perform 71291ec0a1eSYoshinobu Inoue * multicast forwarding as if the packet had just 71391ec0a1eSYoshinobu Inoue * arrived on the interface to which we are about 71491ec0a1eSYoshinobu Inoue * to send. The multicast forwarding function 71591ec0a1eSYoshinobu Inoue * recursively calls this function, using the 71691ec0a1eSYoshinobu Inoue * IPV6_FORWARDING flag to prevent infinite recursion. 71791ec0a1eSYoshinobu Inoue * 71891ec0a1eSYoshinobu Inoue * Multicasts that are looped back by ip6_mloopback(), 71991ec0a1eSYoshinobu Inoue * above, will be forwarded by the ip6_input() routine, 72091ec0a1eSYoshinobu Inoue * if necessary. 72191ec0a1eSYoshinobu Inoue */ 72291ec0a1eSYoshinobu Inoue if (ip6_mrouter && (flags & IPV6_FORWARDING) == 0) { 723a1f7e5f8SHajimu UMEMOTO /* 724a1f7e5f8SHajimu UMEMOTO * XXX: ip6_mforward expects that rcvif is NULL 725a1f7e5f8SHajimu UMEMOTO * when it is called from the originating path. 726a1f7e5f8SHajimu UMEMOTO * However, it is not always the case, since 727a1f7e5f8SHajimu UMEMOTO * some versions of MGETHDR() does not 728a1f7e5f8SHajimu UMEMOTO * initialize the field. 729a1f7e5f8SHajimu UMEMOTO */ 730a1f7e5f8SHajimu UMEMOTO m->m_pkthdr.rcvif = NULL; 731686cdd19SJun-ichiro itojun Hagino if (ip6_mforward(ip6, ifp, m) != 0) { 73291ec0a1eSYoshinobu Inoue m_freem(m); 73391ec0a1eSYoshinobu Inoue goto done; 73491ec0a1eSYoshinobu Inoue } 73591ec0a1eSYoshinobu Inoue } 73682cd038dSYoshinobu Inoue } 73782cd038dSYoshinobu Inoue /* 73882cd038dSYoshinobu Inoue * Multicasts with a hoplimit of zero may be looped back, 73982cd038dSYoshinobu Inoue * above, but must not be transmitted on a network. 74082cd038dSYoshinobu Inoue * Also, multicasts addressed to the loopback interface 74182cd038dSYoshinobu Inoue * are not sent -- the above call to ip6_mloopback() will 74282cd038dSYoshinobu Inoue * loop back a copy if this host actually belongs to the 74382cd038dSYoshinobu Inoue * destination group on the loopback interface. 74482cd038dSYoshinobu Inoue */ 745f95d4633SHajimu UMEMOTO if (ip6->ip6_hlim == 0 || (ifp->if_flags & IFF_LOOPBACK) || 746f95d4633SHajimu UMEMOTO IN6_IS_ADDR_MC_INTFACELOCAL(&ip6->ip6_dst)) { 74782cd038dSYoshinobu Inoue m_freem(m); 74882cd038dSYoshinobu Inoue goto done; 74982cd038dSYoshinobu Inoue } 75082cd038dSYoshinobu Inoue } 75182cd038dSYoshinobu Inoue 75282cd038dSYoshinobu Inoue /* 75382cd038dSYoshinobu Inoue * Fill the outgoing inteface to tell the upper layer 75482cd038dSYoshinobu Inoue * to increment per-interface statistics. 75582cd038dSYoshinobu Inoue */ 75682cd038dSYoshinobu Inoue if (ifpp) 75782cd038dSYoshinobu Inoue *ifpp = ifp; 75882cd038dSYoshinobu Inoue 75931b3783cSHajimu UMEMOTO /* Determine path MTU. */ 760f95d4633SHajimu UMEMOTO if ((error = ip6_getpmtu(ro_pmtu, ro, ifp, &finaldst, &mtu, 761f95d4633SHajimu UMEMOTO &alwaysfrag)) != 0) 76231b3783cSHajimu UMEMOTO goto bad; 76382cd038dSYoshinobu Inoue 76433841545SHajimu UMEMOTO /* 7658b00e59dSHajimu UMEMOTO * The caller of this function may specify to use the minimum MTU 7668b00e59dSHajimu UMEMOTO * in some cases. 7678b00e59dSHajimu UMEMOTO * An advanced API option (IPV6_USE_MIN_MTU) can also override MTU 7688b00e59dSHajimu UMEMOTO * setting. The logic is a bit complicated; by default, unicast 7698b00e59dSHajimu UMEMOTO * packets will follow path MTU while multicast packets will be sent at 7708b00e59dSHajimu UMEMOTO * the minimum MTU. If IP6PO_MINMTU_ALL is specified, all packets 7718b00e59dSHajimu UMEMOTO * including unicast ones will be sent at the minimum MTU. Multicast 7728b00e59dSHajimu UMEMOTO * packets will always be sent at the minimum MTU unless 7738b00e59dSHajimu UMEMOTO * IP6PO_MINMTU_DISABLE is explicitly specified. 7748b00e59dSHajimu UMEMOTO * See RFC 3542 for more details. 77533841545SHajimu UMEMOTO */ 7768b00e59dSHajimu UMEMOTO if (mtu > IPV6_MMTU) { 7778b00e59dSHajimu UMEMOTO if ((flags & IPV6_MINMTU)) 77833841545SHajimu UMEMOTO mtu = IPV6_MMTU; 7798b00e59dSHajimu UMEMOTO else if (opt && opt->ip6po_minmtu == IP6PO_MINMTU_ALL) 7808b00e59dSHajimu UMEMOTO mtu = IPV6_MMTU; 7818b00e59dSHajimu UMEMOTO else if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) && 7828b00e59dSHajimu UMEMOTO (opt == NULL || 7838b00e59dSHajimu UMEMOTO opt->ip6po_minmtu != IP6PO_MINMTU_DISABLE)) { 7848b00e59dSHajimu UMEMOTO mtu = IPV6_MMTU; 7858b00e59dSHajimu UMEMOTO } 7868b00e59dSHajimu UMEMOTO } 78733841545SHajimu UMEMOTO 78833841545SHajimu UMEMOTO /* 78933841545SHajimu UMEMOTO * clear embedded scope identifiers if necessary. 79033841545SHajimu UMEMOTO * in6_clearscope will touch the addresses only when necessary. 79133841545SHajimu UMEMOTO */ 79233841545SHajimu UMEMOTO in6_clearscope(&ip6->ip6_src); 79333841545SHajimu UMEMOTO in6_clearscope(&ip6->ip6_dst); 79482cd038dSYoshinobu Inoue 79582cd038dSYoshinobu Inoue /* 79682cd038dSYoshinobu Inoue * If the outgoing packet contains a hop-by-hop options header, 79782cd038dSYoshinobu Inoue * it must be examined and processed even by the source node. 79882cd038dSYoshinobu Inoue * (RFC 2460, section 4.) 79982cd038dSYoshinobu Inoue */ 80082cd038dSYoshinobu Inoue if (exthdrs.ip6e_hbh) { 80133841545SHajimu UMEMOTO struct ip6_hbh *hbh = mtod(exthdrs.ip6e_hbh, struct ip6_hbh *); 802283f9f8aSHajimu UMEMOTO u_int32_t dummy; /* XXX unused */ 803283f9f8aSHajimu UMEMOTO u_int32_t plen = 0; /* XXX: ip6_process will check the value */ 80482cd038dSYoshinobu Inoue 80533841545SHajimu UMEMOTO #ifdef DIAGNOSTIC 80633841545SHajimu UMEMOTO if ((hbh->ip6h_len + 1) << 3 > exthdrs.ip6e_hbh->m_len) 80733841545SHajimu UMEMOTO panic("ip6e_hbh is not continuous"); 80833841545SHajimu UMEMOTO #endif 80982cd038dSYoshinobu Inoue /* 81082cd038dSYoshinobu Inoue * XXX: if we have to send an ICMPv6 error to the sender, 81182cd038dSYoshinobu Inoue * we need the M_LOOP flag since icmp6_error() expects 81282cd038dSYoshinobu Inoue * the IPv6 and the hop-by-hop options header are 81382cd038dSYoshinobu Inoue * continuous unless the flag is set. 81482cd038dSYoshinobu Inoue */ 81582cd038dSYoshinobu Inoue m->m_flags |= M_LOOP; 81682cd038dSYoshinobu Inoue m->m_pkthdr.rcvif = ifp; 8177efe5d92SHajimu UMEMOTO if (ip6_process_hopopts(m, (u_int8_t *)(hbh + 1), 8187efe5d92SHajimu UMEMOTO ((hbh->ip6h_len + 1) << 3) - sizeof(struct ip6_hbh), 819283f9f8aSHajimu UMEMOTO &dummy, &plen) < 0) { 82082cd038dSYoshinobu Inoue /* m was already freed at this point */ 82182cd038dSYoshinobu Inoue error = EINVAL;/* better error? */ 82282cd038dSYoshinobu Inoue goto done; 82382cd038dSYoshinobu Inoue } 82482cd038dSYoshinobu Inoue m->m_flags &= ~M_LOOP; /* XXX */ 82582cd038dSYoshinobu Inoue m->m_pkthdr.rcvif = NULL; 82682cd038dSYoshinobu Inoue } 82782cd038dSYoshinobu Inoue 828c21fd232SAndre Oppermann /* Jump over all PFIL processing if hooks are not active. */ 829604afec4SChristian S.J. Peron if (!PFIL_HOOKED(&inet6_pfil_hook)) 830c21fd232SAndre Oppermann goto passout; 831c21fd232SAndre Oppermann 8328195404bSBrooks Davis odst = ip6->ip6_dst; 833c21fd232SAndre Oppermann /* Run through list of hooks for output packets. */ 834d6a8d588SMax Laier error = pfil_run_hooks(&inet6_pfil_hook, &m, ifp, PFIL_OUT, inp); 835b140bc1fSSam Leffler if (error != 0 || m == NULL) 836c4ac87eaSDarren Reed goto done; 837c4ac87eaSDarren Reed ip6 = mtod(m, struct ip6_hdr *); 8387efe5d92SHajimu UMEMOTO 8398195404bSBrooks Davis /* See if destination IP address was changed by packet filter. */ 8408195404bSBrooks Davis if (!IN6_ARE_ADDR_EQUAL(&odst, &ip6->ip6_dst)) { 8418195404bSBrooks Davis m->m_flags |= M_SKIP_FIREWALL; 8428195404bSBrooks Davis /* If destination is now ourself drop to ip6_input(). */ 8438195404bSBrooks Davis if (in6_localaddr(&ip6->ip6_dst)) { 8448195404bSBrooks Davis if (m->m_pkthdr.rcvif == NULL) 8458195404bSBrooks Davis m->m_pkthdr.rcvif = loif; 8468195404bSBrooks Davis if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) { 8478195404bSBrooks Davis m->m_pkthdr.csum_flags |= 8488195404bSBrooks Davis CSUM_DATA_VALID | CSUM_PSEUDO_HDR; 8498195404bSBrooks Davis m->m_pkthdr.csum_data = 0xffff; 8508195404bSBrooks Davis } 8518195404bSBrooks Davis m->m_pkthdr.csum_flags |= 8528195404bSBrooks Davis CSUM_IP_CHECKED | CSUM_IP_VALID; 8538195404bSBrooks Davis error = netisr_queue(NETISR_IPV6, m); 8548195404bSBrooks Davis goto done; 8558195404bSBrooks Davis } else 8568195404bSBrooks Davis goto again; /* Redo the routing table lookup. */ 8578195404bSBrooks Davis } 8588195404bSBrooks Davis 8598195404bSBrooks Davis /* XXX: IPFIREWALL_FORWARD */ 8608195404bSBrooks Davis 861c21fd232SAndre Oppermann passout: 86282cd038dSYoshinobu Inoue /* 86382cd038dSYoshinobu Inoue * Send the packet to the outgoing interface. 86482cd038dSYoshinobu Inoue * If necessary, do IPv6 fragmentation before sending. 865f95d4633SHajimu UMEMOTO * 866f95d4633SHajimu UMEMOTO * the logic here is rather complex: 867f95d4633SHajimu UMEMOTO * 1: normal case (dontfrag == 0, alwaysfrag == 0) 868f95d4633SHajimu UMEMOTO * 1-a: send as is if tlen <= path mtu 869f95d4633SHajimu UMEMOTO * 1-b: fragment if tlen > path mtu 870f95d4633SHajimu UMEMOTO * 871f95d4633SHajimu UMEMOTO * 2: if user asks us not to fragment (dontfrag == 1) 872f95d4633SHajimu UMEMOTO * 2-a: send as is if tlen <= interface mtu 873f95d4633SHajimu UMEMOTO * 2-b: error if tlen > interface mtu 874f95d4633SHajimu UMEMOTO * 875f95d4633SHajimu UMEMOTO * 3: if we always need to attach fragment header (alwaysfrag == 1) 876f95d4633SHajimu UMEMOTO * always fragment 877f95d4633SHajimu UMEMOTO * 878f95d4633SHajimu UMEMOTO * 4: if dontfrag == 1 && alwaysfrag == 1 879f95d4633SHajimu UMEMOTO * error, as we cannot handle this conflicting request 88082cd038dSYoshinobu Inoue */ 88182cd038dSYoshinobu Inoue tlen = m->m_pkthdr.len; 88282cd038dSYoshinobu Inoue 883f95d4633SHajimu UMEMOTO if (opt && (opt->ip6po_flags & IP6PO_DONTFRAG)) 884f95d4633SHajimu UMEMOTO dontfrag = 1; 885f95d4633SHajimu UMEMOTO else 886f95d4633SHajimu UMEMOTO dontfrag = 0; 887f95d4633SHajimu UMEMOTO if (dontfrag && alwaysfrag) { /* case 4 */ 888f95d4633SHajimu UMEMOTO /* conflicting request - can't transmit */ 889f95d4633SHajimu UMEMOTO error = EMSGSIZE; 890f95d4633SHajimu UMEMOTO goto bad; 891f95d4633SHajimu UMEMOTO } 892f95d4633SHajimu UMEMOTO if (dontfrag && tlen > IN6_LINKMTU(ifp)) { /* case 2-b */ 893f95d4633SHajimu UMEMOTO /* 894f95d4633SHajimu UMEMOTO * Even if the DONTFRAG option is specified, we cannot send the 895f95d4633SHajimu UMEMOTO * packet when the data length is larger than the MTU of the 896f95d4633SHajimu UMEMOTO * outgoing interface. 897f95d4633SHajimu UMEMOTO * Notify the error by sending IPV6_PATHMTU ancillary data as 898f95d4633SHajimu UMEMOTO * well as returning an error code (the latter is not described 899f95d4633SHajimu UMEMOTO * in the API spec.) 900f95d4633SHajimu UMEMOTO */ 901f95d4633SHajimu UMEMOTO u_int32_t mtu32; 902f95d4633SHajimu UMEMOTO struct ip6ctlparam ip6cp; 903f95d4633SHajimu UMEMOTO 904f95d4633SHajimu UMEMOTO mtu32 = (u_int32_t)mtu; 905f95d4633SHajimu UMEMOTO bzero(&ip6cp, sizeof(ip6cp)); 906f95d4633SHajimu UMEMOTO ip6cp.ip6c_cmdarg = (void *)&mtu32; 907f95d4633SHajimu UMEMOTO pfctlinput2(PRC_MSGSIZE, (struct sockaddr *)&ro_pmtu->ro_dst, 908f95d4633SHajimu UMEMOTO (void *)&ip6cp); 909f95d4633SHajimu UMEMOTO 910f95d4633SHajimu UMEMOTO error = EMSGSIZE; 911f95d4633SHajimu UMEMOTO goto bad; 912f95d4633SHajimu UMEMOTO } 913f95d4633SHajimu UMEMOTO 914f95d4633SHajimu UMEMOTO /* 915f95d4633SHajimu UMEMOTO * transmit packet without fragmentation 916f95d4633SHajimu UMEMOTO */ 917f95d4633SHajimu UMEMOTO if (dontfrag || (!alwaysfrag && tlen <= mtu)) { /* case 1-a and 2-a */ 918f95d4633SHajimu UMEMOTO struct in6_ifaddr *ia6; 919f95d4633SHajimu UMEMOTO 920f95d4633SHajimu UMEMOTO ip6 = mtod(m, struct ip6_hdr *); 921f95d4633SHajimu UMEMOTO ia6 = in6_ifawithifp(ifp, &ip6->ip6_src); 922f95d4633SHajimu UMEMOTO if (ia6) { 9235da9f8faSJosef Karthauser /* Record statistics for this interface address. */ 924f95d4633SHajimu UMEMOTO ia6->ia_ifa.if_opackets++; 925f95d4633SHajimu UMEMOTO ia6->ia_ifa.if_obytes += m->m_pkthdr.len; 9265da9f8faSJosef Karthauser } 927686cdd19SJun-ichiro itojun Hagino error = nd6_output(ifp, origifp, m, dst, ro->ro_rt); 92882cd038dSYoshinobu Inoue goto done; 929f95d4633SHajimu UMEMOTO } 930f95d4633SHajimu UMEMOTO 93182cd038dSYoshinobu Inoue /* 932f95d4633SHajimu UMEMOTO * try to fragment the packet. case 1-b and 3 93382cd038dSYoshinobu Inoue */ 934f95d4633SHajimu UMEMOTO if (mtu < IPV6_MMTU) { 935f95d4633SHajimu UMEMOTO /* path MTU cannot be less than IPV6_MMTU */ 93682cd038dSYoshinobu Inoue error = EMSGSIZE; 93782cd038dSYoshinobu Inoue in6_ifstat_inc(ifp, ifs6_out_fragfail); 93882cd038dSYoshinobu Inoue goto bad; 9397efe5d92SHajimu UMEMOTO } else if (ip6->ip6_plen == 0) { 9407efe5d92SHajimu UMEMOTO /* jumbo payload cannot be fragmented */ 94182cd038dSYoshinobu Inoue error = EMSGSIZE; 94282cd038dSYoshinobu Inoue in6_ifstat_inc(ifp, ifs6_out_fragfail); 94382cd038dSYoshinobu Inoue goto bad; 94482cd038dSYoshinobu Inoue } else { 94582cd038dSYoshinobu Inoue struct mbuf **mnext, *m_frgpart; 94682cd038dSYoshinobu Inoue struct ip6_frag *ip6f; 9478373d51dSHajimu UMEMOTO u_int32_t id = htonl(ip6_randomid()); 94882cd038dSYoshinobu Inoue u_char nextproto; 9492cb64cb2SGeorge V. Neville-Neil 9506f8aee22SBill Paul int qslots = ifp->if_snd.ifq_maxlen - ifp->if_snd.ifq_len; 95182cd038dSYoshinobu Inoue 95282cd038dSYoshinobu Inoue /* 95382cd038dSYoshinobu Inoue * Too large for the destination or interface; 95482cd038dSYoshinobu Inoue * fragment if possible. 95582cd038dSYoshinobu Inoue * Must be able to put at least 8 bytes per fragment. 95682cd038dSYoshinobu Inoue */ 95782cd038dSYoshinobu Inoue hlen = unfragpartlen; 95882cd038dSYoshinobu Inoue if (mtu > IPV6_MAXPACKET) 95982cd038dSYoshinobu Inoue mtu = IPV6_MAXPACKET; 96033841545SHajimu UMEMOTO 96182cd038dSYoshinobu Inoue len = (mtu - hlen - sizeof(struct ip6_frag)) & ~7; 96282cd038dSYoshinobu Inoue if (len < 8) { 96382cd038dSYoshinobu Inoue error = EMSGSIZE; 96482cd038dSYoshinobu Inoue in6_ifstat_inc(ifp, ifs6_out_fragfail); 96582cd038dSYoshinobu Inoue goto bad; 96682cd038dSYoshinobu Inoue } 96782cd038dSYoshinobu Inoue 9686f8aee22SBill Paul /* 9696f8aee22SBill Paul * Verify that we have any chance at all of being able to queue 9706f8aee22SBill Paul * the packet or packet fragments 9716f8aee22SBill Paul */ 9726f8aee22SBill Paul if (qslots <= 0 || ((u_int)qslots * (mtu - hlen) 9736f8aee22SBill Paul < tlen /* - hlen */)) { 9746f8aee22SBill Paul error = ENOBUFS; 9756f8aee22SBill Paul ip6stat.ip6s_odropped++; 9766f8aee22SBill Paul goto bad; 9776f8aee22SBill Paul } 9786f8aee22SBill Paul 97982cd038dSYoshinobu Inoue mnext = &m->m_nextpkt; 98082cd038dSYoshinobu Inoue 98182cd038dSYoshinobu Inoue /* 98282cd038dSYoshinobu Inoue * Change the next header field of the last header in the 98382cd038dSYoshinobu Inoue * unfragmentable part. 98482cd038dSYoshinobu Inoue */ 98582cd038dSYoshinobu Inoue if (exthdrs.ip6e_rthdr) { 98682cd038dSYoshinobu Inoue nextproto = *mtod(exthdrs.ip6e_rthdr, u_char *); 98782cd038dSYoshinobu Inoue *mtod(exthdrs.ip6e_rthdr, u_char *) = IPPROTO_FRAGMENT; 98882cd038dSYoshinobu Inoue } else if (exthdrs.ip6e_dest1) { 98982cd038dSYoshinobu Inoue nextproto = *mtod(exthdrs.ip6e_dest1, u_char *); 99082cd038dSYoshinobu Inoue *mtod(exthdrs.ip6e_dest1, u_char *) = IPPROTO_FRAGMENT; 99182cd038dSYoshinobu Inoue } else if (exthdrs.ip6e_hbh) { 99282cd038dSYoshinobu Inoue nextproto = *mtod(exthdrs.ip6e_hbh, u_char *); 99382cd038dSYoshinobu Inoue *mtod(exthdrs.ip6e_hbh, u_char *) = IPPROTO_FRAGMENT; 99482cd038dSYoshinobu Inoue } else { 99582cd038dSYoshinobu Inoue nextproto = ip6->ip6_nxt; 99682cd038dSYoshinobu Inoue ip6->ip6_nxt = IPPROTO_FRAGMENT; 99782cd038dSYoshinobu Inoue } 99882cd038dSYoshinobu Inoue 99982cd038dSYoshinobu Inoue /* 100082cd038dSYoshinobu Inoue * Loop through length of segment after first fragment, 100188ff5695SSUZUKI Shinsuke * make new header and copy data of each part and link onto 100288ff5695SSUZUKI Shinsuke * chain. 100382cd038dSYoshinobu Inoue */ 100482cd038dSYoshinobu Inoue m0 = m; 100582cd038dSYoshinobu Inoue for (off = hlen; off < tlen; off += len) { 1006a163d034SWarner Losh MGETHDR(m, M_DONTWAIT, MT_HEADER); 100782cd038dSYoshinobu Inoue if (!m) { 100882cd038dSYoshinobu Inoue error = ENOBUFS; 100982cd038dSYoshinobu Inoue ip6stat.ip6s_odropped++; 101082cd038dSYoshinobu Inoue goto sendorfree; 101182cd038dSYoshinobu Inoue } 101233841545SHajimu UMEMOTO m->m_pkthdr.rcvif = NULL; 101382cd038dSYoshinobu Inoue m->m_flags = m0->m_flags & M_COPYFLAGS; 101482cd038dSYoshinobu Inoue *mnext = m; 101582cd038dSYoshinobu Inoue mnext = &m->m_nextpkt; 101682cd038dSYoshinobu Inoue m->m_data += max_linkhdr; 101782cd038dSYoshinobu Inoue mhip6 = mtod(m, struct ip6_hdr *); 101882cd038dSYoshinobu Inoue *mhip6 = *ip6; 101982cd038dSYoshinobu Inoue m->m_len = sizeof(*mhip6); 102082cd038dSYoshinobu Inoue error = ip6_insertfraghdr(m0, m, hlen, &ip6f); 102182cd038dSYoshinobu Inoue if (error) { 102282cd038dSYoshinobu Inoue ip6stat.ip6s_odropped++; 102382cd038dSYoshinobu Inoue goto sendorfree; 102482cd038dSYoshinobu Inoue } 102582cd038dSYoshinobu Inoue ip6f->ip6f_offlg = htons((u_short)((off - hlen) & ~7)); 102682cd038dSYoshinobu Inoue if (off + len >= tlen) 102782cd038dSYoshinobu Inoue len = tlen - off; 102882cd038dSYoshinobu Inoue else 102982cd038dSYoshinobu Inoue ip6f->ip6f_offlg |= IP6F_MORE_FRAG; 103082cd038dSYoshinobu Inoue mhip6->ip6_plen = htons((u_short)(len + hlen + 10317efe5d92SHajimu UMEMOTO sizeof(*ip6f) - sizeof(struct ip6_hdr))); 103282cd038dSYoshinobu Inoue if ((m_frgpart = m_copy(m0, off, len)) == 0) { 103382cd038dSYoshinobu Inoue error = ENOBUFS; 103482cd038dSYoshinobu Inoue ip6stat.ip6s_odropped++; 103582cd038dSYoshinobu Inoue goto sendorfree; 103682cd038dSYoshinobu Inoue } 103782cd038dSYoshinobu Inoue m_cat(m, m_frgpart); 103882cd038dSYoshinobu Inoue m->m_pkthdr.len = len + hlen + sizeof(*ip6f); 1039fc74a9f9SBrooks Davis m->m_pkthdr.rcvif = NULL; 104082cd038dSYoshinobu Inoue ip6f->ip6f_reserved = 0; 104182cd038dSYoshinobu Inoue ip6f->ip6f_ident = id; 104282cd038dSYoshinobu Inoue ip6f->ip6f_nxt = nextproto; 104382cd038dSYoshinobu Inoue ip6stat.ip6s_ofragments++; 104482cd038dSYoshinobu Inoue in6_ifstat_inc(ifp, ifs6_out_fragcreat); 104582cd038dSYoshinobu Inoue } 104682cd038dSYoshinobu Inoue 104782cd038dSYoshinobu Inoue in6_ifstat_inc(ifp, ifs6_out_fragok); 104882cd038dSYoshinobu Inoue } 104982cd038dSYoshinobu Inoue 105082cd038dSYoshinobu Inoue /* 105182cd038dSYoshinobu Inoue * Remove leading garbages. 105282cd038dSYoshinobu Inoue */ 105382cd038dSYoshinobu Inoue sendorfree: 105482cd038dSYoshinobu Inoue m = m0->m_nextpkt; 105582cd038dSYoshinobu Inoue m0->m_nextpkt = 0; 105682cd038dSYoshinobu Inoue m_freem(m0); 105782cd038dSYoshinobu Inoue for (m0 = m; m; m = m0) { 105882cd038dSYoshinobu Inoue m0 = m->m_nextpkt; 105982cd038dSYoshinobu Inoue m->m_nextpkt = 0; 106082cd038dSYoshinobu Inoue if (error == 0) { 1061fe937674SJosef Karthauser /* Record statistics for this interface address. */ 1062fe937674SJosef Karthauser if (ia) { 1063fe937674SJosef Karthauser ia->ia_ifa.if_opackets++; 1064fe937674SJosef Karthauser ia->ia_ifa.if_obytes += m->m_pkthdr.len; 1065fe937674SJosef Karthauser } 1066686cdd19SJun-ichiro itojun Hagino error = nd6_output(ifp, origifp, m, dst, ro->ro_rt); 106782cd038dSYoshinobu Inoue } else 106882cd038dSYoshinobu Inoue m_freem(m); 106982cd038dSYoshinobu Inoue } 107082cd038dSYoshinobu Inoue 107182cd038dSYoshinobu Inoue if (error == 0) 107282cd038dSYoshinobu Inoue ip6stat.ip6s_fragmented++; 107382cd038dSYoshinobu Inoue 107482cd038dSYoshinobu Inoue done: 107582cd038dSYoshinobu Inoue if (ro == &ip6route && ro->ro_rt) { /* brace necessary for RTFREE */ 107682cd038dSYoshinobu Inoue RTFREE(ro->ro_rt); 107782cd038dSYoshinobu Inoue } else if (ro_pmtu == &ip6route && ro_pmtu->ro_rt) { 107882cd038dSYoshinobu Inoue RTFREE(ro_pmtu->ro_rt); 107982cd038dSYoshinobu Inoue } 108082cd038dSYoshinobu Inoue 108182cd038dSYoshinobu Inoue return (error); 108282cd038dSYoshinobu Inoue 108382cd038dSYoshinobu Inoue freehdrs: 108482cd038dSYoshinobu Inoue m_freem(exthdrs.ip6e_hbh); /* m_freem will check if mbuf is 0 */ 108582cd038dSYoshinobu Inoue m_freem(exthdrs.ip6e_dest1); 108682cd038dSYoshinobu Inoue m_freem(exthdrs.ip6e_rthdr); 108782cd038dSYoshinobu Inoue m_freem(exthdrs.ip6e_dest2); 10887efe5d92SHajimu UMEMOTO /* FALLTHROUGH */ 108982cd038dSYoshinobu Inoue bad: 10902cb64cb2SGeorge V. Neville-Neil if (m) 109182cd038dSYoshinobu Inoue m_freem(m); 109282cd038dSYoshinobu Inoue goto done; 109382cd038dSYoshinobu Inoue } 109482cd038dSYoshinobu Inoue 109582cd038dSYoshinobu Inoue static int 10961272577eSXin LI ip6_copyexthdr(struct mbuf **mp, caddr_t hdr, int hlen) 109782cd038dSYoshinobu Inoue { 109882cd038dSYoshinobu Inoue struct mbuf *m; 109982cd038dSYoshinobu Inoue 110082cd038dSYoshinobu Inoue if (hlen > MCLBYTES) 110182cd038dSYoshinobu Inoue return (ENOBUFS); /* XXX */ 110282cd038dSYoshinobu Inoue 1103a163d034SWarner Losh MGET(m, M_DONTWAIT, MT_DATA); 110482cd038dSYoshinobu Inoue if (!m) 110582cd038dSYoshinobu Inoue return (ENOBUFS); 110682cd038dSYoshinobu Inoue 110782cd038dSYoshinobu Inoue if (hlen > MLEN) { 1108a163d034SWarner Losh MCLGET(m, M_DONTWAIT); 110982cd038dSYoshinobu Inoue if ((m->m_flags & M_EXT) == 0) { 111082cd038dSYoshinobu Inoue m_free(m); 111182cd038dSYoshinobu Inoue return (ENOBUFS); 111282cd038dSYoshinobu Inoue } 111382cd038dSYoshinobu Inoue } 111482cd038dSYoshinobu Inoue m->m_len = hlen; 111582cd038dSYoshinobu Inoue if (hdr) 111682cd038dSYoshinobu Inoue bcopy(hdr, mtod(m, caddr_t), hlen); 111782cd038dSYoshinobu Inoue 111882cd038dSYoshinobu Inoue *mp = m; 111982cd038dSYoshinobu Inoue return (0); 112082cd038dSYoshinobu Inoue } 112182cd038dSYoshinobu Inoue 112282cd038dSYoshinobu Inoue /* 112382cd038dSYoshinobu Inoue * Insert jumbo payload option. 112482cd038dSYoshinobu Inoue */ 112582cd038dSYoshinobu Inoue static int 11261272577eSXin LI ip6_insert_jumboopt(struct ip6_exthdrs *exthdrs, u_int32_t plen) 112782cd038dSYoshinobu Inoue { 112882cd038dSYoshinobu Inoue struct mbuf *mopt; 112982cd038dSYoshinobu Inoue u_char *optbuf; 113033841545SHajimu UMEMOTO u_int32_t v; 113182cd038dSYoshinobu Inoue 113282cd038dSYoshinobu Inoue #define JUMBOOPTLEN 8 /* length of jumbo payload option and padding */ 113382cd038dSYoshinobu Inoue 113482cd038dSYoshinobu Inoue /* 113582cd038dSYoshinobu Inoue * If there is no hop-by-hop options header, allocate new one. 113682cd038dSYoshinobu Inoue * If there is one but it doesn't have enough space to store the 113782cd038dSYoshinobu Inoue * jumbo payload option, allocate a cluster to store the whole options. 113882cd038dSYoshinobu Inoue * Otherwise, use it to store the options. 113982cd038dSYoshinobu Inoue */ 114082cd038dSYoshinobu Inoue if (exthdrs->ip6e_hbh == 0) { 1141a163d034SWarner Losh MGET(mopt, M_DONTWAIT, MT_DATA); 114282cd038dSYoshinobu Inoue if (mopt == 0) 114382cd038dSYoshinobu Inoue return (ENOBUFS); 114482cd038dSYoshinobu Inoue mopt->m_len = JUMBOOPTLEN; 114582cd038dSYoshinobu Inoue optbuf = mtod(mopt, u_char *); 114682cd038dSYoshinobu Inoue optbuf[1] = 0; /* = ((JUMBOOPTLEN) >> 3) - 1 */ 114782cd038dSYoshinobu Inoue exthdrs->ip6e_hbh = mopt; 114882cd038dSYoshinobu Inoue } else { 114982cd038dSYoshinobu Inoue struct ip6_hbh *hbh; 115082cd038dSYoshinobu Inoue 115182cd038dSYoshinobu Inoue mopt = exthdrs->ip6e_hbh; 115282cd038dSYoshinobu Inoue if (M_TRAILINGSPACE(mopt) < JUMBOOPTLEN) { 115333841545SHajimu UMEMOTO /* 115433841545SHajimu UMEMOTO * XXX assumption: 115533841545SHajimu UMEMOTO * - exthdrs->ip6e_hbh is not referenced from places 115633841545SHajimu UMEMOTO * other than exthdrs. 115733841545SHajimu UMEMOTO * - exthdrs->ip6e_hbh is not an mbuf chain. 115833841545SHajimu UMEMOTO */ 115982cd038dSYoshinobu Inoue int oldoptlen = mopt->m_len; 116033841545SHajimu UMEMOTO struct mbuf *n; 116182cd038dSYoshinobu Inoue 116233841545SHajimu UMEMOTO /* 116333841545SHajimu UMEMOTO * XXX: give up if the whole (new) hbh header does 116433841545SHajimu UMEMOTO * not fit even in an mbuf cluster. 116533841545SHajimu UMEMOTO */ 116633841545SHajimu UMEMOTO if (oldoptlen + JUMBOOPTLEN > MCLBYTES) 116782cd038dSYoshinobu Inoue return (ENOBUFS); 116882cd038dSYoshinobu Inoue 116933841545SHajimu UMEMOTO /* 117033841545SHajimu UMEMOTO * As a consequence, we must always prepare a cluster 117133841545SHajimu UMEMOTO * at this point. 117233841545SHajimu UMEMOTO */ 1173a163d034SWarner Losh MGET(n, M_DONTWAIT, MT_DATA); 117433841545SHajimu UMEMOTO if (n) { 1175a163d034SWarner Losh MCLGET(n, M_DONTWAIT); 117633841545SHajimu UMEMOTO if ((n->m_flags & M_EXT) == 0) { 117733841545SHajimu UMEMOTO m_freem(n); 117833841545SHajimu UMEMOTO n = NULL; 117933841545SHajimu UMEMOTO } 118033841545SHajimu UMEMOTO } 118133841545SHajimu UMEMOTO if (!n) 118233841545SHajimu UMEMOTO return (ENOBUFS); 118333841545SHajimu UMEMOTO n->m_len = oldoptlen + JUMBOOPTLEN; 118433841545SHajimu UMEMOTO bcopy(mtod(mopt, caddr_t), mtod(n, caddr_t), 118533841545SHajimu UMEMOTO oldoptlen); 118633841545SHajimu UMEMOTO optbuf = mtod(n, caddr_t) + oldoptlen; 118733841545SHajimu UMEMOTO m_freem(mopt); 118833841545SHajimu UMEMOTO mopt = exthdrs->ip6e_hbh = n; 118982cd038dSYoshinobu Inoue } else { 119082cd038dSYoshinobu Inoue optbuf = mtod(mopt, u_char *) + mopt->m_len; 119182cd038dSYoshinobu Inoue mopt->m_len += JUMBOOPTLEN; 119282cd038dSYoshinobu Inoue } 119382cd038dSYoshinobu Inoue optbuf[0] = IP6OPT_PADN; 119482cd038dSYoshinobu Inoue optbuf[1] = 1; 119582cd038dSYoshinobu Inoue 119682cd038dSYoshinobu Inoue /* 119782cd038dSYoshinobu Inoue * Adjust the header length according to the pad and 119882cd038dSYoshinobu Inoue * the jumbo payload option. 119982cd038dSYoshinobu Inoue */ 120082cd038dSYoshinobu Inoue hbh = mtod(mopt, struct ip6_hbh *); 120182cd038dSYoshinobu Inoue hbh->ip6h_len += (JUMBOOPTLEN >> 3); 120282cd038dSYoshinobu Inoue } 120382cd038dSYoshinobu Inoue 120482cd038dSYoshinobu Inoue /* fill in the option. */ 120582cd038dSYoshinobu Inoue optbuf[2] = IP6OPT_JUMBO; 120682cd038dSYoshinobu Inoue optbuf[3] = 4; 120733841545SHajimu UMEMOTO v = (u_int32_t)htonl(plen + JUMBOOPTLEN); 120833841545SHajimu UMEMOTO bcopy(&v, &optbuf[4], sizeof(u_int32_t)); 120982cd038dSYoshinobu Inoue 121082cd038dSYoshinobu Inoue /* finally, adjust the packet header length */ 121182cd038dSYoshinobu Inoue exthdrs->ip6e_ip6->m_pkthdr.len += JUMBOOPTLEN; 121282cd038dSYoshinobu Inoue 121382cd038dSYoshinobu Inoue return (0); 121482cd038dSYoshinobu Inoue #undef JUMBOOPTLEN 121582cd038dSYoshinobu Inoue } 121682cd038dSYoshinobu Inoue 121782cd038dSYoshinobu Inoue /* 121882cd038dSYoshinobu Inoue * Insert fragment header and copy unfragmentable header portions. 121982cd038dSYoshinobu Inoue */ 122082cd038dSYoshinobu Inoue static int 12211272577eSXin LI ip6_insertfraghdr(struct mbuf *m0, struct mbuf *m, int hlen, 12221272577eSXin LI struct ip6_frag **frghdrp) 122382cd038dSYoshinobu Inoue { 122482cd038dSYoshinobu Inoue struct mbuf *n, *mlast; 122582cd038dSYoshinobu Inoue 122682cd038dSYoshinobu Inoue if (hlen > sizeof(struct ip6_hdr)) { 122782cd038dSYoshinobu Inoue n = m_copym(m0, sizeof(struct ip6_hdr), 1228a163d034SWarner Losh hlen - sizeof(struct ip6_hdr), M_DONTWAIT); 122982cd038dSYoshinobu Inoue if (n == 0) 123082cd038dSYoshinobu Inoue return (ENOBUFS); 123182cd038dSYoshinobu Inoue m->m_next = n; 123282cd038dSYoshinobu Inoue } else 123382cd038dSYoshinobu Inoue n = m; 123482cd038dSYoshinobu Inoue 123582cd038dSYoshinobu Inoue /* Search for the last mbuf of unfragmentable part. */ 123682cd038dSYoshinobu Inoue for (mlast = n; mlast->m_next; mlast = mlast->m_next) 123782cd038dSYoshinobu Inoue ; 123882cd038dSYoshinobu Inoue 123982cd038dSYoshinobu Inoue if ((mlast->m_flags & M_EXT) == 0 && 1240686cdd19SJun-ichiro itojun Hagino M_TRAILINGSPACE(mlast) >= sizeof(struct ip6_frag)) { 124182cd038dSYoshinobu Inoue /* use the trailing space of the last mbuf for the fragment hdr */ 12427efe5d92SHajimu UMEMOTO *frghdrp = (struct ip6_frag *)(mtod(mlast, caddr_t) + 12437efe5d92SHajimu UMEMOTO mlast->m_len); 124482cd038dSYoshinobu Inoue mlast->m_len += sizeof(struct ip6_frag); 124582cd038dSYoshinobu Inoue m->m_pkthdr.len += sizeof(struct ip6_frag); 124682cd038dSYoshinobu Inoue } else { 124782cd038dSYoshinobu Inoue /* allocate a new mbuf for the fragment header */ 124882cd038dSYoshinobu Inoue struct mbuf *mfrg; 124982cd038dSYoshinobu Inoue 1250a163d034SWarner Losh MGET(mfrg, M_DONTWAIT, MT_DATA); 125182cd038dSYoshinobu Inoue if (mfrg == 0) 125282cd038dSYoshinobu Inoue return (ENOBUFS); 125382cd038dSYoshinobu Inoue mfrg->m_len = sizeof(struct ip6_frag); 125482cd038dSYoshinobu Inoue *frghdrp = mtod(mfrg, struct ip6_frag *); 125582cd038dSYoshinobu Inoue mlast->m_next = mfrg; 125682cd038dSYoshinobu Inoue } 125782cd038dSYoshinobu Inoue 125882cd038dSYoshinobu Inoue return (0); 125982cd038dSYoshinobu Inoue } 126082cd038dSYoshinobu Inoue 126131b3783cSHajimu UMEMOTO static int 12621272577eSXin LI ip6_getpmtu(struct route_in6 *ro_pmtu, struct route_in6 *ro, 12631272577eSXin LI struct ifnet *ifp, struct in6_addr *dst, u_long *mtup, 12641272577eSXin LI int *alwaysfragp) 126531b3783cSHajimu UMEMOTO { 126631b3783cSHajimu UMEMOTO u_int32_t mtu = 0; 1267f95d4633SHajimu UMEMOTO int alwaysfrag = 0; 126831b3783cSHajimu UMEMOTO int error = 0; 126931b3783cSHajimu UMEMOTO 127031b3783cSHajimu UMEMOTO if (ro_pmtu != ro) { 127131b3783cSHajimu UMEMOTO /* The first hop and the final destination may differ. */ 127231b3783cSHajimu UMEMOTO struct sockaddr_in6 *sa6_dst = 127331b3783cSHajimu UMEMOTO (struct sockaddr_in6 *)&ro_pmtu->ro_dst; 127431b3783cSHajimu UMEMOTO if (ro_pmtu->ro_rt && 1275e5f467a2SHajimu UMEMOTO ((ro_pmtu->ro_rt->rt_flags & RTF_UP) == 0 || 127631b3783cSHajimu UMEMOTO !IN6_ARE_ADDR_EQUAL(&sa6_dst->sin6_addr, dst))) { 127731b3783cSHajimu UMEMOTO RTFREE(ro_pmtu->ro_rt); 127831b3783cSHajimu UMEMOTO ro_pmtu->ro_rt = (struct rtentry *)NULL; 127931b3783cSHajimu UMEMOTO } 128031b3783cSHajimu UMEMOTO if (ro_pmtu->ro_rt == NULL) { 128131b3783cSHajimu UMEMOTO bzero(sa6_dst, sizeof(*sa6_dst)); 128231b3783cSHajimu UMEMOTO sa6_dst->sin6_family = AF_INET6; 128331b3783cSHajimu UMEMOTO sa6_dst->sin6_len = sizeof(struct sockaddr_in6); 128431b3783cSHajimu UMEMOTO sa6_dst->sin6_addr = *dst; 128531b3783cSHajimu UMEMOTO 128631b3783cSHajimu UMEMOTO rtalloc((struct route *)ro_pmtu); 128731b3783cSHajimu UMEMOTO } 128831b3783cSHajimu UMEMOTO } 128931b3783cSHajimu UMEMOTO if (ro_pmtu->ro_rt) { 129031b3783cSHajimu UMEMOTO u_int32_t ifmtu; 129197d8d152SAndre Oppermann struct in_conninfo inc; 129297d8d152SAndre Oppermann 129397d8d152SAndre Oppermann bzero(&inc, sizeof(inc)); 129497d8d152SAndre Oppermann inc.inc_flags = 1; /* IPv6 */ 129597d8d152SAndre Oppermann inc.inc6_faddr = *dst; 129631b3783cSHajimu UMEMOTO 129731b3783cSHajimu UMEMOTO if (ifp == NULL) 129831b3783cSHajimu UMEMOTO ifp = ro_pmtu->ro_rt->rt_ifp; 129931b3783cSHajimu UMEMOTO ifmtu = IN6_LINKMTU(ifp); 130097d8d152SAndre Oppermann mtu = tcp_hc_getmtu(&inc); 130197d8d152SAndre Oppermann if (mtu) 130297d8d152SAndre Oppermann mtu = min(mtu, ro_pmtu->ro_rt->rt_rmx.rmx_mtu); 130397d8d152SAndre Oppermann else 130431b3783cSHajimu UMEMOTO mtu = ro_pmtu->ro_rt->rt_rmx.rmx_mtu; 130531b3783cSHajimu UMEMOTO if (mtu == 0) 130631b3783cSHajimu UMEMOTO mtu = ifmtu; 1307f95d4633SHajimu UMEMOTO else if (mtu < IPV6_MMTU) { 1308f95d4633SHajimu UMEMOTO /* 1309f95d4633SHajimu UMEMOTO * RFC2460 section 5, last paragraph: 1310f95d4633SHajimu UMEMOTO * if we record ICMPv6 too big message with 1311f95d4633SHajimu UMEMOTO * mtu < IPV6_MMTU, transmit packets sized IPV6_MMTU 1312f95d4633SHajimu UMEMOTO * or smaller, with framgent header attached. 1313f95d4633SHajimu UMEMOTO * (fragment header is needed regardless from the 1314f95d4633SHajimu UMEMOTO * packet size, for translators to identify packets) 1315f95d4633SHajimu UMEMOTO */ 1316f95d4633SHajimu UMEMOTO alwaysfrag = 1; 1317f95d4633SHajimu UMEMOTO mtu = IPV6_MMTU; 1318f95d4633SHajimu UMEMOTO } else if (mtu > ifmtu) { 131931b3783cSHajimu UMEMOTO /* 132031b3783cSHajimu UMEMOTO * The MTU on the route is larger than the MTU on 132131b3783cSHajimu UMEMOTO * the interface! This shouldn't happen, unless the 132231b3783cSHajimu UMEMOTO * MTU of the interface has been changed after the 132331b3783cSHajimu UMEMOTO * interface was brought up. Change the MTU in the 132431b3783cSHajimu UMEMOTO * route to match the interface MTU (as long as the 132531b3783cSHajimu UMEMOTO * field isn't locked). 132631b3783cSHajimu UMEMOTO */ 132731b3783cSHajimu UMEMOTO mtu = ifmtu; 132831b3783cSHajimu UMEMOTO ro_pmtu->ro_rt->rt_rmx.rmx_mtu = mtu; 132931b3783cSHajimu UMEMOTO } 133031b3783cSHajimu UMEMOTO } else if (ifp) { 133131b3783cSHajimu UMEMOTO mtu = IN6_LINKMTU(ifp); 133231b3783cSHajimu UMEMOTO } else 133331b3783cSHajimu UMEMOTO error = EHOSTUNREACH; /* XXX */ 133431b3783cSHajimu UMEMOTO 133531b3783cSHajimu UMEMOTO *mtup = mtu; 1336f95d4633SHajimu UMEMOTO if (alwaysfragp) 1337f95d4633SHajimu UMEMOTO *alwaysfragp = alwaysfrag; 133831b3783cSHajimu UMEMOTO return (error); 133931b3783cSHajimu UMEMOTO } 134031b3783cSHajimu UMEMOTO 134182cd038dSYoshinobu Inoue /* 134282cd038dSYoshinobu Inoue * IP6 socket option processing. 134382cd038dSYoshinobu Inoue */ 134482cd038dSYoshinobu Inoue int 13451272577eSXin LI ip6_ctloutput(struct socket *so, struct sockopt *sopt) 134682cd038dSYoshinobu Inoue { 1347f95d4633SHajimu UMEMOTO int privileged, optdatalen, uproto; 1348f95d4633SHajimu UMEMOTO void *optdata; 134933841545SHajimu UMEMOTO struct inpcb *in6p = sotoinpcb(so); 135082cd038dSYoshinobu Inoue int error, optval; 135182cd038dSYoshinobu Inoue int level, op, optname; 135282cd038dSYoshinobu Inoue int optlen; 1353b40ce416SJulian Elischer struct thread *td; 135482cd038dSYoshinobu Inoue 135582cd038dSYoshinobu Inoue if (sopt) { 135682cd038dSYoshinobu Inoue level = sopt->sopt_level; 135782cd038dSYoshinobu Inoue op = sopt->sopt_dir; 135882cd038dSYoshinobu Inoue optname = sopt->sopt_name; 135982cd038dSYoshinobu Inoue optlen = sopt->sopt_valsize; 1360b40ce416SJulian Elischer td = sopt->sopt_td; 136182cd038dSYoshinobu Inoue } else { 136282cd038dSYoshinobu Inoue panic("ip6_ctloutput: arg soopt is NULL"); 136382cd038dSYoshinobu Inoue } 136482cd038dSYoshinobu Inoue error = optval = 0; 136582cd038dSYoshinobu Inoue 136644731cabSJohn Baldwin privileged = (td == 0 || suser(td)) ? 0 : 1; 1367f95d4633SHajimu UMEMOTO uproto = (int)so->so_proto->pr_protocol; 136882cd038dSYoshinobu Inoue 136982cd038dSYoshinobu Inoue if (level == IPPROTO_IPV6) { 137082cd038dSYoshinobu Inoue switch (op) { 137133841545SHajimu UMEMOTO 137282cd038dSYoshinobu Inoue case SOPT_SET: 137382cd038dSYoshinobu Inoue switch (optname) { 1374f95d4633SHajimu UMEMOTO case IPV6_2292PKTOPTIONS: 1375f95d4633SHajimu UMEMOTO #ifdef IPV6_PKTOPTIONS 137682cd038dSYoshinobu Inoue case IPV6_PKTOPTIONS: 1377f95d4633SHajimu UMEMOTO #endif 137882cd038dSYoshinobu Inoue { 137982cd038dSYoshinobu Inoue struct mbuf *m; 138082cd038dSYoshinobu Inoue 138182cd038dSYoshinobu Inoue error = soopt_getm(sopt, &m); /* XXX */ 1382a89ec05eSPeter Wemm if (error != 0) 138382cd038dSYoshinobu Inoue break; 138482cd038dSYoshinobu Inoue error = soopt_mcopyin(sopt, m); /* XXX */ 1385a89ec05eSPeter Wemm if (error != 0) 138682cd038dSYoshinobu Inoue break; 138733841545SHajimu UMEMOTO error = ip6_pcbopts(&in6p->in6p_outputopts, 138833841545SHajimu UMEMOTO m, so, sopt); 138933841545SHajimu UMEMOTO m_freem(m); /* XXX */ 139082cd038dSYoshinobu Inoue break; 139182cd038dSYoshinobu Inoue } 139233841545SHajimu UMEMOTO 139333841545SHajimu UMEMOTO /* 139433841545SHajimu UMEMOTO * Use of some Hop-by-Hop options or some 139533841545SHajimu UMEMOTO * Destination options, might require special 139633841545SHajimu UMEMOTO * privilege. That is, normal applications 139733841545SHajimu UMEMOTO * (without special privilege) might be forbidden 139833841545SHajimu UMEMOTO * from setting certain options in outgoing packets, 139933841545SHajimu UMEMOTO * and might never see certain options in received 140033841545SHajimu UMEMOTO * packets. [RFC 2292 Section 6] 140133841545SHajimu UMEMOTO * KAME specific note: 140233841545SHajimu UMEMOTO * KAME prevents non-privileged users from sending or 140333841545SHajimu UMEMOTO * receiving ANY hbh/dst options in order to avoid 140433841545SHajimu UMEMOTO * overhead of parsing options in the kernel. 140533841545SHajimu UMEMOTO */ 1406f95d4633SHajimu UMEMOTO case IPV6_RECVHOPOPTS: 1407f95d4633SHajimu UMEMOTO case IPV6_RECVDSTOPTS: 1408f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDRDSTOPTS: 1409f95d4633SHajimu UMEMOTO if (!privileged) { 1410f95d4633SHajimu UMEMOTO error = EPERM; 1411f95d4633SHajimu UMEMOTO break; 1412f95d4633SHajimu UMEMOTO } 1413f95d4633SHajimu UMEMOTO /* FALLTHROUGH */ 141482cd038dSYoshinobu Inoue case IPV6_UNICAST_HOPS: 1415f95d4633SHajimu UMEMOTO case IPV6_HOPLIMIT: 141682cd038dSYoshinobu Inoue case IPV6_FAITH: 141733841545SHajimu UMEMOTO 1418f95d4633SHajimu UMEMOTO case IPV6_RECVPKTINFO: 1419f95d4633SHajimu UMEMOTO case IPV6_RECVHOPLIMIT: 1420f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDR: 1421f95d4633SHajimu UMEMOTO case IPV6_RECVPATHMTU: 1422f95d4633SHajimu UMEMOTO case IPV6_RECVTCLASS: 142333841545SHajimu UMEMOTO case IPV6_V6ONLY: 1424f95d4633SHajimu UMEMOTO case IPV6_AUTOFLOWLABEL: 142533841545SHajimu UMEMOTO if (optlen != sizeof(int)) { 142682cd038dSYoshinobu Inoue error = EINVAL; 142733841545SHajimu UMEMOTO break; 142833841545SHajimu UMEMOTO } 142982cd038dSYoshinobu Inoue error = sooptcopyin(sopt, &optval, 143082cd038dSYoshinobu Inoue sizeof optval, sizeof optval); 143182cd038dSYoshinobu Inoue if (error) 143282cd038dSYoshinobu Inoue break; 143382cd038dSYoshinobu Inoue switch (optname) { 143482cd038dSYoshinobu Inoue 143582cd038dSYoshinobu Inoue case IPV6_UNICAST_HOPS: 143682cd038dSYoshinobu Inoue if (optval < -1 || optval >= 256) 143782cd038dSYoshinobu Inoue error = EINVAL; 143882cd038dSYoshinobu Inoue else { 143982cd038dSYoshinobu Inoue /* -1 = kernel default */ 144082cd038dSYoshinobu Inoue in6p->in6p_hops = optval; 144182cd038dSYoshinobu Inoue if ((in6p->in6p_vflag & 144282cd038dSYoshinobu Inoue INP_IPV4) != 0) 144382cd038dSYoshinobu Inoue in6p->inp_ip_ttl = optval; 144482cd038dSYoshinobu Inoue } 144582cd038dSYoshinobu Inoue break; 144682cd038dSYoshinobu Inoue #define OPTSET(bit) \ 144733841545SHajimu UMEMOTO do { \ 144882cd038dSYoshinobu Inoue if (optval) \ 144933841545SHajimu UMEMOTO in6p->in6p_flags |= (bit); \ 145082cd038dSYoshinobu Inoue else \ 145133841545SHajimu UMEMOTO in6p->in6p_flags &= ~(bit); \ 14527efe5d92SHajimu UMEMOTO } while (/*CONSTCOND*/ 0) 1453f95d4633SHajimu UMEMOTO #define OPTSET2292(bit) \ 1454f95d4633SHajimu UMEMOTO do { \ 1455f95d4633SHajimu UMEMOTO in6p->in6p_flags |= IN6P_RFC2292; \ 1456f95d4633SHajimu UMEMOTO if (optval) \ 1457f95d4633SHajimu UMEMOTO in6p->in6p_flags |= (bit); \ 1458f95d4633SHajimu UMEMOTO else \ 1459f95d4633SHajimu UMEMOTO in6p->in6p_flags &= ~(bit); \ 1460f95d4633SHajimu UMEMOTO } while (/*CONSTCOND*/ 0) 146133841545SHajimu UMEMOTO #define OPTBIT(bit) (in6p->in6p_flags & (bit) ? 1 : 0) 146282cd038dSYoshinobu Inoue 1463f95d4633SHajimu UMEMOTO case IPV6_RECVPKTINFO: 1464f95d4633SHajimu UMEMOTO /* cannot mix with RFC2292 */ 1465f95d4633SHajimu UMEMOTO if (OPTBIT(IN6P_RFC2292)) { 1466f95d4633SHajimu UMEMOTO error = EINVAL; 1467f95d4633SHajimu UMEMOTO break; 1468f95d4633SHajimu UMEMOTO } 1469f95d4633SHajimu UMEMOTO OPTSET(IN6P_PKTINFO); 1470f95d4633SHajimu UMEMOTO break; 1471f95d4633SHajimu UMEMOTO 1472f95d4633SHajimu UMEMOTO case IPV6_HOPLIMIT: 1473f95d4633SHajimu UMEMOTO { 1474f95d4633SHajimu UMEMOTO struct ip6_pktopts **optp; 1475f95d4633SHajimu UMEMOTO 1476f95d4633SHajimu UMEMOTO /* cannot mix with RFC2292 */ 1477f95d4633SHajimu UMEMOTO if (OPTBIT(IN6P_RFC2292)) { 1478f95d4633SHajimu UMEMOTO error = EINVAL; 1479f95d4633SHajimu UMEMOTO break; 1480f95d4633SHajimu UMEMOTO } 1481f95d4633SHajimu UMEMOTO optp = &in6p->in6p_outputopts; 1482f95d4633SHajimu UMEMOTO error = ip6_pcbopt(IPV6_HOPLIMIT, 1483f95d4633SHajimu UMEMOTO (u_char *)&optval, 1484f95d4633SHajimu UMEMOTO sizeof(optval), 1485f95d4633SHajimu UMEMOTO optp, 1486f95d4633SHajimu UMEMOTO privileged, uproto); 1487f95d4633SHajimu UMEMOTO break; 1488f95d4633SHajimu UMEMOTO } 1489f95d4633SHajimu UMEMOTO 1490f95d4633SHajimu UMEMOTO case IPV6_RECVHOPLIMIT: 1491f95d4633SHajimu UMEMOTO /* cannot mix with RFC2292 */ 1492f95d4633SHajimu UMEMOTO if (OPTBIT(IN6P_RFC2292)) { 1493f95d4633SHajimu UMEMOTO error = EINVAL; 1494f95d4633SHajimu UMEMOTO break; 1495f95d4633SHajimu UMEMOTO } 1496f95d4633SHajimu UMEMOTO OPTSET(IN6P_HOPLIMIT); 1497f95d4633SHajimu UMEMOTO break; 1498f95d4633SHajimu UMEMOTO 1499f95d4633SHajimu UMEMOTO case IPV6_RECVHOPOPTS: 1500f95d4633SHajimu UMEMOTO /* cannot mix with RFC2292 */ 1501f95d4633SHajimu UMEMOTO if (OPTBIT(IN6P_RFC2292)) { 1502f95d4633SHajimu UMEMOTO error = EINVAL; 1503f95d4633SHajimu UMEMOTO break; 1504f95d4633SHajimu UMEMOTO } 1505f95d4633SHajimu UMEMOTO OPTSET(IN6P_HOPOPTS); 1506f95d4633SHajimu UMEMOTO break; 1507f95d4633SHajimu UMEMOTO 1508f95d4633SHajimu UMEMOTO case IPV6_RECVDSTOPTS: 1509f95d4633SHajimu UMEMOTO /* cannot mix with RFC2292 */ 1510f95d4633SHajimu UMEMOTO if (OPTBIT(IN6P_RFC2292)) { 1511f95d4633SHajimu UMEMOTO error = EINVAL; 1512f95d4633SHajimu UMEMOTO break; 1513f95d4633SHajimu UMEMOTO } 1514f95d4633SHajimu UMEMOTO OPTSET(IN6P_DSTOPTS); 1515f95d4633SHajimu UMEMOTO break; 1516f95d4633SHajimu UMEMOTO 1517f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDRDSTOPTS: 1518f95d4633SHajimu UMEMOTO /* cannot mix with RFC2292 */ 1519f95d4633SHajimu UMEMOTO if (OPTBIT(IN6P_RFC2292)) { 1520f95d4633SHajimu UMEMOTO error = EINVAL; 1521f95d4633SHajimu UMEMOTO break; 1522f95d4633SHajimu UMEMOTO } 1523f95d4633SHajimu UMEMOTO OPTSET(IN6P_RTHDRDSTOPTS); 1524f95d4633SHajimu UMEMOTO break; 1525f95d4633SHajimu UMEMOTO 1526f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDR: 1527f95d4633SHajimu UMEMOTO /* cannot mix with RFC2292 */ 1528f95d4633SHajimu UMEMOTO if (OPTBIT(IN6P_RFC2292)) { 1529f95d4633SHajimu UMEMOTO error = EINVAL; 1530f95d4633SHajimu UMEMOTO break; 1531f95d4633SHajimu UMEMOTO } 1532f95d4633SHajimu UMEMOTO OPTSET(IN6P_RTHDR); 153382cd038dSYoshinobu Inoue break; 153482cd038dSYoshinobu Inoue 153582cd038dSYoshinobu Inoue case IPV6_FAITH: 153682cd038dSYoshinobu Inoue OPTSET(IN6P_FAITH); 153782cd038dSYoshinobu Inoue break; 153882cd038dSYoshinobu Inoue 1539f95d4633SHajimu UMEMOTO case IPV6_RECVPATHMTU: 1540f95d4633SHajimu UMEMOTO /* 1541f95d4633SHajimu UMEMOTO * We ignore this option for TCP 1542f95d4633SHajimu UMEMOTO * sockets. 154318b35df8SHajimu UMEMOTO * (RFC3542 leaves this case 1544f95d4633SHajimu UMEMOTO * unspecified.) 1545f95d4633SHajimu UMEMOTO */ 1546f95d4633SHajimu UMEMOTO if (uproto != IPPROTO_TCP) 1547f95d4633SHajimu UMEMOTO OPTSET(IN6P_MTU); 1548f95d4633SHajimu UMEMOTO break; 1549f95d4633SHajimu UMEMOTO 155033841545SHajimu UMEMOTO case IPV6_V6ONLY: 155133841545SHajimu UMEMOTO /* 15520554093bSHajimu UMEMOTO * make setsockopt(IPV6_V6ONLY) 15530554093bSHajimu UMEMOTO * available only prior to bind(2). 15540554093bSHajimu UMEMOTO * see ipng mailing list, Jun 22 2001. 15550554093bSHajimu UMEMOTO */ 15560554093bSHajimu UMEMOTO if (in6p->in6p_lport || 15577efe5d92SHajimu UMEMOTO !IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) { 15580554093bSHajimu UMEMOTO error = EINVAL; 15590554093bSHajimu UMEMOTO break; 15600554093bSHajimu UMEMOTO } 156133841545SHajimu UMEMOTO OPTSET(IN6P_IPV6_V6ONLY); 156212253795SHajimu UMEMOTO if (optval) 156312253795SHajimu UMEMOTO in6p->in6p_vflag &= ~INP_IPV4; 156412253795SHajimu UMEMOTO else 156512253795SHajimu UMEMOTO in6p->in6p_vflag |= INP_IPV4; 156682cd038dSYoshinobu Inoue break; 1567f95d4633SHajimu UMEMOTO case IPV6_RECVTCLASS: 1568f95d4633SHajimu UMEMOTO /* cannot mix with RFC2292 XXX */ 1569f95d4633SHajimu UMEMOTO if (OPTBIT(IN6P_RFC2292)) { 1570f95d4633SHajimu UMEMOTO error = EINVAL; 1571f95d4633SHajimu UMEMOTO break; 1572f95d4633SHajimu UMEMOTO } 1573f95d4633SHajimu UMEMOTO OPTSET(IN6P_TCLASS); 1574f95d4633SHajimu UMEMOTO break; 1575f95d4633SHajimu UMEMOTO case IPV6_AUTOFLOWLABEL: 1576f95d4633SHajimu UMEMOTO OPTSET(IN6P_AUTOFLOWLABEL); 1577f95d4633SHajimu UMEMOTO break; 1578f95d4633SHajimu UMEMOTO 157982cd038dSYoshinobu Inoue } 158033841545SHajimu UMEMOTO break; 158133841545SHajimu UMEMOTO 1582f95d4633SHajimu UMEMOTO case IPV6_TCLASS: 1583f95d4633SHajimu UMEMOTO case IPV6_DONTFRAG: 1584f95d4633SHajimu UMEMOTO case IPV6_USE_MIN_MTU: 1585f95d4633SHajimu UMEMOTO case IPV6_PREFER_TEMPADDR: 1586f95d4633SHajimu UMEMOTO if (optlen != sizeof(optval)) { 1587f95d4633SHajimu UMEMOTO error = EINVAL; 1588f95d4633SHajimu UMEMOTO break; 1589f95d4633SHajimu UMEMOTO } 1590f95d4633SHajimu UMEMOTO error = sooptcopyin(sopt, &optval, 1591f95d4633SHajimu UMEMOTO sizeof optval, sizeof optval); 1592f95d4633SHajimu UMEMOTO if (error) 1593f95d4633SHajimu UMEMOTO break; 1594f95d4633SHajimu UMEMOTO { 1595f95d4633SHajimu UMEMOTO struct ip6_pktopts **optp; 1596f95d4633SHajimu UMEMOTO optp = &in6p->in6p_outputopts; 1597f95d4633SHajimu UMEMOTO error = ip6_pcbopt(optname, 1598f95d4633SHajimu UMEMOTO (u_char *)&optval, 1599f95d4633SHajimu UMEMOTO sizeof(optval), 1600f95d4633SHajimu UMEMOTO optp, 1601f95d4633SHajimu UMEMOTO privileged, uproto); 1602f95d4633SHajimu UMEMOTO break; 1603f95d4633SHajimu UMEMOTO } 1604f95d4633SHajimu UMEMOTO 1605f95d4633SHajimu UMEMOTO case IPV6_2292PKTINFO: 1606f95d4633SHajimu UMEMOTO case IPV6_2292HOPLIMIT: 1607f95d4633SHajimu UMEMOTO case IPV6_2292HOPOPTS: 1608f95d4633SHajimu UMEMOTO case IPV6_2292DSTOPTS: 1609f95d4633SHajimu UMEMOTO case IPV6_2292RTHDR: 161033841545SHajimu UMEMOTO /* RFC 2292 */ 161133841545SHajimu UMEMOTO if (optlen != sizeof(int)) { 161233841545SHajimu UMEMOTO error = EINVAL; 161333841545SHajimu UMEMOTO break; 161433841545SHajimu UMEMOTO } 161533841545SHajimu UMEMOTO error = sooptcopyin(sopt, &optval, 161633841545SHajimu UMEMOTO sizeof optval, sizeof optval); 161733841545SHajimu UMEMOTO if (error) 161833841545SHajimu UMEMOTO break; 161933841545SHajimu UMEMOTO switch (optname) { 1620f95d4633SHajimu UMEMOTO case IPV6_2292PKTINFO: 1621f95d4633SHajimu UMEMOTO OPTSET2292(IN6P_PKTINFO); 162233841545SHajimu UMEMOTO break; 1623f95d4633SHajimu UMEMOTO case IPV6_2292HOPLIMIT: 1624f95d4633SHajimu UMEMOTO OPTSET2292(IN6P_HOPLIMIT); 162533841545SHajimu UMEMOTO break; 1626f95d4633SHajimu UMEMOTO case IPV6_2292HOPOPTS: 162733841545SHajimu UMEMOTO /* 162833841545SHajimu UMEMOTO * Check super-user privilege. 162933841545SHajimu UMEMOTO * See comments for IPV6_RECVHOPOPTS. 163033841545SHajimu UMEMOTO */ 163133841545SHajimu UMEMOTO if (!privileged) 163233841545SHajimu UMEMOTO return (EPERM); 1633f95d4633SHajimu UMEMOTO OPTSET2292(IN6P_HOPOPTS); 163433841545SHajimu UMEMOTO break; 1635f95d4633SHajimu UMEMOTO case IPV6_2292DSTOPTS: 163633841545SHajimu UMEMOTO if (!privileged) 163733841545SHajimu UMEMOTO return (EPERM); 1638f95d4633SHajimu UMEMOTO OPTSET2292(IN6P_DSTOPTS|IN6P_RTHDRDSTOPTS); /* XXX */ 163933841545SHajimu UMEMOTO break; 1640f95d4633SHajimu UMEMOTO case IPV6_2292RTHDR: 1641f95d4633SHajimu UMEMOTO OPTSET2292(IN6P_RTHDR); 164233841545SHajimu UMEMOTO break; 164382cd038dSYoshinobu Inoue } 164482cd038dSYoshinobu Inoue break; 1645f95d4633SHajimu UMEMOTO case IPV6_PKTINFO: 1646f95d4633SHajimu UMEMOTO case IPV6_HOPOPTS: 1647f95d4633SHajimu UMEMOTO case IPV6_RTHDR: 1648f95d4633SHajimu UMEMOTO case IPV6_DSTOPTS: 1649f95d4633SHajimu UMEMOTO case IPV6_RTHDRDSTOPTS: 1650f95d4633SHajimu UMEMOTO case IPV6_NEXTHOP: 1651f95d4633SHajimu UMEMOTO { 165218b35df8SHajimu UMEMOTO /* new advanced API (RFC3542) */ 1653f95d4633SHajimu UMEMOTO u_char *optbuf; 1654e770771aSHajimu UMEMOTO u_char optbuf_storage[MCLBYTES]; 1655f95d4633SHajimu UMEMOTO int optlen; 1656f95d4633SHajimu UMEMOTO struct ip6_pktopts **optp; 1657f95d4633SHajimu UMEMOTO 1658f95d4633SHajimu UMEMOTO /* cannot mix with RFC2292 */ 1659f95d4633SHajimu UMEMOTO if (OPTBIT(IN6P_RFC2292)) { 1660f95d4633SHajimu UMEMOTO error = EINVAL; 1661f95d4633SHajimu UMEMOTO break; 1662f95d4633SHajimu UMEMOTO } 1663f95d4633SHajimu UMEMOTO 1664e770771aSHajimu UMEMOTO /* 1665e770771aSHajimu UMEMOTO * We only ensure valsize is not too large 1666e770771aSHajimu UMEMOTO * here. Further validation will be done 1667e770771aSHajimu UMEMOTO * later. 1668e770771aSHajimu UMEMOTO */ 1669e770771aSHajimu UMEMOTO error = sooptcopyin(sopt, optbuf_storage, 1670e770771aSHajimu UMEMOTO sizeof(optbuf_storage), 0); 1671a5d1aae3SHajimu UMEMOTO if (error) 1672a5d1aae3SHajimu UMEMOTO break; 1673f95d4633SHajimu UMEMOTO optlen = sopt->sopt_valsize; 1674e770771aSHajimu UMEMOTO optbuf = optbuf_storage; 1675f95d4633SHajimu UMEMOTO optp = &in6p->in6p_outputopts; 1676f95d4633SHajimu UMEMOTO error = ip6_pcbopt(optname, 1677f95d4633SHajimu UMEMOTO optbuf, optlen, 1678f95d4633SHajimu UMEMOTO optp, privileged, uproto); 1679f95d4633SHajimu UMEMOTO break; 1680f95d4633SHajimu UMEMOTO } 168182cd038dSYoshinobu Inoue #undef OPTSET 168282cd038dSYoshinobu Inoue 168382cd038dSYoshinobu Inoue case IPV6_MULTICAST_IF: 168482cd038dSYoshinobu Inoue case IPV6_MULTICAST_HOPS: 168582cd038dSYoshinobu Inoue case IPV6_MULTICAST_LOOP: 168682cd038dSYoshinobu Inoue case IPV6_JOIN_GROUP: 168782cd038dSYoshinobu Inoue case IPV6_LEAVE_GROUP: 168882cd038dSYoshinobu Inoue { 168982cd038dSYoshinobu Inoue if (sopt->sopt_valsize > MLEN) { 169082cd038dSYoshinobu Inoue error = EMSGSIZE; 169182cd038dSYoshinobu Inoue break; 169282cd038dSYoshinobu Inoue } 169382cd038dSYoshinobu Inoue /* XXX */ 1694f95d4633SHajimu UMEMOTO } 1695f95d4633SHajimu UMEMOTO /* FALLTHROUGH */ 1696f95d4633SHajimu UMEMOTO { 1697f95d4633SHajimu UMEMOTO struct mbuf *m; 1698f95d4633SHajimu UMEMOTO 1699f95d4633SHajimu UMEMOTO if (sopt->sopt_valsize > MCLBYTES) { 1700f95d4633SHajimu UMEMOTO error = EMSGSIZE; 1701f95d4633SHajimu UMEMOTO break; 1702f95d4633SHajimu UMEMOTO } 1703f95d4633SHajimu UMEMOTO /* XXX */ 1704e0aec682SAndre Oppermann MGET(m, sopt->sopt_td ? M_WAIT : M_DONTWAIT, MT_DATA); 170582cd038dSYoshinobu Inoue if (m == 0) { 170682cd038dSYoshinobu Inoue error = ENOBUFS; 170782cd038dSYoshinobu Inoue break; 170882cd038dSYoshinobu Inoue } 1709f95d4633SHajimu UMEMOTO if (sopt->sopt_valsize > MLEN) { 1710f95d4633SHajimu UMEMOTO MCLGET(m, sopt->sopt_td ? M_WAIT : M_DONTWAIT); 1711f95d4633SHajimu UMEMOTO if ((m->m_flags & M_EXT) == 0) { 1712f95d4633SHajimu UMEMOTO m_free(m); 1713f95d4633SHajimu UMEMOTO error = ENOBUFS; 1714f95d4633SHajimu UMEMOTO break; 1715f95d4633SHajimu UMEMOTO } 1716f95d4633SHajimu UMEMOTO } 171782cd038dSYoshinobu Inoue m->m_len = sopt->sopt_valsize; 171882cd038dSYoshinobu Inoue error = sooptcopyin(sopt, mtod(m, char *), 171982cd038dSYoshinobu Inoue m->m_len, m->m_len); 1720f95d4633SHajimu UMEMOTO if (error) { 1721f95d4633SHajimu UMEMOTO (void)m_free(m); 1722f95d4633SHajimu UMEMOTO break; 1723f95d4633SHajimu UMEMOTO } 172482cd038dSYoshinobu Inoue error = ip6_setmoptions(sopt->sopt_name, 172582cd038dSYoshinobu Inoue &in6p->in6p_moptions, 172682cd038dSYoshinobu Inoue m); 172782cd038dSYoshinobu Inoue (void)m_free(m); 172882cd038dSYoshinobu Inoue } 172982cd038dSYoshinobu Inoue break; 173082cd038dSYoshinobu Inoue 173182cd038dSYoshinobu Inoue case IPV6_PORTRANGE: 1732686cdd19SJun-ichiro itojun Hagino error = sooptcopyin(sopt, &optval, 1733686cdd19SJun-ichiro itojun Hagino sizeof optval, sizeof optval); 173482cd038dSYoshinobu Inoue if (error) 173582cd038dSYoshinobu Inoue break; 173682cd038dSYoshinobu Inoue 173782cd038dSYoshinobu Inoue switch (optval) { 173882cd038dSYoshinobu Inoue case IPV6_PORTRANGE_DEFAULT: 173982cd038dSYoshinobu Inoue in6p->in6p_flags &= ~(IN6P_LOWPORT); 174082cd038dSYoshinobu Inoue in6p->in6p_flags &= ~(IN6P_HIGHPORT); 174182cd038dSYoshinobu Inoue break; 174282cd038dSYoshinobu Inoue 174382cd038dSYoshinobu Inoue case IPV6_PORTRANGE_HIGH: 174482cd038dSYoshinobu Inoue in6p->in6p_flags &= ~(IN6P_LOWPORT); 174582cd038dSYoshinobu Inoue in6p->in6p_flags |= IN6P_HIGHPORT; 174682cd038dSYoshinobu Inoue break; 174782cd038dSYoshinobu Inoue 174882cd038dSYoshinobu Inoue case IPV6_PORTRANGE_LOW: 174982cd038dSYoshinobu Inoue in6p->in6p_flags &= ~(IN6P_HIGHPORT); 175082cd038dSYoshinobu Inoue in6p->in6p_flags |= IN6P_LOWPORT; 175182cd038dSYoshinobu Inoue break; 175282cd038dSYoshinobu Inoue 175382cd038dSYoshinobu Inoue default: 175482cd038dSYoshinobu Inoue error = EINVAL; 175582cd038dSYoshinobu Inoue break; 175682cd038dSYoshinobu Inoue } 175782cd038dSYoshinobu Inoue break; 175882cd038dSYoshinobu Inoue 1759b2630c29SGeorge V. Neville-Neil #ifdef IPSEC 176082cd038dSYoshinobu Inoue case IPV6_IPSEC_POLICY: 176182cd038dSYoshinobu Inoue { 176282cd038dSYoshinobu Inoue caddr_t req = NULL; 1763686cdd19SJun-ichiro itojun Hagino size_t len = 0; 176482cd038dSYoshinobu Inoue struct mbuf *m; 176582cd038dSYoshinobu Inoue 1766686cdd19SJun-ichiro itojun Hagino if ((error = soopt_getm(sopt, &m)) != 0) /* XXX */ 176782cd038dSYoshinobu Inoue break; 1768686cdd19SJun-ichiro itojun Hagino if ((error = soopt_mcopyin(sopt, m)) != 0) /* XXX */ 176982cd038dSYoshinobu Inoue break; 1770686cdd19SJun-ichiro itojun Hagino if (m) { 177182cd038dSYoshinobu Inoue req = mtod(m, caddr_t); 1772686cdd19SJun-ichiro itojun Hagino len = m->m_len; 1773686cdd19SJun-ichiro itojun Hagino } 177482cd038dSYoshinobu Inoue error = ipsec6_set_policy(in6p, optname, req, 1775686cdd19SJun-ichiro itojun Hagino len, privileged); 177682cd038dSYoshinobu Inoue m_freem(m); 177782cd038dSYoshinobu Inoue } 177882cd038dSYoshinobu Inoue break; 1779b2630c29SGeorge V. Neville-Neil #endif /* IPSEC */ 178082cd038dSYoshinobu Inoue 178182cd038dSYoshinobu Inoue default: 178282cd038dSYoshinobu Inoue error = ENOPROTOOPT; 178382cd038dSYoshinobu Inoue break; 178482cd038dSYoshinobu Inoue } 178582cd038dSYoshinobu Inoue break; 178682cd038dSYoshinobu Inoue 178782cd038dSYoshinobu Inoue case SOPT_GET: 178882cd038dSYoshinobu Inoue switch (optname) { 178982cd038dSYoshinobu Inoue 1790f95d4633SHajimu UMEMOTO case IPV6_2292PKTOPTIONS: 1791f95d4633SHajimu UMEMOTO #ifdef IPV6_PKTOPTIONS 179282cd038dSYoshinobu Inoue case IPV6_PKTOPTIONS: 1793f95d4633SHajimu UMEMOTO #endif 1794f95d4633SHajimu UMEMOTO /* 1795f95d4633SHajimu UMEMOTO * RFC3542 (effectively) deprecated the 1796f95d4633SHajimu UMEMOTO * semantics of the 2292-style pktoptions. 1797f95d4633SHajimu UMEMOTO * Since it was not reliable in nature (i.e., 1798f95d4633SHajimu UMEMOTO * applications had to expect the lack of some 1799f95d4633SHajimu UMEMOTO * information after all), it would make sense 1800f95d4633SHajimu UMEMOTO * to simplify this part by always returning 1801f95d4633SHajimu UMEMOTO * empty data. 1802f95d4633SHajimu UMEMOTO */ 180382cd038dSYoshinobu Inoue sopt->sopt_valsize = 0; 180482cd038dSYoshinobu Inoue break; 180582cd038dSYoshinobu Inoue 1806f95d4633SHajimu UMEMOTO case IPV6_RECVHOPOPTS: 1807f95d4633SHajimu UMEMOTO case IPV6_RECVDSTOPTS: 1808f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDRDSTOPTS: 180982cd038dSYoshinobu Inoue case IPV6_UNICAST_HOPS: 1810f95d4633SHajimu UMEMOTO case IPV6_RECVPKTINFO: 1811f95d4633SHajimu UMEMOTO case IPV6_RECVHOPLIMIT: 1812f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDR: 1813f95d4633SHajimu UMEMOTO case IPV6_RECVPATHMTU: 181433841545SHajimu UMEMOTO 181582cd038dSYoshinobu Inoue case IPV6_FAITH: 181633841545SHajimu UMEMOTO case IPV6_V6ONLY: 1817fa310a7eSYoshinobu Inoue case IPV6_PORTRANGE: 1818f95d4633SHajimu UMEMOTO case IPV6_RECVTCLASS: 1819f95d4633SHajimu UMEMOTO case IPV6_AUTOFLOWLABEL: 182082cd038dSYoshinobu Inoue switch (optname) { 182182cd038dSYoshinobu Inoue 1822f95d4633SHajimu UMEMOTO case IPV6_RECVHOPOPTS: 1823f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_HOPOPTS); 1824f95d4633SHajimu UMEMOTO break; 1825f95d4633SHajimu UMEMOTO 1826f95d4633SHajimu UMEMOTO case IPV6_RECVDSTOPTS: 1827f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_DSTOPTS); 1828f95d4633SHajimu UMEMOTO break; 1829f95d4633SHajimu UMEMOTO 1830f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDRDSTOPTS: 1831f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_RTHDRDSTOPTS); 1832f95d4633SHajimu UMEMOTO break; 1833f95d4633SHajimu UMEMOTO 183482cd038dSYoshinobu Inoue case IPV6_UNICAST_HOPS: 183582cd038dSYoshinobu Inoue optval = in6p->in6p_hops; 183682cd038dSYoshinobu Inoue break; 183782cd038dSYoshinobu Inoue 1838f95d4633SHajimu UMEMOTO case IPV6_RECVPKTINFO: 1839f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_PKTINFO); 1840f95d4633SHajimu UMEMOTO break; 1841f95d4633SHajimu UMEMOTO 1842f95d4633SHajimu UMEMOTO case IPV6_RECVHOPLIMIT: 1843f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_HOPLIMIT); 1844f95d4633SHajimu UMEMOTO break; 1845f95d4633SHajimu UMEMOTO 1846f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDR: 1847f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_RTHDR); 1848f95d4633SHajimu UMEMOTO break; 1849f95d4633SHajimu UMEMOTO 1850f95d4633SHajimu UMEMOTO case IPV6_RECVPATHMTU: 1851f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_MTU); 185282cd038dSYoshinobu Inoue break; 185382cd038dSYoshinobu Inoue 185482cd038dSYoshinobu Inoue case IPV6_FAITH: 185582cd038dSYoshinobu Inoue optval = OPTBIT(IN6P_FAITH); 185682cd038dSYoshinobu Inoue break; 185782cd038dSYoshinobu Inoue 185833841545SHajimu UMEMOTO case IPV6_V6ONLY: 1859854d3b19SHajimu UMEMOTO optval = OPTBIT(IN6P_IPV6_V6ONLY); 186082cd038dSYoshinobu Inoue break; 186182cd038dSYoshinobu Inoue 186282cd038dSYoshinobu Inoue case IPV6_PORTRANGE: 186382cd038dSYoshinobu Inoue { 186482cd038dSYoshinobu Inoue int flags; 186582cd038dSYoshinobu Inoue flags = in6p->in6p_flags; 186682cd038dSYoshinobu Inoue if (flags & IN6P_HIGHPORT) 186782cd038dSYoshinobu Inoue optval = IPV6_PORTRANGE_HIGH; 186882cd038dSYoshinobu Inoue else if (flags & IN6P_LOWPORT) 186982cd038dSYoshinobu Inoue optval = IPV6_PORTRANGE_LOW; 187082cd038dSYoshinobu Inoue else 187182cd038dSYoshinobu Inoue optval = 0; 187282cd038dSYoshinobu Inoue break; 187382cd038dSYoshinobu Inoue } 1874f95d4633SHajimu UMEMOTO case IPV6_RECVTCLASS: 1875f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_TCLASS); 1876f95d4633SHajimu UMEMOTO break; 1877f95d4633SHajimu UMEMOTO 1878f95d4633SHajimu UMEMOTO case IPV6_AUTOFLOWLABEL: 1879f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_AUTOFLOWLABEL); 1880f95d4633SHajimu UMEMOTO break; 188182cd038dSYoshinobu Inoue } 1882f95d4633SHajimu UMEMOTO if (error) 1883f95d4633SHajimu UMEMOTO break; 188482cd038dSYoshinobu Inoue error = sooptcopyout(sopt, &optval, 188582cd038dSYoshinobu Inoue sizeof optval); 188682cd038dSYoshinobu Inoue break; 188782cd038dSYoshinobu Inoue 1888f95d4633SHajimu UMEMOTO case IPV6_PATHMTU: 1889f95d4633SHajimu UMEMOTO { 1890f95d4633SHajimu UMEMOTO u_long pmtu = 0; 1891f95d4633SHajimu UMEMOTO struct ip6_mtuinfo mtuinfo; 189297d8d152SAndre Oppermann struct route_in6 sro; 189397d8d152SAndre Oppermann 189497d8d152SAndre Oppermann bzero(&sro, sizeof(sro)); 1895f95d4633SHajimu UMEMOTO 1896f95d4633SHajimu UMEMOTO if (!(so->so_state & SS_ISCONNECTED)) 1897f95d4633SHajimu UMEMOTO return (ENOTCONN); 1898f95d4633SHajimu UMEMOTO /* 1899f95d4633SHajimu UMEMOTO * XXX: we dot not consider the case of source 1900f95d4633SHajimu UMEMOTO * routing, or optional information to specify 1901f95d4633SHajimu UMEMOTO * the outgoing interface. 1902f95d4633SHajimu UMEMOTO */ 190397d8d152SAndre Oppermann error = ip6_getpmtu(&sro, NULL, NULL, 1904f95d4633SHajimu UMEMOTO &in6p->in6p_faddr, &pmtu, NULL); 190597d8d152SAndre Oppermann if (sro.ro_rt) 190697d8d152SAndre Oppermann RTFREE(sro.ro_rt); 1907f95d4633SHajimu UMEMOTO if (error) 1908f95d4633SHajimu UMEMOTO break; 1909f95d4633SHajimu UMEMOTO if (pmtu > IPV6_MAXPACKET) 1910f95d4633SHajimu UMEMOTO pmtu = IPV6_MAXPACKET; 1911f95d4633SHajimu UMEMOTO 1912f95d4633SHajimu UMEMOTO bzero(&mtuinfo, sizeof(mtuinfo)); 1913f95d4633SHajimu UMEMOTO mtuinfo.ip6m_mtu = (u_int32_t)pmtu; 1914f95d4633SHajimu UMEMOTO optdata = (void *)&mtuinfo; 1915f95d4633SHajimu UMEMOTO optdatalen = sizeof(mtuinfo); 1916f95d4633SHajimu UMEMOTO error = sooptcopyout(sopt, optdata, 1917f95d4633SHajimu UMEMOTO optdatalen); 1918f95d4633SHajimu UMEMOTO break; 1919f95d4633SHajimu UMEMOTO } 1920f95d4633SHajimu UMEMOTO 1921f95d4633SHajimu UMEMOTO case IPV6_2292PKTINFO: 1922f95d4633SHajimu UMEMOTO case IPV6_2292HOPLIMIT: 1923f95d4633SHajimu UMEMOTO case IPV6_2292HOPOPTS: 1924f95d4633SHajimu UMEMOTO case IPV6_2292RTHDR: 1925f95d4633SHajimu UMEMOTO case IPV6_2292DSTOPTS: 192633841545SHajimu UMEMOTO switch (optname) { 1927f95d4633SHajimu UMEMOTO case IPV6_2292PKTINFO: 192833841545SHajimu UMEMOTO optval = OPTBIT(IN6P_PKTINFO); 192933841545SHajimu UMEMOTO break; 1930f95d4633SHajimu UMEMOTO case IPV6_2292HOPLIMIT: 193133841545SHajimu UMEMOTO optval = OPTBIT(IN6P_HOPLIMIT); 193233841545SHajimu UMEMOTO break; 1933f95d4633SHajimu UMEMOTO case IPV6_2292HOPOPTS: 193433841545SHajimu UMEMOTO optval = OPTBIT(IN6P_HOPOPTS); 193533841545SHajimu UMEMOTO break; 1936f95d4633SHajimu UMEMOTO case IPV6_2292RTHDR: 193733841545SHajimu UMEMOTO optval = OPTBIT(IN6P_RTHDR); 193833841545SHajimu UMEMOTO break; 1939f95d4633SHajimu UMEMOTO case IPV6_2292DSTOPTS: 194033841545SHajimu UMEMOTO optval = OPTBIT(IN6P_DSTOPTS|IN6P_RTHDRDSTOPTS); 194133841545SHajimu UMEMOTO break; 194233841545SHajimu UMEMOTO } 194333841545SHajimu UMEMOTO error = sooptcopyout(sopt, &optval, 194433841545SHajimu UMEMOTO sizeof optval); 194533841545SHajimu UMEMOTO break; 1946f95d4633SHajimu UMEMOTO case IPV6_PKTINFO: 1947f95d4633SHajimu UMEMOTO case IPV6_HOPOPTS: 1948f95d4633SHajimu UMEMOTO case IPV6_RTHDR: 1949f95d4633SHajimu UMEMOTO case IPV6_DSTOPTS: 1950f95d4633SHajimu UMEMOTO case IPV6_RTHDRDSTOPTS: 1951f95d4633SHajimu UMEMOTO case IPV6_NEXTHOP: 1952f95d4633SHajimu UMEMOTO case IPV6_TCLASS: 1953f95d4633SHajimu UMEMOTO case IPV6_DONTFRAG: 1954f95d4633SHajimu UMEMOTO case IPV6_USE_MIN_MTU: 1955f95d4633SHajimu UMEMOTO case IPV6_PREFER_TEMPADDR: 1956f95d4633SHajimu UMEMOTO error = ip6_getpcbopt(in6p->in6p_outputopts, 1957f95d4633SHajimu UMEMOTO optname, sopt); 1958f95d4633SHajimu UMEMOTO break; 195933841545SHajimu UMEMOTO 196082cd038dSYoshinobu Inoue case IPV6_MULTICAST_IF: 196182cd038dSYoshinobu Inoue case IPV6_MULTICAST_HOPS: 196282cd038dSYoshinobu Inoue case IPV6_MULTICAST_LOOP: 196382cd038dSYoshinobu Inoue case IPV6_JOIN_GROUP: 196482cd038dSYoshinobu Inoue case IPV6_LEAVE_GROUP: 196582cd038dSYoshinobu Inoue { 196682cd038dSYoshinobu Inoue struct mbuf *m; 196782cd038dSYoshinobu Inoue error = ip6_getmoptions(sopt->sopt_name, 196882cd038dSYoshinobu Inoue in6p->in6p_moptions, &m); 196982cd038dSYoshinobu Inoue if (error == 0) 197082cd038dSYoshinobu Inoue error = sooptcopyout(sopt, 197182cd038dSYoshinobu Inoue mtod(m, char *), m->m_len); 197282cd038dSYoshinobu Inoue m_freem(m); 197382cd038dSYoshinobu Inoue } 197482cd038dSYoshinobu Inoue break; 197582cd038dSYoshinobu Inoue 1976b2630c29SGeorge V. Neville-Neil #ifdef IPSEC 197782cd038dSYoshinobu Inoue case IPV6_IPSEC_POLICY: 197882cd038dSYoshinobu Inoue { 1979f63e7634SYoshinobu Inoue caddr_t req = NULL; 1980686cdd19SJun-ichiro itojun Hagino size_t len = 0; 1981686cdd19SJun-ichiro itojun Hagino struct mbuf *m = NULL; 1982686cdd19SJun-ichiro itojun Hagino struct mbuf **mp = &m; 1983f95d4633SHajimu UMEMOTO size_t ovalsize = sopt->sopt_valsize; 1984f95d4633SHajimu UMEMOTO caddr_t oval = (caddr_t)sopt->sopt_val; 1985f63e7634SYoshinobu Inoue 1986686cdd19SJun-ichiro itojun Hagino error = soopt_getm(sopt, &m); /* XXX */ 1987a46f7e7cSHajimu UMEMOTO if (error != 0) 1988686cdd19SJun-ichiro itojun Hagino break; 1989686cdd19SJun-ichiro itojun Hagino error = soopt_mcopyin(sopt, m); /* XXX */ 1990a46f7e7cSHajimu UMEMOTO if (error != 0) 1991686cdd19SJun-ichiro itojun Hagino break; 1992f95d4633SHajimu UMEMOTO sopt->sopt_valsize = ovalsize; 1993f95d4633SHajimu UMEMOTO sopt->sopt_val = oval; 1994686cdd19SJun-ichiro itojun Hagino if (m) { 199582cd038dSYoshinobu Inoue req = mtod(m, caddr_t); 1996686cdd19SJun-ichiro itojun Hagino len = m->m_len; 1997686cdd19SJun-ichiro itojun Hagino } 1998686cdd19SJun-ichiro itojun Hagino error = ipsec6_get_policy(in6p, req, len, mp); 199982cd038dSYoshinobu Inoue if (error == 0) 200082cd038dSYoshinobu Inoue error = soopt_mcopyout(sopt, m); /* XXX */ 200133841545SHajimu UMEMOTO if (error == 0 && m) 200282cd038dSYoshinobu Inoue m_freem(m); 200382cd038dSYoshinobu Inoue break; 200482cd038dSYoshinobu Inoue } 2005b2630c29SGeorge V. Neville-Neil #endif /* IPSEC */ 200682cd038dSYoshinobu Inoue 200782cd038dSYoshinobu Inoue default: 200882cd038dSYoshinobu Inoue error = ENOPROTOOPT; 200982cd038dSYoshinobu Inoue break; 201082cd038dSYoshinobu Inoue } 201182cd038dSYoshinobu Inoue break; 201282cd038dSYoshinobu Inoue } 2013f95d4633SHajimu UMEMOTO } else { /* level != IPPROTO_IPV6 */ 201482cd038dSYoshinobu Inoue error = EINVAL; 201582cd038dSYoshinobu Inoue } 201682cd038dSYoshinobu Inoue return (error); 201782cd038dSYoshinobu Inoue } 201882cd038dSYoshinobu Inoue 201902b9a206SHajimu UMEMOTO int 20201272577eSXin LI ip6_raw_ctloutput(struct socket *so, struct sockopt *sopt) 202102b9a206SHajimu UMEMOTO { 202202b9a206SHajimu UMEMOTO int error = 0, optval, optlen; 202302b9a206SHajimu UMEMOTO const int icmp6off = offsetof(struct icmp6_hdr, icmp6_cksum); 202402b9a206SHajimu UMEMOTO struct in6pcb *in6p = sotoin6pcb(so); 202502b9a206SHajimu UMEMOTO int level, op, optname; 202602b9a206SHajimu UMEMOTO 202702b9a206SHajimu UMEMOTO if (sopt) { 202802b9a206SHajimu UMEMOTO level = sopt->sopt_level; 202902b9a206SHajimu UMEMOTO op = sopt->sopt_dir; 203002b9a206SHajimu UMEMOTO optname = sopt->sopt_name; 203102b9a206SHajimu UMEMOTO optlen = sopt->sopt_valsize; 203202b9a206SHajimu UMEMOTO } else 203302b9a206SHajimu UMEMOTO panic("ip6_raw_ctloutput: arg soopt is NULL"); 203402b9a206SHajimu UMEMOTO 203502b9a206SHajimu UMEMOTO if (level != IPPROTO_IPV6) { 203602b9a206SHajimu UMEMOTO return (EINVAL); 203702b9a206SHajimu UMEMOTO } 203802b9a206SHajimu UMEMOTO 203902b9a206SHajimu UMEMOTO switch (optname) { 204002b9a206SHajimu UMEMOTO case IPV6_CHECKSUM: 204102b9a206SHajimu UMEMOTO /* 204202b9a206SHajimu UMEMOTO * For ICMPv6 sockets, no modification allowed for checksum 204302b9a206SHajimu UMEMOTO * offset, permit "no change" values to help existing apps. 204402b9a206SHajimu UMEMOTO * 204518b35df8SHajimu UMEMOTO * RFC3542 says: "An attempt to set IPV6_CHECKSUM 204602b9a206SHajimu UMEMOTO * for an ICMPv6 socket will fail." 204718b35df8SHajimu UMEMOTO * The current behavior does not meet RFC3542. 204802b9a206SHajimu UMEMOTO */ 204902b9a206SHajimu UMEMOTO switch (op) { 205002b9a206SHajimu UMEMOTO case SOPT_SET: 205102b9a206SHajimu UMEMOTO if (optlen != sizeof(int)) { 205202b9a206SHajimu UMEMOTO error = EINVAL; 205302b9a206SHajimu UMEMOTO break; 205402b9a206SHajimu UMEMOTO } 205502b9a206SHajimu UMEMOTO error = sooptcopyin(sopt, &optval, sizeof(optval), 205602b9a206SHajimu UMEMOTO sizeof(optval)); 205702b9a206SHajimu UMEMOTO if (error) 205802b9a206SHajimu UMEMOTO break; 205902b9a206SHajimu UMEMOTO if ((optval % 2) != 0) { 206002b9a206SHajimu UMEMOTO /* the API assumes even offset values */ 206102b9a206SHajimu UMEMOTO error = EINVAL; 206202b9a206SHajimu UMEMOTO } else if (so->so_proto->pr_protocol == 206302b9a206SHajimu UMEMOTO IPPROTO_ICMPV6) { 206402b9a206SHajimu UMEMOTO if (optval != icmp6off) 206502b9a206SHajimu UMEMOTO error = EINVAL; 206602b9a206SHajimu UMEMOTO } else 206702b9a206SHajimu UMEMOTO in6p->in6p_cksum = optval; 206802b9a206SHajimu UMEMOTO break; 206902b9a206SHajimu UMEMOTO 207002b9a206SHajimu UMEMOTO case SOPT_GET: 207102b9a206SHajimu UMEMOTO if (so->so_proto->pr_protocol == IPPROTO_ICMPV6) 207202b9a206SHajimu UMEMOTO optval = icmp6off; 207302b9a206SHajimu UMEMOTO else 207402b9a206SHajimu UMEMOTO optval = in6p->in6p_cksum; 207502b9a206SHajimu UMEMOTO 207602b9a206SHajimu UMEMOTO error = sooptcopyout(sopt, &optval, sizeof(optval)); 207702b9a206SHajimu UMEMOTO break; 207802b9a206SHajimu UMEMOTO 207902b9a206SHajimu UMEMOTO default: 208002b9a206SHajimu UMEMOTO error = EINVAL; 208102b9a206SHajimu UMEMOTO break; 208202b9a206SHajimu UMEMOTO } 208302b9a206SHajimu UMEMOTO break; 208402b9a206SHajimu UMEMOTO 208502b9a206SHajimu UMEMOTO default: 208602b9a206SHajimu UMEMOTO error = ENOPROTOOPT; 208702b9a206SHajimu UMEMOTO break; 208802b9a206SHajimu UMEMOTO } 208902b9a206SHajimu UMEMOTO 209002b9a206SHajimu UMEMOTO return (error); 209102b9a206SHajimu UMEMOTO } 209202b9a206SHajimu UMEMOTO 209382cd038dSYoshinobu Inoue /* 209433841545SHajimu UMEMOTO * Set up IP6 options in pcb for insertion in output packets or 209533841545SHajimu UMEMOTO * specifying behavior of outgoing packets. 209682cd038dSYoshinobu Inoue */ 209782cd038dSYoshinobu Inoue static int 20981272577eSXin LI ip6_pcbopts(struct ip6_pktopts **pktopt, struct mbuf *m, 20991272577eSXin LI struct socket *so, struct sockopt *sopt) 210082cd038dSYoshinobu Inoue { 210133841545SHajimu UMEMOTO struct ip6_pktopts *opt = *pktopt; 210282cd038dSYoshinobu Inoue int error = 0; 2103b40ce416SJulian Elischer struct thread *td = sopt->sopt_td; 210482cd038dSYoshinobu Inoue int priv = 0; 210582cd038dSYoshinobu Inoue 210682cd038dSYoshinobu Inoue /* turn off any old options. */ 210782cd038dSYoshinobu Inoue if (opt) { 210833841545SHajimu UMEMOTO #ifdef DIAGNOSTIC 210933841545SHajimu UMEMOTO if (opt->ip6po_pktinfo || opt->ip6po_nexthop || 211033841545SHajimu UMEMOTO opt->ip6po_hbh || opt->ip6po_dest1 || opt->ip6po_dest2 || 211133841545SHajimu UMEMOTO opt->ip6po_rhinfo.ip6po_rhi_rthdr) 211233841545SHajimu UMEMOTO printf("ip6_pcbopts: all specified options are cleared.\n"); 211333841545SHajimu UMEMOTO #endif 2114f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, -1); 211582cd038dSYoshinobu Inoue } else 2116a163d034SWarner Losh opt = malloc(sizeof(*opt), M_IP6OPT, M_WAITOK); 211733841545SHajimu UMEMOTO *pktopt = NULL; 211882cd038dSYoshinobu Inoue 211982cd038dSYoshinobu Inoue if (!m || m->m_len == 0) { 212082cd038dSYoshinobu Inoue /* 212135f6695bSHajimu UMEMOTO * Only turning off any previous options, regardless of 212235f6695bSHajimu UMEMOTO * whether the opt is just created or given. 212382cd038dSYoshinobu Inoue */ 212482cd038dSYoshinobu Inoue free(opt, M_IP6OPT); 212582cd038dSYoshinobu Inoue return (0); 212682cd038dSYoshinobu Inoue } 212782cd038dSYoshinobu Inoue 212882cd038dSYoshinobu Inoue /* set options specified by user. */ 212944731cabSJohn Baldwin if (td && !suser(td)) 213082cd038dSYoshinobu Inoue priv = 1; 2131885adbfaSHajimu UMEMOTO if ((error = ip6_setpktopts(m, opt, NULL, priv, 2132f95d4633SHajimu UMEMOTO so->so_proto->pr_protocol)) != 0) { 2133f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, -1); /* XXX: discard all options */ 213435f6695bSHajimu UMEMOTO free(opt, M_IP6OPT); 213582cd038dSYoshinobu Inoue return (error); 213682cd038dSYoshinobu Inoue } 213782cd038dSYoshinobu Inoue *pktopt = opt; 213882cd038dSYoshinobu Inoue return (0); 213982cd038dSYoshinobu Inoue } 214082cd038dSYoshinobu Inoue 214182cd038dSYoshinobu Inoue /* 214233841545SHajimu UMEMOTO * initialize ip6_pktopts. beware that there are non-zero default values in 214333841545SHajimu UMEMOTO * the struct. 214433841545SHajimu UMEMOTO */ 214533841545SHajimu UMEMOTO void 21461272577eSXin LI ip6_initpktopts(struct ip6_pktopts *opt) 214733841545SHajimu UMEMOTO { 214833841545SHajimu UMEMOTO 214933841545SHajimu UMEMOTO bzero(opt, sizeof(*opt)); 215033841545SHajimu UMEMOTO opt->ip6po_hlim = -1; /* -1 means default hop limit */ 2151f95d4633SHajimu UMEMOTO opt->ip6po_tclass = -1; /* -1 means default traffic class */ 2152f95d4633SHajimu UMEMOTO opt->ip6po_minmtu = IP6PO_MINMTU_MCASTONLY; 2153f95d4633SHajimu UMEMOTO opt->ip6po_prefer_tempaddr = IP6PO_TEMPADDR_SYSTEM; 2154f95d4633SHajimu UMEMOTO } 2155f95d4633SHajimu UMEMOTO 2156f95d4633SHajimu UMEMOTO static int 21571272577eSXin LI ip6_pcbopt(int optname, u_char *buf, int len, struct ip6_pktopts **pktopt, 21581272577eSXin LI int priv, int uproto) 2159f95d4633SHajimu UMEMOTO { 2160f95d4633SHajimu UMEMOTO struct ip6_pktopts *opt; 2161f95d4633SHajimu UMEMOTO 2162f95d4633SHajimu UMEMOTO if (*pktopt == NULL) { 2163f95d4633SHajimu UMEMOTO *pktopt = malloc(sizeof(struct ip6_pktopts), M_IP6OPT, 2164f95d4633SHajimu UMEMOTO M_WAITOK); 2165d5e3406dSHajimu UMEMOTO ip6_initpktopts(*pktopt); 2166f95d4633SHajimu UMEMOTO } 2167f95d4633SHajimu UMEMOTO opt = *pktopt; 2168f95d4633SHajimu UMEMOTO 2169d5e3406dSHajimu UMEMOTO return (ip6_setpktopt(optname, buf, len, opt, priv, 1, 0, uproto)); 2170f95d4633SHajimu UMEMOTO } 2171f95d4633SHajimu UMEMOTO 2172f95d4633SHajimu UMEMOTO static int 21731272577eSXin LI ip6_getpcbopt(struct ip6_pktopts *pktopt, int optname, struct sockopt *sopt) 2174f95d4633SHajimu UMEMOTO { 2175f95d4633SHajimu UMEMOTO void *optdata = NULL; 2176f95d4633SHajimu UMEMOTO int optdatalen = 0; 2177f95d4633SHajimu UMEMOTO struct ip6_ext *ip6e; 2178f95d4633SHajimu UMEMOTO int error = 0; 2179f95d4633SHajimu UMEMOTO struct in6_pktinfo null_pktinfo; 2180f95d4633SHajimu UMEMOTO int deftclass = 0, on; 2181f95d4633SHajimu UMEMOTO int defminmtu = IP6PO_MINMTU_MCASTONLY; 2182f95d4633SHajimu UMEMOTO int defpreftemp = IP6PO_TEMPADDR_SYSTEM; 2183f95d4633SHajimu UMEMOTO 2184f95d4633SHajimu UMEMOTO switch (optname) { 2185f95d4633SHajimu UMEMOTO case IPV6_PKTINFO: 2186f95d4633SHajimu UMEMOTO if (pktopt && pktopt->ip6po_pktinfo) 2187f95d4633SHajimu UMEMOTO optdata = (void *)pktopt->ip6po_pktinfo; 2188f95d4633SHajimu UMEMOTO else { 2189f95d4633SHajimu UMEMOTO /* XXX: we don't have to do this every time... */ 2190f95d4633SHajimu UMEMOTO bzero(&null_pktinfo, sizeof(null_pktinfo)); 2191f95d4633SHajimu UMEMOTO optdata = (void *)&null_pktinfo; 2192f95d4633SHajimu UMEMOTO } 2193f95d4633SHajimu UMEMOTO optdatalen = sizeof(struct in6_pktinfo); 2194f95d4633SHajimu UMEMOTO break; 2195f95d4633SHajimu UMEMOTO case IPV6_TCLASS: 2196f95d4633SHajimu UMEMOTO if (pktopt && pktopt->ip6po_tclass >= 0) 2197f95d4633SHajimu UMEMOTO optdata = (void *)&pktopt->ip6po_tclass; 2198f95d4633SHajimu UMEMOTO else 2199f95d4633SHajimu UMEMOTO optdata = (void *)&deftclass; 2200f95d4633SHajimu UMEMOTO optdatalen = sizeof(int); 2201f95d4633SHajimu UMEMOTO break; 2202f95d4633SHajimu UMEMOTO case IPV6_HOPOPTS: 2203f95d4633SHajimu UMEMOTO if (pktopt && pktopt->ip6po_hbh) { 2204f95d4633SHajimu UMEMOTO optdata = (void *)pktopt->ip6po_hbh; 2205f95d4633SHajimu UMEMOTO ip6e = (struct ip6_ext *)pktopt->ip6po_hbh; 2206f95d4633SHajimu UMEMOTO optdatalen = (ip6e->ip6e_len + 1) << 3; 2207f95d4633SHajimu UMEMOTO } 2208f95d4633SHajimu UMEMOTO break; 2209f95d4633SHajimu UMEMOTO case IPV6_RTHDR: 2210f95d4633SHajimu UMEMOTO if (pktopt && pktopt->ip6po_rthdr) { 2211f95d4633SHajimu UMEMOTO optdata = (void *)pktopt->ip6po_rthdr; 2212f95d4633SHajimu UMEMOTO ip6e = (struct ip6_ext *)pktopt->ip6po_rthdr; 2213f95d4633SHajimu UMEMOTO optdatalen = (ip6e->ip6e_len + 1) << 3; 2214f95d4633SHajimu UMEMOTO } 2215f95d4633SHajimu UMEMOTO break; 2216f95d4633SHajimu UMEMOTO case IPV6_RTHDRDSTOPTS: 2217f95d4633SHajimu UMEMOTO if (pktopt && pktopt->ip6po_dest1) { 2218f95d4633SHajimu UMEMOTO optdata = (void *)pktopt->ip6po_dest1; 2219f95d4633SHajimu UMEMOTO ip6e = (struct ip6_ext *)pktopt->ip6po_dest1; 2220f95d4633SHajimu UMEMOTO optdatalen = (ip6e->ip6e_len + 1) << 3; 2221f95d4633SHajimu UMEMOTO } 2222f95d4633SHajimu UMEMOTO break; 2223f95d4633SHajimu UMEMOTO case IPV6_DSTOPTS: 2224f95d4633SHajimu UMEMOTO if (pktopt && pktopt->ip6po_dest2) { 2225f95d4633SHajimu UMEMOTO optdata = (void *)pktopt->ip6po_dest2; 2226f95d4633SHajimu UMEMOTO ip6e = (struct ip6_ext *)pktopt->ip6po_dest2; 2227f95d4633SHajimu UMEMOTO optdatalen = (ip6e->ip6e_len + 1) << 3; 2228f95d4633SHajimu UMEMOTO } 2229f95d4633SHajimu UMEMOTO break; 2230f95d4633SHajimu UMEMOTO case IPV6_NEXTHOP: 2231f95d4633SHajimu UMEMOTO if (pktopt && pktopt->ip6po_nexthop) { 2232f95d4633SHajimu UMEMOTO optdata = (void *)pktopt->ip6po_nexthop; 2233f95d4633SHajimu UMEMOTO optdatalen = pktopt->ip6po_nexthop->sa_len; 2234f95d4633SHajimu UMEMOTO } 2235f95d4633SHajimu UMEMOTO break; 2236f95d4633SHajimu UMEMOTO case IPV6_USE_MIN_MTU: 2237f95d4633SHajimu UMEMOTO if (pktopt) 2238f95d4633SHajimu UMEMOTO optdata = (void *)&pktopt->ip6po_minmtu; 2239f95d4633SHajimu UMEMOTO else 2240f95d4633SHajimu UMEMOTO optdata = (void *)&defminmtu; 2241f95d4633SHajimu UMEMOTO optdatalen = sizeof(int); 2242f95d4633SHajimu UMEMOTO break; 2243f95d4633SHajimu UMEMOTO case IPV6_DONTFRAG: 2244f95d4633SHajimu UMEMOTO if (pktopt && ((pktopt->ip6po_flags) & IP6PO_DONTFRAG)) 2245f95d4633SHajimu UMEMOTO on = 1; 2246f95d4633SHajimu UMEMOTO else 2247f95d4633SHajimu UMEMOTO on = 0; 2248f95d4633SHajimu UMEMOTO optdata = (void *)&on; 2249f95d4633SHajimu UMEMOTO optdatalen = sizeof(on); 2250f95d4633SHajimu UMEMOTO break; 2251f95d4633SHajimu UMEMOTO case IPV6_PREFER_TEMPADDR: 2252f95d4633SHajimu UMEMOTO if (pktopt) 2253f95d4633SHajimu UMEMOTO optdata = (void *)&pktopt->ip6po_prefer_tempaddr; 2254f95d4633SHajimu UMEMOTO else 2255f95d4633SHajimu UMEMOTO optdata = (void *)&defpreftemp; 2256f95d4633SHajimu UMEMOTO optdatalen = sizeof(int); 2257f95d4633SHajimu UMEMOTO break; 2258f95d4633SHajimu UMEMOTO default: /* should not happen */ 2259f95d4633SHajimu UMEMOTO #ifdef DIAGNOSTIC 2260f95d4633SHajimu UMEMOTO panic("ip6_getpcbopt: unexpected option\n"); 2261f95d4633SHajimu UMEMOTO #endif 2262f95d4633SHajimu UMEMOTO return (ENOPROTOOPT); 2263f95d4633SHajimu UMEMOTO } 2264f95d4633SHajimu UMEMOTO 2265f95d4633SHajimu UMEMOTO error = sooptcopyout(sopt, optdata, optdatalen); 2266f95d4633SHajimu UMEMOTO 2267f95d4633SHajimu UMEMOTO return (error); 226833841545SHajimu UMEMOTO } 226933841545SHajimu UMEMOTO 227033841545SHajimu UMEMOTO void 22711272577eSXin LI ip6_clearpktopts(struct ip6_pktopts *pktopt, int optname) 227233841545SHajimu UMEMOTO { 2273289b28bdSHajimu UMEMOTO if (pktopt == NULL) 2274289b28bdSHajimu UMEMOTO return; 2275289b28bdSHajimu UMEMOTO 2276f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_PKTINFO) { 2277885adbfaSHajimu UMEMOTO if (pktopt->ip6po_pktinfo) 227833841545SHajimu UMEMOTO free(pktopt->ip6po_pktinfo, M_IP6OPT); 227933841545SHajimu UMEMOTO pktopt->ip6po_pktinfo = NULL; 228033841545SHajimu UMEMOTO } 2281f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_HOPLIMIT) 228233841545SHajimu UMEMOTO pktopt->ip6po_hlim = -1; 2283f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_TCLASS) 2284f95d4633SHajimu UMEMOTO pktopt->ip6po_tclass = -1; 2285f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_NEXTHOP) { 2286f95d4633SHajimu UMEMOTO if (pktopt->ip6po_nextroute.ro_rt) { 2287f95d4633SHajimu UMEMOTO RTFREE(pktopt->ip6po_nextroute.ro_rt); 2288f95d4633SHajimu UMEMOTO pktopt->ip6po_nextroute.ro_rt = NULL; 2289f95d4633SHajimu UMEMOTO } 2290885adbfaSHajimu UMEMOTO if (pktopt->ip6po_nexthop) 229133841545SHajimu UMEMOTO free(pktopt->ip6po_nexthop, M_IP6OPT); 229233841545SHajimu UMEMOTO pktopt->ip6po_nexthop = NULL; 229333841545SHajimu UMEMOTO } 2294f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_HOPOPTS) { 2295885adbfaSHajimu UMEMOTO if (pktopt->ip6po_hbh) 229633841545SHajimu UMEMOTO free(pktopt->ip6po_hbh, M_IP6OPT); 229733841545SHajimu UMEMOTO pktopt->ip6po_hbh = NULL; 229833841545SHajimu UMEMOTO } 2299f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_RTHDRDSTOPTS) { 2300885adbfaSHajimu UMEMOTO if (pktopt->ip6po_dest1) 230133841545SHajimu UMEMOTO free(pktopt->ip6po_dest1, M_IP6OPT); 230233841545SHajimu UMEMOTO pktopt->ip6po_dest1 = NULL; 230333841545SHajimu UMEMOTO } 2304f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_RTHDR) { 2305885adbfaSHajimu UMEMOTO if (pktopt->ip6po_rhinfo.ip6po_rhi_rthdr) 230633841545SHajimu UMEMOTO free(pktopt->ip6po_rhinfo.ip6po_rhi_rthdr, M_IP6OPT); 230733841545SHajimu UMEMOTO pktopt->ip6po_rhinfo.ip6po_rhi_rthdr = NULL; 230833841545SHajimu UMEMOTO if (pktopt->ip6po_route.ro_rt) { 230933841545SHajimu UMEMOTO RTFREE(pktopt->ip6po_route.ro_rt); 231033841545SHajimu UMEMOTO pktopt->ip6po_route.ro_rt = NULL; 231133841545SHajimu UMEMOTO } 231233841545SHajimu UMEMOTO } 2313f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_DSTOPTS) { 2314885adbfaSHajimu UMEMOTO if (pktopt->ip6po_dest2) 231533841545SHajimu UMEMOTO free(pktopt->ip6po_dest2, M_IP6OPT); 231633841545SHajimu UMEMOTO pktopt->ip6po_dest2 = NULL; 231733841545SHajimu UMEMOTO } 231833841545SHajimu UMEMOTO } 231933841545SHajimu UMEMOTO 232033841545SHajimu UMEMOTO #define PKTOPT_EXTHDRCPY(type) \ 232133841545SHajimu UMEMOTO do {\ 232233841545SHajimu UMEMOTO if (src->type) {\ 23237efe5d92SHajimu UMEMOTO int hlen = (((struct ip6_ext *)src->type)->ip6e_len + 1) << 3;\ 232433841545SHajimu UMEMOTO dst->type = malloc(hlen, M_IP6OPT, canwait);\ 232533841545SHajimu UMEMOTO if (dst->type == NULL && canwait == M_NOWAIT)\ 232633841545SHajimu UMEMOTO goto bad;\ 232733841545SHajimu UMEMOTO bcopy(src->type, dst->type, hlen);\ 232833841545SHajimu UMEMOTO }\ 23297efe5d92SHajimu UMEMOTO } while (/*CONSTCOND*/ 0) 233033841545SHajimu UMEMOTO 2331885adbfaSHajimu UMEMOTO static int 23321272577eSXin LI copypktopts(struct ip6_pktopts *dst, struct ip6_pktopts *src, int canwait) 233333841545SHajimu UMEMOTO { 2334885adbfaSHajimu UMEMOTO if (dst == NULL || src == NULL) { 233533841545SHajimu UMEMOTO printf("ip6_clearpktopts: invalid argument\n"); 2336885adbfaSHajimu UMEMOTO return (EINVAL); 233733841545SHajimu UMEMOTO } 233833841545SHajimu UMEMOTO 233933841545SHajimu UMEMOTO dst->ip6po_hlim = src->ip6po_hlim; 2340f95d4633SHajimu UMEMOTO dst->ip6po_tclass = src->ip6po_tclass; 2341f95d4633SHajimu UMEMOTO dst->ip6po_flags = src->ip6po_flags; 234233841545SHajimu UMEMOTO if (src->ip6po_pktinfo) { 234333841545SHajimu UMEMOTO dst->ip6po_pktinfo = malloc(sizeof(*dst->ip6po_pktinfo), 234433841545SHajimu UMEMOTO M_IP6OPT, canwait); 23452cb64cb2SGeorge V. Neville-Neil if (dst->ip6po_pktinfo == NULL) 234633841545SHajimu UMEMOTO goto bad; 234733841545SHajimu UMEMOTO *dst->ip6po_pktinfo = *src->ip6po_pktinfo; 234833841545SHajimu UMEMOTO } 234933841545SHajimu UMEMOTO if (src->ip6po_nexthop) { 235033841545SHajimu UMEMOTO dst->ip6po_nexthop = malloc(src->ip6po_nexthop->sa_len, 235133841545SHajimu UMEMOTO M_IP6OPT, canwait); 2352403cbcf5SGeorge V. Neville-Neil if (dst->ip6po_nexthop == NULL) 235333841545SHajimu UMEMOTO goto bad; 235433841545SHajimu UMEMOTO bcopy(src->ip6po_nexthop, dst->ip6po_nexthop, 235533841545SHajimu UMEMOTO src->ip6po_nexthop->sa_len); 235633841545SHajimu UMEMOTO } 235733841545SHajimu UMEMOTO PKTOPT_EXTHDRCPY(ip6po_hbh); 235833841545SHajimu UMEMOTO PKTOPT_EXTHDRCPY(ip6po_dest1); 235933841545SHajimu UMEMOTO PKTOPT_EXTHDRCPY(ip6po_dest2); 236033841545SHajimu UMEMOTO PKTOPT_EXTHDRCPY(ip6po_rthdr); /* not copy the cached route */ 2361885adbfaSHajimu UMEMOTO return (0); 236233841545SHajimu UMEMOTO 236333841545SHajimu UMEMOTO bad: 236433841545SHajimu UMEMOTO if (dst->ip6po_pktinfo) free(dst->ip6po_pktinfo, M_IP6OPT); 236533841545SHajimu UMEMOTO if (dst->ip6po_nexthop) free(dst->ip6po_nexthop, M_IP6OPT); 236633841545SHajimu UMEMOTO if (dst->ip6po_hbh) free(dst->ip6po_hbh, M_IP6OPT); 236733841545SHajimu UMEMOTO if (dst->ip6po_dest1) free(dst->ip6po_dest1, M_IP6OPT); 236833841545SHajimu UMEMOTO if (dst->ip6po_dest2) free(dst->ip6po_dest2, M_IP6OPT); 236933841545SHajimu UMEMOTO if (dst->ip6po_rthdr) free(dst->ip6po_rthdr, M_IP6OPT); 2370885adbfaSHajimu UMEMOTO return (ENOBUFS); 2371885adbfaSHajimu UMEMOTO } 2372885adbfaSHajimu UMEMOTO #undef PKTOPT_EXTHDRCPY 2373885adbfaSHajimu UMEMOTO 2374885adbfaSHajimu UMEMOTO struct ip6_pktopts * 23751272577eSXin LI ip6_copypktopts(struct ip6_pktopts *src, int canwait) 2376885adbfaSHajimu UMEMOTO { 2377885adbfaSHajimu UMEMOTO int error; 2378885adbfaSHajimu UMEMOTO struct ip6_pktopts *dst; 2379885adbfaSHajimu UMEMOTO 2380885adbfaSHajimu UMEMOTO dst = malloc(sizeof(*dst), M_IP6OPT, canwait); 23812cb64cb2SGeorge V. Neville-Neil if (dst == NULL) 2382885adbfaSHajimu UMEMOTO return (NULL); 2383885adbfaSHajimu UMEMOTO ip6_initpktopts(dst); 2384885adbfaSHajimu UMEMOTO 2385885adbfaSHajimu UMEMOTO if ((error = copypktopts(dst, src, canwait)) != 0) { 238635f6695bSHajimu UMEMOTO free(dst, M_IP6OPT); 238733841545SHajimu UMEMOTO return (NULL); 238833841545SHajimu UMEMOTO } 2389885adbfaSHajimu UMEMOTO 2390885adbfaSHajimu UMEMOTO return (dst); 2391885adbfaSHajimu UMEMOTO } 239233841545SHajimu UMEMOTO 239333841545SHajimu UMEMOTO void 23941272577eSXin LI ip6_freepcbopts(struct ip6_pktopts *pktopt) 239533841545SHajimu UMEMOTO { 239633841545SHajimu UMEMOTO if (pktopt == NULL) 239733841545SHajimu UMEMOTO return; 239833841545SHajimu UMEMOTO 2399f95d4633SHajimu UMEMOTO ip6_clearpktopts(pktopt, -1); 240033841545SHajimu UMEMOTO 240133841545SHajimu UMEMOTO free(pktopt, M_IP6OPT); 240233841545SHajimu UMEMOTO } 240333841545SHajimu UMEMOTO 240433841545SHajimu UMEMOTO /* 240582cd038dSYoshinobu Inoue * Set the IP6 multicast options in response to user setsockopt(). 240682cd038dSYoshinobu Inoue */ 240782cd038dSYoshinobu Inoue static int 24081272577eSXin LI ip6_setmoptions(int optname, struct ip6_moptions **im6op, struct mbuf *m) 240982cd038dSYoshinobu Inoue { 241082cd038dSYoshinobu Inoue int error = 0; 241182cd038dSYoshinobu Inoue u_int loop, ifindex; 241282cd038dSYoshinobu Inoue struct ipv6_mreq *mreq; 241382cd038dSYoshinobu Inoue struct ifnet *ifp; 241482cd038dSYoshinobu Inoue struct ip6_moptions *im6o = *im6op; 241582cd038dSYoshinobu Inoue struct route_in6 ro; 241682cd038dSYoshinobu Inoue struct in6_multi_mship *imm; 24177efe5d92SHajimu UMEMOTO struct thread *td = curthread; 241882cd038dSYoshinobu Inoue 241982cd038dSYoshinobu Inoue if (im6o == NULL) { 242082cd038dSYoshinobu Inoue /* 242182cd038dSYoshinobu Inoue * No multicast option buffer attached to the pcb; 242282cd038dSYoshinobu Inoue * allocate one and initialize to default values. 242382cd038dSYoshinobu Inoue */ 242482cd038dSYoshinobu Inoue im6o = (struct ip6_moptions *) 24257ba26d99SDavid E. O'Brien malloc(sizeof(*im6o), M_IP6MOPTS, M_WAITOK); 242682cd038dSYoshinobu Inoue 242782cd038dSYoshinobu Inoue if (im6o == NULL) 242882cd038dSYoshinobu Inoue return (ENOBUFS); 242982cd038dSYoshinobu Inoue *im6op = im6o; 243082cd038dSYoshinobu Inoue im6o->im6o_multicast_ifp = NULL; 243182cd038dSYoshinobu Inoue im6o->im6o_multicast_hlim = ip6_defmcasthlim; 243282cd038dSYoshinobu Inoue im6o->im6o_multicast_loop = IPV6_DEFAULT_MULTICAST_LOOP; 243382cd038dSYoshinobu Inoue LIST_INIT(&im6o->im6o_memberships); 243482cd038dSYoshinobu Inoue } 243582cd038dSYoshinobu Inoue 243682cd038dSYoshinobu Inoue switch (optname) { 243782cd038dSYoshinobu Inoue 243882cd038dSYoshinobu Inoue case IPV6_MULTICAST_IF: 243982cd038dSYoshinobu Inoue /* 244082cd038dSYoshinobu Inoue * Select the interface for outgoing multicast packets. 244182cd038dSYoshinobu Inoue */ 244282cd038dSYoshinobu Inoue if (m == NULL || m->m_len != sizeof(u_int)) { 244382cd038dSYoshinobu Inoue error = EINVAL; 244482cd038dSYoshinobu Inoue break; 244582cd038dSYoshinobu Inoue } 244633841545SHajimu UMEMOTO bcopy(mtod(m, u_int *), &ifindex, sizeof(ifindex)); 244782cd038dSYoshinobu Inoue if (ifindex < 0 || if_index < ifindex) { 244882cd038dSYoshinobu Inoue error = ENXIO; /* XXX EINVAL? */ 244982cd038dSYoshinobu Inoue break; 245082cd038dSYoshinobu Inoue } 2451f9132cebSJonathan Lemon ifp = ifnet_byindex(ifindex); 245282cd038dSYoshinobu Inoue if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) { 245382cd038dSYoshinobu Inoue error = EADDRNOTAVAIL; 245482cd038dSYoshinobu Inoue break; 245582cd038dSYoshinobu Inoue } 245682cd038dSYoshinobu Inoue im6o->im6o_multicast_ifp = ifp; 245782cd038dSYoshinobu Inoue break; 245882cd038dSYoshinobu Inoue 245982cd038dSYoshinobu Inoue case IPV6_MULTICAST_HOPS: 246082cd038dSYoshinobu Inoue { 246182cd038dSYoshinobu Inoue /* 246282cd038dSYoshinobu Inoue * Set the IP6 hoplimit for outgoing multicast packets. 246382cd038dSYoshinobu Inoue */ 246482cd038dSYoshinobu Inoue int optval; 246582cd038dSYoshinobu Inoue if (m == NULL || m->m_len != sizeof(int)) { 246682cd038dSYoshinobu Inoue error = EINVAL; 246782cd038dSYoshinobu Inoue break; 246882cd038dSYoshinobu Inoue } 246933841545SHajimu UMEMOTO bcopy(mtod(m, u_int *), &optval, sizeof(optval)); 247082cd038dSYoshinobu Inoue if (optval < -1 || optval >= 256) 247182cd038dSYoshinobu Inoue error = EINVAL; 247282cd038dSYoshinobu Inoue else if (optval == -1) 247382cd038dSYoshinobu Inoue im6o->im6o_multicast_hlim = ip6_defmcasthlim; 247482cd038dSYoshinobu Inoue else 247582cd038dSYoshinobu Inoue im6o->im6o_multicast_hlim = optval; 247682cd038dSYoshinobu Inoue break; 247782cd038dSYoshinobu Inoue } 247882cd038dSYoshinobu Inoue 247982cd038dSYoshinobu Inoue case IPV6_MULTICAST_LOOP: 248082cd038dSYoshinobu Inoue /* 248182cd038dSYoshinobu Inoue * Set the loopback flag for outgoing multicast packets. 248282cd038dSYoshinobu Inoue * Must be zero or one. 248382cd038dSYoshinobu Inoue */ 248433841545SHajimu UMEMOTO if (m == NULL || m->m_len != sizeof(u_int)) { 248533841545SHajimu UMEMOTO error = EINVAL; 248633841545SHajimu UMEMOTO break; 248733841545SHajimu UMEMOTO } 248833841545SHajimu UMEMOTO bcopy(mtod(m, u_int *), &loop, sizeof(loop)); 248933841545SHajimu UMEMOTO if (loop > 1) { 249082cd038dSYoshinobu Inoue error = EINVAL; 249182cd038dSYoshinobu Inoue break; 249282cd038dSYoshinobu Inoue } 249382cd038dSYoshinobu Inoue im6o->im6o_multicast_loop = loop; 249482cd038dSYoshinobu Inoue break; 249582cd038dSYoshinobu Inoue 249682cd038dSYoshinobu Inoue case IPV6_JOIN_GROUP: 249782cd038dSYoshinobu Inoue /* 249882cd038dSYoshinobu Inoue * Add a multicast group membership. 249982cd038dSYoshinobu Inoue * Group must be a valid IP6 multicast address. 250082cd038dSYoshinobu Inoue */ 250182cd038dSYoshinobu Inoue if (m == NULL || m->m_len != sizeof(struct ipv6_mreq)) { 250282cd038dSYoshinobu Inoue error = EINVAL; 250382cd038dSYoshinobu Inoue break; 250482cd038dSYoshinobu Inoue } 250582cd038dSYoshinobu Inoue mreq = mtod(m, struct ipv6_mreq *); 2506a1f7e5f8SHajimu UMEMOTO 250782cd038dSYoshinobu Inoue if (IN6_IS_ADDR_UNSPECIFIED(&mreq->ipv6mr_multiaddr)) { 250882cd038dSYoshinobu Inoue /* 250982cd038dSYoshinobu Inoue * We use the unspecified address to specify to accept 251082cd038dSYoshinobu Inoue * all multicast addresses. Only super user is allowed 251182cd038dSYoshinobu Inoue * to do this. 251282cd038dSYoshinobu Inoue */ 25137efe5d92SHajimu UMEMOTO if (suser(td)) { 251482cd038dSYoshinobu Inoue error = EACCES; 251582cd038dSYoshinobu Inoue break; 251682cd038dSYoshinobu Inoue } 251782cd038dSYoshinobu Inoue } else if (!IN6_IS_ADDR_MULTICAST(&mreq->ipv6mr_multiaddr)) { 251882cd038dSYoshinobu Inoue error = EINVAL; 251982cd038dSYoshinobu Inoue break; 252082cd038dSYoshinobu Inoue } 252182cd038dSYoshinobu Inoue 252282cd038dSYoshinobu Inoue /* 252382cd038dSYoshinobu Inoue * If no interface was explicitly specified, choose an 252482cd038dSYoshinobu Inoue * appropriate one according to the given multicast address. 252582cd038dSYoshinobu Inoue */ 252682cd038dSYoshinobu Inoue if (mreq->ipv6mr_interface == 0) { 2527a1f7e5f8SHajimu UMEMOTO struct sockaddr_in6 *dst; 2528a1f7e5f8SHajimu UMEMOTO 252982cd038dSYoshinobu Inoue /* 2530a1f7e5f8SHajimu UMEMOTO * Look up the routing table for the 253182cd038dSYoshinobu Inoue * address, and choose the outgoing interface. 253282cd038dSYoshinobu Inoue * XXX: is it a good approach? 253382cd038dSYoshinobu Inoue */ 253482cd038dSYoshinobu Inoue ro.ro_rt = NULL; 253582cd038dSYoshinobu Inoue dst = (struct sockaddr_in6 *)&ro.ro_dst; 253682cd038dSYoshinobu Inoue bzero(dst, sizeof(*dst)); 253782cd038dSYoshinobu Inoue dst->sin6_family = AF_INET6; 2538a1f7e5f8SHajimu UMEMOTO dst->sin6_len = sizeof(*dst); 253982cd038dSYoshinobu Inoue dst->sin6_addr = mreq->ipv6mr_multiaddr; 254082cd038dSYoshinobu Inoue rtalloc((struct route *)&ro); 254182cd038dSYoshinobu Inoue if (ro.ro_rt == NULL) { 254282cd038dSYoshinobu Inoue error = EADDRNOTAVAIL; 254382cd038dSYoshinobu Inoue break; 254482cd038dSYoshinobu Inoue } 254582cd038dSYoshinobu Inoue ifp = ro.ro_rt->rt_ifp; 2546d1dd20beSSam Leffler RTFREE(ro.ro_rt); 2547a1f7e5f8SHajimu UMEMOTO } else { 2548a1f7e5f8SHajimu UMEMOTO /* 2549a1f7e5f8SHajimu UMEMOTO * If the interface is specified, validate it. 2550a1f7e5f8SHajimu UMEMOTO */ 2551a1f7e5f8SHajimu UMEMOTO if (mreq->ipv6mr_interface < 0 || 2552a1f7e5f8SHajimu UMEMOTO if_index < mreq->ipv6mr_interface) { 2553a1f7e5f8SHajimu UMEMOTO error = ENXIO; /* XXX EINVAL? */ 2554a1f7e5f8SHajimu UMEMOTO break; 255582cd038dSYoshinobu Inoue } 2556f9132cebSJonathan Lemon ifp = ifnet_byindex(mreq->ipv6mr_interface); 2557a1f7e5f8SHajimu UMEMOTO if (!ifp) { 2558a1f7e5f8SHajimu UMEMOTO error = ENXIO; /* XXX EINVAL? */ 2559a1f7e5f8SHajimu UMEMOTO break; 2560a1f7e5f8SHajimu UMEMOTO } 2561a1f7e5f8SHajimu UMEMOTO } 256282cd038dSYoshinobu Inoue 256382cd038dSYoshinobu Inoue /* 256482cd038dSYoshinobu Inoue * See if we found an interface, and confirm that it 256582cd038dSYoshinobu Inoue * supports multicast 256682cd038dSYoshinobu Inoue */ 256782cd038dSYoshinobu Inoue if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) { 256882cd038dSYoshinobu Inoue error = EADDRNOTAVAIL; 256982cd038dSYoshinobu Inoue break; 257082cd038dSYoshinobu Inoue } 2571a1f7e5f8SHajimu UMEMOTO 2572a1f7e5f8SHajimu UMEMOTO if (in6_setscope(&mreq->ipv6mr_multiaddr, ifp, NULL)) { 2573a1f7e5f8SHajimu UMEMOTO error = EADDRNOTAVAIL; /* XXX: should not happen */ 2574a1f7e5f8SHajimu UMEMOTO break; 257582cd038dSYoshinobu Inoue } 2576a1f7e5f8SHajimu UMEMOTO 257782cd038dSYoshinobu Inoue /* 257882cd038dSYoshinobu Inoue * See if the membership already exists. 257982cd038dSYoshinobu Inoue */ 2580686cdd19SJun-ichiro itojun Hagino for (imm = im6o->im6o_memberships.lh_first; 2581686cdd19SJun-ichiro itojun Hagino imm != NULL; imm = imm->i6mm_chain.le_next) 258282cd038dSYoshinobu Inoue if (imm->i6mm_maddr->in6m_ifp == ifp && 258382cd038dSYoshinobu Inoue IN6_ARE_ADDR_EQUAL(&imm->i6mm_maddr->in6m_addr, 258482cd038dSYoshinobu Inoue &mreq->ipv6mr_multiaddr)) 258582cd038dSYoshinobu Inoue break; 258682cd038dSYoshinobu Inoue if (imm != NULL) { 258782cd038dSYoshinobu Inoue error = EADDRINUSE; 258882cd038dSYoshinobu Inoue break; 258982cd038dSYoshinobu Inoue } 259082cd038dSYoshinobu Inoue /* 259182cd038dSYoshinobu Inoue * Everything looks good; add a new record to the multicast 259282cd038dSYoshinobu Inoue * address list for the given interface. 259382cd038dSYoshinobu Inoue */ 2594743eee66SSUZUKI Shinsuke imm = in6_joingroup(ifp, &mreq->ipv6mr_multiaddr, &error, 0); 2595743eee66SSUZUKI Shinsuke if (imm == NULL) 259682cd038dSYoshinobu Inoue break; 259782cd038dSYoshinobu Inoue LIST_INSERT_HEAD(&im6o->im6o_memberships, imm, i6mm_chain); 259882cd038dSYoshinobu Inoue break; 259982cd038dSYoshinobu Inoue 260082cd038dSYoshinobu Inoue case IPV6_LEAVE_GROUP: 260182cd038dSYoshinobu Inoue /* 260282cd038dSYoshinobu Inoue * Drop a multicast group membership. 260382cd038dSYoshinobu Inoue * Group must be a valid IP6 multicast address. 260482cd038dSYoshinobu Inoue */ 260582cd038dSYoshinobu Inoue if (m == NULL || m->m_len != sizeof(struct ipv6_mreq)) { 260682cd038dSYoshinobu Inoue error = EINVAL; 260782cd038dSYoshinobu Inoue break; 260882cd038dSYoshinobu Inoue } 260982cd038dSYoshinobu Inoue mreq = mtod(m, struct ipv6_mreq *); 2610a1f7e5f8SHajimu UMEMOTO 261182cd038dSYoshinobu Inoue /* 261282cd038dSYoshinobu Inoue * If an interface address was specified, get a pointer 261382cd038dSYoshinobu Inoue * to its ifnet structure. 261482cd038dSYoshinobu Inoue */ 2615a1f7e5f8SHajimu UMEMOTO if (mreq->ipv6mr_interface < 0 || 2616a1f7e5f8SHajimu UMEMOTO if_index < mreq->ipv6mr_interface) { 261782cd038dSYoshinobu Inoue error = ENXIO; /* XXX EINVAL? */ 261882cd038dSYoshinobu Inoue break; 261982cd038dSYoshinobu Inoue } 2620a1f7e5f8SHajimu UMEMOTO if (mreq->ipv6mr_interface == 0) 2621a1f7e5f8SHajimu UMEMOTO ifp = NULL; 2622a1f7e5f8SHajimu UMEMOTO else 2623f9132cebSJonathan Lemon ifp = ifnet_byindex(mreq->ipv6mr_interface); 2624a1f7e5f8SHajimu UMEMOTO 2625a1f7e5f8SHajimu UMEMOTO /* Fill in the scope zone ID */ 2626a1f7e5f8SHajimu UMEMOTO if (ifp) { 2627a1f7e5f8SHajimu UMEMOTO if (in6_setscope(&mreq->ipv6mr_multiaddr, ifp, NULL)) { 2628a1f7e5f8SHajimu UMEMOTO /* XXX: should not happen */ 2629a1f7e5f8SHajimu UMEMOTO error = EADDRNOTAVAIL; 2630a1f7e5f8SHajimu UMEMOTO break; 2631a1f7e5f8SHajimu UMEMOTO } 2632a1f7e5f8SHajimu UMEMOTO } else if (mreq->ipv6mr_interface != 0) { 263382cd038dSYoshinobu Inoue /* 2634a1f7e5f8SHajimu UMEMOTO * This case happens when the (positive) index is in 2635a1f7e5f8SHajimu UMEMOTO * the valid range, but the corresponding interface has 2636a1f7e5f8SHajimu UMEMOTO * been detached dynamically (XXX). 263782cd038dSYoshinobu Inoue */ 2638a1f7e5f8SHajimu UMEMOTO error = EADDRNOTAVAIL; 2639a1f7e5f8SHajimu UMEMOTO break; 2640a1f7e5f8SHajimu UMEMOTO } else { /* ipv6mr_interface == 0 */ 2641a1f7e5f8SHajimu UMEMOTO struct sockaddr_in6 sa6_mc; 2642a1f7e5f8SHajimu UMEMOTO 2643a1f7e5f8SHajimu UMEMOTO /* 2644a1f7e5f8SHajimu UMEMOTO * The API spec says as follows: 2645a1f7e5f8SHajimu UMEMOTO * If the interface index is specified as 0, the 2646a1f7e5f8SHajimu UMEMOTO * system may choose a multicast group membership to 2647a1f7e5f8SHajimu UMEMOTO * drop by matching the multicast address only. 2648a1f7e5f8SHajimu UMEMOTO * On the other hand, we cannot disambiguate the scope 2649a1f7e5f8SHajimu UMEMOTO * zone unless an interface is provided. Thus, we 2650a1f7e5f8SHajimu UMEMOTO * check if there's ambiguity with the default scope 2651a1f7e5f8SHajimu UMEMOTO * zone as the last resort. 2652a1f7e5f8SHajimu UMEMOTO */ 2653a1f7e5f8SHajimu UMEMOTO bzero(&sa6_mc, sizeof(sa6_mc)); 2654a1f7e5f8SHajimu UMEMOTO sa6_mc.sin6_family = AF_INET6; 2655a1f7e5f8SHajimu UMEMOTO sa6_mc.sin6_len = sizeof(sa6_mc); 2656a1f7e5f8SHajimu UMEMOTO sa6_mc.sin6_addr = mreq->ipv6mr_multiaddr; 2657a1f7e5f8SHajimu UMEMOTO error = sa6_embedscope(&sa6_mc, ip6_use_defzone); 2658a1f7e5f8SHajimu UMEMOTO if (error != 0) 2659a1f7e5f8SHajimu UMEMOTO break; 2660a1f7e5f8SHajimu UMEMOTO mreq->ipv6mr_multiaddr = sa6_mc.sin6_addr; 266182cd038dSYoshinobu Inoue } 26627efe5d92SHajimu UMEMOTO 266382cd038dSYoshinobu Inoue /* 266482cd038dSYoshinobu Inoue * Find the membership in the membership list. 266582cd038dSYoshinobu Inoue */ 2666686cdd19SJun-ichiro itojun Hagino for (imm = im6o->im6o_memberships.lh_first; 2667686cdd19SJun-ichiro itojun Hagino imm != NULL; imm = imm->i6mm_chain.le_next) { 26687efe5d92SHajimu UMEMOTO if ((ifp == NULL || imm->i6mm_maddr->in6m_ifp == ifp) && 266982cd038dSYoshinobu Inoue IN6_ARE_ADDR_EQUAL(&imm->i6mm_maddr->in6m_addr, 267082cd038dSYoshinobu Inoue &mreq->ipv6mr_multiaddr)) 267182cd038dSYoshinobu Inoue break; 267282cd038dSYoshinobu Inoue } 267382cd038dSYoshinobu Inoue if (imm == NULL) { 267482cd038dSYoshinobu Inoue /* Unable to resolve interface */ 267582cd038dSYoshinobu Inoue error = EADDRNOTAVAIL; 267682cd038dSYoshinobu Inoue break; 267782cd038dSYoshinobu Inoue } 267882cd038dSYoshinobu Inoue /* 267982cd038dSYoshinobu Inoue * Give up the multicast address record to which the 268082cd038dSYoshinobu Inoue * membership points. 268182cd038dSYoshinobu Inoue */ 268282cd038dSYoshinobu Inoue LIST_REMOVE(imm, i6mm_chain); 268382cd038dSYoshinobu Inoue in6_delmulti(imm->i6mm_maddr); 26847ba26d99SDavid E. O'Brien free(imm, M_IP6MADDR); 268582cd038dSYoshinobu Inoue break; 268682cd038dSYoshinobu Inoue 268782cd038dSYoshinobu Inoue default: 268882cd038dSYoshinobu Inoue error = EOPNOTSUPP; 268982cd038dSYoshinobu Inoue break; 269082cd038dSYoshinobu Inoue } 269182cd038dSYoshinobu Inoue 269282cd038dSYoshinobu Inoue /* 269382cd038dSYoshinobu Inoue * If all options have default values, no need to keep the mbuf. 269482cd038dSYoshinobu Inoue */ 269582cd038dSYoshinobu Inoue if (im6o->im6o_multicast_ifp == NULL && 269682cd038dSYoshinobu Inoue im6o->im6o_multicast_hlim == ip6_defmcasthlim && 269782cd038dSYoshinobu Inoue im6o->im6o_multicast_loop == IPV6_DEFAULT_MULTICAST_LOOP && 2698686cdd19SJun-ichiro itojun Hagino im6o->im6o_memberships.lh_first == NULL) { 26997ba26d99SDavid E. O'Brien free(*im6op, M_IP6MOPTS); 270082cd038dSYoshinobu Inoue *im6op = NULL; 270182cd038dSYoshinobu Inoue } 270282cd038dSYoshinobu Inoue 270382cd038dSYoshinobu Inoue return (error); 270482cd038dSYoshinobu Inoue } 270582cd038dSYoshinobu Inoue 270682cd038dSYoshinobu Inoue /* 270782cd038dSYoshinobu Inoue * Return the IP6 multicast options in response to user getsockopt(). 270882cd038dSYoshinobu Inoue */ 270982cd038dSYoshinobu Inoue static int 27101272577eSXin LI ip6_getmoptions(int optname, struct ip6_moptions *im6o, struct mbuf **mp) 271182cd038dSYoshinobu Inoue { 271282cd038dSYoshinobu Inoue u_int *hlim, *loop, *ifindex; 271382cd038dSYoshinobu Inoue 2714a163d034SWarner Losh *mp = m_get(M_TRYWAIT, MT_HEADER); /* XXX */ 271582cd038dSYoshinobu Inoue 271682cd038dSYoshinobu Inoue switch (optname) { 271782cd038dSYoshinobu Inoue 271882cd038dSYoshinobu Inoue case IPV6_MULTICAST_IF: 271982cd038dSYoshinobu Inoue ifindex = mtod(*mp, u_int *); 272082cd038dSYoshinobu Inoue (*mp)->m_len = sizeof(u_int); 272182cd038dSYoshinobu Inoue if (im6o == NULL || im6o->im6o_multicast_ifp == NULL) 272282cd038dSYoshinobu Inoue *ifindex = 0; 272382cd038dSYoshinobu Inoue else 272482cd038dSYoshinobu Inoue *ifindex = im6o->im6o_multicast_ifp->if_index; 272582cd038dSYoshinobu Inoue return (0); 272682cd038dSYoshinobu Inoue 272782cd038dSYoshinobu Inoue case IPV6_MULTICAST_HOPS: 272882cd038dSYoshinobu Inoue hlim = mtod(*mp, u_int *); 272982cd038dSYoshinobu Inoue (*mp)->m_len = sizeof(u_int); 273082cd038dSYoshinobu Inoue if (im6o == NULL) 273182cd038dSYoshinobu Inoue *hlim = ip6_defmcasthlim; 273282cd038dSYoshinobu Inoue else 273382cd038dSYoshinobu Inoue *hlim = im6o->im6o_multicast_hlim; 273482cd038dSYoshinobu Inoue return (0); 273582cd038dSYoshinobu Inoue 273682cd038dSYoshinobu Inoue case IPV6_MULTICAST_LOOP: 273782cd038dSYoshinobu Inoue loop = mtod(*mp, u_int *); 273882cd038dSYoshinobu Inoue (*mp)->m_len = sizeof(u_int); 273982cd038dSYoshinobu Inoue if (im6o == NULL) 274082cd038dSYoshinobu Inoue *loop = ip6_defmcasthlim; 274182cd038dSYoshinobu Inoue else 274282cd038dSYoshinobu Inoue *loop = im6o->im6o_multicast_loop; 274382cd038dSYoshinobu Inoue return (0); 274482cd038dSYoshinobu Inoue 274582cd038dSYoshinobu Inoue default: 274682cd038dSYoshinobu Inoue return (EOPNOTSUPP); 274782cd038dSYoshinobu Inoue } 274882cd038dSYoshinobu Inoue } 274982cd038dSYoshinobu Inoue 275082cd038dSYoshinobu Inoue /* 275182cd038dSYoshinobu Inoue * Discard the IP6 multicast options. 275282cd038dSYoshinobu Inoue */ 275382cd038dSYoshinobu Inoue void 27541272577eSXin LI ip6_freemoptions(struct ip6_moptions *im6o) 275582cd038dSYoshinobu Inoue { 275682cd038dSYoshinobu Inoue struct in6_multi_mship *imm; 275782cd038dSYoshinobu Inoue 275882cd038dSYoshinobu Inoue if (im6o == NULL) 275982cd038dSYoshinobu Inoue return; 276082cd038dSYoshinobu Inoue 2761686cdd19SJun-ichiro itojun Hagino while ((imm = im6o->im6o_memberships.lh_first) != NULL) { 276282cd038dSYoshinobu Inoue LIST_REMOVE(imm, i6mm_chain); 276382cd038dSYoshinobu Inoue if (imm->i6mm_maddr) 276482cd038dSYoshinobu Inoue in6_delmulti(imm->i6mm_maddr); 27657ba26d99SDavid E. O'Brien free(imm, M_IP6MADDR); 276682cd038dSYoshinobu Inoue } 27677ba26d99SDavid E. O'Brien free(im6o, M_IP6MOPTS); 276882cd038dSYoshinobu Inoue } 276982cd038dSYoshinobu Inoue 277082cd038dSYoshinobu Inoue /* 277182cd038dSYoshinobu Inoue * Set IPv6 outgoing packet options based on advanced API. 277282cd038dSYoshinobu Inoue */ 277382cd038dSYoshinobu Inoue int 27741272577eSXin LI ip6_setpktopts(struct mbuf *control, struct ip6_pktopts *opt, 27751272577eSXin LI struct ip6_pktopts *stickyopt, int priv, int uproto) 277682cd038dSYoshinobu Inoue { 277733841545SHajimu UMEMOTO struct cmsghdr *cm = 0; 277882cd038dSYoshinobu Inoue 27798507acb1SHajimu UMEMOTO if (control == NULL || opt == NULL) 278082cd038dSYoshinobu Inoue return (EINVAL); 278182cd038dSYoshinobu Inoue 2782885adbfaSHajimu UMEMOTO ip6_initpktopts(opt); 2783f95d4633SHajimu UMEMOTO if (stickyopt) { 2784885adbfaSHajimu UMEMOTO int error; 2785885adbfaSHajimu UMEMOTO 2786f95d4633SHajimu UMEMOTO /* 2787f95d4633SHajimu UMEMOTO * If stickyopt is provided, make a local copy of the options 2788f95d4633SHajimu UMEMOTO * for this particular packet, then override them by ancillary 2789f95d4633SHajimu UMEMOTO * objects. 2790885adbfaSHajimu UMEMOTO * XXX: copypktopts() does not copy the cached route to a next 2791885adbfaSHajimu UMEMOTO * hop (if any). This is not very good in terms of efficiency, 2792885adbfaSHajimu UMEMOTO * but we can allow this since this option should be rarely 2793885adbfaSHajimu UMEMOTO * used. 2794f95d4633SHajimu UMEMOTO */ 2795885adbfaSHajimu UMEMOTO if ((error = copypktopts(opt, stickyopt, M_NOWAIT)) != 0) 2796885adbfaSHajimu UMEMOTO return (error); 2797f95d4633SHajimu UMEMOTO } 279882cd038dSYoshinobu Inoue 279982cd038dSYoshinobu Inoue /* 280082cd038dSYoshinobu Inoue * XXX: Currently, we assume all the optional information is stored 280182cd038dSYoshinobu Inoue * in a single mbuf. 280282cd038dSYoshinobu Inoue */ 280382cd038dSYoshinobu Inoue if (control->m_next) 280482cd038dSYoshinobu Inoue return (EINVAL); 280582cd038dSYoshinobu Inoue 280633841545SHajimu UMEMOTO for (; control->m_len; control->m_data += CMSG_ALIGN(cm->cmsg_len), 280733841545SHajimu UMEMOTO control->m_len -= CMSG_ALIGN(cm->cmsg_len)) { 2808f95d4633SHajimu UMEMOTO int error; 2809f95d4633SHajimu UMEMOTO 2810f95d4633SHajimu UMEMOTO if (control->m_len < CMSG_LEN(0)) 2811f95d4633SHajimu UMEMOTO return (EINVAL); 2812f95d4633SHajimu UMEMOTO 281382cd038dSYoshinobu Inoue cm = mtod(control, struct cmsghdr *); 281482cd038dSYoshinobu Inoue if (cm->cmsg_len == 0 || cm->cmsg_len > control->m_len) 281582cd038dSYoshinobu Inoue return (EINVAL); 281682cd038dSYoshinobu Inoue if (cm->cmsg_level != IPPROTO_IPV6) 281782cd038dSYoshinobu Inoue continue; 281882cd038dSYoshinobu Inoue 2819d5e3406dSHajimu UMEMOTO error = ip6_setpktopt(cm->cmsg_type, CMSG_DATA(cm), 2820885adbfaSHajimu UMEMOTO cm->cmsg_len - CMSG_LEN(0), opt, priv, 0, 1, uproto); 2821f95d4633SHajimu UMEMOTO if (error) 2822f95d4633SHajimu UMEMOTO return (error); 2823f95d4633SHajimu UMEMOTO } 282482cd038dSYoshinobu Inoue 2825f95d4633SHajimu UMEMOTO return (0); 2826f95d4633SHajimu UMEMOTO } 2827f95d4633SHajimu UMEMOTO 2828f95d4633SHajimu UMEMOTO /* 2829f95d4633SHajimu UMEMOTO * Set a particular packet option, as a sticky option or an ancillary data 2830f95d4633SHajimu UMEMOTO * item. "len" can be 0 only when it's a sticky option. 2831f95d4633SHajimu UMEMOTO * We have 4 cases of combination of "sticky" and "cmsg": 2832f95d4633SHajimu UMEMOTO * "sticky=0, cmsg=0": impossible 283318b35df8SHajimu UMEMOTO * "sticky=0, cmsg=1": RFC2292 or RFC3542 ancillary data 283418b35df8SHajimu UMEMOTO * "sticky=1, cmsg=0": RFC3542 socket option 2835f95d4633SHajimu UMEMOTO * "sticky=1, cmsg=1": RFC2292 socket option 2836f95d4633SHajimu UMEMOTO */ 2837f95d4633SHajimu UMEMOTO static int 28381272577eSXin LI ip6_setpktopt(int optname, u_char *buf, int len, struct ip6_pktopts *opt, 28391272577eSXin LI int priv, int sticky, int cmsg, int uproto) 2840f95d4633SHajimu UMEMOTO { 2841f95d4633SHajimu UMEMOTO int minmtupolicy, preftemp; 2842f95d4633SHajimu UMEMOTO 2843f95d4633SHajimu UMEMOTO if (!sticky && !cmsg) { 2844f95d4633SHajimu UMEMOTO #ifdef DIAGNOSTIC 2845d5e3406dSHajimu UMEMOTO printf("ip6_setpktopt: impossible case\n"); 2846f95d4633SHajimu UMEMOTO #endif 2847f95d4633SHajimu UMEMOTO return (EINVAL); 2848f95d4633SHajimu UMEMOTO } 2849f95d4633SHajimu UMEMOTO 2850f95d4633SHajimu UMEMOTO /* 2851f95d4633SHajimu UMEMOTO * IPV6_2292xxx is for backward compatibility to RFC2292, and should 285218b35df8SHajimu UMEMOTO * not be specified in the context of RFC3542. Conversely, 285318b35df8SHajimu UMEMOTO * RFC3542 types should not be specified in the context of RFC2292. 2854f95d4633SHajimu UMEMOTO */ 2855f95d4633SHajimu UMEMOTO if (!cmsg) { 2856f95d4633SHajimu UMEMOTO switch (optname) { 2857f95d4633SHajimu UMEMOTO case IPV6_2292PKTINFO: 2858f95d4633SHajimu UMEMOTO case IPV6_2292HOPLIMIT: 2859f95d4633SHajimu UMEMOTO case IPV6_2292NEXTHOP: 2860f95d4633SHajimu UMEMOTO case IPV6_2292HOPOPTS: 2861f95d4633SHajimu UMEMOTO case IPV6_2292DSTOPTS: 2862f95d4633SHajimu UMEMOTO case IPV6_2292RTHDR: 2863f95d4633SHajimu UMEMOTO case IPV6_2292PKTOPTIONS: 2864f95d4633SHajimu UMEMOTO return (ENOPROTOOPT); 2865f95d4633SHajimu UMEMOTO } 2866f95d4633SHajimu UMEMOTO } 2867f95d4633SHajimu UMEMOTO if (sticky && cmsg) { 2868f95d4633SHajimu UMEMOTO switch (optname) { 2869f95d4633SHajimu UMEMOTO case IPV6_PKTINFO: 2870f95d4633SHajimu UMEMOTO case IPV6_HOPLIMIT: 2871f95d4633SHajimu UMEMOTO case IPV6_NEXTHOP: 2872f95d4633SHajimu UMEMOTO case IPV6_HOPOPTS: 2873f95d4633SHajimu UMEMOTO case IPV6_DSTOPTS: 2874f95d4633SHajimu UMEMOTO case IPV6_RTHDRDSTOPTS: 2875f95d4633SHajimu UMEMOTO case IPV6_RTHDR: 2876f95d4633SHajimu UMEMOTO case IPV6_USE_MIN_MTU: 2877f95d4633SHajimu UMEMOTO case IPV6_DONTFRAG: 2878f95d4633SHajimu UMEMOTO case IPV6_TCLASS: 287918b35df8SHajimu UMEMOTO case IPV6_PREFER_TEMPADDR: /* XXX: not an RFC3542 option */ 2880f95d4633SHajimu UMEMOTO return (ENOPROTOOPT); 2881f95d4633SHajimu UMEMOTO } 2882f95d4633SHajimu UMEMOTO } 2883f95d4633SHajimu UMEMOTO 2884f95d4633SHajimu UMEMOTO switch (optname) { 2885f95d4633SHajimu UMEMOTO case IPV6_2292PKTINFO: 2886f95d4633SHajimu UMEMOTO case IPV6_PKTINFO: 2887f95d4633SHajimu UMEMOTO { 2888f95d4633SHajimu UMEMOTO struct ifnet *ifp = NULL; 2889f95d4633SHajimu UMEMOTO struct in6_pktinfo *pktinfo; 2890f95d4633SHajimu UMEMOTO 2891f95d4633SHajimu UMEMOTO if (len != sizeof(struct in6_pktinfo)) 2892f95d4633SHajimu UMEMOTO return (EINVAL); 2893f95d4633SHajimu UMEMOTO 2894f95d4633SHajimu UMEMOTO pktinfo = (struct in6_pktinfo *)buf; 2895f95d4633SHajimu UMEMOTO 2896f95d4633SHajimu UMEMOTO /* 2897f95d4633SHajimu UMEMOTO * An application can clear any sticky IPV6_PKTINFO option by 2898f95d4633SHajimu UMEMOTO * doing a "regular" setsockopt with ipi6_addr being 2899f95d4633SHajimu UMEMOTO * in6addr_any and ipi6_ifindex being zero. 2900f95d4633SHajimu UMEMOTO * [RFC 3542, Section 6] 2901f95d4633SHajimu UMEMOTO */ 2902f95d4633SHajimu UMEMOTO if (optname == IPV6_PKTINFO && opt->ip6po_pktinfo && 2903f95d4633SHajimu UMEMOTO pktinfo->ipi6_ifindex == 0 && 2904f95d4633SHajimu UMEMOTO IN6_IS_ADDR_UNSPECIFIED(&pktinfo->ipi6_addr)) { 2905f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, optname); 2906f95d4633SHajimu UMEMOTO break; 2907f95d4633SHajimu UMEMOTO } 2908f95d4633SHajimu UMEMOTO 2909f95d4633SHajimu UMEMOTO if (uproto == IPPROTO_TCP && optname == IPV6_PKTINFO && 2910f95d4633SHajimu UMEMOTO sticky && !IN6_IS_ADDR_UNSPECIFIED(&pktinfo->ipi6_addr)) { 2911f95d4633SHajimu UMEMOTO return (EINVAL); 2912f95d4633SHajimu UMEMOTO } 2913f95d4633SHajimu UMEMOTO 2914f95d4633SHajimu UMEMOTO /* validate the interface index if specified. */ 2915f95d4633SHajimu UMEMOTO if (pktinfo->ipi6_ifindex > if_index || 2916f95d4633SHajimu UMEMOTO pktinfo->ipi6_ifindex < 0) { 2917f95d4633SHajimu UMEMOTO return (ENXIO); 2918f95d4633SHajimu UMEMOTO } 2919f95d4633SHajimu UMEMOTO if (pktinfo->ipi6_ifindex) { 2920f95d4633SHajimu UMEMOTO ifp = ifnet_byindex(pktinfo->ipi6_ifindex); 2921f95d4633SHajimu UMEMOTO if (ifp == NULL) 292282cd038dSYoshinobu Inoue return (ENXIO); 292382cd038dSYoshinobu Inoue } 292482cd038dSYoshinobu Inoue 292533841545SHajimu UMEMOTO /* 2926f95d4633SHajimu UMEMOTO * We store the address anyway, and let in6_selectsrc() 2927f95d4633SHajimu UMEMOTO * validate the specified address. This is because ipi6_addr 2928f95d4633SHajimu UMEMOTO * may not have enough information about its scope zone, and 2929f95d4633SHajimu UMEMOTO * we may need additional information (such as outgoing 2930f95d4633SHajimu UMEMOTO * interface or the scope zone of a destination address) to 2931f95d4633SHajimu UMEMOTO * disambiguate the scope. 2932f95d4633SHajimu UMEMOTO * XXX: the delay of the validation may confuse the 2933f95d4633SHajimu UMEMOTO * application when it is used as a sticky option. 293433841545SHajimu UMEMOTO */ 2935f95d4633SHajimu UMEMOTO if (opt->ip6po_pktinfo == NULL) { 2936f95d4633SHajimu UMEMOTO opt->ip6po_pktinfo = malloc(sizeof(*pktinfo), 2937885adbfaSHajimu UMEMOTO M_IP6OPT, M_NOWAIT); 2938885adbfaSHajimu UMEMOTO if (opt->ip6po_pktinfo == NULL) 2939885adbfaSHajimu UMEMOTO return (ENOBUFS); 294082cd038dSYoshinobu Inoue } 2941f95d4633SHajimu UMEMOTO bcopy(pktinfo, opt->ip6po_pktinfo, sizeof(*pktinfo)); 294282cd038dSYoshinobu Inoue break; 2943f95d4633SHajimu UMEMOTO } 294482cd038dSYoshinobu Inoue 2945f95d4633SHajimu UMEMOTO case IPV6_2292HOPLIMIT: 294682cd038dSYoshinobu Inoue case IPV6_HOPLIMIT: 2947f95d4633SHajimu UMEMOTO { 2948f95d4633SHajimu UMEMOTO int *hlimp; 2949f95d4633SHajimu UMEMOTO 2950f95d4633SHajimu UMEMOTO /* 2951f95d4633SHajimu UMEMOTO * RFC 3542 deprecated the usage of sticky IPV6_HOPLIMIT 2952f95d4633SHajimu UMEMOTO * to simplify the ordering among hoplimit options. 2953f95d4633SHajimu UMEMOTO */ 2954f95d4633SHajimu UMEMOTO if (optname == IPV6_HOPLIMIT && sticky) 2955f95d4633SHajimu UMEMOTO return (ENOPROTOOPT); 2956f95d4633SHajimu UMEMOTO 2957f95d4633SHajimu UMEMOTO if (len != sizeof(int)) 2958f95d4633SHajimu UMEMOTO return (EINVAL); 2959f95d4633SHajimu UMEMOTO hlimp = (int *)buf; 2960f95d4633SHajimu UMEMOTO if (*hlimp < -1 || *hlimp > 255) 296182cd038dSYoshinobu Inoue return (EINVAL); 296282cd038dSYoshinobu Inoue 2963f95d4633SHajimu UMEMOTO opt->ip6po_hlim = *hlimp; 296482cd038dSYoshinobu Inoue break; 2965f95d4633SHajimu UMEMOTO } 296682cd038dSYoshinobu Inoue 2967f95d4633SHajimu UMEMOTO case IPV6_TCLASS: 2968f95d4633SHajimu UMEMOTO { 2969f95d4633SHajimu UMEMOTO int tclass; 2970f95d4633SHajimu UMEMOTO 2971f95d4633SHajimu UMEMOTO if (len != sizeof(int)) 2972f95d4633SHajimu UMEMOTO return (EINVAL); 2973f95d4633SHajimu UMEMOTO tclass = *(int *)buf; 2974f95d4633SHajimu UMEMOTO if (tclass < -1 || tclass > 255) 2975f95d4633SHajimu UMEMOTO return (EINVAL); 2976f95d4633SHajimu UMEMOTO 2977f95d4633SHajimu UMEMOTO opt->ip6po_tclass = tclass; 2978f95d4633SHajimu UMEMOTO break; 2979f95d4633SHajimu UMEMOTO } 2980f95d4633SHajimu UMEMOTO 2981f95d4633SHajimu UMEMOTO case IPV6_2292NEXTHOP: 298282cd038dSYoshinobu Inoue case IPV6_NEXTHOP: 298382cd038dSYoshinobu Inoue if (!priv) 298482cd038dSYoshinobu Inoue return (EPERM); 298533841545SHajimu UMEMOTO 2986f95d4633SHajimu UMEMOTO if (len == 0) { /* just remove the option */ 2987f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, IPV6_NEXTHOP); 2988f95d4633SHajimu UMEMOTO break; 2989f95d4633SHajimu UMEMOTO } 2990f95d4633SHajimu UMEMOTO 299133841545SHajimu UMEMOTO /* check if cmsg_len is large enough for sa_len */ 2992f95d4633SHajimu UMEMOTO if (len < sizeof(struct sockaddr) || len < *buf) 299382cd038dSYoshinobu Inoue return (EINVAL); 299482cd038dSYoshinobu Inoue 2995f95d4633SHajimu UMEMOTO switch (((struct sockaddr *)buf)->sa_family) { 2996f95d4633SHajimu UMEMOTO case AF_INET6: 2997f95d4633SHajimu UMEMOTO { 2998f95d4633SHajimu UMEMOTO struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)buf; 2999f95d4633SHajimu UMEMOTO int error; 3000f95d4633SHajimu UMEMOTO 3001f95d4633SHajimu UMEMOTO if (sa6->sin6_len != sizeof(struct sockaddr_in6)) 3002f95d4633SHajimu UMEMOTO return (EINVAL); 3003f95d4633SHajimu UMEMOTO 3004f95d4633SHajimu UMEMOTO if (IN6_IS_ADDR_UNSPECIFIED(&sa6->sin6_addr) || 3005f95d4633SHajimu UMEMOTO IN6_IS_ADDR_MULTICAST(&sa6->sin6_addr)) { 3006f95d4633SHajimu UMEMOTO return (EINVAL); 3007f95d4633SHajimu UMEMOTO } 3008a1f7e5f8SHajimu UMEMOTO if ((error = sa6_embedscope(sa6, ip6_use_defzone)) 3009f95d4633SHajimu UMEMOTO != 0) { 3010f95d4633SHajimu UMEMOTO return (error); 3011f95d4633SHajimu UMEMOTO } 3012f95d4633SHajimu UMEMOTO break; 3013f95d4633SHajimu UMEMOTO } 3014f95d4633SHajimu UMEMOTO case AF_LINK: /* should eventually be supported */ 3015f95d4633SHajimu UMEMOTO default: 3016f95d4633SHajimu UMEMOTO return (EAFNOSUPPORT); 3017f95d4633SHajimu UMEMOTO } 3018f95d4633SHajimu UMEMOTO 3019f95d4633SHajimu UMEMOTO /* turn off the previous option, then set the new option. */ 3020f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, IPV6_NEXTHOP); 3021743eee66SSUZUKI Shinsuke opt->ip6po_nexthop = malloc(*buf, M_IP6OPT, M_NOWAIT); 3022743eee66SSUZUKI Shinsuke if (opt->ip6po_nexthop == NULL) 3023743eee66SSUZUKI Shinsuke return (ENOBUFS); 3024f95d4633SHajimu UMEMOTO bcopy(buf, opt->ip6po_nexthop, *buf); 302582cd038dSYoshinobu Inoue break; 302682cd038dSYoshinobu Inoue 3027f95d4633SHajimu UMEMOTO case IPV6_2292HOPOPTS: 302882cd038dSYoshinobu Inoue case IPV6_HOPOPTS: 302933841545SHajimu UMEMOTO { 303033841545SHajimu UMEMOTO struct ip6_hbh *hbh; 303133841545SHajimu UMEMOTO int hbhlen; 303233841545SHajimu UMEMOTO 3033f95d4633SHajimu UMEMOTO /* 3034f95d4633SHajimu UMEMOTO * XXX: We don't allow a non-privileged user to set ANY HbH 3035f95d4633SHajimu UMEMOTO * options, since per-option restriction has too much 3036f95d4633SHajimu UMEMOTO * overhead. 3037f95d4633SHajimu UMEMOTO */ 3038f95d4633SHajimu UMEMOTO if (!priv) 3039f95d4633SHajimu UMEMOTO return (EPERM); 3040f95d4633SHajimu UMEMOTO 3041f95d4633SHajimu UMEMOTO if (len == 0) { 3042f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, IPV6_HOPOPTS); 3043f95d4633SHajimu UMEMOTO break; /* just remove the option */ 3044f95d4633SHajimu UMEMOTO } 3045f95d4633SHajimu UMEMOTO 3046f95d4633SHajimu UMEMOTO /* message length validation */ 3047f95d4633SHajimu UMEMOTO if (len < sizeof(struct ip6_hbh)) 304882cd038dSYoshinobu Inoue return (EINVAL); 3049f95d4633SHajimu UMEMOTO hbh = (struct ip6_hbh *)buf; 305033841545SHajimu UMEMOTO hbhlen = (hbh->ip6h_len + 1) << 3; 3051f95d4633SHajimu UMEMOTO if (len != hbhlen) 305282cd038dSYoshinobu Inoue return (EINVAL); 305333841545SHajimu UMEMOTO 3054f95d4633SHajimu UMEMOTO /* turn off the previous option, then set the new option. */ 3055f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, IPV6_HOPOPTS); 3056743eee66SSUZUKI Shinsuke opt->ip6po_hbh = malloc(hbhlen, M_IP6OPT, M_NOWAIT); 3057743eee66SSUZUKI Shinsuke if (opt->ip6po_hbh == NULL) 3058743eee66SSUZUKI Shinsuke return (ENOBUFS); 305933841545SHajimu UMEMOTO bcopy(hbh, opt->ip6po_hbh, hbhlen); 3060f95d4633SHajimu UMEMOTO 306182cd038dSYoshinobu Inoue break; 306233841545SHajimu UMEMOTO } 306382cd038dSYoshinobu Inoue 3064f95d4633SHajimu UMEMOTO case IPV6_2292DSTOPTS: 306582cd038dSYoshinobu Inoue case IPV6_DSTOPTS: 3066f95d4633SHajimu UMEMOTO case IPV6_RTHDRDSTOPTS: 306733841545SHajimu UMEMOTO { 3068f95d4633SHajimu UMEMOTO struct ip6_dest *dest, **newdest = NULL; 306933841545SHajimu UMEMOTO int destlen; 307033841545SHajimu UMEMOTO 3071f95d4633SHajimu UMEMOTO if (!priv) /* XXX: see the comment for IPV6_HOPOPTS */ 3072f95d4633SHajimu UMEMOTO return (EPERM); 3073f95d4633SHajimu UMEMOTO 3074f95d4633SHajimu UMEMOTO if (len == 0) { 3075f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, optname); 3076f95d4633SHajimu UMEMOTO break; /* just remove the option */ 3077f95d4633SHajimu UMEMOTO } 3078f95d4633SHajimu UMEMOTO 3079f95d4633SHajimu UMEMOTO /* message length validation */ 3080f95d4633SHajimu UMEMOTO if (len < sizeof(struct ip6_dest)) 308182cd038dSYoshinobu Inoue return (EINVAL); 3082f95d4633SHajimu UMEMOTO dest = (struct ip6_dest *)buf; 308333841545SHajimu UMEMOTO destlen = (dest->ip6d_len + 1) << 3; 3084f95d4633SHajimu UMEMOTO if (len != destlen) 308533841545SHajimu UMEMOTO return (EINVAL); 308682cd038dSYoshinobu Inoue 308782cd038dSYoshinobu Inoue /* 3088f95d4633SHajimu UMEMOTO * Determine the position that the destination options header 3089f95d4633SHajimu UMEMOTO * should be inserted; before or after the routing header. 3090f95d4633SHajimu UMEMOTO */ 3091f95d4633SHajimu UMEMOTO switch (optname) { 3092f95d4633SHajimu UMEMOTO case IPV6_2292DSTOPTS: 3093f95d4633SHajimu UMEMOTO /* 3094f95d4633SHajimu UMEMOTO * The old advacned API is ambiguous on this point. 3095f95d4633SHajimu UMEMOTO * Our approach is to determine the position based 3096f95d4633SHajimu UMEMOTO * according to the existence of a routing header. 3097f95d4633SHajimu UMEMOTO * Note, however, that this depends on the order of the 3098f95d4633SHajimu UMEMOTO * extension headers in the ancillary data; the 1st 3099f95d4633SHajimu UMEMOTO * part of the destination options header must appear 3100f95d4633SHajimu UMEMOTO * before the routing header in the ancillary data, 3101f95d4633SHajimu UMEMOTO * too. 310218b35df8SHajimu UMEMOTO * RFC3542 solved the ambiguity by introducing 3103f95d4633SHajimu UMEMOTO * separate ancillary data or option types. 310482cd038dSYoshinobu Inoue */ 310533841545SHajimu UMEMOTO if (opt->ip6po_rthdr == NULL) 310633841545SHajimu UMEMOTO newdest = &opt->ip6po_dest1; 310733841545SHajimu UMEMOTO else 310833841545SHajimu UMEMOTO newdest = &opt->ip6po_dest2; 3109f95d4633SHajimu UMEMOTO break; 3110f95d4633SHajimu UMEMOTO case IPV6_RTHDRDSTOPTS: 3111f95d4633SHajimu UMEMOTO newdest = &opt->ip6po_dest1; 3112f95d4633SHajimu UMEMOTO break; 3113f95d4633SHajimu UMEMOTO case IPV6_DSTOPTS: 3114f95d4633SHajimu UMEMOTO newdest = &opt->ip6po_dest2; 3115f95d4633SHajimu UMEMOTO break; 3116f95d4633SHajimu UMEMOTO } 311733841545SHajimu UMEMOTO 3118f95d4633SHajimu UMEMOTO /* turn off the previous option, then set the new option. */ 3119f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, optname); 3120743eee66SSUZUKI Shinsuke *newdest = malloc(destlen, M_IP6OPT, M_NOWAIT); 3121fc4c8258SRobert Watson if (*newdest == NULL) 3122743eee66SSUZUKI Shinsuke return (ENOBUFS); 312333841545SHajimu UMEMOTO bcopy(dest, *newdest, destlen); 312433841545SHajimu UMEMOTO 312582cd038dSYoshinobu Inoue break; 312633841545SHajimu UMEMOTO } 312782cd038dSYoshinobu Inoue 3128f95d4633SHajimu UMEMOTO case IPV6_2292RTHDR: 312982cd038dSYoshinobu Inoue case IPV6_RTHDR: 313033841545SHajimu UMEMOTO { 313133841545SHajimu UMEMOTO struct ip6_rthdr *rth; 313233841545SHajimu UMEMOTO int rthlen; 313333841545SHajimu UMEMOTO 3134f95d4633SHajimu UMEMOTO if (len == 0) { 3135f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, IPV6_RTHDR); 3136f95d4633SHajimu UMEMOTO break; /* just remove the option */ 3137f95d4633SHajimu UMEMOTO } 3138f95d4633SHajimu UMEMOTO 3139f95d4633SHajimu UMEMOTO /* message length validation */ 3140f95d4633SHajimu UMEMOTO if (len < sizeof(struct ip6_rthdr)) 314182cd038dSYoshinobu Inoue return (EINVAL); 3142f95d4633SHajimu UMEMOTO rth = (struct ip6_rthdr *)buf; 314333841545SHajimu UMEMOTO rthlen = (rth->ip6r_len + 1) << 3; 3144f95d4633SHajimu UMEMOTO if (len != rthlen) 314582cd038dSYoshinobu Inoue return (EINVAL); 314633841545SHajimu UMEMOTO 314733841545SHajimu UMEMOTO switch (rth->ip6r_type) { 314882cd038dSYoshinobu Inoue case IPV6_RTHDR_TYPE_0: 3149f95d4633SHajimu UMEMOTO if (rth->ip6r_len == 0) /* must contain one addr */ 315033841545SHajimu UMEMOTO return (EINVAL); 3151f95d4633SHajimu UMEMOTO if (rth->ip6r_len % 2) /* length must be even */ 315233841545SHajimu UMEMOTO return (EINVAL); 315333841545SHajimu UMEMOTO if (rth->ip6r_len / 2 != rth->ip6r_segleft) 315482cd038dSYoshinobu Inoue return (EINVAL); 315582cd038dSYoshinobu Inoue break; 315682cd038dSYoshinobu Inoue default: 315733841545SHajimu UMEMOTO return (EINVAL); /* not supported */ 315882cd038dSYoshinobu Inoue } 315933841545SHajimu UMEMOTO 3160f95d4633SHajimu UMEMOTO /* turn off the previous option */ 3161f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, IPV6_RTHDR); 3162743eee66SSUZUKI Shinsuke opt->ip6po_rthdr = malloc(rthlen, M_IP6OPT, M_NOWAIT); 3163743eee66SSUZUKI Shinsuke if (opt->ip6po_rthdr == NULL) 3164743eee66SSUZUKI Shinsuke return (ENOBUFS); 316533841545SHajimu UMEMOTO bcopy(rth, opt->ip6po_rthdr, rthlen); 316633841545SHajimu UMEMOTO 316782cd038dSYoshinobu Inoue break; 316833841545SHajimu UMEMOTO } 316982cd038dSYoshinobu Inoue 3170f95d4633SHajimu UMEMOTO case IPV6_USE_MIN_MTU: 3171f95d4633SHajimu UMEMOTO if (len != sizeof(int)) 3172f95d4633SHajimu UMEMOTO return (EINVAL); 3173f95d4633SHajimu UMEMOTO minmtupolicy = *(int *)buf; 3174f95d4633SHajimu UMEMOTO if (minmtupolicy != IP6PO_MINMTU_MCASTONLY && 3175f95d4633SHajimu UMEMOTO minmtupolicy != IP6PO_MINMTU_DISABLE && 3176f95d4633SHajimu UMEMOTO minmtupolicy != IP6PO_MINMTU_ALL) { 3177f95d4633SHajimu UMEMOTO return (EINVAL); 3178f95d4633SHajimu UMEMOTO } 3179f95d4633SHajimu UMEMOTO opt->ip6po_minmtu = minmtupolicy; 3180f95d4633SHajimu UMEMOTO break; 3181f95d4633SHajimu UMEMOTO 3182f95d4633SHajimu UMEMOTO case IPV6_DONTFRAG: 3183f95d4633SHajimu UMEMOTO if (len != sizeof(int)) 3184f95d4633SHajimu UMEMOTO return (EINVAL); 3185f95d4633SHajimu UMEMOTO 3186f95d4633SHajimu UMEMOTO if (uproto == IPPROTO_TCP || *(int *)buf == 0) { 3187f95d4633SHajimu UMEMOTO /* 3188f95d4633SHajimu UMEMOTO * we ignore this option for TCP sockets. 318918b35df8SHajimu UMEMOTO * (RFC3542 leaves this case unspecified.) 3190f95d4633SHajimu UMEMOTO */ 3191f95d4633SHajimu UMEMOTO opt->ip6po_flags &= ~IP6PO_DONTFRAG; 3192f95d4633SHajimu UMEMOTO } else 3193f95d4633SHajimu UMEMOTO opt->ip6po_flags |= IP6PO_DONTFRAG; 3194f95d4633SHajimu UMEMOTO break; 3195f95d4633SHajimu UMEMOTO 3196f95d4633SHajimu UMEMOTO case IPV6_PREFER_TEMPADDR: 3197f95d4633SHajimu UMEMOTO if (len != sizeof(int)) 3198f95d4633SHajimu UMEMOTO return (EINVAL); 3199f95d4633SHajimu UMEMOTO preftemp = *(int *)buf; 3200f95d4633SHajimu UMEMOTO if (preftemp != IP6PO_TEMPADDR_SYSTEM && 3201f95d4633SHajimu UMEMOTO preftemp != IP6PO_TEMPADDR_NOTPREFER && 3202f95d4633SHajimu UMEMOTO preftemp != IP6PO_TEMPADDR_PREFER) { 3203f95d4633SHajimu UMEMOTO return (EINVAL); 3204f95d4633SHajimu UMEMOTO } 3205f95d4633SHajimu UMEMOTO opt->ip6po_prefer_tempaddr = preftemp; 3206f95d4633SHajimu UMEMOTO break; 3207f95d4633SHajimu UMEMOTO 320882cd038dSYoshinobu Inoue default: 320982cd038dSYoshinobu Inoue return (ENOPROTOOPT); 3210f95d4633SHajimu UMEMOTO } /* end of switch */ 321182cd038dSYoshinobu Inoue 321282cd038dSYoshinobu Inoue return (0); 321382cd038dSYoshinobu Inoue } 321482cd038dSYoshinobu Inoue 321582cd038dSYoshinobu Inoue /* 321682cd038dSYoshinobu Inoue * Routine called from ip6_output() to loop back a copy of an IP6 multicast 321782cd038dSYoshinobu Inoue * packet to the input queue of a specified interface. Note that this 321882cd038dSYoshinobu Inoue * calls the output routine of the loopback "driver", but with an interface 321982cd038dSYoshinobu Inoue * pointer that might NOT be &loif -- easier than replicating that code here. 322082cd038dSYoshinobu Inoue */ 322182cd038dSYoshinobu Inoue void 32221272577eSXin LI ip6_mloopback(struct ifnet *ifp, struct mbuf *m, struct sockaddr_in6 *dst) 322382cd038dSYoshinobu Inoue { 322482cd038dSYoshinobu Inoue struct mbuf *copym; 3225686cdd19SJun-ichiro itojun Hagino struct ip6_hdr *ip6; 322682cd038dSYoshinobu Inoue 322782cd038dSYoshinobu Inoue copym = m_copy(m, 0, M_COPYALL); 3228686cdd19SJun-ichiro itojun Hagino if (copym == NULL) 3229686cdd19SJun-ichiro itojun Hagino return; 3230686cdd19SJun-ichiro itojun Hagino 3231686cdd19SJun-ichiro itojun Hagino /* 3232686cdd19SJun-ichiro itojun Hagino * Make sure to deep-copy IPv6 header portion in case the data 3233686cdd19SJun-ichiro itojun Hagino * is in an mbuf cluster, so that we can safely override the IPv6 3234686cdd19SJun-ichiro itojun Hagino * header portion later. 3235686cdd19SJun-ichiro itojun Hagino */ 3236686cdd19SJun-ichiro itojun Hagino if ((copym->m_flags & M_EXT) != 0 || 3237686cdd19SJun-ichiro itojun Hagino copym->m_len < sizeof(struct ip6_hdr)) { 3238686cdd19SJun-ichiro itojun Hagino copym = m_pullup(copym, sizeof(struct ip6_hdr)); 3239686cdd19SJun-ichiro itojun Hagino if (copym == NULL) 3240686cdd19SJun-ichiro itojun Hagino return; 324182cd038dSYoshinobu Inoue } 3242686cdd19SJun-ichiro itojun Hagino 3243686cdd19SJun-ichiro itojun Hagino #ifdef DIAGNOSTIC 3244686cdd19SJun-ichiro itojun Hagino if (copym->m_len < sizeof(*ip6)) { 3245686cdd19SJun-ichiro itojun Hagino m_freem(copym); 3246686cdd19SJun-ichiro itojun Hagino return; 3247686cdd19SJun-ichiro itojun Hagino } 3248686cdd19SJun-ichiro itojun Hagino #endif 3249686cdd19SJun-ichiro itojun Hagino 3250686cdd19SJun-ichiro itojun Hagino ip6 = mtod(copym, struct ip6_hdr *); 325133841545SHajimu UMEMOTO /* 325233841545SHajimu UMEMOTO * clear embedded scope identifiers if necessary. 325333841545SHajimu UMEMOTO * in6_clearscope will touch the addresses only when necessary. 325433841545SHajimu UMEMOTO */ 325533841545SHajimu UMEMOTO in6_clearscope(&ip6->ip6_src); 325633841545SHajimu UMEMOTO in6_clearscope(&ip6->ip6_dst); 3257686cdd19SJun-ichiro itojun Hagino 3258a89ec05eSPeter Wemm (void)if_simloop(ifp, copym, dst->sin6_family, 0); 325982cd038dSYoshinobu Inoue } 326082cd038dSYoshinobu Inoue 326182cd038dSYoshinobu Inoue /* 326282cd038dSYoshinobu Inoue * Chop IPv6 header off from the payload. 326382cd038dSYoshinobu Inoue */ 326482cd038dSYoshinobu Inoue static int 32651272577eSXin LI ip6_splithdr(struct mbuf *m, struct ip6_exthdrs *exthdrs) 326682cd038dSYoshinobu Inoue { 326782cd038dSYoshinobu Inoue struct mbuf *mh; 326882cd038dSYoshinobu Inoue struct ip6_hdr *ip6; 326982cd038dSYoshinobu Inoue 327082cd038dSYoshinobu Inoue ip6 = mtod(m, struct ip6_hdr *); 327182cd038dSYoshinobu Inoue if (m->m_len > sizeof(*ip6)) { 3272a163d034SWarner Losh MGETHDR(mh, M_DONTWAIT, MT_HEADER); 327382cd038dSYoshinobu Inoue if (mh == 0) { 327482cd038dSYoshinobu Inoue m_freem(m); 327582cd038dSYoshinobu Inoue return ENOBUFS; 327682cd038dSYoshinobu Inoue } 32779967cafcSSam Leffler M_MOVE_PKTHDR(mh, m); 327882cd038dSYoshinobu Inoue MH_ALIGN(mh, sizeof(*ip6)); 327982cd038dSYoshinobu Inoue m->m_len -= sizeof(*ip6); 328082cd038dSYoshinobu Inoue m->m_data += sizeof(*ip6); 328182cd038dSYoshinobu Inoue mh->m_next = m; 328282cd038dSYoshinobu Inoue m = mh; 328382cd038dSYoshinobu Inoue m->m_len = sizeof(*ip6); 328482cd038dSYoshinobu Inoue bcopy((caddr_t)ip6, mtod(m, caddr_t), sizeof(*ip6)); 328582cd038dSYoshinobu Inoue } 328682cd038dSYoshinobu Inoue exthdrs->ip6e_ip6 = m; 328782cd038dSYoshinobu Inoue return 0; 328882cd038dSYoshinobu Inoue } 328982cd038dSYoshinobu Inoue 329082cd038dSYoshinobu Inoue /* 329182cd038dSYoshinobu Inoue * Compute IPv6 extension header length. 329282cd038dSYoshinobu Inoue */ 329382cd038dSYoshinobu Inoue int 32941272577eSXin LI ip6_optlen(struct in6pcb *in6p) 329582cd038dSYoshinobu Inoue { 329682cd038dSYoshinobu Inoue int len; 329782cd038dSYoshinobu Inoue 329882cd038dSYoshinobu Inoue if (!in6p->in6p_outputopts) 329982cd038dSYoshinobu Inoue return 0; 330082cd038dSYoshinobu Inoue 330182cd038dSYoshinobu Inoue len = 0; 330282cd038dSYoshinobu Inoue #define elen(x) \ 330382cd038dSYoshinobu Inoue (((struct ip6_ext *)(x)) ? (((struct ip6_ext *)(x))->ip6e_len + 1) << 3 : 0) 330482cd038dSYoshinobu Inoue 330582cd038dSYoshinobu Inoue len += elen(in6p->in6p_outputopts->ip6po_hbh); 330633841545SHajimu UMEMOTO if (in6p->in6p_outputopts->ip6po_rthdr) 330733841545SHajimu UMEMOTO /* dest1 is valid with rthdr only */ 330882cd038dSYoshinobu Inoue len += elen(in6p->in6p_outputopts->ip6po_dest1); 330982cd038dSYoshinobu Inoue len += elen(in6p->in6p_outputopts->ip6po_rthdr); 331082cd038dSYoshinobu Inoue len += elen(in6p->in6p_outputopts->ip6po_dest2); 331182cd038dSYoshinobu Inoue return len; 331282cd038dSYoshinobu Inoue #undef elen 331382cd038dSYoshinobu Inoue } 3314