CCN Lab Manual Ecl77

DEPARTMENT
OF
ELECTRONICS & COMMUNICATION ENGINEERING
COMPUTER COMMUNICATION LAB MANUAL
VII Semester (ECL77)
Autonomous Course
Dr. ANITHA V
Prof KRUTTHIKA H K
Prof. MAHESH KUMAR
Mr. NUTHESH KUMAR A
Name of the Student :
Semester /Section :
USN :
Batch :
DAYANANDA SAGAR COLLEGE OF ENGINEERING

SHAVIGE MALLESHWARA HILLS, KUMARSWAMY LAYOUT, BANGALORE – 78
AN AUTONOMOUS INSTITUTE AFFILIATED TO VTU, APPROVED BY AICTE & UGC
ACCREDITED BY NBA & NAAC WITH 'A' GRADE
DEPARTMENT ELECTRONICS & COMMUNICATION
ENGINEERING
Name of the Laboratory : COMPUTER COMMUNICATION LAB
Semester/Year : VII / 2018-19 (Autonomous)
No. of Students/Batch : 20
No. of Equipment‘s : 20
Major Equipment‘s : Power Supply

CRO‘s
Sine/Square/Wave Generator
Function Generator
IC Tester
Area in square meters : 109 Sq. Mtrs.
Location : Level – 2
Total Cost of Lab : Rs. 37, 77,535/-
Lab In charge/s:
Instructors :
HOD : Dr. T.C. Manjunath, Ph.D. (IIT Bombay)

ABOUT THE COLLEGE & THE DEPARTMENT
The Dayananda Sagar College of Engineering was established in 1979, was founded by Sri R.
Dayananda Sagar and is run by the Mahatma Gandhi Vidya Peetha Trust (MGVP). The college
offers undergraduate, post-graduates and doctoral programmes under Visvesvaraya Technological
University & is currently autonomous institution. MGVP Trust is an educational trust and was
promoted by Late. Shri. R. Dayananda Sagar in 1960. The Trust manages 28 educational
institutions in the name of ―Dayananda Sagar Institutions‖ (DSI) and multi – Specialty hospitals in
the name of Sagar Hospitals - Bangalore, India. Dayananda Sagar College of Engineering is
approved by All India Council for Technical Education (AICTE), Govt. of India and affiliated to
Visvesvaraya Technological University. It has widest choice of engineering branches having 16
Under Graduate courses & 17 Post Graduate courses. In addition, it has 21 Research Centers in
different branches of Engineering catering to research scholars for obtaining Ph.D under VTU.
Various courses are accredited by NBA & the college has a NAAC with ISO certification. One of
the vibrant & oldest dept is the ECE dept. & is the biggest in the DSI group with 70 staffs & 1200+
students with 10 Ph.D.‘s & 30+ staffs pursuing their research in various universities. At present,
the department runs a UG course (BE) with an intake of 240 & 2 PG courses (M.Tech.), viz., VLSI
Design Embedded Systems & Digital Electronics & Communications with an intake of 18 students
each. The department has got an excellent infrastructure of 10 sophisticated labs & dozen class
room, R & D centre, etc…

VISION OF THE DEPARTMENT
To achieve continuous improvement in quality technical education for global
competence with focus on industry, societal needs, research and professional ethics.
MISSION OF THE DEPARTMENT

 Offering quality education in Electronics and Communication Engineering with
effective teaching and learning process in multidisciplinary environment.
 Training the students to take-up the projects in emerging technologies and work
with the team spirit.
 To imbibe the professional ethics, development of skills and research culture for
better placement opportunities.
PROGRAM EDUCATIONAL OBJECTIVES [PEOs]
After 4 years, the students will be,
PEO-1: Ready to apply the state-of-art technology in industry and meeting the
societal needs with knowledge of Electronics and Communication Engineering due to
strong academic culture.
PEO-2: Competent in technical and soft skills to be employed with capability of

working in multidisciplinary domains.
PEO-3: Professionals, capable of pursuing higher studies in technical, research or

management programs.
PROGRAM SPECIFIC OUTCOMES [PSOs]

Students will be able to,
PSO-1: Design, develop and integrate electronics circuits and systems using current
practices and standards.
PSO-2: Apply knowledge of hardware and software in designing embedded and

communication systems.
INSTRUCTIONS TO THE CANDIDATES
1. Students should come with thorough preparation for the experiment to be
conducted.
2. Students will not be permitted to attend the laboratory unless they bring the
practical record fully completed in all respects pertaining to the experiment
conducted in the previous class.
3. Practical record should be neatly maintained.
4. They should obtain the signature of the staff-in-charge in the observation book
after completing each experiment.
5. Theory regarding each experiment should be written in the practical record before
procedure in your own words.
6. Ask lab technician for assistance if you have any problem.
7. Save your class work, assignments in system.
8. Do not download or install software without the assistance of the laboratory
technician.
9. Do not alter the configuration of the system.
10. Turnoff the systems after use.
LAB MANUAL FOR
COMPUTER COMMUNICATION NETWORKS LABORATORY
Course code: ECL77 Credits : 2

L:P:T:S:0:2:0:0 CIE Marks : 50
Exam Hours : 3 SEE Marks : 50
Total Hours : 26 Total Marks : 100
COURSE OBJECTIVES:
1. To build the knowledge of networking protocols and interconnections.

2. To impart programming skill sets of C/C++ to implement the functionalities and responsibilities of Data
link and networking layer
3. To impart the skill set for students to demonstrate the error control techniques in networking
COURSE OUTCOMES
CO 1 Apply the concepts of HDLC protocol for data communication

CO 2 Design and analyze different routing algorithms
CO 3 Evaluate the quality of service of transmission control protocol
CO 4 Apply the difference between wired and wireless network
CO 5 Evaluate the performance parameters of wired and wireless networks
CO 6 Create different wired and wireless networks for data communication
Mapping of Course Outcomes to Program Outcomes:
PO1 PO2 PO3 PO4 PO5 PO6 PO7 PO8 PO9 PO10 PO11 PO12
CO1 3 3 3 2 1 - - - 2 2 - 1
CO2 3 3 2 2 2 - - - 2 2 - 1
CO3 3 3 2 1 2 - - - 2 2 - 1
CO4 3 2 2 2 2 - - - 2 2 - 1
CO5 3 2 2 1 2 - - - 2 2 - 1
CO6 3 3 2 2 3 - - 1 2 2 - 1
SL COURSE CONTENTS COS
NO
PART-A
IMPLEMENT THE FOLLOWING IN C/C++
1 1. Write a program for a HLDC frame to perform the following for the given CO1,CO2
Data
i) Bit stuffing
ii) Character stuffing
2 For the given data, use CRC-CCITT polynomial to obtain CRC code. Verify CO1,CO2
the program for the cases without error & with error.
3 Implementation of Sliding Window Protocol. CO4
4 Implement Dijkstra‘s algorithm to compute the shortest routing path. CO2
5 Write a program for congestion control using leaky bucket algorithm C03, CO4, CO5
6 Implement Encryption and Decryption of a given message C02, CO3, CO5

PART-B
SIMULATION EXPERIMENTS USING NS2 / NS3 / NCTUNS
7 Implement a point to point network with four nodes and duplex links between CO2, CO4,CO5
them. Analyze the network performance by setting the queue size and varying
the bandwidth.
8 Implement a four node point to point network with links n0-n2, n1-n2 and n2- CO2, CO4,CO5,
n3. Apply TCP agent between n0-n3 and UDP between n1-n3. Apply relevant CO6
applications over TCP and UDP agents changing the parameter and determine
the number of packets sent by TCP/UDP.
9 Implement Ethernet LAN using n (6-10) nodes. Compare the throughput by CO2, CO4,CO5
changing the error rate and data rate.
10 Implement Ethernet LAN using n nodes and assign multiple traffic to the CO2, CO4,CO5
nodes and obtain congestion window for different sources/ destinations.
11 Implement ESS with transmission nodes in Wireless LAN and obtain the CO2, CO4,CO5,
performance parameters. CO6
12 Implementation of any routing algorithm CO2, CO4,CO6
EXTRA PROGRAMS:
1. Implementation of spanning tree algorithm

2. Implementation of Stop and wait protocol
3. Implement a program to communicate between mobile nodes and suspicious nodes using NS2.
4. Implement UDP wireless communication using NS2
5. Implement TCP communication using NS2
HARDWARE AND SOFTWARE REQUIREMENTS:
Hardware Requirements:
 Processor : Pentium 3 or higher
 RAM : 512MB or more
 Hard Disk : 16GB or more ( there should be enough space to hold both Linux and Windows)
Software Requirements:
 Operating System : Windows, Linux
 Compiler: Turbo C\C++ or Borland C\C++
 Simulation Software: NS2/ NCTUns
TEXT BOOKS:
1. Introduction to Network Simulator NS2, Issariyakul, Teerawat, Hossain, Ekram, , Springer
US, 2012.
ASSESSMENT PATTERN:
CIE –Continuous Internal Evaluation Lab (50 Marks)

