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