linux进程间通信-有名管道（FIFO）

转自： http://www.cnblogs.com/fangshenghui/p/4039805.html

有名管道（FIFO）

命名管道也被称为FIFO文件，是一种特殊的文件。由于linux所有的事物都可以被视为文件，所以对命名管道的使用也就变得与文件操作非常统一。

（1）创建命名管道

用如下两个函数中的其中一个，可以创建命名管道。

#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *filename, mode_t mode);
int mknod(const char *filename, mode_t mode | S_IFIFO, (dev_t)0);

filname是指文件名，而mode是指定文件的读写权限。mknod是比较老的函数，而使用mkfifo函数更加简单和规范，所以建议用mkfifo。

open(const char *path, O_RDONLY);//1
open(const char *path, O_RDONLY | O_NONBLOCK);//2
open(const char *path, O_WRONLY);//3
open(const char *path, O_WRONLY | O_NONBLOCK);//4

（2）打开命名管道

和打开其他文件一样，可以用open来打开。通常有四种方法：

有两点要注意:

1、就是程序不能以O_RDWR(读写)模式打开FIFO文件进行读写操作，而其行为也未明确定义，因为如一个管道以读/写方式打开，进程就会读回自己的输出，同时我们通常使用FIFO只是为了单向的数据传递。

2、就是传递给open调用的是FIFO的路径名，而不是正常的文件。（如：const char *fifo_name = "/tmp/my_fifo"; ）

3、第二个参数中的选项O_NONBLOCK，选项O_NONBLOCK表示非阻塞，加上这个选项后，表示open调用是非阻塞的，如果没有这个选项，则表示open调用是阻塞的。

（3）阻塞问题

对于以只读方式（O_RDONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_RDONLY），除非有一个进程以写方式打开同一个FIFO，否则它不会返回；如果open调用是非阻塞的的（即第二个参数为O_RDONLY | O_NONBLOCK），则即使没有其他进程以写方式打开同一个FIFO文件，open调用将成功并立即返回。

对于以只写方式（O_WRONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_WRONLY），open调用将被阻塞，直到有一个进程以只读方式打开同一个FIFO文件为止；如果open调用是非阻塞的（即第二个参数为O_WRONLY | O_NONBLOCK），open总会立即返回，但如果没有其他进程以只读方式打开同一个FIFO文件，open调用将返回-1，并且FIFO也不会被打开。

（4）使用FIFO实现进程间的通信

管道的写入端从一个文件读出数据，然后写入写管道。管道的读取端从管道读出后写到文件中。

写入端代码：fifowrite.c

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

int main()
{
const char *fifo_name = "/tmp/my_fifo";
int pipe_fd = -1;
int data_fd = -1;
int res = 0;
const int open_mode = O_WRONLY;
int bytes_sent = 0;
char buffer[PIPE_BUF + 1];
int bytes_read = 0;

if(access(fifo_name, F_OK) == -1)
 {
 printf ("Create the fifo pipe.\n");
 res = mkfifo(fifo_name, 0777);

if(res != 0)
 {
 fprintf(stderr, "Could not create fifo %s\n", fifo_name);
 exit(EXIT_FAILURE);
 }
 }

 printf("Process %d opening FIFO O_WRONLY\n", getpid());
 pipe_fd = open(fifo_name, open_mode);
 printf("Process %d result %d\n", getpid(), pipe_fd);

if(pipe_fd != -1)
 {
 bytes_read = 0;
 data_fd = open("Data.txt", O_RDONLY);
if (data_fd == -1)
 {
 close(pipe_fd);
 fprintf (stderr, "Open file[Data.txt] failed\n");
return -1;
 }

 bytes_read = read(data_fd, buffer, PIPE_BUF);
 buffer[bytes_read] = '\0';
while(bytes_read > 0)
 {

 res = write(pipe_fd, buffer, bytes_read);
if(res == -1)
 {
 fprintf(stderr, "Write error on pipe\n");
 exit(EXIT_FAILURE);
 }

 bytes_sent += res;
 bytes_read = read(data_fd, buffer, PIPE_BUF);
 buffer[bytes_read] = '\0';
 }

 close(pipe_fd);
 close(data_fd);
 }
else
 exit(EXIT_FAILURE);

 printf("Process %d finished\n", getpid());
 exit(EXIT_SUCCESS);
}

管道读取端： fiforead.c

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

int main()
{
const char *fifo_name = "/tmp/my_fifo";
int pipe_fd = -1;
int data_fd = -1;
int res = 0;
int open_mode = O_RDONLY;
char buffer[PIPE_BUF + 1];
int bytes_read = 0;
int bytes_write = 0;

 memset(buffer, '\0', sizeof(buffer));

 printf("Process %d opening FIFO O_RDONLY\n", getpid());
 pipe_fd = open(fifo_name, open_mode);
 data_fd = open("DataFormFIFO.txt", O_WRONLY|O_CREAT, 0644);


 if (data_fd == -1)
 {
 fprintf(stderr, "Open file[DataFormFIFO.txt] failed\n");
 close(pipe_fd);
return -1;
 }

 printf("Process %d result %d\n",getpid(), pipe_fd);
if(pipe_fd != -1)
 {
do
 {
 res = read(pipe_fd, buffer, PIPE_BUF);
 bytes_write = write(data_fd, buffer, res);
 bytes_read += res;
 }while(res > 0);

 close(pipe_fd);
 close(data_fd);
 }
else
 exit(EXIT_FAILURE);

 printf("Process %d finished, %d bytes read\n", getpid(), bytes_read);
 exit(EXIT_SUCCESS);
}

