BSD 4_4 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..a0196c4 100644 (file)
--- a/usr/src/sbin/route/route.c
+++ b/usr/src/sbin/route/route.c
@@ -1,49 +1,70 @@
 /*
 /*

- * 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.
+ * Copyright (c) 1983, 1989, 1991, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * 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

-char copyright[] =
-"@(#) Copyright (c) 1983 The Regents of the University of California.\n\
- All rights reserved.\n";
+static char copyright[] =
+"@(#) Copyright (c) 1983, 1989, 1991, 1993\n\
+       The Regents of the University of California.  All rights reserved.\n";

 #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    8.1 (Berkeley) 6/5/93";

 #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/mbuf.h>

-#include <sys/kinfo.h>
+#include <sys/sysctl.h>

 
 

+#include <net/if.h>

 #include <net/route.h>
 #include <net/if_dl.h>
 #include <netinet/in.h>
 #include <netns/ns.h>
 #include <netiso/iso.h>
 #include <net/route.h>
 #include <net/if_dl.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 {


@@ -51,7 +72,7 @@ struct keytab {
        int     kt_i;
 } keywords[] = {
 #include "keywords.h"
        int     kt_i;
 } keywords[] = {
 #include "keywords.h"

-{0, 0}
+       {0, 0}

 };
 
 struct ortentry route;
 };
 
 struct ortentry route;


@@ -61,148 +82,218 @@ 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;
+

 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, keyword();

 int    iflag, verbose, aflen = sizeof (struct sockaddr_in);
 int    locking, lockrest, debugonly;
 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 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(), sodump(), bprintf();
+void   print_getmsg(), print_rtmsg(), pmsg_common(), pmsg_addrs();
+int    getaddr(), rtmsg(), x25_makemask();
+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 [ -nqv ] 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, "nqdtv")) != EOF)
+               switch(ch) {
+               case 'n':
+                       nflag = 1;
+                       break;
+               case 'q':
+                       qflag = 1;
+                       break;
+               case 'v':
+                       verbose = 1;
+                       break;
+               case 't':
+                       tflag = 1;
+                       break;
+               case 'd':
+                       debugonly = 1;
+                       break;
+               case '?':
+               default:
+                       usage((char *)NULL);
+               }
+       argc -= optind;
+       argv += optind;
+

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

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

        else
                s = socket(PF_ROUTE, 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:

+               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;
+       size_t needed;
+       int mib[6], rlen, seqno;

        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);
-       }
-       if ((needed = getkerninfo(KINFO_RT_DUMP, 0, 0, 0)) < 0)
-               { perror("route-getkerninfo-estimate"); exit(1);}
-       if ((buf = malloc(needed)) == 0)
-               { printf("out of space\n");; exit(1);}
-       if ((rlen = getkerninfo(KINFO_RT_DUMP, buf, &needed, 0)) < 0)
-               { perror("actual retrieval of routing table"); exit(1);}
-       lim = buf + rlen;
+bad:                   usage(*argv);
+       }
+       mib[0] = CTL_NET;
+       mib[1] = PF_ROUTE;
+       mib[2] = 0;             /* protocol */
+       mib[3] = 0;             /* wildcard address family */
+       mib[4] = NET_RT_DUMP;
+       mib[5] = 0;             /* no flags */
+       if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
+               quit("route-sysctl-estimate");
+       if ((buf = malloc(needed)) == NULL)
+               quit("malloc");
+       if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0)
+               quit("actual retrieval of routing table");
+       lim = buf + needed;
+       if (verbose)
+               (void) printf("Examining routing table from sysctl\n");
+       seqno = 0;              /* ??? */

        for (next = buf; next < lim; next += rtm->rtm_msglen) {
                rtm = (struct rt_msghdr *)next;
        for (next = buf; next < lim; next += rtm->rtm_msglen) {
                rtm = (struct rt_msghdr *)next;

+               if (verbose)
+                       print_rtmsg(rtm, rtm->rtm_msglen);

                if ((rtm->rtm_flags & RTF_GATEWAY) == 0)
                        continue;
                if (af) {
                        struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
                if ((rtm->rtm_flags & RTF_GATEWAY) == 0)
                        continue;
                if (af) {
                        struct sockaddr *sa = (struct sockaddr *)(rtm + 1);

+

                        if (sa->sa_family != af)
                                continue;
                }
                        if (sa->sa_family != af)
                                continue;
                }

+               if (debugonly)
+                       continue;

                rtm->rtm_type = RTM_DELETE;
                rtm->rtm_seq = seqno;
                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 +305,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) {


@@ -225,17 +315,20 @@ routename(sa)
                else
                        domain[0] = 0;
        }
                else
                        domain[0] = 0;
        }

-       switch (sa->sa_family) {
+
+       if (sa->sa_len == 0)
+               strcpy(line, "default");
+       else switch (sa->sa_family) {

 
        case AF_INET:
            {   struct in_addr in;
                in = ((struct sockaddr_in *)sa)->sin_addr;
 
                cp = 0;
 
        case AF_INET:
            {   struct in_addr in;
                in = ((struct sockaddr_in *)sa)->sin_addr;
 
                cp = 0;

-               if (in.s_addr == INADDR_ANY)
+               if (in.s_addr == INADDR_ANY || sa->sa_len < 4)

                        cp = "default";
                if (cp == 0 && !nflag) {
                        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 +342,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;


@@ -267,15 +360,12 @@ routename(sa)
                break;
 
        default:
                break;
 
        default:

-           {   u_short *s = (u_short *)sa->sa_data;
-               u_short *slim = s + ((sa->sa_len + 1)>>1);
+           {   u_short *s = (u_short *)sa;
+               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) /* start with sa->sa_data */
+                       cp += sprintf(cp, " %x", *s);

                break;
            }
        }
                break;
            }
        }


@@ -336,15 +426,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 +456,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 +492,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 = RTF_STATIC;

        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 +523,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 = PF_ROUTE;
+                               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);


@@ -439,6 +538,8 @@ newroute(argc, argv)
                        case K_IFACE:
                        case K_INTERFACE:
                                iflag++;
                        case K_IFACE:
                        case K_INTERFACE:
                                iflag++;

+                       case K_NOSTATIC:
+                               flags &= ~RTF_STATIC;

                                break;
                        case K_LOCK:
                                locking = 1;
                                break;
                        case K_LOCK:
                                locking = 1;


@@ -449,12 +550,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 +565,37 @@ newroute(argc, argv)
                        case K_XRESOLVE:
                                flags |= RTF_XRESOLVE;
                                break;
                        case K_XRESOLVE:
                                flags |= RTF_XRESOLVE;
                                break;

+                       case K_STATIC:
+                               flags |= RTF_STATIC;
+                               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:


@@ -489,9 +619,14 @@ newroute(argc, argv)
                                (void) getaddr(RTA_GATEWAY, *argv, &hp);
                        } else {
                                int ret = atoi(*argv);
                                (void) getaddr(RTA_GATEWAY, *argv, &hp);
                        } else {
                                int ret = atoi(*argv);

+

                                if (ret == 0) {
                                if (ret == 0) {

-                                   printf("%s,%s", "old usage of trailing 0",
-                                          "assuming route to if\n");
+                                   if (strcmp(*argv, "0") == 0)
+                                       printf("%s,%s",
+                                           "old usage of trailing 0",
+                                           "assuming route to if\n");
+                                   else
+                                       usage((char *)NULL);

                                    iflag = 1;
                                    continue;
                                } else if (ret > 0 && ret < 10) {
                                    iflag = 1;
                                    continue;
                                } else if (ret > 0 && ret < 10) {


@@ -515,87 +650,54 @@ newroute(argc, argv)
                flags |= RTF_GATEWAY;
        for (attempts = 1; ; attempts++) {
                errno = 0;
                flags |= RTF_GATEWAY;
        for (attempts = 1; ; attempts++) {
                errno = 0;

-               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 ((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 && *gateway && hp && hp->h_addr_list[1]) {

                        hp->h_addr_list++;
                        hp->h_addr_list++;

-                       bcopy(hp->h_addr_list[0], (caddr_t)&so_dst.sin.sin_addr,
+                       bcopy(hp->h_addr_list[0], &so_gate.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",
-               dest, gateway);
-       if (attempts > 1 && ret == 0)
-           printf(" (%s)",
-               inet_ntoa(((struct sockaddr_in *)&route.rt_gateway)->sin_addr));
+       (void) printf("%s %s %s", cmd, ishost? "host" : "net", dest);
+       if (*gateway) {
+               (void) printf(": gateway %s", gateway);
+               if (attempts > 1 && ret == 0 && af == AF_INET)
+                   (void) printf(" (%s)",
+                       inet_ntoa(((struct sockaddr_in *)&route.rt_gateway)->sin_addr));
+       }

        if (ret == 0)
        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 +728,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 +738,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;


@@ -653,33 +757,90 @@ getaddr(which, s, hpp)
        }
        rtm_addrs |= which;
        switch (which) {
        }
        rtm_addrs |= which;
        switch (which) {

-       case RTA_DST:           su = so_addrs[0]; su->sa.sa_family = af; break;
-       case RTA_GATEWAY:       su = so_addrs[1]; su->sa.sa_family = af; break;
-       case RTA_NETMASK:       su = so_addrs[2]; break;
-       case RTA_GENMASK:       su = so_addrs[3]; break;
-       default:                usage("Internal Error"); /*NOTREACHED*/
+       case RTA_DST:
+               su = &so_dst;
+               su->sa.sa_family = af;
+               break;
+       case RTA_GATEWAY:
+               su = &so_gate;
+               su->sa.sa_family = af;
+               break;
+       case RTA_NETMASK:
+               su = &so_mask;
+               break;
+       case RTA_GENMASK:
+               su = &so_genmask;
+               break;
+       case RTA_IFP:
+               su = &so_ifp;
+               su->sa.sa_family = af;
+               break;
+       case RTA_IFA:
+               su = &so_ifa;
+               su->sa.sa_family = af;
+               break;
+       default:
+               usage("Internal Error");
+               /*NOTREACHED*/

        }
        su->sa.sa_len = aflen;
        if (strcmp(s, "default") == 0) {
                switch (which) {
                case RTA_DST:
                        forcenet++;
        }
        su->sa.sa_len = aflen;
        if (strcmp(s, "default") == 0) {
                switch (which) {
                case RTA_DST:
                        forcenet++;

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

                        break;
                case RTA_NETMASK:
                case RTA_GENMASK:
                        su->sa.sa_len = 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 == 0) hpp = &hp;
-       *hpp = 0;
+               return (0);
+       }
+       switch (af) {
+       case AF_NS:
+               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));
+
+       case AF_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);
+
+       case AF_LINK:
+               link_addr(s, &su->sdl);
+               return (1);
+
+       case AF_CCITT:
+               ccitt_addr(s, &su->sx25);
+               return (which == RTA_DST ? x25_makemask() : 1);
+
+       case PF_ROUTE:
+               su->sa.sa_len = sizeof(*su);
+               sockaddr(s, &su->sa);
+               return (1);
+
+       case AF_INET:
+       default:
+               break;
+       }
+
+       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;


@@ -687,55 +848,39 @@ getaddr(which, s, hpp)
                        return (1);
                else {
                        val = ntohl(val);
                        return (1);
                else {
                        val = ntohl(val);

-               out:    if (which == RTA_DST)
-                               inet_makenetandmask(val, &su->sin);
-                       return (0);
+                       goto netdone;

                }
        }
                }
        }

-       val = inet_network(s);
-       if (val != -1) {
-               goto out;
-       }
-       np = getnetbyname(s);
-       if (np) {
-               val = np->n_net;
-               goto out;
+       if ((val = inet_network(s)) != -1 ||
+           ((np = getnetbyname(s)) != NULL && (val = np->n_net) != 0)) {
+netdone:
+               if (which == RTA_DST)
+                       inet_makenetandmask(val, &su->sin);
+               return (0);

        }
        hp = gethostbyname(s);
        if (hp) {
                *hpp = hp;
                su->sin.sin_family = hp->h_addrtype;
        }
        hp = gethostbyname(s);
        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);
        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);
-               bzero((char *)sms, sizeof(*sms));
-               sms->sns_family = 0;
-               sms->sns_len = 6;
-               sms->sns_addr.x_net = *(union ns_net *)ns_bh;
+}
+
+x25_makemask()
+{
+       register char *cp;
+
+       if ((rtm_addrs & RTA_NETMASK) == 0) {

                rtm_addrs |= RTA_NETMASK;
                rtm_addrs |= RTA_NETMASK;

+               for (cp = (char *)&so_mask.sx25.x25_net;
+                    cp < &so_mask.sx25.x25_opts.op_flags; cp++)
+                       *cp = -1;
+               so_mask.sx25.x25_len = (u_char)&(((sup)0)->sx25.x25_opts);

        }
        }

-       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);
+       return 0;

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


@@ -743,184 +888,409 @@ 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);
+       (void) sprintf(mybuf,"%XH.%s%s", ntohl(net.long_e), host, cport);
+       return (mybuf);

 }
 
 }
 

-upHex(p0)
-char *p0;
+void
+interfaces()

 {
 {

-       register char *p = p0;
-       for (; *p; p++) switch (*p) {
+       size_t needed;
+       int mib[6], af;
+       char *buf, *lim, *next;
+       register struct rt_msghdr *rtm;

 
 

-       case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
-               *p += ('A' - 'a');
+       mib[0] = CTL_NET;
+       mib[1] = PF_ROUTE;
+       mib[2] = 0;             /* protocol */
+       mib[3] = 0;             /* wildcard address family */
+       mib[4] = NET_RT_IFLIST;
+       mib[5] = 0;             /* no flags */
+       if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
+               quit("route-sysctl-estimate");
+       if ((buf = malloc(needed)) == NULL)
+               quit("malloc");
+       if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0)
+               quit("actual retrieval of interface table");
+       lim = buf + needed;
+       for (next = buf; next < lim; next += rtm->rtm_msglen) {
+               rtm = (struct rt_msghdr *)next;
+               print_rtmsg(rtm, rtm->rtm_msglen);

        }
 }
 
        }
 }
 

