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.8 and 1.79

version 1.78.2.8, 2008/03/17 09:15:42

version 1.79, 2005/08/28 21:01:53

Line 65

__KERNEL_RCSID(0, "$NetBSD$");

#include "opt_inet.h"

#include "opt_inet6.h"

#include "opt_ipsec.h"

#include "opt_pfil_hooks.h"

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

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

#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 110 __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 136 static int ip6qmaxlen = IFQ_MAXLEN;

Line 128 static int ip6qmaxlen = IFQ_MAXLEN;

struct in6_ifaddr *in6_ifaddr;

struct ifqueue ip6intrq;

extern callout_t in6_tmpaddrtimer_ch;

int ip6_forward_srcrt; /* XXX */

int ip6_sourcecheck; /* XXX */

int ip6_sourcecheck_interval; /* XXX */

Line 148 struct pfil_head inet6_pfil_hook;

Line 138 struct pfil_head inet6_pfil_hook;

struct ip6stat ip6stat;

static void ip6_init2(void *);

static void ip6_init2 __P((void *));

static struct m_tag *ip6_setdstifaddr(struct mbuf *, const struct in6_ifaddr *);

static int ip6_hopopts_input(u_int32_t *, u_int32_t *, struct mbuf **, int *);

static int ip6_hopopts_input __P((u_int32_t *, u_int32_t *, struct mbuf **, int *));

static struct mbuf *ip6_pullexthdr(struct mbuf *, size_t, int);

static struct mbuf *ip6_pullexthdr __P((struct mbuf *, size_t, int));

* IP6 initialization: fill in IP6 protocol switch table.

* All protocols not implemented in kernel go to raw IP6 protocol handler.

void

ip6_init(void)

ip6_init()

{

const struct ip6protosw *pr;

int i;

Line 175 ip6_init(void)

Line 164 ip6_init(void)

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

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 198 ip6_init(void)

Line 181 ip6_init(void)

}

static void

ip6_init2(void *dummy)

ip6_init2(dummy)

void *dummy;

{

/* nd6_timer_init */

callout_init(&nd6_timer_ch, 0);

callout_init(&nd6_timer_ch);

callout_reset(&nd6_timer_ch, hz, nd6_timer, NULL);

/* timer for regeneranation of temporary addresses randomize ID */

callout_init(&in6_tmpaddrtimer_ch, 0);

callout_reset(&in6_tmpaddrtimer_ch,

(ip6_temp_preferred_lifetime - ip6_desync_factor -

ip6_temp_regen_advance) * hz,

in6_tmpaddrtimer, NULL);

}

* IP6 input interrupt handling. Just pass the packet to ip6_input.

void

ip6intr(void)

ip6intr()

{

int s;

struct mbuf *m;

Line 228 ip6intr(void)

Line 205 ip6intr(void)

splx(s);

if (m == 0)

return;

/* drop the packet if IPv6 operation is disabled on the IF */

if ((ND_IFINFO(m->m_pkthdr.rcvif)->flags & ND6_IFF_IFDISABLED)) {

m_freem(m);

return;

}

ip6_input(m);

}

extern struct route ip6_forward_rt;

extern struct route_in6 ip6_forward_rt;

void

ip6_input(struct mbuf *m)

ip6_input(m)

struct mbuf *m;

{

struct ip6_hdr *ip6;

int hit, off = sizeof(struct ip6_hdr), nest;

int off = sizeof(struct ip6_hdr), nest;

u_int32_t plen;

u_int32_t rtalert = ~0;

int nxt, ours = 0, rh_present = 0;

int nxt, ours = 0;

struct ifnet *deliverifp = NULL;

int srcrt = 0;

const struct rtentry *rt;

union {

struct sockaddr dst;

struct sockaddr_in6 dst6;

} u;

#ifdef FAST_IPSEC

struct m_tag *mtag;

struct tdb_ident *tdbi;

struct secpolicy *sp;

int s, error;

#endif

#ifdef IPSEC

Line 271 ip6_input(struct mbuf *m)

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

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

Line 260 ip6_input(struct mbuf *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, void *)) == 0) {

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

Line 332 ip6_input(struct mbuf *m)

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

Line 303 ip6_input(struct mbuf *m)

#ifdef IPSEC

if (!ipsec_getnhist(m))

#elif defined(FAST_IPSEC)

if (!ipsec_indone(m))

#else

if (1)

#endif

Line 431 ip6_input(struct mbuf *m)

Line 375 ip6_input(struct mbuf *m)

}

