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.1 and 1.23

version 1.1, 1993/03/21 09:45:37

version 1.23, 1995/06/12 06:46:36

Line 1

/* $NetBSD$ */

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

* modification, are permitted provided that the following conditions

Line 30

Line 32

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

* @(#)ip_input.c 7.19 (Berkeley) 5/25/91

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

#include "param.h"

#include <sys/param.h>

#include "systm.h"

#include <sys/systm.h>

#include "malloc.h"

#include <sys/malloc.h>

#include "mbuf.h"

#include <sys/mbuf.h>

#include "domain.h"

#include <sys/domain.h>

#include "protosw.h"

#include <sys/protosw.h>

#include "socket.h"

#include <sys/socket.h>

#include "errno.h"

#include <sys/errno.h>

#include "time.h"

#include <sys/time.h>

#include "kernel.h"

#include <sys/kernel.h>

#include "../net/if.h"

#include <net/if.h>

#include "../net/route.h"

#include <net/route.h>

#include "in.h"

#include <netinet/in.h>

#include "in_systm.h"

#include <netinet/in_systm.h>

#include "ip.h"

#include <netinet/ip.h>

#include "in_pcb.h"

#include <netinet/in_pcb.h>

#include "in_var.h"

#include <netinet/in_var.h>

#include "ip_var.h"

#include <netinet/ip_var.h>

#include "ip_icmp.h"

#include <netinet/ip_icmp.h>

#ifndef IPFORWARDING

#ifdef GATEWAY

Line 67

Line 69

#endif

int ipforwarding = IPFORWARDING;

int ipsendredirects = IPSENDREDIRECTS;

int ip_defttl = IPDEFTTL;

#ifdef DIAGNOSTIC

int ipprintfs = 0;

#endif

Line 75 extern struct domain inetdomain;

Line 78 extern struct domain inetdomain;

extern struct protosw inetsw[];

u_char ip_protox[IPPROTO_MAX];

int ipqmaxlen = IFQ_MAXLEN;

struct in_ifaddr *in_ifaddr; /* first inet address */

struct in_ifaddrhead in_ifaddr;

struct ifqueue ipintrq;

* We need to save the IP options in case a protocol wants to respond

Line 92 static struct ip_srcrt {

Line 96 static struct ip_srcrt {

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

} ip_srcrt;

#ifdef GATEWAY

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

extern int if_index;

u_long *ip_ifmatrix;

#endif

* IP initialization: fill in IP protocol switch table.

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

void

ip_init()

{

Line 119 ip_init()

Line 120 ip_init()

ipq.next = ipq.prev = &ipq;

ip_id = time.tv_sec & 0xffff;

ipintrq.ifq_maxlen = ipqmaxlen;

#ifdef GATEWAY

TAILQ_INIT(&in_ifaddr);

i = (if_index + 1) * (if_index + 1) * sizeof (u_long);

if ((ip_ifmatrix = (u_long *) malloc(i, M_RTABLE, M_WAITOK)) == 0)

panic("no memory for ip_ifmatrix");

#endif

}

struct ip *ip_reass();

struct sockaddr_in ipaddr = { sizeof(ipaddr), AF_INET };

struct route ipforward_rt;

Line 134 struct route ipforward_rt;

Line 130 struct route ipforward_rt;

* Ip input routine. Checksum and byte swap header. If fragmented

* try to reassemble. Process options. Pass to next level.

void

ipintr()

{

Line 160 next:

Line 157 next:

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

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

if (in_ifaddr == NULL)

if (in_ifaddr.tqh_first == 0)

goto bad;

ipstat.ips_total++;

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

Line 169 next:

Line 166 next:

goto next;

}

ip = mtod(m, struct ip *);

if (ip->ip_v != IPVERSION) {

ipstat.ips_badvers++;

goto bad;

}

hlen = ip->ip_hl << 2;

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

ipstat.ips_badhlen++;

Line 228 next:

Line 229 next:

* Check our list of addresses, to see if the packet is for us.

for (ia = in_ifaddr; ia; ia = ia->ia_next) {

for (ia = in_ifaddr.tqh_first; ia; ia = ia->ia_list.tqe_next) {

#define satosin(sa) ((struct sockaddr_in *)(sa))

if (ip->ip_dst.s_addr == ia->ia_addr.sin_addr.s_addr)

if (IA_SIN(ia)->sin_addr.s_addr == ip->ip_dst.s_addr)

goto ours;

if (

#ifdef DIRECTED_BROADCAST

ia->ia_ifp == m->m_pkthdr.rcvif &&

#endif

(ia->ia_ifp->if_flags & IFF_BROADCAST)) {

u_long t;

if (ip->ip_dst.s_addr == ia->ia_broadaddr.sin_addr.s_addr ||

ip->ip_dst.s_addr == ia->ia_netbroadcast.s_addr ||

if (satosin(&ia->ia_broadaddr)->sin_addr.s_addr ==

ip->ip_dst.s_addr)

* Look for all-0's host part (old broadcast addr),

goto ours;

* either for subnet or net.

if (ip->ip_dst.s_addr == ia->ia_netbroadcast.s_addr)

ip->ip_dst.s_addr == ia->ia_subnet ||

ip->ip_dst.s_addr == ia->ia_net)

goto ours;

}

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

struct in_multi *inm;

#ifdef MROUTING

extern struct socket *ip_mrouter;

if (m->m_flags & M_EXT) {

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

ipstat.ips_toosmall++;

goto next;

}

ip = mtod(m, struct ip *);

}

if (ip_mrouter) {

* Look for all-0's host part (old broadcast addr),

* If we are acting as a multicast router, all

* either for subnet or net.

* incoming multicast packets are passed to the

* kernel-level multicast forwarding function.

* The packet is returned (relatively) intact; if

* ip_mforward() returns a non-zero value, the packet

* must be discarded, else it may be accepted below.

* (The IP ident field is put in the same byte order

* as expected when ip_mforward() is called from

* ip_output().)

t = ntohl(ip->ip_dst.s_addr);

ip->ip_id = htons(ip->ip_id);

if (t == ia->ia_subnet)

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

goto ours;

ipstat.ips_cantforward++;

if (t == ia->ia_net)

m_freem(m);

goto next;

}

ip->ip_id = ntohs(ip->ip_id);

* The process-level routing demon needs to receive

* all multicast IGMP packets, whether or not this

* host belongs to their destination groups.

if (ip->ip_p == IPPROTO_IGMP)

goto ours;

ipstat.ips_forward++;

}

#endif

* See if we belong to the destination multicast group on the

* arrival interface.

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

if (inm == NULL) {

ipstat.ips_cantforward++;

m_freem(m);

goto next;

}

if (ip->ip_dst.s_addr == (u_long)INADDR_BROADCAST)

goto ours;

if (ip->ip_dst.s_addr == INADDR_ANY)

}

if (ip->ip_dst.s_addr == INADDR_BROADCAST ||

ip->ip_dst.s_addr == INADDR_ANY)

goto ours;

Line 306 found:

Line 353 found:

* convert offset of this to bytes.

ip->ip_len -= hlen;

((struct ipasfrag *)ip)->ipf_mff = 0;

((struct ipasfrag *)ip)->ipf_mff &= ~1;

if (ip->ip_off & IP_MF)

if (ip->ip_off & IP_MF) {

((struct ipasfrag *)ip)->ipf_mff = 1;

* Make sure that fragments have a data length

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

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

ipstat.ips_badfrags++;

goto bad;

}

((struct ipasfrag *)ip)->ipf_mff |= 1;

}

