protocol.hpp

Go to the documentation of this file.

/*******************************************************************************
* Copyright (C) 2017 Eddie Carle [eddie@isatec.ca]                             *
*                                                                              *
* 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 FASTCGIPP_PROTOCOL_HPP
#define FASTCGIPP_PROTOCOL_HPP

#include <memory>
#include <cstdint>
#include <algorithm>
#include <map>
#include <vector>

#include "fastcgi++/message.hpp"
#include "fastcgi++/sockets.hpp"

namespace Fastcgipp
{
    extern const char version[];


    namespace Protocol
    {
        typedef uint16_t FcgiId;

        const uint16_t badFcgiId = 0xffffUL;


        struct RequestId
        {

            RequestId(
                    FcgiId id,
                    const Socket& socket):
                m_socket(socket),
                m_id(id)
            {}

            RequestId(const RequestId& x):
                m_socket(x.m_socket),
                m_id(x.m_id)
            {}

            RequestId():
                m_socket(Socket()),
                m_id(badFcgiId)
            {}

            RequestId& operator=(const RequestId& x)
            {
                m_socket = x.m_socket;
                m_id = x.m_id;
                return *this;
            }

            Socket m_socket;

            FcgiId m_id;

            struct Less
            {
                using is_transparent = std::true_type;

                bool operator()(const RequestId& x, const RequestId& y) const
                {
                    if(x.m_socket == y.m_socket)
                        return x.m_id < y.m_id;
                    else
                        return x.m_socket < y.m_socket;
                }

                bool operator()(const RequestId& id, const Socket& socket) const
                {
                    return id.m_socket < socket;
                }

                bool operator()(const Socket& socket, const RequestId& id) const
                {
                    return socket < id.m_socket;
                }
            };
        };

        template<class T>
        using Requests = std::map<RequestId, T, RequestId::Less>;

        enum class RecordType: uint8_t
        {
            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
        };

        const int version=1;

        const int chunkSize=8;

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

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

        template<size_t Size> struct Unsigned;
        template<> struct Unsigned<2>
        {
            typedef uint16_t Type;
        };
        template<> struct Unsigned<4>
        {
            typedef uint32_t Type;
        };
        template<> struct Unsigned<8>
        {
            typedef uint64_t Type;
        };


        template<typename T> class BigEndian
        {
        private:
            static const size_t size = sizeof(T);
            static_assert(size==2 || size==4 || size==8, "Fastcgipp::Protocol::"
                    "BigEndian can only work with types of size 2, 4 or 8.");

            typedef typename Unsigned<size>::Type BaseType;

            unsigned char m_data[size];

            void set(T x)
            {
                union
                {
                    BaseType base;
                    T actual;
                };
                actual = x;
                for(unsigned int i=0; i<size; ++i)
                    m_data[i] = static_cast<unsigned char>(
                            0xff & base>>8*(size-1-i));
            }

        public:
            BigEndian& operator=(T x)
            {
                set(x);
                return *this;
            }

            BigEndian(T x)
            {
                set(x);
            }

            constexpr BigEndian()
            {}

            operator T() const
            {
                return read(m_data);
            }


            static T read(const unsigned char* source)
            {
                union
                {
                    BaseType base;
                    T actual;
                };
                base = 0;

                for(unsigned int i=0; i<size; ++i)
                    base |= static_cast<BaseType>(*(source+i))
                        << 8*(size-1-i);

                return actual;
            }

            static T read(const char* source)
            {
                return read(reinterpret_cast<const unsigned char*>(source));
            }
        };


        struct Header
        {
            uint8_t version;

            RecordType type;

            BigEndian<FcgiId> fcgiId;

            BigEndian<uint16_t> contentLength;

            uint8_t paddingLength;

            uint8_t reserved;
        };


        struct BeginRequest
        {
            static const int keepConnBit = 1;


            bool kill() const
            {
                return !(flags & keepConnBit);
            }

            BigEndian<Role> role;

            uint8_t flags;

            uint8_t reserved[5];
        };


        struct UnknownType
        {
            RecordType type;

            uint8_t reserved[7];
        };


        struct EndRequest
        {
            BigEndian<int32_t> appStatus;

            ProtocolStatus protocolStatus;

            uint8_t reserved[3];
        };


        bool processParamHeader(
                const char* data,
                const char* const dataEnd,
                const char*& name,
                const char*& value,
                const char*& end);


        template<int NAMELENGTH, int VALUELENGTH> struct ManagementReply
        {
        private:
            static const int paddingLength = (chunkSize-1)-(
                    sizeof(Header)
                    +2
                    +NAMELENGTH
                    +VALUELENGTH
                    -1)%chunkSize;

            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)
            {
                std::copy(name_, name_+NAMELENGTH, name);
                std::copy(value_, value_+VALUELENGTH, value);
                header.version = version;
                header.type = RecordType::GET_VALUES_RESULT;
                header.fcgiId = 0;
                header.contentLength = NAMELENGTH+VALUELENGTH;
                header.paddingLength= paddingLength;
            }
        };

        extern const ManagementReply<14, 2> maxConnsReply;

        extern const ManagementReply<13, 2> maxReqsReply;

        extern const ManagementReply<15, 1> mpxsConnsReply;
    }
}

#endif