sas

Nano-Howto to use more than one independent Internet connection.
by Christoph Simon
v1.0, Dec 2, 2001
—————————————————————-

1. Intro
========

1.0 Thanks
———-

The solution presented here is based on the patches by Julian
Anastasov. Like several other users on the net struggling with this, I
believe they fill in yet another gap for using Linux as a very
advanced router. It was hard for me not only to get this running for
the first time, but also to understand most of the principles. Also in
this Julian has proofed to have unlimited patience. Thanks.

He also agreed to expose this file on his site:

http://www.linuxvirtualserver.org/~julian/nano.txt

1.1 Initial situation
———————-

I’ve been looking for a solution to use more than one connection to
Internet at the same time for a long time. I’ve found out, that I’m
not alone; there seem to be many having this very problem. The reasons
are generally just to cheaply increase total throughput, or to provide
for a fail-over in case of cheap lines. This is not the situation of a
cluster of web-servers, where main traffic is input, but for networks
which are mainly dedicated to any kind of download.

1.2. Bad news
————-

The setup of all this is not a question of 5 minutes, so I’ll tell at
the beginning where are the limits.

First, this will not work for a single computer with two modem
connections. Load balancing does work reasonably well, but only with a
high number of simultaneous connections to different remote sites.

The tests I’m performing are on a network with 17 client computers
with an daily download (12h) of some 600MB of HTTP traffic in several
hundreds of thousands of connections.

When one connection fails while being used, this connection will be
lost and can’t be continued on another line. The user will have to
establish this connection anew. If it was a big download and the
server doesn’t support continuation, he’ll be out of luck.

The lines I’m using have external modems which react as any other
device with Ethernet. There is no PPP, PPPoE, etc. I can’t tell if
this works or would need modification for instance to use two
telephone lines. Maybe someone else can fill in this.

1.3 Good news
————-

What does work is:

- there is no restriction to 2 lines, though I didn’t test more.
- using 2.4 kernels
- interaction with ip(8) and iptables(8)
- usage of both lines at the same time
- if any line fails, new connections will use any other which working.
- if a line fails, no reconfiguration of the network is required.

Right now, I can’t tell how long it takes in case of a fail over, but
there where several cases I found in the logs and no user realized
that there was a problem.

2. Setup
========

2.1. Preparing the kernel
————————-

Stock kernels are not able to provide this functionality. Julian
Anastasov wrote a patch for 2.2 and 2.4 Linux kernels. I only tried
with several 2.4 kernels, now running 2.4.15pre5. The patches have not
been written for this version, but apply cleanly. The patches are
available on Julian’s web-page:

http://www.linuxvirtualserver.org/~julian/#routes

Choose the patches for your kernel, download them, and apply all of
them.

The patches will not offer any additional configuration options. The
kernel needs to have “equal cost multi path” enabled. This is done in
Network Options. After choosing “IP: advanced router” there will be an
option for it. Only an indirect requirement is, that we will need NAT:
Any host on the local network needs to be able to appear on the
Internet with any of the external IPs; this is the main purpose of
NAT. To get NAT, of course we have to enable connection tracking. But
this would be done anyway. No further options are required, but any
networking option may be used. Particularly, I’ve enabled almost all
options for netfilter and QoS and it’s working fine.

Nothing special is required to run this kernel (no boot options,
etc.).

2.2 Netfilter issues
——————–

As I stated at the beginning, to make use of the patches and the
configuration described here, we need a relatively high number of
connections and remote servers. I’ve tried bitterly, but wasn’t able
to achieve this effect alone. I started several simultaneous
downloads, ran Mozilla on several computers at the same time, opening
different big sites, but no avail. When the regular users came, things
suddenly showed to work correctly. So this is certainly not a setup
for a single box, and then, we’ll need to do some address
translation. Beside this, a firewall will almost always be
unavoidable, but it’s setup is out of scope here. A minimal setup
would enable forwarding in the kernel, establish a default policy of
ALLOW, and create at least two SNAT rules:

iptables -t nat -A POSTROUTING -o IFE1 -s NWI/NMI -j SNAT –to IPE1
iptables -t nat -A POSTROUTING -o IFE2 -s NWI/NMI -j SNAT –to IPE2

If the ISP didn’t give us a fixed IP, for instance using PPPoE, but it
seems that it must be an ARP type device, we would say:

iptables -t nat -A POSTROUTING -o IFE1 -s NWI/NMI -j MASQUERADE
iptables -t nat -A POSTROUTING -o IFE2 -s NWI/NMI -j MASQUERADE

I didn’t try this, but it will work if the analog thing works with
just one line. This is not really new, as we would have to do
something similar anyway, even with only one line to the Internet.

At least for netfilter (not sure for ipfwadm/ipchains), the firewall
must be stateful. This can be done by:

iptables -t filter -N keep_state
iptables -t filter -A keep_state -m state –state RELATED,ESTABLISHED \
-j ACCEPT
iptables -t filter -A keep_state -j RETURN

iptables -t nat -N keep_state
iptables -t nat -A keep_state -m state –state RELATED,ESTABLISHED \
-j ACCEPT
iptables -t nat -A keep_state -j RETURN

and calling this at the beginning of the script:

iptables -t nat -A PREROUTING -j keep_state
iptables -t nat -A POSTROUTING -j keep_state
iptables -t nat -A OUTPUT -j keep_state
iptables -t filter -A INPUT -j keep_state
iptables -t filter -A FORWARD -j keep_state
iptables -t filter -A OUTPUT -j keep_state

2.3 Routing
———–

Here I’ll assume that the computer has three network cards: one to the
local network, and two for each of the external links (DSL modems in
my case). This needs not to be so, as there could be more DSL modems,
and, at least in theory, it’s possible to use one card for more than
one modems, using a hub and two or more IPs on the same device. This
is not a recommended setup because it may introduce security problems,
but might be the only one if we had more lines than PCI slots for
additional network cards.

Abbreviations:
IFI internal interface
IPI IP address of internal interface
NMI netmask for the internal interface
IFE1, IFE2 external interfaces
IPE1, IPE2 external IP address
NWE1, NWE2 external network address
NME1, NME2 mask for the external network (number of bits, like in /24)
BRD1, BRD2 broadcast address for external network
GWE1, GWE2 gateway for external interface

2.3.1 The local loopback and the internal interface
—————————————————

The local loopback must be up and running. There is nothing unusual
about this.

ip link set lo up
ip addr add 127.0.0.1/8 brd + dev lo

At this point, we should be able to ping localhost.

We also set up the internal interface IFI with the internal address
IPI and the netmask for the local network NMI. Assigning an address
will cause the kernel to automatically insert an appropriate route
into table main. This is just fine. Later, there will also be a route
for each external interface, but none of the routes in table main will
have a gateway.

We’ll want to give table main a priority of 50 to make sure it is
looked at first.

But also we want to make sure that there is no default route in table
main. The commands so far didn’t insert any, but if this is a
reconfiguration, there might remain some from the previous setup. If
there is none, the last command will fail, but that’s OK: we just want
to be sure.

ip link set IFI up
ip addr add IPI/NMI brd + dev IFI
ip rule add prio 50 table main
ip route del default table main

At this point, we should be able to ping any host on the local
network.

2.3.2 Setup of external interfaces
———————————-

The configuration of the external interfaces isn’t really different
from that of the internal, but for now, we don’t specify a gateway nor
do we insert a default route.

ip link set IFE1 up
ip addr flush dev IFE1
ip addr add IPE1/NME1 brd BRD1 dev IFE1

ip link set IFE2 up
ip addr flush dev IFE2
ip addr add IPE2/NME2 brd BRD2 dev IFE2

As ip(8) allows to assign more than one address to an interface, it’s
important that there doesn’t remain any configuration from a previous
setup; failing to do so might cause the same address to be specified
twice. That’s what the “addr flush” commands are for. When we actually
specify the address (the last line of each block), the kernel, again,
will insert automatically a route into table main, very much like in
the case of the internal interface.

Now, we should be able to ping the external IPs (IPE1 and IPE2), as
well as the gateways or any other host or device which belongs to
those external network addresses. In my case there is none beside the
gateways. For this reason it would be correct to consider such an
interface like a point-to-point device, but technically it is not.

2.3.3 Setup of the default routes
———————————

This is the complicated part of the setup. During this discussion,
I’ll mention the setup commands step by step. In the end, I’ll repeat
them all together.

