![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trsp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / trsp|
Return to trsp.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / trsp |
1.1 root 1: /*
2: * Copyright (c) 1985 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted provided
6: * that: (1) source distributions retain this entire copyright notice and
7: * comment, and (2) distributions including binaries display the following
8: * acknowledgement: ``This product includes software developed by the
9: * University of California, Berkeley and its contributors'' in the
10: * documentation or other materials provided with the distribution and in
11: * all advertising materials mentioning features or use of this software.
12: * Neither the name of the University nor the names of its contributors may
13: * be used to endorse or promote products derived from this software without
14: * specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: char copyright[] =
22: "@(#) Copyright (c) 1985 Regents of the University of California.\n\
23: All rights reserved.\n";
24: #endif /* not lint */
25:
26: #ifndef lint
27: static char sccsid[] = "@(#)trsp.c 6.7 (Berkeley) 6/1/90";
28: #endif /* not lint */
29:
30: #include <sys/param.h>
31: #include <sys/socket.h>
32: #include <sys/socketvar.h>
33: #define PRUREQUESTS
34: #include <sys/protosw.h>
35:
36: #include <net/route.h>
37: #include <net/if.h>
38:
39: #define TCPSTATES
40: #include <netinet/tcp_fsm.h>
41: #define TCPTIMERS
42: #include <netinet/tcp_timer.h>
43:
44: #include <netns/ns.h>
45: #include <netns/ns_pcb.h>
46: #include <netns/idp.h>
47: #include <netns/idp_var.h>
48: #include <netns/sp.h>
49: #include <netns/spidp.h>
50: #include <netns/spp_timer.h>
51: #include <netns/spp_var.h>
52: #define SANAMES
53: #include <netns/spp_debug.h>
54:
55: #include <stdio.h>
56: #include <errno.h>
57: #include <nlist.h>
58: #include <paths.h>
59:
60: unsigned long ntime;
61: int sflag;
62: int tflag;
63: int jflag;
64: int aflag;
65: int zflag;
66: int numeric();
67: struct nlist nl[] = {
68: { "_spp_debug" },
69: { "_spp_debx" },
70: 0
71: };
72: struct spp_debug spp_debug[SPP_NDEBUG];
73: caddr_t spp_pcbs[SPP_NDEBUG];
74: int spp_debx;
75:
76: main(argc, argv)
77: int argc;
78: char **argv;
79: {
80: int i, mask = 0, npcbs = 0;
81: char *system, *core;
82:
83: system = _PATH_UNIX;
84: core = _PATH_KMEM;
85:
86: argc--, argv++;
87: again:
88: if (argc > 0 && !strcmp(*argv, "-a")) {
89: aflag++, argc--, argv++;
90: goto again;
91: }
92: if (argc > 0 && !strcmp(*argv, "-z")) {
93: zflag++, argc--, argv++;
94: goto again;
95: }
96: if (argc > 0 && !strcmp(*argv, "-s")) {
97: sflag++, argc--, argv++;
98: goto again;
99: }
100: if (argc > 0 && !strcmp(*argv, "-t")) {
101: tflag++, argc--, argv++;
102: goto again;
103: }
104: if (argc > 0 && !strcmp(*argv, "-j")) {
105: jflag++, argc--, argv++;
106: goto again;
107: }
108: if (argc > 0 && !strcmp(*argv, "-p")) {
109: argc--, argv++;
110: if (argc < 1) {
111: fprintf(stderr, "-p: missing sppcb address\n");
112: exit(1);
113: }
114: if (npcbs >= SPP_NDEBUG) {
115: fprintf(stderr, "-p: too many pcb's specified\n");
116: exit(1);
117: }
118: sscanf(*argv, "%x", &spp_pcbs[npcbs++]);
119: argc--, argv++;
120: goto again;
121: }
122: if (argc > 0) {
123: system = *argv;
124: argc--, argv++;
125: mask++;
126: }
127: if (argc > 0) {
128: core = *argv;
129: argc--, argv++;
130: mask++;
131: }
132: (void) nlist(system, nl);
133: if (nl[0].n_value == 0) {
134: fprintf(stderr, "trsp: %s: no namelist\n", system);
135: exit(1);
136: }
137: (void) close(0);
138: if (open(core, 0) < 0) {
139: fprintf(stderr, "trsp: "); perror(core);
140: exit(2);
141: }
142: if (mask) {
143: nl[0].n_value &= 0x7fffffff;
144: nl[1].n_value &= 0x7fffffff;
145: }
146: (void) lseek(0, nl[1].n_value, 0);
147: if (read(0, &spp_debx, sizeof (spp_debx)) != sizeof (spp_debx)) {
148: fprintf(stderr, "trsp: "); perror("spp_debx");
149: exit(3);
150: }
151: printf("spp_debx=%d\n", spp_debx);
152: (void) lseek(0, nl[0].n_value, 0);
153: if (read(0, spp_debug, sizeof (spp_debug)) != sizeof (spp_debug)) {
154: fprintf(stderr, "trsp: "); perror("spp_debug");
155: exit(3);
156: }
157: /*
158: * Here, we just want to clear out the old trace data and start over.
159: */
160: if (zflag) {
161: char *cp = (char *) spp_debug,
162: *cplim = cp + sizeof(spp_debug);
163: (void) close(0);
164: if (open(core, 2) < 0) {
165: fprintf(stderr, "trsp: "); perror(core);
166: exit(2);
167: }
168: while(cp < cplim) *cp++ = 0;
169: (void) lseek(0, nl[0].n_value, 0);
170: if (write(0, spp_debug, sizeof (spp_debug)) != sizeof (spp_debug)) {
171: fprintf(stderr, "trsp: "); perror("spp_debug");
172: exit(3);
173: }
174: (void) lseek(0, nl[1].n_value, 0);
175: spp_debx = 0;
176: if (write(0, &spp_debx, sizeof (spp_debx)) != sizeof (spp_debx)) {
177: fprintf(stderr, "trsp: "); perror("spp_debx");
178: exit(3);
179: }
180: exit(0);
181: }
182: /*
183: * If no control blocks have been specified, figure
184: * out how many distinct one we have and summarize
185: * them in spp_pcbs for sorting the trace records
186: * below.
187: */
188: if (npcbs == 0) {
189: for (i = 0; i < SPP_NDEBUG; i++) {
190: register int j;
191: register struct spp_debug *sd = &spp_debug[i];
192:
193: if (sd->sd_cb == 0)
194: continue;
195: for (j = 0; j < npcbs; j++)
196: if (spp_pcbs[j] == sd->sd_cb)
197: break;
198: if (j >= npcbs)
199: spp_pcbs[npcbs++] = sd->sd_cb;
200: }
201: }
202: qsort(spp_pcbs, npcbs, sizeof (caddr_t), numeric);
203: if (jflag) {
204: char *cp = "";
205:
206: for (i = 0; i < npcbs; i++) {
207: printf("%s%x", cp, spp_pcbs[i]);
208: cp = ", ";
209: }
210: if (*cp)
211: putchar('\n');
212: exit(0);
213: }
214: for (i = 0; i < npcbs; i++) {
215: printf("\n%x:\n", spp_pcbs[i]);
216: dotrace(spp_pcbs[i]);
217: }
218: exit(0);
219: }
220:
221: dotrace(sppcb)
222: register caddr_t sppcb;
223: {
224: register int i;
225: register struct spp_debug *sd;
226:
227: for (i = spp_debx % SPP_NDEBUG; i < SPP_NDEBUG; i++) {
228: sd = &spp_debug[i];
229: if (sppcb && sd->sd_cb != sppcb)
230: continue;
231: ntime = ntohl(sd->sd_time);
232: spp_trace(sd->sd_act, sd->sd_ostate, sd->sd_cb, &sd->sd_sp,
233: &sd->sd_si, sd->sd_req);
234: }
235: for (i = 0; i < spp_debx % SPP_NDEBUG; i++) {
236: sd = &spp_debug[i];
237: if (sppcb && sd->sd_cb != sppcb)
238: continue;
239: ntime = ntohl(sd->sd_time);
240: spp_trace(sd->sd_act, sd->sd_ostate, sd->sd_cb, &sd->sd_sp,
241: &sd->sd_si, sd->sd_req);
242: }
243: }
244:
245: ptime(ms)
246: int ms;
247: {
248:
249: printf("%03d ", (ms/10) % 1000);
250: }
251:
252: numeric(c1, c2)
253: caddr_t *c1, *c2;
254: {
255:
256: return (*c1 - *c2);
257: }
258:
259: spp_trace(act, ostate, asp, sp, si, req)
260: short act, ostate;
261: struct sppcb *asp, *sp;
262: struct spidp *si;
263: int req;
264: {
265: u_short seq, ack, len, alo;
266: int flags, timer;
267: char *cp;
268:
269: if(ostate >= TCP_NSTATES) ostate = 0;
270: if(act > SA_DROP) act = SA_DROP;
271: printf("\n");
272: ptime(ntime);
273: printf("%s:%s", tcpstates[ostate], sanames[act]);
274:
275: if (si != 0) {
276: seq = si->si_seq;
277: ack = si->si_ack;
278: alo = si->si_alo;
279: len = si->si_len;
280: switch (act) {
281: case SA_RESPOND:
282: case SA_OUTPUT:
283: seq = ntohs(seq);
284: ack = ntohs(ack);
285: alo = ntohs(alo);
286: len = ntohs(len);
287: case SA_INPUT:
288: case SA_DROP:
289: if (aflag) {
290: printf("\n\tsna=");
291: ns_printhost(&si->si_sna);
292: printf("\tdna=");
293: ns_printhost(&si->si_dna);
294: }
295: printf("\n\t");
296: #define p1(f) { printf("%s = %x, ", "f", f); }
297: p1(seq); p1(ack); p1(alo); p1(len);
298: flags = si->si_cc;
299: printf("flags=%x", flags);
300: if (flags) {
301: char *cp = "<";
302: #define pf(f) { if (flags&f) { printf("%s%s", cp, "f"); cp = ","; } }
303: pf(SP_SP); pf(SP_SA); pf(SP_OB); pf(SP_EM);
304: printf(">");
305: }
306: printf(", ");
307: #define p2(f) { printf("%s = %x, ", "f", si->si_/**/f); }
308: p2(sid);p2(did);p2(dt);
309: printf("\n\tsna=");
310: ns_printhost(&si->si_sna);
311: printf("\tdna=");
312: ns_printhost(&si->si_dna);
313: }
314: }
315: if(act == SA_USER) {
316: printf("\treq=%s", prurequests[req&0xff]);
317: if ((req & 0xff) == PRU_SLOWTIMO)
318: printf("<%s>", tcptimers[req>>8]);
319: }
320: printf(" -> %s", tcpstates[sp->s_state]);
321:
322: /* print out internal state of sp !?! */
323: printf("\n");
324: if (sp == 0)
325: return;
326: #define p3(f) { printf("%s = %x, ", "f", sp->s_/**/f); }
327: if(sflag) {
328: printf("\t"); p3(rack); p3(ralo); p3(smax); p3(snxt); p3(flags);
329: #undef pf
330: #define pf(f) { if (flags&SF_/**/f) { printf("%s%s", cp, "f"); cp = ","; } }
331: flags = sp->s_flags;
332: if (flags || sp->s_oobflags) {
333: char *cp = "<";
334: pf(ACKNOW); pf(DELACK); pf(HI); pf(HO);
335: pf(PI); pf(WIN); pf(RXT); pf(RVD);
336: flags = sp->s_oobflags;
337: pf(SOOB); pf(IOOB);
338: printf(">");
339: }
340:
341: }
342: /* print out timers? */
343: if (tflag) {
344: char *cp = "\t";
345: register int i;
346:
347: printf("\n\tTIMERS: ");
348: p3(idle); p3(force); p3(rtseq);
349: for (i = 0; i < TCPT_NTIMERS; i++) {
350: if (sp->s_timer[i] == 0)
351: continue;
352: printf("%s%s=%d", cp, tcptimers[i], sp->s_timer[i]);
353: if (i == TCPT_REXMT)
354: printf(" (s_rxtshft=%d)", sp->s_rxtshift);
355: cp = ", ";
356: }
357: if (*cp != '\t')
358: putchar('\n');
359: }
360: }
361:
362: ns_printhost(p)
363: register struct ns_addr *p;
364: {
365:
366: printf("<net:%x%x,host:%4.4x%4.4x%4.4x,port:%x>",
367: p->x_net.s_net[0],
368: p->x_net.s_net[1],
369: p->x_host.s_host[0],
370: p->x_host.s_host[1],
371: p->x_host.s_host[2],
372: p->x_port);
373:
374: }
375:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.