How to Start Layer 3 Routed Protocol Projects Using NS3

To start Layer 3 routed protocols in NS3 that includes to functioning with IP-based (Layer 3) routing protocols, allowing packet forwarding and routing over a network. Layer 3 protocols instances contain OSPF (Open Shortest Path First), BGP (Border Gateway Protocol), RIP (Routing Information Protocol), and AODV (Ad hoc On-Demand Distance Vector). NS3 environment has some Layer 3 routing protocols such as AODV, DSDV, OLSR that mainly created for MANETs, and also NS3 directly supports static routing and RIP.

Here’s a simple guide to configuring a basic Layer 3 routed network using NS3 and demonstrate how to utilize existing routing helpers for IP-based routing.

Step-by-Step Guide to Set Up Layer 3 Routed Protocols in NS3

Option 1: Using Static Routing

Static Routing is a direct way routing packets within a network by described the fixed routes each node. This method is helpful for small networks in which routes don’t actively modify.

Option 2: Using Dynamic Routing Protocols (e.g., RIP, AODV, OLSR)

NS3 environment offers numerous dynamic routing protocols, which function on Layer 3:

  • RIP (Routing Information Protocol): A distance-vector protocol matched for smaller networks.
  • AODV (Ad hoc On-Demand Distance Vector): In MANETs, generally used reactive routing protocol.
  • OLSR (Optimized Link State Routing): A proactive link-state protocol also utilised within MANETs.

Example Setup for Layer 3 Routed Protocols

In this instance, utilize RIP and AODV like Layer 3, we will make a basic network of nodes to routing protocols to illustrate both static and dynamic routing methods.

Step 1: Create a New Script for Layer 3 Routing

In the NS3’s scratch directory, we need to save the following code like layer3_routed_protocol_simulation.cc in

Example Code for layer3_routed_protocol_simulation.cc

Here’s an instance illustrates how to configure both RIP (for static networks) and AODV (for dynamic or mobile networks) in NS3.

#include “ns3/core-module.h”

#include “ns3/network-module.h”

#include “ns3/internet-module.h”

#include “ns3/rip-helper.h”

#include “ns3/aodv-helper.h”

#include “ns3/ipv4-static-routing-helper.h”

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

#include “ns3/mobility-module.h”

#include “ns3/applications-module.h”

using namespace ns3;

NS_LOG_COMPONENT_DEFINE(“Layer3RoutedProtocolSimulation”);

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

LogComponentEnable(“Layer3RoutedProtocolSimulation”, LOG_LEVEL_INFO);

// Create nodes

NodeContainer staticNodes;

staticNodes.Create(3); // Nodes for static routing with RIP

NodeContainer dynamicNodes;

dynamicNodes.Create(3); // Nodes for dynamic routing with AODV

// Set up point-to-point links for static nodes

PointToPointHelper p2p;

p2p.SetDeviceAttribute(“DataRate”, StringValue(“1Gbps”));

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

NetDeviceContainer staticDevices1 = p2p.Install(NodeContainer(staticNodes.Get(0), staticNodes.Get(1)));

NetDeviceContainer staticDevices2 = p2p.Install(NodeContainer(staticNodes.Get(1), staticNodes.Get(2)));

// Set up wireless links for dynamic nodes

WifiHelper wifi;

wifi.SetStandard(WIFI_STANDARD_80211b);

YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default();

YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default();

wifiPhy.SetChannel(wifiChannel.Create());

WifiMacHelper wifiMac;

wifiMac.SetType(“ns3::AdhocWifiMac”);

NetDeviceContainer dynamicDevices = wifi.Install(wifiPhy, wifiMac, dynamicNodes);

// Install Internet stack and set up static routing with RIP on static nodes

InternetStackHelper internetStatic;

RipHelper ripRouting;

Ipv4ListRoutingHelper listStatic;

listStatic.Add(ripRouting, 0);

internetStatic.SetRoutingHelper(listStatic);

internetStatic.Install(staticNodes);

// Install Internet stack and set up dynamic routing with AODV on dynamic nodes

InternetStackHelper internetDynamic;

AodvHelper aodvRouting;

Ipv4ListRoutingHelper listDynamic;

listDynamic.Add(aodvRouting, 0);

internetDynamic.SetRoutingHelper(listDynamic);

internetDynamic.Install(dynamicNodes);

// Assign IP addresses

Ipv4AddressHelper ipv4;

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

ipv4.Assign(staticDevices1);

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

