N command pipe " Inter-process " - c

Question

I have successfully piped the output of one command by using one pipe .
I want to do this with N successive commands where each command represent a process .
This is my attempt at pipelining one command ,So to make a N sequence of command do i need n-1 pipes ? and how the father of all processes can collect the output and print it .
and thank you .
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>
int main(int argc ,char *argv[])
{
int i,pid;
int fd[2];//crea i descriptor
char phrase[30][30];//crea il buffer
pipe(fd); /* crea la pipe */
for(i=0;i<argc;i++)
{
if((pid=fork())==0)
{
strcpy(phrase[i], argv[i+1]);
printf("ho scritoo :'%s'\n",phrase);
close(fd[0]); /* chiude in lettura */
write(fd[1],phrase[i],strlen(phrase[i])+1); /* invia anche 0x00 */
close (fd[1]); // chiude in scrittura
// pid=0 -> figlio
usleep(50000*(1+i)); // Ritardo iniziale
printf("Figlio: %d\n",i+1); // Stampa messaggio del figlio
usleep(500000*(1+i)); // Ritardo finale
return(101+i); // Termina con codice di ritorno
} else {
printf("Ho generato il figlio %d con pid %d\n",i+1,pid);
char message[100]; //creare il buffer
memset(message,0,100);
int bytesread;
bytesread = read(fd[0],message,sizeof(message));
printf("ho letto dalla pipe %d bytes: '%s' \n",bytesread,message);
// close(fd[0]);
}
}
close(fd[0]); /* chiude in scrittura */
close(fd[1]); /* chiude in scrittura */
// Attende che dieci processi terminino
for(i=0;i<argc-1;i++)
{
int status;
wait(&status); // Attende termine di un figlio (uno qualunque)
printf("Terminato processo %d\n",WEXITSTATUS(status));
}
return 0;
}

Answer 1

Yes, you will have N-1 pipes for N processes. You could just have all the processes print to stdout. Since each child process will inherit the parent's stdout, they will all print to whatever the parent's stdout is set to. If you start the chain by redirecting stdout to a file, then they will all print to that file. The problem will synchronizing their writes so that they don't write in the middle of another's write.
If you want to pipe all child output back up to the original parent, you could have each child just write to its parent's pipe everything it reads from its own child's pipe. Each child passing it up the chain in this manner.