Icd handler

examples/chip-tool/BUILD.gn

@@ -102,6 +102,7 @@ static_library("chip-tool-utils") {
 
   public_deps = [
     "${chip_root}/examples/common/tracing:commandline",
+    "${chip_root}/src/app/icd/client:handler",
     "${chip_root}/src/app/icd/client:manager",
     "${chip_root}/src/app/server",
     "${chip_root}/src/app/tests/suites/commands/interaction_model",

examples/chip-tool/commands/common/CHIPCommand.cpp

@@ -50,6 +50,8 @@ chip::Credentials::GroupDataProviderImpl CHIPCommand::sGroupDataProvider{ kMaxGr
 // All fabrics share the same ICD client storage.
 chip::app::DefaultICDClientStorage CHIPCommand::sICDClientStorage;
 chip::Crypto::RawKeySessionKeystore CHIPCommand::sSessionKeystore;
+chip::app::DefaultCheckInDelegate CHIPCommand::sCheckInDelegate;
+chip::app::CheckInHandler CHIPCommand::sCheckInHandler;
 
 namespace {
 
@@ -139,6 +141,10 @@ CHIP_ERROR CHIPCommand::MaybeSetUpStack()
 
     ReturnErrorOnFailure(GetAttestationTrustStore(mPaaTrustStorePath.ValueOr(nullptr), &sTrustStore));
 
+    ReturnLogErrorOnFailure(sCheckInDelegate.Init(&sICDClientStorage));
+    ReturnLogErrorOnFailure(sCheckInHandler.Init(DeviceControllerFactory::GetInstance().GetSystemState()->ExchangeMgr(),
+                                                 &sICDClientStorage, &sCheckInDelegate));
+
     CommissionerIdentity nullIdentity{ kIdentityNull, chip::kUndefinedNodeId };
     ReturnLogErrorOnFailure(InitializeCommissioner(nullIdentity, kIdentityNullFabricId));
 

examples/chip-tool/commands/common/CHIPCommand.h

@@ -25,6 +25,8 @@
 #include "Command.h"
 
 #include <TracingCommandLineArgument.h>
+#include <app/icd/client/CheckInHandler.h>
+#include <app/icd/client/DefaultCheckInDelegate.h>
 #include <app/icd/client/DefaultICDClientStorage.h>
 #include <commands/common/CredentialIssuerCommands.h>
 #include <commands/example/ExampleCredentialIssuerCommands.h>
@@ -160,6 +162,8 @@ class CHIPCommand : public Command
 
     static chip::Credentials::GroupDataProviderImpl sGroupDataProvider;
     static chip::app::DefaultICDClientStorage sICDClientStorage;
+    static chip::app::DefaultCheckInDelegate sCheckInDelegate;
+    static chip::app::CheckInHandler sCheckInHandler;
     CredentialIssuerCommands * mCredIssuerCmds;
 
     std::string GetIdentity();

examples/tv-casting-app/tv-casting-common/BUILD.gn

@@ -118,6 +118,7 @@ chip_data_model("tv-casting-common") {
 
   deps = [
     "${chip_root}/examples/common/tracing:commandline",
+    "${chip_root}/src/app/icd/client:handler",
     "${chip_root}/src/app/icd/client:manager",
     "${chip_root}/src/app/tests/suites/commands/interaction_model",
     "${chip_root}/src/lib/support/jsontlv",

src/app/icd/client/BUILD.gn

@@ -28,5 +28,25 @@ source_set("manager") {
     "${chip_root}/src/app:app_config",
     "${chip_root}/src/crypto",
     "${chip_root}/src/lib/support",
+    "${chip_root}/src/protocols",
+  ]
+}
+
+# ICD Handler source-set is broken out of the main source-set to enable unit tests
+# All sources and configurations used by the CheckInHandler need to go in this source-set
+source_set("handler") {
+  sources = [
+    "CheckInDelegate.h",
+    "CheckInHandler.cpp",
+    "CheckInHandler.h",
+    "DefaultCheckInDelegate.cpp",
+    "DefaultCheckInDelegate.h",
+  ]
+  public_deps = [
+    ":manager",
+    "${chip_root}/src/app",
+    "${chip_root}/src/lib/core",
+    "${chip_root}/src/messaging",
+    "${chip_root}/src/protocols",
   ]
 }

src/app/icd/client/CheckInDelegate.h

@@ -0,0 +1,45 @@
+/*
+ *
+ *    Copyright (c) 2023 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.
+ */
+
+#pragma once
+
+#include <app/icd/client/ICDClientInfo.h>
+
+namespace chip {
+namespace app {
+
+/// Callbacks for check in protocol
+/**
+ * @brief The application implementing an ICD client should inherit the CheckInDelegate and implement the listed callbacks
+ */
+class DLL_EXPORT CheckInDelegate
+{
+public:
+    virtual ~CheckInDelegate() {}
+
+    /**
+     * @brief Callback used to let the application know that a check-in message was received and validated.
+     *
+     * @param[in] clientInfo - ICDClientInfo object representing the state associated with the
+                               node that sent the check-in message.
+     */
+    virtual void OnCheckInComplete(const ICDClientInfo & clientInfo) = 0;
+};
+
+} // namespace app
+} // namespace chip

src/app/icd/client/CheckInHandler.cpp

@@ -0,0 +1,126 @@
+/*
+ *
+ *    Copyright (c) 2023 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.
+ */
+
+/**
+ *    @file
+ *      This file defines objects for a CHIP ICD handler which handles unsolicited check-in messages.
+ *
+ */
+
+#include <app/InteractionModelTimeout.h>
+#include <app/icd/client/CheckInDelegate.h>
+#include <app/icd/client/CheckInHandler.h>
+
+#include <cinttypes>
+
+#include <lib/core/Global.h>
+#include <lib/support/CodeUtils.h>
+#include <messaging/Flags.h>
+#include <protocols/Protocols.h>
+
+#include <protocols/secure_channel/Constants.h>
+
+namespace chip {
+namespace app {
+
+inline constexpr uint64_t kCheckInCounterMax = (1ULL << 32);
+inline constexpr uint32_t kKeyRefreshLimit   = (1U << 31);
+
+CheckInHandler::CheckInHandler() {}
+
+CHIP_ERROR CheckInHandler::Init(Messaging::ExchangeManager * exchangeManager, ICDClientStorage * clientStorage,
+                                CheckInDelegate * delegate)
+{
+    VerifyOrReturnError(exchangeManager != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+    VerifyOrReturnError(clientStorage != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+    VerifyOrReturnError(mpExchangeManager == nullptr, CHIP_ERROR_INCORRECT_STATE);
+    VerifyOrReturnError(mpICDClientStorage == nullptr, CHIP_ERROR_INCORRECT_STATE);
+
+    mpExchangeManager  = exchangeManager;
+    mpICDClientStorage = clientStorage;
+    mpCheckInDelegate  = delegate;
+
+    return mpExchangeManager->RegisterUnsolicitedMessageHandlerForType(Protocols::SecureChannel::MsgType::ICD_CheckIn, this);
+}
+
+void CheckInHandler::Shutdown()
+{
+    mpICDClientStorage = nullptr;
+    mpCheckInDelegate  = nullptr;
+    if (mpExchangeManager)
+    {
+        mpExchangeManager->UnregisterUnsolicitedMessageHandlerForType(Protocols::SecureChannel::MsgType::ICD_CheckIn);
+        mpExchangeManager = nullptr;
+    }
+}
+
+CHIP_ERROR CheckInHandler::OnUnsolicitedMessageReceived(const PayloadHeader & payloadHeader, ExchangeDelegate *& newDelegate)
+{
+    // Return error for wrong message type
+    VerifyOrReturnError(payloadHeader.HasMessageType(Protocols::SecureChannel::MsgType::ICD_CheckIn),
+                        CHIP_ERROR_INVALID_MESSAGE_TYPE);
+
+    newDelegate = this;
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR CheckInHandler::OnMessageReceived(Messaging::ExchangeContext * ec, const PayloadHeader & payloadHeader,
+                                             System::PacketBufferHandle && payload)
+{
+    // If the message type is not ICD_CheckIn, return CHIP_NO_ERROR and exit
+    VerifyOrReturnError(payloadHeader.HasMessageType(Protocols::SecureChannel::MsgType::ICD_CheckIn), CHIP_NO_ERROR);
+
+    ByteSpan payloadByteSpan{ payload->Start(), payload->DataLength() };
+    ICDClientInfo clientInfo;
+    CounterType counter = 0;
+    // If the check-in message processing fails, return CHIP_NO_ERROR and exit.
+    CHIP_ERROR err = mpICDClientStorage->ProcessCheckInPayload(payloadByteSpan, clientInfo, counter);
+    if (CHIP_NO_ERROR != err)
+    {
+        ChipLogError(ICD, "ProcessCheckInPayload failed: %" CHIP_ERROR_FORMAT, err.Format());
+        return CHIP_NO_ERROR;
+    }
+    CounterType receivedCheckInCounterOffset = (counter - clientInfo.start_icd_counter) % kCheckInCounterMax;
+
+    // Detect duplicate check-in messages and return CHIP_NO_ERROR on receiving a duplicate message
+    if (receivedCheckInCounterOffset <= clientInfo.offset)
+    {
+        ChipLogError(ICD, "A duplicate check-in message was received and discarded");
+        return CHIP_NO_ERROR;
+    }
+
+    clientInfo.offset = receivedCheckInCounterOffset;
+    bool refreshKey   = (receivedCheckInCounterOffset > kKeyRefreshLimit);
+
+    if (refreshKey)
+    {
+        // TODO: A new CASE session should be established to re-register the client using a new key. The registration will happen in
+        // CASE session callback
+    }
+    else
+    {
+        mpCheckInDelegate->OnCheckInComplete(clientInfo);
+    }
+
+    return CHIP_NO_ERROR;
+}
+
+void CheckInHandler::OnResponseTimeout(Messaging::ExchangeContext * ec) {}
+
+} // namespace app
+} // namespace chip

src/app/icd/client/CheckInHandler.h

@@ -0,0 +1,93 @@
+/*
+ *
+ *    Copyright (c) 2023 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.
+ */
+
+/**
+ *    @file
+ *      This file defines objects for a CHIP check-in message unsolicited
+ *      handler
+ *
+ */
+
+#pragma once
+
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app/CommandSender.h>
+#include <app/OperationalSessionSetup.h>
+#include <app/icd/client/CheckInDelegate.h>
+#include <app/icd/client/DefaultICDClientStorage.h>
+#include <lib/support/logging/CHIPLogging.h>
+#include <messaging/ExchangeContext.h>
+#include <messaging/ExchangeMgr.h>
+
+namespace chip {
+namespace app {
+
+class CheckInHandler : public Messaging::ExchangeDelegate, public Messaging::UnsolicitedMessageHandler
+{
+
+public:
+    CHIP_ERROR Init(Messaging::ExchangeManager * exchangeManager, ICDClientStorage * clientStorage, CheckInDelegate * delegate);
+    void Shutdown();
+
+    CheckInHandler();
+
+    virtual ~CheckInHandler() = default;
+
+protected:
+    // ExchangeDelegate
+    CHIP_ERROR
+    OnMessageReceived(Messaging::ExchangeContext * ec, const PayloadHeader & payloadHeader,
+                      System::PacketBufferHandle && payload) override;
+
+    // UnsolicitedMessageHandler
+    CHIP_ERROR OnUnsolicitedMessageReceived(const PayloadHeader & payloadHeader, ExchangeDelegate *& newDelegate) override;
+
+    // TODO : Follow up to check if this really needs to be a pure virtual function in Exchange delegate
+    // https://github.com/project-chip/connectedhomeip/issues/31322
+    void OnResponseTimeout(Messaging::ExchangeContext * ec) override;
+
+    Messaging::ExchangeMessageDispatch & GetMessageDispatch() override { return CheckInExchangeDispatch::Instance(); }
+
+private:
+    class CheckInExchangeDispatch : public Messaging::ExchangeMessageDispatch
+    {
+    public:
+        static ExchangeMessageDispatch & Instance()
+        {
+            static CheckInExchangeDispatch instance;
+            return instance;
+        }
+
+        CheckInExchangeDispatch() {}
+        ~CheckInExchangeDispatch() override {}
+
+    protected:
+        bool MessagePermitted(Protocols::Id, uint8_t type) override
+        {
+            return type == to_underlying(Protocols::SecureChannel::MsgType::ICD_CheckIn);
+        }
+        bool IsEncryptionRequired() const override { return false; }
+    };
+
+    Messaging::ExchangeManager * mpExchangeManager = nullptr;
+    CheckInDelegate * mpCheckInDelegate            = nullptr;
+    ICDClientStorage * mpICDClientStorage          = nullptr;
+};
+
+} // namespace app
+} // namespace chip

src/app/icd/client/DefaultCheckInDelegate.cpp

@@ -0,0 +1,44 @@
+/*
+ *    Copyright (c) 2023 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.
+ */
+
+#include "CheckInHandler.h"
+#include <app/icd/client/DefaultCheckInDelegate.h>
+#include <crypto/CHIPCryptoPAL.h>
+#include <lib/support/CodeUtils.h>
+#include <lib/support/logging/CHIPLogging.h>
+#include <memory>
+
+namespace chip {
+namespace app {
+
+CHIP_ERROR DefaultCheckInDelegate::Init(ICDClientStorage * storage)
+{
+    VerifyOrReturnError(storage != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
+    VerifyOrReturnError(mpStorage == nullptr, CHIP_ERROR_INCORRECT_STATE);
+    mpStorage = storage;
+    return CHIP_NO_ERROR;
+}
+
+void DefaultCheckInDelegate::OnCheckInComplete(const ICDClientInfo & clientInfo)
+{
+    ChipLogProgress(
+        ICD, "Check In Message processing complete: start_counter=%" PRIu32 " offset=%" PRIu32 " nodeid=" ChipLogFormatScopedNodeId,
+        clientInfo.start_icd_counter, clientInfo.offset, ChipLogValueScopedNodeId(clientInfo.peer_node));
+}
+
+} // namespace app
+} // namespace chip