http-2 0.8.4 → 0.10.2

data/example/upgrade_server.rb

@@ -39,7 +39,7 @@ end
 
 class UpgradeHandler
   VALID_UPGRADE_METHODS = %w(GET OPTIONS).freeze
-  UPGRADE_RESPONSE = <<-RESP
+  UPGRADE_RESPONSE = <<RESP.freeze
 HTTP/1.1 101 Switching Protocols
 Connection: Upgrade
 Upgrade: h2c
@@ -191,7 +191,7 @@ loop do
         conn << data
       end
 
-    rescue => e
+    rescue StandardError => e
       puts "Exception: #{e}, #{e.message} - closing socket."
       puts e.backtrace.last(10).join("\n")
       sock.close

data/http-2.gemspec

@@ -1,5 +1,4 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('./lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'http/2/version'
 
@@ -19,5 +18,5 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'bundler'
 end

data/lib/http/2/client.rb

@@ -38,14 +38,31 @@ module HTTP2
       super(frame)
     end
 
+    def receive(frame)
+      send_connection_preface
+      super(frame)
+    end
+
+    # sends the preface and initializes the first stream in half-closed state
+    def upgrade
+      fail ProtocolError unless @stream_id == 1
+      send_connection_preface
+      new_stream(state: :half_closed_local)
+    end
+
     # Emit the connection preface if not yet
     def send_connection_preface
       return unless @state == :waiting_connection_preface
       @state = :connected
       emit(:frame, CONNECTION_PREFACE_MAGIC)
 
-      payload = @local_settings.select { |k, v| v != SPEC_DEFAULT_CONNECTION_SETTINGS[k] }
+      payload = @local_settings.reject { |k, v| v == SPEC_DEFAULT_CONNECTION_SETTINGS[k] }
       settings(payload)
     end
+
+    def self.settings_header(**settings)
+      frame = Framer.new.generate(type: :settings, stream: 0, payload: settings)
+      Base64.urlsafe_encode64(frame[9..-1])
+    end
   end
 end

data/lib/http/2/compressor.rb

@@ -139,12 +139,16 @@ module HTTP2
       # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10#section-4.1
       #
       # @param cmd [Hash] { type:, name:, value:, index: }
-      # @return [Array] +[name, value]+ header field that is added to the decoded header list
+      # @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
 
         case cmd[:type]
         when :changetablesize
+          if cmd[:value] > @limit
+            fail CompressionError, 'dynamic table size update exceed limit'
+          end
           self.table_size = cmd[:value]
 
         when :indexed
@@ -199,8 +203,12 @@ module HTTP2
         commands = []
         # Literals commands are marked with :noindex when index is not used
         noindex = [:static, :never].include?(@options[:index])
-        headers.each do |h|
-          cmd = addcmd(h)
+        headers.each do |field, value|
+          # Literal header names MUST be translated to lowercase before
+          # encoding and transmission.
+          field = field.downcase
+          value = '/' if field == ':path' && value.empty?
+          cmd = addcmd(field, value)
           cmd[:type] = :noindex if noindex && cmd[:type] == :incremental
           commands << cmd
           process(cmd)
@@ -220,7 +228,7 @@ module HTTP2
       #
       # @param header [Array] +[name, value]+
       # @return [Hash] command
-      def addcmd(header)
+      def addcmd(*header)
         exact = nil
         name_only = nil
 
@@ -441,11 +449,8 @@ module HTTP2
       # @return [Buffer]
       def encode(headers)
         buffer = Buffer.new
-
-        # Literal header names MUST be translated to lowercase before
-        # encoding and transmission.
-        headers.map! { |hk, hv| [hk.downcase, hv] }
-
+        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)
@@ -549,8 +554,18 @@ module HTTP2
       # @return [Array] +[[name, value], ...]+
       def decode(buf)
         list = []
-        list << @cc.process(header(buf)) until buf.empty?
-        list.compact
+        decoding_pseudo_headers = true
+        until buf.empty?
+          next_header = @cc.process(header(buf))
+          next if next_header.nil?
+          is_pseudo_header = next_header.first.start_with? ':'
+          if !decoding_pseudo_headers && is_pseudo_header
+            fail ProtocolError, 'one or more pseudo headers encountered after regular headers'
+          end
+          decoding_pseudo_headers = is_pseudo_header
+          list << next_header
+        end
+        list
       end
     end
   end

