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;
        }

        std::basic_ostream<charT> out;

        std::basic_ostream<charT> err;


        virtual void errorHandler();


        virtual void bigPostErrorHandler();

        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)
        {}


        bool virtual 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