Home | History | Annotate | Line # | Download | only in netstat
main.c revision 1.63 
      1 /*	$NetBSD: main.c,v 1.63 2006/11/15 11:55:00 elad Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1983, 1988, 1993
      5  *	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. Neither the name of the University nor the names of its contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  */
     31 
     32 #include <sys/cdefs.h>
     33 #ifndef lint
     34 __COPYRIGHT("@(#) Copyright (c) 1983, 1988, 1993\n\
     35 	Regents of the University of California.  All rights reserved.\n");
     36 #endif /* not lint */
     37 
     38 #ifndef lint
     39 #if 0
     40 static char sccsid[] = "from: @(#)main.c	8.4 (Berkeley) 3/1/94";
     41 #else
     42 __RCSID("$NetBSD: main.c,v 1.63 2006/11/15 11:55:00 elad Exp $");
     43 #endif
     44 #endif /* not lint */
     45 
     46 #include <sys/param.h>
     47 #include <sys/file.h>
     48 #include <sys/protosw.h>
     49 #include <sys/socket.h>
     50 
     51 #include <net/if.h>
     52 #include <netinet/in.h>
     53 
     54 #include <ctype.h>
     55 #include <err.h>
     56 #include <errno.h>
     57 #include <kvm.h>
     58 #include <limits.h>
     59 #include <netdb.h>
     60 #include <nlist.h>
     61 #include <paths.h>
     62 #include <stdio.h>
     63 #include <stdlib.h>
     64 #include <string.h>
     65 #include <unistd.h>
     66 #include "netstat.h"
     67 
     68 struct nlist nl[] = {
     69 #define	N_MBSTAT	0
     70 	{ "_mbstat" },
     71 #define	N_IPSTAT	1
     72 	{ "_ipstat" },
     73 #define	N_TCBTABLE	2
     74 	{ "_tcbtable" },
     75 #define	N_TCPSTAT	3
     76 	{ "_tcpstat" },
     77 #define	N_UDBTABLE	4
     78 	{ "_udbtable" },
     79 #define	N_UDPSTAT	5
     80 	{ "_udpstat" },
     81 #define	N_IFNET		6
     82 	{ "_ifnet" },
     83 #define	N_IMP		7
     84 	{ "_imp_softc" },
     85 #define	N_ICMPSTAT	8
     86 	{ "_icmpstat" },
     87 #define	N_RTSTAT	9
     88 	{ "_rtstat" },
     89 #define	N_UNIXSW	10
     90 	{ "_unixsw" },
     91 #define N_IDP		11
     92 	{ "_nspcb"},
     93 #define N_IDPSTAT	12
     94 	{ "_idpstat"},
     95 #define N_SPPSTAT	13
     96 	{ "_spp_istat"},
     97 #define N_NSERR		14
     98 	{ "_ns_errstat"},
     99 #define	N_CLNPSTAT	15
    100 	{ "_clnp_stat"},
    101 #define	IN_NOTUSED	16
    102 	{ "_tp_inpcb" },
    103 #define	ISO_TP		17
    104 	{ "_tp_refinfo" },
    105 #define	N_TPSTAT	18
    106 	{ "_tp_stat" },
    107 #define	N_ESISSTAT	19
    108 	{ "_esis_stat"},
    109 #define N_NIMP		20
    110 	{ "_nimp"},
    111 #define N_RTREE		21
    112 	{ "_rt_tables"},
    113 #define N_CLTP		22
    114 	{ "_cltb"},
    115 #define N_CLTPSTAT	23
    116 	{ "_cltpstat"},
    117 #define	N_NFILE		24
    118 	{ "_nfile" },
    119 #define	N_FILE		25
    120 	{ "_file" },
    121 #define N_IGMPSTAT	26
    122 	{ "_igmpstat" },
    123 #define N_MRTPROTO	27
    124 	{ "_ip_mrtproto" },
    125 #define N_MRTSTAT	28
    126 	{ "_mrtstat" },
    127 #define N_MFCHASHTBL	29
    128 	{ "_mfchashtbl" },
    129 #define	N_MFCHASH	30
    130 	{ "_mfchash" },
    131 #define N_VIFTABLE	31
    132 	{ "_viftable" },
    133 #define N_MSIZE		32
    134 	{ "_msize" },
    135 #define N_MCLBYTES	33
    136 	{ "_mclbytes" },
    137 #define N_DDPSTAT	34
    138 	{ "_ddpstat"},
    139 #define N_DDPCB		35
    140 	{ "_ddpcb"},
    141 #define N_MBPOOL	36
    142 	{ "_mbpool" },
    143 #define N_MCLPOOL	37
    144 	{ "_mclpool" },
    145 #define N_DIVPCB	38
    146 	{ "_divcb"},
    147 #define N_DIVSTAT	39
    148 	{ "_divstat"},
    149 #define N_IP6STAT	40
    150 	{ "_ip6stat" },
    151 #define N_TCP6STAT	41
    152 	{ "_tcp6stat" },
    153 #define N_UDP6STAT	42
    154 	{ "_udp6stat" },
    155 #define N_ICMP6STAT	43
    156 	{ "_icmp6stat" },
    157 #define N_IPSECSTAT	44
    158 	{ "_ipsecstat" },
    159 #define N_IPSEC6STAT	45
    160 	{ "_ipsec6stat" },
    161 #define N_PIM6STAT	46
    162 	{ "_pim6stat" },
    163 #define N_MRT6PROTO	47
    164 	{ "_ip6_mrtproto" },
    165 #define N_MRT6STAT	48
    166 	{ "_mrt6stat" },
    167 #define N_MF6CTABLE	49
    168 	{ "_mf6ctable" },
    169 #define N_MIF6TABLE	50
    170 	{ "_mif6table" },
    171 #define N_PFKEYSTAT	51
    172 	{ "_pfkeystat" },
    173 #define N_ARPSTAT	52
    174 	{ "_arpstat" },
    175 #define N_RIP6STAT	53
    176 	{ "_rip6stat" },
    177 #define	N_ARPINTRQ	54
    178 	{ "_arpintrq" },
    179 #define	N_IPINTRQ	55
    180 	{ "_ipintrq" },
    181 #define	N_IP6INTRQ	56
    182 	{ "_ip6intrq" },
    183 #define	N_ATINTRQ1	57
    184 	{ "_atintrq1" },
    185 #define	N_ATINTRQ2	58
    186 	{ "_atintrq2" },
    187 #define	N_NSINTRQ	59
    188 	{ "_nsintrq" },
    189 #define	N_CLNLINTRQ	60
    190 	{ "_clnlintrq" },
    191 #define	N_LLCINTRQ	61
    192 	{ "_llcintrq" },
    193 #define	N_HDINTRQ	62
    194 	{ "_hdintrq" },
    195 #define	N_NATMINTRQ	63
    196 	{ "_natmintrq" },
    197 #define	N_PPPOEDISCINQ	64
    198 	{ "_ppoediscinq" },
    199 #define	N_PPPOEINQ	65
    200 	{ "_ppoeinq" },
    201 #define	N_PKINTRQ	66
    202 	{ "_pkintrq" },
    203 #define	N_HARDCLOCK_TICKS 67
    204 	{ "_hardclock_ticks" },
    205 #define N_PIMSTAT	68
    206 	{ "_pimstat" },
    207 #define N_CARPSTAT	69
    208 	{ "_carpstats" },
    209 	{ "" },
    210 };
    211 
    212 struct protox {
    213 	u_char	pr_index;		/* index into nlist of cb head */
    214 	u_char	pr_sindex;		/* index into nlist of stat block */
    215 	u_char	pr_wanted;		/* 1 if wanted, 0 otherwise */
    216 	void	(*pr_cblocks)		/* control blocks printing routine */
    217 			__P((u_long, char *));
    218 	void	(*pr_stats)		/* statistics printing routine */
    219 			__P((u_long, char *));
    220 	void	(*pr_istats)
    221 			__P((char *));	/* per/if statistics printing routine */
    222 	void	(*pr_dump)		/* PCB state dump routine */
    223 			__P((u_long));
    224 	char	*pr_name;		/* well-known name */
    225 } protox[] = {
    226 	{ N_TCBTABLE,	N_TCPSTAT,	1,	protopr,
    227 	  tcp_stats,	NULL,		tcp_dump,	"tcp" },
    228 	{ N_UDBTABLE,	N_UDPSTAT,	1,	protopr,
    229 	  udp_stats,	NULL,		0,	"udp" },
    230 	{ -1,		N_IPSTAT,	1,	0,
    231 	  ip_stats,	NULL,		0,	"ip" },
    232 	{ -1,		N_ICMPSTAT,	1,	0,
    233 	  icmp_stats,	NULL,		0,	"icmp" },
    234 	{ -1,		N_IGMPSTAT,	1,	0,
    235 	  igmp_stats,	NULL,		0,	"igmp" },
    236 	{ -1,		N_CARPSTAT,	1,	0,
    237 	  carp_stats,	NULL,		0,	"carp" },
    238 #ifdef IPSEC
    239 	{ -1,		N_IPSECSTAT,	1,	0,
    240 	  ipsec_switch,	NULL,		0,	"ipsec" },
    241 #endif
    242 	{ -1,		N_PIMSTAT,	1,	0,
    243 	  pim_stats,	NULL,		0,	"pim" },
    244 	{ -1,		-1,		0,	0,
    245 	  0,		NULL,		0,	0 }
    246 };
    247 
    248 #ifdef INET6
    249 struct protox ip6protox[] = {
    250 	{ -1,		N_IP6STAT,	1,	0,
    251 	  ip6_stats,	ip6_ifstats,	0,	"ip6" },
    252 	{ -1,		N_ICMP6STAT,	1,	0,
    253 	  icmp6_stats,	icmp6_ifstats,	0,	"icmp6" },
    254 #ifdef TCP6
    255 	{ N_TCBTABLE,	N_TCP6STAT,	1,	ip6protopr,
    256 	  tcp6_stats,	NULL,		tcp6_dump,	"tcp6" },
    257 #else
    258 	{ N_TCBTABLE,	N_TCP6STAT,	1,	ip6protopr,
    259 	  tcp_stats,	NULL,		tcp_dump,	"tcp6" },
    260 #endif
    261 	{ N_UDBTABLE,	N_UDP6STAT,	1,	ip6protopr,
    262 	  udp6_stats,	NULL,		0,	"udp6" },
    263 #ifdef IPSEC
    264 	{ -1,		N_IPSEC6STAT,	1,	0,
    265 	  ipsec_switch,	NULL,		0,	"ipsec6" },
    266 #endif
    267 	{ -1,		N_PIM6STAT,	1,	0,
    268 	  pim6_stats,	NULL,		0,	"pim6" },
    269 	{ -1,		N_RIP6STAT,	1,	0,
    270 	  rip6_stats,	NULL,		0,	"rip6" },
    271 	{ -1,		-1,		0,	0,
    272 	  0,		NULL,		0,	0 }
    273 };
    274 #endif
    275 
    276 struct protox arpprotox[] = {
    277 	{ -1,		N_ARPSTAT,	1,	0,
    278 	  arp_stats,	NULL,		0,	"arp" },
    279 	{ -1,		-1,		0,	0,
    280 	  0,		NULL,		0,	0 }
    281 };
    282 
    283 #ifdef IPSEC
    284 struct protox pfkeyprotox[] = {
    285 	{ -1,		N_PFKEYSTAT,	1,	0,
    286 	  pfkey_stats,	NULL,		0,	"pfkey" },
    287 	{ -1,		-1,		0,	0,
    288 	  0,		NULL,		0,	0 }
    289 };
    290 #endif
    291 
    292 #ifndef SMALL
    293 struct protox atalkprotox[] = {
    294 	{ N_DDPCB,	N_DDPSTAT,	1,	atalkprotopr,
    295 	  ddp_stats,	NULL,		0,	"ddp" },
    296 	{ -1,		-1,		0,	0,
    297 	  0,		NULL,		0 }
    298 };
    299 
    300 #ifdef NS
    301 struct protox nsprotox[] = {
    302 	{ N_IDP,	N_IDPSTAT,	1,	nsprotopr,
    303 	  idp_stats,	NULL,		0,	"idp" },
    304 	{ N_IDP,	N_SPPSTAT,	1,	nsprotopr,
    305 	  spp_stats,	NULL,		0,	"spp" },
    306 	{ -1,		N_NSERR,	1,	0,
    307 	  nserr_stats,	NULL,		0,	"ns_err" },
    308 	{ -1,		-1,		0,	0,
    309 	  0,		NULL,		0 }
    310 };
    311 #endif
    312 
    313 struct protox isoprotox[] = {
    314 	{ ISO_TP,	N_TPSTAT,	1,	iso_protopr,
    315 	  tp_stats,	NULL,		0,	"tp" },
    316 	{ N_CLTP,	N_CLTPSTAT,	1,	iso_protopr,
    317 	  cltp_stats,	NULL,		0,	"cltp" },
    318 	{ -1,		N_CLNPSTAT,	1,	 0,
    319 	  clnp_stats,	NULL,		0,	"clnp"},
    320 	{ -1,		N_ESISSTAT,	1,	 0,
    321 	  esis_stats,	NULL,		0,	"esis"},
    322 	{ -1,		-1,		0,	0,
    323 	  0,		NULL,		0,	0 }
    324 };
    325 #endif
    326 
    327 struct protox *protoprotox[] = { protox,
    328 #ifdef INET6
    329 				 ip6protox,
    330 #endif
    331 				 arpprotox,
    332 #ifdef IPSEC
    333 				 pfkeyprotox,
    334 #endif
    335 #ifndef SMALL
    336 				 atalkprotox,
    337 #ifdef NS
    338 				 nsprotox,
    339 #endif
    340 				 isoprotox,
    341 #endif
    342 				 NULL };
    343 
    344 const struct softintrq {
    345 	const char *siq_name;
    346 	int siq_index;
    347 } softintrq[] = {
    348 	{ "arpintrq", N_ARPINTRQ },
    349 	{ "ipintrq", N_IPINTRQ },
    350 	{ "ip6intrq", N_IP6INTRQ },
    351 	{ "atintrq1", N_ATINTRQ1 },
    352 	{ "atintrq2", N_ATINTRQ2 },
    353 #ifdef NS
    354 	{ "nsintrq", N_NSINTRQ },
    355 #endif
    356 	{ "clnlintrq", N_CLNLINTRQ },
    357 	{ "llcintrq", N_LLCINTRQ },
    358 	{ "hdintrq", N_HDINTRQ },
    359 	{ "natmintrq", N_NATMINTRQ },
    360 	{ "ppoediscinq", N_PPPOEDISCINQ },
    361 	{ "ppoeinq", N_PPPOEINQ },
    362 	{ "pkintrq", N_PKINTRQ },
    363 	{ NULL, -1 },
    364 };
    365 
    366 int main __P((int, char *[]));
    367 static void printproto __P((struct protox *, char *));
    368 static void print_softintrq __P((void));
    369 static void usage __P((void));
    370 static struct protox *name2protox __P((char *));
    371 static struct protox *knownname __P((char *));
    372 static void prepare(char *, char *);
    373 
    374 kvm_t *kvmd;
    375 gid_t egid;
    376 
    377 void
    378 prepare(char *nlistf, char *memf)
    379 {
    380 	char buf[_POSIX2_LINE_MAX];
    381 
    382 	/*
    383 	 * Try to figure out if we can use sysctl or not.
    384 	 */
    385 	if (nlistf != NULL && memf != NULL) {
    386 		/* If we have -M and -N, we're not dealing with live memory. */
    387 		use_sysctl = 0;
    388 	} else if (qflag ||
    389 		   rflag ||
    390 		   iflag ||
    391 #ifndef SMALL
    392 		   gflag ||
    393 #endif
    394 		   Pflag) {
    395 		/* These flags are not yet supported via sysctl(3). */
    396 		use_sysctl = 0;
    397 	} else {
    398 		/* We can use sysctl(3). */
    399 		use_sysctl = 1;
    400 	}
    401 
    402 	if (!use_sysctl) {
    403 		(void)setegid(egid);
    404 		kvmd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, buf);
    405 		(void)setgid(getgid());
    406 		if (kvmd == NULL)
    407 			err(1, "kvm error: %s", buf);
    408 
    409 		if (kvm_nlist(kvmd, nl) < 0 || nl[0].n_type == 0) {
    410 			if (nlistf)
    411 				errx(1, "%s: no namelist", nlistf);
    412 			else
    413 				errx(1, "no namelist");
    414 		}
    415 	} else
    416 		(void)setgid(getgid());
    417 }
    418 
    419 int
    420 main(argc, argv)
    421 	int argc;
    422 	char *argv[];
    423 {
    424 	struct protoent *p;
    425 	struct protox *tp;	/* for printing cblocks & stats */
    426 	int ch;
    427 	char *nlistf = NULL, *memf = NULL;
    428 	char *cp;
    429 	u_long pcbaddr;
    430 
    431 	egid = getegid();
    432 	(void)setegid(getgid());
    433 	tp = NULL;
    434 	af = AF_UNSPEC;
    435 	pcbaddr = 0;
    436 
    437 	while ((ch = getopt(argc, argv,
    438 	    "AabBdf:ghI:LliM:mN:nP:p:qrsStuvw:")) != -1)
    439 		switch (ch) {
    440 		case 'A':
    441 			Aflag = 1;
    442 			break;
    443 		case 'a':
    444 			aflag = 1;
    445 			break;
    446 		case 'b':
    447 			bflag = 1;
    448 			break;
    449 		case 'B':
    450 			Bflag = 1;
    451 			break;
    452 		case 'd':
    453 			dflag = 1;
    454 			break;
    455 		case 'f':
    456 #ifdef NS
    457 			if (strcmp(optarg, "ns") == 0) {
    458 				af = AF_NS;
    459 				break;
    460 			}
    461 #endif
    462 			if (strcmp(optarg, "inet") == 0)
    463 				af = AF_INET;
    464 			else if (strcmp(optarg, "inet6") == 0)
    465 				af = AF_INET6;
    466 			else if (strcmp(optarg, "arp") == 0)
    467 				af = AF_ARP;
    468 			else if (strcmp(optarg, "pfkey") == 0)
    469 				af = PF_KEY;
    470 			else if (strcmp(optarg, "unix") == 0
    471 			    || strcmp(optarg, "local") == 0)
    472 				af = AF_LOCAL;
    473 			else if (strcmp(optarg, "iso") == 0)
    474 				af = AF_ISO;
    475 			else if (strcmp(optarg, "atalk") == 0)
    476 				af = AF_APPLETALK;
    477 			else
    478 				errx(1, "%s: unknown address family",
    479 				    optarg);
    480 			break;
    481 #ifndef SMALL
    482 		case 'g':
    483 			gflag = 1;
    484 			break;
    485 #endif
    486 		case 'I':
    487 			iflag = 1;
    488 			interface = optarg;
    489 			break;
    490 		case 'i':
    491 			iflag = 1;
    492 			break;
    493 		case 'L':
    494 			Lflag = 1;
    495 			break;
    496 		case 'l':
    497 			lflag = 1;
    498 			break;
    499 		case 'M':
    500 			memf = optarg;
    501 			break;
    502 		case 'm':
    503 			mflag = 1;
    504 			break;
    505 		case 'N':
    506 			nlistf = optarg;
    507 			break;
    508 		case 'n':
    509 			numeric_addr = numeric_port = nflag = 1;
    510 			break;
    511 		case 'P':
    512 			errno = 0;
    513 			pcbaddr = strtoul(optarg, &cp, 16);
    514 			if (*cp != '\0' || errno == ERANGE)
    515 				errx(1, "invalid PCB address %s",
    516 				    optarg);
    517 			Pflag = 1;
    518 			break;
    519 		case 'p':
    520 			if ((tp = name2protox(optarg)) == NULL)
    521 				errx(1, "%s: unknown or uninstrumented protocol",
    522 				    optarg);
    523 			pflag = 1;
    524 			break;
    525 		case 'q':
    526 			qflag = 1;
    527 			break;
    528 		case 'r':
    529 			rflag = 1;
    530 			break;
    531 		case 's':
    532 			++sflag;
    533 			break;
    534 		case 'S':
    535 			numeric_addr = 1;
    536 			break;
    537 		case 't':
    538 			tflag = 1;
    539 			break;
    540 		case 'u':
    541 			af = AF_LOCAL;
    542 			break;
    543 		case 'v':
    544 			vflag++;
    545 			break;
    546 		case 'w':
    547 			interval = atoi(optarg);
    548 			iflag = 1;
    549 			break;
    550 		case '?':
    551 		default:
    552 			usage();
    553 		}
    554 	argv += optind;
    555 	argc -= optind;
    556 
    557 #define	BACKWARD_COMPATIBILITY
    558 #ifdef	BACKWARD_COMPATIBILITY
    559 	if (*argv) {
    560 		if (isdigit((unsigned char)**argv)) {
    561 			interval = atoi(*argv);
    562 			if (interval <= 0)
    563 				usage();
    564 			++argv;
    565 			iflag = 1;
    566 		}
    567 		if (*argv) {
    568 			nlistf = *argv;
    569 			if (*++argv)
    570 				memf = *argv;
    571 		}
    572 	}
    573 #endif
    574 
    575 	prepare(nlistf, memf);
    576 
    577 #ifndef SMALL
    578 	if (Bflag) {
    579 		if (sflag)
    580 			bpf_stats();
    581 		else
    582 			bpf_dump(interface);
    583 		exit(0);
    584 	}
    585 #endif
    586 
    587 	if (mflag) {
    588 		mbpr(nl[N_MBSTAT].n_value,  nl[N_MSIZE].n_value,
    589 		    nl[N_MCLBYTES].n_value, nl[N_MBPOOL].n_value,
    590 		    nl[N_MCLPOOL].n_value);
    591 		exit(0);
    592 	}
    593 	if (Pflag) {
    594 		if (tp == NULL) {
    595 			/* Default to TCP. */
    596 			tp = name2protox("tcp");
    597 		}
    598 		if (tp->pr_dump)
    599 			(*tp->pr_dump)(pcbaddr);
    600 		else
    601 			printf("%s: no PCB dump routine\n", tp->pr_name);
    602 		exit(0);
    603 	}
    604 	if (pflag) {
    605 		if (iflag && tp->pr_istats)
    606 			intpr(interval, nl[N_IFNET].n_value, tp->pr_istats);
    607 		else if (tp->pr_stats)
    608 			(*tp->pr_stats)(nl[tp->pr_sindex].n_value,
    609 				tp->pr_name);
    610 		else
    611 			printf("%s: no stats routine\n", tp->pr_name);
    612 		exit(0);
    613 	}
    614 	if (qflag) {
    615 		print_softintrq();
    616 		exit(0);
    617 	}
    618 	/*
    619 	 * Keep file descriptors open to avoid overhead
    620 	 * of open/close on each call to get* routines.
    621 	 */
    622 	sethostent(1);
    623 	setnetent(1);
    624 	if (iflag) {
    625 		if (af != AF_UNSPEC)
    626 			goto protostat;
    627 
    628 		intpr(interval, nl[N_IFNET].n_value, NULL);
    629 		exit(0);
    630 	}
    631 	if (rflag) {
    632 		if (sflag)
    633 			rt_stats(use_sysctl ? 0 : nl[N_RTSTAT].n_value);
    634 		else {
    635 			if (use_sysctl)
    636 				p_rttables(af);
    637 			else
    638 				routepr(nl[N_RTREE].n_value);
    639 		}
    640 		exit(0);
    641 	}
    642 #ifndef SMALL
    643 	if (gflag) {
    644 		if (sflag) {
    645 			if (af == AF_INET || af == AF_UNSPEC)
    646 				mrt_stats(nl[N_MRTPROTO].n_value,
    647 					  nl[N_MRTSTAT].n_value);
    648 #ifdef INET6
    649 			if (af == AF_INET6 || af == AF_UNSPEC)
    650 				mrt6_stats(nl[N_MRT6PROTO].n_value,
    651 					   nl[N_MRT6STAT].n_value);
    652 #endif
    653 		}
    654 		else {
    655 			if (af == AF_INET || af == AF_UNSPEC)
    656 				mroutepr(nl[N_MRTPROTO].n_value,
    657 					 nl[N_MFCHASHTBL].n_value,
    658 					 nl[N_MFCHASH].n_value,
    659 					 nl[N_VIFTABLE].n_value);
    660 #ifdef INET6
    661 			if (af == AF_INET6 || af == AF_UNSPEC)
    662 				mroute6pr(nl[N_MRT6PROTO].n_value,
    663 					  nl[N_MF6CTABLE].n_value,
    664 					  nl[N_MIF6TABLE].n_value);
    665 #endif
    666 		}
    667 		exit(0);
    668 	}
    669 #endif
    670   protostat:
    671 	if (af == AF_INET || af == AF_UNSPEC) {
    672 		setprotoent(1);
    673 		setservent(1);
    674 		/* ugh, this is O(MN) ... why do we do this? */
    675 		while ((p = getprotoent()) != NULL) {
    676 			for (tp = protox; tp->pr_name; tp++)
    677 				if (strcmp(tp->pr_name, p->p_name) == 0)
    678 					break;
    679 			if (tp->pr_name == 0 || tp->pr_wanted == 0)
    680 				continue;
    681 			printproto(tp, p->p_name);
    682 			tp->pr_wanted = 0;
    683 		}
    684 		endprotoent();
    685 		for (tp = protox; tp->pr_name; tp++)
    686 			if (tp->pr_wanted)
    687 				printproto(tp, tp->pr_name);
    688 	}
    689 #ifdef INET6
    690 	if (af == AF_INET6 || af == AF_UNSPEC)
    691 		for (tp = ip6protox; tp->pr_name; tp++)
    692 			printproto(tp, tp->pr_name);
    693 #endif
    694 	if (af == AF_ARP || af == AF_UNSPEC)
    695 		for (tp = arpprotox; tp->pr_name; tp++)
    696 			printproto(tp, tp->pr_name);
    697 #ifdef IPSEC
    698 	if (af == PF_KEY || af == AF_UNSPEC)
    699 		for (tp = pfkeyprotox; tp->pr_name; tp++)
    700 			printproto(tp, tp->pr_name);
    701 #endif
    702 #ifndef SMALL
    703 	if (af == AF_APPLETALK || af == AF_UNSPEC)
    704 		for (tp = atalkprotox; tp->pr_name; tp++)
    705 			printproto(tp, tp->pr_name);
    706 #ifdef NS
    707 	if (af == AF_NS || af == AF_UNSPEC)
    708 		for (tp = nsprotox; tp->pr_name; tp++)
    709 			printproto(tp, tp->pr_name);
    710 #endif
    711 	if (af == AF_ISO || af == AF_UNSPEC)
    712 		for (tp = isoprotox; tp->pr_name; tp++)
    713 			printproto(tp, tp->pr_name);
    714 	if ((af == AF_LOCAL || af == AF_UNSPEC) && !sflag)
    715 		unixpr(nl[N_UNIXSW].n_value);
    716 #endif
    717 	exit(0);
    718 }
    719 
    720 /*
    721  * Print out protocol statistics or control blocks (per sflag).
    722  * If the interface was not specifically requested, and the symbol
    723  * is not in the namelist, ignore this one.
    724  */
    725 static void
    726 printproto(tp, name)
    727 	struct protox *tp;
    728 	char *name;
    729 {
    730 	void (*pr) __P((u_long, char *));
    731 	u_long off;
    732 
    733 	if (sflag) {
    734 		if (iflag) {
    735 			if (tp->pr_istats)
    736 				intpr(interval, nl[N_IFNET].n_value,
    737 				      tp->pr_istats);
    738 			return;
    739 		}
    740 		else {
    741 			pr = tp->pr_stats;
    742 			off = nl[tp->pr_sindex].n_value;
    743 		}
    744 	} else {
    745 		pr = tp->pr_cblocks;
    746 		off = nl[tp->pr_index].n_value;
    747 	}
    748 	if (pr != NULL && ((off || af != AF_UNSPEC) || use_sysctl)) {
    749 		(*pr)(off, name);
    750 	}
    751 }
    752 
    753 /*
    754  * Print softintrq status.
    755  */
    756 void
    757 print_softintrq()
    758 {
    759 	struct ifqueue intrq, *ifq = &intrq;
    760 	const struct softintrq *siq;
    761 	u_long off;
    762 
    763 	for (siq = softintrq; siq->siq_name != NULL; siq++) {
    764 		off = nl[siq->siq_index].n_value;
    765 		if (off == 0)
    766 			continue;
    767 
    768 		kread(off, (char *)ifq, sizeof(*ifq));
    769 		printf("%s:\n", siq->siq_name);
    770 		printf("\tqueue length: %d\n", ifq->ifq_len);
    771 		printf("\tmaximum queue length: %d\n", ifq->ifq_maxlen);
    772 		printf("\tpackets dropped: %d\n", ifq->ifq_drops);
    773 	}
    774 }
    775 
    776 /*
    777  * Read kernel memory, return 0 on success.
    778  */
    779 int
    780 kread(addr, buf, size)
    781 	u_long addr;
    782 	char *buf;
    783 	int size;
    784 {
    785 
    786 	if (kvm_read(kvmd, addr, buf, size) != size) {
    787 		warnx("%s", kvm_geterr(kvmd));
    788 		return (-1);
    789 	}
    790 	return (0);
    791 }
    792 
    793 char *
    794 plural(n)
    795 	int n;
    796 {
    797 
    798 	return (n != 1 ? "s" : "");
    799 }
    800 
    801 char *
    802 plurales(n)
    803 	int n;
    804 {
    805 
    806 	return (n != 1 ? "es" : "");
    807 }
    808 
    809 int
    810 get_hardticks(void)
    811 {
    812 	int hardticks;
    813 
    814 	kread(nl[N_HARDCLOCK_TICKS].n_value, (char *)&hardticks,
    815 	    sizeof(hardticks));
    816 	return (hardticks);
    817 }
    818 
    819 /*
    820  * Find the protox for the given "well-known" name.
    821  */
    822 static struct protox *
    823 knownname(name)
    824 	char *name;
    825 {
    826 	struct protox **tpp, *tp;
    827 
    828 	for (tpp = protoprotox; *tpp; tpp++)
    829 		for (tp = *tpp; tp->pr_name; tp++)
    830 			if (strcmp(tp->pr_name, name) == 0)
    831 				return (tp);
    832 	return (NULL);
    833 }
    834 
    835 /*
    836  * Find the protox corresponding to name.
    837  */
    838 static struct protox *
    839 name2protox(name)
    840 	char *name;
    841 {
    842 	struct protox *tp;
    843 	char **alias;			/* alias from p->aliases */
    844 	struct protoent *p;
    845 
    846 	/*
    847 	 * Try to find the name in the list of "well-known" names. If that
    848 	 * fails, check if name is an alias for an Internet protocol.
    849 	 */
    850 	if ((tp = knownname(name)) != NULL)
    851 		return (tp);
    852 
    853 	setprotoent(1);			/* make protocol lookup cheaper */
    854 	while ((p = getprotoent()) != NULL) {
    855 		/* assert: name not same as p->name */
    856 		for (alias = p->p_aliases; *alias; alias++)
    857 			if (strcmp(name, *alias) == 0) {
    858 				endprotoent();
    859 				return (knownname(p->p_name));
    860 			}
    861 	}
    862 	endprotoent();
    863 	return (NULL);
    864 }
    865 
    866 static void
    867 usage()
    868 {
    869 	const char *progname = getprogname();
    870 
    871 	(void)fprintf(stderr,
    872 "usage: %s [-Aan] [-f address_family] [-M core] [-N system]\n", progname);
    873 	(void)fprintf(stderr,
    874 "       %s [-bdgiLmnqrsSv] [-f address_family] [-M core] [-N system]\n",
    875 	progname);
    876 	(void)fprintf(stderr,
    877 "       %s [-dn] [-I interface] [-M core] [-N system] [-w wait]\n", progname);
    878 	(void)fprintf(stderr,
    879 "       %s [-p protocol] [-M core] [-N system]\n", progname);
    880 	(void)fprintf(stderr,
    881 "       %s [-p protocol] [-M core] [-N system] -P pcbaddr\n", progname);
    882 	(void)fprintf(stderr,
    883 "       %s [-p protocol] [-i] [-I Interface] \n", progname);
    884 	(void)fprintf(stderr,
    885 "       %s [-s] [-f address_family] [-i] [-I Interface]\n", progname);
    886 	(void)fprintf(stderr,
    887 "       %s [-s] [-B] [-I interface]\n", progname);
    888 	exit(1);
    889 }
    890