[Group] Fabric removal sync

src/app/server/Server.cpp

@@ -184,6 +184,10 @@ CHIP_ERROR Server::Init(AppDelegate * delegate, uint16_t secureServicePort, uint
     err = mSessions.Init(&DeviceLayer::SystemLayer(), &mTransports, &mMessageCounterManager, &mDeviceStorage, &GetFabricTable());
     SuccessOrExit(err);
 
+    err = mFabricDelegate.Init(&mSessions);
+    SuccessOrExit(err);
+    mFabrics.AddFabricDelegate(&mFabricDelegate);
+
     err = mExchangeMgr.Init(&mSessions);
     SuccessOrExit(err);
     err = mMessageCounterManager.Init(&mExchangeMgr);

src/app/server/Server.h

@@ -170,6 +170,40 @@ class Server
         ServerTransportMgr * mTransports;
     };
 
+    class ServerFabricDelegate final : public FabricTableDelegate
+    {
+    public:
+        ServerFabricDelegate() {}
+
+        CHIP_ERROR Init(SessionManager * sessionManager)
+        {
+            VerifyOrReturnError(sessionManager != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+
+            mSessionManager = sessionManager;
+            return CHIP_NO_ERROR;
+        };
+
+        void OnFabricDeletedFromStorage(CompressedFabricId compressedId, FabricIndex fabricIndex) override
+        {
+            (void) compressedId;
+            if (mSessionManager != nullptr)
+            {
+                mSessionManager->FabricRemoved(fabricIndex);
+            }
+            Credentials::GroupDataProvider * groupDataProvider = Credentials::GetGroupDataProvider();
+            if (groupDataProvider != nullptr)
+            {
+                groupDataProvider->RemoveFabric(fabricIndex);
+            }
+        };
+        void OnFabricRetrievedFromStorage(FabricInfo * fabricInfo) override { (void) fabricInfo; }
+
+        void OnFabricPersistedToStorage(FabricInfo * fabricInfo) override { (void) fabricInfo; }
+
+    private:
+        SessionManager * mSessionManager = nullptr;
+    };
+
 #if CONFIG_NETWORK_LAYER_BLE
     Ble::BleLayer * mBleLayer = nullptr;
 #endif
@@ -198,6 +232,7 @@ class Server
     Credentials::GroupDataProviderImpl mGroupsProvider;
     app::DefaultAttributePersistenceProvider mAttributePersister;
     GroupDataProviderListener mListener;
+    ServerFabricDelegate mFabricDelegate;
 
     Access::AccessControl mAccessControl;
 

src/controller/CHIPDeviceControllerFactory.cpp

@@ -146,6 +146,10 @@ CHIP_ERROR DeviceControllerFactory::InitSystemState(FactoryInitParams params)
 
     ReturnErrorOnFailure(stateParams.fabricTable->Init(params.fabricIndependentStorage));
 
+    auto delegate = chip::Platform::MakeUnique<ControllerFabricDelegate>(stateParams.sessionMgr);
+    ReturnErrorOnFailure(stateParams.fabricTable->AddFabricDelegate(delegate.get()));
+    delegate.release();
+
     ReturnErrorOnFailure(stateParams.sessionMgr->Init(stateParams.systemLayer, stateParams.transportMgr,
                                                       stateParams.messageCounterManager, params.fabricIndependentStorage,
                                                       stateParams.fabricTable));

src/controller/CHIPDeviceControllerFactory.h

@@ -31,6 +31,7 @@
 
 #include <controller/CHIPDeviceController.h>
 #include <controller/CHIPDeviceControllerSystemState.h>
+#include <credentials/GroupDataProviderImpl.h>
 #include <credentials/attestation_verifier/DeviceAttestationVerifier.h>
 
 namespace chip {
@@ -137,6 +138,41 @@ class DeviceControllerFactory
     //
     void ReleaseSystemState() { mSystemState->Release(); }
 
+    class ControllerFabricDelegate final : public FabricTableDelegate
+    {
+    public:
+        ControllerFabricDelegate() {}
+        ControllerFabricDelegate(SessionManager * sessionManager) : FabricTableDelegate(true), mSessionManager(sessionManager) {}
+
+        CHIP_ERROR Init(SessionManager * sessionManager)
+        {
+            VerifyOrReturnError(sessionManager != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+
+            mSessionManager = sessionManager;
+            return CHIP_NO_ERROR;
+        };
+
+        void OnFabricDeletedFromStorage(CompressedFabricId compressedId, FabricIndex fabricIndex) override
+        {
+            if (mSessionManager != nullptr)
+            {
+                mSessionManager->FabricRemoved(fabricIndex);
+            }
+            Credentials::GroupDataProvider * groupDataProvider = Credentials::GetGroupDataProvider();
+            if (groupDataProvider != nullptr)
+            {
+                groupDataProvider->RemoveFabric(fabricIndex);
+            }
+        };
+
+        void OnFabricRetrievedFromStorage(FabricInfo * fabricInfo) override { (void) fabricInfo; }
+
+        void OnFabricPersistedToStorage(FabricInfo * fabricInfo) override { (void) fabricInfo; }
+
+    private:
+        SessionManager * mSessionManager = nullptr;
+    };
+
 private:
     DeviceControllerFactory(){};
     void PopulateInitParams(ControllerInitParams & controllerParams, const SetupParams & params);

src/credentials/FabricTable.cpp

@@ -401,6 +401,20 @@ CHIP_ERROR FabricInfo::MatchDestinationID(const ByteSpan & targetDestinationId,
     return CHIP_ERROR_CERT_NOT_TRUSTED;
 }
 
+FabricTable::~FabricTable()
+{
+    FabricTableDelegate * delegate = mDelegate;
+    while (delegate)
+    {
+        FabricTableDelegate * temp = delegate->mNext;
+        if (delegate->mOwnedByFabricTable)
+        {
+            chip::Platform::Delete(delegate);
+        }
+        delegate = temp;
+    }
+}
+
 void FabricTable::ReleaseFabricIndex(FabricIndex fabricIndex)
 {
     FabricInfo * fabric = FindFabricWithIndex(fabricIndex);
@@ -629,6 +643,7 @@ CHIP_ERROR FabricTable::Delete(FabricIndex index)
             mFabricCount--;
         }
         ChipLogProgress(Discovery, "Fabric (%d) deleted. Calling OnFabricDeletedFromStorage", index);
+
         FabricTableDelegate * delegate = mDelegate;
         while (delegate)
         {
@@ -651,6 +666,7 @@ void FabricTable::DeleteAllFabrics()
 CHIP_ERROR FabricTable::Init(PersistentStorageDelegate * storage)
 {
     VerifyOrReturnError(storage != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+
     mStorage = storage;
     ChipLogDetail(Discovery, "Init fabric pairing table with server storage");
 

src/credentials/FabricTable.h

@@ -274,6 +274,7 @@ class DLL_EXPORT FabricTableDelegate
     friend class FabricTable;
 
 public:
+    FabricTableDelegate(bool ownedByFabricTable = false) : mOwnedByFabricTable(ownedByFabricTable) {}
     virtual ~FabricTableDelegate() {}
     /**
      * Gets called when a fabric is deleted from KVS store.
@@ -292,6 +293,7 @@ class DLL_EXPORT FabricTableDelegate
 
 private:
     FabricTableDelegate * mNext = nullptr;
+    bool mOwnedByFabricTable    = false;
 };
 
 /**
@@ -365,6 +367,8 @@ class DLL_EXPORT FabricTable
 {
 public:
     FabricTable() { Reset(); }
+    ~FabricTable();
+
     CHIP_ERROR Store(FabricIndex index);
     CHIP_ERROR LoadFromStorage(FabricInfo * info);
 

src/credentials/GroupDataProvider.h

@@ -166,7 +166,7 @@ class GroupDataProvider
         /**
          *  Callback invoked when an existing group is removed.
          *
-         *  @param[in] removed_state  GroupInfo structure of the removed group.
+         *  @param[in] old_group  GroupInfo structure of the removed group.
          */
         virtual void OnGroupRemoved(FabricIndex fabric_index, const GroupInfo & old_group) = 0;
     };

src/transport/GroupPeerMessageCounter.cpp

@@ -151,27 +151,36 @@ CHIP_ERROR GroupPeerTable::RemovePeer(FabricIndex fabricIndex, NodeId nodeId, bo
     {
         if (mGroupFabrics[fabricIt].mDataPeerCount == 0 && mGroupFabrics[fabricIt].mControlPeerCount == 0)
         {
-            mGroupFabrics[fabricIt].mFabricIndex = kUndefinedFabricIndex;
-            // To maintain logic integrity Fabric array cannot have empty slot in between data
-            // Find the last non empty element
-            for (uint32_t i = CHIP_CONFIG_MAX_FABRICS - 1; i > fabricIt; i--)
-            {
-                if (mGroupFabrics[i].mFabricIndex != kUndefinedFabricIndex)
-                {
-                    // Logic works since all buffer are static
-                    // move it up front
-                    new (&mGroupFabrics[fabricIt]) GroupFabric(mGroupFabrics[i]);
-                    new (&mGroupFabrics[i]) GroupFabric();
-                    break;
-                }
-            }
+            RemoveAndCompactFabric(fabricIt);
         }
     }
 
     // Cannot find Peer to remove
     return err;
 }
 
+CHIP_ERROR GroupPeerTable::FabricRemoved(FabricIndex fabricIndex)
+{
+    CHIP_ERROR err = CHIP_ERROR_NOT_FOUND;
+
+    if (fabricIndex == kUndefinedFabricIndex)
+    {
+        return CHIP_ERROR_INVALID_ARGUMENT;
+    }
+
+    for (uint32_t it = 0; it < CHIP_CONFIG_MAX_FABRICS; it++)
+    {
+        if (fabricIndex == mGroupFabrics[it].mFabricIndex)
+        {
+            RemoveAndCompactFabric(it);
+            return CHIP_NO_ERROR;
+        }
+    }
+
+    // Cannot find Fabric to remove
+    return err;
+}
+
 bool GroupPeerTable::RemoveSpecificPeer(GroupSender * list, NodeId nodeId, uint32_t size)
 {
     bool removed = false;
@@ -222,6 +231,28 @@ void GroupPeerTable::CompactPeers(GroupSender * list, uint32_t size)
     }
 }
 
+void GroupPeerTable::RemoveAndCompactFabric(uint32_t tableIndex)
+{
+    if (tableIndex >= CHIP_CONFIG_MAX_FABRICS)
+    {
+        return;
+    }
+    mGroupFabrics[tableIndex].mFabricIndex = kUndefinedFabricIndex;
+    // To maintain logic integrity Fabric array cannot have empty slot in between data
+    // Find the last non empty element
+    for (uint32_t i = CHIP_CONFIG_MAX_FABRICS - 1; i > tableIndex; i--)
+    {
+        if (mGroupFabrics[i].mFabricIndex != kUndefinedFabricIndex)
+        {
+            // Logic works since all buffer are static
+            // move it up front
+            new (&mGroupFabrics[tableIndex]) GroupFabric(mGroupFabrics[i]);
+            new (&mGroupFabrics[i]) GroupFabric();
+            break;
+        }
+    }
+}
+
 GroupOutgoingCounters::GroupOutgoingCounters(chip::PersistentStorageDelegate * storage_delegate)
 {
     Init(storage_delegate);

src/transport/GroupPeerMessageCounter.h

@@ -62,10 +62,13 @@ class GroupPeerTable
     // Used in case of MCSP failure
     CHIP_ERROR RemovePeer(FabricIndex fabricIndex, NodeId nodeId, bool isControl);
 
+    CHIP_ERROR FabricRemoved(FabricIndex fabricIndex);
+
     // Protected for Unit Tests inheritance
 protected:
     bool RemoveSpecificPeer(GroupSender * list, NodeId nodeId, uint32_t size);
     void CompactPeers(GroupSender * list, uint32_t size);
+    void RemoveAndCompactFabric(uint32_t tableIndex);
 
     GroupFabric mGroupFabrics[CHIP_CONFIG_MAX_FABRICS];
 };

src/transport/SessionManager.cpp

@@ -117,6 +117,17 @@ void SessionManager::Shutdown()
     mCB           = nullptr;
 }
 
+/**
+ * @brief Notification that a fabric was removed.
+ *        This function doesn't call ExpireAllPairingsForFabric
+ *        since the CASE session might still be open to send a response
+ *        on the removed fabric.
+ */
+void SessionManager::FabricRemoved(FabricIndex fabricIndex)
+{
+    mGroupPeerMsgCounter.FabricRemoved(fabricIndex);
+}
+
 CHIP_ERROR SessionManager::PrepareMessage(const SessionHandle & sessionHandle, PayloadHeader & payloadHeader,
                                           System::PacketBufferHandle && message, EncryptedPacketBufferHandle & preparedMessage)
 {

src/transport/SessionManager.h

@@ -197,6 +197,11 @@ class DLL_EXPORT SessionManager : public TransportMgrDelegate
      */
     void Shutdown();
 
+    /**
+     * @brief Notification that a fabric was removed.
+     */
+    void FabricRemoved(FabricIndex fabricIndex);
+
     TransportMgrBase * GetTransportManager() const { return mTransportMgr; }
 
     /**

src/transport/tests/TestGroupMessageCounter.cpp

@@ -134,7 +134,7 @@ void RemovePeerTest(nlTestSuite * inSuite, void * inContext)
     FabricIndex fabricIndex                       = 1;
     CHIP_ERROR err                                = CHIP_NO_ERROR;
     chip::Transport::PeerMessageCounter * counter = nullptr;
-    chip::Transport::GroupPeerTable mGroupPeerMsgCounter;
+    TestGroupPeerTable mGroupPeerMsgCounter;
 
     // Fill table up (max fabric and mac peer)
     for (uint32_t it = 0; it < CHIP_CONFIG_MAX_FABRICS; it++)
@@ -165,6 +165,28 @@ void RemovePeerTest(nlTestSuite * inSuite, void * inContext)
     // Try re-adding the previous peer without any error
     err = mGroupPeerMsgCounter.FindOrAddPeer(99, 99, true, counter);
     NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+
+    err = mGroupPeerMsgCounter.FindOrAddPeer(104, 99, true, counter);
+    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+
+    err = mGroupPeerMsgCounter.FindOrAddPeer(105, 99, true, counter);
+    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+
+    err = mGroupPeerMsgCounter.FindOrAddPeer(106, 99, true, counter);
+    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+
+    // Fabric removal test
+    err = mGroupPeerMsgCounter.FabricRemoved(123);
+    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
+
+    err = mGroupPeerMsgCounter.FabricRemoved(99);
+    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+
+    err = mGroupPeerMsgCounter.FabricRemoved(99);
+    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
+
+    // Verify that the Fabric List was compacted.
+    NL_TEST_ASSERT(inSuite, 106 == mGroupPeerMsgCounter.GetFabricIndexAt(0));
 }
 
 void PeerRetrievalTest(nlTestSuite * inSuite, void * inContext)