Ns3 Projects for B.E/B.Tech M.E/M.Tech PhD Scholars.  Phone-Number:9790238391   E-mail: ns3simulation@gmail.com

How to implement distributed routing in ns3

To implement the distributed routing in ns3, this makes the custom routing protocol for that each node individually calculates the routes based on information that receives from its neighbour.

Here are the procedures on how to simulate the distributed routing protocol in ns3 projects:

Step-by-Step Implementation

  1. Set Up ns3 Environment: To make sure ns3 is installed in the computer.
  2. Include Necessary Libraries: In the script we need to add the ns3 libraries.
  3. Define Network Topology: for network topology we make the links and nodes.
  4. Install Internet Stack: download the Internet stack on your nodes.
  5. Implement the Distributed Routing Protocol: To calculates routes in a distributed manner by making the custom routing protocol.
  6. Integrate the Custom Routing Protocol: Incorporate your custom routing protocol into the ns3 stack.
  7. Set up Applications: Download applications to generate traffic and test the routing.
  8. Run the Simulation: Arrange the Performance metrics and executed it.

Example Implementation in C++

The given below are the samples on how to execute the distributed routing protocol in ns3 tool:

  1. Include Libraries:

#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”

#include “ns3/ipv4-routing-protocol.h”

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

#include “ns3/udp-socket.h”

  1. Define Network Topology:

using namespace ns3;

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

CommandLine cmd;

cmd.Parse(argc, argv);

NodeContainer nodes;

nodes.Create(4);

PointToPointHelper pointToPoint;

pointToPoint.SetDeviceAttribute(“DataRate”, StringValue(“5Mbps”));

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

NetDeviceContainer devices01 = pointToPoint.Install(nodes.Get(0), nodes.Get(1));

NetDeviceContainer devices12 = pointToPoint.Install(nodes.Get(1), nodes.Get(2));

NetDeviceContainer devices23 = pointToPoint.Install(nodes.Get(2), nodes.Get(3));

NetDeviceContainer devices30 = pointToPoint.Install(nodes.Get(3), nodes.Get(0));

InternetStackHelper stack;

stack.Install(nodes);

Ipv4AddressHelper address;

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

Ipv4InterfaceContainer interfaces01 = address.Assign(devices01);

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

Ipv4InterfaceContainer interfaces12 = address.Assign(devices12);

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

Ipv4InterfaceContainer interfaces23 = address.Assign(devices23);

address.SetBase(“10.1.4.0”, “255.255.255.0”);

Ipv4InterfaceContainer interfaces30 = address.Assign(devices30);

  1. Implement the Distributed Routing Protocol:
  • Create a new header file distributed-routing.h

#ifndef DISTRIBUTED_ROUTING_H

#define DISTRIBUTED_ROUTING_H

#include “ns3/ipv4-routing-protocol.h”

#include “ns3/ipv4.h”

#include “ns3/net-device.h”

#include “ns3/ptr.h”

#include “ns3/socket.h”

#include <map>

#include <vector>

namespace ns3 {

class DistributedRouting : public Ipv4RoutingProtocol {

public:

static TypeId GetTypeId(void);

DistributedRouting();

virtual ~DistributedRouting();

 

virtual Ptr<Ipv4Route> RouteOutput(

Ptr<Packet> p, const Ipv4Header &header,

Ptr<NetDevice> oif, Socket::SocketErrno &sockerr);

virtual bool RouteInput(

Ptr<const Packet> p, const Ipv4Header &header,

Ptr<const NetDevice> idev,

UnicastForwardCallback ucb, MulticastForwardCallback mcb,

LocalDeliverCallback lcb, ErrorCallback ecb);

virtual void NotifyInterfaceUp(uint32_t interface);

virtual void NotifyInterfaceDown(uint32_t interface);

virtual void NotifyAddAddress(uint32_t interface, Ipv4InterfaceAddress address);

virtual void NotifyRemoveAddress(uint32_t interface, Ipv4InterfaceAddress address);

virtual void SetIpv4(Ptr<Ipv4> ipv4);

void Start();

private:

void ExchangeRoutingInformation();

void UpdateRoutingTable(Ptr<Packet> packet);

void SendRoutingUpdates();

Ptr<Ipv4> m_ipv4;

std::map<Ipv4Address, Ipv4Address> m_routingTable;

std::map<uint32_t, Ptr<Socket>> m_socketMap;

Time m_updateInterval;

EventId m_updateEvent;

};

}

