Land Recent QUIC changes.

net/quic/quic_connection.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_connection.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 35 matching lines @@
 const int kMaxPacketsToSerializeAtOnce = 6;
 
 // Limit the number of packets we send per retransmission-alarm so we
 // eventually cede.  10 is arbitrary.
 const size_t kMaxPacketsPerRetransmissionAlarm = 10;
 
 // Limit the number of FEC groups to two.  If we get enough out of order packets
 // that this becomes limiting, we can revisit.
 const size_t kMaxFecGroups = 2;
 
+// Limit the number of undecryptable packets we buffer in
+// expectation of the CHLO/SHLO arriving.
+const size_t kMaxUndecryptablePackets = 10;
+
 bool Near(QuicPacketSequenceNumber a, QuicPacketSequenceNumber b) {
   QuicPacketSequenceNumber delta = (a > b) ? a - b : b - a;
   return delta <= kMaxPacketGap;
 }
 
 }  // namespace
 
 #define ENDPOINT (is_server_ ? "Server: " : " Client: ")
 
 QuicConnection::QuicConnection(QuicGuid guid,
@@ skipping 46 matching lines @@
   /*
   if (FLAGS_fake_packet_loss_percentage > 0) {
     int32 seed = RandomBase::WeakSeed32();
     LOG(INFO) << ENDPOINT << "Seeding packet loss with " << seed;
     random_.reset(new MTRandom(seed));
   }
   */
 }
 
 QuicConnection::~QuicConnection() {
+  STLDeleteElements(&undecryptable_packets_);
   STLDeleteValues(&unacked_packets_);
   STLDeleteValues(&group_map_);
   for (QueuedPacketList::iterator it = queued_packets_.begin();
        it != queued_packets_.end(); ++it) {
     delete it->packet;
   }
   DLOG(INFO) << ENDPOINT << "write_blocked: " << write_blocked_;
 }
 
 bool QuicConnection::SelectMutualVersion(
@@ skipping 618 matching lines @@
   }
 
   if (!(peer_address == peer_address_ && self_address == self_address_)) {
     address_migrating_ = true;
   }
 
   stats_.bytes_received += packet.length();
   ++stats_.packets_received;
 
   if (!framer_.ProcessPacket(packet)) {
+    // If we are unable to decrypt this packet, it might be
+    // because the CHLO or SHLO packet was lost.
+    if (encryption_level_ != ENCRYPTION_FORWARD_SECURE &&
+        framer_.error() == QUIC_DECRYPTION_FAILURE &&
+        undecryptable_packets_.size() < kMaxUndecryptablePackets) {
+      QueueUndecryptablePacket(packet);
+    }
+    DVLOG(1) << ENDPOINT << "Unable to process packet.  Last packet processed: "
+             << last_header_.packet_sequence_number;
     return;
   }
+  MaybeProcessUndecryptablePackets();
   MaybeProcessRevivedPacket();
 }
 
 bool QuicConnection::OnCanWrite() {
   write_blocked_ = false;
 
   WriteQueuedPackets();
 
   // Sending queued packets may have caused the socket to become write blocked,
   // or the congestion manager to prohibit sending.  If we've sent everything
@@ skipping 206 matching lines @@
 }
 
 bool QuicConnection::IsRetransmission(
     QuicPacketSequenceNumber sequence_number) {
   RetransmissionMap::iterator it = retransmission_map_.find(sequence_number);
   return it != retransmission_map_.end() &&
       it->second.number_retransmissions > 0;
 }
 
 void QuicConnection::SetupRetransmission(
-    QuicPacketSequenceNumber sequence_number) {
+    QuicPacketSequenceNumber sequence_number,
+    EncryptionLevel level) {
   RetransmissionMap::iterator it = retransmission_map_.find(sequence_number);
   if (it == retransmission_map_.end()) {
     DVLOG(1) << ENDPOINT << "Will not retransmit packet " << sequence_number;
     return;
   }
 
   RetransmissionInfo retransmission_info = it->second;
+  // TODO(rch): consider using a much smaller retransmisison_delay
+  // for the ENCRYPTION_NONE packets.
+  size_t effective_retransmission_count =
+      level == ENCRYPTION_NONE ? 0 : retransmission_info.number_retransmissions;
   QuicTime::Delta retransmission_delay =
       congestion_manager_.GetRetransmissionDelay(
           unacked_packets_.size(),
-          retransmission_info.number_retransmissions);
+          effective_retransmission_count);
 
   retransmission_timeouts_.push(RetransmissionTime(
       sequence_number,
       clock_->ApproximateNow().Add(retransmission_delay),
       false));
 
   // Do not set the retransmisson alarm if we're already handling the
   // retransmission alarm because the retransmission alarm will be reset when
   // OnRetransmissionTimeout completes.
   if (!handling_retransmission_timeout_) {
@@ skipping 99 matching lines @@
   if (!retransmission) {
     time_of_last_sent_packet_ = now;
   }
   DVLOG(1) << ENDPOINT << "time of last sent packet: "
            << now.ToDebuggingValue();
 
   // Set the retransmit alarm only when we have sent the packet to the client
   // and not when it goes to the pending queue, otherwise we will end up adding
   // an entry to retransmission_timeout_ every time we attempt a write.
   if (retransmittable == HAS_RETRANSMITTABLE_DATA) {
-    SetupRetransmission(sequence_number);
+    SetupRetransmission(sequence_number, level);
   } else if (packet->is_fec_packet()) {
     SetupAbandonFecTimer(sequence_number);
   }
 
   congestion_manager_.SentPacket(sequence_number, now, packet->length(),
                                  retransmission);
 
   stats_.bytes_sent += encrypted->length();
   ++stats_.packets_sent;
 
@@ skipping 175 matching lines @@
 }
 
 const QuicDecrypter* QuicConnection::decrypter() const {
   return framer_.decrypter();
 }
 
 const QuicDecrypter* QuicConnection::alternative_decrypter() const {
   return framer_.alternative_decrypter();
 }
 
+void QuicConnection::QueueUndecryptablePacket(
+    const QuicEncryptedPacket& packet) {
+  DVLOG(1) << ENDPOINT << "Queueing undecryptable packet.";
+  char* data = new char[packet.length()];
+  memcpy(data, packet.data(), packet.length());
+  undecryptable_packets_.push_back(
+      new QuicEncryptedPacket(data, packet.length(), true));
+}
+
+void QuicConnection::MaybeProcessUndecryptablePackets() {
+  if (undecryptable_packets_.empty() ||
+      encryption_level_ == ENCRYPTION_NONE) {
+    return;
+  }
+
+  while (!undecryptable_packets_.empty()) {
+    DVLOG(1) << ENDPOINT << "Attempting to process undecryptable packet";
+    QuicEncryptedPacket* packet = undecryptable_packets_.front();
+    if (!framer_.ProcessPacket(*packet) &&
+        framer_.error() == QUIC_DECRYPTION_FAILURE) {
+      DVLOG(1) << ENDPOINT << "Unable to process undecryptable packet...";
+      break;
+    }
+    DVLOG(1) << ENDPOINT << "Processed undecryptable packet!";
+    delete packet;
+    undecryptable_packets_.pop_front();
+  }
+
+  // Once forward secure encryption is in use, there will be no
+  // new keys installed and hence any undecryptable packets will
+  // never be able to be decrypted.
+  if (encryption_level_ == ENCRYPTION_FORWARD_SECURE) {
+    STLDeleteElements(&undecryptable_packets_);
+  }
+}
+
 void QuicConnection::MaybeProcessRevivedPacket() {
   QuicFecGroup* group = GetFecGroup();
   if (group == NULL || !group->CanRevive()) {
     return;
   }
   QuicPacketHeader revived_header;
   char revived_payload[kMaxPacketSize];
   size_t len = group->Revive(&revived_header, revived_payload, kMaxPacketSize);
   revived_header.public_header.guid = guid_;
   revived_header.public_header.version_flag = false;
@@ skipping 172 matching lines @@
     if (connection_timeout < timeout) {
       timeout = connection_timeout;
     }
   }
 
   helper_->SetTimeoutAlarm(timeout);
   return false;
 }
 
 }  // namespace net