signal.c File Reference

Signal handling. More...

#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"

Include dependency graph for signal.c:

Go to the source code of this file.

Functions
int	endwin (void)
static void	exit_print_uint (unsigned int n)
	AS-safe version of printf("%u", n)
static void	exit_print_int (int n)
	AS-safe version of printf("%d", n)
static void	exit_print_string (const char *str)
	AS-safe version of printf("%s", str)
void	mutt_sig_empty_handler (int sig)
	Dummy signal handler.
void	mutt_sig_exit_handler (int sig)
	Notify the user and shutdown gracefully.
void	mutt_sig_init (sig_handler_t sig_fn, sig_handler_t exit_fn, sig_handler_t segv_fn)
	Initialise the signal handling.
void	mutt_sig_block (void)
	Block signals during critical operations.
void	mutt_sig_unblock (void)
	Restore previously blocked signals.
void	mutt_sig_block_system (void)
	Block signals before calling exec()
void	mutt_sig_unblock_system (bool restore)
	Restore previously blocked signals.
void	mutt_sig_allow_interrupt (bool allow)
	Allow/disallow Ctrl-C (SIGINT)
void	mutt_sig_reset_child_signals (void)
	Reset ignored signals back to the default.
void	assertion_dump (const char *file, int line, const char *func, const char *cond)
	Dump some debugging info before we stop the program.

Variables
static sigset_t	Sigset
	A set of signals used by mutt_sig_block(), mutt_sig_unblock()
static sigset_t	SigsetSys
	A set of signals used by mutt_sig_block_system(), mutt_sig_unblock_system()
static struct sigaction	SysOldInt
	Backup of SIGINT handler, when mutt_sig_block_system() is called.
static struct sigaction	SysOldQuit
	Backup of SIGQUIT handler, when mutt_sig_block_system() is called.
static bool	SignalsBlocked
	true when signals are blocked, e.g.
static bool	SysSignalsBlocked
	true when system signals are blocked, e.g.
static sig_handler_t	SigHandler = mutt_sig_empty_handler
	Function to handle other signals, e.g. SIGINT (2)
static sig_handler_t	ExitHandler = mutt_sig_exit_handler
	Function to handle SIGTERM (15), SIGHUP (1), SIGQUIT (3) signals.
static sig_handler_t	SegvHandler = mutt_sig_exit_handler
	Function to handle SIGSEGV (11) signals.
sig_handler_t	OldSegvHandler = NULL
	Keep the old SEGV handler, it could have been set by ASAN.
volatile sig_atomic_t	SigInt
	true after SIGINT is received
volatile sig_atomic_t	SigWinch
	true after SIGWINCH is received

Detailed Description

Signal handling.

Authors

• Richard Russon

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file signal.c.

Function Documentation

endwin()

int endwin

(

void

)

Here is the caller graph for this function:

exit_print_uint()

static void exit_print_uint ( unsigned int  n )

static

AS-safe version of printf("%u", n)

Parameters

n	Number to be printed

Definition at line 76 of file signal.c.

{
  char digit;
 
  if (n > 9)
    exit_print_uint(n / 10);
 
  digit = '0' + (n % 10);
 
  if (write(STDOUT_FILENO, &digit, 1) == -1)
  {
    // do nothing
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

exit_print_int()

static void exit_print_int ( int  n )

static

AS-safe version of printf("%d", n)

Parameters

n	Number to be printed

Definition at line 95 of file signal.c.

{
  if (n < 0)
  {
    if (write(STDOUT_FILENO, "-", 1) == -1)
    {
      // do nothing
    }
 
    n = -n;
  }
  exit_print_uint(n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

exit_print_string()

static void exit_print_string ( const char *  str )

static

AS-safe version of printf("%s", str)

Parameters

str	String to be printed

Definition at line 113 of file signal.c.

{
  if (!str)
    return;
 
  if (write(STDOUT_FILENO, str, strlen(str)) == -1)
  {
    // do nothing
  }
}

Here is the caller graph for this function:

mutt_sig_empty_handler()

void mutt_sig_empty_handler

(

int

sig

)

Dummy signal handler.

Parameters

sig	Signal number, e.g. SIGINT

Useful for signals that we can't ignore, or don't want to do anything with.

Definition at line 131 of file signal.c.

{
}

Here is the caller graph for this function:

mutt_sig_exit_handler()

void mutt_sig_exit_handler

(

int

sig

)

Notify the user and shutdown gracefully.

Parameters

sig	Signal number, e.g. SIGINT

Definition at line 139 of file signal.c.

{
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_sig_init()

void mutt_sig_init	(	sig_handler_t	sig_fn,
		sig_handler_t	exit_fn,
		sig_handler_t	segv_fn
	)

Initialise the signal handling.

Parameters

sig_fn	Function to handle signals
exit_fn	Function to call on uncaught signals
segv_fn	Function to call on a segfault (Segmentation Violation)

Set up handlers to ignore or catch signals of interest. We use three handlers for the signals we want to catch, ignore, or exit.

Definition at line 164 of file signal.c.

{
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_sig_block()

void mutt_sig_block

(

void

)

Block signals during critical operations.

It's important that certain signals don't interfere with critical operations. Call mutt_sig_unblock() to restore the signals' behaviour.

Definition at line 228 of file signal.c.

{
  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;
}

Here is the caller graph for this function:

mutt_sig_unblock()

void mutt_sig_unblock

(

void

)

Restore previously blocked signals.

Definition at line 246 of file signal.c.

{
  if (!SignalsBlocked)
    return;
 
  sigprocmask(SIG_UNBLOCK, &Sigset, 0);
  SignalsBlocked = false;
}

Here is the caller graph for this function:

mutt_sig_block_system()

void mutt_sig_block_system

(

void

)

Block signals before calling exec()

It's important that certain signals don't interfere with the child process. Call mutt_sig_unblock_system() to restore the signals' behaviour.

Definition at line 261 of file signal.c.

{
  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;
}

Here is the caller graph for this function:

mutt_sig_unblock_system()

void mutt_sig_unblock_system

(

bool

restore

)

Restore previously blocked signals.

Parameters

restore

If true, restore previous SIGINT, SIGQUIT behaviour

Definition at line 285 of file signal.c.

{
  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;
}

Here is the caller graph for this function:

mutt_sig_allow_interrupt()

void mutt_sig_allow_interrupt

(

bool

allow

)

Allow/disallow Ctrl-C (SIGINT)

Parameters

allow

True to allow Ctrl-C to interrupt signals

Allow the user to interrupt some long operations.

Definition at line 316 of file signal.c.

{
  struct sigaction sa = { 0 };
 
  sa.sa_handler = SigHandler;
#ifdef SA_RESTART
  if (!allow)
    sa.sa_flags |= SA_RESTART;
#endif
  sigaction(SIGINT, &sa, NULL);
}

Here is the caller graph for this function:

mutt_sig_reset_child_signals()

void mutt_sig_reset_child_signals

(

void

)

Reset ignored signals back to the default.

See sigaction(2): A child created via fork(2) inherits a copy of its parent's signal dispositions. During an execve(2), the dispositions of handled signals are reset to the default; the dispositions of ignored signals are left unchanged.

Definition at line 337 of file signal.c.

{
  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);
}

Here is the caller graph for this function:

assertion_dump()

void assertion_dump	(	const char *	file,
		int	line,
		const char *	func,
		const char *	cond
	)

Dump some debugging info before we stop the program.

Parameters

file	Source file
line	Line of source
func	Function
cond	Assertion condition

Definition at line 362 of file signal.c.

{
  endwin();
  show_backtrace();
  printf("%s:%d:%s() -- assertion failed (%s)\n", file, line, func, cond);
}

Here is the call graph for this function:

Variable Documentation

Sigset

sigset_t Sigset

static

A set of signals used by mutt_sig_block(), mutt_sig_unblock()

Definition at line 42 of file signal.c.

SigsetSys

sigset_t SigsetSys

static

A set of signals used by mutt_sig_block_system(), mutt_sig_unblock_system()

Definition at line 44 of file signal.c.

SysOldInt

struct sigaction SysOldInt

static

Backup of SIGINT handler, when mutt_sig_block_system() is called.

Definition at line 47 of file signal.c.

SysOldQuit

struct sigaction SysOldQuit

static

Backup of SIGQUIT handler, when mutt_sig_block_system() is called.

Definition at line 49 of file signal.c.

SignalsBlocked

bool SignalsBlocked

static

true when signals are blocked, e.g.

SIGTERM, SIGHUP

See also

mutt_sig_block(), mutt_sig_unblock()

Definition at line 53 of file signal.c.

SysSignalsBlocked

bool SysSignalsBlocked

static

true when system signals are blocked, e.g.

SIGINT, SIGQUIT

See also

mutt_sig_block_system(), mutt_sig_unblock_system()

Definition at line 57 of file signal.c.

SigHandler

sig_handler_t SigHandler = mutt_sig_empty_handler

static

Function to handle other signals, e.g. SIGINT (2)

Definition at line 60 of file signal.c.

ExitHandler

sig_handler_t ExitHandler = mutt_sig_exit_handler

static

Function to handle SIGTERM (15), SIGHUP (1), SIGQUIT (3) signals.

Definition at line 62 of file signal.c.

SegvHandler

sig_handler_t SegvHandler = mutt_sig_exit_handler

static

Function to handle SIGSEGV (11) signals.

Definition at line 64 of file signal.c.

OldSegvHandler

sig_handler_t OldSegvHandler = NULL

Keep the old SEGV handler, it could have been set by ASAN.

Old SEGV handler, it could have been set by ASAN.

Definition at line 67 of file signal.c.

SigInt

volatile sig_atomic_t SigInt

true after SIGINT is received

Definition at line 69 of file signal.c.

SigWinch

volatile sig_atomic_t SigWinch

true after SIGWINCH is received

Definition at line 70 of file signal.c.