Transport-Layer Services and Concepts

The transport layer acts as the logical bridge between the user-facing application layer and the packet-routing network layer of the TCP/IP suite. This module examines how the transport layer provides process-to-process communication, manages network congestion, handles packet errors, and ensures reliable stream delivery.

1. Principles of the Transport Layer

The primary objective of the transport layer is to provide logical, end-to-end process-to-process communication between application programs running on different hosts.

While the network layer manages host-to-host communication (routing packets from physical machine $A$ to physical machine $B$ ), it is unaware of which specific application process should receive those packets. The transport layer sits above the network layer, demultiplexing network packets down to individual application sockets.

text

+--------------------------------------------------------+
|                   APPLICATION LAYER                    |
|  [HTTP Process]   [DNS Process]   [SMTP Process]       |
+---------+---------------+---------------+--------------+
          |               |               |             
   (Port 80/TCP)    (Port 53/UDP)   (Port 25/TCP)        <-- Transport Sockets
          |               |               |             
+---------+---------------+---------------+--------------+
|                    TRANSPORT LAYER                     |
|           [TCP Engine]        [UDP Engine]             |
+-------------------------+------------------------------+
                          |                             
+-------------------------v------------------------------+
|                     NETWORK LAYER                      |
|                [IP Routing (Host-to-Host)]             |
+--------------------------------------------------------+

1.1 Addressing: Port Numbers

To map data to its designated process, the transport layer utilizes port numbers. Port numbers are 16-bit integers ranging from $0$ to $65,535$ . The Internet Assigned Numbers Authority (IANA) divides these numbers into three clear domains:

Well-Known Ports ( $0$ to $1,023$ ): Reserved for standard, ubiquitous server protocols (e.g., HTTP on port 80, TCP on port 21, SMTP on port 25).
Registered Ports ( $1,024$ to $49,151$ ): Assigned by ICANN to specific services or user applications upon request.
Dynamic/Ephemeral Ports ( $49,152$ to ): Temporarily allocated to client processes when they initiate a connection.

In UNIX and Unix-like operating systems, the binding of well-known ports to services is listed in /etc/services. For example, searching for trivial file transfer services via shell command:

bash

grep -w 69 /etc/services
# Output: tftp 69/udp

1.2 Socket Address

To establish a unique network connection, a transport layer protocol requires both an IP address (network-level routing) and a port number (process-level routing). The combination of these two elements forms a Socket Address:

$\text{Socket Address} = (\text{IP Address}, \text{Port Number})$

An active communication channel is uniquely identified by a 4-tuple consisting of: $\{\text{Source IP}, \text{Source Port}, \text{Destination IP}, \text{Destination Port}\}$

2. Multiplexing, Demultiplexing, and Encapsulation

The transport layer acts as a funnel. It must aggregate outgoing data flows from various application processes into a single channel (multiplexing) and separate incoming data packets back to their target applications (demultiplexing).

Multiplexing: The sender's transport layer gathers chunks of data from multiple active sockets, appends the appropriate source and destination port headers, and passes these segments to the network layer.
Demultiplexing: Upon receiving a segment from the network layer, the receiver's transport layer inspects the destination port, parses the payload, and directs the data to the correct application socket.

text

  Sender-Side (Multiplexing)             Receiver-Side (Demultiplexing)
  
  [App 1]     [App 2]    [App 3]         [App 1]     [App 2]    [App 3]
     |           |          |               ^           ^          ^
  (Port A)    (Port B)   (Port C)        (Port A)    (Port B)   (Port C)
     \           |          /               \           |          /
    +-v----------v----------v-+            +-v----------v----------v-+
    |     Transport Layer     |            |     Transport Layer     |
    +------------+------------+            +------------^------------+
                 | (Encapsulation)                      | (Decapsulation)
                 v                                      |
         To Network Layer                       From Network Layer

During encapsulation, the application stream is segmented, and a transport-layer header (including the port addresses) is prepended. This segment is encapsulated within an IP datagram payload, which is then encapsulated inside a data-link layer frame.

3. Flow Control and Error Control Foundations

Reliable transport requires mechanisms to handle speed disparities between the sender and receiver, as well as lossy network links.

3.1 Flow Control

Flow control balances the rate at which a producer generates data against the rate at which a consumer processes it.

Push Model: The sender transmits packets whenever they are ready. If the receiver's buffers fill up, the receiver must request a pause or drop packets.
Pull Model: The consumer explicitly requests data chunks only when its buffer has available slots.

