quicsilver 0.1.0

data/lib/quicsilver/server.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  class Server
+    attr_reader :address, :port, :server_configuration, :running
+
+    STREAM_EVENT_RECEIVE = "RECEIVE"
+    STREAM_EVENT_RECEIVE_FIN = "RECEIVE_FIN"
+    STREAM_EVENT_CONNECTION_ESTABLISHED = "CONNECTION_ESTABLISHED"
+    STREAM_EVENT_SEND_COMPLETE = "SEND_COMPLETE"
+
+    class << self
+      def stream_buffers
+        @stream_buffers ||= {}
+      end
+
+      def stream_handles
+        @stream_handles ||= {}
+      end
+
+      def rack_app
+        @rack_app
+      end
+
+      def rack_app=(app)
+        @rack_app = app
+      end
+
+      def handle_stream(stream_id, event, data)
+        case event
+        when STREAM_EVENT_CONNECTION_ESTABLISHED
+          puts "🔧 Ruby: Connection established with client"
+          connection_handle = data.unpack1('Q')  # Unpack 64-bit pointer
+          stream = Quicsilver.open_stream(connection_handle, true)  # unidirectional
+          control_data = Quicsilver::HTTP3.build_control_stream
+          Quicsilver.send_stream(stream, control_data, false)  # no FIN
+        when STREAM_EVENT_SEND_COMPLETE
+          puts "🔧 Ruby: Control stream sent to client"
+        when STREAM_EVENT_RECEIVE
+          # Accumulate data
+          stream_buffers[stream_id] ||= ""
+          stream_buffers[stream_id] += data
+          puts "🔧 Ruby: Stream #{stream_id}: Buffering #{data.bytesize} bytes (total: #{stream_buffers[stream_id].bytesize})"
+        when STREAM_EVENT_RECEIVE_FIN
+          # Extract stream handle from data (first 8 bytes)
+          stream_handle = data[0, 8].unpack1('Q')
+          actual_data = data[8..-1] || ""
+
+          # Store stream handle for later use
+          stream_handles[stream_id] = stream_handle
+
+          # Final chunk - process complete message
+          stream_buffers[stream_id] ||= ""
+          stream_buffers[stream_id] += actual_data
+          complete_data = stream_buffers[stream_id]
+
+          # Handle bidirectional streams (client requests)
+          if bidirectional?(stream_id)
+            handle_http3_request(stream_id, complete_data)
+          else
+            # Unidirectional stream (control/QPACK)
+            puts "✅ Ruby: Stream #{stream_id}: Control/QPACK stream (#{complete_data.bytesize} bytes)"
+          end
+
+          # Clean up buffers
+          stream_buffers.delete(stream_id)
+          stream_handles.delete(stream_id)
+        end
+      end
+
+      private
+
+      def bidirectional?(stream_id)
+        # Client-initiated bidirectional streams have bit 0x02 clear
+        (stream_id & 0x02) == 0
+      end
+
+      def handle_http3_request(stream_id, data)
+        parser = HTTP3::RequestParser.new(data)
+        parser.parse
+        env = parser.to_rack_env
+
+        if env && rack_app
+          puts "✅ Ruby: #{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
+
+          # Call Rack app
+          status, headers, body = rack_app.call(env)
+
+          # Encode response
+          encoder = HTTP3::ResponseEncoder.new(status, headers, body)
+          response_data = encoder.encode
+
+          # Get stream handle from stored handles
+          stream_handle = stream_handles[stream_id]
+          if stream_handle
+            # Send response
+            Quicsilver.send_stream(stream_handle, response_data, true)
+            puts "✅ Ruby: Response sent: #{status}"
+          else
+            puts "❌ Ruby: Stream handle not found for stream #{stream_id}"
+          end
+        else
+          puts "❌ Ruby: Failed to parse request"
+        end
+      rescue => e
+        puts "❌ Ruby: Error handling request: #{e.class} - #{e.message}"
+        puts e.backtrace.first(5)
+      end
+    end
+
+    def initialize(port = 4433, address: "0.0.0.0", app: nil, server_configuration: nil)
+      @port = port
+      @address = address
+      @app = app || default_rack_app
+      @server_configuration = server_configuration || ServerConfiguration.new
+      @running = false
+      @listener_data = nil
+
+      # Set class-level rack app so handle_stream can access it
+      self.class.rack_app = @app
+    end
+
+    def start
+      raise ServerIsRunningError, "Server is already running" if @running
+
+      # Initialize MSQUIC if not already done
+      Quicsilver.open_connection
+
+      config = Quicsilver.create_server_configuration(@server_configuration.to_h)
+      unless config
+        raise ServerConfigurationError, "Failed to create server configuration"
+      end
+
+      # Create and start the listener
+      @listener_data = start_listener(config)
+      start_server(config)
+
+      @running = true
+
+      puts "✅ QUIC server started successfully on #{@address}:#{@port}"
+    rescue ServerConfigurationError, ServerListenerError => e
+      cleanup_failed_server
+      @running = false
+      raise e
+    rescue => e
+      cleanup_failed_server
+      @running = false
+
+      error_msg = case e.message
+      when /0x16/
+        "Invalid parameter error - check certificate files and network configuration"
+      when /0x30/
+        "Address already in use - port #{@port} may be occupied"
+      else
+        e.message
+      end
+
+      raise ServerError, "Server start failed: #{error_msg}"
+    end
+
+    def stop
+      return unless @running
+
+      puts "🛑 Stopping QUIC server..."
+
+      if @listener_data
+        listener_handle = @listener_data[0]
+        Quicsilver.stop_listener(listener_handle)
+        Quicsilver.close_listener(@listener_data)
+        @listener_data = nil
+      end
+
+      @running = false
+      puts "👋 Server stopped"    
+    rescue
+      puts "⚠️  Error during server shutdown"
+      # Continue with cleanup even if there are errors
+      @listener_data = nil
+      @running = false
+    end
+
+    def running?
+      @running
+    end
+
+    def server_info
+      {
+        address: @address,
+        port: @port,
+        running: @running,
+        cert_file: @cert_file,
+        key_file: @key_file
+      }
+    end
+
+    def wait_for_connections(timeout: nil)
+      if timeout
+        end_time = Time.now + timeout
+        while Time.now < end_time && @running
+          Quicsilver.process_events
+          sleep(0.01) # Poll every 10ms
+        end
+      else
+        # Keep the server running indefinitely
+        # Process events from MSQUIC callbacks
+        loop do
+          Quicsilver.process_events
+          sleep(0.01) # Poll every 10ms
+          break unless @running
+        end
+      end
+    end
+
+    private
+
+    def default_rack_app
+      ->(env) {
+        [200,
+         {'Content-Type' => 'text/plain'},
+         ["Hello from Quicsilver!\nMethod: #{env['REQUEST_METHOD']}\nPath: #{env['PATH_INFO']}\n"]]
+      }
+    end
+
+    def start_server(config)
+      result = Quicsilver.start_listener(@listener_data.listener_handle, @address, @port)
+      unless result
+        Quicsilver.close_configuration(config)
+        cleanup_failed_server
+        raise ServerListenerError, "Failed to start listener on #{@address}:#{@port}"
+      end
+    end
+
+    def start_listener(config)
+      result = Quicsilver.create_listener(config)
+      listener_data = ListenerData.new(result[0], result[1])
+
+      unless listener_data
+        Quicsilver.close_configuration(config)
+        raise ServerListenerError, "Failed to create listener on #{@address}:#{@port}"
+      end
+
+      listener_data
+    end
+
+    def cleanup_failed_server
+      if @listener_data
+        begin
+          Quicsilver.stop_listener(@listener_data)
+          Quicsilver.close_listener(@listener_data)
+        rescue
+          # Ignore cleanup errors
+        ensure
+          @listener_data = nil
+        end
+      end
+    end
+  end
+end

data/lib/quicsilver/server_configuration.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+ 
+module Quicsilver
+  class ServerConfiguration
+    attr_reader :cert_file, :key_file, :idle_timeout, :server_resumption_level, :peer_bidi_stream_count, 
+      :peer_unidi_stream_count
+
+    QUIC_SERVER_RESUME_AND_ZERORTT = 1
+    QUIC_SERVER_RESUME_ONLY = 2
+    QUIC_SERVER_RESUME_AND_REUSE = 3
+    QUIC_SERVER_RESUME_AND_REUSE_ZERORTT = 4
+
+    def initialize(cert_file = nil, key_file = nil, options = {})
+      @cert_file = cert_file.nil? ? "certs/server.crt" : cert_file
+      @key_file = key_file.nil? ? "certs/server.key" : key_file
+      @idle_timeout = options[:idle_timeout].nil? ? 10000 : options[:idle_timeout]
+      @server_resumption_level = options[:server_resumption_level].nil? ? QUIC_SERVER_RESUME_AND_ZERORTT : options[:server_resumption_level]
+      @peer_bidi_stream_count = options[:peer_bidi_stream_count].nil? ? 10 : options[:peer_bidi_stream_count]
+      @peer_unidi_stream_count = options[:peer_unidi_stream_count].nil? ? 10 : options[:peer_unidi_stream_count]
+      @alpn = options[:alpn].nil? ? "h3" : options[:alpn]
+    end
+
+    # Common HTTP/3 ALPN Values:
+    # "h3" - HTTP/3 (most common)
+    # "h3-29" - HTTP/3 draft version 29
+    # "h3-28" - HTTP/3 draft version 28
+    # "h3-27" - HTTP/3 draft version 27
+    # Other QUIC ALPN Values:
+    # "hq-interop" - HTTP/0.9 over QUIC (testing)
+    # "hq-29" - HTTP/0.9 over QUIC draft 29
+    # "doq" - DNS over QUIC
+    # "doq-i03" - DNS over QUIC draft
+    def alpn
+      @alpn
+    end
+
+    def to_h
+      {
+        cert_file: @cert_file,
+        key_file: @key_file,
+        idle_timeout: @idle_timeout,
+        server_resumption_level: @server_resumption_level,
+        peer_bidi_stream_count: @peer_bidi_stream_count,
+        peer_unidi_stream_count: @peer_unidi_stream_count,
+        alpn: alpn
+      }
+    end
+  end
+end