#endif

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

* Disambiguate address scope zones (if there is ambiguity).

IN6_IS_ADDR_LOOPBACK(&ip6->ip6_dst)) {

* We first make sure that the original source or destination address

if (m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) {

* is not in our internal form for scoped addresses. Such addresses

ours = 1;

* are not necessarily invalid spec-wise, but we cannot accept them due

deliverifp = m->m_pkthdr.rcvif;

* to the usage conflict.

goto hbhcheck;

* in6_setscope() then also checks and rejects the cases where src or

} else {

* dst are the loopback address and the receiving interface

ip6stat.ip6s_badscope++;

* is not loopback.

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

goto bad;

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;

}

if (in6_setscope(&ip6->ip6_src, m->m_pkthdr.rcvif, NULL) ||

in6_setscope(&ip6->ip6_dst, m->m_pkthdr.rcvif, NULL)) {

/* drop packets if interface ID portion is already filled */

ip6stat.ip6s_badscope++;

if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) == 0) {

goto bad;

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_IS_SCOPE_LINKLOCAL(&ip6->ip6_src))

ip6->ip6_src.s6_addr16[1]

= htons(m->m_pkthdr.rcvif->if_index);

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

Line 456 ip6_input(struct mbuf *m)

goto hbhcheck;

}

sockaddr_in6_init(&u.dst6, &ip6->ip6_dst, 0, 0, 0);

* Unicast check

rt = rtcache_lookup2(&ip6_forward_rt, &u.dst, 1, &hit);

