[Boost-commit] svn:boost r7418

From: drrngrvy_at_[hidden]
Date: 2007-07-12 14:09:08

Author: drrngrvy
Date: 2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
New Revision: 7418
URL: http://svn.boost.org/trac/boost/changeset/7418

Log:
Restructuring basic_request and subclasses to model *ReadStream and *WriteStream asio concepts; removing some old files.

Added:
   sandbox/SOC/2007/cgi/boost/cgi/connections/
   sandbox/SOC/2007/cgi/boost/cgi/connections/async_stdio_connection.hpp
   sandbox/SOC/2007/cgi/boost/cgi/connections/stdio_connection.hpp
   sandbox/SOC/2007/cgi/boost/cgi/connections/stdio_connection_impl.hpp
   sandbox/SOC/2007/cgi/boost/cgi/connections/tcp_connection.hpp
   sandbox/SOC/2007/cgi/boost/cgi/detail/extract_params.hpp
   sandbox/SOC/2007/cgi/boost/cgi/detail/url_decode.hpp
   sandbox/SOC/2007/cgi/boost/cgi/request_impl/async_cgi_request_impl.hpp
   sandbox/SOC/2007/cgi/boost/cgi/service_impl/
   sandbox/SOC/2007/cgi/boost/cgi/service_impl/async_cgi_service_impl.hpp
   sandbox/SOC/2007/cgi/boost/cgi/service_impl/cgi_service_impl.hpp
Properties modified: 
   sandbox/SOC/2007/cgi/libs/cgi/doc/   (props changed)
Text files modified: 
   sandbox/SOC/2007/cgi/boost/cgi/basic_connection.hpp               |   130 +-------------------                    
   sandbox/SOC/2007/cgi/boost/cgi/basic_request.hpp                  |   236 ++++++++++++++++++++----------------    
   sandbox/SOC/2007/cgi/boost/cgi/basic_request_acceptor.hpp         |    20 +-                                      
   sandbox/SOC/2007/cgi/boost/cgi/detail/request_traits.hpp          |    21 +-                                      
   sandbox/SOC/2007/cgi/boost/cgi/logger.hpp                         |     5                                         
   sandbox/SOC/2007/cgi/boost/cgi/ostream.hpp                        |     2                                         
   sandbox/SOC/2007/cgi/boost/cgi/request_acceptor_service.hpp       |    26 +++                                     
   sandbox/SOC/2007/cgi/boost/cgi/request_base.hpp                   |     7 +                                       
   sandbox/SOC/2007/cgi/boost/cgi/request_impl/cgi_request_impl.hpp  |   253 +++++++++++++++------------------------ 
   sandbox/SOC/2007/cgi/boost/cgi/request_impl/fcgi_request_impl.hpp |    91 ++++++++------                          
   sandbox/SOC/2007/cgi/boost/cgi/request_service.hpp                |    73 ++++++-----                             
   11 files changed, 383 insertions(+), 481 deletions(-)

Modified: sandbox/SOC/2007/cgi/boost/cgi/basic_connection.hpp
==============================================================================
--- sandbox/SOC/2007/cgi/boost/cgi/basic_connection.hpp	(original)
+++ sandbox/SOC/2007/cgi/boost/cgi/basic_connection.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -23,140 +23,24 @@
   {
   public:
     typedef connection_impl<ProtocolService::protocol_type>  impl_type;
+    typedef boost::shared_ptr<conection_base>                pointer;
 
-  private:
-    impl_type* impl_;
-  };
-
-  template<typename ProtocolService>
-  class basic_connection<tags::stdio>
-    : public connection_base
-  {
-  public:
-    typedef ProtocolService   protocol_service_type;
-
-    basic_connection(protocol_service_type& ps)
-      : in_(std::cin)
-      , out_(std::cout)
-    {
-    }
-
-    template<typename MutableBufferSequence>
-    std::size_t read(MutableBufferSequence buf, boost::system::error_code& ec)
-    {
-      if( buf.data() != in_.rdbuf() )
-        return in_.read(buf.data(), buf.size());
-      return buf.size();
-    }
-
-    template<typename MutableBufferSequence, typename Handler>
-    void async_read(MutableBufferSequence buf, Handler handler)
-    {
-      handler(boost::system_error(), read(buf));
-    }
-
-    template<typename ConstBufferSequence>
-    std::size_t write(ConstBufferSequence& buf)
-    {
-      return out_.write(buf.data(), buf.size());
-    }
-
-    template<typename ConstBufferSequence, typename Handler>
-    void async_write(ConstBufferSequence& buf, Handler handler)
-    {
-      out_.write(buf.data(), buf.size());
-      protocol_service_.post(handler);
-    }
-      
-  private:
-    protocol_service_type& protocol_service_;
-    std::istream& in_;
-    std::ostream& out_;
-  };
-
-  template<typename ProtocolService>
-  class basic_connection<tags::stdio_async>
-    : public connection_base
-  {
-  public:
-    typedef ProtocolService   protocol_service_type;
-
-    basic_connection(protocol_service_type& ps)
-      : protocol_service_(ps)
-      , in_(std::cin)
-      , out_(std::cout)
-    {
-    }
-
-    template<typename MutableBufferSequence>
-    std::size_t read(MutableBufferSequence buf)
-    {
-      if( buf.data() != in_.rdbuf() )
-        return in_.read(buf.data(), buf.size());
-      return buf.size();
-    }
-
-    template<typename MutableBufferSequence, typename Handler>
-    void async_read(MutableBufferSequence buf, Handler handler)
-    {
-      std::size_t bytes_read;
-      if( buf.data() != in_.rdbuf() )
-        bytes_read = in_.read(buf.data(), buf.size());
-      else
-        bytes_read = buf.size();
-
-      protocol_service_.post(boost::bind(&Handler
-                                        , handler
-                                        , boost::system::system_error()
-                                        , bytes_read ));
-    }
-
-    template<typename ConstBufferSequence>
-    std::size_t write(ConstBufferSequence& buf)
-    {
-      return out_.write(buf.data(), buf.size());
-    }
-
-    template<typename ConstBufferSequence, typename Handler>
-    void async_write(ConstBufferSequence& buf, Handler handler)
-    {
-      out_.write(buf.data(), buf.size());
-      protocol_service_.post(handler);
-    }
-      
-  private:
-    protocol_service_type& protocol_service_;
-    std::istream& in_;
-    std::ostream& out_;
-  };
-
-
-
-  template<typename ProtocolService>
-  class basic_connection<ProtocolService, tags::tcp_socket>
-    : public connection_base
-  {
-  public:
-    typedef ProtocolService   protocol_service_type;
-
-    basic_connection(protocol_service_type& ps)
-      : protocol_service_(ps)
-      , sock_(ps.io_service())
+    explicit basic_connection(protocol_service_type& ps)
+      : impl_(ps)
     {
     }
 
-    template<typename ConstBufferSequence, typename Handler>
-    void async_write(ConstBufferSequence& buf, Handler handler)
+    static pointer create()
     {
+      return new basic_connection<protocol_service_type
+                                 , connection_type>(impl_.protocol_service());
     }
 
   private:
-    protocol_service_type protocol_service_;
-    boost::asio::ip::tcp::socket sock_;
+    impl_type impl_;
   };
 
 
-  typedef basic_connection<tags::stdio>    stdio_connection;
   typedef basic_connection<tags::tcp>      tcp_connection;
   //typedef basic_connection<tags::pipe>     pipe_connection; // not implemented
 

Modified: sandbox/SOC/2007/cgi/boost/cgi/basic_request.hpp
==============================================================================
--- sandbox/SOC/2007/cgi/boost/cgi/basic_request.hpp	(original)
+++ sandbox/SOC/2007/cgi/boost/cgi/basic_request.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -12,6 +12,8 @@
 #include <iostream>
 #include <boost/noncopyable.hpp>
 
+#include "detail/request_traits.hpp"
+
 namespace cgi {
 
   enum status_type
@@ -34,65 +36,78 @@
    * seems prohibitively expensive. There could be functions which take a mutex
    * as an arguement and lock it. (Async calls could get messy if you need a
    * protected request object)
+   *
+   * Note: From 10/07/07 this class is going to require a protocol_service be
+   * passed to it. This is good for FastCGI/SCGI and asynchronous CGI. A full
+   * specialisation of this class for sync CGI can be provided... The reasoning
+   * for this is that the added complexity for allowing a non-async CGI request
+   * to use the acceptor and this class doesn't seem worth it: it makes the
+   * whole library much simpler to do it this way.
    */
   template<typename Protocol
-          , enum RequestRole = role_type::responder
+          , typename Service = request_traits<Protocol>::service_type
+          , enum Role = role_type::responder
           , typename ProtocolService = basic_protocol_service<Protocol>
                 , typename Allocator = std::allocator<char> >
   class basic_request
     : public request_base
+      //, public boost::asio::basic_io_object<Service>
     , private boost::noncopyable
   {
   public:
-    typedef basic_request<Protocol, RequestRole
+    typedef basic_request<Protocol, Service, Role
                          , ProtocolService, Allocator >  type;
     typedef Protocol                                     protocol_type;
-    typedef RequestRole                                  role_type;
+    typedef Role                                         role_type;
     typedef ProtocolService                              protocol_service_type;
-    //typedef meta_data<protocol_type>                     data_type;
     typedef boost::shared_ptr<type>                      pointer;
 
-    typedef request_traits<Protocol>                traits;
-    typedef typename traits::impl_type              impl_type;
-    typedef typename traits::service_type           service_type;
+    typedef Service                                 service_type;
+    typedef Service::impl_type                      impl_type;
     typedef boost::shared_ptr<connection_base>      connection_ptr;
 
 
     explicit basic_request(protocol_service_type& s, bool load_now = false)
-      : impl_(s)
+      :// boost::asio::basic_io_object<Service>(s.io_service())
+       next_layer_(s)
+      , service_(boost::asio::use_service<Service>(next_layer_.io_service()))
+      , impl_(service_.null())
       , status_num_(0)
-      //, strand_(s.io_service())
     {
-      if( load_now ) load();
+      service_.construct(impl_);
+      if( load_now ) service_.load(impl_);
     }
 
-    /// Alternate constructor for CGI requests, which don't require a service
-    explicit basic_request(bool load_now = false)
-      : impl_()
-      , status_num_(0)
+    ~basic_request()
     {
-      if( load_now ) load();
+      service_.destroy(impl_);
     }
 
-    ~basic_request()
+    boost::asio::io_service& io_service()
     {
-      end(status_num_);
+      return next_layer_.io_service();
     }
 
     /// Synchronously read/parse the request meta-data
     /**
      * Note: 'loading' including reading/parsing STDIN if parse_stdin == true
      */
-    bool load(bool parse_stdin = false)
+    // Throwing semantics
+    void load(bool parse_stdin = false)
     {
-      if( !service_.load(impl_, parse_stdin) )
-      {
-        status_ = status_type::aborted;     
-        return false;
-      }
-      return true;
+      boost::system::error_code ec;
+      service_.load(impl_, parse_stdin);
+      boost::throw_error(ec);
     }
 
+    // Error-code semantics
+    boost::system::error_code& load(boost::system::error_code& ec
+				   , bool parse_stdin = false)
+    {
+      return service_.load(impl_, parse_stdin, ec);
+    }
+    
+
     /// Asynchronously read/parse the request meta-data
     /**
      * Note: 'loading' including reading/parsing STDIN if parse_stdin == true
@@ -103,43 +118,6 @@
       service_.async_load(impl_, parse_stdin, handler);
     }
 
-    /// Read num_bytes into a default buffer (post-data buffer)
-    std::size_t read(std::size_t num_bytes)
-    {
-      std::size_t bytes_read = impl_.read(connection_, buffer());
-      // buff.commit(bytes_read)
-      return bytes_read;
-    }
-
-    /// Read data synchronously into the provided buffer
-    /**
-     * @return the number of bytes read
-     */
-    template<typename MutableBufferSequence>
-    std::size_t read(MutableBufferSequence& buf)
-    {
-      return impl_.read(connection_, buf);
-    }
-
-    /// Read data asynchronously into the provided buffer
-    template<typename MutableBufferSequence, typename Handler>
-    void async_read(MutableBufferSequence& buf, Handler handler)
-    {
-      impl_.async_read(connection_, buf, handler);
-    }
-
-    template<typename ConstBufferSequence>
-    std::size_t write(ConstBufferSequence& buf)
-    {
-      return impl_.async_write(connection_, buf);
-    }
-
-    template<typename ConstBufferSequence, typename Handler>
-    void async_write(ConstBufferSequence& buf, Handler handler)
-    {
-      impl_.async_write(connection_, buf, handler);
-    }
-
     /// Notify the server the request has finished being handled
     /**
      * In certain situations (such as a Proactor client using the async read
@@ -155,10 +133,10 @@
     {
       BOOST_ASSERT( request_status_ != status_type::ended );
 
-      request_status_ = status_type::ended;
+      service_.set_status(request_status_ = status_type::ended;
       http_status_ = http_status;
       program_status_ = program_status;
-      service_.end(impl_);
+      service_.end(impl_, http_status);
       //io_service_.dispatch(set_status(status_type::ended));
       //impl_.end_request(this, status_code);
     }
@@ -168,6 +146,46 @@
 
     }
 
+    /// Reject the request with a standard '500 Internal Server Error' error
+    void reject()
+    {
+      service_.set_status(impl_, status_type::aborted);
+      service_.end(impl_, http::status_code::internal_server_error);
+    }
+
+    /// Read some data from the request
+    template<typename MutableBufferSequence>
+    std::size_t read_some(const MutableBufferSequence& buf)
+    {
+      error_code ec;
+      std::size_t s = service.read_some(buf, ec);
+      boost::throw_error(ec);
+      return s;
+    }
+
+    template<typename MutableBufferSequence>
+    std::size_t read_some(const MutableBufferSequence& buf
+                         , boost::system::error_code& ec)
+    {
+      return service.read_some(buf, ec);
+    }
+
+    template<typename ConstBufferSequence>
+    std::size_t write_some(const ConstBufferSequence& buf)
+    {
+      error_code ec;
+      std::size_t s = service.write_some(buf, ec);
+      boost::throw_error(ec);
+      return s;
+    }
+
+    template<typename ConstBufferSequence>
+    std::size_t write_some(const ConstBufferSequence& buf
+                          , boost::system::error_code& ec)
+    {
+      return service.write_some(buf, ec);
+    }
+
 /* Not sure if these are needed; leaving it for open discussion to decide.
 
     template<class VarType = ENV>
@@ -186,7 +204,7 @@
     /// Find the get meta-variable matching name
     std::string meta_get(const std::string& name) const
     {
-      return impl_.var<tags::GET>(name);
+      return service_.meta_get(impl_, name);
     }
 
     /// Find the post meta-variable matching name
@@ -197,23 +215,19 @@
      */
     std::string meta_post(const std::string& name, bool greedy = true)
     {
-      std::string& value = impl_.var<POST>(name);
-      if( value.empty() && greedy && impl_.post_data_read() )
-        return service_.var<tags::POST>(name);
-
-      return value;
+      return service_.meta_post(impl_, name, greedy);
     }
 
     /// Find the cookie meta-variable matching name
     std::string meta_cookie(const std::string& name) const
     {
-      return impl_.var<tags::COOKIE>(name);
+      return service_.meta_cookie(impl_, name);
     }
 
     /// Find the environment meta-variable matching name
     std::string meta_env(const std::string& name) const
     {
-      return impl_.var<tags::ENV>(name);
+      return service_.meta_env(impl_, name);
     }
 
     /// Search through all meta vars for the meta-variable matching name
@@ -224,35 +238,38 @@
      *
      * Notes:
      * One option is to parse everything, making this option
-     * a very poor one in production applications.
+     * very inefficient.
      * Another is to leave this function as a 'lazy' search:
      * it'll search with what it's got and no more. Then, also
      * provide a meta_var_all() function which is greedy; the
      * ugly/long name there to discourage use.
      */
-    std::string meta_var(const std::string& name) const
+    std::string meta_var(const std::string& name, bool greedy = false) const
     {
       std::string request_method( meta_env("REQUEST_METHOD") );
 
       std::string tmp;
 
       // If it's not a POST request search meta_get first
-      if( request_method.empty() || request_method == "GET" )
+      if (request_method.empty() || request_method == "GET")
       {
-	      tmp = meta_get(name);
-	      if( !tmp.empty() )
-	        return tmp;
+        tmp = meta_get(name);
+        if (!tmp.empty())
+          return tmp;
       }
 
       tmp = meta_cookie(name);
-      if( !tmp.empty() ) return tmp;
+      if (!tmp.empty())
+	return tmp;
+
       tmp = meta_env(name);
-      if( !tmp.empty() ) return tmp;
+      if (!tmp.empty())
+	return tmp;
 
-      if( !request_method.empty() && request_method == "POST" )
+      if (!request_method.empty() && request_method == "POST")
       {
         tmp = meta_post(name);
-        if( !tmp.empty() )
+        if (!tmp.empty())
           return tmp;
       }
 
@@ -262,55 +279,55 @@
 
     // Some helper functions for the basic CGI 1.1 meta-variables
     std::string auth_type()
-    { return impl_.var<tags::ENV>("AUTH_TYPE"); }
+    { return service_.meta_env(impl_, "AUTH_TYPE"); }
 
     std::string content_length()
-    { return impl_.var<tags::ENV>("CONTENT_LENGTH"); }
+    { return service_.meta_env(impl_, "CONTENT_LENGTH"); }
 
     std::string content_type()
-    { return impl_.var<tags::ENV>("CONTENT_TYPE"); }
+    { return service_.meta_env(impl_, "CONTENT_TYPE"); }
 
     std::string gateway_interface()
-    { return impl_.var<tags::ENV>("GATEWAY_INTERFACE"); }
+    { return service_.meta_env(impl_, "GATEWAY_INTERFACE"); }
 
     std::string path_info()
-    { return impl_.var<tags::ENV>("PATH_INFO"); }
+    { return service_.meta_env(impl_, "PATH_INFO"); }
 
     std::string path_translated()
-    { return impl_.var<tags::ENV>("PATH_TRANSLATED"); }
+    { return service_.meta_env(impl_, "PATH_TRANSLATED"); }
 
     std::string query_string()
-    { return impl_.var<tags::ENV>("QUERY_STRING"); }
+    { return service_.meta_env(impl_, "QUERY_STRING"); }
 
     std::string remote_addr()
-    { return impl_.var<tags::ENV>("REMOTE_ADDR"); }
+    { return service_.meta_env(impl_, "REMOTE_ADDR"); }
 
     std::string remote_host()
-    { return impl_.var<tags::ENV>("REMOTE_HOST"); }
+    { return service_.meta_env(impl_, "REMOTE_HOST"); }
 
     std::string remote_ident()
-    { return impl_.var<tags::ENV>("REMOTE_IDENT"); }
+    { return service_.meta_env(impl_, "REMOTE_IDENT"); }
 
     std::string remote_user()
-    { return impl_.var<tags::ENV>("REMOTE_USER"); }
+    { return service_.meta_env(impl_, "REMOTE_USER"); }
 
     std::string request_method()
-    { return impl_.var<tags::ENV>("REQUEST_METHOD"); }
+    { return service_.meta_env(impl_, "REQUEST_METHOD"); }
 
     std::string script_name()
-    { return impl_.var<tags::ENV>("SCRIPT_NAME"); }
+    { return service_.meta_env(impl_, "SCRIPT_NAME"); }
 
     std::string server_name()
-    { return impl_.var<tags::ENV>("SERVER_NAME"); }
+    { return service_.meta_env(impl_, "SERVER_NAME"); }
 
     std::string server_port()
-    { return impl_.var<tags::ENV>("SERVER_PORT"); }
+    { return service_.meta_env(impl_, "SERVER_PORT"); }
 
     std::string server_protocol()
-    { return impl_.var<tags::ENV>("SERVER_PROTOCOL"); }
+    { return service_.meta_env(impl_, "SERVER_PROTOCOL"); }
 
     std::string server_software()
-    { return impl_.var<tags::ENV>("SERVER_SOFTWARE"); }
+    { return service_.meta_env(impl_, "SERVER_SOFTWARE"); }
 
 
     /// The role that the request is playing
@@ -323,7 +340,7 @@
      */
     role_type& role()
     {
-      return impl_.role();
+      return service_.get_role(impl_);
     }
 
     /// Get the strand associated with the request (if any)
@@ -331,10 +348,11 @@
     // function like basic_request<>::wrap() should be provided: in the case of
     // a synchronous request type the wrapping would still function as expected
     // and there would be no need for protocol-specific code in user programs.
-    boost::asio::strand* strand()
+      /*    boost::asio::strand* strand()
     {
       return impl_.strand();
     }
+      */
 
     /// Get the implementation type for the request
     impl_type& impl() const
@@ -342,14 +360,24 @@
       return impl_;
     }
 
+    void set_status(http::status_code status)
+    {
+      service_.set_http_status(impl_, status);
+    }
+
+    bool is_open()
+    {
+      return service_.is_open(impl_);
+    }
+
   private:
-    connection_ptr conn_;
+    //connection_ptr conn_;
     service_type& service_;
     impl_type impl_;
 
-    int app_status_; // what to return to the server on request completion
-    http_status http_status_;
-    status_type request_status_;
+    //int app_status_; // what to return to the server on request completion
+    //http::status_code http_status_;
+    //status_type request_status_;
 
     //boost::shared_ptr<data_type> data_;
 

Modified: sandbox/SOC/2007/cgi/boost/cgi/basic_request_acceptor.hpp
==============================================================================
--- sandbox/SOC/2007/cgi/boost/cgi/basic_request_acceptor.hpp	(original)
+++ sandbox/SOC/2007/cgi/boost/cgi/basic_request_acceptor.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -13,46 +13,48 @@
 
 namespace cgi {
 
-  template<typename Protocol>
+  template<typename RequestAcceptorService>
   class basic_request_acceptor
     : private boost::noncopyable
+    , public boost::asio::basic_io_object<RequestAcceptorService>
   {
   public:
     //  typedef impl_type;
-    typedef Protocol   protocol_type;
+    typedef RequestAcceptorService         service_type;
+    typedef service_type::protocol_type    protocol_type;
 
-    explicit basic_request_acceptor(basic_protocol_service<Protocol>& pserv)
-      : service_(pserv) 
+    explicit basic_request_acceptor(basic_protocol_service<protocol_type>& s)
+      : boost::asio::use_service<RequestAcceptorService>(s.io_service())
     {
     }
 
     ~basic_request_acceptor()
     {
-      service_.cancel();
+      this->service.cancel();
     }
 
     template<typename CommonGatewayRequest>
     void accept(CommonGatewayRequest& request)
     {
       boost::system::error_code ec;
-      service_.accept(request, ec);
+      this->service.accept(request, ec);
       boost::throw_error(ec);
     }
 
     template<typename CommonGatewayRequest> boost::system::error_code&
     accept(CommonGatewayRequest& request, boost::system::error_code& ec)
     {
-      return service_.accept(request, ec);
+      return this->service.accept(request, ec);
     }
 
     template<typename CommonGatewayRequest, typename Handler>
     void async_accept(CommonGatewayRequest& request, Handler handler)
     {
-      service_.async_accept(request, handler);
+      this->service.async_accept(request, handler);
     }
 
   private:
-    request_acceptor_service<protocol_type> service_;
+    service_type& service_;
   };
 
 

Added: sandbox/SOC/2007/cgi/boost/cgi/connections/async_stdio_connection.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/cgi/boost/cgi/connections/async_stdio_connection.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -0,0 +1,60 @@
+//           -- async_stdio_connection_impl.hpp --
+//
+//            Copyright (c) Darren Garvey 2007.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+////////////////////////////////////////////////////////////////
+#ifndef CGI_ASYNC_STDIO_CONNECTION_IMPL_HPP_INCLUDED__
+#define CGI_ASYNC_STDIO_CONNECTION_IMPL_HPP_INCLUDED__
+
+namespace cgi {
+
+ template<typename ProtocolService>
+  class basic_connection<tags::stdio_async>
+    : public connection_base
+  {
+  public:
+    typedef ProtocolService   protocol_service_type;
+
+    basic_connection(protocol_service_type& ps)
+      : protocol_service_(ps)
+      , in_(std::cin)
+      , out_(std::cout)
+    {
+    }
+
+    template<typename MutableBufferSequence, typename Handler>
+    void async_read_some(MutableBufferSequence buf, boost::system::error_code& ec
+                        , Handler handler)
+    {
+      std::size_t bytes_read;
+      if( buf.data() != in_.rdbuf() )
+        bytes_read = in_.read(buf.data(), buf.size());
+      else
+        bytes_read = buf.size();
+
+      protocol_service_.post(boost::bind(&Handler
+                                        , handler
+                                        , boost::system::system_error()
+                                        , bytes_read ));
+    }
+
+    template<typename ConstBufferSequence, typename Handler>
+    void async_write_some(ConstBufferSequence& buf, boost::system::error_code& ec
+                         , Handler handler)
+    {
+      out_.write(buf.data(), buf.size());
+      protocol_service_.post(handler);
+    }
+      
+  private:
+    protocol_service_type& protocol_service_;
+    std::istream& in_;
+    std::ostream& out_;
+  };
+
+} // namespace cgi
+
+#endif // CGI_ASYNC_STDIO_CONNECTION_IMPL_HPP_INCLUDED__

Added: sandbox/SOC/2007/cgi/boost/cgi/connections/stdio_connection.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/cgi/boost/cgi/connections/stdio_connection.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -0,0 +1,56 @@
+//              -- stdio_connection_impl.hpp --
+//
+//            Copyright (c) Darren Garvey 2007.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+////////////////////////////////////////////////////////////////
+#ifndef CGI_STDIO_CONNECTION_IMPL_HPP_INCLUDED__
+#define CGI_STDIO_CONNECTION_IMPL_HPP_INCLUDED__
+
+namespace cgi {
+
+  template<typename ProtocolService>
+  class basic_connection<tags::stdio>
+    : public connection_base
+  {
+  public:
+    typedef ProtocolService   protocol_service_type;
+
+    basic_connection()
+      : in_(std::cin)
+      , out_(std::cout)
+    {
+    }
+
+    basic_connection(protocol_service_type&)
+      : in_(std::cin)
+      , out_(std::cout)
+    {
+    }
+
+    template<typename MutableBufferSequence>
+    std::size_t read_some(MutableBufferSequence buf, boost::system::error_code& ec)
+    {
+      if( buf.data() != in_.rdbuf() )
+        return in_.read(buf.data(), buf.size());
+      return buf.size();
+    }
+
+    template<typename ConstBufferSequence>
+    std::size_t write_some(ConstBufferSequence& buf, boost::system::error_code& ec)
+    {
+      return out_.write(buf.data(), buf.size());
+    }
+      
+  private:
+    std::istream& in_;
+    std::ostream& out_;
+  };
+
+  typedef basic_connection<tags::stdio>    stdio_connection;
+
+} // namespace cgi
+
+#endif // CGI_STDIO_CONNECTION_IMPL_HPP_INCLUDED__
\ No newline at end of file

Added: sandbox/SOC/2007/cgi/boost/cgi/connections/stdio_connection_impl.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/cgi/boost/cgi/connections/stdio_connection_impl.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -0,0 +1,56 @@
+//              -- stdio_connection_impl.hpp --
+//
+//            Copyright (c) Darren Garvey 2007.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+////////////////////////////////////////////////////////////////
+#ifndef CGI_STDIO_CONNECTION_IMPL_HPP_INCLUDED__
+#define CGI_STDIO_CONNECTION_IMPL_HPP_INCLUDED__
+
+namespace cgi {
+
+  template<typename ProtocolService>
+  class basic_connection<tags::stdio>
+    : public connection_base
+  {
+  public:
+    typedef ProtocolService   protocol_service_type;
+
+    basic_connection()
+      : in_(std::cin)
+      , out_(std::cout)
+    {
+    }
+
+    basic_connection(protocol_service_type&)
+      : in_(std::cin)
+      , out_(std::cout)
+    {
+    }
+
+    template<typename MutableBufferSequence>
+    std::size_t read_some(MutableBufferSequence buf, boost::system::error_code& ec)
+    {
+      if( buf.data() != in_.rdbuf() )
+        return in_.read(buf.data(), buf.size());
+      return buf.size();
+    }
+
+    template<typename ConstBufferSequence>
+    std::size_t write_some(ConstBufferSequence& buf, boost::system::error_code& ec)
+    {
+      return out_.write(buf.data(), buf.size());
+    }
+      
+  private:
+    std::istream& in_;
+    std::ostream& out_;
+  };
+
+  typedef basic_connection<tags::stdio>    stdio_connection;
+
+} // namespace cgi
+
+#endif // CGI_STDIO_CONNECTION_IMPL_HPP_INCLUDED__
\ No newline at end of file

Added: sandbox/SOC/2007/cgi/boost/cgi/connections/tcp_connection.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/cgi/boost/cgi/connections/tcp_connection.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -0,0 +1,40 @@
+//               -- tcp_connection_impl.hpp --
+//
+//            Copyright (c) Darren Garvey 2007.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+////////////////////////////////////////////////////////////////
+#ifndef CGI_TCP_CONNECTION_IMPL_HPP_INCLUDED__
+#define CGI_TCP_CONNECTION_IMPL_HPP_INCLUDED__
+
+namespace cgi {
+
+  template<typename ProtocolService>
+  class basic_connection<ProtocolService, tags::tcp_socket>
+    : public connection_base
+  {
+  public:
+    typedef ProtocolService   protocol_service_type;
+
+    basic_connection(protocol_service_type& ps)
+      : protocol_service_(ps)
+      , sock_(ps.io_service())
+    {
+    }
+
+    template<typename ConstBufferSequence, typename Handler>
+    void async_write(ConstBufferSequence& buf, Handler handler)
+    {
+    }
+
+  private:
+    protocol_service_type protocol_service_;
+    boost::asio::ip::tcp::socket sock_;
+  };
+
+
+} // namespace cgi
+
+#endif // CGI_TCP_CONNECTION_IMPL_HPP_INCLUDED__

Added: sandbox/SOC/2007/cgi/boost/cgi/detail/extract_params.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/cgi/boost/cgi/detail/extract_params.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -0,0 +1,60 @@
+//                -- extract_params.hpp --
+//
+//           Copyright (c) Darren Garvey 2007.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+////////////////////////////////////////////////////////////////
+#ifndef CGI_DETAIL_EXTRACT_PARAMS_HPP_INCLUDED__
+#define CGI_DETAIL_EXTRACT_PARAMS_HPP_INCLUDED__
+
+namespace cgi {
+ namespace detail {
+
+   template<typename Map, typename Separator>
+   boost::system::error_code& extract_params(const std::string& input
+                                            , Map& destination
+                                            , const Separator& separator
+                                            , boost::system::error_code& ec)
+   {
+     if( input.empty() )
+       return boost::system::error_code(34, boost::system::errno_ecat);
+     
+	 typedef boost::tokenizer<Separator>    tokenizer;
+     
+     tokenizer toker(input, sep);
+
+     std::string name, current_token;
+
+     for(tokenizer::iterator iter = toker.begin()
+        ; iter != toker.end()
+        ; ++iter)
+     {
+//       if( *iter == "%" )
+//       {
+//         current_token += detail::url_decode( *++iter );
+//       }else
+       if(*iter == "=")
+       {
+         name = current_token;
+         current_token.clear();
+       }else
+       if( *iter == "&" )
+       {
+         impl_.get_vars_[name] = current_token;
+         current_token.clear();
+         name.clear();
+       }else
+       {
+         current_token = url_decode(*iter);
+       }
+     }
+     if( !name.empty() )
+       impl_.get_vars_[name] = current_token;
+   }
+
+ } // namespace detail
+} // namespace cgi
+
+#endif // CGI_DETAIL_EXTRACT_PARAMS_HPP_INCLUDED__

Modified: sandbox/SOC/2007/cgi/boost/cgi/detail/request_traits.hpp
==============================================================================
--- sandbox/SOC/2007/cgi/boost/cgi/detail/request_traits.hpp	(original)
+++ sandbox/SOC/2007/cgi/boost/cgi/detail/request_traits.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -9,41 +9,38 @@
     template<typename Protocol, typename RequestType = request_type::responder>
     struct request_traits
     {
-/*
-      typedef Protocol                           protocol_type;
-      typedef basic_request<Protocol>            request_type;
-      typedef gateway<Protocol>                  gateway_type;
-      typedef basic_service<Protocol>            service_type;
-      typedef service_options<Protocol>          service_options; // just an idea
-**/
     };
 
     template<>
     struct request_traits<protocol::cgi>
     {
       typedef cgi_request_impl                  impl_type;
-      typedef request_service<protocol::cgi>    service_type;
+      //typedef request_service<protocol::cgi>    service_type;
+      typedef cgi_service_impl                  service_impl_type;
     };
 
     template<>
     struct request_traits<protocol::async_cgi>
     {
-      typedef cgi_async_request_impl                  impl_type;
-      typedef request_service<protocol::async_cgi>    service_type;
+      typedef async_cgi_request_impl                  impl_type;
+      //typedef request_service<protocol::async_cgi>    service_type;
+      typedef async_cgi_service_impl                  service_impl_type;
     };
 
     template<>
     struct request_traits<protocol::fcgi>
     {
       typedef fcgi_request_impl                  impl_type;
-      typedef request_service<protocol::fcgi>    service_type;
+      //typedef request_service<protocol::fcgi>    service_type;
+      typedef fcgi_service_impl                  service_impl_type;
     };
 
     template<>
     struct request_traits<protocol::scgi>
     {
       typedef scgi_request_impl                  impl_type;
-      typedef request_service<protocol::scgi>    service_type;
+      //typedef request_service<protocol::scgi>    service_type;
+      typedef scgi_service_impl                  service_impl_type;
     };
 
  } // namespace detail

Added: sandbox/SOC/2007/cgi/boost/cgi/detail/url_decode.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/cgi/boost/cgi/detail/url_decode.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -0,0 +1,60 @@
+//                  -- url_decode.hpp --
+//
+//           Copyright (c) Darren Garvey 2007.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+////////////////////////////////////////////////////////////////
+#ifndef CGI_DETAIL_URL_DECODE_HPP_INCLUDED__
+#define CGI_DETAIL_URL_DECODE_HPP_INCLUDED__
+
+namespace cgi {
+ namespace detail {
+
+   /// URL-decode a string
+   std::string url_decode( const std::string& str )
+   {
+	 std::string ret;
+
+	 for( unsigned int i=0; i < str.size(); i++ )
+	 {
+	   switch( str[i] )
+       {
+         case ' ':
+           break;
+         case '+':
+           ret += ' ';
+           break;
+         case '%':
+           ret += url_decode(str[i+1], str[i+2]);
+           i += 2;
+           break;
+         default:
+           ret += str[i];
+       }
+     }
+    
+     return ret;
+   }
+
+   /// Take two characters (a hex sequence) and return a char
+   char url_decode( const char c1, const char c2 )
+   {
+	 int ret = ( (c1 >= 'A' && c1 <= 'Z') || (c1 >= 'a' && c1 <= 'z')
+                 ? ((c1 & 0xdf) - 'A') + 10
+                 : (c1 - '0')
+               ) << 4;
+
+	 ret += ( (c2 >= 'A' && c2 <= 'Z') || (c2 >= 'a' && c2 <= 'z')
+              ? ((c2 & 0xdf) - 'A') + 10
+              : (c2 - '0')
+            );
+
+	 return static_cast<char>(ret);
+   }
+
+ } // namespace detail
+} // namespace cgi
+
+#endif // CGI_DETAIL_URL_DECODE_HPP_INCLUDED__

Modified: sandbox/SOC/2007/cgi/boost/cgi/logger.hpp
==============================================================================
--- sandbox/SOC/2007/cgi/boost/cgi/logger.hpp	(original)
+++ sandbox/SOC/2007/cgi/boost/cgi/logger.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -24,6 +24,7 @@
   public:
     /// Default constructor
     explicit logger()
+      : ostream(tags::stderr)
     {
     }
 
@@ -33,7 +34,7 @@
      * destruction.
      */
     logger(std::streambuf* buf)
-      : ostream(buf)
+      : ostream(buf, tags::stderr)
     {
     }
 
@@ -48,7 +49,7 @@
      */
     template<typename CommonGatewayRequest>
     logger(CommonGatewayRequest& req)
-      : ostream(req)
+      : ostream(req, tags::stderr)
     {
     }
 

Modified: sandbox/SOC/2007/cgi/boost/cgi/ostream.hpp
==============================================================================
--- sandbox/SOC/2007/cgi/boost/cgi/ostream.hpp	(original)
+++ sandbox/SOC/2007/cgi/boost/cgi/ostream.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -248,7 +248,7 @@
       req.async_write(ostream_.rdbuf(), destination_, handler));
     }
 
