Make TestBdxTransferServer::Shutdown() restore the default UnsolicitedMessageHandler (project-chip#41536)

feasel0 · web-flow · commit 0c3358c47655 · 2025-11-07T19:16:03.000Z
* Save the SendInit handler, re-register it during shutdown, make it so Shutdown is actually called.

* Moved implementation to Shutdown, simplifying

* Restyled fixes

* Init saves the handler so factory is not needed during shutdown

* Style and comment fixes

* Comment change
diff --git a/src/controller/python/matter/ChipStack.py b/src/controller/python/matter/ChipStack.py
@@ -193,6 +193,9 @@ def Shutdown(self):
         for subscription in tuple(self._subscriptions.values()):
             subscription.Shutdown()
 
+        # Shut down the BDX server.
+        Bdx.Shutdown()
+
         # Terminate Matter thread and shutdown the stack.
         self._ChipStackLib.pychip_DeviceController_StackShutdown()
 
diff --git a/src/controller/python/matter/bdx/Bdx.py b/src/controller/python/matter/bdx/Bdx.py
@@ -248,6 +248,16 @@ def Init():
         setter.Set('pychip_Bdx_InitCallbacks', None, [
                    _OnTransferObtainedCallbackFunct, _OnFailedToObtainTransferCallbackFunct, _OnDataReceivedCallbackFunct,
                    _OnTransferCompletedCallbackFunct])
+        setter.Set('pychip_Bdx_Shutdown',
+                   None, [])
 
     handle.pychip_Bdx_InitCallbacks(
         _OnTransferObtainedCallback, _OnFailedToObtainTransferCallback, _OnDataReceivedCallback, _OnTransferCompletedCallback)
+
+
+def Shutdown():
+    '''
+    Shut down the BDX server.
+    '''
+    handle = GetLibraryHandle()
+    handle.pychip_Bdx_Shutdown()
diff --git a/src/controller/python/matter/bdx/bdx.cpp b/src/controller/python/matter/bdx/bdx.cpp
@@ -215,6 +215,12 @@ void pychip_Bdx_InitCallbacks(OnTransferObtainedCallback onTransferObtainedCallb
     gBdxTransferServer.Init(systemLayer, factory.GetSystemState()->ExchangeMgr());
 }
 
+void pychip_Bdx_Shutdown()
+{
+    // Shut down and clean up resources associated with the TestBdxTransferServer instance.
+    gBdxTransferServer.Shutdown();
+}
+
 // Prepares the BDX system to expect a new transfer.
 // If max_block_size != 0, it overrides the default cap for the next transfer only.
 PyChipError pychip_Bdx_ExpectBdxTransfer(PyObject transferObtainedContext, uint16_t max_block_size)
diff --git a/src/controller/python/matter/bdx/test-bdx-transfer-server.cpp b/src/controller/python/matter/bdx/test-bdx-transfer-server.cpp
@@ -36,14 +36,23 @@ CHIP_ERROR TestBdxTransferServer::Init(System::Layer * systemLayer, Messaging::E
     mSystemLayer     = systemLayer;
     mExchangeManager = exchangeManager;
     // This removes the BdxTransferServer registered as part of CHIPDeviceControllerFactory.
-    mExchangeManager->UnregisterUnsolicitedMessageHandlerForType(MessageType::SendInit);
+    // Store the handler that was previously registered for SendInit so we can restore it on shutdown.
+    mExchangeManager->UnregisterUnsolicitedMessageHandlerForType(MessageType::SendInit, &mPrevSendInitHandler);
     return mExchangeManager->RegisterUnsolicitedMessageHandlerForProtocol(Protocols::BDX::Id, this);
 }
 
 void TestBdxTransferServer::Shutdown()
 {
     VerifyOrReturn(mExchangeManager != nullptr);
     LogErrorOnFailure(mExchangeManager->UnregisterUnsolicitedMessageHandlerForProtocol(Protocols::BDX::Id));
+
+    // Re-register the BdxTransferServer that was registered as part of CHIPDeviceControllerFactory.
+    // Otherwise when BdxTransferServer::Shutdown() attempts to unregister this, it causes an error.
+    if (mPrevSendInitHandler != nullptr)
+    {
+        LogErrorOnFailure(mExchangeManager->RegisterUnsolicitedMessageHandlerForType(MessageType::SendInit, mPrevSendInitHandler));
+    }
+
     mExchangeManager = nullptr;
 }
 
diff --git a/src/controller/python/matter/bdx/test-bdx-transfer-server.h b/src/controller/python/matter/bdx/test-bdx-transfer-server.h
@@ -59,10 +59,11 @@ class TestBdxTransferServer : public Messaging::UnsolicitedMessageHandler
     static constexpr size_t kTransferPoolSize = 2;
 
     ObjectPool<BdxTransfer, kTransferPoolSize> mTransferPool;
-    System::Layer * mSystemLayer                  = nullptr;
-    Messaging::ExchangeManager * mExchangeManager = nullptr;
-    BdxTransfer::Delegate * mBdxTransferDelegate  = nullptr;
-    size_t mExpectedTransfers                     = 0;
+    System::Layer * mSystemLayer                                = nullptr;
+    Messaging::ExchangeManager * mExchangeManager               = nullptr;
+    BdxTransfer::Delegate * mBdxTransferDelegate                = nullptr;
+    size_t mExpectedTransfers                                   = 0;
+    Messaging::UnsolicitedMessageHandler * mPrevSendInitHandler = nullptr;
 };
 
 } // namespace bdx
diff --git a/src/messaging/ExchangeMgr.cpp b/src/messaging/ExchangeMgr.cpp
@@ -135,9 +135,10 @@ CHIP_ERROR ExchangeManager::UnregisterUnsolicitedMessageHandlerForProtocol(Proto
     return UnregisterUMH(protocolId, kAnyMessageType);
 }
 
-CHIP_ERROR ExchangeManager::UnregisterUnsolicitedMessageHandlerForType(Protocols::Id protocolId, uint8_t msgType)
+CHIP_ERROR ExchangeManager::UnregisterUnsolicitedMessageHandlerForType(Protocols::Id protocolId, uint8_t msgType,
+                                                                       Messaging::UnsolicitedMessageHandler ** outHandler)
 {
-    return UnregisterUMH(protocolId, static_cast<int16_t>(msgType));
+    return UnregisterUMH(protocolId, static_cast<int16_t>(msgType), outHandler);
 }
 
 CHIP_ERROR ExchangeManager::RegisterUMH(Protocols::Id protocolId, int16_t msgType, UnsolicitedMessageHandler * handler)
@@ -170,18 +171,29 @@ CHIP_ERROR ExchangeManager::RegisterUMH(Protocols::Id protocolId, int16_t msgTyp
     return CHIP_NO_ERROR;
 }
 
-CHIP_ERROR ExchangeManager::UnregisterUMH(Protocols::Id protocolId, int16_t msgType)
+CHIP_ERROR ExchangeManager::UnregisterUMH(Protocols::Id protocolId, int16_t msgType,
+                                          Messaging::UnsolicitedMessageHandler ** outHandler)
 {
     for (auto & umh : UMHandlerPool)
     {
         if (umh.IsInUse() && umh.Matches(protocolId, msgType))
         {
+            // Store the handler before unregistering.
+            if (outHandler != nullptr)
+            {
+                *outHandler = umh.Handler;
+            }
             umh.Reset();
             SYSTEM_STATS_DECREMENT(chip::System::Stats::kExchangeMgr_NumUMHandlers);
             return CHIP_NO_ERROR;
         }
     }
 
+    if (outHandler != nullptr)
+    {
+        *outHandler = nullptr;
+    }
+
     return CHIP_ERROR_NO_UNSOLICITED_MESSAGE_HANDLER;
 }
 
diff --git a/src/messaging/ExchangeMgr.h b/src/messaging/ExchangeMgr.h
@@ -168,20 +168,26 @@ class DLL_EXPORT ExchangeManager : public SessionMessageDelegate
      *
      *  @param[in]    msgType       The message type of the corresponding protocol.
      *
+     *  @param[out]   outHandler   If non-null, receives the handler that was unregistered. If no
+     *                             handler matched, *outHandler is set to nullptr. Callers may pass
+     *                             nullptr if they do not need this information.
+     *
      *  @retval #CHIP_ERROR_NO_UNSOLICITED_MESSAGE_HANDLER  If the matching unsolicited message handler
      *                                                       is not found.
      *  @retval #CHIP_NO_ERROR On success.
      */
-    CHIP_ERROR UnregisterUnsolicitedMessageHandlerForType(Protocols::Id protocolId, uint8_t msgType);
+    CHIP_ERROR UnregisterUnsolicitedMessageHandlerForType(Protocols::Id protocolId, uint8_t msgType,
+                                                          Messaging::UnsolicitedMessageHandler ** outHandler = nullptr);
 
     /**
      * A strongly-message-typed version of UnregisterUnsolicitedMessageHandlerForType.
      */
     template <typename MessageType, typename = std::enable_if_t<std::is_enum<MessageType>::value>>
-    CHIP_ERROR UnregisterUnsolicitedMessageHandlerForType(MessageType msgType)
+    CHIP_ERROR UnregisterUnsolicitedMessageHandlerForType(MessageType msgType,
+                                                          Messaging::UnsolicitedMessageHandler ** outHandler = nullptr)
     {
         return UnregisterUnsolicitedMessageHandlerForType(Protocols::MessageTypeTraits<MessageType>::ProtocolId(),
-                                                          to_underlying(msgType));
+                                                          to_underlying(msgType), outHandler);
     }
 
     /**
@@ -244,7 +250,8 @@ class DLL_EXPORT ExchangeManager : public SessionMessageDelegate
     UnsolicitedMessageHandlerSlot UMHandlerPool[CHIP_CONFIG_MAX_UNSOLICITED_MESSAGE_HANDLERS];
 
     CHIP_ERROR RegisterUMH(Protocols::Id protocolId, int16_t msgType, UnsolicitedMessageHandler * handler);
-    CHIP_ERROR UnregisterUMH(Protocols::Id protocolId, int16_t msgType);
+    CHIP_ERROR UnregisterUMH(Protocols::Id protocolId, int16_t msgType,
+                             Messaging::UnsolicitedMessageHandler ** outHandler = nullptr);
 
     void OnMessageReceived(const PacketHeader & packetHeader, const PayloadHeader & payloadHeader, const SessionHandle & session,
                            DuplicateMessage isDuplicate, System::PacketBufferHandle && msgBuf) override;
diff --git a/src/messaging/tests/TestExchange.cpp b/src/messaging/tests/TestExchange.cpp
@@ -151,8 +151,11 @@ void TestExchange::DoRoundTripTest(MockExchangeDelegate & delegate1, MockExchang
     ec1->Close();
     ec2->Close();
 
-    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Protocols::SecureChannel::Id, kMsgType_TEST1);
+    Messaging::UnsolicitedMessageHandler * removedHandler = nullptr;
+    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Protocols::SecureChannel::Id, kMsgType_TEST1,
+                                                                          &removedHandler);
     EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(removedHandler, &delegate2);
 }
 
 TEST_F(TestExchange, CheckBasicMessageRoundTrip)
diff --git a/src/messaging/tests/TestExchangeMgr.cpp b/src/messaging/tests/TestExchangeMgr.cpp
@@ -149,8 +149,10 @@ TEST_F(TestExchangeMgr, CheckSessionExpirationBasics)
     EXPECT_FALSE(receiveDelegate.IsOnMessageReceivedCalled);
     ec1->Close();
 
-    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Protocols::BDX::Id, kMsgType_TEST1);
+    Messaging::UnsolicitedMessageHandler * removedHandler = nullptr;
+    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Protocols::BDX::Id, kMsgType_TEST1, &removedHandler);
     EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(removedHandler, &receiveDelegate);
 
     // recreate closed session.
     EXPECT_EQ(CreateSessionAliceToBob(), CHIP_NO_ERROR);
@@ -219,11 +221,15 @@ TEST_F(TestExchangeMgr, CheckUmhRegistrationTest)
     err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForProtocol(Protocols::Echo::Id);
     EXPECT_NE(err, CHIP_NO_ERROR);
 
-    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Protocols::Echo::Id, kMsgType_TEST1);
+    Messaging::UnsolicitedMessageHandler * removedHandler = nullptr;
+    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Protocols::Echo::Id, kMsgType_TEST1, &removedHandler);
     EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(removedHandler, &mockAppDelegate);
 
-    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Protocols::Echo::Id, kMsgType_TEST2);
+    removedHandler = nullptr;
+    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Protocols::Echo::Id, kMsgType_TEST2, &removedHandler);
     EXPECT_NE(err, CHIP_NO_ERROR);
+    EXPECT_EQ(removedHandler, nullptr);
 }
 
 TEST_F(TestExchangeMgr, CheckExchangeMessages)
@@ -256,8 +262,10 @@ TEST_F(TestExchangeMgr, CheckExchangeMessages)
     DrainAndServiceIO();
     EXPECT_TRUE(mockUnsolicitedAppDelegate.IsOnMessageReceivedCalled);
 
-    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Protocols::BDX::Id, kMsgType_TEST1);
+    Messaging::UnsolicitedMessageHandler * removedHandler = nullptr;
+    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Protocols::BDX::Id, kMsgType_TEST1, &removedHandler);
     EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(removedHandler, &mockUnsolicitedAppDelegate);
 }
 
 } // namespace
diff --git a/src/messaging/tests/TestReliableMessageProtocol.cpp b/src/messaging/tests/TestReliableMessageProtocol.cpp
@@ -704,8 +704,10 @@ TEST_F(TestReliableMessageProtocol, CheckResendApplicationMessageWithPeerExchang
     EXPECT_EQ(rm->TestGetCountRetransTable(), 0);
     EXPECT_TRUE(mockReceiver.IsOnMessageReceivedCalled);
 
-    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest);
+    Messaging::UnsolicitedMessageHandler * removedHandler = nullptr;
+    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest, &removedHandler);
     EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(removedHandler, &mockReceiver);
 }
 
 TEST_F(TestReliableMessageProtocol, CheckDuplicateMessageClosedExchange)
@@ -757,8 +759,10 @@ TEST_F(TestReliableMessageProtocol, CheckDuplicateMessageClosedExchange)
     // Let's not drop the duplicate message
     mockReceiver.SetDropAckResponse(false);
 
-    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest);
+    Messaging::UnsolicitedMessageHandler * removedHandler = nullptr;
+    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest, &removedHandler);
     EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(removedHandler, &mockReceiver);
 
     // Wait for the first re-transmit and ack (should take 64ms)
     GetIOContext().DriveIOUntil(1000_ms32, [&] { return loopback.mSentMessageCount >= 3; });
@@ -849,8 +853,10 @@ TEST_F(TestReliableMessageProtocol, CheckDuplicateOldMessageClosedExchange)
     // Let's not drop the duplicate message's ack.
     mockReceiver.SetDropAckResponse(false);
 
-    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest);
+    Messaging::UnsolicitedMessageHandler * removedHandler = nullptr;
+    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest, &removedHandler);
     EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(removedHandler, &mockReceiver);
 
     // Wait for the first re-transmit and ack (should take 64ms)
     rm->StartTimer();
@@ -914,8 +920,10 @@ TEST_F(TestReliableMessageProtocol, CheckResendSessionEstablishmentMessageWithPe
     EXPECT_EQ(rm->TestGetCountRetransTable(), 0);
     EXPECT_TRUE(mockReceiver.IsOnMessageReceivedCalled);
 
-    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest);
+    Messaging::UnsolicitedMessageHandler * removedHandler = nullptr;
+    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest, &removedHandler);
     EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(removedHandler, &mockReceiver);
 }
 
 TEST_F(TestReliableMessageProtocol, CheckDuplicateMessage)
@@ -964,8 +972,10 @@ TEST_F(TestReliableMessageProtocol, CheckDuplicateMessage)
     EXPECT_EQ(loopback.mDroppedMessageCount, 0u);
     EXPECT_EQ(rm->TestGetCountRetransTable(), 1);
 
-    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest);
+    Messaging::UnsolicitedMessageHandler * removedHandler = nullptr;
+    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest, &removedHandler);
     EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(removedHandler, &mockReceiver);
 
     // Let's not drop the duplicate message
     mockReceiver.SetDropAckResponse(false);
@@ -1062,8 +1072,10 @@ TEST_F(TestReliableMessageProtocol, CheckReceiveAfterStandaloneAck)
     // Ensure that we have received that response.
     EXPECT_TRUE(mockSender.IsOnMessageReceivedCalled);
 
-    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest);
+    Messaging::UnsolicitedMessageHandler * removedHandler = nullptr;
+    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest, &removedHandler);
     EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(removedHandler, &mockReceiver);
 
     EXPECT_EQ(rm->TestGetCountRetransTable(), 0);
 }
@@ -1187,8 +1199,10 @@ TEST_F(TestReliableMessageProtocol, CheckPiggybackAfterPiggyback)
     EXPECT_TRUE(mockSender.IsOnMessageReceivedCalled);
     EXPECT_TRUE(mockSender.mReceivedPiggybackAck);
 
-    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest);
+    Messaging::UnsolicitedMessageHandler * removedHandler = nullptr;
+    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest, &removedHandler);
     EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(removedHandler, &mockReceiver);
 
     EXPECT_EQ(rm->TestGetCountRetransTable(), 0);
 }
@@ -1371,8 +1385,10 @@ TEST_F(TestReliableMessageProtocol, CheckMessageAfterClosed)
     // immediately on the receiver, due to the exchange being closed.
     EXPECT_EQ(rm->TestGetCountRetransTable(), 0);
 
-    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest);
+    Messaging::UnsolicitedMessageHandler * removedHandler = nullptr;
+    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest, &removedHandler);
     EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(removedHandler, &mockReceiver);
 
     EXPECT_EQ(rm->TestGetCountRetransTable(), 0);
 }
@@ -1926,8 +1942,10 @@ TEST_F(TestReliableMessageProtocol, CheckApplicationResponseDelayed)
     err = CreateSessionAliceToBob();
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest);
+    Messaging::UnsolicitedMessageHandler * removedHandler = nullptr;
+    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest, &removedHandler);
     EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(removedHandler, &mockReceiver);
 }
 
 TEST_F(TestReliableMessageProtocol, CheckApplicationResponseNeverComes)
@@ -2048,8 +2066,10 @@ TEST_F(TestReliableMessageProtocol, CheckApplicationResponseNeverComes)
     err = CreateSessionAliceToBob();
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest);
+    Messaging::UnsolicitedMessageHandler * removedHandler = nullptr;
+    err = GetExchangeManager().UnregisterUnsolicitedMessageHandlerForType(Echo::MsgType::EchoRequest, &removedHandler);
     EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(removedHandler, &mockReceiver);
 }
 
 #if CHIP_CONFIG_MRP_ANALYTICS_ENABLED

Original file line number	Diff line number	Diff line change
`@@ -135,9 +135,10 @@ CHIP_ERROR ExchangeManager::UnregisterUnsolicitedMessageHandlerForProtocol(Proto`
`135`	`135`	`return UnregisterUMH(protocolId, kAnyMessageType);`
`136`	`136`	`}`
`137`	`137`
`138`		`-CHIP_ERROR ExchangeManager::UnregisterUnsolicitedMessageHandlerForType(Protocols::Id protocolId, uint8_t msgType)`
	`138`	`+CHIP_ERROR ExchangeManager::UnregisterUnsolicitedMessageHandlerForType(Protocols::Id protocolId, uint8_t msgType,`
	`139`	`+ Messaging::UnsolicitedMessageHandler ** outHandler)`
`139`	`140`	`{`
`140`		`- return UnregisterUMH(protocolId, static_cast<int16_t>(msgType));`
	`141`	`+ return UnregisterUMH(protocolId, static_cast<int16_t>(msgType), outHandler);`
`141`	`142`	`}`
`142`	`143`
`143`	`144`	`CHIP_ERROR ExchangeManager::RegisterUMH(Protocols::Id protocolId, int16_t msgType, UnsolicitedMessageHandler * handler)`
`@@ -170,18 +171,29 @@ CHIP_ERROR ExchangeManager::RegisterUMH(Protocols::Id protocolId, int16_t msgTyp`
`170`	`171`	`return CHIP_NO_ERROR;`
`171`	`172`	`}`
`172`	`173`
`173`		`-CHIP_ERROR ExchangeManager::UnregisterUMH(Protocols::Id protocolId, int16_t msgType)`
	`174`	`+CHIP_ERROR ExchangeManager::UnregisterUMH(Protocols::Id protocolId, int16_t msgType,`
	`175`	`+ Messaging::UnsolicitedMessageHandler ** outHandler)`
`174`	`176`	`{`
`175`	`177`	`for (auto & umh : UMHandlerPool)`
`176`	`178`	`{`
`177`	`179`	`if (umh.IsInUse() && umh.Matches(protocolId, msgType))`
`178`	`180`	`{`
	`181`	`+ // Store the handler before unregistering.`
	`182`	`+ if (outHandler != nullptr)`
	`183`	`+ {`
	`184`	`+ *outHandler = umh.Handler;`
	`185`	`+ }`
`179`	`186`	`umh.Reset();`
`180`	`187`	`SYSTEM_STATS_DECREMENT(chip::System::Stats::kExchangeMgr_NumUMHandlers);`
`181`	`188`	`return CHIP_NO_ERROR;`
`182`	`189`	`}`
`183`	`190`	`}`
`184`	`191`
	`192`	`+ if (outHandler != nullptr)`
	`193`	`+ {`
	`194`	`+ *outHandler = nullptr;`
	`195`	`+ }`
	`196`	`+`
`185`	`197`	`return CHIP_ERROR_NO_UNSOLICITED_MESSAGE_HANDLER;`
`186`	`198`	`}`
`187`	`199`