quicsilver 0.1.0 → 0.3.0

data/lib/quicsilver/http3/request_parser.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-require 'stringio'
-
-module Quicsilver
-  module HTTP3
-    class RequestParser
-      attr_reader :frames, :headers, :body
-
-      def initialize(data)
-        @data = data
-        @frames = []
-        @headers = {}
-        @body = StringIO.new
-      end
-
-      def parse
-        parse!
-      end
-
-      def to_rack_env(stream_info = {})
-        return nil if @headers.empty?
-
-        # Extract path and query string
-        path_full = @headers[':path'] || '/'
-        path, query = path_full.split('?', 2)
-
-        # Extract host and port
-        authority = @headers[':authority'] || 'localhost:4433'
-        host, port = authority.split(':', 2)
-        port ||= '4433'
-
-        env = {
-          'REQUEST_METHOD' => @headers[':method'] || 'GET',
-          'PATH_INFO' => path,
-          'QUERY_STRING' => query || '',
-          'SERVER_NAME' => host,
-          'SERVER_PORT' => port,
-          'SERVER_PROTOCOL' => 'HTTP/3',
-          'rack.version' => [1, 3],
-          'rack.url_scheme' => @headers[':scheme'] || 'https',
-          'rack.input' => @body,
-          'rack.errors' => $stderr,
-          'rack.multithread' => true,
-          'rack.multiprocess' => false,
-          'rack.run_once' => false,
-          'rack.hijack?' => false,
-          'SCRIPT_NAME' => '',
-          'CONTENT_LENGTH' => @body.size.to_s,
-        }
-
-        # Add regular headers as HTTP_*
-        @headers.each do |name, value|
-          next if name.start_with?(':')
-          env["HTTP_#{name.upcase.tr('-', '_')}"] = value
-        end
-
-        env
-      end
-
-      private
-
-      def parse!
-        buffer = @data.dup
-        offset = 0
-
-        while offset < buffer.bytesize
-          break if buffer.bytesize - offset < 2
-
-          type, type_len = HTTP3.decode_varint(buffer.bytes, offset)
-          length, length_len = HTTP3.decode_varint(buffer.bytes, offset + type_len)
-          header_len = type_len + length_len
-
-          break if buffer.bytesize < offset + header_len + length
-
-          payload = buffer[offset + header_len, length]
-          @frames << { type: type, length: length, payload: payload }
-
-          case type
-          when 0x01 # HEADERS
-            parse_headers(payload)
-          when 0x00 # DATA
-            @body.write(payload)
-          end
-
-          offset += header_len + length
-        end
-
-        @body.rewind
-      end
-
-      def parse_headers(payload)
-        # Skip QPACK required insert count (1 byte) + delta base (1 byte)
-        offset = 2
-        return if payload.bytesize < offset
-
-        while offset < payload.bytesize
-          byte = payload.bytes[offset]
-
-          # Indexed field line (static table, starts with 0x4X or 0x5X)
-          if (byte & 0xC0) == 0x40 || (byte & 0xC0) == 0x80
-            index = byte & 0x3F
-            offset += 1
-
-            # Check if this is a complete field (name+value) or just name
-            field = decode_static_table_field(index)
-
-            if field.is_a?(Hash)
-              # Complete field with both name and value (e.g., :method GET)
-              @headers.merge!(field)
-            elsif field
-              # Name-only entry, value follows
-              value_len, len_bytes = HTTP3.decode_varint(payload.bytes, offset)
-              offset += len_bytes
-              value = payload[offset, value_len]
-              offset += value_len
-              @headers[field] = value
-            end
-          # Literal with literal name (starts with 0x2X)
-          elsif (byte & 0xE0) == 0x20
-            name_len = byte & 0x1F
-            offset += 1
-            name = payload[offset, name_len]
-            offset += name_len
-
-            value_len, len_bytes = HTTP3.decode_varint(payload.bytes, offset)
-            offset += len_bytes
-            value = payload[offset, value_len]
-            offset += value_len
-
-            @headers[name] = value
-          else
-            break # Unknown encoding
-          end
-        end
-      end
-
-      # QPACK static table decoder (RFC 9204 Appendix A)
-      # Returns Hash for complete fields, String for name-only fields
-      def decode_static_table_field(index)
-        case index
-        when 0 then ':authority'        # Name only
-        when 1 then ':path'             # Name only
-        when 15 then {':method' => 'CONNECT'}
-        when 16 then {':method' => 'DELETE'}
-        when 17 then {':method' => 'GET'}
-        when 18 then {':method' => 'HEAD'}
-        when 19 then {':method' => 'OPTIONS'}
-        when 20 then {':method' => 'POST'}
-        when 21 then {':method' => 'PUT'}
-        when 22 then {':scheme' => 'http'}
-        when 23 then {':scheme' => 'https'}
-        else nil
-        end
-      end
-    end
-  end
-end

