kcenon::network::protocols::quic::frame_builder Class Reference

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

#include <frame.h>

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

Static Public Member Functions
static auto	build (const frame &f) -> std::vector< uint8_t >
	Build any frame from variant.
static auto	build_padding (size_t count=1) -> std::vector< uint8_t >
	Build PADDING frame.
static auto	build_ping () -> std::vector< uint8_t >
	Build PING frame.
static auto	build_ack (const ack_frame &f) -> std::vector< uint8_t >
	Build ACK frame.
static auto	build_reset_stream (const reset_stream_frame &f) -> std::vector< uint8_t >
	Build RESET_STREAM frame.
static auto	build_stop_sending (const stop_sending_frame &f) -> std::vector< uint8_t >
	Build STOP_SENDING frame.
static auto	build_crypto (const crypto_frame &f) -> std::vector< uint8_t >
	Build CRYPTO frame.
static auto	build_new_token (const new_token_frame &f) -> std::vector< uint8_t >
	Build NEW_TOKEN frame.
static auto	build_stream (const stream_frame &f, bool include_length=true) -> std::vector< uint8_t >
	Build STREAM frame.
static auto	build_max_data (const max_data_frame &f) -> std::vector< uint8_t >
	Build MAX_DATA frame.
static auto	build_max_stream_data (const max_stream_data_frame &f) -> std::vector< uint8_t >
	Build MAX_STREAM_DATA frame.
static auto	build_max_streams (const max_streams_frame &f) -> std::vector< uint8_t >
	Build MAX_STREAMS frame.
static auto	build_data_blocked (const data_blocked_frame &f) -> std::vector< uint8_t >
	Build DATA_BLOCKED frame.
static auto	build_stream_data_blocked (const stream_data_blocked_frame &f) -> std::vector< uint8_t >
	Build STREAM_DATA_BLOCKED frame.
static auto	build_streams_blocked (const streams_blocked_frame &f) -> std::vector< uint8_t >
	Build STREAMS_BLOCKED frame.
static auto	build_new_connection_id (const new_connection_id_frame &f) -> std::vector< uint8_t >
	Build NEW_CONNECTION_ID frame.
static auto	build_retire_connection_id (const retire_connection_id_frame &f) -> std::vector< uint8_t >
	Build RETIRE_CONNECTION_ID frame.
static auto	build_path_challenge (const path_challenge_frame &f) -> std::vector< uint8_t >
	Build PATH_CHALLENGE frame.
static auto	build_path_response (const path_response_frame &f) -> std::vector< uint8_t >
	Build PATH_RESPONSE frame.
static auto	build_connection_close (const connection_close_frame &f) -> std::vector< uint8_t >
	Build CONNECTION_CLOSE frame.
static auto	build_handshake_done () -> std::vector< uint8_t >
	Build HANDSHAKE_DONE frame.

Static Private Member Functions
static void	append_varint (std::vector< uint8_t > &buffer, uint64_t value)
static void	append_bytes (std::vector< uint8_t > &buffer, std::span< const uint8_t > data)

Detailed Description

Builder for QUIC frames (RFC 9000 Section 12)

Serializes QUIC frame structures into raw bytes.

Definition at line 121 of file frame.h.

Member Function Documentation

append_bytes()

void kcenon::network::protocols::quic::frame_builder::append_bytes ( std::vector< uint8_t > & buffer, std::span< const uint8_t > data )

staticprivate

Definition at line 885 of file frame.cpp.

{
    buffer.insert(buffer.end(), data.begin(), data.end());
}

append_varint()

void kcenon::network::protocols::quic::frame_builder::append_varint ( std::vector< uint8_t > & buffer, uint64_t value )

staticprivate

Definition at line 879 of file frame.cpp.

{
    auto encoded = varint::encode(value);
    buffer.insert(buffer.end(), encoded.begin(), encoded.end());
}

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

Here is the call graph for this function:

build()

auto kcenon::network::protocols::quic::frame_builder::build ( const frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build any frame from variant.

Parameters

f	Frame to serialize

Returns

Serialized frame bytes

Definition at line 891 of file frame.cpp.

{
    return std::visit([](const auto& fr) -> std::vector<uint8_t> {
        using T = std::decay_t<decltype(fr)>;
        if constexpr (std::is_same_v<T, padding_frame>)
            return build_padding(fr.count);
        else if constexpr (std::is_same_v<T, ping_frame>)
            return build_ping();
        else if constexpr (std::is_same_v<T, ack_frame>)
            return build_ack(fr);
        else if constexpr (std::is_same_v<T, reset_stream_frame>)
            return build_reset_stream(fr);
        else if constexpr (std::is_same_v<T, stop_sending_frame>)
            return build_stop_sending(fr);
        else if constexpr (std::is_same_v<T, crypto_frame>)
            return build_crypto(fr);
        else if constexpr (std::is_same_v<T, new_token_frame>)
            return build_new_token(fr);
        else if constexpr (std::is_same_v<T, stream_frame>)
            return build_stream(fr);
        else if constexpr (std::is_same_v<T, max_data_frame>)
            return build_max_data(fr);
        else if constexpr (std::is_same_v<T, max_stream_data_frame>)
            return build_max_stream_data(fr);
        else if constexpr (std::is_same_v<T, max_streams_frame>)
            return build_max_streams(fr);
        else if constexpr (std::is_same_v<T, data_blocked_frame>)
            return build_data_blocked(fr);
        else if constexpr (std::is_same_v<T, stream_data_blocked_frame>)
            return build_stream_data_blocked(fr);
        else if constexpr (std::is_same_v<T, streams_blocked_frame>)
            return build_streams_blocked(fr);
        else if constexpr (std::is_same_v<T, new_connection_id_frame>)
            return build_new_connection_id(fr);
        else if constexpr (std::is_same_v<T, retire_connection_id_frame>)
            return build_retire_connection_id(fr);
        else if constexpr (std::is_same_v<T, path_challenge_frame>)
            return build_path_challenge(fr);
        else if constexpr (std::is_same_v<T, path_response_frame>)
            return build_path_response(fr);
        else if constexpr (std::is_same_v<T, connection_close_frame>)
            return build_connection_close(fr);
        else if constexpr (std::is_same_v<T, handshake_done_frame>)
            return build_handshake_done();
        else
            return {};
    }, f);
}

Referenced by kcenon::network::protocols::quic::connection::build_packet(), and kcenon::network::internal::quic_socket::send_packet().

Here is the caller graph for this function:

build_ack()

auto kcenon::network::protocols::quic::frame_builder::build_ack ( const ack_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build ACK frame.

Parameters

f	ACK frame structure

Returns

Serialized frame bytes

Definition at line 950 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
 
    // Frame type
    append_varint(buffer, f.ecn ? static_cast<uint64_t>(frame_type::ack_ecn)
                                : static_cast<uint64_t>(frame_type::ack));
 
    // Largest Acknowledged
    append_varint(buffer, f.largest_acknowledged);
 
    // ACK Delay
    append_varint(buffer, f.ack_delay);
 
    // ACK Range Count
    append_varint(buffer, f.ranges.size());
 
    // First ACK Range (largest_ack - smallest_ack in first range)
    // For simplicity, we'll use 0 if no ranges are specified
    uint64_t first_range = 0;
    if (!f.ranges.empty())
    {
        first_range = f.ranges[0].length;
    }
    append_varint(buffer, first_range);
 
    // Additional ranges (skip first)
    for (size_t i = 1; i < f.ranges.size(); ++i)
    {
        append_varint(buffer, f.ranges[i].gap);
        append_varint(buffer, f.ranges[i].length);
    }
 
    // ECN Counts
    if (f.ecn)
    {
        append_varint(buffer, f.ecn->ect0);
        append_varint(buffer, f.ecn->ect1);
        append_varint(buffer, f.ecn->ecn_ce);
    }
 
    return buffer;
}

References kcenon::network::protocols::quic::ack, and kcenon::network::protocols::quic::ack_ecn.

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

Here is the caller graph for this function:

build_connection_close()

auto kcenon::network::protocols::quic::frame_builder::build_connection_close ( const connection_close_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build CONNECTION_CLOSE frame.

Parameters

f	CONNECTION_CLOSE frame structure

Returns

Serialized frame bytes

Definition at line 1173 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
    append_varint(buffer, f.is_application_error
        ? static_cast<uint64_t>(frame_type::connection_close_app)
        : static_cast<uint64_t>(frame_type::connection_close));
 
    append_varint(buffer, f.error_code);
 
    // Frame Type (transport close only)
    if (!f.is_application_error)
    {
        append_varint(buffer, f.frame_type);
    }
 
    // Reason Phrase Length
    append_varint(buffer, f.reason_phrase.size());
 
    // Reason Phrase
    buffer.insert(buffer.end(), f.reason_phrase.begin(), f.reason_phrase.end());
 
    return buffer;
}

References kcenon::network::protocols::quic::connection_close, and kcenon::network::protocols::quic::connection_close_app.

build_crypto()

auto kcenon::network::protocols::quic::frame_builder::build_crypto ( const crypto_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build CRYPTO frame.

Parameters

f	CRYPTO frame structure

Returns

Serialized frame bytes

Definition at line 1015 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
    append_varint(buffer, static_cast<uint64_t>(frame_type::crypto));
    append_varint(buffer, f.offset);
    append_varint(buffer, f.data.size());
    append_bytes(buffer, f.data);
    return buffer;
}

References kcenon::network::protocols::quic::crypto.

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

Here is the caller graph for this function:

build_data_blocked()

auto kcenon::network::protocols::quic::frame_builder::build_data_blocked ( const data_blocked_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build DATA_BLOCKED frame.

Parameters

f	DATA_BLOCKED frame structure

Returns

Serialized frame bytes

Definition at line 1095 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
    append_varint(buffer, static_cast<uint64_t>(frame_type::data_blocked));
    append_varint(buffer, f.maximum_data);
    return buffer;
}

References kcenon::network::protocols::quic::data_blocked.

build_handshake_done()

auto kcenon::network::protocols::quic::frame_builder::build_handshake_done ( ) -> std::vector<uint8_t>

staticnodiscard

Build HANDSHAKE_DONE frame.

Returns

Serialized frame bytes

Definition at line 1198 of file frame.cpp.

{
    return {static_cast<uint8_t>(frame_type::handshake_done)};
}

References kcenon::network::protocols::quic::handshake_done.

build_max_data()

auto kcenon::network::protocols::quic::frame_builder::build_max_data ( const max_data_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build MAX_DATA frame.

Parameters

f	MAX_DATA frame structure

Returns

Serialized frame bytes

Definition at line 1065 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
    append_varint(buffer, static_cast<uint64_t>(frame_type::max_data));
    append_varint(buffer, f.maximum_data);
    return buffer;
}

References kcenon::network::protocols::quic::max_data.

build_max_stream_data()

auto kcenon::network::protocols::quic::frame_builder::build_max_stream_data ( const max_stream_data_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build MAX_STREAM_DATA frame.

Parameters

f	MAX_STREAM_DATA frame structure

Returns

Serialized frame bytes

Definition at line 1074 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
    append_varint(buffer, static_cast<uint64_t>(frame_type::max_stream_data));
    append_varint(buffer, f.stream_id);
    append_varint(buffer, f.maximum_stream_data);
    return buffer;
}

References kcenon::network::protocols::quic::max_stream_data.

build_max_streams()

auto kcenon::network::protocols::quic::frame_builder::build_max_streams ( const max_streams_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build MAX_STREAMS frame.

Parameters

f	MAX_STREAMS frame structure

Returns

Serialized frame bytes

Definition at line 1084 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
    append_varint(buffer, f.bidirectional
        ? static_cast<uint64_t>(frame_type::max_streams_bidi)
        : static_cast<uint64_t>(frame_type::max_streams_uni));
    append_varint(buffer, f.maximum_streams);
    return buffer;
}

References kcenon::network::protocols::quic::max_streams_bidi, and kcenon::network::protocols::quic::max_streams_uni.

build_new_connection_id()

auto kcenon::network::protocols::quic::frame_builder::build_new_connection_id ( const new_connection_id_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build NEW_CONNECTION_ID frame.

Parameters

f	NEW_CONNECTION_ID frame structure

Returns

Serialized frame bytes

Definition at line 1125 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
    append_varint(buffer, static_cast<uint64_t>(frame_type::new_connection_id));
    append_varint(buffer, f.sequence_number);
    append_varint(buffer, f.retire_prior_to);
 
    // Connection ID length (1 byte, not varint)
    buffer.push_back(static_cast<uint8_t>(f.connection_id.size()));
 
    // Connection ID
    append_bytes(buffer, f.connection_id);
 
    // Stateless Reset Token
    buffer.insert(buffer.end(), f.stateless_reset_token.begin(),
                  f.stateless_reset_token.end());
 
    return buffer;
}

References kcenon::network::protocols::quic::new_connection_id.

build_new_token()

auto kcenon::network::protocols::quic::frame_builder::build_new_token ( const new_token_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build NEW_TOKEN frame.

Parameters

f	NEW_TOKEN frame structure

Returns

Serialized frame bytes

Definition at line 1025 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
    append_varint(buffer, static_cast<uint64_t>(frame_type::new_token));
    append_varint(buffer, f.token.size());
    append_bytes(buffer, f.token);
    return buffer;
}

References kcenon::network::protocols::quic::new_token.

build_padding()

auto kcenon::network::protocols::quic::frame_builder::build_padding ( size_t count = 1 ) -> std::vector<uint8_t>

staticnodiscard

Build PADDING frame.

Parameters

count

Number of padding bytes (default 1)

Returns

Serialized frame bytes

Definition at line 940 of file frame.cpp.

{
    return std::vector<uint8_t>(count, 0x00);
}

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

Here is the caller graph for this function:

build_path_challenge()

auto kcenon::network::protocols::quic::frame_builder::build_path_challenge ( const path_challenge_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build PATH_CHALLENGE frame.

Parameters

f	PATH_CHALLENGE frame structure

Returns

Serialized frame bytes

Definition at line 1155 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
    append_varint(buffer, static_cast<uint64_t>(frame_type::path_challenge));
    buffer.insert(buffer.end(), f.data.begin(), f.data.end());
    return buffer;
}

References kcenon::network::protocols::quic::path_challenge.

build_path_response()

auto kcenon::network::protocols::quic::frame_builder::build_path_response ( const path_response_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build PATH_RESPONSE frame.

Parameters

f	PATH_RESPONSE frame structure

Returns

Serialized frame bytes

Definition at line 1164 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
    append_varint(buffer, static_cast<uint64_t>(frame_type::path_response));
    buffer.insert(buffer.end(), f.data.begin(), f.data.end());
    return buffer;
}

References kcenon::network::protocols::quic::path_response.

build_ping()

auto kcenon::network::protocols::quic::frame_builder::build_ping ( ) -> std::vector<uint8_t>

staticnodiscard

Build PING frame.

Returns

Serialized frame bytes

Definition at line 945 of file frame.cpp.

{
    return {0x01};
}

build_reset_stream()

auto kcenon::network::protocols::quic::frame_builder::build_reset_stream ( const reset_stream_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build RESET_STREAM frame.

Parameters

f	RESET_STREAM frame structure

Returns

Serialized frame bytes

Definition at line 994 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
    append_varint(buffer, static_cast<uint64_t>(frame_type::reset_stream));
    append_varint(buffer, f.stream_id);
    append_varint(buffer, f.application_error_code);
    append_varint(buffer, f.final_size);
    return buffer;
}

References kcenon::network::protocols::quic::reset_stream.

build_retire_connection_id()

auto kcenon::network::protocols::quic::frame_builder::build_retire_connection_id ( const retire_connection_id_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build RETIRE_CONNECTION_ID frame.

Parameters

f	RETIRE_CONNECTION_ID frame structure

Returns

Serialized frame bytes

Definition at line 1146 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
    append_varint(buffer, static_cast<uint64_t>(frame_type::retire_connection_id));
    append_varint(buffer, f.sequence_number);
    return buffer;
}

References kcenon::network::protocols::quic::retire_connection_id.

build_stop_sending()

auto kcenon::network::protocols::quic::frame_builder::build_stop_sending ( const stop_sending_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build STOP_SENDING frame.

Parameters

f	STOP_SENDING frame structure

Returns

Serialized frame bytes

Definition at line 1005 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
    append_varint(buffer, static_cast<uint64_t>(frame_type::stop_sending));
    append_varint(buffer, f.stream_id);
    append_varint(buffer, f.application_error_code);
    return buffer;
}

References kcenon::network::protocols::quic::stop_sending.

build_stream()

auto kcenon::network::protocols::quic::frame_builder::build_stream ( const stream_frame & f, bool include_length = true ) -> std::vector<uint8_t>

staticnodiscard

Build STREAM frame.

Parameters

f	STREAM frame structure
include_length	Whether to include explicit length field

Returns

Serialized frame bytes

Definition at line 1035 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
 
    // Build frame type with flags
    uint8_t type = make_stream_type(f.fin, include_length, f.offset > 0);
    buffer.push_back(type);
 
    // Stream ID
    append_varint(buffer, f.stream_id);
 
    // Offset (if non-zero)
    if (f.offset > 0)
    {
        append_varint(buffer, f.offset);
    }
 
    // Length (if requested)
    if (include_length)
    {
        append_varint(buffer, f.data.size());
    }
 
    // Data
    append_bytes(buffer, f.data);
 
    return buffer;
}

