kcenon::network::internal::quic_socket Class Reference

A QUIC socket that wraps UDP and integrates QUIC packet protection. More...

#include <quic_socket.h>

Inheritance diagram for kcenon::network::internal::quic_socket:

Collaboration diagram for kcenon::network::internal::quic_socket:

Public Types
using	stream_data_callback
	Callback for receiving stream data.
using	connected_callback = std::function<void()>
	Callback when connection is established.
using	error_callback = std::function<void(std::error_code)>
	Callback for error handling.
using	close_callback = std::function<void(uint64_t error_code, const std::string& reason)>
	Callback when connection is closed.

Public Member Functions
	quic_socket (asio::ip::udp::socket socket, quic_role role)
	Constructs a QUIC socket.
	~quic_socket ()
	Destructor.
	quic_socket (const quic_socket &)=delete
quic_socket &	operator= (const quic_socket &)=delete
	quic_socket (quic_socket &&other) noexcept
quic_socket &	operator= (quic_socket &&other) noexcept
auto	set_stream_data_callback (stream_data_callback cb) -> void
	Set callback for stream data reception.
auto	set_connected_callback (connected_callback cb) -> void
	Set callback for connection establishment.
auto	set_error_callback (error_callback cb) -> void
	Set callback for errors.
auto	set_close_callback (close_callback cb) -> void
	Set callback for connection close.
auto	connect (const asio::ip::udp::endpoint &endpoint, const std::string &server_name="") -> VoidResult
	Connect to a remote server (client only)
auto	accept (const std::string &cert_file, const std::string &key_file) -> VoidResult
	Accept an incoming connection (server only)
auto	close (uint64_t error_code=0, const std::string &reason="") -> VoidResult
	Close the connection gracefully.
auto	start_receive () -> void
	Start the receive loop.
auto	stop_receive () -> void
	Stop the receive loop.
auto	send_stream_data (uint64_t stream_id, std::vector< uint8_t > &&data, bool fin=false) -> VoidResult
	Send data on a stream.
auto	create_stream (bool unidirectional=false) -> Result< uint64_t >
	Create a new stream.
auto	close_stream (uint64_t stream_id) -> VoidResult
	Close a stream.
auto	is_connected () const noexcept -> bool
	Check if the connection is established.
auto	is_handshake_complete () const noexcept -> bool
	Check if the TLS handshake is complete.
auto	state () const noexcept -> quic_connection_state
	Get the current connection state.
auto	role () const noexcept -> quic_role
	Get the role (client or server)
auto	remote_endpoint () const -> asio::ip::udp::endpoint
	Get the remote endpoint.
auto	local_connection_id () const -> const protocols::quic::connection_id &
	Get the local connection ID.
auto	remote_connection_id () const -> const protocols::quic::connection_id &
	Get the remote connection ID.
auto	socket () -> asio::ip::udp::socket &
	Access the underlying UDP socket.
auto	socket () const -> const asio::ip::udp::socket &
	Access the underlying UDP socket (const)

Private Member Functions
auto	do_receive () -> void
	Internal receive loop implementation.
auto	handle_packet (std::span< const uint8_t > data) -> void
	Handle received packet data.
auto	process_frame (const protocols::quic::frame &f) -> void
	Process a parsed frame.
auto	process_crypto_frame (const protocols::quic::crypto_frame &f) -> void
	Process CRYPTO frame data.
auto	process_stream_frame (const protocols::quic::stream_frame &f) -> void
	Process STREAM frame data.
auto	process_ack_frame (const protocols::quic::ack_frame &f) -> void
	Process ACK frame.
auto	process_connection_close_frame (const protocols::quic::connection_close_frame &f) -> void
	Process CONNECTION_CLOSE frame.
auto	process_handshake_done_frame () -> void
	Process HANDSHAKE_DONE frame.
auto	send_pending_packets () -> void
	Send pending outgoing packets.
auto	send_packet (protocols::quic::encryption_level level, std::vector< protocols::quic::frame > &&frames) -> VoidResult
	Build and send a packet with frames.
auto	queue_crypto_data (std::vector< uint8_t > &&data) -> void
	Queue crypto data for sending.
auto	determine_encryption_level (const protocols::quic::packet_header &header) const noexcept -> protocols::quic::encryption_level
	Determine encryption level from packet header.
auto	generate_connection_id () -> protocols::quic::connection_id
	Generate a new connection ID.
auto	on_retransmit_timeout () -> void
	Retransmission timeout handler.
auto	transition_state (quic_connection_state new_state) -> void
	Transition to a new connection state.

Private Attributes
asio::ip::udp::socket	udp_socket_
	Underlying UDP socket.
asio::ip::udp::endpoint	remote_endpoint_
	Remote endpoint.
std::array< uint8_t, 65536 >	recv_buffer_
	Receive buffer (max UDP datagram size)
quic_role	role_
	Socket role (client/server)
std::atomic< quic_connection_state >	state_ {quic_connection_state::idle}
	Connection state.
protocols::quic::quic_crypto	crypto_
	QUIC crypto handler.
protocols::quic::connection_id	local_conn_id_
	Local connection ID.
protocols::quic::connection_id	remote_conn_id_
	Remote connection ID.
std::array< uint64_t, 4 >	next_packet_number_ {0, 0, 0, 0}
	Packet number for each encryption level.
std::array< uint64_t, 4 >	largest_received_pn_ {0, 0, 0, 0}
	Largest received packet number for each level.
uint64_t	next_stream_id_ {0}
	Next stream ID to allocate.
std::array< std::deque< std::vector< uint8_t > >, 4 >	pending_crypto_data_
	Pending crypto data to send per encryption level.
std::map< uint64_t, std::deque< std::pair< std::vector< uint8_t >, bool > > >	pending_stream_data_
	Pending stream data to send (stream_id -> data queue)
std::mutex	callback_mutex_
	Mutex for callback protection.
stream_data_callback	stream_data_cb_
	Stream data callback.
connected_callback	connected_cb_
	Connected callback.
error_callback	error_cb_
	Error callback.
close_callback	close_cb_
	Close callback.
std::atomic< bool >	is_receiving_ {false}
	Is receive loop running.
