chromeos/dbus/fake_shill_service_client.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chromeos/dbus/fake_shill_service_client.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/command_line.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/stl_util.h"
  12 #include "base/strings/string_util.h"
  13 #include "base/values.h"
  14 #include "chromeos/chromeos_switches.h"
  15 #include "chromeos/dbus/dbus_thread_manager.h"
  16 #include "chromeos/dbus/shill_manager_client.h"
  17 #include "chromeos/dbus/shill_property_changed_observer.h"
  18 #include "chromeos/dbus/shill_stub_helper.h"
  19 #include "chromeos/network/shill_property_util.h"
  20 #include "dbus/bus.h"
  21 #include "dbus/message.h"
  22 #include "dbus/object_path.h"
  23 #include "third_party/cros_system_api/dbus/service_constants.h"
  24
  25 namespace chromeos {
  26
  27 namespace {
  28
  29 void PassStubListValue(const ShillServiceClient::ListValueCallback& callback,
  30                        base::ListValue* value) {
  31   callback.Run(*value);
  32 }
  33
  34 void PassStubServiceProperties(
  35     const ShillServiceClient::DictionaryValueCallback& callback,
  36     DBusMethodCallStatus call_status,
  37     const base::DictionaryValue* properties) {
  38   callback.Run(call_status, *properties);
  39 }
  40
  41 }  // namespace
  42
  43 FakeShillServiceClient::FakeShillServiceClient() : weak_ptr_factory_(this) {
  44 }
  45
  46 FakeShillServiceClient::~FakeShillServiceClient() {
  47   STLDeleteContainerPairSecondPointers(
  48       observer_list_.begin(), observer_list_.end());
  49 }
  50
  51
  52 // ShillServiceClient overrides.
  53
  54 void FakeShillServiceClient::Init(dbus::Bus* bus) {
  55 }
  56
  57 void FakeShillServiceClient::AddPropertyChangedObserver(
  58     const dbus::ObjectPath& service_path,
  59     ShillPropertyChangedObserver* observer) {
  60   GetObserverList(service_path).AddObserver(observer);
  61 }
  62
  63 void FakeShillServiceClient::RemovePropertyChangedObserver(
  64     const dbus::ObjectPath& service_path,
  65     ShillPropertyChangedObserver* observer) {
  66   GetObserverList(service_path).RemoveObserver(observer);
  67 }
  68
  69 void FakeShillServiceClient::GetProperties(
  70     const dbus::ObjectPath& service_path,
  71     const DictionaryValueCallback& callback) {
  72   base::DictionaryValue* nested_dict = NULL;
  73   scoped_ptr<base::DictionaryValue> result_properties;
  74   DBusMethodCallStatus call_status;
  75   stub_services_.GetDictionaryWithoutPathExpansion(service_path.value(),
  76                                                    &nested_dict);
  77   if (nested_dict) {
  78     result_properties.reset(nested_dict->DeepCopy());
  79     // Remove credentials that Shill wouldn't send.
  80     result_properties->RemoveWithoutPathExpansion(shill::kPassphraseProperty,
  81                                                   NULL);
  82     call_status = DBUS_METHOD_CALL_SUCCESS;
  83   } else {
  84     LOG(ERROR) << "Properties not found for: " << service_path.value();
  85     result_properties.reset(new base::DictionaryValue);
  86     call_status = DBUS_METHOD_CALL_FAILURE;
  87   }
  88
  89   base::MessageLoop::current()->PostTask(
  90       FROM_HERE,
  91       base::Bind(&PassStubServiceProperties,
  92                  callback,
  93                  call_status,
  94                  base::Owned(result_properties.release())));
  95 }
  96
  97 void FakeShillServiceClient::SetProperty(const dbus::ObjectPath& service_path,
  98                                          const std::string& name,
  99                                          const base::Value& value,
 100                                          const base::Closure& callback,
 101                                          const ErrorCallback& error_callback) {
 102   if (!SetServiceProperty(service_path.value(), name, value)) {
 103     LOG(ERROR) << "Service not found: " << service_path.value();
 104     error_callback.Run("Error.InvalidService", "Invalid Service");
 105     return;
 106   }
 107   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 108 }
 109
 110 void FakeShillServiceClient::SetProperties(
 111     const dbus::ObjectPath& service_path,
 112     const base::DictionaryValue& properties,
 113     const base::Closure& callback,
 114     const ErrorCallback& error_callback) {
 115   for (base::DictionaryValue::Iterator iter(properties);
 116        !iter.IsAtEnd(); iter.Advance()) {
 117     if (!SetServiceProperty(service_path.value(), iter.key(), iter.value())) {
 118       LOG(ERROR) << "Service not found: " << service_path.value();
 119       error_callback.Run("Error.InvalidService", "Invalid Service");
 120       return;
 121     }
 122   }
 123   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 124 }
 125
 126 void FakeShillServiceClient::ClearProperty(
 127     const dbus::ObjectPath& service_path,
 128     const std::string& name,
 129     const base::Closure& callback,
 130     const ErrorCallback& error_callback) {
 131   base::DictionaryValue* dict = NULL;
 132   if (!stub_services_.GetDictionaryWithoutPathExpansion(
 133       service_path.value(), &dict)) {
 134     error_callback.Run("Error.InvalidService", "Invalid Service");
 135     return;
 136   }
 137   dict->RemoveWithoutPathExpansion(name, NULL);
 138   // Note: Shill does not send notifications when properties are cleared.
 139   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 140 }
 141
 142 void FakeShillServiceClient::ClearProperties(
 143     const dbus::ObjectPath& service_path,
 144     const std::vector<std::string>& names,
 145     const ListValueCallback& callback,
 146     const ErrorCallback& error_callback) {
 147   base::DictionaryValue* dict = NULL;
 148   if (!stub_services_.GetDictionaryWithoutPathExpansion(
 149       service_path.value(), &dict)) {
 150     error_callback.Run("Error.InvalidService", "Invalid Service");
 151     return;
 152   }
 153   scoped_ptr<base::ListValue> results(new base::ListValue);
 154   for (std::vector<std::string>::const_iterator iter = names.begin();
 155       iter != names.end(); ++iter) {
 156     dict->RemoveWithoutPathExpansion(*iter, NULL);
 157     // Note: Shill does not send notifications when properties are cleared.
 158     results->AppendBoolean(true);
 159   }
 160   base::MessageLoop::current()->PostTask(
 161       FROM_HERE,
 162       base::Bind(&PassStubListValue,
 163                  callback, base::Owned(results.release())));
 164 }
 165
 166 void FakeShillServiceClient::Connect(const dbus::ObjectPath& service_path,
 167                                      const base::Closure& callback,
 168                                      const ErrorCallback& error_callback) {
 169   VLOG(1) << "FakeShillServiceClient::Connect: " << service_path.value();
 170   base::DictionaryValue* service_properties = NULL;
 171   if (!stub_services_.GetDictionary(
 172           service_path.value(), &service_properties)) {
 173     LOG(ERROR) << "Service not found: " << service_path.value();
 174     error_callback.Run("Error.InvalidService", "Invalid Service");
 175     return;
 176   }
 177
 178   // Set any other services of the same Type to 'offline' first, before setting
 179   // State to Association which will trigger sorting Manager.Services and
 180   // sending an update.
 181   SetOtherServicesOffline(service_path.value());
 182
 183   // Set Associating.
 184   base::StringValue associating_value(shill::kStateAssociation);
 185   SetServiceProperty(service_path.value(),
 186                      shill::kStateProperty,
 187                      associating_value);
 188
 189   // Stay Associating until the state is changed again after a delay.
 190   base::TimeDelta delay;
 191   if (CommandLine::ForCurrentProcess()->HasSwitch(
 192           chromeos::switches::kEnableStubInteractive)) {
 193     const int kConnectDelaySeconds = 5;
 194     delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds);
 195   }
 196   base::MessageLoop::current()->PostDelayedTask(
 197       FROM_HERE,
 198       base::Bind(&FakeShillServiceClient::ContinueConnect,
 199                  weak_ptr_factory_.GetWeakPtr(),
 200                  service_path.value()),
 201       delay);
 202
 203   callback.Run();
 204 }
 205
 206 void FakeShillServiceClient::Disconnect(const dbus::ObjectPath& service_path,
 207                                         const base::Closure& callback,
 208                                         const ErrorCallback& error_callback) {
 209   base::Value* service;
 210   if (!stub_services_.Get(service_path.value(), &service)) {
 211     error_callback.Run("Error.InvalidService", "Invalid Service");
 212     return;
 213   }
 214   base::TimeDelta delay;
 215   if (CommandLine::ForCurrentProcess()->HasSwitch(
 216           chromeos::switches::kEnableStubInteractive)) {
 217     const int kConnectDelaySeconds = 2;
 218     delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds);
 219   }
 220   // Set Idle after a delay
 221   base::StringValue idle_value(shill::kStateIdle);
 222   base::MessageLoop::current()->PostDelayedTask(
 223       FROM_HERE,
 224       base::Bind(&FakeShillServiceClient::SetProperty,
 225                  weak_ptr_factory_.GetWeakPtr(),
 226                  service_path,
 227                  shill::kStateProperty,
 228                  idle_value,
 229                  base::Bind(&base::DoNothing),
 230                  error_callback),
 231       delay);
 232   callback.Run();
 233 }
 234
 235 void FakeShillServiceClient::Remove(const dbus::ObjectPath& service_path,
 236                                     const base::Closure& callback,
 237                                     const ErrorCallback& error_callback) {
 238   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 239 }
 240
 241 void FakeShillServiceClient::ActivateCellularModem(
 242     const dbus::ObjectPath& service_path,
 243     const std::string& carrier,
 244     const base::Closure& callback,
 245     const ErrorCallback& error_callback) {
 246   base::DictionaryValue* service_properties =
 247       GetModifiableServiceProperties(service_path.value(), false);
 248   if (!service_properties) {
 249     LOG(ERROR) << "Service not found: " << service_path.value();
 250     error_callback.Run("Error.InvalidService", "Invalid Service");
 251   }
 252   SetServiceProperty(service_path.value(),
 253                      shill::kActivationStateProperty,
 254                      base::StringValue(shill::kActivationStateActivating));
 255   base::TimeDelta delay;
 256   if (CommandLine::ForCurrentProcess()->HasSwitch(
 257           chromeos::switches::kEnableStubInteractive)) {
 258     const int kConnectDelaySeconds = 2;
 259     delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds);
 260   }
 261   // Set Activated after a delay
 262   base::MessageLoop::current()->PostDelayedTask(
 263       FROM_HERE,
 264       base::Bind(&FakeShillServiceClient::SetCellularActivated,
 265                  weak_ptr_factory_.GetWeakPtr(),
 266                  service_path,
 267                  error_callback),
 268       delay);
 269
 270   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 271 }
 272
 273 void FakeShillServiceClient::CompleteCellularActivation(
 274     const dbus::ObjectPath& service_path,
 275     const base::Closure& callback,
 276     const ErrorCallback& error_callback) {
 277   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 278 }
 279
 280 void FakeShillServiceClient::GetLoadableProfileEntries(
 281     const dbus::ObjectPath& service_path,
 282     const DictionaryValueCallback& callback) {
 283   // Provide a dictionary with a single { profile_path, service_path } entry
 284   // if the Profile property is set, or an empty dictionary.
 285   scoped_ptr<base::DictionaryValue> result_properties(
 286       new base::DictionaryValue);
 287   base::DictionaryValue* service_properties =
 288       GetModifiableServiceProperties(service_path.value(), false);
 289   if (service_properties) {
 290     std::string profile_path;
 291     if (service_properties->GetStringWithoutPathExpansion(
 292             shill::kProfileProperty, &profile_path)) {
 293       result_properties->SetStringWithoutPathExpansion(
 294           profile_path, service_path.value());
 295     }
 296   } else {
 297     LOG(WARNING) << "Service not in profile: " << service_path.value();
 298   }
 299
 300   DBusMethodCallStatus call_status = DBUS_METHOD_CALL_SUCCESS;
 301   base::MessageLoop::current()->PostTask(
 302       FROM_HERE,
 303       base::Bind(&PassStubServiceProperties,
 304                  callback,
 305                  call_status,
 306                  base::Owned(result_properties.release())));
 307 }
 308
 309 ShillServiceClient::TestInterface* FakeShillServiceClient::GetTestInterface() {
 310   return this;
 311 }
 312
 313 // ShillServiceClient::TestInterface overrides.
 314
 315 void FakeShillServiceClient::AddService(const std::string& service_path,
 316                                         const std::string& name,
 317                                         const std::string& type,
 318                                         const std::string& state,
 319                                         bool add_to_visible_list,
 320                                         bool add_to_watch_list) {
 321   std::string nstate = state;
 322   if (CommandLine::ForCurrentProcess()->HasSwitch(
 323           chromeos::switches::kDefaultStubNetworkStateIdle)) {
 324     nstate = shill::kStateIdle;
 325   }
 326   AddServiceWithIPConfig(service_path, name, type, nstate, "",
 327                          add_to_visible_list, add_to_watch_list);
 328 }
 329
 330 void FakeShillServiceClient::AddServiceWithIPConfig(
 331     const std::string& service_path,
 332     const std::string& name,
 333     const std::string& type,
 334     const std::string& state,
 335     const std::string& ipconfig_path,
 336     bool add_to_visible_list,
 337     bool add_to_watch_list) {
 338   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
 339       AddManagerService(service_path, add_to_visible_list, add_to_watch_list);
 340
 341   base::DictionaryValue* properties =
 342       GetModifiableServiceProperties(service_path, true);
 343   connect_behavior_.erase(service_path);
 344   shill_property_util::SetSSID(name, properties);
 345   properties->SetWithoutPathExpansion(
 346       shill::kNameProperty,
 347       base::Value::CreateStringValue(name));
 348   properties->SetWithoutPathExpansion(
 349       shill::kDeviceProperty,
 350       base::Value::CreateStringValue(
 351           shill_stub_helper::DevicePathForType(type)));
 352   properties->SetWithoutPathExpansion(
 353       shill::kTypeProperty,
 354       base::Value::CreateStringValue(type));
 355   properties->SetWithoutPathExpansion(
 356       shill::kStateProperty,
 357       base::Value::CreateStringValue(state));
 358   if (!ipconfig_path.empty())
 359     properties->SetWithoutPathExpansion(
 360         shill::kIPConfigProperty,
 361         base::Value::CreateStringValue(ipconfig_path));
 362 }
 363
 364 void FakeShillServiceClient::RemoveService(const std::string& service_path) {
 365   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
 366       RemoveManagerService(service_path);
 367
 368   stub_services_.RemoveWithoutPathExpansion(service_path, NULL);
 369   connect_behavior_.erase(service_path);
 370 }
 371
 372 bool FakeShillServiceClient::SetServiceProperty(const std::string& service_path,
 373                                                 const std::string& property,
 374                                                 const base::Value& value) {
 375   base::DictionaryValue* dict = NULL;
 376   if (!stub_services_.GetDictionaryWithoutPathExpansion(service_path, &dict))
 377     return false;
 378
 379   VLOG(1) << "Service.SetProperty: " << property << " = " << value
 380           << " For: " << service_path;
 381
 382   base::DictionaryValue new_properties;
 383   std::string changed_property;
 384   bool case_sensitive = true;
 385   if (StartsWithASCII(property, "Provider.", case_sensitive) ||
 386       StartsWithASCII(property, "OpenVPN.", case_sensitive) ||
 387       StartsWithASCII(property, "L2TPIPsec.", case_sensitive)) {
 388     // These properties are only nested within the Provider dictionary if read
 389     // from Shill.
 390     base::DictionaryValue* provider = new base::DictionaryValue;
 391     provider->SetWithoutPathExpansion(property, value.DeepCopy());
 392     new_properties.SetWithoutPathExpansion(shill::kProviderProperty, provider);
 393     changed_property = shill::kProviderProperty;
 394   } else {
 395     new_properties.SetWithoutPathExpansion(property, value.DeepCopy());
 396     changed_property = property;
 397   }
 398
 399   dict->MergeDictionary(&new_properties);
 400
 401   if (property == shill::kStateProperty) {
 402     // When State changes the sort order of Services may change.
 403     DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
 404         SortManagerServices();
 405   }
 406
 407   base::MessageLoop::current()->PostTask(
 408       FROM_HERE,
 409       base::Bind(&FakeShillServiceClient::NotifyObserversPropertyChanged,
 410                  weak_ptr_factory_.GetWeakPtr(),
 411                  dbus::ObjectPath(service_path), changed_property));
 412   return true;
 413 }
 414
 415 const base::DictionaryValue* FakeShillServiceClient::GetServiceProperties(
 416     const std::string& service_path) const {
 417   const base::DictionaryValue* properties = NULL;
 418   stub_services_.GetDictionaryWithoutPathExpansion(service_path, &properties);
 419   return properties;
 420 }
 421
 422 void FakeShillServiceClient::ClearServices() {
 423   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
 424       ClearManagerServices();
 425
 426   stub_services_.Clear();
 427   connect_behavior_.clear();
 428 }
 429
 430 void FakeShillServiceClient::SetConnectBehavior(const std::string& service_path,
 431                                 const base::Closure& behavior) {
 432   connect_behavior_[service_path] = behavior;
 433 }
 434
 435 void FakeShillServiceClient::NotifyObserversPropertyChanged(
 436     const dbus::ObjectPath& service_path,
 437     const std::string& property) {
 438   base::DictionaryValue* dict = NULL;
 439   std::string path = service_path.value();
 440   if (!stub_services_.GetDictionaryWithoutPathExpansion(path, &dict)) {
 441     LOG(ERROR) << "Notify for unknown service: " << path;
 442     return;
 443   }
 444   base::Value* value = NULL;
 445   if (!dict->GetWithoutPathExpansion(property, &value)) {
 446     LOG(ERROR) << "Notify for unknown property: "
 447                << path << " : " << property;
 448     return;
 449   }
 450   FOR_EACH_OBSERVER(ShillPropertyChangedObserver,
 451                     GetObserverList(service_path),
 452                     OnPropertyChanged(property, *value));
 453 }
 454
 455 base::DictionaryValue* FakeShillServiceClient::GetModifiableServiceProperties(
 456     const std::string& service_path, bool create_if_missing) {
 457   base::DictionaryValue* properties = NULL;
 458   if (!stub_services_.GetDictionaryWithoutPathExpansion(service_path,
 459                                                         &properties) &&
 460       create_if_missing) {
 461     properties = new base::DictionaryValue;
 462     stub_services_.Set(service_path, properties);
 463   }
 464   return properties;
 465 }
 466
 467 FakeShillServiceClient::PropertyObserverList&
 468 FakeShillServiceClient::GetObserverList(const dbus::ObjectPath& device_path) {
 469   std::map<dbus::ObjectPath, PropertyObserverList*>::iterator iter =
 470       observer_list_.find(device_path);
 471   if (iter != observer_list_.end())
 472     return *(iter->second);
 473   PropertyObserverList* observer_list = new PropertyObserverList();
 474   observer_list_[device_path] = observer_list;
 475   return *observer_list;
 476 }
 477
 478 void FakeShillServiceClient::SetOtherServicesOffline(
 479     const std::string& service_path) {
 480   const base::DictionaryValue* service_properties = GetServiceProperties(
 481       service_path);
 482   if (!service_properties) {
 483     LOG(ERROR) << "Missing service: " << service_path;
 484     return;
 485   }
 486   std::string service_type;
 487   service_properties->GetString(shill::kTypeProperty, &service_type);
 488   // Set all other services of the same type to offline (Idle).
 489   for (base::DictionaryValue::Iterator iter(stub_services_);
 490        !iter.IsAtEnd(); iter.Advance()) {
 491     std::string path = iter.key();
 492     if (path == service_path)
 493       continue;
 494     base::DictionaryValue* properties;
 495     if (!stub_services_.GetDictionaryWithoutPathExpansion(path, &properties))
 496       NOTREACHED();
 497
 498     std::string type;
 499     properties->GetString(shill::kTypeProperty, &type);
 500     if (type != service_type)
 501       continue;
 502     properties->SetWithoutPathExpansion(
 503         shill::kStateProperty,
 504         base::Value::CreateStringValue(shill::kStateIdle));
 505   }
 506 }
 507
 508 void FakeShillServiceClient::SetCellularActivated(
 509     const dbus::ObjectPath& service_path,
 510     const ErrorCallback& error_callback) {
 511   SetProperty(service_path,
 512               shill::kActivationStateProperty,
 513               base::StringValue(shill::kActivationStateActivated),
 514               base::Bind(&base::DoNothing),
 515               error_callback);
 516   SetProperty(service_path,
 517               shill::kConnectableProperty,
 518               base::FundamentalValue(true),
 519               base::Bind(&base::DoNothing),
 520               error_callback);
 521 }
 522
 523 void FakeShillServiceClient::ContinueConnect(
 524     const std::string& service_path) {
 525   VLOG(1) << "FakeShillServiceClient::ContinueConnect: " << service_path;
 526   base::DictionaryValue* service_properties = NULL;
 527   if (!stub_services_.GetDictionary(service_path, &service_properties)) {
 528     LOG(ERROR) << "Service not found: " << service_path;
 529     return;
 530   }
 531
 532   if (ContainsKey(connect_behavior_, service_path)) {
 533     const base::Closure& custom_connect_behavior =
 534         connect_behavior_[service_path];
 535     custom_connect_behavior.Run();
 536     return;
 537   }
 538
 539   // No custom connect behavior set, continue with the default connect behavior.
 540   std::string passphrase;
 541   service_properties->GetStringWithoutPathExpansion(
 542       shill::kPassphraseProperty, &passphrase);
 543   if (passphrase == "failure") {
 544     // Simulate a password failure.
 545     SetServiceProperty(service_path,
 546                        shill::kStateProperty,
 547                        base::StringValue(shill::kStateFailure));
 548     base::MessageLoop::current()->PostTask(
 549         FROM_HERE,
 550         base::Bind(
 551             base::IgnoreResult(&FakeShillServiceClient::SetServiceProperty),
 552             weak_ptr_factory_.GetWeakPtr(),
 553             service_path,
 554             shill::kErrorProperty,
 555             base::StringValue(shill::kErrorBadPassphrase)));
 556   } else {
 557     // Set Online.
 558     SetServiceProperty(service_path,
 559                        shill::kStateProperty,
 560                        base::StringValue(shill::kStateOnline));
 561   }
 562 }
 563
 564 }  // namespace chromeos