CCN Lab Manual For 6sem PDF

VISVESVARAYA TECHNOLOGICAL
UNIVERSITY
Belgaum, Karnataka
COMPUTER NETWORKS LABORATORY

B.E., VI Semester
[As per Choice Based Credit System (CBCS) scheme15ECL68]
Prepared by:
Mohammed Khurram J
Assisst Professor
Dept. of ISE, GCE, RMGM
Electronics & Communication Engineering
0
COURSE OBJECTIVES AND OUTCOMES
Course objectives: This course will enable students to:

• Choose suitable tools to model a network and understand the protocols at various OSI
reference levels.
• Design a suitable network and simulate using a Network simulator tool.
• Simulate the networking concepts and protocols using C/C++ programming.
• Model the networks for different configurations and analyze the results.
Course outcomes: On the completion of this laboratory course, the students will be able to:
1. Design and Simulate Network elements with various protocols and standards.
2. Use the network simulator tools for learning and practice of networking algorithms.
3. Demonstrate the working of various protocols and algorithms using C programming.
Graduate Attributes (as per NBA)

• Engineering Knowledge.
• Problem Analysis.
• Design/Development of solutions.
1
Syllabus
Subject Code 15ECL68 IA Marks 20

01Hr Tutorial (Instructions) + 02 Hours Laboratory = 03
Exam Marks 80 Exam Hours 03
Laboratory Experiments
PART-A: Simulation experiments using NS2/ NS3/ OPNET/ NCTUNS/ NetSim/

QualNet/ Packet Tracer or any other equivalent tool
1. Implement a point to pint network with four nodes and duplex links between them. Analyze the
network performance by setting the queue size and varying the bandwidth.
2. Implement a four node point to point network with links n0-n2, n1-n2 and n2-n3. Apply TCP
agent between n0-n3 and UDP between n1-n3. Apply relevant applications over TCP and UDP
agents changing the parameter and determine the number of packets sent by TCP/UDP.
3. Implement Ethernet LAN using n (6-10) nodes. Compare the throughput by changing the error
rate and data rate.
4. Implement Ethernet LAN using n nodes and assign multiple traffic to the nodes and obtain
congestion window for different sources/ destinations.
5. Implement ESS with transmission nodes in Wireless LAN and obtain the performance
parameters.
6. Implementation of Link state routing algorithm
PART-B: Implement the following in C/C++
1. Write a program for a HLDC frame to perform the following.

i) Bit stuffing
ii) Character stuffing.
2. Write a program for distance vector algorithm to find suitable path for transmission.
3. Implement Dijkstra’s algorithm to compute the shortest routing path.
4. For the given data, use CRC-CCITT polynomial to obtain CRC code. Verify the program for the
cases
a. Without error
b. With error
5. Implementation of Stop and Wait Protocol and Sliding Window Protocol
6. Write a program for congestion control using leaky bucket algorithm.
2
PART-A:
Simulation experiments using NS2/ NS3/ OPNET/ NCTUNS/ NetSim/QualNet/

Packet Tracer or any other equivalent tool
1. Implement a point to pint network with four nodes and duplex links between
them. Analyze the network performance by setting the queue size and varying
the bandwidth.
2. Implement a four node point to point network with links n0-n2, n1-n2 and n2-
n3. Apply TCP agent between n0-n3 and UDP between n1-n3. Apply relevant
applications over TCP and UDP agents changing the parameter and determine
the number of packets sent by TCP/UDP.
3. Implement Ethernet LAN using n (6-10) nodes. Compare the throughput by
changing the error rate and data rate.
4. Implement Ethernet LAN using n nodes and assign multiple traffic to the
nodes and obtain congestion window for different sources/ destinations.
5. Implement ESS with transmission nodes in Wireless LAN and obtain the
performance parameters.
6. Implementation of Link state routing algorithm
3
1. Implement a point to pint network with four nodes and duplex links between
them. Analyze the network performance by setting the queue size and varying
the bandwidth.
set ns [new Simulator]