+void

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

+

        verbose = 1;
        verbose = 1;

+       if (debugonly) {
+               interfaces();
+               exit(0);
+       }

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

-               printf("got message of size %d\n", n);
-               print_rtmsg((struct rt_msghdr *)msg);
+               (void) printf("got message of size %d\n", n);
+               print_rtmsg((struct rt_msghdr *)msg, n);

        }
 }
 
 struct {
        struct  rt_msghdr m_rtm;
        }
 }
 
 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
+       else if (cmd == 'g') {
+               cmd = RTM_GET;
+               if (so_ifp.sa.sa_family == 0) {
+                       so_ifp.sa.sa_family == AF_LINK;
+                       so_ifp.sa.sa_len == sizeof(struct sockaddr_dl);
+                       rtm_addrs |= RTA_IFP;
+               }
+       } else

                cmd = RTM_DELETE;
                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)
        if (debugonly)

-               return 0;
+               return (0);

        if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) {
                perror("writing to routing socket");
        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()
+{
+       int olen = so_mask.sa.sa_len;
+       register char *cp1 = olen + (char *)&so_mask, *cp2;
+
+       for (so_mask.sa.sa_len = 0; cp1 > (char *)&so_mask; )
+               if (*--cp1 != 0) {
+                       so_mask.sa.sa_len = 1 + cp1 - (char *)&so_mask;
+                       break;
+               }
+       if ((rtm_addrs & RTA_DST) == 0)
+               return;
+       switch (so_dst.sa.sa_family) {
+       case AF_NS:
+       case AF_INET:
+       case AF_CCITT:
+       case 0:
+               return;
+       case AF_ISO:
+               olen = MIN(so_dst.siso.siso_nlen,
+                          MAX(so_mask.sa.sa_len - 6, 0));
+               break;
+       }
+       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;
+               break;
+       }
+}
+

 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",
+       "RTM_RESOLVE: Route created by cloning",
+       "RTM_NEWADDR: address being added to iface",
+       "RTM_DELADDR: address being removed from iface",
+       "RTM_IFINFO: iface status change",
+       0,
+};

 
 char metricnames[] =
 
 char metricnames[] =

-"\010rttvar\7rtt\6ssthresh\5sendpipe\4recvpipe\3expire\2hopcount\1mtu";
+"\011pksent\010rttvar\7rtt\6ssthresh\5sendpipe\4recvpipe\3expire\2hopcount\1mtu";

 char routeflags[] = 
 char routeflags[] = 

-"\1UP\2GATEWAY\3HOST\5DYNAMIC\6MODIFIED\7DONE\010MASK_PRESENT\011CLONING\012XRESOLVE";
+"\1UP\2GATEWAY\3HOST\4REJECT\5DYNAMIC\6MODIFIED\7DONE\010MASK_PRESENT\011CLONING\012XRESOLVE\013LLINFO\014STATIC\017PROTO2\020PROTO1";
+char ifnetflags[] = 
+"\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5PTP\6NOTRAILERS\7RUNNING\010NOARP\011PPROMISC\012ALLMULTI\013OACTIVE\014SIMPLEX\015LINK0\016LINK1\017LINK2\020MULTICAST";
+char addrnames[] =
+"\1DST\2GATEWAY\3NETMASK\4GENMASK\5IFP\6IFA\7AUTHOR\010BRD";

 
 

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

 {
 {

-       char *cp;
-       register struct sockaddr *sa;
-       int i;
+       struct if_msghdr *ifm;
+       struct ifa_msghdr *ifam;

 
        if (verbose == 0)
                return;
        if (rtm->rtm_version != RTM_VERSION) {
 
        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("routing message version %d not understood\n",
+                   rtm->rtm_version);
+               return;
+       }
+       (void)printf("%s: len %d, ", msgtypes[rtm->rtm_type], rtm->rtm_msglen);
+       switch (rtm->rtm_type) {
+       case RTM_IFINFO:
+               ifm = (struct if_msghdr *)rtm;
+               (void) printf("if# %d, flags:", ifm->ifm_index);
+               bprintf(stdout, ifm->ifm_flags, ifnetflags);
+               pmsg_addrs((char *)(ifm + 1), ifm->ifm_addrs);
+               break;
+       case RTM_NEWADDR:
+       case RTM_DELADDR:
+               ifam = (struct ifa_msghdr *)rtm;
+               (void) printf("metric %d, flags:", ifam->ifam_metric);
+               bprintf(stdout, ifam->ifam_flags, routeflags);
+               pmsg_addrs((char *)(ifam + 1), ifam->ifam_addrs);
+               break;
+       default:
+               (void) printf("pid: %d, seq %d, errno %d, flags:",
+                       rtm->rtm_pid, 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;
+{
+       struct sockaddr *dst = NULL, *gate = NULL, *mask = NULL;
+       struct sockaddr_dl *ifp = NULL;
+       register struct sockaddr *sa;
+       register char *cp;
+       register int i;
+
+       (void) printf("   route to: %s\n", routename(&so_dst));
+       if (rtm->rtm_version != RTM_VERSION) {
+               (void)fprintf(stderr,
+                   "routing message version %d not understood\n",
+                   rtm->rtm_version);
+               return;
+       }
+       if (rtm->rtm_msglen > msglen) {
+               (void)fprintf(stderr,
+                   "message length mismatch, in packet %d, returned %d\n",
+                   rtm->rtm_msglen, msglen);
+       }
+       if (rtm->rtm_errno)  {
+               (void) fprintf(stderr, "RTM_GET: %s (errno %d)\n",
+                   strerror(rtm->rtm_errno), rtm->rtm_errno);
+               return;
+       }
+       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;
+                               switch (i) {
+                               case RTA_DST:
+                                       dst = sa;
+                                       break;
+                               case RTA_GATEWAY:
+                                       gate = sa;
+                                       break;
+                               case RTA_NETMASK:
+                                       mask = sa;
+                                       break;
+                               case RTA_IFP:
+                                       if (sa->sa_family == AF_LINK &&
+                                          ((struct sockaddr_dl *)sa)->sdl_nlen)
+                                               ifp = (struct sockaddr_dl *)sa;
+                                       break;
+                               }
+                               ADVANCE(cp, sa);
+                       }
+       if (dst && mask)
+               mask->sa_family = dst->sa_family;       /* XXX */
+       if (dst)
+               (void)printf("destination: %s\n", routename(dst));
+       if (mask) {
+               int savenflag = nflag;
+
+               nflag = 1;
+               (void)printf("       mask: %s\n", routename(mask));
+               nflag = savenflag;
+       }
+       if (gate && rtm->rtm_flags & RTF_GATEWAY)
+               (void)printf("    gateway: %s\n", routename(gate));
+       if (ifp)
+               (void)printf("  interface: %.*s\n",
+                   ifp->sdl_nlen, ifp->sdl_data);
+       (void)printf("      flags: ");
+       bprintf(stdout, rtm->rtm_flags, routeflags);
+
+#define lock(f)        ((rtm->rtm_rmx.rmx_locks & __CONCAT(RTV_,f)) ? 'L' : ' ')
+#define msec(u)        (((u) + 500) / 1000)            /* usec to msec */
+
+       (void) printf("\n%s\n", "\
+ recvpipe  sendpipe  ssthresh  rtt,msec    rttvar  hopcount      mtu     expire");
+       printf("%8d%c ", rtm->rtm_rmx.rmx_recvpipe, lock(RPIPE));
+       printf("%8d%c ", rtm->rtm_rmx.rmx_sendpipe, lock(SPIPE));
+       printf("%8d%c ", rtm->rtm_rmx.rmx_ssthresh, lock(SSTHRESH));
+       printf("%8d%c ", msec(rtm->rtm_rmx.rmx_rtt), lock(RTT));
+       printf("%8d%c ", msec(rtm->rtm_rmx.rmx_rttvar), lock(RTTVAR));
+       printf("%8d%c ", rtm->rtm_rmx.rmx_hopcount, lock(HOPCOUNT));
+       printf("%8d%c ", rtm->rtm_rmx.rmx_mtu, lock(MTU));
+       if (rtm->rtm_rmx.rmx_expire)
+               rtm->rtm_rmx.rmx_expire -= time(0);
+       printf("%8d%c\n", rtm->rtm_rmx.rmx_expire, lock(EXPIRE));
+#undef lock
+#undef msec
+#define        RTA_IGN (RTA_DST|RTA_GATEWAY|RTA_NETMASK|RTA_IFP|RTA_IFA|RTA_BRD)
+       if (verbose)
+               pmsg_common(rtm);
+       else if (rtm->rtm_addrs &~ RTA_IGN) {
+               (void) printf("sockaddrs: ");
+               bprintf(stdout, rtm->rtm_addrs, addrnames);
+               putchar('\n');
+       }
+#undef RTA_IGN
+}
+
+void
+pmsg_common(rtm)
+       register struct rt_msghdr *rtm;
+{
+       (void) printf("\nlocks: ");
+       bprintf(stdout, rtm->rtm_rmx.rmx_locks, metricnames);
+       (void) printf(" inits: ");
+       bprintf(stdout, rtm->rtm_inits, metricnames);
+       pmsg_addrs(((char *)(rtm + 1)), rtm->rtm_addrs);

 }
 
 }
 

+void
+pmsg_addrs(cp, addrs)
+       char    *cp;
+       int     addrs;
+{
+       register struct sockaddr *sa;
+       int i;
+        
+       if (addrs == 0)
+               return;
+       (void) printf("\nsockaddrs: ");
+       bprintf(stdout, addrs, addrnames);
+       (void) putchar('\n');
+       for (i = 1; i; i <<= 1)
+               if (i & 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 +1299,108 @@ 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);
+       cp++;
+       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;

 }
 }