[C] Comunicazione tramite PIPE

[kinghomer]

Ho provato a sviluppare questa applicazione tramite PIPE per esercitarmi:
Si vuole stampare a video una stringa di testo.
Prima della stampa, si intende censurarne il contenuto evitando di stampare un determinato carattere. Il comando deve far uso di 3 processi:
un processo padre (pubblicatore) e due processifigli (revisore e censore).
Il funzionamento del comando deve essere il seguente:
-Il pubblicatore crea i due figli, revisore e censore;
-Il revisore, una volta creato, comunica la stringa al censore;
-Il censore controlla la stringa ricevuta, eliminando il carattere prescelto, e la invia al pubblicatore;

Il pubblicatore, stampa su video la stringa censurata ricevuta.
La comunicazione tra processi avviene tramite PIPE senza nome.

#include  <fcntl.h>
#include  <stdio.h>
#include  <stdlib.h>
#include  <string.h>
#include  <unistd.h>


int main(int argc, char *argv[]) {
   int pubblicatore[2],censore[2],revisore[2];
   int pid,ret,i,j,status;
   char buffer[10];    // buffer di scambio della stringa
   char temp[10];      // buffer temporaneo in cui si salva la stringa senza il carattere 'A'
   char c='a';        // carattere da eliminare dalla stringa
   char frase[] = "abcdef";   // stringa di partenza

   if((ret= pipe(pubblicatore))==-1) printf("Errore nella creazione della Pipe");
   
   pid=fork();

   // Nel Padre 

   if(pid>0){
      censore[0] = pubblicatore[0];
      censore[1] = pubblicatore[1];
      if((ret= pipe(pubblicatore))==-1) printf("Errore nella creazione della Pipe");
      pid=fork();
      if(pid>0){
         revisore[0]=pubblicatore[0];
         revisore[1]=pubblicatore[1];
      }else{
         //sono nel processo figlio REVISORE
         
         printf("Nel Revisore: %s\n",frase);
         // invio la stringa frase al figlio censore
         write(censore[1],&frase,sizeof(frase));
         close(censore[1]);
      }
   }else{
        // sono nel processo figlio CENSORE
      
        read(revisore[0],&buffer,sizeof(buffer));
        printf("Nel CENSORE: %s\n",buffer);
        // elimino il carattere 'A' da FRASE contenuto in BUFFER e salvo la nuova stringa in TEMP
        for(i,j=0; i<strlen(buffer);i++){
         if(buffer[i]!= 'a'){ 
            temp[j]=buffer[i];
            j++;
         }
      }
      printf("Nel CENSORE (stringa temp): %s\n",temp);
      // invio la nuova stringa censurata al padre
      write(pubblicatore[1],&temp,sizeof(temp));
      close(pubblicatore[1]);
      close(revisore[0]);
   }
   if(pid>0){
   wait(&status);
   wait(&status);
   read(censore[0],&buffer,sizeof(buffer));
   printf("Stringa Censurata: %s\n",&buffer);
   close(censore[0]);
   }
}

Non capisco il perchè, ma la stringa non si riesce a comunicare tra i processi!
Ho provato facendo debug tramite la classica printf();

[LeleFT]

Come evidenziato dal regolamento

Sono da evitare titoli generici come, ad esempio, "problema", "aiuto", "help", "errore" oppure epiteti come "urgente", "difficile", "solo per esperti" e così via.

A volte basta leggerlo il regolamento...


Ciao.

[kinghomer]

Originariamente inviato da LeleFT
Come evidenziato dal regolamento


A volte basta leggerlo il regolamento...


Ciao.

Scusa e grazie !!!
Qualche idea ????

[MacApp]

La pipe deve essere creata una sola volta dal padre.
Ho scritto velocemente (e testato) il seguente autoesplicativo.
Osserva che (per semplicità) controllo gli errori con assert.

EDIT: per completarlo,

• gli errori runtime non dovrebbere essere controllati con assert ma in altra maniera;
• dovresti catturare come mininmo la signal SIGPIPE;
• gestire l'eventuale bufferizzazione sia in scrittura che in lettura.

/*
* Written and tested by MacApp, 18 march 2008
*
* Compiler:
* i686-apple-darwin8-gcc-4.0.1 (GCC) 4.0.1 (Apple Computer, Inc. build 5367)
*
* Command line:
* $ gcc -Wall -pedantic -ansi main.c
*
* Output (as expected):
* The revisor sent to me: "Hi from REVISOR";
*
*/
#include <stdio.h>
#include <unistd.h>
#include <assert.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>

int main (){
    int aPipe [2];

    const int aPipeResult = pipe (aPipe);
    assert (0 == aPipeResult);
    {
        const pid_t aForkResult = fork ();
        assert (-1 != aForkResult);
        assert (0 <= aForkResult);
        if (aForkResult > 0){
            const char * aBufferToSend = "Hi from REVISOR";
            const size_t aNumBytesToWrite = strlen (aBufferToSend)*sizeof (char);
            const ssize_t aWriteResult = write (aPipe [1], aBufferToSend, aNumBytesToWrite);
            assert (aWriteResult == aNumBytesToWrite);
            {
                const int aCloseResult = close (aPipe [1]);
                assert (0 == aCloseResult);
            }
        }
        else{
            char aReadSentence [1024];
            const size_t kNumBytesRead = read (aPipe [0], aReadSentence, (sizeof (aReadSentence) - 1) *sizeof (char));
            assert (-1 != kNumBytesRead);
            (void) printf ("The revisor sent to me: \"%s\";\n", aReadSentence);
            {
                const int aCloseResult = close (aPipe [0]);
                assert (0 == aCloseResult);
            }
        }
    }
    return 0;
}