data/lib/quicsilver/version.rb

@@ -0,0 +1,3 @@
+module Quicsilver
+  VERSION = "0.1.0"
+end

data/lib/quicsilver.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "quicsilver/version"
+require_relative "quicsilver/client"
+require_relative "quicsilver/listener_data"
+require_relative "quicsilver/server"
+require_relative "quicsilver/server_configuration"
+require_relative "quicsilver/http3"
+require_relative "quicsilver/http3/request_parser"
+require_relative "quicsilver/http3/request_encoder"
+require_relative "quicsilver/http3/response_encoder"
+require_relative "quicsilver/quicsilver"
+
+module Quicsilver
+  class Error < StandardError; end
+  class ServerIsRunningError < Error; end
+  class ServerConfigurationError < Error; end
+  class ServerListenerError < Error; end
+  class ServerError < Error; end
+  class ConnectionError < Error; end
+  class TimeoutError < Error; end
+end

data/quicsilver.gemspec

@@ -0,0 +1,44 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "quicsilver/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "quicsilver"
+  spec.version       = Quicsilver::VERSION
+  spec.authors       = ["Haroon Ahmed"]
+  spec.email         = ["haroon.ahmed25@gmail.com"]
+
+  spec.summary       = %q{Minimal HTTP/3 server implementation for Ruby}
+  spec.description   = %q{A minimal HTTP/3 server implementation for Ruby using Microsoft's MSQUIC library.}
+  spec.homepage      = "https://github.com/hahmed/quicsilver"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/hahmed/quicsilver"
+    spec.metadata["changelog_uri"] = "https://github.com/hahmed/quicsilver/blob/main/CHANGELOG.md"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.extensions = ['ext/quicsilver/extconf.rb']
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'rake-compiler', '~> 1.2'
+  spec.add_development_dependency 'rake-compiler-dock', '~> 1.3'
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: quicsilver
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Haroon Ahmed
+bindir: exe
+cert_chain: []
+date: 2025-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler-dock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: A minimal HTTP/3 server implementation for Ruby using Microsoft's MSQUIC
+  library.
+email:
+- haroon.ahmed25@gmail.com
+executables: []
+extensions:
+- ext/quicsilver/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitmodules"
+- ".ruby-version"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/README.md
+- examples/minimal_http3_client.rb
+- examples/minimal_http3_server.rb
+- examples/rack_http3_server.rb
+- examples/setup_certs.sh
+- ext/quicsilver/extconf.rb
+- ext/quicsilver/quicsilver.c
+- lib/quicsilver.rb
+- lib/quicsilver/client.rb
+- lib/quicsilver/http3.rb
+- lib/quicsilver/http3/request_encoder.rb
+- lib/quicsilver/http3/request_parser.rb
+- lib/quicsilver/http3/response_encoder.rb
+- lib/quicsilver/listener_data.rb
+- lib/quicsilver/server.rb
+- lib/quicsilver/server_configuration.rb
+- lib/quicsilver/version.rb
+- quicsilver.gemspec
+homepage: https://github.com/hahmed/quicsilver
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/hahmed/quicsilver
+  source_code_uri: https://github.com/hahmed/quicsilver
+  changelog_uri: https://github.com/hahmed/quicsilver/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Minimal HTTP/3 server implementation for Ruby
+test_files: []