Three-Process Arrangement During system(“sleep 20”)

Signal Handling Rules for Correct system()

Example 1: Simple system() — Without Signal Handling (Incomplete)

/* example1_simple_system.c
 * gcc -o ex1 example1_simple_system.c && ./ex1
 *
 * Simple but INCOMPLETE implementation of system().
 * Missing: signal handling for SIGCHLD, SIGINT, SIGQUIT
 * Good to understand the base, but don't use in production.
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <errno.h>

int simple_system(const char *command)
{
    int status;
    pid_t child_pid;

    if (command == NULL)
        return 1;   /* Assume shell exists */

    child_pid = fork();

    switch (child_pid) {
    case -1:
        /* fork failed */
        return -1;

    case 0:
        /* Child: run command via shell */
        execl("/bin/sh", "sh", "-c", command, (char *)NULL);
        /* If execl fails: */
        _exit(127);

    default:
        /* Parent: wait for the specific child we created */
        /* Use waitpid not wait() — wait() could collect wrong child */
        if (waitpid(child_pid, &status, 0) == -1)
            return -1;
        return status;
    }
}

int main(void)
{
    int ret;

    printf("Testing simple_system():\n\n");

    ret = simple_system("echo Hello from simple_system!");
    if (ret == -1)
        perror("simple_system");
    else if (WIFEXITED(ret))
        printf("Exit code: %d\n\n", WEXITSTATUS(ret));

    ret = simple_system("ls /tmp | wc -l");
    if (WIFEXITED(ret))
        printf("Pipe command exit code: %d\n\n", WEXITSTATUS(ret));

    /* Demonstrate that shell features work */
    ret = simple_system("for i in 1 2 3; do echo \"item $i\"; done");
    printf("Shell loop exit: %d\n", WEXITSTATUS(ret));

    return 0;
}

Example 2: Full system() with Correct Signal Handling

/* example2_full_system.c
 * gcc -o ex2 example2_full_system.c && ./ex2
 *
 * COMPLETE, CORRECT implementation of system() per SUSv3.
 * Handles: SIGCHLD blocking, SIGINT/SIGQUIT ignoring in parent,
 *          EINTR restart for waitpid, _exit(127) on exec fail.
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <errno.h>

int full_system(const char *command)
{
    sigset_t block_mask, orig_mask;
    struct sigaction sa_ignore, sa_orig_quit, sa_orig_int, sa_default;
    pid_t child_pid;
    int status, saved_errno;

    /* Check if shell is available */
    if (command == NULL)
        return full_system(":") == 0;   /* ":" is shell no-op */

    /* --- Step 1: Block SIGCHLD, ignore SIGINT and SIGQUIT ---
     * Must do BEFORE fork() to avoid race conditions.
     * If done after fork: child might exit before parent sets up. */

    sigemptyset(&block_mask);
    sigaddset(&block_mask, SIGCHLD);
    sigprocmask(SIG_BLOCK, &block_mask, &orig_mask);

    sa_ignore.sa_handler = SIG_IGN;
    sa_ignore.sa_flags = 0;
    sigemptyset(&sa_ignore.sa_mask);
    sigaction(SIGINT,  &sa_ignore, &sa_orig_int);
    sigaction(SIGQUIT, &sa_ignore, &sa_orig_quit);

    /* --- Step 2: fork() --- */
    switch (child_pid = fork()) {

    case -1:
        /* fork failed */
        status = -1;
        break;

    case 0:
        /* --- CHILD PROCESS ---
         * Undo parent's signal changes: restore SIGINT/SIGQUIT
         * and unblock SIGCHLD. exec() will reset handlers anyway,
         * but we need to handle the window between fork and exec. */

        sa_default.sa_handler = SIG_DFL;
        sa_default.sa_flags = 0;
        sigemptyset(&sa_default.sa_mask);

        /* Only restore if caller wasn't already ignoring them */
        if (sa_orig_int.sa_handler != SIG_IGN)
            sigaction(SIGINT, &sa_default, NULL);
        if (sa_orig_quit.sa_handler != SIG_IGN)
            sigaction(SIGQUIT, &sa_default, NULL);

        /* Restore original signal mask (unblock SIGCHLD) */
        sigprocmask(SIG_SETMASK, &orig_mask, NULL);

        /* Run the command */
        execl("/bin/sh", "sh", "-c", command, (char *)NULL);

        /* Only reached if execl fails */
        _exit(127);

    default:
        /* --- PARENT PROCESS ---
         * Wait for child we created. Restart if interrupted by signal.
         * Save/restore errno around signal manipulation calls. */

        while (waitpid(child_pid, &status, 0) == -1) {
            if (errno != EINTR) {
                /* Real error from waitpid */
                status = -1;
                break;
            }
            /* EINTR: interrupted by signal, restart waitpid */
        }
        break;
    }

    /* --- Step 3: Restore signal state ---
     * Save errno first: sigaction/sigprocmask may clobber it */
    saved_errno = errno;
    sigprocmask(SIG_SETMASK, &orig_mask, NULL);
    sigaction(SIGINT,  &sa_orig_int,  NULL);
    sigaction(SIGQUIT, &sa_orig_quit, NULL);
    errno = saved_errno;

    return status;
}

