About Linux IPC (vi): Pipe and FIFO

The earliest IPC form on UNIX systems is pipeline, and pipeline creation uses the pipe function:

1. #include <unistd.h>
2. int pipe (int pipefd[2]);

The function creates a one-way pipeline that returns two descriptors pipefd[0], and pipefd[1],pipefd[0] for read operations, Pipefd[1] for write operations. This function generally applies communication between a parent-child process (a relational process), first a process creates a pipeline, then a subprocess, and the parent-child process can communicate through the pipeline.
Piping has the following characteristics:
The pipe is half-duplex, the data can only flow in one direction, when two sides need to communicate, need to establish two pipelines;
Can only be used between parent-child processes or sibling processes (affinity processes);
Separate form a separate file system: A pipe is a file for the process at both ends of the pipe, but it is not an ordinary file, it does not belong to a file system, but is a separate file system, and only exists in memory.
Read and write data: a process that writes to the pipeline is read out by the process at the other end of the pipeline. The content that is written is added to the end of the pipe buffer every time, and the data is read from the head of the buffer each time.


The function pipe is generally used in the following steps:
1.pipe creating pipelines;
2.fork creating sub-processes;
3. The parent-child process shuts down read and write (or write and read) descriptors, respectively;
4. Read the end on the read descriptor to start reading (or block on the read to wait for the writing end to write), write end to write, complete the parent-child process communication process.
A simple communication implementation (modified from the Linux Man Manual)

2. #include <sys/wait.h>
4. #include <stdio.h>
6. #include <stdlib.h>
8. #include <unistd.h>
10. #include <string.h>
12. #include <errno.h>
18. int main (int argc, char *argv[])
20. {
22. int pipefd[2];
24. pid_t Cpid;
26. Char buf[128];
28. int Readlen;
34. if (argc! = 2) {
36. fprintf (stderr, "Usage:%s <string>\n", argv[0]);
38. return-1;
40. }
42. if (pipe (PIPEFD) < 0) {
44. fprintf (stderr, "pipe:%s\n", Strerror (errno));
46. return-1;
48. }
50. Cpid = fork ();
52. if (Cpid < 0) {
54. fprintf (stderr, "fork:%s\n", Strerror (errno));
56. return-1;
58. }
60. if (0 = = cpid) {/ * child process * /
62. Close (pipefd[1]); / * Child process Close Write end * /
64. Readlen = Read (Pipefd[0], buf, 128); //child process blocking on read, waiting for parent process to write
66. if (Readlen < 0) {
68. fprintf (stderr, "read:%s\n", Strerror (errno));
70. return-1;
72. }
74. Write (Stdout_fileno, buf, Readlen);
76. Write (Stdout_fileno, "\ n", 1);
78. Close (pipefd[0]); //Close read descriptor after reading
80. return 0;
82. } Else {/ * parent Process * /
84. Close (pipefd[0]); / * The parent process closes the useless read-
86. Sleep (2);
88. Write (Pipefd[1], argv[1], strlen (argv[1])); //Parent process starts writing
90. Close (pipefd[1]); / * Parent Process Close Write descriptor * /
92. Wait (NULL); / * Parent process waits for child process to exit, recycle child process resource * /
94. return 0;
96. }
98. }

The runtime prints the command-line input parameters, and after the parent process sleeps for 2 seconds, the child process is blocked from reading until the parent process finishes writing the data, the visible pipeline has a synchronization mechanism and does not need to add the synchronization mechanism itself. If you want two processes to transmit data in two directions, you need to build two pipelines to implement them.
The biggest disadvantage of a pipeline is that it can only communicate between processes that have a common ancestor process, and there is no way to use it between two unrelated processes, but a well-known pipeline FIFO solves this problem. FIFO is similar to pipe, but also only one-way transmission of data, but unlike the pipe, he can communicate between unrelated processes, it provides a path associated with it, so long as the process can access the path can establish communication, similar to the previous shared memory, provides a path associated with it.

1. #include <sys/types.h>
2. #include <sys/stat.h>
3. int Mkfifo (const char *pathname, mode_t mode);

Pathname is the system pathname and mode is the file permission bit, similar to the second parameter of the Open function.
Opening or creating a new FIFO is called Mkfifo First, and when the specified pathname already exists, MKFIFO returns a eexist error, and the Open function is called again.
The following is the use of MKFIFO to achieve two-way communication between unrelated processes, where two FIFO is required to be used for both reading and writing. The service process loops the read and waits for the client process to write, then prints the data from the client process and returns the data to the client process; The client process writes data to the server and waits for the data returned by the service process to be read.
Server process:

2. #include <stdio.h>
4. #include <string.h>
6. #include <errno.h>
8. #include <sys/stat.h>
10. #include <sys/types.h>
12. #include <fcntl.h>
14. #include "slnipc.h"
16. int main (int argc, const Char *argv[])
18. {
20. int RC;
22. int wr_fd, RD_FD;
24. Char sendbuf[128];
26. Char recvbuf[128];
28. rc = Mkfifo (Sln_ipc_2ser_path, O_creat | O_EXCL); //Set up FIFO for service process read
30. if (RC < 0) && (errno! = eexist)) {
32. fprintf (stderr, "Mkfifo:%s\n", Strerror (errno));
34. return-1;
36. }
38. rc = Mkfifo (Sln_ipc_2clt_path, O_creat | O_EXCL); //Establish FIFO for service process write
40. if (RC < 0) && (errno! = eexist)) {
42. fprintf (stderr, "Mkfifo:%s\n", Strerror (errno));
44. return-1;
46. }
48. WR_FD = open (Sln_ipc_2clt_path, O_RDWR, 0);
50. if (wr_fd < 0) {
52. fprintf (stderr, "Open:%s\n", Strerror (errno));
54. return-1;
56. }
58. RD_FD = open (Sln_ipc_2ser_path, O_RDWR, 0);
60. if (rd_fd < 0) {
62. fprintf (stderr, "Open:%s\n", Strerror (errno));
64. return-1;
66. }
68. for (;;) {  
70. rc = Read (RD_FD, recvbuf, sizeof (RECVBUF)); //Loop waiting for customer process data to be accepted
72. if (RC < 0) {
74. fprintf (stderr, "read:%s\n", Strerror (errno));
76. continue;
78. }
80. printf ("Server recv:%s\n", recvbuf);
82. snprintf (SendBuf, sizeof (SENDBUF), "Hello, this is server!\n");
84. rc = Write (WR_FD, SendBuf, strlen (SENDBUF));
86. if (RC < 0) {
88. fprintf (stderr, "write:%s\n", Strerror (errno));
90. continue;
92. }
94. }
96. Close (WR_FD);
98. Close (RD_FD);
100. return 0;
102. }

Client process

2. #include <stdio.h>
4. #include <sys/stat.h>
6. #include <sys/types.h>
8. #include <fcntl.h>
10. #include <string.h>
12. #include <errno.h>
14. #include "slnipc.h"
16. int main (int argc, const Char *argv[])
18. {
20. int RC;
22. int rd_fd, WR_FD;
24. Char recvbuf[128];
26. Char sendbuf[128];
28. if (argc! = 2) {
30. fprintf (stderr, "Usage:%s <string>\n", argv[0]);
32. return-1;
34. }
36. snprintf (SendBuf, sizeof (SENDBUF), "%s", argv[1]);
38. WR_FD = open (Sln_ipc_2ser_path, O_RDWR, 0);
40. if (wr_fd < 0) {
42. fprintf (stderr, "Open:%s\n", Strerror (errno));
44. return-1;
46. }
48. RD_FD = open (Sln_ipc_2clt_path, O_RDWR, 0);
50. if (rd_fd < 0) {
52. fprintf (stderr, "Open:%s\n", Strerror (errno));
54. return-1;
56. }
58. rc = Write (WR_FD, SendBuf, strlen (SENDBUF));
60. if (RC < 0) {
62. fprintf (stderr, "write:%s\n", Strerror (errno));
64. return-1;
66. }
68. rc = Read (RD_FD, recvbuf, sizeof (RECVBUF));
70. if (RC < 0) {
72. fprintf (stderr, "write:%s\n", Strerror (errno));
74. return-1;
76. }
78. printf ("client read:%s\n", recvbuf);
80. Close (WR_FD);
82. Close (RD_FD);
84. return 0;
86. }

The server starts running and then runs the client, running the results

1. #./server
2. Server Recv:hi, this isFIFO client
5. #./client "Hi,this is FIFO client"
6. Client Read:hello, this is server!

Here are some similar to the socket implementation interprocess communication process, only the FIFO read-write descriptor is two, the socket read and write using the same descriptor. The emergence of FIFO overcomes the communication of pipelines only between the processes that are related to each other. and other inter-process communication has been, FIFO transmission of data is also a byte stream, you need to define the protocol format to resolve the communication data, you can use the socket section described in the way to achieve the communication protocol.

Download the source code in this section:

http://download.csdn.net/detail/gentleliu/8183027

• Related articles recommended:
• About Linux IPC (i): socket-based interprocess communication (I.)
• About Linux IPC (ii): socket-based interprocess communication (bottom)
• About Linux IPC (iii): MMAP system calls shared memory
• This article from: Hobby Linux Technology Network
• This article link: http://www.ahlinux.com/c/9591.html

About Linux IPC (vi): Pipe and FIFO