（5）命名管道的安全问题

有一种情况是：一个FIFO文件，有多个进程同时向同一个FIFO文件写数据，而只有一个读FIFO进程在同一个FIFO文件中读取数据时，会发生数据块的相互交错。不同进程向一个FIFO读进程发送数据是很普通的情况。这个问题的解决方法，就是让写操作的原子化。系统规定：在一个以O_WRONLY（即阻塞方式）打开的FIFO中，如果写入的数据长度小于等待PIPE_BUF，那么或者写入全部字节，或者一个字节都不写入。如果所有的写请求都是发往一个阻塞的FIFO的，并且每个写记请求的数据长度小于等于PIPE_BUF字节，系统就可以确保数据决不会交错在一起。

----------------------------

转自：http://blog.csdn.net/erlian_beijing/article/details/46698401

FIFO文

#include <sys/types.h>

#include <sys/stat.h>

int mkfifo( const char*pathname, mode_t mode);

参数：

pathname：FIFO的路径名+文件名。

mode：mode_t类型的权限描述符，同open的参数。

返回值：

成功：返回0

失败：如果文件已经存在，则会出错且返回-1。

操作FIFO文件时的特点：

系统调用的I/O函数都可以作用于FIFO，如open、close、read、write等。

打开FIFO时，非阻塞标志(O_NONBLOCK)产生下列影响:

特点一：不指定O_NONBLOCK(即open没有位或O_NONBLOCK)

1、open以只读方式打开FIFO时，要阻塞到某个进程为写而打开此FIFO

2、open以只写方式打开FIFO时，要阻塞到某个进程为读而打开此FIFO。

3、open以只读、只写方式打开FIFO时会阻塞，调用read函数从FIFO里读数据时read也会阻塞。

4、调用write函数向FIFO里写数据，当缓冲区已满时write也会阻塞。

5、通信过程中若写进程先退出了，则调用read函数从FIFO里读数据时不阻塞；若写进程又重新运行，则调用read函数从FIFO里读数据时又恢复阻塞。

6、通信过程中，读进程退出后，写进程向命名管道内写数据时，写进程也会（收到SIGPIPE信号）退出。

特点二：指定O_NONBLOCK(即open位或O_NONBLOCK)

1、先以只读方式打开：如果没有进程已经为写而打开一个FIFO, 只读open成功，并且open不阻塞。

2、先以只写方式打开：如果没有进程已经为读而打开一个FIFO，只写open将出错返回-1。

3、read、write读写命名管道中读数据时不阻塞。

4、通信过程中，读进程退出后，写进程向命名管道内写数据时，写进程也会（收到SIGPIPE信号）退出。

注意：

open函数以可读可写方式打开FIFO文件时的特点：open不阻塞，可以这样理解：因为其本身以可读可写的方式打开，所以不需要别的进程帮其打开。

注：关于非阻塞方式或非阻塞打开FIFO，read时返回值的问题：

若某个FIFO的最后一个写进程终止了或关闭了该FIFO，那么将为FIFO的读进程产生一个文件结束标志。如果 read（）读数据时第一个读到的是文件结束标志，那么就返回0。

1、阻塞方式：

1) 写进程未退出，read阻塞，等待写端的输入

2) 写进程终止了或关闭了该FIFO，read非阻塞，为FIFO的读进程产生一个文件结束标志，read的返回值为0。

2、非阻塞方式：

假设一个进程以非阻塞读方式打开一个FIFO.该FIFO之前已经被以写方式被其他进程打开,但无数据被写入,那么此时读进程需要立刻返回,那么应该返回什么呢?
我们知道如果 read（）读数据时第一个读到的是文件结束标志，那么就返回0。如果像我们想的那样没有数据读应该返回0 ，那么这个0就具有二义性。因为我们不知道是没有数据造成的返回0还是写端关闭造成的返回0.

所以POSIX.1要求，对一个非阻塞的描述符如果无数据可读，则read返回-1，而且 errno被设置为 EAGAIN。

1) 如果在随后调用read函数之前，如果另一个进程已经以写方式打开了该FIFO，并写入了数据，那么正常读取数据。

2) 如果在随后调用read函数之前，如果另一个进程已经以写方式打开了该FIFO，但是并未写入数据，read调用会立刻出错返回-1，并设置 errnno为EAGAIN。

3）如果在随后调用read函数之前，没有其他进程以写方式打开该FIFO，或是曾经有但是在read读时已经关闭了，那么read返回0，表示读到文件结束标志。FIFO文