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.

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.

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.

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 :

Code:

---

ls | wc -l | less

---

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

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:

---

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.

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.

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.

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.

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 ?

— « 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.

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.

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).

Citation:

---

Envoyé par shirohige

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 :

Code:

---

$ mkfifo montube

---

Puis :

Code:

---

$ 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 :

Code:

---

$ cat montube

---

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.

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:

---

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:

---

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à.

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.

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.