TCP Working: 3-Way Handshake & Reliable Communication

TL;DR

TCP (Transmission Control Protocol) is a transport-layer protocol that ensures reliable data transfer. It starts communication with a 3-way handshake to establish a connection, then guarantees data is delivered in order, without loss, and with error correction throughout the communication.

TCP establishes a connection using a 3-way handshake (SYN → SYN-ACK → ACK), ensuring both the client and server are ready to communicate. Once the connection is set, TCP guarantees reliable communication by delivering data in order, detecting errors, retransmitting lost packets, and managing data flow and congestion. This ensures accurate, ordered, and complete data delivery, providing dependable communication over the internet.

Imagine sending data across a network with no rules, no confirmation, and no guarantee that anything arrives correctly. Packets could be lost, duplicated, or arrive in the wrong order, leaving applications confused and data incomplete. To prevent this chaos, the internet relies on structured communication protocols. TCP addresses these problems by defining clear rules for connection setup and data transfer, beginning with the 3-way handshake and continuing with mechanisms that ensure reliable, ordered, and error-free communication between devices.

TCP

What is TCP?

Transmission Control Protocol (TCP) is a key, connection-oriented networking protocol that ensures reliable, ordered, and error-checked delivery of data between applications on an IP network. Operating at the transport layer, it splits data into packets, manages their transmission, resends any lost data, and checks data integrity through a "three-way handshake."

Key Characteristics of TCP:

• Connection-Oriented: TCP requires a three-way handshake before starting data transmission to ensure a reliable connection.

• Reliable: TCP guarantees data delivery, maintains the correct packet order, and detects errors with retransmission if necessary.

• Higher Overhead: TCP uses larger headers (at least 20 bytes) and extra control mechanisms, which can lead to increased latency compared to UDP.

• Flow & Congestion Control: Adjusts data transmission rate to prevent overwhelming the receiver or the network.

Why it is needed?

TCP is needed because the internet itself is unreliable—packets can be lost, duplicated, or arrive out of order. TCP solves these problems by establishing a connection, detecting errors, retransmitting lost data, and managing network congestion. This makes TCP essential for applications where data accuracy and completeness matter, such as web browsing (HTTP/HTTPS), email, and file transfers.

Problems TCP is designed to solve

• Packet Loss:
  Data packets can be lost during transmission; TCP detects this and retransmits missing packets.

• Out-of-Order Delivery:
  Packets may arrive in the wrong sequence; TCP reorders them correctly before delivering data to the application.

• Data Corruption:
  Packets can become corrupted; TCP uses error checking to detect and discard bad data.

• Network Congestion:
  Too much data sent too quickly can overwhelm networks; TCP adjusts transmission speed to prevent congestion.

• Flow Control:
  A fast sender may overwhelm a slow receiver; TCP manages data flow to match the receiver’s capacity.

• Unreliable Underlying Network:
  Since IP does not guarantee delivery, TCP adds reliability on top of it.

In short, TCP ensures reliable, orderly, and efficient communication over an otherwise unreliable network.

TCP 3-Way Handshake

The TCP 3-way handshake is a foundational process used to establish a reliable, connection-oriented session between a client and a server before data transfer. It involves three steps—SYN, SYN-ACK, and ACK—to synchronize sequence numbers and initialize connection parameters, ensuring both parties are ready for full-duplex communication. This process ensures both sides are ready to communicate and agree on initial settings.

Steps of the TCP 3-Way Handshake

1. SYN (Synchronize): The client initiates the connection by sending a TCP segment with the SYN flag set to 111, a random initial sequence number (ISNcap I cap S cap N𝐼𝑆𝑁), and other parameters (e.g., maximum segment size).

2. SYN-ACK (Synchronize-Acknowledgment): The server receives the SYN, sets the SYN and ACK flags to 111, and sends a response. This segment acknowledges the client's SYN (using the client's sequence number +1positive 1+1) and sends its own initial sequence number.

3. ACK (Acknowledgment): The client acknowledges the server's SYN-ACK by sending a segment with the ACK flag set to 111. The sequence number is incremented, and the connection is officially established (ESTABLISHED state).

Key Points to remember

