http-2 0.9.0 → 0.11.0

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
@@ -76,8 +76,8 @@ module HTTP2
       @local_settings  = DEFAULT_CONNECTION_SETTINGS.merge(settings)
       @remote_settings = SPEC_DEFAULT_CONNECTION_SETTINGS.dup
 
-      @compressor   = Header::Compressor.new(settings)
-      @decompressor = Header::Decompressor.new(settings)
+      @compressor   = Header::Compressor.new(**settings)
+      @decompressor = Header::Decompressor.new(**settings)
 
       @active_stream_count = 0
       @streams = {}
@@ -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,6 +148,7 @@ 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.
@@ -351,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
 
@@ -443,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
@@ -493,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
@@ -518,7 +539,7 @@ module HTTP2
         # Process pending settings we have sent.
         [@pending_settings.shift, :local]
       else
-        connection_error(check) if validate_settings(@remote_role, frame[:payload])
+        connection_error if validate_settings(@remote_role, frame[:payload])
         [frame[:payload], :remote]
       end
 
@@ -572,7 +593,8 @@ module HTTP2
           # nothing to do
 
         when :settings_max_frame_size
-          # nothing to do
+          # update framer max_frame_size
+          @framer.max_frame_size = v
 
           # else # ignore unknown settings
         end
@@ -603,8 +625,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.
@@ -634,7 +660,7 @@ module HTTP2
 
       frames
 
-    rescue => e
+    rescue StandardError => e
       connection_error(:compression_error, e: e)
       nil
     end
@@ -649,22 +675,21 @@ module HTTP2
     def activate_stream(id: nil, **args)
       connection_error(msg: 'Stream ID already exists') if @streams.key?(id)
 
-      stream = Stream.new({ connection: self, id: id }.merge(args))
+      stream = Stream.new(**{ connection: self, id: id }.merge(args))
 
       # Streams that are in the "open" state, or either of the "half closed"
       # states count toward the maximum number of streams that an endpoint is
       # 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
@@ -673,6 +698,22 @@ module HTTP2
       @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.
     #
@@ -699,4 +740,5 @@ module HTTP2
       yield
     end
   end
+  # rubocop:enable ClassLength
 end

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

@@ -91,6 +91,10 @@ module HTTP2
       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.
     #
     # @param frame [Hash]
@@ -111,7 +115,15 @@ module HTTP2
         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

data/lib/http/2/version.rb

@@ -1,3 +1,3 @@
 module HTTP2
-  VERSION = '0.9.0'.freeze
+  VERSION = '0.11.0'.freeze
 end

data/spec/client_spec.rb

@@ -1,6 +1,7 @@
 require 'helper'
 
 RSpec.describe HTTP2::Client do
+  include FrameHelpers
   before(:each) do
     @client = Client.new
   end
@@ -32,6 +33,18 @@ RSpec.describe HTTP2::Client do
       expect(frame[:type]).to eq :settings
       expect(frame[:payload]).to include([:settings_max_concurrent_streams, 200])
     end
+
+    it 'should initialize client when receiving server settings before sending ack' do
+      frames = []
+      @client.on(:frame) { |bytes| frames << bytes }
+      @client << f.generate(settings_frame)
+
+      expect(frames[0]).to eq CONNECTION_PREFACE_MAGIC
+      expect(f.parse(frames[1])[:type]).to eq :settings
+      ack_frame = f.parse(frames[2])
+      expect(ack_frame[:type]).to eq :settings
+      expect(ack_frame[:flags]).to include(:ack)
+    end
   end
 
   context 'upgrade' do
@@ -60,33 +73,33 @@ RSpec.describe HTTP2::Client do
 
     it 'should raise error on PUSH_PROMISE against stream 0' do
       expect do
-        @client << set_stream_id(f.generate(PUSH_PROMISE.dup), 0)
+        @client << set_stream_id(f.generate(push_promise_frame), 0)
       end.to raise_error(ProtocolError)
     end
 
     it 'should raise error on PUSH_PROMISE against bogus stream' do
       expect do
-        @client << set_stream_id(f.generate(PUSH_PROMISE.dup), 31_415)
+        @client << set_stream_id(f.generate(push_promise_frame), 31_415)
       end.to raise_error(ProtocolError)
     end
 
     it 'should raise error on PUSH_PROMISE against non-idle stream' do
       expect do
         s = @client.new_stream
-        s.send HEADERS.dup
+        s.send headers_frame
 
-        @client << set_stream_id(f.generate(PUSH_PROMISE.dup), s.id)
-        @client << set_stream_id(f.generate(PUSH_PROMISE.dup), s.id)
+        @client << set_stream_id(f.generate(push_promise_frame), s.id)
+        @client << set_stream_id(f.generate(push_promise_frame), s.id)
       end.to raise_error(ProtocolError)
     end
 
     it 'should emit stream object for received PUSH_PROMISE' do
       s = @client.new_stream
-      s.send HEADERS.deep_dup
+      s.send headers_frame
 
       promise = nil
       @client.on(:promise) { |stream| promise = stream }
-      @client << set_stream_id(f.generate(PUSH_PROMISE.deep_dup), s.id)
+      @client << set_stream_id(f.generate(push_promise_frame), s.id)
 
       expect(promise.id).to eq 2
       expect(promise.state).to eq :reserved_remote
@@ -95,14 +108,14 @@ RSpec.describe HTTP2::Client do
     it 'should emit promise headers for received PUSH_PROMISE' do
       header = nil
       s = @client.new_stream
-      s.send HEADERS.deep_dup
+      s.send headers_frame
 
       @client.on(:promise) do |stream|
         stream.on(:promise_headers) do |h|
           header = h
         end
       end
-      @client << set_stream_id(f.generate(PUSH_PROMISE.deep_dup), s.id)
+      @client << set_stream_id(f.generate(push_promise_frame), s.id)
 
       expect(header).to be_a(Array)
       # expect(header).to eq([%w(a b)])
@@ -110,7 +123,7 @@ RSpec.describe HTTP2::Client do
 
     it 'should auto RST_STREAM promises against locally-RST stream' do
       s = @client.new_stream
-      s.send HEADERS.deep_dup
+      s.send headers_frame
       s.close
 
       allow(@client).to receive(:send)
@@ -119,7 +132,57 @@ RSpec.describe HTTP2::Client do
         expect(frame[:stream]).to eq 2
       end
 
-      @client << set_stream_id(f.generate(PUSH_PROMISE.dup), s.id)
+      @client << set_stream_id(f.generate(push_promise_frame), s.id)
+    end
+  end
+
+  context 'alt-svc' do
+    context 'received in the connection' do
+      it 'should emit :altsvc when receiving one' do
+        @client << f.generate(settings_frame)
+        frame = nil
+        @client.on(:altsvc) do |f|
+          frame = f
+        end
+        @client << f.generate(altsvc_frame)
+        expect(frame).to be_a(Hash)
+      end
+      it 'should not emit :altsvc when the frame when contains no host' do
+        @client << f.generate(settings_frame)
+        frame = nil
+        @client.on(:altsvc) do |f|
+          frame = f
+        end
+
+        @client << f.generate(altsvc_frame.merge(origin: nil))
+        expect(frame).to be_nil
+      end
+    end
+    context 'received in a stream' do
+      it 'should emit :altsvc' do
+        s = @client.new_stream
+        s.send headers_frame
+        s.close
+
+        frame = nil
+        s.on(:altsvc) { |f| frame = f }
+
+        @client << set_stream_id(f.generate(altsvc_frame.merge(origin: nil)), s.id)
+
+        expect(frame).to be_a(Hash)
+      end
+      it 'should not emit :alt_svc when the frame when contains a origin' do
+        s = @client.new_stream
+        s.send headers_frame
+        s.close
+
+        frame = nil
+        s.on(:altsvc) { |f| frame = f }
+
+        @client << set_stream_id(f.generate(altsvc_frame), s.id)
+
+        expect(frame).to be_nil
+      end
     end
   end
 end

data/spec/compressor_spec.rb