References kcenon::network::protocols::quic::make_stream_type().

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

Here is the call graph for this function:

Here is the caller graph for this function:

build_stream_data_blocked()

auto kcenon::network::protocols::quic::frame_builder::build_stream_data_blocked ( const stream_data_blocked_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build STREAM_DATA_BLOCKED frame.

Parameters

f	STREAM_DATA_BLOCKED frame structure

Returns

Serialized frame bytes

Definition at line 1104 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
    append_varint(buffer, static_cast<uint64_t>(frame_type::stream_data_blocked));
    append_varint(buffer, f.stream_id);
    append_varint(buffer, f.maximum_stream_data);
    return buffer;
}

References kcenon::network::protocols::quic::stream_data_blocked.

build_streams_blocked()

auto kcenon::network::protocols::quic::frame_builder::build_streams_blocked ( const streams_blocked_frame & f ) -> std::vector<uint8_t>

staticnodiscard

Build STREAMS_BLOCKED frame.

Parameters

f	STREAMS_BLOCKED frame structure

Returns

Serialized frame bytes

Definition at line 1114 of file frame.cpp.

{
    std::vector<uint8_t> buffer;
    append_varint(buffer, f.bidirectional
        ? static_cast<uint64_t>(frame_type::streams_blocked_bidi)
        : static_cast<uint64_t>(frame_type::streams_blocked_uni));
    append_varint(buffer, f.maximum_streams);
    return buffer;
}

References kcenon::network::protocols::quic::streams_blocked_bidi, and kcenon::network::protocols::quic::streams_blocked_uni.

---

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

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