usr/src/usr.bin/netstat/main.c

/*
 * Copyright (c) 1983, 1988 Regents of the University of California.
 * All rights reserved.
 *
 * %sccs.include.redist.c%
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1983, 1988 Regents of the University of California.\n\
 All rights reserved.\n";
#endif /* not lint */

#ifndef lint
static char sccsid[] = "@(#)main.c	5.23 (Berkeley) %G%";
#endif /* not lint */

#include <sys/param.h>
#include <sys/socket.h>
#include <sys/file.h>
#include <errno.h>
#include <netdb.h>
#include <nlist.h>
#include <kvm.h>
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <paths.h>

struct nlist nl[] = {
#define	N_MBSTAT	0
	{ "_mbstat" },
#define	N_IPSTAT	1
	{ "_ipstat" },
#define	N_TCB		2
	{ "_tcb" },
#define	N_TCPSTAT	3
	{ "_tcpstat" },
#define	N_UDB		4
	{ "_udb" },
#define	N_UDPSTAT	5
	{ "_udpstat" },
#define	N_IFNET		6
	{ "_ifnet" },
#define	N_IMP		7
	{ "_imp_softc" },
#define	N_RTHOST	8
	{ "_rthost" },
#define	N_RTNET		9
	{ "_rtnet" },
#define	N_ICMPSTAT	10
	{ "_icmpstat" },
#define	N_RTSTAT	11
	{ "_rtstat" },
#define	N_NFILE		12
	{ "_nfile" },
#define	N_FILE		13
	{ "_file" },
#define	N_UNIXSW	14
	{ "_unixsw" },
#define N_RTHASHSIZE	15
	{ "_rthashsize" },
#define N_IDP		16
	{ "_nspcb"},
#define N_IDPSTAT	17
	{ "_idpstat"},
#define N_SPPSTAT	18
	{ "_spp_istat"},
#define N_NSERR		19
	{ "_ns_errstat"},
#define	N_CLNPSTAT	20
	{ "_clnp_stat"},
#define	IN_TP		21
	{ "_tp_inpcb" },
#define	ISO_TP		22
	{ "_tp_isopcb" },
#define	N_TPSTAT	23
	{ "_tp_stat" },
#define	N_ESISSTAT	24
	{ "_esis_stat"},
#define N_NIMP		25
	{ "_nimp"},
#define N_RTREE		26
	{ "_radix_node_head"},
#define N_CLTP		27
	{ "_cltb"},
#define N_CLTPSTAT	28
	{ "_cltpstat"},

    /* BBN Internet protocol implementation */
#define	N_TCP		23
	{ "_tcp" },
#define	N_UDP		24
	{ "_udp" },
#define N_RDP		25
	{ "_rdp" },
#define	N_RDPSTAT	26
	{ "_rdpstat" },

	"",
};

/* internet protocols */
extern	int protopr(), bbnprotopr();
extern	int tcp_stats(), udp_stats(), ip_stats(), icmp_stats();
/* ns protocols */
extern	int tcpstats(), udpstats(), ipstats(), icmpstats(), rdpstats();
extern	int nsprotopr();
extern	int spp_stats(), idp_stats(), nserr_stats();
/* iso protocols */
extern	int iso_protopr();
extern	int tp_stats(), esis_stats(), clnp_stats(), cltp_stats();

struct protox {
	u_char	pr_index;		/* index into nlist of cb head */
	u_char	pr_sindex;		/* index into nlist of stat block */
	u_char	pr_wanted;		/* 1 if wanted, 0 otherwise */
	int	(*pr_cblocks)();	/* control blocks printing routine */
	int	(*pr_stats)();		/* statistics printing routine */
	char	*pr_name;		/* well-known name */
};

