sbin/routed/rtquery/rtquery.c

   1 /*-
   2  * Copyright (c) 1982, 1986, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $FreeBSD: src/sbin/routed/rtquery/rtquery.c,v 1.13 1999/08/28 00:14:21 peter Exp $
  30  */
  31
  32 char copyright[] =
  33 "@(#) Copyright (c) 1982, 1986, 1993\n\
  34         The Regents of the University of California.  All rights reserved.\n";
  35
  36 #include <sys/cdefs.h>
  37 #include <sys/param.h>
  38 #include <sys/protosw.h>
  39 #include <sys/socket.h>
  40 #include <sys/time.h>
  41 #include <netinet/in.h>
  42 #define RIPVERSION RIPv2
  43 #include <protocols/routed.h>
  44 #include <arpa/inet.h>
  45 #include <netdb.h>
  46 #include <errno.h>
  47 #include <unistd.h>
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <string.h>
  51 #ifdef sgi
  52 #include <strings.h>
  53 #include <bstring.h>
  54 #endif
  55
  56 #if !defined(sgi) && !defined(__NetBSD__)
  57 static char sccsid[] __attribute__((unused))= "@(#)query.c      8.1 (Berkeley) 6/5/93";
  58 #elif defined(__NetBSD__)
  59 __RCSID("$NetBSD: rtquery.c,v 1.10 1999/02/23 10:47:41 christos Exp $");
  60 #endif
  61
  62 #ifndef sgi
  63 #define _HAVE_SIN_LEN
  64 #endif
  65
  66 #define MD5_DIGEST_LEN 16
  67 typedef struct {
  68         u_int32_t state[4];             /* state (ABCD) */
  69         u_int32_t count[2];             /* # of bits, modulo 2^64 (LSB 1st) */
  70         unsigned char buffer[64];       /* input buffer */
  71 } MD5_CTX;
  72 extern void MD5Init(MD5_CTX*);
  73 extern void MD5Update(MD5_CTX*, u_char*, u_int);
  74 extern void MD5Final(u_char[MD5_DIGEST_LEN], MD5_CTX*);
  75
  76
  77 #define WTIME   15              /* Time to wait for all responses */
  78 #define STIME   (250*1000)      /* usec to wait for another response */
  79
  80 int     soc;
  81
  82 const char *pgmname;
  83
  84 union {
  85         struct rip rip;
  86         char    packet[MAXPACKETSIZE+MAXPATHLEN];
  87 } omsg_buf;
  88 #define OMSG omsg_buf.rip
  89 int omsg_len = sizeof(struct rip);
  90
  91 union {
  92         struct  rip rip;
  93         char    packet[MAXPACKETSIZE+1024];
  94         } imsg_buf;
  95 #define IMSG imsg_buf.rip
  96
  97 int     nflag;                          /* numbers, no names */
  98 int     pflag;                          /* play the `gated` game */
  99 int     ripv2 = 1;                      /* use RIP version 2 */
 100 int     wtime = WTIME;
 101 int     rflag;                          /* 1=ask about a particular route */
 102 int     trace, not_trace;               /* send trace command or not */
 103 int     auth_type = RIP_AUTH_NONE;
 104 char    passwd[RIP_AUTH_PW_LEN];
 105 u_long  keyid;
 106
 107 struct timeval sent;                    /* when query sent */
 108
 109 static char localhost_str[] = "localhost";
 110 static char *default_argv[] = {localhost_str, 0};
 111
 112 static void rip_input(struct sockaddr_in*, int);
 113 static int out(const char *);
 114 static void trace_loop(char *argv[]) __attribute((__noreturn__));
 115 static void query_loop(char *argv[], int) __attribute((__noreturn__));
 116 static int getnet(char *, struct netinfo *);
 117 static u_int std_mask(u_int);
 118 static int parse_quote(char **, const char *, char *, char *, int);
 119 static void usage(void);
 120
 121
 122 int
 123 main(int argc,
 124      char *argv[])
 125 {
 126         int ch, bsize;
 127         char *p, *options, *value, delim;
 128         const char *result;
 129
 130         OMSG.rip_nets[0].n_dst = RIP_DEFAULT;
 131         OMSG.rip_nets[0].n_family = RIP_AF_UNSPEC;
 132         OMSG.rip_nets[0].n_metric = htonl(HOPCNT_INFINITY);
 133
 134         pgmname = argv[0];
 135         delim = 0;
 136         while ((ch = getopt(argc, argv, "np1w:r:t:a:")) != -1)
 137                 switch (ch) {
 138                 case 'n':
 139                         not_trace = 1;
 140                         nflag = 1;
 141                         break;
 142
 143                 case 'p':
 144                         not_trace = 1;
 145                         pflag = 1;
 146                         break;
 147
 148                 case '1':
 149                         ripv2 = 0;
 150                         break;
 151
 152                 case 'w':
 153                         not_trace = 1;
 154                         wtime = (int)strtoul(optarg, &p, 0);
 155                         if (*p != '\0'
 156                             || wtime <= 0)
 157                                 usage();
 158                         break;
 159
 160                 case 'r':
 161                         not_trace = 1;
 162                         if (rflag)
 163                                 usage();
 164                         rflag = getnet(optarg, &OMSG.rip_nets[0]);
 165                         if (!rflag) {
 166                                 struct hostent *hp = gethostbyname(optarg);
 167                                 if (hp == NULL) {
 168                                         fprintf(stderr, "%s: %s:",
 169                                                 pgmname, optarg);
 170                                         herror(0);
 171                                         exit(1);
 172                                 }
 173                                 memcpy(&OMSG.rip_nets[0].n_dst, hp->h_addr,
 174                                        sizeof(OMSG.rip_nets[0].n_dst));
 175                                 OMSG.rip_nets[0].n_family = RIP_AF_INET;
 176                                 OMSG.rip_nets[0].n_mask = -1;
 177                                 rflag = 1;
 178                         }
 179                         break;
 180
 181                 case 't':
 182                         trace = 1;
 183                         options = optarg;
 184                         while (*options != '\0') {
 185                                 /* messy complications to make -W -Wall happy */
 186                                 static char on_str[] = "on";
 187                                 static char more_str[] = "more";
 188                                 static char off_str[] = "off";
 189                                 static char dump_str[] = "dump";
 190                                 static char *traceopts[] = {
 191 #                                   define TRACE_ON     0
 192                                         on_str,
 193 #                                   define TRACE_MORE   1
 194                                         more_str,
 195 #                                   define TRACE_OFF    2
 196                                         off_str,
 197 #                                   define TRACE_DUMP   3
 198                                         dump_str,
 199                                         0
 200                                 };
 201                                 result = "";
 202                                 switch (getsubopt(&options,traceopts,&value)) {
 203                                 case TRACE_ON:
 204                                         OMSG.rip_cmd = RIPCMD_TRACEON;
 205                                         if (!value
 206                                             || strlen(value) > MAXPATHLEN)
 207                                             usage();
 208                                         result = value;
 209                                         break;
 210                                 case TRACE_MORE:
 211                                         if (value)
 212                                             usage();
 213                                         OMSG.rip_cmd = RIPCMD_TRACEON;
 214                                         break;
 215                                 case TRACE_OFF:
 216                                         if (value)
 217                                             usage();
 218                                         OMSG.rip_cmd = RIPCMD_TRACEOFF;
 219                                         break;
 220                                 case TRACE_DUMP:
 221                                         if (value)
 222                                             usage();
 223                                         OMSG.rip_cmd = RIPCMD_TRACEON;
 224                                         result = "dump/../table";
 225                                         break;
 226                                 default:
 227                                         usage();
 228                                 }
 229                                 strcpy((char*)OMSG.rip_tracefile, result);
 230                                 omsg_len += strlen(result) - sizeof(OMSG.ripun);
 231                         }
 232                         break;
 233
 234                 case 'a':
 235                         not_trace = 1;
 236                         p = strchr(optarg,'=');
 237                         if (!p)
 238                                 usage();
 239                         *p++ = '\0';
 240                         if (!strcasecmp("passwd",optarg))
 241                                 auth_type = RIP_AUTH_PW;
 242                         else if (!strcasecmp("md5_passwd",optarg))
 243                                 auth_type = RIP_AUTH_MD5;
 244                         else
 245                                 usage();
 246                         if (0 > parse_quote(&p,"|",&delim,
 247                                             passwd, sizeof(passwd)))
 248                                 usage();
 249                         if (auth_type == RIP_AUTH_MD5
 250                             && delim == '|') {
 251                                 keyid = strtoul(p+1,&p,0);
 252                                 if (keyid > 255 || *p != '\0')
 253                                         usage();
 254                         } else if (delim != '\0') {
 255                                 usage();
 256                         }
 257                         break;
 258
 259                 default:
 260                         usage();
 261         }
 262         argv += optind;
 263         argc -= optind;
 264         if (not_trace && trace)
 265                 usage();
 266         if (argc == 0) {
 267                 argc = 1;
 268                 argv = default_argv;
 269         }
 270
 271         soc = socket(AF_INET, SOCK_DGRAM, 0);
 272         if (soc < 0) {
 273                 perror("socket");
 274                 exit(2);
 275         }
 276
 277         /* be prepared to receive a lot of routes */
 278         for (bsize = 127*1024; ; bsize -= 1024) {
 279                 if (setsockopt(soc, SOL_SOCKET, SO_RCVBUF,
 280                                &bsize, sizeof(bsize)) == 0)
 281                         break;
 282                 if (bsize <= 4*1024) {
 283                         perror("setsockopt SO_RCVBUF");
 284                         break;
 285                 }
 286         }
 287
 288         if (trace)
 289                 trace_loop(argv);
 290         else
 291                 query_loop(argv, argc);
 292         /* NOTREACHED */
 293         return 0;
 294 }
 295
 296
 297 static void
 298 usage(void)
 299 {
 300         fprintf(stderr,
 301                 "usage:  rtquery [-np1] [-r tgt_rt] [-w wtime]"
 302                 " [-a type=passwd] host1 [host2 ...]\n"
 303                 "\trtquery -t {on=filename|more|off|dump}"
 304                                 " host1 [host2 ...]\n");
 305         exit(1);
 306 }
 307
 308
 309 /* tell the target hosts about tracing
 310  */
 311 static void
 312 trace_loop(char *argv[])
 313 {
 314         struct sockaddr_in myaddr;
 315         int res;
 316
 317         if (geteuid() != 0) {
 318                 fprintf(stderr, "-t requires UID 0\n");
 319                 exit(1);
 320         }
 321
 322         if (ripv2) {
 323                 OMSG.rip_vers = RIPv2;
 324         } else {
 325                 OMSG.rip_vers = RIPv1;
 326         }
 327
 328         memset(&myaddr, 0, sizeof(myaddr));
 329         myaddr.sin_family = AF_INET;
 330 #ifdef _HAVE_SIN_LEN
 331         myaddr.sin_len = sizeof(myaddr);
 332 #endif
 333         myaddr.sin_port = htons(IPPORT_RESERVED-1);
 334         while (bind(soc, (struct sockaddr *)&myaddr, sizeof(myaddr)) < 0) {
 335                 if (errno != EADDRINUSE
 336                     || myaddr.sin_port == 0) {
 337                         perror("bind");
 338                         exit(2);
 339                 }
 340                 myaddr.sin_port = htons(ntohs(myaddr.sin_port)-1);
 341         }
 342
 343         res = 1;
 344         while (*argv != NULL) {
 345                 if (out(*argv++) <= 0)
 346                         res = 0;
 347         }
 348         exit(res);
 349 }
 350
 351
 352 /* query all of the listed hosts
 353  */
 354 static void
 355 query_loop(char *argv[], int argc)
 356 {
 357 #       define NA0 (OMSG.rip_auths[0])
 358 #       define NA2 (OMSG.rip_auths[2])
 359         struct seen {
 360                 struct seen *next;
 361                 struct in_addr addr;
 362         } *seen, *sp;
 363         int answered = 0;
 364         int cc;
 365         fd_set bits;
 366         struct timeval now, delay;
 367         struct sockaddr_in from;
 368         socklen_t fromlen;
 369         MD5_CTX md5_ctx;
 370
 371
 372         OMSG.rip_cmd = (pflag) ? RIPCMD_POLL : RIPCMD_REQUEST;
 373         if (ripv2) {
 374                 OMSG.rip_vers = RIPv2;
 375                 if (auth_type == RIP_AUTH_PW) {
 376                         OMSG.rip_nets[1] = OMSG.rip_nets[0];
 377                         NA0.a_family = RIP_AF_AUTH;
 378                         NA0.a_type = RIP_AUTH_PW;
 379                         memcpy(NA0.au.au_pw, passwd, RIP_AUTH_PW_LEN);
 380                         omsg_len += sizeof(OMSG.rip_nets[0]);
 381
 382                 } else if (auth_type == RIP_AUTH_MD5) {
 383                         OMSG.rip_nets[1] = OMSG.rip_nets[0];
 384                         NA0.a_family = RIP_AF_AUTH;
 385                         NA0.a_type = RIP_AUTH_MD5;
 386                         NA0.au.a_md5.md5_keyid = (int8_t)keyid;
 387                         NA0.au.a_md5.md5_auth_len = RIP_AUTH_MD5_LEN;
 388                         NA0.au.a_md5.md5_seqno = 0;
 389                         cc = (char *)&NA2-(char *)&OMSG;
 390                         NA0.au.a_md5.md5_pkt_len = htons(cc);
 391                         NA2.a_family = RIP_AF_AUTH;
 392                         NA2.a_type = htons(1);
 393                         MD5Init(&md5_ctx);
 394                         MD5Update(&md5_ctx,
 395                                   (u_char *)&OMSG, cc);
 396                         MD5Update(&md5_ctx,
 397                                   (u_char *)passwd, RIP_AUTH_MD5_LEN);
 398                         MD5Final(NA2.au.au_pw, &md5_ctx);
 399                         omsg_len += 2*sizeof(OMSG.rip_nets[0]);
 400                 }
 401
 402         } else {
 403                 OMSG.rip_vers = RIPv1;
 404                 OMSG.rip_nets[0].n_mask = 0;
 405         }
 406
 407         /* ask the first (valid) host */
 408         seen = NULL;
 409         while (0 > out(*argv++)) {
 410                 if (*argv == NULL)
 411                         exit(-1);
 412                 answered++;
 413         }
 414
 415         FD_ZERO(&bits);
 416         for (;;) {
 417                 FD_SET(soc, &bits);
 418                 delay.tv_sec = 0;
 419                 delay.tv_usec = STIME;
 420                 cc = select(soc+1, &bits, 0,0, &delay);
 421                 if (cc > 0) {
 422                         fromlen = sizeof(from);
 423                         cc = recvfrom(soc, imsg_buf.packet,
 424                                       sizeof(imsg_buf.packet), 0,
 425                                       (struct sockaddr *)&from, &fromlen);
 426                         if (cc < 0) {
 427                                 perror("recvfrom");
 428                                 exit(1);
 429                         }
 430                         /* count the distinct responding hosts.
 431                          * You cannot match responding hosts with
 432                          * addresses to which queries were transmitted,
 433                          * because a router might respond with a
 434                          * different source address.
 435                          */
 436                         for (sp = seen; sp != NULL; sp = sp->next) {
 437                                 if (sp->addr.s_addr == from.sin_addr.s_addr)
 438                                         break;
 439                         }
 440                         if (sp == NULL) {
 441                                 sp = malloc(sizeof(*sp));
 442                                 if (sp == NULL) {
 443                                         fprintf(stderr,
 444                                                 "rtquery: malloc failed\n");
 445                                         exit(1);
 446                                 }
 447                                 sp->addr = from.sin_addr;
 448                                 sp->next = seen;
 449                                 seen = sp;
 450                                 answered++;
 451                         }
 452
 453                         rip_input(&from, cc);
 454                         continue;
 455                 }
 456
 457                 if (cc < 0) {
 458                         if (errno == EINTR)
 459                                 continue;
 460                         perror("select");
 461                         exit(1);
 462                 }
 463
 464                 /* After a pause in responses, probe another host.
 465                  * This reduces the intermingling of answers.
 466                  */
 467                 while (*argv != NULL && 0 > out(*argv++))
 468                         answered++;
 469
 470                 /* continue until no more packets arrive
 471                  * or we have heard from all hosts
 472                  */
 473                 if (answered >= argc)
 474                         break;
 475
 476                 /* or until we have waited a long time
 477                  */
 478                 if (gettimeofday(&now, 0) < 0) {
 479                         perror("gettimeofday(now)");
 480                         exit(1);
 481                 }
 482                 if (sent.tv_sec + wtime <= now.tv_sec)
 483                         break;
 484         }
 485
 486         /* fail if there was no answer */
 487         exit (answered >= argc ? 0 : 1);
 488 }
 489
 490
 491 /* send to one host
 492  */
 493 static int
 494 out(const char *host)
 495 {
 496         struct sockaddr_in router;
 497         struct hostent *hp;
 498
 499         if (gettimeofday(&sent, 0) < 0) {
 500                 perror("gettimeofday(sent)");
 501                 return -1;
 502         }
 503
 504         memset(&router, 0, sizeof(router));
 505         router.sin_family = AF_INET;
 506 #ifdef _HAVE_SIN_LEN
 507         router.sin_len = sizeof(router);
 508 #endif
 509         if (!inet_aton(host, &router.sin_addr)) {
 510                 hp = gethostbyname(host);
 511                 if (hp == NULL) {
 512                         herror(host);
 513                         return -1;
 514                 }
 515                 memcpy(&router.sin_addr, hp->h_addr, sizeof(router.sin_addr));
 516         }
 517         router.sin_port = htons(RIP_PORT);
 518
 519         if (sendto(soc, &omsg_buf, omsg_len, 0,
 520                    (struct sockaddr *)&router, sizeof(router)) < 0) {
 521                 perror(host);
 522                 return -1;
 523         }
 524
 525         return 0;
 526 }
 527
 528
 529 /*
 530  * Convert string to printable characters
 531  */
 532 static char *
 533 qstring(u_char *s, int len)
 534 {
 535         static char buf[8*20+1];
 536         char *p;
 537         u_char *s2, c;
 538
 539
 540         for (p = buf; len != 0 && p < &buf[sizeof(buf)-1]; len--) {
 541                 c = *s++;
 542                 if (c == '\0') {
 543                         for (s2 = s+1; s2 < &s[len]; s2++) {
 544                                 if (*s2 != '\0')
 545                                         break;
 546                         }
 547                         if (s2 >= &s[len])
 548                             goto exit;
 549                 }
 550
 551                 if (c >= ' ' && c < 0x7f && c != '\\') {
 552                         *p++ = c;
 553                         continue;
 554                 }
 555                 *p++ = '\\';
 556                 switch (c) {
 557                 case '\\':
 558                         *p++ = '\\';
 559                         break;
 560                 case '\n':
 561                         *p++= 'n';
 562                         break;
 563                 case '\r':
 564                         *p++= 'r';
 565                         break;
 566                 case '\t':
 567                         *p++ = 't';
 568                         break;
 569                 case '\b':
 570                         *p++ = 'b';
 571                         break;
 572                 default:
 573                         p += sprintf(p,"%o",c);
 574                         break;
 575                 }
 576         }
 577 exit:
 578         *p = '\0';
 579         return buf;
 580 }
 581
 582
 583 /*
 584  * Handle an incoming RIP packet.
 585  */
 586 static void
 587 rip_input(struct sockaddr_in *from,
 588           int size)
 589 {
 590         struct netinfo *n, *lim;
 591         struct in_addr in;
 592         const char *name;
 593         char net_buf[80];
 594         u_char hash[RIP_AUTH_MD5_LEN];
 595         MD5_CTX md5_ctx;
 596         u_char md5_authed = 0;
 597         u_int mask, dmask;
 598         char *sp;
 599         int i;
 600         struct hostent *hp;
 601         struct netent *np;
 602         struct netauth *na;
 603
 604
 605         if (nflag) {
 606                 printf("%s:", inet_ntoa(from->sin_addr));
 607         } else {
 608                 hp = gethostbyaddr(&from->sin_addr, sizeof(struct in_addr),
 609                                    AF_INET);
 610                 if (hp == NULL) {
 611                         printf("%s:",
 612                                inet_ntoa(from->sin_addr));
 613                 } else {
 614                         printf("%s (%s):", hp->h_name,
 615                                inet_ntoa(from->sin_addr));
 616                 }
 617         }
 618         if (IMSG.rip_cmd != RIPCMD_RESPONSE) {
 619                 printf("\n    unexpected response type %d\n", IMSG.rip_cmd);
 620                 return;
 621         }
 622         printf(" RIPv%d%s %d bytes\n", IMSG.rip_vers,
 623                (IMSG.rip_vers != RIPv1 && IMSG.rip_vers != RIPv2) ? " ?" : "",
 624                size);
 625         if (size > MAXPACKETSIZE) {
 626                 if (size > (int)sizeof(imsg_buf) - (int)sizeof(*n)) {
 627                         printf("       at least %d bytes too long\n",
 628                                size-MAXPACKETSIZE);
 629                         size = (int)sizeof(imsg_buf) - (int)sizeof(*n);
 630                 } else {
 631                         printf("       %d bytes too long\n",
 632                                size-MAXPACKETSIZE);
 633                 }
 634         } else if (size%sizeof(*n) != sizeof(struct rip)%sizeof(*n)) {
 635                 printf("    response of bad length=%d\n", size);
 636         }
 637
 638         n = IMSG.rip_nets;
 639         lim = (struct netinfo *)((char*)n + size) - 1;
 640         for (; n <= lim; n++) {
 641                 name = "";
 642                 if (n->n_family == RIP_AF_INET) {
 643                         in.s_addr = n->n_dst;
 644                         strcpy(net_buf, inet_ntoa(in));
 645
 646                         mask = ntohl(n->n_mask);
 647                         dmask = mask & -mask;
 648                         if (mask != 0) {
 649                                 sp = &net_buf[strlen(net_buf)];
 650                                 if (IMSG.rip_vers == RIPv1) {
 651                                         sprintf(sp," mask=%#x ? ",mask);
 652                                         mask = 0;
 653                                 } else if (mask + dmask == 0) {
 654                                         for (i = 0;
 655                                              (i != 32
 656                                               && ((1<<i)&mask) == 0);
 657                                              i++)
 658                                                 continue;
 659                                         sprintf(sp, "/%d",32-i);
 660                                 } else {
 661                                         sprintf(sp," (mask %#x)", mask);
 662                                 }
 663                         }
 664
 665                         if (!nflag) {
 666                                 if (mask == 0) {
 667                                         mask = std_mask(in.s_addr);
 668                                         if ((ntohl(in.s_addr) & ~mask) != 0)
 669                                                 mask = 0;
 670                                 }
 671                                 /* Without a netmask, do not worry about
 672                                  * whether the destination is a host or a
 673                                  * network. Try both and use the first name
 674                                  * we get.
 675                                  *
 676                                  * If we have a netmask we can make a
 677                                  * good guess.
 678                                  */
 679                                 if ((in.s_addr & ~mask) == 0) {
 680                                         np = getnetbyaddr((long)in.s_addr,
 681                                                           AF_INET);
 682                                         if (np != NULL)
 683                                                 name = np->n_name;
 684                                         else if (in.s_addr == 0)
 685                                                 name = "default";
 686                                 }
 687                                 if (name[0] == '\0'
 688                                     && ((in.s_addr & ~mask) != 0
 689                                         || mask == 0xffffffff)) {
 690                                         hp = gethostbyaddr(&in, sizeof(in),
 691                                                            AF_INET);
 692                                         if (hp != NULL)
 693                                                 name = hp->h_name;
 694                                 }
 695                         }
 696
 697                 } else if (n->n_family == RIP_AF_AUTH) {
 698                         na = (struct netauth*)n;
 699                         if (na->a_type == RIP_AUTH_PW
 700                             && n == IMSG.rip_nets) {
 701                                 printf("  Password Authentication: \"%s\"\n",
 702                                        qstring(na->au.au_pw, RIP_AUTH_PW_LEN));
 703                                 continue;
 704                         }
 705
 706                         if (na->a_type == RIP_AUTH_MD5
 707                             && n == IMSG.rip_nets) {
 708                                 printf("  MD5 Auth"
 709                                        " len=%d KeyID=%d"
 710                                        " auth_len=%d"
 711                                        " seqno=%#x"
 712                                        " rsvd=%#x,%#x\n",
 713                                        ntohs(na->au.a_md5.md5_pkt_len),
 714                                        na->au.a_md5.md5_keyid,
 715                                        na->au.a_md5.md5_auth_len,
 716                                        (int)ntohl(na->au.a_md5.md5_seqno),
 717                                        na->au.a_md5.rsvd[0],
 718                                        na->au.a_md5.rsvd[1]);
 719                                 md5_authed = 1;
 720                                 continue;
 721                         }
 722                         printf("  Authentication type %d: ", ntohs(na->a_type));
 723                         for (i = 0; i < (int)sizeof(na->au.au_pw); i++)
 724                                 printf("%02x ", na->au.au_pw[i]);
 725                         putc('\n', stdout);
 726                         if (md5_authed && n+1 > lim
 727                             && na->a_type == ntohs(1)) {
 728                                 MD5Init(&md5_ctx);
 729                                 MD5Update(&md5_ctx, (u_char *)&IMSG,
 730                                           (char *)na-(char *)&IMSG);
 731                                 MD5Update(&md5_ctx, (u_char *)passwd,
 732                                           RIP_AUTH_MD5_LEN);
 733                                 MD5Final(hash, &md5_ctx);
 734                                 printf("    %s hash\n",
 735                                        memcmp(hash, na->au.au_pw, sizeof(hash))
 736                                        ? "WRONG" : "correct");
 737                         }
 738                         continue;
 739
 740                 } else {
 741                         sprintf(net_buf, "(af %#x) %d.%d.%d.%d",
 742                                 ntohs(n->n_family),
 743                                 (char)(n->n_dst >> 24),
 744                                 (char)(n->n_dst >> 16),
 745                                 (char)(n->n_dst >> 8),
 746                                 (char)n->n_dst);
 747                 }
 748
 749                 printf("  %-18s metric %2d %-10s",
 750                        net_buf, (int)ntohl(n->n_metric), name);
 751
 752                 if (n->n_nhop != 0) {
 753                         in.s_addr = n->n_nhop;
 754                         if (nflag)
 755                                 hp = NULL;
 756                         else
 757                                 hp = gethostbyaddr(&in, sizeof(in), AF_INET);
 758                         printf(" nhop=%-15s%s",
 759                                (hp != NULL) ? hp->h_name : inet_ntoa(in),
 760                                (IMSG.rip_vers == RIPv1) ? " ?" : "");
 761                 }
 762                 if (n->n_tag != 0)
 763                         printf(" tag=%#x%s", n->n_tag,
 764                                (IMSG.rip_vers == RIPv1) ? " ?" : "");
 765                 putc('\n', stdout);
 766         }
 767 }
 768
 769
 770 /* Return the classical netmask for an IP address.
 771  */
 772 static u_int
 773 std_mask(u_int addr)                    /* in network order */
 774 {
 775         addr = ntohl(addr);             /* was a host, not a network */
 776
 777         if (addr == 0)                  /* default route has mask 0 */
 778                 return 0;
 779         if (IN_CLASSA(addr))
 780                 return IN_CLASSA_NET;
 781         if (IN_CLASSB(addr))
 782                 return IN_CLASSB_NET;
 783         return IN_CLASSC_NET;
 784 }
 785
 786
 787 /* get a network number as a name or a number, with an optional "/xx"
 788  * netmask.
 789  */
 790 static int                              /* 0=bad */
 791 getnet(char *name,
 792        struct netinfo *rt)
 793 {
 794         int i;
 795         struct netent *nentp;
 796         u_int mask;
 797         struct in_addr in;
 798         char hname[MAXHOSTNAMELEN+1];
 799         char *mname, *p;
 800
 801
 802         /* Detect and separate "1.2.3.4/24"
 803          */
 804         if (NULL != (mname = strrchr(name,'/'))) {
 805                 i = (int)(mname - name);
 806                 if (i > (int)sizeof(hname)-1)   /* name too long */
 807                         return 0;
 808                 memmove(hname, name, i);
 809                 hname[i] = '\0';
 810                 mname++;
 811                 name = hname;
 812         }
 813
 814         nentp = getnetbyname(name);
 815         if (nentp != NULL) {
 816                 in.s_addr = nentp->n_net;
 817         } else if (inet_aton(name, &in) == 1) {
 818                 in.s_addr = ntohl(in.s_addr);
 819         } else {
 820                 return 0;
 821         }
 822
 823         if (mname == NULL) {
 824                 mask = std_mask(in.s_addr);
 825                 if ((~mask & in.s_addr) != 0)
 826                         mask = 0xffffffff;
 827         } else {
 828                 mask = (u_int)strtoul(mname, &p, 0);
 829                 if (*p != '\0' || mask > 32)
 830                         return 0;
 831                 mask = 0xffffffff << (32-mask);
 832         }
 833
 834         rt->n_dst = htonl(in.s_addr);
 835         rt->n_family = RIP_AF_INET;
 836         rt->n_mask = htonl(mask);
 837         return 1;
 838 }
 839
 840
 841 /* strtok(), but honoring backslash
 842  */
 843 static int                              /* -1=bad */
 844 parse_quote(char **linep,
 845             const char *delims,
 846             char *delimp,
 847             char *buf,
 848             int lim)
 849 {
 850         char c, *pc;
 851         const char *p;
 852
 853
 854         pc = *linep;
 855         if (*pc == '\0')
 856                 return -1;
 857
 858         for (;;) {
 859                 if (lim == 0)
 860                         return -1;
 861                 c = *pc++;
 862                 if (c == '\0')
 863                         break;
 864
 865                 if (c == '\\' && *pc != '\0') {
 866                         if ((c = *pc++) == 'n') {
 867                                 c = '\n';
 868                         } else if (c == 'r') {
 869                                 c = '\r';
 870                         } else if (c == 't') {
 871                                 c = '\t';
 872                         } else if (c == 'b') {
 873                                 c = '\b';
 874                         } else if (c >= '0' && c <= '7') {
 875                                 c -= '0';
 876                                 if (*pc >= '0' && *pc <= '7') {
 877                                         c = (c<<3)+(*pc++ - '0');
 878                                         if (*pc >= '0' && *pc <= '7')
 879                                             c = (c<<3)+(*pc++ - '0');
 880                                 }
 881                         }
 882
 883                 } else {
 884                         for (p = delims; *p != '\0'; ++p) {
 885                                 if (*p == c)
 886                                         goto exit;
 887                         }
 888                 }
 889
 890                 *buf++ = c;
 891                 --lim;
 892         }
 893 exit:
 894         if (delimp != NULL)
 895                 *delimp = c;
 896         *linep = pc-1;
 897         if (lim != 0)
 898                 *buf = '\0';
 899         return 0;
 900 }