Home | History | Annotate | Line # | Download | only in netinet
ip_input.c revision 1.109
      1 /*	$NetBSD: ip_input.c,v 1.109 2000/03/30 13:24:59 augustss Exp $	*/
      2 
      3 /*
      4  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. Neither the name of the project nor the names of its contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
     20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
     23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  */
     31 
     32 /*-
     33  * Copyright (c) 1998 The NetBSD Foundation, Inc.
     34  * All rights reserved.
     35  *
     36  * This code is derived from software contributed to The NetBSD Foundation
     37  * by Public Access Networks Corporation ("Panix").  It was developed under
     38  * contract to Panix by Eric Haszlakiewicz and Thor Lancelot Simon.
     39  *
     40  * Redistribution and use in source and binary forms, with or without
     41  * modification, are permitted provided that the following conditions
     42  * are met:
     43  * 1. Redistributions of source code must retain the above copyright
     44  *    notice, this list of conditions and the following disclaimer.
     45  * 2. Redistributions in binary form must reproduce the above copyright
     46  *    notice, this list of conditions and the following disclaimer in the
     47  *    documentation and/or other materials provided with the distribution.
     48  * 3. All advertising materials mentioning features or use of this software
     49  *    must display the following acknowledgement:
     50  *	This product includes software developed by the NetBSD
     51  *	Foundation, Inc. and its contributors.
     52  * 4. Neither the name of The NetBSD Foundation nor the names of its
     53  *    contributors may be used to endorse or promote products derived
     54  *    from this software without specific prior written permission.
     55  *
     56  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     57  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     58  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     59  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     60  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     61  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     62  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     63  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     64  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     65  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     66  * POSSIBILITY OF SUCH DAMAGE.
     67  */
     68 
     69 /*
     70  * Copyright (c) 1982, 1986, 1988, 1993
     71  *	The Regents of the University of California.  All rights reserved.
     72  *
     73  * Redistribution and use in source and binary forms, with or without
     74  * modification, are permitted provided that the following conditions
     75  * are met:
     76  * 1. Redistributions of source code must retain the above copyright
     77  *    notice, this list of conditions and the following disclaimer.
     78  * 2. Redistributions in binary form must reproduce the above copyright
     79  *    notice, this list of conditions and the following disclaimer in the
     80  *    documentation and/or other materials provided with the distribution.
     81  * 3. All advertising materials mentioning features or use of this software
     82  *    must display the following acknowledgement:
     83  *	This product includes software developed by the University of
     84  *	California, Berkeley and its contributors.
     85  * 4. Neither the name of the University nor the names of its contributors
     86  *    may be used to endorse or promote products derived from this software
     87  *    without specific prior written permission.
     88  *
     89  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     90  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     91  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     92  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     93  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     94  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     95  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     96  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     97  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     98  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     99  * SUCH DAMAGE.
    100  *
    101  *	@(#)ip_input.c	8.2 (Berkeley) 1/4/94
    102  */
    103 
    104 #include "opt_gateway.h"
    105 #include "opt_pfil_hooks.h"
    106 #include "opt_ipsec.h"
    107 #include "opt_mrouting.h"
    108 
    109 #include <sys/param.h>
    110 #include <sys/systm.h>
    111 #include <sys/malloc.h>
    112 #include <sys/mbuf.h>
    113 #include <sys/domain.h>
    114 #include <sys/protosw.h>
    115 #include <sys/socket.h>
    116 #include <sys/socketvar.h>
    117 #include <sys/errno.h>
    118 #include <sys/time.h>
    119 #include <sys/kernel.h>
    120 #include <sys/proc.h>
    121 #include <sys/pool.h>
    122 
    123 #include <vm/vm.h>
    124 #include <sys/sysctl.h>
    125 
    126 #include <net/if.h>
    127 #include <net/if_dl.h>
    128 #include <net/route.h>
    129 #include <net/pfil.h>
    130 
    131 #include <netinet/in.h>
    132 #include <netinet/in_systm.h>
    133 #include <netinet/ip.h>
    134 #include <netinet/in_pcb.h>
    135 #include <netinet/in_var.h>
    136 #include <netinet/ip_var.h>
    137 #include <netinet/ip_icmp.h>
    138 /* just for gif_ttl */
    139 #include <netinet/in_gif.h>
    140 #include "gif.h"
    141 
    142 #ifdef IPSEC
    143 #include <netinet6/ipsec.h>
    144 #include <netkey/key.h>
    145 #include <netkey/key_debug.h>
    146 #endif
    147 
    148 #ifndef	IPFORWARDING
    149 #ifdef GATEWAY
    150 #define	IPFORWARDING	1	/* forward IP packets not for us */
    151 #else /* GATEWAY */
    152 #define	IPFORWARDING	0	/* don't forward IP packets not for us */
    153 #endif /* GATEWAY */
    154 #endif /* IPFORWARDING */
    155 #ifndef	IPSENDREDIRECTS
    156 #define	IPSENDREDIRECTS	1
    157 #endif
    158 #ifndef IPFORWSRCRT
    159 #define	IPFORWSRCRT	1	/* forward source-routed packets */
    160 #endif
    161 #ifndef IPALLOWSRCRT
    162 #define	IPALLOWSRCRT	1	/* allow source-routed packets */
    163 #endif
    164 #ifndef IPMTUDISC
    165 #define IPMTUDISC	0
    166 #endif
    167 #ifndef IPMTUDISCTIMEOUT
    168 #define IPMTUDISCTIMEOUT (10 * 60)	/* as per RFC 1191 */
    169 #endif
    170 
    171 /*
    172  * Note: DIRECTED_BROADCAST is handled this way so that previous
    173  * configuration using this option will Just Work.
    174  */
    175 #ifndef IPDIRECTEDBCAST
    176 #ifdef DIRECTED_BROADCAST
    177 #define IPDIRECTEDBCAST	1
    178 #else
    179 #define	IPDIRECTEDBCAST	0
    180 #endif /* DIRECTED_BROADCAST */
    181 #endif /* IPDIRECTEDBCAST */
    182 int	ipforwarding = IPFORWARDING;
    183 int	ipsendredirects = IPSENDREDIRECTS;
    184 int	ip_defttl = IPDEFTTL;
    185 int	ip_forwsrcrt = IPFORWSRCRT;
    186 int	ip_directedbcast = IPDIRECTEDBCAST;
    187 int	ip_allowsrcrt = IPALLOWSRCRT;
    188 int	ip_mtudisc = IPMTUDISC;
    189 u_int	ip_mtudisc_timeout = IPMTUDISCTIMEOUT;
    190 #ifdef DIAGNOSTIC
    191 int	ipprintfs = 0;
    192 #endif
    193 
    194 struct rttimer_queue *ip_mtudisc_timeout_q = NULL;
    195 
    196 extern	struct domain inetdomain;
    197 int	ipqmaxlen = IFQ_MAXLEN;
    198 struct	in_ifaddrhead in_ifaddr;
    199 struct	in_ifaddrhashhead *in_ifaddrhashtbl;
    200 struct	ifqueue ipintrq;
    201 struct	ipstat	ipstat;
    202 u_int16_t	ip_id;
    203 
    204 struct ipqhead ipq;
    205 int	ipq_locked;
    206 
    207 static __inline int ipq_lock_try __P((void));
    208 static __inline void ipq_unlock __P((void));
    209 
    210 static __inline int
    211 ipq_lock_try()
    212 {
    213 	int s;
    214 
    215 	s = splimp();
    216 	if (ipq_locked) {
    217 		splx(s);
    218 		return (0);
    219 	}
    220 	ipq_locked = 1;
    221 	splx(s);
    222 	return (1);
    223 }
    224 
    225 static __inline void
    226 ipq_unlock()
    227 {
    228 	int s;
    229 
    230 	s = splimp();
    231 	ipq_locked = 0;
    232 	splx(s);
    233 }
    234 
    235 #ifdef DIAGNOSTIC
    236 #define	IPQ_LOCK()							\
    237 do {									\
    238 	if (ipq_lock_try() == 0) {					\
    239 		printf("%s:%d: ipq already locked\n", __FILE__, __LINE__); \
    240 		panic("ipq_lock");					\
    241 	}								\
    242 } while (0)
    243 #define	IPQ_LOCK_CHECK()						\
    244 do {									\
    245 	if (ipq_locked == 0) {						\
    246 		printf("%s:%d: ipq lock not held\n", __FILE__, __LINE__); \
    247 		panic("ipq lock check");				\
    248 	}								\
    249 } while (0)
    250 #else
    251 #define	IPQ_LOCK()		(void) ipq_lock_try()
    252 #define	IPQ_LOCK_CHECK()	/* nothing */
    253 #endif
    254 
    255 #define	IPQ_UNLOCK()		ipq_unlock()
    256 
    257 struct pool ipqent_pool;
    258 
    259 /*
    260  * We need to save the IP options in case a protocol wants to respond
    261  * to an incoming packet over the same route if the packet got here
    262  * using IP source routing.  This allows connection establishment and
    263  * maintenance when the remote end is on a network that is not known
    264  * to us.
    265  */
    266 int	ip_nhops = 0;
    267 static	struct ip_srcrt {
    268 	struct	in_addr dst;			/* final destination */
    269 	char	nop;				/* one NOP to align */
    270 	char	srcopt[IPOPT_OFFSET + 1];	/* OPTVAL, OLEN and OFFSET */
    271 	struct	in_addr route[MAX_IPOPTLEN/sizeof(struct in_addr)];
    272 } ip_srcrt;
    273 
    274 static void save_rte __P((u_char *, struct in_addr));
    275 
    276 /*
    277  * IP initialization: fill in IP protocol switch table.
    278  * All protocols not implemented in kernel go to raw IP protocol handler.
    279  */
    280 void
    281 ip_init()
    282 {
    283 	struct protosw *pr;
    284 	int i;
    285 
    286 	pool_init(&ipqent_pool, sizeof(struct ipqent), 0, 0, 0, "ipqepl",
    287 	    0, NULL, NULL, M_IPQ);
    288 
    289 	pr = pffindproto(PF_INET, IPPROTO_RAW, SOCK_RAW);
    290 	if (pr == 0)
    291 		panic("ip_init");
    292 	for (i = 0; i < IPPROTO_MAX; i++)
    293 		ip_protox[i] = pr - inetsw;
    294 	for (pr = inetdomain.dom_protosw;
    295 	    pr < inetdomain.dom_protoswNPROTOSW; pr++)
    296 		if (pr->pr_domain->dom_family == PF_INET &&
    297 		    pr->pr_protocol && pr->pr_protocol != IPPROTO_RAW)
    298 			ip_protox[pr->pr_protocol] = pr - inetsw;
    299 	LIST_INIT(&ipq);
    300 	ip_id = time.tv_sec & 0xffff;
    301 	ipintrq.ifq_maxlen = ipqmaxlen;
    302 	TAILQ_INIT(&in_ifaddr);
    303 	in_ifaddrhashtbl =
    304 	    hashinit(IN_IFADDR_HASH_SIZE, M_IFADDR, M_WAITOK, &in_ifaddrhash);
    305 	if (ip_mtudisc != 0)
    306 		ip_mtudisc_timeout_q =
    307 		    rt_timer_queue_create(ip_mtudisc_timeout);
    308 #ifdef GATEWAY
    309 	ipflow_init();
    310 #endif
    311 }
    312 
    313 struct	sockaddr_in ipaddr = { sizeof(ipaddr), AF_INET };
    314 struct	route ipforward_rt;
    315 
    316 /*
    317  * IP software interrupt routine
    318  */
    319 void
    320 ipintr()
    321 {
    322 	int s;
    323 	struct mbuf *m;
    324 
    325 	while (1) {
    326 		s = splimp();
    327 		IF_DEQUEUE(&ipintrq, m);
    328 		splx(s);
    329 		if (m == 0)
    330 			return;
    331 		ip_input(m);
    332 	}
    333 }
    334 
    335 /*
    336  * Ip input routine.  Checksum and byte swap header.  If fragmented
    337  * try to reassemble.  Process options.  Pass to next level.
    338  */
    339 void
    340 ip_input(struct mbuf *m)
    341 {
    342 	struct ip *ip = NULL;
    343 	struct ipq *fp;
    344 	struct in_ifaddr *ia;
    345 	struct ifaddr *ifa;
    346 	struct ipqent *ipqe;
    347 	int hlen = 0, mff, len;
    348 	int downmatch;
    349 #ifdef PFIL_HOOKS
    350 	struct packet_filter_hook *pfh;
    351 	struct mbuf *m0;
    352 	int rv;
    353 #endif /* PFIL_HOOKS */
    354 
    355 #ifdef	DIAGNOSTIC
    356 	if ((m->m_flags & M_PKTHDR) == 0)
    357 		panic("ipintr no HDR");
    358 #endif
    359 #ifdef IPSEC
    360 	/*
    361 	 * should the inner packet be considered authentic?
    362 	 * see comment in ah4_input().
    363 	 */
    364 	if (m) {
    365 		m->m_flags &= ~M_AUTHIPHDR;
    366 		m->m_flags &= ~M_AUTHIPDGM;
    367 	}
    368 #endif
    369 	/*
    370 	 * If no IP addresses have been set yet but the interfaces
    371 	 * are receiving, can't do anything with incoming packets yet.
    372 	 */
    373 	if (in_ifaddr.tqh_first == 0)
    374 		goto bad;
    375 	ipstat.ips_total++;
    376 	if (m->m_len < sizeof (struct ip) &&
    377 	    (m = m_pullup(m, sizeof (struct ip))) == 0) {
    378 		ipstat.ips_toosmall++;
    379 		return;
    380 	}
    381 	ip = mtod(m, struct ip *);
    382 	if (ip->ip_v != IPVERSION) {
    383 		ipstat.ips_badvers++;
    384 		goto bad;
    385 	}
    386 	hlen = ip->ip_hl << 2;
    387 	if (hlen < sizeof(struct ip)) {	/* minimum header length */
    388 		ipstat.ips_badhlen++;
    389 		goto bad;
    390 	}
    391 	if (hlen > m->m_len) {
    392 		if ((m = m_pullup(m, hlen)) == 0) {
    393 			ipstat.ips_badhlen++;
    394 			return;
    395 		}
    396 		ip = mtod(m, struct ip *);
    397 	}
    398 
    399 	/*
    400 	 * RFC1122: packets with a multicast source address are
    401 	 * not allowed.
    402 	 */
    403 	if (IN_MULTICAST(ip->ip_src.s_addr)) {
    404 		/* XXX stat */
    405 		goto bad;
    406 	}
    407 
    408 	if (in_cksum(m, hlen) != 0) {
    409 		ipstat.ips_badsum++;
    410 		goto bad;
    411 	}
    412 
    413 	/*
    414 	 * Convert fields to host representation.
    415 	 */
    416 	NTOHS(ip->ip_len);
    417 	NTOHS(ip->ip_off);
    418 	len = ip->ip_len;
    419 
    420 	/*
    421 	 * Check for additional length bogosity
    422 	 */
    423 	if (len < hlen) {
    424 	 	ipstat.ips_badlen++;
    425 		goto bad;
    426 	}
    427 
    428 	/*
    429 	 * Check that the amount of data in the buffers
    430 	 * is as at least much as the IP header would have us expect.
    431 	 * Trim mbufs if longer than we expect.
    432 	 * Drop packet if shorter than we expect.
    433 	 */
    434 	if (m->m_pkthdr.len < len) {
    435 		ipstat.ips_tooshort++;
    436 		goto bad;
    437 	}
    438 	if (m->m_pkthdr.len > len) {
    439 		if (m->m_len == m->m_pkthdr.len) {
    440 			m->m_len = len;
    441 			m->m_pkthdr.len = len;
    442 		} else
    443 			m_adj(m, len - m->m_pkthdr.len);
    444 	}
    445 
    446 #ifdef IPSEC
    447 	/* ipflow (IP fast fowarding) is not compatible with IPsec. */
    448 	m->m_flags &= ~M_CANFASTFWD;
    449 #else
    450 	/*
    451 	 * Assume that we can create a fast-forward IP flow entry
    452 	 * based on this packet.
    453 	 */
    454 	m->m_flags |= M_CANFASTFWD;
    455 #endif
    456 
    457 #ifdef PFIL_HOOKS
    458 	/*
    459 	 * Run through list of hooks for input packets.  If there are any
    460 	 * filters which require that additional packets in the flow are
    461 	 * not fast-forwarded, they must clear the M_CANFASTFWD flag.
    462 	 * Note that filters must _never_ set this flag, as another filter
    463 	 * in the list may have previously cleared it.
    464 	 */
    465 	m0 = m;
    466 	pfh = pfil_hook_get(PFIL_IN, &inetsw[ip_protox[IPPROTO_IP]].pr_pfh);
    467 	for (; pfh; pfh = pfh->pfil_link.tqe_next)
    468 		if (pfh->pfil_func) {
    469 			rv = pfh->pfil_func(ip, hlen,
    470 					    m->m_pkthdr.rcvif, 0, &m0);
    471 			if (rv)
    472 				return;
    473 			m = m0;
    474 			if (m == NULL)
    475 				return;
    476 			ip = mtod(m, struct ip *);
    477 		}
    478 #endif /* PFIL_HOOKS */
    479 
    480 	/*
    481 	 * Process options and, if not destined for us,
    482 	 * ship it on.  ip_dooptions returns 1 when an
    483 	 * error was detected (causing an icmp message
    484 	 * to be sent and the original packet to be freed).
    485 	 */
    486 	ip_nhops = 0;		/* for source routed packets */
    487 	if (hlen > sizeof (struct ip) && ip_dooptions(m))
    488 		return;
    489 
    490 	/*
    491 	 * Check our list of addresses, to see if the packet is for us.
    492 	 *
    493 	 * Traditional 4.4BSD did not consult IFF_UP at all.
    494 	 * The behavior here is to treat addresses on !IFF_UP interface
    495 	 * as not mine.
    496 	 */
    497 	downmatch = 0;
    498 	for (ia = IN_IFADDR_HASH(ip->ip_dst.s_addr).lh_first;
    499 	     ia != NULL;
    500 	     ia = ia->ia_hash.le_next) {
    501 		if (in_hosteq(ia->ia_addr.sin_addr, ip->ip_dst)) {
    502 			if ((ia->ia_ifp->if_flags & IFF_UP) != 0)
    503 				break;
    504 			else
    505 				downmatch++;
    506 		}
    507 	}
    508 	if (ia != NULL)
    509 		goto ours;
    510 	if (m->m_pkthdr.rcvif->if_flags & IFF_BROADCAST) {
    511 		for (ifa = m->m_pkthdr.rcvif->if_addrlist.tqh_first;
    512 		    ifa != NULL; ifa = ifa->ifa_list.tqe_next) {
    513 			if (ifa->ifa_addr->sa_family != AF_INET) continue;
    514 			ia = ifatoia(ifa);
    515 			if (in_hosteq(ip->ip_dst, ia->ia_broadaddr.sin_addr) ||
    516 			    in_hosteq(ip->ip_dst, ia->ia_netbroadcast) ||
    517 			    /*
    518 			     * Look for all-0's host part (old broadcast addr),
    519 			     * either for subnet or net.
    520 			     */
    521 			    ip->ip_dst.s_addr == ia->ia_subnet ||
    522 			    ip->ip_dst.s_addr == ia->ia_net)
    523 				goto ours;
    524 			/*
    525 			 * An interface with IP address zero accepts
    526 			 * all packets that arrive on that interface.
    527 			 */
    528 			if (in_nullhost(ia->ia_addr.sin_addr))
    529 				goto ours;
    530 		}
    531 	}
    532 	if (IN_MULTICAST(ip->ip_dst.s_addr)) {
    533 		struct in_multi *inm;
    534 #ifdef MROUTING
    535 		extern struct socket *ip_mrouter;
    536 
    537 		if (m->m_flags & M_EXT) {
    538 			if ((m = m_pullup(m, hlen)) == 0) {
    539 				ipstat.ips_toosmall++;
    540 				return;
    541 			}
    542 			ip = mtod(m, struct ip *);
    543 		}
    544 
    545 		if (ip_mrouter) {
    546 			/*
    547 			 * If we are acting as a multicast router, all
    548 			 * incoming multicast packets are passed to the
    549 			 * kernel-level multicast forwarding function.
    550 			 * The packet is returned (relatively) intact; if
    551 			 * ip_mforward() returns a non-zero value, the packet
    552 			 * must be discarded, else it may be accepted below.
    553 			 *
    554 			 * (The IP ident field is put in the same byte order
    555 			 * as expected when ip_mforward() is called from
    556 			 * ip_output().)
    557 			 */
    558 			if (ip_mforward(m, m->m_pkthdr.rcvif) != 0) {
    559 				ipstat.ips_cantforward++;
    560 				m_freem(m);
    561 				return;
    562 			}
    563 
    564 			/*
    565 			 * The process-level routing demon needs to receive
    566 			 * all multicast IGMP packets, whether or not this
    567 			 * host belongs to their destination groups.
    568 			 */
    569 			if (ip->ip_p == IPPROTO_IGMP)
    570 				goto ours;
    571 			ipstat.ips_forward++;
    572 		}
    573 #endif
    574 		/*
    575 		 * See if we belong to the destination multicast group on the
    576 		 * arrival interface.
    577 		 */
    578 		IN_LOOKUP_MULTI(ip->ip_dst, m->m_pkthdr.rcvif, inm);
    579 		if (inm == NULL) {
    580 			ipstat.ips_cantforward++;
    581 			m_freem(m);
    582 			return;
    583 		}
    584 		goto ours;
    585 	}
    586 	if (ip->ip_dst.s_addr == INADDR_BROADCAST ||
    587 	    in_nullhost(ip->ip_dst))
    588 		goto ours;
    589 
    590 	/*
    591 	 * Not for us; forward if possible and desirable.
    592 	 */
    593 	if (ipforwarding == 0) {
    594 		ipstat.ips_cantforward++;
    595 		m_freem(m);
    596 	} else {
    597 		/*
    598 		 * If ip_dst matched any of my address on !IFF_UP interface,
    599 		 * and there's no IFF_UP interface that matches ip_dst,
    600 		 * send icmp unreach.  Forwarding it will result in in-kernel
    601 		 * forwarding loop till TTL goes to 0.
    602 		 */
    603 		if (downmatch) {
    604 			icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, 0);
    605 			ipstat.ips_cantforward++;
    606 			return;
    607 		}
    608 		ip_forward(m, 0);
    609 	}
    610 	return;
    611 
    612 ours:
    613 	/*
    614 	 * If offset or IP_MF are set, must reassemble.
    615 	 * Otherwise, nothing need be done.
    616 	 * (We could look in the reassembly queue to see
    617 	 * if the packet was previously fragmented,
    618 	 * but it's not worth the time; just let them time out.)
    619 	 */
    620 	if (ip->ip_off & ~(IP_DF|IP_RF)) {
    621 		/*
    622 		 * Look for queue of fragments
    623 		 * of this datagram.
    624 		 */
    625 		IPQ_LOCK();
    626 		for (fp = ipq.lh_first; fp != NULL; fp = fp->ipq_q.le_next)
    627 			if (ip->ip_id == fp->ipq_id &&
    628 			    in_hosteq(ip->ip_src, fp->ipq_src) &&
    629 			    in_hosteq(ip->ip_dst, fp->ipq_dst) &&
    630 			    ip->ip_p == fp->ipq_p)
    631 				goto found;
    632 		fp = 0;
    633 found:
    634 
    635 		/*
    636 		 * Adjust ip_len to not reflect header,
    637 		 * set ipqe_mff if more fragments are expected,
    638 		 * convert offset of this to bytes.
    639 		 */
    640 		ip->ip_len -= hlen;
    641 		mff = (ip->ip_off & IP_MF) != 0;
    642 		if (mff) {
    643 		        /*
    644 		         * Make sure that fragments have a data length
    645 			 * that's a non-zero multiple of 8 bytes.
    646 		         */
    647 			if (ip->ip_len == 0 || (ip->ip_len & 0x7) != 0) {
    648 				ipstat.ips_badfrags++;
    649 				IPQ_UNLOCK();
    650 				goto bad;
    651 			}
    652 		}
    653 		ip->ip_off <<= 3;
    654 
    655 		/*
    656 		 * If datagram marked as having more fragments
    657 		 * or if this is not the first fragment,
    658 		 * attempt reassembly; if it succeeds, proceed.
    659 		 */
    660 		if (mff || ip->ip_off) {
    661 			ipstat.ips_fragments++;
    662 			ipqe = pool_get(&ipqent_pool, PR_NOWAIT);
    663 			if (ipqe == NULL) {
    664 				ipstat.ips_rcvmemdrop++;
    665 				IPQ_UNLOCK();
    666 				goto bad;
    667 			}
    668 			ipqe->ipqe_mff = mff;
    669 			ipqe->ipqe_m = m;
    670 			ipqe->ipqe_ip = ip;
    671 			m = ip_reass(ipqe, fp);
    672 			if (m == 0) {
    673 				IPQ_UNLOCK();
    674 				return;
    675 			}
    676 			ipstat.ips_reassembled++;
    677 			ip = mtod(m, struct ip *);
    678 			hlen = ip->ip_hl << 2;
    679 			ip->ip_len += hlen;
    680 		} else
    681 			if (fp)
    682 				ip_freef(fp);
    683 		IPQ_UNLOCK();
    684 	}
    685 
    686 	/*
    687 	 * Switch out to protocol's input routine.
    688 	 */
    689 #if IFA_STATS
    690 	ia->ia_ifa.ifa_data.ifad_inbytes += ip->ip_len;
    691 #endif
    692 	ipstat.ips_delivered++;
    693     {
    694 	int off = hlen, nh = ip->ip_p;
    695 
    696 	(*inetsw[ip_protox[nh]].pr_input)(m, off, nh);
    697 	return;
    698     }
    699 bad:
    700 	m_freem(m);
    701 }
    702 
    703 /*
    704  * Take incoming datagram fragment and try to
    705  * reassemble it into whole datagram.  If a chain for
    706  * reassembly of this datagram already exists, then it
    707  * is given as fp; otherwise have to make a chain.
    708  */
    709 struct mbuf *
    710 ip_reass(ipqe, fp)
    711 	struct ipqent *ipqe;
    712 	struct ipq *fp;
    713 {
    714 	struct mbuf *m = ipqe->ipqe_m;
    715 	struct ipqent *nq, *p, *q;
    716 	struct ip *ip;
    717 	struct mbuf *t;
    718 	int hlen = ipqe->ipqe_ip->ip_hl << 2;
    719 	int i, next;
    720 
    721 	IPQ_LOCK_CHECK();
    722 
    723 	/*
    724 	 * Presence of header sizes in mbufs
    725 	 * would confuse code below.
    726 	 */
    727 	m->m_data += hlen;
    728 	m->m_len -= hlen;
    729 
    730 	/*
    731 	 * If first fragment to arrive, create a reassembly queue.
    732 	 */
    733 	if (fp == 0) {
    734 		MALLOC(fp, struct ipq *, sizeof (struct ipq),
    735 		    M_FTABLE, M_NOWAIT);
    736 		if (fp == NULL)
    737 			goto dropfrag;
    738 		LIST_INSERT_HEAD(&ipq, fp, ipq_q);
    739 		fp->ipq_ttl = IPFRAGTTL;
    740 		fp->ipq_p = ipqe->ipqe_ip->ip_p;
    741 		fp->ipq_id = ipqe->ipqe_ip->ip_id;
    742 		LIST_INIT(&fp->ipq_fragq);
    743 		fp->ipq_src = ipqe->ipqe_ip->ip_src;
    744 		fp->ipq_dst = ipqe->ipqe_ip->ip_dst;
    745 		p = NULL;
    746 		goto insert;
    747 	}
    748 
    749 	/*
    750 	 * Find a segment which begins after this one does.
    751 	 */
    752 	for (p = NULL, q = fp->ipq_fragq.lh_first; q != NULL;
    753 	    p = q, q = q->ipqe_q.le_next)
    754 		if (q->ipqe_ip->ip_off > ipqe->ipqe_ip->ip_off)
    755 			break;
    756 
    757 	/*
    758 	 * If there is a preceding segment, it may provide some of
    759 	 * our data already.  If so, drop the data from the incoming
    760 	 * segment.  If it provides all of our data, drop us.
    761 	 */
    762 	if (p != NULL) {
    763 		i = p->ipqe_ip->ip_off + p->ipqe_ip->ip_len -
    764 		    ipqe->ipqe_ip->ip_off;
    765 		if (i > 0) {
    766 			if (i >= ipqe->ipqe_ip->ip_len)
    767 				goto dropfrag;
    768 			m_adj(ipqe->ipqe_m, i);
    769 			ipqe->ipqe_ip->ip_off += i;
    770 			ipqe->ipqe_ip->ip_len -= i;
    771 		}
    772 	}
    773 
    774 	/*
    775 	 * While we overlap succeeding segments trim them or,
    776 	 * if they are completely covered, dequeue them.
    777 	 */
    778 	for (; q != NULL && ipqe->ipqe_ip->ip_off + ipqe->ipqe_ip->ip_len >
    779 	    q->ipqe_ip->ip_off; q = nq) {
    780 		i = (ipqe->ipqe_ip->ip_off + ipqe->ipqe_ip->ip_len) -
    781 		    q->ipqe_ip->ip_off;
    782 		if (i < q->ipqe_ip->ip_len) {
    783 			q->ipqe_ip->ip_len -= i;
    784 			q->ipqe_ip->ip_off += i;
    785 			m_adj(q->ipqe_m, i);
    786 			break;
    787 		}
    788 		nq = q->ipqe_q.le_next;
    789 		m_freem(q->ipqe_m);
    790 		LIST_REMOVE(q, ipqe_q);
    791 		pool_put(&ipqent_pool, q);
    792 	}
    793 
    794 insert:
    795 	/*
    796 	 * Stick new segment in its place;
    797 	 * check for complete reassembly.
    798 	 */
    799 	if (p == NULL) {
    800 		LIST_INSERT_HEAD(&fp->ipq_fragq, ipqe, ipqe_q);
    801 	} else {
    802 		LIST_INSERT_AFTER(p, ipqe, ipqe_q);
    803 	}
    804 	next = 0;
    805 	for (p = NULL, q = fp->ipq_fragq.lh_first; q != NULL;
    806 	    p = q, q = q->ipqe_q.le_next) {
    807 		if (q->ipqe_ip->ip_off != next)
    808 			return (0);
    809 		next += q->ipqe_ip->ip_len;
    810 	}
    811 	if (p->ipqe_mff)
    812 		return (0);
    813 
    814 	/*
    815 	 * Reassembly is complete.  Check for a bogus message size and
    816 	 * concatenate fragments.
    817 	 */
    818 	q = fp->ipq_fragq.lh_first;
    819 	ip = q->ipqe_ip;
    820 	if ((next + (ip->ip_hl << 2)) > IP_MAXPACKET) {
    821 		ipstat.ips_toolong++;
    822 		ip_freef(fp);
    823 		return (0);
    824 	}
    825 	m = q->ipqe_m;
    826 	t = m->m_next;
    827 	m->m_next = 0;
    828 	m_cat(m, t);
    829 	nq = q->ipqe_q.le_next;
    830 	pool_put(&ipqent_pool, q);
    831 	for (q = nq; q != NULL; q = nq) {
    832 		t = q->ipqe_m;
    833 		nq = q->ipqe_q.le_next;
    834 		pool_put(&ipqent_pool, q);
    835 		m_cat(m, t);
    836 	}
    837 
    838 	/*
    839 	 * Create header for new ip packet by
    840 	 * modifying header of first packet;
    841 	 * dequeue and discard fragment reassembly header.
    842 	 * Make header visible.
    843 	 */
    844 	ip->ip_len = next;
    845 	ip->ip_src = fp->ipq_src;
    846 	ip->ip_dst = fp->ipq_dst;
    847 	LIST_REMOVE(fp, ipq_q);
    848 	FREE(fp, M_FTABLE);
    849 	m->m_len += (ip->ip_hl << 2);
    850 	m->m_data -= (ip->ip_hl << 2);
    851 	/* some debugging cruft by sklower, below, will go away soon */
    852 	if (m->m_flags & M_PKTHDR) { /* XXX this should be done elsewhere */
    853 		int plen = 0;
    854 		for (t = m; t; t = t->m_next)
    855 			plen += t->m_len;
    856 		m->m_pkthdr.len = plen;
    857 	}
    858 	return (m);
    859 
    860 dropfrag:
    861 	ipstat.ips_fragdropped++;
    862 	m_freem(m);
    863 	pool_put(&ipqent_pool, ipqe);
    864 	return (0);
    865 }
    866 
    867 /*
    868  * Free a fragment reassembly header and all
    869  * associated datagrams.
    870  */
    871 void
    872 ip_freef(fp)
    873 	struct ipq *fp;
    874 {
    875 	struct ipqent *q, *p;
    876 
    877 	IPQ_LOCK_CHECK();
    878 
    879 	for (q = fp->ipq_fragq.lh_first; q != NULL; q = p) {
    880 		p = q->ipqe_q.le_next;
    881 		m_freem(q->ipqe_m);
    882 		LIST_REMOVE(q, ipqe_q);
    883 		pool_put(&ipqent_pool, q);
    884 	}
    885 	LIST_REMOVE(fp, ipq_q);
    886 	FREE(fp, M_FTABLE);
    887 }
    888 
    889 /*
    890  * IP timer processing;
    891  * if a timer expires on a reassembly
    892  * queue, discard it.
    893  */
    894 void
    895 ip_slowtimo()
    896 {
    897 	struct ipq *fp, *nfp;
    898 	int s = splsoftnet();
    899 
    900 	IPQ_LOCK();
    901 	for (fp = ipq.lh_first; fp != NULL; fp = nfp) {
    902 		nfp = fp->ipq_q.le_next;
    903 		if (--fp->ipq_ttl == 0) {
    904 			ipstat.ips_fragtimeout++;
    905 			ip_freef(fp);
    906 		}
    907 	}
    908 	IPQ_UNLOCK();
    909 #ifdef GATEWAY
    910 	ipflow_slowtimo();
    911 #endif
    912 	splx(s);
    913 }
    914 
    915 /*
    916  * Drain off all datagram fragments.
    917  */
    918 void
    919 ip_drain()
    920 {
    921 
    922 	/*
    923 	 * We may be called from a device's interrupt context.  If
    924 	 * the ipq is already busy, just bail out now.
    925 	 */
    926 	if (ipq_lock_try() == 0)
    927 		return;
    928 
    929 	while (ipq.lh_first != NULL) {
    930 		ipstat.ips_fragdropped++;
    931 		ip_freef(ipq.lh_first);
    932 	}
    933 
    934 	IPQ_UNLOCK();
    935 }
    936 
    937 /*
    938  * Do option processing on a datagram,
    939  * possibly discarding it if bad options are encountered,
    940  * or forwarding it if source-routed.
    941  * Returns 1 if packet has been forwarded/freed,
    942  * 0 if the packet should be processed further.
    943  */
    944 int
    945 ip_dooptions(m)
    946 	struct mbuf *m;
    947 {
    948 	struct ip *ip = mtod(m, struct ip *);
    949 	u_char *cp, *cp0;
    950 	struct ip_timestamp *ipt;
    951 	struct in_ifaddr *ia;
    952 	int opt, optlen, cnt, off, code, type = ICMP_PARAMPROB, forward = 0;
    953 	struct in_addr dst;
    954 	n_time ntime;
    955 
    956 	dst = ip->ip_dst;
    957 	cp = (u_char *)(ip + 1);
    958 	cnt = (ip->ip_hl << 2) - sizeof (struct ip);
    959 	for (; cnt > 0; cnt -= optlen, cp += optlen) {
    960 		opt = cp[IPOPT_OPTVAL];
    961 		if (opt == IPOPT_EOL)
    962 			break;
    963 		if (opt == IPOPT_NOP)
    964 			optlen = 1;
    965 		else {
    966 			optlen = cp[IPOPT_OLEN];
    967 			if (optlen <= 0 || optlen > cnt) {
    968 				code = &cp[IPOPT_OLEN] - (u_char *)ip;
    969 				goto bad;
    970 			}
    971 		}
    972 		switch (opt) {
    973 
    974 		default:
    975 			break;
    976 
    977 		/*
    978 		 * Source routing with record.
    979 		 * Find interface with current destination address.
    980 		 * If none on this machine then drop if strictly routed,
    981 		 * or do nothing if loosely routed.
    982 		 * Record interface address and bring up next address
    983 		 * component.  If strictly routed make sure next
    984 		 * address is on directly accessible net.
    985 		 */
    986 		case IPOPT_LSRR:
    987 		case IPOPT_SSRR:
    988 			if (ip_allowsrcrt == 0) {
    989 				type = ICMP_UNREACH;
    990 				code = ICMP_UNREACH_NET_PROHIB;
    991 				goto bad;
    992 			}
    993 			if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {
    994 				code = &cp[IPOPT_OFFSET] - (u_char *)ip;
    995 				goto bad;
    996 			}
    997 			ipaddr.sin_addr = ip->ip_dst;
    998 			ia = ifatoia(ifa_ifwithaddr(sintosa(&ipaddr)));
    999 			if (ia == 0) {
   1000 				if (opt == IPOPT_SSRR) {
   1001 					type = ICMP_UNREACH;
   1002 					code = ICMP_UNREACH_SRCFAIL;
   1003 					goto bad;
   1004 				}
   1005 				/*
   1006 				 * Loose routing, and not at next destination
   1007 				 * yet; nothing to do except forward.
   1008 				 */
   1009 				break;
   1010 			}
   1011 			off--;			/* 0 origin */
   1012 			if (off > optlen - sizeof(struct in_addr)) {
   1013 				/*
   1014 				 * End of source route.  Should be for us.
   1015 				 */
   1016 				save_rte(cp, ip->ip_src);
   1017 				break;
   1018 			}
   1019 			/*
   1020 			 * locate outgoing interface
   1021 			 */
   1022 			bcopy((caddr_t)(cp + off), (caddr_t)&ipaddr.sin_addr,
   1023 			    sizeof(ipaddr.sin_addr));
   1024 			if (opt == IPOPT_SSRR)
   1025 				ia = ifatoia(ifa_ifwithaddr(sintosa(&ipaddr)));
   1026 			else
   1027 				ia = ip_rtaddr(ipaddr.sin_addr);
   1028 			if (ia == 0) {
   1029 				type = ICMP_UNREACH;
   1030 				code = ICMP_UNREACH_SRCFAIL;
   1031 				goto bad;
   1032 			}
   1033 			ip->ip_dst = ipaddr.sin_addr;
   1034 			bcopy((caddr_t)&ia->ia_addr.sin_addr,
   1035 			    (caddr_t)(cp + off), sizeof(struct in_addr));
   1036 			cp[IPOPT_OFFSET] += sizeof(struct in_addr);
   1037 			/*
   1038 			 * Let ip_intr's mcast routing check handle mcast pkts
   1039 			 */
   1040 			forward = !IN_MULTICAST(ip->ip_dst.s_addr);
   1041 			break;
   1042 
   1043 		case IPOPT_RR:
   1044 			if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {
   1045 				code = &cp[IPOPT_OFFSET] - (u_char *)ip;
   1046 				goto bad;
   1047 			}
   1048 			/*
   1049 			 * If no space remains, ignore.
   1050 			 */
   1051 			off--;			/* 0 origin */
   1052 			if (off > optlen - sizeof(struct in_addr))
   1053 				break;
   1054 			bcopy((caddr_t)(&ip->ip_dst), (caddr_t)&ipaddr.sin_addr,
   1055 			    sizeof(ipaddr.sin_addr));
   1056 			/*
   1057 			 * locate outgoing interface; if we're the destination,
   1058 			 * use the incoming interface (should be same).
   1059 			 */
   1060 			if ((ia = ifatoia(ifa_ifwithaddr(sintosa(&ipaddr))))
   1061 			    == NULL &&
   1062 			    (ia = ip_rtaddr(ipaddr.sin_addr)) == NULL) {
   1063 				type = ICMP_UNREACH;
   1064 				code = ICMP_UNREACH_HOST;
   1065 				goto bad;
   1066 			}
   1067 			bcopy((caddr_t)&ia->ia_addr.sin_addr,
   1068 			    (caddr_t)(cp + off), sizeof(struct in_addr));
   1069 			cp[IPOPT_OFFSET] += sizeof(struct in_addr);
   1070 			break;
   1071 
   1072 		case IPOPT_TS:
   1073 			code = cp - (u_char *)ip;
   1074 			ipt = (struct ip_timestamp *)cp;
   1075 			if (ipt->ipt_len < 5)
   1076 				goto bad;
   1077 			if (ipt->ipt_ptr > ipt->ipt_len - sizeof (int32_t)) {
   1078 				if (++ipt->ipt_oflw == 0)
   1079 					goto bad;
   1080 				break;
   1081 			}
   1082 			cp0 = (cp + ipt->ipt_ptr - 1);
   1083 			switch (ipt->ipt_flg) {
   1084 
   1085 			case IPOPT_TS_TSONLY:
   1086 				break;
   1087 
   1088 			case IPOPT_TS_TSANDADDR:
   1089 				if (ipt->ipt_ptr - 1 + sizeof(n_time) +
   1090 				    sizeof(struct in_addr) > ipt->ipt_len)
   1091 					goto bad;
   1092 				ipaddr.sin_addr = dst;
   1093 				ia = ifatoia(ifaof_ifpforaddr(sintosa(&ipaddr),
   1094 				    m->m_pkthdr.rcvif));
   1095 				if (ia == 0)
   1096 					continue;
   1097 				bcopy(&ia->ia_addr.sin_addr,
   1098 				    cp0, sizeof(struct in_addr));
   1099 				ipt->ipt_ptr += sizeof(struct in_addr);
   1100 				break;
   1101 
   1102 			case IPOPT_TS_PRESPEC:
   1103 				if (ipt->ipt_ptr - 1 + sizeof(n_time) +
   1104 				    sizeof(struct in_addr) > ipt->ipt_len)
   1105 					goto bad;
   1106 				bcopy(cp0, &ipaddr.sin_addr,
   1107 				    sizeof(struct in_addr));
   1108 				if (ifatoia(ifa_ifwithaddr(sintosa(&ipaddr)))
   1109 				    == NULL)
   1110 					continue;
   1111 				ipt->ipt_ptr += sizeof(struct in_addr);
   1112 				break;
   1113 
   1114 			default:
   1115 				goto bad;
   1116 			}
   1117 			ntime = iptime();
   1118 			cp0 = (u_char *) &ntime; /* XXX grumble, GCC... */
   1119 			bcopy(cp0, (caddr_t)cp + ipt->ipt_ptr - 1,
   1120 			    sizeof(n_time));
   1121 			ipt->ipt_ptr += sizeof(n_time);
   1122 		}
   1123 	}
   1124 	if (forward) {
   1125 		if (ip_forwsrcrt == 0) {
   1126 			type = ICMP_UNREACH;
   1127 			code = ICMP_UNREACH_SRCFAIL;
   1128 			goto bad;
   1129 		}
   1130 		ip_forward(m, 1);
   1131 		return (1);
   1132 	}
   1133 	return (0);
   1134 bad:
   1135 	icmp_error(m, type, code, 0, 0);
   1136 	ipstat.ips_badoptions++;
   1137 	return (1);
   1138 }
   1139 
   1140 /*
   1141  * Given address of next destination (final or next hop),
   1142  * return internet address info of interface to be used to get there.
   1143  */
   1144 struct in_ifaddr *
   1145 ip_rtaddr(dst)
   1146 	 struct in_addr dst;
   1147 {
   1148 	struct sockaddr_in *sin;
   1149 
   1150 	sin = satosin(&ipforward_rt.ro_dst);
   1151 
   1152 	if (ipforward_rt.ro_rt == 0 || !in_hosteq(dst, sin->sin_addr)) {
   1153 		if (ipforward_rt.ro_rt) {
   1154 			RTFREE(ipforward_rt.ro_rt);
   1155 			ipforward_rt.ro_rt = 0;
   1156 		}
   1157 		sin->sin_family = AF_INET;
   1158 		sin->sin_len = sizeof(*sin);
   1159 		sin->sin_addr = dst;
   1160 
   1161 		rtalloc(&ipforward_rt);
   1162 	}
   1163 	if (ipforward_rt.ro_rt == 0)
   1164 		return ((struct in_ifaddr *)0);
   1165 	return (ifatoia(ipforward_rt.ro_rt->rt_ifa));
   1166 }
   1167 
   1168 /*
   1169  * Save incoming source route for use in replies,
   1170  * to be picked up later by ip_srcroute if the receiver is interested.
   1171  */
   1172 void
   1173 save_rte(option, dst)
   1174 	u_char *option;
   1175 	struct in_addr dst;
   1176 {
   1177 	unsigned olen;
   1178 
   1179 	olen = option[IPOPT_OLEN];
   1180 #ifdef DIAGNOSTIC
   1181 	if (ipprintfs)
   1182 		printf("save_rte: olen %d\n", olen);
   1183 #endif /* 0 */
   1184 	if (olen > sizeof(ip_srcrt) - (1 + sizeof(dst)))
   1185 		return;
   1186 	bcopy((caddr_t)option, (caddr_t)ip_srcrt.srcopt, olen);
   1187 	ip_nhops = (olen - IPOPT_OFFSET - 1) / sizeof(struct in_addr);
   1188 	ip_srcrt.dst = dst;
   1189 }
   1190 
   1191 /*
   1192  * Retrieve incoming source route for use in replies,
   1193  * in the same form used by setsockopt.
   1194  * The first hop is placed before the options, will be removed later.
   1195  */
   1196 struct mbuf *
   1197 ip_srcroute()
   1198 {
   1199 	struct in_addr *p, *q;
   1200 	struct mbuf *m;
   1201 
   1202 	if (ip_nhops == 0)
   1203 		return ((struct mbuf *)0);
   1204 	m = m_get(M_DONTWAIT, MT_SOOPTS);
   1205 	if (m == 0)
   1206 		return ((struct mbuf *)0);
   1207 
   1208 #define OPTSIZ	(sizeof(ip_srcrt.nop) + sizeof(ip_srcrt.srcopt))
   1209 
   1210 	/* length is (nhops+1)*sizeof(addr) + sizeof(nop + srcrt header) */
   1211 	m->m_len = ip_nhops * sizeof(struct in_addr) + sizeof(struct in_addr) +
   1212 	    OPTSIZ;
   1213 #ifdef DIAGNOSTIC
   1214 	if (ipprintfs)
   1215 		printf("ip_srcroute: nhops %d mlen %d", ip_nhops, m->m_len);
   1216 #endif
   1217 
   1218 	/*
   1219 	 * First save first hop for return route
   1220 	 */
   1221 	p = &ip_srcrt.route[ip_nhops - 1];
   1222 	*(mtod(m, struct in_addr *)) = *p--;
   1223 #ifdef DIAGNOSTIC
   1224 	if (ipprintfs)
   1225 		printf(" hops %x", ntohl(mtod(m, struct in_addr *)->s_addr));
   1226 #endif
   1227 
   1228 	/*
   1229 	 * Copy option fields and padding (nop) to mbuf.
   1230 	 */
   1231 	ip_srcrt.nop = IPOPT_NOP;
   1232 	ip_srcrt.srcopt[IPOPT_OFFSET] = IPOPT_MINOFF;
   1233 	bcopy((caddr_t)&ip_srcrt.nop,
   1234 	    mtod(m, caddr_t) + sizeof(struct in_addr), OPTSIZ);
   1235 	q = (struct in_addr *)(mtod(m, caddr_t) +
   1236 	    sizeof(struct in_addr) + OPTSIZ);
   1237 #undef OPTSIZ
   1238 	/*
   1239 	 * Record return path as an IP source route,
   1240 	 * reversing the path (pointers are now aligned).
   1241 	 */
   1242 	while (p >= ip_srcrt.route) {
   1243 #ifdef DIAGNOSTIC
   1244 		if (ipprintfs)
   1245 			printf(" %x", ntohl(q->s_addr));
   1246 #endif
   1247 		*q++ = *p--;
   1248 	}
   1249 	/*
   1250 	 * Last hop goes to final destination.
   1251 	 */
   1252 	*q = ip_srcrt.dst;
   1253 #ifdef DIAGNOSTIC
   1254 	if (ipprintfs)
   1255 		printf(" %x\n", ntohl(q->s_addr));
   1256 #endif
   1257 	return (m);
   1258 }
   1259 
   1260 /*
   1261  * Strip out IP options, at higher
   1262  * level protocol in the kernel.
   1263  * Second argument is buffer to which options
   1264  * will be moved, and return value is their length.
   1265  * XXX should be deleted; last arg currently ignored.
   1266  */
   1267 void
   1268 ip_stripoptions(m, mopt)
   1269 	struct mbuf *m;
   1270 	struct mbuf *mopt;
   1271 {
   1272 	int i;
   1273 	struct ip *ip = mtod(m, struct ip *);
   1274 	caddr_t opts;
   1275 	int olen;
   1276 
   1277 	olen = (ip->ip_hl << 2) - sizeof (struct ip);
   1278 	opts = (caddr_t)(ip + 1);
   1279 	i = m->m_len - (sizeof (struct ip) + olen);
   1280 	bcopy(opts  + olen, opts, (unsigned)i);
   1281 	m->m_len -= olen;
   1282 	if (m->m_flags & M_PKTHDR)
   1283 		m->m_pkthdr.len -= olen;
   1284 	ip->ip_len -= olen;
   1285 	ip->ip_hl = sizeof (struct ip) >> 2;
   1286 }
   1287 
   1288 int inetctlerrmap[PRC_NCMDS] = {
   1289 	0,		0,		0,		0,
   1290 	0,		EMSGSIZE,	EHOSTDOWN,	EHOSTUNREACH,
   1291 	EHOSTUNREACH,	EHOSTUNREACH,	ECONNREFUSED,	ECONNREFUSED,
   1292 	EMSGSIZE,	EHOSTUNREACH,	0,		0,
   1293 	0,		0,		0,		0,
   1294 	ENOPROTOOPT
   1295 };
   1296 
   1297 /*
   1298  * Forward a packet.  If some error occurs return the sender
   1299  * an icmp packet.  Note we can't always generate a meaningful
   1300  * icmp message because icmp doesn't have a large enough repertoire
   1301  * of codes and types.
   1302  *
   1303  * If not forwarding, just drop the packet.  This could be confusing
   1304  * if ipforwarding was zero but some routing protocol was advancing
   1305  * us as a gateway to somewhere.  However, we must let the routing
   1306  * protocol deal with that.
   1307  *
   1308  * The srcrt parameter indicates whether the packet is being forwarded
   1309  * via a source route.
   1310  */
   1311 void
   1312 ip_forward(m, srcrt)
   1313 	struct mbuf *m;
   1314 	int srcrt;
   1315 {
   1316 	struct ip *ip = mtod(m, struct ip *);
   1317 	struct sockaddr_in *sin;
   1318 	struct rtentry *rt;
   1319 	int error, type = 0, code = 0;
   1320 	struct mbuf *mcopy;
   1321 	n_long dest;
   1322 	struct ifnet *destifp;
   1323 #ifdef IPSEC
   1324 	struct ifnet dummyifp;
   1325 #endif
   1326 
   1327 	dest = 0;
   1328 #ifdef DIAGNOSTIC
   1329 	if (ipprintfs)
   1330 		printf("forward: src %2.2x dst %2.2x ttl %x\n",
   1331 		    ntohl(ip->ip_src.s_addr),
   1332 		    ntohl(ip->ip_dst.s_addr), ip->ip_ttl);
   1333 #endif
   1334 	if (m->m_flags & (M_BCAST|M_MCAST) || in_canforward(ip->ip_dst) == 0) {
   1335 		ipstat.ips_cantforward++;
   1336 		m_freem(m);
   1337 		return;
   1338 	}
   1339 	if (ip->ip_ttl <= IPTTLDEC) {
   1340 		icmp_error(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS, dest, 0);
   1341 		return;
   1342 	}
   1343 	ip->ip_ttl -= IPTTLDEC;
   1344 
   1345 	sin = satosin(&ipforward_rt.ro_dst);
   1346 	if ((rt = ipforward_rt.ro_rt) == 0 ||
   1347 	    !in_hosteq(ip->ip_dst, sin->sin_addr)) {
   1348 		if (ipforward_rt.ro_rt) {
   1349 			RTFREE(ipforward_rt.ro_rt);
   1350 			ipforward_rt.ro_rt = 0;
   1351 		}
   1352 		sin->sin_family = AF_INET;
   1353 		sin->sin_len = sizeof(struct sockaddr_in);
   1354 		sin->sin_addr = ip->ip_dst;
   1355 
   1356 		rtalloc(&ipforward_rt);
   1357 		if (ipforward_rt.ro_rt == 0) {
   1358 			icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, dest, 0);
   1359 			return;
   1360 		}
   1361 		rt = ipforward_rt.ro_rt;
   1362 	}
   1363 
   1364 	/*
   1365 	 * Save at most 68 bytes of the packet in case
   1366 	 * we need to generate an ICMP message to the src.
   1367 	 */
   1368 	mcopy = m_copy(m, 0, imin((int)ip->ip_len, 68));
   1369 
   1370 	/*
   1371 	 * If forwarding packet using same interface that it came in on,
   1372 	 * perhaps should send a redirect to sender to shortcut a hop.
   1373 	 * Only send redirect if source is sending directly to us,
   1374 	 * and if packet was not source routed (or has any options).
   1375 	 * Also, don't send redirect if forwarding using a default route
   1376 	 * or a route modified by a redirect.
   1377 	 */
   1378 	if (rt->rt_ifp == m->m_pkthdr.rcvif &&
   1379 	    (rt->rt_flags & (RTF_DYNAMIC|RTF_MODIFIED)) == 0 &&
   1380 	    !in_nullhost(satosin(rt_key(rt))->sin_addr) &&
   1381 	    ipsendredirects && !srcrt) {
   1382 		if (rt->rt_ifa &&
   1383 		    (ip->ip_src.s_addr & ifatoia(rt->rt_ifa)->ia_subnetmask) ==
   1384 		    ifatoia(rt->rt_ifa)->ia_subnet) {
   1385 			if (rt->rt_flags & RTF_GATEWAY)
   1386 				dest = satosin(rt->rt_gateway)->sin_addr.s_addr;
   1387 			else
   1388 				dest = ip->ip_dst.s_addr;
   1389 			/*
   1390 			 * Router requirements says to only send host
   1391 			 * redirects.
   1392 			 */
   1393 			type = ICMP_REDIRECT;
   1394 			code = ICMP_REDIRECT_HOST;
   1395 #ifdef DIAGNOSTIC
   1396 			if (ipprintfs)
   1397 				printf("redirect (%d) to %x\n", code,
   1398 				    (u_int32_t)dest);
   1399 #endif
   1400 		}
   1401 	}
   1402 
   1403 #ifdef IPSEC
   1404 	/* Don't lookup socket in forwading case */
   1405 	ipsec_setsocket(m, NULL);
   1406 #endif
   1407 	error = ip_output(m, (struct mbuf *)0, &ipforward_rt,
   1408 	    (IP_FORWARDING | (ip_directedbcast ? IP_ALLOWBROADCAST : 0)), 0);
   1409 	if (error)
   1410 		ipstat.ips_cantforward++;
   1411 	else {
   1412 		ipstat.ips_forward++;
   1413 		if (type)
   1414 			ipstat.ips_redirectsent++;
   1415 		else {
   1416 			if (mcopy) {
   1417 #ifdef GATEWAY
   1418 				if (mcopy->m_flags & M_CANFASTFWD)
   1419 					ipflow_create(&ipforward_rt, mcopy);
   1420 #endif
   1421 				m_freem(mcopy);
   1422 			}
   1423 			return;
   1424 		}
   1425 	}
   1426 	if (mcopy == NULL)
   1427 		return;
   1428 	destifp = NULL;
   1429 
   1430 	switch (error) {
   1431 
   1432 	case 0:				/* forwarded, but need redirect */
   1433 		/* type, code set above */
   1434 		break;
   1435 
   1436 	case ENETUNREACH:		/* shouldn't happen, checked above */
   1437 	case EHOSTUNREACH:
   1438 	case ENETDOWN:
   1439 	case EHOSTDOWN:
   1440 	default:
   1441 		type = ICMP_UNREACH;
   1442 		code = ICMP_UNREACH_HOST;
   1443 		break;
   1444 
   1445 	case EMSGSIZE:
   1446 		type = ICMP_UNREACH;
   1447 		code = ICMP_UNREACH_NEEDFRAG;
   1448 #ifndef IPSEC
   1449 		if (ipforward_rt.ro_rt)
   1450 			destifp = ipforward_rt.ro_rt->rt_ifp;
   1451 #else
   1452 		/*
   1453 		 * If the packet is routed over IPsec tunnel, tell the
   1454 		 * originator the tunnel MTU.
   1455 		 *	tunnel MTU = if MTU - sizeof(IP) - ESP/AH hdrsiz
   1456 		 * XXX quickhack!!!
   1457 		 */
   1458 		if (ipforward_rt.ro_rt) {
   1459 			struct secpolicy *sp;
   1460 			int ipsecerror;
   1461 			size_t ipsechdr;
   1462 			struct route *ro;
   1463 
   1464 			sp = ipsec4_getpolicybyaddr(mcopy,
   1465 			                            IPSEC_DIR_OUTBOUND,
   1466 			                            IP_FORWARDING,
   1467 			                            &ipsecerror);
   1468 
   1469 			if (sp == NULL)
   1470 				destifp = ipforward_rt.ro_rt->rt_ifp;
   1471 			else {
   1472 				/* count IPsec header size */
   1473 				ipsechdr = ipsec4_hdrsiz(mcopy,
   1474 				                         IPSEC_DIR_OUTBOUND,
   1475 				                         NULL);
   1476 
   1477 				/*
   1478 				 * find the correct route for outer IPv4
   1479 				 * header, compute tunnel MTU.
   1480 				 *
   1481 				 * XXX BUG ALERT
   1482 				 * The "dummyifp" code relies upon the fact
   1483 				 * that icmp_error() touches only ifp->if_mtu.
   1484 				 */
   1485 				/*XXX*/
   1486 				destifp = NULL;
   1487 				if (sp->req != NULL
   1488 				 && sp->req->sav != NULL
   1489 				 && sp->req->sav->sah != NULL) {
   1490 					ro = &sp->req->sav->sah->sa_route;
   1491 					if (ro->ro_rt && ro->ro_rt->rt_ifp) {
   1492 						dummyifp.if_mtu =
   1493 						    ro->ro_rt->rt_ifp->if_mtu;
   1494 						dummyifp.if_mtu -= ipsechdr;
   1495 						destifp = &dummyifp;
   1496 					}
   1497 				}
   1498 
   1499 				key_freesp(sp);
   1500 			}
   1501 		}
   1502 #endif /*IPSEC*/
   1503 		ipstat.ips_cantfrag++;
   1504 		break;
   1505 
   1506 	case ENOBUFS:
   1507 		type = ICMP_SOURCEQUENCH;
   1508 		code = 0;
   1509 		break;
   1510 	}
   1511 	icmp_error(mcopy, type, code, dest, destifp);
   1512 }
   1513 
   1514 void
   1515 ip_savecontrol(inp, mp, ip, m)
   1516 	struct inpcb *inp;
   1517 	struct mbuf **mp;
   1518 	struct ip *ip;
   1519 	struct mbuf *m;
   1520 {
   1521 
   1522 	if (inp->inp_socket->so_options & SO_TIMESTAMP) {
   1523 		struct timeval tv;
   1524 
   1525 		microtime(&tv);
   1526 		*mp = sbcreatecontrol((caddr_t) &tv, sizeof(tv),
   1527 		    SCM_TIMESTAMP, SOL_SOCKET);
   1528 		if (*mp)
   1529 			mp = &(*mp)->m_next;
   1530 	}
   1531 	if (inp->inp_flags & INP_RECVDSTADDR) {
   1532 		*mp = sbcreatecontrol((caddr_t) &ip->ip_dst,
   1533 		    sizeof(struct in_addr), IP_RECVDSTADDR, IPPROTO_IP);
   1534 		if (*mp)
   1535 			mp = &(*mp)->m_next;
   1536 	}
   1537 #ifdef notyet
   1538 	/*
   1539 	 * XXX
   1540 	 * Moving these out of udp_input() made them even more broken
   1541 	 * than they already were.
   1542 	 *	- fenner (at) parc.xerox.com
   1543 	 */
   1544 	/* options were tossed already */
   1545 	if (inp->inp_flags & INP_RECVOPTS) {
   1546 		*mp = sbcreatecontrol((caddr_t) opts_deleted_above,
   1547 		    sizeof(struct in_addr), IP_RECVOPTS, IPPROTO_IP);
   1548 		if (*mp)
   1549 			mp = &(*mp)->m_next;
   1550 	}
   1551 	/* ip_srcroute doesn't do what we want here, need to fix */
   1552 	if (inp->inp_flags & INP_RECVRETOPTS) {
   1553 		*mp = sbcreatecontrol((caddr_t) ip_srcroute(),
   1554 		    sizeof(struct in_addr), IP_RECVRETOPTS, IPPROTO_IP);
   1555 		if (*mp)
   1556 			mp = &(*mp)->m_next;
   1557 	}
   1558 #endif
   1559 	if (inp->inp_flags & INP_RECVIF) {
   1560 		struct sockaddr_dl sdl;
   1561 
   1562 		sdl.sdl_len = offsetof(struct sockaddr_dl, sdl_data[0]);
   1563 		sdl.sdl_family = AF_LINK;
   1564 		sdl.sdl_index = m->m_pkthdr.rcvif ?
   1565 		    m->m_pkthdr.rcvif->if_index : 0;
   1566 		sdl.sdl_nlen = sdl.sdl_alen = sdl.sdl_slen = 0;
   1567 		*mp = sbcreatecontrol((caddr_t) &sdl, sdl.sdl_len,
   1568 		    IP_RECVIF, IPPROTO_IP);
   1569 		if (*mp)
   1570 			mp = &(*mp)->m_next;
   1571 	}
   1572 }
   1573 
   1574 int
   1575 ip_sysctl(name, namelen, oldp, oldlenp, newp, newlen)
   1576 	int *name;
   1577 	u_int namelen;
   1578 	void *oldp;
   1579 	size_t *oldlenp;
   1580 	void *newp;
   1581 	size_t newlen;
   1582 {
   1583 	extern int subnetsarelocal, hostzeroisbroadcast;
   1584 
   1585 	int error, old;
   1586 
   1587 	/* All sysctl names at this level are terminal. */
   1588 	if (namelen != 1)
   1589 		return (ENOTDIR);
   1590 
   1591 	switch (name[0]) {
   1592 	case IPCTL_FORWARDING:
   1593 		return (sysctl_int(oldp, oldlenp, newp, newlen, &ipforwarding));
   1594 	case IPCTL_SENDREDIRECTS:
   1595 		return (sysctl_int(oldp, oldlenp, newp, newlen,
   1596 			&ipsendredirects));
   1597 	case IPCTL_DEFTTL:
   1598 		return (sysctl_int(oldp, oldlenp, newp, newlen, &ip_defttl));
   1599 #ifdef notyet
   1600 	case IPCTL_DEFMTU:
   1601 		return (sysctl_int(oldp, oldlenp, newp, newlen, &ip_mtu));
   1602 #endif
   1603 	case IPCTL_FORWSRCRT:
   1604 		/* Don't allow this to change in a secure environment.  */
   1605 		if (securelevel > 0)
   1606 			return (sysctl_rdint(oldp, oldlenp, newp,
   1607 			    ip_forwsrcrt));
   1608 		else
   1609 			return (sysctl_int(oldp, oldlenp, newp, newlen,
   1610 			    &ip_forwsrcrt));
   1611 	case IPCTL_DIRECTEDBCAST:
   1612 		return (sysctl_int(oldp, oldlenp, newp, newlen,
   1613 		    &ip_directedbcast));
   1614 	case IPCTL_ALLOWSRCRT:
   1615 		return (sysctl_int(oldp, oldlenp, newp, newlen,
   1616 		    &ip_allowsrcrt));
   1617 	case IPCTL_SUBNETSARELOCAL:
   1618 		return (sysctl_int(oldp, oldlenp, newp, newlen,
   1619 		    &subnetsarelocal));
   1620 	case IPCTL_MTUDISC:
   1621 		error = sysctl_int(oldp, oldlenp, newp, newlen,
   1622 		    &ip_mtudisc);
   1623 		if (ip_mtudisc != 0 && ip_mtudisc_timeout_q == NULL) {
   1624 			ip_mtudisc_timeout_q =
   1625 			    rt_timer_queue_create(ip_mtudisc_timeout);
   1626 		} else if (ip_mtudisc == 0 && ip_mtudisc_timeout_q != NULL) {
   1627 			rt_timer_queue_destroy(ip_mtudisc_timeout_q, TRUE);
   1628 			ip_mtudisc_timeout_q = NULL;
   1629 		}
   1630 		return error;
   1631 	case IPCTL_ANONPORTMIN:
   1632 		old = anonportmin;
   1633 		error = sysctl_int(oldp, oldlenp, newp, newlen, &anonportmin);
   1634 		if (anonportmin >= anonportmax || anonportmin > 65535
   1635 #ifndef IPNOPRIVPORTS
   1636 		    || anonportmin < IPPORT_RESERVED
   1637 #endif
   1638 		    ) {
   1639 			anonportmin = old;
   1640 			return (EINVAL);
   1641 		}
   1642 		return (error);
   1643 	case IPCTL_ANONPORTMAX:
   1644 		old = anonportmax;
   1645 		error = sysctl_int(oldp, oldlenp, newp, newlen, &anonportmax);
   1646 		if (anonportmin >= anonportmax || anonportmax > 65535
   1647 #ifndef IPNOPRIVPORTS
   1648 		    || anonportmax < IPPORT_RESERVED
   1649 #endif
   1650 		    ) {
   1651 			anonportmax = old;
   1652 			return (EINVAL);
   1653 		}
   1654 		return (error);
   1655 	case IPCTL_MTUDISCTIMEOUT:
   1656 		error = sysctl_int(oldp, oldlenp, newp, newlen,
   1657 		   &ip_mtudisc_timeout);
   1658 		if (ip_mtudisc_timeout_q != NULL)
   1659 			rt_timer_queue_change(ip_mtudisc_timeout_q,
   1660 					      ip_mtudisc_timeout);
   1661 		return (error);
   1662 #ifdef GATEWAY
   1663 	case IPCTL_MAXFLOWS:
   1664 	    {
   1665 		int s;
   1666 
   1667 		error = sysctl_int(oldp, oldlenp, newp, newlen,
   1668 		   &ip_maxflows);
   1669 		s = splsoftnet();
   1670 		ipflow_reap(0);
   1671 		splx(s);
   1672 		return (error);
   1673 	    }
   1674 #endif
   1675 	case IPCTL_HOSTZEROBROADCAST:
   1676 		return (sysctl_int(oldp, oldlenp, newp, newlen,
   1677 		    &hostzeroisbroadcast));
   1678 #if NGIF > 0
   1679 	case IPCTL_GIF_TTL:
   1680 		return(sysctl_int(oldp, oldlenp, newp, newlen,
   1681 				  &ip_gif_ttl));
   1682 #endif
   1683 
   1684 	default:
   1685 		return (EOPNOTSUPP);
   1686 	}
   1687 	/* NOTREACHED */
   1688 }
   1689