certificate_pattern.cc revision eb525c5499e34cc9c4b825d6d9e75bb07cc06ace 
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/certificate_pattern.h"
6
7#include "base/logging.h"
8#include "base/values.h"
9#include "chromeos/network/onc/onc_constants.h"
10
11namespace chromeos {
12
13namespace {
14
15// Keys for converting classes below to/from dictionaries.
16const char kCommonNameKey[] = "CommonName";
17const char kLocalityKey[] = "Locality";
18const char kOrganizationKey[] = "Organization";
19const char kOrganizationalUnitKey[] = "OrganizationalUnit";
20const char kIssuerKey[] = "Issuer";
21const char kSubjectKey[] = "Subject";
22const char kEnrollmentUriKey[] = "EnrollmentURI";
23
24bool GetAsListOfStrings(const base::Value& value,
25                        std::vector<std::string>* result) {
26  const base::ListValue* list = NULL;
27  if (!value.GetAsList(&list))
28    return false;
29  result->clear();
30  result->reserve(list->GetSize());
31  for (size_t i = 0; i < list->GetSize(); i++) {
32    std::string item;
33    if (!list->GetString(i, &item))
34      return false;
35    result->push_back(item);
36  }
37  return true;
38}
39
40base::ListValue* CreateListFromStrings(
41    const std::vector<std::string>& strings) {
42  base::ListValue* new_list = new base::ListValue;
43  for (std::vector<std::string>::const_iterator iter = strings.begin();
44       iter != strings.end(); ++iter) {
45    new_list->Append(new base::StringValue(*iter));
46  }
47  return new_list;
48}
49
50}  // namespace
51
52////////////////////////////////////////////////////////////////////////////////
53// IssuerSubjectPattern
54IssuerSubjectPattern::IssuerSubjectPattern(const std::string& common_name,
55                     const std::string& locality,
56                     const std::string& organization,
57                     const std::string& organizational_unit)
58    : common_name_(common_name),
59      locality_(locality),
60      organization_(organization),
61      organizational_unit_(organizational_unit) { }
62
63IssuerSubjectPattern::IssuerSubjectPattern() {}
64
65IssuerSubjectPattern::~IssuerSubjectPattern() {}
66
67bool IssuerSubjectPattern::Empty() const {
68  return common_name_.empty() &&
69         locality_.empty() &&
70         organization_.empty() &&
71         organizational_unit_.empty();
72}
73
74void IssuerSubjectPattern::Clear() {
75  common_name_.clear();
76  locality_.clear();
77  organization_.clear();
78  organizational_unit_.clear();
79}
80
81base::DictionaryValue* IssuerSubjectPattern::CreateAsDictionary() const {
82  base::DictionaryValue* dict = new base::DictionaryValue;
83  if (!common_name_.empty())
84    dict->SetString(kCommonNameKey, common_name_);
85  if (!locality_.empty())
86    dict->SetString(kLocalityKey, locality_);
87  if (!organization_.empty())
88    dict->SetString(kOrganizationKey, organization_);
89  if (!organizational_unit_.empty())
90    dict->SetString(kOrganizationalUnitKey, organizational_unit_);
91  return dict;
92}
93
94bool IssuerSubjectPattern::CopyFromDictionary(
95    const base::DictionaryValue& dict) {
96  Clear();
97  dict.GetString(kCommonNameKey, &common_name_);
98  dict.GetString(kLocalityKey, &locality_);
99  dict.GetString(kOrganizationKey, &organization_);
100  dict.GetString(kOrganizationalUnitKey, &organizational_unit_);
101  // If the dictionary wasn't empty, but we are, or vice versa, then something
102  // went wrong.
103  DCHECK(dict.empty() == Empty());
104  if (dict.empty() != Empty())
105    return false;
106  return true;
107}
108
109////////////////////////////////////////////////////////////////////////////////
110// CertificatePattern
111
112CertificatePattern::CertificatePattern() {}
113
114CertificatePattern::~CertificatePattern() {}
115
116bool CertificatePattern::Empty() const {
117  return issuer_ca_pems_.empty() &&
118         issuer_.Empty() &&
119         subject_.Empty();
120}
121
122void CertificatePattern::Clear() {
123  issuer_ca_pems_.clear();
124  issuer_.Clear();
125  subject_.Clear();
126  enrollment_uri_list_.clear();
127}
128
129base::DictionaryValue* CertificatePattern::CreateAsDictionary() const {
130  base::DictionaryValue* dict = new base::DictionaryValue;
131
132  if (!issuer_ca_pems_.empty()) {
133    dict->Set(onc::certificate::kIssuerCAPEMs,
134              CreateListFromStrings(issuer_ca_pems_));
135  }
136
137  if (!issuer_.Empty())
138    dict->Set(kIssuerKey, issuer_.CreateAsDictionary());
139
140  if (!subject_.Empty())
141    dict->Set(kSubjectKey, subject_.CreateAsDictionary());
142
143  if (!enrollment_uri_list_.empty())
144    dict->Set(kEnrollmentUriKey, CreateListFromStrings(enrollment_uri_list_));
145  return dict;
146}
147
148bool CertificatePattern::CopyFromDictionary(const base::DictionaryValue &dict) {
149  const base::DictionaryValue* child_dict = NULL;
150  const base::ListValue* child_list = NULL;
151  Clear();
152
153  // All of these are optional.
154  if (dict.GetList(onc::certificate::kIssuerCAPEMs, &child_list) &&
155      child_list) {
156    if (!GetAsListOfStrings(*child_list, &issuer_ca_pems_))
157      return false;
158  }
159  if (dict.GetDictionary(kIssuerKey, &child_dict) && child_dict) {
160    if (!issuer_.CopyFromDictionary(*child_dict))
161      return false;
162  }
163  child_dict = NULL;
164  if (dict.GetDictionary(kSubjectKey, &child_dict) && child_dict) {
165    if (!subject_.CopyFromDictionary(*child_dict))
166      return false;
167  }
168  child_list = NULL;
169  if (dict.GetList(kEnrollmentUriKey, &child_list) && child_list) {
170    if (!GetAsListOfStrings(*child_list, &enrollment_uri_list_))
171      return false;
172  }
173
174  // If we didn't copy anything from the dictionary, then it had better be
175  // empty.
176  DCHECK(dict.empty() == Empty());
177  if (dict.empty() != Empty())
178    return false;
179
180  return true;
181}
182
183}  // namespace chromeos
184