kcenon::network::protocols::http2::hpack_decoder Class Reference

HPACK header decoder (RFC 7541) More...

#include <hpack.h>

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

Public Member Functions
	hpack_decoder (size_t max_table_size=4096)
	Construct decoder with max table size.
auto	decode (std::span< const uint8_t > data) -> Result< std::vector< http_header > >
	Decode HPACK binary to headers.
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	decode_integer (std::span< const uint8_t > &data, uint8_t prefix_bits) -> Result< uint64_t >
auto	decode_string (std::span< const uint8_t > &data) -> Result< std::string >
auto	get_indexed_header (size_t index) const -> Result< http_header >

Private Attributes
dynamic_table	table_

Detailed Description

HPACK header decoder (RFC 7541)

Decodes HPACK compressed headers with dynamic table.

Definition at line 208 of file hpack.h.

Constructor & Destructor Documentation

hpack_decoder()

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

explicit

Construct decoder with max table size.

Parameters

max_table_size

Maximum dynamic table size (default 4096)

Definition at line 402 of file hpack.cpp.

        : table_(max_table_size)
    {
    }

Member Function Documentation

decode()

auto kcenon::network::protocols::http2::hpack_decoder::decode

(

std::span< const uint8_t >

data

)

-> Result<std::vector<http_header>>

Decode HPACK binary to headers.

Parameters

data	Encoded HPACK data

Returns

Decoded headers or error

Definition at line 407 of file hpack.cpp.

    {
        std::vector<http_header> headers;
        auto remaining = data;
 
        while (!remaining.empty())
        {
            uint8_t first_byte = remaining[0];
 
            if (first_byte & 0x80)
            {
                // Indexed header field representation
                auto index_result = decode_integer(remaining, 7);
                if (index_result.is_err())
                {
                    return index_result.error();
                }
                size_t index = index_result.value();
 
                auto header_result = get_indexed_header(index);
                if (header_result.is_err())
                {
                    return header_result.error();
                }
 
                headers.push_back(header_result.value());
            }
            else if (first_byte & 0x40)
            {
                // Literal with incremental indexing
                auto name_index_result = decode_integer(remaining, 6);
                if (name_index_result.is_err())
                {
                    return name_index_result.error();
                }
                size_t name_index = name_index_result.value();
 
                std::string name;
                if (name_index == 0)
                {
                    // New name
                    auto name_result = decode_string(remaining);
                    if (name_result.is_err())
                    {
                        return name_result.error();
                    }
                    name = name_result.value();
                }
                else
                {
                    // Indexed name
                    auto header_result = get_indexed_header(name_index);
                    if (header_result.is_err())
                    {
                        return header_result.error();
                    }
                    name = header_result.value().name;
                }
 
                // Decode value
                auto value_result = decode_string(remaining);
                if (value_result.is_err())
                {
                    return value_result.error();
                }
                std::string value = value_result.value();
 
                headers.emplace_back(name, value);
                table_.insert(name, value);
            }
            else
            {
                // Literal without indexing or never indexed
                uint8_t prefix_bits = (first_byte & 0x10) ? 4 : 4;
 
                auto name_index_result = decode_integer(remaining, prefix_bits);
                if (name_index_result.is_err())
                {
                    return name_index_result.error();
                }
                size_t name_index = name_index_result.value();
 
                std::string name;
                if (name_index == 0)
                {
                    // New name
                    auto name_result = decode_string(remaining);
                    if (name_result.is_err())
                    {
                        return name_result.error();
                    }
                    name = name_result.value();
                }
                else
                {
                    // Indexed name
                    auto header_result = get_indexed_header(name_index);
                    if (header_result.is_err())
                    {
                        return header_result.error();
                    }
                    name = header_result.value().name;
                }
 
                // Decode value
                auto value_result = decode_string(remaining);
                if (value_result.is_err())
                {
                    return value_result.error();
                }
 
                headers.emplace_back(name, value_result.value());
            }
        }
 
        return headers;
    }

References kcenon::network::protocols::http2::data, and kcenon::network::protocols::http2::headers.

decode_integer()

auto kcenon::network::protocols::http2::hpack_decoder::decode_integer ( std::span< const uint8_t > & data, uint8_t prefix_bits ) -> Result<uint64_t>

private

Definition at line 536 of file hpack.cpp.

    {
        if (data.empty())
        {
            return error_info(100, "Insufficient data for integer", "hpack");
        }
 
        uint8_t prefix_mask = (1 << prefix_bits) - 1;
        uint64_t value = data[0] & prefix_mask;
        data = data.subspan(1);
 
        if (value < prefix_mask)
        {
            return value;
        }
 
        // Multi-byte integer
        uint64_t m = 0;
        do
        {
            if (data.empty())
            {
                return error_info(101, "Incomplete integer encoding", "hpack");
            }
 
            uint8_t byte = data[0];
            data = data.subspan(1);
 
            value += (byte & 0x7F) << m;
            m += 7;
 
            if (m >= 64)
            {
                return error_info(102, "Integer overflow", "hpack");
            }
 
            if ((byte & 0x80) == 0)
            {
                break;
            }
        } while (true);
 
        return value;
    }

References kcenon::network::protocols::http2::data.

decode_string()

auto kcenon::network::protocols::http2::hpack_decoder::decode_string ( std::span< const uint8_t > & data ) -> Result<std::string>

private

Definition at line 583 of file hpack.cpp.

    {
        if (data.empty())
        {
            return error_info(103, "Insufficient data for string", "hpack");
        }
 
        bool huffman = (data[0] & 0x80) != 0;
 
        auto length_result = decode_integer(data, 7);
        if (length_result.is_err())
        {
            return length_result.error();
        }
 
        size_t length = length_result.value();
 
        if (data.size() < length)
        {
            return error_info(104, "Insufficient data for string value", "hpack");
        }
 
        std::string result;
        if (huffman)
        {
            // Huffman decoding not implemented yet - just return raw for now
            result.assign(data.begin(), data.begin() + length);
        }
        else
        {
            result.assign(data.begin(), data.begin() + length);
        }
 
        data = data.subspan(length);
        return result;
    }

References kcenon::network::protocols::http2::data.

get_indexed_header()

auto kcenon::network::protocols::http2::hpack_decoder::get_indexed_header ( size_t index ) const -> Result<http_header>

private

Definition at line 621 of file hpack.cpp.

    {
        if (index == 0)
        {
            return error_info(105, "Invalid index 0", "hpack");
        }
 
        // Check static table
        if (index <= static_table::size())
        {
            auto header = static_table::get(index);
            if (header.has_value())
            {
                return std::move(header.value());
            }
            return error_info(106, "Invalid static table index", "hpack");
        }
 
        // Check dynamic table
        size_t dynamic_index = index - static_table::size() - 1;
        auto header = table_.get(dynamic_index);
        if (header.has_value())
        {
            return std::move(header.value());
        }
 
        return error_info(107, "Invalid dynamic table index", "hpack");
    }

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

Here is the call graph for this function:

set_max_table_size()

auto kcenon::network::protocols::http2::hpack_decoder::set_max_table_size

(

size_t

size

)

-> void

Set maximum dynamic table size.

Parameters

size	New maximum size

Definition at line 526 of file hpack.cpp.

    {
        table_.set_max_size(size);
    }

table_size()

auto kcenon::network::protocols::http2::hpack_decoder::table_size

(

)

const -> size_t

Get current dynamic table size.

Returns

Current size in bytes

Definition at line 531 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_decoder::table_

private

Definition at line 242 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