Low-Level Networking

18 min read

The Rust standard library ships a small, synchronous, blocking networking API in std::net: TCP via TcpListener/TcpStream and UDP via UdpSocket. It is the rough equivalent of Node’s net and dgram modules — but blocking and thread-based instead of event-loop-based.

Quick Overview

std::net gives you raw TCP and UDP sockets with no runtime, no framework, and no dependencies. The calls are blocking: accept(), read(), and write() each park the current thread until the OS has data, so you get concurrency by spawning a thread per connection rather than by registering callbacks on an event loop.

For a TypeScript/JavaScript developer the mental model flips: in Node, net.createServer is non-blocking and single-threaded by default; in Rust’s std::net every socket operation blocks, and you reach for threads (or an async runtime like Tokio) to handle many clients at once. This file covers the blocking standard-library path — perfect for CLI tools, internal services, and learning how sockets actually work. For high-concurrency production servers you would usually move to tokio::net, which mirrors this API in an async form.

Note: std::net is intentionally minimal. It has no TLS, no HTTP, and no connection pooling. For HTTPS clients reach for reqwest; for HTTP servers reach for axum; for encrypted transport see Section 27: Security.

TypeScript/JavaScript Example

In Node, a TCP echo server is built around the event loop. net.createServer registers a callback that fires for each connection, and you attach data/end listeners to each socket.

1
// echo-server.ts — Node v22, run with: node --experimental-strip-types echo-server.ts
2
import net from "node:net";
3

4
const server = net.createServer((socket) => {
5
  console.log(`New connection from ${socket.remoteAddress}:${socket.remotePort}`);
6

7
  // 'data' fires every time bytes arrive; echo them straight back.
8
  socket.on("data", (chunk: Buffer) => {
9
    socket.write(chunk);
10
  });
11

12
  socket.on("end", () => {
13
    console.log("Connection closed by client");
14
  });
15

16
  socket.on("error", (err) => {
17
    console.error("socket error:", err.message);
18
  });
19
});
20

21
server.listen(7878, "127.0.0.1", () => {
22
  console.log("Echo server listening on 127.0.0.1:7878");
23
});

A matching client:

1
import net from "node:net";
2

3
const client = net.connect(7878, "127.0.0.1", () => {
4
  client.write("hello echo");
5
});
6

7
client.on("data", (data: Buffer) => {
8
  console.log("Server replied:", data.toString());
9
  client.end();
10
});

Key points:

One thread, one event loop; thousands of idle connections cost almost nothing.
You never call read() yourself — the runtime pushes data events at you.
chunk is a Buffer; there is no built-in framing, so a single logical message can arrive split across several data events.

Rust Equivalent

The standard-library version is blocking. listener.incoming() yields one connection at a time; we hand each off to a freshly spawned thread so the accept loop can keep going.

1
use std::io::{Read, Write};
2
use std::net::{TcpListener, TcpStream};
3
use std::thread;
4

5
fn handle_client(mut stream: TcpStream) -> std::io::Result<()> {
6
    let peer = stream.peer_addr()?;
7
    println!("New connection from {peer}");
8

9
    let mut buf = [0u8; 1024];
10
    loop {
11
        // read() blocks until bytes arrive. It returns Ok(0) at EOF,
12
        // i.e. when the peer has closed its half of the connection.
13
        let n = stream.read(&mut buf)?;
14
        if n == 0 {
15
            println!("Connection closed by {peer}");
16
            return Ok(());
17
        }
18
        // Echo exactly the bytes we received back to the client.
19
        stream.write_all(&buf[..n])?;
20
    }
21
}
22

23
fn main() -> std::io::Result<()> {
24
    let listener = TcpListener::bind("127.0.0.1:7878")?;
25
    println!("Echo server listening on {}", listener.local_addr()?);
26

27
    for incoming in listener.incoming() {
28
        match incoming {
29
            Ok(stream) => {
30
                // One thread per connection. The closure takes ownership
31
                // of `stream` via `move`, so it lives as long as the thread.
32
                thread::spawn(move || {
33
                    if let Err(e) = handle_client(stream) {
34
                        eprintln!("client error: {e}");
35
                    }
36
                });
37
            }
38
            Err(e) => eprintln!("accept failed: {e}"),
39
        }
40
    }
41
    Ok(())
42
}

A matching client:

1
use std::io::{Read, Write};
2
use std::net::TcpStream;
3

