kcenon::network::internal::dtls_socket Class Reference

A wrapper around ASIO UDP socket with OpenSSL DTLS encryption. More...

#include <dtls_socket.h>

Inheritance diagram for kcenon::network::internal::dtls_socket:

Collaboration diagram for kcenon::network::internal::dtls_socket:

Public Types
enum class	handshake_type { client , server }
	Handshake type enumeration. More...

Public Member Functions
	dtls_socket (asio::ip::udp::socket socket, SSL_CTX *ssl_ctx)
	Constructs a dtls_socket with an existing UDP socket.
	~dtls_socket ()
	Destructor. Cleans up OpenSSL resources.
	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
	Performs asynchronous DTLS handshake.
auto	set_receive_callback (std::function< void(const std::vector< uint8_t > &, const asio::ip::udp::endpoint &)> callback) -> void
	Sets a callback to receive decrypted inbound datagrams.
auto	set_error_callback (std::function< void(std::error_code)> callback) -> void
	Sets a callback to handle socket errors.
auto	start_receive () -> void
	Begins the continuous asynchronous receive loop.
auto	stop_receive () -> void
	Stops the receive loop.
auto	async_send (std::vector< uint8_t > &&data, std::function< void(std::error_code, std::size_t)> handler) -> void
	Initiates an asynchronous encrypted send.
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
	Initiates an asynchronous encrypted send to a specific endpoint.
auto	set_peer_endpoint (const asio::ip::udp::endpoint &endpoint) -> void
	Sets the peer endpoint for connected mode.
auto	peer_endpoint () const -> asio::ip::udp::endpoint
	Returns the peer endpoint.
auto	socket () -> asio::ip::udp::socket &
	Provides direct access to the underlying UDP socket.
auto	is_handshake_complete () const -> bool
	Checks if the DTLS handshake is complete.

Private Member Functions
auto	do_receive () -> void
	Internal function to handle the receive logic.
auto	process_received_data (const std::vector< uint8_t > &data, const asio::ip::udp::endpoint &sender) -> void
	Processes received encrypted data through DTLS.
auto	flush_bio_output () -> void
	Flushes pending DTLS output to the network.
auto	continue_handshake () -> void
	Continues the handshake process.
auto	make_ssl_error () const -> std::error_code
	Creates an OpenSSL error code from the current error state.

Private Attributes
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}

Detailed Description

A wrapper around ASIO UDP socket with OpenSSL DTLS encryption.

Key Features

• Provides DTLS (Datagram TLS) encryption over UDP transport.
• Uses OpenSSL's DTLS implementation with memory BIOs for async I/O.
• Exposes set_receive_callback() to handle decrypted inbound datagrams and set_error_callback() for error handling.
• start_receive() begins an ongoing loop of receiving encrypted datagrams.
• async_send() encrypts and sends data to the configured peer.

Thread Safety

• All public methods are thread-safe. Callback registration is protected by callback_mutex_.
• ASIO operations are serialized through the io_context.
• OpenSSL operations are protected by ssl_mutex_.
• The provided callbacks will be invoked on an ASIO worker thread; ensure that your callback logic is thread-safe if it shares data.

DTLS Characteristics

• Provides confidentiality and integrity for UDP datagrams.
• Handles packet loss and reordering during handshake.
• Message boundaries are preserved (each receive is one datagram).
• Suitable for real-time applications requiring encryption.

Definition at line 48 of file dtls_socket.h.

Member Enumeration Documentation

handshake_type

enum class kcenon::network::internal::dtls_socket::handshake_type

strong

Handshake type enumeration.

Enumerator
client	Client-side handshake
server	Server-side handshake

Definition at line 54 of file dtls_socket.h.

        {
            client, 
            server  
        };

Constructor & Destructor Documentation

dtls_socket() [1/3]

kcenon::network::internal::dtls_socket::dtls_socket	(	asio::ip::udp::socket	socket,
		SSL_CTX *	ssl_ctx )

Constructs a dtls_socket with an existing UDP socket.

Parameters

