Discussion :

[shirohige]

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.

[ternel]

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.

[Obsidian]

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.

[imperio]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

ls | wc -l | less

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

[shirohige]

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.

[Obsidian]

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.