Lab Cs3591 Computer Networks Lab
Lab Cs3591 Computer Networks Lab
DHARMAPURI
(REGULATION 2021)
INDEX
S.NO DATE LIST OF EXPERIMENTS PAGE MARKS SIGN
NO
1 Basic Commands
2 HTTP web client program to
download a web page using TCP
sockets.
Applications using TCP sockets
like.
(a) Echo client and echo server
3
(b) Chat
AIM:
Learn to use commands like tcpdump, netstat, ifconfig, nslookup and tracert. Capture ping and
trace route PDUs using a network protocol analyzer and examine.
Commands:
1. Netstat:
Netstat provides information and statistics about protocols in use and current TCP/IP network
connections. The Windows help screen (analogous to a Linux or UNIX for netstat reads as
follows: displays protocol statistics and current TCP/IP network connections.
2. TCPDUMP:
To display all traffic between two hosts (represented by variables host1 and host2): # tcpdump
host host1 and host2
Provide the protocol as an argument to display only traffic for a specific protocol, for example
TCP, UDP, ICMP, ARP,
# tcpdump protocol For example to display traffic only for the tcp traffic.
# tcpdump tcp Filtering based on source or destination port To filter based on a source or
destination Port.
3. Ipconfig:
In Windows, ipconfig is a console application designed to run from the Windows command
prompt. This utility allows you to get the IP address information of a Windows computer.
Using ipconfig
From the command prompt, type ipconfig to run the utility with default options. The output of the
default command contains the IP address, network mask, and gateway for all physical and virtual
network adapter.
#ipconfig
4.nslookup
The nslookup (which stands for name server lookup) command is a network utility program used to obtain
information about internet servers. It finds name server information for domains by querying the Domain
Name System.
The nslookup command is a powerful tool for diagnosing DNS problems. You know you're experiencing a
DNS problem when you can access a resource by specifying its IP address but not its DNS name.
#nslookup
5.Trace route:
Traceroute uses Internet Control Message Protocol (ICMP) echo packets with variable time to live (TTL)
values. The response time of each hop is calculated. To guarantee accuracy, each hop is queried multiple
times (usually three times) to better measure the response of that particular hop.
Traceroute is a network diagnostic tool used to track the pathway taken by a packet on an IP network from
source to destination. Traceroute also records the time taken for each hop the packet makes during its route
to the destination. Traceroute uses Internet Control Message Protocol (ICMP) echo packets with variable
time to live (TTL) values.
The response time of each hop is calculated. To guarantee accuracy, each hop is queried multiple times
(usually three times) to better measure the response of that particular hop. Traceroute sends packets with
TTL values that gradually increase from packet to packet, starting with TTL value of one. Routers
decrement TTL values of packets by one when routing and discard packets whose TTL value has reached
zero, returning the ICMP error message ICMP Time Exceeded.For the first set of packets, the first router
receives the packet, decrements the TTL value and drops the packet because it then has TTL value zero.
The router sends an ICMP Time Exceeded message back to the source. The next set of packets are given a
TTL value of two, so the first router forwards the packets, but the second router drops them and replies
with ICMP Time Exceeded.
Proceeding in this way, traceroute uses the returned ICMP Time Exceeded messages to build a list of
routers that packets traverse, until the destination is reached and returns an ICMP Echo Reply message.
With the tracert command shown above, we're asking tracert to show us the path from the local computer
all the way to the network device with the hostname.
6.Ping:
The ping command sends an echo request to a host available on the network. Using this
command, you can check if your remote host is responding well or not. Tracking and isolating
hardware and software problems. Determining the status of the network and various foreign
hosts. The ping command is usually used as a simple way to verify that a computer can
communicate over the network with another computer or network device. The ping command
operates by sending Internet Control Message Protocol (ICMP) Echo Request messages to the
destination computer and waiting for a response.
RESULT:
Thus the various networks commands like tcpdump, netstat, ifconfig, nslookup and
tracert, ping are executed successfully.
EX NO: 2 HTTP web client program to download a web page using
DATE: TCP sockets
AIM:
To write a HTTP web client program to download a web page using TCP sockets.
PROCEDURE:
TCP connection with the web server using a Socket. We then use the socket's input and output
streams to send an HTTP GET request and receive the server's response.
Replace "example.com" with the actual domain name or IP address of the web page you want to
download. You can also modify the port and path variables as needed.
Keep in mind that this is a basic example, and it assumes that the web server is listening on the
standard HTTP port (port 80).
In a real-world scenario, you might need to handle redirects, handle different response codes,
handle chunked encoding, and so on.
PROGRAM:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class WebPageDownloader
{
public static void main(String[] args)
{
String host = "example.com";
int port = 80;
String path = "/";
try (Socket socket = new Socket(host, port);
PrintWriter requestWriter = new PrintWriter(socket.getOutputStream());
BufferedReader responseReader = new BufferedReader(new
InputStreamReader(socket.getInputStream()
)))
{
OUT PUT:
RESULT:
Thus the above program HTTP web client program to download a web page using TCP sockets
has been executed successfully
EX NO 3 (a) Applications using TCP sockets
DATE: Echo client and echo server
AIM:
Write a program for Echo Client and Echo server using TCP sockets.
PROCEDURE:
OUTPUT
Server
C:\Program Files\Java\jdk1.5.0\bin>javac EServer.java
C:\Program Files\Java\jdk1.5.0\bin>java EServer
C:\Program Files\Java\jdk1.5.0\bin>
Client
C:\Program Files\Java\jdk1.5.0\bin>javac EClient.java
C:\Program Files\Java\jdk1.5.0\bin>java EClient
Client: Hai Server
Server:Hai Server
Client: Hello
Server:Hello
Client:end
Server:end
Client:ds
Socket Closed!
b) Echo Client.java:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;
public class EchoClient
{
public static void main(String[] args)
{
String serverAddress = "localhost";
int port = 12345;
try (Socket socket = new Socket(serverAddress, port);
BufferedReader reader = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
Scanner scanner = new Scanner(System.in));
{
System.out.println("Connected to EchoServer at " + serverAddress + ":" + port);
System.out.println("Type a message and press Enter to send, or type 'exit' to quit.");
// Read input from the user and send it to the server String input;
do
{
input = scanner.nextLine();
writer.println(input);
String response = reader.readLine();
System.out.println("Server response: " + response);
}
while (!input.equalsIgnoreCase("exit"));
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
OUTPUT:
Server
C:\Program Files\Java\jdk1.5.0\bin>javac UDPserver.java
C:\Program Files\Java\jdk1.5.0\bin>java UDPserver
press ctrl+c to quit the program
Client:Hai Server
Server:Hello Client
Client:How are You
Server:I am Fine
Client
Downloaded from: annauniversityedu.blogspot.com
25
C:\Program Files\Java\jdk1.5.0\bin>javac UDPclient.java
C:\Program Files\Java\jdk1.5.0\bin>java UDPclient
server waiting
Client:Hai Server
Server:Hello Clie
Client:How are You
Server:I am Fine
Client:end
Result:
Thus the above program for Echo Client and Echo server using TCP sockets has been executed
successfully.
B) ChatClient.java
import java.io.*;
import java.net.*;
import java.util.Scanner;
InputStreamReader(socket.getInputStream()));
System.out.println("Type your messages and press Enter to send, or type 'exit' to quit.");
String serverMessage;
try
} catch (IOException e)
e.printStackTrace();
});
receiveThread.start();
// Read input from the user and send messages to the server
String input;
Do
input = scanner.nextLine();
writer.println(input);
while (!input.equalsIgnoreCase("exit"));
catch (IOException e)
e.printStackTrace();
OUT PUT:
server
E:\nwlab>java FileServer
Sending file ... 9% complete!
Sending file ... 19% complete!
Sending file ... 28% complete!
Sending file ... 38% complete!
Sending file ... 47% complete!
Sending file ... 57% complete!
Sending file ... 66% complete!
Sending file ... 76% complete!
Sending file ... 86% complete!
Sending file ... 95% complete!
Sending file ... 100% complete!
File sent successfully!
E:\nwlab>client
E:\nwlab>java FileClient
RESULT:
Thus the above a program for the Chat Applications using TCP sockets has been executed succesfully.
PROCEDURE:
The DNS server listens on port 53, which is the standard DNS port. It receives DNS queries
from clients, processes them, and sends back the corresponding IP address. The process DNSQuery()
method is a placeholder where you can implement your own logic to map domain names to IP
addresses.
To test the DNS server, you can use a DNS client program or a tool like nslookup. Here's an
example using the nslookup command:
Compile and run the DNS server program using javac DNSServer.java and java DNSServer.
Open a new terminal or command prompt window.
Type nslookup example.com localhost to query the DNS server for the IP address of example.com.
Replace localhost with the IP address or hostname of the machine running the DNS server.
You should see the DNS server responding with the IP address for example.com.
Note that this is a basic example and does not cover all the complexities of a full-fledged DNS
server. It's intended to demonstrate the concept of simulating DNS using UDP sockets.
PROGRAM:
import java.net.*;
while (true)
socket.receive(requestPacket);
InetAddress clientAddress = requestPacket.getAddress();
socket.send(responsePacket);
catch (Exception e)
e.printStackTrace();
// Perform DNS query processing and return the appropriate IP address based on the query
switch (query)
case "example.com":
return "192.0.2.1";
case "google.com":
return "8.8.8.8";
default:
return "Unknown host";
OUT PUT:
Server
javac udpdnsserver.java
java udpdnsserver
Press Ctrl + C to Quit Request for host yahoo.com
Request for host cricinfo.com
Request for host youtube.com
Client
>javac udpdnsclient.java
>java udpdnsclient
Enter the hostname : yahoo.com
IP Address: 68.180.206.184
>java udpdnsclient
Enter the hostname : cricinfo.com
IP Address: 80.168.92.140
>java udpdnsclient
Enter the hostname : youtube.com
RESULT:
Thus the above program for Simulation of DNS using UDP sockets has been executed successfully.
Use a tool wire shark to capture a packets and examine the packets.
PROCEDURE:
Wireshark is a powerful network protocol analyzer that allows you to capture and analyze
network packets. Here's how you can use Wireshark to capture packets and examine them:
1. Start Wireshark on your machine.
2. Select the network interface that you want to capture packets from. For example, if you're using
Wi-Fi, select the Wi-Fi interface. If you're using Ethernet, select the Ethernet interface.
3. Click on the "Start" button to begin capturing packets.
4. Run your DNS server program (as described in the previous response) or any other network
program that generates network traffic.
5. Perform the actions or execute the program that generates the network traffic you want to
capture and examine. For example, if you're using the DNS server program, you can use the
nslookup command or any other DNS client program to perform DNS queries.
6. Once you're done generating the network traffic, go back to Wireshark and click on the "Stop"
button to stop capturing packets.
7. Wireshark will display a list of captured packets in its main window. You can scroll through the
list to view individual packets.
8. You can select a packet from the list to examine its details in the packet details pane. Wireshark
provides detailed information about each packet, including source and destination IP addresses,
port numbers, protocols, and packet payload.
9. To filter the captured packets based on specific criteria, you can use the filter box at the top of
the Wireshark window. For example, you can filter packets by protocol, source or destination IP
address, port number, or any other field.
10. You can right-click on a packet in the list to perform various actions, such as following a TCP
stream, analyzing the packet in more detail, or exporting the packet data for further analysis.
Wireshark provides a wide range of features and capabilities for packet analysis, including the
ability to dissect and decode various protocols, perform statistical analysis, apply filters, and much
more. It's a valuable tool for examining network packets and understanding the communication between
different network entities.
EX NO: 6 Simulating ARP/RARP protocol
DATE:
AIM:
To write a program to simulate ARP/RARP protocol.
PROCEDURE:
In this simulation, we have a simple ARPTable class that stores IP-MAC address mappings. The
ARPProtocolSimulator class demonstrates the usage of this table to simulate ARP and RARP lookups.
To run the simulation, simply compile and execute the ARPProtocolSimulator.java file. It will
perform an ARP lookup by querying the ARP table for a given IP address and display the corresponding
MAC address if found. It will also perform a RARP lookup by searching the ARP table for a given
MAC address and display the corresponding IP address if found.
Note that this is a basic simulation for educational purposes and doesn't involve actual network
communication. In real-world scenarios, ARP and RARP involve communication between devices on a
network to resolve IP and MAC addresses.
In this simulation, we have a simple RARPTable class that stores MAC-IP address mappings.
The RARPProtocolSimulator class demonstrates the usage of this table to simulate a RARP lookup.
To run the simulation, simply compile and execute the RARPProtocolSimulator.java file. It will
perform a RARP lookup by querying the RARP table for a given MAC address and display the
corresponding IP address if found.
PROGRAM:
a) ARP PROTOCOL
import java.util.HashMap;
import java.util.Map;
class ARPTable
{
private Map<String, String> table;
public ARPTable()
{
this.table = new HashMap<>();
}
public void addEntry(String ipAddress, String macAddress) {
table.put(ipAddress, macAddress);
}
public String lookup(String ipAddress)
{
return table.get(ipAddress);
}
}
class ARPProtocolSimulator
{
public static void main(String[] args)
{
ARPTable arpTable = new ARPTable();
arpTable.addEntry("192.168.0.1", "00:11:22:33:44:55");
arpTable.addEntry("192.168.0.2", "AA:BB:CC:DD:EE:FF");
// Simulate ARP lookup
String ipAddress = "192.168.0.1";
String macAddress = arpTable.lookup(ipAddress);
if (macAddress != null)
{
System.out.println("ARP Lookup - IP: " + ipAddress + ", MAC: " + macAddress);
}
else
{
System.out.println("ARP Lookup - IP: " + ipAddress + ", MAC not found");
}
// Simulate RARP lookup
String targetMacAddress = "00:11:22:33:44:55";
String targetIpAddress = null;
for (Map.Entry<String, String> entry : arpTable.getTable().entrySet())
{
if (entry.getValue().equals(targetMacAddress))
{
targetIpAddress = entry.getKey();
break;
}
}
if (targetIpAddress != null)
{
System.out.println("RARP Lookup - MAC: " + targetMacAddress + ", IP: " +
targetIpAddress);
}
else
{
System.out.println("RARP Lookup - MAC: " + targetMacAddress + ", IP not found");
}
}}
b) RARP PROTOCOL:
import java.util.HashMap;
import java.util.Map;
class RARPTable
{
private Map<String, String> table;
public RARPTable()
{
this.table = new HashMap<>();
}
public void addEntry(String macAddress, String ipAddress)
{
table.put(macAddress, ipAddress);
}
public String lookup(String macAddress)
{
return table.get(macAddress);
}
}
class RARPProtocolSimulator
{
public static void main(String[] args)
{
RARPTable rarpTable = new RARPTable();
rarpTable.addEntry("00:11:22:33:44:55", "192.168.0.1");
rarpTable.addEntry("AA:BB:CC:DD:EE:FF", "192.168.0.2");
// Simulate RARP lookup
String macAddress = "00:11:22:33:44:55";
String ipAddress = rarpTable.lookup(macAddress);
if (ipAddress != null)
{
System.out.println("RARP Lookup - MAC: " + macAddress + ", IP: " + ipAddress);
}
else
{
System.out.println("RARP Lookup - MAC: " + macAddress + ", IP not found");
}
}
}
OUT PUT:
E:\networks>java Serverarp
E:\networks>java Clientarp
Enter the Logical address(IP):
165.165.80.80
The Physical Address is: 6A:08:AA:C2
RESULT:
Thus the above program to simulate ARP/RARP protocol has been executed successfully.
EX NO: 7 Study of Network simulator (NS)
DATE:
AIM:
Study of Network simulator (NS) and Simulation of Congestion Control Algorithms using NS.
PROCEDURE:
Network Simulator (NS) is a discrete event network simulation tool used for simulating and
evaluating the performance of computer networks. It allows researchers and network engineers to
simulate various network scenarios, protocols, and algorithms to understand their behaviour and
performance under different conditions.
NS is widely used for academic and research purposes to explore network concepts, test new
protocols, study network behaviour, and evaluate network performance. It provides a flexible and
extensible environment for designing network topologies, defining network parameters, and running
simulations.
Some key features of NS include:
Network Topology: NS allows users to create complex network topologies with nodes, links, and
routers. It supports various network types, including wired and wireless networks.
Protocol Simulation: NS provides a library of network protocols that can be simulated, such as
TCP/IP, UDP, routing protocols (e.g., OSPF, BGP), and congestion control algorithms.
Traffic Generation: NS allows users to generate traffic patterns and flows to simulate realistic
network traffic scenarios. This enables the evaluation of network performance and congestion
control algorithms under different traffic conditions.
Event-driven Simulation: NS operates on an event-driven model, where events (such as packet
arrivals, link failures, or timer expirations) are scheduled and processed based on simulation
time. This allows for fine-grained control and synchronization of network events.
Performance Metrics: NS provides built-in tools for collecting and analysing performance
metrics during simulations. These metrics can include throughput, latency, packet loss,
congestion indicators, and more.
Now, let's discuss simulating Congestion Control Algorithms using NS. Congestion control
algorithms aim to manage network congestion and optimize network performance by regulating the rate
at which data is transmitted. NS enables researchers to simulate and evaluate different congestion
control algorithms and compare their performance in various network scenarios.
To simulate congestion control algorithms using NS, you would typically follow these steps:
Design the network topology:
Define the network topology you want to simulate, including nodes, links, and their properties.
Implement the congestion control algorithm:
Write the code or configure the congestion control algorithm within NS. NS provides a
programming interface to implement custom congestion control algorithms or use existing ones
available in the library.
Define traffic patterns:
Specify the traffic patterns and flows that will be generated in the network. This can include
different types of traffic, such as bulk data transfers, real-time traffic, or background traffic.
Run the simulation: Start the simulation and let NS simulate the network behaviour over time.
NS will handle events, process packets, and simulate the congestion control algorithm's actions based on
the defined network conditions and traffic patterns.
Collect and analyse results:
Monitor and collect performance metrics during the simulation, such as throughput, delay,
packet loss, and congestion indicators. Analyse the results to evaluate the effectiveness and efficiency of
the congestion control algorithm under different scenarios.
Iterate and refine:
Based on the simulation results, refine the congestion control algorithm or experiment with different
parameter settings to optimize network performance.
NS provides extensive documentation, tutorials, and examples to help users get started with
simulating congestion control algorithms and exploring network behaviour. You can refer to the official
NS documentation and resources for detailed guidance on using NS for congestion control simulations.
Keep in mind that simulating congestion control algorithms in NS provides a controlled
environment for evaluation and comparison. Real-world network deployments may introduce additional
complexities and factors that can impact the algorithm's performance. Therefore, it's essential to validate
the simulation results with real-world experiments when possible.
RESULT:
Thus the above study of Network Stimulator has been studied and understood properly.
EX NO: 8 Study of TCP/UDP using simulation tool
DATE:
AIM:
Study of TCP/UDP using simulation tool.
PROCEDURE:
To study the performance of TCP (Transmission Control Protocol) and UDP (User Datagram
Protocol) using simulation tools, you can use network simulators like Network Simulator (NS), ns-3, or
OMNeT++ that provide support for simulating these protocols. Here's an overview of the process:
Traffic Generation:
Define the traffic patterns and flows that will be generated in the network. Decide on the types of
traffic, such as bulk transfers, video streaming, or real-time communications. Set the traffic
characteristics, such as arrival rates, sizes, and destinations, to mimic real-world scenarios.
Simulation Execution:
Run the simulation using the chosen simulation tool. During the simulation, the tool will model
the behaviour of TCP and UDP based on the configured parameters and network conditions. Packets
will be sent, routed, and received by the simulated nodes, and the protocols' mechanisms will be
employed, such as TCP congestion control or UDP's best-effort delivery.
Simulation tools like NS, ns-3, or OMNeT++ provide extensive documentation, example
scenarios, and libraries that facilitate the simulation of TCP and UDP. You can consult their
documentation and resources to learn more about using these tools to study the performance of TCP and
UDP protocols in different network scenarios.
Keep in mind that while simulations provide valuable insights, they may not fully capture the
complexity of real-world networks. Therefore, it's important to complement the simulation results with
real-world experiments whenever possible to validate and verify the findings.
RESULT:
Thus the above study of TCP/UDP protocol has been studied and understood properly.
EX NO: 9(a) Simulation of Distance Vector Algorithm
DATE:
AIM:
To simulate the Distance Vector routing algorithm
PROCEDURE:
To simulate the Distance Vector routing algorithm, you can use network simulation tools like
Network Simulator (NS), ns-3, or OMNeT++. Here's a step-by-step guide on simulating the Distance
Vector algorithm:
Network Topology Design:
Design the network topology you want to simulate. Define the nodes and links in the network,
including their properties such as bandwidth, delay, and reliability. Consider the size and complexity of
the network to reflect the scenario you want to study.
Node Configuration:
Configure each node in the network to use the Distance Vector routing algorithm. Each node
should maintain its routing table and exchange routing updates with its neighboring nodes.
Simulation tools like NS, ns-3, or OMNeT++ provide libraries, modules, and example scenarios
to facilitate the simulation of the Distance Vector algorithm. You can refer to their documentation and
resources for specific guidance on using these tools for Distance Vector simulations.
Remember that simulations provide insights into the behavior of routing algorithms but may not
fully capture the complexity of real-world networks. Therefore, it's important to complement simulation
results with real-world experiments whenever possible to validate and verify the findings.
RESULT:
AIM:
Simulation of Link State Routing algorithm.
PROCEDURE:
To simulate the Link State routing algorithm, you can use network simulation tools like Network
Simulator (NS), ns-3, or OMNeT++. Here's a step-by-step guide on simulating the Link State algorithm:
Network Topology Design:
Design the network topology you want to simulate. Define the nodes and links in the network,
including their properties such as bandwidth, delay, and reliability. Consider the size and complexity of
the network to reflect the scenario you want to study.
Node Configuration:
Configure each node in the network to use the Link State routing algorithm. Each node should
have a Link State Database (LSDB) that stores information about the network's topology.
RESULT:
Thus the above simulation program has been executed successfully.
EX NO: 10 Simulation of an error correction code (CRC)
DATE:
AIM:
Simulation of an error correction code (CRC).
PROCEDURE:
To simulate an error correction code like CRC (Cyclic Redundancy Check), you can use
programming languages like Python to create a simulation program. Here's a step-by-step guide on
simulating CRC:
Select CRC Parameters:
Determine the parameters of the CRC code you want to simulate, such as the polynomial and its
degree, generator polynomial, and the number of bits for the checksum. These parameters define the
characteristics of the CRC code.
Generate Test Data:
Create test data that represents the message to be encoded and transmitted. This can be a string
of bits or bytes, or you can generate random data. Make sure the data contains errors or introduce errors
intentionally to simulate the error correction process.
CRC Encoding:
Implement the CRC encoding process. This involves dividing the message by the generator
polynomial using modulo-2 division and appending the resulting CRC checksum to the original
message. This generates the encoded message.
Error Introduction:
Introduce errors into the encoded message to simulate transmission errors. You can flip bits
randomly or intentionally introduce specific error patterns.
CRC Decoding:
Implement the CRC decoding process. Receive the transmitted message and perform the same
modulo-2 division with the generator polynomial. If the remainder is zero, the message is assumed to be
error-free. If the remainder is non-zero, it indicates the presence of errors.
Error Detection and Correction:
Analyze the remainder obtained in the decoding process. If the remainder is non-zero, errors are
detected. Use the CRC algorithm to correct the errors, if possible. You can attempt to fix the errors by
manipulating the received message or requesting retransmission.
Performance Analysis:
Collect performance metrics to evaluate the effectiveness of the CRC code. Measure the error
detection rate, error correction rate, and false positive rate. Calculate the overall accuracy of the CRC
code in detecting and correcting errors.
Repeat and Compare:
Repeat the simulation with different test data, error patterns, or CRC parameters to analyze the
performance under various conditions. Compare the results to assess the impact of different factors on
the CRC's effectiveness.
By implementing the CRC algorithm in a programming language, you can simulate the error
detection and correction process. You can modify the simulation program to test different CRC
parameters, error patterns, or even combine CRC with other error correction techniques.
Remember that this simulation represents a simplified version of real-world scenarios, and CRC
is just one type of error correction code. More complex error correction codes, such as Reed-Solomon
codes, may require additional considerations and calculations.
RESULT:
Thus the above simulation program has been executed successfully.