Fix IEEE 802.11 management initialization and AID cleanup

Restore simplified station BSS identity setup to the link-layer initialization stage so automatic network configuration sees the AP SSID, while keeping HT peer capability installation at the final stage after mode-set initialization.

Add an AP-owned association-response timeout with per-station deadlines and transaction matching. Expired pending responses now release only uncommitted AID reservations and discard pending HT state without disturbing replacement transactions or committed reassociation IDs.

Document the management serializer's exact-body stream contract and extend the HT element regression to cover vendor elements followed by trailing FCS-like bytes.

Add deterministic unit and module coverage for timeout scheduling, AID reuse, stale transaction protection, simplified-station wireless identity during network configuration, and final-stage HT peer state.

Tests: release and debug builds; 3 focused unit tests; 2 focused module tests.

Author: mgonzalezlopezudc

src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtAp.cc

@@ -66,6 +66,7 @@ Ieee80211MgmtAp::AssociationResponseDisposition Ieee80211MgmtAp::getAssociationR
 Ieee80211MgmtAp::~Ieee80211MgmtAp()
 {
     cancelAndDelete(beaconTimer);
+    cancelAndDelete(associationResponseTimeoutTimer);
 }
 
 void Ieee80211MgmtAp::initialize(int stage)
@@ -76,13 +77,17 @@ void Ieee80211MgmtAp::initialize(int stage)
         // read params and init vars
         ssid = par("ssid").stdstringValue();
         beaconInterval = par("beaconInterval");
+        associationResponseTimeout = par("associationResponseTimeout");
+        if (associationResponseTimeout < SIMTIME_ZERO)
+            throw cRuntimeError("parameter 'associationResponseTimeout' must not be negative");
         numAuthSteps = par("numAuthSteps");
         if (numAuthSteps != 2 && numAuthSteps != 4)
             throw cRuntimeError("parameter 'numAuthSteps' (number of frames exchanged during authentication) must be 2 or 4, not %d", numAuthSteps);
         channelNumber = -1; // value will arrive from physical layer in receiveChangeNotification()
         WATCH(ssid);
         WATCH(channelNumber);
         WATCH(beaconInterval);
+        WATCH(associationResponseTimeout);
         WATCH(numAuthSteps);
         WATCH(staList);
 
@@ -95,6 +100,7 @@ void Ieee80211MgmtAp::initialize(int stage)
 
         // start beacon timer (randomize startup time)
         beaconTimer = new cMessage("beaconTimer");
+        associationResponseTimeoutTimer = new cMessage("associationResponseTimeoutTimer");
     }
 }
 
@@ -104,6 +110,14 @@ void Ieee80211MgmtAp::handleTimer(cMessage *msg)
         sendBeacon();
         scheduleAfter(beaconInterval, beaconTimer);
     }
+    else if (msg == associationResponseTimeoutTimer) {
+        auto sta = staList.find(scheduledAssociationResponseTimeoutAddress);
+        if (sta != staList.end() && isAssociationResponseTimeoutDue(sta->second,
+                scheduledAssociationResponseTimeoutTransactionId, scheduledAssociationResponseTimeoutDeadline, simTime()))
+            clearPendingAssociation(&sta->second);
+        else
+            scheduleAssociationResponseTimeout();
+    }
     else {
         throw cRuntimeError("internal error: unrecognized timer '%s'", msg->getName());
     }
@@ -210,13 +224,46 @@ uint64_t Ieee80211MgmtAp::createAssociationTransactionId()
     return nextAssociationTransactionId;
 }
 
