protocol-quic 0.0.3 → 0.0.4

data/ext/source/Ruby/Protocol/QUIC/TLS/Context.cpp

@@ -0,0 +1,116 @@
+//
+//  Context.cpp
+//  This file is part of the "Protocol::QUIC" project and released under the MIT License.
+//
+//  Created by Samuel Williams on 27/4/2023.
+//  Copyright, 2023, by Samuel Williams. All rights reserved.
+//
+
+#include "Context.hpp"
+
+#include "ClientContext.hpp"
+#include "ServerContext.hpp"
+
+VALUE Ruby_Protocol_QUIC_TLS_Context = Qnil;
+
+static void Ruby_Protocol_QUIC_TLS_Context_free(void *data) {
+	if (data) {
+		delete reinterpret_cast<::Protocol::QUIC::TLS::Context *>(data);
+	}
+}
+
+static size_t Ruby_Protocol_QUIC_TLS_Context_size(const void *data) {
+	return sizeof(::Protocol::QUIC::TLS::Context);
+}
+
+const rb_data_type_t Ruby_Protocol_QUIC_TLS_Context_type = {
+	.wrap_struct_name = "Protocol::QUIC::TLS::Context",
+	.function = {
+		.dmark = NULL,
+		.dfree = Ruby_Protocol_QUIC_TLS_Context_free,
+		.dsize = Ruby_Protocol_QUIC_TLS_Context_size,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+::Protocol::QUIC::TLS::Context * Ruby_Protocol_QUIC_TLS_Context_get(VALUE self)
+{
+	::Protocol::QUIC::TLS::Context *tls_context;
+
+	TypedData_Get_Struct(self, ::Protocol::QUIC::TLS::Context, &Ruby_Protocol_QUIC_TLS_Context_type, tls_context);
+
+	return tls_context;
+}
+
+static VALUE Ruby_Protocol_QUIC_TLS_Context_allocate(VALUE klass) {
+	return TypedData_Wrap_Struct(klass, &Ruby_Protocol_QUIC_TLS_Context_type, NULL);
+}
+
+static VALUE Ruby_Protocol_QUIC_TLS_Context_initialize(VALUE self) {
+	DATA_PTR(self) = new ::Protocol::QUIC::TLS::Context();
+
+	return self;
+}
+
+static VALUE Ruby_Protocol_QUIC_TLS_Context_add_protocol(VALUE self, VALUE name) {
+	StringValue(name);
+	
+	::Protocol::QUIC::TLS::Context *tls_context;
+	TypedData_Get_Struct(self, ::Protocol::QUIC::TLS::Context, &Ruby_Protocol_QUIC_TLS_Context_type, tls_context);
+	
+	tls_context->add_protocol(
+		std::string(RSTRING_PTR(name), RSTRING_LEN(name))
+	);
+	
+	return self;
+}
+
+static VALUE Ruby_Protocol_QUIC_TLS_Context_load_certificate_file(VALUE self, VALUE path) {
+	StringValue(path);
+	
+	auto tls_context = Ruby_Protocol_QUIC_TLS_Context_get(self);
+	tls_context->load_certificate_file(RSTRING_PTR(path));
+	
+	return self;
+}
+
+static VALUE Ruby_Protocol_QUIC_TLS_Context_load_private_key_file(VALUE self, VALUE path) {
+	StringValue(path);
+	
+	auto tls_context = Ruby_Protocol_QUIC_TLS_Context_get(self);
+	tls_context->load_private_key_file(RSTRING_PTR(path));
+	
+	return self;
+}
+
+static VALUE Ruby_Protocol_QUIC_TLS_Context_protocols(VALUE self) {
+	::Protocol::QUIC::TLS::Context *tls_context;
+	TypedData_Get_Struct(self, ::Protocol::QUIC::TLS::Context, &Ruby_Protocol_QUIC_TLS_Context_type, tls_context);
+	
+	VALUE protocols = rb_ary_new();
+	
+	for (auto & protocol : tls_context->protocols()) {
+		rb_ary_push(protocols, rb_str_new(protocol.data(), protocol.size()));
+	}
+	
+	return protocols;
+}
+
+void Init_Ruby_Protocol_QUIC_TLS_Context(VALUE Protocol_QUIC) {
+	VALUE Protocol_QUIC_TLS = rb_define_module_under(Protocol_QUIC, "TLS");
+	
+	Ruby_Protocol_QUIC_TLS_Context =
+			rb_define_class_under(Protocol_QUIC_TLS, "Context", rb_cObject);
+
+	rb_define_alloc_func(Ruby_Protocol_QUIC_TLS_Context, Ruby_Protocol_QUIC_TLS_Context_allocate);
+	rb_define_method(Ruby_Protocol_QUIC_TLS_Context, "initialize", Ruby_Protocol_QUIC_TLS_Context_initialize, 0);
+	
+	rb_define_method(Ruby_Protocol_QUIC_TLS_Context, "add_protocol", Ruby_Protocol_QUIC_TLS_Context_add_protocol, 1);
+	rb_define_method(Ruby_Protocol_QUIC_TLS_Context, "load_certificate_file", Ruby_Protocol_QUIC_TLS_Context_load_certificate_file, 1);
+	rb_define_method(Ruby_Protocol_QUIC_TLS_Context, "load_private_key_file", Ruby_Protocol_QUIC_TLS_Context_load_private_key_file, 1);
+	rb_define_method(Ruby_Protocol_QUIC_TLS_Context, "protocols", Ruby_Protocol_QUIC_TLS_Context_protocols, 0);
+	
+	Init_Ruby_Protocol_QUIC_TLS_ClientContext(Protocol_QUIC_TLS);
+	Init_Ruby_Protocol_QUIC_TLS_ServerContext(Protocol_QUIC_TLS);
+}

data/ext/source/{Protocol → Ruby/Protocol}/QUIC/TLS/Context.hpp

@@ -16,11 +16,11 @@
 extern "C" {
 #endif
 
-extern VALUE Protocol_QUIC_TLS_Context;
+extern VALUE Ruby_Protocol_QUIC_TLS_Context;
 
-extern const rb_data_type_t Protocol_QUIC_TLS_Context_type;
+extern const rb_data_type_t Ruby_Protocol_QUIC_TLS_Context_type;
 
-void Init_Protocol_QUIC_TLS_Context(VALUE Protocol_QUIC);
+void Init_Ruby_Protocol_QUIC_TLS_Context(VALUE Protocol_QUIC);
 
 #ifdef __cplusplus
 }

data/ext/source/Ruby/Protocol/QUIC/TLS/ServerContext.cpp

@@ -0,0 +1,61 @@
+//
+//  ServerContext.cpp
+//  This file is part of the "Protocol::QUIC" project and released under the MIT License.
+//
+//  Created by Samuel Williams on 27/4/2023.
+//  Copyright, 2023, by Samuel Williams. All rights reserved.
+//
+
+#include "ServerContext.hpp"
+#include "Context.hpp"
+
+VALUE Ruby_Protocol_QUIC_TLS_ServerContext = Qnil;
+
+static void Ruby_Protocol_QUIC_TLS_ServerContext_free(void *data) {
+	if (data) {
+		delete reinterpret_cast<::Protocol::QUIC::TLS::ServerContext *>(data);
+	}
+}
+
+static size_t Ruby_Protocol_QUIC_TLS_ServerContext_size(const void *data) {
+	return sizeof(::Protocol::QUIC::TLS::ServerContext);
+}
+
+static const rb_data_type_t Ruby_Protocol_QUIC_TLS_ServerContext_type = {
+	.wrap_struct_name = "Protocol::QUIC::TLS::ServerContext",
+	.function = {
+		.dmark = NULL,
+		.dfree = Ruby_Protocol_QUIC_TLS_ServerContext_free,
+		.dsize = Ruby_Protocol_QUIC_TLS_ServerContext_size,
+	},
+	.parent = &Ruby_Protocol_QUIC_TLS_Context_type,
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+::Protocol::QUIC::TLS::ServerContext * Ruby_Protocol_QUIC_TLS_ServerContext_get(VALUE self)
+{
+	::Protocol::QUIC::TLS::ServerContext *data;
+
+	TypedData_Get_Struct(self, ::Protocol::QUIC::TLS::ServerContext, &Ruby_Protocol_QUIC_TLS_ServerContext_type, data);
+
+	return data;
+}
+
+static VALUE Ruby_Protocol_QUIC_TLS_ServerContext_allocate(VALUE klass) {
+	return TypedData_Wrap_Struct(klass, &Ruby_Protocol_QUIC_TLS_ServerContext_type, NULL);
+}
+
+static VALUE Ruby_Protocol_QUIC_TLS_ServerContext_initialize(VALUE self) {
+	DATA_PTR(self) = new ::Protocol::QUIC::TLS::ServerContext();
+
+	return self;
+}
+
+void Init_Ruby_Protocol_QUIC_TLS_ServerContext(VALUE Protocol_QUIC_TLS) {
+	Ruby_Protocol_QUIC_TLS_ServerContext =
+			rb_define_class_under(Protocol_QUIC_TLS, "ServerContext", Ruby_Protocol_QUIC_TLS_Context);
+
+	rb_define_alloc_func(Ruby_Protocol_QUIC_TLS_ServerContext, Ruby_Protocol_QUIC_TLS_ServerContext_allocate);
+	rb_define_method(Ruby_Protocol_QUIC_TLS_ServerContext, "initialize", Ruby_Protocol_QUIC_TLS_ServerContext_initialize, 0);
+}

data/ext/source/{Protocol → Ruby/Protocol}/QUIC/TLS/ServerContext.hpp

@@ -16,11 +16,11 @@
 extern "C" {
 #endif
 
-extern VALUE Protocol_QUIC_TLS_ServerContext;
+extern VALUE Ruby_Protocol_QUIC_TLS_ServerContext;
 
-void Init_Protocol_QUIC_TLS_ServerContext(VALUE Protocol_QUIC_TLS);
+void Init_Ruby_Protocol_QUIC_TLS_ServerContext(VALUE Protocol_QUIC_TLS);
 
-Protocol::QUIC::TLS::ServerContext * Protocol_QUIC_TLS_ServerContext_get(VALUE self);
+::Protocol::QUIC::TLS::ServerContext * Ruby_Protocol_QUIC_TLS_ServerContext_get(VALUE self);
 
 #ifdef __cplusplus
 }

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

@@ -0,0 +1,36 @@
+#include "QUIC.hpp"
+
+#include "QUIC/Connection.hpp"
+#include "QUIC/TLS/Context.hpp"
+
+#include "QUIC/Address.hpp"
+#include "QUIC/Dispatcher.hpp"
+#include "QUIC/Configuration.hpp"
+#include "QUIC/PacketHeader.hpp"
+#include "QUIC/Socket.hpp"
+
+#include "QUIC/Server.hpp"
+#include "QUIC/Client.hpp"
+#include "QUIC/Stream.hpp"
+
+VALUE Protocol_QUIC = Qnil;
+
+void Init_Ruby_Protocol_QUIC(void)
+{
+	VALUE Protocol = rb_define_module("Protocol");
+	Protocol_QUIC = rb_define_module_under(Protocol, "QUIC");
+	
+	Init_Ruby_Protocol_QUIC_TLS_Context(Protocol_QUIC);
+	
+	Init_Ruby_Protocol_QUIC_Address(Protocol_QUIC);
+	Init_Ruby_Protocol_QUIC_Dispatcher(Protocol_QUIC);
+	Init_Ruby_Protocol_QUIC_Configuration(Protocol_QUIC);
+	Init_Ruby_Protocol_QUIC_PacketHeader(Protocol_QUIC);
+	Init_Ruby_Protocol_QUIC_Socket(Protocol_QUIC);
+	
+	Init_Ruby_Protocol_QUIC_Connection(Protocol_QUIC);
+	Init_Ruby_Protocol_QUIC_Server(Protocol_QUIC);
+	Init_Ruby_Protocol_QUIC_Client(Protocol_QUIC);
+	
+	Init_Ruby_Protocol_QUIC_Stream(Protocol_QUIC);
+}

data/ext/source/{Protocol → Ruby/Protocol}/QUIC.hpp

@@ -8,7 +8,7 @@ extern "C" {
 
 extern VALUE Protocol_QUIC;
 
-void Init_Protocol_QUIC(void);
+void Init_Ruby_Protocol_QUIC(void);
 
 #ifdef __cplusplus
 }

data/ext/teapot.rb

@@ -22,7 +22,7 @@ define_target "ruby-protocol-quic" do |target|
 	target.provides "Ruby/Protocol/QUIC" do
 		source_root = target.package.path + "source"
 		
-		library_path = build dynamic_library: "Protocol_QUIC", source_files: source_root.glob("**/*.{c,cpp}")
+		library_path = build dynamic_library: "Ruby_Protocol_QUIC", source_files: source_root.glob("**/*.{c,cpp}")
 		
 		copy source: [library_path], prefix: environment[:ruby_install_path]
 		

data/lib/protocol/quic/version.rb

@@ -7,6 +7,6 @@
 module Protocol
 	# @namespace
 	module QUIC
-		VERSION = "0.0.3"
+		VERSION = "0.0.4"
 	end
 end

data/lib/protocol/quic.rb

@@ -4,6 +4,6 @@
 # Copyright, 2023-2026, by Samuel Williams.
 
 # Native extension:
-require "Protocol_QUIC"
+require "Ruby_Protocol_QUIC"
 
 require_relative "quic/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protocol-quic
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Samuel Williams
@@ -73,33 +73,33 @@ extra_rdoc_files: []
 files:
 - ext/rakefile.rb
 - ext/ruby-protocol-quic-lock.yml
-- ext/source/Protocol/QUIC.cpp
-- ext/source/Protocol/QUIC.hpp
-- ext/source/Protocol/QUIC/Address.cpp
-- ext/source/Protocol/QUIC/Address.hpp
-- ext/source/Protocol/QUIC/Client.cpp
-- ext/source/Protocol/QUIC/Client.hpp
-- ext/source/Protocol/QUIC/Configuration.cpp
-- ext/source/Protocol/QUIC/Configuration.hpp
-- ext/source/Protocol/QUIC/Connection.cpp
-- ext/source/Protocol/QUIC/Connection.hpp
-- ext/source/Protocol/QUIC/Dispatcher.cpp
-- ext/source/Protocol/QUIC/Dispatcher.hpp
-- ext/source/Protocol/QUIC/PacketHeader.cpp
-- ext/source/Protocol/QUIC/PacketHeader.hpp
-- ext/source/Protocol/QUIC/Reference.hpp
-- ext/source/Protocol/QUIC/Server.cpp
-- ext/source/Protocol/QUIC/Server.hpp
-- ext/source/Protocol/QUIC/Socket.cpp
-- ext/source/Protocol/QUIC/Socket.hpp
-- ext/source/Protocol/QUIC/Stream.cpp
-- ext/source/Protocol/QUIC/Stream.hpp
-- ext/source/Protocol/QUIC/TLS/ClientContext.cpp
-- ext/source/Protocol/QUIC/TLS/ClientContext.hpp
-- ext/source/Protocol/QUIC/TLS/Context.cpp
-- ext/source/Protocol/QUIC/TLS/Context.hpp
-- ext/source/Protocol/QUIC/TLS/ServerContext.cpp
-- ext/source/Protocol/QUIC/TLS/ServerContext.hpp
+- ext/source/Ruby/Protocol/QUIC.cpp
+- ext/source/Ruby/Protocol/QUIC.hpp
+- ext/source/Ruby/Protocol/QUIC/Address.cpp
+- ext/source/Ruby/Protocol/QUIC/Address.hpp
+- ext/source/Ruby/Protocol/QUIC/Client.cpp
+- ext/source/Ruby/Protocol/QUIC/Client.hpp
+- ext/source/Ruby/Protocol/QUIC/Configuration.cpp
+- ext/source/Ruby/Protocol/QUIC/Configuration.hpp
+- ext/source/Ruby/Protocol/QUIC/Connection.cpp
+- ext/source/Ruby/Protocol/QUIC/Connection.hpp
+- ext/source/Ruby/Protocol/QUIC/Dispatcher.cpp
+- ext/source/Ruby/Protocol/QUIC/Dispatcher.hpp
+- ext/source/Ruby/Protocol/QUIC/PacketHeader.cpp
+- ext/source/Ruby/Protocol/QUIC/PacketHeader.hpp
+- ext/source/Ruby/Protocol/QUIC/Reference.hpp
+- ext/source/Ruby/Protocol/QUIC/Server.cpp
+- ext/source/Ruby/Protocol/QUIC/Server.hpp
+- ext/source/Ruby/Protocol/QUIC/Socket.cpp
+- ext/source/Ruby/Protocol/QUIC/Socket.hpp
+- ext/source/Ruby/Protocol/QUIC/Stream.cpp
+- ext/source/Ruby/Protocol/QUIC/Stream.hpp
+- ext/source/Ruby/Protocol/QUIC/TLS/ClientContext.cpp
+- ext/source/Ruby/Protocol/QUIC/TLS/ClientContext.hpp
+- ext/source/Ruby/Protocol/QUIC/TLS/Context.cpp
+- ext/source/Ruby/Protocol/QUIC/TLS/Context.hpp
+- ext/source/Ruby/Protocol/QUIC/TLS/ServerContext.cpp
+- ext/source/Ruby/Protocol/QUIC/TLS/ServerContext.hpp
 - ext/teapot.rb
 - lib/protocol/quic.rb
 - lib/protocol/quic/version.rb

data/ext/source/Protocol/QUIC/Address.cpp

@@ -1,122 +0,0 @@
-//
-//  Address.cpp
-//  This file is part of the "Protocol::QUIC" project and released under the MIT License.
-//
-//  Created by Samuel Williams on 27/4/2023.
-//  Copyright, 2023, by Samuel Williams. All rights reserved.
-//
-
-#include "Address.hpp"
-#include "ruby/backward/cxxanyargs.hpp"
-#include "ruby/internal/intern/object.h"
-
-VALUE Protocol_QUIC_Address = Qnil;
-
-static void Protocol_QUIC_Address_free(void *data) {
-	if (data) {
-		delete reinterpret_cast<Protocol::QUIC::Address *>(data);
-	}
-}
-
-static size_t Protocol_QUIC_Address_size(const void *data) {
-	return sizeof(Protocol::QUIC::Address);
-}
-
-const rb_data_type_t Protocol_QUIC_Address_type = {
-	.wrap_struct_name = "Protocol::QUIC::Address",
-	.function = {
-		.dmark = NULL,
-		.dfree = Protocol_QUIC_Address_free,
-		.dsize = Protocol_QUIC_Address_size,
-	},
-	.data = NULL,
-	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-Protocol::QUIC::Address * Protocol_QUIC_Address_get(VALUE self)
-{
-	Protocol::QUIC::Address *address;
-	
-	TypedData_Get_Struct(self, Protocol::QUIC::Address, &Protocol_QUIC_Address_type, address);
-	
-	return address;
-}
-
-VALUE Protocol_QUIC_Address_allocate(VALUE klass) {
-	return TypedData_Wrap_Struct(klass, &Protocol_QUIC_Address_type, NULL);
-}
-
-static VALUE Protocol_QUIC_Address_initialize(VALUE self) {
-	DATA_PTR(self) = new Protocol::QUIC::Address();
-	
-	return self;
-}
-
-static VALUE Protocol_QUIC_Address_inspect(VALUE self) {
-	auto address = Protocol_QUIC_Address_get(self);
-	auto string = address->to_string();
-	
-	VALUE class_name = rb_inspect(rb_class_of(self));
-	
-	return rb_sprintf("<%" PRIsVALUE ":%p '%s'>", class_name, (void*)self, string.c_str());
-}
-
-static VALUE  Protocol_QUIC_Address_family(VALUE self) {
-	Protocol::QUIC::Address *address = Protocol_QUIC_Address_get(self);
-	
-	return RB_INT2NUM(address->family());
-}
-
-static VALUE Protocol_QUIC_Address_data(VALUE self) {
-	Protocol::QUIC::Address *address = Protocol_QUIC_Address_get(self);
-	
-	return rb_str_new((const char *)&address->data.sa, address->length);
-}
-
-VALUE Protocol_QUIC_Address_wrap(VALUE klass, const Protocol::QUIC::Address & address)
-{
-	VALUE self = Protocol_QUIC_Address_allocate(klass);
-	Protocol_QUIC_Address_initialize(self);
-	
-	Protocol::QUIC::Address *data = Protocol_QUIC_Address_get(self);
-	
-	*data = address;
-	
-	return self;
-}
-
-VALUE Protocol_QUIC_Address_s_resolve(VALUE klass, VALUE host, VALUE service, VALUE family, VALUE type, VALUE flags)
-{
-	StringValue(host);
-	StringValue(service);
-	
-	auto addresses = Protocol::QUIC::Address::resolve(
-		std::string_view(RSTRING_PTR(host), RSTRING_LEN(host)),
-		std::string_view(RSTRING_PTR(service), RSTRING_LEN(service)),
-		RB_NUM2INT(family),
-		RB_NUM2INT(type),
-		RB_NUM2INT(flags)
-	);
-	
-	VALUE result = rb_ary_new_capa(addresses.size());
-	
-	for (auto & address : addresses) {
-		rb_ary_push(result, Protocol_QUIC_Address_wrap(klass, address));
-	}
-	
-	return result;
-}
-
-void Init_Protocol_QUIC_Address(VALUE Protocol_QUIC) {
-	Protocol_QUIC_Address =
-			rb_define_class_under(Protocol_QUIC, "Address", rb_cObject);
-	
-	rb_define_singleton_method(Protocol_QUIC_Address, "resolve", Protocol_QUIC_Address_s_resolve, 5);
-	
-	rb_define_alloc_func(Protocol_QUIC_Address, Protocol_QUIC_Address_allocate);
-	rb_define_method(Protocol_QUIC_Address, "initialize", Protocol_QUIC_Address_initialize, 0);
-	rb_define_method(Protocol_QUIC_Address, "inspect", Protocol_QUIC_Address_inspect, 0);
-	
-	rb_define_method(Protocol_QUIC_Address, "family", Protocol_QUIC_Address_family, 0);
-	rb_define_method(Protocol_QUIC_Address, "data", Protocol_QUIC_Address_data, 0);
-}

data/ext/source/Protocol/QUIC/Client.cpp

@@ -1,157 +0,0 @@
-
-#include "Client.hpp"
-
-#include "Configuration.hpp"
-#include "TLS/ClientContext.hpp"
-#include "Socket.hpp"
-#include "Address.hpp"
-#include "Stream.hpp"
-
-#include <unordered_map>
-
-VALUE Protocol_QUIC_Client = Qnil;
-
-class RubyClient : public Protocol::QUIC::Client {
-public:
-	VALUE self;
-	
-private:
-	VALUE _configuration;
-	VALUE _tls_context;
-	VALUE _socket;
-	VALUE _remote_address;
-	std::unordered_map<Protocol::QUIC::StreamID, VALUE> _ruby_streams;
-	
-public:
-	RubyClient(VALUE self, VALUE configuration, VALUE tls_context, VALUE socket, VALUE remote_address, VALUE chosen_version) : Protocol::QUIC::Client(*Protocol_QUIC_Configuration_get(configuration), *Protocol_QUIC_TLS_ClientContext_get(tls_context), *Protocol_QUIC_Socket_get(socket), *Protocol_QUIC_Address_get(remote_address), RB_NUM2UINT(chosen_version)), self(self), _configuration(configuration), _tls_context(tls_context), _socket(socket), _remote_address(remote_address) {}
-	virtual ~RubyClient() {}
-	
-	void handshake_completed() override
-	{
-		rb_funcall(self, rb_intern("handshake_completed"), 0);
-	}
-	
-	Protocol::QUIC::Stream * create_stream(Protocol::QUIC::StreamID stream_id) override
-	{
-		VALUE stream = rb_funcall(self, rb_intern("create_stream"), 1, RB_LL2NUM(stream_id));
-		_ruby_streams[stream_id] = stream;
-		
-		return Protocol_QUIC_Stream_get(stream);
-	}
-	
-	void disconnect() override
-	{
-		Protocol::QUIC::Client::disconnect();
-		_ruby_streams.clear();
-	}
-	
-	void stream_close(Protocol::QUIC::Stream * stream, std::int32_t flags, std::uint64_t error_code) override
-	{
-		auto stream_id = stream->stream_id();
-		Protocol::QUIC::Client::stream_close(stream, flags, error_code);
-		_ruby_streams.erase(stream_id);
-	}
-	
-	void stream_reset(Protocol::QUIC::Stream * stream, std::size_t final_size, std::uint64_t error_code) override
-	{
-		auto stream_id = stream->stream_id();
-		Protocol::QUIC::Client::stream_reset(stream, final_size, error_code);
-		_ruby_streams.erase(stream_id);
-	}
-	
-	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, ruby_stream] : _ruby_streams) {
-			rb_gc_mark_movable(ruby_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, ruby_stream] : _ruby_streams) {
-			ruby_stream = rb_gc_location(ruby_stream);
-		}
-	}
-};
-
-static void Protocol_QUIC_Client_mark(void *data)
-{
-	if (data) {
-		reinterpret_cast<RubyClient *>(data)->mark();
-	}
-}
-
-static void Protocol_QUIC_Client_compact(void *data)
-{
-	if (data) {
-		reinterpret_cast<RubyClient *>(data)->compact();
-	}
-}
-
-static void Protocol_QUIC_Client_free(void *data)
-{
-	if (data) {
-		delete reinterpret_cast<Protocol::QUIC::Client *>(data);
-	}
-}
-
-static size_t Protocol_QUIC_Client_size(const void *data) {
-	return sizeof(RubyClient);
-}
-
-static const rb_data_type_t Protocol_QUIC_Client_type = {
-	.wrap_struct_name = "Protocol::QUIC::Client",
-	.function = {
-		.dmark = Protocol_QUIC_Client_mark,
-		.dfree = Protocol_QUIC_Client_free,
-		.dsize = Protocol_QUIC_Client_size,
-		.dcompact = Protocol_QUIC_Client_compact,
-	},
-	.data = NULL,
-	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-Protocol::QUIC::Client * Protocol_QUIC_Client_get(VALUE self)
-{
-	Protocol::QUIC::Client *configuration;
-	TypedData_Get_Struct(self, Protocol::QUIC::Client, &Protocol_QUIC_Client_type, configuration);
-	return configuration;
-}
-
-static VALUE Protocol_QUIC_Client_allocate(VALUE klass) {
-	return TypedData_Wrap_Struct(klass, &Protocol_QUIC_Client_type, NULL);
-}
-
-static VALUE Protocol_QUIC_Client_initialize(VALUE self, VALUE configuration, VALUE tls_context, VALUE socket, VALUE remote_address, VALUE chosen_version) {
-	Protocol::QUIC::Client *client = new RubyClient(self, configuration, tls_context, socket, remote_address, chosen_version);
-	DATA_PTR(self) = client;
-	return self;
-}
-
-static VALUE Protocol_QUIC_Client_connect(VALUE self) {
-	Protocol::QUIC::Client *client = Protocol_QUIC_Client_get(self);
-	
-	client->connect();
-	
-	return Qnil;
-}
-
-void Init_Protocol_QUIC_Client(VALUE Protocol_QUIC) {
-	Protocol_QUIC_Client =
-			rb_define_class_under(Protocol_QUIC, "Client", rb_cObject);
-
-	rb_define_alloc_func(Protocol_QUIC_Client, Protocol_QUIC_Client_allocate);
-	rb_define_method(Protocol_QUIC_Client, "initialize", Protocol_QUIC_Client_initialize, 5);
-	
-	rb_define_method(Protocol_QUIC_Client, "connect", Protocol_QUIC_Client_connect, 0);
-}