http-2 1.0.2 → 1.1.0

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

@@ -13,6 +13,8 @@ module HTTP2
       include Error
       include BufferUtils
 
+      FORBIDDEN_HEADERS = %w[connection te].freeze
+
       # @param options [Hash] decoding options.  Only :table_size is effective.
       def initialize(options = {})
         @cc = EncodingContext.new(options)
@@ -30,17 +32,23 @@ module HTTP2
       # @param n [Integer] number of available bits
       # @return [Integer]
       def integer(buf, n)
-        limit = (2**n) - 1
+        limit = (1 << n) - 1
         i = n.zero? ? 0 : (shift_byte(buf) & limit)
 
         m = 0
         if i == limit
-          while (byte = shift_byte(buf))
+          offset = 0
+
+          buf.each_byte.with_index do |byte, idx|
+            offset = idx
+            # while (byte = shift_byte(buf))
             i += ((byte & 127) << m)
             m += 7
 
             break if byte.nobits?(128)
           end
+
+          read_str(buf, offset + 1)
         end
 
         i
@@ -59,7 +67,7 @@ module HTTP2
         str = read_str(buf, len)
         raise CompressionError, "string too short" unless str.bytesize == len
 
-        str = Huffman.new.decode(str) if huffman
+        str = Huffman.decode(str) if huffman
         str.force_encoding(Encoding::UTF_8)
       end
 
@@ -70,37 +78,36 @@ module HTTP2
       def header(buf)
         peek = buf.getbyte(0)
 
-        header = {}
-        header[:type], type = HEADREP.find do |_t, desc|
+        header_type, type = HEADREP.find do |_, desc|
           mask = (peek >> desc[:prefix]) << desc[:prefix]
           mask == desc[:pattern]
         end
 
-        raise CompressionError unless header[:type]
+        raise CompressionError unless header_type && type
 
-        header[:name] = integer(buf, type[:prefix])
+        header_name = integer(buf, type[:prefix])
 
-        case header[:type]
+        case header_type
         when :indexed
-          raise CompressionError if (header[:name]).zero?
+          raise CompressionError if header_name.zero?
+
+          header_name -= 1
 
-          header[:name] -= 1
+          { type: header_type, name: header_name }
         when :changetablesize
-          header[:value] = header[:name]
+          { type: header_type, name: header_name, value: header_name }
         else
-          if (header[:name]).zero?
-            header[:name] = string(buf)
+          if header_name.zero?
+            header_name = string(buf)
           else
-            header[:name] -= 1
+            header_name -= 1
           end
-          header[:value] = string(buf)
-        end
+          header_value = string(buf)
 
-        header
+          { type: header_type, name: header_name, value: header_value }
+        end
       end
 
-      FORBIDDEN_HEADERS = %w[connection te].freeze
-
       # Decodes and processes header commands within provided buffer.
       #
       # @param buf [Buffer]
@@ -114,7 +121,7 @@ module HTTP2
             field, value = @cc.process(header(buf))
             next if field.nil?
 
-            is_pseudo_header = field.start_with? ":"
+            is_pseudo_header = field.start_with?(":")
             if !decoding_pseudo_headers && is_pseudo_header
               raise ProtocolError, "one or more pseudo headers encountered after regular headers"
             end

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

@@ -86,6 +86,16 @@ module HTTP2
 
       STATIC_TABLE_SIZE = STATIC_TABLE.size
 
+      DEFAULT_OPTIONS = {
+        huffman: :shorter,
+        index: :all,
+        table_size: 4096
+      }.freeze
+
+      STATIC_ALL = %i[all static].freeze
+
+      STATIC_NEVER = %i[never static].freeze
+
       # Current table of header key-value pairs.
       attr_reader :table
 
@@ -96,6 +106,9 @@ module HTTP2
       #   :index       Symbol   :all, :static, :never
       attr_reader :options
 
+      # Current table size in octets
+      attr_reader :current_table_size
+
       # Initializes compression context with appropriate client/server
       # defaults and maximum size of the dynamic table.
       #
@@ -104,15 +117,11 @@ module HTTP2
       #   :huffman     Symbol   :always, :never, :shorter
       #   :index       Symbol   :all, :static, :never
       def initialize(options = {})
-        default_options = {
-          huffman: :shorter,
-          index: :all,
-          table_size: 4096
-        }
         @table = []
-        @options = default_options.merge(options)
+        @options = DEFAULT_OPTIONS.merge(options)
         @limit = @options[:table_size]
         @_table_updated = false
+        @current_table_size = 0
       end
 
       # Duplicates current compression context
@@ -140,10 +149,13 @@ module HTTP2
       # @return [Array] +[key, value]+
       def dereference(index)
         # NOTE: index is zero-based in this module.
-        value = STATIC_TABLE[index] || @table[index - STATIC_TABLE_SIZE]
-        raise CompressionError, "Index too large" unless value
+        return STATIC_TABLE[index] if index < STATIC_TABLE_SIZE
+
+        idx = index - STATIC_TABLE_SIZE
+
+        raise CompressionError, "Index too large" if idx >= @table.size
 
-        value
+        @table[index - STATIC_TABLE_SIZE]
       end
 
       # Header Block Processing
@@ -153,9 +165,11 @@ module HTTP2
       # @return [Array, nil] +[name, value]+ header field that is added to the decoded header list,
       #                                      or nil if +cmd[:type]+ is +:changetablesize+
       def process(cmd)
-        emit = nil
+        type = cmd[:type]
+        name = cmd[:name]
+        value = cmd[:value]
 
-        case cmd[:type]
+        case type
         when :changetablesize
           raise CompressionError, "tried to change table size after adding elements to table" if @_table_updated
 
@@ -163,21 +177,18 @@ module HTTP2
           # we should blow up if we receive another frame where the new table size is bigger.
           table_size_updated = @limit != @options[:table_size]
 
-          raise CompressionError, "dynamic table size update exceed limit" if !table_size_updated && cmd[:value] > @limit
+          raise CompressionError, "dynamic table size update exceed limit" if !table_size_updated && value > @limit
 
-          self.table_size = cmd[:value]
+          self.table_size = value
 
+          nil
         when :indexed
           # Indexed Representation
           # An _indexed representation_ entails the following actions:
           # o  The header field corresponding to the referenced entry in either
           # the static table or dynamic table is added to the decoded header
           # list.
-          idx = cmd[:name]
-
-          k, v = dereference(idx)
-          emit = [k, v]
-
+          dereference(name)
         when :incremental, :noindex, :neverindexed
           # A _literal representation_ that is _not added_ to the dynamic table
           # entails the following action:
@@ -188,27 +199,28 @@ module HTTP2
           # o  The header field is added to the decoded header list.
           # o  The header field is inserted at the beginning of the dynamic table.
 
-          case cmd[:name]
+          case name
           when Integer
-            k, v = dereference(cmd[:name])
+            name, v = dereference(name)
 
-            cmd = cmd.dup
-            cmd[:index] ||= cmd[:name]
-            cmd[:value] ||= v
-            cmd[:name] = k
+            value ||= v
           when UPPER
-            raise ProtocolError, "Invalid uppercase key: #{cmd[:name]}"
+            raise ProtocolError, "Invalid uppercase key: #{name}"
           end
 
-          emit = [cmd[:name], cmd[:value]]
+          emit = [name, value]
 
-          add_to_table(emit) if cmd[:type] == :incremental
+          # add to table
+          if type == :incremental && size_check(name.bytesize + value.bytesize + 32)
+            @table.unshift(emit)
+            @current_table_size += name.bytesize + value.bytesize + 32
+            @_table_updated = true
+          end
 
+          emit
         else
-          raise CompressionError, "Invalid type: #{cmd[:type]}"
+          raise CompressionError, "Invalid type: #{type}"
         end
-
-        emit
       end
 
       # Plan header compression according to +@options [:index]+
@@ -219,9 +231,9 @@ module HTTP2
       # @param headers [Array] +[[name, value], ...]+
       # @return [Array] array of commands
       def encode(headers)
-        commands = []
         # Literals commands are marked with :noindex when index is not used
-        noindex = %i[static never].include?(@options[:index])
+        noindex = STATIC_NEVER.include?(@options[:index])
+
         headers.each do |field, value|
           # Literal header names MUST be translated to lowercase before
           # encoding and transmission.
@@ -229,10 +241,9 @@ module HTTP2
           value = "/" if field == ":path" && value.empty?
           cmd = addcmd(field, value)
           cmd[:type] = :noindex if noindex && cmd[:type] == :incremental
-          commands << cmd
           process(cmd)
+          yield cmd
         end
-        commands
       end
 
       # Emits command for a header.
@@ -245,30 +256,36 @@ module HTTP2
       #  :static  Use static table only.
       #  :all     Use all of them.
       #
-      # @param header [Array] +[name, value]+
+      # @param field [String] the header field
+      # @param value [String] the header value
       # @return [Hash] command
-      def addcmd(*header)
+      def addcmd(field, value)
+        # @type var exact: Integer?
         exact = nil
+        # @type var name_only: Integer?
         name_only = nil
 
-        if %i[all static].include?(@options[:index])
-          field, value = header
-          if (svalues = STATIC_TABLE_BY_FIELD[field])
-            svalues.each do |i, svalue|
-              name_only ||= i
-              if svalue == value
-                exact = i
-                break
-              end
+        index_type = @options[:index]
+
+        if STATIC_ALL.include?(index_type) &&
+           STATIC_TABLE_BY_FIELD.key?(field)
+          STATIC_TABLE_BY_FIELD[field].each do |i, svalue|
+            name_only ||= i
+            if value == svalue
+              exact = i
+              break
             end
           end
         end
-        if [:all].include?(@options[:index]) && !exact
-          @table.each_index do |i|
-            if @table[i] == header
-              exact ||= i + STATIC_TABLE_SIZE
+
+        if index_type == :all && !exact
+          @table.each_with_index do |(hfield, hvalue), i|
+            next unless field == hfield
+
+            if value == hvalue
+              exact = i + STATIC_TABLE_SIZE
               break
-            elsif @table[i].first == header.first
+            else
               name_only ||= i + STATIC_TABLE_SIZE
             end
           end
@@ -276,10 +293,8 @@ module HTTP2
 
         if exact
           { name: exact, type: :indexed }
-        elsif name_only
-          { name: name_only, value: header.last, type: :incremental }
         else
-          { name: header.first, value: header.last, type: :incremental }
+          { name: name_only || field, value: value, type: :incremental }
         end
       end
 
@@ -287,13 +302,7 @@ module HTTP2
       #  When the size is reduced, some headers might be evicted.
       def table_size=(size)
         @limit = size
-        size_check(nil)
-      end
-
-      # Returns current table size in octets
-      # @return [Integer]
-      def current_table_size
-        @table.inject(0) { |r, (k, v)| r + k.bytesize + v.bytesize + 32 }
+        size_check(0)
       end
 
       def listen_on_table
@@ -304,32 +313,20 @@ module HTTP2
 
       private
 
-      # Add a name-value pair to the dynamic table.
-      # Older entries might have been evicted so that
-      # the new entry fits in the dynamic table.
-      #
-      # @param cmd [Array] +[name, value]+
-      def add_to_table(cmd)
-        return unless size_check(cmd)
-
-        @table.unshift(cmd)
-        @_table_updated = true
-      end
-
       # To keep the dynamic table size lower than or equal to @limit,
       # remove one or more entries at the end of the dynamic table.
       #
-      # @param cmd [Hash]
+      # @param cmdsize [Integer]
       # @return [Boolean] whether +cmd+ fits in the dynamic table.
-      def size_check(cmd)
-        cursize = current_table_size
-        cmdsize = cmd.nil? ? 0 : cmd[0].bytesize + cmd[1].bytesize + 32
+      def size_check(cmdsize)
+        unless @table.empty?
+          while @current_table_size + cmdsize > @limit
 
-        while cursize + cmdsize > @limit
-          break if @table.empty?
+            name, value = @table.pop
+            @current_table_size -= name.bytesize + value.bytesize + 32
+            break if @table.empty?
 
-          e = @table.pop
-          cursize -= e[0].bytesize + e[1].bytesize + 32
+          end
         end
 
         cmdsize <= @limit

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

@@ -9,9 +9,12 @@ module HTTP2
   # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10
   module Header
     # Huffman encoder/decoder
-    class Huffman
+    module Huffman
+      module_function
+
       include Error
-      include PackingExtensions
+      extend PackingExtensions
+      extend BufferUtils
 
       BITS_AT_ONCE = 4
       EOS = 256
@@ -21,11 +24,13 @@ module HTTP2
       # Length is not encoded in this method.
       #
       # @param str [String]
+      # @param buffer [String]
       # @return [String] binary string
-      def encode(str)
-        bitstring = str.each_byte.map { |chr| ENCODE_TABLE[chr] }.join
-        bitstring << ("1" * ((8 - bitstring.size) % 8))
-        [bitstring].pack("B*")
+      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)))
+        pack([bitstring], "B*", buffer: buffer)
       end
 
       # Decodes provided Huffman coded string.
@@ -46,11 +51,10 @@ module HTTP2
             # Each transition is [emit, next]
             #  [emit] character to be emitted on this transition, empty string, or EOS.
             #  [next] next state number.
-            trans = MACHINE[state][branch]
-            raise CompressionError, "Huffman decode error (EOS found)" if trans.first == EOS
+            first, state = MACHINE.dig(state, branch)
+            raise CompressionError, "Huffman decode error (EOS found)" if first == EOS
 
-            emit << trans.first.chr if trans.first
-            state = trans.last
+            append_str(emit, first.chr) if first
           end
         end
         # Check whether partial input is correctly filled

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

@@ -8,7 +8,7 @@
 
 module HTTP2
   module Header
-    class Huffman
+    module Huffman
       # :nodoc:
       MAX_FINAL_STATE = 7
       MACHINE = [

data/lib/http/2/server.rb

@@ -79,7 +79,7 @@ module HTTP2
 
       # Process received HTTP2-Settings payload
       buf = "".b
-      buf << Base64.urlsafe_decode64(settings.to_s)
+      append_str(buf, Base64.urlsafe_decode64(settings.to_s))
       @framer.common_header(
         {
           length: buf.bytesize,
@@ -120,6 +120,12 @@ module HTTP2
       @state = :waiting_magic
     end
 
+    def activate_stream(**)
+      super.tap do |stream|
+        stream.on(:promise, &method(:promise))
+      end
+    end
+
     def origin_set=(origins)
       @origin_set = Array(origins).map(&:to_s)
       @origins_sent = @origin_set.empty?

data/lib/http/2/stream.rb

@@ -40,6 +40,8 @@ module HTTP2
     include Emitter
     include Error
 
+    STREAM_OPEN_STATES = %i[open half_closed_local half_closing closing].freeze
+
     # Stream ID (odd for client initiated streams, even otherwise).
     attr_reader :id
 
@@ -80,6 +82,11 @@ module HTTP2
       @id = id
       @weight = weight
       @dependency = dependency
+
+      # from mixins
+      @listeners = Hash.new { |hash, key| hash[key] = [] }
+      @send_buffer = FrameBuffer.new
+
       process_priority(weight: weight, dependency: dependency, exclusive: exclusive)
       @local_window_max_size = connection.local_settings[:settings_initial_window_size]
       @local_window = connection.local_settings[:settings_initial_window_size]
@@ -88,7 +95,7 @@ module HTTP2
       @state  = state
       @error  = false
       @closed = false
-      @_method = @_content_length = @_status_code = nil
+      @_method = @_content_length = @_status_code = @_trailers = nil
       @_waiting_on_trailers = false
       @received_data = false
       @activated = false
@@ -113,9 +120,7 @@ module HTTP2
         # If a DATA frame is received whose stream is not in "open" or
         # "half closed (local)" state, the recipient MUST respond with a
         # stream error (Section 5.4.2) of type STREAM_CLOSED.
-        stream_error(:stream_closed) unless @state == :open ||
-                                            @state == :half_closed_local ||
-                                            @state == :half_closing || @state == :closing ||
+        stream_error(:stream_closed) unless STREAM_OPEN_STATES.include?(@state) ||
                                             (@state == :closed && @closed == :local_rst)
         @received_data = true
         calculate_content_length(frame[:length])

data/lib/http/2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTP2
-  VERSION = "1.0.2"
+  VERSION = "1.1.0"
 end

data/lib/http/2.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
 require "http/2/version"
+
+module HTTP2
+  EMPTY = [].freeze
+end
+
 require "http/2/extensions"
 require "http/2/base64"
 require "http/2/error"

data/sig/{next.rbs → 2.rbs}

@@ -7,7 +7,18 @@ module HTTP2
 
   DEFAULT_MAX_CONCURRENT_STREAMS: Integer
 
-  type settings_hash = Hash[Symbol, Integer]
+  EMPTY: []
+
+  type connection_opts = Hash[Symbol, untyped]
+
+  type settings_hash = {
+    settings_header_table_size: Integer,
+    settings_enable_push: Integer,
+    settings_max_concurrent_streams:  Integer,
+    settings_initial_window_size: Integer,
+    settings_max_frame_size: Integer,
+    settings_max_header_list_size: Integer
+  }
 
   type settings_ary = Array[settings_enum]
 
@@ -30,44 +41,44 @@ module HTTP2
   # # FRAMES
   type frame_control_flags = Array[:end_headers | :end_stream]
 
+  type common_frame = { stream: Integer }
+
   # # HEADERS
-  # type headers_frame = {
-  #   type: :headers, flags: frame_control_flags, stream: Integer, payload: Enumerable[header_pair],
-  #   ?method: Symbol, ?trailer: Array[String], ?content_length: Integer, ?padding: Integer
-  # }
+  type headers_frame = common_frame & {
+    type: :headers, flags: frame_control_flags, payload: Enumerable[header_pair] | String,
+    ?method: Symbol, ?trailer: Array[String], ?content_length: Integer, ?padding: Integer
+  }
 
   # # DATA
-  type data_frame = { type: :data, flags: frame_control_flags, stream: Integer, length: Integer, payload: String, padding: Integer }
-                  | { type: :data, flags: frame_control_flags, stream: Integer, length: Integer, payload: String }
-                  | { type: :data, flags: frame_control_flags, payload: String }
+  type data_frame = { type: :data, flags: frame_control_flags, ?length: Integer, payload: String, ?padding: Integer }
 
   # # PUSH_PROMISE
-  # type push_promise_frame = { type: :push_promise, promise_stream: Integer, flags: frame_control_flags, stream: Integer, ?method: Symbol, ?trailer: Array[String], ?content_length: Integer, payload: Enumerable[header_pair], ?padding: Integer }
+  type push_promise_frame = { type: :push_promise, promise_stream: Integer, flags: frame_control_flags, ?method: Symbol, ?trailer: Array[String], ?content_length: Integer, payload: Enumerable[header_pair], ?padding: Integer }
 
   # # SETTINGS
-  # type settings_frame = { type: :settings, stream: 0, payload: Array[[Symbol | Integer, Integer]] }
+  type settings_frame = { type: :settings, payload: Array[[Symbol | Integer, Integer]] }
 
   # # WINDOW_UPDATE
-  # type window_update_frame = { type: :window_update, stream: Integer, increment: Integer }
+  type window_update_frame = { type: :window_update, increment: Integer }
 
   # # PRIORITY
-  type priority_frame = { type: :priority, stream: Integer, dependency: Integer, exclusive: bool, weight: Integer }
+  type priority_frame = { dependency: Integer, exclusive: bool, weight: Integer }
 
   # # ALTSVC
-  # type altsvc_frame = { type: :altsvc, stream: 0, max_age: Integer, port: Integer, proto: "String", host: String }
+  type altsvc_frame = { type: :altsvc, max_age: Integer, port: Integer, proto: "String", host: String }
 
   # # ORIGIN
-  # type origin_frame = { type: :origin, stream: 0, origin: Array[String] }
+  type origin_frame = { type: :origin, origin: Array[String] }
 
   # # PING
-  # type ping_frame = { type: :ping, payload: String, length: Integer }
+  type ping_frame = { type: :ping, payload: String, length: Integer }
 
   # # GOAWAY
-  # type goaway_frame = { type: :goaway, stream: 0, last_stream: Integer, error: Symbol? }
+  type goaway_frame = { type: :goaway, last_stream: Integer, error: Symbol? }
 
-  # type frame = headers_frame | data_frame | push_promise_frame |
+  # type frame = common_frame & (headers_frame | data_frame | push_promise_frame |
   #              settings_frame | window_update_frame | priority_frame | altsvc_frame |
-  #              origin_frame | ping_frame | goaway_frame
+  #              origin_frame | ping_frame | goaway_frame)
 
   type frame_key = :type | :flags | :stream | :padding | :ignore |
                    # headers

data/sig/client.rbs

@@ -1,5 +1,7 @@
 module HTTP2
   class Client < Connection
+    @h2c_upgrade: Symbol?
+
     def upgrade: () -> Stream
 
     def send_connection_preface: () -> void