struct  protox berkprotox[] = {
	{ N_TCB,	N_TCPSTAT,	1,	protopr,
	  tcp_stats,	"tcp" },
	{ N_UDB,	N_UDPSTAT,	1,	protopr,
	  udp_stats,	"udp" },
	{ IN_TP,	N_TPSTAT,	1,	protopr,
	  tp_stats,	"tpip" },
	{ -1,		N_IPSTAT,	1,	0,
	  ip_stats,	"ip" },
	{ -1,		N_ICMPSTAT,	1,	0,
	  icmp_stats,	"icmp" },
	{ -1,		-1,		0,	0,
	  0,		0 }
};

struct protox bbnprotox[] = {
	{ N_TCP,	N_TCPSTAT,	1,	bbnprotopr,
	  tcpstats,	"tcp" },
	{ N_UDP,	N_UDPSTAT,	1,	bbnprotopr,
	  udpstats,	"udp" },
	{ N_RDP,	N_RDPSTAT,	1,	bbnprotopr,
	  rdpstats,	"rdp" },
	{ N_RAWCB,	0,		1,	bbnprotopr,
	  0,		"raw" },
	{ -1,		N_IPSTAT,	1,	0,
	  ipstats,	"ip" },
	{ -1,		N_ICMPSTAT,	1,	0,
	  icmpstats,	"icmp" },
	{ -1,		-1,		0,	0,
	  0,		0 }
};

struct protox nsprotox[] = {
	{ N_IDP,	N_IDPSTAT,	1,	nsprotopr,
	  idp_stats,	"idp" },
	{ N_IDP,	N_SPPSTAT,	1,	nsprotopr,
	  spp_stats,	"spp" },
	{ -1,		N_NSERR,	1,	0,
	  nserr_stats,	"ns_err" },
	{ -1,		-1,		0,	0,
	  0,		0 }
};

struct protox isoprotox[] = {
	{ ISO_TP,	N_TPSTAT,	1,	iso_protopr,
	  tp_stats,	"tp" },
	{ N_CLTP,	N_CLTPSTAT,	1,	iso_protopr,
	  cltp_stats,	"cltp" },
	{ -1,		N_CLNPSTAT,	1,	 0,
	  clnp_stats,	"clnp"},
	{ -1,		N_ESISSTAT,	1,	 0,
	  esis_stats,	"esis"},
	{ -1,		-1,		0,	0,
	  0,		0 }
};

struct protox *protoprotox[] = { protox, nsprotox, isoprotox, NULL };

char	*vmunix = _PATH_UNIX;
char	*kmemf;
int	kmem;
int	kflag;
int	Aflag;
int	aflag;
int	hflag;
int	iflag;
int	mflag;
int	nflag;
int	pflag;
int	rflag;
int	sflag;
int	tflag;
int	dflag;
int	interval;
char	*interface;
int	unit;

int	af = AF_UNSPEC;

