source: trunk/gsdl/src/w32server/cgiwrapper.cpp@ 1011

#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <direct.h>
#include "cgiwrapper.h"
#include "netio.h"
#include "wincgiutils.h"
#include "settings.h"
#include "fileutil.h"

#include "gsdlconf.h"
#include "recptconfig.h"

#if defined (GSDL_USE_OBJECTSPACE)
#include <ospace\std\iostream>
#include <ospace\std\fstream>
#elif defined (GSDL_USE_IOS_H)
#include <iostream.h>
#include <fstream.h>
#else
#include <iostream>
#include <fstream>
#endif

#include "receptionist.h"
#include "nullproto.h"
#include "collectserver.h"
#include "infodbclass.h"
#include "mggdbmsource.h"

// actions
#include "action.h"
#include "statusaction.h"
#include "pageaction.h"
#include "pingaction.h"
#include "queryaction.h"
#include "documentaction.h"
#include "authenaction.h"
#include "usersaction.h"
#include "extlinkaction.h"
//#include "buildaction.h"
#include "delhistoryaction.h"

// browsers
#include "browserclass.h"
#include "vlistbrowserclass.h"
#include "hlistbrowserclass.h"
#include "datelistbrowserclass.h"
#include "invbrowserclass.h"
#include "pagedbrowserclass.h"
#include "htmlbrowserclass.h"

// filters
#include "filter.h"
#include "browsefilter.h"
#include "queryfilter.h"
#include "phrasequeryfilter.h"

// the number of times the library has been accessed
int libaccessnum = 0;

// used to output the text from receptionist
class textstreambuf : public streambuf
{
public:
  textstreambuf ();
  int sync ();
  int overflow (int ch);
  int underflow () {return EOF;}
  
  void tsbreset() {RInfo=NULL;casostr=NULL;}
  void setrequestinfo (RequestInfoT *theRInfo) {RInfo=theRInfo;}
  void cascadeoutput (ostream *thecasostr) {casostr=thecasostr;}
  
private:
  RequestInfoT *RInfo;
  ostream *casostr;
};

textstreambuf::textstreambuf() {
  tsbreset();
  if (base() == ebuf()) allocate();
  setp (base(), ebuf());
};

int textstreambuf::sync () {
  if ((RInfo != NULL) && 
      (Send_String_N(pbase(), out_waiting(), RInfo) < 0)) {
    RInfo = NULL;
  }
  
  if (casostr != NULL) {
    char *thepbase=pbase();
        for (int i=0;i<out_waiting();i++) (*casostr).put(thepbase[i]);
  }
  
  setp (pbase(), epptr());
  
  return 0;
}

int textstreambuf::overflow (int ch) {
  if (sync () == EOF) return EOF;
  if (ch != EOF) sputc (ch);
  return 0;
}


// used to output all the log and error messages
// from receptionist
class logstreambuf : public streambuf
{
public:
  logstreambuf ();
  int sync ();
  int overflow (int ch);
  int underflow () {return EOF;}
};

logstreambuf::logstreambuf () {
  if (base() == ebuf()) allocate();
  setp (base(), ebuf());
}

int logstreambuf::sync () {
  if (gsdl_keep_log || gsdl_show_console) {
    log_message ("LOCAL LIB MESSAGE: ");
        log_message_N (pbase(), out_waiting());
  }

  setp (pbase(), epptr());
  return 0;
}

int logstreambuf::overflow (int ch) {
  if (sync () == EOF) return EOF;
  if (ch != EOF) sputc (ch);
  return 0;
}



#ifndef MAX_FILENAME_SIZE
#define MAX_FILENAME_SIZE 2048
#endif


receptionist recpt;
nullproto nproto;
textstreambuf textstream;
logstreambuf logstream;
DWORD lastlibaccesstime;
DWORD baseavailvirtual;

