Icd handler

examples/chip-tool/BUILD.gn

@@ -103,7 +103,6 @@ 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: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

@@ -51,7 +51,7 @@ chip::Credentials::GroupDataProviderImpl CHIPCommand::sGroupDataProvider{ kMaxGr
 chip::app::DefaultICDClientStorage CHIPCommand::sICDClientStorage;
 chip::Crypto::RawKeySessionKeystore CHIPCommand::sSessionKeystore;
 chip::app::DefaultCheckInDelegate CHIPCommand::sCheckInDelegate;
-chip::app::CheckInMessageHandler CHIPCommand::sCheckInHandler;
+chip::app::CheckInHandler CHIPCommand::sCheckInHandler;
 
 namespace {
 

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

@@ -129,7 +129,10 @@ class CHIPCommand : public Command
 
     // Shut down the command.  After a Shutdown call the command object is ready
     // to be used for another command invocation.
-    virtual void Shutdown() { ResetArguments(); }
+    virtual void Shutdown()
+    {
+        ResetArguments();
+    }
 
     // Clean up any resources allocated by the command.  Some commands may hold
     // on to resources after Shutdown(), but Cleanup() will guarantee those are
@@ -140,12 +143,18 @@ class CHIPCommand : public Command
     // can keep doing work as needed.  Cleanup() will be called when quitting
     // interactive mode.  This method will be called before Shutdown, so it can
     // use member values that Shutdown will normally reset.
-    virtual bool DeferInteractiveCleanup() { return false; }
+    virtual bool DeferInteractiveCleanup()
+    {
+        return false;
+    }
 
     // If true, the controller will be created with server capabilities enabled,
     // such as advertising operational nodes over DNS-SD and accepting incoming
     // CASE sessions.
-    virtual bool NeedsOperationalAdvertising() { return mAdvertiseOperational; }
+    virtual bool NeedsOperationalAdvertising()
+    {
+        return mAdvertiseOperational;
+    }
 
     // Execute any deferred cleanups.  Used when exiting interactive mode.
     static void ExecuteDeferredCleanups(intptr_t ignored);
@@ -163,7 +172,7 @@ class CHIPCommand : public Command
     static chip::Credentials::GroupDataProviderImpl sGroupDataProvider;
     static chip::app::DefaultICDClientStorage sICDClientStorage;
     static chip::app::DefaultCheckInDelegate sCheckInDelegate;
-    static chip::app::CheckInMessageHandler sCheckInHandler;
+    static chip::app::CheckInHandler sCheckInHandler;
     CredentialIssuerCommands * mCredIssuerCmds;
 
     std::string GetIdentity();

src/app/icd/client/BUILD.gn

@@ -47,5 +47,6 @@ source_set("handler") {
     "${chip_root}/src/lib/core",
     "${chip_root}/src/messaging",
     "${chip_root}/src/protocols",
+    "${chip_root}/src/app",
   ]
 }

src/app/icd/client/CheckInDelegate.h

@@ -19,38 +19,63 @@
 #pragma once
 
 #include <app/icd/client/ICDClientInfo.h>
+#include <app/icd/client/ICDRefreshKeyInfo.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
- * OnCheckInComplete will be called on successful processing of a received checkIn message from the server
- * OnRefreshKey will be called when the key needs to be refreshed to avoid check in counter roll over problems. On receiving
- * OnRefreshKey callback, the application needs to generate a new key.
  */
 class DLL_EXPORT CheckInDelegate
 {
 public:
     virtual ~CheckInDelegate() {}
 
     /**
-     * @brief Callback used to let the application know that a checkin message was received and validated.
+     * @brief Callback used to let the application know that a check-in message was received and validated.
      *
-     * @param[in] clientInfo - ClientInfo object of the peer node
+     * @param[in] clientInfo - ICDClientInfo object representing the state associated with the
+                               node that sent the check-in message.
      */
-    virtual void OnCheckInComplete(ICDClientInfo & clientInfo) = 0;
+    virtual void OnCheckInComplete(const ICDClientInfo & clientInfo) = 0;
 
     /**
      * @brief Callback used to let the application know that a key refresh is
-     * needed to avoid counter roolover problems.
+     * needed to avoid counter rollover problems.
      *
-     * The implementer of this function should generate a new key
+     * The implementer of this function should generate a new key and store it in a map with peer nodeID as the key and
+     * ICDRefreshKeyInfo as the value.
      *
-     * @param[out] keyData - new key generated
+     * @param[in] clientInfo - ICDClientInfo object representing the state associated with the
+                               node that sent the check-in message. The callee can use the clientInfo to determine the type of key
+                               to generate.
+     * @param[out] keyData - pointer to the keyData buffer of size keyDataLength. The implementer of this callback should generate a
+                             new key of size keyLength and copy it to the keyData buffer
+     * @param[in] keyLength - length of the new key to be generated
      */
-    virtual void OnRefreshKey(ByteSpan & keyData) = 0;
+    virtual void OnRefreshKeyGenerate(const ICDClientInfo & clientInfo, uint8_t * keyData, uint8_t keyLength) = 0;
+
+    /**
+     * @brief Callback used to retrieve the refresh key information from the application after establishing a new secure session for
+     * re-registration. The application should maintain a map to store the corresponding ICDRefreshKeyInfo for every peer node.
+     * Please refer to ICDRefreshKeyInfo.h for details.
+     *
+     * @param[in] nodeId - node ID of the peer with whom the client needs to re-register with a new key to avoid rollover problems.
+     * @param[out] refreshKeyInfo - stored refreshKeyInfo for the corresponding nodeId from the ICDRefreshKeyMap
+     */
+    virtual CHIP_ERROR OnRefreshKeyRetrieve(const ScopedNodeId & nodeId, ICDRefreshKeyInfo & refreshKeyInfo) = 0;
+
+    /**
+ * @brief Callback used to let the application know that the re-registration with the new key was successful and provides the
+ * updated ICDClientInfo
+ *
+ * @param[in] clientInfo - ICDClientInfo object representing the state associated with the
+                           node that sent the check-in message. This will have the new key used for registration and the updated icd
+                           counter.
+ */
+    virtual void OnRegistrationComplete(const ICDClientInfo & clientInfo) = 0;
 };
 
 } // namespace app