set f [open lab1.tr w]
$ns trace-all $f
set nf [open lab1.nam w]

$ns namtrace-all $nf
proc finish {} {
global f nf ns
$ns flush-trace
close $f
close $nf
exec nam lab1.nam &
exit 0
}
set n0 [$ns node]

set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
$ns duplex-link $n0 $n1 0.3Mb 10ms DropTail #vary bandwidth 0.3, 0.4, 0.5 0.7
$ns queue-limit $n0 $n1 20

set udp0 [new Agent/UDP]

$ns attach-agent $n0 $udp0
set cbr0 [new Application/Traffic/CBR]
$cbr0 attach-agent $udp0
$cbr0 set packetSize_ 500
$cbr0 set interval_ 0.005
set null0 [new Agent/Null]

$ns attach-agent $n3 $null0
$ns connect $udp0 $null0
$ns at 0.1 "$cbr0 start"

$ns at 4.5 "$cbr0 stop"
$ns at 5.0 "finish"
$ns run
4
Steps for execution:
 Open gedit editor and type program. Program name should have the extension “ .tcl ”
[root@localhost ~]# gedit lab1.tcl
 Save the program and quit.
 Run the simulation program
[root@localhost~]# ns lab1.tcl
 Here “ns” indicates network simulator. We get the topology shown in the network animator. Now press the play
button in the simulation window and the simulation will begins.
 To calculate the network performance. Execute the following command.
For calculating number of received packets
[root@localhost~]#grep ^r lab1.tr | grep “cbr” | awk „{s+=$6}END{print s}‟
For calculating total time
[root@localhost~]#grep ^r lab1.tr | grep “cbr” | awk „{s+=$2}END{print s}‟
Network performace = (Packet received/ Total Time) (bps)
 Write the value of network performance in observation sheet. Repeat the above step by changing the bandwidth
to [0.3Mb, 0.4Mb, 0.5Mb, 0.7Mb]to the following line of the program.
 $ns duplex-link $n0 $n1 0.7Mb 10ms DropTail #vary bandwidth 0.3, 0.4, 0.5 0.7
Sl. Bandwidth Network performance

No.
1. 0.3
2. 0.4
3. 0.5
4. 0.7
 Plot a graph with x- axis with bandwidth and y-axis with network performance of UDP protocol.
5
2. Implement a four node point to point network with links n0-n2, n1-n2
and n2-n3. Apply TCP agent between n0-n3 and UDP between n1-n3.
Apply relevant applications over TCP and UDP agents changing the parameter
and determine the number of packets sent by TCP/UDP.

$ns trace-all $f

$ns color 1 "Blue"

$ns color 2 "Red"
proc finish {} {
global ns f nf
$ns flush-trace
close $f
close $nf
exec nam lab2.nam &
exit 0
}
set n0 [$ns node]

set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
$ns duplex-link $n0 $n2 2Mb 10ms DropTail

$ns duplex-link $n2 $n3 2.75Mb 20ms DropTail
set tcp0 [new Agent/TCP]

$ns attach-agent $n0 $tcp0
$tcp0 set class_ 1
set ftp0 [new Application/FTP]

$ftp0 attach-agent $tcp0
set sink [new Agent/TCPSink]

$ns attach-agent $n3 $sink
$ns connect $tcp0 $sink

$udp0 set class_ 2

6

$ns at 1.0 "$ftp0 start"
$ns at 4.0 "$ftp0 stop"
$ns at 5.0 "finish"

$ns run
 To calculate the number of packets sent by TCP. Execute the following command.
[root@localhost~]#grep ^r lab2.tr | grep “tcp” -c
 To calculate the number of packets sent by UDP. Execute the following command.
[root@localhost~]#grep ^r lab2.tr | grep “cbr” –c
7
3. Implement Ethernet LAN using n (6-10) nodes. Compare the throughput by
changing the error rate and data rate.

