protocol-quic 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b501288cde394d030bb3d0ae6e035ee4feae69424eaec58e5dd3e94f1c85bb9
-  data.tar.gz: 1be70108b32ee82f49f5c14e04f7db4e2205bfb2ba9344501663cf69a37f5824
+  metadata.gz: cebc4e910242d2f8a4b5eda4d7b44fcbbe3c6ae3220003d8d5886d3fce785a5c
+  data.tar.gz: a3ae388d1abd5bf2736fe9bd0ace296ce30ca984b2097c535d78bc2fb8417b86
 SHA512:
-  metadata.gz: 5db41a0051307b315912faf24e7a171ff8b4dee2a54181d95e35304e8d5441a63712284a847c4a89e22fb0daecc66543860e79128f2a3230bb3acf24b25cbe80
-  data.tar.gz: 989f6ecb3e69779a9d2d88c1b3b2aab2eab212380e8094637cdba58d7b2e92c4e1cc16413ed07c6d09ee646b5b4fad4bda6a2403cf104c31600b9bbab464e6ac
+  metadata.gz: 15f4ba97d0b2df5a56502f20300f6149f879be26b743eba97b7b3d8fd709cacba7d30b1a032bd312722c64614db156853bedd7e0dc13e9113c870ed8d719275c
+  data.tar.gz: 4c64b7549057a6bd15eb383c1ba2efbf391701aa22f35ed62c412ad630b9642b570b4b31e552daa7606b9bd5e592f090e8e17fc2d538630214e3ca67c74c0a40

checksums.yaml.gz.sig

