2019-03-05 09:22:20 +01:00
|
|
|
#include <sys/mount.h>
|
|
|
|
#include <sys/wait.h>
|
2020-05-19 13:53:16 +02:00
|
|
|
#include <sys/sysmacros.h>
|
|
|
|
#include <linux/input.h>
|
2020-04-12 14:34:56 +02:00
|
|
|
#include <libgen.h>
|
2019-01-20 05:59:37 +01:00
|
|
|
#include <vector>
|
|
|
|
#include <string>
|
2017-04-30 19:58:52 +02:00
|
|
|
|
2020-03-09 09:50:30 +01:00
|
|
|
#include <magisk.hpp>
|
|
|
|
#include <db.hpp>
|
2022-05-12 11:03:42 +02:00
|
|
|
#include <base.hpp>
|
2020-03-09 09:50:30 +01:00
|
|
|
#include <daemon.hpp>
|
|
|
|
#include <resetprop.hpp>
|
|
|
|
#include <selinux.hpp>
|
2017-04-30 19:58:52 +02:00
|
|
|
|
2021-01-11 11:19:10 +01:00
|
|
|
#include "core.hpp"
|
|
|
|
|
2019-01-20 05:59:37 +01:00
|
|
|
using namespace std;
|
|
|
|
|
2020-05-08 09:45:11 +02:00
|
|
|
static bool safe_mode = false;
|
2021-09-15 11:49:54 +02:00
|
|
|
bool zygisk_enabled = false;
|
2017-04-30 19:58:52 +02:00
|
|
|
|
2020-04-18 11:00:48 +02:00
|
|
|
/*********
|
|
|
|
* Setup *
|
|
|
|
*********/
|
2020-04-12 14:34:56 +02:00
|
|
|
|
2021-08-26 12:09:56 +02:00
|
|
|
#define MNT_DIR_IS(dir) (me->mnt_dir == string_view(dir))
|
2022-02-05 08:19:12 +01:00
|
|
|
#define MNT_TYPE_IS(type) (me->mnt_type == string_view(type))
|
2022-09-09 13:29:50 +02:00
|
|
|
#define SETMIR(b, part) ssprintf(b, sizeof(b), "%s/" MIRRDIR "/" #part, MAGISKTMP.data())
|
|
|
|
#define SETBLK(b, part) ssprintf(b, sizeof(b), "%s/" BLOCKDIR "/" #part, MAGISKTMP.data())
|
2019-04-08 05:03:49 +02:00
|
|
|
|
2022-03-02 05:09:59 +01:00
|
|
|
#define do_mount_mirror(part) { \
|
|
|
|
SETMIR(buf1, part); \
|
|
|
|
SETBLK(buf2, part); \
|
|
|
|
unlink(buf2); \
|
2020-11-03 09:37:08 +01:00
|
|
|
mknod(buf2, S_IFBLK | 0600, st.st_dev); \
|
2022-03-02 05:09:59 +01:00
|
|
|
xmkdir(buf1, 0755); \
|
|
|
|
int flags = 0; \
|
|
|
|
auto opts = split_ro(me->mnt_opts, ",");\
|
|
|
|
for (string_view s : opts) { \
|
|
|
|
if (s == "ro") { \
|
|
|
|
flags |= MS_RDONLY; \
|
|
|
|
break; \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
xmount(buf2, buf1, me->mnt_type, flags, nullptr); \
|
|
|
|
LOGI("mount: %s\n", buf1); \
|
2019-04-08 05:03:49 +02:00
|
|
|
}
|
2019-04-07 20:22:45 +02:00
|
|
|
|
2022-03-02 05:09:59 +01:00
|
|
|
#define mount_mirror(part) \
|
|
|
|
if (MNT_DIR_IS("/" #part) \
|
|
|
|
&& !MNT_TYPE_IS("tmpfs") \
|
|
|
|
&& !MNT_TYPE_IS("overlay") \
|
|
|
|
&& lstat(me->mnt_dir, &st) == 0) { \
|
|
|
|
do_mount_mirror(part); \
|
|
|
|
break; \
|
2022-02-05 08:19:12 +01:00
|
|
|
}
|
2020-11-03 09:37:08 +01:00
|
|
|
|
2020-04-21 08:57:29 +02:00
|
|
|
#define link_mirror(part) \
|
|
|
|
SETMIR(buf1, part); \
|
|
|
|
if (access("/system/" #part, F_OK) == 0 && access(buf1, F_OK) != 0) { \
|
2020-12-31 07:11:24 +01:00
|
|
|
xsymlink("./system/" #part, buf1); \
|
|
|
|
LOGI("link: %s\n", buf1); \
|
2020-04-21 08:57:29 +02:00
|
|
|
}
|
|
|
|
|
2020-11-03 08:20:38 +01:00
|
|
|
#define link_orig_dir(dir, part) \
|
2022-02-05 08:19:12 +01:00
|
|
|
if (MNT_DIR_IS(dir) && !MNT_TYPE_IS("tmpfs") && !MNT_TYPE_IS("overlay")) { \
|
|
|
|
SETMIR(buf1, part); \
|
|
|
|
rmdir(buf1); \
|
|
|
|
xsymlink(dir, buf1); \
|
|
|
|
LOGI("link: %s\n", buf1); \
|
|
|
|
break; \
|
2020-11-03 08:20:38 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#define link_orig(part) link_orig_dir("/" #part, part)
|
|
|
|
|
2020-11-04 13:49:43 +01:00
|
|
|
static void mount_mirrors() {
|
2020-12-31 07:11:24 +01:00
|
|
|
char buf1[4096];
|
|
|
|
char buf2[4096];
|
|
|
|
|
|
|
|
LOGI("* Mounting mirrors\n");
|
|
|
|
|
|
|
|
parse_mnt("/proc/mounts", [&](mntent *me) {
|
2022-02-05 08:19:12 +01:00
|
|
|
struct stat st{};
|
|
|
|
do {
|
2022-03-02 05:09:59 +01:00
|
|
|
mount_mirror(system)
|
|
|
|
mount_mirror(vendor)
|
|
|
|
mount_mirror(product)
|
|
|
|
mount_mirror(system_ext)
|
|
|
|
mount_mirror(data)
|
2022-02-05 08:19:12 +01:00
|
|
|
link_orig(cache)
|
|
|
|
link_orig(metadata)
|
|
|
|
link_orig(persist)
|
|
|
|
link_orig_dir("/mnt/vendor/persist", persist)
|
|
|
|
if (SDK_INT >= 24 && MNT_DIR_IS("/proc") && !strstr(me->mnt_opts, "hidepid=2")) {
|
|
|
|
xmount(nullptr, "/proc", nullptr, MS_REMOUNT, "hidepid=2,gid=3009");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} while (false);
|
2020-12-31 07:11:24 +01:00
|
|
|
return true;
|
|
|
|
});
|
|
|
|
SETMIR(buf1, system);
|
|
|
|
if (access(buf1, F_OK) != 0) {
|
|
|
|
xsymlink("./system_root/system", buf1);
|
|
|
|
LOGI("link: %s\n", buf1);
|
|
|
|
parse_mnt("/proc/mounts", [&](mntent *me) {
|
|
|
|
struct stat st;
|
|
|
|
if (MNT_DIR_IS("/") && me->mnt_type != "rootfs"sv && stat("/", &st) == 0) {
|
2022-03-02 05:09:59 +01:00
|
|
|
do_mount_mirror(system_root)
|
2020-12-31 07:11:24 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
link_mirror(vendor)
|
|
|
|
link_mirror(product)
|
|
|
|
link_mirror(system_ext)
|
2020-11-04 13:49:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool magisk_env() {
|
2020-12-31 07:11:24 +01:00
|
|
|
char buf[4096];
|
|
|
|
|
|
|
|
LOGI("* Initializing Magisk environment\n");
|
|
|
|
|
2022-05-20 07:54:49 +02:00
|
|
|
preserve_stub_apk();
|
2020-12-31 07:11:24 +01:00
|
|
|
string pkg;
|
2022-05-18 10:55:58 +02:00
|
|
|
get_manager(0, &pkg);
|
2020-12-31 07:11:24 +01:00
|
|
|
|
2022-11-01 10:04:50 +01:00
|
|
|
ssprintf(buf, sizeof(buf), "%s/0/%s/install", APP_DATA_DIR,
|
2021-09-17 11:07:32 +02:00
|
|
|
pkg.empty() ? "xxx" /* Ensure non-exist path */ : pkg.data());
|
2020-12-31 07:11:24 +01:00
|
|
|
|
|
|
|
// Alternative binaries paths
|
|
|
|
const char *alt_bin[] = { "/cache/data_adb/magisk", "/data/magisk", buf };
|
|
|
|
for (auto alt : alt_bin) {
|
2022-03-17 20:56:34 +01:00
|
|
|
struct stat st{};
|
2020-12-31 07:11:24 +01:00
|
|
|
if (lstat(alt, &st) == 0) {
|
|
|
|
if (S_ISLNK(st.st_mode)) {
|
|
|
|
unlink(alt);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
rm_rf(DATABIN);
|
|
|
|
cp_afc(alt, DATABIN);
|
|
|
|
rm_rf(alt);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rm_rf("/cache/data_adb");
|
|
|
|
|
|
|
|
// Directories in /data/adb
|
|
|
|
xmkdir(DATABIN, 0755);
|
|
|
|
xmkdir(MODULEROOT, 0755);
|
|
|
|
xmkdir(SECURE_DIR "/post-fs-data.d", 0755);
|
|
|
|
xmkdir(SECURE_DIR "/service.d", 0755);
|
|
|
|
|
2022-07-21 21:08:37 +02:00
|
|
|
restore_databincon();
|
|
|
|
|
2021-01-25 09:23:42 +01:00
|
|
|
if (access(DATABIN "/busybox", X_OK))
|
|
|
|
return false;
|
2020-12-31 07:11:24 +01:00
|
|
|
|
|
|
|
sprintf(buf, "%s/" BBPATH "/busybox", MAGISKTMP.data());
|
|
|
|
mkdir(dirname(buf), 0755);
|
2021-01-25 09:23:42 +01:00
|
|
|
cp_afc(DATABIN "/busybox", buf);
|
2020-12-31 07:11:24 +01:00
|
|
|
exec_command_async(buf, "--install", "-s", dirname(buf));
|
|
|
|
|
2022-03-17 11:15:39 +01:00
|
|
|
if (access(DATABIN "/magiskpolicy", X_OK) == 0) {
|
|
|
|
sprintf(buf, "%s/magiskpolicy", MAGISKTMP.data());
|
|
|
|
cp_afc(DATABIN "/magiskpolicy", buf);
|
|
|
|
}
|
|
|
|
|
2020-12-31 07:11:24 +01:00
|
|
|
return true;
|
2018-11-16 04:55:28 +01:00
|
|
|
}
|
2018-11-13 07:53:48 +01:00
|
|
|
|
2020-04-30 10:26:50 +02:00
|
|
|
void reboot() {
|
2020-12-31 07:11:24 +01:00
|
|
|
if (RECOVERY_MODE)
|
|
|
|
exec_command_sync("/system/bin/reboot", "recovery");
|
|
|
|
else
|
|
|
|
exec_command_sync("/system/bin/reboot");
|
2019-11-01 08:07:12 +01:00
|
|
|
}
|
|
|
|
|
2018-11-04 09:38:06 +01:00
|
|
|
static bool check_data() {
|
2020-12-31 07:11:24 +01:00
|
|
|
bool mnt = false;
|
|
|
|
file_readline("/proc/mounts", [&](string_view s) {
|
|
|
|
if (str_contains(s, " /data ") && !str_contains(s, "tmpfs")) {
|
|
|
|
mnt = true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
});
|
|
|
|
if (!mnt)
|
|
|
|
return false;
|
|
|
|
auto crypto = getprop("ro.crypto.state");
|
|
|
|
if (!crypto.empty()) {
|
2022-06-28 07:21:07 +02:00
|
|
|
if (crypto != "encrypted") {
|
2020-12-31 07:11:24 +01:00
|
|
|
// Unencrypted, we can directly access data
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
// Encrypted, check whether vold is started
|
|
|
|
return !getprop("init.svc.vold").empty();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// ro.crypto.state is not set, assume it's unencrypted
|
|
|
|
return true;
|
2018-10-13 03:46:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void unlock_blocks() {
|
2020-12-31 07:11:24 +01:00
|
|
|
int fd, dev, OFF = 0;
|
|
|
|
|
|
|
|
auto dir = xopen_dir("/dev/block");
|
|
|
|
if (!dir)
|
|
|
|
return;
|
|
|
|
dev = dirfd(dir.get());
|
|
|
|
|
|
|
|
for (dirent *entry; (entry = readdir(dir.get()));) {
|
|
|
|
if (entry->d_type == DT_BLK) {
|
|
|
|
if ((fd = openat(dev, entry->d_name, O_RDONLY | O_CLOEXEC)) < 0)
|
|
|
|
continue;
|
|
|
|
if (ioctl(fd, BLKROSET, &OFF) < 0)
|
|
|
|
PLOGE("unlock %s", entry->d_name);
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
}
|
2018-10-13 03:46:09 +02:00
|
|
|
}
|
|
|
|
|
2020-05-19 13:53:16 +02:00
|
|
|
#define test_bit(bit, array) (array[bit / 8] & (1 << (bit % 8)))
|
|
|
|
|
|
|
|
static bool check_key_combo() {
|
2020-12-31 07:11:24 +01:00
|
|
|
uint8_t bitmask[(KEY_MAX + 1) / 8];
|
|
|
|
vector<int> events;
|
|
|
|
constexpr char name[] = "/dev/.ev";
|
|
|
|
|
|
|
|
// First collect candidate events that accepts volume down
|
|
|
|
for (int minor = 64; minor < 96; ++minor) {
|
|
|
|
if (xmknod(name, S_IFCHR | 0444, makedev(13, minor)))
|
|
|
|
continue;
|
|
|
|
int fd = open(name, O_RDONLY | O_CLOEXEC);
|
|
|
|
unlink(name);
|
|
|
|
if (fd < 0)
|
|
|
|
continue;
|
|
|
|
memset(bitmask, 0, sizeof(bitmask));
|
|
|
|
ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(bitmask)), bitmask);
|
|
|
|
if (test_bit(KEY_VOLUMEDOWN, bitmask))
|
|
|
|
events.push_back(fd);
|
|
|
|
else
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
if (events.empty())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
run_finally fin([&]{ std::for_each(events.begin(), events.end(), close); });
|
|
|
|
|
|
|
|
// Check if volume down key is held continuously for more than 3 seconds
|
|
|
|
for (int i = 0; i < 300; ++i) {
|
|
|
|
bool pressed = false;
|
|
|
|
for (const int &fd : events) {
|
|
|
|
memset(bitmask, 0, sizeof(bitmask));
|
|
|
|
ioctl(fd, EVIOCGKEY(sizeof(bitmask)), bitmask);
|
|
|
|
if (test_bit(KEY_VOLUMEDOWN, bitmask)) {
|
|
|
|
pressed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!pressed)
|
|
|
|
return false;
|
|
|
|
// Check every 10ms
|
|
|
|
usleep(10000);
|
|
|
|
}
|
|
|
|
LOGD("KEY_VOLUMEDOWN detected: enter safe mode\n");
|
|
|
|
return true;
|
2020-05-19 13:53:16 +02:00
|
|
|
}
|
|
|
|
|
2020-12-15 12:40:37 +01:00
|
|
|
/***********************
|
|
|
|
* Boot Stage Handlers *
|
|
|
|
***********************/
|
|
|
|
|
|
|
|
static pthread_mutex_t stage_lock = PTHREAD_MUTEX_INITIALIZER;
|
2022-03-01 11:13:18 +01:00
|
|
|
extern int disable_deny();
|
2017-04-30 19:58:52 +02:00
|
|
|
|
2019-02-09 07:51:46 +01:00
|
|
|
void post_fs_data(int client) {
|
2020-12-31 07:11:24 +01:00
|
|
|
close(client);
|
|
|
|
|
|
|
|
mutex_guard lock(stage_lock);
|
|
|
|
|
|
|
|
if (getenv("REMOUNT_ROOT"))
|
|
|
|
xmount(nullptr, "/", nullptr, MS_REMOUNT | MS_RDONLY, nullptr);
|
|
|
|
|
|
|
|
if (!check_data())
|
|
|
|
goto unblock_init;
|
|
|
|
|
|
|
|
DAEMON_STATE = STATE_POST_FS_DATA;
|
|
|
|
setup_logfile(true);
|
|
|
|
|
|
|
|
LOGI("** post-fs-data mode running\n");
|
|
|
|
|
|
|
|
unlock_blocks();
|
|
|
|
mount_mirrors();
|
2022-05-30 08:43:22 +02:00
|
|
|
prune_su_access();
|
2020-12-31 07:11:24 +01:00
|
|
|
|
|
|
|
if (access(SECURE_DIR, F_OK) != 0) {
|
|
|
|
if (SDK_INT < 24) {
|
|
|
|
// There is no FBE pre 7.0, we can directly create the folder without issues
|
|
|
|
xmkdir(SECURE_DIR, 0700);
|
|
|
|
} else {
|
|
|
|
// If the folder is not automatically created by Android,
|
|
|
|
// do NOT proceed further. Manual creation of the folder
|
2021-03-13 17:32:30 +01:00
|
|
|
// will have no encryption flag, which will cause bootloops on FBE devices.
|
2020-12-31 07:11:24 +01:00
|
|
|
LOGE(SECURE_DIR " is not present, abort\n");
|
|
|
|
goto early_abort;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!magisk_env()) {
|
|
|
|
LOGE("* Magisk environment incomplete, abort\n");
|
|
|
|
goto early_abort;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (getprop("persist.sys.safemode", true) == "1" || check_key_combo()) {
|
|
|
|
safe_mode = true;
|
2021-09-12 21:40:34 +02:00
|
|
|
// Disable all modules and denylist so next boot will be clean
|
2020-12-31 07:11:24 +01:00
|
|
|
disable_modules();
|
2021-09-12 21:40:34 +02:00
|
|
|
disable_deny();
|
2020-12-31 07:11:24 +01:00
|
|
|
} else {
|
|
|
|
exec_common_scripts("post-fs-data");
|
2021-09-15 11:49:54 +02:00
|
|
|
db_settings dbs;
|
|
|
|
get_db_settings(dbs, ZYGISK_CONFIG);
|
2021-09-16 14:27:34 +02:00
|
|
|
zygisk_enabled = dbs[ZYGISK_CONFIG];
|
|
|
|
initialize_denylist();
|
2020-12-31 07:11:24 +01:00
|
|
|
handle_modules();
|
|
|
|
}
|
2017-05-03 21:05:37 +02:00
|
|
|
|
2020-11-04 13:49:43 +01:00
|
|
|
early_abort:
|
2020-12-31 07:11:24 +01:00
|
|
|
// We still do magic mount because root itself might need it
|
|
|
|
magic_mount();
|
|
|
|
DAEMON_STATE = STATE_POST_FS_DATA_DONE;
|
2020-05-19 08:29:26 +02:00
|
|
|
|
|
|
|
unblock_init:
|
2020-12-31 07:11:24 +01:00
|
|
|
close(xopen(UNBLOCKFILE, O_RDONLY | O_CREAT, 0));
|
2017-04-30 19:58:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void late_start(int client) {
|
2020-12-31 07:11:24 +01:00
|
|
|
close(client);
|
2017-04-30 19:58:52 +02:00
|
|
|
|
2020-12-31 07:11:24 +01:00
|
|
|
mutex_guard lock(stage_lock);
|
|
|
|
run_finally fin([]{ DAEMON_STATE = STATE_LATE_START_DONE; });
|
|
|
|
setup_logfile(false);
|
2019-02-14 10:27:30 +01:00
|
|
|
|
2020-12-31 07:11:24 +01:00
|
|
|
LOGI("** late_start service mode running\n");
|
2020-12-15 12:40:37 +01:00
|
|
|
|
2020-12-31 07:11:24 +01:00
|
|
|
if (DAEMON_STATE < STATE_POST_FS_DATA_DONE || safe_mode)
|
|
|
|
return;
|
2019-09-17 06:21:07 +02:00
|
|
|
|
2020-12-31 07:11:24 +01:00
|
|
|
exec_common_scripts("service");
|
|
|
|
exec_module_scripts("service");
|
2019-04-05 13:00:30 +02:00
|
|
|
}
|
2017-06-11 10:51:44 +02:00
|
|
|
|
2019-04-05 13:00:30 +02:00
|
|
|
void boot_complete(int client) {
|
2020-12-31 07:11:24 +01:00
|
|
|
close(client);
|
|
|
|
|
|
|
|
mutex_guard lock(stage_lock);
|
|
|
|
DAEMON_STATE = STATE_BOOT_COMPLETE;
|
|
|
|
setup_logfile(false);
|
|
|
|
|
2022-05-29 07:39:44 +02:00
|
|
|
LOGI("** boot-complete triggered\n");
|
2020-12-31 07:11:24 +01:00
|
|
|
|
|
|
|
if (safe_mode)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// At this point it's safe to create the folder
|
|
|
|
if (access(SECURE_DIR, F_OK) != 0)
|
|
|
|
xmkdir(SECURE_DIR, 0700);
|
|
|
|
|
2022-05-20 07:54:49 +02:00
|
|
|
// Ensure manager exists
|
2022-05-30 08:31:57 +02:00
|
|
|
check_pkg_refresh();
|
2022-05-20 07:54:49 +02:00
|
|
|
get_manager(0, nullptr, true);
|
2017-04-30 19:58:52 +02:00
|
|
|
}
|
2022-05-29 07:39:44 +02:00
|
|
|
|
|
|
|
void zygote_restart(int client) {
|
|
|
|
close(client);
|
|
|
|
|
|
|
|
LOGI("** zygote restarted\n");
|
|
|
|
pkg_xml_ino = 0;
|
|
|
|
prune_su_access();
|
|
|
|
}
|