std::atomic< bool >	handshake_complete_ {false}
	Is handshake complete.
asio::steady_timer	retransmit_timer_
	Retransmission timer.
asio::steady_timer	idle_timer_
	Idle timeout timer.
std::mutex	state_mutex_
	Mutex for state protection.

Detailed Description

A QUIC socket that wraps UDP and integrates QUIC packet protection.

Key Features

• Wraps an existing asio::ip::udp::socket for UDP I/O
• Integrates QUIC packet protection (encryption/decryption)
• Handles packet parsing and building
• Manages connection state at socket level
• Supports stream-based data transfer

Thread Safety

• All public methods are thread-safe through internal locking
• Callbacks are invoked on ASIO worker threads
• Ensure callback implementations are thread-safe

QUIC Protocol

• Implements RFC 9000 connection semantics
• Uses RFC 9001 TLS 1.3 for key negotiation
• Supports multiple concurrent streams

Definition at line 72 of file quic_socket.h.

Member Typedef Documentation

close_callback

using kcenon::network::internal::quic_socket::close_callback = std::function<void(uint64_t error_code, const std::string& reason)>

Callback when connection is closed.

Parameters

error_code	The QUIC error code
reason	Human-readable reason string

Definition at line 102 of file quic_socket.h.

connected_callback

using kcenon::network::internal::quic_socket::connected_callback = std::function<void()>

Callback when connection is established.

Definition at line 89 of file quic_socket.h.

error_callback

using kcenon::network::internal::quic_socket::error_callback = std::function<void(std::error_code)>

Callback for error handling.

Parameters

ec	The error code describing the error

Definition at line 95 of file quic_socket.h.

stream_data_callback

using kcenon::network::internal::quic_socket::stream_data_callback

Initial value:

 std::function<void(
            uint64_t stream_id,
            std::span<const uint8_t> data,
            bool fin)>

Callback for receiving stream data.

Parameters

stream_id	The stream identifier
data	The received data
fin	True if this is the final data on the stream

Definition at line 81 of file quic_socket.h.

Constructor & Destructor Documentation

quic_socket() [1/3]

kcenon::network::internal::quic_socket::quic_socket	(	asio::ip::udp::socket	socket,
		quic_role	role )

Constructs a QUIC socket.

Parameters

socket	An open UDP socket
role	Client or server role

Definition at line 20 of file quic_socket.cpp.

    : udp_socket_(std::move(socket))
    , role_(role)
    , retransmit_timer_(udp_socket_.get_executor())
    , idle_timer_(udp_socket_.get_executor())
{
    // Generate local connection ID
    local_conn_id_ = generate_connection_id();
 
    // Initialize next stream ID based on role
    // Client-initiated bidi streams: 0, 4, 8, ...
    // Server-initiated bidi streams: 1, 5, 9, ...
    next_stream_id_ = (role_ == quic_role::client) ? 0 : 1;
}

References kcenon::network::internal::client, generate_connection_id(), local_conn_id_, next_stream_id_, and role_.

Here is the call graph for this function:

~quic_socket()

kcenon::network::internal::quic_socket::~quic_socket

(

)

Destructor.

Definition at line 35 of file quic_socket.cpp.

{
    stop_receive();
 
    // Cancel timers
    retransmit_timer_.cancel();
    idle_timer_.cancel();
}

References idle_timer_, retransmit_timer_, and stop_receive().

Here is the call graph for this function:

quic_socket() [2/3]

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

delete

quic_socket() [3/3]

kcenon::network::internal::quic_socket::quic_socket ( quic_socket && other )

noexcept

Definition at line 44 of file quic_socket.cpp.

    : udp_socket_(std::move(other.udp_socket_))
    , remote_endpoint_(std::move(other.remote_endpoint_))
    , recv_buffer_(std::move(other.recv_buffer_))
    , role_(other.role_)
    , state_(other.state_.load())
    , crypto_(std::move(other.crypto_))
    , local_conn_id_(std::move(other.local_conn_id_))
    , remote_conn_id_(std::move(other.remote_conn_id_))
    , next_packet_number_(other.next_packet_number_)
    , largest_received_pn_(other.largest_received_pn_)
    , next_stream_id_(other.next_stream_id_)
    , pending_crypto_data_(std::move(other.pending_crypto_data_))
    , pending_stream_data_(std::move(other.pending_stream_data_))
    , stream_data_cb_(std::move(other.stream_data_cb_))
    , connected_cb_(std::move(other.connected_cb_))
    , error_cb_(std::move(other.error_cb_))
    , close_cb_(std::move(other.close_cb_))
    , is_receiving_(other.is_receiving_.load())
    , handshake_complete_(other.handshake_complete_.load())
    , retransmit_timer_(std::move(other.retransmit_timer_))
    , idle_timer_(std::move(other.idle_timer_))
{
}

Member Function Documentation

accept()

auto kcenon::network::internal::quic_socket::accept ( const std::string & cert_file, const std::string & key_file ) -> VoidResult

nodiscard

Accept an incoming connection (server only)

Parameters

cert_file	Path to certificate file (PEM format)
key_file	Path to private key file (PEM format)

Returns

Success or error

Definition at line 213 of file quic_socket.cpp.

{
    if (role_ != quic_role::server)
    {
        return error_void(
            error_codes::common_errors::invalid_argument,
            "accept() can only be called on server sockets",
            "quic_socket");
    }
 
    if (state_.load() != quic_connection_state::idle)
    {
        return error_void(
            error_codes::common_errors::invalid_argument,
            "Connection already in progress",
            "quic_socket");
    }
 
    // Initialize server-side crypto
    auto init_result = crypto_.init_server(cert_file, key_file);
    if (init_result.is_err())
    {
        return error_void(
            error_codes::network_system::connection_failed,
            "Failed to initialize TLS server",
            "quic_socket",
            init_result.error().message);
    }
 
    transition_state(quic_connection_state::handshake_start);
 
    // Start receiving - server waits for Initial packet from client
    start_receive();
 
    return ok();
}

References kcenon::network::error_codes::network_system::connection_failed, kcenon::network::error_void(), kcenon::network::internal::handshake_start, kcenon::network::internal::idle, kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::ok(), and kcenon::network::internal::server.

Here is the call graph for this function:

close()

auto kcenon::network::internal::quic_socket::close ( uint64_t error_code = 0, const std::string & reason = "" ) -> VoidResult

nodiscard

Close the connection gracefully.

Parameters

error_code	Application error code (0 for no error)
reason	Human-readable reason string

Returns

Success or error

Definition at line 251 of file quic_socket.cpp.

{
    auto current_state = state_.load();
    if (current_state == quic_connection_state::closed ||
        current_state == quic_connection_state::closing ||
        current_state == quic_connection_state::draining)
    {
        return ok();  // Already closing/closed
    }
 
    transition_state(quic_connection_state::closing);
 
    // Build CONNECTION_CLOSE frame
    connection_close_frame close_frame;
    close_frame.error_code = error_code;
    close_frame.reason_phrase = reason;
    close_frame.is_application_error = (error_code != 0);
 
    // Send CONNECTION_CLOSE
    std::vector<frame> frames;
    frames.push_back(close_frame);
 
    auto level = handshake_complete_.load()
        ? encryption_level::application
        : encryption_level::initial;
 
    auto send_result = send_packet(level, std::move(frames));
    if (send_result.is_err())
    {
        // Log error but continue with close
    }
 
    transition_state(quic_connection_state::draining);
 
    // Set a timer for draining period (3 * PTO), then fully close
    idle_timer_.expires_after(std::chrono::milliseconds(300));
    idle_timer_.async_wait(
        [self = shared_from_this()](const std::error_code& ec)
        {
            if (!ec)
            {
                self->transition_state(quic_connection_state::closed);
                self->stop_receive();
            }
        });
 
    return ok();
}

References kcenon::network::internal::closed, kcenon::network::internal::closing, kcenon::network::internal::draining, kcenon::network::protocols::quic::connection_close_frame::error_code, kcenon::network::protocols::quic::connection_close_frame::is_application_error, kcenon::network::ok(), and kcenon::network::protocols::quic::connection_close_frame::reason_phrase.

Here is the call graph for this function:

close_stream()

auto kcenon::network::internal::quic_socket::close_stream ( uint64_t stream_id ) -> VoidResult

nodiscard

Close a stream.

Parameters

stream_id

Stream to close

Returns

Success or error

Definition at line 377 of file quic_socket.cpp.

{
    std::lock_guard<std::mutex> lock(state_mutex_);
 
    auto it = pending_stream_data_.find(stream_id);
    if (it == pending_stream_data_.end())
    {
        return error_void(
            error_codes::common_errors::not_found,
            "Stream not found",
            "quic_socket");
    }
 
    // Send FIN on the stream
    it->second.push_back({{}, true});
 
    send_pending_packets();
 
    return ok();
}

References kcenon::network::error_void(), kcenon::network::error_codes::common_errors::not_found, and kcenon::network::ok().

Here is the call graph for this function:

connect()

auto kcenon::network::internal::quic_socket::connect ( const asio::ip::udp::endpoint & endpoint, const std::string & server_name = "" ) -> VoidResult

nodiscard

Connect to a remote server (client only)

Parameters

endpoint	Remote endpoint to connect to
server_name	Server name for SNI (TLS)

Returns

Success or error

Definition at line 135 of file quic_socket.cpp.

{
    if (role_ != quic_role::client)
    {
        return error_void(
            error_codes::common_errors::invalid_argument,
            "connect() can only be called on client sockets",
            "quic_socket");
    }
 
    if (state_.load() != quic_connection_state::idle)
    {
        return error_void(
            error_codes::common_errors::invalid_argument,
            "Connection already in progress or established",
            "quic_socket");
    }
 
    remote_endpoint_ = endpoint;
 
    // Initialize client-side crypto
    auto init_result = crypto_.init_client(
        server_name.empty() ? endpoint.address().to_string() : server_name);
    if (init_result.is_err())
    {
        return error_void(
            error_codes::network_system::connection_failed,
            "Failed to initialize TLS client",
            "quic_socket",
            init_result.error().message);
    }
 
    // Generate initial secrets from destination connection ID
    // For client, we use a random connection ID as the destination
    remote_conn_id_ = generate_connection_id();
 
    auto derive_result = crypto_.derive_initial_secrets(remote_conn_id_);
    if (derive_result.is_err())
    {
        return error_void(
            error_codes::network_system::connection_failed,
            "Failed to derive initial secrets",
            "quic_socket",
            derive_result.error().message);
    }
 
    transition_state(quic_connection_state::handshake_start);
 
    // Start handshake - generate ClientHello
    auto handshake_result = crypto_.start_handshake();
    if (handshake_result.is_err())
    {
        transition_state(quic_connection_state::closed);
        return error_void(
            error_codes::network_system::connection_failed,
            "Failed to start TLS handshake",
            "quic_socket",
            handshake_result.error().message);
    }
 
    // Queue the CRYPTO data for sending
    if (!handshake_result.value().empty())
    {
        queue_crypto_data(std::move(handshake_result.value()));
    }
 
    transition_state(quic_connection_state::handshake);
 
    // Start receiving
    start_receive();
 
    // Send initial packet
    send_pending_packets();
 
    return ok();
}

References kcenon::network::internal::client, kcenon::network::internal::closed, kcenon::network::error_codes::network_system::connection_failed, kcenon::network::error_void(), kcenon::network::internal::handshake, kcenon::network::internal::handshake_start, kcenon::network::internal::idle, kcenon::network::error_codes::common_errors::invalid_argument, and kcenon::network::ok().

Here is the call graph for this function:

create_stream()

auto kcenon::network::internal::quic_socket::create_stream ( bool unidirectional = false ) -> Result<uint64_t>

nodiscard

Create a new stream.

Parameters

unidirectional

True for unidirectional stream

Returns

Stream ID or error

Definition at line 341 of file quic_socket.cpp.

