src/sys/netinet6/ip6_input.c - diff

Return to ip6_input.c CVS log

Up to [cvs.NetBSD.org] / src / sys / netinet6

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/netinet6/ip6_input.c between version 1.37.2.14 and 1.38

version 1.37.2.14, 2002/10/18 02:45:23

version 1.38, 2001/03/16 12:22:34

Line 1

/* $NetBSD$ */

/* $KAME: ip6_input.c,v 1.188 2001/03/29 05:34:31 itojun Exp $ */

/* $KAME: ip6_input.c,v 1.183 2001/03/01 15:15:23 itojun Exp $ */

Line 65

* @(#)ip_input.c 8.2 (Berkeley) 1/4/94

#include <sys/cdefs.h>

__KERNEL_RCSID(0, "$NetBSD$");

#include "opt_inet.h"

#include "opt_ipsec.h"

#include "opt_pfil_hooks.h"

Line 85 __KERNEL_RCSID(0, "$NetBSD$");

Line 82 __KERNEL_RCSID(0, "$NetBSD$");

#include <sys/kernel.h>

#include <sys/syslog.h>

#include <sys/proc.h>

#include <sys/sysctl.h>

#include <net/if.h>

#include <net/if_types.h>

Line 101 __KERNEL_RCSID(0, "$NetBSD$");

Line 97 __KERNEL_RCSID(0, "$NetBSD$");

#ifdef INET

#include <netinet/ip.h>

#include <netinet/ip_icmp.h>

#endif /* INET */

#endif /*INET*/

#include <netinet/ip6.h>

#include <netinet6/in6_var.h>

#include <netinet6/ip6_var.h>

Line 109 __KERNEL_RCSID(0, "$NetBSD$");

Line 105 __KERNEL_RCSID(0, "$NetBSD$");

#include <netinet/icmp6.h>

#include <netinet6/in6_ifattach.h>

#include <netinet6/nd6.h>

#include <netinet6/in6_prefix.h>

#ifdef IPSEC

#include <netinet6/ipsec.h>

Line 119 __KERNEL_RCSID(0, "$NetBSD$");

Line 116 __KERNEL_RCSID(0, "$NetBSD$");

/* we need it for NLOOP. */

#include "loop.h"

#include "faith.h"

#include "gif.h"

#include "bpfilter.h"

#if NGIF > 0

#include <netinet6/in6_gif.h>

#endif

#include <net/net_osdep.h>

extern struct domain inet6domain;

Line 159 ip6_init()

Line 153 ip6_init()

{

struct ip6protosw *pr;

int i;

struct timeval tv;

pr = (struct ip6protosw *)pffindproto(PF_INET6, IPPROTO_RAW, SOCK_RAW);

if (pr == 0)

Line 173 ip6_init()

Line 168 ip6_init()

ip6intrq.ifq_maxlen = ip6qmaxlen;

nd6_init();

frag6_init();

ip6_flow_seq = arc4random();

* in many cases, random() here does NOT return random number

* as initialization during bootstrap time occur in fixed order.

microtime(&tv);

ip6_flow_seq = random() ^ tv.tv_usec;

ip6_init2((void *)0);

Line 192 static void

ip6_init2(dummy)

void *dummy;

{

* to route local address of p2p link to loopback,

* assign loopback address first.

in6_ifattach(&loif[0], NULL);

/* nd6_timer_init */

callout_init(&nd6_timer_ch);

callout_reset(&nd6_timer_ch, hz, nd6_timer, NULL);

/* router renumbering prefix list maintenance */

callout_init(&in6_rr_timer_ch);

callout_reset(&in6_rr_timer_ch, hz, in6_rr_timer, NULL);

}

Line 208 ip6intr()

Line 216 ip6intr()

struct mbuf *m;

for (;;) {

s = splnet();

s = splimp();

IF_DEQUEUE(&ip6intrq, m);

splx(s);

if (m == 0)

Line 235 ip6_input(m)

Line 243 ip6_input(m)

* should the inner packet be considered authentic?

* see comment in ah4_input().

m->m_flags &= ~M_AUTHIPHDR;

if (m) {

m->m_flags &= ~M_AUTHIPDGM;

m->m_flags &= ~M_AUTHIPHDR;

m->m_flags &= ~M_AUTHIPDGM;

}

#endif

* mbuf statistics

* mbuf statistics by kazu

if (m->m_flags & M_EXT) {

if (m->m_next)

Line 248 ip6_input(m)

Line 258 ip6_input(m)

else

ip6stat.ip6s_mext1++;

} else {

#define M2MMAX (sizeof(ip6stat.ip6s_m2m)/sizeof(ip6stat.ip6s_m2m[0]))

if (m->m_next) {

if (m->m_flags & M_LOOP) {

ip6stat.ip6s_m2m[loif[0].if_index]++; /* XXX */

ip6stat.ip6s_m2m[loif[0].if_index]++; /*XXX*/

} else if (m->m_pkthdr.rcvif->if_index < M2MMAX)

} else if (m->m_pkthdr.rcvif->if_index <= 31)

ip6stat.ip6s_m2m[m->m_pkthdr.rcvif->if_index]++;

else

ip6stat.ip6s_m2m[0]++;

} else

ip6stat.ip6s_m1++;

#undef M2MMAX

}

in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_receive);

Line 269 ip6_input(m)

Line 277 ip6_input(m)

IP6_EXTHDR_CHECK(m, 0, sizeof(struct ip6_hdr), /*nothing*/);

#endif

if (m->m_len < sizeof(struct ip6_hdr)) {

* If the IPv6 header is not aligned, slurp it up into a new

struct ifnet *inifp;

* mbuf with space for link headers, in the event we forward

inifp = m->m_pkthdr.rcvif;

* it. OTherwise, if it is aligned, make sure the entire base

if ((m = m_pullup(m, sizeof(struct ip6_hdr))) == 0) {

* IPv6 header is in the first mbuf of the chain.

if (IP6_HDR_ALIGNED_P(mtod(m, caddr_t)) == 0) {

struct ifnet *inifp = m->m_pkthdr.rcvif;

if ((m = m_copyup(m, sizeof(struct ip6_hdr),

(max_linkhdr + 3) & ~3)) == NULL) {

/* XXXJRT new stat, please */

ip6stat.ip6s_toosmall++;

in6_ifstat_inc(inifp, ifs6_in_hdrerr);

return;

}

} else if (__predict_false(m->m_len < sizeof(struct ip6_hdr))) {

struct ifnet *inifp = m->m_pkthdr.rcvif;

if ((m = m_pullup(m, sizeof(struct ip6_hdr))) == NULL) {

ip6stat.ip6s_toosmall++;

in6_ifstat_inc(inifp, ifs6_in_hdrerr);

return;

Line 309 ip6_input(m)

Line 303 ip6_input(m)

* Note that filters must _never_ set this flag, as another filter

* in the list may have previously cleared it.

if (pfil_run_hooks(&inet6_pfil_hook, &m, m->m_pkthdr.rcvif,

* let ipfilter look at packet on the wire,

PFIL_IN) != 0)

* not the decapsulated packet.

return;

if (m == NULL)

#ifdef IPSEC

return;

if (!ipsec_getnhist(m))

ip6 = mtod(m, struct ip6_hdr *);

#else

if (1)

#endif

{

if (pfil_run_hooks(&inet6_pfil_hook, &m, m->m_pkthdr.rcvif,

PFIL_IN) != 0)

return;

if (m == NULL)

return;

ip6 = mtod(m, struct ip6_hdr *);

}

#endif /* PFIL_HOOKS */

ip6stat.ip6s_nxthist[ip6->ip6_nxt]++;

#ifdef ALTQ

/* XXX Temporary until ALTQ is changed to use a pfil hook */

if (altq_input != NULL && (*altq_input)(m, AF_INET6) == 0) {

/* packet is dropped by traffic conditioner */

return;

Line 338 ip6_input(m)

Line 323 ip6_input(m)

#endif

* Check against address spoofing/corruption.

* Scope check

if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_src) ||

IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_dst)) {

* XXX: "badscope" is not very suitable for a multicast source.

ip6stat.ip6s_badscope++;

in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_addrerr);

goto bad;

}

* The following check is not documented in specs. A malicious

* The following check is not documented in the spec. Malicious party

* party may be able to use IPv4 mapped addr to confuse tcp/udp stack

* may be able to use IPv4 mapped addr to confuse tcp/udp stack and

* and bypass security checks (act as if it was from 127.0.0.1 by using

* bypass security checks (act as if it was from 127.0.0.1 by using

* IPv6 src ::ffff:127.0.0.1). Be cautious.

* This check chokes if we are in an SIIT cloud. As none of BSDs

* This check chokes if we are in SIIT cloud. As none of BSDs support

* support IPv4-less kernel compilation, we cannot support SIIT

* IPv4-less kernel compilation, we cannot support SIIT environment

* environment at all. So, it makes more sense for us to reject any

* at all. So, it makes more sense for us to reject any malicious

* malicious packets for non-SIIT environment, than try to do a

* packets for non-SIIT environment, than try to do a partical support

* partial support for SIIT environment.

* for SIIT environment.

if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) ||

IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) {

Line 409 ip6_input(m)

Line 391 ip6_input(m)

goto bad;

}

#ifndef FAKE_LOOPBACK_IF

if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) == 0)