socket	An asio::ip::udp::socket that must be open.
ssl_ctx	The OpenSSL SSL_CTX configured for DTLS.

The socket should be connected (for client) or bound (for server) before calling handshake methods.

Definition at line 42 of file dtls_socket.cpp.

    : socket_(std::move(socket))
    , ssl_ctx_(ssl_ctx)
    , ssl_(nullptr)
    , rbio_(nullptr)
    , wbio_(nullptr)
{
    // Create SSL object
    ssl_ = SSL_new(ssl_ctx_);
    if (!ssl_)
    {
        throw std::runtime_error("Failed to create SSL object");
    }
 
    // Create memory BIOs for non-blocking I/O
    rbio_ = BIO_new(BIO_s_mem());
    wbio_ = BIO_new(BIO_s_mem());
    if (!rbio_ || !wbio_)
    {
        if (rbio_) BIO_free(rbio_);
        if (wbio_) BIO_free(wbio_);
        SSL_free(ssl_);
        throw std::runtime_error("Failed to create BIO objects");
    }
 
    // Set BIOs to non-blocking mode
    BIO_set_nbio(rbio_, 1);
    BIO_set_nbio(wbio_, 1);
 
    // Connect BIOs to SSL object (SSL takes ownership)
    SSL_set_bio(ssl_, rbio_, wbio_);
 
    // Enable DTLS cookie exchange for servers (DoS protection)
    // This is optional and can be configured later
}

References rbio_, ssl_, ssl_ctx_, and wbio_.

~dtls_socket()

kcenon::network::internal::dtls_socket::~dtls_socket

(

)

Destructor. Cleans up OpenSSL resources.

Definition at line 78 of file dtls_socket.cpp.

{
    stop_receive();
 
    if (ssl_)
    {
        SSL_shutdown(ssl_);
        SSL_free(ssl_);  // Also frees the BIOs
    }
}

References ssl_, and stop_receive().

Here is the call graph for this function:

dtls_socket() [2/3]

kcenon::network::internal::dtls_socket::dtls_socket ( const dtls_socket & )

delete

dtls_socket() [3/3]

kcenon::network::internal::dtls_socket::dtls_socket ( dtls_socket && )

delete

Member Function Documentation

async_handshake()

auto kcenon::network::internal::dtls_socket::async_handshake	(	handshake_type	type,
		std::function< void(std::error_code)>	handler ) -> void

Performs asynchronous DTLS handshake.

Parameters

type	Handshake type (client or server)
handler	Completion handler with signature void(std::error_code)

Must be called before start_receive() or async_send(). The handshake involves multiple round-trips over UDP.

Definition at line 89 of file dtls_socket.cpp.

{
    handshake_type_ = type;
    handshake_callback_ = std::move(handler);
    handshake_in_progress_.store(true);
 
    {
        std::lock_guard<std::mutex> lock(ssl_mutex_);
 
        if (type == handshake_type::client)
        {
            SSL_set_connect_state(ssl_);
        }
        else
        {
            SSL_set_accept_state(ssl_);
        }
    }
 
    // Start receiving for handshake packets
    start_receive();
 
    // Initiate handshake
    continue_handshake();
}

async_send()

auto kcenon::network::internal::dtls_socket::async_send	(	std::vector< uint8_t > &&	data,
		std::function< void(std::error_code, std::size_t)>	handler ) -> void

Initiates an asynchronous encrypted send.

Parameters

data	The plaintext data to encrypt and send (moved for efficiency).
handler	A completion handler with signature void(std::error_code, std::size_t) invoked upon completion.

The data is encrypted using DTLS before transmission.

Note

Data is moved (not copied) to avoid memory allocation overhead.

Definition at line 371 of file dtls_socket.cpp.

{
    asio::ip::udp::endpoint target;
    {
        std::lock_guard<std::mutex> lock(endpoint_mutex_);
        target = peer_endpoint_;
    }
 
    async_send_to(std::move(data), target, std::move(handler));
}

async_send_to()

auto kcenon::network::internal::dtls_socket::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

Initiates an asynchronous encrypted send to a specific endpoint.

Parameters

