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.82.2.3 and 1.101

version 1.82.2.3, 2006/09/09 02:58:55

version 1.101, 2007/03/24 00:42:14

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

#include <netinet/in.h>

#include <netinet/in_systm.h>

#include <netinet/in_pcb.h>

#ifdef INET

#include <netinet/ip.h>

#include <netinet/ip_icmp.h>

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

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

#include <netinet/ip6.h>

#include <netinet6/in6_var.h>

#include <netinet6/ip6_var.h>

#include <netinet6/in6_pcb.h>

#include <netinet/icmp6.h>

#include <netinet6/scope6_var.h>

#include <netinet6/in6_ifattach.h>

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

#include <netinet6/ipsec.h>

#endif

#ifdef FAST_IPSEC

#include <netipsec/ipsec.h>

#include <netipsec/ipsec6.h>

#include <netipsec/key.h>

#endif /* FAST_IPSEC */

#include <netinet6/ip6protosw.h>

#include "faith.h"

Line 176 ip6_init()

Line 182 ip6_init()

ip6_desync_factor = arc4random() % MAX_TEMP_DESYNC_FACTOR;

ip6_init2((void *)0);

#ifdef GATEWAY

ip6flow_init(ip6_hashsize);

#endif

#ifdef PFIL_HOOKS

/* Register our Packet Filter hook. */

Line 189 ip6_init()

Line 198 ip6_init()

}

static void

ip6_init2(dummy)

ip6_init2(void *dummy)

void *dummy;

