WHATSNEW

Recent changes in the INET Framework
====================================

INET-4.7.x (in development)
---------------------------

Notable backward incompatible changes are the following:

1. IEEE 802.11 rate control per receiver

   IEEE 802.11 rate control now selects and adapts the transmission rate separately for each peer a station transmits to. The rate controls previously kept a single set of adaptive state per module, so the feedback of all peers was blended into one rate.

   To make this possible, the getRate() method of the IRateControl C++ interface, implemented by AarfRateControl and OnoeRateControl, now takes the MAC address of the receiver. This change requires the modification of rate control models implemented outside INET, which no longer compile until their getRate() is given the new argument. Simulation models that only configure a rate control are unaffected.

   Rate selection no longer consults the rate control for group-addressed frames, which are never acknowledged and so could never have their rate corrected by feedback. They now take a mandatory rate, as they already did when no rate control was configured.

   These changes may change the statistical results of simulations that use an adaptive rate control, either where a station transmits to several peers or where it sends group-addressed traffic.

2. IEEE 802.11 wire and reception corrections

   QoS Control fields now use the standard bit positions. Non-QoS Data no longer aliases the QoS TID-0 duplicate cache. OFDM radios generate and check SIGNAL parity and reject undefined RATE codes; HR/DSSS and ERP transmissions carry their specific PHY protocol identities.

   AP beacon intervals are rounded down to whole 1024-us TUs for both target scheduling and advertisement (100ms becomes 99.328ms). Configured intervals must be between 1 and 65535 TUs. Beacon and Probe Response frames now encode the DSSS Current Channel for 2.4 GHz operation. Their channelNumber field is a standard channel number, with -1 for an absent element, rather than an internal channel index. Radio channel parameters and scan results remain internal indices. Custom frame producers should follow the migration guide.

   The mesh no-forwarding-information reason code is corrected from 60 to 62. These corrections change affected packet bytes and may change Wi-Fi simulation trajectories and fingerprints.

   Noncompliant layered OFDM retains its configured mode and RATE-0 placeholder; SIGNAL parity is checked in both compliant and noncompliant operation.

3. UDP no longer reports a received datagram twice

   The Udp module emitted packetReceivedFromLower a second time for every datagram it received from the network layer. Its base class, LayeredProtocolBase, already emits the signal before it calls handleLowerPacket, and Udp emitted it again in processUDPPacket. Every other protocol module emits it once.

   No statistic changes, because Udp.ned declares the signal and sources no statistic from it. Code that subscribes to the signal on a UDP module is affected: it now runs once per datagram instead of twice, so a listener that counted arrivals or summed bytes reported twice the true value and now reports the true one.

4. Resending accepts the packets that a producer offers

   The canPushPacket() method of the Resending protocol element tested its packet argument instead of the packet that the module holds, so it refused every packet that a producer asked about. An active producer that asks before it pushes, for example a PacketServer after a queue, therefore never passed a packet to Resending. Resending now accepts a packet whenever it holds none, as its canPushSomePacket() method already did.

   This changes the results of simulations that feed Resending from such a producer. Inside INET, the client in the Network6 and Network7 steps of tutorials/protocol now sends its packet; before, it sent none.

5. An unrecognized ICMP or ICMPv6 type is discarded, not thrown

   Icmp::processIcmpMessage and the ICMPv6 type switch each had a default branch for a message type they do not know, and each branch threw a cRuntimeError. Any peer could therefore end a simulation with one packet.

   RFC 1122 section 3.2.2 and RFC 4443 section 2.4(b) both require a silent discard. Both branches now emit packetDropped and delete the packet. A simulation that used to stop with "Unknown ICMP type" carries on.

   No baseline moves. A scenario that reached either branch aborted, so it cannot be in a passing fingerprint or statistical baseline.

6. IPv6 reassembly writes the payload length of the reassembled datagram

   Ipv6FragBuf::addFragment rebuilt the datagram from the base header of the first fragment and left its Payload Length field untouched, so the field described that fragment and not the datagram.

   Where the field exceeded the reassembled data, Ipv6::decapsulate asserted and the run stopped. Where it fell short, which is the ordinary two-fragment case, the same function truncated the datagram silently to the first fragment's length. Every IPv6 reassembly was affected. The field now counts every octet after the base header, extension headers included, as RFC 8200 section 3 requires.

   The same function also erased a stale end() iterator when one fragment completed a datagram, which aborted the run on an atomic fragment.

   Simulations that reassemble IPv6 fragments deliver whole datagrams now, so their trajectories and fingerprints may change.

7. ICMPv6 drops an error report for a protocol nothing registered

   Icmpv6 handed the error indication up to the protocol the quoted datagram names without asking whether anything on the node had registered it. The MessageDispatcher then knew no route and stopped the run, so any node could be halted by an ICMPv6 error about a protocol it does not run.

   Icmpv6 already kept the set of registered transport protocols and never read it. It reads it now and drops the report, as Icmp has always done for IPv4.

8. No ICMP or ICMPv6 error about a link-layer broadcast or multicast

   Icmp::maySendErrorMessage and Icmpv6::validateDatagramPromptingError each suppressed an error report for four conditions, and every condition read an IP address. RFC 1122 section 3.2.2 and RFC 4443 section 2.4(e) also forbid a report about a datagram that arrived in a link-layer broadcast or multicast frame, which no IP address records.

   Both functions read the MacAddressInd tag of the arriving frame now. A node that receives a unicast-addressed datagram inside a broadcast frame, for a closed port or an unknown protocol, stays silent instead of answering the address in the source field.

   Simulations where that happens send fewer ICMP messages, so their trajectories and fingerprints may change.

9. IPv6 fills in two length fields it used to leave wrong

   A Packet Too Big report carried an MTU of zero. Icmpv6::sendErrorMessage took no MTU and handed createPacketTooBigMsg a literal 0, under a bare "TODO implement MTU support". It takes one now, and Ipv6 passes the MTU it has already read from the outgoing interface two lines above the call, as RFC 4443 section 3.2 requires. A source that receives the report can act on it.

   Every fragment of a fragmented datagram carried the Payload Length of the whole datagram, because Ipv6::fragmentAndSend builds each fragment from a copy of the base header. Each fragment now carries its own: the fragment header plus that fragment's share.

   Simulations that fragment IPv6 datagrams or report a too-big packet put different bytes on the wire, so their fingerprints may change.

10. IPv4 verifies the header checksum, and reassembly reads the protocol

   Ipv4 dropped a datagram whose header checksum failed only when the header was also structurally incorrect: the guard read "!isCorrect() && !verifyChecksum()" and an AND short-circuits, so a well-formed header never reached the checksum test and a wrong checksum was accepted. The guard is an OR now, which is what RFC 1122 section 3.2.1.2 requires.

   Ipv4FragBuf::Key, the reassembly key, carried three of the four fields RFC 791 names: source, destination and identification, but not the protocol. Fragments of two datagrams that shared an identification but used different protocols reassembled into each other. The key carries the protocol now.

   Simulations with header bit errors drop more datagrams than before, and simulations that fragment two protocols at once reassemble them apart, so fingerprints for those scenarios may change.

11. An ARP packet a host cannot process is discarded, not thrown

    Arp::processArpPacket stopped the run in two places a neighbour controls. Its opcode switch threw on any operation the model does not implement, and RFC 5494 section 3 makes 24 and 25 legal values a neighbour may put on a link. And it peeked the packet with the default flags, which turns an incorrect chunk into an error; the serializer marks a packet incorrect when its hardware space is not Ethernet or its protocol space is not IPv4, so nothing ever read that mark.

    Both now end processing, as RFC 826 states: the unknown opcode breaks out of the switch after the table step, and the unsupported space is dropped with a packetDropped signal. The two RARP branches still throw, which the model means as a statement that it does not implement RARP.

12. TCP takes its first round-trip measurement as RFC 6298 states

    rttMeasurementComplete folded the first measurement into the recurrence of RFC 6298 section 2.3, starting from srtt = 0 and rttvar = 3/4. The first smoothed value was therefore one eighth of the measurement and the first timeout described the initial guess rather than the path.

    Section 2.2 gives the first measurement a case of its own: SRTT = R and RTTVAR = R/2. The estimator now does that, and a new rttMeasured flag in the algorithm state tells the two cases apart.

    Every TCP connection's early retransmission timeout changes, so trajectories and fingerprints of TCP simulations move with it.

13. QUIC closes the connection on an unknown frame type, and a server pads its Initial datagram

    A frame of a type the model does not know threw a cRuntimeError, so any peer could stop a run with one frame. RFC 9000 section 12.4 makes it a connection error of type FRAME_ENCODING_ERROR, and the model now sends CONNECTION_CLOSE with that code. Two further stops sat behind it: the frame loop read on past the error into bytes that are no frame header, and the datagram loop then read those bytes as a packet header. Both stop when a connection error is raised.

    PacketBuilder::buildServerInitialPacket did not pad. RFC 9000 section 14.1 requires a server to expand a datagram carrying an ack-eliciting Initial packet to at least 1200 octets, which the client's builder has always done.

14. DHCP corrects seven defects in its client and server

    The client drew a new transaction identifier for every DHCPREQUEST, so a request never carried the identifier of the offer it answered, against RFC 2131 section 4.4.1. It keeps the identifier of the exchange now, and a new transaction draws its own.

    The server wrote three field values it had no right to write. It put the gateway address into the giaddr of a DHCPOFFER, where RFC 2131 table 3 wants the giaddr of the client's DHCPDISCOVER; it put the leased address into the ciaddr of a DHCPACK, where the table allows only the client's ciaddr or zero; and it wrote a constant false into the flags of every reply, where the table wants the flags of the message it answers. It also returned a domain name server option holding 0.0.0.0, because nothing in the model ever assigns that field.

    The server stayed silent for a DHCPREQUEST naming an address of a foreign subnet, because it asked its lease table before it asked about the subnet and a foreign address is in no table. RFC 2131 section 4.3.2 wants a DHCPNAK.

    The client's retransmission delay was a constant 60 seconds, and it never repeated a DHCPREQUEST at all: it abandoned the transaction at the first timeout. RFC 2131 section 4.1 asks for a randomized exponential backoff, 4 seconds doubling to 64, and section 3.1 asks for the request to be repeated. Both are there now, for the initial exchange only: RENEWING and REBINDING keep the schedule of section 4.4.5.

    DHCP exchanges now take different times and put different bytes on the wire, so trajectories and fingerprints of simulations that use DHCP move.

15. A DHCP client checks the granted address before it takes it

    RFC 2131 section 4.4.1 asks a client to check that the address it was granted is not already in use, and RFC 5227 section 2.1.1 makes that check an ARP Probe. The client now sends one, waits probeWait (1s by default; 0s turns the check off), and takes the address only if nobody answers. If somebody does, it sends a DHCPDECLINE and starts again. It probes only an address it is about to start using, after REQUESTING or REBOOTING, and only on a link that uses ARP.

    Three of the four pieces this needed were already written and unreachable. Arp::sendArpProbe had no caller, DhcpClient::sendDecline had no caller, and Arp::processArpPacket threw "wrong ARP packet: source IPv4 address is empty" on the very packet a probe is, so a neighbour's lawful probe stopped the run. An all-zero sender protocol address marks a probe: it claims nothing, so the table steps are skipped for it and the target question still gets its answer.

    Arp gained an arpAddressConflictDetected signal. A reply to a probe is addressed to the all-zero sender address, so the target question cannot recognize it; Arp remembers what it is probing and matches the reply by its sender protocol address instead.

    IArp gained a pure virtual sendArpProbe, which DhcpClient calls. An IArp implementation outside INET must override it; the migration guide says how. GlobalArp overrides it with an empty body, because it has nobody to ask.

    DhcpClient gained an arpModule parameter and a probeWait parameter. DHCPDECLINE now carries the server identifier, which RFC 2131 table 5 requires.

    DhcpServer marks a declined address unavailable, which RFC 2131 section 4.3.3 makes a MUST. Without it the server offered the same address again and the client declined again for the whole run.

    Every DHCP client now spends probeWait between the acknowledgement and taking the address. The lease timers T1 and T2 are armed when the acknowledgement arrives, so renewal timing does not move; traffic from the client starts one probeWait later.

16. IEEE 802.11 management recovery belongs to each EDCAF

   Management failures and completion now update the contention window and retry state of the affected access category. Previously the shared recovery procedure changed the best-effort window even for voice management frames.

   The hcf.edca.mgmtAndNonQoSRecoveryProcedure module moves beneath each edcaf[i], and its C++ getter moves from Edca to Edcaf. Update configuration, signal subscriptions and result paths as described in the migration guide. Management-recovery trajectories may change, including Block Ack agreement negotiation. The MacQosWithBlockAck example fingerprints are updated; the QoS and NonQos showcase fingerprint controls remain unchanged.

17. IEEE 802.11 PHY mode properties for response-rate selection

   The physical layer (PHY) mode interface now exposes the mode family, legacy preamble type, and non-HT reference rate. Custom rate selectors can query these properties without a dependency on a concrete mode class. HT means High Throughput; VHT means Very High Throughput. The reference rate for HT and VHT modes depends on the modulation and code rate of stream 1. An unsupported reference-rate mapping returns bps(NaN), where NaN means not a number.

   IIeee80211Mode gains three pure virtual methods: getModulationClass(), getLegacyPreambleType(), and getNonHtReferenceRate(). Direct implementations outside INET must implement these methods before they compile again. Ieee80211ModeBase supplies default unknown values for custom subclasses. The migration guide explains the return values and required overrides.

18. IEEE 802.11 radio commands wait for an accepted frame

   Tx is the component that transmits frames for medium access control (MAC). Radio reconfiguration now waits until Tx completes an accepted transmission. This includes the short interframe space (SIFS) before a response. The MAC previously used only the medium state, which cannot identify that wait.

   For example, a radio command arrives while Tx waits to transmit an acknowledgment (ACK) frame. The MAC keeps the command until the ACK completes. This prevents radio reconfiguration before the accepted response completes. The change affects event order and the event fingerprints of IEEE 802.11 simulations.

   Custom implementations of ITx must implement hasTransmission() before they compile again. The method identifies both the wait before transmission and the transmission itself. The migration guide explains the return values and the order of the completion callback.

19. IEEE 802.11 recipient responses do not extend their local NAV

   Tx requires an explicit local NAV choice in both transmitFrame() overloads. The NAV records a reservation of the medium. Custom C++ implementations and callers must add updateLocalNav. DCF holder frames use true. HCF holder frames and recipient responses use false. The migration guide supplies the signatures and completion rules.

   CTS, ACK, and Basic Block Ack responses retain their duration fields without extending the recipient's local NAV. Received reservations still control channel access. For example, a recipient can answer another RTS from the same holder when its own previous CTS would otherwise leave the medium busy.

   HCF clamps response durations to zero and applies ceiling to whole microseconds before transmission. These shared changes can change Wi-Fi simulation results.

20. Every transmission and reception in progress of a radio

   IRadio gained getTransmissionsInProgress() and getReceptionsInProgress(), which return every transmission the radio is transmitting and every reception it is attempting, in no particular order. ReceiverBase and the canvas visualizers use them instead of getTransmissionInProgress() and getReceptionInProgress(), so that they also work for a radio that has several signals in progress at once (see the next item). For Radio, NoiseSource and ShortcutRadio, which have at most one in each direction, the vectors hold at most one element, and nothing else changes.

   This change requires the modification of C++ code that implements IRadio without deriving from Radio: the two methods are pure virtual.

21. Radio: concurrent transmissions and receptions

   Radio can now transmit any number of signals at the same time, and attempt any number of receptions at the same time, as a technology with concurrent per-user transmissions (e.g. a cellular base station) needs. Both are allowed by new Radio parameters, allowConcurrentTransmissions and allowConcurrentReceptions, which default to false. With allowConcurrentReceptions set, every reception the receiver's computeIsReceptionAttempted() accepts is attempted alongside the ones in progress; the receivers shipped with INET attempt one reception at a time either way, so the switch only matters with a receiver that attempts more.

   The behavior with the defaults is unchanged, but the C++ API of Radio subclasses changed: the protected receptionTimer and transmissionTimer members were replaced by the attemptedReceptionTimers and transmissionTimers vectors, and continueTransmission(), endTransmission() and abortTransmission() take the transmission timer as an argument. A subclass that dropped the attempted reception on a reconfiguration by resetting receptionTimer calls abandonAttemptedReceptions() instead. getTransmissionInProgress(), getReceptionInProgress(), getTransmittedSignalPart() and getReceivedSignalPart() answer as before while at most one signal is in progress in their direction, and throw an error while several are. A model that relies on them, such as the StateBasedEpEnergyConsumer and StateBasedCcEnergyConsumer energy consumers, therefore cannot be used with a radio that has several signals in progress at once.

   This change requires the modification of C++ code that derives from Radio and accesses these members or overrides these methods.

22. Interference for a listening of the caller's making

   IRadioMedium gained computeInterference(receiver, listening), formerly a protected member of RadioMedium: the background noise plus the receptions, at the receiver, of the transmissions on the medium that overlap the listening, for a listening that need not belong to any transmission. The result is not cached, but the receptions in it come from the medium's reception cache: the ones not computed yet are computed at the call, and draw their random numbers, if any, then. Together with the propagation, the receiver's createListening() and the analog model, it lets a radio compute a hypothetical SNIR (e.g. for link-quality estimation) from public API.

   This change requires the modification of C++ code that implements IRadioMedium without deriving from RadioMedium.

23. IEEE 802.11 single protection and shared TXNAV

   HCF now checks complete continuation costs under single protection with Block Ack support disabled. Before the next SIFS, the exchange cost must be strictly less than remaining TXNAV. The initial SIFS plus exchange cost must fit the positive TXOP limit. This separation permits bursts whose preceding ACK's propagation delay consumes part of the initial SIFS budget. For example, a 238 us exchange proceeds with 246.67 us TXNAV and sufficient TXOP time, after 10 us SIFS.

   A refused frame remains available for a fresh grant without a retry increment or failed-rate feedback. HCF retains the admitted DATA mode through RTS/CTS. Forecasts preserve the retained successor's mode and ACK policy.

   When the next exchange needs RTS/CTS, the preceding field's successor term contains RTS airtime, one SIFS, and CTS airtime. It excludes the protected DATA and its response. The complete RTS/CTS/DATA/response cost exceeds the remaining TXNAV with unchanged estimates. Single protection therefore refuses that continuation before RTS.

   For example, after DATA A and its ACK, queued DATA B needs RTS/CTS. B waits for a fresh grant after TXNAV expires. An initial exchange can still use RTS/CTS.

   The first exchange retains a compatibility fallback, including under an insufficient positive limit. TXOP-based fragmentation remains unsupported. A zero limit permits no additional exchange. Block Ack support disables the new admission check even without an agreement. Multiple protection retains its separate admission policy.

   Rx now owns shared TXNAV separately from received NAV. Successful holder frames replace TXNAV from their PPDU end and encoded Duration/ID. TXNAV persists after TXOP end and blocks contention, but it does not itself prevent an eligible CTS response. DCF retains its local NAV behavior.

   HCF also blocks local contention through its active sequence. This prevents a second grant during an initial ACK wait before successful TXNAV exists. Normal AIFS and backoff follow channel release.

   Single protection now excludes the current ACK estimate for group management and non-QoS DATA, with Block Ack support enabled or disabled. With support enabled, the legacy forecast can still reserve an ineligible group successor.

   TxOpFs publishes the ACK policy before RTS. If Block Ack replaces a stale Normal Ack policy, the single protection RTS field omits the unnecessary ACK and its SIFS. These field and contention changes can change Wi-Fi simulation results and fingerprints. The separate expiry event and corrected sequence observations can also change fingerprints.

   Custom IRx implementations need the TXNAV operations. Sequence callbacks need the start notification and Boolean submission result. Custom ACK policies must not depend on HCF's removed second policy query. See the migration guide.

24. The distance form of the path loss is computeDistancePathLoss()

   IPathLoss::computePathLoss(propagationSpeed, frequency, distance) was renamed to computeDistancePathLoss(), so that it is no longer an overload of the method that computes the path loss of a reception (see the next item): a model that overrode one of the overloads hid the other. Its documentation now states that the value is independent of the transmitter and the receiver, and may be NaN when the model cannot tell the loss from the distance alone (TwoRayInterference).

   This change requires the modification of C++ code that implements or calls computePathLoss(propagationSpeed, frequency, distance): every path loss model derived from PathLossBase overrides it.

25. The path loss of a reception knows its receiver

   IPathLoss::computePathLoss(transmission, arrival) was replaced by computeReceptionPathLoss(receiverRadio, transmission, arrival). It returns an IReceptionPathLoss, the path loss of that one reception, whose computePathLoss(frequency) gives the loss factor at any frequency, the way IAntenna::getGain() returns an IAntennaGain. Together with the transmission's transmitter radio, the receiver radio identifies the link, so a path loss can now keep per-link state (for example a shadowing that is correlated over distance). Both medium analog models call it once per reception: ScalarMediumAnalogModel evaluates the result at the center frequency, DimensionalMediumAnalogModel across the band, in place of the computeDistancePathLoss() it called before. A path loss with per-link state resolves that state in the call, and the returned object holds values only, so the value of a reception does not depend on when or how often the dimensional model evaluates it. The PathLossBase default evaluates computeDistancePathLoss() for the link's distance, so the results of models that only implement that form are unchanged. The FrequencyDependentAttenuationFunction constructor takes the reception's path loss as its second argument.

   TwoRayGroundReflection and TwoRayInterference now take the geometry of the link into account under DimensionalMediumAnalogModel too: before, the former acted as FreeSpacePathLoss there, and the latter returned NaN.

   This change requires the modification of C++ code that implements or calls computePathLoss(transmission, arrival), or constructs FrequencyDependentAttenuationFunction objects.

26. MPLS follows the TTL rules of RFC 3032

   The TTL field of every label stack entry was 0. A pushed entry now copies the TTL of the entry below it, or of the IPv4 header when it is the first label, and each LSR forwards a labeled packet with the incoming TTL minus one, as RFC 3032 section 2.4 and the Uniform Model of RFC 3443 state.

   The IPv4 TTL also counts the LSRs now. The ingress decrements it before it labels a datagram, and leaves a datagram with TTL 1 to IPv4, which reports it; a pop that empties the label stack writes the outgoing TTL into the IPv4 header. Before, a datagram left an LSP with the TTL it had at the ingress. An LSR now discards a labeled packet whose outgoing TTL is zero, with a packetDropped signal; before, no LSR looked at the TTL.

27. MPLS works on Ethernet links

   An MPLS router with an Ethernet interface stopped the simulation at the first ARP packet, because the MPLS module threw on every protocol other than MPLS and IPv4. Such a packet now goes to the network layer. A labeled packet now also goes through the Ethernet encapsulation, with the ethertype 8847 hex. A LIB entry holds no next hop, so the frame goes to the broadcast address of the link; on a point-to-point link that is the one neighbor.

28. MPLS knows the IPv4 Explicit NULL and the Implicit NULL labels

   An LSR now pops the label 0 at the bottom of the stack with no binding and forwards the datagram by its IPv4 header, and pops the stack where a swap would give the label 3, as RFC 3032 section 2.1 states. The LIB accepts these values as outgoing labels; before, a debug build refused the label 0, and the label 3 went onto the wire. The LIB now allocates labels from 16, after the reserved values; before, RSVP-TE and LDP got labels from 1.

29. MPLS fragments a labeled datagram that is too big for the next link

   An LSR sent a labeled packet of any length, also onto a link with a smaller MTU. It now compares the length with the MTU of the outgoing interface, as RFC 3032 section 3 states. It fragments an IPv4 datagram with the DF bit clear, and each fragment carries the label stack; for a datagram with the DF bit set, it sends an ICMP Destination Unreachable message whose Next-Hop MTU is the MTU minus the label stack. The new parameter icmpModule of Mpls names the ICMP module, by default the one of the node's IPv4 layer.

30. IPsec corrections to the AH and ESP packets

   The first packet of an SA now carries the Sequence Number 1, as RFC 4302 and RFC 4303 state; before, it carried 0. The C++ method SecurityAssociation::getAndIncSeqNum() is now incrementAndGetSeqNum(), and returns the incremented value.

   The AH header now has the layout of RFC 4302: its Payload Length holds the length of the header in 32-bit words minus 2 (before, 0), and the ICV field ends the header, before the payload (before, the ICV followed the payload). In IPv6 the ICV field has the padding that makes the header a multiple of 8 octets, so an AH packet over IPv6 is 4 octets longer with a 16-octet ICV. The payload of AH is no longer an EncryptedChunk, because AH does not encrypt, and the AH dissector reads the new layout.

   The padding of an ESP packet now holds the octets 1, 2, 3 and so on, as RFC 4303 section 2.4 states; before, every octet held the default 63 of a ByteCountChunk.

   After AH or ESP processing, the receiver now checks that the packet matches the selectors of the SA that protected it, and discards it if not (RFC 4301 section 5.2). Before, an SA accepted every packet with its SPI, so a sender could reach any port of the receiver through one SA.

   A packet that matches a PROTECT entry, and no SA of it, is now discarded (RFC 4301 section 5.1); before, it left the host in clear.

   One policy can now protect a packet with ESP and AH together. The new Protection element of a SecurityAssociation overrides the Protection of its SecurityPolicy, so an ESP policy can hold an AH SA as well. The sender applies ESP first and AH around it, whatever the order of the SAs, and the receiver processes the ESP header that follows an AH header. Before, the documentation named a Protection AH_ESP that the configuration refused.

   An SA can now have a hard lifetime (RFC 4301 section 4.4.2.1): the new elements HardLifetimeSeconds and HardLifetimeBytes of a SecurityAssociation or of its SecurityPolicy. With no key management to replace it, an SA whose lifetime has ended is not used any more, and its packets are discarded.

   An SA can now have a set of DSCP values, the new DSCP element of a SecurityAssociation (RFC 4301 section 4.4.2.1). Of the SAs of one policy, the sender uses the first whose set holds the DSCP of the packet, so that classes of traffic can have SAs of their own. Before, the first matching SA carried every packet.

   An outbound ESP SA can now send dummy packets (RFC 4303 section 2.6), with the new DummyPacketInterval element of a SecurityAssociation: ESP packets with Next Header 59 and an empty payload, to the peer of the last packet that the SA protected. The receiver discards them without an error. For this, the IPsec module has the new gates ipIn and ipOut, which the IPv4 and IPv6 network layers connect to their dispatcher.

31. IEEE 802.11 response queries require an explicit caller role

   Sender estimates now query the recipient's HT capabilities instead of the sender's own peer address. This correction can change response reservations, timeout estimates, and TXOP admission in existing HT simulations.

   External IRateSelection and IQosRateSelection implementations and callers must add ResponseQueryRole to their response queries. Use PREDICT for sender estimates. Use RESPOND for recipient responses. The migration guide supplies the signatures and links to the prediction limits.

32. IEEE 802.11 ac interfaces also expose current HT support

   ac interfaces now use existing HT capability and management support alongside VHT and legacy OFDM. Advertised and negotiated HT operation remains limited to 20 MHz and four spatial streams. Added HT modes can change ACK/CTS candidates and adaptive rate steps, including steps between equal nominal rates.

   ac APs require a band with standard channel conversion, including simplified management. The supplied ac configurations now use "5 GHz (mapped 20 MHz)" at 5180 MHz. This frequency change can affect propagation results and fingerprints. See the migration guide for configuration changes and the IEEE 802.11 user guide for radio requirements and model limits.

33. IEEE 802.11 Block Ack recipients preserve delivery order

   Basic Block Ack recipients now count sequence positions as buffer capacity. All fragments of one MSDU occupy one position. A one-position buffer can therefore accept both fragments and deliver the complete MSDU.

   DATA that fills a gap releases all consecutive complete units in the same operation. DATA beyond the window moves the window and releases older complete units. A valid BAR for an accepted agreement also creates and advances an empty reorder record before DATA arrives. Delivery follows cyclic sequence order, including 4095 before 0. These repairs can change delivery times, simulation results, and fingerprints in affected Block Ack scenarios.

   Custom C++ consumers must use the ordered ReleasedFrames return type from BlockAckReordering. Preserve its order through reassembly and deaggregation. The migration guide gives the required change. Basic frame formats and fragment bitmaps remain available.

   The protected getEarliestCompleteMsduOrAMsduIfExists() helper remains available for one release but is deprecated. External subclasses retain its lookup behavior during that period. Delivery code must use the ordered release results instead. The migration guide explains the different ownership contracts.

34. TCP takes the defaults of the RFCs, and gains LinuxTcp and LegacyTcp

   The TCP model was reworked. A flavour is now a choice of congestion control (ITcpCongestionControl) and of loss recovery (ITcpRecovery). The model gained CUBIC (TcpCubic), RACK-TLP loss detection, Proportional Rate Reduction, F-RTO, the undo of a spurious loss, Accurate ECN, TCP Fast Open, keepalive probes, the path MTU search of RFC 4821, and many parameters that select a behavior of Linux. The documentation of the Tcp module lists each RFC, what the model implements, and where it departs from the RFC.

   The defaults of Tcp now follow the RFCs. This changes each simulation that uses TCP without setting these parameters (INET 4.7 -> now):

     sackSupport              false             -> true
     timestampSupport         false             -> true
     windowScalingSupport     false             -> true
     delayedAcksEnabled       false             -> true
     limitedTransmitEnabled   false             -> true
     advertisedWindow         14 * this.mss     -> 65535
     mss                      536               -> -1 (1460 for IPv4, 1440
                                                   for IPv6)
     initial window           one segment       -> initialWindow = "rfc3390"
                                                   (RFC 5681 section 3.1)
     tcpAlgorithmClass        "TcpReno"         -> "TcpNewReno"
     initial RTO              3 s               -> initialRto = 1s
     loss detection           three duplicates  -> RACK-TLP (lossDetectionMode,
                                                   tlpEnabled)
     recovery window          halved at once    -> PRR (prrEnabled)
     PSH                      never set         -> on the last buffered segment
                                                   (pushLastBufferedSegment)
     ECN                      off               -> answers a request
                                                   (tcpEcnMode = "passive")
     pmtudEnabled             false             -> true (DF on IPv4 segments)

   The results of TCP simulations differ from INET 4.7 in any case, also because many defects were repaired. To keep the old defaults, select LegacyTcp, which extends Tcp and changes only defaults:

     **.tcp.typename = "LegacyTcp"

   LinuxTcp extends Tcp in the same way, with the defaults of Linux 7.1: CUBIC with the hybrid slow start, an initial window of ten segments, the timers and the delayed ACK of Linux, and the other behaviors of Linux that parameters select. A parameter that the ini file sets takes precedence over the defaults of the selected module.

   Two parameters are deprecated: increasedIWEnabled (use initialWindow = "rfc3390") and ecnWillingness (use tcpEcnMode = "rfc3168"). They still work in this release.

   Two C++ base classes were renamed: TcpBaseAlg is now TcpAlgorithmBase, and TcpTahoeRenoFamily is now TcpClassicAlgorithmBase. The old names remain as deprecated aliases in this release. A TCP algorithm implemented outside INET needs more than the rename, however: the split into congestion control and recovery moved much of the protected interface that a flavour overrides, so such an algorithm must be written against ITcpCongestionControl and ITcpRecovery.

   The connection has the new signals sndMax, delivered and deliveredCe.

35. Packet classifiers answer a query without a change of state

   PacketClassifierBase::classifyPacket() is now a const function. The base class calls it from queries, such as canPushPacket() and canPullPacket(), and again from the operation that moves the packet, so it must not change the state of the module. The base class calls the new function handlePacketClassified() one time for each packet that goes through the module, and one time for each packet stream, before the packet leaves the module. A classifier that keeps state changes it there.

   This change requires the modification of classifiers implemented outside INET, which no longer compile until their classifyPacket() is const. See the migration guide.

   A pull stream through a classifier now classifies its packet one time, at the start of the stream. Before, each call of the stream classified it.

36. A token bucket classifier takes the tokens of a packet one time

   TokenBucketClassifier and MultiTokenBucketClassifier, and the classifiers that extend them in NED (SingleRateTwoColorClassifier, SingleRateThreeColorClassifier and DualRateThreeColorClassifier), removed the tokens of a packet in each query about the packet, and again when the packet went through. For example, a PacketServer asks canPushPacket() before it pushes a packet. In pull mode, each peek removed tokens. The classifier now removes the tokens one time, when the packet goes through. This can change the results of simulations in which a module asks a token bucket classifier about a packet before it pushes the packet.

37. A weighted round-robin classifier moves its round only for a packet

   WrrClassifier moved its round forward in each query about a packet, for example when a module asked canPushPacket() before it pushed the packet. The packets then went to other consumers than the weights state. The classifier now moves its round only when a packet goes through. This can change the results of simulations in which a module asks a WrrClassifier about a packet before it pushes the packet.

38. A dynamic classifier creates a branch only for a packet

   DynamicClassifier creates the branch of a class when the first packet of the class goes through, or when a module asks canPushPacket() about such a packet, because the answer depends on the branch. Before, its other queries created branches too. The classifier now refuses the reverseOrder parameter, because it creates its output gates in the order in which the classes appear. With reverseOrder = true, it created more branches than classes, and it sent packets of different classes into one branch.

39. Packet schedulers answer a query without a change of state

   PacketSchedulerBase::schedulePacket() is now a const function. The base class calls it from queries, such as canPushSomePacket(), and again from the operation that moves the packet, so it must not change the state of the module. The base class calls the new function handlePacketScheduled() one time for each packet that goes through the module, and one time for each packet stream, when the module holds the packet and before the packet leaves the module. A scheduler that keeps state changes it there.

   This change requires the modification of schedulers implemented outside INET, which no longer compile until their schedulePacket() is const. See the migration guide.

40. A label scheduler skips an empty input

   LabelScheduler read the labels of the packet that each input offered, and it crashed when an input had no packet. It now skips an empty input.

41. A packet scheduler offers the packet that it serves

   canPullPacket() of PacketSchedulerBase returned the packet of the first input that had a packet, and pullPacket() served the input that schedulePacket() selected. The two agreed only for a PriorityScheduler without reverseOrder. A module that reads the offered packet before it pulls, such as TokenBasedServer, then acted on another packet than the one it pulled. Now canPullPacket() returns the packet of the input that schedulePacket() selects, and canPullSomePacket() asks whether that input has a packet. This affects WrrScheduler, ContentBasedScheduler, LabelScheduler, PacketScheduler, MarkovScheduler and PriorityScheduler with reverseOrder. The scheduler function of a PacketScheduler must not change any state, because the base class now calls it from queries too. This can change the results of simulations in which a module reads the packet that such a scheduler offers.

42. Packet filters decide one time for each packet

   PacketFilterBase called matchesPacket() and processPacket() again on each call of a push stream, so its verdict could change in the middle of a stream. It now decides at the start of the stream and keeps the verdict for the stream; processPacket() still runs for each packet instance of the stream. The base class calls the new function handlePacketFiltered() one time for each packet that goes through the filter or that the filter drops, and one time for each packet stream. A filter that keeps state, such as a dropper that counts packets, changes that state there, not in matchesPacket(), processPacket() or dropPacket(). See the migration guide.

43. A filter in pull mode drops a packet in its own operations

   In pull mode, PacketFilterBase::canPullPacket(), a query, pulled and dropped each packet of its provider that did not match. The filter now drops such packets when they become available: when its provider reports a packet, and after each pull. canPullPacket() returns the packet of the provider if it matches. This can change the time of a drop in simulations that pull packets through a filter. ReceiveWithLifetime and EligibilityTimeFilter no longer support pull mode, because their verdict about a packet changes with time without an event of the module.

44. An ordinal based dropper counts a streamed packet one time

   OrdinalBasedDropper counted a packet in processPacket() and dropPacket(), which the filter base class calls for each packet instance of a packet stream. So it counted a streamed packet more than one time, and it dropped other packets than its dropsVector names. It now counts each packet one time, in handlePacketFiltered().

45. A stream merger records a streamed packet one time

   StreamMerger recorded the sequence number of a passing packet in processPacket(), which the filter base class calls for each packet instance of a packet stream. It now records the number one time, in handlePacketFiltered().

46. A random early detection dropper draws its random number in advance

   RedDropper updated its average queue length and drew a random number in matchesPacket(), so each query about a packet, such as canPushPacket(), changed the state of the dropper. It now decides with a stored random number, and it updates its state in handlePacketFiltered() when a packet goes through or is dropped; after a decision that used the stored number, it draws the next one. The dropper draws one more random number at initialization. Simulations with a RedDropper therefore give other results, with the same statistical behavior.

47. A statistical rate limiter draws its random number in advance

   StatisticalRateLimiter drew a random number in matchesPacket(), so in pull mode each query, such as canPullPacket(), drew a number and could give another answer. It now decides with a stored random number, and it draws the next one in handlePacketFiltered() after a decision that used the stored one. The limiter draws one more random number at initialization. Simulations with a StatisticalRateLimiter therefore give other results, with the same statistical behavior.

48. IEEE 802.11 QoS DATA lifetime

   HCF now discards QoS DATA when its finite lifetime expires, with Block Ack support enabled or disabled. Each access category uses mac.hcf.edca.edcaf[*].msduLifetime, with a default of 0.512 seconds. The timer starts at MAC acceptance, so DATA can expire in the queue before transmission. Users can select another positive, finite lifetime for congestion and compatibility studies. A-MSDU construction restarts the aggregate timer; fragmentation, retransmission, and ACK-policy changes preserve the applicable deadline. Accepted exchanges retain their DATA until safe completion and permit no later attempt after expiration.

   Congested QoS simulations can transmit newer DATA because older queued or in-progress DATA expires. Recorded trajectories change in the Block Ack fragmentation showcase, the QoS showcase, and the wireless and ad hoc MacQos examples. The approved fingerprint baselines reflect these lifetime changes.

   HCF records lifetime drops separately in packetDropLifetimeExpired. Its count and byte sum separate lifetime disposal from queue overflow and retry-limit disposal. Aggregation with qOsCheck=false still accepts non-QoS or mixed sources. The resulting QoS aggregate starts its own lifetime at construction, even when its sources have no lifetime entries.

49. The algorithm of a TCP connection is its submodule

   Each TCP connection now creates its congestion control algorithm (TcpNewReno, TcpCubic, DcTcp and the others) as its submodule algorithm, for example tcp.conn-3.algorithm, of the NED type that tcpAlgorithmClass names. Each algorithm has a simple module type of the same name in inet.transportlayer.tcp.flavours, which extends the new TcpAlgorithm and holds the parameters of the algorithm. Qtenv shows the algorithm of a running connection with its parameters and its state variables. The connection keeps the timers and the signals of the algorithm, so the results do not change.

   The parameters that only one algorithm reads moved from Tcp to the type of that algorithm, so their ini keys change:

     **.tcp.cubicBeta              -> **.tcp.conn-*.algorithm.beta
     **.tcp.cubicC                 -> **.tcp.conn-*.algorithm.c
     **.tcp.cubicFastConvergence   -> **.tcp.conn-*.algorithm.fastConvergence
     **.tcp.cubicTcpFriendliness   -> **.tcp.conn-*.algorithm.tcpFriendliness
     **.tcp.cubicCntClamp          -> **.tcp.conn-*.algorithm.cntClamp
     **.tcp.cubicDelta             -> **.tcp.conn-*.algorithm.delta
     **.tcp.hystart...             -> **.tcp.conn-*.algorithm.hystart...
     **.tcp.dctcpGamma             -> **.tcp.conn-*.algorithm.g

   dctcpGamma was a parameter of INET 4.7, and Tcp no longer has it. The parameters of CUBIC and HyStart were not in a release. LinuxTcp and LegacyTcp turn HyStart on with a pattern assignment for the algorithms of their connections. TcpVegas has the new parameters alpha, beta and gamma, with the values of its former constants as defaults.

   A TCP algorithm implemented outside INET needs a simple module type that extends TcpAlgorithm, and Define_Module() in place of Register_Class(); without the type, the connection stops with an error. Its initialize() is now initializeAlgorithm(), and the cancelEvent() helper of TcpAlgorithmBase is now cancelTimer(). See the migration guide.

50. A TCP connection setup lasts as long as its SYN retransmissions

   An active open of Tcp no longer fails after 75 s, and a passive open no longer leaves SYN_RCVD after 75 s. The SYN and SYN-ACK retransmissions alone limit the setup (the synRetries parameter, or TcpSocket::setSynRetries() for one connection), as in Linux. With the defaults of Tcp, 12 retransmissions take about 24 minutes; RFC 9293 section 3.8.3 asks for at least 3 minutes (MUST-23). LinuxTcp keeps the 11 s of Linux. Simulations in which a SYN or a SYN-ACK gets no answer for more than 75 s change.

   When the retransmissions run out, the setup now times out: an active open tells the application with TCP_I_TIMED_OUT, as connect() of Linux fails with ETIMEDOUT, and a passive open returns to LISTEN, or closes if it was forked. Before, the connection aborted without an indication to the application, and a listener that does not fork closed.

   The timer that waits for the SEND of a deferred Fast Open SYN is now TcpConnection::deferredSynTimer, with the constant TCP_TIMEOUT_DEFERRED_SYN. See the migration guide.

51. LinuxTcp drops the data of a SYN without Fast Open

   A TCP listener keeps the data of a SYN that carries no Fast Open option and delivers it after the handshake, as RFC 9293 section 3.10.7.2 allows. A Linux listener drops such data, and the client sends it again after the SYN-ACK. The new parameter dropSynData selects the behavior of Linux; LinuxTcp sets it, and Tcp keeps the data. Simulations with LinuxTcp in which a client sends data on a SYN without Fast Open change. The data of a SYN with an invalid Fast Open cookie is dropped in each mode, as RFC 7413 section 4.2.2 asks, as before.

52. Dynamic Right-Sizing of the TCP receive buffer, as Linux

   With windowAutoTuning and a receive buffer (receiveBufferSize), a TCP receiver now grows its buffer in a long transfer as Linux does (Dynamic Right-Sizing). At each read of the application after one receive RTT, the bytes read in that RTT become the receive space when they are more, and the buffer grows to twice the space, more during slow start, up to the new parameter receiveBufferMax (32 MiB, as tcp_rmem[2] of Linux). In the autoRead mode, each delivery to the application is a read. The new parameter receiveBufferLowRtt (1 ms, as tcp_rcvbuf_low_rtt) selects a smaller growth for small RTTs. The receiver estimates the receive RTT as Linux, with and without timestamps, and the status of a connection reports it with the receive space (rcvRtt, rcvSpace of TcpStatusInfo). Simulations that turn windowAutoTuning on with a receive buffer change, and LinuxTcp has a receive buffer by default (entry 53).

53. LinuxTcp has the receive buffer of Linux, and the window scale covers auto-tuning

   LinuxTcp now has a receive buffer of 131072 bytes (receiveBufferSize), the tcp_rmem[1] that Linux gives each socket, so its window auto-tuning and Dynamic Right-Sizing act with its defaults. Before, LinuxTcp set no receive buffer, and its offered window stayed at advertisedWindow. Tcp keeps no receive buffer apart from the window.

   With windowScalingFactor = -1, windowAutoTuning and a receive buffer that SO_RCVBUF does not lock, the window scale now also represents receiveBufferMax, as Linux tcp_select_initial_window() represents tcp_rmem[2]: with the default of 32 MiB, the shift is 10. Before, the shift represented only the window at the time of the SYN: a buffer of 131072 bytes got a shift of 1, and the offered window could not grow above 131070 bytes, although the buffer grew. A buffer that SO_RCVBUF locks keeps the shift of its own window. Simulations with LinuxTcp, and simulations that turn windowAutoTuning on with a receive buffer, change.

54. The out-of-band byte of received TCP urgent data, as Linux

   The new parameter urgentOutOfBand, which LinuxTcp sets, gives the receive side of urgent data of Linux without SO_OOBINLINE: the last byte of urgent data leaves the stream, and a read stops before it. INET does not deliver that byte, which Linux gives to recv(MSG_OOB), and it sends no urgent data. Tcp keeps treating URG-marked bytes as ordinary data. Simulations change only where a peer sends urgent data to LinuxTcp.

55. A sink can pull a packet that it accepts

   IPassivePacketSource has two new methods, canPullPacket(gate, filter) and pullPacket(gate, filter). The filter, an IPacketFilterFunction, is the acceptance condition of the sink. The source answers and pulls as if it held only the packets that the filter matches, and the pull has the effects of a normal pull of that packet. This is the pull counterpart of canPushPacket(packet, gate): a sink can now take a packet behind a packet that it cannot accept at the moment. PassivePacketSource and EmptyPacketSource support the filter. PacketQueue offers the first packet in queue order that the filter matches. PriorityScheduler and WrrScheduler decide as if each input held only the accepted packets, and a filtered pull spends the credit of a WrrScheduler as a normal pull does. A compound queue, such as CompoundPendingQueue, passes the filter to its parts. IPacketQueue has the new method dequeuePacket(filter): it dequeues the packet that dequeuePacket() would dequeue if the queue held only the packets that the filter matches. The base classes of the queueing model throw an error for it, so a module that cannot choose among its packets refuses the filtered call. A class outside INET that implements IPassivePacketSource or IPacketQueue directly no longer compiles until it declares the new methods. See the migration guide. Simulation results do not change.

Notable backward compatible changes are the following:

1. IEEE 802.11 per-station rate statistics

   The datarateChanged signal of the rate controls is now emitted with the name of the receiving station as a named details object, and a new dataratePerStation statistic demultiplexes it into one data rate vector per peer. The datarateSelected signal of Dcf and Hcf is tagged the same way, which also covers fixed and configured rates. The declaration of the aggregate datarateChanged statistic is unchanged and it still ignores the details, but the values it records move: the rate control no longer reports a rate when the mode set changes, and reports one per station when that station is first seen instead.

2. IEEE 802.11 per-receiver configured data frame rates

   RateSelection and QosRateSelection gained a dataFrameBitratePerReceiver parameter, a map from peer interface module path to bitrate, which fixes the rate of originated unicast data frames separately for each peer. It is empty by default, so it changes nothing unless it is configured. The dataFrameBitrate parameter, which fixes one rate for the whole interface, is unchanged.

3. Naming the host owning a MAC address

   A new L3AddressResolver::getHostNameWithMacAddress() method names the host that owns a MAC address, by the host's path relative to the network, and falls back to the MAC address string when no host owns the address.

4. Type-aware field chunk serializers

   FieldsChunkSerializer gained two protected hooks, serializeFields() and deserializeFields(). The deserializeFields() hook receives the concrete chunk type that was requested from ChunkSerializerRegistry, so a serializer that is registered for several chunk types can build the exact requested type. The old hooks, serialize(stream, chunk) and deserialize(stream), are deprecated but still work: they are no longer pure virtual, and the new hooks call them by default. Serializers written against an earlier INET version need no source change. See the migration guide for the new signatures.

5. Region tag removal by type

   The removeTagsWherePresent() method of SharingRegionTagSet removed the region tags of every type in the given range, and not only the tags of the requested type. It now removes only the requested type, as its documentation always stated. The same correction reaches Chunk::removeTagsWherePresent() and Packet::removeRegionTagsWherePresent(), which forward to it. The clearTags() method gained an optional predicate that selects the tags to clear, and clears all of them by default, so its own behavior is unchanged.

   This may change the results of a simulation that removes the region tags of one type while the region tags of another type cover the same range. Inside INET this happens when ResidenceTimeMeasurer ends a measurement: it removed the ResidenceTimeTag and, with it, the FlowTag and the PacketEventTag of the packet. Those two tags now survive the measurement.

6. IEEE 802.11 MIB rate state and notifications

   The Management Information Base (MIB) now stores supported, basic, and operational rate sets for the local station, Basic Service Set (BSS), and individual peers. A rate set distinguishes unknown information from a known empty set. Rate-set setters validate the input before they commit it. A combined BSS and peer update installs both records before one notification.

   The rateStateChanged signal reports a committed rate, High Throughput (HT) capability, or channel-operation change. Its value is true, with no details object. Listeners query the MIB for current state. Equal rate-set updates emit no signal. The migration guide explains state access and listener use.

   Association release and bulk teardown remove both peer HT capabilities and rate sets before one notification. A listener can install replacement peer state from the callback; teardown does not remove that replacement. Direct HT or rate removal still emits its own notification if state changes. Empty teardown emits no signal. Existing configuration parameters stay unchanged.

7. IEEE 802.11 selectable multiple protection in EDCA TXOPs

   EDCA TXOPs support selectable multiple protection. Single protection remains the default. Nominal timing uses the mode set's short interframe space (SIFS) unchanged after the first transmission step. The first step adds no interframe space. Multiple protection stops normally when another exchange cannot use a legal duration field.

   For example, a 200 us PPDU within a 1024 us TXOP advertises 824 us of reservation. A TXOP is a transmission opportunity; a PPDU is one PHY transmission.

   The user guide explains nominal timing, zero-limit estimates, unused reservation time, and support limits. Multiple protection uses shared TXNAV. It does not check a complete exchange against the remaining budget.

8. Radio medium purge without a timer

   RadioMedium has a new transmissionPurgeMode parameter. The default, "timer", removes transmissions that can no longer interfere with a self-message scheduled at the interference end time of the oldest transmission that can still interfere, as before. "onTransmission" removes them whenever a new transmission is added instead, so the medium schedules no events of its own; this keeps the medium out of the event sequence entirely, which matters for a model whose fingerprints must not depend on the medium's bookkeeping. Interference is computed identically in both modes.

   The protected removeNonInterferingTransmissions() of RadioMedium now only removes; it no longer reschedules the timer, which the timer handler does by calling the new scheduleRemoveNonInterferingTransmissionsTimer() after it. A subclass that calls or overrides removeNonInterferingTransmissions() and relied on the rescheduling must call that method itself.

9. Correlated log-normal shadowing

   LogNormalShadowing has a new correlationDistance parameter. By default (NaN) every path loss computation draws a new shadowing value, as before. With a distance, the value is kept per pair of radios, the same in both directions, and drawn again only when either radio has moved farther than that distance from where it was when the value was drawn, which is how shadowing behaves physically. The value is resolved once per reception, so with DimensionalMediumAnalogModel the whole band of a reception has the same shadowing. The values of a radio's links are dropped when the radio is removed from the medium.

10. Log-normal shadowing once per reception

   Without a correlation distance, LogNormalShadowing draws one shadowing value per reception. With DimensionalMediumAnalogModel it drew one per evaluation of the attenuation, so the frequencies of one reception had independent values, and an evaluation repeated later gave a different one. With ScalarMediumAnalogModel, or with the dimensional model attenuating with the center frequency (the default), nothing changes.

11. IEEE 802.11 mapped 5 GHz channel subset

   The new "5 GHz (mapped 20 MHz)" band supplies standard channels 36, 40, 44, and 48 for HT management. The IEEE 802.11 user guide describes its indices, frequencies, and HT40 pair validation. The subset does not enable 40 MHz HT operation or provide a complete regulatory-domain model.

12. IEEE 802.11 MIB state commit operations

   The MIB now supplies combined operations for peer HT state, BSS rates, and peer rates. Each operation completes its mutations before notification. AP cleanup can also clear station and association-ID tables in the same transition. Standalone setters retain their existing behavior. Local records remain available after cleanup.

13. IEEE 802.11 management publishes legacy rate state

   Full and simplified management now populate the existing MIB rate records from local advertisements and accepted associations. Associated-AP Beacons refresh the STA's BSS and peer rates. Peer departure, association loss, and management stop clear the corresponding records. External models can query these records after rateStateChanged notifications. Current built-in rate selectors retain their existing behavior.

   STA teardown clears BSS rates and peer HT and rate state before one notification. Management clears its association snapshot and Beacon timer first. Listeners see complete cleanup, and the local rate record remains available.

   Association and valid associated-AP Beacons commit HT state and rate records before one notification. AP management clears its pending transaction first. STA management sets its Beacon timer first. Listeners can query the complete state from the callback.

   Full AP departure completes the station downgrade before peer cleanup notification. Full AP stop clears station and association-ID tables, peer state, and BSS rates before one notification. Rate publication excludes BSS membership selectors from legacy rate records. Selector-based join checks remain outside this change.

   Management rejects nonfinite numeric rates in abstract frames before ordered-set insertion. Previously, a NaN after a valid rate could escape validation and replace committed records. Malformed rate elements now preserve committed records and emit no rate notification. Wire-decoded rate octets cannot produce these nonfinite values.

14. Explicit historical Basic Block Ack selection

   HCF adds blockAckVariant = "basic" for historical compatibility. Existing Block Ack, TXOP, QoS, and fragmentation demonstrations select it explicitly. Basic remains the default. HCF rejects unknown values and the reserved "compressed" value during initialization until Compressed exchanges exist. These checks also apply when Block Ack support is disabled. Basic originated in IEEE Std 802.11e-2005; IEEE Std 802.11-2024 reserves its type value.

15. IEEE 802.11 retry counters for each receiver

   QoS recovery now keeps separate retry counters for each receiver. Frames with equal TID, sequence number, and fragment number no longer share a counter across receivers. An acknowledgment or retry-limit disposal for one receiver preserves the other receiver's counter. This repair applies before DATA lifetime expiration.

Notable bug fixes are the following:

1. IEEE 802.11 HT modes preserve the requested band and preamble

   The HT mode factory now includes band and preamble format in its cache key. A 5 GHz request after an equivalent 2.4 GHz request therefore receives the requested band and timing. Previously, that request could receive the earlier mode. Identical complete requests still reuse one object.

2. TCP Limited Transmit sends only new data

   With SACK and lossDetectionMode = "dupthresh", the first duplicate ACK of a flight with no more new data retransmitted the first hole: Limited Transmit took its segment from NextSeg(), whose rule 3 returns an old segment. The fast retransmit then sent the hole again, and the receiver reported a D-SACK. Limited Transmit now sends only previously unsent data, as RFC 3042 and step (3.3) of RFC 6675 say, in both loss detection modes. No fingerprint or statistical baseline of INET moves; simulations that select the dupthresh mode with SACK can change.

3. DumbTcp no longer sends an acknowledged FIN again

   The retransmission timer of DumbTcp restarted at each expiry, also when nothing was outstanding, so DumbTcp sent an acknowledged FIN again every 2 seconds until the connection closed; with a peer that does not close, it went on to the end of the simulation. The timer now stops when all data, the FIN included, is acknowledged, as RFC 6298 section 5.2 says. Simulations that select DumbTcp can change.

4. Nagle no longer holds a TCP retransmission

   Nagle's algorithm counted data as unacknowledged up to the highest sequence number sent. After a go-back, after a retransmission timeout or after a SYN-ACK that did not acknowledge the data of a Fast Open SYN, the partial segment at the end is a retransmission, and Nagle held it until the next retransmission timeout. Nagle now holds only new data, as RFC 9293 section 3.7.4 says and as Linux does. Simulations with losses and Nagle on (the default of Tcp and LegacyTcp) can change; 27 fingerprints and 11 statistical results of the INET examples moved. LinuxTcp, with the Nagle variant of Minshall, was not affected in the packetdrill suite.

5. TCP repairs that reach the algorithms of INET 4.7

   A review of all TCP parameters found defects. Most of their repairs concern features that are new in this release (entry 34), but the repairs below also reach the algorithms and the parameters of INET 4.7. Simulations that use them can change; 30 fingerprints and 20 statistical results of the INET examples moved.

   TcpVegas decided once per RTT to grow or to shrink cwnd by one segment, but it applied the step again at each later ACK until the next decision. So in congestion avoidance, cwnd moved by more than one segment per RTT, and alpha and beta did not hold the number of extra segments between them. TcpVegas now applies the step once per RTT, as the Vegas paper and Linux tcp_vegas_cong_avoid() do. TcpVegas and TcpWestwood also ignored initialSsthresh and ended slow start at 64 KiB; now they take initialSsthresh, as the other algorithms do.

   After a retransmission timeout, TcpReno, TcpNewReno and DcTcp restarted slow start with a cwnd of the MSS. With the timestamp option, a segment carries 12 bytes less data, so a segment of 12 bytes went out after the retransmission. The loss window is now one full-sized segment of data, as RFC 5681 section 3.1 says. Also as RFC 5681 says, only the first timeout of a segment sets ssthresh now; the value of these algorithms stays the same, but their ssthresh statistic no longer records it a second time.

   A receiver with delayedAcksEnabled acknowledged at once only after two segments of the length of its own send MSS. When the segments of the peer were shorter, for example after the path MTU discovery of the sender, each ACK waited for the delayed ACK timeout. Now the ACK also goes at once when the unacknowledged data reach 2*RMSS bytes, as RFC 9293 SHLD-19 says. RMSS is the MSS that the receiver announced.

   With windowScalingSupport and an advertisedWindow above 65535, a SYN-ACK wrote the window into its 16-bit field without a limit, so 131072 became 0. The SYN and the SYN-ACK now carry at most 65535, because RFC 7323 section 2.2 says that their window is never scaled.

   A receiver with classic ECN echoed a CE mark only on a pure ACK, and only for the last segment that arrived. A delayed ACK lost the echo when a segment without CE came after the marked one, and data and FIN segments never had ECE. Now each segment that acknowledges has ECE in the echo state, as RFC 3168 section 6.1.3 says.

   Values without a meaning now stop the simulation with an error that names the parameter and its range: an mss below 88, other than -1; a dupthresh or an initialSsthresh below 1; and a gain g of DcTcp (formerly dctcpGamma) that is not in the range 0 < g <= 1. Before, mss = 0 stalled the connection, dupthresh = 0 gave contradictory loss detection, and a g out of its range moved alpha out of the range 0 to 1. The new parameters of Tcp and TcpCubic check their ranges in the same way.


INET-4.7 (July 2026) — feature release
--------------------------------------

This is a new feature release in the INET 4.x branch. The central theme of this
release is the maturation of the IPv6 protocol family, bringing it substantially
closer to feature parity with IPv4. Highlights include a new declarative IPv6
network configurator, IPv6 multicast routing (MLD, and PIM-DM/PIM-SM over IPv6),
node lifecycle support, Duplicate Address Detection, a modernized Mobile IPv6
(MIPv6) model with new Proxy Mobile IPv6 (PMIPv6) support, and IPv6 support in
BGP (MP-BGP) and IPsec. Outside the IPv6 area, the release brings satellite and
GNSS track mobility models with geographic visualization, a substantial overhaul
of the STP and RSTP spanning tree models, major BGP improvements, TCP Path MTU
Discovery, and a configurable RNG grouping mechanism. The release also contains
numerous smaller improvements and bug fixes. Requires OMNeT++ 6.4 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. Mobile IPv6 (MIPv6) modernization

   The Mobile IPv6 model was substantially modernized and aligned with the rest of
   the IPv6 stack. The module previously named xMIPv6 was renamed to Mipv6, and the
   xMIPv6Support wrapper was flattened into Ipv6NetworkLayer, with Mobile IPv6 now
   enabled by a hasMipv6 switch.

   IPv6 tunneling was reworked to follow the same model as IPv4: a tunnel is now
   represented as a virtual network interface rather than a dedicated mechanism,
   and the former Ipv6Tunneling module was removed. MIPv6-specific per-interface
   state was moved out of Ipv6InterfaceData into a separate Mipv6InterfaceData
   class.

   Several new roaming scenarios were added, and a number of latent correctness
   bugs in binding management, return routability, and route optimization were
   fixed along the way.

   This change requires the modification of simulation models that reference the
   xMIPv6 module type, the Ipv6Tunneling module, or the xMIPv6Support submodule
   path, as well as C++ code that accesses MIPv6 fields through Ipv6InterfaceData.

2. STP and RSTP overhaul

   The Spanning Tree Protocol (STP) and Rapid Spanning Tree Protocol (RSTP) models
   were substantially reworked for correctness and standards compliance. RSTP now
   implements the full Proposal/Agreement handshake for rapid, timer-free
   transition to the forwarding state. Several long-standing defects were fixed,
   including a topology-change (TCN) BPDU storm, a hold-timer violation, and
   incorrect timer interval assignments. The nonstandard ALTERNATE port role, which
   had been backported from RSTP, was removed from STP.

   A number of NED parameters and packet types were renamed for clarity and
   consistency. Notably, the RSTP helloTime parameter was renamed to helloInterval,
   and the STP maxAge parameter was renamed to configuredMaxAge (with the former
   currentMaxAge becoming maxAge). The BPDU packet type names were also reworked
   (e.g. stp-hello, rstp-hello).

   In addition, when the port path cost is not explicitly configured,
   L2NetworkConfigurator now derives the default from the link speed, following
   the recommendation of IEEE 802.1D-2004.

   This change requires the modification of simulation models that configure the
   renamed parameters, and it may significantly change the statistical results of
   spanning tree simulations due to the corrected protocol behavior.

3. IPv6 Router Advertisement interval defaults

   The default Router Advertisement interval was changed to follow RFC 4861.
   Previously, the minIntervalBetweenRAs and maxIntervalBetweenRAs parameters
   defaulted to very short, Mobile-IPv6-tuned values (30 ms and 70 ms) and were
   additionally overridden for wireless interfaces. They now default to the
   standard RFC 4861 values, and the wireless special-casing was removed.

   This change doesn't require the modification of simulation models, but it may
   significantly change the statistical results of IPv6 simulations that relied on
   the previous fast Router Advertisement timing, particularly those involving
   wireless or mobile nodes.

4. IPsec generalization to IPv6

   The IPsec model, introduced in the previous release for IPv4, was generalized
   to be address family independent, and now supports IPv6 as well. Traffic
   selectors and the security association and policy databases operate on
   generic L3 addresses, each IPsec instance serves the address family of its
   enclosing network layer, and Ipv6NetworkLayer gained a hasIpsec switch
   analogous to the IPv4 one. AH and ESP headers are treated as terminal headers
   in the IPv6 extension header chain. Two latent bugs in AH protection (a
   zero-length header on egress, and a double header removal on ingress) were
   fixed, and a new example demonstrates ESP over IPv6.

   As part of this change, the model was moved from the networklayer/ipv4/ipsec
   folder to networklayer/ipsec, with the NED package changing accordingly. This
   change requires the modification of simulation models and C++ code that
   reference the old package or include paths.

5. BGP timer configuration

   The BGP timers, previously configured via the <TimerParams> element of the
   bgpConfig XML file, are now parameters of the Bgp module (connectRetryTime,
   holdTime, keepAliveTime, startDelay). A <TimerParams> element in the XML
   configuration is now rejected with an error message that explains how to
   migrate.

   This change requires the modification of simulation models that configure
   BGP timers in the XML configuration file.

6. ICMP error indication refactoring

   The handling of ICMP error indications was refactored into a properly layered
   architecture in which each protocol layer processes only its own header. As part
   of this, the IcmpErrorInd indication and the IcmpErrorTag tag were each split
   into IPv4-specific and IPv6-specific variants (Icmpv4ErrorInd / Icmpv6ErrorInd
   and Icmpv4ErrorTag / Icmpv6ErrorTag).

   These changes are backward incompatible for C++ code that directly references
   the old combined ICMP error indication or tag types.

Notable backward compatible changes are the following:

1. IPv6 network configurator

   A new Ipv6NetworkConfigurator, with a companion Ipv6NodeConfigurator, was added,
   bringing the declarative, IPv4-style network configuration approach to IPv6.
   Like its IPv4 counterpart, it assigns addresses and sets up routing tables
   automatically based on the network topology, while allowing fine-grained control
   through an XML configuration. Explicit per-interface addresses can be assigned
   (e.g. using a prefix::interface-id form), overriding the default EUI-64 interface
   identifier. Both the IPv4 and IPv6 configurators now also accept CIDR
   "address/prefixlen" notation in static route specifications, and gained
   addRemoteRoutes and addManualRoutes parameters that allow the individual
   route generation steps to be enabled or disabled separately. The simpler
   Ipv6FlatNetworkConfigurator remains available.

2. IPv6 lifecycle and multicast forwarding

   The IPv6 protocol stack gained node lifecycle support, so that IPv6 nodes now
   correctly handle shutdown, restart, and crash operations the same way IPv4 nodes
   do. In addition, IPv6 multicast packet forwarding was implemented, including a
   multicast routing information base and forwarding information base with reverse
   path forwarding (RPF) checks. Together with the multicast routing protocols
   described below, this enables IPv6 multicast scenarios that were previously only
   possible with IPv4.

3. Multicast Listener Discovery (MLD)

   IPv6 multicast group membership is now managed using the Multicast Listener
   Discovery protocol. The MLDv1 router-side behavior was completed, and a new Mldv2
   module implementing MLDv2 (RFC 3810) was added, including the corresponding
   message set, serializer, packet dissector, and printer; the MLD version is
   selected by module typename. Source-specific multicast (SSM) membership state was
   added to Ipv6InterfaceData. The IPv4 IGMPv3 model was brought to lockstep parity
   with MLDv2 (query and report retransmission, interoperation with older versions),
   so that the IPv4 and IPv6 multicast membership implementations now mirror each
   other.

4. PIM over IPv6

   The PIM-DM and PIM-SM multicast routing protocols were generalized to be address
   family independent, operating on generic L3 addresses, and can now run over IPv6
   in addition to IPv4, while the existing IPv4 PIM behavior is preserved unchanged.
   The new MulticastRouter6 node type provides a ready-to-use pure-IPv6 multicast
   router. PIM-SM can also derive the rendezvous point per group from embedded-RP
   IPv6 addresses (RFC 3956). Source-specific multicast (SSM, RFC 4607) is now
   fully supported on both address families: source-list memberships from
   IGMPv3 (IPv4) and MLDv2 (IPv6) drive PIM-SM to build RP-less, source-rooted
   (S,G) trees for groups in the SSM range, using INCLUDE-only semantics and
   requiring no rendezvous point. The PIM packet serializer was extended to support
   the IPv6 encoded-address forms.

5. IPv6 Neighbor Discovery

   IPv6 Neighbor Discovery was extended in several backward compatible ways.
   Duplicate Address Detection (DAD) is now performed for autoconfigured global
   addresses in accordance with RFC 4862, and ICMPv6 Redirect message sending and
   processing was implemented (RFC 4861). Further Router Advertisement and Neighbor
   Discovery parameters were exposed as NED parameters and XML configuration
   attributes, and node bootstrap delays became configurable. A new sendRedirects
   parameter on the Ipv6 module allows suppressing Redirect messages, which is
   useful on wireless ad-hoc networks.

6. Proxy Mobile IPv6

   Support for Proxy Mobile IPv6 (PMIPv6, RFC 5213) was added. PMIPv6 provides
   network-based mobility management: the network tracks the movements of a
   mobile node and keeps its IPv6 address stable across handovers, without
   requiring any mobility support in the mobile node itself. The new Pmipv6
   module implements both the Local Mobility Anchor (LMA) and the Mobile Access
   Gateway (MAG) roles, using Proxy Binding Update / Acknowledgement signaling
   based on the Mobile IPv6 message formats, and tunneling between the MAGs and
   the LMA. A new example demonstrates a handover in a PMIPv6 domain, with the
   mobile node keeping its address across the move.

7. IPv6 netfilter hooks

   The Ipv6 module now provides the same set of netfilter-style hooks as its
   IPv4 counterpart: the LOCALIN hook is now invoked on local delivery, the
   FORWARD hook was added, and packets can be reinjected at all five hook points
   after asynchronous processing. This allows C++ modules such as reactive
   routing protocols to interpose on the IPv6 datapath in the same way as with
   IPv4.

8. BGP improvements

   The BGP model received major improvements in several areas. BGP now supports
   IPv6: sessions can be established over IPv6 TCP connections, and IPv6 routes
   are exchanged using the multiprotocol extensions (MP-BGP, RFC 4760),
   including multiprotocol capability negotiation in the OPEN message (RFC 5492)
   and serialization of the MP_REACH_NLRI and MP_UNREACH_NLRI path attributes.
   Related fixes make iBGP work over a multi-hop IGP with IPv6, and new examples
   demonstrate EBGP over IPv6 and BGP running on top of an OSPFv3-based IGP.

   BGP is now lifecycle-aware: node shutdown, restart, and crash operations are
   handled properly, with sessions re-established and routes re-learned after a
   restart. A new Adj-RIB-In data structure stores all routes learned from
   peers, and the decision process is re-run when a route is withdrawn, so that
   an alternative route can take its place. New examples demonstrate route
   withdrawal and failover scenarios.

   Session management robustness was also improved: routers now use a single
   shared listening socket, connection collision detection was implemented
   according to RFC 4271, several errors in connection retry and reconnection
   handling were fixed, and BGP sessions are shut down gracefully on node
   shutdown.

   The BGP lifecycle support and the Adj-RIB-In extension were contributed by
   Giovanni Nardini.

9. Satellite mobility and geographic visualization

   New mobility models and visualizers support simulating satellite networks
   and other scenarios placed on the Earth's surface. The new SatelliteMobility
   module computes satellite positions from standard TLE (two-line element)
   orbital data using the SGP4 propagation model, and GnssTrackMobility replays
   position tracks recorded by GNSS (GPS) receivers. The underlying geometry
   library was extended with WGS84 geodesy, Earth-centered (ECEF) coordinate
   systems, and an equirectangular map projection.

   On the visualization side, the new GeoMapCanvasVisualizer draws a world map
   with a graticule as the scene background, GeoHorizonCanvasVisualizer draws
   the visibility footprint of satellites on the map, and
   GeoSkyViewCanvasVisualizer displays an azimuth/elevation sky view plot next
   to observer nodes. The mobility visualizer was extended with 3D orientation
   display and direction projection modes, movement trails handle the
   antimeridian correctly, and several visualizers now clip their drawings to
   the map area. Mobile nodes can display their geographic position using the
   {geo_position} directive of displayStringTextFormat. A new example
   demonstrates satellites moving above a map of the Earth.

10. TCP Path MTU Discovery

   The TCP model now implements Path MTU Discovery (RFC 1191 and RFC 1981), allowing
   connections to discover and adapt to the largest packet size that can traverse
   the path without fragmentation. In addition, TCP now forwards ICMPv4 and ICMPv6
   error indications to the application as soft notifications, and aborts
   connections in the SYN_SENT state on hard ICMP errors.

11. RNG grouping

   A new GroupedRngManager was added, providing a flexible way to share random
   number generators among simulation components. It supports grouping components by
   module (the default, one RNG set per module), by node (a node-wide shared RNG
   set), or network-wide (a single global RNG set), selectable via the rng-grouping
   configuration option.

12. OSPFv3 packet serializer

   A packet serializer was added for OSPFv3, enabling OSPFv3 packets to be
   recorded into PCAP files, sent through emulation interfaces, and verified
   byte by byte in fingerprint tests. Several packet format errors (incorrect
   packet and LSA length fields) were fixed in the process, and the Ospfv3
   module gained a checksumMode parameter for RFC-correct checksums.

13. STP/RSTP tutorial

   A new tutorial introduces the Spanning Tree Protocol and Rapid Spanning Tree
   Protocol through a progression of examples, demonstrating root bridge election,
   port roles and states, topology change handling, and the rapid transitions
   provided by RSTP.

14. Documentation refinements

   The IPv6 chapter of the User's Guide was substantially rewritten to reflect the
   modernized IPv6 stack, including documentation of the new Ipv6NetworkConfigurator
   and the XML routing configuration format. New User's Guide chapters describe
   satellite mobility and geographic visualization, and the BGP documentation
   was extended with the configuration file format and the new IPv6 (MP-BGP)
   support. NED documentation for many IPv6 and Mobile IPv6 modules was expanded
   and brought up to date, and several example simulations (e.g. the PIM
   examples) received README files.

15. Notable bug fixes and other changes

   Most modules were migrated to the displayStringTextFormat mechanism for their
   Qtenv display strings, replacing custom refreshDisplay() overrides; the old
   WATCH_xxx() macros were replaced with the unified WATCH() macro, and additional
   watches were added for computed values. This affects only the graphical runtime
   and has no effect on results.

   The LdpMplsRouter and RsvpMplsRouter modules were refactored to share a common
   MplsRouterBase base, eliminating duplicated code. This changes the module
   initialization order and therefore the random number draw order, so MPLS
   simulation results may change.

   Fixed two IPsec ESP correctness bugs: an incorrect block size unit in payload
   padding, and an incorrect total length computation during decryption.

   Fixed a UDP payload padding removal bug that could misdetect trailing data, and a
   crash that occurred when combining multicast traffic with VLANs.

   Fixed a memory leak in MessageDispatcher that occurred when packet delivery
   failed.

   Standardized many internal integer types in the SCTP model and across the
   codebase, improving consistency.

   A new STAGE_NETWORK_INTERFACE_CONFIGURATION stage was inserted into the
   lifecycle start and stop operations, so that network interfaces are
   configured before IPv6 addresses are assigned. This fixes network interfaces
   not re-obtaining their global IPv6 address after a node restart.

   Fixed L2NetworkConfigurator to configure all ports in the network instead of
   just the first one, and added a dumpConfiguration parameter for debugging.

   Fixed visualizers to subscribe to the signals of their subject module rather
   than the visualization target module, so that the two can be fully decoupled.
   The InfoVisualizer now supports the %N directive for displaying the display
   name of a module.

   Fixed crashes that occurred when running GPSR over IPv6.

   IPv6 Neighbor Discovery packets are now created with descriptive names,
   making logs and packet traces easier to read.

   Removed several low-value or redundant IPv6 example simulations (demonetworketh,
   ipv6bulk, and ipv6nclients).

   Several additional issues reported on GitHub have also been fixed.


INET-4.6 (February 2026) — feature release
------------------------------------------

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 protocol-specific
   packet dissectors and packet printers to allow inspection and analysis of
   protected traffic.

   The IPsec protocol implementation was contributed by Marcel Marek.

4. Media Redundancy Protocol (MRP)

   Media Redundancy Protocol (MRP) was added to provide high-availability
   Ethernet ring redundancy. It improves network reliability by managing
   redundant paths in ring topologies, preventing loops, and enabling fast
   recovery after link failures.

   The EthernetSwitch module now includes MRP components such as the core
   protocol logic, redundancy-aware forwarding, a specialized MAC forwarding
   table, and support for interconnecting multiple rings or redundant segments.
   The implementation follows the relevant standards, using a specific multicast
   MAC address for protocol communication and supporting all major MRP message
   types for topology monitoring and change detection.

   Additional signals and statistics were added to improve observability, and
   the implementation was validated under extreme conditions (e.g. very high
   packet error rates) to ensure robust recovery behavior.

   The MRP protocol implementation was contributed by Daniel Zeitler

5. TCP auto-read mode

   The TCP modules were extended with an explicit read mode to support proper
   TCP flow control. Previously, all TCP sockets operated in auto-read mode,
   where received data was immediately delivered to the application, effectively
   disabling flow control.

   When explicit read mode is enabled by setting autoRead to false in
   TcpOpenCommand, applications must issue read requests, similar to real socket
   read() calls. TCP then delivers buffered or newly arrived data up to a
   specified byte limit, reducing the advertised window as data arrives and
   increasing it again only when buffer space is freed by read requests.
   Auto-read mode remains the default for backward compatibility and continues
   to advertise the full configured window.

   Read requests are represented by TcpReadCommand, and a new request may be
   issued only after the previous one has been satisfied. In addition, delivery
   of the TCP_I_PEER_CLOSED indication after a FIN is now delayed until all
   buffered data has been read by the application.

6. AODV gateway

   AODV has been extended to support routing toward external IP networks via a
   statically configured gateway. By defining the new gatewayAddress parameter,
   nodes can now handle traffic destined for external addresses by automatically
   initiating route discovery for the specified gateway. Once the route to the
   gateway is discovered, external packets are queued and forwarded accordingly.

   A showcase was added demonstrating AODV support for routing traffic to
   external networks via a statically configured gateway, featuring a wireless
   ad hoc network communicating with a wired Ethernet host through a gateway
   router.

7. GPSR multiple network interfaces

   The GPSR (Greedy Perimeter Stateless Routing) protocol was updated to support
   simultaneous use of multiple network interfaces, with refactored logic and
   data structures to track neighbors on a per-interface basis. Beacons are now
   sent on all configured interfaces, neighbor information stores both position
   and interface ID, and packet forwarding correctly uses the interface
   associated with the selected neighbor for greedy or perimeter routing. The
   internal tables were reorganized by removing unused functionality, renaming
   PositionTable to GpsrPositionTable, and introducing GpsrNeighborTable.

8. Extended host OS support

   The new ExternalEnvironment, ExternalProcess, and ExternalApp modules provide
   a framework for integrating host OS applications into simulations by managing
   their execution and setup. ExternalEnvironment handles host configuration via
   shell commands and is integrated as an optional submodule within NodeBase,
   while ExternalApp offers a high-level interface to run programs like web
   servers or routing daemons automatically along with the simulation.

   To facilitate host OS isolated emulation, the framework introduces an
   UnsharedNamespaceInitializer class for creating separate host OS user and
   network namespaces. A dedicated INITSTAGE_EXTERNAL ensures external devices
   like TAP interfaces are opened only after the environment is fully prepared.

9. Queueing model

   New utility classes have been introduced to replace raw interface pointers
   with managed references for packet sources and sinks. These classes are
   PassivePacketSinkRef, ActivePacketSinkRef, PassivePacketSourceRef, and
   ActivePacketSourceRef, they manage references to components for both push-
   and pull-based interfaces. Most modules now treat connected sources and sinks
   as optional, enabling these modules to also connect to non-queueing elements.

   Classifiers and schedulers have been extended to enable pulling packets from
   them and pushing packets to them, respectively. Typically, however, they are
   used the other way around, with packets being pushed into classifiers and
   pulled from schedulers.

   Several new modules and module interfaces have also been added. For example,
   the QueueBasedTokenGenerator allows the QueueFiller module to generate
   traffic that prevents a queue from ever becoming empty.

   Statistics collection has been improved across multiple modules. For example,
   many modules now provide a packetLifeTime statistic; previously, only the
   bit-based average lifetime (meanBitLifeTimePerPacket) was tracked. The
   packetLifeTime statistic measures how long a packet stays in the system, from
   entry to exit. Unlike the older meanBitLifeTimePerPacket, it is a simple
   per-packet time delta rather than a bit-weighted average, making it easier to
   interpret, analyze (e.g. histograms, min/max), and align with standard
   metrics such as end-to-end delay.

   In addition, passive packet sinks have been extended with optional statistics
   to detect duplicate, out-of-order, and missing packets based on packet name
   index suffixes. To name a few additional statistical changes, the
   MultiTokenBucketMeter and MultiTokenBucketClassifier modules now record
   separate statistics for each individual token bucket they contain, and the
   SlidingWindowRateMeter and ExponentialRateMeter modules now provide
   packetRate and dataRate statistics.

10. Protocol support

   Several smaller modules have been added to support various protocol features.

   For example, the GroupEligibilityTimeMeter and GroupEligibilityTimeTable
   modules were added to support asynchronous traffic shaping with scheduler
   groups in TSN simulations. The GroupEligibilityTimeMeter provides shared
   eligibility times for streams within the same group, while
   GroupEligibilityTimeTable maintains group state and mappings; they are
   typically connected via Ieee8021qFilter to enforce shared eligibility
   behavior.

   New specialized modules were added to handle Ethernet Frame Check Sequence
   (FCS) separately, including EthernetFcsHeaderInserter, which inserts Ethernet
   FCS headers, and EthernetFcsHeaderChecker, which checks and strips Ethernet
   FCS headers.

   Added modules to support the EtherType Protocol Discrimination (EPD) header
   used by IEEE 802 LLC implementations.

11. Visualizers

   The RoutingTableCanvasVisualizer has been extended with a lazy update
   mechanism that refreshes visualizations only when needed, greatly improving
   performance. Support for multicast routing tables has been added, along with
   new filtering parameters to control multicast group, source address, and
   source node visualization.

   The ChannelCanvasVisualizer is a new module for displaying channel activity.

12. Packet serializers

   An Ieee802154MacHeaderSerializer has been added to support the binary
   representation of the IEEE 802.15.4 protocol. In addition, new serializers
   were introduced for non-standard INET specific protocols or technologies:
   GenericPhyHeaderSerializer, ShortcutPhyHeaderSerializer, and
   ShortcutMacHeaderSerializer.

   The ApskPhyHeaderSerializer was updated to serialize and deserialize the
   protocol field using InetPhyProtocolGroup. This change eliminates fingerprint
   instability caused by serializing internal protocol IDs into the binary
   representation.

   A StreamBufferChunkSerializer was added to enable serialization of frames
   transmitted using Ethernet cut-through switching.

13. RIP routing tutorial

   This tutorial introduces the fundamentals of the Routing Information Protocol
   (RIP) through a series of progressively complex examples. Starting from
   static routing baselines, the tutorial demonstrates basic RIP operation with
   route discovery and convergence, then advances to dynamic scenarios including
   network failures, recovery mechanisms, and loop prevention techniques. Key
   distance-vector concepts such as split horizon, triggered updates, route
   poisoning, and the count-to-infinity problem are explored through hands-on
   examples.

14. OSPF tutorial

   A new multi-step tutorial covers the OSPF (Open Shortest Path First) routing
   protocol in detail. Beginning with basic single-area configurations featuring
   adjacency establishment and SPF-based route computation, it progresses
   through DR/BDR election, link costs, and interface types, then advances to
   hierarchical multi-area topologies with ABRs, summary LSAs, and external
   route advertisements. Advanced topics including stub areas, virtual links,
   and loopback interfaces are also demonstrated.

15. BGP routing tutorial

   A comprehensive tutorial guides users through Border Gateway Protocol (BGP)
   configuration and operation. The tutorial begins with basic E-BGP sessions
   between autonomous systems with automatic next-hop resolution, then
   progresses through I-BGP for distributing external routes within an AS, path
   attributes (AS_PATH, NEXT_HOP, LOCAL_PREF), and multi-hop E-BGP with loopback
   interfaces. Route redistribution with IGPs (RIP and OSPF), AS configuration,
   route aggregation, and policy-based filtering are also covered.

16. New showcases

   The new tsn/combiningfeatures/fpandtas showcase presents a combined-feature
   TSN scenario that demonstrates the simultaneous use of Frame Preemption and
   Time-Aware Shaping (TAS).

   The emulation/mininet showcase, based on the VoIP showcase, is now a
   standalone demonstration of running INET applications within a Mininet
   environment. It uses an AppContainer-based network structure to connect
   simulated traffic with external Mininet components.

   The emulation/webserver showcase demonstrates the ExternalApp and
   ExternalEnvironment framework by running a Python-based HTTP server and a
   wget client as real host OS processes. Network namespaces are used to isolate
   these external applications while enabling communication through the
   simulated network.

17. Documentation refinements

   NED documentation received extensive improvements in consistency, coverage,
   and technical accuracy. Brief descriptions were standardized for better
   presentation in IDE tooltips, terminology and formatting were unified.
   Documentation was added for many previously undocumented modules. Protocol
   documentation was expanded and corrected, notably for TCP and gPTP. New or
   refined material was added for Ethernet (including 10BASE-T1S) and wireless
   physical layer components.

   The User's Guide was revised to use more neutral, professional language. It
   now includes new documentation on TCP flow control and the effects of the new
   autoRead parameter. The Developer's Guide was expanded with additional
   technical diagrams, including a new clock and oscillator model diagram.

   Across the documentation, showcases and tutorials were enhanced with “Try It
   Yourself” sections that provide concrete opp_env commands for interactive
   experimentation.

18. Notable bug fixes and other changes

   Added INET-specific SimpleModule, CompoundModule, and ModuleMixin as standard
   bases to derive all modules from. They have a displayStringTextFormat
   parameter that supports the old style format directives and also WATCH
   variable references. Deriving new or existing modules from these bases is
   optional.

   Obsolete '#abstract-config = true' configuration options in INI files have
   been systematically replaced with the now standard 'abstract = true'.

   Improved robustness and timing accuracy of the RealTimeScheduler. Reduced
   spurious overruns and improved behavior under host load.

   Added a ModuleDump module that can print a module's hierarchy and parameters
   for debugging and comparison across simulations. Optional ModuleDump
   submodules were also added to NetworkBase, enabling partial or full network
   dumps via command line or INI file configuration.

   Added ChannelOwnerRecorder, a result recorder that records which module
   currently owns a communication channel. Useful for debugging resource
   contention and validating channel access behavior. Added a channelOwner
   statistic to WireJunction module to record the owning network node in the
   collision domain.

   Added a SimulationCpuUsageMeasurer module that measures the CPU time used by
   a simulation and records it as a scalar statistic. It can be used for
   performance analysis and benchmarking simulations.

   Added parameters to the MessageDispatcher module to allow directly
   controlling the message dispatching mechanism, in contrast with the automatic
   learning of protocol and interface registrations.

   Improved EIGROP stability, cleanup, and modernization. Several bugs were
   fixed to prevent dangling pointers, handle dynamic neighbor changes
   correctly, and align IPv4 route removal with IPv6 behavior. Core code paths
   were refactored to use modern C++ constructs, missing interface parameters
   were added to improve configurability, and message definitions were
   simplified, resulting in a more robust and consistent implementation.

   Added a few new NED functions. seq() returns the next integer (starting from
   0) associated with a given string key, enabling deterministic sequences
   across evaluations. iterate() returns the next value from an array on each
   evaluation, with the index tracked per context component path. The par()
   function allows dynamic access to module parameters inside expressions.

   All module parameters specifying filenames now support substitution, allowing
   config name, experiment, iteration, run number, etc. to be referenced in the
   values.

   Added the DemuxAppFilter, a result filter that de-multiplexes signals by
   their originating application module, making it easy to record
   per-application statistics even when applications share a common path or
   interface.

   Added the DemuxRegexFilter, a result filter that uses regular expression
   matching on signal metadata or packet names to route incoming data into
   separate output streams, enabling flexible result categorization based on
   naming conventions.

   Added the InterarrivalTime result filter, which computes the time between
   consecutive signals or packet arrivals for analyzing jitter, traffic
   burstiness, and event timing.

   Removed the default value "SSID" for the defaultSsid parameter in
   Ieee80211AgentSta, requiring users to explicitly configure the SSID for
   station associations.

   The FlowMeasurementRecorder has been extended to support recording a
   packetEvent JSON log file, which captures detailed packet-level events during
   the simulation.

   The SctpAssociation class is converted into a simple module.

   Fixed Ethernet multicast delivery in TSN.

   Fixed mCRC calculation for multi-fragment Ethernet frames.

   The Python support libraries were extended with automatic simulation
   comparison that identifies the divergence point.

   Converted self-documentation feature into a compile-time option.

   Removed all per-folder ChangeLog files that summarized local changes, since
   they are no longer useful with current AI tools.

   Several additional issues reported on GitHub have also been fixed.


INET-4.5.4 (October 2024) - Stable
----------------------------------

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 lake errors were fixed. Added logging and 
testing framework enhancements. Added a `python/requirements.txt` so Python
dependenies 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.
- Tets marked as intentionally as SKIP are now left out from the test execution.
- Added `inet_run_release_tests` for pre-release testing.
- A lot of mischelanous fixes.


INET-4.5.3 (September 2024) - Stable
------------------------------------
This version was yanked because of `@enum` related issues.


INET-4.5.2 (August 2024) - Stable
---------------------------------

This is a minor bugfix release containing OMNeT++ 6.1 compatibility fixes
and and a fix for 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.1 (August 2024) - Stable
---------------------------------

This release got rewoked because of OMNeT++ 6.1 incompatibility.


INET-4.5 (April 2023) - Stable
------------------------------

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.2 (Aug 2024) - Stable
------------------------------

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.4.1 (July 2022) - Stable
-------------------------------

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 (May 2022) - Stable
----------------------------

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 splitting/merging, stream encoding/decoding. There are a few other new
   modules, currently used in TSN asynchronous shaping, for transmission eligibility
   time metering, filtering, and queueing.

   A new interactive packet gate has been added that allows the user to directly
   control the gate's open/closed state from Qtenv and experiment interactively.

   Please note that in OMNeT++ 6.0 version of Qtenv the simulation may stop more
   than once in the same event. This is called pause points, and it happens every
   time a packet is passed from one module to another using to queueing model
   elements, the protocol support modules, or the INET packet processing API.

6. Applications

   A new simple out-of-band clock synchronizer application has been added. This
   module can be used to synchronize clocks in the whole network without actually
   sending any time synchronization packets.

   New IEEE 802.2 LLC protocol-specific applications have been added. These allow
   to send IEEE 802.2 LLC packets directly from the application layer.

7. Packet chunks, tags and serializers

   New packet chunks have been added for the IEEE 802.1r protocol.

   Several new packet tags have been added: PcpReq/PcpInd, StreamReq/StreamInd,
   SequenceNumberReq/SequenceNumberInd, ResidenceTimeTag, EligibilityTimeTag,
   CreditGateTag, EnapsulationProtocolReq/EnapsulationProtocolInd. The purpose
   and usage of these tags can be found at the relevant modules.

   New packet chunk serializers have been added for the IEEE 802.1as and IEEE
   802.1r tags. This allows recording of PCAP traces in TSN simulations.

8. Signals and statistics

   Several new signals and statistics have been added. The most notable newly
   added statistics are the measurement of the transmission duration, the signal
   propagation time, and the packet residence time. The latter being the duration
   the packet spends in individual network nodes. For a complete list of signal
   and statistic changes see the ChangeLog in the src folder.

9. Project features

   Several new project features have been added. The IEEE 802.1as and the IEEE
   802.1r features are used in Time-Sensitive Networking. Another feature is
   added for the Microsoft Z3 SAT-solver-based gate schedule configurator, it
   requires the installation of an external library.

   Finally, there is a new feature for an automatic simulation model self documenter.
   This feature allows one to observe the simulations while they are running and
   to collect several categories of information about what the simulation modules
   are doing. The result can be automatically included in the generated NED
   documentation.

10. Visualization

   New visualizers have been added that display some aspects of the Time-Sensitive
   Networking configuration. One visualizer displays the gate schedule for the
   time-aware shapers for multiple network interfaces in multiple network nodes.
   Another visualizer displays the redundant traffic paths configured in the
   stream splitting and stream merging components.

11. Examples

   Several new Time-Sensitive Networking specific examples have been added
   under the showcases/tsn folder. The new examples cover the topic of time
   synchronization, traffic shaping, gate scheduling, per-stream filtering,
   frame replication, frame preemption, cut-through switching, and several
   combinations of these features.

   Another set of new examples, found under the showcases/measurement folder,
   have been added to demonstrate how to do some widely used communication
   network measurements. There are examples for datarate, throughput,
   utilization, end-to-end delay, jitter, queueing time, residence time,
   transmission time, propagation time and various packet-flow-specific
   measurements.

12. Experimental Python support

   A new experimental Python package has been added that allows the automation
   of running and testing multiple simulations concurrently and also optionally
   on an SSH cluster. The automated testing covers smoke, fingerprint, sanitizer,
   statistical, and several other tests. The inet_python_repl shell script starts
   the Python interpreter and loads the required OMNeT++/INET Python packages.
   The main entry points are run_simulations, run_smoke_tests, run_fingerprint_tests,
   and several other run_* functions, there's also an optimize_simulation_parameters
   function. There are also shell scripts (called inet_run_*) that can be used in
   the simulation folders directly.

   This package will be officially supported in the next OMNeT++/INET release.

13. Documentation

   The User's Guide has been extended with new chapters. One new chapter is
   about the new Time-Sensitive Networking features. It gives an overview of
   the available modules and how to use them. Another new chapter is about the
   new packet filter expression syntax. It gives a brief description of the
   syntax and provides several examples.

