INET 4.6.0

This is a new feature release in the INET 4.x branch. Highlights include new protocol implementations for QUIC, Ethernet 10BASE-T1S, IPsec, and MRP; major refinements to the clock model; a reimplementation of IEEE 802.1AS (gPTP); and an important refactoring of the wireless physical layer's analog domain. The release continues to focus on improving correctness, accuracy, modularity, and long-term maintainability while addressing several long-standing limitations. Requires OMNeT++ 6.2 or later.

For the full list of additions, removals, and changes (features, modules, packet chunks/tags, signals, statistics, and C++ classes), see ChangeLog in the src folder.

For further questions, detailed explanations, and guided exploration of INET concepts and features, a dedicated AI-powered wiki is now available at https://deepwiki.com/inet-framework/inet

Notable backward-incompatible changes include the following

1. Clock model refinement

The clock and oscillator models were substantially reworked to improve accuracy, correctness, and robustness. Clock time to simulation time mapping and clock-interval to oscillator-tick conversions were rewritten for mathematical correctness, with stricter consistency checks. Accuracy was improved using precise arithmetic and new scaling utilities (e.g., NumberNear1 and SimTimeScale). The design anticipates future 128-bit simulation time support.

The updated model now accumulates fractional oscillator compensation for more accurate timing. The clock's nominal tick interval must be explicitly configured, as it no longer defaults to the simulation time resolution. The drifting oscillator model was extended with a configurable frequency compensation factor, distinct from the clock's step-based compensation mechanism.

The architecture was modularized to allow multiple clocks to share a single physical oscillator via the clock's oscillatorModule parameter. SettableClock now includes an underlying free-running clock submodule to support simulations that mix synchronized and unsynchronized time. A clock servo model was added, including the IClockServo module interface and the StepClockServo module for implementation.

Clock event handling was also refined: overdue events are now processed immediately, in clock-time order, and newly scheduled events are inserted at the lower bound of the corresponding simulation-time interval, preserving stable ordering. Clock time to simulation time conversion methods now accept explicit lower-bound arguments to ensure robust tie-breaking between adjacent ticks.

Clock and oscillator documentation was significantly expanded and formalized to reflect the stricter semantics of the new implementation.

This change is backward incompatible in that clock-based simulations may produce slightly different statistical results due to the improved correctness and accuracy of the model.

2. IEEE 802.1AS (gPTP) protocol reimplementation

Large parts of the protocol were reimplemented using formal state machines for both peer delay measurement and time synchronization. Standards conformance was improved, including correct handling of grandmaster and neighbor rate ratios. The peer delay and time synchronization processes now maintain separate state for requester/responder and sender/receiver roles.

The new model introduces a dedicated clock servo submodule for updating local time. Peer delay measurements now use an exponential moving average for improved stability and are performed using the unsynchronized local clock to avoid interference during active time synchronization.

For improved standards compliance, message timestamping now occurs at transmission start and reception start rather than at completion. As a result, simulations must use physical layer modules that emit explicit start-of-transmission and start-of-reception signals, such as the StreamingTransmitter and DestreamingReceiver modules.

Due to the high precision required for time synchronization, accurately modeling a 1 ppm clock drift with a nominal 10 ns tick interval requires very fine time granularity. gPTP simulations therefore typically require femtosecond (fs) simulation time resolution, which can be enabled via the simtime-resolution configuration option.

This change is backward incompatible in that simulations using gPTP may produce slightly different statistical results due to the improved correctness and accuracy of the model.

3. Ethernet module renames

Existing Ethernet MAC modules were renamed to use the MacPhy suffix (e.g. EthernetMacPhy, EthernetCsmaMacPhy) to reflect that they combine MAC and PHY functionality in a single module. This resolves naming conflicts introduced by the new dedicated EthernetCsmaMac and EthernetCsmaPhy modules, which provide a modern, state-machine-based implementation of the individual layers and are primarily used by the new Ethernet 10BASE-T1S model.

