18. Network Programming

Network programming enables communication between software applications across different devices over a network. Whether you're developing a chat application, implementing web services, or building client-server systems, understanding network programming is essential in today's connected world. This chapter explores the fundamental concepts, protocols, models, and programming techniques used to build networked applications, with practical implementation using Java (and references to Python/C for parallel understanding). It also covers low-level socket programming as well as higher-level abstractions, providing a comprehensive foundation for real-world application development.

Network programming allows different software applications to communicate across various devices using a network. This means that if you're creating something like a chat application or web service, you need to understand how data travels between devices. The chapter covers key concepts, protocols, and programming methods to create network applications, focusing mainly on Java but also providing insights into Python and C for broader understanding. It will help you grasp both the low-level details of how connections are made (like socket programming) and higher-level approaches to network communication.

Think of network programming like building a telephone system where different phones (devices) need to connect. Just like knowing how to dial a number or set up a line is essential for communication, understanding the principles of data flow and specific protocols is crucial for developers to create applications that interact with each other over a network.

Before diving into code, it's crucial to understand how data flows between computers.

What is a Network?

A network is a collection of interconnected devices (computers, servers, routers) that communicate to share data and resources.

Types of Networks:

• LAN (Local Area Network)
• WAN (Wide Area Network)
• MAN (Metropolitan Area Network)
• PAN (Personal Area Network)

Network Models

• OSI Model (7 layers)
  • Physical, Data Link, Network, Transport, Session, Presentation, Application
• TCP/IP Model (4 layers)
  • Network Access, Internet, Transport, Application

Protocols

• TCP (Transmission Control Protocol) – reliable, connection-oriented
• UDP (User Datagram Protocol) – faster, connectionless
• HTTP/HTTPS, FTP, SMTP, DNS, etc.

Before programming networks, it's important to understand data flow. A network consists of devices such as computers and routers that are connected and can communicate with each other. There are several types of networks:

1. LAN is used in small areas like homes or offices.
2. WAN covers larger geographical areas like cities or countries.
3. MAN is used for networks within city limits.
4. PAN is used for personal devices such as smartphones and tablets.

Moreover, there are network models that help understand how data travels. The OSI Model consists of seven layers that describe the functions required for network communication, while the TCP/IP Model has four layers that reflect how the internet functions. Additionally, protocols like TCP and UDP define how data is sent; TCP is reliable but slower, while UDP is faster but may not guarantee delivery.

Imagine a postal service that delivers letters: the network is like the entire postal system with various levels of processing and transportation. LAN is like your local post office, WAN is similar to long-distance mail that travels across the country, and MAN can be viewed as city-to-city mail systems. Just as the postal service has rules about how packages should be sent and received (protocols), networks do too, ensuring that information flows smoothly.

Socket programming provides an API for communication between machines.

What is a Socket?

A socket is one endpoint of a two-way communication link between two programs running on the network.

• Socket = IP address + Port number
• Types: Stream (TCP), Datagram (UDP)

Java Socket Classes

• java.net.Socket – client side (TCP)
• java.net.ServerSocket – server side (TCP)
• java.net.DatagramSocket, java.net.DatagramPacket – for UDP

Socket programming refers to the process of using a programming interface (API) that facilitates communication over a network between different programs. A socket represents one end of a communication link, comprised of an IP address (identifying a device on the network) and a port number (which identifies a specific service on that device). There are two main types of sockets: stream sockets used for TCP connections which are reliable, and datagram sockets for UDP connections which are faster but less reliable. In Java, there are specific classes to create and manage these sockets, such as Socket for clients and ServerSocket for servers handling TCP connections, and DatagramSocket for UDP processing.

Think of a socket like a phone line between two people: the IP address is like the phone number, and the port number is akin to which type of call (e.g., voice, video) they're making. Just as everyone can use their phones to communicate but needs specific lines (or sockets) to connect properly, applications use sockets to exchange data efficiently over networks.

TCP Server Example

import java.net.*;
import java.io.*;
public class TCPServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(5000);
System.out.println("Server started...");
Socket clientSocket = serverSocket.accept();
System.out.println("Client connected.");
BufferedReader in = new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
String message = in.readLine();
System.out.println("Received: " + message);
out.println("Echo: " + message);
in.close();
out.close();
clientSocket.close();
serverSocket.close();
}
}

TCP Client Example

import java.net.*;
import java.io.*;
public class TCPClient {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("localhost", 5000);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
out.println("Hello Server!");
System.out.println("Server response: " + in.readLine());
in.close();
out.close();
socket.close();
}
}