SEE –Semester End Examination Lab (50 Marks)
Performance Internal
Bloom‘s Category
(Day To Day) Test
Marks (Out of 50) 25 25
Remember
Understand
Apply 05 05
Analyze 10 10
Evaluate 05 05
Create 05 05
Bloom‘s Marks
Category Theory(50)
Remember
Understand
Apply 15
Analyze 15
Evaluate 10
Create 10
PART -A
PROGRAM 1a):
WRITE A PROGRAM FOR A HLDC FRAME TO PERFORM THE BIT STUFFING & DE-
STUFFING FOR THE GIVEN DATA
1. BIT STUFFING
2. BIT STUFFING & DE-STUFFING USING HDLC
Framing involves identifying the beginning and end of a block of information within a
digital stream. In asynchronous data transmission, since transmissions do not occur at regular
intervals, the receiver resynchronizes at the start of each eight bit character by the use of a start bit
that precedes and a stop bit that ends each character .In synchronous data transmission bits are
transmitted at regular intervals and the receiver has the circuitry that recovers and tracks the
frequency and bit transitions of the received data Framing may involve delineating the boundaries
between frames that are of fixed length or it may involve delineating between frames that are of
variable length. Variable length frames need more information to delineate. The methods available
include:
Special characters to identify beginning and end of frame
Special bit patterns-―flags‖ to identify the beginning and end of frames and character counts
BIT STUFFING:
Flag based synchronization was developed to transfer an arbitrary number of bits within a
frame. The figure below shows the structure of an HDLC frame. The beginning and end of an
HDLC frame is indicated by the presence of an eight bit flag. The flag in HDLC consists of the byte
01111110 that is HEX 7E . Bit stuffing prevents the occurrence of the flag inside the frame. The
transmitter examines the contents of the frame and inserts an extra 0 after each instance of five
consecutive 1s. The transmitter then attaches the flag at the beginning and end of the resulting bit
stuffed frame. The receiver looks for five consecutive 1s in the received sequence. Five 1s followed
by a 0 indicate that the 0 is a stuffing bit and so the bit is removed. Five consecutive 1s followed by
10 indicate a flag. Five 1 s followed by 11 indicate an error. The example below show bit stuffing in
HDLC
HDLC FRAME:
The high level data link control protocol is a bit oriented protocol which uses bit stuffing for data
transparency. HDLC frame is as shown.
8 8 8 >0 16 8
0111 1110 Address Control Data Checksum 0111 1110
The Control field is used for sequence numbers and acknowledgements and other purposes.
The Data field may contain arbitrary information. The Checksum field is a minor variation of the
CRC code using CRC-CCITT as the generator. Frames are delimited by 0111 1110 and this
sequence is not allowed in the data field.
ALGORITHM FOR BIT STUFFING
1. Input data sequence
2. Add start of frame to output sequence
3. for every bit in input
a. Append bit to output sequence
b. Is a bit 1?
Yes:
Increment count
If count is 5, append 0 to output sequence and reset count
No:
Set count to 0
4. Add stop of frame bits to output sequence.
ALGORITHM FOR BIT DE-STUFFING

2. Remove start of frame to output sequence
3. for every bit in input
a. Append bit to output sequence
b. Is a bit 1?
Yes:
Increment count
If count is 5, remove 0 from input sequence and reset count
No:
Set count to 0
4. Remove stop of frame bits to output sequence.
/* Program to simulate bit stuffing & Destuffing where the flag byte is 01111110 */
# include <stdio.h>
# include <conio.h>
#include<string.h>
void main()
{
char ch, array[50]={"01111110"},recd_array[50];

int counter=0,i=8,j,k;
clrscr();
printf("Enter the original data stream for bit stuffing : \n");

while((ch=getche())!='\r')
{
if (ch=='1')
++counter;
else
counter=0;
array[i++]=ch;
if (counter==5) /* If 5 ones are encountered append a zero */
{
array[i++]='0';
counter=0;
}
}
array[i]=‘\0‘;
strcat(array,"01111110");
array[i+8]=‘\0‘;
printf("\nThe stuffed data stream is : %s \n",array);
/* Destuffing */
counter=0;
printf("\nThe destuffed data stream is : \n");
for (j=8,k=0;j<(strlen(array)-8);++j)
{
if (array[j]=='1')
++counter;
else
counter=0;
recd_array[k++]=array[j];
if (counter==5) /* If five ones appear, delete the following zero */

{
++j;
counter=0;
}
}
recd_array[k]=‘\0‘;
printf(― the destuffed data stream is %s‖,recd_array);

getch();
}
OR
#include<stdio.h>
#include<conio.h>
void main()
{
int num[100],n;
int i,j,k,cnt=0,flag[8]={0,1,1,1,1,1,1,0},count;
//clrscr();
printf("Enter the size=\n");

scanf("%d",&n);
printf("Enter the sequence=\n");
for(i=0;i<n;i++)
scanf("%d",&num[i]);
for(j=0;j<n;j++)
if(num[j]==flag[0]&&num[j+1]==flag[1]&&num[j+2]==flag[2]&&num[j+3]==flag[3]&&nu
m[j+4]==flag[4]&&num[j+5]==flag[5]&&num[j+6]==flag[6]&&num[j+7]==flag[7])
count=1;
if(count==1)
{
printf("\nAfter stuffing\n");
i=0;
while(i<n)
{
if(num[i]==1)
{
i++;
cnt++;
if(cnt==5)
{
for(k=n+1;k>i;k--)
num[k]=num[k-1];
num[i]=0;
}
}
else
{
i++;
cnt=0;
}
}
for(j=0;j<8;j++)
printf(" %d ",flag[j]);
for(i=0;i<n+1;i++)
printf(" %d ",num[i]);
for(j=0;j<8;j++)
printf(" %d ",flag[j]);
printf("\nAfter destuffing\n");
i=0;
while(i<n)
{
if(num[i]==1)
{
i++;
cnt++;
if(cnt==5)
{
for(k=i;k<n+1;k++)
num[k]=num[k+1];
}
}
else
{
i++;
cnt=0;
}
}
for(i=0;i<n;i++)
}
else
{
printf("\noriginal data=\n");
for(i=0;i<n;i++)
}
getch();
}
OUTPUT:
Enter the original data stream for bit stuffing:

011011111111110010
The stuffed data stream is:
011111100110111110111110001001111110
The destuffed data stream is:
011011111111110010
PROGRAM 1 b) :
ILLUMINATE CHARACTER (BYTE) STUFFING & DE-STUFFING USING HDLC
FRAME FOR THE GIVEN DATA.
Character based frame synchronization methods are used when the information in a frame
consists of an integer number of characters. For example, asynchronous transmission systems are
used extensively to transmit sequences of printable characters using 8 bit ASCII code . To delineate
a frame of characters, special eight bit codes that do not correspond to printable characters are used
as control characters. In ASCII code all characters with hexadecimal values less than 20 correspond
to non-printable characters.(refer the ASCII table shown in figure.)
In particular STX (start of text) control character has hex value 02 and indicates the
beginning of a frame and an ETX (end of text) character has HEX value 03 and denotes the end of a
frame. This method works if the frame contains only printable characters. If a frame carries
computer data, then it is possible that an ETX character will appear inside the frame and cause the
receiver to prematurely truncate the frame. This method is not transparent because the frame cannot
carry all possible bit sequences. The use of byte stuffing enables transparent operation. Byte
stuffing operates as follows. A special DLE (data link escape) control with hex value 10 is
introduced. The two character sequence DLESTX is used to indicate the beginning of a frame and
DLE ETX denotes the end of a frame. The receiver looks for these character pairs to identify the
beginning and end of frames. In order to deal with the occurrence of DLE STX or DLE ETX in the
data contained in the frame, an extra DLE is inserted or stuffed before the occurrence of a DLE
inside the frame.
Consequently every legitimate DLE in the data is replaced by two DLEs. The only incidence
of an individual DLE occurs when DLE precedes the STX or the ETX that identify the beginning
and end of the frame.
Decimal Hexadecimal ASCII DESCRIPTION
0 00 NUL CTRL+1
1 01 SOH CTRL+A
2 02 STX CTRL+B
3 03 ETX CTRL+C
4 04 EOT CTRL+D
5 05 ENQ CTRL+E
6 06 ACK CTRL+F
7 07 BEL CTRL+G
8 08 BS CTRL+H, BACKSPACE
9 09 HT CTRL+I, TAB
10 0A LF CTRL+J, ENTER
11 0B VT CTRL+K
12 0C FF CTRL+L
13 0D CR CTRL+M, RETURN
14 0E SO CTRL+N
15 0F SI CTRL+O
16 10 DLE CTRL+P
ALGORITHM FOR CHARACTER STUFFING/DESTUFFING

2. Add start of frame to output sequence (DLE STX) /remove start of frame chars from input
sequence.
3. for every character in input
a. Append character to output sequence
b. Is character DLE?
Yes: Add DLE to output sequence/remove next DLE from input sequence.
4. Add stop of frame chars to output sequence/remove stop of frame chars from input sequence.
/*Program to demonstrate character stuffing */

# include <stdio.h>
# include <conio.h>
# define DLE 16
# define STX 2
# define ETX 3
void main()
{
char ch;
char array[50]={DLE,STX};
char destuff[50];
int i=2,j,k;
clrscr();
printf("Enter the data stream (Ctrl+B->STX, Ctrl+C->ETX, Ctrl+P->DLE) : \n");
while ((ch=getch())!='\r')
{
if (ch==DLE)
{
array[i++]=DLE;
printf("DLE ");
}
else if (ch==STX) printf("STX ");
else if (ch==ETX) printf("ETX ");
else printf("%c ",ch);
array[i++]=ch;
}
array[i++]=DLE;
array[i++]=ETX;
printf("\nThe stuffed stream is \n");
for (j=0;j<i;++j)
{
if (array[j]==DLE) printf("DLE ");
else if (array[j]==STX) printf("STX ");
else if (array[j]==ETX) printf("ETX ");
else printf("%c ",array[j]);
}
k=0;
printf("\nThe destuffed data stream is : \n");
for (j=2;j<i-2;++j)
{
destuff[k++]=array[j];
if (array[j]==DLE)
{ printf("DLE ");
++j;
}
else if (array[j]==STX)
printf("STX ");
else if (array[j]==ETX)
printf("ETX ");
else
printf("%c ",array[j]);
}
getch();
}
OUTPUT:
Enter the data stream (Ctrl+B->STX, Ctrl+C->ETX, Ctrl+P->DLE) :
A DLE B
The stuffed stream is
DLE STX A DLE DLE B DLE ETX
The destuffed data stream is :
A DLE B
Enter the data stream (Ctrl+B->STX, Ctrl+C->ETX, Ctrl+P->DLE) :

*ABCDLEXYZ
The stuffed stream is
DLE STX ABCDLEXYZ DLEETX
The destuffed data stream is :
ABCDEXYZ
*Note: If you type DLE then stuffing will not be done. DLE will be stuffed only when you
press Ctrl+P.
PROGRAM 2:
FOR THE GIVEN DATA, USE CRC-CCITT POLYNOMIAL TO OBTAIN CRC CODE.
VERIFY THE PROGRAM FOR THE CASES
1. WITHOUT ERROR
2. WITH ERROR
The polynomial code (also known as a cyclic redundancy code or CRC code) is widely used.
Polynomial codes are based upon treating bit strings as representations of polynomials with
coefficients of 0 and 1 only. A k-bit frame is regarded as the coefficient list for a polynomial with k
terms, ranging from xk-1 to x0. Such a polynomial is said to be of a degree k-1. The high-order (left
most) bit is the coefficient of xk-1; the next bit is the coefficient of xk-2, and so on. For example,
110001 has 6 bits and thus represents a six-term polynomial with coefficients 1,1,0,0,0 and 1 : x5 +
x4 + x0.
When the polynomial code method is employed, the sender and receiver must agree upon a
generator polynomial, G(x), in advance. Both the high and low-order bits of the generator must be
1. To compute the checksum for some frame with m bits, corresponding to the polynomial M(x),
the frame must be longer than the generator polynomial. The idea is to append a checksum to the
end of the frame in such a way that the polynomial represented by the check summed frame is
divisible by G (x). When the receiver gets the checksummed frame, it tries dividing it by G(x). If
there is a remainder, there has been a transmission error.
The algorithm for computing checksum is as follows:

1. Let r be the degree of G(x). Append r zero bits to the low-order end of the frame, so it now
contains m+r bits and corresponds to the polynomial xr M(x).
2. Divide the bit string corresponding to G(X) into the bit string corresponding to x r M(x)
using modulo-2 division.
3. Subtract the remainder (which is always r or fewer bits) from the bit string corresponding to
xr M(x) using modulo-2 subtraction. The result is the check summed frame to be
transmitted. Call its polynomial T(x).
The CRC-CCITT polynomial is x16 + x12 + x5 + 1

EXAMPLE TO CALCULATE CRC:
Data Frame to be transmitted: 11100110
Generator Polynomial: 11001 (x4 + x3 + 1)
Message after appending four zeroes (as degree of polynomial is 4): 111001100000
Transmitted Frame= Message frame+ CRC checksum (Remainder)
= 111001100110.
ERROR DETECTION:
The receiver divides the message (including the calculated CRC), by the same polynomial
the transmitter used. If the result of this division is zero, then the transmission was successful.
However, if the result is not equal to zero, an error occurred during the transmission.
Assume for the previous example if the received frame is: 111001100110
The received frame is divided by the same generator polynomial as used by the transmitter
i.e., 11001 (x4 + x3 + 1), we get remainder 0000, indicating, ―No Transmission Error‖. Else if the
remainder is not 0000 indicates ―Transmission error‖
Note: first check the output by taking simple generator polynomial( say 11001) then take ccitt
polynomial(x16 + x12 + x5 + 1) as generator polynomial.
/* C Program to compute polynomial code checksum */
#include<stdio.h>
#include<math.h>
#include<conio.h>
#include<string.h>
#define degree 4
int result[50];
int gen[6]={1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1}; /ccitt polynomial * x16 + x12 + x5 + 1*/
int length;
void calcrc();
void main()
{
int array[50],flag=0;
int i=0;
char ch;
clrscr();
printf("enter frame ");
{
array[i++]=ch-'0';
}
length=i;
for(i=length;i<length+degree;i++)
{
array[i]=0;
}
length=length+degree;
for(i=0;i<length;i++)
{
result[i]=array[i];
}
calcrc();
for(i=0;i<length;++i)
{
result[i]=(result[i]|array[i]);
}
printf("\n the result is \n");

for(i=0;i<length;i++)
printf(" %d",result[i]);
getch();
printf("\nEnter the stream for which CRC has to be checked : ");

i=0;
array[i++]=ch-'0';
length=i;
for (i=0;i<length;i++)
result[i]=array[i];
calcrc();
printf("\nChecksum is : ");
for (i=0;i<length;i++)
{
printf("%d",result[i]);
if(result[i]!=0)
flag=1;
}
if(flag)
printf("\n error in transmission\n");
else
printf("\n No error in transmission\n");
getch();
}
void calcrc()
{
int pos=0,j,i;
while(pos<(length-degree))
{
j=0;
for(i=pos;i<=(pos+degree);i++,j++)
{
result[i]=result[i]^gen[j];
}
i=pos;
while(result[i++]==0)
pos++;
}
}
Note: first check the output by taking simple generator polynomial( say 11001) then take ccitt
polynomial(x16 + x12 + x5 + 1) as generator polynomial.
OUTPUT:
Enter the data stream : 10011

The transmitted frame is : 1 0 0 1 1 0 0 1 0 0 0 1 0 0 1 0 1 0 0 1 0
Enter the stream for which CRC has to be checked: 100110010001001010010
Checksum : 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
No Transmission Error
PROGRAM 3:
IMPLEMENTATION OF SLIDING WINDOW PROTOCOL
In sliding window method, multiple frames are sent by sender at a time before needing an
acknowledgment. Multiple frames sent by source are acknowledged by receiver using a single ACK frame.
SLIDING WINDOW PROTOCOL

Sliding window refers to an imaginary boxes that hold the frames on both sender and receiver side.
• It provides the upper limit on the number of frames that can be transmitted before requiring an
acknowledgment.
• Frames may be acknowledged by receiver at any point even when window is not full on receiver
side.
• Frames may be transmitted by source even when window is not yet full on sender side.
• The windows have a specific size in which the frames are numbered modulo- n, which means they
are numbered from 0 to n-l. For e.g. if n = 8, the frames are numbered 0, 1,2,3,4,5,6, 7, 0,
1,2,3,4,5,6, 7, 0, 1, ....
The size of window is n-1. From the figure shown above, in this case it is 7. Therefore, a maximum
of n-l frames may be sent before an acknowledgment. When the receiver sends an ACK, it includes
the number of next frame it expects to receive. For example in order to acknowledge the group of
frames ending in frame 4, the receiver sends an ACK containing the number 5. When sender sees an
ACK with number 5, it comes to know that all the frames up to number 4 have been received.
Sliding Window on Sender Side

• At the beginning of a transmission, the sender's window contains n-l frames.
• As the frames are sent by source, the left boundary of the window moves inward, shrinking the
size of window. This means if window size is w, if four frames are sent by source after the last
acknowledgment, then the number of frames left in window is w-4.
• When the receiver sends an ACK, the source's window expand i.e. (right boundary moves
outward) to allow in a number of new frames equal to the number of frames acknowledged by that
ACK.
• For example, Let the window size is 7 (see diagram (a)), if frames 0 through 3 have been sent and
no acknowledgment has been received, then the sender's window contains three frames - 4,5,6.
• Now, if an ACK numbered 3 is received by source, it means three frames (0, 1, 2) have been
received by receiver and are undamaged.
• The sender's window will now expand to include the next three frames in its buffer. At this point
the sender's window will contain six frames (4, 5, 6, 7, 0, 1). (See Figure 5.2 )
Sliding Window on Receiver Side

At the beginning of transmission, the receiver's window contains n-1 spaces for frame but not the
frames.
• As the new frames come in, the size of window shrinks.
• Therefore the receiver window represents not the number of frames received but the number of
frames that may still be received without an acknowledgment ACK must be sent.
• Given a window of size w, if three frames are received without an ACK being returned, the
number of spaces in a window is w-3.
• As soon as acknowledgment is sent, window expands to include the number of frames equal to the
number of frames acknowledged.
• For example, let the size of receiver's window is 7 as shown in diagram. It means window contains
spaces for 7 frames.
• With the arrival of the first frame, the receiving window shrinks, moving the boundary from space
0 to 1. Now, window has shrunk by one, so the receiver may accept six more frame before it is
required to send an ACK.
• If frames 0 through 3 have arrived but have DOC been acknowledged, the window will contain
three frame spaces.
• As receiver sends an ACK, the window of the receiver expands to include as many new
placeholders as newly acknowledged frames.
• The window expands to include a number of new frame spaces equal to the number of the most
recently acknowledged frame minus the number of previously acknowledged frame. For e.g., If
window size is 7 and if prior ACK was for frame 2 & the current ACK is for frame 5 the window
expands by three (5-2).
• Therefore, the sliding window of sender shrinks from left when frames of data are sending. The
sliding window of the sender expands to right when acknowledgments are received.
• The sliding window of the receiver shrinks from left when frames of data are received. The sliding
window of the receiver expands to the right when acknowledgement is sent.
SLIDING WINDOW PROTOCOL

#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
4 6
Acknowledgement of above frames sent is received by sender
PROGRAM 4:
IMPLEMENT DIJKSTRA‘S ALGORITHM TO COMPUTE THE SHORTEST ROUTING
PATH.
In order to transfer packets from a source host to the destination host , the network layer
must determine the path or route that the packets are to follow. This is the job of the network layer
routing protocol. At the heart of any routing protocol is the routing algorithm that determines the
path for a packet from source router to destination router. Given a set of routers, with links
connecting the routers, a routing algorithm finds a good path from source router to destination
router, according to some cost criterion. These can be,
1. Hop count: 1/ capacity: The cost is inversely proportional to the link capacity. One assigns higher
costs to lower capacity links. The objective is to send a packet through a path through a path with
the highest capacity. If each link has equal capacity, then the shortest path is the path with the
minimum number of hops
2. Transmission speed: The speed at which the various links operate is an important part of a route‘s
efficiency. Faster links obviously take precedence over slow ones.
3. Congestion: Network congestion caused by the current traffic pattern is considered when
evaluating a route and links that are overly congested are bypassed
4. Route cost : The route cost is a metric assigned by the network administrator used to rate the
relative usability of various routes . The cost can refer to the literal financial expense incurred by
the link or any other pertinent factor.
5. Packet delay: The cost is proportional to an average packet delay which includes queuing delay
in the switch buffer ad propagation delay in the link. The shortest path represents the fastest path to
reach the destination.
Dijkstra's method of computing the shortest path or shortest path routing is a static routing
algorithm. It involves building a graph of the subnet, with each node of the graph representing a
router and each arc representing a communication line or a link. To find a route between a pair of
routers, the algorithm just finds the shortest path between them on the graph.
In Dijkstra's algorithm the metric used for calculation is distance. Each node is labeled with its
distance from the source node along with the previous node in the path. Initially no paths are known
so all nodes are labeled with infinity. As the algorithm proceeds and paths are found, the labels may
change, reflecting better paths. A label may either be tentative or permanent. Initially all nodes are
tentative and once it is discovered that the shortest possible path to a node is got it is made
permanent and never changed after that.
EXAMPLE:
 Permanent