static void page_errorsitecfg (const text_t &gsdlhome, const text_t &collection) {
    
  text_t message = "Error\n\n"
    "The site.cfg configuration file could not be found. This file\n"
    "should contain configuration information relating to this sites\n"
    "setup.\n";
  
  if (collection.empty()) {
    message += "As this program is not being run in collection specific mode,\n"
      "the file should reside at " + gsdlhome + "\\etc\\site.cfg.\n";
  } else {
    message += "As this program is being run in collection specific mode,\n"
      "the file can reside at " + gsdlhome + "\\collect\\" + collection +
      "\\etc\\site.cfg or " + gsdlhome + "\\etc\\site.cfg.\n";
  }

  MessageBox(NULL, message.getcstr(),
         "Greenstone Digital Library Software"
         ,MB_OK|MB_SYSTEMMODAL);
}

static void page_errormaincfg (const text_t &gsdlhome, const text_t &collection) {

  if (collection.empty()) {
    text_t message = "Error\n\n"
      "The main.cfg configuration file could not be found. This file\n"
      "should contain configuration information relating to the\n"
      "setup of the interface. As this program is not being run\n"
      "in collection specific mode the file should reside at\n" +
      gsdlhome + "\\etc\\main.cfg.\n";

    MessageBox(NULL, message.getcstr(),
           "Greenstone Digital Library Software"
           ,MB_OK|MB_SYSTEMMODAL);
  } else {
    text_t message = "Neither the collect.cfg or main.cfg configuration files could\n"
      "be found. This file should contain configuration information\n"
      "relating to the setup of the interface. As this cgi script is\n"
      "being run in collection specific mode the file should reside\n"
      "at either " + gsdlhome + "\\collect\\" + collection + "\\etc\\collect.cfg,\n" +
      gsdlhome + "\\etc\\collect.cfg or " + gsdlhome + "\\etc\\main.cfg.\n";

    MessageBox(NULL, message.getcstr(),
           "Greenstone Digital Library Software"
           ,MB_OK|MB_SYSTEMMODAL);
  }
}

static void page_errorinit (const text_t &/*gsdlhome*/) {

  text_t message = "Error\n\n"
    "An error occurred during the initialisation of the Greenstone Digital\n"
    "Library software. It is likely that the software has not been setup\n"
    "correctly.\n";

  MessageBox(NULL, message.getcstr(),
         "Greenstone Digital Library Software"
         ,MB_OK|MB_SYSTEMMODAL);
}

static void page_errorparseargs (const text_t &gsdlhome) {

  text_t message = "Error\n\n"
    "An error occurred during the parsing of the cgi arguments.\n";

  MessageBox(NULL, message.getcstr(),
         "Greenstone Digital Library Software"
         ,MB_OK|MB_SYSTEMMODAL);
}

static void page_errorcgipage (const text_t &gsdlhome) {

  text_t message = "Error\n\n"
    "An error occurred during the construction of the cgi page.\n";

  MessageBox(NULL, message.getcstr(),
         "Greenstone Digital Library Software"
         ,MB_OK|MB_SYSTEMMODAL);
}

// returns 0 if the directories can't be found
// and the user wants to quit (it returns 1
// if everything is ok)
int checkdir (const text_t &thedir) {
  UINT curerrormode;
  int drive = _getdrive();
  char cwd[1024];
  char rootpath[4];
  UINT drivetype;
  char *cstrthedir = thedir.getcstr();
  int returnvalue = 1;
  
  // make sure no rude error messages are presented to the user
  curerrormode = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
  
  // get the drive name
  if (thedir.size() >= 2 && thedir[1] == ':') {
    if (thedir[0] >= 'a' && thedir[0] <= 'z') {
      drive = thedir[0] - 'a' + 1;
      
    } else if (thedir[0] >= 'A' && thedir[0] <= 'Z') {
      drive = thedir[0] - 'A' + 1;
    }
  }
  
  // find the drive type
  rootpath[0] = drive + 'A' - 1;
  rootpath[1] = ':';
  rootpath[2] = '\\';
  rootpath[3] = '\0';
  drivetype = GetDriveType (rootpath);
  
  // try and set this directory to be the current working
  // directory
  _getcwd(cwd, 1024);
  while (_chdir(cstrthedir) != 0) {
    // failed
    if (drivetype == DRIVE_CDROM) {
      // message to insert the cdrom
      if (MessageBox (NULL, 
              "Please insert the Greenstone Digital Library\n"
              "CD-ROM into the CD-ROM drive and press 'OK'.\n\n"
              "If you don't have the CD-ROM press 'Cancel' to exit\n"
              "this program.", "Greenstone Digital Library Software", 
              MB_OKCANCEL | MB_TASKMODAL) == IDCANCEL) {
    
    returnvalue = 0;
    break;
      }
      
    } else {
      // message saying that the system was unable
      // to find a certain directory
      text_t message = "Failed to find the directory:\n\n" + thedir;
      message += "\n\n"
    "This directory is needed for the successful operation\n"
    "of this software. Make sure it hasn't been deleted or\n"
    "moved, and restart the software. You may need to\n"
    "reinstall this software to correct the problem.";
      char *cstrmessage = message.getcstr();
      
      MessageBox (NULL, cstrmessage, "Greenstone Digital Library Software",
          MB_OK | MB_TASKMODAL);
      
      delete cstrmessage;
      
      returnvalue = 0;
      break;
    }
  }
  
  // revert to the previous error and cwd states
  _chdir(cwd);
  SetErrorMode(curerrormode);
  
  // free the allocated C string
  delete cstrthedir;
  
  return returnvalue;
}


