# signal

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           signal — signal management
    


## SYNOPSIS



           #include <signal.h>
    
           void (*signal(int _sig_ , void (*_func_)(int)))(int);
    


## DESCRIPTION



           The functionality described on this reference page is aligned with
           the ISO C standard. Any conflict between the requirements
           described here and the ISO C standard is unintentional. This
           volume of POSIX.1‐2017 defers to the ISO C standard.
    
           The _signal_() function chooses one of three ways in which receipt
           of the signal number _sig_ is to be subsequently handled. If the
           value of _func_ is SIG_DFL, default handling for that signal shall
           occur.  If the value of _func_ is SIG_IGN, the signal shall be
           ignored.  Otherwise, the application shall ensure that _func_ points
           to a function to be called when that signal occurs. An invocation
           of such a function because of a signal, or (recursively) of any
           further functions called by that invocation (other than functions
           in the standard library), is called a ``signal handler''.
    
           When a signal occurs, and _func_ points to a function, it is
           implementation-defined whether the equivalent of a:
    
               signal(_sig_ , SIG_DFL);
    
           is executed or the implementation prevents some implementation-
           defined set of signals (at least including _sig_) from occurring
           until the current signal handling has completed. (If the value of
           _sig_ is SIGILL, the implementation may alternatively define that no
           action is taken.) Next the equivalent of:
    
               (*func)(sig);
    
           is executed. If and when the function returns, if the value of _sig_
           was SIGFPE, SIGILL, or SIGSEGV or any other implementation-defined
           value corresponding to a computational exception, the behavior is
           undefined. Otherwise, the program shall resume execution at the
           point it was interrupted. The ISO C standard places a restriction
           on applications relating to the use of _raise_() from signal
           handlers.  This restriction does not apply to POSIX applications,
           as POSIX.1‐2008 requires _raise_() to be async-signal-safe (see
           _Section 2.4.3_ , _Signal Actions_).
    
           If the process is multi-threaded, or if the process is single-
           threaded and a signal handler is executed other than as the result
           of:
    
            *  The process calling _abort_(), _raise_(), _kill_(), _pthread_kill_(),
               or _sigqueue_() to generate a signal that is not blocked
    
            *  A pending signal being unblocked and being delivered before
               the call that unblocked it returns
    
           the behavior is undefined if the signal handler refers to any
           object other than _errno_ with static storage duration other than by
           assigning a value to an object declared as **volatile sig_atomic_t** ,
           or if the signal handler calls any function defined in this
           standard other than one of the functions listed in _Section 2.4_ ,
           _Signal Concepts_.
    
           At program start-up, the equivalent of:
    
               signal(_sig_ , SIG_IGN);
    
           is executed for some signals, and the equivalent of:
    
               signal(_sig_ , SIG_DFL);
    
           is executed for all other signals (see _exec_).
    
           The _signal_() function shall not change the setting of _errno_ if
           successful.
    


## RETURN VALUE



           If the request can be honored, _signal_() shall return the value of
           _func_ for the most recent call to _signal_() for the specified signal
           _sig_.  Otherwise, SIG_ERR shall be returned and a positive value
           shall be stored in _errno_.
    


## ERRORS



           The _signal_() function shall fail if:
    
           **EINVAL** The _sig_ argument is not a valid signal number or an attempt
                  is made to catch a signal that cannot be caught or ignore a
                  signal that cannot be ignored.
    
           The _signal_() function may fail if:
    
           **EINVAL** An attempt was made to set the action to SIG_DFL for a
                  signal that cannot be caught or ignored (or both).
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           The _sigaction_() function provides a more comprehensive and
           reliable mechanism for controlling signals; new applications
           should use _sigaction_() rather than _signal_().
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *