home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1995 April / Internet Tools.iso / infoserv / gopher / Unix / GopherTools / glog / glog34.c.Z / glog34.c
Encoding:
C/C++ Source or Header  |  1994-04-07  |  40.3 KB  |  1,574 lines
  1. /*** glog34.c -- analysis tool for Unix gopherd logs ***/
  2. /******************** START CONFIGURATION ***************************/
  3.  
  4. /* Define NODETAIL if you don't want detail listings to be kept. Detail 
  5.  * listings can double the pointer memory required and slow things down.
  6.  */
  7.  
  8. /* #define NODETAIL    */  /* uncomment if you DON'T want detail listings */
  9. /* #define NOSEARCHTXT */  /* uncomment if you DON'T want to output WHAT  */
  10.                            /*    was searched for                         */
  11.  
  12. #define MAXGLINESIZE    500 /* Maximum length of a gopher log line */
  13. /******************** END CONFIGURATION ***************************/
  14. /* That was really hard wasn't it :) */
  15.  
  16. /* Bug Reports/suggestions goto */
  17. #define EMAIL "awick@csugrad.cs.vt.edu"
  18.  
  19. #define    GLOG_VERSION "Gopher Log Analyzer 3.4"
  20. /* Version 3.4 4/4/94 awick
  21.  * Improved coding efficiency in ProcessLine() routine
  22.  * Fixed bug when identifying NOPASV ftp types (previously they went
  23.  *  into the error log). If you use the NOPASV patch, you know what I mean.
  24.  * Search Type now shows what word(s) was(were) searched for...UNLESS
  25.  *  NOSEARCHTXT defined
  26.  * Cleaned up the code alot, and changed the way reports are produced
  27.  * Added the -g histograms option
  28.  * Added the -a averaging/estimating stuff
  29.  * Added the -i infile support
  30.  * Added the -o outfile support
  31.  * Added support for VMS dennis_sherman@unc.edu
  32.  *
  33.  * Version 3.3 7/20/93 jdc@selway.umt.edu
  34.  * fixed up main() routine so that: errors on the command line (or -h as
  35.  * first parameter) cause glog to print the help information and abort.
  36.  * fixed up PrintHelp() routine so help message is more understandable
  37.  * changed FILETYPE character from ' ' to 'I' (What about Image?)
  38.  *
  39.  * Version 3.2 
  40.  * Fixed a small bug with search
  41.  *
  42.  * Version 3.1  7/11/93 Andy Wick - awick@csugrad.cs.vt.edu
  43.  * Added supported for the "missing" gopher types, time plots, month
  44.  * reports and several other things that I forgot :)
  45.  * Also added -b and -e options.
  46.  *
  47.  * Version 3.0 
  48.  * by: Andy Wick - awick@csugrad.cs.vt.edu
  49.  * This version is an almost TOTAL rewrite of glog.  It now reads all
  50.  * the information into memory before it does ANYTHING.  It then goes
  51.  * through the arguments one at a time.  So in order to effect something
  52.  * you must change it before the report.  ie.  Argument order matters now.
  53.  *
  54.  * Version 2.2
  55.  * by: Chuck Shotton - cshotton@oac.hsc.uth.tmc.edu
  56.  *
  57.  * Version 2.1 12/29.92
  58.  * by: Michael Mealling - Georgia Institute of Technology
  59.  *       Office of Information Technology
  60.  *       michael.meallingl@oit.gatech.edu
  61.  *
  62.  * Versions 1.0 6/17/92
  63.  * by: Chuck Shotton - U of Texas Health Science Center - Houston,
  64.  *    Office    of Academic Computing
  65.  *    cshotton@oac.hsc.uth.tmc.edu
  66.  */
  67.  
  68.  
  69. #include <stdio.h>
  70. #include <string.h>
  71. /* Some machines don't have a stdlib.  You can remove it if need be
  72.  *  it is here for type checking, usually :) 
  73.  */
  74. #include <stdlib.h>
  75. #ifdef THINK_C
  76. #include <console.h> 
  77. #endif
  78.  
  79. /********************** THINGS THAT EFFECT INPUT/OUTPUT ********************
  80.  
  81. /* These are the different types of data that are currently reconized. 
  82.    Each must be unique and it only effects the output. */
  83. #define FILETYPE    'I'
  84. #define BINARYTYPE    'B'
  85. #define SOUNDTYPE    'S'
  86. #define DIRTYPE        'D'
  87. #define MAILDIRTYPE    'M'
  88. #define FTPTYPE        'F'
  89. #define RANGETYPE    'R'
  90. #define SEARCHTYPE    '?'
  91.  
  92. char     *ROOTNAME = "Root Connections";
  93. char     *AverageStrs[6] = {""," per year"," per month"," per week"," per day",
  94.             " per hour"};
  95.  
  96. /* How they are in your gopher log file */
  97. char    *Days[7] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
  98. char    *Months[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
  99.                    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
  100.  
  101. /* The base file name for gnuplot reports */
  102. char DEFAULTBASE[7] = "gopher"; 
  103. /**********************************************************************/
  104.  
  105. /* GENERAL STUFF */
  106. typedef unsigned char byte;
  107.  
  108. /* Error log link list */
  109. typedef    struct enode_list {
  110.     char      *data;
  111.     struct enode_list *next;
  112. } ELIST_REC, *ELIST_PTR;
  113.  
  114. /* GOPHER LINE STUFF */
  115.  
  116. /* One line of the gopher log is stored in here */
  117. typedef struct gopher_line {
  118.    byte     day;
  119.    byte     month;
  120.    byte        hour;
  121.    short     date;
  122.    char     *hostname;
  123.    char     *path;
  124.    char     type;
  125. } GOPHER_REC, *GOPHER_PTR;
  126.  
  127. /* A Linked list of gopher lines */
  128. typedef    struct node_list {
  129.     GOPHER_PTR      data;
  130.         short         hits;
  131.     struct node_list *next;
  132. }  LIST_REC, *LIST_PTR;
  133.  
  134. /* Main tree */
  135. typedef    struct node_rec    {
  136.     GOPHER_PTR    data;
  137. #ifndef NODETAIL
  138.     LIST_REC     *llist;
  139. #endif
  140.         short         hits;
  141.     struct node_rec    *left, *right;
  142. } NODE_REC, *NODE_PTR;
  143.  
  144. /* The cruft list is a general list for things that aren't parse-able by
  145.  * ProcessLine().  "cruft" kept for historical reasons.
  146.  */
  147. ELIST_PTR     cruft = NULL;
  148.  
  149. /*
  150.  * The following lists are maintained.
  151.  */
  152. NODE_PTR     hosts = NULL;
  153. NODE_PTR     docs  = NULL;
  154. NODE_PTR     dais  = NULL; /* Can't be days because of VMS :) */
  155. NODE_PTR     dates = NULL;
  156. NODE_PTR     types = NULL;
  157. NODE_PTR     times = NULL;
  158.  
  159. long int     TotalConnects = 0;
  160.  
  161. char    *in_file_name = NULL; /* NULL if stdin */
  162.  
  163. /* Used to tell the Info routines that you are starting and stoping */
  164. #define STARTINFO    (GOPHER_PTR)0
  165. #define ENDINFO        (GOPHER_PTR)1
  166.  
  167. /* Width of reports, Width is a major hack, so be careful */
  168. byte     Width     =     62; /* 79 - WIDTHSUB */
  169. #define WIDTHSUB     17  /* The width of the standard print stuff */
  170.  
  171. /* Information */
  172.    /* Internal */
  173. #define NOINFO        0
  174. #define DETAILINFO    1
  175.    /* Changing these will change the command line options also */
  176.    /* Error log requested, but not a valid SORT TYPE */
  177. #define ERRORINFO    'E'
  178.    /* SORT TYPES */
  179. #define DATAINFO     'D'
  180. #define HOSTINFO    'H'
  181. #define WEEKDAYINFO    'W'
  182. #define MONTHDATEINFO    'M'
  183. #define TYPEINFO    'T'
  184. #define TIMEINFO    'I'
  185.  
  186. char *base = DEFAULTBASE;
  187.  
  188. /* Start stop dates */
  189. char start_date[13], stop_date[13];
  190.  
  191. /* Start stop months */
  192. int mbegin = 1, mend = 12;
  193.  
  194. /* Averages */
  195. byte AverageStrPos = 0; /* Everything */
  196. float AverageDiv = 1.0; /* Don't change the value */
  197.  
  198. /* The only forward decleration needed, since I wrote this the pascal way,
  199.  * the way all programs should be written. :) You don't need all the stupid
  200.  * forward declerations, or prototypes.
  201.  */
  202. void PrintInfo(NODE_PTR tree, void print(GOPHER_PTR), int cmp(GOPHER_PTR a, GOPHER_PTR b), byte DetailType);
  203.  
  204. /* Simple define that cleans up the code a little */
  205. #define INFOERROR(str, strparam) {fprintf(stderr, (str), (strparam)); exit(1);}
  206. #define EXITERROR(str) {fprintf(stderr, (str)); exit(1);}
  207. #define HELPERROR(str) {fprintf(stderr, (str)); PrintHelp(stderr,0);}
  208.  
  209. /*******************************/
  210. /* My StrStr, since it is not standard on all unix machines (sun 4.0.3) */
  211. char *mystrstr(char *s1, char *s2)
  212. {
  213. register int len;
  214.  
  215.    if((len = strlen(s2)) == 0)
  216.       return s1;
  217.  
  218.    while (*s1 != '\0')
  219.    {
  220.       if (strncmp(s1, s2, len) == 0)
  221.          return s1;
  222.       s1++;
  223.    }
  224.  
  225.    return NULL;
  226. }
  227. /*******************************/
  228. /* Add item to error log */
  229. ELIST_PTR InsertErrorLog(ELIST_PTR list, char *data)
  230. {
  231. ELIST_PTR temp;
  232. static ELIST_PTR ende;
  233.  
  234.    if (NULL == (temp = (ELIST_PTR)malloc(sizeof(ELIST_REC))))
  235.       EXITERROR("Not enough memory to add to ErrorLog\n");
  236.    if (NULL == (temp->data = (char *)malloc(sizeof(char) * (strlen(data) +1))))
  237.       EXITERROR("Not enough memory to add to ErrorLog\n");
  238.  
  239.    strcpy(temp->data, data);
  240.    temp->next = NULL;
  241.  
  242.    if (list == NULL)
  243.       return (ende = temp);
  244.  
  245.    ende->next = temp;
  246.    ende = ende->next;
  247.  
  248.    return(list);
  249. }
  250. #ifndef NODETAIL
  251. /*******************************/
  252. LIST_PTR InsertDetail(LIST_PTR list, GOPHER_PTR data)
  253. {
  254. LIST_PTR temp;
  255.  
  256.       if (NULL == (temp = (LIST_PTR)malloc(sizeof(LIST_REC))))
  257.          EXITERROR("Not enough memory to add to DetailList\n");
  258.       temp->data = data;
  259.       temp->next = list;
  260.       temp->hits = 1;
  261.       return(temp);
  262. }
  263. #endif
  264. /*******************************/
  265. /* Insert data into tree, if that element is already in the tree
  266.  * then increment the number of hits.  cmp is used to find the location
  267.  * in the tree.
  268.  */
  269.  
  270. NODE_PTR Insert(NODE_PTR tree, GOPHER_PTR data, int cmp(GOPHER_PTR a, GOPHER_PTR b))
  271. {
  272. int i;
  273.  
  274.    if (tree == NULL)
  275.    {
  276.       if (NULL == (tree = (NODE_PTR) malloc(sizeof(NODE_REC))))
  277.          EXITERROR("No memory for InsertHost\n");
  278.       tree->data = data;
  279.       tree->left = tree->right = NULL;
  280. #ifndef NODETAIL
  281.       tree->llist = InsertDetail(NULL, data);
  282. #endif
  283.       tree->hits = 1;
  284.       return(tree);
  285.    }
  286.  
  287.    i=cmp(data, tree->data);
  288.  
  289.    if (i > 0)
  290.       tree->right = Insert(tree->right, data, cmp);
  291.    else if (i<0) 
  292.       tree->left = Insert(tree->left, data, cmp);
  293.    else
  294.    {
  295.       tree->hits += 1;
  296. #ifndef NODETAIL
  297.       tree->llist = InsertDetail(tree->llist, data);
  298. #endif
  299.    }
  300.  
  301.    return(tree);
  302. }
  303. /*******************************/
  304. /* Return the node with the data in the tree, using the cmp routine */
  305. NODE_PTR Find(NODE_PTR tree, GOPHER_PTR data, int cmp(GOPHER_PTR a, GOPHER_PTR b))
  306. {
  307. int i;
  308.  
  309.    if (tree == NULL)
  310.       return (NULL);
  311.  
  312.    i=cmp(data, tree->data);
  313.  
  314.    if (i > 0)
  315.       return(Find(tree->right, data, cmp));
  316.    if (i<0) 
  317.       return(Find(tree->left, data, cmp));
  318.  
  319.    return(tree);
  320. }
  321. /*******************************/
  322. /* Get a single field from temp, and return the new spot */
  323. char *getf(char *temp, char *field)
  324. {
  325.    while(*temp == ' ')
  326.       temp++;
  327.  
  328.    *field = '\0';
  329.    if (*temp == '\n')
  330.       return(temp);
  331.  
  332.    while ((*temp != ' ') && (*temp != '\0'))
  333.      *field++ = *temp++;
  334.  
  335.    *field = '\0';
  336.    return(temp);
  337. }
  338. /*******************************/
  339. int TypesCmp(GOPHER_PTR a, GOPHER_PTR b)
  340. {
  341.    return(a->type - b->type); 
  342. }
  343. /*******************************/
  344. int TimesCmp(GOPHER_PTR a, GOPHER_PTR b)
  345. { 
  346.    return(a->hour - b->hour); 
  347. }
  348. /*******************************/
  349. int HostsCmp(GOPHER_PTR a, GOPHER_PTR b)
  350. { 
  351.    return(strcmp(a->hostname, b->hostname)); 
  352. }
  353. /*******************************/
  354. int DocsCmp(GOPHER_PTR a, GOPHER_PTR b)
  355. { 
  356.    return(strcmp(a->path, b->path)); 
  357. }
  358. /*******************************/
  359. int DaysCmp(GOPHER_PTR a, GOPHER_PTR b)
  360. { 
  361.    return(a->day - b->day); 
  362. }
  363. /*******************************/
  364. int DatesCmp(GOPHER_PTR a, GOPHER_PTR b)
  365. {
  366. int i = a->month - b->month;
  367.    if (i == 0)
  368.       return(a->date - b->date);
  369.    else
  370.       return(i); 
  371. }
  372. /*******************************/
  373. byte MonthStr2Num(char *str)
  374. {
  375. static char lastmonth[4] = "Jan"; /* Who knows if saving the last month */
  376. static int lastmonthnum = 1;      /* really makes it faster */
  377. int i;
  378.  
  379.    if (strcmp(lastmonth, str) == 0)
  380.       return(lastmonthnum);
  381.  
  382.    for(i=0;i<12;i++)
  383.       if (strcmp(Months[i], str) == 0)
  384.       {
  385.          strcpy(lastmonth, Months[i]);
  386.      lastmonthnum = i+1;
  387.      return(lastmonthnum);
  388.       }
  389.    return(13); 
  390. }
  391. /*******************************/
  392. byte DayStr2Num(char *str)
  393. {
  394. static char lastday[4] = "Sun"; /* Same here.  Is there a better way? */
  395. static int lastdaynum = 1;
  396. int i;
  397.  
  398.    if (strcmp(lastday, str) == 0)
  399.       return(lastdaynum);
  400.  
  401.    for(i=0;i<7;i++)
  402.       if (strcmp(Days[i], str) == 0)
  403.       {
  404.          strcpy(lastday, Days[i]);
  405.      lastdaynum = i+1;
  406.      return(lastdaynum);
  407.       }
  408.    return(8); 
  409. }
  410. /*******************************/
  411. /* This routine adds all the data to all the trees.  Now that I have done
  412.  * it this way, I really hate it.  What was I thinking? :)  It makes no
  413.  * sense to have the dates sort be a tree, since it is always the worst
  414.  * case tree :(.  Oh well maybe in 4.0 someone will fix it 
  415.  */
  416. void AddData(GOPHER_PTR data)
  417. {
  418.    if ((data->month >= mbegin) && (data->month <= mend))
  419.    {
  420.       hosts = Insert(hosts, data, HostsCmp);
  421.       docs  = Insert(docs, data, DocsCmp);
  422.       dates = Insert(dates, data, DatesCmp); /* Slow */
  423.       types = Insert(types, data, TypesCmp);
  424.       times = Insert(times, data, TimesCmp); 
  425.       dais  = Insert(dais, data, DaysCmp);
  426.       /* Small hack to have start and stop dates */
  427.       if (start_date[0] == '\0')
  428.       {
  429.          sprintf(start_date, "%s %s %d", Days[data->day-1], Months[data->month-1],
  430.             data->date);
  431.       }
  432.       sprintf(stop_date, "%s %s %d", Days[data->day-1], Months[data->month-1],
  433.          data->date);
  434.       TotalConnects++;
  435.    }
  436. }
  437.  
  438. /*******************************/
  439. /* Process a single line completely.  It checks to make sure it is a 
  440.  * Valid line, if not it inserts it into the cruft
  441.  */
  442. void ProcessLine(char *line)
  443. {
  444. GOPHER_PTR data;
  445. short len;
  446. char *temp; /* Used to save line, incase it is needed for cruft */
  447. char junk[MAXGLINESIZE];
  448. char message1[MAXGLINESIZE];
  449. char message2[MAXGLINESIZE];
  450.  
  451.    if (NULL == (data = (GOPHER_PTR)malloc(sizeof(GOPHER_REC))))
  452.       EXITERROR("Not enough memory to process line. Sorry\n");
  453.  
  454.    temp = line;
  455.  
  456.    temp = getf(temp, junk); /* Day */
  457.    if (8 == (data->day = DayStr2Num(junk))) 
  458.    { /* Not a real day of week */
  459.       free(data);
  460.       cruft = InsertErrorLog(cruft, line);
  461.       return;
  462.    }
  463.    temp = getf(temp, junk); /* Month */
  464.    if (13 == (data->month = MonthStr2Num(junk)))
  465.    { /* Not a real month */
  466.       free(data);
  467.       cruft = InsertErrorLog(cruft, line);
  468.       return;
  469.    }
  470.    temp = getf(temp, junk); /* Date */
  471.    data->date = atoi(junk);
  472.    temp = getf(temp, junk); /* Time */
  473.    junk[3] = '\0';
  474.    data->hour = atoi(junk); /* Hour */
  475.    temp = getf(temp, junk); /* Year */
  476.    temp = getf(temp, junk); /* Process ID */
  477.    temp = getf(temp ,junk); /* Hostname */
  478.    if (junk[0] == ':')
  479.    { /* A colon in the hostfield...baaad */
  480.       free(data);
  481.       cruft = InsertErrorLog(cruft, line);
  482.       return;
  483.    } 
  484.  
  485. /* This one is for that annoying 0.0.0.* IP address then gets stuck
  486.  * in the log when someone is trying to access something you ain't got
  487.  */
  488.    if (strncmp(junk,"0.0.0", 5) == 0)
  489.    { 
  490.       free(data);
  491.       cruft = InsertErrorLog(cruft, line);
  492.       return;
  493.    } 
  494.  
  495.    if (NULL == (data->hostname = (char *)malloc(sizeof(char) * (strlen(junk)+1))))
  496.       EXITERROR("Not enough memory. Sorry\n");
  497.    strcpy(data->hostname, junk);
  498.  
  499.    temp = getf(temp, junk); /* this should make junk[0]=':' */
  500.    if (junk[0] != ':')
  501.    { /* Now we don't have a colon */
  502.       free(data->hostname);
  503.       free(data);
  504.       cruft = InsertErrorLog(cruft, line);
  505.       return;
  506.    } 
  507.    temp = getf(temp, message1);
  508.    temp = getf(temp, message2);
  509.    while((*temp == ' ') && (*temp != '\0'))
  510.        temp++;
  511.    data->path = (char *)malloc(sizeof(char)*(strlen(temp)+1));
  512.    strcpy(data->path, temp);
  513.    data->path[strlen(temp)] = '\0';
  514.  
  515.  
  516.    if (0 != (len = strlen(data->path)))
  517.    {
  518.       if (data->path[len-1] == '\n')
  519.          data->path[len-1] = '\0';
  520.    }
  521.  
  522.    if (strcmp(message1, "Root") == 0)
  523.    {
  524.       data->type = DIRTYPE;
  525.       free(data->path);
  526.       data->path = ROOTNAME;
  527.       AddData(data);
  528.    }
  529.    else if ((strcmp(message1, "retrieved") == 0) && (strcmp(data->path, "/") == 0))
  530.    {
  531.       data->type = DIRTYPE;
  532.       free(data->path);
  533.       data->path = ROOTNAME;
  534.       AddData(data);
  535.    }
  536.    else if (strcmp(message1, "search") == 0)
  537.    {
  538.       strcpy(junk, message2);
  539. #ifdef NOSEARCHTXT
  540. /*This finds and removes everything after the " for " in a search line*/
  541.       if (strncmp(data->path, "for ", 4) == 0)
  542.       {
  543.          /* We found it at the beginning of data->path */
  544.          temp = data->path;
  545.       }
  546.       else if (NULL == (temp = mystrstr(data->path, " for ")))
  547.       { /* No " for " in the search */
  548.          free(data->path);
  549.          free(data->hostname);
  550.          free(data);
  551.          cruft = InsertErrorLog(cruft, line);
  552.          return;
  553.       }
  554.       *temp = '\0';
  555. #endif
  556.       strcat(junk, " "); /* There is at least one space here */
  557.       strcat(junk, data->path);
  558.       free(data->path);
  559.       data->path = (char *)malloc(sizeof(char)*(strlen(junk)+1));
  560.       strcpy(data->path, junk);
  561.       data->type = SEARCHTYPE;
  562.  
  563.       AddData(data);
  564.    }
  565.    /* changed from "ftp:",4 to "ftp",3 because of NO-PASV patch */
  566.    /* which uses ftp-vms: and ftp-nopasv to denote special ftp types */
  567.    else if (strncmp(message2, "ftp", 3) == 0)
  568.    {
  569.       strcpy(junk, data->path); /* Incase there was a space in the path */
  570.       free(data->path); /* Then we have to save off path, since it contains it*/
  571.       data->path = (char *)malloc(sizeof(char)*(strlen(message2)+strlen(junk)-2));
  572.       strcpy(data->path, message2+4);
  573.       if (strlen(junk) > 0)
  574.       {
  575.          strcat(data->path, " ");
  576.          strcat(data->path, junk);
  577.       }
  578.       data->type = FTPTYPE;
  579.  
  580.       AddData(data);
  581.    }
  582.    else if (strcmp(message1, "retrieved") == 0)
  583.    {
  584.       if (data->path[0] == '\0')
  585.       { /* We some how retrieved nothing */
  586.          free(data->path);
  587.          free(data->hostname);
  588.          free(data);
  589.          cruft = InsertErrorLog(cruft, line);
  590.          return;
  591.       } 
  592.  
  593.       if (strcmp(message2, "directory") == 0)
  594.          data->type = DIRTYPE;
  595.       else if (strcmp(message2, "maildir") == 0)
  596.          data->type = MAILDIRTYPE;
  597.       else if (strcmp(message2, "file") == 0)
  598.          data->type = FILETYPE;
  599.       else if (strcmp(message2, "binary") == 0)
  600.          data->type = BINARYTYPE;
  601.       else if (strcmp(message2, "sound") == 0)
  602.          data->type = SOUNDTYPE;
  603.       else if (strcmp(message2, "range") == 0)
  604.          data->type = RANGETYPE;
  605.       else
  606.       {
  607.          free(data->path);
  608.          free(data->hostname);
  609.          free(data);
  610.          cruft = InsertErrorLog(cruft, line);
  611.          return;
  612.       } 
  613.       AddData(data);
  614.  
  615.    }
  616.    else /* wasn't anything we know about, g+ maybe?*/
  617.    {
  618.       free(data->path);
  619.       free(data->hostname);
  620.       free(data);
  621.       cruft = InsertErrorLog(cruft, line);
  622.       return;
  623.    } 
  624.  
  625.    return;
  626. }
  627.  
  628. /*******************************/
  629. /* The main loop for gathering the data from stdin */
  630. void GatherInfo(void)
  631. {
  632. char line[MAXGLINESIZE];
  633. FILE *fp;
  634.  
  635.    start_date[0] = '\0';
  636.  
  637.    if (in_file_name == NULL)
  638.       fp = stdin;
  639.    else if (NULL == (fp = fopen(in_file_name, "r")))
  640.       INFOERROR("Error opening input file %s\n", in_file_name);
  641.    while(!feof(fp))
  642.    {
  643.       fgets(line, MAXGLINESIZE, fp);
  644.       if (feof(fp))
  645.          break;
  646.       ProcessLine(line);
  647.    }
  648. }
  649. /*******************************/
  650. /* These vars are only valid right after a call to TreeTo?List.  I could have
  651.  *  done some fancy var passing, but why bother. :)  All the print/plot/graph
  652.  *  routines should use the G vars.  Which are modified for averages.
  653.  */
  654. LIST_PTR GByNum;
  655. int GByNumMin; /* These two are used for histograms */
  656. int GByNumMax;
  657. int GNodes;
  658. long int GTotalConnects;
  659.  
  660. /*******************************/
  661. /* Insert the data and number of hits that data got, into a sorted (by hits)
  662.  * link list (GByNum).
  663.  */
  664. void InsertSByNum(GOPHER_PTR data, short hits)
  665. {
  666. LIST_PTR temp, temp2;
  667.  
  668.    if (NULL == (temp = (LIST_PTR)malloc(sizeof(LIST_REC))))
  669.       EXITERROR("Not enough memory in InsertByNum\n");
  670.    temp->data = data;
  671.    temp->next = NULL;
  672.    temp->hits = hits;
  673.  
  674. /* Figure out some vars */
  675.    if (hits < GByNumMin)
  676.       GByNumMin = hits;
  677.    if (hits > GByNumMax)
  678.       GByNumMax = hits;
  679.    GNodes++;
  680.    
  681.    if (GByNum == NULL)
  682.       GByNum = temp;
  683.    else if (GByNum->hits < hits)
  684.    {
  685.       temp->next = GByNum;
  686.       GByNum = temp;
  687.    }
  688.    else
  689.    {
  690.       temp2 = GByNum;
  691.       while (temp2->next != NULL)
  692.       {
  693.          if (temp2->next->hits < hits)
  694.      {
  695.         temp->next = temp2->next;
  696.         temp2->next = temp;
  697.         return;
  698.      }
  699.      temp2 = temp2->next;
  700.       }
  701.       temp2->next = temp;
  702.    }
  703. }
  704.  
  705. /*******************************/
  706. /* Place data and hits onto the front of the list GByNum */
  707. void InsertUByNum(GOPHER_PTR data, short hits)
  708. {
  709. LIST_PTR temp;
  710.  
  711.    if (NULL == (temp = (LIST_PTR)malloc(sizeof(LIST_REC))))
  712.       EXITERROR("Not enough memory in InsertUByNum\n");
  713.    temp->data = data;
  714.    temp->next = NULL;
  715.    temp->hits = hits;
  716.  
  717. /* Figure out some vars */
  718.    if (hits < GByNumMin)
  719.       GByNumMin = hits;
  720.    if (hits > GByNumMax)
  721.       GByNumMax = hits;
  722.    GNodes++;
  723.  
  724.    if (GByNum == NULL)
  725.       GByNum = temp;
  726.  
  727.    else
  728.    {
  729.       temp->next = GByNum;
  730.       GByNum = temp;
  731.    }
  732. }
  733. /*******************************/
  734. /* I did two different routines so it would be faster :).  I know this
  735.  * doesn't follow the logic of the rest of the program, but oh well.
  736.  * Do Inorder so that they remain in order, if two have the same
  737.  * num of hits.  S<orted> mean use InsertSByNum. U<nsorted> means use
  738.  * InsertUByNum.
  739.  */
  740. void TreeToSList(NODE_PTR tree)
  741. {
  742.    if (tree == NULL)
  743.       return;
  744.    
  745.    TreeToSList(tree->left);
  746.    InsertSByNum(tree->data, tree->hits);
  747.    TreeToSList(tree->right);
  748. }
  749.  
  750. /*******************************/
  751. /* See above :) */
  752. void TreeToUList(NODE_PTR tree)
  753. {
  754.    if (tree == NULL)
  755.       return;
  756.    
  757.    TreeToUList(tree->right);
  758.    InsertUByNum(tree->data, tree->hits);
  759.    TreeToUList(tree->left);
  760. }
  761.  
  762. /*******************************/
  763. NODE_PTR ListToTree(LIST_PTR list, int cmp(GOPHER_PTR, GOPHER_PTR))
  764. {
  765. NODE_PTR temptree = NULL;
  766.    for(;list != NULL; list = list->next)
  767.       temptree = Insert(temptree, list->data, cmp);
  768.    return(temptree);
  769. }
  770. /*******************************/
  771. void FreeList(LIST_PTR list)
  772. {
  773. LIST_PTR temp;
  774.    while (list != NULL)
  775.    {
  776.       temp = list;
  777.       list = list->next;
  778.       free(temp);
  779.    }
  780. }
  781. /*******************************/
  782. void FreeTree(NODE_PTR tree)
  783. {
  784.    if (tree == NULL)
  785.       return;
  786.    FreeTree(tree->left);
  787.    FreeTree(tree->right);
  788. #ifndef NODETAIL
  789.    FreeList(tree->llist);
  790. #endif
  791.    free(tree);
  792.    return;
  793. }
  794. /*******************************/
  795. int SizeTree(NODE_PTR tree)
  796. {
  797.    if (tree == NULL)
  798.       return 0;
  799.    return (1 + SizeTree(tree->left) + SizeTree(tree->right));
  800. }
  801. /*******************************/
  802. /* Given a string and and len, left justify and fill with fill */
  803. void printl(char *str, int len, char fill)
  804. {
  805.    while (len > 0)
  806.    {
  807.       if (*str == '\n')
  808.          str++;
  809.       if (*str == '\0')
  810.      putc(fill, stdout);
  811.       else
  812.          putc(*str++, stdout);
  813.       len--;
  814.    }
  815. }
  816. /*******************************/
  817. /* Given a string center justify and fill with fill */
  818. void printc(char *str, char fill)
  819. {
  820. int i, len = strlen(str);
  821. int start = (Width + WIDTHSUB - len)/2;
  822.  
  823.    for(i = 0; i < start; i++)
  824.       putc(fill, stdout);
  825.  
  826.    fputs(str, stdout);
  827.  
  828.    if (fill != ' ')
  829.       for(i = start+len; i < Width + WIDTHSUB ; i++)
  830.          putc(fill, stdout);
  831.    putc('\n', stdout);
  832. }
  833. /*******************************/
  834. char *TypeNames(char type)
  835. {
  836.    switch(type)
  837.    {
  838.    case FILETYPE:
  839.       return("File");
  840.    case SOUNDTYPE:
  841.       return("Sound");
  842.    case BINARYTYPE:
  843.       return("Binary File");
  844.    case DIRTYPE:
  845.       return("Directory");
  846.    case MAILDIRTYPE:
  847.       return("Mail Directory");
  848.    case FTPTYPE:
  849.       return("FTP");
  850.    case RANGETYPE:
  851.       return("Range");
  852.    case SEARCHTYPE:
  853.       return("Search");
  854.    }
  855.    return("Unknown");
  856. }
  857. /*******************************/
  858. void PrintData(GOPHER_PTR data)
  859. {
  860.    if (data == STARTINFO)
  861.          printf("Data access%s:\n", AverageStrs[AverageStrPos]);
  862.    else if (data == ENDINFO)
  863.    {
  864.       printf("%d nodes accessed.  Average of %d connections per node.\n",
  865.          GNodes, GTotalConnects/GNodes);
  866.    }
  867.    else
  868.    {
  869.       printf("%c ",data->type);
  870.       printl(data->path, Width - 2, ' ');
  871.    }
  872. }
  873. /*******************************/
  874. void PrintTime(GOPHER_PTR data)
  875. {
  876.    if (data == STARTINFO)
  877.       printf("Times%s:\n", AverageStrs[AverageStrPos]);
  878.    else if (data == ENDINFO)
  879.    {
  880.       printf("Average of %d connections per hour.\n",
  881.          GTotalConnects/GNodes);
  882.    }
  883.    else
  884.    {
  885.       printf("%2d:00",data->hour);
  886.       printl("", Width - 5, ' ');
  887.    }
  888. }
  889. /*******************************/
  890. void PrintType(GOPHER_PTR data)
  891. {
  892. char *temp;
  893.    if (data == STARTINFO)
  894.       printf("Types%s:\n", AverageStrs[AverageStrPos]);
  895.    else if (data == ENDINFO)
  896.    {
  897.       printf("Average of %d connections per type.\n",
  898.          GTotalConnects/GNodes);
  899.    }
  900.    else
  901.    {
  902.       temp = TypeNames(data->type);
  903.       printl(temp, Width, ' ');
  904.    }
  905. }
  906. /*******************************/
  907. void PrintHost(GOPHER_PTR data)
  908. {
  909.    if (data == STARTINFO)
  910.       printf("Hosts%s:\n", AverageStrs[AverageStrPos]);
  911.    else if (data == ENDINFO)
  912.    {
  913.       printf("%d hosts connected.  Average of %d connections per host.\n",
  914.          GNodes, GTotalConnects/GNodes);
  915.    }
  916.    else
  917.    {
  918.       printl(data->hostname, Width, ' ');
  919.    }
  920.  
  921. }
  922. /*******************************/
  923. void PrintDay(GOPHER_PTR data)
  924. {
  925.    if (data == STARTINFO)
  926.       printf("Days%s:\n", AverageStrs[AverageStrPos]);
  927.    else if (data == ENDINFO)
  928.    {
  929.       printf("Average of %d connections per day of week.\n",
  930.          GTotalConnects/GNodes);
  931.    }
  932.    else
  933.    {
  934.       printl(Days[data->day-1], Width, ' ');
  935.    }
  936. }
  937. /*******************************/
  938. void PrintDate(GOPHER_PTR data)
  939. {
  940.    if (data == STARTINFO)
  941.       printf("Dates %s:\n", AverageStrs[AverageStrPos]);
  942.    else if (data == ENDINFO)
  943.    {
  944.       printf("Connections occured on %d different days.\n", GNodes);
  945.       printf("Average of %d connections per day.\n", GTotalConnects/GNodes);
  946.    }
  947.    else
  948.    {
  949.       
  950.       printf("%3s %3s %d", Days[data->day-1], Months[data->month-1], data->date);
  951.       if (data->date < 10)
  952.          printl("\0", Width - 9, ' ');
  953.       else
  954.          printl("\0", Width - 10, ' ');
  955.    }
  956. }
  957. /*******************************/
  958. void PlotData(FILE *rfp, int num, GOPHER_PTR data)
  959. {
  960.    if (data == STARTINFO)
  961.       INFOERROR("Plot of Data is not currently supported. Mail me ideas: %s\n", EMAIL);
  962. }
  963. /*******************************/
  964. void PlotType(FILE *rfp, int num, GOPHER_PTR data)
  965. {
  966. char *temp = NULL;
  967.    if (data == STARTINFO)
  968.    {
  969.       fprintf(rfp,"set xtics (");
  970.    }
  971.    else if (data == ENDINFO)
  972.    {
  973.       fprintf(rfp,"\"\" %d)\n", num);
  974.       fprintf(rfp,"set data style linespoints\n");
  975.       fprintf(rfp,"set tics out\n");
  976.       fprintf(rfp,"set grid\n");
  977.       fprintf(rfp,"set title \"Gopher Usage\"\n");
  978.       fprintf(rfp,"plot \"%s.dat\"\n", base);
  979.    }
  980.    else
  981.    {
  982.       temp = TypeNames(data->type);
  983.       fprintf(rfp,"\"%s\" %d,", temp, num);
  984.    }
  985.  
  986. }
  987. /*******************************/
  988. void PlotHost(FILE *rfp, int num, GOPHER_PTR data)
  989. {
  990.    if (data == STARTINFO)
  991.       INFOERROR("Plot of Hosts is not currently supported.  Mail me ideas: %s\n", EMAIL);
  992. }
  993. /*******************************/
  994. void PlotDay(FILE *rfp, int num, GOPHER_PTR data)
  995. {
  996.    if (data == STARTINFO)
  997.    {
  998.       fprintf(rfp,"set xtics (");
  999.    }
  1000.    else if (data == ENDINFO)
  1001.    {
  1002.       fprintf(rfp,"\"\" %d)\n", num);
  1003.       fprintf(rfp,"set data style linespoints\n");
  1004.       fprintf(rfp,"set tics out\n");
  1005.       fprintf(rfp,"set grid\n");
  1006.       fprintf(rfp,"set title \"Gopher Usage\"\n");
  1007.       fprintf(rfp,"plot \"%s.dat\"\n", base);
  1008.    }
  1009.    else
  1010.    {
  1011.       fprintf(rfp,"\"%s\" %d,",Days[data->day-1], num);
  1012.    }
  1013. }
  1014. /*******************************/
  1015. void PlotTime(FILE *rfp, int num, GOPHER_PTR data)
  1016. {
  1017.    if (data == STARTINFO)
  1018.    {
  1019.       fprintf(rfp,"set xtics (");
  1020.    }
  1021.    else if (data == ENDINFO)
  1022.    {
  1023.       fprintf(rfp,"\"\" %d)\n", num);
  1024.       fprintf(rfp,"set data style linespoints\n");
  1025.       fprintf(rfp,"set tics out\n");
  1026.       fprintf(rfp,"set grid\n");
  1027.       fprintf(rfp,"set title \"Gopher Usage\"\n");
  1028.       fprintf(rfp,"plot \"%s.dat\"\n", base);
  1029.    }
  1030.    else
  1031.    {
  1032.       fprintf(rfp,"\"%2d\" %d,",data->hour, num);
  1033.    }
  1034. }
  1035. /*******************************/
  1036. void PlotDate(FILE *rfp, int num, GOPHER_PTR data)
  1037. {
  1038.    if (data == STARTINFO)
  1039.    {
  1040.       fprintf(rfp,"set xtics (");
  1041.    }
  1042.    else if (data == ENDINFO)
  1043.    {
  1044.       fprintf(rfp,"\"\" %d)\n", num);
  1045.       fprintf(rfp,"set data style linespoints\n");
  1046.       fprintf(rfp,"set tics out\n");
  1047.       fprintf(rfp,"set grid\n");
  1048.       fprintf(rfp,"set title \"Gopher Usage\"\n");
  1049.       fprintf(rfp,"plot \"%s.dat\"\n", base);
  1050.    }
  1051.    else
  1052.    {
  1053.       if ((data->date == 1) || (data->date == 15) || (num == 1))
  1054.          fprintf(rfp,"\"%s/%d\" %d,",Months[data->month-1], data->date, num);
  1055.    }
  1056. }
  1057. #ifndef NODETAIL
  1058. /*******************************/
  1059. void DoDetail(NODE_PTR tree, byte DetailType)
  1060. {
  1061. NODE_PTR newtree;
  1062.    switch(DetailType)
  1063.    {
  1064.    case DATAINFO:
  1065.       newtree = ListToTree(tree->llist, DocsCmp);
  1066.       PrintInfo(newtree, PrintData, DocsCmp, DETAILINFO);
  1067.       break;
  1068.    case HOSTINFO:
  1069.       newtree = ListToTree(tree->llist, HostsCmp);
  1070.       PrintInfo(newtree, PrintHost, HostsCmp, DETAILINFO);
  1071.       break;
  1072.    case WEEKDAYINFO:
  1073.       newtree = ListToTree(tree->llist, DaysCmp);
  1074.       PrintInfo(newtree, PrintDay, DaysCmp, DETAILINFO);
  1075.       break;
  1076.    case MONTHDATEINFO:
  1077.       newtree = ListToTree(tree->llist, DatesCmp);
  1078.       PrintInfo(newtree, PrintDate, DatesCmp, DETAILINFO);
  1079.       break;
  1080.    case TYPEINFO:
  1081.       newtree = ListToTree(tree->llist, TypesCmp);
  1082.       PrintInfo(newtree, PrintType, TypesCmp, DETAILINFO);
  1083.       break;
  1084.    case TIMEINFO:
  1085.       newtree = ListToTree(tree->llist, TimesCmp);
  1086.       PrintInfo(newtree, PrintTime, TimesCmp, DETAILINFO);
  1087.       break;
  1088.    default:
  1089.       newtree = NULL;
  1090.       break;
  1091.    }
  1092.    FreeTree(newtree);
  1093. }
  1094. #endif
  1095. /*******************************/
  1096. void PrintInfo(NODE_PTR tree, void print(GOPHER_PTR), int cmp(GOPHER_PTR a, GOPHER_PTR b), byte DetailType)
  1097. {
  1098. LIST_PTR temp;
  1099. LIST_PTR ByNum;
  1100. int Nodes;
  1101.  
  1102.    GByNum = NULL; /* Init the vars for the TreeToList function */
  1103.    GNodes = 0;
  1104.    TreeToSList(tree);
  1105.  
  1106.    if (DetailType != DETAILINFO)
  1107.    { /* We are not printing Detail info now, so do headers */
  1108.       print(STARTINFO);
  1109.       printc("", '=');
  1110.    }
  1111.  
  1112.    ByNum = GByNum; /* Save off and clear the globals vars */
  1113.    Nodes = GNodes;
  1114.    GByNum = NULL;
  1115.  
  1116.    temp = ByNum;
  1117.    while (temp != NULL)
  1118.    {
  1119. #ifndef NODETAIL
  1120.       if (DetailType == DETAILINFO)
  1121.          printf("   ");
  1122. #endif
  1123.  
  1124.       print(temp->data);
  1125.       printf(" %4d (%2.2f%%)\n", (int)(temp->hits/AverageDiv), (float)temp->hits*100.0/TotalConnects);
  1126. #ifndef NODETAIL
  1127.       if ((DetailType != NOINFO) && (DetailType != DETAILINFO))
  1128.          DoDetail(Find(tree, temp->data, cmp), DetailType);
  1129.      /* Don't generate Detail for NOINFO or if we are already doing detail */
  1130. #endif
  1131.       temp = temp->next;
  1132.    }
  1133.    if (DetailType != DETAILINFO)
  1134.    { /* We are not printing Detail info now, so do footers */
  1135.       printf("\n");
  1136.       GNodes = Nodes; /* Restore, incase detail messed it up */
  1137.       GTotalConnects = TotalConnects/AverageDiv;
  1138.       print(ENDINFO);
  1139.    }
  1140.    printf("\n");
  1141.    FreeList(ByNum);
  1142. }
  1143. /*******************************/
  1144. void PlotInfo(NODE_PTR tree, void plot(FILE *, int, GOPHER_PTR))
  1145. {
  1146. LIST_PTR temp;
  1147. FILE *rfp, *dfp;
  1148. char *fn;
  1149. int points = 1;
  1150.  
  1151.    fn = (char *)malloc(strlen(base) + 5);
  1152.    sprintf(fn,"%s.run", base);
  1153.    if (NULL == (rfp = fopen(fn, "w")))
  1154.    {
  1155.       fprintf(stderr, "Could not open file \"%s\" for plot run\n", fn);
  1156.       free(fn);
  1157.       return;
  1158.    }
  1159.    sprintf(fn,"%s.dat", base);
  1160.    if (NULL == (dfp = fopen(fn, "w")))
  1161.    {
  1162.       fprintf(stderr, "Could not open file \"%s\" for plot data\n", fn);
  1163.       free(fn);
  1164.       return;
  1165.    }
  1166.    free(fn);
  1167.  
  1168.    plot(rfp, 0, STARTINFO);
  1169.    GByNum = NULL; /* Init the vars for the TreeToList function */
  1170.    GByNumMax = 0;
  1171.    GByNumMin = 36000;
  1172.    TreeToUList(tree);
  1173.  
  1174.    temp = GByNum;
  1175.    while (temp != NULL)
  1176.    {
  1177.       plot(rfp, points, temp->data);
  1178.       fprintf(dfp, "%d %d\n", points++, temp->hits);
  1179.       temp = temp->next;
  1180.    }
  1181.    plot(rfp, points, ENDINFO);
  1182.    printf("\n");
  1183.    FreeList(GByNum);
  1184.    fclose(rfp);
  1185.    fclose(dfp);
  1186. }
  1187. /*******************************/
  1188. void GraphInfo(NODE_PTR tree, void graph(GOPHER_PTR), int strwidth)
  1189. {
  1190. LIST_PTR temp;
  1191. LIST_PTR ByNum;
  1192. int Nodes;
  1193. int i, max, oldwidth = Width, MyWidth;
  1194.  
  1195.  
  1196.    GByNum = NULL; /* Init the vars for the TreeToList function */
  1197.    GNodes = 0;
  1198.    GByNumMax = 0;
  1199.    GByNumMin = 36000;
  1200.    TreeToUList(tree);
  1201.  
  1202.    ByNum = GByNum; /* Save off and clear the globals vars */
  1203.    Nodes = GNodes;
  1204.    GByNum = NULL;
  1205.  
  1206.    graph(STARTINFO);
  1207.    printc("", '=');
  1208.  
  1209.    /* Do the width stuff after printc, yes its a major hack. :) */
  1210.    MyWidth = Width - strwidth;
  1211.    Width = strwidth;
  1212.  
  1213.    temp = ByNum;
  1214.    while (temp != NULL)
  1215.    {
  1216.       graph(temp->data);
  1217.       printf(" %4d (%5.2f%%) ", (int)(temp->hits/AverageDiv), (float)temp->hits*100.0/TotalConnects);
  1218.       max = (int)((temp->hits/AverageDiv) * (MyWidth/(float)GByNumMax));
  1219.       for(i=0; i < max; i++)
  1220.      printf("#");
  1221.       printf("\n");
  1222.       temp = temp->next;
  1223.    }
  1224.    GNodes = Nodes; /* Restore */
  1225.    GTotalConnects = TotalConnects/AverageDiv;
  1226.    printf("\n");
  1227.    graph(ENDINFO);
  1228.    printf("\n");
  1229.    FreeList(ByNum);
  1230.    Width=oldwidth;
  1231. }
  1232. /*******************************/
  1233. void PrintErrorInfo(void)
  1234. {
  1235. ELIST_PTR temp = cruft;
  1236.  
  1237.    printf("Exception/Problem Report\n");
  1238.    printf("NOTE: THESE ENTRIES MAY DENOTE A SERVER PROBLEM. THEY SHOULD BE LOOKED OVER!\n");
  1239.    printc("", '=');
  1240.    while (temp != NULL)
  1241.    {
  1242.       printf(temp->data);
  1243.       temp = temp->next;
  1244.    }
  1245.    printf("\n");
  1246. }
  1247.  
  1248. /*******************************/
  1249.  
  1250. void PrintHelp(FILE *fp, int needreturn)
  1251. {
  1252.   fprintf(fp,"\nUsage: glog [<REPORTTYPE> | -%c | -h] ", ERRORINFO);
  1253. #ifdef VMS
  1254.    fprintf(fp,"[OPTIONS] -i INFILENAME [-o OUTFILENAME]\n");
  1255. #else
  1256.    fprintf(fp,"[OPTIONS] [-i INFILENAME] [-o OUTFILENAME]\n");
  1257. #endif
  1258.    fprintf(fp,"  -h prints this help information\n");
  1259.    fprintf(fp,"  -%c displays an ERROR LOG\n", ERRORINFO);
  1260.    fprintf(fp,"  -i INFILENAME specifies the input file (your gopher logfile)\n");
  1261. #ifndef VMS
  1262.    fprintf(fp,"     stdin is expected to be your gopher logfile, unless -i is used\n");
  1263. #endif
  1264.    fprintf(fp,"  -o OUTFILENAME specifies the output file.  If an output file\n");
  1265.    fprintf(fp,"     is not specified, output will be to the screen.\n\n");
  1266.    
  1267.    fprintf(fp,"REPORTTYPE is:\n");
  1268.    fprintf(fp,"   -g<SORTTYPE> for a histogram\n");
  1269.    fprintf(fp,"   -p<SORTTYPE> to output plot data (gnuplot required to display plot)\n");
  1270.    fprintf(fp,"   -r<SORTTYPE>[<SORTTYPE>] for a report [with detail]\n\n");
  1271.    
  1272. #ifdef VMS
  1273.    fprintf(fp,"SORTTYPE is: (must be inclosed in quotes)\n");
  1274. #else
  1275.    fprintf(fp,"SORTTYPE is:\n");
  1276. #endif
  1277.    fprintf(fp,"   %c = Host Names       %c = Day of Week \n",
  1278.       HOSTINFO, WEEKDAYINFO);
  1279.    fprintf(fp,"   %c = Document Names   %c = Month/Day\n",
  1280.     DATAINFO, MONTHDATEINFO);
  1281.    fprintf(fp,"   %c = Type             %c = Time\n\n", TYPEINFO, TIMEINFO);
  1282.    if (needreturn)
  1283.    {
  1284.       fprintf(stderr, "PRESS [ENTER] TO CONTINUE\n");
  1285.       fflush(stderr);
  1286.       getc(stdin);
  1287.    }
  1288.    fprintf(fp,"OPTIONS are\n");
  1289.    fprintf(fp,"   [-b <beginning month #>] [-e <ending month #>]\n");
  1290.    fprintf(fp,"   [-w <width of report>] [-f <base filename for plot>]\n");
  1291.    fprintf(fp,"   [-a<AVERAGETYPE>]\n\n");
  1292. #ifdef VMS
  1293.    fprintf(fp,"AVERAGETYPE is: (must be inclosed in quotes)\n");
  1294. #else
  1295.    fprintf(fp,"AVERAGETYPE is:\n");
  1296. #endif
  1297.    fprintf(fp,"   E = Everything       Y = Per Year\n");
  1298.    fprintf(fp,"   M = Per Month        W = Per Week\n");
  1299.    fprintf(fp,"   D = Per Day          H = Per Hour\n\n");
  1300.    fprintf(fp,"WARNING:  All arguments are evaluated from left to right,\n");
  1301.    fprintf(fp,"   except for -i, -o, -b, and -e.  Which are evaluated only at\n");
  1302.    fprintf(fp,"   the start of execution.  \n\n");
  1303.  
  1304. #ifdef VMS
  1305.    fprintf(fp,"Example: glog -w 132 -g\"I\" -p\"T\" -a\"Y\" -r\"H\" -i gopher.log\n");
  1306.    fprintf(fp,"   (Remember to enclose capital letters in double quotes!)\n");
  1307. #else
  1308.    fprintf(fp,"Example: glog34 -w 132 -gI -pT -aY -rH < gopher.log | more\n");
  1309. #endif /* VMS */
  1310.    fprintf(fp,"Width of 132, give a Time Histogram, a Type Plot and a Host Report.\n");
  1311. #ifdef VMS
  1312.    fprintf(fp,"Input from gopher.log, output to the screen except for the plot data.\n");
  1313. #else
  1314.    fprintf(fp,"Input from gopher.log output to stdout, except for the plot\n");
  1315. #endif /* VMS */
  1316.    fprintf(fp, "The report is made to look like the logfile contained a years worth of data.\n\n");
  1317.  
  1318.    fflush(fp);
  1319. }
  1320.  
  1321. /*******************************/
  1322. void PrintHdr()
  1323. {
  1324. char center[80];
  1325.  
  1326.    printf("\n");
  1327.    printc(GLOG_VERSION,' ');
  1328.    fflush(stdout);
  1329.  
  1330.    sprintf(center, "%s to %s", start_date, stop_date);
  1331.    printc(center, ' ');
  1332.    if (AverageStrPos == 0)
  1333.    {
  1334.       sprintf(center, "%d connections", TotalConnects);
  1335.       printc(center, ' ');
  1336.    }
  1337.    else
  1338.    {
  1339.       sprintf(center, "%d real connections", TotalConnects);
  1340.       printc(center, ' ');
  1341.       printf("\n");
  1342.       sprintf(center, "%d estimated connections%s", 
  1343.           (int)(TotalConnects/AverageDiv), AverageStrs[AverageStrPos]);
  1344.       printc(center, ' ');
  1345.    }
  1346.    printf("\n\n");
  1347.    fflush(stdout);
  1348.    fflush(stderr);
  1349. }
  1350. /*******************************/
  1351. /* Yes I KNOW main is more than 1 page */
  1352. int main(int argc, char **argv)
  1353. { 
  1354. int i;
  1355. int NumOfDays;
  1356.  
  1357. #ifdef THINK_C
  1358.     argc = ccommand(&argv); 
  1359. #endif   
  1360.  
  1361.    if  (1 == argc || argv[1][1] =='h')
  1362.    {
  1363.       PrintHelp(stdout,1); /* Clueless */
  1364.       exit(-1);
  1365.    }
  1366.  
  1367.    i = 1;
  1368. /* We must go through the arguments twice.  Once for the the arguments that
  1369.  * can only be set once.  I could add argument checking here, but why bother
  1370.  */
  1371.    while (i<argc)
  1372.    {
  1373.       if (argv[i][0] == '-')
  1374.       switch (argv[i][1])
  1375.       {
  1376.       case 'b':
  1377.          if (i<argc-1)
  1378.         mbegin = atoi(argv[++i]);
  1379.      else
  1380.         HELPERROR("\nexpected beginning month argument for -b\n");
  1381.          break;
  1382.       case 'e':
  1383.          if (i<argc-1)
  1384.         mend = atoi(argv[++i]);
  1385.      else
  1386.         HELPERROR("\nexpected ending month argument for -e\n");
  1387.          break;
  1388.       case 'i':
  1389.          if (i<argc-1)
  1390.         in_file_name = argv[++i];
  1391.      else
  1392.         HELPERROR("\nexpected input file name for -i\n");
  1393.          break;
  1394.       case 'o':
  1395.          if (i<argc-1)
  1396.          {
  1397.             i++;
  1398.             if (freopen(argv[i], "w", stdout) == NULL)
  1399.                INFOERROR("Unable to open requested output file %s\n", argv[i]);
  1400.          }
  1401.      else
  1402.         HELPERROR("\nexpected output file name for -o\n");
  1403.          break;
  1404.       }
  1405.       i++;
  1406.    }
  1407. #ifdef VMS
  1408.       /* VMS barfs on stdin as input so FORCE filename */
  1409.       if (in_file_name == NULL)
  1410.          EXITERROR("No input file name on command line%\n");
  1411. #endif /* VMS */
  1412.  
  1413.    GatherInfo();
  1414.  
  1415.    if (TotalConnects == 0)
  1416.       EXITERROR("\nNo [matching] data to process\n");
  1417.  
  1418.    NumOfDays = SizeTree(dates);
  1419.    fflush(stdout);
  1420.    fflush(stderr);
  1421.  
  1422.    i = 1;
  1423.    /* Now go through them again and actually do them, from left to right */
  1424.    while (i<argc)
  1425.    {
  1426.       switch (argv[i][1])
  1427.       {
  1428.       case 'a': /* average changes */
  1429.          switch(argv[i][2])
  1430.      {
  1431.      case 'E':
  1432.         AverageStrPos = 0;
  1433.         AverageDiv = 1.0;
  1434.         break;
  1435.      case 'Y':
  1436.         AverageStrPos = 1;
  1437.         AverageDiv = NumOfDays/365.0;
  1438.         break;
  1439.      case 'M':
  1440.         AverageStrPos = 2;
  1441.         AverageDiv = NumOfDays/(365.0/12.0);
  1442.         break;
  1443.      case 'W':
  1444.         AverageStrPos = 3;
  1445.         AverageDiv = NumOfDays/7.0;
  1446.         break;
  1447.      case 'D':
  1448.         AverageStrPos = 4;
  1449.         AverageDiv = NumOfDays;
  1450.         break;
  1451.      case 'H':
  1452.         AverageStrPos = 5;
  1453.         AverageDiv = NumOfDays*24.0;
  1454.         break;
  1455.      }
  1456.      break;
  1457.       case ERRORINFO:
  1458.      PrintErrorInfo();
  1459.      break;
  1460.       case 'r': /*custom reports*/
  1461.      PrintHdr();
  1462.          switch(argv[i][2])
  1463.      {
  1464.          case DATAINFO:
  1465.         PrintInfo(docs, PrintData, DocsCmp, argv[i][3]);
  1466.         break;
  1467.          case TYPEINFO:
  1468.         PrintInfo(types, PrintType, TypesCmp, argv[i][3]);
  1469.         break;
  1470.          case TIMEINFO:
  1471.         PrintInfo(times, PrintTime, TimesCmp, argv[i][3]);
  1472.         break;
  1473.          case WEEKDAYINFO:
  1474.             PrintInfo(dais, PrintDay, DaysCmp, argv[i][3]);
  1475.         break;
  1476.          case MONTHDATEINFO:
  1477.         PrintInfo(dates, PrintDate, DatesCmp, argv[i][3]);
  1478.         break;
  1479.          case HOSTINFO:
  1480.            PrintInfo(hosts, PrintHost, HostsCmp, argv[i][3]);
  1481.         break;
  1482.      default:
  1483.         HELPERROR("expected SORTTYPE argument for -r\n");
  1484.         break;
  1485.      }
  1486.          printf(" \n");
  1487.      break;
  1488.       case 'p': /*custom plots*/
  1489.          switch (argv[i][2])
  1490.      {
  1491.          case DATAINFO:
  1492.             PlotInfo(docs, PlotData);
  1493.         break;
  1494.          case TYPEINFO:
  1495.         PlotInfo(types, PlotType);
  1496.         break;
  1497.          case TIMEINFO:
  1498.         PlotInfo(times, PlotTime);
  1499.         break;
  1500.          case WEEKDAYINFO:
  1501.         PlotInfo(dais, PlotDay);
  1502.         break;
  1503.          case MONTHDATEINFO:
  1504.         PlotInfo(dates, PlotDate);
  1505.         break;
  1506.          case HOSTINFO:
  1507.         PlotInfo(hosts, PlotHost);
  1508.         break;
  1509.      default:
  1510.         HELPERROR("expected SORTTYPE argument for -p\n");
  1511.         break;
  1512.      }
  1513.       break;
  1514.       case 'g': /*custom graphs*/
  1515.      PrintHdr();
  1516.          switch (argv[i][2])
  1517.      {
  1518.          case DATAINFO:
  1519.             GraphInfo(docs, PrintData, 40);
  1520.         break;
  1521.          case TYPEINFO:
  1522.         GraphInfo(types, PrintType, 15);
  1523.         break;
  1524.          case TIMEINFO:
  1525.         GraphInfo(times, PrintTime,15);
  1526.         break;
  1527.          case WEEKDAYINFO:
  1528.         GraphInfo(dais, PrintDay, 15);
  1529.         break;
  1530.          case MONTHDATEINFO:
  1531.         GraphInfo(dates, PrintDate,15);
  1532.         break;
  1533.          case HOSTINFO:
  1534.         GraphInfo(hosts, PrintHost, 35);
  1535.         break;
  1536.      default:
  1537.         HELPERROR("expected SORTTYPE argument for -g\n");
  1538.         break;
  1539.      }
  1540.          printf(" \n");
  1541.       break;
  1542.       case 'w':
  1543.          if (i<argc-1)
  1544.         Width = atoi(argv[++i]) - WIDTHSUB;
  1545.      else
  1546.         HELPERROR("expected width argument for -w\n");
  1547.      break;
  1548.       case 'f':
  1549.          if (i<argc-1)
  1550.         base = argv[++i];
  1551.      else
  1552.         HELPERROR("expected filename argument for -f\n");
  1553.      break;
  1554.       case 'o':
  1555.       case 'i':
  1556.       case 'b':
  1557.       case 'e':
  1558.          i++;   /* Skip over their arguments */
  1559.          break; /* These are before GatherInfo arguments */
  1560.       case '?':
  1561.       default:
  1562.          fprintf(stderr, "Unknown option \"%c\" Use -h for help\n", argv[i][1]);
  1563.      break;
  1564.       } /*switch*/
  1565.     
  1566.       i++; /* next arg...*/
  1567.         
  1568.    } /*while*/
  1569.   
  1570.    exit(0);
  1571. }
  1572.  
  1573.  
  1574.