Check configuration for networks without UIData

chromeos/network/network_connection_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/network_connection_handler.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "chromeos/chromeos_switches.h"
@@ skipping 37 matching lines @@
 }
 
 void CopyStringFromDictionary(const base::DictionaryValue& source,
                               const std::string& key,
                               base::DictionaryValue* dest) {
   std::string string_value;
   if (source.GetStringWithoutPathExpansion(key, &string_value))
     dest->SetStringWithoutPathExpansion(key, string_value);
 }
 
+std::string GetStringFromDictionary(const base::DictionaryValue& dict,
+                                    const std::string& key) {
+  std::string s;
+  dict.GetStringWithoutPathExpansion(key, &s);
+  return s;
+}
+
 bool NetworkRequiresActivation(const NetworkState* network) {
   return (network->type() == flimflam::kTypeCellular &&
       ((network->activation_state() != flimflam::kActivationStateActivated &&
         network->activation_state() != flimflam::kActivationStateUnknown)));
 }
 
 bool VPNIsConfigured(const std::string& service_path,
                      const std::string& provider_type,
                      const base::DictionaryValue& provider_properties) {
   if (provider_type == flimflam::kProviderOpenVpn) {
-    std::string hostname;
-    provider_properties.GetStringWithoutPathExpansion(
-        flimflam::kHostProperty, &hostname);
+    std::string hostname = GetStringFromDictionary(
+        provider_properties, flimflam::kHostProperty);
     if (hostname.empty()) {
       NET_LOG_EVENT("OpenVPN: No hostname", service_path);
       return false;
     }
-    std::string username;
-    provider_properties.GetStringWithoutPathExpansion(
-        flimflam::kOpenVPNUserProperty, &username);
+    std::string username = GetStringFromDictionary(
+        provider_properties, flimflam::kOpenVPNUserProperty);
     if (username.empty()) {
       NET_LOG_EVENT("OpenVPN: No username", service_path);
       return false;
     }
     bool passphrase_required = false;
     provider_properties.GetBooleanWithoutPathExpansion(
         flimflam::kPassphraseRequiredProperty, &passphrase_required);
     if (passphrase_required) {
       NET_LOG_EVENT("OpenVPN: Passphrase Required", service_path);
       return false;
@@ skipping 278 matching lines @@
   // If 'passphrase_required' is still true, then the 'Passphrase' property
   // has not been set to a minimum length value.
   bool passphrase_required = false;
   service_properties.GetBooleanWithoutPathExpansion(
       flimflam::kPassphraseRequiredProperty, &passphrase_required);
   if (passphrase_required) {
     ErrorCallbackForPendingRequest(service_path, kErrorPassphraseRequired);
     return;
   }
 
-  std::string type, security;
-  service_properties.GetStringWithoutPathExpansion(
-      flimflam::kTypeProperty, &type);
-  service_properties.GetStringWithoutPathExpansion(
-      flimflam::kSecurityProperty, &security);
+  std::string type = GetStringFromDictionary(
+      service_properties, flimflam::kTypeProperty);
+  std::string security = GetStringFromDictionary(
+      service_properties, flimflam::kSecurityProperty);
   bool connectable = false;
   service_properties.GetBooleanWithoutPathExpansion(
       flimflam::kConnectableProperty, &connectable);
 
   // In case NetworkState was not available in ConnectToNetwork (e.g. it had
   // been recently configured), we need to check Connectable again.
   if (connectable && type != flimflam::kTypeVPN) {
     // TODO(stevenjb): Shill needs to properly set Connectable for VPN.
     CallShillConnect(service_path);
     return;
@@ skipping 68 matching lines @@
         pending_requests_.erase(service_path);
         return;
       }
 
       pkcs11_id = CertificateIsConfigured(ui_data.get());
       // Ensure the certificate is available and configured.
       if (!cert_loader_->IsHardwareBacked() || pkcs11_id.empty()) {
         ErrorCallbackForPendingRequest(service_path, kErrorCertificateRequired);
         return;
       }
+    } else {
+      // Certificate is not configured in ui_data, check properties.
+      bool configured = true;
+      if (client_cert_type == client_cert::CONFIG_TYPE_OPENVPN) {

[pneubeck (no reviews), 2013/08/30 11:04:08]

How about putting this into a
  client_cert::GetShillProperties
which would be the exact opposite of client_cert::SetShillProperties ?

[stevenjb, 2013/08/30 17:01:21]

Yeah, I considered doing something like that originally, I'll go ahead and move
it. I'll call it IsCertificateConfigured() since it's not really 'Getting' the
properties, just checking them,

+        std::string cert_id = GetStringFromDictionary(
+            service_properties, flimflam::kOpenVPNClientCertIdProperty);

[pneubeck (no reviews), 2013/08/30 11:04:08]

service_properties -> provider_properties
in case of OpenVPN and ipsec ?

(i'm currently in a hurry, so take it with a grain of salt.)

[stevenjb, 2013/08/30 17:01:21]

Bah, you're right, I keep reversing setting vs getting on those, we've got to
change that.
Done.

+        std::string username = GetStringFromDictionary(
+            service_properties, flimflam::kOpenVPNUserProperty);
+        if (cert_id.empty() || username.empty())
+          configured = false;
+      } else if (client_cert_type == client_cert::CONFIG_TYPE_IPSEC) {
+        std::string cert_id = GetStringFromDictionary(
+            service_properties, flimflam::kL2tpIpsecClientCertIdProperty);
+        std::string username = GetStringFromDictionary(
+            service_properties, flimflam::kL2tpIpsecUserProperty);
+        if (cert_id.empty() || username.empty())
+          configured = false;
+      } else if (client_cert_type == client_cert::CONFIG_TYPE_EAP) {
+        std::string cert_id = GetStringFromDictionary(
+            service_properties, flimflam::kEapCertIdProperty);
+        std::string key_id = GetStringFromDictionary(
+            service_properties, flimflam::kEapKeyIdProperty);
+        std::string identity = GetStringFromDictionary(
+            service_properties, flimflam::kEapIdentityProperty);
+        if (cert_id.empty() || key_id.empty() || identity.empty())
+          configured = false;
+      } else {
+        NOTREACHED();
+      }
+      if (!configured) {
+        ErrorCallbackForPendingRequest(service_path,
+                                       kErrorConfigurationRequired);
+        return;
+      }
     }
 
     // The network may not be 'Connectable' because the TPM properties are not
     // set up, so configure tpm slot/pin before connecting.
     if (cert_loader_ && cert_loader_->IsHardwareBacked()) {
       // Pass NULL if pkcs11_id is empty, so that it doesn't clear any
       // previously configured client cert.
       client_cert::SetShillProperties(client_cert_type,
                                       cert_loader_->tpm_token_slot(),
                                       cert_loader_->tpm_user_pin(),
@@ skipping 236 matching lines @@
 
 void NetworkConnectionHandler::HandleShillActivateSuccess(
     const std::string& service_path,
     const base::Closure& success_callback) {
   NET_LOG_EVENT("Activate Request Sent", service_path);
   if (!success_callback.is_null())
     success_callback.Run();
 }
 
 }  // namespace chromeos