home *** CD-ROM | disk | FTP | other *** search
/ ftp.disi.unige.it / 2015-02-11.ftp.disi.unige.it.tar / ftp.disi.unige.it / pub / .person / GianuzziV / SO1 / Eexec.c < prev    next >
C/C++ Source or Header  |  2001-11-07  |  3KB  |  95 lines
  1. /* Eexec.c
  2.    Processo che genera un figlio, 
  3.    invia al figlio dei caratteri letti da tastiera 
  4.    (terminati con EOF, cioe' ^D) e
  5.    riceve gli stessi caratteri dal figlio.
  6.    Il figlio redireziona gli standard input e output 
  7.    sulle pipe di collegamento con il genitore, poi exegue
  8.    il porgramma dato come argomento. 
  9.    Un esempio di programma e' il succesivo "prova.c", che 
  10.    legge dei caratteri dall standard input e li scrive sullo 
  11.    standard output, finche' trova il carattere '$' */
  12.  
  13. #include <stdio.h>
  14. #include <signal.h>
  15.  
  16. void main(int argc, char ** argv, char ** envp)
  17. {
  18.         int pid;
  19.         int pipeP[2]; /* Parent to Child */
  20.         int pipeC[2]; /* Child to Parent */
  21.         char ch;
  22.         int incount = 0, outcount = 0;
  23.  
  24.         /* costruisce le pipe */
  25.         if( pipe(pipeP) < 0)
  26.         {
  27.                 perror("pipeP non aperta");
  28.                 exit(1);
  29.         }
  30.         if( pipe(pipeC) < 0)
  31.         {
  32.                 perror("pipeC non aperta");
  33.                 exit(1);
  34.         }
  35.  
  36.         /* genera un processo */
  37.         switch( pid = fork() )
  38.         {
  39.                 case -1:
  40.                                 perror("fork Error: ");
  41.                                 exit(1);
  42.                 case 0:
  43.                                 /* figlio */
  44.                                 close(1); /* chiude stdout corrente */
  45.                                 dup( pipeC[1]); /* stdout --> pipeC. */
  46.                                 close(0); /* chiude stdin corrente */
  47.                                 dup( pipeP[0]); /* stdin <-- pipeP */
  48.                                 close( pipeP[1]);
  49.                                 close( pipeC[0]);
  50.                                 execvp(argv[1], argv + 1, envp);
  51.                                 perror("exec Error:");
  52.                                 signal(getppid(), SIGQUIT);
  53.                                 exit(1);
  54.                 default:
  55.                                 /* genitore */
  56.                                 printf("Input per il figlio:\n");
  57.                                 while(  read(0, &ch, 1) > 0 )
  58.                                 {
  59.                                         write(pipeP[1],&ch, 1);
  60.                                         incount ++;
  61.                                 }
  62.                                 ch=0330;
  63.                                 write(pipeP[1],&ch, 1);
  64.                                 close(pipeP[1]);
  65.                                 printf("\nRicevuto dal figlio:\n");
  66.                                 close(pipeC[1]);
  67.                                 while( read(pipeC[0], &ch, 1) == 1)
  68.                                 {
  69.                                         write(1, &ch, 1);
  70.                                         outcount++;
  71.                                 }
  72.                                 printf("\n\nNumero caratteri ricevuti: %d\n",incount);
  73.                                 printf("Numero caratteri inviati: %d\n", outcount);
  74.                                 return;
  75.         }
  76. }
  77.  
  78. /* prova.c */
  79. #include <stdio.h>
  80.  
  81. void main(int argc, char ** argv, char ** envp)
  82. {
  83.     char ch;
  84.     int i;
  85.  
  86.     do
  87.     {
  88.       scanf("%c", &ch);
  89.       printf("%c", ch); 
  90.     }
  91.     while (ch!='$'); 
  92.     printf("\n");
  93. }
  94.  
  95.