Separating ONC<->Shill translation from the ONC signature.

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 95 matching lines @@
     CHECK_EQ(repaired->GetType(), signature.onc_type);
   return repaired.Pass();
 }
 
 scoped_ptr<base::DictionaryValue> Validator::MapObject(
     const OncValueSignature& signature,
     const base::DictionaryValue& onc_object,
     bool* error) {
   scoped_ptr<base::DictionaryValue> repaired(new base::DictionaryValue);
 
-  bool valid;
-  if (&signature == &kToplevelConfigurationSignature)
-    valid = ValidateToplevelConfiguration(onc_object, repaired.get());
-  else if (&signature == &kNetworkConfigurationSignature)
-    valid = ValidateNetworkConfiguration(onc_object, repaired.get());
-  else if (&signature == &kEthernetSignature)
-    valid = ValidateEthernet(onc_object, repaired.get());
-  else if (&signature == &kIPConfigSignature)
-    valid = ValidateIPConfig(onc_object, repaired.get());
-  else if (&signature == &kWiFiSignature)
-    valid = ValidateWiFi(onc_object, repaired.get());
-  else if (&signature == &kVPNSignature)
-    valid = ValidateVPN(onc_object, repaired.get());
-  else if (&signature == &kIPsecSignature)
-    valid = ValidateIPsec(onc_object, repaired.get());
-  else if (&signature == &kOpenVPNSignature)
-    valid = ValidateOpenVPN(onc_object, repaired.get());
-  else if (&signature == &kCertificatePatternSignature)
-    valid = ValidateCertificatePattern(onc_object, repaired.get());
-  else if (&signature == &kProxySettingsSignature)
-    valid = ValidateProxySettings(onc_object, repaired.get());
-  else if (&signature == &kProxyLocationSignature)
-    valid = ValidateProxyLocation(onc_object, repaired.get());
-  else if (&signature == &kEAPSignature)
-    valid = ValidateEAP(onc_object, repaired.get());
-  else if (&signature == &kCertificateSignature)
-    valid = ValidateCertificate(onc_object, repaired.get());
-  else
-    valid = ValidateObjectDefault(signature, onc_object, repaired.get());
+  bool valid = ValidateObjectDefault(signature, onc_object, repaired.get());
+  if (valid) {
+    if (&signature == &kToplevelConfigurationSignature)
+      valid = ValidateToplevelConfiguration(onc_object, repaired.get());
+    else if (&signature == &kNetworkConfigurationSignature)
+      valid = ValidateNetworkConfiguration(onc_object, repaired.get());
+    else if (&signature == &kEthernetSignature)
+      valid = ValidateEthernet(onc_object, repaired.get());
+    else if (&signature == &kIPConfigSignature)
+      valid = ValidateIPConfig(onc_object, repaired.get());
+    else if (&signature == &kWiFiSignature)
+      valid = ValidateWiFi(onc_object, repaired.get());
+    else if (&signature == &kVPNSignature)
+      valid = ValidateVPN(onc_object, repaired.get());
+    else if (&signature == &kIPsecSignature)
+      valid = ValidateIPsec(onc_object, repaired.get());
+    else if (&signature == &kOpenVPNSignature)
+      valid = ValidateOpenVPN(onc_object, repaired.get());
+    else if (&signature == &kCertificatePatternSignature)
+      valid = ValidateCertificatePattern(onc_object, repaired.get());
+    else if (&signature == &kProxySettingsSignature)
+      valid = ValidateProxySettings(onc_object, repaired.get());
+    else if (&signature == &kProxyLocationSignature)
+      valid = ValidateProxyLocation(onc_object, repaired.get());
+    else if (&signature == &kEAPSignature)
+      valid = ValidateEAP(onc_object, repaired.get());
+    else if (&signature == &kCertificateSignature)
+      valid = ValidateCertificate(onc_object, repaired.get());
+  }
 
   if (valid) {
     return repaired.Pass();
   } else {
     DCHECK(error_or_warning_found_);
     error_or_warning_found_ = *error = true;
     return scoped_ptr<base::DictionaryValue>();
   }
 }
 
