1 /*
2  * Copyright (C) 2016 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 "android-base/properties.h"
18 
19 #if defined(__BIONIC__)
20 #define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
21 #include <sys/system_properties.h>
22 #include <sys/_system_properties.h>
23 #endif
24 
25 #include <algorithm>
26 #include <chrono>
27 #include <limits>
28 #include <map>
29 #include <string>
30 
31 #include <android-base/parsebool.h>
32 #include <android-base/parseint.h>
33 #include <android-base/strings.h>
34 
35 #if !defined(__BIONIC__)
36 
37 #define PROP_VALUE_MAX 92
38 
39 static std::map<std::string, std::string>& g_properties = *new std::map<std::string, std::string>;
40 
__system_property_set(const char * key,const char * value)41 int __system_property_set(const char* key, const char* value) {
42   if (key == nullptr || *key == '\0') return -1;
43   if (value == nullptr) value = "";
44 
45   bool read_only = !strncmp(key, "ro.", 3);
46   if (read_only) {
47     const auto [it, success] = g_properties.insert({key, value});
48     return success ? 0 : -1;
49   }
50 
51   if (strlen(value) >= 92) return -1;
52   g_properties[key] = value;
53   return 0;
54 }
55 
__system_property_get(const char * key,char * value)56 int __system_property_get(const char* key, char* value) {
57   auto it = g_properties.find(key);
58   if (it == g_properties.end()) {
59     *value = '\0';
60     return 0;
61   }
62   snprintf(value, PROP_VALUE_MAX, "%s", it->second.c_str());
63   return strlen(value);
64 }
65 
66 #endif
67 
68 namespace android {
69 namespace base {
70 
GetBoolProperty(const std::string & key,bool default_value)71 bool GetBoolProperty(const std::string& key, bool default_value) {
72   switch (ParseBool(GetProperty(key, ""))) {
73     case ParseBoolResult::kError:
74       return default_value;
75     case ParseBoolResult::kFalse:
76       return false;
77     case ParseBoolResult::kTrue:
78       return true;
79   }
80   __builtin_unreachable();
81 }
82 
83 template <typename T>
GetIntProperty(const std::string & key,T default_value,T min,T max)84 T GetIntProperty(const std::string& key, T default_value, T min, T max) {
85   T result;
86   std::string value = GetProperty(key, "");
87   if (!value.empty() && android::base::ParseInt(value, &result, min, max)) return result;
88   return default_value;
89 }
90 
91 template <typename T>
GetUintProperty(const std::string & key,T default_value,T max)92 T GetUintProperty(const std::string& key, T default_value, T max) {
93   T result;
94   std::string value = GetProperty(key, "");
95   if (!value.empty() && android::base::ParseUint(value, &result, max)) return result;
96   return default_value;
97 }
98 
99 template int8_t GetIntProperty(const std::string&, int8_t, int8_t, int8_t);
100 template int16_t GetIntProperty(const std::string&, int16_t, int16_t, int16_t);
101 template int32_t GetIntProperty(const std::string&, int32_t, int32_t, int32_t);
102 template int64_t GetIntProperty(const std::string&, int64_t, int64_t, int64_t);
103 
104 template uint8_t GetUintProperty(const std::string&, uint8_t, uint8_t);
105 template uint16_t GetUintProperty(const std::string&, uint16_t, uint16_t);
106 template uint32_t GetUintProperty(const std::string&, uint32_t, uint32_t);
107 template uint64_t GetUintProperty(const std::string&, uint64_t, uint64_t);
108 
GetProperty(const std::string & key,const std::string & default_value)109 std::string GetProperty(const std::string& key, const std::string& default_value) {
110   std::string property_value;
111 #if defined(__BIONIC__)
112   const prop_info* pi = __system_property_find(key.c_str());
113   if (pi == nullptr) return default_value;
114 
115   __system_property_read_callback(pi,
116                                   [](void* cookie, const char*, const char* value, unsigned) {
117                                     auto property_value = reinterpret_cast<std::string*>(cookie);
118                                     *property_value = value;
119                                   },
120                                   &property_value);
121 #else
122   // TODO: implement host __system_property_find()/__system_property_read_callback()?
123   auto it = g_properties.find(key);
124   if (it == g_properties.end()) return default_value;
125   property_value = it->second;
126 #endif
127   // If the property exists but is empty, also return the default value.
128   // Since we can't remove system properties, "empty" is traditionally
129   // the same as "missing" (this was true for cutils' property_get).
130   return property_value.empty() ? default_value : property_value;
131 }
132 
SetProperty(const std::string & key,const std::string & value)133 bool SetProperty(const std::string& key, const std::string& value) {
134   return (__system_property_set(key.c_str(), value.c_str()) == 0);
135 }
136 
137 #if defined(__BIONIC__)
138 
139 struct WaitForPropertyData {
140   bool done;
141   const std::string* expected_value;
142   unsigned last_read_serial;
143 };
144 
WaitForPropertyCallback(void * data_ptr,const char *,const char * value,unsigned serial)145 static void WaitForPropertyCallback(void* data_ptr, const char*, const char* value, unsigned serial) {
146   WaitForPropertyData* data = reinterpret_cast<WaitForPropertyData*>(data_ptr);
147   if (*data->expected_value == value) {
148     data->done = true;
149   } else {
150     data->last_read_serial = serial;
151   }
152 }
153 
154 // TODO: chrono_utils?
DurationToTimeSpec(timespec & ts,const std::chrono::milliseconds d)155 static void DurationToTimeSpec(timespec& ts, const std::chrono::milliseconds d) {
156   auto s = std::chrono::duration_cast<std::chrono::seconds>(d);
157   auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(d - s);
158   ts.tv_sec = std::min<std::chrono::seconds::rep>(s.count(), std::numeric_limits<time_t>::max());
159   ts.tv_nsec = ns.count();
160 }
161 
162 using AbsTime = std::chrono::time_point<std::chrono::steady_clock>;
163 
UpdateTimeSpec(timespec & ts,std::chrono::milliseconds relative_timeout,const AbsTime & start_time)164 static void UpdateTimeSpec(timespec& ts, std::chrono::milliseconds relative_timeout,
165                            const AbsTime& start_time) {
166   auto now = std::chrono::steady_clock::now();
167   auto time_elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - start_time);
168   if (time_elapsed >= relative_timeout) {
169     ts = { 0, 0 };
170   } else {
171     auto remaining_timeout = relative_timeout - time_elapsed;
172     DurationToTimeSpec(ts, remaining_timeout);
173   }
174 }
175 
176 // Waits for the system property `key` to be created.
177 // Times out after `relative_timeout`.
178 // Sets absolute_timeout which represents absolute time for the timeout.
179 // Returns nullptr on timeout.
WaitForPropertyCreation(const std::string & key,const std::chrono::milliseconds & relative_timeout,const AbsTime & start_time)180 static const prop_info* WaitForPropertyCreation(const std::string& key,
181                                                 const std::chrono::milliseconds& relative_timeout,
182                                                 const AbsTime& start_time) {
183   // Find the property's prop_info*.
184   const prop_info* pi;
185   unsigned global_serial = 0;
186   while ((pi = __system_property_find(key.c_str())) == nullptr) {
187     // The property doesn't even exist yet.
188     // Wait for a global change and then look again.
189     timespec ts;
190     UpdateTimeSpec(ts, relative_timeout, start_time);
191     if (!__system_property_wait(nullptr, global_serial, &global_serial, &ts)) return nullptr;
192   }
193   return pi;
194 }
195 
WaitForProperty(const std::string & key,const std::string & expected_value,std::chrono::milliseconds relative_timeout)196 bool WaitForProperty(const std::string& key, const std::string& expected_value,
197                      std::chrono::milliseconds relative_timeout) {
198   auto start_time = std::chrono::steady_clock::now();
199   const prop_info* pi = WaitForPropertyCreation(key, relative_timeout, start_time);
200   if (pi == nullptr) return false;
201 
202   WaitForPropertyData data;
203   data.expected_value = &expected_value;
204   data.done = false;
205   while (true) {
206     timespec ts;
207     // Check whether the property has the value we're looking for?
208     __system_property_read_callback(pi, WaitForPropertyCallback, &data);
209     if (data.done) return true;
210 
211     // It didn't, so wait for the property to change before checking again.
212     UpdateTimeSpec(ts, relative_timeout, start_time);
213     uint32_t unused;
214     if (!__system_property_wait(pi, data.last_read_serial, &unused, &ts)) return false;
215   }
216 }
217 
WaitForPropertyCreation(const std::string & key,std::chrono::milliseconds relative_timeout)218 bool WaitForPropertyCreation(const std::string& key,
219                              std::chrono::milliseconds relative_timeout) {
220   auto start_time = std::chrono::steady_clock::now();
221   return (WaitForPropertyCreation(key, relative_timeout, start_time) != nullptr);
222 }
223 
CachedProperty(const char * property_name)224 CachedProperty::CachedProperty(const char* property_name)
225     : property_name_(property_name),
226       prop_info_(nullptr),
227       cached_area_serial_(0),
228       cached_property_serial_(0),
229       is_read_only_(android::base::StartsWith(property_name, "ro.")),
230       read_only_property_(nullptr) {
231   static_assert(sizeof(cached_value_) == PROP_VALUE_MAX);
232 }
233 
Get(bool * changed)234 const char* CachedProperty::Get(bool* changed) {
235   std::optional<uint32_t> initial_property_serial_ = cached_property_serial_;
236 
237   // Do we have a `struct prop_info` yet?
238   if (prop_info_ == nullptr) {
239     // `__system_property_find` is expensive, so only retry if a property
240     // has been created since last time we checked.
241     uint32_t property_area_serial = __system_property_area_serial();
242     if (property_area_serial != cached_area_serial_) {
243       prop_info_ = __system_property_find(property_name_.c_str());
244       cached_area_serial_ = property_area_serial;
245     }
246   }
247 
248   if (prop_info_ != nullptr) {
249     // Only bother re-reading the property if it's actually changed since last time.
250     uint32_t property_serial = __system_property_serial(prop_info_);
251     if (property_serial != cached_property_serial_) {
252       __system_property_read_callback(
253           prop_info_,
254           [](void* data, const char*, const char* value, uint32_t serial) {
255             CachedProperty* instance = reinterpret_cast<CachedProperty*>(data);
256             instance->cached_property_serial_ = serial;
257             // Read only properties can be larger than PROP_VALUE_MAX, but also never change value
258             // or location, thus we return the pointer from the shared memory directly.
259             if (instance->is_read_only_) {
260               instance->read_only_property_ = value;
261             } else {
262               strlcpy(instance->cached_value_, value, PROP_VALUE_MAX);
263             }
264           },
265           this);
266     }
267   }
268 
269   if (changed) {
270     *changed = cached_property_serial_ != initial_property_serial_;
271   }
272 
273   if (is_read_only_) {
274     return read_only_property_;
275   } else {
276     return cached_value_;
277   }
278 }
279 
280 #endif
281 
282 }  // namespace base
283 }  // namespace android
284