{
    if (!is_connected())
    {
        return error<uint64_t>(
            error_codes::network_system::connection_failed,
            "Connection not established",
            "quic_socket");
    }
 
    std::lock_guard<std::mutex> lock(state_mutex_);
 
    // Stream ID encoding (RFC 9000 Section 2.1):
    // - Bits 0-1: Type (0=client-initiated bidi, 1=server-initiated bidi,
    //                   2=client-initiated uni, 3=server-initiated uni)
    // - Bits 2+: Sequence number
 
    uint64_t type_bits = 0;
    if (role_ == quic_role::server)
    {
        type_bits |= 0x01;  // Server-initiated
    }
    if (unidirectional)
    {
        type_bits |= 0x02;  // Unidirectional
    }
 
    uint64_t stream_id = (next_stream_id_ << 2) | type_bits;
    next_stream_id_++;
 
    // Initialize the stream's pending data queue
    pending_stream_data_[stream_id] = {};
 
    return ok(std::move(stream_id));
}

References kcenon::network::error_codes::network_system::connection_failed, kcenon::network::protocols::quic::error, kcenon::network::ok(), and kcenon::network::internal::server.

Here is the call graph for this function:

determine_encryption_level()

auto kcenon::network::internal::quic_socket::determine_encryption_level ( const protocols::quic::packet_header & header ) const -> protocols::quic::encryption_level

nodiscardprivatenoexcept

Determine encryption level from packet header.

Parameters

header

Packet header

Returns

Encryption level

Definition at line 905 of file quic_socket.cpp.

{
    if (std::holds_alternative<long_header>(header))
    {
        const auto& lh = std::get<long_header>(header);
        switch (lh.type())
        {
            case packet_type::initial:
                return encryption_level::initial;
            case packet_type::zero_rtt:
                return encryption_level::zero_rtt;
            case packet_type::handshake:
                return encryption_level::handshake;
            default:
                return encryption_level::initial;
        }
    }
    else
    {
        // Short header = 1-RTT = application level
        return encryption_level::application;
    }
}

do_receive()

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

private

Internal receive loop implementation.

Definition at line 441 of file quic_socket.cpp.

{
    if (!is_receiving_.load())
    {
        return;
    }
 
    auto self = shared_from_this();
    udp_socket_.async_receive_from(
        asio::buffer(recv_buffer_),
        remote_endpoint_,
        [this, self](std::error_code ec, std::size_t bytes_transferred)
        {
            if (!is_receiving_.load())
            {
                return;
            }
 
            if (ec)
            {
                if (ec != asio::error::operation_aborted)
                {
                    std::lock_guard<std::mutex> lock(callback_mutex_);
                    if (error_cb_)
                    {
                        error_cb_(ec);
                    }
                }
                return;
            }
 
            if (bytes_transferred > 0)
            {
                handle_packet(std::span(recv_buffer_.data(), bytes_transferred));
            }
 
            // Continue receiving
            if (is_receiving_.load())
            {
                do_receive();
            }
        });
}

generate_connection_id()

auto kcenon::network::internal::quic_socket::generate_connection_id ( ) -> protocols::quic::connection_id

nodiscardprivate

Generate a new connection ID.

Returns

Generated connection ID

Definition at line 930 of file quic_socket.cpp.

{
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<unsigned int> dis(0, 255);
 
    std::array<uint8_t, 8> id_bytes;
    for (auto& byte : id_bytes)
    {
        byte = static_cast<uint8_t>(dis(gen));
    }
 
    return connection_id(std::span<const uint8_t>(id_bytes));
}

Referenced by quic_socket().

Here is the caller graph for this function:

handle_packet()

auto kcenon::network::internal::quic_socket::handle_packet ( std::span< const uint8_t > data ) -> void

private

Handle received packet data.

Parameters

data	Raw packet bytes

Definition at line 485 of file quic_socket.cpp.

{
    // Parse packet header
    auto header_result = packet_parser::parse_header(data);
    if (header_result.is_err())
    {
        // Invalid packet - silently ignore
        return;
    }
 
    auto& [header, header_length] = header_result.value();
 
    // Determine encryption level
    auto level = determine_encryption_level(header);
 
    // For server, derive initial secrets on first Initial packet
    if (role_ == quic_role::server &&
        state_.load() == quic_connection_state::handshake_start)
    {
        if (std::holds_alternative<long_header>(header))
        {
            const auto& lh = std::get<long_header>(header);
            if (lh.type() == packet_type::initial)
            {
                // Use client's DCID as our remote connection ID
                remote_conn_id_ = lh.src_conn_id;
 
                // Derive initial secrets from client's DCID
                auto derive_result = crypto_.derive_initial_secrets(lh.dest_conn_id);
                if (derive_result.is_err())
                {
                    return;
                }
 
                transition_state(quic_connection_state::handshake);
            }
        }
    }
 
    // Get read keys for this level
    auto keys_result = crypto_.get_read_keys(level);
    if (keys_result.is_err())
    {
        // Keys not available yet - queue packet for later processing
        return;
    }
 
    // Unprotect (decrypt) the packet
    // First we need to get the packet number offset
    size_t pn_offset = header_length;
    if (std::holds_alternative<long_header>(header))
    {
        // For long headers, packet number is after the header
        // (already accounted for in header_length for Initial/Handshake)
    }
 
    // Determine packet number length from header (after removing header protection)
    size_t sample_offset = pn_offset + 4;  // Sample is 4 bytes after PN start
    if (sample_offset + hp_sample_size > data.size())
    {
        return;  // Not enough data for sample
    }
 
    std::span<const uint8_t> sample(data.data() + sample_offset, hp_sample_size);
 
    // Create mutable copy for header unprotection
    std::vector<uint8_t> packet_copy(data.begin(), data.end());
 
    auto unprotect_header_result = packet_protection::unprotect_header(
        keys_result.value(),
        std::span(packet_copy.data(), header_length + 4),  // Include space for max PN
        pn_offset,
        sample);
 
    if (unprotect_header_result.is_err())
    {
        return;
    }
 
    auto& [first_byte, pn_length] = unprotect_header_result.value();
 
    // Extract packet number
    uint64_t truncated_pn = 0;
    for (size_t i = 0; i < pn_length; ++i)
    {
        truncated_pn = (truncated_pn << 8) | packet_copy[pn_offset + i];
    }
 
    // Decode full packet number
    auto level_idx = static_cast<size_t>(level);
    uint64_t full_pn = packet_number::decode(
        truncated_pn, pn_length, largest_received_pn_[level_idx]);
 
    // Update largest received
    if (full_pn > largest_received_pn_[level_idx])
    {
        largest_received_pn_[level_idx] = full_pn;
    }
 
    // Decrypt packet payload
    size_t payload_offset = pn_offset + pn_length;
    auto unprotect_result = packet_protection::unprotect(
        keys_result.value(),
        std::span(packet_copy),
        payload_offset,
        full_pn);
 
    if (unprotect_result.is_err())
    {
        return;
    }
 
    auto& [unprotected_header, payload] = unprotect_result.value();
 
    // Parse frames from payload
    auto frames_result = frame_parser::parse_all(payload);
    if (frames_result.is_err())
    {
        return;
    }
 
    // Process each frame
    for (const auto& f : frames_result.value())
    {
        process_frame(f);
    }
 
    // Send any pending responses
    send_pending_packets();
}

