[C - Linux] Uso delle pipe

[ka0s]

Sto provando a scrivere un programma che equivalga al comando di shell: "ls -l | wc". L'intento sarebbe quello di mettere in comunicazione il processo padre e figlio in modo che il primo esegua "ls -l" e il secondo "wc". Non capisco perchè non funziona...

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


 int main(void) {

    int filedes[2];
    int err;
    pid_t pid;

    err = pipe(&filedes[2]);

    if(err == -1) {
        printf("Errore pipe!\n");
        exit(1);
    }

    pid = fork();

    if(pid == -1) {
        printf("Errore fork!\n");
        exit(1);
    }

     if(pid == 0) {
        /* Figlio */
        close(filedes[1]);	/* chiude output sulla pipe */
        close(0);		/* chiude std input */
        dup(filedes[0]);	/* duplica input sulle pipe */
        close(filedes[0]);	/* chiude input che non serve */
        char *params[] = {"wc", NULL, NULL};
        execv("wc", params);
        printf("Errore execv - figlio\n"); /* errore nella exec */
     }
     else
     {
        /* Padre */
        close(filedes[0]);	/* chiude input sulla pipe */
        close(1);		/* chiude std output */
        dup(filedes[1]);	/* duplica output sulla pipe */
        close(filedes[1]);	/* chiude output che non serve */
        char *params[] = {"ls", "l", NULL};
        execv("ls", params);
        printf("Errore execv - padre\n"); /* errore nella exec */
     }

    return 0;
 }

[andbin]

Guarda ... non ho esaminato nel dettaglio il tuo codice ma l'esempio che avevo postato in <questa> discussione funziona.

[ka0s]

Originariamente inviato da andbin

Guarda ... non ho esaminato nel dettaglio il tuo codice ma l'esempio che avevo postato in <questa> discussione funziona.

In realtà l'avevo visto prima di postare quell'esempio però lì è un po' diverso da come dovrei fare io... ad esempio non usare nè la dup2 nè la execlp se possibile, ma solo dup, execv, execve, ecc. e soprattutto non creare due figli ma mettere in comunicazione il padre con il figlio e basta.

[andbin]

Originariamente inviato da ka0s

In realtà l'avevo visto prima di postare quell'esempio però lì è un po' diverso da come dovrei fare io... ad esempio non usare nè la dup2 nè la execlp se possibile, ma solo dup, execv, execve, ecc. e soprattutto non creare due figli ma mettere in comunicazione il padre con il figlio e basta.

