Pipes are one of the most commonly used mechanisms for IPC (inter process communication). IPC is the mechanism by which two or more processes communicate with each other. The commonly used IPC techniques includes shared memory, message queues, pipes and FIFOs (and sometimes even files). Pipes are helpful in the unidirectional form of communication between processes.The pipe() creates a pipe.Syntax
int pipe(fd[2])pipe() creates a pair of file descriptors, pointing to a pipe inode, and places them in the array pointed to by fd. fd[0] is for reading, fd[1] is for writing.Let’s see a simple program how to use piping.
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define MSG_LEN 64
int main(){
int result;
int fd[2];
char *message="Linux World!!!";
char recvd_msg[MSG_LEN];
result = pipe (fd); //Creating a pipe fd[0] is for reading and fd[1] is for writing
if (result < 0) {
perror("pipe ");
exit(1);
}
//writing the message into the pipe
result=write(fd[1],message,strlen(message));
if (result < 0) {
perror("write");
exit(2);
}
//Reading the message from the pipe
result=read (fd[0],recvd_msg,MSG_LEN);
if (result < 0) {
perror("read");
exit(3);
}
printf("%s\n",recvd_msg);
return 0;
}
Output
Linux World!!!
As seen above , the pipe() system call creates a pipe. Now normal system calls like read() or write() can be used for reading and writing data to the pipe. As you have noticed the fd[0] can only be used for reading from the pipe and does not permit writing. Similarly fd[1] can only be used to perform writing to the pipe.
Seeing the above program, one would feel
what is the neccessity of piping?.
You are writing into the pipe and reading from it. That one can do even from a file.
Now let’s see another scenario. If we add more writes in the above program before reading anything and then start reading, you will find that the first read call will fetch you the first written message and so on. So
pipe() is helpful in Implementing a QUEUE strategy(First in First out)
FIFO: the message which was written first will be available for the first read, then the message which came second, for the second read.
Note: The first read itself can get all of the messages written by different write, if it specifies a large size in the size field (a size which can span the size of one or more writes ) as demonstrated here
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define MSG_LEN 64
int main(){
int result;
int fd[2];
char message[MSG_LEN];
char recvd_msg[MSG_LEN];
result = pipe (fd); //Creating a pipe//fd[0] is for reading and fd[1] is for writing
if (result < 0) {
perror("pipe ");
exit(1);
}
strncpy(message,"Linux World!! ",MSG_LEN);
result=write(fd[1],message,strlen(message));
if (result < 0) {
perror("write");
exit(2);
}
strncpy(message,"Understanding ",MSG_LEN);
result=write(fd[1],message,strlen(message));
if (result < 0) {
perror("write");
exit(2);
}
strncpy(message,"Concepts of ",MSG_LEN);
result=write(fd[1],message,strlen(message));
if (result < 0) {
perror("write");
exit(2);
}
strncpy(message,"Piping ", MSG_LEN);
result=write(fd[1],message,strlen(message));
if (result < 0) {
perror("write");
exit(2);
}
result=read (fd[0],recvd_msg,MSG_LEN);
if (result < 0) {
perror("read");
exit(3);
}
printf("%s\n",recvd_msg);
return 0;
}
Output:
Linux World!! Understanding Concepts of Piping
In the above program, The read() call reads all the messages in a single stretch, because of the MSG_LEN(64) which is greater than sum of the size of the messages written in four different writes. The only thing that we must remember that the read() reads in the order of messages written.
