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

How to Implement Routing Information Protocol in ns3

To implement the Routing Information Protocol (RIP) in ns3, we need to create the required classes and methods that can supports the behavior of the protocol. RIP is also known as a distance-vector routing protocol that uses a particular routing metric which is hop count.

Here we have provided the steps to implement RIP IN ns3 using hop count as an routing metric.

Step-by-step guide to Implement RIP in ns-3

  1. Set Up Your ns-3 Workspace: Make sure ns3 is installed on the system.
  2. Create a New Module for RIP:
    • Navigate to the src directory of ns3 and create a new directory named rip.
    • Inside the rip directory, create subdirectories: model, helper, and examples.
  3. Define the RIP Protocol:
    • In the model directory, create .cc and .h files for the RIP protocol. Define the RipRoutingProtocol class that inherits from the Ipv4RoutingProtocol class.
  4. Implement RIP Classes:
    • Implement the key components of RIP: periodic updates, triggered updates, and handling RIP messages.
    • Create classes for the RIP control messages: Request and Response.
  5. Integrate RIP with ns-3’s Routing System:
    • Modify the RoutingHelper class to include RIP.
    • Register RIP as a routing protocol in ns-3.
  6. Create a Simulation Script:
    • Set up a network topology.
    • Install the Internet stack.
    • Use the RIP routing helper to enable RIP.
    • Set up applications and run the simulation.

Example Code Structure

Here’s an example code structure for implementing RIP in ns3.

Define RIP Routing Protocol

// src/rip/model/rip-routing-protocol.h

 

#ifndef RIP_ROUTING_PROTOCOL_H

#define RIP_ROUTING_PROTOCOL_H

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

#include “ns3/ipv4.h”

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

#include “ns3/ipv4-route.h”

#include “ns3/node.h”

#include “ns3/net-device.h”

#include “ns3/socket.h”

#include “ns3/timer.h”

#include <vector>

#include <map>

namespace ns3 {

class RipRoutingProtocol : public Ipv4RoutingProtocol

{

public:

static TypeId GetTypeId (void);

RipRoutingProtocol ();

virtual ~RipRoutingProtocol ();

// Inherited from Ipv4RoutingProtocol

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 RecvRip (Ptr<Socket> socket);

private:

void Start ();

void Stop ();

void SendPeriodicUpdate ();

void SendTriggeredUpdate ();

void HandleRipRequest (Ptr<Packet> p, Ipv4Address src, Ipv4Address dst);

void HandleRipResponse (Ptr<Packet> p, Ipv4Address src, Ipv4Address dst);

Ptr<Ipv4> m_ipv4;

std::map<Ptr<Socket>, Ipv4InterfaceAddress> m_socketAddresses;

std::map<Ipv4Address, Ptr<Ipv4Route>> m_routes;

Timer m_periodicUpdateTimer;

Timer m_triggeredUpdateTimer;

};

 

} // namespace ns3

#endif // RIP_ROUTING_PROTOCOL_H

Implement RIP Routing Protocol

// src/rip/model/rip-routing-protocol.cc

#include “rip-routing-protocol.h”

#include “ns3/log.h”

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

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

namespace ns3 {

NS_LOG_COMPONENT_DEFINE (“RipRoutingProtocol”);

NS_OBJECT_ENSURE_REGISTERED (RipRoutingProtocol);

TypeId

RipRoutingProtocol::GetTypeId (void)

{

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

.SetParent<Ipv4RoutingProtocol> ()

.SetGroupName (“Internet”)

.AddConstructor<RipRoutingProtocol> ();

return tid;

}

RipRoutingProtocol::RipRoutingProtocol ()

{

NS_LOG_FUNCTION (this);

}

RipRoutingProtocol::~RipRoutingProtocol ()

{

NS_LOG_FUNCTION (this);

}

void

RipRoutingProtocol::SetIpv4 (Ptr<Ipv4> ipv4)

{

NS_LOG_FUNCTION (this << ipv4);

m_ipv4 = ipv4;

// Schedule the first periodic update

m_periodicUpdateTimer.SetFunction (&RipRoutingProtocol::SendPeriodicUpdate, this);

m_periodicUpdateTimer.Schedule (Seconds (30.0));

}

void

RipRoutingProtocol::NotifyInterfaceUp (uint32_t interface)

{

NS_LOG_FUNCTION (this << interface);

}

void

RipRoutingProtocol::NotifyInterfaceDown (uint32_t interface)

{

NS_LOG_FUNCTION (this << interface);

}

void

RipRoutingProtocol::NotifyAddAddress (uint32_t interface, Ipv4InterfaceAddress address)

{

NS_LOG_FUNCTION (this << interface << address);

}

void

RipRoutingProtocol::NotifyRemoveAddress (uint32_t interface, Ipv4InterfaceAddress address)

{

NS_LOG_FUNCTION (this << interface << address);

}

void

RipRoutingProtocol::Start ()

{

NS_LOG_FUNCTION (this);

}

void

RipRoutingProtocol::Stop ()

{

NS_LOG_FUNCTION (this);

}

 

void

RipRoutingProtocol::SendPeriodicUpdate ()

{

NS_LOG_FUNCTION (this);

// Implement the logic to send a periodic RIP update

m_periodicUpdateTimer.Schedule (Seconds (30.0));

}

void

RipRoutingProtocol::SendTriggeredUpdate ()

{

NS_LOG_FUNCTION (this);

// Implement the logic to send a triggered RIP update

}

void

RipRoutingProtocol::HandleRipRequest (Ptr<Packet> p, Ipv4Address src, Ipv4Address dst)

{

NS_LOG_FUNCTION (this << p << src << dst);

// Implement the logic to handle a RIP Request

}

void

RipRoutingProtocol::HandleRipResponse (Ptr<Packet> p, Ipv4Address src, Ipv4Address dst)

{

NS_LOG_FUNCTION (this << p << src << dst);

// Implement the logic to handle a RIP Response

}

Ptr<Ipv4Route>

RipRoutingProtocol::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 ();

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

if (m_routes.find (dest) != m_routes.end ())

{

route->SetDestination (dest);

route->SetOutputDevice (oif);

route->SetGateway (m_routes[dest]->GetGateway ());

return route;

}

else

{

sockerr = Socket::ERROR_NOROUTETOHOST;

return nullptr;

}

}

 

