dtls_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
 
#include <array>
#include <atomic>
#include <functional>
#include <memory>
#include <mutex>
#include <system_error>
#include <vector>
 
#include <asio.hpp>
 
#include "internal/utils/common_defs.h"
#include "internal/utils/openssl_compat.h"
#include <kcenon/network/detail/utils/result_types.h>
 
namespace kcenon::network::internal
{
    class dtls_socket : public std::enable_shared_from_this<dtls_socket>
    {
    public:
        enum class handshake_type
        {
            client, 
            server  
        };
 
        [[nodiscard]] static Result<std::shared_ptr<dtls_socket>> create(
            asio::ip::udp::socket socket, SSL_CTX* ssl_ctx);
 
        ~dtls_socket();
 
        // Non-copyable, non-movable
        dtls_socket(const dtls_socket&) = delete;
        dtls_socket& operator=(const dtls_socket&) = delete;
        dtls_socket(dtls_socket&&) = delete;
        dtls_socket& operator=(dtls_socket&&) = delete;
 
        auto async_handshake(
            handshake_type type,
            std::function<void(std::error_code)> handler) -> void;
 
        auto set_receive_callback(
            std::function<void(const std::vector<uint8_t>&,
                               const asio::ip::udp::endpoint&)> callback) -> void;
 
        auto set_error_callback(std::function<void(std::error_code)> callback)
            -> void;
 
        auto start_receive() -> void;
 
        auto stop_receive() -> void;
 
        auto deliver_encrypted(const std::vector<uint8_t>& data,
                               const asio::ip::udp::endpoint& sender) -> void;
 
        auto async_send(
            std::vector<uint8_t>&& data,
            std::function<void(std::error_code, std::size_t)> handler) -> 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) -> void;
 
        auto set_peer_endpoint(const asio::ip::udp::endpoint& endpoint) -> void;
 
        auto peer_endpoint() const -> asio::ip::udp::endpoint;
 
        auto socket() -> asio::ip::udp::socket& { return socket_; }
 
        auto is_handshake_complete() const -> bool
        {
            return handshake_complete_.load();
        }
 
    private:
        dtls_socket(asio::ip::udp::socket socket, SSL* ssl, BIO* rbio, BIO* wbio);
 
        auto do_receive() -> void;
 
        auto process_received_data(const std::vector<uint8_t>& data,
                                   const asio::ip::udp::endpoint& sender) -> void;
 
        auto flush_bio_output() -> void;
 
        auto continue_handshake() -> void;
 
        auto make_ssl_error() const -> std::error_code;
 
    private:
        asio::ip::udp::socket socket_;              
        asio::ip::udp::endpoint peer_endpoint_;     
        asio::ip::udp::endpoint sender_endpoint_;   
        SSL_CTX* ssl_ctx_;                          
        SSL* ssl_;                                  
        BIO* rbio_;                                 
        BIO* wbio_;                                 
        std::array<uint8_t, 65536> read_buffer_;    
        std::mutex ssl_mutex_;                      
        std::mutex callback_mutex_;                 
        std::mutex endpoint_mutex_;                 
        std::function<void(const std::vector<uint8_t>&, const asio::ip::udp::endpoint&)>
            receive_callback_;                      
        std::function<void(std::error_code)>
            error_callback_;                        
        std::function<void(std::error_code)>
            handshake_callback_;                    
        std::atomic<bool> is_receiving_{false};     
        std::atomic<bool> handshake_complete_{false}; 
        std::atomic<bool> handshake_in_progress_{false}; 
        handshake_type handshake_type_{handshake_type::client}; 
    };
 
} // namespace kcenon::network::internal