How Do Pipes and Signals Enable Inter-Process Communication?

After this lesson, you will be able to:

• Create a pipe with pipe(fd) and identify read (fd[0]) and write (fd[1]) ends
• Use dup2 to redirect stdin/stdout to pipe ends
• Implement ls | wc -l in C using pipe, fork, dup2, and execlp
• Register a signal handler with signal(SIGINT, handler_fn) for Ctrl+C
• Identify which signals are catchable (SIGINT, SIGTERM) vs. uncatchable (SIGKILL)

The Shell’s Pipe, From Scratch

When you type ls | wc -l, the shell creates two processes and connects them with a pipe — the output of ls flows directly into the input of wc. You’ve been using this since Week 2. Now you’ll build it yourself.

Pipes: Connecting Processes

How pipe() Works

int fd[2];
pipe(fd);
// fd[0] = read end
// fd[1] = write end

pipe() creates a one-way communication channel. Data written to fd[1] can be read from fd[0]. Think of it as a tube: write into one end, read from the other.

Building ls | wc -l

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

int main(void)
{
    int fd[2];
    pipe(fd);

    pid_t pid1 = fork();
    if (pid1 == 0)
    {
        // Child 1: ls
        close(fd[0]);               // Close unused read end
        dup2(fd[1], STDOUT_FILENO); // Redirect stdout to pipe write end
        close(fd[1]);               // Close original write end (dup'd)
        execlp("ls", "ls", NULL);
        perror("ls failed");
        _exit(1);
    }

    pid_t pid2 = fork();
    if (pid2 == 0)
    {
        // Child 2: wc -l
        close(fd[1]);               // Close unused write end
        dup2(fd[0], STDIN_FILENO);  // Redirect stdin to pipe read end
        close(fd[0]);               // Close original read end (dup'd)
        execlp("wc", "wc", "-l", NULL);
        perror("wc failed");
        _exit(1);
    }

    // Parent: close both pipe ends and wait
    close(fd[0]);
    close(fd[1]);
    wait(NULL);
    wait(NULL);

    return 0;
}

Key Insight: dup2(fd[1], STDOUT_FILENO) rewires stdout to point to the pipe’s write end. After this, anything the child writes to stdout goes into the pipe. The second child does the reverse — dup2(fd[0], STDIN_FILENO) makes it read from the pipe. This is what the shell does behind the scenes.

Close Unused Ends

Common Pitfall: You must close the unused ends of the pipe in each process. If the reader doesn’t close the write end, it will never see EOF (it thinks more data might come from itself). If the writer doesn’t close the read end, it wastes a file descriptor.

Signals: Responding to Events

What Are Signals?

Signals are asynchronous notifications sent to a process. You’ve used them from the shell:

• Ctrl+C sends SIGINT
• Ctrl+Z sends SIGTSTP
• kill PID sends SIGTERM

Now you can handle them in code:

#include <signal.h>

void handle_sigint(int sig)
{
    printf("\nCaught SIGINT! Cleaning up...\n");
    _exit(0);
}

int main(void)
{
    signal(SIGINT, handle_sigint);

    printf("Running... Press Ctrl+C to stop.\n");
    while (1)
    {
        sleep(1);
    }

    return 0;
}

Common Signals

Sending Signals Programmatically

#include <signal.h>

kill(child_pid, SIGTERM);    // Send SIGTERM to a specific process

From Java: Java has Thread.interrupt() and shutdown hooks (Runtime.addShutdownHook) for similar purposes. C’s signals are lower-level — they interrupt at any point, not at a safe checkpoint. Signal handlers must be careful about what functions they call.

Big Picture: Pipes and signals are the two main ways Unix processes communicate. Pipes carry data between processes (the plumbing of pipelines). Signals deliver asynchronous events (interrupts, termination requests, child exits). Together with fork and exec, they give you the complete toolkit for building programs that create, coordinate, and communicate with other programs — which is exactly what a shell does.

What’s Next

The final lesson brings everything together — Unix, C, Java, pointers, memory, processes — into a unified picture of how software systems work.