在接下来的对pipe调用的研究中，我们将学习如何在子进程中运行一个与其父进程完全不同的另外一个程序，而不是仅仅运行一个相同程序。我们用exec调用来完成这一工作。这里的一个难点是，通过exec调用的进程需要知道应该访问哪个文件描述符。在前面的例子中，因为子进程本身有file_pipes数据的一份副本，所以这并不成为问题。但经过exec调用后，情况就不一样了，因为原先的进程已经被新的子进程替换了。为解决这个问题，我们可以将文件描述符（它实际上只是一个数字）作为一个参数传递给用exec启动的程序。

为了演示它是如何工作的，我们需要使用两个程序。第一个程序是数据生产者，它负责创建管道和启动子进程，而后者是数据消费者。

实验 管道和exec函数 

（1）下面这个程序pipe3.c是从pipe2.c修改而来。我们在改动的地方加上了阴影，如下所示：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#define DEBUG_INFO(format, ...) printf("%s - %d - %s :: "format"\n",__FILE__,__LINE__,__func__ ,##__VA_ARGS__)

void test_01(void){
    int len = 0;
    int fds_pipes[2];
    const char some_data[] = "123";
    const char some_data2[] = "456";
    pid_t pid;
    int res;

    char buf[BUFSIZ + 1];
    char buf2[BUFSIZ + 1];


    memset(buf,0,sizeof(buf));
    memset(buf2,0,sizeof(buf2));

    res = pipe(fds_pipes);
    if(res != 0){
        perror("pipe:");
        return;
    }
    pid = fork();
    if(pid < 0){
        perror("fork:");
        return ;
    }
    if(pid == 0){

        sprintf(buf,"%d",fds_pipes[0]);
        sprintf(buf2,"%d",fds_pipes[1]);
        DEBUG_INFO("CHILD");
        res = execl("/big/work/ipc/_build_/pipe4","pipe4",buf,buf2,(char*)0);
        if(res != 0){
            perror("execl:");
            exit(-1);
        }
        sleep(1);
        exit(0);
    }
    len = write(fds_pipes[1],some_data,BUFSIZ);
    DEBUG_INFO("PARENT:pid = %lu,write -- len = %d\n",getpid(),len);
    exit(0);
}

int main(int argc, char**argv){
    test_01();
    DEBUG_INFO("hello world");
    return 0;
}

（2）数据消费者程序pipe4.c负责读取数据，它的代码要简单得多，如下所示： 

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#define DEBUG_INFO(format, ...) printf("%s - %d - %s :: "format"\n",__FILE__,__LINE__,__func__ ,##__VA_ARGS__)

void test_01(int argc, char**argv){
    int len = 0;
    pid_t pid;
    int res;
    int fd_write;
    int fd_read;
    char buf[BUFSIZ + 1];

    memset(buf,0,sizeof(buf));
    sscanf(argv[1], "%d", &fd_read);
    sscanf(argv[2], "%d", &fd_write);

    len = read(fd_read,buf,sizeof(buf));
    DEBUG_INFO("read:len = %d,buf = %s,fd_read=%d",len,buf,fd_read);
}

int main(int argc, char**argv){
    test_01(argc,argv);
    DEBUG_INFO("hello world");
    return 0;
}

要记住，pipe3在程序中调用pipe4，运行pipe3时，我们将看到如下所示的输出结果： 

 实验解析

pipe3程序的开始部分和前面的例子一样，用pipe调用创建一个管道，然后用fork调用创建一个新进程。接下来，它用sprintf把读取管道数据的文件描述符保存到一个缓存区中，该缓存区中的内容将构成pipe4程序的一个参数。我们通过execl调用来启动pipe4程序，execl的参数如下所示。

 ❑ 要启动的程序。

❑ argv[0]：程序名。

❑ argv[1]：包含我们想让被调用程序去读取的文件描述符。

❑（char ＊）0：这个参数的作用是终止被调用程序的参数列表。

pipe4程序从参数字符串中提取出文件描述符数字，然后读取该文件描述符来获取数据。

管道关闭后的读操作 

