Connection-Oriented Transport

The core mechanism for establishing a reliable connection. It's a three-step process: 1) SYN - The client sends a synchronization packet. 2) SYN-ACK - The server acknowledges and synchronizes. 3) ACK - The client acknowledges, finalizing the connection. This ensures both parties are ready to communicate.

Guarantees that all data packets arrive intact and in the correct order. Key mechanisms include:

• Sequence Numbers: Track the order of packets.
• Acknowledgements (ACKs): Confirm receipt of packets.
• Retransmission: Lost or corrupted packets are automatically resent.
• Flow Control: Prevents a fast sender from overwhelming a slow receiver.

A controlled process to gracefully close the connection, ensuring no data is lost. Typically uses a four-way handshake: 1) FIN from the closing party. 2) ACK from the other. 3) FIN from the other party. 4) Final ACK. This allows both sides to finish transmitting remaining data.

The protocol maintains the state of the connection throughout its lifecycle. Both endpoints track information such as:

• Sequence and acknowledgement numbers.
• Receive and send buffers.
• Connection status (LISTEN, SYN-SENT, ESTABLISHED, etc.). This statefulness is fundamental to providing reliability and order guarantees.

The reliability guarantees come with inherent overhead:

• Latency: Handshake and acknowledgement delays.
• Bandwidth: Header size and control packets (ACKs).
• Resource Usage: Memory for connection state on both ends. This makes TCP less suitable than UDP for real-time applications like VoIP or gaming where speed is prioritized over perfect reliability.

Connection-oriented protocols like TCP maintain state (e.g., sequence numbers, window sizes) for each connection, creating a larger attack surface than stateless protocols. This state must be managed, secured, and garbage-collected, introducing complexity. Attackers can exploit this with SYN flood attacks, exhausting server resources by initiating many half-open connections.

The core trade-off: guaranteed, in-order delivery versus speed. Mechanisms like acknowledgments (ACKs), retransmissions, and flow control ensure data integrity but add round-trip time (RTT) latency. For real-time applications (e.g., gaming, VoIP), this can be detrimental, often leading to the use of UDP with application-layer reliability instead.

Because connections are identified by a predictable tuple (source/dest IP/port, sequence numbers), they are susceptible to session hijacking and IP spoofing attacks if not properly secured. Modern mitigations include:

• Using cryptographic protocols like TLS/SSL over TCP.
• Employing robust sequence number randomization.
• Implementing network-level filters against spoofed packets.

A fundamental performance and resilience trade-off. In TCP, if a single packet is lost or arrives out-of-order, subsequent packets in the stream are blocked until the missing data is retransmitted. This creates vulnerability to targeted packet loss attacks and degrades performance on unreliable networks, a key reason QUIC was developed to mitigate this at the transport layer.

Connection-oriented protocols are inherently less susceptible to amplification attacks (like DNS or NTP reflection) because they require a completed handshake before data transfer. This contrasts with connectionless UDP, where an attacker can spoof a source IP and trigger a large response to a victim. The 3-way handshake acts as a built-in, though not foolproof, mitigation.

The stateful nature creates a single point of failure: the connection endpoint. If one endpoint fails (e.g., server crash, state table corruption), the entire connection is lost and must be re-established from scratch. This contrasts with datagram-based systems where individual messages are independent. Solutions involve connection pooling, failover mechanisms, and state replication, adding system complexity.

The process used by TCP to establish a reliable connection before data transfer begins.

• SYN: Client sends a synchronization packet.
• SYN-ACK: Server acknowledges and synchronizes.
• ACK: Client acknowledges, completing the handshake. This process synchronizes sequence numbers and confirms both parties are ready to communicate, ensuring a stateful connection.

A mechanism that prevents a fast sender from overwhelming a slow receiver. In TCP, this is achieved using a sliding window protocol and the receive window (rwnd) field in packet headers. The receiver advertises its available buffer space, and the sender adjusts its transmission rate accordingly, preventing buffer overflow and data loss.

Algorithms that prevent network collapse by regulating data sent into the network. TCP uses mechanisms like:

• Slow Start: Exponentially increases send rate at start.
• Congestion Avoidance: Additive increase after a threshold.
• Fast Retransmit & Recovery: Responds to duplicate ACKs. These algorithms dynamically adjust the congestion window (cwnd) based on packet loss, acting as a feedback loop for network stability.

The primary alternative to connection-oriented protocols. The User Datagram Protocol (UDP) is stateless and sends independent datagrams without prior handshake, ordering, or guaranteed delivery. It's used where low latency is prioritized over reliability, such as in DNS queries, VoIP, and real-time gaming. Contrasts with TCP's stateful, reliable model.

A core distinction in network communication.

• Stateful (Connection-Oriented): The protocol (e.g., TCP) maintains connection state (sequence numbers, window sizes) on both ends for the session's duration.
• Stateless (Connectionless): The protocol (e.g., UDP) treats each packet independently; the server holds no persistent information about the client between requests. This impacts scalability, reliability, and overhead.