-    /// Get the buffer associated with the 
+    /// Get the buffer associated with the stream
     std::streambuf* rdbuf() const { return ostream_.rdbuf(); }
 
     void set_status(http::status_code& num) { http_status_ = num; }

Modified: sandbox/SOC/2007/cgi/boost/cgi/request_acceptor_service.hpp
==============================================================================
--- sandbox/SOC/2007/cgi/boost/cgi/request_acceptor_service.hpp	(original)
+++ sandbox/SOC/2007/cgi/boost/cgi/request_acceptor_service.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -16,9 +16,22 @@
   {
   public:
     typedef Protocol protocol_type;
+    typedef basic_request<Protocol, ...>    implementation_type;
 
-    request_acceptor_service(basic_protocol_service<protocol_type>& pserv)
-      : pservice_(pserv)
+    explicit request_acceptor_service(basic_protocol_service<protocol_type>& s)
+      : pservice_(s)
+    {
+    }
+
+    void shutdown_service()
+    {
+    }
+
+    void construct(implementation_type& impl)
+    {
+    }
+
+    void destroy(implementation_type& impl)
     {
     }
 
@@ -27,7 +40,8 @@
      * Check if there is a waiting request in the queue. If not, accept a
      * connection, and associate it with the request.
      */
-    template<typename CommonGatewayRequest> boost::system::error_code&
+    template<typename CommonGatewayRequest>
+    boost::system::error_code&
     accept(CommonGatewayRequest& request, boost::system::error_code& ec)
     {
       boost::thread::mutex::scoped_lock lk(io_service_.mutex_);
@@ -45,8 +59,8 @@
     }
 
     /// Asynchronously accept a request
-    template<typename RequestService, typename Handler>
-    void async_accept( basic_request<RequestService>& request, Handler handler )
+    template<typename CommonGatewayRequest, typename Handler>
+    void async_accept(CommonGatewayRequest& request, Handler handler)
     {
       boost::thread::mutex::scoped_lock lk(io_service_.mutex_);
       if( !io_service_.request_queue_.empty() )
@@ -57,7 +71,7 @@
               return ec;
       }
       lk.unlock();
-      pservice_.gateway_.async_accept(&request.connection(), handler);
+      pservice_.gateway_.async_accept(request.connection(), handler);
     }
 
   private:

Modified: sandbox/SOC/2007/cgi/boost/cgi/request_base.hpp
==============================================================================
--- sandbox/SOC/2007/cgi/boost/cgi/request_base.hpp	(original)
+++ sandbox/SOC/2007/cgi/boost/cgi/request_base.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -82,6 +82,13 @@
      * supported in production servers {{AFAIK}}
      */
     virtual role_type role() = 0;
+
+    /* SyncReadStream function */
+    template<typename MutableBufferSequence>
+    virtual std::size_t read_some(MutableBufferSequence) = 0;
+
+    template<typename MutableBufferSequence>
+    virtual std::size_t read_some(MutableBufferSequence, error_code&) = 0;
   };
 
 } // namespace cgi

Added: sandbox/SOC/2007/cgi/boost/cgi/request_impl/async_cgi_request_impl.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/cgi/boost/cgi/request_impl/async_cgi_request_impl.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -0,0 +1,26 @@
+#ifndef CGI_ASYNC_CGI_REQUEST_IMPL_HPP_INCLUDED__
+#define CGI_ASYNC_CGI_REQUEST_IMPL_HPP_INCLUDED__
+
+namespace cgi {
+
+  class async_cgi_request_impl
+    : public cgi_request_impl
+  {
+  public:
+    //typedef std::map<std::string,std::string>    map_type;
+
+    async_cgi_request_impl(protocol_service_type& protocol_service)
+      : cgi_request_impl(protocol_service)
+      , protocol_service_(protocol_service)
+    {
+    }
+
+  protected:
+    friend class async_cgi_service_impl;
+
+    protocol_service_type& protocol_service_;
+  }; 
+
+} // namespace cgi
+
+#endif // CGI_ASYNC_CGI_REQUEST_IMPL_HPP_INCLUDED__

Modified: sandbox/SOC/2007/cgi/boost/cgi/request_impl/cgi_request_impl.hpp
==============================================================================
--- sandbox/SOC/2007/cgi/boost/cgi/request_impl/cgi_request_impl.hpp	(original)
+++ sandbox/SOC/2007/cgi/boost/cgi/request_impl/cgi_request_impl.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -1,157 +1,106 @@
 //              -- cgi_request_impl.hpp --
 //
-//           Copyright (c) Darren Garvey 2007.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//           Copyright (c) Darren Garvey 2007.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 //
 ////////////////////////////////////////////////////////////////
-#ifndef CGI_CGI_REQUEST_IMPL_HPP_INCLUDED__
-#define CGI_CGI_REQUEST_IMPL_HPP_INCLUDED__
-
-#include <map>
-#include <boost/noncopyable.hpp>
-
-namespace cgi {
- namespace detail {
-    typename std::map<std::string,std::string>    map_type;
- } // namespace detail
-
-
-  /// Implementation for a standard CGI request
-  /**
-   * Note: This isn't noncopyable since there's no real reason it can't be
-   * copied around. Since basic_request is noncopyable, basic copying will be
-   * restricted but if someone really wants to copy the data, then they can.
-   */
-  class cgi_request_impl
-  {
-  public:
-    /// Constructor
-    /**
-     * Since this request type is synchronous, there is no need for an
-     * io_service, so the passed ProtocolService is just ignored.
-     */
-    template<typename ProtocolService>
-    cgi_request_impl(ProtocolService& pserv)
-    {
-      load(false);
-    }
-
-    /// Synchronously read/parse the request meta-data
-    /**
-     * @param parse_stdin if true then STDIN data is also read/parsed
-     */
-    bool load(bool parse_stdin)
-    {
-    }
-
-    /// Asynchronously read/parse the request meta-data
-    /**
-     * @param parse_stdin if true then STDIN data is also read/parsed
-     */
-    template<typename Handler>
-    void async_load(bool parse_stdin, Handler handler)
-    {
-      load(parse_stdin);
-      handler();
-    }
-
-    template<typename ConnectionPtr, typename MutableBufferSequence>
-    std::size_t read(ConnectionPtr conn, MutableBufferSequence buf)
-    {
-      return conn.read(buf);
-    }
-
-    template<typename ConnectionPtr, typename MutableBufferSequence
-            , typename Handler>
-    void async_read(ConnectionPtr conn, MutableBufferSequence buf
-                   , Handler handler)
-    {
-      conn.async_read(buf, handler);
-    }
-
-    template<typename ConnectionPtr, typename ConstBufferSequence>
-    std::size_t write(ConnectionPtr conn, ConstBufferSequence buf)
-    {
-      return conn.write(buf);
-    }
-
-    template<typename ConnectionPtr, typename ConstBufferSequence
-            , typename Handler>
-    void async_write(ConnectionPtr conn, ConstBufferSequence buf
-                    , Handler handler)
-    {
-      conn.async_write(buf, handler);
-    }
-
-    template<typename VarType> map_type& var() const;
-
-    template<typename VarType>
-    const std::string& var(const std::string& name) const
-    {
-      map_type& meta_data = var<VarType>();
-      if((map_type::iterator pos = meta_data.find(name))
-           != meta_data.end())
-      {
-        return *pos;
-      }
-      return std::string();
-
-      /* Alt:
-      if( meta_data.find(name) != meta_data.end() )
-        return meta_data[name];
-      return std::string();
-      **/
-    }
-
-    void* strand() const { return NULL; }
-    role_type role() const { return role_type::responder; }
-
-  private: // functions
-    
-
-  private: // variables
-    //map_type env_map_;
-    map_type http_map_;
-    map_type cookie_map_;
-    map_type get_map_;
-    map_type post_map_;
-  };
-
-  template<> inline const std::string&
-  cgi_request_impl::var<tags::ENV>(const std::string& name)
-  {
-    return ::getenv(name);
-  }
-
-  /// Get a request map of all the environment meta-variables (slow)
-  /**
-   * -- NOT IMPLEMENTED FOR NOW --
-   *
-   * In the case of a CGI request, the environment meta-data is usually stored
-   * in the process environment, which means there is no direct access to all
-   * of them as a map_type&. In other words, this function call will have to
-   * load all of the variables into memory and then return the map
-   */
-  //template<> inline cgi_request_impl::map_type&
-  //cgi_request_impl::var<tags::ENV>()
-  //{
-  //  throw std::logic_error("Can't get all environment vars as a map_type&");
-  //}
-
-  template<> inline cgi_request_impl::map_type&
-  cgi_request_impl::var<tags::HTTP>() { return http_map_; }
-
-  template<> inline cgi_request_impl::map_type&
-  cgi_request_impl::var<tags::COOKIE>() { return cookie_map_; }
-
-  template<> inline cgi_request_impl::map_type&
-  cgi_request_impl::var<tags::GET>() { return get_map_; }
-
-  template<> inline cgi_request_impl::map_type&
-  cgi_request_impl::var<tags::POST>() { return post_map_; }
-
-} // namespace cgi
-
-#endif // CGI_CGI_REQUEST_IMPL_HPP_INCLUDED__
+#ifndef CGI_CGI_REQUEST_IMPL_HPP_INCLUDED__
+#define CGI_CGI_REQUEST_IMPL_HPP_INCLUDED__
+
+#include <map>
+#include <boost/noncopyable.hpp>
+
+namespace cgi {
+ namespace detail {
+    typename std::map<std::string,std::string>    map_type;
+ } // namespace detail
+
+
+  /// Implementation for a standard CGI request
+  /**
+   * Note: This isn't noncopyable since there's no real reason it can't be
+   * copied around. Since basic_request is noncopyable, basic copying will be
+   * restricted but if someone really wants to copy the data, then they can.
+   */
+  class cgi_request_impl
+  {
+  public:
+    typedef std::map<std::string, std::string>    map_type;
+
+    /// Constructor
+    /**
+     * Since this request type is synchronous, there is no need for an
+     * io_service, so the passed ProtocolService is just ignored.
+     */
+    template<typename ProtocolService>
+    cgi_request_impl(ProtocolService& pserv)
+      : stdin_read_(false)
+      , http_status_(http::status_code::ok)
+      , request_status_(request_status::unloaded)
+    {
+    }
+
+  private:
+    friend class cgi_service_impl;
+
+  protected:
+    map_type get_vars_;
+    map_type post_vars_;
+    map_type cookie_vars_;
+
+    bool stdin_read_;
+
+    http::status_code http_status_;
+    request_status request_status_;
+  };
+    
+
+  private: // functions
+    
+
+  private: // variables
+    //map_type env_map_;
+    map_type http_map_;
+    map_type cookie_map_;
+    map_type get_map_;
+    map_type post_map_;
+  };
+
+  template<> inline const std::string&
+  cgi_request_impl::var<tags::ENV>(const std::string& name)
+  {
+    return ::getenv(name);
+  }
+
+  /// Get a request map of all the environment meta-variables (slow)
+  /**
+   * -- NOT IMPLEMENTED FOR NOW --
+   *
+   * In the case of a CGI request, the environment meta-data is usually stored
+   * in the process environment, which means there is no direct access to all
+   * of them as a map_type&. In other words, this function call will have to
+   * load all of the variables into memory and then return the map
+   */
+  //template<> inline cgi_request_impl::map_type&
+  //cgi_request_impl::var<tags::ENV>()
+  //{
+  //  throw std::logic_error("Can't get all environment vars as a map_type&");
+  //}
+
+  template<> inline cgi_request_impl::map_type&
+  cgi_request_impl::var<tags::HTTP>() { return http_map_; }
+
+  template<> inline cgi_request_impl::map_type&
+  cgi_request_impl::var<tags::COOKIE>() { return cookie_map_; }
+
+  template<> inline cgi_request_impl::map_type&
+  cgi_request_impl::var<tags::GET>() { return get_map_; }
+
+  template<> inline cgi_request_impl::map_type&
+  cgi_request_impl::var<tags::POST>() { return post_map_; }
+
+} // namespace cgi
+
+#endif // CGI_CGI_REQUEST_IMPL_HPP_INCLUDED__

