# sigvec

## NAME



           sigvec, sigblock, sigsetmask, siggetmask, sigmask - BSD signal API
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <signal.h>**
    
           **[[deprecated]] int sigvec(int** _sig_**, const struct sigvec ***_vec_**,**
                                     **struct sigvec ***_ovec_**);**
    
           **[[deprecated]] int sigmask(int** _signum_**);**
    
           **[[deprecated]] int sigblock(int** _mask_**);**
           **[[deprecated]] int sigsetmask(int** _mask_**);**
           **[[deprecated]] int siggetmask(void);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           All functions shown above:
               Since glibc 2.19:
                   _DEFAULT_SOURCE
               glibc 2.19 and earlier:
                   _BSD_SOURCE
    


## DESCRIPTION



           These functions are provided in glibc as a compatibility interface
           for programs that make use of the historical BSD signal API.  This
           API is obsolete: new applications should use the POSIX signal API
           (sigaction(2), sigprocmask(2), etc.).
    
           The **sigvec**() function sets and/or gets the disposition of the
           signal _sig_ (like the POSIX sigaction(2)).  If _vec_ is not NULL, it
           points to a _sigvec_ structure that defines the new disposition for
           _sig_.  If _ovec_ is not NULL, it points to a _sigvec_ structure that is
           used to return the previous disposition of _sig_.  To obtain the
           current disposition of _sig_ without changing it, specify NULL for
           _vec_ , and a non-null pointer for _ovec_.
    
           The dispositions for **SIGKILL** and **SIGSTOP** cannot be changed.
    
           The _sigvec_ structure has the following form:
    
               struct sigvec {
                   void (*sv_handler)(int); /* Signal disposition */
                   int    sv_mask;          /* Signals to be blocked in handler */
                   int    sv_flags;         /* Flags */
               };
    
           The _sv_handler_ field specifies the disposition of the signal, and
           is either: the address of a signal handler function; **SIG_DFL** ,
           meaning the default disposition applies for the signal; or
           **SIG_IGN** , meaning that the signal is ignored.
    
           If _sv_handler_ specifies the address of a signal handler, then
           _sv_mask_ specifies a mask of signals that are to be blocked while
           the handler is executing.  In addition, the signal for which the
           handler is invoked is also blocked.  Attempts to block **SIGKILL** or
           **SIGSTOP** are silently ignored.
    
           If _sv_handler_ specifies the address of a signal handler, then the
           _sv_flags_ field specifies flags controlling what happens when the
           handler is called.  This field may contain zero or more of the
           following flags:
    
           **SV_INTERRUPT**
                  If the signal handler interrupts a blocking system call,
                  then upon return from the handler the system call is not
                  restarted: instead it fails with the error **EINTR**.  If this
                  flag is not specified, then system calls are restarted by
                  default.
    
           **SV_RESETHAND**
                  Reset the disposition of the signal to the default before
                  calling the signal handler.  If this flag is not specified,
                  then the handler remains established until explicitly
                  removed by a later call to **sigvec**() or until the process
                  performs an execve(2).
    
           **SV_ONSTACK**
                  Handle the signal on the alternate signal stack
                  (historically established under BSD using the obsolete
                  **sigstack**() function; the POSIX replacement is
                  sigaltstack(2)).
    
           The **sigmask**() macro constructs and returns a "signal mask" for
           _signum_.  For example, we can initialize the _vec.sv_mask_ field
           given to **sigvec**() using code such as the following:
    
               vec.sv_mask = sigmask(SIGQUIT) | sigmask(SIGABRT);
                           /* Block SIGQUIT and SIGABRT during
                              handler execution */
    
           The **sigblock**() function adds the signals in _mask_ to the process's
           signal mask (like POSIX _sigprocmask(SIG_BLOCK)_), and returns the
           process's previous signal mask.  Attempts to block **SIGKILL** or
           **SIGSTOP** are silently ignored.
    
           The **sigsetmask**() function sets the process's signal mask to the
           value given in _mask_ (like POSIX _sigprocmask(SIG_SETMASK)_), and
           returns the process's previous signal mask.
    
           The **siggetmask**() function returns the process's current signal
           mask.  This call is equivalent to **sigblock**(0).
    


## RETURN VALUE



           The **sigvec**() function returns 0 on success; on error, it returns
           -1 and sets _errno_ to indicate the error.
    
           The **sigblock**() and **sigsetmask**() functions return the previous
           signal mask.
    
           The **sigmask**() macro returns the signal mask for _signum_.
    


## ERRORS



           See the ERRORS under sigaction(2) and sigprocmask(2).
    


## ATTRIBUTES



           For an explanation of the terms used in this section, see
           attributes(7).
           ┌──────────────────────────────────────┬───────────────┬─────────┐
           │ **Interface** │ **Attribute** │ **Value** │
           ├──────────────────────────────────────┼───────────────┼─────────┤
           │ **sigvec**(), **sigmask**(), **sigblock**(),     │ Thread safety │ MT-Safe │
           │ **sigsetmask**(), **siggetmask**()           │               │         │
           └──────────────────────────────────────┴───────────────┴─────────┘
    


## STANDARDS



           None.
    


## NOTES



           On 4.3BSD, the **signal**() function provided reliable semantics (as
           when calling **sigvec**() with _vec.sv_mask_ equal to 0).  On System V,
           **signal**() provides unreliable semantics.  POSIX.1 leaves these
           aspects of **signal**() unspecified.  See signal(2) for further
           details.
    
           In order to wait for a signal, BSD and System V both provided a
           function named sigpause(3), but this function has a different
           argument on the two systems.  See sigpause(3) for details.
    


* * *