02_tcp_and_udp

TCP vs UDP

Transmission Control Protocol (TCP) and User Datagram Protocol (UDP) are foundational Internet protocols that operate on top of IP (Internet Protocol). They determine how data is packaged, addressed, transmitted, and received between devices. TCP prioritizes reliability and ordered delivery. UDP focuses on speed and efficiency with less overhead. Both protocols have unique benefits, and choosing one often depends on the requirements for data integrity, latency, and network conditions.

TCP (Transmission Control Protocol)

TCP is a connection-oriented protocol that ensures packets arrive in sequence. It provides reliability mechanisms like acknowledgments, retransmissions, and congestion control. This makes it ideal for scenarios where missing or out-of-order data is unacceptable, such as file transfers or loading web pages.

How TCP Works

The TCP process begins with a three-way handshake to establish a connection before sending payload data. The ASCII diagram below gives a high-level view of that handshake between a client and a server:

Client                           Server
   |                                |
   |    1. SYN (Synchronize)       |
   |------------------------------->|
   |                                |
   |    2. SYN + ACK (Acknowledge) |
   |<-------------------------------|
   |                                |
   |    3. ACK                     |
   |------------------------------->|
   |                                |
   |   Connection Established       |
   |<==============================>|

After the connection is established, data is sent in segments. TCP ensures data integrity by requiring the receiver to acknowledge each segment. If an acknowledgment is not received, the segment is retransmitted.

Features of TCP

Connection-Oriented Communication: A handshake is required to initialize and tear down the connection.
Ordered Delivery: Packets arrive in the correct sequence or get reassembled in the proper order.
Reliability: Acknowledgments, timeouts, and retransmissions ensure packets are not lost.
Flow and Congestion Control: Mechanisms adjust the sending rate based on network conditions.

Code Example: Simple TCP Server in Python

import socket
 
HOST = '127.0.0.1'
PORT = 5000
 
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))
    s.listen()
    print("TCP server listening on port", PORT)
    
    conn, addr = s.accept()
    with conn:
        print("Connected by", addr)
        data = conn.recv(1024)
        print("Received:", data.decode())
        conn.sendall(b"Hello from TCP server!")

After running this code, the server binds to localhost on port 5000 and waits for a connection.
A client can connect using telnet or netcat, send data, and receive a response.

Typical TCP Use Cases

Web browsing (HTTP/HTTPS).
File transfers (FTP or SCP).
Email protocols (SMTP, IMAP, POP3).
Database connections that require guaranteed delivery of queries and results.

UDP (User Datagram Protocol)

UDP is a connectionless protocol that sends packets called datagrams without establishing a formal channel. It avoids the overhead of handshakes, acknowledgments, and ordered delivery. This makes it well-suited for real-time applications where speed matters more than absolute reliability.

How UDP Works

Communication takes place by sending datagrams to a specified IP and port without any pre-negotiated connection. The following ASCII diagram illustrates how a client and server might exchange data over UDP:

Client                               Server
   |                                    |
   |   1. UDP Datagram (Data)          |
   |----------------------------------->|
   |                                    |
   |   2. UDP Datagram (Response)      |
   |<-----------------------------------|
   |                                    |
   |   (No handshake or guaranteed      |
   |    arrival order)                  |

Packets may arrive out of sequence, or they might be lost. There is no built-in retry mechanism. UDP relies on the application layer to handle or ignore such issues.

Features of UDP

Connectionless Communication: No handshake or session establishment.
No Guaranteed Delivery: Datagrams can be lost or arrive out of order.
Low Overhead: Faster than TCP due to minimal extra fields in headers and no retransmissions by default.
Suitable for Broadcast or Multicast: Commonly used in local network discoveries or streaming.

Code Example: Simple UDP Server in Python

import socket
 
HOST = '127.0.0.1'
PORT = 5001
 
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
    s.bind((HOST, PORT))
    print("UDP server listening on port", PORT)
    
    while True:
        data, addr = s.recvfrom(1024)
        print("Received from", addr, ":", data.decode())
        s.sendto(b"Hello from UDP server!", addr)

This UDP server awaits datagrams on port 5001.
A client can send datagrams using netcat (nc -u 127.0.0.1 5001) and read responses.

Typical UDP Use Cases

Live video or audio streaming where some packet loss is tolerable.
Online gaming with real-time position updates.
Domain Name System (DNS) lookups for speed.
Internal network broadcast or multicast services.

Comparing TCP and UDP

Aspect	TCP	UDP
Connection Model	Connection-oriented (3-way handshake)	Connectionless
Reliability	Guaranteed delivery with retransmissions	No guarantees, best-effort
Ordering	Packets arrive in sequence or are reordered	Packets can arrive in any order
Overhead	Higher overhead for handshakes and acknowledgments	Lower overhead, lightweight headers
Speed	Slower than UDP due to control mechanisms	Usually faster but less reliable
Typical Use Cases	Web requests, file transfers, database access	Streaming media, online games, DNS

Performance and Throughput

A simplified throughput equation can be used for TCP to illustrate the effects of congestion control:

Throughput_tcp ≈ (Window_size / RTT)

Window_size is how many bytes can be sent before waiting for an acknowledgment, and RTT is the round-trip time for a segment to reach the receiver and for an acknowledgment to come back. If packet loss is high, the window shrinks and throughput drops. UDP does not have a built-in window mechanism, so throughput depends on application-layer strategies and network capacity.

Security Considerations

Both TCP and UDP can run over secure channels like TLS or DTLS.

TCP over TLS: Often known as HTTPS (for web traffic).
UDP over DTLS: Provides security for datagram-based traffic, such as secure VoIP.

Vault 📚

Explorer