No using "<vector>" to fix the error from check_include_config.py

crlonxp · crlonxp · commit 7a92e0716326 · 2025-03-13T17:34:23.000+08:00
Change the management of PAFInfo items

Signed-off-by: Lo,Chin-Ran &lt;chin-ran.lo@nxp.com&gt;
diff --git a/scripts/tools/check_includes_config.py b/scripts/tools/check_includes_config.py
@@ -188,7 +188,6 @@
     'src/controller/CHIPDeviceController.cpp': {'string'},
     'src/qrcodetool/setup_payload_commands.cpp': {'string'},
     'src/access/AccessRestrictionProvider.h': {'vector', 'map'},
-    'src/wifipaf/WiFiPAFLayer.h': {'vector'},
     # nrfconnect test runner
     'src/test_driver/nrfconnect/main/runner.cpp': {'vector'},
 }
diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp
@@ -843,7 +843,9 @@ CHIP_ERROR DeviceCommissioner::EstablishPASEConnection(NodeId remoteDeviceId, Re
             VerifyOrReturnValue(!connDiscriminator.IsShortDiscriminator(), CHIP_ERROR_INVALID_ARGUMENT,
                                 ChipLogError(Controller, "Error, Long discriminator is required"));
             uint16_t discriminator = connDiscriminator.GetLongValue();
-            DeviceLayer::ConnectivityMgr().GetWiFiPAF()->AddPafSession(nodeId, discriminator);
+            WiFiPAF::WiFiPAFSession sessionInfo = { .nodeId = nodeId, .discriminator = discriminator};
+            ReturnErrorOnFailure(
+                DeviceLayer::ConnectivityMgr().GetWiFiPAF()->AddPafSession(WiFiPAF::PafInfoAccess::kAccNodeInfo, sessionInfo));
             DeviceLayer::ConnectivityMgr().WiFiPAFSubscribe(discriminator, reinterpret_cast<void *>(this),
                                                             OnWiFiPAFSubscribeComplete, OnWiFiPAFSubscribeError);
             ExitNow(CHIP_NO_ERROR);
diff --git a/src/controller/SetUpCodePairer.cpp b/src/controller/SetUpCodePairer.cpp
@@ -264,7 +264,9 @@ CHIP_ERROR SetUpCodePairer::StartDiscoverOverWiFiPAF(SetupPayload & payload)
     VerifyOrReturnValue(!connDiscriminator.IsShortDiscriminator(), CHIP_ERROR_INVALID_ARGUMENT,
                         ChipLogError(Controller, "Error, Long discriminator is required"));
     uint16_t discriminator = connDiscriminator.GetLongValue();
-    DeviceLayer::ConnectivityMgr().GetWiFiPAF()->AddPafSession(mRemoteId, discriminator);
+    WiFiPAF::WiFiPAFSession sessionInfo = { .nodeId = mRemoteId, .discriminator = discriminator};
+    ReturnErrorOnFailure(
+        DeviceLayer::ConnectivityMgr().GetWiFiPAF()->AddPafSession(WiFiPAF::PafInfoAccess::kAccNodeInfo, sessionInfo));
     CHIP_ERROR err = DeviceLayer::ConnectivityMgr().WiFiPAFSubscribe(discriminator, (void *) this, OnWiFiPAFSubscribeComplete,
                                                                      OnWiFiPAFSubscribeError);
     if (err != CHIP_NO_ERROR)
diff --git a/src/platform/Linux/ConnectivityManagerImpl.cpp b/src/platform/Linux/ConnectivityManagerImpl.cpp
@@ -76,6 +76,9 @@ using namespace ::chip::app::Clusters::GeneralDiagnostics;
 using namespace ::chip::app::Clusters::WiFiNetworkDiagnostics;
 
 using namespace ::chip::DeviceLayer::NetworkCommissioning;
+#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
+using namespace ::chip::WiFiPAF;
+#endif
 
 namespace chip {
 
@@ -938,7 +941,9 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFPublish(ConnectivityManager::WiFiPAF
     wpa_supplicant_1_interface_call_nanpublish_sync(mWpaSupplicant.iface, args, &publish_id, nullptr, &err.GetReceiver());
 
     ChipLogProgress(DeviceLayer, "WiFi-PAF: publish_id: %u ! ", publish_id);
-    _GetWiFiPAF()->AddPafSession(publish_id);
+    WiFiPAFSession sessionInfo = { .id = publish_id };
+    ReturnErrorOnFailure(
+        _GetWiFiPAF()->AddPafSession(PafInfoAccess::kAccSessionId, sessionInfo));
     InArgs.publish_id = publish_id;
 
     g_signal_connect(mWpaSupplicant.iface, "nanreplied",
@@ -1461,7 +1466,8 @@ void ConnectivityManagerImpl::OnDiscoveryResult(GVariant * discov_info)
     /*
         Error Checking
     */
-    auto pPafInfo = _GetWiFiPAF()->GetPAFInfo(pPublishSSI->DevInfo);
+    WiFiPAFSession sessionInfo = { .discriminator = pPublishSSI->DevInfo};
+    auto pPafInfo = _GetWiFiPAF()->GetPAFInfo(PafInfoAccess::kAccDisc, sessionInfo);
     if (pPafInfo == nullptr)
     {
         ChipLogError(DeviceLayer, "WiFi-PAF: DiscoveryResult, no valid session with discriminator: %u", pPublishSSI->DevInfo);
@@ -1559,7 +1565,8 @@ void ConnectivityManagerImpl::OnReplied(GVariant * reply_info)
                         SetupDiscriminator);
         return;
     }
-    auto pPafInfo = _GetWiFiPAF()->GetPAFInfo(publish_id);
+    WiFiPAFSession sessionInfo = { .id = publish_id };
+    auto pPafInfo = _GetWiFiPAF()->GetPAFInfo(PafInfoAccess::kAccSessionId, sessionInfo);
     if (pPafInfo == nullptr)
     {
         ChipLogError(DeviceLayer, "WiFi-PAF: OnReplied, no valid session with publish_id: %d", publish_id);
@@ -1635,13 +1642,15 @@ void ConnectivityManagerImpl::OnNanReceive(GVariant * obj)
 void ConnectivityManagerImpl::OnNanPublishTerminated(guint public_id, gchar * reason)
 {
     ChipLogProgress(Controller, "WiFi-PAF: Publish terminated (%u, %s)", public_id, reason);
-    _GetWiFiPAF()->RmPafSession(public_id);
+    WiFiPAFSession sessionInfo = { .id = public_id };
+    _GetWiFiPAF()->RmPafSession(PafInfoAccess::kAccSessionId, sessionInfo);
 }
 
 void ConnectivityManagerImpl::OnNanSubscribeTerminated(guint subscribe_id, gchar * reason)
 {
     ChipLogProgress(Controller, "WiFi-PAF: Subscription terminated (%u, %s)", subscribe_id, reason);
-    _GetWiFiPAF()->RmPafSession(subscribe_id);
+    WiFiPAFSession sessionInfo = { .id = subscribe_id };
+    _GetWiFiPAF()->RmPafSession(PafInfoAccess::kAccSessionId, sessionInfo);
     /*
         Indicate the connection event
     */
@@ -1699,7 +1708,8 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFSubscribe(const uint16_t & connDiscr
     mOnPafSubscribeComplete = onSuccess;
     mOnPafSubscribeError    = onError;
 
-    auto pPafInfo = _GetWiFiPAF()->GetPAFInfo(PafPublish_ssi.DevInfo);
+    WiFiPAFSession sessionInfo = { .discriminator = PafPublish_ssi.DevInfo};
+    auto pPafInfo = _GetWiFiPAF()->GetPAFInfo(PafInfoAccess::kAccDisc, sessionInfo);
     if (pPafInfo != nullptr)
     {
         pPafInfo->id   = subscribe_id;
diff --git a/src/transport/raw/WiFiPAF.cpp b/src/transport/raw/WiFiPAF.cpp
@@ -71,7 +71,8 @@ CHIP_ERROR WiFiPAFBase::SendMessage(const Transport::PeerAddress & address, Pack
     VerifyOrReturnError(address.GetTransportType() == Type::kWiFiPAF, CHIP_ERROR_INVALID_ARGUMENT);
     VerifyOrReturnError(mWiFiPAFLayer->GetWiFiPAFState() != State::kNotReady, CHIP_ERROR_INCORRECT_STATE);
 
-    WiFiPAFSession * pTxInfo = mWiFiPAFLayer->GetPAFInfo(address.GetRemoteId());
+    WiFiPAFSession sessionInfo = { .nodeId = address.GetRemoteId() };
+    WiFiPAFSession * pTxInfo = mWiFiPAFLayer->GetPAFInfo(chip::WiFiPAF::PafInfoAccess::kAccNodeId, sessionInfo);
     if (pTxInfo == nullptr)
     {
         /*
@@ -96,7 +97,7 @@ bool WiFiPAFBase::CanSendToPeer(const Transport::PeerAddress & address)
 
 CHIP_ERROR WiFiPAFBase::WiFiPAFMessageReceived(WiFiPAFSession & RxInfo, PacketBufferHandle && buffer)
 {
-    auto pPafInfo = mWiFiPAFLayer->GetPAFInfo(RxInfo.id);
+    auto pPafInfo = mWiFiPAFLayer->GetPAFInfo(chip::WiFiPAF::PafInfoAccess::kAccSessionId, RxInfo);
     if (pPafInfo == nullptr)
     {
         /*
diff --git a/src/wifipaf/WiFiPAFLayer.cpp b/src/wifipaf/WiFiPAFLayer.cpp
@@ -228,6 +228,11 @@ CHIP_ERROR PAFTransportCapabilitiesResponseMessage::Decode(const PacketBufferHan
  * WiFiPAFLayer Implementation
  */
 
+WiFiPAFLayer::WiFiPAFLayer()
+{
+    InitialPafInfo();
+}
+
 CHIP_ERROR WiFiPAFLayer::Init(chip::System::Layer * systemLayer)
 {
     mSystemLayer = systemLayer;
@@ -238,23 +243,26 @@ CHIP_ERROR WiFiPAFLayer::Init(chip::System::Layer * systemLayer)
 
 void WiFiPAFLayer::Shutdown(OnCancelDeviceHandle OnCancelDevice)
 {
-    ChipLogProgress(WiFiPAF, "WiFiPAF: Closing all WiFiPAF sessions (%lu)", PafInfoVect.size());
-    for (WiFiPAFSession & PafInfoElm : PafInfoVect)
+    ChipLogProgress(WiFiPAF, "WiFiPAF: Closing all WiFiPAF sessions to shutdown");
+    uint8_t i;
+    WiFiPAFSession *pPafSession;
+
+    for (i=0 ; i<WIFIPAF_LAYER_NUM_PAF_ENDPOINTS ; i++)
     {
-        if (PafInfoElm.id == UINT32_MAX)
+        pPafSession = &mPafInfoVect[i];
+        if (pPafSession->id == UINT32_MAX)
         {
             // Unused session
             continue;
         }
-        ChipLogProgress(WiFiPAF, "WiFiPAF: Canceling id: %u", PafInfoElm.id);
-        OnCancelDevice(PafInfoElm.id, PafInfoElm.role);
-        WiFiPAFEndPoint * endPoint = sWiFiPAFEndPointPool.Find(reinterpret_cast<WIFIPAF_CONNECTION_OBJECT>(&PafInfoElm));
+        ChipLogProgress(WiFiPAF, "WiFiPAF: Canceling id: %u", pPafSession->id);
+        OnCancelDevice(pPafSession->id, pPafSession->role);
+        WiFiPAFEndPoint * endPoint = sWiFiPAFEndPointPool.Find(reinterpret_cast<WIFIPAF_CONNECTION_OBJECT>(pPafSession));
         if (endPoint != nullptr)
         {
             endPoint->DoClose(kWiFiPAFCloseFlag_AbortTransmission, WIFIPAF_ERROR_APP_CLOSED_CONNECTION);
         }
     }
-    PafInfoVect.clear();
 }
 
 bool WiFiPAFLayer::OnWiFiPAFMessageReceived(WiFiPAFSession & RxInfo, System::PacketBufferHandle && msg)
@@ -384,84 +392,144 @@ WiFiPAFLayer::GetHighestSupportedProtocolVersion(const PAFTransportCapabilitiesR
     return retVersion;
 }
 
-void WiFiPAFLayer::AddPafSession(const NodeId nodeId, const uint16_t discriminator)
+#define INVALID_PAF_SESSION_ID      0xff
+void WiFiPAFLayer::InitialPafInfo()
 {
-    for (auto PafInfoElm : PafInfoVect)
+    for (uint8_t i=0 ; i<WIFIPAF_LAYER_NUM_PAF_ENDPOINTS ; i++)
     {
-        if (PafInfoElm.nodeId == nodeId)
-        {
-            assert(PafInfoElm.discriminator == discriminator);
-            // Already exist
-            return;
-        }
+        cleanPafInfo(mPafInfoVect[i]);
     }
-    PafInfoVect.push_back({ .id = UINT32_MAX, .peer_id = UINT32_MAX, .nodeId = nodeId, .discriminator = discriminator });
-    ChipLogProgress(WiFiPAF, "WiFiPAF: Add session with nodeId: %lu, disc: %x, total %lu sessions", nodeId, discriminator,
-                    PafInfoVect.size());
 }
 
-void WiFiPAFLayer::AddPafSession(uint32_t id)
+void WiFiPAFLayer::cleanPafInfo(WiFiPAFSession & SessionInfo)
 {
-    for (auto PafInfoElm : PafInfoVect)
-    {
-        if (PafInfoElm.id == id)
-        {
-            // Already exist
-            return;
-        }
-    }
-    PafInfoVect.push_back({ .id = id });
-    ChipLogProgress(WiFiPAF, "WiFiPAF: Add session with id: %u, total %lu sessions", id, PafInfoVect.size());
+    memset(&SessionInfo, 0, sizeof(WiFiPAFSession));
+    SessionInfo.id = UINT32_MAX;
+    SessionInfo.peer_id = UINT32_MAX;
+    SessionInfo.nodeId = UINT32_MAX;
+    SessionInfo.discriminator = UINT16_MAX;
+    return;
 }
 
-void WiFiPAFLayer::RmPafSession(uint32_t id)
+CHIP_ERROR WiFiPAFLayer::AddPafSession(PafInfoAccess accType, WiFiPAFSession &SessionInfo)
 {
-    for (std::vector<WiFiPAFSession>::iterator it = PafInfoVect.begin(); it != PafInfoVect.end(); it++)
+    uint8_t i;
+    uint8_t eSlotId = INVALID_PAF_SESSION_ID;
+    WiFiPAFSession *pPafSession = nullptr;
+
+    // Check if the session has existed
+    for (i=0 ; i<WIFIPAF_LAYER_NUM_PAF_ENDPOINTS ; i++)
     {
-        if (it->id == id)
+        pPafSession = &mPafInfoVect[i];
+        switch (accType)
         {
-            PafInfoVect.erase(it);
-            return;
-        }
+            case PafInfoAccess::kAccNodeInfo:
+                if (pPafSession->nodeId == SessionInfo.nodeId)
+                {
+                    assert(pPafSession->discriminator == SessionInfo.discriminator);
+                    // Already exist
+                    return CHIP_NO_ERROR;
+                }
+                break;
+            case PafInfoAccess::kAccSessionId:
+                if (pPafSession->id == SessionInfo.id)
+                {
+                    // Already exist
+                    return CHIP_NO_ERROR;
+                }
+                break;
+            default:
+                return CHIP_ERROR_NOT_IMPLEMENTED;
+        };
+        if ((pPafSession->id == UINT32_MAX) && (pPafSession->nodeId == UINT32_MAX) &&
+            (pPafSession->discriminator == UINT16_MAX))
+            eSlotId = i;
     }
-}
-
-WiFiPAFSession * WiFiPAFLayer::GetPAFInfo(NodeId nodeId)
-{
-    for (WiFiPAFSession & PafInfoElm : PafInfoVect)
+    // Add the session if available
+    if (eSlotId != INVALID_PAF_SESSION_ID)
     {
-        if (PafInfoElm.nodeId == nodeId)
+        pPafSession = &mPafInfoVect[eSlotId];
+        switch (accType)
         {
-            return &PafInfoElm;
-        }
+            case PafInfoAccess::kAccNodeInfo:
+                pPafSession->nodeId = SessionInfo.nodeId;
+                pPafSession->discriminator = SessionInfo.discriminator;
+                ChipLogProgress(WiFiPAF, "WiFiPAF: Add session with nodeId: %lu, disc: %x, sessions",
+                    SessionInfo.nodeId, SessionInfo.discriminator);
+                return CHIP_NO_ERROR;
+            case PafInfoAccess::kAccSessionId:
+                pPafSession->id = SessionInfo.id;
+                ChipLogProgress(WiFiPAF, "WiFiPAF: Add session with id: %u", SessionInfo.id);
+                return CHIP_NO_ERROR;
+            default:
+                return CHIP_ERROR_NOT_IMPLEMENTED;
+        };
     }
-    return nullptr;
+    ChipLogError(WiFiPAF, "WiFiPAF: No available space for the new sessions");
+    return CHIP_ERROR_PROVIDER_LIST_EXHAUSTED;
 }
 
-WiFiPAFSession * WiFiPAFLayer::GetPAFInfo(uint32_t id)
+CHIP_ERROR WiFiPAFLayer::RmPafSession(PafInfoAccess accType, WiFiPAFSession &SessionInfo)
 {
-    for (WiFiPAFSession & PafInfoElm : PafInfoVect)
+    uint8_t i;
+    WiFiPAFSession *pPafSession;
+
+    for (i=0 ; i<WIFIPAF_LAYER_NUM_PAF_ENDPOINTS ; i++)
     {
-        if (PafInfoElm.id == id)
+        pPafSession = &mPafInfoVect[i];
+        switch (accType)
         {
-            return &PafInfoElm;
-        }
+            case PafInfoAccess::kAccSessionId:
+                if (pPafSession->id == SessionInfo.id)
+                {
+                    ChipLogProgress(WiFiPAF, "Removing session with id: %u", pPafSession->id);
+                    // Clear the slot
+                    cleanPafInfo(*pPafSession);
+                    return CHIP_NO_ERROR;
+                }
+                break;
+            default:
+                return CHIP_ERROR_NOT_IMPLEMENTED;
+        };
     }
-    return nullptr;
+    ChipLogError(WiFiPAF, "No PAF session found");
+    return CHIP_ERROR_NOT_FOUND;
 }
 
-WiFiPAFSession * WiFiPAFLayer::GetPAFInfo(uint16_t discriminator)
+WiFiPAFSession * WiFiPAFLayer::GetPAFInfo(PafInfoAccess accType, WiFiPAFSession &SessionInfo)
 {
-    for (WiFiPAFSession & PafInfoElm : PafInfoVect)
+    uint8_t i;
+    WiFiPAFSession *pPafSession = nullptr;
+
+    for (i=0 ; i<WIFIPAF_LAYER_NUM_PAF_ENDPOINTS ; i++)
     {
-        if (PafInfoElm.discriminator == discriminator)
+        pPafSession = &mPafInfoVect[i];
+        switch (accType)
         {
-            // Available session
-            return &PafInfoElm;
-        }
+            case PafInfoAccess::kAccSessionId:
+                if (pPafSession->id == SessionInfo.id)
+                {
+                    return pPafSession;
+                }
+                break;
+            case PafInfoAccess::kAccNodeId:
+                if (pPafSession->nodeId == SessionInfo.nodeId)
+                {
+                    return pPafSession;
+                }
+                break;
+            case PafInfoAccess::kAccDisc:
+                if (pPafSession->discriminator == SessionInfo.discriminator)
+                {
+                    return pPafSession;
+                }
+                break;
+            default:
+                return nullptr;
+        };
     }
+
     return nullptr;
 }
-
 } /* namespace WiFiPAF */
 } /* namespace chip */
diff --git a/src/wifipaf/WiFiPAFLayer.h b/src/wifipaf/WiFiPAFLayer.h

Original file line number	Diff line number	Diff line change
`@@ -188,7 +188,6 @@`
`188`	`188`	`'src/controller/CHIPDeviceController.cpp': {'string'},`
`189`	`189`	`'src/qrcodetool/setup_payload_commands.cpp': {'string'},`
`190`	`190`	`'src/access/AccessRestrictionProvider.h': {'vector', 'map'},`
`191`		`- 'src/wifipaf/WiFiPAFLayer.h': {'vector'},`
`192`	`191`	`# nrfconnect test runner`
`193`	`192`	`'src/test_driver/nrfconnect/main/runner.cpp': {'vector'},`
`194`	`193`	`}`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,8 @@ CHIP_ERROR WiFiPAFBase::SendMessage(const Transport::PeerAddress & address, Pack`
`71`	`71`	`VerifyOrReturnError(address.GetTransportType() == Type::kWiFiPAF, CHIP_ERROR_INVALID_ARGUMENT);`
`72`	`72`	`VerifyOrReturnError(mWiFiPAFLayer->GetWiFiPAFState() != State::kNotReady, CHIP_ERROR_INCORRECT_STATE);`
`73`	`73`
`74`		`- WiFiPAFSession * pTxInfo = mWiFiPAFLayer->GetPAFInfo(address.GetRemoteId());`
	`74`	`+ WiFiPAFSession sessionInfo = { .nodeId = address.GetRemoteId() };`
	`75`	`+ WiFiPAFSession * pTxInfo = mWiFiPAFLayer->GetPAFInfo(chip::WiFiPAF::PafInfoAccess::kAccNodeId, sessionInfo);`
`75`	`76`	`if (pTxInfo == nullptr)`
`76`	`77`	`{`
`77`	`78`	`/*`
`@@ -96,7 +97,7 @@ bool WiFiPAFBase::CanSendToPeer(const Transport::PeerAddress & address)`
`96`	`97`
`97`	`98`	`CHIP_ERROR WiFiPAFBase::WiFiPAFMessageReceived(WiFiPAFSession & RxInfo, PacketBufferHandle && buffer)`
`98`	`99`	`{`
`99`		`- auto pPafInfo = mWiFiPAFLayer->GetPAFInfo(RxInfo.id);`
	`100`	`+ auto pPafInfo = mWiFiPAFLayer->GetPAFInfo(chip::WiFiPAF::PafInfoAccess::kAccSessionId, RxInfo);`
`100`	`101`	`if (pPafInfo == nullptr)`
`101`	`102`	`{`
`102`	`103`	`/*`