BANGALORE TECHNOLOGICAL

INSTITUTE

Department of Computer Science and

Engineering

LAB MANUAL
( 2023–24 )

V Semester
21CS52 COMPUTER NETWORK LABORATORY

By,
Mrs. Chaitra Barki
Assistant Professor
 TABLE OF CONTENTS

NS Programs
1. IntroductiontoNS2
2. X Graph
3. Awk and advanced
4. Three node point to point network
5. Transmission of Ping messages
6. Ethernet LAN using n-nodes with multiple traffic
7. Simple ESS with wireless LAN
Java Programs
8. CRC-CCITT
9. Bellman-Ford Algorithm
10. Congestion Control Using Leaky Bucket Algorithm
Viva-voice
References
 Computer Network Laboratory [21CS52] 2023-24

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 usingNS2.
 In general, NS2 provides users with a way of specifying such network protocols and
simulating their corresponding behaviors.

Basic Architecture of NS2

Tcl scripting
• Tcl is a general purpose scripting language.[Interpreter]
• Tcl runs on most of the platforms such as Unix, Windows, and Mac.
• The strength of Tcl is its simplicity.
• It is not necessary to declare a data type for variable prior to the usage.

Basics of TCL
Syntax:command arg1 arg2 arg3
 Hello World!
puts std out{Hello,
World!} Hello, World!
 Variables Command Substitution
seta5 set len [string lengthfoobar]

Department of CSE, BTI Page 3

 Computer Network Laboratory [21CS52] 2023-24
setb$a set len [expr [string length foobar] +9]

 SimpleArithmetic
expr 7.2 / 4
 Procedures
proc Diag {a b} {
set c [expr sqrt($a * $a + $b * $b)]
return $c }
puts―Diagonalofa3,4righttriangleis[Diag34]‖ Output:
Diagonal of a 3, 4 right triangle is5.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.
11. Initialization and termination aspects of the nssimulator.
12. Definition of network nodes, links, queues andtopology.
13. Definition of agents and ofapplications.
14. The nam visualizationtool.
15. Tracing and randomvariables.

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

Department of CSE, BTI Page 4

 Computer Network Laboratory [21CS52] 2023-24
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 file
set tracefile1 [open out.tr w]

$ns trace-all $tracefile1

#Open the NAM trace file

set namfile [open out.nam w]

$ns namtrace-all $namfile

Theabovecreatesatracefilecalled―out.tr‖andanamvisualizationtracefilecalled
―out.nam‖. Within the tcl script, these files are not called explicitly by their names, but instead
bypointersthatare declaredaboveandcalled―tracefile1‖and―namfile‖respectively.
Remarkthattheybeginswitha#symbol.Thesecondlineopenthefile―out.tr‖ tobeusedfor
writing,declaredwiththeletter―w‖.Thethirdlineusesasimulatormethodcalledtrace-all that have
as parameter the name of the file where the traces willgo.
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‖.
Thetermination ofthe program isdoneusinga―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

Department of CSE, BTI Page 5

 Computer Network Laboratory [21CS52] 2023-24

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 traceson the respective files. The tcl
command―close”closesthetracefilesdefinedbeforeandexecexecutesthenamprogramfor
visualization. The command exit will ends the application and return the number 0 as status
to the system. Zero is the default for a clean exit. Other values can be used to say that is a exit
because somethingfails.
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 allowsus to
schedule events explicitly.
The simulation can then begin using the command

$ns run

Definition of a network of links and nodes

The way to define a node is

set n0 [$ns node]

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

Which means that $n0 and $n2 are connected using a bi-directional link that has 10ms
of propagation delay and a capacity of 10Mb per sec for each direction.
Todefine adirectionallinkinsteadofabi-directionalone,we shouldreplace―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

Department of CSE, BTI Page 6

 Computer Network Laboratory [21CS52] 2023-24
arrive is dropped. Many alternative options exist, such as the RED (Random EarlyDiscard)

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

FTP over TCP

