Add an Ethernet EAP policy.

chromeos/network/policy_util.cc

 // Copyright 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/policy_util.h"
 
 #include "base/logging.h"
+#include "base/values.h"
 #include "chromeos/network/network_profile.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"
 #include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/shill_property_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
@@ skipping 54 matching lines @@
 // Returns true if |policy| matches |actual_network|, which must be part of a
 // ONC NetworkConfiguration. This should be the only such matching function
 // within Chrome. Shill does such matching in several functions for network
 // identification. For compatibility, we currently should stick to Shill's
 // matching behavior.
 bool IsPolicyMatching(const base::DictionaryValue& policy,
                       const base::DictionaryValue& actual_network) {
   std::string policy_type;
   policy.GetStringWithoutPathExpansion(onc::network_config::kType,
                                        &policy_type);
-  std::string network_type;
+  std::string actual_network_type;
   actual_network.GetStringWithoutPathExpansion(onc::network_config::kType,
-                                               &network_type);
-  if (policy_type != network_type)
+                                               &actual_network_type);
+  if (policy_type != actual_network_type)
     return false;
 
-  if (network_type != onc::network_type::kWiFi)
-    return false;
+  if (actual_network_type == onc::network_type::kEthernet) {
+    const base::DictionaryValue* policy_ethernet = NULL;
+    policy.GetDictionaryWithoutPathExpansion(onc::network_config::kEthernet,
+                                             &policy_ethernet);
+    const base::DictionaryValue* actual_ethernet = NULL;
+    actual_network.GetDictionaryWithoutPathExpansion(
+        onc::network_config::kEthernet, &actual_ethernet);
+    if (!policy_ethernet || !actual_ethernet)
+      return false;
 
-  const base::DictionaryValue* policy_wifi = NULL;
-  policy.GetDictionaryWithoutPathExpansion(onc::network_config::kWiFi,
-                                           &policy_wifi);
-  const base::DictionaryValue* actual_wifi = NULL;
-  actual_network.GetDictionaryWithoutPathExpansion(onc::network_config::kWiFi,
-                                                   &actual_wifi);
-  if (!policy_wifi || !actual_wifi)
-    return false;
+    std::string policy_auth;
+    policy_ethernet->GetStringWithoutPathExpansion(
+        onc::ethernet::kAuthentication, &policy_auth);
+    std::string actual_auth;
+    actual_ethernet->GetStringWithoutPathExpansion(
+        onc::ethernet::kAuthentication, &actual_auth);
+    return policy_auth == actual_auth;
+  } else if (actual_network_type == onc::network_type::kWiFi) {
+    const base::DictionaryValue* policy_wifi = NULL;
+    policy.GetDictionaryWithoutPathExpansion(onc::network_config::kWiFi,
+                                             &policy_wifi);
+    const base::DictionaryValue* actual_wifi = NULL;
+    actual_network.GetDictionaryWithoutPathExpansion(onc::network_config::kWiFi,
+                                                     &actual_wifi);
+    if (!policy_wifi || !actual_wifi)
+      return false;
 
-  std::string policy_ssid;
-  policy_wifi->GetStringWithoutPathExpansion(onc::wifi::kSSID, &policy_ssid);
-  std::string actual_ssid;
-  actual_wifi->GetStringWithoutPathExpansion(onc::wifi::kSSID, &actual_ssid);
-  return (policy_ssid == actual_ssid);
+    std::string policy_ssid;
+    policy_wifi->GetStringWithoutPathExpansion(onc::wifi::kSSID, &policy_ssid);
+    std::string actual_ssid;
+    actual_wifi->GetStringWithoutPathExpansion(onc::wifi::kSSID, &actual_ssid);
+    return (policy_ssid == actual_ssid);
+  }
+  return false;
 }
 
 }  // namespace
 
 scoped_ptr<base::DictionaryValue> CreateShillConfiguration(
     const NetworkProfile& profile,
     const std::string& guid,
     const base::DictionaryValue* policy,
     const base::DictionaryValue* settings) {
   scoped_ptr<base::DictionaryValue> effective;
@@ skipping 77 matching lines @@
        it != policies.end(); ++it) {
     if (IsPolicyMatching(*it->second, actual_network))
       return it->second;
   }
   return NULL;
 }
 
 }  // namespace policy_util
 
 }  // namespace chromeos