Programming

save stdin stdout and stderr using dup.
For every command
{
    int fd[2];
    if(not last command in pipe)
    {
        if(count ==0)
        {
            if(pipe(fd_pipe) < 0)
            {
                perror("pipe");
            }
 
        }
 
 
        if(dup2(fd_pipe[1], STDOUT_FILENO) <0)
        {
            perror("pipe");
        }
        if(dup2(fd_pipe[0], STDIN_FILENO) <0)
        {
            perror("pipe");
        }
        ++count;
    }
}
else if(last command)
{
    char line[100];
 
    if(dup2(fd_pipe[0], STDIN_FILENO) <0)
    {
        perror("pipe");
    }
    if(dup2(bstdout, 1) <0)
    {
        perror("pipe");
    }
}
Execute the command in subshell(fork and exec)
}
restore stdin out and stderr.

# parent gets writing-end of pipe, child gets reading-end of pipe.
int pipefd[2];

pid_t pid;
pipe(pipefd);

pid=fork();

if(pid < 0)
{
        perror("couldn't fork");
        exit(1);
}
else if(pid == 0) // in child
{
        dup2(pipefd[0], 0); // Overwrite STDIN with read end of pipe
        // Close writing end of pipe!  ESSENTIAL!
        close(pipefd[1]);
        execlp("/bin/cat", NULL); // exec REPLACES the current process
        perror("Couldn't exec"); exit(1);
}

// If we reach here, we must be the parent
const char *str="the owls are not what they seem\n";
int status;
dup2(pipefd[1], 1); // overwrite STDOUT with write end of pipe
close(pipefd[0]); // close the read-end!  ESSENTIAL!
write(1, str, strlen(str));  // send data to cat
close(1); // close FD so the child will get EOF.  Also essential!  wait() would wait forever otherwise.
wait(&status);
fprintf(stderr, "Returned status %d\n", WEXITSTATUS(status));

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main(void)
{
        const char *cmd[]={"ls", "tac", "less", NULL};
        int curpipe[2]={-1, -1}, lastpipe=-1, n;
        pid_t pids[64];

        for(n=0; cmd[n] != NULL; n++)
        {
                // If this isn't the last in the chain,
                // make a pipe for cmd[n] to write into.
                if(cmd[n+1] != NULL) pipe(curpipe);

                switch(pids[n]=fork())
                {
                case -1:
                        perror("couldn't fork");
                        break;
                default:// parent code

                        // Our latest child has a copy of the writing
                        // end, we don't need it anymore.
                        if(curpipe[1] >= 0) close(curpipe[1]);

                        // ...but we'll need the reading end next time.
                        // and we should close the last loop's reading end.
                        if(lastpipe >= 0) close(lastpipe);
                        lastpipe=curpipe[0];

                        // don't use those FD's again.
                        curpipe[1]=-1;  curpipe[0]=-1;
                        break;

                case 0: // child code

                        // If we have a reading end, use it.
                        if(lastpipe >= 0)
                        {
                                dup2(lastpipe, 0);
                                close(lastpipe);
                        }

                        // if we have a writing end, use it.
                        if(curpipe[1] >= 0)
                        {
                                // make a copy.
                                dup2(curpipe[1], 1);
                                // close both ends.
                                close(curpipe[1]);
                                close(curpipe[0]);
                        }

                        execlp(cmd[n], cmd[n], NULL);
                        perror("couldn't exec");
                        exit(1);
                        break;
                }
        }

        for(n=0; cmd[n] != NULL; n++)
        {
                int status;
                wait(&status);
        }
}