[unix-history] / usr.bin / netstat / route.c

/*
 * Copyright (c) 1983, 1988 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#ifndef lint
/* From: static char sccsid[] = "@(#)route.c	5.20 (Berkeley) 11/29/90"; */
static const char route_c_rcsid[] =
	"$Id$";
#endif /* not lint */

#include <sys/param.h>
#include <sys/socket.h>
#include <sys/mbuf.h>

#include <net/if.h>
#define  KERNEL
#include <net/route.h>
#undef KERNEL
#include <netinet/in.h>

#ifdef NS
#include <netns/ns.h>
#endif

#include <netdb.h>
#include <sys/kinfo.h>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

extern	int nflag, aflag, Aflag, af;
int do_rtent;
extern	char *routename(), *netname(), *plural();
#ifdef NS
extern	char *ns_print();
#endif

#define kget(p, d) \
	(kvm_read((off_t)(p), (char *)&(d), sizeof (d)))

/*
 * Definitions for showing gateway flags.
 */
struct bits {
	short	b_mask;
	char	b_val;
} bits[] = {
	{ RTF_UP,	'U' },
	{ RTF_GATEWAY,	'G' },
	{ RTF_HOST,	'H' },
	{ RTF_DYNAMIC,	'D' },
	{ RTF_MODIFIED,	'M' },
	{ RTF_CLONING,	'C' },
	{ RTF_XRESOLVE,	'X' },
	{ RTF_LLINFO,	'L' },
	{ RTF_REJECT,	'R' },
	{ RTF_PROTO2,	'2' },
	{ RTF_PROTO1,	'1' },
	{ 0 }
};

/*
 * Print address family.
 */
void
p_proto(proto)
	int	proto;
{
	switch (proto)
	{
	case AF_INET:
		printf("inet");
		break;
	case AF_NS:
		printf("NS");
		break;
	case AF_OSI:
		printf("OSI");
		break;
	case AF_CCITT:
		printf("CCITT");
		break;
	case AF_APPLETALK:
		printf("AppleTalk");
		break;
	default:
		printf("%d", proto);
		break;
	}
}


/*
 * Print routing tables.
 */
int
routepr(hostaddr, netaddr, hashsizeaddr, treeaddr)
	off_t hostaddr, netaddr, hashsizeaddr, treeaddr;
{
	struct mbuf mb;
	register struct ortentry *rt;
	register struct mbuf *m;
	char name[16], *flags;
	struct mbuf **routehash;
	int hashsize;
	int i, doinghost = 1;

	if (!treeaddr) {
		printf("Could not find routing tables\n");
		return 1;
	}
	printf("Routing tables\n");
	if (Aflag)
		printf("%-8.8s ","Address");
	printf("%-16.16s %-18.18s %-6.6s  %6.6s%8.8s  %-5.5s",
		"Destination", "Gateway",
		"Flags", "Refs", "Use", "Iface");
	if(!aflag) {
		printf("%-6.6s %-6.6s\n", "MTU", "Rtt");
	} else {
		printf("\n    %8s %8s %8s %8s %8s %8s %8s %8s\n",
		       "MTU", "Hopcount", "Expire", "recvpipe",
		       "sendpipe", "ssthresh", "RTT", "RTT var.");
	}

	return treestuff(treeaddr);

}

static union {
	struct	sockaddr u_sa;
	u_short	u_data[128];
} pt_u;
int do_rtent = 0;
struct rtentry rtentry;
struct radix_node rnode;
struct radix_mask rmask;

int NewTree = 0;
treestuff(rtree)
off_t rtree;
{
	struct radix_node_head *rnh, head;

	if (Aflag == 0 && NewTree)
		return(ntreestuff());
	for (kget(rtree, rnh); rnh; rnh = head.rnh_next) {
		kget(rnh, head);
		if (head.rnh_af == 0) {
			if (Aflag || af == AF_UNSPEC) { 
				printf("Netmasks:\n");
				p_tree(head.rnh_treetop);
			}
		} else if (af == AF_UNSPEC || af == head.rnh_af) {
			printf("\nRoute Tree for Protocol Family ");
			p_proto(head.rnh_af);
			printf(":\n");
			do_rtent = 1;
			p_tree(head.rnh_treetop);
		}
	}
}

struct sockaddr *
kgetsa(dst)
register struct sockaddr *dst;
{
	kget(dst, pt_u.u_sa);
	if (pt_u.u_sa.sa_len > sizeof (pt_u.u_sa)) {
		kvm_read((off_t)dst, pt_u.u_data, pt_u.u_sa.sa_len);
	}
	return (&pt_u.u_sa);
}

p_tree(rn)
struct radix_node *rn;
{

again:
	kget(rn, rnode);
	if (rnode.rn_b < 0) {
		if (Aflag)
			printf("%-8.8x ", rn);
		if (rnode.rn_flags & RNF_ROOT)
			printf("(root node)%s",
				    rnode.rn_dupedkey ? " =>\n" : "\n");
		else if (do_rtent) {
			kget(rn, rtentry);
			p_rtentry(&rtentry);
			if (Aflag)
				p_rtnode();
		} else {
			p_sockaddr(kgetsa((struct sockaddr *)rnode.rn_key),
				    0, 44);
			putchar('\n');
		}
		if (rn = rnode.rn_dupedkey)
			goto again;
	} else {
		if (Aflag && do_rtent) {
			printf("%-8.8x ", rn);
			p_rtnode();
		}
		rn = rnode.rn_r;
		p_tree(rnode.rn_l);
		p_tree(rn);
	}
}
char nbuf[20];

p_rtnode()
{

	struct radix_mask *rm = rnode.rn_mklist;
	if (rnode.rn_b < 0) {
		if (rnode.rn_mask) {
			printf("\t  mask ");
			p_sockaddr(kgetsa((struct sockaddr *)rnode.rn_mask),
				    0, -1);
		} else if (rm == 0)
			return;
	} else {
		sprintf(nbuf, "(%d)", rnode.rn_b);
		printf("%6.6s %8.8x : %8.8x", nbuf, rnode.rn_l, rnode.rn_r);
	}
	while (rm) {
		kget(rm, rmask);
		sprintf(nbuf, " %d refs, ", rmask.rm_refs);
		printf(" mk = %8.8x {(%d),%s",
			rm, -1 - rmask.rm_b, rmask.rm_refs ? nbuf : " ");
		p_sockaddr(kgetsa((struct sockaddr *)rmask.rm_mask), 0, -1);
		putchar('}');
		if (rm = rmask.rm_mklist)
			printf(" ->");
	}
	putchar('\n');
}

ntreestuff()
{
	int needed;
	char *buf, *next, *lim;
	register struct rt_msghdr *rtm;

	if ((needed = getkerninfo(KINFO_RT_DUMP, 0, 0, 0)) < 0)
		{ perror("route-getkerninfo-estimate"); exit(1);}
	if ((buf = malloc(needed)) == 0)
		{ printf("out of space\n"); exit(1);}
	if (getkerninfo(KINFO_RT_DUMP, buf, &needed, 0) < 0)
		{ perror("actual retrieval of routing table"); exit(1);}
	lim  = buf + needed;
	for (next = buf; next < lim; next += rtm->rtm_msglen) {
		rtm = (struct rt_msghdr *)next;
		np_rtentry(rtm);
	}
}

np_rtentry(rtm)
register struct rt_msghdr *rtm;
{
	register struct sockaddr *sa = (struct sockaddr *)(rtm + 1);
	static int masks_done, old_af, banner_printed;
	int af = 0, interesting = RTF_UP | RTF_GATEWAY | RTF_HOST;

#ifdef notdef
	/* for the moment, netmasks are skipped over */
	if (!banner_printed) {
		printf("Netmasks:\n");
		banner_printed = 1;
	}
	if (masks_done == 0) {
		if (rtm->rtm_addrs != RTA_DST ) {
			masks_done = 1;
			af = sa->sa_family;
		}
	} else
#endif
		af = sa->sa_family;
	if (af != old_af) {
		printf("\nRoute Tree for Protocol Family %d:\n", af);
		old_af = af;
	}
	if (rtm->rtm_addrs == RTA_DST)
		p_sockaddr(sa, 0, 36);
	else {
		p_sockaddr(sa, rtm->rtm_flags, 16);
		if (sa->sa_len == 0)
			sa->sa_len = sizeof(long);
		sa = (struct sockaddr *)(sa->sa_len + (char *)sa);
		p_sockaddr(sa, 0, 18);
	}
	p_flags(rtm->rtm_flags & interesting, "%-6.6s ");
	putchar('\n');
}

p_sockaddr(sa, flags, width)
struct sockaddr *sa;
int flags, width;
{
	char format[20], workbuf[128], *cp, *cplim;
	register char *cpout;

	switch(sa->sa_family) {
	case AF_INET:
	    {
		register struct sockaddr_in *sin = (struct sockaddr_in *)sa;

		cp = (sin->sin_addr.s_addr == 0) ? "default" :
		      ((flags & RTF_HOST) ?
			routename(sin->sin_addr) : netname(sin->sin_addr, 0L));
	    }
		break;

#ifdef NS
	case AF_NS:
		cp = ns_print((struct sockaddr_ns *)sa);
		break;
#endif

	default:
	    {
		register u_short *s = ((u_short *)sa->sa_data), *slim;

		slim = (u_short *) sa + ((sa->sa_len + sizeof(u_short) - 1) /
		    sizeof(u_short));
		cp = workbuf;
		cplim = cp + sizeof(workbuf) - 6;
		cp += sprintf(cp, "(%d)", sa->sa_family);
		while (s < slim && cp < cplim)
			cp += sprintf(cp, " %x", *s++);
		cp = workbuf;
	    }
	}
	if (width < 0 )
		printf("%s ", cp);
	else {
		if (nflag)
			printf("%-*s ", width, cp);
		else
			printf("%-*.*s ", width, width, cp);
	}
}

p_flags(f, format)
register int f;
char *format;
{
	char name[33], *flags;
	register struct bits *p = bits;
	for (flags = name; p->b_mask; p++)
		if (p->b_mask & f)
			*flags++ = p->b_val;
	*flags = '\0';
	printf(format, name);
}