TCP is a dynamic reliable congestion control protocol. It uses Acknowledgements
created by the destination to know whether packets are well received.
There are number variants of the TCP protocol, such as Tahoe, Reno, NewReno,
Vegas. The type of agent appears in the first line:

set tcp [new Agent/TCP]

The command $ns attach-agent $n0 $tcp defines the source node of the tcp connection.
The command
set sink [new Agent /TCPSink]
Defines the behavior of the destination node of TCP and assigns to it a pointer called sink.

#Setup a UDP connection

set udp [new Agent/UDP]
$ns attach-agent $n1 $udp

set null [new Agent/Null]

$ns attach-agent $n5 $null
$ns connect $udp $null
$udp set fid_2

Department of CSE, BTI Page 7

 Computer Network Laboratory [21CS52] 2023-24

#setup a CBR over UDP connection

set cbr [new Application/Traffic/CBR]

$cbr attach-agent $udp

$cbr set packetsize_ 100

$cbr set rate_ 0.01Mb

$cbr set random_ false

Above shows the definition of a CBR application using a UDP agent

The command $ns attach-agent $n4 $sink defines the destination node. The
command $ns connect $tcp $sink finally makes the TCP connection between the source and
destination nodes.
TCP has many parameters with initial fixed defaults values that can be changed if
mentioned explicitly. For example, the default TCP packet size has a size of 1000bytes.This
can be changed to another value, say 552bytes, using the command $tcp set packetSize_
552.
When we have several flows, we may wish to distinguish them so that we can identify
them with different colors in the visualization part. This is done by the command $tcp set
fid_1thatassignstotheTCPconnectionaflowidentificationof―1‖.Weshalllatergivethe
flowidentification 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>

Department of CSE, BTI Page 8

 Computer Network Laboratory [21CS52] 2023-24

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 theformat:
$ns at <time><event>
The scheduler is started when running ns that is through the command $ns run.
The beginning and end of the FTP and CBR application can be done through the following
command
$ns at 0.1 “$cbr start”

$ns at 1.0 “ $ftp start”

$ns at 124.0 “$ftp stop”

$ns at 124.5 “$cbr stop”

Structure of Trace Files

When tracing into an output ASCII file, the trace is organized in 12 fields as follows
in fig shown below, The meaning of the fieldsare:
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 eventoccurs.
3. Gives the input node of the link at which the eventoccurs.
4. Gives the output node of the link at which the eventoccurs.
5. Gives the packet type (eg CBR orTCP)
6. Gives the packetsize
7. Someflags
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 NAMdisplay.

Department of CSE, BTI Page 9

 Computer Network Laboratory [21CS52] 2023-24

9. This isthe source addressgiven 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 analysispurposes
12. The last field shows the Unique id of thepacket.

Department of CSE, BTI Page 10

 Computer Network Laboratory [21CS52] 2023-24

XGRAPH

The xgraph program draws a graph on an x-display given data read from either data
file or from standard input if no files are specified. It can display upto 64 independent data
sets using different colors and line styles for each set. It annotates the graph with a title, axis
labels, grid lines or tick marks, grid labels and a legend.

Syntax:
Xgraph [options] file-name

Options are listed here

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

Department of CSE, BTI Page 11

 Computer Network Laboratory [21CS52] 2023-24

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 there choice. You can now print a serial
number, using the variable kount, and apply it those directors drawing a salary exceeding
6700:
$ awk –F”|” „$3 == “director”&& $6 > 6700 {
kount =kount+1
printf “ %3f %20s %-12s %d\n”, kount,$2,$3,$6 }‟ empn.lst

THE –f OPTION: STORING awk PROGRAMS IN A FILE

You should holds large awk programs in separate file and provide them with the awk
extension for easier identification. Let’s first store the previous program in the file
empawk.awk:
$ cat empawk.awk
Observe that this time we haven’t used quotes to enclose the awk program. You can
now use awk with the –f filename option to obtain the same output:

Awk –F”|” –f empawk.awk empn.lst

Department of CSE, BTI Page 12

 Computer Network Laboratory [21CS52] 2023-24

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