// c-string version of checkdir for the outside
// world
int cstrcheckdir (char *cstrthedir) {
  return checkdir (cstrthedir);
}


// returns 1 if successful, 0 if unsuccessful
int gsdl_init () {
  cerr = &logstream;
  cout = &textstream;

  // collection should be set to "" unless in 
  // collection specific mode
  text_t collection = "";
  text_tset gsdlhomes;
  text_tarray collections;
  colinfo_tmap::const_iterator this_info = gsdl_collectinfo.begin();
  colinfo_tmap::const_iterator end_info = gsdl_collectinfo.end();

  // note the current time
  lastlibaccesstime = GetTickCount();

  // before we do the init we should make sure
  // that we can find the relevant directories
  if (!checkdir (gsdl_gsdlhome + "\\")) return 0;
  if (!checkdir (gsdl_gsdlhome + "\\macros\\")) return 0;

  if (collection.empty()) {

    // get all collections from each gsdlhome (this relies 
    // on there not being more than one collection with the same 
    // name)
    read_dir (filename_cat (gsdl_gsdlhome, "collect"), collections);
    gsdlhomes.insert (gsdl_gsdlhome);
    while (this_info != end_info) {
      if (gsdlhomes.find ((*this_info).second.gsdl_gsdlhome) == gsdlhomes.end()) {
    read_dir (filename_cat ((*this_info).second.gsdl_gsdlhome, "collect"), collections);
    gsdlhomes.insert ((*this_info).second.gsdl_gsdlhome);
      }
      this_info ++;
    }
  } else {
    collections.push_back (collection);
  }
  
  text_tarray::const_iterator thiscol = collections.begin();
  text_tarray::const_iterator endcol = collections.end();

  while (thiscol != endcol) {

    // this memory is created but never destroyed
    // we're also not doing any error checking to make sure we didn't
    // run out of memory
    collectserver *cserver = new collectserver();
    gdbmclass *gdbmhandler = new gdbmclass();
    mgsearchclass *mgsearch = new mgsearchclass();
    
    // add a null filter
    filterclass *filter = new filterclass();
    cserver->add_filter (filter);
    
    // add a browse filter
    browsefilterclass *browsefilter = new browsefilterclass();
    browsefilter->set_gdbmptr (gdbmhandler);
    cserver->add_filter (browsefilter);
    
    // add a query filter
    queryfilterclass *queryfilter = new queryfilterclass();
    queryfilter->set_gdbmptr (gdbmhandler);
    queryfilter->set_mgsearchptr (mgsearch);
    cserver->add_filter (queryfilter);
    
    // add an mg and gdbm source
    mggdbmsourceclass *mggdbmsource = new mggdbmsourceclass();
    mggdbmsource->set_gdbmptr (gdbmhandler);
    mggdbmsource->set_mgsearchptr (mgsearch);
    cserver->add_source (mggdbmsource);
    
    // inform collection server and everything it contains about
    // its collection name
    cserver->configure ("collection", *thiscol);
    
    nproto.add_collectserver (cserver);
    
    thiscol ++;
  }
  
  // add the protocol to the receptionist
  recpt.add_protocol (&nproto);

  // add other converters
  utf8inconvertclass *utf8inconvert = new utf8inconvertclass();
  utf8outconvertclass *utf8outconvert = new utf8outconvertclass();
  recpt.add_converter ("u", utf8inconvert, utf8outconvert);
  
  mapinconvertclass *gbinconvert = new mapinconvertclass();
  gbinconvert->setmapfile (gsdl_gsdlhome, "gbku", 0x25a1);
  mapoutconvertclass *gboutconvert = new mapoutconvertclass();
  gboutconvert->setmapfile (gsdl_gsdlhome, "ugbk", 0xa1f5);
  recpt.add_converter ("g", gbinconvert, gboutconvert);
  
  // the list of actions.
  statusaction *astatusaction = new statusaction();
  astatusaction->set_receptionist (&recpt);
  recpt.add_action (astatusaction);
  
  pageaction *apageaction = new pageaction();
  recpt.add_action (apageaction);
  
  pingaction *apingaction = new pingaction();
  recpt.add_action (apingaction);
  
  queryaction *aqueryaction = new queryaction();
  recpt.add_action (aqueryaction);
  
  documentaction *adocumentaction = new documentaction();
  recpt.add_action (adocumentaction);
  
  usersaction *ausersaction = new usersaction();
  recpt.add_action (ausersaction);

  extlinkaction *anextlinkaction = new extlinkaction();
  recpt.add_action (anextlinkaction);

  //  buildaction *abuildaction = new buildaction();
  //  abuildaction->set_receptionist (&recpt);
  //  recpt.add_action (abuildaction);
  
  authenaction *aauthenaction = new authenaction();
  aauthenaction->set_receptionist(&recpt);
  recpt.add_action (aauthenaction);

  delhistoryaction adelhistoryaction;
  recpt.add_action(&adelhistoryaction);


  // list of browsers
  vlistbrowserclass *avlistbrowserclass = new vlistbrowserclass();
  recpt.add_browser (avlistbrowserclass);
  recpt.setdefaultbrowser ("VList");

  hlistbrowserclass *ahlistbrowserclass = new hlistbrowserclass();
  recpt.add_browser (ahlistbrowserclass);

  datelistbrowserclass *adatelistbrowserclass = new datelistbrowserclass();
  recpt.add_browser (adatelistbrowserclass);

  invbrowserclass *ainvbrowserclass = new invbrowserclass();
  recpt.add_browser (ainvbrowserclass);

  pagedbrowserclass *apagedbrowserclass = new pagedbrowserclass();
  recpt.add_browser (apagedbrowserclass);

  htmlbrowserclass *ahtmlbrowserclass = new htmlbrowserclass();
  recpt.add_browser (ahtmlbrowserclass);
  
  // set defaults
  recpt.configure ("gsdlhome", gsdl_gsdlhome);
  recpt.configure ("collection", collection);

  int maxrequests = 1;
  text_tset seenhomes;
  this_info = gsdl_collectinfo.begin();

  // configure any collections with gsdlhome (or gdbmhome) 
  // different from the default
  while (this_info != end_info) {
    if (((*this_info).second.gsdl_gsdlhome != gsdl_gsdlhome) ||
    ((*this_info).second.gsdl_gdbmhome != gsdl_gdbmhome) &&
    (seenhomes.find ((*this_info).second.gsdl_gsdlhome + 
             (*this_info).second.gsdl_gdbmhome) == seenhomes.end())) {
      text_tarray tmpconf;
      tmpconf.push_back ((*this_info).first);
      tmpconf.push_back ((*this_info).second.gsdl_gsdlhome);
      tmpconf.push_back ((*this_info).second.gsdl_gdbmhome);
      recpt.configure ("collectinfo", tmpconf);
      seenhomes.insert ((*this_info).second.gsdl_gsdlhome + 
            (*this_info).second.gsdl_gdbmhome);
    }
    this_info ++;
  }

  // read in config files of each gsdlhome (in no particular order)
  // those read in last will override those read earlier
  // collections being used together in this way should be 
  // careful not to have site.cfg or main.cfg files that might 
  // screw with each other.
  text_tset::const_iterator thome = gsdlhomes.begin();
  text_tset::const_iterator ehome = gsdlhomes.end();
  while (thome != ehome) {
    // TODO: should only need to do this once now I think
    // gsdlsite.cfg will need to be installed along with executable
    //    if (!site_cfg_read (recpt, *thome, maxrequests)) {
      // couldn't find the site configuration file
    //      page_errorsitecfg (*thome, collection);
    //      return 0;
    //    } else 
    if (!main_cfg_read (recpt, *thome, collection)) {
      // couldn't find the main configuration file
      page_errormaincfg (*thome, collection);
      return 0;
    }
    thome ++;
  }

  // w32server relies on gwcgi being set to "gw"
  recpt.configure ("gwcgi", "gw");
    
  // initialise the library software
  if (!recpt.init(cerr)) {
    // an error occurred during the initialisation
    page_errorinit(gsdl_gsdlhome);
    return 0;
  }

  // get memory information
  MEMORYSTATUS memstatus;
  memstatus.dwLength = sizeof(MEMORYSTATUS);
  GlobalMemoryStatus(&memstatus);
  baseavailvirtual = memstatus.dwAvailVirtual; // save for later comparison
    
  return 1;
}


