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.130.2.14 and 1.141

version 1.130.2.14, 2002/10/18 02:45:17

version 1.141, 2001/11/13 00:32:38

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 139 __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 166 __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 190 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 199 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 223 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 316 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 335 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 420 ip_input(struct mbuf *m)

Line 416 ip_input(struct mbuf *m)

if (TAILQ_FIRST(&in_ifaddr) == 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 525 ip_input(struct mbuf *m)

Line 507 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 541 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 553 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 626 ip_input(struct mbuf *m)

Line 613 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 684 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 696 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.

Line 744 found:

Line 716 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 755 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 780 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 848 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 858 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 = LIST_FIRST(&fp->ipq_fragq); q != NULL;

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

p = q, q = LIST_NEXT(q, ipqe_q))

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 869 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 884 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 = LIST_NEXT(q, ipqe_q);

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 906 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 = LIST_FIRST(&fp->ipq_fragq); q != NULL;

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

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

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 924 insert:

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

* concatenate fragments.

q = TAILQ_FIRST(&fp->ipq_fragq);

q = LIST_FIRST(&fp->ipq_fragq);

ip = q->ipqe_ip;

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

ipstat.ips_toolong++;

Line 969 insert:

Line 935 insert:

t = m->m_next;

m->m_next = 0;

m_cat(m, t);

nq = TAILQ_NEXT(q, ipqe_q);

nq = LIST_NEXT(q, ipqe_q);

pool_put(&ipqent_pool, q);

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

t = q->ipqe_m;

nq = TAILQ_NEXT(q, ipqe_q);

nq = LIST_NEXT(q, ipqe_q);

pool_put(&ipqent_pool, q);

m_cat(m, t);

}

Line 984 insert:

Line 950 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 986 ip_freef(fp)

IPQ_LOCK_CHECK();

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

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

p = TAILQ_NEXT(q, ipqe_q);

p = LIST_NEXT(q, ipqe_q);

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 1467 ip_stripoptions(m, mopt)

Line 1433 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;

}

Line 1557 ip_forward(m, srcrt)

Line 1523 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 1650 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 1664 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 1781 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 1815 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 1839 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>