Computer Networks Lab

B.Tech. III Year I Sem.

Course Objectives:

1. To understand the working principle of various communication protocols.

2. To understand the network simulator environment and visualize a network topology

and observe its performance

3. To analyze the traffic flow and the contents of protocol frames

Course Outcomes:

1. Implement data link layer farming methods

2. Analyze error detection and error correction codes.

3. Implement and analyze routing and congestion issues in network design.

4. Implement Encoding and Decoding techniques used in presentation layer

5. To be able to work with different network tools

List of Experiments

1. Implement the data link layer framing methods such as character, character-stuffing
and bit stuffing.
2. Write a program to compute CRC code for the polynomials CRC-12, CRC-16 and
CRC CCIP
3. Develop a simple data link layer that performs the flow control using the sliding
window protocol, and loss recovery using the Go-Back-N mechanism.
4. Implement Dijsktra’s algorithm to compute the shortest path through a network
5. Take an example subnet of hosts and obtain a broadcast tree for the subnet.
6. Implement distance vector routing algorithm for obtaining routing tables at each node.
7. Implement data encryption and data decryption
8. Write a program for congestion control using Leaky bucket algorithm.
9. Write a program for frame sorting techniques used in buffers.
10.Wireshark
i. Packet Capture Using Wire shark
ii. Starting Wire shark
iii. Viewing Captured Traffic
iv. Analysis and Statistics & Filters.
11. How to run Nmap scan
12. Operating System Detection using Nmap
13. 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.
vi. Simulate to Plot Congestion for Different Source/Destination
vii. Simulate to Determine the Performance with respect to Transmission of
Packets
 EXPERIMENT NO: 1

Aim: Implement the data link layer framing methods such as.

i. Character stuffing
ii. Bit stuffing.

ALGORITHM:
Step 1. Start
Step 2. Append DLE STX at the beginning of the string
Step 3. Check the data if character is present; if character DLE is present in the string
(example DOODLE) insert another DLE in the string (ex: DOODLEDLE)
Step 4. Transmit DLE ETXat the end of the string
Step 5. Display the string
Step 6. Stop
SOURCE CODE:
i) PROGRAM FOR CHARACTER STUFFING
#include<stdio.h>
#include<string.h>
main()
{
char a[30], fs[50] = " ", t[3], sd, ed, x[3], s[3], d[3], y[3];
inti, j, p = 0, q = 0;
clrscr();
printf("Enter characters to be stuffed:");
scanf("%s", &a);
printf("\nEnter a character that represents starting delimiter:");
scanf(" %c", &sd);
printf("\nEnter a character that represents ending delimiter:");
scanf(" %c", &ed);
x[0] = s[0] = s[1] = sd;
x[1] = s[2] = '\0';
y[0] = d[0] = d[1] = ed;
d[2] = y[1] = '\0';
strcat(fs, x);
for(i = 0; i<strlen(a); i++)
{
t[0] = a[i];
t[1] = '\0';
if(t[0] == sd)
strcat(fs, s);
elseif(t[0] == ed)
strcat(fs, d);
else
strcat(fs, t);
}
strcat(fs, y);
printf("\n After stuffing:%s", fs);
getch();
}

OUTPUT:
Enter characters to be stuffed: goodday
Enter a character that represents starting delimiter: d
Enter a character that represents ending delimiter: g
After stuffing: dggooddddayg
ii) BIT Stuffing program
ALGORITHM
Step 1. Start
Step 2. Initialize the array for transmitted stream with the special bit pattern 0111 1110
which indicates the beginning of the frame.
Step 3. Get the bit stream to be transmitted in to the array.
Step 4. Check for five consecutive ones and if they occur, stuff a bit 0
Step 5. Display the data transmitted as it appears on the data line after appending 0111
1110 at the end
Step 6. For de−stuffing, copy the transmitted data to another array after detecting the
stuffed bits
Step 7. Display the received bit stream
Step 8. Stop

Source code
#include<stdio.h>
#include<conio.h>
void main()
{
inti=0,count=0;
chardatabits[80];
printf("Enter Data Bits: ");
scanf("%s",&databits);
printf("\nData Bits After Bit stuffing: ");
for(i=0; i<strlen(databits); i++)
{
if(databits[i]=='1')
count++;
else
count=0;
printf("%c",databits[i]);
 if(count==5)
{
printf("0");
count=0;
}
}
getch();
}
OUTPUT:
 EXPERIMENT NO: 2.
AIM: Implement on a data set of characters the three CRC polynomials – CRC 12,
CRC 16 and CRC CCIP.
Theory
CRC means Cyclic Redundancy Check. It is the most famous and traditionally successful
mechanism used in error detection through the parity bits installed within the data and
obtaining checksum which acts as the verifier to check whether the data retreived at the
reciever end is genuine or not. Various operations are involved in implementing CRC on a
data set through CRC generating polynomials. In the program, I have also provided the user
to opt for Error detection whereby he can proceed for it. Understand the program below as it
is much simpler than pretented to be so.

ALGORITHM:
Step 1. A string of n as is appended to the data unit. The length of predetermined divisor
is n+ 1.
Step 2. The newly formed data unit 1. A string of n as is appended to the data unit. The
length of predetermined divisor is n+ 1.
i.e. original data + string of n as are divided by the divisor using binary division and
remainderis obtained. This remainder is called CRC.
Step 3. Now, string of n Os appended to data unit is replaced by the CRC remainder
(which is also of n bit).
Step 4. The data unit + CRC is then transmitted to receiver.
Step 5. The receiver on receiving it divides data unit + CRC by the same divisor &
checks theremainder.
Step 6. If the remainder of division is zero, receiver assumes that there is no error in
data and itaccepts it.
Step 7. If remainder is non-zero then there is an error in data and receiver rejects it.
SOURCE CODE:
#include <stdio.h>
#include <math.h>
main()
{
inti, j, k, m, n, cl;
char a[10], b[100], c[100];
clrscr();
printf("\n ENTER POLYNANOMIAL:");
scanf("%s", &a);
printf("\n ENTER THE FRAME:");
scanf("%s",&b);
m = strlen(a);
n = strlen(b);
for (i = 0; i< m; i++)
/*Toeliminat first zeros inpolynomial */
{
if (a[i] == '1')
{
m = m - i;
break;
}
}

for (k = 0; k < m; k++)

/*To Adjust the polynomial
*/
a[k] = a[k + i];
cl = m + n - 1;
for (i = 0; i< n; i++) /*To copy the original frame to c[]*/
c[i] = b[i];
 for (i = n; i< cl; i++) /*To add n-1 zeros at the end of frame */
c[i] = '0';
c[i] = '\0'; /*To make it as a string */
for (i = 0; i< n; i++) /*To set polynomial remainder at end of c[]*/
if (c[i] == '1')
{
for (j = i, k = 0; k < m; k++, j++)
if (a[k] == c[j])
c[j] = '0';
else c[j] = '1';
}

for (i = 0; i< n; i++) /*To copy original data in c[]*/

c[i] = b[i];
printf("\n THE MESSAGE IS: %s", c);
getch();
}
OUTPUT:
ENTER POLYNANOMIAL:1011
ENTER THE FRAME:10011101
THE MESSAGE IS: 10011101011

ENTER POLYNANOMIAL:00101
ENTER THE FRAME:10101011
THE MESSAGE IS: 1010101101
 EXPERIMENT NO: 3.
AIM: Develop a simple data link layer that performs the flow control using the sliding
window protocol, and loss recovery using the Go-Back-N mechanism.
ALGORITHM:
Step 1. Start the program.

Step 2. Get the frame size from the user

Step 3. To create the frame based on the user request.

Step 4. To send frames to server from the client side.

Step 5. If your frames reach the server it will send ACK signal to client otherwise it will send
NACK signal to client.

Step 6. Stop the program

SOURCE CODE:
#include<stdio.h>

