INDEX

S.No. Program Page No. Sign

To understand and study Study of basic network command and

1 2
network configuration commands.

2 Simple project on NS2 – wired and wireless. 3-6

3 Simulation study of pure ALOHA protocol. 7-9

4 Simulation study of slotted ALOHA protocol 10-12

5 Simulation study of Token Bus LAN protocol. 13-15

6 Simulation study of Token Ring LAN protocol. 16-17

7 Simulation study of WAN protocol like Frame Relay, X. 25 18-19

8 Study of 802. 11 wireless LAN protocols. 20-22

Implement the Distance Vector Routing protocol for finding the

9 23-24
shortest path.

Write a program to connect server with client and passes

10 information from one system to another and vice versa that by 25-26
creating / establishing connection.

1
 Experiment - 1
Objective : To understand and study Study of basic network command and network configuration commands.

Theory :
NS2 (Network Simulator 2) is a discrete event simulator primarily used for simulating network protocols, such
as TCP, UDP, routing, and queues in wired and wireless networks.
NAM (Network Animator) is a graphical tool that visualizes the packet movement and node behavior in a
network simulation created in NS2.

Common Network Configuration Commands in NS2:

Command Description

set ns [new Simulator] Creates a new simulator object

set n0 [$ns node] Creates a network node

Creates a bidirectional link between nodes with

$ns duplex-link $n0 $n1 1Mb 10ms DropTail
bandwidth and delay

$ns attach-agent $n0 $udp0 Attaches an agent (e.g., UDP) to a node

$ns connect $udp0 $null1 Connects sender agent to receiver agent

$ns rtproto DV Sets the routing protocol to Distance Vector

$ns at 1.0 "$app start" Schedules an event at a particular time

proc finish {} User-defined procedure to finish simulation

$ns run Starts the simulation

Basic NAM Configuration Commands:

Command Description

$ns namtrace-all $file Creates NAM trace file

$ns duplex-link-op $n0 $n1 orient right Sets orientation of links in NAM

exec nam filename.nam & Launches NAM with the output trace

2
 Experiment - 2
Objective : Simple project on NS2 – wired and wireless

Code Implementation:

1. Wired Simulation -

# Create a simulator
set ns [new Simulator]

# Open trace files

set tracefile [open wired.tr w]
$ns trace-all $tracefile

set namfile [open wired.nam w]

$ns namtrace-all $namfile

# Create nodes
set n0 [$ns node]
set n1 [$ns node]

# Create a duplex link between nodes

$ns duplex-link $n0 $n1 1Mb 10ms DropTail
$ns duplex-link-op $n0 $n1 orient right

# Create UDP agent and attach to node n0

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

# Create Null agent and attach to node n1

set null [new Agent/Null]
$ns attach-agent $n1 $null

# Connect the agents

$ns connect $udp $null

# Attach a CBR application to the UDP agent

set cbr [new Application/Traffic/CBR]
$cbr set packetSize_ 500
$cbr set interval_ 0.5
$cbr attach-agent $udp

# Start and stop traffic

$ns at 0.5 "$cbr start"
$ns at 4.5 "$cbr stop"

3
 # Define finish procedure
proc finish {} {
global ns tracefile namfile
$ns flush-trace
close $tracefile
close $namfile
exec nam wired.nam &
exit 0
}

# Schedule simulation end

$ns at 5.0 "finish"

# Run the simulation

$ns run

Output Simulation:

2. Wireless Simulation
# Create simulator
set ns [new Simulator]

# Define trace and nam files

4
set tracefile [open wireless.tr w]
$ns trace-all $tracefile
set namfile [open wireless.nam w]
$ns namtrace-all $namfile

# Set up topography
set topo [new Topography]
$topo load_flatgrid 500 500

# Create God object

create-god 2

# Configure wireless nodes

