usr/src/cmd/cmd-inet/usr.sbin/in.routed/rtquery.c

   1 /*
   2  * Copyright 2001-2003 Sun Microsystems, Inc.  All rights reserved.
   3  * Use is subject to license terms.
   4  *
   5  * Copyright (c) 1982, 1986, 1993
   6  *      The Regents of the University of California.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgment:
  18  *      This product includes software developed by the University of
  19  *      California, Berkeley and its contributors.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  * $FreeBSD: src/sbin/routed/rtquery/rtquery.c,v 1.14 2000/08/11 08:24:39
  37  * sheldonh Exp $
  38  * char copyright[] = "@(#) Copyright (c) 1982, 1986, 1993\n"
  39  * "The Regents of the University of California.  All rights reserved.\n";
  40  */
  41
  42 #pragma ident   "%Z%%M% %I%     %E% SMI"
  43
  44 #include "defs.h"
  45 #include <sys/types.h>
  46 #include <sys/param.h>
  47 #include <sys/protosw.h>
  48 #include <sys/socket.h>
  49 #include <sys/time.h>
  50 #include <netinet/in.h>
  51 #define RIPVERSION RIPv2
  52 #include <protocols/routed.h>
  53 #include <arpa/inet.h>
  54 #include <netdb.h>
  55 #include <errno.h>
  56 #include <unistd.h>
  57 #include <stdio.h>
  58 #include <stdlib.h>
  59 #include <string.h>
  60 #include <md5.h>
  61 #include <libintl.h>
  62 #include <locale.h>
  63 #include <net/if.h>
  64 #include <netinet/udp.h>
  65
  66 #ident "$Revision: 1.12 $"
  67
  68 #define WTIME   15              /* Time to wait for all responses */
  69 #define STIME   (250*1000)      /* usec to wait for another response */
  70
  71 /*
  72  * The size of the control buffer passed to recvmsg() used to receive
  73  * ancillary data.
  74  */
  75 #define CONTROL_BUFSIZE 1024
  76
  77 static  const char *pgmname;
  78
  79 static  union {
  80         struct rip rip;
  81         char    packet[MAXPACKETSIZE+MAXPATHLEN];
  82 } omsg_buf;
  83 #define OMSG omsg_buf.rip
  84 static int omsg_len = sizeof (struct rip);
  85
  86 static  union {
  87         struct  rip rip;
  88         char    packet[MAXPACKETSIZE+1024];
  89 } imsg_buf;
  90 #define IMSG imsg_buf.rip
  91
  92 static  int     wtime = WTIME;
  93 static  int     auth_type = RIP_AUTH_NONE;
  94 char    passwd[RIP_AUTH_PW_LEN+1];
  95 static  ulong_t keyid;
  96 static  boolean_t       ripv2 = _B_TRUE;                /* use RIP version 2 */
  97 static  boolean_t       trace, not_trace;       /* send trace command or not */
  98 static  boolean_t       nflag;                  /* numbers, no names */
  99 static  boolean_t       pflag;                  /* play the `gated` game */
 100 static  boolean_t       rflag;          /* 1=ask about a particular route */
 101
 102 static  struct timeval sent;                    /* when query sent */
 103
 104 static char *default_argv[] = {"localhost", 0};
 105
 106 static void rip_input(struct sockaddr_in *, int, uint_t);
 107 static int out(const char *, int);
 108 static void trace_loop(char *argv[], int);
 109 static void query_loop(char *argv[], int, int);
 110 static uint_t incoming_interface(struct msghdr *);
 111 static void usage(void);
 112
 113
 114 int
 115 main(int argc, char *argv[])
 116 {
 117 #define MAX_RCVBUF 127*1024
 118 #define MIN_RCVBUF  4*1024
 119
 120         int ch, bsize, soc;
 121         char *p, *tmp_ptr, *options, *value, delim;
 122         const char *result;
 123         in_addr_t netaddr, netmask;
 124         int on;
 125
 126         (void) setlocale(LC_ALL, "");
 127 #if     !defined(TEXT_DOMAIN)   /* Should be defined by cc -D */
 128 #define TEXT_DOMAIN     "SYS_TEXT"
 129 #endif  /* ! TEXT_DOMAIN */
 130
 131         (void) textdomain(TEXT_DOMAIN);
 132
 133         OMSG.rip_nets[0].n_dst = RIP_DEFAULT;
 134         OMSG.rip_nets[0].n_family = RIP_AF_UNSPEC;
 135         OMSG.rip_nets[0].n_metric = htonl(HOPCNT_INFINITY);
 136
 137         if ((pgmname = argv[0]) == NULL)
 138                 pgmname = "rtquery";
 139         while ((ch = getopt(argc, argv, "np1w:r:t:a:")) != -1)
 140                 switch (ch) {
 141                 case 'n':
 142                         not_trace = _B_TRUE;
 143                         nflag = _B_TRUE;
 144                         break;
 145
 146                 case 'p':
 147                         not_trace = _B_TRUE;
 148                         pflag = _B_TRUE;
 149                         break;
 150
 151                 case '1':
 152                         ripv2 = _B_FALSE;
 153                         break;
 154
 155                 case 'w':
 156                         not_trace = _B_TRUE;
 157                         wtime = (int)strtoul(optarg, &p, 0);
 158                         if (*p != '\0' || wtime <= 0 || p == optarg)
 159                                 usage();
 160                         break;
 161
 162                 case 'r':
 163                         not_trace = _B_TRUE;
 164                         if (rflag)
 165                                 usage();
 166                         rflag = getnet(optarg, &netaddr, &netmask);
 167                         if (rflag) {
 168                                 OMSG.rip_nets[0].n_dst = htonl(netaddr);
 169                                 OMSG.rip_nets[0].n_family = RIP_AF_INET;
 170                                 OMSG.rip_nets[0].n_mask = htonl(netmask);
 171                         } else {
 172                                 struct hostent *hp = gethostbyname(optarg);
 173                                 if (hp == NULL) {
 174                                         (void) fprintf(stderr, "%s: %s: %s\n",
 175                                             pgmname, optarg,
 176                                             hstrerror(h_errno));
 177                                         exit(EXIT_FAILURE);
 178                                 }
 179                                 (void) memcpy(&OMSG.rip_nets[0].n_dst,
 180                                     hp->h_addr,
 181                                     sizeof (OMSG.rip_nets[0].n_dst));
 182                                 OMSG.rip_nets[0].n_family = RIP_AF_INET;
 183                                 OMSG.rip_nets[0].n_mask = INADDR_BROADCAST;
 184                                 rflag = _B_TRUE;
 185                         }
 186                         break;
 187
 188                 case 't':
 189                         trace = _B_TRUE;
 190                         options = optarg;
 191                         while (*options != '\0') {
 192                                 /* messy complications to make -W -Wall happy */
 193                                 static char on_str[] = "on";
 194                                 static char more_str[] = "more";
 195                                 static char off_str[] = "off";
 196                                 static char dump_str[] = "dump";
 197                                 static char *traceopts[] = {
 198 #define TRACE_ON        0
 199                                         on_str,
 200 #define TRACE_MORE      1
 201                                         more_str,
 202 #define TRACE_OFF       2
 203                                         off_str,
 204 #define TRACE_DUMP      3
 205                                         dump_str,
 206                                         0
 207                                 };
 208                                 result = "";
 209                                 switch (getsubopt(&options, traceopts,
 210                                     &value)) {
 211                                 case TRACE_ON:
 212                                         OMSG.rip_cmd = RIPCMD_TRACEON;
 213                                         if (value == NULL ||
 214                                             strlen(value) > MAXPATHLEN)
 215                                             usage();
 216                                         result = value;
 217                                         break;
 218                                 case TRACE_MORE:
 219                                         if (value != NULL)
 220                                             usage();
 221                                         OMSG.rip_cmd = RIPCMD_TRACEON;
 222                                         break;
 223                                 case TRACE_OFF:
 224                                         if (value != NULL)
 225                                             usage();
 226                                         OMSG.rip_cmd = RIPCMD_TRACEOFF;
 227                                         break;
 228                                 case TRACE_DUMP:
 229                                         if (value != NULL)
 230                                             usage();
 231                                         OMSG.rip_cmd = RIPCMD_TRACEON;
 232                                         result = "dump/../table";
 233                                         break;
 234                                 default:
 235                                         usage();
 236                                 }
 237                                 (void) strlcpy((char *)OMSG.rip_tracefile,
 238                                     result, MAXPATHLEN);
 239                                 omsg_len += strlen(result) -
 240                                     sizeof (OMSG.ripun);
 241                         }
 242                         break;
 243
 244                 case 'a':
 245                         not_trace = _B_TRUE;
 246                         p = strchr(optarg, '=');
 247                         if (p == NULL)
 248                                 usage();
 249                         *p++ = '\0';
 250                         if (0 == strcasecmp("passwd", optarg))
 251                                 auth_type = RIP_AUTH_PW;
 252                         else if (0 == strcasecmp("md5_passwd", optarg))
 253                                 auth_type = RIP_AUTH_MD5;
 254                         else
 255                                 usage();
 256                         if (0 > parse_quote(&p, "|", &delim,
 257                             passwd, sizeof (passwd)))
 258                                 usage();
 259                         if (auth_type == RIP_AUTH_MD5 &&
 260                             delim == '|') {
 261                                 tmp_ptr = p+1;
 262                                 keyid = strtoul(p+1, &p, 0);
 263                                 if (keyid > 255 || *p != '\0' ||
 264                                     p == tmp_ptr)
 265                                         usage();
 266                         } else if (delim != '\0') {
 267                                 usage();
 268                         }
 269                         break;
 270
 271                 default:
 272                         usage();
 273         }
 274         argv += optind;
 275         argc -= optind;
 276         if (not_trace && trace)
 277                 usage();
 278         if (argc == 0) {
 279                 argc = 1;
 280                 argv = default_argv;
 281         }
 282
 283         soc = socket(PF_INET, SOCK_DGRAM, 0);
 284         if (soc < 0) {
 285                 perror("rtquery: socket");
 286                 exit(EXIT_FAILURE);
 287         }
 288
 289         on = 1;
 290         if (setsockopt(soc, IPPROTO_IP, IP_RECVIF, &on, sizeof (on)))
 291                 perror("rtquery: setsockopt IP_RECVIF");
 292
 293         /* be prepared to receive a lot of routes */
 294         for (bsize = MAX_RCVBUF; ; bsize -= 1024) {
 295                 if (setsockopt(soc, SOL_SOCKET, SO_RCVBUF,
 296                     &bsize, sizeof (bsize)) == 0)
 297                         break;
 298                 if (bsize <= MIN_RCVBUF) {
 299                         perror("rtquery: setsockopt SO_RCVBUF");
 300                         break;
 301                 }
 302         }
 303
 304         if (trace)
 305                 trace_loop(argv, soc);
 306         else
 307                 query_loop(argv, argc, soc);
 308         /* NOTREACHED */
 309         return (0);
 310 }
 311
 312
 313 static void
 314 usage(void)
 315 {
 316         (void) fprintf(stderr,
 317             gettext("usage:  %s [-np1] [-r tgt_rt] [-w wtime]"
 318                 " [-a type=passwd] [host1 ...]\n"),
 319             pgmname);
 320         (void) fprintf(stderr,
 321             gettext("\t%s -t {on=filename|more|off|dump} [host1 ...]\n"),
 322             pgmname);
 323         exit(EXIT_FAILURE);
 324 }
 325
 326
 327 /* Tell the target hosts about tracing */
 328 static void
 329 trace_loop(char *argv[], int soc)
 330 {
 331         struct sockaddr_in myaddr;
 332         int res;
 333         int optval = 1;
 334
 335         if (ripv2) {
 336                 OMSG.rip_vers = RIPv2;
 337         } else {
 338                 OMSG.rip_vers = RIPv1;
 339         }
 340
 341         (void) memset(&myaddr, 0, sizeof (myaddr));
 342         myaddr.sin_family = AF_INET;
 343         if (setsockopt(soc, IPPROTO_UDP, UDP_ANONPRIVBIND,
 344             &optval, sizeof (optval)) < 0) {
 345                 perror("rtquery: setsockopt UDP_ANONPRIVBIND");
 346                 exit(EXIT_FAILURE);
 347         }
 348
 349         if (bind(soc, (struct sockaddr *)&myaddr, sizeof (myaddr)) < 0) {
 350                 perror("rtquery: bind");
 351                 exit(EXIT_FAILURE);
 352         }
 353
 354         res = EXIT_FAILURE;
 355         while (*argv != NULL) {
 356                 if (out(*argv++, soc) == 0)
 357                         res = EXIT_SUCCESS;
 358         }
 359         exit(res);
 360 }
 361
 362
 363 /* Query all of the listed hosts */
 364 static void
 365 query_loop(char *argv[], int argc, int soc)
 366 {
 367 #define NA0 (OMSG.rip_auths[0])
 368 #define NA2 (OMSG.rip_auths[2])
 369         struct seen {
 370                 struct seen *next;
 371                 struct in_addr addr;
 372         } *seen, *sp;
 373         int answered = 0;
 374         int cc;
 375         fd_set bits;
 376         struct timeval now, delay;
 377         struct sockaddr_in from;
 378         MD5_CTX md5_ctx;
 379         struct msghdr msg;
 380         uint_t  ifindex;
 381         struct iovec iov;
 382         uint8_t ancillary_data[CONTROL_BUFSIZE];
 383
 384
 385         OMSG.rip_cmd = (pflag) ? RIPCMD_POLL : RIPCMD_REQUEST;
 386         if (ripv2) {
 387                 OMSG.rip_vers = RIPv2;
 388                 if (auth_type == RIP_AUTH_PW) {
 389                         OMSG.rip_nets[1] = OMSG.rip_nets[0];
 390                         NA0.a_family = RIP_AF_AUTH;
 391                         NA0.a_type = RIP_AUTH_PW;
 392                         (void) memcpy(NA0.au.au_pw, passwd, RIP_AUTH_PW_LEN);
 393                         omsg_len += sizeof (OMSG.rip_nets[0]);
 394
 395                 } else if (auth_type == RIP_AUTH_MD5) {
 396                         OMSG.rip_nets[1] = OMSG.rip_nets[0];
 397                         NA0.a_family = RIP_AF_AUTH;
 398                         NA0.a_type = RIP_AUTH_MD5;
 399                         NA0.au.a_md5.md5_keyid = (int8_t)keyid;
 400                         NA0.au.a_md5.md5_auth_len = RIP_AUTH_MD5_LEN;
 401                         NA0.au.a_md5.md5_seqno = 0;
 402                         cc = (char *)&NA2-(char *)&OMSG;
 403                         NA0.au.a_md5.md5_pkt_len = htons(cc);
 404                         NA2.a_family = RIP_AF_AUTH;
 405                         NA2.a_type = RIP_AUTH_TRAILER;
 406                         MD5Init(&md5_ctx);
 407                         MD5Update(&md5_ctx, (uchar_t *)&OMSG, cc+4);
 408                         MD5Update(&md5_ctx,
 409                             (uchar_t *)passwd, RIP_AUTH_MD5_LEN);
 410                         MD5Final(NA2.au.au_pw, &md5_ctx);
 411                         omsg_len += 2*sizeof (OMSG.rip_nets[0]);
 412                 }
 413
 414         } else {
 415                 OMSG.rip_vers = RIPv1;
 416                 OMSG.rip_nets[0].n_mask = 0;
 417         }
 418
 419         /* ask the first (valid) host */
 420         seen = NULL;
 421         while (0 > out(*argv++, soc)) {
 422                 if (*argv == NULL)
 423                         exit(EXIT_FAILURE);
 424                 answered++;
 425         }
 426
 427         iov.iov_base = &imsg_buf;
 428         iov.iov_len = sizeof (imsg_buf);
 429         msg.msg_iov = &iov;
 430         msg.msg_iovlen = 1;
 431         msg.msg_name = &from;
 432         msg.msg_control = &ancillary_data;
 433
 434         (void) FD_ZERO(&bits);
 435         FD_SET(soc, &bits);
 436         for (;;) {
 437                 delay.tv_sec = 0;
 438                 delay.tv_usec = STIME;
 439                 cc = select(soc+1, &bits, 0, 0, &delay);
 440                 if (cc > 0) {
 441                         msg.msg_namelen = sizeof (from);
 442                         msg.msg_controllen = sizeof (ancillary_data);
 443                         cc = recvmsg(soc, &msg, 0);
 444                         if (cc < 0) {
 445                                 perror("rtquery: recvmsg");
 446                                 exit(EXIT_FAILURE);
 447                         }
 448
 449                         /* avoid looping on high traffic */
 450                         if (answered > argc + 200)
 451                                 break;
 452
 453                         /*
 454                          * count the distinct responding hosts.
 455                          * You cannot match responding hosts with
 456                          * addresses to which queries were transmitted,
 457                          * because a router might respond with a
 458                          * different source address.
 459                          */
 460                         for (sp = seen; sp != NULL; sp = sp->next) {
 461                                 if (sp->addr.s_addr == from.sin_addr.s_addr)
 462                                         break;
 463                         }
 464                         if (sp == NULL) {
 465                                 sp = malloc(sizeof (*sp));
 466                                 if (sp != NULL) {
 467                                         sp->addr = from.sin_addr;
 468                                         sp->next = seen;
 469                                         seen = sp;
 470                                 } else {
 471                                         perror("rtquery: malloc");
 472                                 }
 473                                 answered++;
 474                         }
 475
 476                         ifindex = incoming_interface(&msg);
 477                         rip_input(&from, cc, ifindex);
 478                         continue;
 479                 }
 480
 481                 if (cc < 0) {
 482                         if (errno == EINTR)
 483                                 continue;
 484                         perror("rtquery: select");
 485                         exit(EXIT_FAILURE);
 486                 }
 487
 488                 /*
 489                  * After a pause in responses, probe another host.
 490                  * This reduces the intermingling of answers.
 491                  */
 492                 while (*argv != NULL && 0 > out(*argv++, soc))
 493                         answered++;
 494
 495                 /*
 496                  * continue until no more packets arrive
 497                  * or we have heard from all hosts
 498                  */
 499                 if (answered >= argc)
 500                         break;
 501
 502                 /* or until we have waited a long time */
 503                 if (gettimeofday(&now, 0) < 0) {
 504                         perror("rtquery: gettimeofday");
 505                         exit(EXIT_FAILURE);
 506                 }
 507                 if (sent.tv_sec + wtime <= now.tv_sec)
 508                         break;
 509         }
 510
 511         /* fail if there was no answer */
 512         exit(answered >= argc ? EXIT_SUCCESS : EXIT_FAILURE);
 513 }
 514
 515
 516 /* Send to one host */
 517 static int
 518 out(const char *host, int soc)
 519 {
 520
 521         struct addrinfo hints, *res;
 522         int ret;
 523
 524         if (gettimeofday(&sent, 0) < 0) {
 525                 perror("rtquery: gettimeofday");
 526                 return (-1);
 527         }
 528
 529         (void) memset(&hints, 0, sizeof (hints));
 530         hints.ai_family = PF_INET;
 531         hints.ai_socktype = SOCK_DGRAM;
 532         if ((ret = getaddrinfo(host, "route", &hints, &res)) != 0) {
 533                 (void) fprintf(stderr, "%s: getaddrinfo: %s: %s\n", pgmname,
 534                     host, gai_strerror(ret));
 535                 return (-1);
 536         }
 537
 538         if (sendto(soc, &omsg_buf, omsg_len, 0, res->ai_addr,
 539             res->ai_addrlen) < 0) {
 540                 perror("rtquery: sendto");
 541                 return (-1);
 542         }
 543
 544         freeaddrinfo(res);
 545         return (0);
 546 }
 547
 548 /*
 549  * Handle an incoming RIP packet.
 550  */
 551 static void
 552 rip_input(struct sockaddr_in *from, int size, uint_t ifindex)
 553 {
 554         struct netinfo *n, *lim;
 555         struct in_addr in;
 556         const char *name;
 557         char net_buf[80];
 558         uchar_t hash[RIP_AUTH_MD5_LEN];
 559         MD5_CTX md5_ctx;
 560         uchar_t md5_authed = 0;
 561         in_addr_t mask, dmask;
 562         struct in_addr tmp_addr;
 563         char *sp;
 564         char  ifname[IF_NAMESIZE+1];
 565         int i;
 566         struct hostent *hp;
 567         struct netent *np;
 568         struct netauth *na;
 569         char srcaddr[MAXHOSTNAMELEN + sizeof (" (123.123.123.123)") + 1];
 570         char ifstring[IF_NAMESIZE + 3*sizeof (ifindex) + sizeof (" ()") + 1];
 571
 572         if (!nflag && (hp = gethostbyaddr((char *)&from->sin_addr,
 573             sizeof (struct in_addr), AF_INET)) != NULL) {
 574                 (void) snprintf(srcaddr, sizeof (srcaddr), "%s (%s)",
 575                     hp->h_name, inet_ntoa(from->sin_addr));
 576         } else {
 577                 /* safe; cannot overflow destination */
 578                 (void) strcpy(srcaddr, inet_ntoa(from->sin_addr));
 579         }
 580         if (ifindex == 0) {
 581                 (void) printf("%s:", srcaddr);
 582         } else {
 583                 if (if_indextoname(ifindex, ifname) != NULL)
 584                         (void) snprintf(ifstring, sizeof (ifstring), "%s (%d)",
 585                             ifname, ifindex);
 586                 else
 587                         (void) snprintf(ifstring, sizeof (ifstring), "%d",
 588                             ifindex);
 589                 (void) printf(gettext("%1$s received on interface %2$s:"),
 590                     srcaddr, ifstring);
 591         }
 592
 593         if (IMSG.rip_cmd != RIPCMD_RESPONSE) {
 594                 (void) printf(gettext("\n    unexpected response type %d\n"),
 595                     IMSG.rip_cmd);
 596                 return;
 597         }
 598         (void) printf(gettext(" RIPv%1$d%2$s %3$d bytes\n"), IMSG.rip_vers,
 599             (IMSG.rip_vers != RIPv1 && IMSG.rip_vers != RIPv2) ? " ?" : "",
 600             size);
 601         if (size > MAXPACKETSIZE) {
 602                 if (size > sizeof (imsg_buf) - sizeof (*n)) {
 603                         (void) printf(
 604                             gettext("       at least %d bytes too long\n"),
 605                             size-MAXPACKETSIZE);
 606                         size = sizeof (imsg_buf) - sizeof (*n);
 607                 } else {
 608                         (void) printf(gettext("       %d bytes too long\n"),
 609                             size-MAXPACKETSIZE);
 610                 }
 611         } else if (size%sizeof (*n) != sizeof (struct rip)%sizeof (*n)) {
 612                 (void) printf(gettext("    response of bad length=%d\n"), size);
 613         }
 614
 615         n = IMSG.rip_nets;
 616         lim = n + (size - 4) / sizeof (struct netinfo);
 617         for (; n < lim; n++) {
 618                 name = "";
 619                 if (n->n_family == RIP_AF_INET) {
 620                         in.s_addr = n->n_dst;
 621                         (void) strlcpy(net_buf, inet_ntoa(in),
 622                             sizeof (net_buf));
 623
 624                         tmp_addr.s_addr = (n->n_mask);
 625                         mask = ntohl(n->n_mask);
 626                         dmask = mask & -mask;
 627                         if (mask != 0) {
 628                                 sp = &net_buf[strlen(net_buf)];
 629                                 if (IMSG.rip_vers == RIPv1) {
 630                                         (void) snprintf(sp,
 631                                             (sizeof (net_buf) -
 632                                             strlen(net_buf)),
 633                                             gettext(" mask=%s ? "),
 634                                             inet_ntoa(tmp_addr));
 635                                         mask = 0;
 636                                 } else if (mask + dmask == 0) {
 637                                         i = ffs(mask) - 1;
 638                                         (void) snprintf(sp,
 639                                             (sizeof (net_buf) -
 640                                             strlen(net_buf)), "/%d", 32-i);
 641                                 } else {
 642                                         (void) snprintf(sp,
 643                                             (sizeof (net_buf) -
 644                                                 strlen(net_buf)),
 645                                             gettext(" (mask %s)"),
 646                                             inet_ntoa(tmp_addr));
 647                                 }
 648                         }
 649
 650                         if (!nflag) {
 651                                 if (mask == 0) {
 652                                         mask = std_mask(in.s_addr);
 653                                         if ((ntohl(in.s_addr) & ~mask) != 0)
 654                                                 mask = 0;
 655                                 }
 656                                 /*
 657                                  * Without a netmask, do not worry about
 658                                  * whether the destination is a host or a
 659                                  * network. Try both and use the first name
 660                                  * we get.
 661                                  *
 662                                  * If we have a netmask we can make a
 663                                  * good guess.
 664                                  */
 665                                 if ((in.s_addr & ~mask) == 0) {
 666                                         np = getnetbyaddr((long)in.s_addr,
 667                                             AF_INET);
 668                                         if (np != NULL)
 669                                                 name = np->n_name;
 670                                         else if (in.s_addr == 0)
 671                                                 name = "default";
 672                                 }
 673                                 if (name[0] == '\0' &&
 674                                     ((in.s_addr & ~mask) != 0 ||
 675                                     mask == 0xffffffff)) {
 676                                         hp = gethostbyaddr((char *)&in,
 677                                             sizeof (in), AF_INET);
 678                                         if (hp != NULL)
 679                                                 name = hp->h_name;
 680                                 }
 681                         }
 682
 683                 } else if (n->n_family == RIP_AF_AUTH) {
 684                         na = (struct netauth *)n;
 685                         if (na->a_type == RIP_AUTH_PW &&
 686                             n == IMSG.rip_nets) {
 687                                 (void) printf(
 688                                     gettext("  Password Authentication:"
 689                                     " \"%s\"\n"),
 690                                     qstring(na->au.au_pw,
 691                                     RIP_AUTH_PW_LEN));
 692                                 continue;
 693                         }
 694
 695                         if (na->a_type == RIP_AUTH_MD5 &&
 696                             n == IMSG.rip_nets) {
 697                                 (void) printf(gettext("  MD5 Auth"
 698                                     " len=%1$d KeyID=%2$d"
 699                                     " auth_len=%3$d"
 700                                     " seqno=%4$#x"
 701                                     " rsvd=%5$#x,%6$#x\n"),
 702                                     ntohs(na->au.a_md5.md5_pkt_len),
 703                                     na->au.a_md5.md5_keyid,
 704                                     na->au.a_md5.md5_auth_len,
 705                                     (int)ntohl(na->au.a_md5.md5_seqno),
 706                                     na->au.a_md5.rsvd[0],
 707                                     na->au.a_md5.rsvd[1]);
 708                                 md5_authed = 1;
 709                                 continue;
 710                         }
 711                         (void) printf(gettext("  Authentication type %d: "),
 712                             ntohs(na->a_type));
 713                         for (i = 0; i < sizeof (na->au.au_pw); i++)
 714                                 (void) printf("%02x ",
 715                                     na->au.au_pw[i]);
 716                         (void) putchar('\n');
 717                         if (md5_authed && n+1 > lim &&
 718                             na->a_type == RIP_AUTH_TRAILER) {
 719                                 MD5Init(&md5_ctx);
 720                                 MD5Update(&md5_ctx, (uchar_t *)&IMSG,
 721                                     (char *)na-(char *)&IMSG);
 722                                 MD5Update(&md5_ctx,
 723                                     (uchar_t *)passwd, RIP_AUTH_MD5_LEN);
 724                                 MD5Final(hash, &md5_ctx);
 725                                 (void) printf(gettext("    %s hash\n"),
 726                                     memcmp(hash, na->au.au_pw, sizeof (hash)) ?
 727                                     gettext("WRONG") : gettext("correct"));
 728                         } else if (md5_authed && n+1 > lim &&
 729                             na->a_type != RIP_AUTH_TRAILER) {
 730                                 (void) printf(gettext("Error -"
 731                                 "authentication entry missing hash\n"));
 732                         }
 733                         continue;
 734
 735                 } else {
 736                         tmp_addr.s_addr = n->n_dst;
 737                         (void) snprintf(net_buf, sizeof (net_buf),
 738                             gettext("(address family %1$u) %2$s"),
 739                             ntohs(n->n_family), inet_ntoa(tmp_addr));
 740                 }
 741
 742                 (void) printf(gettext("  %1$-18s metric %2$2lu %3$-10s"),
 743                     net_buf, ntohl(n->n_metric), name);
 744
 745                 if (n->n_nhop != 0) {
 746                         in.s_addr = n->n_nhop;
 747                         if (nflag)
 748                                 hp = NULL;
 749                         else
 750                                 hp = gethostbyaddr((char *)&in, sizeof (in),
 751                                     AF_INET);
 752                         (void) printf(gettext(" nhop=%1$-15s%2$s"),
 753                             (hp != NULL) ? hp->h_name : inet_ntoa(in),
 754                             (IMSG.rip_vers == RIPv1) ? " ?" : "");
 755                 }
 756                 if (n->n_tag != 0)
 757                         (void) printf(gettext(" tag=%1$#x%2$s"), n->n_tag,
 758                             (IMSG.rip_vers == RIPv1) ? " ?" : "");
 759                 (void) putchar('\n');
 760         }
 761 }
 762
 763 /*
 764  * Find the interface which received the given message.
 765  */
 766 static uint_t
 767 incoming_interface(struct msghdr *msg)
 768 {
 769         void *opt;
 770         uint_t ifindex = 0;
 771
 772         /*
 773          * Determine which physical interface this packet was received on by
 774          * processing the message's ancillary data to find the
 775          * IP_RECVIF option we requested.
 776          */
 777         if ((opt = find_ancillary(msg, IP_RECVIF)) == NULL)
 778                 (void) fprintf(stderr,
 779                     gettext("%s: unable to retrieve input interface\n"),
 780                     pgmname);
 781         else
 782                 ifindex = *(uint_t *)opt;
 783         return (ifindex);
 784 }