/*
 * |-----------------------------------------------------------|
 * | Copyright (c) 1991, 1990 MIPS Computer Systems, Inc.      |
 * | All Rights Reserved                                       |
 * |-----------------------------------------------------------|
 * |          Restricted Rights Legend                         |
 * | Use, duplication, or disclosure by the Government is      |
 * | subject to restrictions as set forth in                   |
 * | subparagraph (c)(1)(ii) of the Rights in Technical        |
 * | Data and Computer Software Clause of DFARS 252.227-7013.  |
 * |         MIPS Computer Systems, Inc.                       |
 * |         950 DeGuigne Avenue                               |
 * |         Sunnyvale, California 94088-3650, USA             |
 * |-----------------------------------------------------------|
 */
#ident	"$Header: main.c,v 1.14.3.1 92/06/24 13:40:22 marker Exp $"

/*
 * Copyright (c) 1983, 1988 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted provided
 * that: (1) source distributions retain this entire copyright notice and
 * comment, and (2) distributions including binaries display the following
 * acknowledgement:  ``This product includes software developed by the
 * University of California, Berkeley and its contributors'' in the
 * documentation or other materials provided with the distribution and in
 * all advertising materials mentioning features or use of this software.
 * 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 ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#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.19 (Berkeley) 6/18/90";
#endif /* not lint */

#include <sys/param.h>
#include <sys/vmmac.h>
#include <sys/socket.h>
#include <sys/file.h>
#include <machine/pte.h>
#include <ctype.h>
#include <errno.h>
#include <netdb.h>
#include <nlist.h>
#include <stdio.h>
#ifdef _RISCOS
#include "libutil.h"
#include <net/if.h>
#include <sys/ioctl.h>
#include <mipsif/if_enp.h>
typedef unsigned char	UBYTE;
typedef unsigned short	UWORD;
typedef unsigned long	ULONG;
typedef unsigned short Bit;
#include <sysv/sys/if_egl.h>
#define _PATH_UNIX "/unix"
char *netstat_name;
#else _RISCOS
#include <paths.h>
#endif _RISCOS

#define nl netstatnl
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_RAWCB		6
	{ "_rawcb" },
#define	N_SYSMAP	7
#ifdef _RISCOS
	{ "kptbl" },
#else _RISCOS
	{ "_Sysmap" },
#endif _RISCOS
#define	N_SYSSIZE	8
#ifdef _RISCOS
	{ "syssegsz" },
#else _RISCOS
	{ "_Syssize" },
#endif _RISCOS
#define	N_IFNET		9
	{ "_ifnet" },
#define	N_IMP		10
	{ "_imp_softc" },
#define	N_RTHOST	11
	{ "_rthost" },
#define	N_RTNET		12
	{ "_rtnet" },
#define	N_ICMPSTAT	13
	{ "_icmpstat" },
#define	N_RTSTAT	14
	{ "_rtstat" },
#ifdef _RISCOS
#define	N_V		15
	{ "_v" },   /* System Configuration structure */
#else
#define	N_NFILE		15
	{ "_nfile" },
#endif _RISCOS
#define	N_FILE		16
	{ "_file" },
#define	N_UNIXSW	17
	{ "_unixsw" },
#define N_RTHASHSIZE	18
	{ "_rthashsize" },
#define N_IDP		19
	{ "_nspcb"},
#define N_IDPSTAT	20
	{ "_idpstat"},
#define N_SPPSTAT	21
	{ "_spp_istat"},
#define N_NSERR		22
	{ "_ns_errstat"},
#define	N_CLNPSTAT	23
	{ "_clnp_stat"},
#define	IN_TP		24
	{ "_tp_inpcb" },
#define	ISO_TP		25
	{ "_tp_isopcb" },
#define	ISO_X25		26
	{ /*"_x25_isopcb"*/ "_file"}, /* fast gross hack to speed up */
#define	N_TPSTAT	27
	{ "_tp_stat" },
#define	N_X25STAT	28
	{ /*"_x25_stat"*/ "_file"},
#define	N_ESISSTAT	29
	{ "_esis_stat"},
#define N_NIMP		30
	{ "_nimp"},
#define N_RTREE		31
	{ "_radix_node_head"},
#define N_CLTP		32
	{ "_cltb"},
