kcenon::network::protocols::quic::packet_parser Class Reference

Parser for QUIC packet headers (RFC 9000 Section 17) More...

#include <packet.h>

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

Static Public Member Functions
static constexpr auto	is_long_header (uint8_t first_byte) noexcept -> bool
	Check if a packet has a long header.
static constexpr auto	has_valid_fixed_bit (uint8_t first_byte) noexcept -> bool
	Check if the fixed bit is set correctly.
static auto	parse_header (std::span< const uint8_t > data) -> Result< std::pair< packet_header, size_t > >
	Parse a packet header (without header protection removal)
static auto	parse_long_header (std::span< const uint8_t > data) -> Result< std::pair< long_header, size_t > >
	Parse a long header packet.
static auto	parse_short_header (std::span< const uint8_t > data, size_t conn_id_length) -> Result< std::pair< short_header, size_t > >
	Parse a short header packet.
static constexpr auto	get_long_packet_type (uint8_t first_byte) noexcept -> packet_type
	Get the packet type from long header's first byte.
static auto	is_version_negotiation (std::span< const uint8_t > data) noexcept -> bool
	Check if this is a version negotiation packet.

Detailed Description

Parser for QUIC packet headers (RFC 9000 Section 17)

Parses raw bytes into QUIC packet header structures. Note that this parser handles the unprotected header format; header protection must be removed before parsing packet numbers.

Definition at line 217 of file packet.h.

Member Function Documentation

get_long_packet_type()

static constexpr auto kcenon::network::protocols::quic::packet_parser::get_long_packet_type ( uint8_t first_byte ) -> packet_type

inlinestaticnodiscardconstexprnoexcept

Get the packet type from long header's first byte.

Parameters

first_byte

First byte of a long header packet

Returns

Packet type

Definition at line 273 of file packet.h.

    {
        return static_cast<packet_type>((first_byte >> 4) & 0x03);
    }

has_valid_fixed_bit()

static constexpr auto kcenon::network::protocols::quic::packet_parser::has_valid_fixed_bit ( uint8_t first_byte ) -> bool

inlinestaticnodiscardconstexprnoexcept

Check if the fixed bit is set correctly.

Parameters

first_byte

First byte of the packet

Returns

true if the fixed bit is 1 (as required by RFC 9000)

Definition at line 235 of file packet.h.

    {
        return (first_byte & 0x40) != 0;
    }

is_long_header()

static constexpr auto kcenon::network::protocols::quic::packet_parser::is_long_header ( uint8_t first_byte ) -> bool

inlinestaticnodiscardconstexprnoexcept

Check if a packet has a long header.

Parameters

first_byte

First byte of the packet

Returns

true if the packet has a long header

Definition at line 225 of file packet.h.

    {
        return (first_byte & 0x80) != 0;
    }

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

Here is the caller graph for this function:

is_version_negotiation()

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

staticnodiscardnoexcept

Check if this is a version negotiation packet.

Parameters

data	Input buffer (at least 5 bytes)

Returns

true if this is a version negotiation packet

Definition at line 152 of file packet.cpp.

{
    if (data.size() < 5)
    {
        return false;
    }
    // Long header with version 0
    if ((data[0] & header_form_long) == 0)
    {
        return false;
    }
    uint32_t version = (static_cast<uint32_t>(data[1]) << 24) |
                       (static_cast<uint32_t>(data[2]) << 16) |
                       (static_cast<uint32_t>(data[3]) << 8) |
                       static_cast<uint32_t>(data[4]);
    return version == 0;
}

References kcenon::network::version().

Here is the call graph for this function:

parse_header()

auto kcenon::network::protocols::quic::packet_parser::parse_header ( std::span< const uint8_t > data ) -> Result<std::pair<packet_header, size_t>>

staticnodiscard

Parse a packet header (without header protection removal)

Parameters

data	Input buffer containing the packet

Returns

Result containing (header, header_length) or error

Note

For short headers, the caller must provide the expected connection ID length via parse_short_header instead

Definition at line 170 of file packet.cpp.

{
    if (data.empty())
    {
        return make_error<std::pair<packet_header, size_t>>(
            error_codes::common_errors::invalid_argument,
            "Empty packet data");
    }
 
    if (is_long_header(data[0]))
    {
        auto result = parse_long_header(data);
        if (result.is_err())
        {
            return make_error<std::pair<packet_header, size_t>>(
                result.error().code, result.error().message);
        }
        auto& [header, len] = result.value();
        return ok(std::make_pair(packet_header{std::move(header)}, len));
    }
    else
    {
        // For short headers, we need to know the connection ID length
        // Return an error directing caller to use parse_short_header
        return make_error<std::pair<packet_header, size_t>>(
            error_codes::common_errors::invalid_argument,
            "Short header requires known connection ID length. Use parse_short_header().");
    }
}

References code, kcenon::network::error_codes::common_errors::invalid_argument, and kcenon::network::ok().

Referenced by kcenon::network::core::messaging_quic_server::handle_packet(), and kcenon::network::internal::quic_socket::handle_packet().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_long_header()

auto kcenon::network::protocols::quic::packet_parser::parse_long_header ( std::span< const uint8_t > data ) -> Result<std::pair<long_header, size_t>>

staticnodiscard

Parse a long header packet.

Parameters

data	Input buffer

Returns

Result containing (header, header_length) or error

Definition at line 201 of file packet.cpp.

{
    // Minimum long header: 1 + 4 + 1 + 1 = 7 bytes (with empty CIDs)
    if (data.size() < 7)
    {
        return make_error<std::pair<long_header, size_t>>(
            error_codes::common_errors::invalid_argument,
            "Insufficient data for long header");
    }
 
    long_header header;
    size_t offset = 0;
 
    // First byte
    header.first_byte = data[offset++];
 
    // Validate header form
    if (!is_long_header(header.first_byte))
    {
        return make_error<std::pair<long_header, size_t>>(
            error_codes::common_errors::invalid_argument,
            "Not a long header packet");
    }
 
    // Validate fixed bit
    if (!has_valid_fixed_bit(header.first_byte))
    {
        return make_error<std::pair<long_header, size_t>>(
            error_codes::common_errors::invalid_argument,
            "Invalid fixed bit in long header");
    }
 
    // Version (4 bytes, big-endian)
    if (data.size() < offset + 4)
    {
        return make_error<std::pair<long_header, size_t>>(
            error_codes::common_errors::invalid_argument,
            "Insufficient data for version");
    }
    header.version = (static_cast<uint32_t>(data[offset]) << 24) |
                     (static_cast<uint32_t>(data[offset + 1]) << 16) |
                     (static_cast<uint32_t>(data[offset + 2]) << 8) |
                     static_cast<uint32_t>(data[offset + 3]);
    offset += 4;
 
    // Destination Connection ID Length (1 byte)
    if (data.size() < offset + 1)
    {
        return make_error<std::pair<long_header, size_t>>(
            error_codes::common_errors::invalid_argument,
            "Insufficient data for DCID length");
    }
    uint8_t dcid_len = data[offset++];
    if (dcid_len > connection_id::max_length)
    {
        return make_error<std::pair<long_header, size_t>>(
            error_codes::common_errors::invalid_argument,
            "DCID length exceeds maximum");
    }
 
    // Destination Connection ID
    if (data.size() < offset + dcid_len)
    {
        return make_error<std::pair<long_header, size_t>>(
            error_codes::common_errors::invalid_argument,
            "Insufficient data for DCID");
    }
    header.dest_conn_id = connection_id(data.subspan(offset, dcid_len));
    offset += dcid_len;
 
    // Source Connection ID Length (1 byte)
    if (data.size() < offset + 1)
    {
        return make_error<std::pair<long_header, size_t>>(
            error_codes::common_errors::invalid_argument,
            "Insufficient data for SCID length");
    }
    uint8_t scid_len = data[offset++];
    if (scid_len > connection_id::max_length)
    {
        return make_error<std::pair<long_header, size_t>>(
            error_codes::common_errors::invalid_argument,
            "SCID length exceeds maximum");
    }
 
    // Source Connection ID
    if (data.size() < offset + scid_len)
    {
        return make_error<std::pair<long_header, size_t>>(
            error_codes::common_errors::invalid_argument,
            "Insufficient data for SCID");
    }
    header.src_conn_id = connection_id(data.subspan(offset, scid_len));
    offset += scid_len;
 
    // Type-specific fields
    auto ptype = header.type();
 
    if (ptype == packet_type::initial)
    {
        // Token Length (varint)
        auto token_len_result = varint::decode(data.subspan(offset));
        if (token_len_result.is_err())
        {
            return make_error<std::pair<long_header, size_t>>(
                error_codes::common_errors::invalid_argument,
                "Failed to decode token length");
        }
        auto [token_len, token_len_bytes] = token_len_result.value();
        offset += token_len_bytes;
 
        // Token
        if (data.size() < offset + token_len)
        {
            return make_error<std::pair<long_header, size_t>>(
                error_codes::common_errors::invalid_argument,
                "Insufficient data for token");
        }
        header.token.assign(data.begin() + static_cast<ptrdiff_t>(offset),
                           data.begin() + static_cast<ptrdiff_t>(offset + token_len));
        offset += token_len;
 
        // Packet Length (varint)
        auto pkt_len_result = varint::decode(data.subspan(offset));
        if (pkt_len_result.is_err())
        {
            return make_error<std::pair<long_header, size_t>>(
                error_codes::common_errors::invalid_argument,
                "Failed to decode packet length");
        }
        offset += pkt_len_result.value().second;
 
        // Packet number length from reserved bits
        header.packet_number_length = (header.first_byte & pn_length_mask) + 1;
    }
    else if (ptype == packet_type::handshake || ptype == packet_type::zero_rtt)
    {
        // Packet Length (varint)
        auto pkt_len_result = varint::decode(data.subspan(offset));
        if (pkt_len_result.is_err())
        {
            return make_error<std::pair<long_header, size_t>>(
                error_codes::common_errors::invalid_argument,
                "Failed to decode packet length");
        }
        offset += pkt_len_result.value().second;
 
        // Packet number length from reserved bits
        header.packet_number_length = (header.first_byte & pn_length_mask) + 1;
    }
    else if (ptype == packet_type::retry)
    {
        // Retry packets have token (remaining bytes except last 16) and integrity tag
        // We don't parse the actual payload here, just note that it's a retry
        // The token is everything between the header and the integrity tag
    }
 
    return ok(std::make_pair(std::move(header), offset));
}

References kcenon::network::protocols::quic::varint::decode(), kcenon::network::protocols::quic::long_header::dest_conn_id, kcenon::network::protocols::quic::long_header::first_byte, kcenon::network::protocols::quic::handshake, kcenon::network::protocols::quic::initial, kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::protocols::quic::connection_id::max_length, kcenon::network::ok(), kcenon::network::protocols::quic::long_header::packet_number_length, kcenon::network::protocols::quic::retry, kcenon::network::protocols::quic::long_header::src_conn_id, kcenon::network::protocols::quic::long_header::token, kcenon::network::protocols::quic::long_header::type(), kcenon::network::protocols::quic::long_header::version, and kcenon::network::protocols::quic::zero_rtt.

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

Here is the call graph for this function:

Here is the caller graph for this function:

parse_short_header()

auto kcenon::network::protocols::quic::packet_parser::parse_short_header ( std::span< const uint8_t > data, size_t conn_id_length ) -> Result<std::pair<short_header, size_t>>

staticnodiscard

Parse a short header packet.

Parameters

data	Input buffer
conn_id_length	Expected destination connection ID length

Returns

Result containing (header, header_length) or error

Definition at line 362 of file packet.cpp.

{
    // Minimum: 1 byte first + conn_id + 1 byte packet number
    if (data.size() < 1 + conn_id_length + 1)
    {
        return make_error<std::pair<short_header, size_t>>(
            error_codes::common_errors::invalid_argument,
            "Insufficient data for short header");
    }
 
    short_header header;
    size_t offset = 0;
 
    // First byte
    header.first_byte = data[offset++];
 
    // Validate header form (should be 0 for short header)
    if (is_long_header(header.first_byte))
    {
        return make_error<std::pair<short_header, size_t>>(
            error_codes::common_errors::invalid_argument,
            "Not a short header packet");
    }
 
    // Validate fixed bit
    if (!has_valid_fixed_bit(header.first_byte))
    {
        return make_error<std::pair<short_header, size_t>>(
            error_codes::common_errors::invalid_argument,
            "Invalid fixed bit in short header");
    }
 
    // Destination Connection ID
    if (conn_id_length > 0)
    {
        if (data.size() < offset + conn_id_length)
        {
            return make_error<std::pair<short_header, size_t>>(
                error_codes::common_errors::invalid_argument,
                "Insufficient data for DCID");
        }
        header.dest_conn_id = connection_id(data.subspan(offset, conn_id_length));
        offset += conn_id_length;
    }
 
    // Packet number length from reserved bits
    header.packet_number_length = (header.first_byte & pn_length_mask) + 1;
 
    return ok(std::make_pair(std::move(header), offset));
}

References kcenon::network::protocols::quic::short_header::dest_conn_id, kcenon::network::protocols::quic::short_header::first_byte, kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::ok(), and kcenon::network::protocols::quic::short_header::packet_number_length.

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

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

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