http.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 HTTP_HPP
#define HTTP_HPP

#include <string>
#include <boost/shared_array.hpp>
#include <boost/scoped_array.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <ostream>
#include <istream>
#include <cstring>
#include <sstream>
#include <algorithm>
#include <map>
#include <vector>

#include <fastcgi++/exceptions.hpp>
#include <fastcgi++/protocol.hpp>

namespace Fastcgipp
{
   namespace Http
   {

      template<class charT> struct Post
      {
         enum Type { file, form } type;
         std::basic_string<charT> value;
         std::basic_string<charT>& filename;
         std::basic_string<charT> contentType;

         const char* data() const { return m_data; }
         size_t size() const { return m_size; }
         char* steal() const { char* ptr=m_data; m_data=0; m_size=0; return ptr; }

         Post(): filename(value), m_data(0), m_size(0) {}
         Post(const Post& x):
            type(x.type),
            value(x.value),
            filename(value),
            contentType(x.contentType),
            m_data(x.steal()),
            m_size(x.m_size)
         {}
         ~Post() { delete [] m_data; }
      private:
         mutable char* m_data;
         mutable size_t m_size;
         template<class T> friend class Environment;
      };

      enum RequestMethod
      {
         HTTP_METHOD_ERROR,
         HTTP_METHOD_HEAD,
         HTTP_METHOD_GET,
         HTTP_METHOD_POST,
         HTTP_METHOD_PUT,
         HTTP_METHOD_DELETE,
         HTTP_METHOD_TRACE,
         HTTP_METHOD_OPTIONS,
         HTTP_METHOD_CONNECT
      };
      extern const char* requestMethodLabels[];
      template<class charT, class Traits> inline std::basic_ostream<charT, Traits>& operator<<(std::basic_ostream<charT, Traits>& os, const RequestMethod requestMethod) { return os << requestMethodLabels[requestMethod]; }
   

      class Address
      {
      public:
         static const size_t size=16;


         const unsigned char* data() const { return m_data; }


         unsigned char* data() { return m_data; }


         Address operator=(const unsigned char* data_) { std::memcpy(m_data, data_, size); return *this; }

         Address operator=(const Address& address) { std::memcpy(m_data, address.m_data, size); return *this; }
         Address(const Address& address) { std::memcpy(m_data, address.m_data, size); }
         Address() {}


         explicit Address(const unsigned char* data_) { std::memcpy(m_data, data_, size); }


         void assign(const char* start, const char* end);
         inline bool operator==(const Address& x) const { return std::memcmp(m_data, x.m_data, size)==0; }
         inline bool operator>(const Address& x) const { return std::memcmp(m_data, x.m_data, size)>0; }
         inline bool operator<(const Address& x) const { return std::memcmp(m_data, x.m_data, size)<0; }
         inline bool operator<=(const Address& x) const { return !(std::memcmp(m_data, x.m_data, size)>0); }
         inline bool operator>=(const Address& x) const { return !(std::memcmp(m_data, x.m_data, size)<0); }
         operator bool() const;
         Address operator&(const Address& x) const;

         Address& operator&=(const Address& x);

         void zero() { std::memset(m_data, 0, size); }

      private:
         unsigned char m_data[size];
      };


      template<class charT, class Traits> std::basic_ostream<charT, Traits>& operator<<(std::basic_ostream<charT, Traits>& os, const Address& address);

      template<class charT, class Traits> std::basic_istream<charT, Traits>& operator>>(std::basic_istream<charT, Traits>& is, Address& address);


      template<class charT> struct Environment
      {
         std::basic_string<charT> host;
         std::basic_string<charT> userAgent;
         std::basic_string<charT> acceptContentTypes;
         std::basic_string<charT> acceptLanguages;
         std::basic_string<charT> acceptCharsets;
         std::basic_string<charT> referer;
         std::basic_string<charT> contentType;
         std::basic_string<charT> root;
         std::basic_string<charT> scriptName;
         RequestMethod requestMethod;
         std::basic_string<charT> requestUri;
         typedef std::vector<std::basic_string<charT> > PathInfo;
         PathInfo pathInfo;
         int etag;
         int keepAlive;
         unsigned int contentLength;
         Address serverAddress;
         Address remoteAddress;
         uint16_t serverPort;
         uint16_t remotePort;
         boost::posix_time::ptime ifModifiedSince;

         typedef std::map<std::basic_string<charT>, std::basic_string<charT> > Cookies;
         Cookies cookies;
         const std::basic_string<charT>& findCookie(const charT* key) const;

         typedef std::map<std::basic_string<charT>, std::basic_string<charT> > Gets;
         Gets gets;


         const std::basic_string<charT>& findGet(const charT* key) const;


         bool checkForGet(const charT* key) const;

         typedef std::map<std::basic_string<charT>, Post<charT> > Posts;
         Posts posts;


         const Post<charT>& findPost(const charT* key) const;


         bool checkForPost(const charT* key) const;


         void fill(const char* data, size_t size);


         bool fillPostBuffer(const char* data, size_t size);

         void parsePostsMultipart();

         void parsePostsUrlEncoded();

         void clearPostBuffer() { postBuffer.reset(); pPostBuffer=0; }

         Environment(): requestMethod(HTTP_METHOD_ERROR), etag(0), keepAlive(0), contentLength(0), serverPort(0), remotePort(0) {}
      private:
         boost::scoped_array<char> boundary;
         size_t boundarySize;

         boost::scoped_array<char> postBuffer;
         char* pPostBuffer;
         size_t minPostBufferSize(const size_t size) { return std::min(size, size_t(postBuffer.get()+contentLength-pPostBuffer)); }
      };


      void charToString(const char* data, size_t size, std::wstring& string);


      inline void charToString(const char* data, size_t size, std::string& string) { string.assign(data, size); }


      int atoi(const char* start, const char* end);


      template<class charT> void decodeUrlEncoded(const char* data, size_t size, std::map<std::basic_string<charT>, std::basic_string<charT> >& output, const char fieldSeperator='&');


      size_t percentEscapedToRealBytes(const char* source, char* destination, size_t size);

      extern const char base64Characters[];

      template<class In, class Out> void base64Encode(In start, In end, Out destination);

      template<class In, class Out> Out base64Decode(In start, In end, Out destination);

      class SessionId
      {
         public: static const int size=12;

      private:
         char data[size];

         boost::posix_time::ptime timestamp;

         static bool seeded;

         template<class T> friend class Sessions;
      public:
         SessionId();

         SessionId(const SessionId& x): timestamp(x.timestamp) { std::memcpy(data, x.data, size); }
         const SessionId& operator=(const SessionId& x) { std::memcpy(data, x.data, size); timestamp=x.timestamp; return *this; }

         template<class charT> const SessionId& operator=(charT* data_);

         template<class charT> SessionId(charT* data_) { *this=data_; }

         template<class charT, class Traits> friend std::basic_ostream<charT, Traits>& operator<<(std::basic_ostream<charT, Traits>& os, const SessionId& x);

         bool operator<(const SessionId& x) const { return std::memcmp(data, x.data, SessionId::size)<0; }
         bool operator==(const SessionId& x) const { return std::memcmp(data, x.data, SessionId::size)==0; }

         void refresh() const { *const_cast<boost::posix_time::ptime*>(&timestamp)=boost::posix_time::second_clock::universal_time(); }

         const char* getInternalPointer() const { return data; }
      };

      template<class charT, class Traits> std::basic_ostream<charT, Traits>& operator<<(std::basic_ostream<charT, Traits>& os, const SessionId& x) { base64Encode(x.data, x.data+SessionId::size, std::ostream_iterator<charT, charT, Traits>(os)); return os; }

      template<class T> class Sessions: public std::map<SessionId, T>
      {
      private:
         const boost::posix_time::seconds keepAlive;

         const boost::posix_time::seconds cleanupFrequency;

         boost::posix_time::ptime cleanupTime;
      public:
         typedef typename std::map<SessionId, T>::iterator iterator;
         typedef typename std::map<SessionId, T>::const_iterator const_iterator;
         Sessions(int keepAlive_, int cleanupFrequency_): keepAlive(boost::posix_time::seconds(keepAlive_)), cleanupFrequency(boost::posix_time::seconds(cleanupFrequency_)), cleanupTime(boost::posix_time::second_clock::universal_time()+cleanupFrequency) { }
            
         void cleanup();

         iterator generate(const T& value_ = T());

         boost::posix_time::ptime getExpiry(const_iterator it) const { return it->first.timestamp+keepAlive; }
      };
   }
}

template<class T> void Fastcgipp::Http::Sessions<T>::cleanup()
{
   if(boost::posix_time::second_clock::universal_time() < cleanupTime)
      return;
   boost::posix_time::ptime oldest(boost::posix_time::second_clock::universal_time()-keepAlive);
   iterator it=this->begin();
   while(it!=this->end())
   {
      if(it->first.timestamp < oldest)
         erase(it++);
      else
         ++it;
   }
   cleanupTime=boost::posix_time::second_clock::universal_time()+cleanupFrequency;
}

template<class In, class Out> Out Fastcgipp::Http::base64Decode(In start, In end, Out destination)
{
   Out dest=destination;

   for(int buffer, bitPos=-8, padStart; start!=end || bitPos>-6; ++dest)
   {
      if(bitPos==-8)
      {
         bitPos=18;
         padStart=-9;
         buffer=0;
         while(bitPos!=-6)
         {
            if(start==end) return destination;
            int value=*start++;
            if(value >= 'A' && 'Z' >= value) value -= 'A';
            else if(value >= 'a' && 'z' >= value) value -= 'a' - 26;
            else if(value >= '0' && '9' >= value) value -= '0' - 52;
            else if(value == '+') value = 62;
            else if(value == '/') value = 63;
            else if(value == '=') { padStart=bitPos; break; }
            else return destination;

            buffer |= value << bitPos;
            bitPos-=6;
         }
         bitPos=16;
      }

      *dest = (buffer >> bitPos) & 0xff;
      bitPos-=8;
      if(padStart>=bitPos)
      {
         if( (padStart-bitPos)/6 )
            return dest;
         else
            return ++dest;
      }
   }

   return dest;
}

template<class In, class Out> void Fastcgipp::Http::base64Encode(In start, In end, Out destination)
{
   for(int buffer, bitPos=-6, padded; start!=end || bitPos>-6; ++destination)
   {
      if(bitPos==-6)
      {
         bitPos=16;
         buffer=0;
         padded=-6;
         while(bitPos!=-8)
         {
            if(start!=end) 
               buffer |= (uint32_t)*(unsigned char*)start++ << bitPos;
            else padded+=6;
            bitPos-=8;
         }
         bitPos=18;
      }

      if(padded == bitPos)
      {
         *destination='=';
         padded-=6;
      }
      else *destination=base64Characters[ (buffer >> bitPos)&0x3f ];
      bitPos -= 6;
   }
}

template<class T> typename Fastcgipp::Http::Sessions<T>::iterator Fastcgipp::Http::Sessions<T>::generate(const T& value_)
{
   std::pair<iterator,bool> retVal;
   retVal.second=false;
   while(!retVal.second)
      retVal=insert(std::pair<SessionId, T>(SessionId(), value_));
   return retVal.first;
}

#endif