Add handling + parsing for HTTP/2 ALTSVC frame.

net/spdy/spdy_framer_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <iostream>
 #include <limits>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 221 matching lines @@
       error_count_(0),
       syn_frame_count_(0),
       syn_reply_frame_count_(0),
       headers_frame_count_(0),
       push_promise_frame_count_(0),
       goaway_count_(0),
       setting_count_(0),
       settings_ack_sent_(0),
       settings_ack_received_(0),
       continuation_count_(0),
+      altsvc_count_(0),
+      test_altsvc_ir_(0),
       last_window_update_stream_(0),
       last_window_update_delta_(0),
       last_push_promise_stream_(0),
       last_push_promise_promised_stream_(0),
       data_bytes_(0),
       fin_frame_count_(0),
       fin_opaque_data_(),
       fin_flag_count_(0),
       zero_length_data_frame_count_(0),
       control_frame_header_data_count_(0),
@@ skipping 145 matching lines @@
     ++push_promise_frame_count_;
     InitHeaderStreaming(PUSH_PROMISE, stream_id);
     last_push_promise_stream_ = stream_id;
     last_push_promise_promised_stream_ = promised_stream_id;
   }
 
   virtual void OnContinuation(SpdyStreamId stream_id, bool end) OVERRIDE {
     ++continuation_count_;
   }
 
+  virtual void OnAltSvc(SpdyStreamId stream_id,
+                        uint32 max_age,
+                        uint16 port,
+                        StringPiece protocol_id,
+                        StringPiece host,
+                        StringPiece origin) OVERRIDE {
+    test_altsvc_ir_.set_stream_id(stream_id);
+    test_altsvc_ir_.set_max_age(max_age);
+    test_altsvc_ir_.set_port(port);
+    test_altsvc_ir_.set_protocol_id(protocol_id.as_string());
+    test_altsvc_ir_.set_host(host.as_string());
+    if (origin.length() > 0) {
+      test_altsvc_ir_.set_origin(origin.as_string());
+    }
+    ++altsvc_count_;
+  }
+
   virtual void OnSendCompressedFrame(SpdyStreamId stream_id,
                                      SpdyFrameType type,
                                      size_t payload_len,
                                      size_t frame_len) OVERRIDE {
     last_payload_len_ = payload_len;
     last_frame_len_ = frame_len;
   }
 
   virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
                                         SpdyFrameType type,
@@ skipping 50 matching lines @@
   int error_count_;
   int syn_frame_count_;
   int syn_reply_frame_count_;
   int headers_frame_count_;
   int push_promise_frame_count_;
   int goaway_count_;
   int setting_count_;
   int settings_ack_sent_;
   int settings_ack_received_;
   int continuation_count_;
+  int altsvc_count_;
+  SpdyAltSvcIR test_altsvc_ir_;
   SpdyStreamId last_window_update_stream_;
   uint32 last_window_update_delta_;
   SpdyStreamId last_push_promise_stream_;
   SpdyStreamId last_push_promise_promised_stream_;
   int data_bytes_;
   int fin_frame_count_;  // The count of RST_STREAM type frames received.
   std::string fin_opaque_data_;
   int fin_flag_count_;  // The count of frames with the FIN flag set.
   int zero_length_data_frame_count_;  // The count of zero-length data frames.
   int control_frame_header_data_count_;  // The count of chunks received.
@@ skipping 113 matching lines @@
                    << "'.";
         return false;
       }
     }
     return true;
   }
 
   bool IsSpdy2() { return spdy_version_ == SPDY2; }
   bool IsSpdy3() { return spdy_version_ == SPDY3; }
   bool IsSpdy4() { return spdy_version_ == SPDY4; }
+  bool IsSpdy5() { return spdy_version_ == SPDY5; }
 
   // Version of SPDY protocol to be used.
   SpdyMajorVersion spdy_version_;
   unsigned char spdy_version_ch_;
 };
 
 // All tests are run with 3 different SPDY versions: SPDY/2, SPDY/3, SPDY/4.
 INSTANTIATE_TEST_CASE_P(SpdyFramerTests,
                         SpdyFramerTest,
                         ::testing::Values(SPDY2, SPDY3, SPDY4));
@@ skipping 2263 matching lines @@
 }
 
 TEST_P(SpdyFramerTest, SerializeBlocked) {
   if (spdy_version_ < SPDY4) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
 
   const char kDescription[] = "BLOCKED frame";
+  const char kType = static_cast<unsigned char>(
+      SpdyConstants::SerializeFrameType(spdy_version_, BLOCKED));
   const unsigned char kFrameData[] = {
-    0x00, 0x00, 0x0a, 0x00,
-    0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, kType, 0x00,
+    0x00, 0x00, 0x00,  0x00,
   };
   SpdyBlockedIR blocked_ir(0);
   scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(blocked_ir));
   CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
 }
 
 TEST_P(SpdyFramerTest, CreateBlocked) {
   if (spdy_version_ < SPDY4) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
 
   const char kDescription[] = "BLOCKED frame";
   const SpdyStreamId kStreamId = 3;
 
   scoped_ptr<SpdySerializedFrame> frame_serialized(
       framer.SerializeBlocked(SpdyBlockedIR(kStreamId)));
   SpdyBlockedIR blocked_ir(kStreamId);
   scoped_ptr<SpdySerializedFrame> frame_created(
-                                    framer.SerializeFrame(blocked_ir));
+      framer.SerializeFrame(blocked_ir));
 
   CompareFrames(kDescription, *frame_serialized, *frame_created);
 }
 
 TEST_P(SpdyFramerTest, CreatePushPromiseUncompressed) {
   if (spdy_version_ < SPDY4) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
@@ skipping 12 matching lines @@
   };
 
   SpdyPushPromiseIR push_promise(42, 57);
   push_promise.SetHeader("bar", "foo");
   push_promise.SetHeader("foo", "bar");
   scoped_ptr<SpdySerializedFrame> frame(
     framer.SerializePushPromise(push_promise));
   CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
 }
 
