Linux的管道

管道的基本概念

pipe函数

函数简介：

单向的管道函数，传入一个整型数组(比如pipefd[2])，那么pipefd[1]表示写入端，pipefd[0]表示输出端。写入端写入的数据会被内核缓存，直到读出端读取所有的数据。成功返回0，失败返回-1，同时设定错误码。

所有的pipe创建的管道都是单项的，数据只能从一端传输到另一端。

代码实例：

pfd1管道是父进程向子进程传输数据，子进程从该管道读取数据；pfd2正好相反。下面close函数如果不明白为什么关闭后不影响数据传输，请参考这篇博客

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>

#define MAX_BUFFER_SIZE 100

int main() {
    int pfd1[2];  // 父进程向子进程写数据
    int pfd2[2];  // 子进程向父进程写数据
    pid_t pid;
    char str_par[] = "parent str";

    if (pipe(pfd1) < 0) {
        perror("pipe() pfd1 error\n");
        return 1;
    }

    if (pipe(pfd2) < 0) {
        perror("pipe() pfd2 error\n");
        return 1;
    }

    pid = fork();
    if (pid < 0) {
        perror("fork() error\n");
        return 0;
    } else if (pid > 0) {  // 父进程
        close(pfd1[0]);
        close(pfd2[1]);
        
        write(pfd1[1], str_par, strlen(str_par));
        wait(NULL);  // 等待子进程结束
        
        char buf[MAX_BUFFER_SIZE];
        memset(buf, 0, sizeof(buf));
        read(pfd2[0], buf, sizeof(buf));
        printf("parent process gets child process str: %s\n",  buf);
    } else {  // 子进程
        close(pfd1[1]);
        close(pfd2[0]);

        char buf[MAX_BUFFER_SIZE];
        memset(buf, 0, sizeof(buf));
        read(pfd1[0], buf, sizeof(buf));
        printf("child process gets parent process str: %s\n", buf);
        
        memset(buf, 0, sizeof(buf));
        printf("input child process data: ");
        scanf("%s", buf);
        write(pfd2[1], buf, sizeof(buf));
    }

    return 0;
}

socketpair函数

函数简介

相当于在socket之间创建的一个双向管道，指定数据传输协议后，可以进行双向的出传输数据。
函数原型：

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
int socketpair(int domain, int type, int protocol, int sv[2]);

• domain：管道适用的作用域
• type：协议的类型
• protocol：数据传输协议
• sv[2]：管道返回的fd

创建成功返回0，失败返回-1

代码实例

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

#define parent_socket 1
#define child_socket 0
#define MAX_BUFFER_SIZE 100

int main() {
    int spfd[2];
    pid_t pid;
    
    if (socketpair(AF_UNIX, SOCK_STREAM, 0,spfd) < 0) {
        perror("socketpair() error\n");
        return 1;
    }

    pid = fork();
    if (pid < 0) {
        perror("fork() error\n");
        return 0;
    } else if (pid > 0) {
        char par[] = "This is parent's msg\n";
        write(spfd[parent_socket], par, strlen(par));
        wait(NULL);
        char buf[MAX_BUFFER_SIZE];
        memset(buf, 0, sizeof(buf));
        read(spfd[child_socket], buf, sizeof(buf));
        printf("parent gets child msg: %s", buf);
    } else {
        char chd[] = "This is child's msg\n";
        write(spfd[child_socket], chd, strlen(chd));
        char buf[MAX_BUFFER_SIZE];
        read(spfd[parent_socket], buf, sizeof(buf));
        printf("child gets parent's msg: %s", buf);
    }

    return 0;
}