Department of CSE, BTI Page 13

 Computer Network Laboratory [21CS52] 2023-24

Part-A
ExperimentNo:1 Date:
THREE NODE POINT TO POINT NETWORK

Aim: 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 lab1.nam w] # open a nam trace file in write mode
$ns namtrace-all $nf # nf nam filename
set tf [open lab1.tr w] # tf trace filename
$ns trace-all $tf

proc finish { } {
global ns nf tf
$ns flush-trace # clears trace file contents
close $nf
close $tf
exec nam lab1.nam &
exit 0
}
set n0[$ns node] # creates 3nodes
set n2 [$ns node]
set n3 [$ns node]

$ns duplex-link $n0 $n2 200Mb 10ms DropTail # establishing links

$ns duplex-link $n2 $n3 1Mb 1000ms DropTail
$ns queue-limit $n0 $n2 10

set udp0[new Agent/UDP] # attaching transport layerprotocols

$ns attach-agent $n0 $udp0
set cbr0[new Application/Traffic/CBR] # attaching application layerprotocols
$cbr0 set packetSize_ 500
$cbr0 set interval_ 0.005
$cbr0 attach-agent $udp0

set null0 [new Agent/Null] # creating sink(destination)node

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

$ns at 0.1 "$cbr0 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 „{„

Department of CSE, BTI Page 14

 Computer Network Laboratory [21CS52] 2023-24

BEGIN{ c=0;}
{
if($1= ="d")
{ c++;
printf("%s\t%s\n",$5,$11);
}
}
END{ printf("The number of packets dropped is %d\n",c); }

Steps for execution

Opengediteditorandtypeprogram.Programnameshouldhavetheextension
“ .tcl ”
[root@localhost ~]# gedit lab1.tcl
Save the program and close thefile.
 Open gedit editor and type awk program. Program name should have the
extension “.awk ”
[root@localhost ~]# gedit lab1.awk
Save the program and close thefile.
Run the simulationprogram
[root@localhost~]# ns lab1.tcl
 Here “ns” indicates network simulator. We get the topology shown in the
snapshot.
Now press the play button in the simulation window and the simulation will
begins.
After simulation is completed run awk file to see the output,
[root@localhost~]# awk –f lab1.awklab1.tr
To see the trace file contents open the file as,
[root@localhost~]# gedit lab1.tr

Trace file contains 12 columns:

Event type, Event time, From Node, To Node, Packet Type, Packet Size, Flags
(indicated by --------), Flow ID, Source address, Destination address, Sequence ID,
Packet ID

Department of CSE, BTI Page 15

 Computer Network Laboratory [21CS52] 2023-24
ExperimentNo:2 Date:
TRANSMISSION OF PING MESSAGE

Aim: 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 lab2.nam w ]

$ns namtrace-all $nf

set tf [ open lab2.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] # letters A and P should be capital

$ns attach-agent $n0 $p1
$p1 set packetSize_ 50000
$p1 set interval_ 0.0001

set p2 [new Agent/Ping] # letters A and P should be capital

$ns attach-agent $n1 $p2

set p3 [new Agent/Ping] # letters A and P should be capital

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

set p4 [new Agent/Ping] # letters A and P should be capital

$ns attach-agent $n3 $p4

set p5 [new Agent/Ping] # letters A and P should be capital

$ns attach-agent $n5 $p5

$ns queue-limit $n0 $n4 5

$ns queue-limit $n2 $n4 3

Department of CSE, BTI Page 16

 Computer Network Laboratory [21CS52] 2023-24

$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"
}
# please provide space between $node_ and id. No space between $ and from. No space
between and $ and rtt */

$ns connect $p1 $p5

$ns connect $p3 $p4

