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

static volatile sig_atomic_t got_signal = 0;

static void handler(int sig)
{
    got_signal = 1;
}

/*
 * Safe read() wrapper that retries on EINTR.
 * This is what you must do for all blocking I/O calls
 * when NOT using SA_RESTART.
 */
ssize_t safe_read(int fd, void *buf, size_t count)
{
    ssize_t n;
    while (1) {
        n = read(fd, buf, count);
        if (n == -1 && errno == EINTR) {
            /*
             * read() was interrupted by a signal handler.
             * The handler ran and returned. Try again.
             */
            printf("[safe_read] read() interrupted (EINTR). Retrying...\n");
            continue;
        }
        break;  /* success, EOF, or real error */
    }
    return n;
}

int main(void)
{
    struct sigaction sa;
    sa.sa_handler = handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;   /* No SA_RESTART — we handle EINTR manually */
    sigaction(SIGALRM, &sa, NULL);

    /* Send SIGALRM in 2 seconds — will interrupt the read() */
    alarm(2);

    printf("Waiting for input (type something, or wait 2s for SIGALRM)...\n");

    char buf[128];
    ssize_t n = safe_read(STDIN_FILENO, buf, sizeof(buf) - 1);

    if (n > 0) {
        buf[n] = '\0';
        printf("Read %zd bytes: %s", n, buf);
    } else if (n == 0) {
        printf("EOF\n");
    } else {
        perror("read failed");
    }

    if (got_signal)
        printf("(SIGALRM fired during wait)\n");

    return 0;
}

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

static void sigusr1_handler(int sig)
{
    /* Using write() — async-signal-safe */
    const char msg[] = "[Handler] SIGUSR1 fired — read() will be restarted.\n";
    write(STDOUT_FILENO, msg, sizeof(msg) - 1);
}

int main(void)
{
    struct sigaction sa;
    sa.sa_handler = sigusr1_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;  /* Tell kernel to restart interrupted syscalls */
    sigaction(SIGUSR1, &sa, NULL);

    printf("PID=%d. Reading from stdin. Send SIGUSR1 to interrupt:\n", (int)getpid());
    printf("  kill -USR1 %d\n\n", (int)getpid());

    char buf[64];
    /*
     * With SA_RESTART:
     * - You send SIGUSR1 while this read() is blocking.
     * - The handler runs and prints its message.
     * - When the handler returns, the KERNEL automatically restarts read().
     * - You do NOT see EINTR; the read() continues waiting for input.
     * - No special retry loop needed in application code!
     */
    ssize_t n = read(STDIN_FILENO, buf, sizeof(buf) - 1);

    if (n > 0) {
        buf[n] = '\0';
        printf("Read: %s", buf);
    } else {
        perror("read");
    }
    return 0;
}

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

static volatile sig_atomic_t timed_out = 0;

static void alarm_handler(int sig)
{
    timed_out = 1;
    /* Do NOT set SA_RESTART — we WANT read() to return EINTR */
}

/*
 * Read with timeout.
 * Returns:
 *   n > 0  : bytes read
 *   n == 0 : EOF
 *   n < 0  : error or timeout (check errno: EINTR = timed out)
 */
ssize_t read_with_timeout(int fd, void *buf, size_t len, unsigned int secs)
{
    struct sigaction sa, old_sa;
    sa.sa_handler = alarm_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;  /* No SA_RESTART — we want EINTR on timeout */
    sigaction(SIGALRM, &sa, &old_sa);

    timed_out = 0;
    alarm(secs);          /* Set the timeout */

    ssize_t n = read(fd, buf, len);   /* Block here — interrupted by SIGALRM */

    alarm(0);             /* Cancel the alarm if read returned before timeout */
    sigaction(SIGALRM, &old_sa, NULL);  /* Restore old SIGALRM handler */

    return n;
}

int main(void)
{
    printf("You have 5 seconds to type something:\n");
    fflush(stdout);

    char buf[128];
    ssize_t n = read_with_timeout(STDIN_FILENO, buf, sizeof(buf) - 1, 5);

    if (n > 0) {
        buf[n] = '\0';
        printf("You typed: %s", buf);
    } else if (n == 0) {
        printf("EOF\n");
    } else if (timed_out) {
        printf("\nTimeout! No input within 5 seconds.\n");
    } else {
        perror("read");
    }
    return 0;
}

siginterrupt() lets you change the SA_RESTART setting for a signal after its handler is already installed, without having to re-register the handler.

#include <signal.h>

/*
 * siginterrupt(sig, flag):
 *   flag = 1: handler for 'sig' WILL interrupt blocking syscalls (EINTR)
 *   flag = 0: handler for 'sig' will NOT interrupt (SA_RESTART behaviour)
 *
 * Note: SUSv4 marks siginterrupt() as obsolete.
 * Prefer setting sa_flags in sigaction() directly.
 */
int siginterrupt(int sig, int flag);

/* Example: make SIGALRM interrupt blocking syscalls */
siginterrupt(SIGALRM, 1);   /* equivalent to NOT having SA_RESTART */

/* Example: make SIGUSR1 NOT interrupt blocking syscalls */
siginterrupt(SIGUSR1, 0);   /* equivalent to SA_RESTART */