2018-07-06 01:57:18 +02:00
|
|
|
/* log_daemon.c - A dedicated daemon to monitor logcat
|
2017-04-04 21:44:13 +02:00
|
|
|
*
|
2017-10-08 23:05:52 +02:00
|
|
|
* A universal logcat monitor for many usages. Add listeners to the list,
|
2018-07-06 01:57:18 +02:00
|
|
|
* and the new log line will be sent through sockets to trigger
|
2017-10-08 23:05:52 +02:00
|
|
|
* asynchronous events without polling
|
2017-04-04 21:44:13 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <pthread.h>
|
2017-05-07 21:11:14 +02:00
|
|
|
#include <unistd.h>
|
2018-09-27 09:11:10 +02:00
|
|
|
#include <string.h>
|
|
|
|
#include <stdlib.h>
|
2017-06-02 22:31:01 +02:00
|
|
|
#include <sys/wait.h>
|
2018-07-01 12:18:12 +02:00
|
|
|
#include <fcntl.h>
|
2017-04-04 21:44:13 +02:00
|
|
|
|
2017-04-06 00:12:29 +02:00
|
|
|
#include "magisk.h"
|
2017-04-04 21:44:13 +02:00
|
|
|
#include "utils.h"
|
2018-07-02 16:11:28 +02:00
|
|
|
#include "daemon.h"
|
2018-09-27 09:56:56 +02:00
|
|
|
#include "flags.h"
|
2017-10-08 23:05:52 +02:00
|
|
|
|
2018-11-04 23:23:08 +01:00
|
|
|
bool log_daemon_started = false;
|
2018-11-08 11:03:59 +01:00
|
|
|
static Vector<const char *> log_cmd, clear_cmd;
|
2018-07-02 16:11:28 +02:00
|
|
|
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
|
|
|
|
|
|
|
|
enum {
|
|
|
|
HIDE_EVENT,
|
2018-07-02 16:48:26 +02:00
|
|
|
LOG_EVENT
|
2018-07-02 16:11:28 +02:00
|
|
|
};
|
|
|
|
|
2018-11-04 23:23:08 +01:00
|
|
|
#define EVENT_NUM 2
|
|
|
|
|
2018-07-02 16:11:28 +02:00
|
|
|
struct log_listener {
|
|
|
|
int fd;
|
2018-11-04 23:23:08 +01:00
|
|
|
bool (*filter)(const char *);
|
2018-07-02 16:11:28 +02:00
|
|
|
};
|
2017-10-08 23:05:52 +02:00
|
|
|
|
2018-11-04 23:23:08 +01:00
|
|
|
static bool am_proc_start_filter(const char *log) {
|
2018-11-04 09:38:06 +01:00
|
|
|
return strstr(log, "am_proc_start") != nullptr;
|
2017-12-18 11:17:37 +01:00
|
|
|
}
|
|
|
|
|
2018-11-04 23:23:08 +01:00
|
|
|
static bool magisk_log_filter(const char *log) {
|
2018-07-02 16:48:26 +02:00
|
|
|
return !am_proc_start_filter(log);
|
2017-12-18 11:17:37 +01:00
|
|
|
}
|
|
|
|
|
2018-07-03 16:25:39 +02:00
|
|
|
static struct log_listener events[] = {
|
2017-12-18 11:17:37 +01:00
|
|
|
{ /* HIDE_EVENT */
|
|
|
|
.fd = -1,
|
|
|
|
.filter = am_proc_start_filter
|
|
|
|
},
|
|
|
|
{ /* LOG_EVENT */
|
|
|
|
.fd = -1,
|
|
|
|
.filter = magisk_log_filter
|
|
|
|
}
|
|
|
|
};
|
2017-04-04 21:44:13 +02:00
|
|
|
|
2018-11-04 09:38:06 +01:00
|
|
|
static void sigpipe_handler(int) {
|
2018-07-03 16:25:39 +02:00
|
|
|
close(events[HIDE_EVENT].fd);
|
|
|
|
events[HIDE_EVENT].fd = -1;
|
2018-07-02 16:11:28 +02:00
|
|
|
}
|
|
|
|
|
2018-11-04 09:38:06 +01:00
|
|
|
static void *monitor_thread(void *) {
|
2018-07-02 19:38:19 +02:00
|
|
|
// Block SIGPIPE to prevent interruption
|
|
|
|
sigset_t block_set;
|
|
|
|
sigemptyset(&block_set);
|
|
|
|
sigaddset(&block_set, SIGPIPE);
|
2018-11-04 09:38:06 +01:00
|
|
|
pthread_sigmask(SIG_SETMASK, &block_set, nullptr);
|
2018-07-02 19:38:19 +02:00
|
|
|
// Give the main daemon some time before we monitor it
|
|
|
|
sleep(5);
|
|
|
|
int fd;
|
2018-07-06 01:32:16 +02:00
|
|
|
char b;
|
2018-07-06 01:51:17 +02:00
|
|
|
while (1) {
|
2018-07-02 19:38:19 +02:00
|
|
|
fd = connect_daemon();
|
2018-07-06 01:51:17 +02:00
|
|
|
write_int(fd, HANDSHAKE);
|
2018-07-02 19:38:19 +02:00
|
|
|
// This should hold unless the daemon is killed
|
2018-07-06 01:32:16 +02:00
|
|
|
read(fd, &b, sizeof(b));
|
2018-07-02 19:38:19 +02:00
|
|
|
// The main daemon crashed, spawn a new one
|
|
|
|
close(fd);
|
2018-07-06 01:51:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-04 09:38:06 +01:00
|
|
|
static void *logcat_thread(void *) {
|
2018-07-06 01:51:17 +02:00
|
|
|
int log_fd = -1, log_pid;
|
|
|
|
char line[4096];
|
|
|
|
while (1) {
|
|
|
|
// Start logcat
|
2018-11-26 09:06:43 +01:00
|
|
|
log_pid = exec_array(false, &log_fd, nullptr, log_cmd.data());
|
2018-07-06 01:51:17 +02:00
|
|
|
FILE *logs = fdopen(log_fd, "r");
|
|
|
|
while (fgets(line, sizeof(line), logs)) {
|
|
|
|
if (line[0] == '-')
|
|
|
|
continue;
|
|
|
|
size_t len = strlen(line);
|
|
|
|
pthread_mutex_lock(&lock);
|
|
|
|
for (int i = 0; i < EVENT_NUM; ++i) {
|
|
|
|
if (events[i].fd > 0 && events[i].filter(line))
|
|
|
|
write(events[i].fd, line, len);
|
|
|
|
}
|
|
|
|
pthread_mutex_unlock(&lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
fclose(logs);
|
|
|
|
log_fd = -1;
|
|
|
|
kill(log_pid, SIGTERM);
|
2018-11-04 09:38:06 +01:00
|
|
|
waitpid(log_pid, nullptr, 0);
|
2018-07-06 01:51:17 +02:00
|
|
|
|
|
|
|
LOGI("magisklogd: logcat output EOF");
|
|
|
|
// Clear buffer
|
2018-11-26 09:06:43 +01:00
|
|
|
log_pid = exec_array(false, nullptr, nullptr, clear_cmd.data());
|
2018-11-04 09:38:06 +01:00
|
|
|
waitpid(log_pid, nullptr, 0);
|
2018-07-06 01:51:17 +02:00
|
|
|
}
|
2018-07-02 19:38:19 +02:00
|
|
|
}
|
|
|
|
|
2018-10-12 06:50:47 +02:00
|
|
|
static void log_daemon() {
|
2018-07-02 16:11:28 +02:00
|
|
|
setsid();
|
|
|
|
LOGI("Magisk v" xstr(MAGISK_VERSION) "(" xstr(MAGISK_VER_CODE) ") logger started\n");
|
2018-07-03 16:25:39 +02:00
|
|
|
strcpy(argv0, "magisklogd");
|
2018-07-02 16:11:28 +02:00
|
|
|
|
2018-07-02 19:38:19 +02:00
|
|
|
// Set SIGPIPE handler
|
2018-07-02 16:11:28 +02:00
|
|
|
struct sigaction act;
|
|
|
|
memset(&act, 0, sizeof(act));
|
|
|
|
act.sa_handler = sigpipe_handler;
|
2018-11-04 09:38:06 +01:00
|
|
|
sigaction(SIGPIPE, &act, nullptr);
|
2018-07-02 16:11:28 +02:00
|
|
|
|
|
|
|
// Setup log dumps
|
|
|
|
rename(LOGFILE, LOGFILE ".bak");
|
2018-07-04 17:46:40 +02:00
|
|
|
events[LOG_EVENT].fd = xopen(LOGFILE, O_CREAT | O_WRONLY | O_TRUNC | O_CLOEXEC | O_APPEND, 0644);
|
2018-07-02 16:11:28 +02:00
|
|
|
|
2018-07-06 01:32:16 +02:00
|
|
|
// Construct cmdline
|
2018-11-04 09:38:06 +01:00
|
|
|
log_cmd.push_back(MIRRDIR "/system/bin/logcat");
|
2018-07-06 01:32:16 +02:00
|
|
|
// Test whether these buffers actually works
|
2018-11-04 23:23:08 +01:00
|
|
|
const char *b[] = { "main", "events", "crash" };
|
2018-07-06 01:32:16 +02:00
|
|
|
for (int i = 0; i < 3; ++i) {
|
2018-11-04 09:38:06 +01:00
|
|
|
if (exec_command_sync(MIRRDIR "/system/bin/logcat", "-b", b[i], "-d", "-f", "/dev/null", nullptr) == 0) {
|
|
|
|
log_cmd.push_back("-b");
|
|
|
|
log_cmd.push_back(b[i]);
|
|
|
|
}
|
2018-07-06 01:32:16 +02:00
|
|
|
}
|
2018-07-16 00:42:36 +02:00
|
|
|
chmod("/dev/null", 0666);
|
2018-11-04 09:38:06 +01:00
|
|
|
clear_cmd = log_cmd;
|
|
|
|
log_cmd.push_back("-v");
|
|
|
|
log_cmd.push_back("threadtime");
|
|
|
|
log_cmd.push_back("-s");
|
|
|
|
log_cmd.push_back("am_proc_start");
|
|
|
|
log_cmd.push_back("Magisk");
|
2018-07-17 21:25:36 +02:00
|
|
|
#ifdef MAGISK_DEBUG
|
2018-11-04 09:38:06 +01:00
|
|
|
log_cmd.push_back("*:F");
|
2018-07-17 21:25:36 +02:00
|
|
|
#endif
|
2018-11-04 09:38:06 +01:00
|
|
|
log_cmd.push_back(nullptr);
|
|
|
|
|
|
|
|
clear_cmd.push_back("-c");
|
|
|
|
clear_cmd.push_back(nullptr);
|
2018-07-06 01:32:16 +02:00
|
|
|
|
2018-07-06 01:51:17 +02:00
|
|
|
// Start worker threads
|
|
|
|
pthread_t thread;
|
2018-11-04 09:38:06 +01:00
|
|
|
pthread_create(&thread, nullptr, monitor_thread, nullptr);
|
2018-07-06 01:51:17 +02:00
|
|
|
pthread_detach(thread);
|
2018-11-04 09:38:06 +01:00
|
|
|
xpthread_create(&thread, nullptr, logcat_thread, nullptr);
|
2018-07-06 01:51:17 +02:00
|
|
|
pthread_detach(thread);
|
2017-06-02 22:31:01 +02:00
|
|
|
|
2018-10-28 09:24:53 +01:00
|
|
|
// Handle socket requests
|
|
|
|
struct sockaddr_un sun;
|
|
|
|
socklen_t len = setup_sockaddr(&sun, LOG_SOCKET);
|
|
|
|
int sockfd = xsocket(AF_LOCAL, SOCK_STREAM | SOCK_CLOEXEC, 0);
|
|
|
|
if (xbind(sockfd, (struct sockaddr*) &sun, len))
|
|
|
|
exit(1);
|
|
|
|
xlisten(sockfd, 10);
|
2018-07-06 01:51:17 +02:00
|
|
|
while(1) {
|
2018-11-04 09:38:06 +01:00
|
|
|
int fd = xaccept4(sockfd, nullptr, nullptr, SOCK_CLOEXEC);
|
2018-07-06 01:51:17 +02:00
|
|
|
switch(read_int(fd)) {
|
|
|
|
case HIDE_CONNECT:
|
|
|
|
pthread_mutex_lock(&lock);
|
|
|
|
close(events[HIDE_EVENT].fd);
|
|
|
|
events[HIDE_EVENT].fd = fd;
|
|
|
|
pthread_mutex_unlock(&lock);
|
|
|
|
break;
|
2018-10-28 09:24:53 +01:00
|
|
|
case HANDSHAKE:
|
|
|
|
write_int(fd, HANDSHAKE);
|
2018-07-06 01:51:17 +02:00
|
|
|
default:
|
|
|
|
close(fd);
|
2017-10-08 23:05:52 +02:00
|
|
|
}
|
2018-02-11 19:48:15 +01:00
|
|
|
}
|
2017-04-17 10:36:49 +02:00
|
|
|
}
|
2018-10-12 06:50:47 +02:00
|
|
|
|
2018-11-04 23:23:08 +01:00
|
|
|
bool start_log_daemon() {
|
2018-10-12 06:50:47 +02:00
|
|
|
if (!log_daemon_started) {
|
2018-11-04 09:38:06 +01:00
|
|
|
if (exec_command_sync(MIRRDIR "/system/bin/logcat", "-d", "-f", "/dev/null", nullptr) == 0) {
|
2018-10-12 06:50:47 +02:00
|
|
|
if (fork_dont_care() == 0)
|
|
|
|
log_daemon();
|
2018-11-04 23:23:08 +01:00
|
|
|
log_daemon_started = true;
|
2018-10-28 09:24:53 +01:00
|
|
|
// Wait till we can connect to log_daemon and receive ack
|
2018-10-12 06:50:47 +02:00
|
|
|
int fd = connect_log_daemon();
|
|
|
|
write_int(fd, HANDSHAKE);
|
2018-10-28 09:24:53 +01:00
|
|
|
read_int(fd);
|
2018-10-12 06:50:47 +02:00
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
chmod("/dev/null", 0666);
|
|
|
|
}
|
|
|
|
return log_daemon_started;
|
|
|
|
}
|
|
|
|
|
|
|
|
int connect_log_daemon() {
|
|
|
|
if (!log_daemon_started)
|
|
|
|
return -1;
|
|
|
|
struct sockaddr_un sun;
|
|
|
|
socklen_t len = setup_sockaddr(&sun, LOG_SOCKET);
|
|
|
|
int fd = xsocket(AF_LOCAL, SOCK_STREAM | SOCK_CLOEXEC, 0);
|
|
|
|
while (connect(fd, (struct sockaddr*) &sun, len))
|
|
|
|
usleep(10000);
|
|
|
|
return fd;
|
|
|
|
}
|