BSD 4_3_Net_2 release

[unix-history] / usr / src / sbin / route / route.c

diff --git a/usr/src/sbin/route/route.c b/usr/src/sbin/route/route.c
index 5d4d8b8..ec040c8 100644 (file)
--- a/usr/src/sbin/route/route.c
+++ b/usr/src/sbin/route/route.c
@@ -2,19 +2,33 @@
  * Copyright (c) 1983, 1989 The Regents of the University of California.
  * All rights reserved.
  *
  * Copyright (c) 1983, 1989 The Regents of the University of California.
  * All rights reserved.
  *

- * Redistribution and use in source and binary forms are permitted provided
- * that: (1) source distributions retain this entire copyright notice and
- * comment, and (2) distributions including binaries display the following
- * acknowledgement:  ``This product includes software developed by the
- * University of California, Berkeley and its contributors'' in the
- * documentation or other materials provided with the distribution and in
- * all advertising materials mentioning features or use of this software.
- * Neither the name of the University nor the names of its contributors may
- * 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
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.

  */
 
 #ifndef lint
  */
 
 #ifndef lint


@@ -24,13 +38,13 @@ char copyright[] =
 #endif /* not lint */
 
 #ifndef lint
 #endif /* not lint */
 
 #ifndef lint

-static char sccsid[] = "@(#)route.c    5.27 (Berkeley) 6/22/90";
+static char sccsid[] = "@(#)route.c    5.35 (Berkeley) 6/27/91";

 #endif /* not lint */
 
 #include <sys/param.h>
 #endif /* not lint */
 
 #include <sys/param.h>

+#include <sys/file.h>

 #include <sys/socket.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>

-#include <sys/file.h>

 #include <sys/mbuf.h>
 #include <sys/kinfo.h>
 
 #include <sys/mbuf.h>
 #include <sys/kinfo.h>
 


@@ -39,11 +53,16 @@ static char sccsid[] = "@(#)route.c 5.27 (Berkeley) 6/22/90";
 #include <netinet/in.h>
 #include <netns/ns.h>
 #include <netiso/iso.h>
 #include <netinet/in.h>
 #include <netns/ns.h>
 #include <netiso/iso.h>

-
+#include <netccitt/x25.h>
+#include <arpa/inet.h>

 #include <netdb.h>
 #include <netdb.h>

-#include <stdio.h>
+

 #include <errno.h>
 #include <errno.h>

+#include <unistd.h>
+#include <stdio.h>

 #include <ctype.h>
 #include <ctype.h>

+#include <stdlib.h>
+#include <string.h>

 #include <paths.h>
 
 struct keytab {
 #include <paths.h>
 
 struct keytab {


@@ -61,148 +80,215 @@ union     sockunion {
        struct  sockaddr_ns sns;
        struct  sockaddr_iso siso;
        struct  sockaddr_dl sdl;
        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}; 
+       struct  sockaddr_x25 sx25;
+} so_dst, so_gate, so_mask, so_genmask, so_ifa, so_ifp;
+
+union sockunion *so_addrs[] =
+       { &so_dst, &so_gate, &so_mask, &so_genmask, &so_ifp, &so_ifa, 0}; 
+

 typedef union sockunion *sup;
 typedef union sockunion *sup;

-int    pid, rtm_addrs;
+int    pid, rtm_addrs, uid;

 int    s;
 int    s;

-int    forcehost, forcenet, doflush, nflag, af, qflag, Cflag, keyword();
+int    forcehost, forcenet, doflush, nflag, af, qflag, tflag, 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();
 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();

-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)))
+char   *routename(), *netname();
+void   flushroutes(), newroute(), monitor(), sockaddr();
+void   print_getmsg(), print_rtmsg(), pmsg_common(), sodump(), bprintf();
+int    getaddr(), rtmsg();
+extern char *inet_ntoa(), *iso_ntoa(), *link_ntoa();

 
 

+void

 usage(cp)
 usage(cp)

