ST.

MARY’S GROUP OF INSTITUTIONS GUNTUR

(Approved by AICTE &Govt .of AP, Affiliated to JNTU-KAKINADA, Accredited by 'NAAC')
Chebrolu (V&M), Guntur (Dist), Andhra Pradesh, INDIA-522212

SCHOOL OF ENGINEERING

PRACTICAL RECORD

Name of the student: __________________________________________________

Course:______________Branch:____________Reg.No:______________________

Year:_____________ Semester:_______________ Regulation:_________________

Name of Laboratory:___________________________________________________
 ST.MARY’S GROUP OF INSTITUTIONS GUNTUR
(Approved by AICTE &Govt .of AP, Affiliated to JNTU-KAKINADA, Accredited by 'NAAC')
Chebrolu (V&M), Guntur (Dist), Andhra Pradesh, INDIA-522212

SCHOOL OF ENGINEERING

Certificate
This is to certify that Mr. / Ms.

bearing roll no of _______B. Tech semester

branch has satisfactorily

completed laboratory during the

academic year .

Place: Signature of Faculty

Date:

External Practical Examination held on:______________________

Signature of HOD

Signature of Internal Examiner Signature of External Examiner

 ST.MARY’S GROUP OF INSTITUTIONS GUNTUR
(Approved by AICTE &Govt .of AP, Affiliated to JNTU-KAKINADA, Accredited by 'NAAC')
Chebrolu (V&M), Guntur (Dist), Andhra Pradesh, INDIA-522212

Index
Signature of
S.No Name of the Program Page No. Date
the Faculty
 COMPUTER NETWORKS LAB MANUAL
List of Experiments:

1. Study of Network devices in detail and connect the computers in Local Area Network.
2. Write a Program to implement the data link layer farming methods such as
i) Character stuffing ii) bit stuffing.
3. Write a Program to implement data link layer farming method checksum.
4. Write a program for Hamming Code generation for error detection and correction.
5. Write a Program to implement on a data set of characters the three CRC polynomials – CRC 12, CRC 16 and CRC
CCIP.
6. Write a Program to implement Sliding window protocol for Goback N.
7. Write a Program to implement Sliding window protocol for Selective repeat.
8. Write a Program to implement Stop and Wait Protocol.

9. Write a program for congestion control using leaky bucket algorithm

10. Write a Program to implement Dijkstra‘s algorithm to compute the Shortest path through a graph.
11. Write a Program to implement Distance vector routing algorithm by obtaining routing table at each node (Take an
example subnet graph with weights indicating delay between nodes).
12. Write a Program to implement Broadcast tree by taking subnet of hosts.
13. Wireshark
i. Packet Capture Using Wire shark
ii. Starting Wire shark
iii. Viewing Captured Traffic
iv. Analysis and Statistics & Filters.
14. How to run Nmap scan
15. Operating System Detection using Nmap

16. Do the following using NS2 Simulator

i. NS2 Simulator-Introduction
ii. Simulate to Find the Number of Packets Dropped
iii. Simulate to Find the Number of Packets Dropped by TCP/UDP
iv. Simulate to Find the Number of Packets Dropped due to Congestion
v. Simulate to Compare Data Rate& Throughput.
 EXPERIMENT-1

Aim: Study of different types of Network cables and Practically implement the cross -wiredcable and straight
through cable using clamping tool.

Apparatus (Components): RJ-45 connector, Climping Tool, Twisted pair Cable

Procedure: To do these practical following steps should be done:

1. Start by stripping off about 2 inches of the plastic jacket off the end of the cable. Be very careful at this point,
as to not nick or cut into the wires, which are inside. Doing so could alter the characteristics of your cable, or even
worse render is useless. Check the wires, one more time for nicks or cuts. If there are any, just whack the whole
end off, and start over.

2. Spread the wires apart, but be sure to hold onto the base of the jacket with your other hand. You do not want the
wires to become untwisted down inside the jacket. Category 5 cable must only have 1/2 of an inch of 'untwisted'
wire at the end; otherwise it will be 'out of spec'.At this point, you obviously have ALOT more than 1/2 of an
inch of un-twisted wire.

3. You have 2 end jacks, which must be installed on your cable. If you are using a pre-made cable, with one of
the ends whacked off, you only have one end to install - the crossed over end. Below are two diagrams, which
show how you need to arrange the cables for each type of cable end. Decide at this point which end you are
making and examine the associated picture below.
Diagram shows you how to prepare Cross wired connection
Diagram shows you how to prepare straight through wired connection

Aim: Study of following Network Devices in

Detail
• Repeater
• Hub
 • Switch
• Bridge
• Router
• Gate Way

Apparatus (Software): No software or hardware needed.

Procedure: Following should be done to understand this practical.

1. Repeater:Functioning at Physical Layer.A repeater is an electronic device that receives a signal and
retransmits it at a higher level and/or higher power, or onto the other side of an obstruction, so that the signal
can cover longer distances. Repeater have two ports ,so cannotbe use to connect for more than two devices

2. Hub: An Ethernet hub, active hub, network hub, repeater hub, hub or concentrator
is a device for connecting multiple twisted pair or fiber optic Ethernet devices together and making them act as
a single network segment. Hubs work at the physical layer (layer 1) of the OSI model. The device is a form of
multiport repeater. Repeater hubs also participate in collision detection, forwarding a jam signal to all ports if it
detects a collision.

3. Switch:A network switch or switching hub is a computer networking device that connects network
segments.The term commonly refers to a network bridge that processes androutes data at the data link layer (layer
2) of the OSI model. Switches that additionally process data at the network layer (layer 3 and above) are often
referred to as Layer 3 switches or multilayer switches.

4. Bridge: A network bridge connects multiple network segments at the data link layer (Layer 2) of the OSI
model. In Ethernet networks, the term bridge formally means a device that behaves according to the IEEE
802.1D standard. A bridge and switch are very much alike; a switch being a bridge with numerous ports. Switch
or Layer 2 switch is often used interchangeably with bridge.Bridges can analyze incoming data packets to
determine if the bridge is able to send the given packet to another segment of the network.

5. Router: A router is an electronic device that interconnects two or more computer networks, and selectively
interchanges packets of data between them. Each data packet contains address information that a router can use
to determine if the source and destination are on the same network, or if the data packet must be transferred from
one network to another. Where multiple routers are used in a large collection of interconnected networks, the
routers exchange information about target system addresses, so that each router can build up a table showing the
preferred paths between any two systems on the interconnected networks.

6. Gate Way: In a communications network, a network node equipped for interfacing with another network that uses different
protocols.
• A gateway may contain devices such as protocol translators, impedance matching devices, rate
converters, fault isolators, or signal translators as necessary to provide system interoperability. It also
requires the establishment of mutually acceptable administrative procedures between both networks.
• A protocol translation/mapping gateway interconnects networks with different network protocol
technologies by performing the required protocol conversions.

