HttpServerBase.hpp

Go to the documentation of this file.

#ifndef _IDENTT_HTTP_SERVER_BASE_HPP_
#define _IDENTT_HTTP_SERVER_BASE_HPP_

#include "AsioCompat.hpp"
#include "Mutex.hpp"
#include "Utility.hpp"
#include <functional>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <sstream>
#include <unordered_set>
#include <regex>

namespace identt {
namespace http {
template <class socket_type> class HttpServer;

template <class socket_type>
class HttpServerBase {
protected:
    class Connection;
    class Session;

public:
    class Response : public std::enable_shared_from_this<Response>, public std::ostream {
        friend class HttpServerBase<socket_type>;
        friend class HttpServer<socket_type>;

        std::unique_ptr<asio::streambuf> streambuf = std::unique_ptr<asio::streambuf>(new asio::streambuf());

        std::shared_ptr<Session> session;
        long timeout_content;

        Mutex send_queue_mutex;
        std::list<std::pair<std::shared_ptr<asio::streambuf>, std::function<void(const error_code &)>>> send_queue GUARDED_BY(send_queue_mutex);

        Response(std::shared_ptr<Session> session_, long timeout_content) noexcept : std::ostream(nullptr), session(std::move(session_)), timeout_content(timeout_content)
        {
            rdbuf(streambuf.get());
        }

        template <typename size_type>
        void write_header(const CaseInsensitiveMultimap &header, size_type size)
        {
            bool content_length_written = false;
            bool chunked_transfer_encoding = false;
            for(auto &field : header) {
                if(!content_length_written && case_insensitive_equal(field.first, "content-length"))
                    content_length_written = true;
                else if(!chunked_transfer_encoding && case_insensitive_equal(field.first, "transfer-encoding") && case_insensitive_equal(field.second, "chunked"))
                    chunked_transfer_encoding = true;

                *this << field.first << ": " << field.second << "\r\n";
            }
            if(!content_length_written && !chunked_transfer_encoding && !close_connection_after_response)
                *this << "Content-Length: " << size << "\r\n\r\n";
            else
                *this << "\r\n";
        }

        void send_from_queue() REQUIRES(send_queue_mutex)
        {
            auto self = this->shared_from_this();
            asio::async_write(*self->session->connection->socket, *send_queue.begin()->first, [self](const error_code &ec, std::size_t /*bytes_transferred*/) {
                auto lock = self->session->connection->handler_runner->continue_lock();
                if(!lock)
                    return;
                {
                    LockGuard lock(self->send_queue_mutex);
                    if(!ec) {
                        auto it = self->send_queue.begin();
                        auto callback = std::move(it->second);
                        self->send_queue.erase(it);
                        if(self->send_queue.size() > 0)
                            self->send_from_queue();

                        lock.unlock();
                        if(callback)
                            callback(ec);
                    }
                    else {
                        // All handlers in the queue is called with ec:
                        std::vector<std::function<void(const error_code &)>> callbacks;
                        for(auto &pair : self->send_queue) {
                            if(pair.second)
                                callbacks.emplace_back(std::move(pair.second));
                        }
                        self->send_queue.clear();

                        lock.unlock();
                        for(auto &callback : callbacks)
                            callback(ec);
                    }
                }
            });
        }

        void send_on_delete(const std::function<void(const error_code &)> &callback = nullptr) noexcept
        {
            session->connection->set_timeout(timeout_content);
            auto self = this->shared_from_this(); // Keep Response instance alive through the following async_write
            asio::async_write(*session->connection->socket, *streambuf, [self, callback](const error_code &ec, std::size_t /*bytes_transferred*/) {
                self->session->connection->cancel_timeout();
                auto lock = self->session->connection->handler_runner->continue_lock();
                if(!lock)
                    return;
                if(callback)
                    callback(ec);
            });
        }

    public:
        std::size_t size() noexcept
        {
            return streambuf->size();
        }

        void send(const std::function<void(const error_code &)> &callback = nullptr) noexcept
        {
            session->connection->set_timeout(timeout_content);

            std::shared_ptr<asio::streambuf> streambuf = std::move(this->streambuf);
            this->streambuf = std::unique_ptr<asio::streambuf>(new asio::streambuf());
            rdbuf(this->streambuf.get());

            LockGuard lock(send_queue_mutex);
            send_queue.emplace_back(streambuf, callback);
            if(send_queue.size() == 1)
                send_from_queue();
        }

        void write(const char_type *ptr, std::streamsize n)
        {
            std::ostream::write(ptr, n);
        }

        void write(StatusCode status_code = StatusCode::success_ok, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap())
        {
            *this << "HTTP/1.1 " << identt::http::status_code(status_code) << "\r\n";
            write_header(header, 0);
        }

        void write(StatusCode status_code, string_view content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap())
        {
            *this << "HTTP/1.1 " << identt::http::status_code(status_code) << "\r\n";
            write_header(header, content.size());
            if(!content.empty())
                *this << content;
        }

        void write(StatusCode status_code, std::istream &content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap())
        {
            *this << "HTTP/1.1 " << identt::http::status_code(status_code) << "\r\n";
            content.seekg(0, std::ios::end);
            auto size = content.tellg();
            content.seekg(0, std::ios::beg);
            write_header(header, size);
            if(size)
                *this << content.rdbuf();
        }

        void write(string_view content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap())
        {
            write(StatusCode::success_ok, content, header);
        }

        void write(std::istream &content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap())
        {
            write(StatusCode::success_ok, content, header);
        }

        void write(const CaseInsensitiveMultimap &header)
        {
            write(StatusCode::success_ok, std::string(), header);
        }

        bool close_connection_after_response = false;
    };

    class Content : public std::istream {
        friend class HttpServerBase<socket_type>;

    public:
        std::size_t size() noexcept
        {
            return streambuf.size();
        }
        std::string string() noexcept
        {
            try {
                std::string str;
                auto size = streambuf.size();
                str.resize(size);
                read(&str[0], static_cast<std::streamsize>(size));
                return str;
            }
            catch(...) {
                return std::string();
            }
        }

    private:
        asio::streambuf &streambuf;
        Content(asio::streambuf &streambuf) noexcept : std::istream(&streambuf), streambuf(streambuf) {}
    };

    class Request {
        friend class HttpServerBase<socket_type>;
        friend class HttpServer<socket_type>;
        friend class Session;

        asio::streambuf streambuf;
        std::weak_ptr<Connection> connection;
        std::string optimization = std::to_string(0); // TODO: figure out what goes wrong in gcc optimization without this line

        Request(std::size_t max_request_streambuf_size, const std::shared_ptr<Connection> &connection_) noexcept : streambuf(max_request_streambuf_size), connection(connection_), content(streambuf) {}

    public:
        std::string method, path, query_string, http_version;

        Content content;

        CaseInsensitiveMultimap header;

        std::smatch path_match;

        std::chrono::system_clock::time_point header_read_time;

        asio::ip::tcp::endpoint remote_endpoint() const noexcept
        {
            try {
                if(auto connection = this->connection.lock())
                    return connection->socket->lowest_layer().remote_endpoint();
            }
            catch(...) {
            }
            return asio::ip::tcp::endpoint();
        }

        DEPRECATED std::string remote_endpoint_address() const noexcept
        {
            try {
                if(auto connection = this->connection.lock())
                    return connection->socket->lowest_layer().remote_endpoint().address().to_string();
            }
            catch(...) {
            }
            return std::string();
        }

        DEPRECATED unsigned short remote_endpoint_port() const noexcept
        {
            try {
                if(auto connection = this->connection.lock())
                    return connection->socket->lowest_layer().remote_endpoint().port();
            }
            catch(...) {
            }
            return 0;
        }

        CaseInsensitiveMultimap parse_query_string() const noexcept
        {
            return identt::http::QueryString::parse(query_string);
        }
    };

public:
    using RespPtr = std::shared_ptr<Response>;
    using ReqPtr = std::shared_ptr<Request>;

protected:
    class Connection : public std::enable_shared_from_this<Connection> {
    public:
        template <typename... Args>
        Connection(std::shared_ptr<ScopeRunner> handler_runner_, Args &&... args) noexcept : handler_runner(std::move(handler_runner_)), socket(new socket_type(std::forward<Args>(args)...)) {}