Tentative
(In the fig: The first 5 steps used in computing shortest path from A to D. The arrows indicates
working node.)
To illustrate how the algorithm works, refer the weighted graph shown in figure. We want to
find the shortest path from A to D. We start out by marking node A as permanent, indicated by a
filled-in circle (as A is the source) . Then we examine, in turn each of the nodes which are tentative
(shown by unfilled circles) adjacent to A( the working node), relabeling each one with the distance
to A. Whenever a node is relabeled, we also label it with the node from which probe was made so
that we can reconstruct the final path later.
Having examined each of the nodes adjacent to A, we examine all the tentatively labeled
nodes in the whole graph and make the one with the smallest label permanent, as shown in fig b.
This one becomes the new working node. We now start at B and examine all nodes adjacent to it. If
the sum of the label on B and the distance from B to the node being considered is less than the label
on that node we have a shorter path, soothe node is relabeled. After all the nodes adjacent to the
working node have been inspected and the tentative labels changed if possible, the entire graph is
searched for the tentatively-labeled node, with smallest weight. This node is made permanent and
becomes the working node for the next round.
ALGORITHM:
1. Input graph data
2. Make all nodes TENTATIVE.
2. Input source and destination
3. Make source, the working node
4. Make the working node PERMANENT.
5. Check all tentative nodes, which are connected to working node. Update weight if required.
6. Find TENTATIVE node with smallest weight. Make this the new working node.
7. If working node is destination, go to step 8 else go to step 4
8. Trace back from destination to source.
# include<stdio.h>
# include<conio.h>
/*Total number of nodes in network*/

# define N 10
/*State of each node*/

# define PERMANENT 1
# define TENTATIVE 0
struct node
{
int weight;
int prev;
int state;
};
void main()
{
int table[N][N] =
/* A B C D E F G H I J*/
/*A*/ { {0,1,0,0,0,4,0,0,0,0},
/*B*/ {1,0,4,0,0,0,0,1,0,0},
/*C*/ {0,4,0,3,2,0,0,0,3,0},
/*D*/ {0,0,3,0,1,0,0,0,0,0},
/*E*/ {0,0,2,1,0,3,0,0,0,1},
/*F*/ {4,0,0,0,3,0,1,0,0,0},
/*G*/ {0,0,0,0,0,1,0,2,0,2},
/*H*/ {0,1,0,0,0,0,2,0,1,0},
/*I*/ {0,0,3,0,0,0,0,1,0,2},
/*J*/ {0,0,0,0,1,0,2,0,2,0}
};/* A B C D E F G H I J*/
/*interpret as A is connected to B at a weight of 1 as
table[A][B]=table[B][A]=1*/
int src,dest,i,w_node;
int min;
struct node nodes[N];
for(i=0;i<N;++i)
{
nodes[i].state=TENTATIVE;
nodes[i].weight=10000;
}
printf("\nEnter Source:");
src=getche();
w_node=src=toupper(src)-'A';
nodes[src].prev=-1;
nodes[src].weight=0;
printf("\nEnter Destination:");
dest=toupper(getche())-'A';
do
{
nodes[w_node].state=PERMANENT;
for(i=0;i<N;++i)
{
if(table[w_node][i]!=0 && nodes[i].state==TENTATIVE)
{
if(nodes[w_node].weight+table[w_node][i]<nodes[i].weight)
{
nodes[i].weight=nodes[w_node].weight+table[w_node][i];
nodes[i].prev=w_node;
}
} }
/*Find minimum weighted Tentative node*/

min=10000;
for(i=0;i<N;++i)
{
if(nodes[i].state==TENTATIVE && nodes[i].weight<min)
{
min=nodes[i].weight;
w_node=i;
}
}
} while(w_node!=dest);
printf("\nShortest Path got--->\n%c",dest+65);

do
{
w_node=nodes[w_node].prev;
printf("<-%c",working_node+65);
} while(w_node!=src);
printf("\nAt a total weight of:%d",nodes[dest].weight);
}
OUTPUT:
1. Enter Source:A
Enter Destination:D
Shortest Path got--->
D<-E<-J<-I<-H<-B<-A
At a total weight of: 7
2. Enter the Source: G

Enter the Destination: C
Shortest Path got-
G<-J<-E<-C
At a total weight of: 5
PROGRAM 5:
WRITE A PROGRAM FOR CONGESTION CONTROL USING LEAKY BUCKET
ALGORITHM.
The congesting control algorithms are basically divided into two groups: open loop and
closed loop. Open loop solutions attempt to solve the problem by good design, in essence, to make
sure it does not occur in the first place. Once the system is up and running, midcourse corrections
are not made. Open loop algorithms are further divided into ones that act at source versus ones that
act at the destination.
In contrast, closed loop solutions are based on the concept of a feedback loop if there is any
congestion. Closed loop algorithms are also divided into two sub categories: explicit feedback and
implicit feedback. In explicit feedback algorithms, packets are sent back from the point of
congestion to warn the source. In implicit algorithm, the source deduces the existence of congestion
by making local observation, such as the time needed for acknowledgment to come back.
The presence of congestion means that the load is (temporarily) greater than the resources (in part
of the system) can handle. For subnets that use virtual circuits internally, these methods can be used
at the network layer.
Another open loop method to help manage congestion is forcing the packet to be transmitted
at a more predictable rate. This approach to congestion management is widely used in ATM
networks and is called traffic shaping. The other method is the leaky bucket algorithm. 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. In other words, if one or more
process are already queued, the new packet is unceremoniously discarded. This arrangement can be
built into the hardware interface or simulate d by the host operating system. In fact it is nothing
other than a single server queuing system with constant service time. The host is allowed to put one
packet per clock tick onto the network. This mechanism turns an uneven flow of packet from the
user process inside the host into an even flow of packet onto the network, smoothing out bursts and
greatly reducing the chances of congestion.
#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]);
else printf("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;
else p_sz_rm-=o_rate;
printf("Bytes remaining:%d\n",p_sz_rm);
}
else printf("No packets to transmit\n");
}
}
}
getch();
OUTPUT:
Enter output rate:2
Enter bucket size:10
--------------------------------------------------
Incoming packet:6
Transmission left:6
Next packet will come at 7
Time left 7--------No packets to transmit!!
Transmitted
Bytes remaining:4
Transmitted
Bytes remaining:2
Transmitted
Bytes remaining:0
--------------------------------------------------
Incoming packet:0
Transmission left:0
--------------------------------------------------
Incoming packet:2
Transmission left:2
Transmitted
Bytes remaining:0
--------------------------------------------------
Incoming packet:0
Transmission left:0
Incoming packet:6
Transmission left:6
Transmitted
Bytes remaining:4
Transmitted
Bytes remaining:2
Transmitted
Bytes remaining:0
PROGRAM 6:
IMPLEMENT ENCRYPTION AND DECRYPTION OF A GIVEN MESSAGE.
The science and art of manipulating messages to make them secure is called Cryptography.
An original message to be transformed is called the plain text and the resulting message after the
transformation is called the cipher text. The process of converting the plain text into cipher text is
called encryption. The reverse process is called decryption. The algorithm used for encryption and
decryption is often called a cipher Substitution ciphers are a common technique for altering
messages in games and puzzles. Each letter of the alphabet is mapped into another letter. The cipher
text is obtained by applying the substitution defined by the mapping to the plain text. Transposition
ciphers are another type of encryption scheme. Here the order in which the letters appear is altered.
The letters may be written into an array in one order and read out in a different order.
In cryptography, the messages to be encrypted; known as plaintext, are transformed by a

function that is parameterized by a key. The output of the encryption process, known as cipher text,
is then transmitted, often by messenger or radio. We assume that the enemy or intruder, hears and
accurately copies down the complete cipher text. However, unlike the intended recipient, he does
not know what the decryption key is and so cannot decrypt the cipher text easily. Sometimes the
intruder cannot only listen to the communication channel (passive intruder) but can also record
messages and play them later, inject his own messages, or modify legitimate messages before they
get to the receiver (active intruder). The art of breaking ciphers is called cryptanalysis. The art of
devising ciphers (cryptography) and breaking them (cryptanalysis) is collectively known as
cryptology. It will often be useful to have a notation for relating plaintext, ciphertext and keys. We
will use C=EK(P) to mean that the encryption of the plaintext P using key K gives the ciphertext C.
Similarly, P=DK(C) represents decryption of C to get the plaintext again. It then follows that
DK(EK(P)) = P
Fundamental rule of cryptography is that one must assume that the cryptoanalyst knows the
general method of encryption used. Encryption methods are historically divided into two categories:
substitution ciphers and transposition ciphers.
Encryption Method Cipher C=Ek(P )
Decryption Method Plaintext P=DK(EK(P))
Encryption key-Ek, Decryption key-Dk, Plaintext-P
SUBSTITUTION CIPHERS:
In a substitution cipher, each letter or group of letters is replaced by another letter by adding key to
disguise it.
Plaintext: a b c d e f g h i j k l m n o p q r s t u v w x y z
Key=2
Ciphertext: c d e f g h i j k l m n o ......
Example : attack
Key=3
Encrypted data: dwwdfo
ALGORITHM FOR ENCRYPTION BY SUBSTITUTION METHOD:
1. Read data to be encoded
2. For every character of data
3. Add the key to the character.
4. Print encrypted data.
5. Subtract the key from character
6. Print the decrypted data.

# include<string.h>
# include<ctype.h>
# include<stdio.h>
void main()
{
char data[50];
char encoded[50];
char decoded[50];
int i,len,key;
printf("\nEnter data to be encoded:");
gets(data);
len=strlen(data);
printf(―\nenter the key for encryption\n‖);
scanf(―%d‖,&key);
for(i=0;i<len;i++)
encoded[i]= ‗a‘+((data[i]-‗a‘)+key)%25;
encode[i]=‘\0‘;
printf(―\n the encrypted data is %s‖, encoded);
/*decryption */
for(i=0;i<len;i++)
{
decoded[i]=‘a‘+( (( encoded[i]-‗a‘)+(26-key))%26)
}
decoded[i]=‘\0‘;
printf(―the decrypted message is %s‖, decoded);
}
OUTPUT:
Enter data to be encoded: hello world

Enter the key for encryption: 2
Encrypted data: jgnnq
Decrypted message: hello world

