quicsilver 0.3.0 → 0.4.0

data/lib/quicsilver/protocol/frame_parser.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "frame_reader"
+require_relative "qpack/header_block_decoder"
+
+module Quicsilver
+  module Protocol
+    # Base class for HTTP/3 request and response frame parsing.
+    #
+    # Handles the shared frame walking loop, HEADERS→DATA→HEADERS ordering,
+    # trailer parsing, body accumulation, and size limit enforcement.
+    #
+    # Subclasses implement:
+    #   - parse_headers(payload) — decode the first HEADERS frame
+    class FrameParser
+      # Frame types forbidden on request streams — use hash for O(1) lookup
+      # Static-only QPACK decoder (no dynamic table). Used by default.
+      # Inject a custom decoder via decoder: kwarg for dynamic QPACK support.
+      DEFAULT_DECODER = Qpack::HeaderBlockDecoder.default
+
+      CONTROL_ONLY_SET = Protocol::CONTROL_ONLY_FRAMES.each_with_object({}) { |f, h| h[f] = true }.freeze
+
+      EMPTY_BODY = StringIO.new("".b).tap { |io| io.set_encoding(Encoding::ASCII_8BIT) }
+
+      attr_reader :headers, :trailers, :bytes_consumed
+
+      def frames
+        @frames || []
+      end
+
+      def initialize(decoder:, max_body_size: nil, max_header_size: nil, max_header_count: nil, max_frame_payload_size: nil)
+        @decoder = decoder
+        @max_body_size = max_body_size
+        @max_header_size = max_header_size
+        @max_header_count = max_header_count
+        @max_frame_payload_size = max_frame_payload_size
+        @headers = {}
+        @trailers = {}
+      end
+
+      def body
+        if @body
+          @body.rewind
+          @body
+        elsif @cached_body_str
+          @body = StringIO.new(@cached_body_str)
+          @body.set_encoding(Encoding::ASCII_8BIT)
+          @body
+        else
+          EMPTY_BODY
+        end
+      end
+
+      private
+
+      def parse!
+        walk_frames(@data)
+      end
+
+      def walk_frames(buffer)
+        @headers = {}
+        @trailers = {}
+        @body = nil
+        @frames = nil
+        @bytes_consumed = 0
+        headers_received = false
+        trailers_received = false
+
+        @bytes_consumed = FrameReader.each(buffer) do |type, payload|
+          if @max_frame_payload_size && payload.bytesize > @max_frame_payload_size
+            raise Protocol::FrameError, "Frame payload #{payload.bytesize} exceeds limit #{@max_frame_payload_size}"
+          end
+
+          (@frames ||= []) << { type: type, length: payload.bytesize, payload: payload }
+
+          if CONTROL_ONLY_SET.key?(type)
+            raise Protocol::FrameError, "Frame type 0x#{type.to_s(16)} not allowed on request streams"
+          end
+
+          case type
+          when 0x01 # HEADERS
+            if @max_header_size && payload.bytesize > @max_header_size
+              raise Protocol::MessageError, "Header block #{payload.bytesize} exceeds limit #{@max_header_size}"
+            end
+            if trailers_received
+              raise Protocol::FrameError, "HEADERS frame after trailers"
+            elsif headers_received
+              parse_trailers(payload)
+              trailers_received = true
+            else
+              parse_headers(payload)
+              headers_received = true
+            end
+          when 0x00 # DATA
+            raise Protocol::FrameError, "DATA frame before HEADERS" unless headers_received
+            raise Protocol::FrameError, "DATA frame after trailers" if trailers_received
+            unless @body
+              @body = StringIO.new
+              @body.set_encoding(Encoding::ASCII_8BIT)
+            end
+            @body.write(payload)
+            if @max_body_size && @body.size > @max_body_size
+              raise Protocol::MessageError, "Body size #{@body.size} exceeds limit #{@max_body_size}"
+            end
+          end
+        end
+
+        @body&.rewind
+      end
+
+      # RFC 9110 §5.3: Combine duplicate header values.
+      # - set-cookie: join with "\n" (Rack convention, MUST NOT combine with comma)
+      # - cookie: join with "; " (RFC 9114 §4.2.1)
+      # - all others: join with ", "
+      def store_header(name, value)
+        if @headers.key?(name)
+          separator = case name
+            when "set-cookie" then "\n"
+            when "cookie" then "; "
+            else ", "
+          end
+          @headers[name] = "#{@headers[name]}#{separator}#{value}"
+        else
+          if @max_header_count && @headers.size >= @max_header_count
+            raise Protocol::MessageError, "Header count exceeds limit #{@max_header_count}"
+          end
+          @headers[name] = value
+        end
+      end
+
+      def parse_trailers(payload)
+        @decoder.decode(payload) do |name, value|
+          if name.start_with?(":")
+            raise Protocol::MessageError, "Pseudo-header '#{name}' in trailers"
+          end
+          @trailers[name] = value
+        end
+      end
+    end
+  end
+end

data/lib/quicsilver/protocol/frame_reader.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  module Protocol
+    # Extracts HTTP/3 frames from a byte buffer.
+    # Yields [type, payload] pairs. No protocol semantics — just byte-level extraction.
+    #
+    # Usage:
+    #   FrameReader.each(buffer) do |type, payload|
+    #     case type
+    #     when FRAME_HEADERS then ...
+    #     when FRAME_DATA then ...
+    #     end
+    #   end
+    module FrameReader
+      def self.each(buffer)
+        offset = 0
+        buf_size = buffer.bytesize
+
+        while offset < buf_size
+          break if buf_size - offset < 2
+
+          # Inline single-byte varint fast path (covers frame types 0x00-0x3F)
+          type_byte = buffer.getbyte(offset)
+          if type_byte < 0x40
+            type = type_byte
+            type_len = 1
+          else
+            type, type_len = Protocol.decode_varint_str(buffer, offset)
+            break if type_len == 0
+          end
+
+          len_byte = buffer.getbyte(offset + type_len)
+          if len_byte < 0x40
+            length = len_byte
+            length_len = 1
+          else
+            length, length_len = Protocol.decode_varint_str(buffer, offset + type_len)
+            break if length_len == 0
+          end
+
+          header_len = type_len + length_len
+          break if buf_size < offset + header_len + length
+
+          payload = buffer.byteslice(offset + header_len, length)
+          offset += header_len + length
+
+          yield type, payload
+        end
+
+        offset
+      end
+    end
+  end
+end

data/lib/quicsilver/protocol/frames.rb

@@ -10,6 +10,7 @@ module Quicsilver
     FRAME_PUSH_PROMISE = 0x05
     FRAME_GOAWAY = 0x07
     FRAME_MAX_PUSH_ID = 0x0d
+    FRAME_PRIORITY_UPDATE = 0xF0700  # RFC 9218 — request stream priority update
 
     # Frame types forbidden on request streams (RFC 9114 Section 7.2.4, 7.2.6, 7.2.7)
     CONTROL_ONLY_FRAMES = [FRAME_CANCEL_PUSH, FRAME_SETTINGS, FRAME_GOAWAY, FRAME_MAX_PUSH_ID].freeze
@@ -230,15 +231,25 @@ module Quicsilver
         frame_type + frame_length + payload
       end
 
+      # Generate a random GREASE ID (RFC 9297): 31 * n + 33
+      def grease_id
+        31 * rand(0..20) + 33
+      end
+
       # Build control stream data
-      def build_control_stream
+      # @param max_field_section_size [Integer, nil] Advertise SETTINGS_MAX_FIELD_SECTION_SIZE (0x06)
+      #   to the peer (RFC 9114 §4.2.2 / §7.2.4.1). nil = don't advertise.
+      def build_control_stream(max_field_section_size: nil)
         stream_type = [0x00].pack('C')  # Control stream type
-        settings = build_settings_frame({
-          0x01 => 0,  # QPACK_MAX_TABLE_CAPACITY = 0 (no dynamic table)
-          0x07 => 0   # QPACK_BLOCKED_STREAMS = 0
-        })
-
-        stream_type + settings
+        settings_hash = {
+          0x01 => 0,           # QPACK_MAX_TABLE_CAPACITY = 0 (no dynamic table)
+          0x07 => 0,           # QPACK_BLOCKED_STREAMS = 0
+          0x08 => 1,           # SETTINGS_ENABLE_CONNECT_PROTOCOL (RFC 9220)
+        }
+        settings_hash[0x06] = max_field_section_size if max_field_section_size  # SETTINGS_MAX_FIELD_SECTION_SIZE
+        settings_hash[grease_id] = grease_id  # GREASE setting (RFC 9297)
+
+        stream_type + build_settings_frame(settings_hash)
       end
 
       # Build GOAWAY frame (RFC 9114 Section 7.2.6)

data/lib/quicsilver/protocol/priority.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  module Protocol
+    # HTTP Extensible Priorities (RFC 9218).
+    #
+    # Parses the `priority` header from HTTP requests. Urgency ranges from
+    # 0 (highest) to 7 (lowest), defaulting to 3. Incremental indicates
+    # whether partial data is useful to the client (e.g. progressive images).
+    #
+    # Usage:
+    #   priority = Priority.parse("u=0, i")
+    #   priority.urgency     # => 0
+    #   priority.incremental # => true
+    #
+    #   priority = Priority.parse(nil)  # default
+    #   priority.urgency     # => 3
+    #   priority.incremental # => false
+    class Priority
+      DEFAULT_URGENCY = 3
+      MIN_URGENCY = 0
+      MAX_URGENCY = 7
+
+      attr_reader :urgency, :incremental
+
+      def initialize(urgency: DEFAULT_URGENCY, incremental: false)
+        @urgency = urgency.clamp(MIN_URGENCY, MAX_URGENCY)
+        @incremental = incremental
+      end
+
+      # Parse a priority header value (RFC 9218 §4, Structured Field Values).
+      # Returns a Priority with defaults for missing or invalid values.
+      def self.parse(value)
+        return new unless value && !value.empty?
+
+        urgency = DEFAULT_URGENCY
+        incremental = false
+
+        value.split(",").each do |param|
+          param = param.strip
+          if param.start_with?("u=")
+            urgency = param[2..].to_i
+          elsif param == "i"
+            incremental = true
+          elsif param == "i=?0"
+            incremental = false
+          elsif param == "i=?1"
+            incremental = true
+          end
+        end
+
+        new(urgency: urgency, incremental: incremental)
+      end
+    end
+  end
+end

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

@@ -71,7 +71,7 @@ module Quicsilver
             name = name.to_s
             value = value.to_s
             # Downcase only if needed (most HTTP/3 headers are already lowercase)
-            name = name.downcase if name =~ /[A-Z]/
+            name = name.downcase if name.match?(/[A-Z]/)
 
             cache_key = "#{name}\0#{value}"
 
@@ -166,8 +166,46 @@ module Quicsilver
           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

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

@@ -51,7 +51,22 @@ module Quicsilver
           end
 
           headers = []
-          offset = 2 # skip required insert count + delta base prefix
+
+          # 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)

data/lib/quicsilver/protocol/request_parser.rb

@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 
-require "stringio"
-require_relative "qpack/header_block_decoder"
+require_relative "frame_parser"
+require_relative "priority"
 
 module Quicsilver
   module Protocol
-    class RequestParser
-      attr_reader :headers
+    class RequestParser < FrameParser
 
-      def frames
-        @frames || []
+      # The parsed priority from the `priority` header (RFC 9218).
+      # Returns a Priority with defaults if no header present.
+      def priority
+        @priority ||= Priority.parse(@headers["priority"])
       end
 
