Pipes in Inter-Process Communication (IPC)

What Are Pipes?

Pipes are one of the oldest and simplest forms of Inter-Process Communication (IPC). They create a communication channel between processes, typically in a unidirectional flow: one process writes data into the pipe, and another reads from it.

There are two main types of pipes:

1. Anonymous Pipes – used between related processes (like parent and child).
2. Named Pipes (FIFOs) – can be used between unrelated processes, identified by a name in the filesystem.

🔄 Real-Life Analogy

Imagine a conveyor belt between two factory workers. One worker places boxes (data) on one end, and the other picks them up at the other end. The belt only moves in one direction — like a pipe transferring data from writer to reader.

🧰 How Pipes Work

🧵 Anonymous Pipes

• Created in memory using the pipe() system call.
• Typically used for parent-child communication (via fork()).
• Unidirectional: one end for reading, one for writing.

📁 Named Pipes (FIFOs)

• Created using mkfifo() or mknod().
• Exist in the filesystem (e.g., /tmp/myfifo).
• Can be accessed by any process with permission.
• Also unidirectional, though bidirectional usage is possible with care.

🛠️ Example: Anonymous Pipe in C

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

int main() {
    int fd[2];
    pid_t pid;
    char buffer[100];

    pipe(fd);
    pid = fork();

    if (pid == 0) {
        // Child Process
        close(fd[1]); // Close write end
        read(fd[0], buffer, sizeof(buffer));
        printf("Child received: %s\n", buffer);
    } else {
        // Parent Process
        close(fd[0]); // Close read end
        const char* message = "Hello from parent!";
        write(fd[1], message, strlen(message) + 1);
    }

    return 0;
}

🧪 Example: Named Pipe (FIFO) in Linux

Terminal 1:

mkfifo /tmp/myfifo
cat /tmp/myfifo

Terminal 2:

echo "Hello from FIFO" > /tmp/myfifo

This simple interaction shows one process writing to a FIFO, and another reading from it.

🔐 Security and Lifecycle

• Pipes inherit permissions from the creating process or file system (FIFOs).
• FIFOs must be deleted when no longer needed (rm /tmp/myfifo).
• Be cautious of blocking behavior:
  • Reading blocks if no data is available.
  • Writing blocks if no reader is present (unless using non-blocking I/O).

✅ Advantages of Pipes

❌ Limitations / Challenges

🔍 Use Cases for Pipes

🔁 Pipes vs Other IPC Methods

🧠 Best Practices

• ✅ Close unused ends of pipes to prevent resource leaks.
• 🕵️ Handle EOF and blocking cases carefully.
• 🔁 Use select() or poll() for multiplexing I/O on pipes.
• 📉 Avoid large data transfers; use shared memory for that instead.

🏁 Final Thoughts

Pipes remain a go-to IPC tool for simple, fast, and stream-based communication, especially when dealing with related processes or command-line pipelines. They may not be the most powerful IPC mechanism, but they are elegant and practical for many everyday scenarios.

Use pipes when:

• You need quick, temporary communication.
• You’re chaining commands.
• You're communicating with a forked process.