http-2 1.1.2 → 1.2.0

data/lib/http/2/framer.rb

@@ -1,6 +1,25 @@
 # frozen_string_literal: true
 
 module HTTP2
+  # Frame flags as defined by the spec (max 255 bits)
+  # DATA:          ( X X COMPRESSED X PADDED X X END_STREAM )
+  # HEADERS:       ( X X PRIORITY X PADDED END_HEADERS X END_STREAM )
+  # PRIORITY:      ( X X X X X X X X )
+  # RST_STREAM:    ( X X X X X X X X )
+  # SETTINGS:      ( X X X X X X X ACK )
+  # PUSH_PROMISE:  ( X X X X PADDED END_HEADERS X X )
+  # PING:          ( X X X X X X X ACK )
+  # GOAWAY:        ( X X X X X X X X )
+  # WINDOW_UPDATE: ( X X X X X X X X )
+  # CONTINUATION:  ( X X X X X END_HEADERS X X )
+  # ALTSVC:        ( X X X X X X X X )
+  # ORIGIN:        ( RESERVED4 X X RESERVED3 X RESERVED2 RESERVED X )
+  END_STREAM = ACK = 0b0001 # 1
+  RESERVED = 0b0010 # 2
+  END_HEADERS = 0b0100 # 4
+  PADDED = 0b1000 # 8
+  PRIORITY = 0b0010_0000 # 32
+
   # Performs encoding, decoding, and validation of binary HTTP/2 frames.
   #
   class Framer
@@ -40,39 +59,6 @@ module HTTP2
 
     FRAME_TYPES_WITH_PADDING = %i[data headers push_promise].freeze
 
-    # Per frame flags as defined by the spec
-    FRAME_FLAGS = {
-      data: {
-        end_stream: 0,
-        padded: 3,
-        compressed: 5
-      },
-      headers: {
-        end_stream: 0,
-        end_headers: 2,
-        padded: 3,
-        priority: 5
-      },
-      priority: {},
-      rst_stream: {},
-      settings: { ack: 0 },
-      push_promise: {
-        end_headers: 2,
-        padded: 3
-      },
-      ping: { ack: 0 },
-      goaway: {},
-      window_update: {},
-      continuation: { end_headers: 2 },
-      altsvc: {},
-      origin: {
-        reserved: 1,
-        reserved2: 2,
-        reserved3: 4,
-        reserved4: 8
-      }
-    }.each_value(&:freeze).freeze
-
     # Default settings as defined by the spec
     DEFINED_SETTINGS = {
       settings_header_table_size: 1,
@@ -83,23 +69,25 @@ module HTTP2
       settings_max_header_list_size: 6
     }.freeze
 
-    # Default error types as defined by the spec
-    DEFINED_ERRORS = {
-      no_error: 0,
-      protocol_error: 1,
-      internal_error: 2,
-      flow_control_error: 3,
-      settings_timeout: 4,
-      stream_closed: 5,
-      frame_size_error: 6,
-      refused_stream: 7,
-      cancel: 8,
-      compression_error: 9,
-      connect_error: 10,
-      enhance_your_calm: 11,
-      inadequate_security: 12,
-      http_1_1_required: 13
-    }.freeze
+    DEFINED_SETTINGS_BY_ID = DEFINED_SETTINGS.invert.freeze
+
+    # Default error types as defined by the spec (the code is the array index)
+    DEFINED_ERRORS = %i[
+      no_error
+      protocol_error
+      internal_error
+      flow_control_error
+      settings_timeout
+      stream_closed
+      frame_size_error
+      refused_stream
+      cancel
+      compression_error
+      connect_error
+      enhance_your_calm
+      inadequate_security
+      http_1_1_required
+    ].freeze
 
     RBIT  = 0x7fffffff
     RBYTE = 0x0fffffff
@@ -108,10 +96,12 @@ module HTTP2
     UINT16 = "n"
     UINT8  = "C"
     HEADERPACK = (UINT8 + UINT16 + UINT8 + UINT8 + UINT32).freeze
+    PRIORITYPACK = (UINT32 + UINT8).freeze
+    ALTSVCPACK = (UINT32 + UINT16).freeze
     FRAME_LENGTH_HISHIFT = 16
     FRAME_LENGTH_LOMASK  = 0xFFFF
 
