How to Start BGP Routing Projects Using OMNeT++

To start a Border Gateway Protocol (BGP) routing project using OMNeT++, we should want to replicate a network, which includes several .Systems (ASes) in which each AS utilises BGP swapping routing data. OMNeT++ environment doesn’t have built-in support for BGP thus we will need to execute the BGP protocol from scratch or prolong the existing network protocols within OMNeT++ through INET framework or custom code.

Below is a sequential approach how to begin a BGP Routing project using OMNeT++:

Steps to Start BGP Routing Projects in OMNeT++

Step 1: Install OMNeT++ and INET Framework

  1. Download OMNeT++:
    • We should download and install the OMNeT++ environment on the system.
  2. Install INET Framework:
    • INET framework is a popular simulation framework within OMNeT++ for network protocols, it offers significant models for TCP/IP, routing, and numerous other network protocols.
    • We can be installed INET using GitHub or OMNeT++’s module manager.
  3. Verify Installation:
    • When OMNeT++ and INET are installed then make a basic simulation project confirming that everything is properly functioning.

Step 2: Create a New OMNeT++ Project for BGP Routing

  1. Create a New OMNeT++ Project:
    • Go to OMNeT++ IDE, select File > New > OMNeT++ Project, and make a basic project like BGPRouting.
  2. Create Network Topology:
    • Make a network topology in which several Autonomous Systems (ASes) are linked. These ASes interaction to utilise BGP to exchange routing data in BGP.
    • A normal BGP configuration has routers in each AS, to utilise BGP updates that exchange routing data.

Example of network topology including several ASes:

network BGPRoutingNetwork {

submodules:

AS1_router1: Router;

AS1_router2: Router;

AS2_router1: Router;

AS2_router2: Router;

AS1_host1: Host;

AS2_host1: Host;

connections:

AS1_host1.ethg++ <–> EthernetInterface <–> AS1_router1.ethg++;

AS1_router1.ethg++ <–> EthernetInterface <–> AS1_router2.ethg++;

AS1_router2.ethg++ <–> EthernetInterface <–> AS2_router1.ethg++;

AS2_router1.ethg++ <–> EthernetInterface <–> AS2_router2.ethg++;

AS2_router2.ethg++ <–> EthernetInterface <–> AS2_host1.ethg++;

}

In this example:

  • AS1 and AS2 are two separate Autonomous Systems, each system containing two routers and one host.
  • Routers swap BGP updates to modernize the routes among these two ASes.

Step 3: Implement BGP Protocol (or Extend INET)

OMNeT++ environment and INET framework doesn’t offer an advanced BGP protocol (although they support routing protocols like OSPF and RIP). We can be executed the BGP to utilise the following options:

  1. Use INET Framework:
    • The INET offers routing protocols like RIP and OSPF that we can learn to know how a routing protocol is designed. Then, we can prolong this knowledge for executing BGP by means of changing these protocols or making a custom module, which replicates BGP.
    • Also, we can make a custom BGP module, which manages the BGP-specific operations like exchanging BGP UPDATE messages, sustaining BGP routing tables, and managing BGP attributes.
  2. Custom BGP Module:
    • If we need to execute the BGP from scratch then will want to make a new module, which mimics BGP operations within OMNeT++. We can begin with a custom class, which manages the BGP messages like BGP OPEN, UPDATE, NOTIFICATION, and KEEPALIVE messages, creates the BGP table, and swaps routing data.

Below is a simple framework to make a custom BGP routing module within OMNeT++.

Example BGP Router Module

class BGPRouter : public cSimpleModule {

private:

std::map<int, std::vector<int>> bgpRoutingTable;  // Store BGP routes (destination -> next hop)

protected:

virtual void initialize() override {

// Initialize the BGP table and other variables

}

virtual void handleMessage(cMessage *msg) override {

// Handle incoming BGP messages (OPEN, UPDATE, KEEPALIVE, NOTIFICATION)

if (msg->isSelfMessage()) {

// Periodic tasks, like sending BGP updates or keeping BGP sessions alive

} else {

// Handle BGP messages from other routers

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

processBGPMessages(packet);

}

}

void processBGPMessages(cPacket *msg) {

// Parse and handle BGP messages: UPDATE, OPEN, KEEPALIVE

// BGP table updates, sending advertisements, etc.

}

void sendBGPUpdate() {

// Construct and send a BGP UPDATE message to neighbors

}

void buildBGPTable() {

// Build or update the BGP routing table based on received BGP updates

}

};

