Understanding TCP/UDP Packet Fragmentation, MSS/MTU, Nagle Algorithm, and Sticky Packet Issues

Why Data Slicing Is Needed

Application‑level messages are encapsulated with headers at each layer of the four‑layer network model. When a message reaches the transport layer, TCP adds a header and splits the payload into segments whose size is limited by the Maximum Segment Size (MSS). The underlying network pipe has a maximum transmission unit (MTU) provided by the data‑link layer, typically 1500 bytes; if a packet exceeds this size it must be fragmented.

MTU vs. MSS

MTU (Maximum Transmission Unit) : the largest packet size the network interface can transmit in one piece, usually 1500 bytes.

MSS (Maximum Segment Size) : the largest TCP payload size (excluding TCP header and options). For a typical MTU of 1500 bytes, MSS = 1500 − 20 (IP header) − 20 (TCP header) = 1460 bytes.

What Is a Sticky Packet?

Because TCP is a byte‑stream protocol, the receiver cannot inherently determine where one logical message ends and the next begins. If the sender transmits "李东" and "亚健康终结者" separately, the receiver may read the bytes as "李东亚" and "健康终结者", mistakenly treating them as a single message—this is the sticky‑packet problem.

Why Sticky Packets Occur

Sticky packets arise from the lack of explicit message boundaries in a TCP stream. When the application does not add boundary markers or length fields, the receiver cannot reliably split the incoming byte stream into the original messages.

The Nagle Algorithm

The Nagle algorithm tries to reduce the number of small packets by buffering data until either the buffered data reaches MSS or a timeout (typically 200 ms) expires. While it can improve network efficiency, it also contributes to sticky‑packet scenarios because small messages are delayed and may be combined.

Disabling Nagle Does Not Eliminate Sticky Packets

Even with TCP_NODELAY = 1 , if the receiving application does not promptly read from the TCP receive buffer, multiple messages can still be concatenated in the buffer, leading to sticky packets.

How to Prevent Sticky Packets

Insert a special delimiter (e.g., a unique byte sequence) at the start or end of each message.

Include a length field in the message header so the receiver knows exactly how many bytes belong to a message.

Combine delimiters with length fields and optional checksums/CRCs to verify message integrity.

Does UDP Have Sticky Packets?

UDP is a datagram‑oriented protocol; each send operation corresponds to a distinct packet, and the UDP header contains a length field, so the receiver can directly identify message boundaries without sticky‑packet issues.

Why UDP Includes a Length Field

The length field is useful when the UDP payload is placed in a socket buffer; it tells the application how many bytes constitute a complete datagram, preventing ambiguity similar to TCP’s sticky‑packet problem.

Does the IP Layer Have Sticky‑Packet Problems?

IP may fragment large packets based on MTU, but it only transports raw data and does not interpret message boundaries, so it does not cause sticky packets.

Summary

TCP transmits a continuous byte stream; without explicit boundaries, sticky packets can occur.

The Nagle algorithm influences packet timing but disabling it does not fully solve sticky‑packet issues.

UDP, being datagram‑based, does not suffer from sticky packets.

IP fragmentation does not introduce sticky packets because IP does not care about message semantics.

Properly framing messages with delimiters or length fields (and optional checksums) is the reliable way to avoid sticky‑packet problems.