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.161 and 1.181

version 1.161, 2016/06/22 07:48:17

version 1.181, 2017/07/27 06:59:28

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

#include "opt_inet.h"

#include "opt_inet6.h"

#include "opt_ipsec.h"

#include "opt_compat_netbsd.h"

#include "opt_net_mpsafe.h"

#endif

#include <sys/param.h>

#include <sys/systm.h>

#include <sys/malloc.h>

#include <sys/mbuf.h>

#include <sys/domain.h>

#include <sys/protosw.h>

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

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

#include <sys/proc.h>

#include <sys/sysctl.h>

#include <sys/cprng.h>

#include <sys/percpu.h>

#include <net/if.h>

#include <net/if_types.h>

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

#include <netipsec/key.h>

#endif /* IPSEC */

#ifdef COMPAT_50

#include <compat/sys/time.h>

#include <compat/sys/socket.h>

#endif

#include <netinet6/ip6protosw.h>

#include "faith.h"

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

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

extern struct domain inet6domain;

u_char ip6_protox[IPPROTO_MAX];

struct in6_ifaddr *in6_ifaddr;

pktqueue_t *ip6_pktq __read_mostly;

int ip6_forward_srcrt; /* XXX */

Line 144 pfil_head_t *inet6_pfil_hook;

Line 138 pfil_head_t *inet6_pfil_hook;

percpu_t *ip6stat_percpu;

percpu_t *ip6_forward_rt_percpu __cacheline_aligned;

static void ip6_init2(void);

static void ip6intr(void *);

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

Line 153 static int ip6_process_hopopts(struct mb

Line 149 static int ip6_process_hopopts(struct mb

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

static void sysctl_net_inet6_ip6_setup(struct sysctllog **);

#ifdef NET_MPSAFE

#define SOFTNET_LOCK() mutex_enter(softnet_lock)

#define SOFTNET_UNLOCK() mutex_exit(softnet_lock)

#else

#define SOFTNET_LOCK() KASSERT(mutex_owned(softnet_lock))

#define SOFTNET_UNLOCK() KASSERT(mutex_owned(softnet_lock))

#endif

* IP6 initialization: fill in IP6 protocol switch table.

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

Line 163 ip6_init(void)

Line 167 ip6_init(void)

const struct ip6protosw *pr;

int i;

in6_init();

sysctl_net_inet6_ip6_setup(NULL);

pr = (const struct ip6protosw *)pffindproto(PF_INET6, IPPROTO_RAW, SOCK_RAW);

if (pr == 0)

Line 193 ip6_init(void)

Line 199 ip6_init(void)

KASSERT(inet6_pfil_hook != NULL);

ip6stat_percpu = percpu_alloc(sizeof(uint64_t) * IP6_NSTATS);

ip6_forward_rt_percpu = percpu_alloc(sizeof(struct route));

}

static void

Line 215 ip6intr(void *arg __unused)

Line 222 ip6intr(void *arg __unused)

{

struct mbuf *m;

#ifndef NET_MPSAFE

mutex_enter(softnet_lock);

#endif

while ((m = pktq_dequeue(ip6_pktq)) != NULL) {

struct psref psref;

struct ifnet *rcvif = m_get_rcvif_psref(m, &psref);

Line 235 ip6intr(void *arg __unused)

Line 244 ip6intr(void *arg __unused)

ip6_input(m, rcvif);

m_put_rcvif_psref(rcvif, &psref);

}

#ifndef NET_MPSAFE

mutex_exit(softnet_lock);

#endif

}

extern struct route ip6_forward_rt;

void

ip6_input(struct mbuf *m, struct ifnet *rcvif)

{

Line 250 ip6_input(struct mbuf *m, struct ifnet *

Line 259 ip6_input(struct mbuf *m, struct ifnet *

int nxt, ours = 0, rh_present = 0;

struct ifnet *deliverifp = NULL;

int srcrt = 0;

const struct rtentry *rt;

struct rtentry *rt = NULL;

union {

struct sockaddr dst;

struct sockaddr_in6 dst6;

} u;

struct route *ro;

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

Line 353 ip6_input(struct mbuf *m, struct ifnet *

Line 363 ip6_input(struct mbuf *m, struct ifnet *

IP6_STATINC(IP6_STAT_NXTHIST + ip6->ip6_nxt);

#ifdef ALTQ

if (altq_input != NULL && (*altq_input)(m, AF_INET6) == 0) {

if (altq_input != NULL) {

/* packet is dropped by traffic conditioner */

SOFTNET_LOCK();

return;

if ((*altq_input)(m, AF_INET6) == 0) {

SOFTNET_UNLOCK();

/* packet is dropped by traffic conditioner */

return;

}

SOFTNET_UNLOCK();

}

#endif

Line 429 ip6_input(struct mbuf *m, struct ifnet *

Line 444 ip6_input(struct mbuf *m, struct ifnet *

goto bad;

}

ro = percpu_getref(ip6_forward_rt_percpu);

* Multicast check

if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {

struct in6_multi *in6m = 0;

bool ingroup;

in6_ifstat_inc(rcvif, ifs6_in_mcast);

* See if we belong to the destination multicast group on the

* arrival interface.

IN6_LOOKUP_MULTI(ip6->ip6_dst, rcvif, in6m);

ingroup = in6_multi_group(&ip6->ip6_dst, rcvif);

if (in6m)

if (ingroup)

ours = 1;

else if (!ip6_mrouter) {

uint64_t *ip6s = IP6_STAT_GETREF();

Line 449 ip6_input(struct mbuf *m, struct ifnet *

Line 465 ip6_input(struct mbuf *m, struct ifnet *

ip6s[IP6_STAT_CANTFORWARD]++;

IP6_STAT_PUTREF();

in6_ifstat_inc(rcvif, ifs6_in_discard);

goto bad;

goto bad_unref;

}

deliverifp = rcvif;

goto hbhcheck;

Line 460 ip6_input(struct mbuf *m, struct ifnet *

Line 476 ip6_input(struct mbuf *m, struct ifnet *

* Unicast check

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

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

if (hit)

IP6_STATINC(IP6_STAT_FORWARD_CACHEHIT);

else

Line 495 ip6_input(struct mbuf *m, struct ifnet *

Line 511 ip6_input(struct mbuf *m, struct ifnet *

* packets to a tentative, duplicated, or somehow invalid

* address must not be accepted.

if (!(ia6->ia6_flags & IN6_IFF_NOTREADY)) {

if (!(ia6->ia6_flags & (IN6_IFF_NOTREADY | IN6_IFF_DETACHED))) {

/* this address is ready */

ours = 1;

deliverifp = ia6->ia_ifp; /* correct? */

goto hbhcheck;

} else {

/* address is not ready, so discard the packet. */

char ip6bufs[INET6_ADDRSTRLEN];

char ip6bufd[INET6_ADDRSTRLEN];

nd6log(LOG_INFO, "packet to an unready address %s->%s\n",

ip6_sprintf(&ip6->ip6_src),

IN6_PRINT(ip6bufs, &ip6->ip6_src),

ip6_sprintf(&ip6->ip6_dst));

IN6_PRINT(ip6bufd, &ip6->ip6_dst));

goto bad;

goto bad_unref;

}

Line 533 ip6_input(struct mbuf *m, struct ifnet *

Line 551 ip6_input(struct mbuf *m, struct ifnet *

* working right.

struct ifaddr *ifa;

IFADDR_FOREACH(ifa, rcvif) {

IFADDR_READER_FOREACH(ifa, rcvif) {

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

continue;

if (IN6_ARE_ADDR_EQUAL(IFA_IN6(ifa), &ip6->ip6_dst)) {

Line 552 ip6_input(struct mbuf *m, struct ifnet *

Line 570 ip6_input(struct mbuf *m, struct ifnet *

if (!ip6_forwarding) {

IP6_STATINC(IP6_STAT_CANTFORWARD);

in6_ifstat_inc(rcvif, ifs6_in_discard);

goto bad;

goto bad_unref;

}

hbhcheck:

Line 564 ip6_input(struct mbuf *m, struct ifnet *

Line 582 ip6_input(struct mbuf *m, struct ifnet *

if (deliverifp && ip6_getdstifaddr(m) == NULL) {

struct in6_ifaddr *ia6;

int s = pserialize_read_enter();

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

/* Depends on ip6_setdstifaddr never sleep */

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

* XXX maybe we should drop the packet here,

Line 573 ip6_input(struct mbuf *m, struct ifnet *

Line 593 ip6_input(struct mbuf *m, struct ifnet *

* to the upper layers.

}

pserialize_read_exit(s);

}

Line 588 ip6_input(struct mbuf *m, struct ifnet *

Line 609 ip6_input(struct mbuf *m, struct ifnet *

#if 0 /*touches NULL pointer*/

in6_ifstat_inc(rcvif, ifs6_in_discard);

#endif

rtcache_unref(rt, ro);

percpu_putref(ip6_forward_rt_percpu);

return; /* m have already been freed */

}

Line 611 ip6_input(struct mbuf *m, struct ifnet *

Line 634 ip6_input(struct mbuf *m, struct ifnet *

icmp6_error(m, ICMP6_PARAM_PROB,

ICMP6_PARAMPROB_HEADER,

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

rtcache_unref(rt, ro);

percpu_putref(ip6_forward_rt_percpu);

return;

}

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

sizeof(struct ip6_hbh));

if (hbh == NULL) {

IP6_STATINC(IP6_STAT_TOOSHORT);

rtcache_unref(rt, ro);

percpu_putref(ip6_forward_rt_percpu);

return;

}

KASSERT(IP6_HDR_ALIGNED_P(hbh));

Line 640 ip6_input(struct mbuf *m, struct ifnet *

Line 667 ip6_input(struct mbuf *m, struct ifnet *

if (m->m_pkthdr.len - sizeof(struct ip6_hdr) < plen) {

IP6_STATINC(IP6_STAT_TOOSHORT);

in6_ifstat_inc(rcvif, ifs6_in_truncated);

goto bad;

goto bad_unref;

}

if (m->m_pkthdr.len > sizeof(struct ip6_hdr) + plen) {

if (m->m_len == m->m_pkthdr.len) {

Line 662 ip6_input(struct mbuf *m, struct ifnet *

Line 689 ip6_input(struct mbuf *m, struct ifnet *

* ip6_mforward() returns a non-zero value, the packet

* must be discarded, else it may be accepted below.

if (ip6_mrouter && ip6_mforward(ip6, rcvif, m)) {

if (ip6_mrouter != NULL) {

IP6_STATINC(IP6_STAT_CANTFORWARD);

int error;

m_freem(m);

return;

SOFTNET_LOCK();

}

error = ip6_mforward(ip6, rcvif, m);

if (!ours) {

SOFTNET_UNLOCK();

m_freem(m);

return;

if (error != 0) {

rtcache_unref(rt, ro);

percpu_putref(ip6_forward_rt_percpu);

IP6_STATINC(IP6_STAT_CANTFORWARD);

goto bad;

}

if (!ours)

goto bad_unref;

} else if (!ours) {

rtcache_unref(rt, ro);

percpu_putref(ip6_forward_rt_percpu);

ip6_forward(m, srcrt);

return;

}

Line 691 ip6_input(struct mbuf *m, struct ifnet *

Line 727 ip6_input(struct mbuf *m, struct ifnet *

IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) {

IP6_STATINC(IP6_STAT_BADSCOPE);

in6_ifstat_inc(rcvif, ifs6_in_addrerr);

goto bad;

goto bad_unref;

}

Line 700 ip6_input(struct mbuf *m, struct ifnet *

Line 736 ip6_input(struct mbuf *m, struct ifnet *

#ifdef IFA_STATS

if (deliverifp != NULL) {

struct in6_ifaddr *ia6;

int s = pserialize_read_enter();

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

if (ia6)

ia6->ia_ifa.ifa_data.ifad_inbytes += m->m_pkthdr.len;

pserialize_read_exit(s);

}

#endif

IP6_STATINC(IP6_STAT_DELIVERED);

in6_ifstat_inc(deliverifp, ifs6_in_deliver);

nest = 0;

if (rt != NULL) {

rtcache_unref(rt, ro);

rt = NULL;

}

percpu_putref(ip6_forward_rt_percpu);

rh_present = 0;

while (nxt != IPPROTO_DONE) {

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

Line 744 ip6_input(struct mbuf *m, struct ifnet *

Line 788 ip6_input(struct mbuf *m, struct ifnet *

if ((inet6sw[ip_protox[nxt]].pr_flags

& PR_LASTHDR) != 0) {

int error = ipsec6_input(m);

int error;

error = ipsec6_input(m);

if (error)

goto bad;

}

#endif /* IPSEC */

SOFTNET_LOCK();

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

SOFTNET_UNLOCK();

}

return;

bad_unref:

rtcache_unref(rt, ro);

percpu_putref(ip6_forward_rt_percpu);

bad:

m_freem(m);

return;

}

Line 1024 void

Line 1077 void

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

struct ip6_hdr *ip6, struct mbuf *m)

{

struct socket *so = in6p->in6p_socket;

#ifdef RFC2292

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

#else

#define IS2292(x, y) (y)

#endif

if (in6p->in6p_socket->so_options & SO_TIMESTAMP

if (SOOPT_TIMESTAMP(so->so_options))

#ifdef SO_OTIMESTAMP

mp = sbsavetimestamp(so->so_options, m, mp);

|| in6p->in6p_socket->so_options & SO_OTIMESTAMP

#endif

) {

struct timeval tv;

microtime(&tv);

#ifdef SO_OTIMESTAMP

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

struct timeval50 tv50;

timeval_to_timeval50(&tv, &tv50);

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

SCM_OTIMESTAMP, SOL_SOCKET);

} else

#endif

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

SCM_TIMESTAMP, SOL_SOCKET);

if (*mp)

mp = &(*mp)->m_next;

}

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

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

Line 1063 ip6_savecontrol(struct in6pcb *in6p, str

Line 1098 ip6_savecontrol(struct in6pcb *in6p, str

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

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

pi6.ipi6_ifindex = m->m_pkthdr.rcvif_index;

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

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

sizeof(struct in6_pktinfo),

IS2292(IPV6_2292PKTINFO, IPV6_PKTINFO), IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

Line 1073 ip6_savecontrol(struct in6pcb *in6p, str

Line 1107 ip6_savecontrol(struct in6pcb *in6p, str

if (in6p->in6p_flags & IN6P_HOPLIMIT) {

int hlim = ip6->ip6_hlim & 0xff;

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

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

IS2292(IPV6_2292HOPLIMIT, IPV6_HOPLIMIT), IPPROTO_IPV6);

if (*mp)

mp = &(*mp)->m_next;

Line 1087 ip6_savecontrol(struct in6pcb *in6p, str

Line 1121 ip6_savecontrol(struct in6pcb *in6p, str

flowinfo >>= 20;

tclass = flowinfo & 0xff;

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

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

IPV6_TCLASS, IPPROTO_IPV6);

if (*mp)

Line 1135 ip6_savecontrol(struct in6pcb *in6p, str

Line 1169 ip6_savecontrol(struct in6pcb *in6p, str

* be removed before returning in the RFC 2292.

* Note: this constraint is removed in RFC3542.

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

*mp = sbcreatecontrol(hbh, hbhlen,

IS2292(IPV6_2292HOPOPTS, IPV6_HOPOPTS),

IPPROTO_IPV6);

if (*mp)

Line 1197 ip6_savecontrol(struct in6pcb *in6p, str

Line 1231 ip6_savecontrol(struct in6pcb *in6p, str

if (!(in6p->in6p_flags & IN6P_DSTOPTS))

break;

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

*mp = sbcreatecontrol(ip6e, elen,

IS2292(IPV6_2292DSTOPTS, IPV6_DSTOPTS),

IPPROTO_IPV6);

if (*mp)

Line 1208 ip6_savecontrol(struct in6pcb *in6p, str

Line 1242 ip6_savecontrol(struct in6pcb *in6p, str

if (!(in6p->in6p_flags & IN6P_RTHDR))

break;

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

*mp = sbcreatecontrol(ip6e, elen,

IS2292(IPV6_2292RTHDR, IPV6_RTHDR),

IPPROTO_IPV6);

if (*mp)

Line 1258 ip6_notify_pmtu(struct in6pcb *in6p, con

Line 1292 ip6_notify_pmtu(struct in6pcb *in6p, con

if (mtu == NULL)

return;

#ifdef DIAGNOSTIC

KASSERT(so != NULL);

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;

Line 1269 ip6_notify_pmtu(struct in6pcb *in6p, con

Line 1300 ip6_notify_pmtu(struct in6pcb *in6p, con

if (sa6_recoverscope(&mtuctl.ip6m_addr))

return;

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

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

IPV6_PATHMTU, IPPROTO_IPV6)) == NULL)

return;

Line 1524 ip6_delaux(struct mbuf *m)

Line 1555 ip6_delaux(struct mbuf *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 error;

error = sysctl_lookup(SYSCTLFN_CALL(rnode));

if (error || newp == NULL)

return (error);

mutex_enter(softnet_lock);

KERNEL_LOCK(1, NULL);

ip6flow_reap(0);

KERNEL_UNLOCK_ONE(NULL);

mutex_exit(softnet_lock);

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

mutex_enter(softnet_lock);

KERNEL_LOCK(1, NULL);

error = ip6flow_invalidate_all(tmp);

KERNEL_UNLOCK_ONE(NULL);

mutex_exit(softnet_lock);

} else {

* EINVAL if not a power of 2

error = EINVAL;

}

return error;

}

#endif /* GATEWAY */

* System control for IP6

Line 1902 sysctl_net_inet6_ip6_setup(struct sysctl

Line 1873 sysctl_net_inet6_ip6_setup(struct sysctl

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

/* anonportalgo RFC6056 subtree */

const struct sysctlnode *portalgo_node;

sysctl_createv(clog, 0, NULL, &portalgo_node,

CVSweb <webmaster@jp.NetBSD.org>