static void rememberpref (char *tailstr) {

  //  gsdl_enterlib = tailstr;
}


static void send_file_from_disk(char *filename,
                                RequestInfoT *RInfo,
                                RequestFieldsT *RFields)
{
  int len, nr;  char *tail, *kind;
  FILE *thefile;  
  
  // select appropriate mime type from file name
  len = strlen(filename);
  while (len > 0 && filename[len-1] != '.') len--;
  kind = "unknown";
  if (len > 0) {
    tail = &filename[len];
    if (stricmp("gif",tail) == 0) kind = "image/gif";
    else if (stricmp("jpg",tail) == 0 ||
             stricmp("jpeg",tail) == 0) kind = "image/jpeg";
    else if (stricmp("htm",tail) == 0 ||
             stricmp("html",tail) == 0) kind = "text/html";
  }

  // set up file name
  text_t filenamet = text_t(gsdl_gsdlhome) + filename;
  text_t::iterator here = filenamet.begin();
  text_t::iterator end = filenamet.end();
  while (here != end) {
      if (*here == '/') *here = '\\';
      here ++;
  }

  filename = filenamet.getcstr();
    
  // try to open it
  thefile = fopen(filename, "rb");
  if (thefile == NULL) {
    log_message("file not found\n");
    send_retrieve_error(404, "File not found",
            "Could not find the local file requested", RInfo);
    return;
  }
  
  char buffer[2048];
  // send back required information
  if (send_header(kind, RInfo) >= 0) {
    if (strcmpi(RFields->MethodStr, "HEAD") != 0) {
      for (;;) {
        nr = fread(buffer, 1, 2048, thefile);
        if (nr <= 0) break;
        if (SendData(RInfo->ClientSocket,
                     (BYTE *)buffer, nr,
             RInfo->ThreadNum) < 0) break;        
      }
    }
  }
  fclose(thefile);
}

static void handle_library_request(char *TailStr, RequestInfoT *RInfo,
                   RequestFieldsT *RequestFields) {
  // check for a "?" at the start of the tail string
  if (*TailStr == '?') TailStr++;

  outconvertclass text_t2ascii;
  
  // parse the cgi arguments and produce the resulting page if there
  // has been no errors so far
  cgiargsclass args;
  text_tmap empty; // don't use this (it's for fastcgi on unix)
  if (!recpt.parse_cgi_args (TailStr, args, cerr, empty)) {
    page_errorparseargs(gsdl_gsdlhome);
    return;
  } 
  
  // produce cgi header
  response_t response;
  text_t response_data;

  recpt.get_cgihead_info (args, response, response_data, cerr, empty);

  if (response == location) {
    // location response
    response_data = "@" + recpt.expandmacros (response_data, args, cerr);
    char *response_data_c = response_data.getcstr();
    send_header(response_data_c, RInfo);
    delete response_data_c;
    return;
  } else if (response == content) {
    // content response
    char *response_data_c = response_data.getcstr();
    if (send_header(response_data_c, RInfo) < 0) {
      delete response_data_c;
      return;
    }
    delete response_data_c;
  } else {
    // unknown response
    cerr << "Error: get_cgihead_info returned an unknown response type.\n";
    return;
  }

  textstream.tsbreset();
  textstream.setrequestinfo (RInfo);
  
  if (!recpt.produce_content (args, cout, cerr)) {
    page_errorcgipage(gsdl_gsdlhome);
    return;
  } 
  recpt.log_cgi_args (args, cerr, empty);

  cout << flush;
  cerr << flush;
  
  libaccessnum++;
}

