protocol-http3 0.0.1

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

@@ -0,0 +1,257 @@
+#include "Dispatcher.hpp"
+
+#include "Server.hpp"
+
+#include "../QUIC/Bindings.hpp"
+
+#include <array>
+#include <unordered_map>
+
+VALUE Ruby_Protocol_HTTP3_Dispatcher = Qnil;
+
+namespace Ruby::Protocol::HTTP3 {
+
+	class Dispatcher final : public ::Protocol::QUIC::Dispatcher {
+	public:
+		VALUE self;
+
+	private:
+		VALUE _configuration;
+		VALUE _tls_context;
+		std::unordered_map<::Protocol::HTTP3::Server *, VALUE> _servers;
+		std::unordered_map<::Protocol::QUIC::Socket *, VALUE> _sockets;
+
+	public:
+		Dispatcher(VALUE self, VALUE configuration, VALUE tls_context) :
+			::Protocol::QUIC::Dispatcher(*Ruby_Protocol_QUIC_Configuration_get(configuration), *Ruby_Protocol_QUIC_TLS_ServerContext_get(tls_context)),
+			self(self),
+			_configuration(configuration),
+			_tls_context(tls_context)
+		{
+		}
+
+		VALUE ruby_configuration() noexcept {return _configuration;}
+		VALUE ruby_tls_context() noexcept {return _tls_context;}
+
+		VALUE listen(VALUE ruby_socket)
+		{
+			auto socket = Ruby_Protocol_QUIC_Socket_get(ruby_socket);
+
+			_sockets[socket] = ruby_socket;
+
+			auto server = ::Protocol::QUIC::Dispatcher::listen(*socket);
+
+			if (server) {
+				auto iterator = _servers.find(static_cast<::Protocol::HTTP3::Server *>(server));
+
+				if (iterator == _servers.end()) {
+					rb_raise(rb_eRuntimeError, "Could not find Ruby server wrapper for native server.");
+				}
+
+				return iterator->second;
+			}
+
+			return Qnil;
+		}
+
+		VALUE receive(VALUE ruby_socket)
+		{
+			auto socket = Ruby_Protocol_QUIC_Socket_get(ruby_socket);
+			_sockets[socket] = ruby_socket;
+
+			std::array<::Protocol::QUIC::Byte, 1024*64> buffer;
+			::Protocol::QUIC::Address remote_address;
+			::Protocol::QUIC::ECN ecn = ::Protocol::QUIC::ECN::UNSPECIFIED;
+			auto length = socket->receive_packet(buffer.data(), buffer.size(), remote_address, ecn);
+
+			ngtcp2_version_cid version_cid;
+			auto result = ngtcp2_pkt_decode_version_cid(&version_cid, buffer.data(), length, ::Protocol::QUIC::DEFAULT_SCID_LENGTH);
+
+			if (result == 0) {
+				auto server = process_packet(*socket, remote_address, buffer.data(), length, ecn, version_cid);
+
+				if (server) {
+					auto iterator = _servers.find(static_cast<::Protocol::HTTP3::Server *>(server));
+
+					if (iterator == _servers.end()) {
+						rb_raise(rb_eRuntimeError, "Could not find Ruby server wrapper for native server.");
+					}
+
+					return iterator->second;
+				}
+			}
+			else if (result == NGTCP2_ERR_VERSION_NEGOTIATION) {
+				send_version_negotiation(*socket, version_cid, remote_address);
+			}
+			else {
+				rb_raise(rb_eRuntimeError, "Could not decode QUIC version/CID: %s", ngtcp2_strerror(result));
+			}
+
+			return Qnil;
+		}
+
+		::Protocol::QUIC::Server * create_server(::Protocol::QUIC::Socket & socket, const ::Protocol::QUIC::Address & address, const ngtcp2_pkt_hd & packet_header) override
+		{
+			auto iterator = _sockets.find(&socket);
+
+			if (iterator == _sockets.end()) {
+				rb_raise(rb_eRuntimeError, "Could not find Ruby socket wrapper for native socket.");
+			}
+
+			VALUE ruby_socket = iterator->second;
+			VALUE ruby_address = Ruby_Protocol_QUIC_Address_wrap(Ruby_Protocol_QUIC_Address, address);
+
+			VALUE ruby_packet_header = Ruby_Protocol_QUIC_PacketHeader_allocate(Ruby_Protocol_QUIC_PacketHeader);
+			DATA_PTR(ruby_packet_header) = new ngtcp2_pkt_hd(packet_header);
+
+			VALUE server = rb_funcall(self, rb_intern("create_server"), 3, ruby_socket, ruby_address, ruby_packet_header);
+			auto native_server = Ruby_Protocol_HTTP3_Server_get(server);
+
+			_servers[native_server] = server;
+
+			return native_server;
+		}
+
+		void remove(::Protocol::QUIC::Server * server) override
+		{
+			::Protocol::QUIC::Dispatcher::remove(server);
+			_servers.erase(static_cast<::Protocol::HTTP3::Server *>(server));
+		}
+
+		void mark()
+		{
+			rb_gc_mark_movable(self);
+			rb_gc_mark_movable(_configuration);
+			rb_gc_mark_movable(_tls_context);
+
+			for (auto & [server, ruby_server] : _servers) {
+				(void)server;
+				rb_gc_mark_movable(ruby_server);
+			}
+
+			for (auto & [socket, ruby_socket] : _sockets) {
+				(void)socket;
+				rb_gc_mark_movable(ruby_socket);
+			}
+		}
+
+		void compact()
+		{
+			self = rb_gc_location(self);
+			_configuration = rb_gc_location(_configuration);
+			_tls_context = rb_gc_location(_tls_context);
+
+			for (auto & [server, ruby_server] : _servers) {
+				(void)server;
+				ruby_server = rb_gc_location(ruby_server);
+			}
+
+			for (auto & [socket, ruby_socket] : _sockets) {
+				(void)socket;
+				ruby_socket = rb_gc_location(ruby_socket);
+			}
+		}
+	};
+
+}
+
+static void Ruby_Protocol_HTTP3_Dispatcher_mark(void *data)
+{
+	if (data) {
+		reinterpret_cast<Ruby::Protocol::HTTP3::Dispatcher *>(data)->mark();
+	}
+}
+
+static void Ruby_Protocol_HTTP3_Dispatcher_compact(void *data)
+{
+	if (data) {
+		reinterpret_cast<Ruby::Protocol::HTTP3::Dispatcher *>(data)->compact();
+	}
+}
+
+static void Ruby_Protocol_HTTP3_Dispatcher_free(void *data)
+{
+	if (data) {
+		delete reinterpret_cast<Protocol::QUIC::Dispatcher *>(data);
+	}
+}
+
+static size_t Ruby_Protocol_HTTP3_Dispatcher_size(const void *data)
+{
+	return sizeof(Ruby::Protocol::HTTP3::Dispatcher);
+}
+
+static const rb_data_type_t Ruby_Protocol_HTTP3_Dispatcher_type = {
+	.wrap_struct_name = "Protocol::HTTP3::Dispatcher",
+	.function = {
+		.dmark = Ruby_Protocol_HTTP3_Dispatcher_mark,
+		.dfree = Ruby_Protocol_HTTP3_Dispatcher_free,
+		.dsize = Ruby_Protocol_HTTP3_Dispatcher_size,
+		.dcompact = Ruby_Protocol_HTTP3_Dispatcher_compact,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+Protocol::QUIC::Dispatcher * Ruby_Protocol_HTTP3_Dispatcher_get(VALUE self)
+{
+	Protocol::QUIC::Dispatcher *dispatcher;
+
+	TypedData_Get_Struct(self, Protocol::QUIC::Dispatcher, &Ruby_Protocol_HTTP3_Dispatcher_type, dispatcher);
+
+	return dispatcher;
+}
+
+static VALUE Ruby_Protocol_HTTP3_Dispatcher_allocate(VALUE klass)
+{
+	return TypedData_Wrap_Struct(klass, &Ruby_Protocol_HTTP3_Dispatcher_type, NULL);
+}
+
+static VALUE Ruby_Protocol_HTTP3_Dispatcher_initialize(VALUE self, VALUE configuration, VALUE tls_context)
+{
+	DATA_PTR(self) = new Ruby::Protocol::HTTP3::Dispatcher(self, configuration, tls_context);
+
+	return self;
+}
+
+static VALUE Ruby_Protocol_HTTP3_Dispatcher_configuration(VALUE self)
+{
+	auto dispatcher = dynamic_cast<Ruby::Protocol::HTTP3::Dispatcher *>(Ruby_Protocol_HTTP3_Dispatcher_get(self));
+
+	return dispatcher->ruby_configuration();
+}
+
+static VALUE Ruby_Protocol_HTTP3_Dispatcher_tls_context(VALUE self)
+{
+	auto dispatcher = dynamic_cast<Ruby::Protocol::HTTP3::Dispatcher *>(Ruby_Protocol_HTTP3_Dispatcher_get(self));
+
+	return dispatcher->ruby_tls_context();
+}
+
+static VALUE Ruby_Protocol_HTTP3_Dispatcher_listen(VALUE self, VALUE socket)
+{
+	auto dispatcher = dynamic_cast<Ruby::Protocol::HTTP3::Dispatcher *>(Ruby_Protocol_HTTP3_Dispatcher_get(self));
+
+	return dispatcher->listen(socket);
+}
+
+static VALUE Ruby_Protocol_HTTP3_Dispatcher_receive(VALUE self, VALUE socket)
+{
+	auto dispatcher = dynamic_cast<Ruby::Protocol::HTTP3::Dispatcher *>(Ruby_Protocol_HTTP3_Dispatcher_get(self));
+
+	return dispatcher->receive(socket);
+}
+
+void Init_Ruby_Protocol_HTTP3_Dispatcher(VALUE Protocol_HTTP3)
+{
+	Ruby_Protocol_HTTP3_Dispatcher = rb_define_class_under(Protocol_HTTP3, "Dispatcher", rb_cObject);
+
+	rb_define_alloc_func(Ruby_Protocol_HTTP3_Dispatcher, Ruby_Protocol_HTTP3_Dispatcher_allocate);
+	rb_define_method(Ruby_Protocol_HTTP3_Dispatcher, "initialize", Ruby_Protocol_HTTP3_Dispatcher_initialize, 2);
+
+	rb_define_method(Ruby_Protocol_HTTP3_Dispatcher, "configuration", Ruby_Protocol_HTTP3_Dispatcher_configuration, 0);
+	rb_define_method(Ruby_Protocol_HTTP3_Dispatcher, "tls_context", Ruby_Protocol_HTTP3_Dispatcher_tls_context, 0);
+
+	rb_define_method(Ruby_Protocol_HTTP3_Dispatcher, "listen", Ruby_Protocol_HTTP3_Dispatcher_listen, 1);
+	rb_define_method(Ruby_Protocol_HTTP3_Dispatcher, "receive", Ruby_Protocol_HTTP3_Dispatcher_receive, 1);
+}

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

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <ruby.h>
+
+#include <Protocol/QUIC/Dispatcher.hpp>
+
+extern "C" {
+	extern VALUE Ruby_Protocol_HTTP3_Dispatcher;
+
+	void Init_Ruby_Protocol_HTTP3_Dispatcher(VALUE Protocol_HTTP3);
+
+	Protocol::QUIC::Dispatcher * Ruby_Protocol_HTTP3_Dispatcher_get(VALUE self);
+}

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

@@ -0,0 +1,239 @@
+#include "Server.hpp"
+
+#include "Dispatcher.hpp"
+
+#include "../QUIC/Bindings.hpp"
+
+#include <unordered_map>
+#include <vector>
+
+VALUE Ruby_Protocol_HTTP3_Server = Qnil;
+
+namespace Ruby::Protocol::HTTP3 {
+
+	class Server : public ::Protocol::HTTP3::Server {
+	public:
+		VALUE self;
+
+	private:
+		VALUE _dispatcher;
+		VALUE _configuration;
+		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) :
+			::Protocol::HTTP3::Server(*Ruby_Protocol_HTTP3_Dispatcher_get(dispatcher), *Ruby_Protocol_QUIC_Configuration_get(configuration), *Ruby_Protocol_QUIC_TLS_ServerContext_get(tls_context), *Ruby_Protocol_QUIC_Socket_get(socket), *Ruby_Protocol_QUIC_Address_get(remote_address), *Ruby_Protocol_QUIC_PacketHeader_get(packet_header), nullptr),
+			self(self),
+			_dispatcher(dispatcher),
+			_configuration(configuration),
+			_tls_context(tls_context),
+			_socket(socket),
+			_remote_address(remote_address)
+		{
+			(void)original_connection_id;
+		}
+
+		virtual ~Server()
+		{
+		}
+
+		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::HTTP3::Server::disconnect();
+			_streams.clear();
+		}
+
+		void mark()
+		{
+			rb_gc_mark_movable(self);
+			rb_gc_mark_movable(_dispatcher);
+			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);
+			_dispatcher = rb_gc_location(_dispatcher);
+			_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_Server_mark(void *data)
+{
+	if (data) {
+		reinterpret_cast<Ruby::Protocol::HTTP3::Server *>(data)->mark();
+	}
+}
+
+static void Ruby_Protocol_HTTP3_Server_compact(void *data)
+{
+	if (data) {
+		reinterpret_cast<Ruby::Protocol::HTTP3::Server *>(data)->compact();
+	}
+}
+
+static void Ruby_Protocol_HTTP3_Server_free(void *data)
+{
+	if (data) {
+		delete reinterpret_cast<Protocol::HTTP3::Server *>(data);
+	}
+}
+
+static size_t Ruby_Protocol_HTTP3_Server_size(const void *data)
+{
+	return sizeof(Ruby::Protocol::HTTP3::Server);
+}
+
+static const rb_data_type_t Ruby_Protocol_HTTP3_Server_type = {
+	.wrap_struct_name = "Protocol::HTTP3::Server",
+	.function = {
+		.dmark = Ruby_Protocol_HTTP3_Server_mark,
+		.dfree = Ruby_Protocol_HTTP3_Server_free,
+		.dsize = Ruby_Protocol_HTTP3_Server_size,
+		.dcompact = Ruby_Protocol_HTTP3_Server_compact,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+Protocol::HTTP3::Server * Ruby_Protocol_HTTP3_Server_get(VALUE self)
+{
+	Protocol::HTTP3::Server *server;
+
+	TypedData_Get_Struct(self, Protocol::HTTP3::Server, &Ruby_Protocol_HTTP3_Server_type, server);
+
+	return server;
+}
+
+static VALUE Ruby_Protocol_HTTP3_Server_allocate(VALUE klass)
+{
+	return TypedData_Wrap_Struct(klass, &Ruby_Protocol_HTTP3_Server_type, NULL);
+}
+
+static VALUE Ruby_Protocol_HTTP3_Server_initialize(VALUE self, VALUE dispatcher, VALUE configuration, VALUE tls_context, VALUE socket, VALUE remote_address, VALUE packet_header, VALUE original_connection_id)
+{
+	DATA_PTR(self) = new Ruby::Protocol::HTTP3::Server(self, dispatcher, configuration, tls_context, socket, remote_address, packet_header, original_connection_id);
+
+	return self;
+}
+
+static VALUE Ruby_Protocol_HTTP3_Server_send_packets(VALUE self)
+{
+	auto server = Ruby_Protocol_HTTP3_Server_get(self);
+
+	server->send_packets();
+
+	return Qnil;
+}
+
+static VALUE Ruby_Protocol_HTTP3_Server_submit_response(VALUE self, VALUE stream_id, VALUE headers)
+{
+	auto server = Ruby_Protocol_HTTP3_Server_get(self);
+	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,
+		});
+	}
+
+	server->submit_response(RB_NUM2LL(stream_id), native_headers.data(), native_headers.size());
+	server->send_packets();
+
+	return Qnil;
+}
+
+void Init_Ruby_Protocol_HTTP3_Server(VALUE Protocol_HTTP3)
+{
+	Ruby_Protocol_HTTP3_Server = rb_define_class_under(Protocol_HTTP3, "Server", rb_cObject);
+
+	rb_define_alloc_func(Ruby_Protocol_HTTP3_Server, Ruby_Protocol_HTTP3_Server_allocate);
+	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);
+}

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

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <ruby.h>
+
+#include <Protocol/HTTP3/Server.hpp>
+
+extern "C" {
+	extern VALUE Ruby_Protocol_HTTP3_Server;
+
+	void Init_Ruby_Protocol_HTTP3_Server(VALUE Protocol_HTTP3);
+
+	Protocol::HTTP3::Server * Ruby_Protocol_HTTP3_Server_get(VALUE self);
+}

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

