C Standard Library signal.h

What You’ll Learn

<signal.h> lets your program react to signals—asynchronous events like Ctrl+C (SIGINT), illegal memory access (SIGSEGV), or floating-point errors (SIGFPE). You register a handler with signal and can deliver signals yourself with raise.

Definition and Usage

A signal interrupts normal execution. The OS (or your own code via raise) delivers an integer signal number. If you installed a handler with signal, that function runs; otherwise the default action applies (often terminate the program).

Handlers run asynchronously—they can fire while your program is inside printf, malloc, or a loop. That is why handlers must be tiny and use only async-signal-safe operations. The standard pattern is to set a volatile sig_atomic_t flag and do real work in main.

📝 Syntax

Include the header:

#include <signal.h>

Standard C functions

void (*signal(int sig, void (*handler)(int)))(int);
int raise(int sig);

• signal(sig, handler) — install handler for signal sig; returns previous handler.
• raise(sig) — send signal sig to the current program; returns 0 on success.

Common signal macros

• SIGINT — interrupt (Ctrl+C in terminal).
• SIGTERM — termination request (often from kill).
• SIGFPE — floating-point exception (e.g. division by zero).
• SIGILL — illegal instruction.
• SIGSEGV — invalid memory access.
• SIGABRT — from abort().

Special handler values

• SIG_DFL — default handling (restore with signal(sig, SIG_DFL)).
• SIG_IGN — ignore the signal.
• SIG_ERR — error return from signal (not a handler).

POSIX extensions (not standard C)

On Linux/macOS you may also see sigaction, sigprocmask, kill, and signal-set functions. They are not required by ISO C signal.h—the old reference mixed them together; this page separates standard C from POSIX.

Headers and linking

• #include <signal.h> — no special link flag on most platforms.
• Compile: gcc program.c -std=c11 -o program

Examples Gallery

Compile with gcc file.c -std=c11 -o out. Examples use raise() so output is reproducible without pressing Ctrl+C. On a real terminal, SIGINT also arrives from the keyboard.

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

static volatile sig_atomic_t got_sigint = 0;

void handle_sigint(int sig) {
    (void)sig;
    got_sigint = 1;
}

int main(void) {
    if (signal(SIGINT, handle_sigint) == SIG_ERR) {
        printf("Could not install SIGINT handler\n");
        return 1;
    }

    printf("Simulating Ctrl+C with raise(SIGINT)...\n");
    raise(SIGINT);

    if (got_sigint) {
        printf("Caught SIGINT (signal %d) — handler ran safely\n", SIGINT);
    }

    return 0;
}

Simulating Ctrl+C with raise(SIGINT)...
Caught SIGINT (signal 2) — handler ran safely

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

static volatile sig_atomic_t count = 0;

void on_signal(int sig) {
    (void)sig;
    count++;
}

int main(void) {
    signal(SIGINT, on_signal);

    raise(SIGINT);
    raise(SIGINT);
    raise(SIGINT);

    printf("Handler called %d time(s)\n", (int)count);

    return 0;
}

Handler called 3 time(s)

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

static volatile sig_atomic_t caught = 0;

void handler(int sig) {
    (void)sig;
    caught = 1;
}

int main(void) {
    signal(SIGINT, handler);
    raise(SIGINT);
    printf("With handler: caught = %d\n", (int)caught);

    signal(SIGINT, SIG_IGN);
    caught = 0;
    raise(SIGINT);
    printf("With SIG_IGN: caught = %d (still 0)\n", (int)caught);

    return 0;
}

With handler: caught = 1
With SIG_IGN: caught = 0 (still 0)

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

static volatile sig_atomic_t once = 0;

void catch_once(int sig) {
    (void)sig;
    once = 1;
}

int main(void) {
    signal(SIGINT, catch_once);
    raise(SIGINT);
    printf("First SIGINT: custom handler (once=%d)\n", (int)once);

    signal(SIGINT, SIG_DFL);
    printf("Restored SIG_DFL — next SIGINT would use default action\n");
    printf("(not calling raise again — default often terminates)\n");

    return 0;
}

First SIGINT: custom handler (once=1)
Restored SIG_DFL — next SIGINT would use default action
(not calling raise again — default often terminates)

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

static volatile sig_atomic_t keep_running = 1;

void request_stop(int sig) {
    (void)sig;
    keep_running = 0;
}

int main(void) {
    int tick = 0;

    signal(SIGINT, request_stop);

    printf("Working... (simulate Ctrl+C after 3 ticks)\n");

    while (keep_running && tick < 10) {
        tick++;
        printf("  tick %d\n", tick);

        if (tick == 3) {
            raise(SIGINT);  /* stand in for user pressing Ctrl+C */
        }
    }

    printf("Clean shutdown after %d ticks\n", tick);
    return 0;
}

Working... (simulate Ctrl+C after 3 ticks)
  tick 1
  tick 2
  tick 3
Clean shutdown after 3 ticks

🚀 Common Use Cases

• CLI tools — catch SIGINT for graceful Ctrl+C shutdown.
• Servers — handle SIGTERM from process managers (Docker, systemd).
• Crash signals — log and exit on SIGSEGV (advanced; often use backtrace libraries).
• Timeouts — combine with alarms or timers (often POSIX alarm).
• Testing — raise to verify handler wiring in unit tests.
• Child processes — POSIX kill sends signals to other PIDs (not standard C).

📝 Notes

• Only async-signal-safe functions belong in handlers (_exit, signal, raise, etc.)—not printf or malloc.
• Use volatile sig_atomic_t for flags shared with handlers.
• signal() behavior on repeated signals varies by platform; POSIX sigaction is more reliable.
• Handlers may interrupt system calls, returning EINTR—retry if needed.
• Default action for many signals is process termination.
• Windows C runtime supports a subset of signals; behavior differs from Unix terminals.

⚡ Optimization

Signal handling overhead is negligible for occasional events like Ctrl+C. Avoid installing handlers you do not need. For high-frequency timing, prefer polling or threads rather than flooding the process with signals.

💡 Best Practices