4
fn main() -> std::io::Result<()> {
5
    let mut stream = TcpStream::connect("127.0.0.1:7878")?;
6
    println!("Connected to {}", stream.peer_addr()?);
7

8
    stream.write_all(b"hello echo")?;
9

10
    let mut buf = [0u8; 1024];
11
    let n = stream.read(&mut buf)?;
12
    let reply = String::from_utf8_lossy(&buf[..n]);
13
    println!("Server replied: {reply}");
14
    Ok(())
15
}

Running the server in one terminal and the client in another produces this real output:

1
# client terminal
2
Connected to 127.0.0.1:7878
3
Server replied: hello echo

1
# server terminal
2
Echo server listening on 127.0.0.1:7878
3
New connection from 127.0.0.1:50777
4
Connection closed by 127.0.0.1:50777

The current stable toolchain is Rust 1.96.0 on the 2024 edition; cargo new selects it automatically, and everything above is plain std — no cargo add required.

Detailed Explanation

Binding and accepting

TcpListener::bind("127.0.0.1:7878") asks the OS for a listening socket on that address and port. The argument implements ToSocketAddrs, so you can pass "127.0.0.1:7878", ("127.0.0.1", 7878), a parsed SocketAddr, or even a hostname like "localhost:7878" (which resolves via DNS and may yield several addresses). Binding to "0.0.0.0:7878" listens on every IPv4 interface; "127.0.0.1" restricts it to the loopback (local-only) interface.

listener.incoming() returns an iterator of Result<TcpStream>. Each call to .next() performs a blocking accept() — the thread sleeps until a client connects. Because it is an infinite iterator, the for loop is your server’s main loop.

The `Read` and `Write` traits

A TcpStream is just a byte stream. It implements the standard std::io::Read and std::io::Write traits — the very same traits files implement. That is why you must bring them into scope with use std::io::{Read, Write}; the read/write_all methods come from those traits, not from TcpStream itself.

read(&mut buf) fills part of buf and returns how many bytes it wrote, as Ok(n). Ok(0) means end-of-stream — the peer closed the connection. This is the single most important contract to internalize: you loop until you see Ok(0).
write_all(&buf[..n]) keeps calling the underlying write until every byte is sent or an error occurs. Prefer it over raw write, which (like POSIX write) may send only part of the buffer.

Why a thread per connection

A blocking read() parks the whole thread. If you handled clients inline in the accept loop, a single slow client would freeze the server for everyone else. Spawning a thread per connection (thread::spawn(move || ...)) gives each client its own blocking stack. The move keyword transfers ownership of stream into the closure so it outlives the loop iteration. See Section 26: Threads for the spawn/join mechanics, and Thread Pools if you want to cap the number of live threads.

EOF vs. error

read returning Ok(0) is a clean shutdown — not an error. An actual failure (connection reset, broken pipe) comes back as Err(e), which the ? operator propagates out of handle_client, where the spawned closure logs it. This separation of “stream ended” from “stream broke” is more explicit than Node’s split between the end and error events.

Key Differences

Concept	Node.js (`net`/`dgram`)	Rust (`std::net`)
Concurrency model	Single-threaded event loop, non-blocking	Blocking calls + one thread per connection
Receiving data	`socket.on("data", cb)` push	You call `stream.read(&mut buf)` (pull)
End of stream	`"end"` event	`read` returns `Ok(0)`
Errors	`"error"` event	`Result` returned from each call
Partial writes	Hidden by the runtime’s buffering	`write` may be partial; use `write_all`
Message framing	None (TCP is a byte stream)	None (TCP is a byte stream)
Buffer type	`Buffer` (auto-allocated per chunk)	`&[u8]` / `&mut [u8]` you allocate yourself
Bidirectional split	One `socket` object does both	One stream; `try_clone()` for separate read/write handles
TLS / HTTP	Built into `tls`/`http` modules	Not in `std`; use `rustls`, `reqwest`, `axum`

The deepest difference is the blocking-vs-event-loop split. In Node, idle connections are nearly free, but CPU-bound work in a handler blocks every other connection. In blocking Rust, each connection costs a real OS thread (a megabyte or two of stack), but CPU work in one handler does not stall the others, and the code reads top-to-bottom with no callback nesting. When you outgrow thread-per-connection, you move to async (tokio::net), which keeps a near-identical API while multiplexing thousands of connections onto a few threads.