At the transport layer, sliding window mechanisms utilize a pull/push hybrid feedback system to dynamically update the sender on how much data the receiver can accept.

3.2 Error Control

Error control guarantees that the delivered data stream is complete, in-order, and uncorrupted.

To track packets, transport protocols utilize sequence numbers and acknowledgements. The sequence numbers are cyclic, governed by modulo arithmetic:

$\text{Sequence Numbers} \equiv \text{modulo } 2^m$

where $m$ represents the bit-size of the sequence number field.

4. Fundamental Transport Protocols

To understand modern transport-layer design, we can examine a sequence of protocols moving from low to high complexity.

4.1 The Simple Protocol

The Simple Protocol is an idealized, connectionless protocol with no flow control and no error control. It assumes that the underlying physical link is completely error-free and that the receiver's buffer is infinitely large. The sender simply pushes packets to the receiver as fast as they arrive from the application.

text

Sender                                Receiver
  |                                      |
  |--- Packet 0 ------------------------>| (Process Immediately)
  |--- Packet 1 ------------------------>| (Process Immediately)
  |                                      |

4.2 The Stop-and-Wait Protocol

The Stop-and-Wait Protocol introduces both flow and error control. The sender transmits a single packet and pauses, refusing to send more data until it receives an Acknowledgement (ACK) from the receiver.

Sequence Numbers: Since only one packet is outstanding at any time, a 1-bit sequence number ( $0$ or $1$ ) using modulo-2 arithmetic is sufficient.
Acknowledgments: The ACK number always designates the sequence number of the next expected packet.
Error Recovery: If a packet is lost or corrupted, the receiver discards it. The sender maintains a retransmission timer. If the timer expires before the ACK arrives, the sender retransmits the packet.

text

Sender                                Receiver
  |                                      |
  |--- Seq 0 --------------------------->| (Received OK)
  |<-- ACK 1 ----------------------------| (Expects Seq 1 next)
  |                                      |
  |--- Seq 1 -------------------> [X]    | (Packet Lost)
  |    (Timer Starts)                    |
  |    (Timer Expires)                   |
  |--- Seq 1 (Retransmitted) ----------->| (Received OK)
  |<-- ACK 0 ----------------------------| (Expects Seq 0 next)

Mathematical Performance of Stop-and-Wait

The key drawback of the Stop-and-Wait protocol is its poor link utilization on networks with a high Bandwidth-Delay Product (BDP):

$\text{BDP} = R \times \text{RTT}$

where $R$ is the transmission rate (bandwidth) of the channel, and $\text{RTT}$ is the Round-Trip Time.

Let $L$ be the packet length in bits. The transmission time ( $T_{\text{trans}}$ ) of the packet is:

$T_{\text{trans}} = \frac{L}{R}$

The channel utilization ( $U$ ) of a Stop-and-Wait system can be formulated as:

$U = \frac{T_{\text{trans}}}{T_{\text{trans}} + \text{RTT}}$

If $T_{\text{trans}} \ll \text{RTT}$ , the utilization falls toward zero, leaving the link mostly idle.

4.3 The Go-Back-N (GBN) Protocol

To resolve the low efficiency of Stop-and-Wait, pipelining is introduced. The Go-Back-N protocol allows the sender to transmit multiple packets before waiting for an acknowledgment.

text

Go-Back-N Send Window Layout:
+--------------------------------------------------------------+
| ... | Sf |  Sf+1  |  ...  |  Sn-1  |  ...  | Sf + Ssize - 1 | ...
+--------------------------------------------------------------+
      ^                              ^
      |-- Sent, Unacknowledged       |-- Next to Send

Variables:
- $S_f$ : Sequence number of the first outstanding (sent but unacknowledged) packet.
- $S_n$ : Sequence number of the next packet to be sent.
- $S_{\text{size}}$ : The maximum size of the send window.

$S_{\text{size}} \le 2^m - 1$

If $S_{\text{size}}$ was allowed to be $2^m$ , a complete window loss of ACKs would cause the receiver to confuse new packets with retransmissions of old packets.

Receiver Window: The receiver's window size ( $R_{\text{size}}$ ) is always exactly $1$ . It only accepts packets in strict sequential order.
Cumulative ACK: GBN uses cumulative acknowledgments. An ACK with number $x$ indicates that all packets up to, but not including, $x$ have been successfully received.
Error Handling: If a packet is lost, all subsequent received packets are out-of-order and are discarded by the receiver. Upon a timeout, the sender must go back and retransmit all outstanding packets starting from $S_f$ .

4.4 The Selective-Repeat (SR) Protocol

The Selective-Repeat protocol optimizes GBN by avoiding unnecessary retransmissions of packets that have already arrived intact.

Receiver Window: The receiver maintains a window size $R_{\text{size}} > 1$ , allowing it to receive and buffer out-of-order packets.
Window Constraints: To prevent overlap ambiguities when ACKs are lost, both the sender and receiver window sizes must satisfy:

$S_{\text{size}} = R_{\text{size}} \le 2^{m-1}$

Individual ACK: The ACK number specifies the exact sequence number of the individual, uncorrupted packet received. It is non-cumulative.
Error Recovery: The sender maintains an independent timer for each outstanding packet. Only the specific packet that timed out is retransmitted.

5. User Datagram Protocol (UDP)

The User Datagram Protocol (UDP) is a minimal, connectionless, unreliable transport protocol. It acts as a direct interface to IP, adding only port addressing and basic error checking.

5.1 UDP Header Format

A UDP packet is called a User Datagram and contains a fixed 8-byte header followed by the payload.

text

 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|          Source Port          |        Destination Port       |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|            Length             |            Checksum           |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                             Data                              |
|                             ...                               |

Source Port (16 bits): Port of the sending application.
Destination Port (16 bits): Port of the receiving application.
Length (16 bits): The total size of the UDP datagram (header + data) in bytes.
Checksum (16 bits): Optional fields in IPv4 (mandatory in IPv6) used to detect bit errors.

5.2 The Checksum and Pseudoheader

To calculate the checksum, UDP prepends a pseudoheader containing critical fields from the IP layer. This binds the transport layer segment to its routing parameters, ensuring that the packet was not misdelivered to the wrong destination host.

text

+--------------------------------------------------------+
|                  Source IP Address                     | (4 bytes)
+--------------------------------------------------------+
|                Destination IP Address                  | (4 bytes)
+------------------------+-------------------------------+
|     Zero (1 byte)      |      Protocol ID (17)         | (2 bytes)
+------------------------+-------------------------------+
|                   UDP Length                           | (2 bytes)
+--------------------------------------------------------+

The checksum is computed by dividing the combined pseudoheader, UDP header, and padded payload into 16-bit blocks, summing them using one's complement arithmetic, and taking the one's complement of the final sum.

6. Transmission Control Protocol (TCP) Concepts

The Transmission Control Protocol (TCP) is a connection-oriented, reliable, stream-oriented, full-duplex transport protocol. It abstractly transforms IP's best-effort delivery into a reliable pipeline.

6.1 TCP Segment Format

TCP packets are called segments. The TCP header typically ranges from 20 to 60 bytes depending on options.

text

 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|          Source Port          |        Destination Port       |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                        Sequence Number                        |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                     Acknowledgment Number                     |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|  Data |           |U|A|P|R|S|F|                               |
| Offset| Reserved  |R|C|S|S|Y|I|            Window             |
|       |           |G|K|H|T|N|N|                               |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|           Checksum            |         Urgent Pointer        |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                    Options (0 to 40 bytes)                    |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

Sequence Number (32 bits): Specifies the stream byte offset of the first data byte in this segment.
Acknowledgment Number (32 bits): The sequence number of the next byte expected. Cumulative.
Data Offset (4 bits): Specifies the length of the TCP header in 32-bit words.
Control Flags (6 bits):
- URG: Urgent pointer field is valid.
- ACK: Acknowledgment field is valid.
- PSH: Push function (deliver data immediately).
- RST: Reset the connection.
- SYN: Synchronize sequence numbers (connection setup).
- FIN: Terminate connection.
Window (16 bits): Defines the size of the receiver's window (rwnd) for flow control.

6.2 Connection Lifecycle

TCP requires stateful handshakes to manage connection creation and destruction.

The Three-Way Handshake (Connection Establishment)

To ensure sequence numbers are synchronized and stale connections are avoided, TCP uses a three-way handshake:

text

Client                                             Server
  |                                                  |
  |--- SYN (seq = x) ------------------------------->| [SYN_RCVD]
  |                                                  |
  |<-- SYN-ACK (seq = y, ack = x + 1) ---------------| [SYN_SENT]
  |                                                  |
  |--- ACK (seq = x + 1, ack = y + 1) -------------->| [ESTABLISHED]

