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