p_rtentry(rt)
register struct rtentry *rt;
{
	char name[16];
	register struct sockaddr *sa;
	struct ifnet ifnet;

	p_sockaddr(kgetsa(rt_key(rt)), rt->rt_flags, 16);
	p_sockaddr(kgetsa(rt->rt_gateway), RTF_HOST, 18);
	p_flags(rt->rt_flags, "%-6.6s ");
	printf("%6d %8d ", rt->rt_refcnt, rt->rt_use);
	if (rt->rt_ifp == 0) {
		putchar('\n');
		return;
	}
	kget(rt->rt_ifp, ifnet);
	kvm_read((off_t)ifnet.if_name, name, 16);
	printf(" %.2s%d", name, ifnet.if_unit);
	if(aflag) {
	  /*
	   * MTU
	   */
	  if(rt->rt_rmx.rmx_mtu)
	    printf("\n    %7d%c", rt->rt_rmx.rmx_mtu, 
		   (rt->rt_rmx.rmx_locks & RTV_MTU) ? '*' : ' ');
	  else
	    printf("\n    %-7s ", "-");

	  /*
	   * Hop count
	   */
	  if(rt->rt_rmx.rmx_hopcount)
	    printf(" %7d%c", rt->rt_rmx.rmx_hopcount,
		   (rt->rt_rmx.rmx_locks & RTV_HOPCOUNT) ? '*' : ' ');
	  else
	    printf(" %-6s ", "-");
	  
	  /*
	   * Expiration time
	   */
	  if(rt->rt_rmx.rmx_expire)
	    printf(" %7d%c", rt->rt_rmx.rmx_expire,
		   (rt->rt_rmx.rmx_locks & RTV_EXPIRE) ? '*' : ' ');
	  else
	    printf(" %-7s ", "-");

	  /*
	   * Receive pipe size (bytes)
	   */
	  if(rt->rt_rmx.rmx_recvpipe)
	    printf(" %7d%c", rt->rt_rmx.rmx_recvpipe,
		   (rt->rt_rmx.rmx_locks & RTV_RPIPE) ? '*' : ' ');
	  else
	    printf(" %-7s ", "-");

	  /*
	   * Send pipe size (bytes)
	   */
	  if(rt->rt_rmx.rmx_sendpipe)
	    printf(" %7d%c", rt->rt_rmx.rmx_sendpipe,
		   (rt->rt_rmx.rmx_locks & RTV_SPIPE) ? '*' : ' ');
	  else
	    printf(" %-7s ", "-");

	  /*
	   * Slow-start threshold (bytes)
	   */
	  if(rt->rt_rmx.rmx_ssthresh)
	    printf(" %7d%c", rt->rt_rmx.rmx_ssthresh,
		   (rt->rt_rmx.rmx_locks & RTV_SSTHRESH) ? '*' : ' ');
	  else
	    printf(" %-7s ", "-");

	  /*
	   * Round-trip time (seconds)
	   */
	  if(rt->rt_rmx.rmx_rtt)
	    printf(" %7.4f%c", (1.0 * rt->rt_rmx.rmx_rtt) / RTM_RTTUNIT,
		   (rt->rt_rmx.rmx_locks & RTV_RTT) ? '*' : ' ');
	  else
	    printf(" %-7s ", "-");

	  /*
	   * Round-trip time variance (seconds)
	   */
	  if(rt->rt_rmx.rmx_rttvar)
	    printf(" %7.4f%c", (1.0 * rt->rt_rmx.rmx_rttvar) / RTM_RTTUNIT,
		   (rt->rt_rmx.rmx_locks & RTV_RTTVAR) ? '*' : ' ');
	  else
	    printf(" %-7s ", "-");
	} else {		/* no -a flag */
	  if(rt->rt_rmx.rmx_mtu)
	    printf(" %6d", rt->rt_rmx.rmx_mtu);
	  else
	    printf(" %-6s", "-");
	  if(rt->rt_rmx.rmx_rtt)
	    printf(" %6.3f", (1. * rt->rt_rmx.rmx_rtt) / RTM_RTTUNIT);
	  else
	    printf(" %-6s", "-");
	}
	printf(rt->rt_nodes[0].rn_dupedkey ? " =>\n" : "\n");
}

char *
routename(in)
	struct in_addr in;
{
	register char *cp;
	static char line[MAXHOSTNAMELEN + 1];
	struct hostent *hp;
	static char domain[MAXHOSTNAMELEN + 1];
	static int first = 1;
	char *index();

	if (first) {
		first = 0;
		if (gethostname(domain, MAXHOSTNAMELEN) == 0 &&
		    (cp = index(domain, '.')))
			(void) strcpy(domain, cp + 1);
		else
			domain[0] = 0;
	}
	cp = 0;
	if (!nflag) {
		hp = gethostbyaddr((char *)&in, sizeof (struct in_addr),
			AF_INET);
		if (hp) {
			if ((cp = index(hp->h_name, '.')) &&
			    !strcmp(cp + 1, domain))
				*cp = 0;
			cp = hp->h_name;
		}
	}
	if (cp)
		strncpy(line, cp, sizeof(line) - 1);
	else {
#define C(x)	((x) & 0xff)
		in.s_addr = ntohl(in.s_addr);
		sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24),
			C(in.s_addr >> 16), C(in.s_addr >> 8), C(in.s_addr));
	}
	return (line);
}

/*
 * Return the name of the network whose address is given.
 * The address is assumed to be that of a net or subnet, not a host.
 */
char *
netname(in, mask)
	struct in_addr in;
	u_long mask;
{
	char *cp = 0;
	static char line[MAXHOSTNAMELEN + 1];
	struct netent *np = 0;
	u_long net;
	register i;
	int subnetshift;

	i = ntohl(in.s_addr);
	if (!nflag && i) {
		if (mask == 0) {
			if (IN_CLASSA(i)) {
				mask = IN_CLASSA_NET;
				subnetshift = 8;
			} else if (IN_CLASSB(i)) {
				mask = IN_CLASSB_NET;
				subnetshift = 8;
			} else {
				mask = IN_CLASSC_NET;
				subnetshift = 4;
			}
			/*
			 * If there are more bits than the standard mask
			 * would suggest, subnets must be in use.
			 * Guess at the subnet mask, assuming reasonable
			 * width subnet fields.
			 */
			while (i &~ mask)
				mask = (long)mask >> subnetshift;
		}
		net = i & mask;
		while ((mask & 1) == 0)
			mask >>= 1, net >>= 1;
		np = getnetbyaddr(net, AF_INET);
		if (np)
			cp = np->n_name;
	}	
	if (cp)
		strncpy(line, cp, sizeof(line) - 1);
	else if ((i & 0xffffff) == 0)
		sprintf(line, "%u", C(i >> 24));
	else if ((i & 0xffff) == 0)
		sprintf(line, "%u.%u", C(i >> 24) , C(i >> 16));
	else if ((i & 0xff) == 0)
		sprintf(line, "%u.%u.%u", C(i >> 24), C(i >> 16), C(i >> 8));
	else
		sprintf(line, "%u.%u.%u.%u", C(i >> 24),
			C(i >> 16), C(i >> 8), C(i));
	return (line);
}

