Unix网络编程-管道和FIFO

于 2022-04-26 22:48:19 发布
阅读量284 收藏 1
点赞数 1
分类专栏： Unix网络编程 文章标签： 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NINE_world/article/details/124439314
版权
本文介绍了Unix/Linux系统中进程间通信的管道和FIFO（命名管道）机制，以及如何利用它们进行文件内容的传递。在管道示例中，客户端通过管道将文件路径发送给服务端，服务端读取文件内容并回传给客户端。FIFO示例展示了无亲缘关系进程间的通信，服务端接收客户端的文件路径，读取文件内容并回传。此外，还给出了处理多个客户端请求的服务端示例，服务端通过结构体消息与各个客户端进行交互。
摘要由CSDN通过智能技术生成

管道

/**
 * @file pipe.c
 * 1.客户端传送给服务端一个路径名字
 * 2.服务端读取文件内容通过ipc传送给客户端
 * 3.客户端将读取的内容显示到标准输出
 * 
 * 管道本身是半双工，fork之后是可以全双工，但是只有一个管道缓冲区，根本没法进行通信
 * 全双工的通信还是像下面这样，用两个管道，用两个缓冲区实现
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#define FILEPATH "/home/adce/mycode/vscode/unix_process/pipe/file/pipeFile.txt"
#define PATHSIZE 1024
void Client(int writefd, int readfd);
void Server(int writefd, int readfd);
int main(int argc, char **argv)
{
    int pipe_client[2]; // 客户端写的管道
    int pipe_server[2]; // 服务端写的管道
    if (pipe(pipe_client) < 0 || pipe(pipe_server) < 0)
    {
        perror("pipe");
        exit(-1);
    }
    // 让子进程运行服务端程序，父进程运行客户端程序
    pid_t server_pid;
    if ((server_pid = fork()) < 0)
    {
        perror("fork");
        exit(-1);
    }
    if (server_pid == 0)    // 子进程运行服务端程序
    {
        close(pipe_client[1]);  // 关掉客户端的写通道
        close(pipe_server[0]);  // 关掉服务端的读通道
        Server(pipe_server[1], pipe_client[0]); // 执行服务端程序
        exit(0);    // 执行完就结束
    }
    // 父进程运行客户端程序
    close(pipe_client[0]);  // 关掉客户端的读端
    close(pipe_server[1]);  // 关掉服务端的写端
    Client(pipe_client[1], pipe_server[0]);
    waitpid(server_pid, NULL, 0);   // 收尸子进程
    exit(0);
}

void Client(int writefd, int readfd)
{
    char pathbuf[PATHSIZE];
    strncpy(pathbuf, FILEPATH, PATHSIZE);
    size_t pathlen = strlen(pathbuf);   // 得到路径的真实长度
    ssize_t writesize = write(writefd, pathbuf, pathlen);
    if (writesize < pathlen)    // 如果写入的字节不够，就报错，默认是阻塞写，肯定会够，不够就是出错了
    {
        fprintf(stderr, "write size less than pathlen.\n");
        exit(-1);
    }
    // 循环读
    ssize_t readsize;
    char buf[1024];
    printf("client begin read:\n");
    while ((readsize = read(readfd, buf, 1024)) > 0)
    {
        write(STDOUT_FILENO, buf, readsize);    // 将读到的内容输出到标准输出
    }
    printf("client read over.\n");
    exit(0);
}

void Server(int writefd, int readfd)
{
    char buf[PATHSIZE];
    ssize_t readsize;
    if((readsize = read(readfd, buf, PATHSIZE)) < 0) // 先把路径读出来
    {
        // 读出错
        perror("read");
        exit(-1);
    }
    int filefd;
    filefd = open(buf, O_RDONLY);
    if (filefd < 0)
    {
        fprintf(stderr, "open() failed.");
        exit(-1);
    }
    while ((readsize = read(filefd, buf, PATHSIZE)) > 0)
    {
        write(writefd, buf, readsize);
    }
    write(writefd, "send over!\n", 12);
    exit(0);
}

/**
 * @file pipe-popen.c
 * 1.使用popen调用cat命令读取文件
 * 我们在用shell命令的时候，有一个管道通配符 |
 * 这个popen就是这个作用，启用一个shell命令，并预留管道通信
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define FILEPATH "/home/adce/mycode/vscode/unix_process/pipe/file/pipeFile.txt"
#define PATHSIZE 1024
int main(int argc, char **argv)
{
    char command[PATHSIZE];
    char buf[1024];
    FILE *fp;
    sprintf(command, "cat %s", FILEPATH);
    fp = popen(command, "r");
    int readsize;
    while (fgets(buf, 1024, fp) != NULL)
    {
        printf(buf);
    }
    exit(0);
}

FIFO

两个无关系的进程之间通信。

/**
 * @file fifo-server.c
 * 使用命名管道通信
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
// 最宽松的权限
#define FILE_MODE (S_IRWXU | S_IRWXG | S_IRWXO)
#define FIFOCLIENT "/home/adce/mycode/vscode/unix_process/fifo/file/fifo.client"
#define FIFOSEVER "/home/adce/mycode/vscode/unix_process/fifo/file/fifo.server"
#define FILEPATH "/home/adce/mycode/vscode/unix_process/fifo/file/fifoFile.txt"
#define PATHSIZE 1024
void Client(int writefd, int readfd);
int main(int argc, char **argv)
{
    int readfd, writefd;
    writefd = open(FIFOCLIENT, O_WRONLY, 0);
    readfd = open(FIFOSEVER, O_RDONLY, 0);
    if (readfd < 0 || writefd < 0)
    {
        perror("open");
        exit(-1);
    }
    Client(writefd, readfd);
    unlink(FIFOCLIENT);
    unlink(FIFOSEVER);
    exit(0);
}
void Client(int writefd, int readfd)
{
    char pathbuf[PATHSIZE];
    strncpy(pathbuf, FILEPATH, PATHSIZE);
    size_t pathlen = strlen(pathbuf);   // 得到路径的真实长度
    ssize_t writesize = write(writefd, pathbuf, pathlen);
    if (writesize < pathlen)    // 如果写入的字节不够，就报错，默认是阻塞写，肯定会够，不够就是出错了
    {
        fprintf(stderr, "write size less than pathlen.\n");
        exit(-1);
    }
    // sleep(1);   // 等待服务端先把内容写入fifo，否则可能会读空
    // 循环读
    ssize_t readsize;
    char buf[1024];
    printf("client begin read:\n");
    while ((readsize = read(readfd, buf, 1024)) > 0)
    {
        write(STDOUT_FILENO, buf, readsize);    // 将读到的内容输出到标准输出
    }
    printf("client read over.\n");
    exit(0);
}


/**
 * @file fifo-server.c
 * 使用命名管道通信
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
// 最宽松的权限
#define FILE_MODE (S_IRWXU | S_IRWXG | S_IRWXO)
#define FIFOSEVER "/home/adce/mycode/vscode/unix_process/fifo/file/fifo.server"
#define FIFOCLIENT "/home/adce/mycode/vscode/unix_process/fifo/file/fifo.client"
#define PATHSIZE 1024
void Server(int writefd, int readfd);
int main(int argc, char **argv)
{
    if ((mkfifo(FIFOSEVER, FILE_MODE) < 0) && (errno != EEXIST))
    {
        perror("mkfifo");
        exit(-1);
    }
    if ((mkfifo(FIFOCLIENT, FILE_MODE) < 0) && (errno != EEXIST))
    {
        perror("mkfifo");
        exit(-1);
    }
    int readfd, writefd;
    readfd = open(FIFOCLIENT, O_RDONLY, 0);
    writefd = open(FIFOSEVER, O_WRONLY, 0);
    if (readfd < 0 || writefd < 0)
    {
        perror("open");
        exit(-1);
    }
    Server(writefd, readfd);
    exit(0);
}

void Server(int writefd, int readfd)
{
    char buf[PATHSIZE];
    ssize_t readsize;
    if((readsize = read(readfd, buf, PATHSIZE)) < 0) // 先把路径读出来
    {
        // 读出错
        perror("read");
        exit(-1);
    }
    int filefd;
    filefd = open(buf, O_RDONLY);
    if (filefd < 0)
    {
        fprintf(stderr, "open() failed.");
        exit(-1);
    }
    while ((readsize = read(filefd, buf, PATHSIZE)) > 0)
    {
        write(writefd, buf, readsize);
    }
    write(writefd, "send over!\n", 12);
    exit(0);
}

一个服务端，多个客户端通信：

/**
 * @file proto.h
 * 客户端和服务端共同遵守的协议
 * 定义消息体数据结构
 * 为了简化，这里服务器就统一回复：[pid] OK.
 */
#ifndef PROTO_H_
#define PROTO_H_

#include <limits.h>
#include <unistd.h>
#include <string.h>
#define FIFO_MODE (S_IRWXU | S_IRWXG | S_IRWXO)
#define SERVER_FIFO "/home/adce/mycode/vscode/unix_process/fifo/file/serverfifo"
#define CLIENT_FIFO "/home/adce/mycode/vscode/unix_process/fifo/file/clientfifo."
#define MEGDATESIZE (PIPE_BUF - sizeof(int))
struct msg_st
{
    int pid;        // > 0
    char data[MEGDATESIZE];  // date
};
#endif


/**
 * @file server.c
 * 可以处理多个客户端的通信
 * 使用结构体消息
 * 有一个众所周知的server fifo，服务端从这里面读取数据
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <limits.h>
#include <string.h>
#include "proto.h"
#include <signal.h>
void handle(int p)
{
    printf("logout.\n");
    exit(0);
}
int main(int agrc, char **argv)
{
    signal(SIGINT, handle);
    // 尝试创建并打开fifo
    if (mkfifo(SERVER_FIFO, FIFO_MODE) < 0 && errno != EEXIST)
    {
        perror("mkfifo");
        exit(-1);
    }
    // 自己先打开写fifo，再打开读fifo，防止客户端关闭的时候，服务器整个被阻塞
    int readfd = open(SERVER_FIFO, O_RDONLY);
    if (readfd < 0)
    {
        perror("open");
        exit(-1);
    }
    // 这个只有在readfd阻塞之后才会执行，readfd只会阻塞一次，防止readfd失效，一直占用写端，但是这个fd不用，用nofd表示。
    int nofd = open(SERVER_FIFO, O_WRONLY); 
    if (nofd < 0)
    {
        perror("open");
        exit(-1);
    }

    // 死循环执行任务
    char buf[1024];
    char client_path[1024];
    struct msg_st msg;
    printf("server begin recv:\n");
    while (read(readfd, &msg, sizeof(msg)) > 0)
    {
        printf("[%d]:%s\n", msg.pid, msg.data); // 服务器把接受到的消息打印到终端上
        sprintf(client_path, "%s%d", CLIENT_FIFO, msg.pid);
        sprintf(buf, "[%d]:OK.", msg.pid);
        int sendfd = open(client_path, O_WRONLY);
        if (sendfd < 0)
        {
            perror("open");
            exit(-1);
        }
        strncpy(msg.data, buf, sizeof(buf));
        write(sendfd, &msg, sizeof(msg));
    }
    exit(0);
}


/**
 * @file client.c
 * 客户端有自己独立的client fifo
 * fifo的地址通过结构体传送给服务器
 * 服务器通过这个fifo传回数据
 */