static void handle_server_request(char *initialTailStr, 
                  RequestInfoT *RequestInfo,
                  RequestFieldsT *RequestFields) {
  char tmpstr[1024];
  char tailstr[MAX_URL_SIZE];
  
  // do any url adjustments necessary
  if (strcmp(initialTailStr, "/") == 0) {
    strcpy (tailstr, "/cgi-bin/gw");
  } else strcpy (tailstr, initialTailStr);
  
  // test to see if this is a library request or a local
  // file request
  if ((strncmp(tailstr, "/cgi-bin/gw", 11) == 0) &&
      ((tailstr[11] == '\0') || (tailstr[11] == '?'))) {
    // library request
    
    // log the difference in access times
    DWORD thislibaccesstime = GetTickCount();
    if (gsdl_keep_log||gsdl_show_console) {
      sprintf(tmpstr, "DELTA LIB ACCESS TIME: %i\n", (int)(thislibaccesstime - lastlibaccesstime));
      log_message (tmpstr);
    }
    lastlibaccesstime = thislibaccesstime;
    
    // log this request
    if (gsdl_keep_log||gsdl_show_console) {
      sprintf (tmpstr, "LOCAL LIB: %s\n", tailstr);
      log_message (tmpstr);
    }
    
    handle_library_request (&tailstr[11], RequestInfo, RequestFields);
    
    // remember the preferences
    rememberpref (tailstr);
    
    // log memory information
    if (gsdl_keep_log||gsdl_show_console) {
      MEMORYSTATUS memstatus;
      memstatus.dwLength = sizeof(MEMORYSTATUS);
      GlobalMemoryStatus(&memstatus);
      sprintf (tmpstr, "BDELTA AVAIL VIRTUAL: %i K\n", 
           (int)((baseavailvirtual - memstatus.dwAvailVirtual)/1024));
      log_message (tmpstr);
    }
    
  } else {
    // local file
    if (gsdl_keep_log||gsdl_show_console) {
      sprintf (tmpstr, "LOCAL FILE: %s\n", tailstr);
      log_message (tmpstr);
    }
    send_file_from_disk (tailstr, RequestInfo, RequestFields);
  }
}

static void fix_prefix(char *dest, char *pref, char *suff)
{
  strcpy(dest,pref);
  if (*suff != '/') strcat(dest,"/");
  if (strlen(dest) + strlen(suff) + 1 > MAX_URL_SIZE)
    strcpy(dest,"http://gsdl/name-too-long");
  else
    strcat(dest,suff);
}

int ExamineURIStr(char *URIStr,RequestInfoT *RequestInfo,
          RequestFieldsT *RequestFields)
{
  char *protocol, *machine, *rest;  int port;
  char URICopyA[MAX_URL_SIZE], URICopyB[MAX_URL_SIZE];
  strcpy(URICopyA,URIStr);
  
  if (parse_url(URICopyA,&protocol,&machine,&port,&rest)!=http_ok) {
    /* Alter local file request to address 'gsdl' */
    fix_prefix(URICopyB, "http://gsdl", URIStr);
    URIStr = URICopyB;
    strcpy(URICopyA, URICopyB);
    parse_url(URICopyA,&protocol,&machine,&port,&rest);
  }

  if (strncmp(machine, "gsdl", 5) == 0) {
    // a local file request
    handle_server_request(rest, RequestInfo, RequestFields);
    
  } else {
    send_retrieve_error(404, "File not found",
            "Could not find the local file requested", RequestInfo);
  }
  
  return 1;
}