Modified: sandbox/SOC/2007/cgi/boost/cgi/request_impl/fcgi_request_impl.hpp
==============================================================================
--- sandbox/SOC/2007/cgi/boost/cgi/request_impl/fcgi_request_impl.hpp	(original)
+++ sandbox/SOC/2007/cgi/boost/cgi/request_impl/fcgi_request_impl.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -1,44 +1,57 @@
 //               -- fcgi_request_impl.hpp --
 //
-//            Copyright (c) Darren Garvey 2007.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
+//            Copyright (c) Darren Garvey 2007.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 //
 ////////////////////////////////////////////////////////////////
-#ifndef CGI_FCGI_REQUEST_IMPL_HPP_INCLUDED__
-#define CGI_FCGI_REQUEST_IMPL_HPP_INCLUDED__
-
-namespace cgi {
-
-  /// Implementation for a FastCGI Responder request
-  class fcgi_responder_request_impl
-  {
-    fcgi_request() {} // private default constructor
-  public:
-    fcgi_request(protocol_service_type& pserv)
-      : protocol_service_(pserv)
-    {
-    }
-
-    bool load(bool parse_stdin)
-    {
-    }
-
-    template<typename Handler>
-    void async_load(bool parse_stdin, Handler handler)
-    {
-    }
-
-    /// The role of the request; in this case a responder
-    static role_type& role() { return role_type::responder; }
-  private:
-    protocol_service_type& protocol_service_;
-
-    /// Finished reading from stdin buffer (ie. POST data)
-    bool stdin_read_;
-  };
-
-} // namespace cgi
-
-#endif // CGI_FCGI_REQUEST_IMPL_HPP_INCLUDED__
+#ifndef CGI_FCGI_REQUEST_IMPL_HPP_INCLUDED__
+#define CGI_FCGI_REQUEST_IMPL_HPP_INCLUDED__
+
+namespace cgi {
+
+  /// Implementation for a FastCGI request
+  class fcgi_request_impl
+  {
+    fcgi_request() {} // private default constructor
+  public:
+    typedef tags::fastcgi    protocol_type;
+
+    explicit fcgi_request_impl(protocol_service_type& pserv
+                              , const role_type& role = role_type::responder
+			      , boost::weak_ptr<connection_base> connection = NULL)
+      : protocol_service_(pserv)
+      , role_(role)
+      , connection_(connection)
+      , data_read_(role_ == role_type::filter ? false : true)
+      , stdin_read_(role_ == role_type::authorizer ? true : false)
+    {
+    }
+
+  protected:
+    protocol_service_type& protocol_service_;
+
+    /// The role the request plays
+    role_type role_;
+
+    map_type env_vars_;
+    map_type cookie_vars_;
+    map_type post_vars_;
+    map_type get_vars_;
+
+    std::string stdin_buffer_;
+    std::string data_buffer_;
+
+    /// Finished reading from stdin buffer (ie. POST data)
+    bool stdin_read_;
+
+    /// Finished reading from data buffer (for Filter requests)
+    bool data_read_;
+
+    friend class fcgi_service_impl;
+  };
+
+} // namespace cgi
+
+#endif // CGI_FCGI_REQUEST_IMPL_HPP_INCLUDED__

