signal() — Handle interrupts

When a signal occurs, if func points to a function:

1. First the equivalent of signal(sig,SIG_DFL); is executed or an implementation-defined blocking of the system is performed. (If the value of sig is SIGILL, the occurrence of the reset to SIG_DFL is implementation-defined.)
2. Next, the equivalent of (*func)(sig); is executed. The function func may terminate by executing a return statement or by calling the abort(), exit(), or longjmp() function. If func executes a return statement and the value of sig was SIGFPE or any other implementation-defined value corresponding to a computational exception, the behavior is undefined. Otherwise, the program will resume execution at the point it was interrupted.

The action taken when the interrupt signal is received depends on the value of func.

Value

Meaning

SIG_DFL

Default handling for the signal will occur.

SIG_IGN

The signal is to be ignored.

As of Language Environment® Release 3, the defaults for SIGUSR1, SIGUSR2, SIGINT, and SIGTERM are changed from the signal being ignored to abnormal termination. To compensate for this change, you would explicitly register that the signal is to be ignored, using a call sequence such as:

signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
signal(SIGINT,  SIG_IGN);
signal(SIGTERM, SIG_IGN);

Special behavior for C++:

• The behavior when mixing signal-handling with C++ exception handling is undefined. Also, the use of signal-handling with constructors and destructors is undefined.
• C++ and C language linkage conventions are incompatible, and therefore signal() cannot receive C++ function pointers. If you attempt to pass a C++ function pointer to signal(), the compiler will flag it as an error. Therefore, to use the signal() function in the C++ language, you must ensure that signal handler routines established have C linkage, by declaring them as extern "C".

In Table 1, the Default Actions are:

1

Normal termination of the process.

2

Ignore the signal.

CELEBS20

/* CELEBS20                                      

   This example shows you how to establish a signal handler.                    

 */                                                                             
#include <signal.h>                                                             
#include <stdio.h>                                                              
#include <stdlib.h>                                                             
#define  ONE_K  1024                                                            
                                                                                
#define OUT_OF_STORAGE       (SIGUSR1)                                          
                                                                                
/* The SIGNAL macro does a signal() checking the return code */                 
#define SIGNAL(handler, StrCln)       {                \                        
  if (signal((handler), (StrCln)) == SIG_ERR) {        \                        
    perror("Could not signal user signal");            \                        
    abort();                                           \                        
  }                                                    \                        
}                                                                               
                                                                                
#ifdef __cplusplus                 /* the __cplusplus macro       */            
extern "C" void StrCln(int);       /* is automatically defined    */            
#else                              /* by the C++/MVS compiler     */            
void StrCln(int);                                                               
#endif                                                                          
                                                                                
void DoWork(char **, int);                                                      
                                                                                
int main(int argc, char *argv[]) {                                              
  int size;                                                                     
  char *buffer;                                                                 
                                                                                
  signal(OUT_OF_STORAGE, StrCln);                                               
                                                                                
  if (argc != 2) {                                                              
    printf("Syntax: %s size \n", argv[0]);                                      
    return(-1);                                                                 
  }                                                                             
                                                                                
  size = atoi(argv[1]);                                                         
                                                                                
  DoWork(&buffer, size);                                                        
  return(0);                                                                    
}                                                                               
                                                                                
void StrCln(int SIG_TYPE) {                                                     
  printf("Failed trying to malloc storage\n");                                  
  signal(SIG_TYPE, SIG_DFL);                                                    
  exit(0);                                                                      
}                                                                               
                                                                                
void DoWork(char **buffer, int size) {                                          
  int rc;                                                                       
                                                                                
  while (*buffer !=NULL)                                                        
    *buffer = (char *)malloc(size*ONE_K);                                       
  if (*buffer == NULL) {                                                        
     if (raise(OUT_OF_STORAGE)) {                                               
        perror("Could not raise user signal");                                  
        abort();                                                                
     }                                                                          
  }                                                                             
  return;                                                                       
}