/*
 * Print routing statistics
 */
rt_stats(off)
	off_t off;
{
	struct rtstat rtstat;

	if (off == 0) {
		printf("rtstat: symbol not in namelist\n");
		return;
	}
	kvm_read(off, (char *)&rtstat, sizeof (rtstat));
	printf("routing:\n");
	printf("\t%u bad routing redirect%s\n",
		rtstat.rts_badredirect, plural(rtstat.rts_badredirect));
	printf("\t%u dynamically created route%s\n",
		rtstat.rts_dynamic, plural(rtstat.rts_dynamic));
	printf("\t%u new gateway%s due to redirects\n",
		rtstat.rts_newgateway, plural(rtstat.rts_newgateway));
	printf("\t%u destination%s found unreachable\n",
		rtstat.rts_unreach, plural(rtstat.rts_unreach));
	printf("\t%u use%s of a wildcard route\n",
		rtstat.rts_wildcard, plural(rtstat.rts_wildcard));
}
#ifdef NS
short ns_nullh[] = {0,0,0};
short ns_bh[] = {-1,-1,-1};

char *
ns_print(sns)
struct sockaddr_ns *sns;
{
	struct ns_addr work;
	union { union ns_net net_e; u_long long_e; } net;
	u_short port;
	static char mybuf[50], cport[10], chost[25];
	char *host = "";
	register char *p; register u_char *q;

	work = sns->sns_addr;
	port = ntohs(work.x_port);
	work.x_port = 0;
	net.net_e  = work.x_net;
	if (ns_nullhost(work) && net.long_e == 0) {
		if (port ) {
			sprintf(mybuf, "*.%xH", port);
			upHex(mybuf);
		} else
			sprintf(mybuf, "*.*");
		return (mybuf);
	}

	if (bcmp(ns_bh, work.x_host.c_host, 6) == 0) {
		host = "any";
	} else if (bcmp(ns_nullh, work.x_host.c_host, 6) == 0) {
		host = "*";
	} else {
		q = work.x_host.c_host;
		sprintf(chost, "%02x%02x%02x%02x%02x%02xH",
			q[0], q[1], q[2], q[3], q[4], q[5]);
		for (p = chost; *p == '0' && p < chost + 12; p++);
		host = p;
	}
	if (port)
		sprintf(cport, ".%xH", htons(port));
	else
		*cport = 0;

	sprintf(mybuf,"%xH.%s%s", ntohl(net.long_e), host, cport);
	upHex(mybuf);
	return(mybuf);
}

char *
ns_phost(sns)
struct sockaddr_ns *sns;
{
	struct sockaddr_ns work;
	static union ns_net ns_zeronet;
	char *p;
	
	work = *sns;
	work.sns_addr.x_port = 0;
	work.sns_addr.x_net = ns_zeronet;

	p = ns_print(&work);
	if (strncmp("0H.", p, 3) == 0) p += 3;
	return(p);
}
upHex(p0)
char *p0;
{
	register char *p = p0;
	for (; *p; p++) switch (*p) {

	case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
		*p += ('A' - 'a');
	}
}
#endif /* NS */
Commit	Line	Data
15637ed4 RG	1	/*
	2	* Copyright (c) 1983, 1988 Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	* 3. All advertising materials mentioning features or use of this software
	14	* must display the following acknowledgement:
	15	* This product includes software developed by the University of
	16	* California, Berkeley and its contributors.
	17	* 4. Neither the name of the University nor the names of its contributors
	18	* may be used to endorse or promote products derived from this software
	19	* without specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	22	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	24	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	25	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	26	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	27	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	29	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	30	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	31	* SUCH DAMAGE.
	32	*/
	33
	34	#ifndef lint
49f80972 GW	35	/* From: static char sccsid[] = "@(#)route.c 5.20 (Berkeley) 11/29/90"; */
	36	static const char route_c_rcsid[] =
	37	"$Id$";
15637ed4 RG	38	#endif /* not lint */
	39
	40	#include <sys/param.h>
	41	#include <sys/socket.h>
	42	#include <sys/mbuf.h>
	43
	44	#include <net/if.h>
	45	#define KERNEL
	46	#include <net/route.h>
	47	#undef KERNEL
	48	#include <netinet/in.h>
	49
	50	#ifdef NS
	51	#include <netns/ns.h>
	52	#endif
	53
	54	#include <netdb.h>
	55	#include <sys/kinfo.h>
	56
	57	#include <stdio.h>
	58	#include <string.h>
a2a107a3	59	#include <stdlib.h>
15637ed4 RG	60
	61	extern int nflag, aflag, Aflag, af;
	62	int do_rtent;
	63	extern char routename(), netname(), *plural();
	64	#ifdef NS
