protocol-http3 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 52450e9925c14c39e98b9e9a762a4f0ef69c92a1ff6c7f7898eb8d4e1c60c1e7
+  data.tar.gz: a18affd137347ef514d858c68df6be51f35683e82d13eb28abd0b89b05d55c0a
+SHA512:
+  metadata.gz: 252b5eb914682b2797eab8b6b5c14e76efdb6f53ef7a2e527cc9358dbce83fd7953ffb7fe99e8d08ae6537f00ffb0d83dbf2aeb244bec372606e6cc98e47ae04
+  data.tar.gz: 6715a25f8dda241f3cd0029bfe8aa897524c30418723b5d249f71d2e0ae4e987e6656f213a0f49ebfb91f90d516eedaa1c3c1702b2be33b410998ad8a008b2dd

data/ext/rakefile.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023-2026, by Samuel Williams.
+
+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"
+end

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

@@ -0,0 +1,82 @@
+---
+platforms:
+  :commit: 53bfdd34201790980ba8f4c335dbf659d038eb06
+  :branch: master
+build-make:
+  :commit: 50998307f3d1f462c2bda1999b42b2ea8aeb4b15
+  :branch: master
+build-cmake:
+  :commit: 6558fdad5bbb475f0fa5584ff773de8f12ff232e
+  :branch: master
+protocol-http3:
+  :commit: d9e1c8bc9cb301d430fb48c3aec3b938a6446277
+  :branch: main
+ruby:
+  :commit: 685cdd5a421dae7749f368d08add9aa9709ad043
+  :branch: main
+generate-template:
+  :commit: ad0dcfb6da64cc0508b71916b30e1050c82ecea7
+  :branch: master
+generate-cpp-class:
+  :commit: b8996bd1404904a737b76d6893fc9f9bf78da540
+  :branch: master
+build-compile-commands:
+  :commit: 1c4b18f86d45426d7dd284c28bc53837e5694b6c
+  :branch: main
+variants:
+  :commit: f6a26a8ac3a47a23a213cbd15da2183239d394d1
+  :branch: master
+platform-darwin-osx:
+  :commit: dbd14d21c11e85f6fc067529a63f81cf5e6604d2
+  :branch: master
+platform-darwin-ios:
+  :commit: d0611a1afac738012ffb7c51185499292e9a87ba
+  :branch: master
+build-clang:
+  :commit: 1c9be15a63c149f6decf8d0599b34755aa3b0979
+  :branch: master
+build-darwin:
+  :commit: 0d68478a7754741dd5d360f70294161efdee030d
+  :branch: master
+build-files:
+  :commit: 2e5392ef4e171885b621288c7829e5160f1255bf
+  :branch: master
+executor-unix:
+  :commit: 91f433a59550b826f7bc69e36d1df9c6e5576575
+  :branch: master
+executor-lldb:
+  :commit: 193ba0b15c532d2745b0f0bfb05cd9581e869555
+  :branch: master
+protocol-quic:
+  :commit: 1328f66a91ba7b3e544304dde8ba7bc93d3462ec
+  :branch: main
+scheduler:
+  :commit: 4d05a1631ac749106d268bda07425bf6ce0476dc
+  :branch: main
+nghttp3:
+  :commit: 922c2aaca406840a63ce2c4a808d9c888538671d
+  :branch: main
+ngtcp2:
+  :commit: c65334b60a04200b1691da3d85d38444c5ff951d
+  :branch: main
+concurrent:
+  :commit: 5075d0f6c2c0e90dc152265ec5e236d56fd20c94
+  :branch: master
+time:
+  :commit: c1ec0bb4fc9abca3de559a87884bdbc1413b3f1f
+  :branch: main
+picotls:
+  :commit: 2bc03af57a8ea09f3b0bd11c47c876fd3bc1d9fc
+  :branch: main
+coroutine:
+  :commit: 428204db9f5485d1565884c218933fd16833b439
+  :branch: master
+openssl:
+  :commit: 2f48d686aaaf20dc6d7e8a277803657eb5951530
+  :branch: main
+coroutine-arm64:
+  :commit: aada7d279a6c2ae79b6f8f3e45cfa44de3c432fe
+  :branch: master
+scheduler-ruby:
+  :commit: 94e524e64912081aaa5a8cb54bad7ad73f01a51a
+  :branch: main

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

@@ -0,0 +1,363 @@
+#include "Client.hpp"
+
+#include "../QUIC/Bindings.hpp"
+
+#include <Protocol/HTTP3/Stream.hpp>
+
+#include <array>
+#include <unordered_map>
+#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;
+
+	private:
+		VALUE _configuration;
+		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) :
+			::Protocol::QUIC::Client(*Ruby_Protocol_QUIC_Configuration_get(configuration), *Ruby_Protocol_QUIC_TLS_ClientContext_get(tls_context), *Ruby_Protocol_QUIC_Socket_get(socket), *Ruby_Protocol_QUIC_Address_get(remote_address), RB_NUM2UINT(chosen_version)),
+			::Protocol::HTTP3::Session(::Protocol::HTTP3::Session::Role::CLIENT),
+			self(self),
+			_configuration(configuration),
+			_tls_context(tls_context),
+			_socket(socket),
+			_remote_address(remote_address)
+		{
+		}
+
+		void handshake_completed() override
+		{
+			auto control_stream = open_unidirectional_stream();
+			auto encoder_stream = open_unidirectional_stream();
+			auto decoder_stream = open_unidirectional_stream();
+
+			bind_control_stream(control_stream->stream_id());
+			bind_qpack_streams(encoder_stream->stream_id(), decoder_stream->stream_id());
+
+			send_packets();
+
+			if (rb_respond_to(self, rb_intern("handshake_completed"))) {
+				rb_funcall(self, rb_intern("handshake_completed"), 0);
+			}
+		}
+
+		::Protocol::QUIC::Stream * create_stream(::Protocol::QUIC::StreamID stream_id) override
+		{
+			return new ::Protocol::HTTP3::Stream(*this, *this, stream_id);
+		}
+
+		::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;
+
+				auto vector_count = write_stream_data(stream_id, is_final, http_vectors.data(), http_vectors.size());
+
+				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::Client::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);
+				}
+
+				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 (result == 0 && written_length == 0) {
+					break;
+				}
+			}
+
+			return Status::OK;
+		}
+
+		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;
+			(void)flags;
+			(void)stream_data;
+
+			if (!rb_respond_to(self, rb_intern("header_received"))) {
+				return;
+			}
+
+			auto name_buffer = nghttp3_rcbuf_get_buf(name);
+			auto value_buffer = nghttp3_rcbuf_get_buf(value);
+
+			rb_funcall(
+				self,
+				rb_intern("header_received"),
+				3,
+				RB_LL2NUM(stream_id),
+				rb_str_new(reinterpret_cast<const char *>(name_buffer.base), name_buffer.len),
+				rb_str_new(reinterpret_cast<const char *>(value_buffer.base), value_buffer.len)
+			);
+		}
+
+		void headers_finished(::Protocol::QUIC::StreamID stream_id, bool is_final, void *stream_data) override
+		{
+			(void)stream_data;
+
+			if (rb_respond_to(self, rb_intern("headers_finished"))) {
+				rb_funcall(self, rb_intern("headers_finished"), 2, RB_LL2NUM(stream_id), is_final ? Qtrue : Qfalse);
+			}
+		}
+
+		void settings_received(const nghttp3_proto_settings *settings) override
+		{
+			(void)settings;
+
+			if (rb_respond_to(self, rb_intern("settings_received"))) {
+				rb_funcall(self, rb_intern("settings_received"), 0);
+			}
+		}
+
+		void stream_finished(::Protocol::QUIC::StreamID stream_id, void *stream_data) override
+		{
+			(void)stream_data;
+
+			if (rb_respond_to(self, rb_intern("stream_finished"))) {
+				rb_funcall(self, rb_intern("stream_finished"), 1, RB_LL2NUM(stream_id));
+			}
+		}
+
+		void disconnect() override
+		{
+			::Protocol::QUIC::Client::disconnect();
+			_streams.clear();
+		}
+
+		void mark()
+		{
+			rb_gc_mark_movable(self);
+			rb_gc_mark_movable(_configuration);
+			rb_gc_mark_movable(_tls_context);
+			rb_gc_mark_movable(_socket);
+			rb_gc_mark_movable(_remote_address);
+
+			for (auto & [stream_id, stream] : _streams) {
+				(void)stream_id;
+				rb_gc_mark_movable(stream);
+			}
+		}
+
+		void compact()
+		{
+			self = rb_gc_location(self);
+			_configuration = rb_gc_location(_configuration);
+			_tls_context = rb_gc_location(_tls_context);
+			_socket = rb_gc_location(_socket);
+			_remote_address = rb_gc_location(_remote_address);
+
+			for (auto & [stream_id, stream] : _streams) {
+				(void)stream_id;
+				stream = rb_gc_location(stream);
+			}
+		}
+	};
+
+}
+
+static void Ruby_Protocol_HTTP3_Client_mark(void *data)
+{
+	if (data) {
+		reinterpret_cast<Ruby::Protocol::HTTP3::Client *>(data)->mark();
+	}
+}
+
+static void Ruby_Protocol_HTTP3_Client_compact(void *data)
+{
+	if (data) {
+		reinterpret_cast<Ruby::Protocol::HTTP3::Client *>(data)->compact();
+	}
+}
+
+static void Ruby_Protocol_HTTP3_Client_free(void *data)
+{
+	if (data) {
+		delete reinterpret_cast<Protocol::QUIC::Client *>(data);
+	}
+}
+
+static size_t Ruby_Protocol_HTTP3_Client_size(const void *data)
+{
+	return sizeof(Ruby::Protocol::HTTP3::Client);
+}
+
+static const rb_data_type_t Ruby_Protocol_HTTP3_Client_type = {
+	.wrap_struct_name = "Protocol::HTTP3::Client",
+	.function = {
+		.dmark = Ruby_Protocol_HTTP3_Client_mark,
+		.dfree = Ruby_Protocol_HTTP3_Client_free,
+		.dsize = Ruby_Protocol_HTTP3_Client_size,
+		.dcompact = Ruby_Protocol_HTTP3_Client_compact,
+	},
+	.parent = &Ruby_Protocol_QUIC_Connection_type,
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+Protocol::QUIC::Client * Ruby_Protocol_HTTP3_Client_get(VALUE self)
+{
+	Protocol::QUIC::Client *client;
+
+	TypedData_Get_Struct(self, Protocol::QUIC::Client, &Ruby_Protocol_HTTP3_Client_type, client);
+
+	return client;
+}
+
+static Ruby::Protocol::HTTP3::Client * Ruby_Protocol_HTTP3_Client_native_get(VALUE self)
+{
+	return dynamic_cast<Ruby::Protocol::HTTP3::Client *>(Ruby_Protocol_HTTP3_Client_get(self));
+}
+
+static VALUE Ruby_Protocol_HTTP3_Client_allocate(VALUE klass)
+{
+	return TypedData_Wrap_Struct(klass, &Ruby_Protocol_HTTP3_Client_type, NULL);
+}
+
+static VALUE Ruby_Protocol_HTTP3_Client_initialize(VALUE self, VALUE configuration, VALUE tls_context, VALUE socket, VALUE remote_address, VALUE chosen_version)
+{
+	DATA_PTR(self) = new Ruby::Protocol::HTTP3::Client(self, configuration, tls_context, socket, remote_address, chosen_version);
+
+	return self;
+}
+
+static VALUE Ruby_Protocol_HTTP3_Client_connect(VALUE self)
+{
+	auto client = Ruby_Protocol_HTTP3_Client_get(self);
+
+	client->connect();
+
+	return Qnil;
+}
+
+static VALUE Ruby_Protocol_HTTP3_Client_close(VALUE self)
+{
+	auto client = Ruby_Protocol_HTTP3_Client_get(self);
+
+	client->close();
+
+	return Qnil;
+}
+
+static VALUE Ruby_Protocol_HTTP3_Client_send_packets(VALUE self)
+{
+	auto client = Ruby_Protocol_HTTP3_Client_get(self);
+
+	client->send_packets();
+
+	return Qnil;
+}
+
+static VALUE Ruby_Protocol_HTTP3_Client_receive(VALUE self, VALUE ruby_socket)
+{
+	auto client = Ruby_Protocol_HTTP3_Client_get(self);
+	auto socket = Ruby_Protocol_QUIC_Socket_get(ruby_socket);
+
+	auto path = ngtcp2_conn_get_path(client->native_handle());
+
+	if (!path) {
+		rb_raise(rb_eRuntimeError, "Could not get QUIC client path.");
+	}
+
+	auto status = client->receive_packets(*path, *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:
+		return Qfalse;
+	default:
+		rb_raise(rb_eRuntimeError, "Could not receive QUIC packet.");
+	}
+}
+
+static VALUE Ruby_Protocol_HTTP3_Client_submit_request(VALUE self, VALUE headers)
+{
+	auto client = Ruby_Protocol_HTTP3_Client_native_get(self);
+	auto stream = client->open_bidirectional_stream();
+	auto stream_id = stream->stream_id();
+	auto count = RARRAY_LEN(headers);
+	std::vector<nghttp3_nv> native_headers;
+	native_headers.reserve(count);
+
+	for (long index = 0; index < count; ++index) {
+		VALUE pair = rb_ary_entry(headers, index);
+		VALUE name = rb_ary_entry(pair, 0);
+		VALUE value = rb_ary_entry(pair, 1);
+
+		name = rb_str_to_str(name);
+		value = rb_str_to_str(value);
+
+		native_headers.push_back(nghttp3_nv{
+			.name = reinterpret_cast<std::uint8_t *>(RSTRING_PTR(name)),
+			.value = reinterpret_cast<std::uint8_t *>(RSTRING_PTR(value)),
+			.namelen = static_cast<std::size_t>(RSTRING_LEN(name)),
+			.valuelen = static_cast<std::size_t>(RSTRING_LEN(value)),
+			.flags = NGHTTP3_NV_FLAG_NONE,
+		});
+	}
+
+	client->submit_request(stream_id, native_headers.data(), native_headers.size());
+	client->send_packets();
+
+	return RB_LL2NUM(stream_id);
+}
+
+void Init_Ruby_Protocol_HTTP3_Client(VALUE Protocol_HTTP3)
+{
+	Ruby_Protocol_HTTP3_Client = rb_define_class_under(Protocol_HTTP3, "Client", rb_cObject);
+
+	rb_define_alloc_func(Ruby_Protocol_HTTP3_Client, Ruby_Protocol_HTTP3_Client_allocate);
+	rb_define_method(Ruby_Protocol_HTTP3_Client, "initialize", Ruby_Protocol_HTTP3_Client_initialize, 5);
+
+	rb_define_method(Ruby_Protocol_HTTP3_Client, "connect", Ruby_Protocol_HTTP3_Client_connect, 0);
+	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);
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <ruby.h>
+
+#include <Protocol/HTTP3/Session.hpp>
+#include <Protocol/QUIC/Client.hpp>
+
+extern "C" {
+	extern VALUE Ruby_Protocol_HTTP3_Client;
+
+	void Init_Ruby_Protocol_HTTP3_Client(VALUE Protocol_HTTP3);
+
+	Protocol::QUIC::Client * Ruby_Protocol_HTTP3_Client_get(VALUE self);
+}