Landing Recent QUIC changes until 01/31/2016 05:22 UTC

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>
@@ skipping 286 matching lines @@
       visitor_(nullptr),
       debug_visitor_(nullptr),
       packet_generator_(connection_id_,
                         &framer_,
                         random_generator_,
                         helper->GetBufferAllocator(),
                         this),
       fec_alarm_(helper->CreateAlarm(arena_.New<FecAlarm>(&packet_generator_),
                                      &arena_)),
       idle_network_timeout_(QuicTime::Delta::Infinite()),
-      overall_connection_timeout_(QuicTime::Delta::Infinite()),
+      handshake_timeout_(QuicTime::Delta::Infinite()),
       time_of_last_received_packet_(clock_->ApproximateNow()),
       time_of_last_sent_new_packet_(clock_->ApproximateNow()),
       last_send_for_timeout_(clock_->ApproximateNow()),
       packet_number_of_last_sent_packet_(0),
       sent_packet_manager_(
           perspective,
           kDefaultPathId,
           clock_,
           &stats_,
           FLAGS_quic_use_bbr_congestion_control ? kBBR : kCubic,
@@ skipping 37 matching lines @@
   if (termination_packets_.get() != nullptr) {
     STLDeleteElements(termination_packets_.get());
   }
   STLDeleteValues(&group_map_);
   ClearQueuedPackets();
 }
 
 void QuicConnection::ClearQueuedPackets() {
   for (QueuedPacketList::iterator it = queued_packets_.begin();
        it != queued_packets_.end(); ++it) {
+    // Delete the buffer before calling ClearSerializedPacket, which sets
+    // encrypted_buffer to nullptr.
+    delete[] it->encrypted_buffer;
     QuicUtils::ClearSerializedPacket(&(*it));
   }
   queued_packets_.clear();
 }
 
 void QuicConnection::SetFromConfig(const QuicConfig& config) {
   if (config.negotiated()) {
+    // Handshake complete, set handshake timeout to Infinite.
     SetNetworkTimeouts(QuicTime::Delta::Infinite(),
                        config.IdleConnectionStateLifetime());
     if (config.SilentClose()) {
       silent_close_enabled_ = true;
     }
     if (FLAGS_quic_enable_multipath && config.MultipathEnabled()) {
       multipath_enabled_ = true;
     }
   } else {
     SetNetworkTimeouts(config.max_time_before_crypto_handshake(),
@@ skipping 817 matching lines @@
         &packet_iterator->retransmittable_frames;
     if (retransmittable_frames->empty()) {
       ++packet_iterator;
       continue;
     }
     QuicUtils::RemoveFramesForStream(retransmittable_frames, id);
     if (!retransmittable_frames->empty()) {
       ++packet_iterator;
       continue;
     }
+    delete[] packet_iterator->encrypted_buffer;
     QuicUtils::ClearSerializedPacket(&(*packet_iterator));
     packet_iterator = queued_packets_.erase(packet_iterator);
   }
 }
 
 void QuicConnection::SendWindowUpdate(QuicStreamId id,
                                       QuicStreamOffset byte_offset) {
   // Opportunistically bundle an ack with this outgoing packet.
   ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
   packet_generator_.AddControlFrame(
@@ skipping 244 matching lines @@
 void QuicConnection::WriteQueuedPackets() {
   DCHECK(!writer_->IsWriteBlocked());
 
   if (pending_version_negotiation_packet_) {
     SendVersionNegotiationPacket();
   }
 
   QueuedPacketList::iterator packet_iterator = queued_packets_.begin();
   while (packet_iterator != queued_packets_.end() &&
          WritePacket(&(*packet_iterator))) {
+    delete[] packet_iterator->encrypted_buffer;
+    QuicUtils::ClearSerializedPacket(&(*packet_iterator));
     packet_iterator = queued_packets_.erase(packet_iterator);
   }
 }
 
 void QuicConnection::WritePendingRetransmissions() {
   // Keep writing as long as there's a pending retransmission which can be
   // written.
   while (sent_packet_manager_.HasPendingRetransmissions()) {
     const PendingRetransmission pending =
         sent_packet_manager_.NextPendingRetransmission();
     if (!CanWrite(HAS_RETRANSMITTABLE_DATA)) {
       break;
     }
 
     // Re-packetize the frames with a new packet number for retransmission.
     // Retransmitted data packets do not use FEC, even when it's enabled.
     // Retransmitted packets use the same packet number length as the
     // original.
     // Flush the packet generator before making a new packet.
     // TODO(ianswett): Implement ReserializeAllFrames as a separate path that
     // does not require the creator to be flushed.
     packet_generator_.FlushAllQueuedFrames();
     char buffer[kMaxPacketSize];
     SerializedPacket serialized_packet =
         packet_generator_.ReserializeAllFrames(pending, buffer, kMaxPacketSize);
     if (FLAGS_quic_retransmit_via_onserializedpacket) {
-      DCHECK(serialized_packet.packet == nullptr);
+      DCHECK(serialized_packet.encrypted_buffer == nullptr);
       continue;
     }
-    if (serialized_packet.packet == nullptr) {
+    if (serialized_packet.encrypted_buffer == nullptr) {
       // We failed to serialize the packet, so close the connection.
       // CloseConnection does not send close packet, so no infinite loop here.
       // TODO(ianswett): This is actually an internal error, not an encryption
       // failure.
       CloseConnection(QUIC_ENCRYPTION_FAILURE, false);
       return;
     }
 
     DVLOG(1) << ENDPOINT << "Retransmitting " << pending.packet_number << " as "
              << serialized_packet.packet_number;
@@ skipping 66 matching lines @@
              << "ms";
     return false;
   }
   if (!FLAGS_quic_respect_send_alarm2) {
     send_alarm_->Cancel();
   }
   return true;
 }
 
 bool QuicConnection::WritePacket(SerializedPacket* packet) {
-  if (!WritePacketInner(packet)) {
-    return false;
-  }
-  QuicUtils::ClearSerializedPacket(packet);
-  return true;
-}
-
-bool QuicConnection::WritePacketInner(SerializedPacket* packet) {
   if (packet->packet_number < sent_packet_manager_.largest_sent_packet()) {
     QUIC_BUG << "Attempt to write packet:" << packet->packet_number
              << " after:" << sent_packet_manager_.largest_sent_packet();
     SendConnectionCloseWithDetails(QUIC_INTERNAL_ERROR,
                                    "Packet written out of order.");
     return true;
   }
   if (ShouldDiscardPacket(*packet)) {
     ++stats_.packets_discarded;
     return true;
   }
   // Termination packets are encrypted and saved, so don't exit early.
   const bool is_termination_packet = IsTerminationPacket(*packet);
   if (writer_->IsWriteBlocked() && !is_termination_packet) {
     return false;
   }
 
   QuicPacketNumber packet_number = packet->packet_number;
   DCHECK_LE(packet_number_of_last_sent_packet_, packet_number);
   packet_number_of_last_sent_packet_ = packet_number;
 
-  QuicEncryptedPacket* encrypted = packet->packet;
+  QuicPacketLength encrypted_length = packet->encrypted_length;
   // Termination packets are eventually owned by TimeWaitListManager.
   // Others are deleted at the end of this call.
   if (is_termination_packet) {
     if (termination_packets_.get() == nullptr) {
       termination_packets_.reset(new std::vector<QuicEncryptedPacket*>);
     }
-    // Clone the packet so it's owned in the future.
-    termination_packets_->push_back(encrypted->Clone());
+    // Copy the buffer so it's owned in the future.
+    char* buffer_copy = QuicUtils::CopyBuffer(*packet);
+    termination_packets_->push_back(
+        new QuicEncryptedPacket(buffer_copy, encrypted_length, true));
     // This assures we won't try to write *forced* packets when blocked.
     // Return true to stop processing.
     if (writer_->IsWriteBlocked()) {
       visitor_->OnWriteBlocked();
       return true;
     }
   }
 
-  DCHECK_LE(encrypted->length(), kMaxPacketSize);
-  DCHECK_LE(encrypted->length(), packet_generator_.GetMaxPacketLength());
+  DCHECK_LE(encrypted_length, kMaxPacketSize);
+  DCHECK_LE(encrypted_length, packet_generator_.GetMaxPacketLength());
   DVLOG(1) << ENDPOINT << "Sending packet " << packet_number << " : "
            << (packet->is_fec_packet
                    ? "FEC "
                    : (IsRetransmittable(*packet) == HAS_RETRANSMITTABLE_DATA
                           ? "data bearing "
                           : " ack only "))
            << ", encryption level: "
            << QuicUtils::EncryptionLevelToString(packet->encryption_level)
-           << ", encrypted length:" << encrypted->length();
+           << ", encrypted length:" << encrypted_length;
   DVLOG(2) << ENDPOINT << "packet(" << packet_number << "): " << std::endl
-           << QuicUtils::StringToHexASCIIDump(encrypted->AsStringPiece());
+           << QuicUtils::StringToHexASCIIDump(
+                  StringPiece(packet->encrypted_buffer, encrypted_length));
 
   // Measure the RTT from before the write begins to avoid underestimating the
   // min_rtt_, especially in cases where the thread blocks or gets swapped out
   // during the WritePacket below.
   QuicTime packet_send_time = clock_->Now();
   WriteResult result = writer_->WritePacket(
-      encrypted->data(), encrypted->length(), self_address().address().bytes(),
-      peer_address(), per_packet_options_);
+      packet->encrypted_buffer, encrypted_length,
+      self_address().address().bytes(), peer_address(), per_packet_options_);
   if (result.error_code == ERR_IO_PENDING) {
     DCHECK_EQ(WRITE_STATUS_BLOCKED, result.status);
   }
 
   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;
     }
   }
   if (result.status != WRITE_STATUS_ERROR && debug_visitor_ != nullptr) {
     // Pass the write result to the visitor.
     debug_visitor_->OnPacketSent(*packet, packet->original_packet_number,
-                                 packet->transmission_type, encrypted->length(),
+                                 packet->transmission_type, encrypted_length,
                                  packet_send_time);
   }
   if (packet->transmission_type == NOT_RETRANSMISSION) {
     time_of_last_sent_new_packet_ = packet_send_time;
     if (IsRetransmittable(*packet) == HAS_RETRANSMITTABLE_DATA &&
         last_send_for_timeout_ <= time_of_last_received_packet_) {
       last_send_for_timeout_ = packet_send_time;
     }
   }
   SetPingAlarm();
   MaybeSetFecAlarm(packet_number);
   MaybeSetMtuAlarm();
   DVLOG(1) << ENDPOINT << "time we began writing last sent packet: "
            << packet_send_time.ToDebuggingValue();
 
   // TODO(ianswett): Change the packet number length and other packet creator
   // options by a more explicit API than setting a struct value directly,
   // perhaps via the NetworkChangeVisitor.
   packet_generator_.UpdateSequenceNumberLength(
       sent_packet_manager_.least_packet_awaited_by_peer(),
       sent_packet_manager_.EstimateMaxPacketsInFlight(max_packet_length()));
 
   bool reset_retransmission_alarm = sent_packet_manager_.OnPacketSent(
       packet, packet->original_packet_number, packet_send_time,
-      encrypted->length(), packet->transmission_type,
-      IsRetransmittable(*packet));
+      encrypted_length, packet->transmission_type, IsRetransmittable(*packet));
 
   if (reset_retransmission_alarm || !retransmission_alarm_->IsSet()) {
     SetRetransmissionAlarm();
   }
 
   stats_.bytes_sent += result.bytes_written;
   ++stats_.packets_sent;
   if (packet->transmission_type != NOT_RETRANSMISSION) {
     stats_.bytes_retransmitted += result.bytes_written;
     ++stats_.packets_retransmitted;
   }
 
   if (result.status == WRITE_STATUS_ERROR) {
     OnWriteError(result.error_code);
-    DLOG(ERROR) << ENDPOINT << "failed writing " << encrypted->length()
+    DLOG(ERROR) << ENDPOINT << "failed writing " << encrypted_length
                 << " bytes "
                 << " from host " << (self_address().address().empty()
                                          ? " empty address "
                                          : self_address().ToStringWithoutPort())
                 << " to address " << peer_address().ToString();
     return false;
   }
 
   return true;
 }
@@ skipping 30 matching lines @@
 
 void QuicConnection::OnWriteError(int error_code) {
   DVLOG(1) << ENDPOINT << "Write failed with error: " << error_code << " ("
            << ErrorToString(error_code) << ")";
   // We can't send an error as the socket is presumably borked.
   CloseConnection(QUIC_PACKET_WRITE_ERROR, false);
 }
 
 void QuicConnection::OnSerializedPacket(SerializedPacket* serialized_packet) {
   DCHECK_NE(kInvalidPathId, serialized_packet->path_id);
-  if (serialized_packet->packet == nullptr) {
+  if (serialized_packet->encrypted_buffer == nullptr) {
     // We failed to serialize the packet, so close the connection.
     // CloseConnection does not send close packet, so no infinite loop here.
     // TODO(ianswett): This is actually an internal error, not an encryption
     // failure.
     CloseConnection(QUIC_ENCRYPTION_FAILURE, false);
     return;
   }
   if (serialized_packet->is_fec_packet && fec_alarm_->IsSet()) {
     // If an FEC packet is serialized with the FEC alarm set, cancel the alarm.
     fec_alarm_->Cancel();
@@ skipping 33 matching lines @@
   // complete with the server.
   if (perspective_ == Perspective::IS_CLIENT && !ack_queued_ &&
       ack_frame_updated()) {
     ack_alarm_->Cancel();
     ack_alarm_->Set(clock_->ApproximateNow());
   }
 }
 
 void QuicConnection::SendOrQueuePacket(SerializedPacket* packet) {
   // The caller of this function is responsible for checking CanWrite().
-  if (packet->packet == nullptr) {
-    QUIC_BUG << "packet.packet == nullptr in to SendOrQueuePacket";
+  if (packet->encrypted_buffer == nullptr) {
+    QUIC_BUG << "packet.encrypted_buffer == nullptr in to SendOrQueuePacket";
     return;
   }
 
   sent_entropy_manager_.RecordPacketEntropyHash(packet->packet_number,
                                                 packet->entropy_hash);
   // If there are already queued packets, queue this one immediately to ensure
   // it's written in sequence number order.
   if (!queued_packets_.empty() || !WritePacket(packet)) {
     // Take ownership of the underlying encrypted packet.
-    if (!packet->packet->owns_buffer()) {
-      scoped_ptr<QuicEncryptedPacket> encrypted_deleter(packet->packet);
-      packet->packet = packet->packet->Clone();
-    }
+    packet->encrypted_buffer = QuicUtils::CopyBuffer(*packet);
     queued_packets_.push_back(*packet);
     packet->retransmittable_frames.clear();
   }
 
+  QuicUtils::ClearSerializedPacket(packet);
   // If a forward-secure encrypter is available but is not being used and the
   // next packet number is the first packet which requires
   // forward security, start using the forward-secure encrypter.
   if (encryption_level_ != ENCRYPTION_FORWARD_SECURE &&
       has_forward_secure_encrypter_ &&
       packet->packet_number >= first_required_forward_secure_packet_ - 1) {
     SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
   }
 }
 
@@ skipping 200 matching lines @@
   // serialized packet.
   SendConnectionClosePacket(error, details);
   CloseConnection(error, false);
 }
 
 void QuicConnection::SendConnectionClosePacket(QuicErrorCode error,
                                                const string& details) {
   DVLOG(1) << ENDPOINT << "Force closing " << connection_id() << " with error "
            << QuicUtils::ErrorToString(error) << " (" << error << ") "
            << details;
-  // Don't send explicit connection close packets for timeouts.
-  // This is particularly important on mobile, where connections are short.
-  if (silent_close_enabled_ &&
-      error == QuicErrorCode::QUIC_CONNECTION_TIMED_OUT) {
-    return;
-  }
   ClearQueuedPackets();
   ScopedPacketBundler ack_bundler(this, SEND_ACK);
   QuicConnectionCloseFrame* frame = new QuicConnectionCloseFrame();
   frame->error_code = error;
   frame->error_details = details;
   packet_generator_.AddControlFrame(QuicFrame(frame));
   packet_generator_.FlushAllQueuedFrames();
 }
 
 void QuicConnection::CloseConnection(QuicErrorCode error, bool from_peer) {
@@ skipping 90 matching lines @@
 
   IsHandshake pending_handshake =
       visitor_->HasPendingHandshake() ? IS_HANDSHAKE : NOT_HANDSHAKE;
   // 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.
   return ShouldGeneratePacket(HAS_RETRANSMITTABLE_DATA, pending_handshake);
 }
 
-void QuicConnection::SetNetworkTimeouts(QuicTime::Delta overall_timeout,
+void QuicConnection::SetNetworkTimeouts(QuicTime::Delta handshake_timeout,
                                         QuicTime::Delta idle_timeout) {
-  QUIC_BUG_IF(idle_timeout > overall_timeout)
+  QUIC_BUG_IF(idle_timeout > handshake_timeout)
       << "idle_timeout:" << idle_timeout.ToMilliseconds()
-      << " overall_timeout:" << overall_timeout.ToMilliseconds();
+      << " handshake_timeout:" << handshake_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 (perspective_ == Perspective::IS_SERVER) {
     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;
+  handshake_timeout_ = handshake_timeout;
   idle_network_timeout_ = idle_timeout;
 
   SetTimeoutAlarm();
 }
 
 void QuicConnection::CheckForTimeout() {
   QuicTime now = clock_->ApproximateNow();
   QuicTime time_of_last_packet = QuicTime::Zero();
   if (!FLAGS_quic_use_new_idle_timeout) {
     time_of_last_packet =
         max(time_of_last_received_packet_, time_of_last_sent_new_packet_);
   } else {
     time_of_last_packet =
         max(time_of_last_received_packet_, last_send_for_timeout_);
   }
 
   // |delta| can be < 0 as |now| is approximate time but |time_of_last_packet|
   // is accurate time. However, this should not change the behavior of
   // timeout handling.
   QuicTime::Delta idle_duration = now.Subtract(time_of_last_packet);
   DVLOG(1) << ENDPOINT << "last packet "
            << time_of_last_packet.ToDebuggingValue()
            << " now:" << now.ToDebuggingValue()
            << " idle_duration:" << idle_duration.ToMicroseconds()
            << " idle_network_timeout: "
            << idle_network_timeout_.ToMicroseconds();
   if (idle_duration >= idle_network_timeout_) {
     DVLOG(1) << ENDPOINT << "Connection timedout due to no network activity.";
-    SendConnectionCloseWithDetails(QUIC_CONNECTION_TIMED_OUT,
-                                   "No recent network activity");
+    if (silent_close_enabled_) {
+      // Just clean up local state, don't send a connection close packet.
+      CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT, /*from_peer=*/false);
+    } else {
+      SendConnectionCloseWithDetails(QUIC_NETWORK_IDLE_TIMEOUT,
+                                     "No recent network activity");
+    }
     return;
   }
 
-  if (!overall_connection_timeout_.IsInfinite()) {
+  if (!handshake_timeout_.IsInfinite()) {
     QuicTime::Delta connected_duration =
         now.Subtract(stats_.connection_creation_time);
     DVLOG(1) << ENDPOINT
              << "connection time: " << connected_duration.ToMicroseconds()
-             << " overall timeout: "
-             << overall_connection_timeout_.ToMicroseconds();
-    if (connected_duration >= overall_connection_timeout_) {
-      DVLOG(1) << ENDPOINT
-               << "Connection timedout due to overall connection timeout.";
-      SendConnectionCloseWithDetails(QUIC_CONNECTION_OVERALL_TIMED_OUT,
-                                     "Overall timeout expired");
+             << " handshake timeout: " << handshake_timeout_.ToMicroseconds();
+    if (connected_duration >= handshake_timeout_) {
+      DVLOG(1) << ENDPOINT << "Connection timedout due to handshake timeout.";
+      SendConnectionCloseWithDetails(QUIC_HANDSHAKE_TIMEOUT,
+                                     "Handshake timeout expired");
       return;
     }
   }
 
   SetTimeoutAlarm();
 }
 
 void QuicConnection::SetTimeoutAlarm() {
   QuicTime time_of_last_packet =
       max(time_of_last_received_packet_, time_of_last_sent_new_packet_);
 
   QuicTime deadline = time_of_last_packet.Add(idle_network_timeout_);
-  if (!overall_connection_timeout_.IsInfinite()) {
+  if (!handshake_timeout_.IsInfinite()) {
     deadline =
-        min(deadline,
-            stats_.connection_creation_time.Add(overall_connection_timeout_));
+        min(deadline, stats_.connection_creation_time.Add(handshake_timeout_));
   }
 
   timeout_alarm_->Cancel();
   timeout_alarm_->Set(deadline);
 }
 
 void QuicConnection::SetPingAlarm() {
   if (perspective_ == Perspective::IS_SERVER) {
     // Only clients send pings.
     return;
@@ skipping 278 matching lines @@
 void QuicConnection::OnPathClosed(QuicPathId path_id) {
   // Stop receiving packets on this path.
   framer_.OnPathClosed(path_id);
 }
 
 bool QuicConnection::ack_frame_updated() const {
   return received_packet_manager_.ack_frame_updated();
 }
 
 }  // namespace net