# signal

## NAME



           signal - ANSI C signal handling
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <signal.h>**
    
           **typedef typeof(void (int))  *sighandler_t;**
    
           **sighandler_t signal(int** _signum_**, sighandler_t** _handler_**);**
    


## DESCRIPTION



           **WARNING** : the behavior of **signal**() varies across UNIX versions, and
           has also varied historically across different versions of Linux.
           **Avoid its use** : use sigaction(2) instead.  See _Portability_ below.
    
           **signal**() sets the disposition of the signal _signum_ to _handler_ ,
           which is either **SIG_IGN** , **SIG_DFL** , or the address of a programmer-
           defined function (a "signal handler").
    
           If the signal _signum_ is delivered to the process, then one of the
           following happens:
    
           *  If the disposition is set to **SIG_IGN** , then the signal is
              ignored.
    
           *  If the disposition is set to **SIG_DFL** , then the default action
              associated with the signal (see signal(7)) occurs.
    
           *  If the disposition is set to a function, then first either the
              disposition is reset to **SIG_DFL** , or the signal is blocked (see
              _Portability_ below), and then _handler_ is called with argument
              _signum_.  If invocation of the handler caused the signal to be
              blocked, then the signal is unblocked upon return from the
              handler.
    
           The signals **SIGKILL** and **SIGSTOP** cannot be caught or ignored.
    


## RETURN VALUE



           **signal**() returns the previous value of the signal handler.  On
           failure, it returns **SIG_ERR** , and _errno_ is set to indicate the
           error.
    


## ERRORS



           **EINVAL** _signum_ is invalid.
    


## VERSIONS



           The use of _sighandler_t_ is a GNU extension, exposed if **_GNU_SOURCE**
           is defined; glibc also defines (the BSD-derived) _sig_t_ if
           **_BSD_SOURCE**(glibc 2.19 and earlier) or **_DEFAULT_SOURCE**(glibc
           2.19 and later) is defined.  The standard definition of **signal**()
           is:
    
               **typeof(void (int)) *signal(int** _signum_**, typeof(void (int)) ***_handler_**);**
    
       **Portability**
           The only portable use of **signal**() is to set a signal's disposition
           to **SIG_DFL** or **SIG_IGN**.  The semantics when using **signal**() to
           establish a signal handler vary across systems (and POSIX.1
           explicitly permits this variation); **do not use it for this**
           **purpose.**
    
           POSIX.1 solved the portability mess by specifying sigaction(2),
           which provides explicit control of the semantics when a signal
           handler is invoked; use that interface instead of **signal**().
    


## STANDARDS



           C11, POSIX.1-2008.
    


## NOTES



           The effects of **signal**() in a multithreaded process are
           unspecified.
    
           According to POSIX, the behavior of a process is undefined after
           it ignores a **SIGFPE** , **SIGILL** , or **SIGSEGV** signal that was not
           generated by kill(2) or raise(3).  Integer division by zero has
           undefined result.  On some architectures it will generate a **SIGFPE**
           signal.  (Also dividing the most negative integer by -1 may
           generate **SIGFPE**.)  Ignoring this signal might lead to an endless
           loop.
    
           See sigaction(2) for details on what happens when the disposition
           **SIGCHLD** is set to **SIG_IGN**.
    
           See signal-safety(7) for a list of the async-signal-safe functions
           that can be safely called from inside a signal handler.
    


* * *