kcenon::network::protocols::quic::connection Class Reference

QUIC connection state machine (RFC 9000 Section 5) More...

#include <connection.h>

Collaboration diagram for kcenon::network::protocols::quic::connection:

Public Member Functions
	connection (bool is_server, const connection_id &initial_dcid)
	Construct a connection.
	~connection ()
	connection (const connection &)=delete
auto	operator= (const connection &) -> connection &=delete
	connection (connection &&)=delete
auto	operator= (connection &&) -> connection &=delete
auto	state () const noexcept -> connection_state
	Get current connection state.
auto	handshake_state () const noexcept -> enum handshake_state
	Get current handshake state.
auto	is_established () const noexcept -> bool
	Check if connection is established (handshake complete)
auto	is_draining () const noexcept -> bool
	Check if connection is draining or closing.
auto	is_closed () const noexcept -> bool
	Check if connection is closed.
auto	is_server () const noexcept -> bool
	Check if this is a server-side connection.
auto	local_cid () const -> const connection_id &
	Get local Connection ID.
auto	remote_cid () const -> const connection_id &
	Get remote Connection ID.
auto	initial_dcid () const -> const connection_id &
	Get initial Destination Connection ID (for key derivation)
auto	add_local_cid (const connection_id &cid, uint64_t sequence) -> VoidResult
	Add a new local Connection ID.
auto	retire_cid (uint64_t sequence) -> VoidResult
	Retire a Connection ID.
auto	peer_cid_manager () -> connection_id_manager &
	Get the peer connection ID manager.
auto	peer_cid_manager () const -> const connection_id_manager &
	Get the peer connection ID manager (const)
auto	active_peer_cid () const -> const connection_id &
	Get the currently active peer connection ID.
auto	rotate_peer_cid () -> VoidResult
	Rotate to a new peer connection ID.
void	set_local_params (const transport_parameters &params)
	Set local transport parameters.
void	set_remote_params (const transport_parameters &params)
	Set remote transport parameters.
auto	local_params () const -> const transport_parameters &
	Get local transport parameters.
auto	remote_params () const -> const transport_parameters &
	Get remote transport parameters.
auto	start_handshake (const std::string &server_name) -> Result< std::vector< uint8_t > >
	Start the handshake (client only)
auto	init_server_handshake (const std::string &cert_file, const std::string &key_file) -> VoidResult
	Initialize server handshake.
auto	receive_packet (std::span< const uint8_t > data) -> VoidResult
	Receive and process a packet.
auto	generate_packets () -> std::vector< std::vector< uint8_t > >
	Generate packets to send.
auto	has_pending_data () const -> bool
	Check if there are packets to send.
auto	streams () -> stream_manager &
	Get the stream manager.
auto	streams () const -> const stream_manager &
	Get the stream manager (const)
auto	flow_control () -> flow_controller &
	Get the connection-level flow controller.
auto	flow_control () const -> const flow_controller &
	Get the connection-level flow controller (const)
auto	close (uint64_t error_code, const std::string &reason="") -> VoidResult
	Close the connection.
auto	close_application (uint64_t error_code, const std::string &reason="") -> VoidResult
	Close connection due to application error.
auto	close_error_code () const -> std::optional< uint64_t >
	Get the close error code (if connection was closed)
auto	close_reason () const -> const std::string &
	Get the close reason (if connection was closed)
auto	next_timeout () const -> std::optional< std::chrono::steady_clock::time_point >
	Get the next timeout deadline.
void	on_timeout ()
	Handle timeout event.
auto	idle_deadline () const -> std::chrono::steady_clock::time_point
	Get idle timeout deadline.
auto	crypto () -> quic_crypto &
	Get crypto handler.
auto	crypto () const -> const quic_crypto &
	Get crypto handler (const)
auto	path_mtu () const noexcept -> size_t
	Get current path MTU.
void	enable_pmtud ()
	Enable Path MTU Discovery.
void	disable_pmtud ()
	Disable Path MTU Discovery.
auto	pmtud_enabled () const noexcept -> bool
	Check if PMTUD is enabled.
auto	pmtud () -> pmtud_controller &
	Get the PMTUD controller.
auto	pmtud () const -> const pmtud_controller &
	Get the PMTUD controller (const)
auto	bytes_sent () const noexcept -> uint64_t
	Get total bytes sent.
auto	bytes_received () const noexcept -> uint64_t
	Get total bytes received.
auto	packets_sent () const noexcept -> uint64_t
	Get packets sent count.
auto	packets_received () const noexcept -> uint64_t
	Get packets received count.

Private Member Functions
auto	process_long_header_packet (const long_header &hdr, std::span< const uint8_t > payload) -> VoidResult
	Process a long header packet.
auto	process_short_header_packet (const short_header &hdr, std::span< const uint8_t > payload) -> VoidResult
	Process a short header packet.
auto	process_frames (std::span< const uint8_t > payload, encryption_level level) -> VoidResult
	Process frames from a decrypted packet.
auto	handle_frame (const frame &frame, encryption_level level) -> VoidResult
	Handle a specific frame.
auto	build_packet (encryption_level level) -> std::vector< uint8_t >
	Build a packet at the given encryption level.
auto	get_pn_space (encryption_level level) -> packet_number_space &
	Get packet number space for an encryption level.
auto	get_pn_space (encryption_level level) const -> const packet_number_space &
void	update_state ()
	Update connection state based on handshake progress.
void	reset_idle_timer ()
	Reset idle timer.
void	enter_draining ()
	Transition to draining state.
void	enter_closing ()
	Transition to closing state.
void	apply_remote_params ()
	Apply remote transport parameters.
auto	generate_ack_frame (const packet_number_space &space) -> std::optional< ack_frame >
	Generate ACK frame for a packet number space.
void	handle_loss_detection_result (const loss_detection_result &result)
	Handle loss detection result (RFC 9002)
void	generate_probe_packets ()
	Generate probe packets for PTO (RFC 9002 Section 6.2.4) Sends one or two ack-eliciting packets to probe for acknowledgment.
void	queue_frames_for_retransmission (const sent_packet &lost_packet)
	Queue frames from lost packet for retransmission.
auto	to_sent_packet (const sent_packet_info &info) const -> sent_packet
	Convert sent_packet_info to sent_packet for loss detector.

Private Attributes
bool	is_server_
connection_state	state_ {connection_state::idle}
connection_id	local_cid_
connection_id	remote_cid_
connection_id	initial_dcid_
std::vector< std::pair< uint64_t, connection_id > >	local_cids_
uint64_t	next_cid_sequence_ {1}
connection_id_manager	peer_cid_manager_
transport_parameters	local_params_
transport_parameters	remote_params_
quic_crypto	crypto_
stream_manager	stream_mgr_
flow_controller	flow_ctrl_
rtt_estimator	rtt_estimator_
loss_detector	loss_detector_
congestion_controller	congestion_controller_
pmtud_controller	pmtud_controller_
packet_number_space	initial_space_
packet_number_space	handshake_space_
packet_number_space	app_space_
std::deque< std::vector< uint8_t > >	pending_crypto_initial_
std::deque< std::vector< uint8_t > >	pending_crypto_handshake_
std::deque< std::vector< uint8_t > >	pending_crypto_app_
bool	pending_ack_initial_ {false}
bool	pending_ack_handshake_ {false}
bool	pending_ack_app_ {false}
std::deque< frame >	pending_frames_
bool	close_sent_ {false}
bool	close_received_ {false}
std::optional< uint64_t >	close_error_code_
std::string	close_reason_
bool	application_close_ {false}
std::chrono::steady_clock::time_point	idle_deadline_
std::chrono::steady_clock::time_point	pto_deadline_
std::chrono::steady_clock::time_point	drain_deadline_
uint64_t	bytes_sent_ {0}
uint64_t	bytes_received_ {0}
uint64_t	packets_sent_ {0}
uint64_t	packets_received_ {0}

Detailed Description

QUIC connection state machine (RFC 9000 Section 5)

Manages the complete lifecycle of a QUIC connection including:

• TLS handshake via QUIC-TLS integration
• Packet number spaces (Initial, Handshake, Application)
• Transport parameters negotiation
• Stream management
• Flow control
• Connection termination

Definition at line 157 of file connection.h.

Constructor & Destructor Documentation

connection() [1/3]

kcenon::network::protocols::quic::connection::connection	(	bool	is_server,
		const connection_id &	initial_dcid )

Construct a connection.

Parameters

is_server	True for server-side, false for client-side
initial_dcid	Initial Destination Connection ID

Definition at line 63 of file connection.cpp.

    : is_server_(is_server)
    , initial_dcid_(initial_dcid)
    , peer_cid_manager_(8)  // Default active_connection_id_limit
    , stream_mgr_(is_server)
    , flow_ctrl_(1048576)  // 1MB default
    , loss_detector_(rtt_estimator_)
{
    // Generate local connection ID
    local_cid_ = connection_id::generate();
    local_cids_.emplace_back(0, local_cid_);
 
    // For client: remote CID is the initial DCID
    // For server: remote CID will be set when we receive client's SCID
    if (!is_server)
    {
        remote_cid_ = initial_dcid;
        peer_cid_manager_.set_initial_peer_cid(initial_dcid);
    }
 
    // Initialize default transport parameters
    if (is_server)
    {
        local_params_ = make_default_server_params();
    }
    else
    {
        local_params_ = make_default_client_params();
    }
 
    // Set initial source connection ID
    local_params_.initial_source_connection_id = local_cid_;
 
    // Initialize idle timer
    reset_idle_timer();
}

References kcenon::network::protocols::quic::connection_id::generate(), initial_dcid(), kcenon::network::protocols::quic::transport_parameters::initial_source_connection_id, is_server(), local_cid_, local_cids_, local_params_, kcenon::network::protocols::quic::make_default_client_params(), kcenon::network::protocols::quic::make_default_server_params(), peer_cid_manager_, remote_cid_, reset_idle_timer(), and kcenon::network::protocols::quic::connection_id_manager::set_initial_peer_cid().

Here is the call graph for this function:

~connection()

kcenon::network::protocols::quic::connection::~connection ( )

default

connection() [2/3]

kcenon::network::protocols::quic::connection::connection ( const connection & )

delete

connection() [3/3]

kcenon::network::protocols::quic::connection::connection ( connection && )

delete

Member Function Documentation

active_peer_cid()

auto kcenon::network::protocols::quic::connection::active_peer_cid ( ) const -> const connection_id&

nodiscard

Get the currently active peer connection ID.

This returns the peer CID that should be used in outgoing packets. It may differ from remote_cid() if CID rotation has occurred.

Definition at line 1540 of file connection.cpp.

{
    // If peer CID manager has CIDs, use the active one
    if (peer_cid_manager_.peer_cid_count() > 0)
    {
        return peer_cid_manager_.get_active_peer_cid();
    }
    // Fall back to remote_cid_ for backward compatibility
    return remote_cid_;
}

References kcenon::network::protocols::quic::connection_id_manager::get_active_peer_cid(), kcenon::network::protocols::quic::connection_id_manager::peer_cid_count(), peer_cid_manager_, and remote_cid_.

Here is the call graph for this function:

add_local_cid()

auto kcenon::network::protocols::quic::connection::add_local_cid ( const connection_id & cid, uint64_t sequence ) -> VoidResult

nodiscard

Add a new local Connection ID.

Parameters

cid	Connection ID to add
sequence	Sequence number for this CID

Returns

Success or error

Definition at line 108 of file connection.cpp.

{
    // Check for duplicates
    for (const auto& [seq, existing_cid] : local_cids_)
    {
        if (seq == sequence)
        {
            return error_void(connection_error::protocol_violation,
                              "Duplicate connection ID sequence",
                              "connection");
        }
    }
 
    local_cids_.emplace_back(sequence, cid);
    return ok();
}

References kcenon::network::error_void(), kcenon::network::ok(), and kcenon::network::protocols::quic::connection_error::protocol_violation.

Here is the call graph for this function:

apply_remote_params()

void kcenon::network::protocols::quic::connection::apply_remote_params ( )

private

Apply remote transport parameters.

Definition at line 170 of file connection.cpp.

{
    // Apply to flow control
    flow_ctrl_.update_send_limit(remote_params_.initial_max_data);
 
    // Apply to stream manager
    stream_mgr_.set_peer_max_streams_bidi(remote_params_.initial_max_streams_bidi);
    stream_mgr_.set_peer_max_streams_uni(remote_params_.initial_max_streams_uni);
 
    // Apply to peer CID manager
    peer_cid_manager_.set_active_cid_limit(remote_params_.active_connection_id_limit);
 
    // Update idle timeout
    if (remote_params_.max_idle_timeout > 0)
    {
        auto timeout = std::min(local_params_.max_idle_timeout,
                                remote_params_.max_idle_timeout);
        if (timeout > 0)
        {
            idle_deadline_ = std::chrono::steady_clock::now() +
                             std::chrono::milliseconds(timeout);
        }
    }
}

References kcenon::network::protocols::quic::transport_parameters::active_connection_id_limit, flow_ctrl_, idle_deadline_, kcenon::network::protocols::quic::transport_parameters::initial_max_data, kcenon::network::protocols::quic::transport_parameters::initial_max_streams_bidi, kcenon::network::protocols::quic::transport_parameters::initial_max_streams_uni, local_params_, kcenon::network::protocols::quic::transport_parameters::max_idle_timeout, peer_cid_manager_, remote_params_, kcenon::network::protocols::quic::connection_id_manager::set_active_cid_limit(), kcenon::network::protocols::quic::stream_manager::set_peer_max_streams_bidi(), kcenon::network::protocols::quic::stream_manager::set_peer_max_streams_uni(), stream_mgr_, and kcenon::network::protocols::quic::flow_controller::update_send_limit().

Referenced by set_remote_params().

Here is the call graph for this function:

Here is the caller graph for this function:

build_packet()

auto kcenon::network::protocols::quic::connection::build_packet ( encryption_level level ) -> std::vector<uint8_t>

nodiscardprivate

Build a packet at the given encryption level.

Definition at line 846 of file connection.cpp.

{
    std::vector<uint8_t> packet;
 
    // Get keys for this level
    auto keys_result = crypto_.get_write_keys(level);
    if (keys_result.is_err())
    {
        return packet;
    }
 
    auto& space = get_pn_space(level);
    uint64_t pn = space.next_pn++;
 
    // Build header
    std::vector<uint8_t> header;
    switch (level)
    {
    case encryption_level::initial:
        header = packet_builder::build_initial(
            remote_cid_, local_cid_, {}, pn);
        break;
    case encryption_level::handshake:
        header = packet_builder::build_handshake(
            remote_cid_, local_cid_, pn);
        break;
    case encryption_level::application:
        header = packet_builder::build_short(
            remote_cid_, pn, crypto_.key_phase());
        break;
    default:
        return packet;
    }
 
    // Build payload with frames
    std::vector<uint8_t> payload;
 
    // Add ACK frame if needed
    if (space.ack_needed)
    {
        auto ack = generate_ack_frame(space);
        if (ack)
        {
            auto encoded = frame_builder::build_ack(*ack);
            payload.insert(payload.end(), encoded.begin(), encoded.end());
            space.ack_needed = false;
        }
    }
 
    // Add CRYPTO frames
    std::deque<std::vector<uint8_t>>* crypto_queue = nullptr;
    switch (level)
    {
    case encryption_level::initial:
        crypto_queue = &pending_crypto_initial_;
        break;
    case encryption_level::handshake:
        crypto_queue = &pending_crypto_handshake_;
        break;
    default:
        crypto_queue = &pending_crypto_app_;
        break;
    }
 
    uint64_t crypto_offset = 0;
    while (!crypto_queue->empty())
    {
        auto& data = crypto_queue->front();
        crypto_frame cf;
        cf.offset = crypto_offset;
        cf.data = std::move(data);
        crypto_offset += cf.data.size();
 
        auto encoded = frame_builder::build_crypto(cf);
        payload.insert(payload.end(), encoded.begin(), encoded.end());
        crypto_queue->pop_front();
    }
 
    // Add HANDSHAKE_DONE for server
    if (level == encryption_level::application && is_server_ &&
        hs_state_ == handshake_state::complete && state_ == connection_state::connected)
    {
        handshake_done_frame hd;
        auto encoded = frame_builder::build(hd);
        payload.insert(payload.end(), encoded.begin(), encoded.end());
    }
 
    // Add CONNECTION_CLOSE if closing
    if (close_sent_)
    {
        connection_close_frame ccf;
        ccf.error_code = close_error_code_.value_or(0);
        ccf.reason_phrase = close_reason_;
        ccf.is_application_error = application_close_;
        auto encoded = frame_builder::build(ccf);
        payload.insert(payload.end(), encoded.begin(), encoded.end());
    }
 
    // Add RETIRE_CONNECTION_ID frames for application level
    if (level == encryption_level::application && !close_sent_)
    {
        auto retire_frames = peer_cid_manager_.get_pending_retire_frames();
        for (const auto& rf : retire_frames)
        {
            auto encoded = frame_builder::build(rf);
            payload.insert(payload.end(), encoded.begin(), encoded.end());
        }
        if (!retire_frames.empty())
        {
            peer_cid_manager_.clear_pending_retire_frames();
        }
    }
 
    // Add pending frames (e.g., PING from PTO probing)
    if (!close_sent_)
    {
        while (!pending_frames_.empty())
        {
            const auto& f = pending_frames_.front();
            auto encoded = frame_builder::build(f);
            payload.insert(payload.end(), encoded.begin(), encoded.end());
            pending_frames_.pop_front();
        }
    }
 
    // Add stream data frames for application level
    if (level == encryption_level::application && !close_sent_)
    {
        auto streams = stream_mgr_.streams_with_pending_data();
        for (auto* s : streams)
        {
            if (auto sf = s->next_stream_frame(1200))
            {
                auto encoded = frame_builder::build_stream(*sf);
                payload.insert(payload.end(), encoded.begin(), encoded.end());
            }
        }
    }
 
    if (payload.empty())
    {
        return packet;
    }
 
    // Add padding for Initial packets to meet minimum size
    if (level == encryption_level::initial)
    {
        size_t min_size = 1200;
        size_t current_size = header.size() + payload.size() + 16; // +16 for AEAD tag
        if (current_size < min_size)
        {
            auto encoded = frame_builder::build_padding(min_size - current_size);
            payload.insert(payload.end(), encoded.begin(), encoded.end());
        }
    }
 
    // Encrypt and protect the packet
    auto protect_result = packet_protection::protect(
        keys_result.value(),
        std::span<const uint8_t>(header.data(), header.size()),
        std::span<const uint8_t>(payload.data(), payload.size()),
        pn);
 
    if (protect_result.is_err())
    {
        return {};
    }
 
    packet = std::move(protect_result.value());
 
    // Track sent packet for local state
    sent_packet_info info;
    info.packet_number = pn;
    info.sent_time = std::chrono::steady_clock::now();
    info.sent_bytes = packet.size();
    info.ack_eliciting = !payload.empty();
    info.in_flight = true;
    info.level = level;
    // Note: frames are not stored here as the current implementation
    // doesn't track individual frames in build_packet.
    // For full retransmission support, frames would need to be collected
    // during packet building and stored here.
 
    // Notify loss detector about sent packet (RFC 9002)
    sent_packet sent_pkt;
    sent_pkt.packet_number = info.packet_number;
    sent_pkt.sent_time = info.sent_time;
    sent_pkt.sent_bytes = info.sent_bytes;
    sent_pkt.ack_eliciting = info.ack_eliciting;
    sent_pkt.in_flight = info.in_flight;
    sent_pkt.level = info.level;
    loss_detector_.on_packet_sent(sent_pkt);
 
    // Notify congestion controller about sent packet
    if (info.in_flight)
    {
        congestion_controller_.on_packet_sent(info.sent_bytes);
    }
 
    space.sent_packets[pn] = std::move(info);
 
    bytes_sent_ += packet.size();
    packets_sent_++;
 
    return packet;
}

References kcenon::network::protocols::quic::ack, kcenon::network::protocols::quic::sent_packet::ack_eliciting, kcenon::network::protocols::quic::application, kcenon::network::protocols::quic::frame_builder::build(), kcenon::network::protocols::quic::frame_builder::build_ack(), kcenon::network::protocols::quic::frame_builder::build_crypto(), kcenon::network::protocols::quic::packet_builder::build_handshake(), kcenon::network::protocols::quic::packet_builder::build_initial(), kcenon::network::protocols::quic::frame_builder::build_padding(), kcenon::network::protocols::quic::packet_builder::build_short(), kcenon::network::protocols::quic::frame_builder::build_stream(), kcenon::network::protocols::quic::complete, kcenon::network::protocols::quic::connected, kcenon::network::protocols::quic::crypto_frame::data, kcenon::network::protocols::quic::connection_close_frame::error_code, kcenon::network::protocols::quic::handshake, kcenon::network::protocols::quic::sent_packet::in_flight, kcenon::network::protocols::quic::initial, kcenon::network::protocols::quic::connection_close_frame::is_application_error, kcenon::network::protocols::quic::sent_packet::level, kcenon::network::protocols::quic::crypto_frame::offset, kcenon::network::protocols::quic::sent_packet::packet_number, kcenon::network::protocols::quic::packet_protection::protect(), kcenon::network::protocols::quic::connection_close_frame::reason_phrase, kcenon::network::protocols::quic::sent_packet::sent_bytes, and kcenon::network::protocols::quic::sent_packet::sent_time.