+      METHOD_CONNECT = "CONNECT"
+
       # Known HTTP/3 request pseudo-headers (RFC 9114 §4.3.1)
       VALID_PSEUDO_HEADERS = %w[:method :scheme :authority :path :protocol].freeze
       VALID_PSEUDO_SET = VALID_PSEUDO_HEADERS.each_with_object({}) { |h, s| s[h] = true }.freeze
@@ -20,35 +23,26 @@ module Quicsilver
       FORBIDDEN_HEADERS = %w[connection transfer-encoding keep-alive upgrade proxy-connection te].freeze
       FORBIDDEN_SET = FORBIDDEN_HEADERS.each_with_object({}) { |h, s| s[h] = true }.freeze
 
-      # Frame types forbidden on request streams — use Set-like hash for O(1) lookup
-      CONTROL_ONLY_SET = Protocol::CONTROL_ONLY_FRAMES.each_with_object({}) { |f, h| h[f] = true }.freeze
-
       # Cache for validated header results: payload → headers hash
       # Only used when no custom limits are set (max_header_count, max_header_size)
       HEADERS_CACHE = {}
       HEADERS_CACHE_MAX = 256
 
-      DEFAULT_DECODER = Qpack::HeaderBlockDecoder.default
-
       def initialize(data, **opts)
+        decoder = opts.delete(:decoder) || DEFAULT_DECODER
+        super(decoder: decoder, max_body_size: opts[:max_body_size],
+              max_header_size: opts[:max_header_size],
+              max_header_count: opts[:max_header_count],
+              max_frame_payload_size: opts[:max_frame_payload_size])
         @data = data
-        if opts.empty?
-          @decoder = DEFAULT_DECODER
-          @use_parse_cache = true
-        else
-          @decoder = opts[:decoder] || DEFAULT_DECODER
-          @max_body_size = opts[:max_body_size]
-          @max_header_size = opts[:max_header_size]
-          @max_header_count = opts[:max_header_count]
-          @max_frame_payload_size = opts[:max_frame_payload_size]
-          @use_parse_cache = @decoder.equal?(DEFAULT_DECODER) && !@max_body_size && !@max_header_size && !@max_header_count && !@max_frame_payload_size
-        end
+        @use_parse_cache = @decoder.equal?(DEFAULT_DECODER) && !@max_body_size && !@max_header_size && !@max_header_count && !@max_frame_payload_size
       end
 
       # Reset parser with new data for object reuse (avoids allocation overhead)
       def reset(data)
         @data = data
-        @headers = nil
+        @headers = {}
+        @trailers = {}
         @frames = nil
         @body = nil
         @cached_body_str = nil
@@ -76,7 +70,8 @@ module Quicsilver
             return
           end
         end
-        @headers = nil
+        @headers = {}
+        @trailers = {}
         @frames = nil
         @body = nil
         @cached_body_str = nil
@@ -84,20 +79,6 @@ module Quicsilver
         cache_result if @use_parse_cache
       end
 
-      def body
-        if @body
-          @body
-        elsif @cached_body_str
-          @body = StringIO.new(@cached_body_str)
-          @body.set_encoding(Encoding::ASCII_8BIT)
-          @body
-        else
-          EMPTY_BODY
-        end
-      end
-
-      EMPTY_BODY = StringIO.new("".b).tap { |io| io.set_encoding(Encoding::ASCII_8BIT) }
-
       # Class-level parse result cache
       PARSE_CACHE = {}
       PARSE_CACHE_MAX = 128
@@ -146,7 +127,13 @@ module Quicsilver
 
         method = @headers[":method"]
 
