HTTP2 draft 13: support unknown frame types and settings types as extensions.

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 180 matching lines @@
       LOG(FATAL);
     }
 
     virtual void OnPriority(SpdyStreamId stream_id,
                             SpdyStreamId parent_stream_id,
                             uint8 weight,
                             bool exclusive) OVERRIDE {
       // Do nothing.
     }
 
+    virtual bool OnUnknownFrame(SpdyStreamId stream_id,
+                                int frame_type) override {
+      LOG(FATAL);
+      return false;
+    }
+
     char* ReleaseBuffer() {
       CHECK(finished_);
       return buffer_.release();
     }
 
     virtual void OnWindowUpdate(SpdyStreamId stream_id,
                                 uint32 delta_window_size) OVERRIDE {
       LOG(FATAL);
     }
 
@@ skipping 31 matching lines @@
         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),
         priority_count_(0),
         test_altsvc_ir_(0),
+        on_unknown_frame_result_(false),
         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 169 matching lines @@
     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 OnPriority(SpdyStreamId stream_id,
+                          SpdyStreamId parent_stream_id,
+                          uint8 weight,
+                          bool exclusive) OVERRIDE {
+    ++priority_count_;
+  }
+
+  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
+    DLOG(INFO) << "Unknown frame type " << frame_type;
+    return on_unknown_frame_result_;
+  }
+
   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 OnPriority(SpdyStreamId stream_id,
-                          SpdyStreamId parent_stream_id,
-                          uint8 weight,
-                          bool exclusive) OVERRIDE {
-    ++priority_count_;
-  }
-
   virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
                                         SpdyFrameType type,
                                         size_t frame_len) OVERRIDE {
     last_frame_len_ = frame_len;
   }
 
   // Convenience function which runs a framer simulation with particular input.
   void SimulateInFramer(const unsigned char* input, size_t size) {
     framer_.set_enable_compression(use_compression_);
     framer_.set_visitor(this);
@@ skipping 50 matching lines @@
   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_;
   int priority_count_;
   SpdyAltSvcIR test_altsvc_ir_;
+  bool on_unknown_frame_result_;
   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 2983 matching lines @@
     EXPECT_EQ(1, visitor.error_count_);
   } else {
     // In SPDY 4+, duplicate settings are allowed;
     // each setting replaces the previous value for that setting.
     EXPECT_EQ(3, visitor.setting_count_);
     EXPECT_EQ(0, visitor.error_count_);
     EXPECT_EQ(1, visitor.settings_ack_sent_);
   }
 }
 
+// Tests handling of SETTINGS frame with a setting we don't recognize.
+TEST_P(SpdyFramerTest, ReadUnknownSettingsId) {
+  SpdyFramer framer(spdy_version_);
+
+  const unsigned char kV2FrameData[] = {
+    0x80, spdy_version_ch_, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x1C,
+    0x00, 0x00, 0x00, 0x01,
+    0x10, 0x00, 0x00, 0x00,  // 1st Setting
+    0x00, 0x00, 0x00, 0x02,
+  };
+  const unsigned char kV3FrameData[] = {
+    0x80, spdy_version_ch_, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x1C,
+    0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x10,  // 1st Setting
+    0x00, 0x00, 0x00, 0x02,
+  };
+  const unsigned char kV4FrameData[] = {
+    0x00, 0x06, 0x04, 0x00,
+    0x00, 0x00, 0x00, 0x00,
+    0x00, 0x10,  // 1st Setting
+    0x00, 0x00, 0x00, 0x02,
+  };
+
+  TestSpdyVisitor visitor(spdy_version_);
+  visitor.use_compression_ = false;
+  if (IsSpdy2()) {
+    visitor.SimulateInFramer(kV2FrameData, sizeof(kV2FrameData));
+  } else if (IsSpdy3()) {
+    visitor.SimulateInFramer(kV3FrameData, sizeof(kV3FrameData));
+  } else {
+    visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData));
+  }
+
+  if (!IsSpdy4()) {
+    EXPECT_EQ(0, visitor.setting_count_);
+    EXPECT_EQ(1, visitor.error_count_);
+  } else {
+    // In SPDY 4+, we ignore unknown settings because of extensions.
+    EXPECT_EQ(0, visitor.setting_count_);
+    EXPECT_EQ(0, visitor.error_count_);
+  }
+}
+
 // Tests handling of SETTINGS frame with entries out of order.
 TEST_P(SpdyFramerTest, ReadOutOfOrderSettings) {
   SpdyFramer framer(spdy_version_);
 
   const unsigned char kV2FrameData[] = {
     0x80, spdy_version_ch_, 0x00, 0x04,
     0x00, 0x00, 0x00, 0x1C,
     0x00, 0x00, 0x00, 0x03,
     0x02, 0x00, 0x00, 0x00,  // 1st Setting
     0x00, 0x00, 0x00, 0x02,
@@ skipping 34 matching lines @@
     visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData));
   }
 
   if (!IsSpdy4()) {
     EXPECT_EQ(1, visitor.setting_count_);
     EXPECT_EQ(1, visitor.error_count_);
   } else {
     // In SPDY 4+, settings are allowed in any order.
     EXPECT_EQ(3, visitor.setting_count_);
     EXPECT_EQ(0, visitor.error_count_);
-    // EXPECT_EQ(1, visitor.settings_ack_count_);
   }
 }
 
 TEST_P(SpdyFramerTest, ProcessSettingsAckFrame) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
   SpdyFramer framer(spdy_version_);
 
   const unsigned char kFrameData[] = {
@@ skipping 524 matching lines @@
 TEST_P(SpdyFramerTest, ReadGarbage) {
   SpdyFramer framer(spdy_version_);
   unsigned char garbage_frame[256];
   memset(garbage_frame, ~0, sizeof(garbage_frame));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(garbage_frame, sizeof(garbage_frame));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
+TEST_P(SpdyFramerTest, ReadUnknownExtensionFrame) {
+  if (spdy_version_ <= SPDY3) {
+    return;
+  }
+  SpdyFramer framer(spdy_version_);
+
+  // The unrecognized frame type should still have a valid length.
+  const unsigned char unknown_frame[] = {
+    0x00, 0x08, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff,
+  };
+  TestSpdyVisitor visitor(spdy_version_);
+
+  // Simulate the case where the stream id validation checks out.
+  visitor.on_unknown_frame_result_ = true;
+  visitor.use_compression_ = false;
+  visitor.SimulateInFramer(unknown_frame, arraysize(unknown_frame));
+  EXPECT_EQ(0, visitor.error_count_);
+
+  // Follow it up with a valid control frame to make sure we handle
+  // subsequent frames correctly.
+  SpdySettingsIR settings_ir;
+  settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 1),
+                         false,  // persist
+                         false,  // persisted
+                         10);
+  scoped_ptr<SpdyFrame> control_frame(framer.SerializeSettings(settings_ir));
+  visitor.SimulateInFramer(
+      reinterpret_cast<unsigned char*>(control_frame->data()),
+      control_frame->size());
+  EXPECT_EQ(0, visitor.error_count_);
+  EXPECT_EQ(1u, static_cast<unsigned>(visitor.setting_count_));
+  EXPECT_EQ(1u, static_cast<unsigned>(visitor.settings_ack_sent_));
+}
+
 TEST_P(SpdyFramerTest, ReadGarbageWithValidLength) {
   if (!IsSpdy4()) {
     return;
   }
   SpdyFramer framer(spdy_version_);
   const unsigned char kFrameData[] = {
-    0x00, 0x10, 0xff, 0xff,
+    0x00, 0x08, 0xff, 0xff,
     0xff, 0xff, 0xff, 0xff,
     0xff, 0xff, 0xff, 0xff,
     0xff, 0xff, 0xff, 0xff,
   };
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kFrameData, arraysize(kFrameData));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
@@ skipping 1277 matching lines @@
   EXPECT_EQ(4u, framer.MapWeightToPriority(109));
   EXPECT_EQ(4u, framer.MapWeightToPriority(74));
   EXPECT_EQ(5u, framer.MapWeightToPriority(73));
   EXPECT_EQ(5u, framer.MapWeightToPriority(37));
   EXPECT_EQ(6u, framer.MapWeightToPriority(36));
   EXPECT_EQ(6u, framer.MapWeightToPriority(1));
   EXPECT_EQ(7u, framer.MapWeightToPriority(0));
 }
 
 }  // namespace net