{

/* nd6_timer_init */

Line 232 ip6intr()

Line 240 ip6intr()

extern struct route_in6 ip6_forward_rt;

void

ip6_input(m)

ip6_input(struct mbuf *m)

struct mbuf *m;

{

struct ip6_hdr *ip6;

int off = sizeof(struct ip6_hdr), nest;

Line 242 ip6_input(m)

Line 249 ip6_input(m)

int nxt, ours = 0;

struct ifnet *deliverifp = NULL;

int srcrt = 0;

#ifdef FAST_IPSEC

struct m_tag *mtag;

struct tdb_ident *tdbi;

struct secpolicy *sp;

int s, error;

#endif

#ifdef IPSEC

Line 266 ip6_input(m)

Line 279 ip6_input(m)

else

ip6stat.ip6s_mext1++;

} else {

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

#define M2MMAX __arraycount(ip6stat.ip6s_m2m)

if (m->m_next) {

if (m->m_flags & M_LOOP) {

ip6stat.ip6s_m2m[lo0ifp->if_index]++; /* XXX */

Line 288 ip6_input(m)

Line 301 ip6_input(m)

* 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) {

if (IP6_HDR_ALIGNED_P(mtod(m, void *)) == 0) {

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

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

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

Line 314 ip6_input(m)

Line 327 ip6_input(m)

goto bad;

}

#if defined(IPSEC)

/* IPv6 fast forwarding is not compatible with IPsec. */

m->m_flags &= ~M_CANFASTFWD;

#else

* Assume that we can create a fast-forward IP flow entry

* based on this packet.

m->m_flags |= M_CANFASTFWD;

#endif

#ifdef PFIL_HOOKS

* Run through list of hooks for input packets. If there are any

Line 328 ip6_input(m)

Line 352 ip6_input(m)

#ifdef IPSEC

if (!ipsec_getnhist(m))

#elif defined(FAST_IPSEC)

if (!ipsec_indone(m))

#else

if (1)

#endif

Line 451 ip6_input(m)

Line 477 ip6_input(m)

* Unicast check

if (ip6_forward_rt.ro_rt != NULL &&

if (!IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst,

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

&((const struct sockaddr_in6 *)rtcache_getdst((const struct route *)&ip6_forward_rt))->sin6_addr))

IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst,

rtcache_free((struct route *)&ip6_forward_rt);

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

else

rtcache_check((struct route *)&ip6_forward_rt);

if (ip6_forward_rt.ro_rt != NULL) {

/* XXX Revalidated route is accounted wrongly. */

ip6stat.ip6s_forward_cachehit++;

else {

} else {

struct sockaddr_in6 *dst6;

if (ip6_forward_rt.ro_rt) {

ip6stat.ip6s_forward_cachemiss++;

/* route is down or destination is different */

ip6stat.ip6s_forward_cachemiss++;

RTFREE(ip6_forward_rt.ro_rt);

ip6_forward_rt.ro_rt = 0;

}

bzero(&ip6_forward_rt.ro_dst, sizeof(struct sockaddr_in6));

dst6 = &ip6_forward_rt.ro_dst;

dst6 = (struct sockaddr_in6 *)&ip6_forward_rt.ro_dst;

memset(dst6, 0, sizeof(*dst6));

dst6->sin6_len = sizeof(struct sockaddr_in6);

dst6->sin6_family = AF_INET6;

dst6->sin6_addr = ip6->ip6_dst;

rtalloc((struct route *)&ip6_forward_rt);

rtcache_init((struct route *)&ip6_forward_rt);

}

#define rt6_key(r) ((struct sockaddr_in6 *)((r)->rt_nodes->rn_key))

Line 486 ip6_input(m)

Line 510 ip6_input(m)

* But we think it's even useful in some situations, e.g. when using

* a special daemon which wants to intercept the packet.

if (ip6_forward_rt.ro_rt &&

if (ip6_forward_rt.ro_rt != NULL &&

(ip6_forward_rt.ro_rt->rt_flags &

(RTF_HOST|RTF_GATEWAY)) == RTF_HOST &&

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

Line 529 ip6_input(m)

Line 553 ip6_input(m)

#if defined(NFAITH) && 0 < NFAITH

if (ip6_keepfaith) {

if (ip6_forward_rt.ro_rt && ip6_forward_rt.ro_rt->rt_ifp &&

if (ip6_forward_rt.ro_rt != NULL &&

ip6_forward_rt.ro_rt->rt_ifp != NULL &&

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

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

ours = 1;

Line 547 ip6_input(m)

Line 572 ip6_input(m)

* working right.

struct ifaddr *ifa;

for (ifa = m->m_pkthdr.rcvif->if_addrlist.tqh_first;

TAILQ_FOREACH(ifa, &m->m_pkthdr.rcvif->if_addrlist, ifa_list) {

ifa;

ifa = ifa->ifa_list.tqe_next) {

if (ifa->ifa_addr == NULL)

continue; /* just for safety */

if (ifa->ifa_addr->sa_family != AF_INET6)

Line 630 ip6_input(m)

Line 653 ip6_input(m)

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

icmp6_error(m, ICMP6_PARAM_PROB,

ICMP6_PARAMPROB_HEADER,

(caddr_t)&ip6->ip6_plen - (caddr_t)ip6);

(char *)&ip6->ip6_plen - (char *)ip6);

return;

}

IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m, sizeof(struct ip6_hdr),

Line 757 ip6_input(m)

Line 780 ip6_input(m)

goto bad;

}

#endif

#ifdef FAST_IPSEC

* enforce IPsec policy checking if we are seeing last header.

* note that we do not visit this with protocols with pcb layer

* code - like udp/tcp/raw ip.

if ((inet6sw[ip_protox[nxt]].pr_flags & PR_LASTHDR) != 0) {

* Check if the packet has already had IPsec processing

* done. If so, then just pass it along. This tag gets

* set during AH, ESP, etc. input handling, before the

* packet is returned to the ip input queue for delivery.

mtag = m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL);

s = splsoftnet();

if (mtag != NULL) {

tdbi = (struct tdb_ident *)(mtag + 1);

sp = ipsec_getpolicy(tdbi, IPSEC_DIR_INBOUND);

} else {

sp = ipsec_getpolicybyaddr(m, IPSEC_DIR_INBOUND,

IP_FORWARDING, &error);

}

if (sp != NULL) {

* Check security policy against packet attributes.

error = ipsec_in_reject(sp, m);

KEY_FREESP(&sp);

} else {

/* XXX error stat??? */

error = EINVAL;

DPRINTF(("ip6_input: no SP, packet discarded\n"));/*XXX*/

goto bad;

}

splx(s);

if (error)

goto bad;

}

#endif /* FAST_IPSEC */

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

}

Line 887 ip6_process_hopopts(m, opthead, hbhlen,

Line 950 ip6_process_hopopts(m, opthead, hbhlen,

return (-1);

}

optlen = IP6OPT_RTALERT_LEN;

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

bcopy((void *)(opt + 2), (void *)&rtalert_val, 2);

*rtalertp = ntohs(rtalert_val);

break;

case IP6OPT_JUMBO:

Line 1029 ip6_unknown_opt(optp, m, off)

Line 1092 ip6_unknown_opt(optp, m, off)

* you are using IP6_EXTHDR_CHECK() not m_pulldown())

void

ip6_savecontrol(inp, mp, ip6, m)

ip6_savecontrol(in6p, mp, ip6, m)

struct inpcb *inp;

struct in6pcb *in6p;

struct mbuf **mp;

struct ip6_hdr *ip6;

struct mbuf *m;

Line 1042 ip6_savecontrol(inp, mp, ip6, m)

Line 1105 ip6_savecontrol(inp, mp, ip6, m)

#endif

#ifdef SO_TIMESTAMP

if (inp->inp_socket->so_options & SO_TIMESTAMP) {

if (in6p->in6p_socket->so_options & SO_TIMESTAMP) {

struct timeval tv;

microtime(&tv);

*mp = sbcreatecontrol((caddr_t) &tv, sizeof(tv),

*mp = sbcreatecontrol((void *) &tv, sizeof(tv),

SCM_TIMESTAMP, SOL_SOCKET);

if (*mp)

mp = &(*mp)->m_next;

Line 1058 ip6_savecontrol(inp, mp, ip6, m)

Line 1121 ip6_savecontrol(inp, mp, ip6, m)

return;

/* RFC 2292 sec. 5 */

if ((inp->inp_flags & IN6P_PKTINFO) != 0) {

if ((in6p->in6p_flags & IN6P_PKTINFO) != 0) {

struct in6_pktinfo pi6;

bcopy(&ip6->ip6_dst, &pi6.ipi6_addr, sizeof(struct in6_addr));

in6_clearscope(&pi6.ipi6_addr); /* XXX */

pi6.ipi6_ifindex = m->m_pkthdr.rcvif ?

m->m_pkthdr.rcvif->if_index : 0;

*mp = sbcreatecontrol((caddr_t) &pi6,

*mp = sbcreatecontrol((void *) &pi6,

sizeof(struct in6_pktinfo),

IS2292(IPV6_2292PKTINFO, IPV6_PKTINFO), IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

}

if (inp->inp_flags & IN6P_HOPLIMIT) {

if (in6p->in6p_flags & IN6P_HOPLIMIT) {

int hlim = ip6->ip6_hlim & 0xff;

*mp = sbcreatecontrol((caddr_t) &hlim, sizeof(int),

*mp = sbcreatecontrol((void *) &hlim, sizeof(int),

IS2292(IPV6_2292HOPLIMIT, IPV6_HOPLIMIT), IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

Line 1088 ip6_savecontrol(inp, mp, ip6, m)

Line 1152 ip6_savecontrol(inp, mp, ip6, m)

flowinfo >>= 20;

tclass = flowinfo & 0xff;

*mp = sbcreatecontrol((caddr_t)&tclass, sizeof(tclass),

*mp = sbcreatecontrol((void *)&tclass, sizeof(tclass),

IPV6_TCLASS, IPPROTO_IPV6);

if (*mp)

Line 1102 ip6_savecontrol(inp, mp, ip6, m)

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

* returned to normal user.

* See also RFC3542 section 8 (or RFC2292 section 6).

if ((inp->inp_flags & IN6P_HOPOPTS) != 0) {

if ((in6p->in6p_flags & IN6P_HOPOPTS) != 0) {

* Check if a hop-by-hop options header is contatined in the

* received packet, and if so, store the options as ancillary

Line 1136 ip6_savecontrol(inp, mp, ip6, m)

Line 1200 ip6_savecontrol(inp, mp, ip6, m)

* be removed before returning in the RFC 2292.

* Note: this constraint is removed in RFC3542.

*mp = sbcreatecontrol((caddr_t)hbh, hbhlen,

*mp = sbcreatecontrol((void *)hbh, hbhlen,

IS2292(IPV6_2292HOPOPTS, IPV6_HOPOPTS),

IPPROTO_IPV6);

if (*mp)

Line 1146 ip6_savecontrol(inp, mp, ip6, m)

Line 1210 ip6_savecontrol(inp, mp, ip6, m)

}

/* IPV6_DSTOPTS and IPV6_RTHDR socket options */

if (inp->inp_flags & (IN6P_DSTOPTS | IN6P_RTHDR)) {

if (in6p->in6p_flags & (IN6P_DSTOPTS | IN6P_RTHDR)) {

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

int nxt = xip6->ip6_nxt, off = sizeof(struct ip6_hdr);

Line 1195 ip6_savecontrol(inp, mp, ip6, m)

Line 1259 ip6_savecontrol(inp, mp, ip6, m)

switch (nxt) {

case IPPROTO_DSTOPTS:

if (!inp->inp_flags & IN6P_DSTOPTS)

if (!in6p->in6p_flags & IN6P_DSTOPTS)

break;

*mp = sbcreatecontrol((caddr_t)ip6e, elen,

*mp = sbcreatecontrol((void *)ip6e, elen,

IS2292(IPV6_2292DSTOPTS, IPV6_DSTOPTS),

IPPROTO_IPV6);

if (*mp)

Line 1206 ip6_savecontrol(inp, mp, ip6, m)

Line 1270 ip6_savecontrol(inp, mp, ip6, m)

break;

case IPPROTO_ROUTING:

if (!inp->inp_flags & IN6P_RTHDR)

if (!in6p->in6p_flags & IN6P_RTHDR)

break;

*mp = sbcreatecontrol((caddr_t)ip6e, elen,

*mp = sbcreatecontrol((void *)ip6e, elen,

IS2292(IPV6_2292RTHDR, IPV6_RTHDR),

IPPROTO_IPV6);

if (*mp)

Line 1247 ip6_savecontrol(inp, mp, ip6, m)

Line 1311 ip6_savecontrol(inp, mp, ip6, m)

void

ip6_notify_pmtu(struct in6pcb *in6p, struct sockaddr_in6 *dst, uint32_t *mtu)

ip6_notify_pmtu(struct in6pcb *in6p, const struct sockaddr_in6 *dst,

uint32_t *mtu)

{

struct socket *so;

struct mbuf *m_mtu;

Line 1269 ip6_notify_pmtu(struct in6pcb *in6p, str

Line 1334 ip6_notify_pmtu(struct in6pcb *in6p, str

if (sa6_recoverscope(&mtuctl.ip6m_addr))

return;

if ((m_mtu = sbcreatecontrol((caddr_t)&mtuctl, sizeof(mtuctl),

if ((m_mtu = sbcreatecontrol((void *)&mtuctl, sizeof(mtuctl),

IPV6_PATHMTU, IPPROTO_IPV6)) == NULL)

return;

if (sbappendaddr(&so->so_rcv, (struct sockaddr *)dst, NULL, m_mtu)

if (sbappendaddr(&so->so_rcv, (const struct sockaddr *)dst, NULL, m_mtu)

== 0) {

m_freem(m_mtu);

/* XXX: should count statistics */

Line 1309 ip6_pullexthdr(m, off, nxt)

Line 1374 ip6_pullexthdr(m, off, nxt)

}

#endif

m_copydata(m, off, sizeof(ip6e), (caddr_t)&ip6e);

m_copydata(m, off, sizeof(ip6e), (void *)&ip6e);

if (nxt == IPPROTO_AH)

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

else

Line 1332 ip6_pullexthdr(m, off, nxt)

Line 1397 ip6_pullexthdr(m, off, nxt)

return NULL;

}

m_copydata(m, off, elen, mtod(n, caddr_t));

m_copydata(m, off, elen, mtod(n, void *));

n->m_len = elen;

return n;

}

Line 1365 ip6_get_prevhdr(m, off)

Line 1430 ip6_get_prevhdr(m, off)

nxt = ip6->ip6_nxt;

len = sizeof(struct ip6_hdr);

while (len < off) {

ip6e = (struct ip6_ext *)(mtod(m, caddr_t) + len);

ip6e = (struct ip6_ext *)(mtod(m, char *) + len);

switch (nxt) {

case IPPROTO_FRAGMENT:

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

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

return -1;

if (m->m_pkthdr.len < off + sizeof(ip6))

return -1;

m_copydata(m, off, sizeof(ip6), (caddr_t)&ip6);

m_copydata(m, off, sizeof(ip6), (void *)&ip6);

if (nxtp)

*nxtp = ip6.ip6_nxt;

off += sizeof(ip6);

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

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

if (m->m_pkthdr.len < off + sizeof(fh))

return -1;

m_copydata(m, off, sizeof(fh), (caddr_t)&fh);

m_copydata(m, off, sizeof(fh), (void *)&fh);

if ((fh.ip6f_offlg & IP6F_OFF_MASK) != 0)

return -1;

if (nxtp)

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

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

case IPPROTO_AH:

if (m->m_pkthdr.len < off + sizeof(ip6e))

return -1;

m_copydata(m, off, sizeof(ip6e), (caddr_t)&ip6e);

m_copydata(m, off, sizeof(ip6e), (void *)&ip6e);

if (nxtp)

*nxtp = ip6e.ip6e_nxt;

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

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

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

case IPPROTO_DSTOPTS:

if (m->m_pkthdr.len < off + sizeof(ip6e))

return -1;

m_copydata(m, off, sizeof(ip6e), (caddr_t)&ip6e);

m_copydata(m, off, sizeof(ip6e), (void *)&ip6e);

if (nxtp)

*nxtp = ip6e.ip6e_nxt;

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

Line 1540 ip6_delaux(m)

Line 1605 ip6_delaux(m)

m_tag_delete(m, mtag);

}

#ifdef GATEWAY

* sysctl helper routine for net.inet.ip6.maxflows. Since

* we could reduce this value, call ip6flow_reap();

static int

sysctl_net_inet6_ip6_maxflows(SYSCTLFN_ARGS)

{

int s;

s = sysctl_lookup(SYSCTLFN_CALL(rnode));

if (s || newp == NULL)

return (s);

s = splsoftnet();

ip6flow_reap(0);

splx(s);

return (0);

}

static int

sysctl_net_inet6_ip6_hashsize(SYSCTLFN_ARGS)

{

int error, tmp;

struct sysctlnode node;

node = *rnode;

tmp = ip6_hashsize;

node.sysctl_data = &tmp;

error = sysctl_lookup(SYSCTLFN_CALL(&node));

if (error || newp == NULL)

return (error);

if ((tmp & (tmp - 1)) == 0 && tmp != 0) {

* Can only fail due to malloc()

if (ip6flow_invalidate_all(tmp))

return ENOMEM;

} else {

* EINVAL if not a power of 2

return EINVAL;

}

return (0);

}

#endif /* GATEWAY */

* System control for IP6

Line 1823 SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,

Line 1939 SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,

NULL, 0, &ip6_mcast_pmtu, 0,

CTL_NET, PF_INET6, IPPROTO_IPV6,

CTL_CREATE, CTL_EOL);

#ifdef GATEWAY

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "maxflows",

SYSCTL_DESCR("Number of flows for fast forwarding (IPv6)"),

sysctl_net_inet6_ip6_maxflows, 0, &ip6_maxflows, 0,

CTL_NET, PF_INET6, IPPROTO_IPV6,

CTL_CREATE, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "hashsize",

SYSCTL_DESCR("Size of hash table for fast forwarding (IPv6)"),

sysctl_net_inet6_ip6_hashsize, 0, &ip6_hashsize, 0,

CTL_NET, PF_INET6, IPPROTO_IPV6,

CTL_CREATE, CTL_EOL);

#endif

}

CVSweb <webmaster@jp.NetBSD.org>