protocol-quic 0.0.2 → 0.0.3

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

@@ -0,0 +1,190 @@
+
+#include "Dispatcher.hpp"
+
+#include "Socket.hpp"
+#include "Address.hpp"
+#include "PacketHeader.hpp"
+
+#include "Configuration.hpp"
+#include "TLS/ServerContext.hpp"
+
+#include "Server.hpp"
+
+#include "Reference.hpp"
+
+#include <unordered_map>
+
+class RubyDispatcher final : public Protocol::QUIC::Dispatcher {
+public:
+	VALUE self;
+	
+private:
+	VALUE _ruby_configuration;
+	VALUE _ruby_tls_context;
+	std::unordered_map<Protocol::QUIC::Server *, VALUE> _ruby_servers;
+	std::unordered_map<Protocol::QUIC::Socket *, VALUE> _ruby_sockets;
+	
+public:
+	RubyDispatcher(VALUE self, VALUE configuration, VALUE tls_context) : Protocol::QUIC::Dispatcher(*Protocol_QUIC_Configuration_get(configuration), *Protocol_QUIC_TLS_ServerContext_get(tls_context)), self(self), _ruby_configuration(configuration), _ruby_tls_context(tls_context)
+	{
+	}
+	
+	~RubyDispatcher() {
+	}
+	
+	VALUE ruby_configuration() noexcept {return _ruby_configuration;}
+	VALUE ruby_tls_context() noexcept {return _ruby_tls_context;}
+	
+	Protocol::QUIC::Server * listen(VALUE ruby_socket)
+	{
+		auto socket = Protocol_QUIC_Socket_get(ruby_socket);
+		
+		_ruby_sockets[socket] = ruby_socket;
+		
+		return Protocol::QUIC::Dispatcher::listen(*socket);
+	}
+	
+	Protocol::QUIC::Server * create_server(Protocol::QUIC::Socket &socket, const Protocol::QUIC::Address &address, const ngtcp2_pkt_hd &packet_header) override
+	{
+		auto iterator = _ruby_sockets.find(&socket);
+		
+		if (iterator == _ruby_sockets.end()) {
+			rb_raise(rb_eRuntimeError, "Could not find Ruby socket wrapper for native socket.");
+		}
+		
+		VALUE ruby_socket = iterator->second;
+		VALUE ruby_address = Protocol_QUIC_Address_wrap(Protocol_QUIC_Address, address);
+		
+		VALUE ruby_packet_header = Protocol_QUIC_PacketHeader_allocate(Protocol_QUIC_PacketHeader);
+		ValueReference ruby_packet_header_reference(ruby_packet_header, packet_header);
+		
+		VALUE server = rb_funcall(self, rb_intern("create_server"), 3, ruby_socket, ruby_address, ruby_packet_header);
+		auto native_server = Protocol_QUIC_Server_get(server);
+		
+		_ruby_servers[native_server] = server;
+		
+		return native_server;
+	}
+	
+	void remove(Protocol::QUIC::Server * server) override
+	{
+		Protocol::QUIC::Dispatcher::remove(server);
+		_ruby_servers.erase(server);
+	}
+	
+	void mark() {
+		rb_gc_mark_movable(self);
+		rb_gc_mark_movable(_ruby_configuration);
+		rb_gc_mark_movable(_ruby_tls_context);
+		
+		for (auto & [server, ruby_server] : _ruby_servers) {
+			rb_gc_mark_movable(ruby_server);
+		}
+		
+		for (auto & [socket, ruby_socket] : _ruby_sockets) {
+			rb_gc_mark_movable(ruby_socket);
+		}
+	}
+	
+	void compact() {
+		self = rb_gc_location(self);
+		_ruby_configuration = rb_gc_location(_ruby_configuration);
+		_ruby_tls_context = rb_gc_location(_ruby_tls_context);
+		
+		for (auto & [server, ruby_server] : _ruby_servers) {
+			ruby_server = rb_gc_location(ruby_server);
+		}
+		
+		for (auto & [socket, ruby_socket] : _ruby_sockets) {
+			ruby_socket = rb_gc_location(ruby_socket);
+		}
+	}
+};
+
+VALUE Protocol_QUIC_Dispatcher = Qnil;
+
+static void Protocol_QUIC_Dispatcher_mark(void *data) {
+	if (data) {
+		reinterpret_cast<RubyDispatcher *>(data)->mark();
+	}
+}
+
+static void Protocol_QUIC_Dispatcher_compact(void *data) {
+	if (data) {
+		reinterpret_cast<RubyDispatcher *>(data)->compact();
+	}
+}
+
+static void Protocol_QUIC_Dispatcher_free(void *data) {
+	if (data) {
+		delete reinterpret_cast<Protocol::QUIC::Dispatcher *>(data);
+	}
+}
+
+static size_t Protocol_QUIC_Dispatcher_size(const void *data) {
+	return sizeof(RubyDispatcher);
+}
+
+static const rb_data_type_t Protocol_QUIC_Dispatcher_type = {
+	.wrap_struct_name = "Protocol::QUIC::Dispatcher",
+	.function = {
+		.dmark = Protocol_QUIC_Dispatcher_mark,
+		.dfree = Protocol_QUIC_Dispatcher_free,
+		.dsize = Protocol_QUIC_Dispatcher_size,
+		.dcompact = Protocol_QUIC_Dispatcher_compact,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+Protocol::QUIC::Dispatcher * Protocol_QUIC_Dispatcher_get(VALUE self)
+{
+	Protocol::QUIC::Dispatcher *dispatcher;
+
+	TypedData_Get_Struct(self, Protocol::QUIC::Dispatcher, &Protocol_QUIC_Dispatcher_type, dispatcher);
+
+	return dispatcher;
+}
+
+static VALUE Protocol_QUIC_Dispatcher_allocate(VALUE klass) {
+	return TypedData_Wrap_Struct(klass, &Protocol_QUIC_Dispatcher_type, NULL);
+}
+
+static VALUE Protocol_QUIC_Dispatcher_initialize(VALUE self, VALUE configuration, VALUE tls_context) {
+	auto dispatcher = new RubyDispatcher(self, configuration, tls_context);
+	DATA_PTR(self) = dispatcher;
+	return self;
+}
+
+static VALUE Protocol_QUIC_Dispatcher_configuration(VALUE self) {
+	auto dispatcher = dynamic_cast<RubyDispatcher*>(Protocol_QUIC_Dispatcher_get(self));
+	
+	return dispatcher->ruby_configuration();
+}
+
+static VALUE Protocol_QUIC_Dispatcher_tls_context(VALUE self) {
+	auto dispatcher = dynamic_cast<RubyDispatcher*>(Protocol_QUIC_Dispatcher_get(self));
+	
+	return dispatcher->ruby_tls_context();
+}
+
+static VALUE Protocol_QUIC_Dispatcher_listen(VALUE self, VALUE socket) {
+	auto dispatcher = dynamic_cast<RubyDispatcher*>(Protocol_QUIC_Dispatcher_get(self));
+	
+	dispatcher->listen(socket);
+	
+	return Qnil;
+}
+
+void Init_Protocol_QUIC_Dispatcher(VALUE Protocol_QUIC) {
+	Protocol_QUIC_Dispatcher =
+			rb_define_class_under(Protocol_QUIC, "Dispatcher", rb_cObject);
+
+	rb_define_alloc_func(Protocol_QUIC_Dispatcher, Protocol_QUIC_Dispatcher_allocate);
+	rb_define_method(Protocol_QUIC_Dispatcher, "initialize", Protocol_QUIC_Dispatcher_initialize, 2);
+	
+	rb_define_method(Protocol_QUIC_Dispatcher, "configuration", Protocol_QUIC_Dispatcher_configuration, 0);
+	rb_define_method(Protocol_QUIC_Dispatcher, "tls_context", Protocol_QUIC_Dispatcher_tls_context, 0);
+	
+	rb_define_method(Protocol_QUIC_Dispatcher, "listen", Protocol_QUIC_Dispatcher_listen, 1);
+}

data/ext/source/Protocol/QUIC/Dispatcher.hpp

@@ -0,0 +1,27 @@
+//
+//  Dispatcher.h
+//  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.
+//
+
+#pragma once
+
+#include <ruby.h>
+
+#include <Protocol/QUIC/Dispatcher.hpp>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern VALUE Protocol_QUIC_Dispatcher;
+
+void Init_Protocol_QUIC_Dispatcher(VALUE Protocol_QUIC);
+
+Protocol::QUIC::Dispatcher * Protocol_QUIC_Dispatcher_get(VALUE self);
+
+#ifdef __cplusplus
+}
+#endif

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

@@ -0,0 +1,59 @@
+//
+//  PacketHeader.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 "PacketHeader.hpp"
+
+VALUE Protocol_QUIC_PacketHeader = Qnil;
+
+static void Protocol_QUIC_PacketHeader_free(void *data) {
+	if (data) {
+		delete reinterpret_cast<ngtcp2_pkt_hd *>(data);
+	}
+}
+
+static size_t Protocol_QUIC_PacketHeader_size(const void *data) {
+	return sizeof(ngtcp2_pkt_hd);
+}
+
+const rb_data_type_t Protocol_QUIC_PacketHeader_type = {
+	.wrap_struct_name = "Protocol::QUIC::PacketHeader",
+	.function = {
+		.dmark = NULL,
+		.dfree = Protocol_QUIC_PacketHeader_free,
+		.dsize = Protocol_QUIC_PacketHeader_size,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+ngtcp2_pkt_hd * Protocol_QUIC_PacketHeader_get(VALUE self)
+{
+	ngtcp2_pkt_hd *address;
+	
+	TypedData_Get_Struct(self, ngtcp2_pkt_hd, &Protocol_QUIC_PacketHeader_type, address);
+	
+	return address;
+}
+
+VALUE Protocol_QUIC_PacketHeader_allocate(VALUE klass) {
+	return TypedData_Wrap_Struct(klass, &Protocol_QUIC_PacketHeader_type, NULL);
+}
+
+static VALUE Protocol_QUIC_PacketHeader_initialize(VALUE self) {
+	DATA_PTR(self) = new ngtcp2_pkt_hd();
+	
+	return self;
+}
+
+void Init_Protocol_QUIC_PacketHeader(VALUE Protocol_QUIC) {
+	Protocol_QUIC_PacketHeader =
+			rb_define_class_under(Protocol_QUIC, "PacketHeader", rb_cObject);
+
+	rb_define_alloc_func(Protocol_QUIC_PacketHeader, Protocol_QUIC_PacketHeader_allocate);
+	rb_define_method(Protocol_QUIC_PacketHeader, "initialize", Protocol_QUIC_PacketHeader_initialize, 0);
+}

data/ext/source/Protocol/QUIC/PacketHeader.hpp

@@ -0,0 +1,29 @@
+//
+//  PacketHeader.hpp
+//  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.
+//
+
+#pragma once
+
+#include <ruby.h>
+
+#include <ngtcp2/ngtcp2.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern VALUE Protocol_QUIC_PacketHeader;
+
+void Init_Protocol_QUIC_PacketHeader(VALUE Protocol_QUIC);
+
+ngtcp2_pkt_hd * Protocol_QUIC_PacketHeader_get(VALUE self);
+
+VALUE Protocol_QUIC_PacketHeader_allocate(VALUE klass);
+
+#ifdef __cplusplus
+}
+#endif

data/ext/source/Protocol/QUIC/Reference.hpp

@@ -0,0 +1,31 @@
+//
+//  Reference.hpp
+//  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.
+//
+
+#pragma once
+
+#include <ruby.h>
+
+struct ValueReference {
+	VALUE _value;
+	
+	template <typename ReferenceType>
+	ValueReference(VALUE value, ReferenceType & reference) : _value(value)
+	{
+		DATA_PTR(value) = reinterpret_cast<void*>(&reference);
+	}
+	
+		template <typename ReferenceType>
+	ValueReference(VALUE value, const ReferenceType & reference) : ValueReference(value, const_cast<ReferenceType&>(reference))
+	{
+	}
+	
+	~ValueReference()
+	{
+		DATA_PTR(_value) = NULL;
+	}
+};

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

@@ -0,0 +1,165 @@
+
+#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/Server.hpp

@@ -0,0 +1,27 @@
+//
+//  Server.h
+//  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.
+//
+
+#pragma once
+
+#include <ruby.h>
+
+#include <Protocol/QUIC/Server.hpp>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern VALUE Protocol_QUIC_Server;
+
+void Init_Protocol_QUIC_Server(VALUE Protocol_QUIC);
+
+Protocol::QUIC::Server * Protocol_QUIC_Server_get(VALUE self);
+
+#ifdef __cplusplus
+}
+#endif

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

@@ -0,0 +1,103 @@
+//
+//  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/Socket.hpp

@@ -0,0 +1,29 @@
+//
+//  Socket.hpp
+//  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.
+//
+
+#pragma once
+
+#include <ruby.h>
+
+#include <Protocol/QUIC/Socket.hpp>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern VALUE Protocol_QUIC_Socket;
+
+void Init_Protocol_QUIC_Socket(VALUE Protocol_QUIC);
+
+Protocol::QUIC::Socket * Protocol_QUIC_Socket_get(VALUE self);
+
+VALUE Protocol_QUIC_Socket_allocate(VALUE klass);
+
+#ifdef __cplusplus
+}
+#endif