Fix the error that PAF can't start multiple times in using chip-tool interactive mode

crlonxp · crlonxp · commit 9a51a1d493b3 · 2025-03-17T21:27:19.000+08:00
Fix the code style problems

Signed-off-by: Lo,Chin-Ran &lt;chin-ran.lo@nxp.com&gt;
diff --git a/src/app/server/CommissioningWindowManager.cpp b/src/app/server/CommissioningWindowManager.cpp
@@ -73,7 +73,7 @@ void CommissioningWindowManager::OnPlatformEvent(const DeviceLayer::ChipDeviceEv
         mServer->GetBleLayerObject()->CloseAllBleConnections();
 #endif
 #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
-        chip::WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer()->Shutdown(
+        chip::WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer().Shutdown(
             [](uint32_t id, WiFiPAF::WiFiPafRole role) { DeviceLayer::ConnectivityMgr().WiFiPAFShutdown(id, role); });
 #endif
     }
diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp
@@ -572,7 +572,7 @@ void DeviceCommissioner::Shutdown()
     }
 #endif // CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY
 #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
-    WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer()->Shutdown(
+    WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer().Shutdown(
         [](uint32_t id, WiFiPAF::WiFiPafRole role) { DeviceLayer::ConnectivityMgr().WiFiPAFShutdown(id, role); });
 #endif
 
@@ -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();
-            WiFiPAF::WiFiPAFSession sessionInfo = { .nodeId = nodeId, .discriminator = discriminator };
+            WiFiPAF::WiFiPAFSession sessionInfo = { .role          = WiFiPAF::WiFiPafRole::kWiFiPafRole_Subscriber,
+                                                    .nodeId        = nodeId,
+                                                    .discriminator = discriminator };
             ReturnErrorOnFailure(
                 DeviceLayer::ConnectivityMgr().GetWiFiPAF()->AddPafSession(WiFiPAF::PafInfoAccess::kAccNodeInfo, sessionInfo));
             DeviceLayer::ConnectivityMgr().WiFiPAFSubscribe(discriminator, reinterpret_cast<void *>(this),
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();
-    WiFiPAF::WiFiPAFSession sessionInfo = { .nodeId = mRemoteId, .discriminator = discriminator };
+    WiFiPAF::WiFiPAFSession sessionInfo = { .role          = WiFiPAF::WiFiPafRole::kWiFiPafRole_Subscriber,
+                                            .nodeId        = mRemoteId,
+                                            .discriminator = discriminator };
     ReturnErrorOnFailure(
         DeviceLayer::ConnectivityMgr().GetWiFiPAF()->AddPafSession(WiFiPAF::PafInfoAccess::kAccNodeInfo, sessionInfo));
     CHIP_ERROR err = DeviceLayer::ConnectivityMgr().WiFiPAFSubscribe(discriminator, (void *) this, OnWiFiPAFSubscribeComplete,
diff --git a/src/include/platform/ConnectivityManager.h b/src/include/platform/ConnectivityManager.h
@@ -528,7 +528,7 @@ inline void ConnectivityManager::ResetThreadNetworkDiagnosticsCounts()
 #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
 inline WiFiPAF::WiFiPAFLayer * ConnectivityManager::GetWiFiPAF()
 {
-    return static_cast<ImplClass *>(this)->_GetWiFiPAF();
+    return &WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer();
 }
 
 inline void ConnectivityManager::WiFiPafSetApFreq(const uint16_t freq)
diff --git a/src/include/platform/internal/GenericPlatformManagerImpl.ipp b/src/include/platform/internal/GenericPlatformManagerImpl.ipp
@@ -154,7 +154,7 @@ void GenericPlatformManagerImpl<ImplClass>::_Shutdown()
 
 #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
     ChipLogProgress(DeviceLayer, "WiFi-PAF Layer shutdown");
-    WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer()->Shutdown(
+    WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer().Shutdown(
         [](uint32_t id, WiFiPAF::WiFiPafRole role) { DeviceLayer::ConnectivityMgr().WiFiPAFShutdown(id, role); });
 #endif
 
diff --git a/src/platform/Linux/ConnectivityManagerImpl.cpp b/src/platform/Linux/ConnectivityManagerImpl.cpp
@@ -105,7 +105,7 @@ ConnectivityManagerImpl ConnectivityManagerImpl::sInstance;
 #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
 static void StopSignalHandler(int signum)
 {
-    WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer()->Shutdown([](uint32_t id, WiFiPAF::WiFiPafRole role) {
+    WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer().Shutdown([](uint32_t id, WiFiPAF::WiFiPafRole role) {
         switch (role)
         {
         case WiFiPAF::WiFiPafRole::kWiFiPafRole_Publisher:
@@ -165,7 +165,7 @@ CHIP_ERROR ConnectivityManagerImpl::_Init()
     }
 #endif
 #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
-    pmWiFiPAF = WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer();
+    pmWiFiPAF = &WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer();
     pmWiFiPAF->Init(&DeviceLayer::SystemLayer());
 
     struct sigaction sa = {};
@@ -185,20 +185,21 @@ void ConnectivityManagerImpl::_OnPlatformEvent(const ChipDeviceEvent * event)
     GenericConnectivityManagerImpl_Thread<ConnectivityManagerImpl>::_OnPlatformEvent(event);
 #endif
 #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
+    WiFiPAFLayer & WiFiPafLayer = WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer();
     switch (event->Type)
     {
     case DeviceEventType::kCHIPoWiFiPAFReceived: {
         ChipLogProgress(DeviceLayer, "WiFi-PAF: event: kCHIPoWiFiPAFReceived");
-        WiFiPAF::WiFiPAFSession RxInfo;
+        WiFiPAFSession RxInfo;
         memcpy(&RxInfo, &event->CHIPoWiFiPAFReceived.SessionInfo, sizeof(WiFiPAF::WiFiPAFSession));
-        _GetWiFiPAF()->OnWiFiPAFMessageReceived(RxInfo, System::PacketBufferHandle::Adopt(event->CHIPoWiFiPAFReceived.Data));
+        WiFiPafLayer.OnWiFiPAFMessageReceived(RxInfo, System::PacketBufferHandle::Adopt(event->CHIPoWiFiPAFReceived.Data));
         break;
     }
     case DeviceEventType::kCHIPoWiFiPAFConnected: {
         ChipLogProgress(DeviceLayer, "WiFi-PAF: event: kCHIPoWiFiPAFConnected");
         WiFiPAF::WiFiPAFSession SessionInfo;
         memcpy(&SessionInfo, &event->CHIPoWiFiPAFReceived.SessionInfo, sizeof(WiFiPAF::WiFiPAFSession));
-        _GetWiFiPAF()->HandleTransportConnectionInitiated(SessionInfo, mOnPafSubscribeComplete, mAppState, mOnPafSubscribeError);
+        WiFiPafLayer.HandleTransportConnectionInitiated(SessionInfo, mOnPafSubscribeComplete, mAppState, mOnPafSubscribeError);
         break;
     }
     case DeviceEventType::kCHIPoWiFiPAFCancelConnect: {
@@ -214,7 +215,7 @@ void ConnectivityManagerImpl::_OnPlatformEvent(const ChipDeviceEvent * event)
         ChipLogProgress(DeviceLayer, "WiFi-PAF: event: kCHIPoWiFiPAFWriteDone");
         WiFiPAF::WiFiPAFSession TxInfo;
         memcpy(&TxInfo, &event->CHIPoWiFiPAFReceived.SessionInfo, sizeof(WiFiPAF::WiFiPAFSession));
-        _GetWiFiPAF()->HandleWriteConfirmed(TxInfo, event->CHIPoWiFiPAFReceived.result);
+        WiFiPafLayer.HandleWriteConfirmed(TxInfo, event->CHIPoWiFiPAFReceived.result);
         break;
     }
     }
@@ -941,8 +942,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);
-    WiFiPAFSession sessionInfo = { .id = publish_id };
-    ReturnErrorOnFailure(_GetWiFiPAF()->AddPafSession(PafInfoAccess::kAccSessionId, sessionInfo));
+    WiFiPAFSession sessionInfo  = { .role = WiFiPafRole::kWiFiPafRole_Publisher, .id = publish_id };
+    WiFiPAFLayer & WiFiPafLayer = WiFiPAFLayer::GetWiFiPAFLayer();
+    ReturnErrorOnFailure(WiFiPafLayer.AddPafSession(PafInfoAccess::kAccSessionId, sessionInfo));
     InArgs.publish_id = publish_id;
 
     g_signal_connect(mWpaSupplicant.iface, "nanreplied",
@@ -974,11 +976,6 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFCancelPublish(uint32_t PublishId)
     wpa_supplicant_1_interface_call_nancancel_publish_sync(mWpaSupplicant.iface, PublishId, nullptr, &err.GetReceiver());
     return CHIP_NO_ERROR;
 }
-
-WiFiPAF::WiFiPAFLayer * ConnectivityManagerImpl::_GetWiFiPAF()
-{
-    return pmWiFiPAF;
-}
 #endif
 
 void ConnectivityManagerImpl::StartNonConcurrentWiFiManagement()
@@ -1465,8 +1462,9 @@ void ConnectivityManagerImpl::OnDiscoveryResult(GVariant * discov_info)
     /*
         Error Checking
     */
-    WiFiPAFSession sessionInfo = { .discriminator = pPublishSSI->DevInfo };
-    auto pPafInfo              = _GetWiFiPAF()->GetPAFInfo(PafInfoAccess::kAccDisc, sessionInfo);
+    WiFiPAFSession sessionInfo  = { .discriminator = pPublishSSI->DevInfo };
+    WiFiPAFLayer & WiFiPafLayer = WiFiPAFLayer::GetWiFiPAFLayer();
+    auto pPafInfo               = WiFiPafLayer.GetPAFInfo(PafInfoAccess::kAccDisc, sessionInfo);
     if (pPafInfo == nullptr)
     {
         ChipLogError(DeviceLayer, "WiFi-PAF: DiscoveryResult, no valid session with discriminator: %u", pPublishSSI->DevInfo);
@@ -1564,8 +1562,9 @@ void ConnectivityManagerImpl::OnReplied(GVariant * reply_info)
                         SetupDiscriminator);
         return;
     }
-    WiFiPAFSession sessionInfo = { .id = publish_id };
-    auto pPafInfo              = _GetWiFiPAF()->GetPAFInfo(PafInfoAccess::kAccSessionId, sessionInfo);
+    WiFiPAFSession sessionInfo  = { .id = publish_id };
+    WiFiPAFLayer & WiFiPafLayer = WiFiPAFLayer::GetWiFiPAFLayer();
+    auto pPafInfo               = WiFiPafLayer.GetPAFInfo(PafInfoAccess::kAccSessionId, sessionInfo);
     if (pPafInfo == nullptr)
     {
         ChipLogError(DeviceLayer, "WiFi-PAF: OnReplied, no valid session with publish_id: %d", publish_id);
@@ -1590,7 +1589,7 @@ void ConnectivityManagerImpl::OnReplied(GVariant * reply_info)
     pPafInfo->id      = publish_id;
     pPafInfo->peer_id = peer_subscribe_id;
     memcpy(pPafInfo->peer_addr, peer_addr, sizeof(uint8_t) * 6);
-    _GetWiFiPAF()->HandleTransportConnectionInitiated(*pPafInfo);
+    WiFiPafLayer.HandleTransportConnectionInitiated(*pPafInfo);
 }
 
 void ConnectivityManagerImpl::OnNanReceive(GVariant * obj)
@@ -1641,15 +1640,17 @@ void ConnectivityManagerImpl::OnNanReceive(GVariant * obj)
 void ConnectivityManagerImpl::OnNanPublishTerminated(guint public_id, gchar * reason)
 {
     ChipLogProgress(Controller, "WiFi-PAF: Publish terminated (%u, %s)", public_id, reason);
-    WiFiPAFSession sessionInfo = { .id = public_id };
-    _GetWiFiPAF()->RmPafSession(PafInfoAccess::kAccSessionId, sessionInfo);
+    WiFiPAFSession sessionInfo  = { .id = public_id };
+    WiFiPAFLayer & WiFiPafLayer = WiFiPAFLayer::GetWiFiPAFLayer();
+    WiFiPafLayer.RmPafSession(PafInfoAccess::kAccSessionId, sessionInfo);
 }
 
 void ConnectivityManagerImpl::OnNanSubscribeTerminated(guint subscribe_id, gchar * reason)
 {
     ChipLogProgress(Controller, "WiFi-PAF: Subscription terminated (%u, %s)", subscribe_id, reason);
-    WiFiPAFSession sessionInfo = { .id = subscribe_id };
-    _GetWiFiPAF()->RmPafSession(PafInfoAccess::kAccSessionId, sessionInfo);
+    WiFiPAFSession sessionInfo  = { .id = subscribe_id };
+    WiFiPAFLayer & WiFiPafLayer = WiFiPAFLayer::GetWiFiPAFLayer();
+    WiFiPafLayer.RmPafSession(PafInfoAccess::kAccSessionId, sessionInfo);
     /*
         Indicate the connection event
     */
@@ -1707,8 +1708,9 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFSubscribe(const uint16_t & connDiscr
     mOnPafSubscribeComplete = onSuccess;
     mOnPafSubscribeError    = onError;
 
-    WiFiPAFSession sessionInfo = { .discriminator = PafPublish_ssi.DevInfo };
-    auto pPafInfo              = _GetWiFiPAF()->GetPAFInfo(PafInfoAccess::kAccDisc, sessionInfo);
+    WiFiPAFSession sessionInfo  = { .discriminator = PafPublish_ssi.DevInfo };
+    WiFiPAFLayer & WiFiPafLayer = WiFiPAFLayer::GetWiFiPAFLayer();
+    auto pPafInfo               = WiFiPafLayer.GetPAFInfo(PafInfoAccess::kAccDisc, sessionInfo);
     if (pPafInfo != nullptr)
     {
         pPafInfo->id   = subscribe_id;
diff --git a/src/platform/Linux/ConnectivityManagerImpl.h b/src/platform/Linux/ConnectivityManagerImpl.h
@@ -152,7 +152,6 @@ class ConnectivityManagerImpl final : public ConnectivityManager,
     void OnNanPublishTerminated(guint public_id, gchar * reason);
     void OnNanSubscribeTerminated(guint subscribe_id, gchar * reason);
     CHIP_ERROR _WiFiPAFSend(const WiFiPAF::WiFiPAFSession & TxInfo, chip::System::PacketBufferHandle && msgBuf);
-    WiFiPAF::WiFiPAFLayer * _GetWiFiPAF();
     void _WiFiPafSetApFreq(const uint16_t freq) { mApFreq = freq; }
     CHIP_ERROR _WiFiPAFShutdown(uint32_t id, WiFiPAF::WiFiPafRole role);
 #endif
diff --git a/src/transport/raw/WiFiPAF.cpp b/src/transport/raw/WiFiPAF.cpp
@@ -138,6 +138,7 @@ CHIP_ERROR WiFiPAFBase::WiFiPAFCloseSession(WiFiPAFSession & SessionInfo)
 {
     VerifyOrReturnError(mWiFiPAFLayer->GetWiFiPAFState() != State::kNotReady, CHIP_ERROR_INCORRECT_STATE);
     DeviceLayer::ConnectivityMgr().WiFiPAFShutdown(SessionInfo.id, SessionInfo.role);
+    mWiFiPAFLayer->SetWiFiPAFState(State::kInitialized);
 
     return CHIP_NO_ERROR;
 }
diff --git a/src/wifipaf/WiFiPAFConfig.h b/src/wifipaf/WiFiPAFConfig.h
@@ -36,7 +36,7 @@
  *    simultaneous PAF connections the application will establish).
  */
 #ifndef WIFIPAF_LAYER_NUM_PAF_ENDPOINTS
-#define WIFIPAF_LAYER_NUM_PAF_ENDPOINTS 1
+#define WIFIPAF_LAYER_NUM_PAF_ENDPOINTS 2
 #endif // WIFIPAF_LAYER_NUM_PAF_ENDPOINTS
 
 #if (WIFIPAF_LAYER_NUM_PAF_ENDPOINTS < 1)
diff --git a/src/wifipaf/WiFiPAFEndPoint.cpp b/src/wifipaf/WiFiPAFEndPoint.cpp
@@ -223,12 +223,10 @@ void WiFiPAFEndPoint::FinalizeClose(uint8_t oldState, uint8_t flags, CHIP_ERROR
 
     // Ensure transmit queue is empty and set to NULL.
     mSendQueue = nullptr;
-
     // Clear the session information
     ChipLogProgress(WiFiPAF, "Shutdown PAF session (%u, %u)", mSessionInfo.id, mSessionInfo.role);
     mWiFiPafLayer->mWiFiPAFTransport->WiFiPAFCloseSession(mSessionInfo);
     memset(&mSessionInfo, 0, sizeof(mSessionInfo));
-
     // Fire application's close callback if we haven't already, and it's not suppressed.
     if (oldState != kState_Closing && (flags & kWiFiPAFCloseFlag_SuppressCallback) == 0)
     {
@@ -254,6 +252,7 @@ void WiFiPAFEndPoint::FinalizeClose(uint8_t oldState, uint8_t flags, CHIP_ERROR
             Free();
         }
     }
+    ClearAll();
 }
 
 void WiFiPAFEndPoint::DoCloseCallback(uint8_t state, uint8_t flags, CHIP_ERROR err)
@@ -1264,5 +1263,11 @@ void WiFiPAFEndPoint::HandleSendAckTimeout(chip::System::Layer * systemLayer, vo
     }
 }
 
+void WiFiPAFEndPoint::ClearAll()
+{
+    memset(reinterpret_cast<uint8_t *>(this), 0, sizeof(WiFiPAFEndPoint));
+    return;
+}
+
 } /* namespace WiFiPAF */
 } /* namespace chip */
diff --git a/src/wifipaf/WiFiPAFEndPoint.h b/src/wifipaf/WiFiPAFEndPoint.h
@@ -183,6 +183,7 @@ class DLL_EXPORT WiFiPAFEndPoint
     void FreePAFtpEngine();
 
     void QueueTx(PacketBufferHandle && data, PacketType_t type);
+    void ClearAll();
 };
 
 } /* namespace WiFiPAF */
diff --git a/src/wifipaf/WiFiPAFLayer.cpp b/src/wifipaf/WiFiPAFLayer.cpp
@@ -26,7 +26,6 @@
 #include "WiFiPAFConfig.h"
 #include "WiFiPAFEndPoint.h"
 #include "WiFiPAFError.h"
-#include <cassert>
 #include <lib/core/CHIPEncoding.h>
 
 #undef CHIP_WIFIPAF_LAYER_DEBUG_LOGGING_ENABLED
@@ -314,9 +313,9 @@ CHIP_ERROR WiFiPAFLayer::HandleWriteConfirmed(WiFiPAF::WiFiPAFSession & TxInfo,
 }
 
 static WiFiPAFLayer sInstance;
-WiFiPAFLayer * WiFiPAFLayer::GetWiFiPAFLayer()
+WiFiPAFLayer & WiFiPAFLayer::GetWiFiPAFLayer()
 {
-    return &sInstance;
+    return sInstance;
 }
 
 CHIP_ERROR WiFiPAFLayer::NewEndPoint(WiFiPAFEndPoint ** retEndPoint, WiFiPAFSession & SessionInfo, WiFiPafRole role)
@@ -356,7 +355,7 @@ CHIP_ERROR WiFiPAFLayer::HandleTransportConnectionInitiated(WiFiPAF::WiFiPAFSess
 
 void WiFiPAFLayer::OnEndPointConnectComplete(WiFiPAFEndPoint * endPoint, CHIP_ERROR err)
 {
-    assert(endPoint != nullptr);
+    VerifyOrDie(endPoint != nullptr);
     if (endPoint->mOnPafSubscribeComplete != nullptr)
     {
         endPoint->mOnPafSubscribeComplete(endPoint->mAppState);
@@ -392,29 +391,29 @@ WiFiPAFLayer::GetHighestSupportedProtocolVersion(const PAFTransportCapabilitiesR
     return retVersion;
 }
 
-#define INVALID_PAF_SESSION_ID 0xff
+inline constexpr uint8_t kInvalidActiveWiFiPafSessionId = UINT8_MAX;
 void WiFiPAFLayer::InitialPafInfo()
 {
     for (uint8_t i = 0; i < WIFIPAF_LAYER_NUM_PAF_ENDPOINTS; i++)
     {
-        cleanPafInfo(mPafInfoVect[i]);
+        CleanPafInfo(mPafInfoVect[i]);
     }
 }
 
-void WiFiPAFLayer::cleanPafInfo(WiFiPAFSession & SessionInfo)
+void WiFiPAFLayer::CleanPafInfo(WiFiPAFSession & SessionInfo)
 {
     memset(&SessionInfo, 0, sizeof(WiFiPAFSession));
-    SessionInfo.id            = UINT32_MAX;
-    SessionInfo.peer_id       = UINT32_MAX;
-    SessionInfo.nodeId        = UINT32_MAX;
+    SessionInfo.id            = kUndefinedWiFiPafSessionId;
+    SessionInfo.peer_id       = kUndefinedWiFiPafSessionId;
+    SessionInfo.nodeId        = kUndefinedNodeId;
     SessionInfo.discriminator = UINT16_MAX;
     return;
 }
 
 CHIP_ERROR WiFiPAFLayer::AddPafSession(PafInfoAccess accType, WiFiPAFSession & SessionInfo)
 {
     uint8_t i;
-    uint8_t eSlotId              = INVALID_PAF_SESSION_ID;
+    uint8_t eSlotId              = kInvalidActiveWiFiPafSessionId;
     WiFiPAFSession * pPafSession = nullptr;
 
     // Check if the session has existed
@@ -426,7 +425,7 @@ CHIP_ERROR WiFiPAFLayer::AddPafSession(PafInfoAccess accType, WiFiPAFSession & S
         case PafInfoAccess::kAccNodeInfo:
             if (pPafSession->nodeId == SessionInfo.nodeId)
             {
-                assert(pPafSession->discriminator == SessionInfo.discriminator);
+                VerifyOrDie(pPafSession->discriminator == SessionInfo.discriminator);
                 // Already exist
                 return CHIP_NO_ERROR;
             }
@@ -441,13 +440,17 @@ CHIP_ERROR WiFiPAFLayer::AddPafSession(PafInfoAccess accType, WiFiPAFSession & S
         default:
             return CHIP_ERROR_NOT_IMPLEMENTED;
         };
-        if ((pPafSession->id == UINT32_MAX) && (pPafSession->nodeId == UINT32_MAX) && (pPafSession->discriminator == UINT16_MAX))
+        if ((pPafSession->id == kUndefinedWiFiPafSessionId) && (pPafSession->nodeId == kUndefinedNodeId) &&
+            (pPafSession->discriminator == UINT16_MAX))
+        {
             eSlotId = i;
+        }
     }
     // Add the session if available
-    if (eSlotId != INVALID_PAF_SESSION_ID)
+    if (eSlotId != kInvalidActiveWiFiPafSessionId)
     {
-        pPafSession = &mPafInfoVect[eSlotId];
+        pPafSession       = &mPafInfoVect[eSlotId];
+        pPafSession->role = SessionInfo.role;
         switch (accType)
         {
         case PafInfoAccess::kAccNodeInfo:
@@ -483,7 +486,7 @@ CHIP_ERROR WiFiPAFLayer::RmPafSession(PafInfoAccess accType, WiFiPAFSession & Se
             {
                 ChipLogProgress(WiFiPAF, "Removing session with id: %u", pPafSession->id);
                 // Clear the slot
-                cleanPafInfo(*pPafSession);
+                CleanPafInfo(*pPafSession);
                 return CHIP_NO_ERROR;
             }
             break;
@@ -503,6 +506,13 @@ WiFiPAFSession * WiFiPAFLayer::GetPAFInfo(PafInfoAccess accType, WiFiPAFSession
     for (i = 0; i < WIFIPAF_LAYER_NUM_PAF_ENDPOINTS; i++)
     {
         pPafSession = &mPafInfoVect[i];
+        if (pPafSession->role == kWiFiPafRole_Publisher)
+        {
+            if (pPafSession->id != kUndefinedWiFiPafSessionId)
+                return pPafSession;
+            else
+                continue;
+        }
         switch (accType)
         {
         case PafInfoAccess::kAccSessionId:
diff --git a/src/wifipaf/WiFiPAFLayer.h b/src/wifipaf/WiFiPAFLayer.h
diff --git a/src/wifipaf/WiFiPAFRole.h b/src/wifipaf/WiFiPAFRole.h
diff --git a/src/wifipaf/WiFiPAFTP.h b/src/wifipaf/WiFiPAFTP.h

Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ void CommissioningWindowManager::OnPlatformEvent(const DeviceLayer::ChipDeviceEv`
`73`	`73`	`mServer->GetBleLayerObject()->CloseAllBleConnections();`
`74`	`74`	`#endif`
`75`	`75`	`#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF`
`76`		`- chip::WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer()->Shutdown(`
	`76`	`+ chip::WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer().Shutdown(`
`77`	`77`	`[](uint32_t id, WiFiPAF::WiFiPafRole role) { DeviceLayer::ConnectivityMgr().WiFiPAFShutdown(id, role); });`
`78`	`78`	`#endif`
`79`	`79`	`}`
Original file line number	Diff line number	Diff line change
`@@ -528,7 +528,7 @@ inline void ConnectivityManager::ResetThreadNetworkDiagnosticsCounts()`
`528`	`528`	`#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF`
`529`	`529`	`inline WiFiPAF::WiFiPAFLayer * ConnectivityManager::GetWiFiPAF()`
`530`	`530`	`{`
`531`		`- return static_cast<ImplClass *>(this)->_GetWiFiPAF();`
	`531`	`+ return &WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer();`
`532`	`532`	`}`
`533`	`533`
`534`	`534`	`inline void ConnectivityManager::WiFiPafSetApFreq(const uint16_t freq)`
Original file line number	Diff line number	Diff line change
`@@ -138,6 +138,7 @@ CHIP_ERROR WiFiPAFBase::WiFiPAFCloseSession(WiFiPAFSession & SessionInfo)`
`138`	`138`	`{`
`139`	`139`	`VerifyOrReturnError(mWiFiPAFLayer->GetWiFiPAFState() != State::kNotReady, CHIP_ERROR_INCORRECT_STATE);`
`140`	`140`	`DeviceLayer::ConnectivityMgr().WiFiPAFShutdown(SessionInfo.id, SessionInfo.role);`
	`141`	`+ mWiFiPAFLayer->SetWiFiPAFState(State::kInitialized);`
`141`	`142`
`142`	`143`	`return CHIP_NO_ERROR;`
`143`	`144`	`}`
Original file line number	Diff line number	Diff line change
`@@ -223,12 +223,10 @@ void WiFiPAFEndPoint::FinalizeClose(uint8_t oldState, uint8_t flags, CHIP_ERROR`
`223`	`223`
`224`	`224`	`// Ensure transmit queue is empty and set to NULL.`
`225`	`225`	`mSendQueue = nullptr;`
`226`		`-`
`227`	`226`	`// Clear the session information`
`228`	`227`	`ChipLogProgress(WiFiPAF, "Shutdown PAF session (%u, %u)", mSessionInfo.id, mSessionInfo.role);`
`229`	`228`	`mWiFiPafLayer->mWiFiPAFTransport->WiFiPAFCloseSession(mSessionInfo);`
`230`	`229`	`memset(&mSessionInfo, 0, sizeof(mSessionInfo));`
`231`		`-`
`232`	`230`	`// Fire application's close callback if we haven't already, and it's not suppressed.`
`233`	`231`	`if (oldState != kState_Closing && (flags & kWiFiPAFCloseFlag_SuppressCallback) == 0)`
`234`	`232`	`{`
`@@ -254,6 +252,7 @@ void WiFiPAFEndPoint::FinalizeClose(uint8_t oldState, uint8_t flags, CHIP_ERROR`
`254`	`252`	`Free();`
`255`	`253`	`}`
`256`	`254`	`}`
	`255`	`+ ClearAll();`
`257`	`256`	`}`
`258`	`257`
`259`	`258`	`void WiFiPAFEndPoint::DoCloseCallback(uint8_t state, uint8_t flags, CHIP_ERROR err)`
`@@ -1264,5 +1263,11 @@ void WiFiPAFEndPoint::HandleSendAckTimeout(chip::System::Layer * systemLayer, vo`
`1264`	`1263`	`}`
`1265`	`1264`	`}`
`1266`	`1265`
	`1266`	`+void WiFiPAFEndPoint::ClearAll()`
	`1267`	`+{`
	`1268`	`+ memset(reinterpret_cast<uint8_t *>(this), 0, sizeof(WiFiPAFEndPoint));`
	`1269`	`+ return;`
	`1270`	`+}`
	`1271`	`+`
`1267`	`1272`	`} /* namespace WiFiPAF */`
`1268`	`1273`	`} /* namespace chip */`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,6 @@`
`26`	`26`	`#include "WiFiPAFConfig.h"`
`27`	`27`	`#include "WiFiPAFEndPoint.h"`
`28`	`28`	`#include "WiFiPAFError.h"`
`29`		`-#include <cassert>`
`30`	`29`	`#include <lib/core/CHIPEncoding.h>`
`31`	`30`
`32`	`31`	`#undef CHIP_WIFIPAF_LAYER_DEBUG_LOGGING_ENABLED`
`@@ -314,9 +313,9 @@ CHIP_ERROR WiFiPAFLayer::HandleWriteConfirmed(WiFiPAF::WiFiPAFSession & TxInfo,`
`314`	`313`	`}`
`315`	`314`
`316`	`315`	`static WiFiPAFLayer sInstance;`
`317`		`-WiFiPAFLayer * WiFiPAFLayer::GetWiFiPAFLayer()`
	`316`	`+WiFiPAFLayer & WiFiPAFLayer::GetWiFiPAFLayer()`
`318`	`317`	`{`
`319`		`- return &sInstance;`
	`318`	`+ return sInstance;`
`320`	`319`	`}`
`321`	`320`
`322`	`321`	`CHIP_ERROR WiFiPAFLayer::NewEndPoint(WiFiPAFEndPoint ** retEndPoint, WiFiPAFSession & SessionInfo, WiFiPafRole role)`
`@@ -356,7 +355,7 @@ CHIP_ERROR WiFiPAFLayer::HandleTransportConnectionInitiated(WiFiPAF::WiFiPAFSess`
`356`	`355`
`357`	`356`	`void WiFiPAFLayer::OnEndPointConnectComplete(WiFiPAFEndPoint * endPoint, CHIP_ERROR err)`
`358`	`357`	`{`
`359`		`- assert(endPoint != nullptr);`
	`358`	`+ VerifyOrDie(endPoint != nullptr);`
`360`	`359`	`if (endPoint->mOnPafSubscribeComplete != nullptr)`
`361`	`360`	`{`
`362`	`361`	`endPoint->mOnPafSubscribeComplete(endPoint->mAppState);`
`@@ -392,29 +391,29 @@ WiFiPAFLayer::GetHighestSupportedProtocolVersion(const PAFTransportCapabilitiesR`
`392`	`391`	`return retVersion;`
`393`	`392`	`}`
`394`	`393`
`395`		`-#define INVALID_PAF_SESSION_ID 0xff`
	`394`	`+inline constexpr uint8_t kInvalidActiveWiFiPafSessionId = UINT8_MAX;`
`396`	`395`	`void WiFiPAFLayer::InitialPafInfo()`
`397`	`396`	`{`
`398`	`397`	`for (uint8_t i = 0; i < WIFIPAF_LAYER_NUM_PAF_ENDPOINTS; i++)`
`399`	`398`	`{`
`400`		`- cleanPafInfo(mPafInfoVect[i]);`
	`399`	`+ CleanPafInfo(mPafInfoVect[i]);`
`401`	`400`	`}`
`402`	`401`	`}`
`403`	`402`
`404`		`-void WiFiPAFLayer::cleanPafInfo(WiFiPAFSession & SessionInfo)`
	`403`	`+void WiFiPAFLayer::CleanPafInfo(WiFiPAFSession & SessionInfo)`
`405`	`404`	`{`
`406`	`405`	`memset(&SessionInfo, 0, sizeof(WiFiPAFSession));`
`407`		`- SessionInfo.id = UINT32_MAX;`
`408`		`- SessionInfo.peer_id = UINT32_MAX;`
`409`		`- SessionInfo.nodeId = UINT32_MAX;`
	`406`	`+ SessionInfo.id = kUndefinedWiFiPafSessionId;`
	`407`	`+ SessionInfo.peer_id = kUndefinedWiFiPafSessionId;`
	`408`	`+ SessionInfo.nodeId = kUndefinedNodeId;`
`410`	`409`	`SessionInfo.discriminator = UINT16_MAX;`
`411`	`410`	`return;`
`412`	`411`	`}`
`413`	`412`
`414`	`413`	`CHIP_ERROR WiFiPAFLayer::AddPafSession(PafInfoAccess accType, WiFiPAFSession & SessionInfo)`
`415`	`414`	`{`
`416`	`415`	`uint8_t i;`
`417`		`- uint8_t eSlotId = INVALID_PAF_SESSION_ID;`
	`416`	`+ uint8_t eSlotId = kInvalidActiveWiFiPafSessionId;`
`418`	`417`	`WiFiPAFSession * pPafSession = nullptr;`
`419`	`418`
`420`	`419`	`// Check if the session has existed`
`@@ -426,7 +425,7 @@ CHIP_ERROR WiFiPAFLayer::AddPafSession(PafInfoAccess accType, WiFiPAFSession & S`
`426`	`425`	`case PafInfoAccess::kAccNodeInfo:`
`427`	`426`	`if (pPafSession->nodeId == SessionInfo.nodeId)`
`428`	`427`	`{`
`429`		`- assert(pPafSession->discriminator == SessionInfo.discriminator);`
	`428`	`+ VerifyOrDie(pPafSession->discriminator == SessionInfo.discriminator);`
`430`	`429`	`// Already exist`
`431`	`430`	`return CHIP_NO_ERROR;`
`432`	`431`	`}`
`@@ -441,13 +440,17 @@ CHIP_ERROR WiFiPAFLayer::AddPafSession(PafInfoAccess accType, WiFiPAFSession & S`
`441`	`440`	`default:`
`442`	`441`	`return CHIP_ERROR_NOT_IMPLEMENTED;`
`443`	`442`	`};`
`444`		`- if ((pPafSession->id == UINT32_MAX) && (pPafSession->nodeId == UINT32_MAX) && (pPafSession->discriminator == UINT16_MAX))`
	`443`	`+ if ((pPafSession->id == kUndefinedWiFiPafSessionId) && (pPafSession->nodeId == kUndefinedNodeId) &&`
	`444`	`+ (pPafSession->discriminator == UINT16_MAX))`
	`445`	`+ {`
`445`	`446`	`eSlotId = i;`
	`447`	`+ }`
`446`	`448`	`}`
`447`	`449`	`// Add the session if available`
`448`		`- if (eSlotId != INVALID_PAF_SESSION_ID)`
	`450`	`+ if (eSlotId != kInvalidActiveWiFiPafSessionId)`
`449`	`451`	`{`
`450`		`- pPafSession = &mPafInfoVect[eSlotId];`
	`452`	`+ pPafSession = &mPafInfoVect[eSlotId];`
	`453`	`+ pPafSession->role = SessionInfo.role;`
`451`	`454`	`switch (accType)`
`452`	`455`	`{`
`453`	`456`	`case PafInfoAccess::kAccNodeInfo:`
`@@ -483,7 +486,7 @@ CHIP_ERROR WiFiPAFLayer::RmPafSession(PafInfoAccess accType, WiFiPAFSession & Se`
`483`	`486`	`{`
`484`	`487`	`ChipLogProgress(WiFiPAF, "Removing session with id: %u", pPafSession->id);`
`485`	`488`	`// Clear the slot`
`486`		`- cleanPafInfo(*pPafSession);`
	`489`	`+ CleanPafInfo(*pPafSession);`
`487`	`490`	`return CHIP_NO_ERROR;`
`488`	`491`	`}`
`489`	`492`	`break;`
`@@ -503,6 +506,13 @@ WiFiPAFSession * WiFiPAFLayer::GetPAFInfo(PafInfoAccess accType, WiFiPAFSession`
`503`	`506`	`for (i = 0; i < WIFIPAF_LAYER_NUM_PAF_ENDPOINTS; i++)`
`504`	`507`	`{`
`505`	`508`	`pPafSession = &mPafInfoVect[i];`
	`509`	`+ if (pPafSession->role == kWiFiPafRole_Publisher)`
	`510`	`+ {`
	`511`	`+ if (pPafSession->id != kUndefinedWiFiPafSessionId)`
	`512`	`+ return pPafSession;`
	`513`	`+ else`
	`514`	`+ continue;`
	`515`	`+ }`
`506`	`516`	`switch (accType)`
`507`	`517`	`{`
`508`	`518`	`case PafInfoAccess::kAccSessionId:`