        std::shared_ptr<ScopeRunner> handler_runner;

        std::unique_ptr<socket_type> socket; // Socket must be unique_ptr since asio::ssl::stream<asio::ip::tcp::socket> is not movable

        std::unique_ptr<asio::steady_timer> timer;

        void close() noexcept
        {
            error_code ec;
            socket->lowest_layer().shutdown(asio::ip::tcp::socket::shutdown_both, ec);
            socket->lowest_layer().cancel(ec);
        }

        void set_timeout(long seconds) noexcept
        {
            if(seconds == 0) {
                timer = nullptr;
                return;
            }

            timer = std::unique_ptr<asio::steady_timer>(new asio::steady_timer(get_socket_executor(*socket), std::chrono::seconds(seconds)));
            std::weak_ptr<Connection> self_weak(this->shared_from_this()); // To avoid keeping Connection instance alive longer than needed
            timer->async_wait([self_weak](const error_code &ec) {
                if(!ec) {
                    if(auto self = self_weak.lock())
                        self->close();
                }
            });
        }

        void cancel_timeout() noexcept
        {
            if(timer) {
                try {
                    timer->cancel();
                }
                catch(...) {
                }
            }
        }
    };

    class Session {
    public:
        Session(std::size_t max_request_streambuf_size, std::shared_ptr<Connection> connection_) noexcept : connection(std::move(connection_)), request(new Request(max_request_streambuf_size, connection)) {}

        std::shared_ptr<Connection> connection;
        std::shared_ptr<Request> request;
    };

public:
    class Config {
        friend class HttpServerBase<socket_type>;

        Config(unsigned short port) noexcept : port(port) {}

    public:
        unsigned short port;
        long timeout_request = 5;
        long timeout_content = 300;
        std::size_t max_request_streambuf_size = std::numeric_limits<std::size_t>::max();
        std::string address;
        bool reuse_address = true;
        bool fast_open = false;
    };
    Config config;

private:
    class regex_orderable : public std::regex {
    public:
        std::string str;

        regex_orderable(const char *regex_cstr) : std::regex(regex_cstr), str(regex_cstr) {}
        regex_orderable(std::string regex_str_) : std::regex(regex_str_), str(std::move(regex_str_)) {}
        bool operator<(const regex_orderable &rhs) const noexcept
        {
            return str < rhs.str;
        }
    };

public:
    std::map<regex_orderable, std::map<std::string, std::function<void(std::shared_ptr<typename HttpServerBase<socket_type>::Response>, std::shared_ptr<typename HttpServerBase<socket_type>::Request>)>>> resource;

    std::map<std::string, std::function<void(std::shared_ptr<typename HttpServerBase<socket_type>::Response>, std::shared_ptr<typename HttpServerBase<socket_type>::Request>)>> default_resource;

    std::function<void(std::shared_ptr<typename HttpServerBase<socket_type>::Request>, const error_code &)> on_error;

    std::function<void(std::unique_ptr<socket_type> &, std::shared_ptr<typename HttpServerBase<socket_type>::Request>)> on_upgrade;

    std::shared_ptr<::identt::http::io_whatever> io_whatever;

    unsigned short bind()
    {
        std::lock_guard<std::mutex> lock(start_stop_mutex);

        asio::ip::tcp::endpoint endpoint;
        if(config.address.size() > 0)
            endpoint = asio::ip::tcp::endpoint(make_address(config.address), config.port);
        else
            endpoint = asio::ip::tcp::endpoint(asio::ip::tcp::v6(), config.port);

        if(!acceptor)
            acceptor = std::unique_ptr<asio::ip::tcp::acceptor>(new asio::ip::tcp::acceptor(*io_whatever));
        acceptor->open(endpoint.protocol());
        acceptor->set_option(asio::socket_base::reuse_address(config.reuse_address));
        if(config.fast_open) {
#if defined(__linux__) && defined(TCP_FASTOPEN)
            const int qlen = 5; // This seems to be the value that is used in other examples.
            error_code ec;
            acceptor->set_option(asio::detail::socket_option::integer<IPPROTO_TCP, TCP_FASTOPEN>(qlen), ec);
#endif // End Linux
        }
        acceptor->bind(endpoint);

        after_bind();

        return acceptor->local_endpoint().port();
    }