TRANSPOSITION CIPHERS:
Substitution ciphers preserve the order of the plaintext symbols but disguise them.
Transposition ciphers, in contrast, reorder the letters but do not disguise them. The figure below
depicts a common transposition cipher, the columnar transposition. The cipher is keyed by a word
or phrase not containing any repeated letters. In this example, MEGABUCK is the key. The purpose
of the key is to number the columns, column 1 being under the letter closet to the start of the
alphabet and so on. The plain text is written horizontally, in rows. The cipher text is read out by
columns, starting with the column whose key letter is the lowest.
EXAMPLE:
Plain text : please transfer one million dollars to my swiss bank account six six two
Key text: M E G A B U C K
7 4 5 1 2 8 3 6
please-t
rans fer-
one-mill
ion-doll
ars-tomy
-swiss-b
ank-acco
unt-six-
six-two-
CIPHERTEXT:
as---o---sf,dtsast-rllm-cxolanorsnnienenswktxt-llybo—proia-auseeioosciw
ALGORITHM FOR ENCRYPTION AND DECRYPTION BY TRANSPOSITION

METHOD:
1. Get the plain text
2. Replace spaces with ‗–‗
3. Add ‗–‗ at the end until the length of the plain text is a multiple of length of the key.
4. Set the character=‘A‘
5. Search for character in key text, index=0

6. If found
a.) Yes: pick character from plain text at index position store it in cipher text
Increment index by length of key text repeat 6a
b) No: increment index, if index=length of key text go to step7 else repeat 6.
7. Increment character, check character=‘Z‘, yes: go to step 8, no: repeat 6.
8. Get the encoded text
9 Replace ‗-‗with spaces
10. Set the character=‘A‘
11. Search for character in key text, index=0
12. If found
a.)Yes: pick character from cipher (encoded) text at index position store it in plain
text ,increment index by length of key text repeat 12a
b) No: increment index, if index=length of key text go to step13 else repeat 12.
13. Increment character, check character=‘Z‘, yes: go to step 14, no: repeat 12.
14. Terminate.
#include<conio.h>
#include<stdio.h>
#include<string.h>
#include<ctype.h>
void main()
{
char inp[50],out[50],key[20],enc[50],dec[50];
int i,j,k=0,ilen,tlen,t,klen;
char ch='A';
clrscr();
printf("Enter the string to be encrypted: ");
gets(inp);
printf("\nEnter the key string: ");
gets(key);
ilen=strlen(inp);
tlen=ilen;
klen=strlen(key);
for(t=0;t<ilen;t++)
{
if(inp[t]==' ')
inp[t]='-';
}
while(ilen%klen!=0)
inp[ilen++]='-';
inp[ilen]='\0';
// printf("Updated input: %s",inp);
for(ch='A';ch<='Z';ch++)
for(j=0;j<=klen;j++)
if(toupper(key[j])==ch)
for(i=j;i<ilen;i+=klen)
out[k++]=inp[i];
out[k]='\0';
printf("\nThe encrypted output is: %s",out);
//printf("\nEnter the encrypted message: ");

// gets(enc);
for(ch='A',k=0;ch<='Z';ch++)
for(j=0;j<klen;j++)
if(toupper(key[j])==ch)
for(i=j;i<ilen;i+=klen)
dec[i]=out[k++];
dec[tlen]='\0';
for(t=0;t<tlen;t++)
if(dec[t]=='-')
dec[t]=' ';
printf("\nThe decrypted message is: %s",dec);
getch();
}
OUTPUT:
1. Enter the string to be encrypted: please transfer one million dollars to my swiss bank account six
six two
Enter the key string: megabuck
The encrypted message: as---i---sfmdtsast-rllm-cxolanorsnnienenswktxt-llybo—proia-auseeioosciw
(refer example)
2. Enter the string to be encrypted: CCN Lab is very easy
Enter the key string: TELECOM
The encrypted message: le-csa-vym-sbu-ar-cie

PART B
INTRODUCTION TO NS-2
 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 protocols and simulating
their corresponding behaviors.
BASIC ARCHITECTURE OF NS2:
(TOOL COMMAND LANGUAGE) TCL SCRIPTING

 TCL is a general purpose scripting language. [Interpreter]
 TCL runs on most of the platforms such as Unix, Windows, and Mac.
 The strength of TCL is its simplicity.
 It is not necessary to declare a data type for variable prior to the usage.
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:
1. Initialization and termination aspects of the ns simulator.

2. Definition of network nodes, links, queues and topology.
3. Definition of agents and of applications.
4. The nam visualization tool.
5. Tracing and random variables.
INITIALIZATION AND TERMINATION OF TCL SCRIPT IN NS-2

An ns simulation starts with the command,
set ns [new Simulator]

This is thus the first line in the TCL script. This line declares a new variable using the set command,
you can call this variable as you wish, In general, it is declared as ns because, it is an instance of the
Simulator class, so an object the code [new Simulator] is indeed the installation of the class
Simulator using the reserved word new.
In order to have output files with data on the simulation (trace files) or files used for visualization
(nam files), we need to create the files using ―open command:
#Open the Trace file
set tracefile1 [open out.tr w]

$ns trace-all $tracefile1
#Open the NAM trace file
set namfile [open out.nam w]