ipv4.Assign(staticDevices2);

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

ipv4.Assign(dynamicDevices);

// Configure mobility for dynamic nodes

MobilityHelper mobility;

mobility.SetPositionAllocator(“ns3::GridPositionAllocator”,

“MinX”, DoubleValue(0.0),

“MinY”, DoubleValue(0.0),

“DeltaX”, DoubleValue(50.0),

“DeltaY”, DoubleValue(50.0),

“GridWidth”, UintegerValue(3),

“LayoutType”, StringValue(“RowFirst”));

mobility.SetMobilityModel(“ns3::RandomWaypointMobilityModel”);

mobility.Install(dynamicNodes);

// Set up a UDP echo server on the last node of static nodes

UdpEchoServerHelper echoServer(9);

ApplicationContainer serverApps = echoServer.Install(staticNodes.Get(2));

serverApps.Start(Seconds(1.0));

serverApps.Stop(Seconds(10.0));

// Set up a UDP echo client on the first node of dynamic nodes to communicate with the server

UdpEchoClientHelper echoClient(Ipv4Address(“10.1.2.2”), 9); // Target IP of the last static node

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

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

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

ApplicationContainer clientApps = echoClient.Install(dynamicNodes.Get(0));

clientApps.Start(Seconds(2.0));

clientApps.Stop(Seconds(10.0));

// Print routing tables at each node for debugging

Ipv4StaticRoutingHelper staticRoutingHelper;

for (uint32_t i = 0; i < staticNodes.GetN(); ++i) {

Ptr<OutputStreamWrapper> routingStream = Create<OutputStreamWrapper>(&std::cout);

staticRoutingHelper.PrintRoutingTableAt(Seconds(3.0), staticNodes.Get(i), routingStream);

}

Simulator::Run();

Simulator::Destroy();

return 0;

}

Explanation of the Code

  • Static Nodes with RIP:
    • We set three nodes for static point-to-point interaction to utilize RIP like the routing protocol. RIP routes among the nodes by utilising a distance-vector method.
  • Dynamic Nodes with AODV:
    • Three more nodes are configured to use AODV for mobile ad hoc interaction, a reactive routing protocol, which determines the routes on-demand.
  • Network Configuration:
    • For the static nodes, Point-to-Point links are utilized.
    • WiFi Ad hoc mode is used for dynamic nodes.
  • Mobility Model:
    • Dynamic nodes are allocated a RandomWaypointMobilityModel, replicating movement.
  • Applications:
    • A UDP Echo Server is configured at the end static node.
    • On the initial dynamic node, UDP Echo Client transmits the packets to the server, analysing end-to-end connectivity.
  • Routing Table Debugging:
    • Static routing tables are carried to the comfort at 3 seconds confirming the routing configuration.

Step 2: Build and Run the Simulation

  1. In the scratch directory, we need to save layer3_routed_protocol_simulation.cc.
  2. Go to a terminal, pass through to NS3 directory, and then make the script:

./ns3 build

  1. Run the simulation:

./ns3 run scratch/layer3_routed_protocol_simulation

Above code will run the simulation then we will be observed log messages to show the routing activity, packet forwarding, and UDP application messages.

Further Experimentation Ideas

To discover more advanced Layer 3 routing behavior, we can deliberate:

  • Add More Nodes and Complex Topologies: Append additional static and dynamic nodes and also set a larger network including more complex topologies.
  • Use Different Routing Protocols: Test with other routing protocols like OLSR or DSDV, both of which are also obtainable within NS3.
  • Enable Mobility for All Nodes: For both static and dynamic nodes, allow mobility to experiment the performance of routing in a complete mobile network.
  • Use FlowMonitor: We need to observe packet delivery ratios, end-to-end delay, and routing overhead, estimating protocol efficiency.

In this guide, we clearly showed the simulation process and example coding that related to the Layer 3 Routed Protocol that were executed and simulated within NS3 simulation tool. Additional specific details were also provided about this project.

For great results in your projects, let our team take care of your needs. Rely on us to improve your project performance. You can be confident that our prices are fair, and our experts provide reliable, high-quality work on time.

Contact phdprojects.org for more help. phdprojects.org specializes in Layer 3 Routed Protocol Projects using the NS3 tool, offering customized and high-quality simulations for researchers. Our experienced team is skilled in OSPF (Open Shortest Path First), BGP (Border Gateway Protocol), RIP (Routing Information Protocol), and AODV (Ad hoc On-Demand Distance Vector), with detailed explanations.