src/sys/netinet/ip_input.c - diff

Return to ip_input.c CVS log

Up to [cvs.NetBSD.org] / src / sys / netinet

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/netinet/ip_input.c between version 1.262.6.5 and 1.263

version 1.262.6.5, 2009/01/17 13:29:32

version 1.263, 2008/03/27 00:18:56

Line 45

* 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

* must display the following acknowledgement:

* This product includes software developed by the NetBSD

* Foundation, Inc. and its contributors.

* 4. Neither the name of The NetBSD Foundation nor the names of its

* contributors may be used to endorse or promote products derived

* from this software without specific prior written permission.

* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS

* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED

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

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

#include <netinet/in_proto.h>

#include <netinet/in_var.h>

#include <netinet/ip_var.h>

#include <netinet/ip_private.h>

#include <netinet/ip_icmp.h>

/* just for gif_ttl */

#include <netinet/in_gif.h>

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

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

#ifdef IPSEC

#include <netinet6/ipsec.h>

#include <netinet6/ipsec_private.h>

#include <netkey/key.h>

#endif

#ifdef FAST_IPSEC

Line 225 u_long in_multihash; /* size of hash

Line 230 u_long in_multihash; /* size of hash

int in_multientries; /* total number of addrs */

struct in_multihashhead *in_multihashtbl;

struct ifqueue ipintrq;

struct ipstat ipstat;

uint16_t ip_id;

percpu_t *ipstat_percpu;

#ifdef PFIL_HOOKS

struct pfil_head inet_pfil_hook;

#endif