data	The plaintext data to encrypt and send (moved for efficiency).
endpoint	The target endpoint.
handler	A completion handler invoked upon completion.

Useful for server responding to different clients.

Definition at line 384 of file dtls_socket.cpp.

{
    if (!handshake_complete_.load())
    {
        if (handler)
        {
            handler(std::make_error_code(std::errc::not_connected), 0);
        }
        return;
    }
 
    // Encrypt the data
    int written;
    {
        std::lock_guard<std::mutex> lock(ssl_mutex_);
        written = SSL_write(ssl_, data.data(), static_cast<int>(data.size()));
    }
 
    if (written <= 0)
    {
        if (handler)
        {
            handler(make_ssl_error(), 0);
        }
        return;
    }
 
    // Get encrypted data from write BIO
    std::vector<uint8_t> encrypted;
    {
        std::lock_guard<std::mutex> lock(ssl_mutex_);
        int pending = BIO_ctrl_pending(wbio_);
        if (pending <= 0)
        {
            if (handler)
            {
                handler(std::make_error_code(std::errc::io_error), 0);
            }
            return;
        }
 
        encrypted.resize(static_cast<std::size_t>(pending));
        int read_len = BIO_read(wbio_, encrypted.data(), pending);
        if (read_len <= 0)
        {
            if (handler)
            {
                handler(std::make_error_code(std::errc::io_error), 0);
            }
            return;
        }
        encrypted.resize(static_cast<std::size_t>(read_len));
    }
 
    // Send encrypted data
    auto self = shared_from_this();
    auto buffer = std::make_shared<std::vector<uint8_t>>(std::move(encrypted));
    auto original_size = data.size();
 
    socket_.async_send_to(
        asio::buffer(*buffer),
        endpoint,
        [handler = std::move(handler), buffer, original_size](
            std::error_code ec, std::size_t /*bytes_sent*/)
        {
            if (handler)
            {
                // Report original (plaintext) size to the handler
                handler(ec, ec ? 0 : original_size);
            }
        });
}

continue_handshake()

auto kcenon::network::internal::dtls_socket::continue_handshake ( ) -> void

private

Continues the handshake process.

Definition at line 117 of file dtls_socket.cpp.

{
    if (!handshake_in_progress_.load())
    {
        return;
    }
 
    int result;
    {
        std::lock_guard<std::mutex> lock(ssl_mutex_);
        result = SSL_do_handshake(ssl_);
    }
 
    if (result == 1)
    {
        // Handshake complete
        handshake_in_progress_.store(false);
        handshake_complete_.store(true);
 
        // Flush any remaining output
        flush_bio_output();
 
        std::function<void(std::error_code)> callback;
        {
            std::lock_guard<std::mutex> lock(callback_mutex_);
            callback = std::move(handshake_callback_);
        }
 
        if (callback)
        {
            callback(std::error_code{});
        }
        return;
    }
 
    int ssl_error;
    {
        std::lock_guard<std::mutex> lock(ssl_mutex_);
        ssl_error = SSL_get_error(ssl_, result);
    }
 
    // Flush any output generated by the handshake
    flush_bio_output();
 
    if (ssl_error == SSL_ERROR_WANT_READ || ssl_error == SSL_ERROR_WANT_WRITE)
    {
        // Need more data - continue receiving
        return;
    }
 
    // Handshake failed
    handshake_in_progress_.store(false);
 
    std::function<void(std::error_code)> callback;
    {
        std::lock_guard<std::mutex> lock(callback_mutex_);
        callback = std::move(handshake_callback_);
    }
 
    if (callback)
    {
        callback(make_ssl_error());
    }
}

do_receive()

auto kcenon::network::internal::dtls_socket::do_receive ( ) -> void

private

Internal function to handle the receive logic.

Definition at line 211 of file dtls_socket.cpp.