$ns namtrace-all $namfile
The above creates a trace file called ―out.tr and a nam visualization trace file called ―out.nam.
Within the TCL script, these files are not called explicitly by their names, but instead by pointers
that are declared above and called ―tracefile1 and ―namfile respectively. Remark that they begin
with a # symbol. The second line open the file ―out.tr to be used for writing, declared with the
letter ―w. The third line uses a simulator method called trace-all that have as parameter the name
of the file where the traces will go.
The last line tells the simulator to record all simulation traces in NAM input format. It also
gives the file name that the trace will be written to later by the command $ns flush-trace. In our
case, this will be the file pointed at by the pointer ―$namfile ,i.e the file ―out.tr.
The termination of the program is done using a ―finish procedure.
#Define a „finish‟ procedure
Proc finish { } {
global ns tracefile1 namfile
$ns flush-trace
Close $tracefile1
Close $namfile
Exec nam out.nam &
Exit 0
The word proc declares a procedure in this case called finish and without arguments. The word
global is used to tell that we are using variables declared outside the procedure. The simulator
method ―flush-trace‖ will dump the traces on the respective files. The TCL command ―close‖
closes the trace files defined before and exec executes the nam program for visualization. The
command exit will ends the application and return the number 0 as status to the system. Zero is the
default for a clean exit. Other values can be used to say that exit because something fails.
At the end of ns program we should call the procedure ―finish‖ and specify at what time the
termination should occur. For example,
$ns at 125.0 “finish”

will be used to call ―finish at time 125sec.Indeed,the at method of the simulator allows us to schedule
events explicitly.
The simulation can then begin using the command,
$ns run
Definition of a network of links and nodes
The way to define a node is,
set n0 [$ns node]

The node is created which is printed by the variable n0. When we shall refer to that node in the script we
shall thus write $n0.
Once we define several nodes, we can define the links that connect them. An example of a definition of
a link is:
$ns duplex-link $n0 $n2 10Mb 10ms DropTail

Which means that $n0 and $n2 are connected using a bi-directional link that has 10ms of propagation
delay and a capacity of 10Mb per sec for each direction.
To define a directional link instead of a bi-directional one, we should replace ―duplex-link by

―simplex-link.
In NS, an output queue of a node is implemented as a part of each link whose input is that node.
The definition of the link then includes the way to handle overflow at that queue. In our case, if the
buffer capacity of the output queue is exceeded then the last packet to arrive is dropped. Many
alternative options exist, such as the RED (Random Early Detectiom) mechanism, the FQ (Fair
Queuing), the DRR (Deficit Round Robin), the Stochastic Fair Queuing (SFQ) and the CBQ (which
including a priority and a round-robin scheduler).
In ns, an output queue of a node is implemented as a part of each link whose input is that
node. We should also define the buffer capacity of the queue related to each link. An example
would be:
#set Queue Size of link (n0-n2) to 20

$ns queue-limit $n0 $n2 20
Agents and Applications

We need to define routing (sources, destinations) the agents (protocols) the application that use
them.
FTP over TCP

TCP is a dynamic reliable congestion control protocol. It uses Acknowledgements created by the
destination to know whether packets are well received.
There are number variants of the TCP protocol, such as Tahoe, Reno, NewReno, Vegas. The type of
agent appears in the first line:
set tcp [new Agent/TCP]
The command $ns attach-agent $n0 $tcp defines the source node of the tcp connection.
The command
set sink [new Agent /TCPSink]
Defines the behavior of the destination node of TCP and assigns to it a pointer called sink.
#Setup a UDP connection
set udp [new Agent/UDP]
$ns attach-agent $n1 $udp
set null [new Agent/Null]
$ns attach-agent $n5 $null
$ns connect $udp $null
$udp set fid_2
#Setup a CBR over UDP connection

set cbr [new Application/Traffic/CBR]
$cbr attach-agent $udp
$cbr set packetsize_ 100
$cbr set rate_ 0.01Mb
$cbr set random_ false
Above shows the definition of a CBR application using a UDP agent.
The command $ns attach-agent $n4 $sink defines the destination node. The command $ns
connect $tcp $sink finally makes the TCP connection between the source and destination nodes.
TCP has many parameters with initial fixed defaults values that can be changed if mentioned
explicitly. For example, the default TCP packet size has a size of 1000bytes.This can be changed to
another value, say 552bytes, using the command $tcp set packetSize_ 552.
When we have several flows, we may wish to distinguish them so that we can identify them
with different colors in the visualization part. This is done by the command $tcp set fid_ 1 that
assigns to the
TCP connection a flow identification of ―1‖.We shall later give the flow identification of ―2‖ to
the UDP connection.
CBR over UDP

A UDP source and destination is defined in a similar way as in the case of TCP.
Instead of defining the rate in the command $cbr set rate_ 0.01Mb, one can define the time interval
between transmission of packets using the command.
$cbr set interval_ 0.005
The packet size can be set to some value using

$cbr set packetSize_ <packet size>
SCHEDULING EVENTS
NS is a discrete event based simulation. The tcp script defines when event should occur. The
initializing command set ns [new Simulator] creates an event scheduler, and events are then
scheduled using the format:
$ns at <time> <event>
The scheduler is started when running ns that is through the command $ns run.
The beginning and end of the FTP and CBR application can be done through the following
command
$ns at 0.1 “$cbr start”
$ns at 1.0 “ $ftp start”
$ns at 124.0 “$ftp stop”
$ns at 124.5 “$cbr stop”
STRUCTURE OF TRACE FILES:
When tracing into an output ASCII file, the trace is organized in 12 fields as follows in fig shown
below, The meaning of the fields are:
Event Time From To PKT PKT Flags FID Src Dest Seq PKT
node node type Size Addr Addr No. ID
1. EVENT OR TYPE IDENTIFIER

+ :a packet enque event
- :a packet deque event
r :a packet reception event
d :a packet drop (e.g., sent to dropHead_) event
c :a packet collision at the MAC level
2.TIME: Time at which the packet tracing string is created.
3-4. SOURCE AND DESTINATION NODE: Gives the input node and output node of the link at
which the event occurs.
5. PACKET NAME: Gives the packet type (eg: Constant Bit Rate (CBR) or (Transmission Control
Protocol) TCP).
6. PACKET SIZE: Size of packet in bytes.
7. FLAGS: digit flag string.

―-‖: disable
1st = ―E‖: ECN (Explicit Congestion Notification) echo is enabled.
2nd = ―P‖: the priority in the IP header is enabled.
3rd : Not in use
4th = ―A‖: Congestion action
5th = ―E‖: Congestion has occurred.
6th = ―F‖: The TCP fast start is used.
7th = ―N‖: Explicit Congestion Notification (ECN) is on.
8. FLOW ID: This is the flow id (fid) of IPv6 that a user can set for each flow at the input OTcl
script one can further use this field for analysis purposes; it is also used when specifying stream
color for the NAM display.
9-10. SOURCE AND DESTINATION ADDRESS: The format of these two fields is ―a.b‖, where
―a" is the address and "b" is the port.
11. SEQUENCE NUMBER: This is the network layer protocol‘s packet sequence number. Even
though UDP implementations in a real network do not use sequence number, ns keeps track of UDP
packet sequence number for analysis purposes
12. PACKET UNIQUE ID: The last field shows the unique ID of the packet.
XGRAPH
The xgraph program draws a graph on an x-display given data read from either data file or from
standard input if no files are specified. It can display upto 64 independent data sets using different
colors and line styles for each set. It annotates the graph with a title, axis labels, grid lines or tick
marks, grid labels and a legend.
SYNTAX:
Xgraph [options] file-name
Options are listed here

/-bd <color> (Border)
This specifies the border color of the xgraph window.
/-bg <color> (Background)
This specifies the background color of the xgraph window.
/-fg<color> (Foreground)
This specifies the foreground color of the xgraph window.
/-lf <fontname> (LabelFont)
All axis labels and grid labels are drawn using this font.
/-t<string> (Title Text)
This string is centered at the top of the graph.
/-x <unit name> (XunitText)
This is the unit name for the x-axis. Its default is ―X‖.
/-y <unit name> (YunitText)
This is the unit name for the y-axis. Its default is ―Y‖.
AHO, WEINBERGER AND KERNIGHAN (AWK) SCRIPT:

AWK is a programmable, pattern-matching, and processing tool available in UNIX. It works
equally well with text and numbers. AWK is not just a command, but a programming language too.
In other words, AWK utility is a pattern scanning and processing language. It searches one or more
files to see if they contain lines that match specified patterns and then perform associated actions,
such as writing the line to the standard output or incrementing a counter each time it finds a match.
SYNTAX:
awk option ‘selection_criteria {action}’ file(s)
Here, selection_criteria filters input and select lines for the action component to act upon. The
selection_criteria is enclosed within single quotes and the action within the curly braces. Both the
selection_criteria and action forms an AWK program.
Example: $ awk „/manager/ {print}‟ emp.lst

Variables
Awk allows the user to use variables of there choice. You can now print a serial number, using the
variable kount, and apply it those directors drawing a salary exceeding 6700:
$ awk –F‖|‖ „$3 == ―director‖ && $6 > 6700 {
kount =kount+1
printf ― %3f %20s %-12s %d\n‖, kount,$2,$3,$6 }‟ empn.lst
THE –f OPTION: STORING awk PROGRAMS IN A FILE

You should holds large awk programs in separate file and provide them with the awk extension for
easier identification. Let‘s first store the previous program in the file empawk.awk:
$ cat empawk.awk
Observe that this time we haven‘t used quotes to enclose the awk program. You can now use awk
with the –f filename option to obtain the same output:
Awk –F”|” –f empawk.awk empn.lst
THE BEGIN AND END SECTIONS:
AWK statements are usually applied to all lines selected by the address, and if there are no
addresses, then they are applied to every line of input. But, if you have to print something before
processing the first line, for example, a heading, then the BEGIN section can be used gainfully.
Similarly, the end section useful in printing some totals after processing is over.
The BEGIN and END sections are optional and take the form
BEGIN {action}
END {action}
These two sections, when present, are delimited by the body of the awk program. You can use them
to print a suitable heading at the beginning and the average salary at the end.
BUILT-IN VARIABLES:
Awk has several built-in variables. They are all assigned automatically, though it is also possible for
a user to reassign some of them. You have already used NR, which signifies the record number of
the current line. We‘ll now have a brief look at some of the other variable.
The FS Variable: as stated elsewhere, awk uses a contiguous string of spaces as the default field
delimiter. FS redefines this field separator, which in the sample database happens to be the |. When
used at all, it must occur in the BEGIN section so that the body of the program knows its value
before it starts processing:
BEGIN {FS=‖|‖}
This is an alternative to the –F option which does the same thing.
The OFS Variable: when you used the print statement with comma-separated arguments, each
argument was separated from the other by a space. This is awk‘s default output field separator, and
can reassigned using the variable OFS in the BEGIN section:
BEGIN { OFS=‖~‖ }
When you reassign this variable with a ~ (tilde), awk will use this character for delimiting the print
arguments. This is a useful variable for creating lines with delimited fields.
The NF variable: NF comes in quite handy for cleaning up a database of lines that don‘t contain the
right number of fields. By using it on a file, say emp.lst, you can locate those lines not having 6
fields, and which have crept in due to faulty data entry:
$awk „BEGIN {FS = ―|‖}
NF! =6 { Print ―Record No ―, NR, ―has‖, ―fields‖}‟ empx.lst
STEPS FOR EXECUTION
 Create a folder in roots folder. Open the terminal and type
[root@localhost ~]#cd foldername
 To open editor and type program.
[root@localhost ~]# gedit programname.tcl

*Program name should have the extension ― .tcl ‖
*Type the program in the editor window and then save it.
 To open editor and type awk program.
[root@localhost ~]# gedit programname.awk

*Program name should have the extension ―.awk ‖
* Type the program in the editor window and then save it.
 To run the simulation program,
[root@localhost~]# ns programname.tcl
Here ―ns‖ indicates network simulator. We get the topology shown in the snapshot. Now press the
play button in the simulation window and the simulation will begins.
 To see the trace file contents open the file as ,
[root@localhost~]# gedit out.tr
 After simulation is completed run awk file to see the output ,
[root@localhost~]# awk –f programname.awk out.tr

PROGRAM 7:
TO IMPLEMENT A POINT TO POINT NETWORK WITH FOUR NODES AND DUPLEX

LINKS BETWEEN THEM. ANALYZE THE NETWORK PERFORMANCE BY SETTING
QUEUE SIZE AND VARYING THE BANDWIDTH.
ALGORITHM:
STEP 1: Create the simulator object ns for designing the given simulation.
STEP 2: Open the trace file and nam file in the write mode.
STEP 3: Create the 4 nodes of the simulation using the ‗set‘ command and duplex link between
them.
STEP 4: Create a queue size between nodes .
STEP 5: Create UDP agent for the nodes and attach these agents to the nodes.
STEP 6: The traffic generator used is UDP and measured in terms of cbr0 and cbr1.
STEP 7: Configure node2 and node 3 as the null and attach it.
STEP 8: Connect source and destination nodes using ‗connect‘ command.
STEP 9: Create the Packet size and time interval between each packet coming using the cbr object
instance created.
STEP 10: Schedule the start and stop of events for UDP agent with 0.00msec and 10msec for cbr0
agent.
STEP 11: Schedule the start and stop of events for UDP agent with 2.00msec and 12 msec for cbr1
agent.
STEP 12: Schedule the simulation for 13 msec.
PROGRAM: COMMENTS
set ns [new Simulator] ;#creating a new variable ns
set tf [open p1.tr w] ;#open trace file p1.tr in writable mode
$ns trace-all $tf ;#main class object ns linked with trace file object tf
set nf [open p1.nam w] ;#open nam file p1.nam in writable mode
$ns namtrace-all $nf ;#main class object ns linked with nam file object nf
set n0 [$ns node] ;#creation of nodes

set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
$ns duplex-link $n0 $n2 20Mb 10ms DropTail ;#forming duplex connection between the nodes
$ns duplex-link $n1 $n2 10Mb 10ms DropTail ;#and vary the bandwidth in this link
$ns duplex-link $n2 $n3 0.7Mb 10ms DropTail
$ns set queue-limit $n0 $n2 10 ;#Assigning Queue size between the nodes
$ns set queue-limit $n1 $n2 10
set udp0 [new Agent/UDP] ;#creating object(agent) for the class Agent/UDP
set udp1 [new Agent/UDP] ;#creating object(agent) for the class Agent/UDP
set null [new Agent/Null] ;#creating Destination object(agent) for the class Agent/Null
set cbr0 [new Application/Traffic/CBR] ;#creating object(agent) for the class
;#Application/Traffic/CBR
set cbr1 [new Application/Traffic/CBR]
$ns attach-agent $n0 $udp0 ;#Attaching agents

$ns attach-agent $n1 $udp1
$cbr0 attach-agent $udp0
$ns connect $udp0 $null ;#connecting source and destination node agents
$ns connect $udp1 $null
$cbr0 set packetSize_ 512 ;#assigning values of packet size and time interval
$cbr0 set interval_ 0.001
$cbr1 set packetSize_ 512

proc finish { } { ;#terminate Simulation
global ns nf tf
$ns flush-trace
close $tf
close $nf
exec nam p1.nam &
exit 0
}
$ns at 0.0 "$cbr0 start" ;#Setting time for start and stop the packet transmission.
$ns at 10.0 "$cbr0 stop"
$ns at 2.0 "$cbr1 start"
$ns at 13.0 "finish" ;#Setting time to stop the simulation
$ns run
(AWK) SCRIPT:
BEGIN{
count=0
}
{
if($1=="d")
count++;
}
END {
printf("Number of packets dropped: %d\n",count);
}
TOPOLOGY AND NAM RESULT:
OUTPUT:
Case 1:
Source Destination Bandwidth Delay Queue No. of packets Dropped

Node Node Limit
n0 n2 20Mb 10ms 10
n1 n2 10Mb 10ms 10 9902
n2 n3 0.7Mb 10ms 5
Case 2:
Source Destination Bandwidth Delay Queue No. of packets Dropped

Node Node Limit
n0 n2 200Mb 10ms 100
n1 n2 100Mb 10ms 100 0
n2 n3 70Mb 10ms 50
RESULT: Network Performance analyzed by setting queue size and varying bandwidth using
NS-2.
PROGRAM 8:
TO IMPLEMENT FOUR NODE POINT TO POINT NETWORK WITH LINKS N0-N1,N1-
N2 AND N2-N3. APPLY TCP AGENT BETWEEN N0-N3 AND UDP BETWEEN N1-N3.
APPLY RELEVANT APPLICATION OVER TCP AND UDP AGENTS CHANGING THE
PARAMETER AND DETERMINE THE NUMBER OF PACKETS SENT BY TCP/UDP.
ALGORITHM:
STEP 3: Create the 4 nodes of the simulation using the ‗set‘ command and duplex link between
them.
STEP 4: Create a queue size between nodes.
STEP 5: Create UDP agent between the nodes n0 & n3 and attach these agents to the nodes.
STEP 6: Create TCP agent between the nodes n1 & n3 and attach these agents to the nodes.
STEP 7: The traffic generator used between n0 & n3 is UDP and measured in terms of cbr.
STEP 8: The traffic generator used between n0 & n3 is FTP and measured in terms of ftp.
STEP 9: Configure node 3 as the null and sink in UDP and TCP protocol respectively and attach it.
STEP 10: Connect source and destination nodes using ‗connect‘ command.
STEP 11: Create the Packet size and time interval between each packet coming using the cbr & ftp
object instance created.
STEP 12: Schedule the start and stop of events for FTP agent with 0.00msec and 10msec for ftp
agent.
STEP 13: Schedule the start and stop of events for UDP agent with 2.00msec and 12 msec for cbr
agent.
PROGRAM:
set tf [open p2.tr w]

$ns trace-all $tf
set nf [open p2.nam w]

$ns namtrace-all $nf
set n0 [$ns node]

set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]