Modified: sandbox/SOC/2007/cgi/boost/cgi/request_service.hpp
==============================================================================
--- sandbox/SOC/2007/cgi/boost/cgi/request_service.hpp	(original)
+++ sandbox/SOC/2007/cgi/boost/cgi/request_service.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -15,68 +15,75 @@
   class request_service
     : public boost::asio::io_service::service
   {
+    // The platform-specific implementation (only one for now)
+    typedef detail::request_traits<Protocol>::service_impl_type
+      service_impl_type;
+
   public:
+    typedef service_impl_type::impl_type                  impl_type;
+  
     typedef Protocol                                  protocol_type;
     typedef basic_protocol_service<Protocol>  protocol_service_type;
     typedef basic_request<Protocol>                    request_type;
     //typedef request_impl<Protocol>
 
 
-    request_service(io_service_type& ios)
-      : boost::asio::io_service::service(ios.io_service())
-      , io_service_(ios)
+    /// The unique service identifier
+    static boost::asio::io_service::id id;
+
+    request_service(protocol_service_type& ps)
+      : boost::asio::io_service::service(ps.io_service())
+      , service_impl_(boost::asio::use_service<service_impl_type>(ps.io_service()))
     {
     }
 
-    void shutdown_service()
+    void create(impl_type& impl)
     {
+      service_impl_.create(impl);
     }
 
-    //void construct
-
-    bool load()
+    void destroy(impl_type& impl)
     {
+      service_impl_.destroy(impl);
     }
 
-    template<typename ProtocolService, typename Handler>
-    class load_handler
+    void shutdown_service()
     {
-    public:
-      load_handler(ProtocolService& ps, Handler handler)
-        : service_(ps)
-        , handler_(handler)
-      {
-      }
+      service_impl_.shutdown_service();
+    }
 
-      void operator()(boost::system::error_code& ec)
-      {
-        if( ec )
-          handler(ec);
+    impl_type null() const
+    {
+      return service_impl_.null();
+    }
 
+    //void construct
 
-        //service_.dispatch(handler_(ec));
-      }
+    boost::system::error_code& load(bool parse_stdin, boost::system::error_code& ec)
+    {
+      return service_impl_.load(parse_stdin, ec);
+    }
 
-    private:
-      ProtocolService& service_;
-      Handler handler_;
-    };
 
     template<typename Handler>
-    void async_load(Handler handler)
+    void async_load(impl_type& impl, bool parse_stdin, boost::system::error_code& ec
+                   , Handler handler)
     {
+      service_impl_.async_load(impl, parse_stdin, ec, handler);
     }
-  private:
-    io_service_type& io_service_;
-  };
 
-  template<>
-  class request_service<protocol::cgi>
-  {
-  public:
+    bool is_open(impl_type& impl);
+    {
+      return service_impl_.is_open(impl);
+    }
 
+  private:
+    service_impl_type& service_impl_;
   };
 
+  template<typename Protocol>
+  boost::asio::io_service::id request_service<Protocol>::id;
+
 } // namespace cgi
 
 #endif // CGI_REQUEST_SERVICE_HPP_INCLUDED