{
    if (!is_receiving_.load())
    {
        return;
    }
 
    auto self = shared_from_this();
    socket_.async_receive_from(
        asio::buffer(read_buffer_),
        sender_endpoint_,
        [this, self](std::error_code ec, std::size_t length)
        {
            if (!is_receiving_.load())
            {
                return;
            }
 
            if (ec)
            {
                std::function<void(std::error_code)> callback;
                {
                    std::lock_guard<std::mutex> lock(callback_mutex_);
                    callback = error_callback_;
                }
                if (callback)
                {
                    callback(ec);
                }
                return;
            }
 
            if (length > 0)
            {
                std::vector<uint8_t> data(read_buffer_.begin(),
                                          read_buffer_.begin() + length);
                process_received_data(data, sender_endpoint_);
            }
 
            // Continue receiving
            if (is_receiving_.load())
            {
                do_receive();
            }
        });
}

flush_bio_output()

auto kcenon::network::internal::dtls_socket::flush_bio_output ( ) -> void

private

Flushes pending DTLS output to the network.

Definition at line 330 of file dtls_socket.cpp.

{
    // Check if there's data to send in the write BIO
    std::vector<uint8_t> output;
    {
        std::lock_guard<std::mutex> lock(ssl_mutex_);
        int pending = BIO_ctrl_pending(wbio_);
        if (pending <= 0)
        {
            return;
        }
 
        output.resize(static_cast<std::size_t>(pending));
        int read_len = BIO_read(wbio_, output.data(), pending);
        if (read_len <= 0)
        {
            return;
        }
        output.resize(static_cast<std::size_t>(read_len));
    }
 
    // Send the encrypted data
    asio::ip::udp::endpoint target;
    {
        std::lock_guard<std::mutex> lock(endpoint_mutex_);
        target = peer_endpoint_;
    }
 
    if (target.port() != 0)
    {
        auto buffer = std::make_shared<std::vector<uint8_t>>(std::move(output));
        socket_.async_send_to(
            asio::buffer(*buffer),
            target,
            [buffer](std::error_code /*ec*/, std::size_t /*bytes*/)
            {
                // Fire and forget for handshake messages
            });
    }
}

is_handshake_complete()

auto kcenon::network::internal::dtls_socket::is_handshake_complete ( ) const -> bool

inline

Checks if the DTLS handshake is complete.

Returns

true if handshake completed successfully.

Definition at line 177 of file dtls_socket.h.

        {
            return handshake_complete_.load();
        }

References handshake_complete_.

make_ssl_error()

auto kcenon::network::internal::dtls_socket::make_ssl_error ( ) const -> std::error_code

private

Creates an OpenSSL error code from the current error state.

Returns

std::error_code representing the SSL error.

Definition at line 472 of file dtls_socket.cpp.

{
    unsigned long err = ERR_get_error();
    if (err == 0)
    {
        return std::make_error_code(std::errc::io_error);
    }
    return make_ssl_error_code(static_cast<int>(err));
}

operator=() [1/2]

dtls_socket & kcenon::network::internal::dtls_socket::operator= ( const dtls_socket & )

delete

operator=() [2/2]

dtls_socket & kcenon::network::internal::dtls_socket::operator= ( dtls_socket && )

delete

peer_endpoint()

auto kcenon::network::internal::dtls_socket::peer_endpoint

(

)

const -> asio::ip::udp::endpoint

Returns the peer endpoint.

Returns

The configured peer endpoint.

Definition at line 466 of file dtls_socket.cpp.

{
    std::lock_guard<std::mutex> lock(const_cast<std::mutex&>(endpoint_mutex_));
    return peer_endpoint_;
}

References endpoint_mutex_, and peer_endpoint_.

process_received_data()

auto kcenon::network::internal::dtls_socket::process_received_data ( const std::vector< uint8_t > & data, const asio::ip::udp::endpoint & sender ) -> void

private

Processes received encrypted data through DTLS.

Parameters

data	The encrypted datagram.
sender	The sender's endpoint.

Definition at line 258 of file dtls_socket.cpp.

