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