$ns duplex-link $n2 $n3 0.7Mb 10ms DropTail
set tcp [new Agent/TCP]

set udp [new Agent/UDP]
set tcpsink [new Agent/TCPSink]

set null [new Agent/Null]
set cbr [new Application/Traffic/CBR]

set ftp [new Application/FTP]
$ns attach-agent $n0 $tcp

$ns attach-agent $n1 $udp
$ns attach-agent $n3 $tcpsink
$ftp attach-agent $tcp

$cbr attach-agent $udp
$ns connect $udp $null

$ns connect $tcp $tcpsink
$cbr set packetSize_ 512

$cbr set interval_ 0.005
$ftp set packetSize_ 512

$ftp set interval_ 0.005
proc finish {} {
global ns nf tf
$ns flush-trace
close $tf
close $nf
exec nam p2.nam &
exit 0
}
$ns at 0.0 "$ftp start"

$ns at 10.0 "$ftp stop"
$ns at 2.0 "$cbr start"
$ns at 12.0 "$cbr stop"
$ns at 13.0 "finish"

$ns run
AWK SCRIPT:
BEGIN{
tcp=0;
cbr=0;
}
{
if($1=="-" && $5=="tcp")
tcp++
if($1=="-" && $5=="cbr")
cbr++
}
END{
printf("\n no.of tcp packets sent= %d \n",tcp);
printf("\n no.of cbr packets sent= %d \n",cbr);
}
TO RUN:
ns filename.tcl
awk -f awkfilename.awk tracefilename.tr

PROGRAM 9:
SIMULATE AN ETHERNET LAN USING N NODES (6-10), CHANGE THE ERROR

RATE AND DATA RATE AND COMPARE THE THROUGHPUT.
ALGORITHM:
STEP 3: Create the nodes of the simulation using the ‗set‘ command.
STEP 4: Create Ethernet LAN using make-LAN command and connect the nodes to the LAN.
STEP 5: Create TCP agent for the nodes and attach these agents to the nodes.
STEP 6: The traffic generator used is FTP for both node1 and node5.
STEP 7: Add error node between the nodes 3 and 6.
STEP 8: Configure node5 as the sink and attach it.
STEP 9: Connect node1 and node5 agents using ‗connect‘ command.
STEP 10: Setting colour for the TCP packets.
STEP 11: Schedule the events for FTP agent 0.1msec.

$ns trace-all $tf

$ns color 1 "blue"
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/UDP"

$n3 label "Error Node"
$n5 label "Destination"
;#The below code is used to create a two Lans (Lan1 and #Lan2).
$ns make-lan "$n0 $n1 $n2 $n3" 100Mb 10ms LL Queue/DropTail Mac/802_3
$ns make-lan "$n4 $n5 $n6 " 100Mb 10ms LL Queue/DropTail Mac/802_3

set udp1 [new Agent/UDP]
set cbr1 [ new Application/Traffic/CBR]
set null5 [new Agent/Null]
$ns attach-agent $n1 $udp1

$ns attach-agent $n5 $null5
$ns connect $udp1 $null5

$cbr1 set interval_ 0.0001 ;# This is the data rate.Change
;# this to vary the throughput.
set err [new ErrorModel] ;# The code is used to add an error model
$ns lossmodel $err $n3 $n6 ;#between the nodes n3 and n6.
$err set rate_ 0.1 ;# This is the error rate. Change this
;#rate to add errors between n3 and n6.
$udp1 set class_ 1
proc finish { } {
global nf ns tf
close $nf
close $tf
exec nam p3.nam &
exit 0
}

$ns at 5.0 "finish"
$ns run
AWK SCRIPT:
BEGIN {
Rpacketsize=0;
Rtimeinterval=0;
}
{
if ($1=="r" && $3=="8" && $4=="5")
Rpacketsize=Rpacketsize+$6;
Rtimeinterval=$2;
}
END {
printf ("throughput:%f Mbps\n",(Rpacketsize/Rtimeinterval)*(8/10000000));
}
OUTPUT:
The throughput can be analysed by changing the data rate and error rate as shown below.
Case 1: Fix the data rate to 0.0001 and vary the error rate then throughput decreases as shown
below.
Error Rate
Data Rate
Throughput
0.1
0.0001
0.2
0.0001
0.3
0.0001
0.4
0.0001
Case 2: Fix the error rate to 0.1 and vary the data rate then throughput increases as shown below.
Error Rate
Data Rate
Throughput
0.1
0.1
0.1
0.01
0.1
0.001
0.1
0.0001
RESULT: Simulation of an Ethernet lan using 7 nodes, the Network throughput calculated by
varying the error rate and data rate using NS-2.
PROGRAM 10:
IMPLEMENT ETHERNET LAN USING N NODES AND ASSIGN MULTIPLE TRAFFIC

TO THE NODES AND OBTAIN CONGESTION WINDOW FOR DIFFERENT SOURCES
AND DESTINATIONS.
ALGORITHM:
STEP 3: Create the nodes of the simulation using the ‗set‘ command.
STEP 4: Create Ethernet LAN using make-LAN command and connect the nodes to the LAN.
STEP 6: The traffic generator used is FTP for both node0 and node2.
STEP 7: Configure node3 and node1 as the sink and attach it.
STEP 8: Connect node0 and node3, node2 and node1 agents using ‗connect‘ command.
STEP 9: Set color for the TCP packets.
STEP10: Define congestion window maximum value.
STEP 11: Schedule the events for FTP agent.
PROGRAM:

$ns trace-all $tf

set n0 [$ns node]

set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
$ns make-lan "$n0 $n1 $n2 $n3" 10Mb 10ms LL Queue/DropTail Mac/802_3
set tcp1 [new Agent/TCP]

set ftp1 [new Application/FTP]
set sink1 [new Agent/TCPSink]
$ns attach-agent $n0 $tcp1

$ftp1 attach-agent $tcp1
$ns attach-agent $n3 $sink1
$ns connect $tcp1 $sink1

set file1 [open file1.tr w]

$tcp1 attach $file1
$tcp1 trace cwnd_
$tcp1 set maxcwnd_ 10
set file2 [open file2.tr w]

$tcp2 attach $file2
$tcp2 trace cwnd_
$ns color 1 "red"

$ns color 2 "blue"
$tcp1 set class_ 1

$tcp2 set class_ 2
proc finish { } {
global nf tf ns
$ns flush-trace
exec nam p4.nam &
close $nf
close $tf
exit 0
}
$ns at 0.1 "$ftp1 start"

$ns at 1.5 "$ftp1 stop"
$ns at 2 "$ftp1 start"

$ns at 3 "$ftp1 stop"


$ns at 5.0 "finish"

$ns run
AWK SCRIPT:
BEGIN{
}
{
if($6=="cwnd_")
printf("%f\t%f\t\n",$1,$7);
}
END{
}
TO RUN:
ns filename.tcl
awk -f awkfilename.awk tracefile1name.tr >filename1
awk -f awkfilename.awk tracefile2name.tr >filename2
xgraph -x ―time‖ -y ―convalue‖ filename1 filename2

Plot of congestion window for different sources and destination (tcp1 and tcp2)
RESULT: Ethernet LAN using n(four) nodes implemented by creating multiple traffic to the nodes and
observed congestion window for different sources and destinations.
PROGRAM 11:
TO IMPLEMENT ESS WITH TRANSMISSION NODES IN WIRELESS LAN AND

OBTAIN THE PERFORMANCE PARAMETERS.
ALGORITHM:
STEP 1: Create GOD for wireless nodes.

STEP 4: Create the 3 nodes of the simulation using the ‗set‘ command.
STEP 5: Create a queue size between nodes.
STEP 7: The traffic generator used is TCP and measured in terms of FTP0 and FTP1.
STEP 8: Create data transmission and node movements.
STEP 9: Schedule the simulation for 250 milisec.
PROGRAM:

$ns trace-all $tf

$ns namtrace-all-wireless $nf 1000 1000
set topo [new Topography]

$topo load_flatgrid 1000 1000
$ns node-config -adhocRouting DSDV \

-llType LL \
-macType Mac/802_11 \
-ifqType Queue/DropTail \
-ifqLen 50 \
-phyType Phy/WirelessPhy \
-channelType Channel/WirelessChannel \
-propType Propagation/TwoRayGround \
-antType Antenna/OmniAntenna \
-topoInstance $topo \
-agentTrace ON \
-routerTrace ON
create-god 3
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
$n0 label "tcp0"

$n1 label "sink1/tcp1"
$n2 label "sink2"
$ns initial_node_pos $n0 50

#The below code is used to give the initial node positions.

$n0 set X_ 50
$n0 set Y_ 50
$n1 set X_ 200

$n1 set Y_ 200
$n2 set X_ 700

$n2 set Y_ 700
$ns at 0.1 "$n0 setdest 50 50 15"

$ns at 0.1 "$n1 setdest 200 200 25"
$ns at 0.1 "$n2 setdest 700 700 25"




#The below code is used to provide the node movements.

$ns at 100 "$n1 setdest 550 550 15"
$ns at 190 "$n1 setdest 100 100 15"
proc finish {} {
global ns nf tf
$ns flush-trace
exec nam p5.nam &
close $tf
exit 0
}
$ns at 250 "finish"

$ns run
AWK SCRIPT:
BEGIN{
#include<stdio.h>
count1=0
count2=0
pack1=0
pack2=0
time1=0
time2=0
}
{
if($1=="r"&&$3=="_1_"&&$4=="AGT")
{
count1++
pack1=pack1+$8
time1=$2
}
if($1=="r"&&$3=="_2_"&&$4=="AGT")
{
count2++
pack2=pack2+$8
time2=$2
}
}
END{
printf("The Throughput from n0 to n1: %fMbps\n",((count1*pack1*8)/time1*1000000)))
Printf("The Throughput from n1 to n2:%f Mbps",
((count2* pack2 * 8) /(time2*1000000)))
}
OUTPUT:
The Throughput from n0 to n1:_______Mbps

The Throughput from n1 to n2:_______Mbps
Packet transmission by tcp from n0 to n1

PROGRAM 12:
IMPLEMENTATION OF LINK STATE ROUTING ALGORITHM
ALGORITHM:
STEP 1: Create the simulator object ns for designing the given simulation
STEP 2: Open the trace file and nam file in the write mode
STEP 3: Create the 12 nodes of the simulation using the ‗set‘ command and duplex link between them
STEP 4: Create a queue size between nodes
STEP 5: Create UDP agent for the nodes and attach these agents to the nodes
STEP 6: The traffic generator used is UDP and measured in terms of cbr0 and cbr1
STEP 7: Configure node2 and node 3 as the null and attach it
STEP 8: Connect duplex links between the nodes
STEP 9: Create rtmodel and link between 5 and 11 is disconnected
STEP 10: Schedule the simulation for 50 milisec
#TO CREATE SIMULATOR OBJECT, TRACE FILE AND NAM FILE

set nr [open p6.tr w]
$ns trace-all $nr
#Using routing protocol

$ns rtproto LS
#Creation of Nodes
for {set i 0} {$i < 12} {incr i} {
set n($i) [$ns node]
}
#Creation of links
$ns duplex-link $n(0) $n(1) 1Mb 10ms DropTail
#Set up UDP connection

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

$ns attach-agent $n(5) $null0
$ns attach-agent $n(1) $udp1

$ns attach-agent $n(5) $null1
#Set up CBR over UDP connection


#Schedule events for CBR and FTP agents

$ns rtmodel-at 10.0 down $n(11) $n(5) ;# communication link between node 11
;#to 5 disconnected
$ns rtmodel-at 30.0 up $n(11) $n(5) ;# communication link between node 11
;#to 5 reconnected
$ns rtmodel-at 15.0 down $n(7) $n(6)

$ns rtmodel-at 20.0 up $n(7) $n(6)
$ns color 1 "green"

$ns color 2 "blue"
$udp0 set class_ 1

$udp1 set class_ 2
#Define procedure to clean up

proc finish { } {
global ns nr nf
$ns flush-trace
close $nf
close $nr
exec nam p6.nam &
exit 0
}

$ns at 50.0 "finish"
#Run the simulation

$ns run
#AWK SCRIPT:
BEGIN {
pksend = 0
pkreceive = 0
pkdrop = 0
pkrouting = 0
}
#Executed for each line of input file thru.tr

{
#For udp packets
if ( $1=="+" && ($3=="0" || $3=="1") && $5=="cbr" )
{
pksend++;
}
if ( $1=="r" && $4=="5" && $5=="cbr" )
{
pkreceive++;
}
if ( $1=="d" )
{
pkdrop++;
}
if ( $1=="r" && ($5=="rtProtoDV" || $5=="rtProtoLS") )
{
pkrouting++;
}
}
END {
print "No of send packets = " pksend
print "No of received packets = " pkreceive
print "No of dropped packets = " pkdrop
print "No of routing packets = " pkrouting
print "Normalized Overhead (routing/received), NOH = " pkrouting/pkreceive
print "Packet Delivery Ratio (received/send), PDR = " pkreceive/pksend
}
TOPOLOGY AND NAM:
OUTPUT:
No of Send Packets= 18959

No of Received Packets =13543
No of Dropped Packets= 4349
No of Routing Packets=656
PROBABLE/SUGGESTED QUESTION BANK
1. What are functions of different layers in OSI model?

2. Differentiate between TCP/IP Layers and OSI Layers.
3. Why header is required?
4. What is the use of adding header and trailer to frames?
5. What is encapsulation?
6. Why fragmentation requires?
7. What is MTU?
8. Which layer imposes MTU?
9. Differentiate between flow control and congestion control.
10. Differentiate between Point-to-Point Connection and End-to-End connections.
11. What are protocols running in different layers?
12. What is Protocol Stack?
13. Differentiate between TCP and UDP.
14. Differentiate between Connectionless and connection oriented connection.
15. Why frame sorting is required?
16. What is meant by subnet?
17. What is meant by Gateway?
18. What is an IP address?
19. What is MAC address?
20. Why IP address is required when we have MAC address?
21. What is meant by port?
22. What is a socket?
23. How do you classify congestion control algorithms?
24. Differentiate between Leaky bucket and Token bucket.
25. How do you implement Leaky bucket?
26. How do you generate busty traffic?
27. What is the polynomial used in CRC-CCITT?
28. What are the other error detection algorithms?
29. What is difference between CRC and Hamming code?
30. What is spanning tree?
31. What are Routing algorithms?
32. How do you classify routing algorithms? Give examples for each.
33. What are drawbacks in distance vector algorithm?
34. How routers update distances to each of its neighbor?
35. How do you overcome count to infinity problem?
36. What is cryptography?
37. How do you classify cryptographic algorithms?
38. What is public key?
39. What is private key?
40. What are key, ciphertext and plaintext?
41. What is simulation?
42. What are advantages of simulation?
43. Differentiate between route, bridge, switch and hub. \
44. Explain HDLC frame structure.
45. Explain about NS2.

CCN Lab Manual Ecl77

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

CCN Lab Manual Ecl77

Загружено:

Авторское право:

Доступные форматы

DEPARTMENT

Name of the Student :

DAYANANDA SAGAR COLLEGE OF ENGINEERING

Name of the Laboratory : COMPUTER COMMUNICATION LAB

Semester/Year : VII / 2018-19 (Autonomous)

Major Equipment‘s : Power Supply

Area in square meters : 109 Sq. Mtrs.

Total Cost of Lab : Rs. 37, 77,535/-

HOD : Dr. T.C. Manjunath, Ph.D. (IIT Bombay)

offers undergraduate, post-graduates and doctoral programmes under Visvesvaraya Technological

Visvesvaraya Technological University. It has widest choice of engineering branches having 16

room, R & D centre, etc…

MISSION OF THE DEPARTMENT

PEO-2: Competent in technical and soft skills to be employed with capability of

PEO-3: Professionals, capable of pursuing higher studies in technical, research or

PROGRAM SPECIFIC OUTCOMES [PSOs]

PSO-2: Apply knowledge of hardware and software in designing embedded and

Course code: ECL77 Credits : 2

1. To build the knowledge of networking protocols and interconnections.

CO 1 Apply the concepts of HDLC protocol for data communication

Mapping of Course Outcomes to Program Outcomes:

6 Implement Encryption and Decryption of a given message C02, CO3, CO5

1. Implementation of spanning tree algorithm

HARDWARE AND SOFTWARE REQUIREMENTS:

CIE –Continuous Internal Evaluation Lab (50 Marks)

ALGORITHM FOR BIT DE-STUFFING

char ch, array[50]={"01111110"},recd_array[50];

printf("Enter the original data stream for bit stuffing : \n");

printf("\nThe stuffed data stream is : %s \n",array);

if (counter==5) /* If five ones appear, delete the following zero */

printf(― the destuffed data stream is %s‖,recd_array);

printf("Enter the size=\n");

Enter the original data stream for bit stuffing:

ALGORITHM FOR CHARACTER STUFFING/DESTUFFING

/*Program to demonstrate character stuffing */

printf("Enter the data stream (Ctrl+B->STX, Ctrl+C->ETX, Ctrl+P->DLE) : \n");

Enter the data stream (Ctrl+B->STX, Ctrl+C->ETX, Ctrl+P->DLE) :

The algorithm for computing checksum is as follows:

The CRC-CCITT polynomial is x16 + x12 + x5 + 1

printf("\n the result is \n");

printf("\nEnter the stream for which CRC has to be checked : ");

Enter the data stream : 10011

SLIDING WINDOW PROTOCOL

Sliding Window on Sender Side

Sliding Window on Receiver Side

SLIDING WINDOW PROTOCOL

printf("Enter window size: ");

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

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

/*Total number of nodes in network*/

/*State of each node*/

struct node nodes[N];

/*Find minimum weighted Tentative node*/

printf("\nShortest Path got--->\n%c",dest+65);

2. Enter the Source: G

IMPLEMENT ENCRYPTION AND DECRYPTION OF A GIVEN MESSAGE.

In cryptography, the messages to be encrypted; known as plaintext, are transformed by a

Encryption Method Cipher C=Ek(P )

Decryption Method Plaintext P=DK(EK(P))

Encryption key-Ek, Decryption key-Dk, Plaintext-P

Encrypted data: dwwdfo

ALGORITHM FOR ENCRYPTION BY SUBSTITUTION METHOD:

1. Read data to be encoded

/Program to demonstrate character stuffing /

/Total number of nodes in network/

/State of each node/

/Find minimum weighted Tentative node/