set trf [open lab3.tr w]
$ns trace-all $trf
set naf [open lab3.nam w]
$ns namtrace-all $naf
proc finish { } {
global nf ns tf
exec nam lab3.nam &
close $naf
close $trf
exit 0
}
set n0 [$ns node]

set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
set n5 [$ns node]
set n6 [$ns node]
$n1 label "Source"

$n2 label "Error Node"
$n5 label "Destination"
$ns make-lan "$n0 $n1 $n2 $n3" 10Mb 10ms LL Queue/DropTail Mac/802_3
$ns make-lan "$n4 $n5 $n6" 10Mb 10ms LL Queue/DropTail Mac/802_3

set cbr0 [ new Application/Traffic/CBR]

$udp0 set class_ 1
set err [new ErrorModel]

$ns lossmodel $err $n2 $n6
$err set rate_ 0.7 #vary error rate 0.1, 0.4, 0.5 and 0.7
$ns at 6.0 "finish"

$ns run
8
 To calculate the throughput. Execute the following command.
[root@localhost~]#grep ^r lab3.tr | grep “2 6” | awk „{s+=$6}END{print s}‟
[root@localhost~]#grep ^r lab3.tr | grep “2 6” | awk „{s+=$2}END{print s}‟
Throughput = (Packet received/ Total Time) (bps)
 Write the value of throughput in observation sheet. Repeat the above step by changing the error rate to the
following line of the program.
$err set rate_ 0.7 #vary error rate 0.1, 0.4, 0.5 and 0.7
Sl. Error rate Throughput

No.
1. 0.1
2. 0.4
3. 0.5
4. 0.7
 Plot a graph with x- axis with Error rate and y-axis with Throughput.
9
4. Implement Ethernet LAN using n nodes and assign multiple traffic to the
nodes and obtain congestion window for different sources/ destinations.

$ns trace-all $f

proc finish {} {
global ns f nf outFile1 outFile2
$ns flush-trace
close $f
close $nf
exec nam lab4.nam &
exec xgraph Congestion1.xg Congestion2.xg -geometry 400x400 &
exit 0
}
set n0 [$ns node]

set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
set n5 [$ns node]
$n0 label "Src1"

$n4 label "Dst1"
$n1 label "Src2"
$n5 label "Dst2"
$ns make-lan "$n0 $n1 $n2 $n3 $n4 $n5 " 10Mb 30ms LL Queue/DropTail Mac/802_3

set sink1 [new Agent/TCPSink]
$ns attach-agent $n4 $sink1
$ftp1 set maxPkts_ 1000
$ns connect $tcp1 $sink1
set tcp2 [new Agent/TCP/Reno]

$ftp2 set maxPkts_ 1000
set outFile1 [open Congestion1.xg w]

set outFile2 [open Congestion2.xg w]
10
proc findWindowSize {tcpSource outFile} {
global ns
set now [$ns now]
set cWindSize [$tcpSource set cwnd_]
puts $outFile "$now $cWindSize"
$ns at [expr $now + 0.1] "findWindowSize $tcpSource $outFile"
}
$ns at 0.0 "findWindowSize $tcp1 $outFile1"

$ns at 0.1 "findWindowSize $tcp2 $outFile2"
$ns at 50.0 "finish"
$ns run
 The xgraph automatically calculates and plot the two graph of Congestion window with TCP1 and TCP2.
11
5. Implement ESS with transmission nodes in Wireless LAN and obtain the
performance parameters.

set tf [open lab5.tr w]
$ns trace-all $tf
set topo [new Topography]
$topo load_flatgrid 1300 1300
$ns namtrace-all-wireless $nf 1300 1300
$ns node-config -adhocRouting DSDV \

