Home | History | Annotate | Line # | Download | only in netstat
route.c revision 1.24.2.2 
      1 /*	$NetBSD: route.c,v 1.24.2.2 1999/01/19 07:33:01 cgd 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.24.2.2 1999/01/19 07:33:01 cgd 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 
     50 #include <net/if.h>
     51 #include <net/if_dl.h>
     52 #include <net/if_types.h>
     53 #define _KERNEL
     54 #include <net/route.h>
     55 #undef _KERNEL
     56 #include <netinet/in.h>
     57 #include <netatalk/at.h>
     58 
     59 #include <netns/ns.h>
     60 
     61 #include <sys/sysctl.h>
     62 
     63 #include <netdb.h>
     64 #include <stdio.h>
     65 #include <stdlib.h>
     66 #include <string.h>
     67 #include <unistd.h>
     68 #include "netstat.h"
     69 
     70 #define kget(p, d) (kread((u_long)(p), (char *)&(d), sizeof (d)))
     71 
     72 /*
     73  * Definitions for showing gateway flags.
     74  */
     75 struct bits {
     76 	short	b_mask;
     77 	char	b_val;
     78 } bits[] = {
     79 	{ RTF_UP,	'U' },
     80 	{ RTF_GATEWAY,	'G' },
     81 	{ RTF_HOST,	'H' },
     82 	{ RTF_REJECT,	'R' },
     83 	{ RTF_DYNAMIC,	'D' },
     84 	{ RTF_MODIFIED,	'M' },
     85 	{ RTF_DONE,	'd' }, /* Completed -- for routing messages only */
     86 	{ RTF_MASK,	'm' }, /* Mask Present -- for routing messages only */
     87 	{ RTF_CLONING,	'C' },
     88 	{ RTF_XRESOLVE,	'X' },
     89 	{ RTF_LLINFO,	'L' },
     90 	{ RTF_STATIC,	'S' },
     91 	{ RTF_PROTO1,	'1' },
     92 	{ RTF_PROTO2,	'2' },
     93 	{ 0 }
     94 };
     95 
     96 static union {
     97 	struct	sockaddr u_sa;
     98 	u_short	u_data[128];
     99 } pt_u;
    100 
    101 int	do_rtent = 0;
    102 struct	rtentry rtentry;
    103 struct	radix_node rnode;
    104 struct	radix_mask rmask;
    105 
    106 int	NewTree = 0;
    107 
    108 static struct sockaddr *kgetsa __P((struct sockaddr *));
    109 static void p_tree __P((struct radix_node *));
    110 static void p_rtnode __P((void));
    111 static void ntreestuff __P((void));
    112 static void np_rtentry __P((struct rt_msghdr *));
    113 static void p_sockaddr __P((const struct sockaddr *,
    114 			    const struct sockaddr *, int, int));
    115 static void p_flags __P((int, char *));
    116 static void p_rtentry __P((struct rtentry *));
    117 static void ntreestuff __P((void));
    118 static u_long forgemask __P((u_long));
    119 static void domask __P((char *, u_long, u_long));
    120 
    121 /*
    122  * Print routing tables.
    123  */
    124 void
    125 routepr(rtree)
    126 	u_long rtree;
    127 {
    128 	struct radix_node_head *rnh, head;
    129 	int i;
    130 
    131 	printf("Routing tables\n");
    132 
    133 	if (Aflag == 0 && NewTree)
    134 		ntreestuff();
    135 	else {
    136 		if (rtree == 0) {
    137 			printf("rt_tables: symbol not in namelist\n");
    138 			return;
    139 		}
    140 
    141 		kget(rtree, rt_tables);
    142 		for (i = 0; i <= AF_MAX; i++) {
    143 			if ((rnh = rt_tables[i]) == 0)
    144 				continue;
    145 			kget(rnh, head);
    146 			if (i == AF_UNSPEC) {
    147 				if (Aflag && af == 0) {
    148 					printf("Netmasks:\n");
    149 					p_tree(head.rnh_treetop);
    150 				}
    151 			} else if (af == AF_UNSPEC || af == i) {
    152 				pr_family(i);
    153 				do_rtent = 1;
    154 				pr_rthdr();
    155 				p_tree(head.rnh_treetop);
    156 			}
    157 		}
    158 	}
    159 }
    160 
    161 /*
    162  * Print address family header before a section of the routing table.
    163  */
    164 void
    165 pr_family(af)
    166 	int af;
    167 {
    168 	char *afname;
    169 
    170 	switch (af) {
    171 	case AF_INET:
    172 		afname = "Internet";
    173 		break;
    174 	case AF_NS:
    175 		afname = "XNS";
    176 		break;
    177 	case AF_ISO:
    178 		afname = "ISO";
    179 		break;
    180 	case AF_APPLETALK:
    181 		afname = "AppleTalk";
    182 		break;
    183 	case AF_CCITT:
    184 		afname = "X.25";
    185 		break;
    186 	default:
    187 		afname = NULL;
    188 		break;
    189 	}
    190 	if (afname)
    191 		printf("\n%s:\n", afname);
    192 	else
    193 		printf("\nProtocol Family %d:\n", af);
    194 }
    195 
    196 /* column widths; each followed by one space */
    197 #define	WID_DST		18	/* width of destination column */
    198 #define	WID_GW		18	/* width of gateway column */
    199 
    200 /*
    201  * Print header for routing table columns.
    202  */
    203 void
    204 pr_rthdr()
    205 {
    206 
    207 	if (Aflag)
    208 		printf("%-8.8s ","Address");
    209 	printf("%-*.*s %-*.*s %-6.6s  %6.6s%8.8s %6.6s  %s\n",
    210 		WID_DST, WID_DST, "Destination",
    211 		WID_GW, WID_GW, "Gateway",
    212 		"Flags", "Refs", "Use", "Mtu", "Interface");
    213 }
    214 
    215 static struct sockaddr *
    216 kgetsa(dst)
    217 	struct sockaddr *dst;
    218 {
    219 
    220 	kget(dst, pt_u.u_sa);
    221 	if (pt_u.u_sa.sa_len > sizeof (pt_u.u_sa))
    222 		kread((u_long)dst, (char *)pt_u.u_data, pt_u.u_sa.sa_len);
    223 	return (&pt_u.u_sa);
    224 }
    225 
    226 static void
    227 p_tree(rn)
    228 	struct radix_node *rn;
    229 {
    230 
    231 again:
    232 	kget(rn, rnode);
    233 	if (rnode.rn_b < 0) {
    234 		if (Aflag)
    235 			printf("%-8.8lx ", (u_long) rn);
    236 		if (rnode.rn_flags & RNF_ROOT) {
    237 			if (Aflag)
    238 				printf("(root node)%s",
    239 				    rnode.rn_dupedkey ? " =>\n" : "\n");
    240 		} else if (do_rtent) {
    241 			kget(rn, rtentry);
    242 			p_rtentry(&rtentry);
    243 			if (Aflag)
    244 				p_rtnode();
    245 		} else {
    246 			p_sockaddr(kgetsa((struct sockaddr *)rnode.rn_key),
    247 			    NULL, 0, 44);
    248 			putchar('\n');
    249 		}
    250 		if ((rn = rnode.rn_dupedkey) != NULL)
    251 			goto again;
    252 	} else {
    253 		if (Aflag && do_rtent) {
    254 			printf("%-8.8lx ", (u_long) rn);
    255 			p_rtnode();
    256 		}
    257 		rn = rnode.rn_r;
    258 		p_tree(rnode.rn_l);
    259 		p_tree(rn);
    260 	}
    261 }
    262 
    263 char	nbuf[20];
    264 
    265 static void
    266 p_rtnode()
    267 {
    268 	struct radix_mask *rm = rnode.rn_mklist;
    269 
    270 	if (rnode.rn_b < 0) {
    271 		if (rnode.rn_mask) {
    272 			printf("\t  mask ");
    273 			p_sockaddr(kgetsa((struct sockaddr *)rnode.rn_mask),
    274 				    NULL, 0, -1);
    275 		} else if (rm == 0)
    276 			return;
    277 	} else {
    278 		sprintf(nbuf, "(%d)", rnode.rn_b);
    279 		printf("%6.6s %8.8lx : %8.8lx", nbuf, (u_long) rnode.rn_l,
    280 		    (u_long) rnode.rn_r);
    281 	}
    282 	while (rm) {
    283 		kget(rm, rmask);
    284 		sprintf(nbuf, " %d refs, ", rmask.rm_refs);
    285 		printf(" mk = %8.8lx {(%d),%s", (u_long) rm,
    286 		    -1 - rmask.rm_b, rmask.rm_refs ? nbuf : " ");
    287 		if (rmask.rm_flags & RNF_NORMAL) {
    288 			struct radix_node rnode_aux;
    289 			printf(" <normal>, ");
    290 			kget(rmask.rm_leaf, rnode_aux);
    291 			p_sockaddr(kgetsa((struct sockaddr *)rnode_aux.rn_mask),
    292 				    NULL, 0, -1);
    293 		} else
    294 		    p_sockaddr(kgetsa((struct sockaddr *)rmask.rm_mask),
    295 				NULL, 0, -1);
    296 		putchar('}');
    297 		if ((rm = rmask.rm_mklist) != NULL)
    298 			printf(" ->");
    299 	}
    300 	putchar('\n');
    301 }
    302 
    303 static void
    304 ntreestuff()
    305 {
    306 	size_t needed;
    307 	int mib[6];
    308 	char *buf, *next, *lim;
    309 	struct rt_msghdr *rtm;
    310 
    311         mib[0] = CTL_NET;
    312         mib[1] = PF_ROUTE;
    313         mib[2] = 0;
    314         mib[3] = 0;
    315         mib[4] = NET_RT_DUMP;
    316         mib[5] = 0;
    317         if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
    318 		{ perror("route-sysctl-estimate"); exit(1);}
    319 	if ((buf = malloc(needed)) == 0)
    320 		{ printf("out of space\n"); exit(1);}
    321         if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0)
    322 		{ perror("sysctl of routing table"); exit(1);}
    323 	lim  = buf + needed;
    324 	for (next = buf; next < lim; next += rtm->rtm_msglen) {
    325 		rtm = (struct rt_msghdr *)next;
    326 		np_rtentry(rtm);
    327 	}
    328 }
    329 
    330 static void
    331 np_rtentry(rtm)
    332 	struct rt_msghdr *rtm;
    333 {
    334 	struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
    335 #ifdef notdef
    336 	static int masks_done, banner_printed;
    337 #endif
    338 	static int old_af;
    339 	int af = 0, interesting = RTF_UP | RTF_GATEWAY | RTF_HOST;
    340 
    341 #ifdef notdef
    342 	/* for the moment, netmasks are skipped over */
    343 	if (!banner_printed) {
    344 		printf("Netmasks:\n");
    345 		banner_printed = 1;
    346 	}
    347 	if (masks_done == 0) {
    348 		if (rtm->rtm_addrs != RTA_DST ) {
    349 			masks_done = 1;
    350 			af = sa->sa_family;
    351 		}
    352 	} else
    353 #endif
    354 		af = sa->sa_family;
    355 	if (af != old_af) {
    356 		pr_family(af);
    357 		old_af = af;
    358 	}
    359 	if (rtm->rtm_addrs == RTA_DST)
    360 		p_sockaddr(sa, NULL, 0, 36);
    361 	else {
    362 		p_sockaddr(sa, NULL, rtm->rtm_flags, 16);
    363 		if (sa->sa_len == 0)
    364 			sa->sa_len = sizeof(long);
    365 		sa = (struct sockaddr *)(sa->sa_len + (char *)sa);
    366 		p_sockaddr(sa, NULL, 0, 18);
    367 	}
    368 	p_flags(rtm->rtm_flags & interesting, "%-6.6s ");
    369 	putchar('\n');
    370 }
    371 
    372 static void
    373 p_sockaddr(sa, mask, flags, width)
    374 	const struct sockaddr *sa, *mask;
    375 	int flags, width;
    376 {
    377 	char workbuf[128], *cplim;
    378 	char *cp = workbuf;
    379 
    380 	switch(sa->sa_family) {
    381 	case AF_INET:
    382 	    {
    383 		struct sockaddr_in *sin = (struct sockaddr_in *)sa;
    384 
    385 		if (sin->sin_addr.s_addr == INADDR_ANY)
    386 			cp = "default";
    387 		else if (flags & RTF_HOST)
    388 			cp = routename(sin->sin_addr.s_addr);
    389 		else if (mask)
    390 			cp = netname(sin->sin_addr.s_addr,
    391 			    ((struct sockaddr_in *)mask)->sin_addr.s_addr);
    392 		else
    393 			cp = netname(sin->sin_addr.s_addr, INADDR_ANY);
    394 		break;
    395 	    }
    396 
    397 #ifndef SMALL
    398 	case AF_APPLETALK:
    399 	case 0:
    400 	    {
    401 		if (!(flags & RTF_HOST) && mask)
    402 			cp = atalk_print2(sa,mask,11);
    403 		else
    404 			cp = atalk_print(sa,11);
    405 		break;
    406 	    }
    407 	case AF_NS:
    408 		cp = ns_print((struct sockaddr *)sa);
    409 		break;
    410 #endif
    411 
    412 	case AF_LINK:
    413 	    {
    414 		struct sockaddr_dl *sdl = (struct sockaddr_dl *)sa;
    415 
    416 		if (sdl->sdl_nlen == 0 && sdl->sdl_alen == 0 &&
    417 		    sdl->sdl_slen == 0)
    418 			(void) sprintf(workbuf, "link#%d", sdl->sdl_index);
    419 		else switch (sdl->sdl_type) {
    420 		case IFT_FDDI:
    421 		case IFT_ETHER:
    422 		    {
    423 			int i;
    424 			u_char *lla = (u_char *)sdl->sdl_data +
    425 			    sdl->sdl_nlen;
    426 
    427 			cplim = "";
    428 			for (i = 0; i < sdl->sdl_alen; i++, lla++) {
    429 				cp += sprintf(cp, "%s%02x", cplim, *lla);
    430 				cplim = ":";
    431 			}
    432 			cp = workbuf;
    433 			break;
    434 		    }
    435 		default:
    436 			cp = link_ntoa(sdl);
    437 			break;
    438 		}
    439 		break;
    440 	    }
    441 
    442 	default:
    443 	    {
    444 		u_char *s = (u_char *)sa->sa_data, *slim;
    445 
    446 		slim =  sa->sa_len + (u_char *) sa;
    447 		cplim = cp + sizeof(workbuf) - 6;
    448 		cp += sprintf(cp, "(%d)", sa->sa_family);
    449 		while (s < slim && cp < cplim) {
    450 			cp += sprintf(cp, " %02x", *s++);
    451 			if (s < slim)
    452 			    cp += sprintf(cp, "%02x", *s++);
    453 		}
    454 		cp = workbuf;
    455 	    }
    456 	}
    457 	if (width < 0 )
    458 		printf("%s ", cp);
    459 	else {
    460 		if (nflag)
    461 			printf("%-*s ", width, cp);
    462 		else
    463 			printf("%-*.*s ", width, width, cp);
    464 	}
    465 }
    466 
    467 static void
    468 p_flags(f, format)
    469 	int f;
    470 	char *format;
    471 {
    472 	char name[33], *flags;
    473 	struct bits *p = bits;
    474 
    475 	for (flags = name; p->b_mask; p++)
    476 		if (p->b_mask & f)
    477 			*flags++ = p->b_val;
    478 	*flags = '\0';
    479 	printf(format, name);
    480 }
    481 
    482 static void
    483 p_rtentry(rt)
    484 	struct rtentry *rt;
    485 {
    486 	static struct ifnet ifnet, *lastif;
    487 	struct sockaddr *sa, addr, mask;
    488 
    489 	if (!(sa = kgetsa(rt_key(rt))))
    490 		memset(&addr, 0, sizeof addr);
    491 	else
    492 		addr = *sa;
    493 	if (!rt_mask(rt) || !(sa = kgetsa(rt_mask(rt))))
    494 		memset(&mask, 0, sizeof mask);
    495 	else
    496 		mask = *sa;
    497 	p_sockaddr(&addr, &mask, rt->rt_flags, WID_DST);
    498 	p_sockaddr(kgetsa(rt->rt_gateway), NULL, RTF_HOST, WID_GW);
    499 	p_flags(rt->rt_flags, "%-6.6s ");
    500 	printf("%6d %8ld ", rt->rt_refcnt, rt->rt_use);
    501 	if (rt->rt_rmx.rmx_mtu)
    502 		printf("%6ld%c", rt->rt_rmx.rmx_mtu,
    503 		       (rt->rt_rmx.rmx_locks & RTV_MTU) ? 'L' : ' ');
    504 	else
    505 		printf("%6s ", "-");
    506 	if (rt->rt_ifp) {
    507 		if (rt->rt_ifp != lastif) {
    508 			kget(rt->rt_ifp, ifnet);
    509 			lastif = rt->rt_ifp;
    510 		}
    511 		printf(" %.16s%s", ifnet.if_xname,
    512 			rt->rt_nodes[0].rn_dupedkey ? " =>" : "");
    513 	}
    514 	putchar('\n');
    515 }
    516 
    517 char *
    518 routename(in)
    519 	u_int32_t in;
    520 {
    521 	char *cp;
    522 	static char line[MAXHOSTNAMELEN + 1];
    523 	struct hostent *hp;
    524 	static char domain[MAXHOSTNAMELEN + 1];
    525 	static int first = 1;
    526 
    527 	if (first) {
    528 		first = 0;
    529 		if (gethostname(domain, MAXHOSTNAMELEN) == 0 &&
    530 		    (cp = strchr(domain, '.')))
    531 			(void) strcpy(domain, cp + 1);
    532 		else
    533 			domain[0] = 0;
    534 	}
    535 	cp = 0;
    536 	if (!nflag) {
    537 		hp = gethostbyaddr((char *)&in, sizeof (struct in_addr),
    538 			AF_INET);
    539 		if (hp) {
    540 			if ((cp = strchr(hp->h_name, '.')) &&
    541 			    !strcmp(cp + 1, domain))
    542 				*cp = 0;
    543 			cp = hp->h_name;
    544 		}
    545 	}
    546 	if (cp)
    547 		strncpy(line, cp, sizeof(line) - 1);
    548 	else {
    549 #define C(x)	((x) & 0xff)
    550 		in = ntohl(in);
    551 		sprintf(line, "%u.%u.%u.%u",
    552 		    C(in >> 24), C(in >> 16), C(in >> 8), C(in));
    553 	}
    554 	return (line);
    555 }
    556 
    557 static u_long
    558 forgemask(a)
    559 	u_long a;
    560 {
    561 	u_long m;
    562 
    563 	if (IN_CLASSA(a))
    564 		m = IN_CLASSA_NET;
    565 	else if (IN_CLASSB(a))
    566 		m = IN_CLASSB_NET;
    567 	else
    568 		m = IN_CLASSC_NET;
    569 	return (m);
    570 }
    571 
    572 static void
    573 domask(dst, addr, mask)
    574 	char *dst;
    575 	u_long addr, mask;
    576 {
    577 	int b, i;
    578 
    579 	if (!mask || (forgemask(addr) == mask)) {
    580 		*dst = '\0';
    581 		return;
    582 	}
    583 	i = 0;
    584 	for (b = 0; b < 32; b++)
    585 		if (mask & (1 << b)) {
    586 			int bb;
    587 
    588 			i = b;
    589 			for (bb = b+1; bb < 32; bb++)
    590 				if (!(mask & (1 << bb))) {
    591 					i = -1;	/* noncontig */
    592 					break;
    593 				}
    594 			break;
    595 		}
    596 	if (i == -1)
    597 		sprintf(dst, "&0x%lx", mask);
    598 	else
    599 		sprintf(dst, "/%d", 32-i);
    600 }
    601 
    602 /*
    603  * Return the name of the network whose address is given.
    604  * The address is assumed to be that of a net or subnet, not a host.
    605  */
    606 char *
    607 netname(in, mask)
    608 	u_int32_t in, mask;
    609 {
    610 	char *cp = 0;
    611 	static char line[MAXHOSTNAMELEN + 4];
    612 	struct netent *np = 0;
    613 	u_int32_t net, omask;
    614 	u_int32_t i;
    615 	int subnetshift;
    616 
    617 	i = ntohl(in);
    618 	omask = mask = ntohl(mask);
    619 	if (!nflag && i != INADDR_ANY) {
    620 		if (mask == INADDR_ANY) {
    621 			switch (mask = forgemask(i)) {
    622 			case IN_CLASSA_NET:
    623 				subnetshift = 8;
    624 				break;
    625 			case IN_CLASSB_NET:
    626 				subnetshift = 8;
    627 				break;
    628 			case IN_CLASSC_NET:
    629 				subnetshift = 4;
    630 				break;
    631 			default:
    632 				abort();
    633 			}
    634 			/*
    635 			 * If there are more bits than the standard mask
    636 			 * would suggest, subnets must be in use.
    637 			 * Guess at the subnet mask, assuming reasonable
    638 			 * width subnet fields.
    639 			 */
    640 			while (i &~ mask)
    641 				mask = (long)mask >> subnetshift;
    642 		}
    643 		net = i & mask;
    644 		while ((mask & 1) == 0)
    645 			mask >>= 1, net >>= 1;
    646 		np = getnetbyaddr(net, AF_INET);
    647 		if (np)
    648 			cp = np->n_name;
    649 	}
    650 	if (cp)
    651 		strncpy(line, cp, sizeof(line) - 1);
    652 	else if ((i & 0xffffff) == 0)
    653 		sprintf(line, "%u", C(i >> 24));
    654 	else if ((i & 0xffff) == 0)
    655 		sprintf(line, "%u.%u", C(i >> 24) , C(i >> 16));
    656 	else if ((i & 0xff) == 0)
    657 		sprintf(line, "%u.%u.%u", C(i >> 24), C(i >> 16), C(i >> 8));
    658 	else
    659 		sprintf(line, "%u.%u.%u.%u", C(i >> 24),
    660 			C(i >> 16), C(i >> 8), C(i));
    661 	domask(line+strlen(line), i, omask);
    662 	return (line);
    663 }
    664 
    665 /*
    666  * Print routing statistics
    667  */
    668 void
    669 rt_stats(off)
    670 	u_long off;
    671 {
    672 	struct rtstat rtstat;
    673 
    674 	if (off == 0) {
    675 		printf("rtstat: symbol not in namelist\n");
    676 		return;
    677 	}
    678 	kread(off, (char *)&rtstat, sizeof (rtstat));
    679 	printf("routing:\n");
    680 	printf("\t%u bad routing redirect%s\n",
    681 		rtstat.rts_badredirect, plural(rtstat.rts_badredirect));
    682 	printf("\t%u dynamically created route%s\n",
    683 		rtstat.rts_dynamic, plural(rtstat.rts_dynamic));
    684 	printf("\t%u new gateway%s due to redirects\n",
    685 		rtstat.rts_newgateway, plural(rtstat.rts_newgateway));
    686 	printf("\t%u destination%s found unreachable\n",
    687 		rtstat.rts_unreach, plural(rtstat.rts_unreach));
    688 	printf("\t%u use%s of a wildcard route\n",
    689 		rtstat.rts_wildcard, plural(rtstat.rts_wildcard));
    690 }
    691 short ns_nullh[] = {0,0,0};
    692 short ns_bh[] = {-1,-1,-1};
    693 
    694 char *
    695 ns_print(sa)
    696 	struct sockaddr *sa;
    697 {
    698 	struct sockaddr_ns *sns = (struct sockaddr_ns*)sa;
    699 	struct ns_addr work;
    700 	union { union ns_net net_e; u_long long_e; } net;
    701 	u_short port;
    702 	static char mybuf[50], cport[10], chost[25];
    703 	char *host = "";
    704 	char *p;
    705 	u_char *q;
    706 
    707 	work = sns->sns_addr;
    708 	port = ntohs(work.x_port);
    709 	work.x_port = 0;
    710 	net.net_e  = work.x_net;
    711 	if (ns_nullhost(work) && net.long_e == 0) {
    712 		if (port ) {
    713 			sprintf(mybuf, "*.%xH", port);
    714 			upHex(mybuf);
    715 		} else
    716 			sprintf(mybuf, "*.*");
    717 		return (mybuf);
    718 	}
    719 
    720 	if (memcmp(ns_bh, work.x_host.c_host, 6) == 0) {
    721 		host = "any";
    722 	} else if (memcmp(ns_nullh, work.x_host.c_host, 6) == 0) {
    723 		host = "*";
    724 	} else {
    725 		q = work.x_host.c_host;
    726 		sprintf(chost, "%02x%02x%02x%02x%02x%02xH",
    727 			q[0], q[1], q[2], q[3], q[4], q[5]);
    728 		for (p = chost; *p == '0' && p < chost + 12; p++)
    729 			continue;
    730 		host = p;
    731 	}
    732 	if (port)
    733 		sprintf(cport, ".%xH", htons(port));
    734 	else
    735 		*cport = 0;
    736 
    737 	sprintf(mybuf, "%xH.%s%s", (int)ntohl(net.long_e), host, cport);
    738 	upHex(mybuf);
    739 	return(mybuf);
    740 }
    741 
    742 char *
    743 ns_phost(sa)
    744 	struct sockaddr *sa;
    745 {
    746 	struct sockaddr_ns *sns = (struct sockaddr_ns *)sa;
    747 	struct sockaddr_ns work;
    748 	static union ns_net ns_zeronet;
    749 	char *p;
    750 
    751 	work = *sns;
    752 	work.sns_addr.x_port = 0;
    753 	work.sns_addr.x_net = ns_zeronet;
    754 
    755 	p = ns_print((struct sockaddr *)&work);
    756 	if (strncmp("0H.", p, 3) == 0) p += 3;
    757 	return(p);
    758 }
    759 
    760 void
    761 upHex(p0)
    762 	char *p0;
    763 {
    764 	char *p = p0;
    765 	for (; *p; p++) switch (*p) {
    766 
    767 	case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
    768 		*p += ('A' - 'a');
    769 	}
    770 }
    771