e-mail address: omnetmanual@gmail.com

Phone number: +91 9444856435
DEFENDER

How to Implement Spanning Tree Protocol in OMNeT++

To Implement the Spanning Tree Protocol (STP) in OMNeT++ has needs to make a network protocol and make sure there are no loops in a network with terminated paths. STP mechanism is choosing a root bridge, then estimate the shortest path to the root bridge for each switch and restricting any redundant paths that departure only the active paths that form a loop-free tree structure. Our developers can provide you with information on the implementation of the Spanning Tree Protocol in the OMNeT++ tool, including project topics and execution steps. Please share your project details with us, and we will be happy to assist you further.

The below is the implementation procedure to execute the STP 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 such as STPSimulation and set up the project directory.
  2. Set Up Project Dependencies:
    • Make sure the project references the INET Framework by right-clicking on project in the Project Explorer, navigating to Properties > Project References, and validating the INET project.

Step 3: Define the Network Topology

  1. Create a NED File:
    • Describe the network topology using the NED language. This topology will contain switches that will use the Spanning Tree Protocol to prevent loops.

Example:

network STPNetwork

{

parameters:

int numSwitches = default(4); // Number of switches in the network

submodules:

switch[numSwitches]: EtherSwitch {

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

}

host[numSwitches]: StandardHost {

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

}

connections allowunconnected:

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

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

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

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

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

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

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

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

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

}

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

Step 4: Implement the Spanning Tree Protocol (STP)

The Spanning Tree Protocol works by exchanging Bridge Protocol Data Units (BPDUs) among switches to designate a root bridge, regulate the shortest paths, and restrict redundant links.

  1. Create the STP Module in NED

Example (in NED):

simple STP

{

parameters:

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

gates:

inout lowerLayerIn[];

inout lowerLayerOut[];

}

  1. Implement STP in C++

Here’s a basic structure for implementing STP 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/stp/STPMessage_m.h”

class STP : public cSimpleModule

{

private:

IRoutingTable *inetRoutingTable;

InterfaceTable *interfaceTable;

int bridgeId;

int rootId;

int rootPort;

int rootCost;

std::map<int, int> portRoles;  // Roles: Root Port, Designated Port, or Blocked

cMessage *stpTimer;

protected:

virtual void initialize() override;

virtual void handleMessage(cMessage *msg) override;

void sendBPDU();

void processBPDU(Packet *packet);

void updatePortRoles();

};

Define_Module(STP);

void STP::initialize() {

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

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

bridgeId = getId(); // Use module ID as bridge ID

rootId = bridgeId;  // Initially, assume this bridge is the root

rootPort = -1;

rootCost = 0;

// Schedule periodic BPDU broadcasts

stpTimer = new cMessage(“STP_Timer”);

scheduleAt(simTime() + 1, stpTimer);

}

void STP::handleMessage(cMessage *msg) {

if (msg == stpTimer) {

sendBPDU();

scheduleAt(simTime() + 1, stpTimer);  // Reschedule BPDU broadcast

} else {

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

processBPDU(packet);

}

}

void STP::sendBPDU() {

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

STPMessage *bpdu = new STPMessage(“BPDU”);

bpdu->setRootId(rootId);

bpdu->setRootCost(rootCost);

bpdu->setBridgeId(bridgeId);

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

packet->insertAtBack(bpdu);

send(packet, “lowerLayerOut”, i);

}

}

void STP::processBPDU(Packet *packet) {

const auto& bpdu = packet->peekData<STPMessage>();

int receivedRootId = bpdu->getRootId();

int receivedCost = bpdu->getRootCost() + 1;  // Increment cost by 1 for the hop

int senderBridgeId = bpdu->getBridgeId();

int receivingPort = packet->getArrivalGate()->getIndex();

// Update root bridge if a better one is found

if (receivedRootId < rootId || (receivedRootId == rootId && receivedCost < rootCost)) {

rootId = receivedRootId;

rootCost = receivedCost;

rootPort = receivingPort;

updatePortRoles();

}

delete packet;

}

void STP::updatePortRoles() {

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

if (i == rootPort) {

portRoles[i] = 0;  // Root port

} else if (/* condition to check if this port is the designated port */) {

portRoles[i] = 1;  // Designated port

} else {

portRoles[i] = 2;  // Blocked port

}

}

}

Step 5: Configure the Simulation

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

Example:

network = STPNetwork

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 sure everything is properly implemented and compiled. Run the simulation using OMNeT++’s IDE or command line.

Step 6: Analyse the Results

  1. Monitor Network Behaviour:
    • Perceive how the switches exchange BPDUs and how the network topology stabilizes into a loop-free spanning tree.
  2. Evaluate Performance:
    • Analyse 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 BPDUs exchanged, the number of ports blocked, and the time taken to establish the spanning tree.

Step 7: Optimize and Extend the Protocol

  1. Address Any Issues:
    • If the simulation reveals any challenges like incorrect port blocking, packet loss, adjust the STP logic or network configuration as needed.
  2. Extend the Protocol:
    • To execute additional features such as Rapid Spanning Tree Protocol (RSTP) to optimize the speed of convergence.

In the end, we had explored the basic implementation process on how to execute the Spanning Tree Protocol that handles to estimate the shortest path in the network. If you need additional information regarding the Spanning Tree Protocol we will provide it too.

Related Topics