kcenon::network::protocols::http2::hpack_encoder Class Reference

HPACK header encoder (RFC 7541) More...

#include <hpack.h>

Collaboration diagram for kcenon::network::protocols::http2::hpack_encoder:

Public Member Functions
	hpack_encoder (size_t max_table_size=4096)
	Construct encoder with max table size.
auto	encode (const std::vector< http_header > &headers) -> std::vector< uint8_t >
	Encode headers to HPACK binary format.
auto	set_max_table_size (size_t size) -> void
	Set maximum dynamic table size.
auto	table_size () const -> size_t
	Get current dynamic table size.

Private Member Functions
auto	encode_integer (uint64_t value, uint8_t prefix_bits) -> std::vector< uint8_t >
auto	encode_string (std::string_view str, bool huffman=false) -> std::vector< uint8_t >
auto	encode_indexed (size_t index) -> std::vector< uint8_t >
auto	encode_literal_with_indexing (std::string_view name, std::string_view value) -> std::vector< uint8_t >
auto	encode_literal_with_indexing (size_t name_index, std::string_view value) -> std::vector< uint8_t >
auto	encode_literal_without_indexing (std::string_view name, std::string_view value) -> std::vector< uint8_t >
auto	encode_literal_without_indexing (size_t name_index, std::string_view value) -> std::vector< uint8_t >

Private Attributes
dynamic_table	table_

Detailed Description

HPACK header encoder (RFC 7541)

Encodes HTTP headers using HPACK compression with dynamic table.

Definition at line 158 of file hpack.h.

Constructor & Destructor Documentation

hpack_encoder()

kcenon::network::protocols::http2::hpack_encoder::hpack_encoder ( size_t max_table_size = 4096 )

explicit

Construct encoder with max table size.

Parameters

max_table_size

Maximum dynamic table size (default 4096)

Definition at line 192 of file hpack.cpp.

        : table_(max_table_size)
    {
    }

Member Function Documentation

encode()

auto kcenon::network::protocols::http2::hpack_encoder::encode

(

const std::vector< http_header > &

headers

)

-> std::vector<uint8_t>

Encode headers to HPACK binary format.

Parameters

headers

Headers to encode

Returns

Encoded bytes

Definition at line 197 of file hpack.cpp.

    {
        std::vector<uint8_t> result;
 
        for (const auto& header : headers)
        {
            // Try to find in static table first
            size_t static_index = static_table::find(header.name, header.value);
            if (static_index > 0)
            {
                // Indexed header field representation
                auto encoded = encode_indexed(static_index);
                result.insert(result.end(), encoded.begin(), encoded.end());
                continue;
            }
 
            // Try to find in dynamic table
            auto dynamic_index = table_.find(header.name, header.value);
            if (dynamic_index.has_value())
            {
                // Indexed header field representation
                size_t index = static_table::size() + 1 + dynamic_index.value();
                auto encoded = encode_indexed(index);
                result.insert(result.end(), encoded.begin(), encoded.end());
                continue;
            }
 
            // Check if name is in static table
            size_t name_index = static_table::find(header.name, "");
            if (name_index > 0)
            {
                // Literal with incremental indexing - indexed name
                auto encoded = encode_literal_with_indexing(name_index, header.value);
                result.insert(result.end(), encoded.begin(), encoded.end());
                table_.insert(header.name, header.value);
            }
            else
            {
                // Check if name is in dynamic table
                auto dynamic_name_index = table_.find(header.name, "");
                if (dynamic_name_index.has_value())
                {
                    size_t index = static_table::size() + 1 + dynamic_name_index.value();
                    auto encoded = encode_literal_with_indexing(index, header.value);
                    result.insert(result.end(), encoded.begin(), encoded.end());
                    table_.insert(header.name, header.value);
                }
                else
                {
                    // Literal with incremental indexing - new name
                    auto encoded = encode_literal_with_indexing(header.name, header.value);
                    result.insert(result.end(), encoded.begin(), encoded.end());
                    table_.insert(header.name, header.value);
                }
            }
        }
 
        return result;
    }

References kcenon::network::protocols::http2::static_table::find(), kcenon::network::protocols::http2::headers, and kcenon::network::protocols::http2::static_table::size().

Here is the call graph for this function:

encode_indexed()

auto kcenon::network::protocols::http2::hpack_encoder::encode_indexed ( size_t index ) -> std::vector<uint8_t>

private

Definition at line 322 of file hpack.cpp.

    {
        auto result = encode_integer(index, 7);
        result[0] |= 0x80;  // Set indexed bit
        return result;
    }

encode_integer()

auto kcenon::network::protocols::http2::hpack_encoder::encode_integer ( uint64_t value, uint8_t prefix_bits ) -> std::vector<uint8_t>

private

Definition at line 268 of file hpack.cpp.

    {
        std::vector<uint8_t> result;
        uint8_t max_prefix = (1 << prefix_bits) - 1;
 
        if (value < max_prefix)
        {
            result.push_back(static_cast<uint8_t>(value));
        }
        else
        {
            result.push_back(max_prefix);
            value -= max_prefix;
 
            while (value >= 128)
            {
                result.push_back(static_cast<uint8_t>((value % 128) + 128));
                value /= 128;
            }
            result.push_back(static_cast<uint8_t>(value));
        }
 
        return result;
    }

