lint; KNF; make gcc -Wall happy
[unix-history] / usr / src / sbin / route / route.c
index 6fc3815..ed1b286 100644 (file)
 /*
 /*
- * Copyright (c) 1983 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+ * Copyright (c) 1983, 1989 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * %sccs.include.redist.c%
  */
 
 #ifndef lint
 char copyright[] =
  */
 
 #ifndef lint
 char copyright[] =
-"@(#) Copyright (c) 1983 Regents of the University of California.\n\
+"@(#) Copyright (c) 1983 The Regents of the University of California.\n\
  All rights reserved.\n";
  All rights reserved.\n";
-#endif not lint
+#endif /* not lint */
 
 #ifndef lint
 
 #ifndef lint
-static char sccsid[] = "@(#)route.c    5.6 (Berkeley) %G%";
-#endif not lint
+static char sccsid[] = "@(#)route.c    5.31 (Berkeley) %G%";
+#endif /* not lint */
 
 #include <sys/param.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
 
 #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/if_dl.h>
 #include <netinet/in.h>
 #include <netns/ns.h>
 #include <netinet/in.h>
 #include <netns/ns.h>
+#include <netiso/iso.h>
 
 
-#include <stdio.h>
+#include <netdb.h>
 #include <errno.h>
 #include <ctype.h>
 #include <errno.h>
 #include <ctype.h>
-#include <netdb.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.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_ifp, &so_ifa, 0}; 
+typedef union sockunion *sup;
+int    pid, rtm_addrs, uid;
 int    s;
 int    s;
-int    forcehost, forcenet, doflush, nflag;
-struct sockaddr_in sin = { AF_INET };
+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 rt_metrics rt_metrics;
+u_long  rtm_inits;
 struct in_addr inet_makeaddr();
 struct in_addr inet_makeaddr();
-char   *malloc();
+char   *routename(), *netname();
+void   flushroutes(), newroute(), monitor();
+void   print_getmsg(), print_rtmsg(), pmsg_common(), sodump(), bprintf();
+int    getaddr(), rtmsg();
+extern char *inet_ntoa(), *iso_ntoa(), *link_ntoa();
 
 
+void
+usage(cp)
+       char *cp;
+{
+       (void) fprintf(stderr,
+           "usage: route [ -nqCv ] cmd [[ -<qualifers> ] args ]\n");
+       if (cp)
+               (void) fprintf(stderr, "(botched keyword: %s)\n", cp);
+       exit(1);
+       /* NOTREACHED */
+}
+
+void
+quit(s)
+       char *s;
+{
+       int sverrno = errno;
+
+       (void) fprintf(stderr, "route: ");
+       if (s)
+               (void) fprintf(stderr, "%s: ", s);
+       (void) fprintf(stderr, "%s\n", strerror(sverrno));
+       exit(1);
+       /* NOTREACHED */
+}
+
+#define ROUNDUP(a) \
+       ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
+#define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
+
+int
 main(argc, argv)
        int argc;
        char *argv[];
 {
 main(argc, argv)
        int argc;
        char *argv[];
 {
+       char *argvp;
 
        if (argc < 2)
 
        if (argc < 2)
-               printf("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 *)NULL);
        argc--, argv++;
        for (; argc >  0 && argv[0][0] == '-'; argc--, argv++) {
        argc--, argv++;
        for (; argc >  0 && argv[0][0] == '-'; argc--, argv++) {
-               for (argv[0]++; *argv[0]; argv[0]++)
+               for (argvp = argv[0]++; *argvp; argvp++)
                        switch (*argv[0]) {
                        switch (*argv[0]) {
-                       case 'f':
-                               doflush++;
-                               break;
                        case 'n':
                                nflag++;
                                break;
                        case 'n':
                                nflag++;
                                break;
+                       case 'q':
+                               qflag++;
+                               break;
+                       case 'C':
+                               Cflag++; /* Use old ioctls */
+                               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();
+       uid = getuid();
+       if (Cflag)
+               s = socket(AF_INET, SOCK_RAW, 0);
+       else
+               s = socket(PF_ROUTE, SOCK_RAW, 0);
+       if (s < 0)
+               quit("socket");
+       if (argc > 0) switch (keyword(*argv)) {
+               case K_GET:
+                       uid = 0;
+                       /* FALLTHROUGH */
+               case K_CHANGE:
+                       if (Cflag)
+                               usage("change or get with -C");
+                       /* FALLTHROUGH */
+               case K_ADD:
+               case K_DELETE:
                        newroute(argc, argv);
                        newroute(argc, argv);
-               else if (strcmp(*argv, "change") == 0)
-                       changeroute(argc-1, argv+1);
-               else
-                       printf("%s: huh?\n", *argv);
+               case K_MONITOR:
+                       monitor();
+               case K_FLUSH:
+                       flushroutes(argc, argv);
        }
        }
+       usage(*argv);
+       /* NOTREACHED */
 }
 
 /*
  * 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" },
-       "",
-};
-
-flushroutes()
+void
+flushroutes(argc, argv)
+       int argc;
+       char *argv[];
 {
 {
-       struct mbuf mb;
-       register struct rtentry *rt;
-       register struct mbuf *m;
-       struct mbuf **routehash;
-       int rthashsize, i, doinghost = 1, kmem;
-       char *routename(), *netname();
-
-       nlist("/vmunix", nl);
-       if (nl[N_RTHOST].n_value == 0) {
-               printf("route: \"rthost\", symbol not in namelist\n");
-               exit(1);
-       }
-       if (nl[N_RTNET].n_value == 0) {
-               printf("route: \"rtnet\", symbol not in namelist\n");
-               exit(1);
-       }
-       if (nl[N_RTHASHSIZE].n_value == 0) {
-               printf("route: \"rthashsize\", symbol not in namelist\n");
-               exit(1);
-       }
-       kmem = open("/dev/kmem", 0);
-       if (kmem < 0) {
-               perror("route: /dev/kmem");
-               exit(1);
-       }
-       lseek(kmem, nl[N_RTHASHSIZE].n_value, 0);
-       read(kmem, &rthashsize, sizeof (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)
+       int needed, seqno, rlen;
+       char *buf, *next, *lim;
+       register struct rt_msghdr *rtm;
+
+       if (uid)
+               usage("must be root to alter routing table");
+       shutdown(s, 0); /* Don't want to read back our messages */
+       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);
+       }
+       if ((needed = getkerninfo(KINFO_RT_DUMP, 0, 0, 0)) < 0)
+               quit("route-getkerninfo-estimate");
+       if ((buf = malloc(needed)) == NULL)
+               quit("malloc");
+       if ((rlen = getkerninfo(KINFO_RT_DUMP, buf, &needed, 0)) < 0)
+               quit("actual retrieval of routing table");
+       lim = buf + rlen;
+       seqno = 0;              /* ??? */
+       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) {
-                       lseek(kmem, m, 0);
-                       read(kmem, &mb, sizeof (mb));
-                       rt = mtod(&mb, struct rtentry *);
-                       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)
-                                       error("delete");
-                               else
-                                       printf("done\n");
-                       }
-                       m = mb.m_next;
+               if (af) {
+                       struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
+                       if (sa->sa_family != af)
+                               continue;
+               }
+               rtm->rtm_type = RTM_DELETE;
+               rtm->rtm_seq = seqno;
+               rlen = write(s, next, rtm->rtm_msglen);
+               if (rlen < (int)rtm->rtm_msglen) {
+                       (void) fprintf(stderr,
+                           "route: write to routing socket: %s\n",
+                           strerror(errno));
+                       (void) printf("got only %d for rlen\n", rlen);
+                       break;
+               }
+               seqno++;
+               if (qflag)
+                       continue;
+               if (verbose)
+                       print_rtmsg(rtm, rlen);
+               else {
+                       struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
+                       (void) printf("%-20.20s ", rtm->rtm_flags & RTF_HOST ?
+                           routename(sa) : netname(sa));
+                       sa = (struct sockaddr *)(sa->sa_len + (char *)sa);
+                       (void) printf("%-20.20s ", routename(sa));
+                       (void) printf("done\n");
                }
        }
                }
        }
-       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);
+       exit(0);
+       /* NOTREACHED */
 }
 }
-
+       
 char *
 routename(sa)
        struct sockaddr *sa;
 char *
 routename(sa)
        struct sockaddr *sa;
@@ -165,7 +234,6 @@ routename(sa)
        struct hostent *hp;
        static char domain[MAXHOSTNAMELEN + 1];
        static int first = 1;
        struct hostent *hp;
        static char domain[MAXHOSTNAMELEN + 1];
        static int first = 1;
-       char *index();
        char *ns_print();
 
        if (first) {
        char *ns_print();
 
        if (first) {
@@ -200,7 +268,7 @@ routename(sa)
                else {
 #define C(x)   ((x) & 0xff)
                        in.s_addr = ntohl(in.s_addr);
                else {
 #define C(x)   ((x) & 0xff)
                        in.s_addr = ntohl(in.s_addr);
-                       sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24),
+                       (void) sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24),
                           C(in.s_addr >> 16), C(in.s_addr >> 8), C(in.s_addr));
                }
                break;
                           C(in.s_addr >> 16), C(in.s_addr >> 8), C(in.s_addr));
                }
                break;
@@ -209,11 +277,21 @@ 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);
 
 
-               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)
+                       cp += sprintf(cp, " %x", *s++);
                break;
            }
        }
                break;
            }
        }
@@ -232,8 +310,9 @@ netname(sa)
        static char line[50];
        struct netent *np = 0;
        u_long net, mask;
        static char line[50];
        struct netent *np = 0;
        u_long net, mask;
-       register i;
+       register u_long i;
        int subnetshift;
        int subnetshift;
+       char *ns_print();
 
        switch (sa->sa_family) {
 
 
        switch (sa->sa_family) {
 
@@ -241,7 +320,7 @@ netname(sa)
            {   struct in_addr in;
                in = ((struct sockaddr_in *)sa)->sin_addr;
 
            {   struct in_addr in;
                in = ((struct sockaddr_in *)sa)->sin_addr;
 
-               in.s_addr = ntohl(in.s_addr);
+               i = in.s_addr = ntohl(in.s_addr);
                if (in.s_addr == 0)
                        cp = "default";
                else if (!nflag) {
                if (in.s_addr == 0)
                        cp = "default";
                else if (!nflag) {
@@ -273,15 +352,15 @@ netname(sa)
                if (cp)
                        strcpy(line, cp);
                else if ((in.s_addr & 0xffffff) == 0)
                if (cp)
                        strcpy(line, cp);
                else if ((in.s_addr & 0xffffff) == 0)
-                       sprintf(line, "%u", C(in.s_addr >> 24));
+                       (void) sprintf(line, "%u", C(in.s_addr >> 24));
                else if ((in.s_addr & 0xffff) == 0)
                else if ((in.s_addr & 0xffff) == 0)
-                       sprintf(line, "%u.%u", C(in.s_addr >> 24),
+                       (void) sprintf(line, "%u.%u", C(in.s_addr >> 24),
                            C(in.s_addr >> 16));
                else if ((in.s_addr & 0xff) == 0)
                            C(in.s_addr >> 16));
                else if ((in.s_addr & 0xff) == 0)
-                       sprintf(line, "%u.%u.%u", C(in.s_addr >> 24),
+                       (void) sprintf(line, "%u.%u.%u", C(in.s_addr >> 24),
                            C(in.s_addr >> 16), C(in.s_addr >> 8));
                else
                            C(in.s_addr >> 16), C(in.s_addr >> 8));
                else
-                       sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24),
+                       (void) sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24),
                            C(in.s_addr >> 16), C(in.s_addr >> 8),
                            C(in.s_addr));
                break;
                            C(in.s_addr >> 16), C(in.s_addr >> 8),
                            C(in.s_addr));
                break;
@@ -291,181 +370,388 @@ 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);
 
 
-               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)
+                       cp += sprintf(cp, " %x", *s++);
                break;
            }
        }
        return (line);
 }
 
                break;
            }
        }
        return (line);
 }
 