@@ skipping 236 matching lines @@
     return true;
   }
   return false;
 }
 
 bool Validator::ValidateToplevelConfiguration(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
   using namespace onc::toplevel_config;
 
-  if (!ValidateObjectDefault(kToplevelConfigurationSignature,
-                             onc_object, result)) {
-    return false;
-  }
-
   static const char* kValidTypes[] = { kUnencryptedConfiguration,
                                        kEncryptedConfiguration,
                                        NULL };
   if (FieldExistsAndHasNoValidValue(*result, kType, kValidTypes))
     return false;
 
   bool allRequiredExist = true;
 
   // Not part of the ONC spec yet:
   // We don't require the type field and default to UnencryptedConfiguration.
@@ skipping 14 matching lines @@
   }
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateNetworkConfiguration(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
   using namespace onc::network_config;
 
-  if (!ValidateObjectDefault(kNetworkConfigurationSignature,
-                             onc_object, result)) {
-    return false;
-  }
-
   static const char* kValidTypes[] = { network_type::kEthernet,
                                        network_type::kVPN,
                                        network_type::kWiFi,
                                        network_type::kCellular,
                                        NULL };
   if (FieldExistsAndHasNoValidValue(*result, kType, kValidTypes) ||
       FieldExistsAndIsEmpty(*result, kGUID)) {
     return false;
   }
 
@@ skipping 31 matching lines @@
       NOTREACHED();
   }
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateEthernet(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
   using namespace onc::ethernet;
-  if (!ValidateObjectDefault(kEthernetSignature, onc_object, result))
-    return false;
 
   static const char* kValidAuthentications[] = { kNone, k8021X, NULL };
   if (FieldExistsAndHasNoValidValue(*result, kAuthentication,
                                     kValidAuthentications)) {
     return false;
   }
 
   bool allRequiredExist = true;
   std::string auth;
   result->GetStringWithoutPathExpansion(kAuthentication, &auth);
   if (auth == k8021X)
     allRequiredExist &= RequireField(*result, kEAP);
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateIPConfig(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
   using namespace onc::ipconfig;
-  if (!ValidateObjectDefault(kIPConfigSignature, onc_object, result))
-    return false;
 
   static const char* kValidTypes[] = { kIPv4, kIPv6, NULL };
   if (FieldExistsAndHasNoValidValue(*result, ipconfig::kType, kValidTypes))
     return false;
 
   std::string type;
   result->GetStringWithoutPathExpansion(ipconfig::kType, &type);
   int lower_bound = 1;
   // In case of missing type, choose higher upper_bound.
   int upper_bound = (type == kIPv4) ? 32 : 128;
   if (FieldExistsAndIsNotInRange(*result, kRoutingPrefix,
                                  lower_bound, upper_bound)) {
     return false;
   }
 
   bool allRequiredExist = RequireField(*result, kIPAddress) &
       RequireField(*result, kRoutingPrefix) &
       RequireField(*result, ipconfig::kType);
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateWiFi(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
   using namespace onc::wifi;
-  if (!ValidateObjectDefault(kWiFiSignature, onc_object, result))
-    return false;
 
   static const char* kValidSecurities[] =
       { kNone, kWEP_PSK, kWEP_8021X, kWPA_PSK, kWPA_EAP, NULL };
   if (FieldExistsAndHasNoValidValue(*result, kSecurity, kValidSecurities))
     return false;
 
   bool allRequiredExist = RequireField(*result, kSecurity) &
       RequireField(*result, kSSID);
 
   std::string security;
   result->GetStringWithoutPathExpansion(kSecurity, &security);
   if (security == kWEP_8021X || security == kWPA_EAP)
     allRequiredExist &= RequireField(*result, kEAP);
   else if (security == kWEP_PSK || security == kWPA_PSK)
     allRequiredExist &= RequireField(*result, kPassphrase);
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateVPN(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
   using namespace vpn;
-  if (!ValidateObjectDefault(kVPNSignature, onc_object, result))
-    return false;
 
   static const char* kValidTypes[] =
       { kIPsec, kTypeL2TP_IPsec, kOpenVPN, NULL };
   if (FieldExistsAndHasNoValidValue(*result, vpn::kType, kValidTypes))
     return false;
 
   bool allRequiredExist = RequireField(*result, vpn::kType);
   std::string type;
   result->GetStringWithoutPathExpansion(vpn::kType, &type);
   if (type == kOpenVPN) {
     allRequiredExist &= RequireField(*result, kOpenVPN);
   } else if (type == kIPsec) {
     allRequiredExist &= RequireField(*result, kIPsec);
   } else if (type == kTypeL2TP_IPsec) {
     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::certificate;
-  if (!ValidateObjectDefault(kIPsecSignature, onc_object, result))
-    return false;
 
   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,
                                     kValidCertTypes)) {
     return false;
   }
@@ skipping 19 matching lines @@
 
   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;
-  if (!ValidateObjectDefault(kOpenVPNSignature, onc_object, result))
-    return false;
 
   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,
@@ skipping 16 matching lines @@
   else if (cert_type == kRef)
     allRequiredExist &= RequireField(*result, kClientCertRef);
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateCertificatePattern(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
   using namespace onc::certificate;
-  if (!ValidateObjectDefault(kCertificatePatternSignature, onc_object, result))
-    return false;
 
   bool allRequiredExist = true;
   if (!result->HasKey(kSubject) && !result->HasKey(kIssuer) &&
       !result->HasKey(kIssuerCARef)) {
     error_or_warning_found_ = true;
     allRequiredExist = false;
     std::string message = MessageHeader(error_on_missing_field_) +
         "None of the fields '" + kSubject + "', '" + kIssuer + "', and '" +
         kIssuerCARef + "' is present, but at least one is required.";
     if (error_on_missing_field_)
       LOG(ERROR) << message;
     else
       LOG(WARNING) << message;
   }
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateProxySettings(const base::DictionaryValue& onc_object,
                                       base::DictionaryValue* result) {
   using namespace onc::proxy;
-  if (!ValidateObjectDefault(kProxySettingsSignature, onc_object, result))
-    return false;
 
   static const char* kValidTypes[] = { kDirect, kManual, kPAC, kWPAD, NULL };
   if (FieldExistsAndHasNoValidValue(*result, proxy::kType, kValidTypes))
     return false;
 
   bool allRequiredExist = RequireField(*result, proxy::kType);
   std::string type;
   result->GetStringWithoutPathExpansion(proxy::kType, &type);
   if (type == kManual)
     allRequiredExist &= RequireField(*result, kManual);
   else if (type == kPAC)
     allRequiredExist &= RequireField(*result, kPAC);
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateProxyLocation(const base::DictionaryValue& onc_object,
                                       base::DictionaryValue* result) {
   using namespace onc::proxy;
-  if (!ValidateObjectDefault(kProxyLocationSignature, onc_object, result))
-    return false;
 
   bool allRequiredExist = RequireField(*result, kHost) &
       RequireField(*result, kPort);
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateEAP(const base::DictionaryValue& onc_object,
                             base::DictionaryValue* result) {
   using namespace onc::eap;
   using namespace onc::certificate;
-  if (!ValidateObjectDefault(kEAPSignature, onc_object, result))
-    return false;
 
   static const char* kValidInnerValues[] =
       { kAutomatic, kMD5, kMSCHAPv2, kPAP, NULL };
   static const char* kValidOuterValues[] =
       { kPEAP, kEAP_TLS, kEAP_TTLS, kLEAP, kEAP_SIM, kEAP_FAST, kEAP_AKA,
         NULL };
   static const char* kValidCertTypes[] = { kRef, kPattern, NULL };
 
   // Using strict bit-wise OR to check all conditions.
   if (FieldExistsAndHasNoValidValue(*result, kInner, kValidInnerValues) |
@@ skipping 15 matching lines @@
   else if (cert_type == kRef)
     allRequiredExist &= RequireField(*result, kClientCertRef);
 
   return !error_on_missing_field_ || allRequiredExist;
 }
 
 bool Validator::ValidateCertificate(
     const base::DictionaryValue& onc_object,
     base::DictionaryValue* result) {
   using namespace onc::certificate;
-  if (!ValidateObjectDefault(kCertificateSignature, onc_object, result))
-    return false;
 
   static const char* kValidTypes[] = { kClient, kServer, kAuthority, NULL };
   if (FieldExistsAndHasNoValidValue(*result, kType, kValidTypes) ||
       FieldExistsAndIsEmpty(*result, kGUID)) {
     return false;
   }
 
   std::string type;
   result->GetStringWithoutPathExpansion(kType, &type);
   if (onc_source_ == ONC_SOURCE_DEVICE_POLICY &&
@@ skipping 29 matching lines @@
 }
 
 std::string Validator::MessageHeader(bool is_error) {
   std::string path = path_.empty() ? "toplevel" : JoinString(path_, ".");
   std::string message = "At " + path + ": ";
   return message;
 }
 
 }  // namespace onc
 }  // namespace chromeos