V SEMESTER

[As per Choice Based Credit System (CBCS) scheme]

(Effective from the academic year 2018 -2019)

COMPUTER NETWORK LABORATORY

18CSL57
 DEPARTMENT OF COMPUTERSCIENCE AND ENGINEERING

VISION

”To Emanate as a Prime Source of Technical Education In The Field of

Engineering”.

MISSION
The Department of Computer Science And Engineering will Provide Transformative
education and Research to create, Contribute innovators and Leaders for society and
Industry

V SEMESTER

COMPUTER NETWORK LABORATORY

18CSL57

Signature of the Faculty Signature of the HOD

 COMPUTER NETWORK LABORATORY
(Effective from the academic year 2018 -2019)
SEMESTER – V
Course Code 18CSL57 CIE Marks 40
Number of Contact Hours/Week 0:2:2 SEE Marks 60
Total Number of Lab Contact Hours 36 Exam Hours 03
Credits – 2
Course Learning Objectives: This course (18CSL57) will enable students to:
 Demonstrate operation of network and its management commands
 Simulate and demonstrate the performance of GSM and CDMA
 Implement data link layer and transport layer protocols.
Descriptions (if any):
 For the experiments below modify the topology and parameters set for the experiment and take
multiple rounds of reading and analyze the results available in log files. Plot necessary graphs
and conclude. Use NS2/NS3.
 Installation procedure of the required software must be demonstrated, carried out in groups
and documented in the journal.
Programs List:
PART A
1. Implement three nodes point – to – point network with duplex links between them. Set
the
queue size, vary the bandwidth and find the number of packets dropped.
2. Implement transmission of ping messages/trace route over a network topology consisting of
6 nodes and find the number of packets dropped due to congestion.
3. Implement an Ethernet LAN using n nodes and set multiple traffic nodes and plot congestion
window for different source / destination.
4. Implement simple ESS and with transmitting nodes in wire-less LAN by simulation and
determine the performance with respect to transmission of packets.
5. Implement and study the performance of GSM on NS2/NS3 (Using MAC layer) or
equivalent environment.
6. Implement and study the performance of CDMA on NS2/NS3 (Using stack called Call net) or
equivalent environment
PART B (Implement the following in Java)
7. Write a program for error detecting code using CRC-CCITT (16- bits).
8. Write a program to find the shortest path between vertices using bellman-ford algorithm.
9. Using TCP/IP sockets, write a client – server program to make the client send the file name
and to make the server send back the contents of the requested file if present.
10. Write a program on datagram socket for client/server to display the messages on client side,
typed at the server side.
11. Write a program for simple RSA algorithm to encrypt and decrypt the data.
12. Write a program for congestion control using leaky bucket algorithm.
Laboratory Outcomes: The student should be able to:
 Analyze and Compare various networking protocols.
 Demonstrate the working of different concepts of networking.
 Implement, analyze and evaluate networking protocols in NS2 / NS3 and JAVA programming
language
Conduct of Practical Examination:
 Experiment distribution
CN Lab Manual-2021

o For laboratories having only one part: Students are allowed to pick one experiment
from the lot with equal opportunity.
o For laboratories having PART A and PART B: Students are allowed to pick one experi-
ment from PART A and one experiment from PART B, with equal opportunity.
 Change of experiment is allowed only once and marks allotted for procedure to be made zero of
the changed part only.
 Marks Distribution (Courseed to change in accoradance with university regulations)
i) For laboratories having only one part – Procedure + Execution + Viva-Voce: 15+70+15 =
100 Marks
j) For laboratories having PART A and PART B
i. Part A – Procedure + Execution + Viva = 6 + 28 + 6 = 40 Marks
ii. Part B – Procedure + Execution + Viva = 9 + 42 + 9 = 60 Marks

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 behaviours.

Basic Architecture of NS2

Fig 1: Basic Architecture of Network Simulator

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.

Dept of CSE /RRCE Page | 4

CN Lab Manual-2021

• It is not necessary to declare a data type for variable prior to the usage.

Basics of TCL
Syntax: command arg1 arg2 arg3
• Hello World!
puts stdout{Hello, World!}
Hello, World!
• Variables Command Substitution
set a 5 set len [string length foobar]
set b $a set len [expr [string length foobar] + 9]

• Simple
Arithmetic
expr 7.2 / 4

• Procedures
proc Diag {a b} {
set c [expr sqrt($a * $a + $b * $b)]
return $c }
puts “Diagonal of a 3, 4 right triangle is [Diag 3
4]” Output: Diagonal of a 3, 4 right triangle is 5.0

• Loops
while{$i < $n}
{
for {set i 0} {$i < $n} {incr i}
{ ...
...
}
}

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.

Dept of CSE /RRCE Page | 5

CN Lab Manual-2021

Initialization and Termination of TCL Script in NS-2 An ns simulation starts with the
command
set ns [new Simulator]

which is thus the first line in the tcl script? This line declares a new variable as using the set
command, you can call this variable as you wish, In general people declares it as ns because
it is an instance of the Simulator class, so an object the code [new Simulator] is indeed the
installation of the class Simulator using the reserved word new.
In order to have output files with data on the simulation (trace files) or files used
for visualization (nam files), we need to create the files using “open” command:

#Open the Trace set tracefile1 [open out.tr w]

file $ns trace-all $tracefile1

set namfile [open out.nam w]

#Open the NAM
trace file $ns namtrace-all $namfile

Dept of CSE /RRCE Page | 6

 The above creates a data 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 end the application and return the number 0 as
status to the system. Zero is the default for a clean exit. Other values can be used to say that
is a exit because something fails.
At the end of ns program, we should call the procedure “finish” and specify at what
time the termination should occur. For example,
$ns at 125.0 “finish”
will be used to call “finish” at time 125sec.Indeed, the at method of the simulator allows us
to schedule events explicitly.
The simulation can then begin using the command
$ns run

Definition of a network of links and nodes

The way to define a node is:

set n0 [$ns node]

We created a node that 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 Discard)
mechanism, the FQ (Fair Queuing), the DRR (Deficit Round Robin), the stochastic Fair
Queuing (SFQ) and the CBQ (which including a priority and a round-robin scheduler).
In ns, an output queue of a node is implemented as a part of each link whose input is
that node. We should also define the buffer capacity of the queue related to each link. An
example would be:
#set Queue Size of link (n0-n2) to 20

$ns queue-limit $n0 $n2 20

Agents and Applications

We need to define routing (sources, destinations) the agents (protocols) the
application that use them.
FTP over TCP
TCP is a dynamic reliable congestion control protocol. It uses Acknowledgements
created by the destination to know whether packets are well received.
There are number variants of the TCP protocol, such as Tahoe, Reno, NewReno, Vegas.
The type of agent appears in the first line:

set tcp [new Agent/TCP]

The command $ns attach-agent $n0 $tcp defines the source node of the
tcp connection.

set sink [new Agent /TCPSink]

The Command Defines the behaviour 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

set cbr [new Application/Traffic/CBR]
#setup a CBR over UDP connection
$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 colours 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”

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 Num id

1. The first field is the event type. It is given by one of four possible symbols r, +, -, d
which correspond respectively to receive (at the output of the link), enqueued, dequeued
and dropped.
2. The second field gives the time at which the event occurs.
3. Gives the input node of the link at which the event occurs.
4. Gives the output node of the link at which the event occurs.
5. Gives the packet type (eg CBR or TCP)
6. Gives the packet size
7. Some flags
8. 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. This is the source address given in the form of “node.port”.
10. This is the destination address, given in the same form.
11. 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. The last field shows the unique id of the packet.

Fig2: Working of NS2

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 up to 64 independent data
sets using different colours 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 colour 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”.
Awk- An Advanced
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 their 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
{ count =count+1
printf “ %3f %20s %-12s %d\n”, count,$2,$3,$6 }’ empn.lst
THE –f OPTION: STORING awk PROGRAMS INA FILE
You should hold 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
The FILENAME Variable: FILENAME stores the name of the current file being processed.
Like grep and sed, awk can also handle multiple filenames in the command line. By default,
awk doesn’t print the filename, but you can instruct it to do so:
‘$6<4000 {print FILENAME, $0 }’
With FILENAME, you can device logic that does different things depending on the file that
is processed.

Network Animator Window

 Fig3: Details of NAM Window

NS2 Installation
• NS2 is a free simulation tool.
• It runs on various platforms including UNIX (or Linux), Windows, and Mac systems.
• NS2 source codes are distributed in two forms: the all-in-one suite and the
component-wise.
• ‘all-in-one’ package provides an “install” script which configures the NS2 environment and
creates NS2 executable file using the “make” utility.

NS-2 installation steps in Linux

➢ Go to Computer File System now paste the zip file “ns-allinone-2.34.tar.gz” into opt
folder.
➢ Now unzip the file by typing the following command
[root@localhost opt] # tar -xzvf ns-allinone-2.34.tar.gz
➢ After the files get extracted, we get ns-allinone-2.34 folder as well as zip file ns-allinone-
2.34.tar.gz
[root@localhost opt] # ns-allinone-2.34 ns-allinone-2.34.tar.gz
➢ Now go to ns-allinone-2.33 folder and install
it [root@localhost opt] # cd ns-allinone-2.34
[root@localhost ns-allinone-2.33] # ./install
➢ Once the installation is completed successfully we get certain pathnames in that
terminal which must be pasted in “.bash_profile” file.
➢ First minimize the terminal where installation is done and open a new terminal and
open the file “.bash_profile”
[root@localhost ~] # vi .bash_profile
➢ When we open this file, we get a line in that file which is shown below
 PATH=$PATH:$HOME/bin
To this line we must paste the path which is present in the previous terminal where ns
was installed. First put “:” then paste the path in-front of bin. That path is shown below.
“:/opt/ns-allinone-2.33/bin:/opt/ns-allinone-2.33/tcl8.4.18/unix:/opt/ns-
allinone-2.33/tk8.4.18/unix”.
➢ In the next line type “LD_LIBRARY_PATH=$LD_LIBRARY_PATH:” and paste the
two paths separated by “:” which are present in the previous terminal i.e Important notices
section (1)

