How to Start IGP Protocol Projects Using NS2

To create an Interior Gateway Protocol (IGP) project using NS2 (Network Simulator 2) has includes the replicating for routing in an autonomous system (AS) using protocols such as RIP, OSPF, or EIGRP. Here’s a detailed guide to help you get started:

Steps to Start IGP Protocol Projects Using NS2

  1. Understand IGP and NS2 Capabilities
  • Interior Gateway Protocol (IGP): A protocol used to modify the routing information in a single AS. In general sample has involves:
    • RIP: Routing Information Protocol like as based on the distance-vector.
    • OSPF: Open Shortest Path First such as based on the link-state.
    • EIGRP: Improved the Interior Gateway Routing Protocol for instance advanced distance-vector protocol.
  • NS2 Features: NS2 helps for modify the routing protocols by its modular architecture; ensure the replication of IGP protocols.
  1. Set Up Your Environment
  • Install NS2 and related tools:

sudo apt-get install ns2

  • Validate the installation through process for sample script.
  1. Define the Project Scope
  • Select the IGP Protocol:
    • RIP: Replicate the simple distance-vector routing.
    • OSPF: The link-state protocol has replicates the further complex.
    • EIGRP: Replicate the advanced features such as unequal-cost load balancing.
  • Define Objectives:
    • Analysis the protocol’s routing table convergence.
    • Associate the routing performance for parameter metrics for sample delay, throughput, and overhead.
    • It replicates the network alter such as connection failures and recovery.
  1. Design the Network Topology
  • Topology Design:
    • It build a nodes demonstrate the routers or hosts.
    • Connect the nodes using duplex connection by appropriate bandwidth and delay.
    • Describe the routers in a single AS to execute the IGP protocol.
  • Example Topology:
    • A network contains the six nodes creating a mesh or hierarchical structure.
  1. Configure IGP Protocol
  • While NS2 does not help for built-in the protocols such as OSPF or EIGRP, you can:
    • RIP Simulation: Use a RIP for simple execution for sample distance-vector logic.
    • Custom Implementation: Encompass the NS2 through altering the C++ modules or using previous IGP extensions.

Example TCL Script for IGP (RIP) Simulation:

# Initialize the simulator

set ns [new Simulator]

# Open trace and NAM files

set tracefile [open igp_trace.tr w]

$ns trace-all $tracefile

set namfile [open igp_simulation.nam w]

$ns namtrace-all $namfile

# Create nodes

set n0 [$ns node]

set n1 [$ns node]

set n2 [$ns node]

set n3 [$ns node]

set n4 [$ns node]

set n5 [$ns node]

# Connect nodes

$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 $n3 $n4 1Mb 10ms DropTail

$ns duplex-link $n4 $n5 1Mb 10ms DropTail

$ns duplex-link $n0 $n5 1Mb 10ms DropTail

# Configure RIP routing

$n0 set-routing-protocol “RIP”

$n1 set-routing-protocol “RIP”

$n2 set-routing-protocol “RIP”

$n3 set-routing-protocol “RIP”

$n4 set-routing-protocol “RIP”

$n5 set-routing-protocol “RIP”

# Application traffic

set udp [new Agent/UDP]

$ns attach-agent $n0 $udp

set null [new Agent/Null]

$ns attach-agent $n5 $null

$ns connect $udp $null

# Traffic generation

set cbr [new Application/Traffic/CBR]

$cbr set packetSize_ 512

$cbr set interval_ 0.1

$cbr attach-agent $udp

$ns at 1.0 “$cbr start”

$ns at 5.0 “$cbr stop”

# Terminate simulation

$ns at 10.0 “finish”

proc finish {} {

global ns tracefile namfile

$ns flush-trace

close $tracefile

close $namfile

exec nam igp_simulation.nam &

exit 0

}

$ns run

  1. Simulate Network Changes
  • Launch the dynamic events such as connection failures or new nodes to validate the protocol adaptability:

$ns rtmodel-at 3.0 down $n1 $n2

$ns rtmodel-at 5.0 up $n1 $n2

  1. Run the Simulation
  • Implement the TCL script:

ns igp_simulation.tcl

  • NAM using the envision of the replication:

nam igp_simulation.nam

  1. Analyze Performance
  • Extract data from the trace file (igp_trace.tr) to evaluate:
    • Convergence Time: The convergence rate takes the duration of bring up-to-date routing tables next modify the topology.
    • Packet Delivery Ratio (PDR): In PDR has Ratio of achieved delivered packets.
    • Routing Overhead: The routing overhead has number of control messages modified.
  • Use the tools for AWK or Python for analysis.

Example AWK Script for Convergence Time:

BEGIN {start=0; end=0;}

{

if ($1 == “s” && $4 == “Routing”) {

if (start == 0) {

start = $2;

}

} else if ($1 == “r” && $4 == “Routing”) {

end = $2;

}

}

END {

print “Convergence Time:”, end – start;

}

  1. Extend or Compare IGP Protocols
  • Estimate or encompass the protocols such as OSPF or EIGRP:
    • OSPF: Execute the link-state advertisements and measure the shortest-path.
    • EIGRP: Establish the advanced distance-vector logic for instance unequal-cost load balancing.
  • Associate the IGPs based on:
    • Latency.
    • Scalability.
    • Resource utilization.
  1. Document the Project
  • Include:
    • It starts with objectives and scope.
    • Then it process for the network topology and configurations.
    • After the process gives the simulation outcomes for sample graphs, tables.
    • Finally it gives the observations and recommendations for future work.

Suggested Enhancements

  • Security Additions:
    • Secure the routing bring up-to-date to avoid the spoofing.
  • Energy Efficiency:
    • Validate the IGP performance in energy-constrained environments for sample IoT.
  • Scalability Testing:
    • Replicate the larger AS by hundreds of nodes.

Tools for Advanced Analysis

  • Wireshark: Import the trace files for deeper investigation.
  • MATLAB or Python: Create a performance metrices for graphs and envision.

With the help of this procedure you can obtain the knowledge and can be able to simulate the Interior Gateway Protocol projects in ns2 tool. Should there more quires we can address another document.