    void accept_and_run()
    {
        acceptor->listen();
        accept();
    }

    void start()
    {
        bind();
        accept_and_run();
    }

    void stop() noexcept
    {
        std::lock_guard<std::mutex> lock(start_stop_mutex);

        if(acceptor) {
            error_code ec;
            acceptor->close(ec);

            {
                LockGuard lock(connections->mutex);
                for(auto &connection : connections->set)
                    connection->close();
                connections->set.clear();
            }

        }
    }

    virtual ~HttpServerBase() noexcept
    {
        handler_runner->stop();
        stop();
    }

protected:
    std::mutex start_stop_mutex;

    std::unique_ptr<asio::ip::tcp::acceptor> acceptor;

    struct Connections {
        Mutex mutex;
        std::unordered_set<Connection *> set GUARDED_BY(mutex);
    };
    std::shared_ptr<Connections> connections;

    std::shared_ptr<ScopeRunner> handler_runner;

    HttpServerBase(unsigned short port) noexcept : config(port), connections(new Connections()), handler_runner(new ScopeRunner()) {}

    virtual void after_bind() {}
    virtual void accept() = 0;

    template <typename... Args>
    std::shared_ptr<Connection> create_connection(Args &&... args) noexcept
    {
        auto connections = this->connections;
        auto connection = std::shared_ptr<Connection>(new Connection(handler_runner, std::forward<Args>(args)...), [connections](Connection *connection) {
            {
                LockGuard lock(connections->mutex);
                auto it = connections->set.find(connection);
                if(it != connections->set.end())
                    connections->set.erase(it);
            }
            delete connection;
        });
        {
            LockGuard lock(connections->mutex);
            connections->set.emplace(connection.get());
        }
        return connection;
    }

    void read(const std::shared_ptr<Session> &session)
    {
        session->connection->set_timeout(config.timeout_request);
        asio::async_read_until(*session->connection->socket, session->request->streambuf, "\r\n\r\n", [this, session](const error_code &ec, std::size_t bytes_transferred) {
            session->connection->cancel_timeout();
            auto lock = session->connection->handler_runner->continue_lock();
            if(!lock)
                return;
            session->request->header_read_time = std::chrono::system_clock::now();
            if(session->request->streambuf.size() == session->request->streambuf.max_size()) {
                auto response = std::shared_ptr<Response>(new Response(session, this->config.timeout_content));
                response->write(StatusCode::client_error_payload_too_large);
                if(this->on_error)
                    this->on_error(session->request, make_error_code::make_error_code(errc::message_size));
                return;
            }

            if(!ec) {
                // request->streambuf.size() is not necessarily the same as bytes_transferred, from Boost-docs:
                // "After a successful async_read_until operation, the streambuf may contain additional data beyond the delimiter"
                // The chosen solution is to extract lines from the stream directly when parsing the header. What is left of the
                // streambuf (maybe some bytes of the content) is appended to in the async_read-function below (for retrieving content).
                std::size_t num_additional_bytes = session->request->streambuf.size() - bytes_transferred;

                if(!RequestMessage::parse(session->request->content, session->request->method, session->request->path,
                                          session->request->query_string, session->request->http_version, session->request->header)) {
                    if(this->on_error)
                        this->on_error(session->request, make_error_code::make_error_code(errc::protocol_error));
                    return;
                }

                // If content, read that as well
                auto header_it = session->request->header.find("Content-Length");
                if(header_it != session->request->header.end()) {
                    unsigned long long content_length = 0;
                    try {
                        content_length = stoull(header_it->second);
                    }
                    catch(const std::exception &) {
                        if(this->on_error)
                            this->on_error(session->request, make_error_code::make_error_code(errc::protocol_error));
                        return;
                    }
                    if(content_length > num_additional_bytes) {
                        session->connection->set_timeout(config.timeout_content);
                        asio::async_read(*session->connection->socket, session->request->streambuf, asio::transfer_exactly(content_length - num_additional_bytes), [this, session](const error_code &ec, std::size_t /*bytes_transferred*/) {
                            session->connection->cancel_timeout();
                            auto lock = session->connection->handler_runner->continue_lock();
                            if(!lock)
                                return;
                            if(session->request->streambuf.size() == session->request->streambuf.max_size()) {
                                auto response = std::shared_ptr<Response>(new Response(session, this->config.timeout_content));
                                response->write(StatusCode::client_error_payload_too_large);
                                if(this->on_error)
                                    this->on_error(session->request, make_error_code::make_error_code(errc::message_size));
                                return;
                            }

                            if(!ec)
                                this->find_resource(session);
                            else if(this->on_error)
                                this->on_error(session->request, ec);
                        });
                    }
                    else
                        this->find_resource(session);
                }
                else if((header_it = session->request->header.find("Transfer-Encoding")) != session->request->header.end() && header_it->second == "chunked") {
                    auto chunks_streambuf = std::make_shared<asio::streambuf>(this->config.max_request_streambuf_size);

                    // Copy leftover bytes
                    std::ostream ostream(chunks_streambuf.get());
                    auto size = session->request->streambuf.size();
                    std::unique_ptr<char[]> buffer(new char[size]);
                    session->request->content.read(buffer.get(), static_cast<std::streamsize>(size));
                    ostream.write(buffer.get(), static_cast<std::streamsize>(size));

                    this->read_chunked_transfer_encoded(session, chunks_streambuf);
                }
                else
                    this->find_resource(session);
            }
            else if(this->on_error)
                this->on_error(session->request, ec);
        });
    }

    void read_chunked_transfer_encoded(const std::shared_ptr<Session> &session, const std::shared_ptr<asio::streambuf> &chunks_streambuf)
    {
        session->connection->set_timeout(config.timeout_content);
        asio::async_read_until(*session->connection->socket, *chunks_streambuf, "\r\n", [this, session, chunks_streambuf](const error_code &ec, size_t bytes_transferred) {
            session->connection->cancel_timeout();
            auto lock = session->connection->handler_runner->continue_lock();
            if(!lock)
                return;
            if(chunks_streambuf->size() == chunks_streambuf->max_size()) {
                auto response = std::shared_ptr<Response>(new Response(session, this->config.timeout_content));
                response->write(StatusCode::client_error_payload_too_large);
                if(this->on_error)
                    this->on_error(session->request, make_error_code::make_error_code(errc::message_size));
                return;
            }

            if(!ec) {
                std::istream istream(chunks_streambuf.get());
                std::string line;
                getline(istream, line);
                bytes_transferred -= line.size() + 1;
                line.pop_back();
                unsigned long length = 0;
                try {
                    length = stoul(line, 0, 16);
                }
                catch(...) {
                    if(this->on_error)
                        this->on_error(session->request, make_error_code::make_error_code(errc::protocol_error));
                    return;
                }

                auto num_additional_bytes = chunks_streambuf->size() - bytes_transferred;

                if((2 + length) > num_additional_bytes) {
                    session->connection->set_timeout(config.timeout_content);
                    asio::async_read(*session->connection->socket, *chunks_streambuf, asio::transfer_exactly(2 + length - num_additional_bytes), [this, session, chunks_streambuf, length](const error_code &ec, size_t /*bytes_transferred*/) {
                        session->connection->cancel_timeout();
                        auto lock = session->connection->handler_runner->continue_lock();
                        if(!lock)
                            return;
                        if(chunks_streambuf->size() == chunks_streambuf->max_size()) {
                            auto response = std::shared_ptr<Response>(new Response(session, this->config.timeout_content));
                            response->write(StatusCode::client_error_payload_too_large);
                            if(this->on_error)
                                this->on_error(session->request, make_error_code::make_error_code(errc::message_size));
                            return;
                        }

                        if(!ec)
                            this->read_chunked_transfer_encoded_chunk(session, chunks_streambuf, length);
                        else if(this->on_error)
                            this->on_error(session->request, ec);
                    });
                }
                else
                    this->read_chunked_transfer_encoded_chunk(session, chunks_streambuf, length);
            }
            else if(this->on_error)
                this->on_error(session->request, ec);
        });
    }

