C Signals & Interrupt Handling: Graceful Shutdown, Crash Reporting & Async Events

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

void old_handler(int sig) {
    // signal() may or may not auto-reset the handler on delivery
    // behavior on concurrent signals is implementation-defined
    printf("SIGINT via signal()\n");
}

// sigaction: precise, portable, thread-safe
void new_handler(int sig) {
    // Handler body
}

int setup_signals(void) {
    struct sigaction sa;
    
    sa.sa_handler = new_handler;
    sigemptyset(&sa.sa_mask);        // No additional signals blocked during handler
    sa.sa_flags   = SA_RESTART;      // Restart syscalls interrupted by signal
    
    if (sigaction(SIGINT,  &sa, NULL) < 0) return -1;
    if (sigaction(SIGTERM, &sa, NULL) < 0) return -1;
    
    // Ignore SIGPIPE globally (common in server code)
    sa.sa_handler = SIG_IGN;
    if (sigaction(SIGPIPE, &sa, NULL) < 0) return -1;
    
    return 0;
}

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

// BAD handler — calls async-signal-UNSAFE functions
void bad_handler(int sig) {
    printf("Received signal %d\n", sig);  // UNSAFE: printf uses malloc internally
    free(some_ptr);                        // UNSAFE: malloc/free are not re-entrant
    fclose(some_file);                     // UNSAFE: stdio is not re-entrant
}

// GOOD handler — minimalist, signal-safe
volatile sig_atomic_t g_shutdown_requested = 0;

void good_handler(int sig) {
    // ONLY: set a volatile flag
    g_shutdown_requested = 1;
    
    // Async-signal-safe functions we can call:
    // write() — direct syscall, no buffering
    const char msg[] = "Signal received\n";
    write(STDERR_FILENO, msg, sizeof(msg) - 1);
}

write()     read()      open()      close()    _exit()
kill()      getpid()    getppid()   alarm()    pause()
raise()     signal()    sigaction() sigemptyset() sigfillset()
waitpid()   fork()      execve()

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

volatile sig_atomic_t g_running = 1;     // Main loop control
volatile sig_atomic_t g_reload_config = 0; // Config reload request

void sigterm_handler(int sig) {
    g_running = 0; // Signal the main loop to stop
}

void sighup_handler(int sig) {
    g_reload_config = 1; // Signal config reload
}

int main(void) {
    struct sigaction sa_term = { .sa_handler = sigterm_handler,
                                  .sa_flags   = SA_RESTART };
    sigemptyset(&sa_term.sa_mask);
    sigaction(SIGTERM, &sa_term, NULL);
    sigaction(SIGINT,  &sa_term, NULL);
    
    struct sigaction sa_hup = { .sa_handler = sighup_handler,
                                 .sa_flags   = SA_RESTART };
    sigemptyset(&sa_hup.sa_mask);
    sigaction(SIGHUP, &sa_hup, NULL);
    
    printf("Server running (PID %d). Send SIGTERM or Ctrl+C to stop.\n", getpid());
    
    while (g_running) {
        if (g_reload_config) {
            g_reload_config = 0;
            printf("Reloading configuration...\n");
            // do_reload_config();
        }
        // Normal server work
        sleep(1);
    }
    
    // Main loop exited cleanly — perform graceful shutdown
    printf("Shutting down gracefully...\n");
    // cleanup_connections();
    // flush_write_buffers();
    return 0;
}

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

static volatile sig_atomic_t g_stop = 0;
static void            *g_cleanup_ctx = NULL;

void signal_handler(int sig) {
    g_stop = 1;
}

void setup_graceful_shutdown(void) {
    struct sigaction sa = {
        .sa_handler = signal_handler,
        .sa_flags   = 0, // Don't restart syscalls — let accept() return EINTR
    };
    sigemptyset(&sa.sa_mask);
    sigaction(SIGINT,  &sa, NULL);
    sigaction(SIGTERM, &sa, NULL);
}

int run_server(int server_fd) {
    setup_graceful_shutdown();
    
    while (!g_stop) {
        int client_fd = accept(server_fd, NULL, NULL);
        if (client_fd < 0) {
            if (g_stop) break; // accept() interrupted by our signal — expected
            perror("accept");
            continue;
        }
        handle_client(client_fd);
        close(client_fd);
    }
    
    // Here: g_stop == 1, clean up resources
    printf("Graceful shutdown: closing %d active connections\n", active_connections);
    // close_all_connections();
    // write_shutdown_log();
    return 0;
}

#include <signal.h>
#include <unistd.h>
#include <stdlib.h>

void crash_handler(int sig) {
    // Write crash info using only signal-safe write()
    const char *msg;
    if (sig == SIGSEGV) msg = "CRASH: Segmentation fault (SIGSEGV)\n";
    else if (sig == SIGBUS) msg = "CRASH: Bus error (SIGBUS)\n";
    else if (sig == SIGFPE) msg = "CRASH: Arithmetic error (SIGFPE)\n";
    else msg = "CRASH: Unknown signal\n";
    
    write(STDERR_FILENO, msg, strlen(msg)); // strlen is signal-safe
    
    // Flash flush any critical logs (platform specific)
    // fsync(log_fd); // If log_fd was opened before the crash
    
    // Re-raise with default handler to generate core dump
    signal(sig, SIG_DFL);
    raise(sig);
}

void install_crash_handlers(void) {
    struct sigaction sa = {
        .sa_handler = crash_handler,
        .sa_flags   = SA_RESETHAND, // Reset to default after first invocation
    };
    sigemptyset(&sa.sa_mask);
    sigaction(SIGSEGV, &sa, NULL);
    sigaction(SIGBUS,  &sa, NULL);
    sigaction(SIGFPE,  &sa, NULL);
}

#include <signal.h>

void critical_section(void) {
    sigset_t block_set, old_set;
    
    // Define which signals to block
    sigemptyset(&block_set);
    sigaddset(&block_set, SIGTERM);
    sigaddset(&block_set, SIGINT);
    
    // Block them, save the old mask
    sigprocmask(SIG_BLOCK, &block_set, &old_set);
    
    // === Critical section — signals queued but not delivered ===
    commit_transaction_to_disk();
    // === End critical section ===
    
    // Restore old mask — queued signals delivered now
    sigprocmask(SIG_SETMASK, &old_set, NULL);
}