Automatically resolve ClientCertificatePatterns.

chromeos/network/managed_network_configuration_handler.cc

 // Copyright (c) 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/network/managed_network_configuration_handler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_method_call_status.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_handler_callbacks.h"
+#include "chromeos/network/network_policy_observer.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_ui_data.h"
 #include "chromeos/network/onc/onc_constants.h"
 #include "chromeos/network/onc/onc_merger.h"
 #include "chromeos/network/onc/onc_normalizer.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translator.h"
@@ skipping 53 matching lines @@
 void SetUIData(const NetworkUIData& ui_data,
                base::DictionaryValue* shill_dictionary) {
   base::DictionaryValue ui_data_dict;
   ui_data.FillDictionary(&ui_data_dict);
   std::string ui_data_blob;
   base::JSONWriter::Write(&ui_data_dict, &ui_data_blob);
   shill_dictionary->SetStringWithoutPathExpansion(flimflam::kUIDataProperty,
                                                   ui_data_blob);
 }
 
-// A dummy callback to ignore the result of Shill calls.
-void IgnoreString(const std::string& str) {
-}
-
 void LogErrorWithDict(const tracked_objects::Location& from_where,
                       const std::string& error_name,
                       scoped_ptr<base::DictionaryValue> error_data) {
   LOG(ERROR) << from_where.ToString() << ": " << error_name;
 }
 
 void LogErrorMessage(const tracked_objects::Location& from_where,
                      const std::string& error_name,
                      const std::string& error_message) {
   LOG(ERROR) << from_where.ToString() << ": " << error_message;
@@ skipping 252 matching lines @@
         onc::ReadDictionaryFromJson(ui_data_blob);
     if (ui_data_dict)
       return make_scoped_ptr(new NetworkUIData(*ui_data_dict));
     else
       LOG(ERROR) << "UIData is not a valid JSON dictionary.";
   }
   VLOG(2) << "JSON dictionary has no UIData blob: " << shill_dictionary;
   return scoped_ptr<NetworkUIData>();
 }
 
+void ManagedNetworkConfigurationHandler::AddObserver(
+    NetworkPolicyObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void ManagedNetworkConfigurationHandler::RemoveObserver(
+    NetworkPolicyObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 void ManagedNetworkConfigurationHandler::GetManagedProperties(
     const std::string& userhash,
     const std::string& service_path,
     const network_handler::DictionaryResultCallback& callback,
     const network_handler::ErrorCallback& error_callback) {
   if (!GetPoliciesForUser(userhash) || !GetPoliciesForUser(std::string())) {
     RunErrorCallback(service_path,
                      kPoliciesNotInitialized,
                      kPoliciesNotInitializedMessage,
                      error_callback);
@@ skipping 340 matching lines @@
     GuidToPolicyMap::const_iterator found = device_policies->find(guid);
     if (found != device_policies->end()) {
       *onc_source = onc::ONC_SOURCE_DEVICE_POLICY;
       return found->second;
     }
   }
 
   return NULL;
 }
 
+const base::DictionaryValue*
+ManagedNetworkConfigurationHandler::FindPolicyByGuidAndProfile(
+    const std::string& guid,
+    const std::string& profile_path) const {
+  const NetworkProfile* profile =
+      network_profile_handler_->GetProfileForPath(profile_path);
+  if (!profile) {
+    LOG(ERROR) << "Profile path unknown: " << profile_path;
+    return NULL;
+  }
+
+  const GuidToPolicyMap* policies = GetPoliciesForProfile(*profile);
+  if (!policies)
+    return NULL;
+
+  GuidToPolicyMap::const_iterator it = policies->find(guid);
+  if (it == policies->end())
+    return NULL;
+  return it->second;
+}
+
 void ManagedNetworkConfigurationHandler::OnProfileRemoved(
     const NetworkProfile& profile) {
   // Nothing to do in this case.
 }
 
 const ManagedNetworkConfigurationHandler::GuidToPolicyMap*
 ManagedNetworkConfigurationHandler::GetPoliciesForUser(
     const std::string& userhash) const {
   UserToPoliciesMap::const_iterator it = policies_by_user_.find(userhash);
   if (it == policies_by_user_.end())
@@ skipping 27 matching lines @@
 void ManagedNetworkConfigurationHandler::Init(
     NetworkStateHandler* network_state_handler,
     NetworkProfileHandler* network_profile_handler,
     NetworkConfigurationHandler* network_configuration_handler) {
   network_state_handler_ = network_state_handler;
   network_profile_handler_ = network_profile_handler;
   network_configuration_handler_ = network_configuration_handler;
   network_profile_handler_->AddObserver(this);
 }
 
+void ManagedNetworkConfigurationHandler::OnPolicyApplied(
+    const std::string& service_path) {
+  if (service_path.empty())
+    return;
+  FOR_EACH_OBSERVER(
+      NetworkPolicyObserver, observers_, PolicyApplied(service_path));
+}
+
 ManagedNetworkConfigurationHandler::PolicyApplicator::PolicyApplicator(
     base::WeakPtr<ManagedNetworkConfigurationHandler> handler,
     const NetworkProfile& profile,
     std::set<std::string>* modified_policies)
     : handler_(handler), profile_(profile) {
   remaining_policies_.swap(*modified_policies);
 }
 
 void ManagedNetworkConfigurationHandler::PolicyApplicator::Run() {
   DBusThreadManager::Get()->GetShillProfileClient()->GetProperties(
@@ skipping 120 matching lines @@
         DeleteEntry(entry);
       }
 
       const base::DictionaryValue* user_settings =
           ui_data ? ui_data->user_settings() : NULL;
 
       // Write the new configuration.
       scoped_ptr<base::DictionaryValue> shill_dictionary =
           CreateShillConfiguration(
               profile_, new_guid, new_policy, user_settings);
-      handler_->network_configuration_handler()
-          ->CreateConfiguration(*shill_dictionary,
-                                base::Bind(&IgnoreString),
-                                base::Bind(&LogErrorWithDict, FROM_HERE));
+      handler_->network_configuration_handler()->CreateConfiguration(
+          *shill_dictionary,
+          base::Bind(&ManagedNetworkConfigurationHandler::OnPolicyApplied,
+                     handler_),
+          base::Bind(&LogErrorWithDict, FROM_HERE));
       remaining_policies_.erase(new_guid);
     }
   } else if (was_managed) {
     VLOG(1) << "Removing configuration previously managed by policy "
             << old_guid << ", because the policy was removed.";
 
     // Remove the entry, because the network was managed but isn't anymore.
     // Note: An alternative might be to preserve the user settings, but it's
     // unclear which values originating the policy should be removed.
     DeleteEntry(entry);
@@ skipping 42 matching lines @@
       LOG(ERROR) << "Policy " << *it << " doesn't exist anymore.";
       continue;
     }
 
     VLOG(1) << "Creating new configuration managed by policy " << *it
             << " in profile " << profile_.ToDebugString() << ".";
 
     scoped_ptr<base::DictionaryValue> shill_dictionary =
         CreateShillConfiguration(
             profile_, *it, policy, NULL /* no user settings */);
-    handler_->network_configuration_handler()
-        ->CreateConfiguration(*shill_dictionary,
-                              base::Bind(&IgnoreString),
-                              base::Bind(&LogErrorWithDict, FROM_HERE));
+    handler_->network_configuration_handler()->CreateConfiguration(
+        *shill_dictionary,
+        base::Bind(&ManagedNetworkConfigurationHandler::OnPolicyApplied,
+                   handler_),
+        base::Bind(&LogErrorWithDict, FROM_HERE));
   }
 }
 
 }  // namespace chromeos