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.135.2.6 and 1.136

version 1.135.2.6, 2002/10/10 18:43:59

version 1.136, 2001/08/06 10:25:00

Line 3

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

Line 15

* 3. Neither the name of the project 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 PROJECT AND CONTRIBUTORS ``AS IS'' AND

* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

Line 101

* @(#)ip_input.c 8.2 (Berkeley) 1/4/94

#include <sys/cdefs.h>

__KERNEL_RCSID(0, "$NetBSD$");

#include "opt_gateway.h"

#include "opt_pfil_hooks.h"

#include "opt_ipsec.h"

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

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

#include <sys/errno.h>

#include <sys/time.h>

#include <sys/kernel.h>

#include <sys/proc.h>

#include <sys/pool.h>

#include <uvm/uvm_extern.h>

#include <sys/sysctl.h>

#include <net/if.h>

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

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

/* just for gif_ttl */

#include <netinet/in_gif.h>

#include "gif.h"

#include <net/if_gre.h>

#include "gre.h"

#ifdef MROUTING

#include <netinet/ip_mroute.h>

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

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

#define IPALLOWSRCRT 1 /* allow source-routed packets */

#endif

#ifndef IPMTUDISC

#define IPMTUDISC 1

#define IPMTUDISC 0

#endif

#ifndef IPMTUDISCTIMEOUT

#define IPMTUDISCTIMEOUT (10 * 60) /* as per RFC 1191 */

Line 192 int ip_forwsrcrt = IPFORWSRCRT;

Line 191 int ip_forwsrcrt = IPFORWSRCRT;

int ip_directedbcast = IPDIRECTEDBCAST;

int ip_allowsrcrt = IPALLOWSRCRT;

int ip_mtudisc = IPMTUDISC;

int ip_mtudisc_timeout = IPMTUDISCTIMEOUT;

u_int ip_mtudisc_timeout = IPMTUDISCTIMEOUT;

#ifdef DIAGNOSTIC

int ipprintfs = 0;

#endif

Line 201 struct rttimer_queue *ip_mtudisc_timeout

Line 200 struct rttimer_queue *ip_mtudisc_timeout

extern struct domain inetdomain;

int ipqmaxlen = IFQ_MAXLEN;

u_long in_ifaddrhash; /* size of hash table - 1 */

int in_ifaddrentries; /* total number of addrs */

struct in_ifaddrhead in_ifaddr;

struct in_ifaddrhashhead *in_ifaddrhashtbl;

struct ifqueue ipintrq;

Line 227 ipq_lock_try()

Line 224 ipq_lock_try()

int s;

* Use splvm() -- we're blocking things that would cause

* Use splvm() -- we're bloking things that would cause

* mbuf allocation.

s = splvm();

Line 320 ip_init()

Line 317 ip_init()

int i;

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

NULL);

0, NULL, NULL, M_IPQ);

pr = pffindproto(PF_INET, IPPROTO_RAW, SOCK_RAW);

if (pr == 0)

Line 339 ip_init()

Line 336 ip_init()

in_ifaddrhashtbl = hashinit(IN_IFADDR_HASH_SIZE, HASH_LIST, M_IFADDR,

M_WAITOK, &in_ifaddrhash);

if (ip_mtudisc != 0)

ip_mtudisc_timeout_q =

rt_timer_queue_create(ip_mtudisc_timeout);

#ifdef GATEWAY

ipflow_init();

Line 417 ip_input(struct mbuf *m)

Line 414 ip_input(struct mbuf *m)

* If no IP addresses have been set yet but the interfaces

* are receiving, can't do anything with incoming packets yet.

if (TAILQ_FIRST(&in_ifaddr) == 0)

if (in_ifaddr.tqh_first == 0)

goto bad;

ipstat.ips_total++;

if (m->m_len < sizeof (struct ip) &&

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

(m = m_pullup(m, sizeof (struct ip))) == 0) {

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

ipstat.ips_toosmall++;

* it. Otherwise, if it is aligned, make sure the entire

return;

* base IP header is in the first mbuf of the chain.

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

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

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

/* XXXJRT new stat, please */

ipstat.ips_toosmall++;

return;

}

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

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

ipstat.ips_toosmall++;

return;

}

ip = mtod(m, struct ip *);

if (ip->ip_v != IPVERSION) {

Line 476 ip_input(struct mbuf *m)

Line 459 ip_input(struct mbuf *m)

}

