Magisk/native/jni/init/init.cpp

187 lines
4.4 KiB
C++
Raw Normal View History

2019-05-27 09:29:43 +02:00
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/sysmacros.h>
#include <fcntl.h>
#include <libgen.h>
2019-07-02 07:58:19 +02:00
#include <vector>
2019-05-27 09:29:43 +02:00
#include <xz.h>
2020-03-09 09:50:30 +01:00
#include <magisk.hpp>
#include <utils.hpp>
2019-05-27 09:29:43 +02:00
#include "binaries.h"
#ifdef USE_64BIT
#include "binaries_arch64.h"
#else
#include "binaries_arch.h"
#endif
2020-03-09 09:50:30 +01:00
#include "init.hpp"
2019-05-27 09:29:43 +02:00
using namespace std;
2020-10-27 04:46:15 +01:00
// Debug toggle
#define ENABLE_TEST 0
2019-06-22 12:14:33 +02:00
constexpr int (*init_applet_main[])(int, char *[]) =
{ magiskpolicy_main, magiskpolicy_main, nullptr };
2019-06-22 12:14:33 +02:00
2019-05-27 09:29:43 +02:00
static bool unxz(int fd, const uint8_t *buf, size_t size) {
uint8_t out[8192];
xz_crc32_init();
struct xz_dec *dec = xz_dec_init(XZ_DYNALLOC, 1 << 26);
struct xz_buf b = {
.in = buf,
.in_pos = 0,
.in_size = size,
.out = out,
.out_pos = 0,
.out_size = sizeof(out)
};
enum xz_ret ret;
do {
ret = xz_dec_run(dec, &b);
if (ret != XZ_OK && ret != XZ_STREAM_END)
return false;
write(fd, out, b.out_pos);
b.out_pos = 0;
} while (b.in_pos != size);
return true;
2019-05-27 09:29:43 +02:00
}
int dump_magisk(const char *path, mode_t mode) {
int fd = xopen(path, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, mode);
if (fd < 0)
return 1;
if (!unxz(fd, magisk_xz, sizeof(magisk_xz)))
return 1;
close(fd);
return 0;
2019-05-27 09:29:43 +02:00
}
static int dump_manager(const char *path, mode_t mode) {
int fd = xopen(path, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, mode);
if (fd < 0)
return 1;
if (!unxz(fd, manager_xz, sizeof(manager_xz)))
return 1;
close(fd);
return 0;
2019-05-27 09:29:43 +02:00
}
2019-06-16 21:45:32 +02:00
class RecoveryInit : public BaseInit {
public:
RecoveryInit(char *argv[], cmdline *cmd) : BaseInit(argv, cmd) {}
void start() override {
LOGD("Ramdisk is recovery, abort\n");
rename("/.backup/init", "/init");
rm_rf("/.backup");
exec_init();
}
2019-06-16 21:45:32 +02:00
};
2020-10-27 04:46:15 +01:00
#if ENABLE_TEST
2019-11-18 23:18:56 +01:00
class TestInit : public BaseInit {
2019-06-16 21:45:32 +02:00
public:
TestInit(char *argv[], cmdline *cmd) : BaseInit(argv, cmd) {};
void start() override {
// Place init tests here
}
2019-06-16 21:45:32 +02:00
};
2019-05-27 09:29:43 +02:00
2020-10-27 04:46:15 +01:00
static int test_main(int argc, char *argv[]) {
// Log to console
cmdline_logging();
log_cb.ex = nop_ex;
// Switch to isolate namespace
xunshare(CLONE_NEWNS);
xmount(nullptr, "/", nullptr, MS_PRIVATE | MS_REC, nullptr);
// Unmount everything in reverse
vector<string> mounts;
parse_mnt("/proc/mounts", [&](mntent *me) {
if (me->mnt_dir != "/"sv)
mounts.emplace_back(me->mnt_dir);
return true;
});
for (auto &m : reversed(mounts))
xumount(m.data());
// chroot jail
chdir(dirname(argv[0]));
chroot(".");
chdir("/");
cmdline cmd{};
load_kernel_info(&cmd);
auto init = make_unique<TestInit>(argv, &cmd);
init->start();
return 1;
2019-06-25 12:34:54 +02:00
}
2020-10-27 04:46:15 +01:00
#endif // ENABLE_TEST
static int magisk_proxy_main(int argc, char *argv[]) {
setup_klog();
auto init = make_unique<MagiskProxy>(argv);
init->start();
return 1;
2020-10-27 04:46:15 +01:00
}
2019-06-25 12:34:54 +02:00
2019-05-27 09:29:43 +02:00
int main(int argc, char *argv[]) {
umask(0);
2019-05-27 09:29:43 +02:00
auto name = basename(argv[0]);
if (name == "magisk"sv)
return magisk_proxy_main(argc, argv);
for (int i = 0; init_applet[i]; ++i) {
if (strcmp(name, init_applet[i]) == 0)
return (*init_applet_main[i])(argc, argv);
}
2019-05-27 09:29:43 +02:00
2020-10-27 04:46:15 +01:00
#if ENABLE_TEST
if (getenv("INIT_TEST") != nullptr)
return test_main(argc, argv);
2019-12-06 18:02:34 +01:00
#endif
if (argc > 1 && argv[1] == "-x"sv) {
if (argv[2] == "magisk"sv)
return dump_magisk(argv[3], 0755);
else if (argv[2] == "manager"sv)
return dump_manager(argv[3], 0644);
}
if (getpid() != 1)
return 1;
BaseInit *init;
cmdline cmd{};
if (argc > 1 && argv[1] == "selinux_setup"sv) {
setup_klog();
init = new SecondStageInit(argv);
} else {
// This will also mount /sys and /proc
load_kernel_info(&cmd);
if (cmd.skip_initramfs) {
init = new SARInit(argv, &cmd);
} else {
if (cmd.force_normal_boot)
init = new FirstStageInit(argv, &cmd);
else if (access("/sbin/recovery", F_OK) == 0 || access("/system/bin/recovery", F_OK) == 0)
init = new RecoveryInit(argv, &cmd);
else if (check_two_stage())
init = new FirstStageInit(argv, &cmd);
else
init = new RootFSInit(argv, &cmd);
}
}
// Run the main routine
init->start();
exit(1);
2019-05-27 09:29:43 +02:00
}