main(argc, argv)
	int argc;
	char **argv;
{
	extern char *optarg;
	extern int optind;
	register struct protoent *p;
	register struct protox *tp;	/* for printing cblocks & stats */
	struct protox *name2protox();	/* for -p */
	int ch;
	void usage();

	while ((ch = getopt(argc, argv, "Aadf:hI:iM:mN:np:rstuw")) != EOF)
		switch((char)ch) {
		case 'A':
			Aflag = 1;
			break;
		case 'a':
			aflag = 1;
			break;
		case 'd':
			dflag = 1;
			break;
		case 'f':
			if (strcmp(optarg, "ns") == 0)
				af = AF_NS;
			else if (strcmp(optarg, "inet") == 0)
				af = AF_INET;
			else if (strcmp(optarg, "unix") == 0)
				af = AF_UNIX;
			else if (strcmp(optarg, "iso") == 0)
				af = AF_ISO;
			else {
				(void)fprintf(stderr,
				    "%s: unknown address family\n", optarg);
				exit(1);
			}
			break;
		case 'h':
			hflag = 1;
			break;
		case 'I': {
			char *cp;

			iflag = 1;
			for (cp = interface = optarg; isalpha(*cp); cp++);
			unit = atoi(cp);
			*cp = '\0';
			break;
		}
		case 'i':
			iflag = 1;
			break;
		case 'M':
			kmemf = optarg;
			kflag = 1;
			break;
		case 'm':
			mflag = 1;
			break;
		case 'N':
			vmunix = optarg;
			break;
		case 'n':
			nflag = 1;
			break;
		case 'p':
			if ((tp = name2protox(optarg)) == NULL) {
				(void)fprintf(stderr,
				    "%s: unknown or uninstrumented protocol\n",
				    optarg);
				exit(1);
			}
			pflag = 1;
			break;
		case 'r':
			rflag = 1;
			break;
		case 's':
			sflag = 1;
			break;
		case 't':
			tflag = 1;
			break;
		case 'u':
			af = AF_UNIX;
			break;
		case 'w':
			interval = atoi(optarg);
			break;
		case '?':
		default:
			usage();
		}
	argv += optind;
	argc -= optind;

#define	BACKWARD_COMPATIBILITY
#ifdef	BACKWARD_COMPATIBILITY
	if (*argv) {
		if (isdigit(**argv)) {
			interval = atoi(*argv);
			if (interval <= 0)
				usage();
			++argv;
			iflag = 1;
		}
		if (*argv) {
			vmunix = *argv;
			if (*++argv) {
				kmemf = *argv;
				kflag = 1;
			}
		}
	}
#endif
	if (kvm_openfiles(vmunix, kmemf, NULL) == -1) {
		fprintf(stderr, "netstat: kvm_openfiles: %s\n", kvm_geterr());
		exit(1);
	}
	if (kvm_nlist(nl) < 0 || nl[0].n_type == 0) {
		fprintf(stderr, "%s: no namelist\n", vmunix);
		exit(1);
	}
	if (mflag) {
		mbpr((off_t)nl[N_MBSTAT].n_value);
		exit(0);
	}
	if (pflag) {
		if (tp->pr_stats)
			(*tp->pr_stats)(nl[tp->pr_sindex].n_value,
				tp->pr_name);
		else
			printf("%s: no stats routine\n", tp->pr_name);
		exit(0);
	}
	if (hflag) {
		hostpr(nl[N_IMP].n_value, nl[N_NIMP].n_value);
		exit(0);
	}
	/*
	 * Keep file descriptors open to avoid overhead
	 * of open/close on each call to get* routines.
	 */
	sethostent(1);
	setnetent(1);
	if (iflag) {
		intpr(interval, nl[N_IFNET].n_value);
		exit(0);
	}
	if (rflag) {
		if (sflag)
			rt_stats((off_t)nl[N_RTSTAT].n_value);
		else
			routepr((off_t)nl[N_RTHOST].n_value,
				(off_t)nl[N_RTNET].n_value,
				(off_t)nl[N_RTHASHSIZE].n_value,
				(off_t)nl[N_RTREE].n_value);
		exit(0);
	}
    if (af == AF_INET || af == AF_UNSPEC) {
	struct protox *head;

	head = (nl[N_TCB].n_type == 0) ? bbnprotox : berkprotox;
	setprotoent(1);
	setservent(1);

	for (tp = head; tp->pr_name; tp++) {
		if (tp->pr_wanted == 0)
			continue;

		if (sflag) {
			if (tp->pr_stats)
			    (*tp->pr_stats)(nl[tp->pr_sindex].n_value, tp->pr_name);
		} else if (tp->pr_cblocks)
			(*tp->pr_cblocks)(nl[tp->pr_index].n_value, tp->pr_name);
	}
	endprotoent();
    }
    if (af == AF_NS || af == AF_UNSPEC) {
	for (tp = nsprotox; tp->pr_name; tp++) {
		if (sflag) {
			if (tp->pr_stats)
				(*tp->pr_stats)(nl[tp->pr_sindex].n_value,
					tp->pr_name);
		} else
			if (tp->pr_cblocks)
				(*tp->pr_cblocks)(nl[tp->pr_index].n_value,
					tp->pr_name);
	}
    }
    if (af == AF_ISO || af == AF_UNSPEC) {
	for (tp = isoprotox; tp->pr_name; tp++) {
		if (sflag) {
			if (tp->pr_stats)
				(*tp->pr_stats)(nl[tp->pr_sindex].n_value,
					tp->pr_name);
		} else
			if (tp->pr_cblocks)
				(*tp->pr_cblocks)(nl[tp->pr_index].n_value,
					tp->pr_name);
	}
    }
    if ((af == AF_UNIX || af == AF_UNSPEC) && !sflag)
	    unixpr((off_t)nl[N_NFILE].n_value, (off_t)nl[N_FILE].n_value,
		(struct protosw *)nl[N_UNIXSW].n_value);
    if (af == AF_UNSPEC && sflag)
	impstats(nl[N_IMP].n_value, nl[N_NIMP].n_value);
    exit(0);
}