data/lib/quicsilver/http3/response_encoder.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Quicsilver
-  module HTTP3
-    class ResponseEncoder
-      def initialize(status, headers, body)
-        @status = status
-        @headers = headers
-        @body = body
-      end
-
-      def encode
-        frames = ""
-
-        # HEADERS frame
-        frames += encode_headers_frame
-
-        # DATA frame(s)
-        @body.each do |chunk|
-          frames += encode_data_frame(chunk) unless chunk.empty?
-        end
-
-        @body.close if @body.respond_to?(:close)
-
-        frames
-      end
-
-      private
-
-      def encode_headers_frame
-        payload = encode_qpack_response
-
-        frame_type = HTTP3.encode_varint(0x01)  # HEADERS
-        frame_length = HTTP3.encode_varint(payload.bytesize)
-
-        frame_type + frame_length + payload
-      end
-
-      def encode_data_frame(data)
-        frame_type = HTTP3.encode_varint(0x00)  # DATA
-        frame_length = HTTP3.encode_varint(data.bytesize)
-
-        frame_type + frame_length + data
-      end
-
-      def encode_qpack_response
-        # QPACK prefix: Required Insert Count = 0, Delta Base = 0
-        encoded = [0x00, 0x00].pack('C*')
-
-        # :status pseudo-header (literal indexed)
-        status_str = @status.to_s
-        encoded += [0x58, status_str.bytesize].pack('C*')
-        encoded += status_str
-
-        # Regular headers (literal with literal name)
-        @headers.each do |name, value|
-          next if name.start_with?('rack.')  # Skip Rack internals
-
-          name = name.downcase
-          value = value.to_s
-
-          # Literal field line with literal name (0x2X prefix)
-          encoded += [0x20 | name.bytesize].pack('C')
-          encoded += name
-          encoded += HTTP3.encode_varint(value.bytesize)
-          encoded += value
-        end
-
-        encoded
-      end
-    end
-  end
-end

data/lib/quicsilver/http3.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Quicsilver
-  module HTTP3
-    # Encode variable-length integer
-    def self.encode_varint(value)
-      case value
-      when 0..63
-        [value].pack('C')
-      when 64..16383
-        [0x40 | (value >> 8), value & 0xFF].pack('C*')
-      when 16384..1073741823
-        [0x80 | (value >> 24), (value >> 16) & 0xFF,
-         (value >> 8) & 0xFF, value & 0xFF].pack('C*')
-      else
-        [0xC0 | (value >> 56), (value >> 48) & 0xFF,
-         (value >> 40) & 0xFF, (value >> 32) & 0xFF,
-         (value >> 24) & 0xFF, (value >> 16) & 0xFF,
-         (value >> 8) & 0xFF, value & 0xFF].pack('C*')
-      end
-    end
-
-    def self.build_settings_frame(settings = {})
-      payload = ""
-      settings.each do |id, value|
-        payload += encode_varint(id)
-        payload += encode_varint(value)
-      end
-
-      frame_type = encode_varint(0x04)  # SETTINGS
-      frame_length = encode_varint(payload.bytesize)
-
-      frame_type + frame_length + payload
-    end
-
-    # Build control stream data
-    def self.build_control_stream
-      stream_type = [0x00].pack('C')  # Control stream type
-      settings = build_settings_frame({
-        # 0x01 => 4096,  # QPACK_MAX_TABLE_CAPACITY (optional)
-        # 0x06 => 16384  # MAX_HEADER_LIST_SIZE (optional)
-      })
-
-      stream_type + settings
-    end
-
-    # Decode variable-length integer (RFC 9000)
-    # Returns [value, bytes_consumed]
-    def self.decode_varint(bytes, offset = 0)
-      first = bytes[offset]
-      case (first & 0xC0) >> 6
-      when 0
-        [first & 0x3F, 1]
-      when 1
-        [(first & 0x3F) << 8 | bytes[offset + 1], 2]
-      when 2
-        [(first & 0x3F) << 24 | bytes[offset + 1] << 16 |
-         bytes[offset + 2] << 8 | bytes[offset + 3], 4]
-      else # when 3
-        [(first & 0x3F) << 56 | bytes[offset + 1] << 48 |
-         bytes[offset + 2] << 40 | bytes[offset + 3] << 32 |
-         bytes[offset + 4] << 24 | bytes[offset + 5] << 16 |
-         bytes[offset + 6] << 8 | bytes[offset + 7], 8]
-      end
-    end
-  end
-end
-

data/lib/quicsilver/listener_data.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Quicsilver
-  class ListenerData
-    attr_reader :listener_handle, :context_handle, :started, :stopped, :failed, :configuration
-
-    def initialize(listener_handle, context_handle)
-      @listener_handle = listener_handle  # The MSQUIC listener handle
-      @context_handle = context_handle    # The C context pointer
-      # NOTE: Fetch this from the context handle, or improve return values from the C extension
-      @started = false
-      @stopped = false  
-      @failed = false
-      @configuration = nil
-    end
-
-    def started?
-      @started
-    end
-
-    def stopped?
-      @stopped
-    end
-
-    def failed?
-      @failed
-    end
-  end
-end

data/lib/quicsilver/server.rb

@@ -1,258 +0,0 @@
-# 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

@@ -1,49 +0,0 @@
-# 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