WIP

Author: mkardous-silabs

src/app/BUILD.gn

@@ -144,6 +144,10 @@ source_set("constants") {
   ]
 }
 
+source_set("test-event-trigger") {
+  sources = [ "TestEventTriggerDelegate.h" ]
+}
+
 # interaction-model is a static-library because it currently requires global functions (app/util/...) that are stubbed in different test files that depend on the app static_library
 # which in tern depens on the interaction-model.
 # Using source_set prevents the unit test to build correctly.

src/app/icd/server/BUILD.gn

@@ -76,6 +76,7 @@ source_set("manager") {
     ":notifier",
     ":observer",
     "${chip_root}/src/app:subscription-manager",
+    "${chip_root}/src/app:test-event-trigger",
     "${chip_root}/src/credentials:credentials",
     "${chip_root}/src/messaging",
   ]

src/app/icd/server/ICDManager.cpp

@@ -42,7 +42,8 @@ static_assert(UINT8_MAX >= CHIP_CONFIG_MAX_EXCHANGE_CONTEXTS,
               "ICDManager::mOpenExchangeContextCount cannot hold count for the max exchange count");
 
 void ICDManager::Init(PersistentStorageDelegate * storage, FabricTable * fabricTable, Crypto::SymmetricKeystore * symmetricKeystore,
-                      Messaging::ExchangeManager * exchangeManager, SubscriptionsInfoProvider * subInfoProvider)
+                      Messaging::ExchangeManager * exchangeManager, SubscriptionsInfoProvider * subInfoProvider,
+                      TestEventTriggerDelegate * testEventTriggerDelegate)
 {
 #if CHIP_CONFIG_ENABLE_ICD_CIP
     VerifyOrDie(storage != nullptr);
@@ -52,6 +53,9 @@ void ICDManager::Init(PersistentStorageDelegate * storage, FabricTable * fabricT
     VerifyOrDie(subInfoProvider != nullptr);
 #endif // CHIP_CONFIG_ENABLE_ICD_CIP
 
+    VerifyOrDie(testEventTriggerDelegate);
+    testEventTriggerDelegate->AddHandler(this);
+
 #if CHIP_CONFIG_ENABLE_ICD_LIT
     // LIT ICD Verification Checks
     if (SupportsFeature(Feature::kLongIdleTimeSupport))
@@ -87,8 +91,11 @@ void ICDManager::Init(PersistentStorageDelegate * storage, FabricTable * fabricT
     UpdateOperationState(OperationalState::IdleMode);
 }
 
-void ICDManager::Shutdown()
+void ICDManager::Shutdown(TestEventTriggerDelegate * testEventTriggerDelegate)
 {
+    VerifyOrDie(testEventTriggerDelegate);
+    testEventTriggerDelegate->RemoveHandler(this);
+
     ICDNotifier::GetInstance().Unsubscribe(this);
 
     // cancel any running timer of the icd
@@ -554,6 +561,25 @@ void ICDManager::ExtendActiveMode(Milliseconds16 extendDuration)
     }
 }
 
+CHIP_ERROR ICDManager::HandleEventTrigger(uint64_t eventTrigger)
+{
+    ICDTestEventTriggerEvent trigger = static_cast<ICDTestEventTriggerEvent>(eventTrigger);
+    CHIP_ERROR err                   = CHIP_NO_ERROR;
+
+    switch (trigger)
+    {
+    case ICDTestEventTriggerEvent::kDoubleICDCounterValue:
+        break;
+    case ICDTestEventTriggerEvent::kInvalidateICDCounter:
+        break;
+    default:
+        err = CHIP_ERROR_INVALID_ARGUMENT;
+        break;
+    }
+
+    return err;
+}
+
 ICDManager::ObserverPointer * ICDManager::RegisterObserver(ICDStateObserver * observer)
 {
     return mStateObserverPool.CreateObject(observer);

src/app/icd/server/ICDManager.h

@@ -16,16 +16,11 @@
  */
 #pragma once
 
-#include <app-common/zap-generated/cluster-enums.h>
-
 #include <app/icd/server/ICDServerConfig.h>
 
-#if CHIP_CONFIG_ENABLE_ICD_CIP
-#include <app/icd/server/ICDCheckInSender.h>   // nogncheck
-#include <app/icd/server/ICDMonitoringTable.h> // nogncheck
-#endif                                         // CHIP_CONFIG_ENABLE_ICD_CIP
-
+#include <app-common/zap-generated/cluster-enums.h>
 #include <app/SubscriptionsInfoProvider.h>
+#include <app/TestEventTriggerDelegate.h>
 #include <app/icd/server/ICDConfigurationData.h>
 #include <app/icd/server/ICDNotifier.h>
 #include <app/icd/server/ICDStateObserver.h>
@@ -37,6 +32,11 @@
 #include <platform/internal/CHIPDeviceLayerInternal.h>
 #include <system/SystemClock.h>
 
+#if CHIP_CONFIG_ENABLE_ICD_CIP
+#include <app/icd/server/ICDCheckInSender.h>   // nogncheck
+#include <app/icd/server/ICDMonitoringTable.h> // nogncheck
+#endif                                         // CHIP_CONFIG_ENABLE_ICD_CIP
+
 namespace chip {
 namespace Crypto {
 using SymmetricKeystore = SessionKeystore;
@@ -53,7 +53,7 @@ class TestICDManager;
 /**
  * @brief ICD Manager is responsible of processing the events and triggering the correct action for an ICD
  */
-class ICDManager : public ICDListener
+class ICDManager : public ICDListener, public TestEventTriggerHandler
 {
 public:
     // This structure is used for the creation an ObjectPool of ICDStateObserver pointers
@@ -81,8 +81,9 @@ class ICDManager : public ICDListener
 
     ICDManager() {}
     void Init(PersistentStorageDelegate * storage, FabricTable * fabricTable, Crypto::SymmetricKeystore * symmetricKeyStore,
-              Messaging::ExchangeManager * exchangeManager, SubscriptionsInfoProvider * manager);
-    void Shutdown();
+              Messaging::ExchangeManager * exchangeManager, SubscriptionsInfoProvider * manager,
+              TestEventTriggerDelegate * testEventTriggerDelegate);
+    void Shutdown(TestEventTriggerDelegate * testEventTriggerDelegate);
     void UpdateICDMode();
     void UpdateOperationState(OperationalState state);
     void SetKeepActiveModeRequirements(KeepActiveFlags flag, bool state);
@@ -117,6 +118,15 @@ class ICDManager : public ICDListener
      */
     uint32_t StayActiveRequest(uint32_t stayActiveDuration);
 
+    /**
+     * @brief TestEventTriggerHandler for the ICD feature set
+     *
+     * @param eventTrigger Event trigger to handle.
+     * @return CHIP_ERROR CHIP_NO_ERROR - No erros during the processing
+     *                    CHIP_ERROR_INVALID_ARGUMENT - eventTrigger isn't a valid value
+     */
+    CHIP_ERROR HandleEventTrigger(uint64_t eventTrigger) override;
+
 #if CHIP_CONFIG_ENABLE_ICD_CIP
     void SendCheckInMsgs();
 
@@ -139,14 +149,14 @@ class ICDManager : public ICDListener
     void OnSubscriptionReport() override;
 
 protected:
+    friend class TestICDManager;
+
     /**
      * @brief Hepler function that extends the Active Mode duration as well as the Active Mode Jitter timer for the transition to
      * iddle mode.
      */
     void ExtendActiveMode(System::Clock::Milliseconds16 extendDuration);
 
-    friend class TestICDManager;
-
     static void OnIdleModeDone(System::Layer * aLayer, void * appState);
     static void OnActiveModeDone(System::Layer * aLayer, void * appState);
 
@@ -165,13 +175,23 @@ class ICDManager : public ICDListener
     uint8_t mOpenExchangeContextCount = 0;
 
 private:
+    enum class ICDTestEventTriggerEvent : uint64_t
+    {
+        kForceToActiveMode     = 0x0046'0000'00000001,
+        kForceToIdleMode       = 0x0046'0000'00000002,
+        kAddActiveModeReq      = 0x0046'0000'00000003,
+        kRemoveActiveModeReq   = 0x0046'0000'00000004,
+        kDoubleICDCounterValue = 0x0046'0000'00000005,
+        kInvalidateICDCounter  = 0x0046'0000'00000006,
+    };
+
 #if CHIP_CONFIG_ENABLE_ICD_CIP
     /**
      * @brief Function checks if at least one client registration would require a Check-In message
      *
      * @return true At least one registration would require an Check-In message if we were entering ActiveMode.
-     * @return false None of the registration would require a Check-In message either because there are no registration or because
-     *               they all have associated subscriptions.
+     * @return false None of the registration would require a Check-In message either because there are no registration or
+     * because they all have associated subscriptions.
      */
     bool CheckInMessagesWouldBeSent();
 #endif // CHIP_CONFIG_ENABLE_ICD_CIP

src/app/server/Server.cpp

@@ -342,7 +342,7 @@ CHIP_ERROR Server::Init(const ServerInitParams & initParams)
     mICDManager.RegisterObserver(&app::DnssdServer::Instance());
 
     mICDManager.Init(mDeviceStorage, &GetFabricTable(), mSessionKeystore, &mExchangeMgr,
-                     chip::app::InteractionModelEngine::GetInstance());
+                     chip::app::InteractionModelEngine::GetInstance(), mTestEventTriggerDelegate);
 #endif // CHIP_CONFIG_ENABLE_ICD_SERVER
 
     // This code is necessary to restart listening to existing groups after a reboot
@@ -569,7 +569,7 @@ void Server::Shutdown()
     Access::ResetAccessControlToDefault();
     Credentials::SetGroupDataProvider(nullptr);
 #if CHIP_CONFIG_ENABLE_ICD_SERVER
-    mICDManager.Shutdown();
+    mICDManager.Shutdown(mTestEventTriggerDelegate);
 #endif // CHIP_CONFIG_ENABLE_ICD_SERVER
     mAttributePersister.Shutdown();
     // TODO(16969): Remove chip::Platform::MemoryInit() call from Server class, it belongs to outer code

src/protocols/secure_channel/BUILD.gn

@@ -1,7 +1,10 @@
 import("//build_overrides/chip.gni")
 
 source_set("check-in-counter") {
-  sources = [ "CheckInCounter.h" ]
+  sources = [
+    "CheckInCounter.cpp",
+    "CheckInCounter.h",
+  ]
 
   deps = [
     "${chip_root}/src/crypto",

src/protocols/secure_channel/CheckInCounter.cpp

@@ -0,0 +1,41 @@
+/*
+ *    Copyright (c) 2024 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ * @brief The file implements the Matter Check-In counter
+ *
+ */
+
+#include <protocols/secure_channel/CheckInCounter.h>
+
+namespace chip {
+namespace Protocols {
+namespace SecureChannel {
+
+CHIP_ERROR CheckInCounter::DoubleCheckInCounterValues()
+{
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR CheckInCounter::InvalidateAllCheckInCounterValues()
+{
+    return CHIP_NO_ERROR;
+}
+
+} // namespace SecureChannel
+} // namespace Protocols
+} // namespace chip

src/protocols/secure_channel/CheckInCounter.h

@@ -22,6 +22,7 @@
 #pragma once
 
 #include <crypto/RandUtils.h>
+#include <lib/core/CHIPError.h>
 #include <lib/support/PersistedCounter.h>
 
 namespace chip {
@@ -45,6 +46,21 @@ class CheckInCounter : public PersistedCounter<uint32_t>
      */
     inline uint32_t GetNextCheckInCounterValue() { return (mCounterValue + 1); };
 
+    /**
+     * @brief Doubles the current Check-In counter value to invalidate at least half of the valid values
+     *
+     * @return CHIP_ERROR
+     */
+    CHIP_ERROR DoubleCheckInCounterValues();
+
+    /**
+     * @brief Invalidates all the Check-In counter values. After function call, new Check-In couter value will be equal to current -
+     * 1 (with rollovers)
+     *
+     * @return CHIP_ERROR
+     */
+    CHIP_ERROR InvalidateAllCheckInCounterValues();
+
 private:
     /**
      * @brief Get the Initial Counter Value for the Check-In counter