在继续学习之前，我们再来仔细研究一下打开的文件描述符。至此，我们一直采取的是让读进程读取一些数据然后直接退出的方式，并假设Linux会把清理文件当作是在进程结束时应该做的工作的一部分。

但大多数从标准输入读取数据的程序采用的却是与我们到目前为止见到的例子非常不同的另外一种做法。通常它们并不知道有多少数据需要读取，所以往往采用循环的方法，读取数据——处理数据——读取更多的数据，直到没有数据可读为止。

当没有数据可读时，read调用通常会阻塞，即它将暂停进程来等待直到有数据到达为止。如果管道的另一端已被关闭，也就是说，没有进程打开这个管道并向它写数据了，这时read调用就会阻塞。但这样的阻塞不是很有用，因此对一个已关闭写数据的管道做read调用将返回0而不是阻塞。这就使读进程能够像检测文件结束一样，对管道进行检测并作出相应的动作。注意，这与读取一个无效的文件描述符不同，read把无效的文件描述符看作一个错误并返回-1。

如果跨越fork调用使用管道，就会有两个不同的文件描述符可以用于向管道写数据，一个在父进程中，一个在子进程中。只有把父子进程中的针对管道的写文件描述符都关闭，管道才会被认为是关闭了，对管道的read调用才会失败。我们还将深入讨论这一问题，在学习到O_NONBLOCK标志和FIFO时，我们将看到一个这样的例子。

 把管道用作标准输入和标准输出 

现在，我们已知道了如何使得对一个空管道的读操作失败，下面我们来看一种用管道连接两个进程的更简洁的方法。我们把其中一个管道文件描述符设置为一个已知值，一般是标准输入0或标准输出1。在父进程中做这个设置稍微有点复杂，但它使得子程序的编写变得非常简单。这样做的最大好处是我们可以调用标准程序，即那些不需要以文件描述符为参数的程序。为了完成这个工作，我们需要使用在第3章中介绍过的dup函数。dup函数有两个紧密关联的版本，它们的原型如下所示：

#include <unistd.h>

int dup(int oldfd);
int dup2(int oldfd, int newfd);

dup调用的目的是打开一个新的文件描述符，这与open调用有点类似。不同之处是，dup调用创建的新文件描述符与作为它的参数的那个已有文件描述符指向同一个文件（或管道）。对于dup函数来说，新的文件描述符总是取最小的可用值。而对于dup2函数来说，它所创建的新文件描述符或者与参数file_descriptor_two相同，或者是第一个大于该参数的可用值。

我们可以使用更通用的fcntl调用（command参数设置为F_DUPFD）来达到与调用dup和dup2相同的效果。虽然如此，但dup调用更易于使用，因为它是专门用于复制文件描述符的。而且它的使用非常普遍，你可以发现，在已有的程序中，它的使用比fcntl和F_DUPFD更频繁。

那么，dup是如何帮助我们在进程之间传递数据的呢？诀窍就在于，标准输入的文件描述符总是0，而dup返回的新的文件描述符又总是使用最小可用的数字。因此，如果我们首先关闭文件描述符0然后调用dup，那么新的文件描述符就将是数字0。因为新的文件描述符是复制一个已有的文件描述符，所以标准输入就会改为指向一个我们传递给dup函数的文件描述符所对应的文件或管道。我们创建了两个文件描述符，它们指向同一个文件或管道，而且其中之一是标准输入。

用close和dup函数对文件描述符进行处理

理解当我们关闭文件描述符0，然后调用dup究竟发生了什么的最简单的方法就是，查看开头的4个文件描述符的状态在这一过程中的改变情况，如下表所示

 

 实验 管道和dup函数

再回到前面的例子，但这次，我们将把子程序的stdin文件描述符替换为我们创建的管道的读取端。我们还将对文件描述符做一些清理，使得子程序可以正确检测到管道中数据的结束。与往常一样，为了简洁起见，我们省略了一些错误检查。用如下的代码将pipe3.c修改为pipe5.c：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#define DEBUG_INFO(format, ...) printf("%s - %d - %s :: "format"\n",__FILE__,__LINE__,__func__ ,##__VA_ARGS__)