encode_literal_with_indexing() [1/2]

auto kcenon::network::protocols::http2::hpack_encoder::encode_literal_with_indexing ( size_t name_index, std::string_view value ) -> std::vector<uint8_t>

private

Definition at line 349 of file hpack.cpp.

    {
        std::vector<uint8_t> result;
 
        // Encode name index with 6-bit prefix
        auto index_bytes = encode_integer(name_index, 6);
        index_bytes[0] |= 0x40;  // Set literal with indexing bit
        result.insert(result.end(), index_bytes.begin(), index_bytes.end());
 
        // Encode value
        auto value_bytes = encode_string(value);
        result.insert(result.end(), value_bytes.begin(), value_bytes.end());
 
        return result;
    }

encode_literal_with_indexing() [2/2]

auto kcenon::network::protocols::http2::hpack_encoder::encode_literal_with_indexing ( std::string_view name, std::string_view value ) -> std::vector<uint8_t>

private

Definition at line 329 of file hpack.cpp.

    {
        std::vector<uint8_t> result;
 
        // First byte: 01xxxxxx (literal with incremental indexing, new name)
        result.push_back(0x40);
 
        // Encode name
        auto name_bytes = encode_string(name);
        result.insert(result.end(), name_bytes.begin(), name_bytes.end());
 
        // Encode value
        auto value_bytes = encode_string(value);
        result.insert(result.end(), value_bytes.begin(), value_bytes.end());
 
        return result;
    }

encode_literal_without_indexing() [1/2]

auto kcenon::network::protocols::http2::hpack_encoder::encode_literal_without_indexing ( size_t name_index, std::string_view value ) -> std::vector<uint8_t>

private

Definition at line 387 of file hpack.cpp.

    {
        std::vector<uint8_t> result;
 
        // Encode name index with 4-bit prefix
        auto index_bytes = encode_integer(name_index, 4);
        // First byte already has 0000 prefix for literal without indexing
        result.insert(result.end(), index_bytes.begin(), index_bytes.end());
 
        // Encode value
        auto value_bytes = encode_string(value);
        result.insert(result.end(), value_bytes.begin(), value_bytes.end());
 
        return result;
    }

encode_literal_without_indexing() [2/2]

auto kcenon::network::protocols::http2::hpack_encoder::encode_literal_without_indexing ( std::string_view name, std::string_view value ) -> std::vector<uint8_t>

private

Definition at line 367 of file hpack.cpp.

    {
        std::vector<uint8_t> result;
 
        // First byte: 0000xxxx (literal without indexing, new name)
        result.push_back(0x00);
 
        // Encode name
        auto name_bytes = encode_string(name);
        result.insert(result.end(), name_bytes.begin(), name_bytes.end());
 
        // Encode value
        auto value_bytes = encode_string(value);
        result.insert(result.end(), value_bytes.begin(), value_bytes.end());
 
        return result;
    }

encode_string()

auto kcenon::network::protocols::http2::hpack_encoder::encode_string ( std::string_view str, bool huffman = false ) -> std::vector<uint8_t>

private

Definition at line 294 of file hpack.cpp.

    {
        std::vector<uint8_t> result;
 
        if (huffman)
        {
            // Only use Huffman coding when it actually shrinks the string;
            // RFC 7541 5.2 lets the encoder choose per string.
            auto encoded = huffman::encode(str);
            if (encoded.size() < str.size())
            {
                auto length_bytes = encode_integer(encoded.size(), 7);
                length_bytes[0] |= 0x80;  // Set H bit
                result.insert(result.end(), length_bytes.begin(), length_bytes.end());
                result.insert(result.end(), encoded.begin(), encoded.end());
                return result;
            }
        }
 
        // Raw literal: length with the H bit clear, then the octets verbatim.
        auto length_bytes = encode_integer(str.size(), 7);
        result.insert(result.end(), length_bytes.begin(), length_bytes.end());
        result.insert(result.end(), str.begin(), str.end());
 
        return result;
    }

References kcenon::network::protocols::http2::huffman::encode().

Here is the call graph for this function:

set_max_table_size()

auto kcenon::network::protocols::http2::hpack_encoder::set_max_table_size

(

size_t

size

)

-> void

Set maximum dynamic table size.

Parameters

size	New maximum size

Definition at line 258 of file hpack.cpp.

    {
        table_.set_max_size(size);
    }

table_size()

auto kcenon::network::protocols::http2::hpack_encoder::table_size

(

)

const -> size_t

Get current dynamic table size.

Returns

Current size in bytes

Definition at line 263 of file hpack.cpp.

    {
        return table_.current_size();
    }

References kcenon::network::protocols::http2::dynamic_table::current_size(), and table_.

Here is the call graph for this function:

Member Data Documentation

table_

dynamic_table kcenon::network::protocols::http2::hpack_encoder::table_

private

Definition at line 199 of file hpack.h.

Referenced by table_size().

---

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

• src/internal/protocols/http2/hpack.h
• src/protocols/http2/hpack.cpp