Transport Layer — Cheat Sheet

TCP 3-Way Handshake

// TCP 3-Way Handshake:
//
// Client                          Server
//   │                                │
//   │──── SYN (seq=x) ──────────────>│  Client picks random ISN x
//   │                                │  Server receives, picks ISN y
//   │<─── SYN-ACK (seq=y, ack=x+1) ─│  Server acks client's ISN
//   │                                │
//   │──── ACK (ack=y+1) ────────────>│  Client acks server's ISN
//   │                                │
//   │══════ Connection ESTABLISHED ══│
//   │──── HTTP GET /api/users ──────>│  Data can now flow

// In Java — the handshake is invisible but implicit:
Socket socket = new Socket("api.example.com", 443);
// ↑ This line triggers the full 3-way handshake before returning
// The OS TCP stack handles SYN/SYN-ACK/ACK transparently

// Cost: 1 RTT before first byte of data
// On a 100ms RTT link, every new TCP connection costs 100ms upfront

TCP Flow & Congestion Control

// Flow control: receiver advertises window in every ACK
//
// Sender                              Receiver (rwnd = 64KB)
//   │──── 1KB data ─────────────────>│  rwnd: 64→63KB in ACK
//   │──── 1KB data ─────────────────>│  rwnd: 63→62KB in ACK
//   │  ... (sends up to rwnd) ──────>│
//   │<─── ACK, rwnd=0 ───────────────│  Receiver buffer full! App slow to read
//   │  (sender blocks — zero window) │
//   │──── ZWP (Zero Window Probe) ──>│  Sender probes periodically
//   │<─── ACK, rwnd=32KB ────────────│  Receiver freed buffer space
//   │  (sender resumes) ─────────────│

// Java — increase socket receive buffer to reduce flow control stalls:
Socket socket = new Socket();
socket.setReceiveBufferSize(256 * 1024);  // 256KB receive buffer
socket.setSendBufferSize(256 * 1024);     // 256KB send buffer

// For high-throughput servers, tune OS-level TCP buffers:
// Linux: sysctl -w net.core.rmem_max=16777216
//        sysctl -w net.ipv4.tcp_rmem="4096 87380 16777216"

UDP — User Datagram Protocol

// UDP Header (8 bytes):
// ┌─────────────────┬─────────────────┐
// │ Source Port (2B)│ Dest Port (2B)  │
// ├─────────────────┼─────────────────┤
// │ Length (2B)     │ Checksum (2B)   │
// ├─────────────────┴─────────────────┤
// │ Data (variable)                   │
// └───────────────────────────────────┘
// Total overhead: 8 bytes (vs TCP's 20B minimum)

// Java UDP server:
DatagramSocket server = new DatagramSocket(5353);
byte[] buf = new byte[512];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
server.receive(packet);                         // blocks until a datagram arrives
String msg = new String(packet.getData(), 0, packet.getLength());

// Java UDP client:
DatagramSocket client = new DatagramSocket();
byte[] data = "hello".getBytes();
InetAddress addr = InetAddress.getByName("localhost");
DatagramPacket send = new DatagramPacket(data, data.length, addr, 5353);
client.send(send);                              // fire and forget — no confirmation

Ports & Sockets

// Well-known ports (0–1023):
// 20/21  — FTP (data/control)
// 22     — SSH
// 25     — SMTP
// 53     — DNS (UDP + TCP)
// 80     — HTTP
// 110    — POP3
// 143    — IMAP
// 443    — HTTPS (HTTP over TLS)
// 3306   — MySQL
// 5432   — PostgreSQL
// 6379   — Redis
// 8080   — HTTP alternate (dev servers, Spring Boot default)
// 9092   — Apache Kafka

// Java: bind server to a specific port
ServerSocket server = new ServerSocket(8080);   // privileged port: needs root if < 1024
System.out.println("Listening on port 8080");

Socket client = new Socket("api.example.com", 443);
int localPort = client.getLocalPort();          // OS assigned ephemeral port, e.g. 54231
int remotePort = client.getPort();              // 443
System.out.println("Ephemeral port: " + localPort);

TCP vs UDP

// TCP vs UDP comparison:
// ┌──────────────────────┬─────────────────────┬──────────────────────┐
// │ Property             │ TCP                 │ UDP                  │
// ├──────────────────────┼─────────────────────┼──────────────────────┤
// │ Connection           │ Connection-oriented  │ Connectionless       │
// │ Reliability          │ Guaranteed delivery  │ Best-effort          │
// │ Ordering             │ Guaranteed           │ Not guaranteed       │
// │ Error checking       │ Yes (+ retransmit)   │ Checksum only        │
// │ Flow control         │ Yes (rwnd)           │ No                   │
// │ Congestion control   │ Yes (cwnd)           │ No                   │
// │ Header size          │ 20 bytes minimum     │ 8 bytes              │
// │ Speed                │ Slower               │ Faster               │
// │ Connection setup     │ 3-way handshake      │ None                 │
// │ State                │ Stateful             │ Stateless            │
// │ Use cases            │ HTTP, SSH, DB, SMTP  │ DNS, video, gaming   │
// └──────────────────────┴─────────────────────┴──────────────────────┘