CGI.cc

/*
 * $Id: CGI.cc,v 1.38 2006/04/03 15:11:18 brook Exp $
 */

/*
 * ClearSilver++ Software License.
 *
 * Copyright (c) 2005,2006 Brook Milligan <brook@nmsu.edu>
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 * 3. The name of the author may not be used to endorse or promote
 *    products derived from this software without specific prior
 *    written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "CGI.h"

#include <stdexcept>
#if __GNUC__ >= 3
#include <ext/stdio_filebuf.h>
#else
#include <stdiostream.h>
#endif
#include <syslog.h>

#include "ClearSilverError.h"
#include "ClearSilverException.h"
#include "URL.h"

#define CGI ClearSilverCGI
#define HDF ClearSilverHDF
#include <ClearSilver.h>
#undef CGI
#undef HDF

using namespace std;

namespace ClearSilver
{

  static void cgi_free (ClearSilverCGI*);

                                // constructors
  CGI::CGI ()
    : TraceObject(debug(), "CGI"), cgi_(), hdf_()
  {
    ClearSilverCGI* cgi;
    ClearSilverError error (cgi_init (&cgi, 0));
    if (error)
      {
        string message;
        message += "ClearSilver::Nodes::CGI::CGI (const HDF&): ";
        ClearSilverException e (message);
        e += error;
        throw e;
      }
    error = ClearSilverError (cgi_parse (cgi));
    if (error)
      {
        string message;
        message += "ClearSilver::Nodes::CGI::CGI (const HDF&): ";
        ClearSilverException e (message);
        e += error;
        throw e;
      }
    cgi_ = Ptr(cgi, cgi_free);
    hdf_ = HDF(RootNode(cgi_->hdf, true));
  }

  CGI::CGI (const HDF& hdf)
    : TraceObject(debug(), "CGI", "const HDF&"), cgi_(), hdf_(hdf)
  {
    ClearSilverCGI* cgi;
    ClearSilverError error (cgi_init (&cgi, hdf.root().get()));
    if (error)
      {
        string message;
        message += "ClearSilver::Nodes::CGI::CGI (const HDF&): ";
        ClearSilverException e (message);
        e += error;
        throw e;
      }
    error = ClearSilverError (cgi_parse (cgi));
    if (error)
      {
        string message;
        message += "ClearSilver::Nodes::CGI::CGI (const HDF&): ";
        ClearSilverException e (message);
        e += error;
        throw e;
      }
    cgi_ = Ptr(cgi, cgi_free);
  }

  CGI::CGI (const CGI& cgi)
    : TraceObject(cgi), cgi_(cgi.cgi_), hdf_(cgi.hdf_) {}

  CGI::~CGI () throw() {}

                                // assignment
  CGI&
  CGI::operator = (const CGI& cgi)
  {
    TraceObject::operator = (cgi);
    CGI cgi_(cgi);
    swap(cgi_);
    return *this;
  }

                                // swap contents
  void
  CGI::swap (CGI& cgi) throw()
  {
    TraceObject::swap (cgi);
    cgi_.swap(cgi.cgi_);
    hdf_.swap(cgi.hdf_);
  }

                                // conversions
                                // XXX - assume knowledge of data structure
  CGI::operator bool () const
  {
    return cgi_->hdf && hdf().find("CGI") != hdf().end();
  }

                                // data access
  ConstHDF
  CGI::hdf () const
  {
    return ConstHDF (hdf_);
  }

  HDF
  CGI::hdf ()
  {
    return hdf_;
  }

  string
  CGI::DocumentRoot () const
  {
    return string(hdf()["CGI.DocumentRoot"]);
  }

  string
  CGI::ScriptFilename () const
  {
    return string(hdf()["CGI.ScriptFilename"]);
  }

  string
  CGI::ScriptDirectory () const
  {
    string script_file = hdf().get_value ("CGI.ScriptFilename");
    string::size_type n = script_file.rfind ('/');
    string cgi_directory (script_file, 0, n);
    return cgi_directory;
  }

  string
  CGI::ScriptBasename () const
  {
    string script_file = hdf().get_value ("CGI.ScriptFilename");
    string::size_type n = script_file.rfind ('/');
    string cgi_basename (script_file, n+1);
    return cgi_basename;
  }

  string
  CGI::ScriptBasename (const char * suffix) const
  {
    string s (suffix);
    return ScriptBasename (s);
  }

  string
  CGI::ScriptBasename (const string& suffix) const
  {
    string cgi_basename = ScriptBasename();
    string::size_type n = cgi_basename.rfind (suffix);
    if (n != string::npos)
      cgi_basename.erase (n);
    return cgi_basename;
  }

                                // display
  void
  CGI::display (const char* cs_filename) const
  {
    display (string(cs_filename));
  }

  void
  CGI::display (const string& cs_filename) const
  {
    ClearSilverError error (cgi_display (cgi_.get(), cs_filename.c_str()));
    if (error)
      {
        string message;
        message += "ClearSilver::CGI::display (const string& filename): ";
        message += "filename=" + cs_filename + ": ";
        ClearSilverException e (message);
        e += error;
        throw e;
      }
  }

                                // URI redirection
                                // redirect to a full URI.
  void
  CGI::redirect (const URL& url)
  {
    cgi_redirect_uri (cgi_.get(), "%s", url().c_str());
  }

                                // redirect to a new path
                                // within the same protocol/host/port.
  void
  CGI::redirect_path (const URL& path)
  {
    cgi_redirect (cgi_.get(), "%s", path().c_str());
  }

                                // cookie management
  void
  CGI::set (const Cookie& c)
  {
    ClearSilverError error
      (cgi_cookie_set
       (cgi_.get(),
        c.name().c_str(),
        c.value().c_str(),
        c.credentials().path().empty()?
        static_cast<const char*>(0) : c.credentials().path()().c_str(),
        c.credentials().authority().empty()?
        static_cast<const char*>(0) : c.credentials().authority()().c_str(),
        c.credentials().persist() && !c.credentials().expires().empty()?
        c.credentials().expires()().c_str() : static_cast<const char*>(0),
        c.credentials().persist()? 1 : 0,
        c.credentials().secure()? 1 : 0));
    if (error)
      {
        string message;
        message += "ClearSilver::CGI::set (const Cookie&): ";
        ClearSilverException e (message);
        e += error;
        throw e;
      }
  }

  void
  CGI::clear (const Cookie& c)
  {
    ClearSilverError error
      (cgi_cookie_clear
       (cgi_.get(),
        c.name().c_str(),
        c.credentials().authority().empty()?
        static_cast<const char*>(0) : c.credentials().authority()().c_str(),
        c.credentials().path().empty()?
        static_cast<const char*>(0) : c.credentials().path()().c_str()));
    if (error)
      {
        string message;
        message += "ClearSilver::CGI::clear (const Cookie&): ";
        ClearSilverException e (message);
        e += error;
        throw e;
      }
  }

                                // debug flag.
  bool&
  CGI::debug ()
  {
    static bool debug_ = false;
    return debug_;
  }


  Cookie::Authority
  CGI::cookie_authority (const char * host) const
  {
    return cookie_authority (string (host));
  }

  Cookie::Authority
  CGI::cookie_authority (const string& host) const
  {
    return Cookie::Authority (cgi_cookie_authority (cgi_.get(), host.c_str()));
  }

                                // file upload handling
  FILE*
  CGI::upload () const
  {
    return upload (0);
  }

  FILE*
  CGI::upload (const char * form) const
  {
    return upload (form? string(form) : string());
  }

  FILE*
  CGI::upload (const string& form) const
  {
    FILE* f = cgi_filehandle
      (cgi_.get(), form.empty()? static_cast<char*>(0) : form.c_str());
    return f;
  }

  /*
   * This function should only be called when the boost::shared_ptr
   * destroys the ClearSilver C API CGI structure.  However, the HDF
   * object associated with the corresponding CGI object owns the HDF
   * dataset memory pointed to by the CGI structure.  Consequently, the
   * pointer within the CGI structure must be disassociated from the HDF
   * dataset prior to destroying the CGI structure.
   */

  void
  cgi_free (ClearSilverCGI* cgi)
  {
    syslog (LOG_DEBUG, "%s", "ClearSilver::cgi_free(ClearSilverCGI*)"); // XXX
    cgi->hdf = 0;               // XXX - see above.
    cgi_destroy (&cgi);
  }
};                              // namespace ClearSilver

---