When you call pipe(), the kernel creates an internal buffer (typically 65536 bytes on Linux) and gives you two file descriptors:

#include <unistd.h>

int pipe(int filedes[2]);
/* Returns 0 on success, -1 on error */

filedes[0] — file descriptor open for reading from the pipe
filedes[1] — file descriptor open for writing to the pipe

Data written to filedes[1] can be read from filedes[0].

Example 1: Basic pipe() usage — write and read in same process

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

int main(void)
{
    int fd[2];
    char write_msg[] = "Hello from EmbeddedPathashala!";
    char read_buf[100];
    ssize_t bytes_read;

    /* Create the pipe */
    if (pipe(fd) == -1) {
        perror("pipe");
        return 1;
    }

    printf("pipe created: fd[0]=%d (read), fd[1]=%d (write)\n", fd[0], fd[1]);

    /* Write to the write end */
    write(fd[1], write_msg, strlen(write_msg));
    printf("Written: \"%s\"\n", write_msg);

    /* Read from the read end */
    bytes_read = read(fd[0], read_buf, sizeof(read_buf) - 1);
    read_buf[bytes_read] = '\0';
    printf("Read back: \"%s\"\n", read_buf);

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

Example 2: Check pipe() creates two valid file descriptors

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

void print_fd_flags(int fd, const char *label)
{
    int flags = fcntl(fd, F_GETFL);
    printf("%-20s fd=%d  flags=0x%x (%s)\n",
           label, fd, flags,
           (flags & O_WRONLY) ? "WRITE-ONLY" :
           (flags & O_RDONLY) == O_RDONLY ? "READ-ONLY" : "READ-WRITE");
}

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

    if (pipe(fd) == -1) {
        perror("pipe");
        return 1;
    }

    print_fd_flags(fd[0], "fd[0] read end:");
    print_fd_flags(fd[1], "fd[1] write end:");

    close(fd[0]);
    close(fd[1]);
    return 0;
}
/* Output:
   fd[0] read end:    fd=3  flags=0x0  (READ-ONLY)
   fd[1] write end:   fd=4  flags=0x1  (WRITE-ONLY)
*/

Pipes have no concept of message boundaries. If Process A writes 100 bytes, Process B can read them in any chunk size — 10 bytes at a time, 50 bytes, or all 100 at once. The kernel does not preserve write boundaries.

Example 3: Byte-stream nature of pipes

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

#define READ_CHUNK 5   /* Read only 5 bytes at a time */

int main(void)
{
    int fd[2];
    char *msg = "HELLO_WORLD_PIPE";  /* 16 chars */
    char buf[READ_CHUNK + 1];
    ssize_t n;

    pipe(fd);

    /* Write all at once */
    write(fd[1], msg, strlen(msg));
    close(fd[1]);   /* Signal EOF after write */

    printf("Written %zu bytes at once: \"%s\"\n", strlen(msg), msg);
    printf("Reading %d bytes at a time:\n", READ_CHUNK);

    /* Read in chunks — demonstrates byte-stream behavior */
    int chunk = 1;
    while ((n = read(fd[0], buf, READ_CHUNK)) > 0) {
        buf[n] = '\0';
        printf("  Chunk %d: \"%s\" (%zd bytes)\n", chunk++, buf, n);
    }

    close(fd[0]);
    return 0;
}
/* Output:
   Written 16 bytes at once: "HELLO_WORLD_PIPE"
   Reading 5 bytes at a time:
     Chunk 1: "HELLO" (5 bytes)
     Chunk 2: "_WORL" (5 bytes)
     Chunk 3: "D_PIP" (5 bytes)
     Chunk 4: "E" (1 bytes)
*/