Landing Recent QUIC changes until Sat Sep 10 00:32:41

net/quic/core/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/core/quic_framer.h"
 
 #include <cstdint>
 #include <memory>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/quic/core/crypto/crypto_framer.h"
 #include "net/quic/core/crypto/crypto_handshake_message.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
 #include "net/quic/core/crypto/quic_decrypter.h"
 #include "net/quic/core/crypto/quic_encrypter.h"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_data_reader.h"
 #include "net/quic/core/quic_data_writer.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_socket_address_coder.h"
 #include "net/quic/core/quic_utils.h"
 
+using base::ContainsKey;
 using base::StringPiece;
 using std::map;
 using std::max;
 using std::min;
 using std::numeric_limits;
 using std::string;
 using std::vector;
 #define PREDICT_FALSE(x) (x)
 
 namespace net {
@@ skipping 99 matching lines @@
 
 }  // namespace
 
 QuicFramer::QuicFramer(const QuicVersionVector& supported_versions,
                        QuicTime creation_time,
                        Perspective perspective)
     : visitor_(nullptr),
       entropy_calculator_(nullptr),
       error_(QUIC_NO_ERROR),
       last_packet_number_(0),
+      largest_packet_number_(0),
       last_path_id_(kInvalidPathId),
       last_serialized_connection_id_(0),
       supported_versions_(supported_versions),
       decrypter_level_(ENCRYPTION_NONE),
       alternative_decrypter_level_(ENCRYPTION_NONE),
       alternative_decrypter_latch_(false),
       perspective_(perspective),
       validate_flags_(true),
       creation_time_(creation_time),
       last_timestamp_(QuicTime::Delta::Zero()) {
@@ skipping 637 matching lines @@
 
   uint64_t time = ClosestTo(
       last_timestamp_.ToMicroseconds(), epoch + time_delta_us,
       ClosestTo(last_timestamp_.ToMicroseconds(), prev_epoch + time_delta_us,
                 next_epoch + time_delta_us));
 
   return QuicTime::Delta::FromMicroseconds(time);
 }
 
 bool QuicFramer::IsValidPath(QuicPathId path_id,
-                             QuicPacketNumber* last_packet_number) {
-  if (base::ContainsKey(closed_paths_, path_id)) {
+                             QuicPacketNumber* base_packet_number) {
+  if (ContainsKey(closed_paths_, path_id)) {
     // Path is closed.
     return false;
   }
 
-  if (path_id == last_path_id_) {
-    *last_packet_number = last_packet_number_;
-    return true;
-  }
+  if (FLAGS_quic_packet_numbers_largest_received) {
+    if (path_id == last_path_id_) {
+      *base_packet_number = largest_packet_number_;
+      return true;
+    }
 
-  if (base::ContainsKey(last_packet_numbers_, path_id)) {
-    *last_packet_number = last_packet_numbers_[path_id];
+    if (ContainsKey(largest_packet_numbers_, path_id)) {
+      *base_packet_number = largest_packet_numbers_[path_id];
+    } else {
+      *base_packet_number = 0;
+    }
   } else {
-    *last_packet_number = 0;
+    if (path_id == last_path_id_) {
+      *base_packet_number = last_packet_number_;
+      return true;
+    }
+
+    if (ContainsKey(last_packet_numbers_, path_id)) {
+      *base_packet_number = last_packet_numbers_[path_id];
+    } else {
+      *base_packet_number = 0;
+    }
   }
 
   return true;
 }
 
 void QuicFramer::SetLastPacketNumber(const QuicPacketHeader& header) {
   if (header.public_header.multipath_flag && header.path_id != last_path_id_) {
     if (last_path_id_ != kInvalidPathId) {
       // Save current last packet number before changing path.
       last_packet_numbers_[last_path_id_] = last_packet_number_;
+      if (FLAGS_quic_packet_numbers_largest_received) {
+        largest_packet_numbers_[last_path_id_] = largest_packet_number_;
+      }
     }
     // Change path.
     last_path_id_ = header.path_id;
   }
   last_packet_number_ = header.packet_number;
+  if (FLAGS_quic_packet_numbers_largest_received) {
+    largest_packet_number_ = max(header.packet_number, largest_packet_number_);
+  }
 }
 
 void QuicFramer::OnPathClosed(QuicPathId path_id) {
   closed_paths_.insert(path_id);
   last_packet_numbers_.erase(path_id);
 }
 
 QuicPacketNumber QuicFramer::CalculatePacketNumberFromWire(
     QuicPacketNumberLength packet_number_length,
-    QuicPacketNumber last_packet_number,
+    QuicPacketNumber base_packet_number,
     QuicPacketNumber packet_number) const {
   // The new packet number might have wrapped to the next epoch, or
   // it might have reverse wrapped to the previous epoch, or it might
   // remain in the same epoch.  Select the packet number closest to the
   // next expected packet number, the previous packet number plus 1.
 
   // epoch_delta is the delta between epochs the packet number was serialized
   // with, so the correct value is likely the same epoch as the last sequence
   // number or an adjacent epoch.
   const QuicPacketNumber epoch_delta = UINT64_C(1)
                                        << (8 * packet_number_length);
-  QuicPacketNumber next_packet_number = last_packet_number + 1;
-  QuicPacketNumber epoch = last_packet_number & ~(epoch_delta - 1);
+  QuicPacketNumber next_packet_number = base_packet_number + 1;
+  QuicPacketNumber epoch = base_packet_number & ~(epoch_delta - 1);
   QuicPacketNumber prev_epoch = epoch - epoch_delta;
   QuicPacketNumber next_epoch = epoch + epoch_delta;
 
   return ClosestTo(next_packet_number, epoch + packet_number,
                    ClosestTo(next_packet_number, prev_epoch + packet_number,
                              next_epoch + packet_number));
 }
 
 bool QuicFramer::ProcessPublicHeader(QuicDataReader* reader,
                                      QuicPacketPublicHeader* public_header) {
@@ skipping 63 matching lines @@
   // and only for versions after QUIC_VERSION_32. Earlier versions will
   // set this bit when indicating an 8-byte connection ID, which should
   // not be interpreted as indicating a nonce is present.
   if (quic_version_ > QUIC_VERSION_32 &&
       public_flags & PACKET_PUBLIC_FLAGS_NONCE &&
       !(public_flags & PACKET_PUBLIC_FLAGS_VERSION) &&
       !(public_flags & PACKET_PUBLIC_FLAGS_RST) &&
       // The nonce flag from a client is ignored and is assumed to be an older
       // client indicating an eight-byte connection ID.
       perspective_ == Perspective::IS_CLIENT) {
-    if (!reader->ReadBytes(reinterpret_cast<uint8_t*>(last_nonce_),
-                           sizeof(last_nonce_))) {
+    if (!reader->ReadBytes(reinterpret_cast<uint8_t*>(last_nonce_.data()),
+                           last_nonce_.size())) {
       set_detailed_error("Unable to read nonce.");
       return false;
     }
     public_header->nonce = &last_nonce_;
   } else {
     public_header->nonce = nullptr;
   }
 
   return true;
 }
@@ skipping 94 matching lines @@
 
 bool QuicFramer::ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader,
                                               QuicPacketHeader* header) {
   header->path_id = kDefaultPathId;
   if (header->public_header.multipath_flag &&
       !ProcessPathId(encrypted_reader, &header->path_id)) {
     set_detailed_error("Unable to read path id.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
-  QuicPacketNumber last_packet_number = last_packet_number_;
+  QuicPacketNumber base_packet_number =
+      FLAGS_quic_packet_numbers_largest_received ? largest_packet_number_
+                                                 : last_packet_number_;
   if (header->public_header.multipath_flag &&
-      !IsValidPath(header->path_id, &last_packet_number)) {
+      !IsValidPath(header->path_id, &base_packet_number)) {
     // Stop processing because path is closed.
     return false;
   }
 
   if (!ProcessPacketSequenceNumber(
           encrypted_reader, header->public_header.packet_number_length,
-          last_packet_number, &header->packet_number)) {
+          base_packet_number, &header->packet_number)) {
     set_detailed_error("Unable to read packet number.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
   if (header->packet_number == 0u) {
     set_detailed_error("packet numbers cannot be 0.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
   if (!visitor_->OnUnauthenticatedHeader(*header)) {
@@ skipping 47 matching lines @@
   if (!reader->ReadBytes(path_id, 1)) {
     return false;
   }
 
   return true;
 }
 
 bool QuicFramer::ProcessPacketSequenceNumber(
     QuicDataReader* reader,
     QuicPacketNumberLength packet_number_length,
-    QuicPacketNumber last_packet_number,
+    QuicPacketNumber base_packet_number,
     QuicPacketNumber* packet_number) {
   QuicPacketNumber wire_packet_number = 0u;
   if (!reader->ReadBytes(&wire_packet_number, packet_number_length)) {
     return false;
   }
 
   // TODO(ianswett): Explore the usefulness of trying multiple packet numbers
   // in case the first guess is incorrect.
   *packet_number = CalculatePacketNumberFromWire(
-      packet_number_length, last_packet_number, wire_packet_number);
+      packet_number_length, base_packet_number, wire_packet_number);
   return true;
 }
 
 bool QuicFramer::ProcessFrameData(QuicDataReader* reader,
                                   const QuicPacketHeader& header) {
   if (reader->IsDoneReading()) {
     set_detailed_error("Packet has no frames.");
     return RaiseError(QUIC_MISSING_PAYLOAD);
   }
   while (!reader->IsDoneReading()) {
@@ skipping 1466 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
 }  // namespace net