backend-basic-concepts

A guid of TCP and UDP protocol for backend engineer

9 min read
#backend-basic-concepts

In the world of networking, the Transmission Control Protocol (TCP) and User Datagram Protocol (UDP) play pivotal roles. While they both sit at Layer 4 of the OSI model and facilitate communication between systems, their use cases, features, and approaches differ significantly. Let's delve into the intricacies of these protocols.

Understanding UDP

The User Datagram Protocol (UDP) is a lightweight and straightforward protocol designed for fast and stateless communication. In UDP, the connection process is simple and straightforward. The client sends a datagram (packet) to the server's IP address and port number. Unlike TCP, there is no handshake or acknowledgment mechanism. The server, upon receiving the packet, processes it and optionally sends a response back to the client using the client's IP address and source port specified in the received datagram. This simplicity eliminates latency but provides no guarantee of delivery or order.

Here's what makes UDP unique:

  1. Stateless Protocol: UDP doesn’t maintain a connection between the client and server. This statelessness simplifies communication and reduces overhead.
  2. Minimal Header Size: UDP’s header is only 8 bytes, making it ideal for applications where speed and efficiency matter.
  3. No Guarantee of Delivery: Unlike TCP, UDP doesn’t ensure that data packets arrive at their destination. If a packet is lost, it’s up to the application layer to handle retransmissions.
  4. Typical Use Cases:
    • Video Streaming: Loss of a few frames doesn’t disrupt the user experience.
    • Gaming: Speed is prioritized over guaranteed delivery.
    • DNS Queries: Quick resolution of hostnames to IPs.
  5. Potential Drawbacks:
    • Lack of reliability can cause issues in scenarios where data integrity is critical.
    • Vulnerable to attacks like DNS poisoning due to its simplicity and lack of security measures.

implementation of UDP in nodejs

Lets make a simple UDP server in nodejs which listens on port 41234. Server receives a message from the client and logs it and then server send a message back to client.

  1. dgram module used to create UDP server in nodejs.
const dgram = require('dgram');
const server = dgram.createSocket('udp4');

dgram.createSocket('udp4') creates a UDP socket that uses IPv4. You could use 'udp6' for IPv6.

  1. implement server to handle request
server.on('message', (msg, rinfo) => {
  console.log(`Server received: ${msg} from ${rinfo.address}:${rinfo.port}`);
  
  const response = `Hello, ${rinfo.address}:${rinfo.port}`;
  server.send(response, rinfo.port, rinfo.address, (err) => {
    if (err) console.error(err);
    else console.log('Response sent to client');
  });
});
  • server.on('message'): This event is triggered whenever the server receives a message.
    • msg: Contains the message received from the client.
    • rinfo: Contains information about the client, such as its address and port.
  • server.send(): Sends a response back to the client.
    • response: The message to send.
    • rinfo.port: The port on which the client is listening.
    • rinfo.address: The client's IP address.
    • Callback to handle errors (optional).
  1. Bind the server to port 41234 and start listening on port
server.on('listening', () => {
  const address = server.address();
  console.log(`Server listening on ${address.address}:${address.port}`);
});

server.bind(41234);
  • server.on('listening'): Triggered when the server starts listening for incoming messages.
    • server.address(): Returns the address (IP and port) where the server is bound.
  • server.bind(41234): Binds the server to port 41234. It starts listening for incoming UDP packets on this port.
  1. initialize the client code
const dgram = require('dgram');
const client = dgram.createSocket('udp4');

const message = Buffer.from('Hello, Server!');
  • dgram.createSocket('udp4'): Creates a UDP socket for the client.
  • Buffer.from(): Converts the string Hello, Server! into a binary format (Buffer), as UDP expects binary data.
  1. send message from client to sever
client.send(message, 41234, '127.0.0.1', (err) => {
  if (err) console.error(err);
  else console.log('Message sent to server');
});
  • client.send(): Sends a UDP packet to the server.
    • message: The binary data to send (here, the greeting message).
    • 41234: The port on which the server is listening.
    • 127.0.0.1: The server's IP address (localhost in this case).
    • Callback to handle errors.
client.on('message', (msg, rinfo) => {
  console.log(`Client received: ${msg} from ${rinfo.address}:${rinfo.port}`);
  client.close();
});
  • client.on('message'): Triggered when the client receives a response from the server.
    • msg: Contains the server's response.
    • rinfo: Contains information about the server (address and port).
  • client.close(): Closes the client after receiving the response. Since UDP is connectionless, the client doesn’t need to maintain a persistent connection.

UDP Server code:

const dgram = require('dgram');
const server = dgram.createSocket('udp4');

server.on('message', (msg, rinfo) => {
  console.log(`Server received: ${msg} from ${rinfo.address}:${rinfo.port}`);
  
  // Responding to the client
  const response = `Hello, ${rinfo.address}:${rinfo.port}`;
  server.send(response, rinfo.port, rinfo.address, (err) => {
    if (err) console.error(err);
    else console.log('Response sent to client');
  });
});

server.on('listening', () => {
  const address = server.address();
  console.log(`Server listening on ${address.address}:${address.port}`);
});

// Bind the server to a port
server.bind(41234);

UDP client code:

const dgram = require('dgram');
const client = dgram.createSocket('udp4');

const message = Buffer.from('Hello, Server!');

