Refactoring

src/util/common.c

@@ -34,6 +34,7 @@
 #include "../server.h"
 #include <sys/wait.h>
 #include <sys/types.h>
+#include <pwd.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/time.h>
@@ -44,7 +45,162 @@
 #include <librsvg/rsvg.h>
 #endif
 
+#ifdef ENABLE_LIBUNWIND
+#define UNW_LOCAL_ONLY
+#include <libunwind.h>
+#else
+#ifdef ENABLE_EXECINFO
+#include <execinfo.h>
+#endif
+#endif
+
 #include "../panel.h"
+#include "timer.h"
+
+void write_string(int fd, const char *s)
+{
+    int len = strlen(s);
+    while (len > 0) {
+        int count = write(fd, s, len);
+        if (count >= 0) {
+            s += count;
+            len -= count;
+        } else {
+            break;
+        }
+    }
+}
+
+void log_string(int fd, const char *s)
+{
+    write_string(2, s);
+    write_string(fd, s);
+}
+
+void dump_backtrace(int log_fd)
+{
+#ifndef DISABLE_BACKTRACE
+    log_string(log_fd, "\n" YELLOW "Backtrace:" RESET "\n");
+
+#ifdef ENABLE_LIBUNWIND
+    unw_cursor_t cursor;
+    unw_context_t context;
+    unw_getcontext(&context);
+    unw_init_local(&cursor, &context);
+
+    while (unw_step(&cursor) > 0) {
+        unw_word_t offset;
+        char fname[128];
+        fname[0] = '\0';
+        (void)unw_get_proc_name(&cursor, fname, sizeof(fname), &offset);
+        log_string(log_fd, fname);
+        log_string(log_fd, "\n");
+    }
+#else
+#ifdef ENABLE_EXECINFO
+#define MAX_TRACE_SIZE 128
+    void *array[MAX_TRACE_SIZE];
+    size_t size = backtrace(array, MAX_TRACE_SIZE);
+    char **strings = backtrace_symbols(array, size);
+
+    for (size_t i = 0; i < size; i++) {
+        log_string(log_fd, strings[i]);
+        log_string(log_fd, "\n");
+    }
+
+    free(strings);
+#endif // ENABLE_EXECINFO
+#endif // ENABLE_LIBUNWIND
+#endif // DISABLE_BACKTRACE
+}
+
+// sleep() returns early when signals arrive. This function does not.
+void safe_sleep(int seconds)
+{
+    double t0 = get_time();
+    while (1) {
+        double t = get_time();
+        if (t > t0 + seconds)
+            return;
+        sleep(1);
+    }
+}
+
+const char *signal_name(int sig)
+{
+    switch (sig) {
+    case SIGHUP:
+        return "SIGHUP: Hangup (POSIX).";
+    case SIGINT:
+        return "SIGINT: Interrupt (ANSI).";
+    case SIGQUIT:
+        return "SIGQUIT: Quit (POSIX).";
+    case SIGILL:
+        return "SIGILL: Illegal instruction (ANSI).";
+    case SIGTRAP:
+        return "SIGTRAP: Trace trap (POSIX).";
+    case SIGABRT:
+        return "SIGABRT/SIGIOT: Abort (ANSI) / IOT trap (4.2 BSD).";
+    case SIGBUS:
+        return "SIGBUS: BUS error (4.2 BSD).";
+    case SIGFPE:
+        return "SIGFPE: Floating-point exception (ANSI).";
+    case SIGKILL:
+        return "SIGKILL: Kill, unblockable (POSIX).";
+    case SIGUSR1:
+        return "SIGUSR1: User-defined signal 1 (POSIX).";
+    case SIGSEGV:
+        return "SIGSEGV: Segmentation violation (ANSI).";
+    case SIGUSR2:
+        return "SIGUSR2: User-defined signal 2 (POSIX).";
+    case SIGPIPE:
+        return "SIGPIPE: Broken pipe (POSIX).";
+    case SIGALRM:
+        return "SIGALRM: Alarm clock (POSIX).";
+    case SIGTERM:
+        return "SIGTERM: Termination (ANSI).";
+    // case SIGSTKFLT: return "SIGSTKFLT: Stack fault.";
+    case SIGCHLD:
+        return "SIGCHLD: Child status has changed (POSIX).";
+    case SIGCONT:
+        return "SIGCONT: Continue (POSIX).";
+    case SIGSTOP:
+        return "SIGSTOP: Stop, unblockable (POSIX).";
+    case SIGTSTP:
+        return "SIGTSTP: Keyboard stop (POSIX).";
+    case SIGTTIN:
+        return "SIGTTIN: Background read from tty (POSIX).";
+    case SIGTTOU:
+        return "SIGTTOU: Background write to tty (POSIX).";
+    case SIGURG:
+        return "SIGURG: Urgent condition on socket (4.2 BSD).";
+    case SIGXCPU:
+        return "SIGXCPU: CPU limit exceeded (4.2 BSD).";
+    case SIGXFSZ:
+        return "SIGXFSZ: File size limit exceeded (4.2 BSD).";
+    case SIGVTALRM:
+        return "SIGVTALRM: Virtual alarm clock (4.2 BSD).";
+    case SIGPROF:
+        return "SIGPROF: Profiling alarm clock (4.2 BSD).";
+    // case SIGPWR: return "SIGPWR: Power failure restart (System V).";
+    case SIGSYS:
+        return "SIGSYS: Bad system call.";
+    }
+    static char s[64];
+    sprintf(s, "SIG=%d: Unknown", sig);
+    return s;
+}
+
+const char *get_home_dir()
+{
+    const char *s = getenv("HOME");
+    if (s)
+        return s;
+    struct passwd *pw = getpwuid(getuid());
+    if (!pw)
+        return NULL;
+    return pw->pw_dir;
+}
 
 void copy_file(const char *path_src, const char *path_dest)
 {