• A signal is generated when the event that causes the signal occurs.
• A signal is delivered when the process takes action based on the signal.
• The lifetime of a signal is the interval between its generation and delivery.
• A signal that has been generated but not yet delivered is pending.
• A process catches a signal if it executes a signal handler when the signal is delivered.
• Alternatively, a process can ignore as signal when it is delivered, that is to take no action.
• The function sigaction is used to specify what is to happen to a signal when it is delivered.
• The signal mask determines the action to be taken when the signal is generated. It contains a list of signals to be blocked.
• A blocked signal is not delivered to a process until it is unblocked.
• The function sigprocmask is used to modify the signal mask.
• Each signal has a default action which is usually to terminate the process.

kill -9 pid
kill -KILL pid.

#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);

   if (kill(3423, SIGUSR1) == -1)
      perror("Failed to send the SIGUSR1 signal");

if (kill(getppid(), SIGTERM) == -1)
    perror ("Failed to kill parent");

if (raise(SIGUSR1) != 0)
   perror("Failed to raise SIGUSR1");

int main(void) {
   alarm(10);
   for ( ; ; ) ;
}

#include <signal.h>

int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set, int signo);
int sigdelset(sigset_t *set, int signo);
int sigismember(const sigset_t *set, int signo);

   #include <signal.h>
   int sigprocmask(int how, const sigset_t *restrict set,
                   sigset_t *restrict oset);

• SIG_BLOCK
• SIG_UNBLOCK
• SIG_SETMASK

if ((sigemptyset(&twosigs) == -1) ||
    (sigaddset(&twosigs, SIGINT) == -1)  ||
    (sigaddset(&twosigs, SIGQUIT) == -1))
    perror("Failed to set up signal mask");

sigset_t newsigset;
 
if ((sigemptyset(&newsigset) == -1) ||
    (sigaddset(&newsigset, SIGINT) == -1))
   perror("Failed to initialize the signal set");
else if (sigprocmask(SIG_BLOCK, &newsigset, NULL) == -1)
   perror("Failed to block SIGINT");

#include <signal.h>

int sigaction(int signo, const struct sigaction *act,
                          struct sigaction *oact);
struct sigaction {
   void (*sa_handler)(int); /* SIG_DFL, SIG_IGN or pointer to function */
   sigset_t sa_mask;        /* additional signals to be blocked
                                  during execution of handler */
   int sa_flags;            /* special flags and options */
   void(*sa_sigaction) (int, siginfo_t *, void *); /* realtime handler */
};

struct sigaction act;
 
if (sigaction(SIGINT, NULL, &act) == -1)  /* Find current SIGINT handler */
   perror("Failed to get old handler for SIGINT");
else if (act.sa_handler == SIG_DFL) {    /* if SIGINT handler is default */
   act.sa_handler = SIG_IGN;         /* set new SIGINT handler to ignore */
   if (sigaction(SIGINT, &act, NULL) == -1)
      perror("Failed to ignore SIGINT");
}

void catchctrlc(int signo) {
   char handmsg[] = "I found Ctrl-C\n";
   int msglen = sizeof(handmsg);
 
   write(STDERR_FILENO, handmsg, msglen);
}
...
struct sigaction act;
act.sa_handler = catchctrlc;
act.sa_flags = 0;
if ((sigemptyset(&act.sa_mask) == -1) ||
    (sigaction(SIGINT, &act, NULL) == -1))
   perror("Failed to set SIGINT to handle Ctrl-C");

   struct sigaction newact;
 
   newact.sa_handler = SIG_DFL;    /* new handler set to default */
   newact.sa_flags = 0;            /* no special options */
   if ((sigemptyset(&newact.sa_mask) == -1) ||
       (sigaction(SIGINT, &newact, NULL) == -1))
      perror("Failed to set SIGINT to the default action");