The provided examples demonstrate how to create a simple TCP server and client in Java. The server runs on port 5000, waiting for a client to connect. When a client connects, it receives a message, echoes it back, and both the client and server close the connection afterward. On the client side, the application establishes a connection to the server, sends a greeting message ('Hello Server!'), and waits for the server's response to print it out. This back-and-forth communication illustrates the basic functioning of a client-server model in network programming using TCP.

Consider the TCP server and client like a restaurant (the server) and a customer (the client). The customer places an order (sends a message), and the restaurant prepares the order and sends it back (echoes the message). The process continues until the customer is satisfied and leaves, just as the applications establish a connection, exchange messages, and then terminate the interaction.

UDP Server Example

import java.net.*;
public class UDPServer {
public static void main(String[] args) throws Exception {
DatagramSocket socket = new DatagramSocket(9876);
byte[] receiveData = new byte[1024];
DatagramPacket receivePacket = new DatagramPacket(receiveData,
receiveData.length);
socket.receive(receivePacket);
String message = new String(receivePacket.getData()).trim();
System.out.println("Received: " + message);
socket.close();
}
}

UDP Client Example

import java.net.*;
public class UDPClient {
public static void main(String[] args) throws Exception {
DatagramSocket socket = new DatagramSocket();
byte[] sendData = "Hello UDP Server".getBytes();
InetAddress IPAddress = InetAddress.getByName("localhost");
DatagramPacket sendPacket = new DatagramPacket(sendData,
sendData.length, IPAddress, 9876);
socket.send(sendPacket);
socket.close();
}
}

The UDP examples illustrate how to create a simple UDP server and client in Java. The server operates on port 9876 and listens for incoming data. Once it receives a packet, it extracts the message and outputs it. The client, on the other hand, sends a message ('Hello UDP Server') to the server's address and port without waiting for any type of connection confirmation or acknowledgment from the server. This highlights the key nature of UDP - faster but less reliable communication compared to TCP.

Imagine UDP communication as sending postcards instead of letter packages. Each postcard (data packet) is dropped into a mail slot without a guarantee it will arrive, unlike a secure package that requires signing for. The quick sending and no follow-up confirms the nature of UDP: speed over reliability.

Ports

• Range: 0–65535
• Well-known ports: 0–1023 (e.g., HTTP – 80, FTP – 21)

IP Addressing

• IPv4: e.g., 192.168.1.1
• IPv6: longer format to support more devices

DNS and Domain Names

Domain Name System maps domain names to IP addresses.

In network programming, understanding ports is essential. They serve as communication endpoints, numbered from 0 to 65535, with well-known ports (0-1023) reserved for common services, such as port 80 for HTTP and 21 for FTP. IP addressing determines how devices are identified on the network. IPv4 addresses are numerical (like 192.168.1.1), while IPv6 uses a longer format to accommodate the growing number of internet-connected devices. The Domain Name System (DNS) plays a crucial role in translating user-friendly domain names (like example.com) into machine-readable IP addresses.

Think of ports as doorways in a building (the server), where each room (service) has its own door (port) for people (data) to enter and exit. The IP address is akin to the building's street address, guiding visitors to the correct location, while DNS functions like a directory providing the necessary information to find that address easily, rather than needing to remember numerical addresses.

To handle multiple clients simultaneously:

class ClientHandler extends Thread {
private Socket clientSocket;
public ClientHandler(Socket socket) {
this.clientSocket = socket;
}
public void run() {
try {
BufferedReader in = new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(),
true);
String inputLine;
while ((inputLine = in.readLine()) != null) {
out.println("Echo from server: " + inputLine);
}
in.close();
out.close();
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

And in the main server:

ServerSocket serverSocket = new ServerSocket(5000);
while (true) {
Socket socket = serverSocket.accept();
new ClientHandler(socket).start();
}

To enhance server capacity, multi-threaded programming allows a server to handle multiple client requests simultaneously. In the example, a ClientHandler class extends Thread, creating a new thread for each client connection. Inside the run() method, it processes incoming messages and produces responses, echoing back any received input. Meanwhile, the main server continuously listens for new connections and spawns new threads, allowing for multiple interactions without waiting for one to finish before starting another.

Imagine a busy restaurant again: the main server is the head chef (main server) who prepares dishes (handles requests) but has a team of sous-chefs (client handlers) who each handle individual orders (clients) simultaneously. This means that even with a high volume of customers, the restaurant can still provide quick service without delays.

--