Add handling + parsing for HTTP/2 ALTSVC frame.

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"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_frame_reader.h"
 #include "net/spdy/spdy_bitmasks.h"
 #include "third_party/zlib/zlib.h"
 
+using base::StringPiece;
 using std::string;
 using std::vector;
 
 namespace net {
 
 namespace {
 
 // Compute the id of our dictionary so that we know we're using the
 // right one when asked for it.
 uLong CalculateDictionaryId(const char* dictionary,
@@ skipping 17 matching lines @@
 // initialized lazily to avoid static initializers.
 base::LazyInstance<DictionaryIds>::Leaky g_dictionary_ids;
 
 // Used to indicate no flags in a SPDY flags field.
 const uint8 kNoFlags = 0;
 
 }  // namespace
 
 const SpdyStreamId SpdyFramer::kInvalidStream = -1;
 const size_t SpdyFramer::kHeaderDataChunkMaxSize = 1024;
-// The size of the control frame buffer. Must be >= the minimum size of the
 // largest control frame, which is SYN_STREAM. See GetSynStreamMinimumSize() for
 // calculation details.
 const size_t SpdyFramer::kControlFrameBufferSize = 18;
 
 #ifdef DEBUG_SPDY_STATE_CHANGES
 #define CHANGE_STATE(newstate)                                  \
   do {                                                          \
     DVLOG(1) << "Changing state from: "                         \
              << StateToString(state_)                           \
              << " to " << StateToString(newstate) << "\n";      \
@@ skipping 38 matching lines @@
 // This method is used to preserve buggy behavior and works on both
 // little-endian and big-endian hosts.
 // This method is also bidirectional (can be used to translate SPDY 2 to SPDY 3
 // as well as vice versa).
 void SettingsFlagsAndId::ConvertFlagsAndIdForSpdy2(uint32* val) {
     uint8* wire_array = reinterpret_cast<uint8*>(val);
     std::swap(wire_array[0], wire_array[3]);
     std::swap(wire_array[1], wire_array[2]);
 }
 
+SpdyAltSvcScratch::SpdyAltSvcScratch() { Reset(); }
+SpdyAltSvcScratch::~SpdyAltSvcScratch() {}
+
 bool SpdyFramerVisitorInterface::OnGoAwayFrameData(const char* goaway_data,
                                                    size_t len) {
   return true;
 }
 
 bool SpdyFramerVisitorInterface::OnRstStreamFrameData(
     const char* rst_stream_data,
     size_t len) {
   return true;
 }
@@ skipping 28 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();
+  altsvc_scratch_.Reset();
   remaining_padding_payload_length_ = 0;
   remaining_padding_length_fields_ = 0;
 }
 
 size_t SpdyFramer::GetDataFrameMinimumSize() const {
   return SpdyConstants::GetDataFrameMinimumSize();
 }
 
 // Size, in bytes, of the control frame header.
 size_t SpdyFramer::GetControlFrameHeaderSize() const {
@@ skipping 130 matching lines @@
   // Calculated as frame prefix + 4 (promised stream id).
   return GetControlFrameHeaderSize() + 4;
 }
 
 size_t SpdyFramer::GetContinuationMinimumSize() const  {
   // Size, in bytes, of a CONTINUATION frame not including the variable-length
   // headers fragments.
   return GetControlFrameHeaderSize();
 }
 
+size_t SpdyFramer::GetAltSvcMinimumSize() const  {
+  // Size, in bytes, of an ALTSVC frame not including the Protocol-ID, Host, and
+  // (optional) Origin fields, all of which can vary in length.
+  // Note that this gives a lower bound on the frame size rather than a true
+  // minimum; the actual frame should always be larger than this.
+  // Calculated as frame prefix + 4 (max-age) + 2 (port) + 1 (reserved byte)
+  // + 1 (pid_len) + 1 (host_len).
+  return GetControlFrameHeaderSize() + 9;
+}
+
 size_t SpdyFramer::GetFrameMinimumSize() const {
   return std::min(GetDataFrameMinimumSize(), GetControlFrameHeaderSize());
 }
 
 size_t SpdyFramer::GetFrameMaximumSize() const {
   return SpdyConstants::GetFrameMaximumSize(protocol_version());
 }
 
 size_t SpdyFramer::GetDataFrameMaximumPayload() const {
   return GetFrameMaximumSize() - GetDataFrameMinimumSize();
@@ skipping 26 matching lines @@
     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";
     case SPDY_RST_STREAM_FRAME_PAYLOAD:
       return "SPDY_RST_STREAM_FRAME_PAYLOAD";
     case SPDY_SETTINGS_FRAME_PAYLOAD:
       return "SPDY_SETTINGS_FRAME_PAYLOAD";
+    case SPDY_ALTSVC_FRAME_PAYLOAD:
+      return "SPDY_ALTSVC_FRAME_PAYLOAD";
   }
   return "UNKNOWN_STATE";
 }
 
 void SpdyFramer::set_error(SpdyError error) {
   DCHECK(visitor_);
   error_code_ = error;
   // These values will usually get reset once we come to the end
   // of a header block, but if we run into an error that
   // might not happen, so reset them here.
@@ skipping 87 matching lines @@
     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 ALTSVC:
+      return "ALTSVC";
   }
   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 59 matching lines @@
         break;
       }
 
       case SPDY_GOAWAY_FRAME_PAYLOAD: {
         size_t bytes_read = ProcessGoAwayFramePayload(data, len);
         len -= bytes_read;
         data += bytes_read;
         break;
       }
 
+      case SPDY_ALTSVC_FRAME_PAYLOAD: {
+        size_t bytes_read = ProcessAltSvcFramePayload(data, len);
+        len -= bytes_read;
+        data += bytes_read;
+        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;
@@ skipping 352 matching lines @@
       }
       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()) {
+      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) {
         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) {
         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;
     default:
       LOG(WARNING) << "Valid " << display_protocol_
                    << " control frame with unhandled type: "
                    << current_frame_type_;
       // This branch should be unreachable because of the frame type bounds
       // check above. However, we DLOG(FATAL) here in an effort to painfully
       // club the head of the developer who failed to keep this file in sync
       // with spdy_protocol.h.
       DLOG(FATAL);
       set_error(SPDY_INVALID_CONTROL_FRAME);
@@ skipping 14 matching lines @@
   if (current_frame_type_ == GOAWAY) {
     CHANGE_STATE(SPDY_GOAWAY_FRAME_PAYLOAD);
     return;
   }
 
   if (current_frame_type_ == RST_STREAM) {
     CHANGE_STATE(SPDY_RST_STREAM_FRAME_PAYLOAD);
     return;
   }
 
+  if (current_frame_type_ == ALTSVC) {
+    CHANGE_STATE(SPDY_ALTSVC_FRAME_PAYLOAD);
+    return;
+  }
   // Determine the frame size without variable-length data.
   int32 frame_size_without_variable_data;
   switch (current_frame_type_) {
     case SYN_STREAM:
       syn_frame_processed_ = true;
       frame_size_without_variable_data = GetSynStreamMinimumSize();
       break;
     case SYN_REPLY:
       syn_frame_processed_ = true;
       frame_size_without_variable_data = GetSynReplyMinimumSize();
@@ skipping 867 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::ProcessAltSvcFramePayload(const char* data, size_t len) {
+  if (len == 0) {
+    return 0;
+  }
+
+  // Clamp to the actual remaining payload.
+  len = std::min(len, remaining_data_length_);
+
+  size_t processed_bytes = 0;
+  size_t processing = 0;
+  size_t bytes_remaining;
+  char* buffer;
+  size_t* buffer_len;
+
+  while (len > 0) {
+    if (altsvc_scratch_.pid_len == 0) {
+      // The size of the frame up to the PID_LEN field.
+      size_t fixed_len_portion = GetAltSvcMinimumSize() - 1;
+      bytes_remaining = fixed_len_portion - current_frame_buffer_length_;
+      processing = std::min(len, bytes_remaining);
+      // Buffer the new ALTSVC bytes we got.
+      UpdateCurrentFrameBuffer(&data, &len, processing);
+
+      // Do we have enough to parse the length of the protocol id?
+      if (current_frame_buffer_length_ == fixed_len_portion) {
+        // Parse out the max age, port, and pid_len.
+        SpdyFrameReader reader(current_frame_buffer_.get(),
+                               current_frame_buffer_length_);
+        reader.Seek(GetControlFrameHeaderSize());  // Seek past frame header.
+        bool successful_read = reader.ReadUInt32(&altsvc_scratch_.max_age);
+        reader.ReadUInt16(&altsvc_scratch_.port);
+        reader.Seek(1);  // Reserved byte.
+        successful_read = successful_read &&
+                          reader.ReadUInt8(&altsvc_scratch_.pid_len);
+        DCHECK(successful_read);
+        // Sanity check length value.
+        if (GetAltSvcMinimumSize() + altsvc_scratch_.pid_len >=
+            current_frame_length_) {
+          set_error(SPDY_INVALID_CONTROL_FRAME);
+          return 0;
+        }
+        altsvc_scratch_.protocol_id.reset(
+            new char[size_t(altsvc_scratch_.pid_len)]);
+      }
+      processed_bytes += processing;
+      continue;
+    } else if (altsvc_scratch_.pid_buf_len < altsvc_scratch_.pid_len) {
+      // Buffer protocol id field as in comes in.
+      buffer = altsvc_scratch_.protocol_id.get();
+      buffer_len = &altsvc_scratch_.pid_buf_len;
+      bytes_remaining = altsvc_scratch_.pid_len - altsvc_scratch_.pid_buf_len;
+    } else if (altsvc_scratch_.host_len == 0) {
+      // Parse out the host length.
+      processing = 1;
+      altsvc_scratch_.host_len = *reinterpret_cast<const uint8*>(data);
+      // Sanity check length value.
+      if (GetAltSvcMinimumSize() + altsvc_scratch_.pid_len +
+          altsvc_scratch_.host_len > current_frame_length_) {
+        set_error(SPDY_INVALID_CONTROL_FRAME);
+        return 0;
+      }
+      altsvc_scratch_.host.reset(new char[altsvc_scratch_.host_len]);
+      // Once we have host length, we can also determine the origin length
+      // by process of elimination.
+      altsvc_scratch_.origin_len = current_frame_length_ -
+        GetAltSvcMinimumSize() -
+        altsvc_scratch_.pid_len -
+        altsvc_scratch_.host_len;
+      if (altsvc_scratch_.origin_len > 0) {
+        altsvc_scratch_.origin.reset(new char[altsvc_scratch_.origin_len]);
+      }
+      data += processing;
+      processed_bytes += processing;
+      len -= processing;
+      continue;
+    } else if (altsvc_scratch_.host_buf_len < altsvc_scratch_.host_len) {
+      // Buffer host field as it comes in.
+      // TODO(mlavan): check formatting for host and origin
+      buffer = altsvc_scratch_.host.get();
+      buffer_len = &altsvc_scratch_.host_buf_len;
+      bytes_remaining = altsvc_scratch_.host_len - altsvc_scratch_.host_buf_len;
+    } else {
+      // Buffer (optional) origin field as it comes in.
+      if (altsvc_scratch_.origin_len <= 0) {
+        set_error(SPDY_INVALID_CONTROL_FRAME);
+        return 0;
+      }
+      buffer = altsvc_scratch_.origin.get();
+      buffer_len = &altsvc_scratch_.origin_buf_len;
+      bytes_remaining = remaining_data_length_ -
+        processed_bytes -
+        altsvc_scratch_.origin_buf_len;
+      if (len > bytes_remaining) {
+        // This is our last field; there shouldn't be any more bytes.
+        set_error(SPDY_INVALID_CONTROL_FRAME);
+        return 0;
+      }
+    }
+
+    // Copy data bytes into the appropriate field.
+    processing = std::min(len, bytes_remaining);
+    memcpy(buffer + *buffer_len,
+           data,
+           processing);
+    *buffer_len += processing;
+    data += processing;
+    processed_bytes += processing;
+    len -= processing;
+  }
+
+  remaining_data_length_ -= processed_bytes;
+  if (remaining_data_length_ == 0) {
+    visitor_->OnAltSvc(current_frame_stream_id_,
+                       altsvc_scratch_.max_age,
+                       altsvc_scratch_.port,
+                       StringPiece(altsvc_scratch_.protocol_id.get(),
+                                   altsvc_scratch_.pid_len),
+                       StringPiece(altsvc_scratch_.host.get(),
+                                   altsvc_scratch_.host_len),
+                       StringPiece(altsvc_scratch_.origin.get(),
+                                   altsvc_scratch_.origin_len));
+    CHANGE_STATE(SPDY_AUTO_RESET);
+  }
+
+  return processed_bytes;
+}
+
 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_ & DATA_FLAG_PAD_LOW) {
       pad_low = true;
@@ skipping 727 matching lines @@
 
   if (debug_visitor_) {
     const size_t payload_len = hpack_encoding.size();
     debug_visitor_->OnSendCompressedFrame(continuation.stream_id(),
         CONTINUATION, payload_len, builder.length());
   }
 
   return builder.take();
 }
 
+SpdyFrame* SpdyFramer::SerializeAltSvc(const SpdyAltSvcIR& altsvc) {
+  DCHECK_LT(SPDY3, protocol_version());
+  size_t size = GetAltSvcMinimumSize();
+  size += altsvc.protocol_id().length();
+  size += altsvc.host().length();
+  size += altsvc.origin().length();
+
+  SpdyFrameBuilder builder(size, protocol_version());
+  builder.BeginNewFrame(*this, ALTSVC, kNoFlags, altsvc.stream_id());
+
+  builder.WriteUInt32(altsvc.max_age());
+  builder.WriteUInt16(altsvc.port());
+  builder.WriteUInt8(0);  // Reserved.
+  builder.WriteUInt8(altsvc.protocol_id().length());
+  builder.WriteBytes(altsvc.protocol_id().data(),
+                     altsvc.protocol_id().length());
+  builder.WriteUInt8(altsvc.host().length());
+  builder.WriteBytes(altsvc.host().data(), altsvc.host().length());
+  builder.WriteBytes(altsvc.origin().data(), altsvc.origin().length());
+  DCHECK_LT(GetAltSvcMinimumSize(), builder.length());
+  return builder.take();
+}
+
 namespace {
 
 class FrameSerializationVisitor : public SpdyFrameVisitor {
  public:
   explicit FrameSerializationVisitor(SpdyFramer* framer) : framer_(framer) {}
   virtual ~FrameSerializationVisitor() {}
 
   SpdySerializedFrame* ReleaseSerializedFrame() { return frame_.release(); }
 
   virtual void VisitData(const SpdyDataIR& data) OVERRIDE {
@@ skipping 28 matching lines @@
     frame_.reset(framer_->SerializeBlocked(blocked));
   }
   virtual void VisitPushPromise(
       const SpdyPushPromiseIR& push_promise) OVERRIDE {
     frame_.reset(framer_->SerializePushPromise(push_promise));
   }
   virtual void VisitContinuation(
       const SpdyContinuationIR& continuation) OVERRIDE {
     frame_.reset(framer_->SerializeContinuation(continuation));
   }
+  virtual void VisitAltSvc(const SpdyAltSvcIR& altsvc) OVERRIDE {
+    frame_.reset(framer_->SerializeAltSvc(altsvc));
+  }
 
  private:
   SpdyFramer* framer_;
   scoped_ptr<SpdySerializedFrame> frame_;
 };
 
 }  // namespace
 
 SpdySerializedFrame* SpdyFramer::SerializeFrame(const SpdyFrameIR& frame) {
   FrameSerializationVisitor visitor(this);
@@ skipping 332 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