Skip to content
Modul 18 — Input & Output: Lesen, Schreiben, Dateien & Netzwerk
6

Netzwerk: TcpListener & TcpStream

Lektion 6 von 7

std::net: TCP und UDP

Für Low-Level-Netzwerk bietet std::net blockierende TCP- und UDP-I/O. Zwei zentrale Typen:

  • TcpListener — lauscht auf eingehende Verbindungen (Server)
  • TcpStream — eine offene Verbindung (Client UND Server-Seite)

Ein Echo-Server

Ein Echo-Server schickt einfach alles zurück, was er empfängt. Mit einem Thread pro Verbindung brauchst du nur wenige Zeilen:

use std::net::{TcpListener, TcpStream};
use std::{io, thread};

fn handle_conn(mut stream: TcpStream) -> io::Result<()> {
    // Echo: copy everything from stream back to itself.
    let mut write_stream = stream.try_clone()?;
    io::copy(&mut stream, &mut write_stream)?;
    Ok(())
}

fn echo_main(addr: &str) -> io::Result<()> {
    let listener = TcpListener::bind(addr)?;
    println!("listening on {addr}");

    for stream_result in listener.incoming() {
        let stream = stream_result?;
        let peer = stream.peer_addr()?;
        println!("connection received from {peer}");

        thread::spawn(move || {
            if let Err(e) = handle_conn(stream) {
                eprintln!("error in client thread: {e}");
            }
        });
    }
    Ok(())
}

fn main() {
    echo_main("127.0.0.1:17007").expect("error: ");
}
// → listening on 127.0.0.1:17007
// → connection received from 127.0.0.1:52431
  • listener.incoming() — wartet auf Verbindungen, liefert Result<TcpStream>
  • stream.try_clone() — zweites Handle fürs Schreiben (Rust braucht &mut für Kopien)
  • io::copy(reader, writer) — kopiert alles von Reader zu Writer

Netzwerk: I/O ist überall gleich

Ein TcpStream ist gleichzeitig ein Read und ein Write. Deshalb funktioniert die Reader/Writer-Logik aus den früheren Lektionen auch im Netzwerk — und io::copy braucht nur einen impl Read und einen impl Write, egal ob Datei oder Socket.

Für hochperformante Server mit Tausenden Verbindungen brauchst du aber asynchrone I/O (siehe Modul 17) statt eines Threads pro Verbindung.

⚠ Häufiger Fehler: io::copy(&mut stream, &mut stream) borgt denselben Stream zweimal gleichzeitig veränderlich — E0499 („cannot borrow stream as mutable more than once at a time“). Erst stream.try_clone() liefert das zweite Handle, mit dem Reader und Writer parallel laufen dürfen.

✅ Wichtige Erkenntnisse

0/3

Haken setzen, um deinen Lernfortschritt zu markieren:

  • Rufe dir die Kernpunkte in Erinnerung, bevor du die Liste aufdeckst.

Erinnerungstraining

Tippe den fehlenden Begriff aus dem Gedächtnis ein und prüfe.

Ein bindet eine Adresse und lauscht auf eingehende Verbindungen — incoming() liefert jede als Result<TcpStream>.
Ein TcpStream implementiert sowohl als auch Write — deshalb funktioniert die Reader/Writer-Logik auch im Netzwerk.
(reader, writer) kopiert alles von einer Quelle in ein Ziel — egal ob Datei oder Socket, es braucht nur impl Read und impl Write.
0 von 3 richtig

This site uses essential cookies for Stripe payments. No tracking cookies.