#endif // DISTRIBUTED_ROUTING_H

Create the corresponding implementation file distributed-routing.cc:

#include “distributed-routing.h”

#include “ns3/log.h”

#include “ns3/ipv4-routing-table-entry.h”

#include “ns3/simulator.h”

#include “ns3/inet-socket-address.h”

namespace ns3 {

NS_LOG_COMPONENT_DEFINE(“DistributedRouting”);

NS_OBJECT_ENSURE_REGISTERED(DistributedRouting);

TypeId DistributedRouting::GetTypeId(void) {

static TypeId tid = TypeId(“ns3::DistributedRouting”)

.SetParent<Ipv4RoutingProtocol>()

.SetGroupName(“Internet”)

.AddConstructor<DistributedRouting>();

return tid;

}

DistributedRouting::DistributedRouting() : m_updateInterval(Seconds(5)) {

NS_LOG_FUNCTION(this);

Simulator::Schedule(Seconds(1.0), &DistributedRouting::Start, this);

}

DistributedRouting::~DistributedRouting() {

NS_LOG_FUNCTION(this);

}

void DistributedRouting::SetIpv4(Ptr<Ipv4> ipv4) {

NS_LOG_FUNCTION(this << ipv4);

m_ipv4 = ipv4;

}

void DistributedRouting::Start() {

NS_LOG_FUNCTION(this);

SendRoutingUpdates();

m_updateEvent = Simulator::Schedule(m_updateInterval, &DistributedRouting::Start, this);

}

void DistributedRouting::SendRoutingUpdates() {

NS_LOG_FUNCTION(this);

Ptr<Packet> packet = Create<Packet>();

for (const auto& entry : m_routingTable) {

Ipv4Header header;

header.SetSource(entry.first);

header.SetDestination(entry.second);

packet->AddHeader(header);

}

for (uint32_t i = 0; i < m_ipv4->GetNInterfaces(); ++i) {

Ptr<Socket> socket = m_socketMap[i];

socket->SendTo(packet, 0, InetSocketAddress(Ipv4Address::GetBroadcast(), 80));

}

}

void DistributedRouting::UpdateRoutingTable(Ptr<Packet> packet) {

NS_LOG_FUNCTION(this);

Ipv4Header header;

packet->RemoveHeader(header);

Ipv4Address src = header.GetSource();

Ipv4Address dest = header.GetDestination();

m_routingTable[dest] = src;

}

Ptr<Ipv4Route> DistributedRouting::RouteOutput(

Ptr<Packet> p, const Ipv4Header &header, Ptr<NetDevice> oif,

Socket::SocketErrno &sockerr) {

NS_LOG_FUNCTION(this << p << header << oif << sockerr);

Ipv4Address dest = header.GetDestination();

if (m_routingTable.find(dest) == m_routingTable.end()) {

sockerr = Socket::ERROR_NOROUTETOHOST;

return nullptr;

}

Ptr<Ipv4Route> route = Create<Ipv4Route>();

route->SetDestination(dest);

route->SetGateway(m_routingTable[dest]);

route->SetOutputDevice(oif);

return route;

}

bool DistributedRouting::RouteInput(

Ptr<const Packet> p, const Ipv4Header &header,

Ptr<const NetDevice> idev, UnicastForwardCallback ucb,

MulticastForwardCallback mcb, LocalDeliverCallback lcb,

ErrorCallback ecb) {

NS_LOG_FUNCTION(this << p << header << idev << ucb << mcb << lcb << ecb);

Ipv4Address dest = header.GetDestination();

if (dest == m_ipv4->GetAddress(1, 0).GetLocal()) {

lcb(p, header, idev);

return true;

}

if (m_routingTable.find(dest) == m_routingTable.end()) {

ecb(p, header, Socket::ERROR_NOROUTETOHOST);

return false;

}

Ptr<Ipv4Route> route = Create<Ipv4Route>();

route->SetDestination(dest);

route->SetGateway(m_routingTable[dest]);

route->SetOutputDevice(idev);

ucb(route, p, header);

return true;

}

void DistributedRouting::NotifyInterfaceUp(uint32_t interface) {

NS_LOG_FUNCTION(this << interface);

Ptr<Socket> socket = Socket::CreateSocket(GetObject<Node>(), TypeId::LookupByName(“ns3::UdpSocketFactory”));

socket->SetAllowBroadcast(true);

socket->BindToNetDevice(m_ipv4->GetNetDevice(interface));

socket->Bind(InetSocketAddress(Ipv4Address::GetAny(), 80));

socket->SetRecvCallback(MakeCallback(&DistributedRouting::UpdateRoutingTable, this));

m_socketMap[interface] = socket;

}

void DistributedRouting::NotifyInterfaceDown(uint32_t interface) {

NS_LOG_FUNCTION(this << interface);

m_socketMap[interface]->Close();

m_socketMap.erase(interface);

}

void DistributedRouting::NotifyAddAddress(uint32_t interface, Ipv4InterfaceAddress address) {

NS_LOG_FUNCTION(this << interface << address);

}

void DistributedRouting::NotifyRemoveAddress(uint32_t interface, Ipv4InterfaceAddress address) {

NS_LOG_FUNCTION(this << interface << address);

}

}

  1. Integrate the Custom Routing Protocol:

#include “distributed-routing.h”

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

CommandLine cmd;

cmd.Parse(argc, argv);

NodeContainer nodes;

nodes.Create(4);

PointToPointHelper pointToPoint;

pointToPoint.SetDeviceAttribute(“DataRate”, StringValue(“5Mbps”));

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

NetDeviceContainer devices01 = pointToPoint.Install(nodes.Get(0), nodes.Get(1));

NetDeviceContainer devices12 = pointToPoint.Install(nodes.Get(1), nodes.Get(2));

NetDeviceContainer devices23 = pointToPoint.Install(nodes.Get(2), nodes.Get(3));

NetDeviceContainer devices30 = pointToPoint.Install(nodes.Get(3), nodes.Get(0));

InternetStackHelper stack;

DistributedRoutingHelper distributedRouting;

Ipv4ListRoutingHelper list;

list.Add(distributedRouting, 0);

stack.SetRoutingHelper(list);

stack.Install(nodes);

Ipv4AddressHelper address;

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

address.Assign(devices01);

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

address.Assign(devices12);

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

address.Assign(devices23);

address.SetBase(“10.1.4.0”, “255.255.255.0”);

address.Assign(devices30);

// Set up applications

uint16_t port = 9;

UdpEchoServerHelper server(port);

ApplicationContainer apps = server.Install(nodes.Get(3));

apps.Start(Seconds(1.0));

apps.Stop(Seconds(10.0));

UdpEchoClientHelper client(address.GetAddress(3), port);

client.SetAttribute(“MaxPackets”, UintegerValue(1));

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

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

apps = client.Install(nodes.Get(0));

apps.Start(Seconds(2.0));

apps.Stop(Seconds(10.0));

Simulator::Run();

Simulator::Destroy();

return 0;

}

Explanation

At this point, we describe the process for distributed routing protocol:

  1. Network Topology: The code sets up a network topology with four nodes connected in a ring.
  2. Distributed Routing Protocol: A custom distributed routing protocol class (DistributedRouting) is implemented. This class handles route updates and information exchange among nodes.
  3. Route Updates: The SendRoutingUpdates method sends the current routing table to all neighbors, while the UpdateRoutingTable method updates the routing table based on received information.
  4. Route Input and Output: The RouteInput and RouteOutput methods handle packet routing based on the routing table.
  5. Integrate Custom Routing Protocol: The custom routing protocol is integrated into the ns-3 stack using the DistributedRoutingHelper.
  6. Applications: UdpEchoServer and UdpEchoClient applications are set up to test the routing.

Running the Code

  1. Save your script to a file, for example, distributed-routing.cc.
  2. Compile the script using the ns-3 build system

./waf configure –enable-examples

./waf build

./waf –run scratch/distributed-routing

Overall, we had a knowledge about how distribute routing vector performs and works in ns3 simulators. We also offer further information about the distributed routing vector. If you face any queries in distributed routing protocol in ns3 then feel free to address us all your doubts.