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 253 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;
   DCHECK(managed->update_received());
@@ skipping 39 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 NetworkStateBase* ethernet) const {

[stevenjb, 2013/09/16 23:53:24]

I don't especially like passing a NetworkState* back to NSH. We should just pass
the service_path and look up the NetworkState.

[pneubeck (no reviews), 2013/09/17 12:48:36]

Done.

+  // 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.
+  DCHECK(ethernet);
+  DCHECK(ethernet->type() == flimflam::kTypeEthernet);
+  const NetworkState* ethernet_service = ethernet->AsNetworkState();
+  if (!ethernet_service || !ethernet_service->IsConnectedState())
+    return NULL;
+  const DeviceState* device = GetDeviceState(ethernet_service->device_path());
+  if (!device) {
+    NET_LOG_ERROR(
+        "GetEAPForEthernet",
+        base::StringPrintf("Unknown device %s of connected ethernet service %s",
+                           ethernet_service->path().c_str(),
+                           ethernet_service->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.",
+                      ethernet_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 @@
 
   std::string detail = device->name() + "." + key;
   detail += " = " + network_event_log::ValueAsString(value);
   NET_LOG_EVENT("DevicePropertyUpdated", detail);
 
   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                     DeviceListChanged());
 
   if (key == flimflam::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() ||

[stevenjb, 2013/09/16 23:53:24]

If this is false, then there should be an update in progress, and we should wait
for that update to trigger any notifications. What change to NetworkState are we
intending to signal here?

[pneubeck (no reviews), 2013/09/17 12:48:36]

The intention here is:

Sometime after you plugin the ethernet cable, Shill successfully authenticated
at the EAP server and sets this flag to true.
After that, e.g. the proxy settings have to be updated or any other connection
dependent services.

This additional code here is might not be necessary if Shill always changes the
connection status after the EAP authentication. I'm not sure about that but will
investigate further.

[stevenjb, 2013/09/17 16:22:59]

In that case we should call
RequestUpdateForNetwork(ethernet_service->service_path), which will notify
observers if/when the changed properties have been received.

+          ethernet_service->device_path() != device->path()) {
+        continue;
+      }
+      if (ethernet_service->path() == default_network_path_)
+        OnDefaultNetworkChanged();
+      NetworkPropertiesUpdated(ethernet_service);
+    }
+  }
 }
 
 void NetworkStateHandler::CheckPortalListChanged(
     const std::string& check_portal_list) {
   check_portal_list_ = check_portal_list;
 }
 
 void NetworkStateHandler::NotifyManagerPropertyChanged() {
   NET_LOG_DEBUG("NotifyManagerPropertyChanged", "");
   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
@@ skipping 158 matching lines @@
   }
 
   if (type.MatchesType(flimflam::kTypeCellular))
       return flimflam::kTypeCellular;
 
   NOTREACHED();
   return std::string();
 }
 
 }  // namespace chromeos