Provided by: manpages-fr-dev_3.23.1-1_all bug

NOM

       pipe, pipe2 - Créer un tube.

SYNOPSIS

       #include <unistd.h>

       int pipe(int pipefd[2]);

       #define _GNU_SOURCE
       #include <unistd.h>

       int pipe2(int pipefd[2], int flags);

DESCRIPTION

       pipe()  crée un tube, un canal unidirectionnel de données qui peut être
       utilisé pour la communication entre processus. Le  tableau  pipefd  est
       utilisé pour renvoyé deux descripteurs de fichier faisant référence aux
       extrémités du tube. pipefd[0] fait référence à l’extrémité  de  lecture
       du tube. pipefd[1] fait référence à l’extrémité d’écriture du tube. Les
       données écrites sur  l’extrémité  d’écriture  du  tube  sont  mises  en
       mémoire  tampon  par  le  noyau  jusqu’à  ce  qu’elles  soient lues sur
       l’extrémité de lecture du tube. Pour plus de détails, voir pipe(7).

       Si flags est nul, alors pipe2() est identique  à  pipe().  Les  valeurs
       suivantes  peuvent  être  incluses  à l’aide d’un OU binaire dans flags
       pour obtenir différents comportements :

       O_NONBLOCK  Placer l’attribut d’état de fichier O_NONBLOCK sur les deux
                   nouveaux  descripteurs  de  fichiers  ouverts. Utiliser cet
                   attribut économise des appels  supplémentaires  à  fcntl(2)
                   pour obtenir le même résultat.

       O_CLOEXEC   Placer  l’attribut  « close-on-exec »  (FD_CLOEXEC) sur les
                   deux  nouveaux  descripteurs  de  fichiers.  Consultez   la
                   description  de  cet  attribut  dans  open(2)  pour  savoir
                   pourquoi ça peut être utile.

VALEUR RENVOYÉE

       En cas de réussite, zéro est renvoyé, sinon -1  est  renvoyé  et  errno
       contient le code d’erreur.

ERREURS

       EFAULT pipefd est invalide.

       EINVAL (pipe2()) Valeur incorrecte dans flags.

       EMFILE Trop  de descripteurs de fichier sont utilisés par le processus.

       ENFILE La limite du nombre total de fichiers ouverts sur le  système  a
              été atteinte.

VERSIONS

       pipe2()  a  été  ajouté  à  Linux  dans la version 2.6.27 ; sa prise en
       charge par la glibc est disponible depuis la version 2.9.

CONFORMITÉ

       pipe() : POSIX.1-2001.

       pipe2() est spécifique à Linux.

EXEMPLE

       Le programme suivant crée un tube, puis invoque fork(2) pour  créer  un
       processus fils ; le fils hérite d’un jeu de descripteurs de fichier qui
       se rapportent au même tube. Après le fork(2),  chaque  processus  ferme
       les descripteurs dont il n’a pas besoin pour le tube (voir pipe(7)). Le
       père écrit alors  la  chaîne  contenue  dans  l’argument  de  ligne  de
       commande  du  programme  dans  le  tube, et le fils lit cette chaîne un
       octet à la fois dans le tube, et l’affiche sur la sortie standard.

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

       int
       main(int argc, char *argv[])
       {
           int pipefd[2];
           pid_t cpid;
           char buf;

           if (argc != 2) {
            fprintf(stderr, "Usage: %s <string>\n", argv[0]);
            exit(EXIT_FAILURE);
           }

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

           cpid = fork();
           if (cpid == -1) {
               perror("fork");
               exit(EXIT_FAILURE);
           }

           if (cpid == 0) {    /* Le fils lit dans le tube */
               close(pipefd[1]);          /* Fermeture du descripteur en écriture inutilisé */

               while (read(pipefd[0], &buf, 1) > 0)
                   write(STDOUT_FILENO, &buf, 1);

               write(STDOUT_FILENO, "\n", 1);
               close(pipefd[0]);
               _exit(EXIT_SUCCESS);

           } else {            /* Le père écrit argv[1] dans le tube */
               close(pipefd[0]);          /* Fermeture du descripteur en lecture inutilisé*/
               write(pipefd[1], argv[1], strlen(argv[1]));
               close(pipefd[1]);          /* Le lecteur verra EOF */
               wait(NULL);                /* Attente du fils */
               exit(EXIT_SUCCESS);
           }
       }

VOIR AUSSI

       fork(2), read(2), socketpair(2), write(2), popen(3), pipe(7)

COLOPHON

       Cette page fait partie de  la  publication  3.23  du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies      peuvent      être       trouvées       à       l’adresse
       http://www.kernel.org/doc/man-pages/.

TRADUCTION

       Cette  page  de  manuel  a  été  traduite et mise à jour par Christophe
       Blaess <http://www.blaess.fr/christophe/> entre 1996 et 2003, puis  par
       Alain  Portal  <aportal AT univ-montp2 DOT fr> jusqu’en 2006, et mise à
       disposition sur http://manpagesfr.free.fr/.

       Les mises à jour et corrections de la version présente dans Debian sont
       directement gérées par Julien Cristau <jcristau@debian.org> et l’équipe
       francophone de traduction de Debian.

       Veuillez  signaler  toute  erreur   de   traduction   en   écrivant   à
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous pouvez toujours avoir accès à la version anglaise de  ce  document
       en utilisant la commande « man -L C <section> <page_de_man> ».