1858 lines
61 KiB
C
1858 lines
61 KiB
C
/*
|
|
* @(#)uurate.c 1.2 - Thu Sep 3 18:32:46 1992
|
|
*
|
|
* This program digests log and stats files in the "Taylor" format
|
|
* and outputs various statistical data to standard out.
|
|
*
|
|
* Author:
|
|
* Bob Denny (denny@alisa.com)
|
|
* Fri Feb 7 13:38:36 1992
|
|
*
|
|
* Original author:
|
|
* Mark Pizzolato mark@infopiz.UUCP
|
|
*
|
|
* Edits:
|
|
* Bob Denny - Fri Feb 7 15:04:54 1992
|
|
* Heavy rework for Taylor UUCP. This was the (very old) uurate from
|
|
* DECUS UUCP, which had a single logfile for activity and stats.
|
|
* Personally, I would have done things differently, with tables
|
|
* and case statements, but in the interest of time, I preserved
|
|
* Mark Pizzolato's techniques and style.
|
|
*
|
|
* Bob Denny - Sun Aug 30 14:18:50 1992
|
|
* Changes to report format suggested by Francois Pinard and others.
|
|
* Add summary report, format from uutraf.pl (perl script), again
|
|
* thanks to Francois. Integrate and checkout with 1.03 of Taylor UUCP.
|
|
*
|
|
* Stephan Niemz <stephan@sunlab.ka.sub.org> - Fri Apr 9 1993
|
|
* - Print totals in summary report,
|
|
* - show all commands in execution report,
|
|
* - count incoming calls correctly,
|
|
* - suppress empty tables,
|
|
* - don't divide by zero in efficiency report,
|
|
* - limit the efficiency to 100% (could be more with the i-protocol),
|
|
* - suppress some zeros to improve readability,
|
|
* - check for failure of calloc,
|
|
* - -h option changed to -s for consistency with all other uucp commands
|
|
* (but -h was left in for comptibility).
|
|
*
|
|
* Scott Boyd <scott@futures.com> - Thu Aug 26 13:21:34 PDT 1993
|
|
* - Changed hosts linked-list insertion routine so that hosts
|
|
* are always listed in alphabetical order on reports.
|
|
*
|
|
* Klaus Dahlenburg <kdburg@incoahe.hanse.de> - Fri Jun 18 1993 (1.2.2)
|
|
* - redesigned the printed layout (sticked to those 80 column tubes).
|
|
* - 'Retry time not ...' and ' ERROR: All matching ports ...' will now be
|
|
* counted as calls and will raise the failed-call counter.
|
|
* - times now shown as hh:mm:ss; the fields may hold up to 999 hrs
|
|
* (a month equals 744 hrs at max). Printing will be as follows:
|
|
*
|
|
* hrs > 0 hh:mm:ss
|
|
* min > 0 mm:ss
|
|
* sec > 0 ss
|
|
* leading zeroes are suppressed.
|
|
*
|
|
* - the bytes xfered will be given in thousands only (we're counting
|
|
* so 1K is 1000 bytes!). Sums up to 9,999,999.9 thousand can be shown.
|
|
* - dropped the fractions of a byte in columns: bytes/second (avg cps).
|
|
* - File statistic changed to display in/out in one row instead of 2
|
|
* separate reports.
|
|
* - eliminated the goto in command report and tightened the code; also
|
|
* the 'goto usage' has been replaced by a call to void usage() with no
|
|
* return (exit 1).
|
|
* - a totaling is done for all reports now; the total values are held
|
|
* within the structure; after finishing read there will be an alloc
|
|
* for a site named 'Total' so that the totals line will be printed
|
|
* more or less automatically.
|
|
* - option -t implemented: that is every possible report will be given.
|
|
* - the start and end date/time of the input files are printed; can be
|
|
* dropped by the -q option at run time.
|
|
* - it is now possible to use Log/Stats files from V2_LOGGING configs.
|
|
* They must however not be mixed together (with each other).
|
|
* - the Log/Stats files are taken from config which is passed via
|
|
* Makefile at compile time. Variable to set is: newconfigdir. If the
|
|
* default config can't be read the default values are used
|
|
* (the config is optional!).
|
|
* Note: keyword/filename must be on the same line (no continuation).
|
|
* - -I option implemented to run with a different config file. In case
|
|
* the file can't be opened the run is aborted!
|
|
* - -q option implemented to run without environment report (default is
|
|
* FALSE: print the report).
|
|
* - -p option added to print protocol statistics: one for the packets
|
|
* and one for the errors encountered
|
|
* - reapplied patch by Scott Boyd <scott@futures.com> that I did not
|
|
* get knowledge of
|
|
*/
|
|
/* $Log: uurate.c,v $
|
|
/* Revision 1.3 1995/08/24 05:19:21 jtc
|
|
/* Upgraded to Taylor UUCP 1.06.1 (Thanks to John Kohl).
|
|
/*
|
|
* Revision 1.15 1994/04/07 21:47:11 kdburg
|
|
* printed 'no data avail' while there was data; layout chnaged
|
|
* (cosmetic only)
|
|
*
|
|
* Revision 1.14 1994/04/07 21:16:32 kdburg
|
|
* the layout of the protocol-used line within the LOGFILE changed
|
|
* from 1.04 to 1.05; both formats may be used together; output
|
|
* changed for packet report (columns adjusted)
|
|
*
|
|
* Revision 1.13 1994/04/04 10:04:35 kdburg
|
|
* cosmetic change to the packet-report (separator lines)
|
|
*
|
|
* Revision 1.12 1994/03/30 19:52:04 kdburg
|
|
* incorporated patch by Scott Boyd which was missing from this version
|
|
* of uurate.c. Left the comment in cronological order.
|
|
*
|
|
* Revision 1.11 1994/03/28 18:53:22 kdburg
|
|
* config not checked properly for 'logfile/statsfile' overwrites, bail-out
|
|
* possible; wrong file name written to log for statsfile when found
|
|
*
|
|
* Revision 1.10 1993/09/28 16:46:51 kdburg
|
|
* transmission failures denoted by: failed after ... in stats file
|
|
* have not been counted at all.
|
|
*
|
|
* Revision 1.9 1993/08/17 23:38:36 kdburg
|
|
* sometimes a line(site) was missing from the protocol stats due
|
|
* to a missing +; added option -d and -v reassing option -h to print
|
|
* the help; a zero was returned instead of a null-pointer by
|
|
* prot_sum
|
|
*
|
|
* Revision 1.8 1993/07/03 06:58:55 kdburg
|
|
* empty input not handled properly; assigned some buffer to input; msg
|
|
* not displayed when no protocol data was available
|
|
*
|
|
* Revision 1.7 1993/06/27 10:31:53 kdburg
|
|
* rindex was replaced by strchr must be strrchr
|
|
*
|
|
* Revision 1.6 1993/06/26 06:59:18 kdburg
|
|
* switch hdr_done not reset at beginning of protocol report
|
|
*
|
|
* Revision 1.5 1993/06/25 22:22:30 kdburg
|
|
* changed rindex to strchr; if there is no NEWCONFIG defined take
|
|
* appropriate action
|
|
*
|
|
* Revision 1.4 1993/06/25 20:04:07 kdburg
|
|
* added comment about -p option; inserted proto for rindex
|
|
*
|
|
* Revision 1.3 1993/06/25 19:31:14 kdburg
|
|
* major rework done; added protocol reports (normal/errors)
|
|
*
|
|
* Revision 1.2 1993/06/21 19:53:54 kdburg
|
|
* init
|
|
* */
|
|
|
|
char version[] = "@(#) Taylor UUCP Log File Summary Filter, Version 1.2.2";
|
|
static char rcsid[] = "$Id: uurate.c,v 1.3 1995/08/24 05:19:21 jtc Exp $";
|
|
#include <ctype.h> /* Character Classification */
|
|
#include <math.h>
|
|
#include "uucp.h"
|
|
/* uucp.h includes string.h or strings.h, no include here. */
|
|
|
|
#if HAVE_SYS_PARAM_H
|
|
#include <sys/param.h>
|
|
#endif
|
|
|
|
#define _DEBUG_ 0
|
|
|
|
/*
|
|
* Direction of Calling and Data Transmission
|
|
*/
|
|
|
|
#define IN 0 /* Inbound */
|
|
#define OUT 1 /* Outbound */
|
|
|
|
/*
|
|
* define some limits
|
|
*/
|
|
#define MAXCOLS 8 /* report has this # of columns incl. 'name' */
|
|
#define MAXREP 6 /* number of reports available */
|
|
#define MAXFNAME 64 /* max input file name length incl. path*/
|
|
#define MAXDNAME 8 /* max display (Hostname) name length */
|
|
|
|
/*
|
|
* Data structures used to collect information
|
|
*/
|
|
struct File_Stats
|
|
{
|
|
int files; /* Files Transferred */
|
|
unsigned long bytes; /* Data Size Transferred*/
|
|
double time; /* Transmission Time */
|
|
};
|
|
|
|
struct Phone_Call
|
|
{
|
|
int calls; /* Call Count */
|
|
int succs; /* Successful calls */
|
|
double connect_time; /* Connect Time Spent */
|
|
struct File_Stats flow[2]; /* Rcvd & Sent Data */
|
|
};
|
|
|
|
struct Execution_Command
|
|
{
|
|
struct Execution_Command *next;
|
|
char Commandname[64];
|
|
int count;
|
|
};
|
|
|
|
struct Protocol_Summary
|
|
{
|
|
struct Protocol_Summary *next;
|
|
char type[3];
|
|
long int pr_cnt;
|
|
long int pr_psent;
|
|
long int pr_present;
|
|
long int pr_preceived;
|
|
long int pr_eheader;
|
|
long int pr_echksum;
|
|
long int pr_eorder;
|
|
long int pr_ereject;
|
|
long int pr_pwinmin;
|
|
long int pr_pwinmax;
|
|
long int pr_psizemin;
|
|
long int pr_psizemax;
|
|
};
|
|
|
|
struct Host_entry
|
|
{
|
|
struct Host_entry *next;
|
|
char Hostname[32];
|
|
struct Execution_Command *cmds; /* Local Activities */
|
|
struct Phone_Call call[2]; /* In & Out Activities */
|
|
struct Protocol_Summary *proto;
|
|
};
|
|
|
|
struct Host_entry *hosts = NULL;
|
|
struct Host_entry *tot = NULL;
|
|
struct Host_entry *cur = NULL;
|
|
struct Execution_Command *cmd, *t_cmds = NULL;
|
|
struct Protocol_Summary *prot, *t_prot, *s_prot, *ss_prot = NULL;
|
|
/*
|
|
* Stuff for getopt()
|
|
*/
|
|
|
|
extern int optind; /* GETOPT : Option Index */
|
|
extern char *optarg; /* GETOPT : Option Value */
|
|
#if ! HAVE_STDLIB_H
|
|
extern pointer *calloc();
|
|
#endif /* HAVE_STDLIB_H */
|
|
/*
|
|
* Default files to read. Taken from Taylor compile-time configuration.
|
|
* def_logs must look like an argvec, hence the dummy argv[0].
|
|
* Maybe later modified by scanning the config
|
|
*/
|
|
|
|
static char *def_logs[3] = { NULL, NULL, NULL};
|
|
char *I_conf = NULL; /* points to config lib given by -I option */
|
|
char *D_conf = NULL; /* points to config lib from makefile */
|
|
char *Tlog = NULL; /* points to Log-file */
|
|
char *Tstat = NULL; /* points to Stats-file */
|
|
char Pgm_name[64]; /* our pgm-name */
|
|
char logline[BUFSIZ+1]; /* input area */
|
|
char noConf[] = "- not defined -";
|
|
char buff[16*BUFSIZ];
|
|
char sbuff[2*BUFSIZ];
|
|
|
|
/*
|
|
* Boolean switches for various decisions
|
|
*/
|
|
|
|
int p_done = FALSE; /* TRUE: start date/time of file printed */
|
|
int hdr_done = FALSE; /* TRUE: report header printed */
|
|
int show_files = FALSE; /* TRUE: -f option given */
|
|
int show_calls = FALSE; /* TRUE: -c option given */
|
|
int show_commands = FALSE; /* TRUE: -x option given */
|
|
int show_efficiency = FALSE; /* TRUE: -e option given */
|
|
int show_all = FALSE; /* TRUE: -t option given */
|
|
int show_proto = FALSE; /* TRUE: -p option given */
|
|
int use_stdin = FALSE; /* TRUE: -i option given */
|
|
int be_quiet = FALSE; /* TRUE: -q option given */
|
|
int have_files[2]; /* TRUE: [IN] or [OUT] files found */
|
|
int have_calls = FALSE; /* TRUE: in/out calls found */
|
|
int have_commands = FALSE; /* TRUE: found uuxqt records */
|
|
int have_proto = FALSE; /* TRUE: protocol data found */
|
|
int no_records = TRUE; /* FALSE: got one record from file */
|
|
|
|
/*
|
|
* protos
|
|
*/
|
|
|
|
static pointer *getmem(unsigned n);
|
|
static void inc_cmd(struct Execution_Command **, char *name);
|
|
static void fmtime(double sec, char *buf);
|
|
static void fmbytes(unsigned long n, char *buf);
|
|
static void usage();
|
|
static int chk_config(char *conf, int n, int type);
|
|
static void hdrprt(char c, int bot);
|
|
struct Protocol_Summary *prot_sum(struct Protocol_Summary **, char *, int);
|
|
|
|
/*
|
|
* BEGIN EXECUTION
|
|
*/
|
|
|
|
int main(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
FILE *Log = NULL;
|
|
int c;
|
|
char *p, *s, *stt, *flq = NULL;
|
|
char Hostname[MAXHOSTNAMELEN]; /* def taken from <sys/param.h> */
|
|
char Filename[15]; /* filename to be printed */
|
|
char in_date[14]; /* holds the date info of record read*/
|
|
char in_time[14]; /* holds the time info of record read */
|
|
char dt_info[31]; /* holds the date info from the last record read */
|
|
char *logmsg;
|
|
int sent, called = IN;
|
|
int report = 0; /* if <= 0 give msg that no report was avail. */
|
|
int junk;
|
|
|
|
/* --------------------------------------------------------------------
|
|
* P r o l o g
|
|
* --------------------------------------------------------------------
|
|
*/
|
|
|
|
Hostname[0] = '\0';
|
|
have_files[IN]= have_files[OUT]= FALSE;
|
|
setvbuf(stdout,sbuff,_IOFBF,sizeof(sbuff));
|
|
|
|
/*
|
|
* get how we've been called isolate the name from the path
|
|
*/
|
|
|
|
if ((stt = strrchr(argv[0],'/')) != NULL)
|
|
strcpy(Pgm_name,++stt);
|
|
else
|
|
strcpy(Pgm_name,argv[0]);
|
|
def_logs[0] = Pgm_name;
|
|
|
|
/*
|
|
* I wish the compiler had the #error directive!
|
|
*/
|
|
|
|
#if !HAVE_TAYLOR_LOGGING && !HAVE_V2_LOGGING
|
|
fprintf(stderr,"\a%s: (E) %s\n",Pgm_name,"Your config of Taylor UUCP is not yet supported.");
|
|
fprintf(stderr,"%s: (E) %s\n",Pgm_name,"Current support is for V2 or TAYLOR logging only.");
|
|
puts(" Run aborted due to errors\n")
|
|
exit(1);
|
|
#endif
|
|
|
|
/*
|
|
* get some mem to store the default config name (def's are in
|
|
* policy.h )
|
|
*/
|
|
|
|
if (sizeof(NEWCONFIGLIB) > 1) /* defined at compile time */
|
|
{
|
|
D_conf = (char *)getmem((sizeof(NEWCONFIGLIB) + sizeof("/config")));
|
|
strcpy(D_conf,NEWCONFIGLIB); /* passed by makefile */
|
|
strcat(D_conf,"/config");
|
|
}
|
|
Tlog = (char *)getmem(sizeof(LOGFILE));
|
|
Tstat = (char *)getmem(sizeof(STATFILE));
|
|
Tlog = LOGFILE;
|
|
Tstat = STATFILE;
|
|
|
|
/*
|
|
* Process the command line arguments
|
|
*/
|
|
|
|
while((c = getopt(argc, argv, "I:s:cfdexaitphv")) != EOF)
|
|
{
|
|
switch(c)
|
|
{
|
|
case 'h':
|
|
(void) usage();
|
|
case 's':
|
|
strcpy(Hostname, optarg);
|
|
break;
|
|
case 'c':
|
|
show_calls = TRUE;
|
|
++report;
|
|
break;
|
|
case 'd':
|
|
printf("%s: (I) config-file default: %s\n",Pgm_name,D_conf);
|
|
exit (0);
|
|
break;
|
|
case 'f':
|
|
show_files = TRUE;
|
|
++report;
|
|
break;
|
|
case 'x':
|
|
show_commands = TRUE;
|
|
++report;
|
|
break;
|
|
case 'e':
|
|
show_efficiency = TRUE;
|
|
++report;
|
|
break;
|
|
case 'a':
|
|
show_calls = show_files = show_commands = show_efficiency = TRUE;
|
|
report = 4;
|
|
break;
|
|
case 'i':
|
|
use_stdin = TRUE;
|
|
break;
|
|
case 't':
|
|
show_all = TRUE;
|
|
report = MAXREP;
|
|
break;
|
|
case 'p':
|
|
show_proto = TRUE;
|
|
++report;
|
|
break;
|
|
case 'I':
|
|
I_conf = (char *)getmem(sizeof(optarg));
|
|
I_conf = optarg;
|
|
break;
|
|
case 'q':
|
|
be_quiet = TRUE;
|
|
break;
|
|
case 'v':
|
|
printf("%s\n",rcsid);
|
|
exit (0);
|
|
default :
|
|
(void) usage();
|
|
}
|
|
}
|
|
if (report == 0) /* no options given */
|
|
++report; /* at least summary can be printed */
|
|
if (! be_quiet)
|
|
hdrprt('i',0); /* print header for environment info */
|
|
|
|
/*
|
|
* Adjust argv and argc to account for the args processed above.
|
|
*/
|
|
|
|
argc -= (optind - 1);
|
|
argv += (optind - 1);
|
|
|
|
/*
|
|
* If further args present, Assume rest are logfiles for us to process
|
|
* which should be given in pairs (log plus stat) otherwise the results may
|
|
* not come out as expected! If no further args are present take input from
|
|
* Log and Stat files provided in the compilation environment of Taylor UUCP.
|
|
* If -i was given, Log already points to stdin and no file args are accepted.
|
|
*/
|
|
|
|
if (use_stdin) /* If -i, read from stdin */
|
|
{
|
|
if (argc != 1) /* No file arguments allowed */
|
|
{
|
|
fprintf(stderr,"\a%s: (E) %s\n",Pgm_name,
|
|
"it's not posssible to give file args with '-i'");
|
|
(void) usage();
|
|
}
|
|
else
|
|
{
|
|
argc = 2;
|
|
Log = stdin;
|
|
if (! be_quiet)
|
|
puts(" Input from stdin; no other files will be used\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (argc != 1) /* file arguments are present */
|
|
{
|
|
if (! be_quiet)
|
|
puts(" No defaults used; will use passed file arguments\n");
|
|
}
|
|
else /* Read from current logs */
|
|
{
|
|
def_logs[1] = Tlog; /* prime the */
|
|
def_logs[2] = Tstat; /* file names */
|
|
if (! be_quiet)
|
|
printf(" Config for this run: ");
|
|
|
|
if (I_conf != NULL)
|
|
{
|
|
junk = 0;
|
|
if (! be_quiet)
|
|
printf("%s\n",I_conf);
|
|
if (0 != (chk_config(I_conf,be_quiet,junk)))
|
|
return (8);
|
|
}
|
|
else
|
|
{
|
|
if (D_conf != NULL)
|
|
{
|
|
junk = 1; /* indicate default (compiled) config */
|
|
if (! be_quiet)
|
|
printf("%s\n",D_conf);
|
|
chk_config(D_conf,be_quiet,junk);
|
|
}
|
|
else
|
|
if (! be_quiet)
|
|
printf("%s\n",noConf);
|
|
}
|
|
def_logs[1] = Tlog; /* final setting of */
|
|
def_logs[2] = Tstat; /* file names */
|
|
argv = def_logs; /* Bash argvec to log/stat files */
|
|
argc = sizeof(def_logs) / sizeof(def_logs[0]);
|
|
}
|
|
}
|
|
|
|
/* --------------------------------------------------------------------
|
|
* MAIN LOGFILE PROCESSING LOOP
|
|
* --------------------------------------------------------------------
|
|
*/
|
|
|
|
if (!use_stdin)
|
|
{
|
|
if (argc < 3 && ! be_quiet)
|
|
{
|
|
puts(" (W) there is only one input file!");
|
|
puts(" (W) some reports may not be printed");
|
|
}
|
|
if (! be_quiet)
|
|
hdrprt('d',0); /* give subheaderline */
|
|
}
|
|
|
|
while (argc > 1)
|
|
{
|
|
if (!use_stdin && (Log = fopen(argv[1], "r")) == NULL)
|
|
{
|
|
perror(argv[1]);
|
|
exit (8);
|
|
}
|
|
setvbuf(Log,buff,_IOFBF,sizeof(buff));
|
|
if ((flq = strrchr(argv[1], '/')) == NULL)
|
|
strncpy(Filename,argv[1],sizeof(Filename)-1);
|
|
else
|
|
strncpy(Filename,++flq,sizeof(Filename)-1);
|
|
|
|
strcpy(in_date," n/a");
|
|
strcpy(in_time," n/a");
|
|
p_done = FALSE; /* no info printed yet */
|
|
no_records = TRUE; /* not read any record yet */
|
|
|
|
/*
|
|
* Read each line of the logfile and collect information
|
|
*/
|
|
|
|
while (fgets(logline, sizeof(logline), Log))
|
|
{
|
|
/*
|
|
* The host name of the other end of the connection is
|
|
* always the second field of the log line, whether we
|
|
* are reading a Log file or a Stats file. Set 'p' to
|
|
* point to the second field, null-terminated. Skip
|
|
* the line if something is funny. V2 and Taylor ar identical
|
|
* up to this part. Put out the start/end date of the files read;
|
|
*/
|
|
|
|
if (NULL == (p = strchr(logline, ' ')))
|
|
continue;
|
|
no_records = FALSE; /* got one (usable) record at least */
|
|
++p;
|
|
|
|
if (NULL != (stt = strchr(p, '(')))
|
|
{
|
|
if (! p_done && ! use_stdin && ! be_quiet)
|
|
{
|
|
|
|
#if HAVE_TAYLOR_LOGGING
|
|
sscanf(++stt,"%s%*c%[^.]",in_date,in_time);
|
|
#endif /* HAVE_TAYLOR_LOGGING */
|
|
|
|
#if HAVE_V2_LOGGING
|
|
sscanf(++stt,"%[^-]%*c%[1234567890:]",in_date,in_time);
|
|
#endif /* HAVE_V2_LOGGING */
|
|
|
|
printf(" %-14s %10s %8s",Filename, in_date, in_time);
|
|
strcpy(in_date," n/a"); /* reset to default */
|
|
strcpy(in_time," n/a");
|
|
p_done = TRUE;
|
|
}
|
|
else
|
|
{
|
|
if (! use_stdin && ! be_quiet) /* save for last time stamp prt. */
|
|
strncpy(dt_info,++stt,sizeof(dt_info)-1);
|
|
}
|
|
}
|
|
|
|
if (NULL != (s = strchr(p, ' ')))
|
|
*s = '\0';
|
|
for (s = p; *s; ++s)
|
|
if (isupper(*s))
|
|
*s = tolower(*s);
|
|
|
|
/*
|
|
* Skip this line if we got -s <host> and
|
|
* this line does not contain that host name.
|
|
* Don't skip the `incoming call' line with the system name `-'.
|
|
*/
|
|
|
|
if (Hostname[0] != '\0')
|
|
if ( (p[0] != '-' || p[1] != '\0') && 0 != strcmp(p, Hostname) )
|
|
continue;
|
|
|
|
/*
|
|
* We are within a call block now. If this line is a file
|
|
* transfer record, determine the direction. If not then
|
|
* skip the line if it is not interesting.
|
|
*/
|
|
|
|
if ((s = strchr(++s, ')')) == NULL)
|
|
continue;
|
|
|
|
#if ! HAVE_TAYLOR_LOGGING
|
|
#if HAVE_V2_LOGGING
|
|
if ((strncmp(s,") (",3)) == 0) /* are we in stats file ?) */
|
|
if ((s = strchr(++s, ')')) == NULL)
|
|
continue; /* yes but strange layout */
|
|
#endif /* HAVE_V2_LOGGING */
|
|
#endif /* ! HAVE_TAYLOR_LOGGING */
|
|
|
|
logmsg = s + 2; /* Message is 2 characters after ')' */
|
|
if ((0 != strncmp(logmsg, "Call complete", 13)) &&
|
|
(0 != strncmp(logmsg, "Calling system", 14)) &&
|
|
(0 != strncmp(logmsg, "Incoming call", 13)) &&
|
|
(0 != strncmp(logmsg, "Handshake successful", 20)) &&
|
|
(0 != strncmp(logmsg, "Retry time not", 14)) &&
|
|
(0 != strncmp(logmsg, "ERROR: All matching ports", 25)) &&
|
|
(0 != strncmp(logmsg, "Executing", 9)) &&
|
|
(0 != strncmp(logmsg, "Protocol ", 9)) &&
|
|
(0 != strncmp(logmsg, "sent ", 5)) &&
|
|
(0 != strncmp(logmsg, "received ", 9)) &&
|
|
(0 != strncmp(logmsg, "failed after ", 13)) &&
|
|
(0 != strncmp(logmsg, "Errors: ", 8)))
|
|
continue;
|
|
|
|
/*
|
|
* Find the Host_entry for this host, or create a new
|
|
* one and link it on to the list.
|
|
*/
|
|
|
|
if ((cur == NULL) || (0 != strcmp(p, cur->Hostname)))
|
|
{
|
|
struct Host_entry *e, *last;
|
|
|
|
for (e= cur= hosts; cur != NULL ; e= cur, cur= cur->next)
|
|
if (0 == strcmp(cur->Hostname, p))
|
|
break;
|
|
if (cur == NULL)
|
|
{
|
|
cur= (struct Host_entry *)getmem(sizeof(*hosts));
|
|
strcpy(cur->Hostname, p);
|
|
if (hosts == NULL)
|
|
e= hosts= cur;
|
|
else {
|
|
e = hosts;
|
|
last = NULL;
|
|
while (e != NULL) {
|
|
if (strcmp(e->Hostname, cur->Hostname) <= 0) {
|
|
if (e->next == NULL) {
|
|
e->next = cur;
|
|
break;
|
|
}
|
|
last = e;
|
|
e = e->next;
|
|
}
|
|
else {
|
|
cur->next = e;
|
|
if (last == NULL)
|
|
hosts = cur;
|
|
else
|
|
last->next = cur;
|
|
break;
|
|
}
|
|
} /* while (e != NULL) */
|
|
} /* hosts == NULL */
|
|
} /* cur == NULL */
|
|
}
|
|
|
|
/*
|
|
* OK, if this is a uuxqt record, find the Execution_Command
|
|
* structure for the command being executed, or create a new
|
|
* one. Then count an execution of this command.
|
|
* (Log file only)
|
|
*/
|
|
|
|
if (0 == strncmp(logmsg, "Executing", 9))
|
|
{
|
|
if (NULL == (p = strchr(logmsg, '(')))
|
|
continue;
|
|
if ((s = strpbrk(++p, " )")) == NULL)
|
|
continue;
|
|
*s = '\0';
|
|
inc_cmd(&cur->cmds, p);
|
|
inc_cmd(&t_cmds, p);
|
|
have_commands = TRUE;
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* Count start of outgoing call.
|
|
*/
|
|
|
|
if ((0 == strncmp(logmsg, "Calling system", 14)) ||
|
|
(0 == strncmp(logmsg, "Retry time not", 14)) ||
|
|
(0 == strncmp(logmsg, "ERROR: All matching ports", 25)))
|
|
{
|
|
called = OUT;
|
|
cur->call[OUT].calls++;
|
|
have_calls = TRUE;
|
|
s_prot = NULL; /* destroy pointer to protocol */
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* Count start of incoming call.
|
|
*/
|
|
|
|
if (0 == strncmp(logmsg, "Incoming call", 13))
|
|
{
|
|
called = IN;
|
|
s_prot = NULL; /* destroy pointer to protocol */
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* On an incoming call, get system name from the second line.
|
|
* Get protocol type and size/window too
|
|
*/
|
|
|
|
if (0 == strncmp(logmsg, "Handshake successful", 20))
|
|
{
|
|
if ( called==IN )
|
|
cur->call[IN].calls++;
|
|
have_calls = TRUE;
|
|
s_prot = NULL; /* destroy pointer to protocol */
|
|
if (NULL == (p = strchr(logmsg, '(')))
|
|
continue;
|
|
if (0 == strncmp(p, "(protocol ", 10))
|
|
{
|
|
if (NULL == (p = strchr(p, '\'')))
|
|
continue;
|
|
ss_prot = prot_sum(&cur->proto, ++p, 1);
|
|
s_prot = prot_sum(&t_prot, p, 1);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* check protocol type and get stats
|
|
*
|
|
*/
|
|
|
|
if (0 == strncmp(logmsg, "Protocol ", 9))
|
|
{
|
|
s_prot = NULL; /* destroy pointer to protocol */
|
|
if (NULL == (p = strchr(logmsg, '\'')))
|
|
continue;
|
|
ss_prot = prot_sum(&cur->proto, ++p, 2);
|
|
s_prot = prot_sum(&t_prot, p, 2);
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* check protocol errors. Unfortunately the line does not contain
|
|
* the used protocol, so if any previous line did contain that
|
|
* information and we did process that line we will save the pointer
|
|
* to that particular segment into s_prot. If this pointer is not set
|
|
* the error info is lost for we don't know where to store.
|
|
*
|
|
*/
|
|
|
|
if ((0 == strncmp(logmsg, "Errors: header", 14)) && s_prot != NULL)
|
|
{
|
|
int i1,i2,i3,i4 = 0;
|
|
sscanf(logmsg,"%*s %*s %d%*c%*s %d%*c%*s %d%*c%*s %*s%*c %d",&i1,&i2,&i3,&i4);
|
|
ss_prot->pr_eheader += i1;
|
|
ss_prot->pr_echksum += i2;
|
|
ss_prot->pr_eorder += i3;
|
|
ss_prot->pr_ereject += i4;
|
|
s_prot->pr_eheader += i1;
|
|
s_prot->pr_echksum += i2;
|
|
s_prot->pr_eorder += i3;
|
|
s_prot->pr_ereject += i4;
|
|
s_prot = NULL;
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* Handle end of call. Pick up the connect time.
|
|
* position is on the closing paren of date/time info
|
|
* i.e: ) text....
|
|
*/
|
|
|
|
if (0 == strncmp(logmsg, "Call complete", 13))
|
|
{
|
|
cur->call[called].succs++;
|
|
s_prot = NULL; /* destroy pointer to protocol */
|
|
if (NULL == (s = strchr(logmsg, '(')))
|
|
continue;
|
|
cur->call[called].connect_time += atof(s+1);
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* We are definitely in a Stats file now.
|
|
* If we reached here, this must have been a file transfer
|
|
* record. Count it in the field corresponding to the
|
|
* direction of the transfer. Count bytes transferred and
|
|
* the time to transfer as well.
|
|
* Position within the record is at the word 'received' or 'sent'
|
|
* depending on the direction.
|
|
*/
|
|
|
|
sent = IN; /* give it an initial value */
|
|
if (0 == strncmp(logmsg, "failed after ",13))
|
|
logmsg += 13; /* the transmission failed for any reason */
|
|
/* so advance pointer */
|
|
if (0 == strncmp(logmsg, "sent", 4))
|
|
sent = OUT;
|
|
else if (0 == strncmp(logmsg, "received", 8))
|
|
sent = IN;
|
|
have_files[sent] = TRUE;
|
|
cur->call[called].flow[sent].files++;
|
|
if (NULL == (s = strchr(logmsg, ' '))) /* point past keyword */
|
|
continue; /* nothing follows */
|
|
/* we should be at the bytes column now*/
|
|
#if HAVE_TAYLOR_LOGGING
|
|
cur->call[called].flow[sent].bytes += atol(++s);
|
|
#endif /* HAVE_TAYLOR_LOGGING */
|
|
#if HAVE_V2_LOGGING
|
|
if (NULL == (s = strpbrk(s, "0123456789"))) /* point to # bytes */
|
|
continue;
|
|
cur->call[called].flow[sent].bytes += atol(s);
|
|
#endif /* HAVE_V2_LOGGING */
|
|
if (NULL == (s = strchr(s, ' '))) /* point past # of bytes */
|
|
continue;
|
|
if (NULL == (s = strpbrk(s, "0123456789"))) /* point to # of seconds */
|
|
continue;
|
|
cur->call[called].flow[sent].time += atof(s);
|
|
|
|
} /* end of while (fgets(logline...)) */
|
|
|
|
if (stt != NULL && ! use_stdin && ! be_quiet && ! no_records)
|
|
{
|
|
|
|
#if HAVE_TAYLOR_LOGGING
|
|
sscanf(dt_info,"%s%*c%[^.]",in_date,in_time);
|
|
#endif /* HAVE_TAYLOR_LOGGING */
|
|
|
|
#if HAVE_V2_LOGGING
|
|
sscanf(dt_info,"%[^-]%*c%[1234567890:]",in_date,in_time);
|
|
#endif /* HAVE_V2_LOGGING */
|
|
|
|
printf(" %10s %8s\n",in_date, in_time);
|
|
p_done = FALSE;
|
|
}
|
|
if (Log != stdin)
|
|
{
|
|
if (0 != ferror(Log))
|
|
{
|
|
if (! be_quiet)
|
|
printf(" %-14s data is incomplete; read error"," ");
|
|
else
|
|
fprintf(stderr,"%s (W) data is incomplete; read error on %s\n",
|
|
Pgm_name,argv[1]);
|
|
}
|
|
else
|
|
{
|
|
if (! be_quiet && no_records)
|
|
printf(" %-14s %10s\n",Filename, " is empty ");
|
|
}
|
|
}
|
|
fclose(Log);
|
|
|
|
argc--;
|
|
argv++;
|
|
} /* end of while (for (argv ....) */
|
|
|
|
/*
|
|
* do we have *any* data ?
|
|
*/
|
|
|
|
if (cur == NULL)
|
|
{
|
|
puts("\n(I) Sorry! No data is available for any requested report\n");
|
|
exit(0);
|
|
}
|
|
|
|
/*
|
|
* truncate hostname, alloc the structure holding the totals and
|
|
* collect the totals data
|
|
*/
|
|
|
|
for (cur = hosts; cur != NULL;cur = cur->next)
|
|
{
|
|
cur->Hostname[MAXDNAME] = '\0';
|
|
if (cur->next == NULL) /* last so will have to alloc totals */
|
|
{
|
|
cur->next = (struct Host_entry *)getmem(sizeof(*hosts));
|
|
strcpy(cur->next->Hostname,"Totals");
|
|
tot = cur->next;
|
|
for (cur = hosts; cur != NULL; cur = cur->next)
|
|
{
|
|
if (cur->next != NULL) /* don't count totals to totals */
|
|
{
|
|
tot->call[IN].flow[IN].bytes += cur->call[IN].flow[IN].bytes;
|
|
tot->call[OUT].flow[IN].bytes += cur->call[OUT].flow[IN].bytes;
|
|
tot->call[IN].flow[OUT].bytes += cur->call[IN].flow[OUT].bytes;
|
|
tot->call[OUT].flow[OUT].bytes += cur->call[OUT].flow[OUT].bytes;
|
|
tot->call[IN].flow[IN].time += cur->call[IN].flow[IN].time;
|
|
tot->call[OUT].flow[IN].time += cur->call[OUT].flow[IN].time;
|
|
tot->call[IN].flow[OUT].time += cur->call[IN].flow[OUT].time;
|
|
tot->call[OUT].flow[OUT].time += cur->call[OUT].flow[OUT].time;
|
|
tot->call[IN].flow[IN].files += cur->call[IN].flow[IN].files;
|
|
tot->call[OUT].flow[IN].files += cur->call[OUT].flow[IN].files;
|
|
tot->call[IN].flow[OUT].files += cur->call[IN].flow[OUT].files;
|
|
tot->call[OUT].flow[OUT].files += cur->call[OUT].flow[OUT].files;
|
|
tot->call[OUT].succs += cur->call[OUT].succs;
|
|
tot->call[OUT].calls += cur->call[OUT].calls;
|
|
tot->call[OUT].connect_time += cur->call[OUT].connect_time;
|
|
tot->call[IN].succs += cur->call[IN].succs;
|
|
tot->call[IN].calls += cur->call[IN].calls;
|
|
tot->call[IN].connect_time += cur->call[IN].connect_time;
|
|
}
|
|
}
|
|
break; /* totals is last in Host_Entry */
|
|
}
|
|
}
|
|
|
|
/*
|
|
* ***********
|
|
* * REPORTS *
|
|
* ***********
|
|
*/
|
|
|
|
#if _DEBUG_
|
|
putchar('\n');
|
|
#endif
|
|
|
|
/* ------------------------------------------------------------------
|
|
*
|
|
* Summary report only when no other report except option -t is given
|
|
*
|
|
* I know, this code could be tightened (rbd)...
|
|
* ------------------------------------------------------------------
|
|
*/
|
|
|
|
if ( !(show_calls || show_files ||
|
|
show_efficiency || show_commands || show_proto) || show_all)
|
|
{
|
|
if (have_calls || have_files[IN] || have_files[OUT])
|
|
{
|
|
char t1[32], t2[32], t3[32], t4[32], t5[32];
|
|
long ib, ob, b, rf, sf;
|
|
double it, ot, ir, or;
|
|
|
|
hdr_done = FALSE;
|
|
for (cur = hosts; cur != NULL; cur = cur->next)
|
|
{
|
|
ib = (cur->call[IN].flow[IN].bytes +
|
|
cur->call[OUT].flow[IN].bytes);
|
|
fmbytes(ib, t1);
|
|
|
|
ob = (cur->call[IN].flow[OUT].bytes +
|
|
cur->call[OUT].flow[OUT].bytes);
|
|
fmbytes(ob, t2);
|
|
|
|
/* Don't print null-lines. */
|
|
if (( b= ib+ob ) == 0 )
|
|
continue;
|
|
/* Don't print the header twice. */
|
|
if (! hdr_done)
|
|
{
|
|
hdrprt('s',0); /* print the header line(s) */
|
|
hdr_done = TRUE;
|
|
}
|
|
|
|
fmbytes(b, t3);
|
|
|
|
it = cur->call[IN].flow[IN].time +
|
|
cur->call[OUT].flow[IN].time;
|
|
fmtime(it, t4);
|
|
|
|
ot = cur->call[IN].flow[OUT].time +
|
|
cur->call[OUT].flow[OUT].time;
|
|
fmtime(ot, t5);
|
|
|
|
rf = cur->call[IN].flow[IN].files +
|
|
cur->call[OUT].flow[IN].files;
|
|
|
|
sf = cur->call[IN].flow[OUT].files +
|
|
cur->call[OUT].flow[OUT].files;
|
|
|
|
ir = (it == 0.0) ? 0.0 : (ib / it);
|
|
or = (ot == 0.0) ? 0.0 : (ob / ot);
|
|
|
|
if (cur->next == NULL) /* totals line reached ? */
|
|
hdrprt('s',1); /* print the separator line */
|
|
|
|
printf("%-8s %4d %4d %9s %9s %9s %9s %9s %5.0f %5.0f\n",
|
|
cur->Hostname, rf, sf,
|
|
t1, t2, t3, t4, t5,
|
|
ir, or);
|
|
}
|
|
if (! hdr_done)
|
|
{
|
|
puts("\n(I) No data found to print Compact summary report");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
puts("\n(I) No data available for Compact summary report");
|
|
--report;
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------
|
|
* Protocol statistics report
|
|
* ------------------------------------------------------------------
|
|
*/
|
|
|
|
if (show_proto || show_all)
|
|
{
|
|
if (have_proto)
|
|
{
|
|
/* --------------------- */
|
|
/* protocol packet report */
|
|
/* --------------------- */
|
|
|
|
char *type = NULL;
|
|
hdr_done = FALSE;
|
|
for (cur = hosts; cur != NULL; cur = cur->next)
|
|
{
|
|
type = cur->Hostname;
|
|
if (cur->next == NULL)
|
|
{
|
|
if (hdr_done)
|
|
puts("-------------------------------------------------------------------");
|
|
cur->proto = t_prot;
|
|
}
|
|
for (prot = cur->proto; prot != NULL; prot = prot->next)
|
|
{
|
|
if (! hdr_done)
|
|
{
|
|
hdrprt('p',0); /* print the header line(s) */
|
|
hdr_done = TRUE;
|
|
}
|
|
printf("%-8s %3s %4d %4d %5d %4d %10d %7d %10d\n",
|
|
type == NULL ? " ":cur->Hostname,
|
|
prot->type,
|
|
prot->pr_psizemin,
|
|
prot->pr_psizemax,
|
|
prot->pr_pwinmin,
|
|
prot->pr_pwinmax,
|
|
prot->pr_psent,
|
|
prot->pr_present,
|
|
prot->pr_preceived);
|
|
type = NULL;
|
|
}
|
|
}
|
|
if (! hdr_done)
|
|
puts("\n(I) No data found to print Protocol packet report");
|
|
|
|
/* --------------------- */
|
|
/* protocol error report */
|
|
/* --------------------- */
|
|
|
|
type = NULL;
|
|
hdr_done = FALSE;
|
|
if (t_prot != NULL)
|
|
{
|
|
for (cur = hosts; cur != NULL; cur = cur->next)
|
|
{
|
|
type = cur->Hostname;
|
|
if (cur->next == NULL)
|
|
{
|
|
if (hdr_done)
|
|
puts("--------------------------------------------------------------");
|
|
cur->proto = t_prot;
|
|
}
|
|
|
|
for (prot = cur->proto; prot != NULL; prot = prot->next)
|
|
{
|
|
if ((prot->pr_eheader + prot->pr_echksum +
|
|
prot->pr_eorder + prot->pr_ereject) != 0)
|
|
{
|
|
if (! hdr_done)
|
|
{
|
|
hdrprt('p',1); /* print the header line(s) */
|
|
hdr_done = TRUE;
|
|
}
|
|
printf("%-8s %3s %11d %11d %11d %11d\n",
|
|
type == NULL ? " ":cur->Hostname,
|
|
prot->type,
|
|
prot->pr_eheader,
|
|
prot->pr_echksum,
|
|
prot->pr_eorder,
|
|
prot->pr_ereject);
|
|
type = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (! hdr_done)
|
|
puts("\n(I) No data found to print Protocol error report");
|
|
}
|
|
else
|
|
{
|
|
puts("\n(I) No data available for Protocol reports");
|
|
--report;
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------
|
|
* Call statistics report
|
|
* ------------------------------------------------------------------
|
|
*/
|
|
|
|
if (show_calls || show_all)
|
|
{
|
|
if (have_calls)
|
|
{
|
|
char t1[32], t2[32];
|
|
|
|
hdr_done = FALSE;
|
|
for (cur = hosts; cur != NULL; cur = cur->next)
|
|
{
|
|
if (cur->next == NULL)
|
|
{
|
|
if (hdr_done)
|
|
hdrprt('c',1); /* print the separator line */
|
|
}
|
|
else
|
|
{
|
|
/* Don't print null-lines on deatail lines */
|
|
if ( cur->call[OUT].calls + cur->call[IN].calls == 0 )
|
|
continue;
|
|
|
|
/* Don't print the header twice. */
|
|
if (! hdr_done)
|
|
{
|
|
hdrprt('c',0); /* print the header line(s) */
|
|
hdr_done = TRUE;
|
|
}
|
|
}
|
|
if ( cur->call[OUT].calls > 0 || cur->next == NULL)
|
|
{
|
|
fmtime(cur->call[OUT].connect_time, t1);
|
|
printf( " %-8s %7d %7d %7d %9s",
|
|
cur->Hostname,
|
|
cur->call[OUT].succs,
|
|
cur->call[OUT].calls - cur->call[OUT].succs,
|
|
cur->call[OUT].calls,
|
|
t1 );
|
|
}
|
|
else
|
|
{
|
|
printf( " %-42s", cur->Hostname );
|
|
}
|
|
if ( cur->call[IN].calls > 0 || cur->next == NULL )
|
|
{
|
|
fmtime(cur->call[IN].connect_time, t2);
|
|
printf( " %7d %7d %7d %9s",
|
|
cur->call[IN].succs,
|
|
cur->call[IN].calls - cur->call[IN].succs,
|
|
cur->call[IN].calls,
|
|
t2 );
|
|
}
|
|
putchar('\n');
|
|
}
|
|
if (! hdr_done)
|
|
{
|
|
puts("\n(I) No data found to print Call statistics report");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
puts("\n(I) No data available for Call statistics report");
|
|
--report;
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------
|
|
* File statistics report
|
|
* ------------------------------------------------------------------
|
|
*/
|
|
|
|
if (show_files || show_all)
|
|
{
|
|
if (have_files[IN] || have_files[OUT])
|
|
{
|
|
char t1[32], t2[32];
|
|
double rate = 0, time = 0;
|
|
int b = 0;
|
|
int lineOut = 0;
|
|
|
|
hdr_done = FALSE;
|
|
for (cur = hosts; cur != NULL; cur = cur->next)
|
|
{
|
|
lineOut = 0;
|
|
for (sent= IN; sent <= OUT; ++sent)
|
|
{
|
|
b = cur->call[IN].flow[sent].bytes +
|
|
cur->call[OUT].flow[sent].bytes;
|
|
time = cur->call[IN].flow[sent].time +
|
|
cur->call[OUT].flow[sent].time;
|
|
|
|
/* Don't print null-lines on detail lines. */
|
|
if ( (b != 0 && time != 0.0) || cur->next == NULL)
|
|
{
|
|
/* Don't print the header twice. */
|
|
if (! hdr_done)
|
|
{
|
|
hdrprt('f',0); /* print the header line(s) */
|
|
hdr_done = TRUE;
|
|
}
|
|
fmbytes(b, t1);
|
|
rate = (cur->call[IN].flow[sent].bytes +
|
|
cur->call[OUT].flow[sent].bytes) / time;
|
|
fmtime((cur->call[IN].flow[sent].time +
|
|
cur->call[OUT].flow[sent].time), t2);
|
|
|
|
if (lineOut == 0) /* first half not printed yet ? */
|
|
{
|
|
if (cur->next == NULL) /* totals line ? */
|
|
hdrprt('f',1); /* print the separator line */
|
|
printf(" %-8s", cur->Hostname);
|
|
if (sent == OUT) /* can't happen whith totals line */
|
|
printf("%34s", " ");
|
|
}
|
|
|
|
printf(" %5d %11s %9s %5.0f",
|
|
cur->call[IN].flow[sent].files +
|
|
cur->call[OUT].flow[sent].files,
|
|
t1, t2, rate);
|
|
lineOut = 1;
|
|
}
|
|
} /* end: for (sent ... ) */
|
|
if (lineOut)
|
|
printf("\n");
|
|
} /* end: for (cur= ... ) */
|
|
if (! hdr_done)
|
|
{
|
|
puts("\n(I) No data found to print File statistics report");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
puts("\n(I) No data available for File statistics report");
|
|
--report;
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------
|
|
* Efficiency report
|
|
* ------------------------------------------------------------------
|
|
*/
|
|
|
|
if (show_efficiency || show_all)
|
|
{
|
|
if (have_files[IN] || have_files[OUT])
|
|
{
|
|
char t1[32], t2[32], t3[32];
|
|
double total, flow;
|
|
|
|
hdr_done = FALSE;
|
|
for (cur = hosts; cur != NULL; cur = cur->next)
|
|
{
|
|
/* Don't print null-lines. */
|
|
if ( 0 == cur->call[IN].flow[IN].files +
|
|
cur->call[IN].flow[OUT].files +
|
|
cur->call[OUT].flow[IN].files +
|
|
cur->call[OUT].flow[OUT].files ||
|
|
0.0 == (total= cur->call[IN].connect_time +
|
|
cur->call[OUT].connect_time))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (! hdr_done)
|
|
{
|
|
hdrprt('e',0); /* print the header line(s) */
|
|
hdr_done = TRUE;
|
|
}
|
|
|
|
flow = cur->call[IN].flow[IN].time +
|
|
cur->call[IN].flow[OUT].time +
|
|
cur->call[OUT].flow[IN].time +
|
|
cur->call[OUT].flow[OUT].time;
|
|
fmtime(total, t1);
|
|
fmtime(flow, t2);
|
|
fmtime(total-flow, t3);
|
|
|
|
if (cur->next == NULL)
|
|
hdrprt('e',1); /* print the separator line */
|
|
|
|
printf(" %-8s %10s %10s %10s %7.2f\n",
|
|
cur->Hostname, t1, t2, t3,
|
|
flow >= total ? 100.0: flow*100.0/total);
|
|
} /* end: for (cur= .. */
|
|
if (! hdr_done)
|
|
{
|
|
puts("\n(I) No data found to print Efficiency report");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
puts("\n(I) No data available for Efficiency report");
|
|
--report;
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------
|
|
* Command execution report
|
|
* ------------------------------------------------------------------
|
|
*/
|
|
|
|
if (show_commands || show_all)
|
|
{
|
|
if (have_commands)
|
|
{
|
|
int ncmds, i, match;
|
|
|
|
/*
|
|
* layout the header line. The column's header is the command name
|
|
*/
|
|
|
|
hdr_done = FALSE;
|
|
for (ncmds= 0, cmd= t_cmds;
|
|
cmd != NULL && ncmds <= MAXCOLS-1;
|
|
ncmds++, cmd= cmd->next)
|
|
{
|
|
if (! hdr_done)
|
|
{
|
|
puts("\nCommand executions:");
|
|
puts("-------------------");
|
|
puts(" Name of ");
|
|
fputs(" site ", stdout);
|
|
hdr_done = TRUE;
|
|
}
|
|
printf(" %7s", cmd->Commandname);
|
|
}
|
|
if (! hdr_done)
|
|
{
|
|
puts("\n(I) No data found to print Command execution report");
|
|
}
|
|
else
|
|
{
|
|
fputs("\n --------", stdout);
|
|
for (i= 0; i<ncmds; i++)
|
|
fputs(" ------", stdout);
|
|
putchar('\n');
|
|
|
|
/*
|
|
* print out the number of executions for each host/command
|
|
*/
|
|
|
|
for (cur= hosts; cur != NULL; cur= cur->next)
|
|
{
|
|
if (cur->next == NULL)
|
|
break;
|
|
|
|
/* Don't print null-lines. */
|
|
|
|
if (cur->cmds == NULL)
|
|
continue;
|
|
|
|
printf(" %-8s", cur->Hostname);
|
|
for (cmd= t_cmds; cmd != NULL; cmd= cmd->next)
|
|
{
|
|
struct Execution_Command *ec;
|
|
match = FALSE;
|
|
for(ec= cur->cmds; ec != NULL; ec= ec->next)
|
|
{
|
|
if ( 0 == strcmp(cmd->Commandname, ec->Commandname) )
|
|
{
|
|
printf(" %7d", ec->count);
|
|
match = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if (! match)
|
|
printf("%8s"," "); /* blank out column */
|
|
}
|
|
putchar('\n');
|
|
}
|
|
|
|
/*
|
|
* print the totals line
|
|
*/
|
|
|
|
fputs(" --------", stdout);
|
|
for (i= 0; i<ncmds; i++)
|
|
fputs("--------", stdout);
|
|
printf("\n %-8s", cur->Hostname);
|
|
for (cmd= t_cmds; cmd != NULL; cmd= cmd->next)
|
|
{
|
|
printf(" %7d", cmd->count);
|
|
}
|
|
putchar('\n');
|
|
}
|
|
}
|
|
else
|
|
{
|
|
puts("\n(I) No data available for Command execution report");
|
|
--report;
|
|
}
|
|
}
|
|
if (report <= 0 ) /* any reports ? */
|
|
{
|
|
puts("\n(I) Sorry! No data is available for any requested report\n");
|
|
exit(1);
|
|
}
|
|
|
|
puts("\n(I) End of reports\n");
|
|
exit (0);
|
|
} /* end of main */
|
|
|
|
/* ------------------------------------------------------------------
|
|
* * Functions *
|
|
* ------------------------------------------------------------------
|
|
*/
|
|
|
|
/* ------------------------------------------------------------------
|
|
* display the help
|
|
* ------------------------------------------------------------------
|
|
*/
|
|
|
|
void usage()
|
|
{
|
|
fprintf(stderr,"Usage uurate [-acdefhiptvx] [-s hostname] [-I config file] [logfile(s) ... logfile(s)]\n");
|
|
fprintf(stderr,"where:\t-a\tPrint reports c,e,f,x\n");
|
|
fprintf(stderr,"\t-c\tReport call statistics\n");
|
|
fprintf(stderr,"\t-d\tPrint the name of the default config file\n");
|
|
fprintf(stderr,"\t-e\tReport efficiency statistics\n");
|
|
fprintf(stderr,"\t-f\tReport file transfer statistics\n");
|
|
fprintf(stderr,"\t-h\tPrint this help\n");
|
|
fprintf(stderr,"\t-i\tRead log info from standard input\n");
|
|
fprintf(stderr,"\t-p\tReport protocol statistics\n");
|
|
fprintf(stderr,"\t-t\tAll available reports plus compact summary report\n");
|
|
fprintf(stderr,"\t-v\tPrint version number\n");
|
|
fprintf(stderr,"\t-x\tReport command execution statistics\n");
|
|
fprintf(stderr,"\t-s host\tReport activities involving HOST only\n");
|
|
fprintf(stderr,"\t-I config Use config instead of standard config file\n");
|
|
fprintf(stderr,"If no report options given, a compact summary report is printed.\n");
|
|
fprintf(stderr,"log files should be given as pairs that is Log/Stats ... .\n");
|
|
fprintf(stderr,"If neither -i nor logfiles given, those names found in config will be used\n");
|
|
|
|
exit (1);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------
|
|
* getmem - get some memory
|
|
* ------------------------------------------------------------------
|
|
*/
|
|
|
|
static pointer *getmem(n)
|
|
unsigned n;
|
|
{
|
|
pointer *p;
|
|
|
|
if( NULL== (p= calloc(1, n)) )
|
|
{
|
|
fprintf(stderr,"\a%s (C) %s\n",Pgm_name, "out of memory\n");
|
|
exit (8);
|
|
}
|
|
return p;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------
|
|
* inc_cmd - increment command count
|
|
* ------------------------------------------------------------------
|
|
*/
|
|
|
|
static void inc_cmd(cmds, name)
|
|
struct Execution_Command **cmds;
|
|
char *name;
|
|
{
|
|
int cnt = 0;
|
|
struct Execution_Command *cmd, *ec;
|
|
|
|
for (ec = cmd = *cmds; cmd != NULL; ec= cmd, cmd= cmd->next, cnt++)
|
|
if ( (0 == strcmp(cmd->Commandname, name)) ||
|
|
(0 == strcmp(cmd->Commandname, "Misc.")) )
|
|
break;
|
|
if (cmd == NULL)
|
|
{
|
|
cmd= (struct Execution_Command *)getmem(sizeof(*cmd));
|
|
if (cnt <= MAXCOLS-1) /* first col prints site name therefore < max-1 */
|
|
{
|
|
strcpy(cmd->Commandname, name);
|
|
if (*cmds == NULL)
|
|
ec = *cmds = cmd;
|
|
else
|
|
ec->next= cmd;
|
|
}
|
|
else
|
|
{
|
|
strcpy(ec->Commandname, "Misc."); /* reached high-water-mark */
|
|
cmd = ec; /* backtrack */
|
|
}
|
|
}
|
|
cmd->count++;
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------------
|
|
* prot_sum - collect protocol data
|
|
* ------------------------------------------------------------------
|
|
*/
|
|
|
|
struct Protocol_Summary *
|
|
prot_sum(proto, ptype, ind)
|
|
struct Protocol_Summary **proto;
|
|
char *ptype;
|
|
int ind;
|
|
{
|
|
int cnt = 0;
|
|
int i1, i2, i3 = 0;
|
|
struct Protocol_Summary *cur, *first;
|
|
|
|
for (first = cur = *proto; cur != NULL; first= cur, cur= cur->next, cnt++)
|
|
{
|
|
if ( (0 == strncmp(cur->type, ptype,strlen(cur->type))))
|
|
break;
|
|
}
|
|
if (cur == NULL)
|
|
{
|
|
cur= (struct Protocol_Summary *)getmem(sizeof(*cur));
|
|
sscanf(ptype,"%[^\' ]3",cur->type);
|
|
if (*proto == NULL)
|
|
first = *proto = cur;
|
|
else
|
|
first->next= cur;
|
|
}
|
|
if (NULL == (ptype = strchr(ptype, ' ')))
|
|
return (NULL);
|
|
cur->pr_cnt++;
|
|
have_proto = TRUE;
|
|
++ptype;
|
|
switch(ind)
|
|
{
|
|
case 1: /* used protocol line */
|
|
/*
|
|
* uucp-1.04 format: .... packet size ssss window ww)
|
|
* uucp-1.05 format: .... remote packet/window ssss/ww local ssss/ww)
|
|
* (the remote packet/window will be used!)
|
|
*/
|
|
|
|
i1 = i2 = 0; /* reset */
|
|
|
|
if (NULL == (strchr(ptype, '/')))
|
|
sscanf(ptype,"%*s %*s %d %*s %d",&i1,&i2);
|
|
else
|
|
sscanf(ptype,"%*s %*s %d/%d",&i1,&i2);
|
|
|
|
if (i1 > cur->pr_psizemax)
|
|
cur->pr_psizemax = i1;
|
|
if (i1 < cur->pr_psizemin || cur->pr_psizemin == 0)
|
|
cur->pr_psizemin = i1;
|
|
|
|
if (i2 > cur->pr_pwinmax)
|
|
cur->pr_pwinmax = i2;
|
|
if (i2 < cur->pr_pwinmin || cur->pr_pwinmin == 0)
|
|
cur->pr_pwinmin = i2;
|
|
break;
|
|
case 2: /* protocol statistics line */
|
|
i1 = i2 = i3 = 0; /* reset */
|
|
sscanf(ptype,"%*s %*s %d%*c %*s %d%*c %*s %d",&i1,&i2,&i3);
|
|
cur->pr_psent += i1;
|
|
cur->pr_present += i2;
|
|
cur->pr_preceived += i3;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return (cur);
|
|
}
|
|
/* ------------------------------------------------------------------
|
|
* fmtime() - Format time in hours & minutes & seconds;
|
|
* ------------------------------------------------------------------
|
|
*/
|
|
|
|
static void fmtime(dsec, buf)
|
|
double dsec;
|
|
char *buf;
|
|
{
|
|
long hrs, min, lsec;
|
|
|
|
if( dsec <= 0 )
|
|
{
|
|
strcpy(buf, "0" );
|
|
return;
|
|
}
|
|
lsec = fmod(dsec+0.5, 60L); /* round to the next full second */
|
|
hrs = dsec / 3600L;
|
|
min = ((long)dsec / 60L) % 60L;
|
|
if (hrs == 0)
|
|
if (min == 0)
|
|
sprintf(buf,"%6s%2ld"," ",lsec);
|
|
else
|
|
sprintf(buf,"%3s%2ld:%02ld"," ",min,lsec);
|
|
else
|
|
sprintf(buf,"%2ld:%02ld:%02ld",hrs,min,lsec);
|
|
|
|
}
|
|
|
|
/* ------------------------------------------------------------------
|
|
* fmbytes - Format size in bytes
|
|
* ------------------------------------------------------------------
|
|
*/
|
|
|
|
static void fmbytes(n, buf)
|
|
unsigned long n;
|
|
char *buf;
|
|
{
|
|
if ( n == 0 )
|
|
{
|
|
strcpy( buf, "0.0" );
|
|
return;
|
|
}
|
|
sprintf(buf, "%.1f", (double)n / 1000.0); /* Display in Kilobytes */
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------------
|
|
* chk_config - Read the config file
|
|
* check on keywords: logfile and statfile. When found override
|
|
* the corresponding default
|
|
* ------------------------------------------------------------------
|
|
*/
|
|
|
|
int chk_config(char *T_conf,int be_quiet, int type)
|
|
{
|
|
FILE *Conf;
|
|
char keywrd[9];
|
|
char name[MAXPATHLEN+1];
|
|
char *pos1, *pos2;
|
|
int i = 0;
|
|
int logf = FALSE;
|
|
int statf = FALSE;
|
|
|
|
if ((Conf = fopen(T_conf, "r")) == NULL)
|
|
{
|
|
if (! be_quiet)
|
|
{
|
|
puts(" Could not open config");
|
|
if (type == 0)
|
|
{
|
|
puts(" The run will be aborted\n");
|
|
return (8);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr,"%s (E) %s %s \n",Pgm_name,
|
|
"could not open config:",
|
|
T_conf);
|
|
if (type != 0)
|
|
fprintf(stderr,"%s (W) defaults used for all files\n",
|
|
Pgm_name);
|
|
else
|
|
{
|
|
fprintf(stderr,"%s (C) ended due to errors\n",
|
|
Pgm_name);
|
|
return (8);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (fgets(logline, sizeof(logline), Conf))
|
|
{
|
|
if (logline[0] == '#')
|
|
continue;
|
|
sscanf(logline,"%8s %s",keywrd,name);
|
|
if (0 == strncmp(keywrd,"logfile",7))
|
|
{
|
|
pos1 = pos2 = name;
|
|
for (i=0;(i<=MAXPATHLEN && *pos1 != '\0');pos1++,pos2++,i++)
|
|
{
|
|
if (*pos1 == '#') /* name immed followed by comment */
|
|
break;
|
|
if (*pos1 == '\\') /* quoted comment (filename has #) */
|
|
{
|
|
++pos1; /* skip escape char */
|
|
if (*pos1 != '#') /* continuation ? */
|
|
{
|
|
puts(" Config error:");
|
|
puts(" Found filename continuation; bailing out\n");
|
|
exit (8);
|
|
}
|
|
}
|
|
*pos2 = *pos1; /* move char */
|
|
}
|
|
*pos2 = '\0'; /* terminate string */
|
|
Tlog = (char *)getmem(strlen(name)+1);
|
|
strcpy(Tlog,name);
|
|
if (! be_quiet)
|
|
printf(" logfile used: %s\n",Tlog);
|
|
logf = TRUE;
|
|
if (statf) /* statsfile still to come ? */
|
|
break; /* no finished */
|
|
continue;
|
|
}
|
|
|
|
if (0 == strncmp(keywrd,"statfile",8))
|
|
{
|
|
pos1 = pos2 = name;
|
|
for (i=0;(i<=MAXPATHLEN && *pos1 != '\0');pos1++,pos2++,i++)
|
|
{
|
|
if (*pos1 == '#') /* name immed followed by comment */
|
|
break;
|
|
if (*pos1 == '\\') /* quoted comment (filename has #) */
|
|
{
|
|
++pos1; /* skip escape char */
|
|
if (*pos1 != '#') /* continuation ? */
|
|
{
|
|
puts(" Config error:");
|
|
puts(" Found filename continuation; bailing out\n");
|
|
exit (8);
|
|
}
|
|
}
|
|
*pos2 = *pos1; /* move char */
|
|
}
|
|
*pos2 = '\0'; /* terminate string */
|
|
Tstat = (char *)getmem(strlen(name)+1);
|
|
strcpy(Tstat,name);
|
|
if (! be_quiet)
|
|
printf(" statfile used: %s\n",Tstat);
|
|
statf = TRUE;
|
|
if (logf) /* logfile still to come ? */
|
|
break; /* no finished */
|
|
continue;
|
|
}
|
|
}
|
|
fclose(Conf);
|
|
}
|
|
|
|
if (! be_quiet)
|
|
{
|
|
if (! logf)
|
|
puts(" logfile used: - default -");
|
|
if (! statf)
|
|
puts(" statfile used: - default -");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------------
|
|
* hdrprt - Print Header/Trailer lines (constant data)
|
|
* ------------------------------------------------------------------
|
|
*/
|
|
|
|
static void hdrprt(char head, int bot)
|
|
{
|
|
switch(head)
|
|
{
|
|
case('s'): /* standard summary report */
|
|
if (bot == 0)
|
|
{
|
|
puts("\nCompact summary:");
|
|
puts("----------------");
|
|
puts("\
|
|
Name of + Files + +------- Bytes/1000 --------+ +------ Time -----+ + Avg CPS +\n\
|
|
site in out inbound outbound total inbound outbound in out\n\
|
|
-------- ---- ---- --------- --------- --------- --------- --------- ----- -----");
|
|
}
|
|
else
|
|
puts("\
|
|
--------------------------------------------------------------------------------");
|
|
break;
|
|
|
|
|
|
case('f'): /* file statistic report */
|
|
if (bot == 0)
|
|
{
|
|
puts("\nFile statistics:");
|
|
puts("----------------");
|
|
puts(" Name of +----------- Inbound -----------+ +---------- Outbound -----------+");
|
|
puts(" site files Bytes/1000 xfr time B/sec files Bytes/1000 xfr time B/sec");
|
|
puts(" -------- ----- ----------- --------- ----- ----- ----------- --------- -----");
|
|
}
|
|
else
|
|
puts("\
|
|
----------------------------------------------------------------------------");
|
|
break;
|
|
|
|
|
|
case('c'): /* calls statistic report */
|
|
if (bot == 0)
|
|
{
|
|
puts("\nCall statistics:");
|
|
puts("----------------");
|
|
puts(" Name of +------- Outbound Calls -------+ +-------- Inbound Calls ------+");
|
|
puts(" site succ. failed total time succ. failed total time");
|
|
puts(" -------- ------ ------ ------ --------- ------ ------ ------ ---------");
|
|
}
|
|
else
|
|
puts("\
|
|
----------------------------------------------------------------------------");
|
|
break;
|
|
|
|
|
|
case('e'): /* efficiency statistic report */
|
|
if (bot == 0)
|
|
{
|
|
puts("\nEfficiency:");
|
|
puts("-----------");
|
|
puts(" Name of +------ Times inbound/outbound -------+");
|
|
puts(" site connected xfr time overhead eff. %");
|
|
puts(" -------- --------- --------- --------- ------");
|
|
}
|
|
else
|
|
puts(" -------------------------------------------------");
|
|
break;
|
|
|
|
case('i'): /* Environment information */
|
|
if (bot == 0)
|
|
{
|
|
puts("\nEnvironment Information:");
|
|
puts("------------------------");
|
|
printf(" Default config: %s\n",D_conf == NULL ?
|
|
noConf:D_conf);
|
|
printf(" Default logfile: %s\n",Tlog);
|
|
printf(" Default statfile: %s\n\n",Tstat);
|
|
}
|
|
break;
|
|
|
|
case('d'): /* Date/time coverage */
|
|
if (bot == 0)
|
|
{
|
|
puts("\n Date coverage of input files:");
|
|
puts(" Name of +----- Start -----+ +------ End ------+");
|
|
puts(" file date time date time");
|
|
puts(" -------- ---------- -------- ---------- --------");
|
|
}
|
|
break;
|
|
|
|
case('p'): /* Protocol stats */
|
|
if (bot == 0)
|
|
{
|
|
puts("\nProtocol packet report:");
|
|
puts("-----------------------");
|
|
puts(" +------- protocol -----+ +--------- Packets ----------+");
|
|
puts("Name of packet window ");
|
|
puts("site typ min max min max sent resent received");
|
|
puts("-------- --- ---- ---- ---- ---- ----------- ------- ----------");
|
|
}
|
|
else
|
|
{
|
|
puts("\nProtocol error report:");
|
|
puts("----------------------");
|
|
puts("Name of +----------------- Error Types --------------------+");
|
|
puts("site typ header checksum order rem-reject");
|
|
puts("-------- --- ----------- ---------- ----------- ----------");
|
|
}
|
|
break;
|
|
|
|
default:
|
|
if (bot == 0)
|
|
{
|
|
puts("\nNo header for this report defined:");
|
|
}
|
|
else
|
|
puts(" ");
|
|
break;
|
|
}
|
|
}
|