// Spec: plans/01-runtime.md 6.4, RFC 9113. H2 framing, settings handshake, // HPACK, stream multiplexing, dual flow control, GOAWAY/RST/PING. No server // push. PRIORITY accepted and ignored. Runs on the owning Connection's // transport, waiter and buffers; the Connection keeps lifecycle ownership. #pragma once #include #include #include #include #include #include #include #include #include #include "runtime/caps.h" #include "runtime/http/message.h" #include "runtime/task.h" #include "flow_control.h" #include "hpack.h" #include "settings.h" #include "stream.h" namespace molo::runtime { class EventLoop; namespace tls { class ITlsHandle; } namespace http { class Connection; struct FullRequest; struct FullResponse; } // namespace http } // namespace molo::runtime namespace molo::runtime::http::v2 { struct H2Config { std::size_t body_cap = caps::kBodyMaxDefault; std::size_t max_concurrent_streams = caps::kH2MaxConcurrentStreamsDefault; std::chrono::milliseconds idle_timeout = caps::kIdleKeepAliveTimeout; std::chrono::milliseconds handler_budget = caps::kHandlerBudget; }; class H2Connection : public std::enable_shared_from_this { public: H2Connection(Connection& conn, H2Config config = H2Config{}); ~H2Connection() = default; Task Run(bool expect_magic, bool from_upgrade, const RequestHead& upgrade_head, const std::string& upgrade_body); void drain(); std::size_t requests_served() const { return requests_; } private: struct Frame { uint32_t length = 0; uint8_t type = 0; uint8_t flags = 0; uint32_t stream_id = 0; }; struct OutItem { uint32_t stream_id = 0; std::string bytes; // payload for DATA, full frame(s) otherwise bool is_data = false; bool end_stream = false; std::size_t offset = 0; }; static Task StreamTask(std::weak_ptr weak, uint32_t stream_id, FullRequest req); static Task WriterTask(std::weak_ptr weak); static Task FileBodyTask(std::weak_ptr weak, uint32_t stream_id, FileBody fb); Task Ensure(std::size_t n); Task ReadLoop(bool first_must_be_settings); bool ProcessFrame(const Frame& fr, const char* payload); // Sends HEADERS. file_follows means a file body streams next: the stream // stays open unless HEAD or a no-body status applies. Returns true when // the caller must stream the file body (via FileBodyTask). bool CompleteResponse(uint32_t stream_id, FullResponse resp, bool file_follows); void EnqueueControl(uint32_t stream_id, const std::string& frame_bytes); void EnqueueData(uint32_t stream_id, std::string payload, bool end_stream); void KickWriter(); void WakeWriter(); void SendSettingsAck(); void SendPingAck(const char* payload); void SendRst(uint32_t stream_id, uint32_t code); void SendGoaway(uint32_t code); void SendWindowUpdate(uint32_t stream_id, uint32_t increment); void Fatal(uint32_t code); static std::string FrameBytes(uint8_t type, uint8_t flags, uint32_t stream_id, const char* payload, std::size_t len); bool OnSettings(const Frame& fr, const char* payload); bool OnHeaders(const Frame& fr, const char* payload); bool OnData(const Frame& fr, const char* payload); bool OnRst(const Frame& fr, const char* payload); bool OnPing(const Frame& fr, const char* payload); bool OnGoaway(const Frame& fr, const char* payload); bool OnWindowUpdate(const Frame& fr, const char* payload); bool OnPriority(const Frame& fr, const char* payload); bool OnContinuation(const Frame& fr, const char* payload); bool FinishHeaders(uint32_t stream_id, const std::string& block, bool end_stream); void EraseStream(uint32_t stream_id); void Dispatch(uint32_t stream_id); bool ApplyUpgrade(const RequestHead& head, const std::string& body); Connection& conn_; H2Config config_; Settings local_; Settings peer_; HpackEncoder encoder_; HpackDecoder decoder_; FlowController flow_; std::unordered_map streams_; int64_t conn_in_window_ = 65535; std::unordered_map stream_in_window_; std::deque out_queue_; // Payload bytes currently queued; bounds file-body streaming. std::size_t out_queued_bytes_ = 0; void UnqueueBytes(std::size_t n) { out_queued_bytes_ -= n > out_queued_bytes_ ? out_queued_bytes_ : n; } bool writer_active_ = false; bool read_done_ = false; bool close_after_flush_ = false; bool draining_ = false; bool goaway_sent_ = false; bool peer_goaway_ = false; bool fatal_ = false; uint32_t max_stream_id_ = 0; std::size_t requests_ = 0; // Rapid Reset guard: client-initiated RST_STREAM count over the // connection's lifetime (see caps::kH2MaxStreamResetsPerConnection). std::size_t client_resets_ = 0; // CONTINUATION reassembly state. bool cont_expected_ = false; uint32_t cont_stream_ = 0; std::string cont_buf_; bool cont_end_stream_ = false; std::coroutine_handle<> window_waiter_ = nullptr; std::coroutine_handle<> writer_done_waiter_ = nullptr; }; } // namespace molo::runtime::http::v2