In this code:

  • The router (BGPRouter) executes the incoming BGP messages such as OPEN, UPDATE from other routers.
  • We want to execute the functions such as sendBGPUpdate() transmitting BGP modernizing and buildBGPTable() to sustain the BGP routing table.

BGP Update Messages

Also, we describe the BGP messages. Below is an instance of a custom BGP Update message class:

class BGPUpdate : public cPacket {

public:

std::vector<int> prefixList;  // List of IP prefixes announced by the BGP speaker

std::vector<int> pathAttributes;  // BGP attributes (AS Path, Next Hop, etc.)

BGPUpdate(const char *name = nullptr) : cPacket(name) {}

virtual void parsimPack(cCommBuffer *buffer) override {

cPacket::parsimPack(buffer);

doPacking(buffer, prefixList);

doPacking(buffer, pathAttributes);

}

virtual void parsimUnpack(cCommBuffer *buffer) override {

cPacket::parsimUnpack(buffer);

doUnpacking(buffer, prefixList);

doUnpacking(buffer, pathAttributes);

}

};

This custom message class manages the BGP Update messages that transmit IP prefixes and BGP attributes like AS Path and Next Hop.

Step 4: Configure the Simulation in omnetpp.ini

Set the simulation metrics with the BGP protocol, network settings, and any other related settings in the omnetpp.ini file.

Example configuration for the BGP project:

network = BGPRoutingNetwork

sim-time-limit = 100s

[Config BGP]

*.AS1_router1.routingProtocol = “BGP”

*.AS1_router2.routingProtocol = “BGP”

*.AS2_router1.routingProtocol = “BGP”

*.AS2_router2.routingProtocol = “BGP”

# BGP-related settings, like BGP keep-alive time, hold time, etc.

*.AS1_router1.BGPKeepAliveTime = 60s

*.AS2_router1.BGPKeepAliveTime = 60s

# Define the application traffic between hosts (e.g., ping or UDP traffic)

*.AS1_host1.app[0].typename = “PingApp”

*.AS1_host1.app[0].destAddr = “AS2_host1”

*.AS1_host1.app[0].startTime = 1s

This example configures the BGP protocol for every router within AS1 and AS2 and defines the traffic generation like pings among the hosts.

Step 5: Run and Observe the Simulation

  1. Compile and Run:
    • After programming the BGP module then setting up the simulation and execute the project within OMNeT++.
  2. Visualize with Tkenv:
    • Envision the simulation to utilise Tkenv. We can monitor the BGP routes to be exchanged among the ASes and observe how traffic is sent depends on the BGP routing table.
  3. Debugging:
    • Integrate the logging to utilise EV macros monitoring BGP table updates, message exchanges, and route advertisements.

Example:

EV << “Received BGP Update message from Router ” << neighborID << endl;

EV << “Updated BGP routing table: ” << routingTable << endl;

  1. Performance Metrics:
    • We need to estimate the BGP protocol execution performance with routing convergence time, control message overhead (BGP updates), and path selection.

Step 6: Extend and Optimize

  1. Simulate Failures:
    • Launch the simulation failures like router or link failure and then monitor how BGP meets to new routes.
  2. BGP Path Selection:
    • We need to execute the further BGP path selection algorithms with AS path, Next Hop, Local Preference, and MED (Multi-Exit Discriminator).
  3. Policy-Based Routing:
    • Execute the BGP policies like filtering routes, using preferences rely on specific attributes.
  4. Scalability Testing:
    • Experiment the BGP protocol including several ASes and routers, estimating scalability in large-scale networks.

Conclusion

To make a BGP Routing project using OMNeT++ which involves defining a network with numerous Autonomous Systems in which BGP routers exchange routing data. We can be executed BGP by means of making custom modules to manage the BGP messages and routing tables. From the INET framework by creating own BGP protocol or prolonging existing routing protocols we can be replicate the behaviour of BGP and experiment diverse scenarios like route convergence, failures, and policy-based routing. Let me know, if you need any more assistance, feel free to reach out.

Contact us, and we will provide you with the best guidance. To kick off your BGP Routing Projects with OMNeT++, we at phdprojects.org guarantee exceptional support and customized topics in your areas of interest.