How to implement centralized routing in ns3

To implement the centralized routing in ns3, to evaluate the routes for one another by making the custom routing protocol by use of central node in the network. Get best ideas on implementing centralized routing in ns3 from our programmers.

Here we demonstrate how to implement the centralized routing protocol in ns3:

Step-by-Step Implementation

1. Set Up ns3 Environment: Make sure ns3 is installed in the computer.
2. Include Necessary Libraries: To conclude all the necessary ns3 packages in the script.
3. Define Network Topology: For network topology we make the nodes and links.
4. Install Internet Stack: Install the Internet stack on your nodes.
5. Implement the Centralized Routing Protocol: Generate a custom routing protocol class that calculates and allots routes from a central node.
6. Integrate the Custom Routing Protocol: Integrate your custom routing protocol into the ns3 stack.
7. Set Up Applications: Install applications to generate traffic and test the routing.
8. Run the Simulation: Organize the simulation parameters and execute it.

Example Implementation in C++

Here, we provide the sample reference to complete the script for centralized routing in ns3:

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/ipv4-static-routing-helper.h”

#include <map>

2. 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);

3. Implement the Centralized Routing Protocol:

• Create a new header file centralized-routing.h:

#ifndef CENTRALIZED_ROUTING_H

#define CENTRALIZED_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 CentralizedRouting : public Ipv4RoutingProtocol {

public:

static TypeId GetTypeId(void);

CentralizedRouting();

virtual ~CentralizedRouting();

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 ComputeRoutes();

void DistributeRoutes();

void ReceiveRoutes(Ptr<Socket> socket);

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 // CENTRALIZED_ROUTING_H

Create the corresponding implementation file centralized-routing.cc:

#include “centralized-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(“CentralizedRouting”);

NS_OBJECT_ENSURE_REGISTERED(CentralizedRouting);

TypeId CentralizedRouting::GetTypeId(void) {

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

.SetParent<Ipv4RoutingProtocol>()

.SetGroupName(“Internet”)

.AddConstructor<CentralizedRouting>();

return tid;

}

CentralizedRouting::CentralizedRouting() : m_updateInterval(Seconds(5)) {

NS_LOG_FUNCTION(this);

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

}

CentralizedRouting::~CentralizedRouting() {

NS_LOG_FUNCTION(this);

}

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

NS_LOG_FUNCTION(this << ipv4);

m_ipv4 = ipv4;

}

void CentralizedRouting::Start() {

NS_LOG_FUNCTION(this);

ComputeRoutes();

DistributeRoutes();

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

}

void CentralizedRouting::ComputeRoutes() {

NS_LOG_FUNCTION(this);

// Assume node 0 is the central controller

Ptr<Node> centralNode = NodeList::GetNode(0);

Ptr<Ipv4> centralIpv4 = centralNode->GetObject<Ipv4>();

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

Ipv4Address addr = centralIpv4->GetAddress(i, 0).GetLocal();

for (uint32_t j = 0; j < centralIpv4->GetNInterfaces(); ++j) {

if (i != j) {

Ipv4Address dest = centralIpv4->GetAddress(j, 0).GetLocal();

m_routingTable[dest] = addr;

// Simplified example

}

}

}

}

void CentralizedRouting::DistributeRoutes() {

NS_LOG_FUNCTION(this);

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

for (auto const &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 CentralizedRouting::ReceiveRoutes(Ptr<Socket> socket) {

NS_LOG_FUNCTION(this);

Ptr<Packet> packet = socket->Recv();

Ipv4Header header;

packet->RemoveHeader(header);

Ipv4Address src = header.GetSource();

Ipv4Address dest = header.GetDestination();

m_routingTable[dest] = src;

}

Ptr<Ipv4Route> CentralizedRouting::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 0;

}

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

route->SetDestination(dest);

route->SetGateway(m_routingTable[dest]);

route->SetOutputDevice(oif);

return route;

}

bool CentralizedRouting::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 CentralizedRouting::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(&CentralizedRouting::ReceiveRoutes, this));

m_socketMap[interface] = socket;

}

void CentralizedRouting::NotifyInterfaceDown(uint32_t interface) {

NS_LOG_FUNCTION(this << interface);

m_socketMap[interface]->Close();

m_socketMap.erase(interface);

}

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

NS_LOG_FUNCTION(this << interface << address);

}

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

NS_LOG_FUNCTION(this << interface << address);

}

}

 

4. Integrate the Custom Routing Protocol:

#include “centralized-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;

CentralizedRoutingHelper centralizedRouting;

Ipv4ListRoutingHelper list;

list.Add(centralizedRouting, 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

Here, we explain the process of centralized routing protocol that is:

1. Network Topology: The code sets up a network topology with four nodes connected in a ring.

1. Centralized Routing Protocol: A custom centralized routing protocol class (CentralizedRouting) is implemented. This class handles route computation and distribution from a central node.
2. Route Computation: The ComputeRoutes method computes the routes for all nodes based on the central node’s information.
3. Route Distribution: The DistributeRoutes method broadcasts the computed routes to all nodes in the network.
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 CentralizedRoutingHelper.
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, centralized-routing.cc.
2. Compile the script using the ns3 build system

./waf configure –enable-examples

./waf build

./waf –run scratch/centralized-routing

We had learned here about how the centralized routing protocol will be implemented and executed in ns3 simulation. We also provide additional programming assistance on all centralized routing protocol in ns3simulation.