jammy (2) pipe.2.gz

Provided by: manpages-de-dev_4.13-4_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 Pipedd[2]);

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

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

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.

RÜCKGABEWERT

       Bei Erfolg wird Null zurückgegeben. Bei einem Fehler wird -1 zurückgegeben,  errno  entsprechend  gesetzt
       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).

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.

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

KOLOPHON

       Diese  Seite  ist  Teil  der  Veröffentlichung  5.10  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
       ⟨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⟩.