data/lib/http/2/connection.rb

@@ -20,9 +20,9 @@ module HTTP2
 
   DEFAULT_CONNECTION_SETTINGS = {
     settings_header_table_size:       4096,
-    settings_enable_push:             1,     # enabled for servers
+    settings_enable_push:             1,                     # enabled for servers
     settings_max_concurrent_streams:  100,
-    settings_initial_window_size:     65_535, #
+    settings_initial_window_size:     65_535,
     settings_max_frame_size:          16_384,
     settings_max_header_list_size:    2**31 - 1,             # unlimited
   }.freeze
@@ -33,6 +33,9 @@ module HTTP2
   # Default connection "fast-fail" preamble string as defined by the spec.
   CONNECTION_PREFACE_MAGIC = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n".freeze
 
+  # Time to hold recently closed streams until purge (seconds)
+  RECENTLY_CLOSED_STREAMS_TTL = 15
+
   # Connection encapsulates all of the connection, stream, flow-control,
   # error management, and other processing logic required for a well-behaved
   # HTTP 2.0 endpoint.
@@ -49,9 +52,6 @@ module HTTP2
     # Connection state (:new, :closed).
     attr_reader :state
 
-    # Last connection error if connection is aborted.
-    attr_reader :error
-
     # 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
@@ -95,6 +95,13 @@ module HTTP2
       @send_buffer = []
       @continuation = []
       @error = nil
+
+      @h2c_upgrade = nil
+      @closed_since = nil
+    end
+
+    def closed?
+      @state == :closed
     end
 
     # Allocates new stream for current connection.
@@ -141,12 +148,14 @@ module HTTP2
       send(type: :goaway, last_stream: last_stream,
            error: error, payload: payload)
       @state = :closed
+      @closed_since = Time.now
     end
 
     # Sends a WINDOW_UPDATE frame to the peer.
     #
     # @param increment [Integer]
     def window_update(increment)
+      @local_window += increment
       send(type: :window_update, stream: 0, increment: increment)
     end
 
@@ -312,6 +321,10 @@ module HTTP2
           else
             if (stream = @streams[frame[:stream]])
               stream << frame
+              if frame[:type] == :data
+                update_local_window(frame)
+                calculate_window_update(@local_window_limit)
+              end
             else
               case frame[:type]
               # The PRIORITY frame can be sent for a stream in the "idle" or
@@ -346,11 +359,14 @@ module HTTP2
         end
       end
 
-    rescue => e
+    rescue StandardError => e
       raise if e.is_a?(Error::Error)
       connection_error(e: e)
     end
-    alias << receive
+
+    def <<(*args)
+      receive(*args)
+    end
 
     private
 
@@ -438,12 +454,22 @@ module HTTP2
           # the connection, although a new connection can be established
           # for new streams.
           @state = :closed
+          @closed_since = Time.now
           emit(:goaway, frame[:last_stream], frame[:error], frame[:payload])
-        when :altsvc, :blocked
+        when :altsvc
+          # 4.  The ALTSVC HTTP/2 Frame
+          # An ALTSVC frame on stream 0 with empty (length 0) "Origin"
+          # information is invalid and MUST be ignored.
+          if frame[:origin] && !frame[:origin].empty?
+            emit(frame[:type], frame)
+          end
+        when :blocked
           emit(frame[:type], frame)
         else
           connection_error
         end
+      when :closed
+        connection_error if (Time.now - @closed_since) > 15
       else
         connection_error
       end
@@ -488,7 +514,7 @@ module HTTP2
           # 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.
-          unless 16_384 <= v && v <= 16_777_215
+          unless v >= 16_384 && v <= 16_777_215
             return ProtocolError.new("invalid #{key} value")
           end
         when :settings_max_header_list_size
@@ -598,8 +624,12 @@ module HTTP2
         frame[:payload] = @decompressor.decode(frame[:payload])
       end
 
-    rescue => e
+    rescue CompressionError => e
       connection_error(:compression_error, e: e)
+    rescue ProtocolError => e
+      connection_error(:protocol_error, e: e)
+    rescue StandardError => e
+      connection_error(:internal_error, e: e)
     end
 
     # Encode headers payload and update connection compressor state.
