signal2.h File Reference

Signal handling. More...

#include "config.h"
#include <signal.h>
#include <stdbool.h>

Include dependency graph for signal2.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	ASSERT_STOP   (*(volatile int *) 0 = 0)
#define	ASSERT(COND)

Typedefs
typedef void(*	sig_handler_t) (int sig)

Functions
static void	show_backtrace (void)
void	assertion_dump (const char *file, int line, const char *func, const char *cond)
	Dump some debugging info before we stop the program.
void	mutt_sig_allow_interrupt (bool allow)
	Allow/disallow Ctrl-C (SIGINT)
void	mutt_sig_block (void)
	Block signals during critical operations.
void	mutt_sig_block_system (void)
	Block signals before calling exec()
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_reset_child_signals (void)
	Reset ignored signals back to the default.
void	mutt_sig_unblock (void)
	Restore previously blocked signals.
void	mutt_sig_unblock_system (bool restore)
	Restore previously blocked signals.

Variables
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 signal2.h.

Macro Definition Documentation

ASSERT_STOP

#define ASSERT_STOP   (*(volatile int *) 0 = 0)

Definition at line 56 of file signal2.h.

ASSERT

#define ASSERT

(

COND

)

Value:

  do                                                                           \
  {                                                                            \
    if (!(COND))                                                               \
    {                                                                          \
      assertion_dump(__FILE__, __LINE__, __func__, #COND);                     \
      ASSERT_STOP;                                                             \
    }                                                                          \
  } while (false);

Definition at line 58 of file signal2.h.

Typedef Documentation

sig_handler_t

typedef void(* sig_handler_t) (int sig)

Definition at line 46 of file signal2.h.

Function Documentation

show_backtrace()

static void show_backtrace ( void  )

inlinestatic

Definition at line 33 of file signal2.h.

{} // LCOV_EXCL_LINE

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 346 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:

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 300 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_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 212 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_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 245 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_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 117 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 125 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 150 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 };
 
  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);
}

Here is the call graph for this function:

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 321 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:

mutt_sig_unblock()

void mutt_sig_unblock

(

void

)

Restore previously blocked signals.

Definition at line 230 of file signal.c.

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

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 269 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:

Variable Documentation

SigInt

volatile sig_atomic_t SigInt

extern

true after SIGINT is received

Definition at line 66 of file signal.c.

SigWinch

volatile sig_atomic_t SigWinch

extern

true after SIGWINCH is received

Definition at line 67 of file signal.c.