fix non-signal-safe exit, and refactor signal handlers

5 files changed, 246 insertions, 0 deletions

diff --git a/src/signal/misc.cc b/src/signal/misc.cc
new file mode 100644
index 0000000..e8b780e
--- /dev/null
+++ b/src/signal/misc.cc
@@ -0,0 +1,61 @@
+#include "signal_handler.h"
+
+#include <errno.h>
+
+namespace ov4
+{
+
+void signal_init()
+{
+    /* Install the signal handlers */
+    
+    sigemptyset(&block_job);
+    sigemptyset(&block_sig_TTOU);
+    sigemptyset(&block_io);
+
+    sigaddset(&block_job, SIGINT);
+    sigaddset(&block_job, SIGTSTP);
+    sigaddset(&block_job, SIGCHLD);
+    
+    sigaddset(&block_sig_TTOU, SIGTTOU);
+
+    sigaddset(&block_io, SIGTTOU);
+    sigaddset(&block_io, SIGTTIN);
+
+    Signal(SIGINT,  sigint_handler);   /* ctrl-c */
+    Signal(SIGTSTP, sigtstp_handler);  /* ctrl-z */
+    Signal(SIGCHLD, sigchld_handler);  /* Terminated or stopped child */
+
+    /* This one provides a clean way to kill the shell */
+    Signal(SIGQUIT, sigquit_handler); 
+}
+
+/*
+ * Signal - wrapper for the sigaction function
+ */
+handler_t *Signal([[maybe_unused]] int signum, handler_t *handler) 
+{
+    struct sigaction action, old_action;
+
+    action.sa_handler = handler;  
+    sigemptyset(&action.sa_mask); /* block sigs of type being handled */
+    action.sa_flags = SA_RESTART; /* restart syscalls if possible */
+
+    if (sigaction(signum, &action, &old_action) < 0)
+	unix_error("Signal error");
+    return (old_action.sa_handler);
+}
+
+int block_all(sigset_t *prev)
+{
+    sigset_t set;
+    sigfillset(&set);
+    return sigprocmask(SIG_SETMASK, &set, prev);
+}
+
+int block_handler(sigset_t *prev)
+{
+    return sigprocmask(SIG_BLOCK, &block_job, prev);
+}
+
+}
\ No newline at end of file
diff --git a/src/signal/sigchld_handler.cc b/src/signal/sigchld_handler.cc
new file mode 100644
index 0000000..e11ed26
--- /dev/null
+++ b/src/signal/sigchld_handler.cc
@@ -0,0 +1,99 @@
+#include "signal_handler.h"
+
+#include <errno.h>
+
+namespace ov4
+{
+
+/* 
+ * sigchld_handler - The kernel sends a SIGCHLD to the shell whenever
+ *     a child job terminates (becomes a zombie), or stops because it
+ *     received a SIGSTOP or SIGTSTP signal. The handler reaps all
+ *     available zombie children, but doesn't wait for any other
+ *     currently running children to terminate.  
+ */
+void sigchld_handler([[maybe_unused]] int sig) 
+{
+    int errno_backup = errno;
+
+    sigset_t prev;
+    block_handler(&prev);
+
+    int status, pid;
+    safe_debug("SIGCHLD\n");
+
+    while ((pid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0)
+    {
+        // signal'd or stopped or normally quit
+        // print terminated/stopped message
+        if (WIFSIGNALED(status) || WIFSTOPPED(status))
+        {
+            int jid = pid2jid(pid);
+            safe_output("Job [", jid, "] (", pid, ") ");
+            if (!WIFSTOPPED(status) && WTERMSIG(status) == SIGINT)
+                safe_print("terminated");
+            else if (WIFSTOPPED(status))
+                safe_print("stopped");
+            else 
+                safe_print("idk");
+            safe_print(" by signal ");
+            if (WIFSTOPPED(status))
+                safe_print(WSTOPSIG(status));
+            else
+                safe_print(WTERMSIG(status));
+            safe_print("\n");
+        } 
+
+        // handle job table
+        // and save exit/signal code
+
+        // stopped
+        if (WIFSTOPPED(status))
+        {
+            safe_output("Process suspended PID: ", pid, "\n");
+            sigset_t prev_inner;
+            block_all(&prev_inner);
+            job_suspend(pid);
+            sigprocmask(SIG_SETMASK, &prev_inner, nullptr);
+        }
+        // other type of signal'd
+        // or normally quit
+        else {
+            safe_output("Process terminated PID: ", pid, "\n");
+            sigset_t prev_inner;
+            block_all(&prev_inner);
+            deletejob(pid);
+            sigprocmask(SIG_SETMASK, &prev_inner, nullptr);
+
+            // terminated normally
+            // so that exit code should be available
+            if (WIFEXITED(status))
+            {
+                safe_output("Exit code: ", WEXITSTATUS(status), "\n");
+                if (pid == exit_required_pid)
+                {
+                    exit_code = WEXITSTATUS(status);
+                    safe_logger("sigchld_handler: required PID detected: ", pid, "\n");
+                }
+            }
+            // if signal'd
+            else if (WIFSIGNALED(status))
+            {
+                safe_output("Signal code: ", WTERMSIG(status), "\n");
+                if (pid == exit_required_pid)
+                {
+                    exit_code = SIGNAL_EXIT_CODE_BASE + WTERMSIG(status);
+                    safe_logger("sigchld_handler: required PID detected: ", pid, "\n");
+                }
+            }
+
+        }
+    }
+
+    sigprocmask(SIG_SETMASK, &prev, nullptr);
+
+    errno = errno_backup;
+    return;
+}
+
+}
\ No newline at end of file
diff --git a/src/signal/sigint_handler.cc b/src/signal/sigint_handler.cc
new file mode 100644
index 0000000..706c041
--- /dev/null
+++ b/src/signal/sigint_handler.cc
@@ -0,0 +1,37 @@
+#include "signal_handler.h"
+
+#include <errno.h>
+#include <termios.h>
+#include <sys/ioctl.h>
+
+namespace ov4
+{
+
+/* 
+ * sigint_handler - The kernel sends a SIGINT to the shell whenver the
+ *    user types ctrl-c at the keyboard.  Catch it and send it along
+ *    to the foreground job.  
+ */
+void sigint_handler([[maybe_unused]] int sig) 
+{
+    int errno_backup = errno;
+
+    sigset_t prev;
+    block_handler(&prev);
+
+    int pid = fgpid();
+    if (pid != 0)
+    {
+        kill(-pid, SIGINT);
+    } else {
+        tcflush(STDIN_FILENO, TCIFLUSH);
+        ioctl(STDIN_FILENO, TIOCSTI, "\n");
+    }
+
+    sigprocmask(SIG_SETMASK, &prev, nullptr);
+
+    errno = errno_backup;
+    return;
+}
+
+}
\ No newline at end of file
diff --git a/src/signal/sigquit_handler b/src/signal/sigquit_handler
new file mode 100644
index 0000000..73296eb
--- /dev/null
+++ b/src/signal/sigquit_handler
@@ -0,0 +1,17 @@
+#include "signal_handler.h"
+
+#include <errno.h>
+
+namespace ov4
+{
+
+void sigquit_handler([[maybe_unused]] int sig) 
+{
+    //printf("Terminating after receipt of SIGQUIT signal\n");
+    safe_output("Terminating after receipt of SIGQUIT signal\n");
+    // UNDERSCORE'd version should be safe
+    // but exit() is unsafe
+    _exit(1);
+}
+
+}
\ No newline at end of file
diff --git a/src/signal/sigtstp_handler.cc b/src/signal/sigtstp_handler.cc
new file mode 100644
index 0000000..7b32d31
--- /dev/null
+++ b/src/signal/sigtstp_handler.cc
@@ -0,0 +1,32 @@
+#include "signal_handler.h"
+
+#include <errno.h>
+
+namespace ov4
+{
+
+/*
+ * sigtstp_handler - The kernel sends a SIGTSTP to the shell whenever
+ *     the user types ctrl-z at the keyboard. Catch it and suspend the
+ *     foreground job by sending it a SIGTSTP.  
+ */
+void sigtstp_handler([[maybe_unused]] int sig) 
+{
+    int errno_backup = errno;
+
+    sigset_t prev;
+    block_handler(&prev);
+
+    int pid = fgpid();
+    if (pid != 0)
+    {
+        kill(-pid, SIGTSTP);
+    }
+
+    sigprocmask(SIG_SETMASK, &prev, nullptr);
+
+    errno = errno_backup;
+    return;
+}
+
+}
\ No newline at end of file