Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Implementazione pipeline
Forum - C/C++ - Implementazione pipeline

Avatar
MagoAntò (Normal User)
Rookie


Messaggi: 42
Iscritto: 07/02/2009

Segnala al moderatore
Postato alle 17:24
Giovedì, 13/12/2012
Ciao a tutti!

Sto cercando di svolgere il seguente esercizio: "Scrivere un programma C e Posix sotto Linux che implementi la seguente pipeline acquisita in input da riga di comando: $ ls -al /usr/include | grep a*.h | sort -r |wc -l"

Ecco il codice:

Codice sorgente - presumibilmente C++

  1. /* Scrivere un programma C e Posix sotto Linux che implementi la seguente pipeline acquisita in input da riga di comando:
  2.         $ ls -al /usr/include | grep a*.h | sort -r |wc -l */
  3.  
  4. #include <stdio.h>
  5. #include <unistd.h>
  6. #include <stdlib.h>
  7. #include <errno.h>
  8.  
  9. int main (int argc, char *argv[])
  10. {
  11.         pid_t pid2, pid3, pid4;
  12.        
  13.         int i;
  14.         int TUBO1[2]; // tra p1 e p2
  15.         int TUBO2[2]; // tra p2 e p3
  16.         int TUBO3[2]; // tra p3 e p4
  17.        
  18.         printf ("Stampo gli argomenti\n");
  19.        
  20.         for (i=1; i<argc; i++)
  21.         {
  22.                 printf ("%d) %s\n", i, argv[i]);
  23.         }
  24.         printf ("\n");
  25.        
  26.         // apro la pipe 1
  27.         if (pipe (TUBO1)<0)
  28.         {
  29.                 printf ("Errore nella pipe!\n");
  30.                 exit(1);
  31.         }
  32.        
  33.         // apro la pipe 2
  34.         if (pipe (TUBO2)<0)
  35.         {
  36.                 printf ("Errore nella pipe!\n");
  37.                 exit(2);
  38.         }
  39.        
  40.         // apro la pipe 3
  41.         if (pipe (TUBO3)<0)
  42.         {
  43.                 printf ("Errore nella pipe!\n");
  44.                 exit(3);
  45.         }
  46.        
  47.         switch (fork()) {
  48.                 case -1: // errore nella fork
  49.                         printf ("Errore nella fork!");
  50.                         exit(4);
  51.                
  52.                 case 0:
  53.                         /* Il primo processo figlio deve leggere dalla prima pipe e scrivere nella seconda, quindi chiude la terza in lettura/scrittura,
  54.                         la prima in scrittura e la seconda in lettura */
  55.                         printf("// SONO NEL PRIMO FIGLIO\n");
  56.                        
  57.                         close (TUBO3[0]);
  58.                         close (TUBO3[1]);
  59.                        
  60.                         close (TUBO1[1]);
  61.                         close (TUBO2[0]);
  62.                        
  63.                        
  64.                         close(0);
  65.                         dup2(TUBO1[0],0); // duplico il canale in lettura della prima pipe sullo standard input
  66.                        
  67.                         close(1);
  68.                         dup2(TUBO2[1],1); // duplico il canale in scrittura della seconda pipe sullo standard output
  69.                        
  70.                         // grep a*.h
  71.                         execlp(argv[4],argv[4],argv[5],NULL);
  72.                         printf ("ERRORE NELLA EXEC!\n");
  73.                        
  74.                 default:
  75.                        
  76.                         switch (fork()){
  77.                                 case -1: // errore nella fork
  78.                                         printf ("Errore nella fork!");
  79.                                         exit(5);
  80.                                
  81.                                 case 0:
  82.                                         /* Il secondo processo deve leggere dalla seconda pipe e scrivere sulla terza, quindi chiude la prima pipe in lettura
  83.                                         /scrittura, la seconda in scrittura, la terza in lettura */
  84.                                        
  85.                                         printf("// SONO NEL SECONDO FIGLIO\n");
  86.                                         close(TUBO1[0]);
  87.                                         close(TUBO1[1]);
  88.                                        
  89.                                         close(TUBO2[1]);
  90.                                         close(TUBO3[0]);
  91.                                        
  92.                                         close(0);
  93.                                         dup2(TUBO2[0],0); // duplico il canale in lettura della seconda pipe sullo standard input
  94.                                        
  95.                                         close(1);
  96.                                         dup2(TUBO3[1],1); // duplico il canale in scrittura della terza pipe sullo standard output
  97.                                        
  98.                                         // sort -r
  99.                                         execlp(argv[6],argv[6],argv[7],NULL);
  100.                                         printf ("ERRORE NELLA EXEC!\n");
  101.                                        
  102.                                 default:
  103.                                         switch (fork ()){
  104.                                                
  105.                                                 case -1: // errore nella fork
  106.                                                         printf ("Errore nella fork!\n");
  107.                                                         exit(6);
  108.                                                        
  109.                                                 case 0:
  110.                                                         /* Il terzo figlio deve leggere dalla terza pipe, quindi chiudiamo la prima e la seconda in lettura/
  111.                                                         scrittura, la terza in scrittura */
  112.                                                         printf("// SONO NEL TERZO FIGLIO\n");
  113.                                                         close(TUBO1[0]);
  114.                                                         close(TUBO1[1]);
  115.                                                        
  116.                                                         close (TUBO2[0]);
  117.                                                         close (TUBO2[1]);
  118.                                                        
  119.                                                         close(TUBO3[1]);
  120.                                                        
  121.                                                         close(0);
  122.                                                         dup2(TUBO3[0],0); // duplico il canale in lettura della terza pipe sullo standard input
  123.                                                        
  124.                                                         execlp(argv[8],argv[8],argv[9],NULL);
  125.                                                         printf ("Errore nella execlp!\n");
  126.                                                        
  127.                                                 default:
  128.                                                         /* Il processo padre deve soltanto scrivere sulla prima pipe, quindi chiudiamo la seconda e la terza
  129.                                                         in lettura/scrittura, la prima in lettura */
  130.                                                        
  131.                                                         printf ("// SONO NEL PADRE");
  132.                                                         close (TUBO2[0]);
  133.                                                         close (TUBO2[1]);
  134.                                                        
  135.                                                         close (TUBO3[0]);
  136.                                                         close (TUBO3[1]);
  137.                        
  138.                                                         close (TUBO1[0]);
  139.                        
  140.                                                         close(1);
  141.                                                         dup2 (TUBO1[1], 1); // duplico il canale di scrittura della prima pipe sullo standard output
  142.                                        
  143.                                                         // ls -al /usr/include
  144.                                                         execlp (argv[1], argv[1], argv[2], argv[3], NULL);
  145.                                                         printf ("ERRORE NELLA EXEC!\n");       
  146.                                         }
  147.                                        
  148.                                
  149.                         }
  150.                        
  151.         }
  152.         exit(0);
  153. }



Come output mi restituisce:

Stampo gli argomenti
1) ls
2) -al
3) /usr/include
4) grep
5) a*.h
6) sort
7) -r
8) wc
9) -l

// SONO NEL PRIMO FIGLIO
// SONO NEL SECONDO FIGLIO
// SONO NEL TERZO FIGLIO
~/Desktop/esercizi$ 113

:-| :-| :-|

Forse sbaglio, ma non dovrebbe visualizzarmi l'elenco di file presenti nella cartella /usr/include, i cui nomi inizino per a e finiscano per .h, ordinati in maniera decrescente e, visualizzare il numero di andate a capo?

Grazie in anticipo per gli aiuti!

Ultima modifica effettuata da MagoAntò il 13/12/2012 alle 17:24
PM Quote