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