protocol-http3 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52450e9925c14c39e98b9e9a762a4f0ef69c92a1ff6c7f7898eb8d4e1c60c1e7
-  data.tar.gz: a18affd137347ef514d858c68df6be51f35683e82d13eb28abd0b89b05d55c0a
+  metadata.gz: 2026dd714a98de999332e2aa5eb59944d2f42ee40ec34f1e90ce320c124a41b0
+  data.tar.gz: 25bd20d83b78acd2c7d9eb00436630a6b25e67928fa609e2df5659949a2f6c1e
 SHA512:
-  metadata.gz: 252b5eb914682b2797eab8b6b5c14e76efdb6f53ef7a2e527cc9358dbce83fd7953ffb7fe99e8d08ae6537f00ffb0d83dbf2aeb244bec372606e6cc98e47ae04
-  data.tar.gz: 6715a25f8dda241f3cd0029bfe8aa897524c30418723b5d249f71d2e0ae4e987e6656f213a0f49ebfb91f90d516eedaa1c3c1702b2be33b410998ad8a008b2dd
+  metadata.gz: 10a05532e4bc989f3a4750e1d27eadf1cc745e3b3e6177b3f5cd35de598b096dc869058c62878b8ff45d526d3d4917bf1648d23ae1210b2df8b280c9a32418c7
+  data.tar.gz: 0ce529f6b7f18644c4b4ed655c682ca0aea12c5e482bed759f8745b922861f86da3300b162946fe42263bee4aa1bb0b7c6ed15a806cda69c709db9400e49e574

data/ext/rakefile.rb

@@ -3,10 +3,15 @@
 # Released under the MIT License.
 # Copyright, 2023-2026, by Samuel Williams.
 
+require "rbconfig"
+require "rubygems"
+
+TEAPOT = [RbConfig.ruby, Gem.bin_path("teapot", "teapot")]
+
 task :default do
 	ruby_library_directory = ENV.fetch("RUBYLIBDIR"){ENV.fetch("RUBYARCHDIR")}
 	build_environment = {"RUBYLIBDIR" => ruby_library_directory}
 	
-	sh build_environment, "teapot", "fetch"
-	sh build_environment, "teapot", "scheduler-ruby-library", "Ruby/Protocol/HTTP3"
+	sh build_environment, *TEAPOT, "fetch"
+	sh build_environment, *TEAPOT, "scheduler-ruby-library", "Ruby/Protocol/HTTP3"
 end

data/ext/ruby-protocol-http3-lock.yml

@@ -9,7 +9,7 @@ build-cmake:
   :commit: 6558fdad5bbb475f0fa5584ff773de8f12ff232e
   :branch: master
 protocol-http3:
-  :commit: d9e1c8bc9cb301d430fb48c3aec3b938a6446277
+  :commit: b7d3d4d1b1d6f6c089d2ec9986631bcfe2c373cf
   :branch: main
 ruby:
   :commit: 685cdd5a421dae7749f368d08add9aa9709ad043
@@ -48,7 +48,7 @@ executor-lldb:
   :commit: 193ba0b15c532d2745b0f0bfb05cd9581e869555
   :branch: master
 protocol-quic:
-  :commit: 1328f66a91ba7b3e544304dde8ba7bc93d3462ec
+  :commit: 5d069ac54f446f24dc95003543a2acaeef807e70
   :branch: main
 scheduler:
   :commit: 4d05a1631ac749106d268bda07425bf6ce0476dc
@@ -80,3 +80,12 @@ coroutine-arm64:
 scheduler-ruby:
   :commit: 94e524e64912081aaa5a8cb54bad7ad73f01a51a
   :branch: main
+platform-linux:
+  :commit: c3c5cbf90d26d23c6137def781cd997ddca5e51a
+  :branch: master
+build-linux:
+  :commit: cbc8c52c2ca2fc75761e545c83429ef34e4cd4fe
+  :branch: master
+coroutine-amd64:
+  :commit: 27aee56aa1414094584e7b2d8b74e289ecad4c86
+  :branch: master

data/ext/source/Ruby/Protocol/HTTP3/Client.cpp

@@ -1,17 +1,15 @@
 #include "Client.hpp"
+#include "Stream.hpp"
 
 #include "../QUIC/Bindings.hpp"
 
-#include <Protocol/HTTP3/Stream.hpp>
-
 #include <array>