-    private_constant :RBIT, :RBYTE, :EBIT, :HEADERPACK, :UINT32, :UINT16, :UINT8
+    private_constant :RBIT, :RBYTE, :EBIT, :HEADERPACK, :PRIORITYPACK, :UINT32, :UINT16, :UINT8
 
     # Initializes new framer object.
     #
@@ -146,6 +136,10 @@ module HTTP2
         raise CompressionError, "Window increment (#{frame[:increment]}) is too large"
       end
 
+      flags = frame[:flags]
+
+      raise CompressionError, "Invalid frame flag (#{flags}) for #{type}" unless flags.between?(0, 255)
+
       header = buffer
 
       # make sure the buffer is binary and unfrozen
@@ -160,12 +154,7 @@ module HTTP2
              (length >> FRAME_LENGTH_HISHIFT),
              (length & FRAME_LENGTH_LOMASK),
              FRAME_TYPES[type],
-             frame[:flags].reduce(0) do |acc, f|
-               position = FRAME_FLAGS[type][f]
-               raise CompressionError, "Invalid frame flag (#{f}) for #{type}" unless position
-
-               acc | (1 << position)
-             end,
+             flags,
              stream_id
            ], HEADERPACK, buffer: header, offset: 0) # 8+16,8,8,32
     end
@@ -184,9 +173,7 @@ module HTTP2
 
       {
         type: type,
-        flags: FRAME_FLAGS[type].filter_map do |name, pos|
-          name if flags.anybits?(1 << pos)
-        end,
+        flags: flags,
         length: length,
         stream: stream & RBIT
       }
@@ -198,10 +185,11 @@ module HTTP2
     # @param frame [Hash]
     def generate(frame)
       length = 0
-      frame[:flags] ||= EMPTY
+      frame[:flags] ||= 0
 
       case frame[:type]
       when :data, :continuation
+        # @type var frame: data_frame | continuation_frame
         bytes = frame[:payload]
         length = bytes.bytesize
 
@@ -213,14 +201,16 @@ module HTTP2
             raise CompressionError, "Must specify all of priority parameters for #{frame[:type]}"
           end
 
-          frame[:flags] += [:priority] unless frame[:flags].include?(:priority)
+          frame[:flags] |= PRIORITY
         end
 
-        if frame[:flags].include?(:priority)
+        if frame[:flags].anybits?(PRIORITY)
           length = 5 + headers.bytesize
           bytes = String.new("", encoding: Encoding::BINARY, capacity: length)
-          pack([(frame[:exclusive] ? EBIT : 0) | (frame[:dependency] & RBIT)], UINT32, buffer: bytes)
-          pack([frame[:weight] - 1], UINT8, buffer: bytes)
+          pack(
+            [(frame[:exclusive] ? EBIT : 0) | (frame[:dependency] & RBIT), frame[:weight] - 1],
+            PRIORITYPACK, buffer: bytes
+          )
           append_str(bytes, headers)
         else
           length = headers.bytesize
@@ -234,8 +224,10 @@ module HTTP2
 
         length = 5
         bytes = String.new("", encoding: Encoding::BINARY, capacity: length)
-        pack([(frame[:exclusive] ? EBIT : 0) | (frame[:dependency] & RBIT)], UINT32, buffer: bytes)
-        pack([frame[:weight] - 1], UINT8, buffer: bytes)
+        pack(
+          [(frame[:exclusive] ? EBIT : 0) | (frame[:dependency] & RBIT), frame[:weight] - 1],
+          PRIORITYPACK, buffer: bytes
+        )
 
       when :rst_stream
         length = 4
@@ -248,20 +240,27 @@ module HTTP2
         end
 
         settings = frame[:payload]
-        bytes = String.new("", encoding: Encoding::BINARY, capacity: length)
 
-        settings.each do |(k, v)|
-          if k.is_a? Integer # rubocop:disable Style/GuardClause
-            DEFINED_SETTINGS.value?(k) || next
-          else
-            k = DEFINED_SETTINGS[k]
+        case settings
+        when String
+          length = settings.bytesize
+          bytes = settings
+        else
+          bytes = String.new("", encoding: Encoding::BINARY, capacity: settings.size * 6)
+
+          settings.each do |(k, v)|
+            if k.is_a? Integer # rubocop:disable Style/GuardClause
+              DEFINED_SETTINGS.value?(k) || next
+            else
+              k = DEFINED_SETTINGS[k]
 
