![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to implog.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / etc / implog|
Return to implog.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / etc / implog |
1.1 root 1: /*
2: * Copyright (c) 1983, 1988 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that the above copyright notice and this paragraph are
7: * duplicated in all such forms and that any documentation,
8: * advertising materials, and other materials related to such
9: * distribution and use acknowledge that the software was developed
10: * by the University of California, Berkeley. The name of the
11: * University may not be used to endorse or promote products derived
12: * from this software without specific prior written permission.
13: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
14: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
15: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
16: */
17:
18: #ifndef lint
19: char copyright[] =
20: "@(#) Copyright (c) 1983, 1988 Regents of the University of California.\n\
21: All rights reserved.\n";
22: #endif /* not lint */
23:
24: #ifndef lint
25: static char sccsid[] = "@(#)implog.c 5.10 (Berkeley) 6/18/88";
26: #endif /* not lint */
27:
28: #include <stdio.h>
29: #include <signal.h>
30: #include <sgtty.h>
31:
32: #include <sys/time.h>
33: #include <sys/types.h>
34: #include <sys/file.h>
35: #include <sys/stat.h>
36: #include <sys/socket.h>
37:
38: #include <net/if.h>
39:
40: #include <netinet/in.h>
41: #define IMPMESSAGES
42: #define IMPLEADERS
43: #include <netimp/if_imp.h>
44:
45: #define min(a, b) ((a) < (b) ? (a) : (b))
46:
47: u_char buf[1024];
48: int showdata = 1;
49: int showcontents = 0;
50: int rawheader = 0;
51: int follow = 0;
52: int skip = 0;
53: int link = -1;
54: int host = -1;
55: int imp = -1;
56: int packettype = -1;
57: extern int errno;
58: int log;
59: char *logfile = "/usr/adm/implog";
60:
61: /*
62: * Socket address, internet style, with
63: * unused space taken by timestamp and packet
64: * size.
65: */
66: struct sockstamp {
67: short sin_family;
68: u_short sin_port;
69: struct in_addr sin_addr;
70: time_t sin_time;
71: int sin_cc;
72: };
73: struct sockstamp from;
74:
75: main(argc, argv)
76: char *argv[];
77: {
78: struct stat b;
79: off_t size;
80: char *cp;
81: int hostfrom, impfrom;
82:
83: argc--, argv++;
84: while (argc > 0 && argv[0][0] == '-') {
85: if (strcmp(*argv, "-D") == 0) {
86: showdata = 0;
87: argv++, argc--;
88: continue;
89: }
90: if (strcmp(*argv, "-f") == 0) {
91: follow++;
92: argv++, argc--;
93: continue;
94: }
95: if (strcmp(*argv, "-F") == 0) {
96: skip++;
97: follow++;
98: argv++, argc--;
99: continue;
100: }
101: if (strcmp(*argv, "-c") == 0) {
102: showcontents++;
103: argv++, argc--;
104: continue;
105: }
106: if (strcmp(*argv, "-r") == 0) {
107: rawheader++;
108: argv++, argc--;
109: continue;
110: }
111: if (strcmp(*argv, "-l") == 0) {
112: argc--, argv++;
113: if (argc > 0) {
114: link = atoi(*argv);
115: argc--, argv++;
116: } else
117: link = IMPLINK_IP;
118: continue;
119: }
120: if (strcmp(*argv, "-h") == 0) {
121: argc--, argv++;
122: if (argc < 1) {
123: printf("-h: missing host #\n");
124: exit(2);
125: }
126: host = atoi(*argv);
127: argv++, argc--;
128: continue;
129: }
130: if (strcmp(*argv, "-i") == 0) {
131: argc--, argv++;
132: if (argc < 1) {
133: printf("-i: missing imp #\n");
134: exit(2);
135: }
136: imp = atoi(*argv);
137: argv++, argc--;
138: continue;
139: }
140: if (strcmp(*argv, "-t") == 0) {
141: argc--, argv++;;
142: if (argc < 1) {
143: printf("-t: missing packet type\n");
144: exit(2);
145: }
146: packettype = atoi(*argv);
147: argv++, argc--;;
148: continue;
149: }
150: printf("usage: implog [ -D ] [ -c ] [ -f ] [ -F ] [ -r ] [-h #] [-i #] [ -t # ] [-l [#]] [logfile]\n");
151: exit(2);
152: }
153: if (argc > 0)
154: logfile = argv[0];
155: log = open(logfile, 0);
156: if (log < 0) {
157: perror(logfile);
158: exit(1);
159: }
160: fstat(log, &b);
161: size = b.st_size;
162: if (skip)
163: (void) lseek(log, size, L_SET);
164: again:
165: while (read(log, (char *)&from, sizeof(from)) == sizeof(from)) {
166: if (from.sin_family == 0) {
167: printf("restarted: %.24s\n", ctime(&from.sin_time));
168: continue;
169: }
170: if (host >= 0) {
171: long addr = ntohs(from.sin_addr.s_addr);
172:
173: if (IN_CLASSA(addr)) {
174: hostfrom = ((addr>>16) & 0xFF);
175: impfrom = addr & 0xFF;
176: } else if (IN_CLASSB(addr)) {
177: hostfrom = ((addr>>8) & 0xFF);
178: impfrom = addr & 0xFF;
179: } else {
180: hostfrom = ((addr>>4) & 0xF);
181: impfrom = addr & 0xF;
182: }
183: }
184: if (host >= 0 && hostfrom != host) {
185: lseek(log, from.sin_cc, 1);
186: continue;
187: }
188: if (imp >= 0 && impfrom != imp) {
189: lseek(log, from.sin_cc, 1);
190: continue;
191: }
192: process(log, &from);
193: }
194: while (follow) {
195: fflush(stdout);
196: sleep(5);
197: fstat(log, &b);
198: if (b.st_size > size) {
199: size = b.st_size;
200: goto again;
201: }
202: }
203: }
204:
205: int impdata(), impbadleader(), impdown(), impnoop();
206: int imprfnm(), impincomplete(), imphostdead(), imphostunreach();
207: int impbaddata(), impreset(), impretry(), impnotify(), imptrying();
208: int impready(), impundef();
209:
210: struct messages {
211: u_char m_type; /* type of message */
212: int (*m_func)(); /* routine to process message */
213: } mtypes[] = {
214: { IMPTYPE_DATA, impdata },
215: { IMPTYPE_BADLEADER, impbadleader },
216: { IMPTYPE_DOWN, impdown },
217: { IMPTYPE_NOOP, impnoop },
218: { IMPTYPE_RFNM, imprfnm },
219: { IMPTYPE_INCOMPLETE, impincomplete },
220: { IMPTYPE_HOSTDEAD, imphostdead },
221: { IMPTYPE_HOSTUNREACH, imphostunreach },
222: { IMPTYPE_BADDATA, impbaddata },
223: { IMPTYPE_RESET, impreset },
224: { IMPTYPE_RETRY, impretry },
225: { IMPTYPE_NOTIFY, impnotify },
226: { IMPTYPE_TRYING, imptrying },
227: { IMPTYPE_READY, impready },
228: { -1, impundef }
229: };
230:
231: /*
232: * Print a packet.
233: */
234: process(l, f)
235: int l;
236: struct sockstamp *f;
237: {
238: register struct messages *mp;
239: struct imp_leader *ip;
240: int (*fn)();
241:
242: if (read(l, (char *)buf, f->sin_cc) != f->sin_cc) {
243: perror("read");
244: return;
245: }
246: ip = (struct imp_leader *)buf;
247: ip->il_imp = ntohs(ip->il_imp);
248: if (ip->il_format != IMP_NFF)
249: fn = impundef;
250: else {
251: for (mp = mtypes; mp->m_type != (u_char)-1; mp++)
252: if (mp->m_type == ip->il_mtype)
253: break;
254: fn = mp->m_func;
255: }
256: if (ip->il_mtype == IMPTYPE_DATA) {
257: if (link >= 0 && ip->il_link != link)
258: return;
259: if (!showdata)
260: return;
261: }
262: if (packettype >= 0 && ip->il_mtype != packettype)
263: return;
264: printf("%.24s: ", ctime(&f->sin_time));
265: if (f->sin_cc < sizeof(struct control_leader))
266: printf("(truncated header, %d bytes): ", f->sin_cc);
267: (*fn)(ip, f->sin_cc);
268: if (rawheader && fn != impundef) {
269: putchar('\t');
270: impundef(ip, f->sin_cc);
271: }
272: }
273:
274: impdata(ip, cc)
275: register struct imp_leader *ip;
276: {
277: printf("<DATA, source=%d/%d, link=", ip->il_host, (u_short)ip->il_imp);
278: if (ip->il_link == IMPLINK_IP)
279: printf("ip,");
280: else
281: printf("%d,", ip->il_link);
282: printf(" len=%d bytes>\n", ntohs((u_short)ip->il_length) >> 3);
283: if (showcontents) {
284: register u_char *cp = ((u_char *)ip) + sizeof(*ip);
285: register int i;
286:
287: i = (ntohs(ip->il_length) >> 3) - sizeof(struct imp_leader);
288: cc = min(i, cc);
289: printf("data: (%d bytes)", cc);
290: for (i = 0; i < cc; i++, cp++) {
291: if (i % 25 == 0)
292: printf("\n");
293: printf("%02x ", *cp);
294: }
295: putchar('\n');
296: }
297: }
298:
299: char *badleader[] = {
300: "error flip-flop set",
301: "message < 80 bits",
302: "illegal type field",
303: "opposite leader type"
304: };
305:
306: impbadleader(ip)
307: register struct imp_leader *ip;
308: {
309: printf("bad leader: ");
310: if (ip->il_subtype > IMPLEADER_OPPOSITE)
311: printf("%x\n", ip->il_subtype);
312: else
313: printf("%s\n", badleader[ip->il_subtype]);
314: }
315:
316: impdown(ip)
317: register struct imp_leader *ip;
318: {
319: int tdown, tbackup;
320:
321: printf("imp going down %s", impmessage[ip->il_link & IMP_DMASK]);
322: tdown = ((ip->il_link >> IMPDOWN_WHENSHIFT) & IMPDOWN_WHENMASK) *
323: IMPDOWN_WHENUNIT;
324: if ((ip->il_link & IMP_DMASK) != IMPDOWN_GOING)
325: printf(" in %d minutes", tdown);
326: tbackup = ip->il_subtype * IMPDOWN_WHENUNIT;
327: printf(": back up ");
328: if (tbackup)
329: printf("%d minutes\n", tbackup);
330: else
331: printf("immediately\n");
332: }
333:
334: impnoop(ip)
335: register struct imp_leader *ip;
336: {
337: printf("noop: host %d, imp %d\n", ip->il_host,
338: (u_short)ip->il_imp);
339: }
340:
341: imprfnm(ip)
342: register struct imp_leader *ip;
343: {
344: printf("rfnm: htype=%x, source=%d/%d, link=",
345: ip->il_htype, ip->il_host, ip->il_imp);
346: if (ip->il_link == IMPLINK_IP)
347: printf("ip,");
348: else
349: printf("%d,", ip->il_link);
350: printf(" subtype=%x\n", ip->il_subtype);
351: }
352:
353: char *hostdead[] = {
354: "#0",
355: "ready-line negated",
356: "tardy receiving messages",
357: "ncc doesn't know host",
358: "imp software won't allow messages",
359: "host down for scheduled pm",
360: "host down for hardware work",
361: "host down for software work",
362: "host down for emergency restart",
363: "host down because of power outage",
364: "host stopped at a breakpoint",
365: "host down due to hardware failure",
366: "host not scheduled to be up",
367: "#13",
368: "#14",
369: "host in the process of coming up"
370: };
371:
372: imphostdead(ip)
373: register struct imp_leader *ip;
374: {
375: printf("host %d/%d dead: ", ip->il_host, ip->il_imp);
376: if (ip->il_link & IMP_DMASK)
377: printf("down %s, ", impmessage[ip->il_link & IMP_DMASK]);
378: if (ip->il_subtype <= IMPHOST_COMINGUP)
379: printf("%s\n", hostdead[ip->il_subtype]);
380: else
381: printf("subtype=%x\n", ip->il_subtype);
382: }
383:
384: char *hostunreach[] = {
385: "destination imp can't be reached",
386: "destination host isn't up",
387: "host doesn't support long leader",
388: "communication is prohibited"
389: };
390:
391: imphostunreach(ip)
392: register struct imp_leader *ip;
393: {
394: printf("host %d/%d unreachable: ", ip->il_host, ip->il_imp);
395: if (ip->il_subtype <= IMPREACH_PROHIBITED)
396: printf("%s\n", hostunreach[ip->il_subtype]);
397: else
398: printf("subtype=%x\n", ip->il_subtype);
399: }
400:
401: impbaddata(ip)
402: register struct imp_leader *ip;
403: {
404: printf("error in data: htype=%x, source=%d/%d, link=",
405: ip->il_htype, ip->il_host, ip->il_imp);
406: if (ip->il_link == IMPLINK_IP)
407: printf("ip, ");
408: else
409: printf("%d, ", ip->il_link);
410: printf("subtype=%x\n", ip->il_subtype);
411: }
412:
413: char *incomplete[] = {
414: "host didn't take data fast enough",
415: "message was too long",
416: "message transmission time > 15 seconds",
417: "imp/circuit failure",
418: "no resources within 15 seconds",
419: "source imp i/o failure during receipt"
420: };
421:
422: impincomplete(ip)
423: register struct imp_leader *ip;
424: {
425: printf("incomplete: htype=%x, source=%d/%d, link=",
426: ip->il_htype, ip->il_host, ip->il_imp);
427: if (ip->il_link == IMPLINK_IP)
428: printf("ip,");
429: else
430: printf("%d,", ip->il_link);
431: if (ip->il_subtype <= IMPCOMPLETE_IMPIO)
432: printf(" %s\n", incomplete[ip->il_subtype]);
433: else
434: printf(" subtype=%x\n", ip->il_subtype);
435: }
436:
437: impreset(ip)
438: register struct imp_leader *ip;
439: {
440: printf("reset complete\n");
441: }
442:
443: char *retry[] = {
444: "imp buffer wasn't available",
445: "connection block unavailable"
446: };
447:
448: impretry(ip)
449: register struct imp_leader *ip;
450: {
451: printf("refused, try again: ");
452: if (ip->il_subtype <= IMPRETRY_BLOCK)
453: printf("%s\n", retry[ip->il_subtype]);
454: else
455: printf("subtype=%x\n", ip->il_subtype);
456: }
457:
458: char *notify[] = {
459: "#0",
460: "#1",
461: "connection not available",
462: "reassembly space not available at destination",
463: "message number not available",
464: "transaction block for message not available"
465: };
466:
467: impnotify(ip)
468: register struct imp_leader *ip;
469: {
470: printf("refused, will notify: ");
471: if (ip->il_subtype <= 5)
472: printf("%s\n", notify[ip->il_subtype]);
473: else
474: printf("subtype=%x\n", ip->il_subtype);
475: }
476:
477: imptrying(ip)
478: register struct imp_leader *ip;
479: {
480: printf("refused, still trying\n");
481: }
482:
483: impready(ip)
484: register struct imp_leader *ip;
485: {
486: printf("ready\n");
487: }
488:
489: impundef(ip, len)
490: register struct imp_leader *ip;
491: {
492: printf("<fmt=%x, net=%x, flags=%x, mtype=", ip->il_format,
493: ip->il_network, ip->il_flags);
494: printf("%x, htype=%x,\n\t host=%d(x%x), imp=%d(x%x), link=",
495: ip->il_mtype, ip->il_htype, ip->il_host, ip->il_host,
496: ip->il_imp, ip->il_imp);
497: if (ip->il_link == IMPLINK_IP)
498: printf("ip,");
499: else
500: printf("%d (x%x),", ip->il_link, ip->il_link);
501: printf(" subtype=%x", ip->il_subtype);
502: if (len >= sizeof(struct imp_leader) && ip->il_length)
503: printf(" len=%d bytes", ntohs((u_short)ip->il_length) >> 3);
504: printf(">\n");
505: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.