1caf43b02SWarner Losh /*- 251369649SPedro F. Giffuni * SPDX-License-Identifier: BSD-3-Clause 351369649SPedro F. Giffuni * 482cd038dSYoshinobu Inoue * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. 582cd038dSYoshinobu Inoue * All rights reserved. 682cd038dSYoshinobu Inoue * 782cd038dSYoshinobu Inoue * Redistribution and use in source and binary forms, with or without 882cd038dSYoshinobu Inoue * modification, are permitted provided that the following conditions 982cd038dSYoshinobu Inoue * are met: 1082cd038dSYoshinobu Inoue * 1. Redistributions of source code must retain the above copyright 1182cd038dSYoshinobu Inoue * notice, this list of conditions and the following disclaimer. 1282cd038dSYoshinobu Inoue * 2. Redistributions in binary form must reproduce the above copyright 1382cd038dSYoshinobu Inoue * notice, this list of conditions and the following disclaimer in the 1482cd038dSYoshinobu Inoue * documentation and/or other materials provided with the distribution. 1582cd038dSYoshinobu Inoue * 3. Neither the name of the project nor the names of its contributors 1682cd038dSYoshinobu Inoue * may be used to endorse or promote products derived from this software 1782cd038dSYoshinobu Inoue * without specific prior written permission. 1882cd038dSYoshinobu Inoue * 1982cd038dSYoshinobu Inoue * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 2082cd038dSYoshinobu Inoue * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 2182cd038dSYoshinobu Inoue * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 2282cd038dSYoshinobu Inoue * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 2382cd038dSYoshinobu Inoue * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2482cd038dSYoshinobu Inoue * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2582cd038dSYoshinobu Inoue * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2682cd038dSYoshinobu Inoue * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2782cd038dSYoshinobu Inoue * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2882cd038dSYoshinobu Inoue * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2982cd038dSYoshinobu Inoue * SUCH DAMAGE. 30b48287a3SDavid E. O'Brien * 31b48287a3SDavid E. O'Brien * $KAME: ip6_output.c,v 1.279 2002/01/26 06:12:30 jinmei Exp $ 3282cd038dSYoshinobu Inoue */ 3382cd038dSYoshinobu Inoue 34caf43b02SWarner Losh /*- 3582cd038dSYoshinobu Inoue * Copyright (c) 1982, 1986, 1988, 1990, 1993 3682cd038dSYoshinobu Inoue * The Regents of the University of California. All rights reserved. 3782cd038dSYoshinobu Inoue * 3882cd038dSYoshinobu Inoue * Redistribution and use in source and binary forms, with or without 3982cd038dSYoshinobu Inoue * modification, are permitted provided that the following conditions 4082cd038dSYoshinobu Inoue * are met: 4182cd038dSYoshinobu Inoue * 1. Redistributions of source code must retain the above copyright 4282cd038dSYoshinobu Inoue * notice, this list of conditions and the following disclaimer. 4382cd038dSYoshinobu Inoue * 2. Redistributions in binary form must reproduce the above copyright 4482cd038dSYoshinobu Inoue * notice, this list of conditions and the following disclaimer in the 4582cd038dSYoshinobu Inoue * documentation and/or other materials provided with the distribution. 46fbbd9655SWarner Losh * 3. Neither the name of the University nor the names of its contributors 4782cd038dSYoshinobu Inoue * may be used to endorse or promote products derived from this software 4882cd038dSYoshinobu Inoue * without specific prior written permission. 4982cd038dSYoshinobu Inoue * 5082cd038dSYoshinobu Inoue * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 5182cd038dSYoshinobu Inoue * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 5282cd038dSYoshinobu Inoue * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 5382cd038dSYoshinobu Inoue * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 5482cd038dSYoshinobu Inoue * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 5582cd038dSYoshinobu Inoue * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 5682cd038dSYoshinobu Inoue * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 5782cd038dSYoshinobu Inoue * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 5882cd038dSYoshinobu Inoue * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 5982cd038dSYoshinobu Inoue * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 6082cd038dSYoshinobu Inoue * SUCH DAMAGE. 6182cd038dSYoshinobu Inoue * 6282cd038dSYoshinobu Inoue * @(#)ip_output.c 8.3 (Berkeley) 1/21/94 6382cd038dSYoshinobu Inoue */ 6482cd038dSYoshinobu Inoue 65b48287a3SDavid E. O'Brien #include <sys/cdefs.h> 66b48287a3SDavid E. O'Brien __FBSDID("$FreeBSD$"); 67b48287a3SDavid E. O'Brien 68686cdd19SJun-ichiro itojun Hagino #include "opt_inet.h" 69686cdd19SJun-ichiro itojun Hagino #include "opt_inet6.h" 70f3e7afe2SHans Petter Selasky #include "opt_ratelimit.h" 71686cdd19SJun-ichiro itojun Hagino #include "opt_ipsec.h" 729b03990aSRandall Stewart #include "opt_sctp.h" 7377931dd5SKip Macy #include "opt_route.h" 74c7c0d948SAdrian Chadd #include "opt_rss.h" 7582cd038dSYoshinobu Inoue 7682cd038dSYoshinobu Inoue #include <sys/param.h> 77c26fe973SBjoern A. Zeeb #include <sys/kernel.h> 7882cd038dSYoshinobu Inoue #include <sys/malloc.h> 7982cd038dSYoshinobu Inoue #include <sys/mbuf.h> 8082cd038dSYoshinobu Inoue #include <sys/errno.h> 81c2259ba4SRobert Watson #include <sys/priv.h> 82c26fe973SBjoern A. Zeeb #include <sys/proc.h> 8382cd038dSYoshinobu Inoue #include <sys/protosw.h> 8482cd038dSYoshinobu Inoue #include <sys/socket.h> 8582cd038dSYoshinobu Inoue #include <sys/socketvar.h> 861263305fSBjoern A. Zeeb #include <sys/syslog.h> 87c26fe973SBjoern A. Zeeb #include <sys/ucred.h> 8882cd038dSYoshinobu Inoue 89e7b92e27SBjoern A. Zeeb #include <machine/in_cksum.h> 90e7b92e27SBjoern A. Zeeb 9182cd038dSYoshinobu Inoue #include <net/if.h> 9276039bc8SGleb Smirnoff #include <net/if_var.h> 930f5687f2SMike Karels #include <net/if_llatbl.h> 948195404bSBrooks Davis #include <net/netisr.h> 9582cd038dSYoshinobu Inoue #include <net/route.h> 96c4ac87eaSDarren Reed #include <net/pfil.h> 97b2bdc62aSAdrian Chadd #include <net/rss_config.h> 984b79449eSBjoern A. Zeeb #include <net/vnet.h> 9982cd038dSYoshinobu Inoue 10082cd038dSYoshinobu Inoue #include <netinet/in.h> 10182cd038dSYoshinobu Inoue #include <netinet/in_var.h> 1028a006adbSBjoern A. Zeeb #include <netinet/ip_var.h> 103bacf6684SAlexander V. Chernikov #include <netinet6/in6_fib.h> 10433841545SHajimu UMEMOTO #include <netinet6/in6_var.h> 105686cdd19SJun-ichiro itojun Hagino #include <netinet/ip6.h> 106686cdd19SJun-ichiro itojun Hagino #include <netinet/icmp6.h> 10782cd038dSYoshinobu Inoue #include <netinet6/ip6_var.h> 108686cdd19SJun-ichiro itojun Hagino #include <netinet/in_pcb.h> 10997d8d152SAndre Oppermann #include <netinet/tcp_var.h> 11082cd038dSYoshinobu Inoue #include <netinet6/nd6.h> 111b2bdc62aSAdrian Chadd #include <netinet6/in6_rss.h> 11282cd038dSYoshinobu Inoue 113fcf59617SAndrey V. Elsukov #include <netipsec/ipsec_support.h> 1149b03990aSRandall Stewart #ifdef SCTP 1159b03990aSRandall Stewart #include <netinet/sctp.h> 1169b03990aSRandall Stewart #include <netinet/sctp_crc32.h> 1179b03990aSRandall Stewart #endif 118b9234fafSSam Leffler 1191469c434SHajimu UMEMOTO #include <netinet6/ip6protosw.h> 120a1f7e5f8SHajimu UMEMOTO #include <netinet6/scope6_var.h> 1211469c434SHajimu UMEMOTO 12233cde130SBruce M Simpson extern int in6_mcast_loop; 12382cd038dSYoshinobu Inoue 12482cd038dSYoshinobu Inoue struct ip6_exthdrs { 12582cd038dSYoshinobu Inoue struct mbuf *ip6e_ip6; 12682cd038dSYoshinobu Inoue struct mbuf *ip6e_hbh; 12782cd038dSYoshinobu Inoue struct mbuf *ip6e_dest1; 12882cd038dSYoshinobu Inoue struct mbuf *ip6e_rthdr; 12982cd038dSYoshinobu Inoue struct mbuf *ip6e_dest2; 13082cd038dSYoshinobu Inoue }; 13182cd038dSYoshinobu Inoue 1325e0a6f31SMark Johnston static MALLOC_DEFINE(M_IP6OPT, "ip6opt", "IPv6 options"); 1335e0a6f31SMark Johnston 1346f56329aSXin LI static int ip6_pcbopt(int, u_char *, int, struct ip6_pktopts **, 1356f56329aSXin LI struct ucred *, int); 1366f56329aSXin LI static int ip6_pcbopts(struct ip6_pktopts **, struct mbuf *, 1376f56329aSXin LI struct socket *, struct sockopt *); 13806b479a6SSean Bruno static int ip6_getpcbopt(struct inpcb *, int, struct sockopt *); 1396f56329aSXin LI static int ip6_setpktopt(int, u_char *, int, struct ip6_pktopts *, 1406f56329aSXin LI struct ucred *, int, int, int); 141f95d4633SHajimu UMEMOTO 1429233d8f3SDavid E. O'Brien static int ip6_copyexthdr(struct mbuf **, caddr_t, int); 1436f56329aSXin LI static int ip6_insertfraghdr(struct mbuf *, struct mbuf *, int, 1446f56329aSXin LI struct ip6_frag **); 1459233d8f3SDavid E. O'Brien static int ip6_insert_jumboopt(struct ip6_exthdrs *, u_int32_t); 1469233d8f3SDavid E. O'Brien static int ip6_splithdr(struct mbuf *, struct ip6_exthdrs *); 1470d4df029SAlexander V. Chernikov static int ip6_getpmtu(struct route_in6 *, int, 148d4c22202SAndrew Gallatin struct ifnet *, const struct in6_addr *, u_long *, int *, u_int, 149d4c22202SAndrew Gallatin u_int); 1500d4df029SAlexander V. Chernikov static int ip6_calcmtu(struct ifnet *, const struct in6_addr *, u_long, 151d4c22202SAndrew Gallatin u_long *, int *, u_int); 152f0937b2cSAndrey V. Elsukov static int ip6_getpmtu_ctl(u_int, const struct in6_addr *, u_long *); 1539233d8f3SDavid E. O'Brien static int copypktopts(struct ip6_pktopts *, struct ip6_pktopts *, int); 15482cd038dSYoshinobu Inoue 1557efe5d92SHajimu UMEMOTO 15682cd038dSYoshinobu Inoue /* 1572cb64cb2SGeorge V. Neville-Neil * Make an extension header from option data. hp is the source, and 1582cb64cb2SGeorge V. Neville-Neil * mp is the destination. 1592cb64cb2SGeorge V. Neville-Neil */ 1602cb64cb2SGeorge V. Neville-Neil #define MAKE_EXTHDR(hp, mp) \ 1612cb64cb2SGeorge V. Neville-Neil do { \ 1622cb64cb2SGeorge V. Neville-Neil if (hp) { \ 1632cb64cb2SGeorge V. Neville-Neil struct ip6_ext *eh = (struct ip6_ext *)(hp); \ 1642cb64cb2SGeorge V. Neville-Neil error = ip6_copyexthdr((mp), (caddr_t)(hp), \ 1652cb64cb2SGeorge V. Neville-Neil ((eh)->ip6e_len + 1) << 3); \ 1662cb64cb2SGeorge V. Neville-Neil if (error) \ 1672cb64cb2SGeorge V. Neville-Neil goto freehdrs; \ 1682cb64cb2SGeorge V. Neville-Neil } \ 1692cb64cb2SGeorge V. Neville-Neil } while (/*CONSTCOND*/ 0) 1702cb64cb2SGeorge V. Neville-Neil 1712cb64cb2SGeorge V. Neville-Neil /* 1722cb64cb2SGeorge V. Neville-Neil * Form a chain of extension headers. 1732cb64cb2SGeorge V. Neville-Neil * m is the extension header mbuf 1742cb64cb2SGeorge V. Neville-Neil * mp is the previous mbuf in the chain 1752cb64cb2SGeorge V. Neville-Neil * p is the next header 1762cb64cb2SGeorge V. Neville-Neil * i is the type of option. 1772cb64cb2SGeorge V. Neville-Neil */ 1782cb64cb2SGeorge V. Neville-Neil #define MAKE_CHAIN(m, mp, p, i)\ 1792cb64cb2SGeorge V. Neville-Neil do {\ 1802cb64cb2SGeorge V. Neville-Neil if (m) {\ 1812cb64cb2SGeorge V. Neville-Neil if (!hdrsplit) \ 1822cb64cb2SGeorge V. Neville-Neil panic("assumption failed: hdr not split"); \ 1832cb64cb2SGeorge V. Neville-Neil *mtod((m), u_char *) = *(p);\ 1842cb64cb2SGeorge V. Neville-Neil *(p) = (i);\ 1852cb64cb2SGeorge V. Neville-Neil p = mtod((m), u_char *);\ 1862cb64cb2SGeorge V. Neville-Neil (m)->m_next = (mp)->m_next;\ 1872cb64cb2SGeorge V. Neville-Neil (mp)->m_next = (m);\ 1882cb64cb2SGeorge V. Neville-Neil (mp) = (m);\ 1892cb64cb2SGeorge V. Neville-Neil }\ 1902cb64cb2SGeorge V. Neville-Neil } while (/*CONSTCOND*/ 0) 1912cb64cb2SGeorge V. Neville-Neil 192aaf2cfc0SVANHULLEBUS Yvan void 193e7b92e27SBjoern A. Zeeb in6_delayed_cksum(struct mbuf *m, uint32_t plen, u_short offset) 194e7b92e27SBjoern A. Zeeb { 195e7b92e27SBjoern A. Zeeb u_short csum; 196e7b92e27SBjoern A. Zeeb 197c69baa7eSBjoern A. Zeeb csum = in_cksum_skip(m, offset + plen, offset); 198356ab07eSBjoern A. Zeeb if (m->m_pkthdr.csum_flags & CSUM_UDP_IPV6 && csum == 0) 199e7b92e27SBjoern A. Zeeb csum = 0xffff; 200e7b92e27SBjoern A. Zeeb offset += m->m_pkthdr.csum_data; /* checksum offset */ 201e7b92e27SBjoern A. Zeeb 202e7b92e27SBjoern A. Zeeb if (offset + sizeof(u_short) > m->m_len) { 20368c99a60SBjoern A. Zeeb printf("%s: delayed m_pullup, m->len: %d plen %u off %u " 2041b4381afSAndre Oppermann "csum_flags=%b\n", __func__, m->m_len, plen, offset, 2051b4381afSAndre Oppermann (int)m->m_pkthdr.csum_flags, CSUM_BITS); 206e7b92e27SBjoern A. Zeeb /* 207e7b92e27SBjoern A. Zeeb * XXX this should not happen, but if it does, the correct 208e7b92e27SBjoern A. Zeeb * behavior may be to insert the checksum in the appropriate 209e7b92e27SBjoern A. Zeeb * next mbuf in the chain. 210e7b92e27SBjoern A. Zeeb */ 211e7b92e27SBjoern A. Zeeb return; 212e7b92e27SBjoern A. Zeeb } 213e7b92e27SBjoern A. Zeeb *(u_short *)(m->m_data + offset) = csum; 214e7b92e27SBjoern A. Zeeb } 215e7b92e27SBjoern A. Zeeb 2166c269f69SGleb Smirnoff int 2176c269f69SGleb Smirnoff ip6_fragment(struct ifnet *ifp, struct mbuf *m0, int hlen, u_char nextproto, 218d78c0804SKristof Provost int fraglen , uint32_t id) 2196c269f69SGleb Smirnoff { 2206c269f69SGleb Smirnoff struct mbuf *m, **mnext, *m_frgpart; 2216c269f69SGleb Smirnoff struct ip6_hdr *ip6, *mhip6; 2226c269f69SGleb Smirnoff struct ip6_frag *ip6f; 2236c269f69SGleb Smirnoff int off; 2246c269f69SGleb Smirnoff int error; 2256c269f69SGleb Smirnoff int tlen = m0->m_pkthdr.len; 2266c269f69SGleb Smirnoff 227d78c0804SKristof Provost KASSERT((fraglen % 8 == 0), ("Fragment length must be a multiple of 8")); 22800eab743SKristof Provost 2296c269f69SGleb Smirnoff m = m0; 2306c269f69SGleb Smirnoff ip6 = mtod(m, struct ip6_hdr *); 2316c269f69SGleb Smirnoff mnext = &m->m_nextpkt; 2326c269f69SGleb Smirnoff 233d78c0804SKristof Provost for (off = hlen; off < tlen; off += fraglen) { 2346c269f69SGleb Smirnoff m = m_gethdr(M_NOWAIT, MT_DATA); 2356c269f69SGleb Smirnoff if (!m) { 2366c269f69SGleb Smirnoff IP6STAT_INC(ip6s_odropped); 2376c269f69SGleb Smirnoff return (ENOBUFS); 2386c269f69SGleb Smirnoff } 2396c269f69SGleb Smirnoff m->m_flags = m0->m_flags & M_COPYFLAGS; 2406c269f69SGleb Smirnoff *mnext = m; 2416c269f69SGleb Smirnoff mnext = &m->m_nextpkt; 2426c269f69SGleb Smirnoff m->m_data += max_linkhdr; 2436c269f69SGleb Smirnoff mhip6 = mtod(m, struct ip6_hdr *); 2446c269f69SGleb Smirnoff *mhip6 = *ip6; 2456c269f69SGleb Smirnoff m->m_len = sizeof(*mhip6); 2466c269f69SGleb Smirnoff error = ip6_insertfraghdr(m0, m, hlen, &ip6f); 2476c269f69SGleb Smirnoff if (error) { 2486c269f69SGleb Smirnoff IP6STAT_INC(ip6s_odropped); 2496c269f69SGleb Smirnoff return (error); 2506c269f69SGleb Smirnoff } 2516c269f69SGleb Smirnoff ip6f->ip6f_offlg = htons((u_short)((off - hlen) & ~7)); 252d78c0804SKristof Provost if (off + fraglen >= tlen) 253d78c0804SKristof Provost fraglen = tlen - off; 2546c269f69SGleb Smirnoff else 2556c269f69SGleb Smirnoff ip6f->ip6f_offlg |= IP6F_MORE_FRAG; 256d78c0804SKristof Provost mhip6->ip6_plen = htons((u_short)(fraglen + hlen + 2576c269f69SGleb Smirnoff sizeof(*ip6f) - sizeof(struct ip6_hdr))); 258d78c0804SKristof Provost if ((m_frgpart = m_copym(m0, off, fraglen, M_NOWAIT)) == NULL) { 2596c269f69SGleb Smirnoff IP6STAT_INC(ip6s_odropped); 2606c269f69SGleb Smirnoff return (ENOBUFS); 2616c269f69SGleb Smirnoff } 2626c269f69SGleb Smirnoff m_cat(m, m_frgpart); 263d78c0804SKristof Provost m->m_pkthdr.len = fraglen + hlen + sizeof(*ip6f); 2646c269f69SGleb Smirnoff m->m_pkthdr.fibnum = m0->m_pkthdr.fibnum; 2656c269f69SGleb Smirnoff m->m_pkthdr.rcvif = NULL; 2666c269f69SGleb Smirnoff ip6f->ip6f_reserved = 0; 2676c269f69SGleb Smirnoff ip6f->ip6f_ident = id; 2686c269f69SGleb Smirnoff ip6f->ip6f_nxt = nextproto; 2696c269f69SGleb Smirnoff IP6STAT_INC(ip6s_ofragments); 2706c269f69SGleb Smirnoff in6_ifstat_inc(ifp, ifs6_out_fragcreat); 2716c269f69SGleb Smirnoff } 2726c269f69SGleb Smirnoff 2736c269f69SGleb Smirnoff return (0); 2746c269f69SGleb Smirnoff } 2756c269f69SGleb Smirnoff 2762cb64cb2SGeorge V. Neville-Neil /* 27782cd038dSYoshinobu Inoue * IP6 output. The packet in mbuf chain m contains a skeletal IP6 27882cd038dSYoshinobu Inoue * header (with pri, len, nxt, hlim, src, dst). 27982cd038dSYoshinobu Inoue * This function may modify ver and hlim only. 28082cd038dSYoshinobu Inoue * The mbuf chain containing the packet will be freed. 28182cd038dSYoshinobu Inoue * The mbuf opt, if present, will not be freed. 282bf984051SGleb Smirnoff * If route_in6 ro is present and has ro_rt initialized, route lookup would be 283bf984051SGleb Smirnoff * skipped and ro->ro_rt would be used. If ro is present but ro->ro_rt is NULL, 284bf984051SGleb Smirnoff * then result of route lookup is stored in ro->ro_rt. 28533841545SHajimu UMEMOTO * 286e3a7aa6fSGleb Smirnoff * type of "mtu": rt_mtu is u_long, ifnet.ifr_mtu is int, and 28733841545SHajimu UMEMOTO * nd_ifinfo.linkmtu is u_int32_t. so we use u_long to hold largest one, 288e3a7aa6fSGleb Smirnoff * which is rt_mtu. 2891272577eSXin LI * 2901272577eSXin LI * ifpp - XXX: just for statistics 29182cd038dSYoshinobu Inoue */ 292b174de32SAdrian Chadd /* 293b174de32SAdrian Chadd * XXX TODO: no flowid is assigned for outbound flows? 294b174de32SAdrian Chadd */ 29582cd038dSYoshinobu Inoue int 2961272577eSXin LI ip6_output(struct mbuf *m0, struct ip6_pktopts *opt, 2971272577eSXin LI struct route_in6 *ro, int flags, struct ip6_moptions *im6o, 2981272577eSXin LI struct ifnet **ifpp, struct inpcb *inp) 29982cd038dSYoshinobu Inoue { 3006c269f69SGleb Smirnoff struct ip6_hdr *ip6; 301686cdd19SJun-ichiro itojun Hagino struct ifnet *ifp, *origifp; 30282cd038dSYoshinobu Inoue struct mbuf *m = m0; 3032cb64cb2SGeorge V. Neville-Neil struct mbuf *mprev = NULL; 3046c269f69SGleb Smirnoff int hlen, tlen, len; 30582cd038dSYoshinobu Inoue struct route_in6 ip6route; 306a1f7e5f8SHajimu UMEMOTO struct rtentry *rt = NULL; 307a1f7e5f8SHajimu UMEMOTO struct sockaddr_in6 *dst, src_sa, dst_sa; 3088195404bSBrooks Davis struct in6_addr odst; 30982cd038dSYoshinobu Inoue int error = 0; 3105da9f8faSJosef Karthauser struct in6_ifaddr *ia = NULL; 31182cd038dSYoshinobu Inoue u_long mtu; 312f95d4633SHajimu UMEMOTO int alwaysfrag, dontfrag; 31382cd038dSYoshinobu Inoue u_int32_t optlen = 0, plen = 0, unfragpartlen = 0; 31482cd038dSYoshinobu Inoue struct ip6_exthdrs exthdrs; 315f0937b2cSAndrey V. Elsukov struct in6_addr src0, dst0; 316a1f7e5f8SHajimu UMEMOTO u_int32_t zone; 31782cd038dSYoshinobu Inoue struct route_in6 *ro_pmtu = NULL; 31882cd038dSYoshinobu Inoue int hdrsplit = 0; 319e7b92e27SBjoern A. Zeeb int sw_csum, tso; 3209c57a5b6SHiroki Sato int needfiblookup; 3219c57a5b6SHiroki Sato uint32_t fibnum; 322f8fe3dc9SAndrey V. Elsukov struct m_tag *fwd_tag = NULL; 32379831849SKristof Provost uint32_t id; 324b9234fafSSam Leffler 325b174de32SAdrian Chadd if (inp != NULL) { 326ce9ac139SNavdeep Parhar INP_LOCK_ASSERT(inp); 32781d5d46bSBjoern A. Zeeb M_SETFIB(m, inp->inp_inc.inc_fibnum); 328c2529042SHans Petter Selasky if ((flags & IP_NODEFAULTFLOWID) == 0) { 329c2529042SHans Petter Selasky /* unconditionally set flowid */ 330b174de32SAdrian Chadd m->m_pkthdr.flowid = inp->inp_flowid; 331c2529042SHans Petter Selasky M_HASHTYPE_SET(m, inp->inp_flowtype); 332b174de32SAdrian Chadd } 333b174de32SAdrian Chadd } 33481d5d46bSBjoern A. Zeeb 335fcf59617SAndrey V. Elsukov #if defined(IPSEC) || defined(IPSEC_SUPPORT) 336fcf59617SAndrey V. Elsukov /* 337fcf59617SAndrey V. Elsukov * IPSec checking which handles several cases. 338fcf59617SAndrey V. Elsukov * FAST IPSEC: We re-injected the packet. 339fcf59617SAndrey V. Elsukov * XXX: need scope argument. 340fcf59617SAndrey V. Elsukov */ 341fcf59617SAndrey V. Elsukov if (IPSEC_ENABLED(ipv6)) { 342fcf59617SAndrey V. Elsukov if ((error = IPSEC_OUTPUT(ipv6, m, inp)) != 0) { 343fcf59617SAndrey V. Elsukov if (error == EINPROGRESS) 344fcf59617SAndrey V. Elsukov error = 0; 345fcf59617SAndrey V. Elsukov goto done; 346fcf59617SAndrey V. Elsukov } 347fcf59617SAndrey V. Elsukov } 348fcf59617SAndrey V. Elsukov #endif /* IPSEC */ 349fcf59617SAndrey V. Elsukov 35082cd038dSYoshinobu Inoue bzero(&exthdrs, sizeof(exthdrs)); 35182cd038dSYoshinobu Inoue if (opt) { 35282cd038dSYoshinobu Inoue /* Hop-by-Hop options header */ 35382cd038dSYoshinobu Inoue MAKE_EXTHDR(opt->ip6po_hbh, &exthdrs.ip6e_hbh); 35482cd038dSYoshinobu Inoue /* Destination options header(1st part) */ 35529bc2c48SHajimu UMEMOTO if (opt->ip6po_rthdr) { 35629bc2c48SHajimu UMEMOTO /* 35729bc2c48SHajimu UMEMOTO * Destination options header(1st part) 3582cb64cb2SGeorge V. Neville-Neil * This only makes sense with a routing header. 35929bc2c48SHajimu UMEMOTO * See Section 9.2 of RFC 3542. 36029bc2c48SHajimu UMEMOTO * Disabling this part just for MIP6 convenience is 36129bc2c48SHajimu UMEMOTO * a bad idea. We need to think carefully about a 36229bc2c48SHajimu UMEMOTO * way to make the advanced API coexist with MIP6 36329bc2c48SHajimu UMEMOTO * options, which might automatically be inserted in 36429bc2c48SHajimu UMEMOTO * the kernel. 36529bc2c48SHajimu UMEMOTO */ 36682cd038dSYoshinobu Inoue MAKE_EXTHDR(opt->ip6po_dest1, &exthdrs.ip6e_dest1); 36729bc2c48SHajimu UMEMOTO } 36882cd038dSYoshinobu Inoue /* Routing header */ 36982cd038dSYoshinobu Inoue MAKE_EXTHDR(opt->ip6po_rthdr, &exthdrs.ip6e_rthdr); 37082cd038dSYoshinobu Inoue /* Destination options header(2nd part) */ 37182cd038dSYoshinobu Inoue MAKE_EXTHDR(opt->ip6po_dest2, &exthdrs.ip6e_dest2); 37282cd038dSYoshinobu Inoue } 37382cd038dSYoshinobu Inoue 37482cd038dSYoshinobu Inoue /* 37582cd038dSYoshinobu Inoue * Calculate the total length of the extension header chain. 37682cd038dSYoshinobu Inoue * Keep the length of the unfragmentable part for fragmentation. 37782cd038dSYoshinobu Inoue */ 37882cd038dSYoshinobu Inoue optlen = 0; 3792cb64cb2SGeorge V. Neville-Neil if (exthdrs.ip6e_hbh) 3802cb64cb2SGeorge V. Neville-Neil optlen += exthdrs.ip6e_hbh->m_len; 3812cb64cb2SGeorge V. Neville-Neil if (exthdrs.ip6e_dest1) 3822cb64cb2SGeorge V. Neville-Neil optlen += exthdrs.ip6e_dest1->m_len; 3832cb64cb2SGeorge V. Neville-Neil if (exthdrs.ip6e_rthdr) 3842cb64cb2SGeorge V. Neville-Neil optlen += exthdrs.ip6e_rthdr->m_len; 38582cd038dSYoshinobu Inoue unfragpartlen = optlen + sizeof(struct ip6_hdr); 3862cb64cb2SGeorge V. Neville-Neil 387aaf2cfc0SVANHULLEBUS Yvan /* NOTE: we don't add AH/ESP length here (done in ip6_ipsec_output) */ 3882cb64cb2SGeorge V. Neville-Neil if (exthdrs.ip6e_dest2) 3892cb64cb2SGeorge V. Neville-Neil optlen += exthdrs.ip6e_dest2->m_len; 39082cd038dSYoshinobu Inoue 39182cd038dSYoshinobu Inoue /* 392aaf2cfc0SVANHULLEBUS Yvan * If there is at least one extension header, 39382cd038dSYoshinobu Inoue * separate IP6 header from the payload. 39482cd038dSYoshinobu Inoue */ 395aaf2cfc0SVANHULLEBUS Yvan if (optlen && !hdrsplit) { 39682cd038dSYoshinobu Inoue if ((error = ip6_splithdr(m, &exthdrs)) != 0) { 39782cd038dSYoshinobu Inoue m = NULL; 39882cd038dSYoshinobu Inoue goto freehdrs; 39982cd038dSYoshinobu Inoue } 40082cd038dSYoshinobu Inoue m = exthdrs.ip6e_ip6; 40182cd038dSYoshinobu Inoue hdrsplit++; 40282cd038dSYoshinobu Inoue } 40382cd038dSYoshinobu Inoue 40482cd038dSYoshinobu Inoue ip6 = mtod(m, struct ip6_hdr *); 40582cd038dSYoshinobu Inoue 40682cd038dSYoshinobu Inoue /* adjust mbuf packet header length */ 40782cd038dSYoshinobu Inoue m->m_pkthdr.len += optlen; 40882cd038dSYoshinobu Inoue plen = m->m_pkthdr.len - sizeof(*ip6); 40982cd038dSYoshinobu Inoue 41082cd038dSYoshinobu Inoue /* If this is a jumbo payload, insert a jumbo payload option. */ 41182cd038dSYoshinobu Inoue if (plen > IPV6_MAXPACKET) { 41282cd038dSYoshinobu Inoue if (!hdrsplit) { 41382cd038dSYoshinobu Inoue if ((error = ip6_splithdr(m, &exthdrs)) != 0) { 41482cd038dSYoshinobu Inoue m = NULL; 41582cd038dSYoshinobu Inoue goto freehdrs; 41682cd038dSYoshinobu Inoue } 41782cd038dSYoshinobu Inoue m = exthdrs.ip6e_ip6; 41882cd038dSYoshinobu Inoue hdrsplit++; 41982cd038dSYoshinobu Inoue } 42082cd038dSYoshinobu Inoue /* adjust pointer */ 42182cd038dSYoshinobu Inoue ip6 = mtod(m, struct ip6_hdr *); 42282cd038dSYoshinobu Inoue if ((error = ip6_insert_jumboopt(&exthdrs, plen)) != 0) 42382cd038dSYoshinobu Inoue goto freehdrs; 42482cd038dSYoshinobu Inoue ip6->ip6_plen = 0; 42582cd038dSYoshinobu Inoue } else 42682cd038dSYoshinobu Inoue ip6->ip6_plen = htons(plen); 42782cd038dSYoshinobu Inoue 42882cd038dSYoshinobu Inoue /* 42982cd038dSYoshinobu Inoue * Concatenate headers and fill in next header fields. 43082cd038dSYoshinobu Inoue * Here we have, on "m" 43182cd038dSYoshinobu Inoue * IPv6 payload 43282cd038dSYoshinobu Inoue * and we insert headers accordingly. Finally, we should be getting: 43382cd038dSYoshinobu Inoue * IPv6 hbh dest1 rthdr ah* [esp* dest2 payload] 43482cd038dSYoshinobu Inoue * 43582cd038dSYoshinobu Inoue * during the header composing process, "m" points to IPv6 header. 43682cd038dSYoshinobu Inoue * "mprev" points to an extension header prior to esp. 43782cd038dSYoshinobu Inoue */ 43882cd038dSYoshinobu Inoue u_char *nexthdrp = &ip6->ip6_nxt; 4392cb64cb2SGeorge V. Neville-Neil mprev = m; 44082cd038dSYoshinobu Inoue 44182cd038dSYoshinobu Inoue /* 44282cd038dSYoshinobu Inoue * we treat dest2 specially. this makes IPsec processing 44388ff5695SSUZUKI Shinsuke * much easier. the goal here is to make mprev point the 44488ff5695SSUZUKI Shinsuke * mbuf prior to dest2. 44582cd038dSYoshinobu Inoue * 44682cd038dSYoshinobu Inoue * result: IPv6 dest2 payload 44782cd038dSYoshinobu Inoue * m and mprev will point to IPv6 header. 44882cd038dSYoshinobu Inoue */ 44982cd038dSYoshinobu Inoue if (exthdrs.ip6e_dest2) { 45082cd038dSYoshinobu Inoue if (!hdrsplit) 45182cd038dSYoshinobu Inoue panic("assumption failed: hdr not split"); 45282cd038dSYoshinobu Inoue exthdrs.ip6e_dest2->m_next = m->m_next; 45382cd038dSYoshinobu Inoue m->m_next = exthdrs.ip6e_dest2; 45482cd038dSYoshinobu Inoue *mtod(exthdrs.ip6e_dest2, u_char *) = ip6->ip6_nxt; 45582cd038dSYoshinobu Inoue ip6->ip6_nxt = IPPROTO_DSTOPTS; 45682cd038dSYoshinobu Inoue } 45782cd038dSYoshinobu Inoue 45882cd038dSYoshinobu Inoue /* 45982cd038dSYoshinobu Inoue * result: IPv6 hbh dest1 rthdr dest2 payload 46082cd038dSYoshinobu Inoue * m will point to IPv6 header. mprev will point to the 46182cd038dSYoshinobu Inoue * extension header prior to dest2 (rthdr in the above case). 46282cd038dSYoshinobu Inoue */ 4637efe5d92SHajimu UMEMOTO MAKE_CHAIN(exthdrs.ip6e_hbh, mprev, nexthdrp, IPPROTO_HOPOPTS); 4647efe5d92SHajimu UMEMOTO MAKE_CHAIN(exthdrs.ip6e_dest1, mprev, nexthdrp, 4657efe5d92SHajimu UMEMOTO IPPROTO_DSTOPTS); 4667efe5d92SHajimu UMEMOTO MAKE_CHAIN(exthdrs.ip6e_rthdr, mprev, nexthdrp, 4677efe5d92SHajimu UMEMOTO IPPROTO_ROUTING); 46882cd038dSYoshinobu Inoue 46982cd038dSYoshinobu Inoue /* 47071ce264cSWarner Losh * If there is a routing header, discard the packet. 47182cd038dSYoshinobu Inoue */ 47282cd038dSYoshinobu Inoue if (exthdrs.ip6e_rthdr) { 47382cd038dSYoshinobu Inoue error = EINVAL; 47482cd038dSYoshinobu Inoue goto bad; 47582cd038dSYoshinobu Inoue } 47682cd038dSYoshinobu Inoue 47782cd038dSYoshinobu Inoue /* Source address validation */ 47882cd038dSYoshinobu Inoue if (IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src) && 4794ecbe331SSUZUKI Shinsuke (flags & IPV6_UNSPECSRC) == 0) { 48082cd038dSYoshinobu Inoue error = EOPNOTSUPP; 4819cb8d207SAndrey V. Elsukov IP6STAT_INC(ip6s_badscope); 48282cd038dSYoshinobu Inoue goto bad; 48382cd038dSYoshinobu Inoue } 48482cd038dSYoshinobu Inoue if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_src)) { 48582cd038dSYoshinobu Inoue error = EOPNOTSUPP; 4869cb8d207SAndrey V. Elsukov IP6STAT_INC(ip6s_badscope); 48782cd038dSYoshinobu Inoue goto bad; 48882cd038dSYoshinobu Inoue } 48982cd038dSYoshinobu Inoue 4909cb8d207SAndrey V. Elsukov IP6STAT_INC(ip6s_localout); 49182cd038dSYoshinobu Inoue 49282cd038dSYoshinobu Inoue /* 49382cd038dSYoshinobu Inoue * Route packet. 49482cd038dSYoshinobu Inoue */ 495155d72c4SPedro F. Giffuni if (ro == NULL) { 49682cd038dSYoshinobu Inoue ro = &ip6route; 49782cd038dSYoshinobu Inoue bzero((caddr_t)ro, sizeof(*ro)); 4988c1960d5SMike Karels } 49982cd038dSYoshinobu Inoue ro_pmtu = ro; 50082cd038dSYoshinobu Inoue if (opt && opt->ip6po_rthdr) 50182cd038dSYoshinobu Inoue ro = &opt->ip6po_route; 50282cd038dSYoshinobu Inoue dst = (struct sockaddr_in6 *)&ro->ro_dst; 5039c57a5b6SHiroki Sato fibnum = (inp != NULL) ? inp->inp_inc.inc_fibnum : M_GETFIB(m); 5048195404bSBrooks Davis again: 50582cd038dSYoshinobu Inoue /* 506f95d4633SHajimu UMEMOTO * if specified, try to fill in the traffic class field. 507f95d4633SHajimu UMEMOTO * do not override if a non-zero value is already set. 508f95d4633SHajimu UMEMOTO * we check the diffserv field and the ecn field separately. 509f95d4633SHajimu UMEMOTO */ 510f95d4633SHajimu UMEMOTO if (opt && opt->ip6po_tclass >= 0) { 511f95d4633SHajimu UMEMOTO int mask = 0; 512f95d4633SHajimu UMEMOTO 513f95d4633SHajimu UMEMOTO if ((ip6->ip6_flow & htonl(0xfc << 20)) == 0) 514f95d4633SHajimu UMEMOTO mask |= 0xfc; 515f95d4633SHajimu UMEMOTO if ((ip6->ip6_flow & htonl(0x03 << 20)) == 0) 516f95d4633SHajimu UMEMOTO mask |= 0x03; 517f95d4633SHajimu UMEMOTO if (mask != 0) 518f95d4633SHajimu UMEMOTO ip6->ip6_flow |= htonl((opt->ip6po_tclass & mask) << 20); 519f95d4633SHajimu UMEMOTO } 520f95d4633SHajimu UMEMOTO 521f95d4633SHajimu UMEMOTO /* fill in or override the hop limit field, if necessary. */ 522f95d4633SHajimu UMEMOTO if (opt && opt->ip6po_hlim != -1) 523f95d4633SHajimu UMEMOTO ip6->ip6_hlim = opt->ip6po_hlim & 0xff; 524f95d4633SHajimu UMEMOTO else if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) { 525f95d4633SHajimu UMEMOTO if (im6o != NULL) 526f95d4633SHajimu UMEMOTO ip6->ip6_hlim = im6o->im6o_multicast_hlim; 527f95d4633SHajimu UMEMOTO else 528603724d3SBjoern A. Zeeb ip6->ip6_hlim = V_ip6_defmcasthlim; 529f95d4633SHajimu UMEMOTO } 53084cc0778SGeorge V. Neville-Neil /* 53184cc0778SGeorge V. Neville-Neil * Validate route against routing table additions; 53284cc0778SGeorge V. Neville-Neil * a better/more specific route might have been added. 53384cc0778SGeorge V. Neville-Neil * Make sure address family is set in route. 53484cc0778SGeorge V. Neville-Neil */ 53584cc0778SGeorge V. Neville-Neil if (inp) { 53684cc0778SGeorge V. Neville-Neil ro->ro_dst.sin6_family = AF_INET6; 53784cc0778SGeorge V. Neville-Neil RT_VALIDATE((struct route *)ro, &inp->inp_rt_cookie, fibnum); 53884cc0778SGeorge V. Neville-Neil } 53984cc0778SGeorge V. Neville-Neil if (ro->ro_rt && fwd_tag == NULL && (ro->ro_rt->rt_flags & RTF_UP) && 54084cc0778SGeorge V. Neville-Neil ro->ro_dst.sin6_family == AF_INET6 && 54184cc0778SGeorge V. Neville-Neil IN6_ARE_ADDR_EQUAL(&ro->ro_dst.sin6_addr, &ip6->ip6_dst)) { 54216607317SAndrey V. Elsukov rt = ro->ro_rt; 54316607317SAndrey V. Elsukov ifp = ro->ro_rt->rt_ifp; 54416607317SAndrey V. Elsukov } else { 5450f5687f2SMike Karels if (ro->ro_lle) 5460f5687f2SMike Karels LLE_FREE(ro->ro_lle); /* zeros ro_lle */ 5470f5687f2SMike Karels ro->ro_lle = NULL; 548f8fe3dc9SAndrey V. Elsukov if (fwd_tag == NULL) { 549a1f7e5f8SHajimu UMEMOTO bzero(&dst_sa, sizeof(dst_sa)); 550a1f7e5f8SHajimu UMEMOTO dst_sa.sin6_family = AF_INET6; 551a1f7e5f8SHajimu UMEMOTO dst_sa.sin6_len = sizeof(dst_sa); 552a1f7e5f8SHajimu UMEMOTO dst_sa.sin6_addr = ip6->ip6_dst; 553f8fe3dc9SAndrey V. Elsukov } 55416607317SAndrey V. Elsukov error = in6_selectroute_fib(&dst_sa, opt, im6o, ro, &ifp, 5559c57a5b6SHiroki Sato &rt, fibnum); 55616607317SAndrey V. Elsukov if (error != 0) { 557a1f7e5f8SHajimu UMEMOTO if (ifp != NULL) 55882cd038dSYoshinobu Inoue in6_ifstat_inc(ifp, ifs6_out_discard); 55982cd038dSYoshinobu Inoue goto bad; 56082cd038dSYoshinobu Inoue } 56116607317SAndrey V. Elsukov } 562a1f7e5f8SHajimu UMEMOTO if (rt == NULL) { 563a1f7e5f8SHajimu UMEMOTO /* 564a1f7e5f8SHajimu UMEMOTO * If in6_selectroute() does not return a route entry, 565a1f7e5f8SHajimu UMEMOTO * dst may not have been updated. 566a1f7e5f8SHajimu UMEMOTO */ 567a1f7e5f8SHajimu UMEMOTO *dst = dst_sa; /* XXX */ 56882cd038dSYoshinobu Inoue } 56982cd038dSYoshinobu Inoue 570a1f7e5f8SHajimu UMEMOTO /* 571a1f7e5f8SHajimu UMEMOTO * then rt (for unicast) and ifp must be non-NULL valid values. 572a1f7e5f8SHajimu UMEMOTO */ 573a1f7e5f8SHajimu UMEMOTO if ((flags & IPV6_FORWARDING) == 0) { 574a1f7e5f8SHajimu UMEMOTO /* XXX: the FORWARDING flag can be set for mrouting. */ 575a1f7e5f8SHajimu UMEMOTO in6_ifstat_inc(ifp, ifs6_out_request); 576a1f7e5f8SHajimu UMEMOTO } 577a1f7e5f8SHajimu UMEMOTO if (rt != NULL) { 578a1f7e5f8SHajimu UMEMOTO ia = (struct in6_ifaddr *)(rt->rt_ifa); 579e3a7aa6fSGleb Smirnoff counter_u64_add(rt->rt_pksent, 1); 580a1f7e5f8SHajimu UMEMOTO } 581a1f7e5f8SHajimu UMEMOTO 5829452b0d2SQing Li 583a1f7e5f8SHajimu UMEMOTO /* 584a1f7e5f8SHajimu UMEMOTO * The outgoing interface must be in the zone of source and 5859452b0d2SQing Li * destination addresses. 586a1f7e5f8SHajimu UMEMOTO */ 587a1f7e5f8SHajimu UMEMOTO origifp = ifp; 588a1f7e5f8SHajimu UMEMOTO 589a1f7e5f8SHajimu UMEMOTO src0 = ip6->ip6_src; 590a1f7e5f8SHajimu UMEMOTO if (in6_setscope(&src0, origifp, &zone)) 591a1f7e5f8SHajimu UMEMOTO goto badscope; 592a1f7e5f8SHajimu UMEMOTO bzero(&src_sa, sizeof(src_sa)); 593a1f7e5f8SHajimu UMEMOTO src_sa.sin6_family = AF_INET6; 594a1f7e5f8SHajimu UMEMOTO src_sa.sin6_len = sizeof(src_sa); 595a1f7e5f8SHajimu UMEMOTO src_sa.sin6_addr = ip6->ip6_src; 596a1f7e5f8SHajimu UMEMOTO if (sa6_recoverscope(&src_sa) || zone != src_sa.sin6_scope_id) 597a1f7e5f8SHajimu UMEMOTO goto badscope; 598a1f7e5f8SHajimu UMEMOTO 599a1f7e5f8SHajimu UMEMOTO dst0 = ip6->ip6_dst; 600a1f7e5f8SHajimu UMEMOTO if (in6_setscope(&dst0, origifp, &zone)) 601a1f7e5f8SHajimu UMEMOTO goto badscope; 602a1f7e5f8SHajimu UMEMOTO /* re-initialize to be sure */ 603a1f7e5f8SHajimu UMEMOTO bzero(&dst_sa, sizeof(dst_sa)); 604a1f7e5f8SHajimu UMEMOTO dst_sa.sin6_family = AF_INET6; 605a1f7e5f8SHajimu UMEMOTO dst_sa.sin6_len = sizeof(dst_sa); 606a1f7e5f8SHajimu UMEMOTO dst_sa.sin6_addr = ip6->ip6_dst; 607a1f7e5f8SHajimu UMEMOTO if (sa6_recoverscope(&dst_sa) || zone != dst_sa.sin6_scope_id) { 608a1f7e5f8SHajimu UMEMOTO goto badscope; 609a1f7e5f8SHajimu UMEMOTO } 610a1f7e5f8SHajimu UMEMOTO 6119452b0d2SQing Li /* We should use ia_ifp to support the case of 6129452b0d2SQing Li * sending packets to an address of our own. 6139452b0d2SQing Li */ 6149452b0d2SQing Li if (ia != NULL && ia->ia_ifp) 6159452b0d2SQing Li ifp = ia->ia_ifp; 6169452b0d2SQing Li 617a1f7e5f8SHajimu UMEMOTO /* scope check is done. */ 618a1f7e5f8SHajimu UMEMOTO goto routefound; 619a1f7e5f8SHajimu UMEMOTO 620a1f7e5f8SHajimu UMEMOTO badscope: 6219cb8d207SAndrey V. Elsukov IP6STAT_INC(ip6s_badscope); 622a1f7e5f8SHajimu UMEMOTO in6_ifstat_inc(origifp, ifs6_out_discard); 623a1f7e5f8SHajimu UMEMOTO if (error == 0) 624a1f7e5f8SHajimu UMEMOTO error = EHOSTUNREACH; /* XXX */ 625a1f7e5f8SHajimu UMEMOTO goto bad; 626a1f7e5f8SHajimu UMEMOTO 627a1f7e5f8SHajimu UMEMOTO routefound: 628a1f7e5f8SHajimu UMEMOTO if (rt && !IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) { 629a1f7e5f8SHajimu UMEMOTO if (opt && opt->ip6po_nextroute.ro_rt) { 630a1f7e5f8SHajimu UMEMOTO /* 631a1f7e5f8SHajimu UMEMOTO * The nexthop is explicitly specified by the 632a1f7e5f8SHajimu UMEMOTO * application. We assume the next hop is an IPv6 633a1f7e5f8SHajimu UMEMOTO * address. 634a1f7e5f8SHajimu UMEMOTO */ 635a1f7e5f8SHajimu UMEMOTO dst = (struct sockaddr_in6 *)opt->ip6po_nexthop; 636a1f7e5f8SHajimu UMEMOTO } 637a1f7e5f8SHajimu UMEMOTO else if ((rt->rt_flags & RTF_GATEWAY)) 638a1f7e5f8SHajimu UMEMOTO dst = (struct sockaddr_in6 *)rt->rt_gateway; 639a1f7e5f8SHajimu UMEMOTO } 640a1f7e5f8SHajimu UMEMOTO 641a1f7e5f8SHajimu UMEMOTO if (!IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) { 642a1f7e5f8SHajimu UMEMOTO m->m_flags &= ~(M_BCAST | M_MCAST); /* just in case */ 64382cd038dSYoshinobu Inoue } else { 64482cd038dSYoshinobu Inoue m->m_flags = (m->m_flags & ~M_BCAST) | M_MCAST; 64582cd038dSYoshinobu Inoue in6_ifstat_inc(ifp, ifs6_out_mcast); 64682cd038dSYoshinobu Inoue /* 64782cd038dSYoshinobu Inoue * Confirm that the outgoing interface supports multicast. 64882cd038dSYoshinobu Inoue */ 649a1f7e5f8SHajimu UMEMOTO if (!(ifp->if_flags & IFF_MULTICAST)) { 6509cb8d207SAndrey V. Elsukov IP6STAT_INC(ip6s_noroute); 65182cd038dSYoshinobu Inoue in6_ifstat_inc(ifp, ifs6_out_discard); 65282cd038dSYoshinobu Inoue error = ENETUNREACH; 65382cd038dSYoshinobu Inoue goto bad; 65482cd038dSYoshinobu Inoue } 65533cde130SBruce M Simpson if ((im6o == NULL && in6_mcast_loop) || 65633cde130SBruce M Simpson (im6o && im6o->im6o_multicast_loop)) { 65782cd038dSYoshinobu Inoue /* 65833cde130SBruce M Simpson * Loop back multicast datagram if not expressly 65933cde130SBruce M Simpson * forbidden to do so, even if we have not joined 66033cde130SBruce M Simpson * the address; protocols will filter it later, 66133cde130SBruce M Simpson * thus deferring a hash lookup and lock acquisition 66233cde130SBruce M Simpson * at the expense of an m_copym(). 66382cd038dSYoshinobu Inoue */ 664331dff07SAlexander V. Chernikov ip6_mloopback(ifp, m); 66591ec0a1eSYoshinobu Inoue } else { 66691ec0a1eSYoshinobu Inoue /* 66791ec0a1eSYoshinobu Inoue * If we are acting as a multicast router, perform 66891ec0a1eSYoshinobu Inoue * multicast forwarding as if the packet had just 66991ec0a1eSYoshinobu Inoue * arrived on the interface to which we are about 67091ec0a1eSYoshinobu Inoue * to send. The multicast forwarding function 67191ec0a1eSYoshinobu Inoue * recursively calls this function, using the 67291ec0a1eSYoshinobu Inoue * IPV6_FORWARDING flag to prevent infinite recursion. 67391ec0a1eSYoshinobu Inoue * 67491ec0a1eSYoshinobu Inoue * Multicasts that are looped back by ip6_mloopback(), 67591ec0a1eSYoshinobu Inoue * above, will be forwarded by the ip6_input() routine, 67691ec0a1eSYoshinobu Inoue * if necessary. 67791ec0a1eSYoshinobu Inoue */ 67833cde130SBruce M Simpson if (V_ip6_mrouter && (flags & IPV6_FORWARDING) == 0) { 679a1f7e5f8SHajimu UMEMOTO /* 680a1f7e5f8SHajimu UMEMOTO * XXX: ip6_mforward expects that rcvif is NULL 681a1f7e5f8SHajimu UMEMOTO * when it is called from the originating path. 6827b07d1beSGleb Smirnoff * However, it may not always be the case. 683a1f7e5f8SHajimu UMEMOTO */ 684a1f7e5f8SHajimu UMEMOTO m->m_pkthdr.rcvif = NULL; 685686cdd19SJun-ichiro itojun Hagino if (ip6_mforward(ip6, ifp, m) != 0) { 68691ec0a1eSYoshinobu Inoue m_freem(m); 68791ec0a1eSYoshinobu Inoue goto done; 68891ec0a1eSYoshinobu Inoue } 68991ec0a1eSYoshinobu Inoue } 69082cd038dSYoshinobu Inoue } 69182cd038dSYoshinobu Inoue /* 69282cd038dSYoshinobu Inoue * Multicasts with a hoplimit of zero may be looped back, 69382cd038dSYoshinobu Inoue * above, but must not be transmitted on a network. 69482cd038dSYoshinobu Inoue * Also, multicasts addressed to the loopback interface 69582cd038dSYoshinobu Inoue * are not sent -- the above call to ip6_mloopback() will 69682cd038dSYoshinobu Inoue * loop back a copy if this host actually belongs to the 69782cd038dSYoshinobu Inoue * destination group on the loopback interface. 69882cd038dSYoshinobu Inoue */ 699f95d4633SHajimu UMEMOTO if (ip6->ip6_hlim == 0 || (ifp->if_flags & IFF_LOOPBACK) || 700f95d4633SHajimu UMEMOTO IN6_IS_ADDR_MC_INTFACELOCAL(&ip6->ip6_dst)) { 70182cd038dSYoshinobu Inoue m_freem(m); 70282cd038dSYoshinobu Inoue goto done; 70382cd038dSYoshinobu Inoue } 70482cd038dSYoshinobu Inoue } 70582cd038dSYoshinobu Inoue 70682cd038dSYoshinobu Inoue /* 70782cd038dSYoshinobu Inoue * Fill the outgoing inteface to tell the upper layer 70882cd038dSYoshinobu Inoue * to increment per-interface statistics. 70982cd038dSYoshinobu Inoue */ 71082cd038dSYoshinobu Inoue if (ifpp) 71182cd038dSYoshinobu Inoue *ifpp = ifp; 71282cd038dSYoshinobu Inoue 71331b3783cSHajimu UMEMOTO /* Determine path MTU. */ 714f0937b2cSAndrey V. Elsukov if ((error = ip6_getpmtu(ro_pmtu, ro != ro_pmtu, ifp, &ip6->ip6_dst, 715d4c22202SAndrew Gallatin &mtu, &alwaysfrag, fibnum, *nexthdrp)) != 0) 71631b3783cSHajimu UMEMOTO goto bad; 71782cd038dSYoshinobu Inoue 71833841545SHajimu UMEMOTO /* 7198b00e59dSHajimu UMEMOTO * The caller of this function may specify to use the minimum MTU 7208b00e59dSHajimu UMEMOTO * in some cases. 7218b00e59dSHajimu UMEMOTO * An advanced API option (IPV6_USE_MIN_MTU) can also override MTU 7228b00e59dSHajimu UMEMOTO * setting. The logic is a bit complicated; by default, unicast 7238b00e59dSHajimu UMEMOTO * packets will follow path MTU while multicast packets will be sent at 7248b00e59dSHajimu UMEMOTO * the minimum MTU. If IP6PO_MINMTU_ALL is specified, all packets 7258b00e59dSHajimu UMEMOTO * including unicast ones will be sent at the minimum MTU. Multicast 7268b00e59dSHajimu UMEMOTO * packets will always be sent at the minimum MTU unless 7278b00e59dSHajimu UMEMOTO * IP6PO_MINMTU_DISABLE is explicitly specified. 7288b00e59dSHajimu UMEMOTO * See RFC 3542 for more details. 72933841545SHajimu UMEMOTO */ 7308b00e59dSHajimu UMEMOTO if (mtu > IPV6_MMTU) { 7318b00e59dSHajimu UMEMOTO if ((flags & IPV6_MINMTU)) 73233841545SHajimu UMEMOTO mtu = IPV6_MMTU; 7338b00e59dSHajimu UMEMOTO else if (opt && opt->ip6po_minmtu == IP6PO_MINMTU_ALL) 7348b00e59dSHajimu UMEMOTO mtu = IPV6_MMTU; 7358b00e59dSHajimu UMEMOTO else if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) && 7368b00e59dSHajimu UMEMOTO (opt == NULL || 7378b00e59dSHajimu UMEMOTO opt->ip6po_minmtu != IP6PO_MINMTU_DISABLE)) { 7388b00e59dSHajimu UMEMOTO mtu = IPV6_MMTU; 7398b00e59dSHajimu UMEMOTO } 7408b00e59dSHajimu UMEMOTO } 74133841545SHajimu UMEMOTO 74233841545SHajimu UMEMOTO /* 74333841545SHajimu UMEMOTO * clear embedded scope identifiers if necessary. 74433841545SHajimu UMEMOTO * in6_clearscope will touch the addresses only when necessary. 74533841545SHajimu UMEMOTO */ 74633841545SHajimu UMEMOTO in6_clearscope(&ip6->ip6_src); 74733841545SHajimu UMEMOTO in6_clearscope(&ip6->ip6_dst); 74882cd038dSYoshinobu Inoue 74982cd038dSYoshinobu Inoue /* 75082cd038dSYoshinobu Inoue * If the outgoing packet contains a hop-by-hop options header, 75182cd038dSYoshinobu Inoue * it must be examined and processed even by the source node. 75282cd038dSYoshinobu Inoue * (RFC 2460, section 4.) 75382cd038dSYoshinobu Inoue */ 75482cd038dSYoshinobu Inoue if (exthdrs.ip6e_hbh) { 75533841545SHajimu UMEMOTO struct ip6_hbh *hbh = mtod(exthdrs.ip6e_hbh, struct ip6_hbh *); 756283f9f8aSHajimu UMEMOTO u_int32_t dummy; /* XXX unused */ 757283f9f8aSHajimu UMEMOTO u_int32_t plen = 0; /* XXX: ip6_process will check the value */ 75882cd038dSYoshinobu Inoue 75933841545SHajimu UMEMOTO #ifdef DIAGNOSTIC 76033841545SHajimu UMEMOTO if ((hbh->ip6h_len + 1) << 3 > exthdrs.ip6e_hbh->m_len) 7616d79f3f6SRebecca Cran panic("ip6e_hbh is not contiguous"); 76233841545SHajimu UMEMOTO #endif 76382cd038dSYoshinobu Inoue /* 76482cd038dSYoshinobu Inoue * XXX: if we have to send an ICMPv6 error to the sender, 76582cd038dSYoshinobu Inoue * we need the M_LOOP flag since icmp6_error() expects 76682cd038dSYoshinobu Inoue * the IPv6 and the hop-by-hop options header are 7676d79f3f6SRebecca Cran * contiguous unless the flag is set. 76882cd038dSYoshinobu Inoue */ 76982cd038dSYoshinobu Inoue m->m_flags |= M_LOOP; 77082cd038dSYoshinobu Inoue m->m_pkthdr.rcvif = ifp; 7717efe5d92SHajimu UMEMOTO if (ip6_process_hopopts(m, (u_int8_t *)(hbh + 1), 7727efe5d92SHajimu UMEMOTO ((hbh->ip6h_len + 1) << 3) - sizeof(struct ip6_hbh), 773283f9f8aSHajimu UMEMOTO &dummy, &plen) < 0) { 77482cd038dSYoshinobu Inoue /* m was already freed at this point */ 77582cd038dSYoshinobu Inoue error = EINVAL;/* better error? */ 77682cd038dSYoshinobu Inoue goto done; 77782cd038dSYoshinobu Inoue } 77882cd038dSYoshinobu Inoue m->m_flags &= ~M_LOOP; /* XXX */ 77982cd038dSYoshinobu Inoue m->m_pkthdr.rcvif = NULL; 78082cd038dSYoshinobu Inoue } 78182cd038dSYoshinobu Inoue 782c21fd232SAndre Oppermann /* Jump over all PFIL processing if hooks are not active. */ 7830b4b0b0fSJulian Elischer if (!PFIL_HOOKED(&V_inet6_pfil_hook)) 784c21fd232SAndre Oppermann goto passout; 785c21fd232SAndre Oppermann 7868195404bSBrooks Davis odst = ip6->ip6_dst; 787c21fd232SAndre Oppermann /* Run through list of hooks for output packets. */ 788effaab88SKristof Provost error = pfil_run_hooks(&V_inet6_pfil_hook, &m, ifp, PFIL_OUT, 0, inp); 789b140bc1fSSam Leffler if (error != 0 || m == NULL) 790c4ac87eaSDarren Reed goto done; 7911d4d43c0SAndrey V. Elsukov /* adjust pointer */ 792c4ac87eaSDarren Reed ip6 = mtod(m, struct ip6_hdr *); 7937efe5d92SHajimu UMEMOTO 7949c57a5b6SHiroki Sato needfiblookup = 0; 7958195404bSBrooks Davis /* See if destination IP address was changed by packet filter. */ 7968195404bSBrooks Davis if (!IN6_ARE_ADDR_EQUAL(&odst, &ip6->ip6_dst)) { 7978195404bSBrooks Davis m->m_flags |= M_SKIP_FIREWALL; 7988195404bSBrooks Davis /* If destination is now ourself drop to ip6_input(). */ 7998a006adbSBjoern A. Zeeb if (in6_localip(&ip6->ip6_dst)) { 8008a006adbSBjoern A. Zeeb m->m_flags |= M_FASTFWD_OURS; 8018195404bSBrooks Davis if (m->m_pkthdr.rcvif == NULL) 802603724d3SBjoern A. Zeeb m->m_pkthdr.rcvif = V_loif; 803356ab07eSBjoern A. Zeeb if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA_IPV6) { 8048195404bSBrooks Davis m->m_pkthdr.csum_flags |= 805356ab07eSBjoern A. Zeeb CSUM_DATA_VALID_IPV6 | CSUM_PSEUDO_HDR; 8068195404bSBrooks Davis m->m_pkthdr.csum_data = 0xffff; 8078195404bSBrooks Davis } 8089b03990aSRandall Stewart #ifdef SCTP 809a6cff10fSMichael Tuexen if (m->m_pkthdr.csum_flags & CSUM_SCTP_IPV6) 8109b03990aSRandall Stewart m->m_pkthdr.csum_flags |= CSUM_SCTP_VALID; 8119b03990aSRandall Stewart #endif 8128195404bSBrooks Davis error = netisr_queue(NETISR_IPV6, m); 8138195404bSBrooks Davis goto done; 8144ee7e5a6SAndrey V. Elsukov } else { 8154ee7e5a6SAndrey V. Elsukov RO_RTFREE(ro); 8169c57a5b6SHiroki Sato needfiblookup = 1; /* Redo the routing table lookup. */ 8170f5687f2SMike Karels if (ro->ro_lle) 8180f5687f2SMike Karels LLE_FREE(ro->ro_lle); /* zeros ro_lle */ 8190f5687f2SMike Karels ro->ro_lle = NULL; 8208195404bSBrooks Davis } 8214ee7e5a6SAndrey V. Elsukov } 8229c57a5b6SHiroki Sato /* See if fib was changed by packet filter. */ 8239c57a5b6SHiroki Sato if (fibnum != M_GETFIB(m)) { 8249c57a5b6SHiroki Sato m->m_flags |= M_SKIP_FIREWALL; 8259c57a5b6SHiroki Sato fibnum = M_GETFIB(m); 8269c57a5b6SHiroki Sato RO_RTFREE(ro); 8279c57a5b6SHiroki Sato needfiblookup = 1; 8280f5687f2SMike Karels if (ro->ro_lle) 8290f5687f2SMike Karels LLE_FREE(ro->ro_lle); /* zeros ro_lle */ 8300f5687f2SMike Karels ro->ro_lle = NULL; 8319c57a5b6SHiroki Sato } 8329c57a5b6SHiroki Sato if (needfiblookup) 8339c57a5b6SHiroki Sato goto again; 8348195404bSBrooks Davis 8358a006adbSBjoern A. Zeeb /* See if local, if yes, send it to netisr. */ 8368a006adbSBjoern A. Zeeb if (m->m_flags & M_FASTFWD_OURS) { 8378a006adbSBjoern A. Zeeb if (m->m_pkthdr.rcvif == NULL) 8388a006adbSBjoern A. Zeeb m->m_pkthdr.rcvif = V_loif; 839356ab07eSBjoern A. Zeeb if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA_IPV6) { 8408a006adbSBjoern A. Zeeb m->m_pkthdr.csum_flags |= 841356ab07eSBjoern A. Zeeb CSUM_DATA_VALID_IPV6 | CSUM_PSEUDO_HDR; 8428a006adbSBjoern A. Zeeb m->m_pkthdr.csum_data = 0xffff; 8438a006adbSBjoern A. Zeeb } 8448a006adbSBjoern A. Zeeb #ifdef SCTP 845a6cff10fSMichael Tuexen if (m->m_pkthdr.csum_flags & CSUM_SCTP_IPV6) 8468a006adbSBjoern A. Zeeb m->m_pkthdr.csum_flags |= CSUM_SCTP_VALID; 8478a006adbSBjoern A. Zeeb #endif 8488a006adbSBjoern A. Zeeb error = netisr_queue(NETISR_IPV6, m); 8498a006adbSBjoern A. Zeeb goto done; 8508a006adbSBjoern A. Zeeb } 8518a006adbSBjoern A. Zeeb /* Or forward to some other address? */ 852ffdbf9daSAndrey V. Elsukov if ((m->m_flags & M_IP6_NEXTHOP) && 853ffdbf9daSAndrey V. Elsukov (fwd_tag = m_tag_find(m, PACKET_TAG_IPFORWARD, NULL)) != NULL) { 8548a006adbSBjoern A. Zeeb dst = (struct sockaddr_in6 *)&ro->ro_dst; 855f8fe3dc9SAndrey V. Elsukov bcopy((fwd_tag+1), &dst_sa, sizeof(struct sockaddr_in6)); 8568a006adbSBjoern A. Zeeb m->m_flags |= M_SKIP_FIREWALL; 857ffdbf9daSAndrey V. Elsukov m->m_flags &= ~M_IP6_NEXTHOP; 8588a006adbSBjoern A. Zeeb m_tag_delete(m, fwd_tag); 8598a006adbSBjoern A. Zeeb goto again; 8608a006adbSBjoern A. Zeeb } 8618195404bSBrooks Davis 862c21fd232SAndre Oppermann passout: 86382cd038dSYoshinobu Inoue /* 86482cd038dSYoshinobu Inoue * Send the packet to the outgoing interface. 86582cd038dSYoshinobu Inoue * If necessary, do IPv6 fragmentation before sending. 866f95d4633SHajimu UMEMOTO * 867f95d4633SHajimu UMEMOTO * the logic here is rather complex: 868f95d4633SHajimu UMEMOTO * 1: normal case (dontfrag == 0, alwaysfrag == 0) 869f95d4633SHajimu UMEMOTO * 1-a: send as is if tlen <= path mtu 870f95d4633SHajimu UMEMOTO * 1-b: fragment if tlen > path mtu 871f95d4633SHajimu UMEMOTO * 872f95d4633SHajimu UMEMOTO * 2: if user asks us not to fragment (dontfrag == 1) 873f95d4633SHajimu UMEMOTO * 2-a: send as is if tlen <= interface mtu 874f95d4633SHajimu UMEMOTO * 2-b: error if tlen > interface mtu 875f95d4633SHajimu UMEMOTO * 876f95d4633SHajimu UMEMOTO * 3: if we always need to attach fragment header (alwaysfrag == 1) 877f95d4633SHajimu UMEMOTO * always fragment 878f95d4633SHajimu UMEMOTO * 879f95d4633SHajimu UMEMOTO * 4: if dontfrag == 1 && alwaysfrag == 1 880f95d4633SHajimu UMEMOTO * error, as we cannot handle this conflicting request 88182cd038dSYoshinobu Inoue */ 882e7b92e27SBjoern A. Zeeb sw_csum = m->m_pkthdr.csum_flags; 883e7b92e27SBjoern A. Zeeb if (!hdrsplit) { 884e7b92e27SBjoern A. Zeeb tso = ((sw_csum & ifp->if_hwassist & CSUM_TSO) != 0) ? 1 : 0; 885e7b92e27SBjoern A. Zeeb sw_csum &= ~ifp->if_hwassist; 886e7b92e27SBjoern A. Zeeb } else 887e7b92e27SBjoern A. Zeeb tso = 0; 888e7b92e27SBjoern A. Zeeb /* 889e7b92e27SBjoern A. Zeeb * If we added extension headers, we will not do TSO and calculate the 890e7b92e27SBjoern A. Zeeb * checksums ourselves for now. 891e7b92e27SBjoern A. Zeeb * XXX-BZ Need a framework to know when the NIC can handle it, even 892e7b92e27SBjoern A. Zeeb * with ext. hdrs. 893e7b92e27SBjoern A. Zeeb */ 894356ab07eSBjoern A. Zeeb if (sw_csum & CSUM_DELAY_DATA_IPV6) { 895356ab07eSBjoern A. Zeeb sw_csum &= ~CSUM_DELAY_DATA_IPV6; 896c69baa7eSBjoern A. Zeeb in6_delayed_cksum(m, plen, sizeof(struct ip6_hdr)); 897e7b92e27SBjoern A. Zeeb } 8989b03990aSRandall Stewart #ifdef SCTP 899a6cff10fSMichael Tuexen if (sw_csum & CSUM_SCTP_IPV6) { 900a6cff10fSMichael Tuexen sw_csum &= ~CSUM_SCTP_IPV6; 901e7b92e27SBjoern A. Zeeb sctp_delayed_cksum(m, sizeof(struct ip6_hdr)); 9029b03990aSRandall Stewart } 9039b03990aSRandall Stewart #endif 904e7b92e27SBjoern A. Zeeb m->m_pkthdr.csum_flags &= ifp->if_hwassist; 90582cd038dSYoshinobu Inoue tlen = m->m_pkthdr.len; 90682cd038dSYoshinobu Inoue 907e7b92e27SBjoern A. Zeeb if ((opt && (opt->ip6po_flags & IP6PO_DONTFRAG)) || tso) 908f95d4633SHajimu UMEMOTO dontfrag = 1; 909f95d4633SHajimu UMEMOTO else 910f95d4633SHajimu UMEMOTO dontfrag = 0; 911f95d4633SHajimu UMEMOTO if (dontfrag && alwaysfrag) { /* case 4 */ 912f95d4633SHajimu UMEMOTO /* conflicting request - can't transmit */ 913f95d4633SHajimu UMEMOTO error = EMSGSIZE; 914f95d4633SHajimu UMEMOTO goto bad; 915f95d4633SHajimu UMEMOTO } 916e7b92e27SBjoern A. Zeeb if (dontfrag && tlen > IN6_LINKMTU(ifp) && !tso) { /* case 2-b */ 917f95d4633SHajimu UMEMOTO /* 918f95d4633SHajimu UMEMOTO * Even if the DONTFRAG option is specified, we cannot send the 919f95d4633SHajimu UMEMOTO * packet when the data length is larger than the MTU of the 920f95d4633SHajimu UMEMOTO * outgoing interface. 9218f1beb88SAndrey V. Elsukov * Notify the error by sending IPV6_PATHMTU ancillary data if 9228f1beb88SAndrey V. Elsukov * application wanted to know the MTU value. Also return an 9238f1beb88SAndrey V. Elsukov * error code (this is not described in the API spec). 924f95d4633SHajimu UMEMOTO */ 9258f1beb88SAndrey V. Elsukov if (inp != NULL) 9268f1beb88SAndrey V. Elsukov ip6_notify_pmtu(inp, &dst_sa, (u_int32_t)mtu); 927f95d4633SHajimu UMEMOTO error = EMSGSIZE; 928f95d4633SHajimu UMEMOTO goto bad; 929f95d4633SHajimu UMEMOTO } 930f95d4633SHajimu UMEMOTO 931f95d4633SHajimu UMEMOTO /* 932f95d4633SHajimu UMEMOTO * transmit packet without fragmentation 933f95d4633SHajimu UMEMOTO */ 934f95d4633SHajimu UMEMOTO if (dontfrag || (!alwaysfrag && tlen <= mtu)) { /* case 1-a and 2-a */ 935f95d4633SHajimu UMEMOTO struct in6_ifaddr *ia6; 936f95d4633SHajimu UMEMOTO 937f95d4633SHajimu UMEMOTO ip6 = mtod(m, struct ip6_hdr *); 938f95d4633SHajimu UMEMOTO ia6 = in6_ifawithifp(ifp, &ip6->ip6_src); 939f95d4633SHajimu UMEMOTO if (ia6) { 9405da9f8faSJosef Karthauser /* Record statistics for this interface address. */ 9417caf4ab7SGleb Smirnoff counter_u64_add(ia6->ia_ifa.ifa_opackets, 1); 9427caf4ab7SGleb Smirnoff counter_u64_add(ia6->ia_ifa.ifa_obytes, 9437caf4ab7SGleb Smirnoff m->m_pkthdr.len); 9448c0fec80SRobert Watson ifa_free(&ia6->ia_ifa); 9455da9f8faSJosef Karthauser } 946f3e7afe2SHans Petter Selasky #ifdef RATELIMIT 947f3e7afe2SHans Petter Selasky if (inp != NULL) { 948f3e7afe2SHans Petter Selasky if (inp->inp_flags2 & INP_RATE_LIMIT_CHANGED) 949f3e7afe2SHans Petter Selasky in_pcboutput_txrtlmt(inp, ifp, m); 950f3e7afe2SHans Petter Selasky /* stamp send tag on mbuf */ 951f3e7afe2SHans Petter Selasky m->m_pkthdr.snd_tag = inp->inp_snd_tag; 952f3e7afe2SHans Petter Selasky } else { 953f3e7afe2SHans Petter Selasky m->m_pkthdr.snd_tag = NULL; 954f3e7afe2SHans Petter Selasky } 955f3e7afe2SHans Petter Selasky #endif 95684cc0778SGeorge V. Neville-Neil error = nd6_output_ifp(ifp, origifp, m, dst, 95784cc0778SGeorge V. Neville-Neil (struct route *)ro); 958f3e7afe2SHans Petter Selasky #ifdef RATELIMIT 959f3e7afe2SHans Petter Selasky /* check for route change */ 960f3e7afe2SHans Petter Selasky if (error == EAGAIN) 961f3e7afe2SHans Petter Selasky in_pcboutput_eagain(inp); 962f3e7afe2SHans Petter Selasky #endif 96382cd038dSYoshinobu Inoue goto done; 964f95d4633SHajimu UMEMOTO } 965f95d4633SHajimu UMEMOTO 96682cd038dSYoshinobu Inoue /* 967f95d4633SHajimu UMEMOTO * try to fragment the packet. case 1-b and 3 96882cd038dSYoshinobu Inoue */ 969f95d4633SHajimu UMEMOTO if (mtu < IPV6_MMTU) { 970f95d4633SHajimu UMEMOTO /* path MTU cannot be less than IPV6_MMTU */ 97182cd038dSYoshinobu Inoue error = EMSGSIZE; 97282cd038dSYoshinobu Inoue in6_ifstat_inc(ifp, ifs6_out_fragfail); 97382cd038dSYoshinobu Inoue goto bad; 9747efe5d92SHajimu UMEMOTO } else if (ip6->ip6_plen == 0) { 9757efe5d92SHajimu UMEMOTO /* jumbo payload cannot be fragmented */ 97682cd038dSYoshinobu Inoue error = EMSGSIZE; 97782cd038dSYoshinobu Inoue in6_ifstat_inc(ifp, ifs6_out_fragfail); 97882cd038dSYoshinobu Inoue goto bad; 97982cd038dSYoshinobu Inoue } else { 98082cd038dSYoshinobu Inoue u_char nextproto; 9812cb64cb2SGeorge V. Neville-Neil 98282cd038dSYoshinobu Inoue /* 98382cd038dSYoshinobu Inoue * Too large for the destination or interface; 98482cd038dSYoshinobu Inoue * fragment if possible. 98582cd038dSYoshinobu Inoue * Must be able to put at least 8 bytes per fragment. 98682cd038dSYoshinobu Inoue */ 98782cd038dSYoshinobu Inoue hlen = unfragpartlen; 98882cd038dSYoshinobu Inoue if (mtu > IPV6_MAXPACKET) 98982cd038dSYoshinobu Inoue mtu = IPV6_MAXPACKET; 99033841545SHajimu UMEMOTO 99182cd038dSYoshinobu Inoue len = (mtu - hlen - sizeof(struct ip6_frag)) & ~7; 99282cd038dSYoshinobu Inoue if (len < 8) { 99382cd038dSYoshinobu Inoue error = EMSGSIZE; 99482cd038dSYoshinobu Inoue in6_ifstat_inc(ifp, ifs6_out_fragfail); 99582cd038dSYoshinobu Inoue goto bad; 99682cd038dSYoshinobu Inoue } 99782cd038dSYoshinobu Inoue 9986f8aee22SBill Paul /* 999e7b92e27SBjoern A. Zeeb * If the interface will not calculate checksums on 1000e7b92e27SBjoern A. Zeeb * fragmented packets, then do it here. 1001e7b92e27SBjoern A. Zeeb * XXX-BZ handle the hw offloading case. Need flags. 1002e7b92e27SBjoern A. Zeeb */ 1003356ab07eSBjoern A. Zeeb if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA_IPV6) { 1004c69baa7eSBjoern A. Zeeb in6_delayed_cksum(m, plen, hlen); 1005356ab07eSBjoern A. Zeeb m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA_IPV6; 1006e7b92e27SBjoern A. Zeeb } 1007e7b92e27SBjoern A. Zeeb #ifdef SCTP 1008a6cff10fSMichael Tuexen if (m->m_pkthdr.csum_flags & CSUM_SCTP_IPV6) { 1009e7b92e27SBjoern A. Zeeb sctp_delayed_cksum(m, hlen); 1010a6cff10fSMichael Tuexen m->m_pkthdr.csum_flags &= ~CSUM_SCTP_IPV6; 1011e7b92e27SBjoern A. Zeeb } 1012e7b92e27SBjoern A. Zeeb #endif 101382cd038dSYoshinobu Inoue /* 101482cd038dSYoshinobu Inoue * Change the next header field of the last header in the 101582cd038dSYoshinobu Inoue * unfragmentable part. 101682cd038dSYoshinobu Inoue */ 101782cd038dSYoshinobu Inoue if (exthdrs.ip6e_rthdr) { 101882cd038dSYoshinobu Inoue nextproto = *mtod(exthdrs.ip6e_rthdr, u_char *); 101982cd038dSYoshinobu Inoue *mtod(exthdrs.ip6e_rthdr, u_char *) = IPPROTO_FRAGMENT; 102082cd038dSYoshinobu Inoue } else if (exthdrs.ip6e_dest1) { 102182cd038dSYoshinobu Inoue nextproto = *mtod(exthdrs.ip6e_dest1, u_char *); 102282cd038dSYoshinobu Inoue *mtod(exthdrs.ip6e_dest1, u_char *) = IPPROTO_FRAGMENT; 102382cd038dSYoshinobu Inoue } else if (exthdrs.ip6e_hbh) { 102482cd038dSYoshinobu Inoue nextproto = *mtod(exthdrs.ip6e_hbh, u_char *); 102582cd038dSYoshinobu Inoue *mtod(exthdrs.ip6e_hbh, u_char *) = IPPROTO_FRAGMENT; 102682cd038dSYoshinobu Inoue } else { 102782cd038dSYoshinobu Inoue nextproto = ip6->ip6_nxt; 102882cd038dSYoshinobu Inoue ip6->ip6_nxt = IPPROTO_FRAGMENT; 102982cd038dSYoshinobu Inoue } 103082cd038dSYoshinobu Inoue 103182cd038dSYoshinobu Inoue /* 103282cd038dSYoshinobu Inoue * Loop through length of segment after first fragment, 103388ff5695SSUZUKI Shinsuke * make new header and copy data of each part and link onto 103488ff5695SSUZUKI Shinsuke * chain. 103582cd038dSYoshinobu Inoue */ 103682cd038dSYoshinobu Inoue m0 = m; 103779831849SKristof Provost id = htonl(ip6_randomid()); 103879831849SKristof Provost if ((error = ip6_fragment(ifp, m, hlen, nextproto, len, id))) 103982cd038dSYoshinobu Inoue goto sendorfree; 104082cd038dSYoshinobu Inoue 104182cd038dSYoshinobu Inoue in6_ifstat_inc(ifp, ifs6_out_fragok); 104282cd038dSYoshinobu Inoue } 104382cd038dSYoshinobu Inoue 104482cd038dSYoshinobu Inoue /* 104582cd038dSYoshinobu Inoue * Remove leading garbages. 104682cd038dSYoshinobu Inoue */ 104782cd038dSYoshinobu Inoue sendorfree: 104882cd038dSYoshinobu Inoue m = m0->m_nextpkt; 104982cd038dSYoshinobu Inoue m0->m_nextpkt = 0; 105082cd038dSYoshinobu Inoue m_freem(m0); 1051*c187c034SJonathan T. Looney for (; m; m = m0) { 105282cd038dSYoshinobu Inoue m0 = m->m_nextpkt; 105382cd038dSYoshinobu Inoue m->m_nextpkt = 0; 105482cd038dSYoshinobu Inoue if (error == 0) { 1055fe937674SJosef Karthauser /* Record statistics for this interface address. */ 1056fe937674SJosef Karthauser if (ia) { 10577caf4ab7SGleb Smirnoff counter_u64_add(ia->ia_ifa.ifa_opackets, 1); 10587caf4ab7SGleb Smirnoff counter_u64_add(ia->ia_ifa.ifa_obytes, 10597caf4ab7SGleb Smirnoff m->m_pkthdr.len); 1060fe937674SJosef Karthauser } 1061f3e7afe2SHans Petter Selasky #ifdef RATELIMIT 1062f3e7afe2SHans Petter Selasky if (inp != NULL) { 1063f3e7afe2SHans Petter Selasky if (inp->inp_flags2 & INP_RATE_LIMIT_CHANGED) 1064f3e7afe2SHans Petter Selasky in_pcboutput_txrtlmt(inp, ifp, m); 1065f3e7afe2SHans Petter Selasky /* stamp send tag on mbuf */ 1066f3e7afe2SHans Petter Selasky m->m_pkthdr.snd_tag = inp->inp_snd_tag; 1067f3e7afe2SHans Petter Selasky } else { 1068f3e7afe2SHans Petter Selasky m->m_pkthdr.snd_tag = NULL; 1069f3e7afe2SHans Petter Selasky } 1070f3e7afe2SHans Petter Selasky #endif 107184cc0778SGeorge V. Neville-Neil error = nd6_output_ifp(ifp, origifp, m, dst, 107284cc0778SGeorge V. Neville-Neil (struct route *)ro); 1073f3e7afe2SHans Petter Selasky #ifdef RATELIMIT 1074f3e7afe2SHans Petter Selasky /* check for route change */ 1075f3e7afe2SHans Petter Selasky if (error == EAGAIN) 1076f3e7afe2SHans Petter Selasky in_pcboutput_eagain(inp); 1077f3e7afe2SHans Petter Selasky #endif 107882cd038dSYoshinobu Inoue } else 107982cd038dSYoshinobu Inoue m_freem(m); 108082cd038dSYoshinobu Inoue } 108182cd038dSYoshinobu Inoue 108282cd038dSYoshinobu Inoue if (error == 0) 10839cb8d207SAndrey V. Elsukov IP6STAT_INC(ip6s_fragmented); 108482cd038dSYoshinobu Inoue 108582cd038dSYoshinobu Inoue done: 1086cc94f0c2SGleb Smirnoff if (ro == &ip6route) 1087bf984051SGleb Smirnoff RO_RTFREE(ro); 108882cd038dSYoshinobu Inoue return (error); 108982cd038dSYoshinobu Inoue 109082cd038dSYoshinobu Inoue freehdrs: 109182cd038dSYoshinobu Inoue m_freem(exthdrs.ip6e_hbh); /* m_freem will check if mbuf is 0 */ 109282cd038dSYoshinobu Inoue m_freem(exthdrs.ip6e_dest1); 109382cd038dSYoshinobu Inoue m_freem(exthdrs.ip6e_rthdr); 109482cd038dSYoshinobu Inoue m_freem(exthdrs.ip6e_dest2); 10957efe5d92SHajimu UMEMOTO /* FALLTHROUGH */ 109682cd038dSYoshinobu Inoue bad: 10972cb64cb2SGeorge V. Neville-Neil if (m) 109882cd038dSYoshinobu Inoue m_freem(m); 109982cd038dSYoshinobu Inoue goto done; 110082cd038dSYoshinobu Inoue } 110182cd038dSYoshinobu Inoue 110282cd038dSYoshinobu Inoue static int 11031272577eSXin LI ip6_copyexthdr(struct mbuf **mp, caddr_t hdr, int hlen) 110482cd038dSYoshinobu Inoue { 110582cd038dSYoshinobu Inoue struct mbuf *m; 110682cd038dSYoshinobu Inoue 110782cd038dSYoshinobu Inoue if (hlen > MCLBYTES) 110882cd038dSYoshinobu Inoue return (ENOBUFS); /* XXX */ 110982cd038dSYoshinobu Inoue 111010e5acc3SGleb Smirnoff if (hlen > MLEN) 111110e5acc3SGleb Smirnoff m = m_getcl(M_NOWAIT, MT_DATA, 0); 111210e5acc3SGleb Smirnoff else 111310e5acc3SGleb Smirnoff m = m_get(M_NOWAIT, MT_DATA); 111410e5acc3SGleb Smirnoff if (m == NULL) 111582cd038dSYoshinobu Inoue return (ENOBUFS); 111682cd038dSYoshinobu Inoue m->m_len = hlen; 111782cd038dSYoshinobu Inoue if (hdr) 111882cd038dSYoshinobu Inoue bcopy(hdr, mtod(m, caddr_t), hlen); 111982cd038dSYoshinobu Inoue 112082cd038dSYoshinobu Inoue *mp = m; 112182cd038dSYoshinobu Inoue return (0); 112282cd038dSYoshinobu Inoue } 112382cd038dSYoshinobu Inoue 112482cd038dSYoshinobu Inoue /* 112582cd038dSYoshinobu Inoue * Insert jumbo payload option. 112682cd038dSYoshinobu Inoue */ 112782cd038dSYoshinobu Inoue static int 11281272577eSXin LI ip6_insert_jumboopt(struct ip6_exthdrs *exthdrs, u_int32_t plen) 112982cd038dSYoshinobu Inoue { 113082cd038dSYoshinobu Inoue struct mbuf *mopt; 113182cd038dSYoshinobu Inoue u_char *optbuf; 113233841545SHajimu UMEMOTO u_int32_t v; 113382cd038dSYoshinobu Inoue 113482cd038dSYoshinobu Inoue #define JUMBOOPTLEN 8 /* length of jumbo payload option and padding */ 113582cd038dSYoshinobu Inoue 113682cd038dSYoshinobu Inoue /* 113782cd038dSYoshinobu Inoue * If there is no hop-by-hop options header, allocate new one. 113882cd038dSYoshinobu Inoue * If there is one but it doesn't have enough space to store the 113982cd038dSYoshinobu Inoue * jumbo payload option, allocate a cluster to store the whole options. 114082cd038dSYoshinobu Inoue * Otherwise, use it to store the options. 114182cd038dSYoshinobu Inoue */ 1142155d72c4SPedro F. Giffuni if (exthdrs->ip6e_hbh == NULL) { 114310e5acc3SGleb Smirnoff mopt = m_get(M_NOWAIT, MT_DATA); 114410e5acc3SGleb Smirnoff if (mopt == NULL) 114582cd038dSYoshinobu Inoue return (ENOBUFS); 114682cd038dSYoshinobu Inoue mopt->m_len = JUMBOOPTLEN; 114782cd038dSYoshinobu Inoue optbuf = mtod(mopt, u_char *); 114882cd038dSYoshinobu Inoue optbuf[1] = 0; /* = ((JUMBOOPTLEN) >> 3) - 1 */ 114982cd038dSYoshinobu Inoue exthdrs->ip6e_hbh = mopt; 115082cd038dSYoshinobu Inoue } else { 115182cd038dSYoshinobu Inoue struct ip6_hbh *hbh; 115282cd038dSYoshinobu Inoue 115382cd038dSYoshinobu Inoue mopt = exthdrs->ip6e_hbh; 115482cd038dSYoshinobu Inoue if (M_TRAILINGSPACE(mopt) < JUMBOOPTLEN) { 115533841545SHajimu UMEMOTO /* 115633841545SHajimu UMEMOTO * XXX assumption: 115733841545SHajimu UMEMOTO * - exthdrs->ip6e_hbh is not referenced from places 115833841545SHajimu UMEMOTO * other than exthdrs. 115933841545SHajimu UMEMOTO * - exthdrs->ip6e_hbh is not an mbuf chain. 116033841545SHajimu UMEMOTO */ 116182cd038dSYoshinobu Inoue int oldoptlen = mopt->m_len; 116233841545SHajimu UMEMOTO struct mbuf *n; 116382cd038dSYoshinobu Inoue 116433841545SHajimu UMEMOTO /* 116533841545SHajimu UMEMOTO * XXX: give up if the whole (new) hbh header does 116633841545SHajimu UMEMOTO * not fit even in an mbuf cluster. 116733841545SHajimu UMEMOTO */ 116833841545SHajimu UMEMOTO if (oldoptlen + JUMBOOPTLEN > MCLBYTES) 116982cd038dSYoshinobu Inoue return (ENOBUFS); 117082cd038dSYoshinobu Inoue 117133841545SHajimu UMEMOTO /* 117233841545SHajimu UMEMOTO * As a consequence, we must always prepare a cluster 117333841545SHajimu UMEMOTO * at this point. 117433841545SHajimu UMEMOTO */ 117510e5acc3SGleb Smirnoff n = m_getcl(M_NOWAIT, MT_DATA, 0); 117610e5acc3SGleb Smirnoff if (n == NULL) 117733841545SHajimu UMEMOTO return (ENOBUFS); 117833841545SHajimu UMEMOTO n->m_len = oldoptlen + JUMBOOPTLEN; 117933841545SHajimu UMEMOTO bcopy(mtod(mopt, caddr_t), mtod(n, caddr_t), 118033841545SHajimu UMEMOTO oldoptlen); 118133841545SHajimu UMEMOTO optbuf = mtod(n, caddr_t) + oldoptlen; 118233841545SHajimu UMEMOTO m_freem(mopt); 118333841545SHajimu UMEMOTO mopt = exthdrs->ip6e_hbh = n; 118482cd038dSYoshinobu Inoue } else { 118582cd038dSYoshinobu Inoue optbuf = mtod(mopt, u_char *) + mopt->m_len; 118682cd038dSYoshinobu Inoue mopt->m_len += JUMBOOPTLEN; 118782cd038dSYoshinobu Inoue } 118882cd038dSYoshinobu Inoue optbuf[0] = IP6OPT_PADN; 118982cd038dSYoshinobu Inoue optbuf[1] = 1; 119082cd038dSYoshinobu Inoue 119182cd038dSYoshinobu Inoue /* 119282cd038dSYoshinobu Inoue * Adjust the header length according to the pad and 119382cd038dSYoshinobu Inoue * the jumbo payload option. 119482cd038dSYoshinobu Inoue */ 119582cd038dSYoshinobu Inoue hbh = mtod(mopt, struct ip6_hbh *); 119682cd038dSYoshinobu Inoue hbh->ip6h_len += (JUMBOOPTLEN >> 3); 119782cd038dSYoshinobu Inoue } 119882cd038dSYoshinobu Inoue 119982cd038dSYoshinobu Inoue /* fill in the option. */ 120082cd038dSYoshinobu Inoue optbuf[2] = IP6OPT_JUMBO; 120182cd038dSYoshinobu Inoue optbuf[3] = 4; 120233841545SHajimu UMEMOTO v = (u_int32_t)htonl(plen + JUMBOOPTLEN); 120333841545SHajimu UMEMOTO bcopy(&v, &optbuf[4], sizeof(u_int32_t)); 120482cd038dSYoshinobu Inoue 120582cd038dSYoshinobu Inoue /* finally, adjust the packet header length */ 120682cd038dSYoshinobu Inoue exthdrs->ip6e_ip6->m_pkthdr.len += JUMBOOPTLEN; 120782cd038dSYoshinobu Inoue 120882cd038dSYoshinobu Inoue return (0); 120982cd038dSYoshinobu Inoue #undef JUMBOOPTLEN 121082cd038dSYoshinobu Inoue } 121182cd038dSYoshinobu Inoue 121282cd038dSYoshinobu Inoue /* 121382cd038dSYoshinobu Inoue * Insert fragment header and copy unfragmentable header portions. 121482cd038dSYoshinobu Inoue */ 121582cd038dSYoshinobu Inoue static int 12161272577eSXin LI ip6_insertfraghdr(struct mbuf *m0, struct mbuf *m, int hlen, 12171272577eSXin LI struct ip6_frag **frghdrp) 121882cd038dSYoshinobu Inoue { 121982cd038dSYoshinobu Inoue struct mbuf *n, *mlast; 122082cd038dSYoshinobu Inoue 122182cd038dSYoshinobu Inoue if (hlen > sizeof(struct ip6_hdr)) { 122282cd038dSYoshinobu Inoue n = m_copym(m0, sizeof(struct ip6_hdr), 1223eb1b1807SGleb Smirnoff hlen - sizeof(struct ip6_hdr), M_NOWAIT); 1224155d72c4SPedro F. Giffuni if (n == NULL) 122582cd038dSYoshinobu Inoue return (ENOBUFS); 122682cd038dSYoshinobu Inoue m->m_next = n; 122782cd038dSYoshinobu Inoue } else 122882cd038dSYoshinobu Inoue n = m; 122982cd038dSYoshinobu Inoue 123082cd038dSYoshinobu Inoue /* Search for the last mbuf of unfragmentable part. */ 123182cd038dSYoshinobu Inoue for (mlast = n; mlast->m_next; mlast = mlast->m_next) 123282cd038dSYoshinobu Inoue ; 123382cd038dSYoshinobu Inoue 1234f0cace5dSRobert Watson if (M_WRITABLE(mlast) && 1235686cdd19SJun-ichiro itojun Hagino M_TRAILINGSPACE(mlast) >= sizeof(struct ip6_frag)) { 123682cd038dSYoshinobu Inoue /* use the trailing space of the last mbuf for the fragment hdr */ 12377efe5d92SHajimu UMEMOTO *frghdrp = (struct ip6_frag *)(mtod(mlast, caddr_t) + 12387efe5d92SHajimu UMEMOTO mlast->m_len); 123982cd038dSYoshinobu Inoue mlast->m_len += sizeof(struct ip6_frag); 124082cd038dSYoshinobu Inoue m->m_pkthdr.len += sizeof(struct ip6_frag); 124182cd038dSYoshinobu Inoue } else { 124282cd038dSYoshinobu Inoue /* allocate a new mbuf for the fragment header */ 124382cd038dSYoshinobu Inoue struct mbuf *mfrg; 124482cd038dSYoshinobu Inoue 124510e5acc3SGleb Smirnoff mfrg = m_get(M_NOWAIT, MT_DATA); 124610e5acc3SGleb Smirnoff if (mfrg == NULL) 124782cd038dSYoshinobu Inoue return (ENOBUFS); 124882cd038dSYoshinobu Inoue mfrg->m_len = sizeof(struct ip6_frag); 124982cd038dSYoshinobu Inoue *frghdrp = mtod(mfrg, struct ip6_frag *); 125082cd038dSYoshinobu Inoue mlast->m_next = mfrg; 125182cd038dSYoshinobu Inoue } 125282cd038dSYoshinobu Inoue 125382cd038dSYoshinobu Inoue return (0); 125482cd038dSYoshinobu Inoue } 125582cd038dSYoshinobu Inoue 12560d4df029SAlexander V. Chernikov /* 12570d4df029SAlexander V. Chernikov * Calculates IPv6 path mtu for destination @dst. 12580d4df029SAlexander V. Chernikov * Resulting MTU is stored in @mtup. 12590d4df029SAlexander V. Chernikov * 12600d4df029SAlexander V. Chernikov * Returns 0 on success. 12610d4df029SAlexander V. Chernikov */ 126231b3783cSHajimu UMEMOTO static int 1263f0937b2cSAndrey V. Elsukov ip6_getpmtu_ctl(u_int fibnum, const struct in6_addr *dst, u_long *mtup) 12640d4df029SAlexander V. Chernikov { 1265bacf6684SAlexander V. Chernikov struct nhop6_extended nh6; 1266bacf6684SAlexander V. Chernikov struct in6_addr kdst; 1267bacf6684SAlexander V. Chernikov uint32_t scopeid; 12680d4df029SAlexander V. Chernikov struct ifnet *ifp; 12690d4df029SAlexander V. Chernikov u_long mtu; 1270bacf6684SAlexander V. Chernikov int error; 12710d4df029SAlexander V. Chernikov 1272bacf6684SAlexander V. Chernikov in6_splitscope(dst, &kdst, &scopeid); 1273bacf6684SAlexander V. Chernikov if (fib6_lookup_nh_ext(fibnum, &kdst, scopeid, NHR_REF, 0, &nh6) != 0) 12740d4df029SAlexander V. Chernikov return (EHOSTUNREACH); 12750d4df029SAlexander V. Chernikov 1276bacf6684SAlexander V. Chernikov ifp = nh6.nh_ifp; 1277bacf6684SAlexander V. Chernikov mtu = nh6.nh_mtu; 12780d4df029SAlexander V. Chernikov 1279d4c22202SAndrew Gallatin error = ip6_calcmtu(ifp, dst, mtu, mtup, NULL, 0); 1280bacf6684SAlexander V. Chernikov fib6_free_nh_ext(fibnum, &nh6); 1281bacf6684SAlexander V. Chernikov 1282bacf6684SAlexander V. Chernikov return (error); 12830d4df029SAlexander V. Chernikov } 12840d4df029SAlexander V. Chernikov 12850d4df029SAlexander V. Chernikov /* 12860d4df029SAlexander V. Chernikov * Calculates IPv6 path MTU for @dst based on transmit @ifp, 12870d4df029SAlexander V. Chernikov * and cached data in @ro_pmtu. 12880d4df029SAlexander V. Chernikov * MTU from (successful) route lookup is saved (along with dst) 12890d4df029SAlexander V. Chernikov * inside @ro_pmtu to avoid subsequent route lookups after packet 12900d4df029SAlexander V. Chernikov * filter processing. 12910d4df029SAlexander V. Chernikov * 12920d4df029SAlexander V. Chernikov * Stores mtu and always-frag value into @mtup and @alwaysfragp. 12930d4df029SAlexander V. Chernikov * Returns 0 on success. 12940d4df029SAlexander V. Chernikov */ 12950d4df029SAlexander V. Chernikov static int 12960d4df029SAlexander V. Chernikov ip6_getpmtu(struct route_in6 *ro_pmtu, int do_lookup, 1297f0937b2cSAndrey V. Elsukov struct ifnet *ifp, const struct in6_addr *dst, u_long *mtup, 1298d4c22202SAndrew Gallatin int *alwaysfragp, u_int fibnum, u_int proto) 129931b3783cSHajimu UMEMOTO { 1300bacf6684SAlexander V. Chernikov struct nhop6_basic nh6; 1301bacf6684SAlexander V. Chernikov struct in6_addr kdst; 1302bacf6684SAlexander V. Chernikov uint32_t scopeid; 13030d4df029SAlexander V. Chernikov struct sockaddr_in6 *sa6_dst; 13040d4df029SAlexander V. Chernikov u_long mtu; 130531b3783cSHajimu UMEMOTO 13060d4df029SAlexander V. Chernikov mtu = 0; 13070d4df029SAlexander V. Chernikov if (do_lookup) { 13080d4df029SAlexander V. Chernikov 13090d4df029SAlexander V. Chernikov /* 13100d4df029SAlexander V. Chernikov * Here ro_pmtu has final destination address, while 13110d4df029SAlexander V. Chernikov * ro might represent immediate destination. 13120d4df029SAlexander V. Chernikov * Use ro_pmtu destination since mtu might differ. 13130d4df029SAlexander V. Chernikov */ 13140d4df029SAlexander V. Chernikov sa6_dst = (struct sockaddr_in6 *)&ro_pmtu->ro_dst; 13150d4df029SAlexander V. Chernikov if (!IN6_ARE_ADDR_EQUAL(&sa6_dst->sin6_addr, dst)) 13160d4df029SAlexander V. Chernikov ro_pmtu->ro_mtu = 0; 13170d4df029SAlexander V. Chernikov 13180d4df029SAlexander V. Chernikov if (ro_pmtu->ro_mtu == 0) { 131931b3783cSHajimu UMEMOTO bzero(sa6_dst, sizeof(*sa6_dst)); 132031b3783cSHajimu UMEMOTO sa6_dst->sin6_family = AF_INET6; 132131b3783cSHajimu UMEMOTO sa6_dst->sin6_len = sizeof(struct sockaddr_in6); 132231b3783cSHajimu UMEMOTO sa6_dst->sin6_addr = *dst; 132331b3783cSHajimu UMEMOTO 1324bacf6684SAlexander V. Chernikov in6_splitscope(dst, &kdst, &scopeid); 1325bacf6684SAlexander V. Chernikov if (fib6_lookup_nh_basic(fibnum, &kdst, scopeid, 0, 0, 1326bacf6684SAlexander V. Chernikov &nh6) == 0) 1327bacf6684SAlexander V. Chernikov ro_pmtu->ro_mtu = nh6.nh_mtu; 13280d4df029SAlexander V. Chernikov } 1329bacf6684SAlexander V. Chernikov 1330bacf6684SAlexander V. Chernikov mtu = ro_pmtu->ro_mtu; 13310d4df029SAlexander V. Chernikov } 13320d4df029SAlexander V. Chernikov 13330d4df029SAlexander V. Chernikov if (ro_pmtu->ro_rt) 13340d4df029SAlexander V. Chernikov mtu = ro_pmtu->ro_rt->rt_mtu; 13350d4df029SAlexander V. Chernikov 1336d4c22202SAndrew Gallatin return (ip6_calcmtu(ifp, dst, mtu, mtup, alwaysfragp, proto)); 13370d4df029SAlexander V. Chernikov } 13380d4df029SAlexander V. Chernikov 13390d4df029SAlexander V. Chernikov /* 13400d4df029SAlexander V. Chernikov * Calculate MTU based on transmit @ifp, route mtu @rt_mtu and 13410d4df029SAlexander V. Chernikov * hostcache data for @dst. 13420d4df029SAlexander V. Chernikov * Stores mtu and always-frag value into @mtup and @alwaysfragp. 13430d4df029SAlexander V. Chernikov * 13440d4df029SAlexander V. Chernikov * Returns 0 on success. 13450d4df029SAlexander V. Chernikov */ 13460d4df029SAlexander V. Chernikov static int 13470d4df029SAlexander V. Chernikov ip6_calcmtu(struct ifnet *ifp, const struct in6_addr *dst, u_long rt_mtu, 1348d4c22202SAndrew Gallatin u_long *mtup, int *alwaysfragp, u_int proto) 13490d4df029SAlexander V. Chernikov { 13500d4df029SAlexander V. Chernikov u_long mtu = 0; 13510d4df029SAlexander V. Chernikov int alwaysfrag = 0; 13520d4df029SAlexander V. Chernikov int error = 0; 13530d4df029SAlexander V. Chernikov 13540d4df029SAlexander V. Chernikov if (rt_mtu > 0) { 135531b3783cSHajimu UMEMOTO u_int32_t ifmtu; 135697d8d152SAndre Oppermann struct in_conninfo inc; 135797d8d152SAndre Oppermann 135897d8d152SAndre Oppermann bzero(&inc, sizeof(inc)); 1359dcdb4371SBjoern A. Zeeb inc.inc_flags |= INC_ISIPV6; 136097d8d152SAndre Oppermann inc.inc6_faddr = *dst; 136131b3783cSHajimu UMEMOTO 136231b3783cSHajimu UMEMOTO ifmtu = IN6_LINKMTU(ifp); 1363d4c22202SAndrew Gallatin 1364d4c22202SAndrew Gallatin /* TCP is known to react to pmtu changes so skip hc */ 1365d4c22202SAndrew Gallatin if (proto != IPPROTO_TCP) 136697d8d152SAndre Oppermann mtu = tcp_hc_getmtu(&inc); 1367d4c22202SAndrew Gallatin 136897d8d152SAndre Oppermann if (mtu) 13690d4df029SAlexander V. Chernikov mtu = min(mtu, rt_mtu); 137097d8d152SAndre Oppermann else 13710d4df029SAlexander V. Chernikov mtu = rt_mtu; 137231b3783cSHajimu UMEMOTO if (mtu == 0) 137331b3783cSHajimu UMEMOTO mtu = ifmtu; 1374f95d4633SHajimu UMEMOTO else if (mtu < IPV6_MMTU) { 1375f95d4633SHajimu UMEMOTO /* 1376f95d4633SHajimu UMEMOTO * RFC2460 section 5, last paragraph: 1377f95d4633SHajimu UMEMOTO * if we record ICMPv6 too big message with 1378f95d4633SHajimu UMEMOTO * mtu < IPV6_MMTU, transmit packets sized IPV6_MMTU 1379f95d4633SHajimu UMEMOTO * or smaller, with framgent header attached. 1380f95d4633SHajimu UMEMOTO * (fragment header is needed regardless from the 1381f95d4633SHajimu UMEMOTO * packet size, for translators to identify packets) 1382f95d4633SHajimu UMEMOTO */ 1383f95d4633SHajimu UMEMOTO alwaysfrag = 1; 1384f95d4633SHajimu UMEMOTO mtu = IPV6_MMTU; 138531b3783cSHajimu UMEMOTO } 138631b3783cSHajimu UMEMOTO } else if (ifp) { 138731b3783cSHajimu UMEMOTO mtu = IN6_LINKMTU(ifp); 138831b3783cSHajimu UMEMOTO } else 138931b3783cSHajimu UMEMOTO error = EHOSTUNREACH; /* XXX */ 139031b3783cSHajimu UMEMOTO 139131b3783cSHajimu UMEMOTO *mtup = mtu; 1392f95d4633SHajimu UMEMOTO if (alwaysfragp) 1393f95d4633SHajimu UMEMOTO *alwaysfragp = alwaysfrag; 139431b3783cSHajimu UMEMOTO return (error); 139531b3783cSHajimu UMEMOTO } 139631b3783cSHajimu UMEMOTO 139782cd038dSYoshinobu Inoue /* 139882cd038dSYoshinobu Inoue * IP6 socket option processing. 139982cd038dSYoshinobu Inoue */ 140082cd038dSYoshinobu Inoue int 14011272577eSXin LI ip6_ctloutput(struct socket *so, struct sockopt *sopt) 140282cd038dSYoshinobu Inoue { 140379ba3952SBjoern A. Zeeb int optdatalen, uproto; 1404f95d4633SHajimu UMEMOTO void *optdata; 140533841545SHajimu UMEMOTO struct inpcb *in6p = sotoinpcb(so); 140682cd038dSYoshinobu Inoue int error, optval; 140782cd038dSYoshinobu Inoue int level, op, optname; 140882cd038dSYoshinobu Inoue int optlen; 1409b40ce416SJulian Elischer struct thread *td; 1410c7c0d948SAdrian Chadd #ifdef RSS 1411c7c0d948SAdrian Chadd uint32_t rss_bucket; 1412c7c0d948SAdrian Chadd int retval; 1413c7c0d948SAdrian Chadd #endif 141482cd038dSYoshinobu Inoue 1415aec9c8d5SGeorge V. Neville-Neil /* 1416aec9c8d5SGeorge V. Neville-Neil * Don't use more than a quarter of mbuf clusters. N.B.: 1417aec9c8d5SGeorge V. Neville-Neil * nmbclusters is an int, but nmbclusters * MCLBYTES may overflow 1418aec9c8d5SGeorge V. Neville-Neil * on LP64 architectures, so cast to u_long to avoid undefined 1419aec9c8d5SGeorge V. Neville-Neil * behavior. ILP32 architectures cannot have nmbclusters 1420aec9c8d5SGeorge V. Neville-Neil * large enough to overflow for other reasons. 1421aec9c8d5SGeorge V. Neville-Neil */ 1422aec9c8d5SGeorge V. Neville-Neil #define IPV6_PKTOPTIONS_MBUF_LIMIT ((u_long)nmbclusters * MCLBYTES / 4) 1423aec9c8d5SGeorge V. Neville-Neil 142482cd038dSYoshinobu Inoue level = sopt->sopt_level; 142582cd038dSYoshinobu Inoue op = sopt->sopt_dir; 142682cd038dSYoshinobu Inoue optname = sopt->sopt_name; 142782cd038dSYoshinobu Inoue optlen = sopt->sopt_valsize; 1428b40ce416SJulian Elischer td = sopt->sopt_td; 1429cc29ac7dSRobert Watson error = 0; 1430cc29ac7dSRobert Watson optval = 0; 1431f95d4633SHajimu UMEMOTO uproto = (int)so->so_proto->pr_protocol; 143282cd038dSYoshinobu Inoue 1433fc06cd42SMikolaj Golub if (level != IPPROTO_IPV6) { 1434fc06cd42SMikolaj Golub error = EINVAL; 1435fc06cd42SMikolaj Golub 1436fc06cd42SMikolaj Golub if (sopt->sopt_level == SOL_SOCKET && 1437fc06cd42SMikolaj Golub sopt->sopt_dir == SOPT_SET) { 1438fc06cd42SMikolaj Golub switch (sopt->sopt_name) { 1439fc06cd42SMikolaj Golub case SO_REUSEADDR: 1440fc06cd42SMikolaj Golub INP_WLOCK(in6p); 1441efdf104bSMikolaj Golub if ((so->so_options & SO_REUSEADDR) != 0) 1442efdf104bSMikolaj Golub in6p->inp_flags2 |= INP_REUSEADDR; 1443fc06cd42SMikolaj Golub else 1444efdf104bSMikolaj Golub in6p->inp_flags2 &= ~INP_REUSEADDR; 1445fc06cd42SMikolaj Golub INP_WUNLOCK(in6p); 1446fc06cd42SMikolaj Golub error = 0; 1447fc06cd42SMikolaj Golub break; 1448fc06cd42SMikolaj Golub case SO_REUSEPORT: 1449fc06cd42SMikolaj Golub INP_WLOCK(in6p); 1450fc06cd42SMikolaj Golub if ((so->so_options & SO_REUSEPORT) != 0) 1451fc06cd42SMikolaj Golub in6p->inp_flags2 |= INP_REUSEPORT; 1452fc06cd42SMikolaj Golub else 1453fc06cd42SMikolaj Golub in6p->inp_flags2 &= ~INP_REUSEPORT; 1454fc06cd42SMikolaj Golub INP_WUNLOCK(in6p); 1455fc06cd42SMikolaj Golub error = 0; 1456fc06cd42SMikolaj Golub break; 1457ee799639SBjoern A. Zeeb case SO_SETFIB: 1458ee799639SBjoern A. Zeeb INP_WLOCK(in6p); 1459ee799639SBjoern A. Zeeb in6p->inp_inc.inc_fibnum = so->so_fibnum; 1460ee799639SBjoern A. Zeeb INP_WUNLOCK(in6p); 1461ee799639SBjoern A. Zeeb error = 0; 1462ee799639SBjoern A. Zeeb break; 1463f3e7afe2SHans Petter Selasky case SO_MAX_PACING_RATE: 1464f3e7afe2SHans Petter Selasky #ifdef RATELIMIT 1465f3e7afe2SHans Petter Selasky INP_WLOCK(in6p); 1466f3e7afe2SHans Petter Selasky in6p->inp_flags2 |= INP_RATE_LIMIT_CHANGED; 1467f3e7afe2SHans Petter Selasky INP_WUNLOCK(in6p); 1468f3e7afe2SHans Petter Selasky error = 0; 1469f3e7afe2SHans Petter Selasky #else 1470f3e7afe2SHans Petter Selasky error = EOPNOTSUPP; 1471f3e7afe2SHans Petter Selasky #endif 1472f3e7afe2SHans Petter Selasky break; 1473fc06cd42SMikolaj Golub default: 1474fc06cd42SMikolaj Golub break; 1475fc06cd42SMikolaj Golub } 1476fc06cd42SMikolaj Golub } 1477fc06cd42SMikolaj Golub } else { /* level == IPPROTO_IPV6 */ 147882cd038dSYoshinobu Inoue switch (op) { 147933841545SHajimu UMEMOTO 148082cd038dSYoshinobu Inoue case SOPT_SET: 148182cd038dSYoshinobu Inoue switch (optname) { 1482f95d4633SHajimu UMEMOTO case IPV6_2292PKTOPTIONS: 1483f95d4633SHajimu UMEMOTO #ifdef IPV6_PKTOPTIONS 148482cd038dSYoshinobu Inoue case IPV6_PKTOPTIONS: 1485f95d4633SHajimu UMEMOTO #endif 148682cd038dSYoshinobu Inoue { 148782cd038dSYoshinobu Inoue struct mbuf *m; 148882cd038dSYoshinobu Inoue 1489aec9c8d5SGeorge V. Neville-Neil if (optlen > IPV6_PKTOPTIONS_MBUF_LIMIT) { 1490aec9c8d5SGeorge V. Neville-Neil printf("ip6_ctloutput: mbuf limit hit\n"); 1491aec9c8d5SGeorge V. Neville-Neil error = ENOBUFS; 1492aec9c8d5SGeorge V. Neville-Neil break; 1493aec9c8d5SGeorge V. Neville-Neil } 1494aec9c8d5SGeorge V. Neville-Neil 149582cd038dSYoshinobu Inoue error = soopt_getm(sopt, &m); /* XXX */ 1496a89ec05eSPeter Wemm if (error != 0) 149782cd038dSYoshinobu Inoue break; 149882cd038dSYoshinobu Inoue error = soopt_mcopyin(sopt, m); /* XXX */ 1499a89ec05eSPeter Wemm if (error != 0) 150082cd038dSYoshinobu Inoue break; 150133841545SHajimu UMEMOTO error = ip6_pcbopts(&in6p->in6p_outputopts, 150233841545SHajimu UMEMOTO m, so, sopt); 150333841545SHajimu UMEMOTO m_freem(m); /* XXX */ 150482cd038dSYoshinobu Inoue break; 150582cd038dSYoshinobu Inoue } 150633841545SHajimu UMEMOTO 150733841545SHajimu UMEMOTO /* 150833841545SHajimu UMEMOTO * Use of some Hop-by-Hop options or some 150933841545SHajimu UMEMOTO * Destination options, might require special 151033841545SHajimu UMEMOTO * privilege. That is, normal applications 151133841545SHajimu UMEMOTO * (without special privilege) might be forbidden 151233841545SHajimu UMEMOTO * from setting certain options in outgoing packets, 151333841545SHajimu UMEMOTO * and might never see certain options in received 151433841545SHajimu UMEMOTO * packets. [RFC 2292 Section 6] 151533841545SHajimu UMEMOTO * KAME specific note: 151633841545SHajimu UMEMOTO * KAME prevents non-privileged users from sending or 151733841545SHajimu UMEMOTO * receiving ANY hbh/dst options in order to avoid 151833841545SHajimu UMEMOTO * overhead of parsing options in the kernel. 151933841545SHajimu UMEMOTO */ 1520f95d4633SHajimu UMEMOTO case IPV6_RECVHOPOPTS: 1521f95d4633SHajimu UMEMOTO case IPV6_RECVDSTOPTS: 1522f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDRDSTOPTS: 152379ba3952SBjoern A. Zeeb if (td != NULL) { 152479ba3952SBjoern A. Zeeb error = priv_check(td, 152579ba3952SBjoern A. Zeeb PRIV_NETINET_SETHDROPTS); 152679ba3952SBjoern A. Zeeb if (error) 1527f95d4633SHajimu UMEMOTO break; 1528f95d4633SHajimu UMEMOTO } 1529f95d4633SHajimu UMEMOTO /* FALLTHROUGH */ 153082cd038dSYoshinobu Inoue case IPV6_UNICAST_HOPS: 1531f95d4633SHajimu UMEMOTO case IPV6_HOPLIMIT: 153233841545SHajimu UMEMOTO 1533f95d4633SHajimu UMEMOTO case IPV6_RECVPKTINFO: 1534f95d4633SHajimu UMEMOTO case IPV6_RECVHOPLIMIT: 1535f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDR: 1536f95d4633SHajimu UMEMOTO case IPV6_RECVPATHMTU: 1537f95d4633SHajimu UMEMOTO case IPV6_RECVTCLASS: 153868bb8d62SAdrian Chadd case IPV6_RECVFLOWID: 153968bb8d62SAdrian Chadd #ifdef RSS 154068bb8d62SAdrian Chadd case IPV6_RECVRSSBUCKETID: 154168bb8d62SAdrian Chadd #endif 154233841545SHajimu UMEMOTO case IPV6_V6ONLY: 1543f95d4633SHajimu UMEMOTO case IPV6_AUTOFLOWLABEL: 1544dce33a45SErmal Luçi case IPV6_ORIGDSTADDR: 1545f44270e7SPawel Jakub Dawidek case IPV6_BINDANY: 1546c7c0d948SAdrian Chadd case IPV6_BINDMULTI: 1547c7c0d948SAdrian Chadd #ifdef RSS 1548c7c0d948SAdrian Chadd case IPV6_RSS_LISTEN_BUCKET: 1549c7c0d948SAdrian Chadd #endif 1550f44270e7SPawel Jakub Dawidek if (optname == IPV6_BINDANY && td != NULL) { 1551f44270e7SPawel Jakub Dawidek error = priv_check(td, 1552f44270e7SPawel Jakub Dawidek PRIV_NETINET_BINDANY); 1553f44270e7SPawel Jakub Dawidek if (error) 1554f44270e7SPawel Jakub Dawidek break; 1555f44270e7SPawel Jakub Dawidek } 1556f44270e7SPawel Jakub Dawidek 155733841545SHajimu UMEMOTO if (optlen != sizeof(int)) { 155882cd038dSYoshinobu Inoue error = EINVAL; 155933841545SHajimu UMEMOTO break; 156033841545SHajimu UMEMOTO } 156182cd038dSYoshinobu Inoue error = sooptcopyin(sopt, &optval, 156282cd038dSYoshinobu Inoue sizeof optval, sizeof optval); 156382cd038dSYoshinobu Inoue if (error) 156482cd038dSYoshinobu Inoue break; 156582cd038dSYoshinobu Inoue switch (optname) { 156682cd038dSYoshinobu Inoue 156782cd038dSYoshinobu Inoue case IPV6_UNICAST_HOPS: 156882cd038dSYoshinobu Inoue if (optval < -1 || optval >= 256) 156982cd038dSYoshinobu Inoue error = EINVAL; 157082cd038dSYoshinobu Inoue else { 157182cd038dSYoshinobu Inoue /* -1 = kernel default */ 157282cd038dSYoshinobu Inoue in6p->in6p_hops = optval; 1573fc384fa5SBjoern A. Zeeb if ((in6p->inp_vflag & 157482cd038dSYoshinobu Inoue INP_IPV4) != 0) 157582cd038dSYoshinobu Inoue in6p->inp_ip_ttl = optval; 157682cd038dSYoshinobu Inoue } 157782cd038dSYoshinobu Inoue break; 157882cd038dSYoshinobu Inoue #define OPTSET(bit) \ 157933841545SHajimu UMEMOTO do { \ 1580ab16a5bdSMikolaj Golub INP_WLOCK(in6p); \ 158182cd038dSYoshinobu Inoue if (optval) \ 1582fc384fa5SBjoern A. Zeeb in6p->inp_flags |= (bit); \ 158382cd038dSYoshinobu Inoue else \ 1584fc384fa5SBjoern A. Zeeb in6p->inp_flags &= ~(bit); \ 1585ab16a5bdSMikolaj Golub INP_WUNLOCK(in6p); \ 15867efe5d92SHajimu UMEMOTO } while (/*CONSTCOND*/ 0) 1587f95d4633SHajimu UMEMOTO #define OPTSET2292(bit) \ 1588f95d4633SHajimu UMEMOTO do { \ 1589ab16a5bdSMikolaj Golub INP_WLOCK(in6p); \ 1590fc384fa5SBjoern A. Zeeb in6p->inp_flags |= IN6P_RFC2292; \ 1591f95d4633SHajimu UMEMOTO if (optval) \ 1592fc384fa5SBjoern A. Zeeb in6p->inp_flags |= (bit); \ 1593f95d4633SHajimu UMEMOTO else \ 1594fc384fa5SBjoern A. Zeeb in6p->inp_flags &= ~(bit); \ 1595ab16a5bdSMikolaj Golub INP_WUNLOCK(in6p); \ 1596f95d4633SHajimu UMEMOTO } while (/*CONSTCOND*/ 0) 1597fc384fa5SBjoern A. Zeeb #define OPTBIT(bit) (in6p->inp_flags & (bit) ? 1 : 0) 159882cd038dSYoshinobu Inoue 159937d4fc1eSSean Bruno #define OPTSET2_N(bit, val) do { \ 1600c7c0d948SAdrian Chadd if (val) \ 1601c7c0d948SAdrian Chadd in6p->inp_flags2 |= bit; \ 1602c7c0d948SAdrian Chadd else \ 1603c7c0d948SAdrian Chadd in6p->inp_flags2 &= ~bit; \ 160437d4fc1eSSean Bruno } while (0) 160537d4fc1eSSean Bruno #define OPTSET2(bit, val) do { \ 160637d4fc1eSSean Bruno INP_WLOCK(in6p); \ 160737d4fc1eSSean Bruno OPTSET2_N(bit, val); \ 1608c7c0d948SAdrian Chadd INP_WUNLOCK(in6p); \ 1609c7c0d948SAdrian Chadd } while (0) 1610c7c0d948SAdrian Chadd #define OPTBIT2(bit) (in6p->inp_flags2 & (bit) ? 1 : 0) 161137d4fc1eSSean Bruno #define OPTSET2292_EXCLUSIVE(bit) \ 161237d4fc1eSSean Bruno do { \ 161337d4fc1eSSean Bruno INP_WLOCK(in6p); \ 161437d4fc1eSSean Bruno if (OPTBIT(IN6P_RFC2292)) { \ 161537d4fc1eSSean Bruno error = EINVAL; \ 161637d4fc1eSSean Bruno } else { \ 161737d4fc1eSSean Bruno if (optval) \ 161837d4fc1eSSean Bruno in6p->inp_flags |= (bit); \ 161937d4fc1eSSean Bruno else \ 162037d4fc1eSSean Bruno in6p->inp_flags &= ~(bit); \ 162137d4fc1eSSean Bruno } \ 162237d4fc1eSSean Bruno INP_WUNLOCK(in6p); \ 162337d4fc1eSSean Bruno } while (/*CONSTCOND*/ 0) 1624c7c0d948SAdrian Chadd 1625f95d4633SHajimu UMEMOTO case IPV6_RECVPKTINFO: 162637d4fc1eSSean Bruno OPTSET2292_EXCLUSIVE(IN6P_PKTINFO); 1627f95d4633SHajimu UMEMOTO break; 1628f95d4633SHajimu UMEMOTO 1629f95d4633SHajimu UMEMOTO case IPV6_HOPLIMIT: 1630f95d4633SHajimu UMEMOTO { 1631f95d4633SHajimu UMEMOTO struct ip6_pktopts **optp; 1632f95d4633SHajimu UMEMOTO 1633f95d4633SHajimu UMEMOTO /* cannot mix with RFC2292 */ 1634f95d4633SHajimu UMEMOTO if (OPTBIT(IN6P_RFC2292)) { 1635f95d4633SHajimu UMEMOTO error = EINVAL; 1636f95d4633SHajimu UMEMOTO break; 1637f95d4633SHajimu UMEMOTO } 1638f95d4633SHajimu UMEMOTO optp = &in6p->in6p_outputopts; 1639f95d4633SHajimu UMEMOTO error = ip6_pcbopt(IPV6_HOPLIMIT, 164079ba3952SBjoern A. Zeeb (u_char *)&optval, sizeof(optval), 164179ba3952SBjoern A. Zeeb optp, (td != NULL) ? td->td_ucred : 164279ba3952SBjoern A. Zeeb NULL, uproto); 1643f95d4633SHajimu UMEMOTO break; 1644f95d4633SHajimu UMEMOTO } 1645f95d4633SHajimu UMEMOTO 1646f95d4633SHajimu UMEMOTO case IPV6_RECVHOPLIMIT: 164737d4fc1eSSean Bruno OPTSET2292_EXCLUSIVE(IN6P_HOPLIMIT); 1648f95d4633SHajimu UMEMOTO break; 1649f95d4633SHajimu UMEMOTO 1650f95d4633SHajimu UMEMOTO case IPV6_RECVHOPOPTS: 165137d4fc1eSSean Bruno OPTSET2292_EXCLUSIVE(IN6P_HOPOPTS); 1652f95d4633SHajimu UMEMOTO break; 1653f95d4633SHajimu UMEMOTO 1654f95d4633SHajimu UMEMOTO case IPV6_RECVDSTOPTS: 165537d4fc1eSSean Bruno OPTSET2292_EXCLUSIVE(IN6P_DSTOPTS); 1656f95d4633SHajimu UMEMOTO break; 1657f95d4633SHajimu UMEMOTO 1658f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDRDSTOPTS: 165937d4fc1eSSean Bruno OPTSET2292_EXCLUSIVE(IN6P_RTHDRDSTOPTS); 1660f95d4633SHajimu UMEMOTO break; 1661f95d4633SHajimu UMEMOTO 1662f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDR: 166337d4fc1eSSean Bruno OPTSET2292_EXCLUSIVE(IN6P_RTHDR); 166482cd038dSYoshinobu Inoue break; 166582cd038dSYoshinobu Inoue 1666f95d4633SHajimu UMEMOTO case IPV6_RECVPATHMTU: 1667f95d4633SHajimu UMEMOTO /* 1668f95d4633SHajimu UMEMOTO * We ignore this option for TCP 1669f95d4633SHajimu UMEMOTO * sockets. 167018b35df8SHajimu UMEMOTO * (RFC3542 leaves this case 1671f95d4633SHajimu UMEMOTO * unspecified.) 1672f95d4633SHajimu UMEMOTO */ 1673f95d4633SHajimu UMEMOTO if (uproto != IPPROTO_TCP) 1674f95d4633SHajimu UMEMOTO OPTSET(IN6P_MTU); 1675f95d4633SHajimu UMEMOTO break; 1676f95d4633SHajimu UMEMOTO 167768bb8d62SAdrian Chadd case IPV6_RECVFLOWID: 167868bb8d62SAdrian Chadd OPTSET2(INP_RECVFLOWID, optval); 167968bb8d62SAdrian Chadd break; 168068bb8d62SAdrian Chadd 168168bb8d62SAdrian Chadd #ifdef RSS 168268bb8d62SAdrian Chadd case IPV6_RECVRSSBUCKETID: 168368bb8d62SAdrian Chadd OPTSET2(INP_RECVRSSBUCKETID, optval); 168468bb8d62SAdrian Chadd break; 168568bb8d62SAdrian Chadd #endif 168668bb8d62SAdrian Chadd 168733841545SHajimu UMEMOTO case IPV6_V6ONLY: 168833841545SHajimu UMEMOTO /* 16890554093bSHajimu UMEMOTO * make setsockopt(IPV6_V6ONLY) 16900554093bSHajimu UMEMOTO * available only prior to bind(2). 16910554093bSHajimu UMEMOTO * see ipng mailing list, Jun 22 2001. 16920554093bSHajimu UMEMOTO */ 1693fc384fa5SBjoern A. Zeeb if (in6p->inp_lport || 16947efe5d92SHajimu UMEMOTO !IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) { 16950554093bSHajimu UMEMOTO error = EINVAL; 16960554093bSHajimu UMEMOTO break; 16970554093bSHajimu UMEMOTO } 169833841545SHajimu UMEMOTO OPTSET(IN6P_IPV6_V6ONLY); 169912253795SHajimu UMEMOTO if (optval) 1700fc384fa5SBjoern A. Zeeb in6p->inp_vflag &= ~INP_IPV4; 170112253795SHajimu UMEMOTO else 1702fc384fa5SBjoern A. Zeeb in6p->inp_vflag |= INP_IPV4; 170382cd038dSYoshinobu Inoue break; 1704f95d4633SHajimu UMEMOTO case IPV6_RECVTCLASS: 1705f95d4633SHajimu UMEMOTO /* cannot mix with RFC2292 XXX */ 170637d4fc1eSSean Bruno OPTSET2292_EXCLUSIVE(IN6P_TCLASS); 1707f95d4633SHajimu UMEMOTO break; 1708f95d4633SHajimu UMEMOTO case IPV6_AUTOFLOWLABEL: 1709f95d4633SHajimu UMEMOTO OPTSET(IN6P_AUTOFLOWLABEL); 1710f95d4633SHajimu UMEMOTO break; 1711f95d4633SHajimu UMEMOTO 1712dce33a45SErmal Luçi case IPV6_ORIGDSTADDR: 1713dce33a45SErmal Luçi OPTSET2(INP_ORIGDSTADDR, optval); 1714dce33a45SErmal Luçi break; 1715f44270e7SPawel Jakub Dawidek case IPV6_BINDANY: 1716f44270e7SPawel Jakub Dawidek OPTSET(INP_BINDANY); 1717f44270e7SPawel Jakub Dawidek break; 1718c7c0d948SAdrian Chadd 1719c7c0d948SAdrian Chadd case IPV6_BINDMULTI: 1720c7c0d948SAdrian Chadd OPTSET2(INP_BINDMULTI, optval); 1721c7c0d948SAdrian Chadd break; 1722c7c0d948SAdrian Chadd #ifdef RSS 1723c7c0d948SAdrian Chadd case IPV6_RSS_LISTEN_BUCKET: 1724c7c0d948SAdrian Chadd if ((optval >= 0) && 1725c7c0d948SAdrian Chadd (optval < rss_getnumbuckets())) { 172637d4fc1eSSean Bruno INP_WLOCK(in6p); 1727c7c0d948SAdrian Chadd in6p->inp_rss_listen_bucket = optval; 172837d4fc1eSSean Bruno OPTSET2_N(INP_RSS_BUCKET_SET, 1); 172937d4fc1eSSean Bruno INP_WUNLOCK(in6p); 1730c7c0d948SAdrian Chadd } else { 1731c7c0d948SAdrian Chadd error = EINVAL; 1732c7c0d948SAdrian Chadd } 1733c7c0d948SAdrian Chadd break; 1734c7c0d948SAdrian Chadd #endif 173582cd038dSYoshinobu Inoue } 173633841545SHajimu UMEMOTO break; 173733841545SHajimu UMEMOTO 1738f95d4633SHajimu UMEMOTO case IPV6_TCLASS: 1739f95d4633SHajimu UMEMOTO case IPV6_DONTFRAG: 1740f95d4633SHajimu UMEMOTO case IPV6_USE_MIN_MTU: 1741f95d4633SHajimu UMEMOTO case IPV6_PREFER_TEMPADDR: 1742f95d4633SHajimu UMEMOTO if (optlen != sizeof(optval)) { 1743f95d4633SHajimu UMEMOTO error = EINVAL; 1744f95d4633SHajimu UMEMOTO break; 1745f95d4633SHajimu UMEMOTO } 1746f95d4633SHajimu UMEMOTO error = sooptcopyin(sopt, &optval, 1747f95d4633SHajimu UMEMOTO sizeof optval, sizeof optval); 1748f95d4633SHajimu UMEMOTO if (error) 1749f95d4633SHajimu UMEMOTO break; 1750f95d4633SHajimu UMEMOTO { 1751f95d4633SHajimu UMEMOTO struct ip6_pktopts **optp; 1752f95d4633SHajimu UMEMOTO optp = &in6p->in6p_outputopts; 1753f95d4633SHajimu UMEMOTO error = ip6_pcbopt(optname, 175479ba3952SBjoern A. Zeeb (u_char *)&optval, sizeof(optval), 175579ba3952SBjoern A. Zeeb optp, (td != NULL) ? td->td_ucred : 175679ba3952SBjoern A. Zeeb NULL, uproto); 1757f95d4633SHajimu UMEMOTO break; 1758f95d4633SHajimu UMEMOTO } 1759f95d4633SHajimu UMEMOTO 1760f95d4633SHajimu UMEMOTO case IPV6_2292PKTINFO: 1761f95d4633SHajimu UMEMOTO case IPV6_2292HOPLIMIT: 1762f95d4633SHajimu UMEMOTO case IPV6_2292HOPOPTS: 1763f95d4633SHajimu UMEMOTO case IPV6_2292DSTOPTS: 1764f95d4633SHajimu UMEMOTO case IPV6_2292RTHDR: 176533841545SHajimu UMEMOTO /* RFC 2292 */ 176633841545SHajimu UMEMOTO if (optlen != sizeof(int)) { 176733841545SHajimu UMEMOTO error = EINVAL; 176833841545SHajimu UMEMOTO break; 176933841545SHajimu UMEMOTO } 177033841545SHajimu UMEMOTO error = sooptcopyin(sopt, &optval, 177133841545SHajimu UMEMOTO sizeof optval, sizeof optval); 177233841545SHajimu UMEMOTO if (error) 177333841545SHajimu UMEMOTO break; 177433841545SHajimu UMEMOTO switch (optname) { 1775f95d4633SHajimu UMEMOTO case IPV6_2292PKTINFO: 1776f95d4633SHajimu UMEMOTO OPTSET2292(IN6P_PKTINFO); 177733841545SHajimu UMEMOTO break; 1778f95d4633SHajimu UMEMOTO case IPV6_2292HOPLIMIT: 1779f95d4633SHajimu UMEMOTO OPTSET2292(IN6P_HOPLIMIT); 178033841545SHajimu UMEMOTO break; 1781f95d4633SHajimu UMEMOTO case IPV6_2292HOPOPTS: 178233841545SHajimu UMEMOTO /* 178333841545SHajimu UMEMOTO * Check super-user privilege. 178433841545SHajimu UMEMOTO * See comments for IPV6_RECVHOPOPTS. 178533841545SHajimu UMEMOTO */ 178679ba3952SBjoern A. Zeeb if (td != NULL) { 178779ba3952SBjoern A. Zeeb error = priv_check(td, 178879ba3952SBjoern A. Zeeb PRIV_NETINET_SETHDROPTS); 178979ba3952SBjoern A. Zeeb if (error) 179079ba3952SBjoern A. Zeeb return (error); 179179ba3952SBjoern A. Zeeb } 1792f95d4633SHajimu UMEMOTO OPTSET2292(IN6P_HOPOPTS); 179333841545SHajimu UMEMOTO break; 1794f95d4633SHajimu UMEMOTO case IPV6_2292DSTOPTS: 179579ba3952SBjoern A. Zeeb if (td != NULL) { 179679ba3952SBjoern A. Zeeb error = priv_check(td, 179779ba3952SBjoern A. Zeeb PRIV_NETINET_SETHDROPTS); 179879ba3952SBjoern A. Zeeb if (error) 179979ba3952SBjoern A. Zeeb return (error); 180079ba3952SBjoern A. Zeeb } 1801f95d4633SHajimu UMEMOTO OPTSET2292(IN6P_DSTOPTS|IN6P_RTHDRDSTOPTS); /* XXX */ 180233841545SHajimu UMEMOTO break; 1803f95d4633SHajimu UMEMOTO case IPV6_2292RTHDR: 1804f95d4633SHajimu UMEMOTO OPTSET2292(IN6P_RTHDR); 180533841545SHajimu UMEMOTO break; 180682cd038dSYoshinobu Inoue } 180782cd038dSYoshinobu Inoue break; 1808f95d4633SHajimu UMEMOTO case IPV6_PKTINFO: 1809f95d4633SHajimu UMEMOTO case IPV6_HOPOPTS: 1810f95d4633SHajimu UMEMOTO case IPV6_RTHDR: 1811f95d4633SHajimu UMEMOTO case IPV6_DSTOPTS: 1812f95d4633SHajimu UMEMOTO case IPV6_RTHDRDSTOPTS: 1813f95d4633SHajimu UMEMOTO case IPV6_NEXTHOP: 1814f95d4633SHajimu UMEMOTO { 181518b35df8SHajimu UMEMOTO /* new advanced API (RFC3542) */ 1816f95d4633SHajimu UMEMOTO u_char *optbuf; 1817e770771aSHajimu UMEMOTO u_char optbuf_storage[MCLBYTES]; 1818f95d4633SHajimu UMEMOTO int optlen; 1819f95d4633SHajimu UMEMOTO struct ip6_pktopts **optp; 1820f95d4633SHajimu UMEMOTO 182172bfa0bfSSean Bruno /* cannot mix with RFC2292 */ 182272bfa0bfSSean Bruno if (OPTBIT(IN6P_RFC2292)) { 182372bfa0bfSSean Bruno error = EINVAL; 182472bfa0bfSSean Bruno break; 182572bfa0bfSSean Bruno } 182672bfa0bfSSean Bruno 1827e770771aSHajimu UMEMOTO /* 1828e770771aSHajimu UMEMOTO * We only ensure valsize is not too large 1829e770771aSHajimu UMEMOTO * here. Further validation will be done 1830e770771aSHajimu UMEMOTO * later. 1831e770771aSHajimu UMEMOTO */ 1832e770771aSHajimu UMEMOTO error = sooptcopyin(sopt, optbuf_storage, 1833e770771aSHajimu UMEMOTO sizeof(optbuf_storage), 0); 1834a5d1aae3SHajimu UMEMOTO if (error) 1835a5d1aae3SHajimu UMEMOTO break; 1836f95d4633SHajimu UMEMOTO optlen = sopt->sopt_valsize; 1837e770771aSHajimu UMEMOTO optbuf = optbuf_storage; 1838f95d4633SHajimu UMEMOTO optp = &in6p->in6p_outputopts; 183979ba3952SBjoern A. Zeeb error = ip6_pcbopt(optname, optbuf, optlen, 184079ba3952SBjoern A. Zeeb optp, (td != NULL) ? td->td_ucred : NULL, 184179ba3952SBjoern A. Zeeb uproto); 1842f95d4633SHajimu UMEMOTO break; 1843f95d4633SHajimu UMEMOTO } 184482cd038dSYoshinobu Inoue #undef OPTSET 184582cd038dSYoshinobu Inoue 184682cd038dSYoshinobu Inoue case IPV6_MULTICAST_IF: 184782cd038dSYoshinobu Inoue case IPV6_MULTICAST_HOPS: 184882cd038dSYoshinobu Inoue case IPV6_MULTICAST_LOOP: 184982cd038dSYoshinobu Inoue case IPV6_JOIN_GROUP: 185082cd038dSYoshinobu Inoue case IPV6_LEAVE_GROUP: 185133cde130SBruce M Simpson case IPV6_MSFILTER: 185233cde130SBruce M Simpson case MCAST_BLOCK_SOURCE: 185333cde130SBruce M Simpson case MCAST_UNBLOCK_SOURCE: 185433cde130SBruce M Simpson case MCAST_JOIN_GROUP: 185533cde130SBruce M Simpson case MCAST_LEAVE_GROUP: 185633cde130SBruce M Simpson case MCAST_JOIN_SOURCE_GROUP: 185733cde130SBruce M Simpson case MCAST_LEAVE_SOURCE_GROUP: 185833cde130SBruce M Simpson error = ip6_setmoptions(in6p, sopt); 185982cd038dSYoshinobu Inoue break; 186082cd038dSYoshinobu Inoue 186182cd038dSYoshinobu Inoue case IPV6_PORTRANGE: 1862686cdd19SJun-ichiro itojun Hagino error = sooptcopyin(sopt, &optval, 1863686cdd19SJun-ichiro itojun Hagino sizeof optval, sizeof optval); 186482cd038dSYoshinobu Inoue if (error) 186582cd038dSYoshinobu Inoue break; 186682cd038dSYoshinobu Inoue 1867ab16a5bdSMikolaj Golub INP_WLOCK(in6p); 186882cd038dSYoshinobu Inoue switch (optval) { 186982cd038dSYoshinobu Inoue case IPV6_PORTRANGE_DEFAULT: 187097590249SBjoern A. Zeeb in6p->inp_flags &= ~(INP_LOWPORT); 187197590249SBjoern A. Zeeb in6p->inp_flags &= ~(INP_HIGHPORT); 187282cd038dSYoshinobu Inoue break; 187382cd038dSYoshinobu Inoue 187482cd038dSYoshinobu Inoue case IPV6_PORTRANGE_HIGH: 187597590249SBjoern A. Zeeb in6p->inp_flags &= ~(INP_LOWPORT); 187697590249SBjoern A. Zeeb in6p->inp_flags |= INP_HIGHPORT; 187782cd038dSYoshinobu Inoue break; 187882cd038dSYoshinobu Inoue 187982cd038dSYoshinobu Inoue case IPV6_PORTRANGE_LOW: 188097590249SBjoern A. Zeeb in6p->inp_flags &= ~(INP_HIGHPORT); 188197590249SBjoern A. Zeeb in6p->inp_flags |= INP_LOWPORT; 188282cd038dSYoshinobu Inoue break; 188382cd038dSYoshinobu Inoue 188482cd038dSYoshinobu Inoue default: 188582cd038dSYoshinobu Inoue error = EINVAL; 188682cd038dSYoshinobu Inoue break; 188782cd038dSYoshinobu Inoue } 1888ab16a5bdSMikolaj Golub INP_WUNLOCK(in6p); 188982cd038dSYoshinobu Inoue break; 189082cd038dSYoshinobu Inoue 1891fcf59617SAndrey V. Elsukov #if defined(IPSEC) || defined(IPSEC_SUPPORT) 189282cd038dSYoshinobu Inoue case IPV6_IPSEC_POLICY: 1893fcf59617SAndrey V. Elsukov if (IPSEC_ENABLED(ipv6)) { 1894fcf59617SAndrey V. Elsukov error = IPSEC_PCBCTL(ipv6, in6p, sopt); 189582cd038dSYoshinobu Inoue break; 1896c26fe973SBjoern A. Zeeb } 1897fcf59617SAndrey V. Elsukov /* FALLTHROUGH */ 1898b2630c29SGeorge V. Neville-Neil #endif /* IPSEC */ 189982cd038dSYoshinobu Inoue 190082cd038dSYoshinobu Inoue default: 190182cd038dSYoshinobu Inoue error = ENOPROTOOPT; 190282cd038dSYoshinobu Inoue break; 190382cd038dSYoshinobu Inoue } 190482cd038dSYoshinobu Inoue break; 190582cd038dSYoshinobu Inoue 190682cd038dSYoshinobu Inoue case SOPT_GET: 190782cd038dSYoshinobu Inoue switch (optname) { 190882cd038dSYoshinobu Inoue 1909f95d4633SHajimu UMEMOTO case IPV6_2292PKTOPTIONS: 1910f95d4633SHajimu UMEMOTO #ifdef IPV6_PKTOPTIONS 191182cd038dSYoshinobu Inoue case IPV6_PKTOPTIONS: 1912f95d4633SHajimu UMEMOTO #endif 1913f95d4633SHajimu UMEMOTO /* 1914f95d4633SHajimu UMEMOTO * RFC3542 (effectively) deprecated the 1915f95d4633SHajimu UMEMOTO * semantics of the 2292-style pktoptions. 1916f95d4633SHajimu UMEMOTO * Since it was not reliable in nature (i.e., 1917f95d4633SHajimu UMEMOTO * applications had to expect the lack of some 1918f95d4633SHajimu UMEMOTO * information after all), it would make sense 1919f95d4633SHajimu UMEMOTO * to simplify this part by always returning 1920f95d4633SHajimu UMEMOTO * empty data. 1921f95d4633SHajimu UMEMOTO */ 192282cd038dSYoshinobu Inoue sopt->sopt_valsize = 0; 192382cd038dSYoshinobu Inoue break; 192482cd038dSYoshinobu Inoue 1925f95d4633SHajimu UMEMOTO case IPV6_RECVHOPOPTS: 1926f95d4633SHajimu UMEMOTO case IPV6_RECVDSTOPTS: 1927f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDRDSTOPTS: 192882cd038dSYoshinobu Inoue case IPV6_UNICAST_HOPS: 1929f95d4633SHajimu UMEMOTO case IPV6_RECVPKTINFO: 1930f95d4633SHajimu UMEMOTO case IPV6_RECVHOPLIMIT: 1931f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDR: 1932f95d4633SHajimu UMEMOTO case IPV6_RECVPATHMTU: 193333841545SHajimu UMEMOTO 193433841545SHajimu UMEMOTO case IPV6_V6ONLY: 1935fa310a7eSYoshinobu Inoue case IPV6_PORTRANGE: 1936f95d4633SHajimu UMEMOTO case IPV6_RECVTCLASS: 1937f95d4633SHajimu UMEMOTO case IPV6_AUTOFLOWLABEL: 19385f6bf451SAttilio Rao case IPV6_BINDANY: 1939c7c0d948SAdrian Chadd case IPV6_FLOWID: 1940c7c0d948SAdrian Chadd case IPV6_FLOWTYPE: 194168bb8d62SAdrian Chadd case IPV6_RECVFLOWID: 1942c7c0d948SAdrian Chadd #ifdef RSS 1943c7c0d948SAdrian Chadd case IPV6_RSSBUCKETID: 194468bb8d62SAdrian Chadd case IPV6_RECVRSSBUCKETID: 1945c7c0d948SAdrian Chadd #endif 1946912568c8SJonathan T. Looney case IPV6_BINDMULTI: 194782cd038dSYoshinobu Inoue switch (optname) { 194882cd038dSYoshinobu Inoue 1949f95d4633SHajimu UMEMOTO case IPV6_RECVHOPOPTS: 1950f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_HOPOPTS); 1951f95d4633SHajimu UMEMOTO break; 1952f95d4633SHajimu UMEMOTO 1953f95d4633SHajimu UMEMOTO case IPV6_RECVDSTOPTS: 1954f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_DSTOPTS); 1955f95d4633SHajimu UMEMOTO break; 1956f95d4633SHajimu UMEMOTO 1957f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDRDSTOPTS: 1958f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_RTHDRDSTOPTS); 1959f95d4633SHajimu UMEMOTO break; 1960f95d4633SHajimu UMEMOTO 196182cd038dSYoshinobu Inoue case IPV6_UNICAST_HOPS: 196282cd038dSYoshinobu Inoue optval = in6p->in6p_hops; 196382cd038dSYoshinobu Inoue break; 196482cd038dSYoshinobu Inoue 1965f95d4633SHajimu UMEMOTO case IPV6_RECVPKTINFO: 1966f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_PKTINFO); 1967f95d4633SHajimu UMEMOTO break; 1968f95d4633SHajimu UMEMOTO 1969f95d4633SHajimu UMEMOTO case IPV6_RECVHOPLIMIT: 1970f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_HOPLIMIT); 1971f95d4633SHajimu UMEMOTO break; 1972f95d4633SHajimu UMEMOTO 1973f95d4633SHajimu UMEMOTO case IPV6_RECVRTHDR: 1974f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_RTHDR); 1975f95d4633SHajimu UMEMOTO break; 1976f95d4633SHajimu UMEMOTO 1977f95d4633SHajimu UMEMOTO case IPV6_RECVPATHMTU: 1978f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_MTU); 197982cd038dSYoshinobu Inoue break; 198082cd038dSYoshinobu Inoue 198133841545SHajimu UMEMOTO case IPV6_V6ONLY: 1982854d3b19SHajimu UMEMOTO optval = OPTBIT(IN6P_IPV6_V6ONLY); 198382cd038dSYoshinobu Inoue break; 198482cd038dSYoshinobu Inoue 198582cd038dSYoshinobu Inoue case IPV6_PORTRANGE: 198682cd038dSYoshinobu Inoue { 198782cd038dSYoshinobu Inoue int flags; 1988fc384fa5SBjoern A. Zeeb flags = in6p->inp_flags; 198997590249SBjoern A. Zeeb if (flags & INP_HIGHPORT) 199082cd038dSYoshinobu Inoue optval = IPV6_PORTRANGE_HIGH; 199197590249SBjoern A. Zeeb else if (flags & INP_LOWPORT) 199282cd038dSYoshinobu Inoue optval = IPV6_PORTRANGE_LOW; 199382cd038dSYoshinobu Inoue else 199482cd038dSYoshinobu Inoue optval = 0; 199582cd038dSYoshinobu Inoue break; 199682cd038dSYoshinobu Inoue } 1997f95d4633SHajimu UMEMOTO case IPV6_RECVTCLASS: 1998f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_TCLASS); 1999f95d4633SHajimu UMEMOTO break; 2000f95d4633SHajimu UMEMOTO 2001f95d4633SHajimu UMEMOTO case IPV6_AUTOFLOWLABEL: 2002f95d4633SHajimu UMEMOTO optval = OPTBIT(IN6P_AUTOFLOWLABEL); 2003f95d4633SHajimu UMEMOTO break; 2004f44270e7SPawel Jakub Dawidek 2005dce33a45SErmal Luçi case IPV6_ORIGDSTADDR: 2006dce33a45SErmal Luçi optval = OPTBIT2(INP_ORIGDSTADDR); 2007dce33a45SErmal Luçi break; 2008dce33a45SErmal Luçi 2009f44270e7SPawel Jakub Dawidek case IPV6_BINDANY: 2010f44270e7SPawel Jakub Dawidek optval = OPTBIT(INP_BINDANY); 2011f44270e7SPawel Jakub Dawidek break; 2012c7c0d948SAdrian Chadd 2013c7c0d948SAdrian Chadd case IPV6_FLOWID: 2014c7c0d948SAdrian Chadd optval = in6p->inp_flowid; 2015c7c0d948SAdrian Chadd break; 2016c7c0d948SAdrian Chadd 2017c7c0d948SAdrian Chadd case IPV6_FLOWTYPE: 2018c7c0d948SAdrian Chadd optval = in6p->inp_flowtype; 2019c7c0d948SAdrian Chadd break; 202068bb8d62SAdrian Chadd 202168bb8d62SAdrian Chadd case IPV6_RECVFLOWID: 202268bb8d62SAdrian Chadd optval = OPTBIT2(INP_RECVFLOWID); 202368bb8d62SAdrian Chadd break; 2024c7c0d948SAdrian Chadd #ifdef RSS 2025c7c0d948SAdrian Chadd case IPV6_RSSBUCKETID: 2026c7c0d948SAdrian Chadd retval = 2027c7c0d948SAdrian Chadd rss_hash2bucket(in6p->inp_flowid, 2028c7c0d948SAdrian Chadd in6p->inp_flowtype, 2029c7c0d948SAdrian Chadd &rss_bucket); 2030c7c0d948SAdrian Chadd if (retval == 0) 2031c7c0d948SAdrian Chadd optval = rss_bucket; 2032c7c0d948SAdrian Chadd else 2033c7c0d948SAdrian Chadd error = EINVAL; 2034c7c0d948SAdrian Chadd break; 203568bb8d62SAdrian Chadd 203668bb8d62SAdrian Chadd case IPV6_RECVRSSBUCKETID: 203768bb8d62SAdrian Chadd optval = OPTBIT2(INP_RECVRSSBUCKETID); 203868bb8d62SAdrian Chadd break; 2039c7c0d948SAdrian Chadd #endif 2040c7c0d948SAdrian Chadd 2041c7c0d948SAdrian Chadd case IPV6_BINDMULTI: 2042c7c0d948SAdrian Chadd optval = OPTBIT2(INP_BINDMULTI); 2043c7c0d948SAdrian Chadd break; 2044c7c0d948SAdrian Chadd 204582cd038dSYoshinobu Inoue } 2046f95d4633SHajimu UMEMOTO if (error) 2047f95d4633SHajimu UMEMOTO break; 204882cd038dSYoshinobu Inoue error = sooptcopyout(sopt, &optval, 204982cd038dSYoshinobu Inoue sizeof optval); 205082cd038dSYoshinobu Inoue break; 205182cd038dSYoshinobu Inoue 2052f95d4633SHajimu UMEMOTO case IPV6_PATHMTU: 2053f95d4633SHajimu UMEMOTO { 2054f95d4633SHajimu UMEMOTO u_long pmtu = 0; 2055f95d4633SHajimu UMEMOTO struct ip6_mtuinfo mtuinfo; 20565cbeca44SSean Bruno struct in6_addr addr; 2057f95d4633SHajimu UMEMOTO 2058f95d4633SHajimu UMEMOTO if (!(so->so_state & SS_ISCONNECTED)) 2059f95d4633SHajimu UMEMOTO return (ENOTCONN); 2060f95d4633SHajimu UMEMOTO /* 2061f95d4633SHajimu UMEMOTO * XXX: we dot not consider the case of source 2062f95d4633SHajimu UMEMOTO * routing, or optional information to specify 2063f95d4633SHajimu UMEMOTO * the outgoing interface. 20645cbeca44SSean Bruno * Copy faddr out of in6p to avoid holding lock 20655cbeca44SSean Bruno * on inp during route lookup. 2066f95d4633SHajimu UMEMOTO */ 20675cbeca44SSean Bruno INP_RLOCK(in6p); 20685cbeca44SSean Bruno bcopy(&in6p->in6p_faddr, &addr, sizeof(addr)); 20695cbeca44SSean Bruno INP_RUNLOCK(in6p); 20700d4df029SAlexander V. Chernikov error = ip6_getpmtu_ctl(so->so_fibnum, 20715cbeca44SSean Bruno &addr, &pmtu); 2072f95d4633SHajimu UMEMOTO if (error) 2073f95d4633SHajimu UMEMOTO break; 2074f95d4633SHajimu UMEMOTO if (pmtu > IPV6_MAXPACKET) 2075f95d4633SHajimu UMEMOTO pmtu = IPV6_MAXPACKET; 2076f95d4633SHajimu UMEMOTO 2077f95d4633SHajimu UMEMOTO bzero(&mtuinfo, sizeof(mtuinfo)); 2078f95d4633SHajimu UMEMOTO mtuinfo.ip6m_mtu = (u_int32_t)pmtu; 2079f95d4633SHajimu UMEMOTO optdata = (void *)&mtuinfo; 2080f95d4633SHajimu UMEMOTO optdatalen = sizeof(mtuinfo); 2081f95d4633SHajimu UMEMOTO error = sooptcopyout(sopt, optdata, 2082f95d4633SHajimu UMEMOTO optdatalen); 2083f95d4633SHajimu UMEMOTO break; 2084f95d4633SHajimu UMEMOTO } 2085f95d4633SHajimu UMEMOTO 2086f95d4633SHajimu UMEMOTO case IPV6_2292PKTINFO: 2087f95d4633SHajimu UMEMOTO case IPV6_2292HOPLIMIT: 2088f95d4633SHajimu UMEMOTO case IPV6_2292HOPOPTS: 2089f95d4633SHajimu UMEMOTO case IPV6_2292RTHDR: 2090f95d4633SHajimu UMEMOTO case IPV6_2292DSTOPTS: 209133841545SHajimu UMEMOTO switch (optname) { 2092f95d4633SHajimu UMEMOTO case IPV6_2292PKTINFO: 209333841545SHajimu UMEMOTO optval = OPTBIT(IN6P_PKTINFO); 209433841545SHajimu UMEMOTO break; 2095f95d4633SHajimu UMEMOTO case IPV6_2292HOPLIMIT: 209633841545SHajimu UMEMOTO optval = OPTBIT(IN6P_HOPLIMIT); 209733841545SHajimu UMEMOTO break; 2098f95d4633SHajimu UMEMOTO case IPV6_2292HOPOPTS: 209933841545SHajimu UMEMOTO optval = OPTBIT(IN6P_HOPOPTS); 210033841545SHajimu UMEMOTO break; 2101f95d4633SHajimu UMEMOTO case IPV6_2292RTHDR: 210233841545SHajimu UMEMOTO optval = OPTBIT(IN6P_RTHDR); 210333841545SHajimu UMEMOTO break; 2104f95d4633SHajimu UMEMOTO case IPV6_2292DSTOPTS: 210533841545SHajimu UMEMOTO optval = OPTBIT(IN6P_DSTOPTS|IN6P_RTHDRDSTOPTS); 210633841545SHajimu UMEMOTO break; 210733841545SHajimu UMEMOTO } 210833841545SHajimu UMEMOTO error = sooptcopyout(sopt, &optval, 210933841545SHajimu UMEMOTO sizeof optval); 211033841545SHajimu UMEMOTO break; 2111f95d4633SHajimu UMEMOTO case IPV6_PKTINFO: 2112f95d4633SHajimu UMEMOTO case IPV6_HOPOPTS: 2113f95d4633SHajimu UMEMOTO case IPV6_RTHDR: 2114f95d4633SHajimu UMEMOTO case IPV6_DSTOPTS: 2115f95d4633SHajimu UMEMOTO case IPV6_RTHDRDSTOPTS: 2116f95d4633SHajimu UMEMOTO case IPV6_NEXTHOP: 2117f95d4633SHajimu UMEMOTO case IPV6_TCLASS: 2118f95d4633SHajimu UMEMOTO case IPV6_DONTFRAG: 2119f95d4633SHajimu UMEMOTO case IPV6_USE_MIN_MTU: 2120f95d4633SHajimu UMEMOTO case IPV6_PREFER_TEMPADDR: 212106b479a6SSean Bruno error = ip6_getpcbopt(in6p, optname, sopt); 2122f95d4633SHajimu UMEMOTO break; 212333841545SHajimu UMEMOTO 212482cd038dSYoshinobu Inoue case IPV6_MULTICAST_IF: 212582cd038dSYoshinobu Inoue case IPV6_MULTICAST_HOPS: 212682cd038dSYoshinobu Inoue case IPV6_MULTICAST_LOOP: 212733cde130SBruce M Simpson case IPV6_MSFILTER: 212833cde130SBruce M Simpson error = ip6_getmoptions(in6p, sopt); 212982cd038dSYoshinobu Inoue break; 213082cd038dSYoshinobu Inoue 2131fcf59617SAndrey V. Elsukov #if defined(IPSEC) || defined(IPSEC_SUPPORT) 213282cd038dSYoshinobu Inoue case IPV6_IPSEC_POLICY: 2133fcf59617SAndrey V. Elsukov if (IPSEC_ENABLED(ipv6)) { 2134fcf59617SAndrey V. Elsukov error = IPSEC_PCBCTL(ipv6, in6p, sopt); 213582cd038dSYoshinobu Inoue break; 213682cd038dSYoshinobu Inoue } 2137fcf59617SAndrey V. Elsukov /* FALLTHROUGH */ 2138b2630c29SGeorge V. Neville-Neil #endif /* IPSEC */ 213982cd038dSYoshinobu Inoue default: 214082cd038dSYoshinobu Inoue error = ENOPROTOOPT; 214182cd038dSYoshinobu Inoue break; 214282cd038dSYoshinobu Inoue } 214382cd038dSYoshinobu Inoue break; 214482cd038dSYoshinobu Inoue } 214582cd038dSYoshinobu Inoue } 214682cd038dSYoshinobu Inoue return (error); 214782cd038dSYoshinobu Inoue } 214882cd038dSYoshinobu Inoue 214902b9a206SHajimu UMEMOTO int 21501272577eSXin LI ip6_raw_ctloutput(struct socket *so, struct sockopt *sopt) 215102b9a206SHajimu UMEMOTO { 215202b9a206SHajimu UMEMOTO int error = 0, optval, optlen; 215302b9a206SHajimu UMEMOTO const int icmp6off = offsetof(struct icmp6_hdr, icmp6_cksum); 2154fc384fa5SBjoern A. Zeeb struct inpcb *in6p = sotoinpcb(so); 215502b9a206SHajimu UMEMOTO int level, op, optname; 215602b9a206SHajimu UMEMOTO 215702b9a206SHajimu UMEMOTO level = sopt->sopt_level; 215802b9a206SHajimu UMEMOTO op = sopt->sopt_dir; 215902b9a206SHajimu UMEMOTO optname = sopt->sopt_name; 216002b9a206SHajimu UMEMOTO optlen = sopt->sopt_valsize; 216102b9a206SHajimu UMEMOTO 216202b9a206SHajimu UMEMOTO if (level != IPPROTO_IPV6) { 216302b9a206SHajimu UMEMOTO return (EINVAL); 216402b9a206SHajimu UMEMOTO } 216502b9a206SHajimu UMEMOTO 216602b9a206SHajimu UMEMOTO switch (optname) { 216702b9a206SHajimu UMEMOTO case IPV6_CHECKSUM: 216802b9a206SHajimu UMEMOTO /* 216902b9a206SHajimu UMEMOTO * For ICMPv6 sockets, no modification allowed for checksum 217002b9a206SHajimu UMEMOTO * offset, permit "no change" values to help existing apps. 217102b9a206SHajimu UMEMOTO * 217218b35df8SHajimu UMEMOTO * RFC3542 says: "An attempt to set IPV6_CHECKSUM 217302b9a206SHajimu UMEMOTO * for an ICMPv6 socket will fail." 217418b35df8SHajimu UMEMOTO * The current behavior does not meet RFC3542. 217502b9a206SHajimu UMEMOTO */ 217602b9a206SHajimu UMEMOTO switch (op) { 217702b9a206SHajimu UMEMOTO case SOPT_SET: 217802b9a206SHajimu UMEMOTO if (optlen != sizeof(int)) { 217902b9a206SHajimu UMEMOTO error = EINVAL; 218002b9a206SHajimu UMEMOTO break; 218102b9a206SHajimu UMEMOTO } 218202b9a206SHajimu UMEMOTO error = sooptcopyin(sopt, &optval, sizeof(optval), 218302b9a206SHajimu UMEMOTO sizeof(optval)); 218402b9a206SHajimu UMEMOTO if (error) 218502b9a206SHajimu UMEMOTO break; 218602b9a206SHajimu UMEMOTO if ((optval % 2) != 0) { 218702b9a206SHajimu UMEMOTO /* the API assumes even offset values */ 218802b9a206SHajimu UMEMOTO error = EINVAL; 218902b9a206SHajimu UMEMOTO } else if (so->so_proto->pr_protocol == 219002b9a206SHajimu UMEMOTO IPPROTO_ICMPV6) { 219102b9a206SHajimu UMEMOTO if (optval != icmp6off) 219202b9a206SHajimu UMEMOTO error = EINVAL; 219302b9a206SHajimu UMEMOTO } else 219402b9a206SHajimu UMEMOTO in6p->in6p_cksum = optval; 219502b9a206SHajimu UMEMOTO break; 219602b9a206SHajimu UMEMOTO 219702b9a206SHajimu UMEMOTO case SOPT_GET: 219802b9a206SHajimu UMEMOTO if (so->so_proto->pr_protocol == IPPROTO_ICMPV6) 219902b9a206SHajimu UMEMOTO optval = icmp6off; 220002b9a206SHajimu UMEMOTO else 220102b9a206SHajimu UMEMOTO optval = in6p->in6p_cksum; 220202b9a206SHajimu UMEMOTO 220302b9a206SHajimu UMEMOTO error = sooptcopyout(sopt, &optval, sizeof(optval)); 220402b9a206SHajimu UMEMOTO break; 220502b9a206SHajimu UMEMOTO 220602b9a206SHajimu UMEMOTO default: 220702b9a206SHajimu UMEMOTO error = EINVAL; 220802b9a206SHajimu UMEMOTO break; 220902b9a206SHajimu UMEMOTO } 221002b9a206SHajimu UMEMOTO break; 221102b9a206SHajimu UMEMOTO 221202b9a206SHajimu UMEMOTO default: 221302b9a206SHajimu UMEMOTO error = ENOPROTOOPT; 221402b9a206SHajimu UMEMOTO break; 221502b9a206SHajimu UMEMOTO } 221602b9a206SHajimu UMEMOTO 221702b9a206SHajimu UMEMOTO return (error); 221802b9a206SHajimu UMEMOTO } 221902b9a206SHajimu UMEMOTO 222082cd038dSYoshinobu Inoue /* 222133841545SHajimu UMEMOTO * Set up IP6 options in pcb for insertion in output packets or 222233841545SHajimu UMEMOTO * specifying behavior of outgoing packets. 222382cd038dSYoshinobu Inoue */ 222482cd038dSYoshinobu Inoue static int 22251272577eSXin LI ip6_pcbopts(struct ip6_pktopts **pktopt, struct mbuf *m, 22261272577eSXin LI struct socket *so, struct sockopt *sopt) 222782cd038dSYoshinobu Inoue { 222833841545SHajimu UMEMOTO struct ip6_pktopts *opt = *pktopt; 222982cd038dSYoshinobu Inoue int error = 0; 2230b40ce416SJulian Elischer struct thread *td = sopt->sopt_td; 223182cd038dSYoshinobu Inoue 223282cd038dSYoshinobu Inoue /* turn off any old options. */ 223382cd038dSYoshinobu Inoue if (opt) { 223433841545SHajimu UMEMOTO #ifdef DIAGNOSTIC 223533841545SHajimu UMEMOTO if (opt->ip6po_pktinfo || opt->ip6po_nexthop || 223633841545SHajimu UMEMOTO opt->ip6po_hbh || opt->ip6po_dest1 || opt->ip6po_dest2 || 223733841545SHajimu UMEMOTO opt->ip6po_rhinfo.ip6po_rhi_rthdr) 223833841545SHajimu UMEMOTO printf("ip6_pcbopts: all specified options are cleared.\n"); 223933841545SHajimu UMEMOTO #endif 2240f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, -1); 224182cd038dSYoshinobu Inoue } else 2242a163d034SWarner Losh opt = malloc(sizeof(*opt), M_IP6OPT, M_WAITOK); 224333841545SHajimu UMEMOTO *pktopt = NULL; 224482cd038dSYoshinobu Inoue 224582cd038dSYoshinobu Inoue if (!m || m->m_len == 0) { 224682cd038dSYoshinobu Inoue /* 224735f6695bSHajimu UMEMOTO * Only turning off any previous options, regardless of 224835f6695bSHajimu UMEMOTO * whether the opt is just created or given. 224982cd038dSYoshinobu Inoue */ 225082cd038dSYoshinobu Inoue free(opt, M_IP6OPT); 225182cd038dSYoshinobu Inoue return (0); 225282cd038dSYoshinobu Inoue } 225382cd038dSYoshinobu Inoue 225482cd038dSYoshinobu Inoue /* set options specified by user. */ 225579ba3952SBjoern A. Zeeb if ((error = ip6_setpktopts(m, opt, NULL, (td != NULL) ? 225679ba3952SBjoern A. Zeeb td->td_ucred : NULL, so->so_proto->pr_protocol)) != 0) { 2257f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, -1); /* XXX: discard all options */ 225835f6695bSHajimu UMEMOTO free(opt, M_IP6OPT); 225982cd038dSYoshinobu Inoue return (error); 226082cd038dSYoshinobu Inoue } 226182cd038dSYoshinobu Inoue *pktopt = opt; 226282cd038dSYoshinobu Inoue return (0); 226382cd038dSYoshinobu Inoue } 226482cd038dSYoshinobu Inoue 226582cd038dSYoshinobu Inoue /* 226633841545SHajimu UMEMOTO * initialize ip6_pktopts. beware that there are non-zero default values in 226733841545SHajimu UMEMOTO * the struct. 226833841545SHajimu UMEMOTO */ 226933841545SHajimu UMEMOTO void 22701272577eSXin LI ip6_initpktopts(struct ip6_pktopts *opt) 227133841545SHajimu UMEMOTO { 227233841545SHajimu UMEMOTO 227333841545SHajimu UMEMOTO bzero(opt, sizeof(*opt)); 227433841545SHajimu UMEMOTO opt->ip6po_hlim = -1; /* -1 means default hop limit */ 2275f95d4633SHajimu UMEMOTO opt->ip6po_tclass = -1; /* -1 means default traffic class */ 2276f95d4633SHajimu UMEMOTO opt->ip6po_minmtu = IP6PO_MINMTU_MCASTONLY; 2277f95d4633SHajimu UMEMOTO opt->ip6po_prefer_tempaddr = IP6PO_TEMPADDR_SYSTEM; 2278f95d4633SHajimu UMEMOTO } 2279f95d4633SHajimu UMEMOTO 2280f95d4633SHajimu UMEMOTO static int 22811272577eSXin LI ip6_pcbopt(int optname, u_char *buf, int len, struct ip6_pktopts **pktopt, 228279ba3952SBjoern A. Zeeb struct ucred *cred, int uproto) 2283f95d4633SHajimu UMEMOTO { 2284f95d4633SHajimu UMEMOTO struct ip6_pktopts *opt; 2285f95d4633SHajimu UMEMOTO 2286f95d4633SHajimu UMEMOTO if (*pktopt == NULL) { 2287f95d4633SHajimu UMEMOTO *pktopt = malloc(sizeof(struct ip6_pktopts), M_IP6OPT, 2288f95d4633SHajimu UMEMOTO M_WAITOK); 2289d5e3406dSHajimu UMEMOTO ip6_initpktopts(*pktopt); 2290f95d4633SHajimu UMEMOTO } 2291f95d4633SHajimu UMEMOTO opt = *pktopt; 2292f95d4633SHajimu UMEMOTO 229379ba3952SBjoern A. Zeeb return (ip6_setpktopt(optname, buf, len, opt, cred, 1, 0, uproto)); 2294f95d4633SHajimu UMEMOTO } 2295f95d4633SHajimu UMEMOTO 229606b479a6SSean Bruno #define GET_PKTOPT_VAR(field, lenexpr) do { \ 229706b479a6SSean Bruno if (pktopt && pktopt->field) { \ 229806b479a6SSean Bruno INP_RUNLOCK(in6p); \ 229906b479a6SSean Bruno optdata = malloc(sopt->sopt_valsize, M_TEMP, M_WAITOK); \ 230006b479a6SSean Bruno malloc_optdata = true; \ 230106b479a6SSean Bruno INP_RLOCK(in6p); \ 230206b479a6SSean Bruno if (in6p->inp_flags & (INP_TIMEWAIT | INP_DROPPED)) { \ 230306b479a6SSean Bruno INP_RUNLOCK(in6p); \ 230406b479a6SSean Bruno free(optdata, M_TEMP); \ 230506b479a6SSean Bruno return (ECONNRESET); \ 230606b479a6SSean Bruno } \ 230706b479a6SSean Bruno pktopt = in6p->in6p_outputopts; \ 230806b479a6SSean Bruno if (pktopt && pktopt->field) { \ 230906b479a6SSean Bruno optdatalen = min(lenexpr, sopt->sopt_valsize); \ 231006b479a6SSean Bruno bcopy(&pktopt->field, optdata, optdatalen); \ 231106b479a6SSean Bruno } else { \ 231206b479a6SSean Bruno free(optdata, M_TEMP); \ 231306b479a6SSean Bruno optdata = NULL; \ 231406b479a6SSean Bruno malloc_optdata = false; \ 231506b479a6SSean Bruno } \ 231606b479a6SSean Bruno } \ 231706b479a6SSean Bruno } while(0) 231806b479a6SSean Bruno 231906b479a6SSean Bruno #define GET_PKTOPT_EXT_HDR(field) GET_PKTOPT_VAR(field, \ 232006b479a6SSean Bruno (((struct ip6_ext *)pktopt->field)->ip6e_len + 1) << 3) 232106b479a6SSean Bruno 232206b479a6SSean Bruno #define GET_PKTOPT_SOCKADDR(field) GET_PKTOPT_VAR(field, \ 232306b479a6SSean Bruno pktopt->field->sa_len) 232406b479a6SSean Bruno 2325f95d4633SHajimu UMEMOTO static int 232606b479a6SSean Bruno ip6_getpcbopt(struct inpcb *in6p, int optname, struct sockopt *sopt) 2327f95d4633SHajimu UMEMOTO { 2328f95d4633SHajimu UMEMOTO void *optdata = NULL; 232906b479a6SSean Bruno bool malloc_optdata = false; 2330f95d4633SHajimu UMEMOTO int optdatalen = 0; 2331f95d4633SHajimu UMEMOTO int error = 0; 2332f95d4633SHajimu UMEMOTO struct in6_pktinfo null_pktinfo; 2333f95d4633SHajimu UMEMOTO int deftclass = 0, on; 2334f95d4633SHajimu UMEMOTO int defminmtu = IP6PO_MINMTU_MCASTONLY; 2335f95d4633SHajimu UMEMOTO int defpreftemp = IP6PO_TEMPADDR_SYSTEM; 233606b479a6SSean Bruno struct ip6_pktopts *pktopt; 233706b479a6SSean Bruno 233806b479a6SSean Bruno INP_RLOCK(in6p); 233906b479a6SSean Bruno pktopt = in6p->in6p_outputopts; 2340f95d4633SHajimu UMEMOTO 2341f95d4633SHajimu UMEMOTO switch (optname) { 2342f95d4633SHajimu UMEMOTO case IPV6_PKTINFO: 2343cb207f93SAndrey V. Elsukov optdata = (void *)&null_pktinfo; 2344cb207f93SAndrey V. Elsukov if (pktopt && pktopt->ip6po_pktinfo) { 2345cb207f93SAndrey V. Elsukov bcopy(pktopt->ip6po_pktinfo, &null_pktinfo, 2346cb207f93SAndrey V. Elsukov sizeof(null_pktinfo)); 2347cb207f93SAndrey V. Elsukov in6_clearscope(&null_pktinfo.ipi6_addr); 2348cb207f93SAndrey V. Elsukov } else { 2349f95d4633SHajimu UMEMOTO /* XXX: we don't have to do this every time... */ 2350f95d4633SHajimu UMEMOTO bzero(&null_pktinfo, sizeof(null_pktinfo)); 2351f95d4633SHajimu UMEMOTO } 2352f95d4633SHajimu UMEMOTO optdatalen = sizeof(struct in6_pktinfo); 2353f95d4633SHajimu UMEMOTO break; 2354f95d4633SHajimu UMEMOTO case IPV6_TCLASS: 2355f95d4633SHajimu UMEMOTO if (pktopt && pktopt->ip6po_tclass >= 0) 235606b479a6SSean Bruno deftclass = pktopt->ip6po_tclass; 2357f95d4633SHajimu UMEMOTO optdata = (void *)&deftclass; 2358f95d4633SHajimu UMEMOTO optdatalen = sizeof(int); 2359f95d4633SHajimu UMEMOTO break; 2360f95d4633SHajimu UMEMOTO case IPV6_HOPOPTS: 236106b479a6SSean Bruno GET_PKTOPT_EXT_HDR(ip6po_hbh); 2362f95d4633SHajimu UMEMOTO break; 2363f95d4633SHajimu UMEMOTO case IPV6_RTHDR: 236406b479a6SSean Bruno GET_PKTOPT_EXT_HDR(ip6po_rthdr); 2365f95d4633SHajimu UMEMOTO break; 2366f95d4633SHajimu UMEMOTO case IPV6_RTHDRDSTOPTS: 236706b479a6SSean Bruno GET_PKTOPT_EXT_HDR(ip6po_dest1); 2368f95d4633SHajimu UMEMOTO break; 2369f95d4633SHajimu UMEMOTO case IPV6_DSTOPTS: 237006b479a6SSean Bruno GET_PKTOPT_EXT_HDR(ip6po_dest2); 2371f95d4633SHajimu UMEMOTO break; 2372f95d4633SHajimu UMEMOTO case IPV6_NEXTHOP: 237306b479a6SSean Bruno GET_PKTOPT_SOCKADDR(ip6po_nexthop); 2374f95d4633SHajimu UMEMOTO break; 2375f95d4633SHajimu UMEMOTO case IPV6_USE_MIN_MTU: 2376f95d4633SHajimu UMEMOTO if (pktopt) 237706b479a6SSean Bruno defminmtu = pktopt->ip6po_minmtu; 2378f95d4633SHajimu UMEMOTO optdata = (void *)&defminmtu; 2379f95d4633SHajimu UMEMOTO optdatalen = sizeof(int); 2380f95d4633SHajimu UMEMOTO break; 2381f95d4633SHajimu UMEMOTO case IPV6_DONTFRAG: 2382f95d4633SHajimu UMEMOTO if (pktopt && ((pktopt->ip6po_flags) & IP6PO_DONTFRAG)) 2383f95d4633SHajimu UMEMOTO on = 1; 2384f95d4633SHajimu UMEMOTO else 2385f95d4633SHajimu UMEMOTO on = 0; 2386f95d4633SHajimu UMEMOTO optdata = (void *)&on; 2387f95d4633SHajimu UMEMOTO optdatalen = sizeof(on); 2388f95d4633SHajimu UMEMOTO break; 2389f95d4633SHajimu UMEMOTO case IPV6_PREFER_TEMPADDR: 2390f95d4633SHajimu UMEMOTO if (pktopt) 239106b479a6SSean Bruno defpreftemp = pktopt->ip6po_prefer_tempaddr; 2392f95d4633SHajimu UMEMOTO optdata = (void *)&defpreftemp; 2393f95d4633SHajimu UMEMOTO optdatalen = sizeof(int); 2394f95d4633SHajimu UMEMOTO break; 2395f95d4633SHajimu UMEMOTO default: /* should not happen */ 2396f95d4633SHajimu UMEMOTO #ifdef DIAGNOSTIC 2397f95d4633SHajimu UMEMOTO panic("ip6_getpcbopt: unexpected option\n"); 2398f95d4633SHajimu UMEMOTO #endif 239906b479a6SSean Bruno INP_RUNLOCK(in6p); 2400f95d4633SHajimu UMEMOTO return (ENOPROTOOPT); 2401f95d4633SHajimu UMEMOTO } 240206b479a6SSean Bruno INP_RUNLOCK(in6p); 2403f95d4633SHajimu UMEMOTO 2404f95d4633SHajimu UMEMOTO error = sooptcopyout(sopt, optdata, optdatalen); 240506b479a6SSean Bruno if (malloc_optdata) 240606b479a6SSean Bruno free(optdata, M_TEMP); 2407f95d4633SHajimu UMEMOTO 2408f95d4633SHajimu UMEMOTO return (error); 240933841545SHajimu UMEMOTO } 241033841545SHajimu UMEMOTO 241133841545SHajimu UMEMOTO void 24121272577eSXin LI ip6_clearpktopts(struct ip6_pktopts *pktopt, int optname) 241333841545SHajimu UMEMOTO { 2414289b28bdSHajimu UMEMOTO if (pktopt == NULL) 2415289b28bdSHajimu UMEMOTO return; 2416289b28bdSHajimu UMEMOTO 2417f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_PKTINFO) { 2418885adbfaSHajimu UMEMOTO if (pktopt->ip6po_pktinfo) 241933841545SHajimu UMEMOTO free(pktopt->ip6po_pktinfo, M_IP6OPT); 242033841545SHajimu UMEMOTO pktopt->ip6po_pktinfo = NULL; 242133841545SHajimu UMEMOTO } 2422f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_HOPLIMIT) 242333841545SHajimu UMEMOTO pktopt->ip6po_hlim = -1; 2424f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_TCLASS) 2425f95d4633SHajimu UMEMOTO pktopt->ip6po_tclass = -1; 2426f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_NEXTHOP) { 2427f95d4633SHajimu UMEMOTO if (pktopt->ip6po_nextroute.ro_rt) { 2428f95d4633SHajimu UMEMOTO RTFREE(pktopt->ip6po_nextroute.ro_rt); 2429f95d4633SHajimu UMEMOTO pktopt->ip6po_nextroute.ro_rt = NULL; 2430f95d4633SHajimu UMEMOTO } 2431885adbfaSHajimu UMEMOTO if (pktopt->ip6po_nexthop) 243233841545SHajimu UMEMOTO free(pktopt->ip6po_nexthop, M_IP6OPT); 243333841545SHajimu UMEMOTO pktopt->ip6po_nexthop = NULL; 243433841545SHajimu UMEMOTO } 2435f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_HOPOPTS) { 2436885adbfaSHajimu UMEMOTO if (pktopt->ip6po_hbh) 243733841545SHajimu UMEMOTO free(pktopt->ip6po_hbh, M_IP6OPT); 243833841545SHajimu UMEMOTO pktopt->ip6po_hbh = NULL; 243933841545SHajimu UMEMOTO } 2440f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_RTHDRDSTOPTS) { 2441885adbfaSHajimu UMEMOTO if (pktopt->ip6po_dest1) 244233841545SHajimu UMEMOTO free(pktopt->ip6po_dest1, M_IP6OPT); 244333841545SHajimu UMEMOTO pktopt->ip6po_dest1 = NULL; 244433841545SHajimu UMEMOTO } 2445f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_RTHDR) { 2446885adbfaSHajimu UMEMOTO if (pktopt->ip6po_rhinfo.ip6po_rhi_rthdr) 244733841545SHajimu UMEMOTO free(pktopt->ip6po_rhinfo.ip6po_rhi_rthdr, M_IP6OPT); 244833841545SHajimu UMEMOTO pktopt->ip6po_rhinfo.ip6po_rhi_rthdr = NULL; 244933841545SHajimu UMEMOTO if (pktopt->ip6po_route.ro_rt) { 245033841545SHajimu UMEMOTO RTFREE(pktopt->ip6po_route.ro_rt); 245133841545SHajimu UMEMOTO pktopt->ip6po_route.ro_rt = NULL; 245233841545SHajimu UMEMOTO } 245333841545SHajimu UMEMOTO } 2454f95d4633SHajimu UMEMOTO if (optname == -1 || optname == IPV6_DSTOPTS) { 2455885adbfaSHajimu UMEMOTO if (pktopt->ip6po_dest2) 245633841545SHajimu UMEMOTO free(pktopt->ip6po_dest2, M_IP6OPT); 245733841545SHajimu UMEMOTO pktopt->ip6po_dest2 = NULL; 245833841545SHajimu UMEMOTO } 245933841545SHajimu UMEMOTO } 246033841545SHajimu UMEMOTO 246133841545SHajimu UMEMOTO #define PKTOPT_EXTHDRCPY(type) \ 246233841545SHajimu UMEMOTO do {\ 246333841545SHajimu UMEMOTO if (src->type) {\ 24647efe5d92SHajimu UMEMOTO int hlen = (((struct ip6_ext *)src->type)->ip6e_len + 1) << 3;\ 246533841545SHajimu UMEMOTO dst->type = malloc(hlen, M_IP6OPT, canwait);\ 24668b07e00eSJonathan T. Looney if (dst->type == NULL)\ 246733841545SHajimu UMEMOTO goto bad;\ 246833841545SHajimu UMEMOTO bcopy(src->type, dst->type, hlen);\ 246933841545SHajimu UMEMOTO }\ 24707efe5d92SHajimu UMEMOTO } while (/*CONSTCOND*/ 0) 247133841545SHajimu UMEMOTO 2472885adbfaSHajimu UMEMOTO static int 24731272577eSXin LI copypktopts(struct ip6_pktopts *dst, struct ip6_pktopts *src, int canwait) 247433841545SHajimu UMEMOTO { 2475885adbfaSHajimu UMEMOTO if (dst == NULL || src == NULL) { 247633841545SHajimu UMEMOTO printf("ip6_clearpktopts: invalid argument\n"); 2477885adbfaSHajimu UMEMOTO return (EINVAL); 247833841545SHajimu UMEMOTO } 247933841545SHajimu UMEMOTO 248033841545SHajimu UMEMOTO dst->ip6po_hlim = src->ip6po_hlim; 2481f95d4633SHajimu UMEMOTO dst->ip6po_tclass = src->ip6po_tclass; 2482f95d4633SHajimu UMEMOTO dst->ip6po_flags = src->ip6po_flags; 24836090ab8bSHiroki Sato dst->ip6po_minmtu = src->ip6po_minmtu; 24846090ab8bSHiroki Sato dst->ip6po_prefer_tempaddr = src->ip6po_prefer_tempaddr; 248533841545SHajimu UMEMOTO if (src->ip6po_pktinfo) { 248633841545SHajimu UMEMOTO dst->ip6po_pktinfo = malloc(sizeof(*dst->ip6po_pktinfo), 248733841545SHajimu UMEMOTO M_IP6OPT, canwait); 24882cb64cb2SGeorge V. Neville-Neil if (dst->ip6po_pktinfo == NULL) 248933841545SHajimu UMEMOTO goto bad; 249033841545SHajimu UMEMOTO *dst->ip6po_pktinfo = *src->ip6po_pktinfo; 249133841545SHajimu UMEMOTO } 249233841545SHajimu UMEMOTO if (src->ip6po_nexthop) { 249333841545SHajimu UMEMOTO dst->ip6po_nexthop = malloc(src->ip6po_nexthop->sa_len, 249433841545SHajimu UMEMOTO M_IP6OPT, canwait); 2495403cbcf5SGeorge V. Neville-Neil if (dst->ip6po_nexthop == NULL) 249633841545SHajimu UMEMOTO goto bad; 249733841545SHajimu UMEMOTO bcopy(src->ip6po_nexthop, dst->ip6po_nexthop, 249833841545SHajimu UMEMOTO src->ip6po_nexthop->sa_len); 249933841545SHajimu UMEMOTO } 250033841545SHajimu UMEMOTO PKTOPT_EXTHDRCPY(ip6po_hbh); 250133841545SHajimu UMEMOTO PKTOPT_EXTHDRCPY(ip6po_dest1); 250233841545SHajimu UMEMOTO PKTOPT_EXTHDRCPY(ip6po_dest2); 250333841545SHajimu UMEMOTO PKTOPT_EXTHDRCPY(ip6po_rthdr); /* not copy the cached route */ 2504885adbfaSHajimu UMEMOTO return (0); 250533841545SHajimu UMEMOTO 250633841545SHajimu UMEMOTO bad: 2507016fb9d9SMike Makonnen ip6_clearpktopts(dst, -1); 2508885adbfaSHajimu UMEMOTO return (ENOBUFS); 2509885adbfaSHajimu UMEMOTO } 2510885adbfaSHajimu UMEMOTO #undef PKTOPT_EXTHDRCPY 2511885adbfaSHajimu UMEMOTO 2512885adbfaSHajimu UMEMOTO struct ip6_pktopts * 25131272577eSXin LI ip6_copypktopts(struct ip6_pktopts *src, int canwait) 2514885adbfaSHajimu UMEMOTO { 2515885adbfaSHajimu UMEMOTO int error; 2516885adbfaSHajimu UMEMOTO struct ip6_pktopts *dst; 2517885adbfaSHajimu UMEMOTO 2518885adbfaSHajimu UMEMOTO dst = malloc(sizeof(*dst), M_IP6OPT, canwait); 25192cb64cb2SGeorge V. Neville-Neil if (dst == NULL) 2520885adbfaSHajimu UMEMOTO return (NULL); 2521885adbfaSHajimu UMEMOTO ip6_initpktopts(dst); 2522885adbfaSHajimu UMEMOTO 2523885adbfaSHajimu UMEMOTO if ((error = copypktopts(dst, src, canwait)) != 0) { 252435f6695bSHajimu UMEMOTO free(dst, M_IP6OPT); 252533841545SHajimu UMEMOTO return (NULL); 252633841545SHajimu UMEMOTO } 2527885adbfaSHajimu UMEMOTO 2528885adbfaSHajimu UMEMOTO return (dst); 2529885adbfaSHajimu UMEMOTO } 253033841545SHajimu UMEMOTO 253133841545SHajimu UMEMOTO void 25321272577eSXin LI ip6_freepcbopts(struct ip6_pktopts *pktopt) 253333841545SHajimu UMEMOTO { 253433841545SHajimu UMEMOTO if (pktopt == NULL) 253533841545SHajimu UMEMOTO return; 253633841545SHajimu UMEMOTO 2537f95d4633SHajimu UMEMOTO ip6_clearpktopts(pktopt, -1); 253833841545SHajimu UMEMOTO 253933841545SHajimu UMEMOTO free(pktopt, M_IP6OPT); 254033841545SHajimu UMEMOTO } 254133841545SHajimu UMEMOTO 254233841545SHajimu UMEMOTO /* 254382cd038dSYoshinobu Inoue * Set IPv6 outgoing packet options based on advanced API. 254482cd038dSYoshinobu Inoue */ 254582cd038dSYoshinobu Inoue int 25461272577eSXin LI ip6_setpktopts(struct mbuf *control, struct ip6_pktopts *opt, 254779ba3952SBjoern A. Zeeb struct ip6_pktopts *stickyopt, struct ucred *cred, int uproto) 254882cd038dSYoshinobu Inoue { 2549155d72c4SPedro F. Giffuni struct cmsghdr *cm = NULL; 255082cd038dSYoshinobu Inoue 25518507acb1SHajimu UMEMOTO if (control == NULL || opt == NULL) 255282cd038dSYoshinobu Inoue return (EINVAL); 255382cd038dSYoshinobu Inoue 2554885adbfaSHajimu UMEMOTO ip6_initpktopts(opt); 2555f95d4633SHajimu UMEMOTO if (stickyopt) { 2556885adbfaSHajimu UMEMOTO int error; 2557885adbfaSHajimu UMEMOTO 2558f95d4633SHajimu UMEMOTO /* 2559f95d4633SHajimu UMEMOTO * If stickyopt is provided, make a local copy of the options 2560f95d4633SHajimu UMEMOTO * for this particular packet, then override them by ancillary 2561f95d4633SHajimu UMEMOTO * objects. 2562885adbfaSHajimu UMEMOTO * XXX: copypktopts() does not copy the cached route to a next 2563885adbfaSHajimu UMEMOTO * hop (if any). This is not very good in terms of efficiency, 2564885adbfaSHajimu UMEMOTO * but we can allow this since this option should be rarely 2565885adbfaSHajimu UMEMOTO * used. 2566f95d4633SHajimu UMEMOTO */ 2567885adbfaSHajimu UMEMOTO if ((error = copypktopts(opt, stickyopt, M_NOWAIT)) != 0) 2568885adbfaSHajimu UMEMOTO return (error); 2569f95d4633SHajimu UMEMOTO } 257082cd038dSYoshinobu Inoue 257182cd038dSYoshinobu Inoue /* 257282cd038dSYoshinobu Inoue * XXX: Currently, we assume all the optional information is stored 257382cd038dSYoshinobu Inoue * in a single mbuf. 257482cd038dSYoshinobu Inoue */ 257582cd038dSYoshinobu Inoue if (control->m_next) 257682cd038dSYoshinobu Inoue return (EINVAL); 257782cd038dSYoshinobu Inoue 25786f4da201SBjoern A. Zeeb for (; control->m_len > 0; control->m_data += CMSG_ALIGN(cm->cmsg_len), 257933841545SHajimu UMEMOTO control->m_len -= CMSG_ALIGN(cm->cmsg_len)) { 2580f95d4633SHajimu UMEMOTO int error; 2581f95d4633SHajimu UMEMOTO 2582f95d4633SHajimu UMEMOTO if (control->m_len < CMSG_LEN(0)) 2583f95d4633SHajimu UMEMOTO return (EINVAL); 2584f95d4633SHajimu UMEMOTO 258582cd038dSYoshinobu Inoue cm = mtod(control, struct cmsghdr *); 258682cd038dSYoshinobu Inoue if (cm->cmsg_len == 0 || cm->cmsg_len > control->m_len) 258782cd038dSYoshinobu Inoue return (EINVAL); 258882cd038dSYoshinobu Inoue if (cm->cmsg_level != IPPROTO_IPV6) 258982cd038dSYoshinobu Inoue continue; 259082cd038dSYoshinobu Inoue 2591d5e3406dSHajimu UMEMOTO error = ip6_setpktopt(cm->cmsg_type, CMSG_DATA(cm), 259279ba3952SBjoern A. Zeeb cm->cmsg_len - CMSG_LEN(0), opt, cred, 0, 1, uproto); 2593f95d4633SHajimu UMEMOTO if (error) 2594f95d4633SHajimu UMEMOTO return (error); 2595f95d4633SHajimu UMEMOTO } 259682cd038dSYoshinobu Inoue 2597f95d4633SHajimu UMEMOTO return (0); 2598f95d4633SHajimu UMEMOTO } 2599f95d4633SHajimu UMEMOTO 2600f95d4633SHajimu UMEMOTO /* 2601f95d4633SHajimu UMEMOTO * Set a particular packet option, as a sticky option or an ancillary data 2602f95d4633SHajimu UMEMOTO * item. "len" can be 0 only when it's a sticky option. 2603f95d4633SHajimu UMEMOTO * We have 4 cases of combination of "sticky" and "cmsg": 2604f95d4633SHajimu UMEMOTO * "sticky=0, cmsg=0": impossible 260518b35df8SHajimu UMEMOTO * "sticky=0, cmsg=1": RFC2292 or RFC3542 ancillary data 260618b35df8SHajimu UMEMOTO * "sticky=1, cmsg=0": RFC3542 socket option 2607f95d4633SHajimu UMEMOTO * "sticky=1, cmsg=1": RFC2292 socket option 2608f95d4633SHajimu UMEMOTO */ 2609f95d4633SHajimu UMEMOTO static int 26101272577eSXin LI ip6_setpktopt(int optname, u_char *buf, int len, struct ip6_pktopts *opt, 261179ba3952SBjoern A. Zeeb struct ucred *cred, int sticky, int cmsg, int uproto) 2612f95d4633SHajimu UMEMOTO { 2613f95d4633SHajimu UMEMOTO int minmtupolicy, preftemp; 261479ba3952SBjoern A. Zeeb int error; 2615f95d4633SHajimu UMEMOTO 2616f95d4633SHajimu UMEMOTO if (!sticky && !cmsg) { 2617f95d4633SHajimu UMEMOTO #ifdef DIAGNOSTIC 2618d5e3406dSHajimu UMEMOTO printf("ip6_setpktopt: impossible case\n"); 2619f95d4633SHajimu UMEMOTO #endif 2620f95d4633SHajimu UMEMOTO return (EINVAL); 2621f95d4633SHajimu UMEMOTO } 2622f95d4633SHajimu UMEMOTO 2623f95d4633SHajimu UMEMOTO /* 2624f95d4633SHajimu UMEMOTO * IPV6_2292xxx is for backward compatibility to RFC2292, and should 262518b35df8SHajimu UMEMOTO * not be specified in the context of RFC3542. Conversely, 262618b35df8SHajimu UMEMOTO * RFC3542 types should not be specified in the context of RFC2292. 2627f95d4633SHajimu UMEMOTO */ 2628f95d4633SHajimu UMEMOTO if (!cmsg) { 2629f95d4633SHajimu UMEMOTO switch (optname) { 2630f95d4633SHajimu UMEMOTO case IPV6_2292PKTINFO: 2631f95d4633SHajimu UMEMOTO case IPV6_2292HOPLIMIT: 2632f95d4633SHajimu UMEMOTO case IPV6_2292NEXTHOP: 2633f95d4633SHajimu UMEMOTO case IPV6_2292HOPOPTS: 2634f95d4633SHajimu UMEMOTO case IPV6_2292DSTOPTS: 2635f95d4633SHajimu UMEMOTO case IPV6_2292RTHDR: 2636f95d4633SHajimu UMEMOTO case IPV6_2292PKTOPTIONS: 2637f95d4633SHajimu UMEMOTO return (ENOPROTOOPT); 2638f95d4633SHajimu UMEMOTO } 2639f95d4633SHajimu UMEMOTO } 2640f95d4633SHajimu UMEMOTO if (sticky && cmsg) { 2641f95d4633SHajimu UMEMOTO switch (optname) { 2642f95d4633SHajimu UMEMOTO case IPV6_PKTINFO: 2643f95d4633SHajimu UMEMOTO case IPV6_HOPLIMIT: 2644f95d4633SHajimu UMEMOTO case IPV6_NEXTHOP: 2645f95d4633SHajimu UMEMOTO case IPV6_HOPOPTS: 2646f95d4633SHajimu UMEMOTO case IPV6_DSTOPTS: 2647f95d4633SHajimu UMEMOTO case IPV6_RTHDRDSTOPTS: 2648f95d4633SHajimu UMEMOTO case IPV6_RTHDR: 2649f95d4633SHajimu UMEMOTO case IPV6_USE_MIN_MTU: 2650f95d4633SHajimu UMEMOTO case IPV6_DONTFRAG: 2651f95d4633SHajimu UMEMOTO case IPV6_TCLASS: 265218b35df8SHajimu UMEMOTO case IPV6_PREFER_TEMPADDR: /* XXX: not an RFC3542 option */ 2653f95d4633SHajimu UMEMOTO return (ENOPROTOOPT); 2654f95d4633SHajimu UMEMOTO } 2655f95d4633SHajimu UMEMOTO } 2656f95d4633SHajimu UMEMOTO 2657f95d4633SHajimu UMEMOTO switch (optname) { 2658f95d4633SHajimu UMEMOTO case IPV6_2292PKTINFO: 2659f95d4633SHajimu UMEMOTO case IPV6_PKTINFO: 2660f95d4633SHajimu UMEMOTO { 2661f95d4633SHajimu UMEMOTO struct ifnet *ifp = NULL; 2662f95d4633SHajimu UMEMOTO struct in6_pktinfo *pktinfo; 2663f95d4633SHajimu UMEMOTO 2664f95d4633SHajimu UMEMOTO if (len != sizeof(struct in6_pktinfo)) 2665f95d4633SHajimu UMEMOTO return (EINVAL); 2666f95d4633SHajimu UMEMOTO 2667f95d4633SHajimu UMEMOTO pktinfo = (struct in6_pktinfo *)buf; 2668f95d4633SHajimu UMEMOTO 2669f95d4633SHajimu UMEMOTO /* 2670f95d4633SHajimu UMEMOTO * An application can clear any sticky IPV6_PKTINFO option by 2671f95d4633SHajimu UMEMOTO * doing a "regular" setsockopt with ipi6_addr being 2672f95d4633SHajimu UMEMOTO * in6addr_any and ipi6_ifindex being zero. 2673f95d4633SHajimu UMEMOTO * [RFC 3542, Section 6] 2674f95d4633SHajimu UMEMOTO */ 2675f95d4633SHajimu UMEMOTO if (optname == IPV6_PKTINFO && opt->ip6po_pktinfo && 2676f95d4633SHajimu UMEMOTO pktinfo->ipi6_ifindex == 0 && 2677f95d4633SHajimu UMEMOTO IN6_IS_ADDR_UNSPECIFIED(&pktinfo->ipi6_addr)) { 2678f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, optname); 2679f95d4633SHajimu UMEMOTO break; 2680f95d4633SHajimu UMEMOTO } 2681f95d4633SHajimu UMEMOTO 2682f95d4633SHajimu UMEMOTO if (uproto == IPPROTO_TCP && optname == IPV6_PKTINFO && 2683f95d4633SHajimu UMEMOTO sticky && !IN6_IS_ADDR_UNSPECIFIED(&pktinfo->ipi6_addr)) { 2684f95d4633SHajimu UMEMOTO return (EINVAL); 2685f95d4633SHajimu UMEMOTO } 26869196891fSAndrey V. Elsukov if (IN6_IS_ADDR_MULTICAST(&pktinfo->ipi6_addr)) 26879196891fSAndrey V. Elsukov return (EINVAL); 2688f95d4633SHajimu UMEMOTO /* validate the interface index if specified. */ 26893fa98cf9SGleb Smirnoff if (pktinfo->ipi6_ifindex > V_if_index) 2690f95d4633SHajimu UMEMOTO return (ENXIO); 2691f95d4633SHajimu UMEMOTO if (pktinfo->ipi6_ifindex) { 2692f95d4633SHajimu UMEMOTO ifp = ifnet_byindex(pktinfo->ipi6_ifindex); 2693f95d4633SHajimu UMEMOTO if (ifp == NULL) 269482cd038dSYoshinobu Inoue return (ENXIO); 269582cd038dSYoshinobu Inoue } 2696be393491SDimitry Andric if (ifp != NULL && (ifp->if_afdata[AF_INET6] == NULL || 2697be393491SDimitry Andric (ND_IFINFO(ifp)->flags & ND6_IFF_IFDISABLED) != 0)) 26989196891fSAndrey V. Elsukov return (ENETDOWN); 269982cd038dSYoshinobu Inoue 27009196891fSAndrey V. Elsukov if (ifp != NULL && 27019196891fSAndrey V. Elsukov !IN6_IS_ADDR_UNSPECIFIED(&pktinfo->ipi6_addr)) { 27029196891fSAndrey V. Elsukov struct in6_ifaddr *ia; 27039196891fSAndrey V. Elsukov 2704cb207f93SAndrey V. Elsukov in6_setscope(&pktinfo->ipi6_addr, ifp, NULL); 27059196891fSAndrey V. Elsukov ia = in6ifa_ifpwithaddr(ifp, &pktinfo->ipi6_addr); 27069196891fSAndrey V. Elsukov if (ia == NULL) 27079196891fSAndrey V. Elsukov return (EADDRNOTAVAIL); 27089196891fSAndrey V. Elsukov ifa_free(&ia->ia_ifa); 27099196891fSAndrey V. Elsukov } 271033841545SHajimu UMEMOTO /* 2711f95d4633SHajimu UMEMOTO * We store the address anyway, and let in6_selectsrc() 2712f95d4633SHajimu UMEMOTO * validate the specified address. This is because ipi6_addr 2713f95d4633SHajimu UMEMOTO * may not have enough information about its scope zone, and 2714f95d4633SHajimu UMEMOTO * we may need additional information (such as outgoing 2715f95d4633SHajimu UMEMOTO * interface or the scope zone of a destination address) to 2716f95d4633SHajimu UMEMOTO * disambiguate the scope. 2717f95d4633SHajimu UMEMOTO * XXX: the delay of the validation may confuse the 2718f95d4633SHajimu UMEMOTO * application when it is used as a sticky option. 271933841545SHajimu UMEMOTO */ 2720f95d4633SHajimu UMEMOTO if (opt->ip6po_pktinfo == NULL) { 2721f95d4633SHajimu UMEMOTO opt->ip6po_pktinfo = malloc(sizeof(*pktinfo), 2722885adbfaSHajimu UMEMOTO M_IP6OPT, M_NOWAIT); 2723885adbfaSHajimu UMEMOTO if (opt->ip6po_pktinfo == NULL) 2724885adbfaSHajimu UMEMOTO return (ENOBUFS); 272582cd038dSYoshinobu Inoue } 2726f95d4633SHajimu UMEMOTO bcopy(pktinfo, opt->ip6po_pktinfo, sizeof(*pktinfo)); 272782cd038dSYoshinobu Inoue break; 2728f95d4633SHajimu UMEMOTO } 272982cd038dSYoshinobu Inoue 2730f95d4633SHajimu UMEMOTO case IPV6_2292HOPLIMIT: 273182cd038dSYoshinobu Inoue case IPV6_HOPLIMIT: 2732f95d4633SHajimu UMEMOTO { 2733f95d4633SHajimu UMEMOTO int *hlimp; 2734f95d4633SHajimu UMEMOTO 2735f95d4633SHajimu UMEMOTO /* 2736f95d4633SHajimu UMEMOTO * RFC 3542 deprecated the usage of sticky IPV6_HOPLIMIT 2737f95d4633SHajimu UMEMOTO * to simplify the ordering among hoplimit options. 2738f95d4633SHajimu UMEMOTO */ 2739f95d4633SHajimu UMEMOTO if (optname == IPV6_HOPLIMIT && sticky) 2740f95d4633SHajimu UMEMOTO return (ENOPROTOOPT); 2741f95d4633SHajimu UMEMOTO 2742f95d4633SHajimu UMEMOTO if (len != sizeof(int)) 2743f95d4633SHajimu UMEMOTO return (EINVAL); 2744f95d4633SHajimu UMEMOTO hlimp = (int *)buf; 2745f95d4633SHajimu UMEMOTO if (*hlimp < -1 || *hlimp > 255) 274682cd038dSYoshinobu Inoue return (EINVAL); 274782cd038dSYoshinobu Inoue 2748f95d4633SHajimu UMEMOTO opt->ip6po_hlim = *hlimp; 274982cd038dSYoshinobu Inoue break; 2750f95d4633SHajimu UMEMOTO } 275182cd038dSYoshinobu Inoue 2752f95d4633SHajimu UMEMOTO case IPV6_TCLASS: 2753f95d4633SHajimu UMEMOTO { 2754f95d4633SHajimu UMEMOTO int tclass; 2755f95d4633SHajimu UMEMOTO 2756f95d4633SHajimu UMEMOTO if (len != sizeof(int)) 2757f95d4633SHajimu UMEMOTO return (EINVAL); 2758f95d4633SHajimu UMEMOTO tclass = *(int *)buf; 2759f95d4633SHajimu UMEMOTO if (tclass < -1 || tclass > 255) 2760f95d4633SHajimu UMEMOTO return (EINVAL); 2761f95d4633SHajimu UMEMOTO 2762f95d4633SHajimu UMEMOTO opt->ip6po_tclass = tclass; 2763f95d4633SHajimu UMEMOTO break; 2764f95d4633SHajimu UMEMOTO } 2765f95d4633SHajimu UMEMOTO 2766f95d4633SHajimu UMEMOTO case IPV6_2292NEXTHOP: 276782cd038dSYoshinobu Inoue case IPV6_NEXTHOP: 276879ba3952SBjoern A. Zeeb if (cred != NULL) { 276979ba3952SBjoern A. Zeeb error = priv_check_cred(cred, 277079ba3952SBjoern A. Zeeb PRIV_NETINET_SETHDROPTS, 0); 277179ba3952SBjoern A. Zeeb if (error) 277279ba3952SBjoern A. Zeeb return (error); 277379ba3952SBjoern A. Zeeb } 277433841545SHajimu UMEMOTO 2775f95d4633SHajimu UMEMOTO if (len == 0) { /* just remove the option */ 2776f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, IPV6_NEXTHOP); 2777f95d4633SHajimu UMEMOTO break; 2778f95d4633SHajimu UMEMOTO } 2779f95d4633SHajimu UMEMOTO 278033841545SHajimu UMEMOTO /* check if cmsg_len is large enough for sa_len */ 2781f95d4633SHajimu UMEMOTO if (len < sizeof(struct sockaddr) || len < *buf) 278282cd038dSYoshinobu Inoue return (EINVAL); 278382cd038dSYoshinobu Inoue 2784f95d4633SHajimu UMEMOTO switch (((struct sockaddr *)buf)->sa_family) { 2785f95d4633SHajimu UMEMOTO case AF_INET6: 2786f95d4633SHajimu UMEMOTO { 2787f95d4633SHajimu UMEMOTO struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)buf; 2788f95d4633SHajimu UMEMOTO int error; 2789f95d4633SHajimu UMEMOTO 2790f95d4633SHajimu UMEMOTO if (sa6->sin6_len != sizeof(struct sockaddr_in6)) 2791f95d4633SHajimu UMEMOTO return (EINVAL); 2792f95d4633SHajimu UMEMOTO 2793f95d4633SHajimu UMEMOTO if (IN6_IS_ADDR_UNSPECIFIED(&sa6->sin6_addr) || 2794f95d4633SHajimu UMEMOTO IN6_IS_ADDR_MULTICAST(&sa6->sin6_addr)) { 2795f95d4633SHajimu UMEMOTO return (EINVAL); 2796f95d4633SHajimu UMEMOTO } 2797603724d3SBjoern A. Zeeb if ((error = sa6_embedscope(sa6, V_ip6_use_defzone)) 2798f95d4633SHajimu UMEMOTO != 0) { 2799f95d4633SHajimu UMEMOTO return (error); 2800f95d4633SHajimu UMEMOTO } 2801f95d4633SHajimu UMEMOTO break; 2802f95d4633SHajimu UMEMOTO } 2803f95d4633SHajimu UMEMOTO case AF_LINK: /* should eventually be supported */ 2804f95d4633SHajimu UMEMOTO default: 2805f95d4633SHajimu UMEMOTO return (EAFNOSUPPORT); 2806f95d4633SHajimu UMEMOTO } 2807f95d4633SHajimu UMEMOTO 2808f95d4633SHajimu UMEMOTO /* turn off the previous option, then set the new option. */ 2809f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, IPV6_NEXTHOP); 2810743eee66SSUZUKI Shinsuke opt->ip6po_nexthop = malloc(*buf, M_IP6OPT, M_NOWAIT); 2811743eee66SSUZUKI Shinsuke if (opt->ip6po_nexthop == NULL) 2812743eee66SSUZUKI Shinsuke return (ENOBUFS); 2813f95d4633SHajimu UMEMOTO bcopy(buf, opt->ip6po_nexthop, *buf); 281482cd038dSYoshinobu Inoue break; 281582cd038dSYoshinobu Inoue 2816f95d4633SHajimu UMEMOTO case IPV6_2292HOPOPTS: 281782cd038dSYoshinobu Inoue case IPV6_HOPOPTS: 281833841545SHajimu UMEMOTO { 281933841545SHajimu UMEMOTO struct ip6_hbh *hbh; 282033841545SHajimu UMEMOTO int hbhlen; 282133841545SHajimu UMEMOTO 2822f95d4633SHajimu UMEMOTO /* 2823f95d4633SHajimu UMEMOTO * XXX: We don't allow a non-privileged user to set ANY HbH 2824f95d4633SHajimu UMEMOTO * options, since per-option restriction has too much 2825f95d4633SHajimu UMEMOTO * overhead. 2826f95d4633SHajimu UMEMOTO */ 282779ba3952SBjoern A. Zeeb if (cred != NULL) { 282879ba3952SBjoern A. Zeeb error = priv_check_cred(cred, 282979ba3952SBjoern A. Zeeb PRIV_NETINET_SETHDROPTS, 0); 283079ba3952SBjoern A. Zeeb if (error) 283179ba3952SBjoern A. Zeeb return (error); 283279ba3952SBjoern A. Zeeb } 2833f95d4633SHajimu UMEMOTO 2834f95d4633SHajimu UMEMOTO if (len == 0) { 2835f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, IPV6_HOPOPTS); 2836f95d4633SHajimu UMEMOTO break; /* just remove the option */ 2837f95d4633SHajimu UMEMOTO } 2838f95d4633SHajimu UMEMOTO 2839f95d4633SHajimu UMEMOTO /* message length validation */ 2840f95d4633SHajimu UMEMOTO if (len < sizeof(struct ip6_hbh)) 284182cd038dSYoshinobu Inoue return (EINVAL); 2842f95d4633SHajimu UMEMOTO hbh = (struct ip6_hbh *)buf; 284333841545SHajimu UMEMOTO hbhlen = (hbh->ip6h_len + 1) << 3; 2844f95d4633SHajimu UMEMOTO if (len != hbhlen) 284582cd038dSYoshinobu Inoue return (EINVAL); 284633841545SHajimu UMEMOTO 2847f95d4633SHajimu UMEMOTO /* turn off the previous option, then set the new option. */ 2848f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, IPV6_HOPOPTS); 2849743eee66SSUZUKI Shinsuke opt->ip6po_hbh = malloc(hbhlen, M_IP6OPT, M_NOWAIT); 2850743eee66SSUZUKI Shinsuke if (opt->ip6po_hbh == NULL) 2851743eee66SSUZUKI Shinsuke return (ENOBUFS); 285233841545SHajimu UMEMOTO bcopy(hbh, opt->ip6po_hbh, hbhlen); 2853f95d4633SHajimu UMEMOTO 285482cd038dSYoshinobu Inoue break; 285533841545SHajimu UMEMOTO } 285682cd038dSYoshinobu Inoue 2857f95d4633SHajimu UMEMOTO case IPV6_2292DSTOPTS: 285882cd038dSYoshinobu Inoue case IPV6_DSTOPTS: 2859f95d4633SHajimu UMEMOTO case IPV6_RTHDRDSTOPTS: 286033841545SHajimu UMEMOTO { 2861f95d4633SHajimu UMEMOTO struct ip6_dest *dest, **newdest = NULL; 286233841545SHajimu UMEMOTO int destlen; 286333841545SHajimu UMEMOTO 286479ba3952SBjoern A. Zeeb if (cred != NULL) { /* XXX: see the comment for IPV6_HOPOPTS */ 286579ba3952SBjoern A. Zeeb error = priv_check_cred(cred, 286679ba3952SBjoern A. Zeeb PRIV_NETINET_SETHDROPTS, 0); 286779ba3952SBjoern A. Zeeb if (error) 286879ba3952SBjoern A. Zeeb return (error); 286979ba3952SBjoern A. Zeeb } 2870f95d4633SHajimu UMEMOTO 2871f95d4633SHajimu UMEMOTO if (len == 0) { 2872f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, optname); 2873f95d4633SHajimu UMEMOTO break; /* just remove the option */ 2874f95d4633SHajimu UMEMOTO } 2875f95d4633SHajimu UMEMOTO 2876f95d4633SHajimu UMEMOTO /* message length validation */ 2877f95d4633SHajimu UMEMOTO if (len < sizeof(struct ip6_dest)) 287882cd038dSYoshinobu Inoue return (EINVAL); 2879f95d4633SHajimu UMEMOTO dest = (struct ip6_dest *)buf; 288033841545SHajimu UMEMOTO destlen = (dest->ip6d_len + 1) << 3; 2881f95d4633SHajimu UMEMOTO if (len != destlen) 288233841545SHajimu UMEMOTO return (EINVAL); 288382cd038dSYoshinobu Inoue 288482cd038dSYoshinobu Inoue /* 2885f95d4633SHajimu UMEMOTO * Determine the position that the destination options header 2886f95d4633SHajimu UMEMOTO * should be inserted; before or after the routing header. 2887f95d4633SHajimu UMEMOTO */ 2888f95d4633SHajimu UMEMOTO switch (optname) { 2889f95d4633SHajimu UMEMOTO case IPV6_2292DSTOPTS: 2890f95d4633SHajimu UMEMOTO /* 2891f95d4633SHajimu UMEMOTO * The old advacned API is ambiguous on this point. 2892f95d4633SHajimu UMEMOTO * Our approach is to determine the position based 2893f95d4633SHajimu UMEMOTO * according to the existence of a routing header. 2894f95d4633SHajimu UMEMOTO * Note, however, that this depends on the order of the 2895f95d4633SHajimu UMEMOTO * extension headers in the ancillary data; the 1st 2896f95d4633SHajimu UMEMOTO * part of the destination options header must appear 2897f95d4633SHajimu UMEMOTO * before the routing header in the ancillary data, 2898f95d4633SHajimu UMEMOTO * too. 289918b35df8SHajimu UMEMOTO * RFC3542 solved the ambiguity by introducing 2900f95d4633SHajimu UMEMOTO * separate ancillary data or option types. 290182cd038dSYoshinobu Inoue */ 290233841545SHajimu UMEMOTO if (opt->ip6po_rthdr == NULL) 290333841545SHajimu UMEMOTO newdest = &opt->ip6po_dest1; 290433841545SHajimu UMEMOTO else 290533841545SHajimu UMEMOTO newdest = &opt->ip6po_dest2; 2906f95d4633SHajimu UMEMOTO break; 2907f95d4633SHajimu UMEMOTO case IPV6_RTHDRDSTOPTS: 2908f95d4633SHajimu UMEMOTO newdest = &opt->ip6po_dest1; 2909f95d4633SHajimu UMEMOTO break; 2910f95d4633SHajimu UMEMOTO case IPV6_DSTOPTS: 2911f95d4633SHajimu UMEMOTO newdest = &opt->ip6po_dest2; 2912f95d4633SHajimu UMEMOTO break; 2913f95d4633SHajimu UMEMOTO } 291433841545SHajimu UMEMOTO 2915f95d4633SHajimu UMEMOTO /* turn off the previous option, then set the new option. */ 2916f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, optname); 2917743eee66SSUZUKI Shinsuke *newdest = malloc(destlen, M_IP6OPT, M_NOWAIT); 2918fc4c8258SRobert Watson if (*newdest == NULL) 2919743eee66SSUZUKI Shinsuke return (ENOBUFS); 292033841545SHajimu UMEMOTO bcopy(dest, *newdest, destlen); 292133841545SHajimu UMEMOTO 292282cd038dSYoshinobu Inoue break; 292333841545SHajimu UMEMOTO } 292482cd038dSYoshinobu Inoue 2925f95d4633SHajimu UMEMOTO case IPV6_2292RTHDR: 292682cd038dSYoshinobu Inoue case IPV6_RTHDR: 292733841545SHajimu UMEMOTO { 292833841545SHajimu UMEMOTO struct ip6_rthdr *rth; 292933841545SHajimu UMEMOTO int rthlen; 293033841545SHajimu UMEMOTO 2931f95d4633SHajimu UMEMOTO if (len == 0) { 2932f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, IPV6_RTHDR); 2933f95d4633SHajimu UMEMOTO break; /* just remove the option */ 2934f95d4633SHajimu UMEMOTO } 2935f95d4633SHajimu UMEMOTO 2936f95d4633SHajimu UMEMOTO /* message length validation */ 2937f95d4633SHajimu UMEMOTO if (len < sizeof(struct ip6_rthdr)) 293882cd038dSYoshinobu Inoue return (EINVAL); 2939f95d4633SHajimu UMEMOTO rth = (struct ip6_rthdr *)buf; 294033841545SHajimu UMEMOTO rthlen = (rth->ip6r_len + 1) << 3; 2941f95d4633SHajimu UMEMOTO if (len != rthlen) 294282cd038dSYoshinobu Inoue return (EINVAL); 294333841545SHajimu UMEMOTO 294433841545SHajimu UMEMOTO switch (rth->ip6r_type) { 294582cd038dSYoshinobu Inoue case IPV6_RTHDR_TYPE_0: 2946f95d4633SHajimu UMEMOTO if (rth->ip6r_len == 0) /* must contain one addr */ 294733841545SHajimu UMEMOTO return (EINVAL); 2948f95d4633SHajimu UMEMOTO if (rth->ip6r_len % 2) /* length must be even */ 294933841545SHajimu UMEMOTO return (EINVAL); 295033841545SHajimu UMEMOTO if (rth->ip6r_len / 2 != rth->ip6r_segleft) 295182cd038dSYoshinobu Inoue return (EINVAL); 295282cd038dSYoshinobu Inoue break; 295382cd038dSYoshinobu Inoue default: 295433841545SHajimu UMEMOTO return (EINVAL); /* not supported */ 295582cd038dSYoshinobu Inoue } 295633841545SHajimu UMEMOTO 2957f95d4633SHajimu UMEMOTO /* turn off the previous option */ 2958f95d4633SHajimu UMEMOTO ip6_clearpktopts(opt, IPV6_RTHDR); 2959743eee66SSUZUKI Shinsuke opt->ip6po_rthdr = malloc(rthlen, M_IP6OPT, M_NOWAIT); 2960743eee66SSUZUKI Shinsuke if (opt->ip6po_rthdr == NULL) 2961743eee66SSUZUKI Shinsuke return (ENOBUFS); 296233841545SHajimu UMEMOTO bcopy(rth, opt->ip6po_rthdr, rthlen); 296333841545SHajimu UMEMOTO 296482cd038dSYoshinobu Inoue break; 296533841545SHajimu UMEMOTO } 296682cd038dSYoshinobu Inoue 2967f95d4633SHajimu UMEMOTO case IPV6_USE_MIN_MTU: 2968f95d4633SHajimu UMEMOTO if (len != sizeof(int)) 2969f95d4633SHajimu UMEMOTO return (EINVAL); 2970f95d4633SHajimu UMEMOTO minmtupolicy = *(int *)buf; 2971f95d4633SHajimu UMEMOTO if (minmtupolicy != IP6PO_MINMTU_MCASTONLY && 2972f95d4633SHajimu UMEMOTO minmtupolicy != IP6PO_MINMTU_DISABLE && 2973f95d4633SHajimu UMEMOTO minmtupolicy != IP6PO_MINMTU_ALL) { 2974f95d4633SHajimu UMEMOTO return (EINVAL); 2975f95d4633SHajimu UMEMOTO } 2976f95d4633SHajimu UMEMOTO opt->ip6po_minmtu = minmtupolicy; 2977f95d4633SHajimu UMEMOTO break; 2978f95d4633SHajimu UMEMOTO 2979f95d4633SHajimu UMEMOTO case IPV6_DONTFRAG: 2980f95d4633SHajimu UMEMOTO if (len != sizeof(int)) 2981f95d4633SHajimu UMEMOTO return (EINVAL); 2982f95d4633SHajimu UMEMOTO 2983f95d4633SHajimu UMEMOTO if (uproto == IPPROTO_TCP || *(int *)buf == 0) { 2984f95d4633SHajimu UMEMOTO /* 2985f95d4633SHajimu UMEMOTO * we ignore this option for TCP sockets. 298618b35df8SHajimu UMEMOTO * (RFC3542 leaves this case unspecified.) 2987f95d4633SHajimu UMEMOTO */ 2988f95d4633SHajimu UMEMOTO opt->ip6po_flags &= ~IP6PO_DONTFRAG; 2989f95d4633SHajimu UMEMOTO } else 2990f95d4633SHajimu UMEMOTO opt->ip6po_flags |= IP6PO_DONTFRAG; 2991f95d4633SHajimu UMEMOTO break; 2992f95d4633SHajimu UMEMOTO 2993f95d4633SHajimu UMEMOTO case IPV6_PREFER_TEMPADDR: 2994f95d4633SHajimu UMEMOTO if (len != sizeof(int)) 2995f95d4633SHajimu UMEMOTO return (EINVAL); 2996f95d4633SHajimu UMEMOTO preftemp = *(int *)buf; 2997f95d4633SHajimu UMEMOTO if (preftemp != IP6PO_TEMPADDR_SYSTEM && 2998f95d4633SHajimu UMEMOTO preftemp != IP6PO_TEMPADDR_NOTPREFER && 2999f95d4633SHajimu UMEMOTO preftemp != IP6PO_TEMPADDR_PREFER) { 3000f95d4633SHajimu UMEMOTO return (EINVAL); 3001f95d4633SHajimu UMEMOTO } 3002f95d4633SHajimu UMEMOTO opt->ip6po_prefer_tempaddr = preftemp; 3003f95d4633SHajimu UMEMOTO break; 3004f95d4633SHajimu UMEMOTO 300582cd038dSYoshinobu Inoue default: 300682cd038dSYoshinobu Inoue return (ENOPROTOOPT); 3007f95d4633SHajimu UMEMOTO } /* end of switch */ 300882cd038dSYoshinobu Inoue 300982cd038dSYoshinobu Inoue return (0); 301082cd038dSYoshinobu Inoue } 301182cd038dSYoshinobu Inoue 301282cd038dSYoshinobu Inoue /* 301382cd038dSYoshinobu Inoue * Routine called from ip6_output() to loop back a copy of an IP6 multicast 301482cd038dSYoshinobu Inoue * packet to the input queue of a specified interface. Note that this 301582cd038dSYoshinobu Inoue * calls the output routine of the loopback "driver", but with an interface 301682cd038dSYoshinobu Inoue * pointer that might NOT be &loif -- easier than replicating that code here. 301782cd038dSYoshinobu Inoue */ 301882cd038dSYoshinobu Inoue void 301956a5f52eSGleb Smirnoff ip6_mloopback(struct ifnet *ifp, struct mbuf *m) 302082cd038dSYoshinobu Inoue { 302182cd038dSYoshinobu Inoue struct mbuf *copym; 3022686cdd19SJun-ichiro itojun Hagino struct ip6_hdr *ip6; 302382cd038dSYoshinobu Inoue 3024c3bef61eSKevin Lo copym = m_copym(m, 0, M_COPYALL, M_NOWAIT); 3025686cdd19SJun-ichiro itojun Hagino if (copym == NULL) 3026686cdd19SJun-ichiro itojun Hagino return; 3027686cdd19SJun-ichiro itojun Hagino 3028686cdd19SJun-ichiro itojun Hagino /* 3029686cdd19SJun-ichiro itojun Hagino * Make sure to deep-copy IPv6 header portion in case the data 3030686cdd19SJun-ichiro itojun Hagino * is in an mbuf cluster, so that we can safely override the IPv6 3031686cdd19SJun-ichiro itojun Hagino * header portion later. 3032686cdd19SJun-ichiro itojun Hagino */ 3033f0cace5dSRobert Watson if (!M_WRITABLE(copym) || 3034686cdd19SJun-ichiro itojun Hagino copym->m_len < sizeof(struct ip6_hdr)) { 3035686cdd19SJun-ichiro itojun Hagino copym = m_pullup(copym, sizeof(struct ip6_hdr)); 3036686cdd19SJun-ichiro itojun Hagino if (copym == NULL) 3037686cdd19SJun-ichiro itojun Hagino return; 303882cd038dSYoshinobu Inoue } 3039686cdd19SJun-ichiro itojun Hagino ip6 = mtod(copym, struct ip6_hdr *); 304033841545SHajimu UMEMOTO /* 304133841545SHajimu UMEMOTO * clear embedded scope identifiers if necessary. 304233841545SHajimu UMEMOTO * in6_clearscope will touch the addresses only when necessary. 304333841545SHajimu UMEMOTO */ 304433841545SHajimu UMEMOTO in6_clearscope(&ip6->ip6_src); 304533841545SHajimu UMEMOTO in6_clearscope(&ip6->ip6_dst); 3046654bdb5aSAndrey V. Elsukov if (copym->m_pkthdr.csum_flags & CSUM_DELAY_DATA_IPV6) { 3047654bdb5aSAndrey V. Elsukov copym->m_pkthdr.csum_flags |= CSUM_DATA_VALID_IPV6 | 3048654bdb5aSAndrey V. Elsukov CSUM_PSEUDO_HDR; 3049654bdb5aSAndrey V. Elsukov copym->m_pkthdr.csum_data = 0xffff; 3050654bdb5aSAndrey V. Elsukov } 3051331dff07SAlexander V. Chernikov if_simloop(ifp, copym, AF_INET6, 0); 305282cd038dSYoshinobu Inoue } 305382cd038dSYoshinobu Inoue 305482cd038dSYoshinobu Inoue /* 305582cd038dSYoshinobu Inoue * Chop IPv6 header off from the payload. 305682cd038dSYoshinobu Inoue */ 305782cd038dSYoshinobu Inoue static int 30581272577eSXin LI ip6_splithdr(struct mbuf *m, struct ip6_exthdrs *exthdrs) 305982cd038dSYoshinobu Inoue { 306082cd038dSYoshinobu Inoue struct mbuf *mh; 306182cd038dSYoshinobu Inoue struct ip6_hdr *ip6; 306282cd038dSYoshinobu Inoue 306382cd038dSYoshinobu Inoue ip6 = mtod(m, struct ip6_hdr *); 306482cd038dSYoshinobu Inoue if (m->m_len > sizeof(*ip6)) { 30657b07d1beSGleb Smirnoff mh = m_gethdr(M_NOWAIT, MT_DATA); 30667b07d1beSGleb Smirnoff if (mh == NULL) { 306782cd038dSYoshinobu Inoue m_freem(m); 306882cd038dSYoshinobu Inoue return ENOBUFS; 306982cd038dSYoshinobu Inoue } 307010e5acc3SGleb Smirnoff m_move_pkthdr(mh, m); 3071ed6a66caSRobert Watson M_ALIGN(mh, sizeof(*ip6)); 307282cd038dSYoshinobu Inoue m->m_len -= sizeof(*ip6); 307382cd038dSYoshinobu Inoue m->m_data += sizeof(*ip6); 307482cd038dSYoshinobu Inoue mh->m_next = m; 307582cd038dSYoshinobu Inoue m = mh; 307682cd038dSYoshinobu Inoue m->m_len = sizeof(*ip6); 307782cd038dSYoshinobu Inoue bcopy((caddr_t)ip6, mtod(m, caddr_t), sizeof(*ip6)); 307882cd038dSYoshinobu Inoue } 307982cd038dSYoshinobu Inoue exthdrs->ip6e_ip6 = m; 308082cd038dSYoshinobu Inoue return 0; 308182cd038dSYoshinobu Inoue } 308282cd038dSYoshinobu Inoue 308382cd038dSYoshinobu Inoue /* 308482cd038dSYoshinobu Inoue * Compute IPv6 extension header length. 308582cd038dSYoshinobu Inoue */ 308682cd038dSYoshinobu Inoue int 3087fc384fa5SBjoern A. Zeeb ip6_optlen(struct inpcb *in6p) 308882cd038dSYoshinobu Inoue { 308982cd038dSYoshinobu Inoue int len; 309082cd038dSYoshinobu Inoue 309182cd038dSYoshinobu Inoue if (!in6p->in6p_outputopts) 309282cd038dSYoshinobu Inoue return 0; 309382cd038dSYoshinobu Inoue 309482cd038dSYoshinobu Inoue len = 0; 309582cd038dSYoshinobu Inoue #define elen(x) \ 309682cd038dSYoshinobu Inoue (((struct ip6_ext *)(x)) ? (((struct ip6_ext *)(x))->ip6e_len + 1) << 3 : 0) 309782cd038dSYoshinobu Inoue 309882cd038dSYoshinobu Inoue len += elen(in6p->in6p_outputopts->ip6po_hbh); 309933841545SHajimu UMEMOTO if (in6p->in6p_outputopts->ip6po_rthdr) 310033841545SHajimu UMEMOTO /* dest1 is valid with rthdr only */ 310182cd038dSYoshinobu Inoue len += elen(in6p->in6p_outputopts->ip6po_dest1); 310282cd038dSYoshinobu Inoue len += elen(in6p->in6p_outputopts->ip6po_rthdr); 310382cd038dSYoshinobu Inoue len += elen(in6p->in6p_outputopts->ip6po_dest2); 310482cd038dSYoshinobu Inoue return len; 310582cd038dSYoshinobu Inoue #undef elen 310682cd038dSYoshinobu Inoue } 3107