-char *cp;
+       char *cp;
+{
+       if (cp)
+               (void) fprintf(stderr, "route: botched keyword: %s\n", cp);
+       (void) fprintf(stderr,
+           "usage: route [ -Cnqv ] cmd [[ -<qualifers> ] args ]\n");
+       exit(1);
+       /* NOTREACHED */
+}
+
+void
+quit(s)
+       char *s;

 {
 {

-       fprintf(stderr,
-           "usage: route [ -nqCv ]  cmd [[ -<qualifers> ] args ]\n");
-       if (cp) fprintf(stderr, "(botched keyword: %s)\n", cp);
+       int sverrno = errno;

 
 

+       (void) fprintf(stderr, "route: ");
+       if (s)
+               (void) fprintf(stderr, "%s: ", s);
+       (void) fprintf(stderr, "%s\n", strerror(sverrno));

        exit(1);
        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))
+

 main(argc, argv)
        int argc;
 main(argc, argv)
        int argc;

-       char *argv[];
+       char **argv;

 {
 {

-
+       extern int optind;
+       int ch;

        char *argvp;
        char *argvp;

+

        if (argc < 2)
        if (argc < 2)

-               usage((char *)0);
-       argc--, argv++;
-       for (; argc >  0 && argv[0][0] == '-'; argc--, argv++) {
-               for (argvp = argv[0]++; *argvp; argvp++)
-                       switch (*argv[0]) {
-                       case 'n':
-                               nflag++;
-                               break;
-                       case 'q':
-                               qflag++;
-                               break;
-                       case 'C':
-                               Cflag++; /* Use old ioctls */
-                               break;
-                       case 'v':
-                               verbose++;
-                       }
-       }
+               usage((char *)NULL);
+
+       while ((ch = getopt(argc, argv, "Cnqtv")) != EOF)
+               switch(ch) {
+               case 'C':
+                       Cflag = 1;      /* Use old ioctls. */
+                       break;
+               case 'n':
+                       nflag = 1;
+                       break;
+               case 'q':
+                       qflag = 1;
+                       break;
+               case 'v':
+                       verbose = 1;
+                       break;
+               case 't':
+                       tflag = 1;
+                       break;
+               case '?':
+               default:
+                       usage();
+               }
+       argc -= optind;
+       argv += optind;
+

        pid = getpid();
        pid = getpid();

-       if (Cflag)
+       uid = getuid();
+       if (tflag)
+               s = open("/dev/null", O_WRONLY, 0);
+       else if (Cflag)

                s = socket(AF_INET, SOCK_RAW, 0);
        else
                s = socket(PF_ROUTE, SOCK_RAW, 0);
                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:
+       if (s < 0)
+               quit("socket");
+       if (*argv)
+               switch (keyword(*argv)) {
+               case K_GET:
+                       uid = 0;
+                       /* FALLTHROUGH */
+

                case K_CHANGE:
                case K_CHANGE:

+                       if (Cflag)
+                               usage("change or get with -C");
+                       /* FALLTHROUGH */
+
+               case K_ADD:

                case K_DELETE:
                        newroute(argc, argv);
                case K_DELETE:
                        newroute(argc, argv);

+                       exit(0);
+                       /* NOTREACHED */
+

                case K_MONITOR:
                        monitor();
                case K_MONITOR:
                        monitor();

+                       /* NOTREACHED */
+

                case K_FLUSH:
                        flushroutes(argc, argv);
                case K_FLUSH:
                        flushroutes(argc, argv);

-       }
+                       exit(0);
+                       /* NOTREACHED */
+               }

        usage(*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.
  */

+void

 flushroutes(argc, argv)
 flushroutes(argc, argv)

-char *argv[];
+       int argc;
+       char *argv[];

 {
 {

-       int bufsize, needed, seqno, rlen;
+       int needed, seqno, rlen;

        char *buf, *next, *lim;
        register struct rt_msghdr *rtm;
        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 (uid)
+               quit("must be root to alter routing table");

        shutdown(s, 0); /* Don't want to read back our messages */
        if (argc > 1) {
                argv++;
        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;
+               if (argc == 2 && **argv == '-')
+                   switch (keyword(*argv + 1)) {
+                       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;
+                       case K_X25:
+                               af = AF_CCITT;
+                       default:
+                               goto bad;

                } else
                } else

-                       bad: usage(*argv);
+bad:                   usage(*argv);

        }
        if ((needed = getkerninfo(KINFO_RT_DUMP, 0, 0, 0)) < 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);}
+               quit("route-getkerninfo-estimate");
+       if ((buf = malloc(needed)) == NULL)
+               quit("malloc");

        if ((rlen = getkerninfo(KINFO_RT_DUMP, buf, &needed, 0)) < 0)
        if ((rlen = getkerninfo(KINFO_RT_DUMP, buf, &needed, 0)) < 0)

-               { perror("actual retrieval of routing table"); exit(1);}
+               quit("actual retrieval of routing table");

        lim = buf + rlen;
        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;
                if (af) {
                        struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
        for (next = buf; next < lim; next += rtm->rtm_msglen) {
                rtm = (struct rt_msghdr *)next;
                if ((rtm->rtm_flags & RTF_GATEWAY) == 0)
                        continue;
                if (af) {
                        struct sockaddr *sa = (struct sockaddr *)(rtm + 1);

+

                        if (sa->sa_family != af)
                                continue;
                }
                rtm->rtm_type = RTM_DELETE;
                rtm->rtm_seq = seqno;
                        if (sa->sa_family != af)
                                continue;
                }
                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);
+               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;
                        break;
                }
                seqno++;
                if (qflag)
                        continue;

-               if (verbose) {
+               if (verbose)

                        print_rtmsg(rtm, rlen);
                        print_rtmsg(rtm, rlen);

-               } else {
-                       struct sockaddr *sa = &m.m_u.u_sa;
-                       printf("%-20.20s ", (rtm->rtm_flags & RTF_HOST) ?
+               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);
                            routename(sa) : netname(sa));
                        sa = (struct sockaddr *)(sa->sa_len + (char *)sa);

-                       printf("%-20.20s ", routename(sa));
-                       printf("done\n");
+                       (void) printf("%-20.20s ", routename(sa));
+                       (void) printf("done\n");

                }
        }
                }
        }

