network_ui_data.cc revision 4e180b6a0b4720a9b8e9e959a882386f690f08ff 
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
11namespace chromeos {
12
13// Top-level UI data dictionary keys.
14const char NetworkUIData::kKeyONCSource[] = "onc_source";
15const char NetworkUIData::kKeyCertificatePattern[] = "certificate_pattern";
16const char NetworkUIData::kKeyCertificateType[] = "certificate_type";
17const char NetworkUIData::kKeyUserSettings[] = "user_settings";
18
19namespace {
20
21template <typename Enum>
22struct StringEnumEntry {
23  const char* string;
24  Enum enum_value;
25};
26
27const 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
33const 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.
42template <typename Enum, int N>
43std::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.
54template<typename Enum, int N>
55Enum 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
67NetworkUIData::NetworkUIData()
68    : onc_source_(::onc::ONC_SOURCE_NONE),
69      certificate_type_(CLIENT_CERT_TYPE_NONE) {
70}
71
72NetworkUIData::NetworkUIData(const NetworkUIData& other) {
73  *this = other;
74}
75
76NetworkUIData& 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
86NetworkUIData::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
113NetworkUIData::~NetworkUIData() {
114}
115
116void NetworkUIData::set_user_settings(scoped_ptr<base::DictionaryValue> dict) {
117  user_settings_ = dict.Pass();
118}
119
120void 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
142namespace {
143
144void 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
162void 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
170void 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
179void 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
188void 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
197void 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
227scoped_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
240