When a signal handler is entered, the kernel automatically adds the signal to the process signal mask (blocks it). When the handler returns normally, the kernel removes it from the mask.

But if you use longjmp() to exit the handler (jumping back to main), the behaviour of the signal mask depends on the UNIX variant:

Because of this portability problem, POSIX.1-1990 introduced sigsetjmp() and siglongjmp() which give explicit control over signal mask handling.

#include <setjmp.h>

/*
 * sigsetjmp() - saves execution context + optionally the signal mask
 *
 * env:      buffer to save state into (type: sigjmp_buf, not jmp_buf)
 * savesigs: if nonzero, the CURRENT signal mask is saved in env
 *           and will be restored by siglongjmp()
 *
 * Returns 0 when called directly.
 * Returns the val argument of siglongjmp() when returning via jump.
 */
int sigsetjmp(sigjmp_buf env, int savesigs);

/*
 * siglongjmp() - jumps back to the sigsetjmp() point
 *
 * env: must be the same env buffer previously filled by sigsetjmp()
 * val: value sigsetjmp() will appear to return (should be non-zero)
 *
 * If savesigs was nonzero in sigsetjmp(), the signal mask saved at
 * that time is RESTORED — i.e., the signal that blocked the handler
 * entry is unblocked.
 */
void siglongjmp(sigjmp_buf env, int val);

#define _GNU_SOURCE
#include <stdio.h>
#include <setjmp.h>
#include <signal.h>
#include <string.h>
#include <unistd.h>

static sigjmp_buf env;

/*
 * Guard variable: canJump = 0 until sigsetjmp() has been called.
 * Without this, a signal arriving BEFORE sigsetjmp() would try
 * to jump using an uninitialized env buffer — undefined behaviour.
 */
static volatile sig_atomic_t canJump = 0;

static void handler(int sig)
{
    /* UNSAFE: printf is not async-signal-safe, used here for demo only */
    printf("[Handler] Signal %d received. Signal mask now has this signal blocked.\n", sig);

    if (!canJump) {
        /* env not yet set — safe fallback: just return */
        printf("[Handler] env not initialized. Returning normally.\n");
        return;
    }

    /* siglongjmp with savesigs=1 restores signal mask (unblocks SIGINT) */
    siglongjmp(env, 1);
}

int main(void)
{
    struct sigaction sa;
    sa.sa_handler = handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sigaction(SIGINT, &sa, NULL);

    /*
     * sigsetjmp(env, 1):
     *   - First call: saves context + signal mask. Returns 0.
     *   - After siglongjmp(): returns 1. Signal mask is RESTORED.
     */
    if (sigsetjmp(env, 1) == 0) {
        /* First time: just set up the guard */
        canJump = 1;
        printf("[Main] sigsetjmp() done. Press Ctrl+C to jump back here.\n");
    } else {
        /* Returned via siglongjmp() */
        printf("[Main] Returned from siglongjmp(). Signal mask restored.\n");
        printf("[Main] SIGINT is now UNBLOCKED again. Press Ctrl+C to trigger again.\n");
    }

    /* Main loop — wait for signals */
    int count = 0;
    while (count < 3) {
        pause();
        count++;
    }

    printf("[Main] Received %d signals via nonlocal goto. Exiting.\n", count);
    return 0;
}

#define _GNU_SOURCE
#include <stdio.h>
#include <setjmp.h>
#include <signal.h>
#include <unistd.h>

/*
 * Demonstrates the Linux/System V behaviour:
 * longjmp() does NOT restore the signal mask.
 * After the jump, SIGINT remains blocked — Ctrl+C stops working!
 *
 * To fix: replace setjmp/longjmp with sigsetjmp/siglongjmp (savesigs=1).
 */

static jmp_buf env;
static volatile sig_atomic_t canJump = 0;

static void handler(int sig)
{
    printf("[Handler] SIGINT received. About to longjmp...\n");
    if (!canJump) return;
    longjmp(env, 1);   /* Signal mask is NOT restored here on Linux */
}

void print_sigint_status(void)
{
    sigset_t pending;
    sigprocmask(SIG_BLOCK, NULL, &pending); /* query current mask */
    if (sigismember(&pending, SIGINT))
        printf("[Mask Check] SIGINT is BLOCKED\n");
    else
        printf("[Mask Check] SIGINT is unblocked\n");
}

int main(void)
{
    struct sigaction sa;
    sa.sa_handler = handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sigaction(SIGINT, &sa, NULL);

    printf("Before sigsetjmp:\n");
    print_sigint_status();

    if (setjmp(env) == 0) {
        canJump = 1;
    } else {
        printf("After longjmp():\n");
        print_sigint_status();
        /* On Linux: SIGINT is STILL BLOCKED here! */
        printf("Try Ctrl+C now — it is blocked and has no effect.\n");
    }

    while(1) pause();
    return 0;
}

abort() terminates the process by raising SIGABRT, which by default generates a core dump. This is useful for catching programming errors (like a failed assertion).

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

/*
 * Custom error handler that calls abort().
 * The core dump allows a debugger to inspect state at time of failure.
 */
void fatal_error(const char *msg)
{
    fprintf(stderr, "FATAL: %s\n", msg);
    fprintf(stderr, "Calling abort() — a core dump will be generated.\n");
    abort();   /* Raises SIGABRT → core dump + termination */
}

/*
 * A SIGABRT handler that runs before the process dies.
 * It can do cleanup, but abort() will FORCE termination afterward.
 */
static void sigabrt_handler(int sig)
{
    /* write() is async-signal-safe */
    const char msg[] = "[SIGABRT Handler] Caught SIGABRT. Doing last-chance cleanup.\n";
    write(2, msg, sizeof(msg) - 1);
    /* If we return from this handler, abort() re-raises SIGABRT with SIG_DFL */
}

int main(void)
{
    /* Install a SIGABRT handler to demonstrate last-chance cleanup */
    struct sigaction sa;
    sa.sa_handler = sigabrt_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sigaction(SIGABRT, &sa, NULL);

    /* Simulate a program that detects an internal inconsistency */
    int *ptr = NULL;

    /* Defensive check — in production this might be an assert() */
    if (ptr == NULL) {
        fatal_error("Null pointer dereference detected before use");
    }

    *ptr = 42;  /* Would crash without the check above */
    return 0;
}