Handling Two Types of Signals

Let us extend the previous example to handle two types of signals. We choose to work with SIGINT and SIGALRM (alarm clock).

Here is a simple example. Click here to download a copy of this program.

Let us start with the two signal handlers INThandler() and ALARMhandler():

void  INThandler(int sig)
{
     char  c;

     signal(SIGALRM, SIG_IGN);
     signal(SIGINT, SIG_IGN);
     printf("OUCH, you just hit a Ctrl-C\n"
            "Do you really want to quit? [y/n] ");
     c = getchar();
     if (c == 'y' || c == 'Y')
          exit(0);
     signal(SIGINT, INThandler);
     signal(SIGALRM, ALARMhandler);
     longjmp(JumpBuffer, FROM_CTRL_C);
}

void  ALARMhandler(int  sig)
{
     signal(SIGINT, SIG_IGN);
     signal(SIGALRM, SIG_IGN);
     printf("An alarm signal just arrived ...\n");
     alarm(0);
     signal(SIGALRM, ALARMhandler);
     signal(SIGINT, INThandler);
     longjmp(JumpBuffer, FROM_ALARM);
}

• Both handlers use signal() to ignore SIGINT and SIGALRM once they receive the control, and reinstall the handlers before exit. Finally, they use longjmp() to go back to the main program.
• The SIGINT handler is identical the previous one.
• The SIGALRM displays a message saying that an alarm signal has just occurred. alarm(0) cancels the alarm clock effect.
• Now we have two signal handlers working. If the system detects a SIGINT (resp., SIGALRM), handler INThandler() (resp., ALARMhandler()) will be called.
• Note that to distinguish who is returning the control, INThandler() and ALARMhandler() return FROM_CTRL_C and FROM_ALARM, respectively. They are names defined at the beginning of this program (see the main program).

The main program is simple and is shown below:

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

#define   START         0
#define   FROM_CTRL_C   1
#define   FROM_ALARM    2

#define   ALARM         5

jmp_buf  JumpBuffer;

void     INThandler(int);
void     ALARMhandler(int);

void  main(void)
{
     int  JumpReturn;

     signal(SIGINT, INThandler);
     signal(SIGALRM, ALARMhandler);

     while (1) {
          if ((JumpReturn = setjmp(JumpBuffer)) == START) {
               alarm(ALARM);
               pause();
          }
          else if (JumpReturn == FROM_CTRL_C) {
          }
          else if (JumpReturn == FROM_ALARM) {
               printf("Alarm clock reset to %d sec\n", ALARM);
          }
     }
}

• The main program installs both signal handlers. Then, it enters an infinite loop. In each iteration of this loop, a jump buffer is set. If this is not a return, the return value is START (equal to 0) and the alarm clock is set to ALARM seconds. Then, the main program pauses itself.
• If one of the two signal handlers returns, the return value of setjmp() is either FROM_CTRL_C or FROM_ALARM.
• If returns from INThandler(), the main program does nothing and just goes back for the next iteration.
• If returns from ALARMhandler(), the main program displays a message and goes back for the next iteration. Note that the alarm clock is set to a new value right after the jump buffer is saved.