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>
@@ skipping 186 matching lines @@
                                uint32 max_flow_control_receive_window_bytes)
     : framer_(supported_versions, helper->GetClock()->ApproximateNow(),
               is_server),
       helper_(helper),
       writer_(writer),
       encryption_level_(ENCRYPTION_NONE),
       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),
       pending_version_negotiation_packet_(false),
       received_packet_manager_(kTCP, &stats_),
       ack_queued_(false),
       stop_waiting_count_(0),
       ack_alarm_(helper->CreateAlarm(new AckAlarm(this))),
@@ skipping 10 matching lines @@
       overall_connection_timeout_(QuicTime::Delta::Infinite()),
       time_of_last_received_packet_(clock_->ApproximateNow()),
       time_of_last_sent_new_packet_(clock_->ApproximateNow()),
       sequence_number_of_last_sent_packet_(0),
       sent_packet_manager_(
           is_server, clock_, &stats_, kTCP,
           FLAGS_quic_use_time_loss_detection ? kTime : kNack),
       version_negotiation_state_(START_NEGOTIATION),
       is_server_(is_server),
       connected_(true),
-      address_migrating_(false),
+      peer_ip_changed_(false),
+      peer_port_changed_(false),
+      self_ip_changed_(false),
+      self_port_changed_(false),
       max_flow_control_receive_window_bytes_(
           max_flow_control_receive_window_bytes) {
   if (max_flow_control_receive_window_bytes_ < kDefaultFlowControlSendWindow) {
     DLOG(ERROR) << "Initial receive window ("
                 << max_flow_control_receive_window_bytes_
                 << ") cannot be set lower than default ("
                 << kDefaultFlowControlSendWindow << ").";
     max_flow_control_receive_window_bytes_ = kDefaultFlowControlSendWindow;
   }
 
@@ skipping 850 matching lines @@
                                       const QuicEncryptedPacket& packet) {
   if (!connected_) {
     return;
   }
   if (debug_visitor_) {
     debug_visitor_->OnPacketReceived(self_address, peer_address, packet);
   }
   last_packet_revived_ = false;
   last_size_ = packet.length();
 
-  address_migrating_ = false;
-
-  if (peer_address_.address().empty()) {
-    peer_address_ = peer_address;
-  }
-  if (self_address_.address().empty()) {
-    self_address_ = self_address;
-  }
-
-  if (!(peer_address == peer_address_ && self_address == self_address_)) {
-    address_migrating_ = true;
-  }
+  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 (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;
   }
 
   ++stats_.packets_processed;
   MaybeProcessUndecryptablePackets();
   MaybeProcessRevivedPacket();
   MaybeSendInResponseToPacket();
   SetPingAlarm();
 }
 
+void QuicConnection::CheckForAddressMigration(
+    const IPEndPoint& self_address, const IPEndPoint& peer_address) {
+  peer_ip_changed_ = false;
+  peer_port_changed_ = false;
+  self_ip_changed_ = false;
+  self_port_changed_ = false;
+
+  if (peer_address_.address().empty()) {
+    peer_address_ = peer_address;
+  }
+  if (self_address_.address().empty()) {
+    self_address_ = self_address;
+  }
+
+  if (!peer_address.address().empty() && !peer_address_.address().empty()) {
+    peer_ip_changed_ = (peer_address.address() != peer_address_.address());
+    peer_port_changed_ = (peer_address.port() != peer_address_.port());
+
+    // Store in case we want to migrate connection in ProcessValidatedPacket.
+    migrating_peer_port_ = peer_address.port();
+  }
+
+  if (!self_address.address().empty() && !self_address_.address().empty()) {
+    self_ip_changed_ = (self_address.address() != self_address_.address());
+    self_port_changed_ = (self_address.port() != self_address_.port());
+  }
+}
+
 void QuicConnection::OnCanWrite() {
   DCHECK(!writer_->IsWriteBlocked());
 
   WriteQueuedPackets();
   WritePendingRetransmissions();
 
-  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.
-  if (!CanWrite(NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA,
-                pending_handshake)) {
+  if (!CanWrite(NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA)) {
     return;
   }
 
   {  // Limit the scope of the bundler.
     // Set |include_ack| to false in 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.
-  pending_handshake = visitor_->HasPendingHandshake() ?
-      IS_HANDSHAKE : NOT_HANDSHAKE;
   if (visitor_->HasPendingWrites() && !resume_writes_alarm_->IsSet() &&
-      CanWrite(NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA,
-               pending_handshake)) {
+      CanWrite(NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA)) {
     // We're not write blocked, but some stream didn't write out all of its
     // bytes. Register for 'immediate' resumption so we'll keep writing after
     // other connections and events have had a chance to use the thread.
     resume_writes_alarm_->Set(clock_->ApproximateNow());
   }
 }
 
 void QuicConnection::WriteIfNotBlocked() {
   if (!writer_->IsWriteBlocked()) {
     OnCanWrite();
   }
 }
 
 bool QuicConnection::ProcessValidatedPacket() {
-  if (address_migrating_) {
+  if ((!FLAGS_quic_allow_port_migration && peer_port_changed_) ||
+      peer_ip_changed_ || self_ip_changed_ || self_port_changed_) {
     SendConnectionCloseWithDetails(
         QUIC_ERROR_MIGRATING_ADDRESS,
-        "Address migration is not yet a supported feature");
+        "IP or port migration is not yet a supported feature");
     return false;
   }
+
+  // Port migration is supported, do it now if port has changed.
+  if (FLAGS_quic_allow_port_migration &&
+      peer_port_changed_) {
+    DVLOG(1) << ENDPOINT << "Peer's port changed from "
+             << peer_address_.port() << " to " << migrating_peer_port_
+             << ", migrating connection.";
+    peer_address_ = IPEndPoint(peer_address_.address(), migrating_peer_port_);
+  }
+
   time_of_last_received_packet_ = clock_->Now();
   DVLOG(1) << ENDPOINT << "time of last received packet: "
            << time_of_last_received_packet_.ToDebuggingValue();
 
   if (is_server_ && encryption_level_ == ENCRYPTION_NONE &&
       last_size_ > options()->max_packet_length) {
     options()->max_packet_length = last_size_;
   }
   return true;
 }
@@ skipping 19 matching lines @@
   }
 }
 
 void QuicConnection::WritePendingRetransmissions() {
   // Keep writing as long as there's a pending retransmission which can be
   // written.
   while (sent_packet_manager_.HasPendingRetransmissions()) {
     const QuicSentPacketManager::PendingRetransmission pending =
         sent_packet_manager_.NextPendingRetransmission();
     if (GetPacketType(&pending.retransmittable_frames) == NORMAL &&
-        !CanWrite(pending.transmission_type, HAS_RETRANSMITTABLE_DATA,
-                  pending.retransmittable_frames.HasCryptoHandshake())) {
+        !CanWrite(pending.transmission_type, HAS_RETRANSMITTABLE_DATA)) {
       break;
     }
 
     // Re-packetize the frames with a new sequence number for retransmission.
     // Retransmitted data packets do not use FEC, even when it's enabled.
     // Retransmitted packets use the same sequence number length as the
     // original.
     // Flush the packet creator before making a new packet.
     // TODO(ianswett): Implement ReserializeAllFrames as a separate path that
     // does not require the creator to be flushed.
@@ skipping 17 matching lines @@
   }
 }
 
 void QuicConnection::RetransmitUnackedPackets(
     RetransmissionType retransmission_type) {
   sent_packet_manager_.RetransmitUnackedPackets(retransmission_type);
 
   WriteIfNotBlocked();
 }
 
