http2_connection.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_HTTP_HTTP2_CONNECTION_HPP__
#define NEFORCE_NETWORK_HTTP_HTTP2_CONNECTION_HPP__

 
#include "NeForce/core/async/atomic.hpp"
#include "NeForce/core/async/io_context.hpp"
#include "NeForce/core/memory/weak_ptr.hpp"
#include "NeForce/network/http/http2_protocol.hpp"
#include "NeForce/network/http/http_router.hpp"
#include "NeForce/network/tcp/tcp_socket.hpp"
 
#ifdef NO_ERROR
#    undef NO_ERROR
#endif
 
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_HTTP__


class http2_connection : public enable_shared_from_this<http2_connection> {
public:
    using stream_handler = function<void(uint32_t stream_id, const vector<hpack_header_field>& headers,
                                         const byte_t* data, size_t data_len, bool end_stream)>;
    using close_handler = function<void(uint32_t error_code)>;
 
private:
    unique_ptr<tcp_socket> socket_;
    io_context* ctx_{nullptr};
 
    http2_framer framer_;
    http2_settings local_settings_;
    http2_settings remote_settings_;
    hpack_encoder encoder_;
    hpack_decoder decoder_;
    http2_flow_control flow_control_;
 
    unordered_map<uint32_t, unique_ptr<http2_stream>> streams_;
    uint32_t last_stream_id_ = 0;
    atomic<bool> closed_{false};
    bool preface_received_ = false;
 
    byte_vector read_buffer_;
    byte_vector write_buffer_;
    mutex write_mutex_;
    mutable recursive_mutex stream_mutex_; 
 
    uint32_t connection_consumed_ = 0;                   
    unordered_map<uint32_t, uint32_t> stream_consumed_;  
    unordered_map<uint32_t, uint8_t> stream_priorities_; 
    uint32_t local_stream_window_ = 65535;               
 
    stream_handler stream_handler_;
    close_handler close_handler_;
    http_router* router_ = nullptr;
 
    struct pending_stream {
        vector<hpack_header_field> headers;
        byte_vector header_block_fragment;
        byte_vector data;
        bool end_stream = false;
        bool waiting_continuation = false;
    };
 
    unordered_map<uint32_t, pending_stream> pending_;
 
    void route_stream(uint32_t stream_id, const vector<hpack_header_field>& headers, const byte_t* data,
                      size_t data_len, bool end_stream);
 
    void on_readable(int fd, uint32_t events, error_code ec);
    void on_writable(int fd, uint32_t events, error_code ec);
 
    void handle_frame(http2_frame_type type, uint8_t flags, uint32_t stream_id, const byte_t* payload, size_t len);
 
    void handle_data_frame(uint8_t flags, uint32_t stream_id, const byte_t* payload, size_t len);
    void handle_headers_frame(uint8_t flags, uint32_t stream_id, const byte_t* payload, size_t len);
    void handle_continuation_frame(uint8_t flags, uint32_t stream_id, const byte_t* payload, size_t len);
    void handle_priority_frame(uint32_t stream_id, const byte_t* payload, size_t len);
    void handle_push_promise_frame(uint32_t stream_id, const byte_t* payload, size_t len);
    void handle_settings_frame(uint8_t flags, const byte_t* payload, size_t len);
    void handle_ping_frame(uint8_t flags, const byte_t* payload, size_t len);
    void handle_goaway_frame(const byte_t* payload, size_t len);
    void handle_rst_stream_frame(uint32_t stream_id, const byte_t* payload);
    void handle_window_update_frame(uint32_t stream_id, const byte_t* payload);
    void send_window_update(uint32_t stream_id, uint32_t increment);
 
    void write_frame(const byte_vector& frame);
    void flush_writes();
    void close_connection(http2_error error = http2_error::NO_ERROR);
 
public:
    http2_connection(unique_ptr<tcp_socket> socket, io_context& ctx);
    ~http2_connection();
 
    http2_connection(const http2_connection&) = delete;
    http2_connection& operator=(const http2_connection&) = delete;

    void start();

    void send_response(uint32_t stream_id, const vector<hpack_header_field>& headers, const string& body = {},
                       bool end_stream = true);

    void send_push_promise(uint32_t stream_id, uint32_t promised_stream_id,
                           const vector<hpack_header_field>& request_headers);

    void send_rst_stream(uint32_t stream_id, http2_error error);

    void send_goaway(http2_error error = http2_error::NO_ERROR);

    void handle_upgrade_request(uint32_t stream_id, const vector<hpack_header_field>& headers, const byte_t* data,
                                size_t data_len, bool end_stream);

    void set_stream_handler(stream_handler handler) { stream_handler_ = move(handler); }

    void set_router(http_router* router) { router_ = router; }

    void set_close_handler(close_handler handler) { close_handler_ = move(handler); }

    http2_settings& local_settings() noexcept { return local_settings_; }

    const http2_settings& remote_settings() const noexcept { return remote_settings_; }
 
    bool is_closed() const noexcept { return closed_; }
    uint32_t last_stream_id() const noexcept { return last_stream_id_; }
 
    void stop();
};
 // HTTP
 
NEFORCE_END_HTTP__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_HTTP_HTTP2_CONNECTION_HPP__