C + UNIX, siglongjmp and sigsetjmp

Question

I have a program from a (oldish) text book that is intended to illustrate the use of POSIX signals on UNIX. The program runs a computational loop to compute perfect numbers starting at a fixed point.

• A time alarm signal is used to periodically print status.
• An interrupt signal is used for status on demand.
• A quit signal is used to reset the test interval (or terminate).

---

void perfect(int);

sigjmp_buf jmpenv; /* environment saved by setjmp*/

int n; /* global variable indicating current test point */

int main() {

    int begin; /* starting point for next search*/
        /* interrupt routines*/
    void status();
    void query();

    sigset_t mask;
    struct sigaction action;


    if (sigsetjmp(jmpenv,0)) {
        printf("Enter search starting point (0 to terminate): ");
        scanf("%d",&begin);
        if (begin==0) exit(0);
        sigprocmask(SIG_UNBLOCK, &mask, NULL);
        }
    else begin=2;

    /* Status Routine will handle timer and INTR */

    sigemptyset(&mask);
    sigaddset(&mask, SIGINT);
    sigaddset(&mask, SIGALRM);
    sigaddset(&mask, SIGQUIT);
    action.sa_flags=0;
    action.sa_mask=mask;

    action.sa_handler=status;
    sigaction(SIGINT,&action,NULL);
    sigaction(SIGALRM,&action,NULL);

    action.sa_handler=query;
    sigaction(SIGQUIT,&action,NULL);

    /* start alarm clock */
    alarm(20);
    perfect(begin);
}

void perfect(start) 
    int start;
{
    int i,sum;

    n=start;

while (1) {
    sum=1;
    for (i=2;i<n;i++)
        if (!(n%i)) sum+=i;

    if (sum==n) printf("%d is perfect\n",n);
    n++;
    }
}

void status(signum) 
int signum;
{

    alarm(0); /* shutoff alarm */

    if (signum == SIGINT) printf("Interrupt ");
    if (signum == SIGALRM) printf("Timer ");

    printf("processing %d\n",n);

    alarm(20);  /*restart alarm*/
}   

void query() {siglongjmp(jmpenv,1);}

My questions are:

1. Why does it call void status(); and void query(); in the main at first?
2. After the if statement checks begin == 0 and decides to exit, it follows a line called "sigprocmask(SIG_UNBLOCK, &mask, NULL);" Why do I have to make it unblock after I exit already?

Answer 1

1. Those two lines declare the functions status() and query() as returning void. They don't specify what arguments they take. In modern C, declaring functions inside another function is anathema (and declaring them without full prototypes too is anathema — but that seems to be a discussion for another day since it isn't your code). Functions should be declared outside other functions, and if they're defined or used in another file, they should be declared in a header. If they're defined in the current file and not used in any other file, they should be declared and defined as static functions.

2. The variable begin is initialized unorthodoxly. It is set to 2 on the first pass through the code; after the non-zero return from sigsetjmp(), it is set by user input. It is also likely to be clobbered by the setjmp() stuff because it isn't marked volatile. The rules are esoteric.

   However, the intention is that if begin is zero, then the program exits. Otherwise, it will continue. The sigprocmask() is intended to unblock any signals that were masked. It is not clear to me that it is necessary. By the time you return from the signal handler, the blocked signals should be unblocked — I think — even if you exit via siglongjmp().

Note that calling printf() in a signal handler invokes undefined behaviour. The chances are it will be OK, but it is not guaranteed. There is a list of functions that can be called, either in the POSIX standard or in other questions on SO (I know I've given that list before).

---

Read the manual pages for the functions carefully:

• sigsetjmp()
• siglongjmp()
• setjmp()
• longjmp()

Chris Dodd is correct when he comments that sigsetjmp() with a second argument of 0 does not save the current signal mask. Note that the value of mask is in a local variable that is modified after setjmp() is called and is not marked volatile, so its value when setjmp() returns with a non-zero value is indeterminate (see the caveats in the setjmp() man page).

The rationale section of the man page for sigsetjmp() is interesting reading and mentions similar functionality appearing in 4.2 BSD (released in 1982), so my comment about them not existing in the 70s remains valid (K&R 1st edition and 7th Edition UNIX™ were released in 1978 and 1979 respectively). The sig* names were, AFAICT, invented by POSIX (the BSD systems included _setjmp() and _longjmp() instead).