+void
+set_metric(value, key)
+       char *value;
+       int key;
+{
+       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);
+}
+
+void
 newroute(argc, argv)
        int argc;
 newroute(argc, argv)
        int argc;
-       char *argv[];
+       register char **argv;
 {
 {
-       struct sockaddr_in *sin;
-       char *cmd, *dest, *gateway;
-       int ishost, metric = 0, ret, attempts, oerrno;
-       struct hostent *hp;
-       extern int errno;
+       char *cmd, *dest = "", *gateway = "", *err;
+       int ishost = 0, ret, attempts, oerrno, flags = 0;
+       int key;
+       struct hostent *hp = 0;
 
 
+       if (uid)
+               usage("must be root to alter routing table");
        cmd = argv[0];
        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;
+       if (*cmd != 'g')
+               shutdown(s, 0); /* Don't want to read back our messages */
+       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_REJECT:
+                               flags |= RTF_REJECT;
+                               break;
+                       case K_CLONING:
+                               flags |= RTF_CLONING;
+                               break;
+                       case K_XRESOLVE:
+                               flags |= RTF_XRESOLVE;
+                               break;
+                       case K_IFA:
+                               argc--;
+                               (void) getaddr(RTA_IFA, *++argv, 0);
+                               break;
+                       case K_IFP:
+                               argc--;
+                               (void) getaddr(RTA_IFP, *++argv, 0);
+                               break;
+                       case K_GENMASK:
+                               argc--;
+                               (void) getaddr(RTA_GENMASK, *++argv, 0);
+                               break;
+                       case K_GATEWAY:
+                               argc--;
+                               (void) getaddr(RTA_GATEWAY, *++argv, 0);
+                               break;
+                       case K_DST:
+                               argc--;
+                               ishost = getaddr(RTA_DST, *++argv, &hp);
+                               dest = *argv;
+                               break;
+                       case K_NETMASK:
+                               argc--;
+                               (void) getaddr(RTA_NETMASK, *++argv, 0);
+                               /* FALLTHROUGH */
+                       case K_NET:
+                               forcenet++;
+                               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 (errno != ENETUNREACH && errno != ESRCH)
                        break;
-               if (hp && hp->h_addr_list[1]) {
+               if (af == AF_INET && hp && hp->h_addr_list[1]) {
                        hp->h_addr_list++;
                        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;
        }
+       if (*cmd == 'g')
+               exit(0);
        oerrno = errno;
        oerrno = errno;
-       printf("%s %s %s: gateway %s", cmd, ishost? "host" : "net",
+       (void) printf("%s %s %s: gateway %s", cmd, ishost? "host" : "net",
                dest, gateway);
        if (attempts > 1 && ret == 0)
                dest, gateway);
        if (attempts > 1 && ret == 0)
-           printf(" (%s)",
+           (void) printf(" (%s)",
                inet_ntoa(((struct sockaddr_in *)&route.rt_gateway)->sin_addr));
        if (ret == 0)
                inet_ntoa(((struct sockaddr_in *)&route.rt_gateway)->sin_addr));
        if (ret == 0)
-               printf("\n");
+               (void) printf("\n");
        else {
        else {
-               printf(": ");
-               fflush(stdout);
-               errno = oerrno;
-               error(0);
+               switch (oerrno) {
+               case ESRCH:
+                       err = "not in table";
+                       break;
+               case EBUSY:
+                       err = "entry in use";
+                       break;
+               case ENOBUFS:
+                       err = "routing table overflow";
+                       break;
+               default:
+                       err = strerror(oerrno);
+                       break;
+               }
+               (void) printf(": %s\n", err);
        }
        }
+       exit(0);
+       /* NOTREACHED */
 }
 
 }
 
-changeroute(argc, argv)
-       int argc;
-       char *argv[];
+void
+inet_makenetandmask(net, sin)
+       u_long net;
+       register struct sockaddr_in *sin;
 {
 {
-       printf("not supported\n");
-}
-
-error(cmd)
-       char *cmd;
-{
-
-       if (errno == ESRCH)
-               fprintf(stderr, "not in table\n");
-       else if (errno == EBUSY)
-               fprintf(stderr, "entry in use\n");
-       else if (errno == ENOBUFS)
-               fprintf(stderr, "routing table overflow\n");
-       else
-               perror(cmd);
-}
-
-char *
-savestr(s)
-       char *s;
-{
-       char *sav;
+       u_long addr, mask = 0;
+       register char *cp;
 
 
-       sav = malloc(strlen(s) + 1);
-       if (sav == NULL) {
-               fprintf("route: out of memory\n");
-               exit(1);
+       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;
        }
        }
-       strcpy(sav, s);
-       return (sav);
+       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 *)(&sin->sin_addr + 1);
+       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)
+int
+getaddr(which, s, hpp)
+       int which;
        char *s;
        char *s;
-       struct sockaddr_in *sin;
        struct hostent **hpp;
        struct hostent **hpp;
-       char **name;
-       int isnet;
 {
 {
+       register sup su;
+       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;
 
-       *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;
+       case RTA_IFP:           su = so_addrs[4]; su->sa.sa_family = af; break;
+       case RTA_IFA:           su = so_addrs[5]; su->sa.sa_family = af; 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);
-       }
-       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);
+               switch (which) {
+               case RTA_DST:
+                       forcenet++;
+                       (void) getaddr(RTA_NETMASK, s, 0);
+                       break;
+               case RTA_NETMASK:
+               case RTA_GENMASK:
+                       su->sa.sa_len = 0;
+               }
+               return 0;
+       }
+       if (af == AF_NS)
+               goto do_xns;
+       if (af == AF_OSI)
+               goto do_osi;
+       if (af == AF_LINK)
+               goto do_link;
+       if (hpp == NULL)
+               hpp = &hp;
+       *hpp = NULL;
+       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, (char *)&su->sin.sin_addr, hp->h_length);
+               return (1);
        }
        }
-       fprintf(stderr, "%s: bad value\n", s);
+       (void) fprintf(stderr, "%s: bad value\n", s);
        exit(1);
        exit(1);
+do_xns:
+       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;
+       }
+       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};
@@ -473,56 +759,291 @@ short ns_bh[] = {-1,-1,-1};
 
 char *
 ns_print(sns)
 
 char *
 ns_print(sns)
-struct sockaddr_ns *sns;
+       struct sockaddr_ns *sns;
 {
        struct ns_addr work;
        union { union ns_net net_e; u_long long_e; } net;
        u_short port;
        static char mybuf[50], cport[10], chost[25];
        char *host = "";
 {
        struct ns_addr work;
        union { union ns_net net_e; u_long long_e; } net;
        u_short port;
        static char mybuf[50], cport[10], chost[25];
        char *host = "";
-       register char *p; register u_char *q; u_char *q_lim;
+       register char *p;
+       register u_char *q;
 
        work = sns->sns_addr;
        port = ntohs(work.x_port);
        work.x_port = 0;
        net.net_e  = work.x_net;
        if (ns_nullhost(work) && net.long_e == 0) {
 
        work = sns->sns_addr;
        port = ntohs(work.x_port);
        work.x_port = 0;
        net.net_e  = work.x_net;
        if (ns_nullhost(work) && net.long_e == 0) {
-               if (port ) {
-                       sprintf(mybuf, "*.%xH", port);
-                       upHex(mybuf);
-               } else
-                       sprintf(mybuf, "*.*");
+               if (!port)
+                       return ("*.*");
+               (void) sprintf(mybuf, "*.%XH", port);
                return (mybuf);
        }
 
                return (mybuf);
        }
 
-       if (bcmp(ns_bh, work.x_host.c_host, 6) == 0) { 
+       if (bcmp((char *)ns_bh, (char *)work.x_host.c_host, 6) == 0) 
                host = "any";
                host = "any";
-       } else if (bcmp(ns_nullh, work.x_host.c_host, 6) == 0) {
+       else if (bcmp((char *)ns_nullh, (char *)work.x_host.c_host, 6) == 0)
                host = "*";
                host = "*";
-       else {
+       else {
                q = work.x_host.c_host;
                q = work.x_host.c_host;
-               sprintf(chost, "%02x%02x%02x%02x%02x%02xH",
+               (void) sprintf(chost, "%02X%02X%02X%02X%02X%02XH",
                        q[0], q[1], q[2], q[3], q[4], q[5]);
                        q[0], q[1], q[2], q[3], q[4], q[5]);
-               for (p = chost; *p == '0' && p < chost + 12; p++);
+               for (p = chost; *p == '0' && p < chost + 12; p++)
+                       /* void */;
                host = p;
        }
        if (port)
                host = p;
        }
        if (port)
-               sprintf(cport, ".%xH", htons(port));
+               (void) sprintf(cport, ".%XH", htons(port));
        else
                *cport = 0;
 
        else
                *cport = 0;
 
-       sprintf(mybuf,"%xH.%s%s", ntohl(net.long_e), host, cport);
-       upHex(mybuf);
-       return(mybuf);
+       (void) sprintf(mybuf,"%XH.%s%s", ntohl(net.long_e), host, cport);
+       return (mybuf);
+}
+
+void
+monitor()
+{
+       int n;
+       char msg[2048];
+
+       verbose = 1;
+       for(;;) {
+               n = read(s, msg, 2048);
+               (void) printf("got message of size %d\n", n);
+               print_rtmsg((struct rt_msghdr *)msg);
+       }
 }
 
 }
 
-upHex(p0)
-char *p0;
+struct {
+       struct  rt_msghdr m_rtm;
+       char    m_space[512];
+} m_rtmsg;
+
+int
+rtmsg(cmd, flags)
+       int cmd, flags;
 {
 {
-       register char *p = p0;
-       for (; *p; p++) switch (*p) {
+       static int seq;
+       int rlen;
+       register char *cp = m_rtmsg.m_space;
+       register int l;
 
 
-       case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
-               *p += ('A' - 'a');
+#define NEXTADDR(w, u) \
+       if (rtm_addrs & (w)) {\
+           l = ROUNDUP(u.sa.sa_len); bcopy((char *)&(u), cp, l); cp += l;\
+           if (verbose) sodump(&(u),"u");\
+       }
+
+       errno = 0;
+       bzero((char *)&m_rtmsg, sizeof(m_rtmsg));
+       if (cmd == 'a')
+               cmd = RTM_ADD;
+       else if (cmd == 'c')
+               cmd = RTM_CHANGE;
+       else if (cmd == 'g')
+               cmd = RTM_GET;
+       else
+               cmd = RTM_DELETE;
+#define rtm m_rtmsg.m_rtm
+       rtm.rtm_type = cmd;
+       rtm.rtm_flags = flags;
+       rtm.rtm_version = RTM_VERSION;
+       rtm.rtm_seq = ++seq;
+       rtm.rtm_addrs = rtm_addrs;
+       rtm.rtm_rmx = rt_metrics;
+       rtm.rtm_inits = rtm_inits;
+
+       NEXTADDR(RTA_DST, so_dst);
+       NEXTADDR(RTA_GATEWAY, so_gate);
+       NEXTADDR(RTA_NETMASK, so_mask);
+       NEXTADDR(RTA_GENMASK, so_genmask);
+       NEXTADDR(RTA_IFP, so_ifp);
+       NEXTADDR(RTA_IFA, so_ifa);
+       rtm.rtm_msglen = l = cp - (char *)&m_rtmsg;
+       if (verbose)
+               print_rtmsg(&rtm, l);
+       if (debugonly)
+               return 0;
+       if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) {
+               perror("writing to routing socket");
+               return (-1);
+       }
+       if (cmd == RTM_GET) {
+               do {
+                       l = read(s, (char *)&m_rtmsg, sizeof(m_rtmsg));
+               } while (l > 0 && (rtm.rtm_seq != seq || rtm.rtm_pid != pid));
+               if (l < 0)
+                       (void) fprintf(stderr,
+                           "route: read from routing socket: %s\n",
+                           strerror(errno));
+               else
+                       print_getmsg(&rtm, l);
+       }
+#undef rtm
+       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\4REJECT\5DYNAMIC\6MODIFIED\7DONE\010MASK_PRESENT\011CLONING\012XRESOLVE";
+
+
+void
+print_rtmsg(rtm, msglen)
+       register struct rt_msghdr *rtm;
+       int msglen;
+{
+       if (verbose == 0)
+               return;
+       if (rtm->rtm_version != RTM_VERSION) {
+               (void) printf("routing message version %d not understood\n",
+                   rtm->rtm_version);
+               return;
+       }
+       (void) 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);
+       pmsg_common(rtm);
+}
+
+void
+print_getmsg(rtm, msglen)
+       register struct rt_msghdr *rtm;
+       int msglen;
+{
+       if (rtm->rtm_version != RTM_VERSION) {
+               (void)printf("routing message version %d not understood\n",
+                   rtm->rtm_version);
+               return;
+       }
+       if (rtm->rtm_msglen > msglen) {
+               (void)printf("get length mismatch, in packet %d, returned %d\n",
+                   rtm->rtm_msglen, msglen);
+       }
+       (void) printf("RTM_GET: errno %d, flags:", rtm->rtm_errno); 
+       bprintf(stdout, rtm->rtm_flags, routeflags);
+       (void) printf("\nmetric values:\n\n");
+#define metric(f, e) printf("\t%s:\t%d\n", "f", rtm->rtm_rmx.e)
+       metric(RTV_RPIPE, rmx_recvpipe);
+       metric(RTV_SPIPE, rmx_sendpipe);
+       metric(RTV_SSTHRESH, rmx_ssthresh);
+       metric(RTV_RTT, rmx_rtt);
+       metric(RTV_RTTVAR, rmx_rttvar);
+       metric(RTV_HOPCOUNT, rmx_hopcount);
+       metric(RTV_MTU, rmx_mtu);
+       metric(RTV_EXPIRE, rmx_expire);
+#undef metric
+       pmsg_common(rtm);
+}
+
+void
+pmsg_common(rtm)
+       register struct rt_msghdr *rtm;
+{
+       char *cp;
+       register struct sockaddr *sa;
+       int i;
+
+       (void) printf("\nlocks: ");
+       bprintf(stdout, rtm->rtm_rmx.rmx_locks, metricnames);
+       (void) printf(" inits: ");
+       bprintf(stdout, rtm->rtm_inits, metricnames);
+       (void) printf("\nsockaddrs: ");
+       bprintf(stdout, rtm->rtm_addrs,
+           "\1DST\2GATEWAY\3NETMASK\4GENMASK\5IFP\6IFA\7AUTHOR");
+       (void) 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;
+                               (void) printf(" %s", routename(sa));
+                               ADVANCE(cp, sa);
+                       }
+       (void) putchar('\n');
+       (void) fflush(stdout);
+}
+
+void
+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 = ',';
+                       (void) putc(i, fp);
+                       gotsome = 1;
+                       for (; (i = *s) > 32; s++)
+                               (void) putc(i, fp);
+               } else
+                       while (*s > 32)
+                               s++;
+       }
+       if (gotsome)
+               (void) 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;
+}
+
+void
+sodump(su, which)
+       register sup su;
+       char *which;
+{
+       switch (su->sa.sa_family) {
+       case AF_LINK:
+               (void) printf("%s: link %s; ",
+                   which, link_ntoa(&su->sdl));
+               break;
+       case AF_ISO:
+               (void) printf("%s: iso %s; ",
+                   which, iso_ntoa(&su->siso.siso_addr));
+               break;
+       case AF_INET:
+               (void) printf("%s: inet %s; ",
+                   which, inet_ntoa(su->sin.sin_addr));
+               break;
+       case AF_NS:
+               (void) printf("%s: xns %s; ",
+                   which, ns_ntoa(su->sns.sns_addr));
+               break;
        }
        }
+       (void) fflush(stdout);
 }
 }