move linkaddr() to lib/libc/net/linkaddr.c
[unix-history] / usr / src / sbin / route / route.c
index af967d5..2fda3f0 100644 (file)
@@ -1,18 +1,8 @@
 /*
 /*
- * Copyright (c) 1983 The Regents of the University of California.
+ * Copyright (c) 1983, 1989 The Regents of the University of California.
  * All rights reserved.
  *
  * All rights reserved.
  *
- * Redistribution and use in source and binary forms are permitted
- * provided that the above copyright notice and this paragraph are
- * duplicated in all such forms and that any documentation,
- * advertising materials, and other materials related to such
- * distribution and use acknowledge that the software was developed
- * by the University of California, Berkeley.  The name of the
- * University may not be used to endorse or promote products derived
- * from this software without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
- * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ * %sccs.include.redist.c%
  */
 
 #ifndef lint
  */
 
 #ifndef lint
@@ -22,33 +12,70 @@ char copyright[] =
 #endif /* not lint */
 
 #ifndef lint
 #endif /* not lint */
 
 #ifndef lint
-static char sccsid[] = "@(#)route.c    5.13 (Berkeley) %G%";
+static char sccsid[] = "@(#)route.c    5.26 (Berkeley) %G%";
 #endif /* not lint */
 
 #include <sys/param.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
 #endif /* not lint */
 
 #include <sys/param.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
+#include <sys/file.h>
 #include <sys/mbuf.h>
 #include <sys/mbuf.h>
+#include <sys/kinfo.h>
 
 #include <net/route.h>
 
 #include <net/route.h>
-#include <net/radix.h>
+#include <net/if_dl.h>
 #include <netinet/in.h>
 #include <netns/ns.h>
 #include <netinet/in.h>
 #include <netns/ns.h>
+#include <netiso/iso.h>
 
 
+#include <netdb.h>
 #include <stdio.h>
 #include <errno.h>
 #include <ctype.h>
 #include <stdio.h>
 #include <errno.h>
 #include <ctype.h>
-#include <netdb.h>
+#include <paths.h>
+
+struct keytab {
+       char    *kt_cp;
+       int     kt_i;
+} keywords[] = {
+#include "keywords.h"
+{0, 0}
+};
 
 
-struct rtentry route;
+struct ortentry route;
+union  sockunion {
+       struct  sockaddr sa;
+       struct  sockaddr_in sin;
+       struct  sockaddr_ns sns;
+       struct  sockaddr_iso siso;
+       struct  sockaddr_dl sdl;
+} so_dst, so_gate, so_mask, so_genmask, so_ifa, so_ifp, *so_addrs[] =
+{ &so_dst, &so_gate, &so_mask, &so_genmask, &so_ifa, &so_ifp, 0}; 
+typedef union sockunion *sup;
+int    pid, rtm_addrs;
 int    s;
 int    s;
-int    forcehost, forcenet, doflush, nflag, xnsflag;
+int    forcehost, forcenet, doflush, nflag, af, qflag, Cflag, keyword();
+int    iflag, verbose, aflen = sizeof (struct sockaddr_in);
+int    locking, lockrest, debugonly;
 struct sockaddr_in sin = { sizeof(sin), AF_INET };
 struct sockaddr_in sin = { sizeof(sin), AF_INET };
+struct rt_metrics rt_metrics;
+u_long  rtm_inits;
 struct in_addr inet_makeaddr();
 struct in_addr inet_makeaddr();
-char   *malloc(), *vmunix = "/vmunix";
+char   *malloc(), *routename(), *netname();
+extern char *iso_ntoa(), *link_ntoa();
 #define kget(p, d) \
        (lseek(kmem, (off_t)(p), 0), read(kmem, (char *)&(d), sizeof (d)))
 
 #define kget(p, d) \
        (lseek(kmem, (off_t)(p), 0), read(kmem, (char *)&(d), sizeof (d)))
 
+usage(cp)
+char *cp;
+{
+       fprintf(stderr,
+           "usage: route [ -nqCv ]  cmd [[ -<qualifers> ] args ]\n");
+       if (cp) fprintf(stderr, "(botched keyword: %s)\n", cp);
+
+       exit(1);
+}
+
 main(argc, argv)
        int argc;
        char *argv[];
 main(argc, argv)
        int argc;
        char *argv[];
@@ -56,207 +83,125 @@ main(argc, argv)
 
        char *argvp;
        if (argc < 2)
 
        char *argvp;
        if (argc < 2)
-               fprintf(stderr,
-                   "usage: route [ -n ] [ -f ] [ cmd [ net | host ] args ]\n"),
-               exit(1);
-       s = socket(AF_INET, SOCK_RAW, 0);
-       if (s < 0) {
-               perror("route: socket");
-               exit(1);
-       }
+               usage((char *)0);
        argc--, argv++;
        for (; argc >  0 && argv[0][0] == '-'; argc--, argv++) {
                for (argvp = argv[0]++; *argvp; argvp++)
                        switch (*argv[0]) {
        argc--, argv++;
        for (; argc >  0 && argv[0][0] == '-'; argc--, argv++) {
                for (argvp = argv[0]++; *argvp; argvp++)
                        switch (*argv[0]) {
-                       case 'f':
-                               doflush++;
-                               break;
                        case 'n':
                                nflag++;
                                break;
                        case 'n':
                                nflag++;
                                break;
-                       case 'x':
-                               xnsflag++;
+                       case 'q':
+                               qflag++;
                                break;
                                break;
-                       case 'k':
-                               vmunix = *++argv;
-                               argc--;
+                       case 'C':
+                               Cflag++; /* Use old ioctls */
                                break;
                                break;
+                       case 'v':
+                               verbose++;
                        }
        }
                        }
        }
-       if (doflush)
-               flushroutes();
-       if (argc > 0) {
-               if (strcmp(*argv, "add") == 0)
-                       newroute(argc, argv);
-               else if (strcmp(*argv, "delete") == 0)
+       pid = getpid();
+       if (Cflag)
+               s = socket(AF_INET, SOCK_RAW, 0);
+       else
+               s = socket(PF_ROUTE, SOCK_RAW, 0);
+       if (s < 0) {
+               perror("route: socket");
+               exit(1);
+       }
+       if (argc > 0) switch (keyword(*argv)) {
+               case K_ADD:
+               case K_CHANGE:
+               case K_DELETE:
                        newroute(argc, argv);
                        newroute(argc, argv);
-               else if (strcmp(*argv, "change") == 0)
-                       changeroute(argc-1, argv+1);
-               else
-                       fprintf(stderr, "%s: huh?\n", *argv);
+               case K_MONITOR:
+                       monitor();
+               case K_FLUSH:
+                       flushroutes(argc, argv);
        }
        }
+       usage(*argv);
 }
 
 /*
  * Purge all entries in the routing tables not
  * associated with network interfaces.
  */
 }
 
 /*
  * Purge all entries in the routing tables not
  * associated with network interfaces.
  */
-#include <nlist.h>
-
-struct nlist nl[] = {
-#define        N_RTHOST        0
-       { "_rthost" },
-#define        N_RTNET         1
-       { "_rtnet" },
-#define N_RTHASHSIZE   2
-       { "_rthashsize" },
-#define N_RTREE                3
-       { "_radix_node_head" },
-       "",
-};
-
-int kmem;
-flushroutes()
+flushroutes(argc, argv)
+char *argv[];
 {
 {
-       struct mbuf mb;
-       register struct rtentry *rt;
-       register struct mbuf *m;
-       struct mbuf **routehash;
-       int rthashsize, i, doinghost = 1;
-       char *routename(), *netname();
-
-       nlist(vmunix, nl);
-       kmem = open("/dev/kmem", 0);
-       if (kmem < 0) {
-               perror("route: /dev/kmem");
-               exit(1);
-       }
-       if (nl[N_RTREE].n_value)
-               return (treestuff(nl[N_RTREE].n_value));
-       if (nl[N_RTHOST].n_value == 0) {
-               fprintf(stderr,
-                   "route: \"rthost\", symbol not in namelist\n");
-               exit(1);
-       }
-       if (nl[N_RTNET].n_value == 0) {
-               fprintf(stderr,
-                   "route: \"rtnet\", symbol not in namelist\n");
-               exit(1);
-       }
-       if (nl[N_RTHASHSIZE].n_value == 0) {
-               fprintf(stderr,
-                   "route: \"rthashsize\", symbol not in namelist\n");
-               exit(1);
+       int bufsize, needed, seqno, rlen;
+       char *buf, *next, *lim;
+       register struct rt_msghdr *rtm;
+       struct {
+               struct rt_msghdr m_rtm;
+               union {
+                       char u_saddrs[200];
+                       struct sockaddr u_sa;
+               } m_u;
+       } m;
+
+       if (argc > 1) {
+               argv++;
+               if (argc == 2 && **argv == '-') switch (keyword(1 + *argv)) {
+                       case K_INET:    af = AF_INET;   break;
+                       case K_XNS:     af = AF_NS;     break;
+                       case K_LINK:    af = AF_LINK;   break;
+                       case K_ISO: case K_OSI: af = AF_ISO; break;
+                       default: goto bad;
+               } else
+                       bad: usage(*argv);
        }
        }
-       kget(nl[N_RTHASHSIZE].n_value, rthashsize);
-       routehash = (struct mbuf **)malloc(rthashsize*sizeof (struct mbuf *));
-
-       lseek(kmem, nl[N_RTHOST].n_value, 0);
-       read(kmem, routehash, rthashsize*sizeof (struct mbuf *));
-       printf("Flushing routing tables:\n");
-again:
-       for (i = 0; i < rthashsize; i++) {
-               if (routehash[i] == 0)
+       if ((needed = getkerninfo(KINFO_RT_DUMP, 0, 0, 0)) < 0)
+               { perror("route-getkerninfo-estimate"); exit(1);}
+       if ((buf = malloc(needed)) == 0)
+               { printf("out of space\n");; exit(1);}
+       if ((rlen = getkerninfo(KINFO_RT_DUMP, buf, &needed, 0)) < 0)
+               { perror("actual retrieval of routing table"); exit(1);}
+       lim = buf + rlen;
+       for (next = buf; next < lim; next += rtm->rtm_msglen) {
+               rtm = (struct rt_msghdr *)next;
+               if ((rtm->rtm_flags & RTF_GATEWAY) == 0)
                        continue;
                        continue;
-               m = routehash[i];
-               while (m) {
-                       kget(m, mb);
-                       d_rtentry((struct rtentry *)(mb.m_dat), doinghost);
-                       m = mb.m_next;
+               if (af) {
+                       struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
+                       if (sa->sa_family != af)
+                               continue;
                }
                }
-       }
-       if (doinghost) {
-               lseek(kmem, nl[N_RTNET].n_value, 0);
-               read(kmem, routehash, rthashsize*sizeof (struct mbuf *));
-               doinghost = 0;
-               goto again;
-       }
-       close(kmem);
-       free(routehash);
-       return;
-}
-
-treestuff(rtree)
-off_t rtree;
-{
-       struct radix_node_head *rnh, head;
-           
-       for (kget(rtree, rnh); rnh; rnh = head.rnh_next) {
-               kget(rnh, head);
-               if (head.rnh_af) {
-                       printf("\nFlushing routes for protocol family %d:\n",
-                                                               head.rnh_af);
-                       f_tree(head.rnh_treetop);
+               rtm->rtm_type = RTM_DELETE;
+               rtm->rtm_seq = seqno;
+               if ((rlen = write(s, next, rtm->rtm_msglen)) < 0) {
+                       perror("writing to routing socket");
+                       printf("got only %d for rlen\n", rlen);
+                       break;
                }
                }
-       }
-}
-
-/*
- * This is not a simple tree walk
- * because the deleting a leaf may change the value of pointers
- * up the tree from us.
- */
-
-f_tree(rn)
-struct radix_node *rn;
-{
-       struct radix_node rnode, *found;
-       struct nrtentry nrtentry;
-       int doinghost;
-
-       while (find1(rn, &found)) {
-               kget(found, nrtentry);
-               doinghost = nrtentry.nrt_nodes[0].rn_mask ? 0 : 1;
-               d_rtentry(&nrtentry.nrt_rt, doinghost);
-       }
-}
-
-find1(rn, rnp)
-struct radix_node *rn, **rnp;
-{
-       struct radix_node rnode;
-       struct nrtentry nrtentry;
-
-       kget(rn, rnode);
-       if (rnode.rn_b < 0) {
-               if (rnode.rn_dupedkey && find1(rnode.rn_dupedkey, rnp))
-                       return 1;
-               if ((rnode.rn_flags & RNF_ROOT) == 0) {
-                       if ((rnode.rn_flags & RNF_ACTIVE) == 0) {
-                               printf("Dead entry in tree: %x\n", rn);
-                               exit(1);
-                       }
-                       kget(rn, nrtentry);
-                       if (nrtentry.nrt_rt.rt_flags & RTF_GATEWAY) {
-                               *rnp = rn;
-                               return 1;
-                       }
+       again:
+               if ((rlen = read(s, (char *)&m, sizeof (m))) < 0) {
+                       perror("reading from routing socket");
+                       printf("got only %d for rlen\n", rlen);
+                       break;
                }
                }
-       } else {
-               if (rnode.rn_l && find1(rnode.rn_l, rnp))
-                       return 1;
-               if (rnode.rn_r && find1(rnode.rn_r, rnp))
-                       return 1;
-       }
-       return 0;
-}
-
-d_rtentry(rt, doinghost)
-register struct rtentry *rt;
-{
-       if (rt->rt_flags & RTF_GATEWAY) {
-               printf("%-20.20s ", doinghost ?
-                   routename(&rt->rt_dst) :
-                   netname(&rt->rt_dst));
-               printf("%-20.20s ", routename(&rt->rt_gateway));
-               if (ioctl(s, SIOCDELRT, (caddr_t)rt) < 0) {
-                       fflush(stdout);
-                       error("delete");
-               } else
+               if ((m.m_rtm.rtm_pid != pid) || (m.m_rtm.rtm_seq != seqno)) {
+                       printf("Got response for somebody else's request");
+                       goto again;
+               }
+               seqno++;
+               if (qflag)
+                       continue;
+               if (verbose) {
+                       print_rtmsg(rtm, rlen);
+               } else {
+                       struct sockaddr *sa = &m.m_u.u_sa;
+                       printf("%-20.20s ", (rtm->rtm_flags & RTF_HOST) ?
+                           routename(sa) : netname(sa));
+                       sa = (struct sockaddr *)(sa->sa_len + (char *)sa);
+                       printf("%-20.20s ", routename(sa));
                        printf("done\n");
                        printf("done\n");
+               }
        }
        }
+       exit(0);
 }
 }
