Parser for QUIC frames (RFC 9000 Section 12) More...

#include <frame.h>

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

Static Public Member Functions
static auto	parse (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >
	Parse a single frame from buffer.

static auto	parse_all (std::span< const uint8_t > data) -> Result< std::vector< frame > >
	Parse all frames from buffer.

static auto	peek_type (std::span< const uint8_t > data) -> Result< std::pair< uint64_t, size_t > >
	Get the frame type from raw data without full parsing.

Static Private Member Functions
static auto	parse_padding (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >

static auto	parse_ping (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >

static auto	parse_ack (std::span< const uint8_t > data, bool has_ecn) -> Result< std::pair< frame, size_t > >

static auto	parse_reset_stream (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >

static auto	parse_stop_sending (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >

static auto	parse_crypto (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >

static auto	parse_new_token (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >

static auto	parse_stream (std::span< const uint8_t > data, uint8_t flags) -> Result< std::pair< frame, size_t > >

static auto	parse_max_data (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >

static auto	parse_max_stream_data (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >

static auto	parse_max_streams (std::span< const uint8_t > data, bool bidi) -> Result< std::pair< frame, size_t > >

static auto	parse_data_blocked (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >

static auto	parse_stream_data_blocked (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >

static auto	parse_streams_blocked (std::span< const uint8_t > data, bool bidi) -> Result< std::pair< frame, size_t > >

static auto	parse_new_connection_id (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >

static auto	parse_retire_connection_id (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >

static auto	parse_path_challenge (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >

static auto	parse_path_response (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >

static auto	parse_connection_close (std::span< const uint8_t > data, bool is_app) -> Result< std::pair< frame, size_t > >

static auto	parse_handshake_done (std::span< const uint8_t > data) -> Result< std::pair< frame, size_t > >

Detailed Description

Parser for QUIC frames (RFC 9000 Section 12)

Parses raw bytes into QUIC frame structures. Handles all frame types defined in RFC 9000 Section 19.

Definition at line 24 of file frame.h.

Member Function Documentation

◆ parse()

auto kcenon::network::protocols::quic::frame_parser::parse ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscard

Parse a single frame from buffer.

Parameters

data	Input buffer containing frame data

Returns: Result containing (parsed_frame, bytes_consumed) or error

Definition at line 122 of file frame.cpp.

{
    if (data.empty())
    {
        return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument,
            "Empty frame data");
    }
 
    // Parse frame type
    auto type_result = varint::decode(data);
    if (type_result.is_err())
    {
        return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument,
            "Failed to decode frame type");
    }
 
    auto [type_value, type_len] = type_result.value();
    auto remaining = data.subspan(type_len);
 
    // Check for STREAM frames (0x08-0x0f)
    if (is_stream_frame(type_value))
    {
        auto result = parse_stream(remaining, get_stream_flags(type_value));
        if (result.is_err()) return result;
        auto& [f, consumed] = result.value();
        return ok(std::make_pair(std::move(f), type_len + consumed));
    }
 
    // Dispatch based on frame type
    switch (static_cast<frame_type>(type_value))
    {
        case frame_type::padding:
            return parse_padding(data);
 
        case frame_type::ping:
        {
            auto result = parse_ping(remaining);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::ack:
        {
            auto result = parse_ack(remaining, false);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::ack_ecn:
        {
            auto result = parse_ack(remaining, true);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::reset_stream:
        {
            auto result = parse_reset_stream(remaining);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::stop_sending:
        {
            auto result = parse_stop_sending(remaining);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::crypto:
        {
            auto result = parse_crypto(remaining);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::new_token:
        {
            auto result = parse_new_token(remaining);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::max_data:
        {
            auto result = parse_max_data(remaining);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::max_stream_data:
        {
            auto result = parse_max_stream_data(remaining);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::max_streams_bidi:
        {
            auto result = parse_max_streams(remaining, true);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::max_streams_uni:
        {
            auto result = parse_max_streams(remaining, false);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::data_blocked:
        {
            auto result = parse_data_blocked(remaining);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::stream_data_blocked:
        {
            auto result = parse_stream_data_blocked(remaining);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::streams_blocked_bidi:
        {
            auto result = parse_streams_blocked(remaining, true);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::streams_blocked_uni:
        {
            auto result = parse_streams_blocked(remaining, false);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::new_connection_id:
        {
            auto result = parse_new_connection_id(remaining);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::retire_connection_id:
        {
            auto result = parse_retire_connection_id(remaining);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::path_challenge:
        {
            auto result = parse_path_challenge(remaining);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::path_response:
        {
            auto result = parse_path_response(remaining);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::connection_close:
        {
            auto result = parse_connection_close(remaining, false);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::connection_close_app:
        {
            auto result = parse_connection_close(remaining, true);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        case frame_type::handshake_done:
        {
            auto result = parse_handshake_done(remaining);
            if (result.is_err()) return result;
            auto& [f, consumed] = result.value();
            return ok(std::make_pair(std::move(f), type_len + consumed));
        }
 
        default:
            return make_error<std::pair<frame, size_t>>(
                error_codes::common_errors::invalid_argument,
                "Unknown frame type",
                "type=" + std::to_string(type_value));
    }
}

Here is the call graph for this function:

◆ parse_ack()

auto kcenon::network::protocols::quic::frame_parser::parse_ack	(	std::span< const uint8_t >	data,
		bool	has_ecn ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 394 of file frame.cpp.

{
    size_t offset = 0;
    ack_frame f;
 
    // Largest Acknowledged
    auto largest = varint::decode(data.subspan(offset));
    if (largest.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse largest acknowledged");
    f.largest_acknowledged = largest.value().first;
    offset += largest.value().second;
 
    // ACK Delay
    auto delay = varint::decode(data.subspan(offset));
    if (delay.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse ack delay");
    f.ack_delay = delay.value().first;
    offset += delay.value().second;
 
    // ACK Range Count
    auto range_count = varint::decode(data.subspan(offset));
    if (range_count.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse ack range count");
    offset += range_count.value().second;
 
    // First ACK Range
    auto first_range = varint::decode(data.subspan(offset));
    if (first_range.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse first ack range");
    offset += first_range.value().second;
 
    // Keep the first range too: loss detection and build_ack both use
    // ranges[0] for the range ending at largest_acknowledged.
    f.ranges.push_back({0, first_range.value().first});
    // Additional ranges
    for (uint64_t i = 0; i < range_count.value().first; ++i)
    {
        ack_range range;
 
        auto gap = varint::decode(data.subspan(offset));
        if (gap.is_err()) return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Failed to parse ack gap");
        range.gap = gap.value().first;
        offset += gap.value().second;
 
        auto length = varint::decode(data.subspan(offset));
        if (length.is_err()) return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Failed to parse ack range length");
        range.length = length.value().first;
        offset += length.value().second;
 
        f.ranges.push_back(range);
    }
 
    // ECN Counts (if present)
    if (has_ecn)
    {
        ecn_counts ecn;
 
        auto ect0 = varint::decode(data.subspan(offset));
        if (ect0.is_err()) return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Failed to parse ECT(0) count");
        ecn.ect0 = ect0.value().first;
        offset += ect0.value().second;
 
        auto ect1 = varint::decode(data.subspan(offset));
        if (ect1.is_err()) return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Failed to parse ECT(1) count");
        ecn.ect1 = ect1.value().first;
        offset += ect1.value().second;
 
        auto ecn_ce = varint::decode(data.subspan(offset));
        if (ecn_ce.is_err()) return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Failed to parse ECN-CE count");
        ecn.ecn_ce = ecn_ce.value().first;
        offset += ecn_ce.value().second;
 
        f.ecn = ecn;
    }
 
    return ok(std::make_pair(frame{f}, offset));
}

Here is the call graph for this function:

◆ parse_all()

auto kcenon::network::protocols::quic::frame_parser::parse_all ( std::span< const uint8_t > data ) -> Result<std::vector<frame>>

staticnodiscard

Parse all frames from buffer.

Parameters

data	Input buffer containing one or more frames

Returns: Result containing vector of parsed frames or error

Definition at line 343 of file frame.cpp.

{
    std::vector<frame> frames;
    size_t offset = 0;
 
    while (offset < data.size())
    {
        auto result = parse(data.subspan(offset));
        if (result.is_err())
        {
            return make_error<std::vector<frame>>(
                error_codes::common_errors::invalid_argument,
                "Failed to parse frame at offset " + std::to_string(offset));
        }
 
        auto& [f, consumed] = result.value();
        frames.push_back(std::move(f));
        offset += consumed;
    }
 
    return ok(std::move(frames));
}

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

Referenced by kcenon::network::internal::quic_socket::handle_packet(), and kcenon::network::protocols::quic::connection::process_frames().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_connection_close()

auto kcenon::network::protocols::quic::frame_parser::parse_connection_close	(	std::span< const uint8_t >	data,
		bool	is_app ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 827 of file frame.cpp.

{
    size_t offset = 0;
    connection_close_frame f;
    f.is_application_error = is_app;
 
    // Error Code
    auto error_code = varint::decode(data.subspan(offset));
    if (error_code.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse error code");
    f.error_code = error_code.value().first;
    offset += error_code.value().second;
 
    // Frame Type (transport close only)
    if (!is_app)
    {
        auto frame_type_val = varint::decode(data.subspan(offset));
        if (frame_type_val.is_err()) return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Failed to parse frame type");
        f.frame_type = frame_type_val.value().first;
        offset += frame_type_val.value().second;
    }
 
    // Reason Phrase Length
    auto reason_len = varint::decode(data.subspan(offset));
    if (reason_len.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse reason phrase length");
    offset += reason_len.value().second;
 
    // Reason Phrase
    if (data.size() - offset < reason_len.value().first)
    {
        return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Insufficient reason phrase data");
    }
 
    f.reason_phrase.assign(reinterpret_cast<const char*>(data.data() + offset),
                           reason_len.value().first);
    offset += reason_len.value().first;
 
    return ok(std::make_pair(frame{f}, offset));
}

References kcenon::network::protocols::quic::varint::decode(), kcenon::network::protocols::quic::connection_close_frame::error_code, kcenon::network::protocols::quic::connection_close_frame::frame_type, kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::protocols::quic::connection_close_frame::is_application_error, kcenon::network::ok(), and kcenon::network::protocols::quic::connection_close_frame::reason_phrase.

Here is the call graph for this function:

◆ parse_crypto()

auto kcenon::network::protocols::quic::frame_parser::parse_crypto ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 526 of file frame.cpp.

{
    size_t offset = 0;
    crypto_frame f;
 
    auto crypto_offset = varint::decode(data.subspan(offset));
    if (crypto_offset.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse crypto offset");
    f.offset = crypto_offset.value().first;
    offset += crypto_offset.value().second;
 
    auto length = varint::decode(data.subspan(offset));
    if (length.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse crypto length");
    offset += length.value().second;
 
    if (data.size() - offset < length.value().first)
    {
        return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Insufficient crypto data");
    }
 
    f.data.assign(data.begin() + offset, data.begin() + offset + length.value().first);
    offset += length.value().first;
 
    return ok(std::make_pair(frame{f}, offset));
}

References kcenon::network::protocols::quic::crypto_frame::data, kcenon::network::protocols::quic::varint::decode(), kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::protocols::quic::crypto_frame::offset, and kcenon::network::ok().

Here is the call graph for this function:

◆ parse_data_blocked()

auto kcenon::network::protocols::quic::frame_parser::parse_data_blocked ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 681 of file frame.cpp.

{
    data_blocked_frame f;
 
    auto max_data = varint::decode(data);
    if (max_data.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse max data");
    f.maximum_data = max_data.value().first;
 
    return ok(std::make_pair(frame{f}, max_data.value().second));
}

References kcenon::network::protocols::quic::varint::decode(), kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::protocols::quic::max_data, kcenon::network::protocols::quic::data_blocked_frame::maximum_data, and kcenon::network::ok().

Here is the call graph for this function:

◆ parse_handshake_done()

auto kcenon::network::protocols::quic::frame_parser::parse_handshake_done ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 871 of file frame.cpp.

{
    return ok(std::make_pair(frame{handshake_done_frame{}}, size_t{0}));
}

References kcenon::network::ok().

Here is the call graph for this function:

◆ parse_max_data()

auto kcenon::network::protocols::quic::frame_parser::parse_max_data ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 633 of file frame.cpp.

{
    max_data_frame f;
 
    auto max_data = varint::decode(data);
    if (max_data.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse max data");
    f.maximum_data = max_data.value().first;
 
    return ok(std::make_pair(frame{f}, max_data.value().second));
}

References kcenon::network::protocols::quic::varint::decode(), kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::protocols::quic::max_data, kcenon::network::protocols::quic::max_data_frame::maximum_data, and kcenon::network::ok().

Here is the call graph for this function:

◆ parse_max_stream_data()

auto kcenon::network::protocols::quic::frame_parser::parse_max_stream_data ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 646 of file frame.cpp.

{
    size_t offset = 0;
    max_stream_data_frame f;
 
    auto stream_id = varint::decode(data.subspan(offset));
    if (stream_id.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse stream id");
    f.stream_id = stream_id.value().first;
    offset += stream_id.value().second;
 
    auto max_data = varint::decode(data.subspan(offset));
    if (max_data.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse max stream data");
    f.maximum_stream_data = max_data.value().first;
    offset += max_data.value().second;
 
    return ok(std::make_pair(frame{f}, offset));
}

References kcenon::network::protocols::quic::varint::decode(), kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::protocols::quic::max_data, kcenon::network::protocols::quic::max_stream_data_frame::maximum_stream_data, kcenon::network::ok(), and kcenon::network::protocols::quic::max_stream_data_frame::stream_id.

Here is the call graph for this function:

◆ parse_max_streams()

auto kcenon::network::protocols::quic::frame_parser::parse_max_streams	(	std::span< const uint8_t >	data,
		bool	bidi ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 667 of file frame.cpp.

{
    max_streams_frame f;
    f.bidirectional = bidi;
 
    auto max_streams = varint::decode(data);
    if (max_streams.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse max streams");
    f.maximum_streams = max_streams.value().first;
 
    return ok(std::make_pair(frame{f}, max_streams.value().second));
}

References kcenon::network::protocols::quic::max_streams_frame::bidirectional, kcenon::network::protocols::quic::varint::decode(), kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::protocols::quic::max_streams_frame::maximum_streams, and kcenon::network::ok().

Here is the call graph for this function:

◆ parse_new_connection_id()

auto kcenon::network::protocols::quic::frame_parser::parse_new_connection_id ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 729 of file frame.cpp.

{
    size_t offset = 0;
    new_connection_id_frame f;
 
    // Sequence Number
    auto seq = varint::decode(data.subspan(offset));
    if (seq.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse sequence number");
    f.sequence_number = seq.value().first;
    offset += seq.value().second;
 
    // Retire Prior To
    auto retire = varint::decode(data.subspan(offset));
    if (retire.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse retire prior to");
    f.retire_prior_to = retire.value().first;
    offset += retire.value().second;
 
    // Connection ID Length (1 byte, not varint)
    if (data.size() <= offset)
    {
        return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Missing connection id length");
    }
    uint8_t cid_len = data[offset++];
    if (cid_len > 20)
    {
        return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Connection ID too long");
    }
 
    // Connection ID
    if (data.size() - offset < cid_len)
    {
        return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Insufficient connection id data");
    }
    f.connection_id.assign(data.begin() + offset, data.begin() + offset + cid_len);
    offset += cid_len;
 
    // Stateless Reset Token (16 bytes)
    if (data.size() - offset < 16)
    {
        return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Insufficient reset token data");
    }
    std::copy(data.begin() + offset, data.begin() + offset + 16,
              f.stateless_reset_token.begin());
    offset += 16;
 
    return ok(std::make_pair(frame{f}, offset));
}

References kcenon::network::protocols::quic::new_connection_id_frame::connection_id, kcenon::network::protocols::quic::varint::decode(), kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::ok(), kcenon::network::protocols::quic::new_connection_id_frame::retire_prior_to, kcenon::network::protocols::quic::new_connection_id_frame::sequence_number, and kcenon::network::protocols::quic::new_connection_id_frame::stateless_reset_token.

Here is the call graph for this function:

◆ parse_new_token()

auto kcenon::network::protocols::quic::frame_parser::parse_new_token ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 555 of file frame.cpp.

{
    size_t offset = 0;
    new_token_frame f;
 
    auto length = varint::decode(data.subspan(offset));
    if (length.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse token length");
    offset += length.value().second;
 
    if (data.size() - offset < length.value().first)
    {
        return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Insufficient token data");
    }
 
    f.token.assign(data.begin() + offset, data.begin() + offset + length.value().first);
    offset += length.value().first;
 
    return ok(std::make_pair(frame{f}, offset));
}

References kcenon::network::protocols::quic::varint::decode(), kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::ok(), and kcenon::network::protocols::quic::new_token_frame::token.

Here is the call graph for this function:

◆ parse_padding()

auto kcenon::network::protocols::quic::frame_parser::parse_padding ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 367 of file frame.cpp.

{
    // Count consecutive padding bytes
    size_t count = 0;
    while (count < data.size() && data[count] == 0x00)
    {
        ++count;
    }
 
    if (count == 0)
    {
        count = 1; // At least one padding byte was consumed (the type)
    }
 
    padding_frame f;
    f.count = count;
    return ok(std::make_pair(frame{f}, count));
}

References kcenon::network::protocols::quic::padding_frame::count, and kcenon::network::ok().

Here is the call graph for this function:

◆ parse_path_challenge()

auto kcenon::network::protocols::quic::frame_parser::parse_path_challenge ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 797 of file frame.cpp.

{
    if (data.size() < 8)
    {
        return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Insufficient path challenge data");
    }
 
    path_challenge_frame f;
    std::copy(data.begin(), data.begin() + 8, f.data.begin());
 
    return ok(std::make_pair(frame{f}, size_t{8}));
}

References kcenon::network::protocols::quic::path_challenge_frame::data, kcenon::network::error_codes::common_errors::invalid_argument, and kcenon::network::ok().

Here is the call graph for this function:

◆ parse_path_response()

auto kcenon::network::protocols::quic::frame_parser::parse_path_response ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 812 of file frame.cpp.

{
    if (data.size() < 8)
    {
        return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Insufficient path response data");
    }
 
    path_response_frame f;
    std::copy(data.begin(), data.begin() + 8, f.data.begin());
 
    return ok(std::make_pair(frame{f}, size_t{8}));
}

References kcenon::network::protocols::quic::path_response_frame::data, kcenon::network::error_codes::common_errors::invalid_argument, and kcenon::network::ok().

Here is the call graph for this function:

◆ parse_ping()

auto kcenon::network::protocols::quic::frame_parser::parse_ping ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 387 of file frame.cpp.

{
    // PING frame has no payload after type
    return ok(std::make_pair(frame{ping_frame{}}, size_t{0}));
}

References kcenon::network::ok().

Here is the call graph for this function:

◆ parse_reset_stream()

auto kcenon::network::protocols::quic::frame_parser::parse_reset_stream ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 478 of file frame.cpp.

{
    size_t offset = 0;
    reset_stream_frame f;
 
    auto stream_id = varint::decode(data.subspan(offset));
    if (stream_id.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse stream id");
    f.stream_id = stream_id.value().first;
    offset += stream_id.value().second;
 
    auto error_code = varint::decode(data.subspan(offset));
    if (error_code.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse error code");
    f.application_error_code = error_code.value().first;
    offset += error_code.value().second;
 
    auto final_size = varint::decode(data.subspan(offset));
    if (final_size.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse final size");
    f.final_size = final_size.value().first;
    offset += final_size.value().second;
 
    return ok(std::make_pair(frame{f}, offset));
}

References kcenon::network::protocols::quic::reset_stream_frame::application_error_code, kcenon::network::protocols::quic::varint::decode(), kcenon::network::protocols::quic::reset_stream_frame::final_size, kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::ok(), and kcenon::network::protocols::quic::reset_stream_frame::stream_id.

Here is the call graph for this function:

◆ parse_retire_connection_id()

auto kcenon::network::protocols::quic::frame_parser::parse_retire_connection_id ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 784 of file frame.cpp.

{
    retire_connection_id_frame f;
 
    auto seq = varint::decode(data);
    if (seq.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse sequence number");
    f.sequence_number = seq.value().first;
 
    return ok(std::make_pair(frame{f}, seq.value().second));
}

References kcenon::network::protocols::quic::varint::decode(), kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::ok(), and kcenon::network::protocols::quic::retire_connection_id_frame::sequence_number.

Here is the call graph for this function:

◆ parse_stop_sending()

auto kcenon::network::protocols::quic::frame_parser::parse_stop_sending ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 505 of file frame.cpp.

{
    size_t offset = 0;
    stop_sending_frame f;
 
    auto stream_id = varint::decode(data.subspan(offset));
    if (stream_id.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse stream id");
    f.stream_id = stream_id.value().first;
    offset += stream_id.value().second;
 
    auto error_code = varint::decode(data.subspan(offset));
    if (error_code.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse error code");
    f.application_error_code = error_code.value().first;
    offset += error_code.value().second;
 
    return ok(std::make_pair(frame{f}, offset));
}

References kcenon::network::protocols::quic::stop_sending_frame::application_error_code, kcenon::network::protocols::quic::varint::decode(), kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::ok(), and kcenon::network::protocols::quic::stop_sending_frame::stream_id.

Here is the call graph for this function:

◆ parse_stream()

auto kcenon::network::protocols::quic::frame_parser::parse_stream	(	std::span< const uint8_t >	data,
		uint8_t	flags ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 578 of file frame.cpp.

{
    size_t offset = 0;
    stream_frame f;
 
    // Stream ID
    auto stream_id = varint::decode(data.subspan(offset));
    if (stream_id.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse stream id");
    f.stream_id = stream_id.value().first;
    offset += stream_id.value().second;
 
    // Offset (if OFF bit set)
    if (flags & stream_flags::off)
    {
        auto stream_offset = varint::decode(data.subspan(offset));
        if (stream_offset.is_err()) return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Failed to parse stream offset");
        f.offset = stream_offset.value().first;
        offset += stream_offset.value().second;
    }
 
    // Length (if LEN bit set)
    uint64_t length = 0;
    if (flags & stream_flags::len)
    {
        auto len_result = varint::decode(data.subspan(offset));
        if (len_result.is_err()) return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Failed to parse stream length");
        length = len_result.value().first;
        offset += len_result.value().second;
    }
    else
    {
        // Without LEN, data extends to end of packet
        length = data.size() - offset;
    }
 
    // FIN bit
    f.fin = (flags & stream_flags::fin) != 0;
 
    // Data
    if (data.size() - offset < length)
    {
        return make_error<std::pair<frame, size_t>>(
            error_codes::common_errors::invalid_argument, "Insufficient stream data");
    }
 
    f.data.assign(data.begin() + offset, data.begin() + offset + length);
    offset += length;
 
    return ok(std::make_pair(frame{f}, offset));
}

Here is the call graph for this function:

◆ parse_stream_data_blocked()

auto kcenon::network::protocols::quic::frame_parser::parse_stream_data_blocked ( std::span< const uint8_t > data ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 694 of file frame.cpp.

{
    size_t offset = 0;
    stream_data_blocked_frame f;
 
    auto stream_id = varint::decode(data.subspan(offset));
    if (stream_id.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse stream id");
    f.stream_id = stream_id.value().first;
    offset += stream_id.value().second;
 
    auto max_data = varint::decode(data.subspan(offset));
    if (max_data.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse max stream data");
    f.maximum_stream_data = max_data.value().first;
    offset += max_data.value().second;
 
    return ok(std::make_pair(frame{f}, offset));
}

References kcenon::network::protocols::quic::varint::decode(), kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::protocols::quic::max_data, kcenon::network::protocols::quic::stream_data_blocked_frame::maximum_stream_data, kcenon::network::ok(), and kcenon::network::protocols::quic::stream_data_blocked_frame::stream_id.

Here is the call graph for this function:

◆ parse_streams_blocked()

auto kcenon::network::protocols::quic::frame_parser::parse_streams_blocked	(	std::span< const uint8_t >	data,
		bool	bidi ) -> Result<std::pair<frame, size_t>>

staticnodiscardprivate

Definition at line 715 of file frame.cpp.

{
    streams_blocked_frame f;
    f.bidirectional = bidi;
 
    auto max_streams = varint::decode(data);
    if (max_streams.is_err()) return make_error<std::pair<frame, size_t>>(
        error_codes::common_errors::invalid_argument, "Failed to parse max streams");
    f.maximum_streams = max_streams.value().first;
 
    return ok(std::make_pair(frame{f}, max_streams.value().second));
}

References kcenon::network::protocols::quic::streams_blocked_frame::bidirectional, kcenon::network::protocols::quic::varint::decode(), kcenon::network::error_codes::common_errors::invalid_argument, kcenon::network::protocols::quic::streams_blocked_frame::maximum_streams, and kcenon::network::ok().

Here is the call graph for this function:

◆ peek_type()

auto kcenon::network::protocols::quic::frame_parser::peek_type ( std::span< const uint8_t > data ) -> Result<std::pair<uint64_t, size_t>>

staticnodiscard

Get the frame type from raw data without full parsing.

Parameters

data	Input buffer

Returns: Result containing (frame_type_value, bytes_consumed) or error

Definition at line 116 of file frame.cpp.

{
    return varint::decode(data);
}

References kcenon::network::protocols::quic::varint::decode().

Here is the call graph for this function:

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

src/internal/protocols/quic/frame.h
src/protocols/quic/frame.cpp

Static Public Member Functions

Static Private Member Functions

Detailed Description

Member Function Documentation

◆ parse()

◆ parse_ack()

◆ parse_all()

◆ parse_connection_close()

◆ parse_crypto()

◆ parse_data_blocked()

◆ parse_handshake_done()

◆ parse_max_data()

◆ parse_max_stream_data()

◆ parse_max_streams()

◆ parse_new_connection_id()

◆ parse_new_token()

◆ parse_padding()

◆ parse_path_challenge()

◆ parse_path_response()

◆ parse_ping()

◆ parse_reset_stream()

◆ parse_retire_connection_id()

◆ parse_stop_sending()

◆ parse_stream()

◆ parse_stream_data_blocked()

◆ parse_streams_blocked()

◆ peek_type()