request.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_REQUEST_HPP
#define FASTCGIPP_REQUEST_HPP
 
#include "fastcgi++/protocol.hpp"
#include "fastcgi++/fcgistreambuf.hpp"
#include "fastcgi++/http.hpp"
 
#include <ostream>
#include <functional>
#include <queue>
#include <mutex>
 
namespace Fastcgipp
{
    class Request_base
    {
    public:
 
        virtual std::unique_lock<std::mutex> handler() =0;
 
        virtual ~Request_base() {}
 
        std::mutex mutex;
 
        inline void push(Message&& message)
        {
            std::lock_guard<std::mutex> lock(m_messagesMutex);
            m_messages.push(std::move(message));
        }
 
    protected:
        std::queue<Message> m_messages;
 
        std::mutex m_messagesMutex;
    };
 
 
    template<class charT> class Request: public Request_base
    {
    public:
 
        Request(const size_t maxPostSize=0):
            out(&m_outStreamBuffer),
            err(&m_errStreamBuffer),
            m_maxPostSize(maxPostSize),
            m_state(Protocol::RecordType::PARAMS),
            m_status(Protocol::ProtocolStatus::REQUEST_COMPLETE)
        {
            out.imbue(std::locale("C"));
            err.imbue(std::locale("C"));
        }
 
 
        void configure(
                const Protocol::RequestId& id,
                const Protocol::Role& role,
                bool kill,
                const std::function<void(const Socket&, Block&&, bool)>
                    send,
                const std::function<void(Message)> callback);
 
        std::unique_lock<std::mutex> handler();
 
        virtual ~Request() {}
 
    protected:
        const Http::Environment<charT>& environment() const
        {
            return m_environment;
        }
 
        Http::Environment<charT>& environment()
        {
            return m_environment;
        }
 
        std::basic_ostream<charT> out;
 
        std::basic_ostream<charT> err;
 
 
        virtual void errorHandler();
 
 
        virtual void bigPostErrorHandler();
 
 
        virtual void unknownContentErrorHandler();
 
        Protocol::Role role() const
        {
            return m_role;
        }
 
 
        const std::function<void(Message)>& callback() const
        {
            return m_callback;
        }
 
 
        virtual bool response() =0;
 
 
        virtual void inHandler(int bytesReceived)
        {}
 
 
        virtual bool inProcessor()
        {
            return false;
        }
 
 
        Message m_message;
 
 
        void dump(const char* data, size_t size)
        {
            m_outStreamBuffer.dump(data, size);
        }
 
 
        void dump(const unsigned char* data, size_t size)
        {
            m_outStreamBuffer.dump(reinterpret_cast<const char*>(data), size);
        }
 
 
        void dump(std::basic_istream<char>& stream)
        {
            m_outStreamBuffer.dump(stream);
        }
 
 
        unsigned pickLocale(const std::vector<std::string>& locales);
 
        void setLocale(const std::string& locale);
 
    private:
 
        std::function<void(Message)> m_callback;
 
        Http::Environment<charT> m_environment;
 
        const size_t m_maxPostSize;
 
        Protocol::Role m_role;
 
        Protocol::RequestId m_id;
 
        bool m_kill;
 
        Protocol::RecordType m_state;
 
        void complete();
 
        std::function<void(const Socket&, Block&&, bool kill)> m_send;
 
        Protocol::ProtocolStatus m_status;
 
        FcgiStreambuf<charT> m_outStreamBuffer;
 
        FcgiStreambuf<charT> m_errStreamBuffer;
 
        inline const char* codepage() const;
    };
}
 
#endif