Debian Codegraph @

.cargo/vendor/android_system_properties/src/lib.rs

raw
1 //! A thin rust wrapper for Android system properties.
2 //!
3 //! This crate is similar to the `android-properties` crate with the exception that
4 //! the necessary Android libc symbols are loaded dynamically instead of linked
5 //! statically. In practice this means that the same binary will work with old and
6 //! new versions of Android, even though the API for reading system properties changed
7 //! around Android L.
8 //!
9 //! ## Example
10 //!
11 //! ```rust
12 //! use android_system_properties::AndroidSystemProperties;
13 //!
14 //! let properties = AndroidSystemProperties::new();
15 //!
16 //! if let Some(value) = properties.get("persist.sys.timezone") {
17 //! println!("{}", value);
18 //! }
19 //! ```
20 //!
21 //! ## Listing and setting properties
22 //!
23 //! For the sake of simplicity this crate currently only contains what's needed by wgpu.
24 //! The implementations for listing and setting properties can be added back if anyone needs
25 //! them (let me know by filing an issue).
26 //!
27 //! ## License
28 //!
29 //! Licensed under either of
30 //!
31 //! * Apache License, Version 2.0 ([LICENSE-APACHE] or <http://www.apache.org/licenses/LICENSE-2.0>)
32 //! * MIT license ([LICENSE-MIT] or <http://opensource.org/licenses/MIT>)
33 //!
34 //! at your option.
35 //!
36 //! [LICENSE-APACHE]: https://github.com/nical/android_system_properties/blob/804681c5c1c93d4fab29c1a2f47b7d808dc70fd3/LICENSE-APACHE
37 //! [LICENSE-MIT]: https://github.com/nical/android_system_properties/blob/804681c5c1c93d4fab29c1a2f47b7d808dc70fd3/LICENSE-MIT
38
39 use std::{
40 ffi::{CStr, CString},
41 os::raw::{c_char, c_int, c_void},
42 };
43
44 #[cfg(target_os = "android")]
45 use std::mem;
46
47 unsafe fn property_callback(payload: *mut String, _name: *const c_char, value: *const c_char, _serial: u32) {
48 let cvalue = CStr::from_ptr(value);
49 (*payload) = cvalue.to_str().unwrap().to_string();
50 }
51
52 type Callback = unsafe fn(*mut String, *const c_char, *const c_char, u32);
53
54 type SystemPropertyGetFn = unsafe extern "C" fn(*const c_char, *mut c_char) -> c_int;
55 type SystemPropertyFindFn = unsafe extern "C" fn(*const c_char) -> *const c_void;
56 type SystemPropertyReadCallbackFn = unsafe extern "C" fn(*const c_void, Callback, *mut String) -> *const c_void;
57
58 #[derive(Debug)]
59 /// An object that can retrieve android system properties.
60 ///
61 /// ## Example
62 ///
63 /// ```
64 /// use android_system_properties::AndroidSystemProperties;
65 ///
66 /// let properties = AndroidSystemProperties::new();
67 ///
68 /// if let Some(value) = properties.get("persist.sys.timezone") {
69 /// println!("{}", value);
70 /// }
71 /// ```
72 pub struct AndroidSystemProperties {
73 libc_so: *mut c_void,
74 get_fn: Option<SystemPropertyGetFn>,
75 find_fn: Option<SystemPropertyFindFn>,
76 read_callback_fn: Option<SystemPropertyReadCallbackFn>,
77 }
78
79 unsafe impl Send for AndroidSystemProperties {}
80 unsafe impl Sync for AndroidSystemProperties {}
81
82 impl AndroidSystemProperties {
83 #[cfg(not(target_os = "android"))]
84 /// Create an entry point for accessing Android properties.
85 pub fn new() -> Self {
86 AndroidSystemProperties {
87 libc_so: std::ptr::null_mut(),
88 find_fn: None,
89 read_callback_fn: None,
90 get_fn: None,
91 }
92 }
93
94 #[cfg(target_os = "android")]
95 /// Create an entry point for accessing Android properties.
96 pub fn new() -> Self {
97 let libc_so = unsafe { libc::dlopen(b"libc.so\0".as_ptr().cast(), libc::RTLD_NOLOAD) };
98
99 let mut properties = AndroidSystemProperties {
100 libc_so,
101 find_fn: None,
102 read_callback_fn: None,
103 get_fn: None,
104 };
105
106 if libc_so.is_null() {
107 return properties;
108 }
109
110
111 unsafe fn load_fn(libc_so: *mut c_void, name: &[u8]) -> Option<*const c_void> {
112 let fn_ptr = libc::dlsym(libc_so, name.as_ptr().cast());
113
114 if fn_ptr.is_null() {
115 return None;
116 }
117
118 Some(fn_ptr)
119 }
120
121 unsafe {
122 properties.read_callback_fn = load_fn(libc_so, b"__system_property_read_callback\0")
123 .map(|raw| mem::transmute::<*const c_void, SystemPropertyReadCallbackFn>(raw));
124
125 properties.find_fn = load_fn(libc_so, b"__system_property_find\0")
126 .map(|raw| mem::transmute::<*const c_void, SystemPropertyFindFn>(raw));
127
128 // Fallback for old versions of Android.
129 if properties.read_callback_fn.is_none() || properties.find_fn.is_none() {
130 properties.get_fn = load_fn(libc_so, b"__system_property_get\0")
131 .map(|raw| mem::transmute::<*const c_void, SystemPropertyGetFn>(raw));
132 }
133 }
134
135 properties
136 }
137
138 /// Retrieve a system property.
139 ///
140 /// Returns None if the operation fails.
141 ///
142 /// # Example
143 ///
144 /// ```
145 /// # use android_system_properties::AndroidSystemProperties;
146 /// let properties = AndroidSystemProperties::new();
147 ///
148 /// if let Some(value) = properties.get("persist.sys.timezone") {
149 /// println!("{}", value);
150 /// }
151 /// ```
152 pub fn get(&self, name: &str) -> Option<String> {
153 let cname = CString::new(name).ok()?;
154 self.get_from_cstr(&cname)
155 }
156
157 /// Retrieve a system property using a [`CStr`] key.
158 ///
159 /// Returns None if the operation fails.
160 ///
161 /// # Example
162 ///
163 /// ```
164 /// # use android_system_properties::AndroidSystemProperties;
165 /// # use std::ffi::CStr;
166 /// let properties = AndroidSystemProperties::new();
167 ///
168 /// let key = unsafe { CStr::from_bytes_with_nul_unchecked(b"persist.sys.timezone\0") };
169 /// if let Some(value) = properties.get_from_cstr(key) {
170 /// println!("{}", value);
171 /// }
172 /// ```
173 pub fn get_from_cstr(&self, cname: &std::ffi::CStr) -> Option<String> {
174 // If available, use the recommended approach to accessing properties (Android L and onward).
175 if let (Some(find_fn), Some(read_callback_fn)) = (self.find_fn, self.read_callback_fn) {
176 let info = unsafe { (find_fn)(cname.as_ptr()) };
177
178 if info.is_null() {
179 return None;
180 }
181
182 let mut result = String::new();
183
184 unsafe {
185 (read_callback_fn)(info, property_callback, &mut result);
186 }
187
188 return Some(result);
189 }
190
191 // Fall back to the older approach.
192 if let Some(get_fn) = self.get_fn {
193 // The constant is PROP_VALUE_MAX in Android's libc/include/sys/system_properties.h
194 const PROPERTY_VALUE_MAX: usize = 92;
195 let mut buffer: Vec<u8> = Vec::with_capacity(PROPERTY_VALUE_MAX);
196 let raw = buffer.as_mut_ptr() as *mut c_char;
197
198 let len = unsafe { (get_fn)(cname.as_ptr(), raw) };
199
200 if len > 0 {
201 assert!(len as usize <= buffer.capacity());
202 unsafe { buffer.set_len(len as usize); }
203 String::from_utf8(buffer).ok()
204 } else {
205 None
206 }
207 } else {
208 None
209 }
210 }
211 }
212
213 impl Drop for AndroidSystemProperties {
214 fn drop(&mut self) {
215 if !self.libc_so.is_null() {
216 unsafe {
217 libc::dlclose(self.libc_so);
218 }
219 }
220 }
221 }