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.9 and 1.65

version 1.37.2.9, 2002/06/20 03:49:19

version 1.65, 2003/08/07 16:33:26

Line 42

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

* 3. All advertising materials mentioning features or use of this software

* 3. Neither the name of the University nor the names of its contributors

* must display the following acknowledgement:

* This product includes software developed by the University of

* California, Berkeley and its contributors.

* 4. Neither the name of the University nor the names of its contributors

* may be used to endorse or promote products derived from this software

* without specific prior written permission.

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

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

#include <sys/time.h>

#include <sys/kernel.h>

#include <sys/syslog.h>

#include <sys/lwp.h>

#include <sys/proc.h>

#include <sys/sysctl.h>

Line 150 struct ip6stat ip6stat;

Line 145 struct ip6stat ip6stat;

static void ip6_init2 __P((void *));

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

* IP6 initialization: fill in IP6 protocol switch table.

Line 230 ip6_input(m)

Line 226 ip6_input(m)

u_int32_t rtalert = ~0;

int nxt, ours = 0;

struct ifnet *deliverifp = NULL;

int srcrt = 0;

#ifdef IPSEC

Line 265 ip6_input(m)

Line 262 ip6_input(m)

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

ip6stat.ip6s_total++;

#ifndef PULLDOWN_TEST

/* XXX is the line really necessary? */

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

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

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

#endif

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

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

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

struct ifnet *inifp;

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

inifp = m->m_pkthdr.rcvif;

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

Line 306 ip6_input(m)

Line 312 ip6_input(m)

if (1)

#endif

{

struct in6_addr odst;

odst = ip6->ip6_dst;

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

srcrt = !IN6_ARE_ADDR_EQUAL(&odst, &ip6->ip6_dst);

}

#endif /* PFIL_HOOKS */

Line 615 ip6_input(m)

Line 625 ip6_input(m)

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

return;

}

#ifndef PULLDOWN_TEST

/* ip6_hopopts_input() ensures that mbuf is contiguous */

hbh = (struct ip6_hbh *)(ip6 + 1);

#else

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

sizeof(struct ip6_hbh));

if (hbh == NULL) {

ip6stat.ip6s_tooshort++;

return;

}

#endif

KASSERT(IP6_HDR_ALIGNED_P(hbh));

nxt = hbh->ip6h_nxt;

Line 678 ip6_input(m)

Line 684 ip6_input(m)

return;

}

} else if (!ours) {

ip6_forward(m, 0);

ip6_forward(m, srcrt);

return;

}

Line 768 ip6_hopopts_input(plenp, rtalertp, mp, o

Line 774 ip6_hopopts_input(plenp, rtalertp, mp, o

u_int8_t *opt;

/* validation of the length of the header */

#ifndef PULLDOWN_TEST

IP6_EXTHDR_CHECK(m, off, sizeof(*hbh), -1);

hbh = (struct ip6_hbh *)(mtod(m, caddr_t) + off);

hbhlen = (hbh->ip6h_len + 1) << 3;

IP6_EXTHDR_CHECK(m, off, hbhlen, -1);

hbh = (struct ip6_hbh *)(mtod(m, caddr_t) + off);

#else

IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m,

sizeof(struct ip6_hdr), sizeof(struct ip6_hbh));

if (hbh == NULL) {

Line 789 ip6_hopopts_input(plenp, rtalertp, mp, o

Line 787 ip6_hopopts_input(plenp, rtalertp, mp, o

ip6stat.ip6s_tooshort++;

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 960 ip6_unknown_opt(optp, m, off)

Line 958 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 977 ip6_unknown_opt(optp, m, off)

Line 975 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 1002 ip6_savecontrol(in6p, mp, ip6, m)

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

struct ip6_hdr *ip6;

struct mbuf *m;

{

struct proc *p = (curproc ? curproc->l_proc : 0); /* XXX */

struct proc *p = curproc; /* XXX */

int privileged;

privileged = 0;

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

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

microtime(&tv);

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

SCM_TIMESTAMP, SOL_SOCKET);

if (*mp)

mp = &(*mp)->m_next;

}

#endif

if (in6p->in6p_flags & IN6P_RECVDSTADDR) {

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

sizeof(struct in6_addr), IPV6_RECVDSTADDR,

sizeof(struct in6_addr), IPV6_RECVDSTADDR, IPPROTO_IPV6);

IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

}

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

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

? m->m_pkthdr.rcvif->if_index

: 0;

*mp = sbcreatecontrol((caddr_t) &pi6,

sizeof(struct in6_pktinfo), IPV6_PKTINFO,

sizeof(struct in6_pktinfo), IPV6_PKTINFO, IPPROTO_IPV6);

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,

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

sizeof(int), IPV6_HOPLIMIT, IPPROTO_IPV6);

IPV6_HOPLIMIT, IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

}

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

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

if (ip6->ip6_nxt == IPPROTO_HOPOPTS) {

struct ip6_hbh *hbh;

int hbhlen;

struct mbuf *ext;

#ifndef PULLDOWN_TEST

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

hbh = (struct ip6_hbh *)(ip6 + 1);

ip6->ip6_nxt);

hbhlen = (hbh->ip6h_len + 1) << 3;

if (ext == NULL) {

#else

IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m,

sizeof(struct ip6_hdr), sizeof(struct ip6_hbh));

if (hbh == NULL) {

ip6stat.ip6s_tooshort++;

return;

}

hbh = mtod(ext, struct ip6_hbh *);

hbhlen = (hbh->ip6h_len + 1) << 3;

IP6_EXTHDR_GET(hbh, struct ip6_hbh *, m,

if (hbhlen != ext->m_len) {

sizeof(struct ip6_hdr), hbhlen);

m_freem(ext);

if (hbh == NULL) {

ip6stat.ip6s_tooshort++;

return;

}

#endif

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

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

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

* But it's too painful operation...

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

IPV6_HOPOPTS, IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

m_freem(ext);

}

/* IPV6_DSTOPTS and IPV6_RTHDR socket options */

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

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

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

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

* Search for destination options headers or routing

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

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

* the chain of ancillary data.

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

struct ip6_ext *ip6e;

struct ip6_ext *ip6e = NULL;

int elen;

struct mbuf *ext = NULL;

#ifndef PULLDOWN_TEST

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

* if it is not an extension header, don't try to

if (nxt == IPPROTO_AH)

* pull it from the chain.

elen = (ip6e->ip6e_len + 2) << 2;

else

switch (nxt) {

elen = (ip6e->ip6e_len + 1) << 3;

case IPPROTO_DSTOPTS:

#else

case IPPROTO_ROUTING:

IP6_EXTHDR_GET(ip6e, struct ip6_ext *, m, off,

case IPPROTO_HOPOPTS:

sizeof(struct ip6_ext));

case IPPROTO_AH: /* is it possible? */

if (ip6e == NULL) {

break;

default:

goto loopend;

}

ext = ip6_pullexthdr(m, off, nxt);

if (ext == NULL) {

ip6stat.ip6s_tooshort++;

return;

}

ip6e = mtod(ext, struct ip6_ext *);

if (nxt == IPPROTO_AH)

elen = (ip6e->ip6e_len + 2) << 2;

else

elen = (ip6e->ip6e_len + 1) << 3;

IP6_EXTHDR_GET(ip6e, struct ip6_ext *, m, off, elen);

if (elen != ext->m_len) {

if (ip6e == NULL) {

m_freem(ext);

ip6stat.ip6s_tooshort++;

return;

}

#endif

KASSERT(IP6_HDR_ALIGNED_P(ip6e));

switch (nxt) {

case IPPROTO_DSTOPTS:

if (!in6p->in6p_flags & IN6P_DSTOPTS)

break;

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

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

break;

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

IPV6_DSTOPTS,

IPV6_DSTOPTS, IPPROTO_IPV6);

IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

break;

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

break;

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

IPV6_RTHDR,

IPV6_RTHDR, IPPROTO_IPV6);

IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

break;

case IPPROTO_UDP:

case IPPROTO_HOPOPTS:

case IPPROTO_TCP:

case IPPROTO_AH: /* is it possible? */

case IPPROTO_ICMPV6:

break;

default:

* stop search if we encounter an upper

* other cases have been filtered in the above.

* layer protocol headers.

* none will visit this case. here we supply

* the code just in case (nxt overwritten or

* other cases).

m_freem(ext);

goto loopend;

case IPPROTO_HOPOPTS:

case IPPROTO_AH: /* is it possible? */

break;

}

/* proceed with the next header. */

off += elen;

nxt = ip6e->ip6e_nxt;

ip6e = NULL;

m_freem(ext);

ext = NULL;

}

loopend:

;

}

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

* contains the result, or NULL on error.

static struct mbuf *

ip6_pullexthdr(m, off, nxt)

struct mbuf *m;

size_t off;

int nxt;

{

struct ip6_ext ip6e;

size_t elen;

struct mbuf *n;

#ifdef DIAGNOSTIC

switch (nxt) {

case IPPROTO_DSTOPTS:

case IPPROTO_ROUTING:

case IPPROTO_HOPOPTS:

case IPPROTO_AH: /* is it possible? */

break;

default:

printf("ip6_pullexthdr: invalid nxt=%d\n", nxt);

}

if ((in6p->in6p_flags & IN6P_HOPOPTS) && privileged) {

#endif

/* to be done */

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

if (nxt == IPPROTO_AH)

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

else

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

MGET(n, M_DONTWAIT, MT_DATA);

if (n && elen >= MLEN) {

MCLGET(n, M_DONTWAIT);

if ((n->m_flags & M_EXT) == 0) {

m_free(n);

n = NULL;

}

if ((in6p->in6p_flags & IN6P_DSTOPTS) && privileged) {

if (!n)

/* to be done */

return NULL;

n->m_len = 0;

if (elen >= M_TRAILINGSPACE(n)) {

m_free(n);

return NULL;

}

/* IN6P_RTHDR - to be done */

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

n->m_len = elen;

return n;

}

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

Line 1276 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.

char *

u_int8_t *

ip6_get_prevhdr(m, off)

struct mbuf *m;

int off;

Line 1235 ip6_get_prevhdr(m, off)

Line 1284 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 1259 ip6_get_prevhdr(m, off)

Line 1308 ip6_get_prevhdr(m, off)

nxt = ip6e->ip6e_nxt;

}

if (ip6e)

return(&ip6e->ip6e_nxt);

return (&ip6e->ip6e_nxt);

else

return NULL;

}

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

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

default:

return -1;

}

return -1;

}

CVSweb <webmaster@jp.NetBSD.org>