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

Linux                                              2012-02-14                                            PIPE(2)