std.pipe

Pipes & fd-Duplikation (WP-2): Erstellt unidirektionale anonyme Pipes für die Prozesskommunikation und dupliziert Dateideskriptoren (dup/dup2/dup3). Typischer Einsatz: Eltern-Kind-Kommunikation nach fork, Stdout/Stderr-Umleitung und Pipe-Kaskaden.

→ Standard Library · std.process · std.mqueue

Alle Konstanten dieser Unit:

Alle öffentlichen Funktionen dieser Unit im Überblick:

Übersicht:

Übersicht:

Grundlegendes Anwendungsbeispiel:

Beispiel:

import std.pipe;
import std.process;
import std.alloc;
import std.io;

fn Main(): void {
    var rBuf: int64 := alloc(8);
    var wBuf: int64 := alloc(8);
    PipeCreate(rBuf, wBuf);

    var rFd := peek64(rBuf);
    var wFd := peek64(wBuf);
    free(rBuf, 8);
    free(wBuf, 8);

    var pid := Fork();
    if (pid == 0) {
        // Kindprozess: liest von der Pipe
        close(wFd);
        var buf: int64 := alloc(64);
        var n := read(rFd, buf, 64);
        PrintLn("Kind empfing: " + buf as pchar);
        free(buf, 64);
        close(rFd);
    } else {
        // Elternprozess: schreibt in die Pipe
        close(rFd);
        var msg: pchar := "Hallo Kind";
        write(wFd, msg as int64, 11);
        close(wFd);
        Wait(pid);
    }
}

Beispiel:

import std.pipe;
import std.alloc;

fn RedirectStdout(): int64 {
    var rBuf: int64 := alloc(8);
    var wBuf: int64 := alloc(8);
    Pipe2(rBuf, wBuf, O_CLOEXEC);

    var rFd := peek64(rBuf);
    var wFd := peek64(wBuf);
    free(rBuf, 8);
    free(wBuf, 8);

    // fd 1 (stdout) auf Schreib-Ende der Pipe umleiten
    FdDup2(wFd, 1);
    close(wFd);

    // Alles was jetzt über fd 1 geschrieben wird, landet in der Pipe.
    // Lese-Ende (rFd) zurückgeben.
    return rFd;
}

Beispiel:

import std.pipe;
import std.alloc;
import std.io;

fn TryRead(pipeFd: int64): bool {
    var buf: int64 := alloc(256);
    var n := read(pipeFd, buf, 256);
    free(buf, 256);

    if (n < 0) {
        // n == -11 bedeutet EAGAIN — keine Daten vorhanden
        return false;
    }
    return true;
}

fn SetupNonblocking(): int64 {
    var rBuf: int64 := alloc(8);
    var wBuf: int64 := alloc(8);
    Pipe2(rBuf, wBuf, O_NONBLOCK | O_CLOEXEC);
    var rFd := peek64(rBuf);
    free(rBuf, 8);
    free(wBuf, 8);
    return rFd;
}

Wichtige Hinweise für den Einsatz dieser Unit:

• Eine Pipe ist unidirektional: Das Schreib-Ende (wFd) und Lese-Ende (rFd) müssen nach fork() im jeweils nicht-verwendenden Prozess geschlossen werden — sonst blockiert read auf rFd ewig (Schreib-Ende noch offen).
• Pipes haben einen Kernel-Puffer (typisch 64 KB). write auf eine volle Pipe blockiert; read auf eine leere Pipe blockiert.
• Mit O_NONBLOCK geben read/write sofort zurück: −11 (EAGAIN) wenn nicht bereit.
• FdDup2(wFd, 1) ist der Standardweg um den Stdout eines Kindprozesses abzufangen (vor exec).
• O_CLOEXEC auf der Pipe verhindert, dass der fd nach exec() versehentlich geerbt wird.

Enthaltene Untermodule im Überblick:

• std.process — fork, exec, waitpid
• std.mqueue — Message Queues (prioritätsbasiertes IPC)
• std.signals — Signal-basierte Prozesskommunikation
• std.net.epoll — Pipe-fds lassen sich in epoll einbinden

Letzte Aktualisierung: 2026-06-05