These changes are backward incompatible for simulations that directly reference the old module names.

4. Wireless physical layer refactoring

The wireless physical layer was significantly refactored to simplify how the analog representation of radio signals is selected. Instead of using separate module types, radio and medium modules now use a signalAnalogRepresentation parameter (unitDisk, scalar, or dimensional) to control their behavior.

Responsibility for computing reception success was partially moved from receiver modules to their analog model submodules. To reflect broader applicability, much of the former UnitDisk-specific implementation was replaced by generic components, resulting in modules such as GenericRadio, GenericTransmitter, and GenericReceiver, while UnitDisk remains available as an analog domain representation.

Specific wireless technologies, including IEEE 802.11, IEEE 802.15.4, and APSK, were refactored to align with the new architecture and can now be used with the unitDisk signal analog representation.

5. CRC, FCS, and Checksum

Frame Check Sequence (FCS) is now used consistently for link-layer protocols (e.g. Ethernet, IEEE 802.11), replacing the generic CRC terminology. Accordingly, crcMode parameters in MAC and radio modules were renamed to fcsMode. In the TCP/IP stack, the term checksum is now used explicitly for 16-bit one’s-complement sums, and crcMode was renamed to checksumMode.

The underlying implementations were modernized as well. New algorithms (CRC32C, CRC16-IBM, CRC16-CCITT) were added, generic and configurable CRC utilities were introduced, and protocol-specific handling was improved—most notably, SCTP now uses a dedicated CRC32C implementation. These changes improve standards compliance, verification reliability, and flexibility while preserving existing behavior by default.

Note that these changes are backward incompatible for simulations that explicitly configure the old crcMode or fcsMode parameters.

Notable backward compatible changes are the following

1. 10BASE-T1S Ethernet physical layer

A 10BASE-T1S Ethernet model was added, implementing Physical Layer Collision Avoidance (PLCA) in accordance with IEEE 802.3cg. The PLCA Reconciliation Sublayer provides deterministic access to the shared medium by assigning transmit opportunities (TOs) to nodes in a round-robin manner, effectively eliminating the collisions typical of CSMA/CD and enabling efficient half-duplex communication.

Unlike traditional point-to-point Ethernet topologies, 10BASE-T1S supports a multidrop bus (mixing segment) in which multiple nodes can be daisy-chained on a single twisted pair without a switch. The model introduces new modules such as EthernetCsmaMac, EthernetPlca, and EthernetCsmaPhy; users should use EthernetPlcaNode for hosts, EthernetPlcaInterface for network interfaces, and EthernetMultidropLink for connectivity.

Several example simulations were added to demonstrate the new functionality.

The 10BASE-T1S protocol implementation was contributed by a generous industry partner.

2. QUIC transport protocol

An implementation of the QUIC transport protocol was added, designed to be structurally modular, and suitable for performance and protocol-level experimentation. It models connection-oriented QUIC over UDP with explicit connection and socket management, supports the full handshake including 0-RTT connection establishment, and provides stream-based data transfer with configurable per-stream and connection-level flow control.

The model includes congestion control with selectable algorithms (e.g. NewReno), loss detection and retransmission with correct handling of ACK-eliciting and non-ACK-eliciting frames, and Path MTU Discovery with optional DPLPMTUD and ICMP Packet Too Big processing. It ensures correct byte ordering and in-order delivery, uses randomized initial destination connection IDs with robust lifecycle management, and supports clean connection teardown with explicit close handling and delayed destruction after CONNECTION_CLOSE.

Validation simulations are integrated into the fingerprint and validation test framework. Overall, the QUIC model provides a solid and extensible foundation for simulating modern UDP-based transport protocols and for comparing their behavior against TCP under controlled conditions.

The QUIC protocol implementation was contributed by Timo Völker.

3. IPsec protocol

