Riporto la versione che non mi funziona, che usa una pipe sola:
CODICE
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/wait.h>
#include <string.h>
#define READ 0
#define WRITE 1
// WAITPID: ASPETTA CHE UN PROCESSO SPECIFICO FINISCA
// POI GLI ALTRI SONO RACCOLTI WAIT
//*************************************************
// esempio di comunicazione padre figlio:
// il padre manda un array con pipe0
// il figlio la legge con pipe 0, lo elabora
// e la manda al padre con pipe1
// genn 2020
int main(int argc, char *argv[])
{
int pid,x,i;
int my_pipe_0[2];
int prova[4]={100,2,3,4};
int buff[4];
int status;
// creo le pipes
if (pipe(my_pipe_0)==-1)
{
puts("erroer");
return -1;
}
//********************************************
// filglio
//********************************************
pid = fork();
if ( pid == -1 )
{
printf ("Impossibile creare un nuovo processo\n");
exit(1);
}
if ( pid == 0 )
{
int i;
printf ("Sono il processo 0 figlio di %d, il mio PID è %d\n",getppid(), getpid());
puts("leggo quello che mi manda il padre");
close (my_pipe_0[WRITE]);// chiudo canale scrittura pipe0
read(my_pipe_0[READ], buff, 4*sizeof(int)); //leggo quello che il padre manda
close (my_pipe_0[READ]); // chiudo lettura pipe0
for (i=0; i<4; i++)
{
printf("child %d\n",buff[i]);
prova[i]=prova[i]*100;
}
close (my_pipe_0[READ]);// chiudo canale lettura pipe0
write(my_pipe_0[WRITE], prova, 4*sizeof(int)); // scrivo con pipe0 al padre
close (my_pipe_0[WRITE]); // chiudo canale scrittura pipe0
puts("fine figlio");
exit(0);
}
//************************************************************
// MAIN
//************************************************************
if ( pid> 0 )
{
puts("sono nel main");
close (my_pipe_0[READ]); //chiudo canale lettura pipe0
write(my_pipe_0[WRITE], prova, 4*sizeof(int));//scrivo al figlio con pipe0
close (my_pipe_0[WRITE]);// chiudo canale scrittura pipe0
//-------------------------------------------------------
close (my_pipe_0[WRITE]); //chiudo canale scrittura pipe0
read(my_pipe_0[READ], buff, 4*sizeof(int));//leggo cio che manda il figlio
close (my_pipe_0[READ]);// chiudo canale lettura pipe0
x=wait(&status);
for (i=0 ;i<4 ;i++)
printf("dati elaborati mandati dal figlio: %d\n",buff[i]);
printf ("Il processo %d è terminato con status %d\n", x,status);
}
return 0;
}
e i 2 output:
CODICE
gila@gila-pc:~/Scrivania$ ./xx
sono nel main
Sono il processo 0 figlio di 3197, il mio PID è 3198
leggo quello che mi manda il padre
child 100
child 2
child 3
child 4
fine figlio
dati elaborati mandati dal figlio: 10000
dati elaborati mandati dal figlio: 200
dati elaborati mandati dal figlio: 300
dati elaborati mandati dal figlio: 400
Il processo 3198 è terminato con status 0
/**********************************************************************
sono nel main
Sono il processo 0 figlio di 3280, il mio PID è 3281
leggo quello che mi manda il padre
child 100
child 2
child 3
child 4
fine figlio
dati elaborati mandati dal figlio: 0
dati elaborati mandati dal figlio: 0
dati elaborati mandati dal figlio: 0
dati elaborati mandati dal figlio: 0
Il processo 3281 è terminato con status 0
gila@gila-pc:~/Scrivania$
il secondo output come si nota, perde i valori.
Comunque leggendo qui:
CITAZIONE
Nei sistemi operativi una pipe è uno degli strumenti disponibili per far comunicare tra loro dei processi. Le pipe, diversamente dai socket, offrono un canale di comunicazione monodirezionale, e quindi occorre impiegarne due per ottenere una comunicazione bidirezionale.
tratto da wikipedia, sembrerebbe proprio che ce ne vogliano 2.
Riguardo al discorso di aprire e chiudere i canali, anche li dovrebbe essere come dico...però...
Sto cercando di simulare una broken pipe, cioè un errore che dovrebbero dare canali aperti simultaneamente, ma non
mi riesce. Non so, forse bisogna tirare in ballo pure i segnali.
Insomma, è un argomento molto vasto.
A dire il vero (eterna domanda), mi domando se tutto ciò ha senso per un livello hobbistico...bho!!!
