kcenon::network::protocols::http2::huffman Namespace Reference

Functions
auto	encode (std::string_view input) -> std::vector< uint8_t >
	Encode string using Huffman coding.
auto	decode (std::span< const uint8_t > data) -> Result< std::string >
	Decode Huffman encoded string.
auto	encoded_size (std::string_view input) -> size_t
	Get encoded size for string.

Function Documentation

decode()

auto kcenon::network::protocols::http2::huffman::decode

(

std::span< const uint8_t >

data

)

-> Result<std::string>

Decode Huffman encoded string.

Parameters

data	Encoded bytes

Returns

Decoded string or error

Definition at line 808 of file hpack.cpp.

        {
            static const std::vector<decode_node> tree = build_decode_tree();
 
            std::string out;
            int node = 0;
            int partial_bits = 0;
            bool partial_all_ones = true;
 
            for (uint8_t byte : data)
            {
                for (int i = 7; i >= 0; --i)
                {
                    int bit = (byte >> i) & 1;
                    node = tree[node].children[bit];
                    if (node == -1)
                    {
                        return error_info(108, "Invalid Huffman code", "hpack");
                    }
                    ++partial_bits;
                    if (bit == 0)
                    {
                        partial_all_ones = false;
                    }
 
                    if (tree[node].symbol >= 0)
                    {
                        if (tree[node].symbol == kEosSymbol)
                        {
                            // RFC 7541 5.2: EOS in the encoded data is an error.
                            return error_info(108, "EOS symbol in Huffman-encoded data",
                                              "hpack");
                        }
                        out.push_back(static_cast<char>(tree[node].symbol));
                        node = 0;
                        partial_bits = 0;
                        partial_all_ones = true;
                    }
                }
            }
 
            // RFC 7541 5.2: any trailing bits must be valid EOS padding —
            // at most 7 bits, all set to 1.
            if (node != 0 && (partial_bits > 7 || !partial_all_ones))
            {
                return error_info(108, "Invalid Huffman padding", "hpack");
            }
 
            return out;
        }

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

Referenced by kcenon::network::protocols::http2::hpack_decoder::decode_string().

Here is the caller graph for this function:

encode()

auto kcenon::network::protocols::http2::huffman::encode

(

std::string_view

input

)

-> std::vector<uint8_t>

Encode string using Huffman coding.

Parameters

input

String to encode

Returns

Encoded bytes

Definition at line 775 of file hpack.cpp.

        {
            std::vector<uint8_t> out;
            out.reserve(input.size());
 
            uint64_t buffer = 0;
            int buffer_bits = 0;
 
            for (unsigned char ch : input)
            {
                const auto& entry = kHuffmanTable[ch];
                buffer = (buffer << entry.bits) | entry.code;
                buffer_bits += entry.bits;
 
                while (buffer_bits >= 8)
                {
                    buffer_bits -= 8;
                    out.push_back(static_cast<uint8_t>(buffer >> buffer_bits));
                }
                // Keep only the still-pending low bits to avoid emitting stale data.
                buffer &= (1ull << buffer_bits) - 1;
            }
 
            if (buffer_bits > 0)
            {
                // Pad the final byte with the most significant bits of EOS (all 1s).
                int pad = 8 - buffer_bits;
                out.push_back(static_cast<uint8_t>((buffer << pad) | ((1u << pad) - 1)));
            }
 
            return out;
        }

Referenced by kcenon::network::protocols::http2::hpack_encoder::encode_string().

Here is the caller graph for this function:

encoded_size()

auto kcenon::network::protocols::http2::huffman::encoded_size

(

std::string_view

input

)

-> size_t

Get encoded size for string.

Parameters

input

String to measure

Returns

Size in bytes if Huffman encoded

Definition at line 859 of file hpack.cpp.

        {
            size_t bits = 0;
            for (unsigned char ch : input)
            {
                bits += kHuffmanTable[ch].bits;
            }
            return (bits + 7) / 8;
        }

References bits.