protocol-quic 0.0.3 → 0.0.5

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

@@ -1,165 +0,0 @@
-
-#include "Server.hpp"
-
-#include "Dispatcher.hpp"
-#include "Configuration.hpp"
-#include "Connection.hpp"
-#include "TLS/ServerContext.hpp"
-#include "Socket.hpp"
-#include "Address.hpp"
-#include "PacketHeader.hpp"
-
-#include "Stream.hpp"
-
-#include <unordered_map>
-
-VALUE Protocol_QUIC_Server = Qnil;
-
-class RubyServer : public Protocol::QUIC::Server {
-public:
-	VALUE self;
-	
-private:
-	VALUE _dispatcher;
-	VALUE _configuration;
-	VALUE _tls_context;
-	VALUE _socket;
-	VALUE _remote_address;
-	std::unordered_map<Protocol::QUIC::StreamID, VALUE> _ruby_streams;
-	
-public:
-	RubyServer(VALUE self, VALUE dispatcher, VALUE configuration, VALUE tls_context, VALUE socket, VALUE remote_address, VALUE packet_header, VALUE ocid) : Protocol::QUIC::Server(*Protocol_QUIC_Dispatcher_get(dispatcher), *Protocol_QUIC_Configuration_get(configuration), *Protocol_QUIC_TLS_ServerContext_get(tls_context), *Protocol_QUIC_Socket_get(socket), *Protocol_QUIC_Address_get(remote_address), *Protocol_QUIC_PacketHeader_get(packet_header), nullptr), self(self), _dispatcher(dispatcher), _configuration(configuration), _tls_context(tls_context), _socket(socket), _remote_address(remote_address) {}
-	virtual ~RubyServer() {}
-	
-	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::Server::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::Server::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::Server::stream_reset(stream, final_size, error_code);
-		_ruby_streams.erase(stream_id);
-	}
-	
-	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, ruby_stream] : _ruby_streams) {
-			rb_gc_mark_movable(ruby_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, ruby_stream] : _ruby_streams) {
-			ruby_stream = rb_gc_location(ruby_stream);
-		}
-	}
-};
-
-static void Protocol_QUIC_Server_mark(void *data)
-{
-	if (data) {
-		reinterpret_cast<RubyServer *>(data)->mark();
-	}
-}
-
-static void Protocol_QUIC_Server_compact(void *data)
-{
-	if (data) {
-		reinterpret_cast<RubyServer *>(data)->compact();
-	}
-}
-
-static void Protocol_QUIC_Server_free(void *data)
-{
-	if (data) {
-		delete reinterpret_cast<Protocol::QUIC::Server *>(data);
-	}
-}
-
-static size_t Protocol_QUIC_Server_size(const void *data) {
-	return sizeof(RubyServer);
-}
-
-static const rb_data_type_t Protocol_QUIC_Server_type = {
-	.wrap_struct_name = "Protocol::QUIC::Server",
-	.function = {
-		.dmark = Protocol_QUIC_Server_mark,
-		.dfree = Protocol_QUIC_Server_free,
-		.dsize = Protocol_QUIC_Server_size,
-		.dcompact = Protocol_QUIC_Server_compact,
-	},
-	.parent = &Protocol_QUIC_Connection_type,
-	.data = NULL,
-	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-Protocol::QUIC::Server * Protocol_QUIC_Server_get(VALUE self)
-{
-	Protocol::QUIC::Server *server;
-
-	TypedData_Get_Struct(self, Protocol::QUIC::Server, &Protocol_QUIC_Server_type, server);
-
-	return server;
-}
-
-static VALUE Protocol_QUIC_Server_allocate(VALUE klass) {
-	return TypedData_Wrap_Struct(klass, &Protocol_QUIC_Server_type, NULL);
-}
-
-// Dispatcher & dispatcher, Configuration & configuration, TLS::ServerContext & tls_context, Socket & socket, const Address & remote_address, const ngtcp2_pkt_hd & packet_header, ngtcp2_cid *ocid = nullptr
-static VALUE Protocol_QUIC_Server_initialize(VALUE self, VALUE dispatcher, VALUE configuration, VALUE tls_context, VALUE socket, VALUE remote_address, VALUE packet_header, VALUE ocid) {
-	Protocol::QUIC::Server *server = new RubyServer(self, dispatcher, configuration, tls_context, socket, remote_address, packet_header, ocid);
-
-	DATA_PTR(self) = server;
-
-	return self;
-}
-
-static VALUE Protocol_QUIC_Server_send_packets(VALUE self) {
-	Protocol::QUIC::Server *server = Protocol_QUIC_Server_get(self);
-	
-	server->send_packets();
-	
-	return Qnil;
-}
-
-void Init_Protocol_QUIC_Server(VALUE Protocol_QUIC) {
-	Protocol_QUIC_Server =
-			rb_define_class_under(Protocol_QUIC, "Server", rb_cObject);
-
-	rb_define_alloc_func(Protocol_QUIC_Server, Protocol_QUIC_Server_allocate);
-	rb_define_method(Protocol_QUIC_Server, "initialize", Protocol_QUIC_Server_initialize, 7);
-	
-	rb_define_method(Protocol_QUIC_Server, "send_packets", Protocol_QUIC_Server_send_packets, 0);
-}

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

@@ -1,103 +0,0 @@
-//
-//  Socket.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 "Socket.hpp"
-#include "Address.hpp"
-
-VALUE Protocol_QUIC_Socket = Qnil;
-
-static void Protocol_QUIC_Socket_free(void *data) {
-	if (data) {
-		delete reinterpret_cast<Protocol::QUIC::Socket *>(data);
-	}
-}
-
-static size_t Protocol_QUIC_Socket_size(const void *data) {
-	return sizeof(Protocol::QUIC::Socket);
-}
-
-const rb_data_type_t Protocol_QUIC_Socket_type = {
-	.wrap_struct_name = "Protocol::QUIC::Socket",
-	.function = {
-		.dmark = NULL,
-		.dfree = Protocol_QUIC_Socket_free,
-		.dsize = Protocol_QUIC_Socket_size,
-	},
-	.data = NULL,
-	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-Protocol::QUIC::Socket * Protocol_QUIC_Socket_get(VALUE self)
-{
-	Protocol::QUIC::Socket *socket;
-	
-	TypedData_Get_Struct(self, Protocol::QUIC::Socket, &Protocol_QUIC_Socket_type, socket);
-	
-	return socket;
-}
-
-VALUE Protocol_QUIC_Socket_allocate(VALUE klass) {
-	return TypedData_Wrap_Struct(klass, &Protocol_QUIC_Socket_type, NULL);
-}
-
-static VALUE Protocol_QUIC_Socket_initialize(VALUE self, VALUE domain, VALUE type, VALUE protocol) {
-	DATA_PTR(self) = new Protocol::QUIC::Socket(RB_NUM2INT(domain), RB_NUM2INT(type), RB_NUM2INT(protocol));
-	
-	return self;
-}
-
-static VALUE Protocol_QUIC_Socket_local_address(VALUE self) {
-	auto socket = Protocol_QUIC_Socket_get(self);
-	auto &address = socket->local_address();
-	
-	if (address) {
-		return Protocol_QUIC_Address_wrap(Protocol_QUIC_Address, address);
-	} else {
-		return Qnil;
-	}
-}
-
-static VALUE Protocol_QUIC_Socket_remote_address(VALUE self) {
-	auto socket = Protocol_QUIC_Socket_get(self);
-	auto &address = socket->remote_address();
-	
-	if (address) {
-		return Protocol_QUIC_Address_wrap(Protocol_QUIC_Address, address);
-	} else {
-		return Qnil;
-	}
-}
-
-static VALUE Protocol_QUIC_Socket_bind(VALUE self, VALUE address) {
-	auto socket = Protocol_QUIC_Socket_get(self);
-	
-	return RTEST(
-		socket->bind(*Protocol_QUIC_Address_get(address))
-	);
-}
-
-static VALUE Protocol_QUIC_Socket_connect(VALUE self, VALUE address) {
-	auto socket = Protocol_QUIC_Socket_get(self);
-	
-	return RTEST(
-		socket->connect(*Protocol_QUIC_Address_get(address))
-	);
-}
-
-void Init_Protocol_QUIC_Socket(VALUE Protocol_QUIC) {
-	Protocol_QUIC_Socket = rb_define_class_under(Protocol_QUIC, "Socket", rb_cObject);
-	
-	rb_define_alloc_func(Protocol_QUIC_Socket, Protocol_QUIC_Socket_allocate);
-	rb_define_method(Protocol_QUIC_Socket, "initialize", Protocol_QUIC_Socket_initialize, 3);
-	
-	rb_define_method(Protocol_QUIC_Socket, "local_address", Protocol_QUIC_Socket_local_address, 0);
-	rb_define_method(Protocol_QUIC_Socket, "remote_address", Protocol_QUIC_Socket_remote_address, 0);
-	
-	rb_define_method(Protocol_QUIC_Socket, "bind", Protocol_QUIC_Socket_bind, 1);
-	rb_define_method(Protocol_QUIC_Socket, "connect", Protocol_QUIC_Socket_connect, 1);
-}

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

@@ -1,96 +0,0 @@
-//
-//  Stream.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 "Stream.hpp"
-#include "Connection.hpp"
-#include <Protocol/QUIC/BufferedStream.hpp>
-
-VALUE Protocol_QUIC_Stream = Qnil;
-
-class RubyStream : public Protocol::QUIC::BufferedStream {
-public:
-	VALUE self;
-	
-private:
-	VALUE _connection;
-public:
-	RubyStream(VALUE self, VALUE connection, VALUE stream_id) : Protocol::QUIC::BufferedStream(*Protocol_QUIC_Connection_get(connection), RB_NUM2LL(stream_id)), self(self), _connection(connection) {}
-	
-	virtual ~RubyStream() {}
-	
-	void mark() {
-		rb_gc_mark_movable(self);
-		rb_gc_mark_movable(_connection);
-	}
-	
-	void compact() {
-		self = rb_gc_location(self);
-		_connection = rb_gc_location(_connection);
-	}
-};
-
-static void Protocol_QUIC_Stream_mark(void *data) {
-	if (data) {
-		reinterpret_cast<RubyStream *>(data)->mark();
-	}
-}
-
-static void Protocol_QUIC_Stream_compact(void *data) {
-	if (data) {
-		reinterpret_cast<RubyStream *>(data)->compact();
-	}
-}
-
-static void Protocol_QUIC_Stream_free(void *data) {
-	if (data) {
-		delete reinterpret_cast<RubyStream *>(data);
-	}
-}
-
-static size_t Protocol_QUIC_Stream_size(const void *data) {
-	return sizeof(RubyStream);
-}
-
-const rb_data_type_t Protocol_QUIC_Stream_type = {
-	.wrap_struct_name = "Protocol::QUIC::Stream",
-	.function = {
-		.dmark = Protocol_QUIC_Stream_mark,
-		.dfree = Protocol_QUIC_Stream_free,
-		.dsize = Protocol_QUIC_Stream_size,
-		.dcompact = Protocol_QUIC_Stream_compact,
-	},
-	.data = NULL,
-	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-Protocol::QUIC::Stream * Protocol_QUIC_Stream_get(VALUE self)
-{
-	Protocol::QUIC::Stream *address;
-	
-	TypedData_Get_Struct(self, Protocol::QUIC::Stream, &Protocol_QUIC_Stream_type, address);
-	
-	return address;
-}
-
-VALUE Protocol_QUIC_Stream_allocate(VALUE klass) {
-	return TypedData_Wrap_Struct(klass, &Protocol_QUIC_Stream_type, NULL);
-}
-
-static VALUE Protocol_QUIC_Stream_initialize(VALUE self, VALUE connection, VALUE stream_id) {
-	DATA_PTR(self) = new RubyStream(self, connection, stream_id);
-	
-	return self;
-}
-
-void Init_Protocol_QUIC_Stream(VALUE Protocol_QUIC) {
-	Protocol_QUIC_Stream =
-			rb_define_class_under(Protocol_QUIC, "Stream", rb_cObject);
-
-	rb_define_alloc_func(Protocol_QUIC_Stream, Protocol_QUIC_Stream_allocate);
-	rb_define_method(Protocol_QUIC_Stream, "initialize", Protocol_QUIC_Stream_initialize, 2);
-}

data/ext/source/Protocol/QUIC/TLS/ClientContext.cpp

@@ -1,61 +0,0 @@
-//
-//  ClientContext.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 "ClientContext.hpp"
-#include "Context.hpp"
-
-VALUE Protocol_QUIC_TLS_ClientContext = Qnil;
-
-static void Protocol_QUIC_TLS_ClientContext_free(void *data) {
-	if (data) {
-		delete reinterpret_cast<Protocol::QUIC::TLS::ClientContext *>(data);
-	}
-}
-
-static size_t Protocol_QUIC_TLS_ClientContext_size(const void *data) {
-	return sizeof(Protocol::QUIC::TLS::ClientContext);
-}
-
-static const rb_data_type_t Protocol_QUIC_TLS_ClientContext_type = {
-	.wrap_struct_name = "Protocol::QUIC::TLS::ClientContext",
-	.function = {
-		.dmark = NULL,
-		.dfree = Protocol_QUIC_TLS_ClientContext_free,
-		.dsize = Protocol_QUIC_TLS_ClientContext_size,
-	},
-	.parent = &Protocol_QUIC_TLS_Context_type,
-	.data = NULL,
-	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-Protocol::QUIC::TLS::ClientContext * Protocol_QUIC_TLS_ClientContext_get(VALUE self)
-{
-	Protocol::QUIC::TLS::ClientContext *data;
-
-	TypedData_Get_Struct(self, Protocol::QUIC::TLS::ClientContext, &Protocol_QUIC_TLS_ClientContext_type, data);
-
-	return data;
-}
-
-static VALUE Protocol_QUIC_TLS_ClientContext_allocate(VALUE klass) {
-	return TypedData_Wrap_Struct(klass, &Protocol_QUIC_TLS_ClientContext_type, NULL);
-}
-
-static VALUE Protocol_QUIC_TLS_ClientContext_initialize(VALUE self) {
-	DATA_PTR(self) = new Protocol::QUIC::TLS::ClientContext();
-
-	return self;
-}
-
-void Init_Protocol_QUIC_TLS_ClientContext(VALUE Protocol_QUIC_TLS) {
-	Protocol_QUIC_TLS_ClientContext =
-			rb_define_class_under(Protocol_QUIC_TLS, "ClientContext", Protocol_QUIC_TLS_Context);
-
-	rb_define_alloc_func(Protocol_QUIC_TLS_ClientContext, Protocol_QUIC_TLS_ClientContext_allocate);
-	rb_define_method(Protocol_QUIC_TLS_ClientContext, "initialize", Protocol_QUIC_TLS_ClientContext_initialize, 0);
-}

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

@@ -1,116 +0,0 @@
-//
-//  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 Protocol_QUIC_TLS_Context = Qnil;
-
-static void Protocol_QUIC_TLS_Context_free(void *data) {
-	if (data) {
-		delete reinterpret_cast<Protocol::QUIC::TLS::Context *>(data);
-	}
-}
-
-static size_t Protocol_QUIC_TLS_Context_size(const void *data) {
-	return sizeof(Protocol::QUIC::TLS::Context);
-}
-
-const rb_data_type_t Protocol_QUIC_TLS_Context_type = {
-	.wrap_struct_name = "Protocol::QUIC::TLS::Context",
-	.function = {
-		.dmark = NULL,
-		.dfree = Protocol_QUIC_TLS_Context_free,
-		.dsize = Protocol_QUIC_TLS_Context_size,
-	},
-	.data = NULL,
-	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-Protocol::QUIC::TLS::Context * Protocol_QUIC_TLS_Context_get(VALUE self)
-{
-	Protocol::QUIC::TLS::Context *tls_context;
-
-	TypedData_Get_Struct(self, Protocol::QUIC::TLS::Context, &Protocol_QUIC_TLS_Context_type, tls_context);
-
-	return tls_context;
-}
-
-static VALUE Protocol_QUIC_TLS_Context_allocate(VALUE klass) {
-	return TypedData_Wrap_Struct(klass, &Protocol_QUIC_TLS_Context_type, NULL);
-}
-
-static VALUE Protocol_QUIC_TLS_Context_initialize(VALUE self) {
-	DATA_PTR(self) = new Protocol::QUIC::TLS::Context();
-
-	return self;
-}
-
-static VALUE 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, &Protocol_QUIC_TLS_Context_type, tls_context);
-	
-	tls_context->add_protocol(
-		std::string(RSTRING_PTR(name), RSTRING_LEN(name))
-	);
-	
-	return self;
-}
-
-static VALUE Protocol_QUIC_TLS_Context_load_certificate_file(VALUE self, VALUE path) {
-	StringValue(path);
-	
-	auto tls_context = Protocol_QUIC_TLS_Context_get(self);
-	tls_context->load_certificate_file(RSTRING_PTR(path));
-	
-	return self;
-}
-
-static VALUE Protocol_QUIC_TLS_Context_load_private_key_file(VALUE self, VALUE path) {
-	StringValue(path);
-	
-	auto tls_context = Protocol_QUIC_TLS_Context_get(self);
-	tls_context->load_private_key_file(RSTRING_PTR(path));
-	
-	return self;
-}
-
-static VALUE Protocol_QUIC_TLS_Context_protocols(VALUE self) {
-	Protocol::QUIC::TLS::Context *tls_context;
-	TypedData_Get_Struct(self, Protocol::QUIC::TLS::Context, &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_Protocol_QUIC_TLS_Context(VALUE Protocol_QUIC) {
-	VALUE Protocol_QUIC_TLS = rb_define_module_under(Protocol_QUIC, "TLS");
-	
-	Protocol_QUIC_TLS_Context =
-			rb_define_class_under(Protocol_QUIC_TLS, "Context", rb_cObject);
-
-	rb_define_alloc_func(Protocol_QUIC_TLS_Context, Protocol_QUIC_TLS_Context_allocate);
-	rb_define_method(Protocol_QUIC_TLS_Context, "initialize", Protocol_QUIC_TLS_Context_initialize, 0);
-	
-	rb_define_method(Protocol_QUIC_TLS_Context, "add_protocol", Protocol_QUIC_TLS_Context_add_protocol, 1);
-	rb_define_method(Protocol_QUIC_TLS_Context, "load_certificate_file", Protocol_QUIC_TLS_Context_load_certificate_file, 1);
-	rb_define_method(Protocol_QUIC_TLS_Context, "load_private_key_file", Protocol_QUIC_TLS_Context_load_private_key_file, 1);
-	rb_define_method(Protocol_QUIC_TLS_Context, "protocols", Protocol_QUIC_TLS_Context_protocols, 0);
-	
-	Init_Protocol_QUIC_TLS_ClientContext(Protocol_QUIC_TLS);
-	Init_Protocol_QUIC_TLS_ServerContext(Protocol_QUIC_TLS);
-}

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

@@ -1,61 +0,0 @@
-//
-//  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 Protocol_QUIC_TLS_ServerContext = Qnil;
-
-static void Protocol_QUIC_TLS_ServerContext_free(void *data) {
-	if (data) {
-		delete reinterpret_cast<Protocol::QUIC::TLS::ServerContext *>(data);
-	}
-}
-
-static size_t Protocol_QUIC_TLS_ServerContext_size(const void *data) {
-	return sizeof(Protocol::QUIC::TLS::ServerContext);
-}
-
-static const rb_data_type_t Protocol_QUIC_TLS_ServerContext_type = {
-	.wrap_struct_name = "Protocol::QUIC::TLS::ServerContext",
-	.function = {
-		.dmark = NULL,
-		.dfree = Protocol_QUIC_TLS_ServerContext_free,
-		.dsize = Protocol_QUIC_TLS_ServerContext_size,
-	},
-	.parent = &Protocol_QUIC_TLS_Context_type,
-	.data = NULL,
-	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-Protocol::QUIC::TLS::ServerContext * Protocol_QUIC_TLS_ServerContext_get(VALUE self)
-{
-	Protocol::QUIC::TLS::ServerContext *data;
-
-	TypedData_Get_Struct(self, Protocol::QUIC::TLS::ServerContext, &Protocol_QUIC_TLS_ServerContext_type, data);
-
-	return data;
-}
-
-static VALUE Protocol_QUIC_TLS_ServerContext_allocate(VALUE klass) {
-	return TypedData_Wrap_Struct(klass, &Protocol_QUIC_TLS_ServerContext_type, NULL);
-}
-
-static VALUE Protocol_QUIC_TLS_ServerContext_initialize(VALUE self) {
-	DATA_PTR(self) = new Protocol::QUIC::TLS::ServerContext();
-
-	return self;
-}
-
-void Init_Protocol_QUIC_TLS_ServerContext(VALUE Protocol_QUIC_TLS) {
-	Protocol_QUIC_TLS_ServerContext =
-			rb_define_class_under(Protocol_QUIC_TLS, "ServerContext", Protocol_QUIC_TLS_Context);
-
-	rb_define_alloc_func(Protocol_QUIC_TLS_ServerContext, Protocol_QUIC_TLS_ServerContext_allocate);
-	rb_define_method(Protocol_QUIC_TLS_ServerContext, "initialize", Protocol_QUIC_TLS_ServerContext_initialize, 0);
-}

data/ext/source/Protocol/QUIC.cpp

@@ -1,36 +0,0 @@
-#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_Protocol_QUIC(void)
-{
-	VALUE Protocol = rb_define_module("Protocol");
-	Protocol_QUIC = rb_define_module_under(Protocol, "QUIC");
-	
-	Init_Protocol_QUIC_TLS_Context(Protocol_QUIC);
-	
-	Init_Protocol_QUIC_Address(Protocol_QUIC);
-	Init_Protocol_QUIC_Dispatcher(Protocol_QUIC);
-	Init_Protocol_QUIC_Configuration(Protocol_QUIC);
-	Init_Protocol_QUIC_PacketHeader(Protocol_QUIC);
-	Init_Protocol_QUIC_Socket(Protocol_QUIC);
-	
-	Init_Protocol_QUIC_Connection(Protocol_QUIC);
-	Init_Protocol_QUIC_Server(Protocol_QUIC);
-	Init_Protocol_QUIC_Client(Protocol_QUIC);
-	
-	Init_Protocol_QUIC_Stream(Protocol_QUIC);
-}