Before really starting, let’s make a small experiment: Using any kind
of packet tracer (logs from iptables, tcpdump, etc), we will observe
that if we ping 127.0.0.1, the source address of that packet will be
127.0.0.1; if we ping any address of the local network, the source
address will be that of the internal interface. And if we ping any
host or device outside, the source address will be that of the device
where the packet is going out. Who is being that smart? It might be
the application (e.g., ping) itself, using a bind(2) call, but this is
not normally done for a client. It’s the routing system. In other
words, until a packet actually reaches the routing system, it doesn’t
have a source address.

Well, in practice, some programs try to be smarter than the routing
system, use the bind(2) call, but actually choose a less than optimal
route. This would easily be the case under our setup, as a program
can’t know which of the two external interfaces it should use. Also,
there are some versions of ping which allow the user to specify the
source address. While being an interesting tool also in our setup, the
`being smart’ is then really up to the user.

As I stated in the requirements, NAT is one of them and so is
connection tracking. This consists of a set of information for each
known connection, including specific NAT details.

We see, even if the packet originates on the same computer, in our
case, a packet can have one of four addresses: 127.0.0.1, IPI, IPE1,
or IPE2. This is called the local source address, which plays a major
role when doing NAT. Here, this was one of the key concepts I had to
understand to be able to understand the rest.

I’ll try to `deduce’ the routing commands by following a packet from a
host on the local network. While it might also originate from the
computer we are configuring, this will be the most typical path. I’ll
call that host w1 (the first workstation).

The setup of w1 is as usual: It has a loopback interface, a network
card with an IP address compatible with the local network address, and
a default route which uses as a gateway the computer we are
configuring here (IPI). As soon as the user on w1 does anything which
requires access to Internet, her program will set up a socket and call
connect(2). Then, an IP packet will be formed. The routing system on
w1 will set the source address to w1’s local IP, the destination
address to that of the remote server on the Internet. It will use the
default route to send this packet to us.

The packet will come in by the local interface IFI, being welcome, if
present, by the prerouting chain of the mangle table, but certainly by
the prerouting chain of the nat table.

The nat table will search the already existing connection structures
and find out, that this is a new connection. It will create an
uninitialized info-block, and pass the packet to the routing system.

At this time, we have the following information: The packet came in by
the local interface IFI, has the source address of w1, but we don’t
know yet the local source address.

Being a new connection, there will be nothing matching in the
cache. Also, our configuration so far doesn’t have any default route
yet. So we need one which tells what to do with such a packet:

ip rule add prio 222 table 222
ip route add default table 222 proto static \
nexthop via GWE1 dev IFE1 \
nexthop via GWE2 dev IFE2

This is a multipath default route, causing the kernel to extract each
time another alternative; there could be more than these two.

Now, we get two additional informations: the output device (either
IFE1 or IFE2) and the IP address of the gateway (either GWE1 or
GWE2). Actually we also may get a third information, which is our
local IP address, which is not contained in this route, but the system
will deduce it by interface and gateway if it is not a dynamic
IP. That’s it, routing is doing for us right now, beside sending the
packet to the forward chain of the filter table.

Of course, forwarding must be enabled in the kernel, and there must
not be any netfilter rule disallowing this packet. After that, the
packet is passed along to the postrouting chain of the nat table.

Using the information about the packet we gathered so far, the NAT
system will look for a rule, and find one of the two we gave in the
previous section. If our IP is fixed, now the local source address
will became known, but if it is dynamic, i.e., we used the MASQUERADE
target, we will need to go back to routing, as there is no other way
to find out the right local source address. The answer will come from
table 222, the multipath route, but this time, also interface and
gateway need to match. The NAT system will insert this into the, now
initialized, NAT information in the connection structure, replace the
source address in the packet by this one (which was still the IP of
w1), and get this packet on it’s way to the gateway, going out by the
proper output device.

Note here, that when asking the multipath route, table 222, with a
known output device and gateway, the kernel still has to deduce the IP
address. It will do so, looking at the first address attached to the
interface which, by netmask, is compatible with the gateway
address. If there were more than one possible answers, only the first
will be used. This might be the case if we have both lines on the same
network card, which will work only if we use the MASQUERADE target in
the iptables rules. If we didn’t use the gateway (stock kernels don’t)
to make this match, we surely would be in troubles, because the output
device is the same for both. This means: To be able to use more than
one Internet connection on one and the same network card, the gateways
must be different, the IP addresses must be public IPs and must not
belong to the same subnet. Additionally, we should avoid SNAT in the
iptables rules and take special measures to protect against IP
spoofing.

