1 //
2 // Copyright (C) 2012 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //      http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 
17 #include "update_engine/common/prefs.h"
18 
19 #include <algorithm>
20 
21 #include <base/files/file_enumerator.h>
22 #include <base/files/file_util.h>
23 #include <base/logging.h>
24 #include <base/strings/string_number_conversions.h>
25 #include <base/strings/string_split.h>
26 #include <base/strings/string_util.h>
27 
28 #include "update_engine/common/utils.h"
29 
30 using std::string;
31 using std::vector;
32 
33 namespace chromeos_update_engine {
34 
35 namespace {
36 
DeleteEmptyDirectories(const base::FilePath & path)37 void DeleteEmptyDirectories(const base::FilePath& path) {
38   base::FileEnumerator path_enum(
39       path, false /* recursive */, base::FileEnumerator::DIRECTORIES);
40   for (base::FilePath dir_path = path_enum.Next(); !dir_path.empty();
41        dir_path = path_enum.Next()) {
42     DeleteEmptyDirectories(dir_path);
43     if (base::IsDirectoryEmpty(dir_path))
44 #if BASE_VER < 800000
45       base::DeleteFile(dir_path, false);
46 #else
47       base::DeleteFile(dir_path);
48 #endif
49   }
50 }
51 
52 }  // namespace
53 
GetString(const string & key,string * value) const54 bool PrefsBase::GetString(const string& key, string* value) const {
55   return storage_->GetKey(key, value);
56 }
57 
SetString(const string & key,std::string_view value)58 bool PrefsBase::SetString(const string& key, std::string_view value) {
59   TEST_AND_RETURN_FALSE(storage_->SetKey(key, value));
60   const auto observers_for_key = observers_.find(key);
61   if (observers_for_key != observers_.end()) {
62     std::vector<ObserverInterface*> copy_observers(observers_for_key->second);
63     for (ObserverInterface* observer : copy_observers)
64       observer->OnPrefSet(key);
65   }
66   return true;
67 }
68 
GetInt64(const string & key,int64_t * value) const69 bool PrefsBase::GetInt64(const string& key, int64_t* value) const {
70   string str_value;
71   if (!GetString(key, &str_value))
72     return false;
73   base::TrimWhitespaceASCII(str_value, base::TRIM_ALL, &str_value);
74   TEST_AND_RETURN_FALSE(base::StringToInt64(str_value, value));
75   return true;
76 }
77 
SetInt64(const string & key,const int64_t value)78 bool PrefsBase::SetInt64(const string& key, const int64_t value) {
79   return SetString(key, base::NumberToString(value));
80 }
81 
GetBoolean(const string & key,bool * value) const82 bool PrefsBase::GetBoolean(const string& key, bool* value) const {
83   string str_value;
84   if (!GetString(key, &str_value))
85     return false;
86   base::TrimWhitespaceASCII(str_value, base::TRIM_ALL, &str_value);
87   if (str_value == "false") {
88     *value = false;
89     return true;
90   }
91   if (str_value == "true") {
92     *value = true;
93     return true;
94   }
95   return false;
96 }
97 
SetBoolean(const string & key,const bool value)98 bool PrefsBase::SetBoolean(const string& key, const bool value) {
99   return SetString(key, value ? "true" : "false");
100 }
101 
Exists(const string & key) const102 bool PrefsBase::Exists(const string& key) const {
103   return storage_->KeyExists(key);
104 }
105 
Delete(const string & key)106 bool PrefsBase::Delete(const string& key) {
107   TEST_AND_RETURN_FALSE(storage_->DeleteKey(key));
108   const auto observers_for_key = observers_.find(key);
109   if (observers_for_key != observers_.end()) {
110     std::vector<ObserverInterface*> copy_observers(observers_for_key->second);
111     for (ObserverInterface* observer : copy_observers)
112       observer->OnPrefDeleted(key);
113   }
114   return true;
115 }
116 
Delete(const string & pref_key,const vector<string> & nss)117 bool PrefsBase::Delete(const string& pref_key, const vector<string>& nss) {
118   // Delete pref key for platform.
119   bool success = Delete(pref_key);
120   // Delete pref key in each namespace.
121   for (const auto& ns : nss) {
122     vector<string> namespace_keys;
123     success = GetSubKeys(ns, &namespace_keys) && success;
124     for (const auto& key : namespace_keys) {
125       auto last_key_seperator = key.find_last_of(kKeySeparator);
126       if (last_key_seperator != string::npos &&
127           pref_key == key.substr(last_key_seperator + 1)) {
128         success = Delete(key) && success;
129       }
130     }
131   }
132   return success;
133 }
134 
GetSubKeys(const string & ns,vector<string> * keys) const135 bool PrefsBase::GetSubKeys(const string& ns, vector<string>* keys) const {
136   return storage_->GetSubKeys(ns, keys);
137 }
138 
AddObserver(const string & key,ObserverInterface * observer)139 void PrefsBase::AddObserver(const string& key, ObserverInterface* observer) {
140   observers_[key].push_back(observer);
141 }
142 
RemoveObserver(const string & key,ObserverInterface * observer)143 void PrefsBase::RemoveObserver(const string& key, ObserverInterface* observer) {
144   std::vector<ObserverInterface*>& observers_for_key = observers_[key];
145   auto observer_it =
146       std::find(observers_for_key.begin(), observers_for_key.end(), observer);
147   if (observer_it != observers_for_key.end())
148     observers_for_key.erase(observer_it);
149 }
150 
CreateSubKey(const vector<string> & ns_and_key)151 string PrefsInterface::CreateSubKey(const vector<string>& ns_and_key) {
152   return base::JoinString(ns_and_key, string(1, kKeySeparator));
153 }
154 
155 // Prefs
156 
Init(const base::FilePath & prefs_dir)157 bool Prefs::Init(const base::FilePath& prefs_dir) {
158   return file_storage_.Init(prefs_dir);
159 }
160 
Init(const base::FilePath & prefs_dir)161 bool Prefs::FileStorage::Init(const base::FilePath& prefs_dir) {
162   prefs_dir_ = prefs_dir;
163   // Delete empty directories. Ignore errors when deleting empty directories.
164   DeleteEmptyDirectories(prefs_dir_);
165   return true;
166 }
167 
GetKey(const string & key,string * value) const168 bool Prefs::FileStorage::GetKey(const string& key, string* value) const {
169   base::FilePath filename;
170   TEST_AND_RETURN_FALSE(GetFileNameForKey(key, &filename));
171   if (!base::ReadFileToString(filename, value)) {
172     return false;
173   }
174   return true;
175 }
176 
GetSubKeys(const string & ns,vector<string> * keys) const177 bool Prefs::FileStorage::GetSubKeys(const string& ns,
178                                     vector<string>* keys) const {
179   base::FilePath filename;
180   TEST_AND_RETURN_FALSE(GetFileNameForKey(ns, &filename));
181   base::FileEnumerator namespace_enum(
182       prefs_dir_, true, base::FileEnumerator::FILES);
183   for (base::FilePath f = namespace_enum.Next(); !f.empty();
184        f = namespace_enum.Next()) {
185     auto filename_str = filename.value();
186     if (f.value().compare(0, filename_str.length(), filename_str) == 0) {
187       // Only return the key portion excluding the |prefs_dir_| with slash.
188       keys->push_back(f.value().substr(
189           prefs_dir_.AsEndingWithSeparator().value().length()));
190     }
191   }
192   return true;
193 }
194 
SetKey(const string & key,std::string_view value)195 bool Prefs::FileStorage::SetKey(const string& key, std::string_view value) {
196   base::FilePath filename;
197   TEST_AND_RETURN_FALSE(GetFileNameForKey(key, &filename));
198   if (!base::DirectoryExists(filename.DirName())) {
199     // Only attempt to create the directory if it doesn't exist to avoid calls
200     // to parent directories where we might not have permission to write to.
201     TEST_AND_RETURN_FALSE(base::CreateDirectory(filename.DirName()));
202   }
203   TEST_AND_RETURN_FALSE(base::WriteFile(filename, value.data(), value.size()) ==
204                         static_cast<int>(value.size()));
205   return true;
206 }
207 
KeyExists(const string & key) const208 bool Prefs::FileStorage::KeyExists(const string& key) const {
209   base::FilePath filename;
210   TEST_AND_RETURN_FALSE(GetFileNameForKey(key, &filename));
211   return base::PathExists(filename);
212 }
213 
DeleteKey(const string & key)214 bool Prefs::FileStorage::DeleteKey(const string& key) {
215   base::FilePath filename;
216   TEST_AND_RETURN_FALSE(GetFileNameForKey(key, &filename));
217 #if BASE_VER < 800000
218   TEST_AND_RETURN_FALSE(base::DeleteFile(filename, false));
219 #else
220   TEST_AND_RETURN_FALSE(base::DeleteFile(filename));
221 #endif
222   return true;
223 }
224 
GetFileNameForKey(const string & key,base::FilePath * filename) const225 bool Prefs::FileStorage::GetFileNameForKey(const string& key,
226                                            base::FilePath* filename) const {
227   // Allows only non-empty keys containing [A-Za-z0-9_-/].
228   TEST_AND_RETURN_FALSE(!key.empty());
229   for (char c : key)
230     TEST_AND_RETURN_FALSE(base::IsAsciiAlpha(c) || base::IsAsciiDigit(c) ||
231                           c == '_' || c == '-' || c == kKeySeparator);
232   *filename = prefs_dir_.Append(key);
233   return true;
234 }
235 
236 // MemoryPrefs
237 
GetKey(const string & key,string * value) const238 bool MemoryPrefs::MemoryStorage::GetKey(const string& key,
239                                         string* value) const {
240   auto it = values_.find(key);
241   if (it == values_.end())
242     return false;
243   *value = it->second;
244   return true;
245 }
246 
GetSubKeys(const string & ns,vector<string> * keys) const247 bool MemoryPrefs::MemoryStorage::GetSubKeys(const string& ns,
248                                             vector<string>* keys) const {
249   using value_type = decltype(values_)::value_type;
250   using key_type = decltype(values_)::key_type;
251   auto lower_comp = [](const value_type& pr, const key_type& ns) {
252     return pr.first.substr(0, ns.length()) < ns;
253   };
254   auto upper_comp = [](const key_type& ns, const value_type& pr) {
255     return ns < pr.first.substr(0, ns.length());
256   };
257   auto lower_it =
258       std::lower_bound(begin(values_), end(values_), ns, lower_comp);
259   auto upper_it = std::upper_bound(lower_it, end(values_), ns, upper_comp);
260   while (lower_it != upper_it)
261     keys->push_back((lower_it++)->first);
262   return true;
263 }
264 
SetKey(const string & key,std::string_view value)265 bool MemoryPrefs::MemoryStorage::SetKey(const string& key,
266                                         std::string_view value) {
267   values_[key] = value;
268   return true;
269 }
270 
KeyExists(const string & key) const271 bool MemoryPrefs::MemoryStorage::KeyExists(const string& key) const {
272   return values_.find(key) != values_.end();
273 }
274 
DeleteKey(const string & key)275 bool MemoryPrefs::MemoryStorage::DeleteKey(const string& key) {
276   auto it = values_.find(key);
277   if (it != values_.end())
278     values_.erase(it);
279   return true;
280 }
281 
282 }  // namespace chromeos_update_engine
283