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/containers/hash_tables.h"
+#include "base/stl_util.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_handshake_message.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_socket_address_coder.h"
 
 using base::StringPiece;
 using std::make_pair;
@@ skipping 623 matching lines @@
   }
 
   visitor_->OnPacketComplete();
   return true;
 }
 
 bool QuicFramer::ProcessPublicResetPacket(
     const QuicPacketPublicHeader& public_header) {
   QuicPublicResetPacket packet(public_header);
 
-  if (reader_->BytesRemaining() <=
-      kPublicResetNonceSize + PACKET_6BYTE_SEQUENCE_NUMBER) {
-    // An old-style public reset packet.
+  if (public_header.sequence_number_length == PACKET_6BYTE_SEQUENCE_NUMBER) {
+    // An old-style public reset packet has the
+    // PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE bits set in the public flags.
     // TODO(wtc): remove this when we drop support for QUIC_VERSION_13.
     if (!reader_->ReadUInt64(&packet.nonce_proof)) {
       set_detailed_error("Unable to read nonce proof.");
       return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
     }
 
     if (!reader_->ReadUInt48(&packet.rejected_sequence_number)) {
       set_detailed_error("Unable to read rejected sequence number.");
       return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
     }
@@ skipping 706 matching lines @@
     }
     for (size_t i = 0; i <= range_length; ++i) {
       received_info->missing_packets.insert(last_sequence_number - i);
     }
     // Subtract an extra 1 to ensure ranges are represented efficiently and
     // can't overlap by 1 sequence number.  This allows a missing_delta of 0
     // to represent an adjacent nack range.
     last_sequence_number -= (range_length + 1);
   }
 
+  if (quic_version_ > QUIC_VERSION_14) {
+    // Parse the revived packets list.
+    uint8 num_revived_packets;
+    if (!reader_->ReadBytes(&num_revived_packets, 1)) {
+      set_detailed_error("Unable to read num revived packets.");
+      return false;
+    }
+
+    for (size_t i = 0; i < num_revived_packets; ++i) {
+      QuicPacketSequenceNumber revived_packet = 0;
+      if (!reader_->ReadBytes(&revived_packet,
+                              largest_observed_sequence_number_length)) {
+        set_detailed_error("Unable to read revived packet.");
+        return false;
+      }
+
+      received_info->revived_packets.insert(revived_packet);
+    }
+  }
+
   return true;
 }
 
 bool QuicFramer::ProcessSentInfo(const QuicPacketHeader& header,
                                  SentPacketInfo* sent_info) {
   if (!reader_->ReadBytes(&sent_info->entropy_hash, 1)) {
     set_detailed_error("Unable to read entropy hash for sent packets.");
     return false;
   }
 
@@ skipping 17 matching lines @@
     set_detailed_error("Unable to read congestion feedback type.");
     return false;
   }
   frame->type =
       static_cast<CongestionFeedbackType>(feedback_type);
 
   switch (frame->type) {
     case kInterArrival: {
       CongestionFeedbackMessageInterArrival* inter_arrival =
           &frame->inter_arrival;
-      uint16 unused_accumulated_number_of_lost_packets;
-      if (!reader_->ReadUInt16(
-              &unused_accumulated_number_of_lost_packets)) {
-        set_detailed_error(
-            "Unable to read accumulated number of lost packets.");
-        return false;
+      if (quic_version_ <= QUIC_VERSION_14) {
+        uint16 unused_accumulated_number_of_lost_packets;
+        if (!reader_->ReadUInt16(
+                &unused_accumulated_number_of_lost_packets)) {
+          set_detailed_error(
+              "Unable to read accumulated number of lost packets.");
+          return false;
+        }
       }
       uint8 num_received_packets;
       if (!reader_->ReadBytes(&num_received_packets, 1)) {
         set_detailed_error("Unable to read num received packets.");
         return false;
       }
 
       if (num_received_packets > 0u) {
         uint64 smallest_received;
         if (!ProcessPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
@@ skipping 39 matching lines @@
       uint32 bitrate = 0;
       if (!reader_->ReadUInt32(&bitrate)) {
         set_detailed_error("Unable to read bitrate.");
         return false;
       }
       frame->fix_rate.bitrate = QuicBandwidth::FromBytesPerSecond(bitrate);
       break;
     }
     case kTCP: {
       CongestionFeedbackMessageTCP* tcp = &frame->tcp;
-      uint16 unused_accumulated_number_of_lost_packets;
-      if (!reader_->ReadUInt16(&unused_accumulated_number_of_lost_packets)) {
-        set_detailed_error(
-            "Unable to read accumulated number of lost packets.");
-        return false;
+      if (quic_version_ <= QUIC_VERSION_14) {
+        uint16 unused_accumulated_number_of_lost_packets;
+        if (!reader_->ReadUInt16(&unused_accumulated_number_of_lost_packets)) {
+          set_detailed_error(
+              "Unable to read accumulated number of lost packets.");
+          return false;
+        }
       }
       // TODO(ianswett): Remove receive window, since it's constant.
       uint16 receive_window = 0;
       if (!reader_->ReadUInt16(&receive_window)) {
         set_detailed_error("Unable to read receive window.");
         return false;
       }
       // Simple bit packing, don't send the 4 least significant bits.
       tcp->receive_window = static_cast<QuicByteCount>(receive_window) << 4;
       break;
@@ skipping 265 matching lines @@
 
 size_t QuicFramer::GetAckFrameSize(
     const QuicAckFrame& ack,
     QuicSequenceNumberLength sequence_number_length) {
   AckFrameInfo ack_info = GetAckFrameInfo(ack);
   QuicSequenceNumberLength largest_observed_length =
       GetMinSequenceNumberLength(ack.received_info.largest_observed);
   QuicSequenceNumberLength missing_sequence_number_length =
       GetMinSequenceNumberLength(ack_info.max_delta);
 
-  return GetMinAckFrameSize(quic_version_,
-                            sequence_number_length,
-                            largest_observed_length) +
-      (ack_info.nack_ranges.empty() ? 0 : kNumberOfMissingPacketsSize) +
-       ack_info.nack_ranges.size() *
-           (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER);
+  size_t ack_size = GetMinAckFrameSize(quic_version_,
+                                       sequence_number_length,
+                                       largest_observed_length);
+  if (!ack_info.nack_ranges.empty()) {
+    ack_size += kNumberOfMissingPacketsSize  +
+        (quic_version_ <= QUIC_VERSION_14 ? 0 : kNumberOfRevivedPacketsSize);
+    ack_size += ack_info.nack_ranges.size() *
+      (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER);
+    ack_size +=
+        ack.received_info.revived_packets.size() * largest_observed_length;
+  }
+  return ack_size;
 }
 
 size_t QuicFramer::ComputeFrameLength(
     const QuicFrame& frame,
     bool last_frame_in_packet,
     QuicSequenceNumberLength sequence_number_length) {
   switch (frame.type) {
     case STREAM_FRAME:
       return GetMinStreamFrameSize(quic_version_,
                                    frame.stream_frame->stream_id,
                                    frame.stream_frame->offset,
                                    last_frame_in_packet) +
           frame.stream_frame->data.TotalBufferSize();
     case ACK_FRAME: {
       return GetAckFrameSize(*frame.ack_frame, sequence_number_length);
     }
     case CONGESTION_FEEDBACK_FRAME: {
       size_t len = kQuicFrameTypeSize;
       const QuicCongestionFeedbackFrame& congestion_feedback =
           *frame.congestion_feedback_frame;
       len += 1;  // Congestion feedback type.
 
       switch (congestion_feedback.type) {
         case kInterArrival: {
           const CongestionFeedbackMessageInterArrival& inter_arrival =
               congestion_feedback.inter_arrival;
-          len += 2;
+          if (quic_version_ <= QUIC_VERSION_14) {
+            len += 2;  // Accumulated number of lost packets.
+          }
           len += 1;  // Number received packets.
           if (inter_arrival.received_packet_times.size() > 0) {
             len += PACKET_6BYTE_SEQUENCE_NUMBER;  // Smallest received.
             len += 8;  // Time.
             // 2 bytes per sequence number delta plus 4 bytes per delta time.
             len += PACKET_6BYTE_SEQUENCE_NUMBER *
                 (inter_arrival.received_packet_times.size() - 1);
           }
           break;
         }
         case kFixRate:
-          len += 4;
+          len += 4;  // Bitrate.
           break;
         case kTCP:
-          len += 4;
+          if (quic_version_ <= QUIC_VERSION_14) {
+            len += 2;  // Accumulated number of lost packets.
+          }
+          len += 2;  // Receive window.
           break;
         default:
           set_detailed_error("Illegal feedback type.");
           DVLOG(1) << "Illegal feedback type: " << congestion_feedback.type;
           break;
       }
       return len;
     }
     case RST_STREAM_FRAME:
       return GetMinRstStreamFrameSize(quic_version_) +
@@ skipping 133 matching lines @@
   QuicPacketSequenceNumber ack_largest_observed =
       frame.received_info.largest_observed;
   QuicSequenceNumberLength largest_observed_length =
       GetMinSequenceNumberLength(ack_largest_observed);
   QuicSequenceNumberLength missing_sequence_number_length =
       GetMinSequenceNumberLength(ack_info.max_delta);
   // Determine whether we need to truncate ranges.
   size_t available_range_bytes = writer->capacity() - writer->length() -
       GetMinAckFrameSize(quic_version_,
                          header.public_header.sequence_number_length,
-                         largest_observed_length);
+                         largest_observed_length) -
+      (quic_version_ <= QUIC_VERSION_14 ? 0 : kNumberOfRevivedPacketsSize);
   size_t max_num_ranges = available_range_bytes /
       (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER);
   max_num_ranges =
       min(static_cast<size_t>(numeric_limits<uint8>::max()), max_num_ranges);
   bool truncated = ack_info.nack_ranges.size() > max_num_ranges;
   DVLOG_IF(1, truncated) << "Truncating ack from "
                          << ack_info.nack_ranges.size() << " ranges to "
                          << max_num_ranges;
 
   // Write out the type byte by setting the low order bits and doing shifts
@@ skipping 21 matching lines @@
 
   // TODO(satyamshekhar): Decide how often we really should send this
   // entropy_hash update.
   if (!writer->WriteUInt8(frame.sent_info.entropy_hash)) {
     return false;
   }
 
   DCHECK_GE(header.packet_sequence_number, frame.sent_info.least_unacked);
   const QuicPacketSequenceNumber least_unacked_delta =
       header.packet_sequence_number - frame.sent_info.least_unacked;
+  const QuicPacketSequenceNumber length_shift =
+      header.public_header.sequence_number_length * 8;
+  if (least_unacked_delta >> length_shift > 0) {
+    LOG(DFATAL) << "sequence_number_length "
+                << header.public_header.sequence_number_length
+                << " is too small for least_unacked_delta: "
+                << least_unacked_delta;
+    return false;
+  }
   if (!AppendPacketSequenceNumber(header.public_header.sequence_number_length,
                                   least_unacked_delta, writer)) {
     return false;
   }
 
   const ReceivedPacketInfo& received_info = frame.received_info;
   QuicPacketEntropyHash ack_entropy_hash = received_info.entropy_hash;
   NackRangeMap::reverse_iterator ack_iter = ack_info.nack_ranges.rbegin();
   if (truncated) {
     // Skip the nack ranges which the truncated ack won't include and set
@@ skipping 53 matching lines @@
       return false;
     }
     if (!AppendPacketSequenceNumber(PACKET_1BYTE_SEQUENCE_NUMBER,
                                     ack_iter->second, writer)) {
       return false;
     }
     // Subtract 1 so a missing_delta of 0 means an adjacent range.
     last_sequence_written = ack_iter->first - 1;
     ++num_ranges_written;
   }
+  DCHECK_EQ(num_missing_ranges, num_ranges_written);
 
-  DCHECK_EQ(num_missing_ranges, num_ranges_written);
+  if (quic_version_ > QUIC_VERSION_14) {
+    // Append revived packets.
+    // If not all the revived packets fit, only mention the ones that do.
+    uint8 num_revived_packets =
+        min(received_info.revived_packets.size(),
+            static_cast<size_t>(numeric_limits<uint8>::max()));
+    num_revived_packets = min(
+        static_cast<size_t>(num_revived_packets),
+        (writer->capacity() - writer->length()) / largest_observed_length);
+    if (!writer->WriteBytes(&num_revived_packets, 1)) {
+      return false;
+    }
+
+    SequenceNumberSet::const_iterator iter =
+        received_info.revived_packets.begin();
+    for (int i = 0; i < num_revived_packets; ++i, ++iter) {
+      LOG_IF(DFATAL, !ContainsKey(received_info.missing_packets, *iter));
+      if (!AppendPacketSequenceNumber(largest_observed_length,
+                                      *iter, writer)) {
+        return false;
+      }
+    }
+  }
+
   return true;
 }
 
 bool QuicFramer::AppendQuicCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& frame,
     QuicDataWriter* writer) {
   if (!writer->WriteBytes(&frame.type, 1)) {
     return false;
   }
 
   switch (frame.type) {
     case kInterArrival: {
       const CongestionFeedbackMessageInterArrival& inter_arrival =
           frame.inter_arrival;
-      // accumulated_number_of_lost_packets is removed.  Always write 0.
-      if (!writer->WriteUInt16(0)) {
-        return false;
+      if (quic_version_ <= QUIC_VERSION_14) {
+        // accumulated_number_of_lost_packets is removed.  Always write 0.
+        if (!writer->WriteUInt16(0)) {
+          return false;
+        }
       }
       DCHECK_GE(numeric_limits<uint8>::max(),
                 inter_arrival.received_packet_times.size());
       if (inter_arrival.received_packet_times.size() >
           numeric_limits<uint8>::max()) {
         return false;
       }
       // TODO(ianswett): Make num_received_packets a varint.
       uint8 num_received_packets =
           inter_arrival.received_packet_times.size();
@@ skipping 41 matching lines @@
       if (!writer->WriteUInt32(fix_rate.bitrate.ToBytesPerSecond())) {
         return false;
       }
       break;
     }
     case kTCP: {
       const CongestionFeedbackMessageTCP& tcp = frame.tcp;
       DCHECK_LE(tcp.receive_window, 1u << 20);
       // Simple bit packing, don't send the 4 least significant bits.
       uint16 receive_window = static_cast<uint16>(tcp.receive_window >> 4);
-      // accumulated_number_of_lost_packets is removed.  Always write 0.
-      if (!writer->WriteUInt16(0)) {
-        return false;
+      if (quic_version_ <= QUIC_VERSION_14) {
+        // accumulated_number_of_lost_packets is removed.  Always write 0.
+        if (!writer->WriteUInt16(0)) {
+          return false;
+        }
       }
       if (!writer->WriteUInt16(receive_window)) {
         return false;
       }
       break;
     }
     default:
       return false;
   }
 
@@ skipping 76 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net