-        if method == "CONNECT"
+        if method == METHOD_CONNECT && @headers[":protocol"]
+          # Extended CONNECT (RFC 9220) — requires :scheme, :path, :authority, :protocol
+          raise Protocol::MessageError, "Extended CONNECT must include :scheme" unless @headers[":scheme"]
+          raise Protocol::MessageError, "Extended CONNECT must include :path" unless @headers[":path"]
+          raise Protocol::MessageError, "Extended CONNECT must include :authority" unless @headers[":authority"]
+        elsif method == METHOD_CONNECT
+          # Regular CONNECT (RFC 9114 §4.4)
           raise Protocol::MessageError, "CONNECT request must include :authority" unless @headers[":authority"]
           raise Protocol::MessageError, "CONNECT request must not include :scheme" if @headers[":scheme"]
           raise Protocol::MessageError, "CONNECT request must not include :path" if @headers[":path"]
@@ -168,15 +155,6 @@ module Quicsilver
             raise Protocol::MessageError, ":authority and host header must be consistent"
           end
         end
-
-        # Content-length vs body size (RFC 9114 §4.1.2)
-        if @headers["content-length"]
-          expected = @headers["content-length"].to_i
-          actual = body.size
-          unless expected == actual
-            raise Protocol::MessageError, "Content-length mismatch: header=#{expected}, body=#{actual}"
-          end
-        end
       end
 
       def to_rack_env(stream_info = {})
@@ -184,7 +162,7 @@ module Quicsilver
 
         method = @headers[":method"]
 
-        if method == "CONNECT"
+        if method == METHOD_CONNECT
           return nil unless @headers[":authority"]
         else
           return nil unless method && @headers[":scheme"] && @headers[":path"]
@@ -237,76 +215,6 @@ module Quicsilver
 
       private
 
-      def parse!
-        @headers = {}
-        buffer = @data
-        offset = 0
-        headers_received = false
-        buf_size = buffer.bytesize
-
-        while offset < buf_size
-          break if buf_size - offset < 2
-
-          # Inline single-byte varint fast path (covers frame types 0x00-0x3F)
-          type_byte = buffer.getbyte(offset)
-          if type_byte < 0x40
-            type = type_byte
-            type_len = 1
-          else
-            type, type_len = Protocol.decode_varint_str(buffer, offset)
-          end
-
-          len_byte = buffer.getbyte(offset + type_len)
-          if len_byte < 0x40
-            length = len_byte
-            length_len = 1
-          else
-            length, length_len = Protocol.decode_varint_str(buffer, offset + type_len)
-            break if length_len == 0
-          end
-          break if type_len == 0
-
-          header_len = type_len + length_len
-
-          break if buf_size < offset + header_len + length
-
-          payload = buffer.byteslice(offset + header_len, length)
-
-          if @max_frame_payload_size && length > @max_frame_payload_size
-            raise Protocol::FrameError, "Frame payload #{length} exceeds limit #{@max_frame_payload_size}"
-          end
-
-          (@frames ||= []) << { type: type, length: length, payload: payload }
-
-          if CONTROL_ONLY_SET.key?(type)
-            raise Protocol::FrameError, "Frame type 0x#{type.to_s(16)} not allowed on request streams"
-          end
-
-          case type
-          when 0x01 # HEADERS
-            if @max_header_size && length > @max_header_size
-              raise Protocol::MessageError, "Header block #{length} exceeds limit #{@max_header_size}"
-            end
-            parse_headers(payload)
-            headers_received = true
-          when 0x00 # DATA
-            raise Protocol::FrameError, "DATA frame before HEADERS" unless headers_received
-            unless @body
-              @body = StringIO.new
-              @body.set_encoding(Encoding::ASCII_8BIT)
-            end
-            @body.write(payload)
-            if @max_body_size && @body.size > @max_body_size
-              raise Protocol::MessageError, "Body size #{@body.size} exceeds limit #{@max_body_size}"
-            end
-          end
-
-          offset += header_len + length
-        end
-
-        @body&.rewind
-      end
-
       # Decode QPACK header block and validate per RFC 9114 §4.2 and §4.3.1:
       # - Header names MUST be lowercase
       # - Pseudo-headers MUST appear before regular headers
