BearerConfigurator: a remembered multicast flow belongs to its sender, not just its group

multicastFlows_ was keyed by multicast group id alone, with the first sender to
establish the bearer winning and the entry never removed. Both halves of that
are wrong once the node population changes during the simulation:

- Nothing dropped the entry when its sender left, so multicastGroupJoined() kept
  provisioning later joiners against a bearer whose TX side no longer exists.

- With the entry pinned to the first sender, a node that takes over the group
  afterwards never got remembered at all -- and a group served by two senders
  at once only ever had one of them remembered.

Neither is cosmetic, because the RX side of a bearer is keyed by its sender:
FlowId::rxDrbKey() builds the DrbKey from sourceId, and
BearerManagement::createIncomingConnection() installs the MAC descriptor under
MacCid(senderId, lcid). Provisioning a joiner from a stale flow therefore
creates a descriptor under the *departed* sender's CID, while the PDUs that
actually arrive carry the current sender's -- which lands in exactly the
'connDescIn_.find(cid) != connDescIn_.end()' assert in macPduUnmake() that
multicastGroupJoined() was added to prevent.

So the map is now keyed by (group id, sender id): createConnection() remembers
one flow per sender, multicastGroupJoined() gives the joiner an RX leg for each
remembered sender of the group, and the node-unregistered listener drops the
entries of a departing sender.

Full fingerprint suite 182/182 PASS, CSVs unchanged: in the static scenarios
each group has one sender that never leaves, so the keying change is inert and
the purge never runs.

Author: torokati44

src/simu5g/corenetwork/bearerConfigurator/BearerConfigurator.cc

@@ -921,6 +921,19 @@ void BearerConfigurator::receiveSignal(cComponent *source, simsignal_t signalID,
         else
             ++it;
     }
+
+    // The remembered multicast flows are keyed by group but owned by their sender: drop the
+    // ones this node established, or multicastGroupJoined() would keep handing later joiners
+    // an RX leg keyed to a sender that no longer transmits -- and, since the RX descriptor's
+    // MacCid carries that sender's id, the PDUs of whichever node took over the group would
+    // then arrive on a connection the joiner has no descriptor for. A replacement sender's
+    // createConnection() stores a fresh flow, so the group keeps working.
+    for (auto it = multicastFlows_.begin(); it != multicastFlows_.end(); ) {
+        if (it->first.second == id)
+            it = multicastFlows_.erase(it);
+        else
+            ++it;
+    }
 }
 
 void BearerConfigurator::createConnection(const FlowId& flow, const BearerRequest& req, bool withPdcp)
@@ -960,8 +973,9 @@ void BearerConfigurator::createConnection(const FlowId& flow, const BearerReques
     else {
         // Remember the flow so that nodes joining this group later still get an RX leg; the
         // loop below can only reach the members that already exist. See multicastGroupJoined().
-        if (multicastFlows_.find(groupId) == multicastFlows_.end())
-            multicastFlows_[groupId] = { flow, req, withPdcp };
+        auto flowKey = std::make_pair(groupId, sourceId);
+        if (multicastFlows_.find(flowKey) == multicastFlows_.end())
+            multicastFlows_[flowKey] = { flow, req, withPdcp };
 
         // Multicast bearers stay unidirectional: TX at the sender, RX at the members
         for (auto& [nodeId,_] : binder_->getNodeInfoMap())  //TODO use lte ones if LTE in DC setup, and NR ones if NR in DC setup
@@ -975,10 +989,13 @@ void BearerConfigurator::multicastGroupJoined(MacNodeId nodeId, MacNodeId groupI
 {
     Enter_Method("multicastGroupJoined(%hu, %hu)", (unsigned short)nodeId, (unsigned short)groupId);
 
-    auto it = multicastFlows_.find(groupId);
-    if (it != multicastFlows_.end() && nodeId != it->second.flow.sourceId)
-        createIncomingConnectionOnNode(nodeId, it->second.flow, it->second.req,
-                getNodeTypeById(nodeId) == UE || it->second.withPdcp);
+    for (auto& [key, mf] : multicastFlows_) {
+        auto& [flowGroupId, senderId] = key;
+        if (flowGroupId != groupId || senderId == nodeId)
+            continue;
+        createIncomingConnectionOnNode(nodeId, mf.flow, mf.req,
+                getNodeTypeById(nodeId) == UE || mf.withPdcp);
+    }
 }
 
 void BearerConfigurator::createIncomingConnectionOnNode(MacNodeId nodeId, const FlowId& flow, const BearerRequest& req, bool withPdcp)

src/simu5g/corenetwork/bearerConfigurator/BearerConfigurator.h

@@ -75,14 +75,19 @@ class BearerConfigurator : public cSimpleModule, public cListener
      * provisions the members that exist when the sender starts, which is all of them only if
      * the node population is static; with nodes created during the simulation the joiner
      * would otherwise receive PDUs for a connection its stack knows nothing about.
-     * Keyed by multicast group id; the first sender to establish the bearer wins.
+     *
+     * Keyed by (multicast group id, sender id): the RX side of a bearer is keyed by its
+     * sender (see FlowId::rxDrbKey, and MacCid(senderId, lcid) in
+     * BearerManagement::createIncomingConnection), so a group served by several senders --
+     * at once, or one after another as vehicles come and go -- needs one remembered flow per
+     * sender. Each entry is dropped when its sender leaves, see receiveSignal().
      */
     struct MulticastFlow {
         FlowId flow;
         BearerRequest req;
         bool withPdcp = false;
     };
-    std::map<MacNodeId, MulticastFlow> multicastFlows_;
+    std::map<std::pair<MacNodeId, MacNodeId>, MulticastFlow> multicastFlows_;
 
 
   protected: