// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/ash/components/network/cellular_esim_installer.h"
#include <optional>
#include "ash/constants/ash_features.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/histogram_macros.h"
#include "base/notreached.h"
#include "base/time/time.h"
#include "chromeos/ash/components/dbus/hermes/hermes_euicc_client.h"
#include "chromeos/ash/components/dbus/hermes/hermes_profile_client.h"
#include "chromeos/ash/components/dbus/hermes/hermes_response_status.h"
#include "chromeos/ash/components/dbus/shill/shill_manager_client.h"
#include "chromeos/ash/components/network/cellular_connection_handler.h"
#include "chromeos/ash/components/network/cellular_utils.h"
#include "chromeos/ash/components/network/hermes_metrics_util.h"
#include "chromeos/ash/components/network/metrics/cellular_network_metrics_logger.h"
#include "chromeos/ash/components/network/network_connection_handler.h"
#include "chromeos/ash/components/network/network_event_log.h"
#include "chromeos/ash/components/network/network_profile_handler.h"
#include "chromeos/ash/components/network/network_state_handler.h"
#include "chromeos/ash/components/network/network_ui_data.h"
#include "chromeos/ash/components/network/shill_property_util.h"
#include "chromeos/ash/services/cellular_setup/public/mojom/esim_manager.mojom.h"
#include "components/onc/onc_constants.h"
#include "third_party/cros_system_api/dbus/shill/dbus-constants.h"
using ash::cellular_setup::mojom::ProfileInstallMethod;
namespace ash {
namespace {
void AppendRequiredCellularProperties(
const dbus::ObjectPath& euicc_path,
const dbus::ObjectPath& profile_path,
const NetworkProfile* profile,
base::Value::Dict* shill_properties_to_update) {
HermesEuiccClient::Properties* euicc_properties =
HermesEuiccClient::Get()->GetProperties(euicc_path);
HermesProfileClient::Properties* profile_properties =
HermesProfileClient::Get()->GetProperties(profile_path);
shill_properties_to_update->Set(shill::kTypeProperty, shill::kTypeCellular);
shill_properties_to_update->Set(shill::kProfileProperty, profile->path);
// Insert ICCID and EID to the shill properties.
shill_properties_to_update->Set(shill::kIccidProperty,
profile_properties->iccid().value());
shill_properties_to_update->Set(shill::kEidProperty,
euicc_properties->eid().value());
// Use ICCID as GUID if no GUID found in the given properties.
if (!shill_properties_to_update->FindString(shill::kGuidProperty)) {
shill_properties_to_update->Set(shill::kGuidProperty,
profile_properties->iccid().value());
}
}
bool IsManagedNetwork(const base::Value::Dict& new_shill_properties) {
std::unique_ptr<NetworkUIData> ui_data =
shill_property_util::GetUIDataFromProperties(new_shill_properties);
return ui_data && (ui_data->onc_source() == ::onc::ONC_SOURCE_DEVICE_POLICY ||
ui_data->onc_source() == ::onc::ONC_SOURCE_USER_POLICY);
}
CellularNetworkMetricsLogger::ESimUserInstallMethod ComputeUserInstallMethod(
ProfileInstallMethod install_method) {
switch (install_method) {
case ProfileInstallMethod::kViaSmds:
return CellularNetworkMetricsLogger::ESimUserInstallMethod::kViaSmds;
case ProfileInstallMethod::kViaQrCodeAfterSmds:
return CellularNetworkMetricsLogger::ESimUserInstallMethod::
kViaQrCodeAfterSmds;
case ProfileInstallMethod::kViaQrCodeSkippedSmds:
return CellularNetworkMetricsLogger::ESimUserInstallMethod::
kViaQrCodeSkippedSmds;
case ProfileInstallMethod::kViaActivationCodeAfterSmds:
return CellularNetworkMetricsLogger::ESimUserInstallMethod::
kViaActivationCodeAfterSmds;
case ProfileInstallMethod::kViaActivationCodeSkippedSmds:
return CellularNetworkMetricsLogger::ESimUserInstallMethod::
kViaActivationCodeSkippedSmds;
}
NOTREACHED();
}
CellularNetworkMetricsLogger::ESimPolicyInstallMethod
ComputePolicyInstallMethod(ProfileInstallMethod install_method) {
switch (install_method) {
case ProfileInstallMethod::kViaSmds:
return CellularNetworkMetricsLogger::ESimPolicyInstallMethod::kViaSmds;
// When installing an eSIM profile via policy we do not have the different
// methods that are possible via the consumer flow. Default all SM-DP+
// installation methods to |kViaSmdp|.
case ProfileInstallMethod::kViaQrCodeAfterSmds:
[[fallthrough]];
case ProfileInstallMethod::kViaQrCodeSkippedSmds:
[[fallthrough]];
case ProfileInstallMethod::kViaActivationCodeAfterSmds:
[[fallthrough]];
case ProfileInstallMethod::kViaActivationCodeSkippedSmds:
return CellularNetworkMetricsLogger::ESimPolicyInstallMethod::kViaSmdp;
}
NOTREACHED();
}
} // namespace
// static
void CellularESimInstaller::RecordInstallESimProfileResult(
std::optional<HermesResponseStatus> status,
bool is_managed,
bool is_initial_install,
ProfileInstallMethod install_method) {
const bool is_user_error =
status.has_value() &&
CellularNetworkMetricsLogger::HermesResponseStatusIsUserError(*status);
const CellularNetworkMetricsLogger::ESimOperationResult result =
CellularNetworkMetricsLogger::ComputeESimOperationResult(status);
if (is_managed) {
CellularNetworkMetricsLogger::LogESimPolicyInstallResult(
ComputePolicyInstallMethod(install_method), result, is_initial_install,
is_user_error);
return;
}
CellularNetworkMetricsLogger::LogESimUserInstallResult(
ComputeUserInstallMethod(install_method), result, is_user_error);
}
CellularESimInstaller::CellularESimInstaller() = default;
CellularESimInstaller::~CellularESimInstaller() = default;
void CellularESimInstaller::Init(
CellularConnectionHandler* cellular_connection_handler,
CellularInhibitor* cellular_inhibitor,
NetworkConnectionHandler* network_connection_handler,
NetworkProfileHandler* network_profile_handler,
NetworkStateHandler* network_state_handler) {
cellular_connection_handler_ = cellular_connection_handler;
cellular_inhibitor_ = cellular_inhibitor;
network_connection_handler_ = network_connection_handler;
network_profile_handler_ = network_profile_handler;
network_state_handler_ = network_state_handler;
}
void CellularESimInstaller::InstallProfileFromActivationCode(
const std::string& activation_code,
const std::string& confirmation_code,
const dbus::ObjectPath& euicc_path,
base::Value::Dict new_shill_properties,
InstallProfileFromActivationCodeCallback callback,
bool is_initial_install,
ProfileInstallMethod install_method) {
cellular_inhibitor_->InhibitCellularScanning(
CellularInhibitor::InhibitReason::kInstallingProfile,
base::BindOnce(
&CellularESimInstaller::PerformInstallProfileFromActivationCode,
weak_ptr_factory_.GetWeakPtr(), activation_code, confirmation_code,
euicc_path, std::move(new_shill_properties), is_initial_install,
install_method, std::move(callback)));
}
void CellularESimInstaller::PerformInstallProfileFromActivationCode(
const std::string& activation_code,
const std::string& confirmation_code,
const dbus::ObjectPath& euicc_path,
base::Value::Dict new_shill_properties,
bool is_initial_install,
ProfileInstallMethod install_method,
InstallProfileFromActivationCodeCallback callback,
std::unique_ptr<CellularInhibitor::InhibitLock> inhibit_lock) {
if (!inhibit_lock) {
NET_LOG(ERROR) << "Error inhibiting cellular device";
RecordInstallESimProfileResult(
/*status=*/std::nullopt, IsManagedNetwork(new_shill_properties),
is_initial_install, install_method);
std::move(callback).Run(HermesResponseStatus::kErrorWrongState,
/*profile_path=*/std::nullopt,
/*service_path=*/std::nullopt);
return;
}
// TODO(crbug.com/1186682) Add a check for activation codes that are currently
// being installed to prevent multiple attempts for the same activation code.
NET_LOG(USER) << "Attempting installation with code " << activation_code;
HermesEuiccClient::Get()->InstallProfileFromActivationCode(
euicc_path, activation_code, confirmation_code,
base::BindOnce(&CellularESimInstaller::OnProfileInstallResult,
weak_ptr_factory_.GetWeakPtr(), std::move(callback),
std::move(inhibit_lock), euicc_path,
std::move(new_shill_properties), is_initial_install,
install_method, base::Time::Now()));
}
void CellularESimInstaller::OnProfileInstallResult(
InstallProfileFromActivationCodeCallback callback,
std::unique_ptr<CellularInhibitor::InhibitLock> inhibit_lock,
const dbus::ObjectPath& euicc_path,
const base::Value::Dict& new_shill_properties,
bool is_initial_install,
ProfileInstallMethod install_method,
const base::Time installation_start_time,
HermesResponseStatus status,
dbus::DBusResult dbusResult,
const dbus::ObjectPath* profile_path) {
hermes_metrics::LogInstallViaQrCodeResult(status, dbusResult,
is_initial_install);
RecordInstallESimProfileResult(status, IsManagedNetwork(new_shill_properties),
is_initial_install, install_method);
if (status != HermesResponseStatus::kSuccess) {
NET_LOG(ERROR) << "Error Installing profile status=" << status;
std::move(callback).Run(status, /*profile_path=*/std::nullopt,
/*service_path=*/std::nullopt);
return;
}
UMA_HISTOGRAM_LONG_TIMES_100(
"Network.Cellular.ESim.ProfileDownload.ActivationCode.Latency",
base::Time::Now() - installation_start_time);
pending_inhibit_locks_.emplace(*profile_path, std::move(inhibit_lock));
ConfigureESimService(
new_shill_properties, euicc_path, *profile_path,
base::BindOnce(&CellularESimInstaller::EnableProfile,
weak_ptr_factory_.GetWeakPtr(), std::move(callback),
euicc_path, *profile_path));
}
void CellularESimInstaller::ConfigureESimService(
const base::Value::Dict& new_shill_properties,
const dbus::ObjectPath& euicc_path,
const dbus::ObjectPath& profile_path,
ConfigureESimServiceCallback callback) {
const NetworkProfile* profile =
cellular_utils::GetCellularProfile(network_profile_handler_);
if (!profile) {
NET_LOG(ERROR)
<< "Error configuring eSIM profile. Default profile not initialized.";
std::move(callback).Run(
/*service_path=*/std::nullopt);
return;
}
base::Value::Dict properties_to_set = new_shill_properties.Clone();
AppendRequiredCellularProperties(euicc_path, profile_path, profile,
&properties_to_set);
NET_LOG(EVENT)
<< "Creating shill configuration for eSim profile with properties: "
<< properties_to_set;
auto callback_split = base::SplitOnceCallback(std::move(callback));
ShillManagerClient::Get()->ConfigureServiceForProfile(
dbus::ObjectPath(profile->path), properties_to_set,
base::BindOnce(
&CellularESimInstaller::OnShillConfigurationCreationSuccess,
weak_ptr_factory_.GetWeakPtr(), std::move(callback_split.first)),
base::BindOnce(
&CellularESimInstaller::OnShillConfigurationCreationFailure,
weak_ptr_factory_.GetWeakPtr(), std::move(callback_split.second)));
}
void CellularESimInstaller::OnShillConfigurationCreationSuccess(
ConfigureESimServiceCallback callback,
const dbus::ObjectPath& service_path) {
NET_LOG(EVENT)
<< "Successfully creating shill configuration on service path: "
<< service_path.value();
std::move(callback).Run(service_path);
}
void CellularESimInstaller::OnShillConfigurationCreationFailure(
ConfigureESimServiceCallback callback,
const std::string& error_name,
const std::string& error_message) {
NET_LOG(ERROR) << "Create shill configuration failed, error:" << error_name
<< ", message: " << error_message;
std::move(callback).Run(/*service_path=*/std::nullopt);
}
void CellularESimInstaller::EnableProfile(
InstallProfileFromActivationCodeCallback callback,
const dbus::ObjectPath& euicc_path,
const dbus::ObjectPath& profile_path,
std::optional<dbus::ObjectPath> service_path) {
auto it = pending_inhibit_locks_.find(profile_path);
DCHECK(it != pending_inhibit_locks_.end());
auto callback_split = base::SplitOnceCallback(std::move(callback));
cellular_connection_handler_
->PrepareNewlyInstalledCellularNetworkForConnection(
euicc_path, profile_path, std::move(it->second),
base::BindOnce(&CellularESimInstaller::
OnPrepareCellularNetworkForConnectionSuccess,
weak_ptr_factory_.GetWeakPtr(), profile_path,
std::move(callback_split.first)),
base::BindOnce(&CellularESimInstaller::
OnPrepareCellularNetworkForConnectionFailure,
weak_ptr_factory_.GetWeakPtr(), profile_path,
std::move(callback_split.second)));
pending_inhibit_locks_.erase(it);
}
void CellularESimInstaller::OnPrepareCellularNetworkForConnectionSuccess(
const dbus::ObjectPath& profile_path,
InstallProfileFromActivationCodeCallback callback,
const std::string& service_path,
bool auto_connected) {
NET_LOG(EVENT) << "Successfully enabled installed profile on service path: "
<< service_path;
const NetworkState* network_state =
network_state_handler_->GetNetworkState(service_path);
if (!network_state) {
HandleNewProfileEnableFailure(std::move(callback), profile_path,
service_path,
NetworkConnectionHandler::kErrorNotFound);
return;
}
if (!network_state->IsConnectingOrConnected()) {
// The connection could fail but the user will be notified of connection
// failures separately.
network_connection_handler_->ConnectToNetwork(
service_path,
/*success_callback=*/base::DoNothing(),
/*error_callback=*/base::DoNothing(),
/*check_error_state=*/false, ConnectCallbackMode::ON_STARTED);
}
std::move(callback).Run(HermesResponseStatus::kSuccess, profile_path,
service_path);
}
void CellularESimInstaller::OnPrepareCellularNetworkForConnectionFailure(
const dbus::ObjectPath& profile_path,
InstallProfileFromActivationCodeCallback callback,
const std::string& service_path,
const std::string& error_name) {
HandleNewProfileEnableFailure(std::move(callback), profile_path, service_path,
error_name);
}
void CellularESimInstaller::HandleNewProfileEnableFailure(
InstallProfileFromActivationCodeCallback callback,
const dbus::ObjectPath& profile_path,
const std::string& service_path,
const std::string& error_name) {
NET_LOG(ERROR) << "Error enabling newly created profile path="
<< profile_path.value() << ", service path=" << service_path
<< ", error_name=" << error_name;
// Propagate |profile_path| and |service_path| so that the code that
// initiated the installation can handle the case where the profile was
// successfully installed, but the installation process failed for some
// other reason e.g. failed to enable the profile.
std::move(callback).Run(HermesResponseStatus::kErrorWrongState,
/*profile_path=*/profile_path,
/*service_path=*/service_path);
}
} // namespace ash
Codebase Browser
chromium