bool

RipRoutingProtocol::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 (m_routes.find (dest) != m_routes.end ())

{

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

route->SetDestination (dest);

route->SetOutputDevice (m_ipv4->GetNetDevice (0)); // Example output device

route->SetGateway (m_routes[dest]->GetGateway ());

ucb (route, p, header);

return true;

}

else

{

return false;

}

}

 

void

RipRoutingProtocol::RecvRip (Ptr<Socket> socket)

{

NS_LOG_FUNCTION (this << socket);

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

Ipv4Header ipv4Header;

packet->RemoveHeader (ipv4Header);

Ipv4Address src = ipv4Header.GetSource ();

Ipv4Address dst = ipv4Header.GetDestination ();

// Check if the packet is a RIP Request or Response

uint8_t messageType;

packet->PeekHeader (messageType);

if (messageType == 1) // RIP Request

{

HandleRipRequest (packet, src, dst);

}

else if (messageType == 2) // RIP Response

{

HandleRipResponse (packet, src, dst);

}

}

 

} // namespace ns3

Helper Class

// src/rip/helper/rip-helper.h

#ifndef RIP_HELPER_H

#define RIP_HELPER_H

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

#include “ns3/object-factory.h”

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

namespace ns3 {

class RipHelper : public Ipv4RoutingHelper

{

public:

RipHelper ();

RipHelper (const RipHelper &);

RipHelper &operator= (const RipHelper &);

virtual ~RipHelper ();

virtual RipHelper* Copy (void) const;

virtual Ptr<Ipv4RoutingProtocol> Create (Ptr<Node> node) const;

};

} // namespace ns3

#endif // RIP_HELPER_H

Implement Helper Class

// src/rip/helper/rip-helper.cc

#include “rip-helper.h”

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

#include “ns3/node.h”

namespace ns3 {

RipHelper::RipHelper ()

{

}

RipHelper::RipHelper (const RipHelper &o)

{

}

RipHelper&

RipHelper::operator= (const RipHelper &o)

{

return *this;

}

RipHelper::~RipHelper ()

{

}

RipHelper*

RipHelper::Copy (void) const

{

return new RipHelper (*this);

}

Ptr<Ipv4RoutingProtocol>

RipHelper::Create (Ptr<Node> node) const

{

Ptr<RipRoutingProtocol> protocol = CreateObject<RipRoutingProtocol> ();

node->AggregateObject (protocol);

return protocol;

}

} // namespace ns3

Example Simulation Script

// examples/rip-simulation.cc

#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/rip-helper.h”

using namespace ns3;

NS_LOG_COMPONENT_DEFINE (“RipSimulation”);

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

{

CommandLine cmd;

cmd.Parse (argc, argv);

 

// Create nodes

NodeContainer nodes;

nodes.Create (4);

// Create point-to-point links

PointToPointHelper p2p;

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

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

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

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

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

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

// Install the Internet stack

InternetStackHelper stack;

RipHelper rip;

stack.SetRoutingHelper (rip);

stack.Install (nodes);

// Assign IP addresses

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

// Create a packet sink to receive packets

uint16_t sinkPort = 8080;

Address sinkAddress (InetSocketAddress (Ipv4Address (“10.1.4.1”), sinkPort));

PacketSinkHelper packetSinkHelper (“ns3::TcpSocketFactory”, sinkAddress);

ApplicationContainer sinkApps = packetSinkHelper.Install (nodes.Get (3));

sinkApps.Start (Seconds (1.0));

sinkApps.Stop (Seconds (10.0));

// Create a TCP client to send packets

OnOffHelper clientHelper (“ns3::TcpSocketFactory”, sinkAddress);

clientHelper.SetAttribute(“OnTime”,StringValue (“ns3::ConstantRandomVariable[Constant=1]”));

clientHelper.SetAttribute(“OffTime”,StringValue (“ns3::ConstantRandomVariable[Constant=0]”));

clientHelper.SetAttribute (“DataRate”, DataRateValue (DataRate (“1Mbps”)));

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

ApplicationContainer clientApps = clientHelper.Install (nodes.Get (0));

clientApps.Start (Seconds (2.0));

clientApps.Stop (Seconds (10.0));

 

// Enable tracing

AsciiTraceHelper ascii;

p2p.EnableAsciiAll (ascii.CreateFileStream (“rip-routing.tr”));

p2p.EnablePcapAll (“rip-routing”);

// Run the simulation

Simulator::Run ();

Simulator::Destroy ();

return 0;

}

Running the Simulation

To run the simulation, compile the script and execute it:

./waf configure –enable-examples

./waf build

./waf –run rip-simulation

At last, we had learnt to implement the Routing Information protocol in ns3 by creating the necessary classes and methods for supporting the protocols behaviour like message request and response.

Get Routing Information Protocol (RIP) project done by our developers based as per your concept.