PIPE(2)

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)
    Create a pipe that performs I/O in "packet" mode. Each write(2) to the pipe is dealt with as a separate packet, and read(2)s from the pipe will read one packet at a time. Note the following points:

    *   Writes of greater than PIPE_BUF bytes (see pipe(7)) will be split into multiple packets. The constant PIPE_BUF is defined in <limits.h>.

    *   If a read(2) specifies a buffer size that is smaller than the next packet, then the requested number of bytes are read, and the excess bytes in the packet are discarded. Specifying a buffer size of PIPE_BUF will be sufficient to read the largest possible packets (see the previous point).

    *   Zero-length packets are not supported. (A read(2) that specifies a buffer size of zero is a no-op, and returns 0.)

    Older kernels that do not support this flag will indicate this via an EINVAL error.

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
    Der Prozess benutzt zu viele Dateideskriptoren.

ENFILE
    Die Systembeschrä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. 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), write(2), popen(3), pipe(7)

KOLOPHON
This page is part of release 3.70 of the Linux man-pages project. A description of the project, information about reporting bugs, and the latest version of this page, can be found at 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> und Mario Blättermann <mario.blaettermann@gmail.com> 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>.