References kcenon::network::protocols::quic::packet_number::decode(), kcenon::network::internal::handshake, kcenon::network::internal::handshake_start, kcenon::network::protocols::quic::hp_sample_size, kcenon::network::protocols::quic::frame_parser::parse_all(), kcenon::network::protocols::quic::packet_parser::parse_header(), kcenon::network::internal::server, kcenon::network::protocols::quic::packet_protection::unprotect(), and kcenon::network::protocols::quic::packet_protection::unprotect_header().

Here is the call graph for this function:

is_connected()

auto kcenon::network::internal::quic_socket::is_connected ( ) const -> bool

nodiscardnoexcept

Check if the connection is established.

Returns

True if connected

Definition at line 402 of file quic_socket.cpp.

{
    return state_.load() == quic_connection_state::connected;
}

References kcenon::network::internal::connected, and state_.

is_handshake_complete()

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

nodiscardnoexcept

Check if the TLS handshake is complete.

Returns

True if handshake is done

Definition at line 407 of file quic_socket.cpp.

{
    return handshake_complete_.load();
}

References handshake_complete_.

local_connection_id()

auto kcenon::network::internal::quic_socket::local_connection_id ( ) const -> const protocols::quic::connection_id&

nodiscard

Get the local connection ID.

Returns

Local connection ID

Definition at line 427 of file quic_socket.cpp.

{
    return local_conn_id_;
}

References local_conn_id_.

on_retransmit_timeout()

auto kcenon::network::internal::quic_socket::on_retransmit_timeout ( ) -> void

private

Retransmission timeout handler.

Definition at line 945 of file quic_socket.cpp.

{
    // Retransmission logic would go here
    // For now, just resend pending packets
    send_pending_packets();
}

operator=() [1/2]

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

delete

operator=() [2/2]

quic_socket & kcenon::network::internal::quic_socket::operator= ( quic_socket && other )

noexcept

Definition at line 69 of file quic_socket.cpp.

{
    if (this != &other)
    {
        stop_receive();
 
        udp_socket_ = std::move(other.udp_socket_);
        remote_endpoint_ = std::move(other.remote_endpoint_);
        recv_buffer_ = std::move(other.recv_buffer_);
        role_ = other.role_;
        state_.store(other.state_.load());
        crypto_ = std::move(other.crypto_);
        local_conn_id_ = std::move(other.local_conn_id_);
        remote_conn_id_ = std::move(other.remote_conn_id_);
        next_packet_number_ = other.next_packet_number_;
        largest_received_pn_ = other.largest_received_pn_;
        next_stream_id_ = other.next_stream_id_;
        pending_crypto_data_ = std::move(other.pending_crypto_data_);
        pending_stream_data_ = std::move(other.pending_stream_data_);
 
        std::lock_guard<std::mutex> lock(callback_mutex_);
        stream_data_cb_ = std::move(other.stream_data_cb_);
        connected_cb_ = std::move(other.connected_cb_);
        error_cb_ = std::move(other.error_cb_);
        close_cb_ = std::move(other.close_cb_);
 
        is_receiving_.store(other.is_receiving_.load());
        handshake_complete_.store(other.handshake_complete_.load());
        retransmit_timer_ = std::move(other.retransmit_timer_);
        idle_timer_ = std::move(other.idle_timer_);
    }
    return *this;
}

process_ack_frame()

auto kcenon::network::internal::quic_socket::process_ack_frame ( const protocols::quic::ack_frame & f ) -> void

private

Process ACK frame.

Parameters

f

ACK frame

Definition at line 715 of file quic_socket.cpp.

{
    // Process ACK - remove acknowledged packets from retransmission queue
    // For now, just track the largest acknowledged
    (void)f;  // Placeholder for full implementation
}

process_connection_close_frame()

auto kcenon::network::internal::quic_socket::process_connection_close_frame ( const protocols::quic::connection_close_frame & f ) -> void

private

Process CONNECTION_CLOSE frame.

Parameters

f	Connection close frame

Definition at line 722 of file quic_socket.cpp.

{
    transition_state(quic_connection_state::draining);
 
    std::lock_guard<std::mutex> lock(callback_mutex_);
    if (close_cb_)
    {
        close_cb_(f.error_code, f.reason_phrase);
    }
 
    // Enter draining period
    idle_timer_.expires_after(std::chrono::milliseconds(300));
    idle_timer_.async_wait(
        [self = shared_from_this()](const std::error_code& ec)
        {
            if (!ec)
            {
                self->transition_state(quic_connection_state::closed);
                self->stop_receive();
            }
        });
}

References kcenon::network::internal::closed, and kcenon::network::internal::draining.

process_crypto_frame()

auto kcenon::network::internal::quic_socket::process_crypto_frame ( const protocols::quic::crypto_frame & f ) -> void

private

Process CRYPTO frame data.

Parameters

f	Crypto frame

Definition at line 653 of file quic_socket.cpp.

{
    auto level = crypto_.current_level();
 
    // Process the crypto data through TLS
    auto response_result = crypto_.process_crypto_data(level, f.data);
    if (response_result.is_err())
    {
        return;
    }
 
    // Queue any response crypto data
    if (!response_result.value().empty())
    {
        queue_crypto_data(std::move(response_result.value()));
    }
 
    // Check if handshake is now complete
    if (crypto_.is_handshake_complete() && !handshake_complete_.load())
    {
        handshake_complete_.store(true);
 
        // For client, transition to connected
        // For server, we send HANDSHAKE_DONE
        if (role_ == quic_role::client)
        {
            transition_state(quic_connection_state::connected);
 
            std::lock_guard<std::mutex> lock(callback_mutex_);
            if (connected_cb_)
            {
                connected_cb_();
            }
        }
        else
        {
            // Server sends HANDSHAKE_DONE
            std::vector<frame> frames;
            frames.push_back(handshake_done_frame{});
 
            (void)send_packet(encryption_level::application, std::move(frames));
 
            transition_state(quic_connection_state::connected);
 
            std::lock_guard<std::mutex> lock(callback_mutex_);
            if (connected_cb_)
            {
                connected_cb_();
            }
        }
    }
}

References kcenon::network::internal::client, and kcenon::network::internal::connected.

process_frame()

auto kcenon::network::internal::quic_socket::process_frame ( const protocols::quic::frame & f ) -> void

private

Process a parsed frame.

Parameters

f	Frame to process

Definition at line 616 of file quic_socket.cpp.

{
    std::visit([this](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;
 
        if constexpr (std::is_same_v<T, crypto_frame>)
        {
            process_crypto_frame(arg);
        }
        else if constexpr (std::is_same_v<T, stream_frame>)
        {
            process_stream_frame(arg);
        }
        else if constexpr (std::is_same_v<T, ack_frame>)
        {
            process_ack_frame(arg);
        }
        else if constexpr (std::is_same_v<T, connection_close_frame>)
        {
            process_connection_close_frame(arg);
        }
        else if constexpr (std::is_same_v<T, handshake_done_frame>)
        {
            process_handshake_done_frame();
        }
        else if constexpr (std::is_same_v<T, ping_frame>)
        {
            // PING requires ACK - will be sent with next packet
        }
        else if constexpr (std::is_same_v<T, padding_frame>)
        {
            // PADDING is ignored
        }
        // Other frame types can be added as needed
    }, f);
}

process_handshake_done_frame()

auto kcenon::network::internal::quic_socket::process_handshake_done_frame ( ) -> void

private

Process HANDSHAKE_DONE frame.

Definition at line 745 of file quic_socket.cpp.

{
    // Client receives HANDSHAKE_DONE
    if (role_ == quic_role::client && !handshake_complete_.load())
    {
        handshake_complete_.store(true);
        transition_state(quic_connection_state::connected);
 
        std::lock_guard<std::mutex> lock(callback_mutex_);
        if (connected_cb_)
        {
            connected_cb_();
        }
    }
}

References kcenon::network::internal::client, and kcenon::network::internal::connected.

process_stream_frame()

auto kcenon::network::internal::quic_socket::process_stream_frame ( const protocols::quic::stream_frame & f ) -> void

private

Process STREAM frame data.

Parameters

f	Stream frame

Definition at line 706 of file quic_socket.cpp.

{
    std::lock_guard<std::mutex> lock(callback_mutex_);
    if (stream_data_cb_)
    {
        stream_data_cb_(f.stream_id, f.data, f.fin);
    }
}

queue_crypto_data()

auto kcenon::network::internal::quic_socket::queue_crypto_data ( std::vector< uint8_t > && data ) -> void

private

Queue crypto data for sending.

Parameters

data	Crypto data to send

Definition at line 896 of file quic_socket.cpp.

{
    auto level = crypto_.current_level();
    auto level_idx = static_cast<size_t>(level);
 
    std::lock_guard<std::mutex> lock(state_mutex_);
    pending_crypto_data_[level_idx].push_back(std::move(data));
}

remote_connection_id()

auto kcenon::network::internal::quic_socket::remote_connection_id ( ) const -> const protocols::quic::connection_id&

nodiscard

Get the remote connection ID.

Returns

Remote connection ID

Definition at line 432 of file quic_socket.cpp.

{
    return remote_conn_id_;
}

References remote_conn_id_.

remote_endpoint()

auto kcenon::network::internal::quic_socket::remote_endpoint ( ) const -> asio::ip::udp::endpoint

nodiscard

Get the remote endpoint.

Returns

Remote endpoint

Definition at line 422 of file quic_socket.cpp.

{
    return remote_endpoint_;
}

References remote_endpoint_.

role()

auto kcenon::network::internal::quic_socket::role ( ) const -> quic_role

nodiscardnoexcept

Get the role (client or server)

Returns

Role

Definition at line 417 of file quic_socket.cpp.

{
    return role_;
}

References role_.

send_packet()

auto kcenon::network::internal::quic_socket::send_packet ( protocols::quic::encryption_level level, std::vector< protocols::quic::frame > && frames ) -> VoidResult

nodiscardprivate

Build and send a packet with frames.

Parameters

level	Encryption level
frames	Frames to include

Returns

Success or error

Definition at line 816 of file quic_socket.cpp.

{
    // Get write keys
    auto keys_result = crypto_.get_write_keys(level);
    if (keys_result.is_err())
    {
        return error_void(
            error_codes::common_errors::not_initialized,
            "Write keys not available",
            "quic_socket");
    }
 
    // Build frames payload
    std::vector<uint8_t> payload;
    for (const auto& f : frames)
    {
        auto frame_bytes = frame_builder::build(f);
        payload.insert(payload.end(), frame_bytes.begin(), frame_bytes.end());
    }
 
    // Get next packet number
    auto level_idx = static_cast<size_t>(level);
    uint64_t pn = next_packet_number_[level_idx]++;
 
    // Build header
    std::vector<uint8_t> header;
    if (level == encryption_level::initial)
    {
        header = packet_builder::build_initial(
            remote_conn_id_, local_conn_id_, {}, pn);
    }
    else if (level == encryption_level::handshake)
    {
        header = packet_builder::build_handshake(
            remote_conn_id_, local_conn_id_, pn);
    }
    else
    {
        header = packet_builder::build_short(
            remote_conn_id_, pn, crypto_.key_phase());
    }
 
    // Protect (encrypt) the packet
    auto protect_result = packet_protection::protect(
        keys_result.value(), header, payload, pn);
 
    if (protect_result.is_err())
    {
        return error_void(
            error_codes::common_errors::internal_error,
            "Failed to protect packet",
            "quic_socket",
            protect_result.error().message);
    }
 
    // Send the packet
    auto& protected_packet = protect_result.value();
 
    auto self = shared_from_this();
    auto buffer = std::make_shared<std::vector<uint8_t>>(std::move(protected_packet));
 
    udp_socket_.async_send_to(
        asio::buffer(*buffer),
        remote_endpoint_,
        [self, buffer](std::error_code ec, std::size_t /*bytes_sent*/)
        {
            if (ec && ec != asio::error::operation_aborted)
            {
                std::lock_guard<std::mutex> lock(self->callback_mutex_);
                if (self->error_cb_)
                {
                    self->error_cb_(ec);
                }
            }
        });
 
    return ok();
}

References kcenon::network::protocols::quic::frame_builder::build(), kcenon::network::protocols::quic::packet_builder::build_handshake(), kcenon::network::protocols::quic::packet_builder::build_initial(), kcenon::network::protocols::quic::packet_builder::build_short(), kcenon::network::error_void(), kcenon::network::error_codes::common_errors::internal_error, kcenon::network::error_codes::common_errors::not_initialized, kcenon::network::ok(), and kcenon::network::protocols::quic::packet_protection::protect().

Here is the call graph for this function:

send_pending_packets()

auto kcenon::network::internal::quic_socket::send_pending_packets ( ) -> void

private

Send pending outgoing packets.

Definition at line 761 of file quic_socket.cpp.

{
    auto current_state = state_.load();
    if (current_state == quic_connection_state::closed ||
        current_state == quic_connection_state::idle)
    {
        return;
    }
 
    // Determine which encryption level to use
    encryption_level level = crypto_.current_level();
 
    std::vector<frame> frames;
 
    // Add pending CRYPTO data
    {
        std::lock_guard<std::mutex> lock(state_mutex_);
        auto level_idx = static_cast<size_t>(level);
        while (!pending_crypto_data_[level_idx].empty())
        {
            auto& data = pending_crypto_data_[level_idx].front();
            crypto_frame cf;
            cf.offset = 0;  // Simplified - full impl needs offset tracking
            cf.data = std::move(data);
            frames.push_back(std::move(cf));
            pending_crypto_data_[level_idx].pop_front();
        }
    }
 
    // Add pending STREAM data (only if connected)
    if (is_connected())
    {
        std::lock_guard<std::mutex> lock(state_mutex_);
        for (auto& [stream_id, queue] : pending_stream_data_)
        {
            while (!queue.empty())
            {
                auto& [data, fin] = queue.front();
                stream_frame sf;
                sf.stream_id = stream_id;
                sf.offset = 0;  // Simplified - full impl needs offset tracking
                sf.data = std::move(data);
                sf.fin = fin;
                frames.push_back(std::move(sf));
                queue.pop_front();
            }
        }
    }
 
    if (!frames.empty())
    {
        (void)send_packet(level, std::move(frames));
    }
}

References kcenon::network::internal::closed, kcenon::network::protocols::quic::crypto_frame::data, kcenon::network::protocols::quic::stream_frame::data, kcenon::network::protocols::quic::stream_frame::fin, kcenon::network::internal::idle, kcenon::network::protocols::quic::crypto_frame::offset, kcenon::network::protocols::quic::stream_frame::offset, and kcenon::network::protocols::quic::stream_frame::stream_id.

send_stream_data()

auto kcenon::network::internal::quic_socket::send_stream_data ( uint64_t stream_id, std::vector< uint8_t > && data, bool fin = false ) -> VoidResult

nodiscard

Send data on a stream.

Parameters

stream_id	Target stream ID
data	Data to send (moved for efficiency)
fin	True if this is the final data on the stream

Returns

Success or error

Definition at line 315 of file quic_socket.cpp.

{
    if (!is_connected())
    {
        return error_void(
            error_codes::network_system::connection_failed,
            "Connection not established",
            "quic_socket");
    }
 
    {
        std::lock_guard<std::mutex> lock(state_mutex_);
        pending_stream_data_[stream_id].push_back({std::move(data), fin});
    }
 
    send_pending_packets();
 
    return ok();
}

References kcenon::network::error_codes::network_system::connection_failed, kcenon::network::error_void(), and kcenon::network::ok().

Here is the call graph for this function:

set_close_callback()

auto kcenon::network::internal::quic_socket::set_close_callback

(

close_callback

cb

)

-> void

Set callback for connection close.

Parameters

cb	Callback function

Definition at line 125 of file quic_socket.cpp.

{
    std::lock_guard<std::mutex> lock(callback_mutex_);
    close_cb_ = std::move(cb);
}

set_connected_callback()

auto kcenon::network::internal::quic_socket::set_connected_callback

(

connected_callback

cb

)

-> void

Set callback for connection establishment.

Parameters

cb	Callback function

Definition at line 113 of file quic_socket.cpp.

{
    std::lock_guard<std::mutex> lock(callback_mutex_);
    connected_cb_ = std::move(cb);
}

set_error_callback()

auto kcenon::network::internal::quic_socket::set_error_callback

(

error_callback

cb

)

-> void

Set callback for errors.

Parameters

cb	Callback function

Definition at line 119 of file quic_socket.cpp.

{
    std::lock_guard<std::mutex> lock(callback_mutex_);
    error_cb_ = std::move(cb);
}

set_stream_data_callback()

auto kcenon::network::internal::quic_socket::set_stream_data_callback

(

stream_data_callback

cb

)

-> void

Set callback for stream data reception.

Parameters

cb	Callback function

Definition at line 107 of file quic_socket.cpp.

{
    std::lock_guard<std::mutex> lock(callback_mutex_);
    stream_data_cb_ = std::move(cb);
}

socket() [1/2]

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

inline

Access the underlying UDP socket.

Returns

Reference to the UDP socket

Definition at line 285 of file quic_socket.h.

{ return udp_socket_; }