int testignored(int signo) {
   struct sigaction act;
   if ((sigaction(signo, NULL, &act) == -1) || (act.sa_handler != SIG_IGN))
      return 0;
   return 1;
}

#include <unistd.h>
int pause(void);

static volatile sig_atomic_t sigreceived = 0;

while(sigreceived == 0)
    pause();

static volatile sig_atomic_t sigreceived = 0;

int signum;
sigset_t sigset;
 
sigemptyset(&sigset);
sigaddset(&sigset, signum);
sigprocmask(SIG_BLOCK, &sigset, NULL);
while(sigreceived == 0)
   pause();

#include <signal.h>
int sigsuspend(const sigset_t *sigmask);

static volatile sig_atomic_t sigreceived = 0;

void catch_signal(int signo) {
   sigreceived = 1;
}

 1. sigset_t emptymask, sigmask;
 2. sigemptyset(&emptymask);
 3. sigemptyset(&sigmask);
 4. sigaddset(&sigmask, SIGUSR1);
 5. sigprocmask(SIG_BLOCK, &sigmask, NULL);
 6. while(sigreceived == 0)
 7.    sigsuspend(&emptymask);

 1. static volatile sig_atomic_t sigreceived = 0;

 3. sigset_t maskblocked, maskold, maskunblocked;
 4. int signum = SIGUSR1;

 6. sigprocmask(SIG_SETMASK, NULL, &maskblocked);
 7. sigprocmask(SIG_SETMASK, NULL, &maskunblocked);
 8. sigaddset(&maskblocked, signum);
 9. sigdelset(&maskunblocked, signum);
10. sigprocmask(SIG_BLOCK, &maskblocked, &maskold);
11. while(sigreceived == 0)
12.    sigsuspend(&maskunblocked);
13. sigprocmask(SIG_SETMASK, &maskold, NULL);

• Block all signals
• Put the signals you want to wait for in a sigset_t
• call sigwait
• sigwait blocks the process until at least one of these signals is pending.
• It removes one of the pending signals and gives you the corresponding signal number in the second parameter..
• Do what you want: no signal handler needed.
• It returns 0 on success and -1 on error with errno set.

#include <signal.h>

int sigwait(const sigset_t *restrict sigmask, int *restrict signo);

1. Certain blocking system calls will return -1 with errno set to EINTR if a signal is caught while the function is blocked.
   See the man page to see of a system call can set errno to EINTR.
   In this case you should usually restart the function since a real error has not occurred.
   The restart library handles this for many of the most important system calls.
   Look at the functions in the restart library.
   
   
2. Handling errors in signal handlers.
   If you use a function that can modify errno in a signal handler, you must make sure that it does not interfere with error handling in the main part of the program.
   There is only one errno and it is used by both the main program and by the signal handler.
   Solution: in the signal handler, save and restore errno.
   

   void myhandler(int signo) {
      int esaved;
      esaved = errno;
      write(STDOUT_FILENO, "Got a signal\n", 13);
      errno = esaved;
   }
   

   
   
   
3. Async-signal safety.
   
   • Only certain system calls and library functions may be used safely in a signal handler.
   • The strtok function is an example of a function that might have a problem.
   • In fact, the POSIX standard only guarantees that a small number of functions are async-signal safe, that is safe to use in a signal handler and the main program.
   • Other functions may be async-signal safe in some implementations.
   • Almost none of the functions in the standard C library are on the list.

struct sigaction {
   void (*sa_handler)(int); /* SIG_DFL, SIG_IGN or pointer to function */
   sigset_t sa_mask;        /* additional signals to be blocked
                                  during execution of handler */
   int sa_flags;            /* special flags and options */
   void(*sa_sigaction) (int, siginfo_t *, void *); /* realtime handler */
};

int si_signo;            /* signal number */
int si_code;             /* cause of the signal */
union sigval si_value;   /* signal value */

int sival_int;
void *sival_ptr;

#include <signal.h>

int sigqueue(pid_t pid, int signo, const union sigval value);