switch (m->m_pkthdr.csum_flags &

((m->m_pkthdr.rcvif->if_csum_flags_rx & M_CSUM_IPv4) |

((m->m_pkthdr.rcvif->if_csum_flags & M_CSUM_IPv4) |

M_CSUM_IPv4_BAD)) {

case M_CSUM_IPv4|M_CSUM_IPv4_BAD:

INET_CSUM_COUNTER_INCR(&ip_hwcsum_bad);

Line 525 ip_input(struct mbuf *m)

Line 508 ip_input(struct mbuf *m)

}

#ifdef IPSEC

/* ipflow (IP fast forwarding) is not compatible with IPsec. */

/* ipflow (IP fast fowarding) is not compatible with IPsec. */

m->m_flags &= ~M_CANFASTFWD;

#else

Line 559 ip_input(struct mbuf *m)

Line 542 ip_input(struct mbuf *m)

if (m == NULL)

return;

ip = mtod(m, struct ip *);

hlen = ip->ip_hl << 2;

}

#endif /* PFIL_HOOKS */

Line 572 ip_input(struct mbuf *m)

Line 554 ip_input(struct mbuf *m)

#endif

* Convert fields to host representation.

NTOHS(ip->ip_len);

NTOHS(ip->ip_off);

* Process options and, if not destined for us,

* ship it on. ip_dooptions returns 1 when an

