Limitations of Signals as IPC

When Are Signals Legitimately Used for Process Communication?

• Process synchronization — Parent waits for child to initialize before proceeding (using SIGUSR1 as a “ready” signal)
• Daemon control — SIGHUP to re-read config, SIGTERM to shut down gracefully, SIGUSR1/SIGUSR2 for custom control
• Job control — Shell sends SIGSTOP/SIGCONT to manage foreground/background processes
• Timer expiration — SIGALRM from alarm(), POSIX timer signals
• Event notification — SIGCHLD when a child exits

/* signal_sync_demo.c - Parent/child synchronization via signals */
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>

static volatile sig_atomic_t child_ready = 0;

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

int main(void) {
    /* Parent blocks SIGUSR1 before fork so it doesn't miss it */
    sigset_t block, prev;
    sigemptyset(&block);
    sigaddset(&block, SIGUSR1);
    sigprocmask(SIG_BLOCK, &block, &prev);

    struct sigaction sa = { .sa_handler = handler };
    sigemptyset(&sa.sa_mask);
    sigaction(SIGUSR1, &sa, NULL);

    pid_t child = fork();

    if (child == 0) {
        /* Child: do initialization work, then signal parent */
        printf("Child PID=%d: initializing...\n", getpid());
        sleep(2);  /* Simulate initialization */
        printf("Child: initialization complete, signaling parent\n");
        kill(getppid(), SIGUSR1);  /* Tell parent we're ready */

        /* Continue with actual work */
        sleep(5);
        printf("Child: done\n");
        exit(0);
    }

    /* Parent: wait for child to be ready using sigsuspend */
    printf("Parent PID=%d: waiting for child to initialize...\n", getpid());

    while (!child_ready)
        sigsuspend(&prev);  /* atomically unblock SIGUSR1 and wait */

    sigprocmask(SIG_SETMASK, &prev, NULL);
    printf("Parent: child is ready! Proceeding with work.\n");

    /* Now do work that depends on child being initialized */
    printf("Parent: doing work...\n");
    sleep(2);

    wait(NULL);
    printf("Parent: child exited\n");
    return 0;
}

/* daemon_control.c - Using signals to control a daemon */
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <syslog.h>

static volatile sig_atomic_t reload_config = 0;
static volatile sig_atomic_t shutdown_requested = 0;

void sighup_handler(int sig) {
    reload_config = 1;   /* flag: main loop will reload */
}

void sigterm_handler(int sig) {
    shutdown_requested = 1;  /* flag: main loop will exit cleanly */
}

int main(void) {
    /* Install daemon control signal handlers */
    struct sigaction sa;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;

    sa.sa_handler = sighup_handler;
    sigaction(SIGHUP, &sa, NULL);

    sa.sa_handler = sigterm_handler;
    sigaction(SIGTERM, &sa, NULL);

    openlog("myDaemon", LOG_PID, LOG_DAEMON);
    syslog(LOG_INFO, "Daemon started (PID=%d)", getpid());

    printf("Daemon PID=%d running.\n", getpid());
    printf("  kill -HUP %d   → reload config\n", getpid());
    printf("  kill -TERM %d  → graceful shutdown\n\n", getpid());

    while (!shutdown_requested) {
        if (reload_config) {
            reload_config = 0;
            printf("Reloading configuration...\n");
            syslog(LOG_INFO, "Config reloaded");
        }
        /* Main daemon work */
        sleep(1);
        printf(".");
        fflush(stdout);
    }

    printf("\nShutdown signal received. Cleaning up...\n");
    syslog(LOG_INFO, "Daemon shutting down gracefully");
    closelog();
    return 0;
}

System V Signal API

/* sysv_api_demo.c - System V signal API (for legacy porting only) */
#define _XOPEN_SOURCE 500
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void handler(int sig) {
    printf("Handler: caught signal %d\n", sig);
}

int main(void) {
    /* POSIX-preferred equivalent shown in comments */

    /* System V: sigset() -- equivalent to sigaction() with reliable semantics */
    sigset(SIGINT, handler);       /* POSIX: sigaction(SIGINT, &sa, NULL) */

    /* System V: sighold() -- equivalent to sigprocmask(SIG_BLOCK) for one sig */
    sighold(SIGINT);               /* POSIX: sigaddset + sigprocmask SIG_BLOCK */

    printf("SIGINT blocked (held). Press Ctrl+C -- signal will be pending.\n");
    sleep(3);

    /* System V: sigrelse() -- equivalent to sigprocmask(SIG_UNBLOCK) */
    sigrelse(SIGINT);              /* POSIX: sigprocmask(SIG_UNBLOCK, ...) */
    printf("SIGINT unblocked (released)\n");

    sleep(1);

    /* System V: sigignore() -- equivalent to signal(sig, SIG_IGN) */
    sigignore(SIGINT);             /* POSIX: signal(SIGINT, SIG_IGN) */
    printf("SIGINT now ignored. Ctrl+C will have no effect.\n");
    sleep(2);

    /* System V: sigset() with SIG_HOLD -- adds to mask without changing handler */
    sigset(SIGTERM, SIG_HOLD);     /* POSIX: sigprocmask(SIG_BLOCK, ...) */

    printf("Done. PID=%d\n", getpid());
    return 0;
}

BSD Signal API

/* bsd_api_demo.c - BSD signal API (legacy porting reference) */
#define _BSD_SOURCE
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void handler(int sig) {
    printf("Handler: caught signal %d\n", sig);
}

int main(void) {
    /* BSD: sigvec -- analog of sigaction */
    struct sigvec vec, old_vec;
    vec.sv_handler = handler;
    vec.sv_mask = 0;       /* sigmask() to set which signals to block in handler */
    vec.sv_flags = 0;      /* SV_INTERRUPT = don't restart system calls (non-default) */
    sigvec(SIGINT, &vec, &old_vec);

    /* BSD: sigblock -- block multiple signals at once using bitmask */
    int old_mask = sigblock(sigmask(SIGINT) | sigmask(SIGQUIT));
    /* POSIX equivalent:
       sigset_t mask;
       sigemptyset(&mask);
       sigaddset(&mask, SIGINT); sigaddset(&mask, SIGQUIT);
       sigprocmask(SIG_BLOCK, &mask, NULL); */

    printf("SIGINT and SIGQUIT blocked. PID=%d\n", getpid());
    sleep(3);

    /* BSD: sigsetmask -- set mask to an absolute value */
    sigsetmask(old_mask);  /* restore old mask -- unblocks SIGINT and SIGQUIT */
    /* POSIX: sigprocmask(SIG_SETMASK, &old_mask, NULL) */

    printf("Signals unblocked\n");
    sleep(2);
    return 0;
}

/* Implementing System V functions using POSIX (for learning/portability) */
#define _POSIX_C_SOURCE 200809L
#include <signal.h>
#include <errno.h>

typedef void (*sighandler_t)(int);

/* Implement sighold() using POSIX sigprocmask */
int my_sighold(int sig) {
    sigset_t mask;
    sigemptyset(&mask);
    sigaddset(&mask, sig);
    return sigprocmask(SIG_BLOCK, &mask, NULL);
}

/* Implement sigrelse() using POSIX sigprocmask */
int my_sigrelse(int sig) {
    sigset_t mask;
    sigemptyset(&mask);
    sigaddset(&mask, sig);
    return sigprocmask(SIG_UNBLOCK, &mask, NULL);
}

/* Implement sigignore() using sigaction */
int my_sigignore(int sig) {
    struct sigaction sa;
    sa.sa_handler = SIG_IGN;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    return sigaction(sig, &sa, NULL);
}

/* Implement sigpause() using sigsuspend */
int my_sigpause(int sig) {
    sigset_t mask;
    /* Get current mask */
    sigprocmask(SIG_SETMASK, NULL, &mask);
    /* Remove just this signal from the mask */
    sigdelset(&mask, sig);
    /* Atomically: use this mask and suspend */
    return sigsuspend(&mask);
    /* sigsuspend always returns -1 with errno=EINTR */
}

Chapter 22 — Complete Summary