-       exit(0);

 }
        
 char *
 }
        
 char *


@@ -214,7 +300,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) {


@@ -235,7 +320,7 @@ routename(sa)
                if (in.s_addr == INADDR_ANY)
                        cp = "default";
                if (cp == 0 && !nflag) {
                if (in.s_addr == INADDR_ANY)
                        cp = "default";
                if (cp == 0 && !nflag) {

-                       hp = gethostbyaddr(&in, sizeof (struct in_addr),
+                       hp = gethostbyaddr((char *)&in, sizeof (struct in_addr),

                                AF_INET);
                        if (hp) {
                                if ((cp = index(hp->h_name, '.')) &&
                                AF_INET);
                        if (hp) {
                                if ((cp = index(hp->h_name, '.')) &&


@@ -249,7 +334,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);

-                       (void)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;


@@ -268,14 +353,11 @@ routename(sa)
 
        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);
+               u_short *slim = s + ((sa->sa_len + 1) >> 1);

                char *cp = line + sprintf(line, "(%d)", sa->sa_family);
                char *cp = line + sprintf(line, "(%d)", sa->sa_family);

-               int n;

 
 

-               while (s < slim) {
-                       n = sprintf(cp, " %x", *s);
-                       s++; cp += n;
-               }
+               while (s < slim)
+                       cp += sprintf(cp, " %x", *s++);

                break;
            }
        }
                break;
            }
        }


@@ -336,15 +418,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)

-                       (void)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)

-                       (void)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)

-                       (void)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

-                       (void)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;


@@ -366,20 +448,19 @@ netname(sa)
            {   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);
            {   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;

 
 

-               while (s < slim) {
-                       n = sprintf(cp, " %x", *s);
-                       s++; cp += n;
-               }
+               while (s < slim)
+                       cp += sprintf(cp, " %x", *s++);

                break;
            }
        }
        return (line);
 }
 
                break;
            }
        }
        return (line);
 }
 

+void

 set_metric(value, key)
 set_metric(value, key)

