netstat/main.c

/*
 * 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 this notice is preserved and that due credit is given
 * to the University of California at Berkeley. The name of the University
 * may not be used to endorse or promote products derived from this
 * software without specific prior written permission. This software
 * is provided ``as is'' without express or implied warranty.
 */

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

#ifndef lint
static char sccsid[] = "@(#)main.c      5.11 (Berkeley) 2/7/88";
#endif not lint

#include <sys/param.h>
#include <sys/vmmac.h>
#include <sys/socket.h>
#include <machine/pte.h>
#include <ctype.h>
#include <errno.h>
#include <netdb.h>
#include <nlist.h>
#include <stdio.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_RAWCB         6
        { "_rawcb" },
#define N_SYSMAP        7
        { "_Sysmap" },
#define N_SYSSIZE       8
        { "_Syssize" },
#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" },
#define N_NFILE         15
        { "_nfile" },
#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_NIMP          23
        { "_nimp"},
        "",
};

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

#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" },
        { -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  pte *Sysmap;

char    *system = "/vmunix";
char    *kmemf = "/dev/kmem";
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     interval;
char    *interface;
int     unit;
char    usage[] = "[ -Aaihmnrst ] [-f family] [-p proto] [-I interface] [ interval ] [ system ] [ core ]";

int     af = AF_UNSPEC;

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

main(argc, argv)
        int argc;
        char *argv[];
{
        char *cp, *name;
        register struct protoent *p;
        register struct protox *tp;     /* for printing cblocks & stats */
        struct protox *name2protox();   /* for -p */

        name = argv[0];
        argc--, argv++;
        while (argc > 0 && **argv == '-') {
                for (cp = &argv[0][1]; *cp; cp++)
                switch(*cp) {

                case 'A':
                        Aflag++;
                        break;

                case 'a':
                        aflag++;
                        break;

                case 'h':
                        hflag++;
                        break;

                case 'i':
                        iflag++;
                        break;

                case 'm':
                        mflag++;
                        break;

                case 'n':
                        nflag++;
                        break;

                case 'r':
                        rflag++;
                        break;

                case 's':
                        sflag++;
                        break;

                case 't':
                        tflag++;
                        break;

                case 'u':
                        af = AF_UNIX;
                        break;

                case 'p':
                        argv++;
                        argc--;
                        if (argc == 0)
                                goto use;
                        if ((tp = name2protox(*argv)) == NULLPROTOX) {
                                fprintf(stderr, "%s: unknown or uninstrumented protocol\n",
                                        *argv);
                                exit(10);
                        }
                        pflag++;
                        break;

                case 'f':
                        argv++;
                        argc--;
                        if (strcmp(*argv, "ns") == 0)
                                af = AF_NS;
                        else if (strcmp(*argv, "inet") == 0)
                                af = AF_INET;
                        else if (strcmp(*argv, "unix") == 0)
                                af = AF_UNIX;
                        else {
                                fprintf(stderr, "%s: unknown address family\n",
                                        *argv);
                                exit(10);
                        }
                        break;

                case 'I':
                        iflag++;
                        if (*(interface = cp + 1) == 0) {
                                if ((interface = argv[1]) == 0)
                                        break;
                                argv++;
                                argc--;
                        }
                        for (cp = interface; isalpha(*cp); cp++)
                                ;
                        unit = atoi(cp);
                        *cp-- = 0;
                        break;

                default:
use:
                        printf("usage: %s %s\n", name, usage);
                        exit(1);
                }
                argv++, argc--;
        }
        if (argc > 0 && isdigit(argv[0][0])) {
                interval = atoi(argv[0]);
                if (interval <= 0)
                        goto use;
                argv++, argc--;
                iflag++;
        }
        if (argc > 0) {
                system = *argv;
                argv++, argc--;
        }
        nlist(system, nl);
        if (nl[0].n_type == 0) {
                fprintf(stderr, "%s: no namelist\n", system);
                exit(1);
        }
        if (argc > 0) {
                kmemf = *argv;
                kflag++;
        }
        kmem = open(kmemf, 0);
        if (kmem < 0) {
                fprintf(stderr, "cannot open ");
                perror(kmemf);
                exit(1);
        }
        if (kflag) {
                off_t off;

                off = nl[N_SYSMAP].n_value & 0x7fffffff;
                lseek(kmem, off, 0);
                nl[N_SYSSIZE].n_value *= 4;
                Sysmap = (struct pte *)malloc((u_int)nl[N_SYSSIZE].n_value);
                if (Sysmap == 0) {
                        perror("Sysmap");
                        exit(1);
                }
                read(kmem, (char *)Sysmap, (int)nl[N_SYSSIZE].n_value);
        }
        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);
                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_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);
}

#ifndef KERNBASE
#ifdef vax
#define KERNBASE 0x80000000
#endif
#ifdef tahoe
#define KERNBASE 0xC0000000
#endif
#endif KERNBASE
/*
 * Seek into the kernel for a value.
 */
off_t
klseek(fd, base, off)
        int fd, off;
        off_t base;
{
        if (kflag) {
                /* get kernel pte */
                base &= ~KERNBASE;
                base = ctob(Sysmap[btop(base)].pg_pfnum) + (base & PGOFSET);
        }
        return (lseek(fd, base, off));
}

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 *tp;

        for (tp = protox; tp->pr_name; tp++)
                if (strcmp(tp->pr_name, name) == 0)
                        return(tp);
        for (tp = nsprotox; tp->pr_name; tp++)
                if (strcmp(tp->pr_name, name) == 0)
                        return(tp);
        return(NULLPROTOX);
}

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