Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

2042 lines (2010 sloc) 103.482 kb
/*** analog 6.0 http://www.analog.cx/ ***/
/*** This program is copyright (c) Stephen R. E. Turner 1995 - 2004 except as
*** stated otherwise.
***
*** This program is free software. You can redistribute it and/or modify it
*** under the terms of version 2 of the GNU General Public License, which you
*** should have received with it.
***
*** This program is distributed in the hope that it will be useful, but
*** without any warranty, expressed or implied. ***/
/*** globals.c; declaration and initialisation of globals, and defaults ***/
/* See also init.c and init2.c */
#include "anlghea3.h"
/* Program time */
time_t origstarttime, starttime;
timecode_t starttimec, starttimeuxc;
char *starttimestr;
/* NB starttime and starttimec are displaced by TIMEOFFSET in correct(), but
starttimestr (used in warnings) and starttimeuxc (used in DNS) are not. */
/* What to read from input lines */
unsigned int year, month, date, hour, minute, code;
unsigned long unixtime, proctime;
double bytes;
char am;
/* Input processing */
char *block_start, *block_end, *block_bell, *record_start, *pos;
logical termchar[256];
/* Memory allocation */
Memman *xmemman, *amemman, mm[ITEM_NUMBER], mmq, mms;
char *workspace; /* scratch space for aliasing: see note at top of alias.c */
/* NB Be careful not to nest two usages of workspace. */
/* Are we running from form? */
logical cgi = FALSE;
/* DNS lookups: externs so that no worries about whether to pass them around */
#ifndef NODNS
choice dnslevel;
char *dnsfile, *dnslockfile;
FILE *dnsfilep = NULL, *dnslock = NULL;
Hashtable *dnstable;
unsigned int dnsgoodhrs, dnsbadhrs;
#ifndef NOALARM
unsigned int dnstimeout;
JMP_BUF jumpbuf;
#endif
#endif
/* Signal entries for unwanted hash entries (NULL is already used for unset) */
Hashentry *unwanted_entry, *blank_entry;
Hashindex *dummy_item;
/* Translating reports to other arrays */
choice *rep2type, *rep2reqs, *rep2reqs7, *rep2date, *rep2firstd;
unsigned int *rep2gran, *rep2lng, *rep2datefmt, *rep2colhead, *rep2busystr;
unsigned int *col2colhead, *method2sing, *method2pl, *method2date;
unsigned int *method2pc, *method2relpc, *method2sort;
logical *repistree;
char *byteprefix = " kMGTPEZY"; /* Room for growth :) Note initial space */
/* NB Output versions of the byte prefixes are in the language files */
/* Domain levels; making this global is messy but easiest */
Strpairlist **domlevels;
/* Log formats */
Inputformatlist *logformat = NULL, *deflogformat;
logical newloglist = TRUE, iscache = FALSE;
int tz = 0, stz = 0;
choice wantitem[INPUT_NUMBER];
#ifndef NOPIPES
Strpairlist *uncompresshead = NULL;
#endif
/* Debugging, warnings, pretty printing */
FILE *errfile;
char *commandname = NULL, *commandpath = NULL;
char *debug_args = NULL, *warn_args = NULL;
logical anywarns = FALSE, errmess = FALSE, vblesonly = FALSE;
unsigned int errwidth = ERRLINELENGTH;
unsigned long progressfreq = 0;
unsigned int ppcol = 0;
/* What's recorded by cache files. Array size V5_DATA_NUMBER in anlghea3.h. */
/* don't record "last 7" stuff because it won't be correct at read time */
choice cache_records[V5_DATA_NUMBER] = {REQUESTS, PAGES, REDIR, FAIL, SUCCDATE,
REDIRDATE, FAILDATE, SUCCFIRSTD,
REDIRFIRSTD, FAILFIRSTD};
/* Date names for unlocalised text. See also ENGMONTHLEN etc. in anlghea3.h. */
char *engmonths[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",
"Sep", "Oct", "Nov", "Dec"};
char *englongdays[7] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
"Friday", "Saturday"};
char *engshortdays[7] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
/* Names for things, always in order of enums in anlghea3.h */
char *item_type[] = {"virtual hosts", "files", "users", "referrers",
"browsers", "hosts"};
/* In methodname, we don't need them all, because some only occur internally */
char *methodname[] = {"requests","7-day requests", "pages", "7-day pages", "",
"", "", "", "last date", "", "", "first date", "", "",
"bytes", "7-day bytes", "alphabetical", "random"};
/* Filenames for each language, in order of enum in anlghea3.h */
char *country[] = {"am", "baq", /*"ba",*/ "bg", "bgm", "cat", "cn", "tw",
/*"hr",*/ "cz", "cz1", "dk", "nl", "uk", "us", "fi", "fr",
"de", /*"gr",*/ "hu", /*"is",*/ "id", "it", "jpe", "jpj",
"jps", "jpu", "kr", "lv", /*"lt",*/ "no", "no2", "pl", "pt",
"br", /*"ro",*/ "ru", "ru1", "yu", "sk", "sk1", "si", "si1",
"es", "se", "se2", "tr", "ua"};
/* Report code letters in order of enum in anlghea3.h */
/* Any new ones must also be added to reportorder in anlghea2.h */
char repcodes[] = "1QmWDH45dhw67xrEItiSlLofskKBvRMujJZNnYybpzcP";
/* Column code letters in order of enum in anlghea3.h */
char colcodes[] = "xRSPQBCrspqbcdDeEN";
/* Names for the anchors within the report, in the same order */
/* At most eight letters, because we use them as filenames too. (This limit is
assumed in piechart()). */
char *anchorname[] = {"year", "quartly", "month", "week", "dayrep", "hourrep",
"quartrep", "fiverep", "daysum", "hoursum", "weekhour",
"quartsum", "fivesum", "gensum", "req", "redir", "fail",
"type", "dir", "host", "redihost", "failhost", "dom",
"ref", "refsite", "redirref", "failref", "browrep",
"vhost", "redirvh", "failvh", "user", "rediuser",
"failuser", "org", "searchq", "searchw", "isearchq",
"isearchw", "browsum", "os", "size", "code", "proctime"};
/* These report names are in English, so not the same as in langfile */
/* Again in order of enum in anlghea3.h */
char *repname[] = {"Yearly Report", "Quarterly Report", "Monthly Report",
"Weekly Report", "Daily Report", "Hourly Report",
"Quarter-Hour Report", "Five-Minute Report",
"Daily Summary", "Hourly Summary",
"Hour of the Week Summary", "Quarter-Hour Summary",
"Five-Minute Summary", "General Summary", "Request Report",
"Redirection Report", "Failure Report", "File Type Report",
"Directory Report", "Host Report",
"Host Redirection Report", "Host Failure Report",
"Domain Report", "Referrer Report", "Referring Site Report",
"Redirected Referrer Report", "Failed Referrer Report",
"Browser Report", "Virtual Host Report",
"Virtual Host Redirection Report",
"Virtual Host Failure Report", "User Report",
"User Redirection Report", "User Failure Report",
"Organisation Report", "Search Query Report",
"Search Word Report", "Internal Search Query Report",
"Internal Search Word Report", "Browser Summary",
"Operating System Report", "File Size Report",
"Status Code Report", "Processing Time Report"};
#ifdef EBCDIC
/* EBCDIC-to-ASCII tables:
These tables are bijective - there are no ambigous or duplicate characters.
*/
const unsigned char os_toascii[256] = {
#ifdef _OSD_POSIX /* Fujitsu-Siemens' EDF04 character set on BS2000: */
/*00*/ 0x00, 0x01, 0x02, 0x03, 0x85, 0x09, 0x86, 0x7f,
0x87, 0x8d, 0x8e, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, /*................*/
/*10*/ 0x10, 0x11, 0x12, 0x13, 0x8f, 0x0a, 0x08, 0x97,
0x18, 0x19, 0x9c, 0x9d, 0x1c, 0x1d, 0x1e, 0x1f, /*................*/
/*20*/ 0x80, 0x81, 0x82, 0x83, 0x84, 0x92, 0x17, 0x1b,
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x05, 0x06, 0x07, /*................*/
/*30*/ 0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04,
0x98, 0x99, 0x9a, 0x9b, 0x14, 0x15, 0x9e, 0x1a, /*................*/
/*40*/ 0x20, 0xa0, 0xe2, 0xe4, 0xe0, 0xe1, 0xe3, 0xe5,
0xe7, 0xf1, 0x60, 0x2e, 0x3c, 0x28, 0x2b, 0x7c, /* .........`.<(+|*/
/*50*/ 0x26, 0xe9, 0xea, 0xeb, 0xe8, 0xed, 0xee, 0xef,
0xec, 0xdf, 0x21, 0x24, 0x2a, 0x29, 0x3b, 0x9f, /*&.........!$*);.*/
/*60*/ 0x2d, 0x2f, 0xc2, 0xc4, 0xc0, 0xc1, 0xc3, 0xc5,
0xc7, 0xd1, 0x5e, 0x2c, 0x25, 0x5f, 0x3e, 0x3f, /*-/........^,%_>?*/
/*70*/ 0xf8, 0xc9, 0xca, 0xcb, 0xc8, 0xcd, 0xce, 0xcf,
0xcc, 0xa8, 0x3a, 0x23, 0x40, 0x27, 0x3d, 0x22, /*..........:#@'="*/
/*80*/ 0xd8, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
0x68, 0x69, 0xab, 0xbb, 0xf0, 0xfd, 0xfe, 0xb1, /*.abcdefghi......*/
/*90*/ 0xb0, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70,
0x71, 0x72, 0xaa, 0xba, 0xe6, 0xb8, 0xc6, 0xa4, /*.jklmnopqr......*/
/*a0*/ 0xb5, 0xaf, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
0x79, 0x7a, 0xa1, 0xbf, 0xd0, 0xdd, 0xde, 0xae, /*..stuvwxyz......*/
/*b0*/ 0xa2, 0xa3, 0xa5, 0xb7, 0xa9, 0xa7, 0xb6, 0xbc,
0xbd, 0xbe, 0xac, 0x5b, 0x5c, 0x5d, 0xb4, 0xd7, /*...........[\]..*/
/*c0*/ 0xf9, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
0x48, 0x49, 0xad, 0xf4, 0xf6, 0xf2, 0xf3, 0xf5, /*.ABCDEFGHI......*/
/*d0*/ 0xa6, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
0x51, 0x52, 0xb9, 0xfb, 0xfc, 0xdb, 0xfa, 0xff, /*.JKLMNOPQR......*/
/*e0*/ 0xd9, 0xf7, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
0x59, 0x5a, 0xb2, 0xd4, 0xd6, 0xd2, 0xd3, 0xd5, /*..STUVWXYZ......*/
/*f0*/ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
0x38, 0x39, 0xb3, 0x7b, 0xdc, 0x7d, 0xda, 0x7e /*0123456789.{.}.~*/
#elif defined(OS390) || defined(AS400) || defined(TPF) /* IBM's OS/390 and TPF systems: */
/*
Bijective EBCDIC (character set IBM-1047) to US-ASCII table:
*/
0x00, 0x01, 0x02, 0x03, 0x85, 0x09, 0x86, 0x7f, /* 00-0f: */
0x87, 0x8d, 0x8e, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, /* ................ */
0x10, 0x11, 0x12, 0x13, 0x8f, 0x0a, 0x08, 0x97, /* 10-1f: */
0x18, 0x19, 0x9c, 0x9d, 0x1c, 0x1d, 0x1e, 0x1f, /* ................ */
0x80, 0x81, 0x82, 0x83, 0x84, 0x92, 0x17, 0x1b, /* 20-2f: */
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x05, 0x06, 0x07, /* ................ */
0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04, /* 30-3f: */
0x98, 0x99, 0x9a, 0x9b, 0x14, 0x15, 0x9e, 0x1a, /* ................ */
0x20, 0xa0, 0xe2, 0xe4, 0xe0, 0xe1, 0xe3, 0xe5, /* 40-4f: */
0xe7, 0xf1, 0xa2, 0x2e, 0x3c, 0x28, 0x2b, 0x7c, /* ...........<(+| */
0x26, 0xe9, 0xea, 0xeb, 0xe8, 0xed, 0xee, 0xef, /* 50-5f: */
0xec, 0xdf, 0x21, 0x24, 0x2a, 0x29, 0x3b, 0x5e, /* &.........!$*);^ */
0x2d, 0x2f, 0xc2, 0xc4, 0xc0, 0xc1, 0xc3, 0xc5, /* 60-6f: */
0xc7, 0xd1, 0xa6, 0x2c, 0x25, 0x5f, 0x3e, 0x3f, /* -/.........,%_>? */
0xf8, 0xc9, 0xca, 0xcb, 0xc8, 0xcd, 0xce, 0xcf, /* 70-7f: */
0xcc, 0x60, 0x3a, 0x23, 0x40, 0x27, 0x3d, 0x22, /* .........`:#@'=" */
0xd8, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, /* 80-8f: */
0x68, 0x69, 0xab, 0xbb, 0xf0, 0xfd, 0xfe, 0xb1, /* .abcdefghi...... */
0xb0, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, /* 90-9f: */
0x71, 0x72, 0xaa, 0xba, 0xe6, 0xb8, 0xc6, 0xa4, /* .jklmnopqr...... */
0xb5, 0x7e, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, /* a0-af: */
0x79, 0x7a, 0xa1, 0xbf, 0xd0, 0x5b, 0xde, 0xae, /* .~stuvwxyz...[.. */
0xac, 0xa3, 0xa5, 0xb7, 0xa9, 0xa7, 0xb6, 0xbc, /* b0-bf: */
0xbd, 0xbe, 0xdd, 0xa8, 0xaf, 0x5d, 0xb4, 0xd7, /* .............].. */
0x7b, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, /* c0-cf: */
0x48, 0x49, 0xad, 0xf4, 0xf6, 0xf2, 0xf3, 0xf5, /* {ABCDEFGHI...... */
0x7d, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, /* d0-df: */
0x51, 0x52, 0xb9, 0xfb, 0xfc, 0xf9, 0xfa, 0xff, /* }JKLMNOPQR...... */
0x5c, 0xf7, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, /* e0-ef: */
0x59, 0x5a, 0xb2, 0xd4, 0xd6, 0xd2, 0xd3, 0xd5, /* \.STUVWXYZ...... */
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, /* f0-ff: */
0x38, 0x39, 0xb3, 0xdb, 0xdc, 0xd9, 0xda, 0x9f /* 0123456789...... */
#else
#error Unimplemented EBCDIC platform. Please send information about your system to <martin@apache.org>!
#endif
};
/* Bijective ascii-to-ebcdic table: */
const unsigned char os_toebcdic[256] = {
#ifdef _OSD_POSIX /* Fujitsu-Siemens' EDF04 character set on BS2000: */
/*00*/ 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f,
0x16, 0x05, 0x15, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, /*................*/
/*10*/ 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26,
0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f, /*................*/
/*20*/ 0x40, 0x5a, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d,
0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61, /* !"#$%&'()*+,-./ */
/*30*/ 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f, /*0123456789:;<=>?*/
/*40*/ 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, /*@ABCDEFGHIJKLMNO*/
/*50*/ 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6,
0xe7, 0xe8, 0xe9, 0xbb, 0xbc, 0xbd, 0x6a, 0x6d, /*PQRSTUVWXYZ[\]^_*/
/*60*/ 0x4a, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, /*`abcdefghijklmno*/
/*70*/ 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6,
0xa7, 0xa8, 0xa9, 0xfb, 0x4f, 0xfd, 0xff, 0x07, /*pqrstuvwxyz{|}~.*/
/*80*/ 0x20, 0x21, 0x22, 0x23, 0x24, 0x04, 0x06, 0x08,
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x14, /*................*/
/*90*/ 0x30, 0x31, 0x25, 0x33, 0x34, 0x35, 0x36, 0x17,
0x38, 0x39, 0x3a, 0x3b, 0x1a, 0x1b, 0x3e, 0x5f, /*................*/
/*a0*/ 0x41, 0xaa, 0xb0, 0xb1, 0x9f, 0xb2, 0xd0, 0xb5,
0x79, 0xb4, 0x9a, 0x8a, 0xba, 0xca, 0xaf, 0xa1, /*................*/
/*b0*/ 0x90, 0x8f, 0xea, 0xfa, 0xbe, 0xa0, 0xb6, 0xb3,
0x9d, 0xda, 0x9b, 0x8b, 0xb7, 0xb8, 0xb9, 0xab, /*................*/
/*c0*/ 0x64, 0x65, 0x62, 0x66, 0x63, 0x67, 0x9e, 0x68,
0x74, 0x71, 0x72, 0x73, 0x78, 0x75, 0x76, 0x77, /*................*/
/*d0*/ 0xac, 0x69, 0xed, 0xee, 0xeb, 0xef, 0xec, 0xbf,
0x80, 0xe0, 0xfe, 0xdd, 0xfc, 0xad, 0xae, 0x59, /*................*/
/*e0*/ 0x44, 0x45, 0x42, 0x46, 0x43, 0x47, 0x9c, 0x48,
0x54, 0x51, 0x52, 0x53, 0x58, 0x55, 0x56, 0x57, /*................*/
/*f0*/ 0x8c, 0x49, 0xcd, 0xce, 0xcb, 0xcf, 0xcc, 0xe1,
0x70, 0xc0, 0xde, 0xdb, 0xdc, 0x8d, 0x8e, 0xdf /*................*/
#elif defined(OS390) || defined(AS400) || defined(TPF) /* IBM's OS/390 and TPF systems: */
/*
The US-ASCII to EBCDIC (character set IBM-1047) table:
This table is bijective (no ambiguous or duplicate characters)
*/
0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, /* 00-0f: */
0x16, 0x05, 0x15, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, /* ................ */
0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, /* 10-1f: */
0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f, /* ................ */
0x40, 0x5a, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, /* 20-2f: */
0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61, /* !"#$%&'()*+,-./ */
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, /* 30-3f: */
0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f, /* 0123456789:;<=>? */
0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, /* 40-4f: */
0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, /* @ABCDEFGHIJKLMNO */
0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, /* 50-5f: */
0xe7, 0xe8, 0xe9, 0xad, 0xe0, 0xbd, 0x5f, 0x6d, /* PQRSTUVWXYZ[\]^_ */
0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, /* 60-6f: */
0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, /* `abcdefghijklmno */
0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, /* 70-7f: */
0xa7, 0xa8, 0xa9, 0xc0, 0x4f, 0xd0, 0xa1, 0x07, /* pqrstuvwxyz{|}~. */
0x20, 0x21, 0x22, 0x23, 0x24, 0x04, 0x06, 0x08, /* 80-8f: */
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x14, /* ................ */
0x30, 0x31, 0x25, 0x33, 0x34, 0x35, 0x36, 0x17, /* 90-9f: */
0x38, 0x39, 0x3a, 0x3b, 0x1a, 0x1b, 0x3e, 0xff, /* ................ */
0x41, 0xaa, 0x4a, 0xb1, 0x9f, 0xb2, 0x6a, 0xb5, /* a0-af: */
0xbb, 0xb4, 0x9a, 0x8a, 0xb0, 0xca, 0xaf, 0xbc, /* ................ */
0x90, 0x8f, 0xea, 0xfa, 0xbe, 0xa0, 0xb6, 0xb3, /* b0-bf: */
0x9d, 0xda, 0x9b, 0x8b, 0xb7, 0xb8, 0xb9, 0xab, /* ................ */
0x64, 0x65, 0x62, 0x66, 0x63, 0x67, 0x9e, 0x68, /* c0-cf: */
0x74, 0x71, 0x72, 0x73, 0x78, 0x75, 0x76, 0x77, /* ................ */
0xac, 0x69, 0xed, 0xee, 0xeb, 0xef, 0xec, 0xbf, /* d0-df: */
0x80, 0xfd, 0xfe, 0xfb, 0xfc, 0xba, 0xae, 0x59, /* ................ */
0x44, 0x45, 0x42, 0x46, 0x43, 0x47, 0x9c, 0x48, /* e0-ef: */
0x54, 0x51, 0x52, 0x53, 0x58, 0x55, 0x56, 0x57, /* ................ */
0x8c, 0x49, 0xcd, 0xce, 0xcb, 0xcf, 0xcc, 0xe1, /* f0-ff: */
0x70, 0xdd, 0xde, 0xdb, 0xdc, 0x8d, 0x8e, 0xdf /* ................ */
#else
#error Unimplemented EBCDIC platform. Please send information about your system to <martin@apache.org>!
#endif
};
#endif
logical convertchar[256] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 00 - 0F */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 10 - 1F */
1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 20 - 2F */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, /* 30 - 3F */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 40 - 4F */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 50 - 5F */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 60 - 6F */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, /* 70 - 7F */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 80 - 8F */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 90 - 9F */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* A0 - AF */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* B0 - BF */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* C0 - CF */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* D0 - DF */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* E0 - EF */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; /* F0 - FF */
/* %nm escapes to convert in do_alias(r|f). We convert all ASCII printable
characters (0x20 - 0x7E) with the exception of % (0x25) [to distinguish
%25ab from %ab]; and ? (0x3f), & (0x26), ; (0x3b) and = (0x3d) [to split
query strings up correctly]. Could argue for + (0x2b) in query strings, but
messes search reports up if we do this. */
logical unprintable[256];
/* Unprintable chars for the reports. This is charset dependent. But NB not the
same as isctrl() or !isprint() even for ASCII range. */
/* The outputters */
Outputter cro_outputter =
{cro_pagewidth, cro_cgihead, cro_stylehead, cro_pagetitle, cro_timings,
cro_closehead, cro_pagebotstart, cro_credit, cro_runtime, cro_pagefoot,
cro_stylefoot, cro_reporttitle, cro_reportfooter, cro_reportdesc,
cro_reportspan, cro_gensumhead, cro_gensumfoot, cro_gensumline,
cro_gensumlineb, cro_lastseven, cro_prestart, cro_preend, cro_hrule,
cro_endash, cro_putch, cro_strlength, cro_allowmonth, cro_calcwidths,
cro_declareunit, cro_colheadstart, cro_colheadcol, cro_colheadend,
cro_colheadustart, cro_colheadunderline, cro_colheaduend, cro_rowstart,
cro_levelcell, cro_namecell, cro_ulcell, cro_strcell, cro_bytescell,
cro_pccell, cro_indexcell, cro_rowend, cro_blankline, cro_barchart,
cro_busyprintf, cro_notlistedstr, cro_whatincluded, NULL, NULL, NULL, NULL,
cro_includefile, cro_riscosfiletype};
Outputter html_outputter =
{html_pagewidth, html_cgihead, html_stylehead, html_pagetitle, html_timings,
html_closehead, html_pagebotstart, html_credit, html_runtime, html_pagefoot,
html_stylefoot, html_reporttitle, html_reportfooter, html_reportdesc,
html_reportspan, html_gensumhead, html_gensumfoot, html_gensumline,
html_gensumlineb, html_lastseven, html_prestart, html_preend, html_hrule,
html_endash, html_putch, html_strlength, html_allowmonth, html_calcwidths,
html_declareunit, html_colheadstart, html_colheadcol, html_colheadend,
html_colheadustart, html_colheadunderline, html_colheaduend, html_rowstart,
html_levelcell, html_namecell, html_ulcell, html_strcell, html_bytescell,
html_pccell, html_indexcell, html_rowend, html_blankline, html_barchart,
html_busyprintf, html_notlistedstr, html_whatincluded, html_whatinchead,
html_whatincfoot, html_whatincprintstr, html_printdouble, html_includefile,
html_riscosfiletype};
Outputter latex_outputter =
{latex_pagewidth, latex_cgihead, latex_stylehead, latex_pagetitle,
latex_timings, latex_closehead, latex_pagebotstart, latex_credit,
latex_runtime, latex_pagefoot, latex_stylefoot, latex_reporttitle,
latex_reportfooter, latex_reportdesc, latex_reportspan, latex_gensumhead,
latex_gensumfoot, latex_gensumline, latex_gensumlineb, latex_lastseven,
latex_prestart, latex_preend, latex_hrule, latex_endash, latex_putch,
latex_strlength, latex_allowmonth, latex_calcwidths, latex_declareunit,
latex_colheadstart, latex_colheadcol, latex_colheadend, latex_colheadustart,
latex_colheadunderline, latex_colheaduend, latex_rowstart, latex_levelcell,
latex_namecell, latex_ulcell, latex_strcell, latex_bytescell, latex_pccell,
latex_indexcell, latex_rowend, latex_blankline, latex_barchart,
latex_busyprintf, latex_notlistedstr, latex_whatincluded, latex_whatinchead,
latex_whatincfoot, latex_whatincprintstr, latex_printdouble,
latex_includefile, latex_riscosfiletype};
Outputter plain_outputter =
{plain_pagewidth, plain_cgihead, plain_stylehead, plain_pagetitle,
plain_timings, plain_closehead, plain_pagebotstart, plain_credit,
plain_runtime, plain_pagefoot, plain_stylefoot, plain_reporttitle,
plain_reportfooter, plain_reportdesc, plain_reportspan, plain_gensumhead,
plain_gensumfoot, plain_gensumline, plain_gensumlineb, plain_lastseven,
plain_prestart, plain_preend, plain_hrule, plain_endash, plain_putch,
plain_strlength, plain_allowmonth, plain_calcwidths, plain_declareunit,
plain_colheadstart, plain_colheadcol, plain_colheadend, plain_colheadustart,
plain_colheadunderline, plain_colheaduend, plain_rowstart, plain_levelcell,
plain_namecell, plain_ulcell, plain_strcell, plain_bytescell, plain_pccell,
plain_indexcell, plain_rowend, plain_blankline, plain_barchart,
plain_busyprintf, plain_notlistedstr, plain_whatincluded, plain_whatinchead,
plain_whatincfoot, plain_whatincprintstr, plain_printdouble,
plain_includefile, plain_riscosfiletype};
Outputter xhtml_outputter =
{xhtml_pagewidth, xhtml_cgihead, xhtml_stylehead, xhtml_pagetitle,
xhtml_timings, xhtml_closehead, xhtml_pagebotstart, xhtml_credit,
xhtml_runtime, xhtml_pagefoot, xhtml_stylefoot, xhtml_reporttitle,
xhtml_reportfooter, xhtml_reportdesc, xhtml_reportspan, xhtml_gensumhead,
xhtml_gensumfoot, xhtml_gensumline, xhtml_gensumlineb, xhtml_lastseven,
xhtml_prestart, xhtml_preend, xhtml_hrule, xhtml_endash, xhtml_putch,
xhtml_strlength, xhtml_allowmonth, xhtml_calcwidths, xhtml_declareunit,
xhtml_colheadstart, xhtml_colheadcol, xhtml_colheadend, xhtml_colheadustart,
xhtml_colheadunderline, xhtml_colheaduend, xhtml_rowstart, xhtml_levelcell,
xhtml_namecell, xhtml_ulcell, xhtml_strcell, xhtml_bytescell, xhtml_pccell,
xhtml_indexcell, xhtml_rowend, xhtml_blankline, xhtml_barchart,
xhtml_busyprintf, xhtml_notlistedstr, xhtml_whatincluded, xhtml_whatinchead,
xhtml_whatincfoot, xhtml_whatincprintstr, xhtml_printdouble,
xhtml_includefile, xhtml_riscosfiletype};
Outputter xml_outputter =
{xml_pagewidth, xml_cgihead, xml_stylehead, xml_pagetitle, xml_timings,
xml_closehead, xml_pagebotstart, xml_credit, xml_runtime, xml_pagefoot,
xml_stylefoot, xml_reporttitle, xml_reportfooter, xml_reportdesc,
xml_reportspan, xml_gensumhead, xml_gensumfoot, xml_gensumline,
xml_gensumlineb, xml_lastseven, xml_prestart, xml_preend, xml_hrule,
xml_endash, xml_putch, xml_strlength, xml_allowmonth, xml_calcwidths,
xml_declareunit, xml_colheadstart, xml_colheadcol, xml_colheadend,
xml_colheadustart, xml_colheadunderline, xml_colheaduend, xml_rowstart,
xml_levelcell, xml_namecell, xml_ulcell, xml_strcell, xml_bytescell,
xml_pccell, xml_indexcell, xml_rowend, xml_blankline, xml_barchart,
xml_busyprintf, xml_notlistedstr, xml_whatincluded, xml_whatinchead,
xml_whatincfoot, xml_whatincprintstr, xml_printdouble, xml_includefile,
xml_riscosfiletype};
Inputfns inpfns[] = { /* first the ITEM fns in any order */
/* See also ITEMFNS_NUMBER in anlghea3.c */
/* Also, some letters, namely those with &parsestring and other codes that
take following separators (see list in strtoinfmt() in init.c), need to be
included in the list in report_logfmt() in settings.c. */
{'v', ITEM_VHOST, &parsestring, &mm[ITEM_VHOST]},
{'r', ITEM_FILE, &parsestring, &mm[ITEM_FILE]},
{'u', ITEM_USER, &parsestring, &mm[ITEM_USER]},
{'f', ITEM_REFERRER, &parsestring, &mm[ITEM_REFERRER]},
{'B', ITEM_BROWSER, &parsestring, &mm[ITEM_BROWSER]},
{'S', ITEM_HOST, &parsestring, &mm[ITEM_HOST]},
{'F', ITEM_REFERRER, &parseref, &mm[ITEM_REFERRER]},
{'A', ITEM_BROWSER, &parsemsbrow, &mm[ITEM_BROWSER]},
{'q', INP_QUERY, &parsestring, &mmq},
{'s', INP_IP, &parsestring, &mms},
{'n', INP_MIN, &parseuint2strict, (void *)&minute},
{'h', INP_HOUR, &parseuint2, (void *)&hour},
{'a', INP_AM, &parseam, (void *)&am},
{'d', INP_DATE, &parseuint2, (void *)&date},
{'m', INP_MONTH, &parsenmonth, (void *)&month},
{'M', INP_MONTH, &parsemonth, (void *)&month},
{'y', INP_YEAR, &parseyear2, (void *)&year},
{'Y', INP_YEAR, &parseuint4strict, (void *)&year},
{'Z', INP_YEAR, &parseyear2or4, (void *)&year},
{'U', INP_UNIXTIME, &parseunixtime, (void *)&unixtime},
{'T', INP_PROCTIME, &parseunixtime, (void *)&proctime},
{'t', INP_PROCTIME, &parseproctime, (void *)&proctime},
{'D', INP_PROCTIME, &parseproctimeu, (void *)&proctime},
{'c', INP_CODE, &parsescode, (void *)&code},
{'C', INP_CODE, &parsecode, (void *)&code},
{'b', INP_BYTES, &parseudint, (void *)&bytes},
{'w', UNSET, &parsespace, NULL},
{'W', UNSET, &parseoptspace, NULL},
{'j', UNSET, &parsejunk, NULL},
{'x', UNSET, &parselogfmt, NULL},
{'\0', UNSET, &checkchar, NULL} /* this one must be last as marker */
};
Inputfns pnlinpfn = {'\n', UNSET, &parsenewline, NULL};
Inputfns ccinpfn = {'\0', UNSET, &checkchar, NULL};
Inputfns pjinpfn = {'j', UNSET, &parsejunk, NULL};
Options opts;
/* So that in future we can have several sets of options, and yet still
declare cf[] neatly as below, we shunt them in and out of opts */
Configfns cf[] = {
{"TIMECOLS", &configallcols, (void *)(opts.outopts.cols)},
{"YEARCOLS", &configcols, (void *)(opts.outopts.cols[REP_YEAR])},
{"QUARTERLYCOLS", &configcols, (void *)(opts.outopts.cols[REP_QUARTERLY])},
{"MONTHCOLS", &configcols, (void *)(opts.outopts.cols[REP_MONTH])},
{"WEEKCOLS", &configcols, (void *)(opts.outopts.cols[REP_WEEK])},
{"DAYREPCOLS", &configcols, (void *)(opts.outopts.cols[REP_DAYREP])},
{"FULLDAYCOLS", &configcols, (void *)(opts.outopts.cols[REP_DAYREP])},
{"DAYSUMCOLS", &configcols, (void *)(opts.outopts.cols[REP_DAYSUM])},
{"DAYCOLS", &configcols, (void *)(opts.outopts.cols[REP_DAYSUM])},
{"HOURREPCOLS", &configcols, (void *)(opts.outopts.cols[REP_HOURREP])},
{"FULLHOURCOLS", &configcols, (void *)(opts.outopts.cols[REP_HOURREP])},
{"HOURSUMCOLS", &configcols, (void *)(opts.outopts.cols[REP_HOURSUM])},
{"HOURCOLS", &configcols, (void *)(opts.outopts.cols[REP_HOURSUM])},
{"WEEKHOURCOLS", &configcols,
(void *)(opts.outopts.cols[REP_WEEKHOUR])},
{"QUARTERREPCOLS", &configcols, (void *)(opts.outopts.cols[REP_QUARTERREP])},
{"QUARTERCOLS", &configcols, (void *)(opts.outopts.cols[REP_QUARTERREP])},
{"QUARTERSUMCOLS", &configcols, (void *)(opts.outopts.cols[REP_QUARTERSUM])},
{"FIVEREPCOLS", &configcols, (void *)(opts.outopts.cols[REP_FIVEREP])},
{"FIVECOLS", &configcols, (void *)(opts.outopts.cols[REP_FIVEREP])},
{"FIVESUMCOLS", &configcols, (void *)(opts.outopts.cols[REP_FIVESUM])},
{"REQCOLS", &configcols, (void *)(opts.outopts.cols[REP_REQ])},
{"REDIRCOLS", &configcols, (void *)(opts.outopts.cols[REP_REDIR])},
{"FAILCOLS", &configcols, (void *)(opts.outopts.cols[REP_FAIL])},
{"TYPECOLS", &configcols, (void *)(opts.outopts.cols[REP_TYPE])},
{"SIZECOLS", &configcols, (void *)(opts.outopts.cols[REP_SIZE])},
{"PROCTIMECOLS", &configcols, (void *)(opts.outopts.cols[REP_PROCTIME])},
{"DIRCOLS", &configcols, (void *)(opts.outopts.cols[REP_DIR])},
{"HOSTCOLS", &configcols, (void *)(opts.outopts.cols[REP_HOST])},
{"REDIRHOSTCOLS", &configcols, (void *)(opts.outopts.cols[REP_REDIRHOST])},
{"FAILHOSTCOLS", &configcols, (void *)(opts.outopts.cols[REP_FAILHOST])},
{"DOMCOLS", &configcols, (void *)(opts.outopts.cols[REP_DOM])},
{"ORGCOLS", &configcols, (void *)(opts.outopts.cols[REP_ORG])},
{"REFCOLS", &configcols, (void *)(opts.outopts.cols[REP_REF])},
{"REFSITECOLS", &configcols, (void *)(opts.outopts.cols[REP_REFSITE])},
{"REDIRREFCOLS", &configcols, (void *)(opts.outopts.cols[REP_REDIRREF])},
{"FAILREFCOLS", &configcols, (void *)(opts.outopts.cols[REP_FAILREF])},
{"BROWREPCOLS", &configcols, (void *)(opts.outopts.cols[REP_BROWREP])},
{"FULLBROWCOLS", &configcols, (void *)(opts.outopts.cols[REP_BROWREP])},
{"BROWSUMCOLS", &configcols, (void *)(opts.outopts.cols[REP_BROWSUM])},
{"BROWCOLS", &configcols, (void *)(opts.outopts.cols[REP_BROWSUM])},
{"OSCOLS", &configcols, (void *)(opts.outopts.cols[REP_OS])},
{"VHOSTCOLS", &configcols, (void *)(opts.outopts.cols[REP_VHOST])},
{"REDIRVHOSTCOLS", &configcols, (void *)(opts.outopts.cols[REP_REDIRVHOST])},
{"FAILVHOSTCOLS", &configcols, (void *)(opts.outopts.cols[REP_FAILVHOST])},
{"USERCOLS", &configcols, (void *)(opts.outopts.cols[REP_USER])},
{"REDIRUSERCOLS", &configcols, (void *)(opts.outopts.cols[REP_REDIRUSER])},
{"FAILUSERCOLS", &configcols, (void *)(opts.outopts.cols[REP_FAILUSER])},
{"SEARCHQUERYCOLS", &configcols, (void *)(opts.outopts.cols[REP_SEARCHREP])},
{"SEARCHWORDCOLS", &configcols, (void *)(opts.outopts.cols[REP_SEARCHSUM])},
{"INTSEARCHQUERYCOLS", &configcols,
(void *)(opts.outopts.cols[REP_INTSEARCHREP])},
{"INTSEARCHWORDCOLS", &configcols,
(void *)(opts.outopts.cols[REP_INTSEARCHSUM])},
{"STATUSCOLS", &configcols, (void *)(opts.outopts.cols[REP_CODE])},
{"YEARGRAPH", &configgraph, (void *)&(opts.outopts.graph[REP_YEAR])},
{"QUARTERLYGRAPH", &configgraph,
(void *)&(opts.outopts.graph[REP_QUARTERLY])},
{"MONTHGRAPH", &configgraph, (void *)&(opts.outopts.graph[REP_MONTH])},
{"WEEKGRAPH", &configgraph, (void *)&(opts.outopts.graph[REP_WEEK])},
{"DAYREPGRAPH", &configgraph, (void *)&(opts.outopts.graph[REP_DAYREP])},
{"FULLDAYGRAPH", &configgraph, (void *)&(opts.outopts.graph[REP_DAYREP])},
{"DAYSUMGRAPH", &configgraph, (void *)&(opts.outopts.graph[REP_DAYSUM])},
{"DAYGRAPH", &configgraph, (void *)&(opts.outopts.graph[REP_DAYSUM])},
{"HOURREPGRAPH", &configgraph, (void *)&(opts.outopts.graph[REP_HOURREP])},
{"FULLHOURGRAPH", &configgraph, (void *)&(opts.outopts.graph[REP_HOURREP])},
{"HOURSUMGRAPH", &configgraph, (void *)&(opts.outopts.graph[REP_HOURSUM])},
{"HOURGRAPH", &configgraph, (void *)&(opts.outopts.graph[REP_HOURSUM])},
{"WEEKHOURGRAPH", &configgraph, (void *)&(opts.outopts.graph[REP_WEEKHOUR])},
{"QUARTERREPGRAPH", &configgraph,
(void *)&(opts.outopts.graph[REP_QUARTERREP])},
{"QUARTERGRAPH", &configgraph,
(void *)&(opts.outopts.graph[REP_QUARTERREP])},
{"QUARTERSUMGRAPH", &configgraph,
(void *)&(opts.outopts.graph[REP_QUARTERSUM])},
{"FIVEREPGRAPH", &configgraph, (void *)&(opts.outopts.graph[REP_FIVEREP])},
{"FIVEGRAPH", &configgraph, (void *)&(opts.outopts.graph[REP_FIVEREP])},
{"FIVESUMGRAPH", &configgraph, (void *)&(opts.outopts.graph[REP_FIVESUM])},
{"ALLGRAPH", &configallgraph, (void *)(opts.outopts.graph)},
{"ALLGRAPHS", &configallgraph, (void *)(opts.outopts.graph)},
#ifndef NOGRAPHICS
{"REQCHART", &configchoice, (void *)&(opts.outopts.chartby[G(REP_REQ)])},
{"REDIRCHART", &configchoice, (void *)&(opts.outopts.chartby[G(REP_REDIR)])},
{"FAILCHART", &configchoice, (void *)&(opts.outopts.chartby[G(REP_FAIL)])},
{"TYPECHART", &configchoice, (void *)&(opts.outopts.chartby[G(REP_TYPE)])},
{"SIZECHART", &configchoice, (void *)&(opts.outopts.chartby[G(REP_SIZE)])},
{"PROCTIMECHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_PROCTIME)])},
{"DIRCHART", &configchoice, (void *)&(opts.outopts.chartby[G(REP_DIR)])},
{"HOSTCHART", &configchoice, (void *)&(opts.outopts.chartby[G(REP_HOST)])},
{"REDIRHOSTCHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_REDIRHOST)])},
{"FAILHOSTCHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_FAILHOST)])},
{"DOMCHART", &configchoice, (void *)&(opts.outopts.chartby[G(REP_DOM)])},
{"ORGCHART", &configchoice, (void *)&(opts.outopts.chartby[G(REP_ORG)])},
{"REFCHART", &configchoice, (void *)&(opts.outopts.chartby[G(REP_REF)])},
{"REFSITECHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_REFSITE)])},
{"REDIRREFCHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_REDIRREF)])},
{"FAILREFCHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_FAILREF)])},
{"BROWREPCHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_BROWREP)])},
{"BROWSUMCHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_BROWSUM)])},
{"OSCHART", &configchoice, (void *)&(opts.outopts.chartby[G(REP_OS)])},
{"VHOSTCHART", &configchoice, (void *)&(opts.outopts.chartby[G(REP_VHOST)])},
{"REDIRVHOSTCHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_REDIRVHOST)])},
{"FAILVHOSTCHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_FAILVHOST)])},
{"USERCHART", &configchoice, (void *)&(opts.outopts.chartby[G(REP_USER)])},
{"REDIRUSERCHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_REDIRUSER)])},
{"FAILUSERCHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_FAILUSER)])},
{"SEARCHQUERYCHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_SEARCHREP)])},
{"SEARCHWORDCHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_SEARCHSUM)])},
{"INTSEARCHQUERYCHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_INTSEARCHREP)])},
{"INTSEARCHWORDCHART", &configchoice,
(void *)&(opts.outopts.chartby[G(REP_INTSEARCHSUM)])},
{"STATUSCHART", &configchoice, (void *)&(opts.outopts.chartby[G(REP_CODE)])},
{"ALLCHART", &configallchart, (void *)(opts.outopts.chartby)},
{"ALLCHARTS", &configallchart, (void *)(opts.outopts.chartby)},
{"REQCHARTEXPAND", &configstrlist,
(void *)&(opts.outopts.expandhead[G(REP_REQ)])},
{"REDIRCHARTEXPAND", &configstrlist,
(void *)&(opts.outopts.expandhead[G(REP_REDIR)])},
{"FAILCHARTEXPAND", &configstrlist,
(void *)&(opts.outopts.expandhead[G(REP_FAIL)])},
{"TYPECHARTEXPAND", &configstrlist,
(void *)&(opts.outopts.expandhead[G(REP_TYPE)])},
{"DIRCHARTEXPAND", &configstrlist,
(void *)&(opts.outopts.expandhead[G(REP_DIR)])},
{"DOMCHARTEXPAND", &configstrlist, /* NB special case in configstrlist */
(void *)&(opts.outopts.expandhead[G(REP_DOM)])},
{"ORGCHARTEXPAND", &configstrlist,
(void *)&(opts.outopts.expandhead[G(REP_ORG)])},
{"REFCHARTEXPAND", &configstrlist,
(void *)&(opts.outopts.expandhead[G(REP_REF)])},
{"REFSITECHARTEXPAND", &configstrlist,
(void *)&(opts.outopts.expandhead[G(REP_REFSITE)])},
{"REDIRREFCHARTEXPAND", &configstrlist,
(void *)&(opts.outopts.expandhead[G(REP_REDIRREF)])},
{"FAILREFCHARTEXPAND", &configstrlist,
(void *)&(opts.outopts.expandhead[G(REP_FAILREF)])},
{"BROWSUMCHARTEXPAND", &configstrlist,
(void *)&(opts.outopts.expandhead[G(REP_BROWSUM)])},
{"BROWCHARTEXPAND", &configstrlist,
(void *)&(opts.outopts.expandhead[G(REP_BROWSUM)])},
{"OSCHARTEXPAND", &configstrlist,
(void *)&(opts.outopts.expandhead[G(REP_OS)])},
{"CHARTDIR", &configstr, (void *)&(opts.outopts.chartdir)},
{"LOCALCHARTDIR", &configstr, (void *)&(opts.outopts.localchartdir)},
#ifdef HAVE_GD
{"JPEGCHARTS", &configchoice, (void *)&(opts.outopts.jpegcharts)},
#endif
#endif /* NOGRAPHICS */
{"PNGIMAGES", &configchoice, (void *)&(opts.outopts.pngimages)},
{"BARSTYLE", &configbarstyle, (void *)&(opts.outopts.barstyle)},
{"COMPSEP", &configstr, (void *)&(opts.outopts.compsep)},
{"PRESEP", &configstr, (void *)&(opts.outopts.compsep)},
{"HOSTNAME", &configstr, (void *)&(opts.outopts.hostname)},
{"HOSTURL", &configstr, (void *)&(opts.outopts.hosturl)},
{"LOGO", &configstr, (void *)&(opts.outopts.logo)},
{"LOGOURL", &configstr, (void *)&(opts.outopts.logourl)},
{"STYLESHEET", &configstr, (void *)&(opts.outopts.stylesheet)},
{"CSSPREFIX", &configstr, (void *)&(opts.outopts.cssprefix)},
{"BASEURL", &configstr, (void *)&(opts.outopts.baseurl)},
{"LOGFORMAT", &configlogfmt, (void *)&logformat},
{"DEFAULTLOGFORMAT", &configlogfmt, (void *)&deflogformat},
{"APACHELOGFORMAT", &configapachelogfmt, (void *)&logformat},
{"APACHEDEFAULTLOGFORMAT", &configapachelogfmt, (void *)&deflogformat},
{"TIMEOFFSET", &configoffset, (void *)&stz},
{"LOGTIMEOFFSET", &configoffset, (void *)&tz},
{"LOGFILE", &configlogfile, (void *)(opts.miscopts.logfile)},
{"CACHEFILE", &configcachefile, (void *)(opts.miscopts.logfile)},
{"IMAGEDIR", &configstr, (void *)&(opts.outopts.imagedir)},
{"HEADERFILE", &configstr, (void *)&(opts.outopts.headerfile)},
{"FOOTERFILE", &configstr, (void *)&(opts.outopts.footerfile)},
{"LANGUAGE", &configlang, (void *)&(opts.outopts.lang)},
{"LANGFILE", &configstr, (void *)&(opts.outopts.lang.file)},
{"OUTFILE", &configoutfile, (void *)&(opts.outopts.outfile)},
{"CACHEOUTFILE", &configstr, (void *)&(opts.outopts.cacheoutfile)},
{"ERRFILE", &configerrfile, (void *)&errfile},
{"DOMAINSFILE", &configstr, (void *)&(opts.outopts.domainsfile)},
{"DESCFILE", &configstr, (void *)&(opts.outopts.descfile)},
{"DIRSUFFIX", &configstr, (void *)&(opts.miscopts.dirsuffix)},
{"SEPCHAR", &configchar, (void *)&(opts.outopts.sepchar)},
{"REPSEPCHAR", &configchar, (void *)&(opts.outopts.repsepchar)},
{"DECPOINT", &configchar, (void *)&(opts.outopts.decpt)},
{"DECPT", &configchar, (void *)&(opts.outopts.decpt)},
{"MARKCHAR", &configchar, (void *)&(opts.outopts.markchar)},
{"REQFLOOR", &configfloor, (void *)&(opts.outopts.floor[G(REP_REQ)])},
{"REQARGSFLOOR", &configfloor, (void *)&(opts.outopts.subfloor[G(REP_REQ)])},
{"REDIRFLOOR", &configfloor, (void *)&(opts.outopts.floor[G(REP_REDIR)])},
{"REDIRARGSFLOOR", &configfloor,
(void *)&(opts.outopts.subfloor[G(REP_REDIR)])},
{"FAILFLOOR", &configfloor, (void *)&(opts.outopts.floor[G(REP_FAIL)])},
{"FAILARGSFLOOR", &configfloor,
(void *)&(opts.outopts.subfloor[G(REP_FAIL)])},
{"TYPEFLOOR", &configfloor, (void *)&(opts.outopts.floor[G(REP_TYPE)])},
{"SUBTYPEFLOOR", &configfloor,
(void *)&(opts.outopts.subfloor[G(REP_TYPE)])},
{"DIRFLOOR", &configfloor, (void *)&(opts.outopts.floor[G(REP_DIR)])},
{"SUBDIRFLOOR", &configfloor, (void *)&(opts.outopts.subfloor[G(REP_DIR)])},
{"HOSTFLOOR", &configfloor, (void *)&(opts.outopts.floor[G(REP_HOST)])},
{"REDIRHOSTFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_REDIRHOST)])},
{"FAILHOSTFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_FAILHOST)])},
{"DOMFLOOR", &configfloor, (void *)&(opts.outopts.floor[G(REP_DOM)])},
{"SUBDOMFLOOR", &configfloor, (void *)&(opts.outopts.subfloor[G(REP_DOM)])},
{"ORGFLOOR", &configfloor, (void *)&(opts.outopts.floor[G(REP_ORG)])},
{"SUBORGFLOOR", &configfloor, (void *)&(opts.outopts.subfloor[G(REP_ORG)])},
{"REFFLOOR", &configfloor, (void *)&(opts.outopts.floor[G(REP_REF)])},
{"REFARGSFLOOR", &configfloor, (void *)&(opts.outopts.subfloor[G(REP_REF)])},
{"REFSITEFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_REFSITE)])},
{"REFDIRFLOOR", &configfloor,
(void *)&(opts.outopts.subfloor[G(REP_REFSITE)])},
{"SUBREFSITEFLOOR", &configfloor,
(void *)&(opts.outopts.subfloor[G(REP_REFSITE)])},
{"REDIRREFFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_REDIRREF)])},
{"REDIRREFARGSFLOOR", &configfloor,
(void *)&(opts.outopts.subfloor[G(REP_REDIRREF)])},
{"FAILREFFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_FAILREF)])},
{"FAILREFARGSFLOOR", &configfloor,
(void *)&(opts.outopts.subfloor[G(REP_FAILREF)])},
{"BROWREPFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_BROWREP)])},
{"FULLBROWFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_BROWREP)])},
{"BROWSUMFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_BROWSUM)])},
{"BROWFLOOR", &configfloor, (void *)&(opts.outopts.floor[G(REP_BROWSUM)])},
{"SUBBROWFLOOR", &configfloor,
(void *)&(opts.outopts.subfloor[G(REP_BROWSUM)])},
{"OSFLOOR", &configfloor, (void *)&(opts.outopts.floor[G(REP_OS)])},
{"SUBOSFLOOR", &configfloor, (void *)&(opts.outopts.subfloor[G(REP_OS)])},
{"VHOSTFLOOR", &configfloor, (void *)&(opts.outopts.floor[G(REP_VHOST)])},
{"REDIRVHOSTFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_REDIRVHOST)])},
{"FAILVHOSTFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_FAILVHOST)])},
{"USERFLOOR", &configfloor, (void *)&(opts.outopts.floor[G(REP_USER)])},
{"REDIRUSERFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_REDIRUSER)])},
{"FAILUSERFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_FAILUSER)])},
{"SEARCHQUERYFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_SEARCHREP)])},
{"SEARCHWORDFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_SEARCHSUM)])},
{"INTSEARCHQUERYFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_INTSEARCHREP)])},
{"INTSEARCHWORDFLOOR", &configfloor,
(void *)&(opts.outopts.floor[G(REP_INTSEARCHSUM)])},
{"STATUSFLOOR", &configfloor, (void *)&(opts.outopts.floor[G(REP_CODE)])},
{"FILEALIAS", &configalias, (void *)&(opts.aliashead[ITEM_FILE])},
{"HOSTALIAS", &configalias, (void *)&(opts.aliashead[ITEM_HOST])},
{"REFALIAS", &configalias, (void *)&(opts.aliashead[ITEM_REFERRER])},
{"BROWALIAS", &configalias, (void *)&(opts.aliashead[ITEM_BROWSER])},
{"USERALIAS", &configalias, (void *)&(opts.aliashead[ITEM_USER])},
{"VHOSTALIAS", &configalias, (void *)&(opts.aliashead[ITEM_VHOST])},
{"SEARCHENGINE", &configstrpair2list, (void *)&(opts.searchengines)},
{"INTSEARCHENGINE", &configstrpair2list, (void *)&(opts.intsearchengines)},
{"REQALIAS", &configalias, (void *)&(opts.outopts.aliashead[G(REP_REQ)])},
{"REQOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_REQ)])},
{"REDIRALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_REDIR)])},
{"REDIROUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_REDIR)])},
{"FAILALIAS", &configalias, (void *)&(opts.outopts.aliashead[G(REP_FAIL)])},
{"FAILOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_FAIL)])},
{"TYPEALIAS", &configalias, (void *)&(opts.outopts.aliashead[G(REP_TYPE)])},
{"TYPEOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_TYPE)])},
{"DIRALIAS", &configalias, (void *)&(opts.outopts.aliashead[G(REP_DIR)])},
{"DIROUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_DIR)])},
{"HOSTREPALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_HOST)])},
{"HOSTOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_HOST)])},
{"REDIRHOSTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_REDIRHOST)])},
{"REDIRHOSTOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_REDIRHOST)])},
{"FAILHOSTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_FAILHOST)])},
{"FAILHOSTOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_FAILHOST)])},
{"DOMALIAS", &configalias, (void *)&(opts.outopts.aliashead[G(REP_DOM)])},
{"DOMOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_DOM)])},
{"ORGALIAS", &configalias, (void *)&(opts.outopts.aliashead[G(REP_ORG)])},
{"ORGOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_ORG)])},
{"REFREPALIAS", &configalias, (void *)&(opts.outopts.aliashead[G(REP_REF)])},
{"REFOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_REF)])},
{"REFSITEALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_REFSITE)])},
{"REFSITEOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_REFSITE)])},
{"REDIRREFALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_REDIRREF)])},
{"REDIRREFOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_REDIRREF)])},
{"FAILREFALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_FAILREF)])},
{"FAILREFOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_FAILREF)])},
{"BROWREPALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_BROWREP)])},
{"BROWREPOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_BROWREP)])},
{"FULLBROWOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_BROWREP)])},
{"BROWSUMALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_BROWSUM)])},
{"BROWSUMOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_BROWSUM)])},
{"BROWOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_BROWSUM)])},
{"OSALIAS", &configalias, (void *)&(opts.outopts.aliashead[G(REP_OS)])},
{"OSOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_OS)])},
{"VHOSTREPALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_VHOST)])},
{"VHOSTOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_VHOST)])},
{"REDIRVHOSTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_REDIRVHOST)])},
{"REDIRVHOSTOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_REDIRVHOST)])},
{"FAILVHOSTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_FAILVHOST)])},
{"FAILVHOSTOUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_FAILVHOST)])},
{"USERREPALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_USER)])},
{"USEROUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_USER)])},
{"REDIRUSERALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_REDIRUSER)])},
{"REDIRUSEROUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_REDIRUSER)])},
{"FAILUSERALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_FAILUSER)])},
{"FAILUSEROUTPUTALIAS", &configalias,
(void *)&(opts.outopts.aliashead[G(REP_FAILUSER)])},
#ifndef NOPIPES
{"UNCOMPRESS", &configstrpairlist, (void *)&uncompresshead},
#endif
{"REQARGS", &configtree, (void *)&(opts.outopts.tree[G(REP_REQ)])},
{"REDIRARGS", &configtree, (void *)&(opts.outopts.tree[G(REP_REDIR)])},
{"FAILARGS", &configtree, (void *)&(opts.outopts.tree[G(REP_FAIL)])},
{"REFARGS", &configtree, (void *)&(opts.outopts.tree[G(REP_REF)])},
{"REDIRREFARGS", &configtree, (void *)&(opts.outopts.tree[G(REP_REDIRREF)])},
{"FAILREFARGS", &configtree, (void *)&(opts.outopts.tree[G(REP_FAILREF)])},
{"SUBDOMAIN", &configtree, (void *)&(opts.outopts.tree[G(REP_DOM)])},
{"SUBDOM", &configtree, (void *)&(opts.outopts.tree[G(REP_DOM)])},
{"SUBDIR", &configtree, (void *)&(opts.outopts.tree[G(REP_DIR)])},
{"SUBTYPE", &configtree, (void *)&(opts.outopts.tree[G(REP_TYPE)])},
{"REFDIR", &configtree, (void *)&(opts.outopts.tree[G(REP_REFSITE)])},
{"SUBREFSITE", &configtree, (void *)&(opts.outopts.tree[G(REP_REFSITE)])},
{"SUBBROW", &configtree, (void *)&(opts.outopts.tree[G(REP_BROWSUM)])},
{"SUBOS", &configtree, (void *)&(opts.outopts.tree[G(REP_OS)])},
{"SUBORG", &configstrlist, (void *)&(opts.outopts.suborgs)},
{"SUBORG2", &configtree, (void *)&(opts.outopts.tree[G(REP_ORG)])},
/* have to postpone SUBORG's until domains file has been read */
{"FILEINCLUDE", &configinc, (void *)&(opts.wanthead[ITEM_FILE])},
{"FILEEXCLUDE", &configexc, (void *)&(opts.wanthead[ITEM_FILE])},
{"HOSTINCLUDE", &confighostinc, (void *)&(opts.wanthead[ITEM_HOST])},
{"HOSTEXCLUDE", &confighostexc, (void *)&(opts.wanthead[ITEM_HOST])},
{"REFINCLUDE", &configinc, (void *)&(opts.wanthead[ITEM_REFERRER])},
{"REFEXCLUDE", &configexc, (void *)&(opts.wanthead[ITEM_REFERRER])},
{"BROWINCLUDE", &configinc, (void *)&(opts.wanthead[ITEM_BROWSER])},
{"BROWEXCLUDE", &configexc, (void *)&(opts.wanthead[ITEM_BROWSER])},
{"USERINCLUDE", &configinc, (void *)&(opts.wanthead[ITEM_USER])},
{"USEREXCLUDE", &configexc, (void *)&(opts.wanthead[ITEM_USER])},
{"VHOSTINCLUDE", &configinc, (void *)&(opts.wanthead[ITEM_VHOST])},
{"VHOSTEXCLUDE", &configexc, (void *)&(opts.wanthead[ITEM_VHOST])},
{"STATUSINCLUDE", &configscinc, (void *)(opts.code2type)},
{"STATUSEXCLUDE", &configscexc, (void *)(opts.code2type)},
{"304ISSUCCESS", &configchoice, (void *)&(opts.succ304)},
{"REQINCLUDE", &configinc, (void *)&(opts.outopts.wanthead[G(REP_REQ)])},
{"REQEXCLUDE", &configexc, (void *)&(opts.outopts.wanthead[G(REP_REQ)])},
{"REDIRINCLUDE", &configinc, (void *)&(opts.outopts.wanthead[G(REP_REDIR)])},
{"REDIREXCLUDE", &configexc, (void *)&(opts.outopts.wanthead[G(REP_REDIR)])},
{"FAILINCLUDE", &configinc, (void *)&(opts.outopts.wanthead[G(REP_FAIL)])},
{"FAILEXCLUDE", &configexc, (void *)&(opts.outopts.wanthead[G(REP_FAIL)])},
{"TYPEINCLUDE", &configincd, (void *)&(opts.outopts.wanthead[G(REP_TYPE)])},
{"TYPEEXCLUDE", &configexcd, (void *)&(opts.outopts.wanthead[G(REP_TYPE)])},
{"DIRINCLUDE", &configincs, (void *)&(opts.outopts.wanthead[G(REP_DIR)])},
{"DIREXCLUDE", &configexcs, (void *)&(opts.outopts.wanthead[G(REP_DIR)])},
{"HOSTREPINCLUDE", &confighostinc,
(void *)&(opts.outopts.wanthead[G(REP_HOST)])},
{"HOSTREPEXCLUDE", &confighostexc,
(void *)&(opts.outopts.wanthead[G(REP_HOST)])},
{"REDIRHOSTINCLUDE", &confighostinc,
(void *)&(opts.outopts.wanthead[G(REP_REDIRHOST)])},
{"REDIRHOSTEXCLUDE", &confighostexc,
(void *)&(opts.outopts.wanthead[G(REP_REDIRHOST)])},
{"FAILHOSTINCLUDE", &confighostinc,
(void *)&(opts.outopts.wanthead[G(REP_FAILHOST)])},
{"FAILHOSTEXCLUDE", &confighostexc,
(void *)&(opts.outopts.wanthead[G(REP_FAILHOST)])},
{"DOMINCLUDE", &configincd, (void *)&(opts.outopts.wanthead[G(REP_DOM)])},
{"DOMEXCLUDE", &configexcd, (void *)&(opts.outopts.wanthead[G(REP_DOM)])},
{"ORGINCLUDE", &configinc, (void *)&(opts.outopts.wanthead[G(REP_ORG)])},
{"ORGEXCLUDE", &configexc, (void *)&(opts.outopts.wanthead[G(REP_ORG)])},
{"REFREPINCLUDE", &configinc, (void *)&(opts.outopts.wanthead[G(REP_REF)])},
{"REFREPEXCLUDE", &configexc, (void *)&(opts.outopts.wanthead[G(REP_REF)])},
{"REFSITEINCLUDE", &configincs,
(void *)&(opts.outopts.wanthead[G(REP_REFSITE)])},
{"REFSITEEXCLUDE", &configexcs,
(void *)&(opts.outopts.wanthead[G(REP_REFSITE)])},
{"REDIRREFINCLUDE", &configinc,
(void *)&(opts.outopts.wanthead[G(REP_REDIRREF)])},
{"REDIRREFEXCLUDE", &configexc,
(void *)&(opts.outopts.wanthead[G(REP_REDIRREF)])},
{"FAILREFINCLUDE", &configinc,
(void *)&(opts.outopts.wanthead[G(REP_FAILREF)])},
{"FAILREFEXCLUDE", &configexc,
(void *)&(opts.outopts.wanthead[G(REP_FAILREF)])},
{"BROWSUMINCLUDE", &configinc,
(void *)&(opts.outopts.wanthead[G(REP_BROWSUM)])},
{"BROWSUMEXCLUDE", &configexc,
(void *)&(opts.outopts.wanthead[G(REP_BROWSUM)])},
{"BROWREPINCLUDE", &configinc,
(void *)&(opts.outopts.wanthead[G(REP_BROWREP)])},
{"BROWREPEXCLUDE", &configexc,
(void *)&(opts.outopts.wanthead[G(REP_BROWREP)])},
{"FULLBROWINCLUDE", &configinc,
(void *)&(opts.outopts.wanthead[G(REP_BROWREP)])},
{"FULLBROWEXCLUDE", &configexc,
(void *)&(opts.outopts.wanthead[G(REP_BROWREP)])},
{"OSINCLUDE", &configinc, (void *)&(opts.outopts.wanthead[G(REP_OS)])},
{"OSEXCLUDE", &configexc, (void *)&(opts.outopts.wanthead[G(REP_OS)])},
{"VHOSTREPINCLUDE", &configinc,
(void *)&(opts.outopts.wanthead[G(REP_VHOST)])},
{"VHOSTREPEXCLUDE", &configexc,
(void *)&(opts.outopts.wanthead[G(REP_VHOST)])},
{"REDIRVHOSTINCLUDE", &configinc,
(void *)&(opts.outopts.wanthead[G(REP_REDIRVHOST)])},
{"REDIRVHOSTEXCLUDE", &configexc,
(void *)&(opts.outopts.wanthead[G(REP_REDIRVHOST)])},
{"FAILVHOSTINCLUDE", &configinc,
(void *)&(opts.outopts.wanthead[G(REP_FAILVHOST)])},
{"FAILVHOSTEXCLUDE", &configexc,
(void *)&(opts.outopts.wanthead[G(REP_FAILVHOST)])},
{"USERREPINCLUDE", &configinc,
(void *)&(opts.outopts.wanthead[G(REP_USER)])},
{"USERREPEXCLUDE", &configexc,
(void *)&(opts.outopts.wanthead[G(REP_USER)])},
{"REDIRUSERINCLUDE", &configinc,
(void *)&(opts.outopts.wanthead[G(REP_REDIRUSER)])},
{"REDIRUSEREXCLUDE", &configexc,
(void *)&(opts.outopts.wanthead[G(REP_REDIRUSER)])},
{"FAILUSERINCLUDE", &configinc,
(void *)&(opts.outopts.wanthead[G(REP_FAILUSER)])},
{"FAILUSEREXCLUDE", &configexc,
(void *)&(opts.outopts.wanthead[G(REP_FAILUSER)])},
{"SEARCHQUERYINCLUDE", &configinc,
(void *)&(opts.outopts.wanthead[G(REP_SEARCHREP)])},
{"SEARCHQUERYEXCLUDE", &configexc,
(void *)&(opts.outopts.wanthead[G(REP_SEARCHREP)])},
{"SEARCHWORDINCLUDE", &configinc,
(void *)&(opts.outopts.wanthead[G(REP_SEARCHSUM)])},
{"SEARCHWORDEXCLUDE", &configexc,
(void *)&(opts.outopts.wanthead[G(REP_SEARCHSUM)])},
{"INTSEARCHQUERYINCLUDE", &configinc,
(void *)&(opts.outopts.wanthead[G(REP_INTSEARCHREP)])},
{"INTSEARCHQUERYEXCLUDE", &configexc,
(void *)&(opts.outopts.wanthead[G(REP_INTSEARCHREP)])},
{"INTSEARCHWORDINCLUDE", &configinc,
(void *)&(opts.outopts.wanthead[G(REP_INTSEARCHSUM)])},
{"INTSEARCHWORDEXCLUDE", &configexc,
(void *)&(opts.outopts.wanthead[G(REP_INTSEARCHSUM)])},
{"LINKINCLUDE", &configinc, (void *)&(opts.outopts.link[G(REP_REQ)])},
{"LINKEXCLUDE", &configexc, (void *)&(opts.outopts.link[G(REP_REQ)])},
{"REQLINKINCLUDE", &configinc, (void *)&(opts.outopts.link[G(REP_REQ)])},
{"REQLINKEXCLUDE", &configexc, (void *)&(opts.outopts.link[G(REP_REQ)])},
{"REDIRLINKINCLUDE", &configinc, (void *)&(opts.outopts.link[G(REP_REDIR)])},
{"REDIRLINKEXCLUDE", &configexc, (void *)&(opts.outopts.link[G(REP_REDIR)])},
{"FAILLINKINCLUDE", &configinc, (void *)&(opts.outopts.link[G(REP_FAIL)])},
{"FAILLINKEXCLUDE", &configexc, (void *)&(opts.outopts.link[G(REP_FAIL)])},
{"REFLINKINCLUDE", &configinc, (void *)&(opts.outopts.link[G(REP_REF)])},
{"REFLINKEXCLUDE", &configexc, (void *)&(opts.outopts.link[G(REP_REF)])},
{"REDIRREFLINKINCLUDE", &configinc,
(void *)&(opts.outopts.link[G(REP_REDIRREF)])},
{"REDIRREFLINKEXCLUDE", &configexc,
(void *)&(opts.outopts.link[G(REP_REDIRREF)])},
{"FAILREFLINKINCLUDE", &configinc,
(void *)&(opts.outopts.link[G(REP_FAILREF)])},
{"FAILREFLINKEXCLUDE", &configexc,
(void *)&(opts.outopts.link[G(REP_FAILREF)])},
{"ARGSINCLUDE", &configinc, (void *)&(opts.argshead)},
{"ARGSEXCLUDE", &configexc, (void *)&(opts.argshead)},
{"REFARGSINCLUDE", &configinc, (void *)&(opts.refargshead)},
{"REFARGSEXCLUDE", &configexc, (void *)&(opts.refargshead)},
{"PAGEINCLUDE", &configinc, (void *)&(opts.ispagehead)},
{"PAGEEXCLUDE", &configexc, (void *)&(opts.ispagehead)},
{"ROBOTINCLUDE", &configinc, (void *)&(opts.robots)},
{"ROBOTEXCLUDE", &configexc, (void *)&(opts.robots)},
{"REQSORTBY", &configchoice, (void *)&(opts.outopts.sortby[G(REP_REQ)])},
{"REQARGSSORTBY", &configchoice,
(void *)&(opts.outopts.subsortby[G(REP_REQ)])},
{"REDIRSORTBY", &configchoice, (void *)&(opts.outopts.sortby[G(REP_REDIR)])},
{"REDIRARGSSORTBY", &configchoice,
(void *)&(opts.outopts.subsortby[G(REP_REDIR)])},
{"FAILSORTBY", &configchoice, (void *)&(opts.outopts.sortby[G(REP_FAIL)])},
{"FAILARGSSORTBY", &configchoice,
(void *)&(opts.outopts.subsortby[G(REP_FAIL)])},
{"TYPESORTBY", &configchoice, (void *)&(opts.outopts.sortby[G(REP_TYPE)])},
{"SUBTYPESORTBY", &configchoice,
(void *)&(opts.outopts.subsortby[G(REP_TYPE)])},
{"DIRSORTBY", &configchoice, (void *)&(opts.outopts.sortby[G(REP_DIR)])},
{"SUBDIRSORTBY", &configchoice,
(void *)&(opts.outopts.subsortby[G(REP_DIR)])},
{"HOSTSORTBY", &configchoice, (void *)&(opts.outopts.sortby[G(REP_HOST)])},
{"REDIRHOSTSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_REDIRHOST)])},
{"FAILHOSTSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_FAILHOST)])},
{"DOMSORTBY", &configchoice, (void *)&(opts.outopts.sortby[G(REP_DOM)])},
{"SUBDOMSORTBY", &configchoice,
(void *)&(opts.outopts.subsortby[G(REP_DOM)])},
{"ORGSORTBY", &configchoice, (void *)&(opts.outopts.sortby[G(REP_ORG)])},
{"SUBORGSORTBY", &configchoice,
(void *)&(opts.outopts.subsortby[G(REP_ORG)])},
{"REFSORTBY", &configchoice, (void *)&(opts.outopts.sortby[G(REP_REF)])},
{"REFARGSSORTBY", &configchoice,
(void *)&(opts.outopts.subsortby[G(REP_REF)])},
{"REFSITESORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_REFSITE)])},
{"REFDIRSORTBY", &configchoice,
(void *)&(opts.outopts.subsortby[G(REP_REFSITE)])},
{"SUBREFSITESORTBY", &configchoice,
(void *)&(opts.outopts.subsortby[G(REP_REFSITE)])},
{"REDIRREFSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_REDIRREF)])},
{"REDIRREFARGSSORTBY", &configchoice,
(void *)&(opts.outopts.subsortby[G(REP_REDIRREF)])},
{"FAILREFSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_FAILREF)])},
{"FAILREFARGSSORTBY", &configchoice,
(void *)&(opts.outopts.subsortby[G(REP_FAILREF)])},
{"BROWREPSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_BROWREP)])},
{"FULLBROWSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_BROWREP)])},
{"BROWSUMSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_BROWSUM)])},
{"BROWSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_BROWSUM)])},
{"SUBBROWSORTBY", &configchoice,
(void *)&(opts.outopts.subsortby[G(REP_BROWSUM)])},
{"OSSORTBY", &configchoice, (void *)&(opts.outopts.sortby[G(REP_OS)])},
{"SUBOSSORTBY", &configchoice, (void *)&(opts.outopts.subsortby[G(REP_OS)])},
{"STATUSSORTBY", &configchoice, (void *)&(opts.outopts.sortby[G(REP_CODE)])},
{"VHOSTSORTBY", &configchoice, (void *)&(opts.outopts.sortby[G(REP_VHOST)])},
{"REDIRVHOSTSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_REDIRVHOST)])},
{"FAILVHOSTSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_FAILVHOST)])},
{"USERSORTBY", &configchoice, (void *)&(opts.outopts.sortby[G(REP_USER)])},
{"REDIRUSERSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_REDIRUSER)])},
{"FAILUSERSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_FAILUSER)])},
{"SEARCHQUERYSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_SEARCHREP)])},
{"SEARCHWORDSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_SEARCHSUM)])},
{"INTSEARCHQUERYSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_INTSEARCHREP)])},
{"INTSEARCHWORDSORTBY", &configchoice,
(void *)&(opts.outopts.sortby[G(REP_INTSEARCHSUM)])},
{"ALL", &configall, (void *)(opts.outopts.repq)},
{"ALLBACK", &configallback, (void *)(opts.outopts.back)},
{"YEARLY", &configchoice, (void *)&(opts.outopts.repq[REP_YEAR])},
{"QUARTERLY", &configchoice, (void *)&(opts.outopts.repq[REP_QUARTERLY])},
{"MONTHLY", &configchoice, (void *)&(opts.outopts.repq[REP_MONTH])},
{"WEEKLY", &configchoice, (void *)&(opts.outopts.repq[REP_WEEK])},
{"DAILYREP", &configchoice, (void *)&(opts.outopts.repq[REP_DAYREP])},
{"FULLDAILY", &configchoice, (void *)&(opts.outopts.repq[REP_DAYREP])},
{"DAILYSUM", &configchoice, (void *)&(opts.outopts.repq[REP_DAYSUM])},
{"DAILY", &configchoice, (void *)&(opts.outopts.repq[REP_DAYSUM])},
{"HOURLYREP", &configchoice, (void *)&(opts.outopts.repq[REP_HOURREP])},
{"FULLHOURLY", &configchoice, (void *)&(opts.outopts.repq[REP_HOURREP])},
{"HOURLYSUM", &configchoice, (void *)&(opts.outopts.repq[REP_HOURSUM])},
{"HOURLY", &configchoice, (void *)&(opts.outopts.repq[REP_HOURSUM])},
{"WEEKHOUR", &configchoice, (void *)&(opts.outopts.repq[REP_WEEKHOUR])},
{"QUARTERREP", &configchoice, (void *)&(opts.outopts.repq[REP_QUARTERREP])},
{"QUARTER", &configchoice, (void *)&(opts.outopts.repq[REP_QUARTERREP])},
{"QUARTERSUM", &configchoice, (void *)&(opts.outopts.repq[REP_QUARTERSUM])},
{"FIVEREP", &configchoice, (void *)&(opts.outopts.repq[REP_FIVEREP])},
{"FIVE", &configchoice, (void *)&(opts.outopts.repq[REP_FIVEREP])},
{"FIVESUM", &configchoice, (void *)&(opts.outopts.repq[REP_FIVESUM])},
{"GENERAL", &configchoice, (void *)&(opts.outopts.repq[REP_GENSUM])},
{"LASTSEVEN", &configchoice, (void *)&(opts.outopts.last7)},
{"RUNTIME", &configchoice, (void *)&(opts.outopts.runtime)},
{"GOTOS", &configchoice, (void *)&(opts.outopts.gotos)},
{"REPORTSPAN", &configchoice, (void *)&(opts.outopts.repspan)},
{"REPORTSPANTHRESHOLD", &configuint, (void *)&(opts.outopts.rsthresh)},
{"RSTHRESH", &configuint, (void *)&(opts.outopts.rsthresh)},
{"DESCRIPTIONS", &configchoice, (void *)&(opts.outopts.descriptions)},
{"REQUEST", &configchoice, (void *)&(opts.outopts.repq[REP_REQ])},
{"REDIR", &configchoice, (void *)&(opts.outopts.repq[REP_REDIR])},
{"REDIRECTION", &configchoice, (void *)&(opts.outopts.repq[REP_REDIR])},
{"FAILURE", &configchoice, (void *)&(opts.outopts.repq[REP_FAIL])},
{"FILETYPE", &configchoice, (void *)&(opts.outopts.repq[REP_TYPE])},
{"SIZE", &configchoice, (void *)&(opts.outopts.repq[REP_SIZE])},
{"PROCTIME", &configchoice, (void *)&(opts.outopts.repq[REP_PROCTIME])},
{"DIRECTORY", &configchoice, (void *)&(opts.outopts.repq[REP_DIR])},
{"HOST", &configchoice, (void *)&(opts.outopts.repq[REP_HOST])},
{"REDIRHOST", &configchoice, (void *)&(opts.outopts.repq[REP_REDIRHOST])},
{"FAILHOST", &configchoice, (void *)&(opts.outopts.repq[REP_FAILHOST])},
{"DOMAIN", &configchoice, (void *)&(opts.outopts.repq[REP_DOM])},
{"ORGANISATION", &configchoice, (void *)&(opts.outopts.repq[REP_ORG])},
{"ORGANIZATION", &configchoice, (void *)&(opts.outopts.repq[REP_ORG])},
{"REFERRER", &configchoice, (void *)&(opts.outopts.repq[REP_REF])},
{"REFERER", &configchoice, (void *)&(opts.outopts.repq[REP_REF])},
{"REFSITE", &configchoice, (void *)&(opts.outopts.repq[REP_REFSITE])},
{"REDIRREF", &configchoice, (void *)&(opts.outopts.repq[REP_REDIRREF])},
{"FAILREF", &configchoice, (void *)&(opts.outopts.repq[REP_FAILREF])},
{"BROWSERREP", &configchoice, (void *)&(opts.outopts.repq[REP_BROWREP])},
{"BROWREP", &configchoice, (void *)&(opts.outopts.repq[REP_BROWREP])},
{"FULLBROWSER", &configchoice, (void *)&(opts.outopts.repq[REP_BROWREP])},
{"BROWSERSUM", &configchoice, (void *)&(opts.outopts.repq[REP_BROWSUM])},
{"BROWSUM", &configchoice, (void *)&(opts.outopts.repq[REP_BROWSUM])},
{"BROWSER", &configchoice, (void *)&(opts.outopts.repq[REP_BROWSUM])},
{"OSREP", &configchoice, (void *)&(opts.outopts.repq[REP_OS])},
{"VHOST", &configchoice, (void *)&(opts.outopts.repq[REP_VHOST])},
{"REDIRVHOST", &configchoice, (void *)&(opts.outopts.repq[REP_REDIRVHOST])},
{"FAILVHOST", &configchoice, (void *)&(opts.outopts.repq[REP_FAILVHOST])},
{"USER", &configchoice, (void *)&(opts.outopts.repq[REP_USER])},
{"REDIRUSER", &configchoice, (void *)&(opts.outopts.repq[REP_REDIRUSER])},
{"FAILUSER", &configchoice, (void *)&(opts.outopts.repq[REP_FAILUSER])},
{"SEARCHQUERY", &configchoice, (void *)&(opts.outopts.repq[REP_SEARCHREP])},
{"SEARCHWORD", &configchoice, (void *)&(opts.outopts.repq[REP_SEARCHSUM])},
{"INTSEARCHQUERY", &configchoice,
(void *)&(opts.outopts.repq[REP_INTSEARCHREP])},
{"INTSEARCHWORD", &configchoice,
(void *)&(opts.outopts.repq[REP_INTSEARCHSUM])},
{"STATUS", &configchoice, (void *)&(opts.outopts.repq[REP_CODE])},
{"YEARBACK", &configchoice, (void *)&(opts.outopts.back[REP_YEAR])},
{"QUARTERLYBACK", &configchoice,
(void *)&(opts.outopts.back[REP_QUARTERLY])},
{"MONTHBACK", &configchoice, (void *)&(opts.outopts.back[REP_MONTH])},
{"WEEKBACK", &configchoice, (void *)&(opts.outopts.back[REP_WEEK])},
{"DAYBACK", &configchoice, (void *)&(opts.outopts.back[REP_DAYREP])},
{"DAYREPBACK", &configchoice, (void *)&(opts.outopts.back[REP_DAYREP])},
{"FULLDAYBACK", &configchoice, (void *)&(opts.outopts.back[REP_DAYREP])},
{"HOURBACK", &configchoice, (void *)&(opts.outopts.back[REP_HOURREP])},
{"HOURREPBACK", &configchoice, (void *)&(opts.outopts.back[REP_HOURREP])},
{"FULLHOURBACK", &configchoice, (void *)&(opts.outopts.back[REP_HOURREP])},
{"QUARTERBACK", &configchoice, (void *)&(opts.outopts.back[REP_QUARTERREP])},
{"QUARTERREPBACK", &configchoice,
(void *)&(opts.outopts.back[REP_QUARTERREP])},
{"FIVEBACK", &configchoice, (void *)&(opts.outopts.back[REP_FIVEREP])},
{"FIVEREPBACK", &configchoice, (void *)&(opts.outopts.back[REP_FIVEREP])},
{"RAWBYTES", &configchoice, (void *)&(opts.outopts.rawbytes)},
{"BYTESDP", &configuint, (void *)&(opts.outopts.bytesdp)},
{"NOROBOTS", &configchoice, (void *)&(opts.outopts.norobots)},
{"SETTINGS", &configchoice, (void *)&vblesonly},
{"CGI", &configchoice, (void *)&cgi},
{"OUTPUT", &configchoice, (void *)&(opts.outopts.outstyle)},
{"PDFLATEX", &configchoice, (void *)&(opts.outopts.pdflatex)},
{"CASE", &configchoice, (void *)&(opts.miscopts.case_insensitive)},
{"USERCASE", &configchoice, (void *)&(opts.miscopts.usercase_insensitive)},
{"SEARCHCHARCONVERT", &configchoice, (void *)&(opts.outopts.searchconv)},
{"YEARROWS", &configuint, (void *)&(opts.outopts.rows[REP_YEAR])},
{"QUARTERLYROWS", &configuint, (void *)&(opts.outopts.rows[REP_QUARTERLY])},
{"MONTHROWS", &configuint, (void *)&(opts.outopts.rows[REP_MONTH])},
{"WEEKROWS", &configuint, (void *)&(opts.outopts.rows[REP_WEEK])},
{"DAYROWS", &configuint, (void *)&(opts.outopts.rows[REP_DAYREP])},
{"DAYREPROWS", &configuint, (void *)&(opts.outopts.rows[REP_DAYREP])},
{"FULLDAYROWS", &configuint, (void *)&(opts.outopts.rows[REP_DAYREP])},
{"HOURROWS", &configuint, (void *)&(opts.outopts.rows[REP_HOURREP])},
{"HOURREPROWS", &configuint, (void *)&(opts.outopts.rows[REP_HOURREP])},
{"FULLHOURROWS", &configuint, (void *)&(opts.outopts.rows[REP_HOURREP])},
{"QUARTERROWS", &configuint, (void *)&(opts.outopts.rows[REP_QUARTERREP])},
{"QUARTERREPROWS", &configuint,
(void *)&(opts.outopts.rows[REP_QUARTERREP])},
{"FIVEROWS", &configuint, (void *)&(opts.outopts.rows[REP_FIVEREP])},
{"FIVEREPROWS", &configuint, (void *)&(opts.outopts.rows[REP_FIVEREP])},
{"FILELOWMEM", &configlowmem, (void *)&(opts.miscopts.lowmem[ITEM_FILE])},
{"HOSTLOWMEM", &configlowmem, (void *)&(opts.miscopts.lowmem[ITEM_HOST])},
{"REFLOWMEM", &configlowmem, (void *)&(opts.miscopts.lowmem[ITEM_REFERRER])},
{"BROWLOWMEM", &configlowmem, (void *)&(opts.miscopts.lowmem[ITEM_BROWSER])},
{"USERLOWMEM", &configlowmem, (void *)&(opts.miscopts.lowmem[ITEM_USER])},
{"VHOSTLOWMEM", &configlowmem, (void *)&(opts.miscopts.lowmem[ITEM_VHOST])},
{"ASCIIPAGEWIDTH", &configuint, (void *)&(opts.outopts.plainpagewidth)},
{"PLAINPAGEWIDTH", &configuint, (void *)&(opts.outopts.plainpagewidth)},
{"HTMLPAGEWIDTH", &configuint, (void *)&(opts.outopts.htmlpagewidth)},
{"LATEXPAGEWIDTH", &configuint, (void *)&(opts.outopts.latexpagewidth)},
{"MINGRAPHWIDTH", &configuint, (void *)&(opts.outopts.mingraphwidth)},
{"ERRLINELENGTH", &configuint, (void *)&errwidth},
{"PROGRESSFREQ", &configulong, (void *)&progressfreq},
{"WEEKBEGINSON", &configchoice, (void *)&(opts.outopts.weekbeginson)},
{"FROM", &configstr, (void *)&(opts.dman.fromstr)},
{"TO", &configstr, (void *)&(opts.dman.tostr)},
{"REPORTORDER", &configrepord, (void *)(opts.outopts.reporder)},
{"DEBUG", &configdebug, (void *)&debug_args},
{"WARNINGS", &configdebug, (void *)&warn_args},
{"GENSUMLINES", &configdebug, (void *)&(opts.outopts.gensumlines)},
{"DOMLEVEL", &configdomlevel, (void *)&domlevels},
#ifndef NODNS
{"DNS", &configchoice, (void *)&dnslevel},
{"DNSFILE", &configstr, (void *)&dnsfile},
{"DNSLOCKFILE", &configstr, (void *)&dnslockfile},
{"DNSGOODHOURS", &configuint, (void *)&dnsgoodhrs},
{"DNSBADHOURS", &configuint, (void *)&dnsbadhrs},
#ifndef NOALARM
{"DNSTIMEOUT", &configuint, (void *)&dnstimeout},
#endif
#endif
{"CONFIGFILE", &configcall, NULL},
{"", NULL, NULL} /* at end as marker */
};
void globals(char *comname) {
#ifndef NOFOLLOW
struct stat buf;
char *path, *pathcp, *s, *t = NULL;
size_t l = 0;
logical done;
#endif
int i;
time(&starttime);
starttimestr = ctime(&starttime);
starttimestr[24] = '\0';
(void)parsedate(starttime, "-00-00-00:-00-00", &starttimec, FALSE, FALSE);
(void)parsedate(starttime, "-00-00-00:-00-00", &starttimeuxc, FALSE, TRUE);
/* parsedate() is needed because we don't know the encoding of time() */
errfile = stderr;
setvbuf(stderr, NULL, ERRBUFMODE, BUFSIZ);
signal(SIGTERM, sighandler);
signal(SIGINT, sighandler);
#ifdef SIGHUP
signal(SIGHUP, sighandler);
#endif
#ifdef SIGQUIT
signal(SIGQUIT, sighandler);
#endif
#ifdef SIGPIPE
signal(SIGPIPE, SIG_IGN);
#endif
workspace = (char *)xmalloc(BLOCKSIZE);
block_start = (char *)xmalloc(BLOCKSIZE + 1); /* 1 for terminating char */
for (i = 0; i < ITEM_NUMBER; i++) {
mm[i].curr_pos = NULL;
mm[i].first = NULL;
mm[i].alignment = 1;
}
mmq.curr_pos = NULL;
mmq.first = NULL;
mmq.alignment = 1;
mms.curr_pos = NULL;
mms.first = NULL;
mms.alignment = 1;
xmemman = (Memman *)xmalloc(sizeof(Memman));
xmemman->curr_pos = NULL;
xmemman->first = NULL;
xmemman->alignment = ALIGNSIZE;
amemman = (Memman *)xmalloc(sizeof(Memman));
amemman->curr_pos = NULL;
amemman->first = NULL;
amemman->alignment = ALIGNSIZE;
for (i = 0; i < 256; i++)
termchar[i] = FALSE;
termchar[(unsigned char)'\r'] = TRUE;
termchar[(unsigned char)'\n'] = TRUE;
termchar[(unsigned char)'\0'] = TRUE;
if (IS_EMPTY_STRING(comname))
COPYSTR(commandname, "analog") /* no semicolon by defn of COPYSTR */
else
COPYSTR(commandname, comname);
#ifndef NOFOLLOW
commandpath = (char *)xmalloc(PATH_MAX);
done = FALSE;
if (strpbrk(commandname, PATHSEPS) == NULL &&
(path = getenv("PATH")) != NULL) {
pathcp = (char *)xmalloc(strlen(path) + 1);
strcpy(pathcp, path);
for (s = strtok(pathcp, ":"); !done && s != NULL; s = strtok(NULL, ":")) {
ENSURE_LEN(t, l, strlen(s) + strlen(commandname) + 2);
sprintf(t, "%s%c%s", s, DIRSEP, commandname);
if (realpath(t, commandpath) != NULL && access(commandpath, X_OK) == 0 &&
stat(commandpath, &buf) == 0 && S_ISREG(buf.st_mode))
done = TRUE;
}
}
else if (realpath(commandname, commandpath) != NULL)
done = TRUE;
if (!done)
strcpy(commandpath, commandname);
commandpath = (char *)xrealloc((void *)commandpath, strlen(commandpath) + 1);
#else
commandpath = commandname;
#endif
unwanted_entry = newhashentry(DATA_NUMBER, FALSE);
blank_entry = newhashentry(DATA_NUMBER, FALSE);
dummy_item = (Hashindex *)submalloc(xmemman, sizeof(Hashindex));
dummy_item->own = newhashentry(DATA_NUMBER, FALSE);
rep2lng = (unsigned int *)xmalloc(REP_NUMBER * sizeof(unsigned int));
rep2lng[REP_GENSUM] = gensum_;
rep2lng[REP_YEAR] = yearrep_;
rep2lng[REP_QUARTERLY] = quarterlyrep_;
rep2lng[REP_MONTH] = monthrep_;
rep2lng[REP_WEEK] = weekrep_;
rep2lng[REP_DAYREP] = dayrep_;
rep2lng[REP_DAYSUM] = daysum_;
rep2lng[REP_HOURREP] = hourrep_;
rep2lng[REP_HOURSUM] = hoursum_;
rep2lng[REP_WEEKHOUR] = weekhoursum_;
rep2lng[REP_QUARTERREP] = quarterrep_;
rep2lng[REP_QUARTERSUM] = quartersum_;
rep2lng[REP_FIVEREP] = fiverep_;
rep2lng[REP_FIVESUM] = fivesum_;
rep2lng[REP_REQ] = reqrep_;
rep2lng[REP_REDIR] = redirrep_;
rep2lng[REP_FAIL] = failrep_;
rep2lng[REP_TYPE] = typerep_;
rep2lng[REP_SIZE] = sizerep_;
rep2lng[REP_PROCTIME] = proctimerep_;
rep2lng[REP_DIR] = dirrep_;
rep2lng[REP_HOST] = hostrep_;
rep2lng[REP_REDIRHOST] = redirhostrep_;
rep2lng[REP_FAILHOST] = failhostrep_;
rep2lng[REP_DOM] = domrep_;
rep2lng[REP_ORG] = orgrep_;
rep2lng[REP_REF] = refrep_;
rep2lng[REP_REFSITE] = refsiterep_;
rep2lng[REP_REDIRREF] = redirrefrep_;
rep2lng[REP_FAILREF] = failrefrep_;
rep2lng[REP_BROWREP] = browrep_;
rep2lng[REP_BROWSUM] = browsum_;
rep2lng[REP_OS] = osrep_;
rep2lng[REP_VHOST] = vhostrep_;
rep2lng[REP_REDIRVHOST] = redirvhostrep_;
rep2lng[REP_FAILVHOST] = failvhostrep_;
rep2lng[REP_USER] = userrep_;
rep2lng[REP_REDIRUSER] = rediruserrep_;
rep2lng[REP_FAILUSER] = failuserrep_;
rep2lng[REP_SEARCHREP] = searchrep_;
rep2lng[REP_SEARCHSUM] = searchsum_;
rep2lng[REP_INTSEARCHREP] = intsearchrep_;
rep2lng[REP_INTSEARCHSUM] = intsearchsum_;
rep2lng[REP_CODE] = statrep_;
rep2type = (choice *)xmalloc(REP_NUMBER * sizeof(choice));
rep2type[REP_YEAR] = INP_DATE;
rep2type[REP_QUARTERLY] = INP_DATE;
rep2type[REP_MONTH] = INP_DATE;
rep2type[REP_WEEK] = INP_DATE;
rep2type[REP_DAYREP] = INP_DATE;
rep2type[REP_DAYSUM] = INP_DATE;
rep2type[REP_HOURREP] = INP_DATE;
rep2type[REP_HOURSUM] = INP_DATE;
rep2type[REP_WEEKHOUR] = INP_DATE;
rep2type[REP_QUARTERREP] = INP_DATE;
rep2type[REP_QUARTERSUM] = INP_DATE;
rep2type[REP_FIVEREP] = INP_DATE;
rep2type[REP_FIVESUM] = INP_DATE;
rep2type[REP_GENSUM] = UNSET;
rep2type[REP_REQ] = ITEM_FILE;
rep2type[REP_TYPE] = ITEM_FILE;
rep2type[REP_DIR] = ITEM_FILE;
rep2type[REP_REDIR] = ITEM_FILE;
rep2type[REP_FAIL] = ITEM_FILE;
rep2type[REP_HOST] = ITEM_HOST;
rep2type[REP_REDIRHOST] = ITEM_HOST;
rep2type[REP_FAILHOST] = ITEM_HOST;
rep2type[REP_DOM] = ITEM_HOST;
rep2type[REP_ORG] = ITEM_HOST;
rep2type[REP_USER] = ITEM_USER;
rep2type[REP_REDIRUSER] = ITEM_USER;
rep2type[REP_FAILUSER] = ITEM_USER;
rep2type[REP_REF] = ITEM_REFERRER;
rep2type[REP_REFSITE] = ITEM_REFERRER;
rep2type[REP_REDIRREF] = ITEM_REFERRER;
rep2type[REP_FAILREF] = ITEM_REFERRER;
rep2type[REP_SEARCHREP] = ITEM_REFERRER;
rep2type[REP_SEARCHSUM] = ITEM_REFERRER;
rep2type[REP_INTSEARCHREP] = ITEM_FILE;
rep2type[REP_INTSEARCHSUM] = ITEM_FILE;
rep2type[REP_BROWREP] = ITEM_BROWSER;
rep2type[REP_BROWSUM] = ITEM_BROWSER;
rep2type[REP_OS] = ITEM_BROWSER;
rep2type[REP_VHOST] = ITEM_VHOST;
rep2type[REP_REDIRVHOST] = ITEM_VHOST;
rep2type[REP_FAILVHOST] = ITEM_VHOST;
rep2type[REP_SIZE] = INP_BYTES;
rep2type[REP_PROCTIME] = INP_PROCTIME;
rep2type[REP_CODE] = INP_CODE;
repistree = (logical *)xmalloc(GENREP_NUMBER * sizeof(logical));
for (i = 0; i < GENREP_NUMBER; i++)
repistree[i] = FALSE;
repistree[G(REP_REQ)] = TRUE;
repistree[G(REP_REDIR)] = TRUE;
repistree[G(REP_FAIL)] = TRUE;
repistree[G(REP_REF)] = TRUE;
repistree[G(REP_REDIRREF)] = TRUE;
repistree[G(REP_FAILREF)] = TRUE;
repistree[G(REP_TYPE)] = TRUE;
repistree[G(REP_DIR)] = TRUE;
repistree[G(REP_DOM)] = TRUE;
repistree[G(REP_ORG)] = TRUE;
repistree[G(REP_REFSITE)] = TRUE;
repistree[G(REP_BROWSUM)] = TRUE;
repistree[G(REP_OS)] = TRUE;
rep2reqs = (choice *)xmalloc(GENREP_NUMBER * sizeof(choice));
rep2reqs7 = (choice *)xmalloc(GENREP_NUMBER * sizeof(choice));
rep2date = (choice *)xmalloc(GENREP_NUMBER * sizeof(choice));
rep2firstd = (choice *)xmalloc(GENREP_NUMBER * sizeof(choice));
for (i = 0; i < GENREP_NUMBER; i++)
rep2reqs[i] = REQUESTS;
rep2reqs[G(REP_REDIR)] = REDIR;
rep2reqs[G(REP_FAIL)] = FAIL;
rep2reqs[G(REP_REDIRHOST)] = REDIR;
rep2reqs[G(REP_FAILHOST)] = FAIL;
rep2reqs[G(REP_REDIRUSER)] = REDIR;
rep2reqs[G(REP_FAILUSER)] = FAIL;
rep2reqs[G(REP_REDIRREF)] = REDIR;
rep2reqs[G(REP_FAILREF)] = FAIL;
rep2reqs[G(REP_REDIRVHOST)] = REDIR;
rep2reqs[G(REP_FAILVHOST)] = FAIL;
for (i = 0; i < GENREP_NUMBER; i++) {
rep2reqs7[i] = (rep2reqs[i] == REDIR)?REDIR7:\
((rep2reqs[i] == FAIL)?FAIL7:REQUESTS7);
rep2date[i] = (rep2reqs[i] == REDIR)?REDIRDATE:\
((rep2reqs[i] == FAIL)?FAILDATE:SUCCDATE);
rep2firstd[i] = (rep2reqs[i] == REDIR)?REDIRFIRSTD:\
((rep2reqs[i] == FAIL)?FAILFIRSTD:SUCCFIRSTD);
}
rep2gran = (unsigned int *)xmalloc(DATEREP_NUMBER * sizeof(unsigned int));
rep2gran[REP_DAYREP] = 1;
rep2gran[REP_HOURREP] = 24;
rep2gran[REP_QUARTERREP] = 96;
rep2gran[REP_FIVEREP] = 288;
rep2gran[REP_YEAR] = 1;
rep2gran[REP_QUARTERLY] = 1;
rep2gran[REP_MONTH] = 1;
rep2gran[REP_WEEK] = 1;
rep2gran[REP_DAYSUM] = 1;
rep2gran[REP_HOURSUM] = 24;
rep2gran[REP_WEEKHOUR] = 24;
rep2gran[REP_QUARTERSUM] = 96;
rep2gran[REP_FIVESUM] = 288;
rep2datefmt = (unsigned int *)xmalloc(DATEREP_NUMBER * sizeof(unsigned int));
rep2datefmt[REP_DAYREP] = dayrepfmt_;
rep2datefmt[REP_DAYSUM] = daysumfmt_;
rep2datefmt[REP_HOURREP] = hourrepfmt_;
rep2datefmt[REP_QUARTERREP] = quarterrepfmt_;
rep2datefmt[REP_FIVEREP] = quarterrepfmt_;
rep2datefmt[REP_WEEK] = weekfmt_;
rep2datefmt[REP_MONTH] = monthfmt_;
rep2datefmt[REP_QUARTERLY] = quarterlyfmt_;
rep2datefmt[REP_YEAR] = yearfmt_;
rep2datefmt[REP_HOURSUM] = hoursumfmt_;
rep2datefmt[REP_WEEKHOUR] = weekhoursumfmt_;
rep2datefmt[REP_QUARTERSUM] = quartersumfmt_;
rep2datefmt[REP_FIVESUM] = quartersumfmt_;
rep2colhead = (unsigned int *)xmalloc(REP_NUMBER * sizeof(unsigned int));
rep2colhead[REP_DAYREP] = date_;
rep2colhead[REP_DAYSUM] = day_;
rep2colhead[REP_HOURREP] = time_;
rep2colhead[REP_HOURSUM] = hr_;
rep2colhead[REP_WEEKHOUR] = hr_;
rep2colhead[REP_QUARTERREP] = time_;
rep2colhead[REP_QUARTERSUM] = time_;
rep2colhead[REP_FIVEREP] = time_;
rep2colhead[REP_FIVESUM] = time_;
rep2colhead[REP_WEEK] = weekbeg_;
rep2colhead[REP_MONTH] = month_;
rep2colhead[REP_QUARTERLY] = quarteryr_;
rep2colhead[REP_YEAR] = year_;
rep2colhead[REP_REQ] = file_;
rep2colhead[REP_REDIR] = file_;
rep2colhead[REP_FAIL] = file_;
rep2colhead[REP_TYPE] = ext_;
rep2colhead[REP_SIZE] = size_;
rep2colhead[REP_PROCTIME] = seconds_;
rep2colhead[REP_DIR] = dir_;
rep2colhead[REP_HOST] = host_;
rep2colhead[REP_REDIRHOST] = host_;
rep2colhead[REP_FAILHOST] = host_;
rep2colhead[REP_DOM] = dom_;
rep2colhead[REP_ORG] = org_;
rep2colhead[REP_REF] = url_;
rep2colhead[REP_REFSITE] = site_;
rep2colhead[REP_REDIRREF] = url_;
rep2colhead[REP_FAILREF] = url_;
rep2colhead[REP_BROWREP] = browser_;
rep2colhead[REP_BROWSUM] = browser_;
rep2colhead[REP_OS] = os_;
rep2colhead[REP_VHOST] = vhost_;
rep2colhead[REP_REDIRVHOST] = vhost_;
rep2colhead[REP_FAILVHOST] = vhost_;
rep2colhead[REP_USER] = user_;
rep2colhead[REP_REDIRUSER] = user_;
rep2colhead[REP_FAILUSER] = user_;
rep2colhead[REP_SEARCHREP] = search_;
rep2colhead[REP_SEARCHSUM] = search_;
rep2colhead[REP_INTSEARCHREP] = search_;
rep2colhead[REP_INTSEARCHSUM] = search_;
rep2colhead[REP_CODE] = code_;
rep2busystr = (unsigned int *)xmalloc(DATEREPORTS_NUMBER * sizeof(unsigned int));
rep2busystr[REP_DAYREP] = busyday_;
rep2busystr[REP_HOURREP] = busyhour_;
rep2busystr[REP_QUARTERREP] = busyquarterhr_;
rep2busystr[REP_FIVEREP] = busyfive_;
rep2busystr[REP_WEEK] = busyweek_;
rep2busystr[REP_MONTH] = busymonth_;
rep2busystr[REP_QUARTERLY] = busyquarteryr_;
rep2busystr[REP_YEAR] = busyyear_;
col2colhead = (unsigned int *)xmalloc(COL_NUMBER * sizeof(unsigned int));
col2colhead[COL_REQS] = nreqs_;
col2colhead[COL_PAGES] = npgs_;
col2colhead[COL_BYTES] = nbytes_;
col2colhead[COL_PREQS] = preqs_;
col2colhead[COL_PPAGES] = ppgs_;
col2colhead[COL_PBYTES] = pbytes_;
col2colhead[COL_REQS7] = nreqs7_;
col2colhead[COL_PAGES7] = npgs7_;
col2colhead[COL_BYTES7] = nbytes7_;
col2colhead[COL_PREQS7] = preqs7_;
col2colhead[COL_PPAGES7] = ppgs7_;
col2colhead[COL_PBYTES7] = pbytes7_;
col2colhead[COL_DATE] = lastdate_;
col2colhead[COL_TIME] = lasttime_;
col2colhead[COL_FIRSTD] = firstdate_;
col2colhead[COL_FIRSTT] = firsttime_;
col2colhead[COL_INDEX] = index_;
method2sing = (unsigned int *)xmalloc(METHOD_NUMBER * sizeof(unsigned int));
method2sing[REQUESTS] = request_;
method2sing[REQUESTS7] = request7_;
method2sing[PAGES] = pagereq_;
method2sing[PAGES7] = pagereq7_;
method2sing[REDIR] = redirreq_;
method2sing[REDIR7] = redirreq7_;
method2sing[FAIL] = failreq_;
method2sing[FAIL7] = failreq7_;
method2sing[BYTES] = bytetraffic_;
method2sing[BYTES7] = bytetraffic7_;
method2pl = (unsigned int *)xmalloc(METHOD_NUMBER * sizeof(unsigned int));
method2pl[REQUESTS] = requests_;
method2pl[REQUESTS7] = requests7_;
method2pl[PAGES] = pagereqs_;
method2pl[PAGES7] = pagereqs7_;
method2pl[REDIR] = redirreqs_;
method2pl[REDIR7] = redirreqs7_;
method2pl[FAIL] = failreqs_;
method2pl[FAIL7] = failreqs7_;
method2pl[BYTES] = bytestraffic_;
method2pl[BYTES7] = bytestraffic7_;
method2date = (unsigned int *)xmalloc(METHOD_NUMBER * sizeof(unsigned int));
method2date[SUCCDATE] = sincedate_;
method2date[REDIRDATE] = sinceredirdate_;
method2date[FAILDATE] = sincefaildate_;
method2date[SUCCFIRSTD] = sincefirstd_;
method2date[REDIRFIRSTD] = sinceredirfirstd_;
method2date[FAILFIRSTD] = sincefailfirstd_;
method2pc = (unsigned int *)xmalloc(METHOD_NUMBER * sizeof(unsigned int));
method2pc[REQUESTS] = prequests_;
method2pc[REQUESTS7] = prequests7_;
method2pc[PAGES] = ppages_;
method2pc[PAGES7] = ppages7_;
method2pc[REDIR] = predirs_;
method2pc[REDIR7] = predirs7_;
method2pc[FAIL] = pfails_;
method2pc[FAIL7] = pfails7_;
method2pc[BYTES] = ptraffic_;
method2pc[BYTES7] = ptraffic7_;
method2relpc = (unsigned int *)xmalloc(METHOD_NUMBER * sizeof(unsigned int));
method2relpc[REQUESTS] = pmrequests_;
method2relpc[REQUESTS7] = pmrequests7_;
method2relpc[PAGES] = pmpages_;
method2relpc[PAGES7] = pmpages7_;
method2relpc[REDIR] = pmredirs_;
method2relpc[REDIR7] = pmredirs7_;
method2relpc[FAIL] = pmfails_;
method2relpc[FAIL7] = pmfails7_;
method2relpc[BYTES] = pmtraffic_;
method2relpc[BYTES7] = pmtraffic7_;
method2sort = (unsigned int *)xmalloc(METHOD_NUMBER * sizeof(unsigned int));
method2sort[REQUESTS] = nrequests_;
method2sort[REQUESTS7] = nrequests7_;
method2sort[PAGES] = npages_;
method2sort[PAGES7] = npages7_;
method2sort[REDIR] = nredirs_;
method2sort[REDIR7] = nredirs7_;
method2sort[FAIL] = nfails_;
method2sort[FAIL7] = nfails7_;
method2sort[SUCCDATE] = succdate_;
method2sort[REDIRDATE] = redirdate_;
method2sort[FAILDATE] = faildate_;
method2sort[SUCCFIRSTD] = succfirstd_;
method2sort[REDIRFIRSTD] = redirfirstd_;
method2sort[FAILFIRSTD] = failfirstd_;
method2sort[BYTES] = traffic_;
method2sort[BYTES7] = traffic7_;
}
void defaults(Options *op) {
double codethresh[] = {100., 101., 199., 200., 201., 202., 203., 204., 205.,
206., 299., 300., 301., 302., 303., 304., 305., 306.,
307., 399., 400., 401., 402., 403., 404., 405., 406.,
407., 408., 409., 410., 411., 412., 413., 414., 415.,
416., 417., 499., 500., 501., 502., 503.,
504., 505., 506., 599., -1.};
double sizethresh[] = {0., 10., 100., 1024., 10240., 102400., 1048576.,
10485760., 104857600., 1073741824., -1.};
double ptthresh[] = {0., 10., 20., 50., 100., 200., 500., 1000., 2000.,
5000., 10000., 20000., 60000., 120000., 300000.,
600000., -1.};
/* These thresholds have to be coordinated with the names in arrayrep().
The max codethresh & ptthresh also feature near the end of readcache(). */
double *thresh;
int i, j, k;
op->conffilelist = NULL;
confline(op, "DEBUG", "OFF", NULL, -1);
confline(op, "WARNINGS", "ON", NULL, -1);
op->outopts.gensumlines = NULL;
confline(op, "GENSUMLINES", "ON", NULL, -1);
deflogformat = (Inputformatlist *)submalloc(xmemman,
sizeof(Inputformatlist));
logformat = (Inputformatlist *)submalloc(xmemman, sizeof(Inputformatlist));
deflogformat->used = TRUE;
logformat->used = TRUE;
configlogfmt((void *)&deflogformat, "DEFAULTLOGFORMAT", "AUTO", NULL, -1);
configlogfmt((void *)&logformat, "LOGFORMAT", "DEFAULT", NULL, -1);
deflogformat->used = TRUE;
op->miscopts.logfile[0] = NULL;
op->miscopts.logfile[1] = NULL;
confline(op, "LOGFILE", LOGFILE, NULL, -1);
confline(op, "CACHEFILE", CACHEFILE, NULL, -1);
op->outopts.domainsfile = NULL;
op->outopts.descfile = NULL;
COPYSTR(op->miscopts.dirsuffix, DIRSUFFIX);
#ifndef NODNS
dnslevel = DNS;
dnsgoodhrs = DNSGOODHOURS;
dnsbadhrs = DNSBADHOURS;
COPYSTR(dnsfile, DNSFILE);
COPYSTR(dnslockfile, DNSLOCKFILE);
#ifndef NOALARM
dnstimeout = DNSTIMEOUT;
#endif
#endif
op->miscopts.case_insensitive = CASE_INSENSITIVE;
op->miscopts.usercase_insensitive = USERCASE_INSENSITIVE;
op->outopts.searchconv = SEARCHCHARCONVERT;
op->outopts.outstyle = OUTPUT;
op->outopts.html = TRUE;
op->outopts.pdflatex = TRUE;
COPYSTR(op->outopts.headerfile, HEADERFILE);
COPYSTR(op->outopts.footerfile, FOOTERFILE);
COPYSTR(op->outopts.outfile, OUTFILE);
COPYSTR(op->outopts.cacheoutfile, CACHEOUTFILE);
COPYSTR(op->outopts.imagedir, IMAGEDIR);
op->outopts.chartdir = NULL;
op->outopts.localchartdir = NULL;
op->outopts.jpegcharts = FALSE;
op->outopts.pngimages = PNGIMAGES;
confline(op, "YEARCOLS", YEARCOLS, NULL, -1);
confline(op, "QUARTERLYCOLS", QUARTERLYCOLS, NULL, -1);
confline(op, "MONTHCOLS", MONTHCOLS, NULL, -1);
confline(op, "WEEKCOLS", WEEKCOLS, NULL, -1);
confline(op, "DAYREPCOLS", DAYREPCOLS, NULL, -1);
confline(op, "DAYSUMCOLS", DAYSUMCOLS, NULL, -1);
confline(op, "HOURREPCOLS", HOURREPCOLS, NULL, -1);
confline(op, "HOURSUMCOLS", HOURSUMCOLS, NULL, -1);
confline(op, "WEEKHOURCOLS", WEEKHOURCOLS, NULL, -1);
confline(op, "QUARTERREPCOLS", QUARTERREPCOLS, NULL, -1);
confline(op, "QUARTERSUMCOLS", QUARTERSUMCOLS, NULL, -1);
confline(op, "FIVEREPCOLS", FIVEREPCOLS, NULL, -1);
confline(op, "FIVESUMCOLS", FIVESUMCOLS, NULL, -1);
confline(op, "REQCOLS", REQCOLS, NULL, -1);
confline(op, "REDIRCOLS", REDIRCOLS, NULL, -1);
confline(op, "FAILCOLS", FAILCOLS, NULL, -1);
confline(op, "TYPECOLS", TYPECOLS, NULL, -1);
confline(op, "SIZECOLS", SIZECOLS, NULL, -1);
confline(op, "PROCTIMECOLS", PROCTIMECOLS, NULL, -1);
confline(op, "DIRCOLS", DIRCOLS, NULL, -1);
confline(op, "HOSTCOLS", HOSTCOLS, NULL, -1);
confline(op, "REDIRHOSTCOLS", REDIRHOSTCOLS, NULL, -1);
confline(op, "FAILHOSTCOLS", FAILHOSTCOLS, NULL, -1);
confline(op, "DOMCOLS", DOMCOLS, NULL, -1);
confline(op, "ORGCOLS", ORGCOLS, NULL, -1);
confline(op, "REFCOLS", REFCOLS, NULL, -1);
confline(op, "REFSITECOLS", REFSITECOLS, NULL, -1);
confline(op, "REDIRREFCOLS", REDIRREFCOLS, NULL, -1);
confline(op, "FAILREFCOLS", FAILREFCOLS, NULL, -1);
confline(op, "BROWREPCOLS", BROWREPCOLS, NULL, -1);
confline(op, "BROWSUMCOLS", BROWSUMCOLS, NULL, -1);
confline(op, "OSCOLS", OSCOLS, NULL, -1);
confline(op, "VHOSTCOLS", VHOSTCOLS, NULL, -1);
confline(op, "REDIRVHOSTCOLS", REDIRVHOSTCOLS, NULL, -1);
confline(op, "FAILVHOSTCOLS", FAILVHOSTCOLS, NULL, -1);
confline(op, "USERCOLS", USERCOLS, NULL, -1);
confline(op, "REDIRUSERCOLS", REDIRUSERCOLS, NULL, -1);
confline(op, "FAILUSERCOLS", FAILUSERCOLS, NULL, -1);
confline(op, "SEARCHQUERYCOLS", SEARCHQUERYCOLS, NULL, -1);
confline(op, "SEARCHWORDCOLS", SEARCHWORDCOLS, NULL, -1);
confline(op, "INTSEARCHQUERYCOLS", INTSEARCHQUERYCOLS, NULL, -1);
confline(op, "INTSEARCHWORDCOLS", INTSEARCHWORDCOLS, NULL, -1);
confline(op, "STATUSCOLS", STATUSCOLS, NULL, -1);
op->outopts.repq[REP_YEAR] = YEARLY;
op->outopts.repq[REP_QUARTERLY] = QUARTERLY;
op->outopts.repq[REP_MONTH] = MONTHLY;
op->outopts.repq[REP_WEEK] = WEEKLY;
op->outopts.repq[REP_DAYREP] = DAILYREP;
op->outopts.repq[REP_DAYSUM] = DAILYSUM;
op->outopts.repq[REP_HOURREP] = HOURLYREP;
op->outopts.repq[REP_HOURSUM] = HOURLYSUM;
op->outopts.repq[REP_WEEKHOUR] = WEEKHOUR;
op->outopts.repq[REP_QUARTERREP] = QUARTERREP;
op->outopts.repq[REP_QUARTERSUM] = QUARTERSUM;
op->outopts.repq[REP_FIVEREP] = FIVEREP;
op->outopts.repq[REP_FIVESUM] = FIVESUM;
op->outopts.repq[REP_GENSUM] = GENERAL;
op->outopts.repq[REP_REQ] = REQUEST;
op->outopts.repq[REP_REDIR] = REDIRREP;
op->outopts.repq[REP_FAIL] = FAILREP;
op->outopts.repq[REP_TYPE] = FILETYPE;
op->outopts.repq[REP_SIZE] = SIZEREP;
op->outopts.repq[REP_PROCTIME] = PROCTIME;
op->outopts.repq[REP_DIR] = DIRECTORY;
op->outopts.repq[REP_HOST] = HOST;
op->outopts.repq[REP_REDIRHOST] = REDIRHOST;
op->outopts.repq[REP_FAILHOST] = FAILHOST;
op->outopts.repq[REP_DOM] = DOMAINREP;
op->outopts.repq[REP_ORG] = ORGANISATION;
op->outopts.repq[REP_REF] = REFERRER;
op->outopts.repq[REP_REFSITE] = REFSITE;
op->outopts.repq[REP_REDIRREF] = REDIRREF;
op->outopts.repq[REP_FAILREF] = FAILREF;
op->outopts.repq[REP_BROWREP] = BROWSERREP;
op->outopts.repq[REP_BROWSUM] = BROWSERSUM;
op->outopts.repq[REP_OS] = OSREP;
op->outopts.repq[REP_VHOST] = VHOST;
op->outopts.repq[REP_REDIRVHOST] = REDIRVHOST;
op->outopts.repq[REP_FAILVHOST] = FAILVHOST;
op->outopts.repq[REP_USER] = USER;
op->outopts.repq[REP_REDIRUSER] = REDIRUSER;
op->outopts.repq[REP_FAILUSER] = FAILUSER;
op->outopts.repq[REP_SEARCHREP] = SEARCHQUERY;
op->outopts.repq[REP_SEARCHSUM] = SEARCHWORD;
op->outopts.repq[REP_INTSEARCHREP] = INTSEARCHQUERY;
op->outopts.repq[REP_INTSEARCHSUM] = INTSEARCHWORD;
op->outopts.repq[REP_CODE] = STATUS;
op->outopts.last7 = LASTSEVEN;
op->outopts.runtime = RUNTIME;
op->outopts.gotos = GOTOS;
op->outopts.repspan = REPORTSPAN;
op->outopts.rsthresh = REPORTSPANTHRESHOLD;
op->outopts.descriptions = DESCRIPTIONS;
op->outopts.lang.code = LANGUAGE;
op->outopts.lang.file = NULL;
op->outopts.graph[REP_YEAR] = YEARGRAPH;
op->outopts.graph[REP_QUARTERLY] = QUARTERLYGRAPH;
op->outopts.graph[REP_MONTH] = MONTHGRAPH;
op->outopts.graph[REP_WEEK] = WEEKGRAPH;
op->outopts.graph[REP_DAYREP] = DAYREPGRAPH;
op->outopts.graph[REP_DAYSUM] = DAYSUMGRAPH;
op->outopts.graph[REP_HOURREP] = HOURREPGRAPH;
op->outopts.graph[REP_HOURSUM] = HOURSUMGRAPH;
op->outopts.graph[REP_WEEKHOUR] = WEEKHOURGRAPH;
op->outopts.graph[REP_QUARTERREP] = QUARTERREPGRAPH;
op->outopts.graph[REP_QUARTERSUM] = QUARTERSUMGRAPH;
op->outopts.graph[REP_FIVEREP] = FIVEREPGRAPH;
op->outopts.graph[REP_FIVESUM] = FIVESUMGRAPH;
op->outopts.back[REP_YEAR] = YEARBACK;
op->outopts.back[REP_QUARTERLY] = QUARTERLYBACK;
op->outopts.back[REP_MONTH] = MONTHBACK;
op->outopts.back[REP_WEEK] = WEEKBACK;
op->outopts.back[REP_DAYREP] = DAYBACK;
op->outopts.back[REP_HOURREP] = HOURBACK;
op->outopts.back[REP_QUARTERREP] = QUARTERBACK;
op->outopts.back[REP_FIVEREP] = FIVEBACK;
op->outopts.rows[REP_YEAR] = YEARROWS;
op->outopts.rows[REP_QUARTERLY] = QUARTERLYROWS;
op->outopts.rows[REP_MONTH] = MONTHROWS;
op->outopts.rows[REP_WEEK] = WEEKROWS;
op->outopts.rows[REP_DAYREP] = DAYROWS;
op->outopts.rows[REP_HOURREP] = HOURROWS;
op->outopts.rows[REP_QUARTERREP] = QUARTERROWS;
op->outopts.rows[REP_FIVEREP] = FIVEROWS;
#ifndef NOGRAPHICS
op->outopts.chartby[G(REP_REQ)] = REQCHART;
op->outopts.chartby[G(REP_REDIR)] = REDIRCHART;
op->outopts.chartby[G(REP_FAIL)] = FAILCHART;
op->outopts.chartby[G(REP_TYPE)] = TYPECHART;
op->outopts.chartby[G(REP_DIR)] = DIRCHART;
op->outopts.chartby[G(REP_HOST)] = HOSTCHART;
op->outopts.chartby[G(REP_REDIRHOST)] = REDIRHOSTCHART;
op->outopts.chartby[G(REP_FAILHOST)] = FAILHOSTCHART;
op->outopts.chartby[G(REP_DOM)] = DOMCHART;
op->outopts.chartby[G(REP_REF)] = REFCHART;
op->outopts.chartby[G(REP_REFSITE)] = REFSITECHART;
op->outopts.chartby[G(REP_REDIRREF)] = REDIRREFCHART;
op->outopts.chartby[G(REP_FAILREF)] = FAILREFCHART;
op->outopts.chartby[G(REP_BROWREP)] = BROWREPCHART;
op->outopts.chartby[G(REP_VHOST)] = VHOSTCHART;
op->outopts.chartby[G(REP_REDIRVHOST)] = REDIRVHOSTCHART;
op->outopts.chartby[G(REP_FAILVHOST)] = FAILVHOSTCHART;
op->outopts.chartby[G(REP_USER)] = USERCHART;
op->outopts.chartby[G(REP_REDIRUSER)] = REDIRUSERCHART;
op->outopts.chartby[G(REP_FAILUSER)] = FAILUSERCHART;
op->outopts.chartby[G(REP_ORG)] = ORGCHART;
op->outopts.chartby[G(REP_SEARCHREP)] = SEARCHQUERYCHART;
op->outopts.chartby[G(REP_SEARCHSUM)] = SEARCHWORDCHART;
op->outopts.chartby[G(REP_INTSEARCHREP)] = INTSEARCHQUERYCHART;
op->outopts.chartby[G(REP_INTSEARCHSUM)] = INTSEARCHWORDCHART;
op->outopts.chartby[G(REP_BROWSUM)] = BROWSUMCHART;
op->outopts.chartby[G(REP_OS)] = OSCHART;
op->outopts.chartby[G(REP_SIZE)] = SIZECHART;
op->outopts.chartby[G(REP_CODE)] = STATUSCHART;
op->outopts.chartby[G(REP_PROCTIME)] = PROCTIMECHART;
#else
for (i = 0; i < GENREP_NUMBER; i++)
op->outopts.chartby[i] = CHART_NONE;/* to avoid recording spurious stuff */
#endif /* NOGRAPHICS */
for (i = 0; i < GENREP_NUMBER; i++) {
/* initialise all SUBSORTBYs to UNSET. Then we can use this later as a test
for whether the report is a hierarchical report. Also set all SUBFLOOR
methods to UNSET so that we don't count any unneeded data by mistake. */
op->outopts.subsortby[i] = UNSET;
op->outopts.subfloor[i].floorby = UNSET;
}
op->outopts.sortby[G(REP_REQ)] = REQSORTBY;
op->outopts.subsortby[G(REP_REQ)] = REQSORTBY;
op->outopts.sortby[G(REP_REDIR)] = REDIRSORTBY;
op->outopts.subsortby[G(REP_REDIR)] = REDIRSORTBY;
op->outopts.sortby[G(REP_FAIL)] = FAILSORTBY;
op->outopts.subsortby[G(REP_FAIL)] = FAILSORTBY;
op->outopts.sortby[G(REP_TYPE)] = TYPESORTBY;
op->outopts.subsortby[G(REP_TYPE)] = TYPESORTBY;
op->outopts.sortby[G(REP_DIR)] = DIRSORTBY;
op->outopts.subsortby[G(REP_DIR)] = DIRSORTBY;
op->outopts.sortby[G(REP_HOST)] = HOSTSORTBY;
op->outopts.sortby[G(REP_REDIRHOST)] = REDIRHOSTSORTBY;
op->outopts.sortby[G(REP_FAILHOST)] = FAILHOSTSORTBY;
op->outopts.sortby[G(REP_DOM)] = DOMSORTBY;
op->outopts.subsortby[G(REP_DOM)] = DOMSORTBY;
op->outopts.sortby[G(REP_ORG)] = ORGSORTBY;
op->outopts.subsortby[G(REP_ORG)] = ORGSORTBY;
op->outopts.sortby[G(REP_REF)] = REFSORTBY;
op->outopts.subsortby[G(REP_REF)] = REFSORTBY;
op->outopts.sortby[G(REP_REFSITE)] = REFSITESORTBY;
op->outopts.subsortby[G(REP_REFSITE)] = REFSITESORTBY;
op->outopts.sortby[G(REP_REDIRREF)] = REDIRREFSORTBY;
op->outopts.subsortby[G(REP_REDIRREF)] = REDIRREFSORTBY;
op->outopts.sortby[G(REP_FAILREF)] = FAILREFSORTBY;
op->outopts.subsortby[G(REP_FAILREF)] = FAILREFSORTBY;
op->outopts.sortby[G(REP_BROWREP)] = BROWREPSORTBY;
op->outopts.sortby[G(REP_BROWSUM)] = BROWSUMSORTBY;
op->outopts.subsortby[G(REP_BROWSUM)] = BROWSUMSORTBY;
op->outopts.sortby[G(REP_OS)] = OSSORTBY;
op->outopts.subsortby[G(REP_OS)] = OSSORTBY;
op->outopts.sortby[G(REP_VHOST)] = VHOSTSORTBY;
op->outopts.sortby[G(REP_REDIRVHOST)] = REDIRVHOSTSORTBY;
op->outopts.sortby[G(REP_FAILVHOST)] = FAILVHOSTSORTBY;
op->outopts.sortby[G(REP_USER)] = USERSORTBY;
op->outopts.sortby[G(REP_REDIRUSER)] = REDIRUSERSORTBY;
op->outopts.sortby[G(REP_FAILUSER)] = FAILUSERSORTBY;
op->outopts.sortby[G(REP_SEARCHREP)] = SEARCHQUERYSORTBY;
op->outopts.sortby[G(REP_SEARCHSUM)] = SEARCHWORDSORTBY;
op->outopts.sortby[G(REP_INTSEARCHREP)] = INTSEARCHQUERYSORTBY;
op->outopts.sortby[G(REP_INTSEARCHSUM)] = INTSEARCHWORDSORTBY;
op->outopts.sortby[G(REP_CODE)] = STATUSSORTBY;
op->outopts.sortby[G(REP_SIZE)] = ALPHABETICAL;
op->outopts.sortby[G(REP_PROCTIME)] = ALPHABETICAL;
confline(op, "REQFLOOR", REQFLOOR, NULL, -1);
confline(op, "REQARGSFLOOR", REQARGSFLOOR, NULL, -1);
confline(op, "REDIRFLOOR", REDIRFLOOR, NULL, -1);
confline(op, "REDIRARGSFLOOR", REDIRARGSFLOOR, NULL, -1);
confline(op, "FAILFLOOR", FAILFLOOR, NULL, -1);
confline(op, "FAILARGSFLOOR", FAILARGSFLOOR, NULL, -1);
confline(op, "TYPEFLOOR", TYPEFLOOR, NULL, -1);
confline(op, "SUBTYPEFLOOR", SUBTYPEFLOOR, NULL, -1);
confline(op, "DIRFLOOR", DIRFLOOR, NULL, -1);
confline(op, "SUBDIRFLOOR", SUBDIRFLOOR, NULL, -1);
confline(op, "HOSTFLOOR", HOSTFLOOR, NULL, -1);
confline(op, "REDIRHOSTFLOOR", REDIRHOSTFLOOR, NULL, -1);
confline(op, "FAILHOSTFLOOR", FAILHOSTFLOOR, NULL, -1);
confline(op, "DOMFLOOR", DOMFLOOR, NULL, -1);
confline(op, "SUBDOMFLOOR", SUBDOMFLOOR, NULL, -1);
confline(op, "ORGFLOOR", ORGFLOOR, NULL, -1);
confline(op, "SUBORGFLOOR", SUBORGFLOOR, NULL, -1);
confline(op, "REFFLOOR", REFFLOOR, NULL, -1);
confline(op, "REFARGSFLOOR", REFARGSFLOOR, NULL, -1);
confline(op, "REFSITEFLOOR", REFSITEFLOOR, NULL, -1);
confline(op, "REFDIRFLOOR", REFDIRFLOOR, NULL, -1);
confline(op, "REDIRREFFLOOR", REDIRREFFLOOR, NULL, -1);
confline(op, "REDIRREFARGSFLOOR", REDIRREFARGSFLOOR, NULL, -1);
confline(op, "FAILREFFLOOR", FAILREFFLOOR, NULL, -1);
confline(op, "FAILREFARGSFLOOR", FAILREFARGSFLOOR, NULL, -1);
confline(op, "BROWREPFLOOR", BROWREPFLOOR, NULL, -1);
confline(op, "BROWSUMFLOOR", BROWSUMFLOOR, NULL, -1);
confline(op, "SUBBROWFLOOR", SUBBROWFLOOR, NULL, -1);
confline(op, "OSFLOOR", OSFLOOR, NULL, -1);
confline(op, "SUBOSFLOOR", SUBOSFLOOR, NULL, -1);
confline(op, "VHOSTFLOOR", VHOSTFLOOR, NULL, -1);
confline(op, "REDIRVHOSTFLOOR", REDIRVHOSTFLOOR, NULL, -1);
confline(op, "FAILVHOSTFLOOR", FAILVHOSTFLOOR, NULL, -1);
confline(op, "USERFLOOR", USERFLOOR, NULL, -1);
confline(op, "REDIRUSERFLOOR", REDIRUSERFLOOR, NULL, -1);
confline(op, "FAILUSERFLOOR", FAILUSERFLOOR, NULL, -1);
confline(op, "SEARCHQUERYFLOOR", SEARCHQUERYFLOOR, NULL, -1);
confline(op, "SEARCHWORDFLOOR", SEARCHWORDFLOOR, NULL, -1);
confline(op, "INTSEARCHQUERYFLOOR", INTSEARCHQUERYFLOOR, NULL, -1);
confline(op, "INTSEARCHWORDFLOOR", INTSEARCHWORDFLOOR, NULL, -1);
confline(op, "STATUSFLOOR", STATUSFLOOR, NULL, -1);
confline(op, "REPORTORDER", REPORTORDER, NULL, -1);
op->outopts.barstyle = BARSTYLE;
op->outopts.markchar = MARKCHAR;
op->outopts.rawbytes = RAWBYTES;
op->outopts.bytesdp = BYTESDP;
op->outopts.norobots = NOROBOTS;
COPYSTR(op->outopts.hostname, HOSTNAME);
COPYSTR(op->outopts.hosturl, HOSTURL);
op->outopts.baseurl = NULL;
COPYSTR(op->outopts.logo, LOGO);
COPYSTR(op->outopts.logourl, LOGOURL);
COPYSTR(op->outopts.stylesheet, STYLESHEET);
COPYSTR(op->outopts.cssprefix, CSSPREFIX);
op->outopts.weekbeginson = WEEKBEGINSON;
op->outopts.plainpagewidth = PLAINPAGEWIDTH;
op->outopts.htmlpagewidth = HTMLPAGEWIDTH;
op->outopts.latexpagewidth = LATEXPAGEWIDTH;
op->outopts.mingraphwidth = MINGRAPHWIDTH;
op->outopts.sepchar = (char)UNSET;
op->outopts.repsepchar = (char)UNSET;
op->outopts.decpt = (char)UNSET;
COPYSTR(op->outopts.compsep, COMPSEP);
for (i = 0; i < GENREP_NUMBER; i++) {
op->outopts.link[i] = NULL;
op->outopts.wanthead[i] = NULL;
op->outopts.aliashead[i] = NULL;
op->outopts.expandhead[i] = NULL;
op->outopts.tree[i] = (Tree *)xmalloc(sizeof(Tree));
op->outopts.tree[i]->tree = NULL;
op->outopts.tree[i]->space = (Memman *)xmalloc(sizeof(Memman));
op->outopts.tree[i]->space->curr_pos = NULL;
op->outopts.tree[i]->space->first = NULL;
op->outopts.tree[i]->space->alignment = ALIGNSIZE;
}
domlevels = (Strpairlist **)xmalloc(DOMLEVEL_NUMBER * sizeof(Strpairlist *));
for (i = 0; i < DOMLEVEL_NUMBER; i++)
domlevels[i] = NULL;
op->outopts.tree[G(REP_REQ)]->cutfn = &rnextname;
op->outopts.tree[G(REP_REDIR)]->cutfn = &rnextname;
op->outopts.tree[G(REP_FAIL)]->cutfn = &rnextname;
op->outopts.tree[G(REP_REF)]->cutfn = &rnextname;
op->outopts.tree[G(REP_REDIRREF)]->cutfn = &rnextname;
op->outopts.tree[G(REP_FAILREF)]->cutfn = &rnextname;
op->outopts.tree[G(REP_TYPE)]->cutfn = &tnextname;
op->outopts.tree[G(REP_DIR)]->cutfn = &inextname;
op->outopts.tree[G(REP_DOM)]->cutfn = &onextname;
op->outopts.tree[G(REP_REFSITE)]->cutfn = &snextname;
op->outopts.tree[G(REP_BROWSUM)]->cutfn = &bnextname;
op->outopts.tree[G(REP_OS)]->cutfn = &pnextname;
op->outopts.tree[G(REP_ORG)]->cutfn = &Znextname;
for (i = 0; i < DERVREP_NUMBER; i++) {
op->outopts.derv[i] = (Derv *)xmalloc(sizeof(Derv));
op->outopts.derv[i]->table = rehash(NULL, HASHSIZE, NULL);
op->outopts.derv[i]->space = (Memman *)xmalloc(sizeof(Memman));
op->outopts.derv[i]->space->curr_pos = NULL;
op->outopts.derv[i]->space->first = NULL;
op->outopts.derv[i]->space->alignment = 1;
}
op->outopts.derv[REP_SEARCHREP - FIRST_DERVREP]->cutfn = &Nnextname;
op->outopts.derv[REP_SEARCHSUM - FIRST_DERVREP]->cutfn = &nnextname;
op->outopts.derv[REP_INTSEARCHREP - FIRST_DERVREP]->cutfn = &Nnextname;
op->outopts.derv[REP_INTSEARCHSUM - FIRST_DERVREP]->cutfn = &nnextname;
op->outopts.derv[REP_BROWSUM - FIRST_DERVREP]->cutfn = &Bnextname;
op->outopts.derv[REP_OS - FIRST_DERVREP]->cutfn = &Pnextname;
/* derv[*]->arg is set in finalinit so that lists of search engines and
robots have already been read in */
op->outopts.suborgs = NULL;
for (i = 0; i < LOGDATA_NUMBER; i++)
op->miscopts.data[i] = 0;
op->miscopts.bytes = 0.0;
op->miscopts.bytes7 = 0.0;
confline(op, "REQARGS", "*?*", NULL, -1);
confline(op, "REDIRARGS", "*?*", NULL, -1);
confline(op, "FAILARGS", "*?*", NULL, -1);
confline(op, "REFARGS", "*?*", NULL, -1);
confline(op, "REDIRREFARGS", "*?*", NULL, -1);
confline(op, "FAILREFARGS", "*?*", NULL, -1);
confline(op, "SUBDOMAIN", "*", NULL, -1);
confline(op, "SUBORG2", "*", NULL, -1);
confline(op, "SUBDIR", "*", NULL, -1);
confline(op, "SUBTYPE", "*", NULL, -1);
confline(op, "REFDIR", "*", NULL, -1);
confline(op, "SUBBROW", "*", NULL, -1);
confline(op, "SUBOS", "*:*", NULL, -1);
for (i = 0; i < ITEM_NUMBER; i++) {
op->wanthead[i] = NULL;
op->aliashead[i] = NULL;
op->hash[i] = rehash(NULL, HASHSIZE, NULL);
op->miscopts.lowmem[i] = 0;
}
for (i = 0; i < MIN_SC; i++)
op->code2type[i] = UNWANTED;
for ( ; i < SC_NUMBER; i++)
op->code2type[i] = UNSET;
op->code2type[0] = UNSET; /* code2type[0] used as a special marker in ... */
op->succ304 = TRUE; /* ... configsinex(), correctlogfmt() & finalinit() */
for (i = 0; i < ARRAYREP_NUMBER; i++) {
if (i == REP_CODE - FIRST_ARRAYREP)
thresh = codethresh;
else if (i == REP_SIZE - FIRST_ARRAYREP)
thresh = sizethresh;
else
thresh = ptthresh;
for (k = 0; thresh[k] > -0.5; k++)
; /* find size of array */
k++;
op->arraydata[i] = (Arraydata *)xmalloc(k * sizeof(Arraydata));
for (j = 0; j < k; j++) {
op->arraydata[i][j].threshold = thresh[j];
op->arraydata[i][j].reqs = 0;
op->arraydata[i][j].pages = 0;
op->arraydata[i][j].bytes = 0.0;
op->arraydata[i][j].reqs7 = 0;
op->arraydata[i][j].pages7 = 0;
op->arraydata[i][j].bytes7 = 0.0;
op->arraydata[i][j].lastdate = 0;
op->arraydata[i][j].firstdate = LAST_TIME;
}
}
op->searchengines = NULL;
op->intsearchengines = NULL;
op->robots = NULL;
op->ispagehead = NULL;
op->argshead = NULL;
op->refargshead = NULL;
confline(op, "PAGEINCLUDE", "*/", NULL, -1);
confline(op, "PAGEINCLUDE", "REGEXPI:\\.html?$", NULL, -1);
op->dman.fromstr = NULL;
op->dman.tostr = NULL;
op->dman.currdp = NULL;
op->dman.firstdp = NULL;
op->dman.lastdp = NULL;
op->dman.firsttime = LAST_TIME;
op->dman.lasttime = FIRST_TIME;
}
Jump to Line
Something went wrong with that request. Please try again.