# TCP Working: 3-Way Handshake & Reliable Communication Explained

## **What is TCP and why is it needed?**

TCP (Transmission Control Protocol) is a transport-layer protocol that makes sure data sent between two machines (like your browser and a web server) is:

* delivered reliably (nothing silently lost),
    
* received in order, and
    
* free of duplication.
    

Think of TCP like a **registered courier service**: it tracks every parcel, confirms delivery, and asks for re-delivery if something goes missing. Without TCP, data would be “fire-and-forget” (like shouting across a stadium) — fast but unreliable.

---

## **Problems TCP is designed to solve**

Without rules, these problems appear:

* **Packet loss** — packets may disappear in the network.
    
* **Out-of-order delivery** — packets may take different routes and arrive shuffled.
    
* **Duplication** — the same packet could arrive twice.
    
* **Network congestion** — too much traffic leads to dropped packets and delays.  
    TCP provides mechanisms (handshake, sequence numbers, ACKs, retransmission, flow & congestion control) to handle all of the above.
    

---

## **The 3-Way Handshake — what it is (high level)**

Before any real data flows, TCP establishes a connection with a **3-step handshake** so both sides agree:

1. Client asks to open a connection (SYN).
    
2. Server agrees and also signals readiness (SYN-ACK).
    
3. Client confirms (ACK).  
    After that, they can exchange data.
    

Analogy: Client knocks on the door (SYN). Server opens a little and says “I hear you, I’m ready” (SYN-ACK). Client says “Great, I’m in” (ACK). Now they start talking.

---

## **Step-by-step with a tiny example**

Let’s use simple sequence numbers to follow the handshake:

1. **Client → Server:** `SYN, Seq = 1000`  
    (Client picks an initial sequence number 1000, meaning "my first byte will have index 1001".)
    
2. **Server → Client:** `SYN-ACK, Seq = 5000, Ack = 1001`  
    (Server picks ISN 5000 and acknowledges client’s SYN by setting `Ack = client_ISN + 1`.)
    
3. **Client → Server:** `ACK, Seq = 1001, Ack = 5001`  
    (Client acknowledges server’s SYN by `Ack = server_ISN + 1`.)
    

Connection is now established — both sides know each other’s sequence space and can send data.

**ASCII diagram (handshake):**

```plaintext
Client                        Server
  | ------ SYN (Seq=1000) ---> |
  | <--- SYN-ACK (Seq=5000, Ack=1001) --- |
  | ------ ACK (Seq=1001, Ack=5001) ---> |
(connection established)
```

---

## **How data transfer works in TCP (high level)**

Once established, data is sent in **segments**. Each segment carries:

* a **sequence number** (so the receiver can order bytes), and
    
* the receiver sends **ACKs** to tell the sender which data it has received.
    

Key ideas:

* **Sequence numbers** identify byte positions in the stream.
    
* **Acknowledgements (ACKs)** are usually cumulative (`Ack = next expected byte`).
    
* **Sliding window**: receiver advertises a window size — how many bytes it can accept without further ACKs. This controls flow (prevents overwhelming the receiver).
    

**Example flow (simplified):**

```plaintext
Client sends bytes 1001–2000 (Seq=1001, Len=1000)
Server receives and replies: ACK Ack=2001  (meaning "I got up to 2000; next I expect 2001")
```

---

## **How TCP ensures reliability, order, and correctness**

1. **Sequence numbers** let the receiver reorder out-of-order segments.
    
2. **Cumulative ACKs** tell the sender what has been received; missing bytes are detected as gaps.
    
3. **Retransmission timers:** if the sender does not get an ACK within a timeout, it retransmits the unacknowledged data.
    
4. **Fast retransmit:** multiple duplicate ACKs for the same byte can trigger a faster retransmit without waiting the full timeout.
    
5. **Flow control (windowing):** the receiver tells the sender how much data it can accept (receiver’s advertised window).
    
6. **Congestion control (TCP algorithms):** TCP adjusts its send rate (window) based on network conditions to avoid overwhelming the network (slow start, congestion avoidance, etc.).
    
7. **Checksums:** every TCP segment has a checksum to detect corruption; corrupted segments are discarded and will be retransmitted.
    

All these together make TCP **reliable and ordered**.

---

## **Handling packet loss (simple)**

If a segment is lost:

* Receiver will not ACK the missing bytes (or will ACK up to the last contiguous byte it has).
    
* Sender notices missing ACKs (or sees duplicate ACKs) and retransmits the missing segment.
    
* Once the missing segment arrives, receiver can deliver bytes in order to the application.
    

---

## **Connection termination (closing a TCP connection)**

TCP uses **FIN** and **ACK** to close a connection. Commonly this is a **four-step** process (each side closes independently):

1. **Client → Server:** `FIN, Seq = X` (client has finished sending)
    
2. **Server → Client:** `ACK, Ack = X+1` (server acknowledges client's FIN)
    
3. **Server → Client:** `FIN, Seq = Y` (server finishes sending)
    
4. **Client → Server:** `ACK, Ack = Y+1` (client acknowledges server's FIN)
    

After the final ACK, the connection transitions to TIME\_WAIT (on the side that closed first) to ensure last packets are handled and late duplicates are discarded.

**ASCII diagram (close):**

```plaintext
Client                        Server
  | ------ FIN (Seq=X) ----->  |
  | <----- ACK (Ack=X+1) ----- |
  | <----- FIN (Seq=Y) ------- |
  | ------ ACK (Ack=Y+1) --->  |
(connection closed)
```

**Why TIME\_WAIT?** To ensure any delayed packets from the old connection are not mistaken for a new connection if ports/sequence numbers are reused.

---

## **Quick summary / cheat-sheet**

* **TCP = reliable, ordered, connection-oriented.**
    
* **3-way handshake** (SYN, SYN-ACK, ACK) establishes a connection and synchronizes sequence numbers.
    
* **Data transfer** uses sequence numbers, ACKs, sliding windows, retransmission timers, and checksums.
    
* **Reliability** is achieved via ACKs, retransmission, and ordering.
    
* **Close** uses FIN/ACK (four-step) and TIME\_WAIT to safely terminate.
    

---

## **Small analogies recap**

* **3-way handshake** = polite knocking + handshake before entering.
    
* **Sequence + ACK** = numbered pages of a book; receiver tells which page it expects next.
    
* **Retransmission** = resend a page if the courier lost it.
    
* **Flow control** = receiver saying “send me 3 pages at a time” so it can keep up.
    
* **Congestion control** = courier slowing down deliveries when the road is crowded.