signal2.h File Reference

Signal handling. More...

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

Typedefs
typedef void(*	sig_handler_t) (int sig)

Functions
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_unblock (void)
	Restore previously blocked signals.
void	mutt_sig_unblock_system (bool restore)
	Restore previously blocked signals.

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.

Typedef Documentation

sig_handler_t

typedef void(* sig_handler_t) (int sig)

Definition at line 35 of file signal2.h.

Function Documentation

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 251 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 163 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 196 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 70 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 78 of file signal.c.

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

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 101 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_unblock()

void mutt_sig_unblock

(

void

)

Restore previously blocked signals.

Definition at line 181 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 220 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: