SIGINT

8.4 SIGINT

This signal is generated when a user type control-C in a console. It can also be generated by the kill command. The intention of this signal is “suggest the process to exit”. In other words, the default signal disposition is to terminate the process. However, this signal can be intercepted or even ignored.

Many programs change the default disposition of SIGINT. However, ignoring a user’s request to quit a program is also not appropriate. Most programs changes the disposition so that a program has a chance to shut down properly, then quit.

If a program is to intercept SIGINT to shut down gracefully, it should use the following strategy:

Use signal or sigaction to set up the new handler, but also save the old handler.
When a process is sent SIGINT, the handler performs whatever operation is needed to shut down the program. This may include saving the state, finishing up a transmission, or closing sockets connected to client processes.
After the clean up operation is done. The signaled process should exit using the default SIGINT handler. This means that the process should restore the original default handler of SIGINT, and send itself the signal again.

To save the old handler and set up a new handler:

struct sigaction newSigAction, oldSigAction; /* globals */
/* ... */
newSigAction.sa_handler = handleInt;
sigemptyset(&newSigAction.sa_mask);
newSigAction.sa_flags = 0;
if (sigaction(SIGINT, &newSigAction, &oldSigAction) != 0)
{
/* report error */
}

Then, the signal handler handleInt should be structured as follows:

void handleInt(int signum)
{
  /* ... do whatever to shut down */
  sigaction(SIGINT, &oldSigAction, NULL); /* restore def handler */
  raise(SIGINT); /* send myself the signal again */
}

The following is a complete program to test the handling of SIGINT:

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

struct sigaction oldSigAction;

void handleInt(int signum)
{
  dprintf(2, ”Ouch!\n”);
  sigaction(SIGINT, &oldSigAction, NULL);
  raise(SIGINT);
}

int main(void)
{
  struct sigaction newSigAction;

  newSigAction.sa_handler = handleInt;
  sigemptyset(&newSigAction.sa_mask);
  newSigAction.sa_flags = 0;
  dprintf(2, ”Set_up_the_signal_handler\n”);
  if (sigaction(SIGINT, &newSigAction, &oldSigAction) != 0)
  {
    dprintf(2, ”Could_not_set_up_the_SIGINT_handler\n”);
  }
  else
  {
    dprintf(2, ”Let’s_burn_some_cycles\n”);
    for (;;);
  }
  return 0;
}

If sigaction is not called in the handler, but raise is kept, then the program will endlessly and “recursively” raise the signal, handle it, and raise the signal again. This will, eventually run out of stack space.

If sigaction is put in place, but the raise call is removed, then the first control-C will only cause the message to be printed, but the handler will return and continue the infinite loop in main. When control-C is pressed again, then the program will exit by the default handler of SIGINT.

An alternative (to the original code in the listing) is to use the SA_RESETHAND value in sa_flags. This flag instructs the system to restore the default handler once a signal handler is called. In this case, this flag (use it when newSigAction.sa_flags is initialized) would have accomplished the same logic, and the sigaction call in the handler is no longer needed.

[prev] [prev-tail] [front] [up]