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