// Copyright 2013 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/dbus/fake_shill_service_client.h" #include "base/bind.h" #include "base/bind_helpers.h" #include "base/command_line.h" #include "base/message_loop/message_loop.h" #include "base/stl_util.h" #include "base/strings/string_util.h" #include "base/values.h" #include "chromeos/chromeos_switches.h" #include "chromeos/dbus/dbus_thread_manager.h" #include "chromeos/dbus/shill_manager_client.h" #include "chromeos/dbus/shill_property_changed_observer.h" #include "chromeos/dbus/shill_stub_helper.h" #include "chromeos/network/shill_property_util.h" #include "dbus/bus.h" #include "dbus/message.h" #include "dbus/object_path.h" #include "third_party/cros_system_api/dbus/service_constants.h" namespace chromeos { namespace { void PassStubListValue(const ShillServiceClient::ListValueCallback& callback, base::ListValue* value) { callback.Run(*value); } void PassStubServiceProperties( const ShillServiceClient::DictionaryValueCallback& callback, DBusMethodCallStatus call_status, const base::DictionaryValue* properties) { callback.Run(call_status, *properties); } } // namespace FakeShillServiceClient::FakeShillServiceClient() : weak_ptr_factory_(this) { } FakeShillServiceClient::~FakeShillServiceClient() { STLDeleteContainerPairSecondPointers( observer_list_.begin(), observer_list_.end()); } // ShillServiceClient overrides. void FakeShillServiceClient::Init(dbus::Bus* bus) { } void FakeShillServiceClient::AddPropertyChangedObserver( const dbus::ObjectPath& service_path, ShillPropertyChangedObserver* observer) { GetObserverList(service_path).AddObserver(observer); } void FakeShillServiceClient::RemovePropertyChangedObserver( const dbus::ObjectPath& service_path, ShillPropertyChangedObserver* observer) { GetObserverList(service_path).RemoveObserver(observer); } void FakeShillServiceClient::GetProperties( const dbus::ObjectPath& service_path, const DictionaryValueCallback& callback) { base::DictionaryValue* nested_dict = NULL; scoped_ptr<base::DictionaryValue> result_properties; DBusMethodCallStatus call_status; stub_services_.GetDictionaryWithoutPathExpansion(service_path.value(), &nested_dict); if (nested_dict) { result_properties.reset(nested_dict->DeepCopy()); // Remove credentials that Shill wouldn't send. result_properties->RemoveWithoutPathExpansion(shill::kPassphraseProperty, NULL); call_status = DBUS_METHOD_CALL_SUCCESS; } else { LOG(ERROR) << "Properties not found for: " << service_path.value(); result_properties.reset(new base::DictionaryValue); call_status = DBUS_METHOD_CALL_FAILURE; } base::MessageLoop::current()->PostTask( FROM_HERE, base::Bind(&PassStubServiceProperties, callback, call_status, base::Owned(result_properties.release()))); } void FakeShillServiceClient::SetProperty(const dbus::ObjectPath& service_path, const std::string& name, const base::Value& value, const base::Closure& callback, const ErrorCallback& error_callback) { if (!SetServiceProperty(service_path.value(), name, value)) { LOG(ERROR) << "Service not found: " << service_path.value(); error_callback.Run("Error.InvalidService", "Invalid Service"); return; } base::MessageLoop::current()->PostTask(FROM_HERE, callback); } void FakeShillServiceClient::SetProperties( const dbus::ObjectPath& service_path, const base::DictionaryValue& properties, const base::Closure& callback, const ErrorCallback& error_callback) { for (base::DictionaryValue::Iterator iter(properties); !iter.IsAtEnd(); iter.Advance()) { if (!SetServiceProperty(service_path.value(), iter.key(), iter.value())) { LOG(ERROR) << "Service not found: " << service_path.value(); error_callback.Run("Error.InvalidService", "Invalid Service"); return; } } base::MessageLoop::current()->PostTask(FROM_HERE, callback); } void FakeShillServiceClient::ClearProperty( const dbus::ObjectPath& service_path, const std::string& name, const base::Closure& callback, const ErrorCallback& error_callback) { base::DictionaryValue* dict = NULL; if (!stub_services_.GetDictionaryWithoutPathExpansion( service_path.value(), &dict)) { error_callback.Run("Error.InvalidService", "Invalid Service"); return; } dict->RemoveWithoutPathExpansion(name, NULL); // Note: Shill does not send notifications when properties are cleared. base::MessageLoop::current()->PostTask(FROM_HERE, callback); } void FakeShillServiceClient::ClearProperties( const dbus::ObjectPath& service_path, const std::vector<std::string>& names, const ListValueCallback& callback, const ErrorCallback& error_callback) { base::DictionaryValue* dict = NULL; if (!stub_services_.GetDictionaryWithoutPathExpansion( service_path.value(), &dict)) { error_callback.Run("Error.InvalidService", "Invalid Service"); return; } scoped_ptr<base::ListValue> results(new base::ListValue); for (std::vector<std::string>::const_iterator iter = names.begin(); iter != names.end(); ++iter) { dict->RemoveWithoutPathExpansion(*iter, NULL); // Note: Shill does not send notifications when properties are cleared. results->AppendBoolean(true); } base::MessageLoop::current()->PostTask( FROM_HERE, base::Bind(&PassStubListValue, callback, base::Owned(results.release()))); } void FakeShillServiceClient::Connect(const dbus::ObjectPath& service_path, const base::Closure& callback, const ErrorCallback& error_callback) { VLOG(1) << "FakeShillServiceClient::Connect: " << service_path.value(); base::DictionaryValue* service_properties = NULL; if (!stub_services_.GetDictionary( service_path.value(), &service_properties)) { LOG(ERROR) << "Service not found: " << service_path.value(); error_callback.Run("Error.InvalidService", "Invalid Service"); return; } // Set any other services of the same Type to 'offline' first, before setting // State to Association which will trigger sorting Manager.Services and // sending an update. SetOtherServicesOffline(service_path.value()); // Set Associating. base::StringValue associating_value(shill::kStateAssociation); SetServiceProperty(service_path.value(), shill::kStateProperty, associating_value); // Stay Associating until the state is changed again after a delay. base::TimeDelta delay; if (CommandLine::ForCurrentProcess()->HasSwitch( chromeos::switches::kEnableStubInteractive)) { const int kConnectDelaySeconds = 5; delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds); } base::MessageLoop::current()->PostDelayedTask( FROM_HERE, base::Bind(&FakeShillServiceClient::ContinueConnect, weak_ptr_factory_.GetWeakPtr(), service_path.value()), delay); callback.Run(); } void FakeShillServiceClient::Disconnect(const dbus::ObjectPath& service_path, const base::Closure& callback, const ErrorCallback& error_callback) { base::Value* service; if (!stub_services_.Get(service_path.value(), &service)) { error_callback.Run("Error.InvalidService", "Invalid Service"); return; } base::TimeDelta delay; if (CommandLine::ForCurrentProcess()->HasSwitch( chromeos::switches::kEnableStubInteractive)) { const int kConnectDelaySeconds = 2; delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds); } // Set Idle after a delay base::StringValue idle_value(shill::kStateIdle); base::MessageLoop::current()->PostDelayedTask( FROM_HERE, base::Bind(&FakeShillServiceClient::SetProperty, weak_ptr_factory_.GetWeakPtr(), service_path, shill::kStateProperty, idle_value, base::Bind(&base::DoNothing), error_callback), delay); callback.Run(); } void FakeShillServiceClient::Remove(const dbus::ObjectPath& service_path, const base::Closure& callback, const ErrorCallback& error_callback) { base::MessageLoop::current()->PostTask(FROM_HERE, callback); } void FakeShillServiceClient::ActivateCellularModem( const dbus::ObjectPath& service_path, const std::string& carrier, const base::Closure& callback, const ErrorCallback& error_callback) { base::DictionaryValue* service_properties = GetModifiableServiceProperties(service_path.value(), false); if (!service_properties) { LOG(ERROR) << "Service not found: " << service_path.value(); error_callback.Run("Error.InvalidService", "Invalid Service"); } SetServiceProperty(service_path.value(), shill::kActivationStateProperty, base::StringValue(shill::kActivationStateActivating)); base::TimeDelta delay; if (CommandLine::ForCurrentProcess()->HasSwitch( chromeos::switches::kEnableStubInteractive)) { const int kConnectDelaySeconds = 2; delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds); } // Set Activated after a delay base::MessageLoop::current()->PostDelayedTask( FROM_HERE, base::Bind(&FakeShillServiceClient::SetCellularActivated, weak_ptr_factory_.GetWeakPtr(), service_path, error_callback), delay); base::MessageLoop::current()->PostTask(FROM_HERE, callback); } void FakeShillServiceClient::CompleteCellularActivation( const dbus::ObjectPath& service_path, const base::Closure& callback, const ErrorCallback& error_callback) { base::MessageLoop::current()->PostTask(FROM_HERE, callback); } void FakeShillServiceClient::GetLoadableProfileEntries( const dbus::ObjectPath& service_path, const DictionaryValueCallback& callback) { // Provide a dictionary with a single { profile_path, service_path } entry // if the Profile property is set, or an empty dictionary. scoped_ptr<base::DictionaryValue> result_properties( new base::DictionaryValue); base::DictionaryValue* service_properties = GetModifiableServiceProperties(service_path.value(), false); if (service_properties) { std::string profile_path; if (service_properties->GetStringWithoutPathExpansion( shill::kProfileProperty, &profile_path)) { result_properties->SetStringWithoutPathExpansion( profile_path, service_path.value()); } } else { LOG(WARNING) << "Service not in profile: " << service_path.value(); } DBusMethodCallStatus call_status = DBUS_METHOD_CALL_SUCCESS; base::MessageLoop::current()->PostTask( FROM_HERE, base::Bind(&PassStubServiceProperties, callback, call_status, base::Owned(result_properties.release()))); } ShillServiceClient::TestInterface* FakeShillServiceClient::GetTestInterface() { return this; } // ShillServiceClient::TestInterface overrides. void FakeShillServiceClient::AddService(const std::string& service_path, const std::string& name, const std::string& type, const std::string& state, bool add_to_visible_list, bool add_to_watch_list) { std::string nstate = state; if (CommandLine::ForCurrentProcess()->HasSwitch( chromeos::switches::kDefaultStubNetworkStateIdle)) { nstate = shill::kStateIdle; } AddServiceWithIPConfig(service_path, name, type, nstate, "", add_to_visible_list, add_to_watch_list); } void FakeShillServiceClient::AddServiceWithIPConfig( const std::string& service_path, const std::string& name, const std::string& type, const std::string& state, const std::string& ipconfig_path, bool add_to_visible_list, bool add_to_watch_list) { DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()-> AddManagerService(service_path, add_to_visible_list, add_to_watch_list); base::DictionaryValue* properties = GetModifiableServiceProperties(service_path, true); connect_behavior_.erase(service_path); shill_property_util::SetSSID(name, properties); properties->SetWithoutPathExpansion( shill::kNameProperty, base::Value::CreateStringValue(name)); properties->SetWithoutPathExpansion( shill::kDeviceProperty, base::Value::CreateStringValue( shill_stub_helper::DevicePathForType(type))); properties->SetWithoutPathExpansion( shill::kTypeProperty, base::Value::CreateStringValue(type)); properties->SetWithoutPathExpansion( shill::kStateProperty, base::Value::CreateStringValue(state)); if (!ipconfig_path.empty()) properties->SetWithoutPathExpansion( shill::kIPConfigProperty, base::Value::CreateStringValue(ipconfig_path)); } void FakeShillServiceClient::RemoveService(const std::string& service_path) { DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()-> RemoveManagerService(service_path); stub_services_.RemoveWithoutPathExpansion(service_path, NULL); connect_behavior_.erase(service_path); } bool FakeShillServiceClient::SetServiceProperty(const std::string& service_path, const std::string& property, const base::Value& value) { base::DictionaryValue* dict = NULL; if (!stub_services_.GetDictionaryWithoutPathExpansion(service_path, &dict)) return false; VLOG(1) << "Service.SetProperty: " << property << " = " << value << " For: " << service_path; base::DictionaryValue new_properties; std::string changed_property; bool case_sensitive = true; if (StartsWithASCII(property, "Provider.", case_sensitive) || StartsWithASCII(property, "OpenVPN.", case_sensitive) || StartsWithASCII(property, "L2TPIPsec.", case_sensitive)) { // These properties are only nested within the Provider dictionary if read // from Shill. base::DictionaryValue* provider = new base::DictionaryValue; provider->SetWithoutPathExpansion(property, value.DeepCopy()); new_properties.SetWithoutPathExpansion(shill::kProviderProperty, provider); changed_property = shill::kProviderProperty; } else { new_properties.SetWithoutPathExpansion(property, value.DeepCopy()); changed_property = property; } dict->MergeDictionary(&new_properties); if (property == shill::kStateProperty) { // When State changes the sort order of Services may change. DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()-> SortManagerServices(); } base::MessageLoop::current()->PostTask( FROM_HERE, base::Bind(&FakeShillServiceClient::NotifyObserversPropertyChanged, weak_ptr_factory_.GetWeakPtr(), dbus::ObjectPath(service_path), changed_property)); return true; } const base::DictionaryValue* FakeShillServiceClient::GetServiceProperties( const std::string& service_path) const { const base::DictionaryValue* properties = NULL; stub_services_.GetDictionaryWithoutPathExpansion(service_path, &properties); return properties; } void FakeShillServiceClient::ClearServices() { DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()-> ClearManagerServices(); stub_services_.Clear(); connect_behavior_.clear(); } void FakeShillServiceClient::SetConnectBehavior(const std::string& service_path, const base::Closure& behavior) { connect_behavior_[service_path] = behavior; } void FakeShillServiceClient::NotifyObserversPropertyChanged( const dbus::ObjectPath& service_path, const std::string& property) { base::DictionaryValue* dict = NULL; std::string path = service_path.value(); if (!stub_services_.GetDictionaryWithoutPathExpansion(path, &dict)) { LOG(ERROR) << "Notify for unknown service: " << path; return; } base::Value* value = NULL; if (!dict->GetWithoutPathExpansion(property, &value)) { LOG(ERROR) << "Notify for unknown property: " << path << " : " << property; return; } FOR_EACH_OBSERVER(ShillPropertyChangedObserver, GetObserverList(service_path), OnPropertyChanged(property, *value)); } base::DictionaryValue* FakeShillServiceClient::GetModifiableServiceProperties( const std::string& service_path, bool create_if_missing) { base::DictionaryValue* properties = NULL; if (!stub_services_.GetDictionaryWithoutPathExpansion(service_path, &properties) && create_if_missing) { properties = new base::DictionaryValue; stub_services_.Set(service_path, properties); } return properties; } FakeShillServiceClient::PropertyObserverList& FakeShillServiceClient::GetObserverList(const dbus::ObjectPath& device_path) { std::map<dbus::ObjectPath, PropertyObserverList*>::iterator iter = observer_list_.find(device_path); if (iter != observer_list_.end()) return *(iter->second); PropertyObserverList* observer_list = new PropertyObserverList(); observer_list_[device_path] = observer_list; return *observer_list; } void FakeShillServiceClient::SetOtherServicesOffline( const std::string& service_path) { const base::DictionaryValue* service_properties = GetServiceProperties( service_path); if (!service_properties) { LOG(ERROR) << "Missing service: " << service_path; return; } std::string service_type; service_properties->GetString(shill::kTypeProperty, &service_type); // Set all other services of the same type to offline (Idle). for (base::DictionaryValue::Iterator iter(stub_services_); !iter.IsAtEnd(); iter.Advance()) { std::string path = iter.key(); if (path == service_path) continue; base::DictionaryValue* properties; if (!stub_services_.GetDictionaryWithoutPathExpansion(path, &properties)) NOTREACHED(); std::string type; properties->GetString(shill::kTypeProperty, &type); if (type != service_type) continue; properties->SetWithoutPathExpansion( shill::kStateProperty, base::Value::CreateStringValue(shill::kStateIdle)); } } void FakeShillServiceClient::SetCellularActivated( const dbus::ObjectPath& service_path, const ErrorCallback& error_callback) { SetProperty(service_path, shill::kActivationStateProperty, base::StringValue(shill::kActivationStateActivated), base::Bind(&base::DoNothing), error_callback); SetProperty(service_path, shill::kConnectableProperty, base::FundamentalValue(true), base::Bind(&base::DoNothing), error_callback); } void FakeShillServiceClient::ContinueConnect( const std::string& service_path) { VLOG(1) << "FakeShillServiceClient::ContinueConnect: " << service_path; base::DictionaryValue* service_properties = NULL; if (!stub_services_.GetDictionary(service_path, &service_properties)) { LOG(ERROR) << "Service not found: " << service_path; return; } if (ContainsKey(connect_behavior_, service_path)) { const base::Closure& custom_connect_behavior = connect_behavior_[service_path]; custom_connect_behavior.Run(); return; } // No custom connect behavior set, continue with the default connect behavior. std::string passphrase; service_properties->GetStringWithoutPathExpansion( shill::kPassphraseProperty, &passphrase); if (passphrase == "failure") { // Simulate a password failure. SetServiceProperty(service_path, shill::kStateProperty, base::StringValue(shill::kStateFailure)); base::MessageLoop::current()->PostTask( FROM_HERE, base::Bind( base::IgnoreResult(&FakeShillServiceClient::SetServiceProperty), weak_ptr_factory_.GetWeakPtr(), service_path, shill::kErrorProperty, base::StringValue(shill::kErrorBadPassphrase))); } else { // Set Online. SetServiceProperty(service_path, shill::kStateProperty, base::StringValue(shill::kStateOnline)); } } } // namespace chromeos