• Purpose: To synchronize sequence numbers, ensure both sides can communicate, and prevent old, delayed packets from interfering with a new connection.

• Flags: SYN (synchronize) and ACK (acknowledge) are critical TCP header flags.

• Sequence Numbers: Random numbers used to order packets and ensure reliable data delivery.

After this process, the client and server can begin exchanging data in both directions simultaneously (full-duplex).

Data Transfer in TCP

The data transfer in TCP works in the following stages:

1. Connection Established:
   Before any data is sent, TCP establishes a connection using the 3-way handshake.

2. Data Segmentation:
   The data is broken into smaller units called segments, each with a sequence number.

3. Ordered Transmission:
   Each data segment is assigned a sequence number, allowing the receiver to reassemble packets in the correct order, even if they arrive out of sequence.

4. Acknowledgments (ACKs):
   TCP uses acknowledgments (ACKs) to confirm successful delivery of data. If packets are lost, TCP detects the loss and retransmits them.

5. Retransmission:
   If a data segment is lost, delayed, or corrupted, TCP detects the issue using missing acknowledgments or checksum errors and retransmits the segment to ensure complete and accurate delivery.

6. Flow Control:
   TCP prevents overwhelming the receiver by adjusting the data transmission rate based on the receiver’s capacity.

7. Congestion Control:
   TCP monitors network conditions and dynamically reduces or increases the sending rate to avoid congestion.

Together, these mechanisms ensure that data is delivered accurately, in sequence, and without loss, even over unreliable networks.

Packet Loss and Retransmission

In above diagram, the sender transmits data segments in order: Segment 1, Segment 2, Segment 3, Segment 4, and Segment 5.

• Packet Loss Occurs:
  Segment 2 is lost in transit and never reaches the receiver.

• Receiver Detects the Gap:
  The receiver successfully gets Segment 1, then receives Segment 3, 4, and 5 out of order.
  Since TCP expects data in sequence, the receiver cannot move forward without Segment 2.

• Duplicate ACKs Sent:
  For each out-of-order segment received (Segments 3, 4, and 5), the receiver sends an ACK repeatedly requesting Segment 2.
  These are called duplicate ACKs.

• Fast Retransmit Triggered:
  When the sender receives 3 duplicate ACKs for Segment 2, it assumes that Segment 2 was lost (not just delayed).

• Retransmission:
  The sender immediately retransmits Segment 2 without waiting for a timeout.

Why this matters?
This mechanism, known as Fast Retransmit, allows TCP to quickly recover from packet loss, improving performance and maintaining reliable and ordered data delivery.

There are other algorithms other than Fast Retransmit for Packet Loss & Retransmission like Fast Recovery, RTO (Retransmission Time Out), RACK (Recent acknowledgment), Tail Loss Probe (TLP), Selective Acknowledgments (SACK).

TCP Connection Termination (TCP Teardown)

A TCP connection is closed using a 4-way handshake process, ensuring both sides (client and server) agree to terminate the connection and finish sending data. The initiator sends a FIN (Finish) packet, which is acknowledged (ACK) by the receiver, followed by a FIN from the receiver and a final ACK.

4-Way Handshake Process:

1. FIN (Step 1): The initiator (client or server) sends a FIN segment, indicating it has no more data to send, moving to the FIN-WAIT-1 state.

2. ACK (Step 2): The receiver acknowledges the FIN with an ACK packet. The receiver may still send data, and the initiator is now in the FIN-WAIT-2 state.

3. FIN (Step 3): Once the receiver is finished sending its own data, it sends its own FIN segment to the initiator.

4. ACK (Step 4): The initiator acknowledges the receiver's FIN with an ACK packet. The connection is now closed.

Conclusion

TCP and the 3-way handshake are essential for reliable internet communication. TCP ensures data is delivered correctly and in order, even on unreliable networks. The 3-way handshake establishes a trusted connection before data exchange, ensuring both sides are ready. Together, they enable dependable data transfer for applications needing accuracy. Understanding TCP is crucial for networking basics, troubleshooting, and designing reliable systems.

If you enjoyed this article, check out my other blogs on this profile.

🔗 Connect with me:
LinkedIn | GitHub | X (Twitter)