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>
EnumToString(const StringEnumEntry<Enum> (& table)[N],Enum enum_value)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>
StringToEnum(const StringEnumEntry<Enum> (& table)[N],const std::string & str,Enum fallback)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
NetworkUIData()70 NetworkUIData::NetworkUIData()
71 : onc_source_(::onc::ONC_SOURCE_NONE),
72 certificate_type_(CLIENT_CERT_TYPE_NONE) {
73 }
74
NetworkUIData(const NetworkUIData & other)75 NetworkUIData::NetworkUIData(const NetworkUIData& other) {
76 *this = other;
77 }
78
operator =(const NetworkUIData & other)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
NetworkUIData(const base::DictionaryValue & dict)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
~NetworkUIData()116 NetworkUIData::~NetworkUIData() {
117 }
118
set_user_settings(scoped_ptr<base::DictionaryValue> dict)119 void NetworkUIData::set_user_settings(scoped_ptr<base::DictionaryValue> dict) {
120 user_settings_ = dict.Pass();
121 }
122
GetONCSourceAsString() const123 std::string NetworkUIData::GetONCSourceAsString() const {
124 return EnumToString(kONCSourceTable, onc_source_);
125 }
126
FillDictionary(base::DictionaryValue * dict) const127 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
TranslateClientCertType(const std::string & client_cert_type,NetworkUIData * ui_data)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
TranslateCertificatePattern(const base::DictionaryValue & onc_object,NetworkUIData * ui_data)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
TranslateEAP(const base::DictionaryValue & eap,NetworkUIData * ui_data)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
TranslateIPsec(const base::DictionaryValue & ipsec,NetworkUIData * ui_data)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
TranslateOpenVPN(const base::DictionaryValue & openvpn,NetworkUIData * ui_data)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
TranslateONCHierarchy(const onc::OncValueSignature & signature,const base::DictionaryValue & onc_object,NetworkUIData * ui_data)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
CreateFromONC(::onc::ONCSource onc_source,const base::DictionaryValue & onc_network)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
247