route.c revision 1.20
1 /* $NetBSD: route.c,v 1.20 1997/04/21 11:40:13 mrg Exp $ */ 2 3 /* 4 * Copyright (c) 1983, 1989, 1991, 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. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by the University of 18 * California, Berkeley and its contributors. 19 * 4. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36 #ifndef lint 37 static char copyright[] = 38 "@(#) Copyright (c) 1983, 1989, 1991, 1993\n\ 39 The Regents of the University of California. All rights reserved.\n"; 40 #endif /* not lint */ 41 42 #ifndef lint 43 #if 0 44 static char sccsid[] = "@(#)route.c 8.3 (Berkeley) 3/19/94"; 45 #else 46 static char rcsid[] = "$NetBSD: route.c,v 1.20 1997/04/21 11:40:13 mrg Exp $"; 47 #endif 48 #endif /* not lint */ 49 50 #include <sys/param.h> 51 #include <sys/file.h> 52 #include <sys/socket.h> 53 #include <sys/ioctl.h> 54 #include <sys/mbuf.h> 55 #include <sys/sysctl.h> 56 57 #include <net/if.h> 58 #include <net/route.h> 59 #include <net/if_dl.h> 60 #include <netinet/in.h> 61 #include <netatalk/at.h> 62 #include <netns/ns.h> 63 #include <netiso/iso.h> 64 #include <netccitt/x25.h> 65 #include <arpa/inet.h> 66 #include <netdb.h> 67 68 #include <errno.h> 69 #include <unistd.h> 70 #include <stdio.h> 71 #include <ctype.h> 72 #include <stdlib.h> 73 #include <string.h> 74 #include <paths.h> 75 76 #include "keywords.h" 77 #include "extern.h" 78 79 typedef union sockunion *sup; 80 81 int main __P((int, char **)); 82 static __dead void usage __P((char *)); 83 static void quit __P((char *)); 84 static char *any_ntoa __P((const struct sockaddr *)); 85 static void set_metric __P((char *, int)); 86 static void newroute __P((int, char **)); 87 static void inet_makenetandmask __P((u_long, struct sockaddr_in *)); 88 static int getaddr __P((int, char *, struct hostent **)); 89 #ifndef SMALL 90 static void flushroutes __P((int, char *[])); 91 static int x25_makemask __P((void)); 92 static void interfaces __P((void)); 93 static void monitor __P((void)); 94 static void print_getmsg __P((struct rt_msghdr *, int)); 95 #endif 96 static int rtmsg __P((int, int )); 97 static void mask_addr __P((void)); 98 static void print_rtmsg __P((struct rt_msghdr *, int)); 99 static void pmsg_common __P((struct rt_msghdr *)); 100 static void pmsg_addrs __P((char *, int)); 101 static void bprintf __P((FILE *, int, u_char *)); 102 static int keyword __P((char *)); 103 static void sodump __P((sup, char *)); 104 static void sockaddr __P((char *, struct sockaddr *)); 105 106 struct ortentry route; 107 union sockunion { 108 struct sockaddr sa; 109 struct sockaddr_in sin; 110 struct sockaddr_at sat; 111 struct sockaddr_ns sns; 112 struct sockaddr_iso siso; 113 struct sockaddr_dl sdl; 114 struct sockaddr_x25 sx25; 115 } so_dst, so_gate, so_mask, so_genmask, so_ifa, so_ifp; 116 117 int pid, rtm_addrs; 118 int s; 119 int forcehost, forcenet, doflush, nflag, af, qflag, tflag; 120 int iflag, verbose, aflen = sizeof (struct sockaddr_in); 121 int locking, lockrest, debugonly; 122 struct rt_metrics rt_metrics; 123 u_long rtm_inits; 124 125 static __dead void 126 usage(cp) 127 char *cp; 128 { 129 if (cp) 130 (void) fprintf(stderr, "route: botched keyword: %s\n", cp); 131 (void) fprintf(stderr, 132 "usage: route [ -nqv ] cmd [[ -<qualifers> ] args ]\n"); 133 exit(1); 134 /* NOTREACHED */ 135 } 136 137 static void 138 quit(s) 139 char *s; 140 { 141 int sverrno = errno; 142 143 (void) fprintf(stderr, "route: "); 144 if (s) 145 (void) fprintf(stderr, "%s: ", s); 146 (void) fprintf(stderr, "%s\n", strerror(sverrno)); 147 exit(1); 148 /* NOTREACHED */ 149 } 150 151 #define ROUNDUP(a) \ 152 ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long)) 153 #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len)) 154 155 int 156 main(argc, argv) 157 int argc; 158 char **argv; 159 { 160 extern int optind; 161 int ch; 162 163 if (argc < 2) 164 usage((char *)NULL); 165 166 while ((ch = getopt(argc, argv, "nqdtv")) != EOF) 167 switch(ch) { 168 case 'n': 169 nflag = 1; 170 break; 171 case 'q': 172 qflag = 1; 173 break; 174 case 'v': 175 verbose = 1; 176 break; 177 case 't': 178 tflag = 1; 179 break; 180 case 'd': 181 debugonly = 1; 182 break; 183 case '?': 184 default: 185 usage((char *)NULL); 186 } 187 argc -= optind; 188 argv += optind; 189 190 pid = getpid(); 191 if (tflag) 192 s = open("/dev/null", O_WRONLY, 0); 193 else 194 s = socket(PF_ROUTE, SOCK_RAW, 0); 195 if (s < 0) 196 quit("socket"); 197 198 if (*argv == NULL) 199 goto no_cmd; 200 switch (keyword(*argv)) { 201 202 #ifndef SMALL 203 case K_GET: 204 #endif /* SMALL */ 205 case K_CHANGE: 206 case K_ADD: 207 case K_DELETE: 208 newroute(argc, argv); 209 break; 210 211 case K_SHOW: 212 show(argc, argv); 213 break; 214 215 #ifndef SMALL 216 case K_MONITOR: 217 monitor(); 218 break; 219 220 case K_FLUSH: 221 flushroutes(argc, argv); 222 break; 223 #endif /* SMALL */ 224 225 no_cmd: 226 default: 227 usage(*argv); 228 return 1; 229 } 230 return 0; 231 } 232 233 #ifndef SMALL 234 /* 235 * Purge all entries in the routing tables not 236 * associated with network interfaces. 237 */ 238 static void 239 flushroutes(argc, argv) 240 int argc; 241 char *argv[]; 242 { 243 size_t needed; 244 int mib[6], rlen, seqno; 245 char *buf, *next, *lim; 246 register struct rt_msghdr *rtm; 247 248 shutdown(s, 0); /* Don't want to read back our messages */ 249 if (argc > 1) { 250 argv++; 251 if (argc == 2 && **argv == '-') 252 switch (keyword(*argv + 1)) { 253 case K_INET: 254 af = AF_INET; 255 break; 256 case K_ATALK: 257 af = AF_APPLETALK; 258 break; 259 case K_XNS: 260 af = AF_NS; 261 break; 262 case K_LINK: 263 af = AF_LINK; 264 break; 265 case K_ISO: 266 case K_OSI: 267 af = AF_ISO; 268 break; 269 case K_X25: 270 af = AF_CCITT; 271 default: 272 goto bad; 273 } else 274 bad: usage(*argv); 275 } 276 mib[0] = CTL_NET; 277 mib[1] = PF_ROUTE; 278 mib[2] = 0; /* protocol */ 279 mib[3] = 0; /* wildcard address family */ 280 mib[4] = NET_RT_DUMP; 281 mib[5] = 0; /* no flags */ 282 if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) 283 quit("route-sysctl-estimate"); 284 if ((buf = malloc(needed)) == NULL) 285 quit("malloc"); 286 if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) 287 quit("actual retrieval of routing table"); 288 lim = buf + needed; 289 if (verbose) { 290 (void) printf("Examining routing table from sysctl\n"); 291 if (af) printf("(address family %s)\n", (*argv + 1)); 292 } 293 seqno = 0; /* ??? */ 294 for (next = buf; next < lim; next += rtm->rtm_msglen) { 295 rtm = (struct rt_msghdr *)next; 296 if (verbose) 297 print_rtmsg(rtm, rtm->rtm_msglen); 298 if ((rtm->rtm_flags & RTF_GATEWAY) == 0) 299 continue; 300 if (af) { 301 struct sockaddr *sa = (struct sockaddr *)(rtm + 1); 302 303 if (sa->sa_family != af) 304 continue; 305 } 306 if (debugonly) 307 continue; 308 rtm->rtm_type = RTM_DELETE; 309 rtm->rtm_seq = seqno; 310 rlen = write(s, next, rtm->rtm_msglen); 311 if (rlen < (int)rtm->rtm_msglen) { 312 (void) fprintf(stderr, 313 "route: write to routing socket: %s\n", 314 strerror(errno)); 315 (void) printf("got only %d for rlen\n", rlen); 316 break; 317 } 318 seqno++; 319 if (qflag) 320 continue; 321 if (verbose) 322 print_rtmsg(rtm, rlen); 323 else { 324 struct sockaddr *sa = (struct sockaddr *)(rtm + 1); 325 (void) printf("%-20.20s ", rtm->rtm_flags & RTF_HOST ? 326 routename(sa) : netname(sa)); 327 sa = (struct sockaddr *)(sa->sa_len + (char *)sa); 328 (void) printf("%-20.20s ", routename(sa)); 329 (void) printf("done\n"); 330 } 331 } 332 } 333 #endif /* SMALL */ 334 335 336 static char hexlist[] = "0123456789abcdef"; 337 338 static char * 339 any_ntoa(sa) 340 const struct sockaddr *sa; 341 { 342 static char obuf[64]; 343 const char *in; 344 char *out; 345 int len; 346 347 len = sa->sa_len; 348 in = sa->sa_data; 349 out = obuf; 350 351 do { 352 *out++ = hexlist[(*in >> 4) & 15]; 353 *out++ = hexlist[(*in++) & 15]; 354 *out++ = '.'; 355 } while (--len > 0); 356 out[-1] = '\0'; 357 return obuf; 358 } 359 360 361 char * 362 routename(sa) 363 struct sockaddr *sa; 364 { 365 register char *cp; 366 static char line[50]; 367 struct hostent *hp; 368 static char domain[MAXHOSTNAMELEN + 1]; 369 static int first = 1; 370 struct in_addr in; 371 372 if (first) { 373 first = 0; 374 if (gethostname(domain, MAXHOSTNAMELEN) == 0 && 375 (cp = strchr(domain, '.'))) { 376 (void)strncpy(domain, cp + 1, sizeof(domain) - 1); 377 domain[sizeof(domain) - 1] = '\0'; 378 } else 379 domain[0] = 0; 380 } 381 382 if (sa->sa_len == 0) { 383 strncpy(line, "default", sizeof(line) - 1); 384 line[sizeof(line) - 1] = '\0'; 385 } else switch (sa->sa_family) { 386 387 case AF_INET: 388 in = ((struct sockaddr_in *)sa)->sin_addr; 389 390 cp = 0; 391 if (in.s_addr == INADDR_ANY || sa->sa_len < 4) 392 cp = "default"; 393 if (cp == 0 && !nflag) { 394 hp = gethostbyaddr((char *)&in, sizeof (struct in_addr), 395 AF_INET); 396 if (hp) { 397 if ((cp = strchr(hp->h_name, '.')) && 398 !strcmp(cp + 1, domain)) 399 *cp = 0; 400 cp = hp->h_name; 401 } 402 } 403 if (cp) 404 (void)strncpy(line, cp, sizeof(line) - 1); 405 else 406 (void)strncpy(line, inet_ntoa(in), sizeof(line) - 1); 407 line[sizeof(line) - 1] = '\0'; 408 break; 409 410 case AF_LINK: 411 return (link_ntoa((struct sockaddr_dl *)sa)); 412 413 #ifndef SMALL 414 case AF_NS: 415 return (ns_print((struct sockaddr_ns *)sa)); 416 417 case AF_ISO: 418 (void)snprintf(line, sizeof line, "iso %s", 419 iso_ntoa(&((struct sockaddr_iso *)sa)->siso_addr)); 420 break; 421 422 case AF_APPLETALK: 423 (void) snprintf(line, sizeof(line), "atalk %d.%d", 424 ((struct sockaddr_at *)sa)->sat_addr.s_net, 425 ((struct sockaddr_at *)sa)->sat_addr.s_node); 426 break; 427 #endif /* SMALL */ 428 429 default: 430 (void)snprintf(line, sizeof line, "(%d) %s", 431 sa->sa_family, any_ntoa(sa)); 432 break; 433 434 } 435 return (line); 436 } 437 438 /* 439 * Return the name of the network whose address is given. 440 * The address is assumed to be that of a net or subnet, not a host. 441 */ 442 char * 443 netname(sa) 444 struct sockaddr *sa; 445 { 446 char *cp = 0; 447 static char line[50]; 448 struct netent *np = 0; 449 u_long net, mask; 450 register u_long i; 451 int subnetshift; 452 struct in_addr in; 453 454 switch (sa->sa_family) { 455 456 case AF_INET: 457 in = ((struct sockaddr_in *)sa)->sin_addr; 458 i = ntohl(in.s_addr); 459 if (i == 0) 460 cp = "default"; 461 else if (!nflag) { 462 if (IN_CLASSA(i)) { 463 mask = IN_CLASSA_NET; 464 subnetshift = 8; 465 } else if (IN_CLASSB(i)) { 466 mask = IN_CLASSB_NET; 467 subnetshift = 8; 468 } else { 469 mask = IN_CLASSC_NET; 470 subnetshift = 4; 471 } 472 /* 473 * If there are more bits than the standard mask 474 * would suggest, subnets must be in use. 475 * Guess at the subnet mask, assuming reasonable 476 * width subnet fields. 477 */ 478 while (i &~ mask) 479 mask = (long)mask >> subnetshift; 480 net = i & mask; 481 while ((mask & 1) == 0) 482 mask >>= 1, net >>= 1; 483 np = getnetbyaddr(net, AF_INET); 484 if (np) 485 cp = np->n_name; 486 } 487 if (cp) { 488 (void)strncpy(line, cp, sizeof(line) - 1); 489 line[sizeof(line) - 1] = '\0'; 490 } else { 491 #if 0 /* XXX - This is silly... */ 492 #define C(x) ((x) & 0xff) 493 if ((i & 0xffffff) == 0) 494 (void)snprintf(line, sizeof line, "%u", 495 C(i >> 24)); 496 else if ((i & 0xffff) == 0) 497 (void)snprintf(line, sizeof line, "%u.%u", 498 C(i >> 24), C(i >> 16)); 499 else if ((i & 0xff) == 0) 500 (void)snprintf(line, sizeof line, "%u.%u.%u", 501 C(i >> 24), C(i >> 16), C(i >> 8)); 502 else 503 (void)snprintf(line, sizeof line, "%u.%u.%u.%u", 504 C(i >> 24), C(i >> 16), C(i >> 8), C(i)); 505 #undef C 506 #else /* XXX */ 507 (void)strncpy(line, inet_ntoa(in), sizeof(line) - 1); 508 #endif /* XXX */ 509 } 510 break; 511 512 case AF_LINK: 513 return (link_ntoa((struct sockaddr_dl *)sa)); 514 515 #ifndef SMALL 516 case AF_NS: 517 return (ns_print((struct sockaddr_ns *)sa)); 518 519 case AF_ISO: 520 (void)snprintf(line, sizeof line, "iso %s", 521 iso_ntoa(&((struct sockaddr_iso *)sa)->siso_addr)); 522 break; 523 524 case AF_APPLETALK: 525 (void) snprintf(line, sizeof(line), "atalk %d.%d", 526 ((struct sockaddr_at *)sa)->sat_addr.s_net, 527 ((struct sockaddr_at *)sa)->sat_addr.s_node); 528 break; 529 #endif /* SMALL */ 530 531 default: 532 (void)snprintf(line, sizeof line, "af %d: %s", 533 sa->sa_family, any_ntoa(sa)); 534 break; 535 } 536 return (line); 537 } 538 539 static void 540 set_metric(value, key) 541 char *value; 542 int key; 543 { 544 int flag = 0; 545 u_long noval, *valp = &noval; 546 547 switch (key) { 548 #define caseof(x, y, z) case x: valp = &rt_metrics.z; flag = y; break 549 caseof(K_MTU, RTV_MTU, rmx_mtu); 550 caseof(K_HOPCOUNT, RTV_HOPCOUNT, rmx_hopcount); 551 caseof(K_EXPIRE, RTV_EXPIRE, rmx_expire); 552 caseof(K_RECVPIPE, RTV_RPIPE, rmx_recvpipe); 553 caseof(K_SENDPIPE, RTV_SPIPE, rmx_sendpipe); 554 caseof(K_SSTHRESH, RTV_SSTHRESH, rmx_ssthresh); 555 caseof(K_RTT, RTV_RTT, rmx_rtt); 556 caseof(K_RTTVAR, RTV_RTTVAR, rmx_rttvar); 557 } 558 rtm_inits |= flag; 559 if (lockrest || locking) 560 rt_metrics.rmx_locks |= flag; 561 if (locking) 562 locking = 0; 563 *valp = atoi(value); 564 } 565 566 static void 567 newroute(argc, argv) 568 int argc; 569 register char **argv; 570 { 571 char *cmd, *dest = "", *gateway = "", *err; 572 int ishost = 0, ret, attempts, oerrno, flags = RTF_STATIC; 573 int key; 574 struct hostent *hp = 0; 575 576 cmd = argv[0]; 577 if (*cmd != 'g') 578 shutdown(s, 0); /* Don't want to read back our messages */ 579 while (--argc > 0) { 580 if (**(++argv)== '-') { 581 switch (key = keyword(1 + *argv)) { 582 583 case K_SA: 584 af = PF_ROUTE; 585 aflen = sizeof(union sockunion); 586 break; 587 588 case K_ATALK: 589 af = AF_APPLETALK; 590 aflen = sizeof(struct sockaddr_at); 591 break; 592 593 case K_INET: 594 af = AF_INET; 595 aflen = sizeof(struct sockaddr_in); 596 break; 597 598 case K_LINK: 599 af = AF_LINK; 600 aflen = sizeof(struct sockaddr_dl); 601 break; 602 603 case K_OSI: 604 case K_ISO: 605 af = AF_ISO; 606 aflen = sizeof(struct sockaddr_iso); 607 break; 608 609 case K_X25: 610 af = AF_CCITT; 611 aflen = sizeof(struct sockaddr_x25); 612 break; 613 614 case K_XNS: 615 af = AF_NS; 616 aflen = sizeof(struct sockaddr_ns); 617 break; 618 619 case K_IFACE: 620 case K_INTERFACE: 621 iflag++; 622 break; 623 case K_NOSTATIC: 624 flags &= ~RTF_STATIC; 625 break; 626 case K_LLINFO: 627 flags |= RTF_LLINFO; 628 break; 629 case K_LOCK: 630 locking = 1; 631 break; 632 case K_LOCKREST: 633 lockrest = 1; 634 break; 635 case K_HOST: 636 forcehost++; 637 break; 638 case K_REJECT: 639 flags |= RTF_REJECT; 640 break; 641 case K_BLACKHOLE: 642 flags |= RTF_BLACKHOLE; 643 break; 644 case K_PROTO1: 645 flags |= RTF_PROTO1; 646 break; 647 case K_PROTO2: 648 flags |= RTF_PROTO2; 649 break; 650 case K_CLONING: 651 flags |= RTF_CLONING; 652 break; 653 case K_XRESOLVE: 654 flags |= RTF_XRESOLVE; 655 break; 656 case K_STATIC: 657 flags |= RTF_STATIC; 658 break; 659 case K_IFA: 660 argc--; 661 (void) getaddr(RTA_IFA, *++argv, 0); 662 break; 663 case K_IFP: 664 argc--; 665 (void) getaddr(RTA_IFP, *++argv, 0); 666 break; 667 case K_GENMASK: 668 argc--; 669 (void) getaddr(RTA_GENMASK, *++argv, 0); 670 break; 671 case K_GATEWAY: 672 argc--; 673 (void) getaddr(RTA_GATEWAY, *++argv, 0); 674 break; 675 case K_DST: 676 argc--; 677 ishost = getaddr(RTA_DST, *++argv, &hp); 678 dest = *argv; 679 break; 680 case K_NETMASK: 681 argc--; 682 (void) getaddr(RTA_NETMASK, *++argv, 0); 683 /* FALLTHROUGH */ 684 case K_NET: 685 forcenet++; 686 break; 687 case K_MTU: 688 case K_HOPCOUNT: 689 case K_EXPIRE: 690 case K_RECVPIPE: 691 case K_SENDPIPE: 692 case K_SSTHRESH: 693 case K_RTT: 694 case K_RTTVAR: 695 argc--; 696 set_metric(*++argv, key); 697 break; 698 default: 699 usage(1+*argv); 700 } 701 } else { 702 if ((rtm_addrs & RTA_DST) == 0) { 703 dest = *argv; 704 ishost = getaddr(RTA_DST, *argv, &hp); 705 } else if ((rtm_addrs & RTA_GATEWAY) == 0) { 706 gateway = *argv; 707 (void) getaddr(RTA_GATEWAY, *argv, &hp); 708 } else { 709 int ret = atoi(*argv); 710 711 if (ret == 0) { 712 if (!qflag && strcmp(*argv, "0") == 0) 713 printf("%s,%s", 714 "old usage of trailing 0", 715 "assuming route to if\n"); 716 else 717 usage((char *)NULL); 718 iflag = 1; 719 continue; 720 } else if (ret > 0 && ret < 10) { 721 if (!qflag) { 722 printf("old usage of trailing digit, "); 723 printf("assuming route via gateway\n"); 724 } 725 iflag = 0; 726 continue; 727 } 728 (void) getaddr(RTA_NETMASK, *argv, 0); 729 } 730 } 731 } 732 if (forcehost) 733 ishost = 1; 734 if (forcenet) 735 ishost = 0; 736 flags |= RTF_UP; 737 if (ishost) 738 flags |= RTF_HOST; 739 if (iflag == 0) 740 flags |= RTF_GATEWAY; 741 for (attempts = 1; ; attempts++) { 742 errno = 0; 743 if ((ret = rtmsg(*cmd, flags)) == 0) 744 break; 745 if (errno != ENETUNREACH && errno != ESRCH) 746 break; 747 if (af == AF_INET && *gateway && hp && hp->h_addr_list[1]) { 748 hp->h_addr_list++; 749 memcpy(&so_gate.sin.sin_addr, hp->h_addr_list[0], 750 hp->h_length); 751 } else 752 break; 753 } 754 if (*cmd == 'g') 755 exit(0); 756 oerrno = errno; 757 if (!qflag) { 758 (void) printf("%s %s %s", cmd, ishost? "host" : "net", dest); 759 if (*gateway) { 760 (void) printf(": gateway %s", gateway); 761 if (attempts > 1 && ret == 0 && af == AF_INET) 762 (void) printf(" (%s)", 763 inet_ntoa(((struct sockaddr_in *) 764 &route.rt_gateway)->sin_addr)); 765 } 766 if (ret == 0) 767 (void) printf("\n"); 768 } 769 if (ret != 0) { 770 switch (oerrno) { 771 case ESRCH: 772 err = "not in table"; 773 break; 774 case EBUSY: 775 err = "entry in use"; 776 break; 777 case ENOBUFS: 778 err = "routing table overflow"; 779 break; 780 default: 781 err = strerror(oerrno); 782 break; 783 } 784 (void) printf(": %s\n", err); 785 } 786 } 787 788 static void 789 inet_makenetandmask(net, sin) 790 u_long net; 791 register struct sockaddr_in *sin; 792 { 793 u_long addr, mask = 0; 794 register char *cp; 795 796 rtm_addrs |= RTA_NETMASK; 797 if (net == 0) 798 mask = addr = 0; 799 else if (net < 128) { 800 addr = net << IN_CLASSA_NSHIFT; 801 mask = IN_CLASSA_NET; 802 } else if (net < 65536) { 803 addr = net << IN_CLASSB_NSHIFT; 804 mask = IN_CLASSB_NET; 805 } else if (net < 16777216L) { 806 addr = net << IN_CLASSC_NSHIFT; 807 mask = IN_CLASSC_NET; 808 } else { 809 addr = net; 810 if ((addr & IN_CLASSA_HOST) == 0) 811 mask = IN_CLASSA_NET; 812 else if ((addr & IN_CLASSB_HOST) == 0) 813 mask = IN_CLASSB_NET; 814 else if ((addr & IN_CLASSC_HOST) == 0) 815 mask = IN_CLASSC_NET; 816 else 817 mask = -1; 818 } 819 sin->sin_addr.s_addr = htonl(addr); 820 sin = &so_mask.sin; 821 sin->sin_addr.s_addr = htonl(mask); 822 sin->sin_len = 0; 823 sin->sin_family = 0; 824 cp = (char *)(&sin->sin_addr + 1); 825 while (*--cp == 0 && cp > (char *)sin) 826 ; 827 sin->sin_len = 1 + cp - (char *)sin; 828 } 829 830 /* 831 * Interpret an argument as a network address of some kind, 832 * returning 1 if a host address, 0 if a network address. 833 */ 834 static int 835 getaddr(which, s, hpp) 836 int which; 837 char *s; 838 struct hostent **hpp; 839 { 840 register sup su; 841 struct hostent *hp; 842 struct netent *np; 843 u_long val; 844 char *t; 845 846 if (af == 0) { 847 af = AF_INET; 848 aflen = sizeof(struct sockaddr_in); 849 } 850 rtm_addrs |= which; 851 switch (which) { 852 case RTA_DST: 853 su = &so_dst; 854 su->sa.sa_family = af; 855 break; 856 case RTA_GATEWAY: 857 su = &so_gate; 858 su->sa.sa_family = af; 859 break; 860 case RTA_NETMASK: 861 su = &so_mask; 862 break; 863 case RTA_GENMASK: 864 su = &so_genmask; 865 break; 866 case RTA_IFP: 867 su = &so_ifp; 868 su->sa.sa_family = af; 869 break; 870 case RTA_IFA: 871 su = &so_ifa; 872 su->sa.sa_family = af; 873 break; 874 default: 875 su = NULL; 876 usage("Internal Error"); 877 /*NOTREACHED*/ 878 } 879 su->sa.sa_len = aflen; 880 if (strcmp(s, "default") == 0) { 881 switch (which) { 882 case RTA_DST: 883 forcenet++; 884 (void) getaddr(RTA_NETMASK, s, 0); 885 break; 886 case RTA_NETMASK: 887 case RTA_GENMASK: 888 su->sa.sa_len = 0; 889 } 890 return (0); 891 } 892 switch (af) { 893 #ifndef SMALL 894 case AF_NS: 895 if (which == RTA_DST) { 896 extern short ns_bh[3]; 897 struct sockaddr_ns *sms = &(so_mask.sns); 898 memset(sms, 0, sizeof(*sms)); 899 sms->sns_family = 0; 900 sms->sns_len = 6; 901 sms->sns_addr.x_net = *(union ns_net *)ns_bh; 902 rtm_addrs |= RTA_NETMASK; 903 } 904 su->sns.sns_addr = ns_addr(s); 905 return (!ns_nullhost(su->sns.sns_addr)); 906 907 case AF_OSI: 908 su->siso.siso_addr = *iso_addr(s); 909 if (which == RTA_NETMASK || which == RTA_GENMASK) { 910 register char *cp = (char *)TSEL(&su->siso); 911 su->siso.siso_nlen = 0; 912 do {--cp ;} while ((cp > (char *)su) && (*cp == 0)); 913 su->siso.siso_len = 1 + cp - (char *)su; 914 } 915 return (1); 916 917 case AF_CCITT: 918 ccitt_addr(s, &su->sx25); 919 return (which == RTA_DST ? x25_makemask() : 1); 920 #endif /* SMALL */ 921 922 case PF_ROUTE: 923 su->sa.sa_len = sizeof(*su); 924 sockaddr(s, &su->sa); 925 return (1); 926 927 case AF_APPLETALK: 928 t = strchr (s, '.'); 929 if (!t) { 930 badataddr: 931 (void)fprintf (stderr, "bad address: %s\n", s); 932 exit (1); 933 } 934 val = atoi (s); 935 if (val > 65535) 936 goto badataddr; 937 su->sat.sat_addr.s_net = val; 938 val = atoi (t); 939 if (val > 256) 940 goto badataddr; 941 su->sat.sat_addr.s_node = val; 942 rtm_addrs |= RTA_NETMASK; 943 return(forcehost || su->sat.sat_addr.s_node != 0); 944 945 case AF_LINK: 946 link_addr(s, &su->sdl); 947 return (1); 948 949 case AF_INET: 950 default: 951 break; 952 } 953 954 if (hpp == NULL) 955 hpp = &hp; 956 *hpp = NULL; 957 if (((val = inet_addr(s)) != INADDR_NONE) && 958 (which != RTA_DST || forcenet == 0)) { 959 su->sin.sin_addr.s_addr = val; 960 if (inet_lnaof(su->sin.sin_addr) != INADDR_ANY) 961 return (1); 962 else { 963 val = ntohl(val); 964 goto netdone; 965 } 966 } 967 if ((val = inet_network(s)) != INADDR_NONE || 968 ((np = getnetbyname(s)) != NULL && (val = np->n_net) != 0)) { 969 netdone: 970 if (which == RTA_DST) 971 inet_makenetandmask(val, &su->sin); 972 return (0); 973 } 974 hp = gethostbyname(s); 975 if (hp) { 976 *hpp = hp; 977 su->sin.sin_family = hp->h_addrtype; 978 memcpy(&su->sin.sin_addr, hp->h_addr, hp->h_length); 979 return (1); 980 } 981 (void) fprintf(stderr, "%s: bad value\n", s); 982 exit(1); 983 } 984 985 #ifndef SMALL 986 int 987 x25_makemask() 988 { 989 register char *cp; 990 991 if ((rtm_addrs & RTA_NETMASK) == 0) { 992 rtm_addrs |= RTA_NETMASK; 993 for (cp = (char *)&so_mask.sx25.x25_net; 994 cp < &so_mask.sx25.x25_opts.op_flags; cp++) 995 *cp = -1; 996 so_mask.sx25.x25_len = (u_char)&(((sup)0)->sx25.x25_opts); 997 } 998 return 0; 999 } 1000 1001 short ns_nullh[] = {0,0,0}; 1002 short ns_bh[] = {-1,-1,-1}; 1003 1004 char * 1005 ns_print(sns) 1006 struct sockaddr_ns *sns; 1007 { 1008 struct ns_addr work; 1009 union { union ns_net net_e; u_long long_e; } net; 1010 u_short port; 1011 static char mybuf[50], cport[10], chost[25]; 1012 char *host = ""; 1013 register char *p; 1014 register u_char *q; 1015 1016 work = sns->sns_addr; 1017 port = ntohs(work.x_port); 1018 work.x_port = 0; 1019 net.net_e = work.x_net; 1020 if (ns_nullhost(work) && net.long_e == 0) { 1021 if (!port) 1022 return ("*.*"); 1023 (void)snprintf(mybuf, sizeof mybuf, "*.%XH", port); 1024 return (mybuf); 1025 } 1026 1027 if (memcmp(ns_bh, work.x_host.c_host, 6) == 0) 1028 host = "any"; 1029 else if (memcmp(ns_nullh, work.x_host.c_host, 6) == 0) 1030 host = "*"; 1031 else { 1032 q = work.x_host.c_host; 1033 (void)snprintf(chost, sizeof chost, "%02X%02X%02X%02X%02X%02XH", 1034 q[0], q[1], q[2], q[3], q[4], q[5]); 1035 for (p = chost; *p == '0' && p < chost + 12; p++) 1036 /* void */; 1037 host = p; 1038 } 1039 if (port) 1040 (void)snprintf(cport, sizeof cport, ".%XH", htons(port)); 1041 else 1042 *cport = 0; 1043 1044 (void)snprintf(mybuf, sizeof mybuf, "%XH.%s%s", 1045 (u_int32_t)ntohl(net.long_e), host, cport); 1046 return (mybuf); 1047 } 1048 1049 static void 1050 interfaces() 1051 { 1052 size_t needed; 1053 int mib[6]; 1054 char *buf, *lim, *next; 1055 register struct rt_msghdr *rtm; 1056 1057 mib[0] = CTL_NET; 1058 mib[1] = PF_ROUTE; 1059 mib[2] = 0; /* protocol */ 1060 mib[3] = 0; /* wildcard address family */ 1061 mib[4] = NET_RT_IFLIST; 1062 mib[5] = 0; /* no flags */ 1063 if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) 1064 quit("route-sysctl-estimate"); 1065 if ((buf = malloc(needed)) == NULL) 1066 quit("malloc"); 1067 if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) 1068 quit("actual retrieval of interface table"); 1069 lim = buf + needed; 1070 for (next = buf; next < lim; next += rtm->rtm_msglen) { 1071 rtm = (struct rt_msghdr *)next; 1072 print_rtmsg(rtm, rtm->rtm_msglen); 1073 } 1074 } 1075 1076 static void 1077 monitor() 1078 { 1079 int n; 1080 char msg[2048]; 1081 1082 verbose = 1; 1083 if (debugonly) { 1084 interfaces(); 1085 exit(0); 1086 } 1087 for(;;) { 1088 n = read(s, msg, 2048); 1089 (void) printf("got message of size %d\n", n); 1090 print_rtmsg((struct rt_msghdr *)msg, n); 1091 } 1092 } 1093 1094 #endif /* SMALL */ 1095 1096 1097 struct { 1098 struct rt_msghdr m_rtm; 1099 char m_space[512]; 1100 } m_rtmsg; 1101 1102 static int 1103 rtmsg(cmd, flags) 1104 int cmd, flags; 1105 { 1106 static int seq; 1107 int rlen; 1108 register char *cp = m_rtmsg.m_space; 1109 register int l; 1110 1111 #define NEXTADDR(w, u) \ 1112 if (rtm_addrs & (w)) {\ 1113 l = ROUNDUP(u.sa.sa_len); memcpy(cp, &(u), l); cp += l;\ 1114 if (verbose) sodump(&(u),"u");\ 1115 } 1116 1117 errno = 0; 1118 memset(&m_rtmsg, 0, sizeof(m_rtmsg)); 1119 if (cmd == 'a') 1120 cmd = RTM_ADD; 1121 else if (cmd == 'c') 1122 cmd = RTM_CHANGE; 1123 else if (cmd == 'g') { 1124 #ifdef SMALL 1125 return (-1); 1126 #else /* SMALL */ 1127 cmd = RTM_GET; 1128 if (so_ifp.sa.sa_family == 0) { 1129 so_ifp.sa.sa_family = AF_LINK; 1130 so_ifp.sa.sa_len = sizeof(struct sockaddr_dl); 1131 rtm_addrs |= RTA_IFP; 1132 } 1133 #endif /* SMALL */ 1134 } else 1135 cmd = RTM_DELETE; 1136 #define rtm m_rtmsg.m_rtm 1137 rtm.rtm_type = cmd; 1138 rtm.rtm_flags = flags; 1139 rtm.rtm_version = RTM_VERSION; 1140 rtm.rtm_seq = ++seq; 1141 rtm.rtm_addrs = rtm_addrs; 1142 rtm.rtm_rmx = rt_metrics; 1143 rtm.rtm_inits = rtm_inits; 1144 1145 if (rtm_addrs & RTA_NETMASK) 1146 mask_addr(); 1147 NEXTADDR(RTA_DST, so_dst); 1148 NEXTADDR(RTA_GATEWAY, so_gate); 1149 NEXTADDR(RTA_NETMASK, so_mask); 1150 NEXTADDR(RTA_GENMASK, so_genmask); 1151 NEXTADDR(RTA_IFP, so_ifp); 1152 NEXTADDR(RTA_IFA, so_ifa); 1153 rtm.rtm_msglen = l = cp - (char *)&m_rtmsg; 1154 if (verbose) 1155 print_rtmsg(&rtm, l); 1156 if (debugonly) 1157 return (0); 1158 if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) { 1159 perror("writing to routing socket"); 1160 return (-1); 1161 } 1162 #ifndef SMALL 1163 if (cmd == RTM_GET) { 1164 do { 1165 l = read(s, (char *)&m_rtmsg, sizeof(m_rtmsg)); 1166 } while (l > 0 && (rtm.rtm_seq != seq || rtm.rtm_pid != pid)); 1167 if (l < 0) 1168 (void) fprintf(stderr, 1169 "route: read from routing socket: %s\n", 1170 strerror(errno)); 1171 else 1172 print_getmsg(&rtm, l); 1173 } 1174 #endif /* SMALL */ 1175 #undef rtm 1176 return (0); 1177 } 1178 1179 static void 1180 mask_addr() 1181 { 1182 int olen = so_mask.sa.sa_len; 1183 register char *cp1 = olen + (char *)&so_mask, *cp2; 1184 1185 for (so_mask.sa.sa_len = 0; cp1 > (char *)&so_mask; ) 1186 if (*--cp1 != 0) { 1187 so_mask.sa.sa_len = 1 + cp1 - (char *)&so_mask; 1188 break; 1189 } 1190 if ((rtm_addrs & RTA_DST) == 0) 1191 return; 1192 switch (so_dst.sa.sa_family) { 1193 case AF_NS: 1194 case AF_INET: 1195 case AF_CCITT: 1196 case AF_APPLETALK: 1197 case 0: 1198 return; 1199 case AF_ISO: 1200 olen = MIN(so_dst.siso.siso_nlen, 1201 MAX(so_mask.sa.sa_len - 6, 0)); 1202 break; 1203 } 1204 cp1 = so_mask.sa.sa_len + 1 + (char *)&so_dst; 1205 cp2 = so_dst.sa.sa_len + 1 + (char *)&so_dst; 1206 while (cp2 > cp1) 1207 *--cp2 = 0; 1208 cp2 = so_mask.sa.sa_len + 1 + (char *)&so_mask; 1209 while (cp1 > so_dst.sa.sa_data) 1210 *--cp1 &= *--cp2; 1211 switch (so_dst.sa.sa_family) { 1212 case AF_ISO: 1213 so_dst.siso.siso_nlen = olen; 1214 break; 1215 } 1216 } 1217 1218 char *msgtypes[] = { 1219 "", 1220 "RTM_ADD: Add Route", 1221 "RTM_DELETE: Delete Route", 1222 "RTM_CHANGE: Change Metrics or flags", 1223 "RTM_GET: Report Metrics", 1224 "RTM_LOSING: Kernel Suspects Partitioning", 1225 "RTM_REDIRECT: Told to use different route", 1226 "RTM_MISS: Lookup failed on this address", 1227 "RTM_LOCK: fix specified metrics", 1228 "RTM_OLDADD: caused by SIOCADDRT", 1229 "RTM_OLDDEL: caused by SIOCDELRT", 1230 "RTM_RESOLVE: Route created by cloning", 1231 "RTM_NEWADDR: address being added to iface", 1232 "RTM_DELADDR: address being removed from iface", 1233 "RTM_IFINFO: iface status change", 1234 0, 1235 }; 1236 1237 char metricnames[] = 1238 "\011pksent\010rttvar\7rtt\6ssthresh\5sendpipe\4recvpipe\3expire\2hopcount\1mtu"; 1239 char routeflags[] = 1240 "\1UP\2GATEWAY\3HOST\4REJECT\5DYNAMIC\6MODIFIED\7DONE\010MASK_PRESENT\011CLONING\012XRESOLVE\013LLINFO\014STATIC\017PROTO2\020PROTO1"; 1241 char ifnetflags[] = 1242 "\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5PTP\6NOTRAILERS\7RUNNING\010NOARP\011PPROMISC\012ALLMULTI\013OACTIVE\014SIMPLEX\015LINK0\016LINK1\017LINK2\020MULTICAST"; 1243 char addrnames[] = 1244 "\1DST\2GATEWAY\3NETMASK\4GENMASK\5IFP\6IFA\7AUTHOR\010BRD"; 1245 1246 static void 1247 print_rtmsg(rtm, msglen) 1248 register struct rt_msghdr *rtm; 1249 int msglen; 1250 { 1251 struct if_msghdr *ifm; 1252 struct ifa_msghdr *ifam; 1253 1254 if (verbose == 0) 1255 return; 1256 if (rtm->rtm_version != RTM_VERSION) { 1257 (void) printf("routing message version %d not understood\n", 1258 rtm->rtm_version); 1259 return; 1260 } 1261 (void)printf("%s: len %d, ", msgtypes[rtm->rtm_type], rtm->rtm_msglen); 1262 switch (rtm->rtm_type) { 1263 case RTM_IFINFO: 1264 ifm = (struct if_msghdr *)rtm; 1265 (void) printf("if# %d, flags:", ifm->ifm_index); 1266 bprintf(stdout, ifm->ifm_flags, ifnetflags); 1267 pmsg_addrs((char *)(ifm + 1), ifm->ifm_addrs); 1268 break; 1269 case RTM_NEWADDR: 1270 case RTM_DELADDR: 1271 ifam = (struct ifa_msghdr *)rtm; 1272 (void) printf("metric %d, flags:", ifam->ifam_metric); 1273 bprintf(stdout, ifam->ifam_flags, routeflags); 1274 pmsg_addrs((char *)(ifam + 1), ifam->ifam_addrs); 1275 break; 1276 default: 1277 (void) printf("pid: %d, seq %d, errno %d, flags:", 1278 rtm->rtm_pid, rtm->rtm_seq, rtm->rtm_errno); 1279 bprintf(stdout, rtm->rtm_flags, routeflags); 1280 pmsg_common(rtm); 1281 } 1282 } 1283 1284 #ifndef SMALL 1285 static void 1286 print_getmsg(rtm, msglen) 1287 register struct rt_msghdr *rtm; 1288 int msglen; 1289 { 1290 struct sockaddr *dst = NULL, *gate = NULL, *mask = NULL; 1291 struct sockaddr_dl *ifp = NULL; 1292 register struct sockaddr *sa; 1293 register char *cp; 1294 register int i; 1295 1296 (void) printf(" route to: %s\n", 1297 routename((struct sockaddr *) &so_dst)); 1298 if (rtm->rtm_version != RTM_VERSION) { 1299 (void)fprintf(stderr, 1300 "routing message version %d not understood\n", 1301 rtm->rtm_version); 1302 return; 1303 } 1304 if (rtm->rtm_msglen > msglen) { 1305 (void)fprintf(stderr, 1306 "message length mismatch, in packet %d, returned %d\n", 1307 rtm->rtm_msglen, msglen); 1308 } 1309 if (rtm->rtm_errno) { 1310 (void) fprintf(stderr, "RTM_GET: %s (errno %d)\n", 1311 strerror(rtm->rtm_errno), rtm->rtm_errno); 1312 return; 1313 } 1314 cp = ((char *)(rtm + 1)); 1315 if (rtm->rtm_addrs) 1316 for (i = 1; i; i <<= 1) 1317 if (i & rtm->rtm_addrs) { 1318 sa = (struct sockaddr *)cp; 1319 switch (i) { 1320 case RTA_DST: 1321 dst = sa; 1322 break; 1323 case RTA_GATEWAY: 1324 gate = sa; 1325 break; 1326 case RTA_NETMASK: 1327 mask = sa; 1328 break; 1329 case RTA_IFP: 1330 if (sa->sa_family == AF_LINK && 1331 ((struct sockaddr_dl *)sa)->sdl_nlen) 1332 ifp = (struct sockaddr_dl *)sa; 1333 break; 1334 } 1335 ADVANCE(cp, sa); 1336 } 1337 if (dst && mask) 1338 mask->sa_family = dst->sa_family; /* XXX */ 1339 if (dst) 1340 (void)printf("destination: %s\n", routename(dst)); 1341 if (mask) { 1342 int savenflag = nflag; 1343 1344 nflag = 1; 1345 (void)printf(" mask: %s\n", routename(mask)); 1346 nflag = savenflag; 1347 } 1348 if (gate && rtm->rtm_flags & RTF_GATEWAY) 1349 (void)printf(" gateway: %s\n", routename(gate)); 1350 if (ifp) 1351 (void)printf(" interface: %.*s\n", 1352 ifp->sdl_nlen, ifp->sdl_data); 1353 (void)printf(" flags: "); 1354 bprintf(stdout, rtm->rtm_flags, routeflags); 1355 1356 #define lock(f) ((rtm->rtm_rmx.rmx_locks & __CONCAT(RTV_,f)) ? 'L' : ' ') 1357 #define msec(u) (((u) + 500) / 1000) /* usec to msec */ 1358 1359 (void) printf("\n%s\n", "\ 1360 recvpipe sendpipe ssthresh rtt,msec rttvar hopcount mtu expire"); 1361 printf("%8ld%c ", rtm->rtm_rmx.rmx_recvpipe, lock(RPIPE)); 1362 printf("%8ld%c ", rtm->rtm_rmx.rmx_sendpipe, lock(SPIPE)); 1363 printf("%8ld%c ", rtm->rtm_rmx.rmx_ssthresh, lock(SSTHRESH)); 1364 printf("%8ld%c ", msec(rtm->rtm_rmx.rmx_rtt), lock(RTT)); 1365 printf("%8ld%c ", msec(rtm->rtm_rmx.rmx_rttvar), lock(RTTVAR)); 1366 printf("%8ld%c ", rtm->rtm_rmx.rmx_hopcount, lock(HOPCOUNT)); 1367 printf("%8ld%c ", rtm->rtm_rmx.rmx_mtu, lock(MTU)); 1368 if (rtm->rtm_rmx.rmx_expire) 1369 rtm->rtm_rmx.rmx_expire -= time(0); 1370 printf("%8ld%c\n", rtm->rtm_rmx.rmx_expire, lock(EXPIRE)); 1371 #undef lock 1372 #undef msec 1373 #define RTA_IGN (RTA_DST|RTA_GATEWAY|RTA_NETMASK|RTA_IFP|RTA_IFA|RTA_BRD) 1374 if (verbose) 1375 pmsg_common(rtm); 1376 else if (rtm->rtm_addrs &~ RTA_IGN) { 1377 (void) printf("sockaddrs: "); 1378 bprintf(stdout, rtm->rtm_addrs, addrnames); 1379 putchar('\n'); 1380 } 1381 #undef RTA_IGN 1382 } 1383 #endif /* SMALL */ 1384 1385 void 1386 pmsg_common(rtm) 1387 register struct rt_msghdr *rtm; 1388 { 1389 (void) printf("\nlocks: "); 1390 bprintf(stdout, rtm->rtm_rmx.rmx_locks, metricnames); 1391 (void) printf(" inits: "); 1392 bprintf(stdout, rtm->rtm_inits, metricnames); 1393 pmsg_addrs(((char *)(rtm + 1)), rtm->rtm_addrs); 1394 } 1395 1396 static void 1397 pmsg_addrs(cp, addrs) 1398 char *cp; 1399 int addrs; 1400 { 1401 register struct sockaddr *sa; 1402 int i; 1403 1404 if (addrs == 0) 1405 return; 1406 (void) printf("\nsockaddrs: "); 1407 bprintf(stdout, addrs, addrnames); 1408 (void) putchar('\n'); 1409 for (i = 1; i; i <<= 1) 1410 if (i & addrs) { 1411 sa = (struct sockaddr *)cp; 1412 (void) printf(" %s", routename(sa)); 1413 ADVANCE(cp, sa); 1414 } 1415 (void) putchar('\n'); 1416 (void) fflush(stdout); 1417 } 1418 1419 static void 1420 bprintf(fp, b, s) 1421 register FILE *fp; 1422 register int b; 1423 register u_char *s; 1424 { 1425 register int i; 1426 int gotsome = 0; 1427 1428 if (b == 0) 1429 return; 1430 while ((i = *s++) != 0) { 1431 if (b & (1 << (i-1))) { 1432 if (gotsome == 0) 1433 i = '<'; 1434 else 1435 i = ','; 1436 (void) putc(i, fp); 1437 gotsome = 1; 1438 for (; (i = *s) > 32; s++) 1439 (void) putc(i, fp); 1440 } else 1441 while (*s > 32) 1442 s++; 1443 } 1444 if (gotsome) 1445 (void) putc('>', fp); 1446 } 1447 1448 static int 1449 keyword(cp) 1450 char *cp; 1451 { 1452 register struct keytab *kt = keywords; 1453 1454 while (kt->kt_cp && strcmp(kt->kt_cp, cp)) 1455 kt++; 1456 return kt->kt_i; 1457 } 1458 1459 static void 1460 sodump(su, which) 1461 register sup su; 1462 char *which; 1463 { 1464 switch (su->sa.sa_family) { 1465 case AF_INET: 1466 (void) printf("%s: inet %s; ", 1467 which, inet_ntoa(su->sin.sin_addr)); 1468 break; 1469 case AF_APPLETALK: 1470 (void) printf("%s: atalk %d.%d; ", 1471 which, su->sat.sat_addr.s_net, su->sat.sat_addr.s_node); 1472 break; 1473 case AF_LINK: 1474 (void) printf("%s: link %s; ", 1475 which, link_ntoa(&su->sdl)); 1476 break; 1477 #ifndef SMALL 1478 case AF_ISO: 1479 (void) printf("%s: iso %s; ", 1480 which, iso_ntoa(&su->siso.siso_addr)); 1481 break; 1482 case AF_NS: 1483 (void) printf("%s: xns %s; ", 1484 which, ns_ntoa(su->sns.sns_addr)); 1485 break; 1486 #endif /* SMALL */ 1487 default: 1488 (void) printf("af %p: %s; ", 1489 which, any_ntoa(&su->sa)); 1490 } 1491 (void) fflush(stdout); 1492 } 1493 1494 /* States*/ 1495 #define VIRGIN 0 1496 #define GOTONE 1 1497 #define GOTTWO 2 1498 /* Inputs */ 1499 #define DIGIT (4*0) 1500 #define END (4*1) 1501 #define DELIM (4*2) 1502 1503 static void 1504 sockaddr(addr, sa) 1505 register char *addr; 1506 register struct sockaddr *sa; 1507 { 1508 register char *cp = (char *)sa; 1509 int size = sa->sa_len; 1510 char *cplim = cp + size; 1511 register int byte = 0, state = VIRGIN, new = 0; 1512 1513 (void) memset(cp, 0, size); 1514 cp++; 1515 do { 1516 if ((*addr >= '0') && (*addr <= '9')) { 1517 new = *addr - '0'; 1518 } else if ((*addr >= 'a') && (*addr <= 'f')) { 1519 new = *addr - 'a' + 10; 1520 } else if ((*addr >= 'A') && (*addr <= 'F')) { 1521 new = *addr - 'A' + 10; 1522 } else if (*addr == 0) 1523 state |= END; 1524 else 1525 state |= DELIM; 1526 addr++; 1527 switch (state /* | INPUT */) { 1528 case GOTTWO | DIGIT: 1529 *cp++ = byte; /*FALLTHROUGH*/ 1530 case VIRGIN | DIGIT: 1531 state = GOTONE; byte = new; continue; 1532 case GOTONE | DIGIT: 1533 state = GOTTWO; byte = new + (byte << 4); continue; 1534 default: /* | DELIM */ 1535 state = VIRGIN; *cp++ = byte; byte = 0; continue; 1536 case GOTONE | END: 1537 case GOTTWO | END: 1538 *cp++ = byte; /* FALLTHROUGH */ 1539 case VIRGIN | END: 1540 break; 1541 } 1542 break; 1543 } while (cp < cplim); 1544 sa->sa_len = cp - (char *)sa; 1545 } 1546
Indexes created Sat Sep 27 14:09:57 GMT 2025