e-mail address: omnetmanual@gmail.com

Phone number: +91 9444856435
DEFENDER

 How to Implement Routing Information Protocol in OMNeT++

To Implement the Routing Information Protocol (RIP) in OMNeT++ has includes to generate a distance-vector routing protocol where each router occasionally sends updates to its neighbours about the cost (in hops) to reach each end point in the network. The RIP is a comparatively simple routing protocol, but executing it from scratch needs to familiarize of how routing tables are maintained and updated.

The below are the procedures to implement the RIP in OMNeT++ using the INET framework:

Step-by-Step Implementation:

Step 1: Set Up OMNeT++ and INET Framework

  1. Install OMNeT++:
    • Make sure OMNeT++ is installed on system. We need to download it from the OMNeT++
  2. Install the INET Framework:
    • Download and install the INET Framework, which offers numerous networking protocols and models. INET can be downloaded from the INET GitHub repository.

Step 2: Create a New OMNeT++ Project

  1. Create the Project:
    • Open OMNeT++ and generate a new OMNeT++ project through File > New > OMNeT++ Project.
    • Name project like RIPRoutingSimulation and set up the project directory.
  2. Set Up Project Dependencies:
    • Make sure project references the INET Framework by right-clicking on project in the Project Explorer, navigating to Properties > Project References, and checking the INET project.

Step 3: Define the Network Topology

  1. Create a NED File:
    • Describe network topology using the NED language. This topology will concludes routers configured to use the RIP routing protocol.

Example:

network RIPNetwork

{

parameters:

int numRouters = default(4); // Number of routers in the network

submodules:

router[numRouters]: Router {

@display(“i=block/router”);

}

host[numRouters]: StandardHost {

@display(“i=block/host”);

}

connections allowunconnected:

router[0].ethg++ <–> Eth10Mbps <–> router[1].ethg++;

router[1].ethg++ <–> Eth10Mbps <–> router[2].ethg++;

router[2].ethg++ <–> Eth10Mbps <–> router[3].ethg++;

router[0].ethg++ <–> Eth10Mbps <–> router[2].ethg++;

router[3].ethg++ <–> Eth10Mbps <–> router[1].ethg++;

host[0].ethg++ <–> Eth10Mbps <–> router[0].ethg++;

host[1].ethg++ <–> Eth10Mbps <–> router[1].ethg++;

host[2].ethg++ <–> Eth10Mbps <–> router[2].ethg++;

host[3].ethg++ <–> Eth10Mbps <–> router[3].ethg++;

}

  1. Configure Network Parameters:
    • Set up necessary link performance metrics like bandwidth, delay, and packet loss to mimic a realistic network environment.

Step 4: Implement the RIP Routing Protocol

RIP operates by occasionally distribution routing updates to all neighbouring routers, and it uses a hop count as the parameters. Each router preserves a routing table that lists the best-known distance to each destination.

  1. Create the RIP Module in NED

Example (in NED):

simple RIP

{

parameters:

@display(“i=block/network2”);

gates:

inout lowerLayerIn[];

inout lowerLayerOut[];

}

  1. Implement RIP in C++

Here’s a basic structure for implementing RIP in C++:

#include “inet/common/INETDefs.h”

#include “inet/networklayer/contract/IRoutingTable.h”

#include “inet/networklayer/ipv4/IPv4RoutingTable.h”

#include “inet/networklayer/ipv4/IPv4Route.h”

#include “inet/networklayer/common/L3Address.h”

#include “inet/common/packet/Packet.h”

#include “inet/networklayer/common/InterfaceTable.h”

#include “inet/networklayer/routing/rip/RIPMessage_m.h”

class RIP : public cSimpleModule

{

private:

IRoutingTable *inetRoutingTable;

InterfaceTable *interfaceTable;

std::map<L3Address, int> routingTable;  // Routing table with hop count as metric

cMessage *updateMsg;

protected:

virtual void initialize() override;

virtual void handleMessage(cMessage *msg) override;

void sendRoutingUpdate();

void processRoutingUpdate(Packet *packet);

void updateRoutingTable(const L3Address& destAddr, int hopCount, L3Address nextHop);

};

Define_Module(RIP);

void RIP::initialize() {

inetRoutingTable = getModuleFromPar<IRoutingTable>(par(“routingTableModule”), this);

interfaceTable = getModuleFromPar<InterfaceTable>(par(“interfaceTableModule”), this);

// Initialize routing table with direct connections

for (int i = 0; i < interfaceTable->getNumInterfaces(); i++) {

InterfaceEntry *ie = interfaceTable->getInterface(i);

if (ie->isBroadcast()) {

L3Address address = ie->getNetworkAddress();

routingTable[address] = 1;  // Directly connected networks have a hop count of 1

}

}

// Schedule periodic routing updates

updateMsg = new cMessage(“RIP_Update”);

scheduleAt(simTime() + 1, updateMsg);

}

void RIP::handleMessage(cMessage *msg) {

if (msg == updateMsg) {

sendRoutingUpdate();

scheduleAt(simTime() + 1, updateMsg);  // Reschedule update

} else {

Packet *packet = check_and_cast<Packet *>(msg);

processRoutingUpdate(packet);

}

}

void RIP::sendRoutingUpdate() {

for (auto &entry : routingTable) {

RIPMessage *ripMsg = new RIPMessage(“RIP_Update”);

ripMsg->setDestAddr(entry.first);

ripMsg->setHopCount(entry.second);

Packet *packet = new Packet(“RIP_UpdatePacket”);

packet->insertAtBack(ripMsg);

for (int i = 0; i < gateSize(“lowerLayerOut”); i++) {

send(packet->dup(), “lowerLayerOut”, i);  // Broadcast to all neighbors

}

delete packet;

}

}

void RIP::processRoutingUpdate(Packet *packet) {

const auto& ripMsg = packet->peekData<RIPMessage>();

L3Address destAddr = ripMsg->getDestAddr();

int receivedHopCount = ripMsg->getHopCount();

// Update routing table if a better route is found

if (routingTable.find(destAddr) == routingTable.end() || routingTable[destAddr] > receivedHopCount + 1) {

updateRoutingTable(destAddr, receivedHopCount + 1, packet->getSenderModule()->getFullPath());

}

delete packet;

}

void RIP::updateRoutingTable(const L3Address& destAddr, int hopCount, L3Address nextHop) {

routingTable[destAddr] = hopCount;

// Update the actual inetRoutingTable with the new route

auto *route = inetRoutingTable->findBestMatchingRoute(destAddr);

if (!route) {

route = new IPv4Route();

route->setDestination(destAddr.toIPv4());

route->setNetmask(IPv4Address::ALLONES_ADDRESS);

route->setMetric(hopCount);

route->setSource(IPv4Route::RIP);

route->setGateway(nextHop.toIPv4());

inetRoutingTable->addRoute(route);

} else {

route->setMetric(hopCount);

route->setGateway(nextHop.toIPv4());

}

}

Step 5: Configure the Simulation

  1. Set Up the Simulation in omnetpp.ini:
    • Outline the simulation parameters like the network to use, simulation time, and traffic generation between the hosts.

Example:

network = RIPNetwork

sim-time-limit = 100s

**.scalar-recording = true

**.vector-recording = true

# Traffic generation (e.g., UDP traffic between hosts)

*.host[0].numApps = 1

*.host[0].app[0].typename = “UdpBasicApp”

*.host[0].app[0].destAddress = “host[3]”

*.host[0].app[0].destPort = 5000

*.host[0].app[0].messageLength = 1024B

*.host[0].app[0].sendInterval = uniform(1s, 2s)

  1. Compile and Run the Simulation:
    • Make certain everything is properly executed and compiled. Run the simulation using OMNeT++’s IDE or command line.

Step 6: Analyze the Results

  1. Monitor Network Behavior:
    • monitor how the routing tables are updated over time as RIP broadcasts updates.
  2. Evaluate Performance:
    • Measure the key performance metrics like convergence time, packet delivery ratio, and end-to-end delay.
    • Scalars and Vectors: Use OMNeT++ tools to record and measure scalar and vector data, like the number of routes discovered, the number of packets sent, received, and dropped, as well as the time taken to deliver packets.

Step 7: Optimize and Extend the Protocol

  1. Address Any Issues:
    • If the simulation exposes any concerns about incorrect routing, packet loss, modify the routing logic or network configuration as needed.
  2. Extend the Protocol:
    • Implement additional features such as split horizon or route poisoning to enhance the stability and effectiveness of the RIP protocol.

We demonstrate and show how the Routing Information Protocol will generate the network then applies the Routing Information Protocol in the INET framework that used in OMNeT++ tool.

We have been working on implementing the Routing Information Protocol in the OMNeT++ tool, so feel free to reach out for the best developer support during the simulation process. Our focus is on the distance-vector routing protocol, and we are also well-versed in simple routing protocols related to this project.