Note: TCP is a stream of bytes, not a stream of messages — in both languages. One write_all(b"hello") is not guaranteed to surface as one read. If your protocol has discrete messages you must add framing yourself (length prefixes, newline delimiters, etc.). The Real-World Example below uses newline framing.

UDP: connectionless datagrams

UDP has no connection, no accept loop, and no streams — just a socket you send_to/recv_from. It maps to Node’s dgram module.

1
use std::net::UdpSocket;
2

3
fn main() -> std::io::Result<()> {
4
    let socket = UdpSocket::bind("127.0.0.1:9000")?;
5
    println!("UDP echo server on {}", socket.local_addr()?);
6

7
    let mut buf = [0u8; 1500]; // a buffer larger than a typical MTU
8
    loop {
9
        // recv_from blocks until one datagram arrives, returning
10
        // the byte count and the sender's address.
11
        let (n, src) = socket.recv_from(&mut buf)?;
12
        println!("Got {n} bytes from {src}");
13
        socket.send_to(&buf[..n], src)?; // echo the datagram back
14
    }
15
}

A UDP client. Calling connect on a UDP socket does not open a connection — it just sets a default peer so you can use send/recv instead of send_to/recv_from:

1
use std::net::UdpSocket;
2

3
fn main() -> std::io::Result<()> {
4
    // Port 0 tells the OS to pick a free ephemeral port for us.
5
    let socket = UdpSocket::bind("127.0.0.1:0")?;
6
    socket.connect("127.0.0.1:9000")?;
7

8
    socket.send(b"ping")?;
9

10
    let mut buf = [0u8; 1500];
11
    let n = socket.recv(&mut buf)?;
12
    println!("Echoed back: {}", String::from_utf8_lossy(&buf[..n]));
13
    Ok(())
14
}

Real output from running the server and then the client (the server’s loop replaced with a single recv_from for the demo):

1
# client
2
Echoed back: ping

1
# server
2
UDP echo server on 127.0.0.1:9000
3
Got 4 bytes from 127.0.0.1:53497

Warning: Always size your UDP receive buffer to hold the largest datagram you expect (1500 is a common Ethernet MTU). If a datagram is larger than your buffer, the excess bytes are silently discarded — recv_from returns the truncated length and the rest is gone, unlike TCP where a short read just leaves the remainder for the next call.

Common Pitfalls

Forgetting `use std::io::{Read, Write}`

read, write, and write_all are trait methods. Without the trait in scope the compiler cannot find them, even though the type is correct. The fix is the import; the error otherwise reads like “no method named read found for struct TcpStream… method is available… use std::io::Read”.

Treating one `read` as one message

1
use std::io::Read;
2
use std::net::TcpStream;
3

4
fn read_message(mut stream: TcpStream) -> std::io::Result<String> {
5
    let mut buf = [0u8; 1024];
6
    let n = stream.read(&mut buf)?;          // logic bug, not a compile error
7
    Ok(String::from_utf8_lossy(&buf[..n]).into_owned())
8
}

This compiles and usually works on loopback, which lulls you into a false sense of security. Over a real network the client’s write_all(b"hello world") can split across two TCP segments, so the first read returns only "hello ". TCP guarantees order, not message boundaries. Use a loop, a BufReader::read_line, or a length-prefix protocol instead.

Reading and writing through the same `&mut` stream from two threads

You cannot read in one thread and write in another using a single owned TcpStream, because both need &mut self. Use stream.try_clone()? to get a second independent handle to the same underlying socket — one for the reader thread, one for the writer thread. (The Real-World Example does exactly this.)

Moving the stream into a thread, then using it again

1
use std::net::TcpStream;
2
use std::thread;
3

4
fn main() {
5
    let stream = TcpStream::connect("127.0.0.1:7878").unwrap();
6
    thread::spawn(move || {
7
        let _ = stream.peer_addr();
8
    });
9
    let _ = stream.peer_addr(); // does not compile (error[E0382]: borrow of moved value)
10
}

The real compiler error:

1
error[E0382]: borrow of moved value: `stream`
2
  --> src/main.rs:10:13
3
   |
4
 5 |     let stream = TcpStream::connect("127.0.0.1:7878").unwrap();
5
   |         ------ move occurs because `stream` has type `TcpStream`, which does not implement the `Copy` trait
