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.64.2.2 and 1.82.2.2

version 1.64.2.2, 2004/09/18 14:55:14

version 1.82.2.2, 2006/02/23 16:57:04

Line 94 __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 101 __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>

#include <netinet6/nd6.h>

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

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

#include <netinet6/ip6protosw.h>

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

Line 131 static int ip6qmaxlen = IFQ_MAXLEN;

Line 129 static int ip6qmaxlen = IFQ_MAXLEN;

struct in6_ifaddr *in6_ifaddr;

struct ifqueue ip6intrq;

extern struct ifnet loif[NLOOP];

int ip6_forward_srcrt; /* XXX */

int ip6_sourcecheck; /* XXX */

int ip6_sourcecheck_interval; /* XXX */

Line 143 struct pfil_head inet6_pfil_hook;

Line 140 struct pfil_head inet6_pfil_hook;

struct ip6stat ip6stat;

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 struct mbuf *ip6_pullexthdr __P((struct mbuf *, size_t, int));

Line 154 static struct mbuf *ip6_pullexthdr __P((

Line 152 static struct mbuf *ip6_pullexthdr __P((

void

ip6_init()

{

struct ip6protosw *pr;

const struct ip6protosw *pr;

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)

panic("ip6_init");

for (i = 0; i < IPPROTO_MAX; i++)

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

pr->pr_protocol && pr->pr_protocol != IPPROTO_RAW)

ip6_protox[pr->pr_protocol] = pr - inet6sw;

ip6intrq.ifq_maxlen = ip6qmaxlen;

scope6_init();

addrsel_policy_init();

nd6_init();

frag6_init();

Line 237 ip6_input(m)

#endif

* make sure we don't have onion peering information into m_tag.

ip6_delaux(m);

* mbuf statistics

if (m->m_flags & M_EXT) {

Line 248 ip6_input(m)

Line 253 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[lo0ifp->if_index]++; /* XXX */

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

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

else

Line 264 ip6_input(m)

Line 269 ip6_input(m)

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

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

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

Line 379 ip6_input(m)

Line 384 ip6_input(m)

}

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

}

Line 587 ip6_input(m)

Line 555 ip6_input(m)

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.

* m may be modified in ip6_hopopts_input().

* If a JumboPayload option is included, plen will also be modified.

Line 757 ip6_input(m)

Line 746 ip6_input(m)

}

* 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

* included, the real payload length will be stored in plenp.

Line 991 ip6_unknown_opt(optp, m, off)

Line 1009 ip6_unknown_opt(optp, m, off)

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

void

ip6_savecontrol(in6p, mp, ip6, m)

ip6_savecontrol(inp, mp, ip6, m)

struct in6pcb *in6p;

struct inpcb *inp;

struct mbuf **mp;

struct ip6_hdr *ip6;

struct mbuf *m;

{

#ifdef SO_TIMESTAMP

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

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

struct timeval tv;

microtime(&tv);

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

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

mp = &(*mp)->m_next;

}

#endif

if (in6p->in6p_flags & IN6P_RECVDSTADDR) {

if (inp->inp_flags & IN6P_RECVDSTADDR) {

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

sizeof(struct in6_addr), IPV6_RECVDSTADDR, IPPROTO_IPV6);

if (*mp)

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

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

#ifdef noyet

/* options were tossed above */

if (in6p->in6p_flags & IN6P_RECVOPTS)

if (inp->inp_flags & IN6P_RECVOPTS)

/* broken */

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

if (in6p->in6p_flags & IPV6P_RECVRETOPTS)

if (inp->inp_flags & IPV6P_RECVRETOPTS)

/* broken */

#endif

/* RFC 2292 sec. 5 */

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

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

struct in6_pktinfo pi6;

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->m_pkthdr.rcvif)

? m->m_pkthdr.rcvif->if_index

: 0;

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

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

if (*mp)

mp = &(*mp)->m_next;

}

if (in6p->in6p_flags & IN6P_HOPLIMIT) {

if (inp->inp_flags & IN6P_HOPLIMIT) {

int hlim = ip6->ip6_hlim & 0xff;

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

IPV6_HOPLIMIT, IPPROTO_IPV6);

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

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

* returned to normal user.

* See also RFC 2292 section 6.

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

if ((inp->inp_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 1063 ip6_savecontrol(in6p, mp, ip6, m)

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

* just after the IPv6 header, which fact is assured through

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

int hbhlen;

struct mbuf *ext;

ext = ip6_pullexthdr(m, sizeof(struct ip6_hdr),

ip6->ip6_nxt);

xip6->ip6_nxt);

if (ext == NULL) {

ip6stat.ip6s_tooshort++;

return;

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

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

}

/* IPV6_DSTOPTS and IPV6_RTHDR socket options */

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

if (inp->inp_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

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

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

switch (nxt) {

case IPPROTO_DSTOPTS:

if (!in6p->in6p_flags & IN6P_DSTOPTS)

if (!inp->inp_flags & IN6P_DSTOPTS)

break;

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

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

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

break;

case IPPROTO_ROUTING:

if (!in6p->in6p_flags & IN6P_RTHDR)

if (!inp->inp_flags & IN6P_RTHDR)

break;

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

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

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

Line 1481 SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,

Line 1537 SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,

IPV6CTL_FORWSRCRT, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_STRUCT, "stats", NULL,

NULL, 0, &?, sizeof(?),

CTL_NET, PF_INET6, IPPROTO_IPV6,

IPV6CTL_STATS, 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,

Line 1584 SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,

Line 1634 SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,

CTLFLAG_PERMANENT,

CTLTYPE_STRING, "kame_version",

SYSCTL_DESCR("KAME Version"),

NULL, 0, __KAME_VERSION, 0,

NULL, 0, __UNCONST(__KAME_VERSION), 0,

CTL_NET, PF_INET6, IPPROTO_IPV6,

IPV6CTL_KAME_VERSION, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

Line 1651 SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,

Line 1701 SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,

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

}

CVSweb <webmaster@jp.NetBSD.org>