---

logrecord.C

Go to the documentation of this file.

// $Id: logrecord.C,v 1.4 2001/04/12 14:55:55 dvermeir Exp $

#include <string>
#include <ctype.h> // isxdigit, isalnum
#include "logrecord.h"
#include "date.h"

// Retrieve and store relevant information from a line from a log file.
bool
LogRecord::parse_line(const string& line) {
/* Clear current vector<string> data members. This is
   important because parsing will append to path_ and domain_.
*/
path_.clear(); 
domain_.clear();
/* A parse succeeds if all components can be parsed.
   This should be modified so that we only parse what is necessary,
   according to the configuration. But for now, we are too lazy.
*/
return parse_date(line) && parse_path(line) && parse_domain(line);
}

// Retrieve and store date information from a line from a log file.
bool
LogRecord::parse_date(const string& line) {
/* Select date part: just after first '[' up to first folloing ' '
   e.g.

        spider1.tiscalinet.be - - [02/Nov/2000:10:20:36 +0100] ..

   will select

        02/Nov/2000:10:20:36
*/
string::size_type date_start(line.find_first_of('['));
string::size_type date_end(line.find_first_of(' ',date_start));
string            date_string(line,date_start+1,date_end - date_start-1);

/* Make date_string acceptable to the Date::Date(const char*) parser.

   1. replace '/' by '-'. In the example, this will yield 

        02-Nov-2000:10:20:36
*/
for (string::size_type i=0; i<date_string.size(); ++i)
  if (date_string[i]=='/')
    date_string[i] = '-';
/*
   2. Replace first ':' by space. In the example, this will yield 

        02-Nov-2000 10:20:36
*/
date_string.replace(date_string.find_first_of(':'),1," ");

/* Now parse using Date::Date(const string&). It will throw an exception
   if the date cannot be parsed. In that case, we catch the exception
   and return false.
*/
try {
  Date  date(date_string);
  date_ = date;
  // We are only interested in hours, not minutes or seconds.
  date_.minutes(0);
  date_.seconds(0);
  }
catch (exception& e) {
  cerr << "parse_date: " << e.what() << endl;
  return false;
  }
return true;
}


// Return value of hex digit.
static inline int 
hexdigit(char c) { // assert(isxdigit(c))
if (isdigit(c)) 
  return c - '0';
else if (isupper(c))
  return c - 'A' + 10;
else // must be lower case letter
  return c - 'a' +10;
}

// In-place decoding of encoded url, see RFC 1738.
void
www_decode(string& s) {
unsigned int i(0); // input index
unsigned int j(0); // output index
unsigned int len(s.size());
for (i=0; (i<len); ++i,++j)
  switch (s[i]) {
    // case '+': s[j] = ' '; break; // Apparently not used in the log file.
    case '%': // the following 2 characters must be hex digits: 0-9,a-f
      if ((i+2<len) && isxdigit(s[i+1]) && isxdigit(s[i+2])) {
        s[j] = hexdigit(s[i+1])* 16 + hexdigit(s[i+2]);
        i += 2;
        }
      else
        s[j] = s[i];
      break;
    default: s[j] = s[i]; break;
    }
s.resize(j);
}

// Retrieve and store path information from a line from a log file.
bool
LogRecord::parse_path(const string& line) {
/* The path part can be found between the first and second occurrences
   of `"' (double quote). An example is shown below.

    "GET /ssl/kiesoos.cgi?rolnr=58769\&stjcode=5L10021 HTTP/1.0" 

   This will result in 

     _path = <"","ssl","kiesoos.cgi">
*/
string::size_type path_start(line.find_first_of('\"'));
if (path_start==string::npos)
  return false;
/* We are not interested in the verb (e.g. GET), so we skip until after the first ' '.
   In the example, path_start would then point to.

    /ssl/kiesoos.cgi?rolnr=58769\&stjcode=5L10021 HTTP/1.0" 
*/
path_start = line.find_first_of(' ',path_start);
if (path_start==string::npos)
  return false;
++path_start; // After ' '.
/*  We only want the path until the first '?', '#' or ' '. In the example
    this should result in.

    path_string = /ssl/kiesoos.cgi
*/

string::size_type path_end = line.find_first_of("#? ",path_start);
if (path_end==string::npos)
  return false;

if (path_end==path_start) // cannot have an empty path
  return false;

string path_string(line,path_start,path_end - path_start);

// Decode to translate "%7E" back to '~' etc.
www_decode(path_string);

/* Decode the parts of the path_string into a vector. The first component of the
   vector will be empty if the path_string starts with '/'. 
   We also refuse to append empty strings to path_. This handles cases like
   "/a//b" which will result in <"","a","b">.

  We use n0 to indicate the start position of a component and
  n1 to indicate the position just after the end of the component.
*/
string::size_type n0(path_string.find_first_not_of('/'));

if (n0!=0) // the path starts with '/' which we encode as a first "/" component.
  path_.push_back("");

if (n0==string::npos) // path_string must be "/"
  return true;

string::size_type n1(string::npos);

/* The variable n0 points to the start of a component. We make n1 point to
   the next '/', if any. The component then is the substring starting at
   n0 and ending before n1.
*/
while ((n1=path_string.find_first_of('/',n0))!=string::npos) {
  if (n1>n0) // only non-empty parts are stored.
    path_.push_back(path_string.substr(n0,n1-n0));
  n0 = n1+1;
  }
// If path_string does not end with '/', we must still add the final component.
if (n0<path_string.size())
  path_.push_back(path_string.substr(n0));
return true;
}

// Retrieve and store domain information from a line from a log file.
bool
LogRecord::parse_domain(const string& line) {
/* The domain informatin is easy to find: it's the first part of
   a line, followed by a ' ', as illustrated in the following example.

        igwe.vub.ac.be - - [12/Feb/2000:13:18:49 +0100] ...
        
*/
string::size_type domain_start(0);
string::size_type domain_end(line.find_first_of(' '));
if (domain_end==string::npos)
  return false;
string domain_string(line,domain_start,domain_end);

string::size_type n0(domain_string.find_first_not_of('.'));
if (n0!=0)
  return false;
string::size_type n1(string::npos);

while ((n1 = domain_string.find_first_of('.',n0)) != string::npos) {
  if (n1>n0)
    domain_.push_back(domain_string.substr(n0,n1-n0));
  n0 = n1+1;
  }
// If domain does not end with '.', we still need to add a final component.
if (n0<domain_string.size()) 
  domain_.push_back(domain_string.substr(n0));
  
return true;
}

---

httpstats-stage01 [ 7 April, 2001]