protocol-quic 0.0.2 → 0.0.3

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

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

@@ -0,0 +1,29 @@
+//
+//  Stream.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/Stream.hpp>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern VALUE Protocol_QUIC_Stream;
+
+void Init_Protocol_QUIC_Stream(VALUE Protocol_QUIC);
+
+Protocol::QUIC::Stream * Protocol_QUIC_Stream_get(VALUE self);
+
+VALUE Protocol_QUIC_Stream_allocate(VALUE klass);
+
+#ifdef __cplusplus
+}
+#endif

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

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

@@ -0,0 +1,27 @@
+//
+//  ClientContext.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/TLS/ClientContext.hpp>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern VALUE Protocol_QUIC_TLS_ClientContext;
+
+void Init_Protocol_QUIC_TLS_ClientContext(VALUE Protocol_QUIC_TLS);
+
+Protocol::QUIC::TLS::ClientContext * Protocol_QUIC_TLS_ClientContext_get(VALUE self);
+
+#ifdef __cplusplus
+}
+#endif

data/ext/source/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 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/Context.hpp

@@ -0,0 +1,27 @@
+//
+//  Context.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/TLS/Context.hpp>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern VALUE Protocol_QUIC_TLS_Context;
+
+extern const rb_data_type_t Protocol_QUIC_TLS_Context_type;
+
+void Init_Protocol_QUIC_TLS_Context(VALUE Protocol_QUIC);
+
+#ifdef __cplusplus
+}
+#endif

data/ext/source/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 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/TLS/ServerContext.hpp

@@ -0,0 +1,27 @@
+//
+//  ServerContext.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/TLS/ServerContext.hpp>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern VALUE Protocol_QUIC_TLS_ServerContext;
+
+void Init_Protocol_QUIC_TLS_ServerContext(VALUE Protocol_QUIC_TLS);
+
+Protocol::QUIC::TLS::ServerContext * Protocol_QUIC_TLS_ServerContext_get(VALUE self);
+
+#ifdef __cplusplus
+}
+#endif

data/ext/source/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_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);
+}

data/ext/source/Protocol/QUIC.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <ruby.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern VALUE Protocol_QUIC;
+
+void Init_Protocol_QUIC(void);
+
+#ifdef __cplusplus
+}
+#endif

data/lib/protocol/quic/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protocol-quic
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Samuel Williams
@@ -73,6 +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/teapot.rb
 - lib/protocol/quic.rb
 - lib/protocol/quic/version.rb