进程间通信——FIFO（多个客户进程，一个服务进程）

FIFO简介

FIFO就是Unix的一种复合POSIX标准的进程间通信机制。他又称为命名管道，跟管道的不同点是，每个FIFO都有一个路径名与之关联。

FIFO虽然有路径名，但是他这中文件是在内核态（管道也是在内核态），跟文件系统没有关系。

单个服务器进程，多个客户端进程与服务器进通信。客户端进程想服务器进程发送请求（客户端进程通过write写FIFO），服务端处理（通过read读客户进程的请求）之后返回相应内容（通过write写入专用FIFO）。

单个服务器进程多个客户端进程通信框架

客户进程和服务器进程都知道专用FIFO的路径名，关键是怎样创建客户和服务器进程专用的FIFO。因为，一个系统的进程id是确定的并且互斥，所以我们可以通过进程id去寻找FIFO，客户进程和服务进程之间的FIFO用进程id来创建，在客户和服务器进程之间协商一个格式（比如“fifo.pid”格式）。

多个客户进程向服务器进程请求服务

本示例代码，实现的是将客户进程请求打开一个文件，具体就是客户进程传文件名，服务器进程将文件内容返回。

客户端代码：

/*
 * client.c
 *
 *  Created on: Nov 2, 2016
 *      Author: sujunjun
 */


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

#define FIFO_SERVER "fifo.server"
#define SIZE PIPE_BUF
#define FILE_MODE (S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH)

int main(){

    pid_t pid=getpid();
    char buf[SIZE];
    char client_fifo_name[SIZE];//from server
    snprintf(client_fifo_name,sizeof(client_fifo_name),"fifo.%ld",(long)pid);
    if(mkfifo(client_fifo_name,FILE_MODE)<0 && errno!=EEXIST){
            printf("mk error \n");
            exit(1);
    }
    snprintf(buf,sizeof(buf),"%ld ",(long)pid);
    int len=strlen(buf);
    char *pathname=buf+len;
    fgets(pathname,SIZE-len,stdin);
    len =strlen(buf);/f include \n

    int writefd=open(FIFO_SERVER,O_WRONLY);
    write(writefd,buf,len-1);//len-1==not include \n

    int readfd=open(client_fifo_name,O_RDONLY);
    int r;
    while((r=read(readfd,buf,SIZE))>0){
        write(STDOUT_FILENO,buf,r);
    }
    close(readfd);
    unlink(client_fifo_name);//delete this temp file
    return 0;
}

服务器代码：

/*
 * server.c
 *
 *  Created on: Nov 2, 2016
 */

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

#define FIFO_SERVER "fifo.server"//all known

#define FILE_MODE (S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH)

#define SIZE PIPE_BUF
int main(){
    if(mkfifo(FIFO_SERVER,FILE_MODE)<0 && errno!=EEXIST){
        printf("mk error \n");
        exit(1);
    }

    int readfd=open(FIFO_SERVER,O_RDONLY);
    int writefd=open(FIFO_SERVER,O_WRONLY);

    if(readfd==-1||writefd==-1){
        printf("open error \n");
        exit(1);
    }

    int r;char buf[SIZE];char *pathname;pid_t pid;char client_fifo_name[SIZE];
    while((r=read(readfd,buf,SIZE))>0){
        buf[r]='\0';
        if((pathname=strchr(buf,' '))==NULL){
            printf("not include pid\n");
            continue;
        }
        *pathname++='\0';//*pid_s=0  pid_s++
        pid=atol(buf);
        snprintf(client_fifo_name,sizeof(client_fifo_name),"fifo.%ld",(long)pid);
        if((writefd=open(client_fifo_name,O_WRONLY))<0){
            printf("error\n");
            continue;
        }
        int fd;
        if((fd=open(pathname,O_RDONLY))<0){
            printf("open this file error\n");
            write(writefd,"open this file error\n",sizeof("open this file error\n"));
            close(writefd);
        }else {
            while((r=read(fd,buf,SIZE))>0){
                write(writefd,buf,r);
            }
            close(fd);
        }
        close(writefd);
    }
    return 0;
}

运行示例：

编译两个文件

gcc client.c -o client

gcc server.c -o server

./server

./client  

./client  

./client

多开几个客户进程，请求打开不同的文件，就会看到显示的文件内容。

总结

本例子设计的是一个迭代服务器，如果要设计一个并发服务器，还需要一些多线程编程的知识。

还是要对FIFO一些特性要熟悉，比如open一个FIFO的时候，阻塞和非阻塞open之间的区别。还有FIFO的一次请求字节数必须小于等于PIPE_BUF(在limits.h中)，这样能保证一次读请求是原子操作。如果不是原子的，那么两次请求的字节内容将无法区分。因为服务器进程是一直在循环读请求字节（服务器进程里有一个大循环，read用readline代替就更好理解了）。

snprintf()函数还是比较方便，java中提供的一些字符串与数字之间转换的便利操作，其实在C语言中也有，只不过被我们忽视了。snprintf函数就为我们提供了一个很好的数字转换为字符串的函数。例如：snprintf(buf,buf的长度,"process id is %ld",(long)getpid());最后buf中存放的是"process id is 1234"(进程具体ID).

另外，迭代服务器存在一些弊端，就是在处理服务型攻击的时候比较麻烦，这个不如并发服务器好处理。

服务型攻击，就拿咱们的这个代码来说，如果咱们的客户进程只是请求服务，却从不打开自己进程与服务器专用FIFO来读服务回传的内容，这个时候，服务器可能就处于停顿状态。这就叫服务型攻击（DoS型攻击）。