Please consider a donation to the Higher Intellect project. See or the Donate to Higher Intellect page for more info.

NeXT slirp router

From Higher Intellect Wiki
Jump to navigation Jump to search
I was also rather interested in using a 3.3 system as NAT box.  I would
have thought it would be possible to use something like `slirp' to do
this, which is a user-level thing, rather than a kernel thing.

I intend to try this out (slirp did seem to compile with a few trivial
hacks on 3.3), and will post results.  It looks like it should work,
provided the NeXT can *forward* packets.

Slirp may not give you everything that full NAT does, but it comes
pretty close.  Available at:


From the slirp documentation:

9. Connecting a LAN over Slirp

From the very beginning, Slirp was designed to allow more than one host
access the 'Net at once.  And doing so is *very* easy.

First, you need to setup the LAN (Local Area Network) as if it was really
going to connect to the Internet.  That is, you must give them each a unique
IP (unique relative to each other, not globally unique. E.g., you could give
them all an IP address in the class of addresses).  You also must
tell each host on the LAN to route it's IP packets to the host that is
connected to the Internet via Slirp.

Here's a diagram:

           |         |         |         |         |
        [Host A]  [Host B]  [Host C]  [Host D]  [Host E]
           |                                       |
           |                                       |
           | <- Slirp link                         | <- SLIP link
           |                                       |
           |                                       |
      [Remote Host]                           [Another LAN]
          ... to the Internet

Now, in this diagram, Host A is the Slirp-connected host.  Host's B through
to E can also access the 'Net by simply using Host A as the gateway.  Host A
also must be told to "forward" IP packets (using Remote Host as the gateway)
so that it will send any IP packets not destined for itself to Slirp, and
vice versa (route all packets sent by Slirp, not destined for itself, back
to their respective host's IP).

In other words, the Slirp link is just like a real SLIP/PPP link, which is
what I've been telling you all this time! :)

Note that it is possible to hook up many LAN's to the 'Net by simply
following the normal Internet conventions, and route the packets properly.
In this case "Another LAN" would use Host E as a gateway to the 'Net, Host E,
provided it can forward IP packets, will send them to it's gateway, Host A,
which will send it over Slirp, etc.  In theory, you could connect another
whole Global Internet to the current Internet with no IP address clashes.
Not recommended though :)


I thought I'd followup to my own post to provide a progress report.  I
have managed to connect my PC to the net using the NeXT as a router
successfully via slirp.
It doesn't quite work the way I described it below.  You only need to
run a standard PPP daemon on the NeXT.  You then dialup and telnet (or
rlogin) into a UNIX system at the other end (this may preclude the use
of many ISPs who don't give you a shell), and type `slirp'.  The PPP
link comes up (slirp looks like another ppp daemon as far as the NeXT
is concerned).  You should have a working ppp link (it defaults to the
private address range of 10.0.2.x).

You should then be able to point the other systems on your LAN at the
NeXT (via a default route) and they should now also be able to access
the net.  The nice thing about this is that (like NAT/IP-MASQ), your
LAN is basically invisible to the rest of the world.

This arrangement may not suit some since it requires a shell account
via an 8-bit clean telnet/rlogin and does not support all protocols
(but does support many).  You also need to ensure ip-forwarding is
enabled in your NeXT kernel.  Thanks to Timm Wetzel
for pointing this out to me and finding a small bit of code (from
Deja) that does the job (below).

This would seem to be one way to use the NeXT as router reasonably

/* For OS4.2, compile with: cc -o ipforwarding -O -bsd -fno-builtin -no-precomp ipforwarding.c  */

#include <stdio.h>
#include <strings.h>
#ifndef __STRICT_BSD__
#error Compile with  cc -o ipforwarding -s -object -O -bsd -fno-builtin -no-precomp ipforwarding.c
#include <mach-o/nlist.h>
#include <bsd/libc.h>
#include <bsd/sys/fcntl.h>
#ifndef __STRICT_BSD__
#error Compile with  cc -o ipforwarding -s -object -O -bsd ipforwarding.c
#include <nlist.h>
#include <libc.h>
#include <sys/fcntl.h>

struct nlist nl[]={
    { { "_ipforwarding" } },
    { { (char *)NULL } }

int ipforwarding;

main(argc, argv)
     int argc;
     char *argv[];
    register int s;
    int k;
    char *KERNEL, *KMEM;

    switch (argc) {
      case 1:
      case 2:
        if (!strcmp(argv[1], "off")) break;
        if (!strcmp(argv[1], "on")) {
        if ((argv[1][0]>='0'&&argv[1][0]<='9')||argv[1][0]=='-') {
        /*FALL THROUGH*/
        (void)fprintf(stderr, "Usage: %s [on|off]\n", *argv);
    if (!(KERNEL=getenv("KERNEL")))
#ifdef i386
    if (!(KMEM=getenv("KMEM"))) KMEM="/dev/kmem";
    s=nlist(KERNEL, nl);
    if (s<0) {
    if (s!=0) {
        (void)fprintf(stderr, "%s: nlist failed\n", *argv);
    if ((k=open(KMEM, argc>1 ? O_RDWR : O_RDONLY))<0) {
    if (lseek(k, (long)nl[0].n_value, 0)<0L) {
    if (argc<=1) {
        if (read(k, (char *)&ipforwarding, sizeof ipforwarding)!=
            sizeof ipforwarding) {
        (void)fputs("ipforwarding is ", stdout);
        switch (ipforwarding) {
          case 0:
            (void)fputs("off\n", stdout);
          case 1:
            (void)fputs("on\n", stdout);
            (void)printf("%d\n", ipforwarding);
    else if (write(k, (char *)&ipforwarding, sizeof ipforwarding)!=
             sizeof ipforwarding) {