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.78.2.3 and 1.83.2.1

version 1.78.2.3, 2007/02/26 09:11:52

version 1.83.2.1, 2006/04/19 04:46:12

Line 65

__KERNEL_RCSID(0, "$NetBSD$");

#include "opt_inet.h"

#include "opt_inet6.h"

#include "opt_ipsec.h"

#include "opt_pfil_hooks.h"

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

Line 111 __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 195 ip6_init()

Line 188 ip6_init()

}

static void

ip6_init2(void *dummy)

ip6_init2(dummy)

void *dummy;

{

/* nd6_timer_init */

Line 237 ip6intr()

Line 231 ip6intr()

extern struct route_in6 ip6_forward_rt;

void

ip6_input(struct mbuf *m)

ip6_input(m)

struct mbuf *m;

{

struct ip6_hdr *ip6;

int off = sizeof(struct ip6_hdr), nest;

Line 246 ip6_input(struct mbuf *m)

Line 241 ip6_input(struct mbuf *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 276 ip6_input(struct mbuf *m)

Line 265 ip6_input(struct mbuf *m)

else

ip6stat.ip6s_mext1++;

} else {

#define M2MMAX __arraycount(ip6stat.ip6s_m2m)

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

if (m->m_next) {

if (m->m_flags & M_LOOP) {

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

Line 338 ip6_input(struct mbuf *m)

Line 327 ip6_input(struct mbuf *m)

#ifdef IPSEC

if (!ipsec_getnhist(m))

#elif defined(FAST_IPSEC)

if (!ipsec_indone(m))

#else

if (1)

#endif

Line 422 ip6_input(struct mbuf *m)

Line 409 ip6_input(struct mbuf *m)

* dst are the loopback address and the receiving interface

* is not loopback.

if (__predict_false(

m_makewritable(&m, 0, sizeof(struct ip6_hdr), M_DONTWAIT)))

goto bad;

ip6 = mtod(m, struct ip6_hdr *);

if (in6_clearscope(&ip6->ip6_src) || in6_clearscope(&ip6->ip6_dst)) {

ip6stat.ip6s_badscope++; /* XXX */

goto bad;

Line 463 ip6_input(struct mbuf *m)

Line 446 ip6_input(struct mbuf *m)

* Unicast check

if (!IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst,

if (ip6_forward_rt.ro_rt != NULL &&

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

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

rtcache_free((struct route *)&ip6_forward_rt);

IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst,

else

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

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;

ip6stat.ip6s_forward_cachemiss++;

if (ip6_forward_rt.ro_rt) {

/* route is down or destination is different */

ip6stat.ip6s_forward_cachemiss++;

RTFREE(ip6_forward_rt.ro_rt);

ip6_forward_rt.ro_rt = 0;

}

dst6 = &ip6_forward_rt.ro_dst;

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

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

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

dst6->sin6_len = sizeof(struct sockaddr_in6);

dst6->sin6_family = AF_INET6;

dst6->sin6_addr = ip6->ip6_dst;

rtcache_init((struct route *)&ip6_forward_rt);

rtalloc((struct route *)&ip6_forward_rt);

}

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

Line 496 ip6_input(struct mbuf *m)

Line 481 ip6_input(struct mbuf *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 != NULL &&

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

Line 539 ip6_input(struct mbuf *m)

Line 524 ip6_input(struct mbuf *m)

#if defined(NFAITH) && 0 < NFAITH

if (ip6_keepfaith) {

if (ip6_forward_rt.ro_rt != NULL &&

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

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 558 ip6_input(struct mbuf *m)

Line 542 ip6_input(struct mbuf *m)

* working right.

struct ifaddr *ifa;

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

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

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 766 ip6_input(struct mbuf *m)

Line 752 ip6_input(struct mbuf *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 1084 ip6_savecontrol(in6p, mp, ip6, m)

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

struct ip6_hdr *ip6;

struct mbuf *m;

{

#ifdef RFC2292

#define IS2292(x, y) ((in6p->in6p_flags & IN6P_RFC2292) ? (x) : (y))

#else

#define IS2292(x, y) (y)

#endif

#ifdef SO_TIMESTAMP

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

struct timeval tv;

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

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

mp = &(*mp)->m_next;

}

#endif

if (in6p->in6p_flags & IN6P_RECVDSTADDR) {

*mp = sbcreatecontrol((caddr_t) &ip6->ip6_dst,

sizeof(struct in6_addr), IPV6_RECVDSTADDR, IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

}

/* some OSes call this logic with IPv4 packet, for SO_TIMESTAMP */

#ifdef noyet

if ((ip6->ip6_vfc & IPV6_VERSION_MASK) != IPV6_VERSION)

/* options were tossed above */

return;

if (in6p->in6p_flags & IN6P_RECVOPTS)

/* broken */

/* ip6_srcroute doesn't do what we want here, need to fix */

if (in6p->in6p_flags & IPV6P_RECVRETOPTS)

/* broken */

#endif

/* RFC 2292 sec. 5 */

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,

sizeof(struct in6_pktinfo),

sizeof(struct in6_pktinfo), IPV6_PKTINFO, IPPROTO_IPV6);

IS2292(IPV6_2292PKTINFO, IPV6_PKTINFO), IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

}

if (in6p->in6p_flags & IN6P_HOPLIMIT) {

int hlim = ip6->ip6_hlim & 0xff;

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

IS2292(IPV6_2292HOPLIMIT, IPV6_HOPLIMIT), IPPROTO_IPV6);

IPV6_HOPLIMIT, IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

}

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

u_int32_t flowinfo;

int tclass;

flowinfo = (u_int32_t)ntohl(ip6->ip6_flow & IPV6_FLOWINFO_MASK);

flowinfo >>= 20;

tclass = flowinfo & 0xff;

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

IPV6_TCLASS, IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

}

/* IN6P_NEXTHOP - for outgoing packet only */

* IPV6_HOPOPTS socket option. Recall that we required super-user

* privilege for the option (see ip6_ctloutput), but it might be too

* strict, since there might be some hop-by-hop options which can be

* returned to normal user.

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

* See also RFC 2292 section 6.

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

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

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

* XXX: We copy whole the header even if a jumbo

* payload option is included, which option is to

* be removed before returning in the RFC 2292.

* Note: this constraint is removed in RFC3542.

* But it's too painful operation...

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

IS2292(IPV6_2292HOPOPTS, IPV6_HOPOPTS),

IPV6_HOPOPTS, IPPROTO_IPV6);

IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

m_freem(ext);

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

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

* Note that the order of the headers remains in

* the chain of ancillary data.

for (;;) { /* is explicit loop prevention necessary? */

while (1) { /* is explicit loop prevention necessary? */

struct ip6_ext *ip6e = NULL;

int elen;

struct mbuf *ext = NULL;

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

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

break;

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

IS2292(IPV6_2292DSTOPTS, IPV6_DSTOPTS),

IPV6_DSTOPTS, IPPROTO_IPV6);

IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

break;

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

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

break;

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

IS2292(IPV6_2292RTHDR, IPV6_RTHDR),

IPV6_RTHDR, IPPROTO_IPV6);

IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

break;

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

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

;

}

#undef IS2292

void

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

uint32_t *mtu)

{

struct socket *so;

struct mbuf *m_mtu;

struct ip6_mtuinfo mtuctl;

so = in6p->in6p_socket;

if (mtu == NULL)

return;

#ifdef DIAGNOSTIC

if (so == NULL) /* I believe this is impossible */

panic("ip6_notify_pmtu: socket is NULL");

#endif

memset(&mtuctl, 0, sizeof(mtuctl)); /* zero-clear for safety */

mtuctl.ip6m_mtu = *mtu;

mtuctl.ip6m_addr = *dst;

if (sa6_recoverscope(&mtuctl.ip6m_addr))

return;

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

IPV6_PATHMTU, IPPROTO_IPV6)) == NULL)

return;

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

== 0) {

m_freem(m_mtu);

/* XXX: should count statistics */

} else

sorwakeup(so);

return;

}

* pull single extension header from mbuf chain. returns single mbuf that

Line 1538 ip6_lasthdr(m, off, proto, nxtp)

Line 1428 ip6_lasthdr(m, off, proto, nxtp)

nxt = -1;

nxtp = &nxt;

}

for (;;) {

while (1) {

newoff = ip6_nexthdr(m, off, proto, nxtp);

if (newoff < 0)

return off;

Line 1606 u_char inet6ctlerrmap[PRC_NCMDS] = {

Line 1496 u_char inet6ctlerrmap[PRC_NCMDS] = {

SYSCTL_SETUP(sysctl_net_inet6_ip6_setup, "sysctl net.inet6.ip6 subtree setup")

{

#ifdef RFC2292

#define IS2292(x, y) ((in6p->in6p_flags & IN6P_RFC2292) ? (x) : (y))

#else

#define IS2292(x, y) (y)

#endif

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT,

CVSweb <webmaster@jp.NetBSD.org>