{
    // Write received data to the read BIO
    {
        std::lock_guard<std::mutex> lock(ssl_mutex_);
        int written = BIO_write(rbio_, data.data(), static_cast<int>(data.size()));
        if (written <= 0)
        {
            // BIO write failed
            return;
        }
    }
 
    // If handshake is in progress, continue it
    if (handshake_in_progress_.load())
    {
        continue_handshake();
        return;
    }
 
    // Handshake complete, try to read decrypted data
    if (handshake_complete_.load())
    {
        std::vector<uint8_t> decrypted;
        decrypted.resize(65536);
 
        int read_len;
        {
            std::lock_guard<std::mutex> lock(ssl_mutex_);
            read_len = SSL_read(ssl_, decrypted.data(), static_cast<int>(decrypted.size()));
        }
 
        if (read_len > 0)
        {
            decrypted.resize(static_cast<std::size_t>(read_len));
 
            std::function<void(const std::vector<uint8_t>&, const asio::ip::udp::endpoint&)> callback;
            {
                std::lock_guard<std::mutex> lock(callback_mutex_);
                callback = receive_callback_;
            }
            if (callback)
            {
                callback(decrypted, sender);
            }
        }
        else
        {
            int ssl_error;
            {
                std::lock_guard<std::mutex> lock(ssl_mutex_);
                ssl_error = SSL_get_error(ssl_, read_len);
            }
 
            if (ssl_error != SSL_ERROR_WANT_READ && ssl_error != SSL_ERROR_WANT_WRITE)
            {
                // Real error
                std::function<void(std::error_code)> callback;
                {
                    std::lock_guard<std::mutex> lock(callback_mutex_);
                    callback = error_callback_;
                }
                if (callback)
                {
                    callback(make_ssl_error());
                }
            }
        }
    }
}

set_error_callback()

auto kcenon::network::internal::dtls_socket::set_error_callback

(

std::function< void(std::error_code)>

callback

)

-> void

Sets a callback to handle socket errors.

Parameters

callback

A function with signature void(std::error_code), invoked when any asynchronous operation fails.

If no callback is set, errors are not explicitly handled here.

Definition at line 190 of file dtls_socket.cpp.

{
    std::lock_guard<std::mutex> lock(callback_mutex_);
    error_callback_ = std::move(callback);
}

set_peer_endpoint()

auto kcenon::network::internal::dtls_socket::set_peer_endpoint

(

const asio::ip::udp::endpoint &

endpoint

)

-> void

Sets the peer endpoint for connected mode.

Parameters

endpoint

The peer's UDP endpoint.

Definition at line 460 of file dtls_socket.cpp.

{
    std::lock_guard<std::mutex> lock(endpoint_mutex_);
    peer_endpoint_ = endpoint;
}

set_receive_callback()

auto kcenon::network::internal::dtls_socket::set_receive_callback

(

std::function< void(const std::vector< uint8_t > &, const asio::ip::udp::endpoint &)>

callback

)

-> void

Sets a callback to receive decrypted inbound datagrams.

Parameters

callback

A function with signature void(const std::vector<uint8_t>&, const asio::ip::udp::endpoint&), called whenever a datagram is successfully received and decrypted.

If no callback is set, received data is effectively discarded.

Definition at line 182 of file dtls_socket.cpp.

{
    std::lock_guard<std::mutex> lock(callback_mutex_);
    receive_callback_ = std::move(callback);
}

socket()

auto kcenon::network::internal::dtls_socket::socket ( ) -> asio::ip::udp::socket&

inline

Provides direct access to the underlying UDP socket.

Returns

A reference to the wrapped asio::ip::udp::socket.

Definition at line 171 of file dtls_socket.h.

{ return socket_; }

References socket_.

start_receive()

auto kcenon::network::internal::dtls_socket::start_receive

(

)

-> void

Begins the continuous asynchronous receive loop.

Once called, the class repeatedly receives encrypted datagrams, decrypts them, and invokes the receive callback. If an error occurs, the error callback is triggered.

Definition at line 197 of file dtls_socket.cpp.

{
    bool expected = false;
    if (is_receiving_.compare_exchange_strong(expected, true))
    {
        do_receive();
    }
}

stop_receive()

auto kcenon::network::internal::dtls_socket::stop_receive

(

)

-> void

Stops the receive loop.

Definition at line 206 of file dtls_socket.cpp.

