Signal Handling -- signal()
An application program can specify a function called a signal handler to be invoked when a specific signal is received. When a signal handler is invoked on receipt of a signal, it is said to catch the signal. A process can deal with a signal in one of the following ways:

The process can let the default action happen
The process can block the signal (some signals cannot be ignored)
the process can catch the signal with a handler.
Signal handlers usually execute on the current stack of the process. This lets the signal handler return to the point that execution was interrupted in the process. This can be changed on a per-signal basis so that a signal handler executes on a special stack. If a process must resume in a different context than the interrupted one, it must restore the previous context itself
Receiving signals is straighforward with the function:

int (*signal(int sig, void (*func)()))() -- that is to say the function signal() will call the func functions if the process receives a signal sig. Signal returns a pointer to function func if successful or it returns an error to errno and -1 otherwise.




func() can have three values:


SIG_DFL
-- a pointer to a system default function SID_DFL(), which will terminate the process upon receipt of sig.
SIG_IGN
-- a pointer to system ignore function SIG_IGN() which will disregard the sig action (UNLESS it is SIGKILL).
A function address
-- a user specified function.
SIG_DFL and SIG_IGN are defined in signal.h (standard library) header file.


Thus to ignore a ctrl-c command from the command line. we could do:


   signal(SIGINT, SIG_IGN);


TO reset system so that SIGINT causes a termination at any place in our program, we would do:


   signal(SIGINT, SIG_DFL);





So lets write a program to trap a ctrl-c but not quit on this signal. We have a function sigproc() that is executed when we trap a ctrl-c. We will also set another function to quit the program if it traps the SIGQUIT signal so we can terminate our program:




#include <stdio.h>

void sigproc(void);

void quitproc(void);

main()
{ signal(SIGINT, sigproc);
         signal(SIGQUIT, quitproc);
         printf(``ctrl-c disabled use ctrl- to quitn'');
         for(;;); /* infinite loop */}

void sigproc()
{        signal(SIGINT, sigproc); /*  */
         /* NOTE some versions of UNIX will reset signal to default
         after each call. So for portability reset signal each time */

         printf(``you have pressed ctrl-c n'');
}

void quitproc()
{        printf(``ctrl- pressed to quitn'');
         exit(0); /* normal exit status */
}