// Send message to the server
client.send(message, 41234, '127.0.0.1', (err) => {
  if (err) console.error(err);
  else console.log('Message sent to server');
});

// Listen for responses from the server
client.on('message', (msg, rinfo) => {
  console.log(`Client received: ${msg} from ${rinfo.address}:${rinfo.port}`);
  client.close(); // Close the client after receiving a response
});

We dont need client code to test our server, we can directly use nc(Netcat) command, To send a UDP packet, you can use the following syntax:

echo "Your message" | nc -u <destination_host> <port>

Understanding TCP

TCP (Transmission Control Protocol) is one of the main protocols in the Internet Protocol (IP) suite. It is widely used for establishing and managing reliable, ordered, and error-checked communication between devices over a network. TCP operates at the Transport Layer (Layer 4) of the OSI model and is fundamental for many network applications, such as web browsing, email, and file transfers.

Key Features of TCP:

  1. Connection-Oriented:
    • TCP establishes a connection between two devices before data transfer begins.
    • This is achieved through a process called the three-way handshake.
  2. Reliable Data Transfer:
    • TCP ensures that all data packets are delivered to the recipient in the correct order.
    • Lost or corrupted packets are retransmitted.
  3. Flow Control:
    • TCP prevents overwhelming the receiver by controlling the data flow based on the receiver's capacity.
  4. Error Checking:
    • TCP includes mechanisms to detect errors in transmitted data and request retransmissions if necessary.
  5. Segmentation and Reassembly:
    • Large chunks of data are divided into smaller packets for transmission and reassembled at the destination.
  6. Congestion Control:
    • TCP dynamically adjusts the rate of data transfer based on network conditions to avoid congestion.

Connection establishment of TCP:

In TCP (Transmission Control Protocol), a connection between the server and client is established using a process called the three-way handshake. This handshake ensures that both the client and server are synchronized and ready to exchange data reliably. Here's how it works:

Steps of the Three-Way Handshake

  1. SYN (Synchronize):
    • The client starts by sending a SYN packet to the server.
    • This packet contains an initial sequence number (e.g., X), which indicates the starting point for communication.
    • The client essentially says, "I want to start a connection, and my starting sequence number is X."
Client → Server: SYN (Seq = X)
  1. SYN-ACK (Synchronize-Acknowledge):
    • The server responds with a SYN-ACK packet.
    • This packet acknowledges the client's SYN (ACK = X+1) and sends the server's own starting sequence number (Y).
    • The server says, "I acknowledge your request, and here’s my starting sequence number Y."
Server → Client: SYN-ACK (Seq = Y, ACK = X+1)
  1. ACK (Acknowledge):
    • The client sends an ACK packet back to the server.
    • This packet acknowledges the server’s SYN (ACK = Y+1).
    • The client says, "I acknowledge your response. Let’s start communicating."
Client → Server: ACK (Seq = X+1, ACK = Y+1)

After the three-way handshake, Both the client and server have synchronized sequence numbers. The connection is established, and data transfer can begin.

TCP example in nodejs

Let’s build a simple nodejs server and simulate this using the Netcat (nc) command

  1. build server in nodejs and run it on port 5000
const net = require('net');

const server = net.createServer((socket) => {
    console.log('Connection established!');

    socket.on('data', (data) => {
        console.log(`Received: ${data}`);
        socket.write('Hello from the server!');
    });

    socket.on('end', () => {
        console.log('Client disconnected');
    });
});

server.listen(5000, () => {
    console.log('Server is listening on port 5000');
});

The net module is used to create and manage TCP servers in Node.js. The net.createServer() function creates a new TCP server. The callback function inside runs whenever a new client connects to the server. The listen method binds the server to a specified port (e.g., 5000 in this case) and starts listening for incoming connections. This makes the server ready to accept connection requests from clients. If no hostname or IP address is specified, the server will listen on all available network interfaces (0.0.0.0 by default). You can specify an IP address (e.g., 127.0.0.1 for localhost) or a domain name for more specific binding.

  1. Connect Using Netcat: Open another terminal and use the following command to act as the
nc 127.0.0.1 5000

This initiates a SYN request from the client to the server. The server sends back a SYN-ACK, acknowledging the client’s request and sending its own sequence number. The client sends an ACK to complete the handshake. After the connection is established, type a message in the nc terminal. The server will respond with "Hello from the server!".

Why is the Handshake Necessary in TCP?

  • Reliable Communication: The handshake ensures that both parties agree on the sequence numbers to track data packets and detect duplicates.
  • Flow Control: It helps the server and client establish buffer sizes and manage the rate of data transfer.
  • Security: The handshake can prevent spoofing and unauthorized data injection by verifying the legitimacy of the connection request.

Applications of TCP

TCP is used by many common applications and services, including:

  • HTTP/HTTPS: For web browsing.
  • FTP: For file transfers.
  • SMTP, POP3, IMAP: For email communication.
  • Telnet and SSH: For remote access to servers.

Advantages of TCP

  • Reliable and error-free communication.
  • Ensures ordered data delivery.
  • Well-suited for applications requiring accurate data (e.g., web pages, file transfers).

Disadvantages of TCP

  • Slower than UDP due to the overhead of reliability and connection management.
  • Not ideal for real-time applications like video streaming or gaming (where speed is prioritized over reliability).

For situations requiring low latency and faster data transfer without reliability guarantees, UDP (User Datagram Protocol) is often used instead.