Linux

Our needs were extremely simple: a routing system that would connect one remote site to a shared

Internet router that spoke RIP on our end. The site had one LAN to start with, but would probably be

adding a few more.

We decided to use Linux because it was inexpensive enough for a pilot project: it would cost us two PCs

plus labor. Also, we would be able to have one machine handle routing services, mail services, limited

FTP services, and name services. This saved us the startup costs of a dedicated router plus a UNIX or

dedicated DOS box to manage DNS and POP. Our goal, and current implementation, is shown in Figure

1.

We built the first machine out of a surplus (and highly generic) 80486 motherboard with 8Mb of RAM

and a 120Mb IDE hard drive. We purchased and installed the Slackware distribution of Linux off a

borrowed NEC CD-ROM, making sure to install kernel source code, the PPP daemon, and the various

user-level services we wanted to run.

The first thing to do was to modify the kernel to act as a packet forwarder. Slackware came with many

excellent precompiled kernels, but IP forwarding was not an option. Apparently, some random RFC

specifies that IP forwarding is not to be turned on by default. This actually makes sense: why spend the

processor cycles dealing with it if you don’t need to? So, compiling a kernel ourselves was our only

option. However, it’s not the only option you have: if you want a precompiled Linux 1.2.0 kernel with

IP forwarding, ethernet, and token-ring support, get it from

ftp://moria.co.chatham.ga.us/pub/ vmlinuz.tr.eth.ipfwd

At first, the notion of compiling a kernel seemed daunting. Before this, we’d only re-linked OEM UNIX

kernels. It turned out to be much easier than expected; the processor and hard drive were the only things

that had to work hard.

The directory /usr/src/linux is, by convention, a symbolic link to the current production version of Linux

running on your machine. Finding it is easy: The README file contained therein is fairly short and to

the point, and describes how to configure the kernel and install it.

To make a kernel, we typed:

# cd /usr/src/linux

# make config

...

*

* Networking options

*

TCP/IP networking (CONFIG_INET) [y]

IP forwarding/gatewaying (CONFIG_IP_FORWARD) [n] y

# make dep ; make clean

# make zImage

Then, before installing the kernel, in addition to backing up the current kernel, we also made a boot disk,

just in case. After putting a floppy in the A: drive (for you DOS types), we typed:

# dd if=/vmlinuz of=/dev/fd0

# cp /vmlinuz /vmlinuz.safe

# mv /usr/src/linux/arch/i386/boot/zImage /vmlinuz

# lilo

Added linux

# sync ; reboot

A Few Caveats

If you have played with LILO (the LInux LOader), /vmlinuz may very well not be your system kernel.

Check /etc/lilo.conf if you’re unsure.

Make sure you use networking tools that match your kernel version -- all sorts of strange things can

happen with a mismatch! Specifically, watch out for arp, route, ifconfig, and gated. A good rule of

thumb is to stick to the versions that come on the CD-ROM distribution. If you’re getting your files

from the Internet, pay close attention to READMEs.

Stick to the defaults when configuring by hitting ENTER at the prompts. Be sure you don’t configure a

device that you don’t have -- if you do, you risk lockups and erratic system behavior.

In our case, we also had to scour the earth for a Token Ring driver for Linux, and compile it into our

kernel, but that’s another long story. If you are looking for Token Ring support, and are willing to live

without busmastering and TI chipset support, check out Peter De Schrijver’s Wonderful Token Ring

driver:

ftp://linux3.cc.kuleuven .ac.be/pub/Linux

or

ftp://ftp.cs.kuleuven.

ac.be/pub/unix/linux

See Terry Dawson’s comprehensive NET2-HOWTO for current information on available networking

technology support. Look in:

ftp://sunsite.unc.

edu/pub/Linux/docs/

linux-doc-project/network-guide

Token Ring may well be included in many distributions by the time you read this. I will mention,

however, that we had problems using kernels earlier than 1.2.

Once the kernel was recompiled and ready to forward packets according to its routing table, we needed

to give it routing "smarts," so we started up routed, the ancient routing daemon. This was a mistake;

routed is obsolete and flakey, and should not be used here. Instead, use gated. It will speak every routing

protocol you’re ever likely to need, and it is easy to configure for RIP (see Figure 2). If you need to use

something other than RIP, say, OSPF, you can rest easy knowing that the gated distribution has quite a

few sample configuration files for you to copy.

Any router needs more than one interface to be useful, and our Linux router was no exception. We chose

to use PPP (Point-to-Point Protocol) in conjunction with ISDN terminal adaptors, because ISDN service

is extremely inexpensive here. (ISDN was not supported with most Linux distributions at the time, but