CS3591 COMPUTER NETWORKS LABORATORY

LIST OF EXPERIMENTS
1. Learn to use commands like tcpdump, netstat, ifconfig, nslookup and traceroute.
Capture ping and traceroute PDUs using a network protocol analyzer and examine.
2. Write a HTTP web client program to download a web page using TCP sockets.
3. Applications using TCP sockets like:
a) Echo client and echo server
b) Chat
4. Simulation of DNS using UDP sockets.
5. Use a tool like wireshark to capture packets and examine the packets.
6. Write a code simulating ARP /RARP protocols.
7. Study of Network simulator (NS) and Simulation of Congestion Control
Algorithms using NS.
8. Study of TCP/UDP performance using Simulation tool.
9.Simulation of Distance Vector/ Link State Routing algorithm.
10. Simulation of error correction code (like CRC).
EXP NO.05 Use a tool like Wireshark to capture packets and examine the

packets

AIM:

In this practical exercise, you are going to install Wireshark on a Windows 10

computer, and then capture a packet.

Installing Wireshark
Go to https://www.wireshark.org/download.html to visit the Wireshark download
page.
You must ensure that you use the full URL.
The output will look similar to the following:

You want to download the Windows Installer (64 bit).

Click on the link for your version of software, and you will see a pop-up box at the
foot of your screen.
Choose run, and when the UAC prompt appears, choose Yes.
This will bring up the installation wizard.
Keep pressing ‘Next’ and accept the defaults.
The installation will commence, and the pop-up box below will appear.
Accept the license agreement and press I Agree.
Accept the default settings.
Accept the default settings by pressing Next.
The following wizard will appear (see below).
Press Finish.

The Wireshark installation will still be running in the background.

It should take roughly another 2-3 minutes.
The wizard will appear to say the installation is complete.
Select Next, then Finish.
You will now see a Wireshark shortcut on the desktop, the same as below:

Double-click it and choose your network interface.

When your Wireshark console appears, it should look similar to that shown below.
If you need to change the interface, go to Capture and select Options.
The view above shows The Main Window, which is broken into different sections:
The Menu: This is broken into the following 11 headings:
File, Edit, View, Go, Capture, Analyze, Statistics, Telephony, Wireless, Tools, Help.
The Filter Toolbar: This has a filter pane when you type in the protocol that you want
to view.
The Packet List: This shows all packets that are captured and is shown in blue in the
preceding image.
The Packet Details Pane: This is the gray area that shows the protocol fields of the
packet.
The Packet Bytes Pane: This shows a canonical hex dump of the packet data.

Capturing Packets
Go to the Capture drop-down menu option.
Options lets you change the network interface.
Press the shark symbol with the word Start.
Once you are finished capturing the traffic, press the red square with the
word Stop on it.
These menus are context-sensitive; for example, the Stop button does not become
live until after the Start button appears.
Tip
Always have your web browser ready before you press ‘Start’.
Once you start up Wireshark, you will capture a vast amount of traffic.
After capturing it, you can filter the different types of traffic.

Preparation Before Capture

Go to Google and search for ‘Josh Dobbs Mike Glennon’.
The top of the search list should be similar to that shown below.
If that article is not available, go to the Amazon website instead and search for the
Ian Neil Security+.
The following instructions will be the same.

Starting the Capture

Start Wireshark, go to Capture, then press Start.
Go to your Google and press the hyperlink for the preceding article.
You will then see a massive number of packets being captured.

Stop the Capture

Go to Wireshark, Capture menu, and Press Stop.
You should have captured quite a few packets.
On this occasion, you will have captured over 20,000 packets in about 3 minutes.

Saving the Capture File

On the Wireshark console, in the top left-hand corner, choose File.
Then select ‘Save as‘ and save it as a pcap file (a packet capture file).
Filtering the Capture File (cap)
In the packet that you captured, you have inserted the filter http.
You can now see only TCP and HTTP traffic.
The packet 16340 relates to your arrival at the articles on the nfl.com website.
The IP Address is 172.20.10.1, and the destination is 151.101.62.2.
The request to go to a website uses the HTTP verb GET.
Can you now search your trace for the packet when you arrived at this article?
Open the frame in the packet details pane.
You will see that it is using IPV4, and the traffic is TCP.
Expand the HTTP packet, and the referrer will show the page that you visited.
EX.NO 6(A)- 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 6(B) 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.

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();
atagramPacket 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: 7(A) 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
Loops
while{$i < $n} { for {set i 0} {$i < $n} {incr i} {
... ...

} }

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(B) 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.
EX.NO 8. Study of TCP/UDP Performance using simulation tool

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.
o URG - It indicates that Urgent Pointer field has significant
data and should be processed.
o ACK - It indicates that Acknowledgement field has
significance. If ACK is cleared to 0, it indicates that packet
does not contain any acknowledgement.
o 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.
o SYN - This flag is used to set up a connection between hosts.
o 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

• UDPis 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 9. Simulation of Distance Vector/Link State Routing.
.
a) Distance Vector routing protocol 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 9. Simulation of Distance Vector/Link State Routing.

b) 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: 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
{

BufferedReaderbr=newBufferedReader(newInputStreamReader(
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