Install a Signal Handler

To catch a signal, a signal handler is required. It must be installed properly using function signal() discussed in the previous page.

The following shows a list of important things for installing a signal handler:

• Prepare a function that accepts an integer to be used as a signal handler. You can install one handler for each signal you want to catch/handle. You can also install one signal handler for multiple signal types.
• Call signal() with a signal name as the first argument and the function (the signal handler) you designed as the second argument.
• When the signal you want to handle occurs, your signal handler is called with the argument the signal name that just occurred.
• Two important notes:
  • You might want to ignore that signal within your handler. Why? (Hint: if you don't ignore it, what would happen if the same signal occurs while your signal handler is processing the previous one?)
  • Before returning from your handler, don't forget to re-install the signal handler if you want catch that signal again.
• Where does the signal handler return?
  • No, it returns to nowhere. Think about the way of handling interrupt in a kernel.
  • In fact, once a signal is handled, the control ``returns'' to the interrupted statement.

Example 1

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

void     INThandler(int);

void  main(void)
{
     signal(SIGINT, INThandler);
     while (1)
          pause();
}

void  INThandler(int sig)
{
     char  c;

     signal(sig, SIG_IGN);
     printf("OUCH, did you hit Ctrl-C?\n"
            "Do you really want to quit? [y/n] ");
     c = getchar();
     if (c == 'y' || c == 'Y')
          exit(0);
     else
          signal(SIGINT, INThandler);
}

• The signal handler INThandler() is designed to handle signal SIGINT.
• When the user press Ctrl-C, INThandler() is called with its only argument indicating the signal number. The first thing for INThandler() to do is to ignore the signal. Note that since INThandler() is installed as a Ctrl-C handler, its argument sig should contain SIGINT.

  Then, INThandler() prints a message which asks if the user wants to continue. If the user input is a y or Y, INThandler() exits. Otherwise, it reinstalls itself as the SIGINT handler.

  Note that all SIGINT occurs between these two signal() calls cannot be caught.

• In the main program, INThandler() is installed as the SIGINT handler. After this, the main program enters an infinite loop. For each iteration, the main program just pauses itself. Once the user presses Ctrl-C, this key-press is caught by INThandler() and processed. Finally, the control returns to main and executes the next statement which is while. Consequently, the main program pauses itself again.
• Sometimes Unix may not be able to catch your Ctrl-C. In this case, try a few more times.

Example 2

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

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

unsigned long  counter;            
int            MAX;                
int            ALARMcount;         
int            SECOND;             

void  ALARMhandler(int sig)
{
     signal(SIGALRM, SIG_IGN);      
     ALARMcount++;              
     printf("*** ALARMhandler --> alarm received no. %d.\n", ALARMcount);
     printf("*** ALARMhandler --> counter = %ld\n", counter);
     printf("*** ALARMhandler --> alarm reset to %d seconds\n", SECOND);
     if (ALARMcount == MAX) {          
          printf("*** ALARMhandler --> Maximum alarm count reached.  exit\n");
          exit(0);
     }          
     counter = 0;                       /* otherwise, reset counter */
     alarm(SECOND);                     /* set alarm for next run   */
     signal(SIGALRM, ALARMhandler);     /* reinstall the handler    */
}

void  main(int argc, char *argv[])
{
     if (argc != 3) {
          printf("Use: %s seconds max-alarm-count\n", argv[0]);
          printf("No. of seconds is set to 1\n");
          SECOND = 1;
          printf("Max number of alarms set to 5\n");
          MAX    = 5;
     }
     else {
          SECOND = atoi(argv[1]);
          MAX    = atoi(argv[2]);
     }
     counter    = 0;              
     ALARMcount = 0;                  
     signal(SIGALRM,ALARMhandler);    
     printf("Alarm set to %d seconds and is ticking now.....\n", SECOND);
     alarm(SECOND);                   
     while (1)                        
          counter++;
}

• This program demonstrates the use of SIGALRM. It sets the system alarm clock to SECOND seconds, which is obtained from the first command line argument and has a default value of one second. Then, the main program simply keeps adding 1 to a global counter.
• A SIGALRM is generated every SECOND seconds which is caught by the SIGALRM handler ALARMhandler().
• In ALARMhandler(), it ignores signal SIGALRM, and adds 1 to the alarm counter ALARMcount. If this counter is equal to the upper limit MAX, the program exists; otherwise, the global counter counter is reset, the alarm signal is set again to SECOND seconds, reinstalls the alarm signal handler, and exits this handler. Note that the upper limit MAX is taken from the second command line argument with a default value 5.
• Note that the SIGALRM signal is generated every SECOND seconds. It is never shorter than SECOND seconds; but, it can be a little longer.
• Since there is no SIGINT handler installed, hitting Ctrl-C will terminate this program. You can also hit Ctrl-\ (i.e., SIGQUIT); but, a core dump will be generated by the system.