通过C中的管道重定向stdin和stdout适用于外部程序，但不适用于递归调用

Question

I am trying to communicate with forked child processes via pipe redirection of stdin and stdout in C. I already managed to get this to work for shell commands (like ls , for example) executed in child processes. However, I wasn't able to recursively execute the same program and redirect the output (printed by printf() , fprintf() to stdout , ...) via the pipes from the child process to the parent (in this test to stdout of the parent), although this works fine for ls or similar commands.

Here's how I tried to approach this:

• I create a pipe, the reading end is for the parent, the child process should write to the writing end.
• The Process forks, both processes close the unused end, respectively.
• The writing end of the pipe is redirected to STDOUT_FILENO and closed
• The child process executes the program recursively (it is called ./to2)

As mentioned, this does work if I execute ls in the child process, but not if I try to call the same program recursively. Here's my test program where I tried to get this to work:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <netdb.h>
#include <errno.h>
#include <time.h>
#include <signal.h>
#include <fcntl.h>


static void usage(void){
    fprintf(stderr,"RIP");
    exit(EXIT_FAILURE);
}

int main(int argc, char *argv[]){   
    if(argc > 1){
        dprintf(STDOUT_FILENO,"Please work\n"); 
        printf("\n THIS IS A MESSAGE FROM THE CHILD \n");
        fputs("Pretty Please!\n",stdout);
        fflush(stdout);
        exit(EXIT_SUCCESS);
    }
    int p1[2];
    if(-1 == pipe(p1)) { 
        fprintf(stderr,"pipe\n");
        fprintf(stderr,"%s\n",strerror(errno));
        usage();    
    }
    int f = fork();
    if(f == 0){
        close(p1[0]);
        if(dup2(p1[1],STDOUT_FILENO) < 0){
            fprintf(stderr,"dup2\n");
            usage();
        }
        close(p1[1]);

        //I want this to work:
        //execlp("./to2", "./to2", "-e");

        //This works fine:
        execlp("ls", "ls");

        exit(EXIT_SUCCESS);
    } else if (f == -1) {
        usage();
    } else  {
        close(p1[1]);
        int w = -1;
        if(-1 == wait(&w)) usage();
        char b[12];
        memset(b,0,12); 
        read(p1[0],&b,12);

        char reading_buf[1];

        while(read(p1[0], reading_buf, 1) > 0){ 
            write(1, reading_buf, STDOUT_FILENO);
        }
        close(p1[0]);
    }
}   

For testing purposes, the function is called recursively with additional arguments, while the parent program is called without additional arguments (hence the if(argc>1) ). In the final program, endless recursion is being avoided by other means.

Did I understand something wrongly? I am pretty confused by the fact that the only thing that doesn't seem to work is redirecting the output of my own program...

Thank you very much in advance, any help or ideas are greatly appreciated.

Answer 1

The primary problem is precisely as outlined in the comments — you are not calling execlp() correctly (nor ls in the alternative). You must make the last argument on those function calls into an explicit null pointer, as shown in this code, which is a mostly mildly edited version of what's in the question:

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

static void usage(void)
{
    fprintf(stderr, "RIP\n");
    exit(EXIT_FAILURE);
}

int main(int argc, char *argv[])
{
    if (argc > 1)
    {
        dprintf(STDOUT_FILENO, "Please work\n");
        printf("THIS IS A MESSAGE FROM THE CHILD\n");
        fputs("Pretty Please!\n", stdout);
        fflush(stdout);
        exit(EXIT_SUCCESS);
    }
    int p1[2];
    if (-1 == pipe(p1))
    {
        fprintf(stderr, "pipe: %s\n", strerror(errno));
        usage();
    }
    int f = fork();
    if (f == 0)
    {
        close(p1[0]);
        if (dup2(p1[1], STDOUT_FILENO) < 0)
        {
            fprintf(stderr, "dup2: %s\n", strerror(errno));
            usage();
        }
        close(p1[1]);
        execlp(argv[0], argv[0], "-e", (char *)0);
        fprintf(stderr, "failed to exec %s again\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    else if (f == -1)
    {
        usage();
    }
    else
    {
        close(p1[1]);
        char b[13];
        memset(b, 0, 13);
        if (read(p1[0], &b, 12) < 0)
        {
            fprintf(stderr, "Failed to read from pipe (%s)\n", strerror(errno));
            exit(EXIT_FAILURE);
        }
        int len = strcspn(b, "\n");
        printf("M1 [%.*s]\n", len, b);

        char reading_buf[1];

        while (read(p1[0], reading_buf, 1) > 0)
        {
            write(1, reading_buf, STDOUT_FILENO);
        }
        close(p1[0]);
        int w = -1;
        if (-1 == wait(&w))
            usage();
    }
    return 0;
}

Two important changes should be highlighted:

• This code echoes the first line of data — the one written by dprintf() — whereas the original code just read it and discarded it.
• The wait() call is after the input, not before. If the child had more data to write than a set of fixed messages, it could block waiting for the parent to read some of the data, while the parent is blocked waiting for the child to exit. This would be a deadlock.

The usage() function is not appropriately named — it doesn't report how to run the program. I also exit with a failure status, not success, if the child process fails the execlp() .

Under peculiar circumstances, the wait() call might report on the exit status from some child other than the one that was forked. It is generally best to use a loop to reap such children. However, the circumstances required are extremely peculiar — the process which launched the parent with an exec*() function must have previously created some children for which it didn't wait, so that they are inherited by the parent process (because the PID doesn't change across an exec*() call).