Implement padding for SPDY4/HTTP2 DATA frames.

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.
 
 // TODO(rtenhove) clean up frame buffer size calculations so that we aren't
 // constantly adding and subtracting header sizes; this is ugly and error-
 // prone.
 
 #include "net/spdy/spdy_framer.h"
 
@@ skipping 143 matching lines @@
   previous_state_ = SPDY_RESET;
   error_code_ = SPDY_NO_ERROR;
   remaining_data_length_ = 0;
   remaining_control_header_ = 0;
   current_frame_buffer_length_ = 0;
   current_frame_type_ = DATA;
   current_frame_flags_ = 0;
   current_frame_length_ = 0;
   current_frame_stream_id_ = kInvalidStream;
   settings_scratch_.Reset();
+  remaining_padding_payload_length_ = 0;
+  remaining_padding_length_fields_ = 0;
 }
 
 size_t SpdyFramer::GetDataFrameMinimumSize() const {
   // Size, in bytes, of the data frame header. Future versions of SPDY
   // will likely vary this, so we allow for the flexibility of a function call
   // for this value as opposed to a constant.
   return 8;
 }
 
 // Size, in bytes, of the control frame header.
@@ skipping 168 matching lines @@
     case SPDY_ERROR:
       return "ERROR";
     case SPDY_AUTO_RESET:
       return "AUTO_RESET";
     case SPDY_RESET:
       return "RESET";
     case SPDY_READING_COMMON_HEADER:
       return "READING_COMMON_HEADER";
     case SPDY_CONTROL_FRAME_PAYLOAD:
       return "CONTROL_FRAME_PAYLOAD";
+    case SPDY_READ_PADDING_LENGTH:
+      return "SPDY_READ_PADDING_LENGTH";
+    case SPDY_CONSUME_PADDING:
+      return "SPDY_CONSUME_PADDING";
     case SPDY_IGNORE_REMAINING_PAYLOAD:
       return "IGNORE_REMAINING_PAYLOAD";
     case SPDY_FORWARD_STREAM_FRAME:
       return "FORWARD_STREAM_FRAME";
     case SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK:
       return "SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK";
     case SPDY_CONTROL_FRAME_HEADER_BLOCK:
       return "SPDY_CONTROL_FRAME_HEADER_BLOCK";
     case SPDY_GOAWAY_FRAME_PAYLOAD:
       return "SPDY_GOAWAY_FRAME_PAYLOAD";
@@ skipping 183 matching lines @@
         break;
       }
 
       case SPDY_CONTROL_FRAME_PAYLOAD: {
         size_t bytes_read = ProcessControlFramePayload(data, len);
         len -= bytes_read;
         data += bytes_read;
         break;
       }
 
+      case SPDY_READ_PADDING_LENGTH: {
+        size_t bytes_read = ProcessFramePaddingLength(data, len);
+        len -= bytes_read;
+        data += bytes_read;
+        break;
+      }
+
+      case SPDY_CONSUME_PADDING: {
+        size_t bytes_read = ProcessFramePadding(data, len);
+        len -= bytes_read;
+        data += bytes_read;
+        break;
+      }
+
       case SPDY_IGNORE_REMAINING_PAYLOAD:
         // control frame has too-large payload
         // intentional fallthrough
       case SPDY_FORWARD_STREAM_FRAME: {
         size_t bytes_read = ProcessDataFramePayload(data, len);
         len -= bytes_read;
         data += bytes_read;
         break;
       }
       default:
@@ skipping 133 matching lines @@
   }
 
   // if we're here, then we have the common header all received.
   if (!is_control_frame) {
     if (protocol_version() >= 4) {
       // Catch bogus tests sending oversized DATA frames.
       DCHECK_GE(GetFrameMaximumSize(), current_frame_length_)
           << "DATA frame too large for SPDY >= 4.";
     }
 
-    if (current_frame_flags_ & ~DATA_FLAG_FIN) {
+    uint8 valid_data_flags = 0;
+    if (protocol_version() >= 4) {
+      valid_data_flags = DATA_FLAG_FIN | DATA_FLAG_END_SEGMENT |
+          DATA_FLAG_PAD_LOW | DATA_FLAG_PAD_HIGH;
+    } else {
+      valid_data_flags = DATA_FLAG_FIN;
+    }
+
+    if (current_frame_flags_ & ~valid_data_flags) {
       set_error(SPDY_INVALID_DATA_FRAME_FLAGS);
     } else {
       visitor_->OnDataFrameHeader(current_frame_stream_id_,
                                   remaining_data_length_,
                                   current_frame_flags_ & DATA_FLAG_FIN);
       if (remaining_data_length_ > 0) {
-        CHANGE_STATE(SPDY_FORWARD_STREAM_FRAME);
+        CHANGE_STATE(SPDY_READ_PADDING_LENGTH);
       } else {
         // Empty data frame.
         if (current_frame_flags_ & DATA_FLAG_FIN) {
           visitor_->OnStreamFrameData(
               current_frame_stream_id_, NULL, 0, true);
         }
         CHANGE_STATE(SPDY_AUTO_RESET);
       }
     }
   } else if (version != spdy_version_) {
@@ skipping 1082 matching lines @@
   if (!processed_successfully) {
     set_error(SPDY_RST_STREAM_FRAME_CORRUPT);
   } else if (remaining_data_length_ == 0) {
     // Signal that there is not more opaque data.
     visitor_->OnRstStreamFrameData(NULL, 0);
     CHANGE_STATE(SPDY_AUTO_RESET);
   }
   return original_len;
 }
 
+size_t SpdyFramer::ProcessFramePaddingLength(const char* data, size_t len) {
+  DCHECK_EQ(SPDY_READ_PADDING_LENGTH, state_);
+
+  size_t original_len = len;
+  if (remaining_padding_length_fields_ == 0) {
+    DCHECK_EQ(remaining_padding_payload_length_, 0u);
+    bool pad_low = false;
+    bool pad_high = false;
+    if (current_frame_flags_ & net::DATA_FLAG_PAD_LOW) {
+      pad_low = true;
+      ++remaining_padding_length_fields_;
+    }
+    if (current_frame_flags_ & net::DATA_FLAG_PAD_HIGH) {
+      pad_high = true;
+      ++remaining_padding_length_fields_;
+    }
+    if ((pad_high && !pad_low) ||
+        remaining_data_length_ < remaining_padding_length_fields_) {
+      set_error(SPDY_INVALID_DATA_FRAME_FLAGS);
+      return 0;
+    }
+  }
+
+  // Parse the padding length.
+  while (len != 0 && remaining_padding_length_fields_ != 0) {
+    remaining_padding_payload_length_ =
+        (remaining_padding_payload_length_ << 8) +
+        *reinterpret_cast<const uint8*>(data);
+    ++data;
+    --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);
+  }
+  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) {
+      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 the FIN flag is set, and there is no more data in this data
+    // frame, inform the visitor of EOF via a 0-length data frame.
+    if (!remaining_data_length_ && current_frame_flags_ & DATA_FLAG_FIN) {
+      visitor_->OnStreamFrameData(current_frame_stream_id_, NULL, 0, true);
+    }
+  }
+
+  if (remaining_data_length_ == 0) {
+    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_ > 0) {
-    size_t amount_to_forward = std::min(remaining_data_length_, 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);
     if (amount_to_forward && state_ != SPDY_IGNORE_REMAINING_PAYLOAD) {
       // Only inform the visitor if there is data.
       if (amount_to_forward) {
         visitor_->OnStreamFrameData(
             current_frame_stream_id_, data, amount_to_forward, false);
       }
     }
     data += amount_to_forward;
     len -= amount_to_forward;
     remaining_data_length_ -= amount_to_forward;
 
     // If the FIN flag is set, and there is no more data in this data
     // frame, inform the visitor of EOF via a 0-length data frame.
     if (!remaining_data_length_ && current_frame_flags_ & DATA_FLAG_FIN) {
       visitor_->OnStreamFrameData(current_frame_stream_id_, NULL, 0, true);
     }
   }
 
