http-2 0.6.3 → 0.7.0

data/spec/framer_spec.rb

@@ -9,22 +9,36 @@ describe HTTP2::Framer do
       {
         length: 4,
         type: :headers,
-        flags: [:end_stream, :reserved, :end_headers],
+        flags: [:end_stream, :end_headers],
         stream: 15,
       }
     }
 
-    let(:bytes) { [0x04, 0x01, 0x7, 0x0000000F].pack("nCCN") }
+    let(:bytes) { [0,0x04, 0x01, 0x5, 0x0000000F].pack("CnCCN") }
 
-    it "should generate common 8 byte header" do
+    it "should generate common 9 byte header" do
       f.commonHeader(frame).should eq bytes
     end
 
-    it "should parse common 8 byte header" do
+    it "should parse common 9 byte header" do
       f.readCommonHeader(Buffer.new(bytes)).should eq frame
     end
 
-    it "should raise exception on invalid frame type" do
+    it "should generate a large frame" do
+      f = Framer.new
+      f.max_frame_size = 2**24-1
+      frame = {
+        length: 2**18 + 2**16 + 17,
+        type: :headers,
+        flags: [:end_stream, :end_headers],
+        stream: 15,
+      }
+      bytes = [5, 17, 0x01, 0x5, 0x0000000F].pack("CnCCN")
+      f.commonHeader(frame).should eq bytes
+      f.readCommonHeader(Buffer.new(bytes)).should eq frame
+    end
+
+    it "should raise exception on invalid frame type when sending" do
       expect {
         frame[:type] = :bogus
         f.commonHeader(frame)
@@ -47,7 +61,7 @@ describe HTTP2::Framer do
 
     it "should raise exception on invalid frame size" do
       expect {
-        frame[:length] = 2**16
+        frame[:length] = 2**24
         f.commonHeader(frame)
       }.to raise_error(CompressionError, /too large/)
     end
@@ -58,13 +72,13 @@ describe HTTP2::Framer do
       frame = {
         length: 4,
         type: :data,
-        flags: [:end_stream, :reserved],
+        flags: [:end_stream],
         stream: 1,
         payload: 'text'
       }
 
       bytes = f.generate(frame)
-      bytes.should eq [0x4,0x0,0x3,0x1,*'text'.bytes].pack("nCCNC*")
+      bytes.should eq [0,0x4,0x0,0x1,0x1,*'text'.bytes].pack("CnCCNC*")
 
       f.parse(bytes).should eq frame
     end
@@ -75,13 +89,13 @@ describe HTTP2::Framer do
       frame = {
         length: 12,
         type: :headers,
-        flags: [:end_stream, :reserved, :end_headers],
+        flags: [:end_stream, :end_headers],
         stream: 1,
         payload: 'header-block'
       }
 
       bytes = f.generate(frame)
-      bytes.should eq [0xc,0x1,0x7,0x1,*'header-block'.bytes].pack("nCCNC*")
+      bytes.should eq [0,0xc,0x1,0x5,0x1,*'header-block'.bytes].pack("CnCCNC*")
       f.parse(bytes).should eq frame
     end
 
@@ -89,14 +103,16 @@ describe HTTP2::Framer do
       frame = {
         length: 16,
         type: :headers,
-        flags: [:end_headers, :priority],
+        flags: [:end_headers],
         stream: 1,
-        priority: 15,
+        stream_dependency: 15,
+        weight: 12,
+        exclusive: false,
         payload: 'header-block'
       }
 
       bytes = f.generate(frame)
-      bytes.should eq [0x10,0x1,0xc,0x1,0xf,*'header-block'.bytes].pack("nCCNNC*")
+      bytes.should eq [0,0x11,0x1,0x24,0x1,0xf,0xb,*'header-block'.bytes].pack("CnCCNNCC*")
       f.parse(bytes).should eq frame
     end
   end
@@ -104,14 +120,16 @@ describe HTTP2::Framer do
   context "PRIORITY" do
     it "should generate and parse bytes" do
       frame = {
-        length: 4,
+        length: 5,
         type: :priority,
         stream: 1,
-        priority: 15
+        stream_dependency: 15,
+        weight: 12,
+        exclusive: true,
       }
 
       bytes = f.generate(frame)
-      bytes.should eq [0x4,0x2,0x0,0x1,0xf].pack("nCCNN")
+      bytes.should eq [0,0x5,0x2,0x0,0x1,0x8000000f,0xb].pack("CnCCNNC")
       f.parse(bytes).should eq frame
     end
   end
@@ -126,7 +144,7 @@ describe HTTP2::Framer do
       }
 
       bytes = f.generate(frame)
-      bytes.should eq [0x4,0x3,0x0,0x1,0x5].pack("nCCNN")
+      bytes.should eq [0,0x4,0x3,0x0,0x1,0x5].pack("CnCCNN")
       f.parse(bytes).should eq frame
     end
   end
@@ -134,47 +152,88 @@ describe HTTP2::Framer do
   context "SETTINGS" do
     let(:frame) {
       {
-        length: 8,
         type: :settings,
         flags: [],
         stream: 0,
-        payload: {
-          settings_max_concurrent_streams: 10
-        }
+        payload: [
+          [:settings_max_concurrent_streams, 10],
+          [:settings_header_table_size,      2048],
+        ]
       }
     }
 
     it "should generate and parse bytes" do
+      bytes = f.generate(frame)
+      bytes.should eq [0,12,0x4,0x0,0x0,3,10,1,2048].pack("CnCCNnNnN")
+      parsed = f.parse(bytes)
+      parsed.delete(:length)
+      frame.delete(:length)
+      parsed.should eq frame
+    end
 
+    it "should generate settings when id is given as an integer" do
+      frame[:payload][1][0] = 1
       bytes = f.generate(frame)
-      bytes.should eq [0x8,0x4,0x0,0x0,0x4,0xa].pack("nCCNNN")
-      f.parse(bytes).should eq frame
+      bytes.should eq [0,12,0x4,0x0,0x0,3,10,1,2048].pack("CnCCNnNnN")
     end
 
-    it "should ignore custom settings" do
-      frame[:length] = 8*2
-      frame[:payload] = {
-        settings_max_concurrent_streams: 10,
-        settings_initial_window_size:    20
-      }
+    it "should ignore custom settings when sending" do
+      frame[:payload] = [
+        [:settings_max_concurrent_streams, 10],
+        [:settings_initial_window_size,    20],
+        [55, 30],
+      ]
 
-      buf = f.generate(frame.merge({55 => 30}))
+      buf = f.generate(frame)
+      frame[:payload].slice!(2) # cut off the extension
+      frame[:length] = 12       # frame length should be computed WITHOUT extensions
       f.parse(buf).should eq frame
     end
 
-    it "should raise exception on invalid stream ID" do
+    it "should ignore custom settings when receiving" do
+      frame[:payload] = [
+        [:settings_max_concurrent_streams, 10],
+        [:settings_initial_window_size,    20],
+      ]
+
+      buf = f.generate(frame)
+      buf.setbyte(2, 18) # add 6 to the frame length
+      buf << "\x00\x37\x00\x00\x00\x1e"
+      parsed = f.parse(buf)
+      parsed.delete(:length)
+      frame.delete(:length)
+      parsed.should eq frame
+    end
+
+    it "should raise exception on sending invalid stream ID" do
       expect {
         frame[:stream] = 1
         f.generate(frame)
       }.to raise_error(CompressionError, /Invalid stream ID/)
     end
 
-    it "should raise exception on invalid setting" do
+    it "should raise exception on receiving invalid stream ID" do
+      expect {
+        buf = f.generate(frame)
+        buf.setbyte(8, 1)
+        f.parse(buf)
+      }.to raise_error(ProtocolError, /Invalid stream ID/)
+    end
+
+    it "should raise exception on sending invalid setting" do
       expect {
-        frame[:payload] = {random: 23}
+        frame[:payload] = [[:random, 23]]
         f.generate(frame)
       }.to raise_error(CompressionError, /Unknown settings ID/)
     end
+
+    it "should raise exception on receiving invalid payload length" do
+      expect {
+        buf = f.generate(frame)
+        buf.setbyte(2, 11) # change payload length
+        f.parse(buf)
+      }.to raise_error(ProtocolError, /Invalid settings payload length/)
+    end
   end
 
   context "PUSH_PROMISE" do
@@ -182,14 +241,14 @@ describe HTTP2::Framer do
       frame = {
         length: 11,
         type: :push_promise,
-        flags: [:end_push_promise],
+        flags: [:end_headers],
         stream: 1,
         promise_stream: 2,
         payload: 'headers'
       }
 
       bytes = f.generate(frame)
-      bytes.should eq [0xb,0x5,0x1,0x1,0x2,*'headers'.bytes].pack("nCCNNC*")
+      bytes.should eq [0,0xb,0x5,0x4,0x1,0x2,*'headers'.bytes].pack("CnCCNNC*")
       f.parse(bytes).should eq frame
     end
   end
@@ -200,14 +259,14 @@ describe HTTP2::Framer do
         length: 8,
         stream: 1,
         type: :ping,
-        flags: [:pong],
+        flags: [:ack],
         payload: '12345678'
       }
     }
 
     it "should generate and parse bytes" do
       bytes = f.generate(frame)
-      bytes.should eq [0x8,0x6,0x1,0x1,*'12345678'.bytes].pack("nCCNC*")
+      bytes.should eq [0,0x8,0x6,0x1,0x1,*'12345678'.bytes].pack("CnCCNC*")
       f.parse(bytes).should eq frame
     end
 
@@ -233,7 +292,7 @@ describe HTTP2::Framer do
 
     it "should generate and parse bytes" do
       bytes = f.generate(frame)
-      bytes.should eq [0xd,0x7,0x0,0x1,0x2,0x0,*'debug'.bytes].pack("nCCNNNC*")
+      bytes.should eq [0,0xd,0x7,0x0,0x1,0x2,0x0,*'debug'.bytes].pack("CnCCNNNC*")
       f.parse(bytes).should eq frame
     end
 
@@ -242,7 +301,7 @@ describe HTTP2::Framer do
       frame[:length] = 0x8
 
       bytes = f.generate(frame)
-      bytes.should eq [0x8,0x7,0x0,0x1,0x2,0x0].pack("nCCNNN")
+      bytes.should eq [0,0x8,0x7,0x0,0x1,0x2,0x0].pack("CnCCNNN")
       f.parse(bytes).should eq frame
     end
   end
@@ -256,7 +315,7 @@ describe HTTP2::Framer do
       }
 
       bytes = f.generate(frame)
-      bytes.should eq [0x4,0x9,0x0,0x0,0xa].pack("nCCNN")
+      bytes.should eq [0,0x4,0x8,0x0,0x0,0xa].pack("CnCCNN")
       f.parse(bytes).should eq frame
     end
   end
@@ -267,23 +326,120 @@ describe HTTP2::Framer do
         length: 12,
         type: :continuation,
         stream: 1,
-        flags: [:end_stream, :end_headers],
+        flags: [:end_headers],
         payload: 'header-block'
       }
 
       bytes = f.generate(frame)
-      bytes.should eq [0xc,0xa,0x3,0x1,*'header-block'.bytes].pack("nCCNC*")
+      bytes.should eq [0,0xc,0x9,0x4,0x1,*'header-block'.bytes].pack("CnCCNC*")
       f.parse(bytes).should eq frame
     end
   end
 
+  context "ALTSVC" do
+    it "should generate and parse bytes" do
+      frame = {
+        length: 44,
+        type: :altsvc,
+        stream: 1,
+        max_age: 1402290402,	   # 4
+        port: 8080,		   # 2
+        proto: 'h2-13',		   # 1 + 5
+        host: 'www.example.com',   # 1 + 15
+        origin: 'www.example.com', # 15
+      }
+      bytes = f.generate(frame)
+      expected = [0, 43, 0xa, 0, 1, 1402290402, 8080].pack("CnCCNNn")
+      expected << [5, *'h2-13'.bytes].pack("CC*")
+      expected << [15, *'www.example.com'.bytes].pack("CC*")
+      expected << [*'www.example.com'.bytes].pack("C*")
+      bytes.should eq expected
+      f.parse(bytes).should eq frame
+    end
+  end
+
+  context "Padding" do
+    [:data, :headers, :push_promise].each do |type|
+      [1,256].each do |padlen|
+        context "generating #{type} frame padded #{padlen}" do
+          before do
+            @frame = {
+              length: 12,
+              type: type,
+              stream: 1,
+              payload: 'example data',
+            }
+            type == :push_promise and @frame[:promise_stream] = 2
+            @normal = f.generate(@frame)
+            @padded = f.generate(@frame.merge(:padding => padlen))
+          end
+          it "should generate a frame with padding" do
+            @padded.bytesize.should eq @normal.bytesize + padlen
+          end
+          it "should fill padded octets with zero" do
+            trailer_len = padlen - 1
+            @padded[-trailer_len, trailer_len].should match(/\A\0*\z/)
+          end
+          it "should parse a frame with padding" do
+            f.parse(Buffer.new(@padded)).should eq \
+            f.parse(Buffer.new(@normal)).merge(:padding => padlen)
+          end
+          it "should preserve payload" do
+            f.parse(Buffer.new(@padded))[:payload].should eq @frame[:payload]
+          end
+        end
+      end
+    end
+    context "generating with invalid padding length" do
+      before do
+        @frame = {
+          length: 12,
+          type: :data,
+          stream: 1,
+          payload: 'example data',
+        }
+      end
+      [0, 257,1334].each do |padlen|
+        it "should raise error on trying to generate data frame padded with invalid #{padlen}" do
+          expect {
+            f.generate(@frame.merge(:padding => padlen))
+          }.to raise_error(CompressionError, /padding/i)
+        end
+      end
+      it "should raise error when adding a padding would make frame too large" do
+        @frame[:payload] = 'q' * (f.max_frame_size - 200)
+        @frame[:length]  = @frame[:payload].size
+        @frame[:padding] = 210 # would exceed 4096
+        expect {
+          f.generate(@frame)
+        }.to raise_error(CompressionError, /padding/i)
+      end
+    end
+    context "parsing frames with invalid paddings" do
+      before do
+        @frame = {
+          length: 12,
+          type: :data,
+          stream: 1,
+          payload: 'example data',
+        }
+        @padlen = 123
+        @padded = f.generate(@frame.merge(:padding => @padlen))
+      end
+      it "should raise exception when the given padding is longer than the payload" do
+        @padded.setbyte(9,240)
+        expect { f.parse(Buffer.new(@padded)) }.to raise_error(ProtocolError, /padding/)
+      end
+    end
+  end
+
   it "should determine frame length" do
     frames = [
       [{type: :data, stream: 1, flags: [:end_stream], payload: "abc"}, 3],
       [{type: :headers, stream: 1, payload: "abc"}, 3],
-      [{type: :priority, stream: 3, priority: 30}, 4],
+      [{type: :priority, stream: 3, stream_dependency: 30, exclusive: false, weight: 1}, 5],
       [{type: :rst_stream, stream: 3, error: 100}, 4],
-      [{type: :settings, payload: {settings_max_concurrent_streams: 10}}, 8],
+      [{type: :settings, payload: [[:settings_max_concurrent_streams, 10]]}, 6],
       [{type: :push_promise, promise_stream: 5, payload: "abc"}, 7],
       [{type: :ping, payload: "blob"*2}, 8],
       [{type: :goaway, last_stream: 5, error: 20, payload: "blob"}, 12],
@@ -293,7 +449,8 @@ describe HTTP2::Framer do
 
     frames.each do |(frame, size)|
       bytes = f.generate(frame)
-      bytes.slice(0,2).unpack("n").first.should eq size
+      bytes.slice(1,2).unpack("n").first.should eq size
+      bytes.readbyte(0).should eq 0
     end
   end
 
@@ -318,4 +475,15 @@ describe HTTP2::Framer do
     bytes.should be_empty
   end
 
+  it "should ignore unknown extension frames" do
+    frame = {type: :headers, stream: 1, payload: "headers"}
+    bytes = f.generate(frame)
+    bytes = Buffer.new(bytes + bytes) # Two HEADERS frames in bytes
+    bytes.setbyte(3, 42) # Make the first unknown type 42
+
+    f.parse(bytes).should be_nil   # first frame should be ignored
+    f.parse(bytes).should eq frame # should generate only one HEADERS
+    bytes.should be_empty
+  end
+
 end

data/spec/helper.rb

@@ -1,9 +1,25 @@
-require 'http/2'
+begin
+  if RSpec::Core::Version::STRING.to_i >= 3
+    # Disable deprecation warnings for newer RSpec
+    RSpec.configure do |config|
+      config.expect_with :rspec do |c|
+        c.syntax = [:should, :expect]
+      end
+      config.mock_with :rspec do |c|
+        c.syntax = [:should, :expect]
+      end
+    end
+  end
+rescue Exception
+end
+
 require 'json'
 require 'coveralls'
 
 Coveralls.wear! if ENV["CI"]
 
+require 'http/2'
+
 include HTTP2
 include HTTP2::Header
 include HTTP2::Error
@@ -19,20 +35,22 @@ HEADERS = {
   type: :headers,
   flags: [:end_headers],
   stream: 1,
-  payload: 'header-block'
+  payload: Compressor.new.encode([['a','b']])
 }
 
 HEADERS_END_STREAM = {
   type: :headers,
   flags: [:end_headers, :end_stream],
   stream: 1,
-  payload: 'header-block'
+  payload: Compressor.new.encode([['a','b']])
 }
 
 PRIORITY = {
   type: :priority,
   stream: 1,
-  priority: 15
+  exclusive: false,
+  stream_dependency: 0,
+  weight: 20,
 }
 
 RST_STREAM = {
@@ -44,18 +62,18 @@ RST_STREAM = {
 SETTINGS = {
   type: :settings,
   stream: 0,
-  payload: {
-    settings_max_concurrent_streams: 10,
-    settings_flow_control_options: 1
-  }
+  payload: [
+    [:settings_max_concurrent_streams, 10],
+    [:settings_initial_window_size, 0x7fffffff],
+  ]
 }
 
 PUSH_PROMISE = {
   type: :push_promise,
-  flags: [:end_push_promise],
+  flags: [:end_headers],
   stream: 1,
   promise_stream: 2,
-  payload: 'headers'
+  payload: Compressor.new.encode([['a','b']])
 }
 
 PING = {
@@ -67,7 +85,7 @@ PING = {
 PONG = {
   stream: 0,
   type: :ping,
-  flags: [:pong],
+  flags: [:ack],
   payload: '12345678'
 }
 
@@ -89,14 +107,23 @@ CONTINUATION = {
   payload: '-second-block'
 }
 
+ALTSVC = {
+  type: :altsvc,
+  max_age: 1402290402,          # 4
+  port: 8080,                   # 2    reserved 1
+  proto: 'h2-12',               # 1 + 5
+  host: 'www.example.com',      # 1 + 15
+  origin: 'www.example.com',    # 15
+}
+
 FRAME_TYPES = [
   DATA, HEADERS, PRIORITY, RST_STREAM, SETTINGS, PUSH_PROMISE,
-  PING, GOAWAY, WINDOW_UPDATE, CONTINUATION
+  PING, GOAWAY, WINDOW_UPDATE, CONTINUATION, ALTSVC
 ]
 
 def set_stream_id(bytes, id)
-  head = bytes.slice!(0,8).unpack('nCCN')
-  head[3] = id
+  head = bytes.slice!(0,9).unpack('CnCCN')
+  head[4] = id
 
-  head.pack('nCCN') + bytes
+  head.pack('CnCCN') + bytes
 end