src/app/icd/client/CheckInHandler.cpp

@@ -22,8 +22,10 @@
  *
  */
 
+#include <app/InteractionModelTimeout.h>
 #include <app/icd/client/CheckInDelegate.h>
 #include <app/icd/client/CheckInHandler.h>
+#include <app/icd/client/ICDRefreshKeyInfo.h>
 
 #include <cinttypes>
 
@@ -32,6 +34,9 @@
 #include <messaging/Flags.h>
 #include <protocols/Protocols.h>
 
+#include "controller/InvokeInteraction.h"
+#include <app/InteractionModelEngine.h>
+#include <app/OperationalSessionSetup.h>
 #include <protocols/secure_channel/Constants.h>
 
 namespace chip {
@@ -40,8 +45,12 @@ namespace app {
 inline constexpr uint64_t kCheckInCounterMax = (1ULL << 32);
 inline constexpr uint32_t kKeyRefreshLimit   = (1U << 31);
 
-CHIP_ERROR CheckInMessageHandler::Init(Messaging::ExchangeManager * exchangeManager, ICDClientStorage * clientStorage,
-                                       CheckInDelegate * delegate)
+CheckInHandler::CheckInHandler() :
+    mOnConnectedCallback(HandleDeviceConnected, this), mOnConnectionFailureCallback(HandleDeviceConnectionFailure, this)
+{}
+
+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);
@@ -55,17 +64,18 @@ CHIP_ERROR CheckInMessageHandler::Init(Messaging::ExchangeManager * exchangeMana
     return mpExchangeManager->RegisterUnsolicitedMessageHandlerForType(Protocols::SecureChannel::MsgType::ICD_CheckIn, this);
 }
 
-void CheckInMessageHandler::Shutdown()
+void CheckInHandler::Shutdown()
 {
     mpICDClientStorage = nullptr;
+    mpCheckInDelegate  = nullptr;
     if (mpExchangeManager)
     {
         mpExchangeManager->UnregisterUnsolicitedMessageHandlerForType(Protocols::SecureChannel::MsgType::ICD_CheckIn);
         mpExchangeManager = nullptr;
     }
 }
 
-CHIP_ERROR CheckInMessageHandler::OnUnsolicitedMessageReceived(const PayloadHeader & payloadHeader, ExchangeDelegate *& newDelegate)
+CHIP_ERROR CheckInHandler::OnUnsolicitedMessageReceived(const PayloadHeader & payloadHeader, ExchangeDelegate *& newDelegate)
 {
     // Return error for wrong message type
     VerifyOrReturnError(payloadHeader.HasMessageType(Protocols::SecureChannel::MsgType::ICD_CheckIn),
@@ -75,24 +85,24 @@ CHIP_ERROR CheckInMessageHandler::OnUnsolicitedMessageReceived(const PayloadHead
     return CHIP_NO_ERROR;
 }
 
-CHIP_ERROR CheckInMessageHandler::OnMessageReceived(Messaging::ExchangeContext * ec, const PayloadHeader & payloadHeader,
-                                                    System::PacketBufferHandle && payload)
+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 CheckIn message processing fails, return CHIP_NO_ERROR and exit.
+    // If the check-in message processing fails, return CHIP_NO_ERROR and exit.
     VerifyOrReturnError(CHIP_NO_ERROR == mpICDClientStorage->ProcessCheckInPayload(payloadByteSpan, clientInfo, counter),
                         CHIP_NO_ERROR);
     CounterType receivedCheckInCounterOffset = (counter - clientInfo.start_icd_counter) % kCheckInCounterMax;
 
-    // Detect duplicate CheckIn messages and return CHIP_NO_ERROR on receiving a duplicate message
+    // Detect duplicate check-in messages and return CHIP_NO_ERROR on receiving a duplicate message
     if (receivedCheckInCounterOffset <= clientInfo.offset)
     {
-        ChipLogError(ICD, "A duplicate CheckIn message was received and discarded");
+        ChipLogError(ICD, "A duplicate check-in message was received and discarded");
         return CHIP_NO_ERROR;
     }
 
@@ -101,20 +111,66 @@ CHIP_ERROR CheckInMessageHandler::OnMessageReceived(Messaging::ExchangeContext *
 
     if (refreshKey)
     {
-        ByteSpan newKeyData;
-        mpCheckInDelegate->OnRefreshKey(newKeyData);
-        RegisterClientWithNewKey(clientInfo, newKeyData);
+        uint8_t newKeyData[chip::Crypto::kAES_CCM128_Key_Length];
+        mpCheckInDelegate->OnRefreshKeyGenerate(clientInfo, newKeyData, chip::Crypto::kAES_CCM128_Key_Length);
+        // A new session should be established to re-register the client using the new key. The registration will happen in
+        // mOnDeviceConnected callback
+        EstablishSessionToPeer(clientInfo.peer_node);
+    }
+    else
+    {
+        mpCheckInDelegate->OnCheckInComplete(clientInfo);
     }
-    mpCheckInDelegate->OnCheckInComplete(clientInfo);
+
     return CHIP_NO_ERROR;
 }
 
-CHIP_ERROR CheckInMessageHandler::RegisterClientWithNewKey(ICDClientInfo & clientInfo, const ByteSpan keyData)
+CHIP_ERROR CheckInHandler::RegisterClientWithNewKey(ICDClientInfo & clientInfo, ByteSpan newKey,
+                                                    Messaging::ExchangeManager & exchangeMgr, const SessionHandle & sessionHandle)
 {
-    // TODO - Register the client. On successful registration, update the clientInfo with the new key and store the clientInfo
+    Clusters::IcdManagement::Commands::RegisterClient::Type request;
+    request.checkInNodeID    = clientInfo.peer_node.GetNodeId();
+    request.monitoredSubject = clientInfo.monitored_subject;
+    request.key              = newKey;
+    // TODO1 : We don't have plain data for the old key
+    // TODO2 : Find  the right way to send the registration command. Both the success and failure callbacks for registration should
+    // call OnCheckInComplete
+
     return CHIP_NO_ERROR;
 }
-void CheckInMessageHandler::OnResponseTimeout(Messaging::ExchangeContext * ec) {}
+
+void CheckInHandler::EstablishSessionToPeer(ScopedNodeId peerId)
+{
+    ChipLogProgress(ICD, "Trying to establish a CASE session for re-registering an ICD client");
+    auto * caseSessionManager = InteractionModelEngine::GetInstance()->GetCASESessionManager();
+    VerifyOrReturn(caseSessionManager != nullptr);
+    caseSessionManager->FindOrEstablishSession(peerId, &mOnConnectedCallback, &mOnConnectionFailureCallback);
+}
+
+void CheckInHandler::HandleDeviceConnected(void * context, Messaging::ExchangeManager & exchangeMgr,
+                                           const SessionHandle & sessionHandle)
+{
+    CheckInHandler * const _this = static_cast<CheckInHandler *>(context);
+    VerifyOrDie(_this != nullptr);
+    ICDRefreshKeyInfo refreshKeyInfo;
+    if (CHIP_NO_ERROR !=
+        _this->mpCheckInDelegate->OnRefreshKeyRetrieve(sessionHandle->AsSecureSession()->GetPeer(), refreshKeyInfo))
+    {
+        ChipLogError(ICD, "Failed to retrieve a new key for re-registration of the ICD client");
+    }
+    ByteSpan newKey(refreshKeyInfo.newKey);
+    _this->RegisterClientWithNewKey(refreshKeyInfo.clientInfo, newKey, exchangeMgr, sessionHandle);
+}
+
+void CheckInHandler::HandleDeviceConnectionFailure(void * context, const ScopedNodeId & peerId, CHIP_ERROR err)
+{
+    CheckInHandler * const _this = static_cast<CheckInHandler *>(context);
+    VerifyOrDie(_this != nullptr);
+
+    ChipLogError(ICD, "Failed to establish CASE for re-registration with error '%" CHIP_ERROR_FORMAT "'", err.Format());
+}
+
+void CheckInHandler::OnResponseTimeout(Messaging::ExchangeContext * ec) {}
 
 } // namespace app
 } // namespace chip

src/app/icd/client/CheckInHandler.h

@@ -18,13 +18,15 @@
 
 /**
  *    @file
- *      This file defines objects for a CHIP CheckInMessage unsolicited
+ *      This file defines objects for a CHIP check-in message unsolicited
  *      handler
  *
  */
 
 #pragma once
 
+#include <app-common/zap-generated/cluster-objects.h>
+#include <app/OperationalSessionSetup.h>
 #include <app/icd/client/CheckInDelegate.h>
 #include <app/icd/client/DefaultICDClientStorage.h>
 #include <lib/support/logging/CHIPLogging.h>
@@ -33,19 +35,27 @@
 
 namespace chip {
 namespace app {
-class CheckInMessageHandler : public Messaging::ExchangeDelegate, public Messaging::UnsolicitedMessageHandler
+
+class CheckInHandler : public Messaging::ExchangeDelegate, public Messaging::UnsolicitedMessageHandler
 {
 
 public:
     CHIP_ERROR Init(Messaging::ExchangeManager * exchangeManager, ICDClientStorage * clientStorage, CheckInDelegate * delegate);
     void Shutdown();
 
-    virtual ~CheckInMessageHandler() = default;
+    CheckInHandler();
+
+    virtual ~CheckInHandler() = default;
+
+    static void HandleDeviceConnected(void * context, Messaging::ExchangeManager & exchangeMgr,
+                                      const SessionHandle & sessionHandle);
+    static void HandleDeviceConnectionFailure(void * context, const ScopedNodeId & peerId, CHIP_ERROR err);
 
 protected:
     // ExchangeDelegate
-    CHIP_ERROR OnMessageReceived(Messaging::ExchangeContext * ec, const PayloadHeader & payloadHeader,
-                                 System::PacketBufferHandle && payload) override;
+    CHIP_ERROR
+    OnMessageReceived(Messaging::ExchangeContext * ec, const PayloadHeader & payloadHeader,
+                      System::PacketBufferHandle && payload) override;
 
     // UnsolicitedMessageHandler
     CHIP_ERROR OnUnsolicitedMessageReceived(const PayloadHeader & payloadHeader, ExchangeDelegate *& newDelegate) override;
@@ -62,7 +72,20 @@ class CheckInMessageHandler : public Messaging::ExchangeDelegate, public Messagi
      * @param[in] clientInfo clientInfo object
      * @param[in] keyData New key data to use to re-register the client with the server
      */
-    CHIP_ERROR RegisterClientWithNewKey(ICDClientInfo & clientInfo, const ByteSpan keyData);
+    CHIP_ERROR RegisterClientWithNewKey(ICDClientInfo & clientInfo, ByteSpan newKey, Messaging::ExchangeManager & exchangeMgr,
+                                        const SessionHandle & sessionHandle);
+
+    /**
+     * @brief Sets up a CASE session to the peer, if we can locate a
+     * CASESessionManager.  Returns error if we did not even manage to kick off
+     * a CASE attempt.
+     *
+     * @param[in] peerId Node ID of the peer
+     */
+    void EstablishSessionToPeer(ScopedNodeId peerId);
+
+    chip::Callback::Callback<OnDeviceConnected> mOnConnectedCallback;
+    chip::Callback::Callback<OnDeviceConnectionFailure> mOnConnectionFailureCallback;
 
     class CheckInExchangeDispatch : public Messaging::ExchangeMessageDispatch
     {
@@ -86,8 +109,7 @@ class CheckInMessageHandler : public Messaging::ExchangeDelegate, public Messagi
 
     Messaging::ExchangeManager * mpExchangeManager = nullptr;
     CheckInDelegate * mpCheckInDelegate            = nullptr;
-    Messaging::ExchangeManager * GetExchangeManager(void) const { return mpExchangeManager; }
-    ICDClientStorage * mpICDClientStorage = nullptr;
+    ICDClientStorage * mpICDClientStorage          = nullptr;
 };
 
 } // namespace app