| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chromeos/network/prohibited_technologies_handler.h" |
| |
| #include <set> |
| #include <vector> |
| |
| #include "chromeos/network/managed_network_configuration_handler.h" |
| #include "chromeos/network/network_state_handler.h" |
| #include "chromeos/network/network_util.h" |
| #include "third_party/cros_system_api/dbus/service_constants.h" |
| |
| namespace chromeos { |
| |
| ProhibitedTechnologiesHandler::ProhibitedTechnologiesHandler() = default; |
| |
| ProhibitedTechnologiesHandler::~ProhibitedTechnologiesHandler() { |
| if (managed_network_configuration_handler_) |
| managed_network_configuration_handler_->RemoveObserver(this); |
| if (LoginState::IsInitialized()) |
| LoginState::Get()->RemoveObserver(this); |
| } |
| |
| void ProhibitedTechnologiesHandler::Init( |
| ManagedNetworkConfigurationHandler* managed_network_configuration_handler, |
| NetworkStateHandler* network_state_handler) { |
| if (LoginState::IsInitialized()) |
| LoginState::Get()->AddObserver(this); |
| |
| managed_network_configuration_handler_ = |
| managed_network_configuration_handler; |
| if (managed_network_configuration_handler_) |
| managed_network_configuration_handler_->AddObserver(this); |
| network_state_handler_ = network_state_handler; |
| |
| // Clear the list of prohibited network technologies. As a user logout always |
| // triggers a browser process restart, Init() is always invoked to reallow any |
| // network technology forbidden for the previous user. |
| network_state_handler_->SetProhibitedTechnologies(std::vector<std::string>()); |
| |
| if (LoginState::IsInitialized()) |
| LoggedInStateChanged(); |
| } |
| |
| void ProhibitedTechnologiesHandler::LoggedInStateChanged() { |
| user_logged_in_ = LoginState::Get()->IsUserLoggedIn(); |
| EnforceProhibitedTechnologies(); |
| } |
| |
| void ProhibitedTechnologiesHandler::PoliciesChanged( |
| const std::string& userhash) {} |
| |
| void ProhibitedTechnologiesHandler::PoliciesApplied( |
| const std::string& userhash) { |
| if (userhash.empty()) |
| return; |
| user_policy_applied_ = true; |
| EnforceProhibitedTechnologies(); |
| } |
| |
| void ProhibitedTechnologiesHandler::SetProhibitedTechnologies( |
| const base::ListValue* prohibited_list) { |
| // Build up prohibited network type list and save it for furthur use when |
| // enforced |
| session_prohibited_technologies_.clear(); |
| for (const auto& item : *prohibited_list) { |
| std::string prohibited_technology; |
| bool item_is_string = item.GetAsString(&prohibited_technology); |
| DCHECK(item_is_string); |
| std::string translated_tech = |
| network_util::TranslateONCTypeToShill(prohibited_technology); |
| if (!translated_tech.empty()) |
| session_prohibited_technologies_.push_back(translated_tech); |
| } |
| EnforceProhibitedTechnologies(); |
| } |
| |
| void ProhibitedTechnologiesHandler::EnforceProhibitedTechnologies() { |
| auto prohibited_technologies_ = GetCurrentlyProhibitedTechnologies(); |
| network_state_handler_->SetProhibitedTechnologies(prohibited_technologies_); |
| // Enable ethernet back as user doesn't have a place to enable it back |
| // if user shuts down directly in a user session. As shill will persist |
| // ProhibitedTechnologies which may include ethernet, making users can |
| // not find Ethernet at next boot or logging out unless user log out first |
| // and then shutdown. |
| if (std::find(prohibited_technologies_.begin(), |
| prohibited_technologies_.end(), |
| shill::kTypeEthernet) != prohibited_technologies_.end()) { |
| return; |
| } |
| if (network_state_handler_->IsTechnologyAvailable( |
| NetworkTypePattern::Ethernet()) && |
| !network_state_handler_->IsTechnologyEnabled( |
| NetworkTypePattern::Ethernet())) { |
| network_state_handler_->SetTechnologyEnabled( |
| NetworkTypePattern::Ethernet(), true, network_handler::ErrorCallback()); |
| } |
| } |
| |
| std::vector<std::string> |
| ProhibitedTechnologiesHandler::GetCurrentlyProhibitedTechnologies() { |
| if (!user_logged_in_ || !user_policy_applied_) |
| return globally_prohibited_technologies_; |
| std::set<std::string> prohibited_set; |
| prohibited_set.insert(session_prohibited_technologies_.begin(), |
| session_prohibited_technologies_.end()); |
| prohibited_set.insert(globally_prohibited_technologies_.begin(), |
| globally_prohibited_technologies_.end()); |
| std::vector<std::string> prohibited_list(prohibited_set.begin(), |
| prohibited_set.end()); |
| return prohibited_list; |
| } |
| |
| void ProhibitedTechnologiesHandler::AddGloballyProhibitedTechnology( |
| const std::string& technology) { |
| if (std::find(globally_prohibited_technologies_.begin(), |
| globally_prohibited_technologies_.end(), |
| technology) == globally_prohibited_technologies_.end()) { |
| globally_prohibited_technologies_.push_back(technology); |
| } |
| EnforceProhibitedTechnologies(); |
| } |
| |
| void ProhibitedTechnologiesHandler::RemoveGloballyProhibitedTechnology( |
| const std::string& technology) { |
| auto it = std::find(globally_prohibited_technologies_.begin(), |
| globally_prohibited_technologies_.end(), technology); |
| if (it != globally_prohibited_technologies_.end()) |
| globally_prohibited_technologies_.erase(it); |
| EnforceProhibitedTechnologies(); |
| } |
| |
| } // namespace chromeos |