+TEST_P(SpdyFramerTest, CreateAltSvc) {
+  if (spdy_version_ < SPDY4) {
+    return;
+  }
+
+  SpdyFramer framer(spdy_version_);
+
+  const char kDescription[] = "ALTSVC frame";
+  const char kType = static_cast<unsigned char>(
+      SpdyConstants::SerializeFrameType(spdy_version_, ALTSVC));
+  const unsigned char kFrameData[] = {
+    0x00, 0x17, kType, 0x00,
+    0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x05,
+    0x01, 0xbb, 0x00, 0x04,  // Port = 443
+    'p',  'i',  'd',  '1',   // Protocol-ID
+    0x04, 'h',  'o',  's',
+    't',  'o',  'r',  'i',
+    'g',  'i',  'n',
+  };
+  SpdyAltSvcIR altsvc_ir(3);
+  altsvc_ir.set_max_age(5);
+  altsvc_ir.set_port(443);
+  altsvc_ir.set_protocol_id("pid1");
+  altsvc_ir.set_host("host");
+  altsvc_ir.set_origin("origin");
+  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
+  CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
+}
+
 TEST_P(SpdyFramerTest, ReadCompressedSynStreamHeaderBlock) {
   SpdyFramer framer(spdy_version_);
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
   syn_stream.SetHeader("aa", "vv");
   syn_stream.SetHeader("bb", "ww");
   SpdyHeaderBlock headers = syn_stream.name_value_block();
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor(spdy_version_);
@@ skipping 1062 matching lines @@
   };
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kFrameData, arraysize(kFrameData));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 TEST_P(SpdyFramerTest, SizesTest) {
   SpdyFramer framer(spdy_version_);
   EXPECT_EQ(8u, framer.GetDataFrameMinimumSize());
-  if (IsSpdy4()) {
+  if (IsSpdy4() || IsSpdy5()) {
     EXPECT_EQ(8u, framer.GetSynReplyMinimumSize());
     EXPECT_EQ(12u, framer.GetRstStreamMinimumSize());
     EXPECT_EQ(8u, framer.GetSettingsMinimumSize());
     EXPECT_EQ(16u, framer.GetPingSize());
     EXPECT_EQ(16u, framer.GetGoAwayMinimumSize());
     EXPECT_EQ(8u, framer.GetHeadersMinimumSize());
     EXPECT_EQ(12u, framer.GetWindowUpdateSize());
     EXPECT_EQ(8u, framer.GetBlockedSize());
     EXPECT_EQ(12u, framer.GetPushPromiseMinimumSize());
+    EXPECT_EQ(17u, framer.GetAltSvcMinimumSize());
     EXPECT_EQ(8u, framer.GetFrameMinimumSize());
     EXPECT_EQ(16383u, framer.GetFrameMaximumSize());
     EXPECT_EQ(16375u, framer.GetDataFrameMaximumPayload());
   } else {
     EXPECT_EQ(8u, framer.GetControlFrameHeaderSize());
     EXPECT_EQ(18u, framer.GetSynStreamMinimumSize());
     EXPECT_EQ(IsSpdy2() ? 14u : 12u, framer.GetSynReplyMinimumSize());
     EXPECT_EQ(16u, framer.GetRstStreamMinimumSize());
     EXPECT_EQ(12u, framer.GetSettingsMinimumSize());
     EXPECT_EQ(12u, framer.GetPingSize());
@@ skipping 27 matching lines @@
                    SpdyFramer::SPDY_FORWARD_STREAM_FRAME));
   EXPECT_STREQ("SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK",
                SpdyFramer::StateToString(
                    SpdyFramer::SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK));
   EXPECT_STREQ("SPDY_CONTROL_FRAME_HEADER_BLOCK",
                SpdyFramer::StateToString(
                    SpdyFramer::SPDY_CONTROL_FRAME_HEADER_BLOCK));
   EXPECT_STREQ("SPDY_SETTINGS_FRAME_PAYLOAD",
                SpdyFramer::StateToString(
                    SpdyFramer::SPDY_SETTINGS_FRAME_PAYLOAD));
+  EXPECT_STREQ("SPDY_ALTSVC_FRAME_PAYLOAD",
+               SpdyFramer::StateToString(
+                   SpdyFramer::SPDY_ALTSVC_FRAME_PAYLOAD));
   EXPECT_STREQ("UNKNOWN_STATE",
                SpdyFramer::StateToString(
-                   SpdyFramer::SPDY_SETTINGS_FRAME_PAYLOAD + 1));
+                   SpdyFramer::SPDY_ALTSVC_FRAME_PAYLOAD + 1));
 }
 
 TEST_P(SpdyFramerTest, ErrorCodeToStringTest) {
   EXPECT_STREQ("NO_ERROR",
                SpdyFramer::ErrorCodeToString(SpdyFramer::SPDY_NO_ERROR));
   EXPECT_STREQ("INVALID_CONTROL_FRAME",
                SpdyFramer::ErrorCodeToString(
                    SpdyFramer::SPDY_INVALID_CONTROL_FRAME));
   EXPECT_STREQ("CONTROL_PAYLOAD_TOO_LARGE",
                SpdyFramer::ErrorCodeToString(
@@ skipping 851 matching lines @@
 
   SpdyBlockedIR blocked_ir(0);
   scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(blocked_ir));
   framer.ProcessInput(frame->data(), framer.GetBlockedSize());
 
   EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
+TEST_P(SpdyFramerTest, OnAltSvc) {
+  if (spdy_version_ < SPDY4) {
+    return;
+  }
+
+  const SpdyStreamId kStreamId = 1;
+
+  testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
+  SpdyFramer framer(spdy_version_);
+  framer.set_visitor(&visitor);
+
+  EXPECT_CALL(visitor, OnAltSvc(kStreamId,
+                                10,
+                                443,
+                                StringPiece("pid"),
+                                StringPiece("h1"),
+                                StringPiece("o1")));
+
+  SpdyAltSvcIR altsvc_ir(1);
+  altsvc_ir.set_max_age(10);
+  altsvc_ir.set_port(443);
+  altsvc_ir.set_protocol_id("pid");
+  altsvc_ir.set_host("h1");
+  altsvc_ir.set_origin("o1");
+  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
+  framer.ProcessInput(frame->data(), framer.GetAltSvcMinimumSize() +
+                      altsvc_ir.protocol_id().length() +
+                      altsvc_ir.host().length() +
+                      altsvc_ir.origin().length());
+
+  EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
+  EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
+      << SpdyFramer::ErrorCodeToString(framer.error_code());
+}
+
+TEST_P(SpdyFramerTest, OnAltSvcNoOrigin) {
+  if (spdy_version_ < SPDY4) {
+    return;
+  }
+
+  const SpdyStreamId kStreamId = 1;
+
+  testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
+  SpdyFramer framer(spdy_version_);
+  framer.set_visitor(&visitor);
+
+  EXPECT_CALL(visitor, OnAltSvc(kStreamId,
+                                10,
+                                443,
+                                StringPiece("pid"),
+                                StringPiece("h1"),
+                                StringPiece("")));
+
+  SpdyAltSvcIR altsvc_ir(1);
+  altsvc_ir.set_max_age(10);
+  altsvc_ir.set_port(443);
+  altsvc_ir.set_protocol_id("pid");
+  altsvc_ir.set_host("h1");
+  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
+  framer.ProcessInput(frame->data(), framer.GetAltSvcMinimumSize() +
+                      altsvc_ir.protocol_id().length() +
+                      altsvc_ir.host().length());
+
+  EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
+  EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
+      << SpdyFramer::ErrorCodeToString(framer.error_code());
+}
+
+TEST_P(SpdyFramerTest, OnAltSvcBadLengths) {
+  if (spdy_version_ < SPDY4) {
+    return;
+  }
+
+  const char kType = static_cast<unsigned char>(
+      SpdyConstants::SerializeFrameType(spdy_version_, ALTSVC));
+  {
+    TestSpdyVisitor visitor(spdy_version_);
+    SpdyFramer framer(spdy_version_);
+    framer.set_visitor(&visitor);
+
+    const unsigned char kFrameDataLargePIDLen[] = {
+      0x00, 0x17, kType, 0x00,
+      0x00, 0x00, 0x00, 0x03,
+      0x00, 0x00, 0x00, 0x05,
+      0x01, 0xbb, 0x00, 0x05,  // Port = 443
+      'p',  'i',  'd',  '1',   // Protocol-ID
+      0x04, 'h',  'o',  's',
+      't',  'o',  'r',  'i',
+      'g',  'i',  'n',
+    };
+
+    visitor.SimulateInFramer(kFrameDataLargePIDLen,
+                             sizeof(kFrameDataLargePIDLen));
+    EXPECT_EQ(1, visitor.error_count_);
+    EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
+              visitor.framer_.error_code());
+  }
+
+  {
+    TestSpdyVisitor visitor(spdy_version_);
+    SpdyFramer framer(spdy_version_);
+    framer.set_visitor(&visitor);
+    const unsigned char kFrameDataPIDLenLargerThanFrame[] = {
+      0x00, 0x17, kType, 0x00,
+      0x00, 0x00, 0x00, 0x03,
+      0x00, 0x00, 0x00, 0x05,
+      0x01, 0xbb, 0x00, 0x99,  // Port = 443
+      'p',  'i',  'd',  '1',   // Protocol-ID
+      0x04, 'h',  'o',  's',
+      't',  'o',  'r',  'i',
+      'g',  'i',  'n',
+    };
+
+    visitor.SimulateInFramer(kFrameDataPIDLenLargerThanFrame,
+                             sizeof(kFrameDataPIDLenLargerThanFrame));
+    EXPECT_EQ(1, visitor.error_count_);
+    EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
+              visitor.framer_.error_code());
+  }
+
+  {
+    TestSpdyVisitor visitor(spdy_version_);
+    SpdyFramer framer(spdy_version_);
+    framer.set_visitor(&visitor);
+
+    const unsigned char kFrameDataLargeHostLen[] = {
+      0x00, 0x17, kType, 0x00,
+      0x00, 0x00, 0x00, 0x03,
+      0x00, 0x00, 0x00, 0x05,
+      0x01, 0xbb, 0x00, 0x04,  // Port = 443
+      'p',  'i',  'd',  '1',   // Protocol-ID
+      0x0f, 'h',  'o',  's',
+      't',  'o',  'r',  'i',
+      'g',  'i',  'n',
+    };
+
+    visitor.SimulateInFramer(kFrameDataLargeHostLen,
+                             sizeof(kFrameDataLargeHostLen));
+    EXPECT_EQ(1, visitor.error_count_);
+    EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
+              visitor.framer_.error_code());
+  }
+
+  {
+    TestSpdyVisitor visitor(spdy_version_);
+    SpdyFramer framer(spdy_version_);
+    framer.set_visitor(&visitor);
+    const unsigned char kFrameDataSmallPIDLen[] = {
+      0x00, 0x17, kType, 0x00,
+      0x00, 0x00, 0x00, 0x03,
+      0x00, 0x00, 0x00, 0x05,
+      0x01, 0xbb, 0x00, 0x01,  // Port = 443
+      'p',  'i',  'd',  '1',   // Protocol-ID
+      0x04, 'h',  'o',  's',
+      't',  'o',  'r',  'i',
+      'g',  'i',  'n',
+    };
+
+    visitor.SimulateInFramer(kFrameDataSmallPIDLen,
+                             sizeof(kFrameDataSmallPIDLen));
+    EXPECT_EQ(1, visitor.error_count_);
+    EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
+              visitor.framer_.error_code());
+  }
+}
+
+// Tests handling of ALTSVC frames delivered in small chunks.
+TEST_P(SpdyFramerTest, ReadChunkedAltSvcFrame) {
+  if (spdy_version_ < SPDY4) {
+    return;
+  }
+  SpdyFramer framer(spdy_version_);
+  SpdyAltSvcIR altsvc_ir(1);
+  altsvc_ir.set_max_age(20);
+  altsvc_ir.set_port(443);
+  altsvc_ir.set_protocol_id("protocolid");
+  altsvc_ir.set_host("hostname");
+
+  scoped_ptr<SpdyFrame> control_frame(framer.SerializeAltSvc(altsvc_ir));
+  TestSpdyVisitor visitor(spdy_version_);
+  visitor.use_compression_ = false;
+
+  // Read data in small chunks.
+  size_t framed_data = 0;
+  size_t unframed_data = control_frame->size();
+  size_t kReadChunkSize = 5;  // Read five bytes at a time.
+  while (unframed_data > 0) {
+    size_t to_read = min(kReadChunkSize, unframed_data);
+    visitor.SimulateInFramer(
+        reinterpret_cast<unsigned char*>(control_frame->data() + framed_data),
+        to_read);
+    unframed_data -= to_read;
+    framed_data += to_read;
+  }
+  EXPECT_EQ(0, visitor.error_count_);
+  EXPECT_EQ(1, visitor.altsvc_count_);
+  EXPECT_EQ(20u, visitor.test_altsvc_ir_.max_age());
+  EXPECT_EQ(443u, visitor.test_altsvc_ir_.port());
+  EXPECT_EQ("protocolid", visitor.test_altsvc_ir_.protocol_id());
+  EXPECT_EQ("hostname", visitor.test_altsvc_ir_.host());
+}
+
 }  // namespace net