Transport Layer b

Chapter 3: Transport Layer

🔹 1. Transport Layer Overview: Core Goals

✅ What Does the Transport Layer Do?

• Provides logical communication between application processes on different hosts.

• Builds on network layer (IP) — adds port-number-based demultiplexing and reliability/service controls.

• Two protocols:
• TCP: Connection-oriented, reliable, flow/congestion controlled
• UDP: Connectionless, unreliable, lightweight

✅ Analogy:

• IP = Postal Service → delivers letter (datagram) from house to house

• TCP/UDP = Ann & Bill → deliver letter to specific kid in the house (via port)

🔹 2. Multiplexing & Demultiplexing (CRITICAL!)

✅ Defining Terms

✅ How Demultiplexing Works

➤ UDP: 1-Tuple Demultiplexing

• Uses only destination port number

• All segments to same (host:port) go to same socket

• Multiple clients → same server port = one server socket

✅ UDP is connectionless → no connection state → simple demux

➤ TCP: 4-Tuple Demultiplexing

🧠 Exam Tip:

• UDP demux = destination port only

• TCP demux = 4-tuple → allows multiple persistent connections

🔹 3. UDP: User Datagram Protocol

✅ UDP Features Table

✅ Why Use UDP?

• Low overhead → no connection setup delay (0-RTT)

• No head-of-line blocking

• Ideal for delay-sensitive apps (e.g., Zoom, Twitch)

• Apps add their own reliability if needed → e.g., QUIC (HTTP/3)

✅ UDP Header (8 bytes)

✅ Checksum includes:

• UDP header + payload

• 96-bit pseudo-header: Source IP, Dest IP, Protocol (17), UDP Length → End-to-end integrity — not just link-level

✅ Internet Checksum: 1's Complement Sum

• Treats data as 16-bit integers → sum → take 1’s complement

• Receiver recomputes — must equal 0 if no error

• Weak protection: Can detect single-bit and some multi-bit errors ❌ Fails on two flipped bits that cancel out → not cryptographically secure

💡 Example: 0000 1111 + 1111 0000 = 1 0000 0000 → wraparound → 0000 0000 → checksum = 1111 1111

🔹 4. Reliable Data Transfer: Principles (The Foundation)

✅ Four Core Abstractions

✅ Progression of rdt Protocols

✅ Stop-and-Wait: One packet sent → wait for ACK → then next → Terrible efficiency

✅ rdt3.0 Performance: STOP-AND-WAIT IS SLOW!

💡 Pipelining → allows multiple in-flight packets → fixes this!

🔹 5. Pipelined Protocols: Go-Back-N & Selective Repeat

✅ Basic Idea: Pipelining

• Send N packets before waiting for ACK → improves utilization

• Use sequence numbers to track packets

• Window size = N → max unACKed packets allowed

✅ Go-Back-N (GBN) — Simpler, Less Efficient

✅ Example: Window size=4. Packet 2 lost → sender retransmits 2,3,4,5 (even if 3,4,5 arrived OK)

✅ Selective Repeat (SR) — Efficient, Complex

💡 Critical Rule: Window size ≤ half sequence number space → to avoid “duplicate ACK” ambiguity ❌ Example: 2-bit seq nums (0,1,2,3), window=3 → ambiguity if 0 lost & retransmitted

✅ Use Case: High-bandwidth, high-delay networks (e.g., satellite)

✅ Comparison: GBN vs SR

✅ TCP uses GBN-style (cumulative ACK) + fast retransmit to simulate SR

🔹 6. TCP: Connection-Oriented Reliability

✅ TCP Features (Must Memorize!)

• ✅ Connection-oriented → 3-way handshake

• ✅ Reliable, in-order byte stream → no message boundaries

• ✅ Flow control: via rwnd field

• ✅ Congestion control: congestion avoidance, slow start

• ✅ Full-duplex: both sides send/receive simultaneously

• ✅ ACKs: Cumulative, delayed, duplicate

• ✅ Retransmissions: timeout + fast retransmit (3 dup ACKs)

✅ TCP Segment Header (20+ bytes)

🔑 Key Insight: Sequence numbers = bytes (not packets)! This enables reassembly in order → stream abstraction

✅ TCP Sequence & ACK Numbers

✅ ACK=80 means: “I received up to byte 79. Next I expect byte 80.”

✅ TCP Round-Trip Time (RTT) Estimation

✅ More variation → higher timeout → avoids premature retransmits

🔹 7. TCP Reliable Data Transfer: Fast Retransmit & Delayed ACK

✅ TCP ACK Generation Rules [RFC 5681]

✅ Fast Retransmit (Crucial!)

• Sender receives 3 duplicate ACKs → assume loss → retransmit immediately

• Avoids timeout → improves performance

• Works because 3 dup ACKs = 3 packets received after a gap → probable lost segment in between

❗ TCP Reno uses 3 dup ACKs → fast retransmit ❗ TCP Tahoe waits for timeout → slower

🔹 8. TCP Flow Control

