frame.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 <array>
#include <cstdint>
#include <span>
#include <vector>
#include <memory>
#include <string>
 
namespace kcenon::network::protocols::http2
{
    enum class frame_type : uint8_t
    {
        data          = 0x0,  
        headers       = 0x1,  
        priority      = 0x2,  
        rst_stream    = 0x3,  
        settings      = 0x4,  
        push_promise  = 0x5,  
        ping          = 0x6,  
        goaway        = 0x7,  
        window_update = 0x8,  
        continuation  = 0x9   
    };
 
    namespace frame_flags
    {
        constexpr uint8_t none         = 0x0;
        constexpr uint8_t end_stream   = 0x1;  // DATA, HEADERS
        constexpr uint8_t ack          = 0x1;  // SETTINGS, PING
        constexpr uint8_t end_headers  = 0x4;  // HEADERS, PUSH_PROMISE, CONTINUATION
        constexpr uint8_t padded       = 0x8;  // DATA, HEADERS, PUSH_PROMISE
        constexpr uint8_t priority     = 0x20; // HEADERS
    }
 
    struct frame_header
    {
        uint32_t length;     
        frame_type type;     
        uint8_t flags;       
        uint32_t stream_id;  
 
        static auto parse(std::span<const uint8_t> data) -> Result<frame_header>;
 
        auto serialize() const -> std::vector<uint8_t>;
    };
 
    class frame
    {
    public:
        frame() = default;
 
        frame(const frame_header& hdr, std::vector<uint8_t> payload);
 
        static auto parse(std::span<const uint8_t> data) -> Result<std::unique_ptr<frame>>;
 
        auto serialize() const -> std::vector<uint8_t>;
 
        auto header() const -> const frame_header&;
 
        auto payload() const -> std::span<const uint8_t>;
 
        virtual ~frame() = default;
 
    protected:
        frame_header header_;           
        std::vector<uint8_t> payload_;  
    };
 
    class data_frame : public frame
    {
    public:
        data_frame(uint32_t stream_id, std::vector<uint8_t> data,
                   bool end_stream = false, bool padded = false);
 
        static auto parse(const frame_header& hdr, std::span<const uint8_t> payload)
            -> Result<std::unique_ptr<data_frame>>;
 
        auto is_end_stream() const -> bool;
 
        auto is_padded() const -> bool;
 
        auto data() const -> std::span<const uint8_t>;
 
    private:
        std::vector<uint8_t> data_;  
    };
 
    class headers_frame : public frame
    {
    public:
        headers_frame(uint32_t stream_id, std::vector<uint8_t> header_block,
                      bool end_stream = false, bool end_headers = true);
 
        static auto parse(const frame_header& hdr, std::span<const uint8_t> payload)
            -> Result<std::unique_ptr<headers_frame>>;
 
        auto is_end_stream() const -> bool;
 
        auto is_end_headers() const -> bool;
 
        auto header_block() const -> std::span<const uint8_t>;
 
    private:
        std::vector<uint8_t> header_block_;  
    };
 
    struct setting_parameter
    {
        uint16_t identifier;  
        uint32_t value;       
    };
 
    enum class setting_identifier : uint16_t
    {
        header_table_size      = 0x1,  
        enable_push            = 0x2,  
        max_concurrent_streams = 0x3,  
        initial_window_size    = 0x4,  
        max_frame_size         = 0x5,  
        max_header_list_size   = 0x6   
    };
 
    class settings_frame : public frame
    {
    public:
        explicit settings_frame(std::vector<setting_parameter> settings = {},
                                bool ack = false);
 
        static auto parse(const frame_header& hdr, std::span<const uint8_t> payload)
            -> Result<std::unique_ptr<settings_frame>>;
 
        auto settings() const -> const std::vector<setting_parameter>&;
 
        auto is_ack() const -> bool;
 
    private:
        std::vector<setting_parameter> settings_;  
    };
 
    class rst_stream_frame : public frame
    {
    public:
        rst_stream_frame(uint32_t stream_id, uint32_t error_code);
 
        static auto parse(const frame_header& hdr, std::span<const uint8_t> payload)
            -> Result<std::unique_ptr<rst_stream_frame>>;
 
        auto error_code() const -> uint32_t;
 
    private:
        uint32_t error_code_;  
    };
 
    class ping_frame : public frame
    {
    public:
        explicit ping_frame(std::array<uint8_t, 8> opaque_data = {},
                            bool ack = false);
 
        static auto parse(const frame_header& hdr, std::span<const uint8_t> payload)
            -> Result<std::unique_ptr<ping_frame>>;
 
        auto opaque_data() const -> const std::array<uint8_t, 8>&;
 
        auto is_ack() const -> bool;
 
    private:
        std::array<uint8_t, 8> opaque_data_;  
    };
 
    class goaway_frame : public frame
    {
    public:
        goaway_frame(uint32_t last_stream_id, uint32_t error_code,
                     std::vector<uint8_t> additional_data = {});
 
        static auto parse(const frame_header& hdr, std::span<const uint8_t> payload)
            -> Result<std::unique_ptr<goaway_frame>>;
 
        auto last_stream_id() const -> uint32_t;
 
        auto error_code() const -> uint32_t;
 
        auto additional_data() const -> std::span<const uint8_t>;
 
    private:
        uint32_t last_stream_id_;           
        uint32_t error_code_;               
        std::vector<uint8_t> additional_data_;  
    };
 
    class window_update_frame : public frame
    {
    public:
        window_update_frame(uint32_t stream_id, uint32_t window_size_increment);
 
        static auto parse(const frame_header& hdr, std::span<const uint8_t> payload)
            -> Result<std::unique_ptr<window_update_frame>>;
 
        auto window_size_increment() const -> uint32_t;
 
    private:
        uint32_t window_size_increment_;  
    };
 
    enum class error_code : uint32_t
    {
        no_error            = 0x0,  
        protocol_error      = 0x1,  
        internal_error      = 0x2,  
        flow_control_error  = 0x3,  
        settings_timeout    = 0x4,  
        stream_closed       = 0x5,  
        frame_size_error    = 0x6,  
        refused_stream      = 0x7,  
        cancel              = 0x8,  
        compression_error   = 0x9,  
        connect_error       = 0xa,  
        enhance_your_calm   = 0xb,  
        inadequate_security = 0xc,  
        http_1_1_required   = 0xd   
    };
 
} // namespace kcenon::network::protocols::http2