+bool Ieee80211MgmtAp::isAssociationResponseTimeoutDue(const StaInfo& sta, uint64_t transactionId, simtime_t deadline, simtime_t currentTime)
+{
+    return transactionId != 0 && sta.pendingAssociationTransactionId == transactionId &&
+            sta.pendingAssociationDeadline == deadline && deadline <= currentTime;
+}
+
 void Ieee80211MgmtAp::clearPendingAssociation(StaInfo *sta)
 {
     mib->cancelAssociationIdReservation(sta->address);
     sta->pendingAssociationSuccessful = false;
     sta->pendingAssociationTransactionId = 0;
+    sta->pendingAssociationDeadline = SIMTIME_MAX;
     sta->pendingHtStateAvailable = false;
     sta->pendingHtCapabilitiesValid = false;
+    sta->pendingHtCapabilities = Ieee80211HtCapabilities();
+    scheduleAssociationResponseTimeout();
+}
+
+void Ieee80211MgmtAp::scheduleAssociationResponseTimeout()
+{
+    cancelEvent(associationResponseTimeoutTimer);
+    scheduledAssociationResponseTimeoutTransactionId = 0;
+    scheduledAssociationResponseTimeoutDeadline = SIMTIME_MAX;
+    for (const auto& entry : staList) {
+        const auto& sta = entry.second;
+        if (sta.pendingAssociationTransactionId != 0 && sta.pendingAssociationDeadline < scheduledAssociationResponseTimeoutDeadline) {
+            scheduledAssociationResponseTimeoutAddress = entry.first;
+            scheduledAssociationResponseTimeoutTransactionId = sta.pendingAssociationTransactionId;
+            scheduledAssociationResponseTimeoutDeadline = sta.pendingAssociationDeadline;
+        }
+    }
+    if (scheduledAssociationResponseTimeoutTransactionId != 0)
+        scheduleAt(scheduledAssociationResponseTimeoutDeadline, associationResponseTimeoutTimer);
+}
+
+void Ieee80211MgmtAp::startAssociationResponseTimeout(StaInfo *sta)
+{
+    ASSERT(sta->pendingAssociationTransactionId != 0);
+    sta->pendingAssociationDeadline = simTime() + associationResponseTimeout;
+    scheduleAssociationResponseTimeout();
 }
 
 void Ieee80211MgmtAp::sendBeacon()
@@ -247,8 +294,8 @@ void Ieee80211MgmtAp::handleAuthenticationFrame(Packet *packet, const Ptr<const
         sta->address = staAddress;
         mib->bssAccessPointData.stations[staAddress] = Ieee80211Mib::NOT_AUTHENTICATED;
         sta->authSeqExpected = 1;
-        clearPendingAssociation(sta);
     }
+    clearPendingAssociation(sta);
 
     // reset authentication status, when starting a new auth sequence
     // The statements below are added because the L2 handover time was greater than before when
@@ -263,7 +310,6 @@ void Ieee80211MgmtAp::handleAuthenticationFrame(Packet *packet, const Ptr<const
             mib->releaseAssociationId(sta->address);
         }
         mib->bssAccessPointData.stations[sta->address] = Ieee80211Mib::NOT_AUTHENTICATED;
-        clearPendingAssociation(sta);
         mib->removePeerHtCapabilities(sta->address);
         sta->authSeqExpected = 1;
     }
@@ -336,6 +382,8 @@ void Ieee80211MgmtAp::handleAssociationRequestFrame(Packet *packet, const Ptr<co
 
     // "11.3.2 AP association procedures"
     StaInfo *sta = lookupSenderSTA(header);
+    if (sta != nullptr)
+        clearPendingAssociation(sta);
     if (!sta || mib->bssAccessPointData.stations[sta->address] == Ieee80211Mib::NOT_AUTHENTICATED) {
         // STA not authenticated: send error and return
         const auto& body = makeShared<Ieee80211DeauthenticationFrame>();
@@ -346,7 +394,6 @@ void Ieee80211MgmtAp::handleAssociationRequestFrame(Packet *packet, const Ptr<co
     }
 
     const auto& requestBody = packet->peekData<Ieee80211AssociationRequestFrame>();
-    clearPendingAssociation(sta);
     sta->pendingAssociationSuccessful = false;
     sta->pendingHtStateAvailable = true;
     sta->pendingHtCapabilitiesValid = mib->isHtOperationSupported() && requestBody->getHtCapabilitiesPresent();
@@ -367,6 +414,7 @@ void Ieee80211MgmtAp::handleAssociationRequestFrame(Packet *packet, const Ptr<co
     addHtCapabilities(body);
     addHtOperation(body);
     body->setChunkLength(B(2 + 2 + 2 + body->getSupportedRates().numRates + 2) + getHtMgmtElementsLength(body));
+    startAssociationResponseTimeout(sta);
     sendManagementFrame(basicHtMcsSupported ? "AssocResp-OK" : "AssocResp-UnsupportedHtMcs", body, ST_ASSOCIATIONRESPONSE, sta->address, sta->pendingAssociationTransactionId);
 }
 
@@ -381,6 +429,8 @@ void Ieee80211MgmtAp::handleReassociationRequestFrame(Packet *packet, const Ptr<
 
     // "11.3.4 AP reassociation procedures" -- almost the same as AssociationRequest processing
     StaInfo *sta = lookupSenderSTA(header);
+    if (sta != nullptr)
+        clearPendingAssociation(sta);
     if (!sta || mib->bssAccessPointData.stations[sta->address] == Ieee80211Mib::NOT_AUTHENTICATED) {
         // STA not authenticated: send error and return
         const auto& body = makeShared<Ieee80211DeauthenticationFrame>();
@@ -391,7 +441,6 @@ void Ieee80211MgmtAp::handleReassociationRequestFrame(Packet *packet, const Ptr<
     }
 
     const auto& requestBody = packet->peekData<Ieee80211ReassociationRequestFrame>();
-    clearPendingAssociation(sta);
     sta->pendingAssociationSuccessful = false;
     sta->pendingHtStateAvailable = true;
     sta->pendingHtCapabilitiesValid = mib->isHtOperationSupported() && requestBody->getHtCapabilitiesPresent();
@@ -412,6 +461,7 @@ void Ieee80211MgmtAp::handleReassociationRequestFrame(Packet *packet, const Ptr<
     addHtCapabilities(body);
     addHtOperation(body);
     body->setChunkLength(B(2 + 2 + 2 + (2 + supportedRates.numRates)) + getHtMgmtElementsLength(body));
+    startAssociationResponseTimeout(sta);
     sendManagementFrame(basicHtMcsSupported ? "ReassocResp-OK" : "ReassocResp-UnsupportedHtMcs", body, ST_REASSOCIATIONRESPONSE, sta->address, sta->pendingAssociationTransactionId);
 }
 
@@ -497,6 +547,7 @@ void Ieee80211MgmtAp::start()
 void Ieee80211MgmtAp::stop()
 {
     cancelEvent(beaconTimer);
+    cancelEvent(associationResponseTimeoutTimer);
     staList.clear();
     mib->clearAssociationIds();
     Ieee80211MgmtApBase::stop();

src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtAp.h

@@ -38,6 +38,7 @@ class INET_API Ieee80211MgmtAp : public Ieee80211MgmtApBase
         int authSeqExpected; // when NOT_AUTHENTICATED: transaction sequence number of next expected auth frame
         bool pendingAssociationSuccessful = false;
         uint64_t pendingAssociationTransactionId = 0;
+        simtime_t pendingAssociationDeadline = SIMTIME_MAX;
         bool pendingHtStateAvailable = false;
         bool pendingHtCapabilitiesValid = false;
         Ieee80211HtCapabilities pendingHtCapabilities;
@@ -67,12 +68,17 @@ class INET_API Ieee80211MgmtAp : public Ieee80211MgmtApBase
     std::string ssid;
     int channelNumber = -1;
     simtime_t beaconInterval;
+    simtime_t associationResponseTimeout;
     int numAuthSteps = 0;
 
     // state
     StaList staList; ///< list of STAs
     cMessage *beaconTimer = nullptr;
+    cMessage *associationResponseTimeoutTimer = nullptr;
     uint64_t nextAssociationTransactionId = 0;
+    MacAddress scheduledAssociationResponseTimeoutAddress;
+    uint64_t scheduledAssociationResponseTimeoutTransactionId = 0;
+    simtime_t scheduledAssociationResponseTimeoutDeadline = SIMTIME_MAX;
 
   public:
     Ieee80211MgmtAp() {}
@@ -100,8 +106,11 @@ class INET_API Ieee80211MgmtAp : public Ieee80211MgmtApBase
 
     static const Packet *getAssociationResponseFrame(ITransmitStep *transmitStep);
     static AssociationResponseDisposition getAssociationResponseDisposition(const Packet *responseFrame, uint64_t pendingTransactionId, bool exchangeSucceeded, bool retryPending);
+    static bool isAssociationResponseTimeoutDue(const StaInfo& sta, uint64_t transactionId, simtime_t deadline, simtime_t currentTime);
     virtual uint64_t createAssociationTransactionId();
     virtual void clearPendingAssociation(StaInfo *sta);
+    virtual void scheduleAssociationResponseTimeout();
+    virtual void startAssociationResponseTimeout(StaInfo *sta);
 
     /** Utility function: creates and sends a beacon frame */
     virtual void sendBeacon();

src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtAp.ned

@@ -26,6 +26,7 @@ simple Ieee80211MgmtAp extends SimpleModule like IIeee80211Mgmt
         @class(Ieee80211MgmtAp);
         string ssid = default("SSID");
         double beaconInterval @unit(s) = default(100ms);
+        double associationResponseTimeout @unit(s) = default(5s); // Maximum time to retain an incomplete (re)association response transaction
         int numAuthSteps = default(4); // Use 2 for Open System auth, 4 for WEP
         string interfaceTableModule;
         string radioModule = default("^.radio");   // The path to the Radio module  //FIXME remove default value

src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtFrameSerializer.h

@@ -19,6 +19,8 @@ namespace ieee80211 {
 
 /**
  * Converts between Ieee80211MgmtFrame and binary network byte order IEEE 802.11 mgmt frame.
+ * The input stream passed to deserialize() must be bounded to the exact management-frame body;
+ * all bytes remaining after the fixed fields are interpreted as management elements.
  */
 class INET_API Ieee80211MgmtFrameSerializer : public FieldsChunkSerializer
 {

src/inet/linklayer/ieee80211/mgmt/Ieee80211MgmtStaSimplified.cc

@@ -15,6 +15,19 @@ namespace ieee80211 {
 
 Define_Module(Ieee80211MgmtStaSimplified);
 
+static Ieee80211Mib *findAccessPointMib(const MacAddress& accessPointAddress)
+{
+    L3AddressResolver addressResolver;
+    auto host = addressResolver.findHostWithAddress(accessPointAddress);
+    if (host == nullptr)
+        throw cRuntimeError("Access point with address %s not found", accessPointAddress.str().c_str());
+    auto interfaceTable = addressResolver.findInterfaceTableOf(host);
+    auto networkInterface = interfaceTable->findInterfaceByAddress(accessPointAddress);
+    if (networkInterface == nullptr)
+        throw cRuntimeError("Access point interface with address %s not found", accessPointAddress.str().c_str());
+    return check_and_cast<Ieee80211Mib *>(networkInterface->getSubmodule("mib"));
+}
+
 void Ieee80211MgmtStaSimplified::initialize(int stage)
 {
     Ieee80211MgmtBase::initialize(stage);
@@ -23,18 +36,16 @@ void Ieee80211MgmtStaSimplified::initialize(int stage)
         mib->bssStationData.stationType = Ieee80211Mib::STATION;
         mib->bssStationData.isAssociated = true;
     }
-    else if (stage == INITSTAGE_LAST) {
+    else if (stage == INITSTAGE_LINK_LAYER) {
         L3AddressResolver addressResolver;
         auto accessPointAddress = addressResolver.resolve(par("accessPointAddress"), L3AddressResolver::ADDR_MAC).toMac();
         mib->bssData.bssid = accessPointAddress;
-        auto host = addressResolver.findHostWithAddress(mib->bssData.bssid);
-        if (host == nullptr)
-            throw cRuntimeError("Access point with address %s not found", mib->bssData.bssid.str().c_str());
-        auto interfaceTable = addressResolver.findInterfaceTableOf(host);
-        auto networkInterface = interfaceTable->findInterfaceByAddress(mib->bssData.bssid);
-        auto apMib = dynamic_cast<Ieee80211Mib *>(networkInterface->getSubmodule("mib"));
+        auto apMib = findAccessPointMib(accessPointAddress);
         apMib->bssAccessPointData.stations[mib->address] = Ieee80211Mib::ASSOCIATED;
         mib->bssData.ssid = apMib->bssData.ssid;
+    }
+    else if (stage == INITSTAGE_LAST) {
+        auto apMib = findAccessPointMib(mib->bssData.bssid);
         // Simplified management is an explicit no-air abstraction: install the state that the
         // Association Request/Response exchange would have committed in detailed management.
         if (mib->isHtOperationSupported() && apMib->isHtOperationSupported()) {