How to implement bellman ford routing in ns3

To implement the Bellman-Ford routing algorithm in ns3, we need to make a custom routing protocol that makes uses the bellman-ford techniques to evaluate the shortest paths in the network.

The given below is the step by procedures how to implement the bellman ford routing 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 required ns3 libraries in the script.
3. Define Network Topology: To build a network topology then Create the nodes and links.
4. Install Internet Stack: Download the Internet stack on your nodes.
5. Implement the Bellman-Ford Routing Protocol: Generate a custom routing protocol class that uses the Bellman-Ford algorithm to calculate shortest paths.
6. Integrate the Custom Routing Protocol: Incorporated your custom routing protocol into the ns3 stack.
7. Set up Applications: Download applications to produce traffic and test the routing.
8. Run the Simulation: Configure the simulation parameters and run it.

Example Implementation in C++

Here is the sample reference to complete the script for bellman ford routing protocol 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”

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 devices;

devices.Add(pointToPoint.Install(nodes.Get(0), nodes.Get(1)));

devices.Add(pointToPoint.Install(nodes.Get(1), nodes.Get(2)));

devices.Add(pointToPoint.Install(nodes.Get(2), nodes.Get(3)));

devices.Add(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(devices.Get(0));

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

Ipv4InterfaceContainer interfaces12 = address.Assign(devices.Get(1));

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

Ipv4InterfaceContainer interfaces23 = address.Assign(devices.Get(2));

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

Ipv4InterfaceContainer interfaces30 = address.Assign(devices.Get(3));

3. Implement the Bellman-Ford Routing Protocol:

• Create a new header file bellman-ford-routing.h:

#ifndef BELLMAN_FORD_ROUTING_H

#define BELLMAN_FORD_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 <vector>

#include <map>

namespace ns3 {

class BellmanFordRouting : public Ipv4RoutingProtocol {

public:

static TypeId GetTypeId(void);

BellmanFordRouting();

virtual ~BellmanFordRouting();

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

void BroadcastRoutingUpdates();

void ReceiveRoutingUpdates(Ptr<Socket> socket);

Ptr<Ipv4> m_ipv4;

std::map<Ipv4Address, uint32_t> m_distanceVector;

std::map<Ipv4Address, Ipv4Address> m_nextHop;

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

Time m_updateInterval;

EventId m_updateEvent;

};

}

#endif // BELLMAN_FORD_ROUTING_H

Create the corresponding implementation file bellman-ford-routing.cc:

#include “bellman-ford-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(“BellmanFordRouting”);

NS_OBJECT_ENSURE_REGISTERED(BellmanFordRouting);

TypeId BellmanFordRouting::GetTypeId(void) {

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

.SetParent<Ipv4RoutingProtocol>()

.SetGroupName(“Internet”)

.AddConstructor<BellmanFordRouting>();

return tid;

}

BellmanFordRouting::BellmanFordRouting() : m_updateInterval(Seconds(5)) {

NS_LOG_FUNCTION(this);

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

}

BellmanFordRouting::~BellmanFordRouting() {

NS_LOG_FUNCTION(this);

}

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

NS_LOG_FUNCTION(this << ipv4);

m_ipv4 = ipv4;

}

void BellmanFordRouting::Start() {

NS_LOG_FUNCTION(this);

BellmanFordAlgorithm();

BroadcastRoutingUpdates();

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

}

void BellmanFordRouting::BellmanFordAlgorithm() {

NS_LOG_FUNCTION(this);

// Initialize distances and next hops

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

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

m_distanceVector[addr] = (addr == m_ipv4->GetAddress(1, 0).GetLocal()) ? 0 : UINT32_MAX;

m_nextHop[addr] = Ipv4Address::GetAny();

}

// Bellman-Ford algorithm

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

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

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

Ipv4Address neighbor = m_ipv4->GetAddress(j, 0).GetLocal();

if (m_distanceVector[addr] > m_distanceVector[neighbor] + 1) {

m_distanceVector[addr] = m_distanceVector[neighbor] + 1;

m_nextHop[addr] = neighbor;

}

}

}

}

void BellmanFordRouting::BroadcastRoutingUpdates() {

NS_LOG_FUNCTION(this);

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

for (auto it : m_distanceVector) {

Ipv4Address addr = it.first;

uint32_t distance = it.second;

packet->AddHeader(Ipv4Header(addr, Ipv4Address::GetBroadcast(), distance, 0));

}

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 BellmanFordRouting::ReceiveRoutingUpdates(Ptr<Socket> socket) {

NS_LOG_FUNCTION(this);

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

Ipv4Header header;

packet->RemoveHeader(header);

Ipv4Address addr = header.GetDestination();

uint32_t distance = header.GetIdentification();

if (m_distanceVector[addr] > distance) {

m_distanceVector[addr] = distance;

m_nextHop[addr] = header.GetSource();

}

}

Ptr<Ipv4Route> BellmanFordRouting::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_nextHop.find(dest) == m_nextHop.end()) {

sockerr = Socket::ERROR_NOROUTETOHOST;

return 0;

}

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

route->SetDestination(dest);

route->SetGateway(m_nextHop[dest]);

route->SetOutputDevice(oif);

return route;

}

bool BellmanFordRouting::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_nextHop.find(dest) == m_nextHop.end()) {

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

return false;

}

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

route->SetDestination(dest);

route->SetGateway(m_nextHop[dest]);

route->SetOutputDevice(idev);

ucb(route, p, header);

return true;

}

void BellmanFordRouting::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(&BellmanFordRouting::ReceiveRoutingUpdates, this));

m_socketMap[interface] = socket;

}

void BellmanFordRouting::NotifyInterfaceDown(uint32_t interface) {

NS_LOG_FUNCTION(this << interface);

m_socketMap[interface]->Close();

m_socketMap.erase(interface);

}

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

NS_LOG_FUNCTION(this << interface << address);

}

Void BellmanFordRouting::NotifyRemoveAddress(uint32_tinterface,    Ipv4InterfaceAddress address) {

NS_LOG_FUNCTION (this << interface << address);

}

}

4. Integrate the Custom Routing Protocol:

#include “bellman-ford-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 devices;

devices.Add(pointToPoint.Install(nodes.Get(0), nodes.Get(1)));

devices.Add(pointToPoint.Install(nodes.Get(1), nodes.Get(2)));

devices.Add(pointToPoint.Install(nodes.Get(2), nodes.Get(3)));

devices.Add(pointToPoint.Install(nodes.Get(3), nodes.Get(0)));

InternetStackHelper stack;

BellmanFordRoutingHelper bellmanFordRouting;

Ipv4ListRoutingHelper list;

list.Add(bellmanFordRouting, 0);

stack.SetRoutingHelper(list);

stack.Install(nodes);

Ipv4AddressHelper address;

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

address.Assign(devices);

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

The given below are process for bellman ford routing protocol that are

1. Network Topology: The code sets up a network topology with four nodes connected in a ring.
2. Bellman-Ford Routing Protocol: A custom Bellman-Ford routing protocol class (BellmanFordRouting) is implemented. This class handles distance vector calculations and updates the routing table accordingly.
3. Distance Vector Calculation: The BellmanFordAlgorithm method initializes and computes the distance vectors using the Bellman-Ford algorithm.
4. Routing Updates: The BroadcastRoutingUpdates method broadcasts routing updates to neighbors, and ReceiveRoutingUpdates handles incoming updates.
5. Route Input and Output: The RouteInput and RouteOutput methods handle packet routing using the computed distance vectors.
6. Integrate Custom Routing Protocol: The custom routing protocol is integrated into the ns-3 stack using the BellmanFordRoutingHelper.
7. Applications: UdpEchoServer and UdpEchoClient applications are set up to test the routing.

Running the Code

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

./waf configure –enable-examples

./waf build

./waf –run scratch/bellman-ford-routing

Overall, we had implemented the bellman ford routing in the ns3 and we analyse performance and executed. Bellman-Ford routing algorithm with best programming results for your project.