http-2 1.0.1 → 1.1.0

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

@@ -5,6 +5,7 @@ module HTTP2
     # Responsible for encoding header key-value pairs using HPACK algorithm.
     class Compressor
       include PackingExtensions
+      include BufferUtils
 
       # @param options [Hash] encoding options
       def initialize(options = {})
@@ -34,8 +35,8 @@ module HTTP2
       # @param buffer [String] buffer to pack bytes into
       # @param offset [Integer] offset to insert packed bytes in buffer
       # @return [String] binary string
-      def integer(i, n, buffer:, offset: 0)
-        limit = (2**n) - 1
+      def integer(i, n, buffer:, offset: buffer.size)
+        limit = (1 << n) - 1
         return pack([i], "C", buffer: buffer, offset: offset) if i < limit
 
         bytes = []
@@ -70,19 +71,23 @@ module HTTP2
       #  :shorter Use Huffman when the result is strictly shorter
       #
       # @param str [String]
+      # @param buffer [String]
       # @return [String] binary string
-      def string(str)
+      def string(str, buffer = "".b)
         case @cc.options[:huffman]
         when :always
-          huffman_string(str)
+          huffman_string(str, buffer)
         when :never
-          plain_string(str)
+          plain_string(str, buffer)
         else
-          huffman = huffman_string(str)
-
-          plain = plain_string(str)
-
-          huffman.bytesize < plain.bytesize ? huffman : plain
+          huffman = Huffman.encode(str)
+          if huffman.bytesize < str.bytesize
+            huffman_offset = buffer.bytesize
+            append_str(buffer, huffman)
+            set_huffman_size(buffer, huffman_offset)
+          else
+            plain_string(str, buffer)
+          end
         end
       end
 
@@ -92,27 +97,30 @@ module HTTP2
       # @param buffer [String]
       # @return [Buffer]
       def header(h, buffer = "".b)
-        rep = HEADREP[h[:type]]
+        type = h[:type]
+        rep = HEADREP[type]
+        offset = buffer.size
 
-        case h[:type]
+        case type
         when :indexed
           integer(h[:name] + 1, rep[:prefix], buffer: buffer)
         when :changetablesize
           integer(h[:value], rep[:prefix], buffer: buffer)
         else
-          if h[:name].is_a? Integer
-            integer(h[:name] + 1, rep[:prefix], buffer: buffer)
+          name = h[:name]
+          if name.is_a? Integer
+            integer(name + 1, rep[:prefix], buffer: buffer)
           else
             integer(0, rep[:prefix], buffer: buffer)
-            buffer << string(h[:name])
+            string(name, buffer)
           end
 
-          buffer << string(h[:value])
+          string(h[:value], buffer)
         end
 
         # set header representation pattern on first byte
-        fb = buffer.ord | rep[:pattern]
-        buffer.setbyte(0, fb)
+        fb = buffer[offset].ord | rep[:pattern]
+        buffer.setbyte(offset, fb)
 
         buffer
       end
@@ -123,11 +131,10 @@ module HTTP2
       # @return [Buffer]
       def encode(headers)
         buffer = "".b
-        pseudo_headers, regular_headers = headers.partition { |f, _| f.start_with? ":" }
-        headers = [*pseudo_headers, *regular_headers]
-        commands = @cc.encode(headers)
-        commands.each do |cmd|
-          buffer << header(cmd)
+        headers.partition { |f, _| f.start_with? ":" }.each do |hs|
+          @cc.encode(hs) do |cmd|
+            header(cmd, buffer)
+          end
         end
 
         buffer
@@ -136,22 +143,31 @@ module HTTP2
       private
 
       # @param str [String]
+      # @param buffer [String]
       # @return [String] binary string
-      def huffman_string(str)
-        huffman = Huffman.new.encode(str)
-        integer(huffman.bytesize, 7, buffer: huffman, offset: 0)
-        huffman.setbyte(0, huffman.ord | 0x80)
-        huffman
+      def huffman_string(str, buffer = "".b)
+        huffman_offset = buffer.bytesize
+        Huffman.encode(str, buffer)
+        set_huffman_size(buffer, huffman_offset)
       end
 
       # @param str [String]
+      # @param buffer [String]
       # @return [String] binary string
-      def plain_string(str)
-        plain = "".b
+      def plain_string(str, plain = "".b)
         integer(str.bytesize, 7, buffer: plain)
-        plain << str.dup.force_encoding(Encoding::BINARY)
+        append_str(plain, str)
         plain
       end
+
+      # @param buffer [String]
+      # @param huffman_offset [Integer] buffer offset where huffman string was introduced
+      # @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
+      end
     end
   end
 end

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

@@ -2,7 +2,6 @@
 
 module HTTP2
   module Header
-    using StringExtensions
     # Responsible for decoding received headers and maintaining compression
     # context of the opposing peer. Decompressor must be initialized with
     # appropriate starting context based on local role: client or server.
@@ -12,6 +11,9 @@ module HTTP2
     #   client_role = Decompressor.new(:response)
     class Decompressor
       include Error
+      include BufferUtils
+
+      FORBIDDEN_HEADERS = %w[connection te].freeze
 
       # @param options [Hash] decoding options.  Only :table_size is effective.
       def initialize(options = {})
@@ -30,17 +32,23 @@ module HTTP2
       # @param n [Integer] number of available bits
       # @return [Integer]
       def integer(buf, n)
-        limit = (2**n) - 1
-        i = n.zero? ? 0 : (buf.shift_byte & limit)
+        limit = (1 << n) - 1
+        i = n.zero? ? 0 : (shift_byte(buf) & limit)
 
         m = 0
         if i == limit
-          while (byte = buf.shift_byte)
+          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 & 128).zero?
+            break if byte.nobits?(128)
           end
+
+          read_str(buf, offset + 1)
         end
 
         i
@@ -54,12 +62,12 @@ module HTTP2
       def string(buf)
         raise CompressionError, "invalid header block fragment" if buf.empty?
 
-        huffman = (buf.getbyte(0) & 0x80) == 0x80
+        huffman = buf.getbyte(0).allbits?(0x80)
         len = integer(buf, 7)
-        str = buf.read(len)
+        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

@@ -75,15 +75,27 @@ module HTTP2
         ["vary",                        ""],
         ["via",                         ""],
         ["www-authenticate",            ""]
-      ].each { |pair| pair.each(&:freeze).freeze }.freeze
+      ].each(&:freeze).freeze
 
-      STATIC_TABLE_BY_FIELD = STATIC_TABLE
-                              .each_with_object({})
-                              .with_index { |((field, value), hs), idx| (hs[field] ||= []) << [idx, value] }
-                              .each { |pair| pair.each(&:freeze).freeze }.freeze
+      STATIC_TABLE_BY_FIELD =
+        STATIC_TABLE
+        .each_with_object({})
+        .with_index { |((field, value), hs), idx| (hs[field] ||= []) << [idx, value].freeze }
+        .each_value(&:freeze)
+        .freeze
 
       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
 
@@ -94,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.
       #
@@ -102,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
@@ -138,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
@@ -151,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
 
@@ -161,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:
@@ -186,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]+
@@ -217,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.
@@ -227,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.
@@ -243,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
@@ -274,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
 
@@ -285,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
@@ -302,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,11 +9,12 @@ module HTTP2
   # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10
   module Header
     # Huffman encoder/decoder
-    class Huffman
-      using StringExtensions
+    module Huffman
+      module_function
 
       include Error
-      include PackingExtensions
+      extend PackingExtensions
+      extend BufferUtils
 
       BITS_AT_ONCE = 4
       EOS = 256
@@ -23,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.
@@ -48,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 = [
@@ -268,7 +268,7 @@ module HTTP2
         [[28, 29], [28, 5], [29, 29], [29, 5], [30, 29], [30, 5], [31, 29], [31, 5], [127, 29], [127, 5], [220, 29], [220, 5], [249, 29], [249, 5], [nil, 254], [nil, 255]],
         [[10, 17], [10, 18], [10, 19], [10, 20], [10, 21], [10, 22], [10, 23], [10, 7], [13, 17], [13, 18], [13, 19], [13, 20], [13, 21], [13, 22], [13, 23], [13, 7]],
         [[22, 17], [22, 18], [22, 19], [22, 20], [22, 21], [22, 22], [22, 23], [22, 7], [256, 17], [256, 18], [256, 19], [256, 20], [256, 21], [256, 22], [256, 23], [256, 7]],
-      ].each { |arr| arr.each { |subarr| subarr.each(&:freeze) }.freeze }.freeze
+      ].each { |arr| arr.each { |subarr| subarr.freeze }.freeze }.freeze
     end
   end
 end

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?