SslWsSession.hpp

#pragma once
 
#include "util/Taggable.hpp"
#include "web/dosguard/DOSGuardInterface.hpp"
#include "web/impl/WsBase.hpp"
#include "web/interface/ConnectionBase.hpp"
 
#include <boost/beast/core/flat_buffer.hpp>
#include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/core/tcp_stream.hpp>
#include <boost/beast/http/message.hpp>
#include <boost/beast/http/parser.hpp>
#include <boost/beast/http/string_body.hpp>
#include <boost/beast/ssl.hpp>
#include <boost/beast/ssl/ssl_stream.hpp>
#include <boost/beast/websocket/stream.hpp>
#include <boost/optional/optional.hpp>
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <utility>
 
namespace web {

template <SomeServerHandler HandlerType>
class SslWsSession : public impl::WsBase<SslWsSession, HandlerType> {
    using StreamType =
        boost::beast::websocket::stream<boost::asio::ssl::stream<boost::beast::tcp_stream>>;
    StreamType ws_;
 
public:
    explicit SslWsSession(
        boost::asio::ssl::stream<boost::beast::tcp_stream>&& stream,
        std::string ip,
        std::reference_wrapper<util::TagDecoratorFactory const> tagFactory,
        std::reference_wrapper<dosguard::DOSGuardInterface> dosGuard,
        std::shared_ptr<HandlerType> const& handler,
        boost::beast::flat_buffer&& buffer,
        bool isAdmin,
        std::uint32_t maxWsSendingQueueSize
    )
        : impl::WsBase<SslWsSession, HandlerType>(
              ip,
              tagFactory,
              dosGuard,
              handler,
              std::move(buffer),
              maxWsSendingQueueSize
          )
        , ws_(std::move(stream))
    {
        ConnectionBase::isAdmin_ = isAdmin;  // NOLINT(cppcoreguidelines-prefer-member-initializer)
    }

    StreamType&
    ws()
    {
        return ws_;
    }
};

template <SomeServerHandler HandlerType>
class SslWsUpgrader : public std::enable_shared_from_this<SslWsUpgrader<HandlerType>> {
    using std::enable_shared_from_this<SslWsUpgrader<HandlerType>>::shared_from_this;
 
    boost::asio::ssl::stream<boost::beast::tcp_stream> https_;
    boost::optional<http::request_parser<http::string_body>> parser_;
    boost::beast::flat_buffer buffer_;
    std::string ip_;
    std::reference_wrapper<util::TagDecoratorFactory const> tagFactory_;
    std::reference_wrapper<dosguard::DOSGuardInterface> dosGuard_;
    std::shared_ptr<HandlerType> const handler_;
    http::request<http::string_body> req_;
    bool isAdmin_;
    std::uint32_t maxWsSendingQueueSize_;
 
public:
    SslWsUpgrader(
        boost::asio::ssl::stream<boost::beast::tcp_stream> stream,
        std::string ip,
        std::reference_wrapper<util::TagDecoratorFactory const> tagFactory,
        std::reference_wrapper<dosguard::DOSGuardInterface> dosGuard,
        std::shared_ptr<HandlerType> handler,
        boost::beast::flat_buffer&& buffer,
        http::request<http::string_body> request,
        bool isAdmin,
        std::uint32_t maxWsSendingQueueSize
    )
        : https_(std::move(stream))
        , buffer_(std::move(buffer))
        , ip_(std::move(ip))
        , tagFactory_(tagFactory)
        , dosGuard_(dosGuard)
        , handler_(std::move(handler))
        , req_(std::move(request))
        , isAdmin_(isAdmin)
        , maxWsSendingQueueSize_(maxWsSendingQueueSize)
    {
    }
 
    ~SslWsUpgrader() = default;

    void
    run()
    {
        boost::beast::get_lowest_layer(https_).expires_after(std::chrono::seconds(30));
 
        boost::asio::dispatch(
            https_.get_executor(),
            boost::beast::bind_front_handler(
                &SslWsUpgrader<HandlerType>::doUpgrade, shared_from_this()
            )
        );
    }
 
private:
    void
    doUpgrade()
    {
        parser_.emplace();
 
        // Apply a reasonable limit to the allowed size of the body in bytes to prevent abuse.
        static constexpr auto kMaxBodySize = 10000;
        parser_->body_limit(kMaxBodySize);
 
        boost::beast::get_lowest_layer(https_).expires_after(std::chrono::seconds(30));
        onUpgrade();
    }
 
    void
    onUpgrade()
    {
        if (!boost::beast::websocket::is_upgrade(req_))
            return;
 
        // Disable the timeout. The websocket::stream uses its own timeout settings.
        boost::beast::get_lowest_layer(https_).expires_never();
 
        std::make_shared<SslWsSession<HandlerType>>(
            std::move(https_),
            ip_,
            tagFactory_,
            dosGuard_,
            handler_,
            std::move(buffer_),
            isAdmin_,
            maxWsSendingQueueSize_
        )
            ->run(std::move(req_));
    }
};
}  // namespace web