request.hpp

Go to the documentation of this file.

/***************************************************************************
* Copyright (C) 2007 Eddie Carle [eddie@erctech.org]                       *
*                                                                          *
* This file is part of fastcgi++.                                          *
*                                                                          *
* fastcgi++ is free software: you can redistribute it and/or modify it     *
* under the terms of the GNU Lesser General Public License as  published   *
* by the Free Software Foundation, either version 3 of the License, or (at *
* your option) any later version.                                          *
*                                                                          *
* fastcgi++ 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 Lesser General Public     *
* License for more details.                                                *
*                                                                          *
* You should have received a copy of the GNU Lesser General Public License *
* along with fastcgi++.  If not, see <http://www.gnu.org/licenses/>.       *
****************************************************************************/


#ifndef REQUEST_HPP
#define REQUEST_HPP

#include <queue>
#include <map>
#include <string>
#include <locale>

#include <boost/shared_array.hpp>
#include <boost/thread.hpp>
#include <boost/function.hpp>

#include <fastcgi++/transceiver.hpp>
#include <fastcgi++/protocol.hpp>
#include <fastcgi++/exceptions.hpp>
#include <fastcgi++/fcgistream.hpp>
#include <fastcgi++/http.hpp>

namespace Fastcgipp
{
   template<class T> class Manager;


   template<class charT> class Request
   {
   public:

      Request(const size_t maxPostSize=0): m_maxPostSize(maxPostSize), state(Protocol::PARAMS)  { setloc(std::locale::classic()); out.exceptions(std::ios_base::badbit | std::ios_base::failbit | std::ios_base::eofbit); m_environment.clearPostBuffer(); }

      const Http::Environment<charT>& environment() const { return m_environment; }

      // To dump data into the stream without it being code converted and bypassing the stream buffer call Fcgistream::dump(char* data, size_t size)
      // or Fcgistream::dump(std::basic_istream<char>& stream)
      

      Fcgistream<charT> out;


      Fcgistream<charT> err;


      virtual void errorHandler(const std::exception& error);

      virtual void bigPostErrorHandler();

      Protocol::Role role() const { return m_role; }


      const boost::function<void(Message)>& callback() const { return m_callback; }


      void setloc(std::locale loc_){ out.imbue(loc_); err.imbue(loc_); }


      const std::locale& getloc(){ return loc; }

   protected:

      virtual bool response() =0;


      virtual void inHandler(int bytesReceived) { };


      const Message& message() const { return m_message; }

   private:
      template<class T> friend class Manager;

      std::locale loc;


      Message m_message;


      boost::function<void(Message)> m_callback;

      Http::Environment<charT> m_environment;


      class Messages: public std::queue<Message>, public boost::mutex {};
      Messages messages;

      const size_t m_maxPostSize;


      bool handler();
      Transceiver* transceiver;
      Protocol::Role m_role;
      Protocol::FullId id;
      bool killCon;
      Protocol::RecordType state;
      void complete();

      void set(Protocol::FullId id_, Transceiver& transceiver_, Protocol::Role role_, bool killCon_, boost::function<void(Message)> callback_)
      {
         killCon=killCon_;
         id=id_;
         transceiver=&transceiver_;
         m_role=role_;
         m_callback=callback_;

         err.set(id_, transceiver_, Protocol::ERR);
         out.set(id_, transceiver_, Protocol::OUT);
      }
   };

   namespace Exceptions
   {
      struct RecordsOutOfOrder: public std::exception
      {
         const char* what() const throw() { return "FastCGI records received out of order from server."; }
      };

      struct UnknownContentType: public std::exception
      {
         const char* what() const throw() { return "Client sent unknown content type."; }
      };
   }
}

#endif