“/opt/ns-allinone-2.33/otcl-1.13:/opt/ns-allinone-2.33/lib”
➢ In the next line type “TCL_LIBRARY=$TCL_LIBRARY:” and paste the path which is
present in previous terminal i.e Important Notices section (2)
“/opt/ns-allinone-2.33/tcl8.4.18/library”
➢ In the next line type “export LD_LIBRARY_PATH”
➢ In the next line type “export TCL_LIBRARY”
➢ The next two lines are already present the file “export PATH” and “unset USERNAME”
➢ Save the program ( ESC + shift : wq and press enter )
➢ Now in the terminal where we have opened .bash_profile file, type the following
command to check if path is updated correctly or not
[root@localhost ~] # vi .bash_profile
[root@localhost ~] # source .bash_profile
➢ If path is updated properly, then we will get the prompt as shown
below [root@localhost ~] #
➢ Now open the previous terminal where you have installed ns
[root@localhost ns-allinone-2.33] #
➢ Here we need to configure three packages “ns-2.33”, “nam-1.13” and “xgraph-12.1”
➢ First, configure “ns-2.33” package as shown below
[root@localhost ns-allinone-2.33] # cd ns-2.33
[root@localhost ns-2.33] # ./configure
[root@localhost ns-2.33] # make clean
[root@localhost ns-2.33] # make
[root@localhost ns-2.33] # make install
[root@localhost ns-2.33] # ns
%
➢ If we get “%” symbol it indicates that ns-2.33 configuration was successful.
➢ Second, configure “nam-1.13” package as shown below
[root@localhost ns-2.33] # cd . . [root@localhost
ns-allinone-2.33] # cd nam-1.13 [root@localhost
nam-1.13] # ./configure [root@localhost nam-
1.13] # make clean [root@localhost nam-1.13] #
make [root@localhost nam-1.13] # make install
[root@localhost nam-1.13] # ns

%
➢ If we get “%” symbol it indicates that nam-1.13 configuration was successful.
➢ Third, configure “xgraph-12.1” package as shown below
[root@localhost nam-1.13] # cd . . [root@localhost
ns-allinone-2.33] # cd xgraph-12.1 [root@localhost
xgraph-12.1] # ./configure [root@localhost xgraph-
12.1] # make clean [root@localhost xgraph-12.1] #
make [root@localhost xgraph-12.1] # make install
[root@localhost xgraph-12.1] # ns
 %
This completes the installation process of “NS-2” simulator.
 PART-A

1. Implement three nodes point – to – point network with duplex links between them.
Set the queue size, vary the bandwidth and find the number of packets dropped.

set ns [ new Simulator ] /* Letter S is capital */

set nf [ open p1.nam w ] /* open a nam trace file in write mode */
$ns namtrace-all $nf /* nf – nam file */

set tf [ open p1.tr w ] /* tf- trace file */

$ns trace-all $tf

proc finish {} { /* provide space b/w proc and finish and all are in small case */
global ns nf tf
$ns flush-trace
close $nf
close $tf
exec nam p1.nam &
exit 0
}

set n0 [$ns node] /* creates 4 nodes */

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

$ns duplex-link $n0 $n2 200Mb 10ms DropTail /*Letter M is capital Mb*/
$ns duplex-link $n1 $n2 100Mb 5ms DropTail /*D and T are capital*/ $ns
$ns duplex-link $n2 $n3 1Mb 1000ms DropTail

$ns queue-limit $n0 $n2 10

$ns queue-limit $n1 $n2 10

set udp0 [new Agent/UDP] /* Letters A,U,D and P are capital */

$ns attach-agent $n0 $udp0

set cbr0 [new Application/Traffic/CBR] /* A,T,C,B and R are capital*/

$cbr0 set packetSize_ 500 /*S is capital, space after underscore*/
$cbr0 set interval_ 0.005
$cbr0 attach-agent $udp0

set udp1 [new Agent/UDP]

$ns attach-agent $n1 $udp1

set cbr1 [new Application/Traffic/CBR]

$cbr1 attach-agent $udp1

set udp2 [new Agent/UDP]

$ns attach-agent $n2 $udp2

set cbr2 [new Application/Traffic/CBR]

$cbr2 attach-agent $udp2

set null0 [new Agent/Null] /* A and N are capital */

$ns attach-agent $n3 $null0
$ns connect $udp0 $null0
$ns connect $udp1 $null0

$ns at 0.1 "$cbr0 start"

$ns at 0.2 "$cbr1 start"
$ns at 1.0 "finish"

$ns run

AWK file (Open a new editor using “vi command” and write awk file and save with
“.awk” extension)
/*immediately after BEGIN should open braces ‘{‘
BEGIN {
c=0;
}
{
If ($1= ="d")
{
c++;
printf("%s\t%s\n",$5,$11);
}
}
/*immediately after END should open braces ‘{‘
END{
printf("The number of packets dropped =%d\n",c);
}

Steps for execution

1) Open vi editor and type program. Program name should have the extension “ .tcl ”
[root@localhost ~]# vi p1.tcl
2) Save the program by pressing “ESC key” first, followed by “Shift and :” keys
simultaneously and type “wq” and press Enter key.
3) Open vi editor and type awk program. Program name should have the extension
“.awk ”
[root@localhost ~]# vi p1.awk
4) Save the program by pressing “ESC key” first, followed by “Shift and :” keys
simultaneously and type “wq” and press Enter key.

5) Run the simulation program

[root@localhost~]# ns p1.tcl
i) Here “ns” indicates network simulator. We get the topology shown in the snapshot.
ii) Now press the play button in the simulation window and the simulation
will begins.
6) After simulation is completed run awk file to see the output ,
[root@localhost~]# awk –f p1.awk p1.tr
7) To see the trace file contents open the file as ,
[root@localhost~]# vi p1.tr

Trace file contains 12 columns:-

Event type, Event time, From Node, Source Node, Packet Type, Packet Size, Flags
(indicated by --------), Flow ID, Source address, Destination address, Sequence ID,
Packet ID
Topology
 Note:
1. Set the queue size fixed from n0 to n2 as 10, n1-n2 to 10 and from n2-n3 as
5. Syntax: To set the queue size
$ns set queue-limit <from> <to> <size>
Eg: $ns set queue-limit $n0 $n2 10
2. Go on varying the bandwidth from 10, 20 30 . . and find the number of
packets dropped at the node 2

2. Implement transmission of ping messages/trace route over a network topology

consisting of 6 nodes and find the number of packets dropped due to congestion.

set ns [ new Simulator ]

set nf [ open p2.nam w ]
$ns namtrace-all $nf
set tf [ open p2.tr w ]
$ns trace-all $tf
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
set n5 [$ns node]

$ns duplex-link $n0 $n4 1005Mb 1ms DropTail

$ns duplex-link $n1 $n4 50Mb 1ms DropTail
$ns duplex-link $n2 $n4 2000Mb 1ms DropTail
$ns duplex-link $n3 $n4 200Mb 1ms DropTail
$ns duplex-link $n4 $n5 1Mb 1ms DropTail

set p1 [new Agent/Ping]

$ns attach-agent $n0 $p1
$p1 set packetSize_ 50000
$p1 set interval_ 0.0001
set p2 [new Agent/Ping]
$ns attach-agent $n1 $p2

set p3 [new Agent/Ping]

$ns attach-agent $n2 $p3
$p3 set packetSize_ 30000
$p3 set interval_ 0.00001

set p4 [new Agent/Ping]

$ns attach-agent $n3 $p4

set p5 [new Agent/Ping]

$ns attach-agent $n5 $p5

$ns queue-limit $n0 $n4 5

$ns queue-limit $n2 $n4 3
$ns queue-limit $n4 $n5 2
Agent/Ping instproc recv {from rtt} {
$self instvar node_
puts "node [$node_ id]received answer from $from with round trip time $rtt msec"
}
$ns connect $p1 $p5
$ns connect $p3 $p4

proc finish { } {
global ns nf tf
$ns flush-trace
close $nf
close $tf
exec nam p2.nam &
exit 0
}
$ns at 0.1 "$p1 send"
$ns at 0.2 "$p1 send"
$ns at 0.3 "$p1 send"
$ns at 0.4 "$p1 send"
$ns at 0.5 "$p1 send"
$ns at 0.6 "$p1 send"
$ns at 0.7 "$p1 send"
$ns at 0.8 "$p1 send"
$ns at 0.9 "$p1 send"
$ns at 1.0 "$p1 send"
$ns at 1.1 "$p1 send"
$ns at 1.2 "$p1 send"
$ns at 1.3 "$p1 send"
$ns at 1.4 "$p1 send"
$ns at 1.5 "$p1 send"
$ns at 1.6 "$p1 send"
$ns at 1.7 "$p1 send"
$ns at 1.8 "$p1 send"
$ns at 1.9 "$p1 send"
$ns at 2.0 "$p1 send"
$ns at 2.1 "$p1 send"
$ns at 2.2 "$p1 send"
$ns at 2.3 "$p1 send"
$ns at 2.4 "$p1 send"
$ns at 2.5 "$p1 send"
$ns at 2.6 "$p1 send"
$ns at 2.7 "$p1 send"
$ns at 2.8 "$p1 send"
$ns at 2.9 "$p1 send"

$ns at 0.1 "$p3 send"

$ns at 0.2 "$p3 send"
$ns at 0.3 "$p3 send"
$ns at 0.4 "$p3 send"
$ns at 0.5 "$p3 send"
$ns at 0.6 "$p3 send"
$ns at 0.7 "$p3 send"
$ns at 0.8 "$p3 send"
$ns at 0.9 "$p3 send"
$ns at 1.0 "$p3 send"
$ns at 1.1 "$p3 send"
$ns at 1.2 "$p3 send"
$ns at 1.3 "$p3 send"
$ns at 1.4 "$p3 send"
$ns at 1.5 "$p3 send"
$ns at 1.6 "$p3 send"
$ns at 1.7 "$p3 send"
$ns at 1.8 "$p3 send"
$ns at 1.9 "$p3 send"
$ns at 2.0 "$p3 send"
$ns at 2.1 "$p3 send"
$ns at 2.2 "$p3 send"
$ns at 2.3 "$p3 send"
$ns at 2.4 "$p3 send"
$ns at 2.5 "$p3 send"
$ns at 2.6 "$p3 send"
$ns at 2.7 "$p3 send"
$ns at 2.8 "$p3 send"
$ns at 2.9 "$p3 send"
$ns at 3.0 "finish"
$ns run

AWK file (Open a new editor using “vi command” and write awk file and save with
“.awk” extension)

BEGIN{
drop=0;
}
{
if($1=="d")
{
drop++;
}
}
END{
printf("Total number of %s packets dropped due to congestion =%d\n",$5,drop);
}

Steps for execution

1) Open vi editor and type program. Program name should have the extension “ .tcl ”
[root@localhost ~]# vi p2.tcl
2) Save the program by pressing “ESC key” first, followed by “Shift and :”
keys simultaneously and type “wq” and press Enter key.
3) Open vi editor and type awk program. Program name should have the extension
“.awk ”
[root@localhost ~]# vi p2.awk
4) Save the program by pressing “ESC key” first, followed by “Shift and :”
keys simultaneously and type “wq” and press Enter key.
5) Run the simulation program
[root@localhost~]# ns p2.tcl
i) Here “ns” indicates network simulator. We get the topology shown in
the snapshot.
ii) Now press the play button in the simulation window and the simulation
will begins.
6) After simulation is completed run awk file to see the output ,
[root@localhost~]# awk –f p2.awk p2.tr
7) To see the trace file contents open the file as ,
[root@localhost~]# vi p2.tr

Topology
 Note:
Vary the bandwidth and queue size between the nodes n0-n2 , n2-n4. n6-n2 and n2- n5
and see the number of packets dropped at the nodes.

3. Implement an Ethernet LAN using n nodes and set multiple traffic nodes and
plot congestion window for different source / destination.

set ns [new Simulator]

set tf [open p3.tr w]
$ns trace-all $tf
set nf [open p3.nam w]
$ns namtrace-all $nf

set n0 [$ns node]

$n0 color "magenta"
$n0 label "src1"
set n1 [$ns node]
set n2 [$ns node]
$n2 color "magenta"
$n2 label "src2"
set n3 [$ns node]
$n3 color "blue"
$n3 label "dest2"
set n4 [$ns node]
set n5 [$ns node]
$n5 color "blue"
$n5 label "dest1"

$ns make-lan "$n0 $n1 $n2 $n3 $n4" 100Mb 100ms LL Queue/DropTail Mac/802_3
$ns duplex-link $n4 $n5 1Mb 1ms DropTail

set tcp0 [new Agent/TCP]

$ns attach-agent $n0 $tcp0
set ftp0 [new Application/FTP]
$ftp0 attach-agent $tcp0
$ftp0 set packetSize_ 500
$ftp0 set interval_ 0.0001
set sink5 [new Agent/TCPSink]
$ns attach-agent $n5 $sink5

$ns connect $tcp0 $sink5

set tcp2 [new Agent/TCP]

$ns attach-agent $n2 $tcp2
set ftp2 [new Application/FTP]
$ftp2 attach-agent $tcp2
$ftp2 set packetSize_ 600
$ftp2 set interval_ 0.001
set sink3 [new Agent/TCPSink]
$ns attach-agent $n3 $sink3

$ns connect $tcp2 $sink3

set file1 [open file1.tr w]

$tcp0 attach $file1
set file2 [open file2.tr w]
$tcp2 attach $file2

$tcp0 trace cwnd_

$tcp2 trace cwnd_

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

$ns at 0.1 "$ftp0 start"

$ns at 5 "$ftp0 stop"
$ns at 7 "$ftp0 start"
$ns at 0.2 "$ftp2 start"
$ns at 8 "$ftp2 stop"
$ns at 14 "$ftp0 stop"
$ns at 10 "$ftp2 start"
$ns at 15 "$ftp2 stop"
$ns at 16 "finish"
$ns run

AWK file (Open a new editor using “vi command” and write awk file and save with
“.awk” extension)

cwnd:- means congestion window

BEGIN {
}
{
if($6=="cwnd_") # don’t leave space after writing cwnd_
printf("%f\t%f\t\n",$1,$7); # you must put \n in printf
}
END {
}
Steps for execution
1) Open vi editor and type program. Program name should have the extension “ .tcl ”
[root@localhost ~]# vi p3.tcl
2) Save the program by pressing “ESC key” first, followed by “Shift and :” keys
simultaneously and type “wq” and press Enter key.
3) Open vi editor and type awk program. Program name should have the extension
“.awk ”
[root@localhost ~]# vi p3.awk
4) Save the program by pressing “ESC key” first, followed by “Shift and :” keys
simultaneously and type “wq” and press Enter key.
5) Run the simulation program
[root@localhost~]# ns p3.tcl
6) After simulation is completed run awk file to see the output ,
i. [root@localhost~]# awk –f p3.awk file1.tr > a1
ii. [root@localhost~]# awk –f p3.awk file2.tr > a2
iii. [root@localhost~]# xgraph a1 a2
7) Here we are using the congestion window trace files i.e. file1.tr and file2.tr and we
are redirecting the contents of those files to new files say a1 and a2 using output
redirection operator (>).
8) To see the trace file contents open the file as ,
[root@localhost~]# vi p3.tr
Topology
4. Implement simple ESS and with transmitting nodes in wire-less LAN by simulation
and determine the performance with respect to transmission of packets.

set ns [new Simulator]

set tf [open p4.tr w]
$ns trace-all $tf
set topo [new Topography]
$topo load_flatgrid 1000 1000
set nf [open p4.nam w]
$ns namtrace-all-wireless $nf 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"

$n0 set X_ 50
$n0 set Y_ 50
$n0 set Z_ 0
$n1 set X_ 100
$n1 set Y_ 100
$n1 set Z_ 0
$n2 set X_ 600
$n2 set Y_ 600
$n2 set Z_ 0

$ns at 0.1 "$n0 setdest 50 50 500"

$ns at 0.1 "$n1 setdest 100 100 500"
$ns at 0.1 "$n2 setdest 600 600 500"

set tcp0 [new Agent/TCP]

$ns attach-agent $n0 $tcp0

set ftp0 [new Application/FTP]

$ftp0 attach-agent $tcp0

set sink1 [new Agent/TCPSink]

$ns attach-agent $n1 $sink1
$ns connect $tcp0 $sink1

set tcp1 [new Agent/TCP]

$ns attach-agent $n1 $tcp1

set ftp1 [new Application/FTP]

$ftp1 attach-agent $tcp1

set sink2 [new Agent/TCPSink]

$ns attach-agent $n2 $sink2
$ns connect $tcp1 $sink2

$ns at 5 "$ftp0 start"

$ns at 5 "$ftp1 start"

$ns at 100 "$n1 setdest 550 550 15"

$ns at 190 "$n1 setdest 70 70 15"

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

$ns at 250 "finish"

$ns run

AWK file (Open a new editor using “vi command” and write awk file and save with
“.awk” extension)

BEGIN{
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: %f Mbps\n",((count1*pack1*8)/(time1*1000000)));
printf("The Throughput from n1 to n2: %f Mbps",((count2*pack2*8)/(time2*1000000)));
}

Steps for execution

1) Open vi editor and type program. Program name should have the extension “ .tcl ”
[root@localhost ~]# vi p4.tcl
2) Save the program by pressing “ESC key” first, followed by “Shift and :” keys
simultaneously and type “wq” and press Enter key.
3) Open vi editor and type awk program. Program name should have the extension
“.awk ”
[root@localhost ~]# vi p4.awk
4) Save the program by pressing “ESC key” first, followed by “Shift and :” keys
simultaneously and type “wq” and press Enter key.
5) Run the simulation program
[root@localhost~]# ns p4.tcl
i) Here “ns” indicates network simulator. We get the topology shown in the
snapshot.
ii) Now press the play button in the simulation window and the simulation
will begins.
6) After simulation is completed run awk file to see the output ,
[root@localhost~]# awk –f p4.awk p4.tr
7) To see the trace file contents open the file as ,
[root@localhost~]# vi p4.tr
Topology
Trace file
Here “M” indicates mobile nodes, “AGT” indicates Agent Trace, “RTR” indicates Router
Trace

5. Implement and study the performance of GSM on NS2/NS3 (Using MAC layer)
or equivalent environment.

Second Generation (2G) technology is based on the technology known as global

system for mobile communication (GSM). This technology enabled various networks to
provide services like text messages, picture messages and MMS. The technologies used in 2G
are either TDMA (Time Division Multiple Access) which divides signal into different time
slots or CDMA (Code Division Multiple Access) which allocates a special code to each user
so as to communicate over a multiplex physical channel.
GSM uses a variation of time division multiple access (TDMA). 2G networks
developed as a replacement for first generation (1G) analog cellular networks, and the GSM
standard originally described as a digital, circuit-switched network optimized for full duplex
voice telephony. This expanded over time to include data communications, first by circuit-
switched transport, then by packet data transport via GPRS (General Packet Radio Services).

GSM can be implemented on all the versions of NS2 (Since year 2004: ns-2.27, and later
versions of NS2)

Design:

Note: Save the program in the following path.

jss@jss-OptiPlex-3046:~$ cd ns-allinone-2.35/

jss@jss-OptiPlex-3046:~/ns-allinone-2.35$ cd ns-2.35/

jss@jss-OptiPlex-3046:~/ns-allinone-2.35/ns-2.35$ cd tcl/

jss@jss-OptiPlex-3046:~/ns-allinone-2.35/ns-2.35/tcl$ cd ex/

jss@jss-OptiPlex-3046:~/ns-allinone-2.35/ns-2.35/tcl/ex$ cd wireless-scripts/

jss@jss-OptiPlex-3046:~/ns-allinone-2.35/ns-2.35/tcl/ex/wireless-scripts$ gedit p5.tcl

# General Parameters
set stop 100 ;# Stop time.
# Topology
set type gsm ;#type of link:
# AQM parameters
set minth 0 ;
set maxth 30 ;
set adaptive 1 ;# 1 for Adaptive RED, 0 for plain RED
# Traffic generation.
set flows 0 ;# number of long-lived TCP flows
set window 30 ;# window for long-lived traffic
set web 2 ;# number of web sessions
# Plotting statics.
set opt(wrap) 100 ;# wrap plots?
set opt(srcTrace) is ;# where to plot traffic
set opt(dstTrace) bs2 ;# where to plot traffic

#default downlink bandwidth in bps

set bwDL(gsm) 9600
#default uplink bandwidth in bps
set bwUL(gsm) 9600
#default downlink propagation delay in seconds
set propDL(gsm) .500
#default uplink propagation delay in seconds
set propUL(gsm) .500

set ns [new Simulator]

set tf [open out.tr w]
$ns trace-all $tf

set nodes(is) [$ns node]

set nodes(ms) [$ns node]
set nodes(bs1) [$ns node]
set nodes(bs2) [$ns node]
set nodes(lp) [$ns node]

proc cell_topo {} {
global ns nodes
$ns duplex-link $nodes(lp) $nodes(bs1) 3Mbps 10nodes(ms) DropTail
$ns duplex-link $nodes(bs1) $nodes(ms) 1 1 RED
$ns duplex-link $nodes(ms) $nodes(bs2) 1 1 RED
$ns duplex-link $nodes(bs2) $nodes(is) 3Mbps 50nodes(ms) DropTail
puts " GSM Cell Topology"
}
proc set_link_para {t} {
global ns nodes bwUL bwDL propUL propDL buf
$ns bandwidth $nodes(bs1) $nodes(ms) $bwDL($t) duplex
$ns bandwidth $nodes(bs2) $nodes(ms) $bwDL($t) duplex
$ns delay $nodes(bs1) $nodes(ms) $propDL($t) duplex
$ns delay $nodes(bs2) $nodes(ms) $propDL($t) duplex
$ns queue-limit $nodes(bs1) $nodes(ms) 10
$ns queue-limit $nodes(bs2) $nodes(ms) 10
}
# RED and TCP parameters
Queue/RED set adaptive_ $adaptive
Queue/RED set thresh_ $minth
Queue/RED set maxthresh_ $maxth
Agent/TCP set window_ $window

source web.tcl

#Create topology
switch $type {
gsm -
gprs -
umts {cell_topo}
}
set_link_para $type
$ns insert-delayer $nodes(ms) $nodes(bs1) [new Delayer]
$ns insert-delayer $nodes(ms) $nodes(bs2) [new Delayer]

# Set up forward TCP connection

if {$flows == 0} {
set tcp1 [$ns create-connection TCP/Sack1 $nodes(is) TCPSink/Sack1 $nodes(lp) 0]
set ftp1 [[set tcp1] attach-app FTP]
$ns at 0.8 "[set ftp1] start"
}
if {$flows > 0} {
set tcp1 [$ns create-connection TCP/Sack1 $nodes(is) TCPSink/Sack1 $nodes(lp) 0]
set ftp1 [[set tcp1] attach-app FTP]
$tcp1 set window_ 100
$ns at 0.0 "[set ftp1] start"
$ns at 3.5 "[set ftp1] stop"
set tcp2 [$ns create-connection TCP/Sack1 $nodes(is) TCPSink/Sack1 $nodes(lp) 0]
set ftp2 [[set tcp2] attach-app FTP]
$tcp2 set window_ 3
$ns at 1.0 "[set ftp2] start"
$ns at 8.0 "[set ftp2] stop"
}

proc stop {} {
global nodes opt nf
set wrap $opt(wrap)
set sid [$nodes($opt(srcTrace)) id]
set did [$nodes($opt(dstTrace)) id]
set a "out.tr"
set GETRC "../../../bin/getrc"
set RAW2XG "../../../bin/raw2xg"
exec $GETRC -s $sid -d $did -f 0 out.tr | \
 $RAW2XG -s 0.01 -m $wrap -r > plot.xgr
exec $GETRC -s $did -d $sid -f 0 out.tr | \
$RAW2XG -a -s 0.01 -m $wrap >> plot.xgr
exec xgraph -x time -y packets plot.xgr &
exit 0
}
$ns at $stop "stop"
$ns run

6. Implement and study the performance of CDMA on NS2/NS3 (Using stack called
Call net) or equivalent environment.

3G networks developed as a replacement for second generation (2G) GSM standard

network with full duplex voice telephony. CDMA is used as the access method in many
mobile phone standards. IS-95, also called cdmaOne, and its 3G evolution CDMA2000, are
often simply referred to as CDMA, but UMTS(The Universal Mobile Telecommunications
System is a third generation mobile cellular system for networks based on the GSM
standard.), the 3G standard used by GSM carriers, also uses wideband CDMA. Long-Term
Evolution (LTE) is a standard for high-speed wireless communication which uses CDMA
network technology.
3G technology generally refers to the standard of accessibility and speed of mobile
devices. The standards of the technology were set by the International Telecommunication
Union (ITU). This technology enables use of various services like GPS (Global Positioning
System), mobile television and video conferencing. It not only enables them to be used
worldwide, but also provides with better bandwidth and increased speed. The main aim of
this technology is to allow much better coverage and growth with minimum investment.

CDMA can be implemented on all the versions of NS2 (Since year 2004: ns-2.27, and later
versions of NS2)

Design:
Note: Save the program in the following path.

jss@jss-OptiPlex-3046:~$ cd ns-allinone-2.35/
jss@jss-OptiPlex-3046:~/ns-allinone-2.35$ cd ns-2.35/
jss@jss-OptiPlex-3046:~/ns-allinone-2.35/ns-2.35$ cd tcl/
jss@jss-OptiPlex-3046:~/ns-allinone-2.35/ns-2.35/tcl$ cd ex/
jss@jss-OptiPlex-3046:~/ns-allinone-2.35/ns-2.35/tcl/ex$ cd wireless-scripts/
jss@jss-OptiPlex-3046:~/ns-allinone-2.35/ns-2.35/tcl/ex/wireless-scripts$ gedit p6.tcl

# General Parameters
set stop 100 ;# Stop time.
# Topology
set type cdma ;#type of link:
# AQM parameters
set minth 0 ;
set maxth 30 ;
set adaptive 1 ;# 1 for Adaptive RED, 0 for plain RED
# Traffic generation.
set flows 0 ;# number of long-lived TCP flows
set window 30 ;# window for long-lived traffic
set web 2 ;# number of web sessions
# Plotting statics.
set opt(wrap) 100 ;# wrap plots?
set opt(srcTrace) is ;# where to plot traffic
set opt(dstTrace) bs2 ;# where to plot traffic

#default downlink bandwidth in bps

set bwDL(cdma) 384000
#default uplink bandwidth in bps
set bwUL(cdma) 64000
#default downlink propagation delay in seconds
set propDL(cdma) .150
#default uplink propagation delay in seconds
set propUL(cdma) .150

set ns [new Simulator]

set tf [open out.tr w]
$ns trace-all $tf

set nodes(is) [$ns node]

set nodes(ms) [$ns node]
set nodes(bs1) [$ns node]
set nodes(bs2) [$ns node]
set nodes(lp) [$ns node]

proc cell_topo {} {
global ns nodes
$ns duplex-link $nodes(lp) $nodes(bs1) 3Mbps 10nodes(ms) DropTail
$ns duplex-link $nodes(bs1) $nodes(ms) 1 1 RED
 $ns duplex-link $nodes(ms) $nodes(bs2) 1 1 RED
$ns duplex-link $nodes(bs2) $nodes(is) 3Mbps 50nodes(ms) DropTail
puts " cdma Cell Topology"
}
proc set_link_para {t} {
global ns nodes bwUL bwDL propUL propDL buf
$ns bandwidth $nodes(bs1) $nodes(ms) $bwDL($t) duplex
$ns bandwidth $nodes(bs2) $nodes(ms) $bwDL($t) duplex
$ns delay $nodes(bs1) $nodes(ms) $propDL($t) duplex
$ns delay $nodes(bs2) $nodes(ms) $propDL($t) duplex
$ns queue-limit $nodes(bs1) $nodes(ms) 20
$ns queue-limit $nodes(bs2) $nodes(ms) 20
}
# RED and TCP parameters
Queue/RED set adaptive_ $adaptive
Queue/RED set thresh_ $minth
Queue/RED set maxthresh_ $maxth
Agent/TCP set window_ $window

source web.tcl

#Create topology
switch $type {

cdma {cell_topo}
}
set_link_para $type
$ns insert-delayer $nodes(ms) $nodes(bs1) [new Delayer]
$ns insert-delayer $nodes(ms) $nodes(bs2) [new Delayer]

# Set up forward TCP connection

if {$flows == 0} {
set tcp1 [$ns create-connection TCP/Sack1 $nodes(is) TCPSink/Sack1 $nodes(lp) 0]
set ftp1 [[set tcp1] attach-app FTP]
$ns at 0.8 "[set ftp1] start"
}
if {$flows > 0} {
set tcp1 [$ns create-connection TCP/Sack1 $nodes(is) TCPSink/Sack1 $nodes(lp) 0]
set ftp1 [[set tcp1] attach-app FTP]
$tcp1 set window_ 100
$ns at 0.0 "[set ftp1] start"
$ns at 3.5 "[set ftp1] stop"
set tcp2 [$ns create-connection TCP/Sack1 $nodes(is) TCPSink/Sack1 $nodes(lp) 0]
set ftp2 [[set tcp2] attach-app FTP]
$tcp2 set window_ 3
$ns at 1.0 "[set ftp2] start"
$ns at 8.0 "[set ftp2] stop"
}

proc stop {} {
global nodes opt nf
set wrap $opt(wrap)
set sid [$nodes($opt(srcTrace)) id]
 set did [$nodes($opt(dstTrace)) id]
set a "out.tr"
set GETRC "../../../bin/getrc"
set RAW2XG "../../../bin/raw2xg"
exec $GETRC -s $sid -d $did -f 0 out.tr | \
$RAW2XG -s 0.01 -m $wrap -r > plot.xgr
exec $GETRC -s $did -d $sid -f 0 out.tr | \
$RAW2XG -a -s 0.01 -m $wrap >> plot.xgr
exec xgraph -x time -y packets plot.xgr &
exit 0
}
$ns at $stop "stop"
$ns run

PART-B
Java is a general-purpose computer programming language that is simple, concurrent,
class-based, object-oriented language. The compiled Java code can run on all platforms that
support Java without the need for recompilation hence Java is called as "write once, run
anywhere" (WORA).The Java compiled intermediate output called “byte-code” that can run
on any Java virtual machine (JVM) regardless of computer architecture. The language derives
much of its syntax from C and C++, but it has fewer low-level facilities than either of them.
In Linux operating system Java libraries are preinstalled. It’s very easy and convenient
to compile and run Java programs in Linux environment. To compile and run Java Program
is a two-step process:

1. Compile Java Program from Command Prompt

[root@host ~]# javac Filename.java

The Java compiler (Javac) compiles java program and generates a byte-code with the
same file name and .class extension.
2. Run Java program from Command Prompt
[root@host ~]# java Filename

The java interpreter (Java) runs the byte-code and gives the respective output. It is
important to note that in above command we have omitted the .class suffix of the
byte-code (Filename.class).

1. Write a program for error detecting code using CRC-CCITT (16- bits).

Whenever digital data is stored or interfaced, data corruption might occur. Since the
beginning of computer science, developers have been thinking of ways to deal with this type of
problem. For serial data they came up with the solution to attach a parity bit to each sent byte.
This simple detection mechanism works if an odd number of bits in a byte changes, but an even
number of false bits in one byte will not be detected by the parity check. To overcome this
problem developer have searched for mathematical sound mechanisms to detect multiple false
bits. The CRC calculation or cyclic redundancy check was the result of this. Nowadays CRC
calculations are used in all types of communications. All packets sent over a network connection
are checked with a CRC. Also each data block on your hard disk has a CRC value attached to it.
Modern computer world cannot do without these CRC calculations. So let's see why they are so
widely used. The answer is simple; they are powerful, detect many types of errors and are
extremely fast to calculate especially when dedicated hardware chips are used.
The idea behind CRC calculation is to look at the data as one large binary number. This
number is divided by a certain value and the remainder of the calculation is called the CRC.
Dividing in the CRC calculation at first looks to cost a lot of computing power, but it can be
performed very quickly if we use a method similar to the one learned at school. We will as an
example calculate the remainder for the character 'm'—which is 1101101 in binary notation— by
dividing it by 19 or 10011. Please note that 19 is an odd number. This is necessary as we will see
further on. Please refer to your schoolbooks as the binary calculation method here is not very
different from the decimal method you learned when you were young. It might only look a little
bit strange. Also notations differ between countries, but the method is similar.
With decimal calculations you can quickly check that 109 divided by 19 gives a quotient of 5
with 14 as the remainder. But what we also see in the scheme is that every bit extra to check
only costs one binary comparison and in 50% of the cases one binary subtraction. You can
easily increase the number of bits of the test data string—for example to 56 bits if we use our
example value "Lammert"—and the result can be calculated with 56 binary comparisons and
an average of 28 binary subtractions. This can be implemented in hardware directly with only
very few transistors involved. Also software algorithms can be very efficient.

All of the CRC formulas you will encounter are simply checksum algorithms based on
modulo-2 binary division where we ignore carry bits and in effect the subtraction will be
equal to an exclusive or operation. Though some differences exist in the specifics across
different CRC formulas, the basic mathematical process is always the same:

• The message bits are appended with c zero bits; this augmented message is the dividend
• A predetermined c+1-bit binary sequence, called the generator polynomial, is the divisor
• The checksum is the c-bit remainder that results from the division operation

Table 1 lists some of the most commonly used generator polynomials for 16- and 32-bit
CRCs. Remember that the width of the divisor is always one bit wider than the remainder.
So, for example, you’d use a 17-bit generator polynomial whenever a 16-bit checksum is
required.

CRC-CCITT CRC-16 CRC-32

Checksum
16 bits 16 bits 32 bits
Width

Generator
10001000000100001 11000000000000101 100000100110000010001110110110111
Polynomial

International Standmard CRC Polynomials

Source Code:

import java.io.*;
import java.*;

public class p7
{

public static void main(String a[]) throws IOException

{
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
int[] message;
int[] gen;
int[] app_message;
int[] rem;
int[] trans_message;
int message_bits,gen_bits, total_bits;

System.out.println("\n Enter number of bits in massege:");

message_bits=Integer.parseInt(br.readLine());
message=new int[message_bits];
System.out.println("\n Enter message bits:");
for(int i=0;i<message_bits;i++)
message[i]=Integer.parseInt(br.readLine());
System.out.println("\n Enter number of bits in gen:");
gen_bits=Integer.parseInt(br.readLine());
gen = new int [gen_bits];
System.out.println("\n Enter gen bits :");
for(int i=0; i< gen_bits; i++)
{
gen[i]=Integer.parseInt(br.readLine());
}
total_bits=message_bits+gen_bits-1;
app_message=new int[total_bits];
rem=new int[total_bits];
trans_message=new int[total_bits];
for(int i=0;i< message.length;i++)
{
app_message[i]=message[i];
}
System.out.print("\n Message bits are:");
for(int i=0; i < message_bits; i++)
{
System.out.print(message[i]);
}
System.out.print("\n Generators bits are:");
for(int i=0;i < gen_bits;i++)
{
System.out.print(gen[i]);
}
System.out.print("\n Appended message is:");
for(int i=0; i<app_message.length; i++)
{
System.out.print(app_message[i]);
}
for(int j=0;j<app_message.length;j++)
{
rem[j]=app_message[j];
}
rem=computecrc(app_message,gen,rem);

for(int i=0;i<app_message.length;i++)
{
trans_message[i]=(app_message[i]^rem[i]);
}

System.out.println("*\n Transmitted message from the transmitteris :");

for(int i=0;i<trans_message.length;i++)
{
System.out.print(trans_message[i]);
}
System.out.println("\n Enter received message of +total_bits+ at receiver
end:");
for(int i=0; i<trans_message.length;i++)
{
trans_message[i]=Integer.parseInt(br.readLine());
}
System.out.println("\n Received message is:");
for(int i=0; i< trans_message.length;i++)
{
System.out.print(trans_message[i]);
}
for(int j=0; j<trans_message.length; j++)
{
rem[j]=trans_message[j];
}
rem=computecrc(trans_message,gen,rem);
for(int i=0; i<rem.length; i++)
{
if(rem[i]!=0)
{
System.out.println("\n There is Error in the received message!!!");
break;
}
if(i==rem.length-1)
{
System.out.println("\n There is No Error in the received message!!!");
}
}
}

static int[] computecrc(int app_message[],int gen[],int rem[])

{
int current=0;
while(true)
{
for(int i=0;i<gen.length;i++)
{
rem[current+i]=(rem[current+i]^gen[i]);
}
while(rem[current]==0 && current!=rem.length-1)
{
current++;
}
if((rem.length-current)<gen.length)
{
break;
}
}
return rem;
}
}

2. Write a program to find the shortest path between vertices

using bellman-ford algorithm.
Distance Vector Algorithm is a decentralized routing algorithm
that requires that each router simply inform its neighbours of its routing
table. For each network path, the receiving routers pick the neighbour
advertising the lowest cost, then add this entry into its routing table for
re-advertisement. To find the shortest path, Distance Vector Algorithm is
based on one of two basic algorithms: The Bellman-Ford and the Dijkstra
algorithms.
Routers that use this algorithm have to maintain the distance
tables (which is a one-dimension array -- "a vector"), which tell the
distances and shortest path to sending packets to each node in the
network. The information in the distance table is always up date by
exchanging information with the neighbouring nodes. The number of data
in the table equals to that of all nodes in networks (excluded itself). The
columns of table represent the directly attached neighbours whereas the
rows represent all destinations in the network. Each data contains the path
for sending packets to each destination in the network and distance/or
time to transmit on that path (we call this as "cost"). The measurements in
this algorithm are the number of hops, latency, the number of outgoing
packets, etc.
The Bellman–Ford algorithm is an algorithm that computes shortest
paths from a single source vertex to all of the other vertices in a weighted
digraph. It is slower than Dijkstra's algorithm for the same problem, but
more versatile, as it is capable of handling graphs in which some of the
edge weights are negative numbers. Negative edge weights are found in
various applications of graphs, hence the usefulness of this algorithm. If a
graph contains a "negative cycle" (i.e. a cycle whose edges sum to a
negative value) that is reachable from the source, then there is no
cheapest path: any path that has a point on the negative cycle can be
made cheaper by one more walk around the negative cycle. In such a
case, the Bellman–Ford algorithm can detect negative cycles and report
their existence
Source code:

import java.util.Scanner;
public class p8
{
private int d[];
private int num_ver;
public static final int max_value=999;
public p8(int num_ver)
{
this.num_ver=num_ver;
d=new int [num_ver+1];
}
public void bellmanfordevaluation(int source,int a[][])
{
for(int node=1; node<=num_ver; node++)
{
d[node]=max_value;
}
d[source]=0;
for(int node=1; node<=num_ver-1; node++)
{
for(int sn=1;sn<=num_ver;sn++)
{
for(int dn=1;dn<=num_ver;dn++)
{
if(a[sn][dn]!=max_value)
{
if(d[dn]>d[sn]+a[sn][dn])
d[dn]=d[sn]+a[sn][dn];
}
}
}
}
for(int sn=1;sn<=num_ver;sn++)
{
for(int dn=1;dn<=num_ver;dn++)
{
if(a[sn][dn]!=max_value)
{ if(d[dn]>d[sn]+a[sn][dn])
System.out.println("the graph contains -ve edge cycle");
}
}
}
for(int vertex=1;vertex<=num_ver;vertex++)
{
System.out.println("disten of
source"+source+"to"+vertex+"is"+d[vertex]);
 }
}
public static void main(String args[])
{
int num_ver=0;
int source;
Scanner scanner=new Scanner(System.in);
System.out.println("enter the num of vertices");
num_ver=scanner.nextInt();
int a[][]=new int [num_ver+1] [num_ver+1];
System.out.println("enter the adjacency matrix:");
for(int sn=1;sn<=num_ver;sn++)
{
for(int dn=1;dn<=num_ver;dn++)
{ a[sn][dn]=scanner.nextInt();
if(sn==dn)
{ a[sn][dn]=1;
continue;
}
if(a[sn][dn]==0)
{
a[sn][dn]=max_value;
}
}
}
System.out.println("enter the source vertex");
source=scanner.nextInt();
p8 b=new p8(num_ver);
b.bellmanfordevaluation(source,a);
scanner.close();
}
}

Input graph:

5
A B

3
4

C D
3. TCP/IP sockets, write a client – server program to make the client
send the file name and to make the server send back the contents of
the requested file if present. Implement the above program using as
message queues or FIFOs as IPC channels.

Socket is an interface which enables the client and the server to

communicate and pass on information from one another. Sockets
provide the communication mechanism between two computers using
TCP. A client program creates a socket on its end of the
communication and attempts to connect that socket to a server. When
the connection is made, the server creates a socket object on its end of
the communication. The client and the server can now communicate
by writing to and reading from the socket.

Source Code:
TCP Client

import java.net.*;
import java.io.*;
import java.util.Scanner;
public class p9tcpclient
{
public static void main(String args[])
{
Socket s;
while(true)
{
try
{
s=new Socket("127.0.0.1",3000);
OutputStream ostream=s.getOutputStream();
System.out.println("enter filename");
Scanner input= new Scanner(System.in);
String fname= input.nextLine();
PrintWriter pwrite = new PrintWriter(ostream, true);
pwrite.println(fname);
InputStream istream= s.getInputStream();
Scanner cRead= new Scanner (new InputStreamReader(istream));
while(cRead.hasNext())
System.out.println(cRead.nextLine());
pwrite.close();
s.close();
}
catch(Exception e)
{ e.printStackTrace();}
}
}
}

TCP Server

import java.util.Scanner;
import java.net.*;
import java.io.*;
public class p9tcpserver
{
public static void main(String args[]) throws IOException
{
ServerSocket ss=null;
Socket s=null;
try
{
ss=new ServerSocket(3000);
}
catch(Exception e)
{ e.printStackTrace();
}
while(true)
{
try
{
System.out.println("SERVER READY!!..");
s=ss.accept();
System.out.println("CLIENT CONNECTED..");
InputStream istream = s.getInputStream();
Scanner fread= new Scanner(new InputStreamReader(istream));
String fileName= fread.nextLine();
System.out.println("reading contents of "+fileName);
Scanner contentRead= new Scanner(new FileReader(fileName));
OutputStream ostream= s.getOutputStream();
PrintWriter pwrite = new PrintWriter(ostream,true);
String str;
while(contentRead.hasNext())
pwrite.println(contentRead.nextLine());
pwrite.close();
s.close();
}
catch(FileNotFoundException e1)
{
System.out.println("file not found");
OutputStream ostream =s.getOutputStream();
PrintWriter pwrite= new PrintWriter(ostream,true);
pwrite.close();
}
catch(Exception e)
{}
}
}
}

Note: Create two different files Client.java and Server.java. Follow

the steps given:
1. Open a terminal run the server program and provide the
filename to send
 2. Open one more terminal run the client program and provide
the IP address of the server. We can give localhost address
“127.0.0.1” as it is running on same machine or give the IP
address of the machine.
3. Refer
https://www.tutorialspoint.com/java/java_networking.htm for all
the parameters, methods description in socket communication.

4. Write a program on datagram socket for client/server to

display the messages on client side, typed at the server side.
A datagram socket is the one for sending or receiving point
for a packet delivery service. Each packet sent or received on a
datagram socket is individually addressed and routed. Multiple
packets sent from one machine to another may be routed differently,
and may arrive in any order.

Source Code:
UDP Client

import java.util.Scanner;
import java.net.*;
import java.io.*;
public class p10udpclient
{
public static void main(String args[])
{
Scanner in=new Scanner(System.in);
DatagramSocket skt;
try
{
skt=new DatagramSocket();
InetAddress host=InetAddress.getByName("127.0.0.1");
int s_port=3780;
while(true)
{
System.out.println("Client");
String msg=in.nextLine();
byte[] b = msg.getBytes();
DatagramPacket request=new DatagramPacket(b,b.length,host,s_port);
skt.send(request);
byte buffer[]=new byte[1024];
DatagramPacket reply=new DatagramPacket(buffer,buffer.length);
skt.receive(reply);
System.out.println("Server:"+new String(reply.getData()));
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
 UDP Server

import java.util.Scanner;
import java.net.*;
import java.io.*;
public class p10udpserver
{
public static void main(String args[])
{
Scanner in=new Scanner(System.in);
DatagramSocket skt=null;
try
{
skt=new DatagramSocket(3780);
System.out.println("Server is ready");
while(true)
{
byte buffer[]=new byte[1024];
DatagramPacket req= new DatagramPacket(buffer,buffer.length);
skt.receive(req);
String msg=new String(req.getData());
System.out.println("Client:" +msg);
System.out.println("Server");
String m=in.nextLine();
byte[] sendmsg = m.getBytes();
DatagramPacket reply=new
DatagramPacket(sendmsg,sendmsg.length,req.getAddress(),req.getPort())
;
skt.send(reply);
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
}

Note: Create two different files p10udpserver.java and

p10udpclient.java . Follow the following steps:
1. Open a terminal run the server program.
2. Open one more terminal run the client program, the
sent message will be received.
5. Write a program for simple RSA algorithm to encrypt and
decrypt the data.

RSA is an example of public key cryptography. It was

developed by Rivest, Shamir and Adelman. The RSA algorithm can
be used for both public key encryption and digital signatures. Its
security is based on the difficulty of factoring large integers.

The RSA algorithm's efficiency requires a fast method for

performing the modular exponentiation operation. A less efficient,
conventional method includes raising a number (the input) to a
power (the secret or public key of the algorithm, denoted e and d,
respectively) and taking the remainder of the division with N. A
straight-forward implementation performs these two steps of the
operation sequentially: first, raise it to the power and second, apply
modulo. The RSA algorithm comprises of three steps, which are
depicted below:

Key Generation Algorithm

1. Generate two large random primes, p and q, of
approximately equal size such that their product n = p*q
2. Compute n = p*q and Euler’s totient function (φ) phi(n) = (p-
1)(q-1).
3. Choose an integer e, 1 < e < phi, such that gcd(e, phi) = 1.
4. Compute the secret exponent d,
1 < d < phi, such that e*d ≡ 1
(mod phi).
5. The public key is (e, n) and the private key is (d, n). The
values of p, q, and phi should also be kept secret.

Encryption
Sender A does the following:-

1. Using the public key (e,n)

2. Represents the plaintext message as a positive integer M
3. Computes the cipher text C = M^e mod n.
4. Sends the cipher text C to B (Receiver).

Decryption
Recipient B does the following:-

1. Uses his private key (d, n) to compute M = C^d mod n.

2. Extracts the plaintext from the integer representative m.

Source Code:
RSA Key Generation
import java.util.*;
import java.math.BigInteger;
import java.lang.*;

class p11RSAkeygen
{
public static void main(String[] args)
{

Random rand1=new Random(System.currentTimeMillis()); Random

rand2=new Random(System.currentTimeMillis()*10);

int pubkey=Integer.parseInt(args[0]);

BigInteger bigB_p=BigInteger.probablePrime(32, rand1);

BigInteger bigB_q=BigInteger.probablePrime(32, rand2);

BigInteger bigB_n=bigB_p.multiply(bigB_q);

BigInteger bigB_p_1=bigB_p.subtract(new BigInteger("1"));

BigInteger bigB_q_1=bigB_q.subtract(new BigInteger("1"));

BigInteger bigB_p_1_q_1=bigB_p_1.multiply(bigB_q_1);

while(true)
{

BigInteger BigB_GCD=bigB_p_1_q_1.gcd(new BigInteger(""+pubkey));

if(BigB_GCD.equals(BigInteger.ONE))

{
break;
}
pubkey++;
}
BigInteger bigB_pubkey=new BigInteger(""+pubkey);
BigInteger bigB_prvkey=bigB_pubkey.modInverse(bigB_p_1_q_1);
System.out.println("public key : "+bigB_pubkey+","+bigB_n);
System.out.println("private key : "+bigB_prvkey+","+bigB_n);
}
}

RSA Encryption and Decryption

import java.math.BigInteger;
import java.util.*;
class p11RSAEncDec
{
public static void main(String[] args)
{

BigInteger bigB_pubkey = new BigInteger(args[0]);

BigInteger bigB_prvkey = new BigInteger(args[1]);
BigInteger bigB_n = new BigInteger(args[2]);
int asciiVal=Integer.parseInt(args[3]);
BigInteger bigB_val=new BigInteger(""+asciiVal);
BigInteger bigB_cipherVal=bigB_val.modPow(bigB_pubkey,bigB_n);
System.out.println("Cipher text: " + bigB_cipherVal);
BigInteger
bigB_plainVal=bigB_cipherVal.modPow(bigB_prvkey,bigB_n);
int plainVal=bigB_plainVal.intValue();
System.out.println("Plain text: " +plainVal);
}
}

6. Write a program for congestion control using leaky bucket

algorithm.

The main concept of the leaky bucket algorithm is that the output
data flow remains constant despite the variant input traffic, such as the
water flow in a bucket with a small hole at the bottom. In case the bucket
contains water (or packets) then the output flow follows a constant rate,
while if the bucket is full any additional load will be lost because of
spillover. In a similar way if the bucket is empty the output will be zero.
From network perspective, leaky bucket consists of a finite queue
(bucket) where all the incoming packets are stored in case there is space
in the queue, otherwise the packets are discarded. In order to regulate the
output flow, leaky bucket transmits one packet from the queue in a fixed
time (e.g. at every clock tick). In the following figure we can notice the
main rationale of leaky bucket algorithm, for both the two approaches
(e.g. leaky bucket with water (a) and with packets (b)).

While leaky bucket eliminates completely bursty traffic by regulating the

incoming data flow its main drawback is that it drops packets if the bucket is
full. Also, it doesn’t take into
account the idle process of the sender which means that if the host
doesn’t transmit data for some time the bucket becomes empty without
permitting the transmission of any packet.
Source Code:

import java.util.Scanner;
public class p12
{
public static void main(String[] args) throws InterruptedException
{
Scanner in=new Scanner(System.in);
int n,incoming,outgoing,bs,s=0;
System.out.println("enter the bs,outgoing rate,inputs,incoming size");
bs=in.nextInt();
outgoing=in.nextInt();
n=in.nextInt();
incoming=in.nextInt();
while(n!=0)
{
System.out.println("incoming size is"+incoming);
if(incoming<=(bs-s))
{
s+=incoming;
System.out.println("bucket buffer size is"+s+"out of"+bs);
}
else
{
System.out.println("packet lost="+(incoming-(bs-s)));
s=bs;
System.out.println("bucket buffersize is"+s+"out of"+bs);
}
s-=outgoing;
System.out.println("after outgoing="+s+"packet left out of"+bs+"in
buffer");
n--;
Thread.sleep(3000);
}
in.close();
}
}

VIVA QUESTIONS

1. What do you mean by data communication?

Ans: It is the exchange of data between two devices via some form of
transmission medium such as wire cable. The communicating system must be
part of a communication system made up of a combination of hardware and
software. The effectiveness of a data communication system depends on three
fundamental characteristics: delivery, accuracy and timeliness.

2. What is simplex?

Ans: It is the mode of communication between two devices in which flow of

data is unidirectional. i.e. one can transmit and other can receive. E.g.
keyboard and monitor.

3. What is half-duplex?

Ans: It is the mode of communication between two devices in which flow of

data is bi-directional but not at the same time. i.e. each station can transmit
and receive but not at the same time. E.g. walkie-talkies are half-duplex
system.

4. What is full duplex?

Ans: It is the mode of communication between two devices in which flow of

data is bi-directional and it occurs simultaneously. Here signals going in either
direction share the capacity of the link. E.g. telephone

5. What is a network?

Ans: It is a set of devices connected by communication links. A node can be a

computer or any other device capable of sending and/or receiving data
generated by other nodes on the network.

6. What is distributed processing?

Ans: It is a strategy in which services provided by the network reside at
multiple sites.

7. What is point to point connection?

Ans: It provides a dedicated link between two devices. The entire capacity of
the link is reserved for transmission between the two devices e.g. when we
change the TV channels by remote control we establish a point to point
connection between remote control and TV control system.

8. What is multipoint connection?

Ans: In multipoint connection more than two specific devices share a single
link. Here the capacity of the channel is shared either separately or temporally.

9. What is a topology?

Ans: Topology of a network is defined as the geometric representation of the

relationship of all the links and linking devices (node) to one another. Four
basic topologies are star, bus, ring and mesh. Star – Here each device has a
dedicated point to point link only to a central controller called hub. Bus -It is
multipoint. One long cable acts as a backbone to link all the devices in the
network. Ring -Here each device has a dedicated point to point connection only
with the two devices on either side of it. Mesh -Here every device has a
dedicated point to point link to every other device.

10. Define LAN, MAN and WAN.

Ans: LAN- A local area network (LAN) is a privately owned and links the devices
in a single office, building or campus. It allows resources to be shared between
personal computers and work stations. MAN- A metropolitan-area network
(MAN) spreads over an entire city. It may be wholly owned and operated by a
private company, eg local telephone company. WAN – A wide area network
(WAN) provides long distance transmission of data, voice, image and video
information over large geographic areas that comprise a country, a continent
or even whole world.

11. Define internet?

Ans: It is a network of networks.

12. What is a protocol?

Ans: It is a set of rules that governs data communication. A protocol defines

what is communicated, how it is communicated, and when it is communicated.
The key elements of protocol are syntax, semantics and timing.

13. What is TCP/IP protocol model?

Ans: It is a five layered model which provides guidelines for the development of
universally compatible networking protocols. The five layers are physical, data
link, network, transport and application.
14. Describe the functions of five layers?

Ans: Physical- It transmits raw bits over a medium. It provides mechanical and
electrical specification. Data link- It organizes bits into frames. It provides hop
to hop delivery. Network-It moves the packets from source to destination. It
provides internetworking. Transport-It provides reliable process to process
message delivery and error recovery. Application-It allows it access to network
resources.

15. What is ISO-OSI model?

Ans: Open Systems Interconnection or OSI model was designed by the

International Organization for Standardization (ISO). It is a seven-layer model.
It is a theoretical model designed to show how a protocol stack should be
implemented. It defines two extra layers in addition to TCP/IP model. Session -
It was designed to establish, maintain, and synchronize the interaction
between communicating system. Presentation-It was designed to handle the
syntax and semantics of the information exchanged between the two systems.
It was designed for data translation, encryption, decryption, and compression.

16. What is multiplexing?

Ans: Multiplexing is the process of dividing a link, the physical medium, into
logical channels for better efficiency. Here medium is not changed but it has
several channels instead of one.

17. What is switching?

Ans: Switching in data communication is of three types Circuit switching Packet

switching Message switching

18. How data is transmitted over a medium?

Ans: Data is transmitted in the form of electromagnetic signals.

19. Compare analog and digital signals?

Ans: Analog signals can have an infinite number of values in a range but digital
signal can have only a limited number of values.

20. Define bandwidth?

Ans: The range of frequencies that a medium can pass is called bandwidth. It is
the difference between the highest and lowest frequencies that the medium
can satisfactorily pass.

21. What are the factors on which data rate depends?

Ans: Data rate ie. how fast we can send data depends upon i) Bandwidth
available ii) The levels of signals we can use iii) The quality of the channel (level
of noise)

22. Define bit rate and bit interval?

Ans: Digital signals are aperiodic.so instead of using period and frequency we
use bit interval and bit rate respectively. Bit interval is the time required to
send one single bit. Bit rate is the number of bit intervals per second.

23. What is Nyquist bit rate formula?

Ans: For a noiseless channel, the Nyquist bit rate formula defines the
theoretical maximum bit rate Bitrate=2* Bandwidth*log2L Where Bandwidth is
the bandwidth of the channel L is the number of signal level used to represent
the data Bitrate is the bit rate in bits per second.

24. Define Shannon Capacity?

Ans: Shannon Capacity determines the theoretical highest data rate foe a noise
channel. Capacity= Bandwidth * log2 (1+SNR) Bandwidth is the bandwidth of
the channel.

SNR is the signal to noise ratio, it is the statistical ratio of the power of the
signal to the power of the noise. Capacity is the capacity of the channel in bits
per second

25. What is sampling?

Ans: It is the process of obtaining amplitude of a signal at regular intervals.

26. Define pulse amplitude modulation?

Ans: It is an analog to digital conversion method which takes analog signals,

samples it and generates a series of pulse based on the results of the sampling.
It is not used in data communication because the series of pulses generated
still of any amplitude. To modify it we use pulse code modulation.

27. Define pulse code modulation?

Ans: Pulse code Modulation modifies pulses created by PAM to create a

completely digital signal. For this PCM first quantizes the PAM pulse.
Quantization is the method of assigning integral values in a specific range to
sampled instances.PCM is made up of four separate processes: PAM,
quantization, binary encoding and line encoding.

28. What is Nyquist Theorem?

Ans: According to this theorem, the sampling rate must be at least 2 times the
highest frequency of the original signal.

29. What are the modes of data transmission?

Ans: Data transmission can be serial or parallel in mode In parallel
transmission, a group of bits is sent simultaneously, with each bit on a separate
line. In serial transmission there is only one line and the bits are sent
sequentially.

30. What is Asynchronous mode of data transmission?

Ans: It is a serial mode of transmission. In this mode of transmission, each byte

is framed with a start bit and a stop bit. There may be a variable length gap
between each byte.

31. What is Synchronous mode of data transmission?

Ans: It is a serial mode of transmission. In this mode of transmission, bits are

sent in a continuous stream without start and stop bit and without gaps
between bytes. Regrouping the bits into meaningful bytes is the responsibility
of the receiver.

32. What are the different types of multiplexing?

Ans: Multiplexing is of three types. Frequency division multiplexing and wave

division multiplexing is for analog signals and time division multiplexing is for
digital signals.

33. What is FDM?

Ans: In frequency division multiplexing each signal modulates a different carrier

frequency. The modulated carrier combines to form a new signal that is then
sent across the link. Here multiplexers modulate and combine the signal while
de-multiplexers decompose and demodulate. Guard bands keep the
modulating signal from overlapping and interfering with one another.

34. What is TDM?

Ans: In TDM digital signals from n devices are interleaved with one another,
forming a frame of data. Framing bits allow the TDM multiplexer to
synchronize properly.

35. What are the different transmission media?

Ans: The transmission media is broadly categorized into two types i) Guided
media(wired) i) Unguided media(wireless)

36. What are the different Guided Media?

Ans: The media which provides a conduct from one device to another is called
a guided media. These include twisted pair cable, coaxial cable, and fiber-optic
cable.

37. Describe about the different Guided Medias.

Ans: Twisted pair cable consists of two insulated cupper wires twisted
together. It is used in telephone line for voice and data communications.
Coaxial cable has the following layers: a metallic rod-shaped inner conductor,
an insulator covering the rod, a metallic outer conductor (shield), an insulator
covering the shield, and a plastic cover. Coaxial cable can carry signals of higher
frequency ranges than twisted-pair cable. Coaxial cable is used in cable TV
networks and Ethernet LANs.Fiber-optic cables are composed of a glass or
plastic inner core surrounded by cladding, all encased in an outer jacket. Fiber-
optic cables carry data signals in the form of light. The signal is propagated
along the inner core by reflection. Its features are noise resistance, low
attenuation, and high bandwidth capabilities. It is used in backbone networks,
cable TV networks, and fast Ethernet networks.

38. What do you mean by wireless communication?

Ans: Unguided media transport electromagnetic waves without using a physical

conductor. This type of communication is referred as wireless communication.
Here signals are broadcaster through air and thus available to anyone who has
a device to receive it.

39. What do you mean by switching?

Ans: It is a method in which communication devices are connected to one

another efficiently. A switch is intermediary hardware or software that links
devices together temporarily.

40. What are the switching methods?

Ans: There are three fundamental switching methods: circuit switching, packet
switching, and message switching. In circuit switching, a direct physical
connection between two devices is created by space division switches, time
division switches or both. In packet switching data is transmitted using a packet
switched network. Packet switched network is a network in which data are
transmitted in independent units called packets.

41. What are the duties of data link layer?

Ans: Data link layer is responsible for carrying packets from one hop (computer
or router) to the next. The duties of data link layer include packetizing,
addressing, error control, flow control, medium access control.

42. What are the types of errors?

Ans: Errors can be categorized as a single-bit error or burst error. A single bit
error has one-bit error per data unit. A burst error has two or more bits errors
per data unit.

43. What do you mean by redundancy?

Ans: Redundancy is the concept of sending extra bits for use in error detection.
Three common redundancy methods are parity check, cyclic redundancy check
(CRC), and checksum.

44. Define parity check.

Ans: In parity check, a parity bit is added to every data unit so that the total
number of 1s is even (or odd for odd parity). Simple parity check can detect all
single bit errors. It can detect burst errors only if the total number of errors in
each data unit is odd. In two dimensional parity checks, a block of bits is
divided into rows and a redundant row of bits is added to the whole block.

45. Define cyclic redundancy check (CRC).

Ans: C RC appends a sequence of redundant bits derived from binary division

to the data unit. The divisor in the CRC generator is often represented as an
algebraic polynomial.

46. What is hamming code?

Ans: The hamming code is an error correction method using redundant bits.
The number of bits is a function of the length of the data bits. In hamming code
for a data unit of m bits, we use the formula 2r >= m+r+1 to determine the
number of redundant bits needed. By rearranging the order of bit transmission
of the data units, the hamming code can correct burst errors.

47. What do you mean by flow control?

Ans: It is the regulation of sender’s data rate so that the receiver buffer doesn’t
become overwhelmed.i.e. flow control refers to a set of procedures used to
restrict the amount of data that the sender can send before waiting for
acknowledgement.

48. What do you mean by error control?

Ans: Error control refers primarily to methods of error detection and

retransmission. Anytime an error is detected in an exchange, specified frames
are retransmitted. This process is called automatic repeat request (ARQ).

49. Define stop and wait ARQ.

Ans: In stop and wait ARQ, the sender sends a frame and waits for an
acknowledgement from the receiver before sending the next frame.

50. Define Go-Back-N ARQ?

Ans: In Go-Back-N ARQ, multiple frames can be in transit at the same time. If
there is an error, retransmission begins with the last Unacknowledged frame
even if subsequent frames arrived correctly. Duplicate frames are discarded.

51. Define Selective Repeat ARQ?

Ans: In Selective Repeat ARQ, multiple frames can be in transit at the same
time. If there is an error, only unacknowledged frame is retransmitted.

52. What do you mean by pipelining, is there any pipelining in error control?
Ans: The process in which a task is often begun before the previous task has
ended is called pipelining. There is no pipelining in stop and wait ARQ however
it does apply in Go-Back-N ARQ and Selective Repeat ARQ.

53. What is HDLC?

Ans: It is a bit oriented data link protocol designed to support both half duplex
and full duplex communication over point to point and multi point links. HDLC
is characterized by their station type, configuration and their response modes.

54. What do you mean by point to point protocol?

Ans: The point to point protocol was designed to provide a dedicated line for
users who need internet access via a telephone line or a cable TV connection.
Its connection goes through three phases: idle, establishing, authenticating,
networking and terminating. At data link layer it employs a version of HDLC.

55. What do you mean by point to point protocol stack?

Ans: Point to point protocol uses a stack of other protocol to use the link, to
authenticate the parties involved, and to carry the network layer data. Three
sets of protocols are defined: link control protocol, Authentication protocol,
and network control protocol.

56. What do you mean by line control protocol?

Ans: It is responsible for establishing, maintaining, configuring, and terminating

links.

57. What do you mean by Authentication protocol?

Ans: Authentication means validating the identity of a user who needs to

access a set of resources. It is of two types i) Password Authentication
Protocol(PAP) ii) Challenge Handshake Authentication Protocol(CHAP) PAP is a
twostep process. The user sends a authentication identification and a
password. The system determines the validity of the Information sent. CHAP is
a three step process. The system sends a value to the user. The user
manipulates the value and sends the result. The system Verifies the result.

58. What do you mean by network control protocol?

Ans: Network control protocol is a set of protocols to allow the encapsulation

of data coming from network layer protocol that requires the services of PPP.

59. What do you mean by CSMA?

Ans: To reduce the possibility of collision CSMA method was developed. In

CSMA each station first listens to the medium (Or check the state of the
medium) before sending. It can’t eliminate collision.
60. What do you mean by Bluetooth?

Ans: It is a wireless LAN technology designed to connect devices of different

functions such as telephones, notebooks, computers, cameras, printers and so
on. Bluetooth LAN Is an adhoc network that is the network is formed
spontaneously? It is the implementation of protocol defined by the IEEE 802.15
standard.

61. What is IP address?

Ans: The internet address (IP address) is 32bits that uniquely and universally
defines a host or router on the internet. The portion of the IP address that
identifies the network is called net-id. The portion of the IP address that
identifies the host or router on the network is called host-id.

62. What do you mean by sub netting?

Ans: Sub-netting divides one large network into several smaller ones. It adds an
intermediate level of hierarchy in IP addressing.

63. What are the advantages of fiber optics cable?

Ans: The advantages of fiber optics cable over twisted pair cable are Noise
resistance-As they use light so external noise is not a factor. Less signal
attenuation-fiber optics transmission distance is significantly greater than that
of other guided media. Higher bandwidth. It can support higher bandwidth.

64. What are the disadvantages of fiber optics cable?

Ans: The disadvantages of fiber optics cable over twisted pair cable are Cost-It
is expensive Installation/maintenance-Any roughness or cracking defuses light
and alters the signal Fragility-It is more fragile.

65. What are the propagation type of radio wave?

Ans: Radio wave propagation is dependent upon frequency. There are five
propagation type. i)surface propagation ii) Tropospheric propagation iii)
Lonospheric propagation iv) Line of sight propagation v) Space propagation

66. What do you mean by Geosynchronous Satellites?

Ans: Satellite communication uses a satellite in geosynchronous orbit to relay

signals. The Satellite must move at the same speed as the earth so that it
seems to remain fixed above a certain spot. Only one orbit can be
geosynchronous. This orbit occurs at the equatorial plane and is approximately
22,000 miles from the surface of earth.

67. What are the factors for evaluating the suitability of the media?

Ans: The factors are cost, throughput, attenuation, Electromagnetic

interference(EMI), security.
68. What do you mean by medium access control(MAC) sublayer.

Ans: The protocols used to determine who goes next on a multi-access channel
belong to a sublayer of the data link layer is called the multi-access
channel(MAC) sublayer. It is the bottom part of data link layer.

69. What do you mean by ALOHA?

Ans: It is the method used to solve the channel allocation problem. It is used
for: i) ground based radio broadcasting ii) In a network in which uncoordinated
users are competing for the use of single channel. It is of two types: 1. Pure
aloha 2. Slotted aloha

70. What is pure ALOHA?

Ans: It lets users transmit whenever they have data to send. Collision may
occur but due to feedback property sender can know the status of message.
Conflict occur when at one time more bits are transmitted. The assumptions
are: i) all frame size is same for all user. ii)collision occur when frames are
transmitted simultaneously iii) indefinite population of no of user.
iv)N=number of frames/frame time iv) it obeys poison’s distribution if N>1
there will be collision 0<1

71. What is slotted ALOHA?

Ans: In this method time is divided into discrete intervals, each interval
corresponding to one frame. It requires user to agree on slot boundaries. Here
data is not send at any time instead it wait for beginning of the next slot. Thus
pure ALOHA is turned into discrete one.

72. What do you mean by persistent CSMA (carrier sense multiple access)?

Ans: When a station has data to send, it first listens to the channel to see if
anyone else is transmitting at that moment. If channel is busy it waits until the
station becomes idle. When collision occurs it waits and then sends. It sends
frame with probability 1 when channel is idle.

73. What do you mean by non-persistent CSMA (carrier sense multiple

access)?

Ans: Here if no one else is sending the station begins doing so itself. However,
if the channel is already in use, the station doesn’t continuously sense it rather
it waits for a random period of time and then repeats. It leads better channel
utilization but longer delay.

74. What do you mean by p persistent CSMA (carrier sense multiple access)?

Ans: It applies to slotted channels. when a station becomes ready to send, it

senses the channel. If it is idle it transmits with a probability Pewit a probability
Q=P-1 It defers until the next slot. If that slot is also idle, it either transmits or
defers again with probability P and The process is repeated until either the
frame has been transmitted or another station begins transmitting.

75. What is FDDI?

Ans: It is high performance fiber optic token ring LAN running at 100Mbps over
distance up 1000 stations. FDDI access is limited by time. A FDDI cabling consist
of two fiber rings. i)one transmitting clockwise ii) one transmitting
counterclockwise

76. What is Firewalls?

Ans: It is an electronic down bridge which is used to enhance the security of a

network. It’s configuration has two components. i)Two routers ii) Application
gateway the packets traveling through the LAN are inspected here and packets
meeting certain criteria are forwarded and others are dropped.

77. What is Repeaters?

Ans: A receiver receives a signal before it becomes too weak or corrupted,

regenerates the original bit pattern, and puts the refreshed copy back onto the
link. It operates on physical layer of OSI model.

78. What is Bridges?

Ans: They divide large network into smaller components. They can relay frames
between two originally separated LANs. They provide security through
partitioning traffic. They operate on physical and data link layer of OSI model.

79. What is Routers?

Ans: Router relay packets among multiple interconnected networks. They

receive packet from one connected network and pass it to another network.
They have access to network layer addresses and certain software that enables
them to determine which path is best for transmission among several paths.
They operate on physical, data link and network layer of OSI model.

80. What is Gateway?

Ans: It is a protocol converter. A gateway can accept a packet formatted for

one protocol and convert it to a packet formatted for another protocol. It
operates on all the seven layers of OSI model.

81. What do you mean by Data Terminal Equipment(DTE)?

Ans: It is any device that is source of or destination for binary digital data. At
physical layer it can be a terminal computer. They generate or consume
information.

82. What do you mean by Data Terminating Equipment (DCE)?

Ans: Data circuit terminating equipment includes any functional unit that
transmit or receives data in the form of an analog or digital signal through a
network. DTE generates digital data and passes them to a DCE, the DCE
converts the data to a form acceptable to the transmission media and sends
the converted signal to another DCE on the network.

83. What do you mean by protocol stack?

Ans: The list of protocols used by certain system, one protocol per layer is
called protocol stack.

84. What do you mean by peer?

Ans: Entities comprising the corresponding layers on different machines are

called peers. It may be • hardware device. • processes • human being peers
communicate by using protocol.

85. What do you mean by broadcasting?

Ans: Broadcast system allow addressing a packet to all destination by using a

special code in address field. when packet is transmitted it is received and
processed by every machine on the network.

86. What are the advantages of broadcast network.

Ans: • a single communication channel is shared by all computers. • packets

are transmitted and received by all the computer. • address field is attached to
whom it is intended. • multicasting is used in network.

87. What do you mean by point to point network?

Ans: Point to point network consist of many connections between individual

pair of machines. Large networks are point to point. Routing algorithm plays an
important in point to point network. It uses stored ad forward technique. It is a
packet switching network.

88. What are the design issue of layers?

Ans: The design issue of layer are • Addressing technique.ie source and
destination address • Types of communication • Error control • Order of
message. • Speed matching • Multiplexing and de-multiplexing.

89. What are the protocols in application layer?

Ans: The protocols defined in application layer are • TELNET • FTP • SMTP •
DNS

90. What are the protocols in transport layer?

Ans: The protocols defined in transport layer are

• TCP • UDP

91. Define TCP?

Ans: It is connection oriented protocol. It consists byte streams originating on
one machine to be delivered without error on any other machine in the
network. while transmitting it fragments the stream to discrete messages and
passes to internet layer. At the destination it reassembles the messages into
output stream.

92. Define UDP?

Ans: It is unreliable connectionless protocol. It is used for one-shot, client-

server type, request-reply queries and applications in which prompt delivery is
required than accuracy.

93. Define IP?

Ans: Internetwork protocol (IP) is the transmission mechanism used by TCP/IP

protocol. It is an unreliable and connectionless datagram protocol. It provides
no error checking and tracking.

94. What do you mean by client server model?

Ans: In client server model, the client runs a program to request a service and
the server runs a program to provide the service. These two programs
communicate with each other. One server program can provide services to
many client programs.

95. What are the information that a computer attached to a TCP/IP internet
must possesses?

Ans: Each computer attached to TCP/IP must possesses the following

information • Its IP address • Its subnet mask • The IP address of the router. •
The IP address of the name server.

96. What is domain name system(DNS)?

Ans: Domain Name System (DNS) is a client server application that identifies
each host on the internet with a unique user friendly name.

97. What is TELNET?

Ans: TELNET is a client –server application that allows a user to log on to a

remote machine, giving the user access to the remote system. TELNET is an
abbreviation of terminal Network.

98. What do you mean by local login and remote login?

Ans: When a user logs into a local time-sharing system, it is called local login.
When a user wants to access an application program or utility located on a
remote machine, he or she performs remote login.
99. What is Network Virtual Terminal?

Ans: A universal interface provided by TELNET is called Network Virtual

Terminal(NVT) character set. Via this interface TELNET translates characters
(data or command) that come from local terminal into NVT form and delivers
them to the network.

100. What do you mean by Simple Mail Transfer Protocol?

Ans: The TCP/IP protocol that supports electronic mail on the internet is called
Simple Mail Transfer Protocol. SMTP provides for mail exchange between users
on the same or different computer and supports Sending a single message to
one or more recipient Sending message that include text, voice, video, or
graphics. Sending message to users on network outside the internet.

101. What is Hypertext Transfer Protocol(HTTP)?

Ans: It is the main protocol used to access data on the World Wide Web. the
protocol transfers data in the form of plain text, hypertext, audio, video and so
on. It is so called because its efficiency allows its use in a hypertext
environment where there are rapid jumps from one document to another.

102. What is URL?

Ans: It is a standard for specifying any kind of information