HTTP/2 framer support for reading headers with padding, and for segments.

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 911 matching lines @@
         size_t min_size = GetHeadersMinimumSize();
         if (protocol_version() > SPDY3 &&
             (current_frame_flags_ & HEADERS_FLAG_PRIORITY)) {
           min_size += 4;
         }
         if (current_frame_length_ < min_size) {
           set_error(SPDY_INVALID_CONTROL_FRAME);
         } else if (protocol_version() <= SPDY3 &&
                    current_frame_flags_ & ~CONTROL_FLAG_FIN) {
           set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
-        } else if (protocol_version() > SPDY3 && current_frame_flags_ &
-                   ~(CONTROL_FLAG_FIN | HEADERS_FLAG_PRIORITY |
-                     HEADERS_FLAG_END_HEADERS)) {
+        } else if (protocol_version() > SPDY3 &&
+                   current_frame_flags_ &
+                       ~(CONTROL_FLAG_FIN | HEADERS_FLAG_PRIORITY |
+                         HEADERS_FLAG_END_HEADERS | HEADERS_FLAG_END_SEGMENT |
+                         HEADERS_FLAG_PAD_LOW | HEADERS_FLAG_PAD_HIGH)) {
           set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
         }
       }
       break;
     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);
-      } else if (protocol_version() > SPDY3 && current_frame_flags_ &
-                 ~PUSH_PROMISE_FLAG_END_PUSH_PROMISE) {
+      } else if (protocol_version() > SPDY3 &&
+                 current_frame_flags_ &
+                     ~(PUSH_PROMISE_FLAG_END_PUSH_PROMISE |
+                       HEADERS_FLAG_PAD_LOW | HEADERS_FLAG_PAD_HIGH)) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case CONTINUATION:
       if (current_frame_length_ < GetContinuationMinimumSize() ||
           protocol_version() <= SPDY3) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
-      } else if (current_frame_flags_ & ~HEADERS_FLAG_END_HEADERS) {
+      } else if (current_frame_flags_ &
+                 ~(HEADERS_FLAG_END_HEADERS | HEADERS_FLAG_PAD_LOW |
+                   HEADERS_FLAG_PAD_HIGH)) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case ALTSVC:
       if (current_frame_length_ <= GetAltSvcMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
@@ skipping 457 matching lines @@
                 priority,
                 current_frame_flags_ & CONTROL_FLAG_FIN,
                 false);  // unidirectional
           } else {
             visitor_->OnHeaders(
                 current_frame_stream_id_,
                 (current_frame_flags_ & CONTROL_FLAG_FIN) != 0,
                 expect_continuation_ == 0);
           }
         }
-        CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
+        CHANGE_STATE(SPDY_READ_PADDING_LENGTH);
         break;
       case PUSH_PROMISE:
         {
           DCHECK_LT(SPDY3, protocol_version());
           if (current_frame_stream_id_ == 0) {
             set_error(SPDY_INVALID_CONTROL_FRAME);
             break;
           }
           SpdyStreamId promised_stream_id = kInvalidStream;
           bool successful_read = reader.ReadUInt31(&promised_stream_id);
@@ skipping 10 matching lines @@
             debug_visitor_->OnReceiveCompressedFrame(
                 current_frame_stream_id_,
                 current_frame_type_,
                 current_frame_length_);
           }
           visitor_->OnPushPromise(current_frame_stream_id_,
                                   promised_stream_id,
                                   (current_frame_flags_ &
                                    PUSH_PROMISE_FLAG_END_PUSH_PROMISE) != 0);
         }
-        CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
+        CHANGE_STATE(SPDY_READ_PADDING_LENGTH);
         break;
       case CONTINUATION:
         {
           // Check to make sure the stream id of the current frame is
           // the same as that of the preceding frame.
           // If we're at this point we should already know that
           // expect_continuation_ != 0, so this doubles as a check
           // that current_frame_stream_id != 0.
           if (current_frame_stream_id_ != expect_continuation_) {
             set_error(SPDY_INVALID_CONTROL_FRAME);
             break;
           }
           if (current_frame_flags_ & HEADERS_FLAG_END_HEADERS) {
             expect_continuation_ = 0;
           }
           if (debug_visitor_) {
             debug_visitor_->OnReceiveCompressedFrame(
                 current_frame_stream_id_,
                 current_frame_type_,
                 current_frame_length_);
           }
           visitor_->OnContinuation(current_frame_stream_id_,
                                    (current_frame_flags_ &
                                     HEADERS_FLAG_END_HEADERS) != 0);
         }