Line 330 do { \

Line 334 do { \

#define IPQ_UNLOCK() ipq_unlock()

struct pool inmulti_pool;

POOL_INIT(inmulti_pool, sizeof(struct in_multi), 0, 0, 0, "inmltpl", NULL,

struct pool ipqent_pool;

IPL_SOFTNET);

POOL_INIT(ipqent_pool, sizeof(struct ipqent), 0, 0, 0, "ipqepl", NULL,

IPL_VM);

#ifdef INET_CSUM_COUNTERS

#include <sys/device.h>

Line 397 ip_init(void)

Line 403 ip_init(void)

const struct protosw *pr;

int i;

pool_init(&inmulti_pool, sizeof(struct in_multi), 0, 0, 0, "inmltpl",

NULL, IPL_SOFTNET);

pool_init(&ipqent_pool, sizeof(struct ipqent), 0, 0, 0, "ipqepl",

NULL, IPL_VM);

pr = pffindproto(PF_INET, IPPROTO_RAW, SOCK_RAW);

if (pr == 0)

panic("ip_init");

Line 423 ip_init(void)

Line 424 ip_init(void)

ip_nmbclusters_changed();

TAILQ_INIT(&in_ifaddrhead);

in_ifaddrhashtbl = hashinit(IN_IFADDR_HASH_SIZE, HASH_LIST, true,

in_ifaddrhashtbl = hashinit(IN_IFADDR_HASH_SIZE, HASH_LIST, M_IFADDR,

&in_ifaddrhash);

M_WAITOK, &in_ifaddrhash);

in_multihashtbl = hashinit(IN_IFADDR_HASH_SIZE, HASH_LIST, true,

in_multihashtbl = hashinit(IN_IFADDR_HASH_SIZE, HASH_LIST, M_IPMADDR,

&in_multihash);

M_WAITOK, &in_multihash);

ip_mtudisc_timeout_q = rt_timer_queue_create(ip_mtudisc_timeout);

#ifdef GATEWAY

ipflow_init(ip_hashsize);

Line 446 ip_init(void)

Line 447 ip_init(void)

MOWNER_ATTACH(&ip_tx_mowner);

MOWNER_ATTACH(&ip_rx_mowner);

#endif /* MBUFTRACE */

ipstat_percpu = percpu_alloc(sizeof(uint64_t) * IP_NSTATS);

}

struct sockaddr_in ipaddr = {

Line 465 ipintr(void)

Line 464 ipintr(void)

int s;

struct mbuf *m;

mutex_enter(softnet_lock);

KERNEL_LOCK(1, NULL);

while (!IF_IS_EMPTY(&ipintrq)) {

s = splnet();

IF_DEQUEUE(&ipintrq, m);

splx(s);

if (m == NULL)

if (m == 0)

break;

return;

ip_input(m);

}

KERNEL_UNLOCK_ONE(NULL);

mutex_exit(softnet_lock);

}

Line 516 ip_input(struct mbuf *m)

Line 511 ip_input(struct mbuf *m)

if (TAILQ_FIRST(&in_ifaddrhead) == 0)

goto bad;

IP_STATINC(IP_STAT_TOTAL);

ipstat.ips_total++;

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

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

Line 527 ip_input(struct mbuf *m)

Line 522 ip_input(struct mbuf *m)

if ((m = m_copyup(m, sizeof(struct ip),

(max_linkhdr + 3) & ~3)) == NULL) {

/* XXXJRT new stat, please */

IP_STATINC(IP_STAT_TOOSMALL);

ipstat.ips_toosmall++;

return;

}

} else if (__predict_false(m->m_len < sizeof (struct ip))) {

if ((m = m_pullup(m, sizeof (struct ip))) == NULL) {

IP_STATINC(IP_STAT_TOOSMALL);

ipstat.ips_toosmall++;

return;

}

ip = mtod(m, struct ip *);

if (ip->ip_v != IPVERSION) {

IP_STATINC(IP_STAT_BADVERS);

ipstat.ips_badvers++;

goto bad;

}

hlen = ip->ip_hl << 2;

if (hlen < sizeof(struct ip)) { /* minimum header length */

IP_STATINC(IP_STAT_BADHLEN);

ipstat.ips_badhlen++;

goto bad;

}

if (hlen > m->m_len) {

if ((m = m_pullup(m, hlen)) == 0) {

IP_STATINC(IP_STAT_BADHLEN);

ipstat.ips_badhlen++;

return;

}

ip = mtod(m, struct ip *);

Line 559 ip_input(struct mbuf *m)

Line 554 ip_input(struct mbuf *m)

* not allowed.

if (IN_MULTICAST(ip->ip_src.s_addr)) {

IP_STATINC(IP_STAT_BADADDR);

ipstat.ips_badaddr++;

goto bad;

}

Line 567 ip_input(struct mbuf *m)

Line 562 ip_input(struct mbuf *m)

if ((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||

(ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) {

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

IP_STATINC(IP_STAT_BADADDR);

ipstat.ips_badaddr++;

goto bad;

}

Line 605 ip_input(struct mbuf *m)

Line 600 ip_input(struct mbuf *m)

* Check for additional length bogosity

if (len < hlen) {

IP_STATINC(IP_STAT_BADLEN);

ipstat.ips_badlen++;

goto bad;

}

Line 616 ip_input(struct mbuf *m)

Line 611 ip_input(struct mbuf *m)

* Drop packet if shorter than we expect.

if (m->m_pkthdr.len < len) {

IP_STATINC(IP_STAT_TOOSHORT);

ipstat.ips_tooshort++;

goto bad;

}

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

Line 785 ip_input(struct mbuf *m)

Line 780 ip_input(struct mbuf *m)

* ip_output().)

if (ip_mforward(m, m->m_pkthdr.rcvif) != 0) {

IP_STATINC(IP_STAT_CANTFORWARD);

ipstat.ips_cantforward++;

m_freem(m);

return;

}

Line 797 ip_input(struct mbuf *m)

Line 792 ip_input(struct mbuf *m)

if (ip->ip_p == IPPROTO_IGMP)

goto ours;

IP_STATINC(IP_STAT_CANTFORWARD);

ipstat.ips_forward++;

}

#endif

Line 806 ip_input(struct mbuf *m)

Line 801 ip_input(struct mbuf *m)

IN_LOOKUP_MULTI(ip->ip_dst, m->m_pkthdr.rcvif, inm);

if (inm == NULL) {

IP_STATINC(IP_STAT_CANTFORWARD);

ipstat.ips_cantforward++;

m_freem(m);

return;

}

Line 820 ip_input(struct mbuf *m)

Line 815 ip_input(struct mbuf *m)

* Not for us; forward if possible and desirable.

if (ipforwarding == 0) {

IP_STATINC(IP_STAT_CANTFORWARD);

ipstat.ips_cantforward++;

m_freem(m);

} else {

Line 831 ip_input(struct mbuf *m)

Line 826 ip_input(struct mbuf *m)

if (downmatch) {

icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, 0);

IP_STATINC(IP_STAT_CANTFORWARD);

ipstat.ips_cantforward++;

return;

}

#ifdef IPSEC

if (ipsec4_in_reject(m, NULL)) {

IPSEC_STATINC(IPSEC_STAT_IN_POLVIO);

ipsecstat.in_polvio++;

goto bad;

}

#endif

Line 864 ip_input(struct mbuf *m)

Line 859 ip_input(struct mbuf *m)

KEY_FREESP(&sp);

splx(s);

if (error) {

IP_STATINC(IP_STAT_CANTFORWARD);

ipstat.ips_cantforward++;

goto bad;

}

Line 911 ours:

Line 906 ours:

off = (ntohs(ip->ip_off) & IP_OFFMASK) << 3;

if ((off > 0 ? off + hlen : len) < IP_MINFRAGSIZE - 1) {

IP_STATINC(IP_STAT_BADFRAGS);

ipstat.ips_badfrags++;

goto bad;

}

Line 930 ours:

Line 925 ours:

* fragments.

if (ip->ip_tos != fp->ipq_tos) {

IP_STATINC(IP_STAT_BADFRAGS);

ipstat.ips_badfrags++;

IPQ_UNLOCK();

goto bad;

}

goto found;

Line 954 found:

Line 948 found:

if (ntohs(ip->ip_len) == 0 ||

(ntohs(ip->ip_len) & 0x7) != 0) {

IP_STATINC(IP_STAT_BADFRAGS);

ipstat.ips_badfrags++;

IPQ_UNLOCK();

goto bad;

}

Line 967 found:

Line 961 found:

* attempt reassembly; if it succeeds, proceed.

if (mff || ip->ip_off != htons(0)) {

IP_STATINC(IP_STAT_FRAGMENTS);

ipstat.ips_fragments++;

s = splvm();

ipqe = pool_get(&ipqent_pool, PR_NOWAIT);

splx(s);

if (ipqe == NULL) {

IP_STATINC(IP_STAT_RCVMEMDROP);

ipstat.ips_rcvmemdrop++;

IPQ_UNLOCK();

goto bad;

}

Line 984 found:

Line 978 found:

IPQ_UNLOCK();

return;

}

IP_STATINC(IP_STAT_REASSEMBLED);

ipstat.ips_reassembled++;

ip = mtod(m, struct ip *);

hlen = ip->ip_hl << 2;

ip->ip_len = htons(ntohs(ip->ip_len) + hlen);

Line 1002 found:

Line 996 found:

if ((inetsw[ip_protox[ip->ip_p]].pr_flags & PR_LASTHDR) != 0 &&

ipsec4_in_reject(m, NULL)) {

IPSEC_STATINC(IPSEC_STAT_IN_POLVIO);

ipsecstat.in_polvio++;

goto bad;

}

#endif

Line 1052 DPRINTF(("ip_input: no SP, packet discar

Line 1046 DPRINTF(("ip_input: no SP, packet discar

if (ia && ip)

ia->ia_ifa.ifa_data.ifad_inbytes += ntohs(ip->ip_len);

#endif

IP_STATINC(IP_STAT_DELIVERED);

ipstat.ips_delivered++;

{

int off = hlen, nh = ip->ip_p;

Line 1064 bad:

Line 1058 bad:

return;

badcsum:

IP_STATINC(IP_STAT_BADSUM);

ipstat.ips_badsum++;

m_freem(m);

}

Line 1122 ip_reass(struct ipqent *ipqe, struct ipq

Line 1116 ip_reass(struct ipqent *ipqe, struct ipq

else if (ip_nfragpackets >= ip_maxfragpackets)

goto dropfrag;

ip_nfragpackets++;

fp = malloc(sizeof (struct ipq), M_FTABLE, M_NOWAIT);

MALLOC(fp, struct ipq *, sizeof (struct ipq),

M_FTABLE, M_NOWAIT);

if (fp == NULL)

goto dropfrag;

LIST_INSERT_HEAD(ipqhead, fp, ipq_q);

Line 1221 insert:

Line 1216 insert:

q = TAILQ_FIRST(&fp->ipq_fragq);

ip = q->ipqe_ip;

if ((next + (ip->ip_hl << 2)) > IP_MAXPACKET) {

IP_STATINC(IP_STAT_TOOLONG);

ipstat.ips_toolong++;

ip_freef(fp);

return (0);

}

Line 1253 insert:

Line 1248 insert:

ip->ip_src = fp->ipq_src;

ip->ip_dst = fp->ipq_dst;

LIST_REMOVE(fp, ipq_q);

free(fp, M_FTABLE);

FREE(fp, M_FTABLE);

ip_nfragpackets--;

m->m_len += (ip->ip_hl << 2);

m->m_data -= (ip->ip_hl << 2);

Line 1271 dropfrag:

Line 1266 dropfrag:

if (fp != 0)

fp->ipq_nfrags--;

ip_nfrags--;

IP_STATINC(IP_STAT_FRAGDROPPED);

ipstat.ips_fragdropped++;

m_freem(m);

s = splvm();

pool_put(&ipqent_pool, ipqe);

Line 1306 ip_freef(struct ipq *fp)

Line 1301 ip_freef(struct ipq *fp)

printf("ip_freef: nfrags %d != %d\n", fp->ipq_nfrags, nfrags);

ip_nfrags -= nfrags;

LIST_REMOVE(fp, ipq_q);

free(fp, M_FTABLE);

FREE(fp, M_FTABLE);

ip_nfragpackets--;

}

Line 1338 ip_reass_ttl_decr(u_int ticks)

Line 1333 ip_reass_ttl_decr(u_int ticks)

0 : fp->ipq_ttl - ticks);

nfp = LIST_NEXT(fp, ipq_q);

if (fp->ipq_ttl == 0) {

IP_STATINC(IP_STAT_FRAGTIMEOUT);

ipstat.ips_fragtimeout++;

ip_freef(fp);

} else {

nfrags += fp->ipq_nfrags;

Line 1389 ip_slowtimo(void)

Line 1384 ip_slowtimo(void)

static u_int dropscanidx = 0;

u_int i;

u_int median_ttl;

int s = splsoftnet();

mutex_enter(softnet_lock);

KERNEL_LOCK(1, NULL);

IPQ_LOCK();

Line 1433 ip_slowtimo(void)

Line 1426 ip_slowtimo(void)

dropscanidx = i;

}

IPQ_UNLOCK();

splx(s);

KERNEL_UNLOCK_ONE(NULL);

mutex_exit(softnet_lock);

}

* Drain off all datagram fragments. Don't acquire softnet_lock as

* Drain off all datagram fragments.

* can be called from hardware interrupt context.

void

ip_drain(void)

{

KERNEL_LOCK(1, NULL);

* We may be called from a device's interrupt context. If

* the ipq is already busy, just bail out now.

if (ipq_lock_try() != 0) {

if (ipq_lock_try() == 0)

return;

* Drop half the total fragments now. If more mbufs are

* needed, we will be called again soon.

* Drop half the total fragments now. If more mbufs are needed,

ip_reass_drophalf();

* we will be called again soon.

IPQ_UNLOCK();

}

ip_reass_drophalf();

KERNEL_UNLOCK_ONE(NULL);

IPQ_UNLOCK();

}

Line 1692 ip_dooptions(struct mbuf *m)

Line 1680 ip_dooptions(struct mbuf *m)

return (0);

bad:

icmp_error(m, type, code, 0, 0);

IP_STATINC(IP_STAT_BADOPTIONS);

ipstat.ips_badoptions++;

return (1);

}

Line 1865 ip_forward(struct mbuf *m, int srcrt)

Line 1853 ip_forward(struct mbuf *m, int srcrt)

}

#endif

if (m->m_flags & (M_BCAST|M_MCAST) || in_canforward(ip->ip_dst) == 0) {

IP_STATINC(IP_STAT_CANTFORWARD);

ipstat.ips_cantforward++;

m_freem(m);

return;

}

Line 1929 ip_forward(struct mbuf *m, int srcrt)

Line 1917 ip_forward(struct mbuf *m, int srcrt)

(struct ip_moptions *)NULL, (struct socket *)NULL);

if (error)

IP_STATINC(IP_STAT_CANTFORWARD);

ipstat.ips_cantforward++;

else {

uint64_t *ips = IP_STAT_GETREF();

ipstat.ips_forward++;

ips[IP_STAT_FORWARD]++;

if (type)

if (type) {

ipstat.ips_redirectsent++;

ips[IP_STAT_REDIRECTSENT]++;

else {

IP_STAT_PUTREF();

} else {

IP_STAT_PUTREF();

if (mcopy) {

#ifdef GATEWAY

if (mcopy->m_flags & M_CANFASTFWD)

Line 1970 ip_forward(struct mbuf *m, int srcrt)

Line 1955 ip_forward(struct mbuf *m, int srcrt)

type = ICMP_UNREACH;

code = ICMP_UNREACH_NEEDFRAG;

if ((rt = rtcache_validate(&ipforward_rt)) != NULL)

if ((rt = rtcache_validate(&ipforward_rt)) != NULL) {

destmtu = rt->rt_ifp->if_mtu;

#if defined(IPSEC) || defined(FAST_IPSEC)

{

* If the packet is routed over IPsec tunnel, tell the

* originator the tunnel MTU.

Line 1990 ip_forward(struct mbuf *m, int srcrt)

Line 1973 ip_forward(struct mbuf *m, int srcrt)

sp = ipsec4_getpolicybyaddr(mcopy,

IPSEC_DIR_OUTBOUND, IP_FORWARDING,

&ipsecerror);

#endif

destmtu = rt->rt_ifp->if_mtu;

#if defined(IPSEC) || defined(FAST_IPSEC)

if (sp != NULL) {

/* count IPsec header size */

ipsechdr = ipsec4_hdrsiz(mcopy,

Line 2005 ip_forward(struct mbuf *m, int srcrt)

Line 1991 ip_forward(struct mbuf *m, int srcrt)

&& sp->req->sav != NULL

&& sp->req->sav->sah != NULL) {

ro = &sp->req->sav->sah->sa_route;

rt = rtcache_validate(ro);

if (rt && rt->rt_ifp) {

destmtu =

rt->rt_rmx.rmx_mtu ?

Line 2021 ip_forward(struct mbuf *m, int srcrt)

Line 2006 ip_forward(struct mbuf *m, int srcrt)

KEY_FREESP(&sp);

#endif

}

#endif /*defined(IPSEC) || defined(FAST_IPSEC)*/

IP_STATINC(IP_STAT_CANTFRAG);

}

ipstat.ips_cantfrag++;

break;

case ENOBUFS:

Line 2146 sysctl_net_inet_ip_pmtudto(SYSCTLFN_ARGS

Line 2131 sysctl_net_inet_ip_pmtudto(SYSCTLFN_ARGS

if (tmp < 0)

return (EINVAL);

mutex_enter(softnet_lock);

ip_mtudisc_timeout = tmp;

rt_timer_queue_change(ip_mtudisc_timeout_q, ip_mtudisc_timeout);

mutex_exit(softnet_lock);

return (0);

}

Line 2163 sysctl_net_inet_ip_pmtudto(SYSCTLFN_ARGS

Line 2144 sysctl_net_inet_ip_pmtudto(SYSCTLFN_ARGS

static int

sysctl_net_inet_ip_maxflows(SYSCTLFN_ARGS)

{

int error;

int s;

error = sysctl_lookup(SYSCTLFN_CALL(rnode));

if (error || newp == NULL)

return (error);

mutex_enter(softnet_lock);

KERNEL_LOCK(1, NULL);

ipflow_prune();

s = sysctl_lookup(SYSCTLFN_CALL(rnode));

if (s || newp == NULL)

return (s);

KERNEL_UNLOCK_ONE(NULL);

s = splsoftnet();

mutex_exit(softnet_lock);

ipflow_reap(0);

splx(s);

return (0);

}

Line 2197 sysctl_net_inet_ip_hashsize(SYSCTLFN_ARG

Line 2174 sysctl_net_inet_ip_hashsize(SYSCTLFN_ARG

* Can only fail due to malloc()

mutex_enter(softnet_lock);

if (ipflow_invalidate_all(tmp))

KERNEL_LOCK(1, NULL);

return ENOMEM;

error = ipflow_invalidate_all(tmp);

KERNEL_UNLOCK_ONE(NULL);

mutex_exit(softnet_lock);

} else {

* EINVAL if not a power of 2

error = EINVAL;

return EINVAL;

}

return error;

return (0);

}

#endif /* GATEWAY */

static int

sysctl_net_inet_ip_stats(SYSCTLFN_ARGS)

{

return (NETSTAT_SYSCTL(ipstat_percpu, IP_NSTATS));

}

SYSCTL_SETUP(sysctl_net_inet_ip_setup, "sysctl net.inet.ip subtree setup")

{

Line 2426 SYSCTL_SETUP(sysctl_net_inet_ip_setup, "

Line 2391 SYSCTL_SETUP(sysctl_net_inet_ip_setup, "

CTLFLAG_PERMANENT,

CTLTYPE_STRUCT, "stats",

SYSCTL_DESCR("IP statistics"),

sysctl_net_inet_ip_stats, 0, NULL, 0,

NULL, 0, &ipstat, sizeof(ipstat),

CTL_NET, PF_INET, IPPROTO_IP, IPCTL_STATS,

CTL_EOL);

}

void

ip_statinc(u_int stat)

{

KASSERT(stat < IP_NSTATS);

IP_STATINC(stat);

}

CVSweb <webmaster@jp.NetBSD.org>