proc finish { } {
global ns nf tf
$ns flush-trace
close $nf
close $tf
exec nam lab2.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 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 2.0 "finish"

$ns run

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

BEGIN{
drop=0;

Department of CSE, BTI Page 17

 Computer Network Laboratory [21CS52] 2023-24
}
{
if($1= ="d" )
{
drop++;
}
}
END{
printf("Total number of %s packets dropped due to congestion =%d\n",$5,drop);
}

Steps for execution

 Open gedit editor and type program. Program name should have the extension
“ .tcl”
[root@localhost ~]# gedit lab2.tcl
Save the program and close thefile.
 Open gedit editor and type awk program. Program name should have the
extension “.awk ”
[root@localhost ~]# gedit lab2.awk
Save the program and close thefile.
Run the simulationprogram
[root@localhost~]# ns lab2.tcl
 Here “ns” indicates network simulator. We get the topology shown in the
snapshot.
Now press the play button in the simulation window and the simulation will
begins.
After simulation is completed run awk file to see the output,
[root@localhost~]# awk –f lab2.awklab2.tr
To see the trace file contents open the file as,
[root@localhost~]# gedit lab2.tr

Topology Output

Department of CSE, BTI Page 18

 Computer Network Laboratory [21CS52] 2023-24

Output

Department of CSE, BTI Page 19

 Computer Network Laboratory [21CS52] 2023-24

ExperimentNo:3 Date:
ETHERNET LAN USING N-NODES WITH MULTIPLE TRAFFIC

Aim: 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 lab3.tr w]
$ns trace-all $tf
set nf [open lab3.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

Department of CSE, BTI Page 20

 Computer Network Laboratory [21CS52] 2023-24

$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_ # must put underscore ( _ ) after cwnd and no space between them
$tcp2 trace cwnd_

proc finish { } {
global ns nf tf
$ns flush-trace
close $tf
close $nf
exec nam lab3.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 “gedit command” and write awk file and save with
“.awk” extension)

cwnd:- means congestion window

BEGIN {
}
{
if($6=="cwnd_") #don‟tleavespaceafterwritingcwnd_
printf("%f\t%f\t\n",$1,$7); # you must put \n inprintf
}
END{

Department of CSE, BTI Page 21

 Computer Network Laboratory [21CS52] 2023-24
}

Steps for execution

 Open gedit editor and type program. Program name should have the extension
“ .tcl”
[root@localhost ~]# gedit lab3.tcl
Save the program and close thefile.
 Open gedit editor and type awk program. Program name should have the
extension “.awk ”
[root@localhost ~]# gedit lab3.awk
Save the program and close thefile.
Run the simulationprogram
[root@localhost~]# ns lab3.tcl
 Here “ns” indicates network simulator. We get the topology shown in the
snapshot.
Now press the play button in the simulation window and the simulation will
begins.
 After simulation is completed run awk file to see the output ,
[root@localhost~]# awk –f lab3.awk file1.tr >a1
[root@localhost~]# awk –f lab3.awk file2.tr >a2
[root@localhost~]# xgraph a1 a2\
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(>).
To see the trace file contents open the file as,

Topolgy:

Department of CSE, BTI Page 22

 Computer Network Laboratory [21CS52] 2023-24

Output:

Department of CSE, BTI Page 23

 Computer Network Laboratory [21CS52] 2023-24

ExperimentNo:4 Date:
SIMPLE ESS WITH WIRELESS LAN

Aim: 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 lab4.tr w]
$ns trace-all $tf
set topo [new Topography]
$topo load_flatgrid 1000 1000
set nf [open lab4.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 \
-prrootype 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 15"

$ns at 0.1 "$n1 setdest 100 100 25"

Department of CSE, BTI Page 24

 Computer Network Laboratory [21CS52] 2023-24
$ns at 0.1 "$n2 setdest 600 600 25"
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
exec nam lab4.nam &
close $tf
exit 0
}
$ns at 250 "finish"
$ns run

