---

logrecord.C

Go to the documentation of this file.

// $Id: logrecord.C,v 1.2 2001/04/12 14:55:57 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) {
/* 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  d(date_string);
  date_.set(d.year(),d.month(),d.day(),d.hours());
  }
catch (exception& e) {
  cerr << "LogRecord::parse_date failed: " << 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);

return path_.parse(path_string);
}

// 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);

return domain_.parse(domain_string);
}

---

httpstats-stage02a [ 7 April, 2001]