-char *value;
+       char *value;
+       int key;

 {
        int flag = 0; 
        u_long noval, *valp = &noval;
 {
        int flag = 0; 
        u_long noval, *valp = &noval;


@@ -403,22 +484,24 @@ char *value;
        *valp = atoi(value);
 }
 
        *valp = atoi(value);
 }
 

+void

 newroute(argc, argv)
        int argc;
        register char **argv;
 {
 newroute(argc, argv)
        int argc;
        register char **argv;
 {

-       struct sockaddr_in *sin;
-       char *cmd, *dest, *gateway, *mask;
-       int ishost, metric = 0, ret, attempts, oerrno, flags = 0, next;
+       char *cmd, *dest = "", *gateway = "", *err;
+       int ishost = 0, ret, attempts, oerrno, flags = 0;

        int key;
        struct hostent *hp = 0;
        int key;
        struct hostent *hp = 0;

-       extern int errno;

 
 

-       shutdown(s, 0); /* Don't want to read back our messages */
+       if (uid)
+               quit("must be root to alter routing table");

        cmd = argv[0];
        cmd = argv[0];

+       if (*cmd != 'g')
+               shutdown(s, 0); /* Don't want to read back our messages */

        while (--argc > 0) {
                if (**(++argv)== '-') {
        while (--argc > 0) {
                if (**(++argv)== '-') {

-                       switch(key = keyword(1 + *argv)) {
+                       switch (key = keyword(1 + *argv)) {

                        case K_LINK:
                                af = AF_LINK;
                                aflen = sizeof(struct sockaddr_dl);
                        case K_LINK:
                                af = AF_LINK;
                                aflen = sizeof(struct sockaddr_dl);


@@ -432,6 +515,14 @@ newroute(argc, argv)
                                af = AF_INET;
                                aflen = sizeof(struct sockaddr_in);
                                break;
                                af = AF_INET;
                                aflen = sizeof(struct sockaddr_in);
                                break;

+                       case K_X25:
+                               af = AF_CCITT;
+                               aflen = sizeof(struct sockaddr_x25);
+                               break;
+                       case K_SA:
+                               af = 0;
+                               aflen = sizeof(union sockunion);
+                               break;

                        case K_XNS:
                                af = AF_NS;
                                aflen = sizeof(struct sockaddr_ns);
                        case K_XNS:
                                af = AF_NS;
                                aflen = sizeof(struct sockaddr_ns);


@@ -449,12 +540,14 @@ newroute(argc, argv)
                        case K_HOST:
                                forcehost++;
                                break;
                        case K_HOST:
                                forcehost++;
                                break;

-                       case K_NETMASK:
-                               argc--;
-                               (void) getaddr(RTA_NETMASK, *++argv, 0);
-                               /* FALLTHROUGH */
-                       case K_NET:
-                               forcenet++;
+                       case K_REJECT:
+                               flags |= RTF_REJECT;
+                               break;
+                       case K_PROTO1:
+                               flags |= RTF_PROTO1;
+                               break;
+                       case K_PROTO2:
+                               flags |= RTF_PROTO2;

                                break;
                        case K_CLONING:
                                flags |= RTF_CLONING;
                                break;
                        case K_CLONING:
                                flags |= RTF_CLONING;


@@ -462,10 +555,34 @@ newroute(argc, argv)
                        case K_XRESOLVE:
                                flags |= RTF_XRESOLVE;
                                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_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_MTU:
                        case K_HOPCOUNT:
                        case K_EXPIRE:


@@ -523,79 +640,53 @@ newroute(argc, argv)
                             (caddr_t)&route)) == 0)
                                break;
                } else {
                             (caddr_t)&route)) == 0)
                                break;
                } else {

-                   if ((ret = rtmsg(*cmd, flags)) == 0);
+                   if ((ret = rtmsg(*cmd, flags)) == 0)

                                break;
                }
                if (errno != ENETUNREACH && errno != ESRCH)
                        break;
                                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++;
                        bcopy(hp->h_addr_list[0], (caddr_t)&so_dst.sin.sin_addr,
                            hp->h_length);
                } else
                        break;
        }
                        hp->h_addr_list++;
                        bcopy(hp->h_addr_list[0], (caddr_t)&so_dst.sin.sin_addr,
                            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("");
-       }
-       exit(0);
-}
-
-error(cmd)
-       char *cmd;
-{
-       extern int errno;
-
-       switch(errno) {
-       case ESRCH:
-               printf("not in table\n");
-               break;
-       case EBUSY:
-               printf("entry in use\n");
-               break;
-       case ENOBUFS:
-               printf("routing table overflow\n");
-               break;
-       default:
-               printf("ioctl returns %d\n", errno);
-               perror(cmd);
-       }
-       fflush(stdout);
-       errno = 0;
-}
-
-char *
-savestr(s)
-       char *s;
-{
-       char *sav;
-
-       sav = malloc(strlen(s) + 1);
-       if (sav == NULL) {
-               fprintf("route: out of memory\n");
-               exit(1);
+               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);

        }
        }

