Introduce networkingPrivate.getCertificateLists

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 273 matching lines @@
     repaired_recommended->AppendString(field_name);
   }
 
   result->Set(::onc::kRecommended, repaired_recommended.release());
   return true;
 }
 
 bool Validator::ValidateClientCertFields(bool allow_cert_type_none,
                                          base::DictionaryValue* result) {
   using namespace ::onc::client_cert;
-  const char* const kValidCertTypes[] = {kRef, kPattern};
+  const char* const kValidCertTypes[] = {kRef, kPattern, kPKCS11Id};
   std::vector<const char*> valid_cert_types(toVector(kValidCertTypes));
   if (allow_cert_type_none)
     valid_cert_types.push_back(kClientCertTypeNone);
   if (FieldExistsAndHasNoValidValue(*result, kClientCertType, valid_cert_types))
     return false;
 
   std::string cert_type;
   result->GetStringWithoutPathExpansion(kClientCertType, &cert_type);
 
   bool all_required_exist = true;
 
   if (cert_type == kPattern)
     all_required_exist &= RequireField(*result, kClientCertPattern);
   else if (cert_type == kRef)
     all_required_exist &= RequireField(*result, kClientCertRef);
+  else if (cert_type == kPKCS11Id)
+    all_required_exist &= RequireField(*result, kClientCertPKCS11Id);
 
   return !error_on_missing_field_ || all_required_exist;
 }
 
 namespace {
 
 std::string JoinStringRange(const std::vector<const char*>& strings,
                             const std::string& separator) {
   std::vector<base::StringPiece> string_vector(strings.begin(), strings.end());
   return base::JoinString(string_vector, separator);
@@ skipping 624 matching lines @@
     return false;
   }
 
   if (result->HasKey(kServerCARefs) && result->HasKey(kServerCARef)) {
     error_or_warning_found_ = true;
     LOG(ERROR) << MessageHeader() << "At most one of " << kServerCARefs
                << " and " << kServerCARef << " can be set.";
     return false;
   }
 
-  if (!ValidateClientCertFields(false,  // don't allow ClientCertType None
-                                result)) {
+  if (!ValidateClientCertFields(true /* allow ClientCertType None */, result))
     return false;
-  }
 
   bool all_required_exist = RequireField(*result, kOuter);
 
   return !error_on_missing_field_ || all_required_exist;
 }
 
 bool Validator::ValidateCertificate(base::DictionaryValue* result) {
   using namespace ::onc::certificate;
 
   const char* const kValidTypes[] = {kClient, kServer, kAuthority};
@@ skipping 68 matching lines @@
 }
 
 std::string Validator::MessageHeader() {
   std::string path = path_.empty() ? "toplevel" : base::JoinString(path_, ".");
   std::string message = "At " + path + ": ";
   return message;
 }
 
 }  // namespace onc
 }  // namespace chromeos