@@ -236,6 +236,12 @@ RSpec.describe HTTP2::Header do
         expect(cc.table.size).to be 1
         expect(cc.table.first[0]).to eq 'test2'
       end
+
+      it 'should reject table size update if exceed limit' do
+        cc = EncodingContext.new(table_size: 4096)
+
+        expect { cc.process(type: :changetablesize, value: 150_000_000) }.to raise_error(CompressionError)
+      end
     end
 
     context 'encode' do
@@ -351,6 +357,78 @@ RSpec.describe HTTP2::Header do
         },
       ],
     },
+    { title: 'D.4.a.  Request Examples with Huffman - Client Handling of Improperly Ordered Headers',
+      type: :request,
+      table_size: 4096,
+      huffman: :always,
+      streams: [
+        { wire: '8286 8441 8cf1 e3c2 e5f2 3a6b a0ab 90f4 ff',
+          emitted: [
+            [':method', 'GET'],
+            [':scheme', 'http'],
+            [':path', '/'],
+            [':authority', 'www.example.com'],
+          ],
+          table: [
+            [':authority', 'www.example.com'],
+          ],
+          table_size: 57,
+        },
+        { wire: '8286 84be 5886 a8eb 1064 9cbf',
+          emitted: [
+            [':method', 'GET'],
+            [':scheme', 'http'],
+            ['cache-control', 'no-cache'],
+            [':path', '/'],
+            [':authority', 'www.example.com'],
+          ],
+          table: [
+            ['cache-control', 'no-cache'],
+            [':authority', 'www.example.com'],
+          ],
+          table_size: 110,
+        },
+        { wire: "8287 85bf 4088 25a8 49e9 5ba9 7d7f 8925
+                 a849 e95b b8e8 b4bf",
+          emitted: [
+            [':method', 'GET'],
+            [':scheme', 'https'],
+            ['custom-key', 'custom-value'],
+            [':path', '/index.html'],
+            [':authority', 'www.example.com'],
+          ],
+          table: [
+            ['custom-key', 'custom-value'],
+            ['cache-control', 'no-cache'],
+            [':authority', 'www.example.com'],
+          ],
+          table_size: 164,
+        },
+      ],
+    },
+    { title: 'D.4.b.  Request Examples with Huffman - Server Handling of Improperly Ordered Headers',
+      type: :request,
+      bypass_encoder: true,
+      table_size: 4096,
+      huffman: :always,
+      streams: [
+        { wire: '8286408825a849e95ba97d7f8925a849e95bb8e8b4bf84418cf1e3c2e5f23a6ba0ab90f4ff',
+          emitted: [
+            [':method', 'GET'],
+            [':scheme', 'http'],
+            ['custom-key', 'custom-value'],
+            [':path', '/'],
+            [':authority', 'www.example.com'],
+          ],
+          table: [
+            ['custom-key', 'custom-value'],
+            [':authority', 'www.example.com'],
+          ],
+          table_size: 111,
+          has_bad_headers: true,
+        },
+      ],
+    },
     { title: 'D.5.  Response Examples without Huffman',
       type: :response,
       table_size: 256,
@@ -474,6 +552,22 @@ RSpec.describe HTTP2::Header do
         },
       ],
     },
+    { title: 'D.6.a.  Response Examples with Huffman - dynamic table size updates should not trigger exceptions',
+      type: :response,
+      table_size: 4096,
+      huffman: :always,
+      bypass_encoder: true,
+      streams: [
+        { wire: '2088 7689 aa63 55e5 80ae 16d7 17',
+          emitted: [
+            [':status', '200'],
+            ['server', 'nginx/1.15.2'],
+          ],
+          table: [],
+          table_size: 0,
+        },
+      ],
+    },
   ]
 
   context 'decode' do
@@ -485,25 +579,38 @@ RSpec.describe HTTP2::Header do
             before do
               (0...nth).each do |i|
                 bytes = [ex[:streams][i][:wire].delete(" \n")].pack('H*')