Added: sandbox/SOC/2007/cgi/boost/cgi/service_impl/async_cgi_service_impl.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/cgi/boost/cgi/service_impl/async_cgi_service_impl.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -0,0 +1,84 @@
+#ifndef CGI_ASYNC_CGI_SERVICE_IMPL_HPP_INCLUDED__
+#define CGI_ASYNC_CGI_SERVICE_IMPL_HPP_INCLUDED__
+
+namespace cgi {
+
+  class async_cgi_service_impl
+    : public boost::asio::io_service::service
+    , public cgi_service_impl<async_cgi_request_impl>
+  {
+  public:
+    typedef tags::async_cgi                         protocol_type;
+    typedef typename protocol_type::service_type    protocol_service_type;
+
+    /// The unique service identifier
+    static boost::asio::io_service::id id;
+
+    explicit async_cgi_service_impl(protocol_service_type& protocol_service)
+      : boost::asio::io_service::service(protocol_service.io_service())
+      , cgi_service_impl<async_cgi_request_impl>()
+    {
+    }
+
+    void shutdown_service()
+    {
+    }
+
+    /// Construct a new cgi request implementation
+    void construct(impl_type& impl)
+    {
+    }
+
+    template<typename ImplType, typename Handler>
+    class load_handler
+    {
+    public:
+      load_handler(impl_type& impl, bool parse_stdin, Handler handler)
+	: impl_(impl)
+	, service_(impl.service_)
+	, work_(service.io_service())
+	, parse_stdin_(parse_stdin)
+	, handler_(handler)
+      {
+      }
+
+      void operator()(const boost::system::error_code& error)
+      {
+	if (error)
+	  service_.post(boost::bind(&Handler, handler_, error));
+	
+      }
+    private:
+      protocol_service_type& service_;
+      protocol_service_type::work work_;
+      Handler handler_;
+      ImplType impl_;
+    };
+
+    /// Asynchronously read/parse the request meta-data
+    /**
+     * @param parse_stdin if true then STDIN data is also read/parsed
+     */
+    template<typename Handler>
+    void async_load(impl_type& impl, bool parse_stdin, Handler handler)
+    {
+      impl.service_.post(boost::bind(&load_handler<impl_type, Handler>
+                                       (impl, parse_stdin, handler)));
+    }
+
+    template<typename MutableBufferSequence, typename Handler>
+    void async_read_some(impl_type& impl, const MutableBufferSequence& buf
+                        , Handler handler)
+    {
+      impl.connection_->async_read_some(buf, handler);
+    }
+
+    template<typename ConstBufferSequence, typename Handler>
+    void async_write_some(impl_type& impl, const ConstBufferSequence& buf
+                         , Handler handler)
+    {
+      impl.connection_->async_write_some(buf, handler);
+    }
+  };
+
+#endif // CGI_ASYNC_CGI_SERVICE_IMPL_HPP_INCLUDED__

Added: sandbox/SOC/2007/cgi/boost/cgi/service_impl/cgi_service_impl.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2007/cgi/boost/cgi/service_impl/cgi_service_impl.hpp	2007-07-12 14:09:06 EDT (Thu, 12 Jul 2007)
@@ -0,0 +1,214 @@
+#ifndef CGI_CGI_SERVICE_IMPL_HPP_INCLUDED__
+#define CGI_CGI_SERVICE_IMPL_HPP_INCLUDED__
+
+namespace cgi {
+
+  template<typename RequestImplType>
+  class cgi_service_impl
+  {
+  public:
+	typedef RequestImplType    impl_type;
+
+    explicit cgi_service_impl()
+    {
+    }
+
+    explicit cgi_service_impl(protocol_service_type&)
+    {
+    }
+
+    void shutdown_service()
+    {
+    }
+
+    void create(impl_type& impl)
+    {
+    }
+
+    void destroy(impl_type& impl)
+    {
+    }
+
+    /// Synchronously read/parse the request meta-data
+    /**
+     * @param parse_stdin if true then STDIN data is also read/parsed
+     */
+    boost::system::error_code& load(boost::system::error_code& ec
+                                   , bool parse_stdin)
+    {
+      std::string request_method = meta_get("REQUEST_METHOD");
+      if (request_method == "GET")
+        if (parse_get_vars(ec))
+	      return ec;
+      else
+      if (request_method == "POST" && parse_stdin)
+	    if (parse_post_vars(ec))
+	      return ec;
+
+      parse_cookie_vars(ec);
+      return ec;
+    }
+
+    template<typename ConnectionPtr, typename MutableBufferSequence>
+    std::size_t read_some(impl_type& impl, const MutableBufferSequence& buf
+                         , boost::system::error_code& ec)
+    {
+      std::size_t s = impl.connection_->read_some(buf, ec);
+      return s;
+    }
+
+    template<typename ConnectionPtr, typename ConstBufferSequence>
+    std::size_t write_some(impl_type& impl, const ConstBufferSequence& buf
+                          , boost::system::error_code& ec)
+    {
+      return impl.connection_->write_some(buf, ec);
+    }
+
+
+    //template<typename VarType> map_type& var(impl_type&) const;
+
+    const std::string& var(map_type& meta_data, const std::string& name
+                          , boost::system::error_code& ec) const
+    {
+      if ((map_type::iterator pos = meta_data.find(name)) != meta_data.end())
+      {
+        return *pos;
+      }
+      return std::string();
+
+      /* Alt:
+      if( meta_data.find(name) != meta_data.end() )
+        return meta_data[name];
+      return std::string();
+      **/
+    }
+
+	const std::string& meta_get(impl_type& impl, const std::string& name
+                               , boost::system::error_code& ec) const
+    {
+      return var(impl.get_vars_, name, ec);
+    }
+
+    map_type& meta_get(impl_type& impl) const
+    {
+      return impl.get_vars_;
+    }
+
+    /// Find the post meta-variable matching name
+    /**
+     * @param greedy This determines whether more data can be read to find
+     * the variable. The default is true to cause least surprise in the common
+     * case of having not parsed any of the POST data.
+
+     -----------------------------------------------
+     Should this return a pair of iterators instead?
+     What about url_decoding?
+     -----------------------------------------------
+
+     */
+    const std::string& meta_post(impl_type& impl, const std::string& name
+                                , boost::system::error_code& ec
+                                , bool greedy = true)
+    {
+      const std::string& val = var(impl.post_vars_, name, ec);
+      if (var.empty() && greedy && !ec)
+      {
+
+      }
+
+      return val;
+    }
+
+    map_type& meta_post(impl_type& impl) const
+    {
+      return impl.post_vars_;
+    }
+
+
+    /// Find the cookie meta-variable matching name
+    const std::string& meta_cookie(impl_type& impl, const std::string& name
+                                  , boost::system::error_code& ec) const
+    {
+      return var(impl.cookie_vars_, name, ec, false);
+    }
+
+    map_type& meta_cookie(impl_type& impl) const
+    {
+      return impl.cookie_vars_;
+    }
+
+
+    /// Find the environment meta-variable matching name
+    const std::string& meta_env(impl_type& impl, const std::string& name,
+                               , boost::system::error_code& ec) const
+    {
+	  return ::getenv(name);
+    }
+
+
+    role_type get_role(impl_type& impl) const
+    {
+      return role_type::responder;
+    }
+
+  protected:
+    boost::system::error_code& parse_get_vars(impl_type& impl
+											 , boost::system::error_code& ec)
+    {
+      // Make sure this function hasn't already been called
+      BOOST_ASSERT( impl.get_vars_.empty() );
+
+      extract_params(meta_env("QUERY_STRING")
+                    , impl.get_vars_
+                    , boost::char_separator<char>
+                        ("", "=&", boost::keep_empty_tokens)
+                    , ec);
+
+      return ec;
+    }
+
+    boost::system::error_code& parse_cookie_vars(impl_type& impl
+												, boost::system::error_code& ec)
+    {
+      // Make sure this function hasn't already been called
+      BOOST_ASSERT( impl.cookie_vars_.empty() );
+
+      std::string vars = meta_env("HTTP_COOKIE");
+      if (vars.empty())
+        return ec;
+
+      extract_params(meta_env("HTTP_COOKIE")
+                    , impl.cookie_vars_
+                    , boost::char_separator<char>
+                        ("", "=&", boost::keep_empty_tokens)
+                    , ec);
+
+      return ec;
+    }
+
+    boost::system::error_code& parse_post_vars(impl_type& impl
+											  , boost::system::error_code& ec)
+    {
+      // Make sure this function hasn't already been called
+      BOOST_ASSERT( impl.cookie_vars_.empty() );
+	  
+#     error "Not implemented"
+
+      if (impl_.stdin_parsed_)
+      {
+      }
+
+      return ec;
+    }
+
+    boost::system::error_code& parse_one_post_var(impl_type& impl
+                                                 , boost::system::error_code& ec)
+    {
+#     error "Not implemented"
+      return ec;
+    }
+  };
+
+} // namespace cgi
+
+#endif // CGI_CGI_SERVICE_IMPL_HPP_INCLUDED__