Identify and repair ONC files with duplicate GUIDs

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 369 matching lines @@
   error_or_warning_found_ = true;
   std::string message = MessageHeader() + "The required field '" + field_name +
       "' is missing.";
   if (error_on_missing_field_)
     LOG(ERROR) << message;
   else
     LOG(WARNING) << message;
   return false;
 }
 
+bool Validator::CheckGuidIsUniqueAndAddToSet(const base::DictionaryValue& dict,
+                                             const std::string& key_guid,
+                                             std::set<std::string> *guids) {
+  std::string guid;
+  if (dict.GetStringWithoutPathExpansion(key_guid, &guid)) {
+    if (guids->count(guid) != 0) {
+      error_or_warning_found_ = true;
+      LOG(ERROR) << MessageHeader() << "Found a duplicate GUID.";

[pneubeck (no reviews), 2014/02/17 16:07:40]

nit:
since the GUID isn't a credential, we can as well log it:
"Found duplicate GUID " << guid;

+      return false;
+    }
+    guids->insert(guid);
+  }
+  return true;
+}
+
 bool Validator::IsCertPatternInDevicePolicy(const std::string& cert_type) {
   if (cert_type == ::onc::certificate::kPattern &&
       onc_source_ == ::onc::ONC_SOURCE_DEVICE_POLICY) {
     error_or_warning_found_ = true;
     LOG(ERROR) << MessageHeader() << "Client certificate patterns are "
                << "prohibited in ONC device policies.";
     return true;
   }
   return false;
 }
@@ skipping 51 matching lines @@
   static const char* kValidTypes[] = { ::onc::network_type::kEthernet,
                                        ::onc::network_type::kVPN,
                                        ::onc::network_type::kWiFi,
                                        ::onc::network_type::kCellular,
                                        NULL };
   if (FieldExistsAndHasNoValidValue(*result, kType, kValidTypes) ||
       FieldExistsAndIsEmpty(*result, kGUID)) {
     return false;
   }
 
+  if (!CheckGuidIsUniqueAndAddToSet(*result, kGUID, &network_guids_))
+    return false;
+
   bool all_required_exist = RequireField(*result, kGUID);
 
   bool remove = false;
   result->GetBooleanWithoutPathExpansion(::onc::kRemove, &remove);
   if (!remove) {
     all_required_exist &=
         RequireField(*result, kName) && RequireField(*result, kType);
 
     std::string type;
     result->GetStringWithoutPathExpansion(kType, &type);
@@ skipping 334 matching lines @@
   std::string type;
   result->GetStringWithoutPathExpansion(kType, &type);
   if (onc_source_ == ::onc::ONC_SOURCE_DEVICE_POLICY &&
       (type == kServer || type == kAuthority)) {
     error_or_warning_found_ = true;
     LOG(ERROR) << MessageHeader() << "Server and authority certificates are "
                << "prohibited in ONC device policies.";
     return false;
   }
 
+  if (!CheckGuidIsUniqueAndAddToSet(*result, kGUID, &certificate_guids_))
+    return false;
+
   bool all_required_exist = RequireField(*result, kGUID);
 
   bool remove = false;
   result->GetBooleanWithoutPathExpansion(::onc::kRemove, &remove);
   if (!remove) {
     all_required_exist &= RequireField(*result, kType);
 
     if (type == kClient)
       all_required_exist &= RequireField(*result, kPKCS12);
     else if (type == kServer || type == kAuthority)
       all_required_exist &= RequireField(*result, kX509);
   }
 
   return !error_on_missing_field_ || all_required_exist;
 }
 
 std::string Validator::MessageHeader() {
   std::string path = path_.empty() ? "toplevel" : JoinString(path_, ".");
   std::string message = "At " + path + ": ";
   return message;
 }
 
 }  // namespace onc
 }  // namespace chromeos