int main(void)
{
    int ret;

    printf("Testing full_system() implementation:\n\n");

    /* Basic command */
    ret = full_system("echo 'Full system() works!'");
    printf("Exit: %d\n\n", WEXITSTATUS(ret));

    /* Multi-command pipeline */
    ret = full_system("ps aux | grep -c bash");
    printf("bash processes: exit %d\n\n", WEXITSTATUS(ret));

    /* Command with non-zero exit */
    ret = full_system("test -f /nonexistent_file_12345");
    printf("File test (expect 1): %d\n\n", WEXITSTATUS(ret));

    /* Check NULL: is shell available? */
    printf("Shell available: %s\n", full_system(NULL) ? "YES" : "NO");

    return 0;
}

Example 3: Chapter Exercise 27.4 — Double fork() Pattern

Exercise 27.4 asks about this pattern. It’s used to make a grandchild process become an orphan — meaning the parent doesn’t need to call wait() for it.

/* example3_double_fork.c
 * gcc -o ex3 example3_double_fork.c && ./ex3
 *
 * Chapter exercise 27.4: What does this double-fork pattern do?
 * Answer: Makes grandchild an orphan — adopted by init (PID 1).
 * Parent doesn't need to wait for grandchild → no zombie!
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <time.h>

void do_background_work(void)
{
    /* Simulate some background work */
    printf("[Grandchild PID %d] Starting background work...\n", getpid());
    printf("[Grandchild] PPID = %d (should be 1 = init)\n", getppid());
    sleep(2);
    printf("[Grandchild] Background work done!\n");
    exit(0);
}

int main(void)
{
    pid_t child_pid, grandchild_pid;
    int status;

    printf("Parent PID: %d\n", getpid());

    /* Step 1: First fork */
    child_pid = fork();
    if (child_pid == -1) { perror("fork1"); exit(1); }

    if (child_pid == 0) {
        /* CHILD process */
        printf("Child PID: %d, PPID: %d\n", getpid(), getppid());

        /* Step 2: Second fork */
        grandchild_pid = fork();
        if (grandchild_pid == -1) { perror("fork2"); exit(1); }

        if (grandchild_pid == 0) {
            /* GRANDCHILD: do real work here */
            do_background_work();
            /* NOT REACHED */
        }

        /* CHILD: exit immediately, making grandchild an orphan */
        printf("Child: exiting immediately, grandchild %d is now orphan\n",
               grandchild_pid);
        exit(0);
    }

    /* PARENT: only waits for the short-lived child (fast) */
    if (waitpid(child_pid, &status, 0) == -1) {
        perror("waitpid"); exit(1);
    }
    printf("Parent: child %d exited. Parent is FREE — no need to wait for grandchild!\n",
           child_pid);
    printf("Parent: doing other work while grandchild runs independently...\n");

    /* Parent can continue without waiting for grandchild.
     * Grandchild is adopted by init (PID 1), which will reap it.
     * No zombie! */
    sleep(3);   /* Give grandchild time to finish */
    printf("Parent: done.\n");
    return 0;
}

/* Why is this useful?
 * - Long-running background tasks (like a daemon subprocess)
 * - Parent doesn't want to block waiting for the long task
 * - Avoids zombie: init automatically reaps orphaned children
 * Real use cases: launching daemons, background file operations
 */

Chapter 27 — Complete Summary