version 1.68, 2003/10/30 01:43:09 |
version 1.82.4.1, 2006/04/22 11:40:12 |
Line 103 __KERNEL_RCSID(0, "$NetBSD$"); |
|
Line 103 __KERNEL_RCSID(0, "$NetBSD$"); |
|
#include <netinet6/ip6_var.h> |
#include <netinet6/ip6_var.h> |
#include <netinet6/in6_pcb.h> |
#include <netinet6/in6_pcb.h> |
#include <netinet/icmp6.h> |
#include <netinet/icmp6.h> |
|
#include <netinet6/scope6_var.h> |
#include <netinet6/in6_ifattach.h> |
#include <netinet6/in6_ifattach.h> |
#include <netinet6/nd6.h> |
#include <netinet6/nd6.h> |
|
|
Line 112 __KERNEL_RCSID(0, "$NetBSD$"); |
|
Line 113 __KERNEL_RCSID(0, "$NetBSD$"); |
|
|
|
#include <netinet6/ip6protosw.h> |
#include <netinet6/ip6protosw.h> |
|
|
/* we need it for NLOOP. */ |
|
#include "loop.h" |
|
#include "faith.h" |
#include "faith.h" |
#include "gif.h" |
#include "gif.h" |
#include "bpfilter.h" |
|
|
|
#if NGIF > 0 |
#if NGIF > 0 |
#include <netinet6/in6_gif.h> |
#include <netinet6/in6_gif.h> |
Line 131 static int ip6qmaxlen = IFQ_MAXLEN; |
|
Line 129 static int ip6qmaxlen = IFQ_MAXLEN; |
|
struct in6_ifaddr *in6_ifaddr; |
struct in6_ifaddr *in6_ifaddr; |
struct ifqueue ip6intrq; |
struct ifqueue ip6intrq; |
|
|
extern struct ifnet loif[NLOOP]; |
extern struct callout in6_tmpaddrtimer_ch; |
|
|
int ip6_forward_srcrt; /* XXX */ |
int ip6_forward_srcrt; /* XXX */ |
int ip6_sourcecheck; /* XXX */ |
int ip6_sourcecheck; /* XXX */ |
int ip6_sourcecheck_interval; /* XXX */ |
int ip6_sourcecheck_interval; /* XXX */ |
Line 143 struct pfil_head inet6_pfil_hook; |
|
Line 142 struct pfil_head inet6_pfil_hook; |
|
struct ip6stat ip6stat; |
struct ip6stat ip6stat; |
|
|
static void ip6_init2 __P((void *)); |
static void ip6_init2 __P((void *)); |
|
static struct m_tag *ip6_setdstifaddr __P((struct mbuf *, struct in6_ifaddr *)); |
|
|
static int ip6_hopopts_input __P((u_int32_t *, u_int32_t *, struct mbuf **, int *)); |
static int ip6_hopopts_input __P((u_int32_t *, u_int32_t *, struct mbuf **, int *)); |
static struct mbuf *ip6_pullexthdr __P((struct mbuf *, size_t, int)); |
static struct mbuf *ip6_pullexthdr __P((struct mbuf *, size_t, int)); |
Line 154 static struct mbuf *ip6_pullexthdr __P(( |
|
Line 154 static struct mbuf *ip6_pullexthdr __P(( |
|
void |
void |
ip6_init() |
ip6_init() |
{ |
{ |
struct ip6protosw *pr; |
const struct ip6protosw *pr; |
int i; |
int i; |
|
|
pr = (struct ip6protosw *)pffindproto(PF_INET6, IPPROTO_RAW, SOCK_RAW); |
pr = (const struct ip6protosw *)pffindproto(PF_INET6, IPPROTO_RAW, SOCK_RAW); |
if (pr == 0) |
if (pr == 0) |
panic("ip6_init"); |
panic("ip6_init"); |
for (i = 0; i < IPPROTO_MAX; i++) |
for (i = 0; i < IPPROTO_MAX; i++) |
ip6_protox[i] = pr - inet6sw; |
ip6_protox[i] = pr - inet6sw; |
for (pr = (struct ip6protosw *)inet6domain.dom_protosw; |
for (pr = (const struct ip6protosw *)inet6domain.dom_protosw; |
pr < (struct ip6protosw *)inet6domain.dom_protoswNPROTOSW; pr++) |
pr < (const struct ip6protosw *)inet6domain.dom_protoswNPROTOSW; pr++) |
if (pr->pr_domain->dom_family == PF_INET6 && |
if (pr->pr_domain->dom_family == PF_INET6 && |
pr->pr_protocol && pr->pr_protocol != IPPROTO_RAW) |
pr->pr_protocol && pr->pr_protocol != IPPROTO_RAW) |
ip6_protox[pr->pr_protocol] = pr - inet6sw; |
ip6_protox[pr->pr_protocol] = pr - inet6sw; |
ip6intrq.ifq_maxlen = ip6qmaxlen; |
ip6intrq.ifq_maxlen = ip6qmaxlen; |
|
scope6_init(); |
|
addrsel_policy_init(); |
nd6_init(); |
nd6_init(); |
frag6_init(); |
frag6_init(); |
|
ip6_desync_factor = arc4random() % MAX_TEMP_DESYNC_FACTOR; |
|
|
ip6_init2((void *)0); |
ip6_init2((void *)0); |
|
|
Line 192 ip6_init2(dummy) |
|
Line 195 ip6_init2(dummy) |
|
/* nd6_timer_init */ |
/* nd6_timer_init */ |
callout_init(&nd6_timer_ch); |
callout_init(&nd6_timer_ch); |
callout_reset(&nd6_timer_ch, hz, nd6_timer, NULL); |
callout_reset(&nd6_timer_ch, hz, nd6_timer, NULL); |
|
|
|
/* timer for regeneranation of temporary addresses randomize ID */ |
|
callout_init(&in6_tmpaddrtimer_ch); |
|
callout_reset(&in6_tmpaddrtimer_ch, |
|
(ip6_temp_preferred_lifetime - ip6_desync_factor - |
|
ip6_temp_regen_advance) * hz, |
|
in6_tmpaddrtimer, NULL); |
} |
} |
|
|
/* |
/* |
|
|
splx(s); |
splx(s); |
if (m == 0) |
if (m == 0) |
return; |
return; |
|
/* drop the packet if IPv6 operation is disabled on the IF */ |
|
if ((ND_IFINFO(m->m_pkthdr.rcvif)->flags & ND6_IFF_IFDISABLED)) { |
|
m_freem(m); |
|
return; |
|
} |
ip6_input(m); |
ip6_input(m); |
} |
} |
} |
} |
|
|
#endif |
#endif |
|
|
/* |
/* |
|
* make sure we don't have onion peering information into m_tag. |
|
*/ |
|
ip6_delaux(m); |
|
|
|
/* |
* mbuf statistics |
* mbuf statistics |
*/ |
*/ |
if (m->m_flags & M_EXT) { |
if (m->m_flags & M_EXT) { |
|
|
#define M2MMAX (sizeof(ip6stat.ip6s_m2m)/sizeof(ip6stat.ip6s_m2m[0])) |
#define M2MMAX (sizeof(ip6stat.ip6s_m2m)/sizeof(ip6stat.ip6s_m2m[0])) |
if (m->m_next) { |
if (m->m_next) { |
if (m->m_flags & M_LOOP) { |
if (m->m_flags & M_LOOP) { |
ip6stat.ip6s_m2m[loif[0].if_index]++; /* XXX */ |
ip6stat.ip6s_m2m[lo0ifp->if_index]++; /* XXX */ |
} else if (m->m_pkthdr.rcvif->if_index < M2MMAX) |
} else if (m->m_pkthdr.rcvif->if_index < M2MMAX) |
ip6stat.ip6s_m2m[m->m_pkthdr.rcvif->if_index]++; |
ip6stat.ip6s_m2m[m->m_pkthdr.rcvif->if_index]++; |
else |
else |
|
|
/* |
/* |
* If the IPv6 header is not aligned, slurp it up into a new |
* If the IPv6 header is not aligned, slurp it up into a new |
* mbuf with space for link headers, in the event we forward |
* mbuf with space for link headers, in the event we forward |
* it. OTherwise, if it is aligned, make sure the entire base |
* it. Otherwise, if it is aligned, make sure the entire base |
* IPv6 header is in the first mbuf of the chain. |
* IPv6 header is in the first mbuf of the chain. |
*/ |
*/ |
if (IP6_HDR_ALIGNED_P(mtod(m, caddr_t)) == 0) { |
if (IP6_HDR_ALIGNED_P(mtod(m, caddr_t)) == 0) { |
|
|
} |
} |
#endif |
#endif |
|
|
if (IN6_IS_ADDR_LOOPBACK(&ip6->ip6_src) || |
/* |
IN6_IS_ADDR_LOOPBACK(&ip6->ip6_dst)) { |
* Disambiguate address scope zones (if there is ambiguity). |
if (m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) { |
* We first make sure that the original source or destination address |
ours = 1; |
* is not in our internal form for scoped addresses. Such addresses |
deliverifp = m->m_pkthdr.rcvif; |
* are not necessarily invalid spec-wise, but we cannot accept them due |
goto hbhcheck; |
* to the usage conflict. |
} else { |
* in6_setscope() then also checks and rejects the cases where src or |
ip6stat.ip6s_badscope++; |
* dst are the loopback address and the receiving interface |
in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr); |
* is not loopback. |
goto bad; |
*/ |
} |
if (in6_clearscope(&ip6->ip6_src) || in6_clearscope(&ip6->ip6_dst)) { |
} |
ip6stat.ip6s_badscope++; /* XXX */ |
|
goto bad; |
/* drop packets if interface ID portion is already filled */ |
|
if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) == 0) { |
|
if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src) && |
|
ip6->ip6_src.s6_addr16[1]) { |
|
ip6stat.ip6s_badscope++; |
|
goto bad; |
|
} |
|
if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst) && |
|
ip6->ip6_dst.s6_addr16[1]) { |
|
ip6stat.ip6s_badscope++; |
|
goto bad; |
|
} |
|
} |
} |
|
if (in6_setscope(&ip6->ip6_src, m->m_pkthdr.rcvif, NULL) || |
if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src)) |
in6_setscope(&ip6->ip6_dst, m->m_pkthdr.rcvif, NULL)) { |
ip6->ip6_src.s6_addr16[1] |
ip6stat.ip6s_badscope++; |
= htons(m->m_pkthdr.rcvif->if_index); |
goto bad; |
if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst)) |
|
ip6->ip6_dst.s6_addr16[1] |
|
= htons(m->m_pkthdr.rcvif->if_index); |
|
|
|
/* |
|
* We use rt->rt_ifp to determine if the address is ours or not. |
|
* If rt_ifp is lo0, the address is ours. |
|
* The problem here is, rt->rt_ifp for fe80::%lo0/64 is set to lo0, |
|
* so any address under fe80::%lo0/64 will be mistakenly considered |
|
* local. The special case is supplied to handle the case properly |
|
* by actually looking at interface addresses |
|
* (using in6ifa_ifpwithaddr). |
|
*/ |
|
if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) != 0 && |
|
IN6_IS_ADDR_LINKLOCAL(&ip6->ip6_dst)) { |
|
if (!in6ifa_ifpwithaddr(m->m_pkthdr.rcvif, &ip6->ip6_dst)) { |
|
icmp6_error(m, ICMP6_DST_UNREACH, |
|
ICMP6_DST_UNREACH_ADDR, 0); |
|
/* m is already freed */ |
|
return; |
|
} |
|
|
|
ours = 1; |
|
deliverifp = m->m_pkthdr.rcvif; |
|
goto hbhcheck; |
|
} |
} |
|
|
/* |
/* |
|
|
if (ip6_forward_rt.ro_rt != NULL && |
if (ip6_forward_rt.ro_rt != NULL && |
(ip6_forward_rt.ro_rt->rt_flags & RTF_UP) != 0 && |
(ip6_forward_rt.ro_rt->rt_flags & RTF_UP) != 0 && |
IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst, |
IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst, |
&((struct sockaddr_in6 *)(&ip6_forward_rt.ro_dst))->sin6_addr)) |
&((struct sockaddr_in6 *)(&ip6_forward_rt.ro_dst))->sin6_addr)) |
ip6stat.ip6s_forward_cachehit++; |
ip6stat.ip6s_forward_cachehit++; |
else { |
else { |
struct sockaddr_in6 *dst6; |
struct sockaddr_in6 *dst6; |
|
|
*/ |
*/ |
#if defined(NFAITH) && 0 < NFAITH |
#if defined(NFAITH) && 0 < NFAITH |
if (ip6_keepfaith) { |
if (ip6_keepfaith) { |
if (ip6_forward_rt.ro_rt && ip6_forward_rt.ro_rt->rt_ifp |
if (ip6_forward_rt.ro_rt && ip6_forward_rt.ro_rt->rt_ifp && |
&& ip6_forward_rt.ro_rt->rt_ifp->if_type == IFT_FAITH) { |
ip6_forward_rt.ro_rt->rt_ifp->if_type == IFT_FAITH) { |
/* XXX do we need more sanity checks? */ |
/* XXX do we need more sanity checks? */ |
ours = 1; |
ours = 1; |
deliverifp = ip6_forward_rt.ro_rt->rt_ifp; /* faith */ |
deliverifp = ip6_forward_rt.ro_rt->rt_ifp; /* faith */ |
|
|
|
|
hbhcheck: |
hbhcheck: |
/* |
/* |
|
* record address information into m_tag, if we don't have one yet. |
|
* note that we are unable to record it, if the address is not listed |
|
* as our interface address (e.g. multicast addresses, addresses |
|
* within FAITH prefixes and such). |
|
*/ |
|
if (deliverifp && !ip6_getdstifaddr(m)) { |
|
struct in6_ifaddr *ia6; |
|
|
|
ia6 = in6_ifawithifp(deliverifp, &ip6->ip6_dst); |
|
if (ia6) { |
|
if (!ip6_setdstifaddr(m, ia6)) { |
|
/* |
|
* XXX maybe we should drop the packet here, |
|
* as we could not provide enough information |
|
* to the upper layers. |
|
*/ |
|
} |
|
} |
|
} |
|
|
|
/* |
* Process Hop-by-Hop options header if it's contained. |
* Process Hop-by-Hop options header if it's contained. |
* m may be modified in ip6_hopopts_input(). |
* m may be modified in ip6_hopopts_input(). |
* If a JumboPayload option is included, plen will also be modified. |
* If a JumboPayload option is included, plen will also be modified. |
|
|
if (ip6->ip6_plen == 0 && plen == 0) { |
if (ip6->ip6_plen == 0 && plen == 0) { |
/* |
/* |
* Note that if a valid jumbo payload option is |
* Note that if a valid jumbo payload option is |
* contained, ip6_hoptops_input() must set a valid |
* contained, ip6_hopopts_input() must set a valid |
* (non-zero) payload length to the variable plen. |
* (non-zero) payload length to the variable plen. |
*/ |
*/ |
ip6stat.ip6s_badoptions++; |
ip6stat.ip6s_badoptions++; |
|
|
} |
} |
|
|
/* |
/* |
|
* set/grab in6_ifaddr correspond to IPv6 destination address. |
|
*/ |
|
static struct m_tag * |
|
ip6_setdstifaddr(m, ia6) |
|
struct mbuf *m; |
|
struct in6_ifaddr *ia6; |
|
{ |
|
struct m_tag *mtag; |
|
|
|
mtag = ip6_addaux(m); |
|
if (mtag) |
|
((struct ip6aux *)(mtag + 1))->ip6a_dstia6 = ia6; |
|
return mtag; /* NULL if failed to set */ |
|
} |
|
|
|
struct in6_ifaddr * |
|
ip6_getdstifaddr(m) |
|
struct mbuf *m; |
|
{ |
|
struct m_tag *mtag; |
|
|
|
mtag = ip6_findaux(m); |
|
if (mtag) |
|
return ((struct ip6aux *)(mtag + 1))->ip6a_dstia6; |
|
else |
|
return NULL; |
|
} |
|
|
|
/* |
* Hop-by-Hop options header processing. If a valid jumbo payload option is |
* Hop-by-Hop options header processing. If a valid jumbo payload option is |
* included, the real payload length will be stored in plenp. |
* included, the real payload length will be stored in plenp. |
*/ |
*/ |
Line 997 ip6_savecontrol(in6p, mp, ip6, m) |
|
Line 1030 ip6_savecontrol(in6p, mp, ip6, m) |
|
struct ip6_hdr *ip6; |
struct ip6_hdr *ip6; |
struct mbuf *m; |
struct mbuf *m; |
{ |
{ |
struct proc *p = curproc; /* XXX */ |
|
int privileged; |
|
|
|
privileged = 0; |
|
if (p && !suser(p->p_ucred, &p->p_acflag)) |
|
privileged++; |
|
|
|
#ifdef SO_TIMESTAMP |
#ifdef SO_TIMESTAMP |
if (in6p->in6p_socket->so_options & SO_TIMESTAMP) { |
if (in6p->in6p_socket->so_options & SO_TIMESTAMP) { |
struct timeval tv; |
struct timeval tv; |
Line 1035 ip6_savecontrol(in6p, mp, ip6, m) |
|
Line 1061 ip6_savecontrol(in6p, mp, ip6, m) |
|
if ((in6p->in6p_flags & IN6P_PKTINFO) != 0) { |
if ((in6p->in6p_flags & IN6P_PKTINFO) != 0) { |
struct in6_pktinfo pi6; |
struct in6_pktinfo pi6; |
bcopy(&ip6->ip6_dst, &pi6.ipi6_addr, sizeof(struct in6_addr)); |
bcopy(&ip6->ip6_dst, &pi6.ipi6_addr, sizeof(struct in6_addr)); |
if (IN6_IS_SCOPE_LINKLOCAL(&pi6.ipi6_addr)) |
in6_clearscope(&pi6.ipi6_addr); /* XXX */ |
pi6.ipi6_addr.s6_addr16[1] = 0; |
pi6.ipi6_ifindex = m->m_pkthdr.rcvif ? |
pi6.ipi6_ifindex = (m && m->m_pkthdr.rcvif) |
m->m_pkthdr.rcvif->if_index : 0; |
? m->m_pkthdr.rcvif->if_index |
|
: 0; |
|
*mp = sbcreatecontrol((caddr_t) &pi6, |
*mp = sbcreatecontrol((caddr_t) &pi6, |
sizeof(struct in6_pktinfo), IPV6_PKTINFO, IPPROTO_IPV6); |
sizeof(struct in6_pktinfo), IPV6_PKTINFO, IPPROTO_IPV6); |
if (*mp) |
if (*mp) |
Line 1055 ip6_savecontrol(in6p, mp, ip6, m) |
|
Line 1079 ip6_savecontrol(in6p, mp, ip6, m) |
|
/* IN6P_NEXTHOP - for outgoing packet only */ |
/* IN6P_NEXTHOP - for outgoing packet only */ |
|
|
/* |
/* |
* IPV6_HOPOPTS socket option. We require super-user privilege |
* IPV6_HOPOPTS socket option. Recall that we required super-user |
* for the option, but it might be too strict, since there might |
* privilege for the option (see ip6_ctloutput), but it might be too |
* be some hop-by-hop options which can be returned to normal user. |
* strict, since there might be some hop-by-hop options which can be |
* See RFC 2292 section 6. |
* returned to normal user. |
|
* See also RFC 2292 section 6. |
*/ |
*/ |
if ((in6p->in6p_flags & IN6P_HOPOPTS) != 0 && privileged) { |
if ((in6p->in6p_flags & IN6P_HOPOPTS) != 0) { |
/* |
/* |
* Check if a hop-by-hop options header is contatined in the |
* Check if a hop-by-hop options header is contatined in the |
* received packet, and if so, store the options as ancillary |
* received packet, and if so, store the options as ancillary |
Line 1068 ip6_savecontrol(in6p, mp, ip6, m) |
|
Line 1093 ip6_savecontrol(in6p, mp, ip6, m) |
|
* just after the IPv6 header, which fact is assured through |
* just after the IPv6 header, which fact is assured through |
* the IPv6 input processing. |
* the IPv6 input processing. |
*/ |
*/ |
struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *); |
struct ip6_hdr *xip6 = mtod(m, struct ip6_hdr *); |
if (ip6->ip6_nxt == IPPROTO_HOPOPTS) { |
if (xip6->ip6_nxt == IPPROTO_HOPOPTS) { |
struct ip6_hbh *hbh; |
struct ip6_hbh *hbh; |
int hbhlen; |
int hbhlen; |
struct mbuf *ext; |
struct mbuf *ext; |
|
|
ext = ip6_pullexthdr(m, sizeof(struct ip6_hdr), |
ext = ip6_pullexthdr(m, sizeof(struct ip6_hdr), |
ip6->ip6_nxt); |
xip6->ip6_nxt); |
if (ext == NULL) { |
if (ext == NULL) { |
ip6stat.ip6s_tooshort++; |
ip6stat.ip6s_tooshort++; |
return; |
return; |
Line 1104 ip6_savecontrol(in6p, mp, ip6, m) |
|
Line 1129 ip6_savecontrol(in6p, mp, ip6, m) |
|
|
|
/* IPV6_DSTOPTS and IPV6_RTHDR socket options */ |
/* IPV6_DSTOPTS and IPV6_RTHDR socket options */ |
if (in6p->in6p_flags & (IN6P_DSTOPTS | IN6P_RTHDR)) { |
if (in6p->in6p_flags & (IN6P_DSTOPTS | IN6P_RTHDR)) { |
struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *); |
struct ip6_hdr *xip6 = mtod(m, struct ip6_hdr *); |
int nxt = ip6->ip6_nxt, off = sizeof(struct ip6_hdr); |
int nxt = xip6->ip6_nxt, off = sizeof(struct ip6_hdr); |
|
|
/* |
/* |
* Search for destination options headers or routing |
* Search for destination options headers or routing |
Line 1155 ip6_savecontrol(in6p, mp, ip6, m) |
|
Line 1180 ip6_savecontrol(in6p, mp, ip6, m) |
|
if (!in6p->in6p_flags & IN6P_DSTOPTS) |
if (!in6p->in6p_flags & IN6P_DSTOPTS) |
break; |
break; |
|
|
/* |
|
* We also require super-user privilege for |
|
* the option. |
|
* See the comments on IN6_HOPOPTS. |
|
*/ |
|
if (!privileged) |
|
break; |
|
|
|
*mp = sbcreatecontrol((caddr_t)ip6e, elen, |
*mp = sbcreatecontrol((caddr_t)ip6e, elen, |
IPV6_DSTOPTS, IPPROTO_IPV6); |
IPV6_DSTOPTS, IPPROTO_IPV6); |
if (*mp) |
if (*mp) |
Line 1333 ip6_nexthdr(m, off, proto, nxtp) |
|
Line 1350 ip6_nexthdr(m, off, proto, nxtp) |
|
|
|
switch (proto) { |
switch (proto) { |
case IPPROTO_IPV6: |
case IPPROTO_IPV6: |
|
/* do not chase beyond intermediate IPv6 headers */ |
|
if (off != 0) |
|
return -1; |
if (m->m_pkthdr.len < off + sizeof(ip6)) |
if (m->m_pkthdr.len < off + sizeof(ip6)) |
return -1; |
return -1; |
m_copydata(m, off, sizeof(ip6), (caddr_t)&ip6); |
m_copydata(m, off, sizeof(ip6), (caddr_t)&ip6); |
Line 1422 ip6_lasthdr(m, off, proto, nxtp) |
|
Line 1442 ip6_lasthdr(m, off, proto, nxtp) |
|
} |
} |
} |
} |
|
|
|
struct m_tag * |
|
ip6_addaux(m) |
|
struct mbuf *m; |
|
{ |
|
struct m_tag *mtag; |
|
|
|
mtag = m_tag_find(m, PACKET_TAG_INET6, NULL); |
|
if (!mtag) { |
|
mtag = m_tag_get(PACKET_TAG_INET6, sizeof(struct ip6aux), |
|
M_NOWAIT); |
|
if (mtag) { |
|
m_tag_prepend(m, mtag); |
|
bzero(mtag + 1, sizeof(struct ip6aux)); |
|
} |
|
} |
|
return mtag; |
|
} |
|
|
|
struct m_tag * |
|
ip6_findaux(m) |
|
struct mbuf *m; |
|
{ |
|
struct m_tag *mtag; |
|
|
|
mtag = m_tag_find(m, PACKET_TAG_INET6, NULL); |
|
return mtag; |
|
} |
|
|
|
void |
|
ip6_delaux(m) |
|
struct mbuf *m; |
|
{ |
|
struct m_tag *mtag; |
|
|
|
mtag = m_tag_find(m, PACKET_TAG_INET6, NULL); |
|
if (mtag) |
|
m_tag_delete(m, mtag); |
|
} |
|
|
/* |
/* |
* System control for IP6 |
* System control for IP6 |
*/ |
*/ |
Line 1435 u_char inet6ctlerrmap[PRC_NCMDS] = { |
|
Line 1494 u_char inet6ctlerrmap[PRC_NCMDS] = { |
|
ENOPROTOOPT |
ENOPROTOOPT |
}; |
}; |
|
|
int |
SYSCTL_SETUP(sysctl_net_inet6_ip6_setup, "sysctl net.inet6.ip6 subtree setup") |
ip6_sysctl(name, namelen, oldp, oldlenp, newp, newlen) |
|
int *name; |
|
u_int namelen; |
|
void *oldp; |
|
size_t *oldlenp; |
|
void *newp; |
|
size_t newlen; |
|
{ |
{ |
int old, error; |
|
|
|
/* All sysctl names at this level are terminal. */ |
sysctl_createv(clog, 0, NULL, NULL, |
if (namelen != 1) |
CTLFLAG_PERMANENT, |
return ENOTDIR; |
CTLTYPE_NODE, "net", NULL, |
|
NULL, 0, NULL, 0, |
switch (name[0]) { |
CTL_NET, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
case IPV6CTL_FORWARDING: |
CTLFLAG_PERMANENT, |
return sysctl_int(oldp, oldlenp, newp, newlen, |
CTLTYPE_NODE, "inet6", |
&ip6_forwarding); |
SYSCTL_DESCR("PF_INET6 related settings"), |
case IPV6CTL_SENDREDIRECTS: |
NULL, 0, NULL, 0, |
return sysctl_int(oldp, oldlenp, newp, newlen, |
CTL_NET, PF_INET6, CTL_EOL); |
&ip6_sendredirects); |
sysctl_createv(clog, 0, NULL, NULL, |
case IPV6CTL_DEFHLIM: |
CTLFLAG_PERMANENT, |
return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_defhlim); |
CTLTYPE_NODE, "ip6", |
case IPV6CTL_MAXFRAGPACKETS: |
SYSCTL_DESCR("IPv6 related settings"), |
return sysctl_int(oldp, oldlenp, newp, newlen, |
NULL, 0, NULL, 0, |
&ip6_maxfragpackets); |
CTL_NET, PF_INET6, IPPROTO_IPV6, CTL_EOL); |
case IPV6CTL_ACCEPT_RTADV: |
|
return sysctl_int(oldp, oldlenp, newp, newlen, |
sysctl_createv(clog, 0, NULL, NULL, |
&ip6_accept_rtadv); |
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
case IPV6CTL_KEEPFAITH: |
CTLTYPE_INT, "forwarding", |
return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_keepfaith); |
SYSCTL_DESCR("Enable forwarding of INET6 datagrams"), |
case IPV6CTL_LOG_INTERVAL: |
NULL, 0, &ip6_forwarding, 0, |
return sysctl_int(oldp, oldlenp, newp, newlen, |
CTL_NET, PF_INET6, IPPROTO_IPV6, |
&ip6_log_interval); |
IPV6CTL_FORWARDING, CTL_EOL); |
case IPV6CTL_HDRNESTLIMIT: |
sysctl_createv(clog, 0, NULL, NULL, |
return sysctl_int(oldp, oldlenp, newp, newlen, |
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
&ip6_hdrnestlimit); |
CTLTYPE_INT, "redirect", |
case IPV6CTL_DAD_COUNT: |
SYSCTL_DESCR("Enable sending of ICMPv6 redirect messages"), |
return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_dad_count); |
NULL, 0, &ip6_sendredirects, 0, |
case IPV6CTL_AUTO_FLOWLABEL: |
CTL_NET, PF_INET6, IPPROTO_IPV6, |
return sysctl_int(oldp, oldlenp, newp, newlen, |
IPV6CTL_SENDREDIRECTS, CTL_EOL); |
&ip6_auto_flowlabel); |
sysctl_createv(clog, 0, NULL, NULL, |
case IPV6CTL_DEFMCASTHLIM: |
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
return sysctl_int(oldp, oldlenp, newp, newlen, |
CTLTYPE_INT, "hlim", |
&ip6_defmcasthlim); |
SYSCTL_DESCR("Hop limit for an INET6 datagram"), |
|
NULL, 0, &ip6_defhlim, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_DEFHLIM, CTL_EOL); |
|
#ifdef notyet |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "mtu", NULL, |
|
NULL, 0, &, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_DEFMTU, CTL_EOL); |
|
#endif |
|
#ifdef __no_idea__ |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "forwsrcrt", NULL, |
|
NULL, 0, &?, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_FORWSRCRT, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_STRUCT, "mrtstats", NULL, |
|
NULL, 0, &?, sizeof(?), |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_MRTSTATS, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_?, "mrtproto", NULL, |
|
NULL, 0, &?, sizeof(?), |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_MRTPROTO, CTL_EOL); |
|
#endif |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "maxfragpackets", |
|
SYSCTL_DESCR("Maximum number of fragments to buffer " |
|
"for reassembly"), |
|
NULL, 0, &ip6_maxfragpackets, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_MAXFRAGPACKETS, CTL_EOL); |
|
#ifdef __no_idea__ |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "sourcecheck", NULL, |
|
NULL, 0, &?, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_SOURCECHECK, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "sourcecheck_logint", NULL, |
|
NULL, 0, &?, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_SOURCECHECK_LOGINT, CTL_EOL); |
|
#endif |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "accept_rtadv", |
|
SYSCTL_DESCR("Accept router advertisements"), |
|
NULL, 0, &ip6_accept_rtadv, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_ACCEPT_RTADV, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "keepfaith", |
|
SYSCTL_DESCR("Activate faith interface"), |
|
NULL, 0, &ip6_keepfaith, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_KEEPFAITH, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "log_interval", |
|
SYSCTL_DESCR("Minumum interval between logging " |
|
"unroutable packets"), |
|
NULL, 0, &ip6_log_interval, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_LOG_INTERVAL, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "hdrnestlimit", |
|
SYSCTL_DESCR("Maximum number of nested IPv6 headers"), |
|
NULL, 0, &ip6_hdrnestlimit, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_HDRNESTLIMIT, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "dad_count", |
|
SYSCTL_DESCR("Number of Duplicate Address Detection " |
|
"probes to send"), |
|
NULL, 0, &ip6_dad_count, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_DAD_COUNT, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "auto_flowlabel", |
|
SYSCTL_DESCR("Assign random IPv6 flow labels"), |
|
NULL, 0, &ip6_auto_flowlabel, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_AUTO_FLOWLABEL, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "defmcasthlim", |
|
SYSCTL_DESCR("Default multicast hop limit"), |
|
NULL, 0, &ip6_defmcasthlim, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_DEFMCASTHLIM, CTL_EOL); |
#if NGIF > 0 |
#if NGIF > 0 |
case IPV6CTL_GIF_HLIM: |
sysctl_createv(clog, 0, NULL, NULL, |
return sysctl_int(oldp, oldlenp, newp, newlen, |
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
&ip6_gif_hlim); |
CTLTYPE_INT, "gifhlim", |
#endif |
SYSCTL_DESCR("Default hop limit for a gif tunnel datagram"), |
case IPV6CTL_KAME_VERSION: |
NULL, 0, &ip6_gif_hlim, 0, |
return sysctl_rdstring(oldp, oldlenp, newp, __KAME_VERSION); |
CTL_NET, PF_INET6, IPPROTO_IPV6, |
case IPV6CTL_USE_DEPRECATED: |
IPV6CTL_GIF_HLIM, CTL_EOL); |
return sysctl_int(oldp, oldlenp, newp, newlen, |
#endif /* NGIF */ |
&ip6_use_deprecated); |
sysctl_createv(clog, 0, NULL, NULL, |
case IPV6CTL_RR_PRUNE: |
CTLFLAG_PERMANENT, |
return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_rr_prune); |
CTLTYPE_STRING, "kame_version", |
case IPV6CTL_V6ONLY: |
SYSCTL_DESCR("KAME Version"), |
#ifdef INET6_BINDV6ONLY |
NULL, 0, __UNCONST(__KAME_VERSION), 0, |
return sysctl_rdint(oldp, oldlenp, newp, ip6_v6only); |
CTL_NET, PF_INET6, IPPROTO_IPV6, |
#else |
IPV6CTL_KAME_VERSION, CTL_EOL); |
return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_v6only); |
sysctl_createv(clog, 0, NULL, NULL, |
#endif |
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
case IPV6CTL_ANONPORTMIN: |
CTLTYPE_INT, "use_deprecated", |
old = ip6_anonportmin; |
SYSCTL_DESCR("Allow use of deprecated addresses as " |
error = sysctl_int(oldp, oldlenp, newp, newlen, |
"source addresses"), |
&ip6_anonportmin); |
NULL, 0, &ip6_use_deprecated, 0, |
if (ip6_anonportmin >= ip6_anonportmax || ip6_anonportmin < 0 || |
CTL_NET, PF_INET6, IPPROTO_IPV6, |
ip6_anonportmin > 65535 |
IPV6CTL_USE_DEPRECATED, CTL_EOL); |
#ifndef IPNOPRIVPORTS |
sysctl_createv(clog, 0, NULL, NULL, |
|| ip6_anonportmin < IPV6PORT_RESERVED |
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
#endif |
CTLTYPE_INT, "rr_prune", NULL, |
) { |
NULL, 0, &ip6_rr_prune, 0, |
ip6_anonportmin = old; |
CTL_NET, PF_INET6, IPPROTO_IPV6, |
return (EINVAL); |
IPV6CTL_RR_PRUNE, CTL_EOL); |
} |
sysctl_createv(clog, 0, NULL, NULL, |
return (error); |
CTLFLAG_PERMANENT |
case IPV6CTL_ANONPORTMAX: |
#ifndef INET6_BINDV6ONLY |
old = ip6_anonportmax; |
|CTLFLAG_READWRITE, |
error = sysctl_int(oldp, oldlenp, newp, newlen, |
#endif |
&ip6_anonportmax); |
CTLTYPE_INT, "v6only", |
if (ip6_anonportmin >= ip6_anonportmax || ip6_anonportmax < 0 || |
SYSCTL_DESCR("Disallow PF_INET6 sockets from connecting " |
ip6_anonportmax > 65535 |
"to PF_INET sockets"), |
|
NULL, 0, &ip6_v6only, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_V6ONLY, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "anonportmin", |
|
SYSCTL_DESCR("Lowest ephemeral port number to assign"), |
|
sysctl_net_inet_ip_ports, 0, &ip6_anonportmin, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_ANONPORTMIN, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "anonportmax", |
|
SYSCTL_DESCR("Highest ephemeral port number to assign"), |
|
sysctl_net_inet_ip_ports, 0, &ip6_anonportmax, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_ANONPORTMAX, CTL_EOL); |
#ifndef IPNOPRIVPORTS |
#ifndef IPNOPRIVPORTS |
|| ip6_anonportmax < IPV6PORT_RESERVED |
sysctl_createv(clog, 0, NULL, NULL, |
#endif |
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
) { |
CTLTYPE_INT, "lowportmin", |
ip6_anonportmax = old; |
SYSCTL_DESCR("Lowest privileged ephemeral port number " |
return (EINVAL); |
"to assign"), |
} |
sysctl_net_inet_ip_ports, 0, &ip6_lowportmin, 0, |
return (error); |
CTL_NET, PF_INET6, IPPROTO_IPV6, |
#ifndef IPNOPRIVPORTS |
IPV6CTL_LOWPORTMIN, CTL_EOL); |
case IPV6CTL_LOWPORTMIN: |
sysctl_createv(clog, 0, NULL, NULL, |
old = ip6_lowportmin; |
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
error = sysctl_int(oldp, oldlenp, newp, newlen, |
CTLTYPE_INT, "lowportmax", |
&ip6_lowportmin); |
SYSCTL_DESCR("Highest privileged ephemeral port number " |
if (ip6_lowportmin >= ip6_lowportmax || |
"to assign"), |
ip6_lowportmin > IPV6PORT_RESERVEDMAX || |
sysctl_net_inet_ip_ports, 0, &ip6_lowportmax, 0, |
ip6_lowportmin < IPV6PORT_RESERVEDMIN) { |
CTL_NET, PF_INET6, IPPROTO_IPV6, |
ip6_lowportmin = old; |
IPV6CTL_LOWPORTMAX, CTL_EOL); |
return (EINVAL); |
#endif /* IPNOPRIVPORTS */ |
} |
sysctl_createv(clog, 0, NULL, NULL, |
return (error); |
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
case IPV6CTL_LOWPORTMAX: |
CTLTYPE_INT, "use_tempaddr", |
old = ip6_lowportmax; |
SYSCTL_DESCR("Use temporary address"), |
error = sysctl_int(oldp, oldlenp, newp, newlen, |
NULL, 0, &ip6_use_tempaddr, 0, |
&ip6_lowportmax); |
CTL_NET, PF_INET6, IPPROTO_IPV6, |
if (ip6_lowportmin >= ip6_lowportmax || |
CTL_CREATE, CTL_EOL); |
ip6_lowportmax > IPV6PORT_RESERVEDMAX || |
sysctl_createv(clog, 0, NULL, NULL, |
ip6_lowportmax < IPV6PORT_RESERVEDMIN) { |
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
ip6_lowportmax = old; |
CTLTYPE_INT, "temppltime", |
return (EINVAL); |
SYSCTL_DESCR("preferred lifetime of a temporary address"), |
} |
NULL, 0, &ip6_temp_preferred_lifetime, 0, |
return (error); |
CTL_NET, PF_INET6, IPPROTO_IPV6, |
#endif |
CTL_CREATE, CTL_EOL); |
case IPV6CTL_MAXFRAGS: |
sysctl_createv(clog, 0, NULL, NULL, |
return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_maxfrags); |
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
default: |
CTLTYPE_INT, "tempvltime", |
return EOPNOTSUPP; |
SYSCTL_DESCR("valid lifetime of a temporary address"), |
} |
NULL, 0, &ip6_temp_valid_lifetime, 0, |
/* NOTREACHED */ |
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
CTL_CREATE, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "maxfrags", |
|
SYSCTL_DESCR("Maximum fragments in reassembly queue"), |
|
NULL, 0, &ip6_maxfrags, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_MAXFRAGS, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT, |
|
CTLTYPE_STRUCT, "stats", |
|
SYSCTL_DESCR("IPv6 statistics"), |
|
NULL, 0, &ip6stat, sizeof(ip6stat), |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_STATS, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "use_defaultzone", |
|
SYSCTL_DESCR("Whether to use the default scope zones"), |
|
NULL, 0, &ip6_use_defzone, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
IPV6CTL_USE_DEFAULTZONE, CTL_EOL); |
|
sysctl_createv(clog, 0, NULL, NULL, |
|
CTLFLAG_PERMANENT|CTLFLAG_READWRITE, |
|
CTLTYPE_INT, "mcast_pmtu", |
|
SYSCTL_DESCR("Enable pMTU discovery for multicast packet"), |
|
NULL, 0, &ip6_mcast_pmtu, 0, |
|
CTL_NET, PF_INET6, IPPROTO_IPV6, |
|
CTL_CREATE, CTL_EOL); |
} |
} |