ip->ip_off <<= 3;

Line 316 found:

Line 372 found:

* or if this is not the first fragment,

* attempt reassembly; if it succeeds, proceed.

if (((struct ipasfrag *)ip)->ipf_mff || ip->ip_off) {

if (((struct ipasfrag *)ip)->ipf_mff & 1 || ip->ip_off) {

ipstat.ips_fragments++;

ip = ip_reass((struct ipasfrag *)ip, fp);

if (ip == 0)

goto next;

else

ipstat.ips_reassembled++;

m = dtom(ip);

} else

if (fp)

Line 435 insert:

Line 490 insert:

return (0);

next += q->ip_len;

}

if (q->ipf_prev->ipf_mff)

if (q->ipf_prev->ipf_mff & 1)

return (0);

Line 461 insert:

Line 516 insert:

ip = fp->ipq_next;

ip->ip_len = next;

ip->ipf_mff &= ~1;

((struct ip *)ip)->ip_src = fp->ipq_src;

((struct ip *)ip)->ip_dst = fp->ipq_dst;

remque(fp);

Line 487 dropfrag:

Line 543 dropfrag:

* Free a fragment reassembly header and all

* associated datagrams.

void

ip_freef(fp)

struct ipq *fp;

{

Line 505 ip_freef(fp)

Line 562 ip_freef(fp)

* Put an ip fragment on a reassembly chain.

* Like insque, but pointers in middle of structure.

void

ip_enq(p, prev)

{

Line 518 ip_enq(p, prev)

Line 576 ip_enq(p, prev)

* To ip_enq as remque is to insque.

void

ip_deq(p)

{

Line 531 ip_deq(p)

Line 590 ip_deq(p)

* if a timer expires on a reassembly

* queue, discard it.

void

ip_slowtimo()

{

Line 555 ip_slowtimo()

Line 615 ip_slowtimo()

* Drain off all datagram fragments.

void

ip_drain()

{

Line 564 ip_drain()

Line 625 ip_drain()

}

extern struct in_ifaddr *ifptoia();

struct in_ifaddr *ip_rtaddr();

* Do option processing on a datagram,

* possibly discarding it if bad options are encountered,

Line 574 struct in_ifaddr *ip_rtaddr();

Line 632 struct in_ifaddr *ip_rtaddr();

* Returns 1 if packet has been forwarded/freed,

* 0 if the packet should be processed further.

int

ip_dooptions(m)

struct mbuf *m;

{

Line 582 ip_dooptions(m)

Line 641 ip_dooptions(m)

int opt, optlen, cnt, off, code, type = ICMP_PARAMPROB, forward = 0;

struct in_addr *sin;

struct in_addr *sin, dst;

n_time ntime;

dst = ip->ip_dst;

cp = (u_char *)(ip + 1);

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

for (; cnt > 0; cnt -= optlen, cp += optlen) {

Line 621 ip_dooptions(m)

Line 681 ip_dooptions(m)

goto bad;

}

ipaddr.sin_addr = ip->ip_dst;

ia = (struct in_ifaddr *)

ia = ifatoia(ifa_ifwithaddr(sintosa(&ipaddr)));

ifa_ifwithaddr((struct sockaddr *)&ipaddr);

if (ia == 0) {

if (opt == IPOPT_SSRR) {

type = ICMP_UNREACH;

Line 652 ip_dooptions(m)

Line 711 ip_dooptions(m)

#define INA struct in_ifaddr *

#define SA struct sockaddr *

if ((ia = (INA)ifa_ifwithdstaddr((SA)&ipaddr)) == 0)

ia = in_iaonnetof(in_netof(ipaddr.sin_addr));

ia = (INA)ifa_ifwithnet((SA)&ipaddr);

} else

ia = ip_rtaddr(ipaddr.sin_addr);

if (ia == 0) {

Line 661 ip_dooptions(m)

Line 720 ip_dooptions(m)

goto bad;

}

ip->ip_dst = ipaddr.sin_addr;

bcopy((caddr_t)&(IA_SIN(ia)->sin_addr),

bcopy((caddr_t)&ia->ia_addr.sin_addr,

(caddr_t)(cp + off), sizeof(struct in_addr));

cp[IPOPT_OFFSET] += sizeof(struct in_addr);

forward = 1;

* Let ip_intr's mcast routing check handle mcast pkts

forward = !IN_MULTICAST(ip->ip_dst.s_addr);

break;

case IPOPT_RR:

Line 690 ip_dooptions(m)

Line 752 ip_dooptions(m)

code = ICMP_UNREACH_HOST;

goto bad;

}

bcopy((caddr_t)&(IA_SIN(ia)->sin_addr),

bcopy((caddr_t)&ia->ia_addr.sin_addr,

(caddr_t)(cp + off), sizeof(struct in_addr));

cp[IPOPT_OFFSET] += sizeof(struct in_addr);

break;

Line 700 ip_dooptions(m)

Line 762 ip_dooptions(m)

ipt = (struct ip_timestamp *)cp;

if (ipt->ipt_len < 5)

goto bad;

if (ipt->ipt_ptr > ipt->ipt_len - sizeof (long)) {

if (ipt->ipt_ptr > ipt->ipt_len - sizeof (int32_t)) {

if (++ipt->ipt_oflw == 0)

goto bad;

break;

Line 715 ip_dooptions(m)

Line 777 ip_dooptions(m)

if (ipt->ipt_ptr + sizeof(n_time) +

sizeof(struct in_addr) > ipt->ipt_len)

goto bad;

ia = ifptoia(m->m_pkthdr.rcvif);

ipaddr.sin_addr = dst;

bcopy((caddr_t)&IA_SIN(ia)->sin_addr,

ia = (INA)ifaof_ifpforaddr((SA)&ipaddr,

m->m_pkthdr.rcvif);

if (ia == 0)

continue;

bcopy((caddr_t)&ia->ia_addr.sin_addr,

(caddr_t)sin, sizeof(struct in_addr));

ipt->ipt_ptr += sizeof(struct in_addr);

break;

Line 744 ip_dooptions(m)

Line 810 ip_dooptions(m)

if (forward) {

ip_forward(m, 1);

return (1);

} else

}

return (0);

bad:

icmp_error(m, type, code);

ip->ip_len -= ip->ip_hl << 2; /* XXX icmp_error adds in hdr length */

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

ipstat.ips_badoptions++;

return (1);

}

Line 761 ip_rtaddr(dst)

Line 829 ip_rtaddr(dst)

{

sin = (struct sockaddr_in *) &ipforward_rt.ro_dst;

sin = satosin(&ipforward_rt.ro_dst);

if (ipforward_rt.ro_rt == 0 || dst.s_addr != sin->sin_addr.s_addr) {

if (ipforward_rt.ro_rt) {

Line 776 ip_rtaddr(dst)

Line 844 ip_rtaddr(dst)

}

if (ipforward_rt.ro_rt == 0)

return ((struct in_ifaddr *)0);

return ((struct in_ifaddr *) ipforward_rt.ro_rt->rt_ifa);

return (ifatoia(ipforward_rt.ro_rt->rt_ifa));

}

* Save incoming source route for use in replies,

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

void

save_rte(option, dst)

u_char *option;

struct in_addr dst;

Line 877 ip_srcroute()

Line 946 ip_srcroute()

* will be moved, and return value is their length.

* XXX should be deleted; last arg currently ignored.

void

ip_stripoptions(m, mopt)

struct mbuf *mopt;

Line 896 ip_stripoptions(m, mopt)

Line 966 ip_stripoptions(m, mopt)

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

}

u_char inetctlerrmap[PRC_NCMDS] = {

int inetctlerrmap[PRC_NCMDS] = {

0, 0, 0, 0,

0, EMSGSIZE, EHOSTDOWN, EHOSTUNREACH,

EHOSTUNREACH, EHOSTUNREACH, ECONNREFUSED, ECONNREFUSED,

Line 919 u_char inetctlerrmap[PRC_NCMDS] = {

Line 989 u_char inetctlerrmap[PRC_NCMDS] = {

* The srcrt parameter indicates whether the packet is being forwarded

* via a source route.

void

ip_forward(m, srcrt)

struct mbuf *m;

int srcrt;

Line 928 ip_forward(m, srcrt)

Line 999 ip_forward(m, srcrt)

int error, type = 0, code;

struct mbuf *mcopy;

struct in_addr dest;

n_long dest;

struct ifnet *destifp;

dest.s_addr = 0;

dest = 0;

#ifdef DIAGNOSTIC

if (ipprintfs)

printf("forward: src %x dst %x ttl %x\n", ip->ip_src,

Line 943 ip_forward(m, srcrt)

Line 1015 ip_forward(m, srcrt)

}

HTONS(ip->ip_id);

if (ip->ip_ttl <= IPTTLDEC) {

icmp_error(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, dest);

icmp_error(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, dest, 0);

return;

}

ip->ip_ttl -= IPTTLDEC;

sin = (struct sockaddr_in *)&ipforward_rt.ro_dst;

sin = satosin(&ipforward_rt.ro_dst);

if ((rt = ipforward_rt.ro_rt) == 0 ||

ip->ip_dst.s_addr != sin->sin_addr.s_addr) {

if (ipforward_rt.ro_rt) {

Line 961 ip_forward(m, srcrt)

Line 1033 ip_forward(m, srcrt)

rtalloc(&ipforward_rt);

if (ipforward_rt.ro_rt == 0) {

icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, dest);

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

return;

}

rt = ipforward_rt.ro_rt;

Line 973 ip_forward(m, srcrt)

Line 1045 ip_forward(m, srcrt)

mcopy = m_copy(m, 0, imin((int)ip->ip_len, 64));

#ifdef GATEWAY

ip_ifmatrix[rt->rt_ifp->if_index +

if_index * m->m_pkthdr.rcvif->if_index]++;

#endif

* If forwarding packet using same interface that it came in on,

* perhaps should send a redirect to sender to shortcut a hop.

Line 985 ip_forward(m, srcrt)

Line 1053 ip_forward(m, srcrt)

* Also, don't send redirect if forwarding using a default route

* or a route modified by a redirect.

#define satosin(sa) ((struct sockaddr_in *)(sa))

if (rt->rt_ifp == m->m_pkthdr.rcvif &&

(rt->rt_flags & (RTF_DYNAMIC|RTF_MODIFIED)) == 0 &&

satosin(rt_key(rt))->sin_addr.s_addr != 0 &&

ipsendredirects && !srcrt) {

struct in_ifaddr *ia;

if (rt->rt_ifa &&

u_long src = ntohl(ip->ip_src.s_addr);

(ip->ip_src.s_addr & ifatoia(rt->rt_ifa)->ia_subnetmask) ==

u_long dst = ntohl(ip->ip_dst.s_addr);

ifatoia(rt->rt_ifa)->ia_subnet) {

if ((ia = ifptoia(m->m_pkthdr.rcvif)) &&

(src & ia->ia_subnetmask) == ia->ia_subnet) {

if (rt->rt_flags & RTF_GATEWAY)

dest = satosin(rt->rt_gateway)->sin_addr;

dest = satosin(rt->rt_gateway)->sin_addr.s_addr;

else

dest = ip->ip_dst;

dest = ip->ip_dst.s_addr;

/* Router requirements says to only send host redirects */

* If the destination is reached by a route to host,

* is on a subnet of a local net, or is directly

* on the attached net (!), use host redirect.

* (We may be the correct first hop for other subnets.)

#define RTA(rt) ((struct in_ifaddr *)(rt->rt_ifa))

type = ICMP_REDIRECT;

if ((rt->rt_flags & RTF_HOST) ||

code = ICMP_REDIRECT_HOST;

(rt->rt_flags & RTF_GATEWAY) == 0)

code = ICMP_REDIRECT_HOST;

else if (RTA(rt)->ia_subnetmask != RTA(rt)->ia_netmask &&

(dst & RTA(rt)->ia_netmask) == RTA(rt)->ia_net)

code = ICMP_REDIRECT_HOST;

else

code = ICMP_REDIRECT_NET;

#ifdef DIAGNOSTIC

if (ipprintfs)

printf("redirect (%d) to %x\n", code, dest.s_addr);

printf("redirect (%d) to %lx\n", code, (u_int32_t)dest);

#endif

}

error = ip_output(m, (struct mbuf *)0, &ipforward_rt, IP_FORWARDING);

error = ip_output(m, (struct mbuf *)0, &ipforward_rt, IP_FORWARDING

#ifdef DIRECTED_BROADCAST

| IP_ALLOWBROADCAST

#endif

, 0);

if (error)

ipstat.ips_cantforward++;

else {

Line 1038 ip_forward(m, srcrt)

Line 1093 ip_forward(m, srcrt)

}

if (mcopy == NULL)

return;

destifp = NULL;

switch (error) {

case 0: /* forwarded, but need redirect */

Line 1056 ip_forward(m, srcrt)

Line 1113 ip_forward(m, srcrt)

case EMSGSIZE:

type = ICMP_UNREACH;

code = ICMP_UNREACH_NEEDFRAG;

if (ipforward_rt.ro_rt)

destifp = ipforward_rt.ro_rt->rt_ifp;

ipstat.ips_cantfrag++;

break;

Line 1064 ip_forward(m, srcrt)

Line 1123 ip_forward(m, srcrt)

code = 0;

break;

}

icmp_error(mcopy, type, code, dest);

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

}

int

ip_sysctl(name, namelen, oldp, oldlenp, newp, newlen)

int *name;

u_int namelen;

void *oldp;

size_t *oldlenp;

void *newp;

size_t newlen;

{

/* All sysctl names at this level are terminal. */

if (namelen != 1)

return (ENOTDIR);

switch (name[0]) {

case IPCTL_FORWARDING:

return (sysctl_int(oldp, oldlenp, newp, newlen, &ipforwarding));

case IPCTL_SENDREDIRECTS:

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

&ipsendredirects));

case IPCTL_DEFTTL:

return (sysctl_int(oldp, oldlenp, newp, newlen, &ip_defttl));

#ifdef notyet

case IPCTL_DEFMTU:

return (sysctl_int(oldp, oldlenp, newp, newlen, &ip_mtu));

#endif

default:

return (EOPNOTSUPP);

}

/* NOTREACHED */

}

CVSweb <webmaster@jp.NetBSD.org>