第4章 管道和FIFO

4.1 管道

管道是由pipe函数创建的，提供一个单向数据流。

头文件	#include <unistd.h>
函数原型	int pipe(int fd[2]);
返回值	成功则为0，出错则为-1
函数功能	该函数返回两个文件描述符：fd[0]和fd[1]。fd[0]用来读操作，fd[1]用来写操作
说明	管道只能用于有亲缘关系进程间通讯。要实现非亲缘关系进程间通讯用有名管道FIFO

4.2 管道实现半双工通讯

实现的步骤：

（1）创建管道（fd[0]和fd[1]）

（2）fork

（3）父进程关闭管道的读端（fd[0]）

（4）子进程关闭管道的写端（fd[1]）

（5）父进程往管道的写端（fd[1]）写入数据

（6）子进程从管道的读端（fd[0]）读出数据

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

 #define BUF_MAX_LEN 10

 int main()
 {
     pid_t childpid = ;
     ] = {};
     ] = {};

     // 创建管道
     )
     {
         printf("pipe error");
         ;
     }

     // 创建进程
     childpid = fork();
     )
     {
         printf("fork error\n");
         ;
     }

     // 子进程
     )
     {
         close(pipefd[]); 

         read(pipefd[], buf, BUF_MAX_LEN);
         printf("child:%s\n", buf);

         exit();
     }

     // 父进程
     close(pipefd[]);

     write(pipefd[], "hello", sizeof("hello"));
     printf("parent:%s\n", "hello");

     waitpid(childpid, NULL, );

     ;
 }

4.3 管道实现全双工通讯

实现的步骤：

（1）创建管道1（fd1[0]和fd1[1]）、管道2(fd2[0]和fd2[1])

（2）fork

（3）父进程关闭管道1的读端（fd1[0]）、关闭管道2的写端（fd2[1]）

（4）子进程关闭管道1的写端（fd1[1]）、关闭管道2的读端（fd2[0]）

（5）父、子进程间通讯

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

 #define BUF_MAX_LEN 10

 int main()
 {
     pid_t childpid = ;
     ] = {};
     ] = {};
     ] = {};

     // 创建管道fd1
     )
     {
         printf("pipe error");
         ;
     }

     // 创建管道fd2
     )
     {
         printf("pipe error");
         ;
     }

     // 创建进程
     childpid = fork();
     )
     {
         printf("fork error\n");
         ;
     }

     // 子进程
     )
     {
         sleep();
         close(pipefd1[]);
         close(pipefd2[]); 

         read(pipefd1[], buf, BUF_MAX_LEN);
         printf("child read:%s\n", buf);

         write(pipefd2[], "hi", sizeof("hi"));

         exit();
     }

     // 父进程
     close(pipefd1[]);
     close(pipefd2[]);

     write(pipefd1[], "hello", sizeof("hello"));
     read(pipefd2[], buf, BUF_MAX_LEN);
     printf("parent read:%s\n", buf);

     waitpid(childpid, NULL, );

     ;
 }

4.4 popen 和 pclose 函数

头文件	#include <stdio.h>
函数原型	FILE *popen(const char *command, const char *type);
	int pclose(FILE *stream);
返回值	成功返回文件描述符，失败返回NULL
参数	command	shell命令，这行命令将被传到 bin/sh 并使用-c 标志
	type	r：读到commond的标准输出
		w：写到command的标准输入
说明	popen创建的文件描述符，必须由pclose关闭。

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

 #define BUF_MAX_LEN 100 

 int main()
 {
     FILE *fp = NULL;
     ] = {};

     fp = popen("ls", "r");
     if (fp == NULL)
     {
         printf("popen error\n");
         ;
     }

     while (fgets(buf, BUF_MAX_LEN, fp) != NULL)
     {
         fputs(buf, stdout);
     }

     pclose(fp);

     ;
 }

4.5 FIFO

FIFO由mkfifo函数创建。

头文件	#include <sys/types.h> #include <sys/stat.h>
函数原型	int mkfifo(const char *pathname, mode_t mode);
返回值	成功返回0，出错返回-1
参数	pathname	一个普通的路径名，它是该FIFO名字
	mode	文件的权限
说明	1.mkfifo函数已隐含O_CREAT | O_EXCL，只能创建一个新的FIFO
	2.如要打开存在的FIFO，首先调用mkfifo，然后判断返回值是否为EEXIST，若返回该错误，再调用open或fopen
	3.FIFO只能读或者写，不能即读又写的，因为它是半双工的
	4.对FIFO写总是追加到末尾，对FIFO读总是从头开始，对FIFO调用lseek，则返回ESPIPE错误
	5.open打开FIFO文件时，如果以只写方式没有打开，则只读方式的open会一直阻塞

 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <errno.h>
 #include <fcntl.h>

 #define FIFO1 "/tmp/fifo1"
 #define FIFO2 "/tmp/fifo2"

 #define BUF_MAX_LEN 10

 int main()
 {
     ;
     ;
     pid_t childpid = ;
     ] = {};

     // 打开2个FIFO
     ) < ) && (errno != EEXIST))
     {
         printf("mkfifo error:cannot open %s\n", FIFO1);
         ;
     }

     ) < ) && (errno != EEXIST))
     {
         unlink(FIFO1);
         printf("mkfifo error:cannot open %s\n", FIFO2);
         ;
     }

     // fork子进程
     childpid = fork();
     )
     {
         unlink(FIFO1);
         unlink(FIFO2);
         printf("fork error\n");
         ;
     }

     // child
     )
     {
         readfd = open(FIFO1, O_RDONLY, );
         writefd = open(FIFO2, O_WRONLY, );  

         write(writefd, "hi", sizeof("hi"));
         read(readfd, buf, BUF_MAX_LEN);
         printf("child recv:%s\n", buf);

         close(readfd);
         close(writefd);

         exit();
     }

     // parent
     writefd = open(FIFO1, O_WRONLY, );
     readfd = open(FIFO2, O_RDONLY, );  

     write(writefd, "hello", sizeof("hello"));
     read(readfd, buf, BUF_MAX_LEN);
     printf("parent recv:%s\n", buf);

     waitpid(childpid, NULL, );

     close(readfd);
     close(writefd);

     unlink(FIFO1);
     unlink(FIFO2);

     ;
 }

4.6 管道和FIFO的区别

（1）创建并打开一个管道只需调用pipe。创建并打开一个FIFO则需要在调用mkfifo后再调用open。

（2）管道在所有进程都关闭后自动关闭。FIFO的名字则只能通过调用unlink才从文件系统中删除。

（3）FIFO有一个名字，可以供无亲缘关系的进程间通讯，管道不可以。

4.7 管道和FIFO的额外属性

（1）将描述符设置成非阻塞。

（2）write写入的字节数小于或等于PIPE_BUF（Posix限制），那么write操作是原子性的；如果写入数据大于PIPE_BUF，那么write操作不保证原子性。O_NOBLOCK标志对write的原子性没有影响

（3）如果向一个没有读打开的管道或FIFO写入，那么内核将产生一个SIGPIPE信号。