@@ -1,2 +1,4 @@
-f'�1��m�&��H�e�>�v�U�^��<��'7��+� �%Xr^N��C�2���l�
-���L�C�
+vP��
+��/���f��(��r�J��|�cL��u'W
+W������U�z������(���B��H=b�ѕ�	E��	L�������X��kx�ǂmE��
+d��Z�>u����N��B�g�S�\m��;�=�E��w�>
�������j��Ǥ����Ε${Fh�p?KSE�0pQ;��g���$������;�	��J.Ime; Q v�C��*���R���_��EI��-V:�7<mU�Hp9}L��

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

@@ -9,10 +9,10 @@ build-cmake:
   :commit: 6558fdad5bbb475f0fa5584ff773de8f12ff232e
   :branch: master
 scheduler-ruby:
-  :commit: 8e4e36bfd47485e8379b3d9c0e4258dec63b7320
+  :commit: 94e524e64912081aaa5a8cb54bad7ad73f01a51a
   :branch: main
 protocol-quic:
-  :commit: 9900a7fe0407a2a4ae0a8e0508d6ad8d52f66c27
+  :commit: 1328f66a91ba7b3e544304dde8ba7bc93d3462ec
   :branch: main
 ruby:
   :commit: 685cdd5a421dae7749f368d08add9aa9709ad043

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

@@ -0,0 +1,122 @@
+//
+//  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 Ruby_Protocol_QUIC_Address = Qnil;
+
+static void Ruby_Protocol_QUIC_Address_free(void *data) {
+	if (data) {
+		delete reinterpret_cast<::Protocol::QUIC::Address *>(data);
+	}
+}
+
+static size_t Ruby_Protocol_QUIC_Address_size(const void *data) {
+	return sizeof(::Protocol::QUIC::Address);
+}
+
+const rb_data_type_t Ruby_Protocol_QUIC_Address_type = {
+	.wrap_struct_name = "Protocol::QUIC::Address",
+	.function = {
+		.dmark = NULL,
+		.dfree = Ruby_Protocol_QUIC_Address_free,
+		.dsize = Ruby_Protocol_QUIC_Address_size,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+::Protocol::QUIC::Address * Ruby_Protocol_QUIC_Address_get(VALUE self)
+{
+	::Protocol::QUIC::Address *address;
+	
+	TypedData_Get_Struct(self, ::Protocol::QUIC::Address, &Ruby_Protocol_QUIC_Address_type, address);
+	
+	return address;
+}
+
+VALUE Ruby_Protocol_QUIC_Address_allocate(VALUE klass) {
+	return TypedData_Wrap_Struct(klass, &Ruby_Protocol_QUIC_Address_type, NULL);
+}
+
+static VALUE Ruby_Protocol_QUIC_Address_initialize(VALUE self) {
+	DATA_PTR(self) = new ::Protocol::QUIC::Address();
+	
+	return self;
+}
+
+static VALUE Ruby_Protocol_QUIC_Address_inspect(VALUE self) {
+	auto address = Ruby_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  Ruby_Protocol_QUIC_Address_family(VALUE self) {
+	::Protocol::QUIC::Address *address = Ruby_Protocol_QUIC_Address_get(self);
+	
+	return RB_INT2NUM(address->family());
+}
+
+static VALUE Ruby_Protocol_QUIC_Address_data(VALUE self) {
+	::Protocol::QUIC::Address *address = Ruby_Protocol_QUIC_Address_get(self);
+	
+	return rb_str_new((const char *)&address->data.sa, address->length);
+}
+
+VALUE Ruby_Protocol_QUIC_Address_wrap(VALUE klass, const ::Protocol::QUIC::Address & address)
+{
+	VALUE self = Ruby_Protocol_QUIC_Address_allocate(klass);
+	Ruby_Protocol_QUIC_Address_initialize(self);
+	
+	::Protocol::QUIC::Address *data = Ruby_Protocol_QUIC_Address_get(self);
+	
+	*data = address;
+	
+	return self;
+}
+
+VALUE Ruby_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, Ruby_Protocol_QUIC_Address_wrap(klass, address));
+	}
+	
+	return result;
+}
+
+void Init_Ruby_Protocol_QUIC_Address(VALUE Protocol_QUIC) {
+	Ruby_Protocol_QUIC_Address =
+			rb_define_class_under(Protocol_QUIC, "Address", rb_cObject);
+	
+	rb_define_singleton_method(Ruby_Protocol_QUIC_Address, "resolve", Ruby_Protocol_QUIC_Address_s_resolve, 5);
+	
+	rb_define_alloc_func(Ruby_Protocol_QUIC_Address, Ruby_Protocol_QUIC_Address_allocate);
+	rb_define_method(Ruby_Protocol_QUIC_Address, "initialize", Ruby_Protocol_QUIC_Address_initialize, 0);
+	rb_define_method(Ruby_Protocol_QUIC_Address, "inspect", Ruby_Protocol_QUIC_Address_inspect, 0);
+	
+	rb_define_method(Ruby_Protocol_QUIC_Address, "family", Ruby_Protocol_QUIC_Address_family, 0);
+	rb_define_method(Ruby_Protocol_QUIC_Address, "data", Ruby_Protocol_QUIC_Address_data, 0);
+}

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

@@ -16,14 +16,14 @@
 extern "C" {
 #endif
 
-extern VALUE Protocol_QUIC_Address;
+extern VALUE Ruby_Protocol_QUIC_Address;
 
-void Init_Protocol_QUIC_Address(VALUE Protocol_QUIC);
+void Init_Ruby_Protocol_QUIC_Address(VALUE Protocol_QUIC);
 
-Protocol::QUIC::Address * Protocol_QUIC_Address_get(VALUE self);
+::Protocol::QUIC::Address * Ruby_Protocol_QUIC_Address_get(VALUE self);
 
-VALUE Protocol_QUIC_Address_allocate(VALUE klass);
-VALUE Protocol_QUIC_Address_wrap(VALUE klass, const Protocol::QUIC::Address & address);
+VALUE Ruby_Protocol_QUIC_Address_allocate(VALUE klass);
+VALUE Ruby_Protocol_QUIC_Address_wrap(VALUE klass, const ::Protocol::QUIC::Address & address);
 
 #ifdef __cplusplus
 }

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

@@ -0,0 +1,161 @@
+
+#include "Client.hpp"
+
+#include "Configuration.hpp"
+#include "TLS/ClientContext.hpp"
+#include "Socket.hpp"
+#include "Address.hpp"
+#include "Stream.hpp"
+
+#include <unordered_map>
+
+VALUE Ruby_Protocol_QUIC_Client = Qnil;
+
+namespace Ruby::Protocol::QUIC {
+
+	class Client : 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:
+		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)), self(self), _configuration(configuration), _tls_context(tls_context), _socket(socket), _remote_address(remote_address) {}
+		virtual ~Client() {}
+	
+		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 Ruby_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 Ruby_Protocol_QUIC_Client_mark(void *data)
+{
+	if (data) {
+		reinterpret_cast<Ruby::Protocol::QUIC::Client *>(data)->mark();
+	}
+}
+
+static void Ruby_Protocol_QUIC_Client_compact(void *data)
+{
+	if (data) {
+		reinterpret_cast<Ruby::Protocol::QUIC::Client *>(data)->compact();
+	}
+}
+
+static void Ruby_Protocol_QUIC_Client_free(void *data)
+{
+	if (data) {
+		delete reinterpret_cast<::Protocol::QUIC::Client *>(data);
+	}
+}
+
+static size_t Ruby_Protocol_QUIC_Client_size(const void *data) {
+	return sizeof(Ruby::Protocol::QUIC::Client);
+}
+
+static const rb_data_type_t Ruby_Protocol_QUIC_Client_type = {
+	.wrap_struct_name = "Protocol::QUIC::Client",
+	.function = {
+		.dmark = Ruby_Protocol_QUIC_Client_mark,
+		.dfree = Ruby_Protocol_QUIC_Client_free,
+		.dsize = Ruby_Protocol_QUIC_Client_size,
+		.dcompact = Ruby_Protocol_QUIC_Client_compact,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+::Protocol::QUIC::Client * Ruby_Protocol_QUIC_Client_get(VALUE self)
+{
+	::Protocol::QUIC::Client *configuration;
+	TypedData_Get_Struct(self, ::Protocol::QUIC::Client, &Ruby_Protocol_QUIC_Client_type, configuration);
+	return configuration;
+}
+
+static VALUE Ruby_Protocol_QUIC_Client_allocate(VALUE klass) {
+	return TypedData_Wrap_Struct(klass, &Ruby_Protocol_QUIC_Client_type, NULL);
+}
+
+static VALUE Ruby_Protocol_QUIC_Client_initialize(VALUE self, VALUE configuration, VALUE tls_context, VALUE socket, VALUE remote_address, VALUE chosen_version) {
+	::Protocol::QUIC::Client *client = new Ruby::Protocol::QUIC::Client(self, configuration, tls_context, socket, remote_address, chosen_version);
+	DATA_PTR(self) = client;
+	return self;
+}
+
+static VALUE Ruby_Protocol_QUIC_Client_connect(VALUE self) {
+	::Protocol::QUIC::Client *client = Ruby_Protocol_QUIC_Client_get(self);
+	
+	client->connect();
+	
+	return Qnil;
+}
+
+void Init_Ruby_Protocol_QUIC_Client(VALUE Protocol_QUIC) {
+	Ruby_Protocol_QUIC_Client =
+			rb_define_class_under(Protocol_QUIC, "Client", rb_cObject);
+
+	rb_define_alloc_func(Ruby_Protocol_QUIC_Client, Ruby_Protocol_QUIC_Client_allocate);
+	rb_define_method(Ruby_Protocol_QUIC_Client, "initialize", Ruby_Protocol_QUIC_Client_initialize, 5);
+	
+	rb_define_method(Ruby_Protocol_QUIC_Client, "connect", Ruby_Protocol_QUIC_Client_connect, 0);
+}

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

@@ -16,11 +16,11 @@
 extern "C" {
 #endif
 
-extern VALUE Protocol_QUIC_Client;
+extern VALUE Ruby_Protocol_QUIC_Client;
 
-void Init_Protocol_QUIC_Client(VALUE Protocol_QUIC);
+void Init_Ruby_Protocol_QUIC_Client(VALUE Protocol_QUIC);
 
-Protocol::QUIC::Client * Protocol_QUIC_Client_get(VALUE self);
+::Protocol::QUIC::Client * Ruby_Protocol_QUIC_Client_get(VALUE self);
 
 #ifdef __cplusplus
 }

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

@@ -0,0 +1,74 @@
+
+#include <ruby.h>
+
+#include "Configuration.hpp"
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#include <ngtcp2/ngtcp2.h>
+
+VALUE Ruby_Protocol_QUIC_Configuration = Qnil;
+
+static void Ruby_Protocol_QUIC_Configuration_free(void *data)
+{
+	if (data) {
+		delete reinterpret_cast<::Protocol::QUIC::Configuration *>(data);
+	}
+}
+
+static size_t Ruby_Protocol_QUIC_Configuration_size(const void *data) {
+	return sizeof(::Protocol::QUIC::Configuration);
+}
+
+static const rb_data_type_t Ruby_Protocol_QUIC_Configuration_type = {
+	.wrap_struct_name = "Protocol::QUIC::Configuration",
+	.function = {
+		.dmark = NULL,
+		.dfree = Ruby_Protocol_QUIC_Configuration_free,
+		.dsize = Ruby_Protocol_QUIC_Configuration_size,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE Ruby_Protocol_QUIC_Configuration_allocate(VALUE klass) {
+	auto configuration = new ::Protocol::QUIC::Configuration();
+
+	return TypedData_Wrap_Struct(klass, &Ruby_Protocol_QUIC_Configuration_type, configuration);
+}
+
+::Protocol::QUIC::Configuration * Ruby_Protocol_QUIC_Configuration_get(VALUE self)
+{
+	::Protocol::QUIC::Configuration *configuration;
+
+	TypedData_Get_Struct(self, ::Protocol::QUIC::Configuration, &Ruby_Protocol_QUIC_Configuration_type, configuration);
+
+	return configuration;
+}
+
+static VALUE Ruby_Protocol_QUIC_Configuration_initialize(VALUE self) {
+	::Protocol::QUIC::Configuration *configuration;
+
+	TypedData_Get_Struct(self, ::Protocol::QUIC::Configuration, &Ruby_Protocol_QUIC_Configuration_type, configuration);
+
+	return self;
+}
+
+static VALUE Ruby_Protocol_QUIC_Configuration_static_secret(VALUE self) {
+	::Protocol::QUIC::Configuration *configuration;
+
+	TypedData_Get_Struct(self, ::Protocol::QUIC::Configuration, &Ruby_Protocol_QUIC_Configuration_type, configuration);
+	
+	return rb_str_new((const char *)configuration->static_secret.data(), configuration->static_secret.size());
+}
+
+void Init_Ruby_Protocol_QUIC_Configuration(VALUE Protocol_QUIC) {
+	Ruby_Protocol_QUIC_Configuration =
+			rb_define_class_under(Protocol_QUIC, "Configuration", rb_cObject);
+
+	rb_define_alloc_func(Ruby_Protocol_QUIC_Configuration, Ruby_Protocol_QUIC_Configuration_allocate);
+	rb_define_method(Ruby_Protocol_QUIC_Configuration, "initialize", Ruby_Protocol_QUIC_Configuration_initialize, 0);
+	
+	rb_define_method(Ruby_Protocol_QUIC_Configuration, "static_secret", Ruby_Protocol_QUIC_Configuration_static_secret, 0);
+}

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

@@ -16,11 +16,11 @@
 extern "C" {
 #endif
 
-extern VALUE Protocol_QUIC_Configuration;
+extern VALUE Ruby_Protocol_QUIC_Configuration;
 
-void Init_Protocol_QUIC_Configuration(VALUE Protocol_QUIC);
+void Init_Ruby_Protocol_QUIC_Configuration(VALUE Protocol_QUIC);
 
-Protocol::QUIC::Configuration * Protocol_QUIC_Configuration_get(VALUE self);
+::Protocol::QUIC::Configuration * Ruby_Protocol_QUIC_Configuration_get(VALUE self);
 
 #ifdef __cplusplus
 }

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

@@ -0,0 +1,50 @@
+
+#include <ruby.h>
+
+#include "Connection.hpp"
+#include "ruby/internal/intern/vm.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#include <ngtcp2/ngtcp2.h>
+
+VALUE Ruby_Protocol_QUIC_Connection = Qnil;
+
+static void Ruby_Protocol_QUIC_Connection_free(void *data)
+{
+	if (data) {
+		delete reinterpret_cast<::Protocol::QUIC::Connection *>(data);
+	}
+}
+
+static size_t Ruby_Protocol_QUIC_Connection_size(const void *data) {
+	return sizeof(::Protocol::QUIC::Connection);
+}
+
+const rb_data_type_t Ruby_Protocol_QUIC_Connection_type = {
+	.wrap_struct_name = "Protocol::QUIC::Connection",
+	.function = {
+		.dmark = NULL,
+		.dfree = Ruby_Protocol_QUIC_Connection_free,
+		.dsize = Ruby_Protocol_QUIC_Connection_size,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+::Protocol::QUIC::Connection * Ruby_Protocol_QUIC_Connection_get(VALUE self)
+{
+	::Protocol::QUIC::Connection *connection;
+
+	TypedData_Get_Struct(self, ::Protocol::QUIC::Connection, &Ruby_Protocol_QUIC_Connection_type, connection);
+
+	return connection;
+}
+
+void Init_Ruby_Protocol_QUIC_Connection(VALUE Protocol_QUIC) {
+	Ruby_Protocol_QUIC_Connection =
+			rb_define_class_under(Protocol_QUIC, "Connection", rb_cObject);
+
+	rb_undef_alloc_func(Ruby_Protocol_QUIC_Connection);
+}

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

@@ -16,13 +16,13 @@
 extern "C" {
 #endif
 
-extern VALUE Protocol_QUIC_Connection;
+extern VALUE Ruby_Protocol_QUIC_Connection;
 
-extern const rb_data_type_t Protocol_QUIC_Connection_type;
+extern const rb_data_type_t Ruby_Protocol_QUIC_Connection_type;
 
-void Init_Protocol_QUIC_Connection(VALUE Protocol_QUIC);
+void Init_Ruby_Protocol_QUIC_Connection(VALUE Protocol_QUIC);
 
-Protocol::QUIC::Connection * Protocol_QUIC_Connection_get(VALUE self);
+::Protocol::QUIC::Connection * Ruby_Protocol_QUIC_Connection_get(VALUE self);
 
 #ifdef __cplusplus
 }