2000-07-04 16:35:15 +00:00
|
|
|
/* $FreeBSD$ */
|
2002-04-19 04:46:24 +00:00
|
|
|
/* $KAME: ip6_output.c,v 1.279 2002/01/26 06:12:30 jinmei Exp $ */
|
2000-07-04 16:35:15 +00:00
|
|
|
|
2005-01-07 02:30:35 +00:00
|
|
|
/*-
|
1999-11-22 02:45:11 +00:00
|
|
|
* Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. Neither the name of the project nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
2005-01-07 02:30:35 +00:00
|
|
|
/*-
|
1999-11-22 02:45:11 +00:00
|
|
|
* Copyright (c) 1982, 1986, 1988, 1990, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* @(#)ip_output.c 8.3 (Berkeley) 1/21/94
|
|
|
|
*/
|
|
|
|
|
2000-01-29 13:54:44 +00:00
|
|
|
#include "opt_ip6fw.h"
|
2000-07-04 16:35:15 +00:00
|
|
|
#include "opt_inet.h"
|
|
|
|
#include "opt_inet6.h"
|
|
|
|
#include "opt_ipsec.h"
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/mbuf.h>
|
2001-09-12 08:38:13 +00:00
|
|
|
#include <sys/proc.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
#include <sys/errno.h>
|
|
|
|
#include <sys/protosw.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/socketvar.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
|
|
|
|
#include <net/if.h>
|
2005-04-18 18:35:05 +00:00
|
|
|
#include <net/netisr.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
#include <net/route.h>
|
2000-07-31 13:11:42 +00:00
|
|
|
#include <net/pfil.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <netinet/in_var.h>
|
2001-06-11 12:39:29 +00:00
|
|
|
#include <netinet6/in6_var.h>
|
2000-07-04 16:35:15 +00:00
|
|
|
#include <netinet/ip6.h>
|
|
|
|
#include <netinet/icmp6.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
#include <netinet6/ip6_var.h>
|
2000-07-04 16:35:15 +00:00
|
|
|
#include <netinet/in_pcb.h>
|
2003-11-20 20:07:39 +00:00
|
|
|
#include <netinet/tcp_var.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
#include <netinet6/nd6.h>
|
|
|
|
|
|
|
|
#ifdef IPSEC
|
|
|
|
#include <netinet6/ipsec.h>
|
2000-07-04 16:35:15 +00:00
|
|
|
#ifdef INET6
|
1999-11-22 02:45:11 +00:00
|
|
|
#include <netinet6/ipsec6.h>
|
1999-12-22 19:13:38 +00:00
|
|
|
#endif
|
2000-07-04 16:35:15 +00:00
|
|
|
#include <netkey/key.h>
|
1999-11-22 02:45:11 +00:00
|
|
|
#endif /* IPSEC */
|
|
|
|
|
2002-10-16 02:25:05 +00:00
|
|
|
#ifdef FAST_IPSEC
|
|
|
|
#include <netipsec/ipsec.h>
|
|
|
|
#include <netipsec/ipsec6.h>
|
|
|
|
#include <netipsec/key.h>
|
|
|
|
#endif /* FAST_IPSEC */
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
#include <netinet6/ip6_fw.h>
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
#include <net/net_osdep.h>
|
|
|
|
|
2000-08-12 18:14:13 +00:00
|
|
|
#include <netinet6/ip6protosw.h>
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
static MALLOC_DEFINE(M_IPMOPTS, "ip6_moptions", "internet multicast options");
|
|
|
|
|
|
|
|
struct ip6_exthdrs {
|
2000-07-04 16:35:15 +00:00
|
|
|
struct mbuf *ip6e_ip6;
|
|
|
|
struct mbuf *ip6e_hbh;
|
|
|
|
struct mbuf *ip6e_dest1;
|
|
|
|
struct mbuf *ip6e_rthdr;
|
|
|
|
struct mbuf *ip6e_dest2;
|
1999-11-22 02:45:11 +00:00
|
|
|
};
|
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
static int ip6_pcbopt __P((int, u_char *, int, struct ip6_pktopts **,
|
|
|
|
int, int));
|
2000-07-04 16:35:15 +00:00
|
|
|
static int ip6_pcbopts __P((struct ip6_pktopts **, struct mbuf *,
|
2003-10-08 18:26:08 +00:00
|
|
|
struct socket *, struct sockopt *));
|
2003-10-24 18:26:30 +00:00
|
|
|
static int ip6_getpcbopt __P((struct ip6_pktopts *, int, struct sockopt *));
|
|
|
|
static int ip6_setpktoption __P((int, u_char *, int, struct ip6_pktopts *, int,
|
|
|
|
int, int, int));
|
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
static int ip6_setmoptions __P((int, struct ip6_moptions **, struct mbuf *));
|
|
|
|
static int ip6_getmoptions __P((int, struct ip6_moptions *, struct mbuf **));
|
|
|
|
static int ip6_copyexthdr __P((struct mbuf **, caddr_t, int));
|
|
|
|
static int ip6_insertfraghdr __P((struct mbuf *, struct mbuf *, int,
|
2003-10-08 18:26:08 +00:00
|
|
|
struct ip6_frag **));
|
2000-07-04 16:35:15 +00:00
|
|
|
static int ip6_insert_jumboopt __P((struct ip6_exthdrs *, u_int32_t));
|
|
|
|
static int ip6_splithdr __P((struct mbuf *, struct ip6_exthdrs *));
|
2003-10-20 15:27:48 +00:00
|
|
|
static int ip6_getpmtu __P((struct route_in6 *, struct route_in6 *,
|
2003-10-24 18:26:30 +00:00
|
|
|
struct ifnet *, struct in6_addr *, u_long *, int *));
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-08 18:26:08 +00:00
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
|
|
|
* IP6 output. The packet in mbuf chain m contains a skeletal IP6
|
|
|
|
* header (with pri, len, nxt, hlim, src, dst).
|
|
|
|
* This function may modify ver and hlim only.
|
|
|
|
* The mbuf chain containing the packet will be freed.
|
|
|
|
* The mbuf opt, if present, will not be freed.
|
2001-06-11 12:39:29 +00:00
|
|
|
*
|
|
|
|
* type of "mtu": rt_rmx.rmx_mtu is u_long, ifnet.ifr_mtu is int, and
|
|
|
|
* nd_ifinfo.linkmtu is u_int32_t. so we use u_long to hold largest one,
|
|
|
|
* which is rt_rmx.rmx_mtu.
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
|
|
|
int
|
2002-10-16 01:54:46 +00:00
|
|
|
ip6_output(m0, opt, ro, flags, im6o, ifpp, inp)
|
1999-11-22 02:45:11 +00:00
|
|
|
struct mbuf *m0;
|
|
|
|
struct ip6_pktopts *opt;
|
|
|
|
struct route_in6 *ro;
|
|
|
|
int flags;
|
|
|
|
struct ip6_moptions *im6o;
|
|
|
|
struct ifnet **ifpp; /* XXX: just for statistics */
|
2002-10-16 01:54:46 +00:00
|
|
|
struct inpcb *inp;
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
|
|
|
struct ip6_hdr *ip6, *mhip6;
|
2000-07-04 16:35:15 +00:00
|
|
|
struct ifnet *ifp, *origifp;
|
1999-11-22 02:45:11 +00:00
|
|
|
struct mbuf *m = m0;
|
|
|
|
int hlen, tlen, len, off;
|
|
|
|
struct route_in6 ip6route;
|
|
|
|
struct sockaddr_in6 *dst;
|
2005-04-18 18:35:05 +00:00
|
|
|
struct in6_addr odst;
|
1999-11-22 02:45:11 +00:00
|
|
|
int error = 0;
|
2000-10-19 23:15:54 +00:00
|
|
|
struct in6_ifaddr *ia = NULL;
|
1999-11-22 02:45:11 +00:00
|
|
|
u_long mtu;
|
2003-10-24 18:26:30 +00:00
|
|
|
int alwaysfrag, dontfrag;
|
1999-11-22 02:45:11 +00:00
|
|
|
u_int32_t optlen = 0, plen = 0, unfragpartlen = 0;
|
|
|
|
struct ip6_exthdrs exthdrs;
|
|
|
|
struct in6_addr finaldst;
|
|
|
|
struct route_in6 *ro_pmtu = NULL;
|
|
|
|
int hdrsplit = 0;
|
|
|
|
int needipsec = 0;
|
2004-02-17 14:02:37 +00:00
|
|
|
#if defined(IPSEC) || defined(FAST_IPSEC)
|
1999-11-22 02:45:11 +00:00
|
|
|
int needipsectun = 0;
|
|
|
|
struct secpolicy *sp = NULL;
|
2004-02-17 14:02:37 +00:00
|
|
|
#endif /*IPSEC || FAST_IPSEC*/
|
2002-10-16 02:25:05 +00:00
|
|
|
|
|
|
|
ip6 = mtod(m, struct ip6_hdr *);
|
2003-12-17 04:31:07 +00:00
|
|
|
finaldst = ip6->ip6_dst;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
#define MAKE_EXTHDR(hp, mp) \
|
|
|
|
do { \
|
1999-11-22 02:45:11 +00:00
|
|
|
if (hp) { \
|
|
|
|
struct ip6_ext *eh = (struct ip6_ext *)(hp); \
|
2003-10-08 18:26:08 +00:00
|
|
|
error = ip6_copyexthdr((mp), (caddr_t)(hp), \
|
|
|
|
((eh)->ip6e_len + 1) << 3); \
|
1999-11-22 02:45:11 +00:00
|
|
|
if (error) \
|
|
|
|
goto freehdrs; \
|
|
|
|
} \
|
2003-10-08 18:26:08 +00:00
|
|
|
} while (/*CONSTCOND*/ 0)
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
bzero(&exthdrs, sizeof(exthdrs));
|
2003-10-08 18:26:08 +00:00
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
if (opt) {
|
|
|
|
/* Hop-by-Hop options header */
|
|
|
|
MAKE_EXTHDR(opt->ip6po_hbh, &exthdrs.ip6e_hbh);
|
|
|
|
/* Destination options header(1st part) */
|
2003-10-31 16:32:12 +00:00
|
|
|
if (opt->ip6po_rthdr) {
|
|
|
|
/*
|
|
|
|
* Destination options header(1st part)
|
|
|
|
* This only makes sence with a routing header.
|
|
|
|
* See Section 9.2 of RFC 3542.
|
|
|
|
* Disabling this part just for MIP6 convenience is
|
|
|
|
* a bad idea. We need to think carefully about a
|
|
|
|
* way to make the advanced API coexist with MIP6
|
|
|
|
* options, which might automatically be inserted in
|
|
|
|
* the kernel.
|
|
|
|
*/
|
|
|
|
MAKE_EXTHDR(opt->ip6po_dest1, &exthdrs.ip6e_dest1);
|
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
/* Routing header */
|
|
|
|
MAKE_EXTHDR(opt->ip6po_rthdr, &exthdrs.ip6e_rthdr);
|
|
|
|
/* Destination options header(2nd part) */
|
|
|
|
MAKE_EXTHDR(opt->ip6po_dest2, &exthdrs.ip6e_dest2);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef IPSEC
|
|
|
|
/* get a security policy for this packet */
|
2004-02-03 18:20:55 +00:00
|
|
|
if (inp == NULL)
|
1999-11-22 02:45:11 +00:00
|
|
|
sp = ipsec6_getpolicybyaddr(m, IPSEC_DIR_OUTBOUND, 0, &error);
|
|
|
|
else
|
2004-02-03 18:20:55 +00:00
|
|
|
sp = ipsec6_getpolicybypcb(m, IPSEC_DIR_OUTBOUND, inp, &error);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
if (sp == NULL) {
|
|
|
|
ipsec6stat.out_inval++;
|
2000-07-04 16:35:15 +00:00
|
|
|
goto freehdrs;
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
/* check policy */
|
|
|
|
switch (sp->policy) {
|
|
|
|
case IPSEC_POLICY_DISCARD:
|
|
|
|
/*
|
|
|
|
* This packet is just discarded.
|
|
|
|
*/
|
|
|
|
ipsec6stat.out_polvio++;
|
2000-07-04 16:35:15 +00:00
|
|
|
goto freehdrs;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
case IPSEC_POLICY_BYPASS:
|
|
|
|
case IPSEC_POLICY_NONE:
|
|
|
|
/* no need to do IPsec. */
|
|
|
|
needipsec = 0;
|
|
|
|
break;
|
2003-10-08 18:26:08 +00:00
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
case IPSEC_POLICY_IPSEC:
|
|
|
|
if (sp->req == NULL) {
|
2000-07-04 16:35:15 +00:00
|
|
|
/* acquire a policy */
|
|
|
|
error = key_spdacquire(sp);
|
|
|
|
goto freehdrs;
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
needipsec = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPSEC_POLICY_ENTRUST:
|
|
|
|
default:
|
|
|
|
printf("ip6_output: Invalid policy found. %d\n", sp->policy);
|
|
|
|
}
|
|
|
|
#endif /* IPSEC */
|
2002-10-16 02:25:05 +00:00
|
|
|
#ifdef FAST_IPSEC
|
|
|
|
/* get a security policy for this packet */
|
|
|
|
if (inp == NULL)
|
|
|
|
sp = ipsec_getpolicybyaddr(m, IPSEC_DIR_OUTBOUND, 0, &error);
|
|
|
|
else
|
|
|
|
sp = ipsec_getpolicybysock(m, IPSEC_DIR_OUTBOUND, inp, &error);
|
|
|
|
|
|
|
|
if (sp == NULL) {
|
|
|
|
newipsecstat.ips_out_inval++;
|
|
|
|
goto freehdrs;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
/* check policy */
|
|
|
|
switch (sp->policy) {
|
|
|
|
case IPSEC_POLICY_DISCARD:
|
|
|
|
/*
|
|
|
|
* This packet is just discarded.
|
|
|
|
*/
|
|
|
|
newipsecstat.ips_out_polvio++;
|
|
|
|
goto freehdrs;
|
|
|
|
|
|
|
|
case IPSEC_POLICY_BYPASS:
|
|
|
|
case IPSEC_POLICY_NONE:
|
|
|
|
/* no need to do IPsec. */
|
|
|
|
needipsec = 0;
|
|
|
|
break;
|
2003-10-08 18:26:08 +00:00
|
|
|
|
2002-10-16 02:25:05 +00:00
|
|
|
case IPSEC_POLICY_IPSEC:
|
|
|
|
if (sp->req == NULL) {
|
|
|
|
/* acquire a policy */
|
|
|
|
error = key_spdacquire(sp);
|
|
|
|
goto freehdrs;
|
|
|
|
}
|
|
|
|
needipsec = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPSEC_POLICY_ENTRUST:
|
|
|
|
default:
|
|
|
|
printf("ip6_output: Invalid policy found. %d\n", sp->policy);
|
|
|
|
}
|
|
|
|
#endif /* FAST_IPSEC */
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate the total length of the extension header chain.
|
|
|
|
* Keep the length of the unfragmentable part for fragmentation.
|
|
|
|
*/
|
|
|
|
optlen = 0;
|
|
|
|
if (exthdrs.ip6e_hbh) optlen += exthdrs.ip6e_hbh->m_len;
|
|
|
|
if (exthdrs.ip6e_dest1) optlen += exthdrs.ip6e_dest1->m_len;
|
|
|
|
if (exthdrs.ip6e_rthdr) optlen += exthdrs.ip6e_rthdr->m_len;
|
|
|
|
unfragpartlen = optlen + sizeof(struct ip6_hdr);
|
|
|
|
/* NOTE: we don't add AH/ESP length here. do that later. */
|
|
|
|
if (exthdrs.ip6e_dest2) optlen += exthdrs.ip6e_dest2->m_len;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we need IPsec, or there is at least one extension header,
|
|
|
|
* separate IP6 header from the payload.
|
|
|
|
*/
|
|
|
|
if ((needipsec || optlen) && !hdrsplit) {
|
|
|
|
if ((error = ip6_splithdr(m, &exthdrs)) != 0) {
|
|
|
|
m = NULL;
|
|
|
|
goto freehdrs;
|
|
|
|
}
|
|
|
|
m = exthdrs.ip6e_ip6;
|
|
|
|
hdrsplit++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* adjust pointer */
|
|
|
|
ip6 = mtod(m, struct ip6_hdr *);
|
|
|
|
|
|
|
|
/* adjust mbuf packet header length */
|
|
|
|
m->m_pkthdr.len += optlen;
|
|
|
|
plen = m->m_pkthdr.len - sizeof(*ip6);
|
|
|
|
|
|
|
|
/* If this is a jumbo payload, insert a jumbo payload option. */
|
|
|
|
if (plen > IPV6_MAXPACKET) {
|
|
|
|
if (!hdrsplit) {
|
|
|
|
if ((error = ip6_splithdr(m, &exthdrs)) != 0) {
|
|
|
|
m = NULL;
|
|
|
|
goto freehdrs;
|
|
|
|
}
|
|
|
|
m = exthdrs.ip6e_ip6;
|
|
|
|
hdrsplit++;
|
|
|
|
}
|
|
|
|
/* adjust pointer */
|
|
|
|
ip6 = mtod(m, struct ip6_hdr *);
|
|
|
|
if ((error = ip6_insert_jumboopt(&exthdrs, plen)) != 0)
|
|
|
|
goto freehdrs;
|
|
|
|
ip6->ip6_plen = 0;
|
|
|
|
} else
|
|
|
|
ip6->ip6_plen = htons(plen);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Concatenate headers and fill in next header fields.
|
|
|
|
* Here we have, on "m"
|
|
|
|
* IPv6 payload
|
|
|
|
* and we insert headers accordingly. Finally, we should be getting:
|
|
|
|
* IPv6 hbh dest1 rthdr ah* [esp* dest2 payload]
|
|
|
|
*
|
|
|
|
* during the header composing process, "m" points to IPv6 header.
|
|
|
|
* "mprev" points to an extension header prior to esp.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
u_char *nexthdrp = &ip6->ip6_nxt;
|
|
|
|
struct mbuf *mprev = m;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* we treat dest2 specially. this makes IPsec processing
|
2002-04-19 04:46:24 +00:00
|
|
|
* much easier. the goal here is to make mprev point the
|
|
|
|
* mbuf prior to dest2.
|
1999-11-22 02:45:11 +00:00
|
|
|
*
|
|
|
|
* result: IPv6 dest2 payload
|
|
|
|
* m and mprev will point to IPv6 header.
|
|
|
|
*/
|
|
|
|
if (exthdrs.ip6e_dest2) {
|
|
|
|
if (!hdrsplit)
|
|
|
|
panic("assumption failed: hdr not split");
|
|
|
|
exthdrs.ip6e_dest2->m_next = m->m_next;
|
|
|
|
m->m_next = exthdrs.ip6e_dest2;
|
|
|
|
*mtod(exthdrs.ip6e_dest2, u_char *) = ip6->ip6_nxt;
|
|
|
|
ip6->ip6_nxt = IPPROTO_DSTOPTS;
|
|
|
|
}
|
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
#define MAKE_CHAIN(m, mp, p, i)\
|
|
|
|
do {\
|
1999-11-22 02:45:11 +00:00
|
|
|
if (m) {\
|
|
|
|
if (!hdrsplit) \
|
|
|
|
panic("assumption failed: hdr not split"); \
|
|
|
|
*mtod((m), u_char *) = *(p);\
|
|
|
|
*(p) = (i);\
|
|
|
|
p = mtod((m), u_char *);\
|
|
|
|
(m)->m_next = (mp)->m_next;\
|
|
|
|
(mp)->m_next = (m);\
|
|
|
|
(mp) = (m);\
|
|
|
|
}\
|
2003-10-08 18:26:08 +00:00
|
|
|
} while (/*CONSTCOND*/ 0)
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
|
|
|
* result: IPv6 hbh dest1 rthdr dest2 payload
|
|
|
|
* m will point to IPv6 header. mprev will point to the
|
|
|
|
* extension header prior to dest2 (rthdr in the above case).
|
|
|
|
*/
|
2003-10-08 18:26:08 +00:00
|
|
|
MAKE_CHAIN(exthdrs.ip6e_hbh, mprev, nexthdrp, IPPROTO_HOPOPTS);
|
|
|
|
MAKE_CHAIN(exthdrs.ip6e_dest1, mprev, nexthdrp,
|
|
|
|
IPPROTO_DSTOPTS);
|
|
|
|
MAKE_CHAIN(exthdrs.ip6e_rthdr, mprev, nexthdrp,
|
|
|
|
IPPROTO_ROUTING);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2002-10-16 02:25:05 +00:00
|
|
|
#if defined(IPSEC) || defined(FAST_IPSEC)
|
1999-11-22 02:45:11 +00:00
|
|
|
if (!needipsec)
|
|
|
|
goto skip_ipsec2;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pointers after IPsec headers are not valid any more.
|
|
|
|
* other pointers need a great care too.
|
|
|
|
* (IPsec routines should not mangle mbufs prior to AH/ESP)
|
|
|
|
*/
|
|
|
|
exthdrs.ip6e_dest2 = NULL;
|
|
|
|
|
|
|
|
{
|
|
|
|
struct ip6_rthdr *rh = NULL;
|
|
|
|
int segleft_org = 0;
|
|
|
|
struct ipsec_output_state state;
|
|
|
|
|
|
|
|
if (exthdrs.ip6e_rthdr) {
|
|
|
|
rh = mtod(exthdrs.ip6e_rthdr, struct ip6_rthdr *);
|
|
|
|
segleft_org = rh->ip6r_segleft;
|
|
|
|
rh->ip6r_segleft = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
bzero(&state, sizeof(state));
|
|
|
|
state.m = m;
|
|
|
|
error = ipsec6_output_trans(&state, nexthdrp, mprev, sp, flags,
|
2003-10-08 18:26:08 +00:00
|
|
|
&needipsectun);
|
1999-11-22 02:45:11 +00:00
|
|
|
m = state.m;
|
|
|
|
if (error) {
|
|
|
|
/* mbuf is already reclaimed in ipsec6_output_trans. */
|
|
|
|
m = NULL;
|
|
|
|
switch (error) {
|
|
|
|
case EHOSTUNREACH:
|
|
|
|
case ENETUNREACH:
|
|
|
|
case EMSGSIZE:
|
|
|
|
case ENOBUFS:
|
|
|
|
case ENOMEM:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf("ip6_output (ipsec): error code %d\n", error);
|
2003-10-08 18:26:08 +00:00
|
|
|
/* FALLTHROUGH */
|
1999-11-22 02:45:11 +00:00
|
|
|
case ENOENT:
|
|
|
|
/* don't show these error codes to the user */
|
|
|
|
error = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
if (exthdrs.ip6e_rthdr) {
|
|
|
|
/* ah6_output doesn't modify mbuf chain */
|
|
|
|
rh->ip6r_segleft = segleft_org;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
skip_ipsec2:;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2003-10-08 18:26:08 +00:00
|
|
|
* If there is a routing header, replace the destination address field
|
1999-11-22 02:45:11 +00:00
|
|
|
* with the first hop of the routing header.
|
|
|
|
*/
|
|
|
|
if (exthdrs.ip6e_rthdr) {
|
|
|
|
struct ip6_rthdr *rh =
|
|
|
|
(struct ip6_rthdr *)(mtod(exthdrs.ip6e_rthdr,
|
|
|
|
struct ip6_rthdr *));
|
|
|
|
struct ip6_rthdr0 *rh0;
|
2003-10-24 20:37:05 +00:00
|
|
|
struct in6_addr *addrs;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
switch (rh->ip6r_type) {
|
1999-11-22 02:45:11 +00:00
|
|
|
case IPV6_RTHDR_TYPE_0:
|
|
|
|
rh0 = (struct ip6_rthdr0 *)rh;
|
2003-12-22 03:12:13 +00:00
|
|
|
addrs = (struct in6_addr *)(rh0 + 1);
|
2003-10-24 20:37:05 +00:00
|
|
|
|
|
|
|
ip6->ip6_dst = *addrs;
|
|
|
|
bcopy((caddr_t)(addrs + 1), (caddr_t)addrs,
|
2001-06-11 12:39:29 +00:00
|
|
|
sizeof(struct in6_addr)*(rh0->ip6r0_segleft - 1)
|
1999-11-22 02:45:11 +00:00
|
|
|
);
|
2003-10-24 20:37:05 +00:00
|
|
|
*(addrs + rh0->ip6r0_segleft - 1) = finaldst;
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
|
|
|
default: /* is it possible? */
|
|
|
|
error = EINVAL;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Source address validation */
|
|
|
|
if (IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src) &&
|
|
|
|
(flags & IPV6_DADOUTPUT) == 0) {
|
|
|
|
error = EOPNOTSUPP;
|
|
|
|
ip6stat.ip6s_badscope++;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_src)) {
|
|
|
|
error = EOPNOTSUPP;
|
|
|
|
ip6stat.ip6s_badscope++;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
|
|
|
ip6stat.ip6s_localout++;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Route packet.
|
|
|
|
*/
|
|
|
|
if (ro == 0) {
|
|
|
|
ro = &ip6route;
|
|
|
|
bzero((caddr_t)ro, sizeof(*ro));
|
|
|
|
}
|
|
|
|
ro_pmtu = ro;
|
|
|
|
if (opt && opt->ip6po_rthdr)
|
|
|
|
ro = &opt->ip6po_route;
|
|
|
|
dst = (struct sockaddr_in6 *)&ro->ro_dst;
|
2003-10-08 18:26:08 +00:00
|
|
|
|
2005-04-18 18:35:05 +00:00
|
|
|
again:
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
|
|
|
* If there is a cached route,
|
|
|
|
* check that it is to the same destination
|
|
|
|
* and is still up. If not, free it and try again.
|
|
|
|
*/
|
|
|
|
if (ro->ro_rt && ((ro->ro_rt->rt_flags & RTF_UP) == 0 ||
|
2002-03-29 15:42:44 +00:00
|
|
|
dst->sin6_family != AF_INET6 ||
|
1999-11-22 02:45:11 +00:00
|
|
|
!IN6_ARE_ADDR_EQUAL(&dst->sin6_addr, &ip6->ip6_dst))) {
|
|
|
|
RTFREE(ro->ro_rt);
|
|
|
|
ro->ro_rt = (struct rtentry *)0;
|
|
|
|
}
|
|
|
|
if (ro->ro_rt == 0) {
|
|
|
|
bzero(dst, sizeof(*dst));
|
|
|
|
dst->sin6_family = AF_INET6;
|
|
|
|
dst->sin6_len = sizeof(struct sockaddr_in6);
|
|
|
|
dst->sin6_addr = ip6->ip6_dst;
|
|
|
|
}
|
2003-10-24 18:26:30 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* if specified, try to fill in the traffic class field.
|
|
|
|
* do not override if a non-zero value is already set.
|
|
|
|
* we check the diffserv field and the ecn field separately.
|
|
|
|
*/
|
|
|
|
if (opt && opt->ip6po_tclass >= 0) {
|
|
|
|
int mask = 0;
|
|
|
|
|
|
|
|
if ((ip6->ip6_flow & htonl(0xfc << 20)) == 0)
|
|
|
|
mask |= 0xfc;
|
|
|
|
if ((ip6->ip6_flow & htonl(0x03 << 20)) == 0)
|
|
|
|
mask |= 0x03;
|
|
|
|
if (mask != 0)
|
|
|
|
ip6->ip6_flow |= htonl((opt->ip6po_tclass & mask) << 20);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fill in or override the hop limit field, if necessary. */
|
|
|
|
if (opt && opt->ip6po_hlim != -1)
|
|
|
|
ip6->ip6_hlim = opt->ip6po_hlim & 0xff;
|
|
|
|
else if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {
|
|
|
|
if (im6o != NULL)
|
|
|
|
ip6->ip6_hlim = im6o->im6o_multicast_hlim;
|
|
|
|
else
|
|
|
|
ip6->ip6_hlim = ip6_defmcasthlim;
|
|
|
|
}
|
|
|
|
|
2002-10-16 02:25:05 +00:00
|
|
|
#if defined(IPSEC) || defined(FAST_IPSEC)
|
1999-11-22 02:45:11 +00:00
|
|
|
if (needipsec && needipsectun) {
|
|
|
|
struct ipsec_output_state state;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* All the extension headers will become inaccessible
|
|
|
|
* (since they can be encrypted).
|
|
|
|
* Don't panic, we need no more updates to extension headers
|
|
|
|
* on inner IPv6 packet (since they are now encapsulated).
|
|
|
|
*
|
|
|
|
* IPv6 [ESP|AH] IPv6 [extension headers] payload
|
|
|
|
*/
|
|
|
|
bzero(&exthdrs, sizeof(exthdrs));
|
|
|
|
exthdrs.ip6e_ip6 = m;
|
|
|
|
|
|
|
|
bzero(&state, sizeof(state));
|
|
|
|
state.m = m;
|
|
|
|
state.ro = (struct route *)ro;
|
|
|
|
state.dst = (struct sockaddr *)dst;
|
|
|
|
|
|
|
|
error = ipsec6_output_tunnel(&state, sp, flags);
|
|
|
|
|
|
|
|
m = state.m;
|
|
|
|
ro = (struct route_in6 *)state.ro;
|
|
|
|
dst = (struct sockaddr_in6 *)state.dst;
|
|
|
|
if (error) {
|
|
|
|
/* mbuf is already reclaimed in ipsec6_output_tunnel. */
|
|
|
|
m0 = m = NULL;
|
|
|
|
m = NULL;
|
|
|
|
switch (error) {
|
|
|
|
case EHOSTUNREACH:
|
|
|
|
case ENETUNREACH:
|
|
|
|
case EMSGSIZE:
|
|
|
|
case ENOBUFS:
|
|
|
|
case ENOMEM:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf("ip6_output (ipsec): error code %d\n", error);
|
2003-10-08 18:26:08 +00:00
|
|
|
/* FALLTHROUGH */
|
1999-11-22 02:45:11 +00:00
|
|
|
case ENOENT:
|
|
|
|
/* don't show these error codes to the user */
|
|
|
|
error = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
|
|
|
exthdrs.ip6e_ip6 = m;
|
|
|
|
}
|
2002-04-19 04:46:24 +00:00
|
|
|
#endif /* IPSEC */
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
if (!IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {
|
|
|
|
/* Unicast */
|
|
|
|
|
|
|
|
#define ifatoia6(ifa) ((struct in6_ifaddr *)(ifa))
|
|
|
|
#define sin6tosa(sin6) ((struct sockaddr *)(sin6))
|
|
|
|
/* xxx
|
|
|
|
* interface selection comes here
|
|
|
|
* if an interface is specified from an upper layer,
|
|
|
|
* ifp must point it.
|
|
|
|
*/
|
2000-07-04 16:35:15 +00:00
|
|
|
if (ro->ro_rt == 0) {
|
|
|
|
/*
|
|
|
|
* non-bsdi always clone routes, if parent is
|
|
|
|
* PRF_CLONING.
|
|
|
|
*/
|
1999-12-09 08:56:50 +00:00
|
|
|
rtalloc((struct route *)ro);
|
2000-07-04 16:35:15 +00:00
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
if (ro->ro_rt == 0) {
|
|
|
|
ip6stat.ip6s_noroute++;
|
|
|
|
error = EHOSTUNREACH;
|
|
|
|
/* XXX in6_ifstat_inc(ifp, ifs6_out_discard); */
|
|
|
|
goto bad;
|
|
|
|
}
|
2003-10-07 20:57:35 +00:00
|
|
|
/* XXX rt not locked */
|
1999-11-22 02:45:11 +00:00
|
|
|
ia = ifatoia6(ro->ro_rt->rt_ifa);
|
|
|
|
ifp = ro->ro_rt->rt_ifp;
|
2003-11-20 20:07:39 +00:00
|
|
|
ro->ro_rt->rt_rmx.rmx_pksent++;
|
1999-11-22 02:45:11 +00:00
|
|
|
if (ro->ro_rt->rt_flags & RTF_GATEWAY)
|
|
|
|
dst = (struct sockaddr_in6 *)ro->ro_rt->rt_gateway;
|
|
|
|
m->m_flags &= ~(M_BCAST | M_MCAST); /* just in case */
|
|
|
|
|
|
|
|
in6_ifstat_inc(ifp, ifs6_out_request);
|
|
|
|
|
|
|
|
/*
|
2000-07-04 16:35:15 +00:00
|
|
|
* Check if the outgoing interface conflicts with
|
|
|
|
* the interface specified by ifi6_ifindex (if specified).
|
1999-11-22 02:45:11 +00:00
|
|
|
* Note that loopback interface is always okay.
|
2000-07-04 16:35:15 +00:00
|
|
|
* (this may happen when we are sending a packet to one of
|
|
|
|
* our own addresses.)
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
|
|
|
if (opt && opt->ip6po_pktinfo
|
|
|
|
&& opt->ip6po_pktinfo->ipi6_ifindex) {
|
|
|
|
if (!(ifp->if_flags & IFF_LOOPBACK)
|
|
|
|
&& ifp->if_index != opt->ip6po_pktinfo->ipi6_ifindex) {
|
|
|
|
ip6stat.ip6s_noroute++;
|
|
|
|
in6_ifstat_inc(ifp, ifs6_out_discard);
|
|
|
|
error = EHOSTUNREACH;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (opt && opt->ip6po_hlim != -1)
|
|
|
|
ip6->ip6_hlim = opt->ip6po_hlim & 0xff;
|
|
|
|
} else {
|
|
|
|
/* Multicast */
|
|
|
|
struct in6_multi *in6m;
|
|
|
|
|
|
|
|
m->m_flags = (m->m_flags & ~M_BCAST) | M_MCAST;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if the caller provided any multicast options
|
|
|
|
*/
|
|
|
|
ifp = NULL;
|
|
|
|
if (im6o != NULL) {
|
|
|
|
ip6->ip6_hlim = im6o->im6o_multicast_hlim;
|
|
|
|
if (im6o->im6o_multicast_ifp != NULL)
|
|
|
|
ifp = im6o->im6o_multicast_ifp;
|
|
|
|
} else
|
|
|
|
ip6->ip6_hlim = ip6_defmcasthlim;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if the caller provided the outgoing interface
|
|
|
|
* as an ancillary data.
|
|
|
|
* Boundary check for ifindex is assumed to be already done.
|
|
|
|
*/
|
|
|
|
if (opt && opt->ip6po_pktinfo && opt->ip6po_pktinfo->ipi6_ifindex)
|
2001-09-06 02:40:43 +00:00
|
|
|
ifp = ifnet_byindex(opt->ip6po_pktinfo->ipi6_ifindex);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the destination is a node-local scope multicast,
|
|
|
|
* the packet should be loop-backed only.
|
|
|
|
*/
|
2003-10-21 20:05:32 +00:00
|
|
|
if (IN6_IS_ADDR_MC_INTFACELOCAL(&ip6->ip6_dst)) {
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
|
|
|
* If the outgoing interface is already specified,
|
|
|
|
* it should be a loopback interface.
|
|
|
|
*/
|
|
|
|
if (ifp && (ifp->if_flags & IFF_LOOPBACK) == 0) {
|
|
|
|
ip6stat.ip6s_badscope++;
|
|
|
|
error = ENETUNREACH; /* XXX: better error? */
|
|
|
|
/* XXX correct ifp? */
|
|
|
|
in6_ifstat_inc(ifp, ifs6_out_discard);
|
|
|
|
goto bad;
|
|
|
|
} else {
|
|
|
|
ifp = &loif[0];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (opt && opt->ip6po_hlim != -1)
|
|
|
|
ip6->ip6_hlim = opt->ip6po_hlim & 0xff;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If caller did not provide an interface lookup a
|
|
|
|
* default in the routing table. This is either a
|
|
|
|
* default for the speicfied group (i.e. a host
|
|
|
|
* route), or a multicast default (a route for the
|
|
|
|
* ``net'' ff00::/8).
|
|
|
|
*/
|
|
|
|
if (ifp == NULL) {
|
2003-10-07 20:57:35 +00:00
|
|
|
if (ro->ro_rt == 0)
|
1999-11-22 02:45:11 +00:00
|
|
|
ro->ro_rt = rtalloc1((struct sockaddr *)
|
|
|
|
&ro->ro_dst, 0, 0UL);
|
2003-10-07 20:57:35 +00:00
|
|
|
else
|
|
|
|
RT_LOCK(ro->ro_rt);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (ro->ro_rt == 0) {
|
|
|
|
ip6stat.ip6s_noroute++;
|
|
|
|
error = EHOSTUNREACH;
|
|
|
|
/* XXX in6_ifstat_inc(ifp, ifs6_out_discard) */
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
ia = ifatoia6(ro->ro_rt->rt_ifa);
|
|
|
|
ifp = ro->ro_rt->rt_ifp;
|
2003-11-20 20:07:39 +00:00
|
|
|
ro->ro_rt->rt_rmx.rmx_pksent++;
|
2003-10-04 03:44:50 +00:00
|
|
|
RT_UNLOCK(ro->ro_rt);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((flags & IPV6_FORWARDING) == 0)
|
|
|
|
in6_ifstat_inc(ifp, ifs6_out_request);
|
|
|
|
in6_ifstat_inc(ifp, ifs6_out_mcast);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Confirm that the outgoing interface supports multicast.
|
|
|
|
*/
|
|
|
|
if ((ifp->if_flags & IFF_MULTICAST) == 0) {
|
|
|
|
ip6stat.ip6s_noroute++;
|
|
|
|
in6_ifstat_inc(ifp, ifs6_out_discard);
|
|
|
|
error = ENETUNREACH;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
IN6_LOOKUP_MULTI(ip6->ip6_dst, ifp, in6m);
|
|
|
|
if (in6m != NULL &&
|
|
|
|
(im6o == NULL || im6o->im6o_multicast_loop)) {
|
|
|
|
/*
|
|
|
|
* If we belong to the destination multicast group
|
|
|
|
* on the outgoing interface, and the caller did not
|
|
|
|
* forbid loopback, loop back a copy.
|
|
|
|
*/
|
|
|
|
ip6_mloopback(ifp, m, dst);
|
2000-01-28 05:27:14 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* If we are acting as a multicast router, perform
|
|
|
|
* multicast forwarding as if the packet had just
|
|
|
|
* arrived on the interface to which we are about
|
|
|
|
* to send. The multicast forwarding function
|
|
|
|
* recursively calls this function, using the
|
|
|
|
* IPV6_FORWARDING flag to prevent infinite recursion.
|
|
|
|
*
|
|
|
|
* Multicasts that are looped back by ip6_mloopback(),
|
|
|
|
* above, will be forwarded by the ip6_input() routine,
|
|
|
|
* if necessary.
|
|
|
|
*/
|
|
|
|
if (ip6_mrouter && (flags & IPV6_FORWARDING) == 0) {
|
2000-07-04 16:35:15 +00:00
|
|
|
if (ip6_mforward(ip6, ifp, m) != 0) {
|
2000-01-28 05:27:14 +00:00
|
|
|
m_freem(m);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Multicasts with a hoplimit of zero may be looped back,
|
|
|
|
* above, but must not be transmitted on a network.
|
|
|
|
* Also, multicasts addressed to the loopback interface
|
|
|
|
* are not sent -- the above call to ip6_mloopback() will
|
|
|
|
* loop back a copy if this host actually belongs to the
|
|
|
|
* destination group on the loopback interface.
|
|
|
|
*/
|
2003-10-24 18:26:30 +00:00
|
|
|
if (ip6->ip6_hlim == 0 || (ifp->if_flags & IFF_LOOPBACK) ||
|
|
|
|
IN6_IS_ADDR_MC_INTFACELOCAL(&ip6->ip6_dst)) {
|
1999-11-22 02:45:11 +00:00
|
|
|
m_freem(m);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fill the outgoing inteface to tell the upper layer
|
|
|
|
* to increment per-interface statistics.
|
|
|
|
*/
|
|
|
|
if (ifpp)
|
|
|
|
*ifpp = ifp;
|
|
|
|
|
2003-10-20 15:27:48 +00:00
|
|
|
/* Determine path MTU. */
|
2003-10-24 18:26:30 +00:00
|
|
|
if ((error = ip6_getpmtu(ro_pmtu, ro, ifp, &finaldst, &mtu,
|
|
|
|
&alwaysfrag)) != 0)
|
2003-10-20 15:27:48 +00:00
|
|
|
goto bad;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
2004-02-08 18:22:27 +00:00
|
|
|
* The caller of this function may specify to use the minimum MTU
|
|
|
|
* in some cases.
|
|
|
|
* An advanced API option (IPV6_USE_MIN_MTU) can also override MTU
|
|
|
|
* setting. The logic is a bit complicated; by default, unicast
|
|
|
|
* packets will follow path MTU while multicast packets will be sent at
|
|
|
|
* the minimum MTU. If IP6PO_MINMTU_ALL is specified, all packets
|
|
|
|
* including unicast ones will be sent at the minimum MTU. Multicast
|
|
|
|
* packets will always be sent at the minimum MTU unless
|
|
|
|
* IP6PO_MINMTU_DISABLE is explicitly specified.
|
|
|
|
* See RFC 3542 for more details.
|
2001-06-11 12:39:29 +00:00
|
|
|
*/
|
2004-02-08 18:22:27 +00:00
|
|
|
if (mtu > IPV6_MMTU) {
|
|
|
|
if ((flags & IPV6_MINMTU))
|
|
|
|
mtu = IPV6_MMTU;
|
|
|
|
else if (opt && opt->ip6po_minmtu == IP6PO_MINMTU_ALL)
|
|
|
|
mtu = IPV6_MMTU;
|
|
|
|
else if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) &&
|
|
|
|
(opt == NULL ||
|
|
|
|
opt->ip6po_minmtu != IP6PO_MINMTU_DISABLE)) {
|
|
|
|
mtu = IPV6_MMTU;
|
|
|
|
}
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
/* Fake scoped addresses */
|
|
|
|
if ((ifp->if_flags & IFF_LOOPBACK) != 0) {
|
|
|
|
/*
|
|
|
|
* If source or destination address is a scoped address, and
|
|
|
|
* the packet is going to be sent to a loopback interface,
|
|
|
|
* we should keep the original interface.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX: this is a very experimental and temporary solution.
|
|
|
|
* We eventually have sockaddr_in6 and use the sin6_scope_id
|
|
|
|
* field of the structure here.
|
|
|
|
* We rely on the consistency between two scope zone ids
|
2002-04-19 04:46:24 +00:00
|
|
|
* of source and destination, which should already be assured.
|
|
|
|
* Larger scopes than link will be supported in the future.
|
2000-07-04 16:35:15 +00:00
|
|
|
*/
|
2001-06-11 12:39:29 +00:00
|
|
|
origifp = NULL;
|
2000-07-04 16:35:15 +00:00
|
|
|
if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src))
|
2001-09-06 02:40:43 +00:00
|
|
|
origifp = ifnet_byindex(ntohs(ip6->ip6_src.s6_addr16[1]));
|
2000-07-04 16:35:15 +00:00
|
|
|
else if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst))
|
2001-09-06 02:40:43 +00:00
|
|
|
origifp = ifnet_byindex(ntohs(ip6->ip6_dst.s6_addr16[1]));
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
|
|
|
* XXX: origifp can be NULL even in those two cases above.
|
|
|
|
* For example, if we remove the (only) link-local address
|
|
|
|
* from the loopback interface, and try to send a link-local
|
|
|
|
* address without link-id information. Then the source
|
|
|
|
* address is ::1, and the destination address is the
|
|
|
|
* link-local address with its s6_addr16[1] being zero.
|
|
|
|
* What is worse, if the packet goes to the loopback interface
|
|
|
|
* by a default rejected route, the null pointer would be
|
|
|
|
* passed to looutput, and the kernel would hang.
|
|
|
|
* The following last resort would prevent such disaster.
|
|
|
|
*/
|
|
|
|
if (origifp == NULL)
|
2000-07-04 16:35:15 +00:00
|
|
|
origifp = ifp;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
origifp = ifp;
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
|
|
|
* clear embedded scope identifiers if necessary.
|
|
|
|
* in6_clearscope will touch the addresses only when necessary.
|
|
|
|
*/
|
|
|
|
in6_clearscope(&ip6->ip6_src);
|
|
|
|
in6_clearscope(&ip6->ip6_dst);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check with the firewall...
|
|
|
|
*/
|
2003-10-08 18:26:08 +00:00
|
|
|
if (ip6_fw_enable && ip6_fw_chk_ptr) {
|
1999-11-22 02:45:11 +00:00
|
|
|
u_short port = 0;
|
2002-04-19 04:46:24 +00:00
|
|
|
m->m_pkthdr.rcvif = NULL; /* XXX */
|
1999-11-22 02:45:11 +00:00
|
|
|
/* If ipfw says divert, we have to just drop packet */
|
|
|
|
if ((*ip6_fw_chk_ptr)(&ip6, ifp, &port, &m)) {
|
|
|
|
m_freem(m);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (!m) {
|
|
|
|
error = EACCES;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the outgoing packet contains a hop-by-hop options header,
|
|
|
|
* it must be examined and processed even by the source node.
|
|
|
|
* (RFC 2460, section 4.)
|
|
|
|
*/
|
|
|
|
if (exthdrs.ip6e_hbh) {
|
2001-06-11 12:39:29 +00:00
|
|
|
struct ip6_hbh *hbh = mtod(exthdrs.ip6e_hbh, struct ip6_hbh *);
|
2005-02-27 18:07:18 +00:00
|
|
|
u_int32_t dummy; /* XXX unused */
|
|
|
|
u_int32_t plen = 0; /* XXX: ip6_process will check the value */
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if ((hbh->ip6h_len + 1) << 3 > exthdrs.ip6e_hbh->m_len)
|
|
|
|
panic("ip6e_hbh is not continuous");
|
|
|
|
#endif
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
|
|
|
* XXX: if we have to send an ICMPv6 error to the sender,
|
|
|
|
* we need the M_LOOP flag since icmp6_error() expects
|
|
|
|
* the IPv6 and the hop-by-hop options header are
|
|
|
|
* continuous unless the flag is set.
|
|
|
|
*/
|
|
|
|
m->m_flags |= M_LOOP;
|
|
|
|
m->m_pkthdr.rcvif = ifp;
|
2003-10-08 18:26:08 +00:00
|
|
|
if (ip6_process_hopopts(m, (u_int8_t *)(hbh + 1),
|
|
|
|
((hbh->ip6h_len + 1) << 3) - sizeof(struct ip6_hbh),
|
2005-02-27 18:07:18 +00:00
|
|
|
&dummy, &plen) < 0) {
|
1999-11-22 02:45:11 +00:00
|
|
|
/* m was already freed at this point */
|
|
|
|
error = EINVAL;/* better error? */
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
m->m_flags &= ~M_LOOP; /* XXX */
|
|
|
|
m->m_pkthdr.rcvif = NULL;
|
|
|
|
}
|
|
|
|
|
2004-08-27 15:16:24 +00:00
|
|
|
/* Jump over all PFIL processing if hooks are not active. */
|
|
|
|
if (inet6_pfil_hook.ph_busy_count == -1)
|
|
|
|
goto passout;
|
|
|
|
|
2005-04-18 18:35:05 +00:00
|
|
|
odst = ip6->ip6_dst;
|
2004-08-27 15:16:24 +00:00
|
|
|
/* Run through list of hooks for output packets. */
|
2004-09-29 04:54:33 +00:00
|
|
|
error = pfil_run_hooks(&inet6_pfil_hook, &m, ifp, PFIL_OUT, inp);
|
2003-09-30 04:46:08 +00:00
|
|
|
if (error != 0 || m == NULL)
|
2003-09-23 17:54:04 +00:00
|
|
|
goto done;
|
|
|
|
ip6 = mtod(m, struct ip6_hdr *);
|
2003-10-08 18:26:08 +00:00
|
|
|
|
2005-04-18 18:35:05 +00:00
|
|
|
/* See if destination IP address was changed by packet filter. */
|
|
|
|
if (!IN6_ARE_ADDR_EQUAL(&odst, &ip6->ip6_dst)) {
|
|
|
|
m->m_flags |= M_SKIP_FIREWALL;
|
|
|
|
/* If destination is now ourself drop to ip6_input(). */
|
|
|
|
if (in6_localaddr(&ip6->ip6_dst)) {
|
|
|
|
if (m->m_pkthdr.rcvif == NULL)
|
|
|
|
m->m_pkthdr.rcvif = loif;
|
|
|
|
if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
|
|
|
|
m->m_pkthdr.csum_flags |=
|
|
|
|
CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
|
|
|
|
m->m_pkthdr.csum_data = 0xffff;
|
|
|
|
}
|
|
|
|
m->m_pkthdr.csum_flags |=
|
|
|
|
CSUM_IP_CHECKED | CSUM_IP_VALID;
|
|
|
|
error = netisr_queue(NETISR_IPV6, m);
|
|
|
|
goto done;
|
|
|
|
} else
|
|
|
|
goto again; /* Redo the routing table lookup. */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX: IPFIREWALL_FORWARD */
|
|
|
|
|
2004-08-27 15:16:24 +00:00
|
|
|
passout:
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
|
|
|
* Send the packet to the outgoing interface.
|
|
|
|
* If necessary, do IPv6 fragmentation before sending.
|
2003-10-24 18:26:30 +00:00
|
|
|
*
|
|
|
|
* the logic here is rather complex:
|
|
|
|
* 1: normal case (dontfrag == 0, alwaysfrag == 0)
|
|
|
|
* 1-a: send as is if tlen <= path mtu
|
|
|
|
* 1-b: fragment if tlen > path mtu
|
|
|
|
*
|
|
|
|
* 2: if user asks us not to fragment (dontfrag == 1)
|
|
|
|
* 2-a: send as is if tlen <= interface mtu
|
|
|
|
* 2-b: error if tlen > interface mtu
|
|
|
|
*
|
|
|
|
* 3: if we always need to attach fragment header (alwaysfrag == 1)
|
|
|
|
* always fragment
|
|
|
|
*
|
|
|
|
* 4: if dontfrag == 1 && alwaysfrag == 1
|
|
|
|
* error, as we cannot handle this conflicting request
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
|
|
|
tlen = m->m_pkthdr.len;
|
2003-10-24 18:26:30 +00:00
|
|
|
|
|
|
|
if (opt && (opt->ip6po_flags & IP6PO_DONTFRAG))
|
|
|
|
dontfrag = 1;
|
|
|
|
else
|
|
|
|
dontfrag = 0;
|
|
|
|
if (dontfrag && alwaysfrag) { /* case 4 */
|
|
|
|
/* conflicting request - can't transmit */
|
|
|
|
error = EMSGSIZE;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
if (dontfrag && tlen > IN6_LINKMTU(ifp)) { /* case 2-b */
|
|
|
|
/*
|
|
|
|
* Even if the DONTFRAG option is specified, we cannot send the
|
|
|
|
* packet when the data length is larger than the MTU of the
|
|
|
|
* outgoing interface.
|
|
|
|
* Notify the error by sending IPV6_PATHMTU ancillary data as
|
|
|
|
* well as returning an error code (the latter is not described
|
|
|
|
* in the API spec.)
|
|
|
|
*/
|
|
|
|
u_int32_t mtu32;
|
|
|
|
struct ip6ctlparam ip6cp;
|
|
|
|
|
|
|
|
mtu32 = (u_int32_t)mtu;
|
|
|
|
bzero(&ip6cp, sizeof(ip6cp));
|
|
|
|
ip6cp.ip6c_cmdarg = (void *)&mtu32;
|
|
|
|
pfctlinput2(PRC_MSGSIZE, (struct sockaddr *)&ro_pmtu->ro_dst,
|
|
|
|
(void *)&ip6cp);
|
|
|
|
|
|
|
|
error = EMSGSIZE;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* transmit packet without fragmentation
|
|
|
|
*/
|
|
|
|
if (dontfrag || (!alwaysfrag && tlen <= mtu)) { /* case 1-a and 2-a */
|
|
|
|
struct in6_ifaddr *ia6;
|
|
|
|
|
|
|
|
ip6 = mtod(m, struct ip6_hdr *);
|
|
|
|
ia6 = in6_ifawithifp(ifp, &ip6->ip6_src);
|
|
|
|
if (ia6) {
|
|
|
|
/* Record statistics for this interface address. */
|
|
|
|
ia6->ia_ifa.if_opackets++;
|
|
|
|
ia6->ia_ifa.if_obytes += m->m_pkthdr.len;
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef IPSEC
|
|
|
|
/* clean ipsec history once it goes out of the node */
|
|
|
|
ipsec_delaux(m);
|
|
|
|
#endif
|
2000-07-04 16:35:15 +00:00
|
|
|
error = nd6_output(ifp, origifp, m, dst, ro->ro_rt);
|
1999-11-22 02:45:11 +00:00
|
|
|
goto done;
|
2003-10-24 18:26:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* try to fragment the packet. case 1-b and 3
|
|
|
|
*/
|
|
|
|
if (mtu < IPV6_MMTU) {
|
|
|
|
/* path MTU cannot be less than IPV6_MMTU */
|
1999-11-22 02:45:11 +00:00
|
|
|
error = EMSGSIZE;
|
|
|
|
in6_ifstat_inc(ifp, ifs6_out_fragfail);
|
|
|
|
goto bad;
|
2003-10-08 18:26:08 +00:00
|
|
|
} else if (ip6->ip6_plen == 0) {
|
|
|
|
/* jumbo payload cannot be fragmented */
|
1999-11-22 02:45:11 +00:00
|
|
|
error = EMSGSIZE;
|
|
|
|
in6_ifstat_inc(ifp, ifs6_out_fragfail);
|
|
|
|
goto bad;
|
|
|
|
} else {
|
|
|
|
struct mbuf **mnext, *m_frgpart;
|
|
|
|
struct ip6_frag *ip6f;
|
2003-10-01 15:13:29 +00:00
|
|
|
u_int32_t id = htonl(ip6_randomid());
|
1999-11-22 02:45:11 +00:00
|
|
|
u_char nextproto;
|
2004-10-02 23:45:02 +00:00
|
|
|
#if 0
|
2004-02-08 18:22:27 +00:00
|
|
|
struct ip6ctlparam ip6cp;
|
|
|
|
u_int32_t mtu32;
|
2004-10-02 23:45:02 +00:00
|
|
|
#endif
|
Fix a bug which I discovered recently while doing IPv6 testing at
Wind River. In the IPv4 output path, one of the tests in ip_output()
checks how many slots are actually available in the interface output
queue before attempting to send a packet. If, for example, we need
to transmit a packet of 32K bytes over an interface with an MTU of
1500, we know it's going to take about 21 fragments to do it. If
there's less than 21 slots left in the output queue, there's no point
in transmitting anything at all: IP does not do retransmission, so
sending only some of the fragments would just be a waste of bandwidth.
(In an extreme case, if you're sending a heavy stream of fragmented
packets, you might find yourself sending nothing by the first fragment
of all your packets.) So if ip_output() notices there's not enough
room in the output queue to send the frame, it just dumps the packet
and returns ENOBUFS to the app.
It turns out ip6_output() lacks this code. Consequently, this caused
the netperf UDPIPV6_STREAM test to produce very poor results with large
write sizes. This commit adds code to check the remaining space in the
output queue and junk fragmented packets if they're too big to be
sent, just like with IPv4. (I can't imagine anyone's running an NFS
server using UDP over IPv6, but if they are, this will likely make them
a lot happier. :)
2004-05-14 03:57:17 +00:00
|
|
|
int qslots = ifp->if_snd.ifq_maxlen - ifp->if_snd.ifq_len;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Too large for the destination or interface;
|
|
|
|
* fragment if possible.
|
|
|
|
* Must be able to put at least 8 bytes per fragment.
|
|
|
|
*/
|
|
|
|
hlen = unfragpartlen;
|
|
|
|
if (mtu > IPV6_MAXPACKET)
|
|
|
|
mtu = IPV6_MAXPACKET;
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2004-10-02 23:45:02 +00:00
|
|
|
#if 0
|
|
|
|
/*
|
|
|
|
* It is believed this code is a leftover from the
|
|
|
|
* development of the IPV6_RECVPATHMTU sockopt and
|
|
|
|
* associated work to implement RFC3542.
|
|
|
|
* It's not entirely clear what the intent of the API
|
|
|
|
* is at this point, so disable this code for now.
|
|
|
|
* The IPV6_RECVPATHMTU sockopt and/or IPV6_DONTFRAG
|
|
|
|
* will send notifications if the application requests.
|
|
|
|
*/
|
|
|
|
|
2004-02-08 18:22:27 +00:00
|
|
|
/* Notify a proper path MTU to applications. */
|
|
|
|
mtu32 = (u_int32_t)mtu;
|
|
|
|
bzero(&ip6cp, sizeof(ip6cp));
|
|
|
|
ip6cp.ip6c_cmdarg = (void *)&mtu32;
|
|
|
|
pfctlinput2(PRC_MSGSIZE, (struct sockaddr *)&ro_pmtu->ro_dst,
|
|
|
|
(void *)&ip6cp);
|
2004-10-02 23:45:02 +00:00
|
|
|
#endif
|
2004-02-08 18:22:27 +00:00
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
len = (mtu - hlen - sizeof(struct ip6_frag)) & ~7;
|
|
|
|
if (len < 8) {
|
|
|
|
error = EMSGSIZE;
|
|
|
|
in6_ifstat_inc(ifp, ifs6_out_fragfail);
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
Fix a bug which I discovered recently while doing IPv6 testing at
Wind River. In the IPv4 output path, one of the tests in ip_output()
checks how many slots are actually available in the interface output
queue before attempting to send a packet. If, for example, we need
to transmit a packet of 32K bytes over an interface with an MTU of
1500, we know it's going to take about 21 fragments to do it. If
there's less than 21 slots left in the output queue, there's no point
in transmitting anything at all: IP does not do retransmission, so
sending only some of the fragments would just be a waste of bandwidth.
(In an extreme case, if you're sending a heavy stream of fragmented
packets, you might find yourself sending nothing by the first fragment
of all your packets.) So if ip_output() notices there's not enough
room in the output queue to send the frame, it just dumps the packet
and returns ENOBUFS to the app.
It turns out ip6_output() lacks this code. Consequently, this caused
the netperf UDPIPV6_STREAM test to produce very poor results with large
write sizes. This commit adds code to check the remaining space in the
output queue and junk fragmented packets if they're too big to be
sent, just like with IPv4. (I can't imagine anyone's running an NFS
server using UDP over IPv6, but if they are, this will likely make them
a lot happier. :)
2004-05-14 03:57:17 +00:00
|
|
|
/*
|
|
|
|
* Verify that we have any chance at all of being able to queue
|
|
|
|
* the packet or packet fragments
|
|
|
|
*/
|
|
|
|
if (qslots <= 0 || ((u_int)qslots * (mtu - hlen)
|
|
|
|
< tlen /* - hlen */)) {
|
|
|
|
error = ENOBUFS;
|
|
|
|
ip6stat.ip6s_odropped++;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
mnext = &m->m_nextpkt;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change the next header field of the last header in the
|
|
|
|
* unfragmentable part.
|
|
|
|
*/
|
|
|
|
if (exthdrs.ip6e_rthdr) {
|
|
|
|
nextproto = *mtod(exthdrs.ip6e_rthdr, u_char *);
|
|
|
|
*mtod(exthdrs.ip6e_rthdr, u_char *) = IPPROTO_FRAGMENT;
|
|
|
|
} else if (exthdrs.ip6e_dest1) {
|
|
|
|
nextproto = *mtod(exthdrs.ip6e_dest1, u_char *);
|
|
|
|
*mtod(exthdrs.ip6e_dest1, u_char *) = IPPROTO_FRAGMENT;
|
|
|
|
} else if (exthdrs.ip6e_hbh) {
|
|
|
|
nextproto = *mtod(exthdrs.ip6e_hbh, u_char *);
|
|
|
|
*mtod(exthdrs.ip6e_hbh, u_char *) = IPPROTO_FRAGMENT;
|
|
|
|
} else {
|
|
|
|
nextproto = ip6->ip6_nxt;
|
|
|
|
ip6->ip6_nxt = IPPROTO_FRAGMENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Loop through length of segment after first fragment,
|
2002-04-19 04:46:24 +00:00
|
|
|
* make new header and copy data of each part and link onto
|
|
|
|
* chain.
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
|
|
|
m0 = m;
|
|
|
|
for (off = hlen; off < tlen; off += len) {
|
2003-02-19 05:47:46 +00:00
|
|
|
MGETHDR(m, M_DONTWAIT, MT_HEADER);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (!m) {
|
|
|
|
error = ENOBUFS;
|
|
|
|
ip6stat.ip6s_odropped++;
|
|
|
|
goto sendorfree;
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
m->m_pkthdr.rcvif = NULL;
|
1999-11-22 02:45:11 +00:00
|
|
|
m->m_flags = m0->m_flags & M_COPYFLAGS;
|
|
|
|
*mnext = m;
|
|
|
|
mnext = &m->m_nextpkt;
|
|
|
|
m->m_data += max_linkhdr;
|
|
|
|
mhip6 = mtod(m, struct ip6_hdr *);
|
|
|
|
*mhip6 = *ip6;
|
|
|
|
m->m_len = sizeof(*mhip6);
|
2003-10-08 18:26:08 +00:00
|
|
|
error = ip6_insertfraghdr(m0, m, hlen, &ip6f);
|
|
|
|
if (error) {
|
1999-11-22 02:45:11 +00:00
|
|
|
ip6stat.ip6s_odropped++;
|
|
|
|
goto sendorfree;
|
|
|
|
}
|
|
|
|
ip6f->ip6f_offlg = htons((u_short)((off - hlen) & ~7));
|
|
|
|
if (off + len >= tlen)
|
|
|
|
len = tlen - off;
|
|
|
|
else
|
|
|
|
ip6f->ip6f_offlg |= IP6F_MORE_FRAG;
|
|
|
|
mhip6->ip6_plen = htons((u_short)(len + hlen +
|
2003-10-08 18:26:08 +00:00
|
|
|
sizeof(*ip6f) - sizeof(struct ip6_hdr)));
|
1999-11-22 02:45:11 +00:00
|
|
|
if ((m_frgpart = m_copy(m0, off, len)) == 0) {
|
|
|
|
error = ENOBUFS;
|
|
|
|
ip6stat.ip6s_odropped++;
|
|
|
|
goto sendorfree;
|
|
|
|
}
|
|
|
|
m_cat(m, m_frgpart);
|
|
|
|
m->m_pkthdr.len = len + hlen + sizeof(*ip6f);
|
|
|
|
m->m_pkthdr.rcvif = (struct ifnet *)0;
|
|
|
|
ip6f->ip6f_reserved = 0;
|
|
|
|
ip6f->ip6f_ident = id;
|
|
|
|
ip6f->ip6f_nxt = nextproto;
|
|
|
|
ip6stat.ip6s_ofragments++;
|
|
|
|
in6_ifstat_inc(ifp, ifs6_out_fragcreat);
|
|
|
|
}
|
|
|
|
|
|
|
|
in6_ifstat_inc(ifp, ifs6_out_fragok);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove leading garbages.
|
|
|
|
*/
|
|
|
|
sendorfree:
|
|
|
|
m = m0->m_nextpkt;
|
|
|
|
m0->m_nextpkt = 0;
|
|
|
|
m_freem(m0);
|
|
|
|
for (m0 = m; m; m = m0) {
|
|
|
|
m0 = m->m_nextpkt;
|
|
|
|
m->m_nextpkt = 0;
|
|
|
|
if (error == 0) {
|
2001-06-11 12:39:29 +00:00
|
|
|
/* Record statistics for this interface address. */
|
|
|
|
if (ia) {
|
|
|
|
ia->ia_ifa.if_opackets++;
|
|
|
|
ia->ia_ifa.if_obytes += m->m_pkthdr.len;
|
|
|
|
}
|
|
|
|
#ifdef IPSEC
|
|
|
|
/* clean ipsec history once it goes out of the node */
|
|
|
|
ipsec_delaux(m);
|
|
|
|
#endif
|
2000-07-04 16:35:15 +00:00
|
|
|
error = nd6_output(ifp, origifp, m, dst, ro->ro_rt);
|
1999-11-22 02:45:11 +00:00
|
|
|
} else
|
|
|
|
m_freem(m);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (error == 0)
|
|
|
|
ip6stat.ip6s_fragmented++;
|
|
|
|
|
|
|
|
done:
|
|
|
|
if (ro == &ip6route && ro->ro_rt) { /* brace necessary for RTFREE */
|
|
|
|
RTFREE(ro->ro_rt);
|
|
|
|
} else if (ro_pmtu == &ip6route && ro_pmtu->ro_rt) {
|
|
|
|
RTFREE(ro_pmtu->ro_rt);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef IPSEC
|
|
|
|
if (sp != NULL)
|
|
|
|
key_freesp(sp);
|
|
|
|
#endif /* IPSEC */
|
2002-10-16 02:25:05 +00:00
|
|
|
#ifdef FAST_IPSEC
|
|
|
|
if (sp != NULL)
|
|
|
|
KEY_FREESP(&sp);
|
|
|
|
#endif /* FAST_IPSEC */
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-06 14:02:09 +00:00
|
|
|
return (error);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
freehdrs:
|
|
|
|
m_freem(exthdrs.ip6e_hbh); /* m_freem will check if mbuf is 0 */
|
|
|
|
m_freem(exthdrs.ip6e_dest1);
|
|
|
|
m_freem(exthdrs.ip6e_rthdr);
|
|
|
|
m_freem(exthdrs.ip6e_dest2);
|
2003-10-08 18:26:08 +00:00
|
|
|
/* FALLTHROUGH */
|
1999-11-22 02:45:11 +00:00
|
|
|
bad:
|
|
|
|
m_freem(m);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
ip6_copyexthdr(mp, hdr, hlen)
|
|
|
|
struct mbuf **mp;
|
|
|
|
caddr_t hdr;
|
|
|
|
int hlen;
|
|
|
|
{
|
|
|
|
struct mbuf *m;
|
|
|
|
|
|
|
|
if (hlen > MCLBYTES)
|
2003-10-06 14:02:09 +00:00
|
|
|
return (ENOBUFS); /* XXX */
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-02-19 05:47:46 +00:00
|
|
|
MGET(m, M_DONTWAIT, MT_DATA);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (!m)
|
2003-10-06 14:02:09 +00:00
|
|
|
return (ENOBUFS);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
if (hlen > MLEN) {
|
2003-02-19 05:47:46 +00:00
|
|
|
MCLGET(m, M_DONTWAIT);
|
1999-11-22 02:45:11 +00:00
|
|
|
if ((m->m_flags & M_EXT) == 0) {
|
|
|
|
m_free(m);
|
2003-10-06 14:02:09 +00:00
|
|
|
return (ENOBUFS);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
m->m_len = hlen;
|
|
|
|
if (hdr)
|
|
|
|
bcopy(hdr, mtod(m, caddr_t), hlen);
|
|
|
|
|
|
|
|
*mp = m;
|
2003-10-06 14:02:09 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Insert jumbo payload option.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
ip6_insert_jumboopt(exthdrs, plen)
|
|
|
|
struct ip6_exthdrs *exthdrs;
|
|
|
|
u_int32_t plen;
|
|
|
|
{
|
|
|
|
struct mbuf *mopt;
|
|
|
|
u_char *optbuf;
|
2001-06-11 12:39:29 +00:00
|
|
|
u_int32_t v;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
#define JUMBOOPTLEN 8 /* length of jumbo payload option and padding */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is no hop-by-hop options header, allocate new one.
|
|
|
|
* If there is one but it doesn't have enough space to store the
|
|
|
|
* jumbo payload option, allocate a cluster to store the whole options.
|
|
|
|
* Otherwise, use it to store the options.
|
|
|
|
*/
|
|
|
|
if (exthdrs->ip6e_hbh == 0) {
|
2003-02-19 05:47:46 +00:00
|
|
|
MGET(mopt, M_DONTWAIT, MT_DATA);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (mopt == 0)
|
2003-10-06 14:02:09 +00:00
|
|
|
return (ENOBUFS);
|
1999-11-22 02:45:11 +00:00
|
|
|
mopt->m_len = JUMBOOPTLEN;
|
|
|
|
optbuf = mtod(mopt, u_char *);
|
|
|
|
optbuf[1] = 0; /* = ((JUMBOOPTLEN) >> 3) - 1 */
|
|
|
|
exthdrs->ip6e_hbh = mopt;
|
|
|
|
} else {
|
|
|
|
struct ip6_hbh *hbh;
|
|
|
|
|
|
|
|
mopt = exthdrs->ip6e_hbh;
|
|
|
|
if (M_TRAILINGSPACE(mopt) < JUMBOOPTLEN) {
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
|
|
|
* XXX assumption:
|
|
|
|
* - exthdrs->ip6e_hbh is not referenced from places
|
|
|
|
* other than exthdrs.
|
|
|
|
* - exthdrs->ip6e_hbh is not an mbuf chain.
|
|
|
|
*/
|
1999-11-22 02:45:11 +00:00
|
|
|
int oldoptlen = mopt->m_len;
|
2001-06-11 12:39:29 +00:00
|
|
|
struct mbuf *n;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
|
|
|
* XXX: give up if the whole (new) hbh header does
|
|
|
|
* not fit even in an mbuf cluster.
|
|
|
|
*/
|
|
|
|
if (oldoptlen + JUMBOOPTLEN > MCLBYTES)
|
2003-10-06 14:02:09 +00:00
|
|
|
return (ENOBUFS);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
|
|
|
* As a consequence, we must always prepare a cluster
|
|
|
|
* at this point.
|
|
|
|
*/
|
2003-02-19 05:47:46 +00:00
|
|
|
MGET(n, M_DONTWAIT, MT_DATA);
|
2001-06-11 12:39:29 +00:00
|
|
|
if (n) {
|
2003-02-19 05:47:46 +00:00
|
|
|
MCLGET(n, M_DONTWAIT);
|
2001-06-11 12:39:29 +00:00
|
|
|
if ((n->m_flags & M_EXT) == 0) {
|
|
|
|
m_freem(n);
|
|
|
|
n = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!n)
|
2003-10-06 14:02:09 +00:00
|
|
|
return (ENOBUFS);
|
2001-06-11 12:39:29 +00:00
|
|
|
n->m_len = oldoptlen + JUMBOOPTLEN;
|
|
|
|
bcopy(mtod(mopt, caddr_t), mtod(n, caddr_t),
|
2003-10-08 18:26:08 +00:00
|
|
|
oldoptlen);
|
2001-06-11 12:39:29 +00:00
|
|
|
optbuf = mtod(n, caddr_t) + oldoptlen;
|
|
|
|
m_freem(mopt);
|
|
|
|
mopt = exthdrs->ip6e_hbh = n;
|
1999-11-22 02:45:11 +00:00
|
|
|
} else {
|
|
|
|
optbuf = mtod(mopt, u_char *) + mopt->m_len;
|
|
|
|
mopt->m_len += JUMBOOPTLEN;
|
|
|
|
}
|
|
|
|
optbuf[0] = IP6OPT_PADN;
|
|
|
|
optbuf[1] = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Adjust the header length according to the pad and
|
|
|
|
* the jumbo payload option.
|
|
|
|
*/
|
|
|
|
hbh = mtod(mopt, struct ip6_hbh *);
|
|
|
|
hbh->ip6h_len += (JUMBOOPTLEN >> 3);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fill in the option. */
|
|
|
|
optbuf[2] = IP6OPT_JUMBO;
|
|
|
|
optbuf[3] = 4;
|
2001-06-11 12:39:29 +00:00
|
|
|
v = (u_int32_t)htonl(plen + JUMBOOPTLEN);
|
|
|
|
bcopy(&v, &optbuf[4], sizeof(u_int32_t));
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
/* finally, adjust the packet header length */
|
|
|
|
exthdrs->ip6e_ip6->m_pkthdr.len += JUMBOOPTLEN;
|
|
|
|
|
2003-10-06 14:02:09 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
#undef JUMBOOPTLEN
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Insert fragment header and copy unfragmentable header portions.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
ip6_insertfraghdr(m0, m, hlen, frghdrp)
|
|
|
|
struct mbuf *m0, *m;
|
|
|
|
int hlen;
|
|
|
|
struct ip6_frag **frghdrp;
|
|
|
|
{
|
|
|
|
struct mbuf *n, *mlast;
|
|
|
|
|
|
|
|
if (hlen > sizeof(struct ip6_hdr)) {
|
|
|
|
n = m_copym(m0, sizeof(struct ip6_hdr),
|
2003-10-08 18:26:08 +00:00
|
|
|
hlen - sizeof(struct ip6_hdr), M_DONTWAIT);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (n == 0)
|
2003-10-06 14:02:09 +00:00
|
|
|
return (ENOBUFS);
|
1999-11-22 02:45:11 +00:00
|
|
|
m->m_next = n;
|
|
|
|
} else
|
|
|
|
n = m;
|
|
|
|
|
|
|
|
/* Search for the last mbuf of unfragmentable part. */
|
|
|
|
for (mlast = n; mlast->m_next; mlast = mlast->m_next)
|
|
|
|
;
|
|
|
|
|
|
|
|
if ((mlast->m_flags & M_EXT) == 0 &&
|
2000-07-04 16:35:15 +00:00
|
|
|
M_TRAILINGSPACE(mlast) >= sizeof(struct ip6_frag)) {
|
1999-11-22 02:45:11 +00:00
|
|
|
/* use the trailing space of the last mbuf for the fragment hdr */
|
2003-10-08 18:26:08 +00:00
|
|
|
*frghdrp = (struct ip6_frag *)(mtod(mlast, caddr_t) +
|
|
|
|
mlast->m_len);
|
1999-11-22 02:45:11 +00:00
|
|
|
mlast->m_len += sizeof(struct ip6_frag);
|
|
|
|
m->m_pkthdr.len += sizeof(struct ip6_frag);
|
|
|
|
} else {
|
|
|
|
/* allocate a new mbuf for the fragment header */
|
|
|
|
struct mbuf *mfrg;
|
|
|
|
|
2003-02-19 05:47:46 +00:00
|
|
|
MGET(mfrg, M_DONTWAIT, MT_DATA);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (mfrg == 0)
|
2003-10-06 14:02:09 +00:00
|
|
|
return (ENOBUFS);
|
1999-11-22 02:45:11 +00:00
|
|
|
mfrg->m_len = sizeof(struct ip6_frag);
|
|
|
|
*frghdrp = mtod(mfrg, struct ip6_frag *);
|
|
|
|
mlast->m_next = mfrg;
|
|
|
|
}
|
|
|
|
|
2003-10-06 14:02:09 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
2003-10-20 15:27:48 +00:00
|
|
|
static int
|
2003-10-24 18:26:30 +00:00
|
|
|
ip6_getpmtu(ro_pmtu, ro, ifp, dst, mtup, alwaysfragp)
|
2003-10-20 15:27:48 +00:00
|
|
|
struct route_in6 *ro_pmtu, *ro;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
struct in6_addr *dst;
|
|
|
|
u_long *mtup;
|
2003-10-24 18:26:30 +00:00
|
|
|
int *alwaysfragp;
|
2003-10-20 15:27:48 +00:00
|
|
|
{
|
|
|
|
u_int32_t mtu = 0;
|
2003-10-24 18:26:30 +00:00
|
|
|
int alwaysfrag = 0;
|
2003-10-20 15:27:48 +00:00
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (ro_pmtu != ro) {
|
|
|
|
/* The first hop and the final destination may differ. */
|
|
|
|
struct sockaddr_in6 *sa6_dst =
|
2003-10-24 18:26:30 +00:00
|
|
|
(struct sockaddr_in6 *)&ro_pmtu->ro_dst;
|
2003-10-20 15:27:48 +00:00
|
|
|
if (ro_pmtu->ro_rt &&
|
2003-11-17 07:53:32 +00:00
|
|
|
((ro_pmtu->ro_rt->rt_flags & RTF_UP) == 0 ||
|
2003-10-20 15:27:48 +00:00
|
|
|
!IN6_ARE_ADDR_EQUAL(&sa6_dst->sin6_addr, dst))) {
|
|
|
|
RTFREE(ro_pmtu->ro_rt);
|
|
|
|
ro_pmtu->ro_rt = (struct rtentry *)NULL;
|
|
|
|
}
|
|
|
|
if (ro_pmtu->ro_rt == NULL) {
|
|
|
|
bzero(sa6_dst, sizeof(*sa6_dst));
|
|
|
|
sa6_dst->sin6_family = AF_INET6;
|
|
|
|
sa6_dst->sin6_len = sizeof(struct sockaddr_in6);
|
|
|
|
sa6_dst->sin6_addr = *dst;
|
|
|
|
|
|
|
|
rtalloc((struct route *)ro_pmtu);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (ro_pmtu->ro_rt) {
|
|
|
|
u_int32_t ifmtu;
|
2003-11-20 20:07:39 +00:00
|
|
|
struct in_conninfo inc;
|
|
|
|
|
|
|
|
bzero(&inc, sizeof(inc));
|
|
|
|
inc.inc_flags = 1; /* IPv6 */
|
|
|
|
inc.inc6_faddr = *dst;
|
2003-10-20 15:27:48 +00:00
|
|
|
|
|
|
|
if (ifp == NULL)
|
|
|
|
ifp = ro_pmtu->ro_rt->rt_ifp;
|
|
|
|
ifmtu = IN6_LINKMTU(ifp);
|
2003-11-20 20:07:39 +00:00
|
|
|
mtu = tcp_hc_getmtu(&inc);
|
|
|
|
if (mtu)
|
|
|
|
mtu = min(mtu, ro_pmtu->ro_rt->rt_rmx.rmx_mtu);
|
|
|
|
else
|
|
|
|
mtu = ro_pmtu->ro_rt->rt_rmx.rmx_mtu;
|
2003-10-20 15:27:48 +00:00
|
|
|
if (mtu == 0)
|
|
|
|
mtu = ifmtu;
|
2003-10-24 18:26:30 +00:00
|
|
|
else if (mtu < IPV6_MMTU) {
|
|
|
|
/*
|
|
|
|
* RFC2460 section 5, last paragraph:
|
|
|
|
* if we record ICMPv6 too big message with
|
|
|
|
* mtu < IPV6_MMTU, transmit packets sized IPV6_MMTU
|
|
|
|
* or smaller, with framgent header attached.
|
|
|
|
* (fragment header is needed regardless from the
|
|
|
|
* packet size, for translators to identify packets)
|
|
|
|
*/
|
|
|
|
alwaysfrag = 1;
|
|
|
|
mtu = IPV6_MMTU;
|
|
|
|
} else if (mtu > ifmtu) {
|
2003-10-20 15:27:48 +00:00
|
|
|
/*
|
|
|
|
* The MTU on the route is larger than the MTU on
|
|
|
|
* the interface! This shouldn't happen, unless the
|
|
|
|
* MTU of the interface has been changed after the
|
|
|
|
* interface was brought up. Change the MTU in the
|
|
|
|
* route to match the interface MTU (as long as the
|
|
|
|
* field isn't locked).
|
|
|
|
*/
|
2003-10-21 20:05:32 +00:00
|
|
|
mtu = ifmtu;
|
2003-11-20 20:07:39 +00:00
|
|
|
ro_pmtu->ro_rt->rt_rmx.rmx_mtu = mtu;
|
2003-10-20 15:27:48 +00:00
|
|
|
}
|
|
|
|
} else if (ifp) {
|
|
|
|
mtu = IN6_LINKMTU(ifp);
|
|
|
|
} else
|
|
|
|
error = EHOSTUNREACH; /* XXX */
|
|
|
|
|
|
|
|
*mtup = mtu;
|
2003-10-24 18:26:30 +00:00
|
|
|
if (alwaysfragp)
|
|
|
|
*alwaysfragp = alwaysfrag;
|
2003-10-20 15:27:48 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
|
|
|
* IP6 socket option processing.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
ip6_ctloutput(so, sopt)
|
|
|
|
struct socket *so;
|
|
|
|
struct sockopt *sopt;
|
|
|
|
{
|
2003-10-24 18:26:30 +00:00
|
|
|
int privileged, optdatalen, uproto;
|
|
|
|
void *optdata;
|
2001-06-11 12:39:29 +00:00
|
|
|
struct inpcb *in6p = sotoinpcb(so);
|
1999-11-22 02:45:11 +00:00
|
|
|
int error, optval;
|
|
|
|
int level, op, optname;
|
|
|
|
int optlen;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
if (sopt) {
|
|
|
|
level = sopt->sopt_level;
|
|
|
|
op = sopt->sopt_dir;
|
|
|
|
optname = sopt->sopt_name;
|
|
|
|
optlen = sopt->sopt_valsize;
|
2001-09-12 08:38:13 +00:00
|
|
|
td = sopt->sopt_td;
|
1999-11-22 02:45:11 +00:00
|
|
|
} else {
|
|
|
|
panic("ip6_ctloutput: arg soopt is NULL");
|
|
|
|
}
|
|
|
|
error = optval = 0;
|
|
|
|
|
2002-04-01 21:31:13 +00:00
|
|
|
privileged = (td == 0 || suser(td)) ? 0 : 1;
|
2003-10-24 18:26:30 +00:00
|
|
|
uproto = (int)so->so_proto->pr_protocol;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
if (level == IPPROTO_IPV6) {
|
|
|
|
switch (op) {
|
2001-06-11 12:39:29 +00:00
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
case SOPT_SET:
|
|
|
|
switch (optname) {
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_2292PKTOPTIONS:
|
|
|
|
#ifdef IPV6_PKTOPTIONS
|
1999-11-22 02:45:11 +00:00
|
|
|
case IPV6_PKTOPTIONS:
|
2003-10-24 18:26:30 +00:00
|
|
|
#endif
|
2001-06-11 12:39:29 +00:00
|
|
|
{
|
1999-11-22 02:45:11 +00:00
|
|
|
struct mbuf *m;
|
|
|
|
|
|
|
|
error = soopt_getm(sopt, &m); /* XXX */
|
2003-12-23 02:36:43 +00:00
|
|
|
if (error != 0)
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
|
|
|
error = soopt_mcopyin(sopt, m); /* XXX */
|
2003-12-23 02:36:43 +00:00
|
|
|
if (error != 0)
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
2001-06-11 12:39:29 +00:00
|
|
|
error = ip6_pcbopts(&in6p->in6p_outputopts,
|
|
|
|
m, so, sopt);
|
|
|
|
m_freem(m); /* XXX */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Use of some Hop-by-Hop options or some
|
|
|
|
* Destination options, might require special
|
|
|
|
* privilege. That is, normal applications
|
|
|
|
* (without special privilege) might be forbidden
|
|
|
|
* from setting certain options in outgoing packets,
|
|
|
|
* and might never see certain options in received
|
|
|
|
* packets. [RFC 2292 Section 6]
|
|
|
|
* KAME specific note:
|
|
|
|
* KAME prevents non-privileged users from sending or
|
|
|
|
* receiving ANY hbh/dst options in order to avoid
|
|
|
|
* overhead of parsing options in the kernel.
|
|
|
|
*/
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_RECVHOPOPTS:
|
|
|
|
case IPV6_RECVDSTOPTS:
|
|
|
|
case IPV6_RECVRTHDRDSTOPTS:
|
|
|
|
if (!privileged) {
|
|
|
|
error = EPERM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* FALLTHROUGH */
|
1999-11-22 02:45:11 +00:00
|
|
|
case IPV6_UNICAST_HOPS:
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_HOPLIMIT:
|
1999-11-22 02:45:11 +00:00
|
|
|
case IPV6_FAITH:
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_RECVPKTINFO:
|
|
|
|
case IPV6_RECVHOPLIMIT:
|
|
|
|
case IPV6_RECVRTHDR:
|
|
|
|
case IPV6_RECVPATHMTU:
|
|
|
|
case IPV6_RECVTCLASS:
|
2001-06-11 12:39:29 +00:00
|
|
|
case IPV6_V6ONLY:
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_AUTOFLOWLABEL:
|
2001-06-11 12:39:29 +00:00
|
|
|
if (optlen != sizeof(int)) {
|
1999-11-22 02:45:11 +00:00
|
|
|
error = EINVAL;
|
2001-06-11 12:39:29 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
error = sooptcopyin(sopt, &optval,
|
|
|
|
sizeof optval, sizeof optval);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
switch (optname) {
|
|
|
|
|
|
|
|
case IPV6_UNICAST_HOPS:
|
|
|
|
if (optval < -1 || optval >= 256)
|
|
|
|
error = EINVAL;
|
|
|
|
else {
|
|
|
|
/* -1 = kernel default */
|
|
|
|
in6p->in6p_hops = optval;
|
|
|
|
if ((in6p->in6p_vflag &
|
|
|
|
INP_IPV4) != 0)
|
|
|
|
in6p->inp_ip_ttl = optval;
|
|
|
|
}
|
|
|
|
break;
|
1999-11-22 02:45:11 +00:00
|
|
|
#define OPTSET(bit) \
|
2001-06-11 12:39:29 +00:00
|
|
|
do { \
|
1999-11-22 02:45:11 +00:00
|
|
|
if (optval) \
|
2001-06-11 12:39:29 +00:00
|
|
|
in6p->in6p_flags |= (bit); \
|
1999-11-22 02:45:11 +00:00
|
|
|
else \
|
2001-06-11 12:39:29 +00:00
|
|
|
in6p->in6p_flags &= ~(bit); \
|
2003-10-08 18:26:08 +00:00
|
|
|
} while (/*CONSTCOND*/ 0)
|
2003-10-24 18:26:30 +00:00
|
|
|
#define OPTSET2292(bit) \
|
|
|
|
do { \
|
|
|
|
in6p->in6p_flags |= IN6P_RFC2292; \
|
|
|
|
if (optval) \
|
|
|
|
in6p->in6p_flags |= (bit); \
|
|
|
|
else \
|
|
|
|
in6p->in6p_flags &= ~(bit); \
|
|
|
|
} while (/*CONSTCOND*/ 0)
|
2001-06-11 12:39:29 +00:00
|
|
|
#define OPTBIT(bit) (in6p->in6p_flags & (bit) ? 1 : 0)
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_RECVPKTINFO:
|
|
|
|
/* cannot mix with RFC2292 */
|
|
|
|
if (OPTBIT(IN6P_RFC2292)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
OPTSET(IN6P_PKTINFO);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_HOPLIMIT:
|
|
|
|
{
|
|
|
|
struct ip6_pktopts **optp;
|
|
|
|
|
|
|
|
/* cannot mix with RFC2292 */
|
|
|
|
if (OPTBIT(IN6P_RFC2292)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
optp = &in6p->in6p_outputopts;
|
|
|
|
error = ip6_pcbopt(IPV6_HOPLIMIT,
|
|
|
|
(u_char *)&optval,
|
|
|
|
sizeof(optval),
|
|
|
|
optp,
|
|
|
|
privileged, uproto);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case IPV6_RECVHOPLIMIT:
|
|
|
|
/* cannot mix with RFC2292 */
|
|
|
|
if (OPTBIT(IN6P_RFC2292)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
OPTSET(IN6P_HOPLIMIT);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_RECVHOPOPTS:
|
|
|
|
/* cannot mix with RFC2292 */
|
|
|
|
if (OPTBIT(IN6P_RFC2292)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
OPTSET(IN6P_HOPOPTS);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_RECVDSTOPTS:
|
|
|
|
/* cannot mix with RFC2292 */
|
|
|
|
if (OPTBIT(IN6P_RFC2292)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
OPTSET(IN6P_DSTOPTS);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_RECVRTHDRDSTOPTS:
|
|
|
|
/* cannot mix with RFC2292 */
|
|
|
|
if (OPTBIT(IN6P_RFC2292)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
OPTSET(IN6P_RTHDRDSTOPTS);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_RECVRTHDR:
|
|
|
|
/* cannot mix with RFC2292 */
|
|
|
|
if (OPTBIT(IN6P_RFC2292)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
OPTSET(IN6P_RTHDR);
|
2001-06-11 12:39:29 +00:00
|
|
|
break;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
case IPV6_FAITH:
|
|
|
|
OPTSET(IN6P_FAITH);
|
|
|
|
break;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_RECVPATHMTU:
|
|
|
|
/*
|
|
|
|
* We ignore this option for TCP
|
|
|
|
* sockets.
|
|
|
|
* (rfc2292bis leaves this case
|
|
|
|
* unspecified.)
|
|
|
|
*/
|
|
|
|
if (uproto != IPPROTO_TCP)
|
|
|
|
OPTSET(IN6P_MTU);
|
|
|
|
break;
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
case IPV6_V6ONLY:
|
2001-06-24 20:25:38 +00:00
|
|
|
/*
|
|
|
|
* make setsockopt(IPV6_V6ONLY)
|
|
|
|
* available only prior to bind(2).
|
|
|
|
* see ipng mailing list, Jun 22 2001.
|
|
|
|
*/
|
|
|
|
if (in6p->in6p_lport ||
|
2003-10-08 18:26:08 +00:00
|
|
|
!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) {
|
2001-06-24 20:25:38 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
OPTSET(IN6P_IPV6_V6ONLY);
|
2002-07-24 19:19:53 +00:00
|
|
|
if (optval)
|
|
|
|
in6p->in6p_vflag &= ~INP_IPV4;
|
|
|
|
else
|
|
|
|
in6p->in6p_vflag |= INP_IPV4;
|
2001-06-11 12:39:29 +00:00
|
|
|
break;
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_RECVTCLASS:
|
|
|
|
/* cannot mix with RFC2292 XXX */
|
|
|
|
if (OPTBIT(IN6P_RFC2292)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
OPTSET(IN6P_TCLASS);
|
|
|
|
break;
|
|
|
|
case IPV6_AUTOFLOWLABEL:
|
|
|
|
OPTSET(IN6P_AUTOFLOWLABEL);
|
|
|
|
break;
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
|
|
|
break;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_TCLASS:
|
|
|
|
case IPV6_DONTFRAG:
|
|
|
|
case IPV6_USE_MIN_MTU:
|
|
|
|
case IPV6_PREFER_TEMPADDR:
|
|
|
|
if (optlen != sizeof(optval)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
error = sooptcopyin(sopt, &optval,
|
|
|
|
sizeof optval, sizeof optval);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
{
|
|
|
|
struct ip6_pktopts **optp;
|
|
|
|
optp = &in6p->in6p_outputopts;
|
|
|
|
error = ip6_pcbopt(optname,
|
|
|
|
(u_char *)&optval,
|
|
|
|
sizeof(optval),
|
|
|
|
optp,
|
|
|
|
privileged, uproto);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case IPV6_2292PKTINFO:
|
|
|
|
case IPV6_2292HOPLIMIT:
|
|
|
|
case IPV6_2292HOPOPTS:
|
|
|
|
case IPV6_2292DSTOPTS:
|
|
|
|
case IPV6_2292RTHDR:
|
2001-06-11 12:39:29 +00:00
|
|
|
/* RFC 2292 */
|
|
|
|
if (optlen != sizeof(int)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
error = sooptcopyin(sopt, &optval,
|
|
|
|
sizeof optval, sizeof optval);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
switch (optname) {
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_2292PKTINFO:
|
|
|
|
OPTSET2292(IN6P_PKTINFO);
|
2001-06-11 12:39:29 +00:00
|
|
|
break;
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_2292HOPLIMIT:
|
|
|
|
OPTSET2292(IN6P_HOPLIMIT);
|
2001-06-11 12:39:29 +00:00
|
|
|
break;
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_2292HOPOPTS:
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
|
|
|
* Check super-user privilege.
|
|
|
|
* See comments for IPV6_RECVHOPOPTS.
|
|
|
|
*/
|
|
|
|
if (!privileged)
|
2003-10-06 14:02:09 +00:00
|
|
|
return (EPERM);
|
2003-10-24 18:26:30 +00:00
|
|
|
OPTSET2292(IN6P_HOPOPTS);
|
2001-06-11 12:39:29 +00:00
|
|
|
break;
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_2292DSTOPTS:
|
2001-06-11 12:39:29 +00:00
|
|
|
if (!privileged)
|
2003-10-06 14:02:09 +00:00
|
|
|
return (EPERM);
|
2003-10-24 18:26:30 +00:00
|
|
|
OPTSET2292(IN6P_DSTOPTS|IN6P_RTHDRDSTOPTS); /* XXX */
|
2001-06-11 12:39:29 +00:00
|
|
|
break;
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_2292RTHDR:
|
|
|
|
OPTSET2292(IN6P_RTHDR);
|
2001-06-11 12:39:29 +00:00
|
|
|
break;
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
break;
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_PKTINFO:
|
|
|
|
case IPV6_HOPOPTS:
|
|
|
|
case IPV6_RTHDR:
|
|
|
|
case IPV6_DSTOPTS:
|
|
|
|
case IPV6_RTHDRDSTOPTS:
|
|
|
|
case IPV6_NEXTHOP:
|
|
|
|
{
|
|
|
|
/* new advanced API (2292bis) */
|
|
|
|
u_char *optbuf;
|
|
|
|
int optlen;
|
|
|
|
struct ip6_pktopts **optp;
|
|
|
|
|
|
|
|
/* cannot mix with RFC2292 */
|
|
|
|
if (OPTBIT(IN6P_RFC2292)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2004-03-26 19:52:18 +00:00
|
|
|
switch (optname) {
|
|
|
|
case IPV6_HOPOPTS:
|
|
|
|
case IPV6_DSTOPTS:
|
|
|
|
case IPV6_RTHDRDSTOPTS:
|
|
|
|
case IPV6_NEXTHOP:
|
|
|
|
if (!privileged)
|
|
|
|
error = EPERM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
|
|
|
|
switch (optname) {
|
|
|
|
case IPV6_PKTINFO:
|
|
|
|
optlen = sizeof(struct in6_pktinfo);
|
|
|
|
break;
|
|
|
|
case IPV6_NEXTHOP:
|
|
|
|
optlen = SOCK_MAXADDRLEN;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
optlen = IPV6_MAXOPTHDR;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (sopt->sopt_valsize > optlen) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
optlen = sopt->sopt_valsize;
|
2004-03-26 19:52:18 +00:00
|
|
|
optbuf = malloc(optlen, M_TEMP, M_WAITOK);
|
|
|
|
error = sooptcopyin(sopt, optbuf, optlen,
|
|
|
|
optlen);
|
|
|
|
if (error) {
|
|
|
|
free(optbuf, M_TEMP);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
optp = &in6p->in6p_outputopts;
|
|
|
|
error = ip6_pcbopt(optname,
|
|
|
|
optbuf, optlen,
|
|
|
|
optp, privileged, uproto);
|
2004-03-26 19:52:18 +00:00
|
|
|
free(optbuf, M_TEMP);
|
2003-10-24 18:26:30 +00:00
|
|
|
break;
|
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
#undef OPTSET
|
|
|
|
|
|
|
|
case IPV6_MULTICAST_IF:
|
|
|
|
case IPV6_MULTICAST_HOPS:
|
|
|
|
case IPV6_MULTICAST_LOOP:
|
|
|
|
case IPV6_JOIN_GROUP:
|
|
|
|
case IPV6_LEAVE_GROUP:
|
2003-10-24 18:26:30 +00:00
|
|
|
{
|
|
|
|
if (sopt->sopt_valsize > MLEN) {
|
|
|
|
error = EMSGSIZE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* XXX */
|
|
|
|
}
|
|
|
|
/* FALLTHROUGH */
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
|
|
|
struct mbuf *m;
|
2003-10-08 18:26:08 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
if (sopt->sopt_valsize > MCLBYTES) {
|
1999-11-22 02:45:11 +00:00
|
|
|
error = EMSGSIZE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* XXX */
|
2003-10-24 18:26:30 +00:00
|
|
|
MGET(m, sopt->sopt_td ? M_WAIT : M_DONTWAIT, MT_HEADER);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (m == 0) {
|
|
|
|
error = ENOBUFS;
|
|
|
|
break;
|
|
|
|
}
|
2003-10-24 18:26:30 +00:00
|
|
|
if (sopt->sopt_valsize > MLEN) {
|
|
|
|
MCLGET(m, sopt->sopt_td ? M_WAIT : M_DONTWAIT);
|
|
|
|
if ((m->m_flags & M_EXT) == 0) {
|
|
|
|
m_free(m);
|
|
|
|
error = ENOBUFS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
m->m_len = sopt->sopt_valsize;
|
|
|
|
error = sooptcopyin(sopt, mtod(m, char *),
|
|
|
|
m->m_len, m->m_len);
|
2003-10-24 18:26:30 +00:00
|
|
|
if (error) {
|
|
|
|
(void)m_free(m);
|
|
|
|
break;
|
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
error = ip6_setmoptions(sopt->sopt_name,
|
|
|
|
&in6p->in6p_moptions,
|
|
|
|
m);
|
|
|
|
(void)m_free(m);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
case IPV6_PORTRANGE:
|
|
|
|
error = sooptcopyin(sopt, &optval,
|
|
|
|
sizeof optval, sizeof optval);
|
|
|
|
if (error)
|
|
|
|
break;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
switch (optval) {
|
|
|
|
case IPV6_PORTRANGE_DEFAULT:
|
|
|
|
in6p->in6p_flags &= ~(IN6P_LOWPORT);
|
|
|
|
in6p->in6p_flags &= ~(IN6P_HIGHPORT);
|
|
|
|
break;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
case IPV6_PORTRANGE_HIGH:
|
|
|
|
in6p->in6p_flags &= ~(IN6P_LOWPORT);
|
|
|
|
in6p->in6p_flags |= IN6P_HIGHPORT;
|
|
|
|
break;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
case IPV6_PORTRANGE_LOW:
|
|
|
|
in6p->in6p_flags &= ~(IN6P_HIGHPORT);
|
|
|
|
in6p->in6p_flags |= IN6P_LOWPORT;
|
|
|
|
break;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
default:
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
|
|
|
|
2002-10-16 02:25:05 +00:00
|
|
|
#if defined(IPSEC) || defined(FAST_IPSEC)
|
1999-11-22 02:45:11 +00:00
|
|
|
case IPV6_IPSEC_POLICY:
|
|
|
|
{
|
|
|
|
caddr_t req = NULL;
|
2000-07-04 16:35:15 +00:00
|
|
|
size_t len = 0;
|
1999-11-22 02:45:11 +00:00
|
|
|
struct mbuf *m;
|
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
if ((error = soopt_getm(sopt, &m)) != 0) /* XXX */
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
2000-07-04 16:35:15 +00:00
|
|
|
if ((error = soopt_mcopyin(sopt, m)) != 0) /* XXX */
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
2000-07-04 16:35:15 +00:00
|
|
|
if (m) {
|
1999-11-22 02:45:11 +00:00
|
|
|
req = mtod(m, caddr_t);
|
2000-07-04 16:35:15 +00:00
|
|
|
len = m->m_len;
|
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
error = ipsec6_set_policy(in6p, optname, req,
|
2003-10-08 18:26:08 +00:00
|
|
|
len, privileged);
|
1999-11-22 02:45:11 +00:00
|
|
|
m_freem(m);
|
|
|
|
}
|
|
|
|
break;
|
2001-06-11 12:39:29 +00:00
|
|
|
#endif /* KAME IPSEC */
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
case IPV6_FW_ADD:
|
|
|
|
case IPV6_FW_DEL:
|
|
|
|
case IPV6_FW_FLUSH:
|
|
|
|
case IPV6_FW_ZERO:
|
|
|
|
{
|
|
|
|
struct mbuf *m;
|
|
|
|
struct mbuf **mp = &m;
|
|
|
|
|
|
|
|
if (ip6_fw_ctl_ptr == NULL)
|
|
|
|
return EINVAL;
|
2001-06-24 14:57:20 +00:00
|
|
|
/* XXX */
|
|
|
|
if ((error = soopt_getm(sopt, &m)) != 0)
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
2001-06-24 14:57:20 +00:00
|
|
|
/* XXX */
|
|
|
|
if ((error = soopt_mcopyin(sopt, m)) != 0)
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
|
|
|
error = (*ip6_fw_ctl_ptr)(optname, mp);
|
|
|
|
m = *mp;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
error = ENOPROTOOPT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SOPT_GET:
|
|
|
|
switch (optname) {
|
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_2292PKTOPTIONS:
|
|
|
|
#ifdef IPV6_PKTOPTIONS
|
1999-11-22 02:45:11 +00:00
|
|
|
case IPV6_PKTOPTIONS:
|
2003-10-24 18:26:30 +00:00
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
* RFC3542 (effectively) deprecated the
|
|
|
|
* semantics of the 2292-style pktoptions.
|
|
|
|
* Since it was not reliable in nature (i.e.,
|
|
|
|
* applications had to expect the lack of some
|
|
|
|
* information after all), it would make sense
|
|
|
|
* to simplify this part by always returning
|
|
|
|
* empty data.
|
|
|
|
*/
|
|
|
|
sopt->sopt_valsize = 0;
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_RECVHOPOPTS:
|
|
|
|
case IPV6_RECVDSTOPTS:
|
|
|
|
case IPV6_RECVRTHDRDSTOPTS:
|
1999-11-22 02:45:11 +00:00
|
|
|
case IPV6_UNICAST_HOPS:
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_RECVPKTINFO:
|
|
|
|
case IPV6_RECVHOPLIMIT:
|
|
|
|
case IPV6_RECVRTHDR:
|
|
|
|
case IPV6_RECVPATHMTU:
|
2001-06-11 12:39:29 +00:00
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
case IPV6_FAITH:
|
2001-06-11 12:39:29 +00:00
|
|
|
case IPV6_V6ONLY:
|
2000-01-13 05:07:42 +00:00
|
|
|
case IPV6_PORTRANGE:
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_RECVTCLASS:
|
|
|
|
case IPV6_AUTOFLOWLABEL:
|
1999-11-22 02:45:11 +00:00
|
|
|
switch (optname) {
|
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_RECVHOPOPTS:
|
|
|
|
optval = OPTBIT(IN6P_HOPOPTS);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_RECVDSTOPTS:
|
|
|
|
optval = OPTBIT(IN6P_DSTOPTS);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_RECVRTHDRDSTOPTS:
|
|
|
|
optval = OPTBIT(IN6P_RTHDRDSTOPTS);
|
|
|
|
break;
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
case IPV6_UNICAST_HOPS:
|
|
|
|
optval = in6p->in6p_hops;
|
|
|
|
break;
|
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_RECVPKTINFO:
|
|
|
|
optval = OPTBIT(IN6P_PKTINFO);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_RECVHOPLIMIT:
|
|
|
|
optval = OPTBIT(IN6P_HOPLIMIT);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_RECVRTHDR:
|
|
|
|
optval = OPTBIT(IN6P_RTHDR);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_RECVPATHMTU:
|
|
|
|
optval = OPTBIT(IN6P_MTU);
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_FAITH:
|
|
|
|
optval = OPTBIT(IN6P_FAITH);
|
|
|
|
break;
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
case IPV6_V6ONLY:
|
2002-07-22 15:51:02 +00:00
|
|
|
optval = OPTBIT(IN6P_IPV6_V6ONLY);
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_PORTRANGE:
|
|
|
|
{
|
|
|
|
int flags;
|
|
|
|
flags = in6p->in6p_flags;
|
|
|
|
if (flags & IN6P_HIGHPORT)
|
|
|
|
optval = IPV6_PORTRANGE_HIGH;
|
|
|
|
else if (flags & IN6P_LOWPORT)
|
|
|
|
optval = IPV6_PORTRANGE_LOW;
|
|
|
|
else
|
|
|
|
optval = 0;
|
|
|
|
break;
|
|
|
|
}
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_RECVTCLASS:
|
|
|
|
optval = OPTBIT(IN6P_TCLASS);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_AUTOFLOWLABEL:
|
|
|
|
optval = OPTBIT(IN6P_AUTOFLOWLABEL);
|
|
|
|
break;
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
2003-10-24 18:26:30 +00:00
|
|
|
if (error)
|
|
|
|
break;
|
1999-11-22 02:45:11 +00:00
|
|
|
error = sooptcopyout(sopt, &optval,
|
|
|
|
sizeof optval);
|
|
|
|
break;
|
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_PATHMTU:
|
|
|
|
{
|
|
|
|
u_long pmtu = 0;
|
|
|
|
struct ip6_mtuinfo mtuinfo;
|
2003-11-20 20:07:39 +00:00
|
|
|
struct route_in6 sro;
|
|
|
|
|
|
|
|
bzero(&sro, sizeof(sro));
|
2003-10-24 18:26:30 +00:00
|
|
|
|
|
|
|
if (!(so->so_state & SS_ISCONNECTED))
|
|
|
|
return (ENOTCONN);
|
|
|
|
/*
|
|
|
|
* XXX: we dot not consider the case of source
|
|
|
|
* routing, or optional information to specify
|
|
|
|
* the outgoing interface.
|
|
|
|
*/
|
2003-11-20 20:07:39 +00:00
|
|
|
error = ip6_getpmtu(&sro, NULL, NULL,
|
2003-10-24 18:26:30 +00:00
|
|
|
&in6p->in6p_faddr, &pmtu, NULL);
|
2003-11-20 20:07:39 +00:00
|
|
|
if (sro.ro_rt)
|
|
|
|
RTFREE(sro.ro_rt);
|
2003-10-24 18:26:30 +00:00
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
if (pmtu > IPV6_MAXPACKET)
|
|
|
|
pmtu = IPV6_MAXPACKET;
|
|
|
|
|
|
|
|
bzero(&mtuinfo, sizeof(mtuinfo));
|
|
|
|
mtuinfo.ip6m_mtu = (u_int32_t)pmtu;
|
|
|
|
optdata = (void *)&mtuinfo;
|
|
|
|
optdatalen = sizeof(mtuinfo);
|
|
|
|
error = sooptcopyout(sopt, optdata,
|
|
|
|
optdatalen);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case IPV6_2292PKTINFO:
|
|
|
|
case IPV6_2292HOPLIMIT:
|
|
|
|
case IPV6_2292HOPOPTS:
|
|
|
|
case IPV6_2292RTHDR:
|
|
|
|
case IPV6_2292DSTOPTS:
|
2001-06-11 12:39:29 +00:00
|
|
|
switch (optname) {
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_2292PKTINFO:
|
2001-06-11 12:39:29 +00:00
|
|
|
optval = OPTBIT(IN6P_PKTINFO);
|
|
|
|
break;
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_2292HOPLIMIT:
|
2001-06-11 12:39:29 +00:00
|
|
|
optval = OPTBIT(IN6P_HOPLIMIT);
|
|
|
|
break;
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_2292HOPOPTS:
|
2001-06-11 12:39:29 +00:00
|
|
|
optval = OPTBIT(IN6P_HOPOPTS);
|
|
|
|
break;
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_2292RTHDR:
|
2001-06-11 12:39:29 +00:00
|
|
|
optval = OPTBIT(IN6P_RTHDR);
|
|
|
|
break;
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_2292DSTOPTS:
|
2001-06-11 12:39:29 +00:00
|
|
|
optval = OPTBIT(IN6P_DSTOPTS|IN6P_RTHDRDSTOPTS);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
error = sooptcopyout(sopt, &optval,
|
2003-10-24 18:26:30 +00:00
|
|
|
sizeof optval);
|
|
|
|
break;
|
|
|
|
case IPV6_PKTINFO:
|
|
|
|
case IPV6_HOPOPTS:
|
|
|
|
case IPV6_RTHDR:
|
|
|
|
case IPV6_DSTOPTS:
|
|
|
|
case IPV6_RTHDRDSTOPTS:
|
|
|
|
case IPV6_NEXTHOP:
|
|
|
|
case IPV6_TCLASS:
|
|
|
|
case IPV6_DONTFRAG:
|
|
|
|
case IPV6_USE_MIN_MTU:
|
|
|
|
case IPV6_PREFER_TEMPADDR:
|
|
|
|
error = ip6_getpcbopt(in6p->in6p_outputopts,
|
|
|
|
optname, sopt);
|
2001-06-11 12:39:29 +00:00
|
|
|
break;
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
case IPV6_MULTICAST_IF:
|
|
|
|
case IPV6_MULTICAST_HOPS:
|
|
|
|
case IPV6_MULTICAST_LOOP:
|
|
|
|
case IPV6_JOIN_GROUP:
|
|
|
|
case IPV6_LEAVE_GROUP:
|
|
|
|
{
|
|
|
|
struct mbuf *m;
|
|
|
|
error = ip6_getmoptions(sopt->sopt_name,
|
2003-10-08 18:26:08 +00:00
|
|
|
in6p->in6p_moptions, &m);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (error == 0)
|
|
|
|
error = sooptcopyout(sopt,
|
2003-10-08 18:26:08 +00:00
|
|
|
mtod(m, char *), m->m_len);
|
1999-11-22 02:45:11 +00:00
|
|
|
m_freem(m);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2002-10-16 02:25:05 +00:00
|
|
|
#if defined(IPSEC) || defined(FAST_IPSEC)
|
1999-11-22 02:45:11 +00:00
|
|
|
case IPV6_IPSEC_POLICY:
|
|
|
|
{
|
|
|
|
caddr_t req = NULL;
|
2000-07-04 16:35:15 +00:00
|
|
|
size_t len = 0;
|
|
|
|
struct mbuf *m = NULL;
|
|
|
|
struct mbuf **mp = &m;
|
2003-10-24 18:26:30 +00:00
|
|
|
size_t ovalsize = sopt->sopt_valsize;
|
|
|
|
caddr_t oval = (caddr_t)sopt->sopt_val;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
error = soopt_getm(sopt, &m); /* XXX */
|
2003-12-23 11:01:17 +00:00
|
|
|
if (error != 0)
|
2000-07-04 16:35:15 +00:00
|
|
|
break;
|
|
|
|
error = soopt_mcopyin(sopt, m); /* XXX */
|
2003-12-23 11:01:17 +00:00
|
|
|
if (error != 0)
|
2000-07-04 16:35:15 +00:00
|
|
|
break;
|
2003-10-24 18:26:30 +00:00
|
|
|
sopt->sopt_valsize = ovalsize;
|
|
|
|
sopt->sopt_val = oval;
|
2000-07-04 16:35:15 +00:00
|
|
|
if (m) {
|
1999-11-22 02:45:11 +00:00
|
|
|
req = mtod(m, caddr_t);
|
2000-07-04 16:35:15 +00:00
|
|
|
len = m->m_len;
|
|
|
|
}
|
|
|
|
error = ipsec6_get_policy(in6p, req, len, mp);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (error == 0)
|
2003-10-08 18:26:08 +00:00
|
|
|
error = soopt_mcopyout(sopt, m); /* XXX */
|
2001-06-11 12:39:29 +00:00
|
|
|
if (error == 0 && m)
|
|
|
|
m_freem(m);
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
#endif /* KAME IPSEC */
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
case IPV6_FW_GET:
|
|
|
|
{
|
|
|
|
struct mbuf *m;
|
|
|
|
struct mbuf **mp = &m;
|
|
|
|
|
|
|
|
if (ip6_fw_ctl_ptr == NULL)
|
|
|
|
{
|
|
|
|
return EINVAL;
|
|
|
|
}
|
|
|
|
error = (*ip6_fw_ctl_ptr)(optname, mp);
|
|
|
|
if (error == 0)
|
|
|
|
error = soopt_mcopyout(sopt, m); /* XXX */
|
2001-01-20 22:37:24 +00:00
|
|
|
if (error == 0 && m)
|
1999-11-22 02:45:11 +00:00
|
|
|
m_freem(m);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
error = ENOPROTOOPT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2003-10-24 18:26:30 +00:00
|
|
|
} else { /* level != IPPROTO_IPV6 */
|
1999-11-22 02:45:11 +00:00
|
|
|
error = EINVAL;
|
|
|
|
}
|
2003-10-06 14:02:09 +00:00
|
|
|
return (error);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
2003-10-26 18:17:01 +00:00
|
|
|
int
|
|
|
|
ip6_raw_ctloutput(so, sopt)
|
|
|
|
struct socket *so;
|
|
|
|
struct sockopt *sopt;
|
|
|
|
{
|
|
|
|
int error = 0, optval, optlen;
|
|
|
|
const int icmp6off = offsetof(struct icmp6_hdr, icmp6_cksum);
|
|
|
|
struct in6pcb *in6p = sotoin6pcb(so);
|
|
|
|
int level, op, optname;
|
|
|
|
|
|
|
|
if (sopt) {
|
|
|
|
level = sopt->sopt_level;
|
|
|
|
op = sopt->sopt_dir;
|
|
|
|
optname = sopt->sopt_name;
|
|
|
|
optlen = sopt->sopt_valsize;
|
|
|
|
} else
|
|
|
|
panic("ip6_raw_ctloutput: arg soopt is NULL");
|
|
|
|
|
|
|
|
if (level != IPPROTO_IPV6) {
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (optname) {
|
|
|
|
case IPV6_CHECKSUM:
|
|
|
|
/*
|
|
|
|
* For ICMPv6 sockets, no modification allowed for checksum
|
|
|
|
* offset, permit "no change" values to help existing apps.
|
|
|
|
*
|
|
|
|
* XXX 2292bis says: "An attempt to set IPV6_CHECKSUM
|
|
|
|
* for an ICMPv6 socket will fail."
|
|
|
|
* The current behavior does not meet 2292bis.
|
|
|
|
*/
|
|
|
|
switch (op) {
|
|
|
|
case SOPT_SET:
|
|
|
|
if (optlen != sizeof(int)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
error = sooptcopyin(sopt, &optval, sizeof(optval),
|
|
|
|
sizeof(optval));
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
if ((optval % 2) != 0) {
|
|
|
|
/* the API assumes even offset values */
|
|
|
|
error = EINVAL;
|
|
|
|
} else if (so->so_proto->pr_protocol ==
|
|
|
|
IPPROTO_ICMPV6) {
|
|
|
|
if (optval != icmp6off)
|
|
|
|
error = EINVAL;
|
|
|
|
} else
|
|
|
|
in6p->in6p_cksum = optval;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SOPT_GET:
|
|
|
|
if (so->so_proto->pr_protocol == IPPROTO_ICMPV6)
|
|
|
|
optval = icmp6off;
|
|
|
|
else
|
|
|
|
optval = in6p->in6p_cksum;
|
|
|
|
|
|
|
|
error = sooptcopyout(sopt, &optval, sizeof(optval));
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
error = ENOPROTOOPT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
2001-06-11 12:39:29 +00:00
|
|
|
* Set up IP6 options in pcb for insertion in output packets or
|
|
|
|
* specifying behavior of outgoing packets.
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
ip6_pcbopts(pktopt, m, so, sopt)
|
|
|
|
struct ip6_pktopts **pktopt;
|
2001-06-11 12:39:29 +00:00
|
|
|
struct mbuf *m;
|
1999-11-22 02:45:11 +00:00
|
|
|
struct socket *so;
|
|
|
|
struct sockopt *sopt;
|
|
|
|
{
|
2001-06-11 12:39:29 +00:00
|
|
|
struct ip6_pktopts *opt = *pktopt;
|
1999-11-22 02:45:11 +00:00
|
|
|
int error = 0;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td = sopt->sopt_td;
|
1999-11-22 02:45:11 +00:00
|
|
|
int priv = 0;
|
|
|
|
|
|
|
|
/* turn off any old options. */
|
|
|
|
if (opt) {
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (opt->ip6po_pktinfo || opt->ip6po_nexthop ||
|
|
|
|
opt->ip6po_hbh || opt->ip6po_dest1 || opt->ip6po_dest2 ||
|
|
|
|
opt->ip6po_rhinfo.ip6po_rhi_rthdr)
|
|
|
|
printf("ip6_pcbopts: all specified options are cleared.\n");
|
|
|
|
#endif
|
2003-10-24 18:26:30 +00:00
|
|
|
ip6_clearpktopts(opt, -1);
|
1999-11-22 02:45:11 +00:00
|
|
|
} else
|
2003-02-19 05:47:46 +00:00
|
|
|
opt = malloc(sizeof(*opt), M_IP6OPT, M_WAITOK);
|
2001-06-11 12:39:29 +00:00
|
|
|
*pktopt = NULL;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
if (!m || m->m_len == 0) {
|
|
|
|
/*
|
2002-10-31 19:45:48 +00:00
|
|
|
* Only turning off any previous options, regardless of
|
|
|
|
* whether the opt is just created or given.
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
2002-10-31 19:45:48 +00:00
|
|
|
free(opt, M_IP6OPT);
|
2003-10-06 14:02:09 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* set options specified by user. */
|
2002-04-01 21:31:13 +00:00
|
|
|
if (td && !suser(td))
|
1999-11-22 02:45:11 +00:00
|
|
|
priv = 1;
|
2003-10-24 18:26:30 +00:00
|
|
|
if ((error = ip6_setpktoptions(m, opt, NULL, priv, 1,
|
|
|
|
so->so_proto->pr_protocol)) != 0) {
|
|
|
|
ip6_clearpktopts(opt, -1); /* XXX: discard all options */
|
2002-10-31 19:45:48 +00:00
|
|
|
free(opt, M_IP6OPT);
|
2003-10-06 14:02:09 +00:00
|
|
|
return (error);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
*pktopt = opt;
|
2003-10-06 14:02:09 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
|
|
|
* initialize ip6_pktopts. beware that there are non-zero default values in
|
|
|
|
* the struct.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
init_ip6pktopts(opt)
|
|
|
|
struct ip6_pktopts *opt;
|
|
|
|
{
|
|
|
|
|
|
|
|
bzero(opt, sizeof(*opt));
|
|
|
|
opt->ip6po_hlim = -1; /* -1 means default hop limit */
|
2003-10-24 18:26:30 +00:00
|
|
|
opt->ip6po_tclass = -1; /* -1 means default traffic class */
|
|
|
|
opt->ip6po_minmtu = IP6PO_MINMTU_MCASTONLY;
|
|
|
|
opt->ip6po_prefer_tempaddr = IP6PO_TEMPADDR_SYSTEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
ip6_pcbopt(optname, buf, len, pktopt, priv, uproto)
|
|
|
|
int optname, len, priv;
|
|
|
|
u_char *buf;
|
|
|
|
struct ip6_pktopts **pktopt;
|
|
|
|
int uproto;
|
|
|
|
{
|
|
|
|
struct ip6_pktopts *opt;
|
|
|
|
|
|
|
|
if (*pktopt == NULL) {
|
|
|
|
*pktopt = malloc(sizeof(struct ip6_pktopts), M_IP6OPT,
|
|
|
|
M_WAITOK);
|
|
|
|
init_ip6pktopts(*pktopt);
|
|
|
|
(*pktopt)->needfree = 1;
|
|
|
|
}
|
|
|
|
opt = *pktopt;
|
|
|
|
|
|
|
|
return (ip6_setpktoption(optname, buf, len, opt, priv, 1, 0, uproto));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
ip6_getpcbopt(pktopt, optname, sopt)
|
|
|
|
struct ip6_pktopts *pktopt;
|
|
|
|
struct sockopt *sopt;
|
|
|
|
int optname;
|
|
|
|
{
|
|
|
|
void *optdata = NULL;
|
|
|
|
int optdatalen = 0;
|
|
|
|
struct ip6_ext *ip6e;
|
|
|
|
int error = 0;
|
|
|
|
struct in6_pktinfo null_pktinfo;
|
|
|
|
int deftclass = 0, on;
|
|
|
|
int defminmtu = IP6PO_MINMTU_MCASTONLY;
|
|
|
|
int defpreftemp = IP6PO_TEMPADDR_SYSTEM;
|
|
|
|
|
|
|
|
switch (optname) {
|
|
|
|
case IPV6_PKTINFO:
|
|
|
|
if (pktopt && pktopt->ip6po_pktinfo)
|
|
|
|
optdata = (void *)pktopt->ip6po_pktinfo;
|
|
|
|
else {
|
|
|
|
/* XXX: we don't have to do this every time... */
|
|
|
|
bzero(&null_pktinfo, sizeof(null_pktinfo));
|
|
|
|
optdata = (void *)&null_pktinfo;
|
|
|
|
}
|
|
|
|
optdatalen = sizeof(struct in6_pktinfo);
|
|
|
|
break;
|
|
|
|
case IPV6_TCLASS:
|
|
|
|
if (pktopt && pktopt->ip6po_tclass >= 0)
|
|
|
|
optdata = (void *)&pktopt->ip6po_tclass;
|
|
|
|
else
|
|
|
|
optdata = (void *)&deftclass;
|
|
|
|
optdatalen = sizeof(int);
|
|
|
|
break;
|
|
|
|
case IPV6_HOPOPTS:
|
|
|
|
if (pktopt && pktopt->ip6po_hbh) {
|
|
|
|
optdata = (void *)pktopt->ip6po_hbh;
|
|
|
|
ip6e = (struct ip6_ext *)pktopt->ip6po_hbh;
|
|
|
|
optdatalen = (ip6e->ip6e_len + 1) << 3;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case IPV6_RTHDR:
|
|
|
|
if (pktopt && pktopt->ip6po_rthdr) {
|
|
|
|
optdata = (void *)pktopt->ip6po_rthdr;
|
|
|
|
ip6e = (struct ip6_ext *)pktopt->ip6po_rthdr;
|
|
|
|
optdatalen = (ip6e->ip6e_len + 1) << 3;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case IPV6_RTHDRDSTOPTS:
|
|
|
|
if (pktopt && pktopt->ip6po_dest1) {
|
|
|
|
optdata = (void *)pktopt->ip6po_dest1;
|
|
|
|
ip6e = (struct ip6_ext *)pktopt->ip6po_dest1;
|
|
|
|
optdatalen = (ip6e->ip6e_len + 1) << 3;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case IPV6_DSTOPTS:
|
|
|
|
if (pktopt && pktopt->ip6po_dest2) {
|
|
|
|
optdata = (void *)pktopt->ip6po_dest2;
|
|
|
|
ip6e = (struct ip6_ext *)pktopt->ip6po_dest2;
|
|
|
|
optdatalen = (ip6e->ip6e_len + 1) << 3;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case IPV6_NEXTHOP:
|
|
|
|
if (pktopt && pktopt->ip6po_nexthop) {
|
|
|
|
optdata = (void *)pktopt->ip6po_nexthop;
|
|
|
|
optdatalen = pktopt->ip6po_nexthop->sa_len;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case IPV6_USE_MIN_MTU:
|
|
|
|
if (pktopt)
|
|
|
|
optdata = (void *)&pktopt->ip6po_minmtu;
|
|
|
|
else
|
|
|
|
optdata = (void *)&defminmtu;
|
|
|
|
optdatalen = sizeof(int);
|
|
|
|
break;
|
|
|
|
case IPV6_DONTFRAG:
|
|
|
|
if (pktopt && ((pktopt->ip6po_flags) & IP6PO_DONTFRAG))
|
|
|
|
on = 1;
|
|
|
|
else
|
|
|
|
on = 0;
|
|
|
|
optdata = (void *)&on;
|
|
|
|
optdatalen = sizeof(on);
|
|
|
|
break;
|
|
|
|
case IPV6_PREFER_TEMPADDR:
|
|
|
|
if (pktopt)
|
|
|
|
optdata = (void *)&pktopt->ip6po_prefer_tempaddr;
|
|
|
|
else
|
|
|
|
optdata = (void *)&defpreftemp;
|
|
|
|
optdatalen = sizeof(int);
|
|
|
|
break;
|
|
|
|
default: /* should not happen */
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
panic("ip6_getpcbopt: unexpected option\n");
|
|
|
|
#endif
|
|
|
|
return (ENOPROTOOPT);
|
|
|
|
}
|
|
|
|
|
|
|
|
error = sooptcopyout(sopt, optdata, optdatalen);
|
|
|
|
|
|
|
|
return (error);
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2003-10-24 18:26:30 +00:00
|
|
|
ip6_clearpktopts(pktopt, optname)
|
2001-06-11 12:39:29 +00:00
|
|
|
struct ip6_pktopts *pktopt;
|
2003-10-24 18:26:30 +00:00
|
|
|
int optname;
|
2001-06-11 12:39:29 +00:00
|
|
|
{
|
2003-10-24 18:26:30 +00:00
|
|
|
int needfree;
|
|
|
|
|
2003-11-24 01:53:36 +00:00
|
|
|
if (pktopt == NULL)
|
|
|
|
return;
|
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
needfree = pktopt->needfree;
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
if (optname == -1 || optname == IPV6_PKTINFO) {
|
2001-06-11 12:39:29 +00:00
|
|
|
if (needfree && pktopt->ip6po_pktinfo)
|
|
|
|
free(pktopt->ip6po_pktinfo, M_IP6OPT);
|
|
|
|
pktopt->ip6po_pktinfo = NULL;
|
|
|
|
}
|
2003-10-24 18:26:30 +00:00
|
|
|
if (optname == -1 || optname == IPV6_HOPLIMIT)
|
2001-06-11 12:39:29 +00:00
|
|
|
pktopt->ip6po_hlim = -1;
|
2003-10-24 18:26:30 +00:00
|
|
|
if (optname == -1 || optname == IPV6_TCLASS)
|
|
|
|
pktopt->ip6po_tclass = -1;
|
|
|
|
if (optname == -1 || optname == IPV6_NEXTHOP) {
|
|
|
|
if (pktopt->ip6po_nextroute.ro_rt) {
|
|
|
|
RTFREE(pktopt->ip6po_nextroute.ro_rt);
|
|
|
|
pktopt->ip6po_nextroute.ro_rt = NULL;
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
if (needfree && pktopt->ip6po_nexthop)
|
|
|
|
free(pktopt->ip6po_nexthop, M_IP6OPT);
|
|
|
|
pktopt->ip6po_nexthop = NULL;
|
|
|
|
}
|
2003-10-24 18:26:30 +00:00
|
|
|
if (optname == -1 || optname == IPV6_HOPOPTS) {
|
2001-06-11 12:39:29 +00:00
|
|
|
if (needfree && pktopt->ip6po_hbh)
|
|
|
|
free(pktopt->ip6po_hbh, M_IP6OPT);
|
|
|
|
pktopt->ip6po_hbh = NULL;
|
|
|
|
}
|
2003-10-24 18:26:30 +00:00
|
|
|
if (optname == -1 || optname == IPV6_RTHDRDSTOPTS) {
|
2001-06-11 12:39:29 +00:00
|
|
|
if (needfree && pktopt->ip6po_dest1)
|
|
|
|
free(pktopt->ip6po_dest1, M_IP6OPT);
|
|
|
|
pktopt->ip6po_dest1 = NULL;
|
|
|
|
}
|
2003-10-24 18:26:30 +00:00
|
|
|
if (optname == -1 || optname == IPV6_RTHDR) {
|
2001-06-11 12:39:29 +00:00
|
|
|
if (needfree && pktopt->ip6po_rhinfo.ip6po_rhi_rthdr)
|
|
|
|
free(pktopt->ip6po_rhinfo.ip6po_rhi_rthdr, M_IP6OPT);
|
|
|
|
pktopt->ip6po_rhinfo.ip6po_rhi_rthdr = NULL;
|
|
|
|
if (pktopt->ip6po_route.ro_rt) {
|
|
|
|
RTFREE(pktopt->ip6po_route.ro_rt);
|
|
|
|
pktopt->ip6po_route.ro_rt = NULL;
|
|
|
|
}
|
|
|
|
}
|
2003-10-24 18:26:30 +00:00
|
|
|
if (optname == -1 || optname == IPV6_DSTOPTS) {
|
2001-06-11 12:39:29 +00:00
|
|
|
if (needfree && pktopt->ip6po_dest2)
|
|
|
|
free(pktopt->ip6po_dest2, M_IP6OPT);
|
|
|
|
pktopt->ip6po_dest2 = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#define PKTOPT_EXTHDRCPY(type) \
|
|
|
|
do {\
|
|
|
|
if (src->type) {\
|
2003-10-08 18:26:08 +00:00
|
|
|
int hlen = (((struct ip6_ext *)src->type)->ip6e_len + 1) << 3;\
|
2001-06-11 12:39:29 +00:00
|
|
|
dst->type = malloc(hlen, M_IP6OPT, canwait);\
|
|
|
|
if (dst->type == NULL && canwait == M_NOWAIT)\
|
|
|
|
goto bad;\
|
|
|
|
bcopy(src->type, dst->type, hlen);\
|
|
|
|
}\
|
2003-10-08 18:26:08 +00:00
|
|
|
} while (/*CONSTCOND*/ 0)
|
2001-06-11 12:39:29 +00:00
|
|
|
|
|
|
|
struct ip6_pktopts *
|
|
|
|
ip6_copypktopts(src, canwait)
|
|
|
|
struct ip6_pktopts *src;
|
|
|
|
int canwait;
|
|
|
|
{
|
|
|
|
struct ip6_pktopts *dst;
|
|
|
|
|
|
|
|
if (src == NULL) {
|
|
|
|
printf("ip6_clearpktopts: invalid argument\n");
|
2003-10-06 14:02:09 +00:00
|
|
|
return (NULL);
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
dst = malloc(sizeof(*dst), M_IP6OPT, canwait);
|
|
|
|
if (dst == NULL && canwait == M_NOWAIT)
|
2002-10-31 19:45:48 +00:00
|
|
|
return (NULL);
|
2001-06-11 12:39:29 +00:00
|
|
|
bzero(dst, sizeof(*dst));
|
2003-10-24 18:26:30 +00:00
|
|
|
dst->needfree = 1;
|
2001-06-11 12:39:29 +00:00
|
|
|
|
|
|
|
dst->ip6po_hlim = src->ip6po_hlim;
|
2003-10-24 18:26:30 +00:00
|
|
|
dst->ip6po_tclass = src->ip6po_tclass;
|
|
|
|
dst->ip6po_flags = src->ip6po_flags;
|
2001-06-11 12:39:29 +00:00
|
|
|
if (src->ip6po_pktinfo) {
|
|
|
|
dst->ip6po_pktinfo = malloc(sizeof(*dst->ip6po_pktinfo),
|
2003-10-08 18:26:08 +00:00
|
|
|
M_IP6OPT, canwait);
|
2001-06-11 12:39:29 +00:00
|
|
|
if (dst->ip6po_pktinfo == NULL && canwait == M_NOWAIT)
|
|
|
|
goto bad;
|
|
|
|
*dst->ip6po_pktinfo = *src->ip6po_pktinfo;
|
|
|
|
}
|
|
|
|
if (src->ip6po_nexthop) {
|
|
|
|
dst->ip6po_nexthop = malloc(src->ip6po_nexthop->sa_len,
|
2003-10-08 18:26:08 +00:00
|
|
|
M_IP6OPT, canwait);
|
2001-06-11 12:39:29 +00:00
|
|
|
if (dst->ip6po_nexthop == NULL && canwait == M_NOWAIT)
|
|
|
|
goto bad;
|
|
|
|
bcopy(src->ip6po_nexthop, dst->ip6po_nexthop,
|
2003-10-08 18:26:08 +00:00
|
|
|
src->ip6po_nexthop->sa_len);
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
|
|
|
PKTOPT_EXTHDRCPY(ip6po_hbh);
|
|
|
|
PKTOPT_EXTHDRCPY(ip6po_dest1);
|
|
|
|
PKTOPT_EXTHDRCPY(ip6po_dest2);
|
|
|
|
PKTOPT_EXTHDRCPY(ip6po_rthdr); /* not copy the cached route */
|
2003-10-06 14:02:09 +00:00
|
|
|
return (dst);
|
2001-06-11 12:39:29 +00:00
|
|
|
|
|
|
|
bad:
|
|
|
|
if (dst->ip6po_pktinfo) free(dst->ip6po_pktinfo, M_IP6OPT);
|
|
|
|
if (dst->ip6po_nexthop) free(dst->ip6po_nexthop, M_IP6OPT);
|
|
|
|
if (dst->ip6po_hbh) free(dst->ip6po_hbh, M_IP6OPT);
|
|
|
|
if (dst->ip6po_dest1) free(dst->ip6po_dest1, M_IP6OPT);
|
|
|
|
if (dst->ip6po_dest2) free(dst->ip6po_dest2, M_IP6OPT);
|
|
|
|
if (dst->ip6po_rthdr) free(dst->ip6po_rthdr, M_IP6OPT);
|
2002-10-31 19:45:48 +00:00
|
|
|
free(dst, M_IP6OPT);
|
2003-10-06 14:02:09 +00:00
|
|
|
return (NULL);
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
|
|
|
#undef PKTOPT_EXTHDRCPY
|
|
|
|
|
|
|
|
void
|
|
|
|
ip6_freepcbopts(pktopt)
|
|
|
|
struct ip6_pktopts *pktopt;
|
|
|
|
{
|
|
|
|
if (pktopt == NULL)
|
|
|
|
return;
|
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
ip6_clearpktopts(pktopt, -1);
|
2001-06-11 12:39:29 +00:00
|
|
|
|
|
|
|
free(pktopt, M_IP6OPT);
|
|
|
|
}
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
|
|
|
* Set the IP6 multicast options in response to user setsockopt().
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
ip6_setmoptions(optname, im6op, m)
|
|
|
|
int optname;
|
|
|
|
struct ip6_moptions **im6op;
|
|
|
|
struct mbuf *m;
|
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
u_int loop, ifindex;
|
|
|
|
struct ipv6_mreq *mreq;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
struct ip6_moptions *im6o = *im6op;
|
|
|
|
struct route_in6 ro;
|
|
|
|
struct sockaddr_in6 *dst;
|
|
|
|
struct in6_multi_mship *imm;
|
2003-10-08 18:26:08 +00:00
|
|
|
struct thread *td = curthread;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
if (im6o == NULL) {
|
|
|
|
/*
|
|
|
|
* No multicast option buffer attached to the pcb;
|
|
|
|
* allocate one and initialize to default values.
|
|
|
|
*/
|
|
|
|
im6o = (struct ip6_moptions *)
|
2003-02-19 05:47:46 +00:00
|
|
|
malloc(sizeof(*im6o), M_IPMOPTS, M_WAITOK);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
if (im6o == NULL)
|
2003-10-06 14:02:09 +00:00
|
|
|
return (ENOBUFS);
|
1999-11-22 02:45:11 +00:00
|
|
|
*im6op = im6o;
|
|
|
|
im6o->im6o_multicast_ifp = NULL;
|
|
|
|
im6o->im6o_multicast_hlim = ip6_defmcasthlim;
|
|
|
|
im6o->im6o_multicast_loop = IPV6_DEFAULT_MULTICAST_LOOP;
|
|
|
|
LIST_INIT(&im6o->im6o_memberships);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (optname) {
|
|
|
|
|
|
|
|
case IPV6_MULTICAST_IF:
|
|
|
|
/*
|
|
|
|
* Select the interface for outgoing multicast packets.
|
|
|
|
*/
|
|
|
|
if (m == NULL || m->m_len != sizeof(u_int)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
bcopy(mtod(m, u_int *), &ifindex, sizeof(ifindex));
|
1999-11-22 02:45:11 +00:00
|
|
|
if (ifindex < 0 || if_index < ifindex) {
|
|
|
|
error = ENXIO; /* XXX EINVAL? */
|
|
|
|
break;
|
|
|
|
}
|
2001-09-06 02:40:43 +00:00
|
|
|
ifp = ifnet_byindex(ifindex);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
|
|
|
|
error = EADDRNOTAVAIL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
im6o->im6o_multicast_ifp = ifp;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_MULTICAST_HOPS:
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Set the IP6 hoplimit for outgoing multicast packets.
|
|
|
|
*/
|
|
|
|
int optval;
|
|
|
|
if (m == NULL || m->m_len != sizeof(int)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
bcopy(mtod(m, u_int *), &optval, sizeof(optval));
|
1999-11-22 02:45:11 +00:00
|
|
|
if (optval < -1 || optval >= 256)
|
|
|
|
error = EINVAL;
|
|
|
|
else if (optval == -1)
|
|
|
|
im6o->im6o_multicast_hlim = ip6_defmcasthlim;
|
|
|
|
else
|
|
|
|
im6o->im6o_multicast_hlim = optval;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case IPV6_MULTICAST_LOOP:
|
|
|
|
/*
|
|
|
|
* Set the loopback flag for outgoing multicast packets.
|
|
|
|
* Must be zero or one.
|
|
|
|
*/
|
2001-06-11 12:39:29 +00:00
|
|
|
if (m == NULL || m->m_len != sizeof(u_int)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
bcopy(mtod(m, u_int *), &loop, sizeof(loop));
|
|
|
|
if (loop > 1) {
|
1999-11-22 02:45:11 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
im6o->im6o_multicast_loop = loop;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_JOIN_GROUP:
|
|
|
|
/*
|
|
|
|
* Add a multicast group membership.
|
|
|
|
* Group must be a valid IP6 multicast address.
|
|
|
|
*/
|
|
|
|
if (m == NULL || m->m_len != sizeof(struct ipv6_mreq)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mreq = mtod(m, struct ipv6_mreq *);
|
|
|
|
if (IN6_IS_ADDR_UNSPECIFIED(&mreq->ipv6mr_multiaddr)) {
|
|
|
|
/*
|
|
|
|
* We use the unspecified address to specify to accept
|
|
|
|
* all multicast addresses. Only super user is allowed
|
|
|
|
* to do this.
|
|
|
|
*/
|
2003-10-08 18:26:08 +00:00
|
|
|
if (suser(td)) {
|
1999-11-22 02:45:11 +00:00
|
|
|
error = EACCES;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else if (!IN6_IS_ADDR_MULTICAST(&mreq->ipv6mr_multiaddr)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the interface is specified, validate it.
|
|
|
|
*/
|
2003-11-06 16:42:59 +00:00
|
|
|
if (mreq->ipv6mr_interface < 0 ||
|
|
|
|
if_index < mreq->ipv6mr_interface) {
|
1999-11-22 02:45:11 +00:00
|
|
|
error = ENXIO; /* XXX EINVAL? */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If no interface was explicitly specified, choose an
|
|
|
|
* appropriate one according to the given multicast address.
|
|
|
|
*/
|
|
|
|
if (mreq->ipv6mr_interface == 0) {
|
|
|
|
/*
|
|
|
|
* If the multicast address is in node-local scope,
|
|
|
|
* the interface should be a loopback interface.
|
|
|
|
* Otherwise, look up the routing table for the
|
|
|
|
* address, and choose the outgoing interface.
|
|
|
|
* XXX: is it a good approach?
|
|
|
|
*/
|
2003-10-21 20:05:32 +00:00
|
|
|
if (IN6_IS_ADDR_MC_INTFACELOCAL(&mreq->ipv6mr_multiaddr)) {
|
1999-11-22 02:45:11 +00:00
|
|
|
ifp = &loif[0];
|
|
|
|
} else {
|
|
|
|
ro.ro_rt = NULL;
|
|
|
|
dst = (struct sockaddr_in6 *)&ro.ro_dst;
|
|
|
|
bzero(dst, sizeof(*dst));
|
|
|
|
dst->sin6_len = sizeof(struct sockaddr_in6);
|
|
|
|
dst->sin6_family = AF_INET6;
|
|
|
|
dst->sin6_addr = mreq->ipv6mr_multiaddr;
|
|
|
|
rtalloc((struct route *)&ro);
|
|
|
|
if (ro.ro_rt == NULL) {
|
|
|
|
error = EADDRNOTAVAIL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ifp = ro.ro_rt->rt_ifp;
|
2003-10-04 03:44:50 +00:00
|
|
|
RTFREE(ro.ro_rt);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
} else
|
2001-09-06 02:40:43 +00:00
|
|
|
ifp = ifnet_byindex(mreq->ipv6mr_interface);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* See if we found an interface, and confirm that it
|
|
|
|
* supports multicast
|
|
|
|
*/
|
|
|
|
if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
|
|
|
|
error = EADDRNOTAVAIL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Put interface index into the multicast address,
|
|
|
|
* if the address has link-local scope.
|
|
|
|
*/
|
|
|
|
if (IN6_IS_ADDR_MC_LINKLOCAL(&mreq->ipv6mr_multiaddr)) {
|
2003-11-06 16:42:59 +00:00
|
|
|
mreq->ipv6mr_multiaddr.s6_addr16[1] =
|
|
|
|
htons(ifp->if_index);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* See if the membership already exists.
|
|
|
|
*/
|
2000-07-04 16:35:15 +00:00
|
|
|
for (imm = im6o->im6o_memberships.lh_first;
|
|
|
|
imm != NULL; imm = imm->i6mm_chain.le_next)
|
1999-11-22 02:45:11 +00:00
|
|
|
if (imm->i6mm_maddr->in6m_ifp == ifp &&
|
|
|
|
IN6_ARE_ADDR_EQUAL(&imm->i6mm_maddr->in6m_addr,
|
|
|
|
&mreq->ipv6mr_multiaddr))
|
|
|
|
break;
|
|
|
|
if (imm != NULL) {
|
|
|
|
error = EADDRINUSE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Everything looks good; add a new record to the multicast
|
|
|
|
* address list for the given interface.
|
|
|
|
*/
|
2003-02-19 05:47:46 +00:00
|
|
|
imm = malloc(sizeof(*imm), M_IPMADDR, M_WAITOK);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (imm == NULL) {
|
|
|
|
error = ENOBUFS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((imm->i6mm_maddr =
|
|
|
|
in6_addmulti(&mreq->ipv6mr_multiaddr, ifp, &error)) == NULL) {
|
|
|
|
free(imm, M_IPMADDR);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
LIST_INSERT_HEAD(&im6o->im6o_memberships, imm, i6mm_chain);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_LEAVE_GROUP:
|
|
|
|
/*
|
|
|
|
* Drop a multicast group membership.
|
|
|
|
* Group must be a valid IP6 multicast address.
|
|
|
|
*/
|
|
|
|
if (m == NULL || m->m_len != sizeof(struct ipv6_mreq)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mreq = mtod(m, struct ipv6_mreq *);
|
|
|
|
if (IN6_IS_ADDR_UNSPECIFIED(&mreq->ipv6mr_multiaddr)) {
|
2002-04-01 21:31:13 +00:00
|
|
|
if (suser(td)) {
|
1999-11-22 02:45:11 +00:00
|
|
|
error = EACCES;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else if (!IN6_IS_ADDR_MULTICAST(&mreq->ipv6mr_multiaddr)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If an interface address was specified, get a pointer
|
|
|
|
* to its ifnet structure.
|
|
|
|
*/
|
|
|
|
if (mreq->ipv6mr_interface < 0
|
|
|
|
|| if_index < mreq->ipv6mr_interface) {
|
|
|
|
error = ENXIO; /* XXX EINVAL? */
|
|
|
|
break;
|
|
|
|
}
|
2001-09-06 02:40:43 +00:00
|
|
|
ifp = ifnet_byindex(mreq->ipv6mr_interface);
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
|
|
|
* Put interface index into the multicast address,
|
|
|
|
* if the address has link-local scope.
|
|
|
|
*/
|
|
|
|
if (IN6_IS_ADDR_MC_LINKLOCAL(&mreq->ipv6mr_multiaddr)) {
|
|
|
|
mreq->ipv6mr_multiaddr.s6_addr16[1]
|
|
|
|
= htons(mreq->ipv6mr_interface);
|
|
|
|
}
|
2003-10-08 18:26:08 +00:00
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
|
|
|
* Find the membership in the membership list.
|
|
|
|
*/
|
2000-07-04 16:35:15 +00:00
|
|
|
for (imm = im6o->im6o_memberships.lh_first;
|
|
|
|
imm != NULL; imm = imm->i6mm_chain.le_next) {
|
2003-10-08 18:26:08 +00:00
|
|
|
if ((ifp == NULL || imm->i6mm_maddr->in6m_ifp == ifp) &&
|
1999-11-22 02:45:11 +00:00
|
|
|
IN6_ARE_ADDR_EQUAL(&imm->i6mm_maddr->in6m_addr,
|
2003-10-08 18:26:08 +00:00
|
|
|
&mreq->ipv6mr_multiaddr))
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (imm == NULL) {
|
|
|
|
/* Unable to resolve interface */
|
|
|
|
error = EADDRNOTAVAIL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Give up the multicast address record to which the
|
|
|
|
* membership points.
|
|
|
|
*/
|
|
|
|
LIST_REMOVE(imm, i6mm_chain);
|
|
|
|
in6_delmulti(imm->i6mm_maddr);
|
|
|
|
free(imm, M_IPMADDR);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
error = EOPNOTSUPP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If all options have default values, no need to keep the mbuf.
|
|
|
|
*/
|
|
|
|
if (im6o->im6o_multicast_ifp == NULL &&
|
|
|
|
im6o->im6o_multicast_hlim == ip6_defmcasthlim &&
|
|
|
|
im6o->im6o_multicast_loop == IPV6_DEFAULT_MULTICAST_LOOP &&
|
2000-07-04 16:35:15 +00:00
|
|
|
im6o->im6o_memberships.lh_first == NULL) {
|
1999-11-22 02:45:11 +00:00
|
|
|
free(*im6op, M_IPMOPTS);
|
|
|
|
*im6op = NULL;
|
|
|
|
}
|
|
|
|
|
2003-10-06 14:02:09 +00:00
|
|
|
return (error);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the IP6 multicast options in response to user getsockopt().
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
ip6_getmoptions(optname, im6o, mp)
|
|
|
|
int optname;
|
2001-06-11 12:39:29 +00:00
|
|
|
struct ip6_moptions *im6o;
|
|
|
|
struct mbuf **mp;
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
|
|
|
u_int *hlim, *loop, *ifindex;
|
|
|
|
|
2003-02-19 05:47:46 +00:00
|
|
|
*mp = m_get(M_TRYWAIT, MT_HEADER); /* XXX */
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
switch (optname) {
|
|
|
|
|
|
|
|
case IPV6_MULTICAST_IF:
|
|
|
|
ifindex = mtod(*mp, u_int *);
|
|
|
|
(*mp)->m_len = sizeof(u_int);
|
|
|
|
if (im6o == NULL || im6o->im6o_multicast_ifp == NULL)
|
|
|
|
*ifindex = 0;
|
|
|
|
else
|
|
|
|
*ifindex = im6o->im6o_multicast_ifp->if_index;
|
2003-10-06 14:02:09 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
case IPV6_MULTICAST_HOPS:
|
|
|
|
hlim = mtod(*mp, u_int *);
|
|
|
|
(*mp)->m_len = sizeof(u_int);
|
|
|
|
if (im6o == NULL)
|
|
|
|
*hlim = ip6_defmcasthlim;
|
|
|
|
else
|
|
|
|
*hlim = im6o->im6o_multicast_hlim;
|
2003-10-06 14:02:09 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
case IPV6_MULTICAST_LOOP:
|
|
|
|
loop = mtod(*mp, u_int *);
|
|
|
|
(*mp)->m_len = sizeof(u_int);
|
|
|
|
if (im6o == NULL)
|
|
|
|
*loop = ip6_defmcasthlim;
|
|
|
|
else
|
|
|
|
*loop = im6o->im6o_multicast_loop;
|
2003-10-06 14:02:09 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
default:
|
2003-10-06 14:02:09 +00:00
|
|
|
return (EOPNOTSUPP);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Discard the IP6 multicast options.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ip6_freemoptions(im6o)
|
2001-06-11 12:39:29 +00:00
|
|
|
struct ip6_moptions *im6o;
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
|
|
|
struct in6_multi_mship *imm;
|
|
|
|
|
|
|
|
if (im6o == NULL)
|
|
|
|
return;
|
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
while ((imm = im6o->im6o_memberships.lh_first) != NULL) {
|
1999-11-22 02:45:11 +00:00
|
|
|
LIST_REMOVE(imm, i6mm_chain);
|
|
|
|
if (imm->i6mm_maddr)
|
|
|
|
in6_delmulti(imm->i6mm_maddr);
|
|
|
|
free(imm, M_IPMADDR);
|
|
|
|
}
|
|
|
|
free(im6o, M_IPMOPTS);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set IPv6 outgoing packet options based on advanced API.
|
|
|
|
*/
|
|
|
|
int
|
2003-10-24 18:26:30 +00:00
|
|
|
ip6_setpktoptions(control, opt, stickyopt, priv, needcopy, uproto)
|
1999-11-22 02:45:11 +00:00
|
|
|
struct mbuf *control;
|
2003-10-24 18:26:30 +00:00
|
|
|
struct ip6_pktopts *opt, *stickyopt;
|
|
|
|
int priv, needcopy, uproto;
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
2001-06-11 12:39:29 +00:00
|
|
|
struct cmsghdr *cm = 0;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
if (control == 0 || opt == 0)
|
2003-10-06 14:02:09 +00:00
|
|
|
return (EINVAL);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
if (stickyopt) {
|
|
|
|
/*
|
|
|
|
* If stickyopt is provided, make a local copy of the options
|
|
|
|
* for this particular packet, then override them by ancillary
|
|
|
|
* objects.
|
|
|
|
* XXX: need to gain a reference for the cached route of the
|
|
|
|
* next hop in case of the overriding.
|
|
|
|
*/
|
|
|
|
*opt = *stickyopt;
|
|
|
|
if (opt->ip6po_nextroute.ro_rt) {
|
|
|
|
RT_LOCK(opt->ip6po_nextroute.ro_rt);
|
2003-11-08 23:36:32 +00:00
|
|
|
RT_ADDREF(opt->ip6po_nextroute.ro_rt);
|
2003-10-24 18:26:30 +00:00
|
|
|
RT_UNLOCK(opt->ip6po_nextroute.ro_rt);
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
init_ip6pktopts(opt);
|
|
|
|
opt->needfree = needcopy;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX: Currently, we assume all the optional information is stored
|
|
|
|
* in a single mbuf.
|
|
|
|
*/
|
|
|
|
if (control->m_next)
|
2003-10-06 14:02:09 +00:00
|
|
|
return (EINVAL);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
for (; control->m_len; control->m_data += CMSG_ALIGN(cm->cmsg_len),
|
2003-10-08 18:26:08 +00:00
|
|
|
control->m_len -= CMSG_ALIGN(cm->cmsg_len)) {
|
2003-10-24 18:26:30 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
if (control->m_len < CMSG_LEN(0))
|
|
|
|
return (EINVAL);
|
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
cm = mtod(control, struct cmsghdr *);
|
|
|
|
if (cm->cmsg_len == 0 || cm->cmsg_len > control->m_len)
|
2003-10-06 14:02:09 +00:00
|
|
|
return (EINVAL);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (cm->cmsg_level != IPPROTO_IPV6)
|
|
|
|
continue;
|
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
error = ip6_setpktoption(cm->cmsg_type, CMSG_DATA(cm),
|
|
|
|
cm->cmsg_len - CMSG_LEN(0), opt, priv, needcopy, 1, uproto);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set a particular packet option, as a sticky option or an ancillary data
|
|
|
|
* item. "len" can be 0 only when it's a sticky option.
|
|
|
|
* We have 4 cases of combination of "sticky" and "cmsg":
|
|
|
|
* "sticky=0, cmsg=0": impossible
|
|
|
|
* "sticky=0, cmsg=1": RFC2292 or rfc2292bis ancillary data
|
|
|
|
* "sticky=1, cmsg=0": rfc2292bis socket option
|
|
|
|
* "sticky=1, cmsg=1": RFC2292 socket option
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
ip6_setpktoption(optname, buf, len, opt, priv, sticky, cmsg, uproto)
|
|
|
|
int optname, len, priv, sticky, cmsg, uproto;
|
|
|
|
u_char *buf;
|
|
|
|
struct ip6_pktopts *opt;
|
|
|
|
{
|
|
|
|
int minmtupolicy, preftemp;
|
|
|
|
|
|
|
|
if (!sticky && !cmsg) {
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
printf("ip6_setpktoption: impossible case\n");
|
|
|
|
#endif
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IPV6_2292xxx is for backward compatibility to RFC2292, and should
|
|
|
|
* not be specified in the context of rfc2292bis. Conversely,
|
|
|
|
* rfc2292bis types should not be specified in the context of RFC2292.
|
|
|
|
*/
|
|
|
|
if (!cmsg) {
|
|
|
|
switch (optname) {
|
|
|
|
case IPV6_2292PKTINFO:
|
|
|
|
case IPV6_2292HOPLIMIT:
|
|
|
|
case IPV6_2292NEXTHOP:
|
|
|
|
case IPV6_2292HOPOPTS:
|
|
|
|
case IPV6_2292DSTOPTS:
|
|
|
|
case IPV6_2292RTHDR:
|
|
|
|
case IPV6_2292PKTOPTIONS:
|
|
|
|
return (ENOPROTOOPT);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (sticky && cmsg) {
|
|
|
|
switch (optname) {
|
|
|
|
case IPV6_PKTINFO:
|
|
|
|
case IPV6_HOPLIMIT:
|
|
|
|
case IPV6_NEXTHOP:
|
|
|
|
case IPV6_HOPOPTS:
|
|
|
|
case IPV6_DSTOPTS:
|
|
|
|
case IPV6_RTHDRDSTOPTS:
|
|
|
|
case IPV6_RTHDR:
|
|
|
|
case IPV6_USE_MIN_MTU:
|
|
|
|
case IPV6_DONTFRAG:
|
|
|
|
case IPV6_TCLASS:
|
|
|
|
case IPV6_PREFER_TEMPADDR: /* XXX: not an rfc2292bis option */
|
|
|
|
return (ENOPROTOOPT);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (optname) {
|
|
|
|
case IPV6_2292PKTINFO:
|
|
|
|
case IPV6_PKTINFO:
|
|
|
|
{
|
|
|
|
struct ifnet *ifp = NULL;
|
|
|
|
struct in6_pktinfo *pktinfo;
|
|
|
|
|
|
|
|
if (len != sizeof(struct in6_pktinfo))
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
pktinfo = (struct in6_pktinfo *)buf;
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
/*
|
2003-10-24 18:26:30 +00:00
|
|
|
* An application can clear any sticky IPV6_PKTINFO option by
|
|
|
|
* doing a "regular" setsockopt with ipi6_addr being
|
|
|
|
* in6addr_any and ipi6_ifindex being zero.
|
|
|
|
* [RFC 3542, Section 6]
|
2001-06-11 12:39:29 +00:00
|
|
|
*/
|
2003-10-24 18:26:30 +00:00
|
|
|
if (optname == IPV6_PKTINFO && opt->ip6po_pktinfo &&
|
|
|
|
pktinfo->ipi6_ifindex == 0 &&
|
|
|
|
IN6_IS_ADDR_UNSPECIFIED(&pktinfo->ipi6_addr)) {
|
|
|
|
ip6_clearpktopts(opt, optname);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (uproto == IPPROTO_TCP && optname == IPV6_PKTINFO &&
|
|
|
|
sticky && !IN6_IS_ADDR_UNSPECIFIED(&pktinfo->ipi6_addr)) {
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* validate the interface index if specified. */
|
|
|
|
if (pktinfo->ipi6_ifindex > if_index ||
|
|
|
|
pktinfo->ipi6_ifindex < 0) {
|
|
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
if (pktinfo->ipi6_ifindex) {
|
|
|
|
ifp = ifnet_byindex(pktinfo->ipi6_ifindex);
|
|
|
|
if (ifp == NULL)
|
2003-10-06 14:02:09 +00:00
|
|
|
return (ENXIO);
|
2003-10-24 18:26:30 +00:00
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
/*
|
|
|
|
* We store the address anyway, and let in6_selectsrc()
|
|
|
|
* validate the specified address. This is because ipi6_addr
|
|
|
|
* may not have enough information about its scope zone, and
|
|
|
|
* we may need additional information (such as outgoing
|
|
|
|
* interface or the scope zone of a destination address) to
|
|
|
|
* disambiguate the scope.
|
|
|
|
* XXX: the delay of the validation may confuse the
|
|
|
|
* application when it is used as a sticky option.
|
|
|
|
*/
|
|
|
|
if (sticky) {
|
|
|
|
if (opt->ip6po_pktinfo == NULL) {
|
|
|
|
opt->ip6po_pktinfo = malloc(sizeof(*pktinfo),
|
|
|
|
M_IP6OPT, M_WAITOK);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
2003-10-24 18:26:30 +00:00
|
|
|
bcopy(pktinfo, opt->ip6po_pktinfo, sizeof(*pktinfo));
|
|
|
|
} else
|
|
|
|
opt->ip6po_pktinfo = pktinfo;
|
|
|
|
break;
|
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_2292HOPLIMIT:
|
|
|
|
case IPV6_HOPLIMIT:
|
|
|
|
{
|
|
|
|
int *hlimp;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
/*
|
|
|
|
* RFC 3542 deprecated the usage of sticky IPV6_HOPLIMIT
|
|
|
|
* to simplify the ordering among hoplimit options.
|
|
|
|
*/
|
|
|
|
if (optname == IPV6_HOPLIMIT && sticky)
|
|
|
|
return (ENOPROTOOPT);
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
if (len != sizeof(int))
|
|
|
|
return (EINVAL);
|
|
|
|
hlimp = (int *)buf;
|
|
|
|
if (*hlimp < -1 || *hlimp > 255)
|
|
|
|
return (EINVAL);
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
opt->ip6po_hlim = *hlimp;
|
|
|
|
break;
|
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_TCLASS:
|
|
|
|
{
|
|
|
|
int tclass;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
if (len != sizeof(int))
|
|
|
|
return (EINVAL);
|
|
|
|
tclass = *(int *)buf;
|
|
|
|
if (tclass < -1 || tclass > 255)
|
|
|
|
return (EINVAL);
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
opt->ip6po_tclass = tclass;
|
|
|
|
break;
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_2292NEXTHOP:
|
|
|
|
case IPV6_NEXTHOP:
|
|
|
|
if (!priv)
|
|
|
|
return (EPERM);
|
|
|
|
|
|
|
|
if (len == 0) { /* just remove the option */
|
|
|
|
ip6_clearpktopts(opt, IPV6_NEXTHOP);
|
1999-11-22 02:45:11 +00:00
|
|
|
break;
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
/* check if cmsg_len is large enough for sa_len */
|
|
|
|
if (len < sizeof(struct sockaddr) || len < *buf)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
switch (((struct sockaddr *)buf)->sa_family) {
|
|
|
|
case AF_INET6:
|
2001-06-11 12:39:29 +00:00
|
|
|
{
|
2003-10-24 18:26:30 +00:00
|
|
|
struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)buf;
|
|
|
|
#if 0
|
|
|
|
int error;
|
|
|
|
#endif
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
if (sa6->sin6_len != sizeof(struct sockaddr_in6))
|
2003-10-06 14:02:09 +00:00
|
|
|
return (EINVAL);
|
2003-10-24 18:26:30 +00:00
|
|
|
|
|
|
|
if (IN6_IS_ADDR_UNSPECIFIED(&sa6->sin6_addr) ||
|
|
|
|
IN6_IS_ADDR_MULTICAST(&sa6->sin6_addr)) {
|
2003-10-06 14:02:09 +00:00
|
|
|
return (EINVAL);
|
2003-10-24 18:26:30 +00:00
|
|
|
}
|
|
|
|
#if 0
|
|
|
|
if ((error = scope6_check_id(sa6, ip6_use_defzone))
|
|
|
|
!= 0) {
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
sa6->sin6_scope_id = 0; /* XXX */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case AF_LINK: /* should eventually be supported */
|
|
|
|
default:
|
|
|
|
return (EAFNOSUPPORT);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* turn off the previous option, then set the new option. */
|
|
|
|
ip6_clearpktopts(opt, IPV6_NEXTHOP);
|
|
|
|
if (sticky) {
|
|
|
|
opt->ip6po_nexthop = malloc(*buf, M_IP6OPT, M_WAITOK);
|
|
|
|
bcopy(buf, opt->ip6po_nexthop, *buf);
|
|
|
|
} else
|
|
|
|
opt->ip6po_nexthop = (struct sockaddr *)buf;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_2292HOPOPTS:
|
|
|
|
case IPV6_HOPOPTS:
|
|
|
|
{
|
|
|
|
struct ip6_hbh *hbh;
|
|
|
|
int hbhlen;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX: We don't allow a non-privileged user to set ANY HbH
|
|
|
|
* options, since per-option restriction has too much
|
|
|
|
* overhead.
|
|
|
|
*/
|
|
|
|
if (!priv)
|
|
|
|
return (EPERM);
|
|
|
|
|
|
|
|
if (len == 0) {
|
|
|
|
ip6_clearpktopts(opt, IPV6_HOPOPTS);
|
|
|
|
break; /* just remove the option */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* message length validation */
|
|
|
|
if (len < sizeof(struct ip6_hbh))
|
|
|
|
return (EINVAL);
|
|
|
|
hbh = (struct ip6_hbh *)buf;
|
|
|
|
hbhlen = (hbh->ip6h_len + 1) << 3;
|
|
|
|
if (len != hbhlen)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
/* turn off the previous option, then set the new option. */
|
|
|
|
ip6_clearpktopts(opt, IPV6_HOPOPTS);
|
|
|
|
if (sticky) {
|
|
|
|
opt->ip6po_hbh = malloc(hbhlen, M_IP6OPT, M_WAITOK);
|
|
|
|
bcopy(hbh, opt->ip6po_hbh, hbhlen);
|
|
|
|
} else
|
|
|
|
opt->ip6po_hbh = hbh;
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case IPV6_2292DSTOPTS:
|
|
|
|
case IPV6_DSTOPTS:
|
|
|
|
case IPV6_RTHDRDSTOPTS:
|
|
|
|
{
|
|
|
|
struct ip6_dest *dest, **newdest = NULL;
|
|
|
|
int destlen;
|
|
|
|
|
|
|
|
if (!priv) /* XXX: see the comment for IPV6_HOPOPTS */
|
|
|
|
return (EPERM);
|
|
|
|
|
|
|
|
if (len == 0) {
|
|
|
|
ip6_clearpktopts(opt, optname);
|
|
|
|
break; /* just remove the option */
|
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
/* message length validation */
|
|
|
|
if (len < sizeof(struct ip6_dest))
|
|
|
|
return (EINVAL);
|
|
|
|
dest = (struct ip6_dest *)buf;
|
|
|
|
destlen = (dest->ip6d_len + 1) << 3;
|
|
|
|
if (len != destlen)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine the position that the destination options header
|
|
|
|
* should be inserted; before or after the routing header.
|
|
|
|
*/
|
|
|
|
switch (optname) {
|
|
|
|
case IPV6_2292DSTOPTS:
|
|
|
|
/*
|
|
|
|
* The old advacned API is ambiguous on this point.
|
|
|
|
* Our approach is to determine the position based
|
|
|
|
* according to the existence of a routing header.
|
|
|
|
* Note, however, that this depends on the order of the
|
|
|
|
* extension headers in the ancillary data; the 1st
|
|
|
|
* part of the destination options header must appear
|
|
|
|
* before the routing header in the ancillary data,
|
|
|
|
* too.
|
|
|
|
* RFC2292bis solved the ambiguity by introducing
|
|
|
|
* separate ancillary data or option types.
|
1999-11-22 02:45:11 +00:00
|
|
|
*/
|
2001-06-11 12:39:29 +00:00
|
|
|
if (opt->ip6po_rthdr == NULL)
|
|
|
|
newdest = &opt->ip6po_dest1;
|
|
|
|
else
|
|
|
|
newdest = &opt->ip6po_dest2;
|
2003-10-24 18:26:30 +00:00
|
|
|
break;
|
|
|
|
case IPV6_RTHDRDSTOPTS:
|
|
|
|
newdest = &opt->ip6po_dest1;
|
|
|
|
break;
|
|
|
|
case IPV6_DSTOPTS:
|
|
|
|
newdest = &opt->ip6po_dest2;
|
|
|
|
break;
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
/* turn off the previous option, then set the new option. */
|
|
|
|
ip6_clearpktopts(opt, optname);
|
|
|
|
if (sticky) {
|
|
|
|
*newdest = malloc(destlen, M_IP6OPT, M_WAITOK);
|
|
|
|
bcopy(dest, *newdest, destlen);
|
|
|
|
} else
|
|
|
|
*newdest = dest;
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case IPV6_2292RTHDR:
|
|
|
|
case IPV6_RTHDR:
|
|
|
|
{
|
|
|
|
struct ip6_rthdr *rth;
|
|
|
|
int rthlen;
|
|
|
|
|
|
|
|
if (len == 0) {
|
|
|
|
ip6_clearpktopts(opt, IPV6_RTHDR);
|
|
|
|
break; /* just remove the option */
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
/* message length validation */
|
|
|
|
if (len < sizeof(struct ip6_rthdr))
|
|
|
|
return (EINVAL);
|
|
|
|
rth = (struct ip6_rthdr *)buf;
|
|
|
|
rthlen = (rth->ip6r_len + 1) << 3;
|
|
|
|
if (len != rthlen)
|
|
|
|
return (EINVAL);
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
switch (rth->ip6r_type) {
|
|
|
|
case IPV6_RTHDR_TYPE_0:
|
|
|
|
if (rth->ip6r_len == 0) /* must contain one addr */
|
2003-10-06 14:02:09 +00:00
|
|
|
return (EINVAL);
|
2003-10-24 18:26:30 +00:00
|
|
|
if (rth->ip6r_len % 2) /* length must be even */
|
2003-10-06 14:02:09 +00:00
|
|
|
return (EINVAL);
|
2003-10-24 18:26:30 +00:00
|
|
|
if (rth->ip6r_len / 2 != rth->ip6r_segleft)
|
|
|
|
return (EINVAL);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return (EINVAL); /* not supported */
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
/* turn off the previous option */
|
|
|
|
ip6_clearpktopts(opt, IPV6_RTHDR);
|
|
|
|
if (sticky) {
|
|
|
|
opt->ip6po_rthdr = malloc(rthlen, M_IP6OPT, M_WAITOK);
|
|
|
|
bcopy(rth, opt->ip6po_rthdr, rthlen);
|
|
|
|
} else
|
|
|
|
opt->ip6po_rthdr = rth;
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
break;
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_USE_MIN_MTU:
|
|
|
|
if (len != sizeof(int))
|
|
|
|
return (EINVAL);
|
|
|
|
minmtupolicy = *(int *)buf;
|
|
|
|
if (minmtupolicy != IP6PO_MINMTU_MCASTONLY &&
|
|
|
|
minmtupolicy != IP6PO_MINMTU_DISABLE &&
|
|
|
|
minmtupolicy != IP6PO_MINMTU_ALL) {
|
|
|
|
return (EINVAL);
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
2003-10-24 18:26:30 +00:00
|
|
|
opt->ip6po_minmtu = minmtupolicy;
|
|
|
|
break;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-24 18:26:30 +00:00
|
|
|
case IPV6_DONTFRAG:
|
|
|
|
if (len != sizeof(int))
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
if (uproto == IPPROTO_TCP || *(int *)buf == 0) {
|
|
|
|
/*
|
|
|
|
* we ignore this option for TCP sockets.
|
|
|
|
* (rfc2292bis leaves this case unspecified.)
|
|
|
|
*/
|
|
|
|
opt->ip6po_flags &= ~IP6PO_DONTFRAG;
|
|
|
|
} else
|
|
|
|
opt->ip6po_flags |= IP6PO_DONTFRAG;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_PREFER_TEMPADDR:
|
|
|
|
if (len != sizeof(int))
|
|
|
|
return (EINVAL);
|
|
|
|
preftemp = *(int *)buf;
|
|
|
|
if (preftemp != IP6PO_TEMPADDR_SYSTEM &&
|
|
|
|
preftemp != IP6PO_TEMPADDR_NOTPREFER &&
|
|
|
|
preftemp != IP6PO_TEMPADDR_PREFER) {
|
|
|
|
return (EINVAL);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
2003-10-24 18:26:30 +00:00
|
|
|
opt->ip6po_prefer_tempaddr = preftemp;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return (ENOPROTOOPT);
|
|
|
|
} /* end of switch */
|
1999-11-22 02:45:11 +00:00
|
|
|
|
2003-10-06 14:02:09 +00:00
|
|
|
return (0);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Routine called from ip6_output() to loop back a copy of an IP6 multicast
|
|
|
|
* packet to the input queue of a specified interface. Note that this
|
|
|
|
* calls the output routine of the loopback "driver", but with an interface
|
|
|
|
* pointer that might NOT be &loif -- easier than replicating that code here.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ip6_mloopback(ifp, m, dst)
|
|
|
|
struct ifnet *ifp;
|
2001-06-11 12:39:29 +00:00
|
|
|
struct mbuf *m;
|
|
|
|
struct sockaddr_in6 *dst;
|
1999-11-22 02:45:11 +00:00
|
|
|
{
|
2000-07-04 16:35:15 +00:00
|
|
|
struct mbuf *copym;
|
|
|
|
struct ip6_hdr *ip6;
|
1999-11-22 02:45:11 +00:00
|
|
|
|
|
|
|
copym = m_copy(m, 0, M_COPYALL);
|
2000-07-04 16:35:15 +00:00
|
|
|
if (copym == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure to deep-copy IPv6 header portion in case the data
|
|
|
|
* is in an mbuf cluster, so that we can safely override the IPv6
|
|
|
|
* header portion later.
|
|
|
|
*/
|
|
|
|
if ((copym->m_flags & M_EXT) != 0 ||
|
|
|
|
copym->m_len < sizeof(struct ip6_hdr)) {
|
|
|
|
copym = m_pullup(copym, sizeof(struct ip6_hdr));
|
|
|
|
if (copym == NULL)
|
|
|
|
return;
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
2000-07-04 16:35:15 +00:00
|
|
|
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (copym->m_len < sizeof(*ip6)) {
|
|
|
|
m_freem(copym);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
ip6 = mtod(copym, struct ip6_hdr *);
|
|
|
|
/*
|
|
|
|
* clear embedded scope identifiers if necessary.
|
|
|
|
* in6_clearscope will touch the addresses only when necessary.
|
|
|
|
*/
|
|
|
|
in6_clearscope(&ip6->ip6_src);
|
|
|
|
in6_clearscope(&ip6->ip6_dst);
|
2000-07-04 16:35:15 +00:00
|
|
|
|
2003-12-23 02:36:43 +00:00
|
|
|
(void)if_simloop(ifp, copym, dst->sin6_family, 0);
|
1999-11-22 02:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Chop IPv6 header off from the payload.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
ip6_splithdr(m, exthdrs)
|
|
|
|
struct mbuf *m;
|
|
|
|
struct ip6_exthdrs *exthdrs;
|
|
|
|
{
|
|
|
|
struct mbuf *mh;
|
|
|
|
struct ip6_hdr *ip6;
|
|
|
|
|
|
|
|
ip6 = mtod(m, struct ip6_hdr *);
|
|
|
|
if (m->m_len > sizeof(*ip6)) {
|
2003-02-19 05:47:46 +00:00
|
|
|
MGETHDR(mh, M_DONTWAIT, MT_HEADER);
|
1999-11-22 02:45:11 +00:00
|
|
|
if (mh == 0) {
|
|
|
|
m_freem(m);
|
|
|
|
return ENOBUFS;
|
|
|
|
}
|
2002-12-30 20:22:40 +00:00
|
|
|
M_MOVE_PKTHDR(mh, m);
|
1999-11-22 02:45:11 +00:00
|
|
|
MH_ALIGN(mh, sizeof(*ip6));
|
|
|
|
m->m_len -= sizeof(*ip6);
|
|
|
|
m->m_data += sizeof(*ip6);
|
|
|
|
mh->m_next = m;
|
|
|
|
m = mh;
|
|
|
|
m->m_len = sizeof(*ip6);
|
|
|
|
bcopy((caddr_t)ip6, mtod(m, caddr_t), sizeof(*ip6));
|
|
|
|
}
|
|
|
|
exthdrs->ip6e_ip6 = m;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compute IPv6 extension header length.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
ip6_optlen(in6p)
|
|
|
|
struct in6pcb *in6p;
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (!in6p->in6p_outputopts)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
len = 0;
|
|
|
|
#define elen(x) \
|
|
|
|
(((struct ip6_ext *)(x)) ? (((struct ip6_ext *)(x))->ip6e_len + 1) << 3 : 0)
|
|
|
|
|
|
|
|
len += elen(in6p->in6p_outputopts->ip6po_hbh);
|
2001-06-11 12:39:29 +00:00
|
|
|
if (in6p->in6p_outputopts->ip6po_rthdr)
|
|
|
|
/* dest1 is valid with rthdr only */
|
|
|
|
len += elen(in6p->in6p_outputopts->ip6po_dest1);
|
1999-11-22 02:45:11 +00:00
|
|
|
len += elen(in6p->in6p_outputopts->ip6po_rthdr);
|
|
|
|
len += elen(in6p->in6p_outputopts->ip6po_dest2);
|
|
|
|
return len;
|
|
|
|
#undef elen
|
|
|
|
}
|