quicsilver 0.1.0

data/lib/quicsilver/client.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  class Client
+    attr_reader :hostname, :port, :unsecure, :connection_timeout
+    
+    def initialize(hostname, port = 4433, options = {})
+      @hostname = hostname
+      @port = port
+      @unsecure = options[:unsecure] || true
+      @connection_timeout = options[:connection_timeout] || 5000
+   
+      @connection_data = nil
+      @connected = false
+      @connection_start_time = nil
+    end
+    
+    def connect
+      raise Error, "Already connected" if @connected
+
+      # Initialize MSQUIC if not already done
+      result = Quicsilver.open_connection
+      
+      # Create configuration
+      config = Quicsilver.create_configuration(@unsecure)
+      raise ConnectionError, "Failed to create configuration" if config.nil?
+      
+      # Create connection (returns [handle, context])
+      @connection_data = Quicsilver.create_connection
+      raise ConnectionError, "Failed to create connection" if @connection_data.nil?
+      
+      connection_handle = @connection_data[0]
+      context_handle = @connection_data[1]
+      
+      # Start the connection
+      success = Quicsilver.start_connection(connection_handle, config, @hostname, @port)
+      unless success
+        Quicsilver.close_configuration(config)
+        cleanup_failed_connection
+        raise ConnectionError, "Failed to start connection"
+      end
+
+      # Wait for connection to establish or fail
+      result = Quicsilver.wait_for_connection(context_handle, @connection_timeout)
+
+      if result.key?("error")
+        error_status = result["status"]
+        error_code = result["code"]
+        Quicsilver.close_configuration(config)
+        cleanup_failed_connection
+        error_msg = "Connection failed with status: 0x#{error_status.to_s(16)}, code: #{error_code}"
+        raise ConnectionError, error_msg
+      elsif result.key?("timeout")
+        Quicsilver.close_configuration(config)
+        cleanup_failed_connection
+        error_msg = "Connection timed out after #{@connection_timeout}ms"
+        raise TimeoutError, error_msg
+      end
+      
+      @connected = true
+      @connection_start_time = Time.now
+      
+      send_control_stream
+      
+      # Clean up config since connection is established
+      Quicsilver.close_configuration(config)
+    rescue => e
+      cleanup_failed_connection
+      
+      if e.is_a?(ConnectionError) || e.is_a?(TimeoutError)
+        raise e
+      else
+        raise ConnectionError, "Connection failed: #{e.message}"
+      end
+    end
+    
+    def disconnect
+      return unless @connected || @connection_data
+      
+      begin
+        if @connection_data
+          Quicsilver.close_connection_handle(@connection_data)
+          @connection_data = nil
+        end
+      rescue
+        # Ignore disconnect errors
+      ensure
+        @connected = false
+        @connection_start_time = nil
+      end
+    end
+    
+    def connected?
+      return false unless @connected && @connection_data
+
+      # Get connection status from the C extension
+      context_handle = @connection_data[1]
+      info = Quicsilver.connection_status(context_handle)
+      if info && info.key?("connected")
+        is_connected = info["connected"] && !info["failed"]
+        
+        # If C extension says we're disconnected, update our state
+        if !is_connected && @connected
+          @connected = false
+        end
+        
+        is_connected
+      else
+        # If we can't get status, assume disconnected
+        if @connected
+          @connected = false
+        end
+        false
+      end
+    rescue
+      # If there's an error checking status, assume disconnected
+      if @connected
+        @connected = false
+      end
+      false
+    end
+    
+    def connection_info
+      base_info = if @connection_data
+        begin
+          context_handle = @connection_data[1]
+          Quicsilver.connection_status(context_handle) || {}
+        rescue
+          {}
+        end
+      else
+        {}
+      end
+      
+      base_info.merge({
+        hostname: @hostname,
+        port: @port,
+        uptime: connection_uptime
+      })
+    end
+    
+    def connection_uptime
+      return 0 unless @connection_start_time
+      Time.now - @connection_start_time
+    end
+
+    def send_data(data)
+      raise Error, "Not connected" unless @connected
+
+      stream = open_stream
+      unless stream
+        puts "❌ Failed to open stream"
+        return false
+      end
+
+      result = Quicsilver.send_stream(stream, data, true)
+      puts "✅ Sent #{data.bytesize} bytes"
+      result
+    rescue => e
+      puts "❌ Send data error: #{e.class} - #{e.message}"
+      false
+    end
+    
+    private
+    
+    def cleanup_failed_connection
+      Quicsilver.close_connection_handle(@connection_data) if @connection_data
+      @connection_data = nil
+      @connected = false
+    end
+
+    def open_stream
+      Quicsilver.open_stream(@connection_data[0], false)
+    end
+
+    def open_unidirectional_stream
+      Quicsilver.open_stream(@connection_data[0], true)
+    end
+
+    def send_control_stream
+      # Open unidirectional stream
+      stream = open_unidirectional_stream
+
+      # Build and send control stream data
+      control_data = Quicsilver::HTTP3.build_control_stream
+      Quicsilver.send_stream(stream, control_data, false)
+
+      @control_stream = stream
+    end
+  end
+end