-                @dc.decode(HTTP2::Buffer.new(bytes))
+                if ex[:streams][i][:has_bad_headers]
+                  expect { @dc.decode(HTTP2::Buffer.new(bytes)) }.to raise_error ProtocolError
+                else
+                  @dc.decode(HTTP2::Buffer.new(bytes))
+                end
               end
             end
-            subject do
-              bytes = [ex[:streams][nth][:wire].delete(" \n")].pack('H*')
-              @emitted = @dc.decode(HTTP2::Buffer.new(bytes))
-            end
-            it 'should emit expected headers' do
-              subject
-              # order-perserving compare
-              expect(@emitted).to eq ex[:streams][nth][:emitted]
-            end
-            it 'should update header table' do
-              subject
-              expect(@dc.instance_eval { @cc.table }).to eq ex[:streams][nth][:table]
-            end
-            it 'should compute header table size' do
-              subject
-              expect(@dc.instance_eval { @cc.current_table_size }).to eq ex[:streams][nth][:table_size]
+            if ex[:streams][nth][:has_bad_headers]
+              it 'should raise CompressionError' do
+                bytes = [ex[:streams][nth][:wire].delete(" \n")].pack('H*')
+                expect { @dc.decode(HTTP2::Buffer.new(bytes)) }.to raise_error ProtocolError
+              end
+            else
+              subject do
+                bytes = [ex[:streams][nth][:wire].delete(" \n")].pack('H*')
+                @emitted = @dc.decode(HTTP2::Buffer.new(bytes))
+              end
+              it 'should emit expected headers' do
+                subject
+                # partitioned compare
+                pseudo_headers, headers = ex[:streams][nth][:emitted].partition { |f, _| f.start_with? ':' }
+                partitioned_headers = pseudo_headers + headers
+                expect(@emitted).to eq partitioned_headers
+              end
+              it 'should update header table' do
+                subject
+                expect(@dc.instance_eval { @cc.table }).to eq ex[:streams][nth][:table]
+              end
+              it 'should compute header table size' do
+                subject
+                expect(@dc.instance_eval { @cc.current_table_size }).to eq ex[:streams][nth][:table_size]
+              end
             end
           end
         end
@@ -513,6 +620,7 @@ RSpec.describe HTTP2::Header do
 
   context 'encode' do
     spec_examples.each do |ex|
+      next if ex[:bypass_encoder]
       context "spec example #{ex[:title]}" do
         ex[:streams].size.times do |nth|
           context "request #{nth + 1}" do
@@ -522,22 +630,33 @@ RSpec.describe HTTP2::Header do
             end
             before do
               (0...nth).each do |i|
-                @cc.encode(ex[:streams][i][:emitted])
+                if ex[:streams][i][:has_bad_headers]
+                  @cc.encode(ex[:streams][i][:emitted], ensure_proper_ordering: false)
+                else
+                  @cc.encode(ex[:streams][i][:emitted])
+                end
               end
             end
             subject do
-              @cc.encode(ex[:streams][nth][:emitted])
+              if ex[:streams][nth][:has_bad_headers]
+                @cc.encode(ex[:streams][nth][:emitted], ensure_proper_ordering: false)
+              else
+                @cc.encode(ex[:streams][nth][:emitted])
+              end
             end
             it 'should emit expected bytes on wire' do
+              puts subject.unpack('H*').first
               expect(subject.unpack('H*').first).to eq ex[:streams][nth][:wire].delete(" \n")
             end
-            it 'should update header table' do
-              subject
-              expect(@cc.instance_eval { @cc.table }).to eq ex[:streams][nth][:table]
-            end
-            it 'should compute header table size' do
-              subject
-              expect(@cc.instance_eval { @cc.current_table_size }).to eq ex[:streams][nth][:table_size]
+            unless ex[:streams][nth][:has_bad_headers]
+              it 'should update header table' do
+                subject
+                expect(@cc.instance_eval { @cc.table }).to eq ex[:streams][nth][:table]
+              end
+              it 'should compute header table size' do
+                subject
+                expect(@cc.instance_eval { @cc.current_table_size }).to eq ex[:streams][nth][:table_size]
+              end
             end
           end
         end