1 /*
2 * Copyright (C) 2008 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 "util.h"
18
19 #include <ctype.h>
20 #include <errno.h>
21 #include <fcntl.h>
22 #include <pwd.h>
23 #include <stdarg.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <sys/socket.h>
28 #include <sys/un.h>
29 #include <time.h>
30 #include <unistd.h>
31
32 #include <thread>
33
34 #include <android-base/file.h>
35 #include <android-base/logging.h>
36 #include <android-base/properties.h>
37 #include <android-base/stringprintf.h>
38 #include <android-base/strings.h>
39 #include <android-base/unique_fd.h>
40 #include <cutils/android_reboot.h>
41 #include <cutils/sockets.h>
42 #include <selinux/android.h>
43
44 #include "reboot.h"
45
46 #ifdef _INIT_INIT_H
47 #error "Do not include init.h in files used by ueventd or watchdogd; it will expose init's globals"
48 #endif
49
50 using android::base::boot_clock;
51 using namespace std::literals::string_literals;
52
53 namespace android {
54 namespace init {
55
56 const std::string kDefaultAndroidDtDir("/proc/device-tree/firmware/android/");
57
58 // DecodeUid() - decodes and returns the given string, which can be either the
59 // numeric or name representation, into the integer uid or gid. Returns
60 // UINT_MAX on error.
DecodeUid(const std::string & name,uid_t * uid,std::string * err)61 bool DecodeUid(const std::string& name, uid_t* uid, std::string* err) {
62 *uid = UINT_MAX;
63 *err = "";
64
65 if (isalpha(name[0])) {
66 passwd* pwd = getpwnam(name.c_str());
67 if (!pwd) {
68 *err = "getpwnam failed: "s + strerror(errno);
69 return false;
70 }
71 *uid = pwd->pw_uid;
72 return true;
73 }
74
75 errno = 0;
76 uid_t result = static_cast<uid_t>(strtoul(name.c_str(), 0, 0));
77 if (errno) {
78 *err = "strtoul failed: "s + strerror(errno);
79 return false;
80 }
81 *uid = result;
82 return true;
83 }
84
85 /*
86 * CreateSocket - creates a Unix domain socket in ANDROID_SOCKET_DIR
87 * ("/dev/socket") as dictated in init.rc. This socket is inherited by the
88 * daemon. We communicate the file descriptor's value via the environment
89 * variable ANDROID_SOCKET_ENV_PREFIX<name> ("ANDROID_SOCKET_foo").
90 */
CreateSocket(const char * name,int type,bool passcred,mode_t perm,uid_t uid,gid_t gid,const char * socketcon,selabel_handle * sehandle)91 int CreateSocket(const char* name, int type, bool passcred, mode_t perm, uid_t uid, gid_t gid,
92 const char* socketcon, selabel_handle* sehandle) {
93 if (socketcon) {
94 if (setsockcreatecon(socketcon) == -1) {
95 PLOG(ERROR) << "setsockcreatecon(\"" << socketcon << "\") failed";
96 return -1;
97 }
98 }
99
100 android::base::unique_fd fd(socket(PF_UNIX, type, 0));
101 if (fd < 0) {
102 PLOG(ERROR) << "Failed to open socket '" << name << "'";
103 return -1;
104 }
105
106 if (socketcon) setsockcreatecon(NULL);
107
108 struct sockaddr_un addr;
109 memset(&addr, 0 , sizeof(addr));
110 addr.sun_family = AF_UNIX;
111 snprintf(addr.sun_path, sizeof(addr.sun_path), ANDROID_SOCKET_DIR"/%s",
112 name);
113
114 if ((unlink(addr.sun_path) != 0) && (errno != ENOENT)) {
115 PLOG(ERROR) << "Failed to unlink old socket '" << name << "'";
116 return -1;
117 }
118
119 char *filecon = NULL;
120 if (sehandle) {
121 if (selabel_lookup(sehandle, &filecon, addr.sun_path, S_IFSOCK) == 0) {
122 setfscreatecon(filecon);
123 }
124 }
125
126 if (passcred) {
127 int on = 1;
128 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on))) {
129 PLOG(ERROR) << "Failed to set SO_PASSCRED '" << name << "'";
130 return -1;
131 }
132 }
133
134 int ret = bind(fd, (struct sockaddr *) &addr, sizeof (addr));
135 int savederrno = errno;
136
137 setfscreatecon(NULL);
138 freecon(filecon);
139
140 if (ret) {
141 errno = savederrno;
142 PLOG(ERROR) << "Failed to bind socket '" << name << "'";
143 goto out_unlink;
144 }
145
146 if (lchown(addr.sun_path, uid, gid)) {
147 PLOG(ERROR) << "Failed to lchown socket '" << addr.sun_path << "'";
148 goto out_unlink;
149 }
150 if (fchmodat(AT_FDCWD, addr.sun_path, perm, AT_SYMLINK_NOFOLLOW)) {
151 PLOG(ERROR) << "Failed to fchmodat socket '" << addr.sun_path << "'";
152 goto out_unlink;
153 }
154
155 LOG(INFO) << "Created socket '" << addr.sun_path << "'"
156 << ", mode " << std::oct << perm << std::dec
157 << ", user " << uid
158 << ", group " << gid;
159
160 return fd.release();
161
162 out_unlink:
163 unlink(addr.sun_path);
164 return -1;
165 }
166
ReadFile(const std::string & path,std::string * content,std::string * err)167 bool ReadFile(const std::string& path, std::string* content, std::string* err) {
168 content->clear();
169 *err = "";
170
171 android::base::unique_fd fd(
172 TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_NOFOLLOW | O_CLOEXEC)));
173 if (fd == -1) {
174 *err = "Unable to open '" + path + "': " + strerror(errno);
175 return false;
176 }
177
178 // For security reasons, disallow world-writable
179 // or group-writable files.
180 struct stat sb;
181 if (fstat(fd, &sb) == -1) {
182 *err = "fstat failed for '" + path + "': " + strerror(errno);
183 return false;
184 }
185 if ((sb.st_mode & (S_IWGRP | S_IWOTH)) != 0) {
186 *err = "Skipping insecure file '" + path + "'";
187 return false;
188 }
189
190 if (!android::base::ReadFdToString(fd, content)) {
191 *err = "Unable to read '" + path + "': " + strerror(errno);
192 return false;
193 }
194 return true;
195 }
196
WriteFile(const std::string & path,const std::string & content,std::string * err)197 bool WriteFile(const std::string& path, const std::string& content, std::string* err) {
198 *err = "";
199
200 android::base::unique_fd fd(TEMP_FAILURE_RETRY(
201 open(path.c_str(), O_WRONLY | O_CREAT | O_NOFOLLOW | O_TRUNC | O_CLOEXEC, 0600)));
202 if (fd == -1) {
203 *err = "Unable to open '" + path + "': " + strerror(errno);
204 return false;
205 }
206 if (!android::base::WriteStringToFd(content, fd)) {
207 *err = "Unable to write to '" + path + "': " + strerror(errno);
208 return false;
209 }
210 return true;
211 }
212
mkdir_recursive(const std::string & path,mode_t mode,selabel_handle * sehandle)213 int mkdir_recursive(const std::string& path, mode_t mode, selabel_handle* sehandle) {
214 std::string::size_type slash = 0;
215 while ((slash = path.find('/', slash + 1)) != std::string::npos) {
216 auto directory = path.substr(0, slash);
217 struct stat info;
218 if (stat(directory.c_str(), &info) != 0) {
219 auto ret = make_dir(directory.c_str(), mode, sehandle);
220 if (ret && errno != EEXIST) return ret;
221 }
222 }
223 auto ret = make_dir(path.c_str(), mode, sehandle);
224 if (ret && errno != EEXIST) return ret;
225 return 0;
226 }
227
wait_for_file(const char * filename,std::chrono::nanoseconds timeout)228 int wait_for_file(const char* filename, std::chrono::nanoseconds timeout) {
229 boot_clock::time_point timeout_time = boot_clock::now() + timeout;
230 while (boot_clock::now() < timeout_time) {
231 struct stat sb;
232 if (stat(filename, &sb) != -1) return 0;
233
234 std::this_thread::sleep_for(10ms);
235 }
236 return -1;
237 }
238
import_kernel_cmdline(bool in_qemu,const std::function<void (const std::string &,const std::string &,bool)> & fn)239 void import_kernel_cmdline(bool in_qemu,
240 const std::function<void(const std::string&, const std::string&, bool)>& fn) {
241 std::string cmdline;
242 android::base::ReadFileToString("/proc/cmdline", &cmdline);
243
244 for (const auto& entry : android::base::Split(android::base::Trim(cmdline), " ")) {
245 std::vector<std::string> pieces = android::base::Split(entry, "=");
246 if (pieces.size() == 2) {
247 fn(pieces[0], pieces[1], in_qemu);
248 }
249 }
250 }
251
make_dir(const char * path,mode_t mode,selabel_handle * sehandle)252 int make_dir(const char* path, mode_t mode, selabel_handle* sehandle) {
253 int rc;
254
255 char *secontext = NULL;
256
257 if (sehandle) {
258 selabel_lookup(sehandle, &secontext, path, mode);
259 setfscreatecon(secontext);
260 }
261
262 rc = mkdir(path, mode);
263
264 if (secontext) {
265 int save_errno = errno;
266 freecon(secontext);
267 setfscreatecon(NULL);
268 errno = save_errno;
269 }
270
271 return rc;
272 }
273
274 /*
275 * Writes hex_len hex characters (1/2 byte) to hex from bytes.
276 */
bytes_to_hex(const uint8_t * bytes,size_t bytes_len)277 std::string bytes_to_hex(const uint8_t* bytes, size_t bytes_len) {
278 std::string hex("0x");
279 for (size_t i = 0; i < bytes_len; i++)
280 android::base::StringAppendF(&hex, "%02x", bytes[i]);
281 return hex;
282 }
283
284 /*
285 * Returns true is pathname is a directory
286 */
is_dir(const char * pathname)287 bool is_dir(const char* pathname) {
288 struct stat info;
289 if (stat(pathname, &info) == -1) {
290 return false;
291 }
292 return S_ISDIR(info.st_mode);
293 }
294
expand_props(const std::string & src,std::string * dst)295 bool expand_props(const std::string& src, std::string* dst) {
296 const char* src_ptr = src.c_str();
297
298 if (!dst) {
299 return false;
300 }
301
302 /* - variables can either be $x.y or ${x.y}, in case they are only part
303 * of the string.
304 * - will accept $$ as a literal $.
305 * - no nested property expansion, i.e. ${foo.${bar}} is not supported,
306 * bad things will happen
307 * - ${x.y:-default} will return default value if property empty.
308 */
309 while (*src_ptr) {
310 const char* c;
311
312 c = strchr(src_ptr, '$');
313 if (!c) {
314 dst->append(src_ptr);
315 return true;
316 }
317
318 dst->append(src_ptr, c);
319 c++;
320
321 if (*c == '$') {
322 dst->push_back(*(c++));
323 src_ptr = c;
324 continue;
325 } else if (*c == '\0') {
326 return true;
327 }
328
329 std::string prop_name;
330 std::string def_val;
331 if (*c == '{') {
332 c++;
333 const char* end = strchr(c, '}');
334 if (!end) {
335 // failed to find closing brace, abort.
336 LOG(ERROR) << "unexpected end of string in '" << src << "', looking for }";
337 return false;
338 }
339 prop_name = std::string(c, end);
340 c = end + 1;
341 size_t def = prop_name.find(":-");
342 if (def < prop_name.size()) {
343 def_val = prop_name.substr(def + 2);
344 prop_name = prop_name.substr(0, def);
345 }
346 } else {
347 prop_name = c;
348 LOG(ERROR) << "using deprecated syntax for specifying property '" << c << "', use ${name} instead";
349 c += prop_name.size();
350 }
351
352 if (prop_name.empty()) {
353 LOG(ERROR) << "invalid zero-length property name in '" << src << "'";
354 return false;
355 }
356
357 std::string prop_val = android::base::GetProperty(prop_name, "");
358 if (prop_val.empty()) {
359 if (def_val.empty()) {
360 LOG(ERROR) << "property '" << prop_name << "' doesn't exist while expanding '" << src << "'";
361 return false;
362 }
363 prop_val = def_val;
364 }
365
366 dst->append(prop_val);
367 src_ptr = c;
368 }
369
370 return true;
371 }
372
panic()373 void panic() {
374 LOG(ERROR) << "panic: rebooting to bootloader";
375 // Do not queue "shutdown" trigger since we want to shutdown immediately
376 DoReboot(ANDROID_RB_RESTART2, "reboot", "bootloader", false);
377 }
378
init_android_dt_dir()379 static std::string init_android_dt_dir() {
380 // Use the standard procfs-based path by default
381 std::string android_dt_dir = kDefaultAndroidDtDir;
382 // The platform may specify a custom Android DT path in kernel cmdline
383 import_kernel_cmdline(false,
384 [&](const std::string& key, const std::string& value, bool in_qemu) {
385 if (key == "androidboot.android_dt_dir") {
386 android_dt_dir = value;
387 }
388 });
389 LOG(INFO) << "Using Android DT directory " << android_dt_dir;
390 return android_dt_dir;
391 }
392
393 // FIXME: The same logic is duplicated in system/core/fs_mgr/
get_android_dt_dir()394 const std::string& get_android_dt_dir() {
395 // Set once and saves time for subsequent calls to this function
396 static const std::string kAndroidDtDir = init_android_dt_dir();
397 return kAndroidDtDir;
398 }
399
400 // Reads the content of device tree file under the platform's Android DT directory.
401 // Returns true if the read is success, false otherwise.
read_android_dt_file(const std::string & sub_path,std::string * dt_content)402 bool read_android_dt_file(const std::string& sub_path, std::string* dt_content) {
403 const std::string file_name = get_android_dt_dir() + sub_path;
404 if (android::base::ReadFileToString(file_name, dt_content)) {
405 if (!dt_content->empty()) {
406 dt_content->pop_back(); // Trims the trailing '\0' out.
407 return true;
408 }
409 }
410 return false;
411 }
412
is_android_dt_value_expected(const std::string & sub_path,const std::string & expected_content)413 bool is_android_dt_value_expected(const std::string& sub_path, const std::string& expected_content) {
414 std::string dt_content;
415 if (read_android_dt_file(sub_path, &dt_content)) {
416 if (dt_content == expected_content) {
417 return true;
418 }
419 }
420 return false;
421 }
422
423 } // namespace init
424 } // namespace android
425