-       strcpy(sav, s);
-       return (sav);

 }
 
 }
 

+void

 inet_makenetandmask(net, sin)
 inet_makenetandmask(net, sin)

-u_long net;
-register struct sockaddr_in *sin;
+       u_long net;
+       register struct sockaddr_in *sin;

 {
 {

-       u_long addr;
-       u_long mask = 0;
+       u_long addr, mask = 0;

        register char *cp;
 
        rtm_addrs |= RTA_NETMASK;
        register char *cp;
 
        rtm_addrs |= RTA_NETMASK;


@@ -626,7 +717,7 @@ register struct sockaddr_in *sin;
        sin->sin_addr.s_addr = htonl(mask);
        sin->sin_len = 0;
        sin->sin_family = 0;
        sin->sin_addr.s_addr = htonl(mask);
        sin->sin_len = 0;
        sin->sin_family = 0;

-       cp = (char *)(1 + &(sin->sin_addr));
+       cp = (char *)(&sin->sin_addr + 1);

        while (*--cp == 0 && cp > (char *)sin)
                ;
        sin->sin_len = 1 + cp - (char *)sin;
        while (*--cp == 0 && cp > (char *)sin)
                ;
        sin->sin_len = 1 + cp - (char *)sin;


@@ -636,12 +727,14 @@ register struct sockaddr_in *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.
  */

+int

 getaddr(which, s, hpp)
 getaddr(which, s, hpp)

+       int which;

        char *s;
        struct hostent **hpp;
 {
        char *s;
        struct hostent **hpp;
 {

-       register union sockunion *su;
-       struct  ns_addr ns_addr();
+       register sup su;
+       struct ns_addr ns_addr();

        struct iso_addr *iso_addr();
        struct hostent *hp;
        struct netent *np;
        struct iso_addr *iso_addr();
        struct hostent *hp;
        struct netent *np;


@@ -657,6 +750,8 @@ getaddr(which, s, hpp)
        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_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;
        default:                usage("Internal Error"); /*NOTREACHED*/
        }
        su->sa.sa_len = aflen;


@@ -664,7 +759,7 @@ getaddr(which, s, hpp)
                switch (which) {
                case RTA_DST:
                        forcenet++;
                switch (which) {
                case RTA_DST:
                        forcenet++;

-                       getaddr(RTA_NETMASK, s, 0);
+                       (void) getaddr(RTA_NETMASK, s, 0);

                        break;
                case RTA_NETMASK:
                case RTA_GENMASK:
                        break;
                case RTA_NETMASK:
                case RTA_GENMASK:


@@ -678,8 +773,13 @@ getaddr(which, s, hpp)
                goto do_osi;
        if (af == AF_LINK)
                goto do_link;
                goto do_osi;
        if (af == AF_LINK)
                goto do_link;

-       if (hpp == 0) hpp = &hp;
-       *hpp = 0;
+       if (af == AF_CCITT)
+               goto do_ccitt;
+       if (af == 0)
+               goto do_sa;
+       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 (((val = inet_addr(s)) != -1) &&
            (which != RTA_DST || forcenet == 0)) {
                su->sin.sin_addr.s_addr = val;


@@ -705,14 +805,12 @@ getaddr(which, s, hpp)
        if (hp) {
                *hpp = hp;
                su->sin.sin_family = hp->h_addrtype;
        if (hp) {
                *hpp = hp;
                su->sin.sin_family = hp->h_addrtype;

-               bcopy(hp->h_addr, &su->sin.sin_addr, hp->h_length);
+               bcopy(hp->h_addr, (char *)&su->sin.sin_addr, hp->h_length);

                return (1);
        }
                return (1);
        }

-       fprintf(stderr, "%s: bad value\n", s);
+       (void) fprintf(stderr, "%s: bad value\n", s);

        exit(1);
 do_xns:
        exit(1);
 do_xns:

-       if (val == 0)
-               return(0);

        if (which == RTA_DST) {
                extern short ns_bh[3];
                struct sockaddr_ns *sms = &(so_mask.sns);
        if (which == RTA_DST) {
                extern short ns_bh[3];
                struct sockaddr_ns *sms = &(so_mask.sns);


@@ -733,9 +831,16 @@ do_osi:
                su->siso.siso_len = 1 + cp - (char *)su;
        }
        return (1);
                su->siso.siso_len = 1 + cp - (char *)su;
        }
        return (1);

+do_ccitt:
+       ccitt_addr(s, &su->sx25);
+       return (1);

 do_link:
        link_addr(s, &su->sdl);
        return (1);
 do_link:
        link_addr(s, &su->sdl);
        return (1);

+do_sa:
+       su->sa.sa_len = sizeof(*su);
+       sockaddr(s, &su->sa);
+       return (1);

 }
 
 short ns_nullh[] = {0,0,0};
 }
 
 short ns_nullh[] = {0,0,0};


@@ -743,184 +848,262 @@ 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 ) {
-                       (void)sprintf(mybuf, "*.%xH", port);
-                       upHex(mybuf);
-               } else
-                       (void)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;

-               (void)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)

-               (void)sprintf(cport, ".%xH", htons(port));
+               (void) sprintf(cport, ".%XH", htons(port));

        else
                *cport = 0;
 
        else
                *cport = 0;
 

-       (void)sprintf(mybuf,"%xH.%s%s", ntohl(net.long_e), host, cport);
-       upHex(mybuf);
-       return(mybuf);
-}
-
-upHex(p0)
-char *p0;
-{
-       register char *p = p0;
-       for (; *p; p++) switch (*p) {
-
-       case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
-               *p += ('A' - 'a');
-       }
+       (void) sprintf(mybuf,"%XH.%s%s", ntohl(net.long_e), host, cport);
+       return (mybuf);

 }
 
 }
 

