secure_messaging_udp_client.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 <functional>
#include <future>
#include <memory>
#include <mutex>
#include <string>
#include <string_view>
#include <vector>
 
#include <asio.hpp>
#include <openssl/ssl.h>
 
#include "internal/core/callback_indices.h"
#include "kcenon/network/integration/thread_integration.h"
#include "kcenon/network/detail/utils/lifecycle_manager.h"
#include "kcenon/network/detail/utils/callback_manager.h"
#include "kcenon/network/detail/utils/result_types.h"
 
namespace kcenon::network::internal
{
    class dtls_socket;
}
 
namespace kcenon::network::core
{
    class secure_messaging_udp_client
        : public std::enable_shared_from_this<secure_messaging_udp_client>
    {
    public:
        using receive_callback_t = std::function<void(const std::vector<uint8_t>&)>;
        using connected_callback_t = std::function<void()>;
        using disconnected_callback_t = std::function<void()>;
        using error_callback_t = std::function<void(std::error_code)>;
 
        using udp_receive_callback_t = std::function<void(const std::vector<uint8_t>&,
                                                           const asio::ip::udp::endpoint&)>;
 
        secure_messaging_udp_client(std::string_view client_id, bool verify_cert = true);
 
        ~secure_messaging_udp_client() noexcept;
 
        // Non-copyable, non-movable
        secure_messaging_udp_client(const secure_messaging_udp_client&) = delete;
        secure_messaging_udp_client& operator=(const secure_messaging_udp_client&) = delete;
        secure_messaging_udp_client(secure_messaging_udp_client&&) = delete;
        secure_messaging_udp_client& operator=(secure_messaging_udp_client&&) = delete;
 
        // =====================================================================
        // Lifecycle Management
        // =====================================================================
 
        [[nodiscard]] auto start_client(std::string_view host, unsigned short port) -> VoidResult;
 
        [[nodiscard]] auto stop_client() -> VoidResult;
 
        auto wait_for_stop() -> void;
 
        [[nodiscard]] auto is_running() const noexcept -> bool;
 
        [[nodiscard]] auto is_connected() const noexcept -> bool;
 
        [[nodiscard]] auto client_id() const -> const std::string&;
 
        // =====================================================================
        // Data Transfer
        // =====================================================================
 
        [[nodiscard]] auto send_packet(std::vector<uint8_t>&& data) -> VoidResult;
 
        auto send_packet_with_handler(
            std::vector<uint8_t>&& data,
            std::function<void(std::error_code, std::size_t)> handler) -> VoidResult;
 
        // =====================================================================
        // Callback Setters
        // =====================================================================
 
        auto set_udp_receive_callback(udp_receive_callback_t callback) -> void;
 
        auto set_receive_callback(receive_callback_t callback) -> void;
 
        auto set_connected_callback(connected_callback_t callback) -> void;
 
        auto set_disconnected_callback(disconnected_callback_t callback) -> void;
 
        auto set_error_callback(error_callback_t callback) -> void;
 
    private:
        // =====================================================================
        // Internal Implementation Methods
        // =====================================================================
 
        auto do_start_impl(std::string_view host, unsigned short port) -> VoidResult;
 
        auto do_stop_impl() -> VoidResult;
 
        auto do_send_impl(std::vector<uint8_t>&& data) -> VoidResult;
 
        auto init_ssl_context() -> VoidResult;
 
        auto do_handshake() -> VoidResult;
 
        // =====================================================================
        // Internal Callback Helpers
        // =====================================================================
 
        auto set_connected(bool connected) -> void;
 
        auto invoke_receive_callback(const std::vector<uint8_t>& data) -> void;
 
        auto invoke_connected_callback() -> void;
 
        auto invoke_disconnected_callback() -> void;
 
        auto invoke_error_callback(std::error_code ec) -> void;
 
    private:
        using callback_index = secure_udp_client_callback;
 
        using callbacks_t = utils::callback_manager<
            receive_callback_t,
            connected_callback_t,
            disconnected_callback_t,
            error_callback_t
        >;
 
        // =====================================================================
        // Member Variables
        // =====================================================================
 
        std::string client_id_;              
        utils::lifecycle_manager lifecycle_; 
        callbacks_t callbacks_;              
        std::atomic<bool> is_connected_{false}; 
        bool verify_cert_{true};                         
        std::unique_ptr<asio::io_context> io_context_;   
        std::shared_ptr<internal::dtls_socket> socket_;  
        SSL_CTX* ssl_ctx_{nullptr};                      
        std::shared_ptr<integration::thread_pool_interface> thread_pool_;
        std::future<void> io_context_future_;            
        std::mutex endpoint_mutex_;                      
        asio::ip::udp::endpoint target_endpoint_;        
        std::mutex udp_callback_mutex_;
        udp_receive_callback_t udp_receive_callback_;
    };
 
} // namespace kcenon::network::core