network_configuration_updater.cc revision 8bcbed890bc3ce4d7a057a8f32cab53fa534672e 
1// Copyright (c) 2012 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 "chrome/browser/chromeos/policy/network_configuration_updater.h"
6
7#include "base/bind.h"
8#include "base/bind_helpers.h"
9#include "base/logging.h"
10#include "base/values.h"
11#include "chrome/browser/policy/policy_map.h"
12#include "chromeos/network/managed_network_configuration_handler.h"
13#include "chromeos/network/onc/onc_certificate_importer.h"
14#include "chromeos/network/onc/onc_utils.h"
15#include "policy/policy_constants.h"
16
17namespace policy {
18
19NetworkConfigurationUpdater::~NetworkConfigurationUpdater() {
20  policy_service_->RemoveObserver(POLICY_DOMAIN_CHROME, this);
21}
22
23// static
24scoped_ptr<NetworkConfigurationUpdater>
25NetworkConfigurationUpdater::CreateForDevicePolicy(
26    scoped_ptr<chromeos::onc::CertificateImporter> certificate_importer,
27    PolicyService* policy_service,
28    chromeos::ManagedNetworkConfigurationHandler* network_config_handler) {
29  scoped_ptr<NetworkConfigurationUpdater> updater(
30      new NetworkConfigurationUpdater(onc::ONC_SOURCE_DEVICE_POLICY,
31                                      key::kDeviceOpenNetworkConfiguration,
32                                      certificate_importer.Pass(),
33                                      policy_service,
34                                      network_config_handler));
35  updater->Init();
36  return updater.Pass();
37}
38
39void NetworkConfigurationUpdater::OnPolicyUpdated(const PolicyNamespace& ns,
40                                                  const PolicyMap& previous,
41                                                  const PolicyMap& current) {
42  // Ignore this call. Policy changes are already observed by the registrar.
43}
44
45void NetworkConfigurationUpdater::OnPolicyServiceInitialized(
46    PolicyDomain domain) {
47  if (domain != POLICY_DOMAIN_CHROME)
48    return;
49
50  if (policy_service_->IsInitializationComplete(POLICY_DOMAIN_CHROME)) {
51    VLOG(1) << LogHeader() << " initialized.";
52    policy_service_->RemoveObserver(POLICY_DOMAIN_CHROME, this);
53    ApplyPolicy();
54  }
55}
56
57NetworkConfigurationUpdater::NetworkConfigurationUpdater(
58    onc::ONCSource onc_source,
59    std::string policy_key,
60    scoped_ptr<chromeos::onc::CertificateImporter> certificate_importer,
61    PolicyService* policy_service,
62    chromeos::ManagedNetworkConfigurationHandler* network_config_handler)
63    : onc_source_(onc_source),
64      network_config_handler_(network_config_handler),
65      certificate_importer_(certificate_importer.Pass()),
66      policy_key_(policy_key),
67      policy_change_registrar_(policy_service,
68                               PolicyNamespace(POLICY_DOMAIN_CHROME,
69                                               std::string())),
70      policy_service_(policy_service) {
71}
72
73void NetworkConfigurationUpdater::Init() {
74  policy_change_registrar_.Observe(
75      policy_key_,
76      base::Bind(&NetworkConfigurationUpdater::OnPolicyChanged,
77                 base::Unretained(this)));
78
79  if (policy_service_->IsInitializationComplete(POLICY_DOMAIN_CHROME)) {
80    VLOG(1) << LogHeader() << " is already initialized.";
81    ApplyPolicy();
82  } else {
83    policy_service_->AddObserver(POLICY_DOMAIN_CHROME, this);
84  }
85}
86
87void NetworkConfigurationUpdater::ImportCertificates(
88    const base::ListValue& certificates_onc) {
89  certificate_importer_->ImportCertificates(
90      certificates_onc, onc_source_, NULL);
91}
92
93void NetworkConfigurationUpdater::ApplyNetworkPolicy(
94    base::ListValue* network_configs_onc,
95    base::DictionaryValue* global_network_config) {
96  network_config_handler_->SetPolicy(onc_source_,
97                                     std::string() /* no username hash */,
98                                     *network_configs_onc,
99                                     *global_network_config);
100}
101
102void NetworkConfigurationUpdater::OnPolicyChanged(
103    const base::Value* previous,
104    const base::Value* current) {
105  VLOG(1) << LogHeader() << " changed.";
106  ApplyPolicy();
107}
108
109void NetworkConfigurationUpdater::ApplyPolicy() {
110  const PolicyMap& policies = policy_service_->GetPolicies(
111      PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()));
112  const base::Value* policy_value = policies.GetValue(policy_key_);
113
114  std::string onc_blob;
115  if (!policy_value)
116    VLOG(2) << LogHeader() << " is not set.";
117  else if (!policy_value->GetAsString(&onc_blob))
118    LOG(ERROR) << LogHeader() << " is not a string value.";
119
120  base::ListValue network_configs;
121  base::DictionaryValue global_network_config;
122  base::ListValue certificates;
123  chromeos::onc::ParseAndValidateOncForImport(onc_blob,
124                                              onc_source_,
125                                              "" /* no passphrase */,
126                                              &network_configs,
127                                              &global_network_config,
128                                              &certificates);
129
130  ImportCertificates(certificates);
131  ApplyNetworkPolicy(&network_configs, &global_network_config);
132}
133
134std::string NetworkConfigurationUpdater::LogHeader() const {
135  return chromeos::onc::GetSourceAsString(onc_source_);
136}
137
138}  // namespace policy
139