ONC: add support for non-utf-8 SSIDs

chromeos/network/onc/onc_utils.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_utils.h"
 
 #include "base/base64.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/onc/onc_mapper.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/onc/onc_validator.h"
 #include "crypto/encryptor.h"
 #include "crypto/hmac.h"
 #include "crypto/symmetric_key.h"
@@ skipping 212 matching lines @@
   for (base::ListValue::iterator it = network_configs->begin();
        it != network_configs->end(); ++it) {
     base::DictionaryValue* network = NULL;
     (*it)->GetAsDictionary(&network);
     DCHECK(network);
     ExpandStringsInOncObject(
         kNetworkConfigurationSignature, substitution, network);
   }
 }
 
+void FillInHexSSIDFieldsInOncObject(const OncValueSignature& signature,
+                                    base::DictionaryValue* onc_object) {
+  if (&signature == &kWiFiSignature)
+    FillInHexSSIDField(onc_object);
+
+  // Recurse into nested objects.
+  for (base::DictionaryValue::Iterator it(*onc_object); !it.IsAtEnd();
+       it.Advance()) {
+    base::DictionaryValue* inner_object = NULL;

[pneubeck (no reviews), 2014/11/27 14:49:02]

nit: NULL -> nullptr (please check in the whole CL)

[cschuet (SLOW), 2014/11/27 15:44:31]

Done.

+    if (!onc_object->GetDictionaryWithoutPathExpansion(it.key(), &inner_object))
+      continue;
+
+    const OncFieldSignature* field_signature =
+        GetFieldSignature(signature, it.key());
+    if (!field_signature)
+      continue;
+
+    FillInHexSSIDFieldsInOncObject(*field_signature->value_signature,
+                                   inner_object);
+  }
+}
+
+void FillInHexSSIDField(base::DictionaryValue* wifi_fields) {
+  if (!wifi_fields->HasKey(::onc::wifi::kHexSSID)) {
+    std::string ssid_string;
+    wifi_fields->GetStringWithoutPathExpansion(::onc::wifi::kSSID,
+                                               &ssid_string);
+    wifi_fields->SetStringWithoutPathExpansion(
+        ::onc::wifi::kHexSSID,
+        base::HexEncode(ssid_string.c_str(), ssid_string.size()));
+  }
+}
+
 namespace {
 
 class OncMaskValues : public Mapper {
  public:
   static scoped_ptr<base::DictionaryValue> Mask(
       const OncValueSignature& signature,
       const base::DictionaryValue& onc_object,
       const std::string& mask) {
     OncMaskValues masker(mask);
     bool unused_error;
@@ skipping 138 matching lines @@
                       true,   // Fail on missing fields.
                       from_policy);
   validator.SetOncSource(onc_source);
 
   Validator::Result validation_result;
   toplevel_onc = validator.ValidateAndRepairObject(
       &kToplevelConfigurationSignature,
       *toplevel_onc,
       &validation_result);
 
+  FillInHexSSIDFieldsInOncObject(kToplevelConfigurationSignature,
+                                 toplevel_onc.get());
+
   if (from_policy) {
     UMA_HISTOGRAM_BOOLEAN("Enterprise.ONC.PolicyValidation",
                           validation_result == Validator::VALID);
   }
 
   bool success = true;
   if (validation_result == Validator::VALID_WITH_WARNINGS) {
     LOG(WARNING) << "ONC from " << GetSourceAsString(onc_source)
                  << " produced warnings.";
     success = false;
@@ skipping 279 matching lines @@
   }
 
   const base::ListValue* recommended_keys = NULL;
   return (onc->GetList(recommended_property_key, &recommended_keys) &&
           recommended_keys->Find(base::StringValue(property_basename)) !=
           recommended_keys->end());
 }
 
 }  // namespace onc
 }  // namespace chromeos