Magisk/native/jni/utils/misc.cpp

221 lines
4.6 KiB
C++
Raw Normal View History

2018-11-03 08:06:01 +01:00
/* misc.cpp - Store all functions that are unable to be catagorized clearly
2017-04-06 00:12:29 +02:00
*/
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/prctl.h>
#include <sys/sysmacros.h>
2017-04-06 00:12:29 +02:00
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
2017-04-07 00:21:20 +02:00
#include <fcntl.h>
2017-04-14 21:23:09 +02:00
#include <pwd.h>
2017-11-15 14:00:52 +01:00
#include <unistd.h>
#include <syscall.h>
#include <random>
2020-04-26 08:19:36 +02:00
#include <string>
2017-04-06 00:12:29 +02:00
2020-03-09 09:50:30 +01:00
#include <logging.hpp>
#include <utils.hpp>
2017-04-06 00:12:29 +02:00
2020-04-26 08:19:36 +02:00
using namespace std;
int fork_dont_care() {
2017-10-13 18:08:12 +02:00
int pid = xfork();
if (pid) {
2018-11-03 08:06:01 +01:00
waitpid(pid, nullptr, 0);
return pid;
2017-10-13 18:08:12 +02:00
} else if ((pid = xfork())) {
exit(0);
}
return 0;
}
2017-12-06 18:30:48 +01:00
int fork_no_zombie() {
int pid = xfork();
if (pid)
return pid;
// Unblock all signals
sigset_t block_set;
sigfillset(&block_set);
pthread_sigmask(SIG_UNBLOCK, &block_set, nullptr);
prctl(PR_SET_PDEATHSIG, SIGTERM);
if (getppid() == 1)
exit(1);
return 0;
}
constexpr char ALPHANUM[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
static bool seeded = false;
static std::mt19937 gen;
static std::uniform_int_distribution<int> dist(0, sizeof(ALPHANUM) - 2);
int gen_rand_str(char *buf, int len, bool varlen) {
if (!seeded) {
if (access("/dev/urandom", F_OK) != 0)
mknod("/dev/urandom", 0600 | S_IFCHR, makedev(1, 9));
int fd = xopen("/dev/urandom", O_RDONLY | O_CLOEXEC);
unsigned seed;
xxread(fd, &seed, sizeof(seed));
gen.seed(seed);
close(fd);
seeded = true;
}
if (varlen) {
std::uniform_int_distribution<int> len_dist(len / 2, len);
len = len_dist(gen);
}
for (int i = 0; i < len - 1; ++i)
buf[i] = ALPHANUM[dist(gen)];
buf[len - 1] = '\0';
return len - 1;
}
int strend(const char *s1, const char *s2) {
size_t l1 = strlen(s1);
size_t l2 = strlen(s2);
return strcmp(s1 + l1 - l2, s2);
}
2019-01-26 19:00:19 +01:00
int exec_command(exec_t &exec) {
2019-11-07 23:41:59 +01:00
int pipefd[] = {-1, -1};
int outfd = -1;
2018-11-03 09:03:11 +01:00
2019-01-26 19:00:19 +01:00
if (exec.fd == -1) {
if (xpipe2(pipefd, O_CLOEXEC) == -1)
return -1;
outfd = pipefd[1];
} else if (exec.fd >= 0) {
outfd = exec.fd;
2018-11-03 09:03:11 +01:00
}
2019-01-26 19:00:19 +01:00
int pid = exec.fork();
if (pid < 0) {
close(pipefd[0]);
close(pipefd[1]);
return -1;
} else if (pid) {
if (exec.fd == -1) {
exec.fd = pipefd[0];
2018-11-03 09:03:11 +01:00
close(pipefd[1]);
}
return pid;
}
2018-11-26 09:26:45 +01:00
if (outfd >= 0) {
2018-11-26 09:06:43 +01:00
xdup2(outfd, STDOUT_FILENO);
2019-01-26 19:00:19 +01:00
if (exec.err)
2018-11-26 09:06:43 +01:00
xdup2(outfd, STDERR_FILENO);
2018-11-26 09:26:45 +01:00
close(outfd);
2018-11-03 09:03:11 +01:00
}
2018-11-26 09:26:45 +01:00
// Call the pre-exec callback
2019-01-26 19:00:19 +01:00
if (exec.pre_exec)
exec.pre_exec();
2018-11-03 09:03:11 +01:00
2019-01-26 19:00:19 +01:00
execve(exec.argv[0], (char **) exec.argv, environ);
PLOGE("execve %s", exec.argv[0]);
exit(-1);
2018-11-03 09:03:11 +01:00
}
int exec_command_sync(exec_t &exec) {
2019-11-07 23:41:59 +01:00
int pid = exec_command(exec);
2019-01-26 19:00:19 +01:00
if (pid < 0)
return -1;
2019-11-07 23:41:59 +01:00
int status;
2019-01-26 19:00:19 +01:00
waitpid(pid, &status, 0);
return WEXITSTATUS(status);
}
2020-04-30 10:27:36 +02:00
int new_daemon_thread(thread_entry entry, void *arg, const pthread_attr_t *attr) {
pthread_t thread;
2020-04-30 10:27:36 +02:00
int ret = xpthread_create(&thread, attr, entry, arg);
if (ret == 0)
pthread_detach(thread);
return ret;
}
2019-05-26 06:42:51 +02:00
static void *proxy_routine(void *fp) {
auto fn = reinterpret_cast<std::function<void()>*>(fp);
(*fn)();
delete fn;
return nullptr;
}
2020-04-30 10:27:36 +02:00
int new_daemon_thread(std::function<void()> &&entry) {
return new_daemon_thread(proxy_routine, new std::function<void()>(std::move(entry)));
2019-05-26 06:42:51 +02:00
}
2019-02-15 10:31:39 +01:00
static char *argv0;
static size_t name_len;
void init_argv0(int argc, char **argv) {
argv0 = argv[0];
name_len = (argv[argc - 1] - argv[0]) + strlen(argv[argc - 1]) + 1;
}
void set_nice_name(const char *name) {
memset(argv0, 0, name_len);
strlcpy(argv0, name, name_len);
prctl(PR_SET_NAME, name);
}
bool ends_with(const std::string_view &s1, const std::string_view &s2) {
unsigned l1 = s1.length();
unsigned l2 = s2.length();
return l1 < l2 ? false : s1.compare(l1 - l2, l2, s2) == 0;
}
2019-02-26 09:04:17 +01:00
2019-03-08 02:31:35 +01:00
/*
* Bionic's atoi runs through strtol().
* Use our own implementation for faster conversion.
*/
int parse_int(const char *s) {
int val = 0;
char c;
while ((c = *(s++))) {
if (c > '9' || c < '0')
return -1;
val = val * 10 + c - '0';
}
return val;
}
uint32_t binary_gcd(uint32_t u, uint32_t v) {
if (u == 0) return v;
if (v == 0) return u;
auto shift = __builtin_ctz(u | v);
u >>= __builtin_ctz(u);
do {
v >>= __builtin_ctz(v);
if (u > v) {
auto t = v;
v = u;
u = t;
}
v -= u;
} while (v != 0);
return u << shift;
}
int switch_mnt_ns(int pid) {
char mnt[32];
snprintf(mnt, sizeof(mnt), "/proc/%d/ns/mnt", pid);
if (access(mnt, R_OK) == -1) return 1; // Maybe process died..
int fd, ret;
fd = xopen(mnt, O_RDONLY);
if (fd < 0) return 1;
// Switch to its namespace
ret = xsetns(fd, 0);
close(fd);
return ret;
}
2020-04-26 08:19:36 +02:00
string &replace_all(string &str, string_view from, string_view to) {
size_t pos = 0;
while((pos = str.find(from, pos)) != string::npos) {
str.replace(pos, from.length(), to);
pos += to.length();
}
return str;
}