IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

Rediriger une commande Unix grâce aux pipes.


Sujet :

C

  1. #1
    Membre confirmé
    Homme Profil pro
    Étudiant
    Inscrit en
    Novembre 2012
    Messages
    118
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Novembre 2012
    Messages : 118
    Par défaut Rediriger une commande Unix grâce aux pipes.
    Je souhaiterais réaliser les pipes sous Unix. Par exemple, faire ls | grep lol.txt. Mais je ne vois pas comment faire. Je vois à peu près comment utiliser pipe() avec des exemples simples.

    Mais pour des exemples plus compliqués comme ce que je veux faire je ne vois pas trop.

    Merci pour l'aide.

  2. #2
    Expert éminent

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 202
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 202
    Par défaut
    Bonjour
    make fifo peut être un début de piste
    Je ne suis pas expert du sujet, mais ca t'aidera déjà un peu.

    Une fifo est un pipe nommé, qu'un programme tente de lire, et attend pendant jusqu'a ce qu'un autre le remplisse.

  3. #3
    Modérateur
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    Septembre 2007
    Messages
    7 477
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2007
    Messages : 7 477
    Par défaut
    Bonjour,

    Dans un premier temps, tu peux utiliser popen() pour lancer facilement un programme et établir dans la foulée un tube entre lui et ton programme (c'est toi qui précise le sens de communication).

    Sinon, si tu veux reproduire le comportement du shell lorsque tu pipes plusieurs commandes comme dans ton exemple, il faut d'abord créer des paires de tubes avec pipe(), puis forker avec fork(), faire en sorte que le père et fils referment respectivement leur descripteur en lecture et en écriture (tout ce que tu as dû faire dans les tutoriaux que tu as lus).

    Ensuite, il faut utiliser dup2() pour dupliquer le descripteur de ton tube vers le numéro 0 ou 1 en particulier, correspondant à l'entrée ou à la sortie standard. Comme il s'agit d'une duplication, il faut également refermer le descripteur original.

    À ce moment, tu obtiens deux processus dont le tube est mappé sur les descripteurs des entrées et sortie standard. Il te suffit alors d'appeler execl() ou une de ses variante dans chaque processus pour lancer chaque programme de ta chaîne. Ils hériteront automatiquement des descripteurs que tu as ouverts avant eux et leur entrées et sorties standard seront automatiquement connectés sans qu'ils aient à faire quoi que ce soit.

  4. #4
    Membre Expert
    Avatar de imperio
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2010
    Messages
    871
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ain (Rhône Alpes)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mai 2010
    Messages : 871
    Par défaut
    J'ai deja du code un fonctionnement similaire et je m'y etais pris comme ca en gros :

    - pipe
    - fork
    - dup2
    - execvp

    En gros c'est ce qu'on dit leternel et Obsidian avant moi. La ou ca deviendra plus interessant sera quand tu enchaineras des pipes infinis (theoriquement). Une commande comme ca par exemple :

    Ou encore des choses autrement plus compliquees ! Enfin bref, vaste domaine.

  5. #5
    Membre confirmé
    Homme Profil pro
    Étudiant
    Inscrit en
    Novembre 2012
    Messages
    118
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Novembre 2012
    Messages : 118
    Par défaut
    Merci pour vos réponse mais je suis un peut perdu.
    Mon prof a fait ce code mais il y a des éléments qui me perturbent:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
     
    #include <unistd.h>
    #include <unistd.h>
     
    int             main()
    {
      int           pipefd[2];
      int           pid;
      char          buff[512];
      int           len;
     
      pipe(pipefd);
      pid = fork();
      if (pid == 0)
        {
          close(pipefd[0]);
          write(pipefd[1], "bonjour!", 8);
        }
      else
        {
          close(pipefd[1]);
          len = read(pipefd[0], buff, 511);
          buff[len] = 0;
          write(1, buff, len);
        }
      return (0);
    }
    L'élément qui me trouble c'est que lorsque l'on exécute ls je ne peut pas dire ok tu me l'affiche sur tel ou tel fd. Par exemple dans la commande ls | grep toto il faut envoyé la liste renvoyé par ls à grep qui va faire un filtrage. Mais comment mettre sur le fd[1] de grep se que ls va me renvoyer.

  6. #6
    Modérateur
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    Septembre 2007
    Messages
    7 477
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2007
    Messages : 7 477
    Par défaut
    Relis mon commentaire № 3. Les réponses à tes questions ainsi que les fonctions à utiliser se trouvent dedans.

    Quand tu lances un programme quelconque et que tu fais « printf() » ou « scanf() » dessus sans préciser de flux ou de fichier particulier, ces fonctions lisent et écrivent implicitement dans « l'entrée standard » et la « sortie standard ». Ces flux sont notés « stdin », « stdout » et « stderr » dans la norme C et UNIX en particulier les associe toujours aux descripteurs 0, 1 et 2 (même s'il définit aussi STDIN_FILENO, STDOUT_FILENO et STDERR_FILENO). Ce sont donc les fameux numéros de fd que tu cherches.

    Ce qu'il faut faire, donc, c'est créer un tube, forker, faire en sorte que chaque processus remappe le fd de son tube vers 0 ou 1 respectivement, puis fasse ses traitements normalement, voire fasse un « exec » pour lancer les applications à piper. Celles-ci vont hériter automatiquement des descripteurs que tu auras modifiés et écriront donc automatiquement dans le tube sans avoir à se soucier de quoi que ce soit.

    Présenté autrement : tu reconstruis d'abord tes propres entrées et sortie standard, puis tu lances tes applis normalement.

  7. #7
    Membre confirmé
    Homme Profil pro
    Étudiant
    Inscrit en
    Novembre 2012
    Messages
    118
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Novembre 2012
    Messages : 118
    Par défaut
    Que signifie "remappe" ? Je ne vois pas comment dire à telle commande de stocker les infos dans tel ou tel tube.
    Lors de cette ligne: execl("/bin/ls", "ls", "-l", NULL); je ne peut pas stocker se ki va en resortir dans un fd.

    Dans mon esprit se que je veut faire c'est exécuter cette commande execl("/bin/ls", "ls", "-l", NULL); dans le fils ensuite traiter les informations dans le père.

    Edit: C'est bon j'ai trouver ce documents qui explique bien: http://www.zeitoun.net/articles/comm...ar-tuyau/start

    Merci pour vos réponses.

  8. #8
    Modérateur
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    Septembre 2007
    Messages
    7 477
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2007
    Messages : 7 477
    Par défaut
    Tu reconnaîtras quand même que toutes les instructions qui sont dans la page que tu nous présentes sont dans le commentaire que je t'ai prié de relire.

    Ce qu'il te manque surtout, c'est le fonctionnement de « exec ».

    Lorsque tu appelles « exec » (plus précisément un de ses dérivés), tu ne lances pas un nouveau processus mais tu remplaces l'image du code du processus courant par celle du programme que tu veux lancer.

    C'est pour cela qu'il faut forker avant d'appeler « exec », mais cela signifie aussi que le nouveau programme, même si reprend au début, hérite du PID du processus qui l'a lancé et de tout ce qu'il a ouvert ! Et notamment tous ses fichiers sauf si ceux-ci ont été ouverts avec l'option O_CLOEXEC.

    C'est effectivement le meilleur moyen de transmettre automatiquement tout un héritage et mettre en place un environnement avant le démarrage de ton application. C'est pour cela qu'on te fait remplacer tes entrées et sortie standard par ton tube : pour appeler « exec » ensuite et que l'application à lancer en hérite automatiquement.

  9. #9
    Membre confirmé
    Homme Profil pro
    Étudiant
    Inscrit en
    Novembre 2012
    Messages
    118
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Novembre 2012
    Messages : 118
    Par défaut
    Oui c'était bien indiqué dans ton commentaire. C'était la partie avec dup2() que je ne comprenais pas. Je ne savais pas trop à quoi ça servait. Si on pouvait me donner une bonne explication sur ce que fait exactement cette fonction se serait cool. Car dans le lien donné plus haut il dit que cela sert à connecter les fd, je voudrais savoir si c'est exactement ça et sinon qu'est-ce que c'est au juste merci.

    Tu m'as un peu perdu lorsque tu dit:tu remplaces l'image du code du processus courant par celle du programme que tu veux lancer.

    J'ai rien compris désolé qu'entend tu par image du code ?

  10. #10
    Modérateur
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    Septembre 2007
    Messages
    7 477
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2007
    Messages : 7 477
    Par défaut
    — « dup() » sert à « dupliquer » un descripteur de fichier. Le premier descripteur disponible (celui dont le numéro est le plus petit) est alors utilisé pour référencer le même fichier ;

    — « dup2() » signifie en fait « dup to » et sert à la même chose, à ceci près que tu peux préciser le numéro que tu veux utiliser. Si le numéro de destination est déjà utilisé, le système fait un « close() » dessus au préalable (il est recommandé de le fermer soi-même pour pouvoir récupérer les éventuelles erreurs). Donc :

    • Tu fermes la sortie standard (« 1 ») dans le processus père et l'entrée standard (« 0 ») dans le processus fils, ou tu laisses dup2() le faire pour toi ;
    • Tu les remplaces par la sortie ou l'entrée de ton tube, en dupliquant le bon descripteur vers « 0 » ou « 1 » ;
    • Tu appelles de chaque côté (fils et père) pour lancer en même temps les deux commandes à piper. L'une comme l'autre liront ou écriront dans la sortie ou l'entrée standard sans se soucier de ce qu'elles sont. Mais comme tu les as remplacées par ton tube, tout se qui sera écrit d'un côté sera renvoyé vers l'autre.

  11. #11
    Membre confirmé
    Homme Profil pro
    Étudiant
    Inscrit en
    Novembre 2012
    Messages
    118
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Novembre 2012
    Messages : 118
    Par défaut
    Me revoila, j'ai trouvé un document parlant de tube nommé, pourriez vous me donnez une définition simple de ces tubes ou les différence entre les tubes simple et nommé. D'autre part dans ce document : http://mat.free.free.fr/downloads/c/tubes_nommes.pdf
    Il parle d'atomicité, je site: "L'écriture est atomique si le nombre de caractères à écrire est inférieur à PIPE_BUF, la taille
    du tube sur le système. (cf <limits.h>). "
    Je ne comprends pas ce qu'est "l'écriture atomique" pourriez vous m'éclairer.
    Dansce document 1er paragraphe il dit:
    "L’op´eration de lecture y est destructive !"
    Je voudrais savoir si lors de la lecture le tube est réellement détruit ou si je comprend mal la phrase.
    Merci.

  12. #12
    Expert éminent
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2005
    Messages
    27 395
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2005
    Messages : 27 395
    Par défaut
    Une action est dite atomique si elle ne peut pas être interrompue par une autre tâche (typiquement un autre thread ou un autre processus).
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

  13. #13
    Modérateur
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    Septembre 2007
    Messages
    7 477
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2007
    Messages : 7 477
    Par défaut
    Citation Envoyé par shirohige Voir le message
    Me revoila, j'ai trouvé un document parlant de tube nommé, pourriez vous me donnez une définition simple de ces tubes ou les différence entre les tubes simple et nommé.
    Un « tube » est formé de deux extrémités : une entrée et une sortie, ainsi que d'un buffer en mémoire géré par le système, typiquement de 4096 octets. Ils sont gérés par des descripteurs de fichiers ordinaires, à ceci près que les données que l'on écrit sur l'un sont directement renvoyées vers le second, sans passer par le disque ou un quelconque médium de stockage.

    Comme on ne peut pas créer une extrémité de tube seule et l'associer ensuite à une autre, on demande au système de nous créer un tube tout fait. C'est ce que fait l'appel « pipe() ». C'est pour cela que tu reçois directement deux descripteurs, que tu dois les transmettre à un autre processus par héritage, et que chaque partie doit donc fermer un de ses descripteurs puisqu'elles disposent des deux.

    Un tube « nommé », maintenant, est un tube qui porte un nom, plus précisément créé sur le système de fichiers. Quand tu fais « ls » sur ton disque, tu vois donc une entrée qui n'est pas un fichier. Cette entrée va donc servir de point de rendez-vous à deux processus qui peuvent donc s'y raccorder sans avoir besoin d'hériter des descripteurs, donc sans avoir besoin d'être père et fils ni d'apparaître au même moment.

    Essaie ceci :


    Puis :

    Code Shell : Sélectionner tout - Visualiser dans une fenêtre à part
    $ echo "Hello" > montube

    Tu remarques que cette commande reste en attente, sans rendre la main. Ouvre un second terminal, place-toi dans le même répertoire puis entre :


    Cette dernière commande te ressort ce que tu as entré avec « echo » et tu remarqueras que, sur le premier terminal, la commande s'est débloquée et s'est terminée normalement.

    Certains dæmons, à commencer par le spooler de l'imprimante, se mettaient à l'écoute des requêtes de l'utilisateur de cette façon et c'était effectivement la plus appropriée de le faire. Mais comme ça n'existait pas sur d'autres systèmes, les gens ont pris l'habitude d'utiliser systématiquement un port réseau même si la connexion ne doit pas sortir de la machine concernée et, depuis, tout le monde fait la même chose.

  14. #14
    Membre confirmé
    Homme Profil pro
    Étudiant
    Inscrit en
    Novembre 2012
    Messages
    118
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Novembre 2012
    Messages : 118
    Par défaut
    Désolé de revenir ànla charge mais j'ai des difficultés de compréhension sur dup et dup2.
    Premièrement dup2 sert à connecter le premier fd au second. Dans le dernier morceau de code sur ce lien: http://www.zeitoun.net/articles/comm...ar-tuyau/start
    Il fait:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    /* child */
           close(pfd[1]); /* close the unused write side */
           dup2(pfd[0], 0); /* connect the read side with stdin */
           close(pfd[0]); /* close the read side */
           /* execute the process (wc command) */
           execlp("wc", "wc", (char *) 0);
           printf("wc failed"); /* if execlp returns, it's an error */
           return 3;
    Donc dans un premier temps il ferme l'écriture normale, ensuite il connect pfd[0] à 0 donc il copie les infos de 0 dans pfd[0] et il me semble, selon le man, que cela ferme 0. Ok mais après il ferme pfd[0] donc du coup je suis perdu il écrit où ? sachant qu'au préalable il à fermé dans le pére 1:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    /* parent */
           close(pfd[0]); /* close the unused read side */
           dup2(pfd[1], 1); /* connect the write side with stdout */
           close(pfd[1]); /* close the write side */
           /* execute the process (ls command) */
           execlp("ls", "ls", (char *)0);
           printf("ls failed"); /* if execlp returns, it's an error */
           return 4;
    Sauf si lors du fork chaque processus a son propre stdin et out.
    Merci de méclairer sur ce point.
    Autre point la différence entre dup et dup2 j'ai l'impression que dans dup on est obligé de récupérer la valeur de retoure car dup duplique le fd passer en param mais au début je savait pas comment savoir où elle était passer lol merci de me comfirmé si c'est bien cela.

    J'aurais surement d'autre question merci de répondre à celle là.

  15. #15
    Expert éminent
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2005
    Messages
    27 395
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2005
    Messages : 27 395
    Par défaut
    Après le dup2(pfd[0], 0), les deux descripteurs peuvent être utilisés pour lire dans le tube. Le close(pfd[0]) ferme l'un de ses deux descripteurs, le tube est ainsi raccordé à l'entrée standard du fils seulement.

    Le père fait la même chose avec l'autre bout du tube et sa sortie standard. Ainsi, tout ce que le père écrit dans sa sortie standard, le fils le reçoit dans son entrée standard.

    PS: Oui, avec dup() tu as besoin de récupérer la valeur de retour.
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

  16. #16
    Membre confirmé
    Homme Profil pro
    Étudiant
    Inscrit en
    Novembre 2012
    Messages
    118
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Novembre 2012
    Messages : 118
    Par défaut
    Ok merci c'est claire à présent. En fait lorsqu'on fait dup2(f[0], 0); ca signifie que 0 auras les pripriétés de f[0]. Donc en gros on change les valeur de stdin et stdout.

Discussions similaires

  1. [perl] Pipe dans une commande UNIX
    Par floxi dans le forum Linux
    Réponses: 6
    Dernier message: 29/08/2007, 00h21
  2. Lancer une commande Unix
    Par dm_manu dans le forum MATLAB
    Réponses: 2
    Dernier message: 09/10/2006, 10h44
  3. Explication d'une commande unix
    Par claralavraie dans le forum Linux
    Réponses: 4
    Dernier message: 14/02/2006, 17h22
  4. Réponses: 22
    Dernier message: 09/12/2005, 21h27
  5. [débutant]lancement d'une commande Unix ou LInux depuis Java
    Par msiramy dans le forum API standards et tierces
    Réponses: 6
    Dernier message: 30/09/2005, 18h10

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo