http-2-next 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba5613efe08f91c20db5d9c32fbbac18a2d6f214ba42037c341dd9b40cbffe23
-  data.tar.gz: c7e0f3a0256a2cf7d106c1be72417c863e37f4c203bc7df6910ff91d135479e6
+  metadata.gz: c4ce4e3302e32d2c860cf38d25f82186a233ae9bb446bde932d185ca398d4eec
+  data.tar.gz: c2428f11638405fa7c92390745f4c21022627500fe54d564a46f06e83967d126
 SHA512:
-  metadata.gz: 645582d2208c23b84120256893828f8fc5f3c7d058848979fd62188a9fd31746aafade3759334d06ae8d53b2ee6ab3bff23d4eb5288112da31ccf6dee8a187cf
-  data.tar.gz: 3804926e00e854b61a25dbf0e515ae5fcfb82532403909f6d3e4e035f7ebeef162c14bc00d64babd0013cdb22f2a7164f02dc708d1575392fc8b3445ddd953f6
+  metadata.gz: 5a10531d34c3d37989a6de029b4bfdca1b9742b7614a7785179bea4d8794568b58bd88641c259721520f803b1f6577c2e41ddb49bff75564edfbdf9d422124fc
+  data.tar.gz: 8d9d7e74f52d079a7f9021bcd7679bd7544b1e30d17cdd5f42de24326812c46f4c3f8208f3132ba0e9d0df46b6c947238781a48abbf6d1cacc95da69b3227293

data/README.md

@@ -2,7 +2,7 @@
 
 [![Gem Version](https://badge.fury.io/rb/http-2-next.svg)](http://rubygems.org/gems/http-2-next)
 [![Build status](https://gitlab.com/honeyryderchuck/http-2-next/badges/master/pipeline.svg)](https://gitlab.com/honeyryderchuck/http-2-next/commits/master)
-[![coverage report](https://gitlab.com/honeyryderchuck/http-2-next/badges/master/coverage.svg)](https://honeyryderchuck.gitlab.io/http-2-next/coverage/#_AllFiles)
+[![coverage report](https://gitlab.com/honeyryderchuck/http-2-next/badges/master/coverage.svg?job=coverage)](https://honeyryderchuck.gitlab.io/http-2-next/coverage/#_AllFiles)
 
 **Attention!** This is a fork of the [http-2](https://github.com/igrigorik/http-2) gem.
 

data/lib/http/2/next.rb

@@ -6,9 +6,7 @@ require "http/2/next/error"
 require "http/2/next/emitter"
 require "http/2/next/buffer"
 require "http/2/next/flow_buffer"
-require "http/2/next/huffman"
-require "http/2/next/huffman_statemachine"
-require "http/2/next/compressor"
+require "http/2/next/header"
 require "http/2/next/framer"
 require "http/2/next/connection"
 require "http/2/next/client"

data/lib/http/2/next/buffer.rb

@@ -8,6 +8,8 @@ module HTTP2Next
   class Buffer
     extend Forwardable
 
+    using StringExtensions
+
     def_delegators :@buffer, :ord, :encoding, :setbyte, :unpack,
                    :size, :each_byte, :to_str, :to_s, :length, :inspect,
                    :[], :[]=, :empty?, :bytesize, :include?
@@ -28,6 +30,10 @@ module HTTP2Next
       Buffer.new(@buffer.slice!(0, n))
     end
 
+    def unpack1(*arg)
+      @buffer.unpack1(*arg)
+    end
+
     # Emulate StringIO#getbyte: slice first byte from buffer.
     def getbyte
       read(1).ord
@@ -61,7 +67,7 @@ module HTTP2Next
     # Slice unsigned 32-bit integer from buffer.
     # @return [Integer]
     def read_uint32
-      read(4).unpack(UINT32).first
+      read(4).unpack1(UINT32)
     end
 
     # Ensures that data that is added is binary encoded as well,

data/lib/http/2/next/connection.rb

@@ -57,12 +57,11 @@ module HTTP2Next
     # Size of current connection flow control window (by default, set to
     # infinity, but is automatically updated on receipt of peer settings).
     attr_reader :local_window
-    attr_reader :remote_window
+    attr_reader :remote_window, :remote_settings
     alias window local_window
 
     # Current settings value for local and peer
     attr_reader :local_settings
-    attr_reader :remote_settings
 
     # Pending settings value
     #  Sent but not ack'ed settings
@@ -105,6 +104,7 @@ module HTTP2Next
 
       @h2c_upgrade = nil
       @closed_since = nil
+      @received_frame = false
     end
 
     def closed?
@@ -176,7 +176,7 @@ module HTTP2Next
     # @param settings [Array or Hash]
     def settings(payload)
       payload = payload.to_a
-      connection_error if validate_settings(@local_role, payload)
+      validate_settings(@local_role, payload)
       @pending_settings << payload
       send(type: :settings, stream: 0, payload: payload)
       @pending_settings << payload
@@ -213,6 +213,11 @@ module HTTP2Next
       end
 
       while (frame = @framer.parse(@recv_buffer))
+        if is_a?(Client) && !@received_frame
+          connection_error(:protocol_error, msg: "didn't receive settings") if frame[:type] != :settings
+          @received_frame = true
+        end
+
         # Implementations MUST discard frames
         # that have unknown or unsupported types.
         if frame[:type].nil?
@@ -521,8 +526,6 @@ module HTTP2Next
     def validate_settings(role, settings)
       settings.each do |key, v|
         case key
-        when :settings_header_table_size
-          # Any value is valid
         when :settings_enable_push
           case role
           when :server
@@ -530,32 +533,41 @@ module HTTP2Next
             # Clients MUST reject any attempt to change the
             # SETTINGS_ENABLE_PUSH setting to a value other than 0 by treating the
             # message as a connection error (Section 5.4.1) of type PROTOCOL_ERROR.
-            return ProtocolError.new("invalid #{key} value") unless v.zero?
+            next if v.zero?
+
+            connection_error(:protocol_error, msg: "invalid #{key} value")
           when :client
             # Any value other than 0 or 1 MUST be treated as a
             # connection error (Section 5.4.1) of type PROTOCOL_ERROR.
-            return ProtocolError.new("invalid #{key} value") unless v.zero? || v == 1
+            next if v.zero? || v == 1
+
+            connection_error(:protocol_error, msg: "invalid #{key} value")
           end
-        when :settings_max_concurrent_streams
-          # Any value is valid
         when :settings_initial_window_size
           # Values above the maximum flow control window size of 2^31-1 MUST
           # be treated as a connection error (Section 5.4.1) of type
           # FLOW_CONTROL_ERROR.
-          return FlowControlError.new("invalid #{key} value") unless v <= 0x7fffffff
+          next if v <= 0x7fffffff
+
+          connection_error(:flow_control_error, msg: "invalid #{key} value")
         when :settings_max_frame_size
           # The initial value is 2^14 (16,384) octets.  The value advertised
           # by an endpoint MUST be between this initial value and the maximum
           # allowed frame size (2^24-1 or 16,777,215 octets), inclusive.
           # Values outside this range MUST be treated as a connection error
           # (Section 5.4.1) of type PROTOCOL_ERROR.
-          return ProtocolError.new("invalid #{key} value") unless v >= 16_384 && v <= 16_777_215
-        when :settings_max_header_list_size
+          next if v >= 16_384 && v <= 16_777_215
+
+          connection_error(:protocol_error, msg: "invalid #{key} value")
+          # when :settings_max_concurrent_streams
+          # Any value is valid
+          # when :settings_header_table_size
+          # Any value is valid
+          # when :settings_max_header_list_size
           # Any value is valid
           # else # ignore unknown settings
         end
       end
-      nil
     end
 
     # Update connection settings based on parameters set by the peer.
@@ -572,8 +584,7 @@ module HTTP2Next
                          # Process pending settings we have sent.
                          [@pending_settings.shift, :local]
                        else
-                         check = validate_settings(@remote_role, frame[:payload])
-                         connection_error(check) if check
+                         validate_settings(@remote_role, frame[:payload])
                          [frame[:payload], :remote]
                        end
 
@@ -707,7 +718,7 @@ module HTTP2Next
     # @param priority [Integer]
     # @param window [Integer]
     # @param parent [Stream]
-    def activate_stream(id: nil, **args)
+    def activate_stream(id:, **args)
       connection_error(msg: "Stream ID already exists") if @streams.key?(id)
 
       raise StreamLimitExceeded if @active_stream_count >= (@max_streams || @local_settings[:settings_max_concurrent_streams])

data/lib/http/2/next/emitter.rb

@@ -9,19 +9,18 @@ module HTTP2Next
     #
     # @param event [Symbol]
     # @param block [Proc] callback function
-    def add_listener(event, &block)
+    def on(event, &block)
       raise ArgumentError, "must provide callback" unless block_given?
 
       listeners(event.to_sym).push block
     end
-    alias on add_listener
 
     # Subscribe to next event (at most once) for specified type.
     #
     # @param event [Symbol]
     # @param block [Proc] callback function
     def once(event, &block)
-      add_listener(event) do |*args, &callback|
+      on(event) do |*args, &callback|
         block.call(*args, &callback)
         :delete
       end

data/lib/http/2/next/error.rb

@@ -10,6 +10,7 @@ module HTTP2Next
 
     class Error < StandardError
       def self.inherited(klass)
+        super
         type = klass.name.split("::").last
         type = type.gsub(/([^\^])([A-Z])/, '\1_\2').downcase.to_sym
         HTTP2Next::Error.types[type] = klass

data/lib/http/2/next/extensions.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HTTP2Next
-  module Extensions
+  module RegexpExtensions
     unless Regexp.method_defined?(:match?)
       refine Regexp do
         def match?(*args)
@@ -10,4 +10,14 @@ module HTTP2Next
       end
     end
   end
+
+  module StringExtensions
+    unless String.method_defined?(:unpack1)
+      refine String do
+        def unpack1(format)
+          unpack(format).first
+        end
+      end
+    end
+  end
 end

data/lib/http/2/next/flow_buffer.rb

@@ -73,6 +73,7 @@ module HTTP2Next
 
       while (frame = send_buffer.retrieve(@remote_window))
 
+        # puts "#{self.class} -> #{@remote_window}"
         sent = frame[:payload].bytesize
 
         manage_state(frame) do

data/lib/http/2/next/framer.rb

@@ -4,6 +4,8 @@ module HTTP2Next
   # Performs encoding, decoding, and validation of binary HTTP/2 frames.
   #
   class Framer
+    using StringExtensions
+
     include Error
 
     # Default value of max frame size (16384 bytes)
@@ -154,6 +156,7 @@ module HTTP2Next
     # Decodes common 9-byte header.
     #
     # @param buf [Buffer]
+    # @return [Hash] the corresponding frame
     def read_common_header(buf)
       frame = {}
       len_hi, len_lo, type, flags, stream = buf.slice(0, 9).unpack(HEADERPACK)
@@ -221,7 +224,7 @@ module HTTP2Next
         raise CompressionError, "Invalid stream ID (#{frame[:stream]})" if (frame[:stream]).nonzero?
 
         frame[:payload].each do |(k, v)|
-          if k.is_a? Integer
+          if k.is_a? Integer # rubocop:disable Style/GuardClause
             DEFINED_SETTINGS.value?(k) || next
           else
             k = DEFINED_SETTINGS[k]
@@ -333,10 +336,10 @@ module HTTP2Next
     #
     # @param buf [Buffer]
     def parse(buf)
-      return nil if buf.size < 9
+      return if buf.size < 9
 
       frame = read_common_header(buf)
-      return nil if buf.size < 9 + frame[:length]
+      return if buf.size < 9 + frame[:length]
 
       raise ProtocolError, "payload too large" if frame[:length] > @local_max_frame_size
 
@@ -353,7 +356,7 @@ module HTTP2Next
       if FRAME_TYPES_WITH_PADDING.include?(frame[:type])
         padded = frame[:flags].include?(:padded)
         if padded
-          padlen = payload.read(1).unpack(UINT8).first
+          padlen = payload.read(1).unpack1(UINT8)
           frame[:padding] = padlen + 1
           raise ProtocolError, "padding too long" if padlen > payload.bytesize
 
@@ -395,7 +398,7 @@ module HTTP2Next
         raise ProtocolError, "Invalid stream ID (#{frame[:stream]})" if (frame[:stream]).nonzero?
 
         (frame[:length] / 6).times do
-          id  = payload.read(2).unpack(UINT16).first
+          id  = payload.read(2).unpack1(UINT16)
           val = payload.read_uint32
 
           # Unsupported or unrecognized settings MUST be ignored.
@@ -437,7 +440,7 @@ module HTTP2Next
         origins = []
 
         until payload.empty?
-          len = payload.read(2).unpack(UINT16).first
+          len = payload.read(2).unpack1(UINT16)
           origins << payload.read(len)
         end
 
@@ -452,17 +455,16 @@ module HTTP2Next
 
     def pack_error(e)
       unless e.is_a? Integer
-        raise CompressionError, "Unknown error ID for #{e}" if DEFINED_ERRORS[e].nil?
-
         e = DEFINED_ERRORS[e]
+
+        raise CompressionError, "Unknown error ID for #{e}" unless e
       end
 
       [e].pack(UINT32)
     end
 
     def unpack_error(error)
-      name, = DEFINED_ERRORS.find { |_name, v| v == error }
-      name || error
+      DEFINED_ERRORS.key(error) || error
     end
   end
 end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module HTTP2Next
+  # Implementation of header compression for HTTP 2.0 (HPACK) format adapted
+  # to efficiently represent HTTP headers in the context of HTTP 2.0.
+  #
+  # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10
+  module Header
+    # Header representation as defined by the spec.
+    HEADREP = {
+      indexed: { prefix: 7, pattern: 0x80 },
+      incremental: { prefix: 6, pattern: 0x40 },
+      noindex: { prefix: 4, pattern: 0x00 },
+      neverindexed: { prefix: 4, pattern: 0x10 },
+      changetablesize: { prefix: 5, pattern: 0x20 }
+    }.each_value(&:freeze).freeze
+
+    # Predefined options set for Compressor
+    # http://mew.org/~kazu/material/2014-hpack.pdf
+    NAIVE    = { index: :never,  huffman: :never   }.freeze
+    LINEAR   = { index: :all,    huffman: :never   }.freeze
+    STATIC   = { index: :static, huffman: :never   }.freeze
+    SHORTER  = { index: :all,    huffman: :never   }.freeze
+    NAIVEH   = { index: :never,  huffman: :always  }.freeze
+    LINEARH  = { index: :all,    huffman: :always  }.freeze
+    STATICH  = { index: :static, huffman: :always  }.freeze
+    SHORTERH = { index: :all,    huffman: :shorter }.freeze
+  end
+end
+
+require "http/2/next/header/huffman"
+require "http/2/next/header/huffman_statemachine"
+require "http/2/next/header/encoding_context"
+require "http/2/next/header/compressor"
+require "http/2/next/header/decompressor"

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module HTTP2Next
+  module Header
+    # Responsible for encoding header key-value pairs using HPACK algorithm.
+    class Compressor
+      # @param options [Hash] encoding options
+      def initialize(options = {})
+        @cc = EncodingContext.new(options)
+      end
+
+      # Set dynamic table size in EncodingContext
+      # @param size [Integer] new dynamic table size
+      def table_size=(size)
+        @cc.table_size = size
+      end
+
+      # Encodes provided value via integer representation.
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10#section-5.1
+      #
+      #  If I < 2^N - 1, encode I on N bits
+      #  Else
+      #      encode 2^N - 1 on N bits
+      #      I = I - (2^N - 1)
+      #      While I >= 128
+      #           Encode (I % 128 + 128) on 8 bits
+      #           I = I / 128
+      #      encode (I) on 8 bits
+      #
+      # @param i [Integer] value to encode
+      # @param n [Integer] number of available bits
+      # @return [String] binary string
+      def integer(i, n)
+        limit = 2**n - 1
+        return [i].pack("C") if i < limit
+
+        bytes = []
+        bytes.push limit unless n.zero?
+
+        i -= limit
+        while i >= 128
+          bytes.push((i % 128) + 128)
+          i /= 128
+        end
+
+        bytes.push i
+        bytes.pack("C*")
+      end
+
+      # Encodes provided value via string literal representation.
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10#section-5.2
+      #
+      # * The string length, defined as the number of bytes needed to store
+      #   its UTF-8 representation, is represented as an integer with a seven
+      #   bits prefix. If the string length is strictly less than 127, it is
+      #   represented as one byte.
+      # * If the bit 7 of the first byte is 1, the string value is represented
+      #   as a list of Huffman encoded octets
+      #   (padded with bit 1's until next octet boundary).
+      # * If the bit 7 of the first byte is 0, the string value is
+      #   represented as a list of UTF-8 encoded octets.
+      #
+      # +@options [:huffman]+ controls whether to use Huffman encoding:
+      #  :never   Do not use Huffman encoding
+      #  :always  Always use Huffman encoding
+      #  :shorter Use Huffman when the result is strictly shorter
+      #
+      # @param str [String]
+      # @return [String] binary string
+      def string(str)
+        plain = nil
+        huffman = nil
+        plain = integer(str.bytesize, 7) << str.dup.force_encoding(Encoding::BINARY) unless @cc.options[:huffman] == :always
+        unless @cc.options[:huffman] == :never
+          huffman = Huffman.new.encode(str)
+          huffman = integer(huffman.bytesize, 7) << huffman
+          huffman.setbyte(0, huffman.ord | 0x80)
+        end
+        case @cc.options[:huffman]
+        when :always
+          huffman
+        when :never
+          plain
+        else
+          huffman.bytesize < plain.bytesize ? huffman : plain
+        end
+      end
+
+      # Encodes header command with appropriate header representation.
+      #
+      # @param h [Hash] header command
+      # @param buffer [String]
+      # @return [Buffer]
+      def header(h, buffer = Buffer.new)
+        rep = HEADREP[h[:type]]
+
+        case h[:type]
+        when :indexed
+          buffer << integer(h[:name] + 1, rep[:prefix])
+        when :changetablesize
+          buffer << integer(h[:value], rep[:prefix])
+        else
+          if h[:name].is_a? Integer
+            buffer << integer(h[:name] + 1, rep[:prefix])
+          else
+            buffer << integer(0, rep[:prefix])
+            buffer << string(h[:name])
+          end
+
+          buffer << string(h[:value])
+        end
+
+        # set header representation pattern on first byte
+        fb = buffer.ord | rep[:pattern]
+        buffer.setbyte(0, fb)
+
+        buffer
+      end
+
+      # Encodes provided list of HTTP headers.
+      #
+      # @param headers [Array] +[[name, value], ...]+
+      # @return [Buffer]
+      def encode(headers)
+        buffer = Buffer.new
+        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)
+        end
+
+        buffer
+      end
+    end
+  end
+end