    void read_chunked_transfer_encoded_chunk(const std::shared_ptr<Session> &session, const std::shared_ptr<asio::streambuf> &chunks_streambuf, unsigned long length)
    {
        std::istream istream(chunks_streambuf.get());
        if(length > 0) {
            std::ostream ostream(&session->request->streambuf);
            std::unique_ptr<char[]> buffer(new char[length]);
            istream.read(buffer.get(), static_cast<std::streamsize>(length));
            ostream.write(buffer.get(), static_cast<std::streamsize>(length));
            if(session->request->streambuf.size() == session->request->streambuf.max_size()) {
                auto response = std::shared_ptr<Response>(new Response(session, this->config.timeout_content));
                response->write(StatusCode::client_error_payload_too_large);
                if(this->on_error)
                    this->on_error(session->request, make_error_code::make_error_code(errc::message_size));
                return;
            }
        }

        // Remove "\r\n"
        istream.get();
        istream.get();

        if(length > 0)
            read_chunked_transfer_encoded(session, chunks_streambuf);
        else
            this->find_resource(session);
    }

    void find_resource(const std::shared_ptr<Session> &session)
    {
        // Upgrade connection
        if(on_upgrade) {
            auto it = session->request->header.find("Upgrade");
            if(it != session->request->header.end()) {
                // remove connection from connections
                {
                    LockGuard lock(connections->mutex);
                    auto it = connections->set.find(session->connection.get());
                    if(it != connections->set.end())
                        connections->set.erase(it);
                }

                on_upgrade(session->connection->socket, session->request);
                return;
            }
        }
        // Find path- and method-match, and call write
        for(auto &regex_method : resource) {
            auto it = regex_method.second.find(session->request->method);
            if(it != regex_method.second.end()) {
                std::smatch sm_res;
                if(std::regex_match(session->request->path, sm_res, regex_method.first)) {
                    session->request->path_match = std::move(sm_res);
                    write(session, it->second);
                    return;
                }
            }
        }
        auto it = default_resource.find(session->request->method);
        if(it != default_resource.end())
            write(session, it->second);
    }

    void write(const std::shared_ptr<Session> &session,
               std::function<void(std::shared_ptr<typename HttpServerBase<socket_type>::Response>, std::shared_ptr<typename HttpServerBase<socket_type>::Request>)> &resource_function)
    {
        session->connection->set_timeout(config.timeout_content);
        auto response = std::shared_ptr<Response>(new Response(session, config.timeout_content), [this](Response *response_ptr) {
            auto response = std::shared_ptr<Response>(response_ptr);
            response->send_on_delete([this, response](const error_code &ec) {
                if(!ec) {
                    if(response->close_connection_after_response)
                        return;

                    auto range = response->session->request->header.equal_range("Connection");
                    for(auto it = range.first; it != range.second; it++) {
                        if(case_insensitive_equal(it->second, "close"))
                            return;
                        else if(case_insensitive_equal(it->second, "keep-alive")) {
                            auto new_session = std::make_shared<Session>(this->config.max_request_streambuf_size, response->session->connection);
                            this->read(new_session);
                            return;
                        }
                    }
                    if(response->session->request->http_version >= "1.1") {
                        auto new_session = std::make_shared<Session>(this->config.max_request_streambuf_size, response->session->connection);
                        this->read(new_session);
                        return;
                    }
                }
                else if(this->on_error)
                    this->on_error(response->session->request, ec);
            });
        });

        try {
            resource_function(response, session->request);
        }
        catch(const std::exception &) {
            if(on_error)
                on_error(session->request, make_error_code::make_error_code(errc::operation_canceled));
            return;
        }
    }
};

} // namespace http
} // namespace identt

#endif // _IDENTT_HTTP_SERVER_BASE_HPP_