// Copyright 2019 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/sync_wifi/synced_network_updater_impl.h"
#include "base/functional/bind.h"
#include "base/values.h"
#include "chromeos/ash/components/network/network_configuration_handler.h"
#include "chromeos/ash/components/network/network_event_log.h"
#include "chromeos/ash/components/network/network_handler.h"
#include "chromeos/ash/components/network/network_metadata_store.h"
#include "chromeos/ash/components/network/network_profile_handler.h"
#include "chromeos/ash/components/network/network_state.h"
#include "chromeos/ash/components/sync_wifi/network_type_conversions.h"
#include "chromeos/ash/components/timer_factory/timer_factory.h"
#include "components/device_event_log/device_event_log.h"
#include "components/proxy_config/proxy_config_dictionary.h"
#include "third_party/cros_system_api/dbus/shill/dbus-constants.h"
namespace ash::network_config {
namespace mojom = ::chromeos::network_config::mojom;
}
namespace ash::sync_wifi {
namespace {
const int kMaxRetries = 3;
constexpr base::TimeDelta kTimeout = base::Minutes(1);
} // namespace
SyncedNetworkUpdaterImpl::SyncedNetworkUpdaterImpl(
std::unique_ptr<PendingNetworkConfigurationTracker> tracker,
network_config::mojom::CrosNetworkConfig* cros_network_config,
ash::timer_factory::TimerFactory* timer_factory,
SyncedNetworkMetricsLogger* metrics_logger)
: tracker_(std::move(tracker)),
cros_network_config_(cros_network_config),
timer_factory_(timer_factory),
metrics_logger_(metrics_logger) {
cros_network_config_->AddObserver(
cros_network_config_observer_receiver_.BindNewPipeAndPassRemote());
// Load the current list of networks.
OnNetworkStateListChanged();
std::vector<PendingNetworkConfigurationUpdate> updates =
tracker_->GetPendingUpdates();
for (const PendingNetworkConfigurationUpdate& update : updates)
Retry(update);
}
SyncedNetworkUpdaterImpl::~SyncedNetworkUpdaterImpl() = default;
void SyncedNetworkUpdaterImpl::AddOrUpdateNetwork(
const sync_pb::WifiConfigurationSpecifics& specifics) {
auto id = NetworkIdentifier::FromProto(specifics);
std::string change_guid = tracker_->TrackPendingUpdate(id, specifics);
StartAddOrUpdateOperation(change_guid, id, specifics);
}
void SyncedNetworkUpdaterImpl::StartAddOrUpdateOperation(
const std::string& change_guid,
const NetworkIdentifier& id,
const sync_pb::WifiConfigurationSpecifics& specifics) {
network_config::mojom::NetworkStatePropertiesPtr existing_network =
FindMojoNetwork(id);
network_config::mojom::ConfigPropertiesPtr config =
MojoNetworkConfigFromProto(specifics);
// We can get into this state when the SSID's are improperly encoded hex
// strings, which causes the proto conversion above to return a nullptr.
//
// TODO(b/270151177) : Dig into to understand why we are getting improperly
// encoded SSIDs.
if (!config) {
NET_LOG(ERROR) << "Failed to generate local network config";
metrics_logger_->RecordApplyGenerateLocalNetworkConfig(/*success=*/false);
return;
}
metrics_logger_->RecordApplyGenerateLocalNetworkConfig(/*success=*/true);
StartTimer(change_guid, id);
if (existing_network) {
NET_LOG(EVENT) << "Updating existing network "
<< NetworkGuidId(existing_network->guid);
if (network_guid_to_updates_counter_.contains(existing_network->guid))
network_guid_to_updates_counter_[existing_network->guid]++;
else
network_guid_to_updates_counter_[existing_network->guid] = 1;
cros_network_config_->SetProperties(
existing_network->guid, std::move(config),
base::BindOnce(&SyncedNetworkUpdaterImpl::OnSetPropertiesResult,
weak_ptr_factory_.GetWeakPtr(), change_guid,
existing_network->guid, specifics));
return;
}
NET_LOG(EVENT) << "Adding new network configuration.";
cros_network_config_->ConfigureNetwork(
std::move(config), /*shared=*/false,
base::BindOnce(&SyncedNetworkUpdaterImpl::OnConfigureNetworkResult,
weak_ptr_factory_.GetWeakPtr(), change_guid, specifics));
}
void SyncedNetworkUpdaterImpl::RemoveNetwork(const NetworkIdentifier& id) {
network_config::mojom::NetworkStatePropertiesPtr network =
FindMojoNetwork(id);
if (!network) {
NET_LOG(EVENT) << "Network not found, nothing to remove.";
return;
}
NET_LOG(EVENT) << "Removing network " << NetworkGuidId(network->guid);
std::string change_guid =
tracker_->TrackPendingUpdate(id, /*specifics=*/std::nullopt);
StartDeleteOperation(change_guid, id, network->guid);
}
void SyncedNetworkUpdaterImpl::StartDeleteOperation(
const std::string& change_guid,
const NetworkIdentifier& id,
std::string guid) {
StartTimer(change_guid, id);
cros_network_config_->ForgetNetwork(
guid, base::BindOnce(&SyncedNetworkUpdaterImpl::OnForgetNetworkResult,
weak_ptr_factory_.GetWeakPtr(), change_guid, id));
}
bool SyncedNetworkUpdaterImpl::IsUpdateInProgress(
const std::string& network_guid) {
return network_guid_to_updates_counter_.contains(network_guid) &&
network_guid_to_updates_counter_[network_guid] > 0;
}
network_config::mojom::NetworkStatePropertiesPtr
SyncedNetworkUpdaterImpl::FindMojoNetwork(const NetworkIdentifier& id) {
for (const network_config::mojom::NetworkStatePropertiesPtr& network :
networks_) {
if (id == NetworkIdentifier::FromMojoNetwork(network))
return network.Clone();
}
return nullptr;
}
void SyncedNetworkUpdaterImpl::OnNetworkStateListChanged() {
cros_network_config_->GetNetworkStateList(
network_config::mojom::NetworkFilter::New(
network_config::mojom::FilterType::kConfigured,
network_config::mojom::NetworkType::kWiFi,
/*limit=*/0),
base::BindOnce(&SyncedNetworkUpdaterImpl::OnGetNetworkList,
base::Unretained(this)));
}
void SyncedNetworkUpdaterImpl::OnGetNetworkList(
std::vector<network_config::mojom::NetworkStatePropertiesPtr> networks) {
networks_ = std::move(networks);
}
void SyncedNetworkUpdaterImpl::OnConfigureNetworkResult(
const std::string& change_guid,
const sync_pb::WifiConfigurationSpecifics& proto,
const std::optional<std::string>& network_guid,
const std::string& error_message) {
auto id = NetworkIdentifier::FromProto(proto);
if (network_guid) {
NET_LOG(EVENT) << "Successfully configured network "
<< NetworkGuidId(*network_guid);
NetworkMetadataStore* metadata_store =
NetworkHandler::Get()->network_metadata_store();
metadata_store->SetIsConfiguredBySync(*network_guid);
metadata_store->SetLastConnectedTimestamp(
*network_guid, base::Milliseconds(proto.last_connected_timestamp()));
} else {
NET_LOG(ERROR) << "Failed to configure network "
<< NetworkId(NetworkStateFromNetworkIdentifier(id))
<< " because: " << error_message;
metrics_logger_->RecordApplyNetworkFailureReason(
ApplyNetworkFailureReason::kFailedToAdd, error_message);
}
HandleShillResult(change_guid, id, network_guid.has_value());
}
void SyncedNetworkUpdaterImpl::OnSetPropertiesResult(
const std::string& change_guid,
const std::string& network_guid,
const sync_pb::WifiConfigurationSpecifics& proto,
bool is_success,
const std::string& error_message) {
if (is_success) {
NET_LOG(EVENT) << "Successfully updated network "
<< NetworkGuidId(network_guid);
NetworkMetadataStore* metadata_store =
NetworkHandler::Get()->network_metadata_store();
metadata_store->SetIsConfiguredBySync(network_guid);
metadata_store->SetLastConnectedTimestamp(
network_guid, base::Milliseconds(proto.last_connected_timestamp()));
} else {
NET_LOG(ERROR) << "Failed to update network "
<< NetworkGuidId(network_guid);
metrics_logger_->RecordApplyNetworkFailureReason(
ApplyNetworkFailureReason::kFailedToUpdate, error_message);
}
if (network_guid_to_updates_counter_.contains(network_guid))
network_guid_to_updates_counter_[network_guid]--;
HandleShillResult(change_guid, NetworkIdentifier::FromProto(proto),
is_success);
}
void SyncedNetworkUpdaterImpl::OnForgetNetworkResult(
const std::string& change_guid,
const NetworkIdentifier& id,
bool is_success) {
if (is_success) {
NET_LOG(EVENT) << "Successfully deleted network for change " << change_guid;
} else {
NET_LOG(ERROR) << "Failed to remove network for change " << change_guid;
metrics_logger_->RecordApplyNetworkFailureReason(
ApplyNetworkFailureReason::kFailedToRemove, "");
}
HandleShillResult(change_guid, id, is_success);
}
void SyncedNetworkUpdaterImpl::HandleShillResult(const std::string& change_guid,
const NetworkIdentifier& id,
bool is_success) {
change_guid_to_timer_map_.erase(change_guid);
if (!tracker_->GetPendingUpdate(change_guid, id)) {
NET_LOG(EVENT)
<< "Update to network with change_guid " << change_guid
<< " is no longer pending. This is likely because the change was"
" preempted by another update to the same network.";
return;
}
if (is_success) {
tracker_->MarkComplete(change_guid, id);
metrics_logger_->RecordApplyNetworkSuccess();
return;
}
tracker_->IncrementCompletedAttempts(change_guid, id);
std::optional<PendingNetworkConfigurationUpdate> update =
tracker_->GetPendingUpdate(change_guid, id);
if (update->completed_attempts() >= kMaxRetries) {
NET_LOG(ERROR) << "Ran out of retries for change " << change_guid
<< " to network "
<< NetworkId(NetworkStateFromNetworkIdentifier(id));
tracker_->MarkComplete(change_guid, id);
metrics_logger_->RecordApplyNetworkFailed();
return;
}
Retry(*update);
}
void SyncedNetworkUpdaterImpl::CleanupUpdate(const std::string& change_guid,
const NetworkIdentifier& id) {
tracker_->MarkComplete(change_guid, id);
}
void SyncedNetworkUpdaterImpl::Retry(
const PendingNetworkConfigurationUpdate& update) {
if (update.IsDeleteOperation()) {
network_config::mojom::NetworkStatePropertiesPtr network =
FindMojoNetwork(update.id());
if (!network) {
tracker_->MarkComplete(update.change_guid(), update.id());
return;
}
StartDeleteOperation(update.change_guid(), update.id(), network->guid);
return;
}
StartAddOrUpdateOperation(update.change_guid(), update.id(),
update.specifics().value());
}
void SyncedNetworkUpdaterImpl::StartTimer(const std::string& change_guid,
const NetworkIdentifier& id) {
change_guid_to_timer_map_[change_guid] = timer_factory_->CreateOneShotTimer();
change_guid_to_timer_map_[change_guid]->Start(
FROM_HERE, kTimeout,
base::BindOnce(&SyncedNetworkUpdaterImpl::OnTimeout,
base::Unretained(this), change_guid, id));
}
void SyncedNetworkUpdaterImpl::OnTimeout(const std::string& change_guid,
const NetworkIdentifier& id) {
NET_LOG(ERROR) << "Failed to update network, operation timed out.";
metrics_logger_->RecordApplyNetworkFailureReason(
ApplyNetworkFailureReason::kTimedout, "");
HandleShillResult(change_guid, id, /*is_success=*/false);
}
} // namespace ash::sync_wifi
Codebase Browser
chromium