【IPC】管道和FIFO

最新推荐文章于 2024-10-26 17:37:39 发布
原创 最新推荐文章于 2024-10-26 17:37:39 发布
· 1.1k 阅读 · 0 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linux #pipe #fifo #ipc

UNIX IPC有多种形式，最初使用的便是管道pipe，管道没有名字，又称匿名管道，一般用于有亲缘关系的进程间通信，后来出现了FIFO这种管道，它是有名字的，又叫做有名管道，可用于无亲缘关系的进程间通信，这两种管道的数据传输都可以使用我们最熟悉的write、read函数来完成。

1、管道pipe

创建管道使用如下pipe函数：

#include <unistd.h>
int pipe(int pipefd[2]);

pipe函数打开两个文件描述符，pipefd[0]用于读，pipefd[1]用于写，管道创建成功时返回0，否则返回-1，并设置errno。管道提供了一个单向数据流，一般用于父子进程间，两个进程分别关掉它们的读、写文件描述符，如果需要一个双向数据流，则需要创建两个管道，下面举例说明。

// mainpipe.c
/******************************
** A Client-Server Program
** Using fork and two pipes
** Client: father process, input a pathname
** Server: child process, open the pathname and write back to client
******************************/
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <unistd.h>

#define MAXLINE (100) // buffer size

// client/server, readfd for read, writefd for write
void client(int readfd, int writefd);
void server(int readfd, int writefd);

int main(int argc, char **argv)
{
    int pipe1[2];
    int pipe2[2];
    pid_t childfd;

    if (-1 == pipe(pipe1) || -1 == pipe(pipe2)) { // create two pipes
        printf("create pipe error: %s", strerror(errno));
        exit(EXIT_FAILURE);
    }

    if (0 == (childfd = fork())) { // child
        // using pipe1[0] for read and pipe2[1] for write
        // so close unused pipe1[1] and pipe2[0]
        if (-1 == close(pipe1[1]) || -1 == close(pipe2[0])) {
            printf("close pipe error: %s", strerror(errno));
            exit(EXIT_FAILURE);
        }

        server(pipe1[0], pipe2[1]); // child is a server
        exit(EXIT_SUCCESS);
    }

    // using pipe2[0] for read and pipe1[1] for write
    // so close unused pipe1[0] and pipe2[1]
    if (-1 == close(pipe1[0]) || -1 == close(pipe2[1])) {
        printf("close pipe error: %s", strerror(errno));
        exit(EXIT_FAILURE);
    }

    client(pipe2[0], pipe1[1]); // father is a client

    if (-1 == waitpid(childfd, NULL, 0)) { // wait for child to terminate
        perror("waitpid error");
        exit(EXIT_FAILURE);
    }

    exit(EXIT_SUCCESS);
}

void client(int readfd, int writefd)
{
    size_t len;
    ssize_t n;
    char buff[MAXLINE] = { 0 };

    fgets(buff, MAXLINE, stdin); // using fgets to input from stdin
    len = strlen(buff);
    if ('\n' == buff[len - 1]) {
        --len; // delete newline from fgets
    }

    if (-1 == write(writefd, buff, len)) { // write pathname to pipe
        printf("write error: %s", strerror(errno));
    }

    while (0 < (n = read(readfd, buff, MAXLINE))) { // read data from pipe
        if (-1 == write(STDOUT_FILENO, buff, n)) {
            printf("write error: %s", strerror(errno)); // write data to stdout
        }
    }
}

void server(int readfd, int writefd)
{
    int fd;
    ssize_t n;
    char buff[MAXLINE + 1] = { 0 };

    if (-1 == (n = read(readfd, buff, MAXLINE))) { // read pathname from pipe
        printf("read error: %s", strerror(errno));
    }
    else if (0 == n) {
        perror("end-of-file while reading pathname");
    }
    buff[n] = '\0'; // null terminate

    if (-1 == (fd = open(buff, O_RDONLY))) {
        perror("open error");
        snprintf(buff + n, sizeof(buff) - n, ": can't oepn, %s\n", strerror(errno));
        n = strlen(buff);
        write(writefd, buff, n); // open failed and tell client
    }
    else {
        while (0 < (n = read(fd, buff, MAXLINE))) { // open succeeded and copy file to pipe
            if (-1 == write(writefd, buff, n)) {
                printf("write error: %s", strerror(errno));
            }
        }
        if (-1 == close(fd)) {
            printf("close fd error: %s", strerror(errno));
        }
    }
}

mainpipe.c是一个简单的Client-Server程序，Client通过Server获取文件信息。为了实现双向数据流，即Client输入文件名给Server，而Server又打开这个文件并传输文件内容给Client，这里创建了两个管道。fork之后，子进程为Client，父进程为Server，父子进程分别关闭它们不需要的文件描述符，然后开始通信。

上面提到的管道是一个半双工管道，也就是说一个文件描述符只能用于读，一个文件描述符只能用于写，如果拿某个文件描述符同时进行读写，把它当作全双工管道来用，就会出错，strerror(errno)的输出为“Bad file descriptor”，不过有的系统支持全双工管道的pipe，如SVR4，而socketpair则是具有全双工管道功能的另一个函数。

如果我们在shell终端输入一些支持管道的命令，比如说“ls | sort”，这也是一种单向数据流，半双工管道，把ls的标准输出（一个进程）复制到了sort的标准输入（另一个进程）。

stdio.h中还提供了另一个使用管道的函数popen，它创建一个管道并启动另外一个进程，就好像函数内部封装了pipe和fork一样，该管道也是单双工的，或者读，或者写。

#include <stdio.h>
FILE *popen(const char *command, const char *type);
int pclose(FILE *stream);

popen的command参数是一个shell命令，type可以是r或者w，表示读或者写，pclose用于关闭打开的文件流。下面以一个例子说明popen的用法，实现shell的cat命令，所以type参数应该为r。

// mainpopen.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAXLINE (100) // buffer size

int main(int argc, char **argv)
{
    size_t n;
    char buff[MAXLINE];
    char command[MAXLINE];
    FILE *fp;

    fgets(buff, MAXLINE, stdin); // get file name
    n = strlen(buff);
    if ('\n' == buff[n - 1]) {
        --n; // delete newline from fgets
    }
    snprintf(command, sizeof(command), "cat %s", buff); // shell command

    if (NULL == (fp = popen(command, "r"))) { // create pipe for read
        perror("popen error");
        exit(EXIT_FAILURE);
    }

    while(NULL != fgets(buff, MAXLINE, fp)) {
        fputs(buff, stdout);
    }

    pclose(fp); // close from popen

    exit(EXIT_SUCCESS);
}

2、有名管道FIFO

FIFO即first in first out，类似于pipe，也是半双工的单向数据流，与pipe不同的是它关联一个路径名，因此也叫做有名管道，可以用于没有亲缘关系的进程间通信。下面是与FIFO相关的几个函数。

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int mkfifo(const char *pathname, mode_t mode);
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
int unlink(const char *pathname);

创建FIFO使用mkfifo函数（在shell终端可使用mkfifo命令创建FIFO），pathname是这个FIFO的路径名，mode为文件权限模式，类似于open函数的第三个参数，受当前进程掩码umask的影响，其真正的权限为(mode & ～umask)，创建成功时返回0，失败时返回-1并设置相应的errno。创建失败时，有可能是pathname已经存在了，这时会产生一个EEXIST错误，等同于open函数的flags参数设置了(O_CREAT | O_EXCL)一样，要么创建，要么返回文件已经存在的错误。如果pathname已经存在，可使用open函数来打开并进行IPC通信，open打开时只能是读或者写，即O_RDONLY或者O_WRONLY，而不能是O_RDWR。通信完毕后，从文件系统中删除pathname，使用unlink函数。

下面使用FIFO来代替上面Client-Server程序中的pipe，client和server函数不变，只需修改main函数即可。

// mainfifo.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define MAXLINE (100) // buffer size

#define FIFO1 "/tmp/fifo.1"
#define FIFO2 "/tmp/fifo.2"

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

// client/server, readfd for read, writefd for write
void client(int readfd, int writefd);
void server(int readfd, int writefd);

int main(int argc, char **argv)
{
    int readfd;
    int writefd;
    pid_t childpid;

    if ((0 > mkfifo(FIFO1, FILE_MODE)) && (EEXIST != errno)) { // make fifo, errno can be EEXIST
        printf("mkfifo %s error: %s", FIFO1, strerror(errno));
        exit(EXIT_FAILURE);
    }

    if ((0 > mkfifo(FIFO2, FILE_MODE)) && (EEXIST != errno)) { // make fifo, errno can be EEXIST
        printf("mkfifo %s error: %s", FIFO2, strerror(errno));
        unlink(FIFO1); // remove unuesd fifo
        exit(EXIT_FAILURE);
    }

    if (0 == (childpid = fork())) { // child
        if (0 > (readfd = open(FIFO1, O_RDONLY, 0))) {
            printf("open %s error: %s", FIFO1, strerror(errno));
        }

        if (0 > (writefd = open(FIFO2, O_WRONLY, 0))) {
            printf("open %s error: %s", FIFO2, strerror(errno));
        }

        server(readfd, writefd); // child is a server
        exit(EXIT_SUCCESS);
    }

    if (0 > (writefd = open(FIFO1, O_WRONLY, 0))) {
        printf("open %s error: %s", FIFO1, strerror(errno));
    }

    if (0 > (readfd = open(FIFO2, O_RDONLY, 0))) {
        printf("open %s error: %s", FIFO2, strerror(errno));
    }

    client(readfd, writefd); // father is a client

    if (-1 == waitpid(childpid, NULL, 0)) { // wait for child to terminate
        perror("waitpid error");
    }

    close(readfd);
    close(writefd);

    unlink(FIFO1);
    unlink(FIFO2);

    exit(EXIT_SUCCESS);
}

void client(int readfd, int writefd)
{
    size_t len;
    ssize_t n;
    char buff[MAXLINE] = { 0 };

    fgets(buff, MAXLINE, stdin); // using fgets to input from stdin
    len = strlen(buff);
    if ('\n' == buff[len - 1]) {
        --len; // delete newline from fgets
    }

    if (-1 == write(writefd, buff, len)) { // write pathname to pipe
        printf("write error: %s", strerror(errno));
    }

    while (0 < (n = read(readfd, buff, MAXLINE))) { // read data from pipe
        if (-1 == write(STDOUT_FILENO, buff, n)) {
            printf("write error: %s", strerror(errno)); // write data to stdout
        }
    }
}

void server(int readfd, int writefd)
{
    int fd;
    ssize_t n;
    char buff[MAXLINE + 1] = { 0 };

    if (-1 == (n = read(readfd, buff, MAXLINE))) { // read pathname from pipe
        printf("read error: %s", strerror(errno));
    }
    else if (0 == n) {
        perror("end-of-file while reading pathname");
    }
    buff[n] = '\0'; // null terminate

    if (-1 == (fd = open(buff, O_RDONLY))) {
        perror("open error");
        snprintf(buff + n, sizeof(buff) - n, ": can't oepn, %s\n", strerror(errno));
        n = strlen(buff);
        write(writefd, buff, n); // open failed and tell client
    }
    else {
        while (0 < (n = read(fd, buff, MAXLINE))) { // open succeeded and copy file to pipe
            if (-1 == write(writefd, buff, n)) {
                printf("write error: %s", strerror(errno));
            }
        }
        if (-1 == close(fd)) {
            printf("close fd error: %s", strerror(errno));
        }
    }
}

上面例子中的FIFO应用是在父子进程间进行的，下面再对其进行修改，在两个无亲缘关系的进程间完成。

// server_main.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define MAXLINE (100) // buffer size

#define FIFO1 "/tmp/fifo.1"
#define FIFO2 "/tmp/fifo.2"

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

// server, readfd for read, writefd for write
void server(int readfd, int writefd);

int main(int argc, char **argv)
{
    int readfd;
    int writefd;

    if ((0 > mkfifo(FIFO1, FILE_MODE)) && (EEXIST != errno)) { // make fifo, errno can be EEXIST
        printf("mkfifo %s error: %s", FIFO1, strerror(errno));
        exit(EXIT_FAILURE);
    }

    if ((0 > mkfifo(FIFO2, FILE_MODE)) && (EEXIST != errno)) { // make fifo, errno can be EEXIST
        printf("mkfifo %s error: %s", FIFO2, strerror(errno));
        unlink(FIFO1); // remove unuesd fifo
        exit(EXIT_FAILURE);
    }

    if (0 > (readfd = open(FIFO1, O_RDONLY, 0))) {
        printf("open %s error: %s", FIFO1, strerror(errno));
    }

    if (0 > (writefd = open(FIFO2, O_WRONLY, 0))) {
        printf("open %s error: %s", FIFO2, strerror(errno));
    }

    server(readfd, writefd); // child is a server

    exit(EXIT_SUCCESS);
}

void server(int readfd, int writefd)
{
    int fd;
    ssize_t n;
    char buff[MAXLINE + 1] = { 0 };

    if (-1 == (n = read(readfd, buff, MAXLINE))) { // read pathname from pipe
        printf("read error: %s", strerror(errno));
    }
    else if (0 == n) {
        perror("end-of-file while reading pathname");
    }
    buff[n] = '\0'; // null terminate

    if (-1 == (fd = open(buff, O_RDONLY))) {
        perror("open error");
        snprintf(buff + n, sizeof(buff) - n, ": can't oepn, %s\n", strerror(errno));
        n = strlen(buff);
        write(writefd, buff, n); // open failed and tell client
    }
    else {
        while (0 < (n = read(fd, buff, MAXLINE))) { // open succeeded and copy file to pipe
            if (-1 == write(writefd, buff, n)) {
                printf("write error: %s", strerror(errno));
            }
        }
        if (-1 == close(fd)) {
            printf("close fd error: %s", strerror(errno));
        }
    }
}

// client_main.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define MAXLINE (100) // buffer size

#define FIFO1 "/tmp/fifo.1"
#define FIFO2 "/tmp/fifo.2"

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

// client readfd for read, writefd for write
void client(int readfd, int writefd);

int main(int argc, char **argv)
{
    int readfd;
    int writefd;

    if (0 > (writefd = open(FIFO1, O_WRONLY, 0))) {
        printf("open %s error: %s", FIFO1, strerror(errno));
    }

    if (0 > (readfd = open(FIFO2, O_RDONLY, 0))) {
        printf("open %s error: %s", FIFO2, strerror(errno));
    }

    client(readfd, writefd); // father is a client

    close(readfd);
    close(writefd);

    unlink(FIFO1);
    unlink(FIFO2);

    exit(EXIT_SUCCESS);
}

void client(int readfd, int writefd)
{
    size_t len;
    ssize_t n;
    char buff[MAXLINE] = { 0 };

    fgets(buff, MAXLINE, stdin); // using fgets to input from stdin
    len = strlen(buff);
    if ('\n' == buff[len - 1]) {
        --len; // delete newline from fgets
    }

    if (-1 == write(writefd, buff, len)) { // write pathname to pipe
        printf("write error: %s", strerror(errno));
    }

    while (0 < (n = read(readfd, buff, MAXLINE))) { // read data from pipe
        if (-1 == write(STDOUT_FILENO, buff, n)) {
            printf("write error: %s", strerror(errno)); // write data to stdout
        }
    }
}

然后就可以在shell终端测试了：

$ gcc -o server server_main.c
$ gcc -o client client_main.c
$ ./sever &
$ ./client

3、管道和FIFO的使用注意事项

上面的例子只是简单的介绍了pipe和FIFO的用法，其实在使用过程中，还有一些东西是需要注意的。

阻塞与否——
设置非阻塞时，可以通过open函数的O_NONBLOCK标志实现，也可以通过fcntl函数完成，使用fcntl时一般先通过F_GETFL命令获取文件当前状态flags，然后再将(flags |= O_NONBLOCK)通过G_SETFL命令设置非阻塞，否则可能会出问题。

OPEN_MAX——
一个进程在任意时刻打开文件描述符的最大个数，其值可通过sysconf(_SC_OPEN_MAX)函数查询，使用setrlimit函数来修改，在shell终端也可以使用”getconf OPEN_MAX”命令来查询，通过ulimit命令修改。

PIPE_BUF——
可原子地写往pipe或FIFO的最大数据量，其值可使用pathconf(path, _PC_PIPE_BUF)或fpathconf函数获得，在shell终端使用”getconf PIPE_BUF ”命令也可以查询某个path的PIPE_BUF。

// pipeconf.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char **argv)
{
    if (2 != argc) {
        printf("usage: %s <path>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    printf("OPEN_MAX = %ld, PIPE_BUF = %ld\n", sysconf(_SC_OPEN_MAX), pathconf(argv[1], _PC_PIPE_BUF));
    exit(EXIT_SUCCESS);
}

4、其它

单个服务器，多个客户——
FIFO是一种只能在单台主机上使用的IPC形式。尽管在文件系统中有名字，它们也只能用在本地文件系统上，而不能用在通过NFS安装的文件系统上。

注意函数阻塞技巧。

// mainclient.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define MAXLINE (100) // buffer size
#define SERV_FIFO "/tmp/fifo.serv" // server's well-known FIFO
#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) // (FILE_MODE & ~umask)

int main(int argc, char **argv)
{
    int readfifo, writefifo;
    char *ptr, buff[MAXLINE], fifoname[MAXLINE];
    pid_t pid;
    ssize_t n;
    size_t len;

    pid = getpid();
    snprintf(fifoname, sizeof(fifoname), "/tmp/fifo.%ld", (long)pid);
    // create FIFO with our PID as part of name
    if ((0 > mkfifo(fifoname, FILE_MODE)) && (EEXIST != errno)) {
        printf("mkfifo %s error: %s", fifoname, strerror(errno));
        exit(EXIT_FAILURE);
    }

    snprintf(buff, sizeof(buff), "%ld ", (long)pid);
    len = strlen(buff);
    ptr = buff + len;   
    fgets(ptr, MAXLINE - len, stdin); // read pathname
    len = strlen(buff); // fgets guarantees null byte at end

    // open FIFO to server and write PID and pathname to FIFO
    if (0 > (writefifo = open(SERV_FIFO, O_WRONLY, 0))) {
        printf("open %s error: %s", SERV_FIFO, strerror(errno));
        unlink(fifoname);
        exit(EXIT_FAILURE);
    }
    write(writefifo, buff, len);

    // now open our FIFO, blocks untill server opens for writing
    if (0 > (readfifo = open(fifoname, O_RDONLY, 0))) {
        printf("open %s error: %s", fifoname, strerror(errno));
        unlink(fifoname);
        exit(EXIT_FAILURE);
    }

    while (0 < (n = read(readfifo, buff, MAXLINE))) {
        write(STDOUT_FILENO, buff, n);
    }

    close(readfifo);
    unlink(fifoname);

    exit(EXIT_SUCCESS);
}


// mainserver.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define MAXLINE (100) // buffer size
#define SERV_FIFO "/tmp/fifo.serv" // server's well-known FIFO
#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) // (FILE_MODE & ~umask)

int main(int argc, char **argv)
{
    int readfifo, writefifo, dummyfd, fd;
    char *ptr, buff[MAXLINE], fifoname[MAXLINE];
    pid_t pid;
    ssize_t n;

    // create server's well-known FIFO, OK if already exists
    if ((0 > mkfifo(SERV_FIFO, FILE_MODE)) && (EEXIST != errno)) {
        printf("mkfifo %s error: %s", SERV_FIFO, strerror(errno));
        exit(EXIT_FAILURE);
    }

    // open server's well-known FIFO for reading and writing
    if (0 > (readfifo = open(SERV_FIFO, O_RDONLY, 0))) {
        printf("open %s error: %s", SERV_FIFO, strerror(errno));
        exit(EXIT_FAILURE);
    }
    if (0 > (dummyfd = open(SERV_FIFO, O_WRONLY, 0))) {  // never used, blocks at read insteand of re-open
        printf("open %s error: %s", SERV_FIFO, strerror(errno));
        exit(EXIT_FAILURE);
    }

    while (0 < (n = read(readfifo, buff, MAXLINE))) {
        if ('\n' == buff[n - 1]) {
            --n; // delete newline from read
        }
        buff[n] = '\0'; // null terminate pathname

        if (NULL == (ptr = strchr(buff, ' '))) {
            printf("** request: %s, error input from client", buff);
            continue;
        }

        *ptr++ = 0; // null termiate PID, ptr = pathname
        pid = atol(buff);
        snprintf(fifoname, sizeof(fifoname), "/tmp/fifo.%ld", (long)pid);

        if (0 > (writefifo = open(fifoname, O_WRONLY, 0))) {
            printf("open %s error: %s", fifoname, strerror(errno));
            continue;
        }

        if (0 > (fd = open(ptr, O_RDONLY, 0))) { // error: must tell client
            snprintf(buff + n, sizeof(buff) - n, ": can't open, %s\n", strerror(errno));
            n = strlen(ptr);
            write(writefifo, ptr, n);
            close(writefifo);
        }
        else { // open succeded: copy file to FIFO
            while (0 < (n = read(fd, buff, MAXLINE))) {
                write(writefifo, buff, n);
            }
            close(fd);
            close(writefifo);
        }
    }

//    unlink(readfifo); // no need remove server FIFO

    exit(EXIT_SUCCESS);
}

字节流与消息——
字节流：不存在记录边界，读写操作不检查数据。带内特殊终止序列，如换行符；显式长度，如记录数据长度的数据结构；每次连接一个记录，如open/close。

// pipemesg.h
#ifndef PIPEMESG
#define PIPEMESG

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

#ifndef PIPE_BUF
#define PIPE_BUF (4096)
#endif

// Our own "messages" to use with pipes, FIFOS, and message queues.
// want sizeof(struct mymesg) <= PIPE_BUF
#define MAXMESGDATA (PIPE_BUF - 2 * sizeof(long))
// length of mesg_len and mesg_type
#define MESGHDRSIZE (sizeof(struct mymesg) - MAXMESGDATA)

struct mymesg
{
    long mesg_len; // bytes in mesg_data, can be 0
    long mesg_type; // message type, must be > 0
    char mesg_data[MAXMESGDATA];
};

ssize_t mesg_send(int fd, struct mymesg *mptr);
ssize_t mesg_recv(int fd, struct mymesg *mptr);

void client(int readfd, int writefd);
void server(int readfd, int writefd);

#endif // PIPEMESG

// mesg_send.c
#include "pipemesg.h"

ssize_t mesg_send(int fd, struct mymesg *mptr)
{
    return write(fd, mptr, MESGHDRSIZE + mptr->mesg_len);
}

// mesg_recv.c
#include "pipemesg.h"

ssize_t mesg_recv(int fd, struct mymesg *mptr)
{
    size_t len;
    ssize_t n;
    // read massage header first, to get len of data that follows
    if (0 == (n = read(fd, mptr, MESGHDRSIZE))) {
        return 0; // end of file
    }
    else if (MESGHDRSIZE != n) {
        printf("message header expected %d, got %d\n", MESGHDRSIZE, n);
        return -1;
    }

    if (0 < (len = mptr->mesg_len)) {
        if (len != (n = read(fd, mptr->mesg_data, len))) {
            printf("message header expected %d, got %d\n", len, n);
            return -1;
        }
    }

    return len;
}

// client.c
#include "pipemesg.h"

void client(int readfd, int writefd)
{
    size_t len;
    ssize_t n;
    struct mymesg mesg;
    // read pathname
    fgets(mesg.mesg_data, MAXMESGDATA, stdin);
    len = strlen(mesg.mesg_data);
    if ('\n' == mesg.mesg_data[len - 1]) {
        --len; // delete newline from fgets
    }
    mesg.mesg_len = len;
    mesg.mesg_type = 1;
    // write pathname to IPC channel
    mesg_send(writefd, &mesg);
    // read from IPC, write to standard output
    while (0 < (n = mesg_recv(readfd, &mesg))) {
        write(STDOUT_FILENO, mesg.mesg_data, n);
    }
}

// server.c
#include "pipemesg.h"

void server(int readfd, int writefd)
{
    FILE *fp;
    ssize_t n;
    struct mymesg mesg;
    // read pathname from IPC channel
    mesg.mesg_type = 1;
    if (0 == (n = mesg_recv(readfd, &mesg))) {
        printf("pathname missing\n");
        return;
    }

    mesg.mesg_data[n] = '\0'; // null terminate pathname
    if (NULL == (fp = fopen(mesg.mesg_data, "r"))) {
        // error: must tell client
        snprintf(mesg.mesg_data + n, sizeof(mesg.mesg_data) - n, ":can't open, %s\n", strerror(errno));
        mesg.mesg_len = strlen(mesg.mesg_data);
        mesg_send(writefd, &mesg);
    }
    else {
        // fopen succeeded: copy file to IPC channel
        while (NULL != (fgets(mesg.mesg_data, MAXMESGDATA, fp))) {
            mesg.mesg_len = strlen(mesg.mesg_data);
            mesg_send(writefd, &mesg);
        }
        fclose(fp);
    }

    // send a 0-length message to signify the end
    mesg.mesg_len = 0;
    mesg_send(writefd, &mesg);
}

// mesg_main.c
#include "pipemesg.h"

#define MAXLINE (100) // buffer size
#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)

int main(int argc, char **argv)
{
    int pipe1[2];
    int pipe2[2];
    pid_t childfd;

    if (-1 == pipe(pipe1) || -1 == pipe(pipe2)) { // create two pipes
        printf("create pipe error: %s", strerror(errno));
        exit(EXIT_FAILURE);
    }

    if (0 == (childfd = fork())) { // child
        // using pipe1[0] for read and pipe2[1] for write
        // so close unused pipe1[1] and pipe2[0]
        if (-1 == close(pipe1[1]) || -1 == close(pipe2[0])) {
            printf("close pipe error: %s", strerror(errno));
            exit(EXIT_FAILURE);
        }

        server(pipe1[0], pipe2[1]); // child is a server
        exit(EXIT_SUCCESS);
    }

    // using pipe2[0] for read and pipe1[1] for write
    // so close unused pipe1[0] and pipe2[1]
    if (-1 == close(pipe1[0]) || -1 == close(pipe2[1])) {
        printf("close pipe error: %s", strerror(errno));
        exit(EXIT_FAILURE);
    }

    client(pipe2[0], pipe1[1]); // father is a client

    if (-1 == waitpid(childfd, NULL, 0)) { // wait for child to terminate
        perror("waitpid error");
        exit(EXIT_FAILURE);
    }

    exit(EXIT_SUCCESS);
}
IPC之二：使用命名管道(FIFO)进行进程间通信的例子
whowin
08-08 468
IPC 是 Linux 编程中一个重要的概念，IPC 有多种方式，本文主要介绍命名管道(FIFO)，命名管道可以完成同一台计算机上的进程之间的通信，本文给出了多个具体的实例，每个实例均附有完整的源代码；本文所有实例在 Ubuntu 20.04 上编译测试通过，gcc版本号为：9.4.0；本文适合 Linux 编程的初学者阅读。
管道和FIFO
weixin_50866517的博客
09-30 1129
管道是一种把两个进程之间的标准输入和标准输出连接起来的机制。管道是一种历史悠久的进程间通信的方法。当进程创建管道时，每次都需要提供两个文件描述符来操作管道。其中一个对管道进行写操作，另一个对管道进行读操作。对管道的读写与一般的IO系统函数一致，使用write()函数写入数据，使用read()读出数据。
IPC - FIFO
fzzjoy的专栏
05-20 499
FIFO（有时也被称为有名管道，命名管道）使用方式与管道（PIPE）类似，可参考：http://blog.csdn.net/u010275850/article/details/45867621 最大的区别就是FIFO可用于任意两个进程间通信。FIFO是一种文件类型，因此对于FIFO的操作类似于文件操作，如读、写、打开等操作。 当open一个fifo时，非阻塞标志（O_NONBLOCK）会产生
IPC 通信之 FIFO
aisxyz
02-06 293
FIFO 也被称为命名管道，未命名的管道只能在两个相关的进程之间使用，而且这两个相关的进程还要有一个共同的创建了它们的祖先进程。而通过 FIFO，即使不相关的进程也能交换数据。 FIFO 是一种文件类型，通过 stat 结构的 st_mode 成员可以知道文件是否是 FIFO 类型，可以用 S_ISFIFO 宏对此进行测试。创建 FIFO 类似于创建文件，它的路径名也的确存在与文...
进程间通信(IPC):FIFO
不积跬步无以至千里
05-11 680
FIFO又称命名管道，可以在无亲缘关系即不相关的进程间交换数据。 创建FIFO： #include #include int mkfifo(const char* pathname,mode_t mode); 创建FIFO后，可以用一般的文件io函数来操作，open，close，read,write,unlink等。 非阻塞标志O_NONBLOCK的影响： 未指定O_NONB
linux-ipc-fifo[有名管道]
仙人Immortal的博客
09-12 157
linux-ipc-fifo[有名管道]介绍Demo 介绍 pipe是给有血缘关系的进程通信的，fifo是给无血缘关系的进程通信用的。 mkfifo 创建有名管道 Demo 写： #include <iostream> #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> #include <fcntl.h> #include <string.h> int m
进程间通信(3)——命名管道(FIFO)
私房菜
04-18 1327
命名管道也被称为FIFO(first in first out)文件，它是一种特殊类型的文件，它在文件系统中以文件名的形式存在，但是它的行为却和之前所讲的没有名字的管道（匿名管道）类似。由于Linux中所有的事物都可被视为文件，所以对命名管道的使用也就变得与文件操作非常的统一，也使它的使用非常方便，同时我们也可以像平常的文件名一样在命令中使用。
IPC之FIFO(有名管道)详解
daiyudong2020的博客
08-21 4468
基本概念： 管道没有名字，因此它们的最大劣势是只能用于有一个共同祖先进程的各个进程之间。我们无法在无亲缘关系的进程间创建一个管道并将它用作IPC管道（不考虑描述符传递）。 FIFO指先进先出（first in，first out），它是一个单向（半双工）数据流。不同于管道的是，每个FIFO有一个路径名与之关联，从而允许无亲缘关系的进程访问同一个FIFO。FIFO也称为有名管道（named pi
Linux IPC之管道和FIFO
delphiwcdj的专栏
08-31 3954
导言：管道是UNIX系统上最古老的IPC方法，管道提供了一种优雅的解决方案：给定两个运行不同程序的进程，在shell中如何让一个进程的输出作为另一个进程的输入？管道可以用来在相关（一个共同的祖先进程创建管道）进程之间传递数据。FIFO是管道概念的一个变体，它们之间的一个重要差别在于FIFO可以用于任意进程间的通信。 概述每个shell用户都对在命令中使用管道比较熟悉，例如，统计一个目录中文件的数目：
Linux系统编程——管道（pipe）和命名管道（FIFO）
最新发布
qq_74811378的博客
10-26 706
POSIX标准中的FIFO又名有名管道或命名管道。我们知道前面讲述的POSIX标准中管道是没有名称的，所以它的最大劣势是只能用于具有亲缘关系的进程间的通信。FIFO最大的特性就是每个FIFO都有一个路径名与之相关联，从而允许无亲缘关系的任意两个进程间通过FIFO进行通信。所以，FIFO的两个特性：和管道一样，FIFO仅提供半双工的数据通信，即只支持单向的数据流；和管道不同的是，FIFO可以支持任意两个进程间的通信。1. 管道是一个环形队列缓冲区，允许两个进程以生产者消费者模型进程通信。
【Linux】进程间通信-命名管道FIFO
热门推荐
计算机专业同学的充电站。
01-06 2万+
命名管道概述 如果我们要在不相关的进程间交换数据，那么使用FIFO文件将会十分方便。 FIFO文件通常也称为命名管道（named pipe）。命名管道是一种特殊类型的文件，它在文件系统中以文件名的形式存在。 创建命名管道 创建命名管道一般有两种方式： 命令行方式 一个比较旧的方式是： mknod filename p 这个命令并未出现在X/Open规范的命令列表中，所以
linux 信号处理函数集合
BOKE
11-03 532
alarm（设置信号传送闹钟） 相关函数 signal，sleep 表头文件 #include 定义函数 unsigned int alarm(unsigned int seconds); 函数说明 alarm()用来设置信号SIGALRM在经过参数seconds指定的秒数后传送给目前的进程。如果参数sec
linux信号检查参数相同,linux信号函数
weixin_28748675的博客
05-12 150
alarm(设置信号传送闹钟)相关函数signal，sleep表头文件#include定义函数unsigned int alarm(unsigned int seconds);函数说明alarm()用来设置信号SIGALRM在经过参数seconds指定的秒数后传送给目前的进程。如果参数seconds 为0，则之前设置的闹钟会被取消，并将剩下的时间返回。返回值返回之前闹钟的剩余秒数，如果之前未设闹钟...
Linux进程通信之管道和FIFO
jishublog
07-20 483
Linux进程间的通信可以简称为IPC（InterprocessCommunication），前面说过的Linux的同步工具也是属于IPC的一部分，这里我想说的是通常意义的进程间的实际数据通。 1管道 管道是最早的UNIXIPC，所有的UNIX系统都支持这个IPC通信机制。我们最常见到使用它的位置就是shell中使用的管道命令。管道IPC有两个特性： 管道仅提供半双工的数据通信，即...
mount时，提示“Bad file descriptor”解决方案
fhplzh的专栏
05-20 1万+
问题现象：mount时，出现“Bad file descriptor” 解决方案： 1、关闭10.0.1.2 虚拟机的防火墙 命令：service iptables stop 2、重启10.0.1.2 虚拟机的nfs服务 命令：service nfs restart 然后重新mount ，看是否成功。 如果还不成功，则继续下个步骤 3、设置nfs共享目录 修改...
文件描述符与文件对象的关系
回忆的往昔
10-26 3289
转载请说明出处：http://blog.csdn.net/cywosp/article/details/38965239 概述 在Linux系统中一切皆可以看成是文件，文件又可分为：普通文件、目录文件、链接文件和设备文件。文件描述符（file descriptor）是内核为了高效管理已被打开的文件所创建的索引，其是一个非负整数（通常是小整数），用于指代被打开的文件，所有执行I/O操作的系统调用都通
进程间的通信（IPC）——管道（pipe）与命名管道（fifo）
ayaya的博客
04-03 774
一、管道的概念 管道的实质是一个内核缓冲区，进程以先进先出（FIFO， First In First Out）的方式从缓冲区存取数据：管道一端的进程顺序地将进程数据写入缓冲区，另一端的进程则顺序地读取数据，该缓冲区可以看做一个循环队列，读和写的位置都是自动增加的，一个数据只能被读一次，读出以后再缓冲区都不复存在了。管道也可以看成一个文件，但不是普通文件，也不属于任何文件系统，自立门户，构成一个的文...
IPC - 命名管道（fifo）- 使用
YY_Song 's blogs
06-15 565
命名管道-FIFO命名管道函数原型注意事项FIFO出错信息简单应用参考资料 命名管道 我们前面介绍了匿名管道（pipe），匿名管道实际上就是：内存上的一块缓存。 它的主要实现方式是借助于fork之后父进程和子进程会共享之前已经打开的文件描述符，并且父进程关闭fd[0]读端，子进程关闭fd[1]写端来实现的。 之所以说它是匿名管道，是因为，它在内核中开辟的缓存并没有一个名字。 那么，通过名字就能理解了，命名管道就是在内核中开辟的缓存有自己的名字了。 其实，这也就是命名管道和匿名管道之间的区别。 命名管道的本质
Linux进程间通信（IPC）：管道与FIFO详解
"本文主要介绍了进程间通信（IPC）的概念，包括无名管道和命名管道（FIFO）的原理和使用方法，以Linux系统中的C语言编程为例进行讲解。" 在计算机系统中，进程间通信（IPC）是实现不同进程间信息交换的关键技术。它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值