![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trace.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sbin / XNSrouted|
Return to trace.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sbin / XNSrouted |
1.1 root 1: /*
2: * Copyright (c) 1985 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This file includes significant work done at Cornell University by
6: * Bill Nesheim. That work included by permission.
7: *
8: * Redistribution and use in source and binary forms are permitted
9: * provided that: (1) source distributions retain this entire copyright
10: * notice and comment, and (2) distributions including binaries display
11: * the following acknowledgement: ``This product includes software
12: * developed by the University of California, Berkeley and its contributors''
13: * in the documentation or other materials provided with the distribution
14: * and in all advertising materials mentioning features or use of this
15: * software. Neither the name of the University nor the names of its
16: * contributors may be used to endorse or promote products derived
17: * from this software without specific prior written permission.
18: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
19: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
20: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21: */
22:
23: #ifndef lint
24: static char sccsid[] = "@(#)trace.c 5.9 (Berkeley) 6/1/90";
25: #endif /* not lint */
26:
27: /*
28: * Routing Table Management Daemon
29: */
30: #define RIPCMDS
31: #include "defs.h"
32:
33: #define NRECORDS 50 /* size of circular trace buffer */
34: #ifdef DEBUG
35: FILE *ftrace = stdout;
36: int tracing = 1;
37: #else DEBUG
38: FILE *ftrace = NULL;
39: int tracing = 0;
40: #endif
41:
42: char *xns_ntoa();
43:
44: traceinit(ifp)
45: register struct interface *ifp;
46: {
47:
48: if (iftraceinit(ifp, &ifp->int_input) &&
49: iftraceinit(ifp, &ifp->int_output))
50: return;
51: tracing = 0;
52: syslog(LOG_ERR, "traceinit: can't init %s\n", ifp->int_name);
53: }
54:
55: static
56: iftraceinit(ifp, ifd)
57: struct interface *ifp;
58: register struct ifdebug *ifd;
59: {
60: register struct iftrace *t;
61:
62: ifd->ifd_records =
63: (struct iftrace *)malloc(NRECORDS * sizeof (struct iftrace));
64: if (ifd->ifd_records == 0)
65: return (0);
66: ifd->ifd_front = ifd->ifd_records;
67: ifd->ifd_count = 0;
68: for (t = ifd->ifd_records; t < ifd->ifd_records + NRECORDS; t++) {
69: t->ift_size = 0;
70: t->ift_packet = 0;
71: }
72: ifd->ifd_if = ifp;
73: return (1);
74: }
75:
76: traceon(file)
77: char *file;
78: {
79:
80: if (ftrace != NULL)
81: return;
82: ftrace = fopen(file, "a");
83: if (ftrace == NULL)
84: return;
85: dup2(fileno(ftrace), 1);
86: dup2(fileno(ftrace), 2);
87: tracing = 1;
88: }
89:
90: traceoff()
91: {
92: if (!tracing)
93: return;
94: if (ftrace != NULL)
95: fclose(ftrace);
96: ftrace = NULL;
97: tracing = 0;
98: }
99:
100: trace(ifd, who, p, len, m)
101: register struct ifdebug *ifd;
102: struct sockaddr *who;
103: char *p;
104: int len, m;
105: {
106: register struct iftrace *t;
107:
108: if (ifd->ifd_records == 0)
109: return;
110: t = ifd->ifd_front++;
111: if (ifd->ifd_front >= ifd->ifd_records + NRECORDS)
112: ifd->ifd_front = ifd->ifd_records;
113: if (ifd->ifd_count < NRECORDS)
114: ifd->ifd_count++;
115: if (t->ift_size > 0 && t->ift_packet)
116: free(t->ift_packet);
117: t->ift_packet = 0;
118: t->ift_stamp = time(0);
119: t->ift_who = *who;
120: if (len > 0) {
121: t->ift_packet = malloc(len);
122: if (t->ift_packet)
123: bcopy(p, t->ift_packet, len);
124: else
125: len = 0;
126: }
127: t->ift_size = len;
128: t->ift_metric = m;
129: }
130:
131: traceaction(fd, action, rt)
132: FILE *fd;
133: char *action;
134: struct rt_entry *rt;
135: {
136: struct sockaddr_ns *dst, *gate;
137: static struct bits {
138: int t_bits;
139: char *t_name;
140: } flagbits[] = {
141: { RTF_UP, "UP" },
142: { RTF_GATEWAY, "GATEWAY" },
143: { RTF_HOST, "HOST" },
144: { 0 }
145: }, statebits[] = {
146: { RTS_PASSIVE, "PASSIVE" },
147: { RTS_REMOTE, "REMOTE" },
148: { RTS_INTERFACE,"INTERFACE" },
149: { RTS_CHANGED, "CHANGED" },
150: { 0 }
151: };
152: register struct bits *p;
153: register int first;
154: char *cp;
155: struct interface *ifp;
156:
157: if (fd == NULL)
158: return;
159: fprintf(fd, "%s ", action);
160: dst = (struct sockaddr_ns *)&rt->rt_dst;
161: gate = (struct sockaddr_ns *)&rt->rt_router;
162: fprintf(fd, "dst %s, ", xns_ntoa(&dst->sns_addr));
163: fprintf(fd, "router %s, metric %d, flags",
164: xns_ntoa(&gate->sns_addr), rt->rt_metric);
165: cp = " %s";
166: for (first = 1, p = flagbits; p->t_bits > 0; p++) {
167: if ((rt->rt_flags & p->t_bits) == 0)
168: continue;
169: fprintf(fd, cp, p->t_name);
170: if (first) {
171: cp = "|%s";
172: first = 0;
173: }
174: }
175: fprintf(fd, " state");
176: cp = " %s";
177: for (first = 1, p = statebits; p->t_bits > 0; p++) {
178: if ((rt->rt_state & p->t_bits) == 0)
179: continue;
180: fprintf(fd, cp, p->t_name);
181: if (first) {
182: cp = "|%s";
183: first = 0;
184: }
185: }
186: putc('\n', fd);
187: if (!tracepackets && (rt->rt_state & RTS_PASSIVE) == 0 && rt->rt_ifp)
188: dumpif(fd, rt->rt_ifp);
189: fflush(fd);
190: }
191:
192: dumpif(fd, ifp)
193: register struct interface *ifp;
194: FILE *fd;
195: {
196: if (ifp->int_input.ifd_count || ifp->int_output.ifd_count) {
197: fprintf(fd, "*** Packet history for interface %s ***\n",
198: ifp->int_name);
199: dumptrace(fd, "to", &ifp->int_output);
200: dumptrace(fd, "from", &ifp->int_input);
201: fprintf(fd, "*** end packet history ***\n");
202: }
203: }
204:
205: dumptrace(fd, dir, ifd)
206: FILE *fd;
207: char *dir;
208: register struct ifdebug *ifd;
209: {
210: register struct iftrace *t;
211: char *cp = !strcmp(dir, "to") ? "Output" : "Input";
212:
213: if (ifd->ifd_front == ifd->ifd_records &&
214: ifd->ifd_front->ift_size == 0) {
215: fprintf(fd, "%s: no packets.\n", cp);
216: return;
217: }
218: fprintf(fd, "%s trace:\n", cp);
219: t = ifd->ifd_front - ifd->ifd_count;
220: if (t < ifd->ifd_records)
221: t += NRECORDS;
222: for ( ; ifd->ifd_count; ifd->ifd_count--, t++) {
223: if (t >= ifd->ifd_records + NRECORDS)
224: t = ifd->ifd_records;
225: if (t->ift_size == 0)
226: continue;
227: fprintf(fd, "%.24s: metric=%d\n", ctime(&t->ift_stamp),
228: t->ift_metric);
229: dumppacket(fd, dir, &t->ift_who, t->ift_packet, t->ift_size);
230: }
231: }
232:
233: dumppacket(fd, dir, who, cp, size)
234: FILE *fd;
235: struct sockaddr_ns *who; /* should be sockaddr */
236: char *dir, *cp;
237: register int size;
238: {
239: register struct rip *msg = (struct rip *)cp;
240: register struct netinfo *n;
241: char *xns_nettoa();
242:
243: if (msg->rip_cmd && ntohs(msg->rip_cmd) < RIPCMD_MAX)
244: fprintf(fd, "%s %s %s#%x", ripcmds[ntohs(msg->rip_cmd)],
245: dir, xns_ntoa(&who->sns_addr), ntohs(who->sns_addr.x_port));
246: else {
247: fprintf(fd, "Bad cmd 0x%x %s %s#%x\n", ntohs(msg->rip_cmd),
248: dir, xns_ntoa(&who->sns_addr), ntohs(who->sns_addr.x_port));
249: fprintf(fd, "size=%d cp=%x packet=%x\n", size, cp, packet);
250: return;
251: }
252: switch (ntohs(msg->rip_cmd)) {
253:
254: case RIPCMD_REQUEST:
255: case RIPCMD_RESPONSE:
256: fprintf(fd, ":\n");
257: size -= sizeof (u_short);
258: n = msg->rip_nets;
259: for (; size > 0; n++, size -= sizeof (struct netinfo)) {
260: if (size < sizeof (struct netinfo))
261: break;
262: fprintf(fd, "\tnet %s metric %d\n",
263: xns_nettoa(n->rip_dst),
264: ntohs(n->rip_metric));
265: }
266: break;
267:
268: }
269: }
270:
271: union ns_net_u net;
272:
273: char *
274: xns_nettoa(val)
275: union ns_net val;
276: {
277: static char buf[100];
278: net.net_e = val;
279: (void)sprintf(buf, "%lx", ntohl(net.long_e));
280: return (buf);
281: }
282:
283:
284: char *
285: xns_ntoa(addr)
286: struct ns_addr *addr;
287: {
288: static char buf[100];
289:
290: (void)sprintf(buf, "%s#%x:%x:%x:%x:%x:%x",
291: xns_nettoa(addr->x_net),
292: addr->x_host.c_host[0], addr->x_host.c_host[1],
293: addr->x_host.c_host[2], addr->x_host.c_host[3],
294: addr->x_host.c_host[4], addr->x_host.c_host[5]);
295:
296: return(buf);
297: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.