signal.c

Go to the documentation of this file.

 
#include "config.h"
#include <stddef.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include "message.h"
#include "signal2.h"
 
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;
 
void mutt_sig_empty_handler(int sig)
{
}
 
void mutt_sig_exit_handler(int sig)
{
#ifdef HAVE_DECL_SYS_SIGLIST
  printf(_("Caught signal %d (%s) ...  Exiting\n"), sig, sys_siglist[sig]);
#elif (defined(__sun__) && defined(__svr4__))
  printf(_("Caught signal %d (%s) ...  Exiting\n"), sig, _sys_siglist[sig]);
#elif (defined(__alpha) && defined(__osf__))
  printf(_("Caught signal %d (%s) ...  Exiting\n"), sig, __sys_siglist[sig]);
#else
  printf(_("Caught signal %d ...  Exiting\n"), sig);
#endif
  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 };
 
  sigemptyset(&act.sa_mask);
  act.sa_flags = 0;
  act.sa_handler = SIG_IGN;
  sigaction(SIGPIPE, &act, NULL);
 
  act.sa_handler = SegvHandler;
  sigaction(SIGSEGV, &act, NULL);
 
  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);
}