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