進程間通信——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型攻擊）。