-            raise CompressionError, "Unknown settings ID for #{k}" if k.nil?
-          end
+              raise CompressionError, "Unknown settings ID for #{k}" if k.nil?
+            end
 
-          pack([k], UINT16, buffer: bytes)
-          pack([v], UINT32, buffer: bytes)
-          length += 6
+            pack([k], UINT16, buffer: bytes)
+            pack([v], UINT32, buffer: bytes)
+            length += 6
+          end
         end
 
       when :push_promise
@@ -295,7 +294,7 @@ module HTTP2
       when :altsvc
         length = 6
         bytes = String.new("", encoding: Encoding::BINARY, capacity: length)
-        pack([frame[:max_age], frame[:port]], UINT32 + UINT16, buffer: bytes)
+        pack([frame[:max_age], frame[:port]], ALTSVCPACK, buffer: bytes)
         if frame[:proto]
           raise CompressionError, "Proto too long" if frame[:proto].bytesize > 255
 
@@ -354,7 +353,7 @@ module HTTP2
 
         length += padlen
         pack([padlen -= 1], UINT8, buffer: bytes, offset: 0)
-        frame[:flags] += [:padded]
+        frame[:flags] |= PADDED
 
         # Padding:  Padding octets that contain no application semantic value.
         # Padding octets MUST be set to zero when sending and ignored when
@@ -375,9 +374,9 @@ module HTTP2
 
       frame = read_common_header(buf)
 
-      type = frame[:type]
-      length = frame[:length]
-      flags = frame[:flags]
+      type = frame[:type] #: Symbol
+      length = frame[:length] #: Integer
+      flags = frame[:flags] #: Integer
 
       return if buf.size < 9 + length
 
@@ -394,15 +393,16 @@ module HTTP2
       # Process padding
       padlen = 0
       if FRAME_TYPES_WITH_PADDING.include?(type)
-        padded = flags.include?(:padded)
+        padded = flags.anybits?(PADDED)
         if padded
           padlen = read_str(payload, 1).unpack1(UINT8)
-          frame[:padding] = padlen + 1
           raise ProtocolError, "padding too long" if padlen > payload.bytesize
 
+          frame[:padding] = padlen + 1
+
           payload = payload.byteslice(0, payload.bytesize - padlen) if padlen > 0
           frame[:length] -= frame[:padding]
-          flags.delete(:padded)
+          frame[:flags] ^= PADDED
         end
       end
 
@@ -410,11 +410,11 @@ module HTTP2
       when :data, :ping, :continuation
         frame[:payload] = read_str(payload, length)
       when :headers
-        if flags.include?(:priority)
+        if flags.anybits?(PRIORITY)
           e_sd = read_uint32(payload)
           frame[:dependency] = e_sd & RBIT
           frame[:exclusive] = e_sd.anybits?(EBIT)
-          weight = payload.byteslice(0, 1).ord + 1
+          weight = payload.getbyte(0) + 1
           frame[:weight] = weight
           payload = payload.byteslice(1..-1)
         end
@@ -425,7 +425,7 @@ module HTTP2
         e_sd = read_uint32(payload)
         frame[:dependency] = e_sd & RBIT
         frame[:exclusive] = e_sd.anybits?(EBIT)
-        weight = payload.byteslice(0, 1).ord + 1
+        weight = payload.getbyte(0) + 1
         frame[:weight] = weight
         payload = payload.byteslice(1..-1)
       when :rst_stream
@@ -436,19 +436,19 @@ module HTTP2
       when :settings
         # NOTE: frame[:length] might not match the number of frame[:payload]
         # because unknown extensions are ignored.
-        frame[:payload] = []
         raise ProtocolError, "Invalid settings payload length" unless (length % 6).zero?
 
         raise ProtocolError, "Invalid stream ID (#{frame[:stream]})" if frame[:stream].nonzero?
 
-        (frame[:length] / 6).times do
+        frame[:payload] = (frame[:length] / 6).times.filter_map do
           id  = read_str(payload, 2).unpack1(UINT16)
           val = read_uint32(payload)
 
           # Unsupported or unrecognized settings MUST be ignored.
           # Here we send it along.
-          name, = DEFINED_SETTINGS.find { |_name, v| v == id }
-          frame[:payload] << [name, val] if name
+          if (name = DEFINED_SETTINGS_BY_ID[id])
+            [name, val]
+          end
         end
       when :push_promise
         frame[:promise_stream] = read_uint32(payload) & RBIT
@@ -464,13 +464,13 @@ module HTTP2
 
         frame[:increment] = read_uint32(payload) & RBIT
       when :altsvc
-        frame[:max_age], frame[:port] = read_str(payload, 6).unpack(UINT32 + UINT16)
+        frame[:max_age], frame[:port] = read_str(payload, 6).unpack(ALTSVCPACK)
 
-        len = payload.byteslice(0, 1).ord
+        len = payload.getbyte(0)
         payload = payload.byteslice(1..-1)
         frame[:proto] = read_str(payload, len) if len > 0
 
-        len = payload.byteslice(0, 1).ord
+        len = payload.getbyte(0)
         payload = payload.byteslice(1..-1)
         frame[:host] = read_str(payload, len) if len > 0
 
@@ -495,7 +495,7 @@ module HTTP2
 
     def pack_error(error, buffer:)
       unless error.is_a? Integer
-        error = DEFINED_ERRORS[error]
+        error = DEFINED_ERRORS.index(error)
 
         raise CompressionError, "Unknown error ID for #{error}" unless error
       end
@@ -504,7 +504,7 @@ module HTTP2
     end
 
     def unpack_error(error)
-      DEFINED_ERRORS.key(error) || error
+      DEFINED_ERRORS.fetch(error, error)
     end
   end
 end

data/lib/http/2/header/compressor.rb

@@ -83,8 +83,10 @@ module HTTP2
           huffman = Huffman.encode(str)
           if huffman.bytesize < str.bytesize
             huffman_offset = buffer.bytesize
+            integer(huffman.bytesize, 7, buffer: buffer)
+            buffer.setbyte(huffman_offset, buffer.getbyte(huffman_offset) | 0x80)
             append_str(buffer, huffman)
-            set_huffman_size(buffer, huffman_offset)
+            buffer
           else
             plain_string(str, buffer)
           end
@@ -119,7 +121,7 @@ module HTTP2
         end
 
         # set header representation pattern on first byte
-        fb = buffer[offset].ord | rep[:pattern]
+        fb = buffer.getbyte(offset) | rep[:pattern]
         buffer.setbyte(offset, fb)
 
         buffer
@@ -147,8 +149,17 @@ module HTTP2
       # @return [String] binary string
       def huffman_string(str, buffer = "".b)
         huffman_offset = buffer.bytesize
+        buffer << "\x00".b
         Huffman.encode(str, buffer)
-        set_huffman_size(buffer, huffman_offset)
+        size = buffer.bytesize - huffman_offset - 1
+
+        if size < 127
+          buffer.setbyte(huffman_offset, 0x80 | size)
+        else
+          buffer.slice!(huffman_offset, 1)
+          set_huffman_size(buffer, huffman_offset)
+        end
+        buffer
       end
 
       # @param str [String]
@@ -165,7 +176,7 @@ module HTTP2
       # @return [String] binary string
       def set_huffman_size(buffer, huffman_offset)
         integer(buffer.bytesize - huffman_offset, 7, buffer: buffer, offset: huffman_offset)
-        buffer.setbyte(huffman_offset, buffer[huffman_offset].ord | 0x80)
+        buffer.setbyte(huffman_offset, buffer.getbyte(huffman_offset) | 0x80)
         buffer
       end
     end

data/lib/http/2/header/decompressor.rb

@@ -33,24 +33,25 @@ module HTTP2
       # @return [Integer]
       def integer(buf, n)
         limit = (1 << n) - 1
-        i = n.zero? ? 0 : (shift_byte(buf) & limit)
+        if n.zero?
+          i = 0
+          consumed = 0
+        else
+          i = buf.getbyte(0) & limit
+          consumed = 1
+        end
 