Note: A SYN segment consumes exactly one sequence number, even if it carries zero application payload bytes.

Connection Termination (Four-Way Handshake)

Because TCP is full-duplex, each unidirectional half of a connection must be terminated independently:

text

Client                                             Server
  |                                                  |
  |--- FIN (seq = u) ------------------------------->| [CLOSE_WAIT]
  |<-- ACK (ack = u + 1) ----------------------------| 
  |                                                  |
  |      (Server continues processing data...)       |
  |                                                  |
  |<-- FIN (seq = v) --------------------------------| [LAST_ACK]
  |--- ACK (ack = v + 1) --------------------------->| [CLOSED]

Note: The host executing the active close enters the TIME_WAIT state, maintaining the port mapping for $2 \times \text{MSL}$ (Maximum Segment Lifetime). This ensures that any delayed, duplicate segments from the connection are cleared before a new connection utilizes the same port numbers.

7. Advanced TCP Dynamics: Flow, Error, and Congestion Control

7.1 TCP Flow Control and Sliding Window

TCP utilizes a sliding window for flow control, adjusting the sender's transmission rate based on the receiver's available buffer capacity.

text

TCP Sliding Window Layout:
+--------------------------------------------------------------+
| ... | Sent & ACKed | Sent, No ACK | Can Send | Cannot Send | ...
+--------------------------------------------------------------+
                     ^              ^          ^
                     |              |          |
                   Left           Right       Max
                   Wall           Wall        Edge

To prevent a receiver from shrinking its buffer and causing window conflicts, the following mathematical invariant is enforced:

$\text{new\_ackNo} + \text{new\_rwnd} \ge \text{last\_ackNo} + \text{last\_rwnd}$

Silly Window Syndrome (SWS)

Silly Window Syndrome occurs when TCP segments carry tiny payloads (e.g., $1 \text{ byte}$ of data wrapped in $40 \text{ bytes}$ of header), significantly reducing throughput.

