quicsilver 0.2.0 → 0.4.0

data/lib/quicsilver/http3/response_encoder.rb

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-
-module Quicsilver
-  module HTTP3
-    class ResponseEncoder
-      def initialize(status, headers, body)
-        @status = status
-        @headers = headers
-        @body = body
-      end
-
-      # Buffered encode - returns all frames at once (legacy)
-      def encode
-        frames = "".b
-        frames << encode_headers_frame
-        @body.each do |chunk|
-          frames << encode_data_frame(chunk) unless chunk.empty?
-        end
-        @body.close if @body.respond_to?(:close)
-        frames
-      end
-
-      # Streaming encode - yields frames as they're ready
-      def stream_encode
-        yield encode_headers_frame, false
-
-        last_chunk = nil
-        @body.each do |chunk|
-          yield encode_data_frame(last_chunk), false if last_chunk && !last_chunk.empty?
-          last_chunk = chunk
-        end
-
-        # Send final chunk with FIN=true
-        if last_chunk && !last_chunk.empty?
-          yield encode_data_frame(last_chunk), true
-        else
-          yield "".b, true  # Empty frame to signal FIN
-        end
-
-        @body.close if @body.respond_to?(:close)
-      end
-
-      private
-
-      def encode_headers_frame
-        payload = encode_qpack_response
-        frame_type = HTTP3.encode_varint(HTTP3::FRAME_HEADERS)
-        frame_length = HTTP3.encode_varint(payload.bytesize)
-        frame_type + frame_length + payload
-      end
-
-      def encode_data_frame(data)
-        frame_type = HTTP3.encode_varint(HTTP3::FRAME_DATA)
-        data_bytes = data.to_s.b
-        frame_length = HTTP3.encode_varint(data_bytes.bytesize)
-        frame_type + frame_length + data_bytes
-      end
-
-      def encode_qpack_response
-        # QPACK prefix: Required Insert Count = 0, Delta Base = 0
-        encoded = [0x00, 0x00].pack('C*')
-
-        # :status pseudo-header - use indexed if possible
-        encoded += encode_status(@status)
-
-        # Regular headers
-        @headers.each do |name, value|
-          next if name.start_with?('rack.')  # Skip Rack internals
-
-          name = name.to_s.downcase
-          value = value.to_s
-
-          # Try to use indexed encoding for common headers
-          index = find_static_index(name, value)
-          if index
-            # Pattern 1: Indexed Field Line (1Txxxxxx where T=1 for static)
-            encoded += encode_indexed_field(index)
-          else
-            # Check if just the name exists in static table
-            name_index = find_static_name_index(name)
-            if name_index
-              # Pattern 3: Literal with name reference (01NTxxxx)
-              encoded += encode_literal_with_name_ref(name_index, value)
-            else
-              # Pattern 5: Literal with literal name (001NHxxx)
-              encoded += encode_literal_with_literal_name(name, value)
-            end
-          end
-        end
-
-        encoded
-      end
-
-      private
-
-      def encode_status(status)
-        status_str = status.to_s
-        # Map common status codes to static table indices
-        index = case status_str
-                when '200' then HTTP3::QPACK_STATUS_200  # 25
-                when '404' then HTTP3::QPACK_STATUS_404  # 27
-                when '500' then HTTP3::QPACK_STATUS_500  # 71
-                when '400' then HTTP3::QPACK_STATUS_400  # 67
-                when '100' then 63
-                when '204' then 64
-                when '304' then 26
-                when '403' then 68
-                else nil
-                end
-
-        if index
-          # Indexed field line: 11 (pattern) + T (1=static) + index (prefix integer with N=6)
-          encode_indexed_field_with_prefix(index)
-        else
-          # Literal with name reference - use index 25 (:status 200) for name
-          name_ref = [0x40 | 25].pack('C')
-          status_bytes = status_str.b
-          length = [status_bytes.bytesize].pack('C')
-          name_ref + length + status_bytes
-        end
-      end
-
-      # Encode indexed field line using prefix integer encoding (RFC 7541)
-      # Pattern: 11 + T(1 bit) + index as prefix integer with N=6
-      def encode_indexed_field_with_prefix(index, prefix_bits: 6, pattern: 0xC0)
-        max_prefix = (1 << prefix_bits) - 1  # 2^6 - 1 = 63
-
-        if index < max_prefix
-          # Fits in prefix bits
-          [pattern | index].pack('C')
-        else
-          # Needs continuation bytes
-          result = [pattern | max_prefix].pack('C')  # First byte: all prefix bits set to 1
-          remaining = index - max_prefix
-
-          # Encode remaining value using 7-bit continuation bytes
-          while remaining >= 128
-            result += [(remaining & 0x7F) | 0x80].pack('C')  # MSB=1 means more bytes
-            remaining >>= 7
-          end
-          result += [remaining].pack('C')  # Last byte: MSB=0
-
-          result
-        end
-      end
-
-      def find_static_index(name, value)
-        HTTP3::STATIC_TABLE.each_with_index do |(tbl_name, tbl_value), idx|
-          return idx if tbl_name == name && tbl_value == value
-        end
-        nil
-      end
-
-      def find_static_name_index(name)
-        HTTP3::STATIC_TABLE.each_with_index do |(tbl_name, _), idx|
-          return idx if tbl_name == name
-        end
-        nil
-      end
-
-      def encode_indexed_field(index)
-        # Pattern 1: Indexed Field Line with prefix integer encoding
-        encode_indexed_field_with_prefix(index)
-      end
-
-      def encode_literal_with_name_ref(name_index, value)
-        # Pattern 3: Literal Field Line with Name Reference
-        # 01 N T + 4-bit index (N=0, T=1 for static)
-        prefix = 0x40 | name_index
-        prefix_byte = [prefix].pack('C')
-        value_bytes = value.to_s.b
-        value_length = HTTP3.encode_varint(value_bytes.bytesize)
-        prefix_byte + value_length + value_bytes
-      end
-
-      def encode_literal_with_literal_name(name, value)
-        # Pattern 5: Literal Field Line with Literal Name
-        # 001 N H + 3-bit name length (N=0, H=0 for no Huffman)
-        prefix = 0x20 | name.bytesize
-        name_bytes = name.to_s.b
-        value_bytes = value.to_s.b
-        [prefix].pack('C') + name_bytes + HTTP3.encode_varint(value_bytes.bytesize) + value_bytes
-      end
-    end
-  end
-end