@@ -0,0 +1,28 @@
+#include "HTTP3.hpp"
+
+#include "HTTP3/Client.hpp"
+#include "HTTP3/Dispatcher.hpp"
+#include "HTTP3/Server.hpp"
+
+#include "QUIC/Bindings.hpp"
+
+VALUE Ruby_Protocol_HTTP3 = Qnil;
+
+static VALUE Ruby_Protocol_HTTP3_file_descriptor(VALUE self, VALUE socket)
+{
+	(void)self;
+
+	return INT2NUM(Ruby_Protocol_QUIC_Socket_get(socket)->descriptor());
+}
+
+void Init_Ruby_Protocol_HTTP3(void)
+{
+	VALUE Protocol = rb_define_module("Protocol");
+	Ruby_Protocol_HTTP3 = rb_define_module_under(Protocol, "HTTP3");
+
+	rb_define_singleton_method(Ruby_Protocol_HTTP3, "file_descriptor", Ruby_Protocol_HTTP3_file_descriptor, 1);
+
+	Init_Ruby_Protocol_HTTP3_Client(Ruby_Protocol_HTTP3);
+	Init_Ruby_Protocol_HTTP3_Server(Ruby_Protocol_HTTP3);
+	Init_Ruby_Protocol_HTTP3_Dispatcher(Ruby_Protocol_HTTP3);
+}

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

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <ruby.h>
+
+extern "C" {
+	extern VALUE Ruby_Protocol_HTTP3;
+
+	void Init_Ruby_Protocol_HTTP3(void);
+}

