进程间通信: 管道

管道

管道可以实现在两个进程间通信， 通过使用popen和pclose函数， 其原型如下：

#include <stdio.h>

FILE *popen(const char* command, const char *open_mode);
int pclose(FILE *steam_to_close);

open函数允许一个程序将另一个程序作为新的进程启动， 并传递数据给它或者接收它传递的数据。
command是要运行的程序名和相应的参数。
open_mode 必须是”r” 或者”w”; r表示获取到一个可读的FILE， 可以从中读取command程序的数据。 w表示获取到一个可写的FILE，可以向其写数据， command程序可以读取写过来的数据。
每个popen调用必须是r或者w，不能同时进行读写， 如果要想实现双向通信， 可以使用两个管道。

pipe调用

#include <unistd.h>

int pipe(int file_descriptor[2]);

file_descriptor是两个整数类型的文件描述符组成的数组指针。调用成功后返回0， 失败返回-1，并设置errno。
pipe将两个文件描述符以一种特殊的方式连接起来， 写到file_descriptor[1]中的数据都可以从file_descriptor[0]中读出来。而且只能这样读写， 反过来调用将失败。数据基于FIFO原则进行处理， 即读出顺序是按写入顺序来的。

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

int main(){
    int data_processed;

    int file_pipes[2];

    const char some_data[] = "123";
    char buffer[BUFSIZ + 1];

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

    if (pipe(file_pipes) == 0) {
        data_processed = write(file_pipes[1], some_data, strlen(some_data));
        printf("Wrote %d bytes\n", data_processed);
        data_processed = read(file_pipes[0], buffer, BUFSIZ);
        printf("Read %d bytes: %s\n", data_processed, buffer);
        exit(EXIT_SUCCESS);
    }
    exit(EXIT_FAILURE);
}

这个程序创建一个管道， 然后用文件描述符file_pipes[1]写数据， 用file_pipes[0]中读出数据。
编译输出结果如下：

$ ./pipe1 
Wrote 3 bytes
Read 3 bytes: 123

fork创建新进程时， 原先打开的文件描述符仍是打开的状态。 如果在原先的进程中创建一个管道， 然后再调用fork创建新进程，即可通过管道在两个进程间通信。

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

int main()
{
    int data_processed;
    int file_pipes[2];

    const char some_data[] = "123";
    char buffer[BUFSIZ + 1];

    pid_t child_pid;

    memset(buffer, '\0', sizeof(buffer));
    if (pipe(file_pipes) == 0) {
        child_pid = fork();
        if (child_pid == -1) {
            fprintf(stderr, "fork failure...");
            exit(EXIT_FAILURE);
        }

        if (child_pid == 0) {
            data_processed = read(file_pipes[0], buffer, BUFSIZ);
            printf("Read %d bytes: %s\n", data_processed, buffer);
            exit(EXIT_SUCCESS);
        } else {
            data_processed = write(file_pipes[1], some_data, strlen(some_data));
            printf("Wrote %d bytes\n", data_processed);
        }
    }
    exit(EXIT_SUCCESS);
}

上面这个程序通过pipe调用创建一个管道，fork创建一个子进程，在主线程中写入数据，并在子线程中读出。

$ ./pipe2
Wrote 3 bytes
Read 3 bytes: 123

命名管道

命名管道是特殊类型的文件， 在文件系统中文件名的形式存在， 其行为与上面的管道类似。 如果想在不相关的进程间通信， 可以采用命名管道。
命令行创建命名管道方法是mkfifo filename。 在程序中可以通过调用函数mkfilo。其原型是

#include <sys/types.h>
#include <sys/stat.h>

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

程序：

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

int main()
{
    int res = mkfifo("/tmp/test_fifo", 0777);
    if (res == 0) {
        printf("FIFO created\n");
        exit(EXIT_SUCCESS);
    }
}

$ ls -lF /tmp/
prwxrwxr-x 1 wlyuan wlyuan    0  5月  7 17:25 test_fifo|

输出结果中第一字符p表示这是一个管道， 删除可以通过rm或者unlink调用。

使用test_fifo

$ cat < /tmp/test_fifo & 
[2] 5629
$ echo "test fifo" > /tmp/test_fifo 
$ test fifo

open打开fifo命名管道

与打开普通文件的区别：
1. 不能以O_RDWR方式打开fifo，结果未定义。如果想实现在进程间双向传递数据， 最好使用一对fifo。
2. open_flag（open函数的第二个参数） O_NONBLOCK的用法。

open(const char *path, O_RDONLY);

open调用将阻塞， 除非有一个进程以写的方式打开同一个FIFO，否则它不会返回。

open(const char *path, O_RDONLY | O_NONBLOCK);

这个open调用将成功并立即返回，即使没有其他进程以写的方式打开fifo。

open(const char *path, O_WRONLY);

这种方式将阻塞，直到有进程以读的方式打开同一个fifo。

open(const char *path, O_WRONLY | O_NONBLOCK);

立即返回， 如果没有进程以读的方式打开fifo， 将返回错误-1， fifo也不会打开。

一个客户服务器例子
该例子是通过客户端向服务器server管道写入数据， 服务器端将读取到客户端写入的数据， 将其转换成大写字母， 再写入客户端的管道， 客户端读取结果显示。
client.h

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

#define SERVER_FIFO_NAME "/tmp/serv_fifo"
#define CLIENT_FIFO_NAME "/tmp/cli_%d_fifo"

#define BUFFER_SIZE 20

struct data_to_pass_st {
    pid_t client_pid;
    char some_data[BUFFER_SIZE-1];
};

server.c

#include "client.h"
#include <ctype.h>

int main()
{
    int server_fifo_fd, client_fifo_fd;

    struct data_to_pass_st my_data;
    int read_res;
    char *tmp_char_ptr;
    char client_fifo[256];

    mkfifo(SERVER_FIFO_NAME, 0777);
    server_fifo_fd = open(SERVER_FIFO_NAME, O_RDONLY);
    if (server_fifo_fd == -1) {
        fprintf(stderr, "server fifo open failure...");
        exit(EXIT_FAILURE);
    }

    sleep(10);

    do {
        read_res = read(server_fifo_fd, &my_data, sizeof(my_data));
        if (read_res > 0) {
            tmp_char_ptr = my_data.some_data;
            while(*tmp_char_ptr) {
                *tmp_char_ptr = toupper(*tmp_char_ptr);
                tmp_char_ptr++;
            }
        }
        sprintf(client_fifo, CLIENT_FIFO_NAME, my_data.client_pid);

        client_fifo_fd = open(client_fifo, O_WRONLY);

        if (client_fifo_fd != -1) {
            write(client_fifo_fd, &my_data, sizeof(my_data));
            close(client_fifo_fd);
        }
    } while(read_res > 0);

    close(server_fifo_fd);
    unlink(SERVER_FIFO_NAME);
    exit(EXIT_SUCCESS);
}

client.c

#include "client.h"
#include <ctype.h>

int main()
{
    int server_fifo_fd, client_fifo_fd;

    struct data_to_pass_st my_data;

    int times_to_send;

    char client_fifo[256];

    server_fifo_fd = open(SERVER_FIFO_NAME, O_WRONLY);
    if (server_fifo_fd == -1) {
        fprintf(stderr, "open server fifo failure...");
        exit(EXIT_FAILURE);
    }

    my_data.client_pid = getpid();
    sprintf(client_fifo, CLIENT_FIFO_NAME, getpid());
    if (mkfifo(client_fifo, 0777) == -1) {
        fprintf(stderr, "client open fifo failure...");
        exit(EXIT_FAILURE);
    }

    for (times_to_send = 0; times_to_send < 5; times_to_send++) {
        sprintf(my_data.some_data, "data from %d", my_data.client_pid);
        printf("%d send %s, ", my_data.client_pid, my_data.some_data);
        write(server_fifo_fd, &my_data, sizeof(my_data));
        client_fifo_fd = open(client_fifo, O_RDONLY);
        if (client_fifo_fd != -1) {
            if (read(client_fifo_fd, &my_data, sizeof(my_data))  > 0) {
                printf("received: %s\n", my_data.some_data);

            }
           close(client_fifo_fd);
        }
    }

    close(server_fifo_fd);
    unlink(client_fifo);
    exit(EXIT_SUCCESS);
}

编译完成后， 通过下面shell脚本进行测试

#!/bin/sh
./server &
for i in 1 2 3 4 5
do
    ./client &
done