@@ -629,7 +659,7 @@ module HTTP2
 
       frames
 
-    rescue => e
+    rescue StandardError => e
       connection_error(:compression_error, e: e)
       nil
     end
@@ -651,24 +681,38 @@ module HTTP2
       # permitted to open.
       stream.once(:active) { @active_stream_count += 1 }
       stream.once(:close) do
-        @streams.delete id
         @active_stream_count -= 1
 
         # Store a reference to the closed stream, such that we can respond
         # to any in-flight frames while close is registered on both sides.
         # References to such streams will be purged whenever another stream
-        # is closed, with a minimum of 15s RTT time window.
-        @streams_recently_closed.delete_if { |_, v| (Time.now - v) > 15 }
-        @streams_recently_closed[id] = Time.now
+        # is closed, with a defined RTT time window.
+        @streams_recently_closed[id] = Time.now.to_i
+        cleanup_recently_closed
       end
 
       stream.on(:promise, &method(:promise)) if self.is_a? Server
       stream.on(:frame,   &method(:send))
-      stream.on(:window_update, &method(:window_update))
 
       @streams[id] = stream
     end
 
+    # Purge recently streams closed within defined RTT time window.
+    def cleanup_recently_closed
+      now_ts = Time.now.to_i
+      to_delete = []
+      @streams_recently_closed.each do |stream_id, ts|
+        # Ruby Hash enumeration is ordered, so once fresh stream is met we can stop searching.
+        break if now_ts - ts < RECENTLY_CLOSED_STREAMS_TTL
+        to_delete << stream_id
+      end
+
+      to_delete.each do |stream_id|
+        @streams.delete stream_id
+        @streams_recently_closed.delete stream_id
+      end
+    end
+
     # Emit GOAWAY error indicating to peer that the connection is being
     # aborted, and once sent, raise a local exception.
     #
@@ -689,9 +733,11 @@ module HTTP2
       backtrace = (e && e.backtrace) || []
       fail Error.const_get(klass), msg, backtrace
     end
+    alias error connection_error
 
     def manage_state(_)
       yield
     end
   end
+  # rubocop:enable ClassLength
 end

data/lib/http/2/flow_buffer.rb

@@ -13,6 +13,37 @@ module HTTP2
 
     private
 
+    def update_local_window(frame)
+      frame_size = frame[:payload].bytesize
+      frame_size += frame[:padding] || 0
+      @local_window -= frame_size
+    end
+
+    def calculate_window_update(window_max_size)
+      # If DATA frame is received with length > 0 and
+      # current received window size + delta length is strictly larger than
+      # local window size, it throws a flow control error.
+      #
+      error(:flow_control_error) if @local_window < 0
+
+      # Send WINDOW_UPDATE if the received window size goes over
+      # the local window size / 2.
+      #
+      # The HTTP/2 spec mandates that every DATA frame received
+      # generates a WINDOW_UPDATE to send. In some cases however,
+      # (ex: DATA frames with short payloads),
+      # the noise generated by flow control frames creates enough
+      # congestion for this to be deemed very inefficient.
+      #
+      # This heuristic was inherited from nghttp, which delays the
+      # WINDOW_UPDATE until at least half the window is exhausted.
+      # This works because the sender doesn't need those increments
+      # until the receiver window is exhausted, after which he'll be
+      # waiting for the WINDOW_UPDATE frame.
+      return unless @local_window <= (window_max_size / 2)
+      window_update(window_max_size - @local_window)
+    end
+
     # Buffers outgoing DATA frames and applies flow control logic to split
     # and emit DATA frames based on current flow control window. If the
     # window is large enough, the data is sent immediately. Otherwise, the

data/lib/http/2/framer.rb

@@ -359,14 +359,14 @@ module HTTP2
         if frame[:flags].include? :priority
           e_sd = payload.read_uint32
           frame[:stream_dependency] = e_sd & RBIT
-          frame[:exclusive] = (e_sd & EBIT) != 0 # rubocop:disable Style/NumericPredicate
+          frame[:exclusive] = (e_sd & EBIT) != 0
           frame[:weight] = payload.getbyte + 1
         end
         frame[:payload] = payload.read(frame[:length])
       when :priority
         e_sd = payload.read_uint32
         frame[:stream_dependency] = e_sd & RBIT