void test_01(void){
    int len = 0;
    int fds_pipes[2];
    const char some_data[] = "123";
    pid_t pid;
    int res;

    char buf[BUFSIZ + 1];

    memset(buf,0,sizeof(buf));

    res = pipe(fds_pipes);
    if(res != 0){
        perror("pipe:");
        return;
    }
    pid = fork();
    if(pid < 0){
        perror("fork:");
        return ;
    }
    if(pid == 0){
        close(0);
        res = dup(fds_pipes[0]);
        DEBUG_INFO("res = %d", res);
        close(fds_pipes[0]);
        close(fds_pipes[1]);
        res = execlp("od","od","-c",(char*)0);
        if(res != 0){
            perror("execl:");
            exit(-1);
        }
        sleep(1);
        exit(0);
    }
    close(fds_pipes[0]);
    len = write(fds_pipes[1],some_data,strlen(some_data));
    close(fds_pipes[1]);
    DEBUG_INFO("PARENT:pid = %lu,write -- len = %d\n",getpid(),len);
    sleep(3);
    exit(0);
}

int main(int argc, char**argv){
    test_01();
    DEBUG_INFO("hello world");
    return 0;
}

 执行结果：

 实验解析

与往常一样，这个程序创建一个管道，然后通过fork创建一个子进程。此时，父子进程都有可以访问管道的文件描述符，一个用于读数据，一个用于写数据，所以总共有4个打开的文件描述符。

我们首先来看子进程。子进程先用close（0）关闭它的标准输入，然后调用dup（file_pipes[0]）把与管道的读取端关联的文件描述符复制为文件描述符0，即标准输入。接下来，子进程关闭原先的用来从管道读取数据的文件描述符file_pipes[0]。因为子进程不会向管道写数据，所以它把与管道关联的写操作文件描述符file_pipes[1]也关闭了。现在，它只有一个与管道关联的文件描述符，即文件描述符0，它的标准输入。

接下来，子进程就可以用exec来启动任何从标准输入读取数据的程序了。在本例中，我们使用的是od命令。od命令将等待数据的到来，就好像它在等待来自用户终端的输入一样。事实上，如果没有明确使用检测这两者之间不同的特殊代码，它并不知道输入是来自一个管道，而不是来自一个终端。

父进程首先关闭管道的读取端file_pipes[0]，因为它不会从管道读取数据。接着它向管道写入数据。当所有数据都写完后，父进程关闭管道的写入端并退出。因为现在已没有打开的文件描述符可以向管道写数据了，od程序读取写到管道中的3个字节数据后，后续的读操作将返回0字节，表示已到达文件尾。当读操作返回0时，od程序就退出运行。这类似于在终端上运行od命令，然后按下Ctrl+D组合键发送文件尾标志。下图显示调用pipe之后的情况。

 下图显示调用fork之后的情况。

 下图显示程序做好数据传输准备之后的情况。

 CMakeLists.tx 、编译脚本和sftp.json

cmake_minimum_required(VERSION 3.8)
project(myapp)

# add_compile_options("-std=c++11")

add_executable(popen popen.c)
add_executable(popen2 popen2.c)
add_executable(popen3 popen3.c)
add_executable(popen4 popen4.c)
add_executable(pipe1 pipe1.c)
add_executable(pipe2 pipe2.c)
add_executable(pipe3 pipe3.c)
add_executable(pipe4 pipe4.c)
add_executable(pipe5 pipe5.c)

rm -rf _build_
mkdir _build_ -p
cmake -S ./ -B _build_
make -C _build_
# ./_build_/popen
# ./_build_/popen2
# ./_build_/popen3
# ./_build_/popen4
# ./_build_/pipe1
# ./_build_/pipe2
# ./_build_/pipe3
# ./_build_/pipe4
./_build_/pipe5

{
    "name": "My Server",
    "host": "192.168.31.138",
    "protocol": "sftp",
    "port": 22,
    "username": "lkmao",
    "password": "lkmao",
    "remotePath": "/big/work/ipc",
    "uploadOnSave": true,
    "useTempFile": false,
    "openSsh": false
}

小结