-llType LL \
-macType Mac/802_11 \
-ifqType Queue/DropTail/PriQueue\
-channelType Channel/WirelessChannel \
-propType Propagation/TwoRayGround \
-antType Antenna/OmniAntenna \
-ifqLen 50 \
-phyType Phy/WirelessPhy \
-topoInstance $topo \
-agentTrace ON \
-routerTrace ON
create-god 3
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
$n0 label "ESS"
$n1 label "mob1"
$n2 label "mob2"
$n0 set X_ 10
$n0 set Y_ 600
$n0 set Z_ 0
$n1 set X_ 80
$n1 set Y_ 600
$n1 set Z_ 0
$n2 set X_ 1200
$n2 set Y_ 600
$n2 set Z_ 0
$ns at 0.1 "$n0 setdest 10 600 15"
$ns at 0.1 "$n1 setdest 80 600 25"
$ns at 0.1 "$n2 setdest 1200 600 25"


12
$ns at 2 "$ftp0 start"

$ns at 15 "$ftp1 start"
$ns at 3 "$n1 setdest 1000 600 250"
$ns at 3 "$n2 setdest 80 600 250"
proc finish { } {
global ns nf tf
$ns flush-trace
exec nam lab5.nam &
close $tf
exit 0
}
$ns at 20 "finish"
$ns run
 To calculate the throughput. Execute the following command.
[root@localhost~]#grep ^r lab5.tr | grep “AGT” | grep “tcp” | awk „{s+=$8}END{print s}‟
[root@localhost~]#grep ^r lab5.tr | grep “AGT” | grep “tcp” | awk „{s+=$2}END{print s}‟
Throughput = (Packet received/ Total Time) (bps)
13
6. Implementation of Link state routing algorithm.
$ns rtproto LS

proc finish {} {
global ns nf
$ns flush-trace
close $nf
exec nam lab6.nam &
exit 0
}
for {set i 0} {$i < 7} {incr i} {

set n($i) [$ns node]
}
for {set i 0} {$i < 7} {incr i} {

$ns duplex-link $n($i) $n([expr ($i+1)%7]) 1Mb 10ms DropTail
}

$ns attach-agent $n(0) $udp0


$ns attach-agent $n(3) $null0

$ns rtmodel-at 1.0 down $n(1) $n(2)
$ns rtmodel-at 2.0 up $n(1) $n(2)
$ns at 5.0 "finish"
$ns run
14
 Explain link state routing algorithm using animation. How link state break and rerouting take place.
15
PART-B:
Implement the following in C/C++

i) Bit stuffing
2. Write a program for distance vector algorithm to find suitable path for
transmission.
4. For the given data, use CRC-CCITT polynomial to obtain CRC code. Verify
the program for the cases
a. Without error
b. With error
6. Write a program for congestion control using leaky bucket algorithm.
16
i) Bit stuffing
Bit stuffing is a process of inserting an extra bit as 0, once the frame sequence encountered 5 consecutive 1's.
Program
#include<stdio.h>
int main()
{
int a[15];
int i,j,k,n,c=0,pos=0;
printf("\n Enter the number of bits");
scanf("%d",&n);
printf("\n Enter the bits");
for(i=0;i<n;i++)
scanf("%d",&a[i]);
for(i=0;i<n;i++)
{
if(a[i]==1)
{
c++;
if(c==5)
{
pos=i+1;
c=0;
for(j=n;j>=pos;j--)
{
k=j+1;
a[k]=a[j];
}
a[pos]=0;
n=n+1;
}
}
else
c=0;
}
printf("\n DATA AFTER STUFFING \n");
for(i=0;i<n;i++) {
printf("%d",a[i]);
}
17
Execution:
[root@localhost code]# gcc 1a.c

[root@localhost code]# ./a.out
Enter the number of bits

12
Enter the bits

1
0
1
1
1
1
1
1
1
0
1
1
DATA AFTER STUFFING

1011111011011
18
Character Stuffing is process in which DLESTX and DLEETX are used to denote start and end of character data with
some constraints imposed on repetition of characters.
Program:
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
int main()
{
char c[50],d[50],t[50];
int i,m,j;
printf("enter the number of characters\n");
scanf("%d",&m);
printf("\n enter the characters\n");
for(i=0;i<m+1;i++)
{
scanf("%c",&c[i]);
}
printf("\n original data\n");
for(i=0;i<m+1;i++)
printf("%c",c[i]);
d[0]='d';
d[1]='l';
d[2]='e';
d[3]='s';
d[4]='t';
d[5]='x';
for(i=0,j=6;i<m+1;i++,j++)
{
if((c[i]=='d'&&c[i+1]=='l'&& c[i+2]=='e'))
{
d[j]='d';
j++;
d[j]='l';
j++;
d[j]='e';
j++;
m=m+3;
}
d[j]=c[i];
}
m=m+6;
m++;
d[m]='d';
m++;
d[m]='l';
m++;
d[m]='e';
m++;
d[m]='e';
19
m++;
d[m]='t';
m++;
d[m]='x';
m++;
printf("\n\n transmitted data: \n");
for(i=0;i<m;i++)
{
printf("%c",d[i]);
}
for(i=6,j=0;i <m-6;i++,j++)
{
if(d[i]=='d'&&d[i+1]=='l'&&d[i+2]=='e'&&d[i+3]=='d'&&d[i+4]=='l'&&d[i+5]=='e')
i=i+3;
t[j]=d[i];
}
printf("\n\nreceived data:");
for(i=0;i<j;i++)
{printf("%c",t[i]);
}
}
Execution:
[root@localhost code]# gcc 1b.c
enter the number of characters
9
enter the characters

abcdabcde
original data
abcdabcde
transmitted data:
dlestx
abcdabcdedleetx
received data:
abcdabcde
20
2. Write a program for distance vector algorithm to find suitable path for transmission.
Distance vector routing algorithms operate by having each router maintain a table (i.e., vector) giving the best
known distance to each destination and which line to get there. These tables are updated by exchanging
information with the neighbors.
Program:
#include<stdio.h>
struct node
{
unsigned dist[20];
unsigned from[20];
}rt[10];
int main()
{
int dmat[20][20];
int n,i,j,k,count=0;
printf("\nEnter the number of nodes : ");
scanf("%d",&n);
printf("\nEnter the cost matrix (999 for no link):\n");
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{
scanf("%d",&dmat[i][j]);
dmat[i][i]=0;
rt[i].dist[j]=dmat[i][j];
rt[i].from[j]=j;
}
do
{
count=0;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
for(k=0;k<n;k++)
if(rt[i].dist[j]>dmat[i][k]+rt[k].dist[j])
{
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<n;i++)
{
printf("\n\nState value for router %d is \n",i+1);
for(j=0;j<n;j++)
{
printf("\t\nnode %d via %d Distance%d",j+1,rt[i].from[j]+1,rt[i].dist[j]);
}
}
printf("\n\n");
}
21
Execution:
[root@localhost code]# gcc 2.c

Enter the number of nodes : 4
Enter the cost matrix (999 for no link):
0 2 999 1
2 0 5 2
999 5 0 6
1 2 6 0
State value for router 1 is
node 1 via 1 Distance0




22
Dijkstra algorithm is also called single source shortest path algorithm. The algorithm maintains a list visited[ ]
of vertices, whose shortest distance from the source is calculated.
Program:
#include<stdio.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;
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];
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;
for(i=0;i<n;i++)
if(distance[i]<mindistance&&!visited[i])
{
mindistance=distance[i];
nextnode=i;
}
visited[nextnode]=1;
23
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++;
}
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);
}
}
Execution:

Enter no. of vertices:5
Enter the adjacency matrix:

0 10 0 30 100
10 0 50 0 0
0 50 0 20 10
30 0 20 0 60
100 0 10 60 0
Enter the starting node:0
Distance of node1=10
Path=1<-0
Path=2<-3<-0
Path=3<-0
Path=4<-2<-3<-0
24
4. For the given data, use CRC-CCITT polynomial to obtain CRC code. Verify the program for
the cases
a. Without error
b. With error
Cylic Redundency Check is error checking technique it does error checking via polynomial division.
Progtam:
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define N strlen(g)
char t[128],cs[128],g[]="1000100000010001";
int a,e,c;
void xor(){
for(c=1;c<N;c++)
cs[c]=((cs[c]==g[c])?'0':'1');
}
void crc(){
for(e=0;e<N;e++)
cs[e]=t[e];
do{
if(cs[0]=='1')
xor();
for(c=0;c<N-1;c++)
cs[c]=cs[c+1];
cs[c]=t[e++];
}while(e<=a+N-1);
}
int main(){
printf("\nEnter poly:");
scanf("%s",t);
printf("\nGenerating Polynomial is: %s",g);
a=strlen(t);
for(e=a;e<a+N-1;e++)
t[e]='0';
printf("\nModified t[u] is: %s",t);
crc();
printf("\nChecksum is: %s",cs);
for(e=a;e<a+N-1;e++)
t[e]=cs[e-a];
printf("\nFinal Codeword is: %s",t);
printf("\nTest Error detection 0 (Yes) 1 (No) ? : ");
scanf("%d",&e);
if(e==0){
printf("Enter postion where error is to be inserted:");
scanf("%d",&e);
t[e]=(t[e]=='0')?'1':'0';
printf("Erroneous Data: %s\n",t);
25
}
crc();
for(e=0;(e<N-1)&&(cs[e]!='1');e++);
if(e<N-1)
printf("Error Detected");
else printf("No Error Detected");
return 0;
}
Execution:
Enter poly : 1011101

Generating Polynomial is : 10001000000100001
Modified t[u] is : 10111010000000000000000
Checksum is : 1000101101011000
Final Codeword is : 10111011000101101011000
Test Error detection 0(yes) 1(no) ? : 0
Enter position where you want to insert error : 3
Errorneous data : 10101011000101101011000
Error detected.
Enter poly : 1011101

Generating Polynomial is : 10001000000100001
Modified t[u] is : 10111010000000000000000
Checksum is : 1000101101011000
Final Codeword is : 10111011000101101011000
Test Error detection 0(yes) 1(no) ? : 1
0No Error Detected.
26
5a. Stop and Wait protocol
Program:
#include<stdio.h>
#define w 1
int main()
{
int i,f,frames[50];
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 stop and wait 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);
printf("if error occur negative acknowledge is detected same frame is resend
back\n");
for(i=1;i<=f;i++)
{
if((random()%2)==1)
{
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]);
}
else
{
sleep(3);
printf("negative acknowledge resend %d frame\n",i);
i=i-1;
sleep(1);
}
}
return 0;
}
27
Execution:

Enter number of frames to transmit: 6
Enter 6 frames: 1
4
5
7
8
9
With stop and wait protocol the frames will be sent in the following manner
(assuming no corruption of frames)
After sending 1 frames at each stage sender waits for acknowledgement sent by the
receiver
if error occur negative acknowledge is detected same frame is resend back

1
Acknowledgement of above frames sent is received by sender
negative acknowledge resend 2 frame

4
5
7
8

9
28
5b. Sliding window protocol program
Program
#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;
}
Execution:

Enter window size: 3
Enter number of frames to transmit: 5
Enter 5 frames: 12 20 87 65 4
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 20 87
65 4
29
6. Write a program for congestion control using leaky bucket algorithm
In Leaky bucket, each host is connected to the network by an interface containing a leaky bucket, that is, a
finite internal queue. If a packet arrives at the queue when it is full, the packet is discarded.
Program:
#include<stdio.h>
#include<stdlib.h>
int bucket_size;
void bucket_input ( int pkt_sz, int op_rt )
{
if( pkt_sz > bucket_size )
printf(" \n\nBucket overflow\n ");
else
{
sleep(1);
while ( pkt_sz > op_rt )
{
printf(" \n %d bytes outputted ", op_rt );
pkt_sz-= op_rt;
sleep(1);
}
if ( pkt_sz > 0 )
printf(" \nLast %d bytes sent\n", pkt_sz );
printf(" \n Bucket output successful \n" );
}
}
int main()
{
int i, op_rate, packet_size;
printf("\n Enter Bucket Size: " );
scanf( "%d", &bucket_size );
printf(" \n Enter output rate: " );
scanf( "%d", &op_rate );
for( i=1; i<=5; i++ )
{
sleep(1);
packet_size = random()%1000;
printf(" \n Packet number [%d] \t Packet size = %d ", i, packet_size );
bucket_input( packet_size, op_rate );
}
return 0;
}
30
Execution:
Enter Bucket Size: 500
Enter output rate: 80
Packet number [1] Packet size = 383

80 bytes outputted
80 bytes outputted
80 bytes outputted
80 bytes outputted
Last 63 bytes sent
Bucket output successful
Bucket overflow
Bucket overflow
Bucket overflow
Bucket overflow
31

CCN Lab Manual For 6sem PDF

Uploaded by

Copyright:

Available Formats

CCN Lab Manual For 6sem PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CCN Lab Manual For 6sem PDF

Uploaded by

Copyright:

Available Formats

VISVESVARAYA TECHNOLOGICAL

COMPUTER NETWORKS LABORATORY

Electronics & Communication Engineering

Course objectives: This course will enable students to:

Graduate Attributes (as per NBA)

Subject Code 15ECL68 IA Marks 20

PART-A: Simulation experiments using NS2/ NS3/ OPNET/ NCTUNS/ NetSim/

PART-B: Implement the following in C/C++

1. Write a program for a HLDC frame to perform the following.

Simulation experiments using NS2/ NS3/ OPNET/ NCTUNS/ NetSim/QualNet/

set ns [new Simulator]

set nf [open lab1.nam w]

set n0 [$ns node]

$ns queue-limit $n0 $n1 20

set udp0 [new Agent/UDP]

set null0 [new Agent/Null]

$ns connect $udp0 $null0

$ns at 0.1 "$cbr0 start"

Network performace = (Packet received/ Total Time) (bps)

Sl. Bandwidth Network performance

set ns [new Simulator]

set f [open lab2.tr w]

set nf [open lab2.nam w]

$ns color 1 "Blue"

set n0 [$ns node]

$ns duplex-link $n0 $n2 2Mb 10ms DropTail

$ns queue-limit $n2 $n3 50

set tcp0 [new Agent/TCP]

set ftp0 [new Application/FTP]

set sink [new Agent/TCPSink]

set udp0 [new Agent/UDP]

set cbr0 [new Application/Traffic/CBR]

$ns at 0.1 "$cbr0 start"

$ns at 5.0 "finish"

Steps for execution:

[root@localhost~]#grep ^r lab2.tr | grep “tcp” -c

[root@localhost~]#grep ^r lab2.tr | grep “cbr” –c

set ns [new Simulator]

set n0 [$ns node]

$n1 label "Source"

$ns duplex-link $n2 $n6 30Mb 100ms DropTail

set udp0 [new Agent/UDP]

$cbr0 set packetSize_ 100

set err [new ErrorModel]

$ns at 6.0 "finish"

Throughput = (Packet received/ Total Time) (bps)

Sl. Error rate Throughput

set ns [new Simulator]

set nf [open lab4.nam w]

set n0 [$ns node]

$n0 label "Src1"

set tcp1 [new Agent/TCP]

set tcp2 [new Agent/TCP/Reno]

set outFile1 [open Congestion1.xg w]

$ns at 0.0 "findWindowSize $tcp1 $outFile1"

Steps for execution:

set ns [new Simulator]

$ns node-config -adhocRouting DSDV \

set tcp0 [new Agent/TCP]