UNITED INSTITUTE OF TECHNOLOGY

Periyanaickenpalayam, Coimbatore- 641 020.

CS8581

NETWORKS LABORATORY

DEPARTMENT OF
COMPUTER SCIENCE AND ENGINEERING
 UNITED INSTITUTE OF TECHNOLOGY
Periyanaickenpalayam, Coimbatore- 641 020.

This is to certify that the record work entitled

CS8581 – NETWORKS LABORATORY

is the bonafide record of practical work done by

Name :

Register No : -------------------------------------------------------------------------------

in V semester of B.E Computer Science and Engineering

during the academic year 2020-2021

Staff-in-charge Head of the Department

Submitted for the University Practical Examination held on ------------------------

Internal Examiner External Examiner

 TABLE OF CONTENTS

EXP. PAGE Staff

DATE EXPERIMENT TITLE MARKS
NO. NO. Signature
EX NO : 1 USAGE OF BASIC COMMANDS

AIM: To Learn to use commands like tcpdump, netstat, ifconfig, nslookup and traceroute

1. Tcpdump
The tcpdump utility allows you to capture packets that flow within your network to assist in network
troubleshooting. The following are several examples of using tcpdump with different options. Traffic is captured
based on a specified filter.
Options Description
-D Print a list of network
interfaces.
-i Specify an interface on which
to capture.
-c Specify the number of
packets to receive.
-v, -vv, -vvv Increase the level of detail
(verbosity).
-w Write captured data to a file.
-r Read captured data from a
file.
Many other options and arguments can be used with tcpdump. The following are some
specific examples of the power of the tcpdump utility.
1. Display traffic between 2 hosts
To display all traffic between two hosts (represented by variables host1 and host2):
# tcpdump host host1 and host2
2. Display traffic from a source or destination host only
To display traffic from only a source (src) or destination (dst) host:
# tcpdump src host
# tcpdump dst host
3. Display traffic for a specific protocol
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
4. Filtering based on source or destination port
To filter based on a source or destination port:
# tcpdump src port ftp
# tcpdump dst port http
2.Netstat
Netstat is a common command line TCP/IP networking available in most versions of Windows, Linux, UNIX and
other operating systems. 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.
NETSTAT -a -b -e -n -o -p proto -r -s -v interval
-a Displays all connections and listening ports.
-b
Displays the executable involved in creating each connection or listening port. In some cases well-known
executables host multiple independent components, and in these cases the sequence of components involved in
creating the connection or listening port is displayed. In this case the executable name is in [] at the bottom, on
top is the component it called, and so forth until TCP/IP was reached. Note that this option can be time-consuming
and will fail unless you have sufficient permissions.
-e Displays Ethernet statistics. This may be combined with the -s option.
-n Displays addresses and port numbers in numerical form.
-o Displays the owning process ID associated with each connection.
-p
proto
Shows connections for the protocol specified by proto; proto may be any of: TCP,UDP, TCPv6, or UDPv6. If used
with the -s option to display per-protocol statistics, proto may be any of: IP, IPv6, ICMP, ICMPv6, TCP, TCPv6,
UDP, or UDPv6.
-r Displays the routing table.
-s
Displays per-protocol statistics. By default, statistics are shown for IP, IPv6, ICMP, ICMPv6, TCP, TCPv6, UDP,
and UDPv6; the -p option may be used to specify a subset of the default.
-v When used in conjunction with -b, will display sequence of components involved in creating the connection or
listening port for all executables. interval
Redisplays selected statistics, pausing interval seconds between each display. Press CTRL+C to stop redisplaying
statistics. If omitted, netstat will print the current configuration information once.
Syntax
netstat [-a] [-e] [-n] [-o] [-p Protocol] [-r] [-s] [Interval]
Parameters
Used without
parameters displays active TCP connections.
-a Displays all active TCP connections and the TCP and UDP ports on which the computer is listening.
-e Displays Ethernet statistics, such as the number of bytes and packets sent and received. This parameter can be
combined with -s.
-n Displays active TCP connections, however, addresses and port numbers are expressed numerically and no attempt
is made to determine names.
-o
Displays active TCP connections and includes the process ID (PID) for each connection. You can find the
application based on the PID on the Processes tab in Windows Task Manager. This parameter can be combined with
-a, -n,
and -p.
-p
Shows connections for the protocol specified by Protocol. In this case, the Protocol can be tcp, udp, tcpv6, or udpv6.
If this parameter is used with -s to display statistics by protocol, Protocol can be tcp, udp, icmp, ip, tcpv6, udpv6,
icmpv6, or ipv6.
-s
Displays statistics by protocol. By default, statistics are shown for the TCP, UDP, ICMP, and IP protocols. If the
IPv6 protocol for Windows XP is installed,statistics are shown for the TCP over IPv6, UDP over IPv6, ICMPv6, and
IPv6 protocols. The -p parameter can be used to specify a set of protocols.
-r Displays the contents of the IP routing table. This is equivalent to the route
print command.
Interval
Redisplays the selected information every Interval seconds. Press CTRL+C to stop the redisplay. If this parameter is
omitted, netstat prints the selected information only once.
/? - Displays help at the command prompt.
3. Ifconfig
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. It also allows some control over active TCP/IP
connections. Ipconfig replaced the older winipcfg utility.
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 physicaland virtual network adapter
Syntax
ipconfig [/all] [/renew [Adapter]] [/release [Adapter]] [/flushdns] [/displaydns] [/registerdns]
[/showclassid Adapter] [/setclassid Adapter [ClassID]]
Parameters
Used without
parameters displays the IP address, subnet mask, and default gateway for all adapters. /all Displays the full TCP/IP
configuration for all adapters. Without this parameter, ipconfig displays only the IP address, subnet mask, and
default gateway values for each adapter. Adapters can represent physical interfaces, such as installed network
adapters, or logical interfaces, such as dial-up connections.
/renew
[Adapter]
Renews DHCP configuration for all adapters (if an adapter is not specified) or for a specific adapter if the Adapter
parameter is included. This parameter is available only on computers with adapters that are configured to obtain an
IP address automatically. To specify an adapter name, type the adapter name that appears when you use ipconfig
without parameters.
/release
[Adapter]
Sends a DHCPRELEASE message to the DHCP server to release the current DHCP configuration and discard the IP
address configuration for either all adapters (if an adapter is not specified) or for a specific adapter if the Adapter
parameter is included. This parameter disables TCP/IP for adapters configured to obtain an IP address automatically.
To specify an adapter name, type the adapter name that appears when you use ipconfig without parameters.
/flushdns
Flushes and resets the contents of the DNS client resolver cache. During DNS troubleshooting, you can use this
procedure to discard negative cache entries from the cache, as well as any other entries that have been added
dynamically.
/displaydns
Displays the contents of the DNS client resolver cache, which includes both entries preloaded from the local Hosts
file and any recently obtained resource records for name queries resolved by the computer. The DNS Client
service uses this information to resolve frequently queried names quickly, before querying its configured DNS
servers.
/registerdns
Initiates manual dynamic registration for the DNS names and IP addresses that are configured at a computer. You
can use this parameter to troubleshoot a failed DNS name registration or resolve a dynamic update problem between
a client and the DNS server without rebooting the client computer. The DNS settings in the advanced properties of
the TCP/IP protocol determine which names are registered in DNS.
/showclassid
Adapter Displays the DHCP class ID for a specified adapter. To see the DHCP class ID for all adapters, use the
asterisk (*) wildcard character in place of Adapter. This parameter is available only on computers with adapters that
are configured to obtain an IP address automatically.
/setclassid
Adapter [ClassID] Configures the DHCP class ID for a specified adapter. To set the DHCP class ID for all adapters,
use the asterisk (*) wildcard character in place of Adapter. This parameter is available only on computers with
adapters that are configured to obtain an IP address automatically. If a DHCP class ID is not specified, the current
class ID is removed.
Examples:
Ipconfig To display the basic TCP/IP configuration for all adapters
ipconfig /all To display the full TCP/IP configuration for all adapters
ipconfig /renew "Local Area
Connection"
To renew a DHCP-assigned IP address configuration for only
the Local Area Connection adapter
ipconfig /flushdns To flush the DNS resolver cache when troubleshooting DNS
name resolution problems
ipconfig /showclassid Local To display the DHCP class ID for all adapters with names
that start with Local
ipconfig /setclassid "Local Area
Connection" TEST
To set the DHCP class ID for the Local Area Connection
adapter to TEST
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.
5. traceroute
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.
tracert www.google.com
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 www.google.com.
Tracing route to www.l.google.com [209.85.225.104]
over a maximum of 30 hops:
1 <1 ms <1 ms <1 ms 10.1.0.1
2 35 ms 19 ms 29 ms 98.245.140.1
3 11 ms 27 ms 9 ms te-0-3.dnv.comcast.net [68.85.105.201]
13 81 ms 76 ms 75 ms 209.85.241.37
14 84 ms 91 ms 87 ms 209.85.248.102
15 76 ms 112 ms 76 ms iy-f104.1e100.net [209.85.225.104]
Trace complete.
tracert -j 10.12.0.1 10.29.3.1 10.1.44.1 www.google.com

RESULT

Thus the commands tcpdump, netstat, ifconfig, nslookup and traceroute were examined, analyzed and understood.
EX.NO 2. HTTP web client program to download a web page using TCP sockets.

Aim:
To write a java program for socket for HTTP for web page upload and download .

Algorithm
1.Start the program.
2.Get the frame size from the user
3.To create the frame based on the user request.
4.To send frames to server from the client side.
5.If your frames reach the server it will send ACK signal to client otherwise it will send NACK signal to client.
6.Stop the program

Program :
import java.io.*;
import java.net.*;
public class SocketHTTPClient
{
public static void main(String[] args)
{
String hostName = "www.sunnetwork.in";
int portNumber = 80;
try
{
Socket socket = new Socket(hostName, portNumber);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in =new BufferedReader(new InputStreamReader(socket.getInputStream()));
out.println("GET / HTTP/1.1\nHost: www.sunnetwork.in\n\n");
String inputLine;
while ((inputLine = in.readLine()) != null)
{
System.out.println(inputLine);
}
}
catch (UnknownHostException e)
{
System.err.println("Don't know about host " + hostName);
System.exit(1);
}
catch (IOException e)
{
System.err.println("Couldn't get I/O for the connection to " + hostName);
System.exit(1);
}
}
}

Output:

Result:

Thus the program for creating sockets for HTTP web page to download was implemented .
EX.NO 3a Applications using TCP sockets like Echo client and Echo server

Aim
To write a java program for applications using TCP sockets like Echo client and Echo server

Algorithm
1.Start the program.
2.Get the frame size from the user
3.To create the framebased on the user request.
4.To send frames to server from the client side.
5.If your frames reach the server it will send ACK signal to client otherwise it will send NACK signal to client.
6.Stop the program

Program:

EchoServer.Java:
import java.io.*;
import java.net.*;
public class EchoServer
{
public EchoServer(int portnum)
{
try
{
server = new ServerSocket(portnum);
}
catch (Exception err)
{
System.out.println(err);
}
}
public void serve()
{
try
{
while (true)
{
Socket client = server.accept();
BufferedReader r = new BufferedReader(new InputStreamReader(client.getInputStream()));
PrintWriter w = new PrintWriter(client.getOutputStream(), true);
w.println("Welcome to the Java EchoServer. Type 'bye' to close.");
String line;
do
{
line = r.readLine();
if ( line != null )
w.println("Got: "+ line);
System.out.println (line);
}
while ( !line.trim().equals("bye") );
client.close();
}
}
catch (Exception err)
{
System.err.println(err);
}
}
public static void main(String[] args)
{
EchoServer s = new EchoServer(9999);
s.serve();
}
private ServerSocket server;
}

EchoClient.java :
import java.io.*;
import java.net.*;
public class EchoClient
{
public static void main(String[] args)
{
try
{
Socket s = new Socket("127.0.0.1", 9999);
BufferedReader r = new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter w = new PrintWriter(s.getOutputStream(), true);
BufferedReader con = new BufferedReader(new InputStreamReader(System.in));
String line;
do
{
line = r.readLine();
if ( line != null )
System.out.println(line);
line = con.readLine();
w.println(line);
}
while ( !line.trim().equals("bye") );
}
catch (Exception err)
{
System.err.println(err);
}
}
}

Result:
Thus the java program to concurrently communicate using TCP Sockets was executed successfully.
EX.NO 3b Chat Application

AIM:

To implement a CHAT application using TCP Socket.

Concept:
1. It uses TCP socket communication .We have a server as well as a client.
2. Both can be run in the same machine or different machines. If both are running in
the machine, the address to be given at the client side is local host address.
3. If both are running in different machines, then in the client side we need to specify
the ip address of machine in which server application is running.

Program:
Chatserver.java:
import java.net.*;
import java.io.*;
public class chatserver
{
public static void main(String args[]) throws Exception
{
ServerSocket ss=new ServerSocket(2000);
Socket sk=ss.accept();
BufferedReader cin=new BufferedReader(new
InputStreamReader(sk.getInputStream()));
PrintStream cout=new PrintStream(sk.getOutputStream());
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
String s;
while ( true )
{
s=cin.readLine();
if (s.equalsIgnoreCase("END"))
{
cout.println("BYE");
break;
}
System. out.print("Client : "+s+"\n");
System.out.print("Server : ");
s=stdin.readLine();
cout.println(s);
}
ss.close();
sk.close();
cin.close();
cout.close();
stdin.close();
}
}

Chatclient.java
import java.net.*;
import java.io.*;
public class chatclient
{
public static void main(String args[]) throws Exception
{
Socket sk=new Socket("127.0.0.1",2000);
BufferedReader sin=new BufferedReader(new
InputStreamReader(sk.getInputStream()));
PrintStream sout=new PrintStream(sk.getOutputStream());
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
String s;
while ( true )
{
System.out.print("Client : ");
s=stdin.readLine();
sout.println(s);
s=sin.readLine();
System.out.print("Server : "+s+"\n");
if ( s.equalsIgnoreCase("BYE") )
break;
}
sk.close();
sin.close();
sout.close();
stdin.close();
}
}
OUTPUT:
Server:
E:\nwlab>javac *.java
E:\nwlab>java chatserver
Client : hi
Server : hi
Client:
E:\nwlab>java chatclient
Client : hi
Server : hi
Client :

Result:
Thus, the CHAT application using TCP Socket is implemented successfully.
EX NO 3c File Transfer

AIM:

To write a java program for file transfer using TCP Sockets.

Algorithm
Server
Step1: Import java packages and create class file server.
Step2: Create a new server socket and bind it to the port.
Step3: Accept the client connection
Step4: Get the file name and stored into the BufferedReader.
Step5: Create a new object class file and realine.
Step6: If file is exists then FileReader read the content until EOF is reached.
Step7: Stop the program.
Client
Step1: Import java packages and create class file server.
Step2: Create a new server socket and bind it to the port.
Step3: Now connection is established.
Step4: The object of a BufferReader class is used for storing data content which has been retrieved from socket
object.
Step5 The connection is closed.
Step6: Stop the program.

Program
File Server :
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
public class FileServer
{
public static void main(String[] args) throws Exception
{
//Initialize Sockets
ServerSocket ssock = new ServerSocket(5000);
Socket socket = ssock.accept();
//The InetAddress specification
InetAddress IA = InetAddress.getByName("localhost");
//Specify the file
File file = new File("e:\\Bookmarks.html");
FileInputStream fis = new FileInputStream(file);
BufferedInputStream bis = new BufferedInputStream(fis);
//Get socket's output stream
OutputStream os = socket.getOutputStream();
//Read File Contents into contents array
byte[] contents;
long fileLength = file.length();
long current = 0;
long start = System.nanoTime();
while(current!=fileLength){
int size = 10000;
if(fileLength - current >= size)
current += size;
else{
size = (int)(fileLength - current);
current = fileLength;
}
contents = new byte[size];
bis.read(contents, 0, size);
os.write(contents);
System.out.print("Sending file ... "+(current*100)/fileLength+"% complete!");
}
os.flush();
//File transfer done. Close the socket connection!
socket.close();
ssock.close();
System.out.println("File sent succesfully!");
}}

File Client
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.Socket;
public class FileClient {
public static void main(String[] args) throws Exception{
//Initialize socket
Socket socket = new Socket(InetAddress.getByName("localhost"), 5000);
byte[] contents = new byte[10000];
//Initialize the FileOutputStream to the output file's full path.
FileOutputStream fos = new FileOutputStream("e:\\Bookmarks1.html");
BufferedOutputStream bos = new BufferedOutputStream(fos);
InputStream is = socket.getInputStream();
//No of bytes read in one read() call
int bytesRead = 0;
while((bytesRead=is.read(contents))!=-1)
bos.write(contents, 0, bytesRead);
bos.flush();
socket.close();
System.out.println("File saved successfully!");
}
}

Output
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
File saved successfully!
E:\nwlab>
.

RESULT
Thus the java program file transfer application using TCP Sockets was executed
EX.NO 4. Simulation of DNS using UDP sockets.

Aim :
To write a java program Simulation of DNS using UDP Sockets

Algorithm
1.Start the program.
2.Get the frame size from the user
3.To create the frame based on the user request.
4.To send frames to server from the client side.
5.If your frames reach the server it will send ACK signal to client otherwise it will send NACK signal to client.
6.Stop the program

Program
UDP DNS Server

import java.io.*;
import java.net.*;
public class dnsserver
{
private static int indexOf(String[] array, String str)
{
str = str.trim();
for (int i=0; i < array.length; i++)
{
if (array[i].equals(str)) return i;
}
return -1;
}
public static void main(String arg[])throws IOException
{
String[] hosts = {"zoho.com", "gmail.com","google.com", "facebook.com"};
String[] ip = {"172.28.251.59", "172.217.11.5","172.217.11.14", "31.13.71.36"}; System.out.println("Press Ctrl
+ C to Quit");
while (true)
{
DatagramSocket serversocket=new DatagramSocket(1362);
byte[] senddata = new byte[1021];
byte[] receivedata = new byte[1021];
DatagramPacket recvpack = new DatagramPacket(receivedata, receivedata.length);
serversocket.receive(recvpack);
String sen = new String(recvpack.getData());
InetAddress ipaddress = recvpack.getAddress();
int port = recvpack.getPort();
String capsent;
System.out.println("Request for host " + sen);
if(indexOf (hosts, sen) != -1)
capsent = ip[indexOf (hosts, sen)];
else
capsent = "Host Not Found"; senddata = capsent.getBytes();
DatagramPacket pack = new DatagramPacket (senddata, senddata.length,ipaddress,port);
serversocket.send(pack);
serversocket.close();
}
}
}

UDP DNS Client –

import java.io.*;
import java.net.*;
public class dnsclient
{
public static void main(String args[])throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
DatagramSocket clientsocket = new DatagramSocket();
InetAddress ipaddress;
if (args.length == 0)
ipaddress = InetAddress.getLocalHost();
else
ipaddress = InetAddress.getByName(args[0]);
byte[] senddata = new byte[1024];
byte[] receivedata = new byte[1024];
int portaddr = 1362;
System.out.print("Enter the hostname : ");
String sentence = br.readLine();
senddata = sentence.getBytes();
DatagramPacket pack = new DatagramPacket(senddata,senddata.length, ipaddress,portaddr);
clientsocket.send(pack);
DatagramPacket recvpack =new DatagramPacket(receivedata,receivedata.length);
clientsocket.receive(recvpack);
String modified = new String(recvpack.getData());
System.out.println("IP Address: " + modified);
clientsocket.close();
}
}
OUTPUT
Server
E:\nwlab>java dnsserver
Press Ctrl + C to Quit
Request for host google.com
Request for host flipkart.com

Client
E:\nwlab>java dnsclient
Enter the hostname : google.com
IP Address: 172.217.11.14
E:\nwlab>java dnsclient
Enter the hostname : flipkart.com
IP Address: Host Not Found
E:\nwlab>

Result:
Thus the DNS application program was executed.
EX.NO 5A Program for Address Resolution Protocol (ARP) using TCP

Aim:
To write a java program for simulating ARP protocols using TCP

ALGORITHM:
Client
1. Start the program
2. Using socket connection is established between client and server.
3. Get the IP address to be converted into MAC address.
4. Send this IP address to server.
5. Server returns the MAC address to client.
Server
1. Start the program
2. Accept the socket which is created by the client.
3. Server maintains the table in which IP and corresponding MAC addresses are stored.
4. Read the IP address which is send by the client.
5. Map the IP address with its MAC address and return the MAC address to client.

Program

Client:
import java.io.*; import java.net.*; import java.util.*; class Clientarp
{
public static void main(String args[])
{
try
{
BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); Socket clsct=new
Socket("127.0.0.1",5604);
DataInputStream din=new DataInputStream(clsct.getInputStream()); DataOutputStream dout=new
DataOutputStream(clsct.getOutputStream()); System.out.println("Enter the Logical address(IP):");
String str1=in.readLine(); dout.writeBytes(str1+'\n'); String str=din.readLine();
System.out.println("The Physical Address is: "+str);
clsct.close();
}
catch (Exception e)
{ System.out.println(e);
}
}
}

Server:
import java.io.*; import java.net.*; import java.util.*;
class Serverarp
{
public static void main(String args[])
{
try
{
ServerSocket obj=new ServerSocket(5604);
Socket obj1=obj.accept();
while(true)
{
DataInputStream din=new DataInputStream(obj1.getInputStream()); DataOutputStream dout=new
DataOutputStream(obj1.getOutputStream()); String str=din.readLine();
String ip[]={"165.165.80.80","165.165.79.1"}; String mac[]={"6A:08:AA:C2","8A:BC:E3:FA"}; for(int
i=0;i<ip.length;i++)
{
if(str.equals(ip[i]))
{
dout.writeBytes(mac[i]+'\n');
break;
}}
obj.close();
}}
catch(Exception e)
{
System.out.println(e);
}}}

Output:
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 ARP protocol using TCP Sockets program was executed.
EX.NO 5B Program for Reverse Address Resolution Protocol (RARP) using UDP

Aim:
To write a java program for simulating RARP protocols using UDP

ALGORITHM

Client
1.Start the program
2. using datagram sockets UDP function is established.
2.Get the MAC address to be converted into IP address.
3.Send this MAC address to server.
4.Server returns the IP address to client.

Server
1. Start the program.
2. Server maintains the table in which IP and corresponding MAC addresses are stored.
3. Read the MAC address which is send by the client.
4. Map the IP address with its MAC address and return the IP address to client.

Program
Client:
import java.io.*;
import java.net.*;
import java.util.*;
class Clientrarp
{
public static void main(String args[])
{
try
{
DatagramSocket client=new DatagramSocket();
InetAddress addr=InetAddress.getByName("127.0.0.1");
byte[] sendbyte=new byte[1024];
byte[] receivebyte=new byte[1024];
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter the Physical address (MAC):");
String str=in.readLine(); sendbyte=str.getBytes();
DatagramPacket sender=new DatagramPacket(sendbyte,sendbyte.length,addr,1309);
client.send(sender);
DatagramPacket receiver=new DatagramPacket(receivebyte,receivebyte.length);
client.receive(receiver);
String s=new String(receiver.getData());
System.out.println("The Logical Address is(IP): "+s.trim());
client.close();
}
catch(Exception e)
{
System.out.println(e);
}
}
}
Server:
import java.io.*;
import java.net.*;
import java.util.*;
class Serverrarp
{
public static void main(String args[])
{
try
{
DatagramSocket server=new DatagramSocket(1309);
while(true)
{
byte[] sendbyte=new byte[1024];
byte[] receivebyte=new byte[1024];
DatagramPacket receiver=new DatagramPacket(receivebyte,receivebyte.length);
server.receive(receiver);
String str=new String(receiver.getData());
String s=str.trim();
InetAddress addr=receiver.getAddress();
int port=receiver.getPort();
String ip[]={"165.165.80.80","165.165.79.1"};
String mac[]={"6A:08:AA:C2","8A:BC:E3:FA"};
for(int i=0;i<ip.length;i++)
{
if(s.equals(mac[i]))
{
sendbyte=ip[i].getBytes();
DatagramPacket sender=new DatagramPacket(sendbyte,sendbyte.length,addr,port);
server.send(sender);
break;
}
}
break;
}
}
catch(Exception e)
{
System.out.println(e);
}
}
}

Output:
I:\ex>java Serverrarp12
I:\ex>java Clientrarp12
Enter the Physical address
(MAC): 6A:08:AA:C2
The Logical Address is(IP): 165.165.80.80

Result :

Thus the RARP program using UDP was executed.

Ex No: 6 STUDY OF NETWORK SIMULATOR (NS)

AIM:
To study about NS2 simulator in detail.

THEORY:
Network Simulator (Version 2), widely known as NS2, is simply an event driven simulation tool that has proved
useful in studying the dynamic nature of communication networks. Simulation of wired as well as wireless
network functions and protocols (e.g., routing algorithms, TCP, UDP) can be done using NS2. In general, NS2
provides users with a way of specifying such network protocols and simulating their corresponding behaviors.
Due to its flexibility and modular nature, NS2 has gained constant popularity in the networking research
community since its birth in 1989.

Basic Architecture of NS2:

The above figure shows the basic architecture of NS2. NS2 provides users with an executable command ns
which takes on input argument, the name of a Tcl simulation scripting file. Users are feeding the name of a Tcl
simulation script (which sets up a simulation) as an input argument of an NS2 executable command ns.
In most cases, a simulation trace file is created, and is used to plot graph and/or to create animation. NS2
consists of two key languages: C++ and Object-oriented Tool Command Language (OTcl). While the C++
defines the internal mechanism (i.e., a backend) of the simulation objects, the OTcl sets up simulation by
assembling and configuring the objects as well as scheduling discrete events (i.e., a frontend).
The C++ and the OTcl are linked together using TclCL. Mapped to a C++ object, variables in the OTcl domains
are sometimes referred to as handles. Conceptually, a handle (e.g., n as a Node handle) is just a string
(e.g.,_o10) in the OTcl domain, and does not contain any functionality. instead, the functionality (e.g., receiving
a packet) is defined in the mapped C++ object (e.g., of class Connector). In the OTcl domain, a handle acts as a
frontend which interacts with users and other OTcl objects. It may defines its own procedures and variables to
facilitate the interaction. Note that the member procedures and variables in the OTcl domain are called instance
procedures (instprocs) and instance variables (instvars), respectively

Tcl scripting:
• Tcl is a general purpose scripting language. [Interpreter]
• Tcl runs on most of the platforms such as Unix, Windows, and Mac.
• The strength of Tcl is its simplicity.
• It is not necessary to declare a data type for variable prior to the usage
Basics of TCL
Syntax: command arg1 arg2 arg3
Hello World!
puts stdout{Hello, World!}
Hello, World!
Variables
Command Substitution
set a 5 set len [string length foobar]
set b $a set len [expr [string length foobar] + 9]

Simple Arithmetic
expr 7.2 / 4
Procedures
proc Diag {a b} {
set c [expr sqrt($a * $a + $b * $b)]
return $c }
puts ―Diagonal of a 3, 4 right triangle is [Diag 3 4]‖

Output: Diagonal of a 3, 4 right triangle is 5.0

NS Simulator Preliminaries.

1. Initialization and termination aspects of the ns simulator.

2. Definition of network nodes, links, queues and topology.

3. Definition of agents and of applications.

4. The nam visualization tool.

5. Tracing and random variables

Initialization and Termination of TCL Script in NS-2

An ns simulation starts with the command
set ns [new Simulator]
Which is thus the first line in the tcl script? This line declares a new variable as using the set command, you can
call this variable as you wish, In general people declares it as ns because it is an instance of the Simulator class,
so an object the code[new Simulator] is indeed the installation of the class Simulator using the reserved word
new.
In order to have output files with data on the simulation (trace files) or files used for visualization (nam
files), we need to create the files using ―”open” command:
#Open the Trace file
set tracefile1 [open out.tr w]
$ns trace-all $tracefile1
#Open the NAM trace file
set namfile [open out.nam w]
$ns namtrace-all $namfile
The above creates a dta trace file called ―out.tr‖ and a nam visualization trace file called ―out.nam‖.Within the
tcl script,these files are not called explicitly by their names, but instead by pointers that are declared above and
called ―tracefile1 and ―nam file respectively. Remark that they begins with a # symbol.The second line open
the file ―out.tr‖ to be used for writing, declared with the letter ―w‖.The third line uses a simulator method
called trace-all that have as parameter the name of the file where the traces will go. The last line tells the
simulator to record all simulation traces in NAM input format. It also gives the file name that the trace will be
written to later by the command $ns flush-trace. In our case, this will be the file pointed at by the pointer
―$namfile ,i.e the file ―out.tr‖. The termination of the program is done using a ―finish‖ procedure.

#Define a ‘finish’ procedure

Proc finish { } {
global ns tracefile1 namfile
$ns flush-trace
Close $tracefile1
Close $namfile
Exec nam out.nam &
Exit 0
The word proc declares a procedure in this case called finish and without arguments. The word global is used to
tell that we are using variables declared outside the procedure. The simulator method ―flush-trace” will dump
the traces on the respective files. The tcl command
―close” closes the trace files defined before and exec executes the nam program for visualization. The
command exit will ends the application and return the number 0 as status to the system. Zero is the default for a
clean exit. Other values can be used to say that is a exit because something fails.
At the end of ns program we should call the procedure ―finish‖ and specify at what time the termination should
occur.
For example,
$ns at 125.0 “finish”
will be used to call ―finish‖ at time 125sec.Indeed,the at method of the simulator allows us to schedule events
explicitly.
The simulation can then begin using the command
$ns run
Definition of a network of links and nodes
The way to define a node is
set n0 [$ns node]
The node is created which is printed by the variable n0. When we shall refer to that node in the script we shall
thus write $n0. Once we define several nodes, we can define the links that connect them. An example of a
definition of a link is:
$ns duplex-link $n0 $n2 10Mb 10ms DropTail
Which means that $n0 and $n2 are connected using a bi-directional link that has 10ms of propagation delay and
a capacity of 10Mb per sec for each direction. To define a directional link instead of a bi-directional one, we
should replace “duplexlink” by “simplex-link”. In NS, an output queue of a node is implemented as a part of
each link whose input is that node. The definition of the link then includes the way to handle overflow at that
queue. In our case, if the buffer capacity of the output queue is exceeded then the last packet to arrive is
dropped. Many alternative options exist, such as the RED (Random Early Discard) mechanism, the FQ (Fair
Queuing), the DRR (Deficit Round Robin), the stochastic Fair Queuing (SFQ) and the CBQ (which including a
priority and a round-robin scheduler). In ns, an output queue of a node is implemented as a part of each link
whose input is that node. We should also define the buffer capacity of the queue related to each link. An
example would be:
#set Queue Size of link (n0-n2) to 20 $ns queue-limit $n0 $n2 20
Agents and Applications
We need to define routing (sources, destinations) the agents (protocols) the application that use them
FTP over TCP TCP is a dynamic reliable congestion control protocol. It uses Acknowledgements created by
the destination to know whether packets are well received. There are number variants of the TCP protocol, such
as Tahoe, Reno, NewReno, Vegas. The type of agent appears in the first line:
set tcp [new Agent/TCP]
The command
$ns attach-agent $n0 $tcp
defines the source node of the tcp connection. The command
set sink [new Agent /TCPSink]
Defines the behavior of the destination node of TCP and assigns to it a pointer called sink
#Setup a UDP connection
set udp [new Agent/UDP] $ns attach-agent $n1 $udp set null [new Agent/Null] $ns attach-agent $n5 $null
$ns connect $udp $null $udp set fid_2
#setup a CBR over UDP connection
set cbr [new Application/Traffic/CBR] $cbr attach-agent $udp $cbr set packetsize_ 100 $cbr set rate_
0.01Mb $cbr set random_ false
Above shows the definition of a CBR application using a UDP agent.
The command
$ns attach-agent $n4 $sink
defines the destination node.
The command
$ns connect $tcp $sink
finally makes the TCP connection between the source and destination nodes.
TCP has many parameters with initial fixed defaults values that can be changed if mentioned explicitly. For
example, the default TCP packet size has a size of 1000bytes.This can be changed to another value, say
552bytes, using the command $tcp set packetSize_ 552. When we have several flows, we may wish to
distinguish them so that we can identify them with different colors in the visualization part. This is done by the
command $tcp set fid_ 1 that assigns to the TCP connection a flow identification of “1”.We shall later give the
flow identification of “2” to the UDP connection.
CBR over UDP
A UDP source and destination is defined in a similar way as in the case of TCP. Instead of defining the rate in
the command $cbr set rate_ 0.01Mb, one can define the time interval between transmission of packets using the
command.
$cbr set interval_ 0.005
The packet size can be set to some value using
$cbr set packetSize_ <packet size>
Scheduling Events NS is a discrete event based simulation. The tcp script defines when event should occur.
The initializing command set ns [new Simulator] creates an event scheduler, and events are then scheduled
using the format:
$ns at <time> <event>
The scheduler is started when running ns that is through the command $ns run. The beginning and end of the
FTP and CBR application can be done through the following command
$ns at 0.1 “$cbr start” $ns at 1.0 “ $ftp start” $ns at 124.0 “$ftp stop” $ns at 124.5 “$cbr
stop”

RESULT:

Thus the Network Simulator 2 is studied in detail.

EX.NO 7. Study of TCP/UDP Performance

Aim: To Study the Performance of TCP and UDP protocols.

STUDY – 1 TCP

The transmission Control Protocol (TCP) is one of the most important protocols of Internet Protocols suite. It is
most widely used protocol for data transmission in communication network such as internet.

Features
 TCP is reliable protocol. That is, the receiver always sends either positive or negative
acknowledgement about the data packet to the sender, so that the sender always has bright clue about
whether the data packet is reached the destination or it needs to resend it.
 TCP ensures that the data reaches intended destination in the same order it was sent.
 TCP is connection oriented. TCP requires that connection between two remote points be established
before sending actual data.
 TCP provides error-checking and recovery mechanism.
 TCP provides end-to-end communication.
 TCP provides flow control and quality of service.
 TCP operates in Client/Server point-to-point mode.
 TCP provides full duplex server, i.e. it can perform roles of both receiver and sender.

Header
The length of TCP header is minimum 20 bytes long and maximum 60 bytes.

 Source Port (16-bits) - It identifies source port of the application process on the sending device.
 Destination Port (16-bits) - It identifies destination port of the application process on the receiving
device.
 Sequence Number (32-bits) - Sequence number of data bytes of a segment in a session.
 Acknowledgement Number (32-bits) - When ACK flag is set, this number contains the next sequence
number of the data byte expected and works as acknowledgement of the previous data received.
 Data Offset (4-bits) - This field implies both, the size of TCP header (32-bit words) and the offset of
data in current packet in the whole TCP segment.
  Reserved (3-bits) - Reserved for future use and all are set zero by default.
 Flags (1-bit each)
o NS - Nonce Sum bit is used by Explicit Congestion Notification signaling process.
o CWR - When a host receives packet with ECE bit set, it sets Congestion Windows Reduced
to acknowledge that ECE received.
o ECE -It has two meanings:
-If SYN bit is clear to 0, then ECE means that the IP packet has its CE (congestion
experience) bit set.
-If SYN bit is set to 1, ECE means that the device is ECT capable.
 URG - It indicates that Urgent Pointer field has significant data and should be processed.
 ACK - It indicates that Acknowledgement field has significance. If ACK is cleared to 0, it indicates
that packet does not contain any acknowledgement.
 PSH - When set, it is a request to the receiving station to PUSH data (as soon as it comes) to the
receiving application without buffering it.
o RST - Reset flag has the following features:
- It is used to refuse an incoming connection.
- It is used to reject a segment.
- It is used to restart a connection.
 SYN - This flag is used to set up a connection between hosts.
 FIN - This flag is used to release a connection and no more data is exchanged thereafter. Because
packets with SYN and FIN flags have sequence numbers, they are processed in correct order.
 Windows Size - This field is used for flow control between two stations and indicates the amount of
buffer (in bytes) the receiver has allocated for a segment, i.e. how much data is the receiver expecting.
 Checksum - This field contains the checksum of Header, Data and Pseudo Headers.
 Urgent Pointer - It points to the urgent data byte if URG flag is set to 1.
 Options - It facilitates additional options which are not covered by the regular header. Option field is
always described in 32-bit words. If this field contains data less than 32-bit, padding is used to cover
the remaining bits to reach 32-bit boundary.

Addressing
TCP communication between two remote hosts is done by means of port numbers (TSAPs). Ports numbers can
range from 0 – 65535 which are divided as:
 System Ports (0 – 1023)
 User Ports ( 1024 – 49151)
 Private/Dynamic Ports (49152 – 65535)

Connection Management
TCP communication works in Server/Client model. The client initiates the connection and the server either
accepts or rejects it. Three-way handshaking is used for connection management.
Establishment
Client initiates the connection and sends the segment with a Sequence number. Server acknowledges it back
with its own Sequence number and ACK of client’s segment which is one more than client’s Sequence number.
Client after receiving ACK of its segment sends an acknowledgement of Server’s response.
Release
Either of server and client can send TCP segment with FIN flag set to 1. When the receiving end responds it
back by Acknowledging FIN, that direction of TCP communication is closed and connection is released.
Bandwidth Management
TCP uses the concept of window size to accommodate the need of Bandwidth management. Window size tells
the sender at the remote end, the number of data byte segments the receiver at this end can receive. TCP uses
slow start phase by using window size 1 and increases the window size exponentially after each successful
communication. For example, the client uses windows size 2 and sends 2 bytes of data. When the
acknowledgement of this segment received the windows size is doubled to 4 and next sent the segment sent will
be 4 data bytes long. When the acknowledgement of 4-byte data segment is received, the client sets windows
size to 8 and so on.
If an acknowledgement is missed, i.e. data lost in transit network or it received NACK, then the window size is
reduced to half and slow start phase starts again.
Error Control &and Flow Control
TCP uses port numbers to know what application process it needs to handover the data segment. Along with
that, it uses sequence numbers to synchronize itself with the remote host. All data segments are sent and
received with sequence numbers. The Sender knows which last data segment was received by the Receiver
when it gets ACK. The Receiver knows about the last segment sent by the Sender by referring to the sequence
number of recently received packet.
If the sequence number of a segment recently received does not match with the sequence number the receiver
was expecting, then it is discarded and NACK is sent back. If two segments arrive with the same sequence
number, the TCP timestamp value is compared to make a decision.
Multiplexing
The technique to combine two or more data streams in one session is called Multiplexing. When a TCP client
initializes a connection with Server, it always refers to a well-defined port number which indicates the
application process. The client itself uses a randomly generated port number from private port number pools.
Using TCP Multiplexing, a client can communicate with a number of different application process in a single
session. For example, a client requests a web page which in turn contains different types of data (HTTP, SMTP,
FTP etc.) the TCP session timeout is increased and the session is kept open for longer time so that the three-way
handshake overhead can be avoided.
This enables the client system to receive multiple connection over single virtual connection. These virtual
connections are not good for Servers if the timeout is too long.

Congestion Control
When large amount of data is fed to system which is not capable of handling it, congestion occurs. TCP controls
congestion by means of Window mechanism. TCP sets a window size telling the other end how much data
segment to send. TCP may use three algorithms for congestion control:
 Additive increase, Multiplicative Decrease
 Slow Start
 Timeout React

Timer Management
TCP uses different types of timer to control and management various tasks:
Keep-alive timer:
 This timer is used to check the integrity and validity of a connection.
 When keep-alive time expires, the host sends a probe to check if the connection still exists.

Retransmission timer:
 This timer maintains stateful session of data sent.
 If the acknowledgement of sent data does not receive within the Retransmission time, the data segment
is sent again.

Persist timer:
 TCP session can be paused by either host by sending Window Size 0.
 To resume the session a host needs to send Window Size with some larger value.
 If this segment never reaches the other end, both ends may wait for each other for infinite time.
 When the Persist timer expires, the host re-sends its window size to let the other end know.
 Persist Timer helps avoid deadlocks in communication.

Timed-Wait:
 After releasing a connection, either of the hosts waits for a Timed-Wait time to terminate the
connection completely.
 This is in order to make sure that the other end has received the acknowledgement of its connection
termination request.
 Timed-out can be a maximum of 240 seconds (4 minutes).

Crash Recovery
TCP is very reliable protocol. It provides sequence number to each of byte sent in segment. It provides the
feedback mechanism i.e. when a host receives a packet, it is bound to ACK that packet having the next sequence
number expected (if it is not the last segment).
When a TCP Server crashes mid-way communication and re-starts its process it sends TPDU broadcast to all its
hosts. The hosts can then send the last data segment which was never unacknowledged and carry onwards.

STUDY – 2 UDP
The User Datagram Protocol (UDP) is simplest Transport Layer communication protocol available of the
TCP/IP protocol suite. It involves minimum amount of communication mechanism. UDP is said to be an
unreliable transport protocol but it uses IP services which provides best effort delivery mechanism. In UDP, the
receiver does not generate an acknowledgement of packet received and in turn, the sender does not wait for any
acknowledgement of packet sent. This shortcoming makes this protocol unreliable as well as easier on
processing.
Requirement of UDP
A question may arise, why do we need an unreliable protocol to transport the data? We deploy UDP where the
acknowledgement packets share significant amount of bandwidth along with the actual data. For example, in
case of video streaming, thousands of packets are forwarded towards its users. Acknowledging all the packets is
troublesome and may contain huge amount of bandwidth wastage. The best delivery mechanism of underlying
IP protocol ensures best efforts to deliver its packets, but even if some packets in video streaming get lost, the
impact is not calamitous and can be ignored easily. Loss of few packets in video and voice traffic sometimes
goes unnoticed.
Features
 UDP is used when acknowledgement of data does not hold any significance.
 UDP is good protocol for data flowing in one direction.
 UDP is simple and suitable for query based communications.
 UDP is not connection oriented.
 UDP does not provide congestion control mechanism.
 UDP does not guarantee ordered delivery of data.
 UDP is stateless.
 UDP is suitable protocol for streaming applications such as VoIP, multimedia streaming.

UDP Header
UDP header is as simple as its function.
UDP header contains four main parameters:
 Source Port - This 16 bits information is used to identify the source port of the packet.
 Destination Port - This 16 bits information, is used identify application level service on destination
machine.
 Length - Length field specifies the entire length of UDP packet (including header). It is 16-bits field
and minimum value is 8-byte, i.e. the size of UDP header itself.
 Checksum - This field stores the checksum value generated by the sender before sending. IPv4 has this
field as optional so when checksum field does not contain any value it is made 0 and all its bits are set
to zero.
UDP application
Here are few applications where UDP is used to transmit data:
 Domain Name Services
 Simple Network Management Protocol
 Trivial File Transfer Protocol
 Routing Information Protocol
 Kerberos

Result:
Thus, We studied in detail about the Performance of TCP and UDP protocols.
EX.No 8. Simulation of Distance Vector/Link State Routing.

. Aim:

To simulate and study the link state routing algorithm using simulation using NS2.

Distance Vector routing protocol

Routing is the process of selecting best paths in a network. In the past, the term routing was also used to mean
forwarding network traffic among networks. However this latter function is muchbetter described as simply
forwarding. Routing is performed for many kinds of networks, including the telephone network (circuit
switching), electronic data networks (such as the Internet), and transportation networks. This article is concerned
primarily with routing in electronic data networks using packet switching technology .In packet switching
networks, routing directs packet forwarding (the transit of logically addressed network packets from their source
toward their ultimate destination) through intermediate nodes. Intermediate nodes are typically network
hardware devices such as routers, bridges, gateways, firewalls, or switches. General-purpose computers can also
forward packets and perform routing, though they are not specialized hardware and may suffer from limited
performance. The routing process usually directs forwarding on the basis of routing tables which maintain a
record of the routes to various network destinations. Thus, constructing routing tables, which are held in the
router's memory, is very important for efficient routing. Most routing algorithms use only one network path at a
time. Multipath routing techniques enable the use of multiple alternative paths. In case of overlapping/equal
routes, the following elements are considered in order to decide which routes get installed into the routing table
(sorted by priority):

1. Prefix-Length: where longer subnet masks are preferred (independent of whether it is within a routing

protocol or over different routing protocol)

2. Metric: where a lower metric/cost is preferred (only valid within one and the same routing protocol)

3. Administrative distance: where a lower distance is preferred (only valid between different routing protocols)
Routing, in a more narrow sense of the term, is often contrasted with bridging in its assumption that network
addresses are structured and that similar addresses imply proximity within the network. Structured addresses
allow a single routing table entry to represent the route to a group of devices. In large networks,

structured addressing (routing, in the narrow sense) outperforms unstructured addressing (bridging). Routing has
become the dominant form of addressing on the Internet. Bridging is still widely used within localized
environments.

Algorithm

There are several variants of flooding algorithm. Most work roughly as follows:

1. Each node acts as both a transmitter and a receiver.

2. Each node tries to forward every message to every one of its neighbours except the source node. This results
in every message eventually being delivered to all reachable parts of the network. Algorithms may need to be
more complex than this, since, in some case, precautions have to be taken to avoid wasted duplicate deliveries
and infinite loops, and to allow messages to eventually expire from the system. A variant of flooding called
selective flooding partially addresses these issues by only sending packets to routers in the same direction. In
selective flooding the routers don't send every incoming packet on every line but only on those lines which are
going approximately in the right direction.

Program:

set ns [new Simulator] set nf [open out.nam w]

$ns namtrace-all $nf set tr [open out.tr w]

$ns trace-all $

tr proc finish {} {

global nf ns tr

$ns flush-trace close

$tr exec nam out.nam & exit 0

set n0 [$ns node]

set n1 [$ns node]

set n2 [$ns node]

set n3 [$ns node]

$ns duplex-link $n0 $n1 10Mb 10ms DropTail

$ns duplex-link $n1 $n3 10Mb 10ms DropTail

$ns duplex-link $n2 $n1 10Mb 10ms DropTail

$ns duplex-link-op $n0 $n1 orient right-down

$ns duplex-link-op $n1 $n3 orient right $ns duplex-link-op

$n2 $n1 orient right-up

set tcp [new Agent/TCP]

$ns attach-agent $n0 $tcp

set ftp [new Application/FTP]

$ftp attach-agent $tcp set sink [new Agent/TCPSink]

$ns attach-agent $n3 $sink set udp [new Agent/UDP]

$ns attach-agent $n2 $udp

set cbr [new Application/Traffic/CBR]

$cbr attach-agent $udp set null [new Agent/Null]

$ns attach-agent $n3 $null

$ns connect $tcp $sink

$ns connect $udp $null

$ns rtmodel-at 1.0 down $n1 $n3

$ns rtmodel-at 2.0 up $n1 $n3

$ns rtproto DV $ns at 0.0 "$ftp start"

$ns at 0.0 "$cbr start"

$ns at 5.0 "finish"

$ns run

Result:

Thus the Distance Vector Routing Algorithm was Simulated and studied
EX.No 8b Simulation of Link State Routing.

SIMULATION OF LINK STATE ROUTING ALGORITHM

Aim:

To simulate and study the link state routing algorithm using simulation using NS2. Link State Routing protocol
In link state routing, each router shares its knowledge of its neighborhood with every other router in the internet
work. (i) Knowledge about Neighborhood: Instead of sending its entire routing table a router sends info about its
neighborhood only. (ii) To all Routers: each router sends this information to every other router on the internet
work not just to its neighbor .It does so by a process called flooding. (iii)Information sharing when there is a
change: Each router sends out information about the neighbors when there is change.

ALGORITHM:

1. Create a simulator object

2. Define different colors for different data flows

3. Open a nam trace file and define finish procedure then close the trace file, and execute nam on trace file.

4. Create n number of nodes using for loop

5. Create duplex links between the nodes

6. Setup UDP Connection between n(0) and n(5)

7. Setup another UDP connection between n(1) and n(5)

8. Apply CBR Traffic over both UDP connections

9. Choose Link state routing protocol to transmit data from sender to receiver.

10. Schedule events and run the program.

Program:

set ns [new Simulator]

set nf [open out.nam w]

$ns namtrace-all $nf

set tr [open out.tr w]

$ns trace-all $tr

proc finish {} {

global nf ns tr
$ns flush-trace

close $tr

exec nam out.nam &

exit 0

set n0 [$ns node]

set n1 [$ns node]

set n2 [$ns node]

set n3 [$ns node]

$ns duplex-link $n0 $n1 10Mb 10ms DropTail

$ns duplex-link $n1 $n3 10Mb 10ms DropTail

$ns duplex-link $n2 $n1 10Mb 10ms DropTail

$ns duplex-link-op $n0 $n1 orient right-down

$ns duplex-link-op $n1 $n3 orient right

$ns duplex-link-op $n2 $n1 orient right-up

set tcp [new Agent/TCP]

$ns attach-agent $n0 $tcp

set ftp [new Application/FTP]

$ftp attach-agent $tcp set sink [new Agent/TCPSink]

$ns attach-agent $n3 $sink

set udp [new Agent/UDP]

$ns attach-agent $n2 $udp

set cbr [new Application/Traffic/CBR]

$cbr attach-agent $udp set null [new Agent/Null]

$ns attach-agent $n3 $null

$ns connect $tcp $sink

$ns connect $udp $null

$ns rtmodel-at 1.0 down $n1 $n3

$ns rtmodel-at 2.0 up $n1 $n3

$ns rtproto LS

$ns at 0.0 "$ftp start"

$ns at 0.0 "$cbr start"

$ns at 5.0 "finish"

$ns run

Result:

Thus the program for creating Simulation of Distance Vector/Link State Routing was implemented.
Ex.no.9 PERFORMANCE EVALUATION OF ROUTING PROTOCOLS

AIM:
To Study of performance evaluation of routing protocols using simulation tool

ROUTING PROTOCOLS
There are many routing protocols available. Among them all we are working with AODV and DSR for
performance analysis.

A. Ad-hoc On demand Distance Vector (AODV)

It is purely On-Demand route acquisition routing protocol. It is better protocol than DSDV network as the size
of network may increase depending on the number of vehicle nodes.
1) Path Discovery Process: In order to discover the path between source and destination, a Route Request
message (RREQ) is broadcasted to all the neighbours in radio range who again continue to send the same to
their neighbours in there radio range, until the destination is reached. Every node maintains two counters:
sequence number and broadcast-id in order to maintain loop-free and most recent route information. The
broadcast-id is incremented for every RREQ the source node initiates. If an intermediate node receives the same
copy of request, it discards it without routing it further. When a node forwards the RREQ message, it records the
address of the neighbour from which it received the first copy of the broadcast packet, in order to maintain a
reverse path to the source node. The RREQ packet contains: the source sequence number and the last destination
sequence number know to the source. The source sequence number is used to maintain information about
reverse route and destination sequence number tells about the actual distance to the final node.
2) Route Maintenance: A source node sends a new moving request packet RREQ to find a new route to the
destination. But, if an intermediate node moves from its place, its upstream neighbor noticed the move and
sends a message notification failure of the link to each of its active upstream neighbors to inform them about the
move to source nodes is achieved. After the detection process is again initiated.
B. Dynamic Source Routing (DSR)
It is an On-Demand routing protocol in which the sequence of nodes through which a packet needs to travel is
calculated and maintained as an information in packet header. Every mobile node in the network needs to
maintain a route cache where it caches source routes that it has learned. When a packet is sent, the route-cache
inside the node is compared with the actual route needs to be covered.
1) Route Discovery: The source node broadcasts request-packets to all the neighbours in the network containing
the address of the destination node, and a reply is sent back to the source node with the list of network-nodes
through which it should propagate in the process. Sender initiates the route record as a list with a single element
containing itself followed by the linking of its neighbour in that route. A request packet also contains an
identification number called request-id, which is counter increased only when a new route request packet is
being sent by the source node. To make sure that no loops occur during broadcast, the request is processed in the
given order. A route reply is obtained in DSR by two ways: Symmetric-links (bidirectional), in which the
backward route is followed again to catch the source node. Asymmetric-links (unidirectional) needs to discover
the route up to the source node in the same manner as the forward route is discovered.
2) Route Maintenance: In the hop by hop acknowledgement at data link layer allows the early detection and
retransmission of lost or corrupt packets in the data-link layer. If a transmission error occurs, a route error
packet containing the address of node detecting the error and the host address is sent back to the sender.
Whenever a node receives a route error packet, the hop in error is removed from the route cache and all routes
containing this hop are truncated at that point. When the wireless transmission between two nodes does not
work equally well in both directions, and then end-to-end replies on the application or transport layer may be
used to indicate the status of the route from one host to the other

RESULT
Thus the performance evaluation of routing protocols was studied.
EX.NO 10 Simulation of Error Correction Code(CRC)

AIM :
To Simulation of Error Correction Code using Java.

Theory:
Cyclic redundancy check (CRC)
 Unlike checksum scheme, which is based on addition, CRC is based on binary division.
 In CRC, a sequence of redundant bits, called cyclic redundancy check bits, are appended to the end of
data unit so that the resulting data unit becomes exactly divisible by a second, predetermined binary
number.
 At the destination, the incoming data unit is divided by the same number. If at this step there is no
remainder, the data unit is assumed to be correct and is therefore accepted.
 A remainder indicates that the data unit has been damaged in transit and therefore must be rejected.

Example :
Procedure:
1. Open the editor and type the program for error detection
2. Get the input in the form of bits.
3. Append the redundancy bits.
4. Divide the appended data using a divisor polynomial.
5. The resulting data should be transmitted to the receiver.
6. At the receiver the received data is entered.
7. The same process is repeated at the receiver.
8. If the remainder is zero there is no error otherwise there is some error in the received bits
9. Run the program.

Program:
import java.io.*;
class CRC
{
public static void main(String args[]) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter Generator:");
String gen = br.readLine();
System.out.println("Enter Data:");
String data = br.readLine();
String code = data;
while(code.length() < (data.length() + gen.length() - 1))
code = code + "0";
code = data + div(code,gen);
System.out.println("The transmitted Code Word is: " + code);
System.out.println("Please enter the received Code Word: ");
String rec = br.readLine();
if(Integer.parseInt(div(rec,gen)) == 0)
System.out.println("The received code word contains no errors.");
else
System.out.println("The received code word contains errors.");
}
static String div(String num1,String num2)
{
int pointer = num2.length();
String result = num1.substring(0, pointer);
String remainder = "";
for(int i = 0; i < num2.length(); i++)
{
if(result.charAt(i) == num2.charAt(i))
remainder += "0";
else
remainder += "1"; }
while(pointer < num1.length())
{
if(remainder.charAt(0) == '0')
{
remainder = remainder.substring(1, remainder.length());
remainder = remainder + String.valueOf(num1.charAt(pointer));
pointer++;
}
result = remainder;
remainder = "";
for(int i = 0; i < num2.length(); i++)
{
if(result.charAt(i) == num2.charAt(i))
remainder += "0";
else
remainder += "1";
}}
return remainder.substring(1,remainder.length());
}}

Result:
Thus the error detection and error correction is implemented successfully
Ex No:11 Simulation of congestion control algorithm

Aim:
Write a program for congestion control using leaky bucket algorithm

Theory:
The main concept of the leaky bucket algorithm is that the output data flow remains constant despite the variant
input traffic, such as the water flow in a bucket with a small hole at the bottom. In case the bucket contains
water (or packets) then the output flow follows a constant rate, while if the bucket is full any additional load will
be lost because of spillover. In a similar way if the bucket is empty the output will be zero. From network
perspective, leaky bucket consists of a finite queue (bucket) where all the incoming packets are stored in case
there is space in the queue, otherwise the packets are discarded. In order to regulate the output flow, leaky
bucket transmits one packet from the queue in a fixed time (e.g. at every clock tick). In the following figure we
can notice the main rationale of leaky bucket algorithm, for both the two approaches (e.g. leaky bucket with
water ((a) and with packets (b)) .

While leaky bucket eliminates bursty traffic by regulating the incoming data flow its main drawback is that it
drops packets if the bucket is full. Also, it doesn‘t take into account the idle process of the sender which means
that if the host doesn‘t transmit data for some time the bucket becomes empty without permitting the
transmission of any packet.

Program:
import java.io.*;
import java.util.*;
class Queue
{
int q[],f=0,r=0,size;
void insert(int n)
{ Scanner in = new Scanner(System.in);
q=new int[10];
for (int i=0;i<n;i++)
{System.out.print("\nEnter " + i + " element: ");
int ele=in.nextInt();
if(r+1>10)
{
System.out.println("\nQueue is full \nLost Packet: "+ele);
break;
}
else
{
r++;
q[i]=ele;
}}}
void delete()
{
Scanner in = new Scanner(System.in);
Thread t=new Thread();
if(r==0) System.out.print("\nQueue empty ");
else
{
for(int i=f;i<r;i++)
{
try
{
t.sleep(1000);
}
catch(Exception e){}
System.out.print("\nLeaked Packet: "+q[i]);
f++;
}
}
System.out.println();
}
}
class Leaky extends Thread
{
public static void main(String ar[]) throws Exception
{
Queue q=new Queue();
Scanner src=new Scanner(System.in);
System.out.println("\nEnter the packets to be sent:");
int size=src.nextInt();
q. insert(size); q.delete(); } }

Output:
E:\nwlab>java Leaky
Enter the packets to be sent:
12
Enter 0 element: 23
Enter 1 element: 34
Enter 2 element: 34
Enter 3 element: 334
Enter 4 element: 334
Enter 5 element: 34
Enter 6 element: 34
Enter 7 element: 34
Enter 8 element: 34
Enter 9 element: 34
Enter 10 element: 4

Queue is full
Lost Packet: 4
Leaked Packet: 23
Leaked Packet: 34
Leaked Packet: 34
Leaked Packet: 334
Leaked Packet: 334
Leaked Packet: 34
Leaked Packet: 34
Leaked Packet: 34
Leaked Packet: 34
Leaked Packet: 34
E:\nwlab>

Result:
Thus the program for congestion control using leaky bucket algorithm is implemented and executed
successfully.