if (ip6_forward_rt.ro_rt != NULL &&

if (hit)

(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++;

else

else {

ip6stat.ip6s_forward_cachemiss++;

struct sockaddr_in6 *dst6;

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;

}

#define rt6_getkey(__rt) satocsin6(rt_getkey(__rt))

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

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;

rtalloc((struct route *)&ip6_forward_rt);

}

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

* Accept the packet if the forwarding interface to the destination

Line 501 ip6_input(struct mbuf *m)

Line 494 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 (rt != NULL &&

if (ip6_forward_rt.ro_rt &&

(rt->rt_flags & (RTF_HOST|RTF_GATEWAY)) == RTF_HOST &&

(ip6_forward_rt.ro_rt->rt_flags &

!(rt->rt_flags & RTF_CLONED) &&

(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

* the destination and the key of the rtentry has

* already done through looking up the routing table.

IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst, &rt6_getkey(rt)->sin6_addr) &&

IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst,

&rt6_key(ip6_forward_rt.ro_rt)->sin6_addr) &&

#endif

rt->rt_ifp->if_type == IFT_LOOP) {

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

struct in6_ifaddr *ia6 = (struct in6_ifaddr *)rt->rt_ifa;

struct in6_ifaddr *ia6 =

(struct in6_ifaddr *)ip6_forward_rt.ro_rt->rt_ifa;

if (ia6->ia6_flags & IN6_IFF_ANYCAST)

m->m_flags |= M_ANYCAST6;

Line 541 ip6_input(struct mbuf *m)

Line 537 ip6_input(struct mbuf *m)

#if defined(NFAITH) && 0 < NFAITH

if (ip6_keepfaith) {

if (rt != NULL && rt->rt_ifp != NULL &&

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

rt->rt_ifp->if_type == IFT_FAITH) {

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

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

ours = 1;

deliverifp = rt->rt_ifp; /* faith */

deliverifp = ip6_forward_rt.ro_rt->rt_ifp; /* faith */

goto hbhcheck;

}

Line 559 ip6_input(struct mbuf *m)

Line 555 ip6_input(struct mbuf *m)

* working right.

struct ifaddr *ifa;

IFADDR_FOREACH(ifa, m->m_pkthdr.rcvif) {

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

Line 583 ip6_input(struct mbuf *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) == NULL) {

struct in6_ifaddr *ia6;

ia6 = in6_ifawithifp(deliverifp, &ip6->ip6_dst);

if (ia6 != NULL && ip6_setdstifaddr(m, ia6) == NULL) {

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

Line 609 ip6_input(struct mbuf *m)

if (ip6->ip6_plen == 0 && plen == 0) {

* Note that if a valid jumbo payload option is

* contained, ip6_hopopts_input() must set a valid

* contained, ip6_hoptops_input() must set a valid

* (non-zero) payload length to the variable plen.

ip6stat.ip6s_badoptions++;

Line 638 ip6_input(struct mbuf *m)

Line 617 ip6_input(struct mbuf *m)

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

icmp6_error(m, ICMP6_PARAM_PROB,

ICMP6_PARAMPROB_HEADER,

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

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

return;

}

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

Line 737 ip6_input(struct mbuf *m)

Line 716 ip6_input(struct mbuf *m)

in6_ifstat_inc(deliverifp, ifs6_in_deliver);

nest = 0;

rh_present = 0;

while (nxt != IPPROTO_DONE) {

if (ip6_hdrnestlimit && (++nest > ip6_hdrnestlimit)) {

ip6stat.ip6s_toomanyhdr++;

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

goto bad;

}

Line 755 ip6_input(struct mbuf *m)

Line 732 ip6_input(struct mbuf *m)

goto bad;

}

if (nxt == IPPROTO_ROUTING) {

if (rh_present++) {

in6_ifstat_inc(m->m_pkthdr.rcvif,

ifs6_in_hdrerr);

ip6stat.ip6s_badoptions++;

goto bad;

}

#ifdef IPSEC

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

Line 776 ip6_input(struct mbuf *m)

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

}

splx(s);

if (error)

goto bad;

}

#endif /* FAST_IPSEC */

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

}

Line 824 ip6_input(struct mbuf *m)

Line 753 ip6_input(struct mbuf *m)

}

* set/grab in6_ifaddr correspond to IPv6 destination address.

static struct m_tag *

ip6_setdstifaddr(struct mbuf *m, const struct in6_ifaddr *ia)

{

struct m_tag *mtag;

mtag = ip6_addaux(m);

if (mtag != NULL) {

struct ip6aux *ip6a;

ip6a = (struct ip6aux *)(mtag + 1);

in6_setscope(&ip6a->ip6a_src, ia->ia_ifp, &ip6a->ip6a_scope_id);

ip6a->ip6a_src = ia->ia_addr.sin6_addr;

ip6a->ip6a_flags = ia->ia6_flags;

}

return mtag; /* NULL if failed to set */

}

const struct ip6aux *

ip6_getdstifaddr(struct mbuf *m)

{

struct m_tag *mtag;

mtag = ip6_findaux(m);

if (mtag != NULL)

return (struct ip6aux *)(mtag + 1);

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.

* rtalertp - XXX: should be stored more smart way

static int

ip6_hopopts_input(u_int32_t *plenp, u_int32_t *rtalertp,

ip6_hopopts_input(plenp, rtalertp, mp, offp)

struct mbuf **mp, int *offp)

u_int32_t *plenp;

u_int32_t *rtalertp; /* XXX: should be stored more smart way */

struct mbuf **mp;

int *offp;

{

struct mbuf *m = *mp;

int off = *offp, hbhlen;

Line 907 ip6_hopopts_input(u_int32_t *plenp, u_in

Line 805 ip6_hopopts_input(u_int32_t *plenp, u_in

* opthead + hbhlen is located in continuous memory region.

int

ip6_process_hopopts(struct mbuf *m, u_int8_t *opthead, int hbhlen,

ip6_process_hopopts(m, opthead, hbhlen, rtalertp, plenp)

u_int32_t *rtalertp, u_int32_t *plenp)

struct mbuf *m;

u_int8_t *opthead;

int hbhlen;

u_int32_t *rtalertp;

u_int32_t *plenp;

{

struct ip6_hdr *ip6;

int optlen = 0;

Line 943 ip6_process_hopopts(struct mbuf *m, u_in

Line 845 ip6_process_hopopts(struct mbuf *m, u_in

return (-1);

}

optlen = IP6OPT_RTALERT_LEN;

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

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

*rtalertp = ntohs(rtalert_val);

break;

case IP6OPT_JUMBO:

Line 1040 ip6_process_hopopts(struct mbuf *m, u_in

Line 942 ip6_process_hopopts(struct mbuf *m, u_in

* is not continuous in order to return an ICMPv6 error.

int

ip6_unknown_opt(u_int8_t *optp, struct mbuf *m, int off)

ip6_unknown_opt(optp, m, off)

u_int8_t *optp;

struct mbuf *m;

int off;

{

struct ip6_hdr *ip6;

Line 1082 ip6_unknown_opt(u_int8_t *optp, struct m

Line 987 ip6_unknown_opt(u_int8_t *optp, struct m

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

void

ip6_savecontrol(struct in6pcb *in6p, struct mbuf **mp,

ip6_savecontrol(in6p, mp, ip6, m)

struct ip6_hdr *ip6, struct mbuf *m)

struct in6pcb *in6p;

struct mbuf **mp;

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;

microtime(&tv);

*mp = sbcreatecontrol((void *) &tv, sizeof(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, 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 */

if (IN6_IS_SCOPE_LINKLOCAL(&pi6.ipi6_addr))

pi6.ipi6_ifindex = m->m_pkthdr.rcvif ?

pi6.ipi6_addr.s6_addr16[1] = 0;

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

pi6.ipi6_ifindex = (m && m->m_pkthdr.rcvif)

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

? m->m_pkthdr.rcvif->if_index

sizeof(struct in6_pktinfo),

: 0;

IS2292(IPV6_2292PKTINFO, IPV6_PKTINFO), IPPROTO_IPV6);

*mp = sbcreatecontrol((caddr_t) &pi6,

sizeof(struct in6_pktinfo), 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),

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

IPV6_HOPLIMIT, IPPROTO_IPV6);

IS2292(IPV6_2292HOPLIMIT, 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((void *)&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 1185 ip6_savecontrol(struct in6pcb *in6p, str

Line 1083 ip6_savecontrol(struct in6pcb *in6p, str

* 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((void *)hbh, hbhlen,

*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 1208 ip6_savecontrol(struct in6pcb *in6p, str

Line 1105 ip6_savecontrol(struct in6pcb *in6p, str

* 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(struct in6pcb *in6p, str

Line 1146 ip6_savecontrol(struct in6pcb *in6p, str

if (!in6p->in6p_flags & IN6P_DSTOPTS)

break;

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

*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(struct in6pcb *in6p, str

Line 1156 ip6_savecontrol(struct in6pcb *in6p, str

if (!in6p->in6p_flags & IN6P_RTHDR)

break;

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

*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 1294 ip6_savecontrol(struct in6pcb *in6p, str

Line 1189 ip6_savecontrol(struct in6pcb *in6p, str

;

}

#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((void *)&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

* contains the result, or NULL on error.

static struct mbuf *

ip6_pullexthdr(struct mbuf *m, size_t off, int nxt)

ip6_pullexthdr(m, off, nxt)

struct mbuf *m;

size_t off;

int nxt;

{

struct ip6_ext ip6e;

size_t elen;

Line 1358 ip6_pullexthdr(struct mbuf *m, size_t of

Line 1216 ip6_pullexthdr(struct mbuf *m, size_t of

}

#endif

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

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

if (nxt == IPPROTO_AH)

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

else

Line 1381 ip6_pullexthdr(struct mbuf *m, size_t of

Line 1239 ip6_pullexthdr(struct mbuf *m, size_t of

return NULL;

}

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

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

n->m_len = elen;

return n;

}

Line 1399 ip6_pullexthdr(struct mbuf *m, size_t of

Line 1257 ip6_pullexthdr(struct mbuf *m, size_t of

* we develop `neater' mechanism to process extension headers.

u_int8_t *

ip6_get_prevhdr(struct mbuf *m, int off)

ip6_get_prevhdr(m, off)

struct mbuf *m;

int off;

{

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

Line 1412 ip6_get_prevhdr(struct mbuf *m, int off)

Line 1272 ip6_get_prevhdr(struct mbuf *m, int off)

nxt = ip6->ip6_nxt;

len = sizeof(struct ip6_hdr);

while (len < off) {

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

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

switch (nxt) {

case IPPROTO_FRAGMENT:

Line 1438 ip6_get_prevhdr(struct mbuf *m, int off)

Line 1298 ip6_get_prevhdr(struct mbuf *m, int off)

* get next header offset. m will be retained.

int

ip6_nexthdr(struct mbuf *m, int off, int proto, int *nxtp)

ip6_nexthdr(m, off, proto, nxtp)

struct mbuf *m;

int off;

int proto;

int *nxtp;

{

struct ip6_hdr ip6;

struct ip6_ext ip6e;

Line 1452 ip6_nexthdr(struct mbuf *m, int off, int

Line 1316 ip6_nexthdr(struct mbuf *m, int off, int

switch (proto) {

case IPPROTO_IPV6:

/* do not chase beyond intermediate IPv6 headers */

if (off != 0)

return -1;

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

return -1;

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

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

if (nxtp)

*nxtp = ip6.ip6_nxt;

off += sizeof(ip6);

Line 1470 ip6_nexthdr(struct mbuf *m, int off, int

Line 1331 ip6_nexthdr(struct mbuf *m, int off, int

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

return -1;

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

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

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

return -1;

if (nxtp)

Line 1481 ip6_nexthdr(struct mbuf *m, int off, int

Line 1342 ip6_nexthdr(struct mbuf *m, int off, int

case IPPROTO_AH:

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

return -1;

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

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

if (nxtp)

*nxtp = ip6e.ip6e_nxt;

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

Line 1494 ip6_nexthdr(struct mbuf *m, int off, int

Line 1355 ip6_nexthdr(struct mbuf *m, int off, int

case IPPROTO_DSTOPTS:

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

return -1;

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

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

if (nxtp)

*nxtp = ip6e.ip6e_nxt;

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

Line 1517 ip6_nexthdr(struct mbuf *m, int off, int

Line 1378 ip6_nexthdr(struct mbuf *m, int off, int

* get offset for the last header in the chain. m will be kept untainted.

int

ip6_lasthdr(struct mbuf *m, int off, int proto, int *nxtp)

ip6_lasthdr(m, off, proto, nxtp)

struct mbuf *m;

int off;

int proto;

int *nxtp;

{

int newoff;

int nxt;

Line 1526 ip6_lasthdr(struct mbuf *m, int off, int

Line 1391 ip6_lasthdr(struct mbuf *m, int off, int

nxt = -1;

nxtp = &nxt;

}

for (;;) {

while (1) {

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

if (newoff < 0)

return off;

Line 1540 ip6_lasthdr(struct mbuf *m, int off, int

Line 1405 ip6_lasthdr(struct mbuf *m, int off, int

}

struct m_tag *

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

{

struct m_tag *mtag;

mtag = m_tag_find(m, PACKET_TAG_INET6, NULL);

return mtag;

}

void

ip6_delaux(struct mbuf *m)

{

struct m_tag *mtag;

mtag = m_tag_find(m, PACKET_TAG_INET6, NULL);

if (mtag)

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 1642 u_char inet6ctlerrmap[PRC_NCMDS] = {

Line 1420 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,

Line 1863 SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,

Line 1636 SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,

#endif /* IPNOPRIVPORTS */

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "use_tempaddr",

SYSCTL_DESCR("Use temporary address"),

NULL, 0, &ip6_use_tempaddr, 0,

CTL_NET, PF_INET6, IPPROTO_IPV6,

CTL_CREATE, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "temppltime",

SYSCTL_DESCR("preferred lifetime of a temporary address"),

NULL, 0, &ip6_temp_preferred_lifetime, 0,

CTL_NET, PF_INET6, IPPROTO_IPV6,

CTL_CREATE, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "tempvltime",

SYSCTL_DESCR("valid lifetime of a temporary address"),

NULL, 0, &ip6_temp_valid_lifetime, 0,

CTL_NET, PF_INET6, IPPROTO_IPV6,

CTL_CREATE, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "maxfrags",

SYSCTL_DESCR("Maximum fragments in reassembly queue"),

NULL, 0, &ip6_maxfrags, 0,

Line 1896 SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,

Line 1648 SYSCTL_SETUP(sysctl_net_inet6_ip6_setup,

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

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "mcast_pmtu",

SYSCTL_DESCR("Enable pMTU discovery for multicast packet"),

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>