✅ Purpose

✅ How It Works

• Receiver advertises available buffer space in rwnd field of TCP header

• Sender only sends up to min(cwnd, rwnd) bytes

• rwnd = RcvBuffer – (LastByteReceived – LastByteRead)

💡 Example: Receiver buffer = 4KB Bytes received = 5000 Bytes read by app = 3000 → rwnd = 4096 – (5000 - 3000) = 4096 – 2000 = 2096 → Sender can only send 2096 bytes more.

✅ rwnd can shrink → receiver tells sender “slow down”

🔁 Always observe: TCP is receiver-driven → Pearl of orchestration

🔹 9. TCP Connection Management: 3-Way Handshake

✅ Steps

🔐 States:

• Client: CLOSED → SYN_SENT → ESTABLISHED

• Server: LISTEN → SYN_RCVD → ESTABLISHED

✅ Why 3-Way? (Not 2-Way!)

• To prevent half-open connections

• Example: Stale SYN gets retransmitted → server accepts → client gone → dangling connection

✅ Human analogy:

1. “On belay?”

2. “Belay on.”

3. “Climbing.” → mutual confirmation

✅ Connection Termination: 4-Way FIN Handshake

💡 TIME_WAIT: Client waits 2× MSL (max segment lifetime) to ensure last ACK arrives → prevents old packets from reappearing

🔹 10. TCP Congestion Control

✅ Congestion vs Flow Control

✅ Congestion Signs

• Packet loss (buffer overflow)

• Increase in RTT (queueing delay)

❗ TCP treats any loss as congestion — even wireless or noise-induced → suboptimal

✅ TCP Congestion Control Phases

✅ Algorithm State Diagram (Must Know!)

🔁 ssthresh = “slow start threshold” — set to cwnd/2 on loss

✅ Actions:

• On 3 dup ACKs: ssthresh = cwnd/2, cwnd = ssthresh + 3, enter fast recovery

• On timeout: ssthresh = cwnd/2, cwnd = 1, restart slow start

✅ TCP Throughput Formula

Average throughput ≈ 1.22 × MSS / (RTT × √L) — Mathis Formula —

💡 High-speed long pipes need extremely low loss → TCP Reno struggles

🔹 11. Advanced TCP: CUBIC & BBR

✅ TCP CUBIC (Linux default until ~2024)

• Uses cubic function to scale cwnd → faster recovery after loss

• Smooth, predictable window growth

• Avoids aggressive ramp-down → better network utilization

• After packet loss → cwnd = W_max / 2

• Modern delay → W_max hasn’t changed much

• So, ramp back to W_max faster, then slow down

✅ Result: Better for high-BDP (bandwidth-delay product) networks

✅ BBR (Bottleneck Bandwidth and Round-Trip time)

• Sending rate based on measured bandwidth + min RTT — no loss!

• Doesn’t wait for loss → probes to find max capacity

• Sends just enough to fill pipe → avoid queuing

1. Startup: Increase rate fast until throughput plateaus

2. Drain/BTL: Reduce rate → drain queue → find true min RTT

3. Probe BW: Adjust rate up/down based on recent throughput

✅ Used by Google, YouTube, Cloudflare → higher throughput, lower latency ✅ Newer standard → replacing CUBIC in many modern systems

🔹 12. QUIC & HTTP/3: Transport Layer in Application Layer

✅ QUIC = UDP + TLS + TCP-like reliability + multiplexing

🔹 13. Evolution & Trends in Transport Layer

✅ Trend: Move transport logic to application layer → take control from infrastructure

🚨 Chapter 3: Exam Checklist (Must Know!)

🧠 Key Takeaways (Quote These in Exams!)

• “Transport layer enables process-to-process communication — IP only does host-to-host.” • “TCP is reliable, ordered, flow- and congestion-controlled — UDP is ‘fire and forget.’” • “Sequence numbers count bytes, not packets — making TCP a byte stream!” • “3 duplicate ACKs mean a packet is lost — don’t wait for timeout!” • “Congestion control is not about bandwidth — it’s about queueing delay and loss. “ • “CUBIC is for high-speed networks, BBR is for low-latency, and QUIC is the future.” • “The Internet is moving transport functions to the application layer — TCP is no longer the only option.”

📚 Practice Suggestions for Exam Prep

• ✅ Simulate TCP handshake with 3 states on paper

• ✅ Practice drawing GBN/SR timelines with lost packets

• ✅ Calculate stop-and-wait utilization given L, R, RTT

• ✅ Trace TCP fast retransmit with 3 dup ACKs

• ✅ Write down TCP header fields (seq, ACK, rwnd, flags, checksum)

• ✅ Use Wireshark to capture TCP 3-way handshake → identify SYN, ACK, flags

• ✅ Review cwnd growth on diagram: slow start → CA → loss → recovery → CA

✅ You now command the Transport Layer: from UDP sockets to BBR congestion. You’re ready for Chapter 4 (Network Layer: Data Plane) — the core of the Internet!