BEZEICHNUNG

       pipe - erstellt eine Pipeline

ÜBERSICHT

       #include <unistd.h>

       int pipe(int pipefd[2]);

       #define _GNU_SOURCE           /* Siehe feature_test_macros(7) */
       #include <fcntl.h>    /* Definitionen der O_*-Konstanten abrufen */
       #include <unistd.h>

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

BESCHREIBUNG

       pipe() erzeugt eine Pipeline, einen unidirektionalen Datenkanal, der für die Kommunikation
       zwischen Prozessen verwendet  werden  kann.  Das  Feld  pipefd  wird  verwendet,  um  zwei
       Dateideskriptoren  für  die  Enden  der  Pipeline  zurückzugeben. pipefd[0] bezeichnet das
       Lese-Ende der Pipeline; pipefd[1] das  Schreib-Ende.  In  das  Schreib-Ende  der  Pipeline
       geschriebene  Daten  werden  durch  den  Kernel  gepuffert,  bis sie aus dem Lese-Ende der
       Pipeline gelesen werden (für weitere Details siehe pipe(7)).

       Falls flags 0 ist, dann ist pipe2() dasselbe wie  pipe().  Um  ein  anderes  Verhalten  zu
       bewirken, können die folgenden Werte in flags bitweise ODER-verknüpft werden:

       O_NONBLOCK  setzt  den  Dateistatus-Schalter  O_NONBLOCK  für  einen  der  beiden  offenen
                   Dateideskriptoren. Die Verwendung dieses Schalters spart  zusätzliche  Aufrufe
                   von fcntl(2), um das gleiche Ergebnis zu erreichen.

       O_CLOEXEC   Setzt  den Schalter »schließen bei Ausführung« (close-on-exec, FD_CLOEXEC) für
                   die beiden neuen Dateideskriptoren. Die Beschreibung  desselben  Schalters  in
                   open(2) begründet, warum das nützlich sein kann.

RÜCKGABEWERT

       Bei  Erfolg  wird  Null  zurückgegeben.  Bei  einem Fehler wird -1 zurückgegeben und errno
       entsprechend gesetzt.

FEHLER

       EFAULT pipefd ist ungültig.

       EINVAL (pipe2()) ungültiger Wert in flags

       EMFILE Der Prozess benutzt zu viele Dateideskriptoren.

       ENFILE Die Systembeschränkung für die Gesamtzahl offener Dateien wurde erreicht.

VERSIONEN

       pipe2() wurde zu Linux in der Version 2.6.27 hinzugefügt; Glibc unterstützt  die  Funktion
       seit Version 2.9.

KONFORM ZU

       pipe(): POSIX.1-2001.

       pipe2() ist Linux-spezifisch.

BEISPIEL

       Das  folgende  Programm  erstellt  eine  Pipeline und erzeugt anschließend mittels fork(2)
       einen Kindprozess; das Kind erbt einen kopierten Satz von Dateideskriptoren  für  dieselbe
       pipeline.  Danach  schließt  jeder Prozess die Deskriptoren, die er nicht für die Pipeline
       benötigt (siehe pipe(7)).  Der  erzeugende  Prozess  schreibt  dann  die  Zeichenfolge  im
       Befehlszeilen-Argument in die Pipeline. Der Kindprozess liest diese Zeichenfolge byteweise
       aus der Pipeline und gibt sie auf der Standardausgabe aus.

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

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

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

           if (pipe(pipefd) == -1) {
               perror("Pipeline");    /* Systemfehlermeldung ausgeben */
               exit(EXIT_FAILURE);
           }

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

           if (cpid == 0) {        /* Kindprozess liest aus Pipeline */
               close(pipefd[1]);   /* nicht verwendetes Schreib-Ende schließen */

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

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

           } else {               /* Erzeuger schreibt argv[1] in die Pipeline */
               close(pipefd[0]);  /* nicht verwendetes Lese-Ende schließen */
               write(pipefd[1], argv[1], strlen(argv[1]));
               close(pipefd[1]);          /* der Lesende wird EOF sehen*/
               wait(NULL);                /* auf "das Kind" warten */
               exit(EXIT_SUCCESS);
           }
       }

SIEHE AUCH

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

KOLOPHON

       This page is part of release 3.54 of the Linux man-pages project.  A  description  of  the
       project,     and    information    about    reporting    bugs,    can    be    found    at
       http://www.kernel.org/doc/man-pages/.

ÜBERSETZUNG

       Die   deutsche   Übersetzung   dieser   Handbuchseite   wurde   von   Lars    J.    Brandt
       <ljbrandt@jorma.ping.de> und Martin Eberhard Schauer <Martin.E.Schauer@gmx.de> erstellt.

       Diese  Übersetzung  ist  Freie  Dokumentation;  lesen  Sie  die GNU General Public License
       Version  3  oder  neuer  bezüglich  der  Copyright-Bedingungen.  Es  wird  KEINE   HAFTUNG
       übernommen.

       Wenn Sie Fehler in der Übersetzung dieser Handbuchseite finden, schicken Sie bitte eine E-
       Mail an <debian-l10n-german@lists.debian.org>.