6
 6 |     thread::spawn(move || {
7
   |                   ------- value moved into closure here
8
 7 |         let _ = stream.peer_addr();
9
   |                 ------ variable moved due to use in closure
10
...
11
10 |     let _ = stream.peer_addr();
12
   |             ^^^^^^ value borrowed here after move

If both the spawned thread and main need the socket, call try_clone() before the move and give each side its own handle.

”Address already in use”

Binding to a port that is already taken (or recently used and still in TIME_WAIT) fails. Reproduced by binding the same port twice in one process:

1
use std::net::TcpListener;
2

3
fn main() {
4
    let _first = TcpListener::bind("127.0.0.1:7878").expect("first bind");
5
    match TcpListener::bind("127.0.0.1:7878") {
6
        Ok(_) => println!("second bind ok?!"),
7
        Err(e) => println!("kind={:?} -> {e}", e.kind()),
8
    }
9
}

Real output:

1
kind=AddrInUse -> Address already in use (os error 48)

Always match on e.kind() (an ErrorKind) rather than the OS-specific message string, since the number (48 here on macOS, 98 on Linux) differs per platform.

Connecting to nothing

TcpStream::connect to a closed port returns ErrorKind::ConnectionRefused:

1
kind=ConnectionRefused -> Connection refused (os error 61)

Match on the kind so your retry/backoff logic is portable.

Best Practices

Bound your operations with timeouts

A blocking read with no data, or a connect to a black-holed host, will otherwise hang the thread for the OS default (often ~75 seconds for connect). Set explicit limits:

1
use std::net::{SocketAddr, TcpStream};
2
use std::time::Duration;
3

4
fn main() {
5
    let addr: SocketAddr = "127.0.0.1:7878".parse().unwrap();
6
    match TcpStream::connect_timeout(&addr, Duration::from_secs(2)) {
7
        Ok(stream) => {
8
            // Cap how long any single read/write may block.
9
            stream.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
10
            stream.set_write_timeout(Some(Duration::from_secs(5))).unwrap();
11
            println!("connected, timeouts set");
12
        }
13
        Err(e) => println!("connect failed: {e}"),
14
    }
15
}

When a read timeout fires, read returns Err with kind WouldBlock (TimedOut on some platforms), not Ok(0). Real output from a 200 ms read timeout that elapses with no data:

1
listening on 127.0.0.1:50981
2
timed out: kind=WouldBlock -> Resource temporarily unavailable (os error 35)

Disable Nagle for latency-sensitive traffic

For request/response protocols, set stream.set_nodelay(true) to disable Nagle’s algorithm so small writes are not buffered waiting for more data.

Buffer your reads and writes

Wrap streams in BufReader/BufWriter to coalesce many small syscalls into a few large ones, and to get convenient line-based helpers like read_line and lines(). Remember to flush() a BufWriter (or rely on writeln! + an explicit flush) before you expect the peer to see the bytes.

Match on `ErrorKind`, never on the message string

Error messages and OS error numbers are platform-specific; ErrorKind is portable. Branch on e.kind() == ErrorKind::ConnectionRefused, not on e.to_string().contains("refused").

Reach for async when connections scale

Thread-per-connection is excellent up to a few hundred concurrent clients. Beyond that, the per-thread stack memory and context-switching cost dominate, and tokio::net::{TcpListener, TcpStream} — which mirror these APIs in async form — let a handful of threads service tens of thousands of connections. Treat std::net as the foundation, not the ceiling.

Real-World Example

A line-based echo server that handles many clients concurrently, frames messages on newlines, supports a quit command, and uses try_clone() to read and write the same socket. This is the shape of a real internal protocol service (a debug console, a metrics ingestion port, a simple chat backend).

1
use std::io::{BufRead, BufReader, Write};
2
use std::net::{TcpListener, TcpStream};
3
use std::thread;
4

5
fn handle_client(stream: TcpStream) -> std::io::Result<()> {
6
    let peer = stream.peer_addr()?;
7

8
    // try_clone() gives us a second handle to the SAME socket, so we can
9
    // read through `reader` and write through `writer` independently.
10
    let mut writer = stream.try_clone()?;
11
    let reader = BufReader::new(stream);
12

13
    // BufReader::lines() splits the byte stream on '\n' for us — proper
14
    // message framing instead of trusting one read == one message.
15
    for line in reader.lines() {
16
        let line = line?;
17
        println!("[{peer}] {line}");
18

19
        if line.trim() == "quit" {
20
            writer.write_all(b"bye\n")?;
21
            break;
22
        }
23
        // Echo each line back, uppercased. writeln! adds the trailing '\n'.
24
        writeln!(writer, "{}", line.to_uppercase())?;
25
    }
26

27
    println!("[{peer}] disconnected");
28
    Ok(())
29
}
30

31
fn main() -> std::io::Result<()> {
32
    let listener = TcpListener::bind("127.0.0.1:7878")?;
33
    println!("Line echo server on {}", listener.local_addr()?);
34

35
    for incoming in listener.incoming() {
36
        match incoming {
37
            Ok(stream) => {
38
                thread::spawn(move || {
39
                    if let Err(e) = handle_client(stream) {
40
                        eprintln!("client error: {e}");
41
                    }
42
                });
43
            }
44
            Err(e) => eprintln!("accept failed: {e}"),
45
        }
46
    }
47
    Ok(())
48
}

A small client that drives it through a hello/world/quit exchange:

1
use std::io::{BufRead, BufReader, Write};
2
use std::net::TcpStream;
3

4
fn main() -> std::io::Result<()> {
5
    let stream = TcpStream::connect("127.0.0.1:7878")?;
6
    let mut writer = stream.try_clone()?;
7
    let mut reader = BufReader::new(stream);
8

9
    for msg in ["hello", "world", "quit"] {
10
        writeln!(writer, "{msg}")?;           // send one line
11
        let mut line = String::new();
12
        reader.read_line(&mut line)?;          // read one line back
13
        print!("server: {line}");              // the line already ends in '\n'
14
    }
15
    Ok(())
16
}

Real captured output:

1
# client
2
server: HELLO
3
server: WORLD
4
server: bye

1
# server
2
Line echo server on 127.0.0.1:7878
3
[127.0.0.1:50962] hello
4
[127.0.0.1:50962] world
5
[127.0.0.1:50962] quit
6
[127.0.0.1:50962] disconnected

Notice the framing: even though TCP could have delivered hello\nworld\n in one packet, BufReader::lines() and read_line split it into exactly the lines we sent. That is the framing discipline TCP itself does not give you.

Exercises

Exercise 1: Count bytes, then disconnect

Difficulty: Beginner

Objective: Get comfortable with the blocking read loop and the Ok(0) EOF contract.

Instructions: Write a TCP server that accepts one connection, reads from it until EOF, prints the total number of bytes received, and then exits. Use a single accept (no thread spawning needed). Verify it by connecting with a client that writes a known string and then closes its half of the connection.

Solution

1
use std::io::Read;
2
use std::net::TcpListener;
3

4
fn main() -> std::io::Result<()> {
5
    let listener = TcpListener::bind("127.0.0.1:7878")?;
6
    println!("counting server on {}", listener.local_addr()?);
7

8
    // accept() returns the first connection; ignore the peer address here.
9
    let (mut stream, _peer) = listener.accept()?;
10

11
    let mut buf = [0u8; 1024];
12
    let mut total = 0usize;
13
    loop {
14
        let n = stream.read(&mut buf)?;
15
        if n == 0 {
16
            break; // peer closed its write half -> EOF
17
        }
18
        total += n;
19
    }
20
    println!("received {total} bytes total");
21
    Ok(())
22
}

Exercise 2: A networked key-value store

Difficulty: Intermediate

Objective: Combine threads, shared state, message framing, and a tiny text protocol.

Instructions: Build a multi-client TCP server speaking a line protocol: SET <key> <value> stores a value and replies OK; GET <key> replies with the value or (nil); QUIT closes the connection. Share the map across all client threads with Arc<Mutex<HashMap<String, String>>>. Use BufReader::lines() for framing.

Solution

1
use std::collections::HashMap;
2
use std::io::{BufRead, BufReader, Write};
3
use std::net::{TcpListener, TcpStream};
4
use std::sync::{Arc, Mutex};
5
use std::thread;
6

7
type Store = Arc<Mutex<HashMap<String, String>>>;
8

9
fn handle(stream: TcpStream, store: Store) -> std::io::Result<()> {
10
    let mut writer = stream.try_clone()?;
11
    let reader = BufReader::new(stream);
12

13
    for line in reader.lines() {
14
        let line = line?;
15
        // Split into at most 3 parts: command, key, value.
16
        let mut parts = line.splitn(3, ' ');
17
        match parts.next() {
18
            Some("SET") => {
19
                if let (Some(k), Some(v)) = (parts.next(), parts.next()) {
20
                    store.lock().unwrap().insert(k.to_string(), v.to_string());
21
                    writeln!(writer, "OK")?;
22
                } else {
23
                    writeln!(writer, "ERR usage: SET <key> <value>")?;
24
                }
25
            }
26
            Some("GET") => {
27
                let key = parts.next().unwrap_or("");
28
                match store.lock().unwrap().get(key) {
29
                    Some(v) => writeln!(writer, "{v}")?,
30
                    None => writeln!(writer, "(nil)")?,
31
                }
32
            }
33
            Some("QUIT") => break,
34
            _ => writeln!(writer, "ERR unknown command")?,
35
        }
36
    }
37
    Ok(())
38
}
39

40
fn main() -> std::io::Result<()> {
41
    let listener = TcpListener::bind("127.0.0.1:7878")?;
42
    println!("kv store on {}", listener.local_addr()?);
43

44
    let store: Store = Arc::new(Mutex::new(HashMap::new()));
45
    for incoming in listener.incoming() {
46
        let stream = incoming?;
47
        let store = store.clone(); // clone the Arc, not the map
48
        thread::spawn(move || {
49
            if let Err(e) = handle(stream, store) {
50
                eprintln!("client error: {e}");
51
            }
52
        });
53
    }
54
    Ok(())
55
}

Tip: store.clone() clones the Arc (a cheap reference-count bump), giving every thread shared ownership of the same map. See Channels for an alternative that avoids the shared lock by routing all mutations through one owner thread.

Exercise 3: A UDP time service

Difficulty: Intermediate

Objective: Practice connectionless datagrams and a full request/response round trip over UDP.

Instructions: Write a UDP server that, on receiving a datagram containing TIME, replies with the current Unix timestamp (seconds since the epoch) as ASCII text. Write a client that sends TIME, prints the reply, and exits. Bind the client to port 0 so the OS assigns an ephemeral port.

Solution

1
use std::net::UdpSocket;
2
use std::time::{SystemTime, UNIX_EPOCH};
3

4
fn run_server(socket: &UdpSocket) -> std::io::Result<()> {
5
    let mut buf = [0u8; 64];
6
    let (n, src) = socket.recv_from(&mut buf)?;
7
    if &buf[..n] == b"TIME" {
8
        let now = SystemTime::now()
9
            .duration_since(UNIX_EPOCH)
10
            .unwrap()
11
            .as_secs();
12
        socket.send_to(now.to_string().as_bytes(), src)?;
13
    }
14
    Ok(())
15
}
16

17
fn main() -> std::io::Result<()> {
18
    // Server and client in one process for a self-contained demo.
19
    let server = UdpSocket::bind("127.0.0.1:0")?;
20
    let server_addr = server.local_addr()?;
21

22
    let client = UdpSocket::bind("127.0.0.1:0")?; // port 0 -> OS picks one
23
    client.send_to(b"TIME", server_addr)?;
24

25
    run_server(&server)?;
26

27
    let mut buf = [0u8; 64];
28
    let n = client.recv(&mut buf)?;
29
    println!("server time = {}", String::from_utf8_lossy(&buf[..n]));
30
    Ok(())
31
}

Real output (your timestamp will differ):

1
server time = 1780382543

Note: UDP gives no delivery guarantee. In production you would set a read timeout on the client and retry if no reply arrives, since either the request or the response can be silently dropped.

Low-Level Networking

Quick Overview

TypeScript/JavaScript Example

Rust Equivalent

Detailed Explanation

Binding and accepting

The Read and Write traits

Why a thread per connection

EOF vs. error

Key Differences

UDP: connectionless datagrams

Common Pitfalls

Forgetting use std::io::{Read, Write}

Treating one read as one message

Reading and writing through the same &mut stream from two threads

Moving the stream into a thread, then using it again

”Address already in use”

Connecting to nothing

Best Practices

Bound your operations with timeouts

Disable Nagle for latency-sensitive traffic

Buffer your reads and writes

Match on ErrorKind, never on the message string

Reach for async when connections scale

Real-World Example

Further Reading

Exercises

Exercise 1: Count bytes, then disconnect

Exercise 2: A networked key-value store

Exercise 3: A UDP time service

The `Read` and `Write` traits

Forgetting `use std::io::{Read, Write}`

Treating one `read` as one message

Reading and writing through the same `&mut` stream from two threads

Match on `ErrorKind`, never on the message string