secure_tcp_socket.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
#ifndef KCENON_NETWORK_INTERNAL_TCP_SECURE_TCP_SOCKET_H_
#define KCENON_NETWORK_INTERNAL_TCP_SECURE_TCP_SOCKET_H_
 
#include <array>
#include <atomic>
#include <functional>
#include <memory>
#include <mutex>
#include <span>
#include <system_error>
#include <vector>
 
#include <asio.hpp>
#include <asio/ssl.hpp>
 
#include "internal/utils/common_defs.h"
 
namespace kcenon::network::internal
{
    class secure_tcp_socket : public std::enable_shared_from_this<secure_tcp_socket>
    {
    public:
        using ssl_socket = asio::ssl::stream<asio::ip::tcp::socket>;
 
        secure_tcp_socket(asio::ip::tcp::socket socket,
                          asio::ssl::context& ssl_context);
 
        ~secure_tcp_socket() = default;
 
        auto async_handshake(
            asio::ssl::stream_base::handshake_type type,
            std::function<void(std::error_code)> handler) -> void;
 
        auto set_receive_callback(
            std::function<void(const std::vector<uint8_t>&)> callback) -> void;
 
        auto set_receive_callback_view(
            std::function<void(std::span<const uint8_t>)> callback) -> void;
 
        auto set_error_callback(std::function<void(std::error_code)> callback)
            -> void;
 
        auto start_read() -> void;
 
        auto async_send(
            std::vector<uint8_t>&& data,
            std::function<void(std::error_code, std::size_t)> handler) -> void;
 
        auto stream() -> ssl_socket& { return ssl_stream_; }
 
        auto socket() -> ssl_socket::lowest_layer_type&
        {
            return ssl_stream_.lowest_layer();
        }
 
        auto stop_read() -> void;
 
        auto close() -> void;
 
        [[nodiscard]] auto is_closed() const -> bool;
 
    private:
        auto do_read() -> void;
 
    private:
        using receive_callback_t = std::function<void(const std::vector<uint8_t>&)>;
        using receive_callback_view_t = std::function<void(std::span<const uint8_t>)>;
        using error_callback_t = std::function<void(std::error_code)>;
 
        ssl_socket ssl_stream_; 
        std::array<uint8_t, 4096>
            read_buffer_; 
        std::shared_ptr<receive_callback_t> receive_callback_;
        std::shared_ptr<receive_callback_view_t> receive_callback_view_;
        std::shared_ptr<error_callback_t> error_callback_;
 
        std::mutex callback_mutex_; 
        std::atomic<bool> is_reading_{false}; 
        std::atomic<bool> is_closed_{false};  
    };
} // namespace kcenon::network::internal
 
#endif // KCENON_NETWORK_INTERNAL_TCP_SECURE_TCP_SOCKET_H_