* error was detected (causing an icmp message

Line 589 ip_input(struct mbuf *m)

Line 577 ip_input(struct mbuf *m)

* as not mine.

downmatch = 0;

LIST_FOREACH(ia, &IN_IFADDR_HASH(ip->ip_dst.s_addr), ia_hash) {

for (ia = IN_IFADDR_HASH(ip->ip_dst.s_addr).lh_first;

ia != NULL;

ia = ia->ia_hash.le_next) {

if (in_hosteq(ia->ia_addr.sin_addr, ip->ip_dst)) {

if ((ia->ia_ifp->if_flags & IFF_UP) != 0)

break;

Line 600 ip_input(struct mbuf *m)

Line 590 ip_input(struct mbuf *m)

if (ia != NULL)

goto ours;

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

TAILQ_FOREACH(ifa, &m->m_pkthdr.rcvif->if_addrlist, ifa_list) {

for (ifa = m->m_pkthdr.rcvif->if_addrlist.tqh_first;

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

ifa != NULL; ifa = ifa->ifa_list.tqe_next) {

continue;

if (ifa->ifa_addr->sa_family != AF_INET) continue;

ia = ifatoia(ifa);

if (in_hosteq(ip->ip_dst, ia->ia_broadaddr.sin_addr) ||

in_hosteq(ip->ip_dst, ia->ia_netbroadcast) ||

Line 626 ip_input(struct mbuf *m)

Line 616 ip_input(struct mbuf *m)

#ifdef MROUTING

extern struct socket *ip_mrouter;

if (M_READONLY(m)) {

if (m->m_flags & M_EXT) {

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

ipstat.ips_toosmall++;

return;

Line 697 ip_input(struct mbuf *m)

Line 687 ip_input(struct mbuf *m)

ipstat.ips_cantforward++;

return;

}

#ifdef IPSEC

if (ipsec4_in_reject(m, NULL)) {

ipsecstat.in_polvio++;

goto bad;

}

#endif

ip_forward(m, 0);

}

return;

Line 716 ours:

Line 699 ours:

* if the packet was previously fragmented,

* but it's not worth the time; just let them time out.)

if (ip->ip_off & ~htons(IP_DF|IP_RF)) {

if (ip->ip_off & ~(IP_DF|IP_RF)) {

if (M_READONLY(m)) {

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

ipstat.ips_toosmall++;

goto bad;

}

ip = mtod(m, struct ip *);

}

* Look for queue of fragments

* of this datagram.

IPQ_LOCK();

LIST_FOREACH(fp, &ipq, ipq_q)

for (fp = ipq.lh_first; fp != NULL; fp = fp->ipq_q.le_next)

if (ip->ip_id == fp->ipq_id &&

in_hosteq(ip->ip_src, fp->ipq_src) &&

in_hosteq(ip->ip_dst, fp->ipq_dst) &&

Line 744 found:

Line 719 found:

* set ipqe_mff if more fragments are expected,

* convert offset of this to bytes.

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

ip->ip_len -= hlen;

mff = (ip->ip_off & htons(IP_MF)) != 0;

mff = (ip->ip_off & IP_MF) != 0;

if (mff) {

* Make sure that fragments have a data length

* that's a non-zero multiple of 8 bytes.

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

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

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

ipstat.ips_badfrags++;

IPQ_UNLOCK();

goto bad;

}

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

ip->ip_off <<= 3;

* If datagram marked as having more fragments

* or if this is not the first fragment,

* attempt reassembly; if it succeeds, proceed.

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

if (mff || ip->ip_off) {

ipstat.ips_fragments++;

ipqe = pool_get(&ipqent_pool, PR_NOWAIT);

if (ipqe == NULL) {

Line 784 found:

Line 758 found:

ipstat.ips_reassembled++;

ip = mtod(m, struct ip *);

hlen = ip->ip_hl << 2;

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

ip->ip_len += hlen;

} else

if (fp)

ip_freef(fp);

Line 809 found:

Line 783 found:

#if IFA_STATS

if (ia && ip)

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

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

#endif

ipstat.ips_delivered++;

{

Line 877 ip_reass(ipqe, fp)

Line 851 ip_reass(ipqe, fp)

fp->ipq_ttl = IPFRAGTTL;

fp->ipq_p = ipqe->ipqe_ip->ip_p;

fp->ipq_id = ipqe->ipqe_ip->ip_id;

TAILQ_INIT(&fp->ipq_fragq);

LIST_INIT(&fp->ipq_fragq);

fp->ipq_src = ipqe->ipqe_ip->ip_src;

fp->ipq_dst = ipqe->ipqe_ip->ip_dst;

p = NULL;

Line 887 ip_reass(ipqe, fp)

Line 861 ip_reass(ipqe, fp)

* Find a segment which begins after this one does.

for (p = NULL, q = TAILQ_FIRST(&fp->ipq_fragq); q != NULL;

for (p = NULL, q = fp->ipq_fragq.lh_first; q != NULL;

p = q, q = TAILQ_NEXT(q, ipqe_q))

p = q, q = q->ipqe_q.le_next)

if (ntohs(q->ipqe_ip->ip_off) > ntohs(ipqe->ipqe_ip->ip_off))

if (q->ipqe_ip->ip_off > ipqe->ipqe_ip->ip_off)

break;

Line 898 ip_reass(ipqe, fp)

Line 872 ip_reass(ipqe, fp)

* segment. If it provides all of our data, drop us.

if (p != NULL) {

i = ntohs(p->ipqe_ip->ip_off) + ntohs(p->ipqe_ip->ip_len) -

i = p->ipqe_ip->ip_off + p->ipqe_ip->ip_len -

ntohs(ipqe->ipqe_ip->ip_off);

ipqe->ipqe_ip->ip_off;

if (i > 0) {

if (i >= ntohs(ipqe->ipqe_ip->ip_len))

if (i >= ipqe->ipqe_ip->ip_len)

goto dropfrag;

m_adj(ipqe->ipqe_m, i);

ipqe->ipqe_ip->ip_off =

ipqe->ipqe_ip->ip_off += i;

htons(ntohs(ipqe->ipqe_ip->ip_off) + i);

ipqe->ipqe_ip->ip_len -= i;

ipqe->ipqe_ip->ip_len =

htons(ntohs(ipqe->ipqe_ip->ip_len) - i);

}

Line 915 ip_reass(ipqe, fp)

Line 887 ip_reass(ipqe, fp)

* While we overlap succeeding segments trim them or,

* if they are completely covered, dequeue them.

for (; q != NULL &&

for (; q != NULL && ipqe->ipqe_ip->ip_off + ipqe->ipqe_ip->ip_len >

ntohs(ipqe->ipqe_ip->ip_off) + ntohs(ipqe->ipqe_ip->ip_len) >

q->ipqe_ip->ip_off; q = nq) {

ntohs(q->ipqe_ip->ip_off); q = nq) {

i = (ipqe->ipqe_ip->ip_off + ipqe->ipqe_ip->ip_len) -

i = (ntohs(ipqe->ipqe_ip->ip_off) +

q->ipqe_ip->ip_off;

ntohs(ipqe->ipqe_ip->ip_len)) - ntohs(q->ipqe_ip->ip_off);

if (i < q->ipqe_ip->ip_len) {

if (i < ntohs(q->ipqe_ip->ip_len)) {

q->ipqe_ip->ip_len -= i;

q->ipqe_ip->ip_len =

q->ipqe_ip->ip_off += i;

htons(ntohs(q->ipqe_ip->ip_len) - i);

q->ipqe_ip->ip_off =

htons(ntohs(q->ipqe_ip->ip_off) + i);

m_adj(q->ipqe_m, i);

break;

}

nq = TAILQ_NEXT(q, ipqe_q);

nq = q->ipqe_q.le_next;

m_freem(q->ipqe_m);

TAILQ_REMOVE(&fp->ipq_fragq, q, ipqe_q);

LIST_REMOVE(q, ipqe_q);

pool_put(&ipqent_pool, q);

}

Line 940 insert:

Line 909 insert:

* check for complete reassembly.

if (p == NULL) {

TAILQ_INSERT_HEAD(&fp->ipq_fragq, ipqe, ipqe_q);

LIST_INSERT_HEAD(&fp->ipq_fragq, ipqe, ipqe_q);

} else {

TAILQ_INSERT_AFTER(&fp->ipq_fragq, p, ipqe, ipqe_q);

LIST_INSERT_AFTER(p, ipqe, ipqe_q);

}

next = 0;

for (p = NULL, q = TAILQ_FIRST(&fp->ipq_fragq); q != NULL;

for (p = NULL, q = fp->ipq_fragq.lh_first; q != NULL;

p = q, q = TAILQ_NEXT(q, ipqe_q)) {

p = q, q = q->ipqe_q.le_next) {

if (ntohs(q->ipqe_ip->ip_off) != next)

if (q->ipqe_ip->ip_off != next)

return (0);

next += ntohs(q->ipqe_ip->ip_len);

next += q->ipqe_ip->ip_len;

}

if (p->ipqe_mff)

return (0);

Line 958 insert:

Line 927 insert:

* Reassembly is complete. Check for a bogus message size and

* concatenate fragments.

q = TAILQ_FIRST(&fp->ipq_fragq);

q = fp->ipq_fragq.lh_first;

ip = q->ipqe_ip;

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

ipstat.ips_toolong++;

Line 969 insert:

Line 938 insert:

t = m->m_next;

m->m_next = 0;

m_cat(m, t);

nq = TAILQ_NEXT(q, ipqe_q);

nq = q->ipqe_q.le_next;

pool_put(&ipqent_pool, q);

for (q = nq; q != NULL; q = nq) {

t = q->ipqe_m;

nq = TAILQ_NEXT(q, ipqe_q);

nq = q->ipqe_q.le_next;

pool_put(&ipqent_pool, q);

m_cat(m, t);

}

Line 984 insert:

Line 953 insert:

* dequeue and discard fragment reassembly header.

* Make header visible.

ip->ip_len = htons(next);

ip->ip_len = next;

ip->ip_src = fp->ipq_src;

ip->ip_dst = fp->ipq_dst;

LIST_REMOVE(fp, ipq_q);

Line 1020 ip_freef(fp)

Line 989 ip_freef(fp)

IPQ_LOCK_CHECK();

for (q = TAILQ_FIRST(&fp->ipq_fragq); q != NULL; q = p) {

for (q = fp->ipq_fragq.lh_first; q != NULL; q = p) {

p = TAILQ_NEXT(q, ipqe_q);

p = q->ipqe_q.le_next;

m_freem(q->ipqe_m);

TAILQ_REMOVE(&fp->ipq_fragq, q, ipqe_q);

LIST_REMOVE(q, ipqe_q);

pool_put(&ipqent_pool, q);

}

LIST_REMOVE(fp, ipq_q);

Line 1043 ip_slowtimo()

Line 1012 ip_slowtimo()

int s = splsoftnet();

IPQ_LOCK();

for (fp = LIST_FIRST(&ipq); fp != NULL; fp = nfp) {

for (fp = ipq.lh_first; fp != NULL; fp = nfp) {

nfp = LIST_NEXT(fp, ipq_q);

nfp = fp->ipq_q.le_next;

if (--fp->ipq_ttl == 0) {

ipstat.ips_fragtimeout++;

ip_freef(fp);

Line 1058 ip_slowtimo()

Line 1027 ip_slowtimo()

if (ip_maxfragpackets < 0)

;

else {

while (ip_nfragpackets > ip_maxfragpackets && LIST_FIRST(&ipq))

while (ip_nfragpackets > ip_maxfragpackets && ipq.lh_first)

ip_freef(LIST_FIRST(&ipq));

ip_freef(ipq.lh_first);

}

IPQ_UNLOCK();

#ifdef GATEWAY

Line 1082 ip_drain()

Line 1051 ip_drain()

if (ipq_lock_try() == 0)

return;

while (LIST_FIRST(&ipq) != NULL) {

while (ipq.lh_first != NULL) {

ipstat.ips_fragdropped++;

ip_freef(LIST_FIRST(&ipq));

ip_freef(ipq.lh_first);

}

IPQ_UNLOCK();

Line 1467 ip_stripoptions(m, mopt)

Line 1436 ip_stripoptions(m, mopt)

m->m_len -= olen;

if (m->m_flags & M_PKTHDR)

m->m_pkthdr.len -= olen;

ip->ip_len = htons(ntohs(ip->ip_len) - olen);

ip->ip_len -= olen;

ip->ip_hl = sizeof (struct ip) >> 2;

}

const int inetctlerrmap[PRC_NCMDS] = {

int inetctlerrmap[PRC_NCMDS] = {

0, 0, 0, 0,

0, EMSGSIZE, EHOSTDOWN, EHOSTUNREACH,

EHOSTUNREACH, EHOSTUNREACH, ECONNREFUSED, ECONNREFUSED,

Line 1557 ip_forward(m, srcrt)

Line 1526 ip_forward(m, srcrt)

* we need to generate an ICMP message to the src.

* Pullup to avoid sharing mbuf cluster between m and mcopy.

mcopy = m_copym(m, 0, imin(ntohs(ip->ip_len), 68), M_DONTWAIT);

mcopy = m_copym(m, 0, imin((int)ip->ip_len, 68), M_DONTWAIT);

if (mcopy)

mcopy = m_pullup(mcopy, ip->ip_hl << 2);

Line 1684 ip_forward(m, srcrt)

Line 1653 ip_forward(m, srcrt)

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

if (ro->ro_rt && ro->ro_rt->rt_ifp) {

dummyifp.if_mtu =

ro->ro_rt->rt_rmx.rmx_mtu ?

ro->ro_rt->rt_rmx.rmx_mtu :

ro->ro_rt->rt_ifp->if_mtu;

dummyifp.if_mtu -= ipsechdr;

destifp = &dummyifp;

Line 1700 ip_forward(m, srcrt)

Line 1667 ip_forward(m, srcrt)

break;

case ENOBUFS:

#if 1

* a router should not generate ICMP_SOURCEQUENCH as

* required in RFC1812 Requirements for IP Version 4 Routers.

* source quench could be a big problem under DoS attacks,

* or if the underlying interface is rate-limited.

if (mcopy)

m_freem(mcopy);

return;

#else

type = ICMP_SOURCEQUENCH;

code = 0;

break;

#endif

}

icmp_error(mcopy, type, code, dest, destifp);

}

Line 1829 ip_sysctl(name, namelen, oldp, oldlenp,

Line 1784 ip_sysctl(name, namelen, oldp, oldlenp,

error = sysctl_int(oldp, oldlenp, newp, newlen,

&ip_mtudisc);

if (ip_mtudisc != 0 && ip_mtudisc_timeout_q == NULL) {

ip_mtudisc_timeout_q =

rt_timer_queue_create(ip_mtudisc_timeout);

} else if (ip_mtudisc == 0 && ip_mtudisc_timeout_q != NULL) {

rt_timer_queue_destroy(ip_mtudisc_timeout_q, TRUE);

Line 1863 ip_sysctl(name, namelen, oldp, oldlenp,

Line 1818 ip_sysctl(name, namelen, oldp, oldlenp,

}

return (error);

case IPCTL_MTUDISCTIMEOUT:

old = ip_mtudisc_timeout;

error = sysctl_int(oldp, oldlenp, newp, newlen,

&ip_mtudisc_timeout);

if (ip_mtudisc_timeout < 0) {

ip_mtudisc_timeout = old;

return (EINVAL);

}

if (ip_mtudisc_timeout_q != NULL)

rt_timer_queue_change(ip_mtudisc_timeout_q,

ip_mtudisc_timeout);

return (error);

#ifdef GATEWAY

Line 1892 ip_sysctl(name, namelen, oldp, oldlenp,

Line 1842 ip_sysctl(name, namelen, oldp, oldlenp,

&hostzeroisbroadcast));

#if NGIF > 0

case IPCTL_GIF_TTL:

return (sysctl_int(oldp, oldlenp, newp, newlen,

return(sysctl_int(oldp, oldlenp, newp, newlen,

&ip_gif_ttl));

#endif

#if NGRE > 0

case IPCTL_GRE_TTL:

return (sysctl_int(oldp, oldlenp, newp, newlen,

&ip_gre_ttl));

#endif

#ifndef IPNOPRIVPORTS

case IPCTL_LOWPORTMIN:

old = lowportmin;

CVSweb <webmaster@jp.NetBSD.org>