#else

if (1)

#endif

{

if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src))

ip6->ip6_src.s6_addr16[1]

= htons(m->m_pkthdr.rcvif->if_index);

if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst))

ip6->ip6_dst.s6_addr16[1]

= htons(m->m_pkthdr.rcvif->if_index);

}

if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src))

ip6->ip6_src.s6_addr16[1]

* XXX we need this since we do not have "goto ours" hack route

= htons(m->m_pkthdr.rcvif->if_index);

* for some of our ifaddrs on loopback interface.

if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst))

* we should correct it by changing in6_ifattach to install

ip6->ip6_dst.s6_addr16[1]

* "goto ours" hack route.

= htons(m->m_pkthdr.rcvif->if_index);

if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) != 0) {

if (IN6_IS_ADDR_LINKLOCAL(&ip6->ip6_dst)) {

* We use rt->rt_ifp to determine if the address is ours or not.

ours = 1;

* If rt_ifp is lo0, the address is ours.

deliverifp = m->m_pkthdr.rcvif;

* The problem here is, rt->rt_ifp for fe80::%lo0/64 is set to lo0,

goto hbhcheck;

* 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;

}

Line 468 ip6_input(m)

Line 448 ip6_input(m)

* Unicast check

if (ip6_forward_rt.ro_rt != NULL &&

(ip6_forward_rt.ro_rt->rt_flags & RTF_UP) != 0 &&

IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst,

&((struct sockaddr_in6 *)(&ip6_forward_rt.ro_dst))->sin6_addr))

ip6stat.ip6s_forward_cachehit++;

Line 505 ip6_input(m)

Line 485 ip6_input(m)

if (ip6_forward_rt.ro_rt &&

(ip6_forward_rt.ro_rt->rt_flags &

(RTF_HOST|RTF_GATEWAY)) == RTF_HOST &&

!(ip6_forward_rt.ro_rt->rt_flags & RTF_CLONED) &&

#if 0

* The check below is redundant since the comparison of

Line 513 ip6_input(m)

Line 492 ip6_input(m)

* already done through looking up the routing table.

IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst,

&rt6_key(ip6_forward_rt.ro_rt)->sin6_addr) &&

#endif

ip6_forward_rt.ro_rt->rt_ifp->if_type == IFT_LOOP) {

struct in6_ifaddr *ia6 =

Line 541 ip6_input(m)

Line 520 ip6_input(m)

}

* FAITH (Firewall Aided Internet Translator)

* FAITH(Firewall Aided Internet Translator)

#if defined(NFAITH) && 0 < NFAITH

if (ip6_keepfaith) {

Line 549 ip6_input(m)

Line 528 ip6_input(m)

&& ip6_forward_rt.ro_rt->rt_ifp->if_type == IFT_FAITH) {

/* XXX do we need more sanity checks? */

ours = 1;

deliverifp = ip6_forward_rt.ro_rt->rt_ifp; /* faith */

deliverifp = ip6_forward_rt.ro_rt->rt_ifp; /*faith*/

goto hbhcheck;

}

Line 610 ip6_input(m)

Line 589 ip6_input(m)

ip6 = mtod(m, struct ip6_hdr *);