-
+       
 char *
 routename(sa)
        struct sockaddr *sa;
 char *
 routename(sa)
        struct sockaddr *sa;
@@ -310,11 +255,24 @@ routename(sa)
        case AF_NS:
                return (ns_print((struct sockaddr_ns *)sa));
 
        case AF_NS:
                return (ns_print((struct sockaddr_ns *)sa));
 
+       case AF_LINK:
+               return (link_ntoa((struct sockaddr_dl *)sa));
+
+       case AF_ISO:
+               (void) sprintf(line, "iso %s",
+                   iso_ntoa(&((struct sockaddr_iso *)sa)->siso_addr));
+               break;
+
        default:
            {   u_short *s = (u_short *)sa->sa_data;
        default:
            {   u_short *s = (u_short *)sa->sa_data;
+               u_short *slim = s + ((sa->sa_len + 1)>>1);
+               char *cp = line + sprintf(line, "(%d)", sa->sa_family);
+               int n;
 
 
-               (void)sprintf(line, "af %d: %x %x %x %x %x %x %x",
-                   sa->sa_family, s[0], s[1], s[2], s[3], s[4], s[5], s[6]);
+               while (s < slim) {
+                       n = sprintf(cp, " %x", *s);
+                       s++; cp += n;
+               }
                break;
            }
        }
                break;
            }
        }
