How to Start VLAN Trunking Protocol Projects Using OMNeT++

To start VLAN Trunking Protocol (VTP) using OMNeT++ environment which is a Layer 2 protocol frequently utilised in Ethernet networks for handling VLAN sets up through several switches. It makes sure that consistency in a network within VLAN data by broadcasting modifications from a central switch to others within the similar domain.

Below is a stepwise method to make and replicate a VTP-based project using OMNeT++:

Steps to Start VLAN Trunking Protocol (VTP) Project in OMNeT++

1. Understand VTP

Key Features

• VTP Modes:
  • Server: It makes, alters, and erases VLANs and broadcasts this data.
  • Client: Obtains the VLAN updates from a VTP server and it cannot change the VLANs.
  • Transparent: It supports to send VTP messages however do not utilise updates to their VLAN database.
• Domain:
  • VTP functions in a VLAN domain that is detected by a single name.
• Synchronization:
  • Makes sure that every switch contains consistent VLAN databases.

Applications

• It makes simpler VLAN management within average to large Layer 2 networks.
• Minimizes sets up errors by automating VLAN distribution.

2. Set Up the Environment

Install OMNeT++

1. We should download and install the new version of OMNeT++ on the system.
2. Configure the installation with example simulations is properly configured.

Install INET Framework

• INET framework offers Ethernet and VLAN models which is necessary to replicate the VTP.

1. We can download and construct the INET framework:

make makefiles

make

3. Plan Your Simulation

Define Objectives

• Replicate a network of interconnected switches to utilise VTP.
• Exhibit VLAN propagation and synchronization.
• Measure the performance of VTP within scenarios such as:
  • Faulty or disconnected links.
  • VLAN addition/removal.

Topology

• Make use of a simple topology including some switches that are linked within a star or ring set up.
• Assign one switch like VTP server and others as clients or transparent.

4. Create a New OMNeT++ Project

1. Go to the OMNeT++ IDE.
2. Select File > New > OMNeT++ Project.
3. Name it to the project as VTPRouting and choose Finish.

5. Implement VTP Logic

Extend INET’s VLAN Models

While INET framework offers simple VLAN support, it doesn’t have VTP support. We will prolong it by executing the VTP protocol.

Create a VTP Module

Make a .cc file as VTPRouting.cc for the VTP logic.

Example: VTP Logic

#include <omnetpp.h>

#include <map>

#include <string>

using namespace omnetpp;

class VTPRouting : public cSimpleModule {

private:

std::string mode; // “server”, “client”, or “transparent”

std::string domain; // VTP domain name

int revisionNumber; // Revision number for VLAN updates

std::map<int, std::string> vlanDatabase; // VLAN ID to name mapping

protected:

virtual void initialize() override {

mode = par(“mode”).stringValue();

domain = par(“domain”).stringValue();

revisionNumber = 0;

if (mode == “server”) {

createVLAN(10, “Sales”);

createVLAN(20, “Engineering”);

}

// Start periodic VTP advertisements

if (mode == “server”) {

scheduleAt(simTime() + par(“advertisementInterval”).doubleValue(), new cMessage(“VTPAdvertisement”));

}

}

virtual void handleMessage(cMessage *msg) override {

if (strcmp(msg->getName(), “VTPAdvertisement”) == 0) {

sendVTPAdvertisement();

scheduleAt(simTime() + par(“advertisementInterval”).doubleValue(), msg); // Reschedule

} else {

handleVTPMessage(check_and_cast<cMessage *>(msg));

}

}

void createVLAN(int vlanId, const std::string &vlanName) {

if (mode == “server”) {

vlanDatabase[vlanId] = vlanName;

revisionNumber++;

EV << “VLAN ” << vlanId << ” (” << vlanName << “) added. Revision: ” << revisionNumber << “\n”;

}

}

void sendVTPAdvertisement() {

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

cMessage *advertisement = new cMessage(“VTPMessage”);

advertisement->addPar(“domain”) = domain;

advertisement->addPar(“revisionNumber”) = revisionNumber;

for (const auto &[vlanId, vlanName] : vlanDatabase) {

advertisement->addPar(std::to_string(vlanId).c_str()) = vlanName.c_str();

}

send(advertisement, “out”, i);

}

}

void handleVTPMessage(cMessage *msg) {

std::string receivedDomain = msg->par(“domain”).stringValue();

int receivedRevision = msg->par(“revisionNumber”).intValue();

if (domain != receivedDomain) {

EV << “VTP domain mismatch. Ignoring message.\n”;

delete msg;

return;

}

if (mode == “client” && receivedRevision > revisionNumber) {

EV << “Updating VLAN database with revision ” << receivedRevision << “\n”;

vlanDatabase.clear();

for (cPropertyIterator it(msg->getParList()); !it.end(); it.next()) {

int vlanId = atoi(it.getName());

std::string vlanName = msg->par(it.getValue()).stringValue();

vlanDatabase[vlanId] = vlanName;

}

revisionNumber = receivedRevision;

}

delete msg;

}

};

Define_Module(VTPRouting);

6. Define Network Topology

Create a .ned File

Make a network topology including several switches and VLANs.

Example:

network VTPNetwork {

submodules:

switch[3]: StandardHost {

parameters:

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

mode = index == 0 ? “server” : “client”; // Switch 0 is the server

domain = “VLAN_DOMAIN”;

advertisementInterval = 30s;

}

pc[6]: StandardHost {

@display(“i=device/pc”);

}

connections allowunconnected:

// Connect switches

switch[0].pppg++ <–> switch[1].pppg++;

switch[1].pppg++ <–> switch[2].pppg++;

switch[2].pppg++ <–> switch[0].pppg++;

// Connect PCs to switches

pc[0].pppg++ <–> switch[0].pppg++;

pc[1].pppg++ <–> switch[0].pppg++;

pc[2].pppg++ <–> switch[1].pppg++;

pc[3].pppg++ <–> switch[1].pppg++;

pc[4].pppg++ <–> switch[2].pppg++;

pc[5].pppg++ <–> switch[2].pppg++;

}

7. Configure Simulation Parameters

Edit omnetpp.ini

Set the simulation parameters using .ini files.

Example:

[Config VTPSimulation]

network = VTPNetwork

**.switch[*].numApps = 1

**.switch[*].app[0].typename = “UdpApp”

**.switch[*].advertisementInterval = 30s

simulation.timeLimit = 100s

8. Run the Simulation

1. In OMNeT++, execute the simulation to utilise Tkenv or Cmdenv.
2. Monitor:
   • Modernizes to VLAN databases on the client switches.
   • VLAN advertisements from the server.

9. Analyze Results

Metrics to Evaluate

• Synchronization Time:
  • Measure the duration for every switch to modernize its VLAN databases.
• VLAN Consistency:
  • Confirm that every switch contain consistent VLAN sets up.
• Fault Tolerance:
  • Experiment the behavior in the course of server failure or domain mismatch for tolerance.

Visualization

• Make use of OMNeT++ tools for observing:
  • Database updates on client switches.
  • VLAN advertisements.

10. Extend and Optimize

Advanced Scenarios

• Mimic link or switch failures and then monitor the behaviour of VTP.
• Integrate support for VTP pruning to enhance the VLAN traffic.

Comparison

• We need to equate the VTP including manual VLAN set up to exhibit their benefits.

We had demonstrated the how to create and simulate the VLAN Trucking Protocol Projects that is Layer 2 protocol using above provided sequential methodology using OMNeT++ tool We also deliver the more information on this subject in other simulation scenarios.

We offer stepwise method to make and replicate a VTP-based project using OMNeT++ tailored to your work, rely on us to get a hazzle  free work.