* if the payload length field is 0 and the next header field

* indicates Hop-by-Hop Options header, then a Jumbo Payload

* option MUST be included.

Line 618 ip6_input(m)

Line 597 ip6_input(m)

* Note that if a valid jumbo payload option is

* contained, ip6_hoptops_input() must set a valid

* (non-zero) payload length to the variable plen.

ip6stat.ip6s_badoptions++;

in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_discard);

Line 639 ip6_input(m)

Line 618 ip6_input(m)

return;

}

#endif

KASSERT(IP6_HDR_ALIGNED_P(hbh));

nxt = hbh->ip6h_nxt;

Line 694 ip6_input(m)

Line 672 ip6_input(m)

} else if (!ours) {

ip6_forward(m, 0);

return;

}

ip6 = mtod(m, struct ip6_hdr *);

Line 728 ip6_input(m)

Line 706 ip6_input(m)

ip6stat.ip6s_delivered++;

in6_ifstat_inc(deliverifp, ifs6_in_deliver);

nest = 0;

while (nxt != IPPROTO_DONE) {

if (ip6_hdrnestlimit && (++nest > ip6_hdrnestlimit)) {

ip6stat.ip6s_toomanyhdr++;

Line 757 ip6_input(m)

Line 734 ip6_input(m)

goto bad;

}

#endif

nxt = (*inet6sw[ip6_protox[nxt]].pr_input)(&m, &off, nxt);

}

return;

Line 804 ip6_hopopts_input(plenp, rtalertp, mp, o

Line 781 ip6_hopopts_input(plenp, rtalertp, mp, o

return -1;

}

#endif

KASSERT(IP6_HDR_ALIGNED_P(hbh));

off += hbhlen;

hbhlen -= sizeof(struct ip6_hbh);

opt = (u_int8_t *)hbh + sizeof(struct ip6_hbh);

if (ip6_process_hopopts(m, (u_int8_t *)hbh + sizeof(struct ip6_hbh),

hbhlen, rtalertp, plenp) < 0)

return (-1);

return(-1);

*offp = off;

*mp = m;

return (0);

return(0);

}