@@ -329,7 +237,7 @@ module Quicsilver
 
         @decoder.decode(payload) do |name, value|
           # RFC 9114 §4.2: Header field names MUST be lowercase
-          if name =~ /[A-Z]/
+          if name.match?(/[A-Z]/)
             raise Protocol::MessageError, "Header name '#{name}' contains uppercase characters"
           end
 
@@ -362,26 +270,6 @@ module Quicsilver
           HEADERS_CACHE[key] = @headers.dup.freeze
         end
       end
-
-      # RFC 9110 §5.3: Combine duplicate header values.
-      # - set-cookie: join with "\n" (Rack convention, MUST NOT combine with comma)
-      # - cookie: join with "; " (RFC 9114 §4.2.1)
-      # - all others: join with ", "
-      def store_header(name, value)
-        if @headers.key?(name)
-          separator = case name
-            when "set-cookie" then "\n"
-            when "cookie" then "; "
-            else ", "
-          end
-          @headers[name] = "#{@headers[name]}#{separator}#{value}"
-        else
-          if @max_header_count && @headers.size >= @max_header_count
-            raise Protocol::MessageError, "Header count exceeds limit #{@max_header_count}"
-          end
-          @headers[name] = value
-        end
-      end
     end
   end
 end

data/lib/quicsilver/protocol/response_encoder.rb

@@ -3,12 +3,27 @@
 module Quicsilver
   module Protocol
     class ResponseEncoder
-      def initialize(status, headers, body, encoder: Qpack::Encoder.new, head_request: false)
+      # Encode an informational (1xx) response as a single HEADERS frame.
+      # RFC 9114 §4.1: informational responses are encoded as HEADERS with no body.
+      def self.encode_informational(status, headers, encoder: Qpack::Encoder.new)
+        raise ArgumentError, "Informational status must be 1xx, got #{status}" unless (100..199).include?(status)
+
+        pairs = [[":status", status.to_s]]
+        headers.each { |name, value| pairs << [name.to_s.downcase, value.to_s] }
+        encoded = encoder.encode(pairs)
+
+        Protocol.encode_varint(FRAME_HEADERS) +
+          Protocol.encode_varint(encoded.bytesize) +
+          encoded
+      end
+
+      def initialize(status, headers, body, encoder: Qpack::Encoder.new, head_request: false, trailers: nil)
         @status = status
         @headers = headers
         @body = body
         @encoder = encoder
         @head_request = head_request
+        @trailers = trailers
       end
 
       # Buffered encode - returns all frames at once
@@ -20,6 +35,7 @@ module Quicsilver
             frames << build_frame(FRAME_DATA, chunk) unless chunk.empty?
           end
         end
+        frames << build_frame(FRAME_HEADERS, @encoder.encode(trailer_headers)) if @trailers&.any?
         @body.close if @body.respond_to?(:close)
         frames
       end
@@ -35,7 +51,10 @@ module Quicsilver
             last_chunk = chunk
           end
 
-          if last_chunk && !last_chunk.empty?
+          if @trailers&.any?
+            yield build_frame(FRAME_DATA, last_chunk), false if last_chunk && !last_chunk.empty?
+            yield build_frame(FRAME_HEADERS, @encoder.encode(trailer_headers)), true
+          elsif last_chunk && !last_chunk.empty?
             yield build_frame(FRAME_DATA, last_chunk), true
           else
             yield "".b, true
@@ -63,10 +82,16 @@ module Quicsilver
         headers
       end
 
+      def trailer_headers
+        @trailers.map { |name, value| [name.to_s.downcase, value.to_s] }
+      end
+
       def build_frame(type, payload)
         payload = payload.to_s.b
         Protocol.encode_varint(type) + Protocol.encode_varint(payload.bytesize) + payload
       end
+
+
     end
   end
 end