How does a pipe() work in Linux

In Linux, the pipe() function is a system call that creates a new pipe. A pipe is a special type of file descriptor that is used to pass data between two processes. When a pipe is created, it has a read end and a write end. One process can write to the pipe and another process can read from the pipe.

The pipe() function is defined in the unistd.h header file and has the following prototype:

int pipe(int myPipeFd[2]);

The pipe() function takes an array of two integers as its argument. This array is used to store the file descriptors for the read and write ends of the pipe. The read end of the pipe is stored in o index of array i.e. myPipeFd[0], and the write end of the pipe is stored in index 1 of array i.e. myPipeFd[1].

To use the pipe() function, you would typically call it in the following way:

int pipefd[2];

if (pipe(pipefd) == -1) {
    // Error creating pipe
    // Handle the error
} else {

// Use the pipe
}

In this example, the pipe() function is called and the file descriptors for the read and write ends of the pipe are stored in the pipefd array. If the pipe() function returns -1, it indicates that an error occurred and the pipe could not be created. Otherwise, the pipe has been successfully created and can be used for interprocess communication.

From a process, to write into a pipe, we can use write () function as shown in below example.

int pipefd[2];
char *message = "Hello, World!";

if (pipe(pipefd) == -1) {
    // Error creating pipe
    // Handle the error
} else {
    // Use the pipe
    write(pipefd[1], message, strlen(message));
}

In another process, read() function is used to read from the pipe. we need to file descriptor’s 0^th index, a buffer in which we will read the data, max number of bytes that can be read. read() function will return the number of bytes read from the pipe. Let’s see below example

char buffer[1025];
int bytesRead = 0;

if ((bytesRead  = read( pipefd[0], buffer, 1024 ) ) >= 0) {
    buffer[bytesRead] = 0;  //terminate the string
    printf("read %d bytes from the pipe: "%s"\n", bytesRead  , buffer);
} else {
    perror("read");
}

Summary: The pipe() function in Linux is a system call that creates a new pipe. A pipe is a special type of file descriptor that is used to pass data between two processes. The pipe() function takes an array of two integers as its argument, and it stores the file descriptors for the read and write ends of the pipe in this array.