What Triggers SIGHUP?

What Happens When the Controlling Process Receives SIGHUP?

SIGHUP After the Controlling Process Terminates — Read() Behaviour

Special Use: Daemon Reinitialisation

Code Example 1 — Catching and Logging SIGHUP

/* sighup_demo.c
 * Simple program that catches SIGHUP and logs it.
 * Run in background, then close the terminal to observe SIGHUP.
 * Compile: gcc -o sighup_demo sighup_demo.c
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include <string.h>

static volatile int sighup_count = 0;

static void sighup_handler(int sig)
{
    /* Signal-safe: only increment a counter here.
     * Do real work in the main loop. */
    sighup_count++;
}

int main(void)
{
    /* Install SIGHUP handler */
    struct sigaction sa;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    sa.sa_handler = sighup_handler;
    if (sigaction(SIGHUP, &sa, NULL) == -1) {
        perror("sigaction");
        return 1;
    }

    printf("PID=%ld  PGID=%ld  SID=%ld\n",
           (long)getpid(), (long)getpgrp(), (long)getsid(0));
    printf("Waiting for SIGHUP (close terminal or: kill -HUP %ld)\n",
           (long)getpid());
    fflush(stdout);

    int prev_count = 0;
    while (1) {
        sleep(1);
        if (sighup_count != prev_count) {
            /* Real work done here, not in handler */
            printf("Received SIGHUP (total count: %d) — reinitialising...\n",
                   sighup_count);
            fflush(stdout);
            /*
             * In a real daemon, this is where you would:
             * - reread config files
             * - reopen log files
             * - reset state
             */
            prev_count = sighup_count;
        }
    }
    return 0;
}
/* Send SIGHUP manually: kill -HUP <PID>
 * Output: Received SIGHUP (total count: 1) — reinitialising...
 * This is exactly how nginx, sshd, etc. reload their configs.
 */

Code Example 2 — nohup() Effect: Ignoring SIGHUP

/* nohup_demo.c
 * Demonstrates the effect of ignoring SIGHUP (like nohup(1) does).
 * Compile: gcc -o nohup_demo nohup_demo.c
 * Normal run:  ./nohup_demo        ← will die on terminal close
 * Nohup run:   nohup ./nohup_demo &  ← survives terminal close
 *
 * This code manually does what nohup(1) does for you.
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>

int main(int argc, char *argv[])
{
    /* If --immune flag is given, ignore SIGHUP (like nohup) */
    if (argc > 1 && strcmp(argv[1], "--immune") == 0) {
        if (signal(SIGHUP, SIG_IGN) == SIG_ERR) {
            perror("signal");
            return 1;
        }
        printf("SIGHUP is IGNORED — this process is immune to terminal close\n");
    } else {
        printf("SIGHUP has DEFAULT action — this process will die on terminal close\n");
    }

    printf("PID=%ld running... close terminal or: kill -HUP %ld\n",
           (long)getpid(), (long)getpid());
    fflush(stdout);

    /* Stay alive and periodically write to a log file */
    FILE *log = fopen("/tmp/nohup_demo.log", "a");
    if (!log) log = stderr;

    for (int i = 0; i < 60; i++) {
        sleep(1);
        fprintf(log, "tick %d (PID=%ld)\n", i, (long)getpid());
        fflush(log);
    }

    if (log != stderr) fclose(log);
    return 0;
}
/* Test:
 *   ./nohup_demo --immune &
 *   close terminal window
 *   check /tmp/nohup_demo.log — process kept running!
 */

Interview Questions — Section 34.6