EXPERIMENT 2
Write a Program to implement the data link layer farming methods such as
i) Character stuffing ii) bit stuffing.

Program Code: //Program for Character Stuffing

#include<stdio.h>
#include<string.h>
#include<process.h>
void main()
{
int i=0,j=0,n,pos;
char a[20],b[50],ch;
printf("Enter string\n");
scanf("%s",&a);
n=strlen(a);
printf("Enter position\n");
scanf("%d",&pos);
if(pos>n)
{
printf("invalid position, Enter again :");
scanf("%d",&pos);}
printf("Enter the character\n");
ch=getche();
b[0]='d';
b[1]='l';
b[2]='e';
b[3]='s';
b[4]='t';
b[5]='x';
j=6;
while(i<n)
{
if(i==pos-1)
{
b[j]='d';

b[j+1]='l';
b[j+2]='e';
b[j+3]=ch;
b[j+4]='d';
b[j+5]='l';
b[j+6]='e';
j=j+7;
}
if(a[i]=='d' && a[i+1]=='l' && a[i+2]=='e')
{
b[j]='d';
b[j+1]='l';
b[j+2]='e';
j=j+3;
}
b[j]=a[i];
i++;
j++;
}
b[j]='d';
b[j+1]='l';
b[j+2]='e';
b[j+3]='e';
b[j+4]='t';
b[j+5]='x';
b[j+6]='\0';
printf("\nframe after stuffing:\n");
printf("%s",b);
}

Program Output:
Enter string
MLRITM
Enter position
2
Enter the character
frame after stuffing:
dlestxMdldleLRITMdleetx
------------------
Program Code: // BIT Stuffing program

#include<stdio.h>
#include<string.h>
void main()
{
int a[20],b[30],i,j,k,count,n;
printf("Enter frame length:");
scanf("%d",&n);
printf("Enter input frame (0's & 1's only):");
for(i=0;i<n;i++)
scanf("%d",&a[i]);

i=0; count=1; j=0;

while(i<n)
{
if(a[i]==1)
{
b[j]=a[i];
for(k=i+1;a[k]==1 && k<n && count<5;k++)
{
j++;
b[j]=a[k];
count++;
if(count==5)
{
j++;
b[j]=0;
}
i=k;
}}
else
{
b[j]=a[i];
}
i++;
j++;
}
printf("After stuffing the frame is:");
for(i=0;i<j;i++)
printf("%d",b[i]);
}

Program Output:
Enter frame length:5
Enter input frame (0's & 1's only):
1
1
1
1
1
After stuffing the frame is:111110
------------------

EXPERIMENT 3
Write a Program to implement data link layer farming method checksum.
The Checksum is an error detection method that detected errors in data/message while it is transmitted from sender to receiver.
This method is used by the higher layer protocols and makes use of the Checksum Generator on the Sende r side and Checksum
Checker on the Receiver side.
Examples:
Input: sent_message = “10101111”, rec_message = “10101101”, block_size = 8
Output: Error

Explaination: Since the 7th bit in the sent_message and the rec_message is different, the final checksum value is not equal to
zero denoting that some error has occurred during transmission.
Input: sent_message = “10000101011000111001010011101101”, rec_message = “10000101011000111001010011101101”,
block_size = 8
Output: No Error

// C++ implementation of the above approach

#include <bits/stdc++.h>

using namespace std;

// Function to find the One's complement

// of the given binary string

string Ones_complement(string data)

{

for (int i = 0; i < data.length(); i++) {

if (data[i] == '0')

data[i] = '1';

else

data[i] = '0';

return data;

// Function to return the checksum value of

// the give string when divided in K size blocks

string checkSum(string data, int block_size)

// Check data size is divisible by block_size

// Otherwise add '0' front of the data

int n = data.length();

if (n % block_size != 0) {

int pad_size = block_size - (n % block_size);

for (int i = 0; i < pad_size; i++) {

data = '0' + data;

// Binary addition of all blocks with carry

string result = "";

// First block of data stored in result variable

for (int i = 0; i < block_size; i++) {

result += data[i];

// Loop to calculate the block

// wise addition of data

for (int i = block_size; i < n; i += block_size) {

// Stores the data of the next bloack

string next_block = "";

for (int j = i; j < i + block_size; j++) {

next_block += data[j];

// Stores the binary addition of two blocks

string additions = "";

int sum = 0, carry = 0;

// Loop to calculate the binary addition of

// the current two blocls of k size

for (int k = block_size - 1; k >= 0; k--) {

sum += (next_block[k] - '0')

 + (result[k] - '0');

carry = sum / 2;

if (sum == 0) {

additions = '0' + additions;

sum = carry;

else if (sum == 1) {

additions = '1' + additions;

sum = carry;

else if (sum == 2) {

additions = '0' + additions;

sum = carry;

else {

additions = '1' + additions;

sum = carry;

// After binary add of two blocks with carry,

// if carry is 1 then apply binary addition

string final = "";

if (carry == 1) {

for (int l = additions.length() - 1; l >= 0;

 l--) {

if (carry == 0) {

final = additions[l] + final;

else if (((additions[l] - '0') + carry) % 2

== 0) {

final = "0" + final;

carry = 1;

else {

final = "1" + final;

carry = 0;

result = final;

else {

result = additions;

// Return One's complements of result value

// which represents the required checksum value

return Ones_complement(result);

}
// Function to check if the received message

// is same as the senders message

bool checker(string sent_message,

string rec_message,

int block_size)

// Checksum Value of the senders message

string sender_checksum

= checkSum(sent_message, block_size);

// Checksum value for the receivers message

string receiver_checksum = checkSum(

rec_message + sender_checksum, block_size);

// If receivers checksum value is 0

if (count(receiver_checksum.begin(),

receiver_checksum.end(), '0')

== block_size) {

return true;

else {

return false;

}
 // Driver Code

int main()

string sent_message

= "10000101011000111001010011101101";

string recv_message

= "10000101011000111001010011101101";

int block_size = 8;

if (checker(sent_message,

recv_message,

block_size)) {

cout << "No Error";

else {

cout << "Error";

return 0;

Output
No Error
EXPERIMENT 4
Write a program for Hamming Code generation for error detection and correction

// C program for the above approach

#include <math.h>

#include <stdio.h>

// Store input bits

int input[32];

// Store hamming code

int code[32];

int ham_calc(int, int);

void solve(int input[], int);

// Function to calculate bit for

// ith position

int ham_calc(int position, int c_l)

int count = 0, i, j;

i = position - 1;

// Traverse to store Hamming Code

while (i < c_l) {

for (j = i; j < i + position; j++) {

// If current boit is 1

if (code[j] == 1)
 count++;

// Update i

i = i + 2 * position;

if (count % 2 == 0)

return 0;

else

return 1;

// Function to calculate hamming code

void solve(int input[], int n)

int i, p_n = 0, c_l, j, k;

i = 0;

// Find msg bits having set bit

// at x'th position of number

while (n > (int)pow(2, i) - (i + 1)) {

p_n++;

i++;

}
c_l = p_n + n;

j = k = 0;

// Traverse the msgBits

for (i = 0; i < c_l; i++) {

// Update the code

if (i == ((int)pow(2, k) - 1)) {

code[i] = 0;

k++;

// Update the code[i] to the

// input character at index j

else {

code[i] = input[j];

j++;

// Traverse and update the

// hamming code

for (i = 0; i < p_n; i++) {

// Find current position

 int position = (int)pow(2, i);

// Find value at current position

int value = ham_calc(position, c_l);

// Update the code

code[position - 1] = value;

// Print the Hamming Code

printf("\nThe generated Code Word is: ");

for (i = 0; i < c_l; i++) {

printf("%d", code[i]);

// Driver Code

void main()

// Given input message Bit

input[0] = 0;

input[1] = 1;

input[2] = 1;

input[3] = 1;

int N = 4;
 // Function Call

solve(input, N);

Output:
The generated Code Word is: 0001111
EXPERIMENT 5
Write a Program to implement on a data set of characters the three CRC polynomials – CRC 12, CRC 16 and
CRC CCIP
Program Code: // Program for Cyclic Redundency Check
#include<stdio.h>
int gen[4],genl,frl,rem[4];
void main()
{
int i,j,fr[8],dupfr[11],recfr[11],tlen,flag;
frl=8; genl=4;
printf("Enter frame:");
for(i=0;i<frl;i++)
{
scanf("%d",&fr[i]);
dupfr[i]=fr[i];
}

printf("Enter generator:");
for(i=0;i<genl;i++)
scanf("%d",&gen[i]);
tlen=frl+genl-1;
for(i=frl;i<tlen;i++)
{
dupfr[i]=0;
}
remainder(dupfr);
for(i=0;i<frl;i++)
{
recfr[i]=fr[i];
}
for(i=frl,j=1;j<genl;i++,j++)
{
recfr[i]=rem[j];
}
remainder(recfr);
flag=0;
for(i=0;i<4;i++)
{
if(rem[i]!=0)
flag++;
}
if(flag==0)
{
printf("frame received correctly");
}
else
{
printf("the received frame is wrong");
}
}
remainder(int fr[])
{
int k,k1,i,j;
for(k=0;k<frl;k++)
{
if(fr[k]==1)
{
k1=k;
for(i=0,j=k;i<genl;i++,j++)
{
rem[i]=fr[j]^gen[i];
}
for(i=0;i<genl;i++)
{
fr[k1]=rem[i];
k1++;
}
}
}
}

Program Output:
Enter frame: MLRITM
Enter generator: frame received correctly
------------------

EXPERIMENT 6
Write a Program to implement Sliding window protocol for Goback N
CODE
#include<bits/stdc++.h>

#include<ctime>

#define ll long long int

using namespace std;

void transmission(ll & I, ll & N, ll & tf, ll & tt) {

while (I <= tf) {
int z = 0;
for (int k = I; k < I + N && k <= tf; k++) {
cout << “Sending Frame “ << k << “...” << endl;
tt++;
}
for (int k = I; k < I + N && k <= tf; k++) {
int f = rand() % 2;
if (!f) {
cout << “Acknowledgment for Frame “ << k << “...” << endl;
z++;
} else {
cout << “Timeout!! Frame Number : “ << k << “ Not Received” << endl;
cout << “Retransmitting Window...” << endl;
break;
}
}
 cout << “\n”;
I = I + z;
}
}

int main() {
ll tf, N, tt = 0;
srand(time(NULL));
cout << “Enter the Total number of frames : “;
cin >> tf;
cout << “Enter the Window Size : “;
cin >> N;
ll I = 1;
transmission(I, N, tf, tt);
cout << “Total number of frames which were sent and resent are : “ << tt <<
endl;
return 0;
}

OUTPUT:

Enter the Total number of frames : 12

Enter the Window Size : 4
Sending Frame 1…
Sending Frame 2…
Sending Frame 3…
Sending Frame 4…
Timeout!! Frame Number : 1 Not Received
Retransmitting Window…

Sending Frame 1…
Sending Frame 2…
Sending Frame 3…
Sending Frame 4…
Acknowledgment for Frame 1…
Timeout!! Frame Number : 2 Not Received
Retransmitting Window…

Sending Frame 2…
Sending Frame 3…
Sending Frame 4…
Sending Frame 5…
Timeout!! Frame Number : 2 Not Received
Retransmitting Window…

Sending Frame 2…
Sending Frame 3…
Sending Frame 4…
Sending Frame 5…
Acknowledgment for Frame 2…
Acknowledgment for Frame 3…
Acknowledgment for Frame 4…
Timeout!! Frame Number : 5 Not Received
Retransmitting Window…

Sending Frame 5…
Sending Frame 6…
Sending Frame 7…
Sending Frame 8…
Timeout!! Frame Number : 5 Not Received
Retransmitting Window…

Sending Frame 5…
Sending Frame 6…
Sending Frame 7…
Sending Frame 8…
Acknowledgment for Frame 5…
Timeout!! Frame Number : 6 Not Received
Retransmitting Window…

Sending Frame 6…

Sending Frame 7…
Sending Frame 8…
Sending Frame 9…
Acknowledgment for Frame 6…
Timeout!! Frame Number : 7 Not Received
Retransmitting Window…

Sending Frame 7…
Sending Frame 8…
Sending Frame 9…
Sending Frame 10…
Acknowledgment for Frame 7…
Acknowledgment for Frame 8…
Acknowledgment for Frame 9…
Acknowledgment for Frame 10…

Sending Frame 11…

Sending Frame 12…
Timeout!! Frame Number : 11 Not Received
Retransmitting Window…

Sending Frame 11…

Sending Frame 12…
 Timeout!! Frame Number : 11 Not Received
Retransmitting Window…

Sending Frame 11…

Sending Frame 12…

Acknowledgment for Frame 11…

Acknowledgment for Frame 12…

Total number of frames transmitted(sent + resent) are : 38

EXPERIMENT 7
Write a Program to implement Sliding window protocol for Selective repeat
#include<stdio.h>

int main()
{
int w,i,f,frames[50];

printf("Enter window size: ");

scanf("%d",&w);

printf("\nEnter number of frames to transmit: ");

scanf("%d",&f);

printf("\nEnter %d frames: ",f);

for(i=1;i<=f;i++)
scanf("%d",&frames[i]);

printf("\nWith sliding window protocol the frames will be sent in the following manner (assuming no corruption of
frames)\n\n");
printf("After sending %d frames at each stage sender waits for acknowledgement sent by the receiver\n\n",w);

for(i=1;i<=f;i++)
{
if(i%w==0)
{
printf("%d\n",frames[i]);
printf("Acknowledgement of above frames sent is received by sender\n\n");
}
else
printf("%d ",frames[i]);
}

if(f%w!=0)
printf("\nAcknowledgement of above frames sent is received by sender\n");

return 0;
}
Output

Enter window size: 3

Enter number of frames to transmit: 5

Enter 5 frames: 12 5 89 4 6

With sliding window protocol the frames will be sent in the following manner (assuming no corruption of frames)

After sending 3 frames at each stage sender waits for acknowledgement sent by the receiver

12 5 89
Acknowledgement of above frames sent is received by sender

46
Acknowledgement of above frames sent is received by sender

EXPERIMENT 8
Write a Program to implement Stop and Wait Protocol
#include<iostream>
#include <time.h>
#include <cstdlib>
#include<ctime>
#include <unistd.h>
using namespace std;
class timer {
private:
unsigned long begTime;
public:
void start() {
begTime = clock();
}
unsigned long elapsedTime() {
return ((unsigned long) clock() - begTime) / CLOCKS_PER_SEC;
}
bool isTimeout(unsigned long seconds) {
return seconds >= elapsedTime();
}
};
int main()
{
int frames[] = {1,2,3,4,5,6,7,8,9,10};
unsigned long seconds = 5;
srand(time(NULL));
timer t;
cout<<"Sender has to send frames : ";
for(int i=0;i<10;i++)
cout<<frames[i]<<" ";
cout<<endl;
int count = 0;
bool delay = false;
cout<<endl<<"Sender\t\t\t\t\tReceiver"<<endl;
do
{
bool timeout = false;
cout<<"Sending Frame : "<<frames[count];
cout.flush();
cout<<"\t\t";
t.start();
if(rand()%2)
{
int to = 24600 + rand()%(64000 - 24600) + 1;
for(int i=0;i<64000;i++)
for(int j=0;j<to;j++) {}
}
if(t.elapsedTime() <= seconds)
{
cout<<"Received Frame : "<<frames[count]<<" ";
if(delay)
{
cout<<"Duplicate";
delay = false;
}
cout<<endl;
count++;
}
else
{
cout<<"---"<<endl;
cout<<"Timeout"<<endl;
timeout = true;
}
t.start();

if(rand()%2 || !timeout)
{
int to = 24600 + rand()%(64000 - 24600) + 1;
for(int i=0;i<64000;i++)
for(int j=0;j<to;j++) {}
if(t.elapsedTime() > seconds )
{
cout<<"Delayed Ack"<<endl;
count--;
delay = true;
}
else if(!timeout)
cout<<"Acknowledgement : "<<frames[count]-1<<endl;
}
}while(count!=10);
return 0;
}

OUTPUT
Sender has to send frames : 1 2 3 4 5 6 7 8 9 10

Sender Receiver
Sending Frame : 1 Received Frame : 1
Acknowledgement : 1
Sending Frame : 2 ---
Timeout
Sending Frame : 2 Received Frame : 2
Acknowledgement : 2
Sending Frame : 3 Received Frame : 3
Acknowledgement : 3
Sending Frame : 4 Received Frame : 4
Acknowledgement : 4
Sending Frame : 5 Received Frame : 5
Acknowledgement : 5
Sending Frame : 6 Received Frame : 6
Acknowledgement : 6
Sending Frame : 7 Received Frame : 7
Delayed Ack
Sending Frame : 7 Received Frame : 7 Duplicate
Delayed Ack
Sending Frame : 7 ---
Timeout
Sending Frame : 7 Received Frame : 7 Duplicate
Acknowledgement : 7
Sending Frame : 8 ---
Timeout
Delayed Ack
Sending Frame : 7 Received Frame : 7
Acknowledgement : 7
Sending Frame : 8 Received Frame : 8
Acknowledgement : 8
Sending Frame : 9 Received Frame : 9
Delayed Ack
Sending Frame : 9 ---
Timeout
Sending Frame : 9 Received Frame : 9 Duplicate
Delayed Ack
Sending Frame : 9 Received Frame : 9 Duplicate
Acknowledgement : 9
Sending Frame : 10 ---
Timeout
Sending Frame : 10 Received Frame : 10
Acknowledgement : 10

EXPERIMENT 9
Write a program for congestion control using leaky bucket algorithm

// cpp program to implement leakybucket

#include <bits/stdc++.h>

using namespace std;

int main()

int no_of_queries, storage, output_pkt_size;

int input_pkt_size, bucket_size, size_left;

// initial packets in the bucket

storage = 0;

// total no. of times bucket content is checked

no_of_queries = 4;

// total no. of packets that can

// be accommodated in the bucket

bucket_size = 10;

// no. of packets that enters the bucket at a time

input_pkt_size = 4;

// no. of packets that exits the bucket at a time

output_pkt_size = 1;

for (int i = 0; i < no_of_queries; i++) // space left

size_left = bucket_size - storage;

if (input_pkt_size <= size_left) {

// update storage

storage += input_pkt_size;

else {

printf("Packet loss = %d\n", input_pkt_size);

printf("Buffer size= %d out of bucket size= %d\n",

storage, bucket_size);

storage -= output_pkt_size;

return 0;
 }

// This code is contributed by bunny09262002

// Improved by: rishitchaudhary

Output

Buffer size= 4 out of bucket size= 10

Buffer size= 7 out of bucket size= 10
Buffer size= 10 out of bucket size= 10
Packet loss = 4
Buffer size= 9 out of bucket size= 10

EXPERIMENT 10
Write a Program to implement Dijkstra‘s algorithm to compute the Shortest path through a graph
#include <limits.h>
#include <stdio.h>
#define V 9
int minDistance(int dist[], bool sptSet[]) {
int min = INT_MAX, min_index;
for (int v = 0; v < V; v++)
if (sptSet[v] == false && dist[v] <= min)
min = dist[v], min_index = v;
return min_index;
}
int printSolution(int dist[], int n) {
printf("Vertex Distance from Source\n");
for (int i = 0; i < V; i++)
printf("%d \t %d\n", i, dist[i]);
}
void dijkstra(int graph[V][V], int src) {
int dist[V];
bool sptSet[V];
for (int i = 0; i < V; i++)
 dist[i] = INT_MAX, sptSet[i] = false;
dist[src] = 0;
for (int count = 0; count < V - 1; count++) {
int u = minDistance(dist, sptSet);
sptSet[u] = true;
for (int v = 0; v < V; v++)
if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX && dist[u] + graph[u][v] < dist[v]) dist[v] = dist[u] +
graph[u][v];
}
printSolution(dist, V);
}
int main() {
int graph[V][V] = { { 0, 6, 0, 0, 0, 0, 0, 8, 0 },
{ 6, 0, 8, 0, 0, 0, 0, 13, 0 },
{ 0, 8, 0, 7, 0, 6, 0, 0, 2 },
{ 0, 0, 7, 0, 9, 14, 0, 0, 0 },
{ 0, 0, 0, 9, 0, 10, 0, 0, 0 },
{ 0, 0, 6, 14, 10, 0, 2, 0, 0 },
{ 0, 0, 0, 0, 0, 2, 0, 1, 6 },
{ 8, 13, 0, 0, 0, 0, 1, 0, 7 },
{ 0, 0, 2, 0, 0, 0, 6, 7, 0 }
};
dijkstra(graph, 0);
return 0;
}
Output
Vertex Distance from Source
00
16
2 14
3 21
4 21
5 11
69
78
8 15
EXPERIMENT 11
Write a Program to implement Distance vector routing algorithm by obtaining routing table at each node (Take
an example subnet graph with weights indicating delay between nodes).
#include<stdio.h>
struct node
{
unsigned dist[20];
unsigned from[20];
}rt[10];
int main()
{
int costmat[20][20];
int nodes,i,j,k,count=0;
printf("\nEnter the number of nodes : ");
scanf("%d",&nodes);//Enter the nodes
printf("\nEnter the cost matrix :\n");
for(i=0;i<nodes;i++)
{
for(j=0;j<nodes;j++)
{
scanf("%d",&costmat[i][j]);
costmat[i][i]=0;
rt[i].dist[j]=costmat[i][j];//initialise the distance equal to cost matrix
rt[i].from[j]=j;
}
}
do
{
count=0;
for(i=0;i<nodes;i++)//We choose arbitary vertex k and we calculate the direct distance from the node i to k
using the cost matrix
//and add the distance from k to node j
for(j=0;j<nodes;j++)
for(k=0;k<nodes;k++)
if(rt[i].dist[j]>costmat[i][k]+rt[k].dist[j])
{//We calculate the minimum distance
rt[i].dist[j]=rt[i].dist[k]+rt[k].dist[j];
rt[i].from[j]=k;
count++;
}
}while(count!=0);
for(i=0;i<nodes;i++)
{
printf("\n\n For router %d\n",i+1);
for(j=0;j<nodes;j++)
{
printf("\t\nnode %d via %d Distance %d ",j+1,rt[i].from[j]+1,rt[i].dist[j]);
}
}
printf("\n\n");
getch();
}
/*OUTPUT
A sample run of the program works as:-
Enter the number of nodes :
3
Enter the cost matrix :
027
201
710
For router 1
node 1 via 1 Distance 0
node 2 via 2 Distance 2
node 3 via 3 Distance 3
For router 2
node 1 via 1 Distance 2
node 2 via 2 Distance 0
node 3 via 3 Distance 1
For router 3
node 1 via 1 Distance 3
node 2 via 2 Distance 1
node 3 via 3 Distance 0

EXPERIMENT 12
Write a Program to implement Broadcast tree by taking subnet of hosts
#include
int a[10][10],n;
main()
{
int i,j,root;
clrscr();
printf(“Enter no.of nodes:”);
scanf(“%d”,&n);
printf(“Enter adjacent matrix\n”);
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
printf(“Enter connecting of %d–>%d::”,i,j);
scanf(“%d”,&a[i][j]);
}
printf(“Enter root node:”);
scanf(“%d”,&root);
adj(root);
}
adj(int k)
{
int i,j;
printf(“Adjacent node of root node::\n”);
printf(“%d\n\n”,k);
for(j=1;j<=n;j++)
{
if(a[k][j]==1 || a[j][k]==1)
printf(“%d\t”,j);
}
printf(“\n”);
for(i=1;i<=n;i++)
{
if((a[k][j]==0) && (a[i][k]==0) && (i!=k))
printf(“%d”,i);
}
}
OUTPUT
Enter no.of nodes:5
Enter adjacent matrix
Enter connecting of 1–>1::0
Enter connecting of 1–>2::1
Enter connecting of 1–>3::1
Enter connecting of 1–>4::0
Enter connecting of 1–>5::0
Enter connecting of 2–>1::1
Enter connecting of 2–>2::0
Enter connecting of 2–>3::1
Enter connecting of 2–>4::1
Enter connecting of 2–>5::0
Enter connecting of 3–>1::1
Enter connecting of 3–>2::1
Enter connecting of 3–>3::0
Enter connecting of 3–>4::0
Enter connecting of 3–>5::0
Enter connecting of 4–>1::0

Enter connecting of 4–>2::1

Enter connecting of 4–>3::0
Enter connecting of 4–>4::0
Enter connecting of 4–>5::1
Enter connecting of 5–>1::0
Enter connecting of 5–>2::0
Enter connecting of 5–>3::0
Enter connecting of 5–>4::1
Enter connecting of 5–>5::0
Enter root node:2
Adjacent node of root node::
2
134
5
EXPERIMENT 13
Wireshark
i. Packet Capture Using Wire shark
ii. Starting Wire shark
iii. Viewing Captured Traffic
iv. Analysis and Statistics & Filters.

Packet Sniffing and Wireshark

Introduction
The first part of the lab introduces packet sniffer, Wireshark. Wireshark is a free open- source network protocol analyzer.
It is used for network troubleshooting andcommunication protocol analysis. Wireshark captures network packets in
real time and display them in human-readable format. It provides many advanced features including live capture and
offline analysis, three-pane packet browser, coloring rules for analysis. This document uses Wireshark for the experiments,
and it covers Wireshark installation,packet capturing, and protocol analysis.
Figure 1: Wireshark in Kali Linux
 Background

TCP/IP Network Stack

Figure 2: Encapsulation of Data in the TCP/IP Network Stack

In the CSC 4190 Introduction to Computer Networking, TCP/IP network stack is introduced and studied. This background
section briefly explains the concept of TCP/IP network stack to help you better understand the experiments. TCP/IP is the
most commonly used network model for Internet services. Because its most important protocols, the Transmission Control
Protocol (TCP) and the Internet Protocol (IP) were the first networking protocols defined in this standard, it is named as
TCP/IP. However,it contains multiple layers including application layer, transport layer, network layer, and data link layer.

- Application Layer: The application layer includes the protocols used by most applications for providing
user services. Examples of application layer protocols are Hypertext Transfer Protocol (HTTP), Secure
Shell (SSH), File Transfer Protocol (FTP), and Simple Mail Transfer Protocol (SMTP).
- Transport Layer: The transport layer establishes process-to-process connectivity,and it provides end-to-
end services that are independent of underlying user data. To implement the process-to-process
communication, the protocol introduces a concept of port. The examples of transport layer protocols are
Transport Control Protocol (TCP) and User Datagram Protocol (UDP). The TCP provides flow- control,
connection establishment, and reliable transmission of data, while the UDP is a connectionless
transmission model.
 - Internet Layer: The Internet layer is responsible for sending packets to across networks. It has two
functions: 1) Host identification by using IP addressing system (IPv4 and IPv6); and 2) packets routing
from source to destination. The examples of Internet layer protocols are Internet Protocol (IP), Internet
Control Message Protocol (ICMP), and Address Resolution Protocol (ARP).
- Link Layer: The link layer defines the networking methods within the scope of thelocal network link. It
is used to move the packets between two hosts on the samelink. An common example of link layer
protocols is Ethernet.

Packet Sniffer

Packet sniffer is a basic tool for observing network packet exchanges in a computer. As the name suggests, a packet sniffer
captures (“sniffs”) packets being sent/received from/by your computer; it will also typically store and/or display the
contents of the various protocol fields in these captured packets. A packet sniffer itself is passive. It observes messages
being sent and received by applications and protocols running on your computer, but never sends packets itself.
Figure 3 shows the structure of a packet sniffer. At the right of Figure 3 are the protocols (in this case, Internet protocols)
and applications (such as a web browser orftp client) that normally run on your computer. The packet sniffer, shown
within the dashed rectangle in Figure 3 is an addition to the usual software in your computer, and consists of two parts.
The packet capture library receives a copy of every link-layer frame that is sent from or received by your computer.
Messages exchanged by higher layer protocols such as HTTP, FTP, TCP, UDP, DNS, or IP all are eventually encapsulated
in link-layer frames that are transmitted over physical media such as an Ethernet cable. In Figure 1, the assumed physical
media is an Ethernet, and so all upper-layer protocols are eventually encapsulated within an Ethernet frame. Capturing all
link-layer frames thus gives you access to all messages sent/received from/by all protocols and applications executing in
your computer.
The second component of a packet sniffer is the packet analyzer, which displays the contents of all fields within a protocol
message. In order to do so, the packet analyzer

Figure 3: Packet Sniffer Structure

must “understand” the structure of all messages exchanged by protocols. For example, suppose we are interested in
displaying the various fields in messages exchanged by the HTTP protocol in Figure 3. The packet analyzer understands
the format of Ethernet frames, and so can identify the IP datagram within an Ethernet frame. It also understands the IP
datagram format, so that it can extract the TCP segment within the IP datagram. Finally, it understands the TCP segment
structure, so it can extract the HTTP message contained in the TCP segment. Finally, it understands the HTTP protocol
and so, for example, knows that the first bytes of an HTTP message willcontain the string “GET,” “POST,” or
“HEAD”.
We will be using the Wireshark packet sniffer [http://www.wireshark.org/] for these labs, allowing us to display the
contents of messages being sent/received from/by protocolsat different levels of the protocol stack. (Technically speaking,
Wireshark is a packet analyzer that uses a packet capture library in your computer). Wireshark is a free network protocol
analyzer that runs on Windows, Linux/Unix, and Mac computers.

Getting Wireshark

The Kai Linux has Wireshark installed. You can just launch the Kali Linux VM and openWireshark there. Wireshark
can also be downloaded from here:
https://www.wireshark.org/download.html

Figure 4: Download Page of Wireshark

Starting Wireshark

When you run the Wireshark program, the Wireshark graphic user interface will be shown as Figure 5. Currently, the
program is not capturing the packets.
 Figure 5: Initial Graphic User Interface of Wireshark
Then, you need to choose an interface. If you are running the Wireshark on your laptop,you need to select WiFi interface.
If you are at a desktop, you need to select the Ethernet interface being used. Note that there could be multiple interfaces.
In general, you can select any interface but that does not mean that traffic will flow through that
interface. The network interfaces (i.e., the physical connections) that your computer hasto the network are shown. The
attached Figure 6 was taken from my computer.
After you select the interface, you can click start to capture the packets as shown in
Figure 7.

Figure 6: Capture Interfaces in Wireshark

Figure 7: Capturing Packets in Wireshark
 Figure 8: Wireshark Graphical User Interface on Microsoft Windows

The Wireshark interface has five major components:

The command menus are standard pulldown menus located at the top of the window. Of interest to us now is the File and
Capture menus. The File menu allows you to save captured packet data or open a file containing previously captured
packet data, and exit the Wireshark application. The Capture menu allows you to begin packet capture.
The packet-listing window displays a one-line summary for each packet captured, including the packet number
(assigned by Wireshark; this is not a packet numbercontained in any protocol’s header), the time at which the packet
was captured, the packet’s source and destination addresses, the protocol type, and protocol-specificinformation
contained in the packet. The packet listing can be sorted according to any ofthese categories by clicking on a column name.
The protocol type field lists the highest- level protocol that sent or received this packet, i.e., the protocol that is the source
or ultimate sink for this packet.
The packet-header details window provides details about the packet selected (highlighted) in the packet-listing window.
(To select a packet in the packet-listingwindow, place the cursor over the packet’s one-line summary in the packet-listing
window and click with the left mouse button.). These details include information about the Ethernet frame and IP datagram
that contains this packet. The amount of Ethernet and IP-layer detail displayed can be expanded or minimized by clicking
on the right- pointing or down-pointing arrowhead to the left of the Ethernet frame or IP datagram linein the packet details
window. If the packet has been carried over TCP or UDP, TCP or UDP details will also be displayed, which can similarly
be expanded or minimized. Finally, details about the highest-level protocol that sent or received this packet are also
provided.
The packet-contents window displays the entire contents of the captured frame, in both ASCII and hexadecimal format.
Towards the top of the Wireshark graphical user interface, is the packet display filter field, into which a protocol name
or other information can be entered in order to filterthe information displayed in the packet-listing window (and
hence the packet-headerand packet-contents windows). In the example below, we’ll use the packet-display filter field to
have Wireshark hide (not display) packets except those that correspond to HTTPmessages.
Capturing Packets

After downloading and installing Wireshark, you can launch it and click the name of an interface under Interface List to
start capturing packets on that interface. For example, ifyou want to capture traffic on the wireless network, click your
wireless interface.

Test Run
Do the following steps:

1. Start up the Wireshark program (select an interface and press start to capture packets).
2. Start up your favorite browser (ceweasel in Kali Linux).
3. In your browser, go to Wayne State homepage by typing www.wayne.edu.
4. After your browser has displayed the http://www.wayne.edu page, stop Wireshark packet capture by
selecting stop in the Wireshark capture window.This will cause the Wireshark capture window to
disappear and the main Wireshark window to display all packets captured since you began packet
capture see image below:
 5.Color Coding: You’ll probably see packets highlighted in green, blue, and black. Wireshark uses colors
to help you identify the types of traffic at a glance. By default, green is TCP traffic, dark blue is DNS
traffic, light blue is UDP traffic, andblack identifies TCP packets with problems — for example, they
could have beendelivered out-of-order.
6.You now have live packet data that contains all protocol messages exchanged between your computer and
other network entities! However, as you will notice the HTTP messages are not clearly shown because
there are many other packets included in the packet capture. Even though the only action you took
was to open your browser, there are many other programs in your computer that communicate via the
network in the background. To filter the connections to the ones we want to focus on, we have to use
the filtering functionality of Wireshark by typing “http” in the filtering field as shown below:

Notice that we
now view only the packets that are of protocol HTTP. However, we also still do not have the exact communication we
want to focus on because using HTTP as a filter is not descriptive enough to allow us to find our connection to
http://www.wayne.edu. We need to be more precise if we want to capture the correct setof packets.
7.To further filter packets in Wireshark, we need to use a more precise filter. By setting the
http.host==www.wayne.edu, we are restricting the view to packets that have as an http host the
www.wayne.edu website. Notice that we need two equal signs to perform the match “==” not just one. See
the screenshot below:
8.Now, we can try another protocol. Let’s use Domain Name System (DNS) protocol as an example
here.

9.Let’s try now to find out what are those packets contain by following one of the conversations (also
called network flows), select one of the packets and pressthe right mouse button (if you are on a Mac
use the command button and click), you should see something similar to the screen below:
 EXPERIMENT 14
How to run Nmap scan

Nmap is a free and open-source utility which is used to scan networks and security auditing. Nmap can discover hosts and
services on a computer network by sending packets and analyzing the responses. The utility is available on almost every os, i t is
available for windows, linux and mac.
Download Nmap –
To download Nmap you can simply head towards the official website by clicking here. In case of kali Linux and parrot os, it is
already available in there so you will not need to download the utility.
Please note that scanning websites from Nmap is not legal, in some cases if you are trying to too much in deep then you will
need written permissions from the owner of the website and the IP holder.

How to launch Nmap?

In Windows hosts you can simply install nmap and run it from the desktop icon using administrator privileges . In linux hosts
there are 2 ways of doing it, in case of kali linux and parrot os you can find the icon and click to start and later give it root
privileges by entering your password .

The other way is you can simply run

You can use it as a manual for using commands, just scroll down and head towards examples.

How to do simple scans and be legal?

As already mentioned, scanning networks and websites using nmap can be illegal, you may need written permissions to so. So, to
do scans that are legal you can use scanme.org, they offer you to perform scans on their website without any issues, but please
read their conditions so that you do not harm their website.

Now lets see a simple example to do a scan. To do so simply use nslookup command following the website url or address. If you
do not know the IP address of the website and using the command.
nslookup scanme.nmap.org
will give you its address. Now when you get the address you can use the same for scanning the network by
nslookup "address"
the address should be written as IP address which you found on the previous scan and without quotes.
This is how you can do a simple network scan. Now you can also save your scans in a text file for simplicity by using the
command
nslookup 45.33.32.156 >> result.txt

Please note that nmap is a very noisy scanning utility and you need to be anonymous and legal in some cases to do so. Please
ensure that you use it for legal and educational purposes.

EXPERIMENT 15
Operating System Detection using Nmap

NMAP stands for Network Mapper which is an open-source tool used for network exploration and security auditing, in
comparison to this, a tool named Nessus is used by industry professionals. These tools are mainly used by cybersecurity experts
and hackers.
Its main purpose is:
• Provide the list of the live host.
• Find the open Ports.
• The real-time information of a network.
• OS and Port scanning.
The hackers and the cybersecurity expert need to know the Operating System of the machine. It becomes very easy to access a
system if we can know the specific open ports or the security holes of the system. Network Mapper(NMAP) NMAP has a
database that helps in Operating systems (OS) but it is not automatically updated. The database to detect an OS is located at
‘/usr/share/nmap/nmap-os-db’.
Operating System(OS) detection is a very long and hectic process. So, before we get our hands dirty we should know about the
five separate probes being performed to determine the OS. This probe may consist of one or more packets. The response to each
packet (which is sent by the probe) by the target system helps to determine the OS type.
The five different probes are:
• Sequence Generation.
• ICMP Echo.
• TCP Explicit Congestion Notification.
• TCP.
• UDP.
1. Sequence Generation: The Sequence Generation Probe consists of six packets that are sent 100 ms apart and are all TCP
SYN packets. The result of all these packets will help in Operating System(OS) detection.
2. ICMP Echo: Two ICMP request packets are sent to the target system with different settings in the packet. The result of all
these will help verify the OS type by NMAP.
3. TCP Explicit Congestion Notification: Congestion is a slowdown that occurs when a lot of packets are generated and passed
by a single router. The packets which are sent are mainly used to get back the responses from the target system. This helps to
detect the OS because a specific OS returns a specific value and each OS handles a packet differently.

4. TCP: Six packets are sent during this probe, and some packets are sent to open or closed ports with specific packet settings by
using the corresponding result we can determine the type of Operating System(OS). The TCP Packets which are sent with
varying flags are as follows:
• no flags.
• SYN, FIN, URG, and PSH.
• ACK.
• SYN.
• ACK.
• FIN, PSH, and URG.

5. UDP: UDP probe consists of a single packet that is sent to a closed port. If the port used on the target system is closed and an
ICMP Port Unreachable message is returned it specifies that there is no Firewall.
OS detection using NMAP
Now we need to run the actual commands to perform OS detection using NMAP, and at first, we will get the IP address of the
host system, and then will perform a scan to get all active devices on the network.
Step 1: Getting the IP of the System

ifconfig

Step 2: List of active devices in the Network

nmap -sn 192.168.232.128/24

Let’s do an SYN scan with OS detection in one of the active IPs

Let’s select IP: 192.168.232.2
nmap -sS 192.168.232.2 -O
Running: VMware Player.
OS details: VMware Player virtual NAT device.

Let’s now perform an Aggressive scan To guess the OS

• -sV stands for Service version.

• -A stands for Aggressive.
It will only display the chance of Operation System (OS) on the host computer with the help of Probability and Percentage.
nmap -sV 192.168.232.2 -A

EXPERIMENT 16
Do the following using NS2 Simulator
i. NS2 Simulator-Introduction
ii. Simulate to Find the Number of Packets Dropped
iii. Simulate to Find the Number of Packets Dropped by TCP/UDP
iv. Simulate to Find the Number of Packets Dropped due to Congestion
v. Simulate to Compare Data Rate& Throughput.

Introduction to NS-2:
NS2 is an open-source simulation tool that runs on Linux. It is a discreet eventsimulator targeted
at networking research and provides substantial support for simulation ofrouting, multicast protocols
and IP protocols, such as UDP, TCP, RTP and SRM overwired and wireless (local and satellite)
networks.
 Widely known as NS2, is simply an event driven simulation tool. 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 protocolsand
simulating their corresponding behaviors.

Basic Architecture of NS2

TCL – Tool Command Language

Tcl is a very simple programming language. If you have programmed before, you can learn
enough to write interesting Tcl programs within a few hours. This page providesa quick overview
of the main features of Tcl. After reading this you'll probably be able to start writing simple Tcl scripts
on your own; however, we recommend that you consult one of the many available Tcl books for more
complete information.

Basic syntax

Tcl scripts are made up of commands separated by newlines or semicolons.

Commands all have the same basic form illustrated by the following example:
expr 20 + 10

This command computes the sum of 20 and 10 and returns the result, 30. You can try out this
example and all the others in this page by typing them to a Tcl application such as tclsh; after a
command completes, tclsh prints its result.

Each Tcl command consists of one or more words separated by spaces. In this example there
are four words: expr, 20, +, and 10. The first word is the name of a command and the other words are
arguments to that command. All Tcl commands consist of words,
Where do commands come from?

As you have seen, all of the interesting features in Tcl are represented by commands.
Statements are commands, expressions are evaluated by executing commands, control structures are
commands, and procedures are commands.

Tcl commands are created in three ways. One group of commands is provided bythe Tcl
interpreter itself. These commands are called builtin commands. They include all ofthe commands
you have seen so far and many more (see below). The builtin commands are present in all Tcl
applications.

The second group of commands is created using the Tcl extension mechanism. Tcl provides
APIs that allow you to create a new command by writing a command procedure inC or C++ that
implements the command. You then register the command procedure with the Tcl interpreter by
telling Tcl the name of the command that the procedure implements. In the future, whenever that
particular name is used for a Tcl command, Tcl will call your command procedure to execute the
command. The builtin commands are also implemented using this same extension mechanism; their
command procedures are simply part of the Tcllibrary.

When Tcl is used inside an application, the application incorporates its key features into Tcl
using the extension mechanism. Thus the set of available Tcl commands varies from application to
application. There are also numerous extension packages that can be incorporated into any Tcl
application. One of the best known extensions is Tk, which provides powerful facilities for building
graphical user interfaces. Other extensions provideobject-oriented programming, database access,
more graphical capabilities, and a variety of other features. One of Tcl's greatest advantages for
building integration applications is the ease with which it can be extended to incorporate new features
or communicate with other resources.

The third group of commands consists of procedures created with the proc command, such
as the power command created above. Typically, extensions are used for lower-level functions where
C programming is convenient, and procedures are used for higher-level functions where it is easier
to write in Tcl.
 Wired TCL Script Components

Create the event scheduler

Open new files & turn on the tracing
Create the nodes
Setup the links
Configure the traffic type (e.g., TCP, UDP, etc) Set
the time of traffic generation (e.g., CBR, FTP)
Terminate the simulation
NS Simulator Preliminaries.
Initialization and termination aspects of the ns simulator.
Definition of network nodes, links, queues and topology.
Definition of agents and of applications.
The nam visualization tool.
Tracing and random variables

Features of NS2
NS2 can be employed in most unix systems and windows. Most of the NS2 code is in C++.
It uses TCL as its scripting language, Otcl adds object orientation to TCL.NS(version 2) is an object
oriented, discrete event driven network simulator that is freely distributed and open source.

• Traffic Models: CBR, VBR, Web etc

• Protocols: TCP, UDP, HTTP, Routing algorithms,MAC etc
• Error Models: Uniform, bursty etc
• Misc: Radio propagation, Mobility models , Energy Models

• Topology Generation tools

• Visualization tools (NAM), Tracing

Structure of NS
● NS is an object oriented discrete event simulator
– Simulator maintains list of events and executes one event after another
– Single thread of control: no locking or race conditions

● Back end is C++ event scheduler

– Protocols mostly
– Fast to run, more control
• Front end is OTCL
Creating scenarios, extensions to C++ protocolsfast
to write and change
 Platforms
It can be employed in most unix systems(FreeBSD, Linux, Solaris) and Windows.

Source code
Most of NS2 code is in C++

Scripting language
It uses TCL as its scripting language OTcl adds object orientation to TCL.

Protocols implemented in NS2

Transport layer(Traffic Agent) – TCP, UDP
Network layer(Routing agent)

Interface queue – FIFO queue, Drop Tail queue, Priority queueLogic

link contol layer – IEEE 802.2, AR

How to use NS2

Design Simulation – Determine simulation scenario
Build ns-2 script using tcl.
Run simulation

Simulation with NS2

Define objects of simulation.
Connect the objects to each other

Start the source applications. Packets are then created and are transmitted through
network.

Exit the simulator after a certain fixed time.

NS programming Structure
● Create the event scheduler
● Turn on tracing
● Create network topology

● Create transport connections

● Generate traffic
● Insert errors

Sample Wired Simulation using

NS-2Creating Event Scheduler

● Create event scheduler: set ns [new simulator]

● Schedule an event: $ns at <time> <event>

– event is any legitimate ns/tcl function

$ns at 5.0 “finish”

proc finish {} {
global ns nf

close $nf

exec nam out.nam &

exit 0

● Start Scheduler
$ns run

Tracing

● All packet trace

$ns traceall[open out.tr w]

<event> <time> <from> <to> <pkt> <size>

<flowid> <src> <dst> <seqno> <aseqno>

+ 0.51 0 1 cbr 500 —– 0 0.0 1.0 0 2

_ 0.51 0 1 cbr 500 —– 0 0.0 1.0 0 2

R 0.514 0 1 cbr 500 —–0 0.0 1.0 0 0
● Variable trace
set par [open output/param.tr w]

$tcp attach $par

$tcp trace cwnd_

$tcp trace maxseq_

$tcp trace rtt_

Tracing and Animation

● Network Animator
set nf [open out.nam w]
$ns namtraceall

$nf

proc finish {} {

global ns nf
close $nf
exec nam out.nam &

exit 0

Creating topology

● Two nodes connected by a link

Creating link between nodes
$ns <link_type> $n0 $n1 <bandwidth>
<delay><queue- type> $ns duplex-
link$n0 $n1 1Mb 10ms DropTail

Data Sending

● Create UDP agent

set udp0 [new Agent/UDP]

$ns attach-agent $n0 $udp0

● Create CBR traffic source for

feeding into UDP agentset cbr0 [new
Application/Traffic/CBR]
$cbr0 set packetSize_ 500

$cbr0 set interval_ 0.005

$cbr0 attach-agent$udp0

● Create traffic sink

set null0 [new Agent/Null]

$ns attach-agent$n1 $null0

● Connect two agents

$ns connect $udp0 $null0

● Start and stop of data

$ns at 0.5 “$cbr0 start”

$ns at 4.5 “$cbr0 stop”

Traffic on top of TCP

● FTP
set ftp [new Application/FTP]

$ftp attach-agent$tcp0

● Telnet
set telnet [new Application/Telnet]

$telnet attach-agent$tcp0

PROCEDURE
STEP 1: Start

STEP 2: Create the simulator object ns for designing the

given simulationSTEP 3: Open the trace file and nam file in

the write mode

STEP 4: Create the nodes of the simulation using the ‘set’ command

STEP 5: Create links to the appropriate nodes using $ns duplex-link

command STEP 6: Set the orientation for the nodes in the simulation
using ‘orient’ commandSTEP 7: Create TCP agent for the nodes and

attach these agents to the nodes STEP 8: The traffic generator used is
FTP for both node0 and node1

STEP 9: Configure node1 as the sink and attach it

STEP10: Connect node0 and node1 using
‘connect’ commandSTEP 11: Setting color for
the nodes
STEP 12: Schedule the events for
FTP agent 10 secSTEP 13:

Schedule the simulation for 5

minutes