quicsilver 0.5.0-x86_64-linux

data/lib/quicsilver/protocol/qpack/encoder.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+require_relative "huffman"
+
+module Quicsilver
+  module Protocol
+    module Qpack
+      class Encoder
+        STATIC_TABLE = Protocol::STATIC_TABLE
+
+        # Pre-built hash for O(1) static table lookups
+        STATIC_LOOKUP_FULL = {} # "name\0value" => index
+        STATIC_LOOKUP_NAME = {} # name => first_index
+
+        STATIC_TABLE.each_with_index do |(tbl_name, tbl_value), idx|
+          STATIC_LOOKUP_FULL["#{tbl_name}\0#{tbl_value}".freeze] = idx
+          STATIC_LOOKUP_NAME[tbl_name] ||= idx
+        end
+        STATIC_LOOKUP_FULL.freeze
+        STATIC_LOOKUP_NAME.freeze
+
+        PREFIX = "\x00\x00".b.freeze
+
+        FIELD_CACHE_MAX = 512
+
+        def initialize(huffman: true)
+          @huffman = huffman
+          @field_cache = {}
+          @block_cache = {}
+        end
+
+        # Caches are keyed by header content, never by identity or object_id:
+        # callers may reuse and mutate the same array, and an identity hit
+        # would return the previous encoding.
+        #
+        # Caching a whole field block is only sound because encoding is
+        # static-table-only: Required Insert Count is always zero, so the bytes
+        # never depend on connection state. Implementing the dynamic table
+        # would invalidate @block_cache, since indices are relative to a Base.
+        def encode(headers)
+          if headers.is_a?(Array) && headers.size <= 16
+            # Content-based caching for small header sets
+            block_key = headers.map { |n, v| "#{n}\0#{v}" }.join("\x01")
+            cached_block = @block_cache[block_key]
+            return cached_block if cached_block
+
+            result_frozen = encode_fields(headers).freeze
+            if @block_cache.size < BLOCK_CACHE_MAX
+              @block_cache[block_key.freeze] = result_frozen
+            end
+            return result_frozen
+          end
+
+          encode_fields(headers)
+        end
+
+        BLOCK_CACHE_MAX = 128
+
+        private def encode_fields(headers)
+          out = encode_prefix
+          headers.each do |name, value|
+            name = name.to_s
+            value = value.to_s
+            # Downcase only if needed (most HTTP/3 headers are already lowercase)
+            name = name.downcase if name.match?(/[A-Z]/)
+
+            cache_key = "#{name}\0#{value}"
+
+            # Check field cache
+            cached = @field_cache[cache_key]
+            if cached
+              out << cached
+              next
+            end
+
+            field_start = out.bytesize
+
+            full_idx = STATIC_LOOKUP_FULL[cache_key]
+
+            if full_idx
+              # Indexed Field Line
+              out << encode_prefixed_int(full_idx, 6, 0xC0)
+            else
+              name_idx = STATIC_LOOKUP_NAME[name]
+              if name_idx
+                # Literal with Name Reference
+                out << encode_prefixed_int(name_idx, 4, 0x50)
+                encode_str_into(out, value)
+              else
+                # Literal with Literal Name
+                encode_literal_into(out, name, value)
+              end
+            end
+
+            # Cache the encoded field bytes
+            if @field_cache.size < FIELD_CACHE_MAX
+              @field_cache[cache_key.freeze] = out.byteslice(field_start..).freeze
+            end
+          end
+          out
+        end
+
+        def lookup(name, value)
+          name = name.to_s.downcase
+          value = value.to_s
+          full_idx = STATIC_LOOKUP_FULL["#{name}\0#{value}"]
+          return [full_idx, true] if full_idx
+          name_idx = STATIC_LOOKUP_NAME[name]
+          name_idx ? [name_idx, false] : nil
+        end
+
+        def encode_prefix
+          PREFIX.dup
+        end
+
+        # Public API for encoding a single string value (used by tests/external code)
+        def encode_str(value)
+          out = "".b
+          encode_str_into(out, value.to_s)
+          out
+        end
+
+        private
+
+        # Pattern 1: Indexed Field Line (1xxxxxxx) — kept for test compatibility
+        def encode_indexed(index)
+          encode_prefixed_int(index, 6, 0xC0)
+        end
+
+        def encode_literal_into(out, name, value)
+          name_b = name.b
+          if @huffman
+            huffman_name = Huffman.encode(name_b)
+            if huffman_name.bytesize < name_b.bytesize
+              out << encode_prefixed_int(huffman_name.bytesize, 3, 0x28)
+              out << huffman_name
+              encode_str_into(out, value)
+              return
+            end
+          end
+          out << encode_prefixed_int(name_b.bytesize, 3, 0x20)
+          out << name_b
+          encode_str_into(out, value)
+        end
+
+        def encode_str_into(out, value)
+          value_b = value.b
+          if @huffman
+            huffman = Huffman.encode(value_b)
+            if huffman.bytesize < value_b.bytesize
+              out << encode_prefixed_int(huffman.bytesize, 7, 0x80)
+              out << huffman
+              return
+            end
+          end
+          out << encode_prefixed_int(value_b.bytesize, 7, 0x00)
+          out << value_b
+        end
+
+        # Pre-computed prefix integer tables for hot encode paths.
+        # Key: [prefix_bits, pattern] => Array of frozen encoded strings indexed by value.
+        # Covers all values up to max_prefix (single-byte) and a range beyond.
+        PREFIXED_INT_CACHE = {}
+        [
+          [6, 0xC0],  # Indexed Field Line
+          [4, 0x50],  # Literal with Name Reference (static)
+          [7, 0x80],  # Huffman string length
+          [7, 0x00],  # Raw string length
+          [3, 0x28],  # Huffman literal name length
+          [3, 0x20],  # Raw literal name length
+        ].each do |prefix_bits, pattern|
+          max_prefix = (1 << prefix_bits) - 1
+          # Pre-compute single-byte range + a bit beyond for multi-byte
+          limit = [max_prefix + 64, 256].min
+          table = Array.new(limit) do |value|
+            if value < max_prefix
+              (pattern | value).chr(Encoding::BINARY).freeze
+            else
+              buf = (pattern | max_prefix).chr(Encoding::BINARY)
+              v = value - max_prefix
+              while v >= 128
+                buf << ((v & 0x7F) | 0x80).chr(Encoding::BINARY)
+                v >>= 7
+              end
+              buf << v.chr(Encoding::BINARY)
+              buf.freeze
+            end
+          end
+          PREFIXED_INT_CACHE[[prefix_bits, pattern]] = table.freeze
+        end
+        PREFIXED_INT_CACHE.freeze
+
+        # RFC 7541 prefix integer encoding
+        def encode_prefixed_int(value, prefix_bits, pattern)
+          table = PREFIXED_INT_CACHE[[prefix_bits, pattern]]
+          if table && value < table.size
+            return table[value]
+          end
+
+          max_prefix = (1 << prefix_bits) - 1
+
+          if value < max_prefix
+            (pattern | value).chr(Encoding::BINARY)
+          else
+            buf = (pattern | max_prefix).chr(Encoding::BINARY)
+            value -= max_prefix
+            while value >= 128
+              buf << ((value & 0x7F) | 0x80).chr(Encoding::BINARY)
+              value >>= 7
+            end
+            buf << value.chr(Encoding::BINARY)
+            buf
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quicsilver/protocol/qpack/header_block_decoder.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative "decoder"
+require_relative "huffman"
+
+module Quicsilver
+  module Protocol
+    module Qpack
+      # Decodes a QPACK header block into [name, value] pairs.
+      #
+      # Default implementation uses the static table only (no dynamic table).
+      # To add dynamic table support, implement a class with the same #decode interface:
+      #
+      #   class MyDynamicDecoder
+      #     def decode(payload)
+      #       # parse QPACK field lines from payload
+      #       # yield [name, value] for each decoded header
+      #     end
+      #   end
+      #
+      # Then inject it:
+      #   RequestParser.new(data, decoder: MyDynamicDecoder.new)
+      #   ResponseParser.new(data, decoder: MyDynamicDecoder.new)
+      #
+      class HeaderBlockDecoder
+        include Decoder
+
+        DECODE_CACHE_MAX = 256
+
+        # Shared default instance for parsers that don't need custom decoders
+        def self.default
+          @default ||= new
+        end
+
+        def initialize
+          @decode_cache = {}
+        end
+
+        # Decode a QPACK header block payload (RFC 9204 §4.5).
+        # Yields [name, value] for each decoded field line.
+        def decode(payload)
+          return if payload.nil? || payload.bytesize < 2
+
+          # Check cache for previously decoded payloads
+          if payload.bytesize <= 256
+            cached = @decode_cache[payload]
+            if cached
+              cached.each { |name, value| yield name, value }
+              return
+            end
+          end
+
+          headers = []
+
+          # Decode Required Insert Count (RFC 9204 §4.5.1) — 8-bit prefix integer
+          required_insert_count, ric_bytes = decode_prefix_integer_str(payload, 0, 8, 0x00)
+          offset = ric_bytes
+
+          # Decode Delta Base (RFC 9204 §4.5.1) — 7-bit prefix integer with sign bit
+          delta_base, db_bytes = decode_prefix_integer_str(payload, offset, 7, 0x80)
+          offset += db_bytes
+
+          # Static-only mode: Required Insert Count and Delta Base must be 0
+          if required_insert_count != 0 || delta_base != 0
+            raise Protocol::FrameError.new(
+              "Dynamic QPACK table not supported (required_insert_count=#{required_insert_count}, delta_base=#{delta_base})",
+              error_code: Protocol::QPACK_DECOMPRESSION_FAILED
+            )
+          end
+
+          while offset < payload.bytesize
+            byte = payload.getbyte(offset)
+
+            # Indexed Field Line (1Txxxxxx) — name + value from static table
+            if (byte & 0x80) == 0x80
+              index, bytes_consumed = decode_prefix_integer_str(payload, offset, 6, 0xC0)
+              offset += bytes_consumed
+
+              if index < Protocol::STATIC_TABLE.size
+                name, value = Protocol::STATIC_TABLE[index]
+                headers << [name, value]
+                yield name, value
+              else
+                raise Protocol::FrameError.new(
+                  "Invalid QPACK static table index #{index}",
+                  error_code: Protocol::QPACK_DECOMPRESSION_FAILED
+                )
+              end
+
+            # Literal with Name Reference (01NTxxxx) — name from static table, literal value
+            elsif (byte & 0xC0) == 0x40
+              index, bytes_consumed = decode_prefix_integer_str(payload, offset, 4, 0xF0)
+              offset += bytes_consumed
+
+              if index >= Protocol::STATIC_TABLE.size
+                raise Protocol::FrameError.new(
+                  "Invalid QPACK static table index #{index}",
+                  error_code: Protocol::QPACK_DECOMPRESSION_FAILED
+                )
+              end
+
+              name = Protocol::STATIC_TABLE[index][0]
+              value, consumed = decode_qpack_string_from_str(payload, offset)
+              offset += consumed
+              headers << [name, value]
+              yield name, value
+
+            # Literal with Literal Name (001NHxxx) — both name and value are literals
+            elsif (byte & 0xE0) == 0x20
+              huffman_name = (byte & 0x08) != 0
+              name_len, name_len_bytes = decode_prefix_integer_str(payload, offset, 3, 0x28)
+              offset += name_len_bytes
+              raw_name = payload.byteslice(offset, name_len)
+              name = if huffman_name
+                Huffman.decode(raw_name) || raw_name
+              else
+                raw_name
+              end
+              offset += name_len
+
+              value, consumed = decode_qpack_string_from_str(payload, offset)
+              offset += consumed
+
+              headers << [name, value]
+              yield name, value
+            else
+              break
+            end
+          end
+
+          # Cache the result
+          if payload.bytesize <= 256 && @decode_cache.size < DECODE_CACHE_MAX
+            key = payload.frozen? ? payload : payload.dup.freeze
+            @decode_cache[key] = headers.freeze
+          end
+        end
+      end
+    end
+  end
+end