unified_udp_messaging_server.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 <array>
#include <atomic>
#include <concepts>
#include <functional>
#include <future>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <unordered_map>
#include <vector>
 
#include <asio.hpp>
 
#include "internal/core/callback_indices.h"
#include "internal/interfaces/i_udp_server.h"
#include "kcenon/network/integration/thread_integration.h"
#include "kcenon/network/policy/tls_policy.h"
#include "kcenon/network/detail/protocol/protocol_tags.h"
#include "kcenon/network/detail/utils/callback_manager.h"
#include "kcenon/network/detail/utils/lifecycle_manager.h"
#include "kcenon/network/detail/utils/result_types.h"
 
#ifdef BUILD_TLS_SUPPORT
#include <openssl/ssl.h>
#endif
 
namespace kcenon::network::internal
{
class udp_socket;
#ifdef BUILD_TLS_SUPPORT
class dtls_socket;
#endif
}  // namespace kcenon::network::internal
 
namespace kcenon::network::core
{
 
template <policy::TlsPolicy TlsPolicy = policy::no_tls>
class unified_udp_messaging_server
    : public std::enable_shared_from_this<unified_udp_messaging_server<TlsPolicy>>
    , public interfaces::i_udp_server
{
public:
    static constexpr bool is_secure = policy::is_tls_enabled_v<TlsPolicy>;
 
    using receive_callback_t =
        std::function<void(const std::vector<uint8_t>&, const asio::ip::udp::endpoint&)>;
    using client_connected_callback_t = std::function<void(const asio::ip::udp::endpoint&)>;
    using client_disconnected_callback_t = std::function<void(const asio::ip::udp::endpoint&)>;
    using error_callback_t = std::function<void(std::error_code)>;
 
    explicit unified_udp_messaging_server(std::string_view server_id)
        requires(!policy::is_tls_enabled_v<TlsPolicy>);
 
    unified_udp_messaging_server(std::string_view server_id, const TlsPolicy& tls_config)
        requires policy::is_tls_enabled_v<TlsPolicy>;
 
    ~unified_udp_messaging_server() noexcept override;
 
    // Non-copyable, non-movable
    unified_udp_messaging_server(const unified_udp_messaging_server&) = delete;
    unified_udp_messaging_server& operator=(const unified_udp_messaging_server&) = delete;
    unified_udp_messaging_server(unified_udp_messaging_server&&) = delete;
    unified_udp_messaging_server& operator=(unified_udp_messaging_server&&) = delete;
 
    // =====================================================================
    // Lifecycle Management
    // =====================================================================
 
    [[nodiscard]] auto start_server(uint16_t port) -> VoidResult;
 
    [[nodiscard]] auto stop_server() -> VoidResult;
 
    [[nodiscard]] auto server_id() const -> const std::string&;
 
    // =====================================================================
    // i_network_component interface implementation
    // =====================================================================
 
    [[nodiscard]] auto is_running() const -> bool override;
 
    auto wait_for_stop() -> void override;
 
    // =====================================================================
    // i_udp_server interface implementation
    // =====================================================================
 
    [[nodiscard]] auto start(uint16_t port) -> VoidResult override;
    [[nodiscard]] auto stop() -> VoidResult override;
    [[nodiscard]] auto send_to(const interfaces::i_udp_server::endpoint_info& endpoint,
                               std::vector<uint8_t>&& data,
                               interfaces::i_udp_server::send_callback_t handler = nullptr)
        -> VoidResult override;
    auto set_receive_callback(interfaces::i_udp_server::receive_callback_t callback)
        -> void override;
    auto set_error_callback(error_callback_t callback) -> void override;
 
    // =====================================================================
    // Extended API (not in interface)
    // =====================================================================
 
    auto set_receive_callback(receive_callback_t callback) -> void;
 
    auto set_client_connected_callback(client_connected_callback_t callback) -> void;
 
    auto set_client_disconnected_callback(client_disconnected_callback_t callback) -> void;
 
    auto async_send_to(std::vector<uint8_t>&& data,
                       const asio::ip::udp::endpoint& endpoint,
                       std::function<void(std::error_code, std::size_t)> handler = nullptr)
        -> void;
 
private:
#ifdef BUILD_TLS_SUPPORT
    struct dtls_session
    {
        std::shared_ptr<internal::dtls_socket> socket;
        bool handshake_complete{false};
    };
 
    struct endpoint_hash
    {
        std::size_t operator()(const asio::ip::udp::endpoint& ep) const
        {
            auto addr_hash = std::hash<std::string>{}(ep.address().to_string());
            auto port_hash = std::hash<unsigned short>{}(ep.port());
            return addr_hash ^ (port_hash << 1);
        }
    };
#endif
 
    // =====================================================================
    // Internal Implementation Methods
    // =====================================================================
 
    auto do_start_impl(uint16_t port) -> VoidResult;
    auto do_stop_impl() -> VoidResult;
 
#ifdef BUILD_TLS_SUPPORT
    auto init_ssl_context() -> VoidResult
        requires is_secure;
    auto do_receive() -> void
        requires is_secure;
    auto process_session_data(const std::vector<uint8_t>& data,
                              const asio::ip::udp::endpoint& sender) -> void
        requires is_secure;
    auto create_session(const asio::ip::udp::endpoint& client_endpoint)
        -> std::shared_ptr<dtls_session>
        requires is_secure;
#endif
 
    // =====================================================================
    // Internal Callback Helpers
    // =====================================================================
 
    auto invoke_receive_callback(const std::vector<uint8_t>& data,
                                 const asio::ip::udp::endpoint& endpoint) -> void;
    auto invoke_error_callback(std::error_code ec) -> void;
 
    [[nodiscard]] auto get_receive_callback() const -> receive_callback_t;
    [[nodiscard]] auto get_error_callback() const -> error_callback_t;
 
private:
    using callback_index = unified_udp_server_callback;
 
    using callbacks_t = utils::callback_manager<receive_callback_t,
                                                client_connected_callback_t,
                                                client_disconnected_callback_t,
                                                error_callback_t>;
 
    // =====================================================================
    // Member Variables
    // =====================================================================
 
    std::string server_id_;               
    utils::lifecycle_manager lifecycle_;  
    callbacks_t callbacks_;               
    std::unique_ptr<asio::io_context> io_context_;  
    // Plain UDP mode uses udp_socket
    std::shared_ptr<internal::udp_socket> socket_;  
    std::shared_ptr<integration::thread_pool_interface> thread_pool_;
    std::future<void> io_context_future_;  
#ifdef BUILD_TLS_SUPPORT
    // DTLS mode uses raw socket + session management
    std::unique_ptr<asio::ip::udp::socket> dtls_socket_;  
    SSL_CTX* ssl_ctx_{nullptr};                           
    [[no_unique_address]] TlsPolicy tls_config_;          
    std::array<uint8_t, 65536> read_buffer_;           
    asio::ip::udp::endpoint sender_endpoint_;          
    std::mutex sessions_mutex_;                        
    std::unordered_map<asio::ip::udp::endpoint,
                       std::shared_ptr<dtls_session>,
                       endpoint_hash>
        sessions_;  
#endif
};
 
// =====================================================================
// Type Aliases for Convenience
// =====================================================================
 
using udp_server = unified_udp_messaging_server<policy::no_tls>;
 
#ifdef BUILD_TLS_SUPPORT
using secure_udp_server = unified_udp_messaging_server<policy::tls_enabled>;
#endif
 
}  // namespace kcenon::network::core
 
// Include template implementation
#include "unified_udp_messaging_server.inl"