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.202 and 1.212.2.2.4.1

version 1.202, 2004/05/02 05:02:53

version 1.212.2.2.4.1, 2007/09/17 20:16:58

Line 222 struct rttimer_queue *ip_mtudisc_timeout

int ipqmaxlen = IFQ_MAXLEN;

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

int in_ifaddrentries; /* total number of addrs */

struct in_ifaddrhead in_ifaddrhead;

struct in_ifaddrhashhead *in_ifaddrhashtbl;

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

int in_multientries; /* total number of addrs */

Line 240 struct pfil_head inet_pfil_hook;

* recalculate IP parameters derived from nmbclusters.

static int ip_nmbclusters; /* copy of nmbclusters */

static void ip_nmbclusters_changed __P((void)); /* recalc limits */

static void ip_nmbclusters_changed(void); /* recalc limits */

#define CHECK_NMBCLUSTER_PARAMS() \

do { \

Line 256 do { \

(((((x) & 0xF) | ((((x) >> 8) & 0xF) << 4)) ^ (y)) & IPREASS_HMASK)

struct ipqhead ipq[IPREASS_NHASH];

int ipq_locked;

static int ip_nfragpackets; /* packets in reass queue */

static int ip_nfrags; /* total fragments in reass queues */

int ip_maxfragpackets = 200; /* limit on packets. XXX sysctl */

Line 266 int ip_maxfrags; /* limit on fr

* Additive-Increase/Multiplicative-Decrease (AIMD) strategy for

* IP reassembly queue buffer managment.

* We keep a count of total IP fragments (NB: not fragmented packets!)

* awaiting reassembly (ip_nfrags) and a limit (ip_maxfrags) on fragments.

* If ip_nfrags exceeds ip_maxfrags the limit, we drop half the

Line 274 int ip_maxfrags; /* limit on fr

* repeatedly deleting single packets under heavy fragmentation load

* (e.g., from lossy NFS peers).

static u_int ip_reass_ttl_decr __P((u_int ticks));

static u_int ip_reass_ttl_decr(u_int ticks);

static void ip_reass_drophalf __P((void));

static void ip_reass_drophalf(void);

static __inline int ipq_lock_try __P((void));

static __inline int ipq_lock_try(void);

static __inline void ipq_unlock __P((void));

static __inline void ipq_unlock(void);

static __inline int

ipq_lock_try()

ipq_lock_try(void)

{

int s;

Line 301 ipq_lock_try()

}

static __inline void

ipq_unlock()

ipq_unlock(void)

{

int s;

Line 372 static struct ip_srcrt {

struct in_addr route[MAX_IPOPTLEN/sizeof(struct in_addr)];

} ip_srcrt;

static void save_rte __P((u_char *, struct in_addr));

static void save_rte(u_char *, struct in_addr);

#ifdef MBUFTRACE

struct mowner ip_rx_mowner = { "internet", "rx" };

Line 394 ip_nmbclusters_changed(void)

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

void

ip_init()

ip_init(void)

{

const struct protosw *pr;

int i;

Line 451 struct route ipforward_rt;

* IP software interrupt routine

void

ipintr()

ipintr(void)

{

int s;

struct mbuf *m;

Line 572 ip_input(struct mbuf *m)

break;

default:

/* Must compute it ourselves. */

INET_CSUM_COUNTER_INCR(&ip_swcsum);

* Must compute it ourselves. Maybe skip checksum on

if (in_cksum(m, hlen) != 0)

* loopback interfaces.

goto bad;

if (__predict_true(!(m->m_pkthdr.rcvif->if_flags &

IFF_LOOPBACK) || ip_do_loopback_cksum)) {

INET_CSUM_COUNTER_INCR(&ip_swcsum);

if (in_cksum(m, hlen) != 0)

goto badcsum;

}

break;

}

Line 649 ip_input(struct mbuf *m)

Line 655 ip_input(struct mbuf *m)

return;

ip = mtod(m, struct ip *);

hlen = ip->ip_hl << 2;

* XXX The setting of "srcrt" here is to prevent ip_forward()

* from generating ICMP redirects for packets that have

* been redirected by a hook back out on to the same LAN that

* they came from and is not an indication that the packet

* is being inffluenced by source routing options. This

* allows things like

* "rdr tlp0 0/0 port 80 -> 1.1.1.200 3128 tcp"

* where tlp0 is both on the 1.1.1.0/24 network and is the

* default route for hosts on 1.1.1.0/24. Of course this

* also requires a "map tlp0 ..." to complete the story.

* One might argue whether or not this kind of network config.

* should be supported in this manner...

srcrt = (odst.s_addr != ip->ip_dst.s_addr);

}

