![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pk_dump.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / tests / netccitt|
Return to pk_dump.c CVS log | Up to [Net/2] / Net2 / tests / netccitt |
1.1 root 1: /*-
2: * Copyright (c) 1988, 1991 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This product includes software developed by the University of
16: * California, Berkeley and its contributors.
17: * 4. Neither the name of the University nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: */
33:
34: #ifndef lint
35: char copyright[] =
36: "@(#) Copyright (c) 1988, 1991 The Regents of the University of California.\n\
37: All rights reserved.\n";
38: #endif /* not lint */
39:
40: #ifndef lint
41: static char sccsid[] = "@(#)pk_dump.c 7.2 (Berkeley) 5/9/91";
42: #endif /* not lint */
43:
44: /*
45: * This is a kernel debugging aid.
46: * dumps out a cache of mbufs.
47: */
48:
49: #include <sys/param.h>
50: #include <sys/mbuf.h>
51: #include <sys/socket.h>
52: #include <sys/socketvar.h>
53: #include <net/if.h>
54: #include <netccitt/x25.h>
55: #include <netccitt/pk.h>
56: #include <netccitt/pk_var.h>
57:
58: #include <errno.h>
59: #include <netdb.h>
60: #include <nlist.h>
61: #include <kvm.h>
62: #include <paths.h>
63: #include <stdio.h>
64: /*
65: * This procedure decodes the X.25 level 3 packet returning a
66: * code to be used in switchs or arrays.
67: */
68:
69: pk_decode (xp)
70: register struct x25_packet *xp;
71: {
72: register int type;
73:
74: if (xp -> fmt_identifier != 1)
75: return (INVALID_PACKET);
76: #ifdef ancient_history
77: /*
78: * Make sure that the logical channel group number is 0.
79: * This restriction may be removed at some later date.
80: */
81: if (xp -> lc_group_number != 0)
82: return (INVALID_PACKET);
83: #endif
84: /*
85: * Test for data packet first.
86: */
87: if (!(xp -> packet_type & DATA_PACKET_DESIGNATOR))
88: return (DATA);
89:
90: /*
91: * Test if flow control packet (RR or RNR).
92: */
93: if (!(xp -> packet_type & RR_OR_RNR_PACKET_DESIGNATOR))
94: switch (xp -> packet_type & 0x1f) {
95: case X25_RR:
96: return (RR);
97: case X25_RNR:
98: return (RNR);
99: case X25_REJECT:
100: return (REJECT);
101: }
102:
103: /*
104: * Determine the rest of the packet types.
105: */
106: switch (xp -> packet_type) {
107: case X25_CALL:
108: type = CALL;
109: break;
110:
111: case X25_CALL_ACCEPTED:
112: type = CALL_ACCEPTED;
113: break;
114:
115: case X25_CLEAR:
116: type = CLEAR;
117: break;
118:
119: case X25_CLEAR_CONFIRM:
120: type = CLEAR_CONF;
121: break;
122:
123: case X25_INTERRUPT:
124: type = INTERRUPT;
125: break;
126:
127: case X25_INTERRUPT_CONFIRM:
128: type = INTERRUPT_CONF;
129: break;
130:
131: case X25_RESET:
132: type = RESET;
133: break;
134:
135: case X25_RESET_CONFIRM:
136: type = RESET_CONF;
137: break;
138:
139: case X25_RESTART:
140: type = RESTART;
141: break;
142:
143: case X25_RESTART_CONFIRM:
144: type = RESTART_CONF;
145: break;
146:
147: case X25_DIAGNOSTIC:
148: type = DIAG_TYPE;
149: break;
150:
151: default:
152: type = INVALID_PACKET;
153: }
154: return (type);
155: }
156:
157: char *pk_state[] = {
158: "Listen", "Ready", "Received-Call",
159: "Sent-Call", "Data-Transfer","Received-Clear",
160: "Sent-Clear",
161: };
162:
163: char *pk_name[] = {
164: "Call", "Call-Conf", "Clear",
165: "Clear-Conf", "Data", "Intr", "Intr-Conf",
166: "Rr", "Rnr", "Reset", "Reset-Conf",
167: "Restart", "Restart-Conf", "Reject", "Diagnostic",
168: "Invalid"
169: };
170:
171: int pk_lengths[] = {0, 0, 0,
172: 0, 3, 5, 3,
173: 3, 3, 5, 5,
174: 5, 5, 5, 0,
175: 0, 0};
176:
177: pk_trace (m, dir)
178: register struct mbuf *m;
179: char *dir;
180: {
181: register char *s;
182: struct x25_packet *xp = mtod(m, struct x25_packet *);
183: register int i, len = 0, cnt = 0;
184:
185: i = pk_decode (xp) / MAXSTATES;
186: if ((len = pk_lengths[i]) || (len = m -> m_len))
187: if (len > 5)
188: len = 5;
189:
190: printf ("%s LCN=%d: %s (", dir, LCN(xp), pk_name[i]);
191:
192: for (s = (char *) xp, i = 0; i < len; ++i, ++s)
193: printf ("%x ", (int) * s & 0xff);
194: printf (")\n");
195: }
196:
197: bprintf(fp, b, s)
198: register FILE *fp;
199: register int b;
200: register u_char *s;
201: {
202: register int i;
203: int gotsome = 0;
204:
205: if (b == 0)
206: return;
207: while (i = *s++) {
208: if (b & (1 << (i-1))) {
209: if (gotsome == 0)
210: i = '<';
211: else
212: i = ',';
213: (void) putc(i, fp);
214: gotsome = 1;
215: for (; (i = *s) > 32; s++)
216: (void) putc(i, fp);
217: } else
218: while (*s > 32)
219: s++;
220: }
221: if (gotsome)
222: (void) putc('>', fp);
223: }
224:
225: int verbose = 0; /* so you can adb -w the binary */
226: int tflag = 0;
227: int Iflag = 0;
228: int Aflag = 0;
229: char *vmunix = _PATH_UNIX;
230: char *kmemf;
231: struct nlist nl[] = {
232: {"_pk_output_cache"},
233: {"_pk_input_cache"},
234: 0
235: };
236:
237: main(argc, argv)
238: int argc;
239: char **argv;
240: {
241:
242: if (kvm_openfiles(vmunix, kmemf, NULL) == -1) {
243: fprintf(stderr, "netstat: kvm_openfiles: %s\n", kvm_geterr());
244: exit(1);
245: }
246: if (kvm_nlist(nl) < 0 || nl[0].n_type == 0) {
247: fprintf(stderr, "%s: no namelist\n", vmunix);
248: exit(1);
249: }
250: mbuf_cache_dump(nl);
251: mbuf_cache_dump(nl + 1);
252: }
253: struct mbuf_cache c;
254: struct mbuf **mbvec;
255: #define kget(p, d) \
256: (kvm_read((void *)(p), &(d), sizeof (d)))
257:
258: mbuf_cache_dump(nl)
259: struct nlist *nl;
260: {
261: register struct mbuf *m;
262: unsigned cache_size;
263: int i;
264:
265: printf("Dumping %s:\n", nl->n_name);
266: kget(nl->n_value, c);
267: if (cache_size = c.mbc_size * sizeof(m))
268: mbvec = (struct mbuf **)malloc(cache_size);
269: if (mbvec == 0 || c.mbc_cache == 0)
270: return;
271: kvm_read(c.mbc_cache, mbvec, cache_size);
272: for (i = c.mbc_num;;) {
273: if (i == 0)
274: i = c.mbc_size;
275: i--;
276: if (m = mbvec[i])
277: mbuf_dump(m);
278: if (i == c.mbc_num)
279: break;
280: }
281: }
282:
283:
284: mbuf_dump(m)
285: register struct mbuf *m;
286: {
287: int virgin = 1;
288: register struct x25_packet *xp;
289: struct mbuf n;
290: char extbuf[1024];
291:
292: putchar('\n');
293: for (; m; m = n.m_next) {
294: kget(m, n);
295: printf("m %x", m);
296: if (n.m_flags) {
297: printf(" flags ");
298: bprintf(stdout, n.m_flags,
299: "\1M_EXT\2M_PKTHDR\3M_EOR\4M_BCAST\5M_MCAST");
300: }
301: if (Aflag)
302: printf(" chained %x", n.m_nextpkt);
303: printf(" next %x len %d", n.m_next, n.m_len);
304: if (n.m_flags & M_PKTHDR) {
305: printf(" total %d", n.m_pkthdr.len);
306: if (Iflag)
307: printf(" rcvif %x", n.m_pkthdr.rcvif);
308: }
309: putchar('\n');
310: if (n.m_flags & M_EXT) {
311: kvm_read(n.m_ext.ext_buf, extbuf, sizeof(extbuf));
312: n.m_data = extbuf + (n.m_data - n.m_ext.ext_buf);
313: } else if (n.m_data < m->m_dat + MLEN)
314: n.m_data = n.m_dat + (n.m_data - m->m_dat);
315: else {
316: printf("mbuf screwup\n");
317: continue;
318: }
319: if (virgin) {
320: virgin = 0;
321: pk_trace(&n, " X.25: ");
322: }
323: dumpit("data: ",n.m_data, n.m_len);
324: }
325: }
326:
327: dumpit(what, where, n)
328: char *what; unsigned short *where; int n;
329: {
330: unsigned short *s = where;
331: unsigned short *z = where + (n+1)/2;
332: int count = 0;
333:
334: if (verbose == 0)
335: return;
336: printf(what);
337: while(s < z) {
338: count++;
339: printf("%x ",*s++);
340: if ((count & 15) == 0)
341: putchar('\n');
342: }
343: if (count & 15)
344: putchar('\n');
345: fflush(stdout);
346: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.