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.41 and 1.41.2.4

version 1.41, 2001/04/13 23:30:26

version 1.41.2.4, 2002/09/06 08:49:32

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 82

Line 85

#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 97

Line 101

#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 105

Line 109

#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 116

Line 119

/* 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 153 ip6_init()

Line 159 ip6_init()

{

struct ip6protosw *pr;

int i;

struct timeval tv;

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

if (pr == 0)

Line 168 ip6_init()

Line 173 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 243 ip6_input(m)

Line 235 ip6_input(m)

* should the inner packet be considered authentic?

* see comment in ah4_input().

if (m) {

m->m_flags &= ~M_AUTHIPHDR;

m->m_flags &= ~M_AUTHIPDGM;

}

#endif

* mbuf statistics by kazu

* mbuf statistics

if (m->m_flags & M_EXT) {

if (m->m_next)

Line 261 ip6_input(m)

Line 251 ip6_input(m)

#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)

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

else

Line 279 ip6_input(m)

Line 269 ip6_input(m)

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

#endif

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

struct ifnet *inifp;

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

inifp = m->m_pkthdr.rcvif;

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

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

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

* 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 310 ip6_input(m)

Line 314 ip6_input(m)

* not the decapsulated packet.

#ifdef IPSEC

if (!ipsec_gethist(m, NULL))

if (!ipsec_getnhist(m))

#else

if (1)

#endif

Line 324 ip6_input(m)

Line 328 ip6_input(m)

}

#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 336 ip6_input(m)

Line 338 ip6_input(m)

#endif

* Scope check

* Check against address spoofing/corruption.

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 the spec. Malicious party

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

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

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

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

* and 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 SIIT cloud. As none of BSDs support

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

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

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

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

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

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

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

* for SIIT environment.

* partial support for SIIT environment.

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

IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) {

Line 463 ip6_input(m)

Line 468 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 500 ip6_input(m)

Line 505 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 507 ip6_input(m)

Line 513 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 535 ip6_input(m)

Line 541 ip6_input(m)

}

* FAITH(Firewall Aided Internet Translator)

* FAITH (Firewall Aided Internet Translator)

#if defined(NFAITH) && 0 < NFAITH

if (ip6_keepfaith) {

Line 543 ip6_input(m)

Line 549 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 604 ip6_input(m)

Line 610 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 612 ip6_input(m)

Line 618 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 633 ip6_input(m)

Line 639 ip6_input(m)

return;

}

#endif

KASSERT(IP6_HDR_ALIGNED_P(hbh));

nxt = hbh->ip6h_nxt;

Line 687 ip6_input(m)

Line 694 ip6_input(m)

} else if (!ours) {

ip6_forward(m, 0);

return;

}

ip6 = mtod(m, struct ip6_hdr *);

Line 750 ip6_input(m)

Line 757 ip6_input(m)

goto bad;

}

#endif

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

}

return;

Line 797 ip6_hopopts_input(plenp, rtalertp, mp, o

Line 804 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);

Line 815 ip6_hopopts_input(plenp, rtalertp, mp, o

Line 823 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 829 ip6_process_hopopts(m, opthead, hbhlen,

Line 841 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 849 ip6_process_hopopts(m, opthead, hbhlen,

Line 862 ip6_process_hopopts(m, opthead, hbhlen,

goto bad;

}

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

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

/* XXX stat */

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

icmp6_error(m, ICMP6_PARAM_PROB,

*(opt + 1));

ICMP6_PARAMPROB_HEADER,

erroff + opt + 1 - opthead);

return (-1);

}

optlen = IP6OPT_RTALERT_LEN;

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

Line 864 ip6_process_hopopts(m, opthead, hbhlen,

Line 879 ip6_process_hopopts(m, opthead, hbhlen,

goto bad;

}

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

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

/* XXX stat */

log(LOG_ERR, "length of jumbopayload opt "

icmp6_error(m, ICMP6_PARAM_PROB,

"is inconsistent(%d)\n",

ICMP6_PARAMPROB_HEADER,

*(opt + 1));

erroff + opt + 1 - opthead);

return (-1);

}

optlen = IP6OPT_JUMBO_LEN;

Line 879 ip6_process_hopopts(m, opthead, hbhlen,

Line 895 ip6_process_hopopts(m, opthead, hbhlen,

if (ip6->ip6_plen) {

ip6stat.ip6s_badoptions++;

icmp6_error(m, ICMP6_PARAM_PROB,

ICMP6_PARAMPROB_HEADER,

sizeof(struct ip6_hdr) +

erroff + opt - opthead);

sizeof(struct ip6_hbh) +

return (-1);

opt - opthead);

return(-1);

}

Line 905 ip6_process_hopopts(m, opthead, hbhlen,

Line 919 ip6_process_hopopts(m, opthead, hbhlen,

if (*plenp != 0) {

ip6stat.ip6s_badoptions++;

icmp6_error(m, ICMP6_PARAM_PROB,

ICMP6_PARAMPROB_HEADER,

sizeof(struct ip6_hdr) +

erroff + opt + 2 - opthead);

sizeof(struct ip6_hbh) +

return (-1);

opt + 2 - opthead);

return(-1);

}

#endif

Line 919 ip6_process_hopopts(m, opthead, hbhlen,

Line 931 ip6_process_hopopts(m, opthead, hbhlen,

if (jumboplen <= IPV6_MAXPACKET) {

ip6stat.ip6s_badoptions++;

icmp6_error(m, ICMP6_PARAM_PROB,

ICMP6_PARAMPROB_HEADER,

sizeof(struct ip6_hdr) +

erroff + opt + 2 - opthead);

sizeof(struct ip6_hbh) +

return (-1);

opt + 2 - opthead);

return(-1);

}

*plenp = jumboplen;

Line 933 ip6_process_hopopts(m, opthead, hbhlen,

Line 943 ip6_process_hopopts(m, opthead, hbhlen,

ip6stat.ip6s_toosmall++;

goto bad;

}

if ((optlen = ip6_unknown_opt(opt, m,

optlen = ip6_unknown_opt(opt, m,

sizeof(struct ip6_hdr) +

erroff + opt - opthead);

sizeof(struct ip6_hbh) +

if (optlen == -1)

opt - opthead)) == -1)

return (-1);

return(-1);

optlen += 2;

break;

}

return(0);

return (0);

bad:

m_freem(m);

return(-1);

return (-1);

}

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

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

return;

}

#endif

KASSERT(IP6_HDR_ALIGNED_P(ip6e));

switch (nxt) {

case IPPROTO_DSTOPTS:

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

Line 1333 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 1334 ip6_nexthdr(m, off, proto, nxtp)

Line 1346 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 1393 u_char inet6ctlerrmap[PRC_NCMDS] = {

Line 1407 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 1443 ip6_sysctl(name, namelen, oldp, oldlenp,

Line 1454 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 1453 ip6_sysctl(name, namelen, oldp, oldlenp,

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

&ip6_use_deprecated);

case IPV6CTL_RR_PRUNE:

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

#ifndef INET6_BINDV6ONLY

case IPV6CTL_V6ONLY:

case IPV6CTL_BINDV6ONLY:

#ifdef INET6_BINDV6ONLY

return sysctl_int(oldp, oldlenp, newp, newlen,

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

&ip6_bindv6only);

#else

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

#endif

case IPV6CTL_ANONPORTMIN:

old = ip6_anonportmin;

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

Line 1524 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>