protocol.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 PROTOCOL_HPP
#define PROTOCOL_HPP

#include <fastcgi++/config.h>
#include <map>
#include <string>
#include <exception>

#if defined (HAVE_ENDIAN_H)
#include <endian.h>
#elif defined (HAVE_MACHINE_ENDIAN_H)
#include <machine/endian.h>
#elif defined (HAVE_ARPA_ENDIAN_H)
#include <arpa/nameser_compat.h>
#else
#error Could not locate a file that defines endianess
#endif

#include <stdint.h>

#include <boost/shared_array.hpp>

#include <fastcgi++/message.hpp>

namespace Fastcgipp
{
   extern const char version[];
   namespace Protocol
   {
      typedef uint16_t RequestId;
      

      struct FullId
      {

         FullId(RequestId fcgiId_, int fd_): fcgiId(fcgiId_), fd(fd_) { } 
         FullId() { }
         RequestId fcgiId;
         uint16_t fd;
      };
      
      enum RecordType { BEGIN_REQUEST=1, ABORT_REQUEST=2, END_REQUEST=3, PARAMS=4, IN=5, OUT=6, ERR=7, DATA=8, GET_VALUES=9, GET_VALUES_RESULT=10, UNKNOWN_TYPE=11 };
      
      extern const char* recordTypeLabels[];
   }
}
      

#include <fastcgi++/exceptions.hpp>

namespace Fastcgipp
{

   namespace Protocol
   {
      const int version=1;

      const int chunkSize=8;

      enum Role { RESPONDER=1, AUTHORIZER=2, FILTER=3 };

      enum ProtocolStatus { REQUEST_COMPLETE=0, CANT_MPX_CONN=1, OVERLOADED=2, UNKNOWN_ROLE=3 };


      inline bool operator>(const FullId& x, const FullId& y) { return *(uint32_t*)&x.fcgiId > *(uint32_t*)&y.fcgiId; }


      inline bool operator<(const FullId& x, const FullId& y) { return *(uint32_t*)&x.fcgiId < *(uint32_t*)&y.fcgiId; }


      inline bool operator==(const FullId& x, const FullId& y) { return *(uint32_t*)&x.fcgiId == *(uint32_t*)&y.fcgiId; }


#if __BYTE_ORDER == __LITTLE_ENDIAN
      template<class T> T readBigEndian(T value)
      {
         T result;
         char* pValue=(char*)&value-1;
         char* pValueEnd=pValue+sizeof(T);
         char* pResult=(char*)&result+sizeof(T);
         while(pValue!=pValueEnd)
            *--pResult=*++pValue;
         return result;
      }
#elif __BYTE_ORDER == __BIG_ENDIAN
      template<class T> T readBigEndian(T value)
      {
         return value;
      }
#endif


      class Header
      {
      public:

         void setVersion(uint8_t version_) { version=version_; }


         int getVersion() const { return version; }


         void setType(RecordType type_) { type=static_cast<uint8_t>(type_); }


         RecordType getType() const { return static_cast<RecordType>(type); }


         void setRequestId(RequestId requestId_) { *(uint16_t*)&requestIdB1=readBigEndian(requestId_); }


         RequestId getRequestId() const { return readBigEndian(*(uint16_t*)&requestIdB1); }


         void setContentLength(uint16_t contentLength_) { *(uint16_t*)&contentLengthB1=readBigEndian(contentLength_); }


         int getContentLength() const { return readBigEndian(*(uint16_t*)&contentLengthB1); }


         void setPaddingLength(uint8_t paddingLength_) { paddingLength=paddingLength_; }


         int getPaddingLength() const { return paddingLength; }
      private:
         uint8_t version;
         uint8_t type;
         uint8_t requestIdB1;
         uint8_t requestIdB0;
         uint8_t contentLengthB1;
         uint8_t contentLengthB0;
         uint8_t paddingLength;
         uint8_t reserved;
      };

      

      class BeginRequest
      {
      public:

         Role getRole() const { return static_cast<Role>(readBigEndian(*(uint16_t*)&roleB1)); }


         bool getKeepConn() const { return flags & keepConnBit; }
      private:
         static const int keepConnBit = 1;

         uint8_t roleB1;
         uint8_t roleB0;
         uint8_t flags;
         uint8_t reserved[5];
      };


      class UnknownType
      {
      public:

         void setType(RecordType type_) { type=static_cast<uint8_t>(type_); }
      private:
         uint8_t type;
         uint8_t reserved[7];
      };


      class EndRequest
      {
      public:

         void setAppStatus(int status) { *(int*)&appStatusB3=readBigEndian(status); }


         void setProtocolStatus(ProtocolStatus status) { protocolStatus=static_cast<uint8_t>(status); }
      private:
         uint8_t appStatusB3;
         uint8_t appStatusB2;
         uint8_t appStatusB1;
         uint8_t appStatusB0;
         uint8_t protocolStatus;
         uint8_t reserved[3];
      };


      void processParamHeader(const char* data, size_t dataSize, const char*& name, size_t& nameSize, const char*& value, size_t& valueSize);

      

      template<int NAMELENGTH, int VALUELENGTH, int PADDINGLENGTH> struct ManagementReply
      {
      private:
         Header header;
         uint8_t nameLength;
         uint8_t valueLength;
         uint8_t name[NAMELENGTH];
         uint8_t value[VALUELENGTH];
         uint8_t padding[PADDINGLENGTH];
      public:

         ManagementReply(const char* name_, const char* value_): nameLength(NAMELENGTH), valueLength(VALUELENGTH)
         {
            for(int i=0; i<NAMELENGTH; i++) name[i]=*(name_+i);
            for(int i=0; i<VALUELENGTH; i++) value[i]=*(value_+i);
            header.setVersion(version);
            header.setType(GET_VALUES_RESULT);
            header.setRequestId(0);
            header.setContentLength(NAMELENGTH+VALUELENGTH);
            header.setPaddingLength(PADDINGLENGTH);
         }
      };

      extern ManagementReply<14, 2, 8> maxConnsReply;
      extern ManagementReply<13, 2, 1> maxReqsReply;
      extern ManagementReply<15, 1, 8> mpxsConnsReply;
   }
}

#endif