Deprecates check_peer_address_change_after_decryption.

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 205 matching lines @@
       per_packet_options_(nullptr),
       writer_(writer),
       owns_writer_(owns_writer),
       encryption_level_(ENCRYPTION_NONE),
       has_forward_secure_encrypter_(false),
       first_required_forward_secure_packet_(0),
       clock_(helper->GetClock()),
       random_generator_(helper->GetRandomGenerator()),
       connection_id_(connection_id),
       peer_address_(address),
-      migrating_peer_port_(0),
       last_packet_decrypted_(false),
       last_size_(0),
       current_packet_data_(nullptr),
       last_decrypted_packet_level_(ENCRYPTION_NONE),
       should_last_packet_instigate_acks_(false),
       largest_seen_packet_with_ack_(0),
       largest_seen_packet_with_stop_waiting_(0),
       max_undecryptable_packets_(0),
       pending_version_negotiation_packet_(false),
       save_crypto_packets_as_termination_packets_(false),
@@ skipping 38 matching lines @@
           perspective,
           kDefaultPathId,
           clock_,
           &stats_,
           FLAGS_quic_use_bbr_congestion_control ? kBBR : kCubic,
           FLAGS_quic_use_time_loss_detection ? kTime : kNack,
           /*delegate=*/nullptr),
       version_negotiation_state_(START_NEGOTIATION),
       perspective_(perspective),
       connected_(true),
-      peer_ip_changed_(false),
-      peer_port_changed_(false),
-      self_ip_changed_(false),
-      self_port_changed_(false),
       can_truncate_connection_ids_(true),
       mtu_discovery_target_(0),
       mtu_probe_count_(0),
       packets_between_mtu_probes_(kPacketsBetweenMtuProbesBase),
       next_mtu_probe_at_(kPacketsBetweenMtuProbesBase),
       largest_received_packet_size_(0),
       goaway_sent_(false),
       goaway_received_(false),
       multipath_enabled_(false) {
   DVLOG(1) << ENDPOINT
@@ skipping 911 matching lines @@
                                       const QuicEncryptedPacket& packet) {
   if (!connected_) {
     return;
   }
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnPacketReceived(self_address, peer_address, packet);
   }
   last_size_ = packet.length();
   current_packet_data_ = packet.data();
 
-  if (FLAGS_check_peer_address_change_after_decryption) {
-    last_packet_destination_address_ = self_address;
-    last_packet_source_address_ = peer_address;
-    if (!IsInitializedIPEndPoint(self_address_)) {
-      self_address_ = last_packet_destination_address_;
-    }
-    if (!IsInitializedIPEndPoint(peer_address_)) {
-      peer_address_ = last_packet_source_address_;
-    }
-  } else {
-    CheckForAddressMigration(self_address, peer_address);
+  last_packet_destination_address_ = self_address;
+  last_packet_source_address_ = peer_address;
+  if (!IsInitializedIPEndPoint(self_address_)) {
+    self_address_ = last_packet_destination_address_;
+  }
+  if (!IsInitializedIPEndPoint(peer_address_)) {
+    peer_address_ = last_packet_source_address_;
   }
 
   stats_.bytes_received += packet.length();
   ++stats_.packets_received;
 
   ScopedRetransmissionScheduler alarm_delayer(this);
   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) {
@@ skipping 10 matching lines @@
     return;
   }
 
   ++stats_.packets_processed;
   MaybeProcessUndecryptablePackets();
   MaybeSendInResponseToPacket();
   SetPingAlarm();
   current_packet_data_ = nullptr;
 }
 
-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_ip_ = peer_address.address();
-    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();
 
   // 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.
