Perplessità processi (c,java,python, generico)

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

      int
      main(int argc, char *argv[])
      {
          int pipefd[2];
          pid_t cpid;
          char buf;

          if (argc != 2) {
              fprintf(stderr, "Usage: %s <string>\n", argv[0]);
              exit(EXIT_FAILURE);
          }

          if (pipe(pipefd) == -1) {
              perror("pipe");
              exit(EXIT_FAILURE);
          }

          cpid = fork();
          if (cpid == -1) {
              perror("fork");
              exit(EXIT_FAILURE);
          }

          if (cpid == 0) {    /* Child reads from pipe */
              close(pipefd[1]);          /* Close unused write end */

              while (read(pipefd[0], &buf, 1) > 0)
                  write(STDOUT_FILENO, &buf, 1);

              write(STDOUT_FILENO, "\n", 1);
              close(pipefd[0]);
              _exit(EXIT_SUCCESS);

          } else {            /* Parent writes argv[1] to pipe */
              close(pipefd[0]);          /* Close unused read end */
              write(pipefd[1], argv[1], strlen(argv[1]));
              close(pipefd[1]);          /* Reader will see EOF */
              wait(NULL);                /* Wait for child */
              exit(EXIT_SUCCESS);
          }
      }

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

#define READ 0
#define WRITE 1

/* prova di 2 figli che comunicano col padre usando la stessa pipe
i figli leggono da input e scrivono al padre.
al padre quando arriva una determinata stringa uccide i processi
gila75 genn 2020

*/

void prova_pipe_w0(int pipe_out);
void prova_pipe_w1(int pipe_out);
void prova_pipe_r(int pipe_in);
void input_str (char str[]);



void input_str (char str[])
{
       int len_str;
       len_str=strlen(str);
       str[len_str-1]='\0';
}



void prova_pipe_w0(int pipe_out) //pipe0 figlio0(scrive)
{
       char buff[100];
       while(1)
       {
               fgets(buff,100,stdin);
               input_str(buff);
               printf ("in f0 %s\n",buff);
               write(pipe_out, buff, strlen(buff)+1); // scrivo  al padre
               
       }
}
//************************************************

void prova_pipe_w1(int pipe_out) //pipe0 figlio1(scrive)
{
       char buff[100];
       while(1)
       {
               fgets(buff,100,stdin);
               input_str(buff);
               printf ("in f1 %s\n",buff);
               write(pipe_out, buff, strlen(buff)+1); // scrivo  al padre
       }
}

void prova_pipe_r(int pipe_in) // pipe padre(legge)
{
       char buff [1024];
       int x;
       while(1)
       {
               read(pipe_in, buff, 1024); // leggo dai figli
               printf("padre riceve <%s>\n", buff);
               x=strcmp(buff,"fine");
               if (x==0)
                       break;
       }
       return ;
}
       

int main(int argc, char *argv[])
{
       int pid[2];
       int my_pipe[2];
       int x,status;
       // creo la pipe
       if (pipe(my_pipe)==-1)
       {
               puts("errore");
               return -1;
       }

       
       
//********************************************
//                        figlio 0
//********************************************
       
       pid[0] = fork();
       if ( pid[0] == -1 )
       {
               printf ("Impossibile creare un nuovo processo\n");
               exit(1);
       }

       if ( pid[0] == 0 )
       {
               close (my_pipe[READ]);
               prova_pipe_w0(my_pipe[WRITE]); //passo descrittore pipe scrittura
       }    

//********************************************
//                        figlio 1
//********************************************
       pid[1] = fork();
       if ( pid[1] == -1 )
       {
               printf ("Impossibile creare un nuovo processo\n");
               exit(1);
       }

       if ( pid[1] == 0 )
       {
               close (my_pipe[READ]);
               prova_pipe_w1(my_pipe[WRITE]); //passo descrittore pipe scrittura
       }    


       else // entro nel padre (main)
       {
               close(my_pipe[WRITE]); // chiudo scrittura
               prova_pipe_r(my_pipe[READ]); //apro lettura
       }

       kill(pid[0],1);
       x=wait(&status);
       printf (" processo %d finito con segnale %d\n",x,status);
       kill(pid[1],1);        
       x=wait(&status);
       printf (" processo %d finito con segnale %d\n",x,status);
       puts("fine");
       return 0;

}