signal.c

Go to the documentation of this file.

 
#include "config.h"
#include <signal.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "signal2.h"
 
int endwin(void);
 
static sigset_t Sigset;
static sigset_t SigsetSys;
 
static struct sigaction SysOldInt;
static struct sigaction SysOldQuit;
 
static bool SignalsBlocked;
 
static bool SysSignalsBlocked;
 
static sig_handler_t SigHandler = mutt_sig_empty_handler;
static sig_handler_t ExitHandler = mutt_sig_exit_handler;
static sig_handler_t SegvHandler = mutt_sig_exit_handler;
 
sig_handler_t OldSegvHandler = NULL;
 
volatile sig_atomic_t SigInt;   
volatile sig_atomic_t SigWinch; 
 
static void exit_print_uint(unsigned int n)
{
  char digit;
 
  if (n > 9)
    exit_print_uint(n / 10);
 
  digit = '0' + (n % 10);
 
  if (write(STDOUT_FILENO, &digit, 1) == -1)
  {
    // do nothing
  }
}
 
static void exit_print_int(int n)
{
  if (n < 0)
  {
    if (write(STDOUT_FILENO, "-", 1) == -1)
    {
      // do nothing
    }
 
    n = -n;
  }
  exit_print_uint(n);
}
 
static void exit_print_string(const char *str)
{
  if (!str)
    return;
 
  if (write(STDOUT_FILENO, str, strlen(str)) == -1)
  {
    // do nothing
  }
}
 
void mutt_sig_empty_handler(int sig)
{
}
 
void mutt_sig_exit_handler(int sig)
{
  exit_print_string("Caught signal ");
  exit_print_int(sig);
  exit_print_string(" ");
#ifdef HAVE_DECL_SYS_SIGLIST
  exit_print_string(sys_siglist[sig]);
#elif (defined(__sun__) && defined(__svr4__))
  exit_print_string(_sys_siglist[sig]);
#elif (defined(__alpha) && defined(__osf__))
  exit_print_string(__sys_siglist[sig]);
#endif
  exit_print_string("...  Exiting\n");
  exit(0);
}
 
void mutt_sig_init(sig_handler_t sig_fn, sig_handler_t exit_fn, sig_handler_t segv_fn)
{
  if (sig_fn)
    SigHandler = sig_fn;
 
  if (exit_fn)
    ExitHandler = exit_fn;
 
  if (segv_fn)
    SegvHandler = segv_fn;
 
  struct sigaction act = { 0 };
  struct sigaction old_act = { 0 };
 
  sigemptyset(&act.sa_mask);
  act.sa_flags = 0;
  act.sa_handler = SIG_IGN;
  sigaction(SIGPIPE, &act, NULL);
 
  act.sa_handler = SegvHandler;
  sigaction(SIGSEGV, &act, &old_act);
  OldSegvHandler = old_act.sa_handler;
 
  act.sa_handler = ExitHandler;
  sigaction(SIGTERM, &act, NULL);
  sigaction(SIGHUP, &act, NULL);
  sigaction(SIGQUIT, &act, NULL);
 
  /* we want to avoid race conditions */
  sigaddset(&act.sa_mask, SIGTSTP);
 
  act.sa_handler = SigHandler;
 
  /* we want SIGALRM to abort the current syscall, so we do this before
   * setting the SA_RESTART flag below.  currently this is only used to
   * timeout on a connect() call in a reasonable amount of time. */
  sigaction(SIGALRM, &act, NULL);
 
/* we also don't want to mess with interrupted system calls */
#ifdef SA_RESTART
  act.sa_flags = SA_RESTART;
#endif
 
  sigaction(SIGCONT, &act, NULL);
  sigaction(SIGTSTP, &act, NULL);
  sigaction(SIGINT, &act, NULL);
  sigaction(SIGWINCH, &act, NULL);
 
  /* POSIX doesn't allow us to ignore SIGCHLD,
   * so we just install a dummy handler for it */
  act.sa_handler = mutt_sig_empty_handler;
  /* don't need to block any other signals here */
  sigemptyset(&act.sa_mask);
  /* we don't want to mess with stopped children */
  act.sa_flags |= SA_NOCLDSTOP;
  sigaction(SIGCHLD, &act, NULL);
}
 
void mutt_sig_block(void)
{
  if (SignalsBlocked)
    return;
 
  sigemptyset(&Sigset);
  sigaddset(&Sigset, SIGTERM);
  sigaddset(&Sigset, SIGHUP);
  sigaddset(&Sigset, SIGTSTP);
  sigaddset(&Sigset, SIGINT);
  sigaddset(&Sigset, SIGWINCH);
  sigprocmask(SIG_BLOCK, &Sigset, 0);
  SignalsBlocked = true;
}
 
void mutt_sig_unblock(void)
{
  if (!SignalsBlocked)
    return;
 
  sigprocmask(SIG_UNBLOCK, &Sigset, 0);
  SignalsBlocked = false;
}
 
void mutt_sig_block_system(void)
{
  if (SysSignalsBlocked)
    return;
 
  struct sigaction sa = { 0 };
 
  /* POSIX: ignore SIGINT and SIGQUIT & block SIGCHLD before exec */
  sa.sa_handler = SIG_IGN;
  sa.sa_flags = 0;
  sigemptyset(&sa.sa_mask);
  sigaction(SIGINT, &sa, &SysOldInt);
  sigaction(SIGQUIT, &sa, &SysOldQuit);
 
  sigemptyset(&SigsetSys);
  sigaddset(&SigsetSys, SIGCHLD);
  sigprocmask(SIG_BLOCK, &SigsetSys, 0);
  SysSignalsBlocked = true;
}
 
void mutt_sig_unblock_system(bool restore)
{
  if (!SysSignalsBlocked)
    return;
 
  sigprocmask(SIG_UNBLOCK, &SigsetSys, NULL);
  if (restore)
  {
    sigaction(SIGQUIT, &SysOldQuit, NULL);
    sigaction(SIGINT, &SysOldInt, NULL);
  }
  else
  {
    struct sigaction sa = { 0 };
 
    sa.sa_handler = SIG_DFL;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sigaction(SIGQUIT, &sa, NULL);
    sigaction(SIGINT, &sa, NULL);
  }
 
  SysSignalsBlocked = false;
}
 
void mutt_sig_allow_interrupt(bool allow)
{
  struct sigaction sa = { 0 };
 
  sa.sa_handler = SigHandler;
#ifdef SA_RESTART
  if (!allow)
    sa.sa_flags |= SA_RESTART;
#endif
  sigaction(SIGINT, &sa, NULL);
}
 
void mutt_sig_reset_child_signals(void)
{
  struct sigaction sa = { 0 };
 
  sa.sa_handler = SIG_DFL;
  sa.sa_flags = 0;
  sigemptyset(&sa.sa_mask);
 
  /* These signals are set to SIG_IGN and must be reset */
  sigaction(SIGPIPE, &sa, NULL);
 
  /* These technically don't need to be reset, but the code has been
   * doing so for a long time. */
  sigaction(SIGTERM, &sa, NULL);
  sigaction(SIGTSTP, &sa, NULL);
  sigaction(SIGCONT, &sa, NULL);
}
 
void assertion_dump(const char *file, int line, const char *func, const char *cond)
{
  endwin();
  show_backtrace();
  printf("%s:%d:%s() -- assertion failed (%s)\n", file, line, func, cond);
}