http2_protocol.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_HTTP_HTTP2_PROTOCOL_HPP__
#define NEFORCE_NETWORK_HTTP_HTTP2_PROTOCOL_HPP__

 
#include "NeForce/core/container/unordered_map.hpp"
#include "NeForce/core/functional/function.hpp"
#include "NeForce/core/string/string.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_HTTP__


NEFORCE_INLINE17 constexpr uint32_t HTTP2_MAX_FRAME_SIZE = 16384;
NEFORCE_INLINE17 constexpr uint32_t HTTP2_DEFAULT_HEADER_TABLE_SIZE = 4096;
NEFORCE_INLINE17 constexpr uint32_t HTTP2_DEFAULT_MAX_CONCURRENT_STREAMS = 100;
NEFORCE_INLINE17 constexpr uint32_t HTTP2_DEFAULT_INITIAL_WINDOW_SIZE = 65535;
NEFORCE_INLINE17 constexpr uint32_t HTTP2_DEFAULT_MAX_HEADER_LIST_SIZE = 0xFFFFFFFF;
NEFORCE_INLINE17 constexpr size_t HPACK_STATIC_TABLE_SIZE = 61;
NEFORCE_INLINE17 constexpr string_view HTTP2_CLIENT_PREFACE = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";
 
class byte_cursor;

enum class http2_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,  
};
 
#ifdef NO_ERROR
#    undef NO_ERROR
#endif

enum class http2_error : 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,   
};

enum class http2_settings_id : 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,   
};
 

#pragma pack(push, 1)
struct http2_frame_header {
    uint8_t length_hi = 0;  
    uint8_t length_mid = 0; 
    uint8_t length_lo = 0;  
    uint8_t type = 0;       
    uint8_t flags = 0;      
    uint8_t sid_r = 0;      
    uint8_t sid_mid = 0;    
    uint8_t sid_lo1 = 0;    
    uint8_t sid_lo0 = 0;    
 
    NEFORCE_NODISCARD uint32_t get_length() const noexcept {
        return (static_cast<uint32_t>(length_hi) << 16) | (static_cast<uint32_t>(length_mid) << 8) |
               static_cast<uint32_t>(length_lo);
    }
 
    void set_length(uint32_t len) noexcept {
        length_hi = static_cast<uint8_t>((len >> 16) & 0xFF);
        length_mid = static_cast<uint8_t>((len >> 8) & 0xFF);
        length_lo = static_cast<uint8_t>(len & 0xFF);
    }
 
    NEFORCE_NODISCARD uint32_t get_stream_id() const noexcept {
        return (static_cast<uint32_t>(sid_r & 0x7F) << 24) | (static_cast<uint32_t>(sid_mid) << 16) |
               (static_cast<uint32_t>(sid_lo1) << 8) | static_cast<uint32_t>(sid_lo0);
    }
 
    void set_stream_id(uint32_t id) noexcept {
        sid_r = static_cast<uint8_t>((id >> 24) & 0x7F);
        sid_mid = static_cast<uint8_t>((id >> 16) & 0xFF);
        sid_lo1 = static_cast<uint8_t>((id >> 8) & 0xFF);
        sid_lo0 = static_cast<uint8_t>(id & 0xFF);
    }
};
#pragma pack(pop)
 
 
NEFORCE_INLINE17 constexpr uint8_t HTTP2_FLAG_END_STREAM = 0x1;
NEFORCE_INLINE17 constexpr uint8_t HTTP2_FLAG_END_HEADERS = 0x4;
NEFORCE_INLINE17 constexpr uint8_t HTTP2_FLAG_PADDED = 0x8;
NEFORCE_INLINE17 constexpr uint8_t HTTP2_FLAG_PRIORITY = 0x20;
NEFORCE_INLINE17 constexpr uint8_t HTTP2_FLAG_ACK = 0x1;

struct http2_settings_entry {
    http2_settings_id id; 
    uint32_t value;       
};

struct http2_priority {
    uint32_t stream_dependency; 
    uint8_t weight;             
    bool exclusive;             
};