+void

 monitor()
 {
        int n;
        char msg[2048];
 monitor()
 {
        int n;
        char msg[2048];

+

        verbose = 1;
        for(;;) {
                n = read(s, msg, 2048);
        verbose = 1;
        for(;;) {
                n = read(s, msg, 2048);

-               printf("got message of size %d\n", n);
+               (void) printf("got message of size %d\n", n);

                print_rtmsg((struct rt_msghdr *)msg);
        }
 }
 
 struct {
        struct  rt_msghdr m_rtm;
                print_rtmsg((struct rt_msghdr *)msg);
        }
 }
 
 struct {
        struct  rt_msghdr m_rtm;

-       char m_space[512];
+       char    m_space[512];

 } m_rtmsg;
 
 } m_rtmsg;
 

+int

 rtmsg(cmd, flags)
 rtmsg(cmd, flags)

+       int cmd, flags;

 {
        static int seq;
        int rlen;
 {
        static int seq;
        int rlen;

-       extern int errno;

        register char *cp = m_rtmsg.m_space;
        register int l;
 
        register char *cp = m_rtmsg.m_space;
        register int l;
 

+#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;
        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;
        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;}}
+#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;

 
 

+       if (rtm_addrs & RTA_NETMASK)
+               mask_addr();

        NEXTADDR(RTA_DST, so_dst);
        NEXTADDR(RTA_GATEWAY, so_gate);
        NEXTADDR(RTA_NETMASK, so_mask);
        NEXTADDR(RTA_GENMASK, so_genmask);
        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;
