quicsilver 0.1.0 → 0.2.0

data/lib/quicsilver/http3/response_encoder.rb

@@ -9,65 +9,178 @@ module Quicsilver
         @body = body
       end
 
+      # Buffered encode - returns all frames at once (legacy)
       def encode
-        frames = ""
+        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
 
-        # HEADERS frame
-        frames += encode_headers_frame
+      # Streaming encode - yields frames as they're ready
+      def stream_encode
+        yield encode_headers_frame, false
 
-        # DATA frame(s)
+        last_chunk = nil
         @body.each do |chunk|
-          frames += encode_data_frame(chunk) unless chunk.empty?
+          yield encode_data_frame(last_chunk), false if last_chunk && !last_chunk.empty?
+          last_chunk = chunk
         end
 
-        @body.close if @body.respond_to?(:close)
+        # 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
 
-        frames
+        @body.close if @body.respond_to?(:close)
       end
 
       private
 
       def encode_headers_frame
         payload = encode_qpack_response
-
-        frame_type = HTTP3.encode_varint(0x01)  # HEADERS
+        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(0x00)  # DATA
-        frame_length = HTTP3.encode_varint(data.bytesize)
-
-        frame_type + frame_length + 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 (literal indexed)
-        status_str = @status.to_s
-        encoded += [0x58, status_str.bytesize].pack('C*')
-        encoded += status_str
+        # :status pseudo-header - use indexed if possible
+        encoded += encode_status(@status)
 
-        # Regular headers (literal with literal name)
+        # Regular headers
         @headers.each do |name, value|
           next if name.start_with?('rack.')  # Skip Rack internals
 
-          name = name.downcase
+          name = name.to_s.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
+          # 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

@@ -0,0 +1,160 @@
+# 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/http3.rb

@@ -2,65 +2,219 @@
 
 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*')
+    # HTTP/3 Frame Types (RFC 9114)
+    FRAME_DATA = 0x00
+    FRAME_HEADERS = 0x01
+    FRAME_CANCEL_PUSH = 0x03
+    FRAME_SETTINGS = 0x04
+    FRAME_PUSH_PROMISE = 0x05
+    FRAME_GOAWAY = 0x07
+    FRAME_MAX_PUSH_ID = 0x0d
+
+    # QPACK Static Table Indices (RFC 9204 Appendix A)
+    STATIC_TABLE = [
+      [':authority', ''],                                      # 0
+      [':path', '/'],                                          # 1
+      ['age', '0'],                                            # 2
+      ['content-disposition', ''],                             # 3
+      ['content-length', '0'],                                 # 4
+      ['cookie', ''],                                          # 5
+      ['date', ''],                                            # 6
+      ['etag', ''],                                            # 7
+      ['if-modified-since', ''],                               # 8
+      ['if-none-match', ''],                                   # 9
+      ['last-modified', ''],                                   # 10
+      ['link', ''],                                            # 11
+      ['location', ''],                                        # 12
+      ['referer', ''],                                         # 13
+      ['set-cookie', ''],                                      # 14
+      [':method', 'CONNECT'],                                  # 15
+      [':method', 'DELETE'],                                   # 16
+      [':method', 'GET'],                                      # 17
+      [':method', 'HEAD'],                                     # 18
+      [':method', 'OPTIONS'],                                  # 19
+      [':method', 'POST'],                                     # 20
+      [':method', 'PUT'],                                      # 21
+      [':scheme', 'http'],                                     # 22
+      [':scheme', 'https'],                                    # 23
+      [':status', '103'],                                      # 24
+      [':status', '200'],                                      # 25
+      [':status', '304'],                                      # 26
+      [':status', '404'],                                      # 27
+      [':status', '503'],                                      # 28
+      ['accept', '*/*'],                                       # 29
+      ['accept', 'application/dns-message'],                   # 30
+      ['accept-encoding', 'gzip, deflate, br'],                # 31
+      ['accept-ranges', 'bytes'],                              # 32
+      ['access-control-allow-headers', 'cache-control'],       # 33
+      ['access-control-allow-headers', 'content-type'],        # 34
+      ['access-control-allow-origin', '*'],                    # 35
+      ['cache-control', 'max-age=0'],                          # 36
+      ['cache-control', 'max-age=2592000'],                    # 37
+      ['cache-control', 'max-age=604800'],                     # 38
+      ['cache-control', 'no-cache'],                           # 39
+      ['cache-control', 'no-store'],                           # 40
+      ['cache-control', 'public, max-age=31536000'],           # 41
+      ['content-encoding', 'br'],                              # 42
+      ['content-encoding', 'gzip'],                            # 43
+      ['content-type', 'application/dns-message'],             # 44
+      ['content-type', 'application/javascript'],              # 45
+      ['content-type', 'application/json'],                    # 46
+      ['content-type', 'application/x-www-form-urlencoded'],   # 47
+      ['content-type', 'image/gif'],                           # 48
+      ['content-type', 'image/jpeg'],                          # 49
+      ['content-type', 'image/png'],                           # 50
+      ['content-type', 'text/css'],                            # 51
+      ['content-type', 'text/html; charset=utf-8'],            # 52
+      ['content-type', 'text/plain'],                          # 53
+      ['content-type', 'text/plain;charset=utf-8'],            # 54
+      ['range', 'bytes=0-'],                                   # 55
+      ['strict-transport-security', 'max-age=31536000'],       # 56
+      ['strict-transport-security', 'max-age=31536000; includesubdomains'], # 57
+      ['strict-transport-security', 'max-age=31536000; includesubdomains; preload'], # 58
+      ['vary', 'accept-encoding'],                             # 59
+      ['vary', 'origin'],                                      # 60
+      ['x-content-type-options', 'nosniff'],                   # 61
+      ['x-xss-protection', '1; mode=block'],                   # 62
+      [':status', '100'],                                      # 63
+      [':status', '204'],                                      # 64
+      [':status', '206'],                                      # 65
+      [':status', '302'],                                      # 66
+      [':status', '400'],                                      # 67
+      [':status', '403'],                                      # 68
+      [':status', '421'],                                      # 69
+      [':status', '425'],                                      # 70
+      [':status', '500'],                                      # 71
+      ['accept-language', ''],                                 # 72
+      ['access-control-allow-credentials', 'FALSE'],           # 73
+      ['access-control-allow-credentials', 'TRUE'],            # 74
+      ['access-control-allow-headers', '*'],                   # 75
+      ['access-control-allow-methods', 'get'],                 # 76
+      ['access-control-allow-methods', 'get, post, options'],  # 77
+      ['access-control-allow-methods', 'options'],             # 78
+      ['access-control-expose-headers', 'content-length'],     # 79
+      ['access-control-request-headers', 'content-type'],      # 80
+      ['access-control-request-method', 'get'],                # 81
+      ['access-control-request-method', 'post'],               # 82
+      ['alt-svc', 'clear'],                                    # 83
+      ['authorization', ''],                                   # 84
+      ['content-security-policy', "script-src 'none'; object-src 'none'; base-uri 'none'"], # 85
+      ['early-data', '1'],                                     # 86
+      ['expect-ct', ''],                                       # 87
+      ['forwarded', ''],                                       # 88
+      ['if-range', ''],                                        # 89
+      ['origin', ''],                                          # 90
+      ['purpose', 'prefetch'],                                 # 91
+      ['server', ''],                                          # 92
+      ['timing-allow-origin', '*'],                            # 93
+      ['upgrade-insecure-requests', '1'],                      # 94
+      ['user-agent', ''],                                      # 95
+      ['x-forwarded-for', ''],                                 # 96
+      ['x-frame-options', 'deny'],                             # 97
+      ['x-frame-options', 'sameorigin']                        # 98
+    ].freeze
+
+    # Commonly used indices
+    QPACK_AUTHORITY = 0
+    QPACK_PATH = 1
+    QPACK_CONTENT_LENGTH = 4
+    QPACK_METHOD_CONNECT = 15
+    QPACK_METHOD_DELETE = 16
+    QPACK_METHOD_GET = 17
+    QPACK_METHOD_HEAD = 18
+    QPACK_METHOD_OPTIONS = 19
+    QPACK_METHOD_POST = 20
+    QPACK_METHOD_PUT = 21
+    QPACK_SCHEME_HTTP = 22
+    QPACK_SCHEME_HTTPS = 23
+    QPACK_STATUS_200 = 25
+    QPACK_STATUS_404 = 27
+    QPACK_STATUS_500 = 71
+    QPACK_STATUS_400 = 67
+    QPACK_CONTENT_TYPE_JSON = 46
+    QPACK_CONTENT_TYPE_PLAIN = 53
+
+    class << self
+      # Encode variable-length integer
+      def 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
-    end
 
-    def self.build_settings_frame(settings = {})
-      payload = ""
-      settings.each do |id, value|
-        payload += encode_varint(id)
-        payload += encode_varint(value)
+      def build_settings_frame(settings = {})
+        payload = ""
+        settings.each do |id, value|
+          payload += encode_varint(id)
+          payload += encode_varint(value)
+        end
+
+        frame_type = encode_varint(FRAME_SETTINGS)
+        frame_length = encode_varint(payload.bytesize)
+
+        frame_type + frame_length + payload
       end
 
-      frame_type = encode_varint(0x04)  # SETTINGS
-      frame_length = encode_varint(payload.bytesize)
+      # Build control stream data
+      def build_control_stream
+        stream_type = [0x00].pack('C')  # Control stream type
+        settings = build_settings_frame({})
 
-      frame_type + frame_length + payload
-    end
+        stream_type + settings
+      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)
-      })
+      # Build GOAWAY frame (RFC 9114 Section 7.2.6)
+      # stream_id: The last client-initiated bidirectional stream ID the server will process
+      def build_goaway_frame(stream_id)
+        frame_type = encode_varint(FRAME_GOAWAY)
+        payload = encode_varint(stream_id)
+        frame_length = encode_varint(payload.bytesize)
 
-      stream_type + settings
-    end
+        frame_type + frame_length + payload
+      end
+
+      # Maximum stream ID for initial GOAWAY (2^62 - 4, per RFC 9114)
+      MAX_STREAM_ID = (2**62) - 4
+
+      # Decode variable-length integer (RFC 9000)
+      # Returns [value, bytes_consumed]
+      def decode_varint(bytes, offset = 0)
+        return [0, 0] if offset >= bytes.size
+
+        first = bytes[offset]
+        return [0, 0] if first.nil?
+
+        prefix = (first & 0xC0) >> 6 # Extract 2 MSB
+        length = 1 << prefix # 1, 2, 4, or 8 bytes
+
+        # Check if we have enough bytes
+        return [0, 0] if offset + length > bytes.size
 
-    # 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]
+        case prefix
+        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/quic_stream.rb

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