char *
plural(n)
	int n;
{
	return (n != 1 ? "s" : "");
}

/*
 * Find the protox for the given "well-known" name.
 */
struct protox *
knownname(name)
	char *name;
{
	struct protox **tpp, *tp;

	for (tpp = protoprotox; *tpp; tpp++)
	    for (tp = *tpp; tp->pr_name; tp++)
		if (strcmp(tp->pr_name, name) == 0)
			return(tp);
	return(NULL);
}

/*
 * Find the protox corresponding to name.
 */
struct protox *
name2protox(name)
	char *name;
{
	struct protox *tp;
	char **alias;			/* alias from p->aliases */
	struct protoent *p;

	/*
	 * Try to find the name in the list of "well-known" names. If that
	 * fails, check if name is an alias for an Internet protocol.
	 */
	if (tp = knownname(name))
		return(tp);

	setprotoent(1);			/* make protocol lookup cheaper */
	while (p = getprotoent()) {
		/* assert: name not same as p->name */
		for (alias = p->p_aliases; *alias; alias++)
			if (strcmp(name, *alias) == 0) {
				endprotoent();
				return(knownname(p->p_name));
			}
	}
	endprotoent();
	return(NULL);
}

void
usage()
{
	(void)fprintf(stderr,
"usage: netstat [-Aan] [-f address_family] [-M core] [-N system]\n");
	(void)fprintf(stderr,
"               [-himnrs] [-f address_family] [-M core] [-N system]\n");
	(void)fprintf(stderr,
"               [-n] [-I interface] [-M core] [-N system] [-w wait]\n");
	(void)fprintf(stderr,
"               [-M core] [-N system] [-p protocol]\n");
	exit(1);
}
Commit	Line	Data
	1	/*
	2	* Copyright (c) 1983, 1988 Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* %sccs.include.redist.c%
	6	*/
	7
	8	#ifndef lint
	9	char copyright[] =
	10	"@(#) Copyright (c) 1983, 1988 Regents of the University of California.\n\
	11	All rights reserved.\n";
	12	#endif /* not lint */
	13
	14	#ifndef lint
	15	static char sccsid[] = "@(#)main.c 5.23 (Berkeley) %G%";
	16	#endif /* not lint */
	17
	18	#include <sys/param.h>
	19	#include <sys/socket.h>
	20	#include <sys/file.h>
	21	#include <errno.h>
	22	#include <netdb.h>
	23	#include <nlist.h>
	24	#include <kvm.h>
	25	#include <stdio.h>
	26	#include <ctype.h>
	27	#include <stdlib.h>
	28	#include <string.h>
	29	#include <paths.h>
	30
	31	struct nlist nl[] = {
	32	#define N_MBSTAT 0
	33	{ "_mbstat" },
	34	#define N_IPSTAT 1
	35	{ "_ipstat" },
	36	#define N_TCB 2
	37	{ "_tcb" },
	38	#define N_TCPSTAT 3
	39	{ "_tcpstat" },
	40	#define N_UDB 4
	41	{ "_udb" },
	42	#define N_UDPSTAT 5
	43	{ "_udpstat" },
	44	#define N_IFNET 6
	45	{ "_ifnet" },
	46	#define N_IMP 7
	47	{ "_imp_softc" },
	48	#define N_RTHOST 8
	49	{ "_rthost" },
	50	#define N_RTNET 9
	51	{ "_rtnet" },
	52	#define N_ICMPSTAT 10
	53	{ "_icmpstat" },
	54	#define N_RTSTAT 11
	55	{ "_rtstat" },
	56	#define N_NFILE 12
	57	{ "_nfile" },
	58	#define N_FILE 13
	59	{ "_file" },
	60	#define N_UNIXSW 14
	61	{ "_unixsw" },
	62	#define N_RTHASHSIZE 15
	63	{ "_rthashsize" },
	64	#define N_IDP 16
	65	{ "_nspcb"},
	66	#define N_IDPSTAT 17
	67	{ "_idpstat"},
	68	#define N_SPPSTAT 18
	69	{ "_spp_istat"},
	70	#define N_NSERR 19
	71	{ "_ns_errstat"},
	72	#define N_CLNPSTAT 20
	73	{ "_clnp_stat"},
	74	#define IN_TP 21
	75	{ "_tp_inpcb" },
	76	#define ISO_TP 22
	77	{ "_tp_isopcb" },
	78	#define N_TPSTAT 23
	79	{ "_tp_stat" },
	80	#define N_ESISSTAT 24
	81	{ "_esis_stat"},
	82	#define N_NIMP 25
	83	{ "_nimp"},
	84	#define N_RTREE 26
	85	{ "_radix_node_head"},
	86	#define N_CLTP 27
	87	{ "_cltb"},
	88	#define N_CLTPSTAT 28
	89	{ "_cltpstat"},
	90
	91	/* BBN Internet protocol implementation */
	92	#define N_TCP 23
	93	{ "_tcp" },
	94	#define N_UDP 24
	95	{ "_udp" },
	96	#define N_RDP 25
	97	{ "_rdp" },
	98	#define N_RDPSTAT 26
	99	{ "_rdpstat" },
	100
	101	"",
	102	};
	103
	104	/* internet protocols */
	105	extern int protopr(), bbnprotopr();
	106	extern int tcp_stats(), udp_stats(), ip_stats(), icmp_stats();
	107	/* ns protocols */
	108	extern int tcpstats(), udpstats(), ipstats(), icmpstats(), rdpstats();
	109	extern int nsprotopr();
	110	extern int spp_stats(), idp_stats(), nserr_stats();
	111	/* iso protocols */
	112	extern int iso_protopr();
	113	extern int tp_stats(), esis_stats(), clnp_stats(), cltp_stats();
	114
	115	struct protox {
	116	u_char pr_index; /* index into nlist of cb head */
	117	u_char pr_sindex; /* index into nlist of stat block */
	118	u_char pr_wanted; /* 1 if wanted, 0 otherwise */
	119	int (pr_cblocks)(); / control blocks printing routine */
	120	int (pr_stats)(); / statistics printing routine */
	121	char pr_name; / well-known name */
	122	};
	123
	124	struct protox berkprotox[] = {
	125	{ N_TCB, N_TCPSTAT, 1, protopr,
	126	tcp_stats, "tcp" },
	127	{ N_UDB, N_UDPSTAT, 1, protopr,
	128	udp_stats, "udp" },
	129	{ IN_TP, N_TPSTAT, 1, protopr,
	130	tp_stats, "tpip" },
	131	{ -1, N_IPSTAT, 1, 0,
	132	ip_stats, "ip" },
	133	{ -1, N_ICMPSTAT, 1, 0,
	134	icmp_stats, "icmp" },
	135	{ -1, -1, 0, 0,
	136	0, 0 }
	137	};
	138
	139	struct protox bbnprotox[] = {
	140	{ N_TCP, N_TCPSTAT, 1, bbnprotopr,
	141	tcpstats, "tcp" },
	142	{ N_UDP, N_UDPSTAT, 1, bbnprotopr,
	143	udpstats, "udp" },
	144	{ N_RDP, N_RDPSTAT, 1, bbnprotopr,
	145	rdpstats, "rdp" },
	146	{ N_RAWCB, 0, 1, bbnprotopr,
	147	0, "raw" },
	148	{ -1, N_IPSTAT, 1, 0,
	149	ipstats, "ip" },
	150	{ -1, N_ICMPSTAT, 1, 0,
	151	icmpstats, "icmp" },
	152	{ -1, -1, 0, 0,
	153	0, 0 }
	154	};
	155
	156	struct protox nsprotox[] = {
	157	{ N_IDP, N_IDPSTAT, 1, nsprotopr,
	158	idp_stats, "idp" },
	159	{ N_IDP, N_SPPSTAT, 1, nsprotopr,
	160	spp_stats, "spp" },
	161	{ -1, N_NSERR, 1, 0,
	162	nserr_stats, "ns_err" },
	163	{ -1, -1, 0, 0,
	164	0, 0 }
	165	};
	166
	167	struct protox isoprotox[] = {
	168	{ ISO_TP, N_TPSTAT, 1, iso_protopr,
	169	tp_stats, "tp" },
	170	{ N_CLTP, N_CLTPSTAT, 1, iso_protopr,
	171	cltp_stats, "cltp" },
	172	{ -1, N_CLNPSTAT, 1, 0,
	173	clnp_stats, "clnp"},
	174	{ -1, N_ESISSTAT, 1, 0,
	175	esis_stats, "esis"},
	176	{ -1, -1, 0, 0,
	177	0, 0 }
	178	};
	179
	180	struct protox *protoprotox[] = { protox, nsprotox, isoprotox, NULL };
	181
	182	char *vmunix = _PATH_UNIX;
	183	char *kmemf;
	184	int kmem;
	185	int kflag;
	186	int Aflag;
	187	int aflag;
	188	int hflag;
	189	int iflag;
	190	int mflag;
	191	int nflag;
	192	int pflag;
	193	int rflag;
	194	int sflag;
	195	int tflag;
	196	int dflag;
	197	int interval;
	198	char *interface;
	199	int unit;
	200
	201	int af = AF_UNSPEC;
	202
	203	main(argc, argv)
	204	int argc;
	205	char **argv;
	206	{
	207	extern char *optarg;
	208	extern int optind;
	209	register struct protoent *p;
	210	register struct protox tp; / for printing cblocks & stats */
	211	struct protox name2protox(); / for -p */
	212	int ch;
	213	void usage();
	214
	215	while ((ch = getopt(argc, argv, "Aadf:hI:iM:mN:np:rstuw")) != EOF)
	216	switch((char)ch) {
	217	case 'A':
	218	Aflag = 1;
	219	break;
	220	case 'a':
	221	aflag = 1;
	222	break;
	223	case 'd':
	224	dflag = 1;
	225	break;
	226	case 'f':
	227	if (strcmp(optarg, "ns") == 0)
	228	af = AF_NS;
	229	else if (strcmp(optarg, "inet") == 0)
	230	af = AF_INET;
	231	else if (strcmp(optarg, "unix") == 0)
	232	af = AF_UNIX;
	233	else if (strcmp(optarg, "iso") == 0)
	234	af = AF_ISO;
	235	else {
	236	(void)fprintf(stderr,
	237	"%s: unknown address family\n", optarg);
	238	exit(1);
	239	}
	240	break;
	241	case 'h':
	242	hflag = 1;
	243	break;
	244	case 'I': {
	245	char *cp;
	246
	247	iflag = 1;
	248	for (cp = interface = optarg; isalpha(*cp); cp++);
	249	unit = atoi(cp);
	250	*cp = '\0';
	251	break;
	252	}
	253	case 'i':
	254	iflag = 1;
	255	break;
	256	case 'M':
	257	kmemf = optarg;
	258	kflag = 1;
	259	break;
	260	case 'm':
	261	mflag = 1;
	262	break;
	263	case 'N':
	264	vmunix = optarg;
	265	break;
	266	case 'n':
	267	nflag = 1;
	268	break;
	269	case 'p':
	270	if ((tp = name2protox(optarg)) == NULL) {
	271	(void)fprintf(stderr,
	272	"%s: unknown or uninstrumented protocol\n",
	273	optarg);
	274	exit(1);
	275	}
	276	pflag = 1;
	277	break;
	278	case 'r':
	279	rflag = 1;
	280	break;
	281	case 's':
	282	sflag = 1;
	283	break;
	284	case 't':
	285	tflag = 1;
	286	break;
	287	case 'u':
	288	af = AF_UNIX;
	289	break;
	290	case 'w':
	291	interval = atoi(optarg);
	292	break;
	293	case '?':
	294	default:
	295	usage();
	296	}
	297	argv += optind;
	298	argc -= optind;
	299
	300	#define BACKWARD_COMPATIBILITY
	301	#ifdef BACKWARD_COMPATIBILITY
	302	if (*argv) {
	303	if (isdigit(**argv)) {
	304	interval = atoi(*argv);
	305	if (interval <= 0)
	306	usage();
	307	++argv;
	308	iflag = 1;
	309	}
	310	if (*argv) {
	311	vmunix = *argv;
	312	if (*++argv) {
	313	kmemf = *argv;
	314	kflag = 1;
	315	}
	316	}
	317	}
	318	#endif
	319	if (kvm_openfiles(vmunix, kmemf, NULL) == -1) {
	320	fprintf(stderr, "netstat: kvm_openfiles: %s\n", kvm_geterr());
	321	exit(1);
	322	}
	323	if (kvm_nlist(nl) < 0 \|\| nl[0].n_type == 0) {
	324	fprintf(stderr, "%s: no namelist\n", vmunix);
	325	exit(1);
	326	}
	327	if (mflag) {
	328	mbpr((off_t)nl[N_MBSTAT].n_value);
	329	exit(0);
	330	}
	331	if (pflag) {
	332	if (tp->pr_stats)
	333	(*tp->pr_stats)(nl[tp->pr_sindex].n_value,
	334	tp->pr_name);
	335	else
	336	printf("%s: no stats routine\n", tp->pr_name);
	337	exit(0);
	338	}
	339	if (hflag) {
	340	hostpr(nl[N_IMP].n_value, nl[N_NIMP].n_value);
	341	exit(0);
	342	}
	343	/*
	344	* Keep file descriptors open to avoid overhead
	345	* of open/close on each call to get* routines.
	346	*/
	347	sethostent(1);
	348	setnetent(1);
	349	if (iflag) {
	350	intpr(interval, nl[N_IFNET].n_value);
	351	exit(0);
	352	}
	353	if (rflag) {
	354	if (sflag)
	355	rt_stats((off_t)nl[N_RTSTAT].n_value);
	356	else
	357	routepr((off_t)nl[N_RTHOST].n_value,
	358	(off_t)nl[N_RTNET].n_value,
	359	(off_t)nl[N_RTHASHSIZE].n_value,
	360	(off_t)nl[N_RTREE].n_value);
	361	exit(0);
	362	}
	363	if (af == AF_INET \|\| af == AF_UNSPEC) {
	364	struct protox *head;
	365
	366	head = (nl[N_TCB].n_type == 0) ? bbnprotox : berkprotox;
	367	setprotoent(1);
	368	setservent(1);
	369
	370	for (tp = head; tp->pr_name; tp++) {
	371	if (tp->pr_wanted == 0)
	372	continue;
	373
	374	if (sflag) {
	375	if (tp->pr_stats)
	376	(*tp->pr_stats)(nl[tp->pr_sindex].n_value, tp->pr_name);
	377	} else if (tp->pr_cblocks)
	378	(*tp->pr_cblocks)(nl[tp->pr_index].n_value, tp->pr_name);
	379	}
	380	endprotoent();
	381	}
	382	if (af == AF_NS \|\| af == AF_UNSPEC) {
	383	for (tp = nsprotox; tp->pr_name; tp++) {
	384	if (sflag) {
	385	if (tp->pr_stats)
	386	(*tp->pr_stats)(nl[tp->pr_sindex].n_value,
	387	tp->pr_name);
	388	} else
	389	if (tp->pr_cblocks)
	390	(*tp->pr_cblocks)(nl[tp->pr_index].n_value,
	391	tp->pr_name);
	392	}
	393	}
	394	if (af == AF_ISO \|\| af == AF_UNSPEC) {
	395	for (tp = isoprotox; tp->pr_name; tp++) {
	396	if (sflag) {
	397	if (tp->pr_stats)
	398	(*tp->pr_stats)(nl[tp->pr_sindex].n_value,
	399	tp->pr_name);
	400	} else
	401	if (tp->pr_cblocks)
	402	(*tp->pr_cblocks)(nl[tp->pr_index].n_value,
	403	tp->pr_name);
	404	}
	405	}
	406	if ((af == AF_UNIX \|\| af == AF_UNSPEC) && !sflag)
	407	unixpr((off_t)nl[N_NFILE].n_value, (off_t)nl[N_FILE].n_value,
	408	(struct protosw *)nl[N_UNIXSW].n_value);
	409	if (af == AF_UNSPEC && sflag)
	410	impstats(nl[N_IMP].n_value, nl[N_NIMP].n_value);
	411	exit(0);
	412	}
	413
	414	char *
	415	plural(n)
	416	int n;
	417	{
	418	return (n != 1 ? "s" : "");
	419	}
	420
	421	/*
	422	* Find the protox for the given "well-known" name.
	423	*/
	424	struct protox *
	425	knownname(name)
	426	char *name;
	427	{
	428	struct protox *tpp, tp;
	429
	430	for (tpp = protoprotox; *tpp; tpp++)
	431	for (tp = *tpp; tp->pr_name; tp++)
	432	if (strcmp(tp->pr_name, name) == 0)
	433	return(tp);
	434	return(NULL);
	435	}
	436
	437	/*
	438	* Find the protox corresponding to name.
	439	*/
	440	struct protox *
	441	name2protox(name)
	442	char *name;
	443	{
	444	struct protox *tp;
	445	char *alias; / alias from p->aliases */
	446	struct protoent *p;
	447
	448	/*
	449	* Try to find the name in the list of "well-known" names. If that
	450	* fails, check if name is an alias for an Internet protocol.
	451	*/
	452	if (tp = knownname(name))
	453	return(tp);
	454
	455	setprotoent(1); /* make protocol lookup cheaper */
	456	while (p = getprotoent()) {
	457	/* assert: name not same as p->name */
	458	for (alias = p->p_aliases; *alias; alias++)
	459	if (strcmp(name, *alias) == 0) {
	460	endprotoent();
	461	return(knownname(p->p_name));
	462	}
	463	}
	464	endprotoent();
	465	return(NULL);
	466	}
	467
	468	void
	469	usage()
	470	{
	471	(void)fprintf(stderr,
	472	"usage: netstat [-Aan] [-f address_family] [-M core] [-N system]\n");
	473	(void)fprintf(stderr,
	474	" [-himnrs] [-f address_family] [-M core] [-N system]\n");
	475	(void)fprintf(stderr,
	476	" [-n] [-I interface] [-M core] [-N system] [-w wait]\n");
	477	(void)fprintf(stderr,
	478	" [-M core] [-N system] [-p protocol]\n");
	479	exit(1);
	480	}