Provided by: manpages-de-dev_2.14-1_all bug

BEZEICHNUNG

       pipe - erstellt eine Pipe

Ü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  Pipe,  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 Pipe zurückzugeben. pipefd[0] bezeichnet das Lese-Ende
       der Pipe; pipefd[1] das Schreib-Ende. In das  Schreib-Ende  der  Pipe  geschriebene  Daten
       werden  durch den Kernel gepuffert, bis sie aus dem Lese-Ende der Pipe 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_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.

       O_DIRECT (seit Linux 3.4)
              Erstellt  eine Pipe, die E/A im »Paketmodus« durchführt. Jeder write(2) in die Pipe
              wird als separates Paket gehandhabt und read(2)s aus der Pipe werden ein Paket  auf
              einmal lesen. Beachten Sie die folgenden Punkte:

              *  Schreibvorgänge  mit  mehr  als PIPE_BUF Bytes (siehe pipe(7)) werden in mehrere
                 Pakete aufgeteilt. Die Konstante PIPE_BUF ist in <limits.h> definiert.

              *  Falls ein read(2) einen Puffer angibt, der kleiner als das  nächste  Paket  ist,
                 dann wird die angeforderte Anzahl an Bytes gelesen und die überzähligen Bytes im
                 Paket werden verworfen. Es reicht aus, die Puffergröße als  PIPE_BUF  anzugeben,
                 um das größtmögliche Paket zu lesen (siehe hierzu auch den vorherigen Punkt).

              *  Pakete  der  Länge  null  werden  nicht  unterstützt.  (Ein  read(2),  der  eine
                 Pufferlänge der Größe null angibt, ist eine Nullaktion und liefert 0 zurück.)

              Ältere Kernel, die diesen Schalter nicht unterstützen, zeigen dies mit  dem  Fehler
              EINVAL an.

              Seit Linux 4.5 ist es möglich, die Einstellung O_DIRECT eines Pipe-Dateideskriptors
              mittels fcntl(2) zu ändern.

       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.

RÜCKGABEWERT

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

       Unter  Linux  (und  anderen  Systemen) verändert pipe() beim Fehlschlag pipefd nicht. Eine
       Anforderung, die dieses Verhalten standardisiert, wurde in POSIX.1-2016  hinzugefügt.  Ein
       Linux-spezifischer  Systemaufruf  pipe2()  ändert entsprechend auch pipefd beim Fehlschlag
       nicht.

FEHLER

       EFAULT pipefd ist ungültig.

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

       EMFILE Die Beschränkung pro Prozess der Anzahl offener Datei-Deskriptoren wurde erreicht.

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

       ENFILE Die benutzerbezogene harte Grenze des Speichers, der für  Pipes  zugewiesen  werden
              kann,  wurde  erreicht  und  der  Aufrufende  verfügt nicht über Privilegien; siehe
              pipe(7).

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, POSIX.1-2008.

       pipe2() ist Linux-spezifisch.

BEISPIEL

       Das  folgende  Programm  erstellt eine Pipe 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 Dateideskriptoren, die er nicht für die Pipe
       benötigt  (siehe  pipe(7)).  Der  Elternprozess  schreibt   dann   die   Zeichenfolge   im
       Befehlszeilen-Argument in die Pipe. Der Kindprozess liest diese Zeichenfolge byteweise aus
       der Pipe und gibt sie auf der Standardausgabe aus.

   Programmquelltext
       #include <sys/types.h>
       #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("Pipe");    /* Systemfehlermeldung ausgeben */
               exit(EXIT_FAILURE);
           }

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

           if (cpid == 0) {        /* Kindprozess liest aus Pipe */
               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 {               /* Elternprozess schreibt argv[1] in die Pipe */
               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),  splice(2),  tee(2),  vmsplice(2),  write(2),  popen(3),
       pipe(7)

KOLOPHON

       Diese  Seite  ist  Teil  der  Veröffentlichung  4.16  des  Projekts  Linux-man-pages. Eine
       Beschreibung des Projekts, Informationen, wie Fehler  gemeldet  werden  können  sowie  die
       aktuelle Version dieser Seite finden sich unter https://www.kernel.org/doc/man-pages/.

ÜBERSETZUNG

       Die    deutsche    Übersetzung   dieser   Handbuchseite   wurde   von   Lars   J.   Brandt
       <ljbrandt@jorma.ping.de>,  Martin  Eberhard   Schauer   <Martin.E.Schauer@gmx.de>,   Mario
       Blättermann  <mario.blaettermann@gmail.com>  und  Helge  Kreutzmann <debian@helgefjell.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>.