SimpleModule¶

simple module SimpleModule

Base module for all INET simple modules.

Inheritance diagram¶

Known subclasses¶

Name	Type	Description
SimpleClockSynchronizer	simple module	Periodically synchronizes the slave clock to the master clock with the specified accuracy. The synchronization happens directly using C++ method calls and without any packet exchange. This is primarily useful when the overhead of the time synchronization protocol messages can be safely ignored.
DhcpClient	simple module	Implements the DHCP client protocol. DHCP (Dynamic Host Configuration Protocol), described in RFC 2131, provides configuration parameters to Internet hosts. Requires UDP.
DhcpServer	simple module	Implements the DHCP server protocol. DHCP (Dynamic Host Configuration Protocol), described in RFC 2131, provides configuration parameters to Internet hosts. Requires UDP.
EtherAppClient	simple module	A simple traffic generator for the Ethernet model and the 802.11 model, and generally for any L2 model that accepts Ieee802SapReq tags on the packets. It generates packets containing EtherAppReq chunks. It should be connected directly to Ieee8022Llc.
EtherAppServer	simple module	Server side of the EtherAppClient model – generates packets containing EtherAppResp chunks with the number of bytes requested by the client in corresponding EtherAppReq. It should be connected directly to Ieee8022Llc module.
EthernetSocketIo	simple module	Provides Ethernet socket handling for generic applications.
EtherTrafGen	simple module	A simple traffic generator for the Ethernet model and the 802.11 model, and generally for any L2 model that accepts Ieee802SapReq tag on packets. It should be connected directly to Ieee8022Llc module.
IpvxTrafGen	simple module	Sends IP or IPv6 datagrams to the given address at the given `sendInterval`. The `sendInterval` can be a constant or a random value (e.g. exponential(1)). If the `destAddresses` parameter contains more than one address, one of them is randomly chosen for each packet. An address may be given in the dotted decimal notation (or, for IPv6, in the usual notation with colons), or with the module name. (The `L3AddressResolver` class is used to resolve the address.) To disable the model, set `destAddresses` to “”.
IpvxTrafSink	simple module	Consumes and prints packets received from the IP module. Compatible with both Ipv4 and Ipv6.
Ieee8022LlcSocketIo	simple module	Provides IEEE 802.2 LLC socket handling for generic applications.
IpSocketIo	simple module	Provides IP socket handling for generic applications.
NetPerfMeter	simple module	Application model for comparing the performance of various transport protocols.
PingApp	simple module	Generates ping requests to several hosts (or rather, network interfaces), and calculates the packet loss and round trip times of the replies. It works exactly like ‘ping’ except that it is possible to specify several destination addresses as a space separated list of IP addresses or module names. (The `L3AddressResolver` class is used to resolve the address.) Specifying ‘*’ allows pinging ALL configured network interfaces in the whole simulation. This is useful to check if a host can reach ALL other hosts in the network (i.e. routing tables were set up properly).
QuicClient	simple module	(no description)
QuicDiscardServer	simple module	A QUIC server that reads and discards all received data.
QuicOrderedReceiver	simple module	A QUIC server that reads and discards all received data.
QuicOrderedTrafficgen	simple module	(no description)
QuicTrafficgen	simple module	(no description)
QuicZeroRttClient	simple module	(no description)
RtpApplication	simple module	An application which uses RTP. It acts as a sender if the parameter `fileName` is set, and as a receiver if the parameter is empty.
SctpClient	simple module	Client app for SCTP-based request-reply protocols. Handles a single session (and SCTP connection) at a time.
SctpNatPeer	simple module	Implements a peer application for SCTP NAT traversal. Supports both standard and rendezvous connection establishment methods to traverse NAT devices. Exchanges NAT traversal information with other peers and handles data transfer with configurable parameters. Supports multi-homing with multiple addresses.
SctpNatServer	simple module	Implements a rendezvous server for SCTP NAT traversal. Facilitates communication between peers behind NAT devices by maintaining connection information and exchanging address details between peers. Handles multi-homed connections and processes address addition notifications. Enables direct peer-to-peer communication by providing each peer with the necessary connection details of the other peer.
SctpPeer	simple module	Implements a versatile SCTP application that can function as both client and server simultaneously. Supports sending and receiving data with configurable parameters including multi-streaming, PR-SCTP, and stream reset capabilities. Provides options for echo functionality, ordered/unordered delivery, and configurable think times between transmissions.
SctpServer	simple module	Server app for SCTP-based request-reply protocols. Handles a single session (and SCTP connection) at a time.
TcpBasicClientApp	simple module	Client for a generic request-response style protocol over TCP, to be used with TcpGenericServerApp.
TcpClientSocketIo	simple module	Opens a TCP connection to a given address and port and lets the module connected to its `trafficIn` and `trafficOut` gates send and receive data over that connection. When data is received on the `trafficIn` gate, it is forwarded on the TCP connection via the `socketOut` gate, and vice versa. This module simplifies the task of data exchange over a TCP connection. The TCP connection is opened when the module first receives data on its `trafficIn` gate.
TcpEchoAppThread	simple module	Thread for TcpEchoApp
TcpGenericServerApp	simple module	Generic server application for modeling TCP-based request-reply style protocols or applications.
TcpServerHostApp	simple module	Hosts TCP-based server applications. It dynamically creates and launches a new “thread” object for each incoming connection.
TcpServerListener	simple module	Opens a TCP socket to listen on a port, accepts incoming connections, and dynamically creates modules to handle them. The type of modules to be created can be specified in a parameter. The new modules will be appended to the connection[] submodule array of the parent of this module, i.e., they will be siblings of this module.
TcpServerSocketIo	simple module	Manages an established TCP connection. It handles data transmission to and from a module connected via the `trafficIn` and `trafficOut` gates. When data is received on the `trafficIn` gate, it is forwarded on the TCP connection via the `socketOut` gate, and vice versa. This module simplifies the task of data exchange over an established TCP connection.
TcpSessionApp	simple module	Single-connection TCP application: it opens a connection, sends the given number of bytes, and closes. Sending may be one-off, or may be controlled by a “script” which is a series of (time, number of bytes) pairs. May act either as client or as server. Compatible with both IPv4 (Ipv4) and IPv6 (Ipv6).
TcpSinkAppThread	simple module	Handles a single incoming TCP connection for TcpSinkApp.
TelnetApp	simple module	Models Telnet sessions with a specific user behavior. The server app should be TcpGenericServerApp. Compatible with both Ipv4 and Ipv6.
TrafficgenSimple	simple module	(no description)
TunLoopbackApp	simple module	Provides loopback functionality for a TUN interface by receiving packets, swapping source and destination addresses and ports, and sending them back through the same interface. Processes both network and transport layer headers to properly reverse packet direction. Useful for testing network configurations and protocols without requiring external connections.
TunnelApp	simple module	Relays packets between a pre-existing tunnel endpoint (a local TUN interface) and a remote network address using either UDP or IPv4 protocols.
UdpBasicApp	simple module	Sends UDP packets to the given IP address at the given interval. Compatible with both Ipv4 and Ipv6.
UdpBasicBurst	simple module	Sends UDP packets to the given IP address(es) in bursts, or acts as a packet sink. Compatible with both IPv4 (Ipv4) and IPv6 (Ipv6).
UdpEchoApp	simple module	Listens on a UDP port and sends back each received packet to its sender. Note: when used together with UdpBasicApp, UdpBasicApp’s “received packet lifetime” statistic will record round-trip times.
UdpSink	simple module	Consumes and prints packets received from the Udp module.
UdpSocketIo	simple module	Provides UDP socket handling for generic applications.
UdpVideoStreamClient	simple module	Video streaming client.
UdpVideoStreamServer	simple module	Video stream server. To be used with UdpVideoStreamClient.
SimpleVoipReceiver	simple module	Receives a VoIP stream generated by a SimpleVoipSender, and records statistics. The most important statistic is MOS (Mean Opinion Score, a value between 1 and 5, representing a human user’s view of the voice quality), computed using the E Model defined in the ITU-T G.107 standard. The parameters starting with “emodel_” correspond to the parameters of the E model.
SimpleVoipSender	simple module	Implements a simple VoIP source. It is a constant bitrate source, with talk spurt support added. Packets do not contain actual voice data. Connection setup/teardown is not modeled. The peer must be a SimpleVoipReceiver.
VoipStreamReceiver	simple module	VoipStreamReceiver listens on a UDP port and expects to receive VoIP packets on it. The received voice is then saved into a result audio file that can be compared with the original for further evaluation. VoIP packets are numbered, and out-of-order packets are discarded (the corresponding voice interval will be recorded as silence into the file). VoIP packets that miss their deadlines will similarly be discarded. It is assumed that the audio is played back with a delay (by default 20ms), which allows some jitter for the incoming packets. The resulting audio file is closed when the simulation completes (i.e., in the OMNeT++ finish() function). Only one voice session (“call”) may be underway at a time.
VoipStreamSender	simple module	VoipStreamSender accepts an audio file and a destination IP address/port as input, and will transmit the file’s contents as voice traffic over UDP n times (by default once). For transmission, the audio is resampled at the specified frequency and depth, and encoded with the specified codec at the specified bit rate, and chopped into packets that each carry a specified number of milliseconds of voice. Those values come from module parameters. Packets that are all silence (all samples are below a given threshold in absolute value) are transmitted as special “silence” packets. The module does not simulate any particular VoIP protocol (e.g. RTP), but instead accepts a “header size” parameter that can be set accordingly.
OscillatorBase	simple module	Base module for oscillators.
ExternalEnvironment	simple module	Executes a setup command on the host OS during initialization and another teardown command during module destruction. For example, it can be used to configure virtual network interfaces.
ExternalProcess	simple module	Launches an external OS process in the background, using the command line given in the ‘command’ parameter. The process is terminated when the module is deleted. This module requires using the ~RealTimeScheduler class as the simulation event scheduler.
OsgGeographicCoordinateSystem	simple module	Provides an accurate geographic coordinate system using the built-in OSG API. This is mostly useful for local 3D visualizations created with osgEarth. Scene coordiantes are in meters relative to the scene origin.
SimpleGeographicCoordinateSystem	simple module	Provides a very simple and less accurate geographic coordinate system. The Earth is modeled as a sphere so you may get inaccuracies if you compare it to other wgs84 coordinates. Scene coordinates are in meter and are relative to the scene anchor point. It doesn’t support rotation so the X axis always points east and the Y axis always points south (to have the same handedness as the scene coordinate system)!
Wgs84AnchoredGeographicCoordinateSystem	simple module	Provides an accurate geographic coordinate system: the scene coordinate frame is a local tangent plane pinned to a geographic anchor point and optionally rotated. Scene coordinates are in meters relative to that anchor.
Wgs84EcefGeographicCoordinateSystem	simple module	Provides an accurate geographic coordinate system in which the scene coordinate frame coincides with the Earth-Centered Earth-Fixed (ECEF) frame (origin at the center of the Earth, Z towards the north pole, meters), using the WGS84 ellipsoid.
LayeredProtocolBase	simple module	Module base for different layered protocols.
NodeStatus	simple module	Keeps track of the status of the network node (up, down, etc.) for other modules, and also displays it as a small overlay icon on this module and on the module of the network node.
MessageChecker	simple module	Module that allows checking fields of messages.
SignalSource	simple module	Emits double-valued signals in the specified interval. May be used for testing indicator figures.
ThruputMeter	simple module	Thruput measurement utility module.
PcapRecorder	simple module	Records PCAP traces of frames sent/received by other modules within the same host. By default, it records frames sent/received by L2 modules of StandardHost and Router. The output filename is expected in the `pcapFile` parameter. The `PcapRecorder` module can also print tcpdump-like textual information on the log (EV); this functionality can be controlled by the verbose parameter.
ResidenceTimeMeasurer	simple module	Measures the residence time of packet data in network nodes. The measurement is done by tracking every bit individually using their unique identity. For each bit, the measurement starts when the incoming enclosing packet reception ends (or starts) in the network node. Similarly, for each bit, the measurement ends when the outgoing enclosing packet transmission starts (or ends) in the network node.
ScenarioManager	simple module	ScenarioManager is for setting up and controlling simulation experiments. You can schedule certain events to take place at specified times, like changing a parameter value, changing the bit error rate of a connection, removing or adding connections, removing or adding routes in a routing table, etc, so that you can observe the transient behavior.
ExtEthernetSocket	simple module	Provides a bidirectional connection to an Ethernet socket of the host computer which is running the simulation. It writes the packets that arrive on `upperLayerIn` gate to the specified real socket and sends out packets that arrive from the real socket on the `upperLayerOut` gate.
ExtEthernetTapDevice	simple module	Provides a bidirectional connection to a real TAP device of the host computer which is running the simulation. It writes the packets arrived on `lowerLayerIn` gate to the specified real TAP device, and sends out packets arrived from the real TAP device on `lowerLayerOut` gate.
ExtIpv4Socket	simple module	Provides a bidirectional connection to an IPv4 socket of the host computer which is running the simulation. It writes the packets arrived on `upperLayerIn` gate to the specified real socket, and sends out packets arrived from the real socket on `upperLayerOut` gate.
ExtIpv4TunDevice	simple module	Provides a bidirectional connection to a real TUN device of the host computer which is running the simulation. It writes the packets arrived on `lowerLayerIn` gate to the specified real TUN device, and sends out packets arrived from real TAP device on `lowerLayerOut` gate.
Ipv4Encap	simple module	Handles IPv4 encapsulation and decapsulation for network emulation. Adds IPv4 headers to outgoing packets and removes them from incoming packets. Processes packet tags for fields like TOS, DSCP, ECN, and hop limit. Supports socket operations and manages protocol registration for dispatching packets to the appropriate upper layer protocols.
ExtLowerUdp	simple module	Provides UDP protocol services suitable for emulation. The lower part of the UDP protocol is realized in the real world using real UDP sockets of the host computer which is running the simulation.
MacRelayUnitBase	simple module	Abstract base module for MAC relay unit implementations (Ethernet switches). Provides core functionality for MAC address learning and frame forwarding in bridged Ethernet networks. Contains functionality for maintaining a MAC address table that maps addresses to ports, learning addresses from incoming frames, and forwarding frames to appropriate interfaces. It is able to handle unicast, multicast, and broadcast traffic according to standard Ethernet switching rules.
ExampleQosClassifier	simple module	An example QoS classifier that assigns a User Priority based on the transport protocol and port numbers.
QosClassifier	simple module	Classifies packets and assigns a User Priority based on the IP protocol or the transport protocol port numbers.
RandomQosClassifier	simple module	A QoS classifier that assigns a random User Priority. This is useful for testing purposes.
FailureProtectionConfigurator	simple module	Provides Time-Sensitive Networking (TSN) configuration using other configurators. One is used to provide the stream redundancy (stream splitting and stream merging) configuration, the other one is used to provide the gate scheduling configuration.
L2NetworkConfigurator	simple module	Allows configuring network scenarios at layer 2. The Stp and Rstp related parameters such as link cost, port priority and the “is-edge” flag can be configured with XML files.
L2NodeConfigurator	simple module	Has one instance per network node, and it acts like a bridge between the node and the network’s global configurator module, L2NetworkConfigurator.
MacForwardingTableConfigurator	simple module	Configures the forwarding database (MAC address table) of all network nodes in the network based on the automatically discovered network topology. The configurator uses the shortest path algorithm to determine the outgoing network interface for all network nodes and all destination network interfaces. The effect of this configuration is that the network can use the the GlobalArp module and completely eliminate the ARP protocol messages.
StreamRedundancyConfigurator	simple module	Provides Time-Sensitive Networking (TSN) static stream redundancy configuration. The module automatically configures all the necessary modules related to stream splitting, stream merging and stream filtering in all network nodes. The configuration parameter specifies the streams with a set of path fragments.
GateScheduleConfiguratorBase	simple module	Serves as a basis for gate scheduling configurator modules. It provides methods for derived modules to easily extract the input parameters from the network topology and also to carry out the actual configuration of the resulting schedule. The schedule is automatically configured in all of the PeriodicGate submodules of all queue submodules in the network interface MAC layer submodules. Besides, the application start offsets are also configured. This allows the derived modules to focus on the implementation of the actual scheduling algorithm.
EthernetEncapsulation	simple module	Performs Ethernet II or Ethernet with LLC/SNAP encapsulation/decapsulation.
LocalDelivery	simple module	(no description)
MacForwardingTable	simple module	Handles the mapping between ports and MAC addresses.
EthernetPauseCommandProcessor	simple module	(no description)
EthernetSocketTable	simple module	(no description)
Ieee80211LlcEpd	simple module	An LLC implementation that encapsulates packets with the IEEE 802 `EtherType` Protocol Discrimination (EPD) header, as defined in section 9.2 `EtherTypes` of the IEEE Std 802-2014 standard. See Ieee802EpdHeader.
BasicMpduAggregationPolicy	simple module	Implements an MPDU aggregation policy that never aggregates frames.
BasicMsduAggregationPolicy	simple module	Implements a basic MSDU aggregation policy, controlled by parameters such as the minimum number of subframes needed to compose an A-MSDU, the minimum length for the aggregated payload, the maximum A-MSDU size, etc.
OriginatorBlockAckAgreementHandler	simple module	Manages Block Acknowledgment (Block Ack) agreements for the originator side in IEEE 802.11 networks. Handles the creation, maintenance, and termination of Block Ack agreements with receivers. Processes ADDBA requests/responses and DELBA frames, tracks agreement timeouts, and maintains the state of active agreements. Enables efficient acknowledgment of multiple frames with a single Block Ack frame.
OriginatorBlockAckAgreementPolicy	simple module	Implements the default originator block ACK agreement policy
RecipientBlockAckAgreementHandler	simple module	Manages Block Acknowledgment (Block Ack) agreements for the recipient side in IEEE 802.11 networks. Processes ADDBA requests from originators, creates and maintains Block Ack agreements, handles timeouts, and generates appropriate responses. Implements the recipient side of the Block Ack mechanism as defined in the IEEE 802.11 standard for efficient acknowledgment of multiple frames.
RecipientBlockAckAgreementPolicy	simple module	Implements the default recipient block ACK agreement policy.
Hcca	simple module	Implements HCCA (Hybrid Coordination Function Controlled Channel Access) for IEEE 802.11.
Contention	simple module	The default implementation of IContention.
EdcaCollisionController	simple module	A collision controller used with EDCA. It detects and reports internal collisions among Edcaf instances.
Ds	simple module	Implements the DS (Distribution Service) for IEEE 802.11, which is responsible for distributing correctly received frames to the higher layer, to the wireless LAN, etc.
BasicFragmentationPolicy	simple module	Implements a basic fragmentation policy, which employs a fragmentation frame size threshold.
AckHandler	simple module	Manages acknowledgment (ACK) status tracking for transmitted frames in IEEE 802.11 networks. Maintains a record of frame transmission states, processes received ACK frames, and determines when frames need retransmission.
NonQosRecoveryProcedure	simple module	Implements frame retransmission and recovery procedures for non-QoS frames in IEEE 802.11 networks. Manages short and long retry counters, adjusts contention window size based on transmission outcomes, and enforces retry limits. Handles different retry procedures for frames below and above the RTS threshold as specified in IEEE 802.11 standard section 9.19.2.6.
OriginatorAckPolicy	simple module	Implements the default originator ACK policy for non-QoS stations.
OriginatorQosAckPolicy	simple module	Implements the default originator ACK policy for QoS stations.
QosAckHandler	simple module	Manages acknowledgment handling for QoS frames in IEEE 802.11 networks. Tracks the status of transmitted frames, processes received acknowledgments (both normal ACKs and Block ACKs), and handles different acknowledgment policies. Supports QoS-specific features including Traffic Identifier (TID) based frame tracking and Block ACK mechanisms, enabling reliable frame delivery with Quality of Service guarantees.
QosRecoveryProcedure	simple module	Implements frame retransmission and recovery procedures for QoS frames in IEEE 802.11 networks. Manages retry counters for failed transmissions, adjusts contention window size, and enforces retry limits. Maintains separate short and long retry counters based on frame size relative to RTS threshold, and tracks per-TID frame status to support Quality of Service requirements.
QosRtsPolicy	simple module	Implements the default RTS policy for QoS stations.
RtsPolicy	simple module	Implements the default RTS policy.
TxopProcedure	simple module	Implements the Transmission Opportunity (TXOP) mechanism in IEEE 802.11 QoS networks. Manages TXOP periods during which a station has the right to transmit. Tracks TXOP limits based on access category (AC) and PHY mode. Supports both single and multiple protection mechanisms to protect frame exchanges during the TXOP.
OriginatorProtectionMechanism	simple module	Calculates the Duration/ID field for IEEE 802.11 frames to implement the Network Allocation Vector (NAV) mechanism for virtual carrier sensing. This module computes appropriate duration values for different frame types (RTS, data, management) based on IEEE 802.11 standard rules. For RTS frames, it calculates time needed for the complete RTS-CTS-DATA-ACK exchange.
SingleProtectionMechanism	simple module	Implements the single protection mechanism for IEEE 802.11 networks as defined in the standard section 8.2.5.2. This module calculates the Duration/ID field values for different frame types (RTS, CTS, BlockAckReq, BlockAck, data, management) to properly set the Network Allocation Vector (NAV) in receiving stations.
InProgressFrames	simple module
AarfRateControl	simple module	Implements the Adaptive ARF (AARF) rate control mechanism, which was initially described in IEEE 802.11 Rate Adaptation: A Practical Approach, by M. Lacage, M.H. Manshaei, and T. Turletti, 2004.
OnoeRateControl	simple module	Implements ONOE, a credit-based rate control algorithm originally developed by Atheros.
QosRateSelection	simple module	Implements rate selection for IEEE 802.11 QoS frames. Selects appropriate transmission rates for different frame types (data, management, control, response) based on configured parameters and dynamic conditions. Supports different bitrates for multicast frames, response frames (ACK, CTS, BlockAck), and can use a rate control module for dynamic rate adaptation.
RateSelection	simple module	Implements the default rate selection algorithm. Rate selection decides what bit rate (or MCS) should be used for control frames, management frames and data frames.
CtsPolicy	simple module	Implements the default CTS policy.
QosCtsPolicy	simple module	Implements the default CTS policy for QoS stations.
RecipientAckPolicy	simple module	Implements the default recipient ACK policy.
RecipientQosAckPolicy	simple module	Implements the default recipient ACK policy for QoS stations.
Rx	simple module	Responsible for checking frames received over the radio for errors, for managing the NAV, and for notifying other processes about the channel state (free or busy).
Tx	simple module	Responsible for unconditionally transmitting a frame after waiting for a specified inter-frame space. This is the default implementation of the ITx module interface.
Ieee80211AgentSta	simple module	Used in 802.11 infrastructure mode: in a station (STA), this module controls channel scanning, association and handovers, by sending commands (e.g. Ieee80211Prim_ScanRequest) to the management module (Ieee80211MgmtSta).
Ieee80211MgmtAdhoc	simple module	IEEE 802.11 management module used for ad-hoc mode. This implementation never sends control or management frames, and discards any such frame received. Distributed beacon generation is not modeled.
Ieee80211MgmtAp	simple module	Used in 802.11 infrastructure mode in an access point (AP).
Ieee80211MgmtApSimplified	simple module	Used in 802.11 infrastructure mode in an access point (AP).
Ieee80211MgmtSta	simple module	Used in 802.11 infrastructure mode: handles management frames for a station (STA).
Ieee80211MgmtStaSimplified	simple module	Used in 802.11 infrastructure mode for a station (STA).
Ieee80211Mib	simple module	Management Information Base for IEEE 802.11 networks. Stores configuration and state information including network mode (infrastructure, ad-hoc, mesh), station type (access point or station), authentication and association status, and BSS data (SSID, BSSID). Used by various IEEE 802.11 modules to maintain protocol state and control frame addressing.
Ieee80211Portal	simple module	Implements the portal functionality in IEEE 802.11 networks, serving as a bridge between wireless LANs and wired networks. Performs protocol conversion between IEEE 802.11 frames and IEEE 802.3 (Ethernet) frames, handling frame format differences and LLC header management.
Rstp	simple module	Implements the Rapid Spanning Tree Protocol (IEEE 802.D-2004) for IEC 48-bit MAC addresses. It is a complete implementation except it doesn’t fall back to STP when peers don’t support RSTP.
Stp	simple module	The Spanning Tree Protocol (STP) is a network protocol that ensures a loop-free topology for any bridged Ethernet local area network. The basic function of STP is to prevent bridge loops and the broadcast radiation that results from them. Spanning tree also allows a network design to include spare (redundant) links to provide automatic backup paths if an active link fails, without the danger of bridge loops or the need for manually enabling/disabling these backup links.
StpTester	simple module	Network tester module. Shows if a network topology is loop-free, all nodes are connected, or it has a tree topology.
Ieee8021qSocketTable	simple module	Maintains a table of IEEE 802.1Q VLAN sockets. Each socket entry contains a socket ID, protocol, VLAN ID, and a flag indicating whether to steal packets. The module provides functionality to add, remove, and find sockets based on protocol and VLAN ID criteria. It enables applications to communicate through specific VLANs by associating sockets with VLAN tags, facilitating the routing of packets to the appropriate protocol handlers.
Ieee8022Llc	simple module	(no description)
Ieee8022LlcSocketTable	simple module	(no description)
Loopback	simple module	Loopback interface module implementation.
Mrp	simple module	Implements the Media Redundancy Protocol (MRP) as specified in IEC 62439-2. MRP is used for managing redundancy in ring network topologies commonly found in industrial network settings. MRP is similar in its function to STP and RSTP, in that it ensures a loop-free topology for an Ethernet local area network. This module implements the Media Redundancy Manager (MRM), Media Redundancy Client (MRC), and Media Redundancy Automanager (MRA) roles. This model also includes support for detecting link errors with the help of Continuity Check Messages (CCM) messages defined in 802.1q CFM.
MrpMacForwardingTable	simple module	This is a variant of MacForwardingTable, with added support for the Media Redundancy Protocol (MRP) defined in IEC 62439-2.
Ppp	simple module	PPP implementation.
Tun	simple module	Implements a TUN (network tunnel) interface that provides a virtual network interface for applications. This is the main component of TunInterface. Allows applications to send and receive packets directly to/from the network layer using a socket-like API. Maintains a list of registered sockets and handles commands for opening, closing, and using the TUN interface. Processes packets between upper layers and the network layer, adding appropriate tags for routing.
VirtualTunnel	simple module	Creates a virtual network interface that tunnels traffic through an existing real network interface. This is the main component of VirtualInterface. Supports tunneling via Ethernet or IEEE 802.1Q protocols, with optional VLAN tagging for traffic separation.
MobilityBase	simple module	Abstract base module for mobility models.
Arp	simple module	Implements the Address Resolution Protocol for IPv4 and IEEE 802 6-byte MAC addresses.
GlobalArp	simple module	Provides global address resolution without exchanging packets.
EchoProtocol	simple module	Provides a mechanism to test network layer connectivity using echo request/response messages similar to those of ICMP.
InterfaceTable	simple module	Keeps the table of network interfaces.
NetfilterInfoHook	simple module	(no description)
L3NetworkConfiguratorBase	simple module	Serves as a base module for layer 3 network configurators.
NetworkConfiguratorBase	simple module	(no description)
HostAutoConfigurator	simple module	HostAutoConfigurator automatically assigns IP addresses and sets up the routing table. It has to be added to each host.
Ipv4FlatNetworkConfigurator	simple module	Configures IPv4 addresses and routing tables for a “flat” network, “flat” meaning that all hosts and routers will have the same network address and will only differ in the host part.
Ipv4NodeConfigurator	simple module	Configures the containing network node using information provided by the network’s global configurator modue Ipv4NetworkConfigurator.
Ipv6FlatNetworkConfigurator	simple module	Configures IPv6 addresses and routing tables for a “flat” network, “flat” meaning that all hosts and routers will have the same network address and will only differ in the host part.
Ipv6NodeConfigurator	simple module	Configures the containing network node using information provided by the network’s global configurator module Ipv6NetworkConfigurator.
SingleRateThreeColorMeter	simple module	Implements a Single Rate Three Color Meter (RFC 2697).
TokenBucketMeter	simple module	Simple token bucket meter.
TwoRateThreeColorMeter	simple module	Implements a Two Rate Three Color Meter (RFC 2698).
Icmpv6	simple module	Implements ICMPv6 (RFC 4443): it generates and processes ICMPv6 error messages (destination unreachable, packet too big, time exceeded, parameter problem) on behalf of Ipv6, and answers Echo Requests (ping) with Echo Replies. Neighbor Discovery messages (RS/RA/NS/NA/Redirect) are not handled here but by Ipv6NeighbourDiscovery.
Ipv6NeighbourDiscovery	simple module	Implements IPv6 Neighbor Discovery.
Mldv1	simple module	Implements MLDv1 (RFC 2710): Multicast Listener Discovery for IPv6 – the IPv6 equivalent of Igmpv2. A single module performs both the host listener role and the router querier role; the router role is active only on multicast routers (i.e. when IPv6 multicast forwarding is enabled on the node).
Mldv2	simple module	Implements MLDv2 (RFC 3810): Multicast Listener Discovery version 2 for IPv6 – the IPv6 equivalent of Igmpv3, and the source-filtering successor to Mldv1. Beyond plain group membership, MLDv2 lets a host request a group’s traffic while INCLUDING or EXCLUDING a specific set of sources – the basis for Source-Specific Multicast (SSM). A single module performs both the host listener role and the multicast-router (querier) role; the router role is active only on multicast routers (i.e. when IPv6 multicast forwarding is enabled on the node).
MatrixCloudDelayer	simple module	Delay module for InternetCloud. This is essentially equivalent to a full graph with edges being differently configured `DatarateChannel`’s. It delays and/or drops incoming packets based on rules specified in an xml configuration.
IPsec	simple module	Implements basic IPsec (RFC 4301) functionality. It supports Authentication Header (AH) and Encapsulating Security Payload (ESP), in transport mode, for IPv4 and IPv6 unicast traffic (UDP/TCP/ICMP/ICMPv6). The address family is selected per instance via the `networkProtocol` parameter; the same module type is used in both the IPv4 and IPv6 network layers. A simple performance model to account for the overhead of cryptography is included. The IPsec databases SPD and SAD are stored in separate modules (SecurityPolicyDatabase, SecurityAssociationDatabase).
SecurityAssociationDatabase	simple module	Represents the IPsec Security Association Database (SAD). The database is filled by the IPsec module.
SecurityPolicyDatabase	simple module	Represents the IPsec Security Policy Database (SPD). The database is filled by the IPsec module.
Icmp	simple module	ICMP implementation.
Igmpv2	simple module	Implementation of IGMPv2 protocol. Multicast routers use IGMP to learn which groups have members on each of their attached physical networks.
Igmpv3	simple module	Implements IGMPv3 (RFC 3376), the source-filtering version of the Internet Group Management Protocol for IPv4. Beyond plain group membership (see Igmpv2), IGMPv3 lets a host request a group’s traffic while INCLUDING or EXCLUDING a specific set of sources – the basis for Source-Specific Multicast. A single module performs both the host and the multicast-router (querier) role.
Ipv4	simple module	Implements the IPv4 protocol. The protocol header is represented by the Ipv4Header message class.
Ipv4NatTable	simple module	Stores the network address translation table.
Ipv4RoutingTable	simple module	Stores the routing table. (Per-interface configuration is stored in InterfaceTable.)
RoutingTableRecorder	simple module	Records changes in the routing tables (Ipv4RoutingTable) and interface tables (InterfaceTable) of all hosts and routers. The filename has to be specified in the routinglog-file configuration option that this module registers.
Ipv6	simple module	Implements the IPv6 protocol.
Ipv6RoutingTable	simple module	IPv6 Routing Table and Neighbor Discovery data structures. NOTE: This component MUST be named as `routingTable6` inside a StandardHost/Router etc. in order to be accessible by the Ipv6 and other modules.
Ipv6Tunnel	simple module	Worker module of ~Ipv6TunnelInterface: performs IPv6-in-IPv6 (RFC 2473) encapsulation. A packet routed to this interface (from the IPv6 layer) is wrapped in an outer IPv6 header and handed back to IPv6, which forwards the encapsulated datagram toward the tunnel exit.
Ldp	simple module	Handles and processes LDP messages.
BindingCache	simple module	Holds the Binding Cache of a home agent or correspondent node (RFC 3775): the bindings registered by mobile nodes, mapping each mobile node’s home address to its current care-of address, together with the sequence number and binding lifetime. A home agent uses it to intercept and tunnel traffic to a mobile node that is away from home; a correspondent node uses it for route optimization (sending directly to the care-of address). It also keeps the return-routability nonces used to validate Binding Updates.
BindingUpdateList	simple module	Holds the Binding Update List of a mobile node (RFC 3775): one entry per home agent and correspondent node the node has sent a Binding Update to, recording the care-of address registered, sequence numbers, binding lifetimes, the return-routability state (home/care-of keygen tokens and nonce indices), and retransmission bookkeeping.
Mipv6	simple module	Implements Mobile IPv6 (RFC 3775): the mobility signalling and binding management logic for a mobile node, home agent, or correspondent node (the role is selected by the `isMobileNode` and `isHomeAgent` parameters). It is a submodule of Ipv6NetworkLayer (enabled by its `hasMipv6` parameter) and works together with the BindingUpdateList and BindingCache modules.
LibTable	simple module	Stores the LIB (Label Information Base), accessed by Mpls and its associated control protocols (RsvpTe, Ldp) via direct C++ method calls.
Mpls	simple module	Implements the MPLS protocol.
NextHopForwarding	simple module	A simplified next hop forwarding that routes datagrams using different kinds of network addresses.
NextHopRoutingTable	simple module	Stores next hop routes used by the next hop forwarding protocol.
Pmipv6	simple module	Implements Proxy Mobile IPv6 (RFC 5213): network-based mobility management. Unlike Mobile IPv6 (Mipv6), the mobile node runs no mobility software; the network handles mobility through two entities, both implemented by this module and selected by the `isLocalMobilityAnchor` / `isMobileAccessGateway` parameters:
RsvpClassifier	simple module	Table-based ingress classifier.
RsvpTe	simple module	Implements RSVP-TE, a signalling protocol for MPLS. The module processes RSVP-TE messages, installs labels and does the reservation along LSP paths.
LinkStateRouting	simple module	Implements a very minimalistic link state routing protocol. Apart from the basic topology information, the current link usage is distributed to all participants in the network (by means of flooding).
Ted	simple module	Traffic Engineering Database. Stores network topology with detailed link information, including total and reserved bandwidths.
EthernetHub	simple module	A simple Ethernet hub device that operates at the physical layer. It connects multiple Ethernet devices together in a star topology while creating a single collision domain.
WireJunction	simple module	Models a generic wiring hub.
EthernetCsmaPhy	simple module	Implements the Ethernet CSMA/CD PHY protocol. It supports building both Ethernet CSMA/CD and Ethernet PLCA network interfaces.
EthernetPhy	simple module	(no description)
EthernetPlca	simple module	Implements the Ethernet Phyisical Layer Collision Avoidance (PLCA) protocol defined in the IEEE 802.3cg-2019 standard. It can be used to build an Ethernet network interface that can be connected to 10BASE-T1S multidrop links.
ApskDemodulator	simple module	Part of a simple hypothetical layered receiver. It computes the bit domain representation from the symbol domain representation by applying the configured modulation.
ApskModulator	simple module	Part of a simple hypothetical layered transmitter. It computes the symbol domain representation from the bit domain representation by applying the configured modulation.
DimensionalReceiverAnalogModel	simple module	(no description)
ScalarReceiverAnalogModel	simple module	(no description)
UnitDiskReceiverAnalogModel	simple module	See also: UnitDiskRadioMedium, UnitDiskMediumAnalogModel, UnitDiskReceiverAnalogModel.
StateBasedCcEnergyConsumer	simple module	Provides a radio energy consumer model. The current consumption is determined by the radio mode, the transmitter state, and the receiver state using constant parameters.
StateBasedEpEnergyConsumer	simple module	Provides a radio power consumer model. The power consumption is determined by the radio mode, the transmitter state, and the receiver state using constant parameters.
Ieee80211OfdmDemodulator	simple module	See also: Ieee80211OfdmModulator
Ieee80211OfdmModulator	simple module	This is an IEEE 802.11 OFDM modulator module. The implementation is based on the 18.3.5.8 Subcarrier modulation mapping section in IEEE 802.11-2012 Std.
CcEnergyConsumerBase	simple module	This is an abstract base module for current-based energy consumer models. It defines shared signals and statistics.
CcEnergyGeneratorBase	simple module	This is an abstract base module for current-based energy generator models. It defines shared signals and statistics.
CcEnergySinkBase	simple module	This is an abstract base module for current-based energy sink models. It defines signals and statistics.
CcEnergySourceBase	simple module	This is an abstract base module for current-based energy source models. It defines shared signals and statistics.
CcEnergyStorageBase	simple module	This is an abstract base module for current-based energy storage models. It defines shared signals and statistics.
EpEnergyConsumerBase	simple module	This is an abstract base module for power-based energy consumer models. It defines shared signals and statistics.
EpEnergyGeneratorBase	simple module	This is an abstract base module for power-based energy generator models. It defines shared signals and statistics.
EpEnergySinkBase	simple module	This is an abstract base module for power-based energy sink models. It defines signals and statistics.
EpEnergySourceBase	simple module	This is an abstract base module for power-based energy source models. It defines shared signals and statistics.
EpEnergyStorageBase	simple module	This is an abstract base module for power-based energy storage models. It defines shared signals and statistics.
SimpleEpEnergyManagement	simple module	This energy management model estimates the residual energy capacity of the energy source model by actually querying it. It is only useful when the estimation process is not important. This model initiates node shutdown when the residual capacity decreases below a threshold, and it also initiates node start when the residual capacity increases above another threshold.
ReceiveWithAcknowledge	simple module	(no description)
SendWithAcknowledge	simple module	(no description)
LengthBasedAggregatorPolicy	simple module	A policy for aggregating subpackets based on their length
ReceiveWithProtocol	simple module	(no description)
SendWithProtocol	simple module	(no description)
Forwarding	simple module	(no description)
ReceiveWithHopLimit	simple module	(no description)
SendWithHopLimit	simple module	(no description)
LengthBasedFragmenterPolicy	simple module	(no description)
CarrierBasedLifeTimer	simple module	(no description)
ReceiveAtL3Address	simple module	(no description)
ReceiveAtMacAddress	simple module	(no description)
ReceiveAtPort	simple module	(no description)
SendToL3Address	simple module	(no description)
SendToMacAddress	simple module	(no description)
SendToPort	simple module	Adds a destination port header to packets. The header contains the configured destination port and is used by the corresponding ReceiveAtPort module to filter packets.
GroupEligibilityTimeTable	simple module	A table containing the group eligibility times needed for the `GroupEligibilityTimeMeter`. Groups are dynamically added when a frame with a new combination of ingress port and priority values is seen.
PacketProcessorBase	simple module	Base module for various packet processing modules which maintains a few statistics.
GateControlList	simple module	Configures multiple `PeriodicGate` modules according to a gate control list. The modules are looked for at the `^.transmissionGate[*]` relative module path.
Aodv	simple module	Ad hoc On-Demand Distance Vector Routing Protocol module.
Bgp	simple module	Implements the BGP Version 4 routing protocol (RFC 4271).
Dsdv	simple module	Implements Destination-Sequenced Distance Vector.
Dymo	simple module	Provides Dynamic MANET On-demand (Dymo also known as AODVv2) Routing based on the IETF draft at http://tools.ietf.org/html/draft-ietf-manet-dymo-24.
EigrpRtp	simple module	(no description)
EigrpRtp6	simple module	(no description)
EigrpSplitter	simple module	(no description)
EigrpIpv4Pdm	simple module	(no description)
EigrpIpv6Pdm	simple module	(no description)
EigrpInterfaceTable	simple module	(no description)
EigrpIpv4NeighborTable	simple module	TODO auto-generated module
EigrpIpv4TopologyTable	simple module	(no description)
EigrpIpv6NeighborTable	simple module	TODO auto-generated module
EigrpIpv6TopologyTable	simple module	(no description)
Gpsr	simple module	Provides Greedy Perimeter Stateless Routing for Wireless Networks. The implementation supports both GG and RNG planarization algorithms.
Ospfv2	simple module	Implements the OSPFv2 routing protocol.
Ospfv3Splitter	simple module	(no description)
Ospfv3Process	simple module	Represents a single OSPFv3 routing process within a router. Handles the core functionality of the OSPFv3 protocol including neighbor discovery, database synchronization, shortest path calculation, and route installation. Multiple processes can run simultaneously on a router, each with its own process ID and router ID.
PimDm	simple module	Implementation of PIM-DM protocol (RFC 3973).
PimSm	simple module	Implementation of PIM-SM protocol (RFC 4601).
PimChecksumInsertionHook	simple module	Provides CRC (Cyclic Redundancy Check) insertion functionality for PIM packets. This hook ensures data integrity by calculating and inserting CRC values into outgoing PIM protocol messages before they are transmitted over the network.
PimSplitter	simple module	PimSplitter module dispatches PIM packets received from the network layer according to the PIM mode of the incoming interface. By using a PimSplitter it is possible to build nodes that operate in Dense Mode on some interfaces, and in Sparse Mode on others.
PimInterfaceTable	simple module	The `PimInterfaceTable` module contains the PIM specific configuration parameters and state of the interfaces on which PIM is enabled.
PimNeighborTable	simple module	The `PimNeighborTable` module contains information about neighboring PIM routers.
Rip	simple module	Routing Information Protocol.
Quic	simple module	Implements the QUIC protocol. For other implementations, see IQuic.
Rtcp	simple module	RTCP end system.
Rtp	simple module	The Rtp module is the center of the Rtp layer of an endsystem. It communicates with the application, and sends and receives Rtp data packets.
RtpAvProfile	simple module	Audio-Video RTP Profile. RtpAvProfile is internal to the Rtp module; instances are created and connected dynamically by Rtp.
RTPAVProfilePayload10Receiver	simple module	(no description)
RTPAVProfilePayload10Sender	simple module	(no description)
RtpAvProfilePayload32Receiver	simple module	(no description)
RtpAvProfilePayload32Sender	simple module	(no description)
RTPAVProfileSampleBasedAudioReceiver	simple module	(no description)
RTPAVProfileSampleBasedAudioSender	simple module	(no description)
RtpPayloadReceiver	simple module	(no description)
RtpPayloadSender	simple module	(no description)
RtpProfile	simple module	Generic RTP Profile. RtpProfile is internal to the Rtp module; instances are created and connected dynamically by Rtp.
Sctp	simple module	Implements the SCTP protocol.
SctpAssociation	simple module	Represents a single SCTP association in the SCTP protocol implementation. Implements the SCTP state machine and handles association establishment, data transfer, flow control, congestion control, and association termination. Provides extensive statistics collection for various SCTP metrics.
SctpChecksumInsertion	simple module	Inserts SCTP checksum into packets.
SctpNatHook	simple module	SCTP NAT hook module.
SctpNatTable	simple module	(no description)
SctpUdpHook	simple module	SCTP UDP hook module.
TcpChecksumInsertionHook	simple module	(no description)
TcpSpoof	simple module	Sends fabricated TCP packets. This is a base implementation, you’ll probably have to customize it in C++ according to what you want to send and when you want to send it.
TcpLwip	simple module	TCP model based on the LWIP 1.3.2 project. The original LWIP is available on this page.
Tcp	simple module	Implements the TCP protocol. For other implementations, see ITcp.
TcpConnection	simple module	Represents a single TCP connection in the TCP protocol implementation. Implements the TCP state machine and handles connection establishment, data transfer, flow control, congestion control, and connection termination. Provides extensive statistics collection for various TCP metrics including window sizes, sequence numbers, RTT measurements, and congestion parameters.
Udp	simple module	UDP protocol implementation, for IPv4 (Ipv4) and IPv6 (Ipv6).
UdpChecksumInsertionHook	simple module	Computes and inserts Cyclic Redundancy Check (CRC) values into UDP headers during packet processing. Implements a network filter hook that intercepts packets in the post-routing phase and inserts the correct CRC value based on the packet’s source and destination addresses.
VisualizerBase	simple module	Base module for visualizer simple modules. It simply provides the visualization target module for derived modules.

Extends¶

Name	Type	Description
ModuleMixin	simple module	Base module for all INET modules.

Parameters¶

Name	Type	Default value	Description
displayStringTextFormat	string	“”	Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information

Properties¶

Name	Value	Description
class	SimpleModule

Source code¶

//
// Base module for all INET simple modules.
//
simple SimpleModule extends ModuleMixin
{
    parameters:
        @class(SimpleModule);
}

File: src/inet/common/SimpleModule.ned