hpack.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "kcenon/network/detail/utils/result_types.h"
#include <cstdint>
#include <string>
#include <string_view>
#include <vector>
#include <deque>
#include <optional>
#include <span>
#include <map>
 
namespace kcenon::network::protocols::http2
{
    struct http_header
    {
        std::string name;   
        std::string value;  
 
        http_header() = default;
        http_header(std::string n, std::string v)
            : name(std::move(n)), value(std::move(v)) {}
 
        auto size() const -> size_t
        {
            return name.size() + value.size() + 32;  // RFC 7541: 32 byte overhead
        }
 
        bool operator==(const http_header& other) const
        {
            return name == other.name && value == other.value;
        }
    };
 
    class static_table
    {
    public:
        static auto get(size_t index) -> std::optional<http_header>;
 
        static auto find(std::string_view name, std::string_view value = "")
            -> size_t;
 
        static constexpr auto size() -> size_t { return 61; }
    };
 
    class dynamic_table
    {
    public:
        explicit dynamic_table(size_t max_size = 4096);
 
        auto insert(std::string_view name, std::string_view value) -> void;
 
        auto get(size_t index) const -> std::optional<http_header>;
 
        auto find(std::string_view name, std::string_view value = "") const
            -> std::optional<size_t>;
 
        auto set_max_size(size_t size) -> void;
 
        auto current_size() const -> size_t;
 
        auto max_size() const -> size_t;
 
        auto entry_count() const -> size_t;
 
        auto clear() -> void;
 
    private:
        auto evict_to_size(size_t target_size) -> void;
 
        std::deque<http_header> entries_;
        size_t current_size_ = 0;
        size_t max_size_;
    };
 
    class hpack_encoder
    {
    public:
        explicit hpack_encoder(size_t max_table_size = 4096);
 
        auto encode(const std::vector<http_header>& headers) -> std::vector<uint8_t>;
 
        auto set_max_table_size(size_t size) -> void;
 
        auto table_size() const -> size_t;
 
    private:
        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>;
 
        dynamic_table table_;
    };
 
    class hpack_decoder
    {
    public:
        explicit hpack_decoder(size_t max_table_size = 4096);
 
        auto decode(std::span<const uint8_t> data) -> Result<std::vector<http_header>>;
 
        auto set_max_table_size(size_t size) -> void;
 
        auto table_size() const -> size_t;
 
    private:
        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>;
 
        dynamic_table table_;
    };
 
    namespace huffman
    {
        auto encode(std::string_view input) -> std::vector<uint8_t>;
 
        auto decode(std::span<const uint8_t> data) -> Result<std::string>;
 
        auto encoded_size(std::string_view input) -> size_t;
    }
 
} // namespace kcenon::network::protocols::http2