+       NEXTADDR(RTA_IFP, so_ifp);
+       NEXTADDR(RTA_IFA, so_ifa);
+       rtm.rtm_msglen = l = cp - (char *)&m_rtmsg;

        if (verbose)
        if (verbose)

-               print_rtmsg(&m_rtmsg.m_rtm, l);
+               print_rtmsg(&rtm, l);

        if (debugonly)
                return 0;
        if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) {
                perror("writing to routing socket");
        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);
        }
                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);
 }
 
        return (0);
 }
 

+mask_addr() {
+       register char *cp1, *cp2;
+       int olen;
+
+       if ((rtm_addrs & RTA_DST) == 0)
+               return;
+       switch(so_dst.sa.sa_family) {
+       case AF_NS: case AF_INET: case 0:
+               return;
+       case AF_ISO:
+               olen = MIN(so_dst.siso.siso_nlen, so_mask.sa.sa_len - 6);
+       }
+       cp1 = so_mask.sa.sa_len + 1 + (char *)&so_dst;
+       cp2 = so_dst.sa.sa_len + 1 + (char *)&so_dst;
+       while (cp2 > cp1)
+               *--cp2 = 0;
+       cp2 = so_mask.sa.sa_len + 1 + (char *)&so_mask;
+       while (cp1 > so_dst.sa.sa_data)
+               *--cp1 &= *--cp2;
+       switch(so_dst.sa.sa_family) {
+       case AF_ISO:
+               so_dst.siso.siso_nlen = olen;
+       }
+}
+

 char *msgtypes[] = {
 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, };
+       "",
+       "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[] = 
 
 char metricnames[] =
 "\010rttvar\7rtt\6ssthresh\5sendpipe\4recvpipe\3expire\2hopcount\1mtu";
 char routeflags[] = 

-"\1UP\2GATEWAY\3HOST\5DYNAMIC\6MODIFIED\7DONE\010MASK_PRESENT\011CLONING\012XRESOLVE";
+"\1UP\2GATEWAY\3HOST\4REJECT\5DYNAMIC\6MODIFIED\7DONE\010MASK_PRESENT\011CLONING\012XRESOLVE\013LLINFO\017PROTO2\020PROTO1";

 
 

-#define ROUNDUP(a) ((char *)(1 + (((((int)a)) - 1) | (sizeof(long) - 1))))

 
 

-print_rtmsg(rtm, n)
-register struct rt_msghdr *rtm;
+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  ");
+#define metric(f, e)\
+    printf("%s: %d%s", __STRING(f), rtm->rtm_rmx.__CONCAT(rmx_,f), e)
+       metric(recvpipe, ", ");
+       metric(sendpipe, ", ");
+       metric(ssthresh, ", ");
+       metric(rtt, "\n  ");
+       metric(rttvar, ", ");
+       metric(hopcount, ", ");
+       metric(mtu, ", ");
+       metric(expire, "\n");
+#undef metric
+       pmsg_common(rtm);
+}
+
+void
+pmsg_common(rtm)
+       register struct rt_msghdr *rtm;

 {
        char *cp;
        register struct sockaddr *sa;
        int i;
 
 {
        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)
+       (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)
                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);
+                       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)
 bprintf(fp, b, s)

-register FILE *fp;
-register int b;
-register u_char *s;
+       register FILE *fp;
+       register int b;
+       register u_char *s;

 {
        register int i;
        int gotsome = 0;
 {
        register int i;
        int gotsome = 0;


@@ -929,45 +1112,106 @@ register u_char *s;
                return;
        while (i = *s++) {
                if (b & (1 << (i-1))) {
                return;
        while (i = *s++) {
                if (b & (1 << (i-1))) {

-                       if (gotsome == 0) i = '<'; else i = ',';
-                       putc(i, fp);
+                       if (gotsome == 0)
+                               i = '<';
+                       else
+                               i = ',';
+                       (void) putc(i, fp);

                        gotsome = 1;
                        for (; (i = *s) > 32; s++)
                        gotsome = 1;
                        for (; (i = *s) > 32; s++)

-                               putc(i, fp);
+                               (void) putc(i, fp);

                } else
                        while (*s > 32)
                                s++;
        }
        if (gotsome)
                } else
                        while (*s > 32)
                                s++;
        }
        if (gotsome)

-               putc('>', fp);
+               (void) putc('>', fp);

 }
 }