Here is the call graph for this function:

bytes_received()

auto kcenon::network::protocols::quic::connection::bytes_received ( ) const -> uint64_t

inlinenodiscardnoexcept

Get total bytes received.

Definition at line 518 of file connection.h.

{ return bytes_received_; }

References bytes_received_.

bytes_sent()

auto kcenon::network::protocols::quic::connection::bytes_sent ( ) const -> uint64_t

inlinenodiscardnoexcept

Get total bytes sent.

Definition at line 513 of file connection.h.

{ return bytes_sent_; }

References bytes_sent_.

close()

auto kcenon::network::protocols::quic::connection::close ( uint64_t error_code, const std::string & reason = "" ) -> VoidResult

nodiscard

Close the connection.

Parameters

error_code	Error code (0 for normal close)
reason	Optional reason phrase

Returns

Success or error

Definition at line 1137 of file connection.cpp.

{
    auto span = tracing::is_tracing_enabled()
        ? std::make_optional(tracing::trace_context::create_span("quic.connection.close"))
        : std::nullopt;
    if (span)
    {
        span->set_attribute("quic.close.error_code", static_cast<int64_t>(error_code))
             .set_attribute("quic.close.reason", reason)
             .set_attribute("quic.close.type", "transport")
             .set_attribute("quic.role", is_server_ ? "server" : "client");
    }
 
    // Already closing or closed - don't update error state
    if (is_closed() || is_draining())
    {
        if (span)
        {
            span->set_attribute("quic.close.already_closing", true);
        }
        return ok();
    }
 
    close_error_code_ = error_code;
    close_reason_ = reason;
    close_sent_ = true;
    application_close_ = false;
    enter_closing();
 
    if (span)
    {
        span->set_attribute("quic.state", "closing");
    }
 
    return ok();
}

References kcenon::network::tracing::trace_context::create_span(), kcenon::network::tracing::is_tracing_enabled(), and kcenon::network::ok().

Here is the call graph for this function:

close_application()

auto kcenon::network::protocols::quic::connection::close_application ( uint64_t error_code, const std::string & reason = "" ) -> VoidResult

nodiscard

Close connection due to application error.

Parameters

error_code	Application-level error code
reason	Optional reason phrase

Returns

Success or error

Definition at line 1174 of file connection.cpp.

{
    auto span = tracing::is_tracing_enabled()
        ? std::make_optional(tracing::trace_context::create_span("quic.connection.close_application"))
        : std::nullopt;
    if (span)
    {
        span->set_attribute("quic.close.error_code", static_cast<int64_t>(error_code))
             .set_attribute("quic.close.reason", reason)
             .set_attribute("quic.close.type", "application")
             .set_attribute("quic.role", is_server_ ? "server" : "client");
    }
 
    // Already closing or closed - don't update error state
    if (is_closed() || is_draining())
    {
        if (span)
        {
            span->set_attribute("quic.close.already_closing", true);
        }
        return ok();
    }
 
    close_error_code_ = error_code;
    close_reason_ = reason;
    close_sent_ = true;
    application_close_ = true;
    enter_closing();
 
    if (span)
    {
        span->set_attribute("quic.state", "closing");
    }
 
    return ok();
}

References kcenon::network::tracing::trace_context::create_span(), kcenon::network::tracing::is_tracing_enabled(), and kcenon::network::ok().

Here is the call graph for this function:

close_error_code()

auto kcenon::network::protocols::quic::connection::close_error_code ( ) const -> std::optional<uint64_t>

inlinenodiscard

Get the close error code (if connection was closed)

Definition at line 417 of file connection.h.

    {
        return close_error_code_;
    }

References close_error_code_.

close_reason()

auto kcenon::network::protocols::quic::connection::close_reason ( ) const -> const std::string&

inlinenodiscard

Get the close reason (if connection was closed)

Definition at line 425 of file connection.h.

{ return close_reason_; }

References close_reason_.

crypto() [1/2]

auto kcenon::network::protocols::quic::connection::crypto ( ) -> quic_crypto&

inlinenodiscard

Get crypto handler.

Definition at line 458 of file connection.h.

{ return crypto_; }

References crypto_.

crypto() [2/2]

auto kcenon::network::protocols::quic::connection::crypto ( ) const -> const quic_crypto&

inlinenodiscard

Get crypto handler (const)

Definition at line 463 of file connection.h.

{ return crypto_; }

References crypto_.

disable_pmtud()

void kcenon::network::protocols::quic::connection::disable_pmtud

(

)

Disable Path MTU Discovery.

Stops PMTUD probing and reverts to minimum MTU (1200 bytes).

Definition at line 1572 of file connection.cpp.

{
    pmtud_controller_.disable();
    // Reset congestion controller to minimum MTU
    congestion_controller_.set_max_datagram_size(pmtud_controller_.min_mtu());
}

References congestion_controller_, kcenon::network::protocols::quic::pmtud_controller::disable(), kcenon::network::protocols::quic::pmtud_controller::min_mtu(), pmtud_controller_, and kcenon::network::protocols::quic::congestion_controller::set_max_datagram_size().

Here is the call graph for this function:

enable_pmtud()

void kcenon::network::protocols::quic::connection::enable_pmtud

(

)

Enable Path MTU Discovery.

Starts PMTUD probing to discover the maximum MTU on the path. Uses DPLPMTUD algorithm as specified in RFC 8899.

Definition at line 1565 of file connection.cpp.

{
    pmtud_controller_.enable();
    // Update congestion controller with current MTU
    congestion_controller_.set_max_datagram_size(pmtud_controller_.current_mtu());
}

References congestion_controller_, kcenon::network::protocols::quic::pmtud_controller::current_mtu(), kcenon::network::protocols::quic::pmtud_controller::enable(), pmtud_controller_, and kcenon::network::protocols::quic::congestion_controller::set_max_datagram_size().

Here is the call graph for this function:

enter_closing()

void kcenon::network::protocols::quic::connection::enter_closing ( )

private

Transition to closing state.

Definition at line 1212 of file connection.cpp.

{
    if (state_ == connection_state::closing || state_ == connection_state::draining)
    {
        return;
    }
 
    state_ = connection_state::closing;
 
    // Set drain timer (3 * PTO)
    auto pto = std::chrono::milliseconds(100);  // Simplified PTO
    drain_deadline_ = std::chrono::steady_clock::now() + 3 * pto;
}

References kcenon::network::protocols::quic::closing, drain_deadline_, kcenon::network::protocols::quic::draining, and state_.

enter_draining()

void kcenon::network::protocols::quic::connection::enter_draining ( )

private

Transition to draining state.

Definition at line 1226 of file connection.cpp.

{
    if (state_ == connection_state::draining || state_ == connection_state::closed)
    {
        return;
    }
 
    state_ = connection_state::draining;
 
    // Set drain timer (3 * PTO)
    auto pto = std::chrono::milliseconds(100);
    drain_deadline_ = std::chrono::steady_clock::now() + 3 * pto;
}

References kcenon::network::protocols::quic::closed, drain_deadline_, kcenon::network::protocols::quic::draining, and state_.

flow_control() [1/2]

auto kcenon::network::protocols::quic::connection::flow_control ( ) -> flow_controller&

inlinenodiscard

Get the connection-level flow controller.

Definition at line 385 of file connection.h.

{ return flow_ctrl_; }

References flow_ctrl_.

flow_control() [2/2]

auto kcenon::network::protocols::quic::connection::flow_control ( ) const -> const flow_controller&

inlinenodiscard

Get the connection-level flow controller (const)

Definition at line 390 of file connection.h.

{ return flow_ctrl_; }

References flow_ctrl_.

generate_ack_frame()

auto kcenon::network::protocols::quic::connection::generate_ack_frame ( const packet_number_space & space ) -> std::optional<ack_frame>

nodiscardprivate

Generate ACK frame for a packet number space.

Definition at line 1315 of file connection.cpp.

{
    if (space.largest_received == 0 && !space.ack_needed)
    {
        return std::nullopt;
    }
 
    ack_frame ack;
    ack.largest_acknowledged = space.largest_received;
    ack.ack_delay = std::chrono::duration_cast<std::chrono::microseconds>(
                        std::chrono::steady_clock::now() - space.largest_received_time)
                        .count();
    // Simplified: ACK all packets from 0 to largest_received
    // The first ACK range is implicit (largest_acknowledged to largest_acknowledged - first_ack_range_length)
    // For simplicity, we don't add any additional ranges
 
    return ack;
}

References kcenon::network::protocols::quic::ack, and kcenon::network::protocols::quic::ack_frame::largest_acknowledged.

generate_packets()

auto kcenon::network::protocols::quic::connection::generate_packets ( ) -> std::vector<std::vector<uint8_t>>

nodiscard

Generate packets to send.

Returns

Vector of packets (may be coalesced for handshake)

Definition at line 780 of file connection.cpp.

{
    std::vector<std::vector<uint8_t>> packets;
 
    if (is_closed())
    {
        return packets;
    }
 
    // Generate close packet if closing
    if (close_sent_ && !close_received_)
    {
        auto pkt = build_packet(encryption_level::application);
        if (!pkt.empty())
        {
            packets.push_back(std::move(pkt));
        }
        return packets;
    }
 
    // Generate Initial packets if needed
    if (!pending_crypto_initial_.empty() || pending_ack_initial_)
    {
        auto pkt = build_packet(encryption_level::initial);
        if (!pkt.empty())
        {
            packets.push_back(std::move(pkt));
            pending_ack_initial_ = false;
        }
    }
 
    // Generate Handshake packets if needed
    if (!pending_crypto_handshake_.empty() || pending_ack_handshake_)
    {
        auto pkt = build_packet(encryption_level::handshake);
        if (!pkt.empty())
        {
            packets.push_back(std::move(pkt));
            pending_ack_handshake_ = false;
        }
    }
 
    // Generate 1-RTT packets if connected
    if (state_ == connection_state::connected)
    {
        // Send HANDSHAKE_DONE (server only, once)
        if (is_server_ && hs_state_ == handshake_state::complete)
        {
            // Will be included in next packet
        }
 
        // Generate application data packets
        if (has_pending_data() || pending_ack_app_)
        {
            auto pkt = build_packet(encryption_level::application);
            if (!pkt.empty())
            {
                packets.push_back(std::move(pkt));
                pending_ack_app_ = false;
            }
        }
    }
 
    return packets;
}

References kcenon::network::protocols::quic::application, kcenon::network::protocols::quic::complete, kcenon::network::protocols::quic::connected, kcenon::network::protocols::quic::handshake, and kcenon::network::protocols::quic::initial.

generate_probe_packets()

void kcenon::network::protocols::quic::connection::generate_probe_packets ( )

private

Generate probe packets for PTO (RFC 9002 Section 6.2.4) Sends one or two ack-eliciting packets to probe for acknowledgment.

Definition at line 1384 of file connection.cpp.

{
    // RFC 9002 Section 6.2.4: When PTO expires, send one or two ack-eliciting packets.
    // Probe packets must be ack-eliciting.
 
    // Determine which encryption level to use for probes
    // Priority: Application > Handshake > Initial (use the highest available)
    encryption_level probe_level = encryption_level::initial;
 
    if (crypto_.get_write_keys(encryption_level::application).is_ok())
    {
        probe_level = encryption_level::application;
    }
    else if (crypto_.get_write_keys(encryption_level::handshake).is_ok())
    {
        probe_level = encryption_level::handshake;
    }
 
    // Generate a PING frame as an ack-eliciting probe
    // PING frames are the simplest ack-eliciting frames
    pending_frames_.emplace_back(ping_frame{});
 
    // Mark that we need to send packets
    switch (probe_level)
    {
    case encryption_level::initial:
        // For initial space, we might need to retransmit crypto data
        if (!pending_crypto_initial_.empty())
        {
            // Crypto data will be sent as probe
            break;
        }
        // Queue a PING frame
        break;
 
    case encryption_level::handshake:
        if (!pending_crypto_handshake_.empty())
        {
            break;
        }
        break;
 
    case encryption_level::application:
    case encryption_level::zero_rtt:
        // Application level: PING is sufficient
        break;
    }
}

References kcenon::network::protocols::quic::application, crypto_, kcenon::network::protocols::quic::quic_crypto::get_write_keys(), kcenon::network::protocols::quic::handshake, kcenon::network::protocols::quic::initial, pending_crypto_handshake_, pending_crypto_initial_, pending_frames_, and kcenon::network::protocols::quic::zero_rtt.

Referenced by handle_loss_detection_result().

Here is the call graph for this function:

Here is the caller graph for this function:

get_pn_space() [1/2]

auto kcenon::network::protocols::quic::connection::get_pn_space ( encryption_level level ) -> packet_number_space&

nodiscardprivate

Get packet number space for an encryption level.

Definition at line 1087 of file connection.cpp.

{
    switch (level)
    {
    case encryption_level::initial:
    case encryption_level::zero_rtt:
        return initial_space_;
    case encryption_level::handshake:
        return handshake_space_;
    default:
        return app_space_;
    }
}

References kcenon::network::protocols::quic::handshake, kcenon::network::protocols::quic::initial, and kcenon::network::protocols::quic::zero_rtt.

get_pn_space() [2/2]

auto kcenon::network::protocols::quic::connection::get_pn_space ( encryption_level level ) const -> const packet_number_space&

nodiscardprivate

Definition at line 1101 of file connection.cpp.

{
    switch (level)
    {
    case encryption_level::initial:
    case encryption_level::zero_rtt:
        return initial_space_;
    case encryption_level::handshake:
        return handshake_space_;
    default:
        return app_space_;
    }
}

References kcenon::network::protocols::quic::handshake, kcenon::network::protocols::quic::initial, and kcenon::network::protocols::quic::zero_rtt.

handle_frame()

auto kcenon::network::protocols::quic::connection::handle_frame ( const frame & frame, encryption_level level ) -> VoidResult

nodiscardprivate

Handle a specific frame.

Definition at line 550 of file connection.cpp.

{
    return std::visit(
        [this, level](const auto& f) -> VoidResult
        {
            using T = std::decay_t<decltype(f)>;
 
            if constexpr (std::is_same_v<T, padding_frame>)
            {
                // Padding is ignored
                return ok();
            }
            else if constexpr (std::is_same_v<T, ping_frame>)
            {
                // Ping just elicits an ACK (already handled)
                return ok();
            }
            else if constexpr (std::is_same_v<T, ack_frame>)
            {
                // Process ACK using loss detector (RFC 9002)
                auto recv_time = std::chrono::steady_clock::now();
                auto result = loss_detector_.on_ack_received(f, level, recv_time);
 
                // Handle loss detection result
                handle_loss_detection_result(result);
 
                // Reset PTO count on receiving acknowledgment
                loss_detector_.reset_pto_count();
 
                // Update handshake confirmation for loss detector
                if (crypto_.is_handshake_complete())
                {
                    loss_detector_.set_handshake_confirmed(true);
                }
 
                // Also update our local packet number space tracking
                auto& space = get_pn_space(level);
                if (f.largest_acknowledged > space.largest_acked)
                {
                    space.largest_acked = f.largest_acknowledged;
                }
 
                // Remove acknowledged packets from local tracking
                for (auto it = space.sent_packets.begin();
                     it != space.sent_packets.end();)
                {
                    if (it->first <= f.largest_acknowledged)
                    {
                        it = space.sent_packets.erase(it);
                    }
                    else
                    {
                        ++it;
                    }
                }
                return ok();
            }
            else if constexpr (std::is_same_v<T, crypto_frame>)
            {
                // Process CRYPTO frame
                auto result = crypto_.process_crypto_data(level,
                    std::span<const uint8_t>(f.data.data(), f.data.size()));
                if (result.is_err())
                {
                    return error_void(connection_error::handshake_failed,
                                      "Failed to process crypto data",
                                      "connection",
                                      result.error().message);
                }
 
                // Store response crypto data
                if (!result.value().empty())
                {
                    switch (level)
                    {
                    case encryption_level::initial:
                        pending_crypto_initial_.push_back(std::move(result.value()));
                        break;
                    case encryption_level::handshake:
                        pending_crypto_handshake_.push_back(std::move(result.value()));
                        break;
                    default:
                        pending_crypto_app_.push_back(std::move(result.value()));
                        break;
                    }
                }
 
                return ok();
            }
            else if constexpr (std::is_same_v<T, stream_frame>)
            {
                // Get or create stream
                auto stream_result = stream_mgr_.get_or_create_stream(f.stream_id);
                if (stream_result.is_err())
                {
                    return error_void(connection_error::protocol_violation,
                                      "Failed to get stream",
                                      "connection",
                                      stream_result.error().message);
                }
 
                // Deliver data
                auto recv_result = stream_result.value()->receive_data(
                    f.offset,
                    std::span<const uint8_t>(f.data.data(), f.data.size()),
                    f.fin);
                if (recv_result.is_err())
                {
                    return recv_result;
                }
 
                // Update connection-level flow control
                auto recv_flow = flow_ctrl_.record_received(f.data.size());
                if (recv_flow.is_err())
                {
                    return recv_flow;
                }
                return ok();
            }
            else if constexpr (std::is_same_v<T, max_data_frame>)
            {
                flow_ctrl_.update_send_limit(f.maximum_data);
                return ok();
            }
            else if constexpr (std::is_same_v<T, max_stream_data_frame>)
            {
                auto* s = stream_mgr_.get_stream(f.stream_id);
                if (s)
                {
                    s->set_max_send_data(f.maximum_stream_data);
                }
                return ok();
            }
            else if constexpr (std::is_same_v<T, max_streams_frame>)
            {
                if (f.bidirectional)
                {
                    stream_mgr_.set_peer_max_streams_bidi(f.maximum_streams);
                }
                else
                {
                    stream_mgr_.set_peer_max_streams_uni(f.maximum_streams);
                }
                return ok();
            }
            else if constexpr (std::is_same_v<T, connection_close_frame>)
            {
                close_error_code_ = f.error_code;
                close_reason_ = f.reason_phrase;
                close_received_ = true;
                application_close_ = f.is_application_error;
                enter_draining();
                return ok();
            }
            else if constexpr (std::is_same_v<T, handshake_done_frame>)
            {
                if (!is_server_)
                {
                    hs_state_ = handshake_state::complete;
                    state_ = connection_state::connected;
                }
                return ok();
            }
            else if constexpr (std::is_same_v<T, reset_stream_frame>)
            {
                auto* s = stream_mgr_.get_stream(f.stream_id);
                if (s)
                {
                    return s->receive_reset(f.application_error_code, f.final_size);
                }
                return ok();
            }
            else if constexpr (std::is_same_v<T, stop_sending_frame>)
            {
                auto* s = stream_mgr_.get_stream(f.stream_id);
                if (s)
                {
                    return s->receive_stop_sending(f.application_error_code);
                }
                return ok();
            }
            else if constexpr (std::is_same_v<T, new_connection_id_frame>)
            {
                // RFC 9000 Section 19.15: Process NEW_CONNECTION_ID frame
                // Store the new peer connection ID with its metadata
                connection_id cid(std::span<const uint8_t>(
                    f.connection_id.data(), f.connection_id.size()));
 
                auto result = peer_cid_manager_.add_peer_cid(
                    cid,
                    f.sequence_number,
                    f.retire_prior_to,
                    f.stateless_reset_token);
 
                if (result.is_err())
                {
                    return error_void(connection_error::protocol_violation,
                                      "Failed to process NEW_CONNECTION_ID",
                                      "connection",
                                      result.error().message);
                }
                return ok();
            }
            else if constexpr (std::is_same_v<T, retire_connection_id_frame>)
            {
                return retire_cid(f.sequence_number);
            }
            else if constexpr (std::is_same_v<T, data_blocked_frame> ||
                              std::is_same_v<T, stream_data_blocked_frame> ||
                              std::is_same_v<T, streams_blocked_frame> ||
                              std::is_same_v<T, path_challenge_frame> ||
                              std::is_same_v<T, path_response_frame> ||
                              std::is_same_v<T, new_token_frame>)
            {
                // These frames are acknowledged but may not require action
                return ok();
            }
            else
            {
                return ok();
            }
        },
        frm);
}

References kcenon::network::protocols::quic::complete, kcenon::network::protocols::quic::connected, kcenon::network::error_void(), kcenon::network::protocols::quic::handshake, kcenon::network::protocols::quic::connection_error::handshake_failed, kcenon::network::protocols::quic::initial, kcenon::network::ok(), and kcenon::network::protocols::quic::connection_error::protocol_violation.

