2005-01-07 01:45:51 +00:00
|
|
|
/*-
|
1994-05-24 10:09:53 +00:00
|
|
|
* Copyright (c) 1980, 1986, 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.
|
|
|
|
|
* 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.
|
|
|
|
|
*
|
2001-10-17 11:10:55 +00:00
|
|
|
* @(#)route.h 8.4 (Berkeley) 1/9/95
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
|
1994-08-21 05:11:48 +00:00
|
|
|
#ifndef _NET_ROUTE_H_
|
|
|
|
|
#define _NET_ROUTE_H_
|
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
|
* Kernel resident routing tables.
|
1995-05-30 08:16:23 +00:00
|
|
|
*
|
1994-05-24 10:09:53 +00:00
|
|
|
* The routing tables are initialized when interface addresses
|
|
|
|
|
* are set by making entries for all directly connected interfaces.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
2009-04-16 20:30:28 +00:00
|
|
|
* A route consists of a destination address, a reference
|
|
|
|
|
* to a routing entry, and a reference to an llentry.
|
|
|
|
|
* These are often held by protocols in their control
|
|
|
|
|
* blocks, e.g. inpcb.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
struct route {
|
|
|
|
|
struct rtentry *ro_rt;
|
2009-04-15 20:34:19 +00:00
|
|
|
struct llentry *ro_lle;
|
2011-09-20 20:27:26 +00:00
|
|
|
struct in_ifaddr *ro_ia;
|
|
|
|
|
int ro_flags;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct sockaddr ro_dst;
|
|
|
|
|
};
|
|
|
|
|
|
2012-07-04 07:37:53 +00:00
|
|
|
#define RT_CACHING_CONTEXT 0x1 /* XXX: not used anywhere */
|
|
|
|
|
#define RT_NORTREF 0x2 /* doesn't hold reference on ro_rt */
|
2011-09-20 20:27:26 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
|
* These numbers are used by reliable protocols for determining
|
|
|
|
|
* retransmission behavior and are included in the routing structure.
|
|
|
|
|
*/
|
2003-11-20 20:07:39 +00:00
|
|
|
struct rt_metrics_lite {
|
|
|
|
|
u_long rmx_mtu; /* MTU for this path */
|
|
|
|
|
u_long rmx_expire; /* lifetime for route, e.g. redirect */
|
|
|
|
|
u_long rmx_pksent; /* packets sent using this route */
|
2009-04-14 23:05:36 +00:00
|
|
|
u_long rmx_weight; /* absolute weight */
|
2003-11-20 20:07:39 +00:00
|
|
|
};
|
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
struct rt_metrics {
|
|
|
|
|
u_long rmx_locks; /* Kernel must leave these values alone */
|
|
|
|
|
u_long rmx_mtu; /* MTU for this path */
|
|
|
|
|
u_long rmx_hopcount; /* max hops expected */
|
|
|
|
|
u_long rmx_expire; /* lifetime for route, e.g. redirect */
|
1996-01-30 23:02:38 +00:00
|
|
|
u_long rmx_recvpipe; /* inbound delay-bandwidth product */
|
|
|
|
|
u_long rmx_sendpipe; /* outbound delay-bandwidth product */
|
1994-05-24 10:09:53 +00:00
|
|
|
u_long rmx_ssthresh; /* outbound gateway buffer limit */
|
|
|
|
|
u_long rmx_rtt; /* estimated round trip time */
|
|
|
|
|
u_long rmx_rttvar; /* estimated rtt variance */
|
|
|
|
|
u_long rmx_pksent; /* packets sent using this route */
|
2009-04-14 23:05:36 +00:00
|
|
|
u_long rmx_weight; /* route weight */
|
|
|
|
|
u_long rmx_filler[3]; /* will be used for T/TCP later */
|
1994-05-24 10:09:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* rmx_rtt and rmx_rttvar are stored as microseconds;
|
|
|
|
|
* RTTTOPRHZ(rtt) converts to a value suitable for use
|
|
|
|
|
* by a protocol slowtimo counter.
|
|
|
|
|
*/
|
|
|
|
|
#define RTM_RTTUNIT 1000000 /* units for rtt, rttvar, as units per sec */
|
|
|
|
|
#define RTTTOPRHZ(r) ((r) / (RTM_RTTUNIT / PR_SLOWHZ))
|
|
|
|
|
|
2012-02-17 02:39:58 +00:00
|
|
|
#define RT_DEFAULT_FIB 0 /* Explicitly mark fib=0 restricted cases */
|
Add code to allow the system to handle multiple routing tables.
This particular implementation is designed to be fully backwards compatible
and to be MFC-able to 7.x (and 6.x)
Currently the only protocol that can make use of the multiple tables is IPv4
Similar functionality exists in OpenBSD and Linux.
From my notes:
-----
One thing where FreeBSD has been falling behind, and which by chance I
have some time to work on is "policy based routing", which allows
different
packet streams to be routed by more than just the destination address.
Constraints:
------------
I want to make some form of this available in the 6.x tree
(and by extension 7.x) , but FreeBSD in general needs it so I might as
well do it in -current and back port the portions I need.
One of the ways that this can be done is to have the ability to
instantiate multiple kernel routing tables (which I will now
refer to as "Forwarding Information Bases" or "FIBs" for political
correctness reasons). Which FIB a particular packet uses to make
the next hop decision can be decided by a number of mechanisms.
The policies these mechanisms implement are the "Policies" referred
to in "Policy based routing".
One of the constraints I have if I try to back port this work to
6.x is that it must be implemented as a EXTENSION to the existing
ABIs in 6.x so that third party applications do not need to be
recompiled in timespan of the branch.
This first version will not have some of the bells and whistles that
will come with later versions. It will, for example, be limited to 16
tables in the first commit.
Implementation method, Compatible version. (part 1)
-------------------------------
For this reason I have implemented a "sufficient subset" of a
multiple routing table solution in Perforce, and back-ported it
to 6.x. (also in Perforce though not always caught up with what I
have done in -current/P4). The subset allows a number of FIBs
to be defined at compile time (8 is sufficient for my purposes in 6.x)
and implements the changes needed to allow IPV4 to use them. I have not
done the changes for ipv6 simply because I do not need it, and I do not
have enough knowledge of ipv6 (e.g. neighbor discovery) needed to do it.
Other protocol families are left untouched and should there be
users with proprietary protocol families, they should continue to work
and be oblivious to the existence of the extra FIBs.
To understand how this is done, one must know that the current FIB
code starts everything off with a single dimensional array of
pointers to FIB head structures (One per protocol family), each of
which in turn points to the trie of routes available to that family.
The basic change in the ABI compatible version of the change is to
extent that array to be a 2 dimensional array, so that
instead of protocol family X looking at rt_tables[X] for the
table it needs, it looks at rt_tables[Y][X] when for all
protocol families except ipv4 Y is always 0.
Code that is unaware of the change always just sees the first row
of the table, which of course looks just like the one dimensional
array that existed before.
The entry points rtrequest(), rtalloc(), rtalloc1(), rtalloc_ign()
are all maintained, but refer only to the first row of the array,
so that existing callers in proprietary protocols can continue to
do the "right thing".
Some new entry points are added, for the exclusive use of ipv4 code
called in_rtrequest(), in_rtalloc(), in_rtalloc1() and in_rtalloc_ign(),
which have an extra argument which refers the code to the correct row.
In addition, there are some new entry points (currently called
rtalloc_fib() and friends) that check the Address family being
looked up and call either rtalloc() (and friends) if the protocol
is not IPv4 forcing the action to row 0 or to the appropriate row
if it IS IPv4 (and that info is available). These are for calling
from code that is not specific to any particular protocol. The way
these are implemented would change in the non ABI preserving code
to be added later.
One feature of the first version of the code is that for ipv4,
the interface routes show up automatically on all the FIBs, so
that no matter what FIB you select you always have the basic
direct attached hosts available to you. (rtinit() does this
automatically).
You CAN delete an interface route from one FIB should you want
to but by default it's there. ARP information is also available
in each FIB. It's assumed that the same machine would have the
same MAC address, regardless of which FIB you are using to get
to it.
This brings us as to how the correct FIB is selected for an outgoing
IPV4 packet.
Firstly, all packets have a FIB associated with them. if nothing
has been done to change it, it will be FIB 0. The FIB is changed
in the following ways.
Packets fall into one of a number of classes.
1/ locally generated packets, coming from a socket/PCB.
Such packets select a FIB from a number associated with the
socket/PCB. This in turn is inherited from the process,
but can be changed by a socket option. The process in turn
inherits it on fork. I have written a utility call setfib
that acts a bit like nice..
setfib -3 ping target.example.com # will use fib 3 for ping.
It is an obvious extension to make it a property of a jail
but I have not done so. It can be achieved by combining the setfib and
jail commands.
2/ packets received on an interface for forwarding.
By default these packets would use table 0,
(or possibly a number settable in a sysctl(not yet)).
but prior to routing the firewall can inspect them (see below).
(possibly in the future you may be able to associate a FIB
with packets received on an interface.. An ifconfig arg, but not yet.)
3/ packets inspected by a packet classifier, which can arbitrarily
associate a fib with it on a packet by packet basis.
A fib assigned to a packet by a packet classifier
(such as ipfw) would over-ride a fib associated by
a more default source. (such as cases 1 or 2).
4/ a tcp listen socket associated with a fib will generate
accept sockets that are associated with that same fib.
5/ Packets generated in response to some other packet (e.g. reset
or icmp packets). These should use the FIB associated with the
packet being reponded to.
6/ Packets generated during encapsulation.
gif, tun and other tunnel interfaces will encapsulate using the FIB
that was in effect withthe proces that set up the tunnel.
thus setfib 1 ifconfig gif0 [tunnel instructions]
will set the fib for the tunnel to use to be fib 1.
Routing messages would be associated with their
process, and thus select one FIB or another.
messages from the kernel would be associated with the fib they
refer to and would only be received by a routing socket associated
with that fib. (not yet implemented)
In addition Netstat has been edited to be able to cope with the
fact that the array is now 2 dimensional. (It looks in system
memory using libkvm (!)). Old versions of netstat see only the first FIB.
In addition two sysctls are added to give:
a) the number of FIBs compiled in (active)
b) the default FIB of the calling process.
Early testing experience:
-------------------------
Basically our (IronPort's) appliance does this functionality already
using ipfw fwd but that method has some drawbacks.
For example,
It can't fully simulate a routing table because it can't influence the
socket's choice of local address when a connect() is done.
Testing during the generating of these changes has been
remarkably smooth so far. Multiple tables have co-existed
with no notable side effects, and packets have been routes
accordingly.
ipfw has grown 2 new keywords:
setfib N ip from anay to any
count ip from any to any fib N
In pf there seems to be a requirement to be able to give symbolic names to the
fibs but I do not have that capacity. I am not sure if it is required.
SCTP has interestingly enough built in support for this, called VRFs
in Cisco parlance. it will be interesting to see how that handles it
when it suddenly actually does something.
Where to next:
--------------------
After committing the ABI compatible version and MFCing it, I'd
like to proceed in a forward direction in -current. this will
result in some roto-tilling in the routing code.
Firstly: the current code's idea of having a separate tree per
protocol family, all of the same format, and pointed to by the
1 dimensional array is a bit silly. Especially when one considers that
there is code that makes assumptions about every protocol having the
same internal structures there. Some protocols don't WANT that
sort of structure. (for example the whole idea of a netmask is foreign
to appletalk). This needs to be made opaque to the external code.
My suggested first change is to add routing method pointers to the
'domain' structure, along with information pointing the data.
instead of having an array of pointers to uniform structures,
there would be an array pointing to the 'domain' structures
for each protocol address domain (protocol family),
and the methods this reached would be called. The methods would have
an argument that gives FIB number, but the protocol would be free
to ignore it.
When the ABI can be changed it raises the possibilty of the
addition of a fib entry into the "struct route". Currently,
the structure contains the sockaddr of the desination, and the resulting
fib entry. To make this work fully, one could add a fib number
so that given an address and a fib, one can find the third element, the
fib entry.
Interaction with the ARP layer/ LL layer would need to be
revisited as well. Qing Li has been working on this already.
This work was sponsored by Ironport Systems/Cisco
Reviewed by: several including rwatson, bz and mlair (parts each)
Obtained from: Ironport systems/Cisco
2008-05-09 23:03:00 +00:00
|
|
|
extern u_int rt_numfibs; /* number fo usable routing tables */
|
1995-01-24 04:47:33 +00:00
|
|
|
/*
|
|
|
|
|
* XXX kernel function pointer `rt_output' is visible to applications.
|
|
|
|
|
*/
|
|
|
|
|
struct mbuf;
|
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
|
* We distinguish between routes to hosts and routes to networks,
|
|
|
|
|
* preferring the former if available. For each route we infer
|
|
|
|
|
* the interface to use from the gateway address supplied when
|
|
|
|
|
* the route was entered. Routes that forward packets through
|
|
|
|
|
* gateways are marked so that the output routines know to address the
|
|
|
|
|
* gateway rather than the ultimate destination.
|
|
|
|
|
*/
|
|
|
|
|
#ifndef RNF_NORMAL
|
|
|
|
|
#include <net/radix.h>
|
This patch provides the back end support for equal-cost multi-path
(ECMP) for both IPv4 and IPv6. Previously, multipath route insertion
is disallowed. For example,
route add -net 192.103.54.0/24 10.9.44.1
route add -net 192.103.54.0/24 10.9.44.2
The second route insertion will trigger an error message of
"add net 192.103.54.0/24: gateway 10.2.5.2: route already in table"
Multiple default routes can also be inserted. Here is the netstat
output:
default 10.2.5.1 UGS 0 3074 bge0 =>
default 10.2.5.2 UGS 0 0 bge0
When multipath routes exist, the "route delete" command requires
a specific gateway to be specified or else an error message would
be displayed. For example,
route delete default
would fail and trigger the following error message:
"route: writing to routing socket: No such process"
"delete net default: not in table"
On the other hand,
route delete default 10.2.5.2
would be successful: "delete net default: gateway 10.2.5.2"
One does not have to specify a gateway if there is only a single
route for a particular destination.
I need to perform more testings on address aliases and multiple
interfaces that have the same IP prefixes. This patch as it
stands today is not yet ready for prime time. Therefore, the ECMP
code fragments are fully guarded by the RADIX_MPATH macro.
Include the "options RADIX_MPATH" in the kernel configuration
to enable this feature.
Reviewed by: robert, sam, gnn, julian, kmacy
2008-04-13 05:45:14 +00:00
|
|
|
#ifdef RADIX_MPATH
|
|
|
|
|
#include <net/radix_mpath.h>
|
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
|
|
|
|
struct rtentry {
|
|
|
|
|
struct radix_node rt_nodes[2]; /* tree glue, and other values */
|
2004-04-20 07:03:30 +00:00
|
|
|
/*
|
|
|
|
|
* XXX struct rtentry must begin with a struct radix_node (or two!)
|
|
|
|
|
* because the code does some casts of a 'struct radix_node *'
|
|
|
|
|
* to a 'struct rtentry *'
|
|
|
|
|
*/
|
2004-07-28 06:59:55 +00:00
|
|
|
#define rt_key(r) (*((struct sockaddr **)(&(r)->rt_nodes->rn_key)))
|
|
|
|
|
#define rt_mask(r) (*((struct sockaddr **)(&(r)->rt_nodes->rn_mask)))
|
1994-05-24 10:09:53 +00:00
|
|
|
struct sockaddr *rt_gateway; /* value */
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
int rt_flags; /* up/down?, host/net */
|
|
|
|
|
int rt_refcnt; /* # held references */
|
1994-05-24 10:09:53 +00:00
|
|
|
struct ifnet *rt_ifp; /* the answer: interface to use */
|
2003-11-20 20:07:39 +00:00
|
|
|
struct ifaddr *rt_ifa; /* the answer: interface address to use */
|
2004-04-04 06:14:55 +00:00
|
|
|
struct rt_metrics_lite rt_rmx; /* metrics used by rx'ing protocols */
|
Add code to allow the system to handle multiple routing tables.
This particular implementation is designed to be fully backwards compatible
and to be MFC-able to 7.x (and 6.x)
Currently the only protocol that can make use of the multiple tables is IPv4
Similar functionality exists in OpenBSD and Linux.
From my notes:
-----
One thing where FreeBSD has been falling behind, and which by chance I
have some time to work on is "policy based routing", which allows
different
packet streams to be routed by more than just the destination address.
Constraints:
------------
I want to make some form of this available in the 6.x tree
(and by extension 7.x) , but FreeBSD in general needs it so I might as
well do it in -current and back port the portions I need.
One of the ways that this can be done is to have the ability to
instantiate multiple kernel routing tables (which I will now
refer to as "Forwarding Information Bases" or "FIBs" for political
correctness reasons). Which FIB a particular packet uses to make
the next hop decision can be decided by a number of mechanisms.
The policies these mechanisms implement are the "Policies" referred
to in "Policy based routing".
One of the constraints I have if I try to back port this work to
6.x is that it must be implemented as a EXTENSION to the existing
ABIs in 6.x so that third party applications do not need to be
recompiled in timespan of the branch.
This first version will not have some of the bells and whistles that
will come with later versions. It will, for example, be limited to 16
tables in the first commit.
Implementation method, Compatible version. (part 1)
-------------------------------
For this reason I have implemented a "sufficient subset" of a
multiple routing table solution in Perforce, and back-ported it
to 6.x. (also in Perforce though not always caught up with what I
have done in -current/P4). The subset allows a number of FIBs
to be defined at compile time (8 is sufficient for my purposes in 6.x)
and implements the changes needed to allow IPV4 to use them. I have not
done the changes for ipv6 simply because I do not need it, and I do not
have enough knowledge of ipv6 (e.g. neighbor discovery) needed to do it.
Other protocol families are left untouched and should there be
users with proprietary protocol families, they should continue to work
and be oblivious to the existence of the extra FIBs.
To understand how this is done, one must know that the current FIB
code starts everything off with a single dimensional array of
pointers to FIB head structures (One per protocol family), each of
which in turn points to the trie of routes available to that family.
The basic change in the ABI compatible version of the change is to
extent that array to be a 2 dimensional array, so that
instead of protocol family X looking at rt_tables[X] for the
table it needs, it looks at rt_tables[Y][X] when for all
protocol families except ipv4 Y is always 0.
Code that is unaware of the change always just sees the first row
of the table, which of course looks just like the one dimensional
array that existed before.
The entry points rtrequest(), rtalloc(), rtalloc1(), rtalloc_ign()
are all maintained, but refer only to the first row of the array,
so that existing callers in proprietary protocols can continue to
do the "right thing".
Some new entry points are added, for the exclusive use of ipv4 code
called in_rtrequest(), in_rtalloc(), in_rtalloc1() and in_rtalloc_ign(),
which have an extra argument which refers the code to the correct row.
In addition, there are some new entry points (currently called
rtalloc_fib() and friends) that check the Address family being
looked up and call either rtalloc() (and friends) if the protocol
is not IPv4 forcing the action to row 0 or to the appropriate row
if it IS IPv4 (and that info is available). These are for calling
from code that is not specific to any particular protocol. The way
these are implemented would change in the non ABI preserving code
to be added later.
One feature of the first version of the code is that for ipv4,
the interface routes show up automatically on all the FIBs, so
that no matter what FIB you select you always have the basic
direct attached hosts available to you. (rtinit() does this
automatically).
You CAN delete an interface route from one FIB should you want
to but by default it's there. ARP information is also available
in each FIB. It's assumed that the same machine would have the
same MAC address, regardless of which FIB you are using to get
to it.
This brings us as to how the correct FIB is selected for an outgoing
IPV4 packet.
Firstly, all packets have a FIB associated with them. if nothing
has been done to change it, it will be FIB 0. The FIB is changed
in the following ways.
Packets fall into one of a number of classes.
1/ locally generated packets, coming from a socket/PCB.
Such packets select a FIB from a number associated with the
socket/PCB. This in turn is inherited from the process,
but can be changed by a socket option. The process in turn
inherits it on fork. I have written a utility call setfib
that acts a bit like nice..
setfib -3 ping target.example.com # will use fib 3 for ping.
It is an obvious extension to make it a property of a jail
but I have not done so. It can be achieved by combining the setfib and
jail commands.
2/ packets received on an interface for forwarding.
By default these packets would use table 0,
(or possibly a number settable in a sysctl(not yet)).
but prior to routing the firewall can inspect them (see below).
(possibly in the future you may be able to associate a FIB
with packets received on an interface.. An ifconfig arg, but not yet.)
3/ packets inspected by a packet classifier, which can arbitrarily
associate a fib with it on a packet by packet basis.
A fib assigned to a packet by a packet classifier
(such as ipfw) would over-ride a fib associated by
a more default source. (such as cases 1 or 2).
4/ a tcp listen socket associated with a fib will generate
accept sockets that are associated with that same fib.
5/ Packets generated in response to some other packet (e.g. reset
or icmp packets). These should use the FIB associated with the
packet being reponded to.
6/ Packets generated during encapsulation.
gif, tun and other tunnel interfaces will encapsulate using the FIB
that was in effect withthe proces that set up the tunnel.
thus setfib 1 ifconfig gif0 [tunnel instructions]
will set the fib for the tunnel to use to be fib 1.
Routing messages would be associated with their
process, and thus select one FIB or another.
messages from the kernel would be associated with the fib they
refer to and would only be received by a routing socket associated
with that fib. (not yet implemented)
In addition Netstat has been edited to be able to cope with the
fact that the array is now 2 dimensional. (It looks in system
memory using libkvm (!)). Old versions of netstat see only the first FIB.
In addition two sysctls are added to give:
a) the number of FIBs compiled in (active)
b) the default FIB of the calling process.
Early testing experience:
-------------------------
Basically our (IronPort's) appliance does this functionality already
using ipfw fwd but that method has some drawbacks.
For example,
It can't fully simulate a routing table because it can't influence the
socket's choice of local address when a connect() is done.
Testing during the generating of these changes has been
remarkably smooth so far. Multiple tables have co-existed
with no notable side effects, and packets have been routes
accordingly.
ipfw has grown 2 new keywords:
setfib N ip from anay to any
count ip from any to any fib N
In pf there seems to be a requirement to be able to give symbolic names to the
fibs but I do not have that capacity. I am not sure if it is required.
SCTP has interestingly enough built in support for this, called VRFs
in Cisco parlance. it will be interesting to see how that handles it
when it suddenly actually does something.
Where to next:
--------------------
After committing the ABI compatible version and MFCing it, I'd
like to proceed in a forward direction in -current. this will
result in some roto-tilling in the routing code.
Firstly: the current code's idea of having a separate tree per
protocol family, all of the same format, and pointed to by the
1 dimensional array is a bit silly. Especially when one considers that
there is code that makes assumptions about every protocol having the
same internal structures there. Some protocols don't WANT that
sort of structure. (for example the whole idea of a netmask is foreign
to appletalk). This needs to be made opaque to the external code.
My suggested first change is to add routing method pointers to the
'domain' structure, along with information pointing the data.
instead of having an array of pointers to uniform structures,
there would be an array pointing to the 'domain' structures
for each protocol address domain (protocol family),
and the methods this reached would be called. The methods would have
an argument that gives FIB number, but the protocol would be free
to ignore it.
When the ABI can be changed it raises the possibilty of the
addition of a fib entry into the "struct route". Currently,
the structure contains the sockaddr of the desination, and the resulting
fib entry. To make this work fully, one could add a fib number
so that given an address and a fib, one can find the third element, the
fib entry.
Interaction with the ARP layer/ LL layer would need to be
revisited as well. Qing Li has been working on this already.
This work was sponsored by Ironport Systems/Cisco
Reviewed by: several including rwatson, bz and mlair (parts each)
Obtained from: Ironport systems/Cisco
2008-05-09 23:03:00 +00:00
|
|
|
u_int rt_fibnum; /* which FIB */
|
2003-10-04 03:44:50 +00:00
|
|
|
#ifdef _KERNEL
|
|
|
|
|
/* XXX ugly, user apps use this definition but don't have a mtx def */
|
|
|
|
|
struct mtx rt_mtx; /* mutex for routing entry */
|
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Following structure necessary for 4.3 compatibility;
|
|
|
|
|
* We should eventually move it to a compat file.
|
|
|
|
|
*/
|
|
|
|
|
struct ortentry {
|
|
|
|
|
u_long rt_hash; /* to speed lookups */
|
|
|
|
|
struct sockaddr rt_dst; /* key */
|
|
|
|
|
struct sockaddr rt_gateway; /* value */
|
|
|
|
|
short rt_flags; /* up/down?, host/net */
|
|
|
|
|
short rt_refcnt; /* # held references */
|
|
|
|
|
u_long rt_use; /* raw # packets forwarded */
|
|
|
|
|
struct ifnet *rt_ifp; /* the answer: interface to use */
|
|
|
|
|
};
|
|
|
|
|
|
1994-11-03 01:04:32 +00:00
|
|
|
#define rt_use rt_rmx.rmx_pksent
|
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#define RTF_UP 0x1 /* route usable */
|
|
|
|
|
#define RTF_GATEWAY 0x2 /* destination is a gateway */
|
|
|
|
|
#define RTF_HOST 0x4 /* host entry (net otherwise) */
|
|
|
|
|
#define RTF_REJECT 0x8 /* host or net unreachable */
|
|
|
|
|
#define RTF_DYNAMIC 0x10 /* created dynamically (by redirect) */
|
|
|
|
|
#define RTF_MODIFIED 0x20 /* modified dynamically (by redirect) */
|
|
|
|
|
#define RTF_DONE 0x40 /* message confirmed */
|
2001-11-22 04:50:44 +00:00
|
|
|
/* 0x80 unused, was RTF_DELCLONE */
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
/* 0x100 unused, was RTF_CLONING */
|
1994-05-24 10:09:53 +00:00
|
|
|
#define RTF_XRESOLVE 0x200 /* external daemon resolves name */
|
2009-01-12 11:24:32 +00:00
|
|
|
#define RTF_LLINFO 0x400 /* DEPRECATED - exists ONLY for backward
|
|
|
|
|
compatibility */
|
2008-12-26 19:45:24 +00:00
|
|
|
#define RTF_LLDATA 0x400 /* used by apps to add/del L2 entries */
|
1994-05-24 10:09:53 +00:00
|
|
|
#define RTF_STATIC 0x800 /* manually added */
|
|
|
|
|
#define RTF_BLACKHOLE 0x1000 /* just discard pkts (during updates) */
|
|
|
|
|
#define RTF_PROTO2 0x4000 /* protocol specific routing flag */
|
|
|
|
|
#define RTF_PROTO1 0x8000 /* protocol specific routing flag */
|
|
|
|
|
|
2003-11-20 19:47:31 +00:00
|
|
|
/* XXX: temporary to stay API/ABI compatible with userland */
|
|
|
|
|
#ifndef _KERNEL
|
|
|
|
|
#define RTF_PRCLONING 0x10000 /* unused, for compatibility */
|
|
|
|
|
#endif
|
|
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
/* 0x20000 unused, was RTF_WASCLONED */
|
1994-12-13 22:31:49 +00:00
|
|
|
#define RTF_PROTO3 0x40000 /* protocol specific routing flag */
|
1996-10-09 18:35:10 +00:00
|
|
|
/* 0x80000 unused */
|
1995-02-08 20:01:13 +00:00
|
|
|
#define RTF_PINNED 0x100000 /* future use */
|
1996-05-06 17:42:13 +00:00
|
|
|
#define RTF_LOCAL 0x200000 /* route represents a local address */
|
|
|
|
|
#define RTF_BROADCAST 0x400000 /* route represents a bcast address */
|
|
|
|
|
#define RTF_MULTICAST 0x800000 /* route represents a mcast address */
|
2009-04-14 23:05:36 +00:00
|
|
|
/* 0x8000000 and up unassigned */
|
|
|
|
|
#define RTF_STICKY 0x10000000 /* always route dst->src */
|
|
|
|
|
|
|
|
|
|
#define RTF_RNH_LOCKED 0x40000000 /* radix node head is locked */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2006-03-15 19:39:09 +00:00
|
|
|
/* Mask of RTF flags that are allowed to be modified by RTM_CHANGE. */
|
|
|
|
|
#define RTF_FMASK \
|
|
|
|
|
(RTF_PROTO1 | RTF_PROTO2 | RTF_PROTO3 | RTF_BLACKHOLE | \
|
2009-04-14 23:05:36 +00:00
|
|
|
RTF_REJECT | RTF_STATIC | RTF_STICKY)
|
2006-03-15 19:39:09 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
|
* Routing statistics.
|
|
|
|
|
*/
|
|
|
|
|
struct rtstat {
|
|
|
|
|
short rts_badredirect; /* bogus redirect calls */
|
|
|
|
|
short rts_dynamic; /* routes created by redirects */
|
|
|
|
|
short rts_newgateway; /* routes modified by redirects */
|
|
|
|
|
short rts_unreach; /* lookups which failed */
|
|
|
|
|
short rts_wildcard; /* lookups satisfied by a wildcard */
|
|
|
|
|
};
|
|
|
|
|
/*
|
|
|
|
|
* Structures for routing messages.
|
|
|
|
|
*/
|
|
|
|
|
struct rt_msghdr {
|
|
|
|
|
u_short rtm_msglen; /* to skip over non-understood messages */
|
|
|
|
|
u_char rtm_version; /* future binary compatibility */
|
|
|
|
|
u_char rtm_type; /* message type */
|
|
|
|
|
u_short rtm_index; /* index for associated ifp */
|
|
|
|
|
int rtm_flags; /* flags, incl. kern & message, e.g. DONE */
|
|
|
|
|
int rtm_addrs; /* bitmask identifying sockaddrs in msg */
|
|
|
|
|
pid_t rtm_pid; /* identify sender */
|
|
|
|
|
int rtm_seq; /* for sender to identify action */
|
|
|
|
|
int rtm_errno; /* why failed */
|
2006-03-15 19:39:09 +00:00
|
|
|
int rtm_fmask; /* bitmask used in RTM_CHANGE message */
|
1994-05-24 10:09:53 +00:00
|
|
|
u_long rtm_inits; /* which metrics we are initializing */
|
|
|
|
|
struct rt_metrics rtm_rmx; /* metrics themselves */
|
|
|
|
|
};
|
|
|
|
|
|
2009-04-15 21:36:34 +00:00
|
|
|
#define RTM_VERSION 5 /* Up the ante and ignore older versions */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-09-14 00:33:23 +00:00
|
|
|
/*
|
|
|
|
|
* Message types.
|
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
#define RTM_ADD 0x1 /* Add Route */
|
|
|
|
|
#define RTM_DELETE 0x2 /* Delete Route */
|
|
|
|
|
#define RTM_CHANGE 0x3 /* Change Metrics or flags */
|
|
|
|
|
#define RTM_GET 0x4 /* Report Metrics */
|
|
|
|
|
#define RTM_LOSING 0x5 /* Kernel Suspects Partitioning */
|
|
|
|
|
#define RTM_REDIRECT 0x6 /* Told to use different route */
|
|
|
|
|
#define RTM_MISS 0x7 /* Lookup failed on this address */
|
|
|
|
|
#define RTM_LOCK 0x8 /* fix specified metrics */
|
|
|
|
|
#define RTM_OLDADD 0x9 /* caused by SIOCADDRT */
|
|
|
|
|
#define RTM_OLDDEL 0xa /* caused by SIOCDELRT */
|
|
|
|
|
#define RTM_RESOLVE 0xb /* req to resolve dst to LL addr */
|
|
|
|
|
#define RTM_NEWADDR 0xc /* address being added to iface */
|
|
|
|
|
#define RTM_DELADDR 0xd /* address being removed from iface */
|
|
|
|
|
#define RTM_IFINFO 0xe /* iface going up/down etc. */
|
1997-01-13 21:26:53 +00:00
|
|
|
#define RTM_NEWMADDR 0xf /* mcast group membership being added to if */
|
|
|
|
|
#define RTM_DELMADDR 0x10 /* mcast group membership being deleted */
|
2002-01-18 14:33:04 +00:00
|
|
|
#define RTM_IFANNOUNCE 0x11 /* iface arrival/departure */
|
2004-10-05 19:48:33 +00:00
|
|
|
#define RTM_IEEE80211 0x12 /* IEEE80211 wireless event */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-09-14 00:33:23 +00:00
|
|
|
/*
|
|
|
|
|
* Bitmask values for rtm_inits and rmx_locks.
|
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
#define RTV_MTU 0x1 /* init or lock _mtu */
|
|
|
|
|
#define RTV_HOPCOUNT 0x2 /* init or lock _hopcount */
|
1999-09-14 00:33:23 +00:00
|
|
|
#define RTV_EXPIRE 0x4 /* init or lock _expire */
|
1994-05-24 10:09:53 +00:00
|
|
|
#define RTV_RPIPE 0x8 /* init or lock _recvpipe */
|
|
|
|
|
#define RTV_SPIPE 0x10 /* init or lock _sendpipe */
|
|
|
|
|
#define RTV_SSTHRESH 0x20 /* init or lock _ssthresh */
|
|
|
|
|
#define RTV_RTT 0x40 /* init or lock _rtt */
|
|
|
|
|
#define RTV_RTTVAR 0x80 /* init or lock _rttvar */
|
2009-04-14 23:05:36 +00:00
|
|
|
#define RTV_WEIGHT 0x100 /* init or lock _weight */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
|
/*
|
1999-09-14 00:33:23 +00:00
|
|
|
* Bitmask values for rtm_addrs.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
#define RTA_DST 0x1 /* destination sockaddr present */
|
|
|
|
|
#define RTA_GATEWAY 0x2 /* gateway sockaddr present */
|
|
|
|
|
#define RTA_NETMASK 0x4 /* netmask sockaddr present */
|
|
|
|
|
#define RTA_GENMASK 0x8 /* cloning mask sockaddr present */
|
|
|
|
|
#define RTA_IFP 0x10 /* interface name sockaddr present */
|
|
|
|
|
#define RTA_IFA 0x20 /* interface addr sockaddr present */
|
|
|
|
|
#define RTA_AUTHOR 0x40 /* sockaddr for author of redirect */
|
|
|
|
|
#define RTA_BRD 0x80 /* for NEWADDR, broadcast or p-p dest addr */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Index offsets for sockaddr array for alternate internal encoding.
|
|
|
|
|
*/
|
|
|
|
|
#define RTAX_DST 0 /* destination sockaddr present */
|
|
|
|
|
#define RTAX_GATEWAY 1 /* gateway sockaddr present */
|
|
|
|
|
#define RTAX_NETMASK 2 /* netmask sockaddr present */
|
|
|
|
|
#define RTAX_GENMASK 3 /* cloning mask sockaddr present */
|
|
|
|
|
#define RTAX_IFP 4 /* interface name sockaddr present */
|
|
|
|
|
#define RTAX_IFA 5 /* interface addr sockaddr present */
|
|
|
|
|
#define RTAX_AUTHOR 6 /* sockaddr for author of redirect */
|
|
|
|
|
#define RTAX_BRD 7 /* for NEWADDR, broadcast or p-p dest addr */
|
|
|
|
|
#define RTAX_MAX 8 /* size of array to allocate */
|
|
|
|
|
|
|
|
|
|
struct rt_addrinfo {
|
|
|
|
|
int rti_addrs;
|
|
|
|
|
struct sockaddr *rti_info[RTAX_MAX];
|
2001-10-17 18:07:05 +00:00
|
|
|
int rti_flags;
|
|
|
|
|
struct ifaddr *rti_ifa;
|
|
|
|
|
struct ifnet *rti_ifp;
|
1994-05-24 10:09:53 +00:00
|
|
|
};
|
|
|
|
|
|
2004-04-13 11:22:22 +00:00
|
|
|
/*
|
|
|
|
|
* This macro returns the size of a struct sockaddr when passed
|
|
|
|
|
* through a routing socket. Basically we round up sa_len to
|
|
|
|
|
* a multiple of sizeof(long), with a minimum of sizeof(long).
|
|
|
|
|
* The check for a NULL pointer is just a convenience, probably never used.
|
|
|
|
|
* The case sa_len == 0 should only apply to empty structures.
|
|
|
|
|
*/
|
|
|
|
|
#define SA_SIZE(sa) \
|
|
|
|
|
( (!(sa) || ((struct sockaddr *)(sa))->sa_len == 0) ? \
|
|
|
|
|
sizeof(long) : \
|
|
|
|
|
1 + ( (((struct sockaddr *)(sa))->sa_len - 1) | (sizeof(long) - 1) ) )
|
|
|
|
|
|
1999-12-29 04:46:21 +00:00
|
|
|
#ifdef _KERNEL
|
2003-07-19 00:21:13 +00:00
|
|
|
|
2010-03-16 17:59:12 +00:00
|
|
|
#define RT_LINK_IS_UP(ifp) (!((ifp)->if_capabilities & IFCAP_LINKSTATE) \
|
2010-03-11 17:56:46 +00:00
|
|
|
|| (ifp)->if_link_state == LINK_STATE_UP)
|
2010-03-09 01:11:45 +00:00
|
|
|
|
2003-10-04 03:44:50 +00:00
|
|
|
#define RT_LOCK_INIT(_rt) \
|
|
|
|
|
mtx_init(&(_rt)->rt_mtx, "rtentry", NULL, MTX_DEF | MTX_DUPOK)
|
|
|
|
|
#define RT_LOCK(_rt) mtx_lock(&(_rt)->rt_mtx)
|
|
|
|
|
#define RT_UNLOCK(_rt) mtx_unlock(&(_rt)->rt_mtx)
|
|
|
|
|
#define RT_LOCK_DESTROY(_rt) mtx_destroy(&(_rt)->rt_mtx)
|
|
|
|
|
#define RT_LOCK_ASSERT(_rt) mtx_assert(&(_rt)->rt_mtx, MA_OWNED)
|
2003-07-19 00:21:13 +00:00
|
|
|
|
2003-11-08 23:36:32 +00:00
|
|
|
#define RT_ADDREF(_rt) do { \
|
|
|
|
|
RT_LOCK_ASSERT(_rt); \
|
|
|
|
|
KASSERT((_rt)->rt_refcnt >= 0, \
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
("negative refcnt %d", (_rt)->rt_refcnt)); \
|
2003-11-08 23:36:32 +00:00
|
|
|
(_rt)->rt_refcnt++; \
|
2005-09-14 14:57:04 +00:00
|
|
|
} while (0)
|
2008-09-05 21:03:19 +00:00
|
|
|
|
2003-11-08 23:36:32 +00:00
|
|
|
#define RT_REMREF(_rt) do { \
|
|
|
|
|
RT_LOCK_ASSERT(_rt); \
|
|
|
|
|
KASSERT((_rt)->rt_refcnt > 0, \
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
("bogus refcnt %d", (_rt)->rt_refcnt)); \
|
2003-11-08 23:36:32 +00:00
|
|
|
(_rt)->rt_refcnt--; \
|
2005-09-14 14:57:04 +00:00
|
|
|
} while (0)
|
2003-11-08 23:36:32 +00:00
|
|
|
|
|
|
|
|
#define RTFREE_LOCKED(_rt) do { \
|
2008-09-14 10:22:37 +00:00
|
|
|
if ((_rt)->rt_refcnt <= 1) \
|
|
|
|
|
rtfree(_rt); \
|
|
|
|
|
else { \
|
|
|
|
|
RT_REMREF(_rt); \
|
|
|
|
|
RT_UNLOCK(_rt); \
|
|
|
|
|
} \
|
|
|
|
|
/* guard against invalid refs */ \
|
|
|
|
|
_rt = 0; \
|
|
|
|
|
} while (0)
|
2008-09-05 21:03:19 +00:00
|
|
|
|
2003-11-08 23:36:32 +00:00
|
|
|
#define RTFREE(_rt) do { \
|
2008-09-14 10:22:37 +00:00
|
|
|
RT_LOCK(_rt); \
|
|
|
|
|
RTFREE_LOCKED(_rt); \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
2012-07-04 07:37:53 +00:00
|
|
|
#define RO_RTFREE(_ro) do { \
|
|
|
|
|
if ((_ro)->ro_rt) { \
|
|
|
|
|
if ((_ro)->ro_flags & RT_NORTREF) { \
|
|
|
|
|
(_ro)->ro_flags &= ~RT_NORTREF; \
|
|
|
|
|
(_ro)->ro_rt = NULL; \
|
|
|
|
|
} else { \
|
|
|
|
|
RT_LOCK((_ro)->ro_rt); \
|
|
|
|
|
RTFREE_LOCKED((_ro)->ro_rt); \
|
|
|
|
|
} \
|
|
|
|
|
} \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
2009-06-01 15:49:42 +00:00
|
|
|
struct radix_node_head *rt_tables_get_rnh(int, int);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-01-13 21:26:53 +00:00
|
|
|
struct ifmultiaddr;
|
|
|
|
|
|
2004-10-05 19:48:33 +00:00
|
|
|
void rt_ieee80211msg(struct ifnet *, int, void *, size_t);
|
2002-03-19 21:54:18 +00:00
|
|
|
void rt_ifannouncemsg(struct ifnet *, int);
|
|
|
|
|
void rt_ifmsg(struct ifnet *);
|
|
|
|
|
void rt_missmsg(int, struct rt_addrinfo *, int, int);
|
2011-09-28 13:48:36 +00:00
|
|
|
void rt_missmsg_fib(int, struct rt_addrinfo *, int, int, int);
|
2002-03-19 21:54:18 +00:00
|
|
|
void rt_newaddrmsg(int, struct ifaddr *, int, struct rtentry *);
|
2011-09-28 13:48:36 +00:00
|
|
|
void rt_newaddrmsg_fib(int, struct ifaddr *, int, struct rtentry *, int);
|
2002-03-19 21:54:18 +00:00
|
|
|
void rt_newmaddrmsg(int, struct ifmultiaddr *);
|
2003-10-04 03:44:50 +00:00
|
|
|
int rt_setgate(struct rtentry *, struct sockaddr *, struct sockaddr *);
|
2009-12-30 21:35:34 +00:00
|
|
|
void rt_maskedcopy(struct sockaddr *, struct sockaddr *, struct sockaddr *);
|
2004-04-24 23:34:04 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Note the following locking behavior:
|
|
|
|
|
*
|
|
|
|
|
* rtalloc_ign() and rtalloc() return ro->ro_rt unlocked
|
|
|
|
|
*
|
|
|
|
|
* rtalloc1() returns a locked rtentry
|
|
|
|
|
*
|
|
|
|
|
* rtfree() and RTFREE_LOCKED() require a locked rtentry
|
|
|
|
|
*
|
|
|
|
|
* RTFREE() uses an unlocked entry.
|
|
|
|
|
*/
|
|
|
|
|
|
Add code to allow the system to handle multiple routing tables.
This particular implementation is designed to be fully backwards compatible
and to be MFC-able to 7.x (and 6.x)
Currently the only protocol that can make use of the multiple tables is IPv4
Similar functionality exists in OpenBSD and Linux.
From my notes:
-----
One thing where FreeBSD has been falling behind, and which by chance I
have some time to work on is "policy based routing", which allows
different
packet streams to be routed by more than just the destination address.
Constraints:
------------
I want to make some form of this available in the 6.x tree
(and by extension 7.x) , but FreeBSD in general needs it so I might as
well do it in -current and back port the portions I need.
One of the ways that this can be done is to have the ability to
instantiate multiple kernel routing tables (which I will now
refer to as "Forwarding Information Bases" or "FIBs" for political
correctness reasons). Which FIB a particular packet uses to make
the next hop decision can be decided by a number of mechanisms.
The policies these mechanisms implement are the "Policies" referred
to in "Policy based routing".
One of the constraints I have if I try to back port this work to
6.x is that it must be implemented as a EXTENSION to the existing
ABIs in 6.x so that third party applications do not need to be
recompiled in timespan of the branch.
This first version will not have some of the bells and whistles that
will come with later versions. It will, for example, be limited to 16
tables in the first commit.
Implementation method, Compatible version. (part 1)
-------------------------------
For this reason I have implemented a "sufficient subset" of a
multiple routing table solution in Perforce, and back-ported it
to 6.x. (also in Perforce though not always caught up with what I
have done in -current/P4). The subset allows a number of FIBs
to be defined at compile time (8 is sufficient for my purposes in 6.x)
and implements the changes needed to allow IPV4 to use them. I have not
done the changes for ipv6 simply because I do not need it, and I do not
have enough knowledge of ipv6 (e.g. neighbor discovery) needed to do it.
Other protocol families are left untouched and should there be
users with proprietary protocol families, they should continue to work
and be oblivious to the existence of the extra FIBs.
To understand how this is done, one must know that the current FIB
code starts everything off with a single dimensional array of
pointers to FIB head structures (One per protocol family), each of
which in turn points to the trie of routes available to that family.
The basic change in the ABI compatible version of the change is to
extent that array to be a 2 dimensional array, so that
instead of protocol family X looking at rt_tables[X] for the
table it needs, it looks at rt_tables[Y][X] when for all
protocol families except ipv4 Y is always 0.
Code that is unaware of the change always just sees the first row
of the table, which of course looks just like the one dimensional
array that existed before.
The entry points rtrequest(), rtalloc(), rtalloc1(), rtalloc_ign()
are all maintained, but refer only to the first row of the array,
so that existing callers in proprietary protocols can continue to
do the "right thing".
Some new entry points are added, for the exclusive use of ipv4 code
called in_rtrequest(), in_rtalloc(), in_rtalloc1() and in_rtalloc_ign(),
which have an extra argument which refers the code to the correct row.
In addition, there are some new entry points (currently called
rtalloc_fib() and friends) that check the Address family being
looked up and call either rtalloc() (and friends) if the protocol
is not IPv4 forcing the action to row 0 or to the appropriate row
if it IS IPv4 (and that info is available). These are for calling
from code that is not specific to any particular protocol. The way
these are implemented would change in the non ABI preserving code
to be added later.
One feature of the first version of the code is that for ipv4,
the interface routes show up automatically on all the FIBs, so
that no matter what FIB you select you always have the basic
direct attached hosts available to you. (rtinit() does this
automatically).
You CAN delete an interface route from one FIB should you want
to but by default it's there. ARP information is also available
in each FIB. It's assumed that the same machine would have the
same MAC address, regardless of which FIB you are using to get
to it.
This brings us as to how the correct FIB is selected for an outgoing
IPV4 packet.
Firstly, all packets have a FIB associated with them. if nothing
has been done to change it, it will be FIB 0. The FIB is changed
in the following ways.
Packets fall into one of a number of classes.
1/ locally generated packets, coming from a socket/PCB.
Such packets select a FIB from a number associated with the
socket/PCB. This in turn is inherited from the process,
but can be changed by a socket option. The process in turn
inherits it on fork. I have written a utility call setfib
that acts a bit like nice..
setfib -3 ping target.example.com # will use fib 3 for ping.
It is an obvious extension to make it a property of a jail
but I have not done so. It can be achieved by combining the setfib and
jail commands.
2/ packets received on an interface for forwarding.
By default these packets would use table 0,
(or possibly a number settable in a sysctl(not yet)).
but prior to routing the firewall can inspect them (see below).
(possibly in the future you may be able to associate a FIB
with packets received on an interface.. An ifconfig arg, but not yet.)
3/ packets inspected by a packet classifier, which can arbitrarily
associate a fib with it on a packet by packet basis.
A fib assigned to a packet by a packet classifier
(such as ipfw) would over-ride a fib associated by
a more default source. (such as cases 1 or 2).
4/ a tcp listen socket associated with a fib will generate
accept sockets that are associated with that same fib.
5/ Packets generated in response to some other packet (e.g. reset
or icmp packets). These should use the FIB associated with the
packet being reponded to.
6/ Packets generated during encapsulation.
gif, tun and other tunnel interfaces will encapsulate using the FIB
that was in effect withthe proces that set up the tunnel.
thus setfib 1 ifconfig gif0 [tunnel instructions]
will set the fib for the tunnel to use to be fib 1.
Routing messages would be associated with their
process, and thus select one FIB or another.
messages from the kernel would be associated with the fib they
refer to and would only be received by a routing socket associated
with that fib. (not yet implemented)
In addition Netstat has been edited to be able to cope with the
fact that the array is now 2 dimensional. (It looks in system
memory using libkvm (!)). Old versions of netstat see only the first FIB.
In addition two sysctls are added to give:
a) the number of FIBs compiled in (active)
b) the default FIB of the calling process.
Early testing experience:
-------------------------
Basically our (IronPort's) appliance does this functionality already
using ipfw fwd but that method has some drawbacks.
For example,
It can't fully simulate a routing table because it can't influence the
socket's choice of local address when a connect() is done.
Testing during the generating of these changes has been
remarkably smooth so far. Multiple tables have co-existed
with no notable side effects, and packets have been routes
accordingly.
ipfw has grown 2 new keywords:
setfib N ip from anay to any
count ip from any to any fib N
In pf there seems to be a requirement to be able to give symbolic names to the
fibs but I do not have that capacity. I am not sure if it is required.
SCTP has interestingly enough built in support for this, called VRFs
in Cisco parlance. it will be interesting to see how that handles it
when it suddenly actually does something.
Where to next:
--------------------
After committing the ABI compatible version and MFCing it, I'd
like to proceed in a forward direction in -current. this will
result in some roto-tilling in the routing code.
Firstly: the current code's idea of having a separate tree per
protocol family, all of the same format, and pointed to by the
1 dimensional array is a bit silly. Especially when one considers that
there is code that makes assumptions about every protocol having the
same internal structures there. Some protocols don't WANT that
sort of structure. (for example the whole idea of a netmask is foreign
to appletalk). This needs to be made opaque to the external code.
My suggested first change is to add routing method pointers to the
'domain' structure, along with information pointing the data.
instead of having an array of pointers to uniform structures,
there would be an array pointing to the 'domain' structures
for each protocol address domain (protocol family),
and the methods this reached would be called. The methods would have
an argument that gives FIB number, but the protocol would be free
to ignore it.
When the ABI can be changed it raises the possibilty of the
addition of a fib entry into the "struct route". Currently,
the structure contains the sockaddr of the desination, and the resulting
fib entry. To make this work fully, one could add a fib number
so that given an address and a fib, one can find the third element, the
fib entry.
Interaction with the ARP layer/ LL layer would need to be
revisited as well. Qing Li has been working on this already.
This work was sponsored by Ironport Systems/Cisco
Reviewed by: several including rwatson, bz and mlair (parts each)
Obtained from: Ironport systems/Cisco
2008-05-09 23:03:00 +00:00
|
|
|
int rtexpunge(struct rtentry *);
|
|
|
|
|
void rtfree(struct rtentry *);
|
2008-09-14 08:19:48 +00:00
|
|
|
int rt_check(struct rtentry **, struct rtentry **, struct sockaddr *);
|
Add code to allow the system to handle multiple routing tables.
This particular implementation is designed to be fully backwards compatible
and to be MFC-able to 7.x (and 6.x)
Currently the only protocol that can make use of the multiple tables is IPv4
Similar functionality exists in OpenBSD and Linux.
From my notes:
-----
One thing where FreeBSD has been falling behind, and which by chance I
have some time to work on is "policy based routing", which allows
different
packet streams to be routed by more than just the destination address.
Constraints:
------------
I want to make some form of this available in the 6.x tree
(and by extension 7.x) , but FreeBSD in general needs it so I might as
well do it in -current and back port the portions I need.
One of the ways that this can be done is to have the ability to
instantiate multiple kernel routing tables (which I will now
refer to as "Forwarding Information Bases" or "FIBs" for political
correctness reasons). Which FIB a particular packet uses to make
the next hop decision can be decided by a number of mechanisms.
The policies these mechanisms implement are the "Policies" referred
to in "Policy based routing".
One of the constraints I have if I try to back port this work to
6.x is that it must be implemented as a EXTENSION to the existing
ABIs in 6.x so that third party applications do not need to be
recompiled in timespan of the branch.
This first version will not have some of the bells and whistles that
will come with later versions. It will, for example, be limited to 16
tables in the first commit.
Implementation method, Compatible version. (part 1)
-------------------------------
For this reason I have implemented a "sufficient subset" of a
multiple routing table solution in Perforce, and back-ported it
to 6.x. (also in Perforce though not always caught up with what I
have done in -current/P4). The subset allows a number of FIBs
to be defined at compile time (8 is sufficient for my purposes in 6.x)
and implements the changes needed to allow IPV4 to use them. I have not
done the changes for ipv6 simply because I do not need it, and I do not
have enough knowledge of ipv6 (e.g. neighbor discovery) needed to do it.
Other protocol families are left untouched and should there be
users with proprietary protocol families, they should continue to work
and be oblivious to the existence of the extra FIBs.
To understand how this is done, one must know that the current FIB
code starts everything off with a single dimensional array of
pointers to FIB head structures (One per protocol family), each of
which in turn points to the trie of routes available to that family.
The basic change in the ABI compatible version of the change is to
extent that array to be a 2 dimensional array, so that
instead of protocol family X looking at rt_tables[X] for the
table it needs, it looks at rt_tables[Y][X] when for all
protocol families except ipv4 Y is always 0.
Code that is unaware of the change always just sees the first row
of the table, which of course looks just like the one dimensional
array that existed before.
The entry points rtrequest(), rtalloc(), rtalloc1(), rtalloc_ign()
are all maintained, but refer only to the first row of the array,
so that existing callers in proprietary protocols can continue to
do the "right thing".
Some new entry points are added, for the exclusive use of ipv4 code
called in_rtrequest(), in_rtalloc(), in_rtalloc1() and in_rtalloc_ign(),
which have an extra argument which refers the code to the correct row.
In addition, there are some new entry points (currently called
rtalloc_fib() and friends) that check the Address family being
looked up and call either rtalloc() (and friends) if the protocol
is not IPv4 forcing the action to row 0 or to the appropriate row
if it IS IPv4 (and that info is available). These are for calling
from code that is not specific to any particular protocol. The way
these are implemented would change in the non ABI preserving code
to be added later.
One feature of the first version of the code is that for ipv4,
the interface routes show up automatically on all the FIBs, so
that no matter what FIB you select you always have the basic
direct attached hosts available to you. (rtinit() does this
automatically).
You CAN delete an interface route from one FIB should you want
to but by default it's there. ARP information is also available
in each FIB. It's assumed that the same machine would have the
same MAC address, regardless of which FIB you are using to get
to it.
This brings us as to how the correct FIB is selected for an outgoing
IPV4 packet.
Firstly, all packets have a FIB associated with them. if nothing
has been done to change it, it will be FIB 0. The FIB is changed
in the following ways.
Packets fall into one of a number of classes.
1/ locally generated packets, coming from a socket/PCB.
Such packets select a FIB from a number associated with the
socket/PCB. This in turn is inherited from the process,
but can be changed by a socket option. The process in turn
inherits it on fork. I have written a utility call setfib
that acts a bit like nice..
setfib -3 ping target.example.com # will use fib 3 for ping.
It is an obvious extension to make it a property of a jail
but I have not done so. It can be achieved by combining the setfib and
jail commands.
2/ packets received on an interface for forwarding.
By default these packets would use table 0,
(or possibly a number settable in a sysctl(not yet)).
but prior to routing the firewall can inspect them (see below).
(possibly in the future you may be able to associate a FIB
with packets received on an interface.. An ifconfig arg, but not yet.)
3/ packets inspected by a packet classifier, which can arbitrarily
associate a fib with it on a packet by packet basis.
A fib assigned to a packet by a packet classifier
(such as ipfw) would over-ride a fib associated by
a more default source. (such as cases 1 or 2).
4/ a tcp listen socket associated with a fib will generate
accept sockets that are associated with that same fib.
5/ Packets generated in response to some other packet (e.g. reset
or icmp packets). These should use the FIB associated with the
packet being reponded to.
6/ Packets generated during encapsulation.
gif, tun and other tunnel interfaces will encapsulate using the FIB
that was in effect withthe proces that set up the tunnel.
thus setfib 1 ifconfig gif0 [tunnel instructions]
will set the fib for the tunnel to use to be fib 1.
Routing messages would be associated with their
process, and thus select one FIB or another.
messages from the kernel would be associated with the fib they
refer to and would only be received by a routing socket associated
with that fib. (not yet implemented)
In addition Netstat has been edited to be able to cope with the
fact that the array is now 2 dimensional. (It looks in system
memory using libkvm (!)). Old versions of netstat see only the first FIB.
In addition two sysctls are added to give:
a) the number of FIBs compiled in (active)
b) the default FIB of the calling process.
Early testing experience:
-------------------------
Basically our (IronPort's) appliance does this functionality already
using ipfw fwd but that method has some drawbacks.
For example,
It can't fully simulate a routing table because it can't influence the
socket's choice of local address when a connect() is done.
Testing during the generating of these changes has been
remarkably smooth so far. Multiple tables have co-existed
with no notable side effects, and packets have been routes
accordingly.
ipfw has grown 2 new keywords:
setfib N ip from anay to any
count ip from any to any fib N
In pf there seems to be a requirement to be able to give symbolic names to the
fibs but I do not have that capacity. I am not sure if it is required.
SCTP has interestingly enough built in support for this, called VRFs
in Cisco parlance. it will be interesting to see how that handles it
when it suddenly actually does something.
Where to next:
--------------------
After committing the ABI compatible version and MFCing it, I'd
like to proceed in a forward direction in -current. this will
result in some roto-tilling in the routing code.
Firstly: the current code's idea of having a separate tree per
protocol family, all of the same format, and pointed to by the
1 dimensional array is a bit silly. Especially when one considers that
there is code that makes assumptions about every protocol having the
same internal structures there. Some protocols don't WANT that
sort of structure. (for example the whole idea of a netmask is foreign
to appletalk). This needs to be made opaque to the external code.
My suggested first change is to add routing method pointers to the
'domain' structure, along with information pointing the data.
instead of having an array of pointers to uniform structures,
there would be an array pointing to the 'domain' structures
for each protocol address domain (protocol family),
and the methods this reached would be called. The methods would have
an argument that gives FIB number, but the protocol would be free
to ignore it.
When the ABI can be changed it raises the possibilty of the
addition of a fib entry into the "struct route". Currently,
the structure contains the sockaddr of the desination, and the resulting
fib entry. To make this work fully, one could add a fib number
so that given an address and a fib, one can find the third element, the
fib entry.
Interaction with the ARP layer/ LL layer would need to be
revisited as well. Qing Li has been working on this already.
This work was sponsored by Ironport Systems/Cisco
Reviewed by: several including rwatson, bz and mlair (parts each)
Obtained from: Ironport systems/Cisco
2008-05-09 23:03:00 +00:00
|
|
|
|
|
|
|
|
/* XXX MRT COMPAT VERSIONS THAT SET UNIVERSE to 0 */
|
|
|
|
|
/* Thes are used by old code not yet converted to use multiple FIBS */
|
|
|
|
|
int rt_getifa(struct rt_addrinfo *);
|
2004-04-24 23:34:04 +00:00
|
|
|
void rtalloc_ign(struct route *ro, u_long ignflags);
|
|
|
|
|
void rtalloc(struct route *ro); /* XXX deprecated, use rtalloc_ign(ro, 0) */
|
2003-10-04 03:44:50 +00:00
|
|
|
struct rtentry *rtalloc1(struct sockaddr *, int, u_long);
|
2002-03-19 21:54:18 +00:00
|
|
|
int rtinit(struct ifaddr *, int, int);
|
|
|
|
|
int rtioctl(u_long, caddr_t);
|
|
|
|
|
void rtredirect(struct sockaddr *, struct sockaddr *,
|
2003-10-04 03:44:50 +00:00
|
|
|
struct sockaddr *, int, struct sockaddr *);
|
2002-03-19 21:54:18 +00:00
|
|
|
int rtrequest(int, struct sockaddr *,
|
|
|
|
|
struct sockaddr *, struct sockaddr *, int, struct rtentry **);
|
2007-12-12 20:53:25 +00:00
|
|
|
|
2012-02-17 02:39:58 +00:00
|
|
|
#ifndef BURN_BRIDGES
|
Add code to allow the system to handle multiple routing tables.
This particular implementation is designed to be fully backwards compatible
and to be MFC-able to 7.x (and 6.x)
Currently the only protocol that can make use of the multiple tables is IPv4
Similar functionality exists in OpenBSD and Linux.
From my notes:
-----
One thing where FreeBSD has been falling behind, and which by chance I
have some time to work on is "policy based routing", which allows
different
packet streams to be routed by more than just the destination address.
Constraints:
------------
I want to make some form of this available in the 6.x tree
(and by extension 7.x) , but FreeBSD in general needs it so I might as
well do it in -current and back port the portions I need.
One of the ways that this can be done is to have the ability to
instantiate multiple kernel routing tables (which I will now
refer to as "Forwarding Information Bases" or "FIBs" for political
correctness reasons). Which FIB a particular packet uses to make
the next hop decision can be decided by a number of mechanisms.
The policies these mechanisms implement are the "Policies" referred
to in "Policy based routing".
One of the constraints I have if I try to back port this work to
6.x is that it must be implemented as a EXTENSION to the existing
ABIs in 6.x so that third party applications do not need to be
recompiled in timespan of the branch.
This first version will not have some of the bells and whistles that
will come with later versions. It will, for example, be limited to 16
tables in the first commit.
Implementation method, Compatible version. (part 1)
-------------------------------
For this reason I have implemented a "sufficient subset" of a
multiple routing table solution in Perforce, and back-ported it
to 6.x. (also in Perforce though not always caught up with what I
have done in -current/P4). The subset allows a number of FIBs
to be defined at compile time (8 is sufficient for my purposes in 6.x)
and implements the changes needed to allow IPV4 to use them. I have not
done the changes for ipv6 simply because I do not need it, and I do not
have enough knowledge of ipv6 (e.g. neighbor discovery) needed to do it.
Other protocol families are left untouched and should there be
users with proprietary protocol families, they should continue to work
and be oblivious to the existence of the extra FIBs.
To understand how this is done, one must know that the current FIB
code starts everything off with a single dimensional array of
pointers to FIB head structures (One per protocol family), each of
which in turn points to the trie of routes available to that family.
The basic change in the ABI compatible version of the change is to
extent that array to be a 2 dimensional array, so that
instead of protocol family X looking at rt_tables[X] for the
table it needs, it looks at rt_tables[Y][X] when for all
protocol families except ipv4 Y is always 0.
Code that is unaware of the change always just sees the first row
of the table, which of course looks just like the one dimensional
array that existed before.
The entry points rtrequest(), rtalloc(), rtalloc1(), rtalloc_ign()
are all maintained, but refer only to the first row of the array,
so that existing callers in proprietary protocols can continue to
do the "right thing".
Some new entry points are added, for the exclusive use of ipv4 code
called in_rtrequest(), in_rtalloc(), in_rtalloc1() and in_rtalloc_ign(),
which have an extra argument which refers the code to the correct row.
In addition, there are some new entry points (currently called
rtalloc_fib() and friends) that check the Address family being
looked up and call either rtalloc() (and friends) if the protocol
is not IPv4 forcing the action to row 0 or to the appropriate row
if it IS IPv4 (and that info is available). These are for calling
from code that is not specific to any particular protocol. The way
these are implemented would change in the non ABI preserving code
to be added later.
One feature of the first version of the code is that for ipv4,
the interface routes show up automatically on all the FIBs, so
that no matter what FIB you select you always have the basic
direct attached hosts available to you. (rtinit() does this
automatically).
You CAN delete an interface route from one FIB should you want
to but by default it's there. ARP information is also available
in each FIB. It's assumed that the same machine would have the
same MAC address, regardless of which FIB you are using to get
to it.
This brings us as to how the correct FIB is selected for an outgoing
IPV4 packet.
Firstly, all packets have a FIB associated with them. if nothing
has been done to change it, it will be FIB 0. The FIB is changed
in the following ways.
Packets fall into one of a number of classes.
1/ locally generated packets, coming from a socket/PCB.
Such packets select a FIB from a number associated with the
socket/PCB. This in turn is inherited from the process,
but can be changed by a socket option. The process in turn
inherits it on fork. I have written a utility call setfib
that acts a bit like nice..
setfib -3 ping target.example.com # will use fib 3 for ping.
It is an obvious extension to make it a property of a jail
but I have not done so. It can be achieved by combining the setfib and
jail commands.
2/ packets received on an interface for forwarding.
By default these packets would use table 0,
(or possibly a number settable in a sysctl(not yet)).
but prior to routing the firewall can inspect them (see below).
(possibly in the future you may be able to associate a FIB
with packets received on an interface.. An ifconfig arg, but not yet.)
3/ packets inspected by a packet classifier, which can arbitrarily
associate a fib with it on a packet by packet basis.
A fib assigned to a packet by a packet classifier
(such as ipfw) would over-ride a fib associated by
a more default source. (such as cases 1 or 2).
4/ a tcp listen socket associated with a fib will generate
accept sockets that are associated with that same fib.
5/ Packets generated in response to some other packet (e.g. reset
or icmp packets). These should use the FIB associated with the
packet being reponded to.
6/ Packets generated during encapsulation.
gif, tun and other tunnel interfaces will encapsulate using the FIB
that was in effect withthe proces that set up the tunnel.
thus setfib 1 ifconfig gif0 [tunnel instructions]
will set the fib for the tunnel to use to be fib 1.
Routing messages would be associated with their
process, and thus select one FIB or another.
messages from the kernel would be associated with the fib they
refer to and would only be received by a routing socket associated
with that fib. (not yet implemented)
In addition Netstat has been edited to be able to cope with the
fact that the array is now 2 dimensional. (It looks in system
memory using libkvm (!)). Old versions of netstat see only the first FIB.
In addition two sysctls are added to give:
a) the number of FIBs compiled in (active)
b) the default FIB of the calling process.
Early testing experience:
-------------------------
Basically our (IronPort's) appliance does this functionality already
using ipfw fwd but that method has some drawbacks.
For example,
It can't fully simulate a routing table because it can't influence the
socket's choice of local address when a connect() is done.
Testing during the generating of these changes has been
remarkably smooth so far. Multiple tables have co-existed
with no notable side effects, and packets have been routes
accordingly.
ipfw has grown 2 new keywords:
setfib N ip from anay to any
count ip from any to any fib N
In pf there seems to be a requirement to be able to give symbolic names to the
fibs but I do not have that capacity. I am not sure if it is required.
SCTP has interestingly enough built in support for this, called VRFs
in Cisco parlance. it will be interesting to see how that handles it
when it suddenly actually does something.
Where to next:
--------------------
After committing the ABI compatible version and MFCing it, I'd
like to proceed in a forward direction in -current. this will
result in some roto-tilling in the routing code.
Firstly: the current code's idea of having a separate tree per
protocol family, all of the same format, and pointed to by the
1 dimensional array is a bit silly. Especially when one considers that
there is code that makes assumptions about every protocol having the
same internal structures there. Some protocols don't WANT that
sort of structure. (for example the whole idea of a netmask is foreign
to appletalk). This needs to be made opaque to the external code.
My suggested first change is to add routing method pointers to the
'domain' structure, along with information pointing the data.
instead of having an array of pointers to uniform structures,
there would be an array pointing to the 'domain' structures
for each protocol address domain (protocol family),
and the methods this reached would be called. The methods would have
an argument that gives FIB number, but the protocol would be free
to ignore it.
When the ABI can be changed it raises the possibilty of the
addition of a fib entry into the "struct route". Currently,
the structure contains the sockaddr of the desination, and the resulting
fib entry. To make this work fully, one could add a fib number
so that given an address and a fib, one can find the third element, the
fib entry.
Interaction with the ARP layer/ LL layer would need to be
revisited as well. Qing Li has been working on this already.
This work was sponsored by Ironport Systems/Cisco
Reviewed by: several including rwatson, bz and mlair (parts each)
Obtained from: Ironport systems/Cisco
2008-05-09 23:03:00 +00:00
|
|
|
/* defaults to "all" FIBs */
|
|
|
|
|
int rtinit_fib(struct ifaddr *, int, int);
|
2012-02-17 02:39:58 +00:00
|
|
|
#endif
|
Add code to allow the system to handle multiple routing tables.
This particular implementation is designed to be fully backwards compatible
and to be MFC-able to 7.x (and 6.x)
Currently the only protocol that can make use of the multiple tables is IPv4
Similar functionality exists in OpenBSD and Linux.
From my notes:
-----
One thing where FreeBSD has been falling behind, and which by chance I
have some time to work on is "policy based routing", which allows
different
packet streams to be routed by more than just the destination address.
Constraints:
------------
I want to make some form of this available in the 6.x tree
(and by extension 7.x) , but FreeBSD in general needs it so I might as
well do it in -current and back port the portions I need.
One of the ways that this can be done is to have the ability to
instantiate multiple kernel routing tables (which I will now
refer to as "Forwarding Information Bases" or "FIBs" for political
correctness reasons). Which FIB a particular packet uses to make
the next hop decision can be decided by a number of mechanisms.
The policies these mechanisms implement are the "Policies" referred
to in "Policy based routing".
One of the constraints I have if I try to back port this work to
6.x is that it must be implemented as a EXTENSION to the existing
ABIs in 6.x so that third party applications do not need to be
recompiled in timespan of the branch.
This first version will not have some of the bells and whistles that
will come with later versions. It will, for example, be limited to 16
tables in the first commit.
Implementation method, Compatible version. (part 1)
-------------------------------
For this reason I have implemented a "sufficient subset" of a
multiple routing table solution in Perforce, and back-ported it
to 6.x. (also in Perforce though not always caught up with what I
have done in -current/P4). The subset allows a number of FIBs
to be defined at compile time (8 is sufficient for my purposes in 6.x)
and implements the changes needed to allow IPV4 to use them. I have not
done the changes for ipv6 simply because I do not need it, and I do not
have enough knowledge of ipv6 (e.g. neighbor discovery) needed to do it.
Other protocol families are left untouched and should there be
users with proprietary protocol families, they should continue to work
and be oblivious to the existence of the extra FIBs.
To understand how this is done, one must know that the current FIB
code starts everything off with a single dimensional array of
pointers to FIB head structures (One per protocol family), each of
which in turn points to the trie of routes available to that family.
The basic change in the ABI compatible version of the change is to
extent that array to be a 2 dimensional array, so that
instead of protocol family X looking at rt_tables[X] for the
table it needs, it looks at rt_tables[Y][X] when for all
protocol families except ipv4 Y is always 0.
Code that is unaware of the change always just sees the first row
of the table, which of course looks just like the one dimensional
array that existed before.
The entry points rtrequest(), rtalloc(), rtalloc1(), rtalloc_ign()
are all maintained, but refer only to the first row of the array,
so that existing callers in proprietary protocols can continue to
do the "right thing".
Some new entry points are added, for the exclusive use of ipv4 code
called in_rtrequest(), in_rtalloc(), in_rtalloc1() and in_rtalloc_ign(),
which have an extra argument which refers the code to the correct row.
In addition, there are some new entry points (currently called
rtalloc_fib() and friends) that check the Address family being
looked up and call either rtalloc() (and friends) if the protocol
is not IPv4 forcing the action to row 0 or to the appropriate row
if it IS IPv4 (and that info is available). These are for calling
from code that is not specific to any particular protocol. The way
these are implemented would change in the non ABI preserving code
to be added later.
One feature of the first version of the code is that for ipv4,
the interface routes show up automatically on all the FIBs, so
that no matter what FIB you select you always have the basic
direct attached hosts available to you. (rtinit() does this
automatically).
You CAN delete an interface route from one FIB should you want
to but by default it's there. ARP information is also available
in each FIB. It's assumed that the same machine would have the
same MAC address, regardless of which FIB you are using to get
to it.
This brings us as to how the correct FIB is selected for an outgoing
IPV4 packet.
Firstly, all packets have a FIB associated with them. if nothing
has been done to change it, it will be FIB 0. The FIB is changed
in the following ways.
Packets fall into one of a number of classes.
1/ locally generated packets, coming from a socket/PCB.
Such packets select a FIB from a number associated with the
socket/PCB. This in turn is inherited from the process,
but can be changed by a socket option. The process in turn
inherits it on fork. I have written a utility call setfib
that acts a bit like nice..
setfib -3 ping target.example.com # will use fib 3 for ping.
It is an obvious extension to make it a property of a jail
but I have not done so. It can be achieved by combining the setfib and
jail commands.
2/ packets received on an interface for forwarding.
By default these packets would use table 0,
(or possibly a number settable in a sysctl(not yet)).
but prior to routing the firewall can inspect them (see below).
(possibly in the future you may be able to associate a FIB
with packets received on an interface.. An ifconfig arg, but not yet.)
3/ packets inspected by a packet classifier, which can arbitrarily
associate a fib with it on a packet by packet basis.
A fib assigned to a packet by a packet classifier
(such as ipfw) would over-ride a fib associated by
a more default source. (such as cases 1 or 2).
4/ a tcp listen socket associated with a fib will generate
accept sockets that are associated with that same fib.
5/ Packets generated in response to some other packet (e.g. reset
or icmp packets). These should use the FIB associated with the
packet being reponded to.
6/ Packets generated during encapsulation.
gif, tun and other tunnel interfaces will encapsulate using the FIB
that was in effect withthe proces that set up the tunnel.
thus setfib 1 ifconfig gif0 [tunnel instructions]
will set the fib for the tunnel to use to be fib 1.
Routing messages would be associated with their
process, and thus select one FIB or another.
messages from the kernel would be associated with the fib they
refer to and would only be received by a routing socket associated
with that fib. (not yet implemented)
In addition Netstat has been edited to be able to cope with the
fact that the array is now 2 dimensional. (It looks in system
memory using libkvm (!)). Old versions of netstat see only the first FIB.
In addition two sysctls are added to give:
a) the number of FIBs compiled in (active)
b) the default FIB of the calling process.
Early testing experience:
-------------------------
Basically our (IronPort's) appliance does this functionality already
using ipfw fwd but that method has some drawbacks.
For example,
It can't fully simulate a routing table because it can't influence the
socket's choice of local address when a connect() is done.
Testing during the generating of these changes has been
remarkably smooth so far. Multiple tables have co-existed
with no notable side effects, and packets have been routes
accordingly.
ipfw has grown 2 new keywords:
setfib N ip from anay to any
count ip from any to any fib N
In pf there seems to be a requirement to be able to give symbolic names to the
fibs but I do not have that capacity. I am not sure if it is required.
SCTP has interestingly enough built in support for this, called VRFs
in Cisco parlance. it will be interesting to see how that handles it
when it suddenly actually does something.
Where to next:
--------------------
After committing the ABI compatible version and MFCing it, I'd
like to proceed in a forward direction in -current. this will
result in some roto-tilling in the routing code.
Firstly: the current code's idea of having a separate tree per
protocol family, all of the same format, and pointed to by the
1 dimensional array is a bit silly. Especially when one considers that
there is code that makes assumptions about every protocol having the
same internal structures there. Some protocols don't WANT that
sort of structure. (for example the whole idea of a netmask is foreign
to appletalk). This needs to be made opaque to the external code.
My suggested first change is to add routing method pointers to the
'domain' structure, along with information pointing the data.
instead of having an array of pointers to uniform structures,
there would be an array pointing to the 'domain' structures
for each protocol address domain (protocol family),
and the methods this reached would be called. The methods would have
an argument that gives FIB number, but the protocol would be free
to ignore it.
When the ABI can be changed it raises the possibilty of the
addition of a fib entry into the "struct route". Currently,
the structure contains the sockaddr of the desination, and the resulting
fib entry. To make this work fully, one could add a fib number
so that given an address and a fib, one can find the third element, the
fib entry.
Interaction with the ARP layer/ LL layer would need to be
revisited as well. Qing Li has been working on this already.
This work was sponsored by Ironport Systems/Cisco
Reviewed by: several including rwatson, bz and mlair (parts each)
Obtained from: Ironport systems/Cisco
2008-05-09 23:03:00 +00:00
|
|
|
|
|
|
|
|
/* XXX MRT NEW VERSIONS THAT USE FIBs
|
|
|
|
|
* For now the protocol indepedent versions are the same as the AF_INET ones
|
|
|
|
|
* but this will change..
|
|
|
|
|
*/
|
|
|
|
|
int rt_getifa_fib(struct rt_addrinfo *, u_int fibnum);
|
|
|
|
|
void rtalloc_ign_fib(struct route *ro, u_long ignflags, u_int fibnum);
|
|
|
|
|
void rtalloc_fib(struct route *ro, u_int fibnum);
|
|
|
|
|
struct rtentry *rtalloc1_fib(struct sockaddr *, int, u_long, u_int);
|
|
|
|
|
int rtioctl_fib(u_long, caddr_t, u_int);
|
|
|
|
|
void rtredirect_fib(struct sockaddr *, struct sockaddr *,
|
|
|
|
|
struct sockaddr *, int, struct sockaddr *, u_int);
|
|
|
|
|
int rtrequest_fib(int, struct sockaddr *,
|
|
|
|
|
struct sockaddr *, struct sockaddr *, int, struct rtentry **, u_int);
|
|
|
|
|
int rtrequest1_fib(int, struct rt_addrinfo *, struct rtentry **, u_int);
|
|
|
|
|
|
2007-12-12 20:53:25 +00:00
|
|
|
#include <sys/eventhandler.h>
|
2007-12-17 07:40:34 +00:00
|
|
|
typedef void (*rtevent_arp_update_fn)(void *, struct rtentry *, uint8_t *, struct sockaddr *);
|
|
|
|
|
typedef void (*rtevent_redirect_fn)(void *, struct rtentry *, struct rtentry *, struct sockaddr *);
|
2009-09-08 21:17:17 +00:00
|
|
|
/* route_arp_update_event is no longer generated; see arp_update_event */
|
2007-12-17 07:40:34 +00:00
|
|
|
EVENTHANDLER_DECLARE(route_arp_update_event, rtevent_arp_update_fn);
|
|
|
|
|
EVENTHANDLER_DECLARE(route_redirect_event, rtevent_redirect_fn);
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
1994-08-21 05:11:48 +00:00
|
|
|
|
|
|
|
|
#endif
|