-        CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
+        CHANGE_STATE(SPDY_READ_PADDING_LENGTH);
         break;
       default:
         DCHECK(false);
     }
   }
   return original_len - len;
 }
 
 // Does not buffer the control payload. Instead, either passes directly to the
 // visitor or decompresses and then passes directly to the visitor, via
 // IncrementallyDeliverControlFrameHeaderData() or
 // IncrementallyDecompressControlFrameHeaderData() respectively.
 size_t SpdyFramer::ProcessControlFrameHeaderBlock(const char* data,
                                                   size_t data_len,
                                                   bool is_hpack_header_block) {
   DCHECK_EQ(SPDY_CONTROL_FRAME_HEADER_BLOCK, state_);
 
   bool processed_successfully = true;
   if (current_frame_type_ != SYN_STREAM &&
       current_frame_type_ != SYN_REPLY &&
       current_frame_type_ != HEADERS &&
       current_frame_type_ != PUSH_PROMISE &&
       current_frame_type_ != CONTINUATION) {
     LOG(DFATAL) << "Unhandled frame type in ProcessControlFrameHeaderBlock.";
   }
-  size_t process_bytes = std::min(data_len, remaining_data_length_);
+  size_t process_bytes = std::min(
+      data_len, remaining_data_length_ - remaining_padding_payload_length_);
   if (is_hpack_header_block) {
     if (!GetHpackDecoder()->HandleControlFrameHeadersData(
             current_frame_stream_id_, data, process_bytes)) {
       // TODO(jgraettinger): Finer-grained HPACK error codes.
       set_error(SPDY_DECOMPRESS_FAILURE);
       processed_successfully = false;
     }
   } else if (process_bytes > 0) {
     if (enable_compression_ && protocol_version() <= SPDY3) {
       processed_successfully = IncrementallyDecompressControlFrameHeaderData(
           current_frame_stream_id_, data, process_bytes);
     } else {
       processed_successfully = IncrementallyDeliverControlFrameHeaderData(
           current_frame_stream_id_, data, process_bytes);
     }
   }
   remaining_data_length_ -= process_bytes;
 
   // Handle the case that there is no futher data in this frame.
-  if (remaining_data_length_ == 0 && processed_successfully) {
+  if (remaining_data_length_ == remaining_padding_payload_length_ &&
+      processed_successfully) {
     if (expect_continuation_ == 0) {
       if (is_hpack_header_block) {
         if (!GetHpackDecoder()->HandleControlFrameHeadersComplete(
                 current_frame_stream_id_)) {
           set_error(SPDY_DECOMPRESS_FAILURE);
           processed_successfully = false;
         } else {
           // TODO(jgraettinger): To be removed with migration to
           // SpdyHeadersHandlerInterface. Serializes the HPACK block as a SPDY3
           // block, delivered via reentrant call to
           // ProcessControlFrameHeaderBlock().
           DeliverHpackBlockAsSpdy3Block();
           return process_bytes;
         }
       } else {
         // The complete header block has been delivered. We send a zero-length
         // OnControlFrameHeaderData() to indicate this.
         visitor_->OnControlFrameHeaderData(current_frame_stream_id_, NULL, 0);
       }
-      // If this is a FIN, tell the caller.
-      if ((current_frame_flags_ & CONTROL_FLAG_FIN) || end_stream_when_done_) {
-        end_stream_when_done_ = false;
-        visitor_->OnStreamFrameData(current_frame_stream_id_, NULL, 0, true);
-      }
     }
-    if (processed_successfully)
-      CHANGE_STATE(SPDY_AUTO_RESET);
+    if (processed_successfully) {
+      CHANGE_STATE(SPDY_CONSUME_PADDING);
+    }
   }
 
   // Handle error.
   if (!processed_successfully) {
     return data_len;
   }
 
   // Return amount processed.
   return process_bytes;
 }
@@ skipping 49 matching lines @@
   if (remaining_data_length_ == 0) {
     visitor_->OnSettingsEnd();
     CHANGE_STATE(SPDY_AUTO_RESET);
   }
 
   return processed_bytes;
 }
 
 void SpdyFramer::DeliverHpackBlockAsSpdy3Block() {
   DCHECK_LT(SPDY3, protocol_version());
-  DCHECK_EQ(0u, remaining_data_length_);
+  DCHECK_EQ(remaining_padding_payload_length_, remaining_data_length_);
 
   const SpdyNameValueBlock& block = GetHpackDecoder()->decoded_block();
   if (block.empty()) {
     // Special-case this to make tests happy.
     ProcessControlFrameHeaderBlock(NULL, 0, false);
     return;
   }
   SpdyFrameBuilder builder(
       GetSerializedLength(protocol_version(), &block),
       SPDY3);
 
   SerializeNameValueBlockWithoutCompression(&builder, block);
   scoped_ptr<SpdyFrame> frame(builder.take());
 
+  // Preserve padding length, and reset it after the re-entrant call.
+  size_t remaining_padding = remaining_padding_payload_length_;
+
+  remaining_padding_payload_length_ = 0;
   remaining_data_length_ = frame->size();
+
   ProcessControlFrameHeaderBlock(frame->data(), frame->size(), false);
+
+  remaining_padding_payload_length_ = remaining_padding;
+  remaining_data_length_ = remaining_padding;
 }
 
 bool SpdyFramer::ProcessSetting(const char* data) {
   int id_field;
   SpdySettingsIds id;
   uint8 flags = 0;
   uint32 value;
 
   // Extract fields.
   // Maintain behavior of old SPDY 2 bug with byte ordering of flags/id.
@@ skipping 402 matching lines @@
     --len;
     --remaining_padding_length_fields_;
     --remaining_data_length_;
   }
 
   if (remaining_padding_length_fields_ == 0) {
     if (remaining_padding_payload_length_ > remaining_data_length_) {
       set_error(SPDY_INVALID_DATA_FRAME_FLAGS);
       return 0;
     }
-    CHANGE_STATE(SPDY_FORWARD_STREAM_FRAME);
+    if (current_frame_type_ == DATA) {
+      CHANGE_STATE(SPDY_FORWARD_STREAM_FRAME);
+    } else {
+      DCHECK(current_frame_type_ == HEADERS ||
+             current_frame_type_ == PUSH_PROMISE ||
+             current_frame_type_ == CONTINUATION ||
+             current_frame_type_ == SYN_STREAM ||
+             current_frame_type_ == SYN_REPLY)
+          << current_frame_type_;
+      CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
+    }
   }
   return original_len - len;
 }
 
 size_t SpdyFramer::ProcessFramePadding(const char* data, size_t len) {
   DCHECK_EQ(SPDY_CONSUME_PADDING, state_);
 
   size_t original_len = len;
   if (remaining_padding_payload_length_ > 0) {
     DCHECK_EQ(remaining_padding_payload_length_, remaining_data_length_);
     size_t amount_to_discard = std::min(remaining_padding_payload_length_, len);
-    // The visitor needs to know about padding so it can send window updates.
-    // Communicate the padding to the visitor through a NULL data pointer, with
-    // a nonzero size.
-    if (amount_to_discard) {
+    if (current_frame_type_ == DATA && amount_to_discard > 0) {
+      // The visitor needs to know about padding so it can send window updates.
+      // Communicate the padding to the visitor through a NULL data pointer,
+      // with a nonzero size.
       visitor_->OnStreamFrameData(
           current_frame_stream_id_, NULL, amount_to_discard, false);
     }
     data += amount_to_discard;
     len -= amount_to_discard;
     remaining_padding_payload_length_ -= amount_to_discard;
     remaining_data_length_ -= amount_to_discard;
   }
 
   if (remaining_data_length_ == 0) {
-    // If the FIN flag is set, and there is no more data in this data frame,
+    // If the FIN flag is set, or this ends a header block which set FIN,
     // inform the visitor of EOF via a 0-length data frame.
-    if (current_frame_flags_ & DATA_FLAG_FIN) {
+    if (expect_continuation_ == 0 &&
+        ((current_frame_flags_ & CONTROL_FLAG_FIN) != 0 ||
+         end_stream_when_done_)) {
+      end_stream_when_done_ = false;
       visitor_->OnStreamFrameData(current_frame_stream_id_, NULL, 0, true);
     }
-
     CHANGE_STATE(SPDY_AUTO_RESET);
   }
   return original_len - len;
 }
 
 size_t SpdyFramer::ProcessDataFramePayload(const char* data, size_t len) {
   size_t original_len = len;
   if (remaining_data_length_ - remaining_padding_payload_length_ > 0) {
     size_t amount_to_forward = std::min(
         remaining_data_length_ - remaining_padding_payload_length_, len);
@@ skipping 1082 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