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
|
|
|
*/
|
2018-11-03 08:06:01 +01:00
|
|
|
|
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>
|
2018-09-06 07:33:17 +02:00
|
|
|
#include <syscall.h>
|
2017-04-07 00:21:20 +02:00
|
|
|
#include <sys/types.h>
|
2017-04-22 00:33:40 +02:00
|
|
|
#include <sys/wait.h>
|
2019-02-14 23:36:18 +01:00
|
|
|
#include <sys/prctl.h>
|
2018-02-10 20:40:09 +01:00
|
|
|
#include <sys/sysmacros.h>
|
2017-04-06 00:12:29 +02:00
|
|
|
|
2019-02-10 09:57:51 +01:00
|
|
|
#include <logging.h>
|
|
|
|
#include <utils.h>
|
2017-04-06 00:12:29 +02:00
|
|
|
|
2017-04-14 21:23:09 +02:00
|
|
|
unsigned get_shell_uid() {
|
|
|
|
struct passwd* ppwd = getpwnam("shell");
|
2018-11-03 08:06:01 +01:00
|
|
|
if (nullptr == ppwd)
|
2017-04-14 21:23:09 +02:00
|
|
|
return 2000;
|
|
|
|
|
|
|
|
return ppwd->pw_uid;
|
|
|
|
}
|
|
|
|
|
2017-10-08 23:05:52 +02:00
|
|
|
int fork_dont_care() {
|
2017-10-13 18:08:12 +02:00
|
|
|
int pid = xfork();
|
2017-10-08 23:05:52 +02:00
|
|
|
if (pid) {
|
2018-11-03 08:06:01 +01:00
|
|
|
waitpid(pid, nullptr, 0);
|
2017-10-08 23:05:52 +02:00
|
|
|
return pid;
|
2017-10-13 18:08:12 +02:00
|
|
|
} else if ((pid = xfork())) {
|
2017-10-08 23:05:52 +02:00
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2017-12-06 18:30:48 +01:00
|
|
|
|
2019-02-14 23:36:18 +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;
|
|
|
|
}
|
|
|
|
|
2019-04-05 13:00:30 +02:00
|
|
|
static bool rand_init = false;
|
|
|
|
|
2018-02-10 20:40:09 +01:00
|
|
|
void gen_rand_str(char *buf, int len) {
|
2019-04-05 13:00:30 +02:00
|
|
|
constexpr const char base[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
|
|
|
|
if (!rand_init) {
|
|
|
|
srand(time(nullptr));
|
|
|
|
rand_init = true;
|
2018-02-10 20:40:09 +01:00
|
|
|
}
|
|
|
|
for (int i = 0; i < len - 1; ++i) {
|
2019-04-05 13:00:30 +02:00
|
|
|
buf[i] = base[rand() % (sizeof(base) - 1)];
|
2018-02-10 20:40:09 +01:00
|
|
|
}
|
|
|
|
buf[len - 1] = '\0';
|
|
|
|
}
|
2018-07-20 23:12:22 +02:00
|
|
|
|
|
|
|
int strend(const char *s1, const char *s2) {
|
|
|
|
size_t l1 = strlen(s1);
|
|
|
|
size_t l2 = strlen(s2);
|
|
|
|
return strcmp(s1 + l1 - l2, s2);
|
|
|
|
}
|
2018-09-06 07:33:17 +02:00
|
|
|
|
|
|
|
/* Original source: https://opensource.apple.com/source/cvs/cvs-19/cvs/lib/getline.c
|
|
|
|
* License: GPL 2 or later
|
|
|
|
* Adjusted to match POSIX */
|
|
|
|
#define MIN_CHUNK 64
|
|
|
|
ssize_t __getdelim(char **lineptr, size_t *n, int delim, FILE *stream) {
|
|
|
|
size_t nchars_avail;
|
|
|
|
char *read_pos;
|
|
|
|
|
|
|
|
if (!lineptr || !n || !stream) {
|
|
|
|
errno = EINVAL;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!*lineptr) {
|
|
|
|
*n = MIN_CHUNK;
|
2018-11-03 08:06:01 +01:00
|
|
|
*lineptr = (char *) malloc(*n);
|
2018-09-06 07:33:17 +02:00
|
|
|
if (!*lineptr) {
|
|
|
|
errno = ENOMEM;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
nchars_avail = *n;
|
|
|
|
read_pos = *lineptr;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
int save_errno;
|
2018-11-03 08:06:01 +01:00
|
|
|
int c = getc(stream);
|
2018-09-06 07:33:17 +02:00
|
|
|
|
|
|
|
save_errno = errno;
|
|
|
|
|
|
|
|
if (nchars_avail < 2) {
|
|
|
|
if (*n > MIN_CHUNK)
|
|
|
|
*n *= 2;
|
|
|
|
else
|
|
|
|
*n += MIN_CHUNK;
|
|
|
|
|
|
|
|
nchars_avail = *n + *lineptr - read_pos;
|
2018-11-03 08:06:01 +01:00
|
|
|
*lineptr = (char *) realloc(*lineptr, *n);
|
2018-09-06 07:33:17 +02:00
|
|
|
if (!*lineptr) {
|
|
|
|
errno = ENOMEM;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
read_pos = *n - nchars_avail + *lineptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ferror(stream)) {
|
|
|
|
errno = save_errno;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c == EOF) {
|
|
|
|
if (read_pos == *lineptr)
|
|
|
|
return -1;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
*read_pos++ = c;
|
|
|
|
nchars_avail--;
|
|
|
|
|
|
|
|
if (c == delim)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
*read_pos = '\0';
|
|
|
|
|
|
|
|
return read_pos - *lineptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
ssize_t __getline(char **lineptr, size_t *n, FILE *stream) {
|
|
|
|
return __getdelim(lineptr, n, '\n', stream);
|
|
|
|
}
|
|
|
|
|
2019-01-26 19:00:19 +01:00
|
|
|
int exec_command(exec_t &exec) {
|
|
|
|
int pipefd[2] = {-1, -1}, 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]);
|
2018-12-28 09:33:26 +01:00
|
|
|
exit(-1);
|
2018-11-03 09:03:11 +01:00
|
|
|
}
|
|
|
|
|
2019-02-12 22:13:31 +01:00
|
|
|
int exec_command_sync(exec_t &exec) {
|
2019-01-26 19:00:19 +01:00
|
|
|
int pid, status;
|
|
|
|
pid = exec_command(exec);
|
|
|
|
if (pid < 0)
|
|
|
|
return -1;
|
|
|
|
waitpid(pid, &status, 0);
|
|
|
|
return WEXITSTATUS(status);
|
|
|
|
}
|
|
|
|
|
2019-02-14 23:36:18 +01:00
|
|
|
int new_daemon_thread(void *(*start_routine) (void *), void *arg, const pthread_attr_t *attr) {
|
|
|
|
pthread_t thread;
|
|
|
|
int ret = xpthread_create(&thread, attr, start_routine, 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
int new_daemon_thread(std::function<void()> &&fn) {
|
|
|
|
return new_daemon_thread(proxy_routine, new std::function<void()>(std::move(fn)));
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
2019-02-18 09:05:13 +01:00
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
char *rtrim(char *str) {
|
|
|
|
int len = strlen(str);
|
|
|
|
while (len > 0 && str[len - 1] == ' ')
|
|
|
|
--len;
|
|
|
|
str[len] = '\0';
|
|
|
|
return str;
|
|
|
|
}
|
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;
|
|
|
|
}
|