kcenon::network::protocols::quic::connection_id Class Reference

QUIC Connection ID (RFC 9000 Section 5.1) More...

#include <connection_id.h>

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

Public Member Functions
	connection_id ()=default
	Default constructor creates an empty connection ID.
	connection_id (std::span< const uint8_t > data)
	Construct from raw bytes.
auto	data () const -> std::span< const uint8_t >
	Get the raw bytes of the connection ID.
auto	length () const noexcept -> size_t
	Get the length of the connection ID.
auto	empty () const noexcept -> bool
	Check if the connection ID is empty.
auto	operator== (const connection_id &other) const noexcept -> bool
	Equality comparison.
auto	operator!= (const connection_id &other) const noexcept -> bool
	Inequality comparison.
auto	operator< (const connection_id &other) const noexcept -> bool
	Less-than comparison for use in ordered containers.
auto	to_string () const -> std::string
	Convert to hexadecimal string for debugging.

Static Public Member Functions
static auto	generate (size_t length=8) -> connection_id
	Generate a random connection ID.

Static Public Attributes
static constexpr size_t	max_length = 20
	Maximum length of a connection ID (RFC 9000)

Private Attributes
std::array< uint8_t, max_length >	data_ {}
uint8_t	length_ {0}

Detailed Description

QUIC Connection ID (RFC 9000 Section 5.1)

A connection ID is used to identify a QUIC connection. Connection IDs are used to route packets to the correct connection and to allow endpoints to change network addresses without breaking the connection.

Key properties (RFC 9000):

• Length: 0 to 20 bytes (max_length = 20)
• An endpoint generates connection IDs for its peer to use
• Zero-length connection IDs are valid but limit connection migration
• Connection IDs should be unpredictable to avoid linkability

Definition at line 43 of file connection_id.h.

Constructor & Destructor Documentation

connection_id() [1/2]

kcenon::network::protocols::quic::connection_id::connection_id ( )

default

Default constructor creates an empty connection ID.

Referenced by kcenon::network::protocols::quic::preferred_address_info::operator==().

Here is the caller graph for this function:

connection_id() [2/2]

kcenon::network::protocols::quic::connection_id::connection_id ( std::span< const uint8_t > data )

explicit

Construct from raw bytes.

Parameters

data	Span of bytes (max 20)

Note

If data is longer than max_length, only the first max_length bytes are used

Definition at line 15 of file connection_id.cpp.

{
    size_t copy_len = std::min(data.size(), max_length);
    std::copy_n(data.begin(), copy_len, data_.begin());
    length_ = static_cast<uint8_t>(copy_len);
}

References data(), data_, length_, and max_length.

Here is the call graph for this function:

Member Function Documentation

data()

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

nodiscard

Get the raw bytes of the connection ID.

Returns

Span of connection ID bytes

Definition at line 47 of file connection_id.cpp.

{
    return std::span<const uint8_t>(data_.data(), length_);
}

References data_, and length_.

Referenced by connection_id().

Here is the caller graph for this function:

empty()

auto kcenon::network::protocols::quic::connection_id::empty ( ) const -> bool

nodiscardnoexcept

Check if the connection ID is empty.

Returns

true if length is 0

Definition at line 57 of file connection_id.cpp.

{
    return length_ == 0;
}

References length_.

generate()

auto kcenon::network::protocols::quic::connection_id::generate ( size_t length = 8 ) -> connection_id

staticnodiscard

Generate a random connection ID.

Parameters

length

Desired length (1-20, clamped to max_length)

Returns

Randomly generated connection ID

Definition at line 22 of file connection_id.cpp.

{
    connection_id cid;
 
    // Clamp length to valid range
    size_t actual_length = std::min(length, max_length);
    if (actual_length == 0)
    {
        actual_length = 1;  // Minimum 1 byte for non-empty CID
    }
 
    // Use random_device for cryptographically secure random bytes
    std::random_device rd;
    std::mt19937_64 gen(rd());
    std::uniform_int_distribution<uint16_t> dist(0, 255);
 
    for (size_t i = 0; i < actual_length; ++i)
    {
        cid.data_[i] = static_cast<uint8_t>(dist(gen));
    }
    cid.length_ = static_cast<uint8_t>(actual_length);
 
    return cid;
}

References data_, and length_.

Referenced by kcenon::network::protocols::quic::connection::connection().

Here is the caller graph for this function:

length()

auto kcenon::network::protocols::quic::connection_id::length ( ) const -> size_t

nodiscardnoexcept

Get the length of the connection ID.

Returns

Length in bytes (0-20)

Definition at line 52 of file connection_id.cpp.

{
    return length_;
}

References length_.

operator!=()

auto kcenon::network::protocols::quic::connection_id::operator!= ( const connection_id & other ) const -> bool

nodiscardnoexcept

Inequality comparison.

Parameters

other

Connection ID to compare with

Returns

true if IDs are not equal

Definition at line 72 of file connection_id.cpp.

{
    return !(*this == other);
}

operator<()

auto kcenon::network::protocols::quic::connection_id::operator< ( const connection_id & other ) const -> bool

nodiscardnoexcept

Less-than comparison for use in ordered containers.

Parameters

other

Connection ID to compare with

Returns

true if this ID is less than other

Definition at line 77 of file connection_id.cpp.

{
    // Compare by length first, then by content
    if (length_ != other.length_)
    {
        return length_ < other.length_;
    }
    return std::lexicographical_compare(
        data_.begin(), data_.begin() + length_,
        other.data_.begin(), other.data_.begin() + other.length_);
}

operator==()

auto kcenon::network::protocols::quic::connection_id::operator== ( const connection_id & other ) const -> bool

nodiscardnoexcept

Equality comparison.

Parameters

other

Connection ID to compare with

Returns

true if both IDs are equal

Definition at line 62 of file connection_id.cpp.

{
    if (length_ != other.length_)
    {
        return false;
    }
    return std::equal(data_.begin(), data_.begin() + length_,
                      other.data_.begin());
}

to_string()

auto kcenon::network::protocols::quic::connection_id::to_string ( ) const -> std::string

nodiscard

Convert to hexadecimal string for debugging.

Returns

Hexadecimal representation of the connection ID

Definition at line 89 of file connection_id.cpp.

{
    if (length_ == 0)
    {
        return "<empty>";
    }
 
    std::ostringstream oss;
    oss << std::hex << std::setfill('0');
    for (size_t i = 0; i < length_; ++i)
    {
        oss << std::setw(2) << static_cast<unsigned>(data_[i]);
    }
    return oss.str();
}

References data_, and length_.

Member Data Documentation

data_

std::array<uint8_t, max_length> kcenon::network::protocols::quic::connection_id::data_ {}

private

Definition at line 115 of file connection_id.h.

{};

Referenced by connection_id(), data(), generate(), and to_string().

length_

uint8_t kcenon::network::protocols::quic::connection_id::length_ {0}

private

Definition at line 116 of file connection_id.h.

{0};

Referenced by connection_id(), data(), empty(), generate(), length(), and to_string().

max_length

size_t kcenon::network::protocols::quic::connection_id::max_length = 20

staticconstexpr

Maximum length of a connection ID (RFC 9000)

Definition at line 47 of file connection_id.h.

Referenced by connection_id(), and kcenon::network::protocols::quic::packet_parser::parse_long_header().

---

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

• include/kcenon/network/detail/protocols/quic/connection_id.h
• src/protocols/quic/connection_id.cpp