SimpleModule

simple module

Base module for all INET simple modules.

Inheritance diagram

The following diagram shows inheritance relationships for this type. Unresolved types are missing from the diagram.

Known subclasses

Name	Type	Description
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.
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.
Aodv	simple module	Ad hoc On-Demand Distance Vector Routing Protocol module.
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.
Arp	simple module	Implements the Address Resolution Protocol for IPv4 and IEEE 802 6-byte MAC addresses.
BasicFragmentationPolicy	simple module	Implements a basic fragmentation policy, which employs a fragmentation frame size threshold.
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.
Bgp	simple module	Implements BGP Version 4 routing protocol.
BindingCache	simple module	~xMIPv6 Data structure for the HA and CN(s) only.
BindingUpdateList	simple module	~xMIPv6 Data structure for the Mobile Node(1,2).
CarrierBasedLifeTimer	simple module	(no description)
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.
Contention	simple module	The default implementation of IContention.
CtsPolicy	simple module	Implements the default CTS policy.
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.
DimensionalReceiverAnalogModel	simple module	(no description)
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.
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.
EchoProtocol	simple module	Provides a mechanism to test network layer connectivity using echo request/response messages similar to those of ICMP.
EdcaCollisionController	simple module	A collision controller used with EDCA. It detects and reports internal collisions among ~Edcaf instances.
EigrpInterfaceTable	simple module	(no description)
EigrpIpv4NeighborTable	simple module	TODO auto-generated module
EigrpIpv4Pdm	simple module	(no description)
EigrpIpv4TopologyTable	simple module	(no description)
EigrpIpv6NeighborTable	simple module	TODO auto-generated module
EigrpIpv6Pdm	simple module	(no description)
EigrpIpv6TopologyTable	simple module	(no description)
EigrpRtp	simple module	(no description)
EigrpRtp6	simple module	(no description)
EigrpSplitter	simple module	(no description)
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.
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.
EthernetCsmaPhy	simple module	Implements the Ethernet CSMA/CD PHY protocol. It supports building both Ethernet CSMA/CD and Ethernet PLCA network interfaces.
EthernetEncapsulation	simple module	Performs Ethernet II or Ethernet with LLC/SNAP encapsulation/decapsulation.
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.
EthernetPauseCommandProcessor	simple module	(no description)
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.
EthernetSocketIo	simple module	Provides Ethernet socket handling for generic applications.
EthernetSocketTable	simple module	(no description)
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.
ExampleQosClassifier	simple module	An example QoS classifier that assigns a User Priority based on the transport protocol and port numbers.
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.
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.
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.
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.
Forwarding	simple module	(no description)
GateControlList	simple module	Configures multiple `PeriodicGate` modules according to a gate control list. The modules are looked for at the `^.transmissionGate[*]` relative module path.
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.
GlobalArp	simple module	Provides global address resolution without exchanging packets.
Gpsr	simple module	Provides Greedy Perimeter Stateless Routing for Wireless Networks. The implementation supports both GG and RNG planarization algorithms.
GroupEligibilityTimeTable	simple module	(no description)
Hcca	simple module	Implements HCCA (Hybrid Coordination Function Controlled Channel Access) for IEEE 802.11.
HostAutoConfigurator	simple module	~HostAutoConfigurator automatically assigns IP addresses and sets up the routing table. It has to be added to each host.
Icmp	simple module	ICMP implementation.
Icmpv6	simple module	ICMPv6 implementation.
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).
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.
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.
Ieee80211OfdmDemodulator	simple module	<b>See also:</b> ~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.
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.
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)
Ieee8022LlcSocketIo	simple module	Provides IEEE 802.2 LLC socket handling for generic applications.
Ieee8022LlcSocketTable	simple module	(no description)
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	(no description)
InProgressFrames	simple module
InterfaceTable	simple module	Keeps the table of network interfaces.
IPsec	simple module	Implements basic IPsec (RFC 4301) functionality. It supports Authentication Header (AH) and Encapsulating Security Payload (ESP), in transport mode, for IPv4 unicast traffic (UDP/TCP/ICMP). 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).
IpSocketIo	simple module	Provides IP socket handling for generic applications.
Ipv4	simple module	Implements the IPv4 protocol. The protocol header is represented by the ~Ipv4Header message class.
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.
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.
Ipv4NatTable	simple module	Stores the network address translation table.
Ipv4NodeConfigurator	simple module	Configures the containing network node using information provided by the network's global configurator modue ~Ipv4NetworkConfigurator.
Ipv4RoutingTable	simple module	Stores the routing table. (Per-interface configuration is stored in ~InterfaceTable.)
Ipv6	simple module	Implements the IPv6 protocol.
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.
Ipv6NeighbourDiscovery	simple module	Implements IPv6 Neighbor Discovery.
Ipv6RoutingTable	simple module	IPv6 Routing Table and Neighbor Discovery data structures. NOTE: This component MUST be named as `routingTable6` inside a ~StandardHost/~Router(1,2) etc. in order to be accessible by the ~Ipv6 and other modules
Ipv6Tunneling	simple module	IPv6 Tunnel Manager
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.
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.
L3NetworkConfiguratorBase	simple module	Serves as a base module for layer 3 network configurators.
LayeredProtocolBase	simple module	Module base for different layered protocols.
Ldp	simple module	Handles and processes LDP messages.
LengthBasedAggregatorPolicy	simple module	A policy for aggregating subpackets based on their length
LengthBasedFragmenterPolicy	simple module	(no description)
LibTable	simple module	Stores the LIB (Label Information Base), accessed by ~Mpls and its associated control protocols (~RsvpTe, ~Ldp) via direct C++ method calls.
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).
LocalDelivery	simple module	(no description)
Loopback	simple module	Loopback interface module implementation.
MacForwardingTable	simple module	Handles the mapping between ports and MAC addresses.
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.
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.
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.
MessageChecker	simple module	Module that allows checking fields of messages.
MobilityBase	simple module	Abstract base module for mobility models.
Mpls	simple module	Implements the MPLS protocol.
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.
NetfilterInfoHook	simple module	(no description)
NetPerfMeter	simple module	Application model for comparing the performance of various transport protocols.
NetworkConfiguratorBase	simple module	(no description)
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.
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.
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.
OnoeRateControl	simple module	Implements ONOE, a credit-based rate control algorithm originally developed by Atheros.
OriginatorAckPolicy	simple module	Implements the default originator ACK policy for non-QoS stations.
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
OriginatorProtectionMechanism	simple module	Calculates the Duration/ID field for IEEE 802.11 frames to implement the Network(1,2,3,4) 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.
OriginatorQosAckPolicy	simple module	Implements the default originator ACK policy for QoS stations.
OscillatorBase	simple module	Base module for oscillators.
OsgGeographicCoordinateSystem	simple module	Provides an accurate geographic coordinate system using the built-in OSG API.
Ospfv2	simple module	Implements the OSPFv2 routing protocol.
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.
Ospfv3Splitter	simple module	(no description)
PacketProcessorBase	simple module	Base module for various packet processing modules which maintains a few statistics.
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(1,2). 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.
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.
PimDm	simple module	Implementation of PIM-DM protocol (RFC 3973).
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.
PimSm	simple module	Implementation of PIM-SM protocol (RFC 4601).
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.
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).
Ppp	simple module	PPP implementation.
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.
QosClassifier	simple module	Classifies packets and assigns a User Priority based on the IP protocol or the transport protocol port numbers.
QosCtsPolicy	simple module	Implements the default CTS policy for QoS stations.
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.
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.
Quic	simple module	Implements the QUIC protocol. For other implementations, see ~IQuic.
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)
RandomQosClassifier	simple module	A QoS classifier that assigns a random User Priority. This is useful for testing purposes.
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.
ReceiveAtL3Address	simple module	(no description)
ReceiveAtMacAddress	simple module	(no description)
ReceiveAtPort	simple module	(no description)
ReceiveWithAcknowledge	simple module	(no description)
ReceiveWithHopLimit	simple module	(no description)
ReceiveWithProtocol	simple module	(no description)
RecipientAckPolicy	simple module	Implements the default recipient ACK 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.
RecipientQosAckPolicy	simple module	Implements the default recipient ACK policy for QoS stations.
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.
Rip	simple module	Routing Information Protocol.
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.
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.
RsvpClassifier	simple module	Table-based ingress classifier.
RsvpTe	simple module	(no description)
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.
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.
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.
RtsPolicy	simple module	Implements the default RTS policy.
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).
ScalarReceiverAnalogModel	simple module	(no description)
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.
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.
SctpClient	simple module	Client app for SCTP-based request-reply protocols. Handles a single session (and SCTP connection) at a time.
SctpNatHook	simple module	SCTP NAT hook module.
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.
SctpNatTable	simple module	(no description)
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.
SctpUdpHook	simple module	SCTP UDP hook module.
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.
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.
SendWithAcknowledge	simple module	(no description)
SendWithHopLimit	simple module	(no description)
SendWithProtocol	simple module	(no description)
SignalSource	simple module	Emits double-valued signals in the specified interval. May be used for testing indicator figures.
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.
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.
SimpleGeographicCoordinateSystem	simple module	Provides a very simple and less accurate geographic coordinate system without using OSG. It doesn't support orientation.
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.
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(1,2,3,4) Allocation Vector (NAV) in receiving stations.
SingleRateThreeColorMeter	simple module	Implements a Single Rate Three Color Meter (RFC 2697).
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.
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(1,2,3,4) tester module. Shows if a network topology is loop-free, all nodes are connected, or it has a tree topology.
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.
Tcp	simple module	Implements the TCP protocol. For other implementations, see ~ITcp.
TcpBasicClientApp	simple module	Client for a generic request-response style protocol over TCP, to be used with ~TcpGenericServerApp.
TcpChecksumInsertionHook	simple module	(no description)
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.
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.
TcpEchoAppThread	simple module	Thread for ~TcpEchoApp
TcpGenericServerApp	simple module	Generic server application for modeling TCP-based request-reply style protocols or applications.
TcpLwip	simple module	TCP model based on the LWIP 1.3.2 project. The original LWIP is available on this page.
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.
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.
Ted	simple module	Traffic Engineering Database. Stores network topology with detailed link information, including total and reserved bandwidths.
TelnetApp	simple module	Models Telnet sessions with a specific user behavior. The server app should be ~TcpGenericServerApp. Compatible with both ~Ipv4 and ~Ipv6.
ThruputMeter	simple module	Thruput measurement utility module.
TokenBucketMeter	simple module	Simple token bucket meter.
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.
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.
TwoRateThreeColorMeter	simple module	Implements a Two Rate Three Color Meter (RFC 2698).
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.
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.
Udp	simple module	UDP protocol implementation, for IPv4 (~Ipv4) and IPv6 (~Ipv6).
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).
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.
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.
UnitDiskReceiverAnalogModel	simple module	<b>See also:</b> ~UnitDiskRadioMedium, ~UnitDiskMediumAnalogModel, ~UnitDiskReceiverAnalogModel.
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.
VisualizerBase	simple module	Base module for visualizer simple modules. It simply provides the visualization target module for derived modules.
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.
WireJunction	simple module	Models a generic wiring hub.
xMIPv6	simple module	Implements xMIPv6 (where x = F, H, F-H).

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