-  if (remaining_data_length_ == 0) {
-    CHANGE_STATE(SPDY_AUTO_RESET);
+  if (remaining_data_length_ == remaining_padding_payload_length_) {
+    CHANGE_STATE(SPDY_CONSUME_PADDING);
   }
   return original_len - len;
 }
 
 size_t SpdyFramer::ParseHeaderBlockInBuffer(const char* header_data,
                                           size_t header_length,
                                           SpdyHeaderBlock* block) const {
   SpdyFrameReader reader(header_data, header_length);
 
   // Read number of headers.
@@ skipping 40 matching lines @@
                << num_headers << ").";
       return 0;
     }
 
     // Store header.
     (*block)[name] = value;
   }
   return reader.GetBytesConsumed();
 }
 
-SpdySerializedFrame* SpdyFramer::SerializeData(const SpdyDataIR& data) const {
-  const size_t kSize = GetDataFrameMinimumSize() + data.data().length();
-
-  SpdyDataFlags flags = DATA_FLAG_NONE;
-  if (data.fin()) {
+SpdySerializedFrame* SpdyFramer::SerializeData(const SpdyDataIR& datair) const {
+  uint8 flags = DATA_FLAG_NONE;
+  if (datair.fin()) {
     flags = DATA_FLAG_FIN;
   }
 
-  SpdyFrameBuilder builder(kSize);
-  builder.WriteDataFrameHeader(*this, data.stream_id(), flags);
-  builder.WriteBytes(data.data().data(), data.data().length());
-  DCHECK_EQ(kSize, builder.length());
-  return builder.take();
+  if (protocol_version() >= 4) {
+    int num_padding_fields = 0;
+    if (datair.pad_low()) {
+      flags |= DATA_FLAG_PAD_LOW;
+      ++num_padding_fields;
+    }
+    if (datair.pad_high()) {
+      flags |= DATA_FLAG_PAD_HIGH;
+      ++num_padding_fields;
+    }
+
+    const size_t size_with_padding = num_padding_fields +
+        datair.data().length() + datair.padding_payload_len() +
+        GetDataFrameMinimumSize();
+    SpdyFrameBuilder builder(size_with_padding);
+    builder.WriteDataFrameHeader(*this, datair.stream_id(), flags);
+    if (datair.pad_high()) {
+      builder.WriteUInt8(datair.padding_payload_len() >> 8);
+    }
+    if (datair.pad_low()) {
+      builder.WriteUInt8(datair.padding_payload_len() & 0xff);
+    }
+    builder.WriteBytes(datair.data().data(), datair.data().length());
+    if (datair.padding_payload_len() > 0) {
+      string padding = string(datair.padding_payload_len(), '0');
+      builder.WriteBytes(padding.data(), padding.length());
+    }
+    DCHECK_EQ(size_with_padding, builder.length());
+    return builder.take();
+  } else {
+    const size_t size = GetDataFrameMinimumSize() + datair.data().length();
+    SpdyFrameBuilder builder(size);
+    builder.WriteDataFrameHeader(*this, datair.stream_id(), flags);
+    builder.WriteBytes(datair.data().data(), datair.data().length());
+    DCHECK_EQ(size, builder.length());
+    return builder.take();
+  }
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeDataFrameHeader(
     const SpdyDataIR& data) const {
   const size_t kSize = GetDataFrameMinimumSize();
 
-  SpdyDataFlags flags = DATA_FLAG_NONE;
+  uint8 flags = DATA_FLAG_NONE;
   if (data.fin()) {
     flags = DATA_FLAG_FIN;
   }
+  if (protocol_version() >= 4) {
+    if (data.pad_low()) {
+      flags |= DATA_FLAG_PAD_LOW;
+    }
+    if (data.pad_high()) {
+      flags |= DATA_FLAG_PAD_HIGH;
+    }
+  }
 
   SpdyFrameBuilder builder(kSize);
   builder.WriteDataFrameHeader(*this, data.stream_id(), flags);
-  if (protocol_version() < 4) {
+  if (protocol_version() >= 4) {
+    builder.OverwriteLength(*this, data.data().length() + kSize);
+  } else {
     builder.OverwriteLength(*this, data.data().length());
-  } else {
-    builder.OverwriteLength(*this, data.data().length() + kSize);
   }
   DCHECK_EQ(kSize, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeSynStream(
     const SpdySynStreamIR& syn_stream) {
   uint8 flags = 0;
   if (syn_stream.fin()) {
     flags |= CONTROL_FLAG_FIN;
@@ skipping 749 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