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

net/spdy/spdy_framer.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 "net/spdy/spdy_framer.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/stats_counters.h"
 #include "base/third_party/valgrind/memcheck.h"
@@ skipping 479 matching lines @@
     case PING:
       return "PING";
     case GOAWAY:
       return "GOAWAY";
     case HEADERS:
       return "HEADERS";
     case WINDOW_UPDATE:
       return "WINDOW_UPDATE";
     case CREDENTIAL:
       return "CREDENTIAL";
-    case BLOCKED:
-      return "BLOCKED";
     case PUSH_PROMISE:
       return "PUSH_PROMISE";
     case CONTINUATION:
       return "CONTINUATION";
+    case PRIORITY:
+      return "PRIORITY";
     case ALTSVC:
       return "ALTSVC";
-    case PRIORITY:
-      return "PRIORITY";
+    case BLOCKED:
+      return "BLOCKED";
   }
   return "UNKNOWN_CONTROL_TYPE";
 }
 
 size_t SpdyFramer::ProcessInput(const char* data, size_t len) {
   DCHECK(visitor_);
   DCHECK(data);
 
   size_t original_len = len;
   do {
@@ skipping 310 matching lines @@
 }
 
 void SpdyFramer::ProcessControlFrameHeader(uint16 control_frame_type_field) {
   DCHECK_EQ(SPDY_NO_ERROR, error_code_);
   DCHECK_LE(GetControlFrameHeaderSize(), current_frame_buffer_length_);
 
   // TODO(mlavan): Either remove credential frames from the code entirely,
   // or add them to parsing + serialization methods for SPDY3.
   // Early detection of deprecated frames that we ignore.
   if (protocol_version() <= SPDY3) {
-
     if (control_frame_type_field == CREDENTIAL) {
       current_frame_type_ = CREDENTIAL;
       DCHECK_EQ(SPDY3, protocol_version());
       DVLOG(1) << "CREDENTIAL control frame found. Ignoring.";
       CHANGE_STATE(SPDY_IGNORE_REMAINING_PAYLOAD);
       return;
     }
   }
 
   if (!SpdyConstants::IsValidFrameType(protocol_version(),
                                        control_frame_type_field)) {
-    DLOG(WARNING) << "Invalid control frame type " << control_frame_type_field
-                  << " (protocol version: " << protocol_version() << ")";
-    set_error(SPDY_INVALID_CONTROL_FRAME);
-    return;
+    if (protocol_version() <= SPDY3) {
+      DLOG(WARNING) << "Invalid control frame type " << control_frame_type_field
+                    << " (protocol version: " << protocol_version() << ")";
+      set_error(SPDY_INVALID_CONTROL_FRAME);
+      return;
+    } else {
+      // In HTTP2 we ignore unknown frame types for extensibility, as long as
+      // the rest of the control frame header is valid.
+      // We rely on the visitor to check validity of current_frame_stream_id_.
+      bool valid_stream = visitor_->OnUnknownFrame(current_frame_stream_id_,
+                                                   control_frame_type_field);
+      if (valid_stream) {
+        DVLOG(1) << "Ignoring unknown frame type.";
+        CHANGE_STATE(SPDY_IGNORE_REMAINING_PAYLOAD);
+      } else {
+        // Report an invalid frame error and close the stream if the
+        // stream_id is not valid.
+        DLOG(WARNING) << "Unknown control frame type "
+                      << control_frame_type_field
+                      << " received on invalid stream "
+                      << current_frame_stream_id_;
+        set_error(SPDY_INVALID_CONTROL_FRAME);
+      }
+      return;
+    }
   }
 
   current_frame_type_ = SpdyConstants::ParseFrameType(protocol_version(),
                                                       control_frame_type_field);
 
   // Do some sanity checking on the control frame sizes and flags.
   switch (current_frame_type_) {
     case SYN_STREAM:
       if (current_frame_length_ < GetSynStreamMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
@@ skipping 97 matching lines @@
     case WINDOW_UPDATE:
       if (current_frame_length_ != GetWindowUpdateSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case BLOCKED:
       if (current_frame_length_ != GetBlockedSize() ||
           protocol_version() <= SPDY3) {
-        // TODO(mlavan): BLOCKED frames are no longer part of SPDY4.
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case PUSH_PROMISE:
       if (current_frame_length_ < GetPushPromiseMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (protocol_version() <= SPDY3 && current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
@@ skipping 741 matching lines @@
     flags = id_and_flags.flags();
     value = ntohl(*(reinterpret_cast<const uint32*>(data + 4)));
   } else {
     id_field = ntohs(*(reinterpret_cast<const uint16*>(data)));
     value = ntohl(*(reinterpret_cast<const uint32*>(data + 2)));
   }
 
   // Validate id.
   if (!SpdyConstants::IsValidSettingId(protocol_version(), id_field)) {
     DLOG(WARNING) << "Unknown SETTINGS ID: " << id_field;
-    return false;
+    if (protocol_version() <= SPDY3) {
+      return false;
+    } else {
+      // In HTTP2 we ignore unknown settings for extensibility.
+      return true;
+    }
   }
   id = SpdyConstants::ParseSettingId(protocol_version(), id_field);
 
   if (protocol_version() <= SPDY3) {
     // Detect duplicates.
     if (id <= settings_scratch_.last_setting_id) {
       DLOG(WARNING) << "Duplicate entry or invalid ordering for id " << id
                     << " in " << display_protocol_ << " SETTINGS frame "
                     << "(last setting id was "
                     << settings_scratch_.last_setting_id << ").";
@@ skipping 1474 matching lines @@
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 
   pre_compress_bytes.Add(uncompressed_len);
   post_compress_bytes.Add(compressed_size);
 
   compressed_frames.Increment();
 }
 
 }  // namespace net