---

config_processor.cc

/*
*  Name:      config_processor.cc
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   CGI config processor
*  Date:      $Date: 2003/04/14 00:18:35 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1994-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#include <cstdlib>
#include <fstream>
#include <sstream>
#include <mpcl/net/cgi/config_processor.hh>
#include <mpcl/net/cgi/exceptions.hh>
#include <mpcl/net/url_decoder.hh>
#include <mpcl/text/regex/matcher.hh>


//
//  C O N S T R U C T O R S
//

mpcl::net::cgi::TConfigProcessor::
TConfigProcessor ( int          iPARAMETER_COUNT ,
                   const char** ppkcPARAMETERS   )                 :
  util::prefs::TConfigProcessor (iPARAMETER_COUNT, ppkcPARAMETERS) ,
  gHasInput                     (false)
{

  addEnvironmentVariable ("AUTH_TYPE");
  addEnvironmentVariable ("CONTENT_LENGTH");
  addEnvironmentVariable ("CONTENT_TYPE");
  addEnvironmentVariable ("GATEWAY_INTERFACE");
  addEnvironmentVariable ("HTTP_COOKIE");
  addEnvironmentVariable ("HTTP_USER_AGENT");
  addEnvironmentVariable ("PATH_INFO");
  addEnvironmentVariable ("PATH_TRANSLATED");
  addEnvironmentVariable ("QUERY_STRING");
  addEnvironmentVariable ("REMOTE_ADDR");
  addEnvironmentVariable ("REMOTE_HOST");
  addEnvironmentVariable ("REMOTE_IDENT");
  addEnvironmentVariable ("REMOTE_USER");
  addEnvironmentVariable ("REQUEST_METHOD");
  addEnvironmentVariable ("SCRIPT_NAME");
  addEnvironmentVariable ("SERVER_NAME");
  addEnvironmentVariable ("SERVER_PORT");
  addEnvironmentVariable ("SERVER_PROTOCOL");
  addEnvironmentVariable ("SERVER_SOFTWARE");

}  // TConfigProcessor()


void mpcl::net::cgi::TConfigProcessor::processOptions (void)
{

  using std::cin;
  using std::strtoul;

  if ( !gOptionsProcessed )
  {
    //
    //  Due to problems with standard input (random access),
    //  it musts read the entire input in a variable, and then
    //  parses it (yQuery).
    //
    TString   yQuery;

    //
    //  Process options from configuration file (if any).
    //
    processConfigFile();

    //
    //  If REQUEST_METHOD is "POST" then get input form data
    //  from standard input, else get input from QUERY_STRING.
    //
    if ( ( environmentValue ("REQUEST_METHOD") == "GET"  ) ||
         ( environmentValue ("REQUEST_METHOD") == "HEAD" )  )
    {
      //
      //  REQUEST_METHOD is GET or HEAD.
      //
      yQuery = environmentValue ("QUERY_STRING");
    }
    else if ( environmentValue ("REQUEST_METHOD") == "POST" )
    {
      //
      //  REQUEST_METHOD is POST.
      //  The  environment variable  CONTENT_LENGTH  contains the length of the
      //  string to be read from standard input.
      //

      long unsigned int   luiContentLength;
      char*               pcBuffer;
      
      luiContentLength = strtoul (environmentValue ("CONTENT_LENGTH").c_str(), NULL, 10);
      pcBuffer         = new char [luiContentLength + 1];
      cin.read (pcBuffer, luiContentLength);
      pcBuffer [luiContentLength] = '\0';
      yQuery                      = pcBuffer;
      delete [] pcBuffer;
    }
    else
    {
      throw TBadFormException ("not supported REQUEST_METHOD", __FILE__, __LINE__);
    }

    //
    //  Loads form data encoded using 'application/x-www-form-urlencoded' media
    //  type.
    //
    {
      std::basic_istringstream<char>   tQueryIstringstream (yQuery);

      readFormData (tQueryIstringstream);
      gOptionsProcessed = true;
    }
  }

}  // processOptions()


void mpcl::net::cgi::TConfigProcessor::processCommandLine (void)
{

  for (register int J = 1; ( J < iParametersCount ) ;++J)
  {
    updateOptionWithName (ppkcParametersList [J], "");
  }

}  // processCommandLine()


void mpcl::net::cgi::TConfigProcessor::
readFormData (std::basic_istream<char_type, traits_type>& rtSOURCE_ISTREAM)
{

  using text::html::kcIdentifierValueSeparator;
  using text::regex::TMatcher;

  TString    yName;
  TString    yValue;
  TMatcher   tMatcher (rtSOURCE_ISTREAM);
  bool       gSuccess = true;

  //
  //  CGI form submission message body format:
  //
  //    [{<name_1>=[<value_1>]&}<name_n>=[<value_n>]]
  //
  //  <value> can be formed by spaces (that are changed by '+' spaces),
  //  other characters can be escaped by %NN construction, that means
  //  the character with ASCII value 0xNN.
  //

  while ( gSuccess )
  {
    gSuccess = ( tMatcher.scan ("%t=%t&", &yName, &yValue, NULL) > 0 );
    if ( !gSuccess )
    {
      gSuccess = ( tMatcher.scan ("%t=%t", &yName, &yValue, NULL) > 0 );
    }
    if ( gSuccess )
    {
      TString::size_type   zSeparatorOffset = 0;
      TString::size_type   zPointOffset     = 0;

      yName  = TUrlDecoder::_decode (yName.c_str());
      yValue = TUrlDecoder::_decode (yValue.c_str());
      if ( TString::npos != (zSeparatorOffset = yName.find (kcIdentifierValueSeparator)) )
      {
        if ( TString::npos != (zPointOffset = yName.find ('.', zSeparatorOffset)) )
        {
          //
          //  Case:  <identifier>:<value>.x=<x position>
          //         <identifier>:<value>.y=<y position>
          //
          yValue = yName.substr (zSeparatorOffset + 1, zPointOffset - zSeparatorOffset - 1);
          yName  = yName.substr (0, zSeparatorOffset);
        }
        else
        {
          //
          //  Case:  <identifier>:<value>=<value>
          //
          yName = yName.substr (0, zSeparatorOffset);
        }
      } 
      updateFormOption (yName, yValue);
      gHasInput = true;
    }
  }

}  // read()


mpcl::util::prefs::TOption& mpcl::net::cgi::TConfigProcessor::
updateFormOption (const TString& rkyNAME, const TString& rkyVALUE)
{

  bool                            gFound = false;
  TOptionVector::const_iterator   ktEnd  = tFormOptionVector.end();
  TOptionVector::iterator         I      = tFormOptionVector.begin();

  if ( !rkyNAME.empty() )
  {
    for (; ( I != ktEnd ) ;++I)
    {
      if ( I->name() == rkyNAME )
      {
        if ( !I->hasValue (rkyVALUE) )
        {
          I->addValue (rkyVALUE);
        }
        gFound = true;
        break;
      }
    }
  }
  if ( !gFound )
  {
    TOption   tNewOption (rkyNAME, "", "");

    //
    //  If there is no such option, it adds a new one,
    //  and adds to the new option, the first value.
    //
    tNewOption.addValue (rkyVALUE);
    tFormOptionVector.push_back (tNewOption);
    I = tFormOptionVector.end() - 1;
  }
  return *I;

}  // updateFormOption()


mpcl::util::prefs::TOption& mpcl::net::cgi::TConfigProcessor::
updateOptionWithName ( const TString& rkyNAME  ,
                       const TString& rkyVALUE )
{

  bool                            gFound = false;
  TOptionVector::const_iterator   ktEnd  = tOptionVector.end();
  TOptionVector::iterator         I      = tOptionVector.begin();

  if ( !rkyNAME.empty() )
  {
    for (; ( I != ktEnd ) ;++I)
    {
      if ( I->name() == rkyNAME )
      {
        if ( !I->hasValue (rkyVALUE) )
        {
          I->addValue (rkyVALUE);
        }
        gFound = true;
        break;
      }
    }
  }
  if ( !gFound )
  {
    TOption   tNewOption (rkyNAME, "", "");

    //
    //  If there is no such option, it adds a new one,
    //  and adds to the new option, the first value.
    //
    tNewOption.addValue (rkyVALUE);
    tOptionVector.push_back (tNewOption);
    I = tOptionVector.end() - 1;
  }
  return *I;

}  // updateOption()


//
//  S E L E C T O R S
//

const mpcl::text::TString& mpcl::net::cgi::TConfigProcessor::
getFormValue (const char* pkcNAME) const
{

  using mpcl::text::Format;
  using mpcl::text::TString;
  using std::vector;

  TOptionVector::iterator         I     = tFormOptionVector.begin();
  TOptionVector::const_iterator   ktEnd = tFormOptionVector.end();
  
  for (; ( I != ktEnd ) ;++I)
  {
    if ( I->name() == pkcNAME )
    {
      break;
    } 
  }
  if ( I == ktEnd )
  {
    TString   yMessage;
    
    yMessage = Format ("form option '%s' not found", pkcNAME);
    throw TVariableNotFoundException (yMessage, __FILE__, __LINE__);
  }
  return I->getValue();

}  // getFormValue()


bool mpcl::net::cgi::TConfigProcessor::
hasFormOption (const TString& rkyNAME) const
{

  bool                            gSuccess = false;
  TOptionVector::const_iterator   ktEnd    = tFormOptionVector.end();
  TOptionVector::iterator         I        = tFormOptionVector.begin();
  
  for (; ( I != ktEnd ) ;++I)
  {
    if ( I->name() == rkyNAME )
    {
      gSuccess = true;
      break;
    }
  }
  return gSuccess;

}  // hasFormOption()


bool mpcl::net::cgi::TConfigProcessor::
hasOption (const TString& rkyNAME) const
{

  bool                            gSuccess = false;
  TOptionVector::const_iterator   ktEnd    = tOptionVector.end();
  TOptionVector::iterator         I        = tOptionVector.begin();
  
  for (; ( I != ktEnd ) ;++I)
  {
    if ( I->name() == rkyNAME )
    {
      gSuccess = true;
      break;
    }
  }
  return gSuccess;

}  // hasOption()


void mpcl::net::cgi::TConfigProcessor::
updateForm (text::html::TForm& rtTARGET_FORM) const
{

  TOptionVector::const_iterator   ktEnd = tFormOptionVector.end();
  TOptionVector::iterator         I     = tFormOptionVector.begin();

  rtTARGET_FORM.reset();
  for (; ( I != ktEnd ) ;++I)
  {
    rtTARGET_FORM.setValues (I->name(), I->getValues());
  }

}  // updateForm()

---