@@ -393,71 +351,182 @@ netname(sa)
                return (ns_print((struct sockaddr_ns *)sa));
                break;
 
                return (ns_print((struct sockaddr_ns *)sa));
                break;
 
+       case AF_LINK:
+               return (link_ntoa((struct sockaddr_dl *)sa));
+
+       case AF_ISO:
+               (void) sprintf(line, "iso %s",
+                   iso_ntoa(&((struct sockaddr_iso *)sa)->siso_addr));
+               break;
+
        default:
            {   u_short *s = (u_short *)sa->sa_data;
        default:
            {   u_short *s = (u_short *)sa->sa_data;
+               u_short *slim = s + ((sa->sa_len + 1)>>1);
+               char *cp = line + sprintf(line, "af %d:", sa->sa_family);
+               int n;
 
 
-               (void)sprintf(line, "af %d: %x %x %x %x %x %x %x",
-                   sa->sa_family, s[0], s[1], s[2], s[3], s[4], s[5], s[6]);
+               while (s < slim) {
+                       n = sprintf(cp, " %x", *s);
+                       s++; cp += n;
+               }
                break;
            }
        }
        return (line);
 }
 
                break;
            }
        }
        return (line);
 }
 
+set_metric(value, key)
+char *value;
+{
+       int flag = 0; 
+       u_long noval, *valp = &noval;
+
+       switch (key) {
+#define caseof(x, y, z)        case x: valp = &rt_metrics.z; flag = y; break
+       caseof(K_MTU, RTV_MTU, rmx_mtu);
+       caseof(K_HOPCOUNT, RTV_HOPCOUNT, rmx_hopcount);
+       caseof(K_EXPIRE, RTV_EXPIRE, rmx_expire);
+       caseof(K_RECVPIPE, RTV_RPIPE, rmx_recvpipe);
+       caseof(K_SENDPIPE, RTV_SPIPE, rmx_sendpipe);
+       caseof(K_SSTHRESH, RTV_SSTHRESH, rmx_ssthresh);
+       caseof(K_RTT, RTV_RTT, rmx_rtt);
+       caseof(K_RTTVAR, RTV_RTTVAR, rmx_rttvar);
+       }
+       rtm_inits |= flag;
+       if (lockrest || locking)
+               rt_metrics.rmx_locks |= flag;
+       if (locking)
+               locking = 0;
+       *valp = atoi(value);
+}
+
 newroute(argc, argv)
        int argc;
 newroute(argc, argv)
        int argc;
