How to Start Classful Protocol Projects Using OMNeT++

To start a Classful Routing Protocol using OMNeT++, we adhere to numerous steps. While classful routing protocols such as RIP (Routing Information Protocol) and RIPv1 doesn’t transport subnet mask data within its routing updates depend on the class-based network architecture like Class A, B, C. These protocols are frequently utilised in network designs however have substituted through classless routing protocols such as RIPng and OSPF.

Here, we will guide you how to set up a Classful Routing Protocol project using OMNeT++ focusing on RIP (which is classful). The method is same to other classful protocols like RIPv1 based on exact protocol to replicate.

Steps to Start Classful Protocol Projects in OMNeT++

  1. Install OMNeT++ and INET Framework

Initially, we know the classful routing protocols execution to install OMNeT++ and the INET Framework.

Install OMNeT++:

  1. Download and install OMNeT++ on the system.
  2. Depend on the OS (Linux, Windows, or macOS), we adhere to installation guidance.
  3. Configure the environment according to the instructions with setting the build system.

Install INET Framework:

The INET Framework offers diverse networking protocols with routing protocols. Since it doesn’t contain unconventional classful routing protocols, it can prolong to support them.

  1. Clone the INET repository:

git clone https://github.com/inet-framework/inet.git

cd inet

  1. Build INET:

./configure

make

  1. Familiarize Yourself with OMNeT++ Basics

OMNeT++ is a modular framework, which permits making custom network patterns. Crucial concepts like:

  • Modules: These denotes modules within the network like hosts, routers.
  • NED Files: Delineate the network topology and module communications.
  • INI Files: Save the configuration settings like simulation time, node settings, and protocol sets up for the simulation.
  • Message Types: Describe the kinds of messages are swapped among the nodes.

We should familiarize ourselves with these concepts before beginning the simulation project.

  1. Check for Existing Classful Routing Protocol Implementations

OMNeT++ might not include built-in classful protocols such as RIP v1 in its INET framework, as it is designed for modern, classless routing protocols like RIPng and OSPF. Below are two approaches to work with RIP v1:

Option 1: Use Existing RIP Implementation

  1. Check INET for RIP v1: INET offers support for RIPng (RIP for IPv6). However, RIPv1 (the classful version) might not be directly available. We could adapt the existing RIPng implementation replicating the classful routing or look for third-party execution.
  2. Search for Third-Party Implementations: Explore platforms like GitHub or OMNeT++ forums, which may have offer classful routing protocols with RIPv1.

Option 2: Implement RIP v1 (Classful Routing Protocol)

If no existing solution is found, we might want to create the own implementation of RIP v1. Here’s a basic outline of what to focus on:

  • Routing Table Management: Create a routing table for each node. This table should store information such as destinations, next hops, and metrics (e.g., the distance to attain each destination).
  • Periodic Updates: RIP v1 regularly shares their whole routing table with neighbouring nodes to update them about the available routes.
  • Routing Updates: RIP v1 employs Distance Vector updates, where each node shares its routing table with their neighbouring nodes.
  • Classful Addressing: RIPv1 does not utilise the subnet masks. It considers default subnetting according to the IP classes:
    • Class A: 0.0.0.0/8
    • Class B: 128.0.0.0/16
    • Class C: 192.0.0.0/24
  1. Create the Network Topology

After implementing the protocol (RIP or any other classful routing protocol), the next step is to design the network topology. This is done using NED files, which describe the structure of network and how the nodes are associated.

Example NED File for Classful Routing (RIP):

network ClassfulRIPNetwork {

submodules:

router1: RIPRouter {

@display(“p=100,100”);

}

router2: RIPRouter {

@display(“p=300,100”);

}

router3: RIPRouter {

@display(“p=500,100”);

}

connections:

router1.eth++ <–> router2.eth++;

router2.eth++ <–> router3.eth++;

}

This simple network delineates 3 routers such as router1, router2, router3 that are linked with Ethernet links. We need to prolong the topology by way of inserting additional routers, nodes, and connections making a more complex network.

  1. Configure the Simulation in the INI File

Set the simulation metrics with the routing protocol settings, mobility models (if applicable), and other network-related parameters utilised by INI file.

Example INI File Configuration for RIP:

network = ClassfulRIPNetwork

sim-time-limit = 100s

# Routing Protocol Configuration

*.router1.routingProtocol = “RIP”

*.router2.routingProtocol = “RIP”

*.router3.routingProtocol = “RIP”

# RIP-specific Parameters (optional)

*.router1.rip.updateInterval = 30s

*.router2.rip.updateInterval = 30s

*.router3.rip.updateInterval = 30s

# Record Statistics

*.vector-recording = true

*.scalar-recording = true

# Mobility configuration (if mobile network)

*.router1.mobility = “RandomWaypointMobility”

*.router2.mobility = “RandomWaypointMobility”

*.router3.mobility = “RandomWaypointMobility”

This configuration:

  • It allocates the RIP routing protocol to each router.
  • Configures the update interval for RIP messages (RIP transmits updates for each 30 seconds).
  • For performance analysis, it supports scalar and vector recording.
  • Optionally sets the mobility models if utilising mobile nodes.
  1. Build and Run the Simulation
  1. Compile the Simulation:
    • Make the project using Build Project in OMNeT++ IDE.
    • If utilising the below command, we can execute it:

make

  1. Run the Simulation:
    • We can be executed the simulation in OMNeT++ IDE or with the support of command line:

./run -u Cmdenv

    • Also, we can utilise the Tkenv that permits to monitor visually simulation events for a graphical interface.
  1. Monitor and Analyze the Results

OMNeT++ makes scalar and vector output that can leverage to observe and then examine the simulation’s outcomes.

  • Scalar recording: It contains aggregate parameters such as packet delivery ratio, routing overhead, and so on.
  • Vector recording: It offers in-depth event information like packet arrival times and routing table updates.

Envision this data or transfer the outcomes to external tools such as Python, Excel, or R using OMNeT++’s built-in plotting tools for advanced analysis.

  1. Extend and Experiment

When configuring the simple simulation, we can:

  • Experiment with different network sizes: Monitor how RIP scales in large networks as maximizes the volume of routers and nodes.
  • Simulate link failures or network partitioning: Confirm how RIP manages the network changes and convergence.
  • Equate classful RIP including classless protocols like RIPng or OSPF, measuring the performance in diverse network conditions.

Summary

To begin a Classful Routing Protocol project like RIP v1 using OMNeT++:

  1. Begin by setting up the OMNeT++ simulation environment along with INET Framework.
  2. Verify if RIP v1 is already implemented within the framework. If not, create the own implementation.
  3. Design a network topology to utilise NED files to design the network layout and specify the connections between nodes.
  4. Configure the simulation to use an INI file to describe the protocol’s parameters and network configuration settings.
  5. Execute the simulation and examine the output to utilise the scalar and vector data for analysis.
  6. Modify and test the simulation with various topologies, mobility models, and network configurations to explore diverse scenarios.

We successfully adhere to the simulation approach to effectively replicate and examine the Classful Routing Protocol using OMNeT++. More specifies will be shared on this topic in another guide.

Our developers provide you topics and project ideas for Classful Protocol Projects using OMNeT++. We can modify or implement protocols related to your projects. We also work with classful routing protocols like RIP (Routing Information Protocol) and RIPv1. Stay connected with phdprojects.org. We guarantee timely results with clear explanations. Top of Form