Line 823 ip6_hopopts_input(plenp, rtalertp, mp, o

Line 799 ip6_hopopts_input(plenp, rtalertp, mp, o

* This function is separate from ip6_hopopts_input() in order to

* handle a case where the sending node itself process its hop-by-hop

* options header. In such a case, the function is called from ip6_output().

* The function assumes that hbh header is located right after the IPv6 header

* (RFC2460 p7), opthead is pointer into data content in m, and opthead to

* opthead + hbhlen is located in continuous memory region.

int

ip6_process_hopopts(m, opthead, hbhlen, rtalertp, plenp)

Line 841 ip6_process_hopopts(m, opthead, hbhlen,

Line 813 ip6_process_hopopts(m, opthead, hbhlen,

u_int8_t *opt = opthead;

u_int16_t rtalert_val;

u_int32_t jumboplen;

const int erroff = sizeof(struct ip6_hdr) + sizeof(struct ip6_hbh);

for (; hbhlen > 0; hbhlen -= optlen, opt += optlen) {

switch (*opt) {

Line 862 ip6_process_hopopts(m, opthead, hbhlen,

Line 833 ip6_process_hopopts(m, opthead, hbhlen,

goto bad;

}

if (*(opt + 1) != IP6OPT_RTALERT_LEN - 2) {

/* XXX stat */

/* XXX: should we discard the packet? */

icmp6_error(m, ICMP6_PARAM_PROB,

log(LOG_ERR, "length of router alert opt is inconsitent(%d)",

ICMP6_PARAMPROB_HEADER,

*(opt + 1));

erroff + opt + 1 - opthead);

return (-1);

}

optlen = IP6OPT_RTALERT_LEN;

bcopy((caddr_t)(opt + 2), (caddr_t)&rtalert_val, 2);

Line 879 ip6_process_hopopts(m, opthead, hbhlen,

Line 848 ip6_process_hopopts(m, opthead, hbhlen,

goto bad;

}

if (*(opt + 1) != IP6OPT_JUMBO_LEN - 2) {

/* XXX stat */

/* XXX: should we discard the packet? */

icmp6_error(m, ICMP6_PARAM_PROB,

log(LOG_ERR, "length of jumbopayload opt "

ICMP6_PARAMPROB_HEADER,

"is inconsistent(%d)\n",

erroff + opt + 1 - opthead);

*(opt + 1));

return (-1);

}

optlen = IP6OPT_JUMBO_LEN;

Line 895 ip6_process_hopopts(m, opthead, hbhlen,

Line 863 ip6_process_hopopts(m, opthead, hbhlen,

if (ip6->ip6_plen) {

ip6stat.ip6s_badoptions++;

icmp6_error(m, ICMP6_PARAM_PROB,

ICMP6_PARAMPROB_HEADER,

erroff + opt - opthead);

sizeof(struct ip6_hdr) +

return (-1);

sizeof(struct ip6_hbh) +

opt - opthead);

return(-1);

}

Line 919 ip6_process_hopopts(m, opthead, hbhlen,

Line 889 ip6_process_hopopts(m, opthead, hbhlen,

if (*plenp != 0) {

ip6stat.ip6s_badoptions++;

icmp6_error(m, ICMP6_PARAM_PROB,

ICMP6_PARAMPROB_HEADER,

erroff + opt + 2 - opthead);

sizeof(struct ip6_hdr) +

return (-1);

sizeof(struct ip6_hbh) +

opt + 2 - opthead);

return(-1);

}

#endif

Line 931 ip6_process_hopopts(m, opthead, hbhlen,

Line 903 ip6_process_hopopts(m, opthead, hbhlen,

if (jumboplen <= IPV6_MAXPACKET) {

ip6stat.ip6s_badoptions++;

icmp6_error(m, ICMP6_PARAM_PROB,

ICMP6_PARAMPROB_HEADER,

erroff + opt + 2 - opthead);

sizeof(struct ip6_hdr) +

return (-1);

sizeof(struct ip6_hbh) +

opt + 2 - opthead);

return(-1);

}

*plenp = jumboplen;

Line 943 ip6_process_hopopts(m, opthead, hbhlen,

Line 917 ip6_process_hopopts(m, opthead, hbhlen,

ip6stat.ip6s_toosmall++;

goto bad;

}

optlen = ip6_unknown_opt(opt, m,

if ((optlen = ip6_unknown_opt(opt, m,

erroff + opt - opthead);

sizeof(struct ip6_hdr) +

if (optlen == -1)

sizeof(struct ip6_hbh) +

return (-1);

opt - opthead)) == -1)

return(-1);

optlen += 2;

break;

}

return (0);

return(0);

bad:

m_freem(m);

return (-1);

return(-1);

}

Line 975 ip6_unknown_opt(optp, m, off)

Line 950 ip6_unknown_opt(optp, m, off)

switch (IP6OPT_TYPE(*optp)) {

case IP6OPT_TYPE_SKIP: /* ignore the option */

return ((int)*(optp + 1));

return((int)*(optp + 1));

case IP6OPT_TYPE_DISCARD: /* silently discard */

m_freem(m);

return (-1);

return(-1);

case IP6OPT_TYPE_FORCEICMP: /* send ICMP even if multicasted */

ip6stat.ip6s_badoptions++;

icmp6_error(m, ICMP6_PARAM_PROB, ICMP6_PARAMPROB_OPTION, off);

return (-1);

return(-1);

case IP6OPT_TYPE_ICMP: /* send ICMP if not multicasted */

ip6stat.ip6s_badoptions++;

ip6 = mtod(m, struct ip6_hdr *);

Line 992 ip6_unknown_opt(optp, m, off)

Line 967 ip6_unknown_opt(optp, m, off)

else

icmp6_error(m, ICMP6_PARAM_PROB,

ICMP6_PARAMPROB_OPTION, off);

return (-1);

return(-1);

}

m_freem(m); /* XXX: NOTREACHED */

return (-1);

return(-1);

}

Line 1166 ip6_savecontrol(in6p, mp, ip6, m)

Line 1141 ip6_savecontrol(in6p, mp, ip6, m)

return;

}

#endif

KASSERT(IP6_HDR_ALIGNED_P(ip6e));

switch (nxt) {

case IPPROTO_DSTOPTS:

Line 1243 ip6_savecontrol(in6p, mp, ip6, m)

Line 1217 ip6_savecontrol(in6p, mp, ip6, m)

* carefully. Moreover, it will not be used in the near future when

* we develop `neater' mechanism to process extension headers.

u_int8_t *

char *

ip6_get_prevhdr(m, off)

struct mbuf *m;

int off;

Line 1251 ip6_get_prevhdr(m, off)

Line 1225 ip6_get_prevhdr(m, off)

struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);

if (off == sizeof(struct ip6_hdr))

return (&ip6->ip6_nxt);

return(&ip6->ip6_nxt);

else {

int len, nxt;

struct ip6_ext *ip6e = NULL;

Line 1275 ip6_get_prevhdr(m, off)

Line 1249 ip6_get_prevhdr(m, off)

nxt = ip6e->ip6e_nxt;

}

if (ip6e)

return (&ip6e->ip6e_nxt);

return(&ip6e->ip6e_nxt);

else

return NULL;

}

Line 1333 ip6_nexthdr(m, off, proto, nxtp)

Line 1307 ip6_nexthdr(m, off, proto, nxtp)

if (nxtp)

*nxtp = ip6e.ip6e_nxt;

off += (ip6e.ip6e_len + 2) << 2;

if (m->m_pkthdr.len < off)

return -1;

return off;

case IPPROTO_HOPOPTS:

Line 1346 ip6_nexthdr(m, off, proto, nxtp)

Line 1318 ip6_nexthdr(m, off, proto, nxtp)

if (nxtp)

*nxtp = ip6e.ip6e_nxt;

off += (ip6e.ip6e_len + 1) << 3;

if (m->m_pkthdr.len < off)

return -1;

return off;

case IPPROTO_NONE:

Line 1359 ip6_nexthdr(m, off, proto, nxtp)

Line 1329 ip6_nexthdr(m, off, proto, nxtp)

default:

return -1;

}

return -1;

}

Line 1405 u_char inet6ctlerrmap[PRC_NCMDS] = {

Line 1377 u_char inet6ctlerrmap[PRC_NCMDS] = {

ENOPROTOOPT

};

#include <uvm/uvm_extern.h>

#include <sys/sysctl.h>

int

ip6_sysctl(name, namelen, oldp, oldlenp, newp, newlen)

int *name;

Line 1452 ip6_sysctl(name, namelen, oldp, oldlenp,

Line 1427 ip6_sysctl(name, namelen, oldp, oldlenp,

case IPV6CTL_DEFMCASTHLIM:

return sysctl_int(oldp, oldlenp, newp, newlen,

&ip6_defmcasthlim);

#if NGIF > 0

case IPV6CTL_GIF_HLIM:

return sysctl_int(oldp, oldlenp, newp, newlen,

&ip6_gif_hlim);

#endif

case IPV6CTL_KAME_VERSION:

return sysctl_rdstring(oldp, oldlenp, newp, __KAME_VERSION);

case IPV6CTL_USE_DEPRECATED:

Line 1464 ip6_sysctl(name, namelen, oldp, oldlenp,

Line 1437 ip6_sysctl(name, namelen, oldp, oldlenp,

&ip6_use_deprecated);

case IPV6CTL_RR_PRUNE:

return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_rr_prune);

case IPV6CTL_V6ONLY:

#ifndef INET6_BINDV6ONLY

#ifdef INET6_BINDV6ONLY

case IPV6CTL_BINDV6ONLY:

return sysctl_rdint(oldp, oldlenp, newp, ip6_v6only);

return sysctl_int(oldp, oldlenp, newp, newlen,

#else

&ip6_bindv6only);

return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_v6only);

#endif

case IPV6CTL_ANONPORTMIN:

old = ip6_anonportmin;

Line 1522 ip6_sysctl(name, namelen, oldp, oldlenp,

Line 1494 ip6_sysctl(name, namelen, oldp, oldlenp,

}

return (error);

#endif

case IPV6CTL_MAXFRAGS:

return sysctl_int(oldp, oldlenp, newp, newlen, &ip6_maxfrags);

default:

return EOPNOTSUPP;

}

CVSweb <webmaster@jp.NetBSD.org>