IPC--FIFO

无名管道： 在内存中， read()/write()
有名管道: 在文件系统中，创建后(mkfifo())要用open()打开，用read()/write()读写

以下参考： https://blog.csdn.net/braveyly/article/details/6098288

FIFO

FIFO可以在无关的进程之间交换数据，与无名管道不同。
FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。
FIFO是半双工的

原型

#include <sys/stat.h>

int mkfifo(const char *pathname, mode_t mode);  // 返回值：成功返回0，出错返回-1

(1) 如果pathname指向的FIFO不存在，则创建FIFO，此时返回0；如果pathname指向的FIFO已经存在，则返回-1，errno==EEXIST
(2) 关于mode，此函数已隐含包含O_CREAT(64)和O_EXCL(128)，也就是说要么创建一个新的FIFO，要么返回EEXIST错误。指定S_IRUSR(256) | S_IWUSR(128) | S_IRGRP(32) | S_IROTH(4)表示FIFO允许用户读、用户写、组成员读和其他用户读

int open(const char *pathname, int flags, mode_t mode);

一个FIFO创建完后（或者是已经存在），它必须或者打开用于读，或者打开用于写。对于一个进程而言，FIFO不能打开来既读又写，因为FIFO是半双工的。
(1) 一般情况下（没有指定O_NONBLOCK）,只读open要阻塞到某个其他进程为写而打开这个FIFO为止。类似的，只写open要阻塞到某个其他进程为读而打开它为止
(2) 如果指定了O_NONBLOCK，则只读open立即返回，但是如果没有进程为读而打开一个FIFO，那么只写open将返回-1，并将errno设置成ENXIO

ssize_t write(int fd, const void *buf, size_t count);

ssize_t read(int fd, void *buf, size_t count);

 #include <unistd.h>
 
int close(int fd);

操作文件（广义的：包括普通文件、系统设备和管道）的读写关闭函数。其中fd为文件描述字

int unlink(const char *pathname);

此函数将FIFO从系统中彻底删除。成功返回0，失败返回-1。

命名管道读写规则

FIFO又叫命名管道，事实上它与管道确实在下许多相似之处，下面关于规则的讨论很体现这个相似。

从FIFO中读取数据

约定：如果一个进程为了从FIFO中读取数据而阻塞打开了FIFO，那么称该进程内的读操作为设置了阻塞标志的读操作。

如果有进程写打开FIFO，且当前FIFO为空，则对于设置了阻塞标志的读操作来说，将一直阻塞下去，直到有数据可以读时才继续执行；对于没有设置阻塞标志的读操作来说，则返回0个字节，当前errno值为EAGAIN，提醒以后再试。对于设置了阻塞标志的读操作来说，造成阻塞的原因有两种：一、当前FIFO内有数据，但有其它进程在读这些数据；二、FIFO本身为空。
解阻塞的原因是：FIFO中有新的数据写入，不论写入数据量的大小，也不论读操作请求多少数据量，只要有数据写入即可。读打开的阻塞标志只对本进程第一个读操作施加作用，如果本进程中有多个读操作序列，则在第一个读操作被唤醒并完成读操作后，其它将要执行的读操作将不再阻塞，即使在执行读操作时，FIFO中没有数据也一样（此时，读操作返回0）。如果没有进程写打开FIFO，则设置了阻塞标志的读操作会阻塞。如果FIFO中有数据，则设置了阻塞标志的读操作不会因为FIFO中的字节数少于请求的字节数而阻塞，此时，读操作会返回FIFO中现有的数据量。从FIFO中写入数据

约定：如果一个进程为了向FIFO中写入数据而阻塞打开FIFO，那么称该进程内的写操作为设置了阻塞标志的写操作。

FIFO的长度是需要考虑的一个很重要因素。系统对任一时刻在一个FIFO中可以存在的数据长度是有限制的。它由#define PIPE_BUF定义，在头文件limits.h中。在Linux和许多其他类UNIX系统中，它的值通常是4096字节，Red Hat Fedora9下是4096，但在某些系统中它可能会小到512字节。

虽然对于只有一个FIFO写进程和一个FIFO的读进程而言，这个限制并不重要，但只使用一个FIFO并允许多个不同进程向一个FIFO读进程发送请求的情况是很常见的。如果几个不同的程序尝试同时向FIFO写数据，能否保证来自不同程序的数据块不相互交错就非常关键了à也就是说，每个写操作必须“原子化”。

设置了阻塞标志的写操作：

当要写入的数据量不大于PIPE_BUF时，Linux将保证写入的原子性。如果此时管道空闲缓冲区不足以容纳要写入的字节数，则进入睡眠，直到当缓冲区中能够容纳要写入的字节数时，才开始进行一次性写操作。即写入的数据长度小于等于PIPE_BUF时，那么或者写入全部字节，或者一个字节都不写入，它属于一个一次性行为，具体要看FIFO中是否有足够的缓冲区。当要写入的数据量大于PIPE_BUF时，Linux将不再保证写入的原子性。FIFO缓冲区一有空闲区域，写进程就会试图向管道写入数据，写操作在写完所有请求写的数据后返回。

没有设置阻塞标志的写操作：

当要写入的数据量不大于PIPE_BUF时，Linux将保证写入的原子性。如果当前FIFO空闲缓冲区能够容纳请求写入的字节数，写完后成功返回；如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数，则返回EAGAIN错误，提醒以后再写。当要写入的数据量大于PIPE_BUF时，Linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后，写操作返回。

示例

1 simplefifo

FIFO的基本使用，在父子进程中使用单个FIFO，父进程向FIFO的写文件描述字写进数据，子进程从FIFO的读文件描述字中读出数据

//simplefifo.c
#include <sys/types.h>
#include <sys/stat.h>
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h> //O_RDONLY
#include <errno.h>
#define MAX_LENGTH 10
int main(int argc, char **argv)
{
    int readfd, writefd;
    pid_t childpid;
    int w_length;
    int r_length;
    char buffer[MAX_LENGTH];
    if ((mkfifo("/tmp/fifo.1", (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))<0) && (errno == EEXIST))
 {
        printf("can't create %s", "/tmp/fifo.1");
 }

    if((childpid=fork())==0)  //child process  server
    {
        readfd = open("/tmp/fifo.1", O_RDONLY, 0);
  printf("[son]readfd===%d\n",readfd);
        r_length=read(readfd,buffer,MAX_LENGTH);
        printf("[son]r_length===%d\n",r_length);
        printf("[son]buffer===%s\n",buffer);
        printf("[son]buffer===%d\n",strlen(buffer));
        close(readfd);
    }
    else
    {
        writefd=open("/tmp/fifo.1", O_WRONLY, 0);
  printf("[par]writefd===%d\n",writefd);
        w_length=write(writefd,"abcdef",11);
        printf("[par]w_length===%d\n",w_length);
        waitpid(childpid, NULL, 0); //等待子进程执行完成
        close(writefd);
        unlink("/tmp/fifo.1");
    }
}

gcc simplefifo.c -lpthread -o simplefifo

2 norelationsprocessfifo & block

没有亲缘关系的进程之间使用一个FIFO。将其中阻塞的进程称为服务端进程，将另一个称为客户端进程。客户端向FIFO写数据，服务端从FIFO读取数据

// fifo_read.c
#include <sys/types.h>
#include <sys/stat.h>  //mkfifo
#include <errno.h>  // errno
#include <fcntl.h> //O_RDONLY

#define FIFO_SERVER "/repo/ezheson/test/fifo/fifo.1"

int main(int argc, char **argv)
{
    int readfd;
    int r_length;
    char buffer[10];
    if ((mkfifo(FIFO_SERVER, (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))<0) && (errno == EEXIST))
        printf("can't create %s", "/tmp/fifo.1");
        
    printf("[server]Open fifo...\n");
    readfd = open(FIFO_SERVER, O_RDONLY, 0);
    printf("[server]Have open FIFO, fd = %d\n", readfd);
    
    printf("[server]Read FIFO...\n");
    r_length=read(readfd,buffer,6);
    printf("[server]Have read: r_length=%d; strlen(buffer)=%d; buffer=%s\n",r_length,strlen(buffer),buffer);
    
    close(readfd);
    return;
}

// fifo_write.c
#include <sys/types.h>
#include <sys/stat.h>  //mkfifo
#include <fcntl.h> //O_RDONLY
#define FIFO "/repo/ezheson/test/fifo/fifo.1"

int main(int argc, char **argv)
{
    int writefd;
    int w_length;
    printf("[client]Wait 5s, open fifo\n");
    sleep(5);
    
    writefd=open(FIFO, O_WRONLY, 0);
    printf("[client]FIFO have open, fd = %d\n", writefd);
    sleep(5);
    
    w_length=write(writefd,"abcdef",6);
    printf("[client]Have write %d datas\n", w_length);
    sleep(5);
    
    close(writefd);
    unlink(FIFO);
}

注意，对于读写的长度要严格的控制好，否则可能会写入或读出奇怪的东西。 如上，要写入"adcdef"共6个字符, 那么write()中的长度就是6，读时也用read(… , 6)