+

 int
 keyword(cp)
 int
 keyword(cp)

-char *cp;
+       char *cp;

 {
        register struct keytab *kt = keywords;
 {
        register struct keytab *kt = keywords;

+

        while (kt->kt_cp && strcmp(kt->kt_cp, cp))
                kt++;
        return kt->kt_i;
 }
 
        while (kt->kt_cp && strcmp(kt->kt_cp, cp))
                kt++;
        return kt->kt_i;
 }
 

+void

 sodump(su, which)
 sodump(su, which)

-register union sockunion *su;
-char *which;
+       register sup su;
+       char *which;

 {
        switch (su->sa.sa_family) {
        case AF_LINK:
 {
        switch (su->sa.sa_family) {
        case AF_LINK:

-               printf("%s: link %s; ", which, link_ntoa(&su->sdl));
+               (void) printf("%s: link %s; ",
+                   which, link_ntoa(&su->sdl));

                break;
        case AF_ISO:
                break;
        case AF_ISO:

-               printf("%s: iso %s; ", which, iso_ntoa(&su->siso.siso_addr));
+               (void) printf("%s: iso %s; ",
+                   which, iso_ntoa(&su->siso.siso_addr));

                break;
        case AF_INET:
                break;
        case AF_INET:

-               printf("%s: inet %s; ", which, inet_ntoa(su->sin.sin_addr));
+               (void) printf("%s: inet %s; ",
+                   which, inet_ntoa(su->sin.sin_addr));

                break;
        case AF_NS:
                break;
        case AF_NS:

-               printf("%s: xns %s; ", which, ns_ntoa(&su->sns.sns_addr));
+               (void) printf("%s: xns %s; ",
+                   which, ns_ntoa(su->sns.sns_addr));

                break;
        }
                break;
        }

-       fflush(stdout);
+       (void) fflush(stdout);
+}
+/* States*/
+#define VIRGIN 0
+#define GOTONE 1
+#define GOTTWO 2
+/* Inputs */
+#define        DIGIT   (4*0)
+#define        END     (4*1)
+#define DELIM  (4*2)
+
+void
+sockaddr(addr, sa)
+register char *addr;
+register struct sockaddr *sa;
+{
+       register char *cp = (char *)sa;
+       int size = sa->sa_len;
+       char *cplim = cp + size;
+       register int byte = 0, state = VIRGIN, new;
+
+       bzero(cp, size);
+       do {
+               if ((*addr >= '0') && (*addr <= '9')) {
+                       new = *addr - '0';
+               } else if ((*addr >= 'a') && (*addr <= 'f')) {
+                       new = *addr - 'a' + 10;
+               } else if ((*addr >= 'A') && (*addr <= 'F')) {
+                       new = *addr - 'A' + 10;
+               } else if (*addr == 0) 
+                       state |= END;
+               else
+                       state |= DELIM;
+               addr++;
+               switch (state /* | INPUT */) {
+               case GOTTWO | DIGIT:
+                       *cp++ = byte; /*FALLTHROUGH*/
+               case VIRGIN | DIGIT:
+                       state = GOTONE; byte = new; continue;
+               case GOTONE | DIGIT:
+                       state = GOTTWO; byte = new + (byte << 4); continue;
+               default: /* | DELIM */
+                       state = VIRGIN; *cp++ = byte; byte = 0; continue;
+               case GOTONE | END:
+               case GOTTWO | END:
+                       *cp++ = byte; /* FALLTHROUGH */
+               case VIRGIN | END:
+                       break;
+               }
+               break;
+       } while (cp < cplim); 
+       sa->sa_len = cp - (char *)sa;

 }
 }