-#include <unordered_map>
+#include <stdexcept>
 #include <vector>
 
 VALUE Ruby_Protocol_HTTP3_Client = Qnil;
 
 namespace Ruby::Protocol::HTTP3 {
-
 	class Client final : public ::Protocol::QUIC::Client, public ::Protocol::HTTP3::Session {
 	public:
 		VALUE self;
@@ -21,7 +19,6 @@ namespace Ruby::Protocol::HTTP3 {
 		VALUE _tls_context;
 		VALUE _socket;
 		VALUE _remote_address;
-		std::unordered_map<::Protocol::QUIC::StreamID, VALUE> _streams;
 
 	public:
 		Client(VALUE self, VALUE configuration, VALUE tls_context, VALUE socket, VALUE remote_address, VALUE chosen_version) :
@@ -53,7 +50,19 @@ namespace Ruby::Protocol::HTTP3 {
 
 		::Protocol::QUIC::Stream * create_stream(::Protocol::QUIC::StreamID stream_id) override
 		{
-			return new ::Protocol::HTTP3::Stream(*this, *this, stream_id);
+			return new Stream(*this, *this, stream_id);
+		}
+
+		Stream * stream_for(::Protocol::QUIC::StreamID stream_id)
+		{
+			auto stream = reinterpret_cast<::Protocol::QUIC::Stream *>(ngtcp2_conn_get_stream_user_data(::Protocol::QUIC::Client::native_handle(), stream_id));
+			auto ruby_stream = dynamic_cast<Stream *>(stream);
+
+			if (!ruby_stream) {
+				throw std::runtime_error("Could not find HTTP/3 stream.");
+			}
+
+			return ruby_stream;
 		}
 
 		::Protocol::QUIC::Connection::Status send_stream_data() override
@@ -65,7 +74,14 @@ namespace Ruby::Protocol::HTTP3 {
 				::Protocol::QUIC::StreamID stream_id = -1;
 				bool is_final = false;
 
-				auto vector_count = write_stream_data(stream_id, is_final, http_vectors.data(), http_vectors.size());
+				nghttp3_ssize vector_count = 0;
+
+				try {
+					vector_count = write_stream_data(stream_id, is_final, http_vectors.data(), http_vectors.size());
+				} catch (const std::system_error &) {
+					close_pending_streams();
+					return Status(NGTCP2_ERR_CALLBACK_FAILURE);
+				}
 
 				if (stream_id < 0) {
 					break;
@@ -98,12 +114,16 @@ namespace Ruby::Protocol::HTTP3 {
 					return Status(result);
 				}
 
-				add_write_offset(stream_id, static_cast<std::size_t>(written_length));
-
 				if (result > 0) {
 					send_packet(path_storage.path, packet_info, packet.data(), result);
 				}
 
+				if (written_length < 0) {
+					break;
+				}
+
+				add_write_offset(stream_id, static_cast<std::size_t>(written_length));
+
 				if (result == 0 && written_length == 0) {
 					break;
 				}
@@ -112,6 +132,10 @@ namespace Ruby::Protocol::HTTP3 {
 			return Status::OK;
 		}
 
+		void close_pending_streams()
+		{
+		}
+
 		void header_received(::Protocol::QUIC::StreamID stream_id, std::int32_t token, nghttp3_rcbuf *name, nghttp3_rcbuf *value, std::uint8_t flags, void *stream_data) override
 		{
 			(void)token;
@@ -144,6 +168,31 @@ namespace Ruby::Protocol::HTTP3 {
 			}
 		}
 
+		void stream_data_received(::Protocol::QUIC::StreamID stream_id, const std::uint8_t *data, std::size_t size, void *stream_data) override
+		{
+			(void)stream_data;
+
+			auto stream = stream_for(stream_id);
+			stream->receive_input(data, size);
+
+			if (rb_respond_to(self, rb_intern("data_received"))) {
+				rb_funcall(self, rb_intern("data_received"), 2, RB_LL2NUM(stream_id), stream->shift_input());
+			}
+		}
+
+		void stream_data_acknowledged(::Protocol::QUIC::StreamID stream_id, std::uint64_t size, void *stream_data) override
+		{
+			(void)stream_data;
+
+			stream_for(stream_id)->acknowledge_output(size);
+		}
+
+		void stream_closed(::Protocol::QUIC::StreamID stream_id, std::uint64_t error_code, void *stream_data) override
+		{
+			(void)error_code;
+			(void)stream_data;
+		}
+
 		void settings_received(const nghttp3_proto_settings *settings) override
 		{
 			(void)settings;
@@ -157,6 +206,8 @@ namespace Ruby::Protocol::HTTP3 {
 		{
 			(void)stream_data;
 
+			stream_for(stream_id)->finish_input();
+
 			if (rb_respond_to(self, rb_intern("stream_finished"))) {
 				rb_funcall(self, rb_intern("stream_finished"), 1, RB_LL2NUM(stream_id));
 			}
@@ -165,7 +216,6 @@ namespace Ruby::Protocol::HTTP3 {
 		void disconnect() override
 		{
 			::Protocol::QUIC::Client::disconnect();
-			_streams.clear();
 		}
 
 		void mark()
@@ -176,9 +226,12 @@ namespace Ruby::Protocol::HTTP3 {
 			rb_gc_mark_movable(_socket);
 			rb_gc_mark_movable(_remote_address);
 
-			for (auto & [stream_id, stream] : _streams) {
+			for (auto & [stream_id, stream] : ::Protocol::QUIC::Connection::_streams) {
 				(void)stream_id;
-				rb_gc_mark_movable(stream);
+
+				if (auto ruby_stream = dynamic_cast<Stream *>(stream)) {
+					ruby_stream->mark();
+				}
 			}
 		}
 
@@ -190,11 +243,57 @@ namespace Ruby::Protocol::HTTP3 {
 			_socket = rb_gc_location(_socket);
 			_remote_address = rb_gc_location(_remote_address);
 
-			for (auto & [stream_id, stream] : _streams) {
+			for (auto & [stream_id, stream] : ::Protocol::QUIC::Connection::_streams) {
 				(void)stream_id;
-				stream = rb_gc_location(stream);
+
+				if (auto ruby_stream = dynamic_cast<Stream *>(stream)) {
+					ruby_stream->compact();
+				}
+			}
+		}
+
+		void submit_request_with_body(::Protocol::QUIC::StreamID stream_id, const nghttp3_nv *headers, std::size_t count, VALUE body)
+		{
+			auto stream = stream_for(stream_id);
+			
+			if (NIL_P(body)) {
+				submit_request(stream_id, headers, count, nullptr, stream);
+			} else {
+				submit_request(stream_id, headers, count, stream->reader(), stream);
 			}
 		}
+
+		void append_body(::Protocol::QUIC::StreamID stream_id, VALUE chunk)
+		{
+			auto stream = stream_for(stream_id);
+			auto was_empty = !stream->output_pending();
+
+			stream->append_output(chunk);
+
+			if (was_empty) {
+				resume_stream(stream_id);
+			}
+		}
+
+		void finish_body(::Protocol::QUIC::StreamID stream_id)
+		{
+			auto stream = stream_for(stream_id);
+			auto was_empty = !stream->output_pending();
+
+			stream->finish_output();
+
+			if (was_empty) {
+				resume_stream(stream_id);
+			}
+		}
+
+		void reset_body(::Protocol::QUIC::StreamID stream_id, std::uint64_t error_code)
+		{
+			stream_for(stream_id)->reset_output();
+			shutdown_stream_write(stream_id);
+			close_stream(stream_id, error_code);
+			ngtcp2_conn_shutdown_stream_write(::Protocol::QUIC::Client::native_handle(), 0, stream_id, error_code);
+		}
 	};
 
 }
@@ -307,6 +406,7 @@ static VALUE Ruby_Protocol_HTTP3_Client_receive(VALUE self, VALUE ruby_socket)
 	switch (status) {
 	case Protocol::QUIC::Connection::Status::OK:
 		client->send_packets();
+
 		return Qtrue;
 	case Protocol::QUIC::Connection::Status::CLOSING:
 	case Protocol::QUIC::Connection::Status::DRAINING:
@@ -316,8 +416,13 @@ static VALUE Ruby_Protocol_HTTP3_Client_receive(VALUE self, VALUE ruby_socket)
 	}
 }
 
-static VALUE Ruby_Protocol_HTTP3_Client_submit_request(VALUE self, VALUE headers)
+static VALUE Ruby_Protocol_HTTP3_Client_submit_request(int argc, VALUE *argv, VALUE self)
 {
+	VALUE headers;
+	VALUE body = Qnil;
+
+	rb_scan_args(argc, argv, "11", &headers, &body);
+
 	auto client = Ruby_Protocol_HTTP3_Client_native_get(self);
 	auto stream = client->open_bidirectional_stream();
 	auto stream_id = stream->stream_id();
@@ -342,12 +447,51 @@ static VALUE Ruby_Protocol_HTTP3_Client_submit_request(VALUE self, VALUE headers
 		});
 	}
 
-	client->submit_request(stream_id, native_headers.data(), native_headers.size());
+	client->submit_request_with_body(stream_id, native_headers.data(), native_headers.size(), body);
 	client->send_packets();
 
 	return RB_LL2NUM(stream_id);
 }
 
+static VALUE Ruby_Protocol_HTTP3_Client_write_body_chunk(VALUE self, VALUE stream_id, VALUE chunk)
+{
+	auto client = Ruby_Protocol_HTTP3_Client_native_get(self);
+
+	client->append_body(RB_NUM2LL(stream_id), chunk);
+
+	return Qnil;
+}
+
+static VALUE Ruby_Protocol_HTTP3_Client_read_body_chunk(VALUE self, VALUE stream_id)
+{
+	auto client = Ruby_Protocol_HTTP3_Client_native_get(self);
+
+	return client->stream_for(RB_NUM2LL(stream_id))->shift_input();
+}
+
+static VALUE Ruby_Protocol_HTTP3_Client_finish_body(VALUE self, VALUE stream_id)
+{
+	auto client = Ruby_Protocol_HTTP3_Client_native_get(self);
+
+	client->finish_body(RB_NUM2LL(stream_id));
+
+	return Qnil;
+}
+
+static VALUE Ruby_Protocol_HTTP3_Client_reset_body(int argc, VALUE *argv, VALUE self)
+{
+	VALUE stream_id;
+	VALUE error_code;
+	rb_scan_args(argc, argv, "11", &stream_id, &error_code);
+
+	auto client = Ruby_Protocol_HTTP3_Client_native_get(self);
+	auto native_error_code = NIL_P(error_code) ? NGHTTP3_H3_INTERNAL_ERROR : RB_NUM2ULL(error_code);
+
+	client->reset_body(RB_NUM2LL(stream_id), native_error_code);
+
+	return Qnil;
+}
+
 void Init_Ruby_Protocol_HTTP3_Client(VALUE Protocol_HTTP3)
 {
 	Ruby_Protocol_HTTP3_Client = rb_define_class_under(Protocol_HTTP3, "Client", rb_cObject);
@@ -359,5 +503,9 @@ void Init_Ruby_Protocol_HTTP3_Client(VALUE Protocol_HTTP3)
 	rb_define_method(Ruby_Protocol_HTTP3_Client, "close", Ruby_Protocol_HTTP3_Client_close, 0);
 	rb_define_method(Ruby_Protocol_HTTP3_Client, "send_packets", Ruby_Protocol_HTTP3_Client_send_packets, 0);
 	rb_define_method(Ruby_Protocol_HTTP3_Client, "receive", Ruby_Protocol_HTTP3_Client_receive, 1);
-	rb_define_method(Ruby_Protocol_HTTP3_Client, "submit_request", Ruby_Protocol_HTTP3_Client_submit_request, 1);
+	rb_define_method(Ruby_Protocol_HTTP3_Client, "submit_request", RUBY_METHOD_FUNC(Ruby_Protocol_HTTP3_Client_submit_request), -1);
+	rb_define_method(Ruby_Protocol_HTTP3_Client, "write_body_chunk", Ruby_Protocol_HTTP3_Client_write_body_chunk, 2);
+	rb_define_method(Ruby_Protocol_HTTP3_Client, "read_body_chunk", Ruby_Protocol_HTTP3_Client_read_body_chunk, 1);
+	rb_define_method(Ruby_Protocol_HTTP3_Client, "finish_body", Ruby_Protocol_HTTP3_Client_finish_body, 1);
+	rb_define_method(Ruby_Protocol_HTTP3_Client, "reset_body", RUBY_METHOD_FUNC(Ruby_Protocol_HTTP3_Client_reset_body), -1);
 }

data/ext/source/Ruby/Protocol/HTTP3/Server.cpp

@@ -1,16 +1,17 @@
 #include "Server.hpp"
 
 #include "Dispatcher.hpp"
+#include "Stream.hpp"
 
 #include "../QUIC/Bindings.hpp"
 
-#include <unordered_map>
+#include <array>
+#include <stdexcept>
 #include <vector>
 
 VALUE Ruby_Protocol_HTTP3_Server = Qnil;
 
 namespace Ruby::Protocol::HTTP3 {
-
 	class Server : public ::Protocol::HTTP3::Server {
 	public:
 		VALUE self;
@@ -21,7 +22,6 @@ namespace Ruby::Protocol::HTTP3 {
 		VALUE _tls_context;
 		VALUE _socket;
 		VALUE _remote_address;
-		std::unordered_map<::Protocol::QUIC::StreamID, VALUE> _streams;
 
 	public:
 		Server(VALUE self, VALUE dispatcher, VALUE configuration, VALUE tls_context, VALUE socket, VALUE remote_address, VALUE packet_header, VALUE original_connection_id) :
@@ -40,6 +40,93 @@ namespace Ruby::Protocol::HTTP3 {
 		{
 		}
 
+		::Protocol::QUIC::Stream * create_stream(::Protocol::QUIC::StreamID stream_id) override
+		{
+			return new Stream(*this, *this, stream_id);
+		}
+
+		Stream * stream_for(::Protocol::QUIC::StreamID stream_id)
+		{
+			auto stream = reinterpret_cast<::Protocol::QUIC::Stream *>(ngtcp2_conn_get_stream_user_data(::Protocol::QUIC::Server::native_handle(), stream_id));
+			auto ruby_stream = dynamic_cast<Stream *>(stream);
+
+			if (!ruby_stream) {
+				throw std::runtime_error("Could not find HTTP/3 stream.");
+			}
+
+			return ruby_stream;
+		}
+
+		::Protocol::QUIC::Connection::Status send_stream_data() override
+		{
+			std::array<::Protocol::QUIC::Byte, 1024*64> packet;
+			std::array<nghttp3_vec, 16> http_vectors;
+
+			while (true) {
+				::Protocol::QUIC::StreamID stream_id = -1;
+				bool is_final = false;
+				nghttp3_ssize vector_count = 0;
+
+				try {
+					vector_count = write_stream_data(stream_id, is_final, http_vectors.data(), http_vectors.size());
+				} catch (const std::system_error &) {
+					close_pending_streams();
+					return Status(NGTCP2_ERR_CALLBACK_FAILURE);
+				}
+
+				if (stream_id < 0) {
+					break;
+				}
+
+				std::vector<ngtcp2_vec> stream_vectors;
+				stream_vectors.reserve(static_cast<std::size_t>(vector_count));
+
+				for (nghttp3_ssize index = 0; index < vector_count; ++index) {
+					stream_vectors.push_back(ngtcp2_vec{
+						.base = http_vectors[index].base,
+						.len = http_vectors[index].len,
+					});
+				}
+
+				ngtcp2_path_storage path_storage;
+				ngtcp2_path_storage_zero(&path_storage);
+				ngtcp2_pkt_info packet_info;
+				ngtcp2_ssize written_length = 0;
+				::Protocol::QUIC::StreamDataFlags flags = is_final ? NGTCP2_WRITE_STREAM_FLAG_FIN : 0;
+
+				auto result = ngtcp2_conn_writev_stream(::Protocol::QUIC::Server::native_handle(), &path_storage.path, &packet_info, packet.data(), packet.size(), &written_length, flags, stream_id, stream_vectors.data(), stream_vectors.size(), ::Protocol::QUIC::timestamp());
+
+				if (result == NGTCP2_ERR_STREAM_DATA_BLOCKED || result == NGTCP2_ERR_STREAM_SHUT_WR) {
+					block_stream(stream_id);
+					return Status(result);
+				}
+
+				if (result < 0) {
+					return Status(result);
+				}
+
+				if (result > 0) {
+					send_packet(path_storage.path, packet_info, packet.data(), result);
+				}
+
+				if (written_length < 0) {
+					break;
+				}
+
+				add_write_offset(stream_id, static_cast<std::size_t>(written_length));
+
+				if (result == 0 && written_length == 0) {
+					break;
+				}
+			}
+
+			return Status::OK;
+		}
+
+		void close_pending_streams()
+		{
+		}
+
 		void header_received(::Protocol::QUIC::StreamID stream_id, std::int32_t token, nghttp3_rcbuf *name, nghttp3_rcbuf *value, std::uint8_t flags, void *stream_data) override
 		{
 			(void)token;
@@ -72,6 +159,26 @@ namespace Ruby::Protocol::HTTP3 {
 			}
 		}
 
+		void stream_data_received(::Protocol::QUIC::StreamID stream_id, const std::uint8_t *data, std::size_t size, void *stream_data) override
+		{
+			::Protocol::HTTP3::Server::stream_data_received(stream_id, data, size, stream_data);
+
+			if (rb_respond_to(self, rb_intern("data_received"))) {
+				rb_funcall(self, rb_intern("data_received"), 2, RB_LL2NUM(stream_id), stream_for(stream_id)->shift_input());
+			}
+		}
+
+		void stream_data_acknowledged(::Protocol::QUIC::StreamID stream_id, std::uint64_t size, void *stream_data) override
+		{
+			::Protocol::HTTP3::Server::stream_data_acknowledged(stream_id, size, stream_data);
+		}
+
+		void stream_closed(::Protocol::QUIC::StreamID stream_id, std::uint64_t error_code, void *stream_data) override
+		{
+			(void)error_code;
+			(void)stream_data;
+		}
+
 		void settings_received(const nghttp3_proto_settings *settings) override
 		{
 			(void)settings;
@@ -83,7 +190,7 @@ namespace Ruby::Protocol::HTTP3 {
 
 		void stream_finished(::Protocol::QUIC::StreamID stream_id, void *stream_data) override
 		{
-			(void)stream_data;
+			::Protocol::HTTP3::Server::stream_finished(stream_id, stream_data);
 
 			if (rb_respond_to(self, rb_intern("stream_finished"))) {
 				rb_funcall(self, rb_intern("stream_finished"), 1, RB_LL2NUM(stream_id));
@@ -93,7 +200,6 @@ namespace Ruby::Protocol::HTTP3 {
 		void disconnect() override
 		{
 			::Protocol::HTTP3::Server::disconnect();
-			_streams.clear();
 		}
 
 		void mark()
@@ -105,9 +211,12 @@ namespace Ruby::Protocol::HTTP3 {
 			rb_gc_mark_movable(_socket);
 			rb_gc_mark_movable(_remote_address);
 
-			for (auto & [stream_id, stream] : _streams) {
+			for (auto & [stream_id, stream] : ::Protocol::QUIC::Connection::_streams) {
 				(void)stream_id;
-				rb_gc_mark_movable(stream);
+
+				if (auto ruby_stream = dynamic_cast<Stream *>(stream)) {
+					ruby_stream->mark();
+				}
 			}
 		}
 
@@ -120,11 +229,56 @@ namespace Ruby::Protocol::HTTP3 {
 			_socket = rb_gc_location(_socket);
 			_remote_address = rb_gc_location(_remote_address);
 
-			for (auto & [stream_id, stream] : _streams) {
+			for (auto & [stream_id, stream] : ::Protocol::QUIC::Connection::_streams) {
 				(void)stream_id;
-				stream = rb_gc_location(stream);
+
+				if (auto ruby_stream = dynamic_cast<Stream *>(stream)) {
+					ruby_stream->compact();
+				}
+			}
+		}
+
+		void submit_response_with_body(::Protocol::QUIC::StreamID stream_id, const nghttp3_nv *headers, std::size_t count, VALUE body)
+		{
+			if (NIL_P(body)) {
+				submit_response(stream_id, headers, count);
+			} else {
+				auto stream = stream_for(stream_id);
+				submit_response(stream_id, headers, count, stream->reader(), stream);
 			}
 		}
+
+		void append_body(::Protocol::QUIC::StreamID stream_id, VALUE chunk)
+		{
+			auto stream = stream_for(stream_id);
+			auto was_empty = !stream->output_pending();
+
+			stream->append_output(chunk);
+
+			if (was_empty) {
+				resume_stream(stream_id);
+			}
+		}
+
+		void finish_body(::Protocol::QUIC::StreamID stream_id)
+		{
+			auto stream = stream_for(stream_id);
+			auto was_empty = !stream->output_pending();
+
+			stream->finish_output();
+
+			if (was_empty) {
+				resume_stream(stream_id);
+			}
+		}
+
+		void reset_body(::Protocol::QUIC::StreamID stream_id, std::uint64_t error_code)
+		{
+			stream_for(stream_id)->reset_output();
+			shutdown_stream_write(stream_id);
+			close_stream(stream_id, error_code);
+			ngtcp2_conn_shutdown_stream_write(::Protocol::QUIC::Server::native_handle(), 0, stream_id, error_code);
+		}
 	};
 
 }
@@ -197,8 +351,14 @@ static VALUE Ruby_Protocol_HTTP3_Server_send_packets(VALUE self)
 	return Qnil;
 }
 
-static VALUE Ruby_Protocol_HTTP3_Server_submit_response(VALUE self, VALUE stream_id, VALUE headers)
+static VALUE Ruby_Protocol_HTTP3_Server_submit_response(int argc, VALUE *argv, VALUE self)
 {
+	VALUE stream_id;
+	VALUE headers;
+	VALUE body = Qnil;
+
+	rb_scan_args(argc, argv, "21", &stream_id, &headers, &body);
+
 	auto server = Ruby_Protocol_HTTP3_Server_get(self);
 	auto count = RARRAY_LEN(headers);
 	std::vector<nghttp3_nv> native_headers;
@@ -221,12 +381,74 @@ static VALUE Ruby_Protocol_HTTP3_Server_submit_response(VALUE self, VALUE stream
 		});
 	}
 
-	server->submit_response(RB_NUM2LL(stream_id), native_headers.data(), native_headers.size());
+	auto ruby_server = dynamic_cast<Ruby::Protocol::HTTP3::Server *>(server);
+
+	if (!ruby_server) {
+		rb_raise(rb_eRuntimeError, "Could not get HTTP/3 server.");
+	}
+
+	ruby_server->submit_response_with_body(RB_NUM2LL(stream_id), native_headers.data(), native_headers.size(), body);
 	server->send_packets();
 
 	return Qnil;
 }
 
+static VALUE Ruby_Protocol_HTTP3_Server_write_body_chunk(VALUE self, VALUE stream_id, VALUE chunk)
+{
+	auto server = dynamic_cast<Ruby::Protocol::HTTP3::Server *>(Ruby_Protocol_HTTP3_Server_get(self));
+
+	if (!server) {
+		rb_raise(rb_eRuntimeError, "Could not get HTTP/3 server.");
+	}
+
+	server->append_body(RB_NUM2LL(stream_id), chunk);
+
+	return Qnil;
+}
+
+static VALUE Ruby_Protocol_HTTP3_Server_read_body_chunk(VALUE self, VALUE stream_id)
+{
+	auto server = dynamic_cast<Ruby::Protocol::HTTP3::Server *>(Ruby_Protocol_HTTP3_Server_get(self));
+
+	if (!server) {
+		rb_raise(rb_eRuntimeError, "Could not get HTTP/3 server.");
+	}
+
+	return server->stream_for(RB_NUM2LL(stream_id))->shift_input();
+}
+
+static VALUE Ruby_Protocol_HTTP3_Server_finish_body(VALUE self, VALUE stream_id)
+{
+	auto server = dynamic_cast<Ruby::Protocol::HTTP3::Server *>(Ruby_Protocol_HTTP3_Server_get(self));
+
+	if (!server) {
+		rb_raise(rb_eRuntimeError, "Could not get HTTP/3 server.");
+	}
+
+	server->finish_body(RB_NUM2LL(stream_id));
+
+	return Qnil;
+}
+
+static VALUE Ruby_Protocol_HTTP3_Server_reset_body(int argc, VALUE *argv, VALUE self)
+{
+	VALUE stream_id;
+	VALUE error_code;
+	rb_scan_args(argc, argv, "11", &stream_id, &error_code);
+
+	auto server = dynamic_cast<Ruby::Protocol::HTTP3::Server *>(Ruby_Protocol_HTTP3_Server_get(self));
+
+	if (!server) {
+		rb_raise(rb_eRuntimeError, "Could not get HTTP/3 server.");
+	}
+
+	auto native_error_code = NIL_P(error_code) ? NGHTTP3_H3_INTERNAL_ERROR : RB_NUM2ULL(error_code);
+
+	server->reset_body(RB_NUM2LL(stream_id), native_error_code);
+
+	return Qnil;
+}
+
 void Init_Ruby_Protocol_HTTP3_Server(VALUE Protocol_HTTP3)
 {
 	Ruby_Protocol_HTTP3_Server = rb_define_class_under(Protocol_HTTP3, "Server", rb_cObject);
@@ -235,5 +457,9 @@ void Init_Ruby_Protocol_HTTP3_Server(VALUE Protocol_HTTP3)
 	rb_define_method(Ruby_Protocol_HTTP3_Server, "initialize", Ruby_Protocol_HTTP3_Server_initialize, 7);
 
 	rb_define_method(Ruby_Protocol_HTTP3_Server, "send_packets", Ruby_Protocol_HTTP3_Server_send_packets, 0);
-	rb_define_method(Ruby_Protocol_HTTP3_Server, "submit_response", Ruby_Protocol_HTTP3_Server_submit_response, 2);
+	rb_define_method(Ruby_Protocol_HTTP3_Server, "submit_response", RUBY_METHOD_FUNC(Ruby_Protocol_HTTP3_Server_submit_response), -1);
+	rb_define_method(Ruby_Protocol_HTTP3_Server, "write_body_chunk", Ruby_Protocol_HTTP3_Server_write_body_chunk, 2);
+	rb_define_method(Ruby_Protocol_HTTP3_Server, "read_body_chunk", Ruby_Protocol_HTTP3_Server_read_body_chunk, 1);
+	rb_define_method(Ruby_Protocol_HTTP3_Server, "finish_body", Ruby_Protocol_HTTP3_Server_finish_body, 1);
+	rb_define_method(Ruby_Protocol_HTTP3_Server, "reset_body", RUBY_METHOD_FUNC(Ruby_Protocol_HTTP3_Server_reset_body), -1);
 }

data/ext/source/Ruby/Protocol/HTTP3/Stream.cpp

@@ -0,0 +1,155 @@
+#include "Stream.hpp"
+
+#include <stdexcept>
+
+namespace Ruby::Protocol::HTTP3 {
+	Stream::Stream(::Protocol::HTTP3::Session & session, ::Protocol::QUIC::Connection & connection, ::Protocol::QUIC::StreamID stream_id) :
+		::Protocol::HTTP3::Stream(session, connection, stream_id),
+		_reader{read_data}
+	{
+	}
+
+	Stream::~Stream()
+	{
+	}
+
+	void Stream::receive_input(const void *data, std::size_t size)
+	{
+		if (_input_finished) {
+			throw std::runtime_error("Cannot receive input after stream input has finished.");
+		}
+
+		_input_chunks.push_back(rb_str_new(static_cast<const char *>(data), size));
+	}
+
+	void Stream::finish_input()
+	{
+		_input_finished = true;
+	}
+
+	void Stream::acknowledge_output(std::size_t size)
+	{
+		_acknowledged_output += size;
+
+		while (!_retained_output_chunks.empty() && _acknowledged_output >= static_cast<std::size_t>(RSTRING_LEN(_retained_output_chunks.front()))) {
+			_acknowledged_output -= static_cast<std::size_t>(RSTRING_LEN(_retained_output_chunks.front()));
+			_retained_output_chunks.pop_front();
+		}
+	}
+
+	bool Stream::output_pending() const noexcept
+	{
+		return !_output_chunks.empty();
+	}
+
+	void Stream::append_output(VALUE chunk)
+	{
+		if (_output_finished) {
+			throw std::runtime_error("Cannot append output after stream output has finished.");
+		}
+
+		chunk = rb_str_to_str(chunk);
+		_output_chunks.push_back(rb_str_dup_frozen(chunk));
+	}
+
+	void Stream::finish_output()
+	{
+		_output_finished = true;
+	}
+
+	void Stream::reset_output()
+	{
+		_output_finished = true;
+		_output_chunks.clear();
+		clear_retained_output();
+	}
+
+	VALUE Stream::shift_input()
+	{
+		if (_input_chunks.empty()) {
+			return Qnil;
+		}
+
+		auto chunk = _input_chunks.front();
+		_input_chunks.pop_front();
+
+		return chunk;
+	}
+
+	void Stream::mark()
+	{
+		for (auto chunk : _input_chunks) {
+			rb_gc_mark_movable(chunk);
+		}
+
+		for (auto chunk : _output_chunks) {
+			rb_gc_mark_movable(chunk);
+		}
+
+		for (auto chunk : _retained_output_chunks) {
+			rb_gc_mark_movable(chunk);
+		}
+	}
+
+	void Stream::compact()
+	{
+		for (auto & chunk : _input_chunks) {
+			chunk = rb_gc_location(chunk);
+		}
+
+		for (auto & chunk : _output_chunks) {
+			chunk = rb_gc_location(chunk);
+		}
+
+		for (auto & chunk : _retained_output_chunks) {
+			chunk = rb_gc_location(chunk);
+		}
+	}
+
+	nghttp3_ssize Stream::read_data(nghttp3_conn *connection, std::int64_t stream_id, nghttp3_vec *vectors, std::size_t vector_count, std::uint32_t *flags, void *connection_data, void *stream_data)
+	{
+		(void)connection;
+		(void)stream_id;
+		(void)connection_data;
+
+		if (vector_count == 0) {
+			return 0;
+		}
+
+		auto stream = reinterpret_cast<Stream *>(stream_data);
+
+		if (!stream) {
+			*flags |= NGHTTP3_DATA_FLAG_EOF;
+			return 0;
+		}
+
+		if (stream->_output_chunks.empty()) {
+			if (!stream->_output_finished) {
+				return NGHTTP3_ERR_WOULDBLOCK;
+			}
+
+			*flags |= NGHTTP3_DATA_FLAG_EOF;
+			return 0;
+		}
+
+		stream->_retained_output_chunks.push_back(stream->_output_chunks.front());
+		stream->_output_chunks.pop_front();
+
+		auto chunk = stream->_retained_output_chunks.back();
+
+		vectors[0].base = reinterpret_cast<std::uint8_t *>(RSTRING_PTR(chunk));
+		vectors[0].len = RSTRING_LEN(chunk);
+
+		if (stream->_output_finished && stream->_output_chunks.empty()) {
+			*flags |= NGHTTP3_DATA_FLAG_EOF;
+		}
+
+		return 1;
+	}
+
+	void Stream::clear_retained_output()
+	{
+		_retained_output_chunks.clear();
+		_acknowledged_output = 0;
+	}
+}

data/ext/source/Ruby/Protocol/HTTP3/Stream.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <ruby.h>
+
+#include <Protocol/HTTP3/Stream.hpp>
+
+#include <deque>
+
+namespace Ruby::Protocol::HTTP3 {
+	class Stream : public ::Protocol::HTTP3::Stream {
+	public:
+		Stream(::Protocol::HTTP3::Session & session, ::Protocol::QUIC::Connection & connection, ::Protocol::QUIC::StreamID stream_id);
+		virtual ~Stream();
+
+		nghttp3_data_reader * reader() noexcept {return &_reader;}
+
+		void receive_input(const void *data, std::size_t size) override;
+		void finish_input() override;
+
+		void acknowledge_output(std::size_t size) override;
+
+		bool output_pending() const noexcept;
+		void append_output(VALUE chunk);
+		void finish_output();
+		void reset_output();
+
+		VALUE shift_input();
+
+		void mark();
+		void compact();
+
+		static nghttp3_ssize read_data(nghttp3_conn *connection, std::int64_t stream_id, nghttp3_vec *vectors, std::size_t vector_count, std::uint32_t *flags, void *connection_data, void *stream_data);
+
+	private:
+		nghttp3_data_reader _reader;
+
+		std::deque<VALUE> _input_chunks;
+		std::deque<VALUE> _output_chunks;
+		std::deque<VALUE> _retained_output_chunks;
+
+		std::size_t _acknowledged_output = 0;
+		bool _input_finished = false;
+		bool _output_finished = false;
+
+		void clear_retained_output();
+	};
+}

data/lib/protocol/http3/stream.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+module Protocol::HTTP3
+	# A single HTTP/3 request or response body stream.
+	class Stream
+		# Initialize the stream wrapper for the given connection and native stream identifier.
+		def initialize(connection, stream_id)
+			@connection = connection
+			@stream_id = stream_id
+		end
+		
+		attr :connection
+		attr :stream_id
+		
+		# Read the next available body chunk from the stream.
+		def read_chunk
+			@connection.__send__(:read_body_chunk, @stream_id)
+		end
+		
+		# Write a body chunk to the stream.
+		def write_chunk(chunk)
+			@connection.__send__(:write_body_chunk, @stream_id, chunk)
+			@connection.send_packets
+		end
+		
+		# Finish the stream after all body chunks have been written.
+		def finish
+			@connection.__send__(:finish_body, @stream_id)
+			@connection.send_packets
+		end
+		
+		# Reset the stream with the optional HTTP/3 error code.
+		def reset(error_code = nil)
+			@connection.__send__(:reset_body, @stream_id, error_code)
+			@connection.send_packets
+		end
+		
+		# Write all chunks from the given body to the stream.
+		def write_body(body)
+			error = nil
+			
+			begin
+				while chunk = body.read
+					write_chunk(chunk)
+				end
+			rescue => error
+				reset
+				raise
+			ensure
+				body.close(error)
+				finish unless error
+			end
+		end
+	end
+end

data/lib/protocol/http3/version.rb

@@ -7,6 +7,6 @@
 module Protocol
 	# @namespace
 	module HTTP3
-		VERSION = "0.0.1"
+		VERSION = "0.0.2"
 	end
 end

data/lib/protocol/http3.rb

@@ -9,3 +9,39 @@ require_relative "http3/version"
 
 # Native extension:
 require "Ruby_Protocol_HTTP3"
+
+require_relative "http3/stream"
+
+module Protocol::HTTP3
+	# An HTTP/3 client connection.
+	class Client
+		alias native_submit_request submit_request
+		
+		# Submit a request and return the stream used for the response body.
+		def submit_request(headers, body = nil)
+			Stream.new(self, native_submit_request(headers, body))
+		end
+		
+		private :read_body_chunk
+		private :write_body_chunk
+		private :finish_body
+		private :reset_body
+	end
+	
+	# An HTTP/3 server connection.
+	class Server
+		alias native_submit_response submit_response
+		
+		# Submit a response for the given stream and return the stream used for the response body.
+		def submit_response(stream_id, headers, body = nil)
+			Stream.new(self, stream_id).tap do
+				native_submit_response(stream_id, headers, body)
+			end
+		end
+		
+		private :read_body_chunk
+		private :write_body_chunk
+		private :finish_body
+		private :reset_body
+	end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protocol-http3
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Samuel Williams
@@ -38,20 +38,34 @@ cert_chain:
   -----END CERTIFICATE-----
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: protocol-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.62'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.62'
 - !ruby/object:Gem::Dependency
   name: protocol-quic
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: 0.0.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: 0.0.9
 - !ruby/object:Gem::Dependency
   name: teapot
   requirement: !ruby/object:Gem::Requirement
@@ -95,9 +109,12 @@ files:
 - ext/source/Ruby/Protocol/HTTP3/Dispatcher.hpp
 - ext/source/Ruby/Protocol/HTTP3/Server.cpp
 - ext/source/Ruby/Protocol/HTTP3/Server.hpp
+- ext/source/Ruby/Protocol/HTTP3/Stream.cpp
+- ext/source/Ruby/Protocol/HTTP3/Stream.hpp
 - ext/source/Ruby/Protocol/QUIC/Bindings.hpp
 - ext/teapot.rb
 - lib/protocol/http3.rb
+- lib/protocol/http3/stream.rb
 - lib/protocol/http3/version.rb
 - license.md
 - readme.md