-       char *argv[];
+       register char **argv;
 {
        struct sockaddr_in *sin;
 {
        struct sockaddr_in *sin;
-       char *cmd, *dest, *gateway;
-       int ishost, metric = 0, ret, attempts, oerrno;
-       struct hostent *hp;
+       char *cmd, *dest, *gateway, *mask;
+       int ishost, metric = 0, ret, attempts, oerrno, flags = 0, next;
+       int key;
+       struct hostent *hp = 0;
        extern int errno;
 
        cmd = argv[0];
        extern int errno;
 
        cmd = argv[0];
-       if ((strcmp(argv[1], "host")) == 0) {
-               forcehost++;
-               argc--, argv++;
-       } else if ((strcmp(argv[1], "net")) == 0) {
-               forcenet++;
-               argc--, argv++;
-       }
-       if (*cmd == 'a') {
-               if (argc != 4) {
-                       printf("usage: %s destination gateway metric\n", cmd);
-                       printf("(metric of 0 if gateway is this host)\n");
-                       return;
-               }
-               metric = atoi(argv[3]);
-       } else {
-               if (argc < 3) {
-                       printf("usage: %s destination gateway\n", cmd);
-                       return;
+       while (--argc > 0) {
+               if (**(++argv)== '-') {
+                       switch(key = keyword(1 + *argv)) {
+                       case K_LINK:
+                               af = AF_LINK;
+                               aflen = sizeof(struct sockaddr_dl);
+                               break;
+                       case K_OSI:
+                       case K_ISO:
+                               af = AF_ISO;
+                               aflen = sizeof(struct sockaddr_iso);
+                               break;
+                       case K_INET:
+                               af = AF_INET;
+                               aflen = sizeof(struct sockaddr_in);
+                               break;
+                       case K_XNS:
+                               af = AF_NS;
+                               aflen = sizeof(struct sockaddr_ns);
+                               break;
+                       case K_IFACE:
+                       case K_INTERFACE:
+                               iflag++;
+                               break;
+                       case K_LOCK:
+                               locking = 1;
+                               break;
+                       case K_LOCKREST:
+                               lockrest = 1;
+                               break;
+                       case K_HOST:
+                               forcehost++;
+                               break;
+                       case K_NETMASK:
+                               argc--;
+                               (void) getaddr(RTA_NETMASK, *++argv, 0);
+                               /* FALLTHROUGH */
+                       case K_NET:
+                               forcenet++;
+                               break;
+                       case K_CLONING:
+                               flags |= RTF_CLONING;
+                               break;
+                       case K_XRESOLVE:
+                               flags |= RTF_XRESOLVE;
+                               break;
+                       case K_GENMASK:
+                               argc--;
+                               (void) getaddr(RTA_GENMASK, *++argv, 0);
+                               break;
+                       case K_MTU:
+                       case K_HOPCOUNT:
+                       case K_EXPIRE:
+                       case K_RECVPIPE:
+                       case K_SENDPIPE:
+                       case K_SSTHRESH:
+                       case K_RTT:
+                       case K_RTTVAR:
+                               argc--;
+                               set_metric(*++argv, key);
+                               break;
+                       default:
+                               usage(1+*argv);
+                       }
+               } else {
+                       if ((rtm_addrs & RTA_DST) == 0) {
+                               dest = *argv;
+                               ishost = getaddr(RTA_DST, *argv, &hp);
+                       } else if ((rtm_addrs & RTA_GATEWAY) == 0) {
+                               gateway = *argv;
+                               (void) getaddr(RTA_GATEWAY, *argv, &hp);
+                       } else {
+                               int ret = atoi(*argv);
+                               if (ret == 0) {
+                                   printf("%s,%s", "old usage of trailing 0",
+                                          "assuming route to if\n");
+                                   iflag = 1;
+                                   continue;
+                               } else if (ret > 0 && ret < 10) {
+                                   printf("old usage of trailing digit, ");
+                                   printf("assuming route via gateway\n");
+                                   iflag = 0;
+                                   continue;
+                               }
+                               (void) getaddr(RTA_NETMASK, *argv, 0);
+                       }
                }
        }
                }
        }
-       sin = (struct sockaddr_in *)&route.rt_dst;
-       ishost = getaddr(argv[1], &route.rt_dst, &hp, &dest, forcenet);
        if (forcehost)
                ishost = 1;
        if (forcenet)
                ishost = 0;
        if (forcehost)
                ishost = 1;
        if (forcenet)
                ishost = 0;
-       sin = (struct sockaddr_in *)&route.rt_gateway;
-       (void) getaddr(argv[2], &route.rt_gateway, &hp, &gateway, 0);
-       route.rt_flags = RTF_UP;
+       flags |= RTF_UP;
        if (ishost)
        if (ishost)
-               route.rt_flags |= RTF_HOST;
-       if (metric > 0)
-               route.rt_flags |= RTF_GATEWAY;
+               flags |= RTF_HOST;
+       if (iflag == 0)
+               flags |= RTF_GATEWAY;
        for (attempts = 1; ; attempts++) {
                errno = 0;
        for (attempts = 1; ; attempts++) {
                errno = 0;
-               if ((ret = ioctl(s, *cmd == 'a' ? SIOCADDRT : SIOCDELRT,
-                    (caddr_t)&route)) == 0)
-                       break;
+               if (Cflag && (af == AF_INET || af == AF_NS)) {
+                       route.rt_flags = flags;
+                       route.rt_dst = so_dst.sa;
+                       route.rt_gateway = so_gate.sa;
+                       if ((ret = ioctl(s, *cmd == 'a' ? SIOCADDRT : SIOCDELRT,
+                            (caddr_t)&route)) == 0)
+                               break;
+               } else {
+                   if ((ret = rtmsg(*cmd, flags)) == 0);
+                               break;
+               }
                if (errno != ENETUNREACH && errno != ESRCH)
                        break;
                if (hp && hp->h_addr_list[1]) {
                        hp->h_addr_list++;
                if (errno != ENETUNREACH && errno != ESRCH)
                        break;
                if (hp && hp->h_addr_list[1]) {
                        hp->h_addr_list++;
-                       bcopy(hp->h_addr_list[0], (caddr_t)&sin->sin_addr,
+                       bcopy(hp->h_addr_list[0], (caddr_t)&so_dst.sin.sin_addr,
                            hp->h_length);
                } else
                        break;
                            hp->h_length);
                } else
                        break;
@@ -474,15 +543,9 @@ newroute(argc, argv)
                printf(": ");
                fflush(stdout);
                errno = oerrno;
                printf(": ");
                fflush(stdout);
                errno = oerrno;
-               error(0);
+               error("");
        }
        }
-}
-
-changeroute(argc, argv)
-       int argc;
-       char *argv[];
-{
-       printf("not supported\n");
+       exit(0);
 }
 
 error(cmd)
 }
 
 error(cmd)
@@ -492,17 +555,20 @@ error(cmd)
 
        switch(errno) {
        case ESRCH:
 
        switch(errno) {
        case ESRCH:
-               fprintf(stderr, "not in table\n");
+               printf("not in table\n");
                break;
        case EBUSY:
                break;
        case EBUSY:
-               fprintf(stderr, "entry in use\n");
+               printf("entry in use\n");
                break;
        case ENOBUFS:
                break;
        case ENOBUFS:
-               fprintf(stderr, "routing table overflow\n");
+               printf("routing table overflow\n");
                break;
        default:
                break;
        default:
+               printf("ioctl returns %d\n", errno);
                perror(cmd);
        }
                perror(cmd);
        }
