Implements migration of a QUIC connection to a different destination address if specified by the se…

net/quic/quic_stream_factory.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_stream_factory.h"
 
 #include <openssl/aead.h>
 
 #include <algorithm>
 #include <tuple>
@@ skipping 614 matching lines @@
     int threshold_public_resets_post_handshake,
     int threshold_timeouts_with_open_streams,
     int socket_receive_buffer_size,
     bool delay_tcp_race,
     int max_server_configs_stored_in_properties,
     bool close_sessions_on_ip_change,
     bool disable_quic_on_timeout_with_open_streams,
     int idle_connection_timeout_seconds,
     bool migrate_sessions_on_network_change,
     bool migrate_sessions_early,
+    bool allow_server_migration,
     bool force_hol_blocking,
     const QuicTagVector& connection_options,
     bool enable_token_binding)
     : require_confirmation_(true),
       net_log_(net_log),
       host_resolver_(host_resolver),
       client_socket_factory_(client_socket_factory),
       http_server_properties_(http_server_properties),
       transport_security_state_(transport_security_state),
       cert_transparency_verifier_(cert_transparency_verifier),
@@ skipping 34 matching lines @@
       delay_tcp_race_(delay_tcp_race),
       yield_after_packets_(kQuicYieldAfterPacketsRead),
       yield_after_duration_(QuicTime::Delta::FromMilliseconds(
           kQuicYieldAfterDurationMilliseconds)),
       close_sessions_on_ip_change_(close_sessions_on_ip_change),
       migrate_sessions_on_network_change_(
           migrate_sessions_on_network_change &&
           NetworkChangeNotifier::AreNetworkHandlesSupported()),
       migrate_sessions_early_(migrate_sessions_early &&
                               migrate_sessions_on_network_change_),
+      allow_server_migration_(allow_server_migration),
       force_hol_blocking_(force_hol_blocking),
       port_seed_(random_generator_->RandUint64()),
       check_persisted_supports_quic_(true),
       has_initialized_data_(false),
       num_push_streams_created_(0),
       status_(OPEN),
       task_runner_(nullptr),
       ssl_config_service_(ssl_config_service),
       weak_factory_(this) {
   if (ssl_config_service_.get())
@@ skipping 739 matching lines @@
           session->connection_id(), "Non-migratable stream");
       if (force_close) {
         // Close sessions with non-migratable streams.
         session->CloseSessionOnError(
             ERR_NETWORK_CHANGED,
             QUIC_CONNECTION_MIGRATION_NON_MIGRATABLE_STREAM);
       }
       continue;
     }
 
-    MigrateSessionToNetwork(session, new_network, bound_net_log, nullptr);
+    MigrateSessionToNewNetwork(session, new_network, bound_net_log, nullptr);
   }
 }
 
 void QuicStreamFactory::MaybeMigrateSingleSession(
     QuicChromiumClientSession* session,
     MigrationCause migration_cause,
     scoped_refptr<StringIOBuffer> packet) {
   ScopedConnectionMigrationEventLog scoped_event_log(
       net_log_,
       migration_cause == EARLY_MIGRATION ? "EarlyMigration" : "WriteError");
@@ skipping 11 matching lines @@
   if (new_network == NetworkChangeNotifier::kInvalidNetworkHandle) {
     // No alternate network found.
     // TODO (jri): Add histogram for this failure case.
     scoped_event_log.net_log().AddEvent(
         NetLog::TYPE_QUIC_CONNECTION_MIGRATION_FAILURE,
         base::Bind(&NetLogQuicConnectionMigrationFailureCallback,
                    session->connection_id(), "No new network"));
     return;
   }
   OnSessionGoingAway(session);
-  MigrateSessionToNetwork(session, new_network, scoped_event_log.net_log(),
-                          packet);
+  MigrateSessionToNewNetwork(session, new_network, scoped_event_log.net_log(),
+                             packet);
 }
 
-void QuicStreamFactory::MigrateSessionToNetwork(
+void QuicStreamFactory::MigrateSessionToNewPeerAddress(
     QuicChromiumClientSession* session,
-    NetworkHandle new_network,
+    IPEndPoint peer_address,
+    const BoundNetLog& bound_net_log) {
+  if (!allow_server_migration_)
+    return;
+  // Specifying kInvalidNetworkHandle for the |network| parameter
+  // causes the session to use the default network for the new socket.
+  MigrateSession(session, peer_address,
+                 NetworkChangeNotifier::kInvalidNetworkHandle, bound_net_log,
+                 nullptr);
+}
+
+void QuicStreamFactory::MigrateSessionToNewNetwork(
+    QuicChromiumClientSession* session,
+    NetworkHandle network,
     const BoundNetLog& bound_net_log,
     scoped_refptr<StringIOBuffer> packet) {
+  MigrateSession(session, session->connection()->peer_address(), network,
+                 bound_net_log, packet);
+}
+
+void QuicStreamFactory::MigrateSession(QuicChromiumClientSession* session,
+                                       IPEndPoint peer_address,
+                                       NetworkHandle network,
+                                       const BoundNetLog& bound_net_log,
+                                       scoped_refptr<StringIOBuffer> packet) {
   // Use OS-specified port for socket (DEFAULT_BIND) instead of
   // using the PortSuggester since the connection is being migrated
   // and not being newly created.
   std::unique_ptr<DatagramClientSocket> socket(
       client_socket_factory_->CreateDatagramClientSocket(
           DatagramSocket::DEFAULT_BIND, RandIntCallback(),
           session->net_log().net_log(), session->net_log().source()));
-  QuicConnection* connection = session->connection();
-  if (ConfigureSocket(socket.get(), connection->peer_address(), new_network) !=
-      OK) {
+  if (ConfigureSocket(socket.get(), peer_address, network) != OK) {
     session->CloseSessionOnError(ERR_NETWORK_CHANGED, QUIC_INTERNAL_ERROR);
     HistogramAndLogMigrationFailure(
         bound_net_log, MIGRATION_STATUS_INTERNAL_ERROR,
         session->connection_id(), "Socket configuration failed");
     return;
   }
   std::unique_ptr<QuicChromiumPacketReader> new_reader(
       new QuicChromiumPacketReader(socket.get(), clock_.get(), session,
                                    yield_after_packets_, yield_after_duration_,
                                    session->net_log()));
@@ skipping 372 matching lines @@
   // Since the session was active, there's no longer an
   // HttpStreamFactoryImpl::Job running which can mark it broken, unless the TCP
   // job also fails. So to avoid not using QUIC when we otherwise could, we mark
   // it as recently broken, which means that 0-RTT will be disabled but we'll
   // still race.
   http_server_properties_->MarkAlternativeServiceRecentlyBroken(
       alternative_service);
 }
 
 }  // namespace net