Sender-Created SWS (Nagle's Algorithm): If an application generates data one byte at a time, the sender should transmit the first byte immediately and buffer any subsequent incoming bytes until:
1. A maximum-sized segment (MSS) can be sent.
2. An ACK for the previous segment is received.
Receiver-Created SWS: If an application consumes data slowly, the receiver might repeatedly advertise small window openings (e.g., 1 byte). Two solutions prevent this:
1. Clark's Solution: Force the receiver to advertise a window size of $0$ until there is enough space to fit an entire MSS, or at least half the receiver's buffer is empty.
2. Delayed Acknowledgement: The receiver delays sending an ACK (for up to 500 ms) until more space opens up, preventing the sender's window from sliding forward incrementally.

7.2 TCP Error Control

TCP handles packet corruption and loss through checksums, sliding-window buffering, and dynamic retransmission timers.

Fast Retransmit

If a segment is lost in transit, subsequent in-order packets will cause the receiver to repeatedly send duplicate ACKs (dupACKs) indicating the sequence number of the missing segment. If the sender receives three duplicate ACKs for the same packet, it bypasses the timer and immediately retransmits the missing segment before the timer expires.

text

Sender                                Receiver
  |--- Seg 1 ------------------------>|
  |--- Seg 2 --------> [LOST]         |
  |--- Seg 3 ------------------------>| (Out-of-order, sends ACK 2)
  |<-- ACK 2 -------------------------| (dupACK 1)
  |--- Seg 4 ------------------------>| (Out-of-order, sends ACK 2)
  |<-- ACK 2 -------------------------| (dupACK 2)
  |--- Seg 5 ------------------------>| (Out-of-order, sends ACK 2)
  |<-- ACK 2 -------------------------| (dupACK 3 -> Trigger Fast Retransmit!)
  |--- Seg 2 (Retransmitted) -------->| (Success)

7.3 TCP Congestion Control

To prevent the intermediate routers from dropping packets due to queue exhaustion, TCP maintains a Congestion Window (cwnd). The sender's effective transmission window ( $W$ ) is bounded by:

$W = \min(\text{rwnd}, \text{cwnd})$

The congestion control algorithm is modeled as an state machine with two core phases.

1. Slow Start (Exponential Increase)

Upon initialization or after a packet loss timeout, cwnd is set to $1 \text{ MSS}$ . During the Slow Start phase, cwnd increases exponentially:

$\text{cwnd} \leftarrow \text{cwnd} + 1 \quad (\text{per received ACK})$

This doubling of the window size every RTT continues until cwnd reaches the slow-start threshold (ssthresh).

text

cwnd (MSS)
  ^
  |                                        / (Congestion Avoidance)
  |                                       /
  |                                      /
  |                        [ssthresh]   /
  |                            |_______/
  |                           /
  |                          / (Slow Start)
  |                         /
  |                        /
  |_______________________/_______________________> Time (RTT)

2. Congestion Avoidance (Additive Increase)

Once $\text{cwnd} \ge \text{ssthresh}$ , TCP enters the Congestion Avoidance phase to probe the network's capacity more carefully. During this phase, cwnd increases linearly:

$\text{cwnd} \leftarrow \text{cwnd} + \frac{1}{\text{cwnd}} \quad (\text{per received ACK})$

This increases the window size by approximately $1 \text{ MSS}$ per RTT.

Handling Congestion Events

Timeout Event: If a timeout occurs, TCP assumes severe network congestion. It reacts by updating the variables and restarting the cycle:

$\text{ssthresh} \leftarrow \max\left(\frac{\text{cwnd}}{2}, 2 \cdot \text{MSS}\right)$

$\text{cwnd} \leftarrow 1 \cdot \text{MSS}$

The sender then drops back into the Slow Start phase.

Three Duplicate ACKs (Fast Recovery): If three duplicate ACKs are received, TCP assumes a milder form of congestion where some packets are still getting through. Rather than dropping cwnd to $1$ , it enters Fast Recovery:

$\text{ssthresh} \leftarrow \max\left(\frac{\text{cwnd}}{2}, 2 \cdot \text{MSS}\right)$

$\text{cwnd} \leftarrow \text{ssthresh} + 3 \cdot \text{MSS}$

The sender then continues with the linear increase of Congestion Avoidance.

7.4 TCP Timers and RTT Calculations

TCP dynamically computes its Retransmission Timeout (RTO) using continuous measurements of the round-trip time.

RTT Smoothing and Deviation

To filter out packet delay spikes, TCP calculates a smoothed RTT ( $RTT_S$ ) and an RTT deviation ( $RTT_D$ ):

First Measurement:

$RTT_S \leftarrow RTT_M$

$RTT_D \leftarrow \frac{RTT_M}{2}$

Subsequent Measurements:

$RTT_S \leftarrow (1 - \alpha)RTT_S + \alpha RTT_M$

$RTT_D \leftarrow (1 - \beta)RTT_D + \beta |RTT_S - RTT_M|$

Standard filter constants: $\alpha = 0.125 \ (1/8)$ and $\beta = 0.25 \ (1/4)$ .

Retransmission Timeout (RTO) Formulation

Using these smoothed metrics, the retransmission timeout value is computed as:

$\text{RTO} = RTT_S + 4 \times RTT_D$

Karn's Algorithm

When a packet is retransmitted and an ACK is eventually returned, it is impossible to determine whether the ACK corresponds to the original transmission or the retransmitted packet. To prevent these ambiguous samples from corrupting the RTT estimate, Karn's Algorithm dictates that any RTT sample from a retransmitted segment must be discarded and excluded from the $RTT_S$ and $RTT_D$ calculations. Instead, the RTO is temporarily doubled for each consecutive retransmission timeout.

Summary

The transport layer bridges host-to-host network routing and application process delivery using port numbers and socket endpoints.
Sliding-window protocols enable reliable, high-throughput delivery over lossy links. GBN uses a receiver window of $1$ and cumulative ACKs, while SR uses larger receiver buffers and selective acknowledgements.
UDP provides a simple, connectionless service with low overhead, checking packet integrity with a pseudoheader checksum.
TCP offers a reliable connection-oriented stream service, utilizing a three-way handshake for state management.
TCP combines Nagle’s algorithm, sliding window flow control, fast retransmit, and dynamic congestion control algorithms (Slow Start and Congestion Avoidance) to optimize throughput while protecting the network from congestion collapse.

Assessed progress

Transport-Layer Services and Concepts

Key Concepts

Process-to-Process Communication

Sliding Window Protocols

Silly Window Syndrome

Three-Way Handshake

Congestion Control

Quick Check

Computer Networks

Computer Networks