How to Start Interior Gateway Routing Protocol Using NS3

To start an Interior Gateway Routing Protocol (IGRP) project using NS3 has series of steps to execute or replicate a routing protocol that are utilized in an autonomous system. Although NS3 doesn’t directly support IGRP, we can either manually execute the protocol or adjust it to utilize custom routing aspects, which are offered by NS3.

Here’s a structured method on how to start the IGRP Projects in NS3:

Steps to Start IGRP Projects in NS3

1. Understand IGRP

• What is IGRP?
  • Cisco is created IGRP that is a distance-vector routing protocol.
  • Key Features:
    • Indicators like bandwidth, delay, load, and reliability.
    • Periodic updates sustaining the routing tables.
    • This protocol is used hierarchical routing.
• Why Use IGRP?
  • It is created for scalability in large networks.
  • Utilize several parameters, to scales traffic.

2. Set Up NS3

• Install NS3:
  • Go to nsnam.org then we can download and install NS3.
• Verify Installation:

./waf –run scratch/test-example

• Required Modules:
  • internet: It supports for the IPv4 stack and basic routing.
  • point-to-point: This module is utilized for wired network replication.

3. Plan Your IGRP Project

• Define Objectives:
  • To execute the IGRP logic that is metric-based distance-vector routing.
  • Measure the performance of IGRP such as convergence time, throughput.
• Possible Scenarios:
  • We replicate hierarchical routing within a large network.
  • Experiment the IGRP convergence in topology changes.
• Metrics to Measure:
  • We compute the performance indicators such as routing convergence time, packet delivery ratio and routing overhead.

4. Write a Basic Network Simulation

• Simplified network topology used to replicate the distance-vector routing.
• Example: Static Routing Simulation

#include “ns3/core-module.h”

#include “ns3/network-module.h”

#include “ns3/internet-module.h”

#include “ns3/point-to-point-module.h”

#include “ns3/applications-module.h”

using namespace ns3;

int main(int argc, char *argv[]) {

CommandLine cmd;

cmd.Parse(argc, argv);

NodeContainer nodes;

nodes.Create(4); // Create 4 nodes

PointToPointHelper p2p;

p2p.SetDeviceAttribute(“DataRate”, StringValue(“10Mbps”));

p2p.SetChannelAttribute(“Delay”, StringValue(“2ms”));

NetDeviceContainer devices1 = p2p.Install(nodes.Get(0), nodes.Get(1));

NetDeviceContainer devices2 = p2p.Install(nodes.Get(1), nodes.Get(2));

NetDeviceContainer devices3 = p2p.Install(nodes.Get(2), nodes.Get(3));

InternetStackHelper stack;

stack.Install(nodes);

Ipv4AddressHelper ipv4;

ipv4.SetBase(“10.1.1.0”, “255.255.255.0”);

ipv4.Assign(devices1);

ipv4.SetBase(“10.1.2.0”, “255.255.255.0”);

ipv4.Assign(devices2);

ipv4.SetBase(“10.1.3.0”, “255.255.255.0”);

ipv4.Assign(devices3);

// Simulate custom routing logic (e.g., metric-based distance vector)

UdpEchoServerHelper echoServer(9);

ApplicationContainer serverApp = echoServer.Install(nodes.Get(3));

serverApp.Start(Seconds(1.0));

serverApp.Stop(Seconds(10.0));

UdpEchoClientHelper echoClient(Ipv4Address(“10.1.3.1”), 9);

echoClient.SetAttribute(“MaxPackets”, UintegerValue(5));

echoClient.SetAttribute(“Interval”, TimeValue(Seconds(1.0)));

echoClient.SetAttribute(“PacketSize”, UintegerValue(1024));

ApplicationContainer clientApp = echoClient.Install(nodes.Get(0));

clientApp.Start(Seconds(2.0));

clientApp.Stop(Seconds(10.0));

p2p.EnablePcapAll(“igrp-project”);

Simulator::Run();

Simulator::Destroy();

return 0;

}

5. Implement IGRP Logic

• Extend NS3’s Routing Protocol:
  • Make a custom routing protocol by means of prolonging the Ipv4RoutingProtocol class.
  • Implement key methods:
    • RouteInput(): To manage incoming packets.
    • RouteOutput(): We need to find the next hop for outgoing packets.
    • PeriodicUpdates(): Transmitting updates on usual intervals.
• Key Features to Implement:
  • Metric Calculation:
    • We can utilize indicators such as bandwidth, delay, and reliability for calculation.
    • Example: Metric = (K1 * Bandwidth) + (K2 * Delay) where K1 and K2 are constants.
  • Distance Vector Updates:
    • Nodes occasionally swap the routing tables.
    • According to the lowest metric to modernize routes.
  • Loop Prevention:
    • Prevent routing loops to utilize split horizon or hold-down timers.

6. Test and Debug

• Enable Logging:

export NS_LOG=Ipv4RoutingProtocol=level_all

./waf –run scratch/igrp-project

• Verify Routing Logic:
  • In the course of simulation, we can print routing tables:

Ptr<Ipv4> ipv4 = nodes.Get(0)->GetObject<Ipv4>();

ipv4->GetRoutingProtocol()->Print(std::cout);

• Analyze Traffic Flow:
  • Inspect packets within Wireshark to utilise PCAP tracing.

7. Evaluate IGRP Performance

• Metrics to Measure:
  • Convergence Time: We assess the duration for the routing table to stable after a change.
  • Packet Delivery Ratio: We measure the ratio of effectively distributed packets.
  • Routing Overhead: Compute the volumes of control traffic that are made.
• Use FlowMonitor:

FlowMonitorHelper flowMonitor;

Ptr<FlowMonitor> monitor = flowMonitor.InstallAll();

8. Advanced Features

• Hierarchical Routing:
  • To replicate the larger networks including hierarchical models.
• Dynamic Topology Changes:
  • Launch link failures and then experiment the adaptability of IGRP.
• Comparison with Other Protocols:
  • Then, we equate the IGRP with RIP or OSPF such as scalability and performance.

In the end, we discussed about how to start and analyse the Interior Gateway Routing Protocols projects with the support of above offered procedure in NS3 simulation tool. If you have any doubts on this subject, we will clear it.

Get personalized support from phdprojects.org. We implement or replicate a routing protocol based on your research specifics. Our approach is systematic, providing you with clear explanations at each step. For optimal project outcomes, you can rely on our experts, who will assist you throughout every phase of your Interior Gateway Routing Protocol Projects using the NS3 tool.