chromeos/network/managed_network_configuration_handler_impl.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/network/managed_network_configuration_handler_impl.h"
   6
   7 #include <set>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/guid.h"
  12 #include "base/location.h"
  13 #include "base/logging.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/stl_util.h"
  17 #include "base/values.h"
  18 #include "chromeos/dbus/shill_manager_client.h"
  19 #include "chromeos/dbus/shill_profile_client.h"
  20 #include "chromeos/dbus/shill_service_client.h"
  21 #include "chromeos/network/device_state.h"
  22 #include "chromeos/network/network_configuration_handler.h"
  23 #include "chromeos/network/network_device_handler.h"
  24 #include "chromeos/network/network_event_log.h"
  25 #include "chromeos/network/network_policy_observer.h"
  26 #include "chromeos/network/network_profile.h"
  27 #include "chromeos/network/network_profile_handler.h"
  28 #include "chromeos/network/network_state.h"
  29 #include "chromeos/network/network_state_handler.h"
  30 #include "chromeos/network/network_ui_data.h"
  31 #include "chromeos/network/onc/onc_merger.h"
  32 #include "chromeos/network/onc/onc_signature.h"
  33 #include "chromeos/network/onc/onc_translator.h"
  34 #include "chromeos/network/onc/onc_validator.h"
  35 #include "chromeos/network/policy_util.h"
  36 #include "chromeos/network/shill_property_util.h"
  37 #include "components/onc/onc_constants.h"
  38 #include "third_party/cros_system_api/dbus/service_constants.h"
  39
  40 namespace chromeos {
  41
  42 namespace {
  43
  44 typedef std::map<std::string, const base::DictionaryValue*> GuidToPolicyMap;
  45
  46 // These are error strings used for error callbacks. None of these error
  47 // messages are user-facing: they should only appear in logs.
  48 const char kInvalidUserSettings[] = "InvalidUserSettings";
  49 const char kNetworkAlreadyConfigured[] = "NetworkAlreadyConfigured";
  50 const char kPoliciesNotInitialized[] = "PoliciesNotInitialized";
  51 const char kProfileNotInitialized[] = "ProflieNotInitialized";
  52 const char kSetOnUnconfiguredNetwork[] = "SetCalledOnUnconfiguredNetwork";
  53 const char kUnknownProfilePath[] = "UnknownProfilePath";
  54 const char kUnknownNetwork[] = "UnknownNetwork";
  55
  56 std::string ToDebugString(::onc::ONCSource source,
  57                           const std::string& userhash) {
  58   return source == ::onc::ONC_SOURCE_USER_POLICY ?
  59       ("user policy of " + userhash) : "device policy";
  60 }
  61
  62 void InvokeErrorCallback(const std::string& service_path,
  63                          const network_handler::ErrorCallback& error_callback,
  64                          const std::string& error_name) {
  65   std::string error_msg = "ManagedConfig Error: " + error_name;
  66   NET_LOG_ERROR(error_msg, service_path);
  67   network_handler::RunErrorCallback(
  68       error_callback, service_path, error_name, error_msg);
  69 }
  70
  71 void LogErrorWithDict(const tracked_objects::Location& from_where,
  72                       const std::string& error_name,
  73                       scoped_ptr<base::DictionaryValue> error_data) {
  74   network_event_log::internal::AddEntry(
  75        from_where.file_name(), from_where.line_number(),
  76        network_event_log::LOG_LEVEL_ERROR,
  77        error_name, "");
  78 }
  79
  80 const base::DictionaryValue* GetByGUID(const GuidToPolicyMap& policies,
  81                                        const std::string& guid) {
  82   GuidToPolicyMap::const_iterator it = policies.find(guid);
  83   if (it == policies.end())
  84     return NULL;
  85   return it->second;
  86 }
  87
  88 }  // namespace
  89
  90 struct ManagedNetworkConfigurationHandlerImpl::Policies {
  91   ~Policies();
  92
  93   GuidToPolicyMap per_network_config;
  94   base::DictionaryValue global_network_config;
  95 };
  96
  97 ManagedNetworkConfigurationHandlerImpl::Policies::~Policies() {
  98   STLDeleteValues(&per_network_config);
  99 }
 100
 101 void ManagedNetworkConfigurationHandlerImpl::AddObserver(
 102     NetworkPolicyObserver* observer) {
 103   observers_.AddObserver(observer);
 104 }
 105
 106 void ManagedNetworkConfigurationHandlerImpl::RemoveObserver(
 107     NetworkPolicyObserver* observer) {
 108   observers_.RemoveObserver(observer);
 109 }
 110
 111 // GetManagedProperties
 112
 113 void ManagedNetworkConfigurationHandlerImpl::GetManagedProperties(
 114     const std::string& userhash,
 115     const std::string& service_path,
 116     const network_handler::DictionaryResultCallback& callback,
 117     const network_handler::ErrorCallback& error_callback) {
 118   if (!GetPoliciesForUser(userhash) || !GetPoliciesForUser(std::string())) {
 119     InvokeErrorCallback(service_path, error_callback, kPoliciesNotInitialized);
 120     return;
 121   }
 122   network_configuration_handler_->GetProperties(
 123       service_path,
 124       base::Bind(
 125           &ManagedNetworkConfigurationHandlerImpl::GetPropertiesCallback,
 126           weak_ptr_factory_.GetWeakPtr(),
 127           base::Bind(
 128               &ManagedNetworkConfigurationHandlerImpl::SendManagedProperties,
 129               weak_ptr_factory_.GetWeakPtr(),
 130               callback,
 131               error_callback)),
 132       error_callback);
 133 }
 134
 135 void ManagedNetworkConfigurationHandlerImpl::SendManagedProperties(
 136     const network_handler::DictionaryResultCallback& callback,
 137     const network_handler::ErrorCallback& error_callback,
 138     const std::string& service_path,
 139     scoped_ptr<base::DictionaryValue> shill_properties) {
 140   std::string profile_path;
 141   shill_properties->GetStringWithoutPathExpansion(shill::kProfileProperty,
 142                                                   &profile_path);
 143   const NetworkProfile* profile =
 144       network_profile_handler_->GetProfileForPath(profile_path);
 145   if (!profile)
 146     NET_LOG_ERROR("No profile for service: " + profile_path, service_path);
 147
 148   scoped_ptr<NetworkUIData> ui_data =
 149       shill_property_util::GetUIDataFromProperties(*shill_properties);
 150
 151   const base::DictionaryValue* user_settings = NULL;
 152   const base::DictionaryValue* shared_settings = NULL;
 153
 154   if (ui_data && profile) {
 155     if (profile->type() == NetworkProfile::TYPE_SHARED)
 156       shared_settings = ui_data->user_settings();
 157     else if (profile->type() == NetworkProfile::TYPE_USER)
 158       user_settings = ui_data->user_settings();
 159     else
 160       NOTREACHED();
 161   } else if (profile) {
 162     NET_LOG_ERROR("Service contains empty or invalid UIData", service_path);
 163     // TODO(pneubeck): add a conversion of user configured entries of old
 164     // ChromeOS versions. We will have to use a heuristic to determine which
 165     // properties _might_ be user configured.
 166   }
 167
 168   scoped_ptr<base::DictionaryValue> active_settings(
 169       onc::TranslateShillServiceToONCPart(
 170           *shill_properties,
 171           &onc::kNetworkWithStateSignature));
 172
 173   std::string guid;
 174   active_settings->GetStringWithoutPathExpansion(::onc::network_config::kGUID,
 175                                                  &guid);
 176
 177   const base::DictionaryValue* user_policy = NULL;
 178   const base::DictionaryValue* device_policy = NULL;
 179   if (!guid.empty() && profile) {
 180     const Policies* policies = GetPoliciesForProfile(*profile);
 181     if (!policies) {
 182       InvokeErrorCallback(
 183           service_path, error_callback, kPoliciesNotInitialized);
 184       return;
 185     }
 186     const base::DictionaryValue* policy =
 187         GetByGUID(policies->per_network_config, guid);
 188     if (profile->type() == NetworkProfile::TYPE_SHARED)
 189       device_policy = policy;
 190     else if (profile->type() == NetworkProfile::TYPE_USER)
 191       user_policy = policy;
 192     else
 193       NOTREACHED();
 194   }
 195
 196   // This call also removes credentials from policies.
 197   scoped_ptr<base::DictionaryValue> augmented_properties =
 198       onc::MergeSettingsAndPoliciesToAugmented(
 199           onc::kNetworkConfigurationSignature,
 200           user_policy,
 201           device_policy,
 202           user_settings,
 203           shared_settings,
 204           active_settings.get());
 205   callback.Run(service_path, *augmented_properties);
 206 }
 207
 208 // GetProperties
 209
 210 void ManagedNetworkConfigurationHandlerImpl::GetProperties(
 211     const std::string& service_path,
 212     const network_handler::DictionaryResultCallback& callback,
 213     const network_handler::ErrorCallback& error_callback) {
 214   network_configuration_handler_->GetProperties(
 215       service_path,
 216       base::Bind(
 217           &ManagedNetworkConfigurationHandlerImpl::GetPropertiesCallback,
 218           weak_ptr_factory_.GetWeakPtr(),
 219           base::Bind(&ManagedNetworkConfigurationHandlerImpl::SendProperties,
 220                      weak_ptr_factory_.GetWeakPtr(),
 221                      callback,
 222                      error_callback)),
 223       error_callback);
 224 }
 225
 226 void ManagedNetworkConfigurationHandlerImpl::SendProperties(
 227     const network_handler::DictionaryResultCallback& callback,
 228     const network_handler::ErrorCallback& error_callback,
 229     const std::string& service_path,
 230     scoped_ptr<base::DictionaryValue> shill_properties) {
 231   scoped_ptr<base::DictionaryValue> onc_network(
 232       onc::TranslateShillServiceToONCPart(*shill_properties,
 233                                           &onc::kNetworkWithStateSignature));
 234   callback.Run(service_path, *onc_network);
 235 }
 236
 237 // SetProperties
 238
 239 void ManagedNetworkConfigurationHandlerImpl::SetProperties(
 240     const std::string& service_path,
 241     const base::DictionaryValue& user_settings,
 242     const base::Closure& callback,
 243     const network_handler::ErrorCallback& error_callback) const {
 244   const NetworkState* state =
 245       network_state_handler_->GetNetworkStateFromServicePath(
 246           service_path, true /* configured_only */);
 247   if (!state) {
 248     InvokeErrorCallback(service_path, error_callback, kUnknownNetwork);
 249     return;
 250   }
 251
 252   std::string guid = state->guid();
 253   if (guid.empty()) {
 254     // TODO(pneubeck): create an initial configuration in this case. As for
 255     // CreateConfiguration, user settings from older ChromeOS versions have to
 256     // determined here.
 257     InvokeErrorCallback(
 258         service_path, error_callback, kSetOnUnconfiguredNetwork);
 259     return;
 260   }
 261
 262   const std::string& profile_path = state->profile_path();
 263   const NetworkProfile *profile =
 264       network_profile_handler_->GetProfileForPath(profile_path);
 265   if (!profile) {
 266     InvokeErrorCallback(service_path, error_callback, kUnknownProfilePath);
 267     return;
 268   }
 269
 270   VLOG(2) << "SetProperties: Found GUID " << guid << " and profile "
 271           << profile->ToDebugString();
 272
 273   const Policies* policies = GetPoliciesForProfile(*profile);
 274   if (!policies) {
 275     InvokeErrorCallback(service_path, error_callback, kPoliciesNotInitialized);
 276     return;
 277   }
 278
 279   // Validate the ONC dictionary. We are liberal and ignore unknown field
 280   // names. User settings are only partial ONC, thus we ignore missing fields.
 281   onc::Validator validator(false,  // Ignore unknown fields.
 282                            false,  // Ignore invalid recommended field names.
 283                            false,  // Ignore missing fields.
 284                            false);  // This ONC does not come from policy.
 285
 286   onc::Validator::Result validation_result;
 287   scoped_ptr<base::DictionaryValue> validated_user_settings =
 288       validator.ValidateAndRepairObject(
 289           &onc::kNetworkConfigurationSignature,
 290           user_settings,
 291           &validation_result);
 292
 293   if (validation_result == onc::Validator::INVALID) {
 294     InvokeErrorCallback(service_path, error_callback, kInvalidUserSettings);
 295     return;
 296   }
 297   if (validation_result == onc::Validator::VALID_WITH_WARNINGS)
 298     LOG(WARNING) << "Validation of ONC user settings produced warnings.";
 299
 300   const base::DictionaryValue* policy =
 301       GetByGUID(policies->per_network_config, guid);
 302   VLOG(2) << "This configuration is " << (policy ? "" : "not ") << "managed.";
 303
 304   scoped_ptr<base::DictionaryValue> shill_dictionary(
 305       policy_util::CreateShillConfiguration(
 306           *profile, guid, policy, validated_user_settings.get()));
 307
 308   network_configuration_handler_->SetProperties(
 309       service_path, *shill_dictionary, callback, error_callback);
 310 }
 311
 312 void ManagedNetworkConfigurationHandlerImpl::CreateConfiguration(
 313     const std::string& userhash,
 314     const base::DictionaryValue& properties,
 315     const network_handler::StringResultCallback& callback,
 316     const network_handler::ErrorCallback& error_callback) const {
 317   const Policies* policies = GetPoliciesForUser(userhash);
 318   if (!policies) {
 319     InvokeErrorCallback("", error_callback, kPoliciesNotInitialized);
 320     return;
 321   }
 322
 323   if (policy_util::FindMatchingPolicy(policies->per_network_config,
 324                                       properties)) {
 325     InvokeErrorCallback("", error_callback, kNetworkAlreadyConfigured);
 326     return;
 327   }
 328
 329   const NetworkProfile* profile =
 330       network_profile_handler_->GetProfileForUserhash(userhash);
 331   if (!profile) {
 332     InvokeErrorCallback("", error_callback, kProfileNotInitialized);
 333     return;
 334   }
 335
 336   // TODO(pneubeck): In case of WiFi, check that no other configuration for the
 337   // same {SSID, mode, security} exists. We don't support such multiple
 338   // configurations, yet.
 339
 340   // Generate a new GUID for this configuration. Ignore the maybe provided GUID
 341   // in |properties| as it is not our own and from an untrusted source.
 342   std::string guid = base::GenerateGUID();
 343   scoped_ptr<base::DictionaryValue> shill_dictionary(
 344       policy_util::CreateShillConfiguration(
 345           *profile, guid, NULL /*no policy*/, &properties));
 346
 347   network_configuration_handler_->CreateConfiguration(
 348       *shill_dictionary, callback, error_callback);
 349 }
 350
 351 void ManagedNetworkConfigurationHandlerImpl::RemoveConfiguration(
 352     const std::string& service_path,
 353     const base::Closure& callback,
 354     const network_handler::ErrorCallback& error_callback) const {
 355   network_configuration_handler_->RemoveConfiguration(
 356       service_path, callback, error_callback);
 357 }
 358
 359 void ManagedNetworkConfigurationHandlerImpl::SetPolicy(
 360     ::onc::ONCSource onc_source,
 361     const std::string& userhash,
 362     const base::ListValue& network_configs_onc,
 363     const base::DictionaryValue& global_network_config) {
 364   VLOG(1) << "Setting policies from " << ToDebugString(onc_source, userhash)
 365           << ".";
 366
 367   // |userhash| must be empty for device policies.
 368   DCHECK(onc_source != ::onc::ONC_SOURCE_DEVICE_POLICY ||
 369          userhash.empty());
 370   Policies* policies = NULL;
 371   if (ContainsKey(policies_by_user_, userhash)) {
 372     policies = policies_by_user_[userhash].get();
 373   } else {
 374     policies = new Policies;
 375     policies_by_user_[userhash] = make_linked_ptr(policies);
 376   }
 377
 378   policies->global_network_config.MergeDictionary(&global_network_config);
 379
 380   GuidToPolicyMap old_per_network_config;
 381   policies->per_network_config.swap(old_per_network_config);
 382
 383   // This stores all GUIDs of policies that have changed or are new.
 384   std::set<std::string> modified_policies;
 385
 386   for (base::ListValue::const_iterator it = network_configs_onc.begin();
 387        it != network_configs_onc.end(); ++it) {
 388     const base::DictionaryValue* network = NULL;
 389     (*it)->GetAsDictionary(&network);
 390     DCHECK(network);
 391
 392     std::string guid;
 393     network->GetStringWithoutPathExpansion(::onc::network_config::kGUID, &guid);
 394     DCHECK(!guid.empty());
 395
 396     if (policies->per_network_config.count(guid) > 0) {
 397       NET_LOG_ERROR("ONC from " + ToDebugString(onc_source, userhash) +
 398                     " contains several entries for the same GUID ", guid);
 399       delete policies->per_network_config[guid];
 400     }
 401     const base::DictionaryValue* new_entry = network->DeepCopy();
 402     policies->per_network_config[guid] = new_entry;
 403
 404     const base::DictionaryValue* old_entry = old_per_network_config[guid];
 405     if (!old_entry || !old_entry->Equals(new_entry))
 406       modified_policies.insert(guid);
 407   }
 408
 409   STLDeleteValues(&old_per_network_config);
 410
 411   const NetworkProfile* profile =
 412       network_profile_handler_->GetProfileForUserhash(userhash);
 413   if (profile) {
 414     scoped_refptr<PolicyApplicator> applicator =
 415         new PolicyApplicator(weak_ptr_factory_.GetWeakPtr(),
 416                              *profile,
 417                              policies->per_network_config,
 418                              policies->global_network_config,
 419                              &modified_policies);
 420     applicator->Run();
 421   } else {
 422     VLOG(1) << "The relevant Shill profile isn't initialized yet, postponing "
 423             << "policy application.";
 424     // See OnProfileAdded.
 425   }
 426
 427   FOR_EACH_OBSERVER(NetworkPolicyObserver, observers_, PolicyChanged(userhash));
 428 }
 429
 430 void ManagedNetworkConfigurationHandlerImpl::OnProfileAdded(
 431     const NetworkProfile& profile) {
 432   VLOG(1) << "Adding profile " << profile.ToDebugString() << "'.";
 433
 434   const Policies* policies = GetPoliciesForProfile(profile);
 435   if (!policies) {
 436     VLOG(1) << "The relevant policy is not initialized, "
 437             << "postponing policy application.";
 438     // See SetPolicy.
 439     return;
 440   }
 441
 442   std::set<std::string> policy_guids;
 443   for (GuidToPolicyMap::const_iterator it =
 444            policies->per_network_config.begin();
 445        it != policies->per_network_config.end(); ++it) {
 446     policy_guids.insert(it->first);
 447   }
 448
 449   scoped_refptr<PolicyApplicator> applicator =
 450       new PolicyApplicator(weak_ptr_factory_.GetWeakPtr(),
 451                            profile,
 452                            policies->per_network_config,
 453                            policies->global_network_config,
 454                            &policy_guids);
 455   applicator->Run();
 456 }
 457
 458 void ManagedNetworkConfigurationHandlerImpl::OnProfileRemoved(
 459     const NetworkProfile& profile) {
 460   // Nothing to do in this case.
 461 }
 462
 463 void ManagedNetworkConfigurationHandlerImpl::CreateConfigurationFromPolicy(
 464     const base::DictionaryValue& shill_properties) {
 465   network_configuration_handler_->CreateConfiguration(
 466       shill_properties,
 467       base::Bind(
 468           &ManagedNetworkConfigurationHandlerImpl::OnPolicyAppliedToNetwork,
 469           weak_ptr_factory_.GetWeakPtr()),
 470       base::Bind(&LogErrorWithDict, FROM_HERE));
 471 }
 472
 473 void ManagedNetworkConfigurationHandlerImpl::
 474     UpdateExistingConfigurationWithPropertiesFromPolicy(
 475         const base::DictionaryValue& existing_properties,
 476         const base::DictionaryValue& new_properties) {
 477   base::DictionaryValue shill_properties;
 478
 479   std::string profile;
 480   existing_properties.GetStringWithoutPathExpansion(shill::kProfileProperty,
 481                                                     &profile);
 482   if (profile.empty()) {
 483     NET_LOG_ERROR("Missing profile property",
 484                   shill_property_util::GetNetworkIdFromProperties(
 485                       existing_properties));
 486     return;
 487   }
 488   shill_properties.SetStringWithoutPathExpansion(shill::kProfileProperty,
 489                                                  profile);
 490
 491   if (!shill_property_util::CopyIdentifyingProperties(
 492           existing_properties,
 493           true /* properties were read from Shill */,
 494           &shill_properties)) {
 495     NET_LOG_ERROR("Missing identifying properties",
 496                   shill_property_util::GetNetworkIdFromProperties(
 497                       existing_properties));
 498   }
 499
 500   shill_properties.MergeDictionary(&new_properties);
 501
 502   network_configuration_handler_->CreateConfiguration(
 503       shill_properties,
 504       base::Bind(
 505           &ManagedNetworkConfigurationHandlerImpl::OnPolicyAppliedToNetwork,
 506           weak_ptr_factory_.GetWeakPtr()),
 507       base::Bind(&LogErrorWithDict, FROM_HERE));
 508 }
 509
 510 void ManagedNetworkConfigurationHandlerImpl::OnPoliciesApplied() {
 511 }
 512
 513 const base::DictionaryValue*
 514 ManagedNetworkConfigurationHandlerImpl::FindPolicyByGUID(
 515     const std::string userhash,
 516     const std::string& guid,
 517     ::onc::ONCSource* onc_source) const {
 518   *onc_source = ::onc::ONC_SOURCE_NONE;
 519
 520   if (!userhash.empty()) {
 521     const Policies* user_policies = GetPoliciesForUser(userhash);
 522     if (user_policies) {
 523       const base::DictionaryValue* policy =
 524           GetByGUID(user_policies->per_network_config, guid);
 525       if (policy) {
 526         *onc_source = ::onc::ONC_SOURCE_USER_POLICY;
 527         return policy;
 528       }
 529     }
 530   }
 531
 532   const Policies* device_policies = GetPoliciesForUser(std::string());
 533   if (device_policies) {
 534     const base::DictionaryValue* policy =
 535         GetByGUID(device_policies->per_network_config, guid);
 536     if (policy) {
 537       *onc_source = ::onc::ONC_SOURCE_DEVICE_POLICY;
 538       return policy;
 539     }
 540   }
 541
 542   return NULL;
 543 }
 544
 545 const base::DictionaryValue*
 546 ManagedNetworkConfigurationHandlerImpl::GetGlobalConfigFromPolicy(
 547     const std::string userhash) const {
 548   const Policies* policies = GetPoliciesForUser(userhash);
 549   if (!policies)
 550     return NULL;
 551
 552   return &policies->global_network_config;
 553 }
 554 const base::DictionaryValue*
 555 ManagedNetworkConfigurationHandlerImpl::FindPolicyByGuidAndProfile(
 556     const std::string& guid,
 557     const std::string& profile_path) const {
 558   const NetworkProfile* profile =
 559       network_profile_handler_->GetProfileForPath(profile_path);
 560   if (!profile) {
 561     NET_LOG_ERROR("Profile path unknown:" + profile_path, guid);
 562     return NULL;
 563   }
 564
 565   const Policies* policies = GetPoliciesForProfile(*profile);
 566   if (!policies)
 567     return NULL;
 568
 569   return GetByGUID(policies->per_network_config, guid);
 570 }
 571
 572 const ManagedNetworkConfigurationHandlerImpl::Policies*
 573 ManagedNetworkConfigurationHandlerImpl::GetPoliciesForUser(
 574     const std::string& userhash) const {
 575   UserToPoliciesMap::const_iterator it = policies_by_user_.find(userhash);
 576   if (it == policies_by_user_.end())
 577     return NULL;
 578   return it->second.get();
 579 }
 580
 581 const ManagedNetworkConfigurationHandlerImpl::Policies*
 582 ManagedNetworkConfigurationHandlerImpl::GetPoliciesForProfile(
 583     const NetworkProfile& profile) const {
 584   DCHECK(profile.type() != NetworkProfile::TYPE_SHARED ||
 585          profile.userhash.empty());
 586   return GetPoliciesForUser(profile.userhash);
 587 }
 588
 589 ManagedNetworkConfigurationHandlerImpl::ManagedNetworkConfigurationHandlerImpl()
 590     : network_state_handler_(NULL),
 591       network_profile_handler_(NULL),
 592       network_configuration_handler_(NULL),
 593       network_device_handler_(NULL),
 594       weak_ptr_factory_(this) {}
 595
 596 ManagedNetworkConfigurationHandlerImpl::
 597     ~ManagedNetworkConfigurationHandlerImpl() {
 598   network_profile_handler_->RemoveObserver(this);
 599 }
 600
 601 void ManagedNetworkConfigurationHandlerImpl::Init(
 602     NetworkStateHandler* network_state_handler,
 603     NetworkProfileHandler* network_profile_handler,
 604     NetworkConfigurationHandler* network_configuration_handler,
 605     NetworkDeviceHandler* network_device_handler) {
 606   network_state_handler_ = network_state_handler;
 607   network_profile_handler_ = network_profile_handler;
 608   network_configuration_handler_ = network_configuration_handler;
 609   network_device_handler_ = network_device_handler;
 610   network_profile_handler_->AddObserver(this);
 611 }
 612
 613 void ManagedNetworkConfigurationHandlerImpl::OnPolicyAppliedToNetwork(
 614     const std::string& service_path) {
 615   if (service_path.empty())
 616     return;
 617   FOR_EACH_OBSERVER(
 618       NetworkPolicyObserver, observers_, PolicyApplied(service_path));
 619 }
 620
 621 // Get{Managed}Properties helpers
 622
 623 void ManagedNetworkConfigurationHandlerImpl::GetDeviceStateProperties(
 624     const std::string& service_path,
 625     base::DictionaryValue* properties) {
 626   std::string connection_state;
 627   properties->GetStringWithoutPathExpansion(
 628       shill::kStateProperty, &connection_state);
 629   if (!NetworkState::StateIsConnected(connection_state))
 630     return;
 631
 632   // Get the IPConfig properties from the device and store them in "IPConfigs"
 633   // (plural) in the properties dictionary. (Note: Shill only provides a single
 634   // "IPConfig" property for a network service, but a consumer of this API may
 635   // want information about all ipv4 and ipv6 IPConfig properties.
 636   std::string device;
 637   properties->GetStringWithoutPathExpansion(shill::kDeviceProperty, &device);
 638   const DeviceState* device_state =
 639       network_state_handler_->GetDeviceState(device);
 640   if (!device_state) {
 641     NET_LOG_ERROR("GetDeviceProperties: no device: " + device, service_path);
 642     return;
 643   }
 644
 645   // Get the hardware MAC address from the DeviceState.
 646   if (!device_state->mac_address().empty()) {
 647     properties->SetStringWithoutPathExpansion(
 648         shill::kAddressProperty, device_state->mac_address());
 649   }
 650
 651   // Convert IPConfig dictionary to a ListValue.
 652   base::ListValue* ip_configs = new base::ListValue;
 653   for (base::DictionaryValue::Iterator iter(device_state->ip_configs());
 654        !iter.IsAtEnd(); iter.Advance()) {
 655     ip_configs->Append(iter.value().DeepCopy());
 656   }
 657   properties->SetWithoutPathExpansion(shill::kIPConfigsProperty, ip_configs);
 658 }
 659
 660 void ManagedNetworkConfigurationHandlerImpl::GetPropertiesCallback(
 661     GetDevicePropertiesCallback send_callback,
 662     const std::string& service_path,
 663     const base::DictionaryValue& shill_properties) {
 664   scoped_ptr<base::DictionaryValue> shill_properties_copy(
 665       shill_properties.DeepCopy());
 666
 667   // Add associated Device properties before the ONC translation.
 668   GetDeviceStateProperties(service_path, shill_properties_copy.get());
 669
 670   // Only request Device properties for Cellular networks with a valid device.
 671   std::string type, device_path;
 672   if (!network_device_handler_ ||
 673       !shill_properties_copy->GetStringWithoutPathExpansion(
 674           shill::kTypeProperty, &type) ||
 675       type != shill::kTypeCellular ||
 676       !shill_properties_copy->GetStringWithoutPathExpansion(
 677           shill::kDeviceProperty, &device_path) ||
 678       device_path.empty()) {
 679     send_callback.Run(service_path, shill_properties_copy.Pass());
 680     return;
 681   }
 682
 683   // Request the device properties. On success or failure pass (a possibly
 684   // modified) |shill_properties| to |send_callback|.
 685   scoped_ptr<base::DictionaryValue> shill_properties_copy_error_copy(
 686       shill_properties_copy->DeepCopy());
 687   network_device_handler_->GetDeviceProperties(
 688       device_path,
 689       base::Bind(&ManagedNetworkConfigurationHandlerImpl::
 690                      GetDevicePropertiesSuccess,
 691                  weak_ptr_factory_.GetWeakPtr(),
 692                  service_path,
 693                  base::Passed(&shill_properties_copy),
 694                  send_callback),
 695       base::Bind(&ManagedNetworkConfigurationHandlerImpl::
 696                      GetDevicePropertiesFailure,
 697                  weak_ptr_factory_.GetWeakPtr(),
 698                  service_path,
 699                  base::Passed(&shill_properties_copy_error_copy),
 700                  send_callback));
 701 }
 702
 703 void ManagedNetworkConfigurationHandlerImpl::GetDevicePropertiesSuccess(
 704     const std::string& service_path,
 705     scoped_ptr<base::DictionaryValue> network_properties,
 706     GetDevicePropertiesCallback send_callback,
 707     const std::string& device_path,
 708     const base::DictionaryValue& device_properties) {
 709   // Create a "Device" dictionary in |network_properties|.
 710   network_properties->SetWithoutPathExpansion(
 711       shill::kDeviceProperty, device_properties.DeepCopy());
 712   send_callback.Run(service_path, network_properties.Pass());
 713 }
 714
 715 void ManagedNetworkConfigurationHandlerImpl::GetDevicePropertiesFailure(
 716     const std::string& service_path,
 717     scoped_ptr<base::DictionaryValue> network_properties,
 718     GetDevicePropertiesCallback send_callback,
 719     const std::string& error_name,
 720     scoped_ptr<base::DictionaryValue> error_data) {
 721   NET_LOG_ERROR("Error getting device properties", service_path);
 722   send_callback.Run(service_path, network_properties.Pass());
 723 }
 724
 725
 726 }  // namespace chromeos