#endif /* PFIL_HOOKS */

Line 712 ip_input(struct mbuf *m)

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

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

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

continue;

ia = ifatoia(ifa);

Line 815 ip_input(struct mbuf *m)

Line 835 ip_input(struct mbuf *m)

sp = ipsec_getpolicy(tdbi, IPSEC_DIR_INBOUND);

} else {

sp = ipsec_getpolicybyaddr(m, IPSEC_DIR_INBOUND,

IP_FORWARDING, &error);

}

if (sp == NULL) { /* NB: can happen if error */

splx(s);

Line 965 found:

Line 985 found:

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

Line 973 found:

Line 993 found:

sp = ipsec_getpolicy(tdbi, IPSEC_DIR_INBOUND);

} else {

sp = ipsec_getpolicybyaddr(m, IPSEC_DIR_INBOUND,

IP_FORWARDING, &error);

}

if (sp != NULL) {

Line 985 found:

Line 1005 found:

/* XXX error stat??? */

error = EINVAL;

DPRINTF(("ip_input: no SP, packet discarded\n"));/*XXX*/

goto bad;

}

splx(s);

if (error)

Line 1023 badcsum:

Line 1042 badcsum:

* is given as fp; otherwise have to make a chain.

struct mbuf *

ip_reass(ipqe, fp, ipqhead)

ip_reass(struct ipqent *ipqe, struct ipq *fp, struct ipqhead *ipqhead)

struct ipqent *ipqe;

struct ipq *fp;

struct ipqhead *ipqhead;

{

struct mbuf *m = ipqe->ipqe_m;

struct ipqent *nq, *p, *q;

Line 1057 ip_reass(ipqe, fp, ipqhead)

Line 1073 ip_reass(ipqe, fp, ipqhead)

* We are about to add a fragment; increment frag count.

ip_nfrags++;

* If first fragment to arrive, create a reassembly queue.

Line 1208 insert:

Line 1224 insert:

for (t = m; t; t = t->m_next)

plen += t->m_len;

m->m_pkthdr.len = plen;

m->m_pkthdr.csum_flags = 0;

}

return (m);

Line 1226 dropfrag:

Line 1243 dropfrag:

* associated datagrams.

void

ip_freef(fp)

ip_freef(struct ipq *fp)

struct ipq *fp;

