Provided by: manpages-de-dev_2.15-1build1_all bug

BEZEICHNUNG

       pipe - erstellt eine Pipe

ÜBERSICHT

       #include <unistd.h>

       /* Auf Alpha, IA-64, MIPS, SuperH und SPARC/SPARC64; siehe ANMERKUNGEN */
       struct fd_pair {
       long fd[2];
       };
       struct fd_pair pipe();

       /* Auf allen anderen Architekturen */
       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 die offene Datei-Deskription, auf die
              sich  der  neue  Dateideskriptor  bezieht.  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,  errno
       entsprechend gesetzt und pipefd bleibt unverändert.

       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.

ANMERKUNGEN

       Das  Systemv-ABI  auf  einigen  Architekturen  erlaubt  die  Verwendung von mehr als einem
       Register zum Zurückliefern mehrerer Werte; eine Reihe von  Architekturen  (konkret  Alpha,
       IA-64,  MIPS,  SuperH  und  SPARC/SPARC64)  (mis-)brauchen  diese  Funktionalität,  um den
       Systemaufruf pipe() auf eine funktionale Weise zu implementieren:  der  Aufruf  akzeptiert
       keine Argumente und liefert im Erfolgsfall ein Paar von Dateideskriptoren als Rückgabewert
       zurück. Die Glibc-Wrapperfunktion pipe() geht damit transparent um. Siehe  syscall(2)  für
       Informationen   im   Hinblick   auf   die   Register,  die  zur  Speicherung  des  zweiten
       Dateideskriptors verwandt werden.

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