$ns node-config -adhocRouting AODV \
-llType LL \
-macType Mac/802_11 \
-ifqType Queue/DropTail/PriQueue \
-ifqLen 50 \
-antType Antenna/OmniAntenna \
-propType Propagation/TwoRayGround \
-phyType Phy/WirelessPhy \
-channelType Channel/WirelessChannel \
-topoInstance $topo \
-agentTrace ON \
-routerTrace ON \
-macTrace ON

# Create wireless nodes

set n0 [$ns node]
set n1 [$ns node]

# Set node positions

$n0 set X_ 100
$n0 set Y_ 100
$n0 set Z_ 0

$n1 set X_ 200

$n1 set Y_ 100
$n1 set Z_ 0

# Fix node positions

$ns at 0.0 "$n0 setdest 100 100 0"
$ns at 0.0 "$n1 setdest 200 100 0"

# Setup UDP agent and CBR traffic

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

5
set null [new Agent/Null]
$ns attach-agent $n1 $null

$ns connect $udp $null

set cbr [new Application/Traffic/CBR]

$cbr set packetSize_ 300
$cbr set interval_ 0.3
$cbr attach-agent $udp

$ns at 1.0 "$cbr start"

$ns at 4.5 "$cbr stop"

# Finish procedure
proc finish {} {
global ns tracefile namfile
$ns flush-trace
close $tracefile
close $namfile
exec nam wireless.nam &
exit 0
}
$ns at 5.0 "finish"
$ns run

Output Simulation:

6
 Experiment - 3
Objective : Simulation study of pure ALOHA protocol.

Code Implementation:
# ALOHA Simulation in NS2 using TCL
# Define simulator
set ns [new Simulator]

# Open trace and NAM files

set tracefile [open aloha.tr w]
$ns trace-all $tracefile

set namfile [open aloha.nam w]

$ns namtrace-all $namfile

# Create nodes
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]

# Positioning for NAM visualization

$n0 set X_ 50
$n0 set Y_ 100
$n1 set X_ 150
$n1 set Y_ 100
$n2 set X_ 250
$n2 set Y_ 100

# Links
$ns duplex-link $n0 $n1 1Mb 10ms DropTail
$ns duplex-link $n2 $n1 1Mb 10ms DropTail

# Set up UDP agents to simulate ALOHA senders

set udp0 [new Agent/UDP]
set udp1 [new Agent/UDP]
$ns attach-agent $n0 $udp0
$ns attach-agent $n2 $udp1

# Null sink at receiver

set null [new Agent/Null]
$ns attach-agent $n1 $null

$ns connect $udp0 $null

$ns connect $udp1 $null

7
# Create traffic generators (CBR) with ALOHA-like behavior (random start times)
set cbr0 [new Application/Traffic/CBR]
$cbr0 set packetSize_ 500
$cbr0 set interval_ 1.0
$cbr0 attach-agent $udp0

set cbr1 [new Application/Traffic/CBR]

$cbr1 set packetSize_ 500
$cbr1 set interval_ 1.0
$cbr1 attach-agent $udp1

# ALOHA: schedule with random times to simulate lack of synchronization

set rng0 [new RandomVariable/Uniform]
$rng0 set min_ 0.5
$rng0 set max_ 1.5
set start0 [$rng0 value]

set rng1 [new RandomVariable/Uniform]

$rng1 set min_ 0.5
$rng1 set max_ 1.5
set start1 [$rng1 value]

# Start CBR traffic with randomized delays

$ns at $start0 "$cbr0 start"
$ns at $start1 "$cbr1 start"

# Stop simulation
$ns at 5.0 "$cbr0 stop"
$ns at 5.0 "$cbr1 stop"
$ns at 5.1 "finish"

proc finish {} {
global ns tracefile namfile
$ns flush-trace
close $tracefile
close $namfile
exec nam aloha.nam &
exit 0
}

# Run simulation
$ns run

8
Output Simulation:

9
 Experiment - 4
Objective : Simulation study of slotted ALOHA protocol.

Code Implementation:
# Slotted ALOHA Simulation in NS2.35
set ns [new Simulator]

