xref: /freebsd/usr.bin/netstat/route.c (revision 87569f75a91f298c52a71823c04d41cf53c88889)
1 /*
2  * Copyright (c) 1983, 1988, 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 #if 0
35 #ifndef lint
36 static char sccsid[] = "From: @(#)route.c	8.6 (Berkeley) 4/28/95";
37 #endif /* not lint */
38 #endif
39 
40 #include <sys/cdefs.h>
41 __FBSDID("$FreeBSD$");
42 
43 #include <sys/param.h>
44 #include <sys/protosw.h>
45 #include <sys/socket.h>
46 #include <sys/time.h>
47 
48 #include <net/ethernet.h>
49 #include <net/if.h>
50 #include <net/if_var.h>
51 #include <net/if_dl.h>
52 #include <net/if_types.h>
53 #include <net/radix.h>
54 #include <net/route.h>
55 
56 #include <netinet/in.h>
57 #include <netipx/ipx.h>
58 #include <netatalk/at.h>
59 #include <netgraph/ng_socket.h>
60 
61 #include <sys/sysctl.h>
62 
63 #include <arpa/inet.h>
64 #include <libutil.h>
65 #include <netdb.h>
66 #include <stdio.h>
67 #include <stdlib.h>
68 #include <string.h>
69 #include <unistd.h>
70 #include <err.h>
71 #include <time.h>
72 #include "netstat.h"
73 
74 #define kget(p, d) (kread((u_long)(p), (char *)&(d), sizeof (d)))
75 
76 /*
77  * Definitions for showing gateway flags.
78  */
79 struct bits {
80 	u_long	b_mask;
81 	char	b_val;
82 } bits[] = {
83 	{ RTF_UP,	'U' },
84 	{ RTF_GATEWAY,	'G' },
85 	{ RTF_HOST,	'H' },
86 	{ RTF_REJECT,	'R' },
87 	{ RTF_DYNAMIC,	'D' },
88 	{ RTF_MODIFIED,	'M' },
89 	{ RTF_DONE,	'd' }, /* Completed -- for routing messages only */
90 	{ RTF_CLONING,	'C' },
91 	{ RTF_XRESOLVE,	'X' },
92 	{ RTF_LLINFO,	'L' },
93 	{ RTF_STATIC,	'S' },
94 	{ RTF_PROTO1,	'1' },
95 	{ RTF_PROTO2,	'2' },
96 	{ RTF_WASCLONED,'W' },
97 	{ RTF_PRCLONING,'c' },
98 	{ RTF_PROTO3,	'3' },
99 	{ RTF_BLACKHOLE,'B' },
100 	{ RTF_BROADCAST,'b' },
101 	{ 0 , 0 }
102 };
103 
104 typedef union {
105 	long	dummy;		/* Helps align structure. */
106 	struct	sockaddr u_sa;
107 	u_short	u_data[128];
108 } sa_u;
109 
110 static sa_u pt_u;
111 
112 int	do_rtent = 0;
113 struct	rtentry rtentry;
114 struct	radix_node rnode;
115 struct	radix_mask rmask;
116 struct	radix_node_head *rt_tables[AF_MAX+1];
117 
118 int	NewTree = 0;
119 
120 static struct sockaddr *kgetsa (struct sockaddr *);
121 static void size_cols (int ef, struct radix_node *rn);
122 static void size_cols_tree (struct radix_node *rn);
123 static void size_cols_rtentry (struct rtentry *rt);
124 static void p_tree (struct radix_node *);
125 static void p_rtnode (void);
126 static void ntreestuff (void);
127 static void np_rtentry (struct rt_msghdr *);
128 static void p_sockaddr (struct sockaddr *, struct sockaddr *, int, int);
129 static const char *fmt_sockaddr (struct sockaddr *sa, struct sockaddr *mask,
130 				 int flags);
131 static void p_flags (int, const char *);
132 static const char *fmt_flags(int f);
133 static void p_rtentry (struct rtentry *);
134 static u_long forgemask (u_long);
135 static void domask (char *, u_long, u_long);
136 
137 /*
138  * Print routing tables.
139  */
140 void
141 routepr(u_long rtree)
142 {
143 	struct radix_node_head *rnh, head;
144 	int i;
145 
146 	printf("Routing tables\n");
147 
148 	if (Aflag == 0 && NewTree)
149 		ntreestuff();
150 	else {
151 		if (rtree == 0) {
152 			printf("rt_tables: symbol not in namelist\n");
153 			return;
154 		}
155 
156 		kget(rtree, rt_tables);
157 		for (i = 0; i <= AF_MAX; i++) {
158 			if ((rnh = rt_tables[i]) == 0)
159 				continue;
160 			kget(rnh, head);
161 			if (i == AF_UNSPEC) {
162 				if (Aflag && af == 0) {
163 					printf("Netmasks:\n");
164 					p_tree(head.rnh_treetop);
165 				}
166 			} else if (af == AF_UNSPEC || af == i) {
167 				size_cols(i, head.rnh_treetop);
168 				pr_family(i);
169 				do_rtent = 1;
170 				pr_rthdr(i);
171 				p_tree(head.rnh_treetop);
172 			}
173 		}
174 	}
175 }
176 
177 /*
178  * Print address family header before a section of the routing table.
179  */
180 void
181 pr_family(int af1)
182 {
183 	const char *afname;
184 
185 	switch (af1) {
186 	case AF_INET:
187 		afname = "Internet";
188 		break;
189 #ifdef INET6
190 	case AF_INET6:
191 		afname = "Internet6";
192 		break;
193 #endif /*INET6*/
194 	case AF_IPX:
195 		afname = "IPX";
196 		break;
197 	case AF_ISO:
198 		afname = "ISO";
199 		break;
200 	case AF_APPLETALK:
201 		afname = "AppleTalk";
202 		break;
203 	case AF_CCITT:
204 		afname = "X.25";
205 		break;
206 	case AF_NETGRAPH:
207 		afname = "Netgraph";
208 		break;
209 	default:
210 		afname = NULL;
211 		break;
212 	}
213 	if (afname)
214 		printf("\n%s:\n", afname);
215 	else
216 		printf("\nProtocol Family %d:\n", af1);
217 }
218 
219 /* column widths; each followed by one space */
220 #ifndef INET6
221 #define	WID_DST_DEFAULT(af) 	18	/* width of destination column */
222 #define	WID_GW_DEFAULT(af)	18	/* width of gateway column */
223 #define	WID_IF_DEFAULT(af)	(Wflag ? 8 : 6)	/* width of netif column */
224 #else
225 #define	WID_DST_DEFAULT(af) \
226 	((af) == AF_INET6 ? (numeric_addr ? 33: 18) : 18)
227 #define	WID_GW_DEFAULT(af) \
228 	((af) == AF_INET6 ? (numeric_addr ? 29 : 18) : 18)
229 #define	WID_IF_DEFAULT(af)	((af) == AF_INET6 ? 8 : (Wflag ? 8 : 6))
230 #endif /*INET6*/
231 
232 static int wid_dst;
233 static int wid_gw;
234 static int wid_flags;
235 static int wid_refs;
236 static int wid_use;
237 static int wid_mtu;
238 static int wid_if;
239 static int wid_expire;
240 
241 static void
242 size_cols(int ef, struct radix_node *rn)
243 {
244 	wid_dst = WID_DST_DEFAULT(ef);
245 	wid_gw = WID_GW_DEFAULT(ef);
246 	wid_flags = 6;
247 	wid_refs = 6;
248 	wid_use = 8;
249 	wid_mtu = 6;
250 	wid_if = WID_IF_DEFAULT(ef);
251 	wid_expire = 6;
252 
253 	if (Wflag)
254 		size_cols_tree(rn);
255 }
256 
257 static void
258 size_cols_tree(struct radix_node *rn)
259 {
260 again:
261 	kget(rn, rnode);
262 	if (rnode.rn_bit < 0) {
263 		if ((rnode.rn_flags & RNF_ROOT) == 0) {
264 			kget(rn, rtentry);
265 			size_cols_rtentry(&rtentry);
266 		}
267 		if ((rn = rnode.rn_dupedkey))
268 			goto again;
269 	} else {
270 		rn = rnode.rn_right;
271 		size_cols_tree(rnode.rn_left);
272 		size_cols_tree(rn);
273 	}
274 }
275 
276 static void
277 size_cols_rtentry(struct rtentry *rt)
278 {
279 	static struct ifnet ifnet, *lastif;
280 	struct rtentry parent;
281 	static char buffer[100];
282 	const char *bp;
283 	struct sockaddr *sa;
284 	sa_u addr, mask;
285 	int len;
286 
287 	/*
288 	 * Don't print protocol-cloned routes unless -a.
289 	 */
290 	if (rt->rt_flags & RTF_WASCLONED && !aflag) {
291 		kget(rt->rt_parent, parent);
292 		if (parent.rt_flags & RTF_PRCLONING)
293 			return;
294 	}
295 
296 	bzero(&addr, sizeof(addr));
297 	if ((sa = kgetsa(rt_key(rt))))
298 		bcopy(sa, &addr, sa->sa_len);
299 	bzero(&mask, sizeof(mask));
300 	if (rt_mask(rt) && (sa = kgetsa(rt_mask(rt))))
301 		bcopy(sa, &mask, sa->sa_len);
302 	bp = fmt_sockaddr(&addr.u_sa, &mask.u_sa, rt->rt_flags);
303 	len = strlen(bp);
304 	wid_dst = MAX(len, wid_dst);
305 
306 	bp = fmt_sockaddr(kgetsa(rt->rt_gateway), NULL, RTF_HOST);
307 	len = strlen(bp);
308 	wid_gw = MAX(len, wid_gw);
309 
310 	bp = fmt_flags(rt->rt_flags);
311 	len = strlen(bp);
312 	wid_flags = MAX(len, wid_flags);
313 
314 	if (addr.u_sa.sa_family == AF_INET || Wflag) {
315 		len = snprintf(buffer, sizeof(buffer), "%ld", rt->rt_refcnt);
316 		wid_refs = MAX(len, wid_refs);
317 		len = snprintf(buffer, sizeof(buffer), "%lu", rt->rt_use);
318 		wid_use = MAX(len, wid_use);
319 		if (Wflag && rt->rt_rmx.rmx_mtu != 0) {
320 			len = snprintf(buffer, sizeof(buffer),
321 				       "%lu", rt->rt_rmx.rmx_mtu);
322 			wid_mtu = MAX(len, wid_mtu);
323 		}
324 	}
325 	if (rt->rt_ifp) {
326 		if (rt->rt_ifp != lastif) {
327 			kget(rt->rt_ifp, ifnet);
328 			lastif = rt->rt_ifp;
329 			len = strlen(ifnet.if_xname);
330 			wid_if = MAX(len, wid_if);
331 		}
332 		if (rt->rt_rmx.rmx_expire) {
333 			time_t expire_time;
334 
335 			if ((expire_time =
336 			    rt->rt_rmx.rmx_expire - time(NULL)) > 0) {
337 				len = snprintf(buffer, sizeof(buffer), "%d",
338 					       (int)expire_time);
339 				wid_expire = MAX(len, wid_expire);
340 			}
341 		}
342 	}
343 }
344 
345 
346 /*
347  * Print header for routing table columns.
348  */
349 void
350 pr_rthdr(int af1)
351 {
352 
353 	if (Aflag)
354 		printf("%-8.8s ","Address");
355 	if (af1 == AF_INET || Wflag) {
356 		if (Wflag) {
357 			printf("%-*.*s %-*.*s %-*.*s %*.*s %*.*s %*.*s %*.*s %*s\n",
358 				wid_dst,	wid_dst,	"Destination",
359 				wid_gw,		wid_gw,		"Gateway",
360 				wid_flags,	wid_flags,	"Flags",
361 				wid_refs,	wid_refs,	"Refs",
362 				wid_use,	wid_use,	"Use",
363 				wid_mtu,	wid_mtu,	"Mtu",
364 				wid_if,		wid_if,		"Netif",
365 				wid_expire,			"Expire");
366 		} else {
367 			printf("%-*.*s %-*.*s %-*.*s %*.*s %*.*s %*.*s %*s\n",
368 				wid_dst,	wid_dst,	"Destination",
369 				wid_gw,		wid_gw,		"Gateway",
370 				wid_flags,	wid_flags,	"Flags",
371 				wid_refs,	wid_refs,	"Refs",
372 				wid_use,	wid_use,	"Use",
373 				wid_if,		wid_if,		"Netif",
374 				wid_expire,			"Expire");
375 		}
376 	} else {
377 		printf("%-*.*s %-*.*s %-*.*s  %*.*s %*s\n",
378 			wid_dst,	wid_dst,	"Destination",
379 			wid_gw,		wid_gw,		"Gateway",
380 			wid_flags,	wid_flags,	"Flags",
381 			wid_if,		wid_if,		"Netif",
382 			wid_expire,			"Expire");
383 	}
384 }
385 
386 static struct sockaddr *
387 kgetsa(struct sockaddr *dst)
388 {
389 
390 	kget(dst, pt_u.u_sa);
391 	if (pt_u.u_sa.sa_len > sizeof (pt_u.u_sa))
392 		kread((u_long)dst, (char *)pt_u.u_data, pt_u.u_sa.sa_len);
393 	return (&pt_u.u_sa);
394 }
395 
396 static void
397 p_tree(struct radix_node *rn)
398 {
399 
400 again:
401 	kget(rn, rnode);
402 	if (rnode.rn_bit < 0) {
403 		if (Aflag)
404 			printf("%-8.8lx ", (u_long)rn);
405 		if (rnode.rn_flags & RNF_ROOT) {
406 			if (Aflag)
407 				printf("(root node)%s",
408 				    rnode.rn_dupedkey ? " =>\n" : "\n");
409 		} else if (do_rtent) {
410 			kget(rn, rtentry);
411 			p_rtentry(&rtentry);
412 			if (Aflag)
413 				p_rtnode();
414 		} else {
415 			p_sockaddr(kgetsa((struct sockaddr *)rnode.rn_key),
416 				   NULL, 0, 44);
417 			putchar('\n');
418 		}
419 		if ((rn = rnode.rn_dupedkey))
420 			goto again;
421 	} else {
422 		if (Aflag && do_rtent) {
423 			printf("%-8.8lx ", (u_long)rn);
424 			p_rtnode();
425 		}
426 		rn = rnode.rn_right;
427 		p_tree(rnode.rn_left);
428 		p_tree(rn);
429 	}
430 }
431 
432 char	nbuf[20];
433 
434 static void
435 p_rtnode(void)
436 {
437 	struct radix_mask *rm = rnode.rn_mklist;
438 
439 	if (rnode.rn_bit < 0) {
440 		if (rnode.rn_mask) {
441 			printf("\t  mask ");
442 			p_sockaddr(kgetsa((struct sockaddr *)rnode.rn_mask),
443 				   NULL, 0, -1);
444 		} else if (rm == 0)
445 			return;
446 	} else {
447 		sprintf(nbuf, "(%d)", rnode.rn_bit);
448 		printf("%6.6s %8.8lx : %8.8lx", nbuf, (u_long)rnode.rn_left, (u_long)rnode.rn_right);
449 	}
450 	while (rm) {
451 		kget(rm, rmask);
452 		sprintf(nbuf, " %d refs, ", rmask.rm_refs);
453 		printf(" mk = %8.8lx {(%d),%s",
454 			(u_long)rm, -1 - rmask.rm_bit, rmask.rm_refs ? nbuf : " ");
455 		if (rmask.rm_flags & RNF_NORMAL) {
456 			struct radix_node rnode_aux;
457 			printf(" <normal>, ");
458 			kget(rmask.rm_leaf, rnode_aux);
459 			p_sockaddr(kgetsa((struct sockaddr *)rnode_aux.rn_mask),
460 				    NULL, 0, -1);
461 		} else
462 		    p_sockaddr(kgetsa((struct sockaddr *)rmask.rm_mask),
463 				NULL, 0, -1);
464 		putchar('}');
465 		if ((rm = rmask.rm_mklist))
466 			printf(" ->");
467 	}
468 	putchar('\n');
469 }
470 
471 static void
472 ntreestuff(void)
473 {
474 	size_t needed;
475 	int mib[6];
476 	char *buf, *next, *lim;
477 	struct rt_msghdr *rtm;
478 
479 	mib[0] = CTL_NET;
480 	mib[1] = PF_ROUTE;
481 	mib[2] = 0;
482 	mib[3] = 0;
483 	mib[4] = NET_RT_DUMP;
484 	mib[5] = 0;
485 	if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {
486 		err(1, "sysctl: net.route.0.0.dump estimate");
487 	}
488 
489 	if ((buf = malloc(needed)) == 0) {
490 		errx(2, "malloc(%lu)", (unsigned long)needed);
491 	}
492 	if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
493 		err(1, "sysctl: net.route.0.0.dump");
494 	}
495 	lim  = buf + needed;
496 	for (next = buf; next < lim; next += rtm->rtm_msglen) {
497 		rtm = (struct rt_msghdr *)next;
498 		np_rtentry(rtm);
499 	}
500 }
501 
502 static void
503 np_rtentry(struct rt_msghdr *rtm)
504 {
505 	struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
506 #ifdef notdef
507 	static int masks_done, banner_printed;
508 #endif
509 	static int old_af;
510 	int af1 = 0, interesting = RTF_UP | RTF_GATEWAY | RTF_HOST;
511 
512 #ifdef notdef
513 	/* for the moment, netmasks are skipped over */
514 	if (!banner_printed) {
515 		printf("Netmasks:\n");
516 		banner_printed = 1;
517 	}
518 	if (masks_done == 0) {
519 		if (rtm->rtm_addrs != RTA_DST ) {
520 			masks_done = 1;
521 			af1 = sa->sa_family;
522 		}
523 	} else
524 #endif
525 		af1 = sa->sa_family;
526 	if (af1 != old_af) {
527 		pr_family(af1);
528 		old_af = af1;
529 	}
530 	if (rtm->rtm_addrs == RTA_DST)
531 		p_sockaddr(sa, NULL, 0, 36);
532 	else {
533 		p_sockaddr(sa, NULL, rtm->rtm_flags, 16);
534 		sa = (struct sockaddr *)(SA_SIZE(sa) + (char *)sa);
535 		p_sockaddr(sa, NULL, 0, 18);
536 	}
537 	p_flags(rtm->rtm_flags & interesting, "%-6.6s ");
538 	putchar('\n');
539 }
540 
541 static void
542 p_sockaddr(struct sockaddr *sa, struct sockaddr *mask, int flags, int width)
543 {
544 	const char *cp;
545 
546 	cp = fmt_sockaddr(sa, mask, flags);
547 
548 	if (width < 0 )
549 		printf("%s ", cp);
550 	else {
551 		if (numeric_addr)
552 			printf("%-*s ", width, cp);
553 		else
554 			printf("%-*.*s ", width, width, cp);
555 	}
556 }
557 
558 static const char *
559 fmt_sockaddr(struct sockaddr *sa, struct sockaddr *mask, int flags)
560 {
561 	static char workbuf[128];
562 	const char *cp;
563 
564 	switch(sa->sa_family) {
565 	case AF_INET:
566 	    {
567 		struct sockaddr_in *sockin = (struct sockaddr_in *)sa;
568 
569 		if ((sockin->sin_addr.s_addr == INADDR_ANY) &&
570 			mask &&
571 			ntohl(((struct sockaddr_in *)mask)->sin_addr.s_addr)
572 				==0L)
573 				cp = "default" ;
574 		else if (flags & RTF_HOST)
575 			cp = routename(sockin->sin_addr.s_addr);
576 		else if (mask)
577 			cp = netname(sockin->sin_addr.s_addr,
578 				     ntohl(((struct sockaddr_in *)mask)
579 					   ->sin_addr.s_addr));
580 		else
581 			cp = netname(sockin->sin_addr.s_addr, 0L);
582 		break;
583 	    }
584 
585 #ifdef INET6
586 	case AF_INET6:
587 	    {
588 		struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)sa;
589 		struct in6_addr *in6 = &sa6->sin6_addr;
590 
591 		/*
592 		 * XXX: This is a special workaround for KAME kernels.
593 		 * sin6_scope_id field of SA should be set in the future.
594 		 */
595 		if (IN6_IS_ADDR_LINKLOCAL(in6) ||
596 		    IN6_IS_ADDR_MC_LINKLOCAL(in6)) {
597 		    /* XXX: override is ok? */
598 		    sa6->sin6_scope_id = (u_int32_t)ntohs(*(u_short *)&in6->s6_addr[2]);
599 		    *(u_short *)&in6->s6_addr[2] = 0;
600 		}
601 
602 		if (flags & RTF_HOST)
603 		    cp = routename6(sa6);
604 		else if (mask)
605 		    cp = netname6(sa6,
606 				  &((struct sockaddr_in6 *)mask)->sin6_addr);
607 		else {
608 		    cp = netname6(sa6, NULL);
609 		}
610 		break;
611 	    }
612 #endif /*INET6*/
613 
614 	case AF_IPX:
615 	    {
616 		struct ipx_addr work = ((struct sockaddr_ipx *)sa)->sipx_addr;
617 		if (ipx_nullnet(satoipx_addr(work)))
618 			cp = "default";
619 		else
620 			cp = ipx_print(sa);
621 		break;
622 	    }
623 	case AF_APPLETALK:
624 	    {
625 		if (!(flags & RTF_HOST) && mask)
626 			cp = atalk_print2(sa,mask,9);
627 		else
628 			cp = atalk_print(sa,11);
629 		break;
630 	    }
631 	case AF_NETGRAPH:
632 	    {
633 		printf("%s", ((struct sockaddr_ng *)sa)->sg_data);
634 		break;
635 	    }
636 
637 	case AF_LINK:
638 	    {
639 		struct sockaddr_dl *sdl = (struct sockaddr_dl *)sa;
640 
641 		if (sdl->sdl_nlen == 0 && sdl->sdl_alen == 0 &&
642 		    sdl->sdl_slen == 0) {
643 			(void) sprintf(workbuf, "link#%d", sdl->sdl_index);
644 			cp = workbuf;
645 		} else
646 			switch (sdl->sdl_type) {
647 
648 			case IFT_ETHER:
649 			case IFT_L2VLAN:
650 				if (sdl->sdl_alen == ETHER_ADDR_LEN) {
651 					cp = ether_ntoa((struct ether_addr *)
652 					    (sdl->sdl_data + sdl->sdl_nlen));
653 					break;
654 				}
655 				/* FALLTHROUGH */
656 			default:
657 				cp = link_ntoa(sdl);
658 				break;
659 			}
660 		break;
661 	    }
662 
663 	default:
664 	    {
665 		u_char *s = (u_char *)sa->sa_data, *slim;
666 		char *cq, *cqlim;
667 
668 		cq = workbuf;
669 		slim =  sa->sa_len + (u_char *) sa;
670 		cqlim = cq + sizeof(workbuf) - 6;
671 		cq += sprintf(cq, "(%d)", sa->sa_family);
672 		while (s < slim && cq < cqlim) {
673 			cq += sprintf(cq, " %02x", *s++);
674 			if (s < slim)
675 			    cq += sprintf(cq, "%02x", *s++);
676 		}
677 		cp = workbuf;
678 	    }
679 	}
680 
681 	return (cp);
682 }
683 
684 static void
685 p_flags(int f, const char *format)
686 {
687 	printf(format, fmt_flags(f));
688 }
689 
690 static const char *
691 fmt_flags(int f)
692 {
693 	static char name[33];
694 	char *flags;
695 	struct bits *p = bits;
696 
697 	for (flags = name; p->b_mask; p++)
698 		if (p->b_mask & f)
699 			*flags++ = p->b_val;
700 	*flags = '\0';
701 	return (name);
702 }
703 
704 static void
705 p_rtentry(struct rtentry *rt)
706 {
707 	static struct ifnet ifnet, *lastif;
708 	struct rtentry parent;
709 	static char buffer[128];
710 	static char prettyname[128];
711 	struct sockaddr *sa;
712 	sa_u addr, mask;
713 
714 	/*
715 	 * Don't print protocol-cloned routes unless -a.
716 	 */
717 	if (rt->rt_flags & RTF_WASCLONED && !aflag) {
718 		kget(rt->rt_parent, parent);
719 		if (parent.rt_flags & RTF_PRCLONING)
720 			return;
721 	}
722 
723 	bzero(&addr, sizeof(addr));
724 	if ((sa = kgetsa(rt_key(rt))))
725 		bcopy(sa, &addr, sa->sa_len);
726 	bzero(&mask, sizeof(mask));
727 	if (rt_mask(rt) && (sa = kgetsa(rt_mask(rt))))
728 		bcopy(sa, &mask, sa->sa_len);
729 	p_sockaddr(&addr.u_sa, &mask.u_sa, rt->rt_flags, wid_dst);
730 	p_sockaddr(kgetsa(rt->rt_gateway), NULL, RTF_HOST, wid_gw);
731 	snprintf(buffer, sizeof(buffer), "%%-%d.%ds ", wid_flags, wid_flags);
732 	p_flags(rt->rt_flags, buffer);
733 	if (addr.u_sa.sa_family == AF_INET || Wflag) {
734 		printf("%*ld %*lu ", wid_refs, rt->rt_refcnt,
735 				     wid_use, rt->rt_use);
736 		if (Wflag) {
737 			if (rt->rt_rmx.rmx_mtu != 0)
738 				printf("%*lu ", wid_mtu, rt->rt_rmx.rmx_mtu);
739 			else
740 				printf("%*s ", wid_mtu, "");
741 		}
742 	}
743 	if (rt->rt_ifp) {
744 		if (rt->rt_ifp != lastif) {
745 			kget(rt->rt_ifp, ifnet);
746 			lastif = rt->rt_ifp;
747 			strlcpy(prettyname, ifnet.if_xname, sizeof(prettyname));
748 		}
749 		printf("%*.*s", wid_if, wid_if, prettyname);
750 		if (rt->rt_rmx.rmx_expire) {
751 			time_t expire_time;
752 
753 			if ((expire_time =
754 			    rt->rt_rmx.rmx_expire - time((time_t *)0)) > 0)
755 				printf(" %*d", wid_expire, (int)expire_time);
756 		}
757 		if (rt->rt_nodes[0].rn_dupedkey)
758 			printf(" =>");
759 	}
760 	putchar('\n');
761 }
762 
763 char *
764 routename(u_long in)
765 {
766 	char *cp;
767 	static char line[MAXHOSTNAMELEN];
768 	struct hostent *hp;
769 
770 	cp = 0;
771 	if (!numeric_addr) {
772 		hp = gethostbyaddr((char *)&in, sizeof (struct in_addr),
773 			AF_INET);
774 		if (hp) {
775 			cp = hp->h_name;
776 			trimdomain(cp, strlen(cp));
777 		}
778 	}
779 	if (cp) {
780 		strncpy(line, cp, sizeof(line) - 1);
781 		line[sizeof(line) - 1] = '\0';
782 	} else {
783 #define C(x)	((x) & 0xff)
784 		in = ntohl(in);
785 		sprintf(line, "%lu.%lu.%lu.%lu",
786 		    C(in >> 24), C(in >> 16), C(in >> 8), C(in));
787 	}
788 	return (line);
789 }
790 
791 static u_long
792 forgemask(u_long a)
793 {
794 	u_long m;
795 
796 	if (IN_CLASSA(a))
797 		m = IN_CLASSA_NET;
798 	else if (IN_CLASSB(a))
799 		m = IN_CLASSB_NET;
800 	else
801 		m = IN_CLASSC_NET;
802 	return (m);
803 }
804 
805 static void
806 domask(char *dst, u_long addr, u_long mask)
807 {
808 	int b, i;
809 
810 	if (!mask || (forgemask(addr) == mask)) {
811 		*dst = '\0';
812 		return;
813 	}
814 	i = 0;
815 	for (b = 0; b < 32; b++)
816 		if (mask & (1 << b)) {
817 			int bb;
818 
819 			i = b;
820 			for (bb = b+1; bb < 32; bb++)
821 				if (!(mask & (1 << bb))) {
822 					i = -1;	/* noncontig */
823 					break;
824 				}
825 			break;
826 		}
827 	if (i == -1)
828 		sprintf(dst, "&0x%lx", mask);
829 	else
830 		sprintf(dst, "/%d", 32-i);
831 }
832 
833 /*
834  * Return the name of the network whose address is given.
835  * The address is assumed to be that of a net or subnet, not a host.
836  */
837 char *
838 netname(u_long in, u_long mask)
839 {
840 	char *cp = 0;
841 	static char line[MAXHOSTNAMELEN];
842 	struct netent *np = 0;
843 	u_long dmask;
844 	u_long i;
845 
846 #define	NSHIFT(m) (							\
847 	(m) == IN_CLASSA_NET ? IN_CLASSA_NSHIFT :			\
848 	(m) == IN_CLASSB_NET ? IN_CLASSB_NSHIFT :			\
849 	(m) == IN_CLASSC_NET ? IN_CLASSC_NSHIFT :			\
850 	0)
851 
852 	i = ntohl(in);
853 	dmask = forgemask(i);
854 	if (!numeric_addr && i) {
855 		np = getnetbyaddr(i >> NSHIFT(mask), AF_INET);
856 		if (np == NULL && mask == 0)
857 			np = getnetbyaddr(i >> NSHIFT(dmask), AF_INET);
858 		if (np != NULL) {
859 			cp = np->n_name;
860 			trimdomain(cp, strlen(cp));
861 		}
862 	}
863 #undef NSHIFT
864 	if (cp != NULL) {
865 		strncpy(line, cp, sizeof(line) - 1);
866 		line[sizeof(line) - 1] = '\0';
867 	} else {
868 		switch (dmask) {
869 		case IN_CLASSA_NET:
870 			if ((i & IN_CLASSA_HOST) == 0) {
871 				sprintf(line, "%lu", C(i >> 24));
872 				break;
873 			}
874 			/* FALLTHROUGH */
875 		case IN_CLASSB_NET:
876 			if ((i & IN_CLASSB_HOST) == 0) {
877 				sprintf(line, "%lu.%lu",
878 					C(i >> 24), C(i >> 16));
879 				break;
880 			}
881 			/* FALLTHROUGH */
882 		case IN_CLASSC_NET:
883 			if ((i & IN_CLASSC_HOST) == 0) {
884 				sprintf(line, "%lu.%lu.%lu",
885 					C(i >> 24), C(i >> 16), C(i >> 8));
886 				break;
887 			}
888 			/* FALLTHROUGH */
889 		default:
890 			sprintf(line, "%lu.%lu.%lu.%lu",
891 				C(i >> 24), C(i >> 16), C(i >> 8), C(i));
892 			break;
893 		}
894 	}
895 	domask(line + strlen(line), i, mask);
896 	return (line);
897 }
898 
899 #ifdef INET6
900 const char *
901 netname6(struct sockaddr_in6 *sa6, struct in6_addr *mask)
902 {
903 	static char line[MAXHOSTNAMELEN];
904 	u_char *p = (u_char *)mask;
905 	u_char *lim;
906 	int masklen, illegal = 0, flag = 0;
907 
908 	if (mask) {
909 		for (masklen = 0, lim = p + 16; p < lim; p++) {
910 			switch (*p) {
911 			 case 0xff:
912 				 masklen += 8;
913 				 break;
914 			 case 0xfe:
915 				 masklen += 7;
916 				 break;
917 			 case 0xfc:
918 				 masklen += 6;
919 				 break;
920 			 case 0xf8:
921 				 masklen += 5;
922 				 break;
923 			 case 0xf0:
924 				 masklen += 4;
925 				 break;
926 			 case 0xe0:
927 				 masklen += 3;
928 				 break;
929 			 case 0xc0:
930 				 masklen += 2;
931 				 break;
932 			 case 0x80:
933 				 masklen += 1;
934 				 break;
935 			 case 0x00:
936 				 break;
937 			 default:
938 				 illegal ++;
939 				 break;
940 			}
941 		}
942 		if (illegal)
943 			fprintf(stderr, "illegal prefixlen\n");
944 	}
945 	else
946 		masklen = 128;
947 
948 	if (masklen == 0 && IN6_IS_ADDR_UNSPECIFIED(&sa6->sin6_addr))
949 		return("default");
950 
951 	if (numeric_addr)
952 		flag |= NI_NUMERICHOST;
953 	getnameinfo((struct sockaddr *)sa6, sa6->sin6_len, line, sizeof(line),
954 		    NULL, 0, flag);
955 
956 	if (numeric_addr)
957 		sprintf(&line[strlen(line)], "/%d", masklen);
958 
959 	return line;
960 }
961 
962 char *
963 routename6(struct sockaddr_in6 *sa6)
964 {
965 	static char line[MAXHOSTNAMELEN];
966 	int flag = 0;
967 	/* use local variable for safety */
968 	struct sockaddr_in6 sa6_local = {AF_INET6, sizeof(sa6_local),};
969 
970 	sa6_local.sin6_addr = sa6->sin6_addr;
971 	sa6_local.sin6_scope_id = sa6->sin6_scope_id;
972 
973 	if (numeric_addr)
974 		flag |= NI_NUMERICHOST;
975 
976 	getnameinfo((struct sockaddr *)&sa6_local, sa6_local.sin6_len,
977 		    line, sizeof(line), NULL, 0, flag);
978 
979 	return line;
980 }
981 #endif /*INET6*/
982 
983 /*
984  * Print routing statistics
985  */
986 void
987 rt_stats(u_long rtsaddr, u_long rttaddr)
988 {
989 	struct rtstat rtstat;
990 	int rttrash;
991 
992 	if (rtsaddr == 0) {
993 		printf("rtstat: symbol not in namelist\n");
994 		return;
995 	}
996 	if (rttaddr == 0) {
997 		printf("rttrash: symbol not in namelist\n");
998 		return;
999 	}
1000 	kread(rtsaddr, (char *)&rtstat, sizeof (rtstat));
1001 	kread(rttaddr, (char *)&rttrash, sizeof (rttrash));
1002 	printf("routing:\n");
1003 
1004 #define	p(f, m) if (rtstat.f || sflag <= 1) \
1005 	printf(m, rtstat.f, plural(rtstat.f))
1006 
1007 	p(rts_badredirect, "\t%u bad routing redirect%s\n");
1008 	p(rts_dynamic, "\t%u dynamically created route%s\n");
1009 	p(rts_newgateway, "\t%u new gateway%s due to redirects\n");
1010 	p(rts_unreach, "\t%u destination%s found unreachable\n");
1011 	p(rts_wildcard, "\t%u use%s of a wildcard route\n");
1012 #undef p
1013 
1014 	if (rttrash || sflag <= 1)
1015 		printf("\t%u route%s not in table but not freed\n",
1016 		    rttrash, plural(rttrash));
1017 }
1018 
1019 char *
1020 ipx_print(struct sockaddr *sa)
1021 {
1022 	u_short port;
1023 	struct servent *sp = 0;
1024 	const char *net = "", *host = "";
1025 	char *p;
1026 	u_char *q;
1027 	struct ipx_addr work = ((struct sockaddr_ipx *)sa)->sipx_addr;
1028 	static char mybuf[50];
1029 	char cport[10], chost[15], cnet[15];
1030 
1031 	port = ntohs(work.x_port);
1032 
1033 	if (ipx_nullnet(work) && ipx_nullhost(work)) {
1034 
1035 		if (port) {
1036 			if (sp)
1037 				sprintf(mybuf, "*.%s", sp->s_name);
1038 			else
1039 				sprintf(mybuf, "*.%x", port);
1040 		} else
1041 			sprintf(mybuf, "*.*");
1042 
1043 		return (mybuf);
1044 	}
1045 
1046 	if (ipx_wildnet(work))
1047 		net = "any";
1048 	else if (ipx_nullnet(work))
1049 		net = "*";
1050 	else {
1051 		q = work.x_net.c_net;
1052 		sprintf(cnet, "%02x%02x%02x%02x",
1053 			q[0], q[1], q[2], q[3]);
1054 		for (p = cnet; *p == '0' && p < cnet + 8; p++)
1055 			continue;
1056 		net = p;
1057 	}
1058 
1059 	if (ipx_wildhost(work))
1060 		host = "any";
1061 	else if (ipx_nullhost(work))
1062 		host = "*";
1063 	else {
1064 		q = work.x_host.c_host;
1065 		sprintf(chost, "%02x%02x%02x%02x%02x%02x",
1066 			q[0], q[1], q[2], q[3], q[4], q[5]);
1067 		for (p = chost; *p == '0' && p < chost + 12; p++)
1068 			continue;
1069 		host = p;
1070 	}
1071 
1072 	if (port) {
1073 		if (strcmp(host, "*") == 0)
1074 			host = "";
1075 		if (sp)
1076 			snprintf(cport, sizeof(cport),
1077 				"%s%s", *host ? "." : "", sp->s_name);
1078 		else
1079 			snprintf(cport, sizeof(cport),
1080 				"%s%x", *host ? "." : "", port);
1081 	} else
1082 		*cport = 0;
1083 
1084 	snprintf(mybuf, sizeof(mybuf), "%s.%s%s", net, host, cport);
1085 	return(mybuf);
1086 }
1087 
1088 char *
1089 ipx_phost(struct sockaddr *sa)
1090 {
1091 	struct sockaddr_ipx *sipx = (struct sockaddr_ipx *)sa;
1092 	struct sockaddr_ipx work;
1093 	static union ipx_net ipx_zeronet;
1094 	char *p;
1095 	struct ipx_addr in;
1096 
1097 	work = *sipx;
1098 	in = work.sipx_addr;
1099 
1100 	work.sipx_addr.x_port = 0;
1101 	work.sipx_addr.x_net = ipx_zeronet;
1102 	p = ipx_print((struct sockaddr *)&work);
1103 	if (strncmp("*.", p, 2) == 0) p += 2;
1104 
1105 	return(p);
1106 }
1107 
1108 void
1109 upHex(char *p0)
1110 {
1111 	char *p = p0;
1112 
1113 	for (; *p; p++)
1114 		switch (*p) {
1115 
1116 		case 'a':
1117 		case 'b':
1118 		case 'c':
1119 		case 'd':
1120 		case 'e':
1121 		case 'f':
1122 			*p += ('A' - 'a');
1123 			break;
1124 		}
1125 }
1126