References udp_socket_.

socket() [2/2]

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

inline

Access the underlying UDP socket (const)

Returns

Const reference to the UDP socket

Definition at line 291 of file quic_socket.h.

{ return udp_socket_; }

References udp_socket_.

start_receive()

auto kcenon::network::internal::quic_socket::start_receive

(

)

-> void

Start the receive loop.

Once called, the socket continuously receives UDP datagrams, processes QUIC packets, and invokes appropriate callbacks.

Definition at line 304 of file quic_socket.cpp.

{
    is_receiving_.store(true);
    do_receive();
}

state()

auto kcenon::network::internal::quic_socket::state ( ) const -> quic_connection_state

nodiscardnoexcept

Get the current connection state.

Returns

Connection state

Definition at line 412 of file quic_socket.cpp.

{
    return state_.load();
}

References state_.

stop_receive()

auto kcenon::network::internal::quic_socket::stop_receive

(

)

-> void

Stop the receive loop.

Definition at line 310 of file quic_socket.cpp.

{
    is_receiving_.store(false);
}

Referenced by ~quic_socket().

Here is the caller graph for this function:

transition_state()

auto kcenon::network::internal::quic_socket::transition_state ( quic_connection_state new_state ) -> void

private

Transition to a new connection state.

Parameters

new_state

New state

Definition at line 952 of file quic_socket.cpp.

{
    state_.store(new_state);
}

Member Data Documentation

callback_mutex_

std::mutex kcenon::network::internal::quic_socket::callback_mutex_

mutableprivate

Mutex for callback protection.

Definition at line 445 of file quic_socket.h.

close_cb_

close_callback kcenon::network::internal::quic_socket::close_cb_

private

Close callback.

Definition at line 457 of file quic_socket.h.

connected_cb_

connected_callback kcenon::network::internal::quic_socket::connected_cb_

private

Connected callback.

Definition at line 451 of file quic_socket.h.

crypto_

protocols::quic::quic_crypto kcenon::network::internal::quic_socket::crypto_

private

QUIC crypto handler.

Definition at line 413 of file quic_socket.h.

error_cb_

error_callback kcenon::network::internal::quic_socket::error_cb_

private

Error callback.

Definition at line 454 of file quic_socket.h.

handshake_complete_

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

private

Is handshake complete.

Definition at line 467 of file quic_socket.h.

{false};

Referenced by is_handshake_complete().

idle_timer_

asio::steady_timer kcenon::network::internal::quic_socket::idle_timer_

private

Idle timeout timer.

Definition at line 477 of file quic_socket.h.

Referenced by ~quic_socket().

is_receiving_

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

private

Is receive loop running.

Definition at line 464 of file quic_socket.h.

{false};

largest_received_pn_

std::array<uint64_t, 4> kcenon::network::internal::quic_socket::largest_received_pn_ {0, 0, 0, 0}

private

Largest received packet number for each level.

Definition at line 425 of file quic_socket.h.

{0, 0, 0, 0};

local_conn_id_

protocols::quic::connection_id kcenon::network::internal::quic_socket::local_conn_id_

private

Local connection ID.

Definition at line 416 of file quic_socket.h.

Referenced by local_connection_id(), and quic_socket().

next_packet_number_

std::array<uint64_t, 4> kcenon::network::internal::quic_socket::next_packet_number_ {0, 0, 0, 0}

private

Packet number for each encryption level.

Definition at line 422 of file quic_socket.h.

{0, 0, 0, 0};

next_stream_id_

uint64_t kcenon::network::internal::quic_socket::next_stream_id_ {0}

private

Next stream ID to allocate.

Definition at line 428 of file quic_socket.h.

{0};

Referenced by quic_socket().

pending_crypto_data_

std::array<std::deque<std::vector<uint8_t> >, 4> kcenon::network::internal::quic_socket::pending_crypto_data_

private

Pending crypto data to send per encryption level.

Definition at line 435 of file quic_socket.h.

pending_stream_data_

std::map<uint64_t, std::deque<std::pair<std::vector<uint8_t>, bool> > > kcenon::network::internal::quic_socket::pending_stream_data_

private

Pending stream data to send (stream_id -> data queue)

Definition at line 438 of file quic_socket.h.

recv_buffer_

std::array<uint8_t, 65536> kcenon::network::internal::quic_socket::recv_buffer_

private

Receive buffer (max UDP datagram size)

Definition at line 404 of file quic_socket.h.

remote_conn_id_

protocols::quic::connection_id kcenon::network::internal::quic_socket::remote_conn_id_

private

Remote connection ID.

Definition at line 419 of file quic_socket.h.

Referenced by remote_connection_id().

remote_endpoint_

asio::ip::udp::endpoint kcenon::network::internal::quic_socket::remote_endpoint_

private

Remote endpoint.

Definition at line 401 of file quic_socket.h.

Referenced by remote_endpoint().

retransmit_timer_

asio::steady_timer kcenon::network::internal::quic_socket::retransmit_timer_

private

Retransmission timer.

Definition at line 474 of file quic_socket.h.

Referenced by ~quic_socket().

role_

quic_role kcenon::network::internal::quic_socket::role_

private

Socket role (client/server)

Definition at line 407 of file quic_socket.h.

Referenced by quic_socket(), and role().

state_

std::atomic<quic_connection_state> kcenon::network::internal::quic_socket::state_ {quic_connection_state::idle}

private

Connection state.

Definition at line 410 of file quic_socket.h.

{quic_connection_state::idle};

Referenced by is_connected(), and state().

state_mutex_

std::mutex kcenon::network::internal::quic_socket::state_mutex_

mutableprivate

Mutex for state protection.

Definition at line 480 of file quic_socket.h.

stream_data_cb_

stream_data_callback kcenon::network::internal::quic_socket::stream_data_cb_

private

Stream data callback.

Definition at line 448 of file quic_socket.h.

udp_socket_

asio::ip::udp::socket kcenon::network::internal::quic_socket::udp_socket_

private

Underlying UDP socket.

Definition at line 398 of file quic_socket.h.

Referenced by socket(), and socket().

---

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

• src/internal/quic_socket.h
• src/internal/quic_socket.cpp