-void QuicConnection::DiscardUnencryptedPackets() {
-  sent_packet_manager_.DiscardUnencryptedPackets();
+void QuicConnection::NeuterUnencryptedPackets() {
+  sent_packet_manager_.NeuterUnencryptedPackets();
   // This may have changed the retransmission timer, so re-arm it.
   retransmission_alarm_->Cancel();
   QuicTime retransmission_time = sent_packet_manager_.GetRetransmissionTime();
   if (retransmission_time != QuicTime::Zero()) {
     retransmission_alarm_->Set(retransmission_time);
   }
 }
 
 bool QuicConnection::ShouldGeneratePacket(
     TransmissionType transmission_type,
     HasRetransmittableData retransmittable,
     IsHandshake handshake) {
   // We should serialize handshake packets immediately to ensure that they
   // end up sent at the right encryption level.
   if (handshake == IS_HANDSHAKE) {
     return true;
   }
 
-  return CanWrite(transmission_type, retransmittable, handshake);
+  return CanWrite(transmission_type, retransmittable);
 }
 
 bool QuicConnection::CanWrite(TransmissionType transmission_type,
-                              HasRetransmittableData retransmittable,
-                              IsHandshake handshake) {
+                              HasRetransmittableData retransmittable) {
   if (writer_->IsWriteBlocked()) {
     visitor_->OnWriteBlocked();
     return false;
   }
 
   // TODO(rch): consider removing this check so that if an ACK comes in
   // before the alarm goes it, we might be able send out a packet.
   // This check assumes that if the send alarm is set, it applies equally to all
   // types of transmissions.
   if (send_alarm_->IsSet()) {
@@ skipping 27 matching lines @@
     return true;
   }
 
   // If the packet is CONNECTION_CLOSE, we need to try to send it immediately
   // and encrypt it to hand it off to TimeWaitListManager.
   // If the packet is QUEUED, we don't re-consult the congestion control.
   // This ensures packets are sent in sequence number order.
   // TODO(ianswett): The congestion control should have been consulted before
   // serializing the packet, so this could be turned into a LOG_IF(DFATAL).
   if (packet.type == NORMAL && !CanWrite(packet.transmission_type,
-                                         packet.retransmittable,
-                                         packet.handshake)) {
+                                         packet.retransmittable)) {
     return false;
   }
 
   // Some encryption algorithms require the packet sequence numbers not be
   // repeated.
   DCHECK_LE(sequence_number_of_last_sent_packet_, sequence_number);
   sequence_number_of_last_sent_packet_ = sequence_number;
 
   QuicEncryptedPacket* encrypted = framer_.EncryptPacket(
       packet.encryption_level, sequence_number, *packet.packet);
@@ skipping 609 matching lines @@
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
   }
   DCHECK_EQ(already_in_batch_mode_,
             connection_->packet_generator_.InBatchMode());
 }
 
 }  // namespace net