The gateway, and potentially lots of routers in the Internet, are
supposed to do the right thing to make this packet reach it’s
destination. There, the answer packet will use the source address
(which is now either IPE1 or IPE2) to come back into our computer by
the same interface where it left. Essentially, the procedure is
reversed; our routing table will find the way to w1 already in table
main.

Most user actions on the Internet aren’t happy with just one packet of
data; let’s have a look what happens if a second packet is sent from
w1 to the same destination:

Again, the packet will arrive at the local interface of this computer
and pass through the prerouting chain of the mangle table if that
exists. The prerouting chain of the nat table will start looking for
an existing, matching connection, and this time, it will find one. As
there is no DNAT rule in the netfilter setup for this packet, NAT will
just hand over the packet to the routing system.

The routing system will look at the connection, and the patches will
find that there is NAT information present, and that after routing
some mangling will be done. Now, the routing question will give the
input device (IFI), the source address (the IP of w1), the destination
address (that of the server on the Internet), and the local source
address (either IPE1 or IPE2). In this situation, we do not want to
match the multipath route, because the multipath route doesn’t look at
local source address, we couldn’t make sure that we get this time the
same line as before. So we add a table for each interface:

ip rule add prio 201 from NWE1/NME1 table 201
ip route add default via GWE1 dev IFE1 src IPE1 proto static table 201
ip route append prohibit default table 201 metric 1 proto static

ip rule add prio 202 from NWE2/NME2 table 202
ip route add default via GWE2 dev IFE2 src IPE2 proto static table 202
ip route append prohibit default table 202 metric 1 proto static

This can’t be matched when table 222 should be matched, as we now
require the local source address to be known. We choose a priority
that makes sure these routes are found after the main table and before
table 222, which is more general than these.

These are still default route, because they must match any Internet
address.