14. Licensing and code formatting

   The whole INET Framework has been re-licensed under the LGPL. The vast majority
   of INET components were already licensed under LGPL. All other components that
   were not, and where we could not reach the original authors, or they did not
   agree with the new license, have been moved into a separate INET-GPL project.

   As of today, the new INET-GPL project (https://github.com/inet-framework/inet-gpl)
   contains the following old INET components:
    - TCP NSC
    - packetdrill
    - HTB queue and scheduler
    - HTTP tools

   All source files have been changed with respect to license headers. The longer
   license header variants have been replaced with a standard one-liner SPX license
   reference.

15. Notable bug fixes and other changes

   Fixed packet level region tag updating when packet contents are changed.

   Fixed copying region tags in fragmentation, defragmentation, aggregation, and deaggregation.

   Fixed the hazards in queue length statistics that allowed the length to go
   below 0 or above the queue capacity for zero simulation time.

   Fixed the utilization result filter that incorrectly calculated 1-utilization.

   Fixed several memory leaks and other problems found by the sanitizer.

   There were several other minor bug fixes some of which are documented on Github.

   The VoIP stream modules have been updated to the latest development library.


INET-4.3.9 (April 2022) - Stable
--------------------------------

Compatible with OMNeT++ 6.0.
(Preview and RC versions are NOT supported).

Bugfixes:

  - 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.


INET-4.3.8 (April 2022) - Stable
--------------------------------

Several minor bugfixes plus compatibility fixes for OMNeT++ 6.0.
OMNeT++ 6.0 Preview and RC versions are NOT supported.
For details see individual ChangeLog files 

  - simplified findInterfaceByAddress() and findHostWithAddress(),
    uses NetworkInterface::hasNetworkAddress()
  - Replaced duplicate implementations of findInterfaceByAddress and
    isLocalAddress in RoutingTables
  - Changed initial values of simtime_t fields to -1 instead of NaN, because
    double NaN cannot be converted to simtime_t.
  - Replaced deprecated init() to new init(Context* ctx) in ResultFilters.
  - Fixed #747: Avoid division by zero causing scheduling a message to 
    infinite simulation time.
  - Fixed SendOptions duration/remainingDuration for the animation of 
    synchronous packet pushes/pulls in queueing/protocolelement
  - Fixes for change in OMNeT++ 6 where uniform(a,b) now expecting a <=b
  - Various smaller bugfixes and optimizations


INET-4.3.7 (February 2022) - Stable
-----------------------------------

This release contains compatibility fixes for OMNeT++ 6.0 RC1.
OMNeT++ 6.0 Preview 15 or earlier versions are NOT supported.


INET-4.3.6 (December 2021) - Stable
-----------------------------------

This release contains compatibility fixes for OMNeT++ 6.0 Preview 15.
OMNeT++ 6.0 Preview 13 or earlier versions are NOT supported.


INET-4.3.5 (November 2021) - Stable
-----------------------------------

This release contains compatibility fixes for OMNeT++ 6.0 Preview 14.
OMNeT++ 6.0 Preview 13 or earlier versions are NOT supported.


INET-4.3.4 (October 2021) - Stable
----------------------------------

This release contains compatibility fixes for OMNeT++ 6.0 Preview 13.
OMNeT++ 6.0 Preview 12 or earlier versions are NOT supported.


INET-4.3.3 (August 2021) - Stable
---------------------------------

This release contains compatibility fixes for OMNeT++ 6.0 Preview 12.
(OMNeT++ 6.0 Preview 11 or earlier versions are NOT supported.)


INET-4.3.2 (April 2021) - Stable
--------------------------------

This release contains compatibility fixes for OMNeT++ 6.0 Preview 11.


INET-4.3.1 (April 2021) - Stable
--------------------------------

Minor bugfixes.

  - fixed bug #646
  - fixed calling base ClockUserModuleMixin class from initialize


INET-4.3 (January 2021) - Stable
--------------------------------

This is a new minor stable release of the INET 4.x branch. The highlights of this
release are the infrastructure for Time-Sensitive Networking protocols, the EIGRP
routing protocol and DCTCP congestion control.

For TSN support, a new modular Ethernet MAC and PHY layer model has been added
which provides Ethernet frame preemption, Ethernet cut-through switching, a gating
mechanism for packet queueing, and a clock model which also models clock drifting.

New API level features include intra-node packet streaming, inter-node transmission
update support, bit level packet data identity tracking, and the ability to define
and measure packet flows.

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 preview 10 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 src/ChangeLog.

Notable backward incompatible changes are the following:

1. Packet API

   The packet tag, chunk tag and chunk region tag APIs have been changed to
   store all tags using shared pointers. Moreover, the vectors containing said
   tags have also been changed to be stored using shared pointers. These shared
   data structures are automatically copied behind the scenes when they are
   modified, and they are also shared among multiple packets.

   The reasoning is that packets are copied quite often, so this operation must
   be very efficient both in terms of space and time. Often the copied packet is
   not modified with respect to the attached tags, so it makes sense to share these
   data structures. The previous packet API already shared the packet data between
   copies, but it didn't share the attached tags.

   Internally, the class TagSet has been replaced with another class, SharedTagSet,
   and similarly, the class RegionTagSet has been replaced with SharedRegionTagSet.

   This change requires the modification of simulation models, because tags are
   now returned as shared pointers. Moreover, a different method must be called,
   namely the ones with the 'ForUpdate' suffix, to modify existing tags. Due to
   this copy-on-write semantics, this change can also break existing user code.

2. Ethernet

   Several modules which had an abbreviated Ether in their names have been renamed
   to have the complete word, Ethernet, in their names instead. This change affects
   many names: EthernetSwitch, EthernetMac, EthernetLink, EthernetSignal, etc.

   The Ethernet switch relay functionality provided by the MacRelayUnit and
   Ieee8021dRelay modules have been refactored. The most prominent change is that
   these modules no longer work on Ethernet frames only. They simply expect the
   packets to contain the necessary metadata such as the incoming interface
   indication (InterfaceInd) and the source and destination MAC address indication
   (MacAddressInd) in order to operate.

   A new WireJunction module has been added which replaces the functionality of
   the old EtherBus and EtherHub modules. This module represents a generic wiring
   hub, and simply broadcasts messages (packets, frames, signals) received on one
   port to all other ports, mimicking the propagation of wired electrical signals.

   The physical signal class hierarchy has been refactored, the old Signal class
   has been split into a generic wireless signal, called WirelessSignal, and
   a generic wired signal, called WiredSignal, both subclassed from Signal.

   The renames may break existing simulations but they are easy to follow. The
   MAC relay changes are internal to network nodes and may only break Ethernet
   extension models. All the other changes are likely to produce compilation
   errors.

3. IEEE 802.1q support

   The old 802.1q support has been removed from the default EthernetInterface,
   because it unnecessarily complicated the network interface and it was not
   extensible.

   The LinkLayerNodeBase base module has been extended with separate and optional
   Ethernet and IEEE 802.1q protocol layers, where protocol modules have on instance
   per network node. This results in a different structure from the default one
   where the Ethernet protocol is part of the network interface. The advantage is
   that various additional IEEE 802 protocols such as 802 LLC, 802 SNAP, 802.1q
   and 802.1ae are better composable this way.

   Several small layered protocol models and infrastructure components have been
   added to support these IEEE 802 protocols. These include among others protocol
   header inserters and checkers, protocol printers and dissectors, etc.

   This change may break simulations that used the old IEEE 802.1q support. They
   must be carefully investigated and updated to use the new model instead.

4. VLAN support

   The VLAN support has been completely refactored to use separate modules for
   filtering and mapping VLAN indications and requests on packets according to
   a user-configurable policy. The new VlanIndFilter and VlanReqMapper modules
   are part of a VLAN policy module of Ethernet switches by default.

   This change may cause simulations to ignore certain parameters which are
   expected to affect virtual interfaces and thus break existing simulations.

5. Virtual interfaces

   The vlan submodule vector of network nodes inherited from LinkLayerNodeBase
   has been renamed to virt. The original name suggested misleadingly that this
   set of network interfaces were meant to be used exclusively for VLAN, but that
   is not the case. The virtual interfaces, called VirtualInterface, can be used
   for all kinds of protocol parameterization such as changing the source MAC
   address.

   This change may cause simulations to ignore certain parameters which are
   expected to affect virtual interfaces.

6. Registering protocols and services

   There was some confusion with respect to the expected module gates in the
   arguments of the registerService() and registerProtocol() methods. Following
   the OSI terminology, the registerService() method now takes the requestIn
   and indicationOut gates, the registerProtocol() method takes the requestOut
   and indicationIn gates as arguments. This change has been followed with
   all affected modules.

   Unfortunately, this change may break existing code silently, although not
   very likely. The registration calls may provide the incorrect gates to the
   MessageDispatcher modules, which in turn will dispatch the packets to the
   wrong modules or not at all. Luckily, in the latter case, an error will be
   thrown and the simulation terminates.

7. Mobility

   All methods in the IMobility interface that returned a Coord or a Quaternion
   data structure by value have been changed to return a const reference instead.
   These methods, especially the getCurrentPosition() method, may be called quite
   often, so avoiding the copying of said data structures increases performance.

   This change can be followed easily by implementations, because in most cases
   the values were already stored in the mobility modules. This change is not
   expected to break existing models silently.

8. Radio medium analog model

   Similarly to the IMobility interface change, several methods that returned
   or received as an argument a Coord or a Quaternion data structure by value
   has been changed to return or receive a const reference instead. Again, these
   methods may be called quite often in wireless network simulations, so avoiding
   the copying of these data structures increases performance.

   This change has very little effect on the implementations, since in most cases
   the values were already stored in the related object with a large enough dynamic
   extent. This change is not expected to break existing models silently.

9. Queueing model

   The IPacketQueue interface has been changed to use explicit enqueuePacket()
   and dequeuePacket() methods instead of relying on the generic pushPacket()
   and pullPacket().

   This change required to updated all existing MAC models to use the new API.
   Other 3rd party MAC modules have to be updated accordingly.

10. Renames

   Several folders in the physicallayer folder have been moved below the newly
   added wired and wireless folders, and renamed. Besides, all support modules have
   been moved one level deeper into the common folders. This change helps new
   users to find existing physical layer technologies more easily, because they
   have their own folders right inside the wired and wireless folders. This change
   separates the largely independent wired and wireless physical layer support
   modules and implementations.

   Similary to the above, several folders in the visualizer folder have been
   moved below the newly added canvas and osg folders. This change is required
   in order to be able to add separate features for canvas (2D) and OSG (3D)
   visualizations.

   The InterfaceEntry module that represents network interfaces has been renamed
   to NetworkInterface. The old name was a left-over from the time when this
   class was really an integral part of the InterfaceTable module. This is no
   longer the case, thus the renaming makes perfect sense.

   The Protocol::ieee8022 global protocol variable has been renamed, and split
   into Protocol::ieee8022llc and Protocol::ieee8022snap.

   The queueing API has been updated to reflect the new push/pull duality in
   the naming convention as opposed to the old push/pop duality. For example,
   the old packetPopped signal has been renamed to packetPulled, and the old
   popPacket() method in the IPassivePacketSource has been renamed to pullPacket().

   The IPacketQueueingElement C++ interface and the corresponding base class,
   called PacketQueueingElementBase, has been renamed to IPacketProcessor and
   PacketProcessorBase, respectively. The reason is that, although these classes
   are part of the queueing API, they are more general and their original name
   didn't capture this fact. Also, in several protocol implementations deriving
   classes from the classes with the original names looked really weird.

   All integral C++ type alias have been replaced with the standard variants.
   For example, the int64 type alias has been replaced with int64_t.

   These changes mostly result in NED errors and C++ compilation errors in the
   simulation models which are affected, and they are easy to follow.

11. Removed models

   The NetAnimTrace module has been removed. The visualization functionality it
   provided has been replaced with the much more versatile and feature rich
   visualizer modules.

   The PacketDump class, which was used to provide a very basic human readable
   string representation of the packet content, has been removed. The packet
   printer API is a much more versatile and widely parameterizable way of
   printing packets, and there's no reason to have two different ways of doing
   the same thing.

   The EtherBus module has been removed because it has been completely replaced
   with the generic WireJunction module.

   The Ieee8021qEncap module has been removed. This module was used in the Ethernet
   network interfaces to provide IEEE 802.1q protocol support and VLAN networking.

   These changes break existing simulation models with a compile time or runtime
   error.

Notable backward compatible changes are the following:

1. Packet API

   The Packet API has been extended with several new replace and update methods.
   The replace methods allow replacing arbitrary parts of the packet content with
   a single method call. The update methods allow updating arbitrary parts of the
   packet content in place with a single method call. Similarly to the completeness
   of these methods, the remove and insert methods have also been further extended.

   Moreover, the Packet API has been extended with a packet level region tag
   support. This allows attaching region tags to the data of packets similarly
   to how chunks already allowed this. The main difference is that when data
   is attached to chunks, then it must be in a form that can be shared among
   multiple packets which share the same chunk throughout the network. For
   example, the creation timestamp of coherent data fragments is such a data.
   In contrast, the queueing time of coherent data fragments belongs to the
   individual packets, and must be separately updated for different paths the
   same data takes in the network.

   The chunk API has been extended with a bit-level identity tracking of data.
   In other words, it is now possible to determine if the data that shows up at
   two different locations in the network, independently of whether these locations
   are in the same network node or not, and also independently of how the data
   is represented (field-based or binary), is the same data or not. This feature,
   for example, is useful for end-to-end delay measurements and more accurate
   path visualization.

   A new chunk class, called EncryptedChunk, has been added to allow storing
   encrypted data in a packet without actually encrypting the data. Internally,
   the new chunk uses a shared reference to the encrypted chunk and the length
   of the encrypted binary representation.

   Efficient parsim support has been added to all classes of the Packet API,
   including the Packet class itself, all chunk classes, and all tags.

   The PacketProtocolTag has been extended with an extra front and back offset
   that further specifies where the actual protocol is to be found within the
   packet data. This feature is primarily useful to keep the associated protocol
   of the packet up to date even while the packet is being constructed within a
   protocol module. Doing so allows the packet printer and packet dissector to
   understand a partially encapsulated, incomplete packet.

2. Clock model

   Several new modules have been added to support the modeling of hardware clocks
   and the related clock drift phenomena. The new modules can be found in a new
   top level folder called clock. The clock model is an optional feature that
   can be most conveniently used via the ClockUserModuleBase and ClockUserModuleMixin
   classes.

   Several modules have been extended with optional clock support: UdpBasicApp,
   InterpacketGapInserter, TransmitterBase, PeriodicGate, etc. This feature has
   been documented in the User's Guide.

3. Ethernet

   A completely new modular Ethernet model has been added to the linklayer and
   physicallayer folders. The three most prominent new features that are directly
   supported are the Ethernet frame preemption, Ethernet cut-through switching,
   and the gating mechanism in the Ethernet queues.

   The new model contains of several smaller modules that allow the user to
   combine them in more ways than before and also to customize their behavior.
   The main purpose of this change was to provide support for Ethernet
   Time-Sensitive Networking (TSN) features.

   Following the changes in the OMNeT++ cDatarateChannel API, both existing
   Ethernet MAC models that used the old forceTransmissionFinishTime() API have
   been updated to use the new transmission update mechanism instead.

4. PPP

   Similarly to the change in the Ethernet model, the PPP protocol implementation
   has been changed to use the new transmission update API in place of the old
   forceTransmissionFinishTime().

5. TCP

   A new congestion control algorithm, called DCTCP, has been added by Marcel
   Marek. Also, related to this change, the ECN support has been enhanced to be
   customizable by congestion control algorithms.

6. Enhanced Interior Gateway Routing Protocol (EIGRP)

   A new model of the routing protocol EIGRP with support for IPv4 and IPv6 has
   been ported from ANSAINET 3.4.0 to INET. This is a large addition that adds a
   lot of modules, some new network node types, and it also comes with several new
   examples.

   This model was contributed by Vladimir Vesely, Jan Bloudicek, Vit Rek, and Jan
   Zavrel from the Brno University of Technology.

7. Packet flows and timing measurements

   The concept of packet flows has been added to provide support for advanced timing
   measurements. A packet flow is a logical classification of packets, identified
   by a name, over the whole network and over the duration of the whole simulation.
   Packets may have a PacketFlow tag attached to a region of data which describes
   flow membership.

   This feature allows making timing measurements between two or more arbitrary
   end points in the network. The measurement can separate queueing time, processing
   time, propagation time, transmission time, etc. on a per-bit basis efficiently.
   It is also possible to collect all packet events (e.g queueing, processing,
   transmission, propagation) and do arbitrary computations again on a per-bit
   basis. This feature is provided by the FlowMeasurementStarter and FlowMeasurementRecorder
   modules. The measurement data are collected on packets in various time tags
   (e.g. QueueingTimeTag), which are updated by all related modules (e.g. PacketQueue).

8. Queueing model

   The synchronous packet processing API has been extended with the support of
   packet streaming between modules. This feature allows two modules within the
   same network node to communicate synchronously (without sending asynchronous
   messages) and process a packet bit by bit over a nonzero amount of time. The
   related methods are called pushPacketStart(), pushPacketEnd(), pushPacketProgress(),
   pullPacketStart(), pullPacketEnd(), and pullPacketProgress().

   Several queueing model base classes have been refined and somewhat refactored
   in order to better support the new feature. Also, many queueing model elements
   have been extended with direct packet streaming support.

   A few new queueing model elements have also been added that provide support
   for the gating mechanism of Time-Sensitive Networking and for the preemption
   mechanism of Ethernet. Some notable examples are PacketGate, PeriodicGate,
   PreemptingServer, PreemptableStreamer, etc.

9. PCAP

   The PCAP support has been extended with the more modern PCAPng file format.
   This is the new default output file format for the PcapRecorder module. The
   support for recording PCAP files has been extended to the network, network
   node, and network interface level. The new format allows recording the network
   interface and packet direction (outbound/inbound) for frames and also supports
   mixing packet formats, making it possible to record the traffic of potentially
   the whole network into a single file.

10. Socket processing

   Several new modular socket command and packet processing components have been
   added for Ethernet and IEEE 802.2 LLC protocols. There are modules for handling
   the opening, configuration, and closing commands for sockets, others for maintaining
   a table of open sockets (which can also be inspected in the runtime user interface),
   and some for processing and duplicating the incoming packets for all open sockets.

11. Protocol elements library

   Many small generic and reusable protocol implementation support components
   have been added. These components include, among others, generic components for
   packet fragmentation and defragmentation, aggregation and deaggregation, CRC and
   FCS insertion and checking, and physical layer wired transmitter and receiver
   models.

12. Visualizer

   A new packet flow visualizer has been added, called PacketFlowCanvasVisualizer
   and its OSG variant PacketFlowOsgVisualizer. They have also been included in
   the integrated visualizer modules. The new visualizers display the packet flow
   paths as polylines along with some basic statistics. This visualizer relies on
   the newly introduced packet flow concept.

   The spectrum and spectrogram visualization of the MediumCanvasVisualizer has
   been further enhanced with better options and a more efficient implementation.

13. Printing formatted output

   Support for producing formatted log output has been added with the new EV_FIELD
   and other EV_ macros. The default str() method in several Packet API classes
   (e.g. Packet, various Chunks, Signal) have been enhanced to provide better
   textual representation in the log.

   The IPrintableObject C++ interface has been moved to the common folder. It
   has also been extended with template support for printing objects without
   having to repeat a lot of code and with using the default shift operator.

14. Features (.oppfeatures)

   Several new OMNeT++ features have been added and some old features have been
   split. These changes can be found in the IDE on the INET project properties:

    - Clock
    - Clock examples
    - EIGRP routing
    - EIGRP routing examples
    - Emulation showcase
    - IEEE 802.1ae
    - IEEE 802.1q
    - IEEE 802.2
    - Internet protocol examples
    - Open MP support
    - Physical layer common
    - Physical layer wired common
    - Physical layer wireless common
    - Protocol support
    - Protocol tutorial
    - Queueing library
    - Queueing tutorial
    - Unit disk radio
    - Virtual interface
    - Visualization OSG (3D)
    - Visualization OSG (3D) showcases
    - Visualization canvas (2D)
    - Visualization canvas (2D) showcases
    - Visualization common
    - Wireless noise source

15. Examples

   Several new examples have been added:
    - clock drift
    - Ethernet frame preemption
    - Ethernet cut-through switching
    - gating mechanism in Ethernet queueing
    - modular Ethernet interface
    - DCTCP congestion algorithm
    - timing measurement along packet flows
    - video streaming using network emulation
    - signal power spectral density visualization

   A few examples have been substantially changed to follow other changes:
    - IEEE 802.1d
    - virtual LAN

16. Testing

   The fingerprint testing script has been extended with support for computing
   multiple different fingerprints and a separate fingerprint calculator option.
   The updated fingerprint tests contain four separate fingerprint values for
   each example simulation:

    - detailed model behavior
    - complete network byte order packet data and timing at the network level
    - complete network packet length and timing at the network level
    - graphics in the runtime user interface.

   Several new fingerprint, module, and unit tests have been added for the new
   clock model, the protocol support modules, and the new formatted output.

17. Documentation

   A new chapter about the newly added clock model has been added to the User's
   Guide. The Collecting Results chapter has been completed and also extended
   with a new section that describes how to do timing measurements along packet
   flows. The queueing model and emulation chapters of the User's Guide has been
   updated to reflect the changes in the queueing model of this release.

18. Bug fixes

   A bug in the TCP Nagle's algorithm has been fixed, see #558.

   A bug related to using the latest avcodec libraries (e.g. Ubuntu 20.10) in
   the VoIP streaming applications has been fixed.

   The C++ numeric type selection/promotion support for unit specific binary
   operators has been fixed to follow what C++ does with the standard types.

19. Code cleanup and formatting

   The whole source tree has been cleaned up with respect to C++ code formatting,
   indentation, header guards, whitespace, and so on. Moreover, all copyright
   headers in the C++ source files have been updated to use the official GPL-2
   and GPL-3 formats as suggested.

   All markers (TBD, XXX, etc.) in the source code has been unified to use one
   of the standard TODO, FIXME, and KLUDGE markers. These have well-defined
   meaning and it makes finding them easier.

20. Other notable changes

   A few new multi-dimensional mathematical functions have been added that can
   be useful to represent signal power density in the physical layer. These new
   functions are the Rasterized2DFunction, PeriodicallyInterpolated2DFunction,
   LeftCurryingFunction and RightCurryingFunction.

   In several places the std::min and std::max calls have been replaced with
   inet::minnan, inet::maxnan that properly propagate NaN values.

   The IProtocolRegistrationListener interfaces have been extended to allow
   registering a protocol group or any protocol as a fallback for a service or
   protocol available at a module gate.

   A new OperationalMixin template base class has been added that allows using
   the same behavior as the OperationBase where it was not applicable due to
   it having a specific base class.

   Several network base NED modules (NetworkBase, WiredNetworkBase, WirelessNetworkBase,
   Ieee80211NetworkBase) have been added to support easier use of the typical
   configurator, radio medium, visualizer, etc. network level submodules.

   The module initialization stages have been extended with INITSTAGE_CLOCK and
   INITSTAGE_NETWORK_LAYER_PROTOCOLS.

   Several automatic weak shared module pointers have been added to so simplify
   direct cross module communication via C++ method calls. The added classes are
   called ModuleRef, ModuleRefByGate, and ModuleRefByParameter.

   A new generic C++ compound module class has been added, called OmittedModule,
   which allows optional submodules to be easily omitted by the user via INI
   file parameters without unnecessarily complicating the parent compound module
   structure with several conditionals due to optional connections.

   Several packet serializers have been extended to be more complete in terms of
   being able to serialize packets into network byte order. Most notable changes
   are in the Ipv6HeaderSerializer, and the DsdvHelloSerializer.

   The INET specific FingerprintCalculator class has been refactored and made
   official. This fingerprint calculator supports computing a fingerprint that
   contains all packet data and timestamps on the network.

   The usage of transmissionStarted, transmissionEnded and receptionStarted,
   receptionEnded signals have been extended to the new wired physical layer
   models.

   Many models have been updated to use the new scheduleAfter(), rescheduleAt(),
   and rescheduleAfter() methods that were introduced in the OMNeT++ API.

   The generic MessageDispatcher has been extended to support the new packet
   streaming API. It has also been enhanced to have better circular connection
   detection and error reporting.

   All Enter_Method_Silent() calls have been replaced with Enter_Method() because
   Qtenv has been extended with filter expressions for the method call animation,
   which provides a better control.


INET-4.2.10 (April 2022) - Stable
---------------------------------

Several minor bugfixes plus some compatibility fixes for OMNeT++ 6.0.
OMNeT++ 6.0 Preview and RC versions are NOT supported.

  - simplified findInterfaceByAddress() and findHostWithAddress(),
    uses NetworkInterface::hasNetworkAddress()
  - Replaced duplicate implementations of findInterfaceByAddress and
    isLocalAddress in RoutingTables
  - Changed initial values of simtime_t fields to -1 instead of NaN, because
    double NaN cannot be converted to simtime_t.
  - Replaced deprecated init() to new init(Context* ctx) in ResultFilters.
  - Fixed #747: Avoid division by zero causing scheduling a message to 
    infinite simulation time.
  - Fixes for change in OMNeT++ 6 where uniform(a,b) now expecting a <=b
  - backported inet_fingerprinttest script from master
  - voipstream: use libswresample instead of libavresample (backported from master)
  - Various smaller bigfixes and optimizations


INET-4.2.9 (February 2022) - Stable
-----------------------------------

This release contains compatibility fixes for OMNeT++ 6.0 and a few backported
fixes from the INET 4.3.x branch. Requires OMNeT++ 5.7 or 6.0rc1.


INET-4.2.8 (November 2021) - Stable
-----------------------------------

This release contains compatibility fixes for OMNeT++ 6.0 and a few backported
fixes from the INET 4.3.x branch. Requires OMNeT++ 5.7 or 6.0 preview 14.


INET-4.2.7 (October 2021) - Stable
----------------------------------

This release contains compatibility fixes for OMNeT++ 6.0 Preview 13
and OMNeT++ 5.7. (Earlier OMNeT++ 6 versions WILL NOT work.)


INET-4.2.6 (Sept 1, 2021) - Stable
----------------------------------

This release contains compatibility fixes for OMNeT++ 6.0 Preview 12 and
OMNeT++ 5.7 Preview 1. This release WILL NOT work with OMNeT++ 5.6.x or 6.0pre11
or earlier. If you want to use those versions, please use INET 4.2.5.


INET-4.2.5 (May 18, 2021) - Stable
----------------------------------

This release contains:

  - Compatibility fixes for OMNeT++ 6.0 Preview 11.
  - Fixed default type names for 802.15.4 transmitter and receiver.
  - Fixed worng statechange signal in Radio
  - Fixed crash in rare cases when accessing receptionTimer.


INET-4.2.4 (May 6, 2021) - Stable
---------------------------------

This release contains fixes for linker errors on Windows.


INET-4.2.3 (April 22, 2021) - Stable
------------------------------------

This release contains compatibility fixes for OMNeT++ 6.0 Preview 11.


INET-4.2.2 (January 7, 2021) - Stable
-------------------------------------

This release contains a fix to build properly on Windows with OMNeT++ 6.0 Preview 10.


INET-4.2.1 (October 2020) - Stable
----------------------------------

This release contains a compatibility fix to be able to build INET with
OMNeT++ 6.0 Preview 9. It requires OMNeT++ 5.4.1 or later.

NOTE: OMNeT++ 6.0 Preview 5-8 will NOT work with this releasre. Use INET 4.2.0
with those versions or rather upgrade your OMNeT++ installation.


INET-4.2 (January 2020) - Stable
--------------------------------

This is a new minor stable release of the INET 4.x branch. This version includes
a few important new features, some backward incompatible changes, a number of small
improvements, and several bug fixes. This version requires OMNeT++ 5.5.1 or later.

Notable backward incompatible changes are the following:

1. Representation of radio signals

   The multidimensional (in terms of space, time, and frequency) analog domain
   representation of radio signals in the physical layer has been substantially
   changed. The old multidimensional mathematical function implementation, which
   was originally inherited from MiXiM, has been replaced with a completely new
   implementation. The reason behind this change is that the old implementation
   had several non-trivial open bugs, it was often 10+ times slower than the
   equivalent scalar signal representation, and due to its iterator-based API
   and its eager computational nature, it was less composable and extensible.

   The new implementation is capable of representing all kinds of radio signals
   such as OFDM, FHSS, UWB, etc. It also allows mixing these wireless technologies
   arbitrarily. The new API is more flexible in terms of composition, and it
   allows arbitrary extensions to be combined with existing representations.

   The new implementation has better performance than the old one both in terms
   of memory usage and execution speed. Thanks to the usage of shared pointers,
   it scales well to large networks with a small memory footprint and is easy
   to maintain and use. It also has comparable execution speed to the equivalent
   scalar signal representation. Futhermore, it allows the visualization of the
   power spectral desnsity of individual signals and the transmission medium in
   Qtenv.

   Simulation models which use the old C++ API will not compile, and need to be
   updated.

   The transmitter timeGains and frequencyGains NED parameters, which determine
   the signal power over time and frequency, have been changed in the various
   dimensional radio models. The new synax is more expressive and more user
   friendly. The changed interpretation of these NED parameters will cause
   an error in existing simultations that use it.

   See the presentation from the OMNeT++ Community Summit 2019:
   https://summit.omnetpp.org/2019/assets/pdf/math.pdf

2. Queueing model

   A new top-level source folder containing a new queueing model package has
   been added. The new queueing model provides reusable modules for various
   application areas. These modules can be used to build application traffic
   generators, queueing models for MAC protocols, traffic conditioning models
   for quality of service implementations, and so on.

   The queueing model contains several different kinds of elements: sources,
   sinks, queues, buffers, filters, servers, classifiers, schedulers, etc.
   Some of the queueing elements were already present in INET, but most of them
   are written from scratch. The most important change is that the queueing model
   became synchronous by default, primarily in order to avoid event race conditions
   in complex queueing models, and also to increase performance by eliminating
   simulation events. The User's Guide has been extended with a relevant chapter.

   This change results in compilation errors and NED errors in simulation models
   which use the old queueing model. You may look at changes to existing MAC
   protocols to see how to update your code.

3. MAC protocols and DiffServ

   All MAC protocols have been updated to use the new queueing model for their
   transmission queues in a very similar way. All protocols have been extended
   with a replaceable queue submodule, even in the default case, so there's no
   internal queue anymore. Different queue length parameters have been removed
   from MAC modules, because complex transmission queues may have all sorts of
   parameters rendering the MAC queue length parameters useless.

   The DiffServ implementation has also been updated to use the new queueing model.

   These changes may cause existing models to silently produce different simulation
   results, because some module parameters such as txQueueLimit and queueLength
   MAC protocol parameters no longer exist.

4. Packet API

   The interpretation of the Chunk API length parameter for negative values has
   been changed in the peek() and has() functions. The old version interpreted
   the value -1 as any length. The new version interprets negative values as any
   length up to the absolute value of the parameter. The change was required to
   properly implement the Chunk serialization API for all edge cases.

   This change may result in incorrect behavior silently if the -1 parameter
   value was used explicitly. Generally, that is not expected to cause a problem
   because these APIs are not normally used in models.

   The non-template versions of peekAtBack(), popAtBack(), and removeAtBack()
   in the Packet class has been changed to require the length parameter. The
   reason being that deserialization is only supported forwards, so there's no
   way of knowing the length when a raw packet is used.

   This change may result in compilation errors in existing code.

5. IEEE 802.11 (WiFi)

   The IEEE 802.11 model has been changed to have explicit modules for both the
   PendingQueue and the InProgressFrames. Futhermore, several submodules of the
   Hcf module have been moved to the Edcaf module to better reflect their usage.

   Throughout the 802.11 model has also been extended with several new signals
   and statistics. The ACK handling mechanism in QoS mode has been fixed.

   Several parts of the IEEE 802.11 frame have been renamed to be consistent with
   the naming scheme:

   Ieee80211DataFrame -> Ieee80211DataHeader
   Ieee80211DataOrMgmtFrame -> Ieee80211DataOrMgmtHeader
   Ieee80211ManagementHeader -> Ieee80211MgmtHeader
   Ieee80211ManagementFrame -> Ieee80211MgmtFrame
   Ieee80211Frame -> Ieee80211MacHeader
   Ieee80211OneAddressFrame -> Ieee80211OneAddressHeader
   Ieee80211TwoAddressFrame -> Ieee80211TwoAddressHeader
   Ieee80211ACKFrame -> Ieee80211AckFrame
   Ieee80211RTSFrame -> Ieee80211RtsFrame
   Ieee80211CTSFrame -> Ieee80211CtsFrame

   Most simulations are not affected, because the external interface of the
   802.11 MAC has not been changed. Nevertheless, simulations which go deeper
   in the direct parameterization of the 802.11 MAC submodules have to be
   updated.

6. Transmission medium

   The storage mechanism of radios and transmissions has been moved from the
   radio medium module to the communication cache submodule. This allows the
   usage of different strategies for different kinds of networks. For example,
   a dynamic network where radios are created and destroyed dynamically can
   have better performance with a non-default mechanism.

   This change results in compilation errors if the underlying C++ interfaces
   were implemented in user code.

7. Variuos renames

   The carrierFrequency parameters have been renamed to centerFrequency in several
   modules where they were named incorrectly.

   With the addition of the new Ospfv3 implementation, the old OSPF implementation
   has been renamed from Ospf to Ospfv2.

   These changes may require updating the affected simulations.

Notable backward compatible changes are the following:

1. OSPF version 3

   A new OSPF protocol implementation has been added which implements version 3
   of the protocol.

   This feature is a contribution of Lukáš Galbička and Marcel Marek.

2. TCP/IP ECN

   The TCP/IP model has been extended with partial support for Explicit
   Congestion Notification (ECN).

   This feature is a contribution of Marcel Marek and Mohammad HabibAllah.

3. TTL and ToS in sockets

   The UDP and TCP socket options have been extended with time-to-live and
   type-of-service parameters.

   This feature is a contribution of Mani Amoozadeh.

4. Packet API

   The Packet API has also been extended with a PF_ALLOW_EMPTY flag to support
   returning Empty chunks. This feature makes certain algorithms easier to write,
   because the user doesn't have to check for nullptr all over the place.

   The PacketDissector::ICallback interface has been extended with a new callback
   called shouldDissectProtocolDataUnit() for the possibility to stop dissection
   for performance reasons.

5. Physical layer components

   The physical layer dimensional model has been extended with a new NoiseSource
   and a new DimensionalBackgroundNoise module. The former is capable of generating
   noise periodically as a point source with optional mobility. The latter can
   be used to describe a non-isotropic background noise which changes over time
   and frequency.

6. Visualization of radio signals

   The MediumCanvasVisualizer has been extended with the visualization of signal
   power spectrums, signal power spectrograms, and signal power maps. Spectrum
   figures display signal power density over frequency at a given position and
   moment of time. Spectogram figures display signal power density over time and
   frequency at a given position. Power map figures display signal power density
   over space at a given frequency and moment of time.

   All three kinds of figures can be used to display a particular signal or the
   total power density of transmission medium. The new visualization is also
   capable of displaying the above for the currently transmitted or received
   signal automatically while simultaneously comparing it to the total interfering
   signals and noise using color coding. The visualization takes into account the
   directional selectivity of radio antennas.

   A new "network node", called the Probe, allows the visualization of the total
   transmission medium power spectral density at any given location. The latest
   Qtenv supports dragging network nodes with Shift + left mouse click. This
   feature effectively allows the user to explore power spectral density in space
   by simply dragging a probe node.

   See the following example videos:
   https://www.youtube.com/watch?v=oyjX03MSi7s
   https://www.youtube.com/watch?v=Oi1sq23IPYs
   https://www.youtube.com/watch?v=TyYQ53hUrns

7. Visualization of street maps

   The new OpenStreetMapSceneCanvasVisualizer allows displaying an arbitrary
   street map file created by OpenStreetMap as the background of a compound
   module. The configuration is simple: the visualizer takes the map filename
   parameter and the geographic coordinate system takes longitude/latitude
   parameters to specify the origin of the scene.

8. Applications parameterized with traffic generators

   New generic TCP and UDP applications such as UdpApp, TcpClientApp, TcpServerApp
   have been added with composable traffic source and traffic sink components.
   One can implement new behavior by assembling queueing elements. For example,
   new applications can be easily set up to simulate request-response based
   client-server applications (see TcpRequestResponseApp), or a remote terminal
   (see TelnetClientApp/TelnetServerApp).

9. Module initialization

   A new named initialization stage, called INITSTAGE_ROUTER_ID_ASSIGNMENT, has
   been added. The configuration of the router ID has been moved to this stage.

10. Packet serialization and emulation

    New chunk serializers have been added for several protocols. Changed several
    protocol field types and names in MSG files to be more correct. Fixed and
    refactored CRC calculation, CRC mode parameters and handling, CRC insertion
    and verification. Of course, the exact CRC calculation and verification are
    still optional due to performance reasons.

    These changes make the emulation support more feature complete. Most of the
    example simulations are expected to work with serialized packets too. This
    can be simply tested by running the fingerprint tests with the sendRawBytes
    parameters of network interfaces set to true.

11. Regression testing with fingerprint calculation

    A special fingerprint calculator (NetworkCommunicationFingerprintCalculator)
    has been added, which is capable of computing a simulation fingerprint using
    the timing and binary contents of packets sent between network nodes. This
    feature allows easier regression testing for some simulation models if the
    exchanged packets are expected to stay the same. This kind of fingerprint
    ignores all internal details of how the network nodes operate.

12. Documentation

    The User's Guide has been extended with a new chapter on the newly added
    queueing package. It has also been updated with respect to the new generic
    applications.

    A new queueing model tutorial has been added. This tutorial contains very
    minimal explanation, it is rather provided to give a quick glance.

    The tutorial is available at:
    https://inet.omnetpp.org/docs/tutorials/queueing/doc

13. Other minor changes

    Module shutdown operation has been refactored and extended in simulation
    time to allow for graceful closing of TCP connections.

    PCAP recording has been enhanced with automatic network type detection and
    optional packet conversion.

    New PRE and POST module initialization signals have been added for dynamic
    module creation.

    A new WeightedHistogramRecorder has been added which records histograms using
    weighted double values.

    The packet inspector has been enchanced to display the front, back, and data
    parts of packets separately in Qtenv. Furthermore, packet tags and data tags
    are also displayed in children mode.

    All applications have been extended for CreationTimeTag to calculate end-to-end delay.
    Several applications have been extended with ToS and DSCP parameters.
    The ManetRouter has been extended with a parameterizable routingApp submodule.
    The InterfaceEntry module base has been added to all interface modules.
    The MAC protocol base classes have been merged into one.
    Extended the <disconnect> and <set-channel-param> commands in ScenarioManager.
    Added OpenMP support to allow parallel computation for physical signal visualization.
    Added notifications about changing the InterfaceProtocolData set to InterfaceEntry.
    Added TcpSocket::ReceiveQueueBasedCallback to make writing applications easier.

    Fixed small packet and chunk length discrepancies in several protocols.
    Fixed TCP SACK rexmit queue inconsistency by Luca Giacomoni.
    Fixed several memory leaks.

    Numerous other bug fixes and small improvements.


NET-4.1.2 (November 2019) - Stable
------------------------------

- Fixes to build with OMNeT++ 6.0, too.


INET-4.1.1 (May 2019) - Stable
------------------------------

- A minor fix to build with OMNeT++ 5.5, too.


INET-4.1 (January 2019) - Stable
--------------------------------

This is a new minor stable release of the INET 4.x branch. It comes with some
backward incompatile changes, a few new features, a number of smaller improvements,
and many bug fixes. This version requires OMNeT++ 5.4.1 or later.

The backward incompatible changes are the following:

1. The module initialization stages have been refactored. All stages with numbers
   in their names (e.g. INITSTAGE_LINK_LAYER_2) have been removed, because their
   intended purpose was not clear, and they were often misused. Several new stages
   have been added to replace the removed stages. The new stages have names which
   express better the specific purposes they are used for (e.g. INITSTAGE_POWER,
   INITSTAGE_GROUP_MOBILITY, INITSTAGE_NETWORK_INTERFACE_CONFIGURATION).

   This change most likely results in compilation errors in simulation models
   which use the affected initialization stages. It may also cause runtime errors
   if the stage name has not been changed but its usage is slightly modified.

2. Individual protocol specific data structure fields of InterfaceEntry (e.g. the
   ipv4Data field with type Ipv4InterfaceData stores IP address and netmask) have
   been removed and replaced with a generic API. The new API allows storing any
   number of arbitrary protocol specific data structures in the network interface
   similarly to packet tags. All affected protocols have been updated.

   This change always results in compilation errors in affected simulation models.

3. The old ExtInterface module (used for emulation) has been split into several
   modules. There are separate modules for using simulated network interfaces from
   the host OS, and also for using host OS network interfaces from the simulation.
   The new external interfaces no longer rely on PCAP, they rather use host OS
   raw sockets and TUN/TAP interfaces. Besides ethernet, the new version also
   provides IEEE 802.11 network interface emulation. A new external UDP protocol
   module is also added, which allows INET applications to be tested unmodified
   on real networks using the UDP protocol of the host OS.

   This change results in runtime errors in simulations which use the modified
   models. Configuration of affected simulations have to be updated.

4. Replaced EulerAngles with Quaternion to represent orientation (and angular
   velocity, and angular acceleration) in mobility models to avoid gimbal lock
   and ambigous state representation. Euler angles are easy for human consumption
   but they are generally considered a bad idea for representing 3D orientation.

   This change always results in compilation errors in affected simulation models.

5. Moved MAC address parameters from MAC modules to the corresponding network
   interface modules (e.g. EtherMac -> EthernetInterface). The reason is that
   MAC address really belongs to the network interface and often management or
   other network interface submodules need access to it.

   This change results in runtime errors in simulations which use the modified
   parameters. Configuration of affected simulations have to be updated.

The backward compatible changes are the following:

6. Many applications have been extended with support for lifecycle operations.
   Applications can be started, stopped, and crashed individually using the same
   ScenarioManager script which is also used to control the lifecycle operations
   of network nodes. These applications also subclass from a common ApplicationBase.
   Similarly to applications, network interfaces also support lifecycle operations,
   they can be brought down and up using the ScenarioManager.

7. Two new protocol groups (for UDP and TCP) have been added which allow the
   identification of application protocols based on port numbers. The application
   protocols may not even be implemented in INET, yet they can still be identified
   (e.g. when using emulation) and displayed in the Qtenv packet log window.

8. The PacketPrinter has been extended with a new type column which contains
   the protocol specific packet type (e.g. ECHO_REQUEST for ICMPv4). The packet
   type is contributed by the protocol specific packet printer. This feature helps
   understanding packet logs in Qtenv. With the new version, the printer is also
   capable of providing a reasonably good enough packet name for packets received
   from external sources (e.g. an external network interface during emulation).

9. Modules that provide emulation support have been extended with a new host OS
   network namespace parameter. This feature allows, for example, running multiple
   linux BABEL daemons in their own network namespaces (with their own routing
   tables etc.) and connecting each one to the same simulation which provides
   mobility and wireless connectivity. For another example, it allows connecting
   multiple docker containers running in separate network namespaces again to
   the same simulation. Unfortunately, the network namespace feature is only
   available on Linux at the moment.

10. Added two new socket classes, EthernetSocket and Ieee8022LlcSocket, which
    allow applications to directly use the link layer protocols on a particular
    network interface. For example, an application can send and receive ethernet
    frames directly, bypassing network and transport layer protocols.

11. Added IEEE 802.1Q VLAN tag (C tag and S tag) support to ethernet interfaces.
    Virtual ethernet networks can be statically configured using ethernet interface
    parameters of switches and hosts. Additionally, all network nodes can have
    any number of virtual network interfaces which can be configured to request
    VLAN tagging. This feature allows using multiple different virtual networks
    on the same physical network on a per-application basis.

12. Raphael Riebl contributed support for ether type discrimantion for IEEE 802.11p
    networks in the 5.9 GHz band. The new modules provide both IEEE 802.11 EPD and
    IEEE 802.11 LPD as required by the standard. The LLC module is automatically
    selected based on the opMode and band parameters.

13. Mani Amoozadeh contributed several new features and fixed quite a few bugs
    in BGP and OSPF wired routing protocols. Among others, BGP has been updated
    related to split horizon, multi-hop EGBP, network interface mode parameters,
    packet checksum calculation, packet serialization, and multiple additional
    parameters to turn on/off individual protocol features. Similarly, OSPF has
    also been updated related to BDR promotion, network interface mode parameters,
    packet checksum calculation, and packet serialization. He also validated the
    INET models by comparing simulation runs with the CISCO packet tracer tool
    for many important use cases.

14. Other notable changes

    Updated a few mobility models to provide better parameterization for 3D.

    Added ClnsAddress and ClnsAddressType from ANSA project.

    Added a new antenna model for rotationally symmetric antenna lobes.

    Added linear and logarithmic antenna lobe visualization.

    Extended IPv4 network configuration with support for configuring isolated networks.

    Fixed several smaller issues related to 802.11 block acknowledgement and QoS recovery procedures.

    Numerous other bug fixes and small improvements.


INET-4.0 (June 2018) - Stable
-----------------------------

This is the first stable release of the new INET 4.x branch. All originally
planned tasks have been completed. This version requires OMNeT++ 5.4.1 or later.

With the new INET 4.0 release, the development of the old INET 3.x branch is
stopped. Users are strongly encouraged to use the new INET 4.0 version for new
projects and also for migrating existing projects. Admittably, migration is not
trivial, but there's an 'INET 4.0 Migration Guide' to help with the task under
the 'doc/misc' folder.

The main changes of the new INET 4.0 major stable release are:

1. Packet API

   The INET Packet API has been completely redesigned to supports efficient
   construction, sharing, duplication, encapsulation, aggregation, fragmentation,
   and serialization of packets.

   The new Packet API also adds many other useful features such as a detailed
   packet printer, a packet dissector, a packet filter based on packet data,
   packet tags for cross-layer communication, region tags for attaching metadata
   to packet data, and queueing and buffering packet data.

   The new Packet API also makes implementing communication protocols easier. The
   resulting code looks more similar to the real world implementation. Supporting
   emulation is pretty much trivial when implementing communication protocols.

   For more details on how to use the new Packet API, see the 'INET Developer's Guide'.

2. Network node architecture

   The internal structure of network nodes has been changed considerably. With
   the new architecture, applications can directly talk to any protocol down to
   the link layer, and protocols don't have to deal with dispatching packets and
   commands to other protocols. Cross-layer communication is directly supported
   in both downward and upward directions.

   For more details on how to use the new architecture, see the 'INET User's Guide'.

3. Documentation

   The somewhat outdated 'INET Framework for OMNeT++ Manual' has been reworked
   and split into the 'INET User's Guide' and 'INET Developer's Guide'. Several
   new detailed showcases have been added and many have been updated, they are
   available on the INET website.

The highlights of this release since the last development release are:

1. Socket API

   The Socket API has been redesigned and uniformized. All sockets can be used
   with similar callback interfaces. All callback functions receive the socket
   object as a parameter to allow handling multiple sockets concurrently.

   New raw Ipv4Socket and Ipv6Socket classes have been added to directly access
   the IPv4 and IPv6 protocols from applications.

2. Module type parameters

   All string NED module parameters, which were used to specify submodule types,
   have been replaced with the standard OMNeT++ typename parameter. This reduces
   the confusion caused by having two different configuration options for the
   same task. The typename parameter is also simpler and more generic in the
   sense that it allows configuring the module type for submodule vector elements.

   The replacement of the EthernetInterface queueType and the Ieee80211Interface
   agentType parameters requires the applications which use them to be updated.
   The queueType parameter had effect on the dataQueueType of the EtherQosQueue,
   which is no longer true. The agentType parameter depended on the mgmtType
   parameter, which is also no longer true. These parameters must be set separately.

3. NED units

   With the new OMNeT++ 5.4 release, INET supports the automatic conversion of
   non-linear units such as dBm, dBW to W, dB to ratio, etc. All 0/0 and +-1/0
   parameter value assignments have been replaced with nan and +-inf respectively.

4. Various renames

   Renamed several modules, submodules, classes, interfaces, etc. to be consistent
   with the INET naming conventions:

    - GenericNetworkProtocol module -> NextHopForwarding
    - generic folder -> nexthop
    - gnp submodule -> nextHop
    - InterfaceEntry get/setNextHopProtocolData functions -> get/setNextHopData
    - Protocol::gnp global variable -> Protocol::nextHopForwarding
    - NextHopDatagram class -> NextHopForwardingHeader

    - RsvpRouter module -> RsvpMplsRouter
    - LdpRouter module -> LdpMplsRouter
    - Rsvp module -> RsvpTe.
    - rsvp_te folder -> rsvpte
    - Protoco::rsvp global variable -> rsvpte.

5. Packet error representation

   The physical layer error models have been extended with a corruption mode
   parameter. The available corruption modes are: packet, chunk, byte, or bit
   level. The parameter determines on what level the error model introduces
   errors into a packet.

   In many protocols, various corruption modes don't lead to different outcome.
   Nevertheless, this change allows implementing IEEE 802.11 A-MPDU aggregation
   with support to only dropping the individual subframes which are received
   incorrectly.

6. IEEE 802.11

   Thanks to Alfonso Ariza Quintana, the 802.11/ac (VHT PHY) modes have been
   added to physical layer. Futhermore, the necessary 5GHz bands with 20, 40,
   80, and 160 Mhz bandwidth have also been added.

   The 802.11 mode lookup mechanism has been extended with bandwidth and number
   of spatial streams parameters, and the mechanism has also been relaxed to
   allow specifying more already supported bitrates (e.g. 86.7 Mbps with 0.1 Mbps
   precision).

   Fixed bug when a packet was received from another Ap and sent up incorrectly.
   Fixed ACK frame duration bug reported by Raphael Elsner.
   Fixed exploded frame transmitter address in MsduDeaggregation.
   Fixed length field wrap around for large packets.
   Fixed center frequency calculation in Ieee80211ArithmeticalBand.

7. Emulation

   The whole emulation support, including the ExternalInterface compound module,
   the Ext simple module, and the corresponding cSocketRtScheduler have been
   redesigned and heavily refactored. The new C++ scheduler class is called
   RealTimeScheduler and it is completely independent of the external interfaces.

   The new scheduler still provides real time simulation execution, but it also
   allows for using the POSIX select mechanism to support I/O operations with
   file descriptors. The external interface hooks into this mechanism to read
   raw packets via PCAP. Futhermore, the new external interface implementation
   uses dedicated raw sockets to send packets.

8. Lifecycle and scenario management

   The LifecycleController module has been removed because the module did not
   have and is not expected to have any parameters in the future. Therefore the
   LifecycleController module is no longer needed in the network for the lifecycle
   operations to work. The corresponding LifecycleController C++ class with the
   actual functionality remains there.

   The ScenarioManager scripting has been extended with the following shortcuts
   for the lifecycle operations:
    - <shutdown module="hostA"/>
    - <startup module="hostA"/>
    - <crash module="hostA"/>

9. RIP

   Thanks to the contributions of Mani Amoozadeh the RIP protocol has been
   refactored to store the protocol specific route data in the routing table
   instead of an internal data structure. The protocol has also been extended
   with new hold-down timer and triggered update parameters.

   Fixed sending updates on interface which is down.

10. Other notable changes

    The Ethernet model has been extended with 200 Gbit and 400 Gbit modes.

    The antenna directional selectivity computation in wireless medium analog
    models has been fixed.

    Several missing protocol dissectors and protocol printers have been added.

    All protocol specific header serializers have been moved to the folder of their
    respective communication protocol.

    In order to suppor more recent OSG Earth versions, the osgEarth::ObjectLocatorNode
    has been replaced with GeoTransform and osg::PositionAttitudeTransform.


INET-3.99.3 (April 2018) - Development
--------------------------------------

This is planned to be the last development release of the upcoming INET-4.0 version.

All originally planned refactorings have been completed, and we don't expect too many
changes until the final version is released. This version requires OMNeT++ 5.3 or later.

The highlights of this release are:

1. Documentation

   The somewhat outdated 'INET Framework for OMNeT++ Manual' draft has been split
   into two documents. One is called the User's Guide and the other one is called
   the Developer's Guide. The reason for the split is that the two documents have
   different target audiences, and they focus on introducing different aspects of
   the INET Framework.

   The User's Guide is intended for users who are mainly interested in assembling
   simulations using the existing components provided by the INET Framework. In
   contrast, the Developer's Guide is intended for developers who are mainly
   interested in developing their own protocols as an addition to the INET
   Framework. Both guides are work in progress, but many parts have been added,
   deleted, and rewritten compared to the old manual.

2. Packet API

   The packet API has been finalized. Several Packet and Chunk functions have been
   renamed for better consistency and more clarity. Affected C++ class level and
   function level documentation has been updated.

   For more details, see the related patch at:
   https://github.com/inet-framework/inet/commit/cf00e516f318893de5f396a498eb11592d8dd1b9

3. Packet dissector

   The packet API has been extended with a new packet dissector API. The packet
   dissector analyzes a packet solely based on the assigned packet protocol and
   the data it contains. The analysis is done according to the protocol logic as
   opposed to the actual representation of the data. The packet dissector works
   similarly to a parser. Basically, it walks through each part (such as protocol
   headers) of a packet in order. For each part, it determines the corresponding
   protocol and the most specific representation for that protocol.

   The packet dissector is mostly implemented in the PacketDissector C++ class.
   It relies on small registered protocol-specific dissector classes such as the
   Ipv4ProtocolDissector. User defined protocols can register their own protocol
   dissector classes to extend the functionality of the generic packet dissector.

4. Packet filter

   Filtering packets based on the actual data they contain is a long time missing
   functionality of INET. With the help of the new packet dissector API, it is
   very simple to create such packet filters.

   In order to simplify filtering, INET provides a new generic expression-based
   packet filter implemented in the PacketFilter C++ class. The expression syntax
   is the same as other OMNeT++ expressions, and the data filter is matched against
   individual parts of the packet as found by the packet dissector. For example,
   the expression "inet::Ipv4Header and srcAddress(10.0.0.*)" matches all packets
   that contains an IPv4 header with a '10.0.0' source address prefix.

5. Packet printer

   Based on the new packet dissector, the INET packet printer has been reworked.
   The new packet printer is implemented in the PacketPrinter C++ class. It relies
   on small protocol specific printer classes to form the user readable string
   representation. User defined protocols can register their own protocol printer
   classes to extend the functionality of the generic packet printer.

   With the OMNeT++ 5.3 version the message printer API has been changed to provide
   support for ANSI escape sequences for styling, and for options. The new INET
   packet printer allows showing/hiding columns and control various printing
   features from Qtenv. The new packet printer provides the following columns in
   Qtenv: 'Source', 'Destination', 'Protocol', 'Length', and 'Info' similarly to
   the well-known Wireshark protocol analyzer. The info column for simple packets
   is assembled inside-out in terms of protocol nesting, but for more complicated
   packets (e.g. ones using aggregation) it is assembled left to right.

6. Packet tags

   With the OMNeT++ 5.3 version, the old experimental API for attaching tag objects
   to packets is no longer available. Meanwhile INET has been extended with a very
   similar, although not exactly source code compatible API.

   The most important consequence is that cMessage and cPacket instances cannot
   have tags attached any more. In order to make dispatching non-packet messages
   between protocols still possible, two new cMessage subclasses called Request
   and Indication have been introduced. Protocols send instances of said classes
   to request services from other protocols or indicate status changes to other
   protocols.

7. SCTP

   With this new release, SCTP, the last remaining protocol, has also been
   ported to the new packet API.

   Many thanks to Irene Rüngeler for her valuable contribution.

8. Packet drill

   The last remaining application has also been ported to the new packet API.
   This application is heavily used for testing UDP, TCP, and SCTP transport
   protocols. All tests under the packetdrill folder pass.

9. Mobility

   Throughout the mobility API and implementation, speed has been renamed to
   velocity where appropriate. The reason is that speed is generally considered
   a scalar quantity whereas velocity is considered a vector quantity.

   The documentation of orientation has been updated to clarify how exactly it
   is meant to be understood. As a somewhat related change, the double type of
   angles in mobility models and geographic positioning (longitude, latitude)
   has been replaced with compile-time checked C++ types called rad and deg for
   clarity.

   New mobility models have been added, some of which allow the combination of
   existing mobility models. The SuperpositioningMobility combines the trajectory
   of several other mobility modules using superposition. The AttachedMobility
   provides a mobility that is attached to another mobility at a given offset.

10. Various renames

    All network interfaces have been renamed to have 'Interface' suffix in their
    names. All signals having the old 'NF_' (obsolete NotificationBoard) prefix
    in their names have been renamed according to the new INET signal naming scheme.
    Moreover, many functions have been renamed (e.g. camel case) to use the INET
    C++ naming scheme.

11. Visualization

    Physical transmission medium, data link and physical link, network path, and
    packet drop visualizers have been extended with the new packet data filtering.
    This allows, for example, to configure several network path visualizers within
    an IntegratedMultiCanvasVisualizer to display the path of packets with certain
    destination addresses differently.

12. PCAP recording

    Similarly to visualization, PCAP recording has also been extended with the
    new packet data filtering. This allows recording only certain packets in a
    PCAP file, which results in drastically reduced file size and significantly
    increased performance.

13. Other notable changes

    The protocol registration C++ interface has been changed to provide better
    support for the message dispatching mechanism. The result is that protocols
    and MessageDispatcher modules can be connected in more flexible ways. In fact,
    MessageDispatchers now only have one gate vector to connect to, they learn
    where protocols are and act accordingly. Network nodes are free to connect
    protocols directly or by using one or several MessageDispatchers as they see
    fit.

    The physical environment ground model has been extended with a new OSG based
    OsgEarthGround model which uses the elevation data of the map. The ground models
    have been also extended with the computation of the ground normal vector.

    Some globally registered protocol identifiers (e.g. Protocol::ieee80211) have
    been split into separate PHY, MAC, and MGMT protocols to disambiguate packet
    parts for the packet dissector. This only affects the registered protocol
    identifiers, actual protocol implementations are unaffected.

    Several MSG file customizations (i.e. @customize) have been refactored or
    eliminated altogether by using the new MSG compiler features of OMNeT++. The
    main purpose is to simplify MSG files, remove unnecessary C++ customizations,
    and to ease understanding and maintaining these files.

    Potential infinite loop in the GPSR MANET routing has been fixed.


INET-3.99.2 (December 2017) - Development
-----------------------------------------

This release is the next development snapshot of the upcoming INET-4.0 version.

The code is still work in progress, which means some details may change until the
final 4.0 version is released. This version requires OMNeT++ 5.3.

The highlights of this release are:

1. New MSG file format

   The new OMNeT++ 5.3 release contains a new version of the MSG compiler. The
   new MSG compiler comes with an updated MSG file syntax which provides several
   very useful improvements. The most notable one is the introduction of import
   statements. The new MSG compiler is not enabled by default in OMNeT++ 5.3 for
   backward compatibility.

   INET heavily relies on using MSG files, so we decided to switch to the new
   syntax. All MSG files have been updated resulting in much simpler content.

   The most notable MSG file changes are:

    - added import statements
    - switched to proper pointer support
    - deleted early declarations
    - moved several properties from fields to types
    - removed many cplusplus blocks
    - removed many unnecessary typedefs

2. Renamed camel case for abbreviations

   Many INET protocol implementations use several capitalized abbreviations to
   shorten long technical terms. Often these abbreviations are concatenated
   resulting in hardly understandable sequence of capital letters. Some notable
   examples are: AODVRERR, OSPFLSA, PIMDM, etc. Many protocol implementations
   also use identifiers which concatenate camel case words with capitalized
   abbreviations making understanding even more difficult. Some notable examples
   are: TCPSACKRexmitQueue, RTCPSDESPacket, OSPFDDOptions, etc.

   We decided to use a generic camel case naming scheme for the identifiers in
   INET. The most important change is that capitalized abbreviations are simply
   treated as words. Using a generic naming scheme makes INET look more consistent.
   All C++ class names, NED module names, packet class names, etc. have been
   updated according to the new naming scheme.

3. Fixed misnomers

   Some misnomers have been fixed to avoid confusion and to better communicate
   the intended goal and behavior of the affected components.

   The most notable renamed C++ classes, modules, and related packet headers are:

    - Csma -> Ieee802154Mac
      This rename was brought up at the 4th OMNeT++ Community Summit. The main
      reason is that the name has to express that this module is intended to
      implement a specific standard (IEEE 802.15.4) as opposed to some generic
      hypothetical protocol. Otherwise maintainers are free to change the code
      however they see fit.

    - BMacLayer -> BMac
    - LMacLayer -> LMac
      These renames simply remove an unnecessary word that hardly adds anything
      to the meaning. The word layer is not used anywhere else in INET modules,
      this was a leftover after migrating the protocols from MiXiM.

    - IdealMac -> AckingMac
      This rename is admitting that this MAC protocol is not ideal in any way.
      In fact, this trivial MAC protocol isn't a real medium access protocol at
      all. This is primarily useful for sitations where the MAC protocol is not
      to be simulated in detail. It doesn't provide carrier sense mechanism,
      collision avoidance, or collision detection. The only MAC feature it provides
      is optional out-of-band acknowledgement, hence the name.

    - IdealRadio -> UnitDiskRadio
      This rename is simply admitting the fact that this radio implements the
      well known unit disk radio model.

   There are several other related C++ classes and NED modules which have also
   been renamed to follow the above renames. For example, IdealRadioMedium ->
   UnitDiskRadioMedium, etc.

4. New models

   Some existing MAC protocols didn't have a predefined wireless interface module
   which may prevented users to find out how to use them.

   - BNic
     This is a wireless interface which uses BMac and ApskScalarRadio by default.

   - LNic
     This is a wireless interface which uses LMac and ApskScalarRadio by default.

   - ShortcutMac
     This module implements a simple shortcut to peer MAC protocol that completely
     bypasses the physical layer.

   - ShortcutRadio
     This module implements a simple shortcut to peer radio protocol that completely
     bypasses the physical medium.

5. Region Tags

   The INET packet API has been extended with region tags. The new region tags
   API is provided by chunks, therefore it's available in packets, queues, and
   buffers. This is an entirely new API that is completely independent of the
   already provided packet tags API.

   Packet tags allow attaching meta information to a packet as a whole. They are
   used inside network nodes to pass information between protocols residing in
   different layers (cross-layer communication). Packet tags don't change when
   new headers are inserted into packets, or when existing headers are removed.

   As opposed to packet tags, region tags allow attaching meta information to a
   region of data designated by an offset and a length. The attached information
   sticks to that data part independently of how the data is stored. Region tags
   are also maintained if the data is queued, buffered, fragmented, or aggregated.

   For example, region tags can be very simply used to measure end to end delay
   in a TCP application. The source application has to attach a creation time
   region tag with the current simulation time to the data before sending it down
   using the TCP socket. The destination application has to query the creation time
   region tag for the data it just received from the TCP socket. The application
   gets a list of creation time region tags in response. Each tag specifies the
   timestamp and the part for which it is attached to. The important thing to note
   here is that all the underlying protocols (including but not limited to TCP,
   IPv4, IEEE 802.11, etc.) may queue, buffer, fragment, aggregate data as they
   see fit. Nevertheless, the region tag API maintains the attached tags as if
   they were individually attached to every single bit. Even if the individual
   subparts are routed using alternative routes in the network.

6. Chunk immutability

   The Packet, ChunkQueue, and ChunkBuffer C++ classes have been changed to
   automatically mark inserted chunks as immutable. Prior to this change it was
   the caller's responsibility to do so, which turned out to be unnecessary.
   With this change the pushHeader and pushTrailer functions have been removed
   from the API, and they have been replaced with insertHeader and insertTrailer
   respectively.

7. Packet drop signals

   All packet drop related OMNeT++ signals have been replaced with the generic
   packetDrop signal. The generic signal always carries a details object with it,
   which describes the packet drop reason and some other data such as a retry
   limit. The main reason for this change is to allow the packet drop visualizer
   to display all packet drops independently of the source and reason.

8. Data link visualization

   The data link activity visualization has been extended with a new feature that
   determines what level of activity is displayed. The supported activity levels
   are the following:

    - service
      The service level data link activity means that arrows are displayed for
      packets going in at the top of the link layer in the source node and going
      out at the top of the link layer in the destination node. (all SDUs)

    - peer
      The peer level data link activity means that arrows are displayed for
      packets processed inside the link layer in the source node and processed
      inside the link layer in the destination node.

    - protocol
      The protocol level data link activity means that arrows are displayed for
      packets going out at the bottom of link layer in the source node and going
      in at the bottom of the link layer in the destination node. (all PDUs)

9. IEEE 802.11 model

   The model has been changed with respect to packet names for A-MSDU aggregated
   and fragmentated packets. Aggregate packets have a name that is a concatenation
   of the names of all the aggregated packets. Fragment packets have a name that
   contains the name of the original packet plus the fragment index. In both cases,
   the restored packets (deaggregated or defragmented) at the other end have their
   names restored.


INET-3.99.1 (November 2017) - Development
-----------------------------------------

This release is the second development snapshot of the upcoming INET-4.0 version.

The code is still work in progress, which means some details may change until the
final 4.0 version is released. At the moment, it requires a modified version of
OMNeT++ 5.1 or 5.2. The modification is distributed as a patch file in the
'misc/patch' folder.

The highlights of this release are:

1. General

 - Dropped obsolete run scripts for individual simulations. The run scripts are
   replaced by a setenv script in the INET installation and separate inet scripts
   in the bin folder. Run 'setenv' once from the shell to setup the environment
   variables, and run 'inet', 'inet_release' or 'inet_dbg' from the simulation
   directory.
 - Removed compatibility macros required for OMNeT++ 4.x builds. This new INET
   version doesn't build with OMNeT++ 4.x versions.
 - Renamed the byte and bit C++ units to B and b respectively. The new names
   were selected to be conformant with the IEC & IEEE unit conventions.
 - Fixed several memory leaks and other minor bugs.

2. Shared pointer

 - Added aliases for std::shared_ptr, std::make_shared, std::dynamic_pointer_cast,
   etc. to support replacing the shared pointer implementation used by the new
   Packet API.
 - Added a new shared pointer implementation (from Boost) called IntrusivePtr.
   The new implementation uses only 1 counter (no weak counter) that is directly
   added to the shared object using inheritance (thus intrusive). This shared
   pointer is not thread safe, so it doesn't use atomic operations to increment
   and decrement counters, but generally that isn't a requirement for simulation.
   According to speed measurements (see tests/speed folder) the release builds
   run 5-10% faster.

3. CRC handling

 - CRC insertion and validation code has been refactored and adapted to the new
   Packet API. This change affects UDP, TCP, IPv4, IPv6, ICMPv4, ICMPv6, Ethernet,
   and IEEE 802.11. The protocol modules have a parameter to control CRC handling.
   They support different CRC operation modes: disabled, declared, and computed.
   Either the disabled (if supported by the protocol) or the computed mode must
   be selected if packets are recorded in a PCAP file.

4. Ethernet

 - Refactored physical layer packet representation and processing
 - Cleaned up MSG files defining ethernet PHY and MAC frames and headers.

5. IEEE 802.2

 - Renamed the global C++ protocol variable to Protocol::ieee8022, and the global
   C++ protocol group variable to ProtocolGroup::ieee8022protocol.
 - Fixed handling incoming packets with bit errors.

6. IEEE 802.11

 - Revived the FCS computation and verification. The FCS computation is optional,
   you can enable it using the 'fcsMode' parameter of the Ieee80211Mac.
 - Fixed rate selection mechanism for control response frames. They must be sent
   with a mandatory rate that is not faster than the rate of the packet for which
   they are a response. If the received packet was not sent with a mandatory rate,
   then they were sent with the highest mandatory rate.
 - Changed 802.11 OFDM error models with respect to the service field. The service
   field is part of the PHY header in terms of bits, but it's sent in the data part
   in terms of symbols.
 - Fixed PHY header length in Ieee80211Radio. Added separate PHY chunks and PHY
   padding bits for completeness. This change doesn't affect the signal duration,
   because it was alrady correctly computed.
 - Added descriptors for several parts for signals, transmissions, modes, bands,
   channels, etc. The new descriptors allow inspecting of the signal meta data
   in the runtime user interface.
 - Extended 802.11 layered error model for packet level simulation.

7. CsmaCa

 - Added 'fcsMode' parameter and FCS computation and verification.
 - Changed headerLength and ackLength to the minimum value, any additional length
   specified is represented by a separate ByteCount chunk.
 - Fixed error caused by receiving an ACK frame with bit errors.
 - Fixed state machine when receiving unexpected frames while trying to transmit one.

8. Netfilter

 - Refactored netfilter hooks so that the new interface functions only get the
   datagram as a parameter. Hook implementations should query and modify the
   packet and/or the attached tags. For example, setting the outgoing interface
   can be done by attaching an InterfaceReq tag.

9. Network interface

 - Added the InterfaceEntry class used by InterfaceTable to the corresponding
   NIC modules, because they represent the same network interface. All network
   interface modules are required to have a @class(InterfaceEntry) property in
   their NED definition. This change also allows one to see the internal state
   of a network interface just by selecting its submodule in the runtime user
   interface.

10. Radio

 - Extracted a separate IAntennaGain interface from the IAntenna interface. This
   change allows the transmissions to carry directional selectivity even if the
   transmitter radio gets destroyed during the propagation of the signal.
 - Changed transmitter lookup to use radio identifier instead of internal pointer
   to fix crashes when the condition described above occurs.
 - Separated simsignals for transmission/reception from radio signal departure/arrival.
   This allows differentiating signals at the receiver which are actually attempted
   to be received as opposed to simply arriving there.

11. MANET routing

 - Adapted all MANET routing protocols (AODV, DYMO, and GPSR) to the refactored
   INetfilter hook interface. Routing protocols query and modify the packet and/or
   the attached tags as they need.

12. TCP

 - Removed obsolete TCP socket 'dataTransferMode' parameter from all implementations.
   Applications don't have to decide upfront between sending byte count based, field
   based, or raw bytes based packets. With the new API, applications can send any
   combination of the above over the same connection.

13. Visualizer

 - Added a new set of integrated visualizer modules called IntegratedMultiVisualizer,
   IntegratedMultiCanvasVisualizer, and IntegratedMultiOsgVisualizer. These modules
   contain a submodule vector of all special purpose visualizers inside as opposed
   to a single instance. This change allows, for example, one to easily configure
   several visualizers to display various aspects of the simulation differently.


INET-3.99.0 (August 2017) - Development
---------------------------------------

This release is the first development snapshot of the upcoming INET-4.0 version.
It contains a number of non-trivial backward incompatible changes compared to the
INET 3.x releases. These changes may require considerable efforts from INET users
to migrate their projects and protocols. The migration may affect INI files, NED
files, and C++ code. Please refer to the INET-4.0 migration guide under 'doc/misc/'
for further details.

The code is still work in progress, which means some details may change until the
final 4.0 version is released. At the moment, it requires a modified version of
OMNeT++ 5.1 or 5.2. The modification is distributed as a patch file in the
'misc/patch' folder.

The highlights of this release are:

1. Redesigned network node architecture

   The internal structure of network nodes has been changed considerably. These
   changes have profound effects on how applications are using protocols, and
   also on how protocols communicate with each other.

   With the new architecture, applications are able to use multiple protocols
   simultaneously, even if the protocols are part of different protocol layers.
   For example, in the old model it was impossible for a StandardHost application
   to use TCP and UDP protocols at the same time. This old restriction has been
   eliminated. Applications can now talk to any protocol (or several protocols),
   even several layers below. The dispatch mechanism necessary for that is now
   built into the new network node architecture.

   Furthermore, protocols don't have to deal with dispatching packets to other
   protocols or applications any more. In the old architecture, many protocols
   (e.g. IP) implemented their own mechanisms to communicate with multiple
   protocols/applications. In the new network node architecture this issue is
   solved by the dispatching mechanism, and protocols don't need to implement
   their own dispatching.

   The main component of the new network node architecture is the so-called
   MessageDispatcher module type. Such modules are responsible for directing
   packets from one protocol to the other and also between applications and
   protocols. Most often, MessageDispatcher modules are displayed as horizontal
   lines between protocol layers inside the network nodes. Protocols and
   applications connect to the dispatcher module directly above and below them.
   Dispatchers do not need to be configured because they learn about connected
   protocols/application at runtime.

   Please refer to the 'src/inet/node/base' and 'src/inet/node/inet' folders for
   more details.

2. Introduction of packet tags

   Packets no longer carry control info data structures while being passed around
   in a network node. They have a set of so-called packet tags attached instead.
   A packet tag is usually a very small data structure that focuses on a single
   parameterization aspect of one or more protocols. For example, a MacAddressReq
   tag specifies the requested transmitter and receiver MAC addresses for a MAC
   protocol.

   In general, packet tags come in three flavors: requests (top down), indications
   (bottom up), and plain tags (meta data). The naming convention for packet tags
   is to use the Req, Ind, or Tag suffix respectively. Tags are usually defined
   in MSG files, so that they can be inspected in the runtime environment.

   Tags can pass through protocol layers and reach far away from the originator
   protocol in both the downward and upward direction. This allows protocols to
   implement mechanisms that depend on meta data that is not directly present in
   a packet. For example, a wireless routing protocol could make more informed
   decisions when building the routing table by using the SignalPowerInd tag
   attached by the physical layer. Similarly, an application could attach an
   InterfaceReq to a packet in order to instruct the routing protocol to use a
   particular outgoing interface.

   The old control info data structures that were used with packets are no longer
   available. They have been split into several packet tags. Other control info
   data structures that were used with commands are left unchanged. All related
   protocols have been updated to use the new packet tags. New tags have also
   been introduced which don't have a counterpart in the old data structures.

   Please refer to the MSG files with the 'Tag.msg' suffix for more details.

3. Introduction of flat packets

   A new packet API is introduced that supports efficient construction, sharing,
   duplication, encapsulation, aggregation, fragmentation and serialization. The
   new API also supports dual representation, packet data can be accessed both as
   raw bytes and as objects.

   The new API contains two layers, the lower layer focuses on the representation
   of data. The primary building block of the lower layer is the Chunk class and
   its subclasses. The upper layer builds on top of this and provides the typical
   packet, queue and buffer abstractions used by protocols.

   Nearly all protocols (except SCTP) have been changed to use the new packet API.
   This includes TCP, UDP, IPv4, IPv6, AODV, OSPF, RIP, MPLS, Ethernet, PPP,
   802.11, etc. Due to the flat nature of the new packet data structure, all old
   packet data structures (subclasses of cPacket) have been replaced with chunks
   (subclasses of FieldChunk).

   The various old TCP transfer mode parameters which were used to distinguish
   between communicating with simple byte counts, objects, or byte streams are
   obsolete. Applications and protocols are free to use any kind of chunk in any
   combination. Other protocols will be able to handle such packets transparently
   using the new API.

   Furthermore, all old packet serializer classes have been changed to integrate
   with the new packet API. This allows the transparent processing of packets
   by protocols independently whether they are actually represented as a sequence
   of bytes or as a sequence of field based chunks.

   NOTE: SCTP has not been ported yet to the new architeture and is currently
   excluded from the build.

   Please refer to the 'src/inet/common/packet' and 'test/packet' folders for
   more details.

4. The new implementation has been extensibly tested. We used fingerprint tests
   after each change to ensure that all protocol behaviors have been preserved.


INET 3.8.5 (Nov 2024) - Stable
------------------------------

Contains compatibility fixes for OMNeT++ 6.1.
Requires OMNeT++ 5.7 or 6.0.


INET 3.8.4 (Aug 2024) - Stable
------------------------------

Contains compatibility fixes for OMNeT++ 6.1.
Requires OMNeT++ 5.7 or 6.0.


INET 3.8.3 (April 2022) - Stable
--------------------------------

Contains compatibility fixes for OMNeT++ 6.0.
Requires OMNeT++ 5.7 or 6.0.


INET 3.8.2 (February 2022) - Stable
-----------------------------------

Contains compatibility fixes for OMNeT++ 6.0.
Requires OMNeT++ 5.7 or 6.0rc1.


INET 3.8.1 (November 2021) - stable
-----------------------------------

Contains compatibility fixes for OMNeT++ 6.0.
Requires OMNeT++ 5.7 or 6.0 preview 14.


INET 3.8 (September 2021) - Stable
----------------------------------

This release requires OMNeT++ 5.7 or 6.0 preview 13. For older OMNeT++ versions
please use INET 3.7.x. This version serves as a stepping stone for porting
older INET based models to OMNeT++ 6 and INET 4.x. A recommended way is to
port first to INET 3.8 (and OMNeT++ 5.7), then upgrade to OMNeT++ 6 and finally
port the model to INET 4.x.

Main changes since 3.7:

  - MSG files are now in OMNeT++ 6 compatible format (i.e. using --msg6
    because OMNeT++ 6 no longer supports --msg4)
  - NED files are now compatible with both OMNeT++ 5.7 and 6.0 (i.e. they are
    explictly using `parent.foo` and `this.foo` in experssions of submodule
    and connection blocks.)
  - Follow OMNeT++ API changes: use AnyPtr instead of void*
  - Fix #92: TcpConnection: accepts simultaneous open requests


INET 3.7.1 (April 2021) - stable
--------------------------------

This release contains compatibility fixes for OMNeT++ 6.0 preview 11,
plus minor bugfixes:

  - localPort parameter didn't take effect in TCPAppBase
  - use BYPASS for multicast packets to allow unfiltered multicast traffic in IPSec


INET 3.7 (January 2021) - stable
--------------------------------

This release adds an IPsec model, improves on UDPBasicApp, and contains small
bug fixes. It requires OMNeT++ 5.3 or later, or OMNeT++ 6.0 Preview 9 or 10.

IPsec:

  The IPsec model implements basic RFC 4301 functionality: Authentication
  Header (AH) and Encapsulating Security Payload (ESP). Key exchange protocols
  are not model modeled, but instead, security associations (SAs) are statically
  configured and remain in effect for the entire duration of the simulation.

  The model does not perform actual cryptography. This was an explicit non-goal,
  as the purpose of the model is to study the effects of the network overhead of
  IPsec. As a consequence, encryption keys, certificates, and other cryptography-
  related data do not appear in the model's data structures. However, protocol
  overhead and a simple performance model to account for the runtime overhead
  of cryptography are included.

  Further limitations:
  - Transport mode only. Tunnel mode is not supported.
  - Multicast traffic is not supported.
  - The anti-replay mechanism is not implemented.
  - DSCP-based SA selection is not implemented.

UDPBasicApp:

  Added sendScript parameter; sendInterval made optional. The change is
  backward compatible (existing fingerprints unchanged).

VoIPStream:

  Updated for avcodec-7:4.2.4

Other:

  Fixed a number of (previously hidden) subtle ownership problems.


INET 3.6.8 (October 2020) - Stable
----------------------------------

This release contains a compatibility fix to be able to build INET with
OMNeT++ 6.0 Preview 9. It requires OMNeT++ 5.3 or later.

NOTE: OMNeT++ 6.0 Preview 5-8 will NOT work with this release. Use INET 3.6.7
with those versions or rather upgrade your OMNeT++ installation.


INET 3.6.7 (November 2019) - Stable
-----------------------------------

This release contains a compatibility fix to be able to build INET with
OMNeT++ 6.0 Preview 5. It requires OMNeT++ 5.3 or later.


INET 3.6.6 (August 2019) - Stable
---------------------------------

This release contains a bug fix for an issue where clang did not export
the typinfo symbols for classes on Windows. This caused link errors on
dependent projets. It requires OMNeT++ 5.3 or later.

General:

  - Added NetworkCommunicationFingerprintCalculator, to be able to generate
    INET 4 compatible fingerprints that are based on network communication.


INET 3.6.5 (April 2019) - Stable
--------------------------------

This release contains minor bug fixes and compatibility fixes for the
OMNeT++ 5.4.1 release and for recent Linux distros. It requires
OMNeT++ 5.3 or later.

General:

  - Added missing measurement units for 0 values in NED and INI files
  - NED files are now using fully qualified type names
  - Added missing doParsimPacking/doParsimUnpacking in L3Address

Ethernet:

  - Fixed 'EtherMAC swallows frames when PAUSE is engaged (#391)'
  - Fixed 'Cannot abort PAUSE (LFC) before timeout (#390)'
    (author: Danushka Menikkumbura)

ieee802.11:

  - Fixed ACK frame duration bug where the duration was incorrectly
    rounded up in seconds instead of microseconds for data fragment ACKs.

TCP:

  - Bugfix: static variables were removed, but remained in header

SCTP:

  - Set the DupTsn relative to the localDiffTSN

IPv6:

  - Added constructors in AdvPrefix.

Visualizers:

  - Removed dependence on ObjectLocatorNode as it was removed in recent
    versions of osgEarth


INET 3.6.4 (March 2018) - Stable
--------------------------------

This release contains minor bug fixes and compatibility fixes for the
OMNeT++ 5.3 Preview 4 release. It requires OMNeT++ 5.1 or later.

General:

  - Changed some module parameters from double to int.

  - Corrected memory management issue in radio module.

  - common: added intWithUnit() ned function.

Packet printer:

  - made it compatible with the new message printer API in OMNeT++ 5.3


INET 3.6.3 (December 2017) - Stable
-----------------------------------

This release contains minor bug fixes and compatibility fixes for the final
OMNeT++ 5.3 Preview 1 release. It requires OMNeT++ 5.1 or later.

TCP:

  - Fixed TCP/IP Checksum calculation with odd lengths.

SCTP:

  - Fixed a retransmission bug where the transmission counter was not
    advanced when the data was retransmitted due to timeout.
	- Fixed a bug when fast recovery was active and the cumulative TSN
    advanced, the miss indications were not increased.

Packetdrill:

	- The counting of Gap Reports was fixed.
	- Added a new test to test fast Retransmissions.

Ieee802154NarrowbandScalarRadio:

	- The bandwidth was not correctly claculated, leading to incorrect channel allocation
	- The PHY header was calculated wrong

APSKScalarReceiver:

	- Fixed sensitivity bug in APSKScalarReceiver found by Tobias Thiel


INET 3.6.2 (October 2017) - Stable
----------------------------------

This release contains minor bug fixes and compatibility fixes for the final
OMNeT++ 5.2 release. It requires OMNeT++ 5.1 or later.

 - Tcp: Fixed incorrect connection pointer in rexmitQueue.
 - Edcaf: Fixed aifs calculation for customised aifsn.
 - Visualization: parameter rename
 - inet_featuretool: Removed warning when treating a missing feature in the state files as default.
 - Updated showcases and tutorials.
 - Various fixes to eliminate warnings on clang 4 and gcc 7.x.


INET 3.6.1 (July 2017) - Stable
-------------------------------

This release contains minor compatibility fixes. It requires OMNeT++ 5.1 or later.

 - Minor compatibility fix to work with OMNeT++ 5.2 Preview 1
 - Turned on the parallel build option in the IDE project file.


INET-3.6.0 (June 2017) - Stable
-------------------------------

This release contains some important new features, several bug fixes, and a few
minor enhancements. It requires OMNeT++ 5.1 or later.

Highlights in this release:

 - On Windows, INET is no longer using the auto-import feature of the linker, because
   it generated more than 65536 symbols. Dependent projects crashed because of this.
   All INET APIs now should be prefixed with INET_API macro. (fixes #257)

 - The makefile now generates separate precompiled header for debug and release mode.
   This is required to be able to quicly switch between release and debug mode in the IDE.

 - The IEEE 802.11 MAC model has been extended with several new components. The
   implementation is entirely based on the standard IEEE 802.11™-2012 Part 11:
   Wireless LAN Medium Access Control (MAC) and Physical Layer (PHY) Specifications.

   The new architecture is designed to be modular to facilitate experimenting
   with new policies, features and algorithms within the MAC layer. Users can
   easily replace individual components with their own implementations. Policies,
   which most likely to be experimented with, are extracted into their own modules.

   The new model has the following replaceable built-in policies:
    - ACK policy
    - RTS/CTS policy
    - Originator and recipient block ACK agreement policies
    - MSDU aggregation policy
    - Fragmentation policy

   The new model also separates the following components:
    - Coordination functions
    - Channel access methods
    - MAC data services
    - Aggregation and deaggregation
    - Fragmentation and defragmentation
    - Block ACK agreements and reordering
    - Frame exchange sequences
    - Duplicate removal
    - Rate selection
    - Rate control
    - Protection mechanisms
    - Recovery procedure
    - Contention
    - Frame queues
    - TX/RX

   There are several enhancements and new features to the previous version, the
   most notable are frame exchange sequences, block acknowledgement, and MSDU
   aggregation.

   The new version was thoroughly tested against the old one using fingerprint
   tests. The tests ensure that the new version doesn't introduce any regression.
   In fact, the tests brought up a few problems in the old implementation that
   were fixed in the new one.

 - The power model has been extended with support for charge/current based models
   as opposed to the existing energy/power based ones. A new energy management
   component has also been added to separate monitoring and controlling of energy
   consumers and generators from the rest of the model.

 - New visualizers has been added to display packet drops and link breaks, data
   contained in interface tables, routes stored in routing tables, queues filled
   with packets, residual capacity of energy storages, and transport connections
   between network nodes. The new visualizers are also added to the already existing
   integrated ones. Note: many features that work with the 2D visualizers currently
   don't work with the 3D OSG visualizers.

 - Added new features for various tutorials and showcases.


INET-3.5.0 (February 2017) - Stable
-----------------------------------

This release contains mostly bug fixes and compatibility changes. It requires
OMNeT++ 5.1. Earlier versions of OMNeT++ are *not* compatible.

Highlights in this release:

Build:

  - The build process is now using precompiled headers. This can speed up the
    build process considerably.

  - Feature macros (WITH_*) that show the enablement of features are now placed
    into a header file (src/inet/features.h) instead of passed on the command line.
    The build process adds the WITH_OSG and WITH_OSGEARTH macro to the opp_defines.h
    file when WITH_OSG/WITH_OSGEARTH is set to yes. This allows the IDE to properly
    highlight/disable the appropriate code fragments.

  - 64-bit build is now supported on Windows.

Visualizers:

  - Added a Plot figure (see InstrumentsExample).

DHCP:

  - DHCP fixes.

  - DHCP can now activated in a Router by setting hasDHCP=true

  - Added new WirelessNetWith2DHCP example.

Radio:

  - Added two-ray interference model (TwoRayInterference) as a pathoss model.

SCTP:

  - Added StreamReconfig support for SCTP (by Irene Ruengeler)

GPSR:

  - Allow to specify the interface name in a parameter instead of
    using a hardcoded interface name.

Fixes:

  - Small fixes in SimpleEnergyStorage and during Antenna initialization

  - Calling IPv6RoutingTable::getInterfaceByAddress(const L3Address& address) or
    findGpsrOptionFromNetworkDatagram() function caused infinite recursion.

  - Radio: Fixed FreeSpacePathLoss bug in the loss formula for alpha != 2 case,
    reported by Benjamin Sliwa.

  - SimpleVoIPServer now resolves destAddress at startTime (instead
    of initialization)

  - Ieee8021dRelay: fixed a null pointer crash

  - StaticConcentricMobility: fixed a rounding issue

  - ICMP: fixed "icmp error answer to a fragmented udp packet" problem

  - ICMP: fixing bug #64: Buffer Overflow Error

  - AODV: no longer causes assertion failure when RREP-ACK arrived after a timeout


INET-3.4.0 (June 2016) - Stable
-------------------------------

This INET release requires OMNeT++ 5.0. This is due to the new visualization
feature which uses the Canvas and OSG APIs introduced in OMNeT++ 5.0. Most
other parts of the codebase still builds with OMNeT++ 4.6.

Highlights is this release:

Tutorials:

  - Added a Wireless Tutorial (tutorials/wireless). The tutorial consists of
    several simulation models of increasing complexity, demonstrating the INET
    architecture and features related to wireless communication networks. The
    models are accompanied by a text which explains each step, complete with
    screenshots and recorded animations.

  - Added draft for a visualization tutorial.

Visualizers:

  - Added a new 'visualizer' folder under 'src' that contains visualizer modules.
    The current visualizer modules can display the scene (optionally with osgEarth),
    the network nodes (optionally with 3D models), physical objects in
    the physical environment, node mobility along with movement trail, discovered
    network connectivity, discovered network routes, ongoing transmissions,
    ongoing receptions, propagating radio signals, and statistics.

    The visualizer modules are intentionally kept separate from network protocol
    models. They are responsible for displaying various aspects of the simulation
    in a graphical user interface. The most common mechanism they use is looking
    up other modules and/or subscribing to the signals they emit. The visualizer
    modules are compatible with both Tkenv and Qtenv. In Qtenv they are able to
    display on both a 2D canvas and a 3D OSG scene.

Instrument figures:

  - Implemented a facility that allows one to display various gauges, meters
    and indicators in the network graphics that take their inputs from signals.
    The "gadgets" themselves are figures that are added into the network using
    @figure properties, and they are driven by signals via @statistic properties,
    using a special result recorder ("figure") that sets the value in the target
    figure. Figure types are: gauge, linearGauge, progressMeter, thermometer,
    counter, indicatorLabel/indicatorText, and indexedImage. Their sources
    are in src/inet/common/figures.

    There is a demo in examples/visualization/instruments, and an additional
    usage example in the Wireless Tutorial (tutorials/wireless).

MAC protocols:

  - Added CsmaCaMac, a simple CSMA/CA-based MAC protocol with optional
    acknowledgements and a retry mechanism. With the appropriate settings,
    it can approximate basic 802.11b ad-hoc mode operation. The code is
    based on the original Ieee80211Mac (802.11b) from 2006.

  - IdealMac: Changed out-of-band ACKs to be optional.

  - LMAC, BMAC, CSMA: Fixed handling of frames with bit errors.

  - WirelessNic: added optional classifier submodule

  - Ieee80211Mac: Resurrected link break signal for giving up a transmission.

Radio:

  - The physical environment model has been extended to include a ground model.
    Ground models need to implement the IGround interface that currently
    contains a getElevation() method. A very simple implementation, FlatGround
    is also provided.

  - The TwoRayGroundReflection model has been updated to use the ground model
    of the physical environment.

  - Added packetReceivedFromUpper and packetSentToUpper signals.

Mobility:

  - Mobility models now use the initialZ parameter even if position is
    initialized from the display string.

  - Added VehicleMobility that simulates turning at waypoints.

  - Now all mobile nodes face (i.e. set the  orientation to) the direction of
    movement. This affects radio reception when direction antenna is used.

Physical enviromment:

  - Added geographic coordinate system support.

  - TracingObstacleLoss renamed to DielectricObstacleLoss.

Misc:

  - Added ApplicationPacket that can be used as generic application payload.
    Currently it contains a sequence number.

  - UDPBasicApp/UDPSink: changed to use ApplicationPacket, and record
    received packet sequence numbers

  - RelayUnit: Added packetReceivedFromLowerSignal and packetSentToLowerSignal signals.

  - AODV: Removed AODV-RERR messages for inactive routes.

  - Applications: Added throughput statistic to some applications.

  - IPv4: Added sentTo/receivedFrom upper/lower signals.

  - Common: Added average forest "material".

  - Common: Added throughput result filter.

Build:

  - Added a top level 'doc' target to build all INET documentation in a single step

  - Added project feature tests (tests/features)


INET-3.3.0 (June 2016) - Stable
-------------------------------

This release requires OMNeT++ 4.6 or 5.0.

Build:

  - Removed unnecessary -pINET from the makemake options. This caused linking
    issues on Windows when 'clang' was used as a compiler. (the INET_API
    macros are needed only for Visual C++)

  - In makefrag, use inet_featuretool instead of scanning the compiler options
    to detect the enablement of the VoIPStream and NSC features

  - Fix: TCP_lwip did not compile when using the command-line make.

  - Examples: 'run' script can now take parameters containing spaces (as long as
    they are quoted properly)

SCTP:

  - Packetdrill: Added SCTP support and socket options (by Irene Ruengeler)

  - SCTP: added support for the SCTP_ACCEPT command (by Irene Ruengeler)

Physical layer:

  - Added IdealObstacleLoss. This obstacle loss model determines power loss by
    checking if there is any obstructing physical object along the straight
    propagation path. The result is either total power loss if there was
    such an object or no loss at all if there wasn't.

MANET:

  - The "MANET Routing" feature (a collection of routing protocols ported
    into INET from other projects) was removed from the source tree. The
    removed MANET routing algorithms are still available in the INETMANET
    fork of INET (https://github.com/aarizaq/inetmanet-2.0). INET now contains
    the following natively implemented MANET routing protocols: AODV, DYMO, GPSR.

Fixes:

  - IPv4: bug fix in IPv4 packet deserialization

  - Ieee802.11: bug fix in 802.11 management code (set TID only for QoS data
    frames)

  - TelnetApp: bug fix (cancel pending timers correctly)

  - IPv4NetworkConfigurator: bug fix: links were not properly detected by the
    configurator when nodes connected to a switch were defined after the switch
    in the NED file

  - IPv6: double delete fixed

  - IPv4RoutingTable: fix: only interfaces with the BROADCAST flag set have
    local broadcast addresses

  - AODV: fix: AODV stopped with an error if an ICMP error packet was received
    (ICMP packets are now accepted and silently dropped)

  - examples: removed obsolete fingerprints.ini files

Ethernet:

  - Added a separate EtherPhyFrame class. Motivation: there was no obvious way
    looking at an EtherFrame to tell whether it already contains preamble+SFD
    or not.

  - Change: When modeling the decapsulation from PHY header (subtracting preamble
    and SFD lengths), padding to minimum frame size was also undone. This is
    no longer done.

  - EtherIFG renamed to EtherFilledIFG

  - Catch duplex-halfduplex misconfiguration and throw error

  - Fix incorrect byte counting during burst

  - Serializer: adapted to the introduction of EtherPhyFrame

  - Serializer: fix: CRC was in wrong byte order

  - Serializer: fix: length field contained incorrect value (size of frame
    instead of size of payload)


INET-3.2.4 (April 2016) - Stable
--------------------------------

This is a minor maintenance release that requires either OMNeT++ 4.6,
or 5.0. (Earlier test versions of OMNeT++ will not work.)

Changes:

  - build: updated inet_featuretool (the same like the opp_featuretool in OMNeT++ 5.0)
  - minor fixes to make it build under both OMNeT++ 4.6 and 5.0


INET-3.2.3 (March 2016) - Stable
--------------------------------

This is a minor maintenance release that requires either OMNeT++ 4.6,
or 5.0rc or later. (Earlier test versions of OMNeT++ will not work.)

Changes:

  - build: updated inet_featuretool (the same like the opp_featuretool in OMNeT++ 5.0 rc)
  - several fixes to make it compatible with both OMNeT++ 4.6 and 5.0
  - smoke and fingerprint tests are running on both OMNeT++ 4.6 and 5.0
  - some variable renames and fixes in ieee802.11


INET-3.2.1 (January 2016) - Stable
----------------------------------

Changes:

  - 802.11 MAC model: EDCA, rate control crashes fixed
  - Radio: Fixed handling of abort reception/transmission.
  - Added missing INET_API defines
  - Physical layer: Fixed memory issues detected by valgrind


INET-3.2 (December 2015) - Stable
---------------------------------

This release requires either OMNeT++ 4.6, or 5.0b3 or later. (Earlier test
versions of OMNeT++ will not work.)

IEEE 802.11 MAC model:

 - After further refinement, new features, several bugfixes and validation
   testing, the new MAC model was made the default one. It was also renamed
   from Ieee80211NewMac to Ieee80211Mac, while the old Ieee80211Mac became
   Ieee80211OldMac.

 - Improvements on the new MAC model include:
   * Added fragmentation support;
   * Added Onoe, ARF, AARF rate control algorithms;
   * Implemented early Ack timeout;

 - Validation: Several validation tests were run against the ns-3 Wifi model.
   In the tested configurations, it was ensured that new Mac model behaves
   *exactly* as the ns-3 model (that is, timestamped packet logs match exactly).
   Discrepancies were resolved with bugfixes in our code, in the ns-3 code,
   or both. Bugs found in ns-3 were reported in the ns-3 bugtracker.
   See tests/misc/ns3.

Physical layer:

 - Added support for the simulation of separate signal parts in the Radio.
   The preamble, header and data parts can be optionally simulated
   separately. This results in a more accurate simulation, because a
   reception may be aborted before the data part is received.

 - Added separate preambleDuration parameters to each radio transmitter for more
   flexible configuration.

 - Added Ieee80211IdealRadio, an ideal channel model (aka unit disc radio)
   suitable for use with Ieee80211Mac.

Fixes:

 - Fixed PER computation in NetworkConfiguratorBase.

 - Fixed missing byte length in AODV and added control packet length configuration.

 - RTT initialization was fixed in TCP (Vegas, Westwood) because the original
   value caused "out of range" error with the overflow check introduced in
   OMNeT++ 5.0b3.

 - BPDU packet length was incorrectly set sometimes in the 802.1d model.

 - Fixed incorrect sign of lastSpeed in some mobility models.

 - The VoIPStream app has been updated to work with the ffmpeg version
   distributed in Ubuntu 15.10

 - Added some INET_API macros to compile properly on Windows.

 - QoSClassifier example no longer needs the 802.11 project feature.


INET-3.1.1 (October 2015) - Stable
----------------------------------

Changes:

  - Fixed build problem on Windows


INET-3.1.0 (October 2015) - Stable
----------------------------------

This release requires OMNeT++ 4.6 or later. In addition to several bug fixes,
it features the following additions compared to INET-3.0:

1. A modular and extensible new 802.11 MAC model.

   It replaces the existing monolithic 802.11 MAC model that has become
   increasingly difficult to maintain and extend over the years. The new MAC
   has a modular design, where components can be swapped in and out. Concepts
   such as contention-based channel access, frame exchange sequences, EDCA
   queues, aggregation, fragmentation, duplicate detection, block acknow-
   ledgement, frame rate selection, automatic rate selection, etc would
   be expressed as self-contained C++ classes that implement abstract
   interfaces and (may) have multiple implementations.

   This kind of modular design also favours the open-source development model,
   because abstract interfaces give contributors better cues on where to start
   implementing a new feature, and new classes can be more readily accepted
   into the codebase because changes to existing code (and thus the risk of
   introducing new bugs) can be minimized.

   In this initial form, it has roughly the same set of 802.11 features as the
   old Ieee80211Mac module: basic DCF and EDCA, with the channel access and
   some more parameters being configurable.

   For now, the old Ieee80211Mac is still the default one for simulations.
   To switch to using the new one, add the following line to your omnetpp.ini:

   **.macType = "Ieee80211CompatibleNewMac"

   Ieee80211CompatibleNewMac is a wrapper around Ieee80211NewMac to make its
   parameterization similar to the old MAC.

   Note that the new MAC is a compound module. You can double-click on the mac
   submodule (in Tkenv) and expore its internals.

   See the ChangeLog in src/inet/linklayer/ieee80211/newmac/ for more
   information. The same folder also contains a presentation about the
   architecture of the new MAC, as it was presented at the 2nd OMNeT++
   Community Summit in September 2015 (see http://summit.omnetpp.org).

2. Packetdrill. This is a port of Google's Packetdrill testing tool into
   the INET Framework.

   Google released the script-based Packetdrill tool in 2013. It allows one
   to test transport protocols like UDP and TCP on Linux and BSD-based
   operating systems. Scripts define test cases that inject packets to the
   protocol implementation under test, perform operations using the API
   controlling the transport protocol, and verify the sending of packets, all
   at specified times. The ported version provides a simple and powerful
   method of testing transport protocols implemented in INET.

   Packetdrill has been contributed by Irene Rungeler and Michael Tuexen at
   FH Muenster. Packetdrill has been presented at the 2nd OMNeT++ Community
   Summit in September 2015; find the paper and presentation slides
   at http://summit.omnetpp.org.

3. Manet protocols in inet.routing.extras package are now disabled by default.
   You can still enable the MANET feature manually or you can use INETMANET
   (a fork of INET) which contains a more up to date codebase for these protocols.

4. Changes and bug fixes in the (old) 802.11 MAC:

   - The default lot time was not always correctly chosen for the configured
     mode (modulation and coding scheme).

   - Change maxQueueSize's meaning to per AC queue. Before, maxQueueSize
     referred to the total of the AC queue lengths, which could cause starvation
     of higher priority queues (see ChangeLog for more info.)

   - Removed external queue support, that is, the mgmt submodule in the Nic
     no longer serves as a passive queue for the MAC.


INET-3.0.0 (June 2015) - Stable
-------------------------------

This release requires OMNeT++ 4.6 or later. There are numerous breaking changes
since the latest stable version (2.6). Please read this file carefully and
see the ChangeLog files in the source for more details.

Nodes:
 - Modules that represent a "node" at network level should be tagged with
   @networkNode property instead of @node. (The @node property name was
   too generic.) The INode module interface was renamed to INetworkNode, too.

Applications:
 - The functionality of PingTestApp was merged into PingApp and PingTestApp
   was removed.

Network Layer:
 - Refactored IPv4/IPv6 options to use TLVOptions structure.


INET-2.99.1 (May 2015) - Development
------------------------------------

This release is the last development snapshot of the upcoming INET-3.0 version.

The highlights of this release are:

1. Includes a new packet/bit/symbol level physical layer model for the 802.11
   OFDM PHY according to the IEEE 802.11-2012 standard, and a hypothetical
   generic packet/bit/symbol level APSK physical layer model for further
   experimentation. The new implementations include forward error correction
   encoding/decoding, scrambling/descrambling, interleaving/deinterleaving, and
   modulation/demodulation.

2. Contains fixes for more than 300 defects found by Coverity, an online C++
   static code analysis tool. The reported Defect Density is decreased to
   0.5/kLoC which is considered a result. You can find the detailed results at
   https://scan.coverity.com/projects/3472

3. Contains several other memory leak and memory management fixes reported by
   valgrind memcheck.

4. Modernizes C++ source code using new C++11 features such as nullptr, auto
   types, range loop, override, etc.

Read on for further details.

All components:
 - Replaced all variants of findModuleWherever calls with module parameters,
   because their behavior is non-predictable and less composable.
 - Replaced most getParentModule calls with module parameters to make modules
   less dependent on their context, and thus more reusable.
 - Replaced UnimplementedModule and all related *_None modules with calls to
   firstAvailableOrEmpty NED function, and changed affected submodules to be
   present conditionally.
 - Moved interface classes under contract subdirectories. Moved base classes
   under base subdirectories.
 - Introduced a new script called 'inet_featuretool' in the root folder of the
   project that allows listing/enabling/disabling specific features from the
   command line. Use 'inet_featuretool -h' for further info.
   The 'make makefiles' command now uses this tool to extract the required
   command line options to generate the makefile. This means that after
   enabling/disabling a feature you always have to invoke 'make makefiles'
   to regenerate the makefile based on the new feature enablement state.

Nodes:
 - All "node type" modules implement the INode module interface so it is now
   possible to create networks (using the <"actualNodeType"> like INode construct)
   where the actual node type can be configured from an ini file.

Emulation:
 - Network Emulation feature no longer depends on OMNeT++ to detect the presence
   of PCAP. Instead the feature can be turned on/off by the user.

Common:
 - Added create-module and delete-module commands to ScenarioManager.
 - New macros in INETDefs.h to test INET version: INET_VERSION (format: 0xAABB
   where AA is the major while BB is the minor version in hex) and
   INET_PATCH_LEVEL (format: 0xCC is the patch level in hex).
 - On Linux, specifying --valgrind as the first argument for the opp_run script
   (or a run script in the examples folder) will start the simulation using the
   'valgrind' memory profiler.
 - Added a reusable HeatMapFigure and a GaugeFigure.
 - Added a reusable DelayedInitializer to support static member initialization
   without having to worry about the initialization order.
 - Renamed ByteArrayMessage to RawPacket.

Environment:
 - Added isometric view angles to physical environment visualization.
 - Added class and module interfaces to physical environment.

Mobility:
 - Added a new StaticConcentricMobility similar to StaticGridMobility that places
   nodes on concentric circles.
 - Removed TracCI and TraCIScenarioManager because these modules are maintained
   in the Veins framework.

Serializer:
 - Refactored packet serializer classes to use a safe buffer class to read and
   write binary data. This allows parsing incorrect binary representations without
   runtime errors required by bit precise physical layer models.
 - Refactored recursion in serializers to be extensible with new packet formats
   without modifying existing code.
 - Fixed a number of packet length bugs and inconsistencies between serialized
   and non-serialized forms.

Application:
 - Merged NetPerfMeter application from the master branch added by Thomas Dreibholz.

PCAP:
 - Allow flushing the pcapFile after each write to ensure that all packets are
   captured in case of a crash.

Transport Layer:
 - Added ITransportPacket interface to TCPSegment, UDPPacket, and SCTPMessage.
   It allows generic handling of transport packets.

SCTP:
 - Added fragPoint parameter to limit the size of fragments.
 - After the handshake only send heartbeats on unconfirmed paths.
 - Fixed close command handling, i.e. stop reading when the command is sent.
 - Handle SACK and NR_SACK separately and use getByteLength instead of getBitLength.
 - Fixed several bugs.

TCP:
 - Refactored and cleaned up TCP header options.
 - Fixed scaling window bug (Martin Becke).

Network Layer:
 - Factored out the network topology extraction algorithm from IPv4NetworkConfigurator
   into a base class.
 - Added support to IPv4NetworkConfigurator for computing wireless shortest path
   based on a simple packet error rate estimation.
 - Added netmaskRoutes parameter to IPv4RoutingTable to control whether netmask
   routes are maintained or not.
 - Added useAdminDist parameter to IPv4RoutingTable to enable/disable the use
   of Cisco specific routing entry extension (disabled by default).
 - Added IGMPv3 implementation (the orinal code came from the ANSA project).
   It has been almost fully rewritten and extended by Tamas Borbely.

Routing:
 - Added PIM-DM and PIM-SM implementation. The original codebase (from the ANSA project
   http://nes.fit.vutbr.cz/ansa) has been extensively reviewed, refactored and
   extended by Tamas Borbely.

Configurator:
 - Refactored supported metrics (hopCount, delay, dataRate, errorRate) and related
   parameters in IPv4NetworkConfigurator.
 - Added autoroute XML configuration element to IPv4NetworkConfigurator. It provides
   parameters for the automatic route discovery. The autoroute element determines
   the set of routing tables that will be modified, the set of destinations for
   which the shortest path will be computed, the used metric and the cost for nodes
   and links.

Link layer:
 - Added TUN/TAP virtual network interfaces thanks to Irene Ruengeler. This kind
   of interfaces send/receive packets to/from TUN applications.
 - Updated the 802.11 MAC implementation to use the new 802.11 mode descriptors.
 - Replaced the old 802.11 operational mode and modulation descriptor classes.
   This change modifies the fingerprint of a few simulations, because the header
   length was computed incorrectly.
 - Changed the 802.11 MAC to use asynchronous commands to set the radio mode.
 - Updated the 802.11 MAC state machine diagram (graphviz) to reflect the current
   state of the implementation.
 - Added safety guard to the 802.11 MAC against recursively calling handleWithFSM.
 - Fixed packet order in transmissionQueue.
 - Renamed getNetworkInterfaceModule to getInterfaceModule in InterfaceEntry.
 - Improved response time on external interfaces. On Linux cSocketScheduler is now
   using immediate mode to reduce the CPU usage while still maintaining a fast
   sub millisec response time (Artur Scussel). On Windows and MAC OS X the polling
   interval was reduced to improve the response time.
 - Added support for sending NF_LINK_BREAK signal from BMAC and CSMA. This is
   required for certain routing protocols (i.e. AODV) to function properly.
 - Extended Ethernet macs accept raw packet

Physical layer:
 - Extended the physical layer contract interfaces for layered implementations.
 - Added signal representations for packet domain, bit domain, symbol domain,
   sample domain and analog domain, and also added contracts for the processing
   components in all of these domains.
 - Added a detailed 802.11 OFDM physical layer implementation that supports
   packet-level, bit-level, and symbol-level simulations in compliant, and also
   in freely configurable non-compliant operational modes.
 - Replaced the old 802.11 operational mode and modulation descriptor classes.
   The new classes are more detailed and more complete implementations. They
   supports both the flat and the layered physical layer models and provide PHY
   characteristics. The implemented 802.11 modes are: DSSS, HR-DSSS, FHSS, IR,
   OFDM, ERP-OFDM.
 - Added IEEE 802.11 High Throughput mode descriptor. This mode is defined in
   Clause 20. High Throughput (HT) PHY specification in the IEEE 802.11-2012
   specification. The new HT mode makes available the Wifi n modes in the
   Ieee80211ModeSet.
 - Added a simple hypothetical APSK physical layer implementation that supports
   packet-level, bit-level, and symbol-level simulations with widely configurable
   bit-domain and symbol-domain parameters.
 - Consistently moved packet level and bit level implementations into separate
   subdirectories throughout the physical layer.
 - Added a generic convolutional encoder/decoder, a generic additive
   scrambler/descrambler, and a 802.11 specific interleaver/deinterleaver.
 - Added a separate modulations folder that contains descriptor classes for
   various keying techniques such as BPSK, QPSK, QAM16, QAM64, QAM256, MQAM,
   DBPSK, DQPSK, MASK, MFSK, MPSK, DSSS-OQPSK-16, etc.
 - Reimplemented the computation of BER and SER based on the SNIR for the QAM-like
   modulations according to wikipedia.
 - Added a special IntervalTree cache for efficiently computing arrival intervals
   for transmissions. This change drastically increases the physical layer
   performance for large networks with lots of ongoing transmissions.
 - Refactored the radio medium model to support the optional representation of
   PHY frames for the layered physical layer models.
 - Refactored the medium analog model to simultaneously support the new layered
   and the already existing flat radio signal models.
 - Refactored the existing 802.11 statistical error models to use the new
   operation mode descriptors.
 - Extracted the BER table based 802.11 statistical error model into a separate
   class. This change modifies the fingerprint of simulations that use this
   error model.
 - Added a new detailed 802.11 error model that computes erroneous packet
   domain, bit domain or symbol domain signal representations.
 - Added 802.11 OFDM PHY frame serializer.
 - Extracted separate CommunicationCache classes from RadioMedium.
 - Extracted separate CommunicationLog class from RadioMedium.
 - Extracted a separate MediumLimitCache module from RadioMedium.
 - Extracted a separate MediumVisualizer module from RadioMedium.
 - Added optional recent communication heat map to MediumVisualizer.
 - Renamed radio control info classes to TransmissionRequest and ReceptionIndication.
 - Added Ieee80211TransmissionRequest with an optional IIeee80211Mode parameter
   to allow the mac module to determine the exact physical layer operational mode.
 - Added CosineAntenna and ParabolicAntenna.
 - Added basic antenna array support to be used with 802.11 HT modes.
 - Added arrival parameter to computeReceptionPower. Added snir parameter to
   computeIsReceptionSuccessful. Added snir parameter to computeReceptionDecision.
 - Added level parameter to printToStream function to better support logging.
 - Fixed the indefinite heap growth bug in the RadioMedium.

Tests:
 - Added separate automated tests for convolutional encoding/decoding,
   interleaving/deinterleaving, scrambling/descrambling, modulation/demodulation
   and various combinations.

Examples:
 - Added a new detailed 802.11 OFDM radio example that supports configurable
   packet-level, bit-level, and symbol-level simulations for model verification.
 - Also added a simple hypothetical APSK radio example that supports configurable
   packet-level, bit-level, and symbol-level simulations for model verification.
 - Added a work in progress Wireless tutorial in the tutorials/wireless folder.


INET-2.99.0 (November 2014) - Development
-----------------------------------------

This release is a snapshot of the development that has begun in early 2013, and
will culminate in the release of INET-3.0. The code is work in progress, which
means all details may still change until 3.0 is reached.

This release requires OMNeT++ 4.6 or later.

The highlights of this release are:

 1. Network layer refactoring that allows higher layer protocols (including
    routing protocols) to be written in a network protocol agnostic manner.

 2. A new physical layer model that builds upon the INET and MiXiM physical
    layers, and brings them to new heights. Design goals were extreme modularity,
    extensibility, the ability to support (and easily switch between) various
    levels of detail, and the ability to add support for exploiting various
    pieces of parallel hardware.

 3. Extensive refactoring aimed at improving code quality. It includes
    directory restructuring, code formatting, refactoring of init stages and
    publish-subscribe communication, and more.

Read on for further details.

Geometry model:

 - Added new orientation related classes: EulerAngles, Rotation, and Quaternion.
 - Added new basic 3D geometry classes: LineSegment, Box, Plane, and Polygon.
 - Added new 3D convex shapes: Cuboid, Sphere, Prism, and Polyhedron.
 - Added new geometry cache data structures: SpatialGrid, QuadTree, and BVHTree.

Physical environment model:

 - Removed obsolete classes: Obstacle, ObstacleControl, and AnnotationManager.
 - Implemented a completely new physical environment model as follows.
 - Added a new global PhysicalEnvironment module that provides some trivial
   global properties: temperature, space limits, and a list of physical objects.
 - Added a new PhysicalObject class that has shape, position, orientation,
   material, and various graphics properties.
 - Added a new Material class along with some default materials: vacuum, air,
   copper, aluminium, wood, brick, concrete, and glass.
 - Added a new IObjectCache interface for efficient physical object queries
   along a line segment.
 - Added IObjectCache implementations: GridObjectCache and BVHObjectCache.
 - Added an XML file format to initialize the physical environment with shapes,
   materials, and physical objects.
 - Added support for drawing the physical objects on a compound module canvas
   (Tkenv) in 2D as seen from a configured view angle.
 - Added examples that demonstrate the initialization and usage of the physical
   environment, the physical objects, and the configuration of the object cache.

Power model:

 - Removed obsolete classes: IBattery, BasicBattery, InetSimpleBattery and Energy.
 - Implemented a completely new power model.
 - Added new interfaces: IEnergyConsumer, IEnergyStorage, and IEnergyGenerator.
 - Added implementations: IdealEnergyStorage, and SimpleEnergyStorage.
 - Added a new power consumer implementation for radios based on the radio mode,
   the reception state, and the transmission state: StateBasedEnergyConsumer.

Physical layer:

 - Refactored and unified the existing INET and MiXiM physical layer models into
   a new extended and scalable model as follows.
 - Designed new interfaces and classes to support optimistic parallel computation
   of reception results utilizing multicore CPUs and/or GPUs.
 - Designed new model that supports different level of details with respect to
   transmitters, receivers, radio signals, antennas, propagation models, etc.
 - Added new radio signal power representations: scalar and dimensional over
   time, frequency, space, etc.
 - Added various performance vs. accuracy tradeoff configuration options (e.g.
   range filter, radio mode filter, listening mode filter, MAC address filter)
 - Added concurrent transmitter and receiver radio mode (transceiver mode).
 - Added separate controllable radio mode and automatic signaling of reception
   state and transmission state.
 - Added configurable non-zero time radio mode switching.
 - Added separate power consumption model based on the radio mode, the reception
   state and the transmission state.
 - Added support for burst mode (back to back) transmissions.
 - Introduced compile time checked physical units in C++ code to avoid conversion
   errors and to enhance self documentation.

Physical layer radio model:

 - Removed obsolete classes: Radio, IdealRadio, GenericRadio, GenericRadioModel,
   IRadio, IRadioModel, INoiseGenerator, and some others.
 - Added new interfaces: IRadio, IAntenna, ITransmitter, IReceiver, and IErrorModel.
 - Added new implementation classes: Radio, IdealRadio, ScalarRadio,
   DimensionalRadio, Ieee80211Radio, and Ieee802154UWBIRRadio.
 - Added a number of implementation base classes and subcomponents unlisted here.
 - Added and updated error model implementations: FlatErrorModel,
   Ieee80211NistErrorModel, Ieee80211YansErrorModel
 - Introduced controllable radio mode: off, sleep, receiver, transmitter,
   transceiver, and switching.
 - Introduced automatically signaled reception state: undefined, idle, busy,
   synchronizing and receiving.
 - Introduced automatically signaled transmission state: undefined, transmitting.
 - Added new antenna classes: IsotropicAntenna, ConstantGainAntenna,
   DipoleAntenna, and InterpolatingAntenna.

Physical layer radio medium model:

 - Removed obsolete classes: ChannelAccess ChannelControl, IdealChannelModel,
   IdealChannelModelAccess and some others.
 - Added new interfaces to model the radio medium: IRadioMedium, IPropagation,
   IBackgroundNoise, IPathLoss, IObstacleLoss, IAttenuation, and INeighborCache.
 - Added new implementation classes: RadioMedium, IdealRadioMedium,
   ScalarRadioMedium, DimensionalRadioMedium, Ieee80211RadioMedium, and
   Ieee802154UWBIRRadioMedium.
 - Added propagation models: ConstantTimePropagation and ConstantSpeedPropagation.
 - Added background noise source models: ScalarIsotropicBackgroundNoise and
   DimensionalIsotropicBackgroundNoise.
 - Refactored existing path loss models: FreeSpacePathLoss, LogNormalShadowing,
   TwoRayGroundReflection, NakagamiFading, RayleighFading, RicianFading, and
   SUIPathLoss.
 - Added new path loss models: BreakpointPathLoss and UWBIRStochasticPathLoss
   from MiXiM.
 - Added a new obstacle loss model: TracingObstacleLoss.
 - Added INeighborCache implementations: ListNeighborCache, GridNeighborCache,
   and QuadTreeNeighborCache.

Physical layer communication model:

 - Removed obsolete classes: AirFrame, IdealAirFrame and SnrList.
 - Added new interfaces: IRadioFrame, ITransmission, IArrival, IReception,
   INoise, ISNIR, IListening, and IReceptionDecision.
 - Added new implementation classes: RadioFrame, Arrival, Interference,
   ScalarSNIR, DimensionalSNIR.
 - Added a number of implementation base classes unlisted here.
 - Added range based, narrow band scalar and dimensional signal power
   representations for transmissions, receptions, and noise.

Link layer:

 - Added a simple MAC protocol for testing purposes: IdealMac.
 - Ported MAC protocols from MiXiM: CSMA, BMACLayer, and LMacLayer.

Network layer:

 - IPv4/IPv6: dynamic registration of upper layer protocols.
   TCP, UDP, SCTP, RSVP, OSPF, MANET are all merged into transport gates.
   Network user modules must register their protocol number by sending
   an IPRegisterProtocolCommand from initialize().
   Introduced an IPSocket class that wraps the registration process.

 - Refactoring: routing tables and routes now implement a common IRoutingTable
   and IRoute C++ interface (details below)

   Motivation: allow uniform access to the IPv4, IPv6 and possibly other routing tables;
   e.g. some wireless networks may use MAC address as network address. Also, in
   simulation it sometimes makes sense to work with simple abstract addresses like
   module names, indices or IDs.

   Being able to uniformly access routing tables containing different types of
   addresses makes it possible to implement routing protocols in generic way.
   I.e. the same DYMO module can work with IPv4, IPv6, MAC and other addresses
   without change and recompiling.

   Ingredients of this patch:
    - generic L3Address class that can hold all kinds of addresses (=union)
    - interfaces for generic access: IRoutingTable, IRoute, INetworkDatagram, etc.
    - Ping refactoring (use generic addressing instead of hardcoded IPv4, IPv6)
    - merged routing table change notification constants for IPv4 and IPv6

 - NetworkLayer was renamed to IPv4NetworkLayer and moved into src/networklayer/ipv4;
   same for IPv6 (NetworkLayer6 -> IPv6NetworkLayer).

 - IPvXAddress ha been extended and renamed to L3Address. Similarly,
   IPvXAddressResolver became L3AddressResolver. In addition to IPv4 and IPv6
   addresses, L3Address also allows using other kinds of addresses and identifiers
   (e.g. MACAddress, module IDs, module paths) for network-layer addressing.

 - Added GenericNetworkProtocol, which is a simplified network protocol with
   table-based forwarding. It uses L3Address, so it is agnostic to the network-layer
   address type.

 - Added MultiNetworkLayer, which is a wrapper for multiple network layers; in
   practice it can be used for simulating IPv4/IPv6 dual-stack hosts.

 - Ported network protocols from MiXiM: Flood, ProbabilisticBroadcast, and WiseRoute.

C++ source cleanup:

 - Changed include directives to specify the full path of the header file. This
   resolves ambiguities caused by different projects having similar header files,
   and by case-insensitive file systems (Windows).

 - Changed header guards to use a uniform syntax.

 - Applied code formatting (whitespace, braces, etc.) Formatter script (based on
   uncrustify) is under _scripts/reformat, for future formatting needs.

 - Introduced C++ namespaces: inet, inet::utils, inet::ospf, inet::bgp, inet::sctp, etc.

 - Init stages have been refactored: initialization is now done bottom-up,
   by layers, and hardcoded init stage numbers have been replaced by symbolic
   constants.

 - Removed NotificationBoard and INotifiable: all modules now use OMNeT++ signals
   for publish/subscribe communication.

 - Improved logging: log messages have been classified by importance, and logging
   to EV has been replaced by EV_ERROR, EV_WARN, EV (for EV_INFO), EV_DETAIL,
   EV_DEBUG and EV_TRACE accordingly. Proper support for these log categories
   will be available from OMNeT++ 5.0, for 4.x they are simply mapped to EV.

 - Several modules have been adapted to the coding conventions, e.g. the RTP models.

Directory reorganization:

 - Moved src/ under src/inet/ to avoid header conflicts with 3rd party software.

 - base/ and util/ have been consolidated into common/ and its several subdirectories
   (e.g. common/misc/, common/geometry/, common/queue/, common/lifecycle/)

 - queue/ has become common/queue/.

 - Routing protocols have been moved into the new routing/ toplevel directory
   from networklayer/routing/, networklayer/bgpv4 and networklayer/ospfv2/.

 - Protocols in networklayer/manetrouting/ have been moved into routing/extras/.

 - transport/ has been renamed to transportlayer/.

 - battery/ has been replaced by power/, intended to hold models for power management
   related components.

 - The physicallayer/ toplevel directory has been created to hold the new physical
   layer model.

 - The environment/ toplevel directory has been created for models that represent
   the global physical environment.

 - world/ no longer exists, its contents has been distributed to other directories.

 - status/ lives on as common/lifecycle/.

 - networklayer/autorouting/ has become networklayer/configurator/.

 - applications/httptools/ has been split up to several subdirectories: browser/,
   server/, configurator/, common/.


INET 2.6 (March 05, 2015) - Stable
----------------------------------

This release requires OMNeT++ 4.4 or later. It contains the following changes:

   - made compatible with OMNeT++ 5.0b1
   - added OLIA for CMT-SCTP (by Martin Becke)
   - added a trace player feature to NetPerfMeter
   - fixed compile errors when using OMNeT++ 5.0b1
   - fixed an issue with too small initial value of 'ssthreshold' in TCP
   - fixed window scaling in TCP
   - added INET_VERSION macro (in hexadecimal form e.g.: 0x0206)


INET 2.5.1 (November 7, 2014)
-----------------------------

This release requires OMNeT++ 4.4.

Changes:

   - fixed a crash in SCTP
   - now builds with all features turned off


INET 2.5.0 (October 29, 2014)
-----------------------------

This release requires OMNeT++ 4.4.

Changes:

   - made the codebase compile in C++11 mode. (required by OMNeT++ 4.6)
   - added netperfmeter application by Thomas Dreibholz


INET-2.4.0 (June 12, 2014)
--------------------------

New AODV protocol implementation:

   - From-scratch AODV implementation backported from the integration
     branch; see src/network/routing/

Changes:

   - Added support for link break detection in IdealWireless
     (using the NF_LINK_BREAK signal)
   - VoIPStream updated to match the latest version of ffmpeg library.
   - Added packet printers that can dump packet data in OMNeT++ 4.5/Tkenv
     in the packet trace window.
   - Fixed non-conformant 802.11 WAITACK timeout computation


INET-2.3.0 (March 17, 2014)
---------------------------

This release contains several new protocols, and a lot of changes that were
backported from the current integration branch (destined to be INET 3.0).
This release requires OMNeT++ 4.3.

Application startTime/stopTime fixes:

   - apps start sending at startTime, and send their last packet
     before stopTime
   - negative stopTime means sending forever
   - if startTime and stopTime are the same, the app sends a single
     packet only (except TCP apps)

DHCPServer and Client:

   - The whole implementation has been reviewed to bring it closer to
     the standards defined in RFC 2131 and 2132.

   - Major changes were made both in client's and server's state machines.
     It is now extended with new states (INIT-REBOOT, REBOOTING) and
     with new message types (DHCPNAK, DHCPDECLINE). The new states allow
     the user to model scenarios with lifecycle events.

   - The server's performance model has been removed.

   - The internal representation of the DHCP options were moved to the
     DHCPOptions INET message definition file.

   - Limitation: The client module currently does not support multiple
     DHCP servers and BOOTP relay agents.

SCTP improvements submitted by Irene Rungeler and Thomas Dreibholz:

   - added CMT support (Concurrent Multipath Transfer)
   - added SCTP NAT support
   - added support for using SCTP over IPv6

STP / RSTP support (802.1d) added to the EthernetSwitch:

   - STP: added IEEE 802.1D-1998 implementation of Spanning Tree Protocol.
     The source code is based on the ANSA (https://github.com/kvetak/ANSA)
     implementation.

   - RSTP: added IEEE 802.1D-2004 implementation of Spanning Tree Protocol.
     The source code is based on Juan Luis Garrote Molinero's implementation
     from INETMANET.

   - Interfaces can be configured using the new L2NetworkConfigurator module.
     This module allows one to configure network scenarios at Layer 2.

   - Replaced the EtherSwitch relay unit with a new, STP/RSTP capable one.
     The CPU and memory modeling are no longer supported in this relay unit.

Nodes automatically pick-up the network configuration on restart:

   - An IPv4NodeConfigurator module has been added to hosts, which is responsible
     for configuring the host on restart based on information stored in the
     IPv4NetworkConfigurator module.

INetFilter::IHook API:

   Modules can now hook into the IP module with the new 'NetFilter' API.
   Routing protocols can be implemented now without modifying the IP
   module's code. ManetRoutingBase, InternetCloud and ARP have been updated
   to use the new 'NetFilter' API.

Added new routing protocols:

   - RIP (networklayer/routing/rip)
   - GPSR (networklayer/routing/gpsr)
   - DYMO (networklayer/routing/dymo)
   These protocols use INetFilter::IHook, too.

Revised Mobility code:

   Split the 'models' directory into multiple directories:
   - contract - specifies the interface of mobility models
   - common - shared files among mobility models that are not complete
     mobility models
   - static - mobility models that actually don't move
   - single - mobility models controlling only one moving object
   - group - mobility models controlling multiple interlinked moving objects

Radio:

    Added the Stanford University Interim radio propagation model contributed
    by Konrad Polys and Krzysztof Grochla.

Other, smaller changes:

  - Added ILifecycle support to most applications
  - Renamed AppBase to ApplicationBase and moved to 'common'.
  - UDP: added option to specify the source address of the sent datagram
  - UDPBasicBurst: added bool parameter: excludeLocalDestAddresses
  - UDPVideoStreamCli: use stages in initialize
  - UDPApp*: Added AppBase and subclassed UDP apps from it.
    Binds sockets at startTime and closes them at stopTime.
  - EtherApp* bugfixes
  - Added a command to set TCP queue length threshold. TCP will notify the
    application if it is ready to transmit more bytes.
  - registerSignal() calls were moved from initialize() to static
    variable declarations.
  - Added/fixed @signal declarations, fixed the type of emitted values.
  - httptools: removed the fileExists() function.
  - New logging mechanism + EV handling in preparation for the new OMNeT++ 5.0
    logging mechanism.
  - IPv4Route/IPv6Route: added administrative distance field
  - Added IPv6 header serializer (so ext interfaces can be used with IPv6, too)
  - Invalid access of message pointers fixed in: OSPF, SCTP, DHCP, PingApp

  - Battery: code review, small fixes.
  - Revised init stages in all modules
  - Many smaller fixes and improvements (see the ChangeLog files for further detail.)


INET-2.2.0 (August 22, 2013)
----------------------------

The main highlight of this release is the long-sought support for
simulating node shutdown/restart events for network nodes.
This release requires OMNeT++ 4.2 or later.

New features:

1. Lifecycle infrastructure.

   For node shutdown/crash/startup/etc, a LifecycleOperation (e.g.
   NodeShutdownOperation) is applied to the submodule tree of the  node
   (host or router) by LifecycleController. Each module can decide how
   to handle the operation and how to store the resulting state (up/down,etc).
   Operations can be multi-stage, and don't need to complete immediately
   (i.e. they can take nonzero simulation time and multiple events to complete).

   Network nodes now also have a status submodule (type NodeStatus) with the sole
   purpose of storing the whole node's status (up/down) and displaying it
   via icons.

    - classes: ILifecycle, LifecycleOperation (NodeOperation, InterfaceOperation),
      LifecycleController, NodeStatus
    - NodeStatus module to store the network node's status (up or down)
    - added optional NodeStatus submodule to NodeBase
    - added a test for the basic Lifecycle infrastructure

   We also removed obsolete ways of shutdown/restart: FailureManager, PowerControl,
   LDP_FAILED/RSVP_FAILED, etc.

2. Static IP4 configuration:

   A new module, IPv4NodeConfigurator was added to IPv4NetworkLayer. This module
   is necessary because IPv4NetworkConfigurator cannot configure the node after
   a restart (see newly introduced node lifecycle operations above), since
   being a global module, it doesn't know about node lifecycle events. The new
   module listens to node lifecycle events, and configures the node's routing
   table and interfaces according to configuration computed by the network's
   global IPv4NetworkConfigurator module. Initialization-time node configuration
   is also carried out by the new module.

3. Added TCP Vegas and Westwood algorithms.

   The implementation is a slightly improved version of a 2013 workshop submission:
   "INET framework extensions for TCP Vegas and TCP Westwood", Maria Fernandez,
   Carlos Calafate, Juan-Carlos Cano and Pietro Manzoni. OMNeT++ Workshop, 2013.
   http://www.omnet-workshop.org/2013/uploads/slides/OMNeT-Workshop2013-SP-4.pdf

4. Added IdealWirelessNic (IdealRadio + IdealWirelessMac) and IdealWirelessFrame msg.

   This is a highly abstracted wireless NIC that consists of a unit disk radio
   and a trivial MAC protocol. It offers simplicity for scenarios where Layer 1
   and Layer 2 effects can be completely ignored, for example testing the basic
   functionality of a wireless ad-hoc routing protocol.

   The most important parameter this model accepts is the transmission range.
   When a radio transmits a frame, all other radios within transmission range
   will receive the frame correctly, and radios out of range will not be
   affected at all. There are no collisions -- a radio can simultaneously
   receive any number of frames, and also transmit a single frame at the same time.

5. STCP received several new features (patches submitted by Irene Ruengeler):
   - 8 new strategies for SCTP stream scheduling
   - SCTP Stream Reset (RFC 6525)
   - SCTP Authentication (RFC 4895)
   - Add-IP feature for SCTP (RFC 5061)
   - NR_SACK feature to SCTP
   - Partial Reliability SCTP (RFC 3758)
   - SCTP packet drop feature  (draft-stewart-sctp-pktdrprep-15.txt)
   - SCTP "sack immediately" feature (draft-ietf-tsvwg-sctp-sack-immediately)
   - several alternatives to send fast retransmissions on SCTP

6. Loopback interface added

   Loopback used to be a special case inside the IPv4/IPv6 modules, now it
   is handled completely like any other interface, with a separate Loopback
   module.

7. EtherSwitch, AccessPoint:

   Bare EtherMAC modules have been replaced with EthernetInterface, so that
   external queues can be used (useful for e.g. QoS).

8. InterfaceTable, NIC, NetworkLayer:

   Revert to earlier behavior of determining networkLayerGateIndex.
   Now the module connected to a NIC *must* have gate vectors called ifIn and ifOut.
   If it doesn't, the code decides that the NIC is *not* directly connected to
   a network layer, and leaves networkLayerGateIndex unfilled.

Other, smaller changes:

  - MANET protocols have been synchronized with the INETMANET project
  - NodeBase: added optional battery (off by default)
  - UDP: implemented ReuseAddress option (it's like SO_REUSEADDR socket
    option in Linux). If ReuseAddress is set to true on two sockets,
    then they can bind to the same local address/port.
  - PingApp and other apps: for the stopTime parameter, 'none' is now represented
    by -1, not 0. As this is the default setting, likely very few simulations
    (ini files) are affected.
  - IPv4NetworkConfigurator: added @groups to <interface> (ie. multicast groups
    can now be also specified in the <interface> element, not only in a separate
    <multicast-group> element)
  - in many simulation examples, .irt files were replaced by IPv4NetworkConfigurator XML.
  - EtherMACFullDuplex: wait IFG *after* frames, not before.
  - Ieee80211Mac: added signals declarations and statistics in the NED file
  - EthernetInterface: the encap submodule was made replaceable ("like IEtherEncap")
  - NED: Added InterfaceTable unconditionally to bridge devices, as it is currently
    required by IPv4NetworkConfigurator. Also added NotificationBoard required by
    InterfaceTable.
  - IPv4NetworkConfigurator: Changed to support mixed wired and wireless LANs
    for autoconfiguration.
  - Fixed IPv4NetworkConfigurator bug sometimes not being able to assign addresses.
    Changed to assign most constrained addresses first.
  - RTPHost was moved from src/transport to src/nodes/, and changed to be based
    on StandardHost
  - TurtleMobility: Fixed getting the position from a mobility signal listener
    during initialization. The script was resumed before initialize() finished,
    resulting in incorrect positioning.
  - StaticGridMobility: Added new parameters to specify the number of rows/columns
    and the horizontal/verical separation between the nodes. Note that the way
    the node positions are calculated has changed. You may need to update your
    INI files (see the NED file for more info.)
  - Many smaller fixes and improvements


INET-2.1.0 (Jan 31, 2013)
-------------------------

NEW:

  - Added a new module to model an "internet cloud". The component can
    be configured to model packet delay, datarate and drop probability
    between each input-output interface pair. The parameter matrix
    is provided as an XML configuration file. See the README file
    in src/nodes/internetcloud for further details.
  - New SimpleVoIPReceiver/Sender applications that gather MOS (Mean
    Opinion Score) for measuring voice quality.
  - Added HNA support to the Batman protocol (MANET)

CHANGED:

Applications:
  - PingApp: Shows the configured destination address at the end of the
    simulation.
  - TCPBasicClientApp: bugfix #611: simulation generated an ASSERT if
    numRequestsPerSession parameter value larger than 1.
  - TcpApp: socket state is now shown on the GUI (in Echo, Sink and Session apps.)
  - VoipTool: was renamed to VoIPStream (The actual module names are
    VoIPStreamSender/Receiver.)

Ethernet:
  - Transmission channel's 'disabled' parameter is now correctly handled in
    EtherMacBase.

Ieee80211Mac:
  - Better parameter processing in MAC: error is thrown if an undefined value
    is specified for the opmode or autoBitrate parameters.
  - Added the Ieee80211Descriptor class to assign modulation speed
    and type for the different opModes.
  - Bugfix: Default bitrate for opMode 'p' was incorrectly set.

BGP:
  - Minor optimizations
  - Bugfix: The text in specification "sets the ConnectRetryTimer to zero" means:
    restart this timer. The _connectRetryTime member now stores the timeout value.

Manetrouting:
  - updated documentation
  - replaced Uint128 with ManetNetworkAddress
  - removed:
      - unused ManetTimer and BatmanTimer class
      - unused static variables
      - isIpLocalAddress(), uses isLocalAddress()
      - convertAddressToString()
      - getXPos(), getYPos() functions, you should use getPosition()
        instead.
  - redesigned coordinate and speed storage and access.
    replaced double x,y with a Coord.  getDirection() now returns the
    speed vector (as a Coord)
  - getters returns UNSPECIFIED_ADDRESS if addrType==UNDEFINED
  - merged sendToIp() code into a common base function sendToIpOnIface()

AODV:
  - AODV's hand-written descriptors were replaced with generated ones
    [with A.Varga]
  - aodv_msg_struct.h: added getter methods expected by the generated
    descriptors removed hand-written aodv_msg_struct_descriptor.cc

Batman:
  - Updated and expanded documentation
  - Updated the code to match the latest available "batmand" version.
  - Numerous optimizations
  - Fixed several memory leaks
  - Fixed routing table corruption and possible crash when multiple
    radios were used in a single host
  - Fixed decapsulation of incoming packets. Now it checks for the
    type of decapsulated packet.
  - Fix for a problem when aggregated batman packets were
    dropped erronously.
  - Added HNA support. Nodes can advertise external networks,
    so traffic towards those networks can be routed correctly.
    Use the announcedNetworks parameter to specify multiple connected
    external networks.
  - Added SourceModifier script to help the conversion from the original
    batmand code.
    - fixes spaces, tabs and empty lines
    - replaces some c-style structs to c++-style classes
    - replaces some batmand specified list manipulators with c++ code
    - replaces malloc/free with new/delete
    - removes prof_start()/prof_stop() calls

Examples:
  - Added a new simulation with wired and wireless hosts exchanging UDP
    data via an AccessPoint. It shows how to use the IPv4NetworkConfigurator
    to mix wired and wireless networks.
  - Fixes for BGP examples.
  - New example to demonstrate HNA support in Batman.
  - Hostautoconf examample moved to the adhoc folder.

Other changes:
  - Uint128 class was removed. Use ManetNetworkAddress class instead.
  - Visual changes in StandardHost/NodeBase: utility module icons are
    now smaller and wlan[]/PingApp[] modules are displayed in a row.
  - NodeBase: it is possible to use mobility module even if numRadios = 0
  - Added check for detecting too small netmask parameter value in
    HostAutoConfigurator
  - PacketDump: TCP header option fix (dumped only in verbose mode.)
  - Bugfix #620. The module pointer returned by a ModuleAccess class is
    now cached only if get() was used. For get(module) no caching is done.
  - MACAddress: made the constructor explicit so we will not see
    unexpected implicit conversions in future
  - IPv6Address: removed Uint128 related functions and added an
    additional constructMask() method
  - headerserializers: compile fix for Visual C++ 10.0 and later
  - Pcap now records on ALL interfaces by default (including external IFs).
    Added Enter_Method for better error reporting if a packet cannot be
    serialized. Also added an icon for PcapRecorder.
  - Several TCP related fixes.


INET-2.0.0 (August 7, 2012)
---------------------------

If you are upgrading from an earlier INET version (i.e. INET 20111118),
expect to have to revise your existing omnetpp.ini files and possibly
NED/C++ files as well.

Changes since 1.99.5:

The DHCP protocol received several fixes. It is now possible to use DHCP
with both wired and wireless interfaces.

MANET routing protocols updated from INETMANET-2.0 @ 9a3dc7a
OLSR protocol received several patches allowing it to work with multiple
radios. It can work now on both wired and wireless interfaces.

Ieee80211:
  - bugfix: The latest version of INET (1.99.5) contained a bug where
    speed values for 11MBps and 12MBps were swapped.
  - A new "bitrate" parameter was added to the Ieee80211Nic module.
    The Radio and MAC module uses this bitrate to set thir own bitrate
    value. Its default value is 11Mbps for 802.11b, 27Mbps for 802.11p
    and 54Mbps for 802.11g and  802.11a. (i.e. the default bitrate depends
    on the opMode parameter) This can avoid potential configuration
    inconsitencies. UPDATE all your INI files accordingly.

The Ethernet module now throws an error message if two ethernet ports are
connected using an IdealChannel. Previously it just silently ignored the
connection that was definitely against the "least surprise" principle.

A new "Delayer" module has been added and DropsGenerator and DuplicatesGenerator
has been renamed to OrdinalBasedDropper and OrdinalBasedDuplicator respectively.
These modules implement the IHook module interface and can be installed inside
hosts to induce different packet errors. IHook modules can be inserted
between the network and link layer protocols.

The Ext-interface, TraCI, Mobility and Ping modules received some minor fixes.
See ChangeLogs in individual source folders for more information.


INET-1.99.5 (June 22, 2012)
---------------------------

This is the final testing version of the 1.99.x series leading to the 2.0
release. Requires OMNeT++ 4.2 (version 4.2.2 suggested).

Several OSPF fixes and changes in configuration (see the ChangeLog file
in the OSPF folder for details):
  - improved error detection in xml config files
  - replaced the ospfConfigFile string-type ned parameter with ospfConfig parameter (xml type)
  - uses IPvXAddressResolver for reading IP address and IP netmask values from xml
  - uses @name instead @id to identify the routers in the xml config
  - most attributes in xml config became optional, and default values
      come from ned the parameters of OSPFRouting (with same name)
  - modified xml schema: converted most subnodes to attributes
  - Added etc/OSPFold_to_OSPFnew.xsl for converting the old xml format to new, and
      converted all the ospf config files to the new format in the examples folder
      (after using the converter you must convert router@id to router@name by hand).
  - added @toward attribute to XML for easier interface specification
      old: interfaces were specified by their name (e.g. ifName="eth0").
      new: interfaces can be specified either by their name (e.g. ifName="eth0"),
      or by the name of a module the interface is connected to (e.g. toward="Area3.N9")
  - fixed OSPF.xsd schema

Queueing components:
  The networklayer/queue folder has moved to linklayer/queue folder as
  queues are mostly used in linklayer. This is a new framework that can be
  used to create more complex systems.
  Old queuing components has been removed:
   - DropTailQosQueue, REDQueue, WeightedFairQueue
   - IQoSClassifier (moved to linklayer/ieee80211/mac)
   - BasicDSCPClassifier
  Some of them can be substituted by compound modules composed of these newly
  added components:
   - FIFOQueue
   - REDDropper
   - ThresholdDropper
   - PriorityScheduler
   - WRRScheduler
  For example REDQueue is a combination of a REDDropper and a FIFOQueue,
  and DropTailQosQueue is a combination of some classifier, DropTailQueues,
  and a PriorityScheduler. Read the INET Manual (in doc folder) for more
  information about the usage of these modules.

Brand new Differentiated Services component (using the Queueing framework)
that is implementing the following standards:
  - RFC 2474: Definition of the Differentiated Services Field (DS Field) in
    the IPv4 and IPv6 Headers
  - RFC 2475: An Architecture for Differentiated Services
  - RFC 2597: Assured Forwarding PHB Group
  - RFC 2697: A Single Rate Three Color Marker
  - RFC 2698: A Two Rate Three Color Marker
  - RFC 3246: An Expedited Forwarding PHB (Per-Hop Behavior)
  - RFC 3290: An Informal Management Model for Diffserv Routers


New send method on UDPSocket now allows to specify on which interface
the packets should be sent out.

Added DHCP protocol implementation by Juan Carlos Maureira
taken over from INETMANET-2.0 @ 7fb431b. It can be deployed just
like any other UDP apps.

MANET routing protocols updated from INETMANET-2.0 @ 7fb431b
The whole manetrouting directory was taken over.

Mobility: Added two new mobility models:
  - TraCI + TraCIScenarioManager to connect with an external server
  - LinearNodeDistribution - static hosts in a single line in
    ANY direction

IPv4Route: removed the "type" attribute from the routing entries

VoIPTool: Now compiles with the latest version of ffmpeg libs

IGMPv2: external routers attached to the IGMP module are now
responsible for implementing the IGMP router logic (emitting queries
and processing group membership reports). In this case the IGMP
module passes all incoming IGMP messages to the external router.

Updated 802.11 model from INETMANET-2.0 @ 7fb431b (minor bugfixes)
All files are synced. The following features were omitted:
MULTIQUEUES, HWMP and MESH networking related code.
The default wireless NIC is now using the latest 802.11 code from
INETMANET. The Ieee80211NewNic was renamed to Ieee80211Nic. With
the new NIC it is now possible set the operating mode (a,b,g,p)
The original Ieee80211 implementation was removed to avoid confusion.

The ancient 802.11 implementation from the mobility framework was removed
(i.e. the mf80211 directory).

Added HostAutoConfigurator module (should be added inside a host)
This configurator is deprecated and should be used ONLY if the hosts are
dynamically created/deleted during the simulation. Otherwise please use the
new IPv4NetworkConfigurator.

IPv4NetworkConfigurator: Examples have been updated to use this configurator.
XML configuration format changes:
  - added @among attribute for interface and multicast-group entries:
    "among='X Y Z'"   means   "hosts='X Y Z' towards='X Y Z'"
  - added @metric attribute for interface entry in XML
  - added @id attribute for wireless entry
  - several smaller bugfixes and documentation changes (see ChangeLog
    in the directory)

IPv4 fix: subnet directed broadcast (e.g. 192.168.1.255) works now:
When the datagram reaches the router of the subnet, it should
be forwarded as a link layer broadcast.

Changes in link layer
  - added INic moduleinterface, all other network interfaces should
    implement this
  - renamed the netwIn, netwOut gates to upperLayerIn, upperLayerOut

Small fixes in MACAddress, PPP, IPv4NetworkConfigurator, VoIPTool,
Mobility, BatteryModule


INET-1.99.4 (March 20, 2012)
----------------------------

This version contains mainly bugfixes, plus some features that did not make
into the previous release. Requires OMNeT++ 4.2 (version 4.2.1 suggested).

- Added IPv4NetworkConfigurator, a new network configurator for IPv4

  This is intended to replace both routing files (.irt/.mrt) and
  specialized network configurators like FlatNetworkConfigurator,
  and do much more.

  Covers address assignment (manual, automatic), adding manual routes,
  setting up static routing, optimizing the routing tables, etc.
  Unlike FlatNetworkConfigurator, it will generate per-interface
  addresses. Wireless networks are also supported.

- Added an IGMPv2 implementation, based on code contributed by Jesse Jones

Changes in IPv4 multicast routing:
- We now use reverse path forwarding (routing entry contains
  source address/mask, multicast group, parent (incoming) interface
  and the set of child (outgoing) interfaces).
- The new routing table enables to specify a separate multicast
  routing tree per source network and multicast group. (Old
  implementation used a common tree for each source.) The multicast
  routing tree is represented by IPv4MulticastRoute entries.
- IRoutingTable has been extended with methods manipulating the
  multicast routing entries. Notifications are generated, when
  the multicast routing table changes.
- IPv4 multicast routing algorithm uses the multicast routes
  for forwarding decisions.
- When HL does not specify the multicast interface for outgoing
  datagrams, then it is selected according to the routing table
  or the source address of the datagram.

Change from previous behavior:
- packets sent to a multicast address from higher layer: it used
  to go out on each interface that had a matching route in the
  routing table (unless mcast interface was specified by HL).
  Now it only goes out on the first match route's interface;
  if there's no match it goes out on the 1st multicast interface
  (unless mcast interface was specified by HL). If you want to
  send on multiple interfaces, you have to send multiple packets
  from the higher layer.

- multicast forwarding: no longer takes into account the routes
  in the unticast routing table that have mcast destinations.
  Only the (new format) multicast table is used. This new
  multicast routing table can only be configured with
  IPv4NetworkConfigurator, routing files don't support it.
- mobility: fixed infinite loop when nextChange is set to current
  simulation time

- base: Added createNode(), createLink() factory methods to Topology class.

- Enhancements in IPvXAddressResolver. The new resolver allows you
  to specify an interface based on which module the interface is
  connected to.

- Added a RoutingTableRecorder module that records all the changes
  in the routing table to a file.

- OSPF & BGP fix:
    - gateway is now correcty set on routing table entries.
    - eliminated redundant nextHop field from routing table entries

- Fixed routing table change notifications.

- Added printMulticastRoutingTable() to IRoutingTable

- Added IPingApp interface and support for more than one PingApp
  in a host.

- Changes in the UDP socket API:

  The first call on an UDP socket do not need to be bind() or connect()
  anymore. It is possible to create a socket and sending data immediately
  by calling sendTo(). It is also possible to set socket options before
  calling connect() or bind(). connect() can be called several times.
  However the bind() call fails if the socket is already bound.

- LDP: The LDP module now creates a separate UDP socket for each
  multicast interface of the node, sets the multicast interface
  on them, and sends a copy of LDP-Hellos via each socket.

- ICMP messages are correctly handled now in all TCP implementations
  (in LwIP and NSC, too)

See ChangeLogs in individual source folders for more information.


INET-1.99.3 (Feb 22, 2012)
--------------------------

With this release, we have started a review of all basic protocol modules in
the INET Framework, fixing bugs, refactoring for clarity and maintainability,
and implementing commonly needed missing features. A testing framework is also
falling into place. We have added ChangeLog files in each source directory
to make it easier to follow things for end users and contributors alike, and
we'll also be requiring ChangeLog entries from contributors who submit code
patches. ChangeLogs also include a brief history of the corresponding
components from the start; if you have fixes or amendments, please contact us.
This version of INET requires OMNeT++ 4.2 (version 4.2.1 suggested).

- Ethernet model improvements: EtherMAC refactored for better readability;
  added reconnect support, better PAUSE support, support for 40 Gigabit and
  100 Gigabit Ethernet; several bugfixes; regression and validation tests

- added predefined Ethernet link types: Eth10M, Eth100M, Eth1G, Eth10G,
  Eth40G, Eth100G

- IPv4 model improvements: better fragmentation and multicast support; IPv4
  module refactored for readability and maintainability; several bugfixes

- IPv4 routing table improvements: notification for routing entry changes
  (routing entry objects no longer need to be immutable); lookup performance
  optimization (routes are kept in decreasing prefix length order to speed up
  longest prefix match); cleanup and bugfixes

- IPv6 improvements: implemented Default Router Selection as specified in
  RFC 4861 6.3.6 (round-robin); tunneling is now available without xMIPv6;
  implemented datagram fragmentation/reassembly; IPv6 now works over PPP;
  several other bug fixes

- UDP: better multicast support and DSCP support (apps can specify ToS [IPv4] /
  Traffic Class [IPv6] byte); bug fixes

- PPPInterface, EthernetInterface: use queueType="" instead of queueType=
  "NoQueue" to turn off external queue module and use internal queue.

- Ieee80211, MANET routing: updated to latest INETMANET release:
  radio: added support for noise generators and configurable error models;
  802.11: Airtime Link Metric support; duplicate frame detection / filtering;
  support for prioritizing of multicast frames

- added WeightedFairQueue from INETMANET

- removed Ieee802.11 Mesh feature. It depended on too many upper layer
  protocols and features.

- statistics (@statistic properties) cleaned up in all modules: standardized
  on lower case statistics titles; record packet counts in a less confusing
  way (NOT as rcvdPkBytes:count); cleaned up recorder lists

- miscellaneous: timer usage optimized in DYMO_FAU; revised PingApp, e.g.
  printPing is now turned off by default; numerous bug fixes and improvements

- added a test suite (tests/); it contains fingerprint tests (for regression
  testing); smoke tests (crude regression tests); statistical tests (for
  validation); unit tests (of classes/modules); and other tests. We make most
  use of fingerprint tests, so they are probably in the best state.

See ChangeLogs in individual source folders for more information.


INET-1.99.2 (Nov 18, 2011)
--------------------------

Requires OMNeT++ 4.2 (final).

- Integrated Kristjan Jonsson's HttpTools project,
  http://code.google.com/p/omnet-httptools/

- The mobility models have been revised and brought in sync with their
  MiXiM versions; added 3D coordinate system from MiXim; added MoBAN mobility
  model from MiXiM.

- UDP: multicast, broadcast and ttl support; bugfixes; heavy API changes.
  It is now possible to receive broadcasts and multicasts. Implemented support
  for the following socket options: time-to-live (unicast and multicast),
  broadcast, multicast output interface, join multicast group, leave multicast
  group. Connect without bind is now supported (used to be an error).
  The cost of the above is changes in the way you talk to the UDP module:
  UDPControlInfo has been split to several classes (UDPBindCommand, UDPConnect-
  Command, UDPSendCommand, etc.), and the UDPSocket class has been redesigned.
  Check transport/udp/ChangeLog for detailed information.

- Apps: some standardization of parameter names, so that various modules don't
  call the same thing differently. Introduced the following names:
  'startTime', 'stopTime', 'sendInterval', 'localAddress', 'localPort'.
  E.g. the following parameters became 'sendInterval': 'messageFreq',
  'waitTime', 'packetInterval', 'interval', and 'waitInterval'.

- Added a 'stopTime' parameter to several apps: TelnetApp, UDPBasicApp,
  TCPBasicClientApp, IPvXTrafGen, EtherAppCli

- UDPBasicBurst revised

- Removed Blackboard (it was obsolete and out of use)

- Numerous bugfixes.


INET-1.99.1 (May 27, 2011)
--------------------------

This is a beta of a major feature release, with new models and a lot of
incompatible changes. It requires at least OMNeT++ 4.2b2.
If you are upgrading from an earlier INET version, expect to have
to revise your existing simulations.

- INET can now be compiled with various parts turned off. This is based on
  the new OMNeT++ Project Features facility, avaiable from 4.2b2, see
  http://www.omnet-workshop.org/2011/uploads/slides/OMNeT_WS2011_S3_P1_Varga.pdf
  slides 9-13. INET project features are defined in the .oppfeatures file;
  features can be turned on/off in Project -> Project Features... in the IDE.
  Not all features will compile on Windows: the ones that need to be turned off
  on Windows are TCP_NSC, TCP_lwIP, VoIPTool, MANET Routing, Mesh Networking.

- Integrated the following external packages: VoIPTool, xMIPv6.

- Several components were taken over from INETMANET: MANET routing, combined
  802.11a/b/g/e model, 802.11 mesh networking, obstacle model, several
  mobility models, battery model, globalARP feature. Multiple radio support
  has also been added to INET, loosely based on the INETMANET solution.

- NED-level cleanup of several compound modules: hosts, routers, NICs, APs,
  switches, etc. There were a lot of very similar modules that differred in the
  presence or type of one or more submodules, resulting in code duplication
  and confusion in general. Many variants have been eliminated, and the
  differences have been mapped to parameters, parametric or conditional
  submodules.

- ChannelController now deals only with radios and not hosts. This makes it
  possible to have hosts with several radio interfaces. The radios are
  registered/unregistered in the ChannelAccess module (previously host
  registration was done by the mobility modules). ChannelControl/ChannelAccess
  are now completely independent of the mobility modules. This means that if
  there is no mobility module present in a host, the host's displaystring
  will be used to set the static positions of the radios.

- Ethernet switch was moved under the linklayer/ethernet/switch directory.
  EtherHostQ is now called EtherHost. To have no queue in the Ethernet host,
  specify queueType="NoQueue" (which in fact inserts a dummy queue).
  In EtherSwitch, EtherHost and inside the EthernetInterface the
  csmacdSupport parameter can be used to switch between the full (EtherMAC)
  and the simplified (EtherMACFullDuplex) implementation.

- EthernetInterfaceFullDuplex removed. By default EthernetInterface is using
  EtherMACFullDuplex, a simplified MAC that does not support CSMA/CD and works
  only with point-to-point links. Use the EthernetInterface with
  csmacdSupport=true to turn on CSMA/CD support (EtherMAC).

- IPv4-related modules and classes whose names started with "IP" were renamed
  to start with "IPv4", to be more explicit and more future-proof. IP->IPv4,
  IPAddress->IPv4Address, IPControlInfo->IPv4ControlInfo, IPRoute->IPv4Route,
  IPDatagram->IPv4Datagram, etc.

- Renamed routingTableFile to routingTable in RoutingTable6. Added default
  parameter value. You no longer need to specify **.routingTableFile =
  xmldoc("empty.xml") and have an empty.xml file in the model directory.
  OMNeT++ 4.2 supports the xml("<inlinexml/>") syntax; we now use that for
  the default value.

- New PcapRecorder module (in StandardHost) for recording traffic to a pcap file.
  It is intended as a replacement for the old TCPDump module.

- StandardHost and Router now have a common base (containing Link~ and
  NetworkLayer) Wireless~ and AdhocHost is derived from StandardHost. All of
  them (including Router) support multiple wireless, Ethernet, PPP and
  external interfaces (i.e. multiple wireless radios are supported using
  different channels)

- Several modules - especially inside StandardHost - are now conditional
  (using NED's new "conditional submodule" feature), and will be instantiated
  only if needed. For example, TCP is only instantiated if there are TCP
  applications configured for the host.

- Router and StandardHost have optional mobility support. The mobility module
  is created only if there are wireless cards present in the node (numRadios>0).
  Of course WirelessHost and AdhocHost have mobility by default. You can configure
  the mobility type using the "mobilityType" parameter. BasicMobility have
  been renamed to NullMobility (resulting stationary nodes). There is a dummy
  mobility type called NoMobility which does not have any C++ implementation.
  Nodes that do not need mobility support (i.e. no radios) should set their type
  to NoMobility.

- FailedRouter has been removed (was a trivial node). BurstHost moved to the
  example directory (it was not generic and was used only by a single example).
  MobileHost has been removed; use AdhocHost instead as a drop-in replacement.

- Network Interface Cards (Ieee80211Nic, EthernetInterface and PPPInterface)
  now support input and output hook modules that implement the IHook interface.
  Hooks are useful for simulating packet drops, duplication or measuring thruput.
  The number of hook modules can be controlled with the numInputHooks /
  numOutputHooks parameters, and the hook's type via typename.
  An example: that installs two hooks in the input path of PPP:
    **.ppp[*].numInputHooks = 2
    **.ppp[*].inputHook[0].typename = "DropsGenerator"
    **.ppp[*].inputHook[1].typename = "ThruputMeter"

- Network interfaces can specify a queueType paramater. Possible values:
  DropTailQueue, DropTailQoSQueue, REDQueue, NoQueue.
  To disable queueing, use NoQueue: **.ppp[*].queueType = "NoQueue"

- PPPInterfaceNoQueue and EthernetInterfaceNoQueue have been removed; use the
  queueType="NoQueue" parameter in the interfaces.

- TCP, UDP and SCTP implementations are now pluggable; you can select the
  implementation with the tcpType, udpType and sctpType parameters in the host.
  Modules must implement ITCP, IUDP and ISCTP interface and the specify
  the implementing NED type in the parameter. At the moment SCTP and UDP
  have only one implementation. TCP has TCP (the default INET implementation),
  TCP_NSC (Network Simulation Cradle) and TCP_lwIP (the lightweight IP stack).

- AccessPoint has been generalized. Now it supports both (multiple) wireless
  and ethernet ports. Relaying between ethernet and wireless ports is now
  supported. A relay unit is created only if more than one ports are present
  in the AccessPoint, i.e. having a single radio and no ethernet connections
  will fall back to a single wireless NIC without a relay unit. Having no radio
  and several ethernet ports connected will practically result in an ethernet
  switch.

- Wireless NICs now should implement IWirelessNIC. Now we have only a single
  Ieee80211Nic implementation instead of the 5 variants we have previously.
  Management type (Adhoc, AccessPoint, Station, AccessPointSimplified and
  StationSimplified) can be configured using the mgmtType parameter of the NIC
  (instead of having separate NIC types for each.)

- Multiple radios on independent channels are now supported by all nodes. See
  the wireless/multiradio example.

- The radio infrastucture have been refactored. All radios should now implement
  the IRadio interface. They are now pluggable. RadioModel can be configured
  also via a module parameter. The attenuationModel parameter was moved from
  the radio to ChannelController (it is now global) and renamed to propagationModel.
  Several new propagation model have been added (see NED file docs).

- Removed the TCPSpoofingHost node. Use instead StandardHost with the
  tcpType="TCPSpoof" parameter.

- NAMTrace and NAMTraceWriter modules have been moved to the obsolete directory.
  Turn on event logging instead and use the eventlog animator in the IDE. Event
  logging can be turned on with --record-eventlog=true from the command line or
  using the toolbar button in Tkenv. Once the .elog file is generated, right
  click on it in the IDE and select Open with / Animation Player.

- ChannelInstaller module has been removed. Implemented a ThruputMeteringChannel that
  extends DatarateChannel. It adds thruputDisplayFormat that allows showing different
  statistics along the source gate of the channel. Specifying "" as display format
  results the same behavior as DatarateChannel (with no performance penalty).
  If you want to gather statistics, you do not need this channel. The DatarateChannel
  already emits signals "channelBusy", "messageSent" and "messageDiscarded"
  that can be used to calculate different statistics. Use "opp_run -h neddecls"
  to see what statistics are provided by default. e.g in INI file use
  **.channel.throughput.result-recording-modes=+last to store all channel's
  thoughput values as scalars.


INET-1.99.0 (March 3, 2011)
---------------------------

This is a beta of a major feature release, with new models and also incompatible
changes. If you are upgrading from an earlier INET version, expect to have
to revise your existing omnetpp.ini files and possibly NED/C++ files as well.

The most significant changes:

- replaced cOutVector and recordScalar() with signal-based statistics
  recording in most places (see @statistic properties in NED files)

- support for more than one type of tcpApp and udpApp in StandardHost
  (elimination of tcpAppType/udpAppType parameters)

- Interfaces renamed to start with letter "I". BasicMobility -> IMobility,
  TCPApp->ITCPApp, UDPApp->IUDPApp, SCTPApp->ISCTPApp, MacRelayUnit->IMacRelayUnit,
  Radio->IRadio, Ieee80211Mgmt->IIeee80211Mgmt, OutputQueue->IOutputQueue,
  INetworkInterface->IWiredNic

- added new AdhocHost for basic node types used in adhoc networks. Supports
  mobility and multiple wireless radios. It obsoletes the MFMobileHost
  (use AdhocHost with **.wlan.type-name=Nic80211) and MobileHost (use AdhocHost
  with default parameters)

- added new AccessPoint module with configurable wireless, ethernet and relay
  unit and mobility module types. Obsoletes: WirelessAP and WirelessAPWithEth
  (use AccessPoint), WirelessAPSimplified and WirelessAPWithEthSimplified
  (use AccessPoint with **.wlan.type-name=Ieee80211NicAPSimplified),
  WirelessHost (use StandardHost with numRadios=1) and WirelessHostSimplified
  (use StandardHost with numRadios=1 and **.wlan.type-name=Ieee80211NicSTASimplified)

- in StandardHost and Router it is now possible to configure what wireless, ethernet, ppp
  or external interfaces are used. Wired interfaces must implement IWiredNic, and wireless
  modules must implement IWirelessNic. Mobility type and number of wireless cards (default=0)
  can be also configured via **.wlan.type-name and **.mobility.type-name. The use of
  interfaces obsoletes several older modules which differed only in interface types
  (like WirelessHost or ExtRouter)

- enhanced Router to support external interfaces, ppp, wireless, ethernet etc. This module
  is similar to StandardHost except it does not contain the transport layer and application layer
  protocols (plus IPForwarding is enabled by default). Obsoletes the ExtRouter module (use Router)

- NetworkLayer and NetworkLayer6: added dummy modules that implement the IHook interface
  at the bottom of network layer (above link layer). This allows one to insert
  thruput metering, packet drop and duplication modules etc. without modifying the module.
  New modules implementing IHook: ThruputMeter, DropsGenerator, DuplicatesGenerator and Nop.
  Use **.networkLayer.outputHook.type-name = "ThruputMeter" to configure them (use inputHook
  for incoming traffic)

- added global ARP optimization. If you are not interested in modeling the traffic of ARP protocol,
  it is now possible to use a much faster implementation by specifying (by Alfonso Ariza Quintana):
  **.networkLayer.arp.globalARP=true

- multiple radios (on multiple channels) are supported by StandardHost, AdhocHost
  and Router if ChannelControllerExtended is used in the network.

- point-to-point Ethernet links can now use normal DatarateChannels
  (EtherMAC's txrate parameter was removed)

- added a new TCP model that directly wraps the lwIP stack (without
  NetworkSimulationCradle (NSC) overhead)

- TCP transfer mode (bytecount / cPacket / bytestream) is now
  controlled by the app via a control info field (the sendQueueClass/
  receiveQueueClass TCP module parameters were removed); this works across
  all three TCP models (native OMNeT++, NSC, lwIP)

- experimental support for application-imposed TCP flow control (i.e.
  implementation of "socket read" calls; this is not yet in the
  "integration" branch)

- brand new BGPv4 model, contributed by Helene Lageber

- OSPF model: mass renaming and code formatting to make code conform
  to the rest of INET in coding style

- fix: Ieee80211DataFrame was missing the LLC SNAP header, so all
  802.11 data frames were simulated with 8 bytes less length than
  they should have (this will slightly modify simulation results)

- RTP model refactoring to make it use msg files and a control info
  based interface toward apps

- some improvements INETMANET implemented have been taken over into
  INET (also to decrease INETMANET maintenance cost)

- started taking over xMIPv6's modification to the base INET, so
  xMIPv6 won't need to patch INET

- added basic "New INET simulation" wizards which appear under
  File|New in the IDE

- started working on an INET User Manual (see inet.omnetpp.org)

- added an initial test suite with tests for Ethernet, 802.11 and TCP
  (uses OMNeT++'s opp_test utility and the "omnetpp" R plugin for
  scripted checking of simulation results; not yet in "integration")

- many smaller bug fixes and refactoring, mostly invisible for users

In more details:

* Reorganized StandardHost:

Several changes were introduced to make the basic building blocks of
simulation (StandardHost, AdhocHost, Router etc.) more configurable,
without the need to copy and modify the modules or derive a new module
type. Applications, tcp type, nic, mobility, routing protocols can be
configured using parameters or the **.type-name=typename in the .ini file.

* Ethernet point-to-point links:

In the old code, datarate of Ethernet channels were to be set to zero, and
the real datarate given in the txrate parameter of EtherMAC. This was to
work around a limitation in OMNeT++ 3.x's channel support. In the new code,
the txrate parameter is gone, and the datarate should be set on the
channel. This is consistent with e.g. PPP. This requires non-backward
compatible changes to models.

* Support for several different TCP/UDP apps in StandardHost

In the old code, tcpApp[] is declared as
  tcpApp[numTcpApps]: <tcpAppType> like TCPApp;
which has the side effect that when using StandardHost, all apps have to be
the same type (the one in the tcpAppType parameter). OMNeT++ 4.x supports
setting the types one-by-one, using the following syntax:
  tcpApp[numTcpApps]: <> like TCPApp;
and in the ini file, you have to write
  **.tcpApp[0].type-name = "inet.applications.tcpapp.TCPBasicClientApp"
  **.tcpApp[1].type-name = "inet.applications.tcpapp.TCPEchoApp"
  **.tcpApp[*].type-name = "inet.applications.tcpapp.TCPSinkApp"
  etc.
The existing tcpAppType/udpAppType/sctpAppType parameters would be removed.
However, this also means that existing ini files have to be changed.
If they are not updated, the simulation will not work.

* Multiple TCP implementations, and related parameterization changes

INET now supports Network Simulation Cradle (NSC; wraps several FreeBSD,
Linux and lwIP stacks), and we have an lwIP-based TCP module as well
(without the NSC limitations and overhead); the NED types are TCP, TCP_NSC,
TCP_lwip. Any of them can be selected in StandardHost, via the tcpType
parameter (the tcp module is now declared as "tcp: <tcpType> like ITCP").
tcpType defaults to the native OMNeT++ TCP module.

The sendQueueClass/rcvQueueClass parameters are gone. They were used to
select what to transmit inside TCP segments: C++ objects (cPacket) or byte
counts only. Now, this can (must) be specified per-connection by the app
layer, because the app knows best what it requires. Also, instead of two
class names now there is a single enum value; it should be put into the
dataTransferMode field of TCPOpenCommand. Potential values are:

   TCP_TRANSFER_UNDEFINED = 0;  // Invalid value
   TCP_TRANSFER_BYTECOUNT = 1;  // Transmit byte counts only
   TCP_TRANSFER_OBJECT = 2;     // Transmit the application packet C++ objects
   TCP_TRANSFER_BYTESTREAM = 3; // Transmit actual bytes

Ideally, all 3 TCP implementations should understand all 3 transfer modes;
currently OBJECT support is missing from TCP_NSC.


INET-20110225
-------------

- additional statistics in the SCTP module (Alberto Cortes)

- fix for SCTP Path.Max.Retrans threshold problem (Alberto Cortes)

- minor changes in #includes to ensure compatibility with upcoming OMNeT++ 4.2


INET-20100723
-------------

- TCP improvement (Thomas Reschka, Zoltan Bojthe).
  * implemented RFC 1323 (TCP Extensions for High Performance):
      - Window Scale option
      - Timestamps option (Round-Trip Time Measurement - RTTM)
      - Protect Against Wrapped Sequence Numbers (PAWS)
      - added a PAWS modification according to the latest proposal
        of the tcplw@cray.com list (Braden 1993/04/26)
  * implemented missing part of RFC 2581: Re-starting Idle Connections
  * various fixes
  * see details in src/transport/tcp/ChangeLog.

- added examples for new TCP features (Thomas Reschka):
  * examples/inet/tcptimestamps
  * examples/inet/tcpwindowscale

- added NetAnimTrace module (Andras Varga). This module can be used to record
  input for the NetAnim program (http://www.nsnam.org/wiki/index.php/NetAnim)

- Ieee80211Radio: added a shadowing component for the path loss reception model
  (Nikos Simantirakis). This is a random variable has a normal distribution
  in dB and results to -normal distribution in mW. This is a widespread and
  common model used for reproducing shadowing effects (Rappaport, T. S. (2002),
  Communications - Principles and Practice, Prentice Hall PTR).

- bugfix and small improvements in SCTP, TCPSessionApp, ThruputMeter

- cosmetic changes in many other files (comments, indentation, compiler warning
  elimination, variable renaming, etc.)


INET-20100323
-------------

- added "label" annotations to gates and modules to support the adaptive palette
  filtering and gate matching in the connection chooser (OMNeT++ 4.1).

- updated SCTP implementation by Michael Tuexen, Irene Ruengeler and
  Thomas Dreibholz

- added support for Sam Jensen's Network Simulation Cradle,
  http://www.wand.net.nz/~stj2/nsc/, which makes real-world TCP stacks available
  in simulations. Currently NSC supports the FreeBSD, OpenBSD, lwIP and Linux
  stacks. The TCP_NSC module (transport/tcp_nsc) is a drop-in replacement for the
  normal TCP module (transport/tcp), and can be activated with a single parameter
  setting in StandardHost. See src/transport/tcp_nsc, 3rdparty/README, and
  examples/inet/tcpclientserver.

- added TCP SACK and New Reno implementation by Thomas Reschka. The original TCP
  version is still available as TCP_old. See src/transport/tcp/ChangeLog for details.


INET-20090325
-------------

- tagged version for OMNeT++ 4.0 final
- reworked build system to create shared library by default
- added SCTP from Michael Tuexen and Irene Ruengeler


INET-20080920
-------------

Internal snapshot, for omnetpp-4.0b6.

- performance optimization in all queue modules: remember output gate pointer
  instead of looking up gate by name for each send()

- Ieee80211AgentSTA.cc: randomize the start time of the scanning process.
  (Randomizing the time of sending the first beacon in Ieee80211MgmtAP.cc
  was already done earlier.)

- IP: set TTL to 1 on new datagram if the destination address is link local
  multicast, to prevent broadcasting to non-neighbouring routers.

- several bugfixes


INET-20080709
-------------

Internal snapshot, for omnetpp-4.0b3.

- interface table and routing table are now accessed via the C++ interfaces
  IInterfaceTable and IRoutingTable. This is done to reduce interdependencies
  among modules; more specifically, to allow users implement their own
  InterfaceTables and RoutingTables and plug them into INET simulations,
  without any change to the base INET.

- PPP and EtherMAC2: performance: don't fire tx begin/end notifications if
  no one is listening; remember output gate pointer instead of looking it up
  by name for each send

- UDPEchoApp: messageLength parameter now understood in bytes not bits

- RoutingTable: implemented routing cache and other optimizations


INET-20080630
-------------

Internal snapshot, for omnetpp-4.0b2.

- to enable and encourage extending INET via subclassing (as opposed to
  patching), nearly all member functions made virtual (except in data classes
  like IPAddress), and also, private sections in most classes were changed to
  protected.

- some refactoring on TCP, UDP and IP, to allow subclassing of TCP, UDP and IP
  packets: packets are now created via factory methods that can be overridden
  if needed

- AbstractQueue (base class for IP and other modules) made more efficient: now it
  doesn't schedule a timer if (when) serviceTime is zero.

- IPAddress class made more efficient [code from Ingmar Baumgart, OverSim]

- parsim: added pack/unpack functions for IPAddress, IPv6Address, IPvXAddress

- InterfaceTable: added deleteInterface(). This also causes RoutingTable to
  drop routes that correspond to the deleted interface.

- RoutingTable: wrapped naked data members of IPRoute into getters/setters;
  enforce by returning "const" pointers that routes already added cannot be
  changed any more (one must delete and re-add it)

- InterfaceTable: created a getInterfaceById() method, NOT to be
  confused with getInterface(pos)! Ids are stable after deletions,
  unlike 0..getNumInterfaces()-1 indices, and reliable/safe unlike
  InterfaceEntry* pointers

- InterfaceTable and RoutingTable now fire proper notifications on changes:
  NF_INTERFACE_CREATED, NF_INTERFACE_DELETED, NF_INTERFACE_STATE_CHANGED,
  NF_INTERFACE_CONFIG_CHANGED; NF_IPv4_ROUTE_ADDED, NF_IPv4_ROUTE_DELETED,
  NF_IPv6_ROUTE_ADDED, NF_IPv6_ROUTE_DELETED, etc.

- NotificationBoard: added hasSubscribers(int category) method, to allow for
  optimizing out firing change notifications if there's no one listening.


INET-20080624
-------------

Internal snapshot, for omnetpp-4.0b2.

- updated for OMNeT++ 4.0b2

- extensive renaming: added "get" verb to getter methods in most classes;
  also eliminated @addGetVerb(true) from message classes

- revived the RTP model: starting from Ahmed Ayadi's patch, migrated the code
  to OMNeT++ 4.0, and started some refactoring (started introducing .msg files
  for handcoded message classes; not yet finished)


INET-20080606
-------------

Internal snapshot, for omnetpp-4.0b1.

- directory structure reorganized

- converted to OMNeT++ 4.0

- some refactoring (parameter/gate name changes, etc)

- IP/IPv6: do not schedule a timer if processing time is zero (change made
  in base/AbstractQueue)

- FlatNetworkConfigurator: use @node() property to determine which modules are
  network nodes (removed moduleTypes, nonIPModuleTypes parameters)


INET-20061020
-------------

- new example network: Examples/Ethernet/ARPTest (old ARPTest renamed)

- bugfixes: AbstractRadio (Dave Symonds); Ieee80211 (also reported by Dave)


INET-20060912a
--------------

- improvements on the wireless infrastructure: support for multiple channels
  and channel switching by NICs; account for finite radio wave propagation speed

- added new 802.11 model which also supports infrastructure mode; see
  NetworkInterfaces/Ieee80211. Even for ad-hoc mode, Ieee80211Mac is recommended
  over the older Mac80211 from MF.

- added Ieee80211Radio which supersedes SnrEval80211 and Decider80211.

- added EtherDuplexMAC, a simplified Ethernet implementation for full duplex
  point-to-point operation mode when CSMA/CD is not in use.

- makefiles within Examples/ have been largely unnecessary because all
  simulations just invoke bin/INET. Realizing these makefiles have been
  confusing to many people, they got removed now. The target to generate
  them is still present in makemakefiles in case someone needs it.

- several other fixes


INET-20060330
-------------

- checked in the new MPLS, RSVP-TE and LDP models, written/rewritten by
  Vojta Janota

- new model: Network/Quagga. This is port of the Quagga routing daemon to the
  INET Framework. Currently provides RIP and OSPFv2 routing. Quagga itself is
  a fork of Zebra. (Ported to INET by Vojta Janota)

- new model: Network/OSPFv2. This is a new OSPF implementation.
  (author: Andras Babos)

- UDP rewritten: similarly to TCP, dispatching is now done inside UDP, and
  apps now identify sockets with a sockId; implemented ephemeral port reuse

- UDPSocket class added to facilitate talking to the UDP model from apps;
  analogous to TCPSocket (thanks to Michael Tuexen and Vojta Janota for
  feedback)

- new snapshot of the IPv6 module (by Wei Yang Ng)

- added ability to write nam traces (Util/NAMTraceWriter, World/NAMTrace);
  feature originally implemented by Vojta Janota (and refactored by Andras,
  so bugs are very likely mine)

- implemented ThruputMeteringChannel which can display #packets, pk/sec etc
  on the links; and ChannelInstaller as a temporary solution to install
  ThruputMeteringChannel instead of the built-in BasicChannel class.

- updated module class ctors/dtors for OMNeT++ 3.2; changed msg->length()/8 to
  msg->byteLength() and msg->setLength(8*bytes) to msg->setByteLength(bytes),
  etc.

- TCP: Reno bugs fixed (reported by Pascal Rousseau); TCPMessageBasedSendQueue
  seqNo bug fixed (Adam Hudson); implemented reuse of ephemeral ports;
  fixed incorrect behaviour when ACK of SYN carries data (reported by Joachim
  Meichle); fixed minor issue that when the user issued CLOSE, transition to
  FIN_WAIT_1 was done immediately and not deferred until all data are sent.

- added Applications/TCPApp/TCPSpoof

- hosts have now the same queues as routers (reported by Michael Tuexen)

- ev replaced with EV in every module (speed increase in Express mode)

- NetworkLayer(6): gates towards interfaces renamed to ifOut[]/ifIn[]

- FlatNetworkConfigurator internals refactored

- added another network configurator, NetworkConfigurator

- RoutingTable: routerId selection moved from stage 1 to stage 3 (you may
  need to revise your code if it depends on routerId)


INET-20050922
-------------
- patched for OMNeT++ 3.2:
  - added '=NULL' default value to all args of hand-code module constructors
    (2 or 3 places)
  - RSVPPacket.h: dup() return type has to be cPolymorphic with OMNeT++ 3.2;
    fixed it using '#if OMNETPP_VERSION<0x0302...#else...#endif'

  Note: THIS IS THE ONLY RELEASE WHICH IS COMPATIBLE WITH BOTH 3.1 AND 3.2

- UDP dispatchByPort bug fixed; further smaller fixes

- IPv6 updated (still unfinished)

- NOT YET FIXED:
  - TCP bug http://www.omnetpp.org/listarchive/msg05687.php
  - incorrect handling of host queues (Michael Tuexen)


INET-20050720
-------------

- module types renamed for consistency: PPPModule -> PPP, TCPMain -> TCP,
  UDPProcessing -> UDP

- C++ methods renamed: isNull() -> isUnspecified() in IPAddress, IPv6Addres,
  IPvXAddress

- created two subdirs under Transport/TCP: flavours and queues, and moved
  the appropriate cc/h files there. The structure of the TCP model should
  now be much more obvious to readers. Also added READMEs explaining things.

- TCP fixes: raise an error (~EADDRINUSE) on attempt to create more than one
  connections to listen on the same port

- implemented REDQueue

- beginnings of a "Getting started with TCP" doc


INET-20050705
-------------
- TCP improvements: separate congestion control behaviour classes
  TCPTahoe, TCPReno and TCPNoCongestionControl provided, for teaching
  purposes (their code is very short, to the point, and extensively
  commented).

- TCP: fixed bogus RTT calculation and other other bugs; also, sequence
  numbers are now recorded into omnetpp.vec, so with Plove one can create
  sequence number plots like Sally Floyd's [thanks to Ahmet Sekercioglu
  for help!]

- still TCP: fixed the bug which caused closing of a connection to be reported
  2MSL (240s) later to the user.

- Added support for drop-tail router queues, and queues with QoS support
  based on DS Code Point; RED in preparation (see Network/Queue)

- Added wireless and mobility support (based on Mobility Framework code),
  including 802.11b ad-hoc mode MAC, and several new mobility models
  (also new to MF). Supports mobility traces from BonnMotion and ANSim.

- Contract directories introduced: Transport/Contract, Network/Contract
  and NetworkInterfaces/Contract. These directories contain a minimal set
  of classes necessary for using one layer's functionality from higher layers.

- Added notification mechanism: modules can now notify each other about
  "events" such as routing table changes, interface status changes (up/down),
  interface configuration changes, wireless handovers, changes in the state
  of the wireless channel, mobile node position changes, etc. Notification
  works via the NotificationBoard which replaces the Blackboard.

- InterfaceTable introduced: it stores all interface configuration that was
  previously stored in RoutingTable. Per-interface data structure was also
  split into protocol independent (InterfaceEntry) and protocol dependent
  (IPv4InterfaceData, IPv6InterfaceData) parts.

- ScenarioManager introduced (experimental, in World/ subdirectory):
  it addresses the need for simulating scenarios like "what if this cable
  breaks at t=20s", or "what if traffic intensity grows at t=100s".
  Scenario is described in an XML file.

- Ping and VideoStream applications added (from IPv6SuiteWithINET)

- ARP got moved up from L2 to L3; this is to prepare for IPv6 support (IPv6
  doesn't need ARP, so we can no longer have it as part of the network
  interfaces)

- prepared for IPv6: application layer, transport layer and IPv6 contract
  taken over from IPv6SuiteWithINET-20050502

- work in progress: from-scratch IPv6 implementation by Wei Yang Ng (Monash
  University) and Andras Varga

- added INET_API definitions to classes, so that one can build a DLL that can
  be loaded dynamically into INET.exe (hint: compile DLL code *without*
  /DBUILDING_INET, and link them with INET.lib! then add [General]/load-libs=
  to omnetpp.ini.)

- Network/IPv4d subdirectory finally thrown out. It was a bad idea to
  implement IP with a dozen small modules in the first place.

- added files called !WORK_IN_PROGRESS! with some explanations to
  directories which contain unfinished simulation models.


INET-20050404 released
----------------------
- Updated to omnetpp-3.1.
- patches from Michael Tuexen


INET-20050102
-------------
- updated to omnetpp-3.0


INET-20041007
-------------
- package renamed to INET Framework


IPSuite-20041007
----------------
- practically a complete rewrite of IPSuite took place 03/2004 through
  10/2004. See change log at http://ctieware.eng.monash.edu.au/twiki/
  bin/view/Simulation/IPSuiteLogOfChanges


Preparations for rewriting IPSuite, 09/2003-03/2004
---------------------------------------------------
2004-02-04  Andras Varga

        * got it compiled with omnetpp-3.0pre1. changes:
        - added #include <iostream>, using std::ostream at a couple of places
        - deprecated receiveOn(), receiveNewOn() no longer exists, replaced by:
                msg = receive();
                ASSERT(dfmsg->arrivedOn("fromEnqHook"));  // FIXME revise this
        * removed ProcessorManager altogether

2003-09-19  Andras Varga

        * added the MPLS/LDP/RSVP-TE models created by Xuan Thang Nguyen
        (Xuan.T.Nguyen@uts.edu.au) at UTS (University of Technology, Sydney).
        See http://charlie.it.uts.edu.au/~tkaphan/xtn/capstone/

        * did IPsuite modifications necessary fo MPLS. Modularity is preserved:
        it is still possible to build IPSuite without the MPLS models.

2003-09-18  Andras Varga

        * merged patches for compiling with MSVC.

        * module descriptions (comments) added to/rearranged in all NED files
        for documentation generation with new opp_neddoc.

        * DIRECTORY STRUCTURE WAS REARRANGED along the lines of the OSI layers,
        and also to make it consistent with the IPv6Suite. Hopefully every file
        is now where one would expect to find it.

        * added makemake.cmd for generating Makefile.vc's (using opp_nmakemake)
        for building with MSVC, and makemake for generating Unix makefiles

        * lots of minor fixes to make the code compile with MSVC.
        Note: for compatibility with MSVC6.0,
          1. return type of dup() should ALWAYS be cObject* (and cannot be the
             actual class name)
          2. class variables cannot be initialized (even const or
             static const ones) within the class declaration.

        * updated for recent OMNeT++ versions: added ",row" to vector module
        display strings; removed className() methods, etc.

        * FIXME: KIDSRouter was missing from the original IPSuite! KIDSNw1
        didn't compile. I temporarily substituted a copy of NextHopRouter.

2003-09-17  Andras Varga

        * taken ipsuite-20021124-src.tgz and started improving it.


IPSuite's change log, 2000-2001
-------------------------------
Before Andras Varga took over the development in 2003, IPSuite was
created and developed at University of Karlsruhe, Germany.

2001-12-10  Ulrich Kaage  <kaage@int.uni-karlsruhe.de>

        * Global changes for OMNeT++ 2.2 conformance:
        copy constructor -> const argument
        virtual long length(const ) -> virtual long length(const) const
        virtual int numInitStages() -> virtual int numInitStages () const
        virtual char *className() -> virtual const char* className() const
        virtual cObject *dup() -> virtual cObject *dup() const
        cObject& operator=(cObject& o) -> cObject& operator=(const cObject& o)

2001-08-31  Ulrich Kaage  <kaage@int.uni-karlsruhe.de>

        * CVS-Tag da-kussaether: Work on TCP by Rolf Kussaether;
        implementation of TCP flavours Reno (fast recovery) and New Reno.

2001-03-19 Verena Kahmann <kahmann@telematik.informatik.uni-karlsruhe.de>
        * deleted all queues and behaviors except FIFO* and the basic behaviors.
        Maybe we have to apply some extra cleaning still.
2000-12-19  Ulrich Kaage  <kaage@int.uni-karlsruhe.de>

        * recent (standalone) TCP model is merged into the ip-suite. The
        simple test network is now located in ./Networks/TCPTester

2000-12-13  Ulrich Kaage  <kaage@int.uni-karlsruhe.de>

        * makeipsuite: replaced by top level Makefile

        * rundemo: front end for launching all available simulations

        * Makefile: Top level makefile to create Makefiles from Makefile.in
        in all subdirectories

        * removed mmake in subdirectories and replaced them by Makefile.in

2000-11-22  Ulrich Kaage  <kaage@int.uni-karlsruhe.de>

        * CREDITS: Put your name here if you have contributed to the
        OMNeT++ Internet Protocol Suite