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

int main(){

int piped[2];//pipe descriptors
char buf[16 * 1024];
pid_t child;

if(pipe(piped)<0){
   fprintf(stderr,"pipe creation failed \n");
   exit(-1);
 }
 
 if((child = fork()) < 0){
 fprintf(stderr,"process creation failed \n");
 exit(-1);
 }
 
 else if(child == 0){
        close(piped[1]);//close the write end of child
         // You don't need to close stdin, dup2() does that.
         close(0);//close stdin
         if((dup2(piped[0],0)) < 0){//duplicate read end with stdin;
        fprintf(stderr,"duplication of pipe desc failed \n");
        exit(-1); // exit only takes positive values.
        }

        // Why are you reading from the pipe?  that's wc's job.
        int linesrd = read(piped[0],buf,sizeof(buf));
        
        printf("The noof bytes read are %d \n",linesrd);
       
        if(linesrd < 0)
        fprintf(stderr,"Read error \n");
       
        // how could strlen() possibly tell you the length of a string that
        // doesn't already have a null terminator??  Just use 'linesrd'.
        buf[strlen(buf)-1] = '\0';

       // Just give execlp buf directly, no need to make another pointer
       // to the exact same memory.
       char *buf1 = buf;

      // Feeding wc another commandline parameter tells it to
      // read from the file NAMED that.  It won't read from stdin.
      execlp("wc","wc","-l",buf1,NULL); 
        //exit(1);
        }
        
        else{        
        close(piped[0]);//close read end of pipe
        // you don't need to close stdout, dup2() does that.
        close(1);//close stdout
        if(dup2(piped[1],1) < 0){//duplicate write end with stdout
        fprintf(stderr," duplication error \n");
        exit(-1);
        }
        
        int w=execlp("ls","ls",NULL);
        // execlp does not create a new process.
        // execlp REPLACES your process.
        // Any code below it only runs when exec fails!
        
        close(piped[1]);
        
        if(w<0){
        fprintf(stderr,"Something went wrong \n");
        exit(-1);
        }
        
        wait(NULL);
        
        }
        
        return(0);
        }

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

int main(){
        int piped[2];//pipe descriptors
        pid_t child;

        if(pipe(piped)<0){
                fprintf(stderr,"pipe creation failed \n");
                exit(-1);
        }

        if((child = fork()) < 0){
                 fprintf(stderr,"process creation failed \n");
                exit(-1);
        }
        else if(child == 0){
                close(piped[1]);//close the write end of child
                if((dup2(piped[0],0)) < 0)
                {//duplicate read end with stdin;
                        fprintf(stderr,"duplication of pipe desc failed \n");
                        exit(-1);
                }
                // wc -l will read from fd 0 directly once execlp() replaces
                // this child with it.  This is because it keeps any open files.
                execlp("wc","wc","-l",NULL);
                exit(1); // Yes, you need this in case something goes wrong!
        }
        else{
                close(piped[0]);//close read end of pipe
                if(dup2(piped[1],1) < 0){//duplicate write end with stdout
                        fprintf(stderr," duplication error \n");
                        exit(-1);
                }

                // ls will feed its output directly into fd 1 once execlp() replaces our process with it.
                // This is because exec() keeps the same files open once it's replaced, including pipes, sockets, etc.
                int w=execlp("ls","ls",NULL);
                if(w < 0) perror("Coudln't execlp"); // perror tells you WHAT went wrong
                exit(1);
        }
}