route.c revision 1.38
1 /* $NetBSD: route.c,v 1.38 1999/07/01 18:40:36 itojun Exp $ */ 2 3 /* 4 * Copyright (c) 1983, 1988, 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 #include <sys/cdefs.h> 37 #ifndef lint 38 #if 0 39 static char sccsid[] = "from: @(#)route.c 8.3 (Berkeley) 3/9/94"; 40 #else 41 __RCSID("$NetBSD: route.c,v 1.38 1999/07/01 18:40:36 itojun Exp $"); 42 #endif 43 #endif /* not lint */ 44 45 #include <sys/param.h> 46 #include <sys/protosw.h> 47 #include <sys/socket.h> 48 #include <sys/mbuf.h> 49 #include <sys/un.h> 50 51 #include <net/if.h> 52 #include <net/if_dl.h> 53 #include <net/if_types.h> 54 #define _KERNEL 55 #include <net/route.h> 56 #undef _KERNEL 57 #include <netinet/in.h> 58 #include <netatalk/at.h> 59 #include <netiso/iso.h> 60 61 #include <netns/ns.h> 62 63 #include <sys/sysctl.h> 64 65 #include <arpa/inet.h> 66 67 #include <err.h> 68 #include <netdb.h> 69 #include <stdio.h> 70 #include <stdlib.h> 71 #include <string.h> 72 #include <unistd.h> 73 74 #include "netstat.h" 75 76 #define kget(p, d) (kread((u_long)(p), (char *)&(d), sizeof (d))) 77 78 /* 79 * Definitions for showing gateway flags. 80 */ 81 struct bits { 82 short b_mask; 83 char b_val; 84 } bits[] = { 85 { RTF_UP, 'U' }, 86 { RTF_GATEWAY, 'G' }, 87 { RTF_HOST, 'H' }, 88 { RTF_REJECT, 'R' }, 89 { RTF_DYNAMIC, 'D' }, 90 { RTF_MODIFIED, 'M' }, 91 { RTF_DONE, 'd' }, /* Completed -- for routing messages only */ 92 { RTF_MASK, 'm' }, /* Mask Present -- for routing messages only */ 93 { RTF_CLONING, 'C' }, 94 { RTF_XRESOLVE, 'X' }, 95 { RTF_LLINFO, 'L' }, 96 { RTF_STATIC, 'S' }, 97 { RTF_PROTO1, '1' }, 98 { RTF_PROTO2, '2' }, 99 { 0 } 100 }; 101 102 /* 103 * XXX we put all of the sockaddr types in here to force the alignment 104 * to be correct. 105 */ 106 static union sockaddr_union { 107 struct sockaddr u_sa; 108 struct sockaddr_in u_in; 109 struct sockaddr_un u_un; 110 struct sockaddr_iso u_iso; 111 struct sockaddr_at u_at; 112 struct sockaddr_dl u_dl; 113 struct sockaddr_ns u_ns; 114 u_short u_data[128]; 115 int u_dummy; /* force word-alignment */ 116 } pt_u; 117 118 int do_rtent = 0; 119 struct rtentry rtentry; 120 struct radix_node rnode; 121 struct radix_mask rmask; 122 123 int NewTree = 0; 124 125 static struct sockaddr *kgetsa __P((struct sockaddr *)); 126 static void p_tree __P((struct radix_node *)); 127 static void p_rtnode __P((void)); 128 static void ntreestuff __P((void)); 129 static void np_rtentry __P((struct rt_msghdr *)); 130 static void p_sockaddr __P((const struct sockaddr *, 131 const struct sockaddr *, int, int)); 132 static void p_flags __P((int, char *)); 133 static void p_rtentry __P((struct rtentry *)); 134 static void ntreestuff __P((void)); 135 static u_long forgemask __P((u_long)); 136 static void domask __P((char *, size_t, u_long, u_long)); 137 #ifdef INET6 138 char *netname6 __P((struct in6_addr *, struct in6_addr *)); 139 static char ntop_buf[INET6_ADDRSTRLEN]; 140 #endif 141 142 /* 143 * Print routing tables. 144 */ 145 void 146 routepr(rtree) 147 u_long rtree; 148 { 149 struct radix_node_head *rnh, head; 150 int i; 151 152 printf("Routing tables\n"); 153 154 if (Aflag == 0 && NewTree) 155 ntreestuff(); 156 else { 157 if (rtree == 0) { 158 printf("rt_tables: symbol not in namelist\n"); 159 return; 160 } 161 162 kget(rtree, rt_tables); 163 for (i = 0; i <= AF_MAX; i++) { 164 if ((rnh = rt_tables[i]) == 0) 165 continue; 166 kget(rnh, head); 167 if (i == AF_UNSPEC) { 168 if (Aflag && af == 0) { 169 printf("Netmasks:\n"); 170 p_tree(head.rnh_treetop); 171 } 172 } else if (af == AF_UNSPEC || af == i) { 173 pr_family(i); 174 do_rtent = 1; 175 pr_rthdr(); 176 p_tree(head.rnh_treetop); 177 } 178 } 179 } 180 } 181 182 /* 183 * Print address family header before a section of the routing table. 184 */ 185 void 186 pr_family(af) 187 int af; 188 { 189 char *afname; 190 191 switch (af) { 192 case AF_INET: 193 afname = "Internet"; 194 break; 195 #ifdef INET6 196 case AF_INET6: 197 afname = "Internet6"; 198 break; 199 #endif 200 case AF_NS: 201 afname = "XNS"; 202 break; 203 case AF_ISO: 204 afname = "ISO"; 205 break; 206 case AF_APPLETALK: 207 afname = "AppleTalk"; 208 break; 209 case AF_CCITT: 210 afname = "X.25"; 211 break; 212 default: 213 afname = NULL; 214 break; 215 } 216 if (afname) 217 printf("\n%s:\n", afname); 218 else 219 printf("\nProtocol Family %d:\n", af); 220 } 221 222 /* column widths; each followed by one space */ 223 #ifndef INET6 224 #define WID_DST 18 /* width of destination column */ 225 #define WID_GW 18 /* width of gateway column */ 226 #else 227 #define WID_DST (nflag ? 28 : 18) /* width of destination column */ 228 #define WID_GW (nflag ? 26 : 18) /* width of gateway column */ 229 #endif /* INET6 */ 230 231 /* 232 * Print header for routing table columns. 233 */ 234 void 235 pr_rthdr() 236 { 237 238 if (Aflag) 239 printf("%-8.8s ","Address"); 240 printf("%-*.*s %-*.*s %-6.6s %6.6s%8.8s %6.6s %s\n", 241 WID_DST, WID_DST, "Destination", 242 WID_GW, WID_GW, "Gateway", 243 "Flags", "Refs", "Use", "Mtu", "Interface"); 244 } 245 246 static struct sockaddr * 247 kgetsa(dst) 248 struct sockaddr *dst; 249 { 250 251 kget(dst, pt_u.u_sa); 252 if (pt_u.u_sa.sa_len > sizeof (pt_u.u_sa)) 253 kread((u_long)dst, (char *)pt_u.u_data, pt_u.u_sa.sa_len); 254 return (&pt_u.u_sa); 255 } 256 257 static void 258 p_tree(rn) 259 struct radix_node *rn; 260 { 261 262 again: 263 kget(rn, rnode); 264 if (rnode.rn_b < 0) { 265 if (Aflag) 266 printf("%-8.8lx ", (u_long) rn); 267 if (rnode.rn_flags & RNF_ROOT) { 268 if (Aflag) 269 printf("(root node)%s", 270 rnode.rn_dupedkey ? " =>\n" : "\n"); 271 } else if (do_rtent) { 272 kget(rn, rtentry); 273 p_rtentry(&rtentry); 274 if (Aflag) 275 p_rtnode(); 276 } else { 277 p_sockaddr(kgetsa((struct sockaddr *)rnode.rn_key), 278 NULL, 0, 44); 279 putchar('\n'); 280 } 281 if ((rn = rnode.rn_dupedkey) != NULL) 282 goto again; 283 } else { 284 if (Aflag && do_rtent) { 285 printf("%-8.8lx ", (u_long) rn); 286 p_rtnode(); 287 } 288 rn = rnode.rn_r; 289 p_tree(rnode.rn_l); 290 p_tree(rn); 291 } 292 } 293 294 static void 295 p_rtnode() 296 { 297 struct radix_mask *rm = rnode.rn_mklist; 298 char nbuf[20]; 299 300 if (rnode.rn_b < 0) { 301 if (rnode.rn_mask) { 302 printf("\t mask "); 303 p_sockaddr(kgetsa((struct sockaddr *)rnode.rn_mask), 304 NULL, 0, -1); 305 } else if (rm == 0) 306 return; 307 } else { 308 (void)snprintf(nbuf, sizeof nbuf, "(%d)", rnode.rn_b); 309 printf("%6.6s %8.8lx : %8.8lx", nbuf, (u_long) rnode.rn_l, 310 (u_long) rnode.rn_r); 311 } 312 while (rm) { 313 kget(rm, rmask); 314 (void)snprintf(nbuf, sizeof nbuf, " %d refs, ", rmask.rm_refs); 315 printf(" mk = %8.8lx {(%d),%s", (u_long) rm, 316 -1 - rmask.rm_b, rmask.rm_refs ? nbuf : " "); 317 if (rmask.rm_flags & RNF_NORMAL) { 318 struct radix_node rnode_aux; 319 printf(" <normal>, "); 320 kget(rmask.rm_leaf, rnode_aux); 321 p_sockaddr(kgetsa((struct sockaddr *)rnode_aux.rn_mask), 322 NULL, 0, -1); 323 } else 324 p_sockaddr(kgetsa((struct sockaddr *)rmask.rm_mask), 325 NULL, 0, -1); 326 putchar('}'); 327 if ((rm = rmask.rm_mklist) != NULL) 328 printf(" ->"); 329 } 330 putchar('\n'); 331 } 332 333 static void 334 ntreestuff() 335 { 336 size_t needed; 337 int mib[6]; 338 char *buf, *next, *lim; 339 struct rt_msghdr *rtm; 340 341 mib[0] = CTL_NET; 342 mib[1] = PF_ROUTE; 343 mib[2] = 0; 344 mib[3] = 0; 345 mib[4] = NET_RT_DUMP; 346 mib[5] = 0; 347 if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) 348 err(1, "route sysctl estimate"); 349 if ((buf = malloc(needed)) == 0) 350 errx(1, "out of space"); 351 if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) 352 err(1, "sysctl of routing table"); 353 lim = buf + needed; 354 for (next = buf; next < lim; next += rtm->rtm_msglen) { 355 rtm = (struct rt_msghdr *)next; 356 np_rtentry(rtm); 357 } 358 } 359 360 static void 361 np_rtentry(rtm) 362 struct rt_msghdr *rtm; 363 { 364 struct sockaddr *sa = (struct sockaddr *)(rtm + 1); 365 #ifdef notdef 366 static int masks_done, banner_printed; 367 #endif 368 static int old_af; 369 int af = 0, interesting = RTF_UP | RTF_GATEWAY | RTF_HOST; 370 371 #ifdef notdef 372 /* for the moment, netmasks are skipped over */ 373 if (!banner_printed) { 374 printf("Netmasks:\n"); 375 banner_printed = 1; 376 } 377 if (masks_done == 0) { 378 if (rtm->rtm_addrs != RTA_DST ) { 379 masks_done = 1; 380 af = sa->sa_family; 381 } 382 } else 383 #endif 384 af = sa->sa_family; 385 if (af != old_af) { 386 pr_family(af); 387 old_af = af; 388 } 389 if (rtm->rtm_addrs == RTA_DST) 390 p_sockaddr(sa, NULL, 0, 36); 391 else { 392 p_sockaddr(sa, NULL, rtm->rtm_flags, 16); 393 if (sa->sa_len == 0) 394 sa->sa_len = sizeof(long); 395 sa = (struct sockaddr *)(sa->sa_len + (char *)sa); 396 p_sockaddr(sa, NULL, 0, 18); 397 } 398 p_flags(rtm->rtm_flags & interesting, "%-6.6s "); 399 putchar('\n'); 400 } 401 402 static void 403 p_sockaddr(sa, mask, flags, width) 404 const struct sockaddr *sa, *mask; 405 int flags, width; 406 { 407 char workbuf[128], *cplim; 408 char *cp = workbuf; 409 410 switch(sa->sa_family) { 411 case AF_INET: 412 { 413 struct sockaddr_in *sin = (struct sockaddr_in *)sa; 414 415 if (sin->sin_addr.s_addr == INADDR_ANY) 416 cp = "default"; 417 else if (flags & RTF_HOST) 418 cp = routename(sin->sin_addr.s_addr); 419 else if (mask) 420 cp = netname(sin->sin_addr.s_addr, 421 ((struct sockaddr_in *)mask)->sin_addr.s_addr); 422 else 423 cp = netname(sin->sin_addr.s_addr, INADDR_ANY); 424 break; 425 } 426 427 #ifdef INET6 428 case AF_INET6: 429 { 430 struct in6_addr *in6 = &((struct sockaddr_in6 *)sa)->sin6_addr; 431 432 if (flags & RTF_HOST) 433 cp = routename6((char *)in6); 434 else if (mask) { 435 cp = netname6(in6, 436 &((struct sockaddr_in6 *)mask)->sin6_addr); 437 } else 438 cp = (char *)inet_ntop(AF_INET6, in6, ntop_buf, 439 sizeof(ntop_buf)); 440 break; 441 } 442 #endif 443 444 #ifndef SMALL 445 case AF_APPLETALK: 446 case 0: 447 { 448 if (!(flags & RTF_HOST) && mask) 449 cp = atalk_print2(sa,mask,11); 450 else 451 cp = atalk_print(sa,11); 452 break; 453 } 454 case AF_NS: 455 cp = ns_print((struct sockaddr *)sa); 456 break; 457 #endif 458 459 case AF_LINK: 460 { 461 struct sockaddr_dl *sdl = (struct sockaddr_dl *)sa; 462 463 if (sdl->sdl_nlen == 0 && sdl->sdl_alen == 0 && 464 sdl->sdl_slen == 0) 465 (void)snprintf(workbuf, sizeof workbuf, "link#%d", 466 sdl->sdl_index); 467 else switch (sdl->sdl_type) { 468 case IFT_FDDI: 469 case IFT_ETHER: 470 { 471 int i; 472 u_char *lla = (u_char *)sdl->sdl_data + 473 sdl->sdl_nlen; 474 475 cplim = ""; 476 for (i = 0; i < sdl->sdl_alen; i++, lla++) { 477 /* XXX */ 478 cp += sprintf(cp, "%s%02x", cplim, *lla); 479 cplim = ":"; 480 } 481 cp = workbuf; 482 break; 483 } 484 default: 485 cp = link_ntoa(sdl); 486 break; 487 } 488 break; 489 } 490 491 default: 492 { 493 u_char *s = (u_char *)sa->sa_data, *slim; 494 495 slim = sa->sa_len + (u_char *) sa; 496 cplim = cp + sizeof(workbuf) - 6; 497 cp += sprintf(cp, "(%d)", sa->sa_family); 498 while (s < slim && cp < cplim) { 499 cp += sprintf(cp, " %02x", *s++); 500 if (s < slim) 501 cp += sprintf(cp, "%02x", *s++); 502 } 503 cp = workbuf; 504 } 505 } 506 if (width < 0 ) 507 printf("%s ", cp); 508 else { 509 if (nflag) 510 printf("%-*s ", width, cp); 511 else 512 printf("%-*.*s ", width, width, cp); 513 } 514 } 515 516 static void 517 p_flags(f, format) 518 int f; 519 char *format; 520 { 521 char name[33], *flags; 522 struct bits *p = bits; 523 524 for (flags = name; p->b_mask && flags - name < sizeof(name); p++) 525 if (p->b_mask & f) 526 *flags++ = p->b_val; 527 *flags = '\0'; 528 printf(format, name); 529 } 530 531 static struct sockaddr *sockcopy __P((struct sockaddr *, 532 union sockaddr_union *)); 533 534 /* 535 * copy a sockaddr into an allocated region, allocate at least sockaddr 536 * bytes and zero unused 537 */ 538 static struct sockaddr * 539 sockcopy(sp, dp) 540 struct sockaddr *sp; 541 union sockaddr_union *dp; 542 { 543 int len; 544 545 if (sp == 0 || sp->sa_len == 0) 546 (void)memset(dp, 0, sizeof (*sp)); 547 else { 548 len = (sp->sa_len >= sizeof (*sp)) ? sp->sa_len : sizeof (*sp); 549 (void)memcpy(dp, sp, len); 550 } 551 return ((struct sockaddr *)dp); 552 } 553 554 static void 555 p_rtentry(rt) 556 struct rtentry *rt; 557 { 558 static struct ifnet ifnet, *lastif; 559 union sockaddr_union addr_un, mask_un; 560 struct sockaddr *addr, *mask; 561 562 memset(&addr_un, 0, sizeof(addr_un)); 563 memset(&mask_un, 0, sizeof(mask_un)); 564 addr = sockcopy(kgetsa(rt_key(rt)), &addr_un); 565 if (rt_mask(rt)) 566 mask = sockcopy(kgetsa(rt_mask(rt)), &mask_un); 567 else 568 mask = sockcopy(NULL, &mask_un); 569 p_sockaddr(addr, mask, rt->rt_flags, WID_DST); 570 p_sockaddr(kgetsa(rt->rt_gateway), NULL, RTF_HOST, WID_GW); 571 p_flags(rt->rt_flags, "%-6.6s "); 572 printf("%6d %8lu ", rt->rt_refcnt, rt->rt_use); 573 if (rt->rt_rmx.rmx_mtu) 574 printf("%6lu", rt->rt_rmx.rmx_mtu); 575 else 576 printf("%6s", "-"); 577 putchar((rt->rt_rmx.rmx_locks & RTV_MTU) ? 'L' : ' '); 578 if (rt->rt_ifp) { 579 if (rt->rt_ifp != lastif) { 580 kget(rt->rt_ifp, ifnet); 581 lastif = rt->rt_ifp; 582 } 583 printf(" %.16s%s", ifnet.if_xname, 584 rt->rt_nodes[0].rn_dupedkey ? " =>" : ""); 585 } 586 putchar('\n'); 587 if (vflag) { 588 printf("\texpire %10lu%c recvpipe %10ld%c " 589 "sendpipe %10ld%c\n", 590 rt->rt_rmx.rmx_expire, 591 (rt->rt_rmx.rmx_locks & RTV_EXPIRE) ? 'L' : ' ', 592 rt->rt_rmx.rmx_recvpipe, 593 (rt->rt_rmx.rmx_locks & RTV_RPIPE) ? 'L' : ' ', 594 rt->rt_rmx.rmx_sendpipe, 595 (rt->rt_rmx.rmx_locks & RTV_SPIPE) ? 'L' : ' '); 596 printf("\tssthresh %10lu%c rtt %10ld%c " 597 "rttvar %10ld%c\n", 598 rt->rt_rmx.rmx_ssthresh, 599 (rt->rt_rmx.rmx_locks & RTV_SSTHRESH) ? 'L' : ' ', 600 rt->rt_rmx.rmx_rtt, 601 (rt->rt_rmx.rmx_locks & RTV_RTT) ? 'L' : ' ', 602 rt->rt_rmx.rmx_rttvar, 603 (rt->rt_rmx.rmx_locks & RTV_RTTVAR) ? 'L' : ' '); 604 } 605 606 } 607 608 char * 609 routename(in) 610 u_int32_t in; 611 { 612 char *cp; 613 static char line[MAXHOSTNAMELEN + 1]; 614 struct hostent *hp; 615 static char domain[MAXHOSTNAMELEN + 1]; 616 static int first = 1; 617 618 if (first) { 619 first = 0; 620 if (gethostname(domain, MAXHOSTNAMELEN) == 0) { 621 domain[sizeof(domain) - 1] = '\0'; 622 if ((cp = strchr(domain, '.'))) 623 (void)strcpy(domain, cp + 1); 624 else 625 domain[0] = 0; 626 } else 627 domain[0] = 0; 628 } 629 cp = 0; 630 if (!nflag) { 631 hp = gethostbyaddr((char *)&in, sizeof (struct in_addr), 632 AF_INET); 633 if (hp) { 634 if ((cp = strchr(hp->h_name, '.')) && 635 !strcmp(cp + 1, domain)) 636 *cp = 0; 637 cp = hp->h_name; 638 } 639 } 640 if (cp) { 641 strncpy(line, cp, sizeof(line) - 1); 642 line[sizeof(line) - 1] = '\0'; 643 } else { 644 #define C(x) ((x) & 0xff) 645 in = ntohl(in); 646 snprintf(line, sizeof line, "%u.%u.%u.%u", 647 C(in >> 24), C(in >> 16), C(in >> 8), C(in)); 648 } 649 return (line); 650 } 651 652 static u_long 653 forgemask(a) 654 u_long a; 655 { 656 u_long m; 657 658 if (IN_CLASSA(a)) 659 m = IN_CLASSA_NET; 660 else if (IN_CLASSB(a)) 661 m = IN_CLASSB_NET; 662 else 663 m = IN_CLASSC_NET; 664 return (m); 665 } 666 667 static void 668 domask(dst, dlen, addr, mask) 669 char *dst; 670 size_t dlen; 671 u_long addr, mask; 672 { 673 int b, i; 674 675 if (!mask || (forgemask(addr) == mask)) { 676 *dst = '\0'; 677 return; 678 } 679 i = 0; 680 for (b = 0; b < 32; b++) 681 if (mask & (1 << b)) { 682 int bb; 683 684 i = b; 685 for (bb = b+1; bb < 32; bb++) 686 if (!(mask & (1 << bb))) { 687 i = -1; /* noncontig */ 688 break; 689 } 690 break; 691 } 692 if (i == -1) 693 (void)snprintf(dst, dlen, "&0x%lx", mask); 694 else 695 (void)snprintf(dst, dlen, "/%d", 32-i); 696 } 697 698 /* 699 * Return the name of the network whose address is given. 700 * The address is assumed to be that of a net or subnet, not a host. 701 */ 702 char * 703 netname(in, mask) 704 u_int32_t in, mask; 705 { 706 char *cp = 0; 707 static char line[MAXHOSTNAMELEN + 4]; 708 struct netent *np = 0; 709 u_int32_t net, omask; 710 u_int32_t i; 711 int subnetshift; 712 713 i = ntohl(in); 714 omask = mask = ntohl(mask); 715 if (!nflag && i != INADDR_ANY) { 716 if (mask == INADDR_ANY) { 717 switch (mask = forgemask(i)) { 718 case IN_CLASSA_NET: 719 subnetshift = 8; 720 break; 721 case IN_CLASSB_NET: 722 subnetshift = 8; 723 break; 724 case IN_CLASSC_NET: 725 subnetshift = 4; 726 break; 727 default: 728 abort(); 729 } 730 /* 731 * If there are more bits than the standard mask 732 * would suggest, subnets must be in use. 733 * Guess at the subnet mask, assuming reasonable 734 * width subnet fields. 735 */ 736 while (i &~ mask) 737 mask = (long)mask >> subnetshift; 738 } 739 net = i & mask; 740 /* 741 * Note: shift the hosts bits out in octet units, since 742 * not all versions of getnetbyaddr() do this for us (e.g. 743 * the current `etc/networks' parser). 744 */ 745 while ((mask & 0xff) == 0) 746 mask >>= 8, net >>= 8; 747 np = getnetbyaddr(net, AF_INET); 748 if (np) 749 cp = np->n_name; 750 } 751 if (cp) 752 strncpy(line, cp, sizeof(line) - 1); 753 else if ((i & 0xffffff) == 0) 754 (void)snprintf(line, sizeof line, "%u", C(i >> 24)); 755 else if ((i & 0xffff) == 0) 756 (void)snprintf(line, sizeof line, "%u.%u", C(i >> 24) 757 , C(i >> 16)); 758 else if ((i & 0xff) == 0) 759 (void)snprintf(line, sizeof line, "%u.%u.%u", C(i >> 24), 760 C(i >> 16), C(i >> 8)); 761 else 762 (void)snprintf(line, sizeof line, "%u.%u.%u.%u", C(i >> 24), 763 C(i >> 16), C(i >> 8), C(i)); 764 domask(line + strlen(line), sizeof(line) - strlen(line), i, omask); 765 return (line); 766 } 767 768 #ifdef INET6 769 char * 770 netname6(in6, mask) 771 struct in6_addr *in6; 772 struct in6_addr *mask; 773 { 774 static char line[MAXHOSTNAMELEN + 1]; 775 struct in6_addr net6; 776 u_char *p; 777 u_char *lim; 778 int masklen, final = 0, illegal = 0; 779 780 net6 = *in6; 781 net6.s6_addr32[0] &= mask->s6_addr32[0]; 782 net6.s6_addr32[1] &= mask->s6_addr32[1]; 783 net6.s6_addr32[2] &= mask->s6_addr32[2]; 784 net6.s6_addr32[3] &= mask->s6_addr32[3]; 785 786 masklen = 0; 787 lim = (u_char *)mask + 16; 788 for (p = (u_char *)mask; p < lim; p++) { 789 if (final && *p) { 790 illegal++; 791 continue; 792 } 793 794 switch (*p & 0xff) { 795 case 0xff: 796 masklen += 8; 797 break; 798 case 0xfe: 799 masklen += 7; 800 final++; 801 break; 802 case 0xfc: 803 masklen += 6; 804 final++; 805 break; 806 case 0xf8: 807 masklen += 5; 808 final++; 809 break; 810 case 0xf0: 811 masklen += 4; 812 final++; 813 break; 814 case 0xe0: 815 masklen += 3; 816 final++; 817 break; 818 case 0xc0: 819 masklen += 2; 820 final++; 821 break; 822 case 0x80: 823 masklen += 1; 824 final++; 825 break; 826 case 0x00: 827 final++; 828 break; 829 default: 830 final++; 831 illegal++; 832 break; 833 } 834 } 835 836 if (masklen == 0 && IN6_IS_ADDR_UNSPECIFIED(in6)) 837 return("default"); 838 839 if (illegal) 840 fprintf(stderr, "illegal prefixlen\n"); 841 sprintf(line, "%s/%d", inet_ntop(AF_INET6, &net6, ntop_buf, 842 sizeof(ntop_buf)), 843 masklen); 844 return line; 845 } 846 847 char * 848 routename6(in6) 849 char *in6; 850 { 851 static char line[MAXHOSTNAMELEN + 1]; 852 sprintf(line, "%s", inet_ntop(AF_INET6, in6, ntop_buf, 853 sizeof(ntop_buf))); 854 return line; 855 } 856 #endif /*INET6*/ 857 858 /* 859 * Print routing statistics 860 */ 861 void 862 rt_stats(off) 863 u_long off; 864 { 865 struct rtstat rtstat; 866 867 if (off == 0) { 868 printf("rtstat: symbol not in namelist\n"); 869 return; 870 } 871 kread(off, (char *)&rtstat, sizeof (rtstat)); 872 printf("routing:\n"); 873 printf("\t%u bad routing redirect%s\n", 874 rtstat.rts_badredirect, plural(rtstat.rts_badredirect)); 875 printf("\t%u dynamically created route%s\n", 876 rtstat.rts_dynamic, plural(rtstat.rts_dynamic)); 877 printf("\t%u new gateway%s due to redirects\n", 878 rtstat.rts_newgateway, plural(rtstat.rts_newgateway)); 879 printf("\t%u destination%s found unreachable\n", 880 rtstat.rts_unreach, plural(rtstat.rts_unreach)); 881 printf("\t%u use%s of a wildcard route\n", 882 rtstat.rts_wildcard, plural(rtstat.rts_wildcard)); 883 } 884 short ns_nullh[] = {0,0,0}; 885 short ns_bh[] = {-1,-1,-1}; 886 887 char * 888 ns_print(sa) 889 struct sockaddr *sa; 890 { 891 struct sockaddr_ns *sns = (struct sockaddr_ns*)sa; 892 struct ns_addr work; 893 union { 894 union ns_net net_e; 895 u_long long_e; 896 } net; 897 u_short port; 898 static char mybuf[50], cport[10], chost[25]; 899 char *host = ""; 900 char *p; 901 u_char *q; 902 903 work = sns->sns_addr; 904 port = ntohs(work.x_port); 905 work.x_port = 0; 906 net.net_e = work.x_net; 907 if (ns_nullhost(work) && net.long_e == 0) { 908 if (port ) { 909 (void)snprintf(mybuf, sizeof mybuf, "*.%xH", port); 910 upHex(mybuf); 911 } else 912 (void)snprintf(mybuf, sizeof mybuf, "*.*"); 913 return (mybuf); 914 } 915 916 if (memcmp(ns_bh, work.x_host.c_host, 6) == 0) { 917 host = "any"; 918 } else if (memcmp(ns_nullh, work.x_host.c_host, 6) == 0) { 919 host = "*"; 920 } else { 921 q = work.x_host.c_host; 922 (void)snprintf(chost, sizeof chost, "%02x%02x%02x%02x%02x%02xH", 923 q[0], q[1], q[2], q[3], q[4], q[5]); 924 for (p = chost; *p == '0' && p < chost + 12; p++) 925 continue; 926 host = p; 927 } 928 if (port) 929 (void)snprintf(cport, sizeof cport, ".%xH", htons(port)); 930 else 931 *cport = 0; 932 933 (void)snprintf(mybuf, sizeof mybuf, "%xH.%s%s", (int)ntohl(net.long_e), 934 host, cport); 935 upHex(mybuf); 936 return (mybuf); 937 } 938 939 char * 940 ns_phost(sa) 941 struct sockaddr *sa; 942 { 943 struct sockaddr_ns *sns = (struct sockaddr_ns *)sa; 944 struct sockaddr_ns work; 945 static union ns_net ns_zeronet; 946 char *p; 947 948 work = *sns; 949 work.sns_addr.x_port = 0; 950 work.sns_addr.x_net = ns_zeronet; 951 952 p = ns_print((struct sockaddr *)&work); 953 if (strncmp("0H.", p, 3) == 0) 954 p += 3; 955 return (p); 956 } 957 958 void 959 upHex(p0) 960 char *p0; 961 { 962 char *p = p0; 963 964 for (; *p; p++) 965 switch (*p) { 966 case 'a': 967 case 'b': 968 case 'c': 969 case 'd': 970 case 'e': 971 case 'f': 972 *p += ('A' - 'a'); 973 } 974 } 975
Indexes created Wed Sep 24 05:09:52 GMT 2025