1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 1982, 1986, 1988, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by the University of
|
|
|
|
* California, Berkeley and its contributors.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* @(#)ip_input.c 8.2 (Berkeley) 1/4/94
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
1998-01-09 03:21:07 +00:00
|
|
|
#include "opt_bootp.h"
|
1996-06-12 19:34:33 +00:00
|
|
|
#include "opt_ipfw.h"
|
1998-12-14 18:09:13 +00:00
|
|
|
#include "opt_ipdn.h"
|
1997-11-05 20:17:23 +00:00
|
|
|
#include "opt_ipdivert.h"
|
1998-03-21 11:34:28 +00:00
|
|
|
#include "opt_ipfilter.h"
|
1999-08-29 12:18:39 +00:00
|
|
|
#include "opt_ipstealth.h"
|
1999-12-22 19:13:38 +00:00
|
|
|
#include "opt_ipsec.h"
|
2002-07-31 17:17:51 +00:00
|
|
|
#include "opt_mac.h"
|
2000-07-31 13:11:42 +00:00
|
|
|
#include "opt_pfil_hooks.h"
|
2001-06-01 10:02:28 +00:00
|
|
|
#include "opt_random_ip_id.h"
|
1996-06-12 19:34:33 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
2002-07-31 17:17:51 +00:00
|
|
|
#include <sys/mac.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/mbuf.h>
|
1998-12-14 18:09:13 +00:00
|
|
|
#include <sys/malloc.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/domain.h>
|
|
|
|
#include <sys/protosw.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/kernel.h>
|
1995-03-16 18:22:28 +00:00
|
|
|
#include <sys/syslog.h>
|
1995-03-16 18:17:34 +00:00
|
|
|
#include <sys/sysctl.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2000-07-31 23:41:47 +00:00
|
|
|
#include <net/pfil.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <net/if.h>
|
2001-09-25 18:40:52 +00:00
|
|
|
#include <net/if_types.h>
|
1997-11-05 02:51:32 +00:00
|
|
|
#include <net/if_var.h>
|
1996-11-11 04:56:32 +00:00
|
|
|
#include <net/if_dl.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <net/route.h>
|
1995-05-11 00:13:26 +00:00
|
|
|
#include <net/netisr.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <netinet/in_systm.h>
|
1995-03-16 18:17:34 +00:00
|
|
|
#include <netinet/in_var.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <netinet/ip.h>
|
|
|
|
#include <netinet/in_pcb.h>
|
|
|
|
#include <netinet/ip_var.h>
|
|
|
|
#include <netinet/ip_icmp.h>
|
1996-10-07 19:21:46 +00:00
|
|
|
#include <machine/in_cksum.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1994-09-06 22:42:31 +00:00
|
|
|
#include <sys/socketvar.h>
|
1996-05-08 04:29:08 +00:00
|
|
|
|
|
|
|
#include <netinet/ip_fw.h>
|
2001-10-05 05:45:27 +00:00
|
|
|
#include <netinet/ip_dummynet.h>
|
|
|
|
|
1999-12-22 19:13:38 +00:00
|
|
|
#ifdef IPSEC
|
|
|
|
#include <netinet6/ipsec.h>
|
|
|
|
#include <netkey/key.h>
|
|
|
|
#endif
|
|
|
|
|
2002-10-16 02:25:05 +00:00
|
|
|
#ifdef FAST_IPSEC
|
|
|
|
#include <netipsec/ipsec.h>
|
|
|
|
#include <netipsec/key.h>
|
|
|
|
#endif
|
|
|
|
|
1995-06-13 17:51:16 +00:00
|
|
|
int rsvp_on = 0;
|
1994-09-06 22:42:31 +00:00
|
|
|
|
1998-05-19 14:04:36 +00:00
|
|
|
int ipforwarding = 0;
|
1995-11-14 20:34:56 +00:00
|
|
|
SYSCTL_INT(_net_inet_ip, IPCTL_FORWARDING, forwarding, CTLFLAG_RW,
|
1999-05-03 23:57:32 +00:00
|
|
|
&ipforwarding, 0, "Enable IP forwarding between interfaces");
|
1995-11-14 20:34:56 +00:00
|
|
|
|
1996-01-05 20:47:05 +00:00
|
|
|
static int ipsendredirects = 1; /* XXX */
|
1995-11-14 20:34:56 +00:00
|
|
|
SYSCTL_INT(_net_inet_ip, IPCTL_SENDREDIRECTS, redirect, CTLFLAG_RW,
|
1999-05-03 23:57:32 +00:00
|
|
|
&ipsendredirects, 0, "Enable sending IP redirects");
|
1995-11-14 20:34:56 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
int ip_defttl = IPDEFTTL;
|
1995-11-14 20:34:56 +00:00
|
|
|
SYSCTL_INT(_net_inet_ip, IPCTL_DEFTTL, ttl, CTLFLAG_RW,
|
1999-05-03 23:57:32 +00:00
|
|
|
&ip_defttl, 0, "Maximum TTL on IP packets");
|
1995-11-14 20:34:56 +00:00
|
|
|
|
|
|
|
static int ip_dosourceroute = 0;
|
|
|
|
SYSCTL_INT(_net_inet_ip, IPCTL_SOURCEROUTE, sourceroute, CTLFLAG_RW,
|
1999-05-03 23:57:32 +00:00
|
|
|
&ip_dosourceroute, 0, "Enable forwarding source routed IP packets");
|
1998-02-16 19:23:58 +00:00
|
|
|
|
|
|
|
static int ip_acceptsourceroute = 0;
|
1999-05-03 23:57:32 +00:00
|
|
|
SYSCTL_INT(_net_inet_ip, IPCTL_ACCEPTSOURCEROUTE, accept_sourceroute,
|
|
|
|
CTLFLAG_RW, &ip_acceptsourceroute, 0,
|
|
|
|
"Enable accepting source routed IP packets");
|
1999-12-22 19:13:38 +00:00
|
|
|
|
|
|
|
static int ip_keepfaith = 0;
|
|
|
|
SYSCTL_INT(_net_inet_ip, IPCTL_KEEPFAITH, keepfaith, CTLFLAG_RW,
|
|
|
|
&ip_keepfaith, 0,
|
|
|
|
"Enable packet capture for FAITH IPv4->IPv6 translater daemon");
|
|
|
|
|
2003-01-26 01:44:05 +00:00
|
|
|
static int nipq = 0; /* total # of reass queues */
|
|
|
|
static int maxnipq;
|
2001-06-03 23:33:23 +00:00
|
|
|
SYSCTL_INT(_net_inet_ip, OID_AUTO, maxfragpackets, CTLFLAG_RW,
|
2003-01-26 01:44:05 +00:00
|
|
|
&maxnipq, 0,
|
2001-06-03 23:33:23 +00:00
|
|
|
"Maximum number of IPv4 fragment reassembly queue entries");
|
|
|
|
|
2003-02-22 06:41:47 +00:00
|
|
|
static int maxfragsperpacket;
|
|
|
|
SYSCTL_INT(_net_inet_ip, OID_AUTO, maxfragsperpacket, CTLFLAG_RW,
|
|
|
|
&maxfragsperpacket, 0,
|
|
|
|
"Maximum number of IPv4 fragments allowed per packet");
|
|
|
|
|
2002-11-19 17:06:06 +00:00
|
|
|
static int ip_sendsourcequench = 0;
|
|
|
|
SYSCTL_INT(_net_inet_ip, OID_AUTO, sendsourcequench, CTLFLAG_RW,
|
|
|
|
&ip_sendsourcequench, 0,
|
|
|
|
"Enable the transmission of source quench packets");
|
|
|
|
|
2001-03-04 01:39:19 +00:00
|
|
|
/*
|
|
|
|
* XXX - Setting ip_checkinterface mostly implements the receive side of
|
|
|
|
* the Strong ES model described in RFC 1122, but since the routing table
|
2001-03-05 22:40:27 +00:00
|
|
|
* and transmit implementation do not implement the Strong ES model,
|
2001-03-04 01:39:19 +00:00
|
|
|
* setting this to 1 results in an odd hybrid.
|
2001-03-05 08:45:05 +00:00
|
|
|
*
|
2001-03-05 22:40:27 +00:00
|
|
|
* XXX - ip_checkinterface currently must be disabled if you use ipnat
|
|
|
|
* to translate the destination address to another local interface.
|
2001-03-05 08:45:05 +00:00
|
|
|
*
|
|
|
|
* XXX - ip_checkinterface must be disabled if you add IP aliases
|
|
|
|
* to the loopback interface instead of the interface where the
|
|
|
|
* packets for those addresses are received.
|
2001-03-04 01:39:19 +00:00
|
|
|
*/
|
2001-03-02 20:54:03 +00:00
|
|
|
static int ip_checkinterface = 1;
|
|
|
|
SYSCTL_INT(_net_inet_ip, OID_AUTO, check_interface, CTLFLAG_RW,
|
|
|
|
&ip_checkinterface, 0, "Verify packet arrives on correct interface");
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
1995-11-14 20:34:56 +00:00
|
|
|
static int ipprintfs = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
2003-09-23 17:54:04 +00:00
|
|
|
#ifdef PFIL_HOOKS
|
|
|
|
struct pfil_head inet_pfil_hook;
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2003-03-04 23:19:55 +00:00
|
|
|
static struct ifqueue ipintrq;
|
2001-09-29 04:34:11 +00:00
|
|
|
static int ipqmaxlen = IFQ_MAXLEN;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
extern struct domain inetdomain;
|
2001-09-03 20:03:55 +00:00
|
|
|
extern struct protosw inetsw[];
|
1994-05-24 10:09:53 +00:00
|
|
|
u_char ip_protox[IPPROTO_MAX];
|
2001-09-29 04:34:11 +00:00
|
|
|
struct in_ifaddrhead in_ifaddrhead; /* first inet address */
|
|
|
|
struct in_ifaddrhashhead *in_ifaddrhashtbl; /* inet addr hash table */
|
|
|
|
u_long in_ifaddrhmask; /* mask for hash table */
|
|
|
|
|
1999-05-27 12:20:33 +00:00
|
|
|
SYSCTL_INT(_net_inet_ip, IPCTL_INTRQMAXLEN, intr_queue_maxlen, CTLFLAG_RW,
|
1999-05-03 23:57:32 +00:00
|
|
|
&ipintrq.ifq_maxlen, 0, "Maximum size of the IP input queue");
|
1995-11-14 20:34:56 +00:00
|
|
|
SYSCTL_INT(_net_inet_ip, IPCTL_INTRQDROPS, intr_queue_drops, CTLFLAG_RD,
|
1999-05-03 23:57:32 +00:00
|
|
|
&ipintrq.ifq_drops, 0, "Number of packets dropped from the IP input queue");
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1994-08-18 22:36:09 +00:00
|
|
|
struct ipstat ipstat;
|
2001-06-23 17:17:59 +00:00
|
|
|
SYSCTL_STRUCT(_net_inet_ip, IPCTL_STATS, stats, CTLFLAG_RW,
|
1999-05-03 23:57:32 +00:00
|
|
|
&ipstat, ipstat, "IP statistics (struct ipstat, netinet/ip_var.h)");
|
1997-09-15 23:07:01 +00:00
|
|
|
|
|
|
|
/* Packet reassembly stuff */
|
|
|
|
#define IPREASS_NHASH_LOG2 6
|
|
|
|
#define IPREASS_NHASH (1 << IPREASS_NHASH_LOG2)
|
|
|
|
#define IPREASS_HMASK (IPREASS_NHASH - 1)
|
|
|
|
#define IPREASS_HASH(x,y) \
|
1999-01-27 22:42:27 +00:00
|
|
|
(((((x) & 0xF) | ((((x) >> 8) & 0xF) << 4)) ^ (y)) & IPREASS_HMASK)
|
1997-09-15 23:07:01 +00:00
|
|
|
|
2001-03-16 20:00:53 +00:00
|
|
|
static TAILQ_HEAD(ipqhead, ipq) ipq[IPREASS_NHASH];
|
2003-09-05 00:10:33 +00:00
|
|
|
struct mtx ipqlock;
|
|
|
|
|
|
|
|
#define IPQ_LOCK() mtx_lock(&ipqlock)
|
|
|
|
#define IPQ_UNLOCK() mtx_unlock(&ipqlock)
|
2003-10-14 18:45:50 +00:00
|
|
|
#define IPQ_LOCK_INIT() mtx_init(&ipqlock, "ipqlock", NULL, MTX_DEF)
|
|
|
|
#define IPQ_LOCK_ASSERT() mtx_assert(&ipqlock, MA_OWNED)
|
1994-08-18 22:36:09 +00:00
|
|
|
|
1995-11-14 20:34:56 +00:00
|
|
|
#ifdef IPCTL_DEFMTU
|
|
|
|
SYSCTL_INT(_net_inet_ip, IPCTL_DEFMTU, mtu, CTLFLAG_RW,
|
1999-05-03 23:57:32 +00:00
|
|
|
&ip_mtu, 0, "Default MTU");
|
1995-11-14 20:34:56 +00:00
|
|
|
#endif
|
|
|
|
|
1999-02-22 18:19:57 +00:00
|
|
|
#ifdef IPSTEALTH
|
2003-11-15 01:45:56 +00:00
|
|
|
int ipstealth = 0;
|
1999-02-22 18:19:57 +00:00
|
|
|
SYSCTL_INT(_net_inet_ip, OID_AUTO, stealth, CTLFLAG_RW,
|
|
|
|
&ipstealth, 0, "");
|
|
|
|
#endif
|
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
|
1996-04-03 13:52:20 +00:00
|
|
|
/* Firewall hooks */
|
|
|
|
ip_fw_chk_t *ip_fw_chk_ptr;
|
2000-02-10 17:56:01 +00:00
|
|
|
int fw_enable = 1 ;
|
2002-11-20 19:07:27 +00:00
|
|
|
int fw_one_pass = 1;
|
1996-02-23 15:47:58 +00:00
|
|
|
|
2001-10-05 05:45:27 +00:00
|
|
|
/* Dummynet hooks */
|
|
|
|
ip_dn_io_t *ip_dn_io_ptr;
|
1998-12-14 18:09:13 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2002-06-23 20:48:26 +00:00
|
|
|
* XXX this is ugly -- the following two global variables are
|
|
|
|
* used to store packet state while it travels through the stack.
|
|
|
|
* Note that the code even makes assumptions on the size and
|
|
|
|
* alignment of fields inside struct ip_srcrt so e.g. adding some
|
|
|
|
* fields will break the code. This needs to be fixed.
|
|
|
|
*
|
1994-05-24 10:09:53 +00:00
|
|
|
* We need to save the IP options in case a protocol wants to respond
|
|
|
|
* to an incoming packet over the same route if the packet got here
|
|
|
|
* using IP source routing. This allows connection establishment and
|
|
|
|
* maintenance when the remote end is on a network that is not known
|
|
|
|
* to us.
|
|
|
|
*/
|
1995-11-14 20:34:56 +00:00
|
|
|
static int ip_nhops = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
static struct ip_srcrt {
|
|
|
|
struct in_addr dst; /* final destination */
|
|
|
|
char nop; /* one NOP to align */
|
|
|
|
char srcopt[IPOPT_OFFSET + 1]; /* OPTVAL, OLEN and OFFSET */
|
|
|
|
struct in_addr route[MAX_IPOPTLEN/sizeof(struct in_addr)];
|
|
|
|
} ip_srcrt;
|
|
|
|
|
2002-03-19 21:25:46 +00:00
|
|
|
static void save_rte(u_char *, struct in_addr);
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
static int ip_dooptions(struct mbuf *m, int,
|
|
|
|
struct sockaddr_in *next_hop);
|
2003-11-14 21:48:57 +00:00
|
|
|
static void ip_forward(struct mbuf *m, int srcrt,
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
struct sockaddr_in *next_hop);
|
2002-03-19 21:25:46 +00:00
|
|
|
static void ip_freef(struct ipqhead *, struct ipq *);
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
static struct mbuf *ip_reass(struct mbuf *, struct ipqhead *,
|
|
|
|
struct ipq *, u_int32_t *, u_int16_t *);
|
1999-12-06 00:43:07 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* IP initialization: fill in IP protocol switch table.
|
|
|
|
* All protocols not implemented in kernel go to raw IP protocol handler.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ip_init()
|
|
|
|
{
|
2001-09-03 20:03:55 +00:00
|
|
|
register struct protosw *pr;
|
1994-05-24 10:09:53 +00:00
|
|
|
register int i;
|
|
|
|
|
1996-12-13 21:29:07 +00:00
|
|
|
TAILQ_INIT(&in_ifaddrhead);
|
2001-09-29 04:34:11 +00:00
|
|
|
in_ifaddrhashtbl = hashinit(INADDR_NHASH, M_IFADDR, &in_ifaddrhmask);
|
2001-09-03 20:03:55 +00:00
|
|
|
pr = pffindproto(PF_INET, IPPROTO_RAW, SOCK_RAW);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (pr == 0)
|
|
|
|
panic("ip_init");
|
|
|
|
for (i = 0; i < IPPROTO_MAX; i++)
|
|
|
|
ip_protox[i] = pr - inetsw;
|
2001-09-03 20:03:55 +00:00
|
|
|
for (pr = inetdomain.dom_protosw;
|
|
|
|
pr < inetdomain.dom_protoswNPROTOSW; pr++)
|
1994-05-24 10:09:53 +00:00
|
|
|
if (pr->pr_domain->dom_family == PF_INET &&
|
|
|
|
pr->pr_protocol && pr->pr_protocol != IPPROTO_RAW)
|
|
|
|
ip_protox[pr->pr_protocol] = pr - inetsw;
|
1997-09-15 23:07:01 +00:00
|
|
|
|
2003-09-23 17:54:04 +00:00
|
|
|
#ifdef PFIL_HOOKS
|
|
|
|
inet_pfil_hook.ph_type = PFIL_TYPE_AF;
|
|
|
|
inet_pfil_hook.ph_af = AF_INET;
|
|
|
|
if ((i = pfil_head_register(&inet_pfil_hook)) != 0)
|
|
|
|
printf("%s: WARNING: unable to register pfil hook, "
|
|
|
|
"error %d\n", __func__, i);
|
|
|
|
#endif /* PFIL_HOOKS */
|
|
|
|
|
2003-09-05 00:10:33 +00:00
|
|
|
IPQ_LOCK_INIT();
|
1997-09-15 23:07:01 +00:00
|
|
|
for (i = 0; i < IPREASS_NHASH; i++)
|
2001-03-16 20:00:53 +00:00
|
|
|
TAILQ_INIT(&ipq[i]);
|
1997-09-15 23:07:01 +00:00
|
|
|
|
2003-02-22 06:41:47 +00:00
|
|
|
maxnipq = nmbclusters / 32;
|
|
|
|
maxfragsperpacket = 16;
|
1997-09-15 23:07:01 +00:00
|
|
|
|
2001-06-01 10:02:28 +00:00
|
|
|
#ifndef RANDOM_IP_ID
|
1998-03-30 09:56:58 +00:00
|
|
|
ip_id = time_second & 0xffff;
|
2001-06-01 10:02:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
ipintrq.ifq_maxlen = ipqmaxlen;
|
2002-04-04 21:03:38 +00:00
|
|
|
mtx_init(&ipintrq.ifq_mtx, "ip_inq", NULL, MTX_DEF);
|
2003-11-08 22:28:40 +00:00
|
|
|
netisr_register(NETISR_IP, ip_input, &ipintrq, NETISR_MPSAFE);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ip input routine. Checksum and byte swap header. If fragmented
|
|
|
|
* try to reassemble. Process options. Pass to next level.
|
|
|
|
*/
|
1996-02-05 20:36:02 +00:00
|
|
|
void
|
|
|
|
ip_input(struct mbuf *m)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2003-11-14 21:02:22 +00:00
|
|
|
struct ip *ip = NULL;
|
1996-04-03 13:52:20 +00:00
|
|
|
struct ipq *fp;
|
2000-10-19 23:15:54 +00:00
|
|
|
struct in_ifaddr *ia = NULL;
|
2001-09-29 04:34:11 +00:00
|
|
|
struct ifaddr *ifa;
|
2003-11-14 21:02:22 +00:00
|
|
|
int i, checkif, hlen = 0;
|
|
|
|
int ours = 0;
|
1997-02-06 11:14:22 +00:00
|
|
|
u_short sum;
|
2001-02-27 19:43:14 +00:00
|
|
|
struct in_addr pkt_dst;
|
1999-12-06 00:43:07 +00:00
|
|
|
u_int32_t divert_info = 0; /* packet divert/tee info */
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
struct ip_fw_args args;
|
2003-11-14 21:48:57 +00:00
|
|
|
int dchg = 0; /* dest changed after fw */
|
2003-10-16 16:25:25 +00:00
|
|
|
#ifdef PFIL_HOOKS
|
|
|
|
struct in_addr odst; /* original dst address */
|
|
|
|
#endif
|
2002-10-16 02:25:05 +00:00
|
|
|
#ifdef FAST_IPSEC
|
|
|
|
struct m_tag *mtag;
|
|
|
|
struct tdb_ident *tdbi;
|
|
|
|
struct secpolicy *sp;
|
|
|
|
int s, error;
|
|
|
|
#endif /* FAST_IPSEC */
|
1999-12-06 00:43:07 +00:00
|
|
|
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
args.eh = NULL;
|
|
|
|
args.oif = NULL;
|
|
|
|
args.rule = NULL;
|
|
|
|
args.divert_rule = 0; /* divert cookie */
|
|
|
|
args.next_hop = NULL;
|
1998-12-14 18:09:13 +00:00
|
|
|
|
2003-11-14 21:02:22 +00:00
|
|
|
/*
|
|
|
|
* Grab info from MT_TAG mbufs prepended to the chain.
|
|
|
|
*
|
|
|
|
* XXX: This is ugly. These pseudo mbuf prepend tags should really
|
|
|
|
* be real m_tags. Before these have always been allocated on the
|
|
|
|
* callers stack, so we didn't have to free them. Now with
|
|
|
|
* ip_fastforward they are true mbufs and we have to free them
|
|
|
|
* otherwise we have a leak. Must rewrite ipfw to use m_tags.
|
|
|
|
*/
|
|
|
|
for (; m && m->m_type == MT_TAG;) {
|
|
|
|
struct mbuf *m0;
|
|
|
|
|
2002-10-16 01:54:46 +00:00
|
|
|
switch(m->_m_tag_id) {
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
default:
|
|
|
|
printf("ip_input: unrecognised MT_TAG tag %d\n",
|
2002-10-16 01:54:46 +00:00
|
|
|
m->_m_tag_id);
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case PACKET_TAG_DUMMYNET:
|
|
|
|
args.rule = ((struct dn_pkt *)m)->rule;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PACKET_TAG_DIVERT:
|
2002-06-27 11:02:06 +00:00
|
|
|
args.divert_rule = (intptr_t)m->m_hdr.mh_data & 0xffff;
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case PACKET_TAG_IPFORWARD:
|
|
|
|
args.next_hop = (struct sockaddr_in *)m->m_hdr.mh_data;
|
|
|
|
break;
|
2003-11-14 21:02:22 +00:00
|
|
|
|
|
|
|
case PACKET_TAG_IPFASTFWD_OURS:
|
|
|
|
ours = 1;
|
|
|
|
break;
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
}
|
2003-11-14 21:02:22 +00:00
|
|
|
|
|
|
|
m0 = m;
|
|
|
|
m = m->m_next;
|
|
|
|
/* XXX: This is set by ip_fastforward */
|
|
|
|
if (m0->m_nextpkt == (struct mbuf *)1)
|
|
|
|
m_free(m0);
|
2002-06-23 09:15:43 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2003-04-08 14:25:47 +00:00
|
|
|
M_ASSERTPKTHDR(m);
|
2002-05-21 18:52:24 +00:00
|
|
|
|
2003-11-14 21:02:22 +00:00
|
|
|
if (ours) /* ip_fastforward firewall changed dest to local */
|
|
|
|
goto ours;
|
|
|
|
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
if (args.rule) { /* dummynet already filtered us */
|
|
|
|
ip = mtod(m, struct ip *);
|
2002-10-20 22:52:07 +00:00
|
|
|
hlen = ip->ip_hl << 2;
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
goto iphack ;
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
ipstat.ips_total++;
|
1996-10-07 19:21:46 +00:00
|
|
|
|
|
|
|
if (m->m_pkthdr.len < sizeof(struct ip))
|
|
|
|
goto tooshort;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
if (m->m_len < sizeof (struct ip) &&
|
|
|
|
(m = m_pullup(m, sizeof (struct ip))) == 0) {
|
|
|
|
ipstat.ips_toosmall++;
|
1996-02-05 20:36:02 +00:00
|
|
|
return;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
ip = mtod(m, struct ip *);
|
1996-10-07 19:21:46 +00:00
|
|
|
|
2002-10-20 22:52:07 +00:00
|
|
|
if (ip->ip_v != IPVERSION) {
|
1994-05-24 10:09:53 +00:00
|
|
|
ipstat.ips_badvers++;
|
|
|
|
goto bad;
|
|
|
|
}
|
1996-10-07 19:21:46 +00:00
|
|
|
|
2002-10-20 22:52:07 +00:00
|
|
|
hlen = ip->ip_hl << 2;
|
1994-05-24 10:09:53 +00:00
|
|
|
if (hlen < sizeof(struct ip)) { /* minimum header length */
|
|
|
|
ipstat.ips_badhlen++;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
if (hlen > m->m_len) {
|
|
|
|
if ((m = m_pullup(m, hlen)) == 0) {
|
|
|
|
ipstat.ips_badhlen++;
|
1996-02-05 20:36:02 +00:00
|
|
|
return;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
ip = mtod(m, struct ip *);
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
|
|
|
|
/* 127/8 must not appear on wire - RFC1122 */
|
|
|
|
if ((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||
|
|
|
|
(ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) {
|
|
|
|
if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) == 0) {
|
|
|
|
ipstat.ips_badaddr++;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-03-27 19:14:27 +00:00
|
|
|
if (m->m_pkthdr.csum_flags & CSUM_IP_CHECKED) {
|
|
|
|
sum = !(m->m_pkthdr.csum_flags & CSUM_IP_VALID);
|
1996-10-07 19:21:46 +00:00
|
|
|
} else {
|
2000-03-27 19:14:27 +00:00
|
|
|
if (hlen == sizeof(struct ip)) {
|
|
|
|
sum = in_cksum_hdr(ip);
|
|
|
|
} else {
|
|
|
|
sum = in_cksum(m, hlen);
|
|
|
|
}
|
1996-10-07 19:21:46 +00:00
|
|
|
}
|
1997-02-06 11:14:22 +00:00
|
|
|
if (sum) {
|
1994-05-24 10:09:53 +00:00
|
|
|
ipstat.ips_badsum++;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert fields to host representation.
|
|
|
|
*/
|
2002-02-18 20:35:27 +00:00
|
|
|
ip->ip_len = ntohs(ip->ip_len);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ip->ip_len < hlen) {
|
|
|
|
ipstat.ips_badlen++;
|
|
|
|
goto bad;
|
|
|
|
}
|
2002-02-18 20:35:27 +00:00
|
|
|
ip->ip_off = ntohs(ip->ip_off);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check that the amount of data in the buffers
|
|
|
|
* is as at least much as the IP header would have us expect.
|
|
|
|
* Trim mbufs if longer than we expect.
|
|
|
|
* Drop packet if shorter than we expect.
|
|
|
|
*/
|
|
|
|
if (m->m_pkthdr.len < ip->ip_len) {
|
1996-10-07 19:21:46 +00:00
|
|
|
tooshort:
|
1994-05-24 10:09:53 +00:00
|
|
|
ipstat.ips_tooshort++;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
if (m->m_pkthdr.len > ip->ip_len) {
|
|
|
|
if (m->m_len == m->m_pkthdr.len) {
|
|
|
|
m->m_len = ip->ip_len;
|
|
|
|
m->m_pkthdr.len = ip->ip_len;
|
|
|
|
} else
|
|
|
|
m_adj(m, ip->ip_len - m->m_pkthdr.len);
|
|
|
|
}
|
2003-02-23 00:47:06 +00:00
|
|
|
#if defined(IPSEC) && !defined(IPSEC_FILTERGIF)
|
|
|
|
/*
|
|
|
|
* Bypass packet filtering for packets from a tunnel (gif).
|
|
|
|
*/
|
- cleanup SP refcnt issue.
- share policy-on-socket for listening socket.
- don't copy policy-on-socket at all. secpolicy no longer contain
spidx, which saves a lot of memory.
- deep-copy pcb policy if it is an ipsec policy. assign ID field to
all SPD entries. make it possible for racoon to grab SPD entry on
pcb.
- fixed the order of searching SA table for packets.
- fixed to get a security association header. a mode is always needed
to compare them.
- fixed that the incorrect time was set to
sadb_comb_{hard|soft}_usetime.
- disallow port spec for tunnel mode policy (as we don't reassemble).
- an user can define a policy-id.
- clear enc/auth key before freeing.
- fixed that the kernel crashed when key_spdacquire() was called
because key_spdacquire() had been implemented imcopletely.
- preparation for 64bit sequence number.
- maintain ordered list of SA, based on SA id.
- cleanup secasvar management; refcnt is key.c responsibility;
alloc/free is keydb.c responsibility.
- cleanup, avoid double-loop.
- use hash for spi-based lookup.
- mark persistent SP "persistent".
XXX in theory refcnt should do the right thing, however, we have
"spdflush" which would touch all SPs. another solution would be to
de-register persistent SPs from sptree.
- u_short -> u_int16_t
- reduce kernel stack usage by auto variable secasindex.
- clarify function name confusion. ipsec_*_policy ->
ipsec_*_pcbpolicy.
- avoid variable name confusion.
(struct inpcbpolicy *)pcb_sp, spp (struct secpolicy **), sp (struct
secpolicy *)
- count number of ipsec encapsulations on ipsec4_output, so that we
can tell ip_output() how to handle the packet further.
- When the value of the ul_proto is ICMP or ICMPV6, the port field in
"src" of the spidx specifies ICMP type, and the port field in "dst"
of the spidx specifies ICMP code.
- avoid from applying IPsec transport mode to the packets when the
kernel forwards the packets.
Tested by: nork
Obtained from: KAME
2003-11-04 16:02:05 +00:00
|
|
|
if (ipsec_getnhist(m))
|
2003-02-23 00:47:06 +00:00
|
|
|
goto pass;
|
|
|
|
#endif
|
2003-07-22 18:58:34 +00:00
|
|
|
#if defined(FAST_IPSEC) && !defined(IPSEC_FILTERGIF)
|
|
|
|
/*
|
|
|
|
* Bypass packet filtering for packets from a tunnel (gif).
|
|
|
|
*/
|
|
|
|
if (m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL) != NULL)
|
|
|
|
goto pass;
|
|
|
|
#endif
|
2001-03-05 08:45:05 +00:00
|
|
|
|
1995-01-12 13:06:32 +00:00
|
|
|
/*
|
|
|
|
* IpHack's section.
|
|
|
|
* Right now when no processing on packet has done
|
|
|
|
* and it is still fresh out of network we do our black
|
|
|
|
* deals with it.
|
1996-07-10 19:44:30 +00:00
|
|
|
* - Firewall: deny/allow/divert
|
1996-08-21 21:37:07 +00:00
|
|
|
* - Xlate: translate packet's addr/port (NAT).
|
1998-12-14 18:09:13 +00:00
|
|
|
* - Pipe: pass pkt through dummynet.
|
1995-01-12 13:06:32 +00:00
|
|
|
* - Wrap: fake packet's addr/port <unimpl.>
|
|
|
|
* - Encapsulate: put it in another IP and send out. <unimp.>
|
|
|
|
*/
|
1998-12-14 18:09:13 +00:00
|
|
|
|
|
|
|
iphack:
|
2000-07-31 13:11:42 +00:00
|
|
|
|
|
|
|
#ifdef PFIL_HOOKS
|
1997-04-03 10:47:12 +00:00
|
|
|
/*
|
2003-09-23 17:54:04 +00:00
|
|
|
* Run through list of hooks for input packets.
|
2003-10-16 16:25:25 +00:00
|
|
|
*
|
|
|
|
* NB: Beware of the destination address changing (e.g.
|
|
|
|
* by NAT rewriting). When this happens, tell
|
|
|
|
* ip_forward to do the right thing.
|
1997-04-03 10:47:12 +00:00
|
|
|
*/
|
2003-10-16 16:25:25 +00:00
|
|
|
odst = ip->ip_dst;
|
2003-09-23 17:54:04 +00:00
|
|
|
if (pfil_run_hooks(&inet_pfil_hook, &m, m->m_pkthdr.rcvif,
|
|
|
|
PFIL_IN) != 0)
|
|
|
|
return;
|
|
|
|
if (m == NULL) /* consumed by filter */
|
|
|
|
return;
|
|
|
|
ip = mtod(m, struct ip *);
|
2003-11-14 21:48:57 +00:00
|
|
|
dchg = (odst.s_addr != ip->ip_dst.s_addr);
|
2000-07-31 13:11:42 +00:00
|
|
|
#endif /* PFIL_HOOKS */
|
1995-01-12 13:06:32 +00:00
|
|
|
|
2001-11-04 22:56:25 +00:00
|
|
|
if (fw_enable && IPFW_LOADED) {
|
1998-07-06 03:20:19 +00:00
|
|
|
/*
|
|
|
|
* If we've been forwarded from the output side, then
|
|
|
|
* skip the firewall a second time
|
|
|
|
*/
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
if (args.next_hop)
|
1998-07-06 03:20:19 +00:00
|
|
|
goto ours;
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
|
|
|
|
args.m = m;
|
|
|
|
i = ip_fw_chk_ptr(&args);
|
|
|
|
m = args.m;
|
|
|
|
|
2002-05-09 10:34:57 +00:00
|
|
|
if ( (i & IP_FW_PORT_DENY_FLAG) || m == NULL) { /* drop */
|
2001-12-14 19:33:29 +00:00
|
|
|
if (m)
|
|
|
|
m_freem(m);
|
|
|
|
return;
|
2001-02-02 00:18:00 +00:00
|
|
|
}
|
2002-05-09 10:34:57 +00:00
|
|
|
ip = mtod(m, struct ip *); /* just in case m changed */
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
if (i == 0 && args.next_hop == NULL) /* common case */
|
1999-12-06 00:43:07 +00:00
|
|
|
goto pass;
|
2001-11-04 22:56:25 +00:00
|
|
|
if (DUMMYNET_LOADED && (i & IP_FW_PORT_DYNT_FLAG) != 0) {
|
2002-06-23 09:15:43 +00:00
|
|
|
/* Send packet to the appropriate pipe */
|
|
|
|
ip_dn_io_ptr(m, i&0xffff, DN_TO_IP_IN, &args);
|
1999-12-06 00:43:07 +00:00
|
|
|
return;
|
1998-12-14 18:09:13 +00:00
|
|
|
}
|
1998-07-06 03:20:19 +00:00
|
|
|
#ifdef IPDIVERT
|
1999-12-06 00:43:07 +00:00
|
|
|
if (i != 0 && (i & IP_FW_PORT_DYNT_FLAG) == 0) {
|
|
|
|
/* Divert or tee packet */
|
|
|
|
divert_info = i;
|
1996-07-10 19:44:30 +00:00
|
|
|
goto ours;
|
1997-06-02 05:02:37 +00:00
|
|
|
}
|
1998-12-14 18:09:13 +00:00
|
|
|
#endif
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
if (i == 0 && args.next_hop != NULL)
|
1999-12-06 00:43:07 +00:00
|
|
|
goto pass;
|
1998-07-06 03:20:19 +00:00
|
|
|
/*
|
1998-12-14 18:09:13 +00:00
|
|
|
* if we get here, the packet must be dropped
|
1998-07-06 03:20:19 +00:00
|
|
|
*/
|
1999-12-06 00:43:07 +00:00
|
|
|
m_freem(m);
|
|
|
|
return;
|
1996-07-10 19:44:30 +00:00
|
|
|
}
|
1998-12-14 18:09:13 +00:00
|
|
|
pass:
|
1994-10-28 15:09:49 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Process options and, if not destined for us,
|
|
|
|
* ship it on. ip_dooptions returns 1 when an
|
|
|
|
* error was detected (causing an icmp message
|
|
|
|
* to be sent and the original packet to be freed).
|
|
|
|
*/
|
|
|
|
ip_nhops = 0; /* for source routed packets */
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
if (hlen > sizeof (struct ip) && ip_dooptions(m, 0, args.next_hop))
|
1996-02-05 20:36:02 +00:00
|
|
|
return;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1994-09-06 22:42:31 +00:00
|
|
|
/* greedy RSVP, snatches any PATH packet of the RSVP protocol and no
|
1995-06-13 17:51:16 +00:00
|
|
|
* matter if it is destined to another node, or whether it is
|
1994-09-06 22:42:31 +00:00
|
|
|
* a multicast one, RSVP wants it! and prevents it from being forwarded
|
|
|
|
* anywhere else. Also checks if the rsvp daemon is running before
|
|
|
|
* grabbing the packet.
|
|
|
|
*/
|
1995-06-13 17:51:16 +00:00
|
|
|
if (rsvp_on && ip->ip_p==IPPROTO_RSVP)
|
1994-09-06 22:42:31 +00:00
|
|
|
goto ours;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Check our list of addresses, to see if the packet is for us.
|
1999-02-09 16:55:46 +00:00
|
|
|
* If we don't have any addresses, assume any unicast packet
|
|
|
|
* we receive might be for us (and let the upper layers deal
|
|
|
|
* with it).
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1999-02-09 16:55:46 +00:00
|
|
|
if (TAILQ_EMPTY(&in_ifaddrhead) &&
|
|
|
|
(m->m_flags & (M_MCAST|M_BCAST)) == 0)
|
|
|
|
goto ours;
|
|
|
|
|
2001-02-27 19:43:14 +00:00
|
|
|
/*
|
|
|
|
* Cache the destination address of the packet; this may be
|
|
|
|
* changed by use of 'ipfw fwd'.
|
|
|
|
*/
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
pkt_dst = args.next_hop ? args.next_hop->sin_addr : ip->ip_dst;
|
2001-02-27 19:43:14 +00:00
|
|
|
|
2001-03-04 01:39:19 +00:00
|
|
|
/*
|
|
|
|
* Enable a consistency check between the destination address
|
|
|
|
* and the arrival interface for a unicast packet (the RFC 1122
|
|
|
|
* strong ES model) if IP forwarding is disabled and the packet
|
2001-03-04 03:22:36 +00:00
|
|
|
* is not locally generated and the packet is not subject to
|
|
|
|
* 'ipfw fwd'.
|
2001-03-05 08:45:05 +00:00
|
|
|
*
|
2001-11-04 22:56:25 +00:00
|
|
|
* XXX - Checking also should be disabled if the destination
|
2001-03-05 08:45:05 +00:00
|
|
|
* address is ipnat'ed to a different interface.
|
|
|
|
*
|
2001-03-05 22:40:27 +00:00
|
|
|
* XXX - Checking is incompatible with IP aliases added
|
2001-03-05 08:45:05 +00:00
|
|
|
* to the loopback interface instead of the interface where
|
|
|
|
* the packets are received.
|
2001-03-04 01:39:19 +00:00
|
|
|
*/
|
|
|
|
checkif = ip_checkinterface && (ipforwarding == 0) &&
|
2001-09-25 18:40:52 +00:00
|
|
|
m->m_pkthdr.rcvif != NULL &&
|
2001-03-04 03:22:36 +00:00
|
|
|
((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) == 0) &&
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
(args.next_hop == NULL);
|
2001-03-04 01:39:19 +00:00
|
|
|
|
2001-09-29 04:34:11 +00:00
|
|
|
/*
|
|
|
|
* Check for exact addresses in the hash bucket.
|
|
|
|
*/
|
|
|
|
LIST_FOREACH(ia, INADDR_HASH(pkt_dst.s_addr), ia_hash) {
|
1998-07-06 03:20:19 +00:00
|
|
|
/*
|
2001-03-04 01:39:19 +00:00
|
|
|
* If the address matches, verify that the packet
|
|
|
|
* arrived via the correct interface if checking is
|
|
|
|
* enabled.
|
1998-07-06 03:20:19 +00:00
|
|
|
*/
|
2001-03-04 01:39:19 +00:00
|
|
|
if (IA_SIN(ia)->sin_addr.s_addr == pkt_dst.s_addr &&
|
|
|
|
(!checkif || ia->ia_ifp == m->m_pkthdr.rcvif))
|
1999-03-12 01:15:57 +00:00
|
|
|
goto ours;
|
2001-09-29 04:34:11 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Check for broadcast addresses.
|
|
|
|
*
|
|
|
|
* Only accept broadcast packets that arrive via the matching
|
|
|
|
* interface. Reception of forwarded directed broadcasts would
|
|
|
|
* be handled via ip_forward() and ether_output() with the loopback
|
|
|
|
* into the stack for SIMPLEX interfaces handled by ether_output().
|
|
|
|
*/
|
|
|
|
if (m->m_pkthdr.rcvif->if_flags & IFF_BROADCAST) {
|
|
|
|
TAILQ_FOREACH(ifa, &m->m_pkthdr.rcvif->if_addrhead, ifa_link) {
|
|
|
|
if (ifa->ifa_addr->sa_family != AF_INET)
|
|
|
|
continue;
|
|
|
|
ia = ifatoia(ifa);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (satosin(&ia->ia_broadaddr)->sin_addr.s_addr ==
|
2001-02-27 19:43:14 +00:00
|
|
|
pkt_dst.s_addr)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto ours;
|
2001-02-27 19:43:14 +00:00
|
|
|
if (ia->ia_netbroadcast.s_addr == pkt_dst.s_addr)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto ours;
|
2001-09-29 04:34:11 +00:00
|
|
|
#ifdef BOOTP_COMPAT
|
|
|
|
if (IA_SIN(ia)->sin_addr.s_addr == INADDR_ANY)
|
|
|
|
goto ours;
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) {
|
|
|
|
struct in_multi *inm;
|
|
|
|
if (ip_mrouter) {
|
|
|
|
/*
|
|
|
|
* If we are acting as a multicast router, all
|
|
|
|
* 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.
|
|
|
|
*/
|
Massive cleanup of the ip_mroute code.
No functional changes, but:
+ the mrouting module now should behave the same as the compiled-in
version (it did not before, some of the rsvp code was not loaded
properly);
+ netinet/ip_mroute.c is now truly optional;
+ removed some redundant/unused code;
+ changed many instances of '0' to NULL and INADDR_ANY as appropriate;
+ removed several static variables to make the code more SMP-friendly;
+ fixed some minor bugs in the mrouting code (mostly, incorrect return
values from functions).
This commit is also a prerequisite to the addition of support for PIM,
which i would like to put in before DP2 (it does not change any of
the existing APIs, anyways).
Note, in the process we found out that some device drivers fail to
properly handle changes in IFF_ALLMULTI, leading to interesting
behaviour when a multicast router is started. This bug is not
corrected by this commit, and will be fixed with a separate commit.
Detailed changes:
--------------------
netinet/ip_mroute.c all the above.
conf/files make ip_mroute.c optional
net/route.c fix mrt_ioctl hook
netinet/ip_input.c fix ip_mforward hook, move rsvp_input() here
together with other rsvp code, and a couple
of indentation fixes.
netinet/ip_output.c fix ip_mforward and ip_mcast_src hooks
netinet/ip_var.h rsvp function hooks
netinet/raw_ip.c hooks for mrouting and rsvp functions, plus
interface cleanup.
netinet/ip_mroute.h remove an unused and optional field from a struct
Most of the code is from Pavlin Radoslavov and the XORP project
Reviewed by: sam
MFC after: 1 week
2002-11-15 22:53:53 +00:00
|
|
|
if (ip_mforward &&
|
|
|
|
ip_mforward(ip, m->m_pkthdr.rcvif, m, 0) != 0) {
|
1994-05-24 10:09:53 +00:00
|
|
|
ipstat.ips_cantforward++;
|
|
|
|
m_freem(m);
|
1996-02-05 20:36:02 +00:00
|
|
|
return;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2002-05-12 00:22:38 +00:00
|
|
|
* The process-level routing daemon needs to receive
|
1994-05-24 10:09:53 +00:00
|
|
|
* 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++;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* 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) {
|
1997-01-21 21:08:09 +00:00
|
|
|
ipstat.ips_notmember++;
|
1994-05-24 10:09:53 +00:00
|
|
|
m_freem(m);
|
1996-02-05 20:36:02 +00:00
|
|
|
return;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
goto ours;
|
|
|
|
}
|
|
|
|
if (ip->ip_dst.s_addr == (u_long)INADDR_BROADCAST)
|
|
|
|
goto ours;
|
|
|
|
if (ip->ip_dst.s_addr == INADDR_ANY)
|
|
|
|
goto ours;
|
|
|
|
|
1999-12-22 19:13:38 +00:00
|
|
|
/*
|
|
|
|
* FAITH(Firewall Aided Internet Translator)
|
|
|
|
*/
|
|
|
|
if (m->m_pkthdr.rcvif && m->m_pkthdr.rcvif->if_type == IFT_FAITH) {
|
|
|
|
if (ip_keepfaith) {
|
|
|
|
if (ip->ip_p == IPPROTO_TCP || ip->ip_p == IPPROTO_ICMP)
|
|
|
|
goto ours;
|
|
|
|
}
|
|
|
|
m_freem(m);
|
|
|
|
return;
|
|
|
|
}
|
2001-09-25 18:40:52 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Not for us; forward if possible and desirable.
|
|
|
|
*/
|
|
|
|
if (ipforwarding == 0) {
|
|
|
|
ipstat.ips_cantforward++;
|
2001-02-21 16:59:47 +00:00
|
|
|
m_freem(m);
|
2002-02-26 02:11:13 +00:00
|
|
|
} else {
|
|
|
|
#ifdef IPSEC
|
|
|
|
/*
|
|
|
|
* Enforce inbound IPsec SPD.
|
|
|
|
*/
|
|
|
|
if (ipsec4_in_reject(m, NULL)) {
|
|
|
|
ipsecstat.in_polvio++;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
#endif /* IPSEC */
|
2002-10-16 02:25:05 +00:00
|
|
|
#ifdef FAST_IPSEC
|
|
|
|
mtag = m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL);
|
|
|
|
s = splnet();
|
|
|
|
if (mtag != NULL) {
|
|
|
|
tdbi = (struct tdb_ident *)(mtag + 1);
|
|
|
|
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);
|
|
|
|
/*XXX error stat???*/
|
|
|
|
DPRINTF(("ip_input: no SP for forwarding\n")); /*XXX*/
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check security policy against packet attributes.
|
|
|
|
*/
|
|
|
|
error = ipsec_in_reject(sp, m);
|
|
|
|
KEY_FREESP(&sp);
|
|
|
|
splx(s);
|
|
|
|
if (error) {
|
|
|
|
ipstat.ips_cantforward++;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
#endif /* FAST_IPSEC */
|
2003-11-14 21:48:57 +00:00
|
|
|
ip_forward(m, dchg, args.next_hop);
|
2002-02-26 02:11:13 +00:00
|
|
|
}
|
1996-02-05 20:36:02 +00:00
|
|
|
return;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
ours:
|
2001-12-29 09:24:18 +00:00
|
|
|
#ifdef IPSTEALTH
|
|
|
|
/*
|
|
|
|
* IPSTEALTH: Process non-routing options only
|
|
|
|
* if the packet is destined for us.
|
|
|
|
*/
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
if (ipstealth && hlen > sizeof (struct ip) &&
|
|
|
|
ip_dooptions(m, 1, args.next_hop))
|
2001-12-29 09:24:18 +00:00
|
|
|
return;
|
|
|
|
#endif /* IPSTEALTH */
|
|
|
|
|
2000-10-19 23:15:54 +00:00
|
|
|
/* Count the packet in the ip address stats */
|
|
|
|
if (ia != NULL) {
|
|
|
|
ia->ia_ifa.if_ipackets++;
|
|
|
|
ia->ia_ifa.if_ibytes += m->m_pkthdr.len;
|
|
|
|
}
|
1994-10-28 15:09:49 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* If offset or IP_MF are set, must reassemble.
|
|
|
|
* Otherwise, nothing need be done.
|
|
|
|
* (We could look in the reassembly queue to see
|
|
|
|
* if the packet was previously fragmented,
|
|
|
|
* but it's not worth the time; just let them time out.)
|
|
|
|
*/
|
2000-10-26 13:14:48 +00:00
|
|
|
if (ip->ip_off & (IP_MF | IP_OFFMASK)) {
|
1999-12-22 19:13:38 +00:00
|
|
|
|
2003-02-01 05:59:51 +00:00
|
|
|
/* If maxnipq is 0, never accept fragments. */
|
2003-01-28 03:39:39 +00:00
|
|
|
if (maxnipq == 0) {
|
|
|
|
ipstat.ips_fragments++;
|
|
|
|
ipstat.ips_fragdropped++;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
1997-09-15 23:07:01 +00:00
|
|
|
sum = IPREASS_HASH(ip->ip_src.s_addr, ip->ip_id);
|
2003-09-05 00:10:33 +00:00
|
|
|
IPQ_LOCK();
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Look for queue of fragments
|
|
|
|
* of this datagram.
|
|
|
|
*/
|
2001-03-16 20:00:53 +00:00
|
|
|
TAILQ_FOREACH(fp, &ipq[sum], ipq_list)
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ip->ip_id == fp->ipq_id &&
|
|
|
|
ip->ip_src.s_addr == fp->ipq_src.s_addr &&
|
|
|
|
ip->ip_dst.s_addr == fp->ipq_dst.s_addr &&
|
2002-07-31 17:17:51 +00:00
|
|
|
#ifdef MAC
|
|
|
|
mac_fragment_match(m, fp) &&
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
ip->ip_p == fp->ipq_p)
|
|
|
|
goto found;
|
1997-09-15 23:07:01 +00:00
|
|
|
|
2003-06-06 19:32:48 +00:00
|
|
|
fp = NULL;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2003-01-28 03:39:39 +00:00
|
|
|
/*
|
|
|
|
* Enforce upper bound on number of fragmented packets
|
|
|
|
* for which we attempt reassembly;
|
|
|
|
* If maxnipq is -1, accept all fragments without limitation.
|
|
|
|
*/
|
|
|
|
if ((nipq > maxnipq) && (maxnipq > 0)) {
|
1997-09-15 23:07:01 +00:00
|
|
|
/*
|
|
|
|
* drop something from the tail of the current queue
|
|
|
|
* before proceeding further
|
|
|
|
*/
|
2001-03-16 20:00:53 +00:00
|
|
|
struct ipq *q = TAILQ_LAST(&ipq[sum], ipqhead);
|
|
|
|
if (q == NULL) { /* gak */
|
1997-09-15 23:07:01 +00:00
|
|
|
for (i = 0; i < IPREASS_NHASH; i++) {
|
2001-03-16 20:00:53 +00:00
|
|
|
struct ipq *r = TAILQ_LAST(&ipq[i], ipqhead);
|
|
|
|
if (r) {
|
2003-02-25 11:49:01 +00:00
|
|
|
ipstat.ips_fragtimeout += r->ipq_nfrags;
|
2001-03-16 20:00:53 +00:00
|
|
|
ip_freef(&ipq[i], r);
|
1997-09-15 23:07:01 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2003-01-28 03:39:39 +00:00
|
|
|
} else {
|
2003-02-25 11:49:01 +00:00
|
|
|
ipstat.ips_fragtimeout += q->ipq_nfrags;
|
2001-03-16 20:00:53 +00:00
|
|
|
ip_freef(&ipq[sum], q);
|
2003-01-28 03:39:39 +00:00
|
|
|
}
|
1997-09-15 23:07:01 +00:00
|
|
|
}
|
|
|
|
found:
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Adjust ip_len to not reflect header,
|
|
|
|
* convert offset of this to bytes.
|
|
|
|
*/
|
|
|
|
ip->ip_len -= hlen;
|
2000-10-26 13:14:48 +00:00
|
|
|
if (ip->ip_off & IP_MF) {
|
1998-08-24 07:47:39 +00:00
|
|
|
/*
|
|
|
|
* 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) {
|
2003-09-05 00:10:33 +00:00
|
|
|
IPQ_UNLOCK();
|
1998-08-24 07:47:39 +00:00
|
|
|
ipstat.ips_toosmall++; /* XXX */
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
m->m_flags |= M_FRAG;
|
2002-09-17 11:20:02 +00:00
|
|
|
} else
|
|
|
|
m->m_flags &= ~M_FRAG;
|
1994-05-24 10:09:53 +00:00
|
|
|
ip->ip_off <<= 3;
|
|
|
|
|
|
|
|
/*
|
2000-10-26 13:14:48 +00:00
|
|
|
* Attempt reassembly; if it succeeds, proceed.
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
* ip_reass() will return a different mbuf, and update
|
|
|
|
* the divert info in divert_info and args.divert_rule.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2000-10-26 13:14:48 +00:00
|
|
|
ipstat.ips_fragments++;
|
|
|
|
m->m_pkthdr.header = ip;
|
|
|
|
m = ip_reass(m,
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
&ipq[sum], fp, &divert_info, &args.divert_rule);
|
2003-09-05 00:10:33 +00:00
|
|
|
IPQ_UNLOCK();
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
if (m == 0)
|
2000-10-26 13:14:48 +00:00
|
|
|
return;
|
|
|
|
ipstat.ips_reassembled++;
|
|
|
|
ip = mtod(m, struct ip *);
|
|
|
|
/* Get the header length of the reassembled packet */
|
2002-10-20 22:52:07 +00:00
|
|
|
hlen = ip->ip_hl << 2;
|
1997-07-25 03:58:21 +00:00
|
|
|
#ifdef IPDIVERT
|
2000-10-26 13:14:48 +00:00
|
|
|
/* Restore original checksum before diverting packet */
|
|
|
|
if (divert_info != 0) {
|
|
|
|
ip->ip_len += hlen;
|
2002-02-18 20:35:27 +00:00
|
|
|
ip->ip_len = htons(ip->ip_len);
|
|
|
|
ip->ip_off = htons(ip->ip_off);
|
2000-10-26 13:14:48 +00:00
|
|
|
ip->ip_sum = 0;
|
2000-11-01 11:21:45 +00:00
|
|
|
if (hlen == sizeof(struct ip))
|
|
|
|
ip->ip_sum = in_cksum_hdr(ip);
|
|
|
|
else
|
|
|
|
ip->ip_sum = in_cksum(m, hlen);
|
2002-02-18 20:35:27 +00:00
|
|
|
ip->ip_off = ntohs(ip->ip_off);
|
|
|
|
ip->ip_len = ntohs(ip->ip_len);
|
2000-10-26 13:14:48 +00:00
|
|
|
ip->ip_len -= hlen;
|
|
|
|
}
|
1997-07-25 03:58:21 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
} else
|
|
|
|
ip->ip_len -= hlen;
|
|
|
|
|
1996-07-10 19:44:30 +00:00
|
|
|
#ifdef IPDIVERT
|
|
|
|
/*
|
1999-12-06 00:43:07 +00:00
|
|
|
* Divert or tee packet to the divert protocol if required.
|
1996-07-10 19:44:30 +00:00
|
|
|
*/
|
1999-12-06 00:43:07 +00:00
|
|
|
if (divert_info != 0) {
|
|
|
|
struct mbuf *clone = NULL;
|
|
|
|
|
|
|
|
/* Clone packet if we're doing a 'tee' */
|
|
|
|
if ((divert_info & IP_FW_PORT_TEE_FLAG) != 0)
|
2003-02-19 05:47:46 +00:00
|
|
|
clone = m_dup(m, M_DONTWAIT);
|
1999-12-06 00:43:07 +00:00
|
|
|
|
|
|
|
/* Restore packet header fields to original values */
|
|
|
|
ip->ip_len += hlen;
|
2002-02-18 20:35:27 +00:00
|
|
|
ip->ip_len = htons(ip->ip_len);
|
|
|
|
ip->ip_off = htons(ip->ip_off);
|
1999-12-06 00:43:07 +00:00
|
|
|
|
|
|
|
/* Deliver packet to divert input routine */
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
divert_packet(m, 1, divert_info & 0xffff, args.divert_rule);
|
1997-06-02 05:02:37 +00:00
|
|
|
ipstat.ips_delivered++;
|
1997-11-13 22:57:57 +00:00
|
|
|
|
1999-12-06 00:43:07 +00:00
|
|
|
/* If 'tee', continue with original packet */
|
|
|
|
if (clone == NULL)
|
|
|
|
return;
|
|
|
|
m = clone;
|
|
|
|
ip = mtod(m, struct ip *);
|
2002-01-26 10:14:08 +00:00
|
|
|
ip->ip_len += hlen;
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
/*
|
|
|
|
* Jump backwards to complete processing of the
|
|
|
|
* packet. But first clear divert_info to avoid
|
|
|
|
* entering this block again.
|
|
|
|
* We do not need to clear args.divert_rule
|
|
|
|
* or args.next_hop as they will not be used.
|
|
|
|
*/
|
2002-01-26 10:14:08 +00:00
|
|
|
divert_info = 0;
|
|
|
|
goto pass;
|
1997-11-13 22:57:57 +00:00
|
|
|
}
|
1996-07-10 19:44:30 +00:00
|
|
|
#endif
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef IPSEC
|
|
|
|
/*
|
|
|
|
* enforce IPsec policy checking if we are seeing last header.
|
|
|
|
* note that we do not visit this with protocols with pcb layer
|
|
|
|
* code - like udp/tcp/raw ip.
|
|
|
|
*/
|
|
|
|
if ((inetsw[ip_protox[ip->ip_p]].pr_flags & PR_LASTHDR) != 0 &&
|
|
|
|
ipsec4_in_reject(m, NULL)) {
|
|
|
|
ipsecstat.in_polvio++;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
#endif
|
2002-10-16 02:25:05 +00:00
|
|
|
#if FAST_IPSEC
|
|
|
|
/*
|
|
|
|
* enforce IPsec policy checking if we are seeing last header.
|
|
|
|
* note that we do not visit this with protocols with pcb layer
|
|
|
|
* code - like udp/tcp/raw ip.
|
|
|
|
*/
|
|
|
|
if ((inetsw[ip_protox[ip->ip_p]].pr_flags & PR_LASTHDR) != 0) {
|
|
|
|
/*
|
|
|
|
* Check if the packet has already had IPsec processing
|
|
|
|
* 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 = splnet();
|
|
|
|
if (mtag != NULL) {
|
|
|
|
tdbi = (struct tdb_ident *)(mtag + 1);
|
|
|
|
sp = ipsec_getpolicy(tdbi, IPSEC_DIR_INBOUND);
|
|
|
|
} else {
|
|
|
|
sp = ipsec_getpolicybyaddr(m, IPSEC_DIR_INBOUND,
|
|
|
|
IP_FORWARDING, &error);
|
|
|
|
}
|
|
|
|
if (sp != NULL) {
|
|
|
|
/*
|
|
|
|
* Check security policy against packet attributes.
|
|
|
|
*/
|
|
|
|
error = ipsec_in_reject(sp, m);
|
|
|
|
KEY_FREESP(&sp);
|
|
|
|
} else {
|
|
|
|
/* XXX error stat??? */
|
|
|
|
error = EINVAL;
|
|
|
|
DPRINTF(("ip_input: no SP, packet discarded\n"));/*XXX*/
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
if (error)
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
#endif /* FAST_IPSEC */
|
2001-06-11 12:39:29 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Switch out to protocol's input routine.
|
|
|
|
*/
|
|
|
|
ipstat.ips_delivered++;
|
2003-11-08 22:28:40 +00:00
|
|
|
NET_PICKUP_GIANT();
|
2002-06-23 09:15:43 +00:00
|
|
|
if (args.next_hop && ip->ip_p == IPPROTO_TCP) {
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
/* TCP needs IPFORWARD info if available */
|
|
|
|
struct m_hdr tag;
|
1999-12-22 19:13:38 +00:00
|
|
|
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
tag.mh_type = MT_TAG;
|
|
|
|
tag.mh_flags = PACKET_TAG_IPFORWARD;
|
|
|
|
tag.mh_data = (caddr_t)args.next_hop;
|
|
|
|
tag.mh_next = m;
|
2003-11-17 03:17:49 +00:00
|
|
|
tag.mh_nextpkt = NULL;
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
|
|
|
|
(*inetsw[ip_protox[ip->ip_p]].pr_input)(
|
|
|
|
(struct mbuf *)&tag, hlen);
|
|
|
|
} else
|
|
|
|
(*inetsw[ip_protox[ip->ip_p]].pr_input)(m, hlen);
|
2003-11-08 22:28:40 +00:00
|
|
|
NET_DROP_GIANT();
|
1996-02-05 20:36:02 +00:00
|
|
|
return;
|
1994-05-24 10:09:53 +00:00
|
|
|
bad:
|
|
|
|
m_freem(m);
|
1996-02-05 20:36:02 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1999-12-06 00:43:07 +00:00
|
|
|
* Take incoming datagram fragment and try to reassemble it into
|
|
|
|
* whole datagram. If a chain for reassembly of this datagram already
|
|
|
|
* exists, then it is given as fp; otherwise have to make a chain.
|
|
|
|
*
|
|
|
|
* When IPDIVERT enabled, keep additional state with each packet that
|
|
|
|
* tells us if we need to divert or tee the packet we're building.
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
* In particular, *divinfo includes the port and TEE flag,
|
|
|
|
* *divert_rule is the number of the matching rule.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1999-12-06 00:43:07 +00:00
|
|
|
|
1999-12-22 19:13:38 +00:00
|
|
|
static struct mbuf *
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
ip_reass(struct mbuf *m, struct ipqhead *head, struct ipq *fp,
|
|
|
|
u_int32_t *divinfo, u_int16_t *divert_rule)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1998-08-24 07:47:39 +00:00
|
|
|
struct ip *ip = mtod(m, struct ip *);
|
2000-10-26 13:14:48 +00:00
|
|
|
register struct mbuf *p, *q, *nq;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct mbuf *t;
|
2002-10-20 22:52:07 +00:00
|
|
|
int hlen = ip->ip_hl << 2;
|
1994-05-24 10:09:53 +00:00
|
|
|
int i, next;
|
2003-10-29 15:07:04 +00:00
|
|
|
u_int8_t ecn, ecn0;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2003-09-05 00:10:33 +00:00
|
|
|
IPQ_LOCK_ASSERT();
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Presence of header sizes in mbufs
|
|
|
|
* would confuse code below.
|
|
|
|
*/
|
|
|
|
m->m_data += hlen;
|
|
|
|
m->m_len -= hlen;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If first fragment to arrive, create a reassembly queue.
|
|
|
|
*/
|
2003-06-06 19:32:48 +00:00
|
|
|
if (fp == NULL) {
|
2003-02-19 05:47:46 +00:00
|
|
|
if ((t = m_get(M_DONTWAIT, MT_FTABLE)) == NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto dropfrag;
|
|
|
|
fp = mtod(t, struct ipq *);
|
2002-07-31 17:17:51 +00:00
|
|
|
#ifdef MAC
|
2003-03-26 15:12:03 +00:00
|
|
|
if (mac_init_ipq(fp, M_NOWAIT) != 0) {
|
|
|
|
m_free(t);
|
|
|
|
goto dropfrag;
|
|
|
|
}
|
2002-07-31 17:17:51 +00:00
|
|
|
mac_create_ipq(m, fp);
|
|
|
|
#endif
|
2001-03-16 20:00:53 +00:00
|
|
|
TAILQ_INSERT_HEAD(head, fp, ipq_list);
|
1997-09-15 23:07:01 +00:00
|
|
|
nipq++;
|
2003-02-22 06:41:47 +00:00
|
|
|
fp->ipq_nfrags = 1;
|
1994-05-24 10:09:53 +00:00
|
|
|
fp->ipq_ttl = IPFRAGTTL;
|
|
|
|
fp->ipq_p = ip->ip_p;
|
|
|
|
fp->ipq_id = ip->ip_id;
|
1998-08-24 07:47:39 +00:00
|
|
|
fp->ipq_src = ip->ip_src;
|
|
|
|
fp->ipq_dst = ip->ip_dst;
|
1998-12-21 22:40:54 +00:00
|
|
|
fp->ipq_frags = m;
|
|
|
|
m->m_nextpkt = NULL;
|
1996-07-10 19:44:30 +00:00
|
|
|
#ifdef IPDIVERT
|
1999-12-06 00:43:07 +00:00
|
|
|
fp->ipq_div_info = 0;
|
1998-05-25 10:37:48 +00:00
|
|
|
fp->ipq_div_cookie = 0;
|
1996-07-10 19:44:30 +00:00
|
|
|
#endif
|
1998-12-21 22:40:54 +00:00
|
|
|
goto inserted;
|
2002-07-31 17:17:51 +00:00
|
|
|
} else {
|
2003-02-22 06:41:47 +00:00
|
|
|
fp->ipq_nfrags++;
|
2002-07-31 17:17:51 +00:00
|
|
|
#ifdef MAC
|
|
|
|
mac_update_ipq(m, fp);
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1998-08-24 07:47:39 +00:00
|
|
|
#define GETIP(m) ((struct ip*)((m)->m_pkthdr.header))
|
|
|
|
|
2003-10-29 15:07:04 +00:00
|
|
|
/*
|
|
|
|
* Handle ECN by comparing this segment with the first one;
|
|
|
|
* if CE is set, do not lose CE.
|
|
|
|
* drop if CE and not-ECT are mixed for the same packet.
|
|
|
|
*/
|
|
|
|
ecn = ip->ip_tos & IPTOS_ECN_MASK;
|
|
|
|
ecn0 = GETIP(fp->ipq_frags)->ip_tos & IPTOS_ECN_MASK;
|
|
|
|
if (ecn == IPTOS_ECN_CE) {
|
|
|
|
if (ecn0 == IPTOS_ECN_NOTECT)
|
|
|
|
goto dropfrag;
|
|
|
|
if (ecn0 != IPTOS_ECN_CE)
|
|
|
|
GETIP(fp->ipq_frags)->ip_tos |= IPTOS_ECN_CE;
|
|
|
|
}
|
|
|
|
if (ecn == IPTOS_ECN_NOTECT && ecn0 != IPTOS_ECN_NOTECT)
|
|
|
|
goto dropfrag;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Find a segment which begins after this one does.
|
|
|
|
*/
|
1998-08-24 07:47:39 +00:00
|
|
|
for (p = NULL, q = fp->ipq_frags; q; p = q, q = q->m_nextpkt)
|
|
|
|
if (GETIP(q)->ip_off > ip->ip_off)
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is a preceding segment, it may provide some of
|
|
|
|
* our data already. If so, drop the data from the incoming
|
1998-12-21 22:40:54 +00:00
|
|
|
* segment. If it provides all of our data, drop us, otherwise
|
|
|
|
* stick new segment in the proper place.
|
2000-03-27 19:14:27 +00:00
|
|
|
*
|
|
|
|
* If some of the data is dropped from the the preceding
|
|
|
|
* segment, then it's checksum is invalidated.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1998-08-24 07:47:39 +00:00
|
|
|
if (p) {
|
|
|
|
i = GETIP(p)->ip_off + GETIP(p)->ip_len - ip->ip_off;
|
1994-05-24 10:09:53 +00:00
|
|
|
if (i > 0) {
|
|
|
|
if (i >= ip->ip_len)
|
|
|
|
goto dropfrag;
|
1999-12-22 19:13:38 +00:00
|
|
|
m_adj(m, i);
|
2000-03-27 19:14:27 +00:00
|
|
|
m->m_pkthdr.csum_flags = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
ip->ip_off += i;
|
|
|
|
ip->ip_len -= i;
|
|
|
|
}
|
1998-12-21 22:40:54 +00:00
|
|
|
m->m_nextpkt = p->m_nextpkt;
|
|
|
|
p->m_nextpkt = m;
|
|
|
|
} else {
|
|
|
|
m->m_nextpkt = fp->ipq_frags;
|
|
|
|
fp->ipq_frags = m;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* While we overlap succeeding segments trim them or,
|
|
|
|
* if they are completely covered, dequeue them.
|
|
|
|
*/
|
1998-08-24 07:47:39 +00:00
|
|
|
for (; q != NULL && ip->ip_off + ip->ip_len > GETIP(q)->ip_off;
|
1998-12-21 22:40:54 +00:00
|
|
|
q = nq) {
|
2003-02-25 11:53:11 +00:00
|
|
|
i = (ip->ip_off + ip->ip_len) - GETIP(q)->ip_off;
|
1998-08-24 07:47:39 +00:00
|
|
|
if (i < GETIP(q)->ip_len) {
|
|
|
|
GETIP(q)->ip_len -= i;
|
|
|
|
GETIP(q)->ip_off += i;
|
|
|
|
m_adj(q, i);
|
2000-03-27 19:14:27 +00:00
|
|
|
q->m_pkthdr.csum_flags = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
}
|
1998-08-24 07:47:39 +00:00
|
|
|
nq = q->m_nextpkt;
|
1998-12-21 22:40:54 +00:00
|
|
|
m->m_nextpkt = nq;
|
2003-02-25 11:49:01 +00:00
|
|
|
ipstat.ips_fragdropped++;
|
2003-02-22 06:41:47 +00:00
|
|
|
fp->ipq_nfrags--;
|
1998-08-24 07:47:39 +00:00
|
|
|
m_freem(q);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1998-12-21 22:40:54 +00:00
|
|
|
inserted:
|
1996-07-10 19:44:30 +00:00
|
|
|
|
|
|
|
#ifdef IPDIVERT
|
|
|
|
/*
|
1999-12-06 00:43:07 +00:00
|
|
|
* Transfer firewall instructions to the fragment structure.
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
* Only trust info in the fragment at offset 0.
|
1996-07-10 19:44:30 +00:00
|
|
|
*/
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
if (ip->ip_off == 0) {
|
|
|
|
fp->ipq_div_info = *divinfo;
|
|
|
|
fp->ipq_div_cookie = *divert_rule;
|
|
|
|
}
|
1999-12-06 00:43:07 +00:00
|
|
|
*divinfo = 0;
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
*divert_rule = 0;
|
1996-07-10 19:44:30 +00:00
|
|
|
#endif
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2003-02-22 06:41:47 +00:00
|
|
|
* Check for complete reassembly and perform frag per packet
|
|
|
|
* limiting.
|
|
|
|
*
|
|
|
|
* Frag limiting is performed here so that the nth frag has
|
|
|
|
* a chance to complete the packet before we drop the packet.
|
|
|
|
* As a result, n+1 frags are actually allowed per packet, but
|
|
|
|
* only n will ever be stored. (n = maxfragsperpacket.)
|
|
|
|
*
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
next = 0;
|
1998-08-24 07:47:39 +00:00
|
|
|
for (p = NULL, q = fp->ipq_frags; q; p = q, q = q->m_nextpkt) {
|
2003-02-22 06:41:47 +00:00
|
|
|
if (GETIP(q)->ip_off != next) {
|
2003-02-25 11:49:01 +00:00
|
|
|
if (fp->ipq_nfrags > maxfragsperpacket) {
|
|
|
|
ipstat.ips_fragdropped += fp->ipq_nfrags;
|
2003-02-22 06:41:47 +00:00
|
|
|
ip_freef(head, fp);
|
2003-02-25 11:49:01 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
2003-02-22 06:41:47 +00:00
|
|
|
}
|
1998-08-24 07:47:39 +00:00
|
|
|
next += GETIP(q)->ip_len;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1998-08-24 07:47:39 +00:00
|
|
|
/* Make sure the last packet didn't have the IP_MF flag */
|
2003-02-22 06:41:47 +00:00
|
|
|
if (p->m_flags & M_FRAG) {
|
2003-02-25 11:49:01 +00:00
|
|
|
if (fp->ipq_nfrags > maxfragsperpacket) {
|
|
|
|
ipstat.ips_fragdropped += fp->ipq_nfrags;
|
2003-02-22 06:41:47 +00:00
|
|
|
ip_freef(head, fp);
|
2003-02-25 11:49:01 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
2003-02-22 06:41:47 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
1996-10-25 17:57:53 +00:00
|
|
|
* Reassembly is complete. Make sure the packet is a sane size.
|
|
|
|
*/
|
1998-08-24 07:47:39 +00:00
|
|
|
q = fp->ipq_frags;
|
|
|
|
ip = GETIP(q);
|
2002-10-20 22:52:07 +00:00
|
|
|
if (next + (ip->ip_hl << 2) > IP_MAXPACKET) {
|
1996-10-25 17:57:53 +00:00
|
|
|
ipstat.ips_toolong++;
|
2003-02-25 11:49:01 +00:00
|
|
|
ipstat.ips_fragdropped += fp->ipq_nfrags;
|
2001-03-16 20:00:53 +00:00
|
|
|
ip_freef(head, fp);
|
1996-10-25 17:57:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Concatenate fragments.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1998-08-24 07:47:39 +00:00
|
|
|
m = q;
|
1994-05-24 10:09:53 +00:00
|
|
|
t = m->m_next;
|
|
|
|
m->m_next = 0;
|
|
|
|
m_cat(m, t);
|
1998-08-24 07:47:39 +00:00
|
|
|
nq = q->m_nextpkt;
|
1998-09-10 08:56:40 +00:00
|
|
|
q->m_nextpkt = 0;
|
1998-08-24 07:47:39 +00:00
|
|
|
for (q = nq; q != NULL; q = nq) {
|
|
|
|
nq = q->m_nextpkt;
|
1998-09-10 08:56:40 +00:00
|
|
|
q->m_nextpkt = NULL;
|
2000-03-27 19:14:27 +00:00
|
|
|
m->m_pkthdr.csum_flags &= q->m_pkthdr.csum_flags;
|
|
|
|
m->m_pkthdr.csum_data += q->m_pkthdr.csum_data;
|
2000-09-14 21:06:48 +00:00
|
|
|
m_cat(m, q);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2002-07-31 17:17:51 +00:00
|
|
|
#ifdef MAC
|
|
|
|
mac_create_datagram_from_ipq(fp, m);
|
|
|
|
mac_destroy_ipq(fp);
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1996-07-10 19:44:30 +00:00
|
|
|
#ifdef IPDIVERT
|
|
|
|
/*
|
1999-12-06 00:43:07 +00:00
|
|
|
* Extract firewall instructions from the fragment structure.
|
1996-07-10 19:44:30 +00:00
|
|
|
*/
|
1999-12-06 00:43:07 +00:00
|
|
|
*divinfo = fp->ipq_div_info;
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
*divert_rule = fp->ipq_div_cookie;
|
1996-07-10 19:44:30 +00:00
|
|
|
#endif
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Create header for new ip packet by
|
|
|
|
* modifying header of first packet;
|
|
|
|
* dequeue and discard fragment reassembly header.
|
|
|
|
* Make header visible.
|
|
|
|
*/
|
|
|
|
ip->ip_len = next;
|
1998-08-24 07:47:39 +00:00
|
|
|
ip->ip_src = fp->ipq_src;
|
|
|
|
ip->ip_dst = fp->ipq_dst;
|
2001-03-16 20:00:53 +00:00
|
|
|
TAILQ_REMOVE(head, fp, ipq_list);
|
1997-09-15 23:07:01 +00:00
|
|
|
nipq--;
|
1994-05-24 10:09:53 +00:00
|
|
|
(void) m_free(dtom(fp));
|
2002-10-20 22:52:07 +00:00
|
|
|
m->m_len += (ip->ip_hl << 2);
|
|
|
|
m->m_data -= (ip->ip_hl << 2);
|
1994-05-24 10:09:53 +00:00
|
|
|
/* some debugging cruft by sklower, below, will go away soon */
|
2002-09-18 19:43:01 +00:00
|
|
|
if (m->m_flags & M_PKTHDR) /* XXX this should be done elsewhere */
|
|
|
|
m_fixhdr(m);
|
1999-12-22 19:13:38 +00:00
|
|
|
return (m);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
dropfrag:
|
1998-07-06 09:06:58 +00:00
|
|
|
#ifdef IPDIVERT
|
1999-12-06 00:43:07 +00:00
|
|
|
*divinfo = 0;
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
*divert_rule = 0;
|
1998-07-06 09:06:58 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
ipstat.ips_fragdropped++;
|
2003-06-06 19:32:48 +00:00
|
|
|
if (fp != NULL)
|
2003-02-22 06:41:47 +00:00
|
|
|
fp->ipq_nfrags--;
|
1994-05-24 10:09:53 +00:00
|
|
|
m_freem(m);
|
|
|
|
return (0);
|
1998-08-24 07:47:39 +00:00
|
|
|
|
|
|
|
#undef GETIP
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Free a fragment reassembly header and all
|
|
|
|
* associated datagrams.
|
|
|
|
*/
|
1995-11-14 20:34:56 +00:00
|
|
|
static void
|
2001-03-16 20:00:53 +00:00
|
|
|
ip_freef(fhp, fp)
|
|
|
|
struct ipqhead *fhp;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct ipq *fp;
|
|
|
|
{
|
1998-08-24 07:47:39 +00:00
|
|
|
register struct mbuf *q;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2003-09-05 00:10:33 +00:00
|
|
|
IPQ_LOCK_ASSERT();
|
|
|
|
|
1998-08-24 07:47:39 +00:00
|
|
|
while (fp->ipq_frags) {
|
|
|
|
q = fp->ipq_frags;
|
|
|
|
fp->ipq_frags = q->m_nextpkt;
|
|
|
|
m_freem(q);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2001-03-16 20:00:53 +00:00
|
|
|
TAILQ_REMOVE(fhp, fp, ipq_list);
|
1994-05-24 10:09:53 +00:00
|
|
|
(void) m_free(dtom(fp));
|
1997-09-15 23:07:01 +00:00
|
|
|
nipq--;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IP timer processing;
|
|
|
|
* if a timer expires on a reassembly
|
|
|
|
* queue, discard it.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ip_slowtimo()
|
|
|
|
{
|
|
|
|
register struct ipq *fp;
|
|
|
|
int s = splnet();
|
1997-09-15 23:07:01 +00:00
|
|
|
int i;
|
|
|
|
|
2003-09-05 00:10:33 +00:00
|
|
|
IPQ_LOCK();
|
1997-09-15 23:07:01 +00:00
|
|
|
for (i = 0; i < IPREASS_NHASH; i++) {
|
2001-03-16 20:00:53 +00:00
|
|
|
for(fp = TAILQ_FIRST(&ipq[i]); fp;) {
|
|
|
|
struct ipq *fpp;
|
|
|
|
|
|
|
|
fpp = fp;
|
|
|
|
fp = TAILQ_NEXT(fp, ipq_list);
|
|
|
|
if(--fpp->ipq_ttl == 0) {
|
2003-02-25 11:49:01 +00:00
|
|
|
ipstat.ips_fragtimeout += fpp->ipq_nfrags;
|
2001-03-16 20:00:53 +00:00
|
|
|
ip_freef(&ipq[i], fpp);
|
1997-09-15 23:07:01 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
2001-06-03 23:33:23 +00:00
|
|
|
/*
|
|
|
|
* If we are over the maximum number of fragments
|
|
|
|
* (due to the limit being lowered), drain off
|
|
|
|
* enough to get down to the new limit.
|
|
|
|
*/
|
2003-02-26 07:28:35 +00:00
|
|
|
if (maxnipq >= 0 && nipq > maxnipq) {
|
2003-02-01 05:59:51 +00:00
|
|
|
for (i = 0; i < IPREASS_NHASH; i++) {
|
2003-02-25 11:53:11 +00:00
|
|
|
while (nipq > maxnipq && !TAILQ_EMPTY(&ipq[i])) {
|
2003-02-25 11:49:01 +00:00
|
|
|
ipstat.ips_fragdropped +=
|
|
|
|
TAILQ_FIRST(&ipq[i])->ipq_nfrags;
|
2001-06-03 23:33:23 +00:00
|
|
|
ip_freef(&ipq[i], TAILQ_FIRST(&ipq[i]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2003-09-05 00:10:33 +00:00
|
|
|
IPQ_UNLOCK();
|
1994-05-24 10:09:53 +00:00
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Drain off all datagram fragments.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ip_drain()
|
|
|
|
{
|
1997-09-15 23:07:01 +00:00
|
|
|
int i;
|
1995-12-19 20:46:15 +00:00
|
|
|
|
2003-09-05 00:10:33 +00:00
|
|
|
IPQ_LOCK();
|
1997-09-15 23:07:01 +00:00
|
|
|
for (i = 0; i < IPREASS_NHASH; i++) {
|
2001-03-16 20:00:53 +00:00
|
|
|
while(!TAILQ_EMPTY(&ipq[i])) {
|
2003-02-25 11:49:01 +00:00
|
|
|
ipstat.ips_fragdropped +=
|
|
|
|
TAILQ_FIRST(&ipq[i])->ipq_nfrags;
|
2001-03-16 20:00:53 +00:00
|
|
|
ip_freef(&ipq[i], TAILQ_FIRST(&ipq[i]));
|
1997-09-15 23:07:01 +00:00
|
|
|
}
|
|
|
|
}
|
2003-09-05 00:10:33 +00:00
|
|
|
IPQ_UNLOCK();
|
1995-12-19 20:46:15 +00:00
|
|
|
in_rtqdrain();
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do option processing on a datagram,
|
|
|
|
* possibly discarding it if bad options are encountered,
|
|
|
|
* or forwarding it if source-routed.
|
2001-12-29 09:24:18 +00:00
|
|
|
* The pass argument is used when operating in the IPSTEALTH
|
|
|
|
* mode to tell what options to process:
|
|
|
|
* [LS]SRR (pass 0) or the others (pass 1).
|
|
|
|
* The reason for as many as two passes is that when doing IPSTEALTH,
|
|
|
|
* non-routing options should be processed only if the packet is for us.
|
1994-05-24 10:09:53 +00:00
|
|
|
* Returns 1 if packet has been forwarded/freed,
|
|
|
|
* 0 if the packet should be processed further.
|
|
|
|
*/
|
1995-11-14 20:34:56 +00:00
|
|
|
static int
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
ip_dooptions(struct mbuf *m, int pass, struct sockaddr_in *next_hop)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
struct ip *ip = mtod(m, struct ip *);
|
|
|
|
u_char *cp;
|
|
|
|
struct in_ifaddr *ia;
|
1994-05-24 10:09:53 +00:00
|
|
|
int opt, optlen, cnt, off, code, type = ICMP_PARAMPROB, forward = 0;
|
|
|
|
struct in_addr *sin, dst;
|
|
|
|
n_time ntime;
|
2002-06-23 20:48:26 +00:00
|
|
|
struct sockaddr_in ipaddr = { sizeof(ipaddr), AF_INET };
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
dst = ip->ip_dst;
|
|
|
|
cp = (u_char *)(ip + 1);
|
2002-10-20 22:52:07 +00:00
|
|
|
cnt = (ip->ip_hl << 2) - sizeof (struct ip);
|
1994-05-24 10:09:53 +00:00
|
|
|
for (; cnt > 0; cnt -= optlen, cp += optlen) {
|
|
|
|
opt = cp[IPOPT_OPTVAL];
|
|
|
|
if (opt == IPOPT_EOL)
|
|
|
|
break;
|
|
|
|
if (opt == IPOPT_NOP)
|
|
|
|
optlen = 1;
|
|
|
|
else {
|
2000-05-10 01:25:33 +00:00
|
|
|
if (cnt < IPOPT_OLEN + sizeof(*cp)) {
|
|
|
|
code = &cp[IPOPT_OLEN] - (u_char *)ip;
|
|
|
|
goto bad;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
optlen = cp[IPOPT_OLEN];
|
2000-06-02 20:18:38 +00:00
|
|
|
if (optlen < IPOPT_OLEN + sizeof(*cp) || optlen > cnt) {
|
1994-05-24 10:09:53 +00:00
|
|
|
code = &cp[IPOPT_OLEN] - (u_char *)ip;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
switch (opt) {
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Source routing with record.
|
|
|
|
* Find interface with current destination address.
|
|
|
|
* If none on this machine then drop if strictly routed,
|
|
|
|
* or do nothing if loosely routed.
|
|
|
|
* Record interface address and bring up next address
|
|
|
|
* component. If strictly routed make sure next
|
|
|
|
* address is on directly accessible net.
|
|
|
|
*/
|
|
|
|
case IPOPT_LSRR:
|
|
|
|
case IPOPT_SSRR:
|
2001-12-29 09:24:18 +00:00
|
|
|
#ifdef IPSTEALTH
|
|
|
|
if (ipstealth && pass > 0)
|
|
|
|
break;
|
|
|
|
#endif
|
2001-06-11 12:39:29 +00:00
|
|
|
if (optlen < IPOPT_OFFSET + sizeof(*cp)) {
|
|
|
|
code = &cp[IPOPT_OLEN] - (u_char *)ip;
|
|
|
|
goto bad;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {
|
|
|
|
code = &cp[IPOPT_OFFSET] - (u_char *)ip;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
ipaddr.sin_addr = ip->ip_dst;
|
|
|
|
ia = (struct in_ifaddr *)
|
|
|
|
ifa_ifwithaddr((struct sockaddr *)&ipaddr);
|
|
|
|
if (ia == 0) {
|
|
|
|
if (opt == IPOPT_SSRR) {
|
|
|
|
type = ICMP_UNREACH;
|
|
|
|
code = ICMP_UNREACH_SRCFAIL;
|
|
|
|
goto bad;
|
|
|
|
}
|
1997-10-28 18:55:21 +00:00
|
|
|
if (!ip_dosourceroute)
|
|
|
|
goto nosourcerouting;
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Loose routing, and not at next destination
|
|
|
|
* yet; nothing to do except forward.
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
off--; /* 0 origin */
|
2000-05-17 04:05:07 +00:00
|
|
|
if (off > optlen - (int)sizeof(struct in_addr)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* End of source route. Should be for us.
|
|
|
|
*/
|
1998-02-16 19:23:58 +00:00
|
|
|
if (!ip_acceptsourceroute)
|
|
|
|
goto nosourcerouting;
|
1994-05-24 10:09:53 +00:00
|
|
|
save_rte(cp, ip->ip_src);
|
|
|
|
break;
|
|
|
|
}
|
2001-12-29 09:24:18 +00:00
|
|
|
#ifdef IPSTEALTH
|
|
|
|
if (ipstealth)
|
|
|
|
goto dropit;
|
|
|
|
#endif
|
1995-03-16 18:22:28 +00:00
|
|
|
if (!ip_dosourceroute) {
|
1998-07-08 08:49:51 +00:00
|
|
|
if (ipforwarding) {
|
|
|
|
char buf[16]; /* aaa.bbb.ccc.ddd\0 */
|
|
|
|
/*
|
|
|
|
* Acting as a router, so generate ICMP
|
|
|
|
*/
|
1997-10-27 21:07:26 +00:00
|
|
|
nosourcerouting:
|
1998-07-08 08:49:51 +00:00
|
|
|
strcpy(buf, inet_ntoa(ip->ip_dst));
|
|
|
|
log(LOG_WARNING,
|
|
|
|
"attempted source route from %s to %s\n",
|
|
|
|
inet_ntoa(ip->ip_src), buf);
|
|
|
|
type = ICMP_UNREACH;
|
|
|
|
code = ICMP_UNREACH_SRCFAIL;
|
|
|
|
goto bad;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Not acting as a router, so silently drop.
|
|
|
|
*/
|
2001-12-29 09:24:18 +00:00
|
|
|
#ifdef IPSTEALTH
|
|
|
|
dropit:
|
|
|
|
#endif
|
1998-07-08 08:49:51 +00:00
|
|
|
ipstat.ips_cantforward++;
|
|
|
|
m_freem(m);
|
|
|
|
return (1);
|
|
|
|
}
|
1995-03-16 18:22:28 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* locate outgoing interface
|
|
|
|
*/
|
1995-05-09 13:35:48 +00:00
|
|
|
(void)memcpy(&ipaddr.sin_addr, cp + off,
|
1994-05-24 10:09:53 +00:00
|
|
|
sizeof(ipaddr.sin_addr));
|
1995-03-16 18:22:28 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
if (opt == IPOPT_SSRR) {
|
|
|
|
#define INA struct in_ifaddr *
|
|
|
|
#define SA struct sockaddr *
|
|
|
|
if ((ia = (INA)ifa_ifwithdstaddr((SA)&ipaddr)) == 0)
|
|
|
|
ia = (INA)ifa_ifwithnet((SA)&ipaddr);
|
|
|
|
} else
|
2003-11-14 21:48:57 +00:00
|
|
|
ia = ip_rtaddr(ipaddr.sin_addr);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ia == 0) {
|
|
|
|
type = ICMP_UNREACH;
|
|
|
|
code = ICMP_UNREACH_SRCFAIL;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
ip->ip_dst = ipaddr.sin_addr;
|
1995-05-09 13:35:48 +00:00
|
|
|
(void)memcpy(cp + off, &(IA_SIN(ia)->sin_addr),
|
|
|
|
sizeof(struct in_addr));
|
1994-05-24 10:09:53 +00:00
|
|
|
cp[IPOPT_OFFSET] += sizeof(struct in_addr);
|
|
|
|
/*
|
|
|
|
* Let ip_intr's mcast routing check handle mcast pkts
|
|
|
|
*/
|
|
|
|
forward = !IN_MULTICAST(ntohl(ip->ip_dst.s_addr));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPOPT_RR:
|
2001-12-29 09:24:18 +00:00
|
|
|
#ifdef IPSTEALTH
|
|
|
|
if (ipstealth && pass == 0)
|
|
|
|
break;
|
|
|
|
#endif
|
2000-06-02 20:18:38 +00:00
|
|
|
if (optlen < IPOPT_OFFSET + sizeof(*cp)) {
|
|
|
|
code = &cp[IPOPT_OFFSET] - (u_char *)ip;
|
|
|
|
goto bad;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {
|
|
|
|
code = &cp[IPOPT_OFFSET] - (u_char *)ip;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If no space remains, ignore.
|
|
|
|
*/
|
|
|
|
off--; /* 0 origin */
|
2000-05-17 04:05:07 +00:00
|
|
|
if (off > optlen - (int)sizeof(struct in_addr))
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
1995-05-09 13:35:48 +00:00
|
|
|
(void)memcpy(&ipaddr.sin_addr, &ip->ip_dst,
|
1994-05-24 10:09:53 +00:00
|
|
|
sizeof(ipaddr.sin_addr));
|
|
|
|
/*
|
|
|
|
* locate outgoing interface; if we're the destination,
|
|
|
|
* use the incoming interface (should be same).
|
|
|
|
*/
|
|
|
|
if ((ia = (INA)ifa_ifwithaddr((SA)&ipaddr)) == 0 &&
|
2003-11-14 21:48:57 +00:00
|
|
|
(ia = ip_rtaddr(ipaddr.sin_addr)) == 0) {
|
1994-05-24 10:09:53 +00:00
|
|
|
type = ICMP_UNREACH;
|
|
|
|
code = ICMP_UNREACH_HOST;
|
|
|
|
goto bad;
|
|
|
|
}
|
1995-05-09 13:35:48 +00:00
|
|
|
(void)memcpy(cp + off, &(IA_SIN(ia)->sin_addr),
|
|
|
|
sizeof(struct in_addr));
|
1994-05-24 10:09:53 +00:00
|
|
|
cp[IPOPT_OFFSET] += sizeof(struct in_addr);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPOPT_TS:
|
2001-12-29 09:24:18 +00:00
|
|
|
#ifdef IPSTEALTH
|
|
|
|
if (ipstealth && pass == 0)
|
|
|
|
break;
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
code = cp - (u_char *)ip;
|
2001-10-25 06:27:51 +00:00
|
|
|
if (optlen < 4 || optlen > 40) {
|
|
|
|
code = &cp[IPOPT_OLEN] - (u_char *)ip;
|
1994-05-24 10:09:53 +00:00
|
|
|
goto bad;
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
2001-10-25 06:27:51 +00:00
|
|
|
if ((off = cp[IPOPT_OFFSET]) < 5) {
|
|
|
|
code = &cp[IPOPT_OLEN] - (u_char *)ip;
|
2001-06-11 12:39:29 +00:00
|
|
|
goto bad;
|
|
|
|
}
|
2001-10-25 06:27:51 +00:00
|
|
|
if (off > optlen - (int)sizeof(int32_t)) {
|
|
|
|
cp[IPOPT_OFFSET + 1] += (1 << 4);
|
|
|
|
if ((cp[IPOPT_OFFSET + 1] & 0xf0) == 0) {
|
|
|
|
code = &cp[IPOPT_OFFSET] - (u_char *)ip;
|
1994-05-24 10:09:53 +00:00
|
|
|
goto bad;
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
}
|
2001-10-25 06:27:51 +00:00
|
|
|
off--; /* 0 origin */
|
|
|
|
sin = (struct in_addr *)(cp + off);
|
|
|
|
switch (cp[IPOPT_OFFSET + 1] & 0x0f) {
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case IPOPT_TS_TSONLY:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPOPT_TS_TSANDADDR:
|
2001-10-25 06:27:51 +00:00
|
|
|
if (off + sizeof(n_time) +
|
|
|
|
sizeof(struct in_addr) > optlen) {
|
|
|
|
code = &cp[IPOPT_OFFSET] - (u_char *)ip;
|
1994-05-24 10:09:53 +00:00
|
|
|
goto bad;
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
ipaddr.sin_addr = dst;
|
|
|
|
ia = (INA)ifaof_ifpforaddr((SA)&ipaddr,
|
|
|
|
m->m_pkthdr.rcvif);
|
|
|
|
if (ia == 0)
|
|
|
|
continue;
|
1995-05-09 13:35:48 +00:00
|
|
|
(void)memcpy(sin, &IA_SIN(ia)->sin_addr,
|
|
|
|
sizeof(struct in_addr));
|
2001-10-25 06:27:51 +00:00
|
|
|
cp[IPOPT_OFFSET] += sizeof(struct in_addr);
|
2002-10-10 12:03:36 +00:00
|
|
|
off += sizeof(struct in_addr);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case IPOPT_TS_PRESPEC:
|
2001-10-25 06:27:51 +00:00
|
|
|
if (off + sizeof(n_time) +
|
|
|
|
sizeof(struct in_addr) > optlen) {
|
|
|
|
code = &cp[IPOPT_OFFSET] - (u_char *)ip;
|
1994-05-24 10:09:53 +00:00
|
|
|
goto bad;
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
1995-05-09 13:35:48 +00:00
|
|
|
(void)memcpy(&ipaddr.sin_addr, sin,
|
1994-05-24 10:09:53 +00:00
|
|
|
sizeof(struct in_addr));
|
|
|
|
if (ifa_ifwithaddr((SA)&ipaddr) == 0)
|
|
|
|
continue;
|
2001-10-25 06:27:51 +00:00
|
|
|
cp[IPOPT_OFFSET] += sizeof(struct in_addr);
|
2002-10-10 12:03:36 +00:00
|
|
|
off += sizeof(struct in_addr);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2001-10-25 06:27:51 +00:00
|
|
|
code = &cp[IPOPT_OFFSET + 1] - (u_char *)ip;
|
1994-05-24 10:09:53 +00:00
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
ntime = iptime();
|
2001-10-25 06:27:51 +00:00
|
|
|
(void)memcpy(cp + off, &ntime, sizeof(n_time));
|
|
|
|
cp[IPOPT_OFFSET] += sizeof(n_time);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
1998-02-12 03:37:45 +00:00
|
|
|
if (forward && ipforwarding) {
|
2003-11-14 21:48:57 +00:00
|
|
|
ip_forward(m, 1, next_hop);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
bad:
|
|
|
|
icmp_error(m, type, code, 0, 0);
|
|
|
|
ipstat.ips_badoptions++;
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Given address of next destination (final or next hop),
|
|
|
|
* return internet address info of interface to be used to get there.
|
|
|
|
*/
|
2001-11-30 10:40:28 +00:00
|
|
|
struct in_ifaddr *
|
2003-11-14 21:48:57 +00:00
|
|
|
ip_rtaddr(dst)
|
2001-11-30 10:40:28 +00:00
|
|
|
struct in_addr dst;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2003-11-20 20:07:39 +00:00
|
|
|
struct route sro;
|
2003-11-14 21:48:57 +00:00
|
|
|
struct sockaddr_in *sin;
|
|
|
|
struct in_ifaddr *ifa;
|
|
|
|
|
2003-11-20 20:07:39 +00:00
|
|
|
sro.ro_rt = NULL;
|
|
|
|
sin = (struct sockaddr_in *)&sro.ro_dst;
|
2003-11-14 21:48:57 +00:00
|
|
|
sin->sin_family = AF_INET;
|
|
|
|
sin->sin_len = sizeof(*sin);
|
|
|
|
sin->sin_addr = dst;
|
2003-11-20 20:07:39 +00:00
|
|
|
rtalloc_ign(&sro, RTF_CLONING);
|
2003-11-14 21:48:57 +00:00
|
|
|
|
2003-11-20 20:07:39 +00:00
|
|
|
if (sro.ro_rt == NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
return ((struct in_ifaddr *)0);
|
2003-11-14 21:48:57 +00:00
|
|
|
|
2003-11-20 20:07:39 +00:00
|
|
|
ifa = ifatoia(sro.ro_rt->rt_ifa);
|
|
|
|
RTFREE(sro.ro_rt);
|
2003-11-14 21:48:57 +00:00
|
|
|
return ifa;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Save incoming source route for use in replies,
|
|
|
|
* to be picked up later by ip_srcroute if the receiver is interested.
|
|
|
|
*/
|
2002-09-28 17:15:38 +00:00
|
|
|
static void
|
1994-05-24 10:09:53 +00:00
|
|
|
save_rte(option, dst)
|
|
|
|
u_char *option;
|
|
|
|
struct in_addr dst;
|
|
|
|
{
|
|
|
|
unsigned olen;
|
|
|
|
|
|
|
|
olen = option[IPOPT_OLEN];
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (ipprintfs)
|
|
|
|
printf("save_rte: olen %d\n", olen);
|
|
|
|
#endif
|
|
|
|
if (olen > sizeof(ip_srcrt) - (1 + sizeof(dst)))
|
|
|
|
return;
|
1996-06-08 08:19:03 +00:00
|
|
|
bcopy(option, ip_srcrt.srcopt, olen);
|
1994-05-24 10:09:53 +00:00
|
|
|
ip_nhops = (olen - IPOPT_OFFSET - 1) / sizeof(struct in_addr);
|
|
|
|
ip_srcrt.dst = dst;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Retrieve incoming source route for use in replies,
|
|
|
|
* in the same form used by setsockopt.
|
|
|
|
* The first hop is placed before the options, will be removed later.
|
|
|
|
*/
|
|
|
|
struct mbuf *
|
|
|
|
ip_srcroute()
|
|
|
|
{
|
|
|
|
register struct in_addr *p, *q;
|
|
|
|
register struct mbuf *m;
|
|
|
|
|
|
|
|
if (ip_nhops == 0)
|
|
|
|
return ((struct mbuf *)0);
|
2003-02-19 05:47:46 +00:00
|
|
|
m = m_get(M_DONTWAIT, MT_HEADER);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (m == 0)
|
|
|
|
return ((struct mbuf *)0);
|
|
|
|
|
|
|
|
#define OPTSIZ (sizeof(ip_srcrt.nop) + sizeof(ip_srcrt.srcopt))
|
|
|
|
|
|
|
|
/* length is (nhops+1)*sizeof(addr) + sizeof(nop + srcrt header) */
|
|
|
|
m->m_len = ip_nhops * sizeof(struct in_addr) + sizeof(struct in_addr) +
|
|
|
|
OPTSIZ;
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (ipprintfs)
|
|
|
|
printf("ip_srcroute: nhops %d mlen %d", ip_nhops, m->m_len);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First save first hop for return route
|
|
|
|
*/
|
|
|
|
p = &ip_srcrt.route[ip_nhops - 1];
|
|
|
|
*(mtod(m, struct in_addr *)) = *p--;
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (ipprintfs)
|
1998-12-21 22:40:54 +00:00
|
|
|
printf(" hops %lx", (u_long)ntohl(mtod(m, struct in_addr *)->s_addr));
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy option fields and padding (nop) to mbuf.
|
|
|
|
*/
|
|
|
|
ip_srcrt.nop = IPOPT_NOP;
|
|
|
|
ip_srcrt.srcopt[IPOPT_OFFSET] = IPOPT_MINOFF;
|
1995-05-09 13:35:48 +00:00
|
|
|
(void)memcpy(mtod(m, caddr_t) + sizeof(struct in_addr),
|
|
|
|
&ip_srcrt.nop, OPTSIZ);
|
1994-05-24 10:09:53 +00:00
|
|
|
q = (struct in_addr *)(mtod(m, caddr_t) +
|
|
|
|
sizeof(struct in_addr) + OPTSIZ);
|
|
|
|
#undef OPTSIZ
|
|
|
|
/*
|
|
|
|
* Record return path as an IP source route,
|
|
|
|
* reversing the path (pointers are now aligned).
|
|
|
|
*/
|
|
|
|
while (p >= ip_srcrt.route) {
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (ipprintfs)
|
1998-12-21 22:40:54 +00:00
|
|
|
printf(" %lx", (u_long)ntohl(q->s_addr));
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
|
|
|
*q++ = *p--;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Last hop goes to final destination.
|
|
|
|
*/
|
|
|
|
*q = ip_srcrt.dst;
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (ipprintfs)
|
1998-12-21 22:40:54 +00:00
|
|
|
printf(" %lx\n", (u_long)ntohl(q->s_addr));
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
|
|
|
return (m);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Strip out IP options, at higher
|
|
|
|
* level protocol in the kernel.
|
|
|
|
* Second argument is buffer to which options
|
|
|
|
* will be moved, and return value is their length.
|
|
|
|
* XXX should be deleted; last arg currently ignored.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ip_stripoptions(m, mopt)
|
|
|
|
register struct mbuf *m;
|
|
|
|
struct mbuf *mopt;
|
|
|
|
{
|
|
|
|
register int i;
|
|
|
|
struct ip *ip = mtod(m, struct ip *);
|
|
|
|
register caddr_t opts;
|
|
|
|
int olen;
|
|
|
|
|
2002-10-20 22:52:07 +00:00
|
|
|
olen = (ip->ip_hl << 2) - sizeof (struct ip);
|
1994-05-24 10:09:53 +00:00
|
|
|
opts = (caddr_t)(ip + 1);
|
|
|
|
i = m->m_len - (sizeof (struct ip) + olen);
|
1995-05-09 13:35:48 +00:00
|
|
|
bcopy(opts + olen, opts, (unsigned)i);
|
1994-05-24 10:09:53 +00:00
|
|
|
m->m_len -= olen;
|
|
|
|
if (m->m_flags & M_PKTHDR)
|
|
|
|
m->m_pkthdr.len -= olen;
|
2002-10-20 22:52:07 +00:00
|
|
|
ip->ip_v = IPVERSION;
|
|
|
|
ip->ip_hl = sizeof(struct ip) >> 2;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
u_char inetctlerrmap[PRC_NCMDS] = {
|
|
|
|
0, 0, 0, 0,
|
|
|
|
0, EMSGSIZE, EHOSTDOWN, EHOSTUNREACH,
|
|
|
|
EHOSTUNREACH, EHOSTUNREACH, ECONNREFUSED, ECONNREFUSED,
|
|
|
|
EMSGSIZE, EHOSTUNREACH, 0, 0,
|
2003-06-17 06:21:08 +00:00
|
|
|
0, 0, EHOSTUNREACH, 0,
|
2001-08-27 22:10:07 +00:00
|
|
|
ENOPROTOOPT, ECONNREFUSED
|
1994-05-24 10:09:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Forward a packet. If some error occurs return the sender
|
|
|
|
* an icmp packet. Note we can't always generate a meaningful
|
|
|
|
* icmp message because icmp doesn't have a large enough repertoire
|
|
|
|
* of codes and types.
|
|
|
|
*
|
|
|
|
* If not forwarding, just drop the packet. This could be confusing
|
|
|
|
* if ipforwarding was zero but some routing protocol was advancing
|
|
|
|
* us as a gateway to somewhere. However, we must let the routing
|
|
|
|
* protocol deal with that.
|
|
|
|
*
|
|
|
|
* The srcrt parameter indicates whether the packet is being forwarded
|
|
|
|
* via a source route.
|
|
|
|
*/
|
1995-11-14 20:34:56 +00:00
|
|
|
static void
|
2003-11-14 21:48:57 +00:00
|
|
|
ip_forward(struct mbuf *m, int srcrt, struct sockaddr_in *next_hop)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
struct ip *ip = mtod(m, struct ip *);
|
2003-11-14 21:48:57 +00:00
|
|
|
struct in_ifaddr *ia;
|
1994-05-25 09:21:21 +00:00
|
|
|
int error, type = 0, code = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct mbuf *mcopy;
|
|
|
|
n_long dest;
|
2001-12-28 21:21:57 +00:00
|
|
|
struct in_addr pkt_dst;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct ifnet *destifp;
|
2002-10-16 02:25:05 +00:00
|
|
|
#if defined(IPSEC) || defined(FAST_IPSEC)
|
1999-12-22 19:13:38 +00:00
|
|
|
struct ifnet dummyifp;
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-12-28 21:21:57 +00:00
|
|
|
/*
|
|
|
|
* Cache the destination address of the packet; this may be
|
|
|
|
* changed by use of 'ipfw fwd'.
|
|
|
|
*/
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
pkt_dst = next_hop ? next_hop->sin_addr : ip->ip_dst;
|
2001-12-28 21:21:57 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (ipprintfs)
|
1994-10-28 15:09:49 +00:00
|
|
|
printf("forward: src %lx dst %lx ttl %x\n",
|
2001-12-28 21:21:57 +00:00
|
|
|
(u_long)ip->ip_src.s_addr, (u_long)pkt_dst.s_addr,
|
1998-08-17 01:05:25 +00:00
|
|
|
ip->ip_ttl);
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
1994-10-28 15:09:49 +00:00
|
|
|
|
|
|
|
|
2001-12-28 21:21:57 +00:00
|
|
|
if (m->m_flags & (M_BCAST|M_MCAST) || in_canforward(pkt_dst) == 0) {
|
1994-05-24 10:09:53 +00:00
|
|
|
ipstat.ips_cantforward++;
|
|
|
|
m_freem(m);
|
|
|
|
return;
|
|
|
|
}
|
1999-02-22 18:19:57 +00:00
|
|
|
#ifdef IPSTEALTH
|
|
|
|
if (!ipstealth) {
|
|
|
|
#endif
|
|
|
|
if (ip->ip_ttl <= IPTTLDEC) {
|
|
|
|
icmp_error(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS,
|
2003-11-14 21:48:57 +00:00
|
|
|
0, 0);
|
1999-02-22 18:19:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
#ifdef IPSTEALTH
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1999-02-22 18:19:57 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2003-11-14 21:48:57 +00:00
|
|
|
if ((ia = ip_rtaddr(pkt_dst)) == 0) {
|
|
|
|
icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, 0);
|
Make sure the cached forwarding route (ipforward_rt) is still up before
using it. Not checking this may have caused the wrong IP address to be
used when processing certain IP options (see example below). This also
caused the wrong route to be passed to ip_output() when forwarding, but
fortunately ip_output() is smart enough to detect this.
This example demonstrates the wrong behavior of the Record Route option
observed with this bug. Host ``freebsd'' is acting as the gateway for
the ``sysv''.
1. On the gateway, we add the route to the destination. The new route
will use the primary address of the loopback interface, 127.0.0.1:
: freebsd# route add 10.0.0.66 -iface lo0 -reject
: add host 10.0.0.66: gateway lo0
2. From the client, we ping the destination. We see the correct replies.
Please note that this also causes the relevant route on the ``freebsd''
gateway to be cached in ipforward_rt variable:
: sysv# ping -snv 10.0.0.66
: PING 10.0.0.66: 56 data bytes
: ICMP Host Unreachable from gateway 192.168.0.115
: ICMP Host Unreachable from gateway 192.168.0.115
: ICMP Host Unreachable from gateway 192.168.0.115
:
: ----10.0.0.66 PING Statistics----
: 3 packets transmitted, 0 packets received, 100% packet loss
3. On the gateway, we delete the route to the destination, thus making
the destination reachable through the `default' route:
: freebsd# route delete 10.0.0.66
: delete host 10.0.0.66
4. From the client, we ping destination again, now with the RR option
turned on. The surprise here is the 127.0.0.1 in the first reply.
This is caused by the bug in ip_rtaddr() not checking the cached
route is still up befor use. The debug code also shows that the
wrong (down) route is further passed to ip_output(). The latter
detects that the route is down, and replaces the bogus route with
the valid one, so we see the correct replies (192.168.0.115) on
further probes:
: sysv# ping -snRv 10.0.0.66
: PING 10.0.0.66: 56 data bytes
: 64 bytes from 10.0.0.66: icmp_seq=0. time=10. ms
: IP options: <record route> 127.0.0.1, 10.0.0.65, 10.0.0.66,
: 192.168.0.65, 192.168.0.115, 192.168.0.120,
: 0.0.0.0(Current), 0.0.0.0, 0.0.0.0
: 64 bytes from 10.0.0.66: icmp_seq=1. time=0. ms
: IP options: <record route> 192.168.0.115, 10.0.0.65, 10.0.0.66,
: 192.168.0.65, 192.168.0.115, 192.168.0.120,
: 0.0.0.0(Current), 0.0.0.0, 0.0.0.0
: 64 bytes from 10.0.0.66: icmp_seq=2. time=0. ms
: IP options: <record route> 192.168.0.115, 10.0.0.65, 10.0.0.66,
: 192.168.0.65, 192.168.0.115, 192.168.0.120,
: 0.0.0.0(Current), 0.0.0.0, 0.0.0.0
:
: ----10.0.0.66 PING Statistics----
: 3 packets transmitted, 3 packets received, 0% packet loss
: round-trip (ms) min/avg/max = 0/3/10
2001-03-18 13:04:07 +00:00
|
|
|
return;
|
2003-11-14 21:48:57 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
It was possible for ip_forward() to supply to icmp_error()
an IP header with ip_len in network byte order. For certain
values of ip_len, this could cause icmp_error() to write
beyond the end of an mbuf, causing mbuf free-list corruption.
This problem was observed during generation of ICMP redirects.
We now make quite sure that the copy of the IP header kept
for icmp_error() is stored in a non-shared mbuf header so
that it will not be modified by ip_output().
Also:
- Calculate the correct number of bytes that need to be
retained for icmp_error(), instead of assuming that 64
is enough (it's not).
- In icmp_error(), use m_copydata instead of bcopy() to
copy from the supplied mbuf chain, in case the first 8
bytes of IP payload are not stored directly after the IP
header.
- Sanity-check ip_len in icmp_error(), and panic if it is
less than sizeof(struct ip). Incoming packets with bad
ip_len values are discarded in ip_input(), so this should
only be triggered by bugs in the code, not by bad packets.
This patch results from code and suggestions from Ruslan, Bosko,
Jonathan Lemon and Matt Dillon, with important testing by Mike
Tancsa, who could reproduce this problem at will.
Reported by: Mike Tancsa <mike@sentex.net>
Reviewed by: ru, bmilekic, jlemon, dillon
2001-03-08 19:03:26 +00:00
|
|
|
* Save the IP header and at most 8 bytes of the payload,
|
|
|
|
* in case we need to generate an ICMP message to the src.
|
|
|
|
*
|
2002-06-23 20:48:26 +00:00
|
|
|
* XXX this can be optimized a lot by saving the data in a local
|
|
|
|
* buffer on the stack (72 bytes at most), and only allocating the
|
|
|
|
* mbuf if really necessary. The vast majority of the packets
|
|
|
|
* are forwarded without having to send an ICMP back (either
|
|
|
|
* because unnecessary, or because rate limited), so we are
|
|
|
|
* really we are wasting a lot of work here.
|
|
|
|
*
|
It was possible for ip_forward() to supply to icmp_error()
an IP header with ip_len in network byte order. For certain
values of ip_len, this could cause icmp_error() to write
beyond the end of an mbuf, causing mbuf free-list corruption.
This problem was observed during generation of ICMP redirects.
We now make quite sure that the copy of the IP header kept
for icmp_error() is stored in a non-shared mbuf header so
that it will not be modified by ip_output().
Also:
- Calculate the correct number of bytes that need to be
retained for icmp_error(), instead of assuming that 64
is enough (it's not).
- In icmp_error(), use m_copydata instead of bcopy() to
copy from the supplied mbuf chain, in case the first 8
bytes of IP payload are not stored directly after the IP
header.
- Sanity-check ip_len in icmp_error(), and panic if it is
less than sizeof(struct ip). Incoming packets with bad
ip_len values are discarded in ip_input(), so this should
only be triggered by bugs in the code, not by bad packets.
This patch results from code and suggestions from Ruslan, Bosko,
Jonathan Lemon and Matt Dillon, with important testing by Mike
Tancsa, who could reproduce this problem at will.
Reported by: Mike Tancsa <mike@sentex.net>
Reviewed by: ru, bmilekic, jlemon, dillon
2001-03-08 19:03:26 +00:00
|
|
|
* We don't use m_copy() because it might return a reference
|
|
|
|
* to a shared cluster. Both this function and ip_output()
|
|
|
|
* assume exclusive access to the IP header in `m', so any
|
|
|
|
* data in a cluster may change before we reach icmp_error().
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2003-02-19 05:47:46 +00:00
|
|
|
MGET(mcopy, M_DONTWAIT, m->m_type);
|
|
|
|
if (mcopy != NULL && !m_dup_pkthdr(mcopy, m, M_DONTWAIT)) {
|
2002-12-30 20:22:40 +00:00
|
|
|
/*
|
|
|
|
* It's probably ok if the pkthdr dup fails (because
|
|
|
|
* the deep copy of the tag chain failed), but for now
|
|
|
|
* be conservative and just discard the copy since
|
|
|
|
* code below may some day want the tags.
|
|
|
|
*/
|
|
|
|
m_free(mcopy);
|
|
|
|
mcopy = NULL;
|
|
|
|
}
|
It was possible for ip_forward() to supply to icmp_error()
an IP header with ip_len in network byte order. For certain
values of ip_len, this could cause icmp_error() to write
beyond the end of an mbuf, causing mbuf free-list corruption.
This problem was observed during generation of ICMP redirects.
We now make quite sure that the copy of the IP header kept
for icmp_error() is stored in a non-shared mbuf header so
that it will not be modified by ip_output().
Also:
- Calculate the correct number of bytes that need to be
retained for icmp_error(), instead of assuming that 64
is enough (it's not).
- In icmp_error(), use m_copydata instead of bcopy() to
copy from the supplied mbuf chain, in case the first 8
bytes of IP payload are not stored directly after the IP
header.
- Sanity-check ip_len in icmp_error(), and panic if it is
less than sizeof(struct ip). Incoming packets with bad
ip_len values are discarded in ip_input(), so this should
only be triggered by bugs in the code, not by bad packets.
This patch results from code and suggestions from Ruslan, Bosko,
Jonathan Lemon and Matt Dillon, with important testing by Mike
Tancsa, who could reproduce this problem at will.
Reported by: Mike Tancsa <mike@sentex.net>
Reviewed by: ru, bmilekic, jlemon, dillon
2001-03-08 19:03:26 +00:00
|
|
|
if (mcopy != NULL) {
|
2002-10-20 22:52:07 +00:00
|
|
|
mcopy->m_len = imin((ip->ip_hl << 2) + 8,
|
It was possible for ip_forward() to supply to icmp_error()
an IP header with ip_len in network byte order. For certain
values of ip_len, this could cause icmp_error() to write
beyond the end of an mbuf, causing mbuf free-list corruption.
This problem was observed during generation of ICMP redirects.
We now make quite sure that the copy of the IP header kept
for icmp_error() is stored in a non-shared mbuf header so
that it will not be modified by ip_output().
Also:
- Calculate the correct number of bytes that need to be
retained for icmp_error(), instead of assuming that 64
is enough (it's not).
- In icmp_error(), use m_copydata instead of bcopy() to
copy from the supplied mbuf chain, in case the first 8
bytes of IP payload are not stored directly after the IP
header.
- Sanity-check ip_len in icmp_error(), and panic if it is
less than sizeof(struct ip). Incoming packets with bad
ip_len values are discarded in ip_input(), so this should
only be triggered by bugs in the code, not by bad packets.
This patch results from code and suggestions from Ruslan, Bosko,
Jonathan Lemon and Matt Dillon, with important testing by Mike
Tancsa, who could reproduce this problem at will.
Reported by: Mike Tancsa <mike@sentex.net>
Reviewed by: ru, bmilekic, jlemon, dillon
2001-03-08 19:03:26 +00:00
|
|
|
(int)ip->ip_len);
|
|
|
|
m_copydata(m, 0, mcopy->m_len, mtod(mcopy, caddr_t));
|
|
|
|
}
|
Fixed broken ICMP error generation, unified conversion of IP header
fields between host and network byte order. The details:
o icmp_error() now does not add IP header length. This fixes the problem
when icmp_error() is called from ip_forward(). In this case the ip_len
of the original IP datagram returned with ICMP error was wrong.
o icmp_error() expects all three fields, ip_len, ip_id and ip_off in host
byte order, so DTRT and convert these fields back to network byte order
before sending a message. This fixes the problem described in PR 16240
and PR 20877 (ip_id field was returned in host byte order).
o ip_ttl decrement operation in ip_forward() was moved down to make sure
that it does not corrupt the copy of original IP datagram passed later
to icmp_error().
o A copy of original IP datagram in ip_forward() was made a read-write,
independent copy. This fixes the problem I first reported to Garrett
Wollman and Bill Fenner and later put in audit trail of PR 16240:
ip_output() (not always) converts fields of original datagram to network
byte order, but because copy (mcopy) and its original (m) most likely
share the same mbuf cluster, ip_output()'s manipulations on original
also corrupted the copy.
o ip_output() now expects all three fields, ip_len, ip_off and (what is
significant) ip_id in host byte order. It was a headache for years that
ip_id was handled differently. The only compatibility issue here is the
raw IP socket interface with IP_HDRINCL socket option set and a non-zero
ip_id field, but ip.4 manual page was unclear on whether in this case
ip_id field should be in host or network byte order.
2000-09-01 12:33:03 +00:00
|
|
|
|
|
|
|
#ifdef IPSTEALTH
|
|
|
|
if (!ipstealth) {
|
|
|
|
#endif
|
|
|
|
ip->ip_ttl -= IPTTLDEC;
|
|
|
|
#ifdef IPSTEALTH
|
|
|
|
}
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If forwarding packet using same interface that it came in on,
|
|
|
|
* perhaps should send a redirect to sender to shortcut a hop.
|
|
|
|
* Only send redirect if source is sending directly to us,
|
|
|
|
* and if packet was not source routed (or has any options).
|
|
|
|
* Also, don't send redirect if forwarding using a default route
|
|
|
|
* or a route modified by a redirect.
|
|
|
|
*/
|
2003-11-14 21:48:57 +00:00
|
|
|
dest = 0;
|
|
|
|
if (ipsendredirects && ia->ia_ifp == m->m_pkthdr.rcvif) {
|
|
|
|
struct sockaddr_in *sin;
|
|
|
|
struct route ro;
|
|
|
|
struct rtentry *rt;
|
|
|
|
|
2003-11-20 20:07:39 +00:00
|
|
|
ro.ro_rt = NULL;
|
2003-11-14 21:48:57 +00:00
|
|
|
sin = (struct sockaddr_in *)&ro.ro_dst;
|
|
|
|
sin->sin_family = AF_INET;
|
|
|
|
sin->sin_len = sizeof(*sin);
|
|
|
|
sin->sin_addr = pkt_dst;
|
2003-11-20 19:47:31 +00:00
|
|
|
rtalloc_ign(&ro, RTF_CLONING);
|
2003-11-14 21:48:57 +00:00
|
|
|
|
|
|
|
rt = ro.ro_rt;
|
|
|
|
|
|
|
|
if (rt && (rt->rt_flags & (RTF_DYNAMIC|RTF_MODIFIED)) == 0 &&
|
|
|
|
satosin(rt_key(rt))->sin_addr.s_addr != 0 &&
|
|
|
|
ipsendredirects && !srcrt && !next_hop) {
|
1994-05-24 10:09:53 +00:00
|
|
|
#define RTA(rt) ((struct in_ifaddr *)(rt->rt_ifa))
|
2003-11-14 21:48:57 +00:00
|
|
|
u_long src = ntohl(ip->ip_src.s_addr);
|
|
|
|
|
|
|
|
if (RTA(rt) &&
|
|
|
|
(src & RTA(rt)->ia_subnetmask) == RTA(rt)->ia_subnet) {
|
|
|
|
if (rt->rt_flags & RTF_GATEWAY)
|
|
|
|
dest = satosin(rt->rt_gateway)->sin_addr.s_addr;
|
|
|
|
else
|
|
|
|
dest = pkt_dst.s_addr;
|
|
|
|
/* Router requirements says to only send host redirects */
|
|
|
|
type = ICMP_REDIRECT;
|
|
|
|
code = ICMP_REDIRECT_HOST;
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
2003-11-14 21:48:57 +00:00
|
|
|
if (ipprintfs)
|
|
|
|
printf("redirect (%d) to %lx\n", code, (u_long)dest);
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
2003-11-14 21:48:57 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2003-11-14 21:48:57 +00:00
|
|
|
if (rt)
|
|
|
|
RTFREE(rt);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2002-08-03 14:59:45 +00:00
|
|
|
{
|
|
|
|
struct m_hdr tag;
|
|
|
|
|
|
|
|
if (next_hop) {
|
|
|
|
/* Pass IPFORWARD info if available */
|
|
|
|
|
|
|
|
tag.mh_type = MT_TAG;
|
|
|
|
tag.mh_flags = PACKET_TAG_IPFORWARD;
|
|
|
|
tag.mh_data = (caddr_t)next_hop;
|
|
|
|
tag.mh_next = m;
|
2003-11-17 03:17:49 +00:00
|
|
|
tag.mh_nextpkt = NULL;
|
2002-08-03 14:59:45 +00:00
|
|
|
m = (struct mbuf *)&tag;
|
|
|
|
}
|
2003-11-14 21:48:57 +00:00
|
|
|
error = ip_output(m, (struct mbuf *)0, NULL, IP_FORWARDING, 0, NULL);
|
2002-08-03 14:59:45 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error)
|
|
|
|
ipstat.ips_cantforward++;
|
|
|
|
else {
|
|
|
|
ipstat.ips_forward++;
|
|
|
|
if (type)
|
|
|
|
ipstat.ips_redirectsent++;
|
|
|
|
else {
|
2003-11-14 21:02:22 +00:00
|
|
|
if (mcopy)
|
1994-05-24 10:09:53 +00:00
|
|
|
m_freem(mcopy);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (mcopy == NULL)
|
|
|
|
return;
|
|
|
|
destifp = NULL;
|
|
|
|
|
|
|
|
switch (error) {
|
|
|
|
|
|
|
|
case 0: /* forwarded, but need redirect */
|
|
|
|
/* type, code set above */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ENETUNREACH: /* shouldn't happen, checked above */
|
|
|
|
case EHOSTUNREACH:
|
|
|
|
case ENETDOWN:
|
|
|
|
case EHOSTDOWN:
|
|
|
|
default:
|
|
|
|
type = ICMP_UNREACH;
|
|
|
|
code = ICMP_UNREACH_HOST;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case EMSGSIZE:
|
|
|
|
type = ICMP_UNREACH;
|
|
|
|
code = ICMP_UNREACH_NEEDFRAG;
|
2003-11-14 21:48:57 +00:00
|
|
|
#if defined(IPSEC) || defined(FAST_IPSEC)
|
1999-12-22 19:13:38 +00:00
|
|
|
/*
|
|
|
|
* If the packet is routed over IPsec tunnel, tell the
|
|
|
|
* originator the tunnel MTU.
|
|
|
|
* tunnel MTU = if MTU - sizeof(IP) - ESP/AH hdrsiz
|
|
|
|
* XXX quickhack!!!
|
|
|
|
*/
|
2003-11-14 21:48:57 +00:00
|
|
|
{
|
1999-12-22 19:13:38 +00:00
|
|
|
struct secpolicy *sp = NULL;
|
|
|
|
int ipsecerror;
|
|
|
|
int ipsechdr;
|
2003-11-14 21:48:57 +00:00
|
|
|
struct route *ro;
|
1999-12-22 19:13:38 +00:00
|
|
|
|
2003-11-14 21:48:57 +00:00
|
|
|
#ifdef IPSEC
|
1999-12-22 19:13:38 +00:00
|
|
|
sp = ipsec4_getpolicybyaddr(mcopy,
|
|
|
|
IPSEC_DIR_OUTBOUND,
|
2003-11-14 21:48:57 +00:00
|
|
|
IP_FORWARDING,
|
|
|
|
&ipsecerror);
|
|
|
|
#else /* FAST_IPSEC */
|
2002-10-16 02:25:05 +00:00
|
|
|
sp = ipsec_getpolicybyaddr(mcopy,
|
|
|
|
IPSEC_DIR_OUTBOUND,
|
2003-11-14 21:48:57 +00:00
|
|
|
IP_FORWARDING,
|
|
|
|
&ipsecerror);
|
|
|
|
#endif
|
|
|
|
if (sp != NULL) {
|
2002-10-16 02:25:05 +00:00
|
|
|
/* count IPsec header size */
|
|
|
|
ipsechdr = ipsec4_hdrsiz(mcopy,
|
|
|
|
IPSEC_DIR_OUTBOUND,
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* find the correct route for outer IPv4
|
|
|
|
* header, compute tunnel MTU.
|
|
|
|
*
|
|
|
|
* XXX BUG ALERT
|
|
|
|
* The "dummyifp" code relies upon the fact
|
|
|
|
* that icmp_error() touches only ifp->if_mtu.
|
|
|
|
*/
|
|
|
|
/*XXX*/
|
|
|
|
destifp = NULL;
|
|
|
|
if (sp->req != NULL
|
|
|
|
&& sp->req->sav != NULL
|
|
|
|
&& sp->req->sav->sah != NULL) {
|
2003-11-14 21:48:57 +00:00
|
|
|
ro = &sp->req->sav->sah->sa_route;
|
|
|
|
if (ro->ro_rt && ro->ro_rt->rt_ifp) {
|
2002-10-16 02:25:05 +00:00
|
|
|
dummyifp.if_mtu =
|
2003-11-14 21:48:57 +00:00
|
|
|
ro->ro_rt->rt_ifp->if_mtu;
|
2002-10-16 02:25:05 +00:00
|
|
|
dummyifp.if_mtu -= ipsechdr;
|
|
|
|
destifp = &dummyifp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-11-14 21:48:57 +00:00
|
|
|
#ifdef IPSEC
|
|
|
|
key_freesp(sp);
|
|
|
|
#else /* FAST_IPSEC */
|
2002-10-16 02:25:05 +00:00
|
|
|
KEY_FREESP(&sp);
|
2003-11-14 21:48:57 +00:00
|
|
|
#endif
|
|
|
|
ipstat.ips_cantfrag++;
|
|
|
|
break;
|
|
|
|
} else
|
|
|
|
#endif /*IPSEC || FAST_IPSEC*/
|
|
|
|
destifp = ia->ia_ifp;
|
|
|
|
#if defined(IPSEC) || defined(FAST_IPSEC)
|
2002-10-16 02:25:05 +00:00
|
|
|
}
|
2003-11-14 21:48:57 +00:00
|
|
|
#endif /*IPSEC || FAST_IPSEC*/
|
1994-05-24 10:09:53 +00:00
|
|
|
ipstat.ips_cantfrag++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ENOBUFS:
|
2002-11-19 17:06:06 +00:00
|
|
|
/*
|
|
|
|
* A router should not generate ICMP_SOURCEQUENCH as
|
|
|
|
* required in RFC1812 Requirements for IP Version 4 Routers.
|
|
|
|
* Source quench could be a big problem under DoS attacks,
|
|
|
|
* or if the underlying interface is rate-limited.
|
|
|
|
* Those who need source quench packets may re-enable them
|
|
|
|
* via the net.inet.ip.sendsourcequench sysctl.
|
|
|
|
*/
|
|
|
|
if (ip_sendsourcequench == 0) {
|
|
|
|
m_freem(mcopy);
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
type = ICMP_SOURCEQUENCH;
|
|
|
|
code = 0;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
2000-05-15 18:41:01 +00:00
|
|
|
|
|
|
|
case EACCES: /* ipfw denied packet */
|
|
|
|
m_freem(mcopy);
|
|
|
|
return;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
icmp_error(mcopy, type, code, dest, destifp);
|
|
|
|
}
|
|
|
|
|
1996-11-11 04:56:32 +00:00
|
|
|
void
|
|
|
|
ip_savecontrol(inp, mp, ip, m)
|
|
|
|
register struct inpcb *inp;
|
|
|
|
register struct mbuf **mp;
|
|
|
|
register struct ip *ip;
|
|
|
|
register struct mbuf *m;
|
|
|
|
{
|
|
|
|
if (inp->inp_socket->so_options & SO_TIMESTAMP) {
|
|
|
|
struct timeval tv;
|
|
|
|
|
|
|
|
microtime(&tv);
|
|
|
|
*mp = sbcreatecontrol((caddr_t) &tv, sizeof(tv),
|
|
|
|
SCM_TIMESTAMP, SOL_SOCKET);
|
|
|
|
if (*mp)
|
|
|
|
mp = &(*mp)->m_next;
|
2002-05-31 11:52:35 +00:00
|
|
|
}
|
1996-11-11 04:56:32 +00:00
|
|
|
if (inp->inp_flags & INP_RECVDSTADDR) {
|
|
|
|
*mp = sbcreatecontrol((caddr_t) &ip->ip_dst,
|
|
|
|
sizeof(struct in_addr), IP_RECVDSTADDR, IPPROTO_IP);
|
|
|
|
if (*mp)
|
|
|
|
mp = &(*mp)->m_next;
|
|
|
|
}
|
2003-04-29 21:36:18 +00:00
|
|
|
if (inp->inp_flags & INP_RECVTTL) {
|
|
|
|
*mp = sbcreatecontrol((caddr_t) &ip->ip_ttl,
|
|
|
|
sizeof(u_char), IP_RECVTTL, IPPROTO_IP);
|
|
|
|
if (*mp)
|
|
|
|
mp = &(*mp)->m_next;
|
|
|
|
}
|
1996-11-11 04:56:32 +00:00
|
|
|
#ifdef notyet
|
|
|
|
/* XXX
|
|
|
|
* Moving these out of udp_input() made them even more broken
|
|
|
|
* than they already were.
|
|
|
|
*/
|
|
|
|
/* options were tossed already */
|
|
|
|
if (inp->inp_flags & INP_RECVOPTS) {
|
|
|
|
*mp = sbcreatecontrol((caddr_t) opts_deleted_above,
|
|
|
|
sizeof(struct in_addr), IP_RECVOPTS, IPPROTO_IP);
|
|
|
|
if (*mp)
|
|
|
|
mp = &(*mp)->m_next;
|
|
|
|
}
|
|
|
|
/* ip_srcroute doesn't do what we want here, need to fix */
|
|
|
|
if (inp->inp_flags & INP_RECVRETOPTS) {
|
|
|
|
*mp = sbcreatecontrol((caddr_t) ip_srcroute(),
|
|
|
|
sizeof(struct in_addr), IP_RECVRETOPTS, IPPROTO_IP);
|
|
|
|
if (*mp)
|
|
|
|
mp = &(*mp)->m_next;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (inp->inp_flags & INP_RECVIF) {
|
1997-11-05 02:51:32 +00:00
|
|
|
struct ifnet *ifp;
|
|
|
|
struct sdlbuf {
|
|
|
|
struct sockaddr_dl sdl;
|
|
|
|
u_char pad[32];
|
|
|
|
} sdlbuf;
|
|
|
|
struct sockaddr_dl *sdp;
|
|
|
|
struct sockaddr_dl *sdl2 = &sdlbuf.sdl;
|
|
|
|
|
|
|
|
if (((ifp = m->m_pkthdr.rcvif))
|
|
|
|
&& ( ifp->if_index && (ifp->if_index <= if_index))) {
|
2001-09-06 02:40:43 +00:00
|
|
|
sdp = (struct sockaddr_dl *)
|
|
|
|
(ifaddr_byindex(ifp->if_index)->ifa_addr);
|
1997-11-05 02:51:32 +00:00
|
|
|
/*
|
|
|
|
* Change our mind and don't try copy.
|
|
|
|
*/
|
|
|
|
if ((sdp->sdl_family != AF_LINK)
|
|
|
|
|| (sdp->sdl_len > sizeof(sdlbuf))) {
|
|
|
|
goto makedummy;
|
|
|
|
}
|
|
|
|
bcopy(sdp, sdl2, sdp->sdl_len);
|
|
|
|
} else {
|
|
|
|
makedummy:
|
|
|
|
sdl2->sdl_len
|
|
|
|
= offsetof(struct sockaddr_dl, sdl_data[0]);
|
|
|
|
sdl2->sdl_family = AF_LINK;
|
|
|
|
sdl2->sdl_index = 0;
|
|
|
|
sdl2->sdl_nlen = sdl2->sdl_alen = sdl2->sdl_slen = 0;
|
|
|
|
}
|
|
|
|
*mp = sbcreatecontrol((caddr_t) sdl2, sdl2->sdl_len,
|
1996-11-11 04:56:32 +00:00
|
|
|
IP_RECVIF, IPPROTO_IP);
|
|
|
|
if (*mp)
|
|
|
|
mp = &(*mp)->m_next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-06-23 20:48:26 +00:00
|
|
|
/*
|
|
|
|
* XXX these routines are called from the upper part of the kernel.
|
|
|
|
* They need to be locked when we remove Giant.
|
|
|
|
*
|
|
|
|
* They could also be moved to ip_mroute.c, since all the RSVP
|
|
|
|
* handling is done there already.
|
|
|
|
*/
|
|
|
|
static int ip_rsvp_on;
|
|
|
|
struct socket *ip_rsvpd;
|
1994-09-06 22:42:31 +00:00
|
|
|
int
|
|
|
|
ip_rsvp_init(struct socket *so)
|
|
|
|
{
|
|
|
|
if (so->so_type != SOCK_RAW ||
|
|
|
|
so->so_proto->pr_protocol != IPPROTO_RSVP)
|
Massive cleanup of the ip_mroute code.
No functional changes, but:
+ the mrouting module now should behave the same as the compiled-in
version (it did not before, some of the rsvp code was not loaded
properly);
+ netinet/ip_mroute.c is now truly optional;
+ removed some redundant/unused code;
+ changed many instances of '0' to NULL and INADDR_ANY as appropriate;
+ removed several static variables to make the code more SMP-friendly;
+ fixed some minor bugs in the mrouting code (mostly, incorrect return
values from functions).
This commit is also a prerequisite to the addition of support for PIM,
which i would like to put in before DP2 (it does not change any of
the existing APIs, anyways).
Note, in the process we found out that some device drivers fail to
properly handle changes in IFF_ALLMULTI, leading to interesting
behaviour when a multicast router is started. This bug is not
corrected by this commit, and will be fixed with a separate commit.
Detailed changes:
--------------------
netinet/ip_mroute.c all the above.
conf/files make ip_mroute.c optional
net/route.c fix mrt_ioctl hook
netinet/ip_input.c fix ip_mforward hook, move rsvp_input() here
together with other rsvp code, and a couple
of indentation fixes.
netinet/ip_output.c fix ip_mforward and ip_mcast_src hooks
netinet/ip_var.h rsvp function hooks
netinet/raw_ip.c hooks for mrouting and rsvp functions, plus
interface cleanup.
netinet/ip_mroute.h remove an unused and optional field from a struct
Most of the code is from Pavlin Radoslavov and the XORP project
Reviewed by: sam
MFC after: 1 week
2002-11-15 22:53:53 +00:00
|
|
|
return EOPNOTSUPP;
|
1994-09-06 22:42:31 +00:00
|
|
|
|
|
|
|
if (ip_rsvpd != NULL)
|
Massive cleanup of the ip_mroute code.
No functional changes, but:
+ the mrouting module now should behave the same as the compiled-in
version (it did not before, some of the rsvp code was not loaded
properly);
+ netinet/ip_mroute.c is now truly optional;
+ removed some redundant/unused code;
+ changed many instances of '0' to NULL and INADDR_ANY as appropriate;
+ removed several static variables to make the code more SMP-friendly;
+ fixed some minor bugs in the mrouting code (mostly, incorrect return
values from functions).
This commit is also a prerequisite to the addition of support for PIM,
which i would like to put in before DP2 (it does not change any of
the existing APIs, anyways).
Note, in the process we found out that some device drivers fail to
properly handle changes in IFF_ALLMULTI, leading to interesting
behaviour when a multicast router is started. This bug is not
corrected by this commit, and will be fixed with a separate commit.
Detailed changes:
--------------------
netinet/ip_mroute.c all the above.
conf/files make ip_mroute.c optional
net/route.c fix mrt_ioctl hook
netinet/ip_input.c fix ip_mforward hook, move rsvp_input() here
together with other rsvp code, and a couple
of indentation fixes.
netinet/ip_output.c fix ip_mforward and ip_mcast_src hooks
netinet/ip_var.h rsvp function hooks
netinet/raw_ip.c hooks for mrouting and rsvp functions, plus
interface cleanup.
netinet/ip_mroute.h remove an unused and optional field from a struct
Most of the code is from Pavlin Radoslavov and the XORP project
Reviewed by: sam
MFC after: 1 week
2002-11-15 22:53:53 +00:00
|
|
|
return EADDRINUSE;
|
1994-09-06 22:42:31 +00:00
|
|
|
|
|
|
|
ip_rsvpd = so;
|
1995-06-13 17:51:16 +00:00
|
|
|
/*
|
|
|
|
* This may seem silly, but we need to be sure we don't over-increment
|
|
|
|
* the RSVP counter, in case something slips up.
|
|
|
|
*/
|
|
|
|
if (!ip_rsvp_on) {
|
|
|
|
ip_rsvp_on = 1;
|
|
|
|
rsvp_on++;
|
|
|
|
}
|
1994-09-06 22:42:31 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ip_rsvp_done(void)
|
|
|
|
{
|
|
|
|
ip_rsvpd = NULL;
|
1995-06-13 17:51:16 +00:00
|
|
|
/*
|
|
|
|
* This may seem silly, but we need to be sure we don't over-decrement
|
|
|
|
* the RSVP counter, in case something slips up.
|
|
|
|
*/
|
|
|
|
if (ip_rsvp_on) {
|
|
|
|
ip_rsvp_on = 0;
|
|
|
|
rsvp_on--;
|
|
|
|
}
|
1994-09-06 22:42:31 +00:00
|
|
|
return 0;
|
|
|
|
}
|
Massive cleanup of the ip_mroute code.
No functional changes, but:
+ the mrouting module now should behave the same as the compiled-in
version (it did not before, some of the rsvp code was not loaded
properly);
+ netinet/ip_mroute.c is now truly optional;
+ removed some redundant/unused code;
+ changed many instances of '0' to NULL and INADDR_ANY as appropriate;
+ removed several static variables to make the code more SMP-friendly;
+ fixed some minor bugs in the mrouting code (mostly, incorrect return
values from functions).
This commit is also a prerequisite to the addition of support for PIM,
which i would like to put in before DP2 (it does not change any of
the existing APIs, anyways).
Note, in the process we found out that some device drivers fail to
properly handle changes in IFF_ALLMULTI, leading to interesting
behaviour when a multicast router is started. This bug is not
corrected by this commit, and will be fixed with a separate commit.
Detailed changes:
--------------------
netinet/ip_mroute.c all the above.
conf/files make ip_mroute.c optional
net/route.c fix mrt_ioctl hook
netinet/ip_input.c fix ip_mforward hook, move rsvp_input() here
together with other rsvp code, and a couple
of indentation fixes.
netinet/ip_output.c fix ip_mforward and ip_mcast_src hooks
netinet/ip_var.h rsvp function hooks
netinet/raw_ip.c hooks for mrouting and rsvp functions, plus
interface cleanup.
netinet/ip_mroute.h remove an unused and optional field from a struct
Most of the code is from Pavlin Radoslavov and the XORP project
Reviewed by: sam
MFC after: 1 week
2002-11-15 22:53:53 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
rsvp_input(struct mbuf *m, int off) /* XXX must fixup manually */
|
|
|
|
{
|
|
|
|
if (rsvp_input_p) { /* call the real one if loaded */
|
|
|
|
rsvp_input_p(m, off);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Can still get packets with rsvp_on = 0 if there is a local member
|
|
|
|
* of the group to which the RSVP packet is addressed. But in this
|
|
|
|
* case we want to throw the packet away.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!rsvp_on) {
|
|
|
|
m_freem(m);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ip_rsvpd != NULL) {
|
|
|
|
rip_input(m, off);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* Drop the packet */
|
|
|
|
m_freem(m);
|
|
|
|
}
|