Here is the call graph for this function:

handle_loss_detection_result()

void kcenon::network::protocols::quic::connection::handle_loss_detection_result ( const loss_detection_result & result )

private

Handle loss detection result (RFC 9002)

Parameters

result

Loss detection result from timeout or ACK processing

Definition at line 1339 of file connection.cpp.

{
    switch (result.event)
    {
    case loss_detection_event::pto_expired:
        // PTO timeout: generate probe packets (RFC 9002 Section 6.2.4)
        generate_probe_packets();
        break;
 
    case loss_detection_event::packet_lost:
        // Handle lost packets: queue frames for retransmission and update congestion control
        for (const auto& lost : result.lost_packets)
        {
            queue_frames_for_retransmission(lost);
            congestion_controller_.on_packet_lost(lost);
        }
        break;
 
    case loss_detection_event::none:
        // No action needed
        break;
    }
 
    // Process acknowledged packets for congestion control
    auto ack_time = std::chrono::steady_clock::now();
    for (const auto& acked : result.acked_packets)
    {
        congestion_controller_.on_packet_acked(acked, ack_time);
    }
 
    // Handle ECN congestion signal (RFC 9002 Section 7.1)
    if (result.ecn_signal == ecn_result::congestion_signal)
    {
        // ECN-CE marks indicate congestion without packet loss
        // Trigger congestion response using the sent time of the triggering packet
        congestion_controller_.on_ecn_congestion(result.ecn_congestion_sent_time);
    }
    else if (result.ecn_signal == ecn_result::ecn_failure)
    {
        // ECN validation failed - disable ECN for this connection
        // The ecn_tracker in loss_detector already handles this internally
        // No additional action needed here
    }
}

References kcenon::network::protocols::quic::loss_detection_result::acked_packets, congestion_controller_, kcenon::network::protocols::quic::congestion_signal, kcenon::network::protocols::quic::loss_detection_result::ecn_congestion_sent_time, kcenon::network::protocols::quic::ecn_failure, kcenon::network::protocols::quic::loss_detection_result::ecn_signal, kcenon::network::protocols::quic::loss_detection_result::event, generate_probe_packets(), kcenon::network::protocols::quic::loss_detection_result::lost_packets, kcenon::network::protocols::quic::none, kcenon::network::protocols::quic::congestion_controller::on_ecn_congestion(), kcenon::network::protocols::quic::congestion_controller::on_packet_acked(), kcenon::network::protocols::quic::congestion_controller::on_packet_lost(), kcenon::network::protocols::quic::packet_lost, kcenon::network::protocols::quic::pto_expired, and queue_frames_for_retransmission().

Referenced by on_timeout().

Here is the call graph for this function:

Here is the caller graph for this function:

handshake_state()

auto kcenon::network::protocols::quic::connection::handshake_state ( ) const -> enum handshake_state

inlinenodiscardnoexcept

Get current handshake state.

Definition at line 187 of file connection.h.

    {
        return hs_state_;
    }

has_pending_data()

auto kcenon::network::protocols::quic::connection::has_pending_data ( ) const -> bool

nodiscard

Check if there are packets to send.

Definition at line 1053 of file connection.cpp.

{
    if (!pending_crypto_initial_.empty() ||
        !pending_crypto_handshake_.empty() ||
        !pending_crypto_app_.empty())
    {
        return true;
    }
 
    if (pending_ack_initial_ || pending_ack_handshake_ || pending_ack_app_)
    {
        return true;
    }
 
    if (close_sent_)
    {
        return true;
    }
 
    // Check for pending frames (e.g., PING from PTO probing)
    if (!pending_frames_.empty())
    {
        return true;
    }
 
    // Check for stream data
    auto& streams = const_cast<stream_manager&>(stream_mgr_);
    return !streams.streams_with_pending_data().empty();
}

References close_sent_, pending_ack_app_, pending_ack_handshake_, pending_ack_initial_, pending_crypto_app_, pending_crypto_handshake_, pending_crypto_initial_, pending_frames_, stream_mgr_, streams(), and kcenon::network::protocols::quic::stream_manager::streams_with_pending_data().

Here is the call graph for this function:

idle_deadline()

auto kcenon::network::protocols::quic::connection::idle_deadline ( ) const -> std::chrono::steady_clock::time_point

inlinenodiscard

Get idle timeout deadline.

Definition at line 446 of file connection.h.

    {
        return idle_deadline_;
    }

References idle_deadline_.

init_server_handshake()

auto kcenon::network::protocols::quic::connection::init_server_handshake ( const std::string & cert_file, const std::string & key_file ) -> VoidResult

nodiscard

Initialize server handshake.

Parameters

cert_file	Path to certificate file
key_file	Path to private key file

Returns

Success or error

Definition at line 295 of file connection.cpp.

{
    auto span = tracing::is_tracing_enabled()
        ? std::make_optional(tracing::trace_context::create_span("quic.connection.init_server_handshake"))
        : std::nullopt;
    if (span)
    {
        span->set_attribute("quic.role", "server")
             .set_attribute("net.transport", "udp")
             .set_attribute("quic.version", "1");
    }
 
    if (!is_server_)
    {
        if (span)
        {
            span->set_error("Not a server connection");
        }
        return error_void(connection_error::invalid_state,
                          "Not a server connection",
                          "connection");
    }
 
    auto result = crypto_.init_server(cert_file, key_file);
    if (result.is_err())
    {
        if (span)
        {
            span->set_error(result.error().message);
        }
        return error_void(connection_error::handshake_failed,
                          "Failed to initialize server crypto",
                          "connection",
                          result.error().message);
    }
 
    // Derive initial secrets using the client's DCID
    auto derive_result = crypto_.derive_initial_secrets(initial_dcid_);
    if (derive_result.is_err())
    {
        if (span)
        {
            span->set_error(derive_result.error().message);
        }
        return error_void(connection_error::handshake_failed,
                          "Failed to derive initial secrets",
                          "connection",
                          derive_result.error().message);
    }
 
    state_ = connection_state::handshaking;
    if (span)
    {
        span->set_attribute("quic.state", "handshaking");
    }
    return ok();
}

References kcenon::network::tracing::trace_context::create_span(), kcenon::network::error_void(), kcenon::network::protocols::quic::connection_error::handshake_failed, kcenon::network::protocols::quic::handshaking, kcenon::network::protocols::quic::connection_error::invalid_state, kcenon::network::tracing::is_tracing_enabled(), and kcenon::network::ok().

Here is the call graph for this function:

initial_dcid()

auto kcenon::network::protocols::quic::connection::initial_dcid ( ) const -> const connection_id&

inlinenodiscard

Get initial Destination Connection ID (for key derivation)

Definition at line 239 of file connection.h.

{ return initial_dcid_; }

References initial_dcid_.

Referenced by connection().

Here is the caller graph for this function:

is_closed()

auto kcenon::network::protocols::quic::connection::is_closed ( ) const -> bool

inlinenodiscardnoexcept

Check if connection is closed.

Definition at line 212 of file connection.h.

    {
        return state_ == connection_state::closed;
    }

References kcenon::network::protocols::quic::closed, and state_.

Referenced by next_timeout().

Here is the caller graph for this function:

is_draining()

auto kcenon::network::protocols::quic::connection::is_draining ( ) const -> bool

inlinenodiscardnoexcept

Check if connection is draining or closing.

Definition at line 203 of file connection.h.

    {
        return state_ == connection_state::draining ||
               state_ == connection_state::closing;
    }

References kcenon::network::protocols::quic::closing, kcenon::network::protocols::quic::draining, and state_.

Referenced by next_timeout(), and on_timeout().

Here is the caller graph for this function:

is_established()

auto kcenon::network::protocols::quic::connection::is_established ( ) const -> bool

inlinenodiscardnoexcept

Check if connection is established (handshake complete)

Definition at line 195 of file connection.h.

    {
        return state_ == connection_state::connected;
    }

References kcenon::network::protocols::quic::connected, and state_.

is_server()

auto kcenon::network::protocols::quic::connection::is_server ( ) const -> bool

inlinenodiscardnoexcept

Check if this is a server-side connection.

Definition at line 220 of file connection.h.

{ return is_server_; }

References is_server_.

Referenced by connection().

Here is the caller graph for this function:

local_cid()

auto kcenon::network::protocols::quic::connection::local_cid ( ) const -> const connection_id&

inlinenodiscard

Get local Connection ID.

Definition at line 229 of file connection.h.

{ return local_cid_; }

References local_cid_.

local_params()

auto kcenon::network::protocols::quic::connection::local_params ( ) const -> const transport_parameters&

inlinenodiscard

Get local transport parameters.

Definition at line 308 of file connection.h.

    {
        return local_params_;
    }

References local_params_.

next_timeout()

auto kcenon::network::protocols::quic::connection::next_timeout ( ) const -> std::optional<std::chrono::steady_clock::time_point>

nodiscard

Get the next timeout deadline.

Returns

Timeout time point or nullopt if no timer is set

Definition at line 1259 of file connection.cpp.

{
    if (is_closed())
    {
        return std::nullopt;
    }
 
    if (is_draining())
    {
        return drain_deadline_;
    }
 
    // Return the earliest of idle timeout and loss detection timeout
    auto loss_timeout = loss_detector_.next_timeout();
    if (loss_timeout.has_value())
    {
        return std::min(idle_deadline_, *loss_timeout);
    }
 
    return idle_deadline_;
}

References drain_deadline_, idle_deadline_, is_closed(), is_draining(), loss_detector_, and kcenon::network::protocols::quic::loss_detector::next_timeout().

Here is the call graph for this function:

on_timeout()

void kcenon::network::protocols::quic::connection::on_timeout

(

)

Handle timeout event.

Definition at line 1282 of file connection.cpp.

{
    auto now = std::chrono::steady_clock::now();
 
    // Check drain timeout
    if (is_draining() && now >= drain_deadline_)
    {
        state_ = connection_state::closed;
        return;
    }
 
    // Check idle timeout
    if (now >= idle_deadline_)
    {
        close_error_code_ = 0;
        close_reason_ = "Idle timeout";
        state_ = connection_state::closed;
        return;
    }
 
    // Handle PTO timeout for loss detection (RFC 9002 Section 6.2)
    auto loss_timeout = loss_detector_.next_timeout();
    if (loss_timeout.has_value() && now >= *loss_timeout)
    {
        auto result = loss_detector_.on_timeout();
        handle_loss_detection_result(result);
    }
}

