Provided by: manpages-de-dev_4.21.0-2_all bug

BEZEICHNUNG

       pipe - erstellt eine Pipe

BIBLIOTHEK

       Standard-C-Bibliothek (libc, -lc)

ÜBERSICHT

       #include <unistd.h>

       int pipe(int Pipedd[2]);

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

       int pipe2(int Pipedd[2], int Schalter);

       /* Auf Alpha-, IA-64-, MIPS-, SuperH- und SPARC/SPARC64-Systemen hat pipe()
          den folgenden Prototyp; siehe ANMERKUNGEN */

       #include <unistd.h>

       struct fd_pair {
       long fd[2];
       };
       struct fd_pair pipe(void);

BESCHREIBUNG

       pipe()  erzeugt  eine  Pipe,  einen unidirektionalen Datenkanal, der für die Kommunikation
       zwischen Prozessen verwendet  werden  kann.  Das  Feld  Pipedd  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 Schalter 0 ist, dann ist pipe2() dasselbe wie pipe(). Um ein  anderes  Verhalten  zu
       bewirken, können die folgenden Werte in Schalter 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.

       O_NOTIFICATION_PIPE
              Seit Linux 5.8 ist ein allgemeiner Benachrichtigungsmechanismus oberhalb von  Pipes
              gebaut  worden,  bei  denen der Kernel Benachrichtungsmeldungen in vom Benutzerraum
              geöffnete Pipes vebindet. Der Eigentümer der Pipe muss dem Kernel mitteilen, welche
              Ereignisquellen  beobachtet werden sollen. Auch können Filter angewendet werden, um
              auszuwählen, welche Unterereignisse in die Pipe gelegt werden sollen.

RÜCKGABEWERT

       Bei Erfolg wird Null zurückgegeben. Bei einem Fehler wird -1 zurückgegeben, errno gesetzt,
       um den Fehler anzuzeigen und Pipedd bleibt unverändert.

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

FEHLER

       EFAULT Pipedd ist ungültig.

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

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

       ENOPKG (pipe2()) O_NOTIFICATION_PIPE wurde in Schalter übergeben und die Unterstützung für
              Benachrichtigungen (CONFIG_WATCH_QUEUE) ist nicht im Kernel einkompiliert.

VERSIONEN

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

STANDARDS

       pipe(): POSIX.1-2001, POSIX.1-2008.

       pipe2() ist Linux-spezifisch.

ANMERKUNGEN

       Das System-V-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.

BEISPIELE

       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 <stdio.h>
       #include <stdlib.h>
       #include <string.h>
       #include <sys/wait.h>
       #include <unistd.h>

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

           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("fork");
               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)

Ü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 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ 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 die Mailingliste der Übersetzer ⟨debian-l10n-german@lists.debian.org⟩.