Signal Sets

A signal set a way to indicate a group of signals.
- ```
       #include <signal.h>
       int sigemptyset(sigset_t *set);
       int sigfillset(sigset_t *set);
       int sigaddset(sigset_t *set, int signum);
       int sigdelset(sigset_t *set, int signum);
       int sigismember(const sigset_t *set, int signum);
          
```
- This could be a bit mask, or not.
- The best way to think of it is a set.
- sigemptyset creates an empty set.
- sigfillset creates the set of all signals.
- sigaddset adds the selected signal to the set
- sigdelset deletes the selected signal from the set.
- sigismember tests for signal membership in a set.

GLIBC extends this with

       int sigisemptyset(const sigset_t *set);
       int sigorset(sigset_t *dest, const sigset_t *left,
                     const sigset_t *right);
       int sigandset(sigset_t *dest, const sigset_t *left,
                     const sigset_t *right);

Using sigset: Blocking Signals
- ```
       #include <signal.h>
       int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
	 
```
- The signal mask is the set of signals for which the signal is blocked.
- HOW:
  - SIG_BLOCK - block the signals.
    - Union of current set with the set argument.
  - SIG_UBLOCK - remove the set argument signals from the blocked set
  - SIG_SETMASK - set the values to be the set argument.
- If oldset is not null, the old value is stored here.
- If set is null the mask is unchanged but the value is returned in oldset.
- Blocking SIGKILL and SIGSTOP is not possible.
- Blocking SIGBUS, SIGFPE, SIGILL, SIGSEGV are undefined if the real problem occurs (NOT kill, raise, ....)
Using sigset: sigpending
- ```
       #include <signal.h>
       int sigpending(sigset_t *set);
	 
```
- Returns the set of signals which are pending
- But only blocked signals which are not ignored.
At this point, it is important to note that signals are not queued
- sigpending will report a signal has been received.
- No matter how many signals of that type have been received.
- And the signal will only be delivered once as well.

Signal Disposition: sigaction

       #include <signal.h>
       int sigaction(int signum, const struct sigaction *act,
                     struct sigaction *oldact);

       struct sigaction {
           void     (*sa_handler)(int);
           void     (*sa_sigaction)(int, siginfo_t *, void *);
           sigset_t   sa_mask;
           int        sa_flags;
           void     (*sa_restorer)(void);
       };

This is the proper alternative to signal
signum: Anything but SIGKILL and SIGSTOP
act: the new action for the signal to be installed.
oldact: the old signal action.

The sigaction structure

sa_handler and sa_sigaction might be parts of a union, don't use both.
sa_restorer is not intended for applications (POSIX does not define it)
sa_handler is the set from signal (SIG_DFL, SIG_IGN or handler)
sa_sigaction is an alternative to sa_handler
- The signal that forced the call is the first parameter
- A pointer to siginfo_t is the second parameter.
- A pointer to a ucontext_t is the third argument, but this is normally not used.
- This field is only used if sa_flags is set to SA_SIGINFO
sa_mask is a set of signals which should be blocked while the signal handler is executing.
- In addition, the signal which generated the call will be blocked too.
sa_flags can also specify (FOR THE SIGNAL BEING PROCESSED)
- SA_NOCLDSTOP : for SIGCHILD ignore sigchild generated by child processesses which receive STOP, CONT .. signals
- SA_NOCLDWAIT - don't turn children into zombies.
- SA_NODEFER: don't block additional versions of this signal being delevered (remember, the signal it's self is blocked by default)
- SA_ONSTACK: Use an alternate stack to call the signal handler.
- SA_RESETHAND: When the signal is caught, reset the handler to the default.

When the sa_sigaction signal handler is used, the following structure is returend

          siginfo_t {
               int      si_signo;     /* Signal number */
               int      si_errno;     /* An errno value */
               int      si_code;      /* Signal code */
               int      si_trapno;    /* Trap number that caused
                                         hardware-generated signal
                                         (unused on most architectures) */
               pid_t    si_pid;       /* Sending process ID */
               uid_t    si_uid;       /* Real user ID of sending process */
               int      si_status;    /* Exit value or signal */
               clock_t  si_utime;     /* User time consumed */
               clock_t  si_stime;     /* System time consumed */
               sigval_t si_value;     /* Signal value */
               int      si_int;       /* POSIX.1b signal */
               void    *si_ptr;       /* POSIX.1b signal */
               int      si_overrun;   /* Timer overrun count;
                                         POSIX.1b timers */
                                        POSIX.1b timers */
               int      si_timerid;   /* Timer ID; POSIX.1b timers */
               void    *si_addr;      /* Memory location which caused fault */
               long     si_band;      /* Band event (was int in
                                         glibc 2.3.2 and earlier) */
               int      si_fd;        /* File descriptor */
               short    si_addr_lsb;  /* Least significant bit of address
                                         (since Linux 2.6.32) */
               void    *si_lower;     /* Lower bound when address violation
                                         occurred (since Linux 3.19) */
               void    *si_upper;     /* Upper bound when address violation
                                         occurred (since Linux 3.19) */
               int      si_pkey;      /* Protection key on PTE that caused
                                         fault (since Linux 4.6) */
               void    *si_call_addr; /* Address of system call instruction
                                         (since Linux 3.5) */
               int      si_syscall;   /* Number of attempted system call
                                         (since Linux 3.5) */
               unsigned int si_arch;  /* Architecture of attempted system call
                                         (since Linux 3.5) */
           }

Many of these filds are specific to the signal or how the signal was generated.
- kill, sigqueue fill in si_pid, si_uid
- SIGFPE provides si_code:
  - FPE_INTDIV - int/0
  - FPE_INTOVF - integer overflow
  - FPE_FLTDIV - float/0
  - FPE_FLTOVF - overflow
  - FPE_FLTUND - underflow
  - FPE_FLTRES - inexact result
  - FPE_FLTINV - invalid operation
  - FPE_FLTSUB - subscript out of range.
- I would never use this without reviewing.