data/lib/quicsilver/http3/request_encoder.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  module HTTP3
+    class RequestEncoder
+      def initialize(method:, path:, scheme: 'https', authority: 'localhost:4433', headers: {}, body: nil)
+        @method = method.upcase
+        @path = path
+        @scheme = scheme
+        @authority = authority
+        @headers = headers
+        @body = body
+      end
+
+      def encode
+        frames = []
+
+        # Build HEADERS frame
+        headers_payload = encode_headers
+        frames << build_frame(0x01, headers_payload)  # 0x01 = HEADERS frame
+
+        # Build DATA frame if body present
+        if @body && !@body.empty?
+          body_data = @body.is_a?(String) ? @body : @body.join
+          frames << build_frame(0x00, body_data)  # 0x00 = DATA frame
+        end
+
+        frames.join.force_encoding(Encoding::BINARY)
+      end
+
+      private
+
+      def build_frame(type, payload)
+        frame_type = HTTP3.encode_varint(type)
+        frame_length = HTTP3.encode_varint(payload.bytesize)
+        frame_type + frame_length + payload
+      end
+
+      def encode_headers
+        payload = "".b
+
+        # QPACK prefix: Required Insert Count = 0, Delta Base = 0
+        payload += "\x00\x00".b
+
+        # Encode pseudo-headers using Indexed Field Line with Post-Base Index
+        # Pattern: 0x50 (0101 0000) for :method, :scheme
+        # Pattern: 0x40 | index for :authority, :path (literal name, literal value)
+
+        # :method (use literal since GET/POST have specific indices but we want flexibility)
+        payload += encode_literal_pseudo_header(':method', @method)
+
+        # :scheme
+        payload += encode_literal_pseudo_header(':scheme', @scheme)
+
+        # :authority
+        payload += encode_literal_pseudo_header(':authority', @authority)
+
+        # :path
+        payload += encode_literal_pseudo_header(':path', @path)
+
+        # Encode regular headers
+        @headers.each do |name, value|
+          payload += encode_literal_header(name.to_s.downcase, value.to_s)
+        end
+
+        payload
+      end
+
+      # Literal field line with literal name for pseudo-headers
+      # Pattern: 0x50 (indexed name from static table) + value
+      def encode_literal_pseudo_header(name, value)
+        # For pseudo-headers, use indexed name reference from static table
+        # with literal value (pattern: 0101xxxx where xxxx = static table index)
+        static_index = case name
+        when ':authority' then 0
+        when ':path' then 1
+        when ':method' then (@method == 'GET' ? 17 : 20)  # GET=17, POST=20
+        when ':scheme' then (@scheme == 'http' ? 22 : 23)
+        else nil
+        end
+
+        if static_index
+          # Use indexed field line (0x40 | index)
+          result = "".b
+          result += [0x40 | static_index].pack('C')
+          # For non-exact matches, append literal value
+          if name == ':authority' || name == ':path'
+            result += HTTP3.encode_varint(value.bytesize)
+            result += value.to_s.b
+          end
+          result
+        else
+          # Fallback to literal name
+          encode_literal_header(name, value)
+        end
+      end
+
+      # Literal field line with literal name
+      # Pattern: 0x20 | name_length, name_bytes, value_length, value_bytes
+      def encode_literal_header(name, value)
+        result = "".b
+        # 0x20 = literal with literal name (no indexing)
+        name_len = name.bytesize
+        result += [0x20 | (name_len & 0x1F)].pack('C')
+        result += name.b
+        result += HTTP3.encode_varint(value.bytesize)
+        result += value.to_s.b
+        result
+      end
+    end
+  end
+end

data/lib/quicsilver/http3/request_parser.rb

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

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

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

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