{

struct ipqent *q, *p;

u_int nfrags = 0;

Line 1268 ip_reass_ttl_decr(u_int ticks)

Line 1284 ip_reass_ttl_decr(u_int ticks)

u_int nfrags, median, dropfraction, keepfraction;

struct ipq *fp, *nfp;

int i;

nfrags = 0;

memset(fragttl_histo, 0, sizeof fragttl_histo);

for (i = 0; i < IPREASS_NHASH; i++) {

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

fp->ipq_ttl = ((fp->ipq_ttl <= ticks) ?

Line 1324 ip_reass_drophalf(void)

Line 1340 ip_reass_drophalf(void)

* queue, discard it.

void

ip_slowtimo()

ip_slowtimo(void)

{

static u_int dropscanidx = 0;

u_int i;

Line 1381 ip_slowtimo()

Line 1397 ip_slowtimo()

* Drain off all datagram fragments.

void

ip_drain()

ip_drain(void)

{

Line 1408 ip_drain()

Line 1424 ip_drain()

* 0 if the packet should be processed further.

int

ip_dooptions(m)

ip_dooptions(struct mbuf *m)

struct mbuf *m;

{

struct ip *ip = mtod(m, struct ip *);

u_char *cp, *cp0;

Line 1638 bad:

Line 1653 bad:

* return internet address info of interface to be used to get there.

struct in_ifaddr *

ip_rtaddr(dst)

ip_rtaddr(struct in_addr dst)

struct in_addr dst;

{

struct sockaddr_in *sin;

Line 1666 ip_rtaddr(dst)

Line 1680 ip_rtaddr(dst)

* to be picked up later by ip_srcroute if the receiver is interested.

void

save_rte(option, dst)

save_rte(u_char *option, struct in_addr dst)

u_char *option;

struct in_addr dst;

{

unsigned olen;

Line 1690 save_rte(option, dst)

Line 1702 save_rte(option, dst)

* The first hop is placed before the options, will be removed later.

struct mbuf *

ip_srcroute()

ip_srcroute(void)

{

struct in_addr *p, *q;

struct mbuf *m;

Line 1762 ip_srcroute()

Line 1774 ip_srcroute()

* XXX should be deleted; last arg currently ignored.

void

ip_stripoptions(m, mopt)

ip_stripoptions(struct mbuf *m, struct mbuf *mopt)

struct mbuf *m;

struct mbuf *mopt;

{

int i;

struct ip *ip = mtod(m, struct ip *);

Line 1806 const int inetctlerrmap[PRC_NCMDS] = {

Line 1816 const int inetctlerrmap[PRC_NCMDS] = {

* via a source route.

void

ip_forward(m, srcrt)

ip_forward(struct mbuf *m, int srcrt)

struct mbuf *m;

int srcrt;

{

struct ip *ip = mtod(m, struct ip *);

struct sockaddr_in *sin;

Line 2036 ip_forward(m, srcrt)

Line 2044 ip_forward(m, srcrt)

}

void

ip_savecontrol(inp, mp, ip, m)

ip_savecontrol(struct inpcb *inp, struct mbuf **mp, struct ip *ip,

struct inpcb *inp;

struct mbuf *m)

struct mbuf **mp;

struct ip *ip;

struct mbuf *m;

{

if (inp->inp_socket->so_options & SO_TIMESTAMP) {

Line 2133 sysctl_net_inet_ip_maxflows(SYSCTLFN_ARG

Line 2138 sysctl_net_inet_ip_maxflows(SYSCTLFN_ARG

s = sysctl_lookup(SYSCTLFN_CALL(rnode));

if (s)

return (s);

s = splsoftnet();

ipflow_reap(0);

splx(s);

Line 2154 SYSCTL_SETUP(sysctl_net_inet_ip_setup, "

Line 2159 SYSCTL_SETUP(sysctl_net_inet_ip_setup, "

CTL_NET, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT,

CTLTYPE_NODE, "inet", NULL,

CTLTYPE_NODE, "inet",

SYSCTL_DESCR("PF_INET related settings"),

NULL, 0, NULL, 0,

CTL_NET, PF_INET, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT,

CTLTYPE_NODE, "ip", NULL,

CTLTYPE_NODE, "ip",

SYSCTL_DESCR("IPv4 related settings"),

NULL, 0, NULL, 0,

CTL_NET, PF_INET, IPPROTO_IP, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "forwarding", NULL,

CTLTYPE_INT, "forwarding",

SYSCTL_DESCR("Enable forwarding of INET datagrams"),

NULL, 0, &ipforwarding, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_FORWARDING, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "redirect", NULL,

CTLTYPE_INT, "redirect",

SYSCTL_DESCR("Enable sending of ICMP redirect messages"),

NULL, 0, &ipsendredirects, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_SENDREDIRECTS, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "ttl", NULL,

CTLTYPE_INT, "ttl",

SYSCTL_DESCR("Default TTL for an INET datagram"),

NULL, 0, &ip_defttl, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_DEFTTL, CTL_EOL);

#ifdef IPCTL_DEFMTU

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT /* |CTLFLAG_READWRITE? */,

CTLTYPE_INT, "mtu", NULL,

CTLTYPE_INT, "mtu",

SYSCTL_DESCR("Default MTA for an INET route"),

NULL, 0, &ip_mtu, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_DEFMTU, CTL_EOL);

#endif /* IPCTL_DEFMTU */

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READONLY1,

CTLTYPE_INT, "forwsrcrt", NULL,

CTLTYPE_INT, "forwsrcrt",

SYSCTL_DESCR("Enable forwarding of source-routed "

"datagrams"),

NULL, 0, &ip_forwsrcrt, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_FORWSRCRT, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "directed-broadcast", NULL,

CTLTYPE_INT, "directed-broadcast",

SYSCTL_DESCR("Enable forwarding of broadcast datagrams"),

NULL, 0, &ip_directedbcast, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_DIRECTEDBCAST, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "allowsrcrt", NULL,

CTLTYPE_INT, "allowsrcrt",

SYSCTL_DESCR("Accept source-routed datagrams"),

NULL, 0, &ip_allowsrcrt, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_ALLOWSRCRT, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "subnetsarelocal", NULL,

CTLTYPE_INT, "subnetsarelocal",

SYSCTL_DESCR("Whether logical subnets are considered "

"local"),

NULL, 0, &subnetsarelocal, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_SUBNETSARELOCAL, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "mtudisc", NULL,

CTLTYPE_INT, "mtudisc",

SYSCTL_DESCR("Use RFC1191 Path MTU Discovery"),

NULL, 0, &ip_mtudisc, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_MTUDISC, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "anonportmin", NULL,

CTLTYPE_INT, "anonportmin",

SYSCTL_DESCR("Lowest ephemeral port number to assign"),

sysctl_net_inet_ip_ports, 0, &anonportmin, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_ANONPORTMIN, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "anonportmax", NULL,

CTLTYPE_INT, "anonportmax",

SYSCTL_DESCR("Highest ephemeral port number to assign"),

sysctl_net_inet_ip_ports, 0, &anonportmax, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_ANONPORTMAX, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "mtudisctimeout", NULL,

CTLTYPE_INT, "mtudisctimeout",

SYSCTL_DESCR("Lifetime of a Path MTU Discovered route"),

sysctl_net_inet_ip_pmtudto, 0, &ip_mtudisc_timeout, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_MTUDISCTIMEOUT, CTL_EOL);

#ifdef GATEWAY

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "maxflows", NULL,

CTLTYPE_INT, "maxflows",

SYSCTL_DESCR("Number of flows for fast forwarding"),

sysctl_net_inet_ip_maxflows, 0, &ip_maxflows, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_MAXFLOWS, CTL_EOL);

#endif /* GATEWAY */

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "hostzerobroadcast", NULL,

CTLTYPE_INT, "hostzerobroadcast",

SYSCTL_DESCR("All zeroes address is broadcast address"),

NULL, 0, &hostzeroisbroadcast, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_HOSTZEROBROADCAST, CTL_EOL);

#if NGIF > 0

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "gifttl", NULL,

CTLTYPE_INT, "gifttl",

SYSCTL_DESCR("Default TTL for a gif tunnel datagram"),

NULL, 0, &ip_gif_ttl, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_GIF_TTL, CTL_EOL);

Line 2262 SYSCTL_SETUP(sysctl_net_inet_ip_setup, "

Line 2286 SYSCTL_SETUP(sysctl_net_inet_ip_setup, "

#ifndef IPNOPRIVPORTS

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "lowportmin", NULL,

CTLTYPE_INT, "lowportmin",

SYSCTL_DESCR("Lowest privileged ephemeral port number "

"to assign"),

sysctl_net_inet_ip_ports, 0, &lowportmin, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_LOWPORTMIN, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "lowportmax", NULL,

CTLTYPE_INT, "lowportmax",

SYSCTL_DESCR("Highest privileged ephemeral port number "

"to assign"),

sysctl_net_inet_ip_ports, 0, &lowportmax, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_LOWPORTMAX, CTL_EOL);

#endif /* IPNOPRIVPORTS */

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "maxfragpackets", NULL,

CTLTYPE_INT, "maxfragpackets",

SYSCTL_DESCR("Maximum number of fragments to retain for "

"possible reassembly"),

NULL, 0, &ip_maxfragpackets, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_MAXFRAGPACKETS, CTL_EOL);

#if NGRE > 0

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "grettl", NULL,

CTLTYPE_INT, "grettl",

SYSCTL_DESCR("Default TTL for a gre tunnel datagram"),

NULL, 0, &ip_gre_ttl, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_GRE_TTL, CTL_EOL);

#endif /* NGRE */

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "checkinterface", NULL,

CTLTYPE_INT, "checkinterface",

SYSCTL_DESCR("Enable receive side of Strong ES model "

"from RFC1122"),

NULL, 0, &ip_checkinterface, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_CHECKINTERFACE, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "random_id", NULL,

CTLTYPE_INT, "random_id",

SYSCTL_DESCR("Assign random ip_id values"),

NULL, 0, &ip_do_randomid, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_RANDOMID, CTL_EOL);

sysctl_createv(clog, 0, NULL, NULL,

CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

CTLTYPE_INT, "do_loopback_cksum",

SYSCTL_DESCR("Perform IP checksum on loopback"),

NULL, 0, &ip_do_loopback_cksum, 0,

CTL_NET, PF_INET, IPPROTO_IP,

IPCTL_LOOPBACKCKSUM, CTL_EOL);

}

CVSweb <webmaster@jp.NetBSD.org>