Land Recent QUIC Changes

net/quic/quic_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/quic/quic_framer.h"
 
 #include "base/hash_tables.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_data_reader.h"
 #include "net/quic/quic_data_writer.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::make_pair;
 using std::map;
 using std::numeric_limits;
 using std::string;
 
 namespace net {
 
 namespace {
 
 // Mask to select the lowest 48 bits of a sequence number.
 const QuicPacketSequenceNumber kSequenceNumberMask =
     GG_UINT64_C(0x0000FFFFFFFFFFFF);
 
+const uint32 kInvalidDeltaTime = 0xffffffff;
+
 // Returns the absolute value of the difference between |a| and |b|.
 QuicPacketSequenceNumber Delta(QuicPacketSequenceNumber a,
                                QuicPacketSequenceNumber b) {
   // Since these are unsigned numbers, we can't just return abs(a - b)
   if (a < b) {
     return b - a;
   }
   return a - b;
 }
 
@@ skipping 34 matching lines @@
 
 // static
 size_t QuicFramer::GetMinStreamFrameSize() {
   return kQuicFrameTypeSize + kQuicStreamIdSize +
       kQuicStreamFinSize + kQuicStreamOffsetSize + kQuicStreamPayloadLengthSize;
 }
 
 // static
 size_t QuicFramer::GetMinAckFrameSize() {
   return kQuicFrameTypeSize + kQuicEntropyHashSize + kSequenceNumberSize +
-      kQuicEntropyHashSize + kSequenceNumberSize + kNumberOfMissingPacketsSize;
+      kQuicEntropyHashSize + kSequenceNumberSize +
+      kQuicDeltaTimeLargestObservedSize + kNumberOfMissingPacketsSize;
 }
 
 // static
 size_t QuicFramer::GetMinRstStreamFrameSize() {
   return kQuicFrameTypeSize + kQuicStreamIdSize + kQuicErrorCodeSize +
       kQuicErrorDetailsLengthSize;
 }
 
 // static
 size_t QuicFramer::GetMinConnectionCloseFrameSize() {
@@ skipping 25 matching lines @@
   size_t frame_len = ComputeFrameLength(frame);
   if (frame_len > free_bytes) {
     // Only truncate the first frame in a packet, so if subsequent ones go
     // over, stop including more frames.
     if (!first_frame) {
       return 0;
     }
     if (CanTruncate(frame)) {
       // Truncate the frame so the packet will not exceed kMaxPacketSize.
       // Note that we may not use every byte of the writer in this case.
-      DLOG(INFO) << "Truncating large frame";
-      return free_bytes;
+      if (free_bytes >= GetMinAckFrameSize()) {
+        DLOG(INFO) << "Truncating large frame";
+        return free_bytes;
+      }
+      return 0;
     }
   }
   return frame_len;
 }
 
 QuicPacketEntropyHash QuicFramer::GetPacketEntropyHash(
     const QuicPacketHeader& header) const {
   if (!header.entropy_flag) {
     // TODO(satyamshekhar): Return some more better value here (something that
     // is not a constant).
@@ skipping 499 matching lines @@
   while (!reader_->IsDoneReading()) {
     uint8 frame_type;
     if (!reader_->ReadBytes(&frame_type, 1)) {
       set_detailed_error("Unable to read frame type.");
       return RaiseError(QUIC_INVALID_FRAME_DATA);
     }
     switch (frame_type) {
       case PADDING_FRAME:
         // We're done with the packet
         return true;
-      case STREAM_FRAME:
-        if (!ProcessStreamFrame()) {
+      case STREAM_FRAME: {
+        QuicStreamFrame frame;
+        if (!ProcessStreamFrame(&frame)) {
           return RaiseError(QUIC_INVALID_FRAME_DATA);
         }
+        if (!visitor_->OnStreamFrame(frame)) {
+          DLOG(INFO) << "Visitor asked to stopped further processing.";
+          // Returning true since there was no parsing error.
+          return true;
+        }
         break;
+      }
       case ACK_FRAME: {
         QuicAckFrame frame;
         if (!ProcessAckFrame(&frame)) {
           return RaiseError(QUIC_INVALID_FRAME_DATA);
         }
+        if (!visitor_->OnAckFrame(frame)) {
+          DLOG(INFO) << "Visitor asked to stopped further processing.";
+          // Returning true since there was no parsing error.
+          return true;
+        }
         break;
       }
       case CONGESTION_FEEDBACK_FRAME: {
         QuicCongestionFeedbackFrame frame;
         if (!ProcessQuicCongestionFeedbackFrame(&frame)) {
           return RaiseError(QUIC_INVALID_FRAME_DATA);
         }
+        if (!visitor_->OnCongestionFeedbackFrame(frame)) {
+          DLOG(INFO) << "Visitor asked to stopped further processing.";
+          // Returning true since there was no parsing error.
+          return true;
+        }
         break;
       }
-      case RST_STREAM_FRAME:
-        if (!ProcessRstStreamFrame()) {
+      case RST_STREAM_FRAME: {
+        QuicRstStreamFrame frame;
+        if (!ProcessRstStreamFrame(&frame)) {
           return RaiseError(QUIC_INVALID_RST_STREAM_DATA);
         }
+        if (!visitor_->OnRstStreamFrame(frame)) {
+          DLOG(INFO) << "Visitor asked to stopped further processing.";
+          // Returning true since there was no parsing error.
+          return true;
+        }
         break;
-      case CONNECTION_CLOSE_FRAME:
-        if (!ProcessConnectionCloseFrame()) {
+      }
+      case CONNECTION_CLOSE_FRAME: {
+        QuicConnectionCloseFrame frame;
+        if (!ProcessConnectionCloseFrame(&frame)) {
           return RaiseError(QUIC_INVALID_CONNECTION_CLOSE_DATA);
         }
+        if (!visitor_->OnConnectionCloseFrame(frame)) {
+          DLOG(INFO) << "Visitor asked to stopped further processing.";
+          // Returning true since there was no parsing error.
+          return true;
+        }
         break;
-      case GOAWAY_FRAME:
-        if (!ProcessGoAwayFrame()) {
+      }
+      case GOAWAY_FRAME: {
+        QuicGoAwayFrame goaway_frame;
+        if (!ProcessGoAwayFrame(&goaway_frame)) {
           return RaiseError(QUIC_INVALID_GOAWAY_DATA);
         }
+        if (!visitor_->OnGoAwayFrame(goaway_frame)) {
+          DLOG(INFO) << "Visitor asked to stopped further processing.";
+          // Returning true since there was no parsing error.
+          return true;
+        }
         break;
+      }
       default:
         set_detailed_error("Illegal frame type.");
         DLOG(WARNING) << "Illegal frame type: "
                       << static_cast<int>(frame_type);
         return RaiseError(QUIC_INVALID_FRAME_DATA);
     }
   }
 
   return true;
 }
 
-bool QuicFramer::ProcessStreamFrame() {
-  QuicStreamFrame frame;
-  if (!reader_->ReadUInt32(&frame.stream_id)) {
+bool QuicFramer::ProcessStreamFrame(QuicStreamFrame* frame) {
+  if (!reader_->ReadUInt32(&frame->stream_id)) {
     set_detailed_error("Unable to read stream_id.");
     return false;
   }
 
   uint8 fin;
   if (!reader_->ReadBytes(&fin, 1)) {
     set_detailed_error("Unable to read fin.");
     return false;
   }
   if (fin > 1) {
     set_detailed_error("Invalid fin value.");
     return false;
   }
-  frame.fin = (fin == 1);
+  frame->fin = (fin == 1);
 
-  if (!reader_->ReadUInt64(&frame.offset)) {
+  if (!reader_->ReadUInt64(&frame->offset)) {
     set_detailed_error("Unable to read offset.");
     return false;
   }
 
-  if (!reader_->ReadStringPiece16(&frame.data)) {
+  if (!reader_->ReadStringPiece16(&frame->data)) {
     set_detailed_error("Unable to read frame data.");
     return false;
   }
 
-  visitor_->OnStreamFrame(frame);
   return true;
 }
 
 bool QuicFramer::ProcessAckFrame(QuicAckFrame* frame) {
   if (!ProcessSentInfo(&frame->sent_info)) {
     return false;
   }
   if (!ProcessReceivedInfo(&frame->received_info)) {
     return false;
   }
-  visitor_->OnAckFrame(*frame);
   return true;
 }
 
 bool QuicFramer::ProcessReceivedInfo(ReceivedPacketInfo* received_info) {
   if (!reader_->ReadBytes(&received_info->entropy_hash, 1)) {
     set_detailed_error("Unable to read entropy hash for received packets.");
     return false;
   }
 
   if (!ProcessPacketSequenceNumber(&received_info->largest_observed)) {
      set_detailed_error("Unable to read largest observed.");
      return false;
   }
-  // TODO(pwestin): read and update delta_time_largest_observed.
+
+  uint32 delta_time_largest_observed_us;
+  if (!reader_->ReadUInt32(&delta_time_largest_observed_us)) {
+    set_detailed_error("Unable to read delta time largest observed.");
+    return false;
+  }
+
+  if (delta_time_largest_observed_us == kInvalidDeltaTime) {
+    received_info->delta_time_largest_observed = QuicTime::Delta::Infinite();
+  } else {
+    received_info->delta_time_largest_observed =
+        QuicTime::Delta::FromMicroseconds(delta_time_largest_observed_us);
+  }
 
   uint8 num_missing_packets;
   if (!reader_->ReadBytes(&num_missing_packets, 1)) {
     set_detailed_error("Unable to read num missing packets.");
     return false;
   }
 
   for (int i = 0; i < num_missing_packets; ++i) {
     QuicPacketSequenceNumber sequence_number;
     if (!ProcessPacketSequenceNumber(&sequence_number)) {
@@ skipping 111 matching lines @@
       tcp->receive_window = static_cast<QuicByteCount>(receive_window) << 4;
       break;
     }
     default:
       set_detailed_error("Illegal congestion feedback type.");
       DLOG(WARNING) << "Illegal congestion feedback type: "
                     << frame->type;
       return RaiseError(QUIC_INVALID_FRAME_DATA);
   }
 
-  visitor_->OnCongestionFeedbackFrame(*frame);
   return true;
 }
 
-bool QuicFramer::ProcessRstStreamFrame() {
-  QuicRstStreamFrame frame;
-  if (!reader_->ReadUInt32(&frame.stream_id)) {
+bool QuicFramer::ProcessRstStreamFrame(QuicRstStreamFrame* frame) {
+  if (!reader_->ReadUInt32(&frame->stream_id)) {
     set_detailed_error("Unable to read stream_id.");
     return false;
   }
 
   uint32 error_code;
   if (!reader_->ReadUInt32(&error_code)) {
     set_detailed_error("Unable to read rst stream error code.");
     return false;
   }
 
   if (error_code >= QUIC_STREAM_LAST_ERROR ||
       error_code < QUIC_STREAM_NO_ERROR) {
     set_detailed_error("Invalid rst stream error code.");
     return false;
   }
 
-  frame.error_code = static_cast<QuicRstStreamErrorCode>(error_code);
+  frame->error_code = static_cast<QuicRstStreamErrorCode>(error_code);
 
   StringPiece error_details;
   if (!reader_->ReadStringPiece16(&error_details)) {
     set_detailed_error("Unable to read rst stream error details.");
     return false;
   }
-  frame.error_details = error_details.as_string();
+  frame->error_details = error_details.as_string();
 
-  visitor_->OnRstStreamFrame(frame);
   return true;
 }
 
-bool QuicFramer::ProcessConnectionCloseFrame() {
-  QuicConnectionCloseFrame frame;
-
+bool QuicFramer::ProcessConnectionCloseFrame(QuicConnectionCloseFrame* frame) {
   uint32 error_code;
   if (!reader_->ReadUInt32(&error_code)) {
     set_detailed_error("Unable to read connection close error code.");
     return false;
   }
 
   if (error_code >= QUIC_LAST_ERROR ||
          error_code < QUIC_NO_ERROR) {
     set_detailed_error("Invalid error code.");
     return false;
   }
 
-  frame.error_code = static_cast<QuicErrorCode>(error_code);
+  frame->error_code = static_cast<QuicErrorCode>(error_code);
 
   StringPiece error_details;
   if (!reader_->ReadStringPiece16(&error_details)) {
     set_detailed_error("Unable to read connection close error details.");
     return false;
   }
-  frame.error_details = error_details.as_string();
+  frame->error_details = error_details.as_string();
 
-  if (!ProcessAckFrame(&frame.ack_frame)) {
+  if (!ProcessAckFrame(&frame->ack_frame)) {
     DLOG(WARNING) << "Unable to process ack frame.";
     return false;
   }
 
-  visitor_->OnConnectionCloseFrame(frame);
+  if (!visitor_->OnAckFrame(frame->ack_frame)) {
+    DLOG(INFO) << "Visitor asked to stopped further processing.";
+    // Returning true since there was no parsing error.
+    return true;
+  }
+
   return true;
 }
 
-bool QuicFramer::ProcessGoAwayFrame() {
-  QuicGoAwayFrame frame;
-
+bool QuicFramer::ProcessGoAwayFrame(QuicGoAwayFrame* frame) {
   uint32 error_code;
   if (!reader_->ReadUInt32(&error_code)) {
     set_detailed_error("Unable to read go away error code.");
     return false;
   }
-  frame.error_code = static_cast<QuicErrorCode>(error_code);
+  frame->error_code = static_cast<QuicErrorCode>(error_code);
 
   if (error_code >= QUIC_LAST_ERROR ||
       error_code < QUIC_NO_ERROR) {
     set_detailed_error("Invalid error code.");
     return false;
   }
 
   uint32 stream_id;
   if (!reader_->ReadUInt32(&stream_id)) {
     set_detailed_error("Unable to read last good stream id.");
     return false;
   }
-  frame.last_good_stream_id = static_cast<QuicStreamId>(stream_id);
+  frame->last_good_stream_id = static_cast<QuicStreamId>(stream_id);
 
   StringPiece reason_phrase;
   if (!reader_->ReadStringPiece16(&reason_phrase)) {
     set_detailed_error("Unable to read goaway reason.");
     return false;
   }
-  frame.reason_phrase = reason_phrase.as_string();
+  frame->reason_phrase = reason_phrase.as_string();
 
-  visitor_->OnGoAwayFrame(frame);
   return true;
 }
 
 // static
 StringPiece QuicFramer::GetAssociatedDataFromEncryptedPacket(
     const QuicEncryptedPacket& encrypted, bool includes_version) {
   return StringPiece(encrypted.data() + kStartOfHashData,
                      GetStartOfEncryptedData(includes_version) -
                          kStartOfHashData);
 }
@@ skipping 199 matching lines @@
   size_t received_entropy_offset = writer->length();
   if (!writer->WriteUInt8(frame.received_info.entropy_hash)) {
     return false;
   }
 
   size_t largest_observed_offset = writer->length();
   if (!AppendPacketSequenceNumber(frame.received_info.largest_observed,
                                   writer)) {
     return false;
   }
-  // TODO(pwestin): calculate and add delta_time_largest_observed to the
-  // message.
+  uint32 delta_time_largest_observed_us = kInvalidDeltaTime;
+  if (!frame.received_info.delta_time_largest_observed.IsInfinite()) {
+    delta_time_largest_observed_us =
+        frame.received_info.delta_time_largest_observed.ToMicroseconds();
+  }
+
+  size_t delta_time_largest_observed_offset = writer->length();
+  if (!writer->WriteUInt32(delta_time_largest_observed_us)) {
+    return false;
+  }
 
   // We don't check for overflowing uint8 here, because we only can fit 192 acks
   // per packet, so if we overflow we will be truncated.
   uint8 num_missing_packets = frame.received_info.missing_packets.size();
   size_t num_missing_packets_offset = writer->length();
   if (!writer->WriteBytes(&num_missing_packets, 1)) {
     return false;
   }
 
   SequenceNumberSet::const_iterator it =
       frame.received_info.missing_packets.begin();
   int num_missing_packets_written = 0;
   for (; it != frame.received_info.missing_packets.end(); ++it) {
     if (!AppendPacketSequenceNumber(*it, writer)) {
       // We are truncating.
       QuicPacketSequenceNumber largest_observed =
           CalculateLargestObserved(frame.received_info.missing_packets, --it);
       // Overwrite entropy hash for received packets.
       writer->WriteUInt8ToOffset(
           entropy_calculator_->ReceivedEntropyHash(largest_observed),
           received_entropy_offset);
       // Overwrite largest_observed.
       writer->WriteUInt48ToOffset(largest_observed & kSequenceNumberMask,
                                   largest_observed_offset);
+      writer->WriteUInt32ToOffset(kInvalidDeltaTime,
+                                  delta_time_largest_observed_offset);
       writer->WriteUInt8ToOffset(num_missing_packets_written,
                                  num_missing_packets_offset);
       return true;
     }
     ++num_missing_packets_written;
     DCHECK_GE(numeric_limits<uint8>::max(), num_missing_packets_written);
   }
 
   return true;
 }
@@ skipping 137 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DLOG(INFO) << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net