Unix网络编程-管道和FIFO

最新推荐文章于 2023-08-05 21:10:26 发布
最新推荐文章于 2023-08-05 21:10:26 发布
阅读量217 收藏 1
点赞数 1
分类专栏： Unix网络编程 文章标签： 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NINE_world/article/details/124439314
版权

管道

/**
 * @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);
}
橙子砰砰枪
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux网络编程 - 在服务器端运用进程间通信之管道(pipe)
yunfan
01-10 2110
本文主要讲解进程间通信之一的管道（匿名管道）方式，讨论Linux系统中管道的工作原理及其使用方法，并将管道机制运用在Linux网络编程之中。
Linux下进程间通信机制：FIFO（命名管道）
郑智仁的备忘录
05-21 6613
FIFO ，又称命名管道 ，是Linux下（unix环境下）一种进程间通信的机制，应用广泛。 函数mkfifo 用于创建命名管道，使用命令man 3 mkfifo 可查看此函数信息。FIFO创建后，可以像普通文件一样对其访问。  Linux下一个同名命令mkfifo 也用于创建FIFO，例如：执行命令$ mkfifo /tmp/fifo$ cat /tmp/fifo
第44 章 管道和FIFO
最新发布
u010783439的博客
08-05 191
每个shell用户都对在命令中使用管道比较熟悉，如下面这个统计一个目录中文件数目的命令所示。为执行上面的命令，shell创建了两个进程分别执行ls和wc.(这时通过使用fork()和exec()来完成的，第24章和27章分别对这两个函数进行了介绍。)图44-1展示了这两个进程是如何使用管道的。除了说明管道的用法之外，图44-1的另外一个目的是阐明管道这个名称的由来。可以将管道卡成是一组铅管，它允许数据从一个进程流向另一个进程。
Unix网络编程-进程间通信---4、最初的Unix IPC --FIFO
LuckyDog0623的博客
05-03 272
FIFO 1、 FIFO指先进先出first in first out；考虑到pipe只能用户父子进程之间的进程间通信的机制； FIFO和pipe一样，是一个单向数据流，但是fifo有一个路径名与之相关两，能够让不同进程访问实现通信 2、int mkfifo(const char *pathname, mode_t mode) 注意：mode的几个宏 （1）、mkfifo已经指定O_CREAT | O_EXCL，也就是说要么创建新的fifo，要么返回错误（已经存在）mode； （2）、打开（open）一个
网络编程_进程间通信_管道
P__aranoid的博客
11-04 240
一. 匿名管道—-单工管道 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
UNIX网络编程卷1和2
03-20
Richard Stevens撰写，分为卷1和卷2，深入浅出地介绍了UNIX系统上的网络编程技术。这两本书为程序员提供了全面而详细的网络编程知识，是许多开发者的必备参考书籍。 卷1《套接字联网API（第3版）》主要涵盖了以下...
linux/unix系统编程手册附录代码
06-04
《Linux/Unix系统编程手册》是一本深受程序员和系统管理员喜爱的经典著作，它详细阐述了在Linux和Unix操作系统上进行低级编程的各种技术。附录中的代码是书中的实例，旨在帮助读者深入理解和掌握这些系统编程的核心...
unix网络编程上下卷
07-03
此外，还讨论了错误处理、性能优化和网络编程中的常见问题，比如半关闭状态、TIME_WAIT状态和套接字缓冲区的管理。 卷2则将焦点转向进程间通信（IPC），这是构建分布式系统的关键。书中涵盖了许多Unix IPC机制，如...
unix环境高级编程&&unix网络编程
11-08
在IT领域，Unix环境高级编程和Unix网络编程是两本非常经典的教材，它们为程序员提供了深入理解操作系统原理和网络通信的基础。这两本书是学习如何在Unix/Linux系统上编写高效、可靠的程序的重要参考资料。 《Unix...
UNIX网络编程-第2卷-进程间通讯
08-16
总而言之，《UNIX网络编程-第2卷-进程间通讯》是学习和理解UNIX系统中多进程通信不可多得的参考书，对于从事系统编程、网络编程或者并发程序设计的工程师来说，其内容详实、实践性强，能帮助读者深入理解并掌握这一...
Linux网络编程——管道通信
Li丶Chong的博客
07-16 443
管道通信分为无名管道和有名管道，无名管道可以用于具有亲缘关系进程间的通信，有名管道克服管道没有名字的限制 管道是Linux支持的最初UNIX IPC形式之一，具有以下特点 管道是半双工的，数据只能想一个方向流动，需要进行双向通讯时需要建立两个管道 只能用与父子进程和兄弟进程之间（具有亲缘关系）的通讯 单独构成一种独立的文件系统，管道对于管道两端的进程来说就是两个文件，但是它不是普通文件，也...
UNIX环境高级编程——管道和FIFO的额外属性
weixin_33962923的博客
07-07 92
一个描述符能以两种方式设置成非阻塞。（1）调用open时可以指定O_NONBLOCK标志。 writefd = open(FIFO1,O_WRONLY | O_NONBLOCK,0);（2）如果一个描述符已经打开，那么可以调用fcntl以启用O_NONBLOCK标志。对于管道来说，必须使用这种技术，因为管道没有open调用，在pipe调用中也无法指定O_NONBLOCK标志。使用fcnt...
unix环境编程 第十五章 15.5FIFO
weixin_43873960的博客
11-29 68
FIFO有时被命名为管道。通过FIFO，不相关的进程也能交换数据。 创建FIFO类似于创建文件 #include <sys/stat.h> int mkfifo(const char *path,mode_t mode); int mkfifoat(int fd,const char *path,mode_t mode); //成功返回0，出错返回-1 mode参数的规格说明与open函数中的mode的相同。 当open一个FIFO时，非阻塞标志会产生下列影响： 在一般情况下，制度o
UNIX中管道的理解与实现
crazy_scott的博客
03-06 4645
今天上课老师具体讲了管道在UNIX中的作用以及实现原理，自己下来琢磨了好一阵子，基本上搞清楚了，赶紧记在小本本上。 管道是什么 首先来看一个命令： cat file1 file2 | sort cat表示读取file1、file2中的数据，然后使用管道 |，将这些内容作为输入，使用sort函数作为输出，最后输出在屏幕上。 管道做了什么事 熟悉类UNIX系统的朋友一定经...
UNIX网络编程之管道与FIFO
Dandelion_gong的博客
05-16 3985
管道是最初的Unix IPC形式，它们的最大局限是没有名字，所以，管道只能用于有亲缘关系的进程只见使用。之后，慢慢随着FIFO的加入，这点才有所改观。FIFO也成为又名管道。管道和FIFO的共同点就是它们都是通过read和write函数进行访问的。管道： 管道时有pipe函数创建，提供一个单路数据流。也就是说，所有的管道都是半双工。 管道创建方法： #include <unistd.h>
UNIX环境高级编程——管道和FIFO限制
weixin_33995481的博客
07-07 86
系统加于管道和FIFO的唯一限制为：OPEN_MAX 一个进程在任意时刻打开的最大描述符数；PIPE_BUF 可原子的写往一个管道或FIFO的最大数据量。OPEN_MAX的值可通过调用sysconf函数查询。它通过可通过执行ulimit命令(Bourne shell或Korn Shell）或limit命令（C shell）从shell中修改。它也可以通过调用setrlimi...
Unix上用C程序实现pipe管道命令“ | “（pipe，fork，dup2，close，execl，重定向）
weixin_47826078的博客
10-15 574
#include<errno.h> #include<stdio.h> #include<unistd.h> #include<sys/types.h> int main(void){ pid_t childpid; int fd[2]; if((pipe(fd) == -1) || ((childpid = fork()) == -1)){ //{ int pipe(int filedes[2])}: fd[0]先进先出的读，fd[1]写； pipe函
管道-进程通信
dfuw13072的博客
02-27 143
body, table{font-family: 微软雅黑; font-size: 10pt} table{border-collapse: collapse; border: solid gray; border-width: 2px 0 2px 0;} th{border: 1px ...
UNIX网络编程：卷2 - 进程间通信深入解析
"UNIX网络编程 卷2：进程间通信第2版 文字版" 本书是关于UNIX系统下网络编程的权威指南，特别是关注进程间通信（IPC）的方面。作者详细介绍了各种IPC机制，包括管道、FIFO、消息队列、信号量、共享内存以及互斥锁和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

橙子砰砰枪

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

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

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

打赏作者

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

抵扣说明：

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

余额充值