Check configuration for networks without UIData

chromeos/network/client_cert_util.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/client_cert_util.h"
 
 #include <cert.h>
 #include <pk11pub.h>
 
 #include <list>
@@ skipping 73 matching lines @@
     }
 
     return (std::find(issuer_ca_pems_.begin(), issuer_ca_pems_.end(),
                       pem_encoded) ==
             issuer_ca_pems_.end());
   }
  private:
   const std::vector<std::string>& issuer_ca_pems_;
 };
 
+std::string GetStringFromDictionary(const base::DictionaryValue& dict,
+                                    const std::string& key) {
+  std::string s;
+  dict.GetStringWithoutPathExpansion(key, &s);
+  return s;
+}
+
 }  // namespace
 
 // Returns true only if any fields set in this pattern match exactly with
 // similar fields in the principal.  If organization_ or organizational_unit_
 // are set, then at least one of the organizations or units in the principal
 // must match.
 bool CertPrincipalMatches(const IssuerSubjectPattern& pattern,
                           const net::CertPrincipal& principal) {
   if (!pattern.common_name().empty() &&
       pattern.common_name() != principal.common_name) {
@@ skipping 127 matching lines @@
                                                   *pkcs11_id);
       }
       break;
     }
   }
   DCHECK(tpm_pin_property);
   if (!tpm_pin.empty())
     properties->SetStringWithoutPathExpansion(tpm_pin_property, tpm_pin);
 }
 
+bool IsCertificateConfigured(const client_cert::ConfigType cert_config_type,
+                             const base::DictionaryValue& service_properties) {
+  // VPN certificate properties are read from the Provider dictionary.
+  const base::DictionaryValue* provider_properties = NULL;
+  service_properties.GetDictionaryWithoutPathExpansion(
+      flimflam::kProviderProperty, &provider_properties);
+  switch (cert_config_type) {
+    case CONFIG_TYPE_NONE:
+      return true;
+    case CONFIG_TYPE_OPENVPN:
+      // OpenVPN generally requires a passphrase and we don't know whether or
+      // not one is required, so always return false here.
+      return false;
+    case CONFIG_TYPE_IPSEC:
+      // IPSec may require a passphrase, so return false here also.
+      return false;
+    case 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);
+      return !cert_id.empty() && !key_id.empty() && !identity.empty();
+    }
+  }
+  NOTREACHED();
+  return false;
+}
+
 }  // namespace client_cert
 
 }  // namespace chromeos