The third line of each block is similar to a REJECT target in iptables
in case the corresponding interface is not working: If the client on
the local network sends a packet on an established connection, but in
the meanwhile the interface stopped operating, we will send this
client an ICMP controll message `PKT_FILTERED’, hoping to cause it to
stop sending packets, and the user might wish to open a new
connection, which will succeed if at least one other line is still
working.

Stepping through all routing tables, either table 201 or table 202
will match, according to the output device selected when we matched
the multipath route for the first packet. The tricky part is, what the
patches are doing here: They look at the local source address. If it
is zero, the old behavior would just match the multipath route in
table 222, but as we do know already the local source address (i.e.,
it is not zero) from what we found in the connection structure,
particularly what concerns NAT, we will try to match the rules against
the local source address rather than the packet’s source address,
which is still the IP of w1. This is why either table 201 or table 202
will provide the match, telling the gateway address and the output
device.

Having done it’s job, the routing system will send the packet to the
forward chain of the filter table, to continue in the postrouting
chain of the nat table. That has an easy game now, because, no matter
if the found target is MASQUERADE or SNAT, all necessary information
is already known. The packet’s source address will be replaced by our
local source address and the packet can continue it’s way going out by
the chosen output device, and reach it’s destination through the
Internet. The same procedure is repeated for all further packets,
because the connection information is kept alive during a certain
time, even after closing the connection (FIN or RST).

Now let’s have a look at a packet which originates on this computer
with a destination on the Internet. As we found out in our experiment,
the source address is not known before routing, and we won’t need any
NAT. Here we will assume that the program which generates this packet
does not use the bind() call. If it would, either table 201 or table
202, according to the IP this program binds to, would be used and no
(further) load balancing can take place. So, the packet will start
crossing the output chain of the mangle table, if that is present, and
go to the output chain of nat. As there is no rule for a destination
nat, it will continue being evaluated in the routing system. No local
source address is known yet, so the multipath route in table 222 will
match. This will provide the output device, the gateway and also the
local source IP. Now the connection information can be completed. With
that, the packet will cross the output chain of the filter table and
reach the postrouting chain of the nat table. From there the packet
can be sent to the gateway. From now on, the connection is known and
all further packets will use this path.

Now the full sequence of commands, all together. For convenience, I’ll
repeat the meaning of the abbreviations:

Abbreviations:
IFI internal interface
IPI IP address of internal interface
NMI netmask for the internal interface
IFE1, IFE2 external interfaces
IPE1, IPE2 external IP address
NWE1, NWE2 external network address
NME1, NME2 mask for the external network (number of bits, like in /24)
BRD1, BRD2 broadcast address for external network
GWE1, GWE2 gateway for external interface

ip link set IFI up
ip addr add IPI/NMI brd + dev IFI
ip rule add prio 50 table main
ip route del default table main

ip link set IFE1 up
ip addr flush dev IFE1
ip addr add IPE1/NME1 brd BRD1 dev IFE1

ip link set IFE2 up
ip addr flush dev IFE2
ip addr add IPE2/NME2 brd BRD2 dev IFE2

ip rule add prio 201 from NWE1/NME1 table 201
ip route add default via GWE1 dev IFE1 src IPE1 proto static table 201
ip route append prohibit default table 201 metric 1 proto static

ip rule add prio 202 from NWE2/NME2 table 202
ip route add default via GWE2 dev IFE2 src IPE2 proto static table 202
ip route append prohibit default table 202 metric 1 proto static

ip rule add prio 222 table 222
ip route add default table 222 proto static \
nexthop via GWE1 dev IFE1 \
nexthop via GWE2 dev IFE2

Let’s check it out:

ip address

This should print on the terminal one entry for the local loopback,
IFI, IFE1 and IFE2, and maybe some other things, if we have it
configured (like my GRE tunnels).

ip rule

This should look like this:

0: from all lookup local
50: from all lookup main
201: from NWE1/NME1 lookup 201
202: from NWE2/NME2 lookup 202
222: from all lookup 222
32766: from all lookup main
32767: from all lookup default

Table local is used for the local loopback, table main has the network
routes to the internal network and for the external interfaces, which
only give access to our gateways. Tables 201 and 202 (which also might
have the same priority), will provide a default route if the local
source address is known (because they have to match NWE1 or NWE2). And
table 222 will provide the multipath route. The tables with priority
32766 and 32767 will not be used.

ip route list table main

Giving:

NWI/NMI dev IFI proto kernel scope link src IPI
NWE1/NME1 dev IFE1 proto kernel scope link src IPE1
NWE2/NME2 dev IFE2 proto kernel scope link src IPE2

These are only routes to the corresponding networks without using a
gateway.

ip route list table 201

Giving:

default via GWE1 dev IFE1 proto static src IPE1
prohibit default proto static metric 1

And:

ip route list table 202

Giving:

default via GWE2 dev IFE2 proto static src IPE2
prohibit default proto static metric 1

These are the default routes requiring the local source address to be
known. And finally:

ip route list table 222

Giving:

default proto static
nexthop via GWE1 dev IFE1 weight 1
nexthop via GWE2 dev IFE2 weight 1

which of course is our multipath route. The weights where inserted by
the kernel and could be changed. Actually, they need to be changed
specially if the two lines have a very different capacity. With this
configuration, both lines are going to be used the same amount of
times (at least in the long run), even in case the first line has 4
times the capacity of the second. To compensate for that, we would add
“weight 4″ after IFE1, like in:

ip route add default table 222 proto static \
nexthop via GWE1 dev IFE1 weight 4\
nexthop via GWE2 dev IFE2 weight 1

The numbers should be as small as possible, because in this case, the
kernel will create 5 alternative routes, four of them being the
same. For this reason, it wouldn’t really be an equivalent to say
“weight 400″ and “weight 100″, nor would it be a good idea.

Now, let’s see how the kernel chooses certain routes:

Asking, how to reach the gateway:

ip route get GW1

We get the route from table main:

GW1 dev IFE1 src IPE1
cache mtu 1500

Now, let’s ask for the route to a host on the internet. Note, that the
ip(8) command does no DNS lookups; we need to provide the IP. This one
goes to www.kernel.org:

ip route get 204.152.189.113

My system answered:

204.152.189.113 via GWE1 dev IFE1 src IPE1
cache mtu 1500

i.e., having chosen the first interface. As it got this from the
cache, it won’t be easy to get the answer for the second interface
until the cache expires, or we flush it explicitly. If not found in
the cache, this answer must come from table 222. To test tables 201
and 202, we can use:

ip route get from IPE1 to 204.152.189.113
ip route get from IPE2 to 204.152.189.113

and would get respectively:

204.152.189.113 from IPE1 via GWE1 dev IFE1
cache mtu 1500
204.152.189.113 from IPE2 via GWE2 dev IFE2
cache mtu 1500

Up to here, we know how all external lines are being used while they
are working. It’s also easy to guess what happens if all external
lines fail. But let’s see what happens if only one external line
fails:

At a first glance, nothing special happens. If one of the routes in
the multipath statement is unavailable, it just stops being eligible
and we get always the other one (one of the others, if more than
two). But it is less evident, what happen during the transition.

When we try to send a packet to another device, and that fails, like
in real live, we’ll blame the other side. But if we can’t reach one
neighbor, it doesn’t mean necessarily that we can’t reach any
neighbor. This depends on the reason for the failure. If the problem
is in our network card or in the cable attached to it, we won’t reach
any other, but it’s also possible that only this remote device is
down. Well, in our particular case, this is the same, because, from
the functional point of view, this is a point to point connection, and
beside the gateway and ourselves, there is no other device. But the
lower level transport system can’t know that and hence will mark this
link just as suspected to fail. Neither the routing cache nor the
connection information have yet knowledge of the problem, and the
user’s connection will block.

After a certain time, Ethernet will consider the gateway dead and mark
it as unreachable. If this is because the link was brought down, the
routing cache will be flushed immediately, forcing the next packet to
choose a new route, which will get only a working one. Otherwise, the
packet could use a route in the cache which is actually unreachable,
causing it to fail: All connections which are in the cache and which
use this route will just go nowhere. After a certain interval of time,
the entries in the routing cache expire, and than the route have to be
looked for again, offering only working routes, and things will work
again.

From the user’s point of view: An established connection using a line
which stops working will be lost. She’ll need to establish a new
connection. Until the cache expires, a new connection will work only
if the route isn’t yet in the cache, or if the cached route uses a
working line. But if the route is cached and uses the failing line,
the connection will not work.

The time until the cache expires is controlled by the kernel variable
/proc/sys/net/ipv4/route/gc_interval and defaults to 60 seconds. The
bigger this number, the longer it will take until failing routes are
not being used again, but the shorter this time, the smaller the
chances to find a connection in the cache, loosing time to look up the
connection in the routing tables.

The inverse is analog: If the line comes back up, cached routes won’t
use it. But routes found by matching the multipath route in table 222
will consider this route as eligible again, and possibly use it. But
more on this in the next section.

2.4 Keeping them alive
———————-

We’re almost done. There is a subtle issue about the kernel detecting
the state of an interface. We can not find out whether an interface is
working without just trying to use it. As long as the kernel doesn’t
use the interface, it can’t know if it is working or not. When we try
to use it, the kernel will mark the interface according to the result
of that operation. If this means, the interface is down, and we
continue trying to access Internet, the kernel will simply use the
other interface. How then can the kernel find out, that the failing
interface is working again? Well, it can’t, because it wouldn’t even
try. This is good, because users we wouldn’t like to have to wait for
a timeout with each packet. But then, there needs to be a way to
notice when the interface comes back up. The only way is to use the
interface explicitly with non critical packets. Before using these
patches I had written a daemon which would set up explicit routes to
each gateway and send pings in regular intervals (once per
minute). Then the default route was set either to the preferred
interface or to the only one working. Now, this daemon doesn’t need to
change routes anymore, but it still has to send the pings.

But there isn’t really a daemon needed for this. A simple script:

while : ; do
ping -c 1 GWE1 > /dev/null 2>&1
ping -c 1 GWE2 > /dev/null 2>&1
sleep 60
done
can do this.

At the beginning, I was worried because I’ve a link where the provider
doesn’t reply pings. But this is really not necessary. The trick is,
that ARP requests must be answered for anything to work. One
consequence of this is, that for now I’m only sure that this works for
devices which are based on Ethernet, i.e., which use the ARP. Other
devices, like dialup links, can only work if the underlying network
protocol provides a correct status change. But I’m not aware if or
which Linux protocols are implemented this way.

What I’ve learned from this is, that it’s not enough to just set a
device up or down, or to add or remove a route. Somehow, the kernel
must also be told, that this device or route is working or stopped
doing so.

Running the pings once every minute all the time isn’t what seems to
be an elegant solution, but it works. Hopefully, someday we’ll get
this done behind the scene.

During development of this setup, I’ve considered using arping rather
than ICMP echo replies. Both can be problematic. The gateway can drop
echo messages, so ping wouldn’t work. On the other hand, I’ve noticed
in two situations that the provider apparently had installed some kind
of load balancing making the MAC address of the gateway toggling from
one to another. This renders arping useless. So I stayed with
ping. This will work anyway, because my daemon doesn’t need to know
the result: Even if I don’t get an ICMP echo reply, the kernel will
fill in the right MAC address for this gateway and know that it is
reachable or not.

It seems that newer versions of arping use a broadcast mode, which
would solve the problem with a provider that changes the MAC address
of the gateway every few minutes. I didn’t try it yet, but I will.

3. Comments
3.2 About the patches
———————

Some of us are curious and wish to know what the Julian’s patches
actually do. Here is a summary:

- With the patches enabled, we can use “proto static” for all
routes. Doing so, the route for a link will survive even if that
device stops working. This is essential, specially if the reason for
using two lines is redundancy: If a line fails, all attributes of
the device remain, beside the fact that it can’t be used until it
comes up again. We can continue pinging the gateway for to detect
the moment the link comes up again. Equal cost multipath exists also
without these patches, but wouldn’t work in such a situation.

- If the device continues existing even if it doesn’t work, the kernel
needs a way to decide whether this is a route might be chosen,
specially if several are available. This is called the “dead
gateway detection”; it works for any kind of unicast routes
(multipath/unipath, input/output) and provided by these patches.

- A multipath route consists of several routes with the same source
and destination, but a different path, which is specified by the
device and the gateway. It is because of the patches that the kernel
knows how to distinguish the route not only by source and
destination, but also by device and gateway. Also, at least when
each line has a different device, the kernel’s reverse path checking
(rp_filter) will work correctly.

- The NAT system has no idea how to deal with alternative routes, this
is something the routing system has to do. And one of the additions
of these patches is make the routing system prepare the route of an
individual packet for the nat system, such that it looks as if it
where the only possible route.

3.1 Practical experience
———————–

It’s very little time that I use this, so obviously I can’t give any
long term results. But after the first few days of working, I can say
that load-balancing is working reasonably well. I could imagine a more
fine grained behavior which would benefit single users with two DSL
lines, but in my particular situation I’ve seen a difference on total
load of only 15%.

Fail-over happened already several times and went by without being
noticed by the users. In the time I’m using this, I didn’t experience
any problem. It just works :-).

ciccio@kiosknet.com.br

================================

http://www.nabble.com/HOW-TO—LOAD-BALANCE-WITH-2-OR-MORE-RED-NICs-to9368851.html#a9368851

LOAD BALANCING WITH 2 OR MORE RED NICS
*************************************

The objective of this small howto is to make a load balance of the internet traffic between 2 or more red nics with STATIC IP (is a must)
1. Configure 1 red nic using the web interface
2. Open a ssh connexion as root to the firewall and enter to the folder /var/efw/uplinks (”cd /var/efw/uplinks”)
3. run the command “cp -p -r ./main ./link2 (if you have more red nics repeat this step but with ./link3 ./link4 ./link… you get the point)
4. Enter to each one of the copied folders and edit all of the parameter in the file “settings” except DEFAULT_GATEWAY, leave that one blank
5. Do the previous step with the folder main ( /var/efw/uplinks/main)
6. Recheck that all parameter for all of your links are set OK, and that all DEFAULT_GATEWAY fields are blank (is a must or else it wont balance the traffic)
7. Enter the directory /var/efw/inithooks (”/var/efw/inithooks”)
8. add to the files start.local updatered.active.local updatered.inactive.local updatered.local and updatewizard.local

route del default
route del default
route del default
route del default
ip route add default equalize scope global \
nexthop via dev weight 1 \
nexthop via dev weight 1 \
nexthop via dev weight 1 \
.
.
.
NOTE: remove the ” \ ” in the last line
NOTE: i modify ALL those files because i do not know witch one endian use to generate the routing tables.

9. Restart your endian firewall
10. Wait 5 minutes or so an log to the firewall
11. Check your routes with the command “ip route”, it shoud show you all the gateways that are using in a round robin balance for the packets that goes out from your network to the internet.
12. HAVE FUN

P.S: if any one can make a scrit or some howto to create such route with a DHCP or pppoe red iface it would be great.

Bye

Fernando Cabrera Jaramillo