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