Non vedo come si possa fare usando solo dup(). Questa funzione duplica il descrittore passato e ritorna un nuovo descrittore (che tra l'altro nel tuo codice ignori, quindi non serve comunque a nulla).

Ma la questione non è la duplicazione bensì il fatto che il descrittore della pipe in scrittura va assegnato allo standard output (così chi scrive sullo standard output scrive in realtà sulla pipe) e il descrittore della pipe in lettura va assegnato allo standard-input (così chi legge dallo standard input legge in realtà dalla pipe). Per questo serve dup2.

Per quanto riguarda la exec, beh usa quella che vuoi. Le varie execXX differiscono tra di loro solo per il modo in cui vengono passati gli argomenti e il modo in cui viene cercato l'eseguibile.

[andbin]

Volendo usare execv e volendo creare 1 solo figlio (ma usando sempre dup2), si può fare così:

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

int main (void)
{
    pid_t  pid;
    int    fd_pipe[2];
    int    r;
    char  *args1[] = { "who", NULL };
    char  *args2[] = { "wc", "-l", NULL };

    r = pipe (fd_pipe);

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

    pid = fork ();

    if (pid == -1)
    {
        perror ("fork");
        exit (1);
    }
    else if (pid == 0)    /* Figlio */
    {
        dup2 (fd_pipe[1], STDOUT_FILENO);
        close (fd_pipe[0]);
        close (fd_pipe[1]);

        if (execv ("/usr/bin/who", args1) == -1)
        {
            perror ("execv");
            exit (1);
        }
    }

    dup2 (fd_pipe[0], STDIN_FILENO);
    close (fd_pipe[0]);
    close (fd_pipe[1]);

    if (execv ("/usr/bin/wc", args2) == -1)
    {
        perror ("execv");
        exit (1);
    }

    return 0;
}

[ka0s]

Grazie per il secondo esempio
Nel frattempo credo di essere arrivato ad una mia soluzione, usando due fork (la prima divide tra il processo che poi gestirà la pipe e quello che sarebbe la "shell", la seconda appunto gestisce la pipe tra un nuovo processo padre e figlio).

Ti posto due sorgenti, il primo usa solo le dup, il secondo usa la dup2: io sapevo che in effetti la dup2 si poteva ottenere con la combinazione close+dup.
Infatti leggendo nel manuale dice:
int dup2(int oldfd, int newfd);
dup2() makes newfd be the copy of oldfd, closing newfd first if necessary.

sorgente1:

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


 int main(void) {

    int status;
    pid_t pid1, pid2;
    int filedes[2];

    /* fork 1 */
    pid1 = fork();

    if(pid1 == -1) {
        printf("Errore fork1\n");
        exit(1);
    }

    if(pid1 == 0) {
        /* processo che gestirà la pipe */
        pipe(filedes);

        /* fork 2 */
        pid2 = fork();

        if(pid2 == -1) {
            printf("Errore fork2\n");
            exit(1);
        }

        if(pid2 == 0) {
            /* child - esegue ls -l */
            close(filedes[0]);  /* chiudi input sulla pipe */
            close(1);           /* chiudi std output */
            dup(filedes[1]);    /* duplica (=assegna) std output alla pipe */
            close(filedes[1]);  /* chiudi output che non serve */
            char *params[] = {"/bin/ls", "-l", NULL};
            execv("/bin/ls", params);
            printf("Errore execv - figlio\n"); /* errore nella exec */
        }
        else
        {
            /* parent - esegue wc */
            close(filedes[1]);  /* chiudi output sulla pipe */
            close(0);           /* chiudi std input */
            dup(filedes[0]);    /* duplica (=assegna) std input alla pipe */
            close(filedes[0]);  /* chiudi input che non serve */
            char *params[] = {"/usr/bin/wc", NULL, NULL};
            execv("/usr/bin/wc", params);
            printf("Errore execv - padre\n"); /* errore nella exec */
        }
    }
    else
    {
        /* processo shell in attesa... */
        waitpid(-1, &status, 0);
    }

    return 0;
 }

sorgente2 (solo la parte modificata):

 if(pid2 == 0) {
            /* child - esegue ls -l */
            dup2(filedes[1], 1); /* duplica (=assegna) std output all'output della pipe */
                                 /* chiudendo prima lo std output */
            close(filedes[0]);   /* chiude output della pipe */
            close(filedes[1]);   /* chiude input della pipe */
            char *params[] = {"/bin/ls", "-l", NULL};
            execv("/bin/ls", params);
            printf("Errore execv - figlio\n");
        }
        else
        {
            /* parent - esegue wc */
            dup2(filedes[0], 0); /* duplica (=assegna) std input all'input della pipe */
                                 /* chiudendo prima lo std input */
            close(filedes[1]);   /* chiude input della pipe */
            close(filedes[0]);   /* chiude output della pipe */
            char *params[] = {"/usr/bin/wc", NULL, NULL};
            execv("/usr/bin/wc", params);
            printf("Errore execv - padre\n"); /* se la exec va storta avvisa dell'errore */
        }

Così funzionano entrambi... penso sia giusto, però non sono sicurissimo!

[andbin]

Sì, c'è una cosa che mi sono ricordato adesso. Con dup non puoi specificare esplicitamente su quale descrittore fare la copia (con dup2 sì invece). Ma se si legge bene la documentazione di dup(), si scopre che fa la copia sul descrittore con numero più basso che trova inutilizzato.

Quindi facendo ad esempio:
close(0);
dup(filedes[0]);

si ottiene che dup trova che il descrittore 0 è inutilizzato e quindi ci copia il descrittore della pipe.

[qwerty86]

Originariamente inviato da andbin

Sì, c'è una cosa che mi sono ricordato adesso. Con dup non puoi specificare esplicitamente su quale descrittore fare la copia (con dup2 sì invece). Ma se si legge bene la documentazione di dup(), si scopre che fa la copia sul descrittore con numero più basso che trova inutilizzato.

Quindi facendo ad esempio:
close(0);
dup(filedes[0]);

si ottiene che dup trova che il descrittore 0 è inutilizzato e quindi ci copia il descrittore della pipe.

Si confermo è cosi. Esame di Lso?( Laboratorio di Sistemi Operativi)