AWK file:(Open a new editor using “gedit 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")
Department of CSE, BTI Page 25
 Computer Network Laboratory [21CS52] 2023-24
{
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

 Open gedit editor and type program. Program name should have the extension
“ .tcl”
[root@localhost ~]# gedit lab4.tcl
Save the program and close thefile.
 Open gedit editor and type awk program. Program name should have the
extension “.awk ”
[root@localhost ~]# gedit lab4.awk
Save the program and close thefile.
Run the simulationprogram
[root@localhost~]# ns lab4.tcl
 Here “ns” indicates network simulator. We get the topology shown in the
snapshot.
Now press the play button in the simulation window and the simulation will
begins.
After simulation is completed run awk file to see the output,
[root@localhost~]# awk –f lab4.awklab4.tr
To see the trace file contents open the file as,
[root@localhost~]# gedit lab4.tr
Output:

Node 1 and 2arecommunicating Node 2 is moving towards node3

Department of CSE, BTI Page 26

 Computer Network Laboratory [21CS52] 2023-24

Node 2 is coming back from node 3towardsnode1 TraceFile

Here “M” indicates mobile nodes, “AGT” indicates Agent Trace, “RTR” indicates
Route Trace

Department of CSE, BTI Page 27

 Computer Network Laboratory [21CS52] 2023-24

ExperimentNo:1 Date:
Error Detecting Code Using CRC-CCITT (16-bit)

Aim: Write a Program for ERROR detecting code using CRC-CCITT (16bit).

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 developers 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 areused.

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 methodyou learned whenyou were

Department of CSE, BTI Page 28

 Computer Network Laboratory [21CS52] 2023-24

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 thesame:
 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- and32-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.
Table 1: International Standard CRC Polynomials
CRC-CCITT CRC-16 CRC-32
Checksum
16 bits 16 bits 32 bits
Width
Generator
10001000000100001 11000000000000101 100000100110000010001110110110111
Polynomial
Error detection with CRC
Consider a message represented by the polynomial M(x)

Department of CSE, BTI Page 29

 Computer Network Laboratory [21CS52] 2023-24

Consider a generating polynomial G(x)

This is used to generate a CRC = C(x) to be appended to M(x).
Note this G(x) is prime.
Steps:
1. Multiply M(x) by highest power in G(x). i.e. Add So much zeros toM(x).
2. Divide the result by G(x). The remainder =C(x).
Special case: This won't work if bitstring =all zeros. We don't allow such an
M(x).But M(x) bitstring = 1 will work, for example. Can divide 1101 into 1000.
3. If: x div y gives remainder c
that means: x = n y + c
Hence (x-c) = ny
(x-c) div y gives remainder 0
Here (x-c) = (x+c)
Hence (x+c) div y gives remainder 0
4. Transmit: T(x) = M(x) +C(x)
5. Receiver end: Receive T(x). Divide by G(x), should have remainder0.

Note if G(x) has order n - highest power is xn,

then G(x) will cover (n+1) bits
and the remainder will cover n bits.
i.e. Add n bits (Zeros) tomessage.

Some CRC polynomials that are actually used

Some CRC polynomials

 CRC-8:
x8+x2+x+1
o Used in: 802.16 (along with errorcorrection).
 CRC-CCITT:
x16+x12+x5+1
o Used in: HDLC, SDLC, PPPdefault
 IBM-CRC-16 (ANSI):
x16+x15+x2+1

Department of CSE, BTI Page 30

 Computer Network Laboratory [21CS52] 2023-24

 802.3:
x32+x26+x23+x22 +x16+x12+x11+x10 +x8+x7+x5+x4+x2+x+1
o Used in: Ethernet, PPProotion

Source Code:
import java.util.*;
class crc
{ void div(int a[],intk)
{ intgp[]={1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1};
int count=0;
for(int i=0;i<k;i++)
{
if(a[i]==gp[0])
{
for(int j=i;j<17+i;j++)
{
a[j]=a[j]^gp[count++];
}
count=0;
}
}
}
public static void main(String args[])
{
int a[]=new int[100];
int b[]=new int[100];
int len,k;
crc ob=new crc();
System.out.println("Enter the length of Data Frame:");
Scanner sc=new Scanner(System.in);
len=sc.nextInt();
int flag=0;
System.out.println("Enter the Message:");
for(int i=0;i<len;i++)
{ a[i]=sc.nextInt();
}
for(int i=0;i<16;i++)
{ a[len++]=0;
}
k=len-16;
for(int i=0;i<len;i++)
{ b[i]=a[i];
}
ob.div(a,k);
for(int i=0;i<len;i++)
a[i]=a[i]^b[i];
System.out.println("Data to be transmitted: ");

Department of CSE, BTI Page 31

 Computer Network Laboratory [21CS52] 2023-24
for(int i=0;i<len;i++)
{
System.out.print(a[i]+" ");
}
System.out.println();
System.out.println("Enter the Reveived Data: ");
for(int i=0;i<len;i++)
{
a[i]=sc.nextInt();
}
ob.div(a, k);

for(int i=0;i<len;i++)
{
if(a[i]!=0)
{
flag=1;
break;
}
}
if(flag==1)
System.out.println("error in data");
else
System.out.println("no error");
}
}

Output:
Enter the length of Data Frame: 4
Enter the Message: 1 0 1 1
Data to be transmitted: 1 0 1 1 1 0 1 1 0 0 0 1 0 1 1 0 1 0 1 1
Enter the Reveived Data: 1 0 1 1 1 0 1 1 0 0 0 0 0 1 1 0 1 0 1 1
ERROR in Recived Data
**********************************************************

Department of CSE, BTI Page 32

 Computer Network Laboratory [21CS52] 2023-24

ExperimentNo:2 Date:
Bellman-ford Algorithm

Aim: 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 neighbors of its routing table. For each network path, the receiving
routers pick the neighbor 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 upd by exchanging
information with the neighboring 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
neighbors 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
Implementation Algorithm:
1. send my routing table to all my neighbors whenever my link tablechanges
2. when I get a routing table from a neighbor on port P with link metricM:
a. add L to each of the neighbor'smetrics
b. for each entry (D, P', M') in the updated neighbor'stable:

Department of CSE, BTI Page 33

 Computer Network Laboratory [21CS52] 2023-24
i. if I do not have an entry for D, add (D, P, M') to my routingtable
ii. if I have an entry for D with metric M", add (D, P, M') to my routing
table if M' <M"
3. if my routing table has changed, send all the new entries to all myneighbors.

Source Code:
import java.util.Scanner;
public class BellmanFord
{ private int D[];
private intnum_ver;
public static final int MAX_VALUE = 999;
public BellmanFord(int n)
{ this.n=n;
D = new int[n+1];
}
public void shortest(int s,int A[][])
{ for (inti=1;i<=n;i++)
{ D[i]=MAX_VALUE;
} D[s] = 0;
for(int k=1;k<=n-1;k++)
{ for(inti=1;i<=n;i++)
{ for(intj=1;j<=n;j++)
{ if(A[i][j]!=MAX_VALUE)
{ if(D[j]>D[i]+A[i][j])
D[j]=D[i]+A[i][j];
}
}
}
}
for(int i=1;i<=n;i++)
{ for(intj=1;j<=n;j++)
{ if(A[i][j]!=MAX_VALUE)
{ if(D[j]>D[i]+A[i][j])
{
System.out.println("The Graph contains negative egde cycle");
return;
} }
}
}
for(int i=1;i<=n;i++)
{
System.out.println("Distance of source " + s + " to "+ i + " is " + D[i]);
}
}
public static void main(String[ ] args)
{ intn=0,s;
Scanner sc = new Scanner(System.in);
System.out.println("Enter the number of vertices");

Department of CSE, BTI Page 34

 Computer Network Laboratory [21CS52] 2023-24
n = sc.nextInt();
int A[][] = new int[n+1][n+1];
System.out.println("Enter the Weighted matrix");
for(int i=1;i<=n;i++)
{ for(intj=1;j<=n;j++)
{ A[i][j]=sc.nextInt();
if(i==j)
{ A[i][j]=0;
continue;
}
if(A[i][j]==0)
{ A[i][j]=MAX_VALUE;
}
}
}
System.out.println("Enter the source vertex");
s=sc.nextInt();
BellmanFord b = new BellmanFord(n);
b.shortest(s,A);
sc.close();
}
}
Output:
Enter the number of vertices
4
Enter the adjacency matrix
0 5 0 0
5 0 3 4
0 3 0 2
0 4 2 0
Enter the source vertex
2
Distance of source 2 to 1 is 5
Distance of source 2 to 2 is 0
Distance of source 2 to 3 is 3
Distance of source 2 to 4 is 4

Department of CSE, BTI Page 35

 Computer Network Laboratory [21CS52] 2023-24
ExperimentNo:6 Date:
Congestion Control Using Leaky Bucket Algorithm
Aim: C 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)).

Figure 2.4 - The leaky bucket traffic shaping algorithm

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.

Department of CSE, BTI Page 36

 Computer Network Laboratory [21CS52] 2023-24

Implementation Algorithm:
Steps:
1. Read The Data ForPackets
2. Read The QueueSize
3. Divide the Data intoPackets
4. Assign the random Propagation delays for each packets to input into the bucket
(input_packet).
5. wlile((Clock++<5*total_packets)and
(out_packets<total_paclets))
a. if (clock ==input_packet)
i. insert intoQueue
b. if (clock % 5 == 0)
i. Remove paclet fromQueue
6. End

Source Code:
import java.util.*;
public class leaky
{
static int min(int x,int y)
{
if(x<y)
return x;
else
return y;
}
public static void main(String[] args)
{ int drop=0,mini,nsec,cap,count=0,i,process;
int inp[]=newint[25];
Scanner sc=new Scanner(System.in);

System.out.println("Enter The Bucket Size\n");

cap= sc.nextInt();
System.out.println("Enter The Operation Rate\n");
process= sc.nextInt();
System.out.println("Enter The No. Of Seconds You Want To Stimulate\n");
nsec=sc.nextInt();
for(i=0;i<nsec;i++)
{ System.out.print("Enter The Size Of The Packet Entering At "+ i+1 +"
sec"); inp[i] = sc.nextInt();

Department of CSE, BTI Page 37

 Computer Network Laboratory [21CS52] 2023-24
}
System.out.println("\nSecond | Packet Recieved | Packet Sent | Packet Left |
Packet Dropped|\n");
//System.out.println("--------------------------------------------------------------------
----\n");
for(i=0;i<nsec;i++)
{ count+=inp[i];
if(count>cap)
{ drop=count-cap;
count=cap;
}
System.out.print(i+1);
System.out.print("\t\t"+inp[i]);
mini=min(count,process);
System.out.print("\t\t"+mini);
count=count-mini;
System.out.print("\t\t"+count);
System.out.print("\t\t"+drop);
drop=0;
System.out.println();
}
for(;count!=0;i++)
{
if(count>cap)
{
drop=count-cap;
count=cap;
}
System.out.print(i+1);
System.out.print("\t\t0");
mini=min(count,process);
System.out.print("\t\t"+mini);
count=count-mini;
System.out.print("\t\t"+count);
System.out.print("\t\t"+drop);
System.out.println();
}
}

Output:

Enter The Bucket Size

5
Enter The Operation Rate
2
Enter The No. Of Seconds You Want To Stimulate
3

Department of CSE, BTI Page 38

 Computer Network Laboratory [21CS52] 2023-24

Enter The Size Of The Packet Entering At 1 sec

5
Enter The Size Of The Packet Entering At 1 sec
4
Enter The Size Of The Packet Entering At 1 sec
3
Second|Packet Recieved|Packet Sent|Packet Left|Packet Dropped|
---------------------------------------------------------------------------------
1 5 2 3 0
2 4 2 3 2
3 3 2 3 1
4 0 2 1 0
5 0 1 0 0

Department of CSE, BTI Page 39

 Computer Network Laboratory [21CS52] 2023-24

VIVA QUESTIONS
1. What are functions of differentlayers?
2. Differentiate between TCP/IP Layers and OSILayers
3. Why header isrequired?
4. What is the use of adding header and trailer toframes?
5. What isencapsulation?
6. Why fragmentationrequires?
7. What isMTU?
8. Which layer imposesMTU?
9. Differentiate between flow control and congestioncontrol.
10. Differentiate between Point-to-Point Connection and End-to-Endconnections.
11. What are protocols running in differentlayers?
12. What is ProtocolStack?
13. Differentiate between TCP andUDP.
14. Differentiate between Connectionless and connection orientedconnection.
15. Why frame sorting isrequired?
16. What is meant bysubnet?
17. What is meant byGateway?
18. What is an IP address?
19. What is MACaddress?
20. Why IP address is required when we have MACaddress?
21. What is meant byport?
22. What are ephemerical port number and well known portnumbers?
23. What is asocket?
24. What are the parameters ofsocket()?
25. Describe bind(), listen(), accept(),connect(), send() andrecv().
26. What are system calls? Mention few ofthem.
27. What is IPC? Name threetechniques.
28. Explain mkfifo(), open(), close() with parameters.
29. What is meant by filedescriptor?
30. What is meant by trafficshaping?
31. How do you classify congestion controlalgorithms?
32. Differentiate between Leaky bucket and Tokenbucket.

Department of CSE, BTI Page 40

 Computer Network Laboratory [21CS52] 2023-24
33. How do you implement Leakybucket?
34. How do you generate bustytraffic?
35. What is the polynomial used inCRC-CCITT?
36. What are the other error detectionalgorithms?
37. What is difference between CRC and Hammingcode?
38. Why Hamming code is called 7,4code?
39. What is odd parity and evenparity?
40. What is meant bysyndrome?
41. What is generatormatrix?
42. What is spanningtree?
43. Differentiate between Prim’s and Kruskal’salgorithm.
44. What are Routingalgorithms?
45. How do you classify routing algorithms? Give examples foreach.
46. What are drawbacks in distance vectoralgorithm?
47. How routers update distances to each of itsneighbor?
48. How do you overcome count to infinityproblem?
49. What iscryptography?
50. How do you classify cryptographicalgorithms?
51. What is publickey?
52. What is privatekey?
53. What are key, ciphertext andplaintext?
54. What issimulation?
55. What are advantages ofsimulation?
56. Differentiate between Simulation andEmulation.
57. What is meant byrouter?
58. What is meant bybridge?
59. What is meant byswitch?
60. What is meant byhub?
61. Differentiate between route, bridge, switch andhub.
62. What is ping andtelnet?
63. What isFTP?
64. What isBER?
65. What is meant by congestionwindow?
66. What isBSS?

Department of CSE, BTI Page 41

 Computer Network Laboratory [21CS52] 2023-24
67. What is incoming throughput and outgoingthroughput?
68. What iscollision?
69. How do you generate multiple traffics across different sender-receiverpairs?
70. How do you setup EthernetLAN?
71. What is meant by mobilehost?
72. What is meant byNCTUns?
73. What are dispatcher, coordinator andnctunsclient?
74. Name few other Network simulators
75. Differentiate between logical and physicaladdress.
76. Which address gets affected if a system moves from one place to anotherplace?
77. What is ICMP? What are uses of ICMP? Namefew.
78. Which layer implements security fordata?

Department of CSE, BTI Page 42

 Computer Network Laboratory [21CS52] 2023-24

REFERENCE

1. Communication Networks: Fundamental Concepts and Key

Architectures - Alberto Leon, Garcia and Indra Widjaja, 3rd Edition, Tata
McGraw- Hill,2004.
2. Data and Computer Communication, William Stallings, 8thtEdition, Pearson
Education,2007.
3. Computer Networks: A Systems Approach - Larry L. Peterson and Bruce S.
David, 4th Edition, Elsevier,2007.
4. Introduction to Data Communications and Networking – Wayne Tomasi,
Pearson Education,2005.
5. Communication Networks – Fundamental Concepts and Key
architectures – Alberto Leon- Garcia and Indra Widjaja:, 2rd Edition, Tata
McGraw-Hill,2004
6. Computer and Communication Networks – Nader F. Mir:, Pearson
Education,2007.

Department of CSE, BTI Page 43