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

#include <string>
#include <ostream>
#include <istream>
#include <iterator>
#include <cstring>
#include <algorithm>
#include <map>
#include <vector>
#include <memory>
#include <array>
#include <ctime>
#include <cstring>
#include <atomic>

#include <fastcgi++/protocol.hpp>

namespace Fastcgipp
{
    namespace Http
    {

        template<class charT> struct File
        {
            std::basic_string<charT> filename;

            std::basic_string<charT> contentType;

            size_t size;

            mutable std::unique_ptr<char[]> data;

            File(File&& x):
                filename(std::move(x.filename)),
                contentType(std::move(x.contentType)),
                size(x.size),
                data(std::move(x.data))
            {}

            File() {}
        };

        enum class RequestMethod
        {
            ERROR=0,
            HEAD=1,
            GET=2,
            POST=3,
            PUT=4,
            DELETE=5,
            TRACE=6,
            OPTIONS=7,
            CONNECT=8
        };

        extern const std::array<const char* const, 9> 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[static_cast<int>(requestMethod)];
        }


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

            std::array<unsigned char, size> m_data;


            Address operator=(const unsigned char* data)
            {
                std::copy(data, data+m_data.size(), m_data.begin());
                return *this;
            }

            Address operator=(const Address& address)
            {
                std::copy(
                        address.m_data.begin(),
                        address.m_data.end(),
                        m_data.begin());
                return *this;
            }

            Address(const Address& address)
            {
                std::copy(
                        address.m_data.begin(),
                        address.m_data.end(),
                        m_data.begin());
            }

            Address()
            {
                zero();
            }


            explicit Address(const unsigned char* data)
            {
                std::copy(data, data+m_data.size(), m_data.begin());
            }


            template<class charT> void assign(
                    const charT* start,
                    const charT* end);

            bool operator==(const Address& x) const
            {
                return std::equal(
                        m_data.cbegin(),
                        m_data.cend(),
                        x.m_data.cbegin());
            }

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

            operator bool() const;

            Address operator&(const Address& x) const;

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

