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