secure_session.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <atomic>
#include <deque>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <string_view>
#include <vector>
 
#include <asio.hpp>
#include <asio/ssl.hpp>
 
#include "kcenon/network/internal/tcp/secure_tcp_socket.h"
 
namespace kcenon::network::session
{
 
    class secure_session
        : public std::enable_shared_from_this<secure_session>
    {
    public:
        secure_session(asio::ip::tcp::socket socket,
                       asio::ssl::context& ssl_context,
                       std::string_view server_id);
 
        ~secure_session() noexcept;
 
        auto start_session() -> void;
 
        auto stop_session() -> void;
 
        [[nodiscard]] auto is_stopped() const noexcept -> bool {
            return is_stopped_.load(std::memory_order_relaxed);
        }
 
        auto send_packet(std::vector<uint8_t>&& data) -> void;
 
        auto set_receive_callback(
            std::function<void(const std::vector<uint8_t>&)> callback) -> void;
 
        auto set_disconnection_callback(
            std::function<void(const std::string&)> callback) -> void;
 
        auto set_error_callback(
            std::function<void(std::error_code)> callback) -> void;
 
        [[nodiscard]] auto server_id() const -> const std::string& {
            return server_id_;
        }
 
    private:
        auto on_receive(const std::vector<uint8_t>& data) -> void;
 
        auto on_error(std::error_code ec) -> void;
 
        auto process_next_message() -> void;
 
    private:
        std::string server_id_; 
        std::shared_ptr<internal::secure_tcp_socket>
            socket_;            
        std::atomic<bool> is_stopped_{
            false
        }; 
        std::deque<std::vector<uint8_t>> pending_messages_;
 
        mutable std::mutex queue_mutex_;
 
        static constexpr size_t max_pending_messages_ = 1000;
 
        std::function<void(const std::vector<uint8_t>&)> receive_callback_;
        std::function<void(const std::string&)> disconnection_callback_;
        std::function<void(std::error_code)> error_callback_;
 
        mutable std::mutex callback_mutex_;
    };
 
} // namespace kcenon::network::session