secure_messaging_udp_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 <functional>
#include <future>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
#include <asio.hpp>
#include <openssl/ssl.h>
 
#include "kcenon/network/detail/utils/result_types.h"
#include "kcenon/network/integration/thread_integration.h"
 
namespace kcenon::network::internal
{
    class dtls_socket;
}
 
namespace kcenon::network::core
{
    class secure_messaging_udp_server : public std::enable_shared_from_this<secure_messaging_udp_server>
    {
    public:
        using udp_receive_callback_t = std::function<void(const std::vector<uint8_t>&,
                                                           const asio::ip::udp::endpoint&)>;
        using udp_client_callback_t = std::function<void(const asio::ip::udp::endpoint&)>;
 
        explicit secure_messaging_udp_server(std::string_view server_id);
 
        ~secure_messaging_udp_server() noexcept;
 
        // Non-copyable
        secure_messaging_udp_server(const secure_messaging_udp_server&) = delete;
        secure_messaging_udp_server& operator=(const secure_messaging_udp_server&) = delete;
 
        auto set_certificate_chain_file(const std::string& file_path) -> VoidResult;
 
        auto set_private_key_file(const std::string& file_path) -> VoidResult;
 
        auto start_server(uint16_t port) -> VoidResult;
 
        auto stop_server() -> VoidResult;
 
        auto wait_for_stop() -> 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;
 
        auto set_receive_callback(udp_receive_callback_t callback) -> void;
 
        auto set_error_callback(std::function<void(std::error_code)> callback) -> void;
 
        auto set_client_connected_callback(udp_client_callback_t callback) -> void;
 
        auto set_client_disconnected_callback(udp_client_callback_t callback) -> void;
 
        [[nodiscard]] auto is_running() const noexcept -> bool
        {
            return is_running_.load(std::memory_order_acquire);
        }
 
        [[nodiscard]] auto server_id() const -> const std::string& { return server_id_; }
 
    private:
        struct dtls_session
        {
            std::shared_ptr<internal::dtls_socket> socket;
            bool handshake_complete{false};
        };
 
        auto init_ssl_context() -> VoidResult;
 
        auto do_receive() -> void;
 
        auto process_session_data(const std::vector<uint8_t>& data,
                                  const asio::ip::udp::endpoint& sender) -> void;
 
        auto create_session(const asio::ip::udp::endpoint& client_endpoint)
            -> std::shared_ptr<dtls_session>;
 
        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);
            }
        };
 
    private:
        // Lifecycle management (consistent with other messaging classes)
        std::string server_id_;                          
        std::atomic<bool> is_running_{false};            
        std::optional<std::promise<void>> stop_promise_; 
        std::future<void> stop_future_;                  
        // DTLS protocol-specific members
        std::unique_ptr<asio::io_context> io_context_;   
        std::unique_ptr<asio::ip::udp::socket> socket_;  
        SSL_CTX* ssl_ctx_{nullptr};                      
        std::string cert_file_;                          
        std::string key_file_;                           
        std::shared_ptr<integration::thread_pool_interface> thread_pool_;
        std::future<void> io_context_future_;            
        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_;                                   
        // UDP-specific callbacks (different signature from TCP servers)
        mutable std::mutex callback_mutex_;              
        udp_receive_callback_t receive_callback_;
        std::function<void(std::error_code)> error_callback_;
        udp_client_callback_t client_connected_callback_;
        udp_client_callback_t client_disconnected_callback_;
    };
 
} // namespace kcenon::network::core