The IPv4 model was extended with a comprehensive IPsec implementation to support secure network communication. The model supports both Authentication Header (AH) and Encapsulating Security Payload (ESP), with an emphasis on standards compliance, including correct AH header lengths and proper placement of ESP trailers within encrypted payloads.

The implementation supports UDP traffic and multicast communication, enabling a wide range of secured network scenarios. It also includes proto...

INET 3.8.5

This release contains compatibility fixes for OMNeT++ 6.1.
Requires OMNeT++ 5.7 or 6.0 or later.

INET 4.5.4

This is a minor patch release containing OMNeT++ 6.1 compatibility fixes (enum related issues). It contains also fixes for #880, #886, #913, #919, #956, #967, #974, #982. Several memory leak errors were fixed. Added logging and testing framework enhancements. Added a python/requirements.txt so Python dependencies can be installed by pip install -r python/requirements.txt. Fixed escaping errors with Python 3.12 in pythons scripts.

Test framework enhancements:

• Added new commands inet_run_*_tests to allow running various tests.
• Smoke tests are executed for run #0 only by default.
• Tests marked intentionally as SKIP are now left out from the test execution.
• Added inet_run_release_tests for pre-release testing.
• A lot of miscellaneous fixes.

INET 4.4.2

This is a minor bugfix release containing OMNeT++ 6.1 compatibility fixes, minor issues in pcapng Reader/Writer and an incorrect formula used in Rayleigh pathloss computation (NOTE: This change may alter a simulation's results if it used the Rayleigh pathloss model).

INET 4.5.2

This is a minor patch release of INET 4.5 containing several fixes since the 4.5.1 version.

INET 4.5.1

This patch release resolves a Windows-specific linker error (missing symbols) that occurred when trying to build model frameworks based on INET. It was fixed by adding INET_API annotations where they were missing.

INET 4.5.0

This is a new minor stable release within the INET 4.x branch. The main feature of this release is the ability to concurrently run multiple simulations within the same process (requires OMNeT++ 7.0 preview 2 or later), along with an extended Ethernet cut-through switching functionality.

There are also a number of small improvements, and several bug fixes. Some changes are backward incompatible, so existing models may need to be updated. This version requires OMNeT++ 6.0 or later.

For a complete list of all added, removed, and changed folders, NED modules, packet chunks, packet tags, statistics, C++ classes, and signals please refer to the ChangeLog file in the src folder.

Notable backward incompatible changes are the following:

1. Ethernet cut-through switching

   The Ethernet cut-through switching implementation has been extended to work with all TSN traffic filtering and TSN traffic shaping methods. Previously it was not possible to combine these features. For a packet that was forwarded using cut-through switching, the otherwise configured traffic shaping and traffic filtering methods in the switch were completely bypassed.

   The new implementation allows processing the incomplete packet in the switch while the packet buffer is being filled up by the incoming interface. All Ethernet headers are available and the packet length is known, so traffic filtering and traffic shaping can take place the same way it does for store-and-forward packets.

   For more information, see the showcase at: https://inet.omnetpp.org/docs/showcases/tsn/cutthroughswitching/doc/index.html

   This change doesn't require the modification of simulation models, but it may significantly change the statistical results of simulations that use traffic filtering or traffic shaping with cut-through switching.

2. Clock model

   The RandomDriftOscillator module has been refactored to have a more useful parameterization. The module has an initial random drift rate parameter that represents the inaccuracy of device production. Besides, the module uses a random walk process for an additional drift rate change that represents the voltage and temperature dependent inaccuracy of the device.

   Please note that the gPTP time synchronization change (described later) makes the RandomDriftOscillator module more useful than the previously widely used ConstantDriftOscillator module because the first time synchronization can now completely eliminate the effects of a constant drift.

   This change requires the modification of simulation models that use the RandomDriftOscillator module because the parameterization has been changed.

3. Time-Sensitive Networking

   The credit-based shaper has been changed to stop accumulating credits when the corresponding time-aware shaper (same traffic category) transmission gate is closed. Additionally, the credit-based shaper can also stop accumulating credits when the implicit guard band of the time-aware shaper is active.

   The time-aware shaper already provides an implicit guard band before each time a gate is closing according to the gate schedule. This guard band is defined by the following rule: no packet is allowed to pass the gate unless the packet can be transmitted completely before the gate closes.

   This change doesn't require the modification of simulation models, but it may significantly change the statistical results of simulations that use both the credit-based shaper and the time-aware shaper for the same traffic category.

4. Running simulations concurrently (experimental)

   INET has been changed to support running multiple simulations concurrently within a single process. Previously this was not possible, partly because OMNeT++ itself didn't support concurrent simulation execution, but also because INET contained several global variables. Please note that this is an experimental feature in both OMNeT++ and INET.

   In order to provide this feature, global variables have been either eliminated, or replaced with simulation shared variables, or marked with the 'const' qualifier signifying that their values cannot be changed, or marked with the 'OPP_THREAD_LOCAL' macro to store their values separately for each thread.

   This change may require the modification of simulation models if they directly access some of the modified global variables. Additionally, simulation models that have their own global variables must be updated to support running simulations concurrently.

   This feature requires using OMNeT++ 7.0 preview 2 or later. For more information, see the https://omnetpp.org/download/preview page.

Notable backward compatible changes are the following:

1. Clock model

   The clock model has been extended with an oscillator compensation parameter. This parameter can be used to reduce the effect of an inaccurate oscillator on clock time. Time synchronization mechanisms can often estimate the clock speed differences and set this parameter to reduce the clock time difference that would arise over time from clocks running at different speeds.

2. IEEE 802.1-AS (gPTP)

   The gPTP time synchronization protocol has been extended to also compensate for a drifting oscillator. Previously time synchronization only set the clock time but it didn't account for the clock speed differences between the master and the slave clock.

   This change can result in an order of magnitude smaller maximum clock time difference between the master and slave clocks over the period of two time synchronization events.

3. Queueing model

   The behavior of complex queueing models depends among others on the execution order of timers. Previously the scheduling priority for such timers were not configurable, so the user could not control the order of their execution. This limitation could prevent getting the desired behavior from the combination of certain modules. For example, a packet server may need to wait for all gates to open or close before using the scheduler to process the next packet at the same simulation time.

   Several queueing modules have been extended with additional parameters to control the scheduling priority of timers. This gives fine grained control over the order of timer events, that affects how the modules can be combined into more complex behavior.

   Additionally, the active packet source and packet sink modules that generate or consume traffic periodically have been extended with initial offset parameters.

4. IEEE 802.11

   The 802.11 model contains several policy modules that can be replaced by the user to customize the model behavior. For example, the fragmentation policy decides when and how frames should be fragmented. Unfortunately, previously several policy modules were not replaceable using only INI file parameter assignments. This limitation has been fixed.

   All policy submodules have been replaced with submodules having parameterized module types and corresponding module interfaces, making it easy to replace policy submodules using only INI files. Additionally, the documentation of several 802.11 modules and module interfaces have been refined.

5. Protocol element

   The generic protocol elements library have been extended with a protocol independent cut-through implementation. The new modules provide an example of how this mechanism can be implemented and allows teaching and researching this topic.

6. Notable bug fixes and other changes

   • The protocol encapsulation requests and protocol dispatching mechanism between applications, IP, Ethernet, and other protocols have been refactored to use a uniform implementation through utility functions. This provides the user with a more flexible network node architecture where the protocol encapsulation can be decided on a per packet basis.
   • Fixed exponent in the calculation of dielectric obstacle loss.
   • Fixed getReceptionStartTimeVariables method of Z3GateScheduleConfigurator.
   • Fixed processing of Ethernet control frames.
   • Fixed emitting linkBrokenSignal when transmitted packet is not acknowledged.
   • The IPv4NetworkConfigurator log output has been improved.

INET 4.4.1

This is a minor bugfix release, mostly fixing linker errors on Windows for projects depending on INET.

• Fixed #758
• Added several INET_API markers to fix linker errors on Windows
• Fixed duplicate symbol linker errors on Windows when using template classes as a base class.
• Fixed some inline method declarations.

INET 4.4.0

This is a new minor stable release of the INET 4.x branch. The highlight of this release is the implementation of several Time-Sensitive Networking (TSN) features. Also, INET is now fully licensed under LGPL (see later for details).

Experimental Python support has been added for running simulations concurrently and optionally on an SSH cluster. This is mostly useful for running parameter studies, automated testing and optimizing parameters.

There are also a number of small improvements, and several bug fixes. Some changes are backward incompatible, so existing models may need to be updated. This version requires OMNeT++ 6.0 or later.

For a complete list of all added, removed, and changed folders, NED modules, packet chunks, packet tags, statistics, C++ classes, and signals please refer to the ChangeLog file in the src folder.

Notable backward incompatible changes are the following:

1. Network interfaces

   The queue modules are placed back inside the network interface compound module as direct submodules, reverting back a previous change in INET 4.2 version.

   In the INET 3.x versions, the network interface queue submodules were part of the network interface compound modules, and they were directly connected to other submodules within the network interface using connections and gates. This structure was not ideal when a packet could be immediately served by the MAC layer, because the queue recorded a zero simulation time increase in the queue length. The problem was especially difficult to get around when compound packet queues were used. In order to fix this issue, we decided to move the MAC layer queues (as simple submodules) under the MAC layer compound module. Having this structure allowed the MAC modules to completely bypass the queue modules if the queueing of the packet was not necessary.

   Unfortunately, this change turned out to be bad for various reasons. The most important is that the queue needs to communicate with the module it is connected to. For example, a complex compound queue which can delay packets needs to notify the connected module, in this case of the MAC module, when a packet becomes ready to be pulled. So once again, we decided to move the queues back where they were before, outside of the MAC modules. Of course, the original queue length hazard problem still had to be solved, but as it turned out that problem had to be solved anyway.

   This change may require the modification of simulation models, because the queue module parameter assignments (referring to the old module positions) may have no effect any more. This change can break existing simulations silently producing different results.

2. Network nodes

   The addition of Time-Sensitive Networking features required to further extend the network node architecture by adding a separate bridging layer compound module between the L2 and L3 layers. This new module is optional and it can be present in both Ethernet switches and standard hosts.

   The VLAN policy module has been moved into the new bridging layer in order to correctly combine with the TSN stream features.

   This change requires updating the VLAN policy module parameter assignments, otherwise simulations may silently produce different results.

3. Packet filter expressions

   Several INET modules (packet filters, packet classifiers, packet schedulers, various visualizers, etc.) use packet filter expressions to differentiate packets. In earlier INET versions, the packet filter expressions were limited to only access certain parts of the packet: name, length, kind, one protocol header at a time. Perhaps the most important such limitation was that it was not really possible to combine conditions for different protocol headers.

   The new packet filter expression syntax is more general while it retains the often useful simple pattern matching mechanism for packet names. The generic NED expression syntax supports the more complicated cases, where filtering for packet content and packet meta-data is needed. It also allows the combination of conditions for different protocol headers that was not possible before.

   This change may require the modification of simulation models, because packet filter expressions are not backward compatible. This change can break existing simulations silently producing different results.

   The User's Guide contains a separate chapter describing the packet filter expressions with several examples.

4. Signals and statistics

   Several signals and statistics have been renamed and several others are split into multiple different ones. This change was necessary in order to have a more coherent naming and also to have more fine-grained results. The most important affected modules are the flow measurement recorder and the queueing model elements. See the ChangeLog file under the src folder for more details.

   This change may require the modification of analysis files, because the results may be different. This change can break existing analysis files silently producing different diagrams.

Notable backward compatible changes are the following:

1. Time-Sensitive Networking

   Several new modules have been added to provide new features of Time-Sensitive Networking.

   An existing implementation of the gPTP time synchronization protocol has been ported and merged into the INET framework. The protocol has been extended with the support of multiple time synchronization domains. The clock model has been extended to allow changing the active time domain to simulate failover. Please note that the actual mechanism that detects the time synchronization failure is not yet provided, so right now only manual failover can be simulated.

   The new traffic shaping feature provides modules for time-aware shaping, credit-based shaping, asynchronous shaping, and also various combinations of them. These modules are usually part of the network interfaces in the complex queueing mechanism of Time-Sensitive Networking.

   The per-stream filtering feature provides modules for token-bucket-based traffic metering, transmission eligibility time calculation, and a form of statistical traffic metering. These modules are usually part of the ingress traffic filter of the bridging layer.

   The frame replication and elimination feature provides modules for stream identification, stream splitting/merging, and stream encoding/decoding as part of the bridging layer.

   All of the above TSN features are described in detail in the User's Guide and the respective NED files. Besides, there are several new showcases that demonstrate the individual TSN features and a few combinations.

2. Ethernet model

   The old Ethernet (non-TSN) network interface infrastructure has been changed.

   The FCS protocol header insertion has been moved from the Ethernet MAC layer module to the Ethernet protocol layer module. The Ethernet protocol layer was already separated from the network interface and moved to separate module in network nodes in the previous INET version. This change makes it possible to use the old and the new TSN capable Ethernet models interchangeably.

3. Link-layer network-wide automatic configuration

   Several new network-wide automatic configurator modules have been added.

   One such network configurator module configures all MAC address tables (aka. MAC forwarding information databases) automatically in all Ethernet switches by discovering the network topology and finding the shortest paths between all network node pairs. This configurator can be used instead of manually configuring the Ethernet switches or instead of using an automatic spanning tree protocol such as STP or RSTP.

   There are several newly added gate scheduling configurators. They can configure the gate schedules of time-aware shapers for all traffic categories in all network interfaces of all network nodes. The resulting schedules are such that the required end-to-end latency and jitter limits are met for all configured streams. The following gate scheduling configurators are available:

   • simple eager configurator
   • Z3 SAT-solver-based configurator (requires installation of external library)
   • TSNsched-based configurator (requires installation of external tool)

   Another network level configurator that is used in Time-Sensitive Networking is the stream redundancy configurator. This module configures the stream merger and stream splitter modules in all network nodes such that all redundant traffic paths are used. The redundant streams make the network resilient to various node and/or link failures.

   Finally, there is the so called failure protection configurator that is used in Time-Sensitive Networking. This module configures the network using the stream redundancy, and optionally the gate scheduling configurators, to meet the complex node and/or link failure protection requirements of all traffic streams by figuring out the necessary redundant paths.

4. Processing delay

   A simple packet processing delay mechanism has been added to the TSN network interface and also to the bridging layer. This allows one to simulate a very simple packet processing delay for incoming and outgoing packets, and also for packets that are forwarded by the bridging layer.

5. Queueing model and protocol elements

   The queueing model have been extended with various token bucket meters and classifiers. The model also allows one to create chained token buckets where the overflowing tokens go to another bucket. Meters simply attach meta data to packets while classifiers push packets to different gates, both based on the state of the token buckets. These modules are currently used in TSN per-stream traffic filtering.

   Several new generic protocol support elements have been added. There are several new modules, currently used in TSN frame replication, for stream identification, stream spli...

INET 4.3.9

Compatibility fixes for OMNeT++ 6.0.
(Preview and RC versions are NOT supported.)

• voipstream: use libswresample instead of libavresample (backported from master)
• fixed #745: AckingMac segfaults on printing packet in handleUpperPacket()
• RoutingTableRecorder: bugfix: routingLogFile was closed and destroyed during cleanup, however it must be destroyed only in the destructor.