# Create trace and nam output files

set tracefile [open slotted_aloha.tr w]
$ns trace-all $tracefile
set namfile [open slotted_aloha.nam w]
$ns namtrace-all-wireless $namfile 500 500

# Define simulation area

set val(x) 500
set val(y) 500

# Number of nodes
set num_nodes 5

# Create the wireless channel

set chan [new Channel/WirelessChannel]

# Topography
set topo [new Topography]
$topo load_flatgrid $val(x) $val(y)

# Configure wireless nodes

$ns node-config -adhocRouting DSDV \
-llType LL \
-macType Mac/802_11 \
-ifqType Queue/DropTail/PriQueue \
-ifqLen 50 \
-antType Antenna/OmniAntenna \
-propType Propagation/TwoRayGround \
-phyType Phy/WirelessPhy \
-channel $chan \
-topoInstance $topo \
-agentTrace ON \
-routerTrace ON \
-macTrace ON

# Create God for routing info

create-god $num_nodes

10
# Create nodes and set initial positions
for {set i 0} {$i < $num_nodes} {incr i} {
set node($i) [$ns node]
$node($i) set X_ [expr 100 + 80 * $i]
$node($i) set Y_ 250
$node($i) set Z_ 0
$ns initial_node_pos $node($i) 30
}

# Create a UDP agent and traffic generator for each node

for {set i 0} {$i < $num_nodes} {incr i} {
# UDP Agent
set udp($i) [new Agent/UDP]
$ns attach-agent $node($i) $udp($i)

# Null sink at node 0 (receiver)

if {$i != 0} {
set null($i) [new Agent/Null]
$ns attach-agent $node(0) $null($i)
$ns connect $udp($i) $null($i)

# CBR traffic
set cbr($i) [new Application/Traffic/CBR]
$cbr($i) set packetSize_ 512
$cbr($i) set interval_ 0.05
$cbr($i) set random_ false
$cbr($i) attach-agent $udp($i)
}
}

# Define slot time (in seconds)

set slot_time 0.1

# Schedule slotted transmissions

set sim_start 1.0
for {set t $sim_start} {$t <= 9.0} {set t [expr $t + $slot_time]} {
# Randomize which node gets to transmit this slot
set sender [expr int(rand() * ($num_nodes - 1)) + 1]
$ns at $t "$cbr($sender) start"
$ns at [expr $t + 0.02] "$cbr($sender) stop"
}

# End simulation
$ns at 10.0 "finish"

proc finish {} {
global ns tracefile namfile

11
 $ns flush-trace
close $tracefile
close $namfile
exec nam slotted_aloha.nam &
exit 0
}

# Run the simulation

$ns run

Output Simulation:

12
 Experiment - 5
Objective : Simulation study of Token Bus LAN protocol.

Code Implementation:
# Token Bus Protocol Simulation in NS2 (fixed layout)

# Create the simulator

set ns [new Simulator]

# Output files
set tracefile [open tokenbus.tr w]
$ns trace-all $tracefile

set namfile [open tokenbus.nam w]

$ns namtrace-all $namfile

# Create 4 nodes
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]

# Create a hub node to simulate bus medium

set hub [$ns node]

# Set positions for clear NAM layout

$n0 set X_ 50
$n1 set X_ 150
$n2 set X_ 250
$n3 set X_ 350

$n0 set Y_ 200

$n1 set Y_ 200
$n2 set Y_ 200
$n3 set Y_ 200

$hub set X_ 200

$hub set Y_ 100

# Connect all nodes to the common hub (bus)

foreach node "$n0 $n1 $n2 $n3" {
$ns duplex-link $node $hub 1Mb 10ms DropTail
}

# Create UDP agents for each node

13
foreach i {0 1 2 3} {
set udp($i) [new Agent/UDP]
set null($i) [new Agent/Null]
set node [eval set n$i]
$ns attach-agent $node $udp($i)
$ns attach-agent $hub $null($i)
$ns connect $udp($i) $null($i)
}

# Create CBR traffic applications (1 per node)

foreach i {0 1 2 3} {
set cbr($i) [new Application/Traffic/CBR]
$cbr($i) set packetSize_ 500
$cbr($i) set interval_ 0.5
$cbr($i) attach-agent $udp($i)
}

# Token-passing logic: each node transmits for 1 second

set time 0.5
for {set i 0} {$i < 4} {incr i} {
$ns at $time "$cbr($i) start"
set stoptime [expr $time + 1.0]
$ns at $stoptime "$cbr($i) stop"
set time $stoptime
}

# End simulation
$ns at [expr $time + 0.5] "finish"

# Finish procedure
proc finish {} {
global ns tracefile namfile
$ns flush-trace
close $tracefile
close $namfile
exec nam tokenbus.nam &
exit 0
}

# Run the simulation

$ns run

14
Output Simulation:

15
 Experiment - 6
Objective : Simulation study of Token Ring LAN protocol.

Code Implementation:
# Token Ring Protocol Simulation in NS2.35
set ns [new Simulator]

# Create trace and NAM files

set tracefile [open token_ring.tr w]
$ns trace-all $tracefile
set namfile [open token_ring.nam w]
$ns namtrace-all $namfile

# Define number of nodes

set num_nodes 5

# Create nodes
for {set i 0} {$i < $num_nodes} {incr i} {
set n($i) [$ns node]
}

# Create a ring topology (each node connects to the next, last connects to first)
for {set i 0} {$i < $num_nodes} {incr i} {
set next [expr ($i + 1) % $num_nodes]
$ns duplex-link $n($i) $n($next) 1Mb 10ms DropTail
$ns duplex-link-op $n($i) $n($next) orient right
}

# Create UDP agents and attach to nodes

for {set i 0} {$i < $num_nodes} {incr i} {
set udp($i) [new Agent/UDP]
$ns attach-agent $n($i) $udp($i)

set null($i) [new Agent/Null]

set recv_index [expr ($i + 1) % $num_nodes]
$ns attach-agent $n($recv_index) $null($i)

$ns connect $udp($i) $null($i)

set cbr($i) [new Application/Traffic/CBR]

$cbr($i) set packetSize_ 500
$cbr($i) set interval_ 0.1
$cbr($i) set random_ false
$cbr($i) attach-agent $udp($i)
}

16
# Define token passing logic
set token_time 0.5
set start_time 1.0
for {set i 0} {$i < $num_nodes} {incr i} {
set t [expr $start_time + $i * $token_time]
$ns at $t "$cbr($i) start"
$ns at [expr $t + 0.3] "$cbr($i) stop"
}

# End simulation
$ns at [expr $start_time + $num_nodes * $token_time + 1] "finish"

# Finish procedure
proc finish {} {
global ns tracefile namfile
$ns flush-trace
close $tracefile
close $namfile
exec nam token_ring.nam &
exit 0
}
# Run the simulation
$ns run

Output Simulation:

17
 Experiment - 7
Objective : Simulation study of WAN protocol like Frame Relay, X. 25.

Code Implementation:
# Frame Relay/X.25 WAN Emulation in NS2
set ns [new Simulator]

# Output files
set tracefile [open wan.tr w]
$ns trace-all $tracefile
set namfile [open wan.nam w]
$ns namtrace-all $namfile

# Create nodes
set siteA [$ns node]
set siteB [$ns node]
set siteC [$ns node]
set fr_switch [$ns node] ;# Acts like a frame relay switch

# Create links (simulate WAN links with delays)

$ns duplex-link $siteA $fr_switch 512Kb 50ms DropTail
$ns duplex-link $siteB $fr_switch 512Kb 50ms DropTail
$ns duplex-link $siteC $fr_switch 512Kb 50ms DropTail

# Position nodes in NAM