data/lib/quicsilver/http3/response_parser.rb

@@ -1,160 +0,0 @@
-# frozen_string_literal: true
-
-require 'stringio'
-
-module Quicsilver
-  module HTTP3
-    class ResponseParser
-      attr_reader :frames, :headers, :status
-
-      def initialize(data)
-        @data = data
-        @frames = []
-        @headers = {}
-        @body_io = StringIO.new
-        @status = nil
-      end
-
-      def body
-        @body_io.rewind
-        @body_io
-      end
-
-      def parse
-        parse!
-      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_io.write(payload)
-          end
-
-          offset += header_len + length
-        end
-      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]
-
-          # Pattern 1: Indexed Field Line (1Txxxxxx)
-          if (byte & 0x80) == 0x80
-            # Decode prefix integer with N=6 bits
-            index, bytes_consumed = decode_prefix_integer(payload.bytes, offset, 6, 0xC0)
-            offset += bytes_consumed
-
-            field = decode_static_table_field(index)
-            if field.is_a?(Hash)
-              field.each do |name, value|
-                if name == ":status"
-                  @status = value.to_i
-                else
-                  @headers[name] = value
-                end
-              end
-            end
-          # Pattern 3: Literal with Name Reference (01NTxxxx)
-          elsif (byte & 0xC0) == 0x40
-            index = byte & 0x3F
-            offset += 1
-
-            entry = HTTP3::STATIC_TABLE[index] if index < HTTP3::STATIC_TABLE.size
-            name = entry ? entry[0] : nil
-
-            if name
-              value_len, len_bytes = HTTP3.decode_varint(payload.bytes, offset)
-              offset += len_bytes
-              value = payload[offset, value_len]
-              offset += value_len
-
-              if name == ":status"
-                @status = value.to_i
-              else
-                @headers[name] = value
-              end
-            end
-          # Pattern 5: Literal with literal name (001NHxxx)
-          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
-          end
-        end
-      end
-
-      def decode_static_table_field(index)
-        return nil if index >= HTTP3::STATIC_TABLE.size
-
-        name, value = HTTP3::STATIC_TABLE[index]
-
-        if value.empty?
-          name
-        else
-          {name => value}
-        end
-      end
-
-      # Decode prefix integer (RFC 7541)
-      # Returns [value, bytes_consumed]
-      def decode_prefix_integer(bytes, offset, prefix_bits, pattern_mask)
-        max_prefix = (1 << prefix_bits) - 1  # 2^N - 1
-
-        first_byte = bytes[offset]
-        value = first_byte & max_prefix
-        bytes_consumed = 1
-
-        # If all prefix bits are 1, value continues in next byte(s)
-        if value == max_prefix
-          multiplier = 1
-          loop do
-            return [value, bytes_consumed] if offset + bytes_consumed >= bytes.size
-
-            next_byte = bytes[offset + bytes_consumed]
-            bytes_consumed += 1
-
-            value += (next_byte & 0x7F) * multiplier
-            break if (next_byte & 0x80) == 0  # MSB=0 means last byte
-
-            multiplier *= 128
-          end
-        end
-
-        [value, bytes_consumed]
-      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/quic_stream.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Quicsilver
-  class QuicStream
-    attr_reader :stream_id, :is_unidirectional, :buffer
-    attr_accessor :stream_handle
-
-    def initialize(stream_id, is_unidirectional: nil)
-      @stream_id = stream_id
-      @is_unidirectional = is_unidirectional.nil? ? !bidirectional? : is_unidirectional
-      @buffer = StringIO.new.tap { |io| io.set_encoding(Encoding::ASCII_8BIT) }
-      @stream_handle = nil
-    end
-
-    def bidirectional?
-      (stream_id & 0x02) == 0
-    end
-
-    def ready_to_send?
-      !stream_handle.nil?
-    end
-
-    def append_data(data)
-      @buffer.write(data)
-    end
-
-    def data
-      @buffer.string
-    end
-
-    def clear_buffer
-      @buffer.truncate(0)
-      @buffer.rewind
-    end
-  end
-end

data/lib/quicsilver/request_registry.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Quicsilver
-  class RequestRegistry
-    def initialize
-      @requests = {}
-      @mutex = Mutex.new
-    end
-
-    def track(stream_id, connection_handle, path:, method:, started_at: Time.now)
-      @mutex.synchronize do
-        @requests[stream_id] = {
-          connection_handle: connection_handle,
-          path: path,
-          method: method,
-          started_at: started_at
-        }
-      end
-    end
-
-    def complete(stream_id)
-      @mutex.synchronize { @requests.delete(stream_id) }
-    end
-
-    def active_count
-      @mutex.synchronize { @requests.size }
-    end
-
-    def active_requests
-      @mutex.synchronize { @requests.dup }
-    end
-
-    def requests_older_than(seconds)
-      cutoff = Time.now - seconds
-      @mutex.synchronize do
-        @requests.select { |_, r| r[:started_at] < cutoff }
-      end
-    end
-
-    def empty?
-      @mutex.synchronize { @requests.empty? }
-    end
-
-    def include?(stream_id)
-      @mutex.synchronize { @requests.key?(stream_id) }
-    end
-  end
-end