#define N_CLTPSTAT	33
	{ "_cltpstat"},
#ifdef _RISCOS
#define N_ID_STRING	34
	{ "id_string" },
#define N_PAGESIZE	35
	{ "pagesize" },
#endif _RISCOS

	"",
};

/* internet protocols */
extern	int protopr();
extern	int tcp_stats(), udp_stats(), ip_stats(), icmp_stats();
/* ns protocols */
extern	int nsprotopr();
extern	int spp_stats(), idp_stats(), nserr_stats();
#ifdef _RISCOS
extern	int enp_stats();
#endif _RISCOS
/* iso protocols */
extern	int iso_protopr();
extern	int tp_stats(), esis_stats(), clnp_stats(), cltp_stats();

#define NULLPROTOX	((struct protox *) 0)
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 */
} protox[] = {
	{ 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 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" },
#ifdef notdef
	{ ISO_X25,	N_X25STAT,	1,	x25_protopr,
	  x25_stats,	"x25" },
#endif
	{ -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, NULLPROTOX };

struct	pte *Sysmap;

char	*system = _PATH_UNIX;
#ifdef _RISCOS
char	*kmemf = "/dev/kmem";
#else _RISCOS
char	*kmemf;
#endif _RISCOS
int	kmem;
int	kflag;
int	Aflag;
int	aflag;
int	hflag;
int	iflag;
int	mflag;
int	nflag;
int	pflag;
int	rflag;
int	sflag;
int	tflag;
#ifdef _RISCOS
int	fflag;
int	eflag;
int	Vflag;
#endif _RISCOS
int	dflag;
int	interval;
char	*interface;
int	unit;
#ifdef _RISCOS
char	usage_m1[] =
	  "[ -Aanu ] [ -f address_family ] [ system ] [ core ]";
char	usage_m2[] = 
	  "[ -himnrsuV ] [ -f address_family ] [ system ] [ core ]";
char	usage_m3[] =
	  "[ -nV ] [ -I interface ] interval [ system ] [ core ]";
#endif _RISCOS

int	af = AF_UNSPEC;
#ifdef _RISCOS
char	iface[128];
#endif _RISCOS

extern	char *malloc();
extern	off_t lseek();

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;

#ifdef _RISCOS
	netstat_name = argv[0];
#endif _RISCOS
	while ((ch = getopt(argc, argv, "AI:af:himnp:drstue:V?")) != EOF)
		switch((char)ch) {
		case 'A':
			Aflag++;
			break;
		case 'I': {
			char *cp;

			iflag++;
			for (cp = interface = optarg; isalpha(*cp); cp++);
			unit = atoi(cp);
			*cp = '\0';
			break;
		}
		case 'a':
			aflag++;
			break;

		case 'd':
			dflag++;
			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 {
				fprintf(stderr, "%s: unknown address family\n", optarg);
				exit(10);
			}
			break;
		case 'h':
			hflag++;
			break;

		case 'i':
			iflag++;
			break;

		case 'm':
			mflag++;
			break;

		case 'n':
			nflag++;
			break;

		case 'p':
			if ((tp = name2protox(optarg)) == NULLPROTOX) {
				fprintf(stderr, "%s: unknown or uninstrumented protocol\n", optarg);
				exit(10);
			}
			pflag++;
			break;
		case 'r':
			rflag++;
			break;

		case 's':
			sflag++;
			break;

		case 't':
			tflag++;
			break;

		case 'u':
			af = AF_UNIX;
			break;

#ifdef _RISCOS
		case 'V':
			Vflag++;
			break;

		case 'e':
			eflag++;
			strcpy(iface, optarg);
			break;
#else _RISCOS

		case 'e':
		case 'V':
#endif _RISCOS
		case '?':
		default:
			usage();
		}
	argv += optind;
	argc -= optind;

	if (argc > 0) {
		if (isdigit(argv[0][0])) {
			interval = atoi(argv[0]);
			if (interval <= 0)
				usage();
			argv++, argc--;
			iflag++;
		}
		if (argc > 0) {
			system = *argv;
			argv++, argc--;
			if (argc > 0) {
				kmemf = *argv;
				kflag++;
			}
		}
	}
#ifdef _RISCOS
	nlist(system, nl);
	if (nl[0].n_type == 0) {
		fprintf(stderr, "%s: no namelist\n", system);
		exit(1);
	}
	kmem = open(kmemf, 0);
	if (kmem < 0) {
		fprintf(stderr, "cannot open ");
		perror(kmemf);
		exit(1);
	}
	/* Check to ensure that the kernel id strings match */
	if (check_kernel_id (kmem,
			(long)nl[N_ID_STRING].n_value, system) > 0) {
		fprintf(stderr,"%s does not match %s\n",system,kmemf);
		exit(1);
	};
	if (kflag) {
		initkmem(kmem, nl[N_SYSSIZE].n_value, nl[N_SYSMAP].n_value,
			nl[N_PAGESIZE].n_value);
	}

	if (eflag) {
		ifstat_dump();
		exit(0);
	}
#else _RISCOS
	if (kvm_openfiles(system, kmemf, (char *)0) == -1) {
		fprintf("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", system);
		exit(1);
	};
#endif RISCOS

	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) {
	setprotoent(1);
	setservent(1);
	while (p = getprotoent()) {

		for (tp = protox; tp->pr_name; tp++)
			if (strcmp(tp->pr_name, p->p_name) == 0)
				break;
		if (tp->pr_name == 0 || tp->pr_wanted == 0)
			continue;
		if (sflag) {
			if (tp->pr_stats)
				(*tp->pr_stats)(nl[tp->pr_sindex].n_value,
					p->p_name);
		} else
			if (tp->pr_cblocks)
				(*tp->pr_cblocks)(nl[tp->pr_index].n_value,
					p->p_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)
#ifdef _RISCOS
	    unixpr ((off_t)nl[N_V].n_value, (off_t)nl[N_FILE].n_value,
		(struct protosw *)nl[N_UNIXSW].n_value);
#else _RISCOS
	    unixpr((off_t)nl[N_NFILE].n_value, (off_t)nl[N_FILE].n_value,
		(struct protosw *)nl[N_UNIXSW].n_value);
#endif _RISCOS
    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(NULLPROTOX);
}


#ifdef _RISCOS
/*
 * A little tid bit to dump the guts of the ENP-10.  We need this to
 * get a better handle on network performance.
 */

int
ifstat_dump()
{
	int s;
	struct {
		struct enpstat board_stats;
		struct es_stats driver_stats;
		EGL_CSB eglstat;
		} enpstat;
	register struct enpstat *bs = &enpstat.board_stats;
	register struct es_stats *ds = &enpstat.driver_stats;
	extern int errno;
	struct ifreq ifr;

	errno = 0;
	ifr.ifr_data = (caddr_t)&enpstat;
	strcpy(ifr.ifr_name, iface);
	s = socket(AF_INET, SOCK_DGRAM, 0);
	if (errno)
		{
		perror("Socket failed on");
		exit(1);
		}

	ioctl(s, SIOCGIFSTATS, &ifr);
	if (errno)
		{
		perror("Ioctl failed on");
		exit(1);
		}

	printf("Interface Statistics Dump For %s\n", iface);
	switch (iface[1]) {
		case 'n':
			/* enp */
		printf("successful transmit\t%d\n", bs->e_xmit_successful);
		printf("multiple retries\t%d\n", bs->e_mult_retry);
		printf("single retries\t\t%d\n", bs->e_one_retry);
		printf("failed retries\t\t%d\n", bs->e_fail_retry);
		printf("deferred transmits\t%d\n", bs->e_deferrals);
		printf("transmit buf error\t%d\n", bs->e_xmit_buff_err);
		printf("silo underrun\t\t%d\t", bs->e_silo_underrun);
		printf("silo overrun\t\t%d\n", bs->e_silo_overrun);
		printf("late collisions\t\t%d\n", bs->e_late_coll);
		printf("lost carrier\t\t%d\n", bs->e_lost_carrier);
		printf("babbling node\t\t%d\n", bs->e_babble);
		printf("no hearbeat\t\t%d\n", bs->e_no_heartbeat);
		printf("transmit mem error\t%d\n", bs->e_xmit_mem_err);
		printf("successful receive\t%d\n", bs->e_rcv_successful);
		printf("dropped packets\t\t%d\n", bs->e_rcv_missed);
		printf("crc error\t\t%d\n", bs->e_crc_err);
		printf("frame error\t\t%d\n", bs->e_frame_err);
		printf("receive buf errror\t%d\n", bs->e_rcv_buff_err);
		printf("receive mem error\t%d\n", bs->e_rcv_mem_err);
		printf("rcv controller error\t%d\n", ds->ictlrerr);
		printf("rcv bad trailer1\t%d\t", ds->ibadtrailer);
		printf("rcv bad trailer2\t%d\n", ds->ibadtrailer2);
		printf("no rcv mbufs\t\t%d\t", ds->inombufs);
		printf("no xmit mbufs\t\t%d\n", ds->onombufs);
		printf("rcv queue full\t\t%d\n", ds->iqfull);
			break;
		case 'g':
			/* egl */
#ifdef notdef
		printf("LANCE Interrupts\t\t%d\n", enpstat.eglstat.csb_NLINT);
		printf("Attempted Transmissions\t\t%d\n", enpstat.eglstat.csb_NATX);
		printf("Transmissions\t\t\t%d\n", enpstat.eglstat.csb_NTX);
		printf("Multiple Retries\t\t%d\n", enpstat.eglstat.csb_NMR);
		printf("Single Retries\t\t\t%d\n", enpstat.eglstat.csb_NSR);
		printf("Retry Failures\t\t\t%d\n", enpstat.eglstat.csb_NRF);
		printf("Deferrals\t\t\t%d\n", enpstat.eglstat.csb_NDEF);
		printf("Transmit Buffer Errors\t\t%d\n", enpstat.eglstat.csb_NTBE);
		printf("SILO Underruns\t\t\t%d\n", enpstat.eglstat.csb_NSLU);
		printf("Late Collisions\t\t\t%d\n", enpstat.eglstat.csb_NLTC);
		printf("Carrier Losses\t\t\t%d\n", enpstat.eglstat.csb_NCLS);
		printf("Babbling Xmitter\t\t%d\n", enpstat.eglstat.csb_NBTX);
		printf("Collisions\t\t\t%d\n", enpstat.eglstat.csb_NCOL);
		printf("Transmit Memory Errors\t\t%d\n", enpstat.eglstat.csb_NTME);
		printf("Transmit Ring Owner Errors\t%d\n", enpstat.eglstat.csb_TROWN);
		printf("Attempted Receptions\t\t%d\n", enpstat.eglstat.csb_NATR);
		printf("Messages Received\t\t%d\n", enpstat.eglstat.csb_NRCV);
		printf("Missed Messages\t\t\t%d\n", enpstat.eglstat.csb_NMIS);
		printf("CRC Errors\t\t\t%d\n", enpstat.eglstat.csb_CRC);
		printf("Framing Errors\t\t\t%d\n", enpstat.eglstat.csb_FRAM);
		printf("Receive Buffer Errors\t\t%d\n", enpstat.eglstat.csb_NRBE);
		printf("Silo Overruns\t\t\t%d\n", enpstat.eglstat.csb_NSLO);
		printf("Receive Memory Errors\t\t%d\n", enpstat.eglstat.csb_NRME);
		printf("Revceive Ring Owner Errors\t%d\n", enpstat.eglstat.csb_RROWN);
#endif notdef
			break;
		}
}
#endif _RISCOS

/*
 * 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(NULLPROTOX);
}

#ifdef _RISCOS
klseek(fd, base, off) 
int	fd, base, off;
{
	kmem_lseek(fd, base, off, kflag);
}

int
kvm_read(off,addr,size)
	off_t	off;
	caddr_t	addr;
	int	size;
{
	if (klseek(kmem,off,0) == -1)
		return(-1);
	return(read(kmem,addr,size));
}
#endif _RISCOS

usage()
{
#ifdef _RISCOS
	fprintf(stderr,"usage: %s %s\n", netstat_name, usage_m1);
	fprintf(stderr,"       %s %s\n", netstat_name, usage_m2);
	fprintf(stderr,"       %s %s\n", netstat_name, usage_m3);
#else _RISCOS
	fputs("usage: netstat [-Aan] [-f address_family] [system] [core]\n               [-himnrs] [-f address_family] [system] [core]\n               [-n] [-I interface] interval [system] [core]\n", stderr);
#endif _RISCOS
	exit(1);
}
