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.200 and 1.218

version 1.200, 2004/04/25 16:42:42

version 1.218, 2005/06/28 19:38:58

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

#include <netinet/in_systm.h>

#include <netinet/ip.h>

#include <netinet/in_pcb.h>

#include <netinet/in_proto.h>

#include <netinet/in_var.h>

#include <netinet/ip_var.h>

#include <netinet/ip_icmp.h>

Line 222 struct rttimer_queue *ip_mtudisc_timeout

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

Line 241 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 { \

Line 257 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

Line 267 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

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

Line 302 ipq_lock_try()

}

static __inline void

ipq_unlock()

ipq_unlock(void)

{

int s;

Line 347 struct evcnt ip_swcsum = EVCNT_INITIALIZ

Line 348 struct evcnt ip_swcsum = EVCNT_INITIALIZ

#define INET_CSUM_COUNTER_INCR(ev) (ev)->ev_count++

EVCNT_ATTACH_STATIC(ip_hwcsum_bad);

EVCNT_ATTACH_STATIC(ip_hwcsum_ok);

EVCNT_ATTACH_STATIC(ip_swcsum);

#else

#define INET_CSUM_COUNTER_INCR(ev) /* nothing */

Line 368 static struct ip_srcrt {

Line 373 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 390 ip_nmbclusters_changed(void)

Line 395 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 434 ip_init()

Line 439 ip_init()

"error %d\n", i);

#endif /* PFIL_HOOKS */

#ifdef INET_CSUM_COUNTERS

evcnt_attach_static(&ip_hwcsum_bad);

evcnt_attach_static(&ip_hwcsum_ok);

evcnt_attach_static(&ip_swcsum);

#endif /* INET_CSUM_COUNTERS */

#ifdef MBUFTRACE

MOWNER_ATTACH(&ip_tx_mowner);

MOWNER_ATTACH(&ip_rx_mowner);

Line 453 struct route ipforward_rt;

Line 452 struct route ipforward_rt;

* IP software interrupt routine

void

ipintr()

ipintr(void)

{

int s;

struct mbuf *m;

Line 574 ip_input(struct mbuf *m)

Line 573 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 651 ip_input(struct mbuf *m)

Line 656 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 714 ip_input(struct mbuf *m)

Line 733 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 740 ip_input(struct mbuf *m)

Line 759 ip_input(struct mbuf *m)

#ifdef MROUTING

extern struct socket *ip_mrouter;

if (M_READONLY(m)) {

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

ipstat.ips_toosmall++;

return;

}

ip = mtod(m, struct ip *);

}

if (ip_mrouter) {

* If we are acting as a multicast router, all

Line 825 ip_input(struct mbuf *m)

Line 836 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 879 ours:

Line 890 ours:

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

if (ip->ip_off & ~htons(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

Line 982 found:

Line 986 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 990 found:

Line 994 found:

sp = ipsec_getpolicy(tdbi, IPSEC_DIR_INBOUND);

} else {

sp = ipsec_getpolicybyaddr(m, IPSEC_DIR_INBOUND,

IP_FORWARDING, &error);

}

if (sp != NULL) {

Line 1040 badcsum:

Line 1044 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 1074 ip_reass(ipqe, fp, ipqhead)

Line 1075 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 1225 insert:

Line 1226 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 1243 dropfrag:

Line 1245 dropfrag:

* associated datagrams.

void

ip_freef(fp)

ip_freef(struct ipq *fp)

struct ipq *fp;

{

struct ipqent *q, *p;

u_int nfrags = 0;

Line 1285 ip_reass_ttl_decr(u_int ticks)

Line 1286 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 1341 ip_reass_drophalf(void)

Line 1342 ip_reass_drophalf(void)

* queue, discard it.

void

ip_slowtimo()

ip_slowtimo(void)

{

static u_int dropscanidx = 0;

u_int i;

Line 1398 ip_slowtimo()

Line 1399 ip_slowtimo()

* Drain off all datagram fragments.

void

ip_drain()

ip_drain(void)

{

Line 1425 ip_drain()

Line 1426 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 1655 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 1683 ip_rtaddr(dst)

Line 1682 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 1707 save_rte(option, dst)

Line 1704 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 1779 ip_srcroute()

Line 1776 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 1823 const int inetctlerrmap[PRC_NCMDS] = {

Line 1818 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 1879 ip_forward(m, srcrt)

Line 1872 ip_forward(m, srcrt)

rtalloc(&ipforward_rt);

if (ipforward_rt.ro_rt == 0) {

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

icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_NET, dest, 0);

return;

}

rt = ipforward_rt.ro_rt;

Line 2053 ip_forward(m, srcrt)

Line 2046 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 2150 sysctl_net_inet_ip_maxflows(SYSCTLFN_ARG

Line 2140 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 2171 SYSCTL_SETUP(sysctl_net_inet_ip_setup, "

Line 2161 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 2279 SYSCTL_SETUP(sysctl_net_inet_ip_setup, "

Line 2288 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>