@@ skipping 30 matching lines @@
     OnCanWrite();
   }
 }
 
 bool QuicConnection::ProcessValidatedPacket(const QuicPacketHeader& header) {
   if (header.fec_flag) {
     // Drop any FEC packet.
     return false;
   }
 
-  if (FLAGS_check_peer_address_change_after_decryption) {
-    if (perspective_ == Perspective::IS_SERVER &&
-        IsInitializedIPEndPoint(self_address_) &&
-        IsInitializedIPEndPoint(last_packet_destination_address_) &&
-        (!(self_address_ == last_packet_destination_address_))) {
-      SendConnectionCloseWithDetails(
-          QUIC_ERROR_MIGRATING_ADDRESS,
-          "Self address migration is not supported at the server.");
-      return false;
-    }
-  } else {
-    if (perspective_ == Perspective::IS_SERVER &&
-        (self_ip_changed_ || self_port_changed_)) {
-      SendConnectionCloseWithDetails(
-          QUIC_ERROR_MIGRATING_ADDRESS,
-          "Self address migration is not supported at the server.");
-      return false;
-    }
+  if (perspective_ == Perspective::IS_SERVER &&
+      IsInitializedIPEndPoint(self_address_) &&
+      IsInitializedIPEndPoint(last_packet_destination_address_) &&
+      (!(self_address_ == last_packet_destination_address_))) {
+    SendConnectionCloseWithDetails(
+        QUIC_ERROR_MIGRATING_ADDRESS,
+        "Self address migration is not supported at the server.");
+    return false;
   }
 
   if (!Near(header.packet_number, last_header_.packet_number)) {
     DVLOG(1) << ENDPOINT << "Packet " << header.packet_number
              << " out of bounds.  Discarding";
     SendConnectionCloseWithDetails(QUIC_INVALID_PACKET_HEADER,
                                    "packet number out of bounds");
     return false;
   }
 
@@ skipping 924 matching lines @@
   ++mtu_probe_count_;
 
   DVLOG(2) << "Sending a path MTU discovery packet #" << mtu_probe_count_;
   SendMtuDiscoveryPacket(mtu_discovery_target_);
 
   DCHECK(!mtu_discovery_alarm_->IsSet());
 }
 
 void QuicConnection::MaybeMigrateConnectionToNewPeerAddress() {
   IPEndPoint last_peer_address;
-  if (FLAGS_check_peer_address_change_after_decryption) {
-    last_peer_address = last_packet_source_address_;
-  } else {
-    last_peer_address = IPEndPoint(
-        peer_ip_changed_ ? migrating_peer_ip_ : peer_address_.address(),
-        peer_port_changed_ ? migrating_peer_port_ : peer_address_.port());
-  }
+  last_peer_address = last_packet_source_address_;
   PeerAddressChangeType peer_address_change_type =
       QuicUtils::DetermineAddressChangeType(peer_address_, last_peer_address);
   // TODO(fayang): Currently, all peer address change type are allowed. Need to
   // add a method ShouldAllowPeerAddressChange(PeerAddressChangeType type) to
-  // determine whehter |type| is allowed.
-  if (FLAGS_check_peer_address_change_after_decryption) {
-    if (peer_address_change_type == NO_CHANGE) {
-      return;
-    }
-
-    IPEndPoint old_peer_address = peer_address_;
-    peer_address_ = last_packet_source_address_;
-
-    DVLOG(1) << ENDPOINT << "Peer's ip:port changed from "
-             << old_peer_address.ToString() << " to "
-             << peer_address_.ToString() << ", migrating connection.";
-
-    visitor_->OnConnectionMigration(peer_address_change_type);
-    sent_packet_manager_.OnConnectionMigration(peer_address_change_type);
-
+  // determine whether |type| is allowed.
+  if (peer_address_change_type == NO_CHANGE) {
     return;
   }
 
-  if (peer_ip_changed_ || peer_port_changed_) {
-    IPEndPoint old_peer_address = peer_address_;
-    peer_address_ = IPEndPoint(
-        peer_ip_changed_ ? migrating_peer_ip_ : peer_address_.address(),
-        peer_port_changed_ ? migrating_peer_port_ : peer_address_.port());
+  IPEndPoint old_peer_address = peer_address_;
+  peer_address_ = last_packet_source_address_;
 
-    DVLOG(1) << ENDPOINT << "Peer's ip:port changed from "
-             << old_peer_address.ToString() << " to "
-             << peer_address_.ToString() << ", migrating connection.";
+  DVLOG(1) << ENDPOINT << "Peer's ip:port changed from "
+           << old_peer_address.ToString() << " to " << peer_address_.ToString()
+           << ", migrating connection.";
 
-    visitor_->OnConnectionMigration(peer_address_change_type);
-    DCHECK_NE(peer_address_change_type, NO_CHANGE);
-    sent_packet_manager_.OnConnectionMigration(peer_address_change_type);
-  }
+  visitor_->OnConnectionMigration(peer_address_change_type);
+  sent_packet_manager_.OnConnectionMigration(peer_address_change_type);
 }
 
 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();
 }
 
 StringPiece QuicConnection::GetCurrentPacket() {
   if (current_packet_data_ == nullptr) {
     return StringPiece();
   }
   return StringPiece(current_packet_data_, last_size_);
 }
 
 }  // namespace net