✨个人主页： 北 海
🎉所属专栏： Linux学习之旅
🎃操作环境： CentOS 7.6 阿里云远程服务器

成就一亿技术人

文章目录

🌇前言

命名管道通信属于 IPC 的其中一种方式，作为管道家族，命名管道的特点就是 自带同步与互斥机制、数据单向流通，与匿名管道不同的是：命名管道有自己的名字，因此可以被没有血缘关系的进程看到，意味着命名管道可以实现毫不相干的两个独立进程间通信

图解

🏙️正文

1、什么是命名管道

简单，给匿名管道起个名字就变成了命名管道

那么如何给 匿名管道 起名字呢？

  • 结合文件系统，给匿名管道这个纯纯的内存文件分配 inode，将文件名与之构建联系，关键点在于不给它分配 Data block，因为它是一个纯纯的内存文件，是不需要将数据刷盘到磁盘中的

可以将命名管道理解为 “挂名” 后的匿名管道，把匿名管道加入文件系统中，但仅仅是挂个名而已，目的就是为了让其他进程也能看到这个文件（文件系统中的文件可以被所有进程看到）

因为没有 Data block，所以命名管道这个特殊文件大小为 0

1.1、创建及简单使用

命令管道的创建依赖于函数 mkfifo，函数原型如下

函数原型

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

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

关于 mkfifo 函数

组成部分含义
返回值 int创建成功返回 0，失败返回 -1
参数1 const char *pathname创建命名管道文件时的路径+名字
参数2 mode_t mode创建命令管道文件时的权限

对于参数1，既可以传递绝对路径 /home/xxx/namePipeCode/fifo，也可以传递相对路径 ./fifo，当然绝对路径更灵活，但也更长

对于参数2，mode_t 其实就是对 unsigned int 的封装，等价于 uint32_t，而 mode 就是创建命名管道时的初始权限，实际权限需要经过 umask 掩码计算

不难发现，mkfifo 和 mkdir 非常像，其实 mkfifo 可以直接在命令行中运行

创建一个名为 fifo 的命名管道文件

mkfifo fifo

结果

成功解锁了一种新的特殊类型文件：p 管道文件

图解
出自：Linux 权限理解和学习

这个管道文件也非常特殊：大小为 0，从侧面说明 管道文件就是一个纯纯的内存级文件，有自己的上限，出现在文件系统中，只是单纯挂个名而已

可以直接在命令行中使用命名管道：

  • echo 可以进行数据写入，可以重定向至 fifo
  • cat 可以进行数据读取，同样也可以重定向于 fifo
  • 打开两个终端窗口（两个进程），即可进行通信

图解

当然也可以通过程序实现两个独立进程 IPC

思路：创建 服务端 server 和 客户端 client 两个独立的进程，服务端 server 创建并以 读 的方式打开管道文件，客户端 client 以 写 的方式打开管道文件，打开后俩进程可以进程通信，通信结束后，由客户端关闭 写端（服务端 读端 读取到 0 后也关闭并删除命令管道文件）

注意：

  • 当管道文件不存在时，文件会打开失败，因此为了确保正常通信，需要先运行服务端 server 创建管道文件
  • 服务端启动后，因为是读端，所以会阻塞等待 客户端（写端）写入数据
  • 客户端写入数据时，因为 '\n' 也被读取了，所以要去除此字符
  • 通信结束后，需要服务端主动删除管道文件
unlink 命令管道文件名	//删除管道文件

为了让服务端和客户端能享有同一个文件名，可以创建一个公共头文件 common.h，其中存储 命名管道文件名及默认权限等公有信息

公共资源 common.h

#pragma once

#include <iostream>
#include <string>

std::string fifo_name = "./fifo";   //管道名
uint32_t mode = 0666;   //权限

服务端 server.cc

#include <iostream>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "common.h"

using namespace std;

int main()
{
    // 服务端
    // 1、创建命名管道文件
    int ret = mkfifo(fifo_name.c_str(), mode);
    if (ret < 0)
    {
        cerr << "mkfifo fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 2、以读的方式打开文件
    int rfd = open(fifo_name.c_str(), O_RDONLY);
    if (rfd < 0)
    {
        cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 3、读取数据
    while (true)
    {
        char buff[64];
        int n = read(rfd, buff, sizeof(buff) - 1);
        buff[n] = '\0';

        if (n > 0)
        {
            cout << "Server get message# " << buff << endl;
        }
        else if (n == 0)
        {
            cout << "写端关闭，读端读取到0，终止读端" << endl;
            break;
        }
        else
        {
            cout << "读取异常" << endl;
            break;
        }
    }

    close(rfd);
    unlink(fifo_name.c_str());  //删除命名管道文件

    return 0;
}

客户端 client.cc

#include <iostream>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "common.h"

using namespace std;

int main()
{
    // 客户端
    // 1、打开文件
    int wfd = open(fifo_name.c_str(), O_WRONLY);
    if (wfd < 0)
    {
        cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 2、写入数据，进行通信
    char buff[64] = {0};
    while (true)
    {
        cout << "Client send message# ";
        fgets(buff, sizeof(buff) - 1, stdin);
        buff[strlen(buff) - 1] = '\0'; // 去除 '\n'

        if (strcasecmp("exit", buff) == 0)
            break;

        write(wfd, buff, strlen(buff));
    }

    close(wfd);

    return 0;
}

注：strcasecmp 是一个字符串比较函数，无论字符串大小写，都能进行比较

运行效果：

结果

所以 挂了名之后的命名管道是如何实现独立进程间 IPC 的呢？

1.2、命名管道的工作原理

把视角拉回文件系统：当重复多次打开同一个文件时，并不会费力的打开多次，而且在第一次打开的基础上，对 struct file 结构体中的引用计数 ++，所以对于同一个文件，不同进程打开了，看到的就是同一个

  • 具体例子：显示器文件（stdout）只有一个吧，是不是所有进程都可以同时进行写入？
  • 同理，命名管道文件也是如此，先创建出文件，在文件系统中挂个名，然后让独立的进程以不同的方式打开同一个命名管道文件，比如进程 A 以只读的方式打开，进程 B 以只写的方式打开，那么此时进程 B 就可以向进程 A 写文件，即 IPC

图示

因为命名管道适用于独立的进程间 IPC，所以无论是读端和写端，进程 A、进程 B 为其分配的 fd 是一致的，都是 3

  • 如果是匿名管道，因为是依靠继承才看到同一文件的，所以读端和写端 fd 不一样

所以 命名管道 和 匿名管道 还是有区别的

1.3、命名管道与匿名管道的区别

不同点：

  • 匿名管道只能用于具有血缘关系的进程间通信；而命名管道不讲究，谁都可以用
  • 匿名管道直接通过 pipe 函数创建使用；而命名管道需要先通过 mkfifo 函数创建，然后再通过 open 打开使用
  • 出现多条匿名管道时，可能会出现写端 fd 重复继承的情况；而命名管道不会出现这种情况

在其他方面，匿名管道与命名管道几乎一致

  • 两个都属于管道家族，都是最古老的进程间通信方式，都自带同步与互斥机制，提供的都是流式数据传输

2、命名管道的特点及特殊场景

命名管道的特点及特殊场景与匿名管道完全一致，这里简单回顾下，详细内容可跳转至 《Linux进程间通信【匿名管道】》

2.1、特点

可以简单总结为：

  • 管道是半双工通信
  • 管道生命随进程而终止
  • 命名管道任意多个进程间通信
  • 管道提供的是流式数据传输服务
  • 管道自带 同步与互斥 机制

2.2、四种特殊场景

四种场景分别为

  1. 管道为空时，读端阻塞，等待写端写入数据
  2. 管道为满时，写端阻塞，等待读端读取数据
  3. 进程通信时，关闭读端，OS 发出 13 号信号 SIGPIPE 终止写端进程
  4. 进程通信时，关闭写端，读端读取到 0 字节数据，可以借此判断终止读端

3、命名管道实操

以下是一些使用命名管道实现的简单小程序，主要目的是为了熟悉命名管道的使用

3.1、实现文件拷贝

下载应用的本质是在下载文件，将服务器看作写端，自己的电脑看作读端，那么 下载 这个动作本质上就是 IPC，不过是在网络层面实现的

我们可以利用 命名管道实现不同进程间 IPC，即进程从文件中读取并写入一批数据，另一个进程一次读取一批数据并保存至新文件中，这样就实现了文件的拷贝

目标：利用命名管道，向空文件 target.txt 中写入数据，即拷贝源文件 file.txt

公共资源 common.h

#pragma once

#include <iostream>
#include <string>

std::string fifo_name = "./fifo";   //管道名
uint32_t mode = 0666;   //权限

服务端（写端） server.cc 提供文件拷贝服务

#include <iostream>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "common.h"

using namespace std;

int main()
{
    // 服务端
    // 1、打开文件
    int wfd = open(fifo_name.c_str(), O_WRONLY);
    if (wfd < 0)
    {
        cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 2、打开源文件
    FILE *fp = fopen("file.txt", "r");
    if (fp == NULL)
    {
        cerr << "fopen fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 3、读取源文件数据
    char buff[1024];
    int n = fread(buff, sizeof(char), sizeof(buff), fp);

    //IPC区域
    // 4、写入源文件至命名管道
    write(wfd, buff, strlen(buff));
    cout << "服务端已向管道写入: " << n << "字节的数据" << endl;
    //IPC区域

    fclose(fp);
    fp = nullptr;
    close(wfd);
    return 0;
}

客户端（读端） client.cc 从服务端中拷贝文件（下载）

#include <iostream>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "common.h"

using namespace std;

int main()
{
    // 客户端
    // 1、创建命名管道文件
    int ret = mkfifo(fifo_name.c_str(), mode);
    if (ret < 0)
    {
        cerr << "mkfifo fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 2、以读的方式打开管道文件
    int rfd = open(fifo_name.c_str(), O_RDONLY);
    if (rfd < 0)
    {
        cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 3、打开目标文件
    FILE *fp = fopen("target.txt", "w");
    if (fp == NULL)
    {
        cerr << "fopen fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    //IPC区域
    // 4、读取数据
    char buff[1024];
    int n = read(rfd, buff, sizeof(buff) - 1);
    buff[n] = '\0';

    if (n > 0)
        cout << "客户端已从管道读取: " << n << "字节的数据" << endl;
    else if (n == 0)
        cout << "写端关闭，读端读取到0，终止读端" << endl;
    else
        cout << "读取异常" << endl;
    //IPC区域

    //5、写入目标文件，完成拷贝
    fwrite(buff, sizeof(char), strlen(buff), fp);
    cout << "客户端已成功从服务端下载（拷贝）了文件数据" << endl;

    fclose(fp);
    close(rfd);
    unlink(fifo_name.c_str()); // 删除命名管道文件
    return 0;
}

拷贝结果：成功拷贝

结果

此时 服务端是写端，客户端是读端，实现的是 下载服务；当 服务端是读端，客户端是写端时，实现的就是 上传服务，搞两条管道就能模拟实现简单的 数据双向传输服务

注意： 创建管道文件后，无论先启动读端，还是先启动写端，都要阻塞式的等待另一方进行交互

3.2、实现进程控制

在 Linux 匿名管道 IPC 中，我们实现了一个简易版的进程控制程序，原理是通过多条匿名管道实现父进程对多个子进程执行任务分配

匿名管道用于有血缘关系间 IPC，命名管道也可以

所以我们可以把上一篇文章中的 匿名管道换为命名管道，一样可以实现通信

任务池 Task.hpp

#include <iostream>
#include <string>
#include <functional>
#include <unordered_map>
#include <unistd.h>

using namespace std;

void PrintLOG()
{
    cout << "PID: " << getpid() << " 正在执行打印日志的任务…" << endl;
}

void InsertSQL()
{
    cout << "PID: " << getpid() << " 正在执行数据库插入的任务…" << endl;
}

void NetRequst()
{
    cout << "PID: " << getpid() << " 正在执行网络请求的任务…" << endl;
}

class Task
{
public:
    Task()
    {
        // 装载任务
        _tt = {{"打印日志", PrintLOG}, {"数据库插入", InsertSQL}, {"网络请求", NetRequst}};
    }

    // 展示任务
    void showTask()
    {
        cout << "目前可用任务有：[";
        for (auto e : _tt)
            cout << e.first << " ";
        cout << "]" << endl;
        cout << "输入 退出 以终止程序" << endl;
    }

    // 执行任务
    void Execute(const string &task)
    {
        if (_tt.count(task) == 0)
        {
            cerr << "没有这个任务：" << task << endl;
        }
        else
        {
            _tt[task](); // 函数对象调用
        }
    }

private:
    unordered_map<string, function<void(void)>> _tt;
};

控制程序 namePipeCtrl.cc 包括进程、管道创建，任务执行与进程等待

#include <iostream>
#include <string>
#include <vector>
#include <cassert>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "Task.hpp"

using namespace std;

enum
{
    NAME_SIZE = 64
};

// 子进程基本信息类
class ProcINfo
{

public:
    ProcINfo(pid_t pid = pid_t(), int wfd = int())
        : _pid(pid), _wfd(wfd), _num(_cnt++)
    {
        char buff[NAME_SIZE] = {0};
        snprintf(buff, NAME_SIZE, "Process %d | pid:wfd [%d:%d]", _num, _pid, _wfd);
        _name = string(buff);
    }

    pid_t _pid;
    int _wfd;
    int _num;
    string _name;
    static int _cnt;
};

int ProcINfo::_cnt = 0;

// 进程控制类
class ProcCtrl
{
public:
    ProcCtrl(int num = 3, mode_t mode = 0666)
        : _num(num), _mode(mode)
    {
        // 根据 _num 创建命名管道及子进程
        CreatPipeAndProc();
    }

    ~ProcCtrl()
    {
        waitProc();
    }

    // 创建管道及进程
    void CreatPipeAndProc()
    {
        // 因为是继承的，所以也要注意写端重复继承问题
        vector<int> fds;
        for (int i = 0; i < _num; i++)
        {
            // 步骤：创建管道，存入 _vst
            char pipeNameBUff[NAME_SIZE]; // 管道名缓冲区
            snprintf(pipeNameBUff, NAME_SIZE, "./fifo-%d", i);

            int ret = mkfifo(pipeNameBUff, _mode);
            assert(ret != -1);
            (void)ret;

            _vst.push_back(string(pipeNameBUff));

            // 创建子进程，让子进程以只读的方式打开管道文件
            pid_t id = fork();
            if (id == 0)
            {
                // 子进程内
                // 先关闭不必要的写端
                for (auto e : fds)
                    close(e);

                // 打开管道文件，并进入任务等待默认（读端阻塞）
                int rfd = open(_vst[i].c_str(), O_RDONLY);
                assert(rfd != -1);
                (void)rfd;

                waitCommand(rfd);

                close(rfd); // 关闭读端
                exit(0);
            }

            // 父进程以写打开管道，保存 fd 信息
            int wfd = open(_vst[i].c_str(), O_WRONLY);
            assert(wfd != -1);
            (void)wfd;

            // 注册子进程信息
            _vpt.push_back(ProcINfo(id, wfd));
            fds.push_back(wfd);
        }
    }

    // 子进程等待任务派发
    void waitCommand(int rfd)
    {
        while (true)
        {
            char buff[NAME_SIZE] = {0};
            int n = read(rfd, buff, sizeof(buff) - 1);

            buff[n] = '\0';

            if (n > 0)
            {
                Task().Execute(string(buff));
            }
            else if (n == 0)
            {
                cerr << "读端读取到 0，写端已关闭，读端也即将关闭" << endl;
                break;
            }
            else
            {
                cerr << "子进程读取异常！" << endl;
                break;
            }
        }
    }

    // 展示可选进程
    void showProc()
    {
        cout << "目前可用进程有：[";
        int i = 0;
        for (i = 0; i < _num - 1; i++)
            cout << i << "|";
        cout << i << "]" << endl;
    }

    // 下达任务给子进程
    void ctrlProc()
    {
        while (true)
        {
            cout << "==========================" << endl;
            int n = 0;
            do
            {
                showProc();
                cout << "请选择子进程:> ";
                cin >> n;
            } while (n < 0 || n >= _num);

            Task().showTask();
            string taskName;
            cout << "请选择任务:> ";
            cin >> taskName;

            if (taskName == "退出")
                break;

            // 将信息通过命名管道写给子进程
            cout << "选择进程 ->" << _vpt[n]._name << " 执行 " << taskName << " 任务" << endl;
            write(_vpt[n]._wfd, taskName.c_str(), taskName.size());
            sleep(1);
        }
    }

    // 关闭写端、删除文件、等待子进程退出
    void waitProc()
    {
        for (int i = 0; i < _num; i++)
        {
            close(_vpt[i]._wfd);               // 关闭写端
            unlink(_vst[i].c_str());           // 关闭管道文件
            waitpid(_vpt[i]._pid, nullptr, 0); // 等待子进程
        }

        cout << "所有子进程已回收" << endl;
    }

private:
    vector<ProcINfo> _vpt; // 子进程信息表
    vector<string> _vst;   // 命名管道信息表
    int _num;              // 子进程数/命名管道数
    mode_t _mode;          // 命名管道文件的权限
};

int main()
{
    ProcCtrl p1;
    p1.ctrlProc();
    return 0;
}

执行结果如下：

结果

关于 父子进程间使用命名管道通信 值得注意的问题：

  1. 在命名管道创建后，需要先创建子进程，让子进程打开【读端或写端】，然后才让父进程打开【写端或读端】，这是因为假如先让父进程打开【写端或读端】，那么此时父进程就会进入【阻塞】状态，导致无法创建子进程，自然也就无法再打开【读端或写端】；所以正确做法是先让子进程打开，即使子进程【阻塞】了，父进程也还能运行。不要让【阻塞】阻碍子进程的创建
  2. 子进程继承都存在的问题：写端重复继承，因此需要关闭不必要的写端 fd

关于问题一的理解可以看看下面这两张图：

错误用法： 父进程先打开【写端或读端】，再创建子进程，最后才让子进程打开【读端或写端】

图解1

正确用法： 先创建子进程，让子进程打开【读端或写端】，再让父进程打开【写端或读端】

图解2

3.3、实现进程遥控（配合简易版 bash）

利用命名管道就可以远程遥控，原理很简单：简易版 bash 会等待命令输入，将输入源换成命名管道读端，再创建一个独立进程，作为命名管道的写端，此时就可以实现远程遥控进程，执行不同的指令

这里直接用之前写好的 简易版 bash，关于 简易版 bash 的具体实现可以看看这篇文章 《Linux模拟实现【简易版bash】》

步骤：

  • 创建命名管道
  • 将 bash 改装，打开命名管道文件，作为 读端
  • 创建独立进程，打开命名管道文件，作为 写端
  • 进行 IPC，发送命令给 bash 执行

公共资源 common.h

#pragma once

#include <iostream>
#include <string>

std::string fifo_name = "./fifo";   //管道名
uint32_t mode = 0666;   //权限

简易版bash mybash.cc

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <string.h>
#include <assert.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "common.h"

using namespace std;

#define COM_SIZE 1024
#define ARGV_SIZE 64
#define DEF_CHAR " "

void split(char *argv[ARGV_SIZE], char *ps)
{
    assert(argv && ps);

    // 调用 C语言 中的 strtok 函数分割字符串
    int pos = 0;
    argv[pos++] = strtok(ps, DEF_CHAR); // 有空格就分割
    while (argv[pos++] = strtok(NULL, DEF_CHAR))
        ; // 不断分割

    argv[pos] = NULL; // 确保安全
}

void showEnv()
{
    extern char **environ; // 使用当前进行的环境变量表
    int pos = 0;
    for (; environ[pos]; printf("%s\n", environ[pos++]))
        ;
}

// 枚举类型，用于判断不同的文件打开方式
enum redir
{
    REDIR_INPUT = 0,
    REDIR_OUTPUT,
    REDIR_APPEND,
    REDIR_NONE
} redir_type = REDIR_NONE; // 创建对象 redir_type，默认为 NONE

// 检查是否出现重定向符
char *checkDir(char *command)
{
    // 从右往左遍历，遇到 > >> < 就置为 '\0'
    size_t end = strlen(command); // 与返回值相匹配
    char *ps = command + end;     // 为了避免出现无符号-1，这里采取错位的方法
    while (end != 0)
    {
        if (command[end - 1] == '>')
        {
            if (command[end - 2] == '>')
            {
                command[end - 2] = '\0';
                redir_type = REDIR_APPEND;
                return ps;
            }

            command[end - 1] = '\0';
            redir_type = REDIR_OUTPUT;
            return ps;
        }
        else if (command[end - 1] == '<')
        {
            command[end - 1] = '\0';
            redir_type = REDIR_INPUT;
            return ps;
        }

        // 如果不是空格，就可以更新 ps指向
        if (*(command + end - 1) != ' ')
            ps = command + end - 1;

        end--;
    }

    return NULL; // 如果没有重定向符，就返回空
}

int main()
{
    char myEnv[COM_SIZE][ARGV_SIZE]; // 大小与前面有关
    int env_pos = 0;                 // 专门维护缓冲区
    int exit_code = 0;               // 保存退出码的全局变量

    // 2023.6.7 更新
    // 创建管道文件
    int ret = mkfifo(fifo_name.c_str(), mode);
    assert(ret != -1);
    (void)ret;

    // 打开管道文件
    int rfd = open(fifo_name.c_str(), O_RDONLY);
    assert(rfd != -1);
    (void)rfd;

    // 这是一个始终运行的程序：bash
    while (1)
    {
        char command[COM_SIZE]; // 存放指令的数组（缓冲区）

        // 打印提示符
        printf("[User@myBash default]$ ");
        fflush(stdout);

        // 读取指令
        //从管道中读取
        int n = read(rfd, command, COM_SIZE - 1);

        if(n == 0)
        {
            cout << "写端已关闭，读端也即将关闭" << endl;
            break;
        }

        command[n] = '\0';
        cout << command << endl;

        // 重定向
        // 在获取指令后进行判断
        // 如果成立，则获取目标文件名 filename
        char *filename = checkDir(command);

        // 指令分割
        // 将连续的指令分割为 argv 表
        char *argv[ARGV_SIZE];
        split(argv, command);

        // 特殊处理
        // 颜色高亮处理，识别是否为 ls 指令
        if (strcmp(argv[0], "ls") == 0)
        {
            int pos = 0;
            while (argv[pos++])
                ;                                   // 找到尾
            argv[pos - 1] = (char *)"--color=auto"; // 添加此字段
            argv[pos] = NULL;                       // 结尾
        }

        // 目录间移动处理
        if (strcmp(argv[0], "cd") == 0)
        {
            // 直接调用接口，然后 continue 不再执行后续代码
            if (strcmp(argv[1], "~") == 0)
                chdir("/home"); // 回到家目录
            else if (strcmp(argv[1], "-") == 0)
                chdir(getenv("OLDPWD"));
            else if (argv[1])
                chdir(argv[1]); // argv[1] 中就是路径
            continue;           // 终止此次循环
        }

        // 环境变量相关
        if (strcmp(argv[0], "export") == 0)
        {
            if (argv[1])
            {
                strcpy(myEnv[env_pos], argv[1]);
                putenv(myEnv[env_pos++]);
            }
            continue; // 一样需要提前结束循环
        }

        // 环境变量表
        if (strcmp(argv[0], "env") == 0)
        {
            showEnv(); // 调用函数，打印父进程的环境变量表
            continue;  // 提前结束本次循环
        }

        // echo 相关
        // 只有 echo $ 才做特殊处理（环境变量+退出码）
        if (strcmp(argv[0], "echo") == 0 && argv[1][0] == '$')
        {
            if (argv[1] && argv[1][0] == '$')
            {
                if (argv[1][1] == '?')
                    printf("%d\n", exit_code);
                else
                    printf("%s\n", getenv(argv[1] + 1));
            }

            continue;
        }

        // 子进程进行程序替换
        pid_t id = fork();
        if (id == 0)
        {
            // 判断是否需要进行重定向
            if (redir_type == REDIR_INPUT)
            {
                int fd = open(filename, O_RDONLY);
                dup2(fd, 0); // 更改输入，读取文件 filename
            }
            else if (redir_type == REDIR_OUTPUT)
            {
                int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
                dup2(fd, 1); // 写入
            }
            else if (redir_type == REDIR_APPEND)
            {
                int fd = open(filename, O_WRONLY | O_CREAT | O_APPEND, 0666);
                dup2(fd, 1); // 追加
            }

            // 直接执行程序替换，这里使用 execvp
            execvp(argv[0], argv);

            exit(168); // 替换失败后返回
        }

        // 父进程等待子进程终止
        int status = 0;
        waitpid(id, &status, 0); // 在等待队列中阻塞
        exit_code = WEXITSTATUS(status);
        if (WIFEXITED(status))
        {
            // 假如程序替换失败
            if (exit_code == 168)
                printf("%s: Error - %s\n", argv[0], "The directive is not yet defined");
        }
        else
            printf("process run fail! [code_dump]:%d [exit_signal]:%d\n", (status >> 7) & 1, status & 0x7F); // 子进程异常终止的情况
    }

    //关闭管道文件
    close(rfd);
    unlink(fifo_name.c_str());
    return 0;
}

进程控制端 namePipeCtrl.cc

#include <iostream>
#include <cassert>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include "common.h"

using namespace std;

int main()
{
    // 打开管道文件 --- 只写
    int wfd = open(fifo_name.c_str(), O_WRONLY);
    assert(wfd != -1);
    (void)wfd;

    char buff[64];
    while (true)
    {
        cout << "远程发送指令:> ";
        fgets(buff, sizeof(buff) - 1, stdin);
        buff[strlen(buff) - 1] = '\0';  // 去除 '\n'

        if (strcasecmp("exit", buff) == 0)
            break;

        // 向管道写入数据
        write(wfd, buff, strlen(buff));
    }

    close(wfd);
    return 0;
}

实际效果如下：

图示

注意： 在进行指令处理时，需要注意 '\n'，不能把 '\n' 带入进程替换中

3.4、实现字符实时读取

回车 '\n' 这个东西很难处理，那么有没有一种方式，能实现不输入回车也能写入数据至管道中呢？答案是有的

比如以下代码，可以实现特殊化读取，即 不需要特定条件触发缓冲区冲刷，实时写入字符

公共资源 common.h

#pragma once

#include <iostream>
#include <string>

std::string fifo_name = "./fifo";   //管道名
uint32_t mode = 0666;   //权限

服务端 server.cc 实时读取字符

#include <iostream>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "common.h"

using namespace std;

int main()
{
    // 服务端
    // 1、创建命名管道文件
    int ret = mkfifo(fifo_name.c_str(), mode);
    if (ret < 0)
    {
        cerr << "mkfifo fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 2、以读的方式打开文件
    int rfd = open(fifo_name.c_str(), O_RDONLY);
    if (rfd < 0)
    {
        cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 3、读取数据
    while (true)
    {
        char buff[64];
        int n = read(rfd, buff, sizeof(buff) - 1);
        buff[n] = '\0';

        if (n > 0)
        {
            buff[n] = 0;
            printf("%c", buff[0]);
            fflush(stdout);
        }
        else if (n == 0)
        {
            cout << "写端关闭，读端读取到0，终止读端" << endl;
            break;
        }
        else
        {
            cout << "读取异常" << endl;
            break;
        }
    }

    close(rfd);
    unlink(fifo_name.c_str()); // 删除命名管道文件

    return 0;
}

客户端 client.cc 实时发送字符

#include <iostream>
#include <cstring>
#include <cerrno>
#include <cassert>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "common.h"

using namespace std;

int main()
{
    // 客户端
    // 1、打开文件
    int wfd = open(fifo_name.c_str(), O_WRONLY);
    if (wfd < 0)
    {
        cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 2、写入数据，进行通信
    char buff[64] = {0};
    while (true)
    {
        system("stty raw");
        int c = getchar();
        system("stty -raw");

        ssize_t n = write(wfd, (char *)&c, sizeof(char));
        assert(n >= 0);
        (void)n;
    }

    close(wfd);

    return 0;
}

实时读取字符的效果如下：

图示

本文中涉及的所有代码均在此仓库中：《命名管道博客仓库》

🌆总结

以上就是本次关于 Linux 进程间通信之命名管道的全部内容了，作为匿名管道的兄弟，命名管道具备匿名管道的大部分特性，使用方法也基本一致，不过二者在创建和打开方式上各有不同：匿名管道简单，但只能用于具有血缘关系进程间通信，命名管道虽麻烦些，但适用于所有进程间通信场景；在本文的最后，使用命名管道实现了几个简单的小程序，这些小程序的本质都是一样的：创建命名管道 -> 打开命名管道 -> 通信 -> 关闭命名管道，掌握其中一个即可融会贯通

星辰大海

相关文章推荐

Linux进程间通信【匿名管道】

Linux基础IO【软硬链接与动静态库】

Linux基础IO【深入理解文件系统】

Linux【模拟实现C语言文件流】

Linux基础IO【重定向及缓冲区理解】

Linux基础IO【文件理解与操作】

# linux # 运维 # 服务器
Logo
开放原子开发者工作坊

开放原子开发者工作坊旨在鼓励更多人参与开源活动，与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动，如meetup、训练营等，主打技术交流，干货满满，真诚地邀请各位开发者共同参与！

更多推荐

第二届开放原子大赛首批创新成果集结武汉，诚邀广大开发者共鉴开源技术盛宴

第二届开放原子大赛首批创新成果集结武汉，诚邀广大开发者共鉴开源技术盛宴

avatar 开放原子开发者工作坊

诚邀报名 | 开源基础设施能力建设分论坛：打造开源生态的“心脏”

诚邀报名 | 开源基础设施能力建设分论坛：打造开源生态的“心脏”

avatar 开放原子开发者工作坊

诚邀报名 | 编程语言分论坛：AI时代的技术革新与开源实践

诚邀报名 | 编程语言分论坛：AI时代的技术革新与开源实践

avatar 开放原子开发者工作坊