struct http2_data_frame {
    uint32_t stream_id;      
    byte_vector data;        
    uint8_t pad_length = 0;  
    bool end_stream = false; 
};

struct http2_headers_frame {
    uint32_t stream_id;        
    byte_vector header_block;  
    uint8_t pad_length = 0;    
    http2_priority priority{}; 
    bool end_stream = false;   
    bool end_headers = false;  
    bool has_priority = false; 
};

struct http2_rst_stream_frame {
    uint32_t stream_id;     
    http2_error error_code; 
};

struct http2_settings_frame {
    bool ack = false;                     
    vector<http2_settings_entry> entries; 
};

struct http2_ping_frame {
    uint64_t opaque_data; 
    bool ack = false;     
};

struct http2_goaway_frame {
    uint32_t last_stream_id; 
    http2_error error_code;  
    byte_vector debug_data;  
};

struct http2_window_update_frame {
    uint32_t stream_id;             
    uint32_t window_size_increment; 
};

struct http2_push_promise_frame {
    uint32_t stream_id;          
    uint32_t promised_stream_id; 
    byte_vector header_block;    
    uint8_t pad_length = 0;      
    bool end_headers = false;    
};

struct http2_continuation_frame {
    uint32_t stream_id;       
    byte_vector header_block; 
    bool end_headers = false; 
};

struct hpack_header_field {
    string name;  
    string value; 
};
 

class NEFORCE_API hpack_encoder {
private:
    struct table_entry {
        string name;
        string value;
        size_t name_len;
        size_t value_len;
    };

    uint32_t max_table_size_;
    uint32_t current_table_size_ = 0;
    vector<table_entry> dynamic_table_;
 
    void add_to_dynamic_table(const string& name, const string& value);
    void evict_for_size(uint32_t needed);
    NEFORCE_NODISCARD int32_t find_in_tables(const string& name, const string& value) const;
    NEFORCE_NODISCARD int32_t find_name_in_tables(const string& name) const;
 
public:
    explicit hpack_encoder(uint32_t max_table_size = HTTP2_DEFAULT_HEADER_TABLE_SIZE);
 
    byte_vector encode(const vector<hpack_header_field>& headers);
 
    void set_max_table_size(uint32_t size);
    NEFORCE_NODISCARD uint32_t max_table_size() const noexcept { return max_table_size_; }
    NEFORCE_NODISCARD size_t table_size() const noexcept { return dynamic_table_.size(); }
};

class NEFORCE_API hpack_decoder {
public:
    using header_callback = function<void(const string& name, const string& value)>;
 
private:
    struct table_entry {
        string name;
        string value;
        size_t name_len;
        size_t value_len;
    };

    uint32_t max_table_size_;
    uint32_t current_table_size_ = 0;
    vector<table_entry> dynamic_table_;
 
    void add_to_dynamic_table(const string& name, const string& value);
    void evict_for_size(uint32_t needed);
 
public:
    explicit hpack_decoder(uint32_t max_table_size = HTTP2_DEFAULT_HEADER_TABLE_SIZE);
 
    vector<hpack_header_field> decode(const byte_t* data, size_t len);
    void set_max_table_size(uint32_t size);
 
    void decode_incremental(byte_cursor& cur, header_callback cb);
};
 

class NEFORCE_API http2_framer {
public:
    using frame_callback =
            function<void(http2_frame_type type, uint8_t flags, uint32_t stream_id, const byte_t* payload, size_t len)>;
 
private:
    byte_vector partial_buffer_;
    size_t expected_length_ = 0;
    http2_frame_header current_header_{};
    bool reading_header_ = true;
 
public:
    static byte_vector encode_data_frame(const http2_data_frame& frame);
    static byte_vector encode_headers_frame(const http2_headers_frame& frame);
    static byte_vector encode_push_promise_frame(const http2_push_promise_frame& frame);
    static byte_vector encode_rst_stream_frame(const http2_rst_stream_frame& frame);
    static byte_vector encode_settings_frame(const http2_settings_frame& frame);
    static byte_vector encode_ping_frame(const http2_ping_frame& frame);
    static byte_vector encode_goaway_frame(const http2_goaway_frame& frame);
    static byte_vector encode_window_update_frame(const http2_window_update_frame& frame);
    static byte_vector encode_continuation_frame(const http2_continuation_frame& frame);
 
