Signals

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

/* volatile: always read from memory, never cache in register */
/* sig_atomic_t: safe to write from signal handler (atomic) */
volatile sig_atomic_t interrupted = 0;

/* Signal handler — called asynchronously when SIGINT arrives */
/* Signature MUST be: void handler(int signo) */
void impatient(int signo) {
    (void)signo;         /* suppress "unused parameter" warning */
    interrupted = 1;     /* just set a flag — no printf! */
}

int main(void) {
    /* sigaction is preferred over signal() */
    struct sigaction act = { 0 };   /* zero-initialize */
    act.sa_handler = impatient;
    sigaction(SIGINT, &act, NULL);  /* NULL = don't care about old handler */

    printf("Now we wait... (press Ctrl+C)\n");

    /* Main loop checks the flag — handler only sets the flag */
    while (!interrupted) {
        usleep(10000);   /* 10ms sleep */
    }

    printf("Oh.. you didn't like waiting\n");
    printf("Program terminated\n");
    return 0;
}

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

int main(void) {
    /* Ignore SIGINT — Ctrl+C will do nothing */
    signal(SIGINT, SIG_IGN);
    printf("SIGINT ignored. Ctrl+C has no effect for 3 seconds.\n");
    sleep(3);

    /* Restore the default action — Ctrl+C will terminate again */
    signal(SIGINT, SIG_DFL);
    printf("Default restored. Ctrl+C will now terminate the process.\n");
    sleep(5);   /* if you press Ctrl+C now, process terminates */

    printf("Done.\n");
    return 0;
}

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

/* write() is async-signal-safe. printf() is NOT. */
void handle_sigint(int sig) {
    /* Safe: write() is in the async-signal-safe list */
    const char msg[] = "\nCaught SIGINT — use write(), not printf()!\n";
    write(STDERR_FILENO, msg, strlen(msg));
    /* _exit() is safe. exit() is NOT (it flushes stdio buffers). */
    _exit(1);
}

int main(void) {
    struct sigaction act = { 0 };
    act.sa_handler = handle_sigint;
    sigaction(SIGINT, &act, NULL);

    /* Simulate long work */
    for (;;) {
        usleep(100000);
    }
    return 0;
}

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

int main(void) {
    pid_t my_pid = getpid();
    printf("My PID is %d\n", my_pid);
    printf("Sending SIGUSR1 to myself...\n");

    /* Send SIGUSR1 to ourselves */
    /* kill(pid, sig): returns 0 on success, -1 on error */
    kill(my_pid, SIGUSR1);

    /* SIGUSR1 default action is to terminate — so this line may not print */
    printf("Still alive (would need a handler to get here)\n");
    return 0;
}
/* shell equivalent: kill -USR1 <pid>  or  kill -10 <pid> */