$ns duplex-link-op $siteA $fr_switch orient right-up
$ns duplex-link-op $siteB $fr_switch orient right
$ns duplex-link-op $siteC $fr_switch orient right-down

# Create UDP agents (simulate data over VC)

set udpA [new Agent/UDP]
$ns attach-agent $siteA $udpA
set nullB [new Agent/Null]
$ns attach-agent $siteB $nullB

# Create a virtual circuit from Site A -> Site B

$ns connect $udpA $nullB

# Application traffic on VC
set cbr [new Application/Traffic/CBR]
$cbr set packetSize_ 300
$cbr set interval_ 0.1
$cbr attach-agent $udpA

# Start/stop traffic

18
$ns at 1.0 "$cbr start"
$ns at 5.0 "$cbr stop"

# Another VC: Site C → Site A

set udpC [new Agent/UDP]
$ns attach-agent $siteC $udpC

set nullA [new Agent/Null]

$ns attach-agent $siteA $nullA
$ns connect $udpC $nullA

set cbr2 [new Application/Traffic/CBR]

$cbr2 set packetSize_ 300
$cbr2 set interval_ 0.15
$cbr2 attach-agent $udpC

$ns at 2.0 "$cbr2 start"

$ns at 6.0 "$cbr2 stop"

# End simulation
$ns at 7.0 "finish"

proc finish {} {
global ns tracefile namfile
$ns flush-trace
close $tracefile
close $namfile
exec nam wan.nam &
exit 0
} Output Simulation:
$ns run

19
 Experiment - 8
Objective : Study of 802. 11 wireless LAN protocols.

Code Implementation:
# NS2 simulation of IEEE 802.11 Wireless LAN with colored traffic flows

set ns [new Simulator]

# Trace files
set tracefile [open wlan.tr w]
$ns trace-all $tracefile
set namfile [open wlan.nam w]
$ns namtrace-all-wireless $namfile 500 500

# Define topology boundary

set val(x) 500
set val(y) 500

# Define number of nodes

set num_nodes 5

# Create a channel
set chan [new Channel/WirelessChannel]

# Topography
set topo [new Topography]
$topo load_flatgrid $val(x) $val(y)

# Wireless node configuration

$ns node-config -adhocRouting DSDV \
-llType LL \
-macType Mac/802_11 \
-ifqType Queue/DropTail/PriQueue \
-ifqLen 50 \
-antType Antenna/OmniAntenna \
-propType Propagation/TwoRayGround \
-phyType Phy/WirelessPhy \
-channel $chan \
-topoInstance $topo \
-agentTrace ON \
-routerTrace ON \
-macTrace ON \
-movementTrace ON

# Create GOD (required for wireless simulations)

20
create-god $num_nodes

# Create nodes
for {set i 0} {$i < $num_nodes} {incr i} {
set node($i) [$ns node]
$node($i) random-motion 0 ;# disable random motion
}

# Define initial positions and labels

$node(0) set X_ 100; $node(0) set Y_ 100
$node(1) set X_ 400; $node(1) set Y_ 100
$node(2) set X_ 250; $node(2) set Y_ 250
$node(3) set X_ 100; $node(3) set Y_ 400
$node(4) set X_ 400; $node(4) set Y_ 400

# NAM configuration (only label the nodes, color is not supported for wireless nodes)
for {set i 0} {$i < $num_nodes} {incr i} {
$ns at 0.0 "$node($i) label Node-$i"
}

# Define TCP flow setup

proc setup_tcp_flow {src dst flow_color} {
global ns node

set tcp [new Agent/TCP]

set sink [new Agent/TCPSink]
$ns attach-agent $node($src) $tcp
$ns attach-agent $node($dst) $sink
$ns connect $tcp $sink
$tcp set fid_ $flow_color

set ftp [new Application/FTP]

$ftp attach-agent $tcp
return $ftp
}

# Setup three flows

set ftp1 [setup_tcp_flow 0 2 1] ;# red
set ftp2 [setup_tcp_flow 1 3 2] ;# green
set ftp3 [setup_tcp_flow 4 2 3] ;# blue

# Start traffic
$ns at 1.0 "$ftp1 start"
$ns at 2.0 "$ftp2 start"
$ns at 3.0 "$ftp3 start"

# Optional mobility

21
$ns at 0.5 "$node(0) setdest 200 200 10"
$ns at 1.0 "$node(1) setdest 300 300 10"
$ns at 1.5 "$node(4) setdest 200 350 15"

# Finish
$ns at 10.0 "finish"

proc finish {} {
global ns tracefile namfile
$ns flush-trace
close $tracefile
close $namfile
exec nam wlan.nam &
exit 0
}

# Run simulation
$ns run

Output Simulation:

22
 Experiment - 9
Objective : Implement the Distance Vector Routing protocol for finding the shortest path.

Code Implementation:
# Distance Vector Routing Simulation in NS2

# Create simulator
set ns [new Simulator]

# Open trace files

set tracefile [open dv.tr w]
$ns trace-all $tracefile
set namfile [open dv.nam w]
$ns namtrace-all $namfile

# Define nodes
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]

# Positioning for NAM

$ns duplex-link $n0 $n1 1Mb 10ms DropTail
$ns duplex-link $n1 $n2 1Mb 10ms DropTail
$ns duplex-link $n2 $n3 1Mb 10ms DropTail
$ns duplex-link $n0 $n2 1Mb 30ms DropTail ;# Higher cost path

$ns duplex-link-op $n0 $n1 orient right

$ns duplex-link-op $n1 $n2 orient right
$ns duplex-link-op $n2 $n3 orient down
$ns duplex-link-op $n0 $n2 orient down-right

# Set routing protocol to Distance Vector

$ns rtproto DV

# Attach UDP agents

set udp0 [new Agent/UDP]
set null3 [new Agent/Null]
$ns attach-agent $n0 $udp0
$ns attach-agent $n3 $null3
$ns connect $udp0 $null3

# CBR traffic over UDP

set cbr0 [new Application/Traffic/CBR]
$cbr0 set packetSize_ 1000

23
$cbr0 set interval_ 0.5
$cbr0 attach-agent $udp0

# Start simulation
$ns at 1.0 "$cbr0 start"
$ns at 5.0 "$cbr0 stop"

# Finish
$ns at 6.0 "finish"

proc finish {} {
global ns tracefile namfile
$ns flush-trace
close $tracefile
close $namfile
exec nam dv.nam &
exit 0
}

$ns run

Output Simulation:

24
 Experiment - 10
Objective : Write a program to connect server with client and passes information from one system to another
and vice versa that by creating / establishing connection.

Code Implementation:
1. Server –

import socket

# Create a TCP/IP socket

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Bind the socket to a specific address and port

server_host = '0.0.0.0' # Listens on all interfaces
server_port = 12345
server_socket.bind((server_host, server_port))

# Listen for incoming connections

server_socket.listen(1)
print(f"[+] Server listening on port {server_port}...")

# Accept a connection
conn, addr = server_socket.accept()
print(f"[+] Connection established with {addr}")

while True:
# Receive message from client
data = conn.recv(1024).decode()
if data.lower() == 'exit':
print("[-] Client disconnected.")
break
print(f"Client says: {data}")

# Send reply to client

reply = input("Server reply: ")
conn.send(reply.encode())

conn.close()
server_socket.close()

2. Client –

import socket

# Create a TCP/IP socket

25
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Enter the server's IP address here

server_ip = input("127.0.0.1")
server_port = 12345

# Connect to server
client_socket.connect((server_ip, server_port))
print("[+] Connected to the server.")

while True:
# Send message to server
message = input("You: ")
client_socket.send(message.encode())

if message.lower() == 'exit':
break

# Receive server's reply

data = client_socket.recv(1024).decode()
print(f"Server says: {data}")

client_socket.close()

Output Simulation:

26