![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / netstat|
Return to main.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / netstat |
1.1 root 1: /*
2: * Copyright (c) 1983 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: char copyright[] =
9: "@(#) Copyright (c) 1983 Regents of the University of California.\n\
10: All rights reserved.\n";
11: #endif not lint
12:
13: #ifndef lint
14: static char sccsid[] = "@(#)main.c 5.7 (Berkeley) 5/22/86";
15: #endif not lint
16:
17: #include <sys/param.h>
18: #include <sys/vmmac.h>
19: #include <sys/socket.h>
20: #include <machine/pte.h>
21: #include <ctype.h>
22: #include <errno.h>
23: #include <netdb.h>
24: #include <nlist.h>
25: #include <stdio.h>
26:
27: struct nlist nl[] = {
28: #define N_MBSTAT 0
29: { "_mbstat" },
30: #define N_IPSTAT 1
31: { "_ipstat" },
32: #define N_TCB 2
33: { "_tcb" },
34: #define N_TCPSTAT 3
35: { "_tcpstat" },
36: #define N_UDB 4
37: { "_udb" },
38: #define N_UDPSTAT 5
39: { "_udpstat" },
40: #define N_RAWCB 6
41: { "_rawcb" },
42: #define N_SYSMAP 7
43: { "_Sysmap" },
44: #define N_SYSSIZE 8
45: { "_Syssize" },
46: #define N_IFNET 9
47: { "_ifnet" },
48: #define N_HOSTS 10
49: { "_hosts" },
50: #define N_RTHOST 11
51: { "_rthost" },
52: #define N_RTNET 12
53: { "_rtnet" },
54: #define N_ICMPSTAT 13
55: { "_icmpstat" },
56: #define N_RTSTAT 14
57: { "_rtstat" },
58: #define N_NFILE 15
59: { "_nfile" },
60: #define N_FILE 16
61: { "_file" },
62: #define N_UNIXSW 17
63: { "_unixsw" },
64: #define N_RTHASHSIZE 18
65: { "_rthashsize" },
66: #define N_IDP 19
67: { "_nspcb"},
68: #define N_IDPSTAT 20
69: { "_idpstat"},
70: #define N_SPPSTAT 21
71: { "_spp_istat"},
72: #define N_NSERR 22
73: { "_ns_errstat"},
74: "",
75: };
76:
77: /* internet protocols */
78: extern int protopr();
79: extern int tcp_stats(), udp_stats(), ip_stats(), icmp_stats();
80: extern int nsprotopr();
81: extern int spp_stats(), idp_stats(), nserr_stats();
82:
83: struct protox {
84: u_char pr_index; /* index into nlist of cb head */
85: u_char pr_sindex; /* index into nlist of stat block */
86: u_char pr_wanted; /* 1 if wanted, 0 otherwise */
87: int (*pr_cblocks)(); /* control blocks printing routine */
88: int (*pr_stats)(); /* statistics printing routine */
89: char *pr_name; /* well-known name */
90: } protox[] = {
91: { N_TCB, N_TCPSTAT, 1, protopr,
92: tcp_stats, "tcp" },
93: { N_UDB, N_UDPSTAT, 1, protopr,
94: udp_stats, "udp" },
95: { -1, N_IPSTAT, 1, 0,
96: ip_stats, "ip" },
97: { -1, N_ICMPSTAT, 1, 0,
98: icmp_stats, "icmp" },
99: { -1, -1, 0, 0,
100: 0, 0 }
101: };
102:
103: struct protox nsprotox[] = {
104: { N_IDP, N_IDPSTAT, 1, nsprotopr,
105: idp_stats, "idp" },
106: { N_IDP, N_SPPSTAT, 1, nsprotopr,
107: spp_stats, "spp" },
108: { -1, N_NSERR, 1, 0,
109: nserr_stats, "ns_err" },
110: { -1, -1, 0, 0,
111: 0, 0 }
112: };
113:
114: struct pte *Sysmap;
115:
116: char *system = "/vmunix";
117: char *kmemf = "/dev/kmem";
118: int kmem;
119: int kflag;
120: int Aflag;
121: int aflag;
122: int hflag;
123: int iflag;
124: int mflag;
125: int nflag;
126: int rflag;
127: int sflag;
128: int tflag;
129: int fflag;
130: int interval;
131: char *interface;
132: int unit;
133: char usage[] = "[ -Aaihmnrst ] [-f address_family] [-I interface] [ interval ] [ system ] [ core ]";
134:
135: int af = AF_UNSPEC;
136:
137: main(argc, argv)
138: int argc;
139: char *argv[];
140: {
141: int i;
142: char *cp, *name;
143: register struct protoent *p;
144: register struct protox *tp;
145:
146: name = argv[0];
147: argc--, argv++;
148: while (argc > 0 && **argv == '-') {
149: for (cp = &argv[0][1]; *cp; cp++)
150: switch(*cp) {
151:
152: case 'A':
153: Aflag++;
154: break;
155:
156: case 'a':
157: aflag++;
158: break;
159:
160: case 'h':
161: hflag++;
162: break;
163:
164: case 'i':
165: iflag++;
166: break;
167:
168: case 'm':
169: mflag++;
170: break;
171:
172: case 'n':
173: nflag++;
174: break;
175:
176: case 'r':
177: rflag++;
178: break;
179:
180: case 's':
181: sflag++;
182: break;
183:
184: case 't':
185: tflag++;
186: break;
187:
188: case 'u':
189: af = AF_UNIX;
190: break;
191:
192: case 'f':
193: argv++;
194: argc--;
195: if (strcmp(*argv, "ns") == 0)
196: af = AF_NS;
197: else if (strcmp(*argv, "inet") == 0)
198: af = AF_INET;
199: else if (strcmp(*argv, "unix") == 0)
200: af = AF_UNIX;
201: else {
202: fprintf(stderr, "%s: unknown address family\n",
203: *argv);
204: exit(10);
205: }
206: break;
207:
208: case 'I':
209: iflag++;
210: if (*(interface = cp + 1) == 0) {
211: if ((interface = argv[1]) == 0)
212: break;
213: argv++;
214: argc--;
215: }
216: for (cp = interface; isalpha(*cp); cp++)
217: ;
218: unit = atoi(cp);
219: *cp-- = 0;
220: break;
221:
222: default:
223: use:
224: printf("usage: %s %s\n", name, usage);
225: exit(1);
226: }
227: argv++, argc--;
228: }
229: if (argc > 0 && isdigit(argv[0][0])) {
230: interval = atoi(argv[0]);
231: if (interval <= 0)
232: goto use;
233: argv++, argc--;
234: iflag++;
235: }
236: if (argc > 0) {
237: system = *argv;
238: argv++, argc--;
239: }
240: nlist(system, nl);
241: if (nl[0].n_type == 0) {
242: fprintf(stderr, "%s: no namelist\n", system);
243: exit(1);
244: }
245: if (argc > 0) {
246: kmemf = *argv;
247: kflag++;
248: }
249: kmem = open(kmemf, 0);
250: if (kmem < 0) {
251: fprintf(stderr, "cannot open ");
252: perror(kmemf);
253: exit(1);
254: }
255: if (kflag) {
256: off_t off;
257:
258: off = nl[N_SYSMAP].n_value & 0x7fffffff;
259: lseek(kmem, off, 0);
260: nl[N_SYSSIZE].n_value *= 4;
261: Sysmap = (struct pte *)malloc(nl[N_SYSSIZE].n_value);
262: if (Sysmap == 0) {
263: perror("Sysmap");
264: exit(1);
265: }
266: read(kmem, Sysmap, nl[N_SYSSIZE].n_value);
267: }
268: if (mflag) {
269: mbpr(nl[N_MBSTAT].n_value);
270: exit(0);
271: }
272: /*
273: * Keep file descriptors open to avoid overhead
274: * of open/close on each call to get* routines.
275: */
276: sethostent(1);
277: setnetent(1);
278: if (iflag) {
279: intpr(interval, nl[N_IFNET].n_value);
280: exit(0);
281: }
282: if (hflag) {
283: hostpr(nl[N_HOSTS].n_value);
284: exit(0);
285: }
286: if (rflag) {
287: if (sflag)
288: rt_stats(nl[N_RTSTAT].n_value);
289: else
290: routepr(nl[N_RTHOST].n_value, nl[N_RTNET].n_value,
291: nl[N_RTHASHSIZE].n_value);
292: exit(0);
293: }
294: if (af == AF_INET || af == AF_UNSPEC) {
295: setprotoent(1);
296: setservent(1);
297: while (p = getprotoent()) {
298:
299: for (tp = protox; tp->pr_name; tp++)
300: if (strcmp(tp->pr_name, p->p_name) == 0)
301: break;
302: if (tp->pr_name == 0 || tp->pr_wanted == 0)
303: continue;
304: if (sflag) {
305: if (tp->pr_stats)
306: (*tp->pr_stats)(nl[tp->pr_sindex].n_value,
307: p->p_name);
308: } else
309: if (tp->pr_cblocks)
310: (*tp->pr_cblocks)(nl[tp->pr_index].n_value,
311: p->p_name);
312: }
313: endprotoent();
314: }
315: if (af == AF_NS || af == AF_UNSPEC) {
316: for (tp = nsprotox; tp->pr_name; tp++) {
317: if (sflag) {
318: if (tp->pr_stats)
319: (*tp->pr_stats)(nl[tp->pr_sindex].n_value,
320: tp->pr_name);
321: } else
322: if (tp->pr_cblocks)
323: (*tp->pr_cblocks)(nl[tp->pr_index].n_value,
324: tp->pr_name);
325: }
326: }
327: if ((af == AF_UNIX || af == AF_UNSPEC) && !sflag)
328: unixpr(nl[N_NFILE].n_value, nl[N_FILE].n_value,
329: nl[N_UNIXSW].n_value);
330: exit(0);
331: }
332:
333: /*
334: * Seek into the kernel for a value.
335: */
336: klseek(fd, base, off)
337: int fd, base, off;
338: {
339:
340: if (kflag) {
341: /* get kernel pte */
342: #ifdef vax
343: base &= 0x7fffffff;
344: #endif
345: base = ctob(Sysmap[btop(base)].pg_pfnum) + (base & PGOFSET);
346: }
347: lseek(fd, base, off);
348: }
349:
350: char *
351: plural(n)
352: int n;
353: {
354:
355: return (n != 1 ? "s" : "");
356: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.