int main()
{
intw,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 NO: 4.
AIM: Implement Dijkstra‘s algorithm to compute the Shortest path through a network
ALGORITHM:
Step 1: Create a set shortPath to store vertices that come in the way of the shortest path tree.
Step 2: Initialize all distance values as INFINITE and assign distance values as 0 for source
vertex so that it is picked first.
Step 3: Loop until all vertices of the graph are in the shortPath.
Step 3.1: Take a new vertex that is not visited and is nearest.
Step 3.2: Add this vertex to shortPath.
Step 3.3: For all adjacent vertices of this vertex update distances. Now check every
adjacent vertex of V, if sum of distance of u and weight of edge is elss the update it.

SOURCE CODE:
#include<stdio.h>
#include<conio.h>
#define INFINITY 9999
#define MAX 10
void dijkstra(int G[MAX][MAX], int n, int startnode);
int main() {
int G[MAX][MAX], i, j, n, u;
printf("Enter no. of vertices:");
scanf("%d", & n);
printf("\nEnter the adjacency matrix:\n");
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
scanf("%d", & G[i][j]);
printf("\nEnter the starting node:");
scanf("%d", & u);
dijkstra(G, n, u);
return 0;
}

void dijkstra(int G[MAX][MAX], int n, int startnode) {

int cost[MAX][MAX], distance[MAX], pred[MAX];
int visited[MAX], count, mindistance, nextnode, i, j;
//pred[] stores the predecessor of each node
//count gives the number of nodes seen so far
//create the cost matrix
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (G[i][j] == 0)
cost[i][j] = INFINITY;
else
cost[i][j] = G[i][j];
//initialize pred[],distance[] and visited[]
for (i = 0; i < n; i++) {
distance[i] = cost[startnode][i];
pred[i] = startnode;
visited[i] = 0;
}
distance[startnode] = 0;
visited[startnode] = 1;
count = 1;
while (count < n - 1) {
mindistance = INFINITY;
//nextnode gives the node at minimum distance
for (i = 0; i < n; i++)
if (distance[i] < mindistance && !visited[i]) {
mindistance = distance[i];
nextnode = i;
}
//check if a better path exists through nextnode
visited[nextnode] = 1;
for (i = 0; i < n; i++)
if (!visited[i])
if (mindistance + cost[nextnode][i] < distance[i]) {
distance[i] = mindistance + cost[nextnode][i];
pred[i] = nextnode;
}
 count++;
}

//print the path and distance of each node

for (i = 0; i < n; i++)
if (i != startnode) {
printf("\nDistance of node%d=%d", i, distance[i]);
printf("\nPath=%d", i);
j = i;
do {
j = pred[j];
printf("<-%d", j);
} while (j != startnode);
}
}

OUTPUT
 EXPERIMENT NO: 5.
AIM: Implement broadcast tree for a given subnet of hosts
ALGORITHM:
Step 1: Start
Step 2: Select any edge of minimal value that is not a loop. This is the first edge of T.
Step 3: Select any remaining edge of G having minimal value that does not from a circuit with
the edges already included in T.
Continue Step 4: until T contains n-1 edges where n is the number of vertices of G.
Step 5: Stop
SOURCE CODE:
#include<stdio.h>
int p, q, u, v, n;
int min = 99, mincost = 0;
int t[50][2], i, j;
int parent[50], edge[50][50];
void main() {
printf("\n Enter the number of nodes");
scanf("%d", & n);
for (i = 0; i< n; i++) {
printf("%c\t", 65 + i);
parent[i] = -1;
}
printf("\n");
for (i = 0; i< n; i++) {
printf("%c", 65 + i);
for (j = 0; j < n; j++)
scanf("%d", & edge[i][j]);
}
for (i = 0; i< n; i++) {
for (j = 0; j < n; j++)
if (edge[i][j] != 99)
if (min > edge[i][j]) {
min = edge[i][j];
u = i;
v = j;
}
p = find(u);
q = find(v);
if (p != q) {
t[i][0] = u;
t[i][1] = v;
mincost = mincost + edge[u][v];
sunion(p, q);
} else {
t[i][0] = -1;
t[i][1] = -1;
}
min = 99;
}
printf("Minimum cost is %d\n Minimum spanning tree is\n", mincost);
for (i = 0; i< n; i++)
if (t[i][0] != -1 && t[i][1] != -1) {
printf("%c %c %d", 65 + t[i][0], 65 + t[i][1],
edge[t[i][0]][t[i][1]]);
printf("\n");
}
}
sunion(int l, int m) {
parent[l] = m;
}
find(int l) {
if (parent[l] > 0)
 l = parent[l];
return l;
}

OUTPUT:
 EXPERIMENT NO: 6
NAME OF THE EXPERIMENT: Distance Vector routing.
AIM: Obtain Routing table at each node using distance vector routing algorithm for a
given subnet.
ALGORITHM:
At each node x,

STEP 1:Initialization

for all destinations y in N:

Dx(y) = c(x,y) // If y is not a neighbor then c(x,y) = ∞
for each neighbor w
Dw(y) = ? for all destination y in N.
for each neighbor w
send distance vector Dx = [ Dx(y) : y in N ] to w

STEP 2: loop
wait(until I receive any distance vector from some neighbor w)
for each y in N:
Dx(y) = minv{c(x,v)+Dv(y)}
If Dx(y) is changed for any destination y
Send distance vector Dx = [ Dx(y) : y in N ] to all neighbors

forever

SOURCE CODE:
#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:
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 NO: 7
NAME OF THE EXPERIMENT: RSA.
AIM: Using RSA algorithm encrypt a text data and Decrypt the same.
ALGORITHM
Step 1: Two prime numbers are selected as p and q

Step 2: n = pq which is the modulus of both the keys.

Step 3: Calculate totient = (p-1)(q-1)

Step 4: Choose e such that e > 1 and coprime to totient which means gcd (e,
totient) must be equal to 1, e is the public key

Step 5: Choose d such that it satisfies the equation de = 1 + k (totient), d is the

private key not known to everyone.

Step 6: Cipher text is calculated using the equation c = m^e mod n where m is the
message.

Step 7: With the help of c and d we decrypt message using equation m = c^d mod
n where d is the private key.

SOURCE CODE
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>

long int p,q,n,t,flag,e[100],d[100],temp[100],j,m[100],en[100],i;

char msg[100];
int prime(long int);
void ce();
long int cd(long int);
void encrypt();
void decrypt();
void main()
{
clrscr();
printf("\nENTER FIRST PRIME NUMBER\n");
scanf("%d",&p);
flag=prime(p);
if(flag==0)
{
printf("\nWRONG INPUT\n");
getch();
 exit(1);
}
printf("\nENTER ANOTHER PRIME NUMBER\n");
scanf("%d",&q);
flag=prime(q);
if(flag==0||p==q)
{
printf("\nWRONG INPUT\n");
getch();
exit(1);
}
printf("\nENTER MESSAGE\n");
fflush(stdin);
scanf("%s",msg);
for(i=0;msg[i]!=NULL;i++)
m[i]=msg[i];
n=p*q;
t=(p-1)*(q-1);
ce();
printf("\nPOSSIBLE VALUES OF e AND d ARE\n");
for(i=0;i<j-1;i++)
printf("\n%ld\t%ld",e[i],d[i]);
encrypt();
decrypt();
getch();
}
int prime(long int pr)
{
int i;
j=sqrt(pr);
for(i=2;i<=j;i++)
{
if(pr%i==0)
return 0;
}
return 1;
}
void ce()
{
int k;
k=0;
for(i=2;i<t;i++)
{
if(t%i==0)
continue;
flag=prime(i);
 if(flag==1&&i!=p&&i!=q)
{
e[k]=i;
flag=cd(e[k]);
if(flag>0)
{
d[k]=flag;
k++;
}
if(k==99)
break;
}
}
}
long int cd(long int x)
{
long int k=1;
while(1)
{
k=k+t;
if(k%x==0)
return(k/x);
}
}
void encrypt()
{
long int pt,ct,key=e[0],k,len;
i=0;
len=strlen(msg);
while(i!=len)
{
pt=m[i];
pt=pt-96;
k=1;
for(j=0;j<key;j++)
{
k=k*pt;
k=k%n;
}
temp[i]=k;
ct=k+96;
en[i]=ct;
i++;
}
en[i]=-1;
printf("\nTHE ENCRYPTED MESSAGE IS\n");
for(i=0;en[i]!=-1;i++)
printf("%c",en[i]);
}
void decrypt()
{
long int pt,ct,key=d[0],k;
i=0;
while(en[i]!=-1)
{
ct=temp[i];
k=1;
for(j=0;j<key;j++)
{
k=k*ct;
k=k%n;
}
pt=k+96;
m[i]=pt;
i++;
}
m[i]=-1;
printf("\nTHE DECRYPTED MESSAGE IS\n");
for(i=0;m[i]!=-1;i++)
printf("%c",m[i]);
}

OUTPUT:
 EXPERIMENT NO: 8

AIM: Write a program for congestion control using Leaky bucket algorithm.
ALGORITHM:
Step 1: Initialize a counter to n at the tick of the clock.
Step 2: Repeat until n is smaller than the packet size of the packet at the head of the
queue.
1. Pop a packet out of the head of the queue, say P.
2. Send the packet P, into the network
3. Decrement the counter by the size of packet P.
Step 3: Reset the counter and go to step 1.

SOURCE CODE:
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
void main() {
int
packets[8], i, j, clk, b_size, o_rate, i_rate, p_sz_rm = 0, p_sz, p_time;
clrscr();
for (i = 0; i< 5; ++i) {
packets[i] = rand() % 10;
if (packets[i] == 0) --i;
}
printf("Enter output rate:");
scanf("%d", &o_rate);
printf("\nEnter bucket size:");
scanf("%d", &b_size);
for (i = 0; i< 5; ++i) {
if ((packets[i] + p_sz_rm) >b_size) {
if (packets[i] >b_size)
printf("\nIncoming packet size:%d greater than
bucket capacity\ n ",packets[i]);
elseprintf("Bucket size exceeded\n");
}
else {
p_sz = packets[i];
p_sz_rm += p_sz;
printf("\n------------------------------------------------- -
\n ");
printf("Incoming packet:%d", p_sz); printf("\nTransmission left:%d\n", p_sz_rm); p_time =
rand() % 10; printf("Next packet will come at %d", p_time);
for (clk = 0; clk<p_time&&p_sz_rm> 0; ++clk) {
printf("\nTime left %d---No packets to
transmit!!\n ",p_time-clk);
sleep(1);
if (p_sz_rm) {
printf("Transmitted\n");
if (p_sz_rm<o_rate)
p_sz_rm = 0;
elsep_sz_rm -= o_rate;
printf("Bytes remaining:%d\n", p_sz_rm);
} else printf("No packets to transmit\n");
}
}
}
getch();
}

OUTPUT
 EXPERIMENT NO: 9
AIM: Write a program for frame sorting techniques used in buffers.
ALGORITHM:
Step 1: Enter the number of frames
Step 2: Enter the frame contents for sequence number
Step 3: divides the stream of bits received from the network layer into manageable data units
called frames
Step 4: If frames are to be distributed to different systems on the network, the Data link layer
adds a header to the frame to define the sender and/or receiver of the frame.
SOURCE CODE:
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#define FSize 3
typedef struct packet{int SeqNum; char Data[FSize+1];}packet;
struct packet *readdata, *transdata;
int divide(char *msg) {
int msglen, NoOfPacket, i, j;
msglen = strlen(msg);
NoOfPacket = msglen/FSize;
if ((msglen%FSize)!=0) NoOfPacket++;
readdata = (struct packet *)malloc(sizeof(packet) * NoOfPacket);
for(i = 0; i < NoOfPacket; i++) {
readdata[i].SeqNum = i + 1;
for (j = 0; (j < FSize) && (*msg != '\0'); j++, msg++)
readdata[i].Data[j] = *msg;
readdata[i].Data[j] = '\0';
}
printf("\nThe Message has been divided as follows\n");
printf("\nPacket No. Data\n\n");
for (i = 0; i < NoOfPacket; i++)
printf(" %2d %s\n", readdata[i].SeqNum,
readdata[i].Data);
 return NoOfPacket;
}
void shuffle(int NoOfPacket) {
int *Status;
int i, j, trans;
randomize();
Status=(int * )calloc(NoOfPacket, sizeof(int));
transdata = (struct packet *)malloc(sizeof(packet) * NoOfPacket);
for (i = 0; i < NoOfPacket;) {
trans = rand()%NoOfPacket;
if (Status[trans]!=1) {
transdata[i].SeqNum = readdata[trans].SeqNum;

strcpy(transdata[i].Data, readdata[trans].Data);
i++; Status[trans] = 1;
}
}
free(Status);
}
void sortframes(int NoOfPacket) {
packet temp;
int i, j;
for (i = 0; i < NoOfPacket; i++)
for (j = 0; j < NoOfPacket – i-1; j++)
if (transdata[j].SeqNum > transdata[j + 1].SeqNum) {
temp.SeqNum = transdata[j].SeqNum;
strcpy(temp.Data, transdata[j].Data);
transdata[j].SeqNum = transdata[j + 1].SeqNum;
strcpy(transdata[j].Data, transdata[j + 1].Data);
transdata[j + 1].SeqNum = temp.SeqNum;
strcpy(transdata[j + 1].Data, temp.Data);
}
}
void receive(int NoOfPacket) {
int i;
printf("\nPackets received in the following order\n");
 for (i = 0; i < NoOfPacket; i++) printf("%4d", transdata[i].SeqNum);
sortframes(NoOfPacket);
printf("\n\nPackets in order after sorting..\n");
for (i = 0; i < NoOfPacket; i++) printf("%4d", transdata[i].SeqNum);
printf("\n\nMessage received is :\n");
for (i = 0; i < NoOfPacket; i++) printf("%s", transdata[i].Data);
}
void main() {
char *msg;
int NoOfPacket;
clrscr();
printf("\nEnter The message to be Transmitted :\n");
scanf("%[^\n]", msg);
NoOfPacket = divide(msg);
shuffle(NoOfPacket);
receive(NoOfPacket);
free(readdata);
free(transdata);
getch();
}
OUTPUT
Enter The messgae to be Transmitted :
hi, it was nice meeting u on sunday
The Message has been divided as follows
Packet No. Data
1 hi,
2 it
3 wa
4sn
5 ice
6 me
7 eti
8 ng
9uo
10 n s
11 und
12 ay
Packets received in the following order
4 2 6 3 5 1 8 9 11 7 12 10
Packets in order after sorting..
1 2 3 4 5 6 7 8 9 10 11 12
Message received is :
hi, it was nice meeting u on sunday
 EXPERIMENT NO: 10
Note: Find the steps given in experiments to run the tools.
AIM: Wireshark
i. Packet Capture Using Wire shark
ii. Starting Wire shark
iii. Viewing Captured Traffic
iv. Analysis and Statistics & Filters.

Wireshark

What is Wireshark?

Wireshark is an open-source packet analyzer, which is used for education, analysis, software
development, communication protocol development, and network troubleshooting.

It is used to track the packets so that each one is filtered to meet our specific needs. It is
commonly called as a sniffer, network protocol analyzer, and network analyzer. It is also
used by network security engineers to examine security problems.

Wireshark is a free to use application which is used to apprehend the data back and forth. It is
often called as a free packet sniffer computer application. It puts the network card into an
unselective mode, i.e., to accept all the packets which it receives.

Uses of Wireshark:

Wireshark can be used in the following ways:

1. It is used by network security engineers to examine security problems.

2. It allows the users to watch all the traffic being passed over the network.
3. It is used by network engineers to troubleshoot network issues.
4. It also helps to troubleshoot latency issues and malicious activities on your network.
5. It can also analyze dropped packets.
 6. It helps us to know how all the devices like laptop, mobile phones, desktop, switch,
routers, etc., communicate in a local network or the rest of the world.

What is a packet?

A packet is a unit of data which is transmitted over a network between the origin and the
destination. Network packets are small, i.e., maximum 1.5 Kilobytes for Ethernet packets
and 64 Kilobytes for IP packets. The data packets in the Wireshark can be viewed online and
can be analyzed offline.

i) Starting Wire shark

Step 1: Open the wire shark software

 ii) Packet Capture Using Wire shark
Step 1:

.
Step 2:

Step 3:

Step 4: Create a file to save captured packets

Step 5: Press red button to stop capturing packets

Step 6: Now open the captured packet file

iii) Viewing Captured Traffic

Step 1: Viewing Packets You Have Captured
Once you have captured some packets or you have opened a previously saved capture file, you
can view the packets that are displayed in the packet list pane by simply clicking on a packet
in the packet list pane, which will bring up the selected packet in the tree view and byte view
panes.

You can then expand any part of the tree to view detailed information about each protocol in
each packet. Clicking on an item in the tree will highlight the corresponding bytes in the byte
view. An example with a TCP packet selected is shown in Figure 1, “Wireshark with a TCP
packet selected for viewing”. It also has the Acknowledgment number in the TCP header
selected, which shows up in the byte view as the selected bytes.

Fig 1. Wireshark with a TCP packet selected for viewing

Step 2:

You can also select and view packets the same way while Wireshark is capturing if you
selected “Update list of packets in real time” in the “Capture Preferences” dialog box.

In addition you can view individual packets in a separate window as shown in Figure 2,
“Viewing a packet in a separate window”. You can do this by double-clicking on an item in
the packet list or by selecting the packet in which you are interested in the packet list pane and
selecting
Step 3: View → Show Packet in New Window. This allows you to easily compare two or
more packets, even across multiple files.
Figure 2. Viewing a packet in a separate window

iv) Analysis and Statistics & Filters.

Analyzing data packets on Wireshark

Wireshark shows you three different panes for inspecting packet data. The Packet List, the
top pane, lists all the packets in the capture. When you click on a packet, the other two panes
change to show you the details about the selected packet. You can also tell if the packet is
part of a conversation. Here are details about each column in the top pane:

 No.: This is the number order of the packet captured. The bracket indicates that this
packet is part of a conversation.
 Time: This column shows how long after you started the capture this particular packet
was captured. You can change this value in the Settings menu to display a different
option.
 Source: This is the address of the system that sent the packet.
 Destination: This is the address of the packet destination.
 Protocol: This is the type of packet. For example: TCP, DNS, DHCPv6, or ARP.
 Length: This column shows you the packet’s length, measured in bytes.
  Info: This column shows you more information about the packet contents, which will
vary depending on the type of packet.

Packet Details, the middle pane, shows you as much readable information about the packet
as possible, depending on the packet type. You can right-click and create filters based on the
highlighted text in this field.

The bottom pane, Packet Bytes, displays the packet exactly as it was captured in
hexadecimal.

When looking at a packet that is part of a conversation, you can right-click the packet and
select Follow to see only the packets that are part of that conversation.

Wireshark filters

Some of the best features of Wireshark are the capture filters and display filters. Filters allow
you to view the capture the way you need to see it to troubleshoot the issues at hand. Below
are several filters to get you started.

