Add an Ethernet EAP policy.

chromeos/network/network_state_handler.cc

 // Copyright (c) 2012 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/network_state_handler.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
@@ skipping 266 matching lines @@
 }
 
 void NetworkStateHandler::GetNetworkListByType(const NetworkTypePattern& type,
                                                NetworkStateList* list) const {
   DCHECK(list);
   list->clear();
   for (ManagedStateList::const_iterator iter = network_list_.begin();
        iter != network_list_.end(); ++iter) {
     const NetworkState* network = (*iter)->AsNetworkState();
     DCHECK(network);
-    if (!network->update_received())
-      continue;
-    if (network->Matches(type))
+    if (network->update_received() && network->Matches(type))
       list->push_back(network);
   }
 }
 
 void NetworkStateHandler::GetDeviceList(DeviceStateList* list) const {
   DCHECK(list);
   list->clear();
   for (ManagedStateList::const_iterator iter = device_list_.begin();
        iter != device_list_.end(); ++iter) {
     const DeviceState* device = (*iter)->AsDeviceState();
     DCHECK(device);
-    if (!device->update_received())
-      continue;
-    list->push_back(device);
+    if (device->update_received())
+      list->push_back(device);
   }
 }
 
 void NetworkStateHandler::GetFavoriteList(FavoriteStateList* list) const {
+  GetFavoriteListByType(NetworkTypePattern::Default(), list);
+}
+
+void NetworkStateHandler::GetFavoriteListByType(const NetworkTypePattern& type,
+                                                FavoriteStateList* list) const {
   DCHECK(list);
   FavoriteStateList result;
   list->clear();
   for (ManagedStateList::const_iterator iter = favorite_list_.begin();
        iter != favorite_list_.end(); ++iter) {
     const FavoriteState* favorite = (*iter)->AsFavoriteState();
     DCHECK(favorite);
-    if (!favorite->update_received())
-      continue;
-    if (favorite->is_favorite())
+    if (favorite->update_received() && favorite->is_favorite() &&
+        favorite->Matches(type)) {
       list->push_back(favorite);
+    }
   }
 }
 
 const FavoriteState* NetworkStateHandler::GetFavoriteState(
     const std::string& service_path) const {
   ManagedState* managed =
       GetModifiableManagedState(&favorite_list_, service_path);
   if (!managed)
     return NULL;
   if (managed && !managed->update_received())
@@ skipping 40 matching lines @@
         ManagedState::MANAGED_TYPE_NETWORK, network->path());
   }
 }
 
 void NetworkStateHandler::SetCheckPortalList(
     const std::string& check_portal_list) {
   NET_LOG_EVENT("SetCheckPortalList", check_portal_list);
   shill_property_handler_->SetCheckPortalList(check_portal_list);
 }
 
+const FavoriteState* NetworkStateHandler::GetEAPForEthernet(
+    const std::string& service_path) const {
+  const NetworkState* network = GetNetworkState(service_path);
+  if (!network) {
+    NET_LOG_ERROR("GetEAPForEthernet", "Unknown service path " + service_path);
+    return NULL;
+  }
+  if (network->type() != shill::kTypeEthernet) {
+    NET_LOG_ERROR("GetEAPForEthernet", "Not of type Ethernet: " + service_path);
+    return NULL;
+  }
+  if (!network->IsConnectedState())
+    return NULL;
+
+  // The same EAP service is shared for all ethernet services/devices.
+  // However EAP is used/enabled per device and only if the connection was
+  // successfully established.
+  const DeviceState* device = GetDeviceState(network->device_path());
+  if (!device) {
+    NET_LOG_ERROR(
+        "GetEAPForEthernet",
+        base::StringPrintf("Unknown device %s of connected ethernet service %s",
+                           service_path.c_str(),
+                           network->device_path().c_str()));
+    return NULL;
+  }
+  if (!device->eap_authentication_completed())
+    return NULL;
+
+  FavoriteStateList list;
+  GetFavoriteListByType(NetworkTypePattern::Primitive(shill::kTypeEthernetEap),
+                        &list);
+  if (list.empty()) {
+    NET_LOG_ERROR("GetEAPForEthernet",
+                  base::StringPrintf(
+                      "Ethernet service %s connected using EAP, but no "
+                      "EAP service found.",
+                      service_path.c_str()));
+    return NULL;
+  }
+  DCHECK(list.size() == 1);
+  return list.front();
+}
+
 void NetworkStateHandler::GetNetworkStatePropertiesForTest(
     base::DictionaryValue* dictionary) const {
   for (ManagedStateList::const_iterator iter = network_list_.begin();
        iter != network_list_.end(); ++iter) {
     base::DictionaryValue* network_dict = new base::DictionaryValue;
     (*iter)->AsNetworkState()->GetProperties(network_dict);
     dictionary->SetWithoutPathExpansion((*iter)->path(), network_dict);
   }
 }
 
@@ skipping 180 matching lines @@
     return;
 
   std::string detail = device->name() + "." + key;
   detail += " = " + network_event_log::ValueAsString(value);
   NET_LOG_EVENT("DevicePropertyUpdated", detail);
 
   NotifyDeviceListChanged();
 
   if (key == shill::kScanningProperty && device->scanning() == false)
     ScanCompleted(device->type());
+  if (key == shill::kEapAuthenticationCompletedProperty) {
+    // Notify a change for each Ethernet service using this device.
+    NetworkStateList ethernet_services;
+    GetNetworkListByType(NetworkTypePattern::Ethernet(), &ethernet_services);
+    for (NetworkStateList::const_iterator it = ethernet_services.begin();
+         it != ethernet_services.end(); ++it) {
+      const NetworkState* ethernet_service = *it;
+      if (ethernet_service->update_received() ||
+          ethernet_service->device_path() != device->path()) {
+        continue;
+      }
+      RequestUpdateForNetwork(ethernet_service->path());
+    }
+  }
 }
 
 void NetworkStateHandler::CheckPortalListChanged(
     const std::string& check_portal_list) {
   check_portal_list_ = check_portal_list;
 }
 
 void NetworkStateHandler::TechnologyListChanged() {
   // Eventually we would like to replace Technology state with Device state.
   // For now, treat technology state changes as device list changes.
@@ skipping 162 matching lines @@
   }
 
   if (type.MatchesType(shill::kTypeCellular))
     return shill::kTypeCellular;
 
   NOTREACHED();
   return std::string();
 }
 
 }  // namespace chromeos