Sending a Signal: ANSI C Function raise()

ANSI C has a library function raise() for sending a signal to the program that contains this raise() call. The following is the function prototype:

int  raise(int sig)

If this function is executed successfully, the signal specified in sig is generated. If the program has a signal handler, this signal will be processed by the that signal handler; otherwise, this signal will be handled by the default way. If the call is unsuccessful, raise() returns a non-zero value.

Note that function raise() can only send a signal to the program that contains it. raise() cannot send a signal to other processes. To send a signal to other processes, the system call kill() should be used. Click here to learn more about kill().

Example

The following is example that demonstrates the use of function raise(). Click here to download this program.

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

long  prev_fact, i;    

void  SIGhandler(int);     

void  SIGhandler(int sig)
{
     printf("\nReceived a SIGUSR1.  The answer is %ld! = %ld\n", 
               i-1, prev_fact);
     exit(0);
}

void  main(void)
{
     long  fact;

     printf("Factorial Computation:\n\n");
     signal(SIGUSR1, SIGhandler); 
     for (prev_fact = i = 1; ; i++, prev_fact = fact) { 
          fact = prev_fact * i;  
          if (fact < 0)        
               raise(SIGUSR1); 
          else if (i % 3 == 0)  
               printf("     %ld! = %ld\n", i, fact);
     }
}

You might have noticed in the past that multiplying or adding two large integers may result in a negative value. This is a sure sign of integer overflow. The above program computes the factorial until the result becomes negative. Hence, the previous result is the largest factorial we can get before an integer overflow occurs.
So, we use two long integers, fact and prev_fact to store the current and previous factorial values. If fact is negative, we use raise() to send out a SIGUSR1 signal.
This SIGUSR1 has no specific meaning. The user program may interpret this signal freely. Since we only want to handle signal SIGUSR1, we know that once it arrives, we have a factorial computation overflow. Thus, the handler SIGhandler() prints out the previous, positive factorial value stored in prev_fact.
Of course, you can use raise() to send any signals. For example, sending SIGQUIT terminates the program and generates a core dump; sending SIGINT is equivalent to hitting Ctrl-C; sending SIGTERM or SIGKILL kills the program. We use SIGUSR1 here because it illustrates a way of using user-defined signals.