            void zero()
            {
                m_data.fill(0);
            }
        };


        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::vector<std::string> acceptLanguages;

            std::basic_string<charT> acceptCharsets;
      
            std::basic_string<charT> authorization;
      
            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;

            std::vector<std::basic_string<charT>> pathInfo;

            unsigned etag;

            unsigned keepAlive;

            unsigned contentLength;

            Address serverAddress;

            Address remoteAddress;

            uint16_t serverPort;

            uint16_t remotePort;

            std::time_t ifModifiedSince;

            std::multimap<
                std::basic_string<charT>,
                std::basic_string<charT>> cookies;

            std::multimap<
                std::basic_string<charT>,
                std::basic_string<charT>> gets;

            std::multimap<
                std::basic_string<charT>,
                std::basic_string<charT>> posts;

            std::multimap<
                std::basic_string<charT>,
                File<charT>> files;


            void fill(
                    const char* data,
                    const char* dataEnd);


            void fillPostBuffer(
                    const char* start,
                    const char* end);


            bool parsePostBuffer();

            const std::vector<char>& postBuffer() const
            {
                return m_postBuffer;
            }

            void clearPostBuffer()
            {
                m_postBuffer.clear();
                m_postBuffer.shrink_to_fit();
            }

            Environment():
                requestMethod(RequestMethod::ERROR),
                etag(0),
                keepAlive(0),
                contentLength(0),
                serverPort(0),
                remotePort(0),
                ifModifiedSince(0)
            {}
        private:
            inline void parsePostsMultipart();

            inline void parsePostsUrlEncoded();

            std::vector<char> boundary;

            std::vector<char> m_postBuffer;
        };


        void vecToString(
                const char* start,
                const char* end,
                std::wstring& string);


        inline void vecToString(
                const char* start,
                const char* end,
                std::string& string)
        {
            string.assign(start, end);
        }


        template<class charT> int atoi(const charT* start, const charT* end);


        template<class charT> float atof(const charT* start, const charT* end);


        template<class charT> void decodeUrlEncoded(
                const char* data,
                const char* dataEnd,
                std::multimap<
                    std::basic_string<charT>,
                    std::basic_string<charT>>& output,
                const char* const fieldSeparator="&");


        char* percentEscapedToRealBytes(
                const char* start,
                const char* end,
                char* destination);

        extern const std::array<const char, 64> base64Characters;


        template<class In, class Out>
        Out 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 size_t size=15;

            static const size_t stringLength=size*4/3;

        private:
            std::array<unsigned char, size> m_data;

            mutable std::time_t m_timestamp;

            void refresh() const
            {
                m_timestamp = std::time(nullptr);
            }

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

            SessionId(const SessionId& x):
                m_timestamp(x.m_timestamp)
            {
                std::copy(x.m_data.begin(), x.m_data.end(), m_data.begin());
            }


            template<class charT>
            SessionId(const std::basic_string<charT>& string);

            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(
                        m_data.data(),
                        x.m_data.data(),
                        SessionId::size)<0;
            }

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

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


        template<class T> class Sessions
        {
        private:
            const unsigned int m_keepAlive;

            std::time_t m_cleanupTime;

            std::map<SessionId, std::shared_ptr<const T>> m_sessions;

            mutable std::mutex m_mutex;

            static const size_t expirationLength = 30;

            char m_expiration[2][expirationLength];

            std::atomic<const char*> m_expirationPtr;

            void setExpiration();

        public:

            Sessions(unsigned int keepAlive):
                m_keepAlive(keepAlive),
                m_cleanupTime(std::time(nullptr)+keepAlive)
            {
                setExpiration();
            }


            std::shared_ptr<const T> get(const SessionId& id);

            size_t size() const
            {
                std::lock_guard<std::mutex> lock(m_mutex);
                return m_sessions.size();
            }


            SessionId generate(const std::shared_ptr<const T>& data);


            void erase(const SessionId& id)
            {
                std::lock_guard<std::mutex> lock(m_mutex);
                m_sessions.erase(id);
            }

            const char* expiration() const
            {
                return m_expirationPtr;
            }
        };
    }
}

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>
Out 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 |= static_cast<int>(
                            *reinterpret_cast<const 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;
    }

    return destination;
}

template<class T> Fastcgipp::Http::SessionId
Fastcgipp::Http::Sessions<T>::generate(const std::shared_ptr<const T>& data)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    std::pair<
            typename std::map<SessionId, std::shared_ptr<const T>>::iterator,
            bool>
        retVal;
    retVal.second=false;
    while(!retVal.second)
        retVal=m_sessions.insert(std::pair<SessionId, std::shared_ptr<const T>>(
                    SessionId(),
                    data));
    return retVal.first->first;
}

template<class T> std::shared_ptr<const T>
Fastcgipp::Http::Sessions<T>::get(const SessionId& id)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    const std::time_t now = std::time(nullptr);
    const std::time_t oldest(now-m_keepAlive);

    if(now >= m_cleanupTime)
    {
        auto session = m_sessions.begin();
        while(session != m_sessions.end())
        {
            if(session->first.m_timestamp < oldest)
                session = m_sessions.erase(session);
            else
                ++session;
        }
        m_cleanupTime = std::time(nullptr)+m_keepAlive;
        setExpiration();
    }

    const auto session = m_sessions.find(id);
    if(session != m_sessions.cend())
    {
        if(session->first.m_timestamp < oldest)
            m_sessions.erase(session);
        else
        {
            session->first.refresh();
            return session->second;
        }
    }

    return std::shared_ptr<const T>();
}

template<class T> void Fastcgipp::Http::Sessions<T>::setExpiration()
{
    char* const newExpiration(
        m_expirationPtr==m_expiration[0]?m_expiration[1]:m_expiration[0]);
    const std::time_t expirationTime = m_cleanupTime + m_keepAlive;
    const auto count = std::strftime(
            newExpiration,
            expirationLength,
            "%a, %d %b %Y %H:%M:%S GMT",
            std::gmtime(&expirationTime));
    std::fill(newExpiration+count, newExpiration+expirationLength, 0);
    m_expirationPtr = newExpiration;
}

#endif