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 <string.h>
 #include <sys/types.h>
+
 #include <algorithm>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <set>
 #include <utility>
 
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 27 matching lines @@
 namespace {
 
 // The largest gap in packets we'll accept without closing the connection.
 // This will likely have to be tuned.
 const QuicPacketSequenceNumber kMaxPacketGap = 5000;
 
 // 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;
-
 // Maximum number of acks received before sending an ack in response.
 const size_t kMaxPacketsReceivedBeforeAckSend = 20;
 
 bool Near(QuicPacketSequenceNumber a, QuicPacketSequenceNumber b) {
   QuicPacketSequenceNumber delta = (a > b) ? a - b : b - a;
   return delta <= kMaxPacketGap;
 }
 
 // An alarm that is scheduled to send an ack if a timeout occurs.
 class AckAlarm : public QuicAlarm::Delegate {
@@ skipping 85 matching lines @@
  private:
   QuicConnection* connection_;
 
   DISALLOW_COPY_AND_ASSIGN(PingAlarm);
 };
 
 }  // namespace
 
 QuicConnection::QueuedPacket::QueuedPacket(SerializedPacket packet,
                                            EncryptionLevel level)
-  : serialized_packet(packet),
-    encryption_level(level),
-    transmission_type(NOT_RETRANSMISSION),
-    original_sequence_number(0) {
+    : serialized_packet(packet),
+      encryption_level(level),
+      transmission_type(NOT_RETRANSMISSION),
+      original_sequence_number(0) {
 }
 
 QuicConnection::QueuedPacket::QueuedPacket(
     SerializedPacket packet,
     EncryptionLevel level,
     TransmissionType transmission_type,
     QuicPacketSequenceNumber original_sequence_number)
     : serialized_packet(packet),
       encryption_level(level),
       transmission_type(transmission_type),
@@ skipping 18 matching lines @@
       clock_(helper->GetClock()),
       random_generator_(helper->GetRandomGenerator()),
       connection_id_(connection_id),
       peer_address_(address),
       migrating_peer_port_(0),
       last_packet_revived_(false),
       last_size_(0),
       last_decrypted_packet_level_(ENCRYPTION_NONE),
       largest_seen_packet_with_ack_(0),
       largest_seen_packet_with_stop_waiting_(0),
+      max_undecryptable_packets_(0),
       pending_version_negotiation_packet_(false),
       received_packet_manager_(&stats_),
       ack_queued_(false),
       num_packets_received_since_last_ack_sent_(0),
       stop_waiting_count_(0),
       ack_alarm_(helper->CreateAlarm(new AckAlarm(this))),
       retransmission_alarm_(helper->CreateAlarm(new RetransmissionAlarm(this))),
       send_alarm_(helper->CreateAlarm(new SendAlarm(this))),
       resume_writes_alarm_(helper->CreateAlarm(new SendAlarm(this))),
       timeout_alarm_(helper->CreateAlarm(new TimeoutAlarm(this))),
@@ skipping 47 matching lines @@
       SetNetworkTimeouts(QuicTime::Delta::Infinite(),
                          config.IdleConnectionStateLifetime());
     } else {
       SetNetworkTimeouts(config.max_time_before_crypto_handshake(),
                          config.max_idle_time_before_crypto_handshake());
     }
   } else {
     SetIdleNetworkTimeout(config.IdleConnectionStateLifetime());
   }
   sent_packet_manager_.SetFromConfig(config);
+  max_undecryptable_packets_ = config.max_undecryptable_packets();
 }
 
 bool QuicConnection::SelectMutualVersion(
     const QuicVersionVector& available_versions) {
   // Try to find the highest mutual version by iterating over supported
   // versions, starting with the highest, and breaking out of the loop once we
   // find a matching version in the provided available_versions vector.
   const QuicVersionVector& supported_versions = framer_.supported_versions();
   for (size_t i = 0; i < supported_versions.size(); ++i) {
     const QuicVersion& version = supported_versions[i];
@@ skipping 825 matching lines @@
   CheckForAddressMigration(self_address, peer_address);
 
   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 (framer_.error() == QUIC_DECRYPTION_FAILURE) {
       if (encryption_level_ != ENCRYPTION_FORWARD_SECURE &&
-          undecryptable_packets_.size() < kMaxUndecryptablePackets) {
+          undecryptable_packets_.size() < max_undecryptable_packets_) {
         QueueUndecryptablePacket(packet);
       } else if (debug_visitor_.get() != nullptr) {
         debug_visitor_->OnUndecryptablePacket();
       }
     }
     DVLOG(1) << ENDPOINT << "Unable to process packet.  Last packet processed: "
              << last_header_.packet_sequence_number;
     return;
   }
 
@@ skipping 39 matching lines @@
   WritePendingRetransmissions();
 
   // Sending queued packets may have caused the socket to become write blocked,
   // or the congestion manager to prohibit sending.  If we've sent everything
   // we had queued and we're still not blocked, let the visitor know it can
   // write more.
   if (!CanWrite(HAS_RETRANSMITTABLE_DATA)) {
     return;
   }
 
-  {  // Limit the scope of the bundler.
-    // Set |include_ack| to false in bundler; ack inclusion happens elsewhere.
+  { // Limit the scope of the bundler. ACK inclusion happens elsewhere.
     ScopedPacketBundler bundler(this, NO_ACK);
     visitor_->OnCanWrite();
   }
 
   // After the visitor writes, it may have caused the socket to become write
   // blocked or the congestion manager to prohibit sending, so check again.
   if (visitor_->WillingAndAbleToWrite() &&
       !resume_writes_alarm_->IsSet() &&
       CanWrite(HAS_RETRANSMITTABLE_DATA)) {
     // We're not write blocked, but some stream didn't write out all of its
@@ skipping 124 matching lines @@
   QuicTime::Delta delay = sent_packet_manager_.TimeUntilSend(
       now, retransmittable);
   if (delay.IsInfinite()) {
     send_alarm_->Cancel();
     return false;
   }
 
   // If the scheduler requires a delay, then we can not send this packet now.
   if (!delay.IsZero()) {
     send_alarm_->Update(now.Add(delay), QuicTime::Delta::FromMilliseconds(1));
-    DVLOG(1) << "Delaying sending.";
+    DVLOG(1) << ENDPOINT << "Delaying sending " << delay.ToMilliseconds()
+             << "ms";
     return false;
   }
   send_alarm_->Cancel();
   return true;
 }
 
 bool QuicConnection::WritePacket(QueuedPacket* packet) {
   if (!WritePacketInner(packet)) {
     return false;
   }
@@ skipping 65 matching lines @@
            << QuicUtils::StringToHexASCIIDump(
                packet->serialized_packet.packet->AsStringPiece());
 
   WriteResult result = writer_->WritePacket(encrypted->data(),
                                             encrypted->length(),
                                             self_address().address(),
                                             peer_address());
   if (result.error_code == ERR_IO_PENDING) {
     DCHECK_EQ(WRITE_STATUS_BLOCKED, result.status);
   }
-  if (debug_visitor_.get() != nullptr) {
-    // Pass the write result to the visitor.
-    debug_visitor_->OnPacketSent(sequence_number,
-                                 packet->original_sequence_number,
-                                 packet->encryption_level,
-                                 packet->transmission_type,
-                                 *encrypted,
-                                 result);
-  }
 
   if (result.status == WRITE_STATUS_BLOCKED) {
     visitor_->OnWriteBlocked();
     // If the socket buffers the the data, then the packet should not
     // be queued and sent again, which would result in an unnecessary
     // duplicate packet being sent.  The helper must call OnCanWrite
     // when the write completes, and OnWriteError if an error occurs.
     if (!writer_->IsWriteBlockedDataBuffered()) {
       return false;
     }
   }
   QuicTime now = clock_->Now();
+  if (result.status != WRITE_STATUS_ERROR && debug_visitor_.get() != nullptr) {
+    // Pass the write result to the visitor.
+    debug_visitor_->OnPacketSent(packet->serialized_packet,
+                                 packet->original_sequence_number,
+                                 packet->encryption_level,
+                                 packet->transmission_type,
+                                 *encrypted,
+                                 now);
+  }
   if (packet->transmission_type == NOT_RETRANSMISSION) {
     time_of_last_sent_new_packet_ = now;
   }
   SetPingAlarm();
   DVLOG(1) << ENDPOINT << "time of last sent packet: "
            << now.ToDebuggingValue();
 
   // TODO(ianswett): Change the sequence number length and other packet creator
   // options by a more explicit API than setting a struct value directly,
   // perhaps via the NetworkChangeVisitor.
@@ skipping 408 matching lines @@
   // we had queued and we're still not blocked, let the visitor know it can
   // write more.
   return ShouldGeneratePacket(NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA,
                               pending_handshake);
 }
 
 void QuicConnection::SetIdleNetworkTimeout(QuicTime::Delta timeout) {
   // Adjust the idle timeout on client and server to prevent clients from
   // sending requests to servers which have already closed the connection.
   if (is_server_) {
-    timeout = timeout.Add(QuicTime::Delta::FromSeconds(1));
+    timeout = timeout.Add(QuicTime::Delta::FromSeconds(3));
   } else if (timeout > QuicTime::Delta::FromSeconds(1)) {
     timeout = timeout.Subtract(QuicTime::Delta::FromSeconds(1));
   }
 
   if (timeout < idle_network_timeout_) {
     idle_network_timeout_ = timeout;
     if (FLAGS_quic_timeouts_only_from_alarms) {
       SetTimeoutAlarm();
     } else {
       CheckForTimeout();
@@ skipping 17 matching lines @@
 }
 
 void QuicConnection::SetNetworkTimeouts(QuicTime::Delta overall_timeout,
                                         QuicTime::Delta idle_timeout) {
   LOG_IF(DFATAL, idle_timeout > overall_timeout)
       << "idle_timeout:" << idle_timeout.ToMilliseconds()
       << " overall_timeout:" << overall_timeout.ToMilliseconds();
   // Adjust the idle timeout on client and server to prevent clients from
   // sending requests to servers which have already closed the connection.
   if (is_server_) {
-    idle_timeout = idle_timeout.Add(QuicTime::Delta::FromSeconds(1));
+    idle_timeout = idle_timeout.Add(QuicTime::Delta::FromSeconds(3));
   } else if (idle_timeout > QuicTime::Delta::FromSeconds(1)) {
     idle_timeout = idle_timeout.Subtract(QuicTime::Delta::FromSeconds(1));
   }
   overall_connection_timeout_ = overall_timeout;
   idle_network_timeout_ = idle_timeout;
 
   SetTimeoutAlarm();
 }
 
 void QuicConnection::CheckForTimeout() {
@@ skipping 123 matching lines @@
   }
   for (size_t i = 0; i < retransmittable_frames->frames().size(); ++i) {
     if (retransmittable_frames->frames()[i].type == CONNECTION_CLOSE_FRAME) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net