COMPUTER NETWORKS - ISWE205P

LAB ASSESSMENT -3
Due Date: 11.03.2025
• NAME : SIVASHREE.PL
• REG NO : 23MIS0117
• SLOT : F2+TF2

1. Implement Image Transfer between Client and Server using

UDP communication.

SERVER.JAVA
import java.io.*;
import java.net.*;
import java.util.*;

class Server {
private static final int PORT = 9876;
private static final int PACKET_SIZE = 1024;

public static void main(String[] args) {

try (DatagramSocket socket = new DatagramSocket(PORT);
 FileOutputStream fos = new
FileOutputStream("received_image.jpg")) {

System.out.println("Server is waiting for image...");

byte[] buffer = new byte[PACKET_SIZE + 4];

Map<Integer, byte[]> receivedPackets = new TreeMap<>();

boolean receiving = true;

while (receiving) {
DatagramPacket packet = new DatagramPacket(buffer,
buffer.length);
socket.receive(packet);

String receivedData = new String(packet.getData(), 0,

packet.getLength());
if (receivedData.equals("END")) {
receiving = false;
break;
}

int sequenceNumber =
bytesToInt(Arrays.copyOfRange(packet.getData(), 0, 4));
byte[] imageData = Arrays.copyOfRange(packet.getData(), 4,
packet.getLength());
receivedPackets.put(sequenceNumber, imageData);
}

for (byte[] chunk : receivedPackets.values()) {

fos.write(chunk);
 }
System.out.println("Image received successfully.");
} catch (Exception e) {
e.printStackTrace();
}
}
private static int bytesToInt(byte[] bytes) {
return ((bytes[0] & 0xFF) << 24) | ((bytes[1] & 0xFF) << 16) | ((bytes[2] &
0xFF) << 8) | (bytes[3] &
0xFF);
}
}

OUTPUT :
CLIENT.JAVA
import java.io.*;
import java.net.*;

public class Client {

private static final int PORT = 9876;
private static final String SERVER_IP = "127.0.0.1";
private static final int PACKET_SIZE = 1024;

public static void main(String[] args) {

try (DatagramSocket socket = new DatagramSocket();
FileInputStream fis = new FileInputStream("image.jpg")) {

InetAddress serverAddress = InetAddress.getByName(SERVER_IP);

byte[] buffer = new byte[PACKET_SIZE];
int bytesRead;
int sequenceNumber = 0;

System.out.println("Sending image...");

while ((bytesRead = fis.read(buffer)) != -1) {

byte[] dataToSend = new byte[bytesRead + 4];
System.arraycopy(intToBytes(sequenceNumber), 0, dataToSend, 4);
System.arraycopy(buffer, 0, dataToSend, 4, bytesRead);

DatagramPacket packet = new DatagramPacket(dataToSend,

dataToSend.length, serverAddress,
PORT);
socket.send(packet);
 sequenceNumber++;
}
// Send end signal
byte[] endSignal = "END".getBytes();
DatagramPacket endPacket = new DatagramPacket(endSignal,
endSignal.length, serverAddress,
PORT);
socket.send(endPacket);

System.out.println("Image sent successfully.");

} catch (Exception e) {
e.printStackTrace();
}
}

private static byte[] intToBytes(int value) {

return new byte[]{
(byte) (value >> 24),
(byte) (value >> 16),
(byte) (value >> 8),
(byte) value
};
}
}
OUTPUT :

2.Use ARP/RARP protocol to find physical address of a host

given its logical address, find a logical address given its physical
address. Implement using UDP sockets.

SERVER.JAVA
import java.net.*;
import java.util.HashMap;
public class Server {
// A map to simulate IP to MAC address mapping (ARP table)
private static HashMap<String, String> ipToMac = new HashMap<>();
// A map to simulate MAC to IP address mapping (RARP table)
private static HashMap<String, String> macToIp = new HashMap<>();

public static void main(String[] args) {

// Sample entries in ARP and RARP tables
ipToMac.put("192.168.1.1", "00:14:22:01:23:45");
ipToMac.put("192.168.1.2", "00:14:22:01:23:46");
 macToIp.put("00:14:22:01:23:45", "192.168.1.1");
macToIp.put("00:14:22:01:23:46", "192.168.1.2");

try {
DatagramSocket serverSocket = new DatagramSocket(9876); //
Listening on UDP port 9876
System.out.println("Server is running...");

byte[] receiveData = new byte[1024];

while (true) {
// Receive packet

DatagramPacket receivePacket = new DatagramPacket(receiveData,

receiveData.length);
serverSocket.receive(receivePacket);
String receivedMessage = new String(receivePacket.getData(), 0,
receivePacket.getLength());
String clientAddress = receivePacket.getAddress().toString();

System.out.println("Received: " + receivedMessage);

// Process ARP request (IP -> MAC)

if (receivedMessage.startsWith("ARP")) {
String ipAddress = receivedMessage.split(" ")[1];
String macAddress = ipToMac.get(ipAddress);
if (macAddress != null) {
String responseMessage = "MAC address for IP " + ipAddress +
": " + macAddress;
 DatagramPacket sendPacket = new
DatagramPacket(responseMessage.getBytes(), responseMessage.length(),
receivePacket.getAddress(), receivePacket.getPort());
serverSocket.send(sendPacket);
} else {
String responseMessage = "IP address not found in ARP table.";
DatagramPacket sendPacket = new
DatagramPacket(responseMessage.getBytes(), responseMessage.length(),
receivePacket.getAddress(), receivePacket.getPort());
serverSocket.send(sendPacket);
}
}
// Process RARP request (MAC -> IP)
else if (receivedMessage.startsWith("RARP")) {

String macAddress = receivedMessage.split(" ")[1];

String ipAddress = macToIp.get(macAddress);
if (ipAddress != null) {
String responseMessage = "IP address for MAC " + macAddress
+ ": " + ipAddress;
DatagramPacket sendPacket = new
DatagramPacket(responseMessage.getBytes(), responseMessage.length(),
receivePacket.getAddress(), receivePacket.getPort());
serverSocket.send(sendPacket);
} else {
String responseMessage = "MAC address not found in RARP
table.";
DatagramPacket sendPacket = new
DatagramPacket(responseMessage.getBytes(), responseMessage.length(),
 receivePacket.getAddress(), receivePacket.getPort());
serverSocket.send(sendPacket);
}
}
}
} catch (Exception e) {

e.printStackTrace();
}
}

OUTPUT :

CLIENT.JAVA

import java.net.*;
public class Client {
public static void main(String[] args) {
try {
DatagramSocket clientSocket = new DatagramSocket();
 InetAddress serverAddress = InetAddress.getByName("localhost");
int serverPort = 9876; // The server listens on port 9876

// ARP request to find MAC address for a given IP address

String arpRequest = "ARP 192.168.1.1";
DatagramPacket sendPacket = new
DatagramPacket(arpRequest.getBytes(), arpRequest.length(), serverAddress,
serverPort);

clientSocket.send(sendPacket);

// Receive response
byte[] receiveData = new byte[1024];
DatagramPacket receivePacket = new DatagramPacket(receiveData,

receiveData.length);
clientSocket.receive(receivePacket);
System.out.println("Server Response: " + new
String(receivePacket.getData(), 0, receivePacket.getLength()));

// RARP request to find IP address for a given MAC address

String rarpRequest = "RARP 00:14:22:01:23:45";
sendPacket = new DatagramPacket(rarpRequest.getBytes(),
rarpRequest.length(), serverAddress, serverPort);
clientSocket.send(sendPacket);
// Receive response
receivePacket = new DatagramPacket(receiveData,
receiveData.length);
 clientSocket.receive(receivePacket);
System.out.println("Server Response: " + new
String(receivePacket.getData(), 0, receivePacket.getLength()));

clientSocket.close();
} catch (Exception e) {
e.printStackTrace();
}
} }

OUTPUT :

3.Implement a Domain Name System (DNS) server and client

using UDP sockets. The client should give the Uniform
Resource Locator (URL) as the input and the server should
send the respective IP address.

SERVER.JAVA
import java.net.*;
import java.util.HashMap;
public class Server {
 // A simple hashmap to simulate a DNS database
private static HashMap<String, String> dnsDatabase = new HashMap<>();
public static void main(String[] args) {
// Populate the DNS database with sample mappings
dnsDatabase.put("www.example.com", "93.184.216.34");
dnsDatabase.put("www.google.com", "142.250.185.78");
dnsDatabase.put("www.facebook.com", "157.240.22.35");
try {
DatagramSocket serverSocket = new DatagramSocket(53); // DNS
operates typically on port 53
System.out.println("DNS Server is running...");

byte[] receiveData = new byte[1024];

while (true) {
// Receive the request from the client
DatagramPacket receivePacket = new DatagramPacket(receiveData,
receiveData.length);

serverSocket.receive(receivePacket);
String clientRequest = new String(receivePacket.getData(), 0,
receivePacket.getLength());
String clientAddress = receivePacket.getAddress().toString();
System.out.println("Received request from client: " +
clientRequest);

// Perform DNS lookup

String ipAddress = dnsDatabase.get(clientRequest);
 // Respond with the corresponding IP address or an error message
String responseMessage;
if (ipAddress != null) {
responseMessage = "IP Address for " + clientRequest + ": " +
ipAddress;
} else {
responseMessage = "Error: Domain not found!";
}

// Send the response back to the client

DatagramPacket sendPacket = new
DatagramPacket(responseMessage.getBytes(), responseMessage.length(),
receivePacket.getAddress(), receivePacket.getPort());

serverSocket.send(sendPacket);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

OUTPUT :
CLIENT.JAVA
import java.net.*;
import java.util.Scanner;
public class Client {
public static void main(String[] args) {
try {
DatagramSocket clientSocket = new DatagramSocket();
InetAddress serverAddress = InetAddress.getByName("localhost");
int serverPort = 53; // Standard DNS port

Scanner scanner = new Scanner(System.in);

System.out.println("Enter the domain name (e.g.,

www.example.com): ");
String domainName = scanner.nextLine();

// Send the DNS request (domain name) to the server

DatagramPacket sendPacket = new
DatagramPacket(domainName.getBytes(), domainName.length(),
serverAddress, serverPort);
clientSocket.send(sendPacket);

// Receive the server's response

byte[] receiveData = new byte[1024];
DatagramPacket receivePacket = new DatagramPacket(receiveData,

receiveData.length);
clientSocket.receive(receivePacket);
 System.out.println("Server Response: " + new
String(receivePacket.getData(), 0, receivePacket.getLength()));

clientSocket.close();
scanner.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}

OUTPUT :
 4.Write a UDP based server code to get the client's date of birth
and calculate the age as of today. The client must enter the
year, month, and date of birth. Get today's date from the
server.

SERVER.JAVA
import java.net.*;
import java.io.*;
import java.time.*;
import java.time.format.DateTimeFormatter;

public class Server {

public static void main(String[] args) {
DatagramSocket socket = null;
try {

socket = new DatagramSocket(9876);

byte[] receiveData = new byte[1024];

System.out.println("Server is ready to receive date of birth from

client...");

while (true) {
DatagramPacket receivePacket = new DatagramPacket(receiveData,
receiveData.length);
socket.receive(receivePacket);
String clientMessage = new String(receivePacket.getData(), 0,
receivePacket.getLength());
 InetAddress clientAddress = receivePacket.getAddress();
int clientPort = receivePacket.getPort();

DateTimeFormatter formatter =
DateTimeFormatter.ofPattern("yyyy-MM-dd");
LocalDate birthDate = LocalDate.parse(clientMessage, formatter);
LocalDate currentDate = LocalDate.now();
Period period = Period.between(birthDate, currentDate);

String ageMessage = "You are " + period.getYears() + " years, " +

period.getMonths() + " months, and " + period.getDays() + " days
old.";
socket.send(new DatagramPacket(ageMessage.getBytes(),
ageMessage.length(), clientAddress, clientPort));
}

} catch (Exception e) {
e.printStackTrace();
} finally {
if (socket != null && !socket.isClosed()) {
socket.close();
}
}
}
}
OUTPUT :

CLIENT.JAVA
import java.net.*;
import java.util.Scanner;
public class Client {
public static void main(String[] args) {
DatagramSocket socket = null;
Scanner scanner = new Scanner(System.in);
try {
socket = new DatagramSocket();
InetAddress serverAddress = InetAddress.getByName("localhost");

System.out.print("Enter your date of birth (yyyy-mm-dd): ");

String dob = scanner.nextLine();
byte[] sendData = dob.getBytes();

DatagramPacket sendPacket = new DatagramPacket(sendData,

sendData.length, serverAddress, 9876);
socket.send(sendPacket);
 byte[] receiveData = new byte[1024];

DatagramPacket receivePacket = new DatagramPacket(receiveData,

receiveData.length);
socket.receive(receivePacket);
String serverMessage = new String(receivePacket.getData(), 0,
receivePacket.getLength());

System.out.println("Server: " + serverMessage);

} catch (Exception e) {
e.printStackTrace();
} finally {
if (socket != null && !socket.isClosed()) {
socket.close();
}
}
}
}
OUTPUT :