如何正确使用管道将数据从子进程传输到父进程？

Question

I'm trying to create a function that returns true if execvp is successful and false if it is not. Initially, I didn't use a pipe and the problem was that whenever execvp failed, I get 2 returns, one false and one true (from the parent). Now that I'm piping, I'm never getting a false returned when execvp fails.

I know there are a lot related questions and answers on this topic, but I can't seem to narrow down where my particular error is. What I want is for my variables return_type_child, return_type_parent, and this->return_type to all contain the same value. I expected that in the child process, execvp would fail so the next lines would execute. As a result, I thought that the 3 variables mentioned would all be false, but instead when I print out the value in this->return_type, 1 is displayed.

bool Command::execute() {
    this->fork_helper();
    return return_type;
}

void Command::fork_helper() {
    bool return_type_child = true;
    int fd[2];
    pipe(fd);
    pid_t child;
    char *const argv[] = {"zf","-la", nullptr};
    child = fork();
    if (child > 0) {
        wait(NULL);
        close(0);
        close(fd[1]);
        dup(fd[0]);
        bool return_type_parent = read(fd[0], &return_type_child, sizeof(return_
        this->return_type = return_type_parent;
    }
    else if (child == 0) {
        close(fd[0]);
        close(1);
        dup(fd[1]);
        execvp(argv[0], argv);
        this->return_type = false;
        return_type_child = false;
        write(1,&return_type_child,sizeof(return_type_child));
    }
    return;
}

I've also tried putting a cout statement after execvp(argv[0], argv), which never ran. Any help is greatly appreciated!

Answer 1

From the code, it seems to be an XY problem (edit: moved this section to the front due to a comment that confirms this). If the goal is to get the exit status of the child, then for that there is the value that wait returns , and no pipes are required:

int stat;
wait(&stat);

Read the manual of wait to figure out how to read it. The value of stat can be tested as follows:

• WEXITSTATUS(stat) - If WIFEXITED(stat) != 0, then this are the lower 8 bits of child's call to exit(N) or the return value from main . It might work correctly without checking WIFEXITED, but the standard does not specify that.
• WTERMSIG(stat) - If WIFSIGNALED(stat) != 0, then this is the signal number that caused the process to exit (eg 11 is segmentation fault). It might work correctly without checking WIFSIGNALED, but the standard does not specify that.

There are several errors in the code. See the added comments:

void Command::fork_helper() {
    // File descriptors here: 0=stdin, 1=stdout, 2=stderr 
    //(and 3..N opened in the program, could also be none).
    bool return_type_child = true;
    int fd[2];
    pipe(fd);
    // File descriptors here: 0=stdin, 1=stdout, 2=stderr 
    //(and 3..N opened in the program, could also be none).
    // N+1=fd[0] data exhaust of the pipe
    // N+2=fd[1] data intake of the pipe
    pid_t child;
    char *const argv[] = {"zf","-la", nullptr};
    child = fork();
    if (child > 0) {
        // This code is executed in the parent.
        wait(NULL); // wait for the child to complete.

This wait is a potential deadlock: if the child writes enough data to the pipe (usually in the kilobytes) , the write blocks and waits for the parent to read the pipe. The parent wait(NULL) waits for the child to complete, which which waits for the parent to read the pipe. This is likely not effecting the code in question, but it is problematic.

        close(0);
        close(fd[1]);
        dup(fd[0]);
        // File descriptors here: 0=new stdin=data exhaust of the pipe
        // 1=stdout, 2=stderr 
        // (and 3..N opened in the program, could also be none).
        // N+1=fd[0] data exhaust of the pipe (stdin is now a duplicate)

This is problematic since:

1. the code just lost the original stdin.
2. The pipe is never closed. You should close fd[0] explicitly, don't close(0), and don't duplicate fd[0].
3. It is good idea to avoid having duplicate descriptors, except for having stderr duplicate stdout.

.

        bool return_type_parent = read(fd[0], &return_type_child, sizeof(return_
        this->return_type = return_type_parent;

    }
    else if (child == 0) {
        // this code runs in the child.
        close(fd[0]);
        close(1);
        dup(fd[1]);
        // File descriptors here: 0=stdin, 1=new stdout=pipe intake, 2=stderr 
        //(and 3..N opened in the program, could also be none).
        // N+2=fd[1] pipe intake (new stdout is a duplicate)

This is problematic, since there are two duplicate data intakes to the pipe. In this case it is not critical since they are both closed automatically when the process ends, but it is a bad practice. It is a bad practice, since only closing all the pipe intakes signals END-OF-FILE to the exhaust. Closing one intake but not the other, does not signal END-OF-FILE. Again, in your case it is not causing trouble since the child's exit closes all the intakes.

        execvp(argv[0], argv);

The code below the above line is never reached, unless execvp itself failed. The execvp fails only when the file does not exist, or the caller has no permission to execute it. If the executable starts to execute and fails later (possibly even if it fails to read a shared library), then still execvp itself succeeds and never returns. This is because execvp replaces the executable, and the following code is no longer in memory when execvp starts to run the other program.

        this->return_type = false;
        return_type_child = false;
        write(1,&return_type_child,sizeof(return_type_child));
    }
    return;
 }