3 norelationsprocessfifo & NONBLOCK

#include <sys/types.h>
#include <sys/stat.h>  //mkfifo
#include <errno.h>  // errno
#include <fcntl.h> //O_RDONLY
#define FIFO_SERVER "/repo/ezheson/test/fifo/fifo.1"
int main(int argc, char **argv)
{
    int readfd, count = 0;
    int r_length;
    char buffer[10];
    if ((mkfifo(FIFO_SERVER, (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))<0) && (errno == EEXIST))
    {
        printf("can't create %s", "/tmp/fifo.1");
        exit(1);
    }
    printf("[server]Open fifo...\n");
    readfd = open(FIFO_SERVER, O_RDONLY | O_NONBLOCK, 0);
    printf("[server]Have open FIFO, fd = %d\n", readfd);
    printf("[server]Read FIFO...\n");
    while(1)
    {
        r_length=read(readfd,buffer,10);
        if (r_length > 0)
        {
            printf("[server]%d, Have read: r_length=%d; strlen(buffer)=%d; buffer=%s\n",count++, r_length,strlen(buffer),buffer);
        }
        else
        {
            printf("[server]%d, Have read zero\n", count++);
        }
        sleep(1);
    }
    close(readfd);
    unlink(FIFO_SERVER);
    return;
}

4 struct msg

//server.c
#include <errno.h>
#include <stdio.h>
#include "msg.h"

#define FIFO_SERVER "/repo/ezheson/test/fifo/fifo.1"

int main(int argc, char **argv)
{
    int readfd;
    size_t  len;
    ssize_t  n;
    struct mymesg mesg;
    
    if ((mkfifo(FIFO_SERVER, (S_IRUSR | S_IWUSR | S_IRGRP |S_IROTH))<0) && (errno == EEXIST))
    {
        printf("can't create %s\n", FIFO_SERVER);
    }
    
    readfd = open(FIFO_SERVER, O_RDONLY | O_NONBLOCK, 0);
    
    while(1)
    {
        /* firstly, get header info of struct */
        if ((n = read(readfd, &mesg, MESGHDRSIZE)) == 0)
        {   
            // printf("end of file!\n");   /* at the end of file, no data */
            // return(0);                  /* end of file */
            sleep(1);
            continue;
        }
        else if (n != MESGHDRSIZE)
        {   
            printf("message header: expected %d, got %d\n", MESGHDRSIZE, n);
            return(0);
        }
        
        if ((len = mesg.mesg_len) > 0)
        {
                /* get data in struct */
            if ((n = read(readfd, mesg.mesg_data, len)) != len)
            {
                printf("message data: expected %d, got %d\n", len, n);
                return(0);
            }
        }
        
        printf("[SRV]mesg_len=%d, mesg_type=%d\n",mesg.mesg_len,mesg.mesg_type);
        printf("[SRV]mesg_data=%s\n",mesg.mesg_data);
    }
    
    close(readfd);
    unlink(FIFO_SERVER);
    
    return 0;
}

CC=gcc
INCLUDES=-I/repo/ezheson/test/fifo
OUTPUTS=server.o
TARGET=server

$(TARGET):$(OUTPUTS)
        $(CC) $^ -o $@
$(OUTPUTS):%.o:%.c
        $(CC) $(INCLUDES) -c $< -o $@

.PHONY:clean
clean:
        rm -rf $(TARGET) $(OUTPUTS)

#! /bin/bash
fifo_file="/repo/ezheson/test/fifo/fifo.1"
if [[ -e ${fifo_file} ]]; then
    echo "fifo_file: ${fifo_file} exist, remove it"
    rm -rf ${fifo_file}
fi

make clean &
wait

make &
wait

echo "build finish..."
./server

//client.c
#include <string.h>
#include <stdio.h>
#include "msg.h"
#define FIFO  "/repo/ezheson/test/fifo/fifo.1"
int main(int argc, char *argv[])
{
    int writefd;
    struct mymesg mesg;
    int i, loop = 1;
    printf("argv[1] is %d, %s\n", *(argv[1]), argv[1]);
    if (argc == 2)
    {
        loop = atol(argv[1]);
    }
    printf("loop is %d\n", loop);
    writefd = open(FIFO, O_WRONLY, 0);
    mesg.mesg_len=10;
    mesg.mesg_type=1;
    strcpy(mesg.mesg_data,"abcdefghij");
    for (i = 0; i < loop; i++)
    {
        write(writefd,&mesg,MESGHDRSIZE + mesg.mesg_len);
    }
    close(writefd);
    unlink(FIFO);
}