10948f21	65	extern char *ns_print();
15637ed4	66	#endif
a2a107a3	67
15637ed4 RG	68	#define kget(p, d) \
	69	(kvm_read((off_t)(p), (char *)&(d), sizeof (d)))
	70
	71	/*
	72	* Definitions for showing gateway flags.
	73	*/
	74	struct bits {
	75	short b_mask;
	76	char b_val;
	77	} bits[] = {
	78	{ RTF_UP, 'U' },
	79	{ RTF_GATEWAY, 'G' },
	80	{ RTF_HOST, 'H' },
	81	{ RTF_DYNAMIC, 'D' },
	82	{ RTF_MODIFIED, 'M' },
	83	{ RTF_CLONING, 'C' },
	84	{ RTF_XRESOLVE, 'X' },
	85	{ RTF_LLINFO, 'L' },
	86	{ RTF_REJECT, 'R' },
a2a107a3 GW	87	{ RTF_PROTO2, '2' },
a2a107a3 GW	88	{ RTF_PROTO1, '1' },
15637ed4 RG	89	{ 0 }
	90	};
	91
f76b4708 NW	92	/*
	93	* Print address family.
	94	*/
	95	void
	96	p_proto(proto)
	97	int proto;
	98	{
	99	switch (proto)
	100	{
	101	case AF_INET:
	102	printf("inet");
	103	break;
ad0448d8 GW	104	case AF_NS:
	105	printf("NS");
	106	break;
	107	case AF_OSI:
	108	printf("OSI");
	109	break;
	110	case AF_CCITT:
	111	printf("CCITT");
	112	break;
	113	case AF_APPLETALK:
	114	printf("AppleTalk");
	115	break;
f76b4708 NW	116	default:
	117	printf("%d", proto);
	118	break;
	119	}
	120	}
	121
	122
15637ed4 RG	123	/*
	124	* Print routing tables.
	125	*/
a2a107a3	126	int
15637ed4 RG	127	routepr(hostaddr, netaddr, hashsizeaddr, treeaddr)
	128	off_t hostaddr, netaddr, hashsizeaddr, treeaddr;
	129	{
	130	struct mbuf mb;
	131	register struct ortentry *rt;
	132	register struct mbuf *m;
	133	char name[16], *flags;
	134	struct mbuf **routehash;
	135	int hashsize;
	136	int i, doinghost = 1;
	137
a2a107a3 GW	138	if (!treeaddr) {
	139	printf("Could not find routing tables\n");
	140	return 1;
	141	}
15637ed4 RG	142	printf("Routing tables\n");
	143	if (Aflag)
	144	printf("%-8.8s ","Address");
a2a107a3	145	printf("%-16.16s %-18.18s %-6.6s %6.6s%8.8s %-5.5s",
15637ed4	146	"Destination", "Gateway",
a2a107a3 GW	147	"Flags", "Refs", "Use", "Iface");
	148	if(!aflag) {
	149	printf("%-6.6s %-6.6s\n", "MTU", "Rtt");
	150	} else {
	151	printf("\n %8s %8s %8s %8s %8s %8s %8s %8s\n",
	152	"MTU", "Hopcount", "Expire", "recvpipe",
	153	"sendpipe", "ssthresh", "RTT", "RTT var.");
	154	}
	155
	156	return treestuff(treeaddr);
	157
15637ed4 RG	158	}
	159
	160	static union {
	161	struct sockaddr u_sa;
	162	u_short u_data[128];
	163	} pt_u;
	164	int do_rtent = 0;
	165	struct rtentry rtentry;
	166	struct radix_node rnode;
	167	struct radix_mask rmask;
	168
	169	int NewTree = 0;
	170	treestuff(rtree)
	171	off_t rtree;
	172	{
	173	struct radix_node_head *rnh, head;
	174
	175	if (Aflag == 0 && NewTree)
	176	return(ntreestuff());
	177	for (kget(rtree, rnh); rnh; rnh = head.rnh_next) {
	178	kget(rnh, head);
	179	if (head.rnh_af == 0) {
	180	if (Aflag \|\| af == AF_UNSPEC) {
	181	printf("Netmasks:\n");
	182	p_tree(head.rnh_treetop);
	183	}
	184	} else if (af == AF_UNSPEC \|\| af == head.rnh_af) {
f76b4708 NW	185	printf("\nRoute Tree for Protocol Family ");
	186	p_proto(head.rnh_af);
	187	printf(":\n");
15637ed4 RG	188	do_rtent = 1;
	189	p_tree(head.rnh_treetop);
	190	}
	191	}
	192	}
	193
	194	struct sockaddr *
	195	kgetsa(dst)
	196	register struct sockaddr *dst;
	197	{
	198	kget(dst, pt_u.u_sa);
	199	if (pt_u.u_sa.sa_len > sizeof (pt_u.u_sa)) {
	200	kvm_read((off_t)dst, pt_u.u_data, pt_u.u_sa.sa_len);
	201	}
	202	return (&pt_u.u_sa);
	203	}
	204
	205	p_tree(rn)
	206	struct radix_node *rn;
	207	{
	208
	209	again:
	210	kget(rn, rnode);
	211	if (rnode.rn_b < 0) {
	212	if (Aflag)
	213	printf("%-8.8x ", rn);
	214	if (rnode.rn_flags & RNF_ROOT)
	215	printf("(root node)%s",
	216	rnode.rn_dupedkey ? " =>\n" : "\n");
	217	else if (do_rtent) {
	218	kget(rn, rtentry);
	219	p_rtentry(&rtentry);
	220	if (Aflag)
	221	p_rtnode();
	222	} else {
	223	p_sockaddr(kgetsa((struct sockaddr *)rnode.rn_key),
	224	0, 44);
	225	putchar('\n');
	226	}
	227	if (rn = rnode.rn_dupedkey)
	228	goto again;
	229	} else {
	230	if (Aflag && do_rtent) {
	231	printf("%-8.8x ", rn);
	232	p_rtnode();
	233	}
	234	rn = rnode.rn_r;
	235	p_tree(rnode.rn_l);
	236	p_tree(rn);
	237	}
	238	}
	239	char nbuf[20];
	240
	241	p_rtnode()
	242	{
	243
	244	struct radix_mask *rm = rnode.rn_mklist;
	245	if (rnode.rn_b < 0) {
	246	if (rnode.rn_mask) {
	247	printf("\t mask ");
	248	p_sockaddr(kgetsa((struct sockaddr *)rnode.rn_mask),
	249	0, -1);
	250	} else if (rm == 0)
	251	return;
252	} else {
253	sprintf(nbuf, "(%d)", rnode.rn_b);
254	printf("%6.6s %8.8x : %8.8x", nbuf, rnode.rn_l, rnode.rn_r);
255	}
256	while (rm) {
257	kget(rm, rmask);
258	sprintf(nbuf, " %d refs, ", rmask.rm_refs);
259	printf(" mk = %8.8x {(%d),%s",
260	rm, -1 - rmask.rm_b, rmask.rm_refs ? nbuf : " ");
261	p_sockaddr(kgetsa((struct sockaddr *)rmask.rm_mask), 0, -1);
262	putchar('}');
263	if (rm = rmask.rm_mklist)
264	printf(" ->");
265	}
266	putchar('\n');
267	}
268
269	ntreestuff()
270	{
271	int needed;
272	char buf, next, *lim;
273	register struct rt_msghdr *rtm;
274
275	if ((needed = getkerninfo(KINFO_RT_DUMP, 0, 0, 0)) < 0)
276	{ perror("route-getkerninfo-estimate"); exit(1);}
277	if ((buf = malloc(needed)) == 0)
278	{ printf("out of space\n"); exit(1);}
279	if (getkerninfo(KINFO_RT_DUMP, buf, &needed, 0) < 0)
280	{ perror("actual retrieval of routing table"); exit(1);}
281	lim = buf + needed;
282	for (next = buf; next < lim; next += rtm->rtm_msglen) {
283	rtm = (struct rt_msghdr *)next;
284	np_rtentry(rtm);
285	}
286	}
287
288	np_rtentry(rtm)
289	register struct rt_msghdr *rtm;
290	{
291	register struct sockaddr sa = (struct sockaddr )(rtm + 1);
292	static int masks_done, old_af, banner_printed;
293	int af = 0, interesting = RTF_UP \| RTF_GATEWAY \| RTF_HOST;
294
295	#ifdef notdef
296	/* for the moment, netmasks are skipped over */
297	if (!banner_printed) {
298	printf("Netmasks:\n");
299	banner_printed = 1;
300	}
301	if (masks_done == 0) {
302	if (rtm->rtm_addrs != RTA_DST ) {
303	masks_done = 1;
304	af = sa->sa_family;
305	}
306	} else
307	#endif
308	af = sa->sa_family;
309	if (af != old_af) {
310	printf("\nRoute Tree for Protocol Family %d:\n", af);
311	old_af = af;
312	}
313	if (rtm->rtm_addrs == RTA_DST)
314	p_sockaddr(sa, 0, 36);
315	else {
316	p_sockaddr(sa, rtm->rtm_flags, 16);
317	if (sa->sa_len == 0)
318	sa->sa_len = sizeof(long);
319	sa = (struct sockaddr )(sa->sa_len + (char )sa);
320	p_sockaddr(sa, 0, 18);
321	}
322	p_flags(rtm->rtm_flags & interesting, "%-6.6s ");
323	putchar('\n');
324	}
325
326	p_sockaddr(sa, flags, width)
327	struct sockaddr *sa;
328	int flags, width;
329	{
330	char format[20], workbuf[128], cp, cplim;
331	register char *cpout;
332
333	switch(sa->sa_family) {
334	case AF_INET:
335	{
336	register struct sockaddr_in sin = (struct sockaddr_in )sa;
337
338	cp = (sin->sin_addr.s_addr == 0) ? "default" :
339	((flags & RTF_HOST) ?
340	routename(sin->sin_addr) : netname(sin->sin_addr, 0L));
341	}
342	break;
343
344	#ifdef NS
345	case AF_NS:
346	cp = ns_print((struct sockaddr_ns *)sa);
347	break;
348	#endif
349
350	default:
351	{
352	register u_short s = ((u_short )sa->sa_data), *slim;
353
354	slim = (u_short *) sa + ((sa->sa_len + sizeof(u_short) - 1) /
355	sizeof(u_short));
356	cp = workbuf;
357	cplim = cp + sizeof(workbuf) - 6;
358	cp += sprintf(cp, "(%d)", sa->sa_family);
359	while (s < slim && cp < cplim)
360	cp += sprintf(cp, " %x", *s++);
361	cp = workbuf;
362	}
363	}
364	if (width < 0 )
365	printf("%s ", cp);
366	else {
367	if (nflag)
368	printf("%-*s ", width, cp);
369	else
370	printf("%-.s ", width, width, cp);
371	}
372	}
373
374	p_flags(f, format)
375	register int f;
376	char *format;
377	{
378	char name[33], *flags;
379	register struct bits *p = bits;
380	for (flags = name; p->b_mask; p++)
381	if (p->b_mask & f)
382	*flags++ = p->b_val;
383	*flags = '\0';
384	printf(format, name);
385	}
386
387	p_rtentry(rt)
388	register struct rtentry *rt;
389	{
390	char name[16];
391	register struct sockaddr *sa;
392	struct ifnet ifnet;
393
394	p_sockaddr(kgetsa(rt_key(rt)), rt->rt_flags, 16);
f76b4708	395	p_sockaddr(kgetsa(rt->rt_gateway), RTF_HOST, 18);
15637ed4 RG	396	p_flags(rt->rt_flags, "%-6.6s ");
	397	printf("%6d %8d ", rt->rt_refcnt, rt->rt_use);
	398	if (rt->rt_ifp == 0) {
	399	putchar('\n');
	400	return;
	401	}
	402	kget(rt->rt_ifp, ifnet);
	403	kvm_read((off_t)ifnet.if_name, name, 16);
ad0448d8	404	printf(" %.2s%d", name, ifnet.if_unit);
a2a107a3 GW	405	if(aflag) {
	406	/*
	407	* MTU
	408	*/
	409	if(rt->rt_rmx.rmx_mtu)
	410	printf("\n %7d%c", rt->rt_rmx.rmx_mtu,
	411	(rt->rt_rmx.rmx_locks & RTV_MTU) ? '*' : ' ');
	412	else
	413	printf("\n %-7s ", "-");
	414
	415	/*
	416	* Hop count
	417	*/
	418	if(rt->rt_rmx.rmx_hopcount)
	419	printf(" %7d%c", rt->rt_rmx.rmx_hopcount,
	420	(rt->rt_rmx.rmx_locks & RTV_HOPCOUNT) ? '*' : ' ');
	421	else
	422	printf(" %-6s ", "-");
	423
	424	/*
	425	* Expiration time
	426	*/
	427	if(rt->rt_rmx.rmx_expire)
	428	printf(" %7d%c", rt->rt_rmx.rmx_expire,
	429	(rt->rt_rmx.rmx_locks & RTV_EXPIRE) ? '*' : ' ');
	430	else
	431	printf(" %-7s ", "-");
	432
	433	/*
	434	* Receive pipe size (bytes)
	435	*/
	436	if(rt->rt_rmx.rmx_recvpipe)
	437	printf(" %7d%c", rt->rt_rmx.rmx_recvpipe,
	438	(rt->rt_rmx.rmx_locks & RTV_RPIPE) ? '*' : ' ');
	439	else
	440	printf(" %-7s ", "-");
	441
	442	/*
	443	* Send pipe size (bytes)
	444	*/
	445	if(rt->rt_rmx.rmx_sendpipe)
	446	printf(" %7d%c", rt->rt_rmx.rmx_sendpipe,
	447	(rt->rt_rmx.rmx_locks & RTV_SPIPE) ? '*' : ' ');
	448	else
	449	printf(" %-7s ", "-");
	450
	451	/*
	452	* Slow-start threshold (bytes)
	453	*/
	454	if(rt->rt_rmx.rmx_ssthresh)
	455	printf(" %7d%c", rt->rt_rmx.rmx_ssthresh,
	456	(rt->rt_rmx.rmx_locks & RTV_SSTHRESH) ? '*' : ' ');
	457	else
	458	printf(" %-7s ", "-");
	459
	460	/*
	461	* Round-trip time (seconds)
	462	*/
	463	if(rt->rt_rmx.rmx_rtt)
	464	printf(" %7.4f%c", (1.0 * rt->rt_rmx.rmx_rtt) / RTM_RTTUNIT,
	465	(rt->rt_rmx.rmx_locks & RTV_RTT) ? '*' : ' ');
	466	else
	467	printf(" %-7s ", "-");
	468
469	/*
470	* Round-trip time variance (seconds)
471	*/
472	if(rt->rt_rmx.rmx_rttvar)
473	printf(" %7.4f%c", (1.0 * rt->rt_rmx.rmx_rttvar) / RTM_RTTUNIT,
474	(rt->rt_rmx.rmx_locks & RTV_RTTVAR) ? '*' : ' ');
475	else
476	printf(" %-7s ", "-");
477	} else { /* no -a flag */
478	if(rt->rt_rmx.rmx_mtu)
479	printf(" %6d", rt->rt_rmx.rmx_mtu);
480	else
481	printf(" %-6s", "-");
482	if(rt->rt_rmx.rmx_rtt)
483	printf(" %6.3f", (1. * rt->rt_rmx.rmx_rtt) / RTM_RTTUNIT);
484	else
485	printf(" %-6s", "-");
486	}
ad0448d8	487	printf(rt->rt_nodes[0].rn_dupedkey ? " =>\n" : "\n");
15637ed4 RG	488	}
	489
	490	char *
	491	routename(in)
	492	struct in_addr in;
	493	{
	494	register char *cp;
	495	static char line[MAXHOSTNAMELEN + 1];
	496	struct hostent *hp;
	497	static char domain[MAXHOSTNAMELEN + 1];
	498	static int first = 1;
	499	char *index();
	500
	501	if (first) {
	502	first = 0;
	503	if (gethostname(domain, MAXHOSTNAMELEN) == 0 &&
	504	(cp = index(domain, '.')))
	505	(void) strcpy(domain, cp + 1);
	506	else
	507	domain[0] = 0;
	508	}
	509	cp = 0;
	510	if (!nflag) {
	511	hp = gethostbyaddr((char *)&in, sizeof (struct in_addr),
	512	AF_INET);
	513	if (hp) {
	514	if ((cp = index(hp->h_name, '.')) &&
	515	!strcmp(cp + 1, domain))
	516	*cp = 0;
	517	cp = hp->h_name;
	518	}
	519	}
	520	if (cp)
	521	strncpy(line, cp, sizeof(line) - 1);
	522	else {
	523	#define C(x) ((x) & 0xff)
	524	in.s_addr = ntohl(in.s_addr);
	525	sprintf(line, "%u.%u.%u.%u", C(in.s_addr >> 24),
	526	C(in.s_addr >> 16), C(in.s_addr >> 8), C(in.s_addr));
	527	}
	528	return (line);
	529	}
	530
	531	/*
	532	* Return the name of the network whose address is given.
	533	* The address is assumed to be that of a net or subnet, not a host.
	534	*/
	535	char *
	536	netname(in, mask)
	537	struct in_addr in;
	538	u_long mask;
	539	{
	540	char *cp = 0;
	541	static char line[MAXHOSTNAMELEN + 1];
	542	struct netent *np = 0;
	543	u_long net;
	544	register i;
	545	int subnetshift;
	546
	547	i = ntohl(in.s_addr);
	548	if (!nflag && i) {
	549	if (mask == 0) {
	550	if (IN_CLASSA(i)) {
	551	mask = IN_CLASSA_NET;
552	subnetshift = 8;
553	} else if (IN_CLASSB(i)) {
554	mask = IN_CLASSB_NET;
555	subnetshift = 8;
556	} else {
557	mask = IN_CLASSC_NET;
558	subnetshift = 4;
559	}
560	/*
561	* If there are more bits than the standard mask
562	* would suggest, subnets must be in use.
563	* Guess at the subnet mask, assuming reasonable
564	* width subnet fields.
565	*/
566	while (i &~ mask)
567	mask = (long)mask >> subnetshift;
568	}
569	net = i & mask;
570	while ((mask & 1) == 0)
571	mask >>= 1, net >>= 1;
572	np = getnetbyaddr(net, AF_INET);
573	if (np)
574	cp = np->n_name;
575	}
576	if (cp)
577	strncpy(line, cp, sizeof(line) - 1);
578	else if ((i & 0xffffff) == 0)
579	sprintf(line, "%u", C(i >> 24));
580	else if ((i & 0xffff) == 0)
581	sprintf(line, "%u.%u", C(i >> 24) , C(i >> 16));
582	else if ((i & 0xff) == 0)
583	sprintf(line, "%u.%u.%u", C(i >> 24), C(i >> 16), C(i >> 8));
584	else
585	sprintf(line, "%u.%u.%u.%u", C(i >> 24),
586	C(i >> 16), C(i >> 8), C(i));
587	return (line);
588	}
589
590	/*
591	* Print routing statistics
592	*/
593	rt_stats(off)
594	off_t off;
595	{
596	struct rtstat rtstat;
597
598	if (off == 0) {
599	printf("rtstat: symbol not in namelist\n");
600	return;
601	}
602	kvm_read(off, (char *)&rtstat, sizeof (rtstat));
603	printf("routing:\n");
604	printf("\t%u bad routing redirect%s\n",
605	rtstat.rts_badredirect, plural(rtstat.rts_badredirect));
606	printf("\t%u dynamically created route%s\n",
607	rtstat.rts_dynamic, plural(rtstat.rts_dynamic));
608	printf("\t%u new gateway%s due to redirects\n",
609	rtstat.rts_newgateway, plural(rtstat.rts_newgateway));
610	printf("\t%u destination%s found unreachable\n",
611	rtstat.rts_unreach, plural(rtstat.rts_unreach));
612	printf("\t%u use%s of a wildcard route\n",
613	rtstat.rts_wildcard, plural(rtstat.rts_wildcard));
614	}
615	#ifdef NS
616	short ns_nullh[] = {0,0,0};
617	short ns_bh[] = {-1,-1,-1};
618
619	char *
620	ns_print(sns)
621	struct sockaddr_ns *sns;
622	{
623	struct ns_addr work;
624	union { union ns_net net_e; u_long long_e; } net;
625	u_short port;
626	static char mybuf[50], cport[10], chost[25];
627	char *host = "";
628	register char p; register u_char q;
629
630	work = sns->sns_addr;
631	port = ntohs(work.x_port);
632	work.x_port = 0;
633	net.net_e = work.x_net;
634	if (ns_nullhost(work) && net.long_e == 0) {
635	if (port ) {
636	sprintf(mybuf, "*.%xH", port);
637	upHex(mybuf);
638	} else
639	sprintf(mybuf, ".");
640	return (mybuf);
641	}
642
643	if (bcmp(ns_bh, work.x_host.c_host, 6) == 0) {
644	host = "any";
645	} else if (bcmp(ns_nullh, work.x_host.c_host, 6) == 0) {
646	host = "*";
647	} else {
648	q = work.x_host.c_host;
649	sprintf(chost, "%02x%02x%02x%02x%02x%02xH",
650	q[0], q[1], q[2], q[3], q[4], q[5]);
651	for (p = chost; *p == '0' && p < chost + 12; p++);
652	host = p;
653	}
654	if (port)
655	sprintf(cport, ".%xH", htons(port));
656	else
657	*cport = 0;
658
659	sprintf(mybuf,"%xH.%s%s", ntohl(net.long_e), host, cport);
660	upHex(mybuf);
661	return(mybuf);
662	}
663
664	char *
665	ns_phost(sns)
666	struct sockaddr_ns *sns;
667	{
668	struct sockaddr_ns work;
669	static union ns_net ns_zeronet;
670	char *p;
671
672	work = *sns;
673	work.sns_addr.x_port = 0;
674	work.sns_addr.x_net = ns_zeronet;
675
676	p = ns_print(&work);
677	if (strncmp("0H.", p, 3) == 0) p += 3;
678	return(p);
679	}
680	upHex(p0)
681	char *p0;
682	{
683	register char *p = p0;
684	for (; p; p++) switch (p) {
685
686	case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
687	*p += ('A' - 'a');
688	}
689	}
690	#endif /* NS */