Provided by: manpages-de-dev_1.11-1_all 
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_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 Pipeline, die E/A im »Paketmodus« durchführt. Jeder write(2) in die
Pipeline wird als separates Paket gehandhabt und read(2)s aus der Pipeline 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 Nulloperation und liefert 0 zurück.)
Ältere Kernel, die diesen Schalter nicht unterstützen, zeigen dies mit dem Fehler
EINVAL an.
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.
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.
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 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.
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("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), splice(2), write(2), popen(3), pipe(7)
KOLOPHON
Diese Seite ist Teil der Veröffentlichung 4.04 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 http://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>.