Add 2 new classes QuicConnectionMigrationManager and QuicSpdyClientSessionWithMigration which are extracted from Chromium [QuicChromiumClientSession](https://source.chromium.org/chromium/chromium/src/+/main:net/quic/quic_chromium_client_session.h) to handle network disconnected signal from the platform by migrating to an alternative network if available. Note that identifying the platform picked default network and migrating back to default network after the above migration will be implemented as a follow up. Added a factory interface QuicPathContextFactory for QuicPathValidationContext. This is part of the chain CLs to fork Chromium's connection migration code extracted in https://chromium-review.googlesource.com/c/chromium/src/+/5980615 which is verified to work for Chromium. PiperOrigin-RevId: 794210361
diff --git a/build/source_list.bzl b/build/source_list.bzl index 1f5dec0..598d2b5 100644 --- a/build/source_list.bzl +++ b/build/source_list.bzl
@@ -255,6 +255,7 @@ "quic/core/http/http_encoder.h", "quic/core/http/http_frames.h", "quic/core/http/metadata_decoder.h", + "quic/core/http/quic_connection_migration_manager.h", "quic/core/http/quic_header_list.h", "quic/core/http/quic_headers_stream.h", "quic/core/http/quic_receive_control_stream.h", @@ -263,6 +264,7 @@ "quic/core/http/quic_server_session_base.h", "quic/core/http/quic_spdy_client_session.h", "quic/core/http/quic_spdy_client_session_base.h", + "quic/core/http/quic_spdy_client_session_with_migration.h", "quic/core/http/quic_spdy_client_stream.h", "quic/core/http/quic_spdy_server_stream_base.h", "quic/core/http/quic_spdy_session.h", @@ -333,6 +335,7 @@ "quic/core/quic_dispatcher_stats.h", "quic/core/quic_error_codes.h", "quic/core/quic_flow_controller.h", + "quic/core/quic_force_blockable_packet_writer.h", "quic/core/quic_framer.h", "quic/core/quic_generic_session.h", "quic/core/quic_idle_network_detector.h", @@ -349,6 +352,7 @@ "quic/core/quic_packet_writer.h", "quic/core/quic_packet_writer_wrapper.h", "quic/core/quic_packets.h", + "quic/core/quic_path_context_factory.h", "quic/core/quic_path_validator.h", "quic/core/quic_ping_manager.h", "quic/core/quic_process_packet_interface.h", @@ -600,6 +604,7 @@ "quic/core/http/http_decoder.cc", "quic/core/http/http_encoder.cc", "quic/core/http/metadata_decoder.cc", + "quic/core/http/quic_connection_migration_manager.cc", "quic/core/http/quic_header_list.cc", "quic/core/http/quic_headers_stream.cc", "quic/core/http/quic_receive_control_stream.cc", @@ -608,6 +613,7 @@ "quic/core/http/quic_server_session_base.cc", "quic/core/http/quic_spdy_client_session.cc", "quic/core/http/quic_spdy_client_session_base.cc", + "quic/core/http/quic_spdy_client_session_with_migration.cc", "quic/core/http/quic_spdy_client_stream.cc", "quic/core/http/quic_spdy_server_stream_base.cc", "quic/core/http/quic_spdy_session.cc", @@ -1260,6 +1266,7 @@ "quic/core/http/http_encoder_test.cc", "quic/core/http/http_frames_test.cc", "quic/core/http/metadata_decoder_test.cc", + "quic/core/http/quic_connection_migration_manager_test.cc", "quic/core/http/quic_header_list_test.cc", "quic/core/http/quic_headers_stream_test.cc", "quic/core/http/quic_receive_control_stream_test.cc",
diff --git a/build/source_list.gni b/build/source_list.gni index 2e0abf3..88d7559 100644 --- a/build/source_list.gni +++ b/build/source_list.gni
@@ -255,6 +255,7 @@ "src/quiche/quic/core/http/http_encoder.h", "src/quiche/quic/core/http/http_frames.h", "src/quiche/quic/core/http/metadata_decoder.h", + "src/quiche/quic/core/http/quic_connection_migration_manager.h", "src/quiche/quic/core/http/quic_header_list.h", "src/quiche/quic/core/http/quic_headers_stream.h", "src/quiche/quic/core/http/quic_receive_control_stream.h", @@ -263,6 +264,7 @@ "src/quiche/quic/core/http/quic_server_session_base.h", "src/quiche/quic/core/http/quic_spdy_client_session.h", "src/quiche/quic/core/http/quic_spdy_client_session_base.h", + "src/quiche/quic/core/http/quic_spdy_client_session_with_migration.h", "src/quiche/quic/core/http/quic_spdy_client_stream.h", "src/quiche/quic/core/http/quic_spdy_server_stream_base.h", "src/quiche/quic/core/http/quic_spdy_session.h", @@ -333,6 +335,7 @@ "src/quiche/quic/core/quic_dispatcher_stats.h", "src/quiche/quic/core/quic_error_codes.h", "src/quiche/quic/core/quic_flow_controller.h", + "src/quiche/quic/core/quic_force_blockable_packet_writer.h", "src/quiche/quic/core/quic_framer.h", "src/quiche/quic/core/quic_generic_session.h", "src/quiche/quic/core/quic_idle_network_detector.h", @@ -349,6 +352,7 @@ "src/quiche/quic/core/quic_packet_writer.h", "src/quiche/quic/core/quic_packet_writer_wrapper.h", "src/quiche/quic/core/quic_packets.h", + "src/quiche/quic/core/quic_path_context_factory.h", "src/quiche/quic/core/quic_path_validator.h", "src/quiche/quic/core/quic_ping_manager.h", "src/quiche/quic/core/quic_process_packet_interface.h", @@ -600,6 +604,7 @@ "src/quiche/quic/core/http/http_decoder.cc", "src/quiche/quic/core/http/http_encoder.cc", "src/quiche/quic/core/http/metadata_decoder.cc", + "src/quiche/quic/core/http/quic_connection_migration_manager.cc", "src/quiche/quic/core/http/quic_header_list.cc", "src/quiche/quic/core/http/quic_headers_stream.cc", "src/quiche/quic/core/http/quic_receive_control_stream.cc", @@ -608,6 +613,7 @@ "src/quiche/quic/core/http/quic_server_session_base.cc", "src/quiche/quic/core/http/quic_spdy_client_session.cc", "src/quiche/quic/core/http/quic_spdy_client_session_base.cc", + "src/quiche/quic/core/http/quic_spdy_client_session_with_migration.cc", "src/quiche/quic/core/http/quic_spdy_client_stream.cc", "src/quiche/quic/core/http/quic_spdy_server_stream_base.cc", "src/quiche/quic/core/http/quic_spdy_session.cc", @@ -1261,6 +1267,7 @@ "src/quiche/quic/core/http/http_encoder_test.cc", "src/quiche/quic/core/http/http_frames_test.cc", "src/quiche/quic/core/http/metadata_decoder_test.cc", + "src/quiche/quic/core/http/quic_connection_migration_manager_test.cc", "src/quiche/quic/core/http/quic_header_list_test.cc", "src/quiche/quic/core/http/quic_headers_stream_test.cc", "src/quiche/quic/core/http/quic_receive_control_stream_test.cc",
diff --git a/build/source_list.json b/build/source_list.json index a65b111..c1b7035 100644 --- a/build/source_list.json +++ b/build/source_list.json
@@ -254,6 +254,7 @@ "quiche/quic/core/http/http_encoder.h", "quiche/quic/core/http/http_frames.h", "quiche/quic/core/http/metadata_decoder.h", + "quiche/quic/core/http/quic_connection_migration_manager.h", "quiche/quic/core/http/quic_header_list.h", "quiche/quic/core/http/quic_headers_stream.h", "quiche/quic/core/http/quic_receive_control_stream.h", @@ -262,6 +263,7 @@ "quiche/quic/core/http/quic_server_session_base.h", "quiche/quic/core/http/quic_spdy_client_session.h", "quiche/quic/core/http/quic_spdy_client_session_base.h", + "quiche/quic/core/http/quic_spdy_client_session_with_migration.h", "quiche/quic/core/http/quic_spdy_client_stream.h", "quiche/quic/core/http/quic_spdy_server_stream_base.h", "quiche/quic/core/http/quic_spdy_session.h", @@ -332,6 +334,7 @@ "quiche/quic/core/quic_dispatcher_stats.h", "quiche/quic/core/quic_error_codes.h", "quiche/quic/core/quic_flow_controller.h", + "quiche/quic/core/quic_force_blockable_packet_writer.h", "quiche/quic/core/quic_framer.h", "quiche/quic/core/quic_generic_session.h", "quiche/quic/core/quic_idle_network_detector.h", @@ -348,6 +351,7 @@ "quiche/quic/core/quic_packet_writer.h", "quiche/quic/core/quic_packet_writer_wrapper.h", "quiche/quic/core/quic_packets.h", + "quiche/quic/core/quic_path_context_factory.h", "quiche/quic/core/quic_path_validator.h", "quiche/quic/core/quic_ping_manager.h", "quiche/quic/core/quic_process_packet_interface.h", @@ -599,6 +603,7 @@ "quiche/quic/core/http/http_decoder.cc", "quiche/quic/core/http/http_encoder.cc", "quiche/quic/core/http/metadata_decoder.cc", + "quiche/quic/core/http/quic_connection_migration_manager.cc", "quiche/quic/core/http/quic_header_list.cc", "quiche/quic/core/http/quic_headers_stream.cc", "quiche/quic/core/http/quic_receive_control_stream.cc", @@ -607,6 +612,7 @@ "quiche/quic/core/http/quic_server_session_base.cc", "quiche/quic/core/http/quic_spdy_client_session.cc", "quiche/quic/core/http/quic_spdy_client_session_base.cc", + "quiche/quic/core/http/quic_spdy_client_session_with_migration.cc", "quiche/quic/core/http/quic_spdy_client_stream.cc", "quiche/quic/core/http/quic_spdy_server_stream_base.cc", "quiche/quic/core/http/quic_spdy_session.cc", @@ -1260,6 +1266,7 @@ "quiche/quic/core/http/http_encoder_test.cc", "quiche/quic/core/http/http_frames_test.cc", "quiche/quic/core/http/metadata_decoder_test.cc", + "quiche/quic/core/http/quic_connection_migration_manager_test.cc", "quiche/quic/core/http/quic_header_list_test.cc", "quiche/quic/core/http/quic_headers_stream_test.cc", "quiche/quic/core/http/quic_receive_control_stream_test.cc",
diff --git a/quiche/quic/core/http/quic_connection_migration_manager.cc b/quiche/quic/core/http/quic_connection_migration_manager.cc new file mode 100644 index 0000000..eda3e0a --- /dev/null +++ b/quiche/quic/core/http/quic_connection_migration_manager.cc
@@ -0,0 +1,591 @@ +// Copyright 2025 The Chromium Authors +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "quiche/quic/core/http/quic_connection_migration_manager.h" + +#include <cstddef> +#include <list> +#include <memory> +#include <optional> +#include <string> +#include <utility> + +#include "absl/base/nullability.h" +#include "absl/strings/str_format.h" +#include "absl/strings/string_view.h" +#include "quiche/quic/core/http/quic_spdy_client_session_with_migration.h" +#include "quiche/quic/core/quic_alarm.h" +#include "quiche/quic/core/quic_clock.h" +#include "quiche/quic/core/quic_config.h" +#include "quiche/quic/core/quic_connection_context.h" +#include "quiche/quic/core/quic_error_codes.h" +#include "quiche/quic/core/quic_force_blockable_packet_writer.h" +#include "quiche/quic/core/quic_packet_writer.h" +#include "quiche/quic/core/quic_path_context_factory.h" +#include "quiche/quic/core/quic_path_validator.h" +#include "quiche/quic/core/quic_time.h" +#include "quiche/quic/core/quic_types.h" +#include "quiche/quic/platform/api/quic_client_stats.h" +#include "quiche/quic/platform/api/quic_logging.h" +#include "quiche/quic/platform/api/quic_socket_address.h" +#include "quiche/common/platform/api/quiche_client_stats.h" +#include "quiche/common/platform/api/quiche_logging.h" +#include "quiche/common/quiche_callbacks.h" + +namespace quic { + +namespace { +// Time to wait (in seconds) when no networks are available and +// migrating sessions need to wait for a new network to connect. +const size_t kWaitTimeForNewNetworkSecs = 10; + +class WaitForMigrationDelegate : public QuicAlarm::Delegate { + public: + explicit WaitForMigrationDelegate( + QuicConnectionMigrationManager* absl_nonnull migration_manager, + QuicConnectionContext* absl_nullable context) + : migration_manager_(migration_manager), context_(context) {} + WaitForMigrationDelegate(const WaitForMigrationDelegate&) = delete; + WaitForMigrationDelegate& operator=(const WaitForMigrationDelegate&) = delete; + QuicConnectionContext* GetConnectionContext() override { return context_; } + void OnAlarm() override { migration_manager_->OnMigrationTimeout(); } + + private: + QuicConnectionMigrationManager* absl_nonnull migration_manager_; + QuicConnectionContext* absl_nullable context_; +}; + +std::string MigrationCauseToString(MigrationCause cause) { + switch (cause) { + case MigrationCause::UNKNOWN_CAUSE: + return "Unknown"; + case MigrationCause::ON_NETWORK_CONNECTED: + return "OnNetworkConnected"; + case MigrationCause::ON_NETWORK_DISCONNECTED: + return "OnNetworkDisconnected"; + case MigrationCause::ON_WRITE_ERROR: + return "OnWriteError"; + case MigrationCause::ON_NETWORK_MADE_DEFAULT: + return "OnNetworkMadeDefault"; + case MigrationCause::ON_MIGRATE_BACK_TO_DEFAULT_NETWORK: + return "OnMigrateBackToDefaultNetwork"; + case MigrationCause::CHANGE_NETWORK_ON_PATH_DEGRADING: + return "OnPathDegrading"; + case MigrationCause::CHANGE_PORT_ON_PATH_DEGRADING: + return "ChangePortOnPathDegrading"; + case MigrationCause::NEW_NETWORK_CONNECTED_POST_PATH_DEGRADING: + return "NewNetworkConnectedPostPathDegrading"; + case MigrationCause::ON_SERVER_PREFERRED_ADDRESS_AVAILABLE: + return "OnServerPreferredAddressAvailable"; + default: + QUICHE_NOTREACHED(); + break; + } + return "InvalidCause"; +} + +} // namespace + +QuicConnectionMigrationManager::QuicConnectionMigrationManager( + QuicSpdyClientSessionWithMigration* absl_nonnull session, + const quic::QuicClock* absl_nonnull clock, + QuicNetworkHandle /*default_network*/, QuicNetworkHandle current_network, + QuicPathContextFactory* absl_nonnull path_context_factory, + const QuicConnectionMigrationConfig& config) + : session_(session), + connection_(session->connection()), + clock_(clock), + current_network_(current_network), + path_context_factory_(path_context_factory), + config_(config), + wait_for_migration_alarm_(connection_->alarm_factory()->CreateAlarm( + new WaitForMigrationDelegate(this, connection_->context()))) {} + +QuicConnectionMigrationManager::~QuicConnectionMigrationManager() { + wait_for_migration_alarm_->PermanentCancel(); +} + +void QuicConnectionMigrationManager::OnNetworkDisconnected( + QuicNetworkHandle disconnected_network) { + LogMetricsOnNetworkDisconnected(); + if (debug_visitor_) { + debug_visitor_->OnNetworkDisconnected(disconnected_network); + } + if (!session_->version().HasIetfQuicFrames()) { + return; + } + if (!config_.migrate_session_on_network_change) { + return; + } + if (debug_visitor_) { + debug_visitor_->OnConnectionMigrationAfterNetworkDisconnected( + disconnected_network); + } + // Stop probing the disconnected network if there is one. + QuicPathValidationContext* context = connection_->GetPathValidationContext(); + if (context && context->network() == disconnected_network && + context->peer_address() == connection_->peer_address()) { + connection_->CancelPathValidation(); + } + + // Ignore the signal if the current active network is not affected. + if (current_network() != disconnected_network) { + QUIC_DVLOG(1) << "Client's current default network is not affected by the " + << "disconnected one."; + return; + } + current_migration_cause_ = MigrationCause::ON_NETWORK_DISCONNECTED; + LogHandshakeStatusOnMigrationSignal(); + if (!session_->OneRttKeysAvailable()) { + // Close the connection if handshake has not completed. Migration before + // that is not allowed. + // TODO(danzh): the current behavior aligns with Chrome. But according to + // IETF spec, check handshake confirmed instead. + session_->OnConnectionToBeClosedDueToMigrationError( + current_migration_cause_, + QUIC_CONNECTION_MIGRATION_HANDSHAKE_UNCONFIRMED); + connection_->CloseConnection( + QUIC_CONNECTION_MIGRATION_HANDSHAKE_UNCONFIRMED, + "Network disconnected before handshake complete.", + ConnectionCloseBehavior::SILENT_CLOSE); + return; + } + // Attempt to find alternative network. + QuicNetworkHandle new_network = + session_->FindAlternateNetwork(disconnected_network); + if (new_network == kInvalidNetworkHandle) { + OnNoNewNetwork(); + return; + } + // Current network is being disconnected, migrate immediately to the + // alternative network. + MigrateNetworkImmediately(new_network); +} +void QuicConnectionMigrationManager::MigrateNetworkImmediately( + QuicNetworkHandle network) { + // There is no choice but to migrate to |network|. If any error encountered, + // close the session. When migration succeeds: + // - if no longer on the default network, start timer to migrate back; + // - otherwise, it's brought to default network, cancel the running timer to + // migrate back. + QUICHE_DCHECK(config_.migrate_session_on_network_change); + if (MaybeCloseIdleSession(/*has_write_error=*/false, + ConnectionCloseBehavior::SILENT_CLOSE)) { + return; + } + // Do not migrate if connection migration is disabled. + if (migration_disabled_) { + session_->OnConnectionToBeClosedDueToMigrationError( + current_migration_cause_, QUIC_CONNECTION_MIGRATION_DISABLED_BY_CONFIG); + connection_->CloseConnection(QUIC_CONNECTION_MIGRATION_DISABLED_BY_CONFIG, + "Migration disabled by config", + ConnectionCloseBehavior::SILENT_CLOSE); + OnMigrationFailure( + QuicConnectionMigrationStatus::MIGRATION_STATUS_DISABLED_BY_CONFIG, + "Migration disabled by config"); + return; + } + if (network == current_network()) { + OnMigrationFailure( + QuicConnectionMigrationStatus::MIGRATION_STATUS_ALREADY_MIGRATED, + "Already bound to new network"); + return; + } + // Cancel probing on |network| if there is any. + QuicPathValidationContext* context = connection_->GetPathValidationContext(); + if (context && context->network() == network && + context->peer_address() == connection_->peer_address()) { + connection_->CancelPathValidation(); + } + pending_migrate_network_immediately_ = true; + Migrate(network, connection_->peer_address(), + /*close_session_on_error=*/true, + [this](QuicNetworkHandle network, MigrationResult result) { + FinishMigrateNetworkImmediately(network, result); + }); +} + +QuicConnectionMigrationManager:: + PathContextCreationResultDelegateForImmediateMigration:: + PathContextCreationResultDelegateForImmediateMigration( + QuicConnectionMigrationManager* absl_nonnull migration_manager, + bool close_session_on_error, MigrationCallback migration_callback) + : migration_manager_(migration_manager), + close_session_on_error_(close_session_on_error), + migration_callback_(std::move(migration_callback)) {} + +void QuicConnectionMigrationManager:: + PathContextCreationResultDelegateForImmediateMigration::OnCreationSucceeded( + std::unique_ptr<QuicPathValidationContext> context) { + migration_manager_->FinishMigrate(std::move(context), close_session_on_error_, + std::move(migration_callback_)); +} + +void QuicConnectionMigrationManager:: + PathContextCreationResultDelegateForImmediateMigration::OnCreationFailed( + QuicNetworkHandle network, absl::string_view error) { + static_cast<QuicForceBlockablePacketWriter*>( + migration_manager_->connection_->writer()) + ->ForceWriteBlocked(false); + std::move(migration_callback_)(network, MigrationResult::FAILURE); + if (close_session_on_error_) { + migration_manager_->session_->OnConnectionToBeClosedDueToMigrationError( + migration_manager_->current_migration_cause_, + QUIC_CONNECTION_MIGRATION_INTERNAL_ERROR); + migration_manager_->session_->connection()->CloseConnection( + QUIC_CONNECTION_MIGRATION_INTERNAL_ERROR, + "Failed to create a path context", + ConnectionCloseBehavior::SILENT_CLOSE); + } + migration_manager_->OnMigrationFailure( + QuicConnectionMigrationStatus::MIGRATION_STATUS_INTERNAL_ERROR, error); +} + +void QuicConnectionMigrationManager::Migrate( + QuicNetworkHandle network, QuicSocketAddress peer_address, + bool close_session_on_error, MigrationCallback migration_callback) { + migration_attempted_ = true; + migration_successful_ = false; + if (!path_context_factory_) { + std::move(migration_callback)(network, MigrationResult::FAILURE); + return; + } + if (network != kInvalidNetworkHandle) { + // This is a migration attempt from connection migration. + session_->ResetNonMigratableStreams(); + if (!config_.migrate_idle_session && !session_->HasActiveRequestStreams()) { + std::move(migration_callback)(network, MigrationResult::FAILURE); + // If idle sessions can not be migrated, close the session if needed. + if (close_session_on_error) { + session_->OnConnectionToBeClosedDueToMigrationError( + current_migration_cause_, + QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS); + connection_->CloseConnection( + QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS, + "Migrating idle session is disabled.", + ConnectionCloseBehavior::SILENT_CLOSE); + } + return; + } + } else { + // TODO(b/430345640): remove the if condition if the historgram is not hit + // at all in production. + QUIC_CLIENT_HISTOGRAM_BOOL( + "Net.QuicSession.MigratingToInvalidNetwork", true, + "Connection is migrating with an invalid network handle."); + } + QUIC_DVLOG(1) << "Force blocking the current packet writer"; + static_cast<QuicForceBlockablePacketWriter*>(connection_->writer()) + ->ForceWriteBlocked(true); + if (config_.disable_blackhole_detection_on_immediate_migrate) { + // Turn off the black hole detector since the writer is blocked. + // Blackhole will be re-enabled once a packet is sent again. + connection_->blackhole_detector().StopDetection(false); + } + path_context_factory_->CreatePathValidationContext( + network, peer_address, + std::make_unique<PathContextCreationResultDelegateForImmediateMigration>( + this, close_session_on_error, std::move(migration_callback))); +} + +void QuicConnectionMigrationManager::FinishMigrateNetworkImmediately( + QuicNetworkHandle /*network*/, MigrationResult /*result*/) { + pending_migrate_network_immediately_ = false; + // TODO(danzh): check whether the session is on the default network or not. If + // not, set timer to migrate back to default network. +} + +void QuicConnectionMigrationManager::FinishMigrate( + std::unique_ptr<QuicPathValidationContext> path_context, + bool close_session_on_error, MigrationCallback callback) { + // Migrate to the new socket. + MigrationCause current_migration_cause = current_migration_cause_; + QuicNetworkHandle network = path_context->network(); + if (!session_->MigrateToNewPath(std::move(path_context))) { + static_cast<QuicForceBlockablePacketWriter*>(connection_->writer()) + ->ForceWriteBlocked(false); + std::move(callback)(network, MigrationResult::FAILURE); + if (close_session_on_error) { + session_->OnConnectionToBeClosedDueToMigrationError( + current_migration_cause, QUIC_CONNECTION_MIGRATION_INTERNAL_ERROR); + connection_->CloseConnection(QUIC_CONNECTION_MIGRATION_INTERNAL_ERROR, + "Session failed to migrate to new path.", + ConnectionCloseBehavior::SILENT_CLOSE); + } + return; + } + current_network_ = network; + wait_for_migration_alarm_->Cancel(); + migration_successful_ = true; + OnMigrationSuccess(); + std::move(callback)(network, MigrationResult::SUCCESS); +} + +void QuicConnectionMigrationManager::OnNoNewNetwork() { + QUICHE_DCHECK(session_->OneRttKeysAvailable()); + wait_for_new_network_ = true; + if (debug_visitor_) { + debug_visitor_->OnWaitingForNewNetworkToMigrate(); + } + QUIC_DVLOG(1) << "Force blocking the packet writer while waiting for new " + "netowrk for migraion cause " + << MigrationCauseToString(current_migration_cause_); + // Force blocking the packet writer to avoid any writes since there is no + // alternate network available. + static_cast<QuicForceBlockablePacketWriter*>(connection_->writer()) + ->ForceWriteBlocked(true); + if (config_.disable_blackhole_detection_on_immediate_migrate) { + // Turn off the black hole detector since the writer is blocked. + // Blackhole will be re-enabled once a packet is sent again. + connection_->blackhole_detector().StopDetection(false); + } + session_->OnNoNewNetworkForMigration(); + // Set an alarm to close the session if not being able to migrate to a new + // network soon. + if (!wait_for_migration_alarm_->IsSet()) { + wait_for_migration_alarm_->Set( + clock_->ApproximateNow() + + QuicTimeDelta::FromSeconds(kWaitTimeForNewNetworkSecs)); + } +} + +void QuicConnectionMigrationManager::OnMigrationTimeout() { + if (debug_visitor_) { + debug_visitor_->OnWaitForNetworkFailed(); + } + MigrationCause current_migration_cause = current_migration_cause_; + // |current_migration_cause_| will be reset after logging. + ResetMigrationCauseAndLogResult( + QuicConnectionMigrationStatus::MIGRATION_STATUS_TIMEOUT); + session_->OnConnectionToBeClosedDueToMigrationError( + current_migration_cause, QUIC_CONNECTION_MIGRATION_NO_NEW_NETWORK); + connection_->CloseConnection( + QUIC_CONNECTION_MIGRATION_NO_NEW_NETWORK, + absl::StrFormat("Migration for cause %s timed out", + MigrationCauseToString(current_migration_cause)), + ConnectionCloseBehavior::SILENT_CLOSE); +} + +void QuicConnectionMigrationManager::LogMetricsOnNetworkDisconnected() { + most_recent_network_disconnected_timestamp_ = clock_->ApproximateNow(); +} + +bool QuicConnectionMigrationManager::MaybeCloseIdleSession( + bool has_write_error, ConnectionCloseBehavior close_behavior) { + if (session_->HasActiveRequestStreams()) { + return false; + } + if (!config_.migrate_idle_session) { + // Close the idle session. + if (!has_write_error) { + session_->OnConnectionToBeClosedDueToMigrationError( + current_migration_cause_, + QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS); + connection_->CloseConnection( + QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS, + "Migrating idle session is disabled.", close_behavior); + } else { + connection_->CloseConnection(QUIC_PACKET_WRITE_ERROR, + "Write error for non-migratable session", + close_behavior); + } + OnMigrationFailure( + QuicConnectionMigrationStatus::MIGRATION_STATUS_NO_MIGRATABLE_STREAMS, + "No active streams"); + return true; + } + // There are no active/drainning streams, check the last stream's finish time. + if (session_->TimeSinceLastStreamClose() < config_.idle_migration_period) { + // Still within the idle migration period. + return false; + } + if (!has_write_error) { + session_->OnConnectionToBeClosedDueToMigrationError( + current_migration_cause_, QUIC_NETWORK_IDLE_TIMEOUT); + connection_->CloseConnection( + QUIC_NETWORK_IDLE_TIMEOUT, + "Idle session exceeds configured idle migration period", + ConnectionCloseBehavior::SILENT_CLOSE); + } else { + connection_->CloseConnection(QUIC_PACKET_WRITE_ERROR, + "Write error for idle session", + close_behavior); + } + OnMigrationFailure( + QuicConnectionMigrationStatus::MIGRATION_STATUS_IDLE_MIGRATION_TIMEOUT, + "Idle migration period exceeded"); + return true; +} + +void QuicConnectionMigrationManager::OnHandshakeCompleted( + const QuicConfig& negotiated_config) { + migration_disabled_ = negotiated_config.DisableConnectionMigration(); + // TODO(danzh): attempt to migrate back to the default network after handshake + // has been completed if the session is not created on the default network. +} + +void QuicConnectionMigrationManager::ResetMigrationCauseAndLogResult( + QuicConnectionMigrationStatus status) { + if (current_migration_cause_ == + MigrationCause::CHANGE_PORT_ON_PATH_DEGRADING) { + QUIC_CLIENT_HISTOGRAM_ENUM("Net.QuicSession.PortMigration", status, + MIGRATION_STATUS_MAX, ""); + current_migration_cause_ = MigrationCause::UNKNOWN_CAUSE; + return; + } + if (current_migration_cause_ == + MigrationCause::ON_SERVER_PREFERRED_ADDRESS_AVAILABLE) { + QUIC_CLIENT_HISTOGRAM_ENUM( + "Net.QuicSession.OnServerPreferredAddressAvailable", status, + MIGRATION_STATUS_MAX, ""); + current_migration_cause_ = MigrationCause::UNKNOWN_CAUSE; + return; + } + QUIC_CLIENT_HISTOGRAM_ENUM("Net.QuicSession.ConnectionMigration", status, + MIGRATION_STATUS_MAX, ""); + // Log the connection migraiton result to different histograms based on the + // cause of the connection migration. + switch (current_migration_cause_) { + case MigrationCause::UNKNOWN_CAUSE: + QUIC_CLIENT_HISTOGRAM_ENUM("Net.QuicSession.ConnectionMigration.Unknown", + status, MIGRATION_STATUS_MAX, ""); + break; + case MigrationCause::ON_NETWORK_CONNECTED: + QUIC_CLIENT_HISTOGRAM_ENUM( + "Net.QuicSession.ConnectionMigration.OnNetworkConnected", status, + MIGRATION_STATUS_MAX, ""); + break; + case MigrationCause::ON_NETWORK_DISCONNECTED: + QUIC_CLIENT_HISTOGRAM_ENUM( + "Net.QuicSession.ConnectionMigration.OnNetworkDisconnected", status, + MIGRATION_STATUS_MAX, ""); + break; + case MigrationCause::ON_WRITE_ERROR: + QUIC_CLIENT_HISTOGRAM_ENUM( + "Net.QuicSession.ConnectionMigration.OnWriteError", status, + MIGRATION_STATUS_MAX, ""); + break; + case MigrationCause::ON_NETWORK_MADE_DEFAULT: + QUIC_CLIENT_HISTOGRAM_ENUM( + "Net.QuicSession.ConnectionMigration.OnNetworkMadeDefault", status, + MIGRATION_STATUS_MAX, ""); + break; + case MigrationCause::ON_MIGRATE_BACK_TO_DEFAULT_NETWORK: + QUIC_CLIENT_HISTOGRAM_ENUM( + "Net.QuicSession.ConnectionMigration.OnMigrateBackToDefaultNetwork", + status, MIGRATION_STATUS_MAX, ""); + break; + case MigrationCause::CHANGE_NETWORK_ON_PATH_DEGRADING: + QUIC_CLIENT_HISTOGRAM_ENUM( + "Net.QuicSession.ConnectionMigration.OnPathDegrading", status, + MIGRATION_STATUS_MAX, ""); + break; + case MigrationCause::NEW_NETWORK_CONNECTED_POST_PATH_DEGRADING: + QUIC_CLIENT_HISTOGRAM_ENUM( + "Net.QuicSession.ConnectionMigration." + "NewNetworkConnectedPostPathDegrading", + status, MIGRATION_STATUS_MAX, ""); + break; + case MigrationCause::CHANGE_PORT_ON_PATH_DEGRADING: + case MigrationCause::ON_SERVER_PREFERRED_ADDRESS_AVAILABLE: + // Already has been handled above. + break; + } + current_migration_cause_ = MigrationCause::UNKNOWN_CAUSE; +} + +void QuicConnectionMigrationManager::LogHandshakeStatusOnMigrationSignal() + const { + const bool handshake_confirmed = session_->OneRttKeysAvailable(); + if (current_migration_cause_ == + MigrationCause::CHANGE_PORT_ON_PATH_DEGRADING) { + QUIC_CLIENT_HISTOGRAM_BOOL("Net.QuicSession.HandshakeStatusOnPortMigration", + handshake_confirmed, ""); + return; + } + if (current_migration_cause_ == + MigrationCause::ON_SERVER_PREFERRED_ADDRESS_AVAILABLE) { + QUIC_CLIENT_HISTOGRAM_BOOL( + "Net.QuicSession.HandshakeStatusOnMigratingToServerPreferredAddress", + handshake_confirmed, ""); + return; + } + QUIC_CLIENT_HISTOGRAM_BOOL( + "Net.QuicSession.HandshakeStatusOnConnectionMigration", + handshake_confirmed, ""); + switch (current_migration_cause_) { + case MigrationCause::UNKNOWN_CAUSE: + QUIC_CLIENT_HISTOGRAM_BOOL( + "Net.QuicSession.HandshakeStatusOnConnectionMigration.Unknown", + handshake_confirmed, ""); + break; + case MigrationCause::ON_NETWORK_CONNECTED: + QUIC_CLIENT_HISTOGRAM_BOOL( + "Net.QuicSession.HandshakeStatusOnConnectionMigration." + "OnNetworkConnected", + handshake_confirmed, ""); + break; + case MigrationCause::ON_NETWORK_DISCONNECTED: + QUIC_CLIENT_HISTOGRAM_BOOL( + "Net.QuicSession.HandshakeStatusOnConnectionMigration." + "OnNetworkDisconnected", + handshake_confirmed, ""); + break; + case MigrationCause::ON_WRITE_ERROR: + QUIC_CLIENT_HISTOGRAM_BOOL( + "Net.QuicSession.HandshakeStatusOnConnectionMigration.OnWriteError", + handshake_confirmed, ""); + break; + case MigrationCause::ON_NETWORK_MADE_DEFAULT: + QUIC_CLIENT_HISTOGRAM_BOOL( + "Net.QuicSession.HandshakeStatusOnConnectionMigration." + "OnNetworkMadeDefault", + handshake_confirmed, ""); + break; + case MigrationCause::ON_MIGRATE_BACK_TO_DEFAULT_NETWORK: + QUIC_CLIENT_HISTOGRAM_BOOL( + "Net.QuicSession.HandshakeStatusOnConnectionMigration." + "OnMigrateBackToDefaultNetwork", + handshake_confirmed, ""); + break; + case MigrationCause::CHANGE_NETWORK_ON_PATH_DEGRADING: + QUIC_CLIENT_HISTOGRAM_BOOL( + "Net.QuicSession.HandshakeStatusOnConnectionMigration." + "OnPathDegrading", + handshake_confirmed, ""); + break; + case MigrationCause::NEW_NETWORK_CONNECTED_POST_PATH_DEGRADING: + QUIC_CLIENT_HISTOGRAM_BOOL( + "Net.QuicSession.HandshakeStatusOnConnectionMigration." + "NewNetworkConnectedPostPathDegrading", + handshake_confirmed, ""); + break; + case MigrationCause::CHANGE_PORT_ON_PATH_DEGRADING: + case MigrationCause::ON_SERVER_PREFERRED_ADDRESS_AVAILABLE: + // Already has been handled above. + break; + } +} + +void QuicConnectionMigrationManager::OnMigrationFailure( + QuicConnectionMigrationStatus status, absl::string_view reason) { + if (debug_visitor_) { + debug_visitor_->OnConnectionMigrationFailed( + current_migration_cause_, connection_->connection_id(), reason); + } + // |current_migration_cause_| will be reset afterwards. + ResetMigrationCauseAndLogResult(status); +} + +void QuicConnectionMigrationManager::OnMigrationSuccess() { + if (debug_visitor_) { + debug_visitor_->OnConnectionMigrationSuccess(current_migration_cause_, + connection_->connection_id()); + } + // |current_migration_cause_| will be reset afterwards. + ResetMigrationCauseAndLogResult( + QuicConnectionMigrationStatus::MIGRATION_STATUS_SUCCESS); +} + +} // namespace quic
diff --git a/quiche/quic/core/http/quic_connection_migration_manager.h b/quiche/quic/core/http/quic_connection_migration_manager.h new file mode 100644 index 0000000..2bcd4ca --- /dev/null +++ b/quiche/quic/core/http/quic_connection_migration_manager.h
@@ -0,0 +1,241 @@ +// Copyright 2025 The Chromium Authors +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef QUICHE_QUIC_CORE_HTTP_QUIC_CONNECTION_MIGRATION_MANAGER_H_ +#define QUICHE_QUIC_CORE_HTTP_QUIC_CONNECTION_MIGRATION_MANAGER_H_ + +#include <cstddef> +#include <list> +#include <memory> + +#include "absl/base/nullability.h" +#include "absl/strings/string_view.h" +#include "quiche/quic/core/quic_alarm.h" +#include "quiche/quic/core/quic_clock.h" +#include "quiche/quic/core/quic_config.h" +#include "quiche/quic/core/quic_connection_id.h" +#include "quiche/quic/core/quic_packet_writer.h" +#include "quiche/quic/core/quic_path_context_factory.h" +#include "quiche/quic/core/quic_time.h" +#include "quiche/quic/core/quic_types.h" +#include "quiche/quic/platform/api/quic_socket_address.h" +#include "quiche/common/platform/api/quiche_export.h" +#include "quiche/common/quiche_callbacks.h" + +namespace quic { + +namespace test { +class QuicConnectionMigrationManagerPeer; +} // namespace test + +class QuicSpdyClientSessionWithMigration; + +// Result of a session migration attempt. +enum class MigrationResult { + SUCCESS, // Migration succeeded. + NO_NEW_NETWORK, // Migration failed since no new network was found. + FAILURE, // Migration failed for other reasons. +}; + +// Cause of a migration. +enum class MigrationCause { + UNKNOWN_CAUSE, // Not migrating. + ON_NETWORK_CONNECTED, // No probing. + ON_NETWORK_DISCONNECTED, // No probing. + ON_WRITE_ERROR, // No probing. + ON_NETWORK_MADE_DEFAULT, // With probing. + ON_MIGRATE_BACK_TO_DEFAULT_NETWORK, // With probing. + CHANGE_NETWORK_ON_PATH_DEGRADING, // With probing. + CHANGE_PORT_ON_PATH_DEGRADING, // With probing. + NEW_NETWORK_CONNECTED_POST_PATH_DEGRADING, // With probing. + ON_SERVER_PREFERRED_ADDRESS_AVAILABLE, // With probing. +}; + +// Result of connection migration. +enum class QuicConnectionMigrationStatus { + MIGRATION_STATUS_SUCCESS, + MIGRATION_STATUS_NO_MIGRATABLE_STREAMS, + MIGRATION_STATUS_ALREADY_MIGRATED, + MIGRATION_STATUS_INTERNAL_ERROR, + MIGRATION_STATUS_TOO_MANY_CHANGES, + MIGRATION_STATUS_NON_MIGRATABLE_STREAM, + MIGRATION_STATUS_NOT_ENABLED, + MIGRATION_STATUS_NO_ALTERNATE_NETWORK, + MIGRATION_STATUS_ON_PATH_DEGRADING_DISABLED, + MIGRATION_STATUS_DISABLED_BY_CONFIG, + MIGRATION_STATUS_PATH_DEGRADING_NOT_ENABLED, + MIGRATION_STATUS_TIMEOUT, + MIGRATION_STATUS_ON_WRITE_ERROR_DISABLED, + MIGRATION_STATUS_PATH_DEGRADING_BEFORE_HANDSHAKE_CONFIRMED, + MIGRATION_STATUS_IDLE_MIGRATION_TIMEOUT, + MIGRATION_STATUS_NO_UNUSED_CONNECTION_ID, + MIGRATION_STATUS_MAX +}; + +struct QUICHE_NO_EXPORT QuicConnectionMigrationConfig { + // Whether to migrate a session with no in-flight requests to a different + // network or port. + bool migrate_idle_session = false; + // Session can be migrated if its idle time is within this period. + QuicTimeDelta idle_migration_period = QuicTimeDelta::FromSeconds(30); + // Whether to migrate to a different network upon the underlying platform's + // network change signals and write error. + bool migrate_session_on_network_change = false; + + // Below are optional experimental features. + bool disable_blackhole_detection_on_immediate_migrate = true; +}; + +class QUICHE_EXPORT QuicConnectionMigrationDebugVisitor { + public: + virtual ~QuicConnectionMigrationDebugVisitor() = default; + + virtual void OnWaitingForNewNetworkToMigrate() = 0; + virtual void OnWaitForNetworkFailed() = 0; + virtual void OnNetworkDisconnected( + QuicNetworkHandle disconnected_network) = 0; + virtual void OnConnectionMigrationAfterNetworkDisconnected( + QuicNetworkHandle disconnected_network) = 0; + virtual void OnConnectionMigrationAboutToStartAfterEvent( + absl::string_view event_name) = 0; + virtual void OnConnectionMigrationStarted() = 0; + virtual void OnConnectionMigrationFailed(MigrationCause migration_cause, + QuicConnectionId connection_id, + absl::string_view details) = 0; + virtual void OnConnectionMigrationSuccess(MigrationCause migration_cause, + QuicConnectionId connection_id) = 0; +}; + +using MigrationCallback = + quiche::SingleUseCallback<void(QuicNetworkHandle, MigrationResult)>; + +// This class receives network change signals from the device and events +// reported by the connection, like path degrading and write error, to make +// decision about whether and how to migrate the connection to a different +// network or port. +class QUICHE_EXPORT QuicConnectionMigrationManager { + public: + QuicConnectionMigrationManager( + QuicSpdyClientSessionWithMigration* absl_nonnull session, + const quic::QuicClock* absl_nonnull clock, + QuicNetworkHandle default_network, QuicNetworkHandle current_network, + QuicPathContextFactory* absl_nonnull path_context_factory, + const QuicConnectionMigrationConfig& config); + + ~QuicConnectionMigrationManager(); + + // Called when the platform detects the given network to be disconnected. + void OnNetworkDisconnected(QuicNetworkHandle disconnected_network); + + // Called by the session when the handshake gets completed. |config| is the + // negotiated QUIC configuration. + void OnHandshakeCompleted(const QuicConfig& negotiated_config); + + void OnMigrationFailure(QuicConnectionMigrationStatus status, + absl::string_view reason); + + // Called when migration alarm fires. If migration has not occurred + // since alarm was set, closes session with error. + void OnMigrationTimeout(); + + void set_debug_visitor( + QuicConnectionMigrationDebugVisitor* absl_nullable visitor) { + debug_visitor_ = visitor; + } + + const QuicConnectionMigrationConfig& config() const { return config_; } + + // Returns the network interface that is currently used to send packets. + QuicNetworkHandle current_network() const { return current_network_; } + + bool migration_attempted() const { return migration_attempted_; } + + bool migration_successful() const { return migration_successful_; } + + private: + friend class test::QuicConnectionMigrationManagerPeer; + + class PathContextCreationResultDelegateForImmediateMigration + : public QuicPathContextFactory::CreationResultDelegate { + public: + // |migration_manager| should out live this instance. + PathContextCreationResultDelegateForImmediateMigration( + QuicConnectionMigrationManager* absl_nonnull migration_manager, + bool close_session_on_error, MigrationCallback migration_callback); + + void OnCreationSucceeded( + std::unique_ptr<QuicPathValidationContext> context) override; + + void OnCreationFailed(QuicNetworkHandle network, + absl::string_view error) override; + + private: + QuicConnectionMigrationManager* absl_nonnull migration_manager_; + const bool close_session_on_error_; + MigrationCallback migration_callback_; + }; + + // TODO(danzh): Schedules a migration alarm to wait for a new network. + void OnNoNewNetwork(); + + // Called when there is only one possible working network: |network|, if any + // error is encountered, this session will be closed. + // TODO(danzh): When the migration succeeds: + // - If no longer on the default network, set timer to migrate back to the + // default network; + // - If now on the default network, cancel timer to migrate back to default + // network. + void MigrateNetworkImmediately(QuicNetworkHandle network); + + void FinishMigrateNetworkImmediately(QuicNetworkHandle network, + MigrationResult result); + + // Migrates session over to use |peer_address| and |network|. + // If |network| is kInvalidNetworkHandle, default network is used. If + // the migration fails and |close_session_on_error| is true, session will be + // closed. + void Migrate(QuicNetworkHandle network, QuicSocketAddress peer_address, + bool close_session_on_error, + MigrationCallback migration_callback); + // Helper to finish session migration once the |path_context| is provided. + void FinishMigrate(std::unique_ptr<QuicPathValidationContext> path_context, + bool close_session_on_error, MigrationCallback callback); + + bool MaybeCloseIdleSession(bool has_write_error, + ConnectionCloseBehavior close_behavior); + + void LogMetricsOnNetworkDisconnected(); + void LogHandshakeStatusOnMigrationSignal() const; + void LogProbeResultToHistogram(MigrationCause cause, bool success); + void OnMigrationSuccess(); + void ResetMigrationCauseAndLogResult(QuicConnectionMigrationStatus status); + + QuicSpdyClientSessionWithMigration* absl_nonnull session_; + QuicConnection* absl_nonnull connection_; + const quic::QuicClock* absl_nonnull clock_; // Unowned. + // Stores the network interface that is currently used by the connection. + QuicNetworkHandle current_network_; + QuicPathContextFactory* absl_nonnull path_context_factory_; + // Not owned. + QuicConnectionMigrationDebugVisitor* absl_nullable debug_visitor_ = nullptr; + const QuicConnectionMigrationConfig config_; + bool migration_disabled_ = false; + + // True when a session migration starts from MigrateNetworkImmediately. + bool pending_migrate_network_immediately_ = false; + MigrationCause current_migration_cause_ = MigrationCause::UNKNOWN_CAUSE; + // True if migration is triggered, and there is no alternate network to + // migrate to. + bool wait_for_new_network_ = false; + quic::QuicTime most_recent_network_disconnected_timestamp_ = + quic::QuicTime::Zero(); + bool migration_attempted_ = false; + bool migration_successful_ = false; + + std::unique_ptr<QuicAlarm> wait_for_migration_alarm_; +}; + +} // namespace quic + +#endif // QUICHE_QUIC_CORE_HTTP_QUIC_CONNECTION_MIGRATION_MANAGER_H_
diff --git a/quiche/quic/core/http/quic_connection_migration_manager_test.cc b/quiche/quic/core/http/quic_connection_migration_manager_test.cc new file mode 100644 index 0000000..20bfccc --- /dev/null +++ b/quiche/quic/core/http/quic_connection_migration_manager_test.cc
@@ -0,0 +1,746 @@ +// Copyright 2025 The Chromium Authors +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "quiche/quic/core/http/quic_connection_migration_manager.h" + +#include <memory> + +#include "quiche/quic/core/crypto/null_encrypter.h" +#include "quiche/quic/core/http/quic_spdy_client_session_with_migration.h" +#include "quiche/quic/core/io/socket.h" +#include "quiche/quic/core/quic_force_blockable_packet_writer.h" +#include "quiche/quic/platform/api/quic_test.h" +#include "quiche/quic/test_tools/quic_config_peer.h" +#include "quiche/quic/test_tools/quic_connection_peer.h" +#include "quiche/quic/test_tools/quic_test_utils.h" + +using testing::_; +using testing::Invoke; +using testing::NiceMock; +using testing::Return; +using testing::StrictMock; + +namespace quic::test { + +MATCHER_P(IsFrame, type, "") { return arg.type == type; } + +class QuicConnectionMigrationManagerPeer { + public: + static QuicAlarm* GetWaitForMigrationAlarm( + QuicConnectionMigrationManager* manager) { + return manager->wait_for_migration_alarm_.get(); + } +}; + +class TestQuicForceBlockablePacketWriter + : public QuicForceBlockablePacketWriter { + public: + TestQuicForceBlockablePacketWriter() : QuicForceBlockablePacketWriter() { + ON_CALL(writer_, WritePacket(_, _, _, _, _, _)) + .WillByDefault(Return(WriteResult(WRITE_STATUS_OK, 0))); + ON_CALL(writer_, GetMaxPacketSize(_)) + .WillByDefault(Return(kMaxOutgoingPacketSize)); + ON_CALL(writer_, IsBatchMode()).WillByDefault(Return(false)); + ON_CALL(writer_, GetNextWriteLocation(_, _)) + .WillByDefault(Return(QuicPacketBuffer())); + ON_CALL(writer_, Flush()) + .WillByDefault(Return(WriteResult(WRITE_STATUS_OK, 0))); + ON_CALL(writer_, SupportsReleaseTime()).WillByDefault(Return(false)); + } + + // QuicPacketWriter. + WriteResult WritePacket(const char* buffer, size_t buf_len, + const QuicIpAddress& self_address, + const QuicSocketAddress& peer_address, + PerPacketOptions* options, + const QuicPacketWriterParams& params) override { + return writer_.WritePacket(buffer, buf_len, self_address, peer_address, + options, params); + } + + void SetWritable() override { writer_.SetWritable(); } + + std::optional<int> MessageTooBigErrorCode() const override { + return kSocketErrorMsgSize; + } + + QuicByteCount GetMaxPacketSize( + const QuicSocketAddress& peer_address) const override { + return writer_.GetMaxPacketSize(peer_address); + } + + bool SupportsReleaseTime() const override { + return writer_.SupportsReleaseTime(); + } + + bool IsBatchMode() const override { return writer_.IsBatchMode(); } + + bool SupportsEcn() const override { return writer_.SupportsEcn(); } + + QuicPacketBuffer GetNextWriteLocation( + const QuicIpAddress& self_address, + const QuicSocketAddress& peer_address) override { + return writer_.GetNextWriteLocation(self_address, peer_address); + } + + WriteResult Flush() override { return writer_.Flush(); } + + bool IsWriteBlocked() const override { + return force_write_blocked_ || writer_.IsWriteBlocked(); + } + + // QuicForceBlockablePacketWriter + void ForceWriteBlocked(bool enforce_write_block) override { + force_write_blocked_ = enforce_write_block; + } + + MockPacketWriter& GetMockWriter() { return writer_; } + + private: + NiceMock<MockPacketWriter> writer_; + bool force_write_blocked_ = false; +}; + +class TestQuicClientPathValidationContext : public QuicPathValidationContext { + public: + TestQuicClientPathValidationContext( + const quic::QuicSocketAddress& self_address, + const quic::QuicSocketAddress& peer_address, QuicNetworkHandle network) + : QuicPathValidationContext(self_address, peer_address, network), + writer_(std::make_unique<TestQuicForceBlockablePacketWriter>()) {} + + quic::QuicPacketWriter* WriterToUse() override { return writer_.get(); } + + bool ShouldConnectionOwnWriter() const override { return true; } + + void ReleasePacketWriter() { writer_.release(); } + + private: + std::unique_ptr<TestQuicForceBlockablePacketWriter> writer_; +}; + +class TestQuicPathContextFactory : public QuicPathContextFactory { + public: + TestQuicPathContextFactory() = default; + + void CreatePathValidationContext( + QuicNetworkHandle network, QuicSocketAddress peer_address, + std::unique_ptr<CreationResultDelegate> result_delegate) override { + pending_result_delegate_ = std::move(result_delegate); + network_ = network; + peer_address_ = peer_address; + if (!async_creation_) { + FinishPendingCreation(); + } + ++num_creation_attempts_; + } + + void FinishPendingCreation() { + ASSERT_NE(pending_result_delegate_, nullptr) + << "No pending path context creation"; + if (has_error_) { + pending_result_delegate_->OnCreationFailed( + network_, "path context creation failure."); + } else { + QUICHE_DCHECK(network_to_address_map_.contains(network_)); + pending_result_delegate_->OnCreationSucceeded( + std::make_unique<TestQuicClientPathValidationContext>( + network_to_address_map_[network_], peer_address_, network_)); + network_to_address_map_.erase(network_); + } + pending_result_delegate_ = nullptr; + } + + void SetSelfAddressForNetwork(QuicNetworkHandle network, + const QuicSocketAddress& self_address) { + QUICHE_DCHECK(!network_to_address_map_.contains(network)); + network_to_address_map_[network] = self_address; + } + + size_t num_creation_attempts() const { return num_creation_attempts_; } + + private: + bool async_creation_ = false; + bool has_error_ = false; + std::unique_ptr<CreationResultDelegate> pending_result_delegate_; + QuicNetworkHandle network_ = kInvalidNetworkHandle; + QuicSocketAddress peer_address_; + absl::flat_hash_map<QuicNetworkHandle, QuicSocketAddress> + network_to_address_map_; + size_t num_creation_attempts_ = 0; +}; + +class TestCryptoStream : public QuicCryptoStream, public QuicCryptoHandshaker { + public: + explicit TestCryptoStream(QuicSession* session) + : QuicCryptoStream(session), + QuicCryptoHandshaker(this, session), + params_(new QuicCryptoNegotiatedParameters) { + // Simulate a negotiated cipher_suite with a fake value. + params_->cipher_suite = 1; + } + + void EstablishZeroRttEncryption() { + encryption_established_ = true; + session()->connection()->SetEncrypter( + ENCRYPTION_ZERO_RTT, + std::make_unique<NullEncrypter>(session()->perspective())); + } + + void OnHandshakeMessage(const CryptoHandshakeMessage& /*message*/) override { + encryption_established_ = true; + one_rtt_keys_available_ = true; + QuicErrorCode error; + std::string error_details; + session()->config()->SetInitialStreamFlowControlWindowToSend( + test::kInitialStreamFlowControlWindowForTest); + session()->config()->SetInitialSessionFlowControlWindowToSend( + test::kInitialSessionFlowControlWindowForTest); + if (session()->version().UsesTls()) { + if (session()->perspective() == Perspective::IS_CLIENT) { + session()->config()->SetOriginalConnectionIdToSend( + session()->connection()->connection_id()); + session()->config()->SetInitialSourceConnectionIdToSend( + session()->connection()->connection_id()); + } else { + session()->config()->SetInitialSourceConnectionIdToSend( + session()->connection()->client_connection_id()); + } + TransportParameters transport_parameters; + EXPECT_TRUE( + session()->config()->FillTransportParameters(&transport_parameters)); + error = session()->config()->ProcessTransportParameters( + transport_parameters, /* is_resumption = */ false, &error_details); + } else { + CryptoHandshakeMessage msg; + session()->config()->ToHandshakeMessage(&msg, transport_version()); + error = + session()->config()->ProcessPeerHello(msg, CLIENT, &error_details); + } + session()->OnConfigNegotiated(); + EXPECT_THAT(error, test::IsQuicNoError()); + session()->OnNewEncryptionKeyAvailable( + ENCRYPTION_FORWARD_SECURE, + std::make_unique<NullEncrypter>(session()->perspective())); + if (session()->connection()->version().handshake_protocol == + PROTOCOL_TLS1_3) { + session()->OnTlsHandshakeComplete(); + } else { + session()->SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE); + } + session()->DiscardOldEncryptionKey(ENCRYPTION_INITIAL); + } + + // QuicCryptoStream implementation + ssl_early_data_reason_t EarlyDataReason() const override { + return ssl_early_data_unknown; + } + bool encryption_established() const override { + return encryption_established_; + } + bool one_rtt_keys_available() const override { + return one_rtt_keys_available_; + } + const QuicCryptoNegotiatedParameters& crypto_negotiated_params() + const override { + return *params_; + } + CryptoMessageParser* crypto_message_parser() override { + return QuicCryptoHandshaker::crypto_message_parser(); + } + void OnPacketDecrypted(EncryptionLevel /*level*/) override {} + void OnOneRttPacketAcknowledged() override {} + void OnHandshakePacketSent() override {} + void OnHandshakeDoneReceived() override {} + void OnNewTokenReceived(absl::string_view /*token*/) override {} + std::string GetAddressToken( + const CachedNetworkParameters* /*cached_network_parameters*/) + const override { + return ""; + } + bool ValidateAddressToken(absl::string_view /*token*/) const override { + return true; + } + const CachedNetworkParameters* PreviousCachedNetworkParams() const override { + return nullptr; + } + void SetPreviousCachedNetworkParams( + CachedNetworkParameters /*cached_network_params*/) override {} + HandshakeState GetHandshakeState() const override { + return one_rtt_keys_available() ? HANDSHAKE_CONFIRMED : HANDSHAKE_START; + } + void SetServerApplicationStateForResumption( + std::unique_ptr<ApplicationState> /*application_state*/) override {} + MOCK_METHOD(std::unique_ptr<QuicDecrypter>, + AdvanceKeysAndCreateCurrentOneRttDecrypter, (), (override)); + MOCK_METHOD(std::unique_ptr<QuicEncrypter>, CreateCurrentOneRttEncrypter, (), + (override)); + + MOCK_METHOD(void, OnCanWrite, (), (override)); + bool HasPendingCryptoRetransmission() const override { return false; } + + MOCK_METHOD(bool, HasPendingRetransmission, (), (const, override)); + + void OnConnectionClosed(const QuicConnectionCloseFrame& /*frame*/, + ConnectionCloseSource /*source*/) override {} + + bool ExportKeyingMaterial(absl::string_view /*label*/, + absl::string_view /*context*/, + size_t /*result_len*/, + std::string* /*result*/) override { + return false; + } + + SSL* GetSsl() const override { return nullptr; } + + bool IsCryptoFrameExpectedForEncryptionLevel( + EncryptionLevel level) const override { + return level != ENCRYPTION_ZERO_RTT; + } + + EncryptionLevel GetEncryptionLevelToSendCryptoDataOfSpace( + PacketNumberSpace space) const override { + switch (space) { + case INITIAL_DATA: + return ENCRYPTION_INITIAL; + case HANDSHAKE_DATA: + return ENCRYPTION_HANDSHAKE; + case APPLICATION_DATA: + return ENCRYPTION_FORWARD_SECURE; + default: + QUICHE_DCHECK(false); + return NUM_ENCRYPTION_LEVELS; + } + } + + private: + using QuicCryptoStream::session; + + bool encryption_established_ = false; + bool one_rtt_keys_available_ = false; + quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_; +}; + +class TestStream : public QuicSpdyStream { + public: + TestStream(QuicStreamId id, QuicSpdySession* session, StreamType type) + : QuicSpdyStream(id, session, type) {} + + TestStream(PendingStream* pending, QuicSpdySession* session) + : QuicSpdyStream(pending, session) {} + + void OnBodyAvailable() override {} + + MOCK_METHOD(void, OnCanWrite, (), (override)); + MOCK_METHOD(bool, RetransmitStreamData, + (QuicStreamOffset, QuicByteCount, bool, TransmissionType), + (override)); + + MOCK_METHOD(bool, HasPendingRetransmission, (), (const, override)); + + protected: + bool ValidateReceivedHeaders(const QuicHeaderList& /*header_list*/) override { + return true; + } +}; + +class TestQuicSpdyClientSessionWithMigration + : public QuicSpdyClientSessionWithMigration { + public: + TestQuicSpdyClientSessionWithMigration( + QuicConnection* connection, QuicSession::Visitor* visitor, + const QuicConfig& config, + const ParsedQuicVersionVector& supported_versions, + QuicNetworkHandle default_network, QuicNetworkHandle current_network, + std::unique_ptr<QuicPathContextFactory> path_context_factory, + QuicConnectionMigrationConfig migration_config) + : QuicSpdyClientSessionWithMigration( + connection, visitor, config, supported_versions, default_network, + current_network, std::move(path_context_factory), migration_config), + crypto_stream_(this) { + ON_CALL(*this, IsSessionProxied()).WillByDefault(Return(false)); + ON_CALL(*this, OnMigrationToPathDone(_, _)) + .WillByDefault( + Invoke([](std::unique_ptr<QuicPathValidationContext> context, + bool success) { + if (success) { + static_cast<TestQuicClientPathValidationContext&>(*context) + .ReleasePacketWriter(); + } + })); + } + + MOCK_METHOD(void, ResetNonMigratableStreams, (), (override)); + MOCK_METHOD(void, OnNoNewNetworkForMigration, (), (override)); + MOCK_METHOD(void, PrepareForProbingOnPath, + (QuicPathValidationContext & context), (override)); + MOCK_METHOD(bool, IsSessionProxied, (), (const)); + MOCK_METHOD(QuicTimeDelta, TimeSinceLastStreamClose, (), (override)); + MOCK_METHOD(bool, PrepareForMigrationToPath, (QuicPathValidationContext&)); + MOCK_METHOD(void, OnMigrationToPathDone, + (std::unique_ptr<QuicPathValidationContext>, bool)); + MOCK_METHOD(void, OnConnectionToBeClosedDueToMigrationError, + (MigrationCause migration_cause, QuicErrorCode quic_error), + (override)); + + // QuicSpdyClientSessionWithMigration. + QuicNetworkHandle FindAlternateNetwork(QuicNetworkHandle network) override { + QUICHE_DCHECK_NE(network, alternate_network_); + return alternate_network_; + } + + void StartDraining() override { going_away_ = true; } + + // QuicSession. + TestCryptoStream* GetMutableCryptoStream() override { + return &crypto_stream_; + } + + const TestCryptoStream* GetCryptoStream() const override { + return &crypto_stream_; + } + + void OnProofValid( + const QuicCryptoClientConfig::CachedState& /*cached*/) override {} + + void OnProofVerifyDetailsAvailable( + const ProofVerifyDetails& /*verify_details*/) override {} + + TestStream* CreateOutgoingBidirectionalStream() override { + QuicStreamId id = GetNextOutgoingBidirectionalStreamId(); + if (id == + QuicUtils::GetInvalidStreamId(connection()->transport_version())) { + return nullptr; + } + TestStream* stream = new TestStream(id, this, BIDIRECTIONAL); + ActivateStream(absl::WrapUnique(stream)); + return stream; + } + + TestStream* CreateIncomingStream(QuicStreamId id) override { + // Enforce the limit on the number of open streams. + if (!VersionHasIetfQuicFrames(connection()->transport_version()) && + stream_id_manager().num_open_incoming_streams() + 1 > + max_open_incoming_bidirectional_streams()) { + // No need to do this test for version 99; it's done by + // QuicSession::GetOrCreateStream. + connection()->CloseConnection( + QUIC_TOO_MANY_OPEN_STREAMS, "Too many streams!", + ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET); + return nullptr; + } + + TestStream* stream = new TestStream( + id, this, + test::DetermineStreamType(id, connection()->version(), perspective(), + /*is_incoming=*/true, BIDIRECTIONAL)); + ActivateStream(absl::WrapUnique(stream)); + return stream; + } + + TestStream* CreateIncomingStream(PendingStream* pending) override { + TestStream* stream = new TestStream(pending, this); + ActivateStream(absl::WrapUnique(stream)); + return stream; + } + + void set_alternate_network(QuicNetworkHandle network) { + alternate_network_ = network; + } + + bool going_away() const { return going_away_; } + + using QuicSpdyClientSessionWithMigration::migration_manager; + + protected: + bool ShouldCreateIncomingStream(QuicStreamId /*id*/) override { return true; } + bool ShouldCreateOutgoingBidirectionalStream() override { return true; } + + private: + QuicNetworkHandle alternate_network_ = kInvalidNetworkHandle; + bool going_away_ = false; + NiceMock<TestCryptoStream> crypto_stream_; +}; + +class QuicConnectionMigrationManagerTest + : public test::QuicTestWithParam<ParsedQuicVersion> { + public: + QuicConnectionMigrationManagerTest() + : versions_(ParsedQuicVersionVector{GetParam()}), + config_(test::DefaultQuicConfig()), + path_context_factory_(new TestQuicPathContextFactory()), + connection_(new StrictMock<test::MockQuicConnection>( + &connection_helper_, &alarm_factory_, Perspective::IS_CLIENT, + versions_)), + default_writer_(new NiceMock<TestQuicForceBlockablePacketWriter>()) { + connection_->SetQuicPacketWriter(default_writer_, true); + } + + void Initialize() { + migration_config_.migrate_session_on_network_change = + connection_migration_on_network_change_; + migration_config_.migrate_idle_session = migrate_idle_session_; + + session_ = std::make_unique<TestQuicSpdyClientSessionWithMigration>( + connection_, &session_visitor_, config_, versions_, default_network_, + initial_network_, + std::unique_ptr<QuicPathContextFactory>(path_context_factory_), + migration_config_); + session_->Initialize(); + migration_manager_ = &session_->migration_manager(); + EXPECT_EQ(migration_manager_->current_network(), initial_network_); + + connection_helper_.GetClock()->AdvanceTime(QuicTimeDelta::FromSeconds(1)); + + if (complete_handshake_) { + CompleteHandshake(/*received_server_preferred_address=*/false); + return; + } + } + + void CompleteHandshake(bool received_server_preferred_address) { + const QuicConnectionId extra_connection_id = TestConnectionId(1234); + ASSERT_NE(extra_connection_id, connection_->connection_id()); + const StatelessResetToken reset_token = + QuicUtils::GenerateStatelessResetToken(extra_connection_id); + if (version().HasIetfQuicFrames() && received_server_preferred_address) { + // OnHandshakeMessage() will populate the received values with these. + QuicIpAddress ipv4, ipv6; + ASSERT_TRUE(ipv4.FromString("127.0.0.2")); + ASSERT_TRUE(ipv6.FromString("::2")); + session_->config()->SetIPv4AlternateServerAddressToSend( + QuicSocketAddress(ipv4, 12345)); + session_->config()->SetIPv6AlternateServerAddressToSend( + QuicSocketAddress(ipv6, 12345)); + session_->config()->SetPreferredAddressConnectionIdAndTokenToSend( + extra_connection_id, reset_token); + } + CryptoHandshakeMessage msg; + session_->GetMutableCryptoStream()->OnHandshakeMessage(msg); + EXPECT_TRUE(session_->OneRttKeysAvailable()); + EXPECT_EQ(session_->GetHandshakeState(), HANDSHAKE_CONFIRMED); + if (received_server_preferred_address) { + EXPECT_TRUE( + QuicConnectionPeer::GetReceivedServerPreferredAddress(connection_) + .IsInitialized()); + } + + connection_->SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE); + if (version().HasIetfQuicFrames() && !received_server_preferred_address) { + // Prepare an additional CID for future migration. + QuicNewConnectionIdFrame frame; + frame.connection_id = extra_connection_id; + frame.stateless_reset_token = reset_token; + frame.retire_prior_to = 0u; + frame.sequence_number = 1u; + connection_->OnNewConnectionIdFrame(frame); + } + connection_->OnHandshakeComplete(); + } + + ParsedQuicVersion version() const { return versions_[0]; } + + protected: + QuicNetworkHandle default_network_ = 1; + QuicNetworkHandle initial_network_ = 1; + MockQuicConnectionHelper connection_helper_; + MockAlarmFactory alarm_factory_; + NiceMock<test::MockQuicSessionVisitor> session_visitor_; + ParsedQuicVersionVector versions_; + QuicConfig config_; + QuicConnectionMigrationConfig migration_config_; + // Owned by |session_| + TestQuicPathContextFactory* path_context_factory_; + // Owned by |session_| + StrictMock<test::MockQuicConnection>* connection_; + NiceMock<TestQuicForceBlockablePacketWriter>* default_writer_; + std::unique_ptr<TestQuicSpdyClientSessionWithMigration> session_; + QuicConnectionMigrationManager* migration_manager_ = nullptr; + bool connection_migration_on_path_degrading_ = true; + bool port_migration_ = true; + bool connection_migration_on_network_change_ = true; + bool migrate_idle_session_ = false; + bool complete_handshake_ = true; +}; + +// Used by ::testing::PrintToStringParamName(). +std::string PrintToString(const ParsedQuicVersion& p) { + return ParsedQuicVersionToString(p); +} + +INSTANTIATE_TEST_SUITE_P(QuicConnectionMigrationManagerTests, + QuicConnectionMigrationManagerTest, + ::testing::ValuesIn(CurrentSupportedHttp3Versions()), + ::testing::PrintToStringParamName()); + +// This test verifies that session times out connection migration attempt +// with signals delivered in the following order (no alternate network is +// available): +// - default network disconnected is delivered: session attempts connection +// migration but found not alternate network. Session waits for a new network +// comes up in the next kWaitTimeForNewNetworkSecs seconds. +// - no new network is connected, migration times out. Session is closed. +TEST_P(QuicConnectionMigrationManagerTest, MigrationTimeoutWithNoNewNetwork) { + Initialize(); + + // Trigger a network disconnected signal to attempt migrating to a different + // network. But since there is no alternative network available, no migration + // should have happened. + EXPECT_CALL(*session_, OnNoNewNetworkForMigration()); + migration_manager_->OnNetworkDisconnected(initial_network_); + EXPECT_EQ(path_context_factory_->num_creation_attempts(), 0u); + EXPECT_TRUE(default_writer_->IsWriteBlocked()); + + QuicAlarm* migration_alarm = + QuicConnectionMigrationManagerPeer::GetWaitForMigrationAlarm( + migration_manager_); + EXPECT_TRUE(migration_alarm->IsSet()); + EXPECT_EQ(migration_alarm->deadline() - connection_helper_.GetClock()->Now(), + QuicTimeDelta::FromSeconds(10)); + + EXPECT_CALL( + *connection_, + CloseConnection(QUIC_CONNECTION_MIGRATION_NO_NEW_NETWORK, + "Migration for cause OnNetworkDisconnected timed out", + ConnectionCloseBehavior::SILENT_CLOSE)); + connection_helper_.GetClock()->AdvanceTime(QuicTimeDelta::FromSeconds(10)); + alarm_factory_.FireAlarm(migration_alarm); +} + +// This test verifies session migrates off the disconnected default network. +TEST_P(QuicConnectionMigrationManagerTest, + MigratingOffDisconnectedDefaultNetwork) { + migrate_idle_session_ = true; + Initialize(); + + const QuicNetworkHandle alternate_network = 2; + session_->set_alternate_network(alternate_network); + EXPECT_NE(alternate_network, migration_manager_->current_network()); + QuicSocketAddress alternate_self_address = + QuicSocketAddress(QuicIpAddress::Loopback6(), /*port=*/kTestPort); + EXPECT_NE(alternate_self_address.host(), connection_->self_address().host()); + path_context_factory_->SetSelfAddressForNetwork(alternate_network, + alternate_self_address); + + EXPECT_CALL(*session_, TimeSinceLastStreamClose()) + .WillOnce(Return(QuicTimeDelta::Zero())); + EXPECT_CALL(*session_, ResetNonMigratableStreams()); + EXPECT_CALL(*session_, PrepareForMigrationToPath(_)).WillOnce(Return(true)); + EXPECT_CALL(*session_, OnMigrationToPathDone(_, true)); + migration_manager_->OnNetworkDisconnected(initial_network_); + EXPECT_EQ(migration_manager_->current_network(), alternate_network); + EXPECT_EQ(connection_->self_address(), alternate_self_address); + EXPECT_EQ(path_context_factory_->num_creation_attempts(), 1u); +} + +// This test verifies that sessions idle for longer than the configured +// |idle_migration_period| should not be migrated. +TEST_P(QuicConnectionMigrationManagerTest, DoNotMigrateLongIdleSession) { + migrate_idle_session_ = true; + Initialize(); + const QuicNetworkHandle alternate_network = 2; + session_->set_alternate_network(alternate_network); + EXPECT_NE(alternate_network, migration_manager_->current_network()); + + EXPECT_CALL(*session_, TimeSinceLastStreamClose()) + .WillOnce(Return(migration_config_.idle_migration_period)); + EXPECT_CALL( + *connection_, + CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT, + "Idle session exceeds configured idle migration period", + ConnectionCloseBehavior::SILENT_CLOSE)); + migration_manager_->OnNetworkDisconnected(initial_network_); +} + +// This test verifies that no idle sessions should be migrated if disallowed by +// config. +TEST_P(QuicConnectionMigrationManagerTest, + DoNotMigrateIdleSessionIfDisabledByConfig) { + migrate_idle_session_ = false; + Initialize(); + const QuicNetworkHandle alternate_network = 2; + session_->set_alternate_network(alternate_network); + EXPECT_NE(alternate_network, migration_manager_->current_network()); + EXPECT_CALL(*connection_, + CloseConnection(QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS, + "Migrating idle session is disabled.", + ConnectionCloseBehavior::SILENT_CLOSE)); + migration_manager_->OnNetworkDisconnected(initial_network_); +} + +TEST_P(QuicConnectionMigrationManagerTest, + ConnectionMigrationDisabledDuringHandshake) { + QuicConfigPeer::SetReceivedDisableConnectionMigration(&config_); + migrate_idle_session_ = true; + Initialize(); + + const QuicNetworkHandle alternate_network = 2; + session_->set_alternate_network(alternate_network); + EXPECT_NE(alternate_network, migration_manager_->current_network()); + EXPECT_TRUE(session_->config()->DisableConnectionMigration()); + + EXPECT_CALL(*session_, TimeSinceLastStreamClose()) + .WillOnce(Return(QuicTimeDelta::Zero())); + EXPECT_CALL(*connection_, + CloseConnection(QUIC_CONNECTION_MIGRATION_DISABLED_BY_CONFIG, + "Migration disabled by config", + ConnectionCloseBehavior::SILENT_CLOSE)); + migration_manager_->OnNetworkDisconnected(initial_network_); +} + +class QuicConnectionMigrationManagerGoogleQuicTest + : public QuicConnectionMigrationManagerTest {}; + +INSTANTIATE_TEST_SUITE_P(QuicConnectionMigrationManagerGoogleQuicTests, + QuicConnectionMigrationManagerGoogleQuicTest, + ::testing::ValuesIn(ParsedQuicVersionVector{ + quic::ParsedQuicVersion::Q046()}), + ::testing::PrintToStringParamName()); + +TEST_P(QuicConnectionMigrationManagerGoogleQuicTest, NoMigrationForGoogleQuic) { + Initialize(); + session_->set_alternate_network(-1); + // If the session has attempted to migrate, it would have found no alternate + // network and called OnNoNewNetworkForMigration(). + EXPECT_CALL(*session_, OnNoNewNetworkForMigration()).Times(0); + migration_manager_->OnNetworkDisconnected(initial_network_); +} + +class QuicSpdyClientSessionWithMigrationTest + : public QuicConnectionMigrationManagerTest {}; + +INSTANTIATE_TEST_SUITE_P(QuicSpdyClientSessionWithMigrationTests, + QuicSpdyClientSessionWithMigrationTest, + ::testing::ValuesIn(CurrentSupportedHttp3Versions()), + ::testing::PrintToStringParamName()); + +TEST_P(QuicSpdyClientSessionWithMigrationTest, + SessionFailedToPrepareForMigration) { + migrate_idle_session_ = true; + Initialize(); + + const QuicNetworkHandle alternate_network = 2; + session_->set_alternate_network(alternate_network); + EXPECT_NE(alternate_network, migration_manager_->current_network()); + QuicSocketAddress alternate_self_address = + QuicSocketAddress(QuicIpAddress::Loopback6(), /*port=*/kTestPort); + EXPECT_NE(alternate_self_address.host(), connection_->self_address().host()); + path_context_factory_->SetSelfAddressForNetwork(alternate_network, + alternate_self_address); + + EXPECT_CALL(*session_, TimeSinceLastStreamClose()) + .WillOnce(Return(QuicTimeDelta::Zero())); + EXPECT_CALL(*session_, ResetNonMigratableStreams()); + // Session failed to prepare for migration. Migration should not be attempted. + EXPECT_CALL(*session_, PrepareForMigrationToPath(_)).WillOnce(Return(false)); + EXPECT_CALL(*connection_, + CloseConnection(QUIC_CONNECTION_MIGRATION_INTERNAL_ERROR, + "Session failed to migrate to new path.", + ConnectionCloseBehavior::SILENT_CLOSE)); + migration_manager_->OnNetworkDisconnected(initial_network_); + EXPECT_EQ(migration_manager_->current_network(), default_network_); + EXPECT_EQ(path_context_factory_->num_creation_attempts(), 1u); +} + +} // namespace quic::test
diff --git a/quiche/quic/core/http/quic_spdy_client_session_with_migration.cc b/quiche/quic/core/http/quic_spdy_client_session_with_migration.cc new file mode 100644 index 0000000..4796961 --- /dev/null +++ b/quiche/quic/core/http/quic_spdy_client_session_with_migration.cc
@@ -0,0 +1,69 @@ +// Copyright 2025 The Chromium Authors +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "quiche/quic/core/http/quic_spdy_client_session_with_migration.h" + +namespace quic { + +QuicSpdyClientSessionWithMigration::QuicSpdyClientSessionWithMigration( + QuicConnection* connection, QuicSession::Visitor* visitor, + const QuicConfig& config, const ParsedQuicVersionVector& supported_versions, + QuicNetworkHandle default_network, QuicNetworkHandle current_network, + std::unique_ptr<QuicPathContextFactory> path_context_factory, + QuicConnectionMigrationConfig migration_config) + : QuicSpdyClientSessionBase(connection, visitor, config, + supported_versions), + path_context_factory_(std::move(path_context_factory)), + migration_manager_(this, connection->clock(), default_network, + current_network, path_context_factory_.get(), + migration_config) {} + +QuicSpdyClientSessionWithMigration::~QuicSpdyClientSessionWithMigration() = + default; + +void QuicSpdyClientSessionWithMigration::OnTlsHandshakeComplete() { + QuicSpdyClientSessionBase::OnTlsHandshakeComplete(); + migration_manager_.OnHandshakeCompleted(*config()); +} + +void QuicSpdyClientSessionWithMigration::SetDefaultEncryptionLevel( + EncryptionLevel level) { + QuicSpdyClientSessionBase::SetDefaultEncryptionLevel(level); + if (level == ENCRYPTION_FORWARD_SECURE) { + migration_manager_.OnHandshakeCompleted(*config()); + } +} + +bool QuicSpdyClientSessionWithMigration::MigrateToNewPath( + std::unique_ptr<QuicPathValidationContext> path_context) { + if (!PrepareForMigrationToPath(*path_context)) { + QUIC_CLIENT_HISTOGRAM_BOOL("Net.QuicSession.PrepareForMigrationToPath", + false, ""); + return false; + } + const bool success = MigratePath( + path_context->self_address(), path_context->peer_address(), + path_context->WriterToUse(), path_context->ShouldConnectionOwnWriter()); + + if (!success) { + migration_manager_.OnMigrationFailure( + QuicConnectionMigrationStatus::MIGRATION_STATUS_NO_UNUSED_CONNECTION_ID, + "No unused server connection ID"); + QUIC_DVLOG(1) << "MigratePath fails as there is no CID available"; + } + OnMigrationToPathDone(std::move(path_context), success); + return success; +} + +void QuicSpdyClientSessionWithMigration::SetMigrationDebugVisitor( + QuicConnectionMigrationDebugVisitor* visitor) { + migration_manager_.set_debug_visitor(visitor); +} + +const QuicConnectionMigrationConfig& +QuicSpdyClientSessionWithMigration::GetConnectionMigrationConfig() const { + return migration_manager_.config(); +} + +} // namespace quic
diff --git a/quiche/quic/core/http/quic_spdy_client_session_with_migration.h b/quiche/quic/core/http/quic_spdy_client_session_with_migration.h new file mode 100644 index 0000000..9aa2e52 --- /dev/null +++ b/quiche/quic/core/http/quic_spdy_client_session_with_migration.h
@@ -0,0 +1,112 @@ +// Copyright 2025 The Chromium Authors +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef QUICHE_QUIC_CORE_HTTP_QUIC_SPDY_CLIENT_SESSION_WITH_MIGRATION_H_ +#define QUICHE_QUIC_CORE_HTTP_QUIC_SPDY_CLIENT_SESSION_WITH_MIGRATION_H_ + +#include <memory> + +#include "quiche/quic/core/http/quic_connection_migration_manager.h" +#include "quiche/quic/core/http/quic_spdy_client_session_base.h" +#include "quiche/quic/core/quic_config.h" +#include "quiche/quic/core/quic_connection.h" +#include "quiche/quic/core/quic_error_codes.h" +#include "quiche/quic/core/quic_path_context_factory.h" +#include "quiche/quic/core/quic_session.h" +#include "quiche/quic/core/quic_time.h" +#include "quiche/quic/core/quic_types.h" +#include "quiche/quic/core/quic_versions.h" +#include "quiche/quic/platform/api/quic_socket_address.h" +#include "quiche/common/platform/api/quiche_export.h" + +namespace quic { + +// A client session implementation that supports connection migration upon these +// events under IETF versions: +// 1. platform's network change signals +// 2. packetwrite error +// 3. QuicConnection detected path degrading +// 4. received server preferred address +// 5. handshake completion on a non-default network. +class QUICHE_EXPORT QuicSpdyClientSessionWithMigration + : public QuicSpdyClientSessionBase { + public: + QuicSpdyClientSessionWithMigration( + QuicConnection* connection, QuicSession::Visitor* visitor, + const QuicConfig& config, + const ParsedQuicVersionVector& supported_versions, + QuicNetworkHandle default_network, QuicNetworkHandle current_network, + std::unique_ptr<QuicPathContextFactory> path_context_factory, + QuicConnectionMigrationConfig migration_config); + + ~QuicSpdyClientSessionWithMigration() override; + + // Called before connection gets closed upon a migration failure. + virtual void OnConnectionToBeClosedDueToMigrationError( + MigrationCause migration_cause, QuicErrorCode quic_error) = 0; + + // Returns a network handle which is different from the given |network|; + virtual QuicNetworkHandle FindAlternateNetwork(QuicNetworkHandle network) = 0; + + // Close non-migratable streams in both directions by sending reset stream to + // peer when connection migration attempts to migrate to the alternate + // network. + virtual void ResetNonMigratableStreams() = 0; + + // Called when there is no new network available to migrate to upon write + // error or network disconnect. + virtual void OnNoNewNetworkForMigration() = 0; + + // Mark the session draining to not accept any new requests. + virtual void StartDraining() = 0; + + // Called before using the given |context| to probe a path. + virtual void PrepareForProbingOnPath(QuicPathValidationContext& context) = 0; + + virtual bool IsSessionProxied() const = 0; + + // Returns the time elapsed since the latest stream closure. + virtual quic::QuicTimeDelta TimeSinceLastStreamClose() = 0; + + // QuicSpdyClientSessionBase + void OnTlsHandshakeComplete() override; + void SetDefaultEncryptionLevel(EncryptionLevel level) override; + + // Migrates session onto the new path, i.e. changing the default writer and + // network. + // Returns true on successful migration. + bool MigrateToNewPath( + std::unique_ptr<QuicPathValidationContext> path_context); + + void SetMigrationDebugVisitor( + quic::QuicConnectionMigrationDebugVisitor* visitor); + + const QuicConnectionMigrationConfig& GetConnectionMigrationConfig() const; + + QuicConnectionMigrationManager& migration_manager() { + return migration_manager_; + } + + const QuicConnectionMigrationManager& migration_manager() const { + return migration_manager_; + } + + protected: + // Called in MigrateToNewPath() prior to calling MigratePath(). + // Return false if MigratePath() should be skipped. + virtual bool PrepareForMigrationToPath( + QuicPathValidationContext& context) = 0; + + // Called in MigrateToNewPath() after MigratePath() for clean up. + virtual void OnMigrationToPathDone( + std::unique_ptr<QuicPathValidationContext> context, bool success) = 0; + + private: + std::unique_ptr<QuicPathContextFactory> path_context_factory_; + QuicConnectionMigrationManager migration_manager_; +}; + +} // namespace quic + +#endif // QUICHE_QUIC_CORE_HTTP_QUIC_SPDY_CLIENT_SESSION_WITH_MIGRATION_H_
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc index 7b40eda..f0b2be0 100644 --- a/quiche/quic/core/quic_connection.cc +++ b/quiche/quic/core/quic_connection.cc
@@ -1672,11 +1672,19 @@ const QuicSocketAddress& effective_peer_address, QuicConnection* connection) : QuicPathValidationContext(self_address, peer_address, - effective_peer_address), + effective_peer_address, /*network=*/-1), connection_(connection) {} QuicPacketWriter* WriterToUse() override { return connection_->writer(); } + // Reverse path validation always re-uses the original writer. So this method + // will not be called and the return value here doesn't matter. + bool ShouldConnectionOwnWriter() const override { + QUIC_BUG(client_only_writer_interface_used_in_server_side) + << "Reverse path validation shouldn't call this interface."; + return false; + } + private: QuicConnection* connection_; };
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc index 87e13dd..3814725 100644 --- a/quiche/quic/core/quic_connection_test.cc +++ b/quiche/quic/core/quic_connection_test.cc
@@ -2553,6 +2553,7 @@ writer_(writer) {} QuicPacketWriter* WriterToUse() override { return writer_; } + bool ShouldConnectionOwnWriter() const override { return false; } private: QuicPacketWriter* writer_;
diff --git a/quiche/quic/core/quic_force_blockable_packet_writer.h b/quiche/quic/core/quic_force_blockable_packet_writer.h new file mode 100644 index 0000000..a487885 --- /dev/null +++ b/quiche/quic/core/quic_force_blockable_packet_writer.h
@@ -0,0 +1,26 @@ +// Copyright 2025 The Chromium Authors +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef QUICHE_QUIC_CORE_QUIC_FORCE_BLOCKABLE_PACKET_WRITER_H_ +#define QUICHE_QUIC_CORE_QUIC_FORCE_BLOCKABLE_PACKET_WRITER_H_ + +#include "quiche/quic/core/quic_packet_writer.h" + +namespace quic { + +// A extended interface of QuicPacketWriter that can be forced to be write +// blocked. +class QUICHE_EXPORT QuicForceBlockablePacketWriter : public QuicPacketWriter { + public: + // If `enforce_write_block` is true, IsWriteBlocked() will always return true + // regardless of whether SetWritable() is called or not until + // this method is called again with |enforce_write_block| false. + // If |enforce_write_block| is false, SetWritable() may still be needed to + // make IsWriteBlocked() to return true. + virtual void ForceWriteBlocked(bool enforce_write_block) = 0; +}; + +} // namespace quic + +#endif // QUICHE_QUIC_CORE_QUIC_FORCE_BLOCKABLE_PACKET_WRITER_H_
diff --git a/quiche/quic/core/quic_path_context_factory.h b/quiche/quic/core/quic_path_context_factory.h new file mode 100644 index 0000000..0134587 --- /dev/null +++ b/quiche/quic/core/quic_path_context_factory.h
@@ -0,0 +1,51 @@ +// Copyright 2025 The Chromium Authors +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef QUICHE_QUIC_CORE_QUIC_PATH_CONTEXT_FACTORY_H_ +#define QUICHE_QUIC_CORE_QUIC_PATH_CONTEXT_FACTORY_H_ + +#include <memory> + +#include "absl/strings/string_view.h" +#include "quiche/quic/core/quic_path_validator.h" +#include "quiche/quic/platform/api/quic_socket_address.h" +#include "quiche/common/platform/api/quiche_export.h" + +namespace quic { + +// An interface for creating QuicPathValidationContext objects used for probing +// and migrating path. +class QUICHE_EXPORT QuicPathContextFactory { + public: + // An interface to handle creation success and failure given the creation + // might be asynchronous. + class CreationResultDelegate { + public: + virtual ~CreationResultDelegate() = default; + + // Called when the manager successfully created a path context. + // |context| must not be nullptr. + virtual void OnCreationSucceeded( + std::unique_ptr<QuicPathValidationContext> context) = 0; + + // Called when the manager fails to create a path context on |network|. + // |error| will be populated with details. + virtual void OnCreationFailed(QuicNetworkHandle network, + absl::string_view error) = 0; + }; + + virtual ~QuicPathContextFactory() = default; + + // Create a QuicPathValidationContext instance on the given |network| + // connecting to |peer_address|. + // |result_delegate| can be called either in the current call stack or + // asynchronously. + virtual void CreatePathValidationContext( + QuicNetworkHandle network, QuicSocketAddress peer_address, + std::unique_ptr<CreationResultDelegate> result_delegate) = 0; +}; + +} // namespace quic + +#endif // QUICHE_QUIC_CORE_QUIC_PATH_CONTEXT_FACTORY_H_
diff --git a/quiche/quic/core/quic_path_validator.h b/quiche/quic/core/quic_path_validator.h index 37faca3..fffcfb8 100644 --- a/quiche/quic/core/quic_path_validator.h +++ b/quiche/quic/core/quic_path_validator.h
@@ -40,26 +40,50 @@ kMaxValue, }; +// Opaque handle for device-wide connection to a particular network. +// For example an association with a particular WiFi network with a particular +// SSID or a connection to particular cellular network. The meaning of this +// handle is target-dependent. On Android QuicNetworkHandles are equivalent to: +// On Lollipop, the framework's concept of NetIDs (e.g. Network.netId), and +// On Marshmallow and newer releases, network handle (e.g. +// Network.getNetworkHandle()). +using QuicNetworkHandle = int64_t; + +// An invalid NetworkHandle. +inline constexpr QuicNetworkHandle kInvalidNetworkHandle = -1; + // Interface to provide the information of the path to be validated. class QUICHE_EXPORT QuicPathValidationContext { public: QuicPathValidationContext(const QuicSocketAddress& self_address, const QuicSocketAddress& peer_address) - : self_address_(self_address), - peer_address_(peer_address), - effective_peer_address_(peer_address) {} + : QuicPathValidationContext(self_address, peer_address, + kInvalidNetworkHandle) {} QuicPathValidationContext(const QuicSocketAddress& self_address, const QuicSocketAddress& peer_address, - const QuicSocketAddress& effective_peer_address) + QuicNetworkHandle network) + : QuicPathValidationContext(self_address, peer_address, peer_address, + network) {} + + QuicPathValidationContext(const QuicSocketAddress& self_address, + const QuicSocketAddress& peer_address, + const QuicSocketAddress& effective_peer_address, + QuicNetworkHandle network) : self_address_(self_address), peer_address_(peer_address), - effective_peer_address_(effective_peer_address) {} + effective_peer_address_(effective_peer_address), + network_handle_(network) {} virtual ~QuicPathValidationContext() = default; virtual QuicPacketWriter* WriterToUse() = 0; + // Returns true if the writer should be owned by the QUIC connection. + // TODO(danzh): make it a pure virtual interface once + // EnvoyQuicPathValidationContext implements it. + virtual bool ShouldConnectionOwnWriter() const { return true; } + QuicNetworkHandle network() const { return network_handle_; } const QuicSocketAddress& self_address() const { return self_address_; } const QuicSocketAddress& peer_address() const { return peer_address_; } const QuicSocketAddress& effective_peer_address() const { @@ -73,9 +97,13 @@ QuicSocketAddress self_address_; // The address to send PATH_CHALLENGE. QuicSocketAddress peer_address_; - // The actual peer address which is different from |peer_address_| if the peer + // The actual peer address which is different from `peer_address_` if the peer // is behind a proxy. QuicSocketAddress effective_peer_address_; + // See comments above for QuicNetworkHandle. + // `kInvalidNetworkHandle`, if the platform doesn't expose handles for + // networks, e.g. iOS and Linux. It shouldn't referred to in such case. + QuicNetworkHandle network_handle_; }; // Used to validate a path by sending up to 3 PATH_CHALLENGE frames before
diff --git a/quiche/quic/test_tools/quic_test_utils.h b/quiche/quic/test_tools/quic_test_utils.h index 2bc5c12..d08657d 100644 --- a/quiche/quic/test_tools/quic_test_utils.h +++ b/quiche/quic/test_tools/quic_test_utils.h
@@ -1459,7 +1459,7 @@ const QuicSocketAddress& effective_peer_address, QuicPacketWriter* writer) : QuicPathValidationContext(self_address, peer_address, - effective_peer_address), + effective_peer_address, /*network=*/-1), writer_(writer) {} QuicPacketWriter* WriterToUse() override { return writer_; }
diff --git a/quiche/quic/tools/quic_client_base.h b/quiche/quic/tools/quic_client_base.h index 2b9176e..37e10ae 100644 --- a/quiche/quic/tools/quic_client_base.h +++ b/quiche/quic/tools/quic_client_base.h
@@ -39,6 +39,7 @@ alternative_writer_(std::move(writer)) {} QuicPacketWriter* WriterToUse() override { return alternative_writer_.get(); } + bool ShouldConnectionOwnWriter() const override { return false; } QuicPacketWriter* ReleaseWriter() { return alternative_writer_.release(); }