Wireshark capture filters

Capture filters limit the captured packets by the chosen filter. If the packets don’t match the
filter, Wireshark won’t save them. Examples of capture filters include:

host IP-address: This filter limits the captured traffic to and from the IP address

net 192.168.0.0/24: This filter captures all traffic on the subnet

dst host IP-address: Capture packets sent to the specified host

port 53: Capture traffic on port 53 only

port not 53 and not arp: Capture all traffic except DNS and ARP traffic

Wireshark display filters

Wireshark display filters change the view of the capture during analysis. After you’ve
stopped the packet capture, use display filters to narrow down the packets in the Packet List
to troubleshoot your issue.

One of the most useful display filters is:

ip.src==IP-address and ip.dst==IP-address

This filter shows packets sent from one computer (ip.src) to another (ip.dst). You can also
use ip.addr to show packets to and from that IP. Other filters include:

tcp.porteq 25: This filter will show you all traffic on port 25, which is usually SMTP traffic
icmp: This filter will show you only ICMP traffic in the capture, most likely they are pings

ip.addr != IP_address: This filter shows you all traffic except the traffic to or from the
specified computer

Analysts even build filters to detect specific attacks, like this filter used to detect the Sasser
worm:

ls_ads.opnum==0x09

Step 4: Metrics and statistics

Under the Statistics menu, you’ll find a plethora of options to view details about your capture.
Step 5: Capture File Properties:

Step 6: Wireshark I/O Graph:

 EXPERIMENT NO: 11
AIM: How to run Nmap scan
1. Download the Nmap installer. This can be found for free from the developer’s website.
It is highly recommended that you download directly from the developer to avoid any
potential viruses or fake files. Downloading the Nmap installer includes Zenmap, the
graphical interface for Nmap which makes it easy for newcomers to perform scans
without having to learn command lines.
The Zenmap program is available for Windows, Linux, and Mac OS X. You can find the
installation files for all operating systems on the Nmap website.

2. Install Nmap. Run the installer once it is finished downloading. You will be asked which
components you would like to install. In order to get the full benefit of Nmap, keep all of
these checked. Nmap will not install any adware or spyware.
Step 1:

3. Run the "Nmap – Zenmap" GUI program. If you left your settings at default during
installation, you should be able to see an icon for it on your desktop. If not, look in your
Start menu. Opening Zenmap will start the program.
Step 2:

4. Enter in the target for your scan. The Zenmap program makes scanning a fairly simple
process. The first step to running a scan is choosing your target. You can enter a domain
(example.com), an IP address (127.0.0.1), a network (192.168.1.0/24), or a combination of
those.
 Depending on the intensity and target of your scan, running an Nmap scan may be against
the terms of your internet service provider, and may land you in hot water. Always check
your local laws and your ISP contract before performing Nmap scans on targets other
than your own network.
Step 3:

5. Choose your Profile. Profiles are preset groupings of modifiers that change what is
scanned. The profiles allow you to quickly select different types of scans without having
to type in the modifiers on the command line. Choose the profile that best fits your needs
 Intense scan - A comprehensive scan. Contains Operating System (OS) detection,
version detection, script scanning, traceroute, and has aggressive scan timing. This is
considered an intrusive scan.
 Ping scan - This scan simply detects if the targets are online, it does not scan any ports.
 Quick scan - This is quicker than a regular scan due to aggressive timing and only
scanning select ports.
 Regular scan - This is the standard Nmap scan without any modifiers. It will return ping
and return open ports on the target.
Step 4:

6. Click Scan to start scanning. The active results of the scan will be displayed in the
Nmap Output tab. The time the scan takes will depend on the scan profile you chose, the
physical distance to the target, and the target’s network configuration.
Step 5:

7. Read your results. Once the scan is finished, you’ll see the message "Nmap done" at the
bottom of the Nmap Output tab. You can now check your results, depending on the type
of scan you performed. All of the results will be listed in the main Nmap Output tab, but
you can use the other tabs to get a better look at specific data.[2]
 Ports/Hosts - This tab will show the results of your port scan, including the services for