    void decode_frames(const byte_t* data, size_t len, frame_callback cb);
};
 

enum class http2_stream_state {
    IDLE,
    RESERVED_LOCAL,
    RESERVED_REMOTE,
    OPEN,
    HALF_CLOSED_LOCAL,
    HALF_CLOSED_REMOTE,
    CLOSED,
};

class NEFORCE_API http2_stream {
public:
    explicit http2_stream(uint32_t stream_id);
 
    NEFORCE_NODISCARD uint32_t id() const noexcept { return stream_id_; }
    NEFORCE_NODISCARD http2_stream_state state() const noexcept { return state_; }
 
    NEFORCE_NODISCARD bool can_send_headers() const;
    NEFORCE_NODISCARD bool can_send_data() const;
    NEFORCE_NODISCARD bool can_receive() const;
    NEFORCE_NODISCARD bool is_closed() const noexcept { return state_ == http2_stream_state::CLOSED; }
 
    void on_send_headers(bool end_stream);
    void on_send_data(bool end_stream);
    void on_receive_headers(bool end_stream);
    void on_receive_data(bool end_stream);
    void on_send_rst_stream();
    void on_receive_rst_stream();
    void close();
 
    NEFORCE_NODISCARD uint32_t local_window() const noexcept { return local_window_; }
    NEFORCE_NODISCARD uint32_t remote_window() const noexcept { return remote_window_; }
    void consume_local_window(uint32_t amount);
    void consume_remote_window(uint32_t amount);
    void add_local_window(uint32_t amount);
    void add_remote_window(uint32_t amount);
 
private:
    uint32_t stream_id_;
    http2_stream_state state_ = http2_stream_state::IDLE;
    uint32_t local_window_ = HTTP2_DEFAULT_INITIAL_WINDOW_SIZE;
    uint32_t remote_window_ = HTTP2_DEFAULT_INITIAL_WINDOW_SIZE;
};

class NEFORCE_API http2_flow_control {
public:
    explicit http2_flow_control(uint32_t initial_window = HTTP2_DEFAULT_INITIAL_WINDOW_SIZE);
 
    void set_initial_window(uint32_t size);
 
    NEFORCE_NODISCARD bool can_send(uint32_t stream_id, uint32_t amount) const;
    void consume(uint32_t stream_id, uint32_t amount);
    void add_window(uint32_t stream_id, uint32_t amount);
    NEFORCE_NODISCARD uint32_t window(uint32_t stream_id) const;
    NEFORCE_NODISCARD uint32_t connection_window() const noexcept { return connection_window_; }
 
private:
    uint32_t initial_window_;
    uint32_t connection_window_;
    unordered_map<uint32_t, uint32_t> stream_windows_;
};
 

class NEFORCE_API http2_settings {
public:
    http2_settings();
 
    void set(http2_settings_id id, uint32_t value);
    NEFORCE_NODISCARD uint32_t get(http2_settings_id id) const;
 
    NEFORCE_NODISCARD uint32_t header_table_size() const;
    NEFORCE_NODISCARD bool enable_push() const;
    NEFORCE_NODISCARD uint32_t max_concurrent_streams() const;
    NEFORCE_NODISCARD uint32_t initial_window_size() const;
    NEFORCE_NODISCARD uint32_t max_frame_size() const;
    NEFORCE_NODISCARD uint32_t max_header_list_size() const;
 
    void apply_remote_settings(const http2_settings_frame& frame);
 
    static http2_settings defaults() { return {}; }
 
private:
    unordered_map<uint16_t, uint32_t> params_;
};
 // HTTP
 
NEFORCE_END_HTTP__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_HTTP_HTTP2_PROTOCOL_HPP__