+       fflush(stdout);
+       errno = 0;
 }
 
 char *
 }
 
 char *
@@ -520,73 +586,152 @@ savestr(s)
        return (sav);
 }
 
        return (sav);
 }
 
+inet_makenetandmask(net, sin)
+u_long net;
+register struct sockaddr_in *sin;
+{
+       u_long addr;
+       u_long mask = 0;
+       register char *cp;
+
+       rtm_addrs |= RTA_NETMASK;
+       if (net == 0)
+               mask = addr = 0;
+       else if (net < 128) {
+               addr = net << IN_CLASSA_NSHIFT;
+               mask = IN_CLASSA_NET;
+       } else if (net < 65536) {
+               addr = net << IN_CLASSB_NSHIFT;
+               mask = IN_CLASSB_NET;
+       } else if (net < 16777216L) {
+               addr = net << IN_CLASSC_NSHIFT;
+               mask = IN_CLASSC_NET;
+       } else {
+               addr = net;
+               if ((addr & IN_CLASSA_HOST) == 0)
+                       mask =  IN_CLASSA_NET;
+               else if ((addr & IN_CLASSB_HOST) == 0)
+                       mask =  IN_CLASSB_NET;
+               else if ((addr & IN_CLASSC_HOST) == 0)
+                       mask =  IN_CLASSC_NET;
+               else
+                       mask = -1;
+       }
+       sin->sin_addr.s_addr = htonl(addr);
+       sin = &so_mask.sin;
+       sin->sin_addr.s_addr = htonl(mask);
+       sin->sin_len = 0;
+       sin->sin_family = 0;
+       cp = (char *)(1 + &(sin->sin_addr));
+       while (*--cp == 0 && cp > (char *)sin)
+               ;
+       sin->sin_len = 1 + cp - (char *)sin;
+}
+
 /*
  * Interpret an argument as a network address of some kind,
  * returning 1 if a host address, 0 if a network address.
  */
 /*
  * Interpret an argument as a network address of some kind,
  * returning 1 if a host address, 0 if a network address.
  */
-getaddr(s, sin, hpp, name, isnet)
+getaddr(which, s, hpp)
        char *s;
        char *s;
-       struct sockaddr_in *sin;
        struct hostent **hpp;
        struct hostent **hpp;