-        m = 0
         if i == limit
-          offset = 0
-
-          buf.each_byte.with_index do |byte, idx|
-            offset = idx
-            # while (byte = shift_byte(buf))
+          m = 0
+          while (byte = buf.getbyte(consumed))
             i += ((byte & 127) << m)
             m += 7
-
+            consumed += 1
             break if byte.nobits?(128)
           end
-
-          read_str(buf, offset + 1)
         end
 
+        read_str(buf, consumed)
         i
       end
 

data/lib/http/2/header/encoding_context.rb

@@ -118,6 +118,8 @@ module HTTP2
       #   :index       Symbol   :all, :static, :never
       def initialize(options = {})
         @table = []
+        @table_by_field = Hash.new { |hs, k| hs[k] = [] }
+        @unshifts = 0
         @options = DEFAULT_OPTIONS.merge(options)
         @limit = @options[:table_size]
         @_table_updated = false
@@ -129,9 +131,13 @@ module HTTP2
       def dup
         other = EncodingContext.new(@options)
         t = @table
+        tbf = @table_by_field.transform_values(&:dup)
+        unshifts = @unshifts
         l = @limit
         other.instance_eval do
           @table = t.dup # shallow copy
+          @table_by_field = tbf
+          @unshifts = unshifts
           @limit = l
         end
         other
@@ -213,6 +219,8 @@ module HTTP2
           # add to table
           if type == :incremental && size_check?(name.bytesize + value.bytesize + 32)
             @table.unshift(emit)
+            @unshifts += 1
+            @table_by_field[name].unshift([value, @unshifts])
             @current_table_size += name.bytesize + value.bytesize + 32
             @_table_updated = true
           end
@@ -279,14 +287,14 @@ module HTTP2
         end
 
         if index_type == :all && !exact
-          @table.each_with_index do |(hfield, hvalue), i|
-            next unless field == hfield
+          field_entries = @table_by_field[field]
 
+          field_entries&.each do |hvalue, unshift_id|
+            abs_index = (@unshifts - unshift_id) + STATIC_TABLE_SIZE
+            name_only ||= abs_index
             if value == hvalue
-              exact = i + STATIC_TABLE_SIZE
+              exact = abs_index
               break
-            else
-              name_only ||= i + STATIC_TABLE_SIZE
             end
           end
         end
@@ -317,9 +325,13 @@ module HTTP2
         return if @table.empty?
 
         while @current_table_size + cmdsize > @limit
-
           name, value = @table.pop
           @current_table_size -= name.bytesize + value.bytesize + 32
+
+          field_arr = @table_by_field[name]
+          field_arr.pop
+          @table_by_field.delete(name) if field_arr.empty?
+
           break if @table.empty?
 
         end

data/lib/http/2/header/huffman.rb

@@ -20,6 +20,8 @@ module HTTP2
       EOS = 256
       private_constant :EOS
 
+      EOS_PADDING = (0..7).map { |n| ("1" * n).b.freeze }.freeze
+
       # Encodes provided value via huffman encoding.
       # Length is not encoded in this method.
       #
@@ -29,7 +31,7 @@ module HTTP2
       def encode(str, buffer = "".b)
         bitstring = String.new("", encoding: Encoding::BINARY, capacity: (str.bytesize * 30) + ((8 - str.size) % 8))
         str.each_byte { |chr| append_str(bitstring, ENCODE_TABLE[chr]) }
-        append_str(bitstring, "1" * ((8 - bitstring.size) % 8))
+        append_str(bitstring, EOS_PADDING[(8 - bitstring.size) % 8])
         pack([bitstring], "B*", buffer: buffer)
       end
 
@@ -54,13 +56,13 @@ module HTTP2
             first, state = MACHINE.dig(state, branch)
             raise CompressionError, "Huffman decode error (EOS found)" if first == EOS
 
-            append_str(emit, first.chr) if first
+            emit << first if first
           end
         end
         # Check whether partial input is correctly filled
         raise CompressionError, "Huffman decode error (EOS invalid)" unless state <= MAX_FINAL_STATE
 
-        emit.force_encoding(Encoding::BINARY)
+        emit
       end
 
       # Huffman table as specified in
@@ -325,7 +327,7 @@ module HTTP2
         [0x3fffffff, 30]
       ].each(&:freeze).freeze
 
-      ENCODE_TABLE = CODES.map { |c, l| [c].pack("N").unpack1("B*")[-l..-1] }.each(&:freeze).freeze
+      ENCODE_TABLE = CODES.map { |c, l| [c].pack("N").unpack1("B*")[-l..-1].b.freeze }.freeze
     end
   end
 end

data/lib/http/2/server.rb

@@ -78,18 +78,12 @@ module HTTP2
       receive(CONNECTION_PREFACE_MAGIC)
 
       # Process received HTTP2-Settings payload
-      buf = "".b
-      append_str(buf, Base64.urlsafe_decode64(settings.to_s))
-      @framer.common_header(
-        {
-          length: buf.bytesize,
-          type: :settings,
-          stream: 0,
-          flags: []
-        },
-        buffer: buf
-      )
-      receive(buf)
+      receive(@framer.generate(
+                type: :settings,
+                stream: 0,
+                flags: 0,
+                payload: Base64.urlsafe_decode64(settings.to_s)
+              ))
 
       # Activate stream (id: 1) with on HTTP/1.1 request parameters
       stream = activate_stream(id: 1)
@@ -97,7 +91,7 @@ module HTTP2
 
       headers_frame = {
         type: :headers,
-        flags: [:end_headers],
+        flags: END_HEADERS,
         stream: 1,
         weight: DEFAULT_WEIGHT,
         dependency: 0,
@@ -106,11 +100,11 @@ module HTTP2
       }
 
       if body.empty?
-        headers_frame[:flags] << [:end_stream]
+        headers_frame[:flags] |= END_HEADERS
         stream << headers_frame
       else
         stream << headers_frame
-        stream << { type: :data, stream: 1, payload: body, flags: [:end_stream] }
+        stream << { type: :data, stream: 1, payload: body, flags: END_STREAM }
       end
 
       # Mark h2c upgrade as finished
@@ -135,7 +129,7 @@ module HTTP2
 
     def connection_settings(frame)
       super
-      return unless frame[:flags].include?(:ack) && !@origins_sent
+      return unless frame[:flags].anybits?(ACK) && !@origins_sent
 
       send(type: :origin, stream: 0, payload: @origin_set)
     end
@@ -148,7 +142,7 @@ module HTTP2
     #
     # @param parent [Stream]
     # @param headers [Enumerable[String, String]]
-    # @param flags [Array[Symbol]]
+    # @param flags Integer
     # @param callback [Proc]
     def promise(parent, headers, flags)
       promise = new_stream(parent: parent)
@@ -157,7 +151,7 @@ module HTTP2
         flags: flags,
         stream: parent.id,
         promise_stream: promise.id,
-        payload: headers.to_a
+        payload: headers
       )
 
       yield(promise)

data/lib/http/2/settings.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module HTTP2
+  # Default values for SETTINGS frame, as defined by the spec.
+  SPEC_DEFAULT_CONNECTION_SETTINGS = {
+    settings_header_table_size: 4096,
+    settings_enable_push: 1, # enabled for servers
+    settings_max_concurrent_streams: Framer::MAX_STREAM_ID, # unlimited
+    settings_initial_window_size: 65_535,
+    settings_max_frame_size: 16_384,
+    settings_max_header_list_size: (2 << 30) - 1 # unlimited
+  }.freeze
+
+  Settings = Struct.new(
+    :settings_header_table_size,
+    :settings_enable_push,
+    :settings_max_concurrent_streams,
+    :settings_initial_window_size,
+    :settings_max_frame_size,
+    :settings_max_header_list_size,
+    keyword_init: true
+  ) do
+    def initialize(
+      settings_header_table_size: 4096,
+      settings_enable_push: 1,
+      settings_max_concurrent_streams: 100,
+      settings_initial_window_size: 65_535,
+      settings_max_frame_size: 16_384,
+      settings_max_header_list_size: (2 << 30) - 1
+    )
+      super
+    end
+
+    def each_setting
+      each_pair do |k, v|
+        next if v == SPEC_DEFAULT_CONNECTION_SETTINGS[k]
+
+        yield k, v
+      end
+    end
+  end
+end