those ports.
 Topology - This shows the traceroute for the scan you performed. You can see how many
hops your data goes through to reach the target.
 Host Details - This shows a summary of your target learned through scans, such as the
number of ports, IP addresses, hostnames, operating systems, and more.
 Scans - This tab stores the commands of your previously-run scans. This allows you to
quickly re-scan with a specific set of parameters.
 EXPERIMENT NO: 12
AIM: Operating System Detection using Nmap

Step 1: Step 2:

Step 3:
 EXPERIMENT NO: 13
AIM: Do the following using NS2 Simulator
NS2 Simulator-Introduction.
1. What is NS2
NS2 stands for Network Simulator Version 2. It is an open-source event-driven simulator designed
specifically for research in computer communication networks.

2. Features of NS2
1. It is a discrete event simulator for networking research.
2. It provides substantial support to simulate bunch of protocols like TCP, FTP, UDP, https and DSR.
3. It simulates wired and wireless network.
4. It is primarily Unix based.
5. Uses TCL as its scripting language.
6. Otcl: Object oriented support
7. Tclcl: C++ and otcl linkage
8. Discrete event scheduler

3. Basic Architecture
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. The C++ and the OTcl are
linked together using TclCL

Basic Architecture of Network simulator 2

Simulate to Find the Number of Packets Dropped

//creating an agent object

set ping0 [new Agent/Ping]
//agent object node0
$ns attach-agent $n0 $ping0
set ping1 [new Agent/Ping]
//agent object node1
$ns attach-agent $n1 $ping1
set ping4 [new Agent/Ping]
//agent object node4
$ns attach-agent $n4 $ping4
set ping5 [new Agent/Ping]
//agent object node5
$ns attach-agent $n5 $ping5
//node2 and node3 acts as an intermediate nodes
//$ns connect $source $destination
$ns connect $ping0 $ping4
$ns connect $ping1 $ping5
//function to constantly ping th destination at an interval of 0.01s
proc sendPingPacket {} {
//global objects
global ns ping0 ping1
//time interval
set time 0.01
//sets now with the current time of simulation
set now [$ns now]
//when the current simulation time($now) + time($time = 0.01) occurs a ping is sent to
the destination
$ns at [expr $now + $time] "$ping0 send"
$ns at [expr $now + $time] "$ping1 send"

//pingPacket is sent
$ns at [expr $now + $time] "sendPingPacket"
}
//In the Tcl code, a procedure 'Agent/Ping recv {from rtt}' has to be defined which
allows the user to react to the ping result.
Agent/Ping instproc recv {from rtt} {
global seq
$self instvar node_
}
$ns at 0.01 "sendPingPacket"
$ns at 10.0 "finish"