-       char **name;
-       int isnet;
 {
 {
-       struct sockaddr_ns *sns = (struct sockaddr_ns *)sin;
+       register union sockunion *su;
        struct  ns_addr ns_addr();
        struct  ns_addr ns_addr();
+       struct iso_addr *iso_addr();
        struct hostent *hp;
        struct netent *np;
        u_long val;
 
        struct hostent *hp;
        struct netent *np;
        u_long val;
 
-       if (xnsflag)
-               goto do_xns;
-       *hpp = 0;
+       if (af == 0) {
+               af = AF_INET;
+               aflen = sizeof(struct sockaddr_in);
+       }
+       rtm_addrs |= which;
+       switch (which) {
+       case RTA_DST:           su = so_addrs[0]; su->sa.sa_family = af; break;
+       case RTA_GATEWAY:       su = so_addrs[1]; su->sa.sa_family = af; break;
+       case RTA_NETMASK:       su = so_addrs[2]; break;
+       case RTA_GENMASK:       su = so_addrs[3]; break;
+       default:                usage("Internal Error"); /*NOTREACHED*/
+       }
+       su->sa.sa_len = aflen;
        if (strcmp(s, "default") == 0) {
        if (strcmp(s, "default") == 0) {
-               sin->sin_family = AF_INET;
-               sin->sin_addr = inet_makeaddr(0, INADDR_ANY);
-               *name = "default";
-               return(0);
+               switch (which) {
+               case RTA_DST:
+                       forcenet++;
+                       getaddr(RTA_NETMASK, s, 0);
+                       break;
+               case RTA_NETMASK:
+               case RTA_GENMASK:
+                       su->sa.sa_len = 0;
+               }
+               return 0;
        }
        }
-       sin->sin_family = AF_INET;
-       if (isnet == 0) {
-               val = inet_addr(s);
-               if (val != -1) {
-                       sin->sin_addr.s_addr = val;
-                       *name = s;
-                       return(inet_lnaof(sin->sin_addr) != INADDR_ANY);
+       if (af == AF_NS)
+               goto do_xns;
+       if (af == AF_OSI)
+               goto do_osi;
+       if (af == AF_LINK)
+               goto do_link;
+       if (hpp == 0) hpp = &hp;
+       *hpp = 0;
+       if (((val = inet_addr(s)) != -1) &&
+           (which != RTA_DST || forcenet == 0)) {
+               su->sin.sin_addr.s_addr = val;
+               if (inet_lnaof(su->sin.sin_addr) != INADDR_ANY)
+                       return (1);
+               else {
+                       val = ntohl(val);
+               out:    if (which == RTA_DST)
+                               inet_makenetandmask(val, &su->sin);
+                       return (0);
                }
        }
        val = inet_network(s);
        if (val != -1) {
                }
        }
        val = inet_network(s);
        if (val != -1) {
-               sin->sin_addr = inet_makeaddr(val, INADDR_ANY);
-               *name = s;
-               return(0);
+               goto out;
        }
        np = getnetbyname(s);
        if (np) {
        }
        np = getnetbyname(s);
        if (np) {
-               sin->sin_family = np->n_addrtype;
-               sin->sin_addr = inet_makeaddr(np->n_net, INADDR_ANY);
-               *name = savestr(np->n_name);
-               return(0);
+               val = np->n_net;
+               goto out;
        }
        hp = gethostbyname(s);
        if (hp) {
                *hpp = hp;
        }
        hp = gethostbyname(s);
        if (hp) {
                *hpp = hp;
-               sin->sin_family = hp->h_addrtype;
-               bcopy(hp->h_addr, &sin->sin_addr, hp->h_length);
-               *name = savestr(hp->h_name);
-               return(1);
+               su->sin.sin_family = hp->h_addrtype;
+               bcopy(hp->h_addr, &su->sin.sin_addr, hp->h_length);
+               return (1);
        }
        fprintf(stderr, "%s: bad value\n", s);
        exit(1);
 do_xns:
        }
        fprintf(stderr, "%s: bad value\n", s);
        exit(1);
 do_xns:
-       bzero((char *)sns, sizeof (*sns));
-       sns->sns_family = AF_NS;
-       if (strcmp(s, "default") == 0) {
-               *name = "default";
+       if (val == 0)
                return(0);
                return(0);
+       if (which == RTA_DST) {
+               extern short ns_bh[3];
+               struct sockaddr_ns *sms = &(so_mask.sns);
+               bzero((char *)sms, sizeof(*sms));
+               sms->sns_family = 0;
+               sms->sns_len = 6;
+               sms->sns_addr.x_net = *(union ns_net *)ns_bh;
+               rtm_addrs |= RTA_NETMASK;
        }
        }
-       sns->sns_addr = ns_addr(s);
-       return (!ns_nullhost(sns->sns_addr));
+       su->sns.sns_addr = ns_addr(s);
+       return (!ns_nullhost(su->sns.sns_addr));
+do_osi:
+       su->siso.siso_addr = *iso_addr(s);
+       if (which == RTA_NETMASK || which == RTA_GENMASK) {
+               register char *cp = (char *)TSEL(&su->siso);
+               su->siso.siso_nlen = 0;
+               do {--cp ;} while ((cp > (char *)su) && (*cp == 0));
+               su->siso.siso_len = 1 + cp - (char *)su;
+       }
+       return (1);
+do_link:
+       link_addr(s, &su->sdl);
+       return (1);
 }
 
 short ns_nullh[] = {0,0,0};
 }
 
 short ns_nullh[] = {0,0,0};
@@ -647,3 +792,196 @@ char *p0;
                *p += ('A' - 'a');
        }
 }
                *p += ('A' - 'a');
        }
 }