#include "proto.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <limits.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
void handle(int p)
{
    printf("logout.\n");
    exit(0);
}
int main(int argc, char **argv)
{
    signal(SIGINT, handle);
    pid_t pid = getpid();
    char path[1024];
    sprintf(path, "%s%d", CLIENT_FIFO, pid);
    if (mkfifo(path, FIFO_MODE) < 0 && errno != EEXIST) // 新建自己的fifo
    {
        perror("mkfifo");
        exit(-1);
    }
    // 打开服务端的fifo
    int sendfd = open(SERVER_FIFO, O_WRONLY);
    struct msg_st msg;
    char buf[1024];
    gets(buf);  // 手动输入消息
    msg.pid = pid;
    strncpy(msg.data, buf, strlen(buf));
    write(sendfd, &msg, sizeof(msg));   // 发送消息
    int recvfd = open(path, O_RDONLY);  // 打开自己的fifo，读内容，注意，不能打开早了，否则会阻塞
    while(1)
    {
        read(recvfd, &msg, sizeof(msg));
        puts(msg.data);
        gets(buf);
        strncpy(msg.data, buf, strlen(buf));
        write(sendfd, &msg, sizeof(msg));   // 发送消息
    }
    exit(0);
}
橙子砰砰枪
关注
专栏目录
UNIX进程间的通信 FIFO
jimmy_yinjg的专栏
12-01 277
FIFO,命名管道。可以在不相关的进程间进行通信。FIFO是一种文件类型，下面为创建FIFO文件的函数 #include #include int mkfifo(const char *pathname, mode_t mode); 成功则返回0，否则返回-1. 打开关闭FIFO如同普通文件方法一样。应注意打开一个FIFO时，可选择非阻塞标志(O_NONBLOCK)，
UNIX编程——管道和FIFO
rqc112233的专栏
11-21 1015
进程间的通信有三种形式：管道/FIFO、Posix(Portable Operating System Interface，可移植操作系统接口)消息队列、System V 消息队列，先来介绍第一种通信方式，也是最开始的一种通信方式：管道/FIFO 1.对于管道而言，它的局限在于没有名字，从而只能有秦缘关系的进程使用，但是后面有发展出FIFO(这种又被称为有名管道)，一般使用的是read和writ
UNIX环境高级编程——管道和FIFO的额外属性
weixin_33962923的博客
07-07 108
一个描述符能以两种方式设置成非阻塞。（1）调用open时可以指定O_NONBLOCK标志。 writefd = open(FIFO1,O_WRONLY | O_NONBLOCK,0);（2）如果一个描述符已经打开，那么可以调用fcntl以启用O_NONBLOCK标志。对于管道来说，必须使用这种技术，因为管道没有open调用，在pipe调用中也无法指定O_NONBLOCK标志。使用fcnt...
UNIX网络编程之管道与FIFO
Dandelion_gong的博客
05-16 4007
管道是最初的Unix IPC形式，它们的最大局限是没有名字，所以，管道只能用于有亲缘关系的进程只见使用。之后，慢慢随着FIFO的加入，这点才有所改观。FIFO也成为又名管道。管道和FIFO的共同点就是它们都是通过read和write函数进行访问的。管道： 管道时有pipe函数创建，提供一个单路数据流。也就是说，所有的管道都是半双工。 管道创建方法： #include <unistd.h>
Linux网络编程 - 在服务器端运用进程间通信之管道(pipe)
yunfan
01-10 2168
本文主要讲解进程间通信之一的管道（匿名管道）方式，讨论Linux系统中管道的工作原理及其使用方法，并将管道机制运用在Linux网络编程之中。
unix环境高级编程--第章 文件和目录.doc.doc
06-09
" Unix 环境高级编程 - 文件和目录" 在 Unix 环境高级编程中，文件和目录是两个基本概念。本章将详细介绍文件和目录的属性、stat 函数、fstat 函数、lstat 函数等知识点，并且对目录进行操作的函数进行详细的解释。...
UNIX网络编程-第2卷-进程间通讯
08-16
总而言之，《UNIX网络编程-第2卷-进程间通讯》是学习和理解UNIX系统中多进程通信不可多得的参考书，对于从事系统编程、网络编程或者并发程序设计的工程师来说，其内容详实、实践性强，能帮助读者深入理解并掌握这一...
UNIX网络编程卷1和2
03-20
Richard Stevens撰写，分为卷1和卷2，深入浅出地介绍了UNIX系统上的网络编程技术。这两本书为程序员提供了全面而详细的网络编程知识，是许多开发者的必备参考书籍。 卷1《套接字联网API（第3版）》主要涵盖了以下...
UNIX网络编程-第2卷 程间通信 源代码
10-19
本书从对Posix IPC和System V IPC的内部结构开始讨论，全面深入地介绍了4种IPC形式：消息传递（管道、FIFO、消息队列）、同步（互斥锁、条件变量、读写锁、文件与记录锁、信号量）、共享内存（匿名共享内存、具名...
UNIX网络编程-第2卷-进程间通信
10-26
本书全面深入地讲述了各种进程间通信（IPC）形式，...本书内容详尽且具权威性，几乎每章都提供精选的习题，是计算机和网络专业高年级本科生和研究生的首选教材。本书也可作为网络研究和开发人员的自学教材和参考书。
网络编程_进程间通信_管道
P__aranoid的博客
11-04 281
一. 匿名管道—-单工管道 1. 与文件的区别 管道 文件 打开 popen() 关闭 pclose() 2. 操作 操作 命令 打开 FILE* popen(const char* cmd,const char* open_mode); 读 size_t fread(void* buf,size_t size,size_t num,FILE* stre
FIFO（UNIX环境高级编程笔记）
The_perfect_world的博客
04-26 271
  FIFO 有时被称为命名管道。未命名的管道只能在两个相关的进程之间使用，而且这两个相关的进程还要有一个共同创建了它们的祖先进程。 #include <sys/stat.h>int mkfifo(const char*path, mode_t mode);int mkfifoat(int fd, const char *path, mode_t mode);         ...
Linux网络编程——管道通信
Li丶Chong的博客
07-16 473
管道通信分为无名管道和有名管道，无名管道可以用于具有亲缘关系进程间的通信，有名管道克服管道没有名字的限制 管道是Linux支持的最初UNIX IPC形式之一，具有以下特点 管道是半双工的，数据只能想一个方向流动，需要进行双向通讯时需要建立两个管道 只能用与父子进程和兄弟进程之间（具有亲缘关系）的通讯 单独构成一种独立的文件系统，管道对于管道两端的进程来说就是两个文件，但是它不是普通文件，也...
网络编程之 进程间的通信之管道的使用
dearQiHao的博客
10-28 2177
如何使用管道是进程间通信的关键 博主先声明一下，关于处理进程创建以及销毁的方法。        “子进程究竟何时终止？？？？调用waitpid函数后还要无休止的等待子进程终止吗？？？”，这显然会是一个问题。因为父进程往往与紫禁城一样繁忙，因此我们不能只调用waitpid函数来等待子进程终止。那么我们应该怎么办呢？？？  &nbs...
网络编程学习笔记之命名管道(上)
liagn的专栏
12-14 662
1,命名管道的命名规范: //server/Pipe/[path]name 2,命名管道的通信模式: 字节模式和消息模式 3,建立一个基本的命名管道服务器: 1) 使用A P I函数C r e a t e N a m e d P i p e，创建一个命名管道实例句柄; 2) 使用A P I函数C o n n e c t N a m e d P i p e，在命名管道实例上监听客户机连接请求
网络编程（14）—— 进程间通信-管道pipe
Hyman的博客
10-11 2348
Linux中利用管道pipe进行进程间的通信，pipe的函数原型如下： #include int pipe(int pipefd[2]); pipe的参数是一个int型的二维数组，执行完该函数后我们就创建了一个管道，二维数组的两个 元素就分别是管道的输出端（可写）和管道的输出端（可读），我们分别利用write和read函数 进行管道中数据的写和读。 以下代码，先利用fork产生了子进程
Linux下进程间通信机制：FIFO（命名管道）
郑智仁的备忘录
05-21 6696
FIFO ，又称命名管道 ，是Linux下（unix环境下）一种进程间通信的机制，应用广泛。 函数mkfifo 用于创建命名管道，使用命令man 3 mkfifo 可查看此函数信息。FIFO创建后，可以像普通文件一样对其访问。  Linux下一个同名命令mkfifo 也用于创建FIFO，例如：执行命令$ mkfifo /tmp/fifo$ cat /tmp/fifo
【UNIX网络编程】FIFO
diandingyin9417的博客
04-26 112
管道作为进程间通信的最古老方式，它的缺点是没有名字，因此仅仅能用在有亲缘关系的父子进程之间。对于无亲缘关系的进程间。无法用管道进行通信。FIFO能够完毕无亲缘关系的进程间的通信。FIFO也被称为命名管道。它是一种特殊类型的文件。在文件系统中以文件名称的形式存在，但它的行为却和上面提到的管道类似。 创建命名管道有两种方法： 1、在命令行上运行命令：mkfifo filename...
UNIX网络编程：进程间通信深入解析
IPC允许不同的进程之间共享数据和协调操作，是构建分布式和网络应用程序的基础。 本书首先介绍了IPC的基本概念和目标，帮助读者理解IPC在解决多进程协同工作时的问题上所扮演的角色。然后，它逐步引导读者掌握...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

橙子砰砰枪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值