{
    is_receiving_.store(false);
}

Referenced by ~dtls_socket().

Here is the caller graph for this function:

Member Data Documentation

callback_mutex_

std::mutex kcenon::network::internal::dtls_socket::callback_mutex_

private

Protects callback registration.

Definition at line 225 of file dtls_socket.h.

endpoint_mutex_

std::mutex kcenon::network::internal::dtls_socket::endpoint_mutex_

private

Protects endpoint access.

Definition at line 226 of file dtls_socket.h.

Referenced by peer_endpoint().

error_callback_

std::function<void(std::error_code)> kcenon::network::internal::dtls_socket::error_callback_

private

Error callback.

Definition at line 231 of file dtls_socket.h.

handshake_callback_

std::function<void(std::error_code)> kcenon::network::internal::dtls_socket::handshake_callback_

private

Handshake completion callback.

Definition at line 233 of file dtls_socket.h.

handshake_complete_

std::atomic<bool> kcenon::network::internal::dtls_socket::handshake_complete_ {false}

private

Handshake completed flag.

Definition at line 236 of file dtls_socket.h.

{false}; 

Referenced by is_handshake_complete().

handshake_in_progress_

std::atomic<bool> kcenon::network::internal::dtls_socket::handshake_in_progress_ {false}

private

Handshake in progress flag.

Definition at line 237 of file dtls_socket.h.

{false}; 

handshake_type_

handshake_type kcenon::network::internal::dtls_socket::handshake_type_ {handshake_type::client}

private

Handshake mode.

Definition at line 238 of file dtls_socket.h.

{handshake_type::client}; 

is_receiving_

std::atomic<bool> kcenon::network::internal::dtls_socket::is_receiving_ {false}

private

Receive loop active flag.

Definition at line 235 of file dtls_socket.h.

{false};     

peer_endpoint_

asio::ip::udp::endpoint kcenon::network::internal::dtls_socket::peer_endpoint_

private

Peer endpoint for connected mode.

Definition at line 214 of file dtls_socket.h.

Referenced by peer_endpoint().

rbio_

BIO* kcenon::network::internal::dtls_socket::rbio_

private

Read BIO (memory).

Definition at line 219 of file dtls_socket.h.

Referenced by dtls_socket().

read_buffer_

std::array<uint8_t, 65536> kcenon::network::internal::dtls_socket::read_buffer_

private

Buffer for receiving datagrams.

Definition at line 222 of file dtls_socket.h.

receive_callback_

std::function<void(const std::vector<uint8_t>&, const asio::ip::udp::endpoint&)> kcenon::network::internal::dtls_socket::receive_callback_

private

Inbound data callback.

Definition at line 229 of file dtls_socket.h.

sender_endpoint_

asio::ip::udp::endpoint kcenon::network::internal::dtls_socket::sender_endpoint_

private

Sender endpoint for receives.

Definition at line 215 of file dtls_socket.h.

socket_

asio::ip::udp::socket kcenon::network::internal::dtls_socket::socket_

private

The underlying UDP socket.

Definition at line 213 of file dtls_socket.h.

Referenced by socket().

ssl_

SSL* kcenon::network::internal::dtls_socket::ssl_

private

OpenSSL SSL object.

Definition at line 218 of file dtls_socket.h.

Referenced by dtls_socket(), and ~dtls_socket().

ssl_ctx_

SSL_CTX* kcenon::network::internal::dtls_socket::ssl_ctx_

private

OpenSSL context (not owned).

Definition at line 217 of file dtls_socket.h.

Referenced by dtls_socket().

ssl_mutex_

std::mutex kcenon::network::internal::dtls_socket::ssl_mutex_

private

Protects SSL operations.

Definition at line 224 of file dtls_socket.h.

wbio_

BIO* kcenon::network::internal::dtls_socket::wbio_

private

Write BIO (memory).

Definition at line 220 of file dtls_socket.h.

Referenced by dtls_socket().

---

The documentation for this class was generated from the following files:

• src/internal/tcp/dtls_socket.h
• src/internal/dtls_socket.cpp