+
+monitor()
+{
+       int n;
+       char msg[2048];
+       verbose = 1;
+       for(;;) {
+               n = read(s, msg, 2048);
+               printf("got message of size %d\n", n);
+               print_rtmsg((struct rt_msghdr *)msg);
+       }
+}
+
+struct {
+       struct  rt_msghdr m_rtm;
+       char m_space[512];
+} m_rtmsg;
+
+rtmsg(cmd, flags)
+{
+       static int seq;
+       int rlen;
+       extern int errno;
+       register char *cp = m_rtmsg.m_space;
+       register int l;
+
+       errno = 0;
+       bzero((char *)&m_rtmsg, sizeof(m_rtmsg));
+       if (cmd == 'a')
+               cmd = RTM_ADD;
+       else if (cmd == 'c')
+               cmd = RTM_CHANGE;
+       else
+               cmd = RTM_DELETE;
+       m_rtmsg.m_rtm.rtm_flags = flags;
+       m_rtmsg.m_rtm.rtm_version = RTM_VERSION;
+       m_rtmsg.m_rtm.rtm_seq = ++seq;
+       m_rtmsg.m_rtm.rtm_addrs = rtm_addrs;
+       m_rtmsg.m_rtm.rtm_rmx = rt_metrics;
+       m_rtmsg.m_rtm.rtm_inits = rtm_inits;
+
+#define ROUND(a) (1 + (((a) - 1) | (sizeof(long) - 1)))
+#define NEXTADDR(w, u) { if (rtm_addrs & (w)) {l = (u).sa.sa_len;\
+       if(verbose)sodump(&(u),"u");if(l == 0) l = sizeof(int); l = ROUND(l);\
+               bcopy((char *)&(u), cp, l); cp += l;}}
+
+       NEXTADDR(RTA_DST, so_dst);
+       NEXTADDR(RTA_GATEWAY, so_gate);
+       NEXTADDR(RTA_NETMASK, so_mask);
+       NEXTADDR(RTA_GENMASK, so_genmask);
+       m_rtmsg.m_rtm.rtm_msglen = l = cp - (char *)&m_rtmsg;
+       m_rtmsg.m_rtm.rtm_type = cmd;
+       if (verbose)
+               print_rtmsg(&m_rtmsg.m_rtm, l);
+       if (debugonly)
+               return 0;
+       if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) {
+               perror("writing to routing socket");
+               printf("got only %d for rlen\n", rlen);
+               return (-1);
+       }
+again:
+       if ((rlen = read(s, (char *)&m_rtmsg, l)) < 0) {
+               perror("reading from routing socket");
+               printf("got only %d for rlen\n", rlen);
+               return (-1);
+       }
+       if ((m_rtmsg.m_rtm.rtm_pid != pid) ||
+           (m_rtmsg.m_rtm.rtm_seq != seq)) {
+               printf("Got response for somebody else's request");
+               goto again;
+       }
+       if (qflag == 0)
+               print_rtmsg( &m_rtmsg.m_rtm, rlen);
+       if ((m_rtmsg.m_rtm.rtm_flags & RTF_DONE) == 0) {
+               errno = m_rtmsg.m_rtm.rtm_errno;
+               perror("response from routing socket turned down");
+               return (-1);
+       }
+       return (0);
+}
+
+char *msgtypes[] = {
+"",
+"RTM_ADD: Add Route",
+"RTM_DELETE: Delete Route",
+"RTM_CHANGE: Change Metrics or flags",
+"RTM_GET: Report Metrics",
+"RTM_LOSING: Kernel Suspects Partitioning",
+"RTM_REDIRECT: Told to use different route",
+"RTM_MISS: Lookup failed on this address",
+"RTM_LOCK: fix specified metrics",
+"RTM_OLDADD: caused by SIOCADDRT",
+"RTM_OLDDEL: caused by SIOCDELRT",
+0, };
+
+char metricnames[] =
+"\010rttvar\7rtt\6ssthresh\5sendpipe\4recvpipe\3expire\2hopcount\1mtu";
+char routeflags[] = 
+"\1UP\2GATEWAY\3HOST\5DYNAMIC\6MODIFIED\7DONE\010MASK_PRESENT\011CLONING\012XRESOLVE";
+
+#define ROUNDUP(a) ((char *)(1 + (((((int)a)) - 1) | (sizeof(long) - 1))))
+
+print_rtmsg(rtm, n)
+register struct rt_msghdr *rtm;
+{
+       char *cp;
+       register struct sockaddr *sa;
+       int i;
+
+       if (verbose == 0)
+               return;
+       if (rtm->rtm_version != RTM_VERSION) {
+           printf("routing message version %d not understood\n",
+                                                       rtm->rtm_version);
+       } else {
+           printf("%s\npid: %d, len %d, seq %d, errno %d, flags:",
+                   msgtypes[rtm->rtm_type], rtm->rtm_pid, rtm->rtm_msglen,
+                   rtm->rtm_seq, rtm->rtm_errno); 
+           bprintf(stdout, rtm->rtm_flags, routeflags);
+           printf("\nlocks: "); bprintf(stdout, rtm->rtm_rmx.rmx_locks, metricnames);
+           printf(" inits: "); bprintf(stdout, rtm->rtm_inits, metricnames);
+           printf("\nsockaddrs: ");
+           bprintf(stdout, rtm->rtm_addrs,
+               "\1DST\2GATEWAY\3NETMASK\4GENMASK\5IFP\6IFA\7AUTHOR");
+           putchar('\n');
+           cp = ((char *)(rtm + 1));
+           if (rtm->rtm_addrs)
+               for (i = 1; i; i <<= 1)
+                   if (i & rtm->rtm_addrs) {
+                           sa = (struct sockaddr *)cp;
+                           printf(" %s", routename(sa));
+                           cp = ROUNDUP(cp + sa->sa_len);
+                   }
+           putchar('\n');
+       }
+       fflush(stdout);
+}
+
+bprintf(fp, b, s)
+register FILE *fp;
+register int b;
+register u_char *s;
+{
+       register int i;
+       int gotsome = 0;
+
+       if (b == 0)
+               return;
+       while (i = *s++) {
+               if (b & (1 << (i-1))) {
+                       if (gotsome == 0) i = '<'; else i = ',';
+                       putc(i, fp);
+                       gotsome = 1;
+                       for (; (i = *s) > 32; s++)
+                               putc(i, fp);
+               } else
+                       while (*s > 32)
+                               s++;
+       }
+       if (gotsome)
+               putc('>', fp);
+}
+int
+keyword(cp)
+char *cp;
+{
+       register struct keytab *kt = keywords;
+       while (kt->kt_cp && strcmp(kt->kt_cp, cp))
+               kt++;
+       return kt->kt_i;
+}
+
+sodump(su, which)
+register union sockunion *su;
+char *which;
+{
+       switch (su->sa.sa_family) {
+       case AF_LINK:
+               printf("%s: link %s; ", which, link_ntoa(&su->sdl));
+               break;
+       case AF_ISO:
+               printf("%s: iso %s; ", which, iso_ntoa(&su->siso.siso_addr));
+               break;
+       case AF_INET:
+               printf("%s: inet %s; ", which, inet_ntoa(su->sin.sin_addr));
+               break;
+       case AF_NS:
+               printf("%s: xns %s; ", which, ns_ntoa(&su->sns.sns_addr));
+               break;
+       }
+       fflush(stdout);
+}