chromeos/network/network_ui_data.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chromeos/network/network_ui_data.h"
   6
   7 #include "base/logging.h"
   8 #include "base/values.h"
   9 #include "chromeos/network/onc/onc_signature.h"
  10
  11 namespace chromeos {
  12
  13 // Top-level UI data dictionary keys.
  14 const char NetworkUIData::kKeyONCSource[] = "onc_source";
  15 const char NetworkUIData::kKeyCertificatePattern[] = "certificate_pattern";
  16 const char NetworkUIData::kKeyCertificateType[] = "certificate_type";
  17 const char NetworkUIData::kKeyUserSettings[] = "user_settings";
  18 const char NetworkUIData::kONCSourceUserImport[] = "user_import";
  19 const char NetworkUIData::kONCSourceDevicePolicy[] = "device_policy";
  20 const char NetworkUIData::kONCSourceUserPolicy[] = "user_policy";
  21
  22 namespace {
  23
  24 template <typename Enum>
  25 struct StringEnumEntry {
  26   const char* string;
  27   Enum enum_value;
  28 };
  29
  30 const StringEnumEntry< ::onc::ONCSource> kONCSourceTable[] = {
  31   { NetworkUIData::kONCSourceUserImport, ::onc::ONC_SOURCE_USER_IMPORT },
  32   { NetworkUIData::kONCSourceDevicePolicy, ::onc::ONC_SOURCE_DEVICE_POLICY },
  33   { NetworkUIData::kONCSourceUserPolicy, ::onc::ONC_SOURCE_USER_POLICY }
  34 };
  35
  36 const StringEnumEntry<ClientCertType> kClientCertTable[] = {
  37   { "none", CLIENT_CERT_TYPE_NONE },
  38   { "pattern", CLIENT_CERT_TYPE_PATTERN },
  39   { "ref", CLIENT_CERT_TYPE_REF }
  40 };
  41
  42 // Converts |enum_value| to the corresponding string according to |table|. If no
  43 // enum value of the table matches (which can only occur if incorrect casting
  44 // was used to obtain |enum_value|), returns an empty string instead.
  45 template <typename Enum, int N>
  46 std::string EnumToString(const StringEnumEntry<Enum>(& table)[N],
  47                          Enum enum_value) {
  48   for (int i = 0; i < N; ++i) {
  49     if (table[i].enum_value == enum_value)
  50       return table[i].string;
  51   }
  52   return std::string();
  53 }
  54
  55 // Converts |str| to the corresponding enum value according to |table|. If no
  56 // string of the table matches, returns |fallback| instead.
  57 template<typename Enum, int N>
  58 Enum StringToEnum(const StringEnumEntry<Enum>(& table)[N],
  59                   const std::string& str,
  60                   Enum fallback) {
  61   for (int i = 0; i < N; ++i) {
  62     if (table[i].string == str)
  63       return table[i].enum_value;
  64   }
  65   return fallback;
  66 }
  67
  68 }  // namespace
  69
  70 NetworkUIData::NetworkUIData()
  71     : onc_source_(::onc::ONC_SOURCE_NONE),
  72       certificate_type_(CLIENT_CERT_TYPE_NONE) {
  73 }
  74
  75 NetworkUIData::NetworkUIData(const NetworkUIData& other) {
  76   *this = other;
  77 }
  78
  79 NetworkUIData& NetworkUIData::operator=(const NetworkUIData& other) {
  80   certificate_pattern_ = other.certificate_pattern_;
  81   onc_source_ = other.onc_source_;
  82   certificate_type_ = other.certificate_type_;
  83   if (other.user_settings_)
  84     user_settings_.reset(other.user_settings_->DeepCopy());
  85   policy_guid_ = other.policy_guid_;
  86   return *this;
  87 }
  88
  89 NetworkUIData::NetworkUIData(const base::DictionaryValue& dict) {
  90   std::string source;
  91   dict.GetString(kKeyONCSource, &source);
  92   onc_source_ = StringToEnum(kONCSourceTable, source, ::onc::ONC_SOURCE_NONE);
  93
  94   std::string type_string;
  95   dict.GetString(kKeyCertificateType, &type_string);
  96   certificate_type_ =
  97       StringToEnum(kClientCertTable, type_string, CLIENT_CERT_TYPE_NONE);
  98
  99   if (certificate_type_ == CLIENT_CERT_TYPE_PATTERN) {
 100     const base::DictionaryValue* cert_dict = NULL;
 101     dict.GetDictionary(kKeyCertificatePattern, &cert_dict);
 102     if (cert_dict)
 103       certificate_pattern_.CopyFromDictionary(*cert_dict);
 104     if (certificate_pattern_.Empty()) {
 105       // This case may occur if UIData from an older CrOS version is read.
 106       LOG(WARNING) << "Couldn't parse a valid certificate pattern.";
 107       certificate_type_ = CLIENT_CERT_TYPE_NONE;
 108     }
 109   }
 110
 111   const base::DictionaryValue* user_settings = NULL;
 112   if (dict.GetDictionary(kKeyUserSettings, &user_settings))
 113     user_settings_.reset(user_settings->DeepCopy());
 114 }
 115
 116 NetworkUIData::~NetworkUIData() {
 117 }
 118
 119 void NetworkUIData::set_user_settings(scoped_ptr<base::DictionaryValue> dict) {
 120   user_settings_ = dict.Pass();
 121 }
 122
 123 std::string NetworkUIData::GetONCSourceAsString() const {
 124   return EnumToString(kONCSourceTable, onc_source_);
 125 }
 126
 127 void NetworkUIData::FillDictionary(base::DictionaryValue* dict) const {
 128   dict->Clear();
 129
 130   std::string source_string = GetONCSourceAsString();
 131   if (!source_string.empty())
 132     dict->SetString(kKeyONCSource, source_string);
 133
 134   if (certificate_type_ != CLIENT_CERT_TYPE_NONE) {
 135     std::string type_string = EnumToString(kClientCertTable, certificate_type_);
 136     dict->SetString(kKeyCertificateType, type_string);
 137
 138     if (certificate_type_ == CLIENT_CERT_TYPE_PATTERN &&
 139         !certificate_pattern_.Empty()) {
 140       dict->Set(kKeyCertificatePattern,
 141                 certificate_pattern_.CreateAsDictionary());
 142     }
 143   }
 144   if (user_settings_)
 145     dict->SetWithoutPathExpansion(kKeyUserSettings,
 146                                   user_settings_->DeepCopy());
 147 }
 148
 149 namespace {
 150
 151 void TranslateClientCertType(const std::string& client_cert_type,
 152                              NetworkUIData* ui_data) {
 153   using namespace ::onc::certificate;
 154   ClientCertType type;
 155   if (client_cert_type == kNone) {
 156     type = CLIENT_CERT_TYPE_NONE;
 157   } else if (client_cert_type == kRef) {
 158     type = CLIENT_CERT_TYPE_REF;
 159   } else if (client_cert_type == kPattern) {
 160     type = CLIENT_CERT_TYPE_PATTERN;
 161   } else {
 162     type = CLIENT_CERT_TYPE_NONE;
 163     NOTREACHED();
 164   }
 165
 166   ui_data->set_certificate_type(type);
 167 }
 168
 169 void TranslateCertificatePattern(const base::DictionaryValue& onc_object,
 170                                  NetworkUIData* ui_data) {
 171   CertificatePattern pattern;
 172   bool success = pattern.CopyFromDictionary(onc_object);
 173   DCHECK(success);
 174   ui_data->set_certificate_pattern(pattern);
 175 }
 176
 177 void TranslateEAP(const base::DictionaryValue& eap,
 178                   NetworkUIData* ui_data) {
 179   std::string client_cert_type;
 180   if (eap.GetStringWithoutPathExpansion(::onc::eap::kClientCertType,
 181                                         &client_cert_type)) {
 182     TranslateClientCertType(client_cert_type, ui_data);
 183   }
 184 }
 185
 186 void TranslateIPsec(const base::DictionaryValue& ipsec,
 187                     NetworkUIData* ui_data) {
 188   std::string client_cert_type;
 189   if (ipsec.GetStringWithoutPathExpansion(::onc::vpn::kClientCertType,
 190                                           &client_cert_type)) {
 191     TranslateClientCertType(client_cert_type, ui_data);
 192   }
 193 }
 194
 195 void TranslateOpenVPN(const base::DictionaryValue& openvpn,
 196                       NetworkUIData* ui_data) {
 197   std::string client_cert_type;
 198   if (openvpn.GetStringWithoutPathExpansion(::onc::vpn::kClientCertType,
 199                                             &client_cert_type)) {
 200     TranslateClientCertType(client_cert_type, ui_data);
 201   }
 202 }
 203
 204 void TranslateONCHierarchy(const onc::OncValueSignature& signature,
 205                            const base::DictionaryValue& onc_object,
 206                            NetworkUIData* ui_data) {
 207   if (&signature == &onc::kCertificatePatternSignature)
 208     TranslateCertificatePattern(onc_object, ui_data);
 209   else if (&signature == &onc::kEAPSignature)
 210     TranslateEAP(onc_object, ui_data);
 211   else if (&signature == &onc::kIPsecSignature)
 212     TranslateIPsec(onc_object, ui_data);
 213   else if (&signature == &onc::kOpenVPNSignature)
 214     TranslateOpenVPN(onc_object, ui_data);
 215
 216   // Recurse into nested objects.
 217   for (base::DictionaryValue::Iterator it(onc_object); !it.IsAtEnd();
 218        it.Advance()) {
 219     const base::DictionaryValue* inner_object;
 220     if (!it.value().GetAsDictionary(&inner_object))
 221       continue;
 222
 223     const onc::OncFieldSignature* field_signature =
 224         GetFieldSignature(signature, it.key());
 225
 226     TranslateONCHierarchy(*field_signature->value_signature, *inner_object,
 227                           ui_data);
 228   }
 229 }
 230
 231 }  // namespace
 232
 233 // static
 234 scoped_ptr<NetworkUIData> NetworkUIData::CreateFromONC(
 235     ::onc::ONCSource onc_source,
 236     const base::DictionaryValue& onc_network) {
 237   scoped_ptr<NetworkUIData> ui_data(new NetworkUIData());
 238   TranslateONCHierarchy(onc::kNetworkConfigurationSignature, onc_network,
 239                         ui_data.get());
 240
 241   ui_data->set_onc_source(onc_source);
 242
 243   return ui_data.Pass();
 244 }
 245
 246 }  // namespace chromeos