// 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.
#ifndef CHROMEOS_ASH_COMPONENTS_NETWORK_CELLULAR_POLICY_HANDLER_H_
#define CHROMEOS_ASH_COMPONENTS_NETWORK_CELLULAR_POLICY_HANDLER_H_
#include <optional>
#include "base/component_export.h"
#include "base/containers/queue.h"
#include "base/gtest_prod_util.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/scoped_observation.h"
#include "base/timer/timer.h"
#include "base/values.h"
#include "chromeos/ash/components/network/cellular_esim_profile_handler.h"
#include "chromeos/ash/components/network/network_state_handler.h"
#include "chromeos/ash/components/network/network_state_handler_observer.h"
#include "chromeos/ash/components/network/policy_util.h"
#include "net/base/backoff_entry.h"
namespace dbus {
class ObjectPath;
} // namespace dbus
namespace ash {
class CellularESimInstaller;
class CellularInhibitor;
class NetworkProfileHandler;
class NetworkStateHandler;
class ManagedCellularPrefHandler;
class ManagedNetworkConfigurationHandler;
enum class HermesResponseStatus;
// This class encapsulates the logic for installing eSIM profiles configured by
// policy. Installation requests are added to a queue, and each request will be
// retried a fixed number of times with a retry delay between each attempt.
class COMPONENT_EXPORT(CHROMEOS_NETWORK) CellularPolicyHandler
: public HermesManagerClient::Observer,
public CellularESimProfileHandler::Observer,
public NetworkStateHandlerObserver {
public:
CellularPolicyHandler();
CellularPolicyHandler(const CellularPolicyHandler&) = delete;
CellularPolicyHandler& operator=(const CellularPolicyHandler&) = delete;
~CellularPolicyHandler() override;
void Init(CellularESimProfileHandler* cellular_esim_profile_handler,
CellularESimInstaller* cellular_esim_installer,
CellularInhibitor* cellular_inhibitor,
NetworkProfileHandler* network_profile_handler,
NetworkStateHandler* network_state_handler,
ManagedCellularPrefHandler* managed_cellular_pref_handler,
ManagedNetworkConfigurationHandler*
managed_network_configuration_handler);
// Installs the policy eSIM profile defined in |onc_config|. The Shill service
// configuration will be updated to match the GUID provided by |onc_config|
// and to include the ICCID of the installed profile. Installations are
// performed using a queue, and each installation will be retried a fix number
// of times.
void InstallESim(const base::Value::Dict& onc_config);
private:
// This enum allows us to treat a retry differently depending on what the
// reason for retrying is.
enum class InstallRetryReason {
kMissingNonCellularConnectivity = 0,
kInternalError = 1,
kUserError = 2,
kOther = 3,
};
// HermesUserErrorCodes indicate errors made by the user. These can be due
// to bad input or a valid input that has already been successfully processed.
// In such errors, we do not attempt to retry.
const std::array<HermesResponseStatus, 4> kHermesUserErrorCodes = {
HermesResponseStatus::kErrorAlreadyDisabled,
HermesResponseStatus::kErrorAlreadyEnabled,
HermesResponseStatus::kErrorInvalidActivationCode,
HermesResponseStatus::kErrorInvalidIccid};
// HermesInternalErrorCodes indicate system failure during the installation
// process. These error can happen due to code bugs or reasons unrelated to
// user input. In these cases, we retry using an exponental backoff policy to
// attempt the installation again.
const std::array<HermesResponseStatus, 7> kHermesInternalErrorCodes = {
HermesResponseStatus::kErrorUnknown,
HermesResponseStatus::kErrorInternalLpaFailure,
HermesResponseStatus::kErrorWrongState,
HermesResponseStatus::kErrorSendApduFailure,
HermesResponseStatus::kErrorUnexpectedModemManagerState,
HermesResponseStatus::kErrorModemMessageProcessing,
HermesResponseStatus::kErrorPendingProfile};
friend class CellularPolicyHandlerTest;
// Represents policy eSIM install request parameters. Requests are queued and
// processed one at a time. |activation_code| represents the SM-DP+ activation
// code that will be used to install the eSIM profile, and |onc_config| is the
// ONC configuration of the cellular policy.
struct InstallPolicyESimRequest {
InstallPolicyESimRequest(policy_util::SmdxActivationCode activation_code,
const base::Value::Dict& onc_config);
InstallPolicyESimRequest(const InstallPolicyESimRequest&) = delete;
InstallPolicyESimRequest& operator=(const InstallPolicyESimRequest&) =
delete;
~InstallPolicyESimRequest();
const policy_util::SmdxActivationCode activation_code;
base::Value::Dict onc_config;
net::BackoffEntry retry_backoff;
};
// HermesManagerClient::Observer:
void OnAvailableEuiccListChanged() override;
// CellularESimProfileHandler::Observer:
void OnESimProfileListUpdated() override;
// NetworkStateHandlerObserver:
void DeviceListChanged() override;
void OnShuttingDown() override;
// These functions implement the functionality necessary to interact with the
// queue of policy eSIM installation requests.
void ResumeInstallIfNeeded();
void ProcessRequests();
void ScheduleRetryAndProcessRequests(
std::unique_ptr<InstallPolicyESimRequest> request,
InstallRetryReason reason);
void PushRequestAndProcess(std::unique_ptr<InstallPolicyESimRequest> request);
void PopRequest();
void PopAndProcessRequests();
// Attempts to install the first request in the queue. This function is
// responsible for ensuring that both a cellular device and Hermes are
// available. Further, this function will also refresh the list of installed
// eSIM profiles so that we can properly determine whether an eSIM profile has
// already been installed for the request.
void AttemptInstallESim();
// Actually responsible for kicking off the installation process. This
// function will configure the Shill service that corresponds to the profile
// that will be installed, and will ensure that we have non-cellular internet
// connectivity.
void PerformInstallESim(const dbus::ObjectPath& euicc_path,
base::Value::Dict new_shill_properties);
void OnRefreshProfileList(
const dbus::ObjectPath& euicc_path,
base::Value::Dict new_shill_properties,
std::unique_ptr<CellularInhibitor::InhibitLock> inhibit_lock);
void OnConfigureESimService(std::optional<dbus::ObjectPath> service_path);
void OnInhibitedForRefreshSmdxProfiles(
const dbus::ObjectPath& euicc_path,
base::Value::Dict new_shill_properties,
std::unique_ptr<CellularInhibitor::InhibitLock> inhibit_lock);
void OnRefreshSmdxProfiles(
const dbus::ObjectPath& euicc_path,
base::Value::Dict new_shill_properties,
std::unique_ptr<CellularInhibitor::InhibitLock> inhibit_lock,
base::TimeTicks start_time,
HermesResponseStatus status,
const std::vector<dbus::ObjectPath>& profile_paths);
void CompleteRefreshSmdxProfiles(
const dbus::ObjectPath& euicc_path,
base::Value::Dict new_shill_properties,
std::unique_ptr<CellularInhibitor::InhibitLock> inhibit_lock,
HermesResponseStatus status,
const std::vector<dbus::ObjectPath>& profile_paths);
void OnESimProfileInstallAttemptComplete(
HermesResponseStatus hermes_status,
std::optional<dbus::ObjectPath> profile_path,
std::optional<std::string> service_path);
void OnWaitTimeout();
base::Value::Dict GetNewShillProperties();
const policy_util::SmdxActivationCode& GetCurrentActivationCode() const;
std::optional<dbus::ObjectPath> FindExistingMatchingESimProfile(
const std::string& iccid);
// Return std::nullopt if no or empty iccid is found in the policy ONC.
std::optional<std::string> GetIccidFromPolicyONC();
bool HasNonCellularInternetConnectivity();
InstallRetryReason HermesResponseStatusToRetryReason(
HermesResponseStatus status) const;
raw_ptr<CellularESimProfileHandler> cellular_esim_profile_handler_ = nullptr;
raw_ptr<CellularESimInstaller> cellular_esim_installer_ = nullptr;
raw_ptr<CellularInhibitor> cellular_inhibitor_ = nullptr;
raw_ptr<NetworkProfileHandler> network_profile_handler_ = nullptr;
raw_ptr<NetworkStateHandler> network_state_handler_ = nullptr;
base::ScopedObservation<NetworkStateHandler, NetworkStateHandlerObserver>
network_state_handler_observer_{this};
raw_ptr<ManagedCellularPrefHandler, DanglingUntriaged>
managed_cellular_pref_handler_ = nullptr;
raw_ptr<ManagedNetworkConfigurationHandler, DanglingUntriaged>
managed_network_configuration_handler_ = nullptr;
bool is_installing_ = false;
// While Hermes is the source of truth for the EUICC state, Chrome maintains a
// cache of the installed eSIM profiles. To ensure we properly detect when a
// profile has already been installed for a particular request we force a
// refresh of the profile cache before each installation.
bool need_refresh_profile_list_ = true;
base::circular_deque<std::unique_ptr<InstallPolicyESimRequest>>
remaining_install_requests_;
base::OneShotTimer wait_timer_;
base::ScopedObservation<HermesManagerClient, HermesManagerClient::Observer>
hermes_observation_{this};
base::ScopedObservation<CellularESimProfileHandler,
CellularESimProfileHandler::Observer>
cellular_esim_profile_handler_observation_{this};
base::WeakPtrFactory<CellularPolicyHandler> weak_ptr_factory_{this};
};
} // namespace ash
#endif // CHROMEOS_ASH_COMPONENTS_NETWORK_CELLULAR_POLICY_HANDLER_H_
Codebase Browser
chromium