data/ext/source/Ruby/Protocol/QUIC/Bindings.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <ruby.h>
+
+#include <Protocol/QUIC/Address.hpp>
+#include <Protocol/QUIC/Configuration.hpp>
+#include <Protocol/QUIC/Client.hpp>
+#include <Protocol/QUIC/Connection.hpp>
+#include <Protocol/QUIC/Dispatcher.hpp>
+#include <Protocol/QUIC/Socket.hpp>
+#include <Protocol/QUIC/TLS/ClientContext.hpp>
+#include <Protocol/QUIC/TLS/ServerContext.hpp>
+
+#include <ngtcp2/ngtcp2.h>
+
+extern "C" {
+	extern VALUE Ruby_Protocol_QUIC_Address;
+	extern VALUE Ruby_Protocol_QUIC_PacketHeader;
+	extern const rb_data_type_t Ruby_Protocol_QUIC_Connection_type;
+
+	Protocol::QUIC::Address * Ruby_Protocol_QUIC_Address_get(VALUE self);
+	VALUE Ruby_Protocol_QUIC_Address_wrap(VALUE klass, const Protocol::QUIC::Address & address);
+
+	Protocol::QUIC::Configuration * Ruby_Protocol_QUIC_Configuration_get(VALUE self);
+	Protocol::QUIC::Client * Ruby_Protocol_QUIC_Client_get(VALUE self);
+	Protocol::QUIC::Connection * Ruby_Protocol_QUIC_Connection_get(VALUE self);
+	Protocol::QUIC::Dispatcher * Ruby_Protocol_QUIC_Dispatcher_get(VALUE self);
+
+	ngtcp2_pkt_hd * Ruby_Protocol_QUIC_PacketHeader_get(VALUE self);
+	VALUE Ruby_Protocol_QUIC_PacketHeader_allocate(VALUE klass);
+
+	Protocol::QUIC::Socket * Ruby_Protocol_QUIC_Socket_get(VALUE self);
+	Protocol::QUIC::TLS::ClientContext * Ruby_Protocol_QUIC_TLS_ClientContext_get(VALUE self);
+	Protocol::QUIC::TLS::ServerContext * Ruby_Protocol_QUIC_TLS_ServerContext_get(VALUE self);
+}

data/ext/teapot.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+teapot_version "3.0"
+
+define_project "ruby-protocol-http3" do |project|
+	project.title = "Protocol::HTTP3"
+	project.license = "MIT License"
+end
+
+define_target "ruby-protocol-http3" do |target|
+	target.depends "Language/C++17"
+	
+	target.depends "Library/Protocol/HTTP3"
+	target.depends "Library/ruby"
+	target.depends "Build/Files"
+	target.depends "Build/Compile/Commands"
+	
+	target.provides "Ruby/Protocol/HTTP3" do
+		source_root = target.package.path + "source"
+		
+		library_path = build dynamic_library: "Ruby_Protocol_HTTP3", source_files: source_root.glob("**/*.{c,cpp}")
+		
+		copy source: [library_path], prefix: environment[:ruby_install_path]
+		
+		compile_commands destination_path: (source_root + "compile_commands.json")
+	end
+end
+
+define_configuration "ruby-protocol-http3" do |configuration|
+	configuration[:source] = "https://github.com/kurocha/"
+	
+	configuration.require "platforms"
+	
+	configuration.require "build-make"
+	configuration.require "build-cmake"
+	
+	configuration.require "scheduler-ruby"
+	configuration.require "protocol-http3"
+	configuration.require "ruby"
+	
+	configuration.require "generate-template"
+	configuration.require "generate-cpp-class"
+	
+	configuration.require "build-compile-commands"
+end

data/lib/protocol/http3/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023-2026, by Samuel Williams.
+
+# @namespace
+module Protocol
+	# @namespace
+	module HTTP3
+		VERSION = "0.0.1"
+	end
+end

data/lib/protocol/http3.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023-2026, by Samuel Williams.
+
+require "protocol/quic"
+
+require_relative "http3/version"
+
+# Native extension:
+require "Ruby_Protocol_HTTP3"

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2023-2026, by Samuel Williams.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.