References close_error_code_, close_reason_, kcenon::network::protocols::quic::closed, drain_deadline_, handle_loss_detection_result(), idle_deadline_, is_draining(), loss_detector_, kcenon::network::protocols::quic::loss_detector::next_timeout(), kcenon::network::protocols::quic::loss_detector::on_timeout(), and state_.

Here is the call graph for this function:

operator=() [1/2]

auto kcenon::network::protocols::quic::connection::operator= ( connection && ) -> connection &=delete

delete

operator=() [2/2]

auto kcenon::network::protocols::quic::connection::operator= ( const connection & ) -> connection &=delete

delete

packets_received()

auto kcenon::network::protocols::quic::connection::packets_received ( ) const -> uint64_t

inlinenodiscardnoexcept

Get packets received count.

Definition at line 528 of file connection.h.

    {
        return packets_received_;
    }

References packets_received_.

packets_sent()

auto kcenon::network::protocols::quic::connection::packets_sent ( ) const -> uint64_t

inlinenodiscardnoexcept

Get packets sent count.

Definition at line 523 of file connection.h.

{ return packets_sent_; }

References packets_sent_.

path_mtu()

auto kcenon::network::protocols::quic::connection::path_mtu ( ) const -> size_t

nodiscardnoexcept

Get current path MTU.

Returns

Current validated MTU for this connection path

Definition at line 1560 of file connection.cpp.

{
    return pmtud_controller_.current_mtu();
}

References kcenon::network::protocols::quic::pmtud_controller::current_mtu(), and pmtud_controller_.

Here is the call graph for this function:

peer_cid_manager() [1/2]

auto kcenon::network::protocols::quic::connection::peer_cid_manager ( ) -> connection_id_manager&

inlinenodiscard

Get the peer connection ID manager.

Definition at line 260 of file connection.h.

    {
        return peer_cid_manager_;
    }

References peer_cid_manager_.

peer_cid_manager() [2/2]

auto kcenon::network::protocols::quic::connection::peer_cid_manager ( ) const -> const connection_id_manager&

inlinenodiscard

Get the peer connection ID manager (const)

Definition at line 268 of file connection.h.

    {
        return peer_cid_manager_;
    }

References peer_cid_manager_.

pmtud() [1/2]

auto kcenon::network::protocols::quic::connection::pmtud ( ) -> pmtud_controller&

inlinenodiscard

Get the PMTUD controller.

Definition at line 499 of file connection.h.

{ return pmtud_controller_; }

References pmtud_controller_.

pmtud() [2/2]

auto kcenon::network::protocols::quic::connection::pmtud ( ) const -> const pmtud_controller&

inlinenodiscard

Get the PMTUD controller (const)

Definition at line 504 of file connection.h.

{ return pmtud_controller_; }

References pmtud_controller_.

pmtud_enabled()

auto kcenon::network::protocols::quic::connection::pmtud_enabled ( ) const -> bool

nodiscardnoexcept

Check if PMTUD is enabled.

Returns

True if PMTUD is enabled

Definition at line 1579 of file connection.cpp.

{
    return pmtud_controller_.is_enabled();
}

References kcenon::network::protocols::quic::pmtud_controller::is_enabled(), and pmtud_controller_.

Here is the call graph for this function:

process_frames()

auto kcenon::network::protocols::quic::connection::process_frames ( std::span< const uint8_t > payload, encryption_level level ) -> VoidResult

nodiscardprivate

Process frames from a decrypted packet.

Definition at line 523 of file connection.cpp.

{
    // Parse all frames in the payload
    auto frames_result = frame_parser::parse_all(payload);
    if (frames_result.is_err())
    {
        return error_void(connection_error::protocol_violation,
                          "Failed to parse frames",
                          "connection",
                          frames_result.error().message);
    }
 
    // Process each frame
    for (const auto& f : frames_result.value())
    {
        auto result = handle_frame(f, level);
        if (result.is_err())
        {
            return result;
        }
    }
 
    update_state();
    return ok();
}

References kcenon::network::error_void(), kcenon::network::ok(), kcenon::network::protocols::quic::frame_parser::parse_all(), and kcenon::network::protocols::quic::connection_error::protocol_violation.

Here is the call graph for this function:

process_long_header_packet()

auto kcenon::network::protocols::quic::connection::process_long_header_packet ( const long_header & hdr, std::span< const uint8_t > payload ) -> VoidResult

nodiscardprivate

Process a long header packet.

Definition at line 428 of file connection.cpp.

{
    encryption_level level;
    switch (hdr.type())
    {
    case packet_type::initial:
        level = encryption_level::initial;
        pending_ack_initial_ = true;
        break;
    case packet_type::handshake:
        level = encryption_level::handshake;
        pending_ack_handshake_ = true;
        break;
    case packet_type::zero_rtt:
        level = encryption_level::zero_rtt;
        break;
    case packet_type::retry:
        // Handle Retry packet specially
        return ok();
    default:
        return error_void(connection_error::protocol_violation,
                          "Unknown packet type",
                          "connection");
    }
 
    // Update remote CID if this is first packet from peer
    if (remote_cid_.length() == 0)
    {
        remote_cid_ = hdr.src_conn_id;
        peer_cid_manager_.set_initial_peer_cid(hdr.src_conn_id);
    }
 
    // Server: set original DCID for transport parameters
    if (is_server_ && !local_params_.original_destination_connection_id)
    {
        local_params_.original_destination_connection_id = hdr.dest_conn_id;
    }
 
    // Get keys for this level
    auto keys_result = crypto_.get_read_keys(level);
    if (keys_result.is_err())
    {
        // Keys not yet available - this might happen during handshake
        return ok();
    }
 
    // Track largest packet number
    auto& space = get_pn_space(level);
    if (hdr.packet_number > space.largest_received)
    {
        space.largest_received = hdr.packet_number;
        space.largest_received_time = std::chrono::steady_clock::now();
    }
    space.ack_needed = true;
 
    return process_frames(payload, level);
}

References kcenon::network::error_void(), kcenon::network::protocols::quic::handshake, kcenon::network::protocols::quic::initial, kcenon::network::ok(), kcenon::network::protocols::quic::connection_error::protocol_violation, kcenon::network::protocols::quic::retry, and kcenon::network::protocols::quic::zero_rtt.

Here is the call graph for this function:

process_short_header_packet()

auto kcenon::network::protocols::quic::connection::process_short_header_packet ( const short_header & hdr, std::span< const uint8_t > payload ) -> VoidResult

nodiscardprivate

Process a short header packet.

Definition at line 488 of file connection.cpp.

{
    if (state_ != connection_state::connected)
    {
        // Short header packets require completed handshake
        return error_void(connection_error::not_established,
                          "Received 1-RTT packet before handshake complete",
                          "connection");
    }
 
    pending_ack_app_ = true;
 
    // Get 1-RTT keys
    auto keys_result = crypto_.get_read_keys(encryption_level::application);
    if (keys_result.is_err())
    {
        return error_void(connection_error::handshake_failed,
                          "1-RTT keys not available",
                          "connection");
    }
 
    // Track largest packet number
    auto& space = app_space_;
    if (hdr.packet_number > space.largest_received)
    {
        space.largest_received = hdr.packet_number;
        space.largest_received_time = std::chrono::steady_clock::now();
    }
    space.ack_needed = true;
 
    return process_frames(payload, encryption_level::application);
}

References kcenon::network::protocols::quic::application, kcenon::network::protocols::quic::connected, kcenon::network::error_void(), kcenon::network::protocols::quic::connection_error::handshake_failed, and kcenon::network::protocols::quic::connection_error::not_established.

Here is the call graph for this function:

queue_frames_for_retransmission()

void kcenon::network::protocols::quic::connection::queue_frames_for_retransmission ( const sent_packet & lost_packet )

private

Queue frames from lost packet for retransmission.

Parameters

lost_packet

The packet that was declared lost

Definition at line 1433 of file connection.cpp.

{
    // Queue frames from the lost packet for retransmission
    // Note: Some frames should not be retransmitted (ACK, PADDING)
    const auto level = lost_packet.level;
 
    for (const auto& f : lost_packet.frames)
    {
        std::visit(
            [this, level](const auto& frm)
            {
                using T = std::decay_t<decltype(frm)>;
 
                // Skip non-retransmittable frames
                if constexpr (std::is_same_v<T, padding_frame> ||
                              std::is_same_v<T, ack_frame>)
                {
                    // These frames are not retransmitted
                }
                else if constexpr (std::is_same_v<T, crypto_frame>)
                {
                    // Crypto frames need to be retransmitted with their data
                    switch (level)
                    {
                    case encryption_level::initial:
                        pending_crypto_initial_.push_back(frm.data);
                        break;
                    case encryption_level::handshake:
                        pending_crypto_handshake_.push_back(frm.data);
                        break;
                    case encryption_level::zero_rtt:
                    case encryption_level::application:
                        pending_crypto_app_.push_back(frm.data);
                        break;
                    }
                }
                else if constexpr (std::is_same_v<T, stream_frame>)
                {
                    // Stream data retransmission:
                    // The stream will naturally resend unacknowledged data
                    // when next_stream_frame() is called, as the data remains
                    // in the send buffer until acknowledged via acknowledge_data().
                    // No explicit action needed here.
                    (void)frm;
                }
                else if constexpr (std::is_same_v<T, ping_frame> ||
                                   std::is_same_v<T, new_token_frame> ||
                                   std::is_same_v<T, handshake_done_frame>)
                {
                    // These frames can be retransmitted
                    pending_frames_.push_back(frm);
                }
                else if constexpr (std::is_same_v<T, max_data_frame> ||
                                   std::is_same_v<T, max_stream_data_frame> ||
                                   std::is_same_v<T, max_streams_frame> ||
                                   std::is_same_v<T, data_blocked_frame> ||
                                   std::is_same_v<T, stream_data_blocked_frame> ||
                                   std::is_same_v<T, streams_blocked_frame>)
                {
                    // Flow control frames: queue for retransmission
                    pending_frames_.push_back(frm);
                }
                else if constexpr (std::is_same_v<T, reset_stream_frame> ||
                                   std::is_same_v<T, stop_sending_frame>)
                {
                    // Stream control frames: queue for retransmission
                    pending_frames_.push_back(frm);
                }
                else if constexpr (std::is_same_v<T, new_connection_id_frame> ||
                                   std::is_same_v<T, retire_connection_id_frame>)
                {
                    // Connection ID management: queue for retransmission
                    pending_frames_.push_back(frm);
                }
                else if constexpr (std::is_same_v<T, path_challenge_frame> ||
                                   std::is_same_v<T, path_response_frame>)
                {
                    // Path validation: may need fresh challenge, skip retransmission
                    (void)frm;
                }
                else if constexpr (std::is_same_v<T, connection_close_frame>)
                {
                    // CONNECTION_CLOSE is handled specially during closing
                    (void)frm;
                }
            },
            f);
    }
}

References kcenon::network::protocols::quic::application, kcenon::network::protocols::quic::sent_packet::frames, kcenon::network::protocols::quic::handshake, kcenon::network::protocols::quic::initial, kcenon::network::protocols::quic::sent_packet::level, pending_crypto_app_, pending_crypto_handshake_, pending_crypto_initial_, pending_frames_, and kcenon::network::protocols::quic::zero_rtt.

Referenced by handle_loss_detection_result().

Here is the caller graph for this function:

receive_packet()

auto kcenon::network::protocols::quic::connection::receive_packet ( std::span< const uint8_t > data ) -> VoidResult

nodiscard

Receive and process a packet.

Parameters

data	Raw packet data

Returns

Success or error

Definition at line 358 of file connection.cpp.

{
    auto span = tracing::is_tracing_enabled()
        ? std::make_optional(tracing::trace_context::create_span("quic.connection.receive_packet"))
        : std::nullopt;
    if (span)
    {
        span->set_attribute("quic.packet.size", static_cast<int64_t>(data.size()))
             .set_attribute("quic.role", is_server_ ? "server" : "client")
             .set_attribute("quic.state", connection_state_to_string(state_));
    }
 
    if (data.empty())
    {
        if (span)
        {
            span->set_error("Empty packet");
        }
        return error_void(connection_error::protocol_violation,
                          "Empty packet",
                          "connection");
    }
 
    if (is_draining() || is_closed())
    {
        // In draining/closed state, just count the packet
        packets_received_++;
        bytes_received_ += data.size();
        if (span)
        {
            span->set_attribute("quic.packet.ignored", true);
        }
        return ok();
    }
 
    bytes_received_ += data.size();
    packets_received_++;
    reset_idle_timer();
 
    // Check header form
    if (packet_parser::is_long_header(data[0]))
    {
        auto parse_result = packet_parser::parse_long_header(data);
        if (parse_result.is_err())
        {
            return error_void(connection_error::protocol_violation,
                              "Failed to parse long header",
                              "connection",
                              parse_result.error().message);
        }
 
        auto [header, header_len] = parse_result.value();
        return process_long_header_packet(header, data.subspan(header_len));
    }
    else
    {
        auto parse_result = packet_parser::parse_short_header(data, local_cid_.length());
        if (parse_result.is_err())
        {
            return error_void(connection_error::protocol_violation,
                              "Failed to parse short header",
                              "connection",
                              parse_result.error().message);
        }
 
        auto [header, header_len] = parse_result.value();
        return process_short_header_packet(header, data.subspan(header_len));
    }
}

References kcenon::network::protocols::quic::connection_state_to_string(), kcenon::network::tracing::trace_context::create_span(), kcenon::network::error_void(), kcenon::network::protocols::quic::packet_parser::is_long_header(), kcenon::network::tracing::is_tracing_enabled(), kcenon::network::ok(), kcenon::network::protocols::quic::packet_parser::parse_long_header(), kcenon::network::protocols::quic::packet_parser::parse_short_header(), and kcenon::network::protocols::quic::connection_error::protocol_violation.

Here is the call graph for this function:

remote_cid()

auto kcenon::network::protocols::quic::connection::remote_cid ( ) const -> const connection_id&

inlinenodiscard

Get remote Connection ID.

Definition at line 234 of file connection.h.

{ return remote_cid_; }

References remote_cid_.

remote_params()

auto kcenon::network::protocols::quic::connection::remote_params ( ) const -> const transport_parameters&

inlinenodiscard

Get remote transport parameters.

Definition at line 316 of file connection.h.

    {
        return remote_params_;
    }

References remote_params_.

reset_idle_timer()

void kcenon::network::protocols::quic::connection::reset_idle_timer ( )

private

Reset idle timer.

Definition at line 1244 of file connection.cpp.

{
    auto timeout = local_params_.max_idle_timeout;
    if (remote_params_.max_idle_timeout > 0)
    {
        timeout = std::min(timeout, remote_params_.max_idle_timeout);
    }
 
    if (timeout > 0)
    {
        idle_deadline_ = std::chrono::steady_clock::now() +
                         std::chrono::milliseconds(timeout);
    }
}

References idle_deadline_, local_params_, kcenon::network::protocols::quic::transport_parameters::max_idle_timeout, and remote_params_.

Referenced by connection().

Here is the caller graph for this function:

retire_cid()

auto kcenon::network::protocols::quic::connection::retire_cid ( uint64_t sequence ) -> VoidResult

nodiscard

Retire a Connection ID.

Parameters

sequence

Sequence number of CID to retire

Returns

Success or error

Definition at line 126 of file connection.cpp.

{
    auto it = std::find_if(local_cids_.begin(), local_cids_.end(),
                           [sequence](const auto& p) { return p.first == sequence; });
 
    if (it == local_cids_.end())
    {
        return error_void(connection_error::protocol_violation,
                          "Connection ID not found",
                          "connection");
    }
 
    // Don't retire the only remaining CID
    if (local_cids_.size() <= 1)
    {
        return error_void(connection_error::protocol_violation,
                          "Cannot retire last connection ID",
                          "connection");
    }
 
    local_cids_.erase(it);
    return ok();
}

References kcenon::network::error_void(), kcenon::network::ok(), and kcenon::network::protocols::quic::connection_error::protocol_violation.

Here is the call graph for this function:

rotate_peer_cid()

auto kcenon::network::protocols::quic::connection::rotate_peer_cid ( ) -> VoidResult

nodiscard

Rotate to a new peer connection ID.

Returns

Success or error if no unused CID is available

Used for path migration or proactive CID rotation.

Definition at line 1551 of file connection.cpp.

{
    return peer_cid_manager_.rotate_peer_cid();
}

set_local_params()

void kcenon::network::protocols::quic::connection::set_local_params

(

const transport_parameters &

params

)

Set local transport parameters.

Parameters

params

Parameters to advertise to peer

Definition at line 154 of file connection.cpp.

{
    local_params_ = params;
    local_params_.initial_source_connection_id = local_cid_;
 
    // Apply to subsystems
    stream_mgr_.set_local_max_streams_bidi(params.initial_max_streams_bidi);
    stream_mgr_.set_local_max_streams_uni(params.initial_max_streams_uni);
}

References kcenon::network::protocols::quic::transport_parameters::initial_max_streams_bidi, kcenon::network::protocols::quic::transport_parameters::initial_max_streams_uni, kcenon::network::protocols::quic::transport_parameters::initial_source_connection_id, local_cid_, local_params_, kcenon::network::protocols::quic::stream_manager::set_local_max_streams_bidi(), kcenon::network::protocols::quic::stream_manager::set_local_max_streams_uni(), and stream_mgr_.

Here is the call graph for this function:

set_remote_params()

void kcenon::network::protocols::quic::connection::set_remote_params

(

const transport_parameters &

params

)

Set remote transport parameters.

Parameters

params

Parameters received from peer

Definition at line 164 of file connection.cpp.

{
    remote_params_ = params;
    apply_remote_params();
}

References apply_remote_params(), and remote_params_.

Here is the call graph for this function:

start_handshake()

auto kcenon::network::protocols::quic::connection::start_handshake ( const std::string & server_name ) -> Result<std::vector<uint8_t>>

nodiscard

Start the handshake (client only)

Parameters

server_name

Server hostname for SNI

Returns

Initial crypto data to send or error

Definition at line 199 of file connection.cpp.

{
    auto span = tracing::is_tracing_enabled()
        ? std::make_optional(tracing::trace_context::create_span("quic.connection.start_handshake"))
        : std::nullopt;
    if (span)
    {
        span->set_attribute("quic.role", "client")
             .set_attribute("quic.server_name", server_name)
             .set_attribute("net.transport", "udp")
             .set_attribute("quic.version", "1");
    }
 
    if (is_server_)
    {
        if (span)
        {
            span->set_error("Server cannot start handshake");
        }
        return error<std::vector<uint8_t>>(connection_error::invalid_state,
                                            "Server cannot start handshake",
                                            "connection");
    }
 
    if (state_ != connection_state::idle)
    {
        if (span)
        {
            span->set_error("Connection already started");
        }
        return error<std::vector<uint8_t>>(connection_error::invalid_state,
                                            "Connection already started",
                                            "connection");
    }
 
    // Initialize crypto for client
    auto init_result = crypto_.init_client(server_name);
    if (init_result.is_err())
    {
        if (span)
        {
            span->set_error(init_result.error().message);
        }
        return error<std::vector<uint8_t>>(connection_error::handshake_failed,
                                            "Failed to initialize crypto",
                                            "connection",
                                            init_result.error().message);
    }
 
    // Derive initial secrets
    auto derive_result = crypto_.derive_initial_secrets(initial_dcid_);
    if (derive_result.is_err())
    {
        if (span)
        {
            span->set_error(derive_result.error().message);
        }
        return error<std::vector<uint8_t>>(connection_error::handshake_failed,
                                            "Failed to derive initial secrets",
                                            "connection",
                                            derive_result.error().message);
    }
 
    // Start TLS handshake to get ClientHello
    auto hs_result = crypto_.start_handshake();
    if (hs_result.is_err())
    {
        if (span)
        {
            span->set_error(hs_result.error().message);
        }
        return error<std::vector<uint8_t>>(connection_error::handshake_failed,
                                            "Failed to start TLS handshake",
                                            "connection",
                                            hs_result.error().message);
    }
 
    // Store crypto data for Initial packet
    if (!hs_result.value().empty())
    {
        pending_crypto_initial_.push_back(std::move(hs_result.value()));
    }
 
    // Update state
    state_ = connection_state::handshaking;
    hs_state_ = handshake_state::waiting_server_hello;
 
    if (span)
    {
        span->set_attribute("quic.state", "handshaking");
    }
 
    return ok(std::vector<uint8_t>{});
}

References kcenon::network::tracing::trace_context::create_span(), kcenon::network::protocols::quic::error, kcenon::network::protocols::quic::connection_error::handshake_failed, kcenon::network::protocols::quic::handshaking, kcenon::network::protocols::quic::idle, kcenon::network::protocols::quic::connection_error::invalid_state, kcenon::network::tracing::is_tracing_enabled(), kcenon::network::message, kcenon::network::ok(), and kcenon::network::protocols::quic::waiting_server_hello.

Here is the call graph for this function:

state()

auto kcenon::network::protocols::quic::connection::state ( ) const -> connection_state

inlinenodiscardnoexcept

Get current connection state.

Definition at line 182 of file connection.h.

{ return state_; }

References state_.

streams() [1/2]

auto kcenon::network::protocols::quic::connection::streams ( ) -> stream_manager&

inlinenodiscard

Get the stream manager.

Definition at line 371 of file connection.h.

{ return stream_mgr_; }

References stream_mgr_.

Referenced by has_pending_data().

Here is the caller graph for this function:

streams() [2/2]

auto kcenon::network::protocols::quic::connection::streams ( ) const -> const stream_manager&

inlinenodiscard

Get the stream manager (const)

Definition at line 376 of file connection.h.

{ return stream_mgr_; }

References stream_mgr_.

to_sent_packet()

auto kcenon::network::protocols::quic::connection::to_sent_packet ( const sent_packet_info & info ) const -> sent_packet

nodiscardprivate

Convert sent_packet_info to sent_packet for loss detector.

Definition at line 1523 of file connection.cpp.

{
    sent_packet pkt;
    pkt.packet_number = info.packet_number;
    pkt.sent_time = info.sent_time;
    pkt.sent_bytes = info.sent_bytes;
    pkt.ack_eliciting = info.ack_eliciting;
    pkt.in_flight = info.in_flight;
    pkt.level = info.level;
    pkt.frames = info.frames;
    return pkt;
}

References kcenon::network::protocols::quic::sent_packet::ack_eliciting, kcenon::network::protocols::quic::sent_packet::frames, kcenon::network::protocols::quic::sent_packet::in_flight, kcenon::network::protocols::quic::sent_packet::level, kcenon::network::protocols::quic::sent_packet::packet_number, kcenon::network::protocols::quic::sent_packet::sent_bytes, and kcenon::network::protocols::quic::sent_packet::sent_time.

update_state()

void kcenon::network::protocols::quic::connection::update_state ( )

private

Update connection state based on handshake progress.

Definition at line 1120 of file connection.cpp.

{
    if (crypto_.is_handshake_complete() && hs_state_ != handshake_state::complete)
    {
        hs_state_ = handshake_state::complete;
        if (is_server_)
        {
            state_ = connection_state::connected;
        }
        // Client waits for HANDSHAKE_DONE
    }
}

References kcenon::network::protocols::quic::complete, kcenon::network::protocols::quic::connected, crypto_, kcenon::network::protocols::quic::quic_crypto::is_handshake_complete(), is_server_, and state_.

Here is the call graph for this function:

Member Data Documentation

app_space_

packet_number_space kcenon::network::protocols::quic::connection::app_space_

private

Definition at line 570 of file connection.h.

application_close_

bool kcenon::network::protocols::quic::connection::application_close_ {false}

private

Definition at line 590 of file connection.h.

{false};

bytes_received_

uint64_t kcenon::network::protocols::quic::connection::bytes_received_ {0}

private

Definition at line 599 of file connection.h.

{0};

Referenced by bytes_received().

bytes_sent_

uint64_t kcenon::network::protocols::quic::connection::bytes_sent_ {0}

private

Definition at line 598 of file connection.h.

{0};

Referenced by bytes_sent().

close_error_code_

std::optional<uint64_t> kcenon::network::protocols::quic::connection::close_error_code_

private

Definition at line 588 of file connection.h.

Referenced by close_error_code(), and on_timeout().

close_reason_

std::string kcenon::network::protocols::quic::connection::close_reason_

private

Definition at line 589 of file connection.h.

Referenced by close_reason(), and on_timeout().

close_received_

bool kcenon::network::protocols::quic::connection::close_received_ {false}

private

Definition at line 587 of file connection.h.

{false};

close_sent_

bool kcenon::network::protocols::quic::connection::close_sent_ {false}

private

Definition at line 586 of file connection.h.

{false};

Referenced by has_pending_data().

congestion_controller_

congestion_controller kcenon::network::protocols::quic::connection::congestion_controller_

private

Definition at line 562 of file connection.h.

Referenced by disable_pmtud(), enable_pmtud(), and handle_loss_detection_result().

crypto_

quic_crypto kcenon::network::protocols::quic::connection::crypto_

private

Definition at line 555 of file connection.h.

Referenced by crypto(), crypto(), generate_probe_packets(), and update_state().

drain_deadline_

std::chrono::steady_clock::time_point kcenon::network::protocols::quic::connection::drain_deadline_

private

Definition at line 595 of file connection.h.

Referenced by enter_closing(), enter_draining(), next_timeout(), and on_timeout().

flow_ctrl_

flow_controller kcenon::network::protocols::quic::connection::flow_ctrl_

private

Definition at line 557 of file connection.h.

Referenced by apply_remote_params(), flow_control(), and flow_control().

handshake_space_

packet_number_space kcenon::network::protocols::quic::connection::handshake_space_

private

Definition at line 569 of file connection.h.

idle_deadline_

std::chrono::steady_clock::time_point kcenon::network::protocols::quic::connection::idle_deadline_

private

Definition at line 593 of file connection.h.

Referenced by apply_remote_params(), idle_deadline(), next_timeout(), on_timeout(), and reset_idle_timer().

initial_dcid_

connection_id kcenon::network::protocols::quic::connection::initial_dcid_

private

Definition at line 545 of file connection.h.

Referenced by initial_dcid().

initial_space_

packet_number_space kcenon::network::protocols::quic::connection::initial_space_

private

Definition at line 568 of file connection.h.

is_server_

bool kcenon::network::protocols::quic::connection::is_server_

private

Definition at line 538 of file connection.h.

Referenced by is_server(), and update_state().

local_cid_

connection_id kcenon::network::protocols::quic::connection::local_cid_

private

Definition at line 543 of file connection.h.

Referenced by connection(), local_cid(), and set_local_params().

local_cids_

std::vector<std::pair<uint64_t, connection_id> > kcenon::network::protocols::quic::connection::local_cids_

private

Definition at line 546 of file connection.h.

Referenced by connection().

local_params_

transport_parameters kcenon::network::protocols::quic::connection::local_params_

private

Definition at line 551 of file connection.h.

Referenced by apply_remote_params(), connection(), local_params(), reset_idle_timer(), and set_local_params().

loss_detector_

loss_detector kcenon::network::protocols::quic::connection::loss_detector_

private

Definition at line 561 of file connection.h.

Referenced by next_timeout(), and on_timeout().

next_cid_sequence_

uint64_t kcenon::network::protocols::quic::connection::next_cid_sequence_ {1}

private

Definition at line 547 of file connection.h.

{1};

packets_received_

uint64_t kcenon::network::protocols::quic::connection::packets_received_ {0}

private

Definition at line 601 of file connection.h.

{0};

Referenced by packets_received().

packets_sent_

uint64_t kcenon::network::protocols::quic::connection::packets_sent_ {0}

private

Definition at line 600 of file connection.h.

{0};

Referenced by packets_sent().

peer_cid_manager_

connection_id_manager kcenon::network::protocols::quic::connection::peer_cid_manager_

private

Definition at line 548 of file connection.h.

Referenced by active_peer_cid(), apply_remote_params(), connection(), peer_cid_manager(), and peer_cid_manager().

pending_ack_app_

bool kcenon::network::protocols::quic::connection::pending_ack_app_ {false}

private

Definition at line 580 of file connection.h.

{false};

Referenced by has_pending_data().

pending_ack_handshake_

bool kcenon::network::protocols::quic::connection::pending_ack_handshake_ {false}

private

Definition at line 579 of file connection.h.

{false};

Referenced by has_pending_data().

pending_ack_initial_

bool kcenon::network::protocols::quic::connection::pending_ack_initial_ {false}

private

Definition at line 578 of file connection.h.

{false};

Referenced by has_pending_data().

pending_crypto_app_

std::deque<std::vector<uint8_t> > kcenon::network::protocols::quic::connection::pending_crypto_app_

private

Definition at line 575 of file connection.h.

Referenced by has_pending_data(), and queue_frames_for_retransmission().

pending_crypto_handshake_

std::deque<std::vector<uint8_t> > kcenon::network::protocols::quic::connection::pending_crypto_handshake_

private

Definition at line 574 of file connection.h.

Referenced by generate_probe_packets(), has_pending_data(), and queue_frames_for_retransmission().

pending_crypto_initial_

std::deque<std::vector<uint8_t> > kcenon::network::protocols::quic::connection::pending_crypto_initial_

private

Definition at line 573 of file connection.h.

Referenced by generate_probe_packets(), has_pending_data(), and queue_frames_for_retransmission().

pending_frames_

std::deque<frame> kcenon::network::protocols::quic::connection::pending_frames_

private

Definition at line 583 of file connection.h.

Referenced by generate_probe_packets(), has_pending_data(), and queue_frames_for_retransmission().

pmtud_controller_

pmtud_controller kcenon::network::protocols::quic::connection::pmtud_controller_

private

Definition at line 565 of file connection.h.

Referenced by disable_pmtud(), enable_pmtud(), path_mtu(), pmtud(), pmtud(), and pmtud_enabled().

pto_deadline_

std::chrono::steady_clock::time_point kcenon::network::protocols::quic::connection::pto_deadline_

private

Definition at line 594 of file connection.h.

remote_cid_

connection_id kcenon::network::protocols::quic::connection::remote_cid_

private

Definition at line 544 of file connection.h.

Referenced by active_peer_cid(), connection(), and remote_cid().

remote_params_

transport_parameters kcenon::network::protocols::quic::connection::remote_params_

private

Definition at line 552 of file connection.h.

Referenced by apply_remote_params(), remote_params(), reset_idle_timer(), and set_remote_params().

rtt_estimator_

rtt_estimator kcenon::network::protocols::quic::connection::rtt_estimator_

private

Definition at line 560 of file connection.h.

state_

connection_state kcenon::network::protocols::quic::connection::state_ {connection_state::idle}

private

Definition at line 539 of file connection.h.

{connection_state::idle};

Referenced by enter_closing(), enter_draining(), is_closed(), is_draining(), is_established(), on_timeout(), state(), and update_state().

stream_mgr_

stream_manager kcenon::network::protocols::quic::connection::stream_mgr_

private

Definition at line 556 of file connection.h.

Referenced by apply_remote_params(), has_pending_data(), set_local_params(), streams(), and streams().

---

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

• src/internal/protocols/quic/connection.h
• src/protocols/quic/connection.cpp