Resolve certificate references in ONC by PEM.

chromeos/network/onc/onc_validator.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/onc/onc_validator.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/json/json_writer.h"
@@ skipping 562 matching lines @@
     allRequiredExist &= RequireField(*result, kIPsec) &
         RequireField(*result, kL2TP);
   }
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateIPsec(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
-  using namespace onc::vpn;
+  using namespace onc::ipsec;
   using namespace onc::certificate;
 
   static const char* kValidAuthentications[] = { kPSK, kCert, NULL };
   static const char* kValidCertTypes[] = { kRef, kPattern, NULL };
   // Using strict bit-wise OR to check all conditions.
   if (FieldExistsAndHasNoValidValue(*result, kAuthenticationType,
                                     kValidAuthentications) |
-      FieldExistsAndHasNoValidValue(*result, kClientCertType,
+      FieldExistsAndHasNoValidValue(*result, vpn::kClientCertType,
                                     kValidCertTypes)) {
     return false;
   }
 
   bool allRequiredExist = RequireField(*result, kAuthenticationType) &
       RequireField(*result, kIKEVersion);
   std::string auth;
   result->GetStringWithoutPathExpansion(kAuthenticationType, &auth);
   if (auth == kCert) {
-    allRequiredExist &= RequireField(*result, kClientCertType) &
+    allRequiredExist &= RequireField(*result, vpn::kClientCertType) &
         RequireField(*result, kServerCARef);
   }
   std::string cert_type;
-  result->GetStringWithoutPathExpansion(kClientCertType, &cert_type);
+  result->GetStringWithoutPathExpansion(vpn::kClientCertType, &cert_type);
 
   if (CertPatternInDevicePolicy(cert_type))
     return false;
 
   if (cert_type == kPattern)
-    allRequiredExist &= RequireField(*result, kClientCertPattern);
+    allRequiredExist &= RequireField(*result, vpn::kClientCertPattern);
   else if (cert_type == kRef)
-    allRequiredExist &= RequireField(*result, kClientCertRef);
+    allRequiredExist &= RequireField(*result, vpn::kClientCertRef);
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateOpenVPN(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
   using namespace onc::vpn;
   using namespace onc::openvpn;
   using namespace onc::certificate;
 
   static const char* kValidAuthRetryValues[] =
       { openvpn::kNone, kInteract, kNoInteract, NULL };
   static const char* kValidCertTypes[] =
       { certificate::kNone, kRef, kPattern, NULL };
   static const char* kValidCertTlsValues[] =
       { openvpn::kNone, openvpn::kServer, NULL };
 
   // Using strict bit-wise OR to check all conditions.
   if (FieldExistsAndHasNoValidValue(*result, kAuthRetry,
                                     kValidAuthRetryValues) |
-      FieldExistsAndHasNoValidValue(*result, kClientCertType, kValidCertTypes) |
+      FieldExistsAndHasNoValidValue(*result, vpn::kClientCertType,
+                                    kValidCertTypes) |
       FieldExistsAndHasNoValidValue(*result, kRemoteCertTLS,
                                     kValidCertTlsValues)) {
     return false;
   }
 
   bool allRequiredExist = RequireField(*result, kClientCertType);
   std::string cert_type;
   result->GetStringWithoutPathExpansion(kClientCertType, &cert_type);
 
   if (CertPatternInDevicePolicy(cert_type))
     return false;
 
   if (cert_type == kPattern)
-    allRequiredExist &= RequireField(*result, kClientCertPattern);
+    allRequiredExist &= RequireField(*result, vpn::kClientCertPattern);
   else if (cert_type == kRef)
-    allRequiredExist &= RequireField(*result, kClientCertRef);
+    allRequiredExist &= RequireField(*result, vpn::kClientCertRef);
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateCertificatePattern(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
   using namespace onc::certificate;
 
   bool allRequiredExist = true;
@@ skipping 115 matching lines @@
 }
 
 std::string Validator::MessageHeader() {
   std::string path = path_.empty() ? "toplevel" : JoinString(path_, ".");
   std::string message = "At " + path + ": ";
   return message;
 }
 
 }  // namespace onc
 }  // namespace chromeos