Handling Signals: Function signal()

The most important function for handling signals is signal(). It has the following function prototype:

void (*signal (int, void (*)(int))) (int);

Here are some explanations:

signal() is a system call that returns the address of a function that takes an integer argument and has no return value. The following is what signal() returns:
```
void  (*)(int)
```
In fact, what signal() returns is the previously installed handler.
signal() requires two arguments:
- The first one is an integer int, which must be a signal name (e.g., SIGINT) or a predefined signal related constant.
- The second one is a function
```
void (*)(int)
```
  which accepts an integer argument and returns nothing. This is the function that will handle the signal specified in the first argument. This function is called a signal handler. More precisely, if the system detects the signal specified in the first argument, the signal handler as specified in the second argument is called.
```
signal(SIGINT, CtrlCHandler)
```
  The above specifies that the signal handler for signal SIGINT is function CtrlCHandler().
- If you want to ignore the signal specified by the first argument (i.e., pretending that the signal never happens), use SIG_IGN for the second argument.
```
signal(SIGINT, SIG_IGN)

signal(SIGALRM, SIG_IGN)
```
  In the above two lines, SIGINT and SIGALRM are ignored.
- If you want the system to use the default way to handle a signal, use SIG_DFL for the second argument.
```
signal(SIGALRM, SIG_DFL)
```
  The above line asks the system to handle SIGALRM in a defaulted way.
On success, signal() returns the address of the previously handler for this specific signal; otherwise, it returns SIG_ERR.

Example

The following is a very simple example. Click here to download this program.

#include  <stdio.h>
#include  <signal.h>

#define   MAX_i    10000
#define   DIVISOR   1000
#define   MAX_j    20000

void  main(void)
{
     int            i;
     unsigned long  j, sum;

     signal(SIGINT, SIG_IGN);        
     printf("CPU-bound loop started.  Pressing Ctrl-C has no effect....\n");
     for (i = 1; i <= MAX_i; i++)  {
          sum = 0;
          for (j = 0; j <= MAX_j; j++)
               sum += j;
          if (i % DIVISOR == 0)
               printf("Iteration %d, sum = %ld\n", i, sum);
     }
     printf("Computation is done.\n\n");

     signal(SIGINT, SIG_DFL);     
     printf("CPU-bound loop restarted.  Pressing Ctrl-C HAS effect now...\n");
     for (i = 1; i <= MAX_i; i++)  {
          sum = 0;
          for (j = 0; j <= MAX_j; j++)
               sum += j;
          if (i % DIVISOR == 0)
               printf("Iteration %d, sum = %ld\n", i, sum);
     }
     printf("Computation is done.\n");
}

The above program has two identical loops. However, before the first loop starts, signal SIGINT is ignored and, as a result, hitting Ctrl-C has no effect. Before the second loop starts, signal SIGINT handling is reset to the default, which means the program is interrupted when Ctrl-C is pressed.