Provided by: manpages-fr-dev_3.57d1p1-1_all bug

NOM

       pipe, pipe2 - Créer un tube

SYNOPSIS

       #include <unistd.h>

       int pipe(int pipefd[2]);

       #define _GNU_SOURCE             /* Consultez feature_test_macros(7) */
       #include <fcntl.h>              /* Obtenir les définition de constante O_* */
       #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  renvoyer  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, consultez 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

       S'il réussit, cet appel système renvoie 0. S'il échoue, il renvoie -1 et remplit errno en conséquence.

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 (consultez 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.

   Source du programme
       #include <sys/types.h>
       #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, "Utilisation : %s <chaîne>\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.57 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

       Depuis 2010, cette traduction est maintenue à l'aide de l'outil po4a <http://po4a.alioth.debian.org/> par
       l'équipe de traduction francophone au sein du projet perkamon <http://perkamon.alioth.debian.org/>.

       Christophe      Blaess      <http://www.blaess.fr/christophe/>      (1996-2003),       Alain       Portal
       <http://manpagesfr.free.fr/>  (2003-2006).  Julien  Cristau  et  l'équipe  francophone  de  traduction de
       Debian (2006-2009).

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

Linux                                            5 janvier 2014                                          PIPE(2)