-        frame[:exclusive] = (e_sd & EBIT) != 0 # rubocop:disable Style/NumericPredicate
+        frame[:exclusive] = (e_sd & EBIT) != 0
         frame[:weight] = payload.getbyte + 1
       when :rst_stream
         frame[:error] = unpack_error payload.read_uint32
@@ -442,4 +442,5 @@ module HTTP2
       name || error
     end
   end
+  # rubocop:enable ClassLength
 end

data/lib/http/2/stream.rb

@@ -71,22 +71,28 @@ module HTTP2
     # @param exclusive [Boolean]
     # @param window [Integer]
     # @param parent [Stream]
-    def initialize(connection:, id:, weight: 16, dependency: 0, exclusive: false, parent: nil)
+    # @param state [Symbol]
+    def initialize(connection:, id:, weight: 16, dependency: 0, exclusive: false, parent: nil, state: :idle)
       @connection = connection
       @id = id
       @weight = weight
       @dependency = dependency
       process_priority(weight: weight, stream_dependency: dependency, exclusive: exclusive)
+      @local_window_max_size = connection.local_settings[:settings_initial_window_size]
       @local_window  = connection.local_settings[:settings_initial_window_size]
       @remote_window = connection.remote_settings[:settings_initial_window_size]
       @parent = parent
-      @state  = :idle
+      @state  = state
       @error  = false
       @closed = false
       @send_buffer = []
 
       on(:window) { |v| @remote_window = v }
-      on(:local_window) { |v| @local_window = v }
+      on(:local_window) { |v| @local_window_max_size = @local_window = v }
+    end
+
+    def closed?
+      @state == :closed
     end
 
     # Processes incoming HTTP 2.0 frames. The frames must be decoded upstream.
@@ -97,21 +103,27 @@ module HTTP2
 
       case frame[:type]
       when :data
-        window_size = frame[:payload].bytesize
-        window_size += frame[:padding] || 0
-        @local_window -= window_size
+        update_local_window(frame)
+        # Emit DATA frame
         emit(:data, frame[:payload]) unless frame[:ignore]
-
-        # Automatically send WINDOW_UPDATE,
-        # assuming that emit(:data) can now receive next data
-        window_update(window_size) if window_size > 0
-      when :headers, :push_promise
+        calculate_window_update(@local_window_max_size)
+      when :headers
         emit(:headers, frame[:payload]) unless frame[:ignore]
+      when :push_promise
+        emit(:promise_headers, frame[:payload]) unless frame[:ignore]
       when :priority
         process_priority(frame)
       when :window_update
         process_window_update(frame)
-      when :altsvc, :blocked
+      when :altsvc
+        # 4.  The ALTSVC HTTP/2 Frame
+        # An ALTSVC frame on a
+        # stream other than stream 0 containing non-empty "Origin" information
+        # is invalid and MUST be ignored.
+        if !frame[:origin] || frame[:origin].empty?
+          emit(frame[:type], frame)
+        end
+      when :blocked
         emit(frame[:type], frame)
       end
 
@@ -144,6 +156,7 @@ module HTTP2
     end
 
     # Sends a HEADERS frame containing HTTP response headers.
+    # All pseudo-header fields MUST appear in the header block before regular header fields.
     #
     # @param headers [Array or Hash] Array of key-value pairs or Hash
     # @param end_headers [Boolean] indicates that no more headers will be sent
@@ -153,7 +166,7 @@ module HTTP2
       flags << :end_headers if end_headers
       flags << :end_stream  if end_stream
 
-      send(type: :headers, flags: flags, payload: headers.to_a)
+      send(type: :headers, flags: flags, payload: headers)
     end
 
     def promise(headers, end_headers: true, &block)
@@ -228,8 +241,6 @@ module HTTP2
     #
     # @param increment [Integer]
     def window_update(increment)
-      # always emit connection-level WINDOW_UPDATE
-      emit(:window_update, increment)
       # emit stream-level WINDOW_UPDATE unless stream is closed
       return if @state == :closed || @state == :remote_closed
       send(type: :window_update, increment: increment)
@@ -602,6 +613,7 @@ module HTTP2
       klass = error.to_s.split('_').map(&:capitalize).join
       fail Error.const_get(klass), msg
     end
+    alias error stream_error
 
     def manage_state(frame)
       transition(frame, true)