Set onc_source UI data parameter when importing ONC.

chrome/browser/chromeos/cros/onc_network_parser.cc

 // Copyright (c) 2011 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 "chrome/browser/chromeos/cros/onc_network_parser.h"
 
+#include <keyhi.h>
 #include <pk11pub.h>
-#include <keyhi.h>
 
 #include "base/base64.h"
 #include "base/json/json_value_serializer.h"
 #include "base/json/json_writer.h"  // for debug output only.
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/native_network_constants.h"
 #include "chrome/browser/chromeos/cros/native_network_parser.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/common/net/x509_certificate_model.h"
@@ skipping 160 matching lines @@
 std::string ConvertValueToString(const base::Value& value) {
   std::string value_json;
   base::JSONWriter::Write(&value, false, &value_json);
   return value_json;
 }
 
 }  // namespace
 
 // -------------------- OncNetworkParser --------------------
 
-OncNetworkParser::OncNetworkParser(const std::string& onc_blob)
+OncNetworkParser::OncNetworkParser(const std::string& onc_blob,
+                                   NetworkUIData::ONCSource onc_source)
     : NetworkParser(get_onc_mapper()),
+      onc_source_(onc_source),
       network_configs_(NULL),
       certificates_(NULL) {
   VLOG(2) << __func__ << ": OncNetworkParser called on " << onc_blob;
   JSONStringValueSerializer deserializer(onc_blob);
   deserializer.set_allow_trailing_comma(true);
   scoped_ptr<base::Value> root(deserializer.Deserialize(NULL, &parse_error_));
 
   if (!root.get() || root->GetType() != base::Value::TYPE_DICTIONARY) {
     LOG(WARNING) << "OncNetworkParser received bad ONC file: " << parse_error_;
   } else {
@@ skipping 21 matching lines @@
 
 // static
 const EnumMapper<PropertyIndex>* OncNetworkParser::property_mapper() {
   return get_onc_mapper();
 }
 
 int OncNetworkParser::GetNetworkConfigsSize() const {
   return network_configs_ ? network_configs_->GetSize() : 0;
 }
 
+Network* OncNetworkParser::ParseNetwork(int n) {
+  CHECK(network_configs_);
+  CHECK(static_cast<size_t>(n) < network_configs_->GetSize());
+  CHECK_GE(n, 0);
+  DictionaryValue* info = NULL;
+  if (!network_configs_->GetDictionary(n, &info)) {
+    parse_error_ = l10n_util::GetStringUTF8(
+        IDS_NETWORK_CONFIG_ERROR_NETWORK_PROP_DICT_MALFORMED);
+    return NULL;
+  }
+
+  if (VLOG_IS_ON(2)) {
+    std::string network_json;
+    base::JSONWriter::Write(static_cast<base::Value*>(info),
+                            true, &network_json);
+    VLOG(2) << "Parsing network at index " << n
+            << ": " << network_json;
+  }
+
+  return CreateNetworkFromInfo(std::string(), *info);
+}
+
 int OncNetworkParser::GetCertificatesSize() const {
   return certificates_ ? certificates_->GetSize() : 0;
 }
 
 scoped_refptr<net::X509Certificate> OncNetworkParser::ParseCertificate(
     int cert_index) {
   CHECK(certificates_);
   CHECK(static_cast<size_t>(cert_index) < certificates_->GetSize());
   CHECK_GE(cert_index, 0);
   base::DictionaryValue* certificate = NULL;
@@ skipping 44 matching lines @@
     return ParseClientCertificate(cert_index, guid, certificate);
   }
 
   LOG(WARNING) << "ONC File: certificate of unknown type: " << cert_type
                << " at index " << cert_index;
   parse_error_ = l10n_util::GetStringUTF8(
       IDS_NETWORK_CONFIG_ERROR_CERT_TYPE_MISSING);
   return NULL;
 }
 
-Network* OncNetworkParser::ParseNetwork(int n) {
-  CHECK(network_configs_);
-  CHECK(static_cast<size_t>(n) < network_configs_->GetSize());
-  CHECK_GE(n, 0);
-  DictionaryValue* info = NULL;
-  if (!network_configs_->GetDictionary(n, &info)) {
-    parse_error_ = l10n_util::GetStringUTF8(
-        IDS_NETWORK_CONFIG_ERROR_NETWORK_PROP_DICT_MALFORMED);
-    return NULL;
-  }
-
-  if (VLOG_IS_ON(2)) {
-    std::string network_json;
-    base::JSONWriter::Write(static_cast<base::Value*>(info),
-                            true, &network_json);
-    VLOG(2) << "Parsing network at index " << n
-            << ": " << network_json;
-  }
-
-  return CreateNetworkFromInfo(std::string(), *info);
-}
-
 Network* OncNetworkParser::CreateNetworkFromInfo(
     const std::string& service_path,
     const DictionaryValue& info) {
   ConnectionType type = ParseTypeFromDictionary(info);
   if (type == TYPE_UNKNOWN) {  // Return NULL if cannot parse network type.
     parse_error_ = l10n_util::GetStringUTF8(
         IDS_NETWORK_CONFIG_ERROR_NETWORK_TYPE_MISSING);
     return NULL;
   }
   scoped_ptr<Network> network(CreateNewNetwork(type, service_path));
+
+  // Initialize UI data.
+  NetworkUIData ui_data;
+  ui_data.set_onc_source(onc_source_);
+  ui_data.FillDictionary(network->ui_data());
+
+  // Parse all properties recursively.
   if (!ParseNestedObject(network.get(),
                          "NetworkConfiguration",
                          static_cast<const base::Value&>(info),
                          network_configuration_signature,
                          ParseNetworkConfigurationValue)) {
     LOG(WARNING) << "Network " << network->name() << " failed to parse.";
     if (parse_error_.empty())
       parse_error_ = l10n_util::GetStringUTF8(
           IDS_NETWORK_CONFIG_ERROR_NETWORK_PROP_DICT_MALFORMED);
     return NULL;
   }
+
+  // Update the UI data property.
+  std::string ui_data_json;
+  base::JSONWriter::Write(network->ui_data(), false, &ui_data_json);
+  base::StringValue ui_data_string_value(ui_data_json);
+  network->UpdatePropertyMap(PROPERTY_INDEX_UI_DATA, ui_data_string_value);
+
   if (VLOG_IS_ON(2)) {
     VLOG(2) << "Created Network '" << network->name()
             << "' from info. Path:" << service_path
             << " Type:" << ConnectionTypeToString(type);
   }
+
   return network.release();
 }
 
+bool OncNetworkParser::ParseNestedObject(Network* network,
+                                         const std::string& onc_type,
+                                         const base::Value& value,
+                                         OncValueSignature* signature,
+                                         ParserPointer parser) {
+  bool any_errors = false;
+  if (!value.IsType(base::Value::TYPE_DICTIONARY)) {
+    VLOG(1) << network->name() << ": expected object of type " << onc_type;
+    parse_error_ = l10n_util::GetStringUTF8(
+        IDS_NETWORK_CONFIG_ERROR_NETWORK_PROP_DICT_MALFORMED);
+    return false;
+  }
+  VLOG(2) << "Parsing nested object of type " << onc_type;
+  const DictionaryValue* dict = NULL;
+  value.GetAsDictionary(&dict);
+  for (DictionaryValue::key_iterator iter = dict->begin_keys();
+       iter != dict->end_keys(); ++iter) {
+    const std::string& key = *iter;
+
+    // Recommended keys are only of interest to the UI code and the UI reads it
+    // directly from the ONC blob.
+    if (key == "Recommended")
+      continue;
+
+    base::Value* inner_value = NULL;
+    dict->GetWithoutPathExpansion(key, &inner_value);
+    CHECK(inner_value != NULL);
+    int field_index;
+    for (field_index = 0; signature[field_index].field != NULL; ++field_index) {
+      if (key == signature[field_index].field)
+        break;
+    }
+    if (signature[field_index].field == NULL) {
+      VLOG(1) << network->name() << ": unexpected field: "
+              << key << ", in type: " << onc_type;
+      any_errors = true;
+      continue;
+    }
+    if (!inner_value->IsType(signature[field_index].type)) {
+      VLOG(1) << network->name() << ": field with wrong type: " << key
+              << ", actual type: " << inner_value->GetType()
+              << ", expected type: " << signature[field_index].type;
+      any_errors = true;
+      continue;
+    }
+    PropertyIndex index = signature[field_index].index;
+    // We need to UpdatePropertyMap now since parser might want to
+    // change the mapped value.
+    network->UpdatePropertyMap(index, *inner_value);
+    if (!parser(this, index, *inner_value, network)) {
+      VLOG(1) << network->name() << ": field not parsed: " << key;
+      any_errors = true;
+      continue;
+    }
+    if (VLOG_IS_ON(2)) {
+      std::string value_json;
+      base::JSONWriter::Write(inner_value, true, &value_json);
+      VLOG(2) << network->name() << ": Successfully parsed [" << key
+              << "(" << index << ")] = " << value_json;
+    }
+  }
+  if (any_errors) {
+    parse_error_ = l10n_util::GetStringUTF8(
+        IDS_NETWORK_CONFIG_ERROR_NETWORK_PROP_DICT_MALFORMED);
+  }
+  return !any_errors;
+}
+
 Network* OncNetworkParser::CreateNewNetwork(
     ConnectionType type, const std::string& service_path) {
   Network* network = NetworkParser::CreateNewNetwork(type, service_path);
   if (network) {
     if (type == TYPE_WIFI)
       network->SetNetworkParser(new OncWifiNetworkParser());
     else if (type == TYPE_VPN)
       network->SetNetworkParser(new OncVirtualNetworkParser());
   }
   return network;
@@ skipping 15 matching lines @@
   return type_string;
 }
 
 std::string OncNetworkParser::GetGuidFromDictionary(
     const base::DictionaryValue& info) {
   std::string guid_string;
   info.GetString("GUID", &guid_string);
   return guid_string;
 }
 
+// static
+bool OncNetworkParser::ParseNetworkConfigurationValue(
+    OncNetworkParser* parser,
+    PropertyIndex index,
+    const base::Value& value,
+    Network* network) {
+  switch (index) {
+    case PROPERTY_INDEX_ONC_WIFI: {
+      return parser->ParseNestedObject(network,
+                                       "WiFi",
+                                       value,
+                                       wifi_signature,
+                                       OncWifiNetworkParser::ParseWifiValue);
+    }
+    case PROPERTY_INDEX_ONC_VPN: {
+      if (!CheckNetworkType(network, TYPE_VPN, "VPN"))
+        return false;
+      VirtualNetwork* virtual_network = static_cast<VirtualNetwork*>(network);
+      // Got the "VPN" field.  Immediately store the VPN.Type field
+      // value so that we can properly validate fields in the VPN
+      // object based on the type.
+      const DictionaryValue* dict = NULL;
+      CHECK(value.GetAsDictionary(&dict));
+      std::string provider_type_string;
+      if (!dict->GetString("Type", &provider_type_string)) {
+        VLOG(1) << network->name() << ": VPN.Type is missing";
+        return false;
+      }
+      ProviderType provider_type =
+        OncVirtualNetworkParser::ParseProviderType(provider_type_string);
+      virtual_network->set_provider_type(provider_type);
+      return parser->ParseNestedObject(network,
+                                       "VPN",
+                                       value,
+                                       vpn_signature,
+                                       OncVirtualNetworkParser::ParseVPNValue);
+      return true;
+    }
+    case PROPERTY_INDEX_ONC_REMOVE:
+      VLOG(1) << network->name() << ": Remove field not yet implemented";
+      return false;
+    case PROPERTY_INDEX_TYPE: {
+      // Update property with native value for type.
+      std::string str =
+        NativeNetworkParser::network_type_mapper()->GetKey(network->type());
+      scoped_ptr<StringValue> val(Value::CreateStringValue(str));
+      network->UpdatePropertyMap(PROPERTY_INDEX_TYPE, *val.get());
+      return true;
+    }
+    case PROPERTY_INDEX_GUID:
+    case PROPERTY_INDEX_NAME:
+      // Fall back to generic parser for these.
+      return parser->ParseValue(index, value, network);
+    default:
+      break;
+  }
+  return false;
+}
+
+// static
+bool OncNetworkParser::CheckNetworkType(Network* network,
+                                        ConnectionType expected,
+                                        const std::string& onc_type) {
+  if (expected != network->type()) {
+    LOG(WARNING) << network->name() << ": "
+                 << onc_type << " field unexpected for this type network";
+    return false;
+  }
+  return true;
+}
+
 scoped_refptr<net::X509Certificate>
 OncNetworkParser::ParseServerOrCaCertificate(
     int cert_index,
     const std::string& cert_type,
     const std::string& guid,
     base::DictionaryValue* certificate) {
   net::CertDatabase cert_database;
   bool web_trust = false;
   base::ListValue* trust_list = NULL;
   if (certificate->GetList("Trust", &trust_list)) {
@@ skipping 149 matching lines @@
   } else {
     LOG(WARNING) << "ONC File: Unable to find private key for cert at index"
                  << cert_index;
   }
 
   VLOG(2) << "Successfully imported client certificate at index "
           << cert_index;
   return cert_result;
 }
 
-bool OncNetworkParser::ParseNestedObject(Network* network,
-                                         const std::string& onc_type,
-                                         const base::Value& value,
-                                         OncValueSignature* signature,
-                                         ParserPointer parser) {
-  bool any_errors = false;
-  if (!value.IsType(base::Value::TYPE_DICTIONARY)) {
-    VLOG(1) << network->name() << ": expected object of type " << onc_type;
-    parse_error_ = l10n_util::GetStringUTF8(
-        IDS_NETWORK_CONFIG_ERROR_NETWORK_PROP_DICT_MALFORMED);
-    return false;
-  }
-  VLOG(2) << "Parsing nested object of type " << onc_type;
-  const DictionaryValue* dict = NULL;
-  value.GetAsDictionary(&dict);
-  for (DictionaryValue::key_iterator iter = dict->begin_keys();
-       iter != dict->end_keys(); ++iter) {
-    const std::string& key = *iter;
-    base::Value* inner_value = NULL;
-    dict->GetWithoutPathExpansion(key, &inner_value);
-    CHECK(inner_value != NULL);
-    int field_index;
-    for (field_index = 0; signature[field_index].field != NULL; ++field_index) {
-      if (key == signature[field_index].field)
-        break;
-    }
-    if (signature[field_index].field == NULL) {
-      VLOG(1) << network->name() << ": unexpected field: "
-              << key << ", in type: " << onc_type;
-      any_errors = true;
-      continue;
-    }
-    if (!inner_value->IsType(signature[field_index].type)) {
-      VLOG(1) << network->name() << ": field with wrong type: " << key
-              << ", actual type: " << inner_value->GetType()
-              << ", expected type: " << signature[field_index].type;
-      any_errors = true;
-      continue;
-    }
-    PropertyIndex index = signature[field_index].index;
-    // We need to UpdatePropertyMap now since parser might want to
-    // change the mapped value.
-    network->UpdatePropertyMap(index, *inner_value);
-    if (!parser(this, index, *inner_value, network)) {
-      VLOG(1) << network->name() << ": field not parsed: " << key;
-      any_errors = true;
-      continue;
-    }
-    if (VLOG_IS_ON(2)) {
-      std::string value_json;
-      base::JSONWriter::Write(inner_value, true, &value_json);
-      VLOG(2) << network->name() << ": Successfully parsed [" << key
-              << "(" << index << ")] = " << value_json;
-    }
-  }
-  if (any_errors)
-    parse_error_ = l10n_util::GetStringUTF8(
-        IDS_NETWORK_CONFIG_ERROR_NETWORK_PROP_DICT_MALFORMED);
-  return !any_errors;
-}
-
-// static
-bool OncNetworkParser::CheckNetworkType(Network* network,
-                                        ConnectionType expected,
-                                        const std::string& onc_type) {
-  if (expected != network->type()) {
-    LOG(WARNING) << network->name() << ": "
-                 << onc_type << " field unexpected for this type network";
-    return false;
-  }
-  return true;
-}
-
-// static
-bool OncNetworkParser::ParseNetworkConfigurationValue(
-    OncNetworkParser* parser,
-    PropertyIndex index,
-    const base::Value& value,
-    Network* network) {
-  switch (index) {
-    case PROPERTY_INDEX_ONC_WIFI: {
-      return parser->ParseNestedObject(network,
-                                       "WiFi",
-                                       value,
-                                       wifi_signature,
-                                       OncWifiNetworkParser::ParseWifiValue);
-    }
-    case PROPERTY_INDEX_ONC_VPN: {
-      if (!CheckNetworkType(network, TYPE_VPN, "VPN"))
-        return false;
-      VirtualNetwork* virtual_network = static_cast<VirtualNetwork*>(network);
-      // Got the "VPN" field.  Immediately store the VPN.Type field
-      // value so that we can properly validate fields in the VPN
-      // object based on the type.
-      const DictionaryValue* dict = NULL;
-      CHECK(value.GetAsDictionary(&dict));
-      std::string provider_type_string;
-      if (!dict->GetString("Type", &provider_type_string)) {
-        VLOG(1) << network->name() << ": VPN.Type is missing";
-        return false;
-      }
-      ProviderType provider_type =
-        OncVirtualNetworkParser::ParseProviderType(provider_type_string);
-      virtual_network->set_provider_type(provider_type);
-      return parser->ParseNestedObject(network,
-                                       "VPN",
-                                       value,
-                                       vpn_signature,
-                                       OncVirtualNetworkParser::ParseVPNValue);
-      return true;
-    }
-    case PROPERTY_INDEX_ONC_REMOVE:
-      VLOG(1) << network->name() << ": Remove field not yet implemented";
-      return false;
-    case PROPERTY_INDEX_TYPE: {
-      // Update property with native value for type.
-      std::string str =
-        NativeNetworkParser::network_type_mapper()->GetKey(network->type());
-      scoped_ptr<StringValue> val(Value::CreateStringValue(str));
-      network->UpdatePropertyMap(PROPERTY_INDEX_TYPE, *val.get());
-      return true;
-    }
-    case PROPERTY_INDEX_GUID:
-    case PROPERTY_INDEX_NAME:
-      // Fall back to generic parser for these.
-      return parser->ParseValue(index, value, network);
-    default:
-      break;
-  }
-  return false;
-}
-
-// static
-bool OncNetworkParser::DeleteCertAndKeyByNickname(const std::string& label) {
-  net::CertificateList cert_list;
-  ListCertsWithNickname(label, &cert_list);
-  net::CertDatabase cert_db;
-  bool result = true;
-  for (net::CertificateList::iterator iter = cert_list.begin();
-       iter != cert_list.end(); ++iter) {
-    // If we fail, we try and delete the rest still.
-    // TODO(gspencer): this isn't very "transactional".  If we fail on some, but
-    // not all, then it's possible to leave things in a weird state.
-    // Luckily there should only be one cert with a particular
-    // label, and the cert not being found is one of the few reasons the
-    // delete could fail, but still...  The other choice is to return
-    // failure immediately, but that doesn't seem to do what is intended.
-    if (!cert_db.DeleteCertAndKey(iter->get()))
-      result = false;
-  }
-  return result;
-}
-
 // static
 void OncNetworkParser::ListCertsWithNickname(const std::string& label,
                                              net::CertificateList* result) {
   net::CertificateList all_certs;
   net::CertDatabase cert_db;
   cert_db.ListCerts(&all_certs);
   result->clear();
   for (net::CertificateList::iterator iter = all_certs.begin();
        iter != all_certs.end(); ++iter) {
     if (iter->get()->os_cert_handle()->nickname) {
@@ skipping 20 matching lines @@
       char* private_key_nickname = PK11_GetPrivateKeyNickname(private_key);
       if (private_key_nickname && private_key_nickname == label)
         result->push_back(*iter);
       PORT_Free(private_key_nickname);
       SECKEY_DestroyPrivateKey(private_key);
     }
   }
 }
 
 // static
+bool OncNetworkParser::DeleteCertAndKeyByNickname(const std::string& label) {
+  net::CertificateList cert_list;
+  ListCertsWithNickname(label, &cert_list);
+  net::CertDatabase cert_db;
+  bool result = true;
+  for (net::CertificateList::iterator iter = cert_list.begin();
+       iter != cert_list.end(); ++iter) {
+    // If we fail, we try and delete the rest still.
+    // TODO(gspencer): this isn't very "transactional".  If we fail on some, but
+    // not all, then it's possible to leave things in a weird state.
+    // Luckily there should only be one cert with a particular
+    // label, and the cert not being found is one of the few reasons the
+    // delete could fail, but still...  The other choice is to return
+    // failure immediately, but that doesn't seem to do what is intended.
+    if (!cert_db.DeleteCertAndKey(iter->get()))
+      result = false;
+  }
+  return result;
+}
+
+// static
 std::string OncNetworkParser::GetPkcs11IdFromCertGuid(const std::string& guid) {
   // We have to look up the GUID to find the PKCS#11 ID that is needed.
   net::CertificateList cert_list;
   ListCertsWithNickname(guid, &cert_list);
   DCHECK_EQ(1ul, cert_list.size());
   if (cert_list.size() == 1)
     return x509_certificate_model::GetPkcs11Id(cert_list[0]->os_cert_handle());
   return std::string();
 }
 
@@ skipping 472 matching lines @@
     // on the value of AuthenticationType.
     { "L2TP-IPsec", PROVIDER_TYPE_L2TP_IPSEC_PSK },
     { "OpenVPN", PROVIDER_TYPE_OPEN_VPN },
   };
   CR_DEFINE_STATIC_LOCAL(EnumMapper<ProviderType>, parser,
       (table, arraysize(table), PROVIDER_TYPE_MAX));
   return parser.Get(type);
 }
 
 }  // namespace chromeos