Read/write stdin/out for bash interpreter linux, fork - execl

Question

I've been trying to write a program that will send and receive commands to a bash shell (/bin/sh). Like a wrapper program around a bash shell. So, I could write to stdin "cd ~/Desktop", then write again "ls" and I will receive a listing of the files on the desktop. I can't get it working though. On the second write command in this code, it will echo back whatever I wrote to stdin. I've also tried using popen() but that only provides output, not allowing me to write to stdin. Could someone please help solve this problem? Thanks

void main()
{
    // Create a pipe and fork
    //
    int fd[2];
    int p = pipe(fd);
    pid_t pid = fork();

    if (pid > 0)
    {
        // Read from the pipe and output the result
        //
        //close(fd[1]);
        char buf[1024] = { 0 };

        read(fd[0], buf, sizeof(buf));

        printf("1 - %s\n", buf);

        write (fd[1], "ifconfig", strlen ("ifconfig") );

        // problem is here, read is returning echo'd bytes from write()

        read(fd[0], buf, sizeof(buf));

        printf("2 - %s\n", buf);    


        // Wait for child to terminate
        int status;
        wait(&status);
    }
    else if (pid == 0)
    {
        // Redirect stdout and stderr to the pipe and execute the shell
        // command
        //
        dup2(fd[0], STDIN_FILENO);
        dup2(fd[1], STDOUT_FILENO);
        dup2(fd[1], STDERR_FILENO);
        //close(fd[0]);
        execl("/bin/sh", "exec sh", "-c", "ls", (char*) NULL );
    }

}

EDIT - Updated code per 1st answer, now there is no output from the 2nd read() call

void main()
{
    // Create a pipe and fork
    //
    int fd[2];

int ChildToParent[2], ParentToChild[2];



    pipe (ParentToChild);
pipe (ChildToParent);

    pid_t pid = fork();

    if (pid > 0)
    {
        // In parent process

        // Read the output of the child from child_to_parent[0]
        // We don't need child_to_parent[1] so close it
        close(ChildToParent[1]);

        // Write output to the child using parent_to_child[1]
        // We don't need parent_to_child[0] so close it
        close(ParentToChild[0]);

        // Read from and write to the child process...
        char buf[1024] = { 0 };

        read(ChildToParent[0], buf, sizeof(buf));   
    printf("1 - %s\n", buf);


    write(ParentToChild[1], "whoami", strlen ("whoami") );

    memset (buf, 0, 1024);

    // this call to read returns nothing
    read(ChildToParent[0], buf, sizeof(buf));
    printf("2 - %s\n", buf);



    }
    else if (pid == 0)
    {
        // Redirect stdout and stderr to the pipe and execute the shell
        // command
        //
    // child_to_parent[1] is were we write output, it's the
        // new standard output, child_to_parent[0] can be closed
        dup2 (ChildToParent[1], STDOUT_FILENO);
        close(ChildToParent[0]);

        // parent_to_child[0] is where we read input from, it's the
        // new standard input, parent_to_child[1] can be closed
        dup2 (ParentToChild[0], STDIN_FILENO);
        close(ParentToChild[1]);

        //close(fd[0]);
        execl("/bin/sh", "exec sh", "-c", "ls", (char*) NULL );
    }

}

Answer 1

Remember that pipes are a one-way communication stream. You can't use it for two-way communication between two processes. For that you need two pipes, one in each direction.

Perhaps something like this simple example:

// Pipe for the child process to write to the parent process
int child_to_parent[2];

// Pipe for the parent process to write to the child process
int parent_to_child[2];

// Create the TWO pipes
pipe(child_to_parent);
pipe(parent_to_child);

pid_t pid = fork();
if (pid > 0)
{
    // In parent process

    // Read the output of the child from child_to_parent[0]
    // We don't need child_to_parent[1] so close it
    close(child_to_parent[1]);

    // Write output to the child using parent_to_child[1]
    // We don't need parent_to_child[0] so close it
    close(parent_to_child[0]);

    // Read from and write to the child process...
}
else if (pid == 0)
{
    // In child process

    // child_to_parent[1] is were we write output, it's the
    // new standard output, child_to_parent[0] can be closed
    dup2(child_to_parent[1], STDOUT_FILENO);
    close(child_to_parent[0]);

    // parent_to_child[0] is where we read input from, it's the
    // new standard input, parent_to_child[1] can be closed
    dup2(parent_to_child[0], STDIN_FILENO);
    close(parent_to_child[1]);

    // Do whatever the child is supposed to do
}