blob: b34d45d70f4297c75cd835c10bce1ab389ada3f1 [file] [log] [blame]
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001/*
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
Tom Cherry3f5eaae52017-04-06 16:30:22 -070017#include "util.h"
18
Mark Salyzyn62767fe2016-10-27 07:45:34 -070019#include <ctype.h>
20#include <errno.h>
21#include <fcntl.h>
Mark Salyzyn62767fe2016-10-27 07:45:34 -070022#include <pwd.h>
Elliott Hughes636ebc92019-10-07 18:16:23 -070023#include <signal.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080024#include <stdarg.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080025#include <stdio.h>
Tom Cherry3f5eaae52017-04-06 16:30:22 -070026#include <stdlib.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080027#include <string.h>
Tom Cherry3f5eaae52017-04-06 16:30:22 -070028#include <sys/socket.h>
29#include <sys/un.h>
Colin Cross504bc512010-04-13 19:35:09 -070030#include <time.h>
Mark Salyzyn62767fe2016-10-27 07:45:34 -070031#include <unistd.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080032
Deyao Ren238e9092022-07-21 23:05:13 +000033#include <map>
Elliott Hughes290a2282016-11-14 17:08:47 -080034#include <thread>
35
Elliott Hughes4f713192015-12-04 22:00:26 -080036#include <android-base/file.h>
Elliott Hughesf86b5a62016-06-24 15:12:21 -070037#include <android-base/logging.h>
Elliott Hughesdc803122018-05-24 18:00:39 -070038#include <android-base/properties.h>
Tom Cherry2e4c85f2019-07-09 13:33:36 -070039#include <android-base/scopeguard.h>
Elliott Hughes4f713192015-12-04 22:00:26 -080040#include <android-base/strings.h>
Mark Salyzyndb691072016-11-07 10:16:53 -080041#include <android-base/unique_fd.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080042#include <cutils/sockets.h>
Tom Cherry3f5eaae52017-04-06 16:30:22 -070043#include <selinux/android.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080044
Yi-Yo Chiangb8c23252023-07-25 22:08:55 +080045#if defined(__ANDROID__)
46#include <fs_mgr.h>
47#endif
48
Tom Cherrya2f91362020-02-20 10:50:00 -080049#ifdef INIT_FULL_SOURCES
Tom Cherryc5cf85d2019-07-31 13:59:15 -070050#include <android/api-level.h>
Tom Cherry4772f1d2019-07-30 09:34:41 -070051#include <sys/system_properties.h>
Tom Cherryc5cf85d2019-07-31 13:59:15 -070052
Tom Cherry59656fb2019-05-28 10:19:44 -070053#include "reboot_utils.h"
Vic Yang92c236e2019-05-28 15:58:35 -070054#include "selabel.h"
Tom Cherryc5cf85d2019-07-31 13:59:15 -070055#include "selinux.h"
Tom Cherryde6bd502018-02-13 16:50:08 -080056#else
57#include "host_init_stubs.h"
58#endif
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080059
James Hawkinse78ea772017-03-24 11:43:02 -070060using android::base::boot_clock;
Tom Cherry4772f1d2019-07-30 09:34:41 -070061using android::base::StartsWith;
Tom Cherry517e1f12017-05-04 17:40:33 -070062using namespace std::literals::string_literals;
James Hawkinse78ea772017-03-24 11:43:02 -070063
Tom Cherry81f5d3e2017-06-22 12:53:17 -070064namespace android {
65namespace init {
66
Eric Biggers48c05a62022-05-13 19:40:09 +000067const std::string kDataDirPrefix("/data/");
68
Tom Cherry18278d22019-11-12 16:21:20 -080069void (*trigger_shutdown)(const std::string& command) = nullptr;
70
Tom Cherry517e1f12017-05-04 17:40:33 -070071// DecodeUid() - decodes and returns the given string, which can be either the
Tom Cherry11a3aee2017-08-03 12:54:07 -070072// numeric or name representation, into the integer uid or gid.
73Result<uid_t> DecodeUid(const std::string& name) {
Tom Cherry517e1f12017-05-04 17:40:33 -070074 if (isalpha(name[0])) {
75 passwd* pwd = getpwnam(name.c_str());
Tom Cherry11a3aee2017-08-03 12:54:07 -070076 if (!pwd) return ErrnoError() << "getpwnam failed";
77
78 return pwd->pw_uid;
William Roberts3792e6c2016-04-06 19:18:50 -070079 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080080
81 errno = 0;
Tom Cherry517e1f12017-05-04 17:40:33 -070082 uid_t result = static_cast<uid_t>(strtoul(name.c_str(), 0, 0));
Tom Cherry11a3aee2017-08-03 12:54:07 -070083 if (errno) return ErrnoError() << "strtoul failed";
84
85 return result;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080086}
87
88/*
Mark Salyzynb066fcc2017-05-05 14:44:35 -070089 * CreateSocket - creates a Unix domain socket in ANDROID_SOCKET_DIR
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080090 * ("/dev/socket") as dictated in init.rc. This socket is inherited by the
91 * daemon. We communicate the file descriptor's value via the environment
92 * variable ANDROID_SOCKET_ENV_PREFIX<name> ("ANDROID_SOCKET_foo").
93 */
Adam Langleyecc14a52022-05-11 22:32:47 +000094Result<int> CreateSocket(const std::string& name, int type, bool passcred, bool should_listen,
95 mode_t perm, uid_t uid, gid_t gid, const std::string& socketcon) {
Tom Cherry2e4c85f2019-07-09 13:33:36 -070096 if (!socketcon.empty()) {
97 if (setsockcreatecon(socketcon.c_str()) == -1) {
98 return ErrnoError() << "setsockcreatecon(\"" << socketcon << "\") failed";
Nick Kralevich83ccb1c2015-11-23 16:26:42 -080099 }
100 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800101
Mark Salyzyndb691072016-11-07 10:16:53 -0800102 android::base::unique_fd fd(socket(PF_UNIX, type, 0));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800103 if (fd < 0) {
Tom Cherry2e4c85f2019-07-09 13:33:36 -0700104 return ErrnoError() << "Failed to open socket '" << name << "'";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800105 }
106
Tom Cherry2e4c85f2019-07-09 13:33:36 -0700107 if (!socketcon.empty()) setsockcreatecon(nullptr);
Stephen Smalley8348d272013-05-13 12:37:04 -0400108
Mark Salyzyndb691072016-11-07 10:16:53 -0800109 struct sockaddr_un addr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800110 memset(&addr, 0 , sizeof(addr));
111 addr.sun_family = AF_UNIX;
Tom Cherry2e4c85f2019-07-09 13:33:36 -0700112 snprintf(addr.sun_path, sizeof(addr.sun_path), ANDROID_SOCKET_DIR "/%s", name.c_str());
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800113
Mark Salyzyndb691072016-11-07 10:16:53 -0800114 if ((unlink(addr.sun_path) != 0) && (errno != ENOENT)) {
Tom Cherry2e4c85f2019-07-09 13:33:36 -0700115 return ErrnoError() << "Failed to unlink old socket '" << name << "'";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800116 }
117
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700118 std::string secontext;
119 if (SelabelLookupFileContext(addr.sun_path, S_IFSOCK, &secontext) && !secontext.empty()) {
120 setfscreatecon(secontext.c_str());
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500121 }
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500122
Mark Salyzynb066fcc2017-05-05 14:44:35 -0700123 if (passcred) {
124 int on = 1;
Bart Van Asscheaee2ec82022-12-02 18:48:15 -0800125 if (setsockopt(fd.get(), SOL_SOCKET, SO_PASSCRED, &on, sizeof(on))) {
Tom Cherry2e4c85f2019-07-09 13:33:36 -0700126 return ErrnoError() << "Failed to set SO_PASSCRED '" << name << "'";
Mark Salyzynb066fcc2017-05-05 14:44:35 -0700127 }
128 }
129
Bart Van Asscheaee2ec82022-12-02 18:48:15 -0800130 int ret = bind(fd.get(), (struct sockaddr*)&addr, sizeof(addr));
Mark Salyzyndb691072016-11-07 10:16:53 -0800131 int savederrno = errno;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800132
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700133 if (!secontext.empty()) {
134 setfscreatecon(nullptr);
135 }
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500136
Tom Cherry2e4c85f2019-07-09 13:33:36 -0700137 auto guard = android::base::make_scope_guard([&addr] { unlink(addr.sun_path); });
138
Nick Kralevich9bcfd642016-02-24 15:50:52 -0800139 if (ret) {
Mark Salyzyndb691072016-11-07 10:16:53 -0800140 errno = savederrno;
Tom Cherry2e4c85f2019-07-09 13:33:36 -0700141 return ErrnoError() << "Failed to bind socket '" << name << "'";
Nick Kralevich9bcfd642016-02-24 15:50:52 -0800142 }
143
Mark Salyzyndb691072016-11-07 10:16:53 -0800144 if (lchown(addr.sun_path, uid, gid)) {
Tom Cherry2e4c85f2019-07-09 13:33:36 -0700145 return ErrnoError() << "Failed to lchown socket '" << addr.sun_path << "'";
Nick Kralevich9bcfd642016-02-24 15:50:52 -0800146 }
Mark Salyzyndb691072016-11-07 10:16:53 -0800147 if (fchmodat(AT_FDCWD, addr.sun_path, perm, AT_SYMLINK_NOFOLLOW)) {
Tom Cherry2e4c85f2019-07-09 13:33:36 -0700148 return ErrnoError() << "Failed to fchmodat socket '" << addr.sun_path << "'";
Nick Kralevich9bcfd642016-02-24 15:50:52 -0800149 }
Bart Van Asscheaee2ec82022-12-02 18:48:15 -0800150 if (should_listen && listen(fd.get(), /* use OS maximum */ 1 << 30)) {
Adam Langleyecc14a52022-05-11 22:32:47 +0000151 return ErrnoError() << "Failed to listen on socket '" << addr.sun_path << "'";
152 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800153
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700154 LOG(INFO) << "Created socket '" << addr.sun_path << "'"
155 << ", mode " << std::oct << perm << std::dec
156 << ", user " << uid
157 << ", group " << gid;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800158
Tom Cherry2e4c85f2019-07-09 13:33:36 -0700159 guard.Disable();
Mark Salyzyndb691072016-11-07 10:16:53 -0800160 return fd.release();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800161}
162
Tom Cherry11a3aee2017-08-03 12:54:07 -0700163Result<std::string> ReadFile(const std::string& path) {
Tom Cherry53089aa2017-03-31 15:47:33 -0700164 android::base::unique_fd fd(
165 TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_NOFOLLOW | O_CLOEXEC)));
Elliott Hughesf682b472015-02-06 12:19:48 -0800166 if (fd == -1) {
Tom Cherry11a3aee2017-08-03 12:54:07 -0700167 return ErrnoError() << "open() failed";
Elliott Hughesf682b472015-02-06 12:19:48 -0800168 }
169
170 // For security reasons, disallow world-writable
171 // or group-writable files.
Nick Kralevich38f368c2012-01-18 10:39:01 -0800172 struct stat sb;
Bart Van Asscheaee2ec82022-12-02 18:48:15 -0800173 if (fstat(fd.get(), &sb) == -1) {
Tom Cherry11a3aee2017-08-03 12:54:07 -0700174 return ErrnoError() << "fstat failed()";
Nick Kralevich38f368c2012-01-18 10:39:01 -0800175 }
176 if ((sb.st_mode & (S_IWGRP | S_IWOTH)) != 0) {
Tom Cherry11a3aee2017-08-03 12:54:07 -0700177 return Error() << "Skipping insecure file";
Nick Kralevich38f368c2012-01-18 10:39:01 -0800178 }
179
Tom Cherry11a3aee2017-08-03 12:54:07 -0700180 std::string content;
181 if (!android::base::ReadFdToString(fd, &content)) {
182 return ErrnoError() << "Unable to read file contents";
Tom Cherry2cbbe9f2017-05-04 18:17:33 -0700183 }
Tom Cherry11a3aee2017-08-03 12:54:07 -0700184 return content;
Elliott Hughesf682b472015-02-06 12:19:48 -0800185}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800186
Joel Galenson4b591f12017-11-27 14:45:26 -0800187static int OpenFile(const std::string& path, int flags, mode_t mode) {
188 std::string secontext;
189 if (SelabelLookupFileContext(path, mode, &secontext) && !secontext.empty()) {
190 setfscreatecon(secontext.c_str());
191 }
192
193 int rc = open(path.c_str(), flags, mode);
194
195 if (!secontext.empty()) {
196 int save_errno = errno;
197 setfscreatecon(nullptr);
198 errno = save_errno;
199 }
200
201 return rc;
202}
203
Tom Cherrybbcbc2f2019-06-10 11:08:01 -0700204Result<void> WriteFile(const std::string& path, const std::string& content) {
Yongqin Liudbe88e72016-12-28 16:06:19 +0800205 android::base::unique_fd fd(TEMP_FAILURE_RETRY(
Joel Galenson4b591f12017-11-27 14:45:26 -0800206 OpenFile(path, O_WRONLY | O_CREAT | O_NOFOLLOW | O_TRUNC | O_CLOEXEC, 0600)));
Elliott Hughesf682b472015-02-06 12:19:48 -0800207 if (fd == -1) {
Tom Cherry11a3aee2017-08-03 12:54:07 -0700208 return ErrnoError() << "open() failed";
Elliott Hughesf682b472015-02-06 12:19:48 -0800209 }
Tom Cherry2cbbe9f2017-05-04 18:17:33 -0700210 if (!android::base::WriteStringToFd(content, fd)) {
Tom Cherry11a3aee2017-08-03 12:54:07 -0700211 return ErrnoError() << "Unable to write file contents";
Nick Kralevicheedbe812015-04-25 14:10:03 -0700212 }
Tom Cherrybbcbc2f2019-06-10 11:08:01 -0700213 return {};
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800214}
215
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700216bool mkdir_recursive(const std::string& path, mode_t mode) {
Tom Cherry060b74b2017-04-12 14:27:51 -0700217 std::string::size_type slash = 0;
218 while ((slash = path.find('/', slash + 1)) != std::string::npos) {
219 auto directory = path.substr(0, slash);
220 struct stat info;
221 if (stat(directory.c_str(), &info) != 0) {
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700222 auto ret = make_dir(directory, mode);
223 if (!ret && errno != EEXIST) return false;
Colin Crossb0ab94b2010-04-08 16:16:20 -0700224 }
225 }
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700226 auto ret = make_dir(path, mode);
227 if (!ret && errno != EEXIST) return false;
228 return true;
Colin Crossb0ab94b2010-04-08 16:16:20 -0700229}
230
Elliott Hughes9605a942016-11-10 17:43:47 -0800231int wait_for_file(const char* filename, std::chrono::nanoseconds timeout) {
Wei Wang4cea1212017-08-22 12:07:37 -0700232 android::base::Timer t;
233 while (t.duration() < timeout) {
Elliott Hughes9605a942016-11-10 17:43:47 -0800234 struct stat sb;
Wei Wang4cea1212017-08-22 12:07:37 -0700235 if (stat(filename, &sb) != -1) {
236 LOG(INFO) << "wait for '" << filename << "' took " << t;
237 return 0;
238 }
Elliott Hughes290a2282016-11-14 17:08:47 -0800239 std::this_thread::sleep_for(10ms);
Elliott Hughes9605a942016-11-10 17:43:47 -0800240 }
Wei Wang4cea1212017-08-22 12:07:37 -0700241 LOG(WARNING) << "wait for '" << filename << "' timed out and took " << t;
Elliott Hughes9605a942016-11-10 17:43:47 -0800242 return -1;
Colin Crosscd0f1732010-04-19 17:10:24 -0700243}
Colin Crossf83d0b92010-04-21 12:04:20 -0700244
Tom Cherryc88d8f92019-08-19 15:21:25 -0700245void ImportKernelCmdline(const std::function<void(const std::string&, const std::string&)>& fn) {
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700246 std::string cmdline;
247 android::base::ReadFileToString("/proc/cmdline", &cmdline);
Vladimir Chtchetkine2b995432011-09-28 09:55:31 -0700248
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700249 for (const auto& entry : android::base::Split(android::base::Trim(cmdline), " ")) {
250 std::vector<std::string> pieces = android::base::Split(entry, "=");
251 if (pieces.size() == 2) {
Tom Cherryc88d8f92019-08-19 15:21:25 -0700252 fn(pieces[0], pieces[1]);
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700253 }
Vladimir Chtchetkine2b995432011-09-28 09:55:31 -0700254 }
255}
Stephen Smalleye096e362012-06-11 13:37:39 -0400256
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700257bool make_dir(const std::string& path, mode_t mode) {
258 std::string secontext;
259 if (SelabelLookupFileContext(path, mode, &secontext) && !secontext.empty()) {
260 setfscreatecon(secontext.c_str());
Stephen Smalleye096e362012-06-11 13:37:39 -0400261 }
Stephen Smalleye096e362012-06-11 13:37:39 -0400262
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700263 int rc = mkdir(path.c_str(), mode);
Stephen Smalleye096e362012-06-11 13:37:39 -0400264
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700265 if (!secontext.empty()) {
Stephen Smalleye096e362012-06-11 13:37:39 -0400266 int save_errno = errno;
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700267 setfscreatecon(nullptr);
Stephen Smalleye096e362012-06-11 13:37:39 -0400268 errno = save_errno;
269 }
Kenny Rootb5982bf2012-10-16 23:07:05 -0700270
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700271 return rc == 0;
Stephen Smalleye096e362012-06-11 13:37:39 -0400272}
273
Andres Moralesdb5f5d42015-05-08 08:30:33 -0700274/*
Lee Campbellf13b1b32015-07-24 16:57:14 -0700275 * Returns true is pathname is a directory
276 */
277bool is_dir(const char* pathname) {
278 struct stat info;
279 if (stat(pathname, &info) == -1) {
280 return false;
281 }
282 return S_ISDIR(info.st_mode);
283}
Tom Cherryb7349902015-08-26 11:43:36 -0700284
Tom Cherryc5cf85d2019-07-31 13:59:15 -0700285Result<std::string> ExpandProps(const std::string& src) {
Tom Cherryb7349902015-08-26 11:43:36 -0700286 const char* src_ptr = src.c_str();
287
Tom Cherryc5cf85d2019-07-31 13:59:15 -0700288 std::string dst;
Tom Cherryb7349902015-08-26 11:43:36 -0700289
290 /* - variables can either be $x.y or ${x.y}, in case they are only part
291 * of the string.
292 * - will accept $$ as a literal $.
293 * - no nested property expansion, i.e. ${foo.${bar}} is not supported,
294 * bad things will happen
Mark Salyzyn4b561622016-06-07 08:49:01 -0700295 * - ${x.y:-default} will return default value if property empty.
Tom Cherryb7349902015-08-26 11:43:36 -0700296 */
297 while (*src_ptr) {
298 const char* c;
299
300 c = strchr(src_ptr, '$');
301 if (!c) {
Tom Cherryc5cf85d2019-07-31 13:59:15 -0700302 dst.append(src_ptr);
303 return dst;
Tom Cherryb7349902015-08-26 11:43:36 -0700304 }
305
Tom Cherryc5cf85d2019-07-31 13:59:15 -0700306 dst.append(src_ptr, c);
Tom Cherryb7349902015-08-26 11:43:36 -0700307 c++;
308
309 if (*c == '$') {
Tom Cherryc5cf85d2019-07-31 13:59:15 -0700310 dst.push_back(*(c++));
Tom Cherryb7349902015-08-26 11:43:36 -0700311 src_ptr = c;
312 continue;
313 } else if (*c == '\0') {
Tom Cherryc5cf85d2019-07-31 13:59:15 -0700314 return dst;
Tom Cherryb7349902015-08-26 11:43:36 -0700315 }
316
317 std::string prop_name;
Mark Salyzyn4b561622016-06-07 08:49:01 -0700318 std::string def_val;
Tom Cherryb7349902015-08-26 11:43:36 -0700319 if (*c == '{') {
320 c++;
321 const char* end = strchr(c, '}');
322 if (!end) {
323 // failed to find closing brace, abort.
Tom Cherryc5cf85d2019-07-31 13:59:15 -0700324 return Error() << "unexpected end of string in '" << src << "', looking for }";
Tom Cherryb7349902015-08-26 11:43:36 -0700325 }
326 prop_name = std::string(c, end);
327 c = end + 1;
Mark Salyzyn4b561622016-06-07 08:49:01 -0700328 size_t def = prop_name.find(":-");
329 if (def < prop_name.size()) {
330 def_val = prop_name.substr(def + 2);
331 prop_name = prop_name.substr(0, def);
332 }
Tom Cherryb7349902015-08-26 11:43:36 -0700333 } else {
334 prop_name = c;
Tom Cherryc5cf85d2019-07-31 13:59:15 -0700335 if (SelinuxGetVendorAndroidVersion() >= __ANDROID_API_R__) {
336 return Error() << "using deprecated syntax for specifying property '" << c
337 << "', use ${name} instead";
338 } else {
339 LOG(ERROR) << "using deprecated syntax for specifying property '" << c
340 << "', use ${name} instead";
341 }
Tom Cherryb7349902015-08-26 11:43:36 -0700342 c += prop_name.size();
343 }
344
345 if (prop_name.empty()) {
Tom Cherryc5cf85d2019-07-31 13:59:15 -0700346 return Error() << "invalid zero-length property name in '" << src << "'";
Tom Cherryb7349902015-08-26 11:43:36 -0700347 }
348
Tom Cherryccf23532017-03-28 16:40:41 -0700349 std::string prop_val = android::base::GetProperty(prop_name, "");
Tom Cherryb7349902015-08-26 11:43:36 -0700350 if (prop_val.empty()) {
Mark Salyzyn4b561622016-06-07 08:49:01 -0700351 if (def_val.empty()) {
Tom Cherryc5cf85d2019-07-31 13:59:15 -0700352 return Error() << "property '" << prop_name << "' doesn't exist while expanding '"
353 << src << "'";
Mark Salyzyn4b561622016-06-07 08:49:01 -0700354 }
355 prop_val = def_val;
Tom Cherryb7349902015-08-26 11:43:36 -0700356 }
357
Tom Cherryc5cf85d2019-07-31 13:59:15 -0700358 dst.append(prop_val);
Tom Cherryb7349902015-08-26 11:43:36 -0700359 src_ptr = c;
360 }
361
Tom Cherryc5cf85d2019-07-31 13:59:15 -0700362 return dst;
Tom Cherryb7349902015-08-26 11:43:36 -0700363}
Elliott Hughes331cf2f2016-11-29 19:20:58 +0000364
Yu Ningc01022a2017-07-26 17:54:08 +0800365// Reads the content of device tree file under the platform's Android DT directory.
Bowgo Tsaid2620172017-04-17 22:17:09 +0800366// Returns true if the read is success, false otherwise.
367bool read_android_dt_file(const std::string& sub_path, std::string* dt_content) {
Yi-Yo Chiangb8c23252023-07-25 22:08:55 +0800368#if defined(__ANDROID__)
369 const std::string file_name = android::fs_mgr::GetAndroidDtDir() + sub_path;
Bowgo Tsaid2620172017-04-17 22:17:09 +0800370 if (android::base::ReadFileToString(file_name, dt_content)) {
371 if (!dt_content->empty()) {
372 dt_content->pop_back(); // Trims the trailing '\0' out.
373 return true;
374 }
375 }
Yi-Yo Chiangb8c23252023-07-25 22:08:55 +0800376#endif
Bowgo Tsaid2620172017-04-17 22:17:09 +0800377 return false;
378}
379
380bool is_android_dt_value_expected(const std::string& sub_path, const std::string& expected_content) {
381 std::string dt_content;
382 if (read_android_dt_file(sub_path, &dt_content)) {
383 if (dt_content == expected_content) {
384 return true;
385 }
386 }
387 return false;
388}
Tom Cherry81f5d3e2017-06-22 12:53:17 -0700389
Tom Cherryde6bd502018-02-13 16:50:08 -0800390bool IsLegalPropertyName(const std::string& name) {
391 size_t namelen = name.size();
392
393 if (namelen < 1) return false;
394 if (name[0] == '.') return false;
395 if (name[namelen - 1] == '.') return false;
396
397 /* Only allow alphanumeric, plus '.', '-', '@', ':', or '_' */
398 /* Don't allow ".." to appear in a property name */
399 for (size_t i = 0; i < namelen; i++) {
400 if (name[i] == '.') {
401 // i=0 is guaranteed to never have a dot. See above.
402 if (name[i - 1] == '.') return false;
403 continue;
404 }
405 if (name[i] == '_' || name[i] == '-' || name[i] == '@' || name[i] == ':') continue;
406 if (name[i] >= 'a' && name[i] <= 'z') continue;
407 if (name[i] >= 'A' && name[i] <= 'Z') continue;
408 if (name[i] >= '0' && name[i] <= '9') continue;
409 return false;
410 }
411
412 return true;
413}
414
Tom Cherry4772f1d2019-07-30 09:34:41 -0700415Result<void> IsLegalPropertyValue(const std::string& name, const std::string& value) {
416 if (value.size() >= PROP_VALUE_MAX && !StartsWith(name, "ro.")) {
417 return Error() << "Property value too long";
418 }
419
420 if (mbstowcs(nullptr, value.data(), 0) == static_cast<std::size_t>(-1)) {
421 return Error() << "Value is not a UTF8 encoded string";
422 }
423
424 return {};
425}
426
Eric Biggers6cb5a362022-05-13 19:11:42 +0000427// Remove unnecessary slashes so that any later checks (e.g., the check for
428// whether the path is a top-level directory in /data) don't get confused.
429std::string CleanDirPath(const std::string& path) {
430 std::string result;
431 result.reserve(path.length());
432 // Collapse duplicate slashes, e.g. //data//foo// => /data/foo/
433 for (char c : path) {
434 if (c != '/' || result.empty() || result.back() != '/') {
435 result += c;
436 }
437 }
438 // Remove trailing slash, e.g. /data/foo/ => /data/foo
439 if (result.length() > 1 && result.back() == '/') {
440 result.pop_back();
441 }
442 return result;
443}
444
Paul Crowley68258e82019-10-28 07:55:03 -0700445Result<MkdirOptions> ParseMkdir(const std::vector<std::string>& args) {
Eric Biggers6cb5a362022-05-13 19:11:42 +0000446 std::string path = CleanDirPath(args[1]);
Eric Biggers48c05a62022-05-13 19:40:09 +0000447 const bool is_toplevel_data_dir =
448 StartsWith(path, kDataDirPrefix) &&
449 path.find_first_of('/', kDataDirPrefix.size()) == std::string::npos;
450 FscryptAction fscrypt_action =
451 is_toplevel_data_dir ? FscryptAction::kRequire : FscryptAction::kNone;
Paul Crowley68258e82019-10-28 07:55:03 -0700452 mode_t mode = 0755;
453 Result<uid_t> uid = -1;
454 Result<gid_t> gid = -1;
Paul Crowley68258e82019-10-28 07:55:03 -0700455 std::string ref_option = "ref";
456 bool set_option_encryption = false;
457 bool set_option_key = false;
458
459 for (size_t i = 2; i < args.size(); i++) {
460 switch (i) {
461 case 2:
462 mode = std::strtoul(args[2].c_str(), 0, 8);
463 break;
464 case 3:
465 uid = DecodeUid(args[3]);
Bernie Innocenticecebbb2020-02-06 03:49:33 +0900466 if (!uid.ok()) {
Paul Crowley68258e82019-10-28 07:55:03 -0700467 return Error()
468 << "Unable to decode UID for '" << args[3] << "': " << uid.error();
469 }
470 break;
471 case 4:
472 gid = DecodeUid(args[4]);
Bernie Innocenticecebbb2020-02-06 03:49:33 +0900473 if (!gid.ok()) {
Paul Crowley68258e82019-10-28 07:55:03 -0700474 return Error()
475 << "Unable to decode GID for '" << args[4] << "': " << gid.error();
476 }
477 break;
478 default:
479 auto parts = android::base::Split(args[i], "=");
480 if (parts.size() != 2) {
481 return Error() << "Can't parse option: '" << args[i] << "'";
482 }
483 auto optname = parts[0];
484 auto optval = parts[1];
485 if (optname == "encryption") {
486 if (set_option_encryption) {
487 return Error() << "Duplicated option: '" << optname << "'";
488 }
489 if (optval == "Require") {
490 fscrypt_action = FscryptAction::kRequire;
491 } else if (optval == "None") {
492 fscrypt_action = FscryptAction::kNone;
493 } else if (optval == "Attempt") {
494 fscrypt_action = FscryptAction::kAttempt;
495 } else if (optval == "DeleteIfNecessary") {
496 fscrypt_action = FscryptAction::kDeleteIfNecessary;
497 } else {
498 return Error() << "Unknown encryption option: '" << optval << "'";
499 }
500 set_option_encryption = true;
501 } else if (optname == "key") {
502 if (set_option_key) {
503 return Error() << "Duplicated option: '" << optname << "'";
504 }
505 if (optval == "ref" || optval == "per_boot_ref") {
506 ref_option = optval;
507 } else {
508 return Error() << "Unknown key option: '" << optval << "'";
509 }
510 set_option_key = true;
511 } else {
512 return Error() << "Unknown option: '" << args[i] << "'";
513 }
514 }
515 }
516 if (set_option_key && fscrypt_action == FscryptAction::kNone) {
517 return Error() << "Key option set but encryption action is none";
518 }
Eric Biggers48c05a62022-05-13 19:40:09 +0000519 if (is_toplevel_data_dir) {
Paul Crowley68258e82019-10-28 07:55:03 -0700520 if (!set_option_encryption) {
Eric Biggers6cb5a362022-05-13 19:11:42 +0000521 LOG(WARNING) << "Top-level directory needs encryption action, eg mkdir " << path
Paul Crowley68258e82019-10-28 07:55:03 -0700522 << " <mode> <uid> <gid> encryption=Require";
523 }
524 if (fscrypt_action == FscryptAction::kNone) {
Eric Biggers6cb5a362022-05-13 19:11:42 +0000525 LOG(INFO) << "Not setting encryption policy on: " << path;
Paul Crowley68258e82019-10-28 07:55:03 -0700526 }
527 }
Paul Crowley68258e82019-10-28 07:55:03 -0700528
Eric Biggers6cb5a362022-05-13 19:11:42 +0000529 return MkdirOptions{path, mode, *uid, *gid, fscrypt_action, ref_option};
Paul Crowley68258e82019-10-28 07:55:03 -0700530}
531
Alistair Delvaa2cc1eb2020-05-20 16:24:00 -0700532Result<MountAllOptions> ParseMountAll(const std::vector<std::string>& args) {
533 bool compat_mode = false;
534 bool import_rc = false;
535 if (SelinuxGetVendorAndroidVersion() <= __ANDROID_API_Q__) {
536 if (args.size() <= 1) {
537 return Error() << "mount_all requires at least 1 argument";
538 }
539 compat_mode = true;
540 import_rc = true;
541 }
542
543 std::size_t first_option_arg = args.size();
544 enum mount_mode mode = MOUNT_MODE_DEFAULT;
545
546 // If we are <= Q, then stop looking for non-fstab arguments at slot 2.
547 // Otherwise, stop looking at slot 1 (as the fstab path argument is optional >= R).
548 for (std::size_t na = args.size() - 1; na > (compat_mode ? 1 : 0); --na) {
549 if (args[na] == "--early") {
550 first_option_arg = na;
551 mode = MOUNT_MODE_EARLY;
552 } else if (args[na] == "--late") {
553 first_option_arg = na;
554 mode = MOUNT_MODE_LATE;
555 import_rc = false;
556 }
557 }
558
559 std::string fstab_path;
560 if (first_option_arg > 1) {
561 fstab_path = args[1];
562 } else if (compat_mode) {
563 return Error() << "mount_all argument 1 must be the fstab path";
564 }
565
566 std::vector<std::string> rc_paths;
567 for (std::size_t na = 2; na < first_option_arg; ++na) {
568 rc_paths.push_back(args[na]);
569 }
570
571 return MountAllOptions{rc_paths, fstab_path, mode, import_rc};
572}
573
Tom Cherry4772f1d2019-07-30 09:34:41 -0700574Result<std::pair<int, std::vector<std::string>>> ParseRestorecon(
575 const std::vector<std::string>& args) {
576 struct flag_type {
577 const char* name;
578 int value;
579 };
580 static const flag_type flags[] = {
581 {"--recursive", SELINUX_ANDROID_RESTORECON_RECURSE},
582 {"--skip-ce", SELINUX_ANDROID_RESTORECON_SKIPCE},
583 {"--cross-filesystems", SELINUX_ANDROID_RESTORECON_CROSS_FILESYSTEMS},
584 {0, 0}};
585
586 int flag = 0;
587 std::vector<std::string> paths;
588
589 bool in_flags = true;
590 for (size_t i = 1; i < args.size(); ++i) {
591 if (android::base::StartsWith(args[i], "--")) {
592 if (!in_flags) {
593 return Error() << "flags must precede paths";
594 }
595 bool found = false;
596 for (size_t j = 0; flags[j].name; ++j) {
597 if (args[i] == flags[j].name) {
598 flag |= flags[j].value;
599 found = true;
600 break;
601 }
602 }
603 if (!found) {
604 return Error() << "bad flag " << args[i];
605 }
606 } else {
607 in_flags = false;
608 paths.emplace_back(args[i]);
609 }
610 }
611 return std::pair(flag, paths);
612}
613
Alistair Delvade28a862020-06-08 11:04:53 -0700614Result<std::string> ParseSwaponAll(const std::vector<std::string>& args) {
615 if (args.size() <= 1) {
616 if (SelinuxGetVendorAndroidVersion() <= __ANDROID_API_Q__) {
617 return Error() << "swapon_all requires at least 1 argument";
618 }
619 return {};
620 }
621 return args[1];
622}
623
Alistair Delvaa2cc1eb2020-05-20 16:24:00 -0700624Result<std::string> ParseUmountAll(const std::vector<std::string>& args) {
Alistair Delvade28a862020-06-08 11:04:53 -0700625 if (args.size() <= 1) {
626 if (SelinuxGetVendorAndroidVersion() <= __ANDROID_API_Q__) {
Alistair Delvaa2cc1eb2020-05-20 16:24:00 -0700627 return Error() << "umount_all requires at least 1 argument";
628 }
Alistair Delvade28a862020-06-08 11:04:53 -0700629 return {};
Alistair Delvaa2cc1eb2020-05-20 16:24:00 -0700630 }
631 return args[1];
632}
633
Tom Cherry59656fb2019-05-28 10:19:44 -0700634static void InitAborter(const char* abort_message) {
635 // When init forks, it continues to use this aborter for LOG(FATAL), but we want children to
636 // simply abort instead of trying to reboot the system.
637 if (getpid() != 1) {
638 android::base::DefaultAborter(abort_message);
639 return;
640 }
641
Elliott Hughes636ebc92019-10-07 18:16:23 -0700642 InitFatalReboot(SIGABRT);
Tom Cherry59656fb2019-05-28 10:19:44 -0700643}
644
645// The kernel opens /dev/console and uses that fd for stdin/stdout/stderr if there is a serial
646// console enabled and no initramfs, otherwise it does not provide any fds for stdin/stdout/stderr.
647// SetStdioToDevNull() is used to close these existing fds if they exist and replace them with
648// /dev/null regardless.
649//
650// In the case that these fds are provided by the kernel, the exec of second stage init causes an
651// SELinux denial as it does not have access to /dev/console. In the case that they are not
652// provided, exec of any further process is potentially dangerous as the first fd's opened by that
653// process will take the stdin/stdout/stderr fileno's, which can cause issues if printf(), etc is
654// then used by that process.
655//
656// Lastly, simply calling SetStdioToDevNull() in first stage init is not enough, since first
657// stage init still runs in kernel context, future child processes will not have permissions to
658// access any fds that it opens, including the one opened below for /dev/null. Therefore,
659// SetStdioToDevNull() must be called again in second stage init.
660void SetStdioToDevNull(char** argv) {
Tom Cherry48e83e62018-10-04 13:14:14 -0700661 // Make stdin/stdout/stderr all point to /dev/null.
Tom Cherry247ffbf2019-07-08 15:09:36 -0700662 int fd = open("/dev/null", O_RDWR); // NOLINT(android-cloexec-open)
Tom Cherry48e83e62018-10-04 13:14:14 -0700663 if (fd == -1) {
664 int saved_errno = errno;
Tom Cherry59656fb2019-05-28 10:19:44 -0700665 android::base::InitLogging(argv, &android::base::KernelLogger, InitAborter);
Tom Cherry48e83e62018-10-04 13:14:14 -0700666 errno = saved_errno;
667 PLOG(FATAL) << "Couldn't open /dev/null";
668 }
Tom Cherry59656fb2019-05-28 10:19:44 -0700669 dup2(fd, STDIN_FILENO);
670 dup2(fd, STDOUT_FILENO);
671 dup2(fd, STDERR_FILENO);
672 if (fd > STDERR_FILENO) close(fd);
673}
674
675void InitKernelLogging(char** argv) {
Tom Cherry75e13ba2019-05-21 13:53:05 -0700676 SetFatalRebootTarget();
Tom Cherry59656fb2019-05-28 10:19:44 -0700677 android::base::InitLogging(argv, &android::base::KernelLogger, InitAborter);
Tom Cherry48e83e62018-10-04 13:14:14 -0700678}
679
Jiyong Park68660412019-01-16 23:00:59 +0900680bool IsRecoveryMode() {
681 return access("/system/bin/recovery", F_OK) == 0;
682}
683
Kiyoung Kim0cbee0d2021-03-02 16:45:27 +0900684// Check if default mount namespace is ready to be used with APEX modules
685static bool is_default_mount_namespace_ready = false;
686
687bool IsDefaultMountNamespaceReady() {
688 return is_default_mount_namespace_ready;
689}
690
691void SetDefaultMountNamespaceReady() {
692 is_default_mount_namespace_ready = true;
693}
694
Jiyong Park11d7bc52022-07-15 13:44:14 +0900695bool Has32BitAbi() {
696 static bool has = !android::base::GetProperty("ro.product.cpu.abilist32", "").empty();
697 return has;
698}
699
Deyao Rendf40ed12022-07-14 22:51:10 +0000700std::string GetApexNameFromFileName(const std::string& path) {
701 static const std::string kApexDir = "/apex/";
702 if (StartsWith(path, kApexDir)) {
703 auto begin = kApexDir.size();
704 auto end = path.find('/', begin);
705 return path.substr(begin, end - begin);
706 }
707 return "";
708}
709
Deyao Ren238e9092022-07-21 23:05:13 +0000710std::vector<std::string> FilterVersionedConfigs(const std::vector<std::string>& configs,
711 int active_sdk) {
712 std::vector<std::string> filtered_configs;
713
714 std::map<std::string, std::pair<std::string, int>> script_map;
715 for (const auto& c : configs) {
716 int sdk = 0;
717 const std::vector<std::string> parts = android::base::Split(c, ".");
718 std::string base;
719 if (parts.size() < 2) {
720 continue;
721 }
722
723 // parts[size()-1], aka the suffix, should be "rc" or "#rc"
724 // any other pattern gets discarded
725
726 const auto& suffix = parts[parts.size() - 1];
727 if (suffix == "rc") {
728 sdk = 0;
729 } else {
730 char trailer[9] = {0};
731 int r = sscanf(suffix.c_str(), "%d%8s", &sdk, trailer);
732 if (r != 2) {
733 continue;
734 }
735 if (strlen(trailer) > 2 || strcmp(trailer, "rc") != 0) {
736 continue;
737 }
738 }
739
740 if (sdk < 0 || sdk > active_sdk) {
741 continue;
742 }
743
744 base = parts[0];
745 for (unsigned int i = 1; i < parts.size() - 1; i++) {
746 base = base + "." + parts[i];
747 }
748
749 // is this preferred over what we already have
750 auto it = script_map.find(base);
751 if (it == script_map.end() || it->second.second < sdk) {
752 script_map[base] = std::make_pair(c, sdk);
753 }
754 }
755
756 for (const auto& m : script_map) {
757 filtered_configs.push_back(m.second.first);
758 }
759 return filtered_configs;
760}
761
Tom Cherry81f5d3e2017-06-22 12:53:17 -0700762} // namespace init
763} // namespace android