ONC: Add IPAddressConfigType and NameServersConfigType

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 504 matching lines @@
   return true;
 }
 
 bool Validator::ValidateNetworkConfiguration(base::DictionaryValue* result) {
   using namespace ::onc::network_config;
 
   const char* const kValidTypes[] = {
       ::onc::network_type::kEthernet, ::onc::network_type::kVPN,
       ::onc::network_type::kWiFi, ::onc::network_type::kCellular};
   const std::vector<const char*> valid_types(toVector(kValidTypes));
+  const char* const kValidIPConfigTypes[] = {kIPConfigTypeDHCP,
+                                             kIPConfigTypeStatic};
+  const std::vector<const char*> valid_ipconfig_types(
+      toVector(kValidIPConfigTypes));
   if (FieldExistsAndHasNoValidValue(*result, kType, valid_types) ||
+      FieldExistsAndHasNoValidValue(*result, kIPAddressConfigType,
+                                    valid_ipconfig_types) ||
+      FieldExistsAndHasNoValidValue(*result, kNameServersConfigType,
+                                    valid_ipconfig_types) ||
       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 ip_address_config_type, name_servers_config_type;
+    result->GetStringWithoutPathExpansion(kIPAddressConfigType,
+                                          &ip_address_config_type);
+    result->GetStringWithoutPathExpansion(kNameServersConfigType,
+                                          &name_servers_config_type);
+    if (ip_address_config_type == kIPConfigTypeStatic ||
+        name_servers_config_type == kIPConfigTypeStatic) {
+      // TODO(pneubeck): Add ValidateStaticIPConfig and confirm that the
+      // correct properties are provided based on the config type.
+      all_required_exist &= RequireField(*result, kStaticIPConfig);
+    }
+
     std::string type;
     result->GetStringWithoutPathExpansion(kType, &type);
 
     // Prohibit anything but WiFi and Ethernet for device-level policy (which
     // corresponds to shared networks). See also http://crosbug.com/28741.
     if (onc_source_ == ::onc::ONC_SOURCE_DEVICE_POLICY && !type.empty() &&
         type != ::onc::network_type::kWiFi &&
         type != ::onc::network_type::kEthernet) {
       error_or_warning_found_ = true;
       LOG(ERROR) << MessageHeader() << "Networks of type '"
@@ skipping 355 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