// Copyright 2020 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/dbus/hermes/hermes_euicc_client.h"
#include <optional>
#include "base/functional/bind.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/metrics/histogram_functions.h"
#include "base/observer_list.h"
#include "base/strings/string_util.h"
#include "base/task/sequenced_task_runner.h"
#include "chromeos/ash/components/dbus/hermes/constants.h"
#include "chromeos/ash/components/dbus/hermes/fake_hermes_euicc_client.h"
#include "chromeos/ash/components/dbus/hermes/hermes_response_status.h"
#include "components/device_event_log/device_event_log.h"
#include "dbus/bus.h"
#include "dbus/dbus_result.h"
#include "dbus/message.h"
#include "dbus/object_path.h"
#include "dbus/object_proxy.h"
#include "dbus/property.h"
#include "third_party/cros_system_api/dbus/hermes/dbus-constants.h"
namespace ash {
namespace {
HermesEuiccClient* g_instance = nullptr;
// Activation codes with preceding/trailing whitespace can cause issues when
// provided to Hermes; for example, an SM-DS activation code with trailing
// whitespace may result in profiles not being discovered. This function trims
// this whitespace. This function returns a `std::string` since
// `dbus::MessageWriter::AppendString()` does not respect the length of
// `std::string_view` if it is shorter than the string it is a substring of.
std::string PrepareActivationCodeForHermes(const std::string& activation_code) {
std::string trimmed;
base::TrimWhitespaceASCII(activation_code, base::TrimPositions::TRIM_ALL,
&trimmed);
return trimmed;
}
void MaybeEmitHermesInstallationAttemptStep(
HermesEuiccClient::InstallationAttemptStep step,
size_t attempt) {
if (attempt > 0) {
return;
}
base::UmaHistogramEnumeration(
HermesEuiccClient::kHermesInstallationAttemptStepsHistogram, step);
}
} // namespace
HermesEuiccClient::Properties::Properties(
dbus::ObjectProxy* object_proxy,
const PropertyChangedCallback& callback)
: dbus::PropertySet(object_proxy, hermes::kHermesEuiccInterface, callback) {
RegisterProperty(hermes::euicc::kEidProperty, &eid_);
RegisterProperty(hermes::euicc::kIsActiveProperty, &is_active_);
RegisterProperty(hermes::euicc::kProfilesProperty, &profiles_);
RegisterProperty(hermes::euicc::kPhysicalSlotProperty, &physical_slot_);
}
HermesEuiccClient::Properties::~Properties() = default;
class HermesEuiccClientImpl : public HermesEuiccClient {
public:
explicit HermesEuiccClientImpl(dbus::Bus* bus) : bus_(bus) {}
explicit HermesEuiccClientImpl(const HermesEuiccClient&) = delete;
~HermesEuiccClientImpl() override = default;
using ProxyPropertiesPair =
std::pair<dbus::ObjectProxy*, std::unique_ptr<Properties>>;
using ObjectMap = std::map<dbus::ObjectPath, ProxyPropertiesPair>;
// HermesEuiccClient:
void InstallProfileFromActivationCode(
const dbus::ObjectPath& euicc_path,
const std::string& activation_code,
const std::string& confirmation_code,
InstallCarrierProfileCallback callback) override {
dbus::ObjectProxy* object_proxy = GetOrCreateProperties(euicc_path).first;
// On managed devices, attempts to install profile could happen right after
// boot and it results in a dbus error if hermes hasn't started yet. This
// call waits for hermes to start before attempting installation.
object_proxy->WaitForServiceToBeAvailable(base::BindOnce(
&HermesEuiccClientImpl::InstallProfileFromActivationCodeImpl,
weak_ptr_factory_.GetWeakPtr(), std::move(euicc_path), activation_code,
confirmation_code, std::move(callback), /*attempt=*/0));
base::UmaHistogramEnumeration(
HermesEuiccClient::kHermesInstallationAttemptStepsHistogram,
InstallationAttemptStep::kInstallationRequested);
}
void InstallProfileFromActivationCodeImpl(
const dbus::ObjectPath& euicc_path,
const std::string& activation_code,
const std::string& confirmation_code,
InstallCarrierProfileCallback callback,
int attempt,
bool service_is_available) {
if (!service_is_available) {
NET_LOG(ERROR) << "Failed to wait for D-Bus service to become available";
std::move(callback).Run(HermesResponseStatus::kErrorWrongState,
dbus::DBusResult::kErrorServiceUnknown, nullptr);
MaybeEmitHermesInstallationAttemptStep(
InstallationAttemptStep::kHermesUnavailable, attempt);
return;
}
dbus::ObjectProxy* object_proxy = GetOrCreateProperties(euicc_path).first;
dbus::MethodCall method_call(
hermes::kHermesEuiccInterface,
hermes::euicc::kInstallProfileFromActivationCode);
dbus::MessageWriter writer(&method_call);
writer.AppendString(PrepareActivationCodeForHermes(activation_code));
writer.AppendString(confirmation_code);
object_proxy->CallMethodWithErrorResponse(
&method_call, hermes_constants::kHermesNetworkOperationTimeoutMs,
base::BindOnce(&HermesEuiccClientImpl::OnProfileInstallResponse,
weak_ptr_factory_.GetWeakPtr(), std::move(euicc_path),
activation_code, confirmation_code, std::move(callback),
attempt));
MaybeEmitHermesInstallationAttemptStep(
InstallationAttemptStep::kInstallationStarted, attempt);
}
void InstallPendingProfile(const dbus::ObjectPath& euicc_path,
const dbus::ObjectPath& carrier_profile_path,
const std::string& confirmation_code,
HermesResponseCallback callback) override {
dbus::MethodCall method_call(hermes::kHermesEuiccInterface,
hermes::euicc::kInstallPendingProfile);
dbus::MessageWriter writer(&method_call);
writer.AppendObjectPath(carrier_profile_path);
writer.AppendString(confirmation_code);
dbus::ObjectProxy* object_proxy = GetOrCreateProperties(euicc_path).first;
object_proxy->CallMethodWithErrorResponse(
&method_call, hermes_constants::kHermesNetworkOperationTimeoutMs,
base::BindOnce(&HermesEuiccClientImpl::OnHermesStatusResponse,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
}
void RequestPendingProfiles(const dbus::ObjectPath& euicc_path,
const std::string& root_smds,
HermesResponseCallback callback) override {
dbus::MethodCall method_call(hermes::kHermesEuiccInterface,
hermes::euicc::kRequestPendingProfiles);
dbus::MessageWriter writer(&method_call);
writer.AppendString(root_smds);
dbus::ObjectProxy* object_proxy = GetOrCreateProperties(euicc_path).first;
object_proxy->CallMethodWithErrorResponse(
&method_call, hermes_constants::kHermesNetworkOperationTimeoutMs,
base::BindOnce(&HermesEuiccClientImpl::OnHermesStatusResponse,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
}
void RefreshInstalledProfiles(const dbus::ObjectPath& euicc_path,
bool restore_slot,
HermesResponseCallback callback) override {
dbus::MethodCall method_call(hermes::kHermesEuiccInterface,
hermes::euicc::kRefreshInstalledProfiles);
dbus::MessageWriter writer(&method_call);
writer.AppendBool(restore_slot);
dbus::ObjectProxy* object_proxy = GetOrCreateProperties(euicc_path).first;
object_proxy->CallMethodWithErrorResponse(
&method_call, hermes_constants::kHermesNetworkOperationTimeoutMs,
base::BindOnce(&HermesEuiccClientImpl::OnHermesStatusResponse,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
}
void RefreshSmdxProfiles(const dbus::ObjectPath& euicc_path,
const std::string& activation_code,
bool restore_slot,
RefreshSmdxProfilesCallback callback) override {
dbus::MethodCall method_call(hermes::kHermesEuiccInterface,
hermes::euicc::kRefreshSmdxProfiles);
dbus::MessageWriter writer(&method_call);
writer.AppendString(PrepareActivationCodeForHermes(activation_code));
writer.AppendBool(restore_slot);
dbus::ObjectProxy* object_proxy = GetOrCreateProperties(euicc_path).first;
object_proxy->CallMethodWithErrorResponse(
&method_call, hermes_constants::kHermesNetworkOperationTimeoutMs,
base::BindOnce(&HermesEuiccClientImpl::OnRefreshSmdxProfilesResponse,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
}
void UninstallProfile(const dbus::ObjectPath& euicc_path,
const dbus::ObjectPath& carrier_profile_path,
HermesResponseCallback callback) override {
dbus::MethodCall method_call(hermes::kHermesEuiccInterface,
hermes::euicc::kUninstallProfile);
dbus::MessageWriter writer(&method_call);
writer.AppendObjectPath(carrier_profile_path);
dbus::ObjectProxy* object_proxy = GetOrCreateProperties(euicc_path).first;
object_proxy->CallMethodWithErrorResponse(
&method_call, hermes_constants::kHermesNetworkOperationTimeoutMs,
base::BindOnce(&HermesEuiccClientImpl::OnHermesStatusResponse,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
}
void ResetMemory(const dbus::ObjectPath& euicc_path,
hermes::euicc::ResetOptions reset_option,
HermesResponseCallback callback) override {
dbus::MethodCall method_call(hermes::kHermesEuiccInterface,
hermes::euicc::kResetMemory);
dbus::MessageWriter writer(&method_call);
writer.AppendInt32(static_cast<int32_t>(reset_option));
dbus::ObjectProxy* object_proxy = GetOrCreateProperties(euicc_path).first;
object_proxy->CallMethodWithErrorResponse(
&method_call, hermes_constants::kHermesOperationTimeoutMs,
base::BindOnce(&HermesEuiccClientImpl::OnResetMemoryResponse,
weak_ptr_factory_.GetWeakPtr(), euicc_path,
std::move(callback)));
}
Properties* GetProperties(const dbus::ObjectPath& euicc_path) override {
return GetOrCreateProperties(euicc_path).second.get();
}
TestInterface* GetTestInterface() override { return nullptr; }
HermesEuiccClient& operator=(const HermesEuiccClient&) = delete;
private:
const ProxyPropertiesPair& GetOrCreateProperties(
const dbus::ObjectPath& euicc_path) {
auto it = object_map_.find(euicc_path);
if (it != object_map_.end())
return it->second;
dbus::ObjectProxy* object_proxy =
bus_->GetObjectProxy(hermes::kHermesServiceName, euicc_path);
auto properties = std::make_unique<Properties>(
object_proxy,
base::BindRepeating(&HermesEuiccClientImpl::OnPropertyChanged,
weak_ptr_factory_.GetWeakPtr(), euicc_path));
properties->ConnectSignals();
properties->GetAll();
object_map_[euicc_path] =
std::make_pair(object_proxy, std::move(properties));
return object_map_[euicc_path];
}
void OnPropertyChanged(const dbus::ObjectPath& euicc_path,
const std::string& property_name) {
for (auto& observer : observers()) {
observer.OnEuiccPropertyChanged(euicc_path, property_name);
}
}
void OnProfileInstallResponse(const dbus::ObjectPath& euicc_path,
const std::string& activation_code,
const std::string& confirmation_code,
InstallCarrierProfileCallback callback,
int attempt,
dbus::Response* response,
dbus::ErrorResponse* error_response) {
if (error_response) {
NET_LOG(ERROR) << "Profile install failed with error: "
<< error_response->GetErrorName();
if (HermesResponseStatusFromErrorName(error_response->GetErrorName()) ==
HermesResponseStatus::kErrorUnknownResponse &&
attempt < kMaxInstallAttempts) {
base::SequencedTaskRunner::GetCurrentDefault()->PostDelayedTask(
FROM_HERE,
base::BindOnce(
&HermesEuiccClientImpl::InstallProfileFromActivationCodeImpl,
weak_ptr_factory_.GetWeakPtr(), std::move(euicc_path),
activation_code, confirmation_code, std::move(callback),
attempt + 1, /*service_is_available=*/true),
kInstallRetryDelay);
return;
}
std::move(callback).Run(
HermesResponseStatusFromErrorName(error_response->GetErrorName()),
GetResult(error_response), nullptr);
base::UmaHistogramEnumeration(
HermesEuiccClient::kHermesInstallationAttemptStepsHistogram,
InstallationAttemptStep::kInstallationFailed);
return;
}
if (!response) {
// No Error or Response received.
NET_LOG(ERROR) << "Carrier profile installation Error: No error or "
"response received.";
std::move(callback).Run(HermesResponseStatus::kErrorNoResponse,
dbus::DBusResult::kErrorNoReply, nullptr);
base::UmaHistogramEnumeration(
HermesEuiccClient::kHermesInstallationAttemptStepsHistogram,
InstallationAttemptStep::kInstallationNoResponse);
return;
}
dbus::MessageReader reader(response);
dbus::ObjectPath profile_path;
reader.PopObjectPath(&profile_path);
std::move(callback).Run(HermesResponseStatus::kSuccess,
dbus::DBusResult::kSuccess, &profile_path);
base::UmaHistogramEnumeration(
HermesEuiccClient::kHermesInstallationAttemptStepsHistogram,
InstallationAttemptStep::kInstallationSucceeded);
}
void OnRefreshSmdxProfilesResponse(RefreshSmdxProfilesCallback callback,
dbus::Response* response,
dbus::ErrorResponse* error_response) {
std::vector<dbus::ObjectPath> profile_paths;
if (error_response) {
NET_LOG(ERROR) << "Refresh SM-DX profiles failed with error: "
<< error_response->GetErrorName();
std::move(callback).Run(
HermesResponseStatusFromErrorName(error_response->GetErrorName()),
profile_paths);
return;
}
if (!response) {
// No Error or Response received.
NET_LOG(ERROR) << "Refresh SM-DX profiles Error: No error or "
"response received.";
std::move(callback).Run(HermesResponseStatus::kErrorNoResponse,
profile_paths);
return;
}
dbus::MessageReader reader(response);
reader.PopArrayOfObjectPaths(&profile_paths);
std::move(callback).Run(HermesResponseStatus::kSuccess, profile_paths);
}
void OnHermesStatusResponse(HermesResponseCallback callback,
dbus::Response* response,
dbus::ErrorResponse* error_response) {
if (error_response) {
NET_LOG(ERROR) << "Hermes Euicc operation failed with error: "
<< error_response->GetErrorName();
std::move(callback).Run(
HermesResponseStatusFromErrorName(error_response->GetErrorName()));
return;
}
std::move(callback).Run(HermesResponseStatus::kSuccess);
}
void OnResetMemoryResponse(const dbus::ObjectPath& euicc_path,
HermesResponseCallback callback,
dbus::Response* response,
dbus::ErrorResponse* error_response) {
OnHermesStatusResponse(std::move(callback), response, error_response);
if (error_response) {
return;
}
for (auto& observer : observers()) {
observer.OnEuiccReset(euicc_path);
}
}
raw_ptr<dbus::Bus> bus_;
ObjectMap object_map_;
base::WeakPtrFactory<HermesEuiccClientImpl> weak_ptr_factory_{this};
};
HermesEuiccClient::HermesEuiccClient() {
DCHECK(!g_instance);
g_instance = this;
}
HermesEuiccClient::~HermesEuiccClient() {
DCHECK_EQ(g_instance, this);
g_instance = nullptr;
}
void HermesEuiccClient::AddObserver(Observer* observer) {
DCHECK(observer);
observers_.AddObserver(observer);
}
void HermesEuiccClient::RemoveObserver(Observer* observer) {
DCHECK(observer);
observers_.RemoveObserver(observer);
}
// static
void HermesEuiccClient::Initialize(dbus::Bus* bus) {
DCHECK(bus);
DCHECK(!g_instance);
new HermesEuiccClientImpl(bus);
}
// static
void HermesEuiccClient::InitializeFake() {
new FakeHermesEuiccClient();
}
// static
void HermesEuiccClient::Shutdown() {
DCHECK(g_instance);
delete g_instance;
}
// static
HermesEuiccClient* HermesEuiccClient::Get() {
return g_instance;
}
} // namespace ash
Codebase Browser
chromium