Mastering POSIX Signals, Fork, and Pipes in C: A Practical Guide

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

volatile sig_atomic_t flag = 0;

void handle_sigint(int sig) {
    flag = 1;
}

int main() {
    struct sigaction sa;
    sa.sa_handler = handle_sigint;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sigaction(SIGINT, &sa, NULL);

    while (!flag) {
        printf("Working...\n");
        sleep(1);
    }
    printf("\nExiting gracefully.\n");
    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();

    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) {
        // Child process
        printf("Child: PID = %d, Parent PID = %d\n", getpid(), getppid());
    } else {
        // Parent process
        printf("Parent: PID = %d, Child PID = %d\n", getpid(), pid);
        wait(NULL); // Wait for child to finish
    }
    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>

int main() {
    int fd[2];
    if (pipe(fd) == -1) {
        perror("pipe");
        return 1;
    }

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) {
        // Child: read from pipe
        close(fd[1]); // Close unused write end
        char buffer[256];
        ssize_t n = read(fd[0], buffer, sizeof(buffer) - 1);
        if (n > 0) {
            buffer[n] = '\0';
            printf("Child received: %s\n", buffer);
        }
        close(fd[0]);
    } else {
        // Parent: write to pipe
        close(fd[0]); // Close unused read end
        char *msg = "Hello from parent!";
        write(fd[1], msg, strlen(msg));
        close(fd[1]);
        wait(NULL);
    }
    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    int to_child[2], to_parent[2];
    if (pipe(to_child) == -1 || pipe(to_parent) == -1) {
        perror("pipe");
        return 1;
    }

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) {
        // Child
        close(to_child[1]); // Close write end of to_child
        close(to_parent[0]); // Close read end of to_parent

        int num;
        read(to_child[0], &num, sizeof(num));
        int result = num * num;
        write(to_parent[1], &result, sizeof(result));

        close(to_child[0]);
        close(to_parent[1]);
    } else {
        // Parent
        close(to_child[0]); // Close read end of to_child
        close(to_parent[1]); // Close write end of to_parent

        int num = 5;
        write(to_child[1], &num, sizeof(num));
        int result;
        read(to_parent[0], &result, sizeof(result));
        printf("Square of %d is %d\n", num, result);

        close(to_child[1]);
        close(to_parent[0]);
        wait(NULL);
    }
    return 0;
}

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>

volatile sig_atomic_t child_exit = 0;

void sigchld_handler(int sig) {
    int status;
    pid_t pid;
    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
        printf("Child %d exited with status %d\n", pid, WEXITSTATUS(status));
    }
    child_exit = 1;
}

int main() {
    struct sigaction sa;
    sa.sa_handler = sigchld_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
    sigaction(SIGCHLD, &sa, NULL);

    for (int i = 0; i < 3; i++) {
        pid_t pid = fork();
        if (pid == 0) {
            // Child
            printf("Child %d starting\n", getpid());
            sleep(1);
            exit(i);
        }
    }

    // Parent waits for all children (handler does the reaping)
    while (!child_exit) {
        pause(); // Wait for signal
    }
    printf("All children done.\n");
    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <sys/select.h>

int signal_pipe[2];

void sigint_handler(int sig) {
    write(signal_pipe[1], "", 1); // Write one byte
}

int main() {
    if (pipe(signal_pipe) == -1) {
        perror("pipe");
        return 1;
    }

    struct sigaction sa;
    sa.sa_handler = sigint_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    sigaction(SIGINT, &sa, NULL);

    fd_set readfds;
    FD_ZERO(&readfds);
    FD_SET(signal_pipe[0], &readfds);

    printf("Waiting for SIGINT...\n");
    select(signal_pipe[0] + 1, &readfds, NULL, NULL, NULL);

    char buf;
    read(signal_pipe[0], &buf, 1);
    printf("Signal received. Exiting.\n");

    close(signal_pipe[0]);
    close(signal_pipe[1]);
    return 0;
}