![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uurate.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / contrib|
Return to uurate.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 / contrib |
1.1 root 1: /*
2: * @(#)uurate.c 1.2 - Thu Sep 3 18:32:46 1992
3: *
4: * This program digests log and stats files in the "Taylor" format
5: * and outputs various statistical data to standard out.
6: *
7: * Author:
8: * Bob Denny ([email protected])
9: * Fri Feb 7 13:38:36 1992
10: *
11: * Original author:
12: * Mark Pizzolato [email protected]
13: *
14: * Edits:
15: * Bob Denny - Fri Feb 7 15:04:54 1992
16: * Heavy rework for Taylor UUCP. This was the (very old) uurate from
17: * DECUS UUCP, which had a single logfile for activity and stats.
18: * Personally, I would have done things differently, with tables
19: * and case statements, but in the interest of time, I preserved
20: * Mark Pizzolato's techniques and style.
21: *
22: * Bob Denny - Sun Aug 30 14:18:50 1992
23: * Changes to report format suggested by Francois Pinard and others.
24: * Add summary report, format from uutraf.pl (perl script), again
25: * thanks to Francois. Integrate and checkout with 1.03 of Taylor UUCP.
26: */
27:
28: char version[] = "@(#) Taylor UUCP Log File Summary Filter, Version 1.2";
29:
30: #include <ctype.h> /* Character Classification */
31: #include <string.h>
32: #include <math.h>
33:
34: #include "uucp.h"
35:
36:
37: #define _DEBUG_ 0
38:
39: /*
40: * Direction of Calling and Data Transmission
41: */
42: #define IN 0 /* Inbound */
43: #define OUT 1 /* Outbound */
44:
45: /*
46: * Data structures used to collect information
47: */
48: struct File_Stats
49: {
50: int files; /* Files Transferred */
51: unsigned long bytes; /* Data Size Transferred*/
52: double time; /* Transmission Time */
53: };
54:
55: struct Phone_Call
56: {
57: int calls; /* Call Count */
58: int succs; /* Successful calls */
59: double connect_time; /* Connect Time Spent */
60: struct File_Stats flow[2]; /* Rcvd & Sent Data */
61: };
62:
63: struct Execution_Command
64: {
65: struct Execution_Command *next;
66: char Commandname[64];
67: int count;
68: };
69:
70: struct Host_entry
71: {
72: struct Host_entry *next;
73: char Hostname[32];
74: struct Execution_Command *cmds; /* Local Activities */
75: struct Phone_Call call[2]; /* In & Out Activities */
76: };
77:
78: /*
79: * Stuff for getopt()
80: */
81: extern int optind; /* GETOPT : Option Index */
82: extern char *optarg; /* GETOPT : Option Value */
83: extern void *calloc();
84:
85: static void fmtime();
86: static void fmbytes();
87:
88: /*
89: * Default files to read. Taken from Taylor compile-time configuration.
90: * Must look like an argvec, hence the dummy argv[0].
91: */
92: static char *(def_logs[3]) = { "", LOGFILE, STATFILE };
93:
94: /*
95: * Misc. strings for reports
96: */
97: static char *(file_hdr[2]) = { "\nReceived file statistics:\n",
98: "\nSent file statistics\n" };
99:
100: /*
101: * BEGIN EXECUTION
102: */
103: main(argc, argv)
104: int argc;
105: char *argv[];
106: {
107: char c;
108: char *p, *s;
109: struct Host_entry *hosts = NULL;
110: struct Host_entry *cur = NULL;
111: struct Host_entry *e;
112: struct Execution_Command *cmd;
113: struct Execution_Command *ec;
114: char Hostname[64];
115: FILE *Log = NULL;
116: char logline[1024];
117: char *logmsg;
118: int sent;
119: int called;
120: int show_files = 0; /* I prefer boolean, but... */
121: int show_calls = 0;
122: int show_commands = 0;
123: int show_efficiency = 0;
124: int show_summary = 0;
125: int have_files = 0;
126: int have_calls = 0;
127: int have_commands = 0;
128: int use_stdin = 0;
129: Hostname[0] = '\0';
130:
131: /*
132: * I wish the compiler had the #error directive!
133: */
134: #if !HAVE_TAYLOR_LOGGING
135: fprintf(stderr, "uurate cannot be used with your configuration of\n");
136: fprintf(stderr, "Taylor UUCP. To use uurate you must be using the\n");
137: fprintf(stderr, "TAYLOR_LOGGING configuration.\n");
138: exit(1);
139: #endif
140:
141: /*
142: * Process the command line arguments
143: */
144: while((c = getopt(argc, argv, "h:cfexai")) != EOF)
145: {
146: switch(c)
147: {
148: case 'h':
149: strcpy(Hostname, optarg);
150: break;
151: case 'c':
152: show_calls = 1;
153: break;
154: case 'f':
155: show_files = 1;
156: break;
157: case 'x':
158: show_commands = 1;
159: break;
160: case 'e':
161: show_efficiency = 1;
162: break;
163: case 'a':
164: show_calls = show_files = show_commands = show_efficiency = 1;
165: break;
166: case 'i':
167: use_stdin = 1;
168: break;
169: default :
170: goto usage;
171: }
172: }
173:
174: /*
175: * If no report switches given, show summary report.
176: */
177: if (show_calls == 0 && show_files == 0
178: && show_efficiency == 0 && show_commands == 0)
179: show_summary = 1;
180:
181: /*
182: * Adjust argv and argc to account for the args processed above.
183: */
184: argc -= (optind - 1);
185: argv += (optind - 1);
186:
187: /*
188: * If further args present, Assume rest are logfiles for us to process,
189: * otherwise, take input from Log and Stat files provided in the
190: * compilation environment of Taylor UUCP. If -i was given, Log already
191: * points to stdin and no file args are accepted.
192: */
193: if(argc == 1) /* No file arguments */
194: {
195: if (use_stdin) /* If -i, read from stdin */
196: {
197: argc = 2;
198: Log = stdin;
199: }
200: else /* Read from current logs */
201: {
202: argc = 3; /* Bash argvec to default log/stat files */
203: argv = &def_logs[0];
204: }
205: }
206: else if (use_stdin) /* File args with -i is an error */
207: {
208: fprintf(stderr, "uurate (error): file args given with '-i'\n");
209: goto usage;
210: }
211:
212: #if _DEBUG_
213: printf("\n");
214: #endif
215:
216: /*
217: * MAIN LOGFILE PROCESSING LOOP
218: */
219: while (argc > 1)
220: {
221:
222: if (!use_stdin && (Log = fopen(argv[1], "r")) == NULL)
223: {
224: perror(argv[1]);
225: return;
226: }
227:
228: #if _DEBUG_
229: printf("Reading %s...\n", (use_stdin ? "stdin" : argv[1]));
230: #endif
231:
232: /*
233: * Read each line of the logfile and collect information
234: */
235: while (fgets(logline, sizeof(logline), Log))
236: {
237: /*
238: * The host name of the other end of the connection is
239: * always the second field of the log line, whether we
240: * are reading a Log file or a Stats file. Set 'p' to
241: * point to the second field, null-terminated. Skip
242: * the line if something is funny.
243: */
244: if (NULL == (p = strchr(logline, ' ')))
245: continue;
246: ++p;
247: if (NULL != (s = strchr(p, ' ')))
248: *s = '\0';
249: for (s = p; *s; ++s)
250: if (isupper(*s))
251: *s = tolower(*s);
252: /*
253: * Skip this line if we got -h <host> and
254: * this line does not contain that host name.
255: */
256: if (Hostname[0] != '\0')
257: if (0 != strcmp(p, Hostname))
258: continue;
259: /*
260: * We are within a call block now. If this line is a file
261: * transfer record, determine the direction. If not then
262: * skip the line if it is not interesting.
263: */
264: if ((s = strchr(++s, ')')) == NULL)
265: continue;
266: logmsg = s + 2; /* Message is 2 characters after ')' */
267: if (0 == strncmp(logmsg, "sent", 4))
268: sent = OUT;
269: else
270: if (0 == strncmp(logmsg, "received", 8))
271: sent = IN;
272: else
273: if ((0 != strncmp(logmsg, "Call complete", 13)) &&
274: (0 != strncmp(logmsg, "Calling system", 14)) &&
275: (0 != strncmp(logmsg, "Incoming call", 13)) &&
276: (0 != strncmp(logmsg, "Executing", 9)))
277: continue;
278: /*
279: * Find the Host_entry for this host, or create a new
280: * one and link it on to the list.
281: */
282: if ((cur == NULL) || (0 != strcmp(p, cur->Hostname)))
283: {
284: for (cur = hosts; cur != NULL ; cur = cur->next)
285: if (0 == strcmp(cur->Hostname, p))
286: break;
287: if (cur == NULL)
288: {
289: cur = (struct Host_entry *)calloc(1, sizeof(*hosts));
290: strcpy(cur->Hostname, p);
291: if (hosts == NULL)
292: hosts = cur;
293: else
294: {
295: for (e = hosts; e->next != NULL; e = e->next);
296: e->next = cur;
297: }
298: }
299: }
300: /*
301: * OK, if this is a uuxqt record, find the Execution_Command
302: * structure for the command being executed, or create a new
303: * one. Then count an execution of this command.
304: */
305: if (0 == strncmp(logmsg, "Executing", 9))
306: {
307: if (NULL == (p = strchr(logmsg, '(')))
308: continue;
309: if ((s = strpbrk(++p, " )")) == NULL)
310: continue;
311: *s = '\0';
312: for (cmd = cur->cmds; cmd != NULL; cmd = cmd->next)
313: if (0 == strcmp(cmd->Commandname, p))
314: break;
315: if (cmd == NULL)
316: {
317: cmd = (struct Execution_Command *)calloc(1, sizeof(*cmd));
318: strcpy(cmd->Commandname, p);
319: if (cur->cmds == NULL)
320: cur->cmds = cmd;
321: else
322: {
323: for (ec = cur->cmds; ec->next != NULL; ec = ec->next);
324: ec->next = cmd;
325: }
326: }
327: ++cmd->count;
328: have_commands = 1;
329: continue;
330: }
331: /*
332: * Count start of outgoing call.
333: */
334: if (0 == strncmp(logmsg, "Calling system", 14))
335: {
336: called = OUT;
337: cur->call[called].calls += 1;
338: have_calls = 1;
339: continue;
340: }
341: /*
342: * Count start of incoming call.
343: */
344: if (0 == strncmp(logmsg, "Incoming call", 13))
345: {
346: called = IN;
347: cur->call[called].calls += 1;
348: have_calls = 1;
349: continue;
350: }
351: /*
352: * Handle end of call. Pick up the connect time.
353: */
354: if (0 == strncmp(logmsg, "Call complete", 13))
355: {
356: cur->call[called].succs += 1;
357: if (NULL == (s = strchr(logmsg, '(')))
358: continue;
359: cur->call[called].connect_time += atof(s+1);
360: continue;
361: }
362: /*
363: * If we reached here, this must have been a file transfer
364: * record. Count it in the field corresponding to the
365: * direction of the transfer. Count bytes transferred and
366: * the time to transfer as well.
367: */
368: have_files = 1;
369: cur->call[called].flow[sent].files += 1;
370: if (NULL == (s = strchr(logmsg, ' ')))
371: continue;
372: cur->call[called].flow[sent].bytes += atol(++s);
373: if (NULL == (s = strchr(s, ' ')))
374: continue;
375: if (NULL == (s = strpbrk(s, "0123456789")))
376: continue;
377: cur->call[called].flow[sent].time += atof(s);
378: }
379: argc -= 1;
380: argv += 1;
381: if(Log != stdin)
382: fclose(Log);
383: }
384:
385: /*
386: * ***********
387: * * REPORTS *
388: * ***********
389: */
390:
391: /*
392: * Truncate the Hostnames to 8 characters at most.
393: */
394: for (cur = hosts; cur != NULL; cur = cur->next)
395: cur->Hostname[8] = '\0';
396:
397: #if _DEBUG_
398: printf("\n");
399: #endif
400:
401: /*
402: * Summary report
403: *
404: * I know, this code could be tightened (rbd)...
405: */
406: if(show_summary)
407: {
408: char t1[32], t2[32], t3[32], t4[32], t5[32];
409: long ib, ob, b, rf, sf;
410: long t_ib=0, t_ob=0, t_b=0, t_rf=0, t_sf=0;
411: double it, ot, ir, or;
412: double t_it=0.0, t_ot=0.0;
413: int nhosts = 0;
414:
415: printf("\n\
416: Remote ------- Bytes -------- --- Time ---- -- Avg CPS -- -- Files --\n");
417: printf("\
418: Host Rcvd Sent Total Rcvd Sent Rcvd Sent Rcvd Sent\n");
419: printf("\
420: -------- ------- ------- ------- ------ ------ ------ ------ ----- -----\n");
421: for (cur = hosts; cur != NULL; cur = cur->next)
422: {
423: ib = (cur->call[IN].flow[IN].bytes +
424: cur->call[OUT].flow[IN].bytes);
425: fmbytes(ib, t1);
426: t_ib += ib;
427:
428: ob = (cur->call[IN].flow[OUT].bytes +
429: cur->call[OUT].flow[OUT].bytes);
430: fmbytes(ob, t2);
431: t_ob += ob;
432:
433: b = ib + ob;
434: fmbytes(b, t3);
435: t_b += b;
436:
437: it = cur->call[IN].flow[IN].time +
438: cur->call[OUT].flow[IN].time;
439: fmtime(it, t4);
440: t_it += it;
441:
442: ot = cur->call[IN].flow[OUT].time +
443: cur->call[OUT].flow[OUT].time;
444: fmtime(ot, t5);
445: t_ot += ot;
446:
447: rf = cur->call[IN].flow[IN].files +
448: cur->call[OUT].flow[IN].files;
449: t_rf += rf;
450:
451: sf = cur->call[IN].flow[OUT].files +
452: cur->call[OUT].flow[OUT].files;
453: t_sf += sf;
454:
455: ir = (it == 0.0) ? 0.0 : (ib / it);
456: or = (ot == 0.0) ? 0.0 : (ob / ot);
457:
458: printf("%-8s %7s %7s %7s %6s %6s %6.1f %6.1f %5d %5d\n",
459: cur->Hostname,
460: t1, t2, t3, t4, t5,
461: ir, or, rf, sf);
462: }
463:
464: if(nhosts > 1)
465: {
466: fmbytes(t_ib, t1);
467: fmbytes(t_ob, t2);
468: fmbytes(t_b, t3);
469: fmtime(t_it, t4);
470: fmtime(t_ot, t5);
471: ir = (t_it == 0.0) ? 0.0 : (t_ib / t_it);
472: or = (t_ot == 0.0) ? 0.0 : (t_ob / t_ot);
473:
474: printf("\
475: -------- ------- ------- ------- ------ ------ ------ ------ ----- -----\n");
476: printf("\
477: Totals %7s %7s %7s %6s %6s %6.1f %6.1f %5d %5d\n",
478: t1, t2, t3, t4, t5,
479: ir, or, t_rf, t_sf);
480: }
481: }
482:
483:
484: /*
485: * Call statistics report
486: */
487: if(show_calls && have_calls)
488: {
489: char t1[32], t2[32];
490:
491: printf("\nCall statistics:\n");
492: printf("\
493: sysname callto failto totime callfm failfm fmtime\n");
494: printf("\
495: -------- ------ ------ -------- ------ ------ --------\n");
496: for (cur = hosts; cur != NULL; cur = cur->next)
497: {
498: fmtime(cur->call[OUT].connect_time, t1);
499: fmtime(cur->call[IN].connect_time, t2),
500: printf(" %-8s %6d %6d %8s %6d %6d %8s\n",
501: cur->Hostname,
502: cur->call[OUT].calls,
503: cur->call[OUT].calls - cur->call[OUT].succs,
504: t1,
505: cur->call[IN].calls,
506: cur->call[IN].calls - cur->call[IN].succs,
507: t2);
508: }
509: }
510:
511: /*
512: * File statistics report
513: */
514: if(show_files && have_files)
515: {
516: char t1[32], t2[32];
517:
518: for (sent = IN; sent <= OUT; ++sent)
519: {
520: printf(file_hdr[sent]);
521: printf(" sysname files bytes xfr time byte/s\n");
522: printf(" -------- ------ -------- -------- ------\n");
523: for (cur = hosts; cur != NULL; cur = cur->next)
524: {
525: double rate;
526: double time;
527:
528: time = cur->call[IN].flow[sent].time +
529: cur->call[OUT].flow[sent].time;
530: if (time == 0.0)
531: continue;
532: rate = (cur->call[IN].flow[sent].bytes +
533: cur->call[OUT].flow[sent].bytes) / time;
534: fmbytes((cur->call[IN].flow[sent].bytes +
535: cur->call[OUT].flow[sent].bytes), t1);
536: fmtime((cur->call[IN].flow[sent].time +
537: cur->call[OUT].flow[sent].time), t2);
538: printf(" %-8s %6d %8s %8s %6.1f\n",
539: cur->Hostname,
540: cur->call[IN].flow[sent].files +
541: cur->call[OUT].flow[sent].files,
542: t1, t2, rate);
543: }
544: }
545: }
546:
547: /*
548: * Efficiency report
549: */
550: if (show_efficiency && have_files)
551: {
552: char t1[32], t2[32], t3[32];
553: double total, flow;
554:
555: printf("\nEfficiency:\n");
556: printf(" sysname conntime flowtime ovhdtime eff. %%\n");
557: printf(" -------- -------- -------- -------- ------\n");
558: for (cur = hosts; cur != NULL; cur = cur->next)
559: {
560: total = cur->call[IN].connect_time + cur->call[OUT].connect_time;
561: flow = cur->call[IN].flow[IN].time + cur->call[IN].flow[OUT].time +
562: cur->call[OUT].flow[IN].time + cur->call[OUT].flow[OUT].time;
563: fmtime(total, t1);
564: fmtime(flow, t2);
565: fmtime((total-flow), t3);
566: printf(" %-8s %8s %8s %8s %5.1f%%\n",
567: cur->Hostname, t1, t2, t3, ((flow / total) * 100.0));
568: }
569: }
570:
571: /*
572: * Command execution report
573: */
574: if (show_commands & have_commands)
575: {
576: printf("\nCommand executions:\n");
577: printf(" sysname rmail rnews other\n");
578: printf(" -------- ------ ------ ------\n");
579: for (cur = hosts; cur != NULL; cur = cur->next)
580: {
581: int rmail, rnews, other;
582:
583: if (cur->cmds == NULL)
584: continue;
585: rmail = rnews = other = 0;
586: for (cmd = cur->cmds; cmd != NULL; cmd = cmd->next)
587: {
588: if (strcmp(cmd->Commandname, "rmail") == 0)
589: rmail += cmd->count;
590: else if (strcmp(cmd->Commandname, "rnews") == 0)
591: rnews += cmd->count;
592: else
593: other += cmd->count;
594: }
595: printf(" %-8s %6d %6d %6d\n", cur->Hostname,
596: rmail, rnews, other);
597: }
598: }
599: return;
600:
601: usage:
602: fprintf(stderr,
603: "Usage uurate [-cfexai] [-h hostname] [logfile ... logfile]\n");
604: fprintf(stderr,"where:\t-c\tReport call statistics\n");
605: fprintf(stderr, "\t-f\tReport file transfer statistics\n");
606: fprintf(stderr, "\t-e\tReport efficiency statistics\n");
607: fprintf(stderr, "\t-x\tReport command execution statistics\n");
608: fprintf(stderr, "\t-a\tAll of the above reports\n");
609: fprintf(stderr, "\t-h host\tReport activities involving ONLY host\n");
610: fprintf(stderr, "\t-i\tRead log info from standard input\n");
611: fprintf(stderr,
612: "If no report options given, a compact summary report is given.\n");
613: fprintf(stderr,
614: "If neither -i nor logfiles given, defaults to reading from\n");
615: fprintf(stderr, "%s and %s\n\n", LOGFILE, STATFILE);
616: }
617:
618: /*
619: * fmtime() - Format time in hours & minutes;
620: */
621: static void fmtime(dsec, buf)
622: double dsec;
623: char *buf;
624: {
625: long hrs, min, lsec;
626:
627: lsec = dsec;
628: hrs = lsec / 3600L;
629: min = (lsec - (hrs * 3600L)) / 60L;
630:
631: sprintf(buf, "%02ld:%02ld", hrs, min);
632: }
633:
634: /*
635: * fmbytes - Format size in bytes
636: */
637: static void fmbytes(n, buf)
638: unsigned long n;
639: char *buf;
640: {
641: char t;
642: double s = n;
643:
644: if(s >= 10239897.6) /* More than 9999.9K ? */
645: {
646: s = (double)n / 1048576.0; /* Yes, display in Megabytes */
647: t = 'M';
648: }
649: else
650: {
651: s = (double)n / 1024.0; /* Display in Kilobytes */
652: t = 'K';
653: }
654:
655: sprintf(buf, "%.1f%c", s, t);
656: }
657:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.