From f18d8b78b3edfffb7c06f3eb69b74403fe32b6c8 Mon Sep 17 00:00:00 2001
From: Carol Yang <clyang@apple.com>
Date: Wed, 8 Dec 2021 23:11:08 -0800
Subject: [PATCH] [OTA] Use CASESessionManager to establish CASE sessions from
 OTARequestor class (#12636)

---
 .../OTAProviderExample.cpp                    |  26 +-
 examples/ota-requestor-app/linux/main.cpp     |  61 ++--
 src/app/CASESessionManager.h                  |   3 +
 .../clusters/ota-requestor/BDXDownloader.cpp  |  61 ++++
 .../clusters/ota-requestor/BDXDownloader.h    |  12 +
 .../ota-requestor/ClusterInterface.cpp        |   2 +-
 .../clusters/ota-requestor/OTARequestor.cpp   | 321 ++++++++----------
 src/app/clusters/ota-requestor/OTARequestor.h | 115 ++++---
 .../ota-requestor/OTARequestorInterface.h     |   4 +
 src/app/server/Server.h                       |  22 +-
 src/lib/core/CHIPError.h                      |  16 +
 11 files changed, 379 insertions(+), 264 deletions(-)

diff --git a/examples/ota-provider-app/ota-provider-common/OTAProviderExample.cpp b/examples/ota-provider-app/ota-provider-common/OTAProviderExample.cpp
index 3cc95d329c7b58..fe53145f19af96 100644
--- a/examples/ota-provider-app/ota-provider-common/OTAProviderExample.cpp
+++ b/examples/ota-provider-app/ota-provider-common/OTAProviderExample.cpp
@@ -20,17 +20,23 @@
 
 #include <app-common/zap-generated/cluster-objects.h>
 #include <app/clusters/ota-provider/ota-provider-delegate.h>
+#include <app/server/Server.h>
 #include <app/util/af.h>
+#include <credentials/FabricTable.h>
 #include <crypto/RandUtils.h>
 #include <lib/core/CHIPTLV.h>
 #include <lib/support/CHIPMemString.h>
-#include <protocols/secure_channel/PASESession.h> // For chip::kTestDeviceNodeId
 
 #include <string.h>
 
 using chip::ByteSpan;
 using chip::CharSpan;
+using chip::FabricIndex;
+using chip::FabricInfo;
+using chip::MutableCharSpan;
+using chip::NodeId;
 using chip::Optional;
+using chip::Server;
 using chip::Span;
 using chip::app::Clusters::OTAProviderDelegate;
 using namespace chip::app::Clusters::OtaSoftwareUpdateProvider::Commands;
@@ -57,19 +63,18 @@ void GenerateUpdateToken(uint8_t * buf, size_t bufSize)
     }
 }
 
-bool GenerateBdxUri(const Span<char> & fileDesignator, Span<char> outUri, size_t availableSize)
+bool GenerateBdxUri(NodeId nodeId, CharSpan fileDesignator, MutableCharSpan outUri)
 {
     static constexpr char bdxPrefix[] = "bdx://";
-    chip::NodeId nodeId               = chip::kTestDeviceNodeId; // TODO: read this dynamically
     size_t nodeIdHexStrLen            = sizeof(nodeId) * 2;
     size_t expectedLength             = strlen(bdxPrefix) + nodeIdHexStrLen + 1 + fileDesignator.size();
 
-    if (expectedLength >= availableSize)
+    if (expectedLength >= outUri.size())
     {
         return false;
     }
 
-    size_t written = static_cast<size_t>(snprintf(outUri.data(), availableSize, "%s" ChipLogFormatX64 "/%s", bdxPrefix,
+    size_t written = static_cast<size_t>(snprintf(outUri.data(), outUri.size(), "%s" ChipLogFormatX64 "/%s", bdxPrefix,
                                                   ChipLogValueX64(nodeId), fileDesignator.data()));
 
     return expectedLength == written;
@@ -115,9 +120,16 @@ EmberAfStatus OTAProviderExample::HandleQueryImage(chip::app::CommandHandler * c
 
     if (strlen(mOTAFilePath))
     {
+        // TODO: This uses the current node as the provider to supply the OTA image. This can be configurable such that the provider
+        // supplying the response is not the provider supplying the OTA image.
+        FabricIndex fabricIndex = commandObj->GetExchangeContext()->GetSessionHandle().GetFabricIndex();
+        FabricInfo * fabricInfo = Server::GetInstance().GetFabricTable().FindFabricWithIndex(fabricIndex);
+        NodeId nodeId           = fabricInfo->GetPeerId().GetNodeId();
+
         // Only doing BDX transport for now
-        GenerateBdxUri(Span<char>(mOTAFilePath, strlen(mOTAFilePath)), Span<char>(uriBuf, 0), kUriMaxLen);
-        ChipLogDetail(SoftwareUpdate, "generated URI: %s", uriBuf);
+        MutableCharSpan uri(uriBuf, kUriMaxLen);
+        GenerateBdxUri(nodeId, CharSpan(mOTAFilePath, strlen(mOTAFilePath)), uri);
+        ChipLogDetail(SoftwareUpdate, "Generated URI: %.*s", static_cast<int>(uri.size()), uri.data());
     }
 
     // Set Status for the Query Image Response
diff --git a/examples/ota-requestor-app/linux/main.cpp b/examples/ota-requestor-app/linux/main.cpp
index fc004f357376ed..4f38efd37420a2 100644
--- a/examples/ota-requestor-app/linux/main.cpp
+++ b/examples/ota-requestor-app/linux/main.cpp
@@ -16,7 +16,8 @@
  *    limitations under the License.
  */
 
-#include <app/OperationalDeviceProxy.h>
+#include <app/CASEClientPool.h>
+#include <app/OperationalDeviceProxyPool.h>
 #include <app/server/Server.h>
 #include <controller/ExampleOperationalCredentialsIssuer.h>
 #include <credentials/examples/DeviceAttestationCredsExample.h>
@@ -30,30 +31,38 @@
 
 using chip::BDXDownloader;
 using chip::ByteSpan;
+using chip::CASEClientPool;
 using chip::CharSpan;
-using chip::DeviceProxy;
 using chip::EndpointId;
 using chip::FabricIndex;
+using chip::GetRequestorInstance;
 using chip::LinuxOTAImageProcessor;
 using chip::NodeId;
 using chip::OnDeviceConnected;
 using chip::OnDeviceConnectionFailure;
+using chip::OperationalDeviceProxyPool;
+using chip::OTADownloader;
 using chip::OTAImageProcessorParams;
+using chip::OTARequestor;
 using chip::PeerId;
 using chip::Server;
 using chip::VendorId;
 using chip::Callback::Callback;
-using chip::Inet::IPAddress;
 using chip::System::Layer;
 using chip::Transport::PeerAddress;
 using namespace chip::ArgParser;
 using namespace chip::Messaging;
 using namespace chip::app::Clusters::OtaSoftwareUpdateProvider::Commands;
 
-OTARequestor requestorCore;
-LinuxOTARequestorDriver requestorUser;
-BDXDownloader downloader;
-LinuxOTAImageProcessor imageProcessor;
+constexpr size_t kMaxActiveCaseClients = 2;
+constexpr size_t kMaxActiveDevices     = 8;
+
+OTARequestor gRequestorCore;
+LinuxOTARequestorDriver gRequestorUser;
+BDXDownloader gDownloader;
+LinuxOTAImageProcessor gImageProcessor;
+CASEClientPool<kMaxActiveCaseClients> gCASEClientPool;
+OperationalDeviceProxyPool<kMaxActiveDevices> gDevicePool;
 
 bool HandleOptions(const char * aProgram, OptionSet * aOptions, int aIdentifier, const char * aName, const char * aValue);
 void OnStartDelayTimerHandler(Layer * systemLayer, void * appState);
@@ -62,10 +71,8 @@ constexpr uint16_t kOptionProviderNodeId      = 'n';
 constexpr uint16_t kOptionProviderFabricIndex = 'f';
 constexpr uint16_t kOptionUdpPort             = 'u';
 constexpr uint16_t kOptionDiscriminator       = 'd';
-constexpr uint16_t kOptionIPAddress           = 'i';
 constexpr uint16_t kOptionDelayQuery          = 'q';
 
-const char * ipAddress          = NULL;
 NodeId providerNodeId           = 0x0;
 FabricIndex providerFabricIndex = 1;
 uint16_t requestorSecurePort    = 0;
@@ -77,8 +84,6 @@ OptionDef cmdLineOptionsDef[] = {
     { "providerFabricIndex", chip::ArgParser::kArgumentRequired, kOptionProviderFabricIndex },
     { "udpPort", chip::ArgParser::kArgumentRequired, kOptionUdpPort },
     { "discriminator", chip::ArgParser::kArgumentRequired, kOptionDiscriminator },
-    // TODO: This can be removed once OperationalDeviceProxy can resolve the IP Address from Node ID
-    { "ipaddress", chip::ArgParser::kArgumentRequired, kOptionIPAddress },
     { "delayQuery", chip::ArgParser::kArgumentRequired, kOptionDelayQuery },
     {},
 };
@@ -95,8 +100,6 @@ OptionSet cmdLineOptions = { HandleOptions, cmdLineOptionsDef, "PROGRAM OPTIONS"
                              "  -d/--discriminator <discriminator>\n"
                              "        A 12-bit value used to discern between multiple commissionable CHIP device\n"
                              "        advertisements. If none is specified, default value is 3840.\n"
-                             "  -i/--ipaddress <IP Address>\n"
-                             "        The IP Address of the OTA Provider to connect to. This value must be supplied.\n"
                              "  -q/--delayQuery <Time in seconds>\n"
                              "        From boot up, the amount of time to wait before triggering the QueryImage\n"
                              "        command. If none or zero is supplied, QueryImage will not be triggered.\n" };
@@ -144,10 +147,6 @@ bool HandleOptions(const char * aProgram, OptionSet * aOptions, int aIdentifier,
             retval = false;
         }
         break;
-    case kOptionIPAddress:
-        ipAddress = aValue;
-        ChipLogError(SoftwareUpdate, "IP Address = %s", aValue);
-        break;
     case kOptionDelayQuery:
         delayQueryTimeInSec = static_cast<uint16_t>(strtol(aValue, NULL, 0));
         break;
@@ -201,10 +200,16 @@ int main(int argc, char * argv[])
     SetDeviceAttestationCredentialsProvider(chip::Credentials::Examples::GetExampleDACProvider());
 
     // Initialize and interconnect the Requestor and Image Processor objects -- START
-    SetRequestorInstance(&requestorCore);
+    SetRequestorInstance(&gRequestorCore);
+
+    // Set server instance used for session establishment
+    chip::Server * server = &(chip::Server::GetInstance());
+    server->SetCASEClientPool(&gCASEClientPool);
+    server->SetDevicePool(&gDevicePool);
+    gRequestorCore.SetServerInstance(server);
 
     // Connect the Requestor and Requestor Driver objects
-    requestorCore.SetOtaRequestorDriver(&requestorUser);
+    gRequestorCore.SetOtaRequestorDriver(&gRequestorUser);
 
     // WARNING: this is probably not realistic to know such details of the image or to even have an OTADownloader instantiated at
     // the beginning of program execution. We're using hardcoded values here for now since this is a reference application.
@@ -212,28 +217,20 @@ int main(int argc, char * argv[])
     // TODO: add API for OTARequestor to pass QueryImageResponse info to the application to use for OTADownloader init
     OTAImageProcessorParams ipParams;
     ipParams.imageFile = CharSpan("test.txt");
-    imageProcessor.SetOTAImageProcessorParams(ipParams);
-    imageProcessor.SetOTADownloader(&downloader);
+    gImageProcessor.SetOTAImageProcessorParams(ipParams);
+    gImageProcessor.SetOTADownloader(&gDownloader);
 
     // Connect the Downloader and Image Processor objects
-    downloader.SetImageProcessorDelegate(&imageProcessor);
+    gDownloader.SetImageProcessorDelegate(&gImageProcessor);
 
-    requestorCore.SetBDXDownloader(&downloader);
+    gRequestorCore.SetBDXDownloader(&gDownloader);
     // Initialize and interconnect the Requestor and Image Processor objects -- END
 
-    // Pass the IP Address to the OTARequestor object: Use of explicit IP address is temporary
-    // until the Exchange Layer implements address resolution
-    {
-        IPAddress ipAddr;
-        IPAddress::FromString(ipAddress, ipAddr);
-        requestorCore.SetIpAddress(ipAddr);
-    }
-
     // Test Mode operation: If a delay is provided, QueryImage after the timer expires
     if (delayQueryTimeInSec > 0)
     {
         // In this mode Provider node ID and fabric idx must be supplied explicitly from program args
-        requestorCore.TestModeSetProviderParameters(providerNodeId, providerFabricIndex);
+        gRequestorCore.TestModeSetProviderParameters(providerNodeId, providerFabricIndex);
 
         chip::DeviceLayer::SystemLayer().StartTimer(chip::System::Clock::Milliseconds32(delayQueryTimeInSec * 1000),
                                                     OnStartDelayTimerHandler, nullptr);
diff --git a/src/app/CASESessionManager.h b/src/app/CASESessionManager.h
index cbad650c0886c7..f2a5b381592a0c 100644
--- a/src/app/CASESessionManager.h
+++ b/src/app/CASESessionManager.h
@@ -56,6 +56,9 @@ class CASESessionManager : public SessionReleaseDelegate, public Dnssd::Resolver
         VerifyOrDie(params.sessionInitParams.Validate() == CHIP_NO_ERROR);
 
         mConfig = params;
+
+        // TODO: Revisit who should be set as the resolver delegate
+        Dnssd::Resolver::Instance().SetResolverDelegate(this);
     }
 
     virtual ~CASESessionManager() {}
diff --git a/src/app/clusters/ota-requestor/BDXDownloader.cpp b/src/app/clusters/ota-requestor/BDXDownloader.cpp
index 96d3edc21bc729..44e3ed9e6aa509 100644
--- a/src/app/clusters/ota-requestor/BDXDownloader.cpp
+++ b/src/app/clusters/ota-requestor/BDXDownloader.cpp
@@ -19,6 +19,8 @@
 #include "BDXDownloader.h"
 
 #include <lib/core/CHIPError.h>
+#include <lib/support/BufferReader.h>
+#include <lib/support/BytesToHex.h>
 #include <lib/support/CodeUtils.h>
 #include <protocols/bdx/BdxMessages.h>
 #include <system/SystemClock.h> /* TODO:(#12520) remove */
@@ -215,4 +217,63 @@ CHIP_ERROR BDXDownloader::HandleBdxEvent(const chip::bdx::TransferSession::Outpu
     return CHIP_NO_ERROR;
 }
 
+// TODO: Add unit tests for parsing BDX URI
+CHIP_ERROR BDXDownloader::ParseBdxUri(CharSpan uri, NodeId & nodeId, MutableCharSpan fileDesignator)
+{
+    // Check against minimum length of a valid BDX URI
+    if (uri.size() < kValidBdxUriMinLen)
+    {
+        return CHIP_ERROR_INVALID_STRING_LENGTH;
+    }
+
+    uint8_t readValue[kUriMaxLen];
+    Encoding::LittleEndian::Reader uriReader(reinterpret_cast<const uint8_t *>(uri.data()), uri.size());
+
+    // Check the scheme field matches the BDX prefix
+    memset(readValue, 0, sizeof(readValue));
+    ReturnErrorOnFailure(uriReader.ReadBytes(readValue, sizeof(bdxPrefix)).StatusCode());
+    ByteSpan expectedScheme(bdxPrefix, sizeof(bdxPrefix));
+    ByteSpan actualScheme(readValue, sizeof(bdxPrefix));
+    if (!expectedScheme.data_equal(actualScheme))
+    {
+        return CHIP_ERROR_INVALID_SCHEME_PREFIX;
+    }
+
+    // Extract the node ID from the authority field
+    memset(readValue, 0, sizeof(readValue));
+    ReturnErrorOnFailure(uriReader.ReadBytes(readValue, kNodeIdHexStringLen).StatusCode());
+    uint8_t buffer[kNodeIdHexStringLen];
+    if (Encoding::HexToBytes(reinterpret_cast<const char *>(readValue), kNodeIdHexStringLen, buffer, kNodeIdHexStringLen) == 0)
+    {
+        return CHIP_ERROR_INVALID_DESTINATION_NODE_ID;
+    }
+    nodeId = Encoding::BigEndian::Get64(buffer);
+    if (!IsOperationalNodeId(nodeId))
+    {
+        return CHIP_ERROR_INVALID_DESTINATION_NODE_ID;
+    }
+
+    // Verify the separator between authority and path fields
+    memset(readValue, 0, sizeof(readValue));
+    ReturnErrorOnFailure(uriReader.ReadBytes(readValue, sizeof(bdxSeparator)).StatusCode());
+    ByteSpan expectedSeparator(bdxSeparator, sizeof(bdxSeparator));
+    ByteSpan actualSeparator(readValue, sizeof(bdxSeparator));
+    if (!expectedSeparator.data_equal(actualSeparator))
+    {
+        return CHIP_ERROR_MISSING_URI_SEPARATOR;
+    }
+
+    // Extract file designator from the path field
+    size_t fileDesignatorLength = uriReader.Remaining();
+    memset(readValue, 0, sizeof(readValue));
+    ReturnErrorOnFailure(uriReader.ReadBytes(readValue, fileDesignatorLength).StatusCode());
+    size_t written = static_cast<size_t>(snprintf(fileDesignator.data(), fileDesignator.size(), "%s", readValue));
+    if (written != fileDesignatorLength)
+    {
+        return CHIP_ERROR_INTERNAL;
+    }
+
+    return CHIP_NO_ERROR;
+}
+
 } // namespace chip
diff --git a/src/app/clusters/ota-requestor/BDXDownloader.h b/src/app/clusters/ota-requestor/BDXDownloader.h
index d4c86d29736bd1..f7b9e2500885b3 100644
--- a/src/app/clusters/ota-requestor/BDXDownloader.h
+++ b/src/app/clusters/ota-requestor/BDXDownloader.h
@@ -33,6 +33,13 @@
 
 namespace chip {
 
+// Constants for BDX URI parsing
+constexpr uint8_t bdxPrefix[]         = { 'b', 'd', 'x', ':', '/', '/' };
+constexpr uint8_t bdxSeparator[]      = { '/' };
+constexpr uint8_t kValidBdxUriMinLen  = 24;
+constexpr uint8_t kNodeIdHexStringLen = 16;
+constexpr size_t kUriMaxLen           = 256;
+
 class BDXDownloader : public chip::OTADownloader
 {
 public:
@@ -65,6 +72,11 @@ class BDXDownloader : public chip::OTADownloader
     CHIP_ERROR FetchNextData() override;
     // TODO: override SkipData
 
+    /**
+     * Validate the URI and parse the BDX URI for various fields
+     */
+    CHIP_ERROR ParseBdxUri(CharSpan uri, NodeId & nodeId, MutableCharSpan fileDesignator);
+
 private:
     void PollTransferSession();
     CHIP_ERROR HandleBdxEvent(const chip::bdx::TransferSession::OutputEvent & outEvent);
diff --git a/src/app/clusters/ota-requestor/ClusterInterface.cpp b/src/app/clusters/ota-requestor/ClusterInterface.cpp
index 3637d9392951ff..599524aae87864 100644
--- a/src/app/clusters/ota-requestor/ClusterInterface.cpp
+++ b/src/app/clusters/ota-requestor/ClusterInterface.cpp
@@ -28,7 +28,7 @@ bool emberAfOtaSoftwareUpdateRequestorClusterAnnounceOtaProviderCallback(
     const chip::app::Clusters::OtaSoftwareUpdateRequestor::Commands::AnnounceOtaProvider::DecodableType & commandData)
 {
     EmberAfStatus status;
-    OTARequestorInterface * requestor = GetRequestorInstance();
+    chip::OTARequestorInterface * requestor = chip::GetRequestorInstance();
 
     if (requestor != nullptr)
     {
diff --git a/src/app/clusters/ota-requestor/OTARequestor.cpp b/src/app/clusters/ota-requestor/OTARequestor.cpp
index 224e974cb5ba77..703dfa7334f670 100644
--- a/src/app/clusters/ota-requestor/OTARequestor.cpp
+++ b/src/app/clusters/ota-requestor/OTARequestor.cpp
@@ -19,82 +19,69 @@
 /* This file contains the implementation of the OTARequestor class. All the core
  * OTA Requestor logic is contained in this class.
  */
-#include "OTARequestor.h"
 
-#include <app/server/Server.h>
-#include <app/util/util.h>
+#include <app-common/zap-generated/attributes/Accessors.h>
 #include <lib/core/CHIPEncoding.h>
-#include <lib/support/CodeUtils.h>
 #include <platform/CHIPDeviceLayer.h>
+#include <zap-generated/CHIPClusters.h>
 
 #include "BDXDownloader.h"
+#include "OTARequestor.h"
 
-#include <app-common/zap-generated/attributes/Accessors.h>
-#include <controller/CHIPDeviceControllerFactory.h>
-#include <controller/CommissioneeDeviceProxy.h>
-#include <controller/ExampleOperationalCredentialsIssuer.h>
+namespace chip {
 
-#include <zap-generated/CHIPClientCallbacks.h>
-#include <zap-generated/CHIPClusters.h>
+using namespace app::Clusters;
+using namespace app::Clusters::OtaSoftwareUpdateProvider::Commands;
+using namespace app::Clusters::OtaSoftwareUpdateRequestor::Commands;
+using bdx::TransferSession;
 
-using namespace chip;
-using namespace chip::app::Clusters;
-using namespace chip::bdx;
-using namespace chip::Messaging;
-using namespace chip::app::Clusters::OtaSoftwareUpdateProvider::Commands;
-
-namespace {
 // Global instance of the OTARequestorInterface.
 OTARequestorInterface * globalOTARequestorInstance = nullptr;
 
 constexpr uint32_t kImmediateStartDelayMs = 1; // Start the timer with this value when starting OTA "immediately"
 
-// Callbacks for connection management
-void OnConnected(void * context, chip::OperationalDeviceProxy * deviceProxy);
-Callback::Callback<OnDeviceConnected> mOnConnectedCallback(OnConnected, nullptr);
-
-void OnConnectionFailure(void * context, NodeId deviceId, CHIP_ERROR error);
-Callback::Callback<OnDeviceConnectionFailure> mOnConnectionFailureCallback(OnConnectionFailure, nullptr);
-
-void OnQueryImageResponse(void * context, const QueryImageResponse::DecodableType & response);
-void OnQueryImageFailure(void * context, EmberAfStatus status);
-
-void StartDelayTimerHandler(chip::System::Layer * systemLayer, void * appState)
+static void LogQueryImageResponse(const QueryImageResponse::DecodableType & response)
 {
-    VerifyOrReturn(appState != nullptr);
-    static_cast<OTARequestor *>(appState)->ConnectToProvider();
-}
-
-void OnQueryImageFailure(void * context, EmberAfStatus status)
-{
-    ChipLogDetail(SoftwareUpdate, "QueryImage failure response %" PRIu8, status);
-}
-
-// Called whenever FindOrEstablishSession is successful. Finds the Requestor instance
-// and calls the corresponding OTARequestor member function
-void OnConnected(void * context, chip::OperationalDeviceProxy * deviceProxy)
-{
-    OTARequestor * requestorCore = static_cast<OTARequestor *>(GetRequestorInstance());
-
-    VerifyOrDie(requestorCore != nullptr);
-
-    requestorCore->mOnConnected(context, deviceProxy);
+    ChipLogDetail(SoftwareUpdate, "QueryImageResponse:");
+    ChipLogDetail(SoftwareUpdate, "  status: %" PRIu8 "", response.status);
+    if (response.delayedActionTime.HasValue())
+    {
+        ChipLogDetail(SoftwareUpdate, "  delayedActionTime: %" PRIu32 " seconds", response.delayedActionTime.Value());
+    }
+    if (response.imageURI.HasValue())
+    {
+        ChipLogDetail(SoftwareUpdate, "  imageURI: %.*s", static_cast<int>(response.imageURI.Value().size()),
+                      response.imageURI.Value().data());
+    }
+    if (response.softwareVersion.HasValue())
+    {
+        ChipLogDetail(SoftwareUpdate, "  softwareVersion: %" PRIu32 "", response.softwareVersion.Value());
+    }
+    if (response.softwareVersionString.HasValue())
+    {
+        ChipLogDetail(SoftwareUpdate, "  softwareVersionString: %.*s",
+                      static_cast<int>(response.softwareVersionString.Value().size()),
+                      response.softwareVersionString.Value().data());
+    }
+    if (response.updateToken.HasValue())
+    {
+        ChipLogDetail(SoftwareUpdate, "  updateToken: %zu", response.updateToken.Value().size());
+    }
+    if (response.userConsentNeeded.HasValue())
+    {
+        ChipLogDetail(SoftwareUpdate, "  userConsentNeeded: %d", response.userConsentNeeded.Value());
+    }
+    if (response.metadataForRequestor.HasValue())
+    {
+        ChipLogDetail(SoftwareUpdate, "  metadataForRequestor: %zu", response.metadataForRequestor.Value().size());
+    }
 }
 
-void OnConnectionFailure(void * context, NodeId deviceId, CHIP_ERROR error)
+void StartDelayTimerHandler(System::Layer * systemLayer, void * appState)
 {
-    ChipLogError(SoftwareUpdate, "failed to connect to 0x%" PRIX64 ": %" CHIP_ERROR_FORMAT, deviceId, error.Format());
-}
-// Finds the Requestor instance and calls the corresponding OTARequestor member function
-void OnQueryImageResponse(void * context, const QueryImageResponse::DecodableType & response)
-{
-    OTARequestor * requestorCore = static_cast<OTARequestor *>(GetRequestorInstance());
-
-    VerifyOrDie(requestorCore != nullptr);
-
-    requestorCore->mOnQueryImageResponse(context, response);
+    VerifyOrReturn(appState != nullptr);
+    static_cast<OTARequestor *>(appState)->ConnectToProvider(OTARequestor::kQueryImage);
 }
-} // namespace
 
 void SetRequestorInstance(OTARequestorInterface * instance)
 {
@@ -112,59 +99,55 @@ struct OTARequestor::QueryImageRequest
     QueryImage::Type args;
 };
 
-void OTARequestor::mOnQueryImageResponse(void * context, const QueryImageResponse::DecodableType & response)
+void OTARequestor::OnQueryImageResponse(void * context, const QueryImageResponse::DecodableType & response)
 {
-    ChipLogDetail(SoftwareUpdate, "QueryImageResponse responded with action %" PRIu8, response.status);
-
-    CHIP_ERROR err = CHIP_NO_ERROR;
-
-    // TODO: handle QueryImageResponse status types
-    if (response.status != EMBER_ZCL_OTA_QUERY_STATUS_UPDATE_AVAILABLE)
-    {
-        return;
-    }
-
-    VerifyOrReturn(mBdxDownloader != nullptr, ChipLogError(SoftwareUpdate, "downloader is null"));
+    LogQueryImageResponse(response);
 
-    // TODO: allow caller to provide their own OTADownloader instance and set BDX parameters
+    VerifyOrReturn(context != nullptr, ChipLogError(SoftwareUpdate, "Received QueryImageResponse with invalid context"));
 
-    TransferSession::TransferInitData initOptions;
-    initOptions.TransferCtlFlags = chip::bdx::TransferControlFlags::kReceiverDrive;
-    initOptions.MaxBlockSize     = 1024;
-    char testFileDes[9]          = { "test.txt" };
-    initOptions.FileDesLength    = static_cast<uint16_t>(strlen(testFileDes));
-    initOptions.FileDesignator   = reinterpret_cast<uint8_t *>(testFileDes);
+    OTARequestor * requestorCore = static_cast<OTARequestor *>(context);
 
-    chip::OperationalDeviceProxy * operationalDeviceProxy = Server::GetInstance().GetOperationalDeviceProxy();
-    if (operationalDeviceProxy != nullptr)
+    switch (response.status)
     {
-        chip::Messaging::ExchangeManager * exchangeMgr = operationalDeviceProxy->GetExchangeManager();
-        chip::Optional<chip::SessionHandle> session    = operationalDeviceProxy->GetSecureSession();
-        if (exchangeMgr != nullptr && session.HasValue())
-        {
-            exchangeCtx = exchangeMgr->NewContext(session.Value(), &mBdxMessenger);
-        }
-
-        if (exchangeCtx == nullptr)
-        {
-            ChipLogError(BDX, "unable to allocate ec: exchangeMgr=%p sessionExists? %u", exchangeMgr, session.HasValue());
-            return;
-        }
+    case EMBER_ZCL_OTA_QUERY_STATUS_UPDATE_AVAILABLE: {
+        // TODO: Add a method to OTARequestorDriver used to report error condictions
+        VerifyOrReturn(response.imageURI.HasValue(), ChipLogError(SoftwareUpdate, "Update is available but no image URI present"));
+
+        // Parse out the provider node ID and file designator from the image URI
+        NodeId nodeId                         = kUndefinedNodeId;
+        char fileDesignatorBuffer[kUriMaxLen] = { 0 };
+        MutableCharSpan fileDesignator(fileDesignatorBuffer, kUriMaxLen);
+        CHIP_ERROR err = requestorCore->mBdxDownloader->ParseBdxUri(response.imageURI.Value(), nodeId, fileDesignator);
+        VerifyOrReturn(err == CHIP_NO_ERROR,
+                       ChipLogError(SoftwareUpdate, "Parse BDX image URI (%.*s) returned err=%" CHIP_ERROR_FORMAT,
+                                    static_cast<int>(response.imageURI.Value().size()), response.imageURI.Value().data(),
+                                    err.Format()));
+        requestorCore->mProviderNodeId = nodeId;
+
+        // CSM should already be created for sending QueryImage command so use the same CSM since the
+        // provider node ID that will supply the OTA image must be on the same fabric as the sender of the QueryImageResponse
+        requestorCore->ConnectToProvider(kStartBDX);
+        break;
     }
+    case EMBER_ZCL_OTA_QUERY_STATUS_BUSY:
+        break;
+    case EMBER_ZCL_OTA_QUERY_STATUS_NOT_AVAILABLE:
+        break;
+    // TODO: Add download protocol not supported
+    // Issue #9524 should handle all response status appropriately
+    default:
+        break;
+    }
+}
 
-    mBdxMessenger.Init(mBdxDownloader, exchangeCtx);
-    mBdxDownloader->SetMessageDelegate(&mBdxMessenger);
-    err = mBdxDownloader->SetBDXParams(initOptions);
-    VerifyOrReturn(err == CHIP_NO_ERROR,
-                   ChipLogError(SoftwareUpdate, "Error init BDXDownloader: %" CHIP_ERROR_FORMAT, err.Format()));
-    err = mBdxDownloader->BeginPrepareDownload();
-    VerifyOrReturn(err == CHIP_NO_ERROR,
-                   ChipLogError(SoftwareUpdate, "Error init BDXDownloader: %" CHIP_ERROR_FORMAT, err.Format()));
+void OTARequestor::OnQueryImageFailure(void * context, EmberAfStatus status)
+{
+    ChipLogDetail(SoftwareUpdate, "QueryImage failure response %" PRIu8, status);
 }
 
-EmberAfStatus OTARequestor::HandleAnnounceOTAProvider(
-    chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
-    const chip::app::Clusters::OtaSoftwareUpdateRequestor::Commands::AnnounceOtaProvider::DecodableType & commandData)
+EmberAfStatus OTARequestor::HandleAnnounceOTAProvider(app::CommandHandler * commandObj,
+                                                      const app::ConcreteCommandPath & commandPath,
+                                                      const AnnounceOtaProvider::DecodableType & commandData)
 {
     auto & providerLocation   = commandData.providerLocation;
     auto & announcementReason = commandData.announcementReason;
@@ -205,12 +188,12 @@ EmberAfStatus OTARequestor::HandleAnnounceOTAProvider(
         return EMBER_ZCL_STATUS_FAILURE;
     }
 
-    chip::DeviceLayer::SystemLayer().StartTimer(chip::System::Clock::Milliseconds32(msToStart), StartDelayTimerHandler, this);
+    DeviceLayer::SystemLayer().StartTimer(System::Clock::Milliseconds32(msToStart), StartDelayTimerHandler, this);
 
     return EMBER_ZCL_STATUS_SUCCESS;
 }
 
-CHIP_ERROR OTARequestor::SetupCASESessionManager(chip::FabricIndex fabricIndex)
+CHIP_ERROR OTARequestor::SetupCASESessionManager(FabricIndex fabricIndex)
 {
     // A previous CASE session had been established
     if (mCASESessionManager != nullptr)
@@ -218,7 +201,7 @@ CHIP_ERROR OTARequestor::SetupCASESessionManager(chip::FabricIndex fabricIndex)
         if (mCASESessionManager->GetFabricInfo()->GetFabricIndex() != fabricIndex)
         {
             // CSM is per fabric so if fabric index does not match the previous session, CSM needs to be set up again
-            chip::Platform::Delete(mCASESessionManager);
+            Platform::Delete(mCASESessionManager);
             mCASESessionManager = nullptr;
         }
         else
@@ -231,29 +214,30 @@ CHIP_ERROR OTARequestor::SetupCASESessionManager(chip::FabricIndex fabricIndex)
     // CSM has not been setup so create a new instance of it
     if (mCASESessionManager == nullptr)
     {
-        chip::Server * server         = &(chip::Server::GetInstance());
-        chip::FabricInfo * fabricInfo = server->GetFabricTable().FindFabricWithIndex(fabricIndex);
+        FabricInfo * fabricInfo = mServer->GetFabricTable().FindFabricWithIndex(fabricIndex);
         if (fabricInfo == nullptr)
         {
             ChipLogError(SoftwareUpdate, "Did not find fabric for index %d", fabricIndex);
             return CHIP_ERROR_INVALID_ARGUMENT;
         }
 
-        chip::DeviceProxyInitParams initParams = {
-            .sessionManager = &(server->GetSecureSessionManager()),
-            .exchangeMgr    = &(server->GetExchangeManager()),
-            .idAllocator    = &(server->GetSessionIDAllocator()),
+        DeviceProxyInitParams initParams = {
+            .sessionManager = &(mServer->GetSecureSessionManager()),
+            .exchangeMgr    = &(mServer->GetExchangeManager()),
+            .idAllocator    = &(mServer->GetSessionIDAllocator()),
             .fabricInfo     = fabricInfo,
+            .clientPool     = mServer->GetCASEClientPool(),
             // TODO: Determine where this should be instantiated
-            .imDelegate = chip::Platform::New<chip::Controller::DeviceControllerInteractionModelDelegate>(),
+            .imDelegate = Platform::New<Controller::DeviceControllerInteractionModelDelegate>(),
         };
 
-        chip::CASESessionManagerConfig sessionManagerConfig = {
+        CASESessionManagerConfig sessionManagerConfig = {
             .sessionInitParams = initParams,
             .dnsCache          = nullptr,
+            .devicePool        = mServer->GetDevicePool(),
         };
 
-        mCASESessionManager = chip::Platform::New<chip::CASESessionManager>(sessionManagerConfig);
+        mCASESessionManager = Platform::New<CASESessionManager>(sessionManagerConfig);
     }
 
     if (mCASESessionManager == nullptr)
@@ -265,80 +249,54 @@ CHIP_ERROR OTARequestor::SetupCASESessionManager(chip::FabricIndex fabricIndex)
     return CHIP_NO_ERROR;
 }
 
-// Converted from SendQueryImageCommand()
-void OTARequestor::ConnectToProvider()
+void OTARequestor::ConnectToProvider(OnConnectedAction onConnectedAction)
 {
-    chip::NodeId peerNodeId           = mProviderNodeId;
-    chip::FabricIndex peerFabricIndex = mProviderFabricIndex;
-
-    Server * server           = &(Server::GetInstance());
-    chip::FabricInfo * fabric = server->GetFabricTable().FindFabricWithIndex(peerFabricIndex);
-    if (fabric == nullptr)
-    {
-        ChipLogError(SoftwareUpdate, "Did not find fabric for index %d", peerFabricIndex);
-        return;
-    }
-
-    chip::DeviceProxyInitParams initParams = {
-        .sessionManager = &(server->GetSecureSessionManager()),
-        .exchangeMgr    = &(server->GetExchangeManager()),
-        .idAllocator    = &(server->GetSessionIDAllocator()),
-        .fabricInfo     = fabric,
-        // TODO: Determine where this should be instantiated
-        .imDelegate = chip::Platform::New<chip::Controller::DeviceControllerInteractionModelDelegate>(),
-    };
-
-    chip::OperationalDeviceProxy * operationalDeviceProxy =
-        chip::Platform::New<chip::OperationalDeviceProxy>(initParams, fabric->GetPeerIdForNode(peerNodeId));
-    if (operationalDeviceProxy == nullptr)
-    {
-        ChipLogError(SoftwareUpdate, "Failed in creating an instance of OperationalDeviceProxy");
-        return;
-    }
-
-    server->SetOperationalDeviceProxy(operationalDeviceProxy);
+    CHIP_ERROR err = SetupCASESessionManager(mProviderFabricIndex);
+    VerifyOrReturn(err == CHIP_NO_ERROR,
+                   ChipLogError(SoftwareUpdate, "Cannot setup CASESessionManager: %" CHIP_ERROR_FORMAT, err.Format()));
 
-    // Explicitly calling UpdateDeviceData() should not be needed once OperationalDeviceProxy can resolve IP address from node ID
-    // and fabric index
-    Transport::PeerAddress addr = Transport::PeerAddress::UDP(mIpAddress, CHIP_PORT);
-    operationalDeviceProxy->UpdateDeviceData(addr, operationalDeviceProxy->GetMRPConfig());
+    // Set the action to take once connection is successfully established
+    mOnConnectedAction = onConnectedAction;
 
-    CHIP_ERROR err = operationalDeviceProxy->Connect(&mOnConnectedCallback, &mOnConnectionFailureCallback);
-    if (err != CHIP_NO_ERROR)
-    {
-        ChipLogError(SoftwareUpdate, "Cannot establish connection to peer device: %" CHIP_ERROR_FORMAT, err.Format());
-    }
+    ChipLogDetail(SoftwareUpdate, "Establishing session to provider node ID 0x" ChipLogFormatX64 " on fabric index %d",
+                  ChipLogValueX64(mProviderNodeId), mProviderFabricIndex);
+    err = mCASESessionManager->FindOrEstablishSession(mProviderNodeId, &mOnConnectedCallback, &mOnConnectionFailureCallback);
+    VerifyOrReturn(err == CHIP_NO_ERROR,
+                   ChipLogError(SoftwareUpdate, "Cannot establish connection to provider: %" CHIP_ERROR_FORMAT, err.Format()));
 }
 
-// Member function called whenever FindOrEstablishSession is successful
-void OTARequestor::mOnConnected(void * context, chip::DeviceProxy * deviceProxy)
+// Called whenever FindOrEstablishSession is successful
+void OTARequestor::OnConnected(void * context, OperationalDeviceProxy * deviceProxy)
 {
-    switch (onConnectedState)
+    VerifyOrReturn(context != nullptr, ChipLogError(SoftwareUpdate, "Successfully established session but context is invalid"));
+    OTARequestor * requestorCore = static_cast<OTARequestor *>(context);
+
+    switch (requestorCore->mOnConnectedAction)
     {
     case kQueryImage: {
         constexpr EndpointId kOtaProviderEndpoint = 0;
 
         QueryImageRequest request;
-        CHIP_ERROR err = BuildQueryImageRequest(request);
+        CHIP_ERROR err = requestorCore->BuildQueryImageRequest(request);
         VerifyOrReturn(err == CHIP_NO_ERROR,
                        ChipLogError(SoftwareUpdate, "Failed to build QueryImage command: %" CHIP_ERROR_FORMAT, err.Format()));
 
         Controller::OtaSoftwareUpdateProviderCluster cluster;
         cluster.Associate(deviceProxy, kOtaProviderEndpoint);
 
-        err = cluster.InvokeCommand(request.args, /* context = */ nullptr, OnQueryImageResponse, OnQueryImageFailure);
+        err = cluster.InvokeCommand(request.args, requestorCore, OnQueryImageResponse, OnQueryImageFailure);
         VerifyOrReturn(err == CHIP_NO_ERROR,
                        ChipLogError(SoftwareUpdate, "Failed to send QueryImage command: %" CHIP_ERROR_FORMAT, err.Format()));
 
         break;
     }
     case kStartBDX: {
-        VerifyOrReturn(mBdxDownloader != nullptr, ChipLogError(SoftwareUpdate, "downloader is null"));
+        VerifyOrReturn(requestorCore->mBdxDownloader != nullptr, ChipLogError(SoftwareUpdate, "Downloader is null"));
 
         // TODO: allow caller to provide their own OTADownloader instance and set BDX parameters
 
         TransferSession::TransferInitData initOptions;
-        initOptions.TransferCtlFlags = chip::bdx::TransferControlFlags::kReceiverDrive;
+        initOptions.TransferCtlFlags = bdx::TransferControlFlags::kReceiverDrive;
         initOptions.MaxBlockSize     = 1024;
         char testFileDes[9]          = { "test.txt" };
         initOptions.FileDesLength    = static_cast<uint16_t>(strlen(testFileDes));
@@ -347,27 +305,37 @@ void OTARequestor::mOnConnected(void * context, chip::DeviceProxy * deviceProxy)
         if (deviceProxy != nullptr)
         {
             chip::Messaging::ExchangeManager * exchangeMgr = deviceProxy->GetExchangeManager();
-            chip::Optional<chip::SessionHandle> session    = deviceProxy->GetSecureSession();
-            if (exchangeMgr != nullptr && session.HasValue())
+            if (exchangeMgr == nullptr)
             {
-                exchangeCtx = exchangeMgr->NewContext(session.Value(), &mBdxMessenger);
+                ChipLogError(SoftwareUpdate, "Cannot retrieve exchange manager from device");
+                return;
             }
 
-            if (exchangeCtx == nullptr)
+            Optional<SessionHandle> session = deviceProxy->GetSecureSession();
+            if (!session.HasValue())
             {
-                ChipLogError(BDX, "unable to allocate ec: exchangeMgr=%p sessionExists? %u", exchangeMgr, session.HasValue());
+                ChipLogError(SoftwareUpdate, "Cannot retrieve session from device");
+                return;
+            }
+
+            requestorCore->mExchangeCtx = exchangeMgr->NewContext(session.Value(), &requestorCore->mBdxMessenger);
+
+            if (requestorCore->mExchangeCtx == nullptr)
+            {
+                ChipLogError(BDX, "Unable to allocate ec: exchangeMgr=%p sessionExists? %u, OTA progress cannot continue",
+                             exchangeMgr, session.HasValue());
                 return;
             }
         }
 
-        mBdxMessenger.Init(mBdxDownloader, exchangeCtx);
-        mBdxDownloader->SetMessageDelegate(&mBdxMessenger);
-        CHIP_ERROR err = mBdxDownloader->SetBDXParams(initOptions);
+        requestorCore->mBdxMessenger.Init(requestorCore->mBdxDownloader, requestorCore->mExchangeCtx);
+        requestorCore->mBdxDownloader->SetMessageDelegate(&requestorCore->mBdxMessenger);
+        CHIP_ERROR err = requestorCore->mBdxDownloader->SetBDXParams(initOptions);
         VerifyOrReturn(err == CHIP_NO_ERROR,
                        ChipLogError(SoftwareUpdate, "Error init BDXDownloader: %" CHIP_ERROR_FORMAT, err.Format()));
-        err = mBdxDownloader->BeginPrepareDownload();
+        err = requestorCore->mBdxDownloader->BeginPrepareDownload();
         VerifyOrReturn(err == CHIP_NO_ERROR,
-                       ChipLogError(SoftwareUpdate, "Error init BDXDownloader: %" CHIP_ERROR_FORMAT, err.Format()));
+                       ChipLogError(SoftwareUpdate, "Cannot begin prepare download: %" CHIP_ERROR_FORMAT, err.Format()));
         break;
     }
     default:
@@ -375,10 +343,15 @@ void OTARequestor::mOnConnected(void * context, chip::DeviceProxy * deviceProxy)
     }
 }
 
+// Called whenever FindOrEstablishSession fails
+void OTARequestor::OnConnectionFailure(void * context, NodeId deviceId, CHIP_ERROR error)
+{
+    ChipLogError(SoftwareUpdate, "Failed to connect to node 0x%" PRIX64 ": %" CHIP_ERROR_FORMAT, deviceId, error.Format());
+}
+
 void OTARequestor::TriggerImmediateQuery()
 {
-    // Perhaps we don't need a separate function ConnectToProvider, revisit this
-    ConnectToProvider();
+    ConnectToProvider(kQueryImage);
 }
 
 CHIP_ERROR OTARequestor::BuildQueryImageRequest(QueryImageRequest & request)
@@ -414,3 +387,5 @@ CHIP_ERROR OTARequestor::BuildQueryImageRequest(QueryImageRequest & request)
 
     return CHIP_NO_ERROR;
 }
+
+} // namespace chip
diff --git a/src/app/clusters/ota-requestor/OTARequestor.h b/src/app/clusters/ota-requestor/OTARequestor.h
index 5f028a5ea8dbae..77eb0dcd9163e5 100644
--- a/src/app/clusters/ota-requestor/OTARequestor.h
+++ b/src/app/clusters/ota-requestor/OTARequestor.h
@@ -22,16 +22,29 @@
 
 #pragma once
 
+#include <app/CASESessionManager.h>
+#include <app/server/Server.h>
+#include <protocols/bdx/BdxMessages.h>
+
 #include "BDXDownloader.h"
 #include "OTARequestorDriver.h"
 #include "OTARequestorInterface.h"
-#include <app/CASESessionManager.h>
-#include <protocols/bdx/BdxMessages.h>
+
+namespace chip {
 
 // This class implements all of the core logic of the OTA Requestor
 class OTARequestor : public OTARequestorInterface
 {
 public:
+    // Various actions to take when OnConnected callback is called
+    enum OnConnectedAction
+    {
+        kQueryImage = 0,
+        kStartBDX,
+    };
+
+    OTARequestor() : mOnConnectedCallback(OnConnected, this), mOnConnectionFailureCallback(OnConnectionFailure, this) {}
+
     // Application interface declarations -- start
 
     // Application directs the Requestor to start the Image Query process
@@ -55,36 +68,36 @@ class OTARequestor : public OTARequestorInterface
     // Virtual functions from OTARequestorInterface start
     // Handler for the AnnounceOTAProvider command
     EmberAfStatus HandleAnnounceOTAProvider(
-        chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
-        const chip::app::Clusters::OtaSoftwareUpdateRequestor::Commands::AnnounceOtaProvider::DecodableType & commandData);
+        app::CommandHandler * commandObj, const app::ConcreteCommandPath & commandPath,
+        const app::Clusters::OtaSoftwareUpdateRequestor::Commands::AnnounceOtaProvider::DecodableType & commandData);
 
     // Virtual functions from OTARequestorInterface -- end
-    void ConnectToProvider();
-
-    void mOnConnected(void * context, chip::DeviceProxy * deviceProxy);
-    void mOnQueryImageResponse(
-        void * context,
-        const chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImageResponse::DecodableType & response);
 
-    // When the Requestor is used as a test tool (Tesm Mode) the Provider parameters may be supplied explicitly
-    void TestModeSetProviderParameters(chip::NodeId NodeId, chip::FabricIndex FabIndex)
+    /**
+     * Called to set the server instance which used to get access to the system resources necessary to open CASE sessions and drive
+     * BDX transfers
+     */
+    void SetServerInstance(Server * server) { mServer = server; }
+
+    /**
+     * Called to establish a session to mProviderNodeId on mProviderFabricIndex. This must be called from the same externally
+     * synchronized context as any other Matter stack method.
+     *
+     * @param onConnectedAction  The action to take once session to provider has been established
+     */
+    void ConnectToProvider(OnConnectedAction onConnectedAction);
+
+    /**
+     * Called to indicate test mode. This is when the Requestor is used as a test tool and the the provider parameters are supplied
+     * explicitly.
+     */
+    void TestModeSetProviderParameters(NodeId nodeId, FabricIndex fabIndex)
     {
-        mProviderNodeId      = NodeId;
-        mProviderFabricIndex = FabIndex;
+        mProviderNodeId      = nodeId;
+        mProviderFabricIndex = fabIndex;
     }
 
-    // Temporary until IP address resolution is implemented in the Exchange Layer
-    void SetIpAddress(chip::Inet::IPAddress IpAddress) { mIpAddress = IpAddress; }
-
 private:
-    // Enums
-    // Various cases for when OnConnected callback could be called
-    enum OnConnectedState
-    {
-        kQueryImage = 0,
-        kStartBDX,
-    };
-
     struct QueryImageRequest;
 
     // TODO: the application should define this, along with initializing the BDXDownloader
@@ -154,22 +167,42 @@ class OTARequestor : public OTARequestorInterface
         chip::BDXDownloader * mDownloader;
     };
 
-    // Variables
-    // TODO: align on variable naming standard
-    OTARequestorDriver * mOtaRequestorDriver;
-    chip::NodeId mProviderNodeId;
-    chip::FabricIndex mProviderFabricIndex;
-    uint32_t mOtaStartDelayMs                      = 0;
-    chip::CASESessionManager * mCASESessionManager = nullptr;
-    OnConnectedState onConnectedState              = kQueryImage;
-    chip::Messaging::ExchangeContext * exchangeCtx = nullptr;
-    chip::BDXDownloader * mBdxDownloader; // TODO: this should be OTADownloader
-    BDXMessenger mBdxMessenger;           // TODO: ideally this is held by the application
-
-    // TODO: Temporary until IP address resolution is implemented in the Exchange layer
-    chip::Inet::IPAddress mIpAddress;
-
-    // Functions
+    /**
+     * Setup CASESessionManager used to establish a session with the provider
+     */
     CHIP_ERROR SetupCASESessionManager(chip::FabricIndex fabricIndex);
+
+    /**
+     * Create a QueryImage request using values from the Basic cluster attributes
+     */
     CHIP_ERROR BuildQueryImageRequest(QueryImageRequest & req);
+
+    /**
+     * Session connection callbacks
+     */
+    static void OnConnected(void * context, OperationalDeviceProxy * deviceProxy);
+    static void OnConnectionFailure(void * context, NodeId deviceId, CHIP_ERROR error);
+    Callback::Callback<OnDeviceConnected> mOnConnectedCallback;
+    Callback::Callback<OnDeviceConnectionFailure> mOnConnectionFailureCallback;
+
+    /**
+     * QueryImage callbacks
+     */
+    static void
+    OnQueryImageResponse(void * context,
+                         const app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImageResponse::DecodableType & response);
+    static void OnQueryImageFailure(void * context, EmberAfStatus status);
+
+    OTARequestorDriver * mOtaRequestorDriver  = nullptr;
+    NodeId mProviderNodeId                    = kUndefinedNodeId;
+    FabricIndex mProviderFabricIndex          = kUndefinedFabricIndex;
+    uint32_t mOtaStartDelayMs                 = 0;
+    CASESessionManager * mCASESessionManager  = nullptr;
+    OnConnectedAction mOnConnectedAction      = kQueryImage;
+    Messaging::ExchangeContext * mExchangeCtx = nullptr;
+    BDXDownloader * mBdxDownloader            = nullptr; // TODO: this should be OTADownloader
+    BDXMessenger mBdxMessenger;                          // TODO: ideally this is held by the application
+    Server * mServer = nullptr;
 };
+
+} // namespace chip
diff --git a/src/app/clusters/ota-requestor/OTARequestorInterface.h b/src/app/clusters/ota-requestor/OTARequestorInterface.h
index 240e9aa5c7926b..0af7452c51efe8 100644
--- a/src/app/clusters/ota-requestor/OTARequestorInterface.h
+++ b/src/app/clusters/ota-requestor/OTARequestorInterface.h
@@ -28,6 +28,8 @@
 
 #pragma once
 
+namespace chip {
+
 // Interface class to connect the OTA Software Update Requestor cluster command processing
 // with the core OTA Requestor logic. The OTARequestor class implements this interface
 class OTARequestorInterface
@@ -56,3 +58,5 @@ void SetRequestorInstance(OTARequestorInterface * instance);
 
 // Get the object implementing OTARequestorInterface
 OTARequestorInterface * GetRequestorInstance();
+
+} // namespace chip
diff --git a/src/app/server/Server.h b/src/app/server/Server.h
index f432832128fc21..d2d3ba80a044a2 100644
--- a/src/app/server/Server.h
+++ b/src/app/server/Server.h
@@ -17,7 +17,8 @@
 
 #pragma once
 
-#include <app/OperationalDeviceProxy.h>
+#include <app/CASEClientPool.h>
+#include <app/OperationalDeviceProxyPool.h>
 #include <app/server/AppDelegate.h>
 #include <app/server/CommissioningWindowManager.h>
 #include <credentials/FabricTable.h>
@@ -66,6 +67,14 @@ class Server
 
     FabricTable & GetFabricTable() { return mFabrics; }
 
+    CASEClientPoolDelegate * GetCASEClientPool() { return mCASEClientPool; }
+
+    void SetCASEClientPool(CASEClientPoolDelegate * clientPool) { mCASEClientPool = clientPool; }
+
+    OperationalDeviceProxyPoolDelegate * GetDevicePool() { return mDevicePool; }
+
+    void SetDevicePool(OperationalDeviceProxyPoolDelegate * devicePool) { mDevicePool = devicePool; }
+
     Messaging::ExchangeManager & GetExchangeManager() { return mExchangeMgr; }
 
     SessionIDAllocator & GetSessionIDAllocator() { return mSessionIDAllocator; }
@@ -74,13 +83,6 @@ class Server
 
     TransportMgrBase & GetTransportManager() { return mTransports; }
 
-    chip::OperationalDeviceProxy * GetOperationalDeviceProxy() { return mOperationalDeviceProxy; }
-
-    void SetOperationalDeviceProxy(chip::OperationalDeviceProxy * operationalDeviceProxy)
-    {
-        mOperationalDeviceProxy = operationalDeviceProxy;
-    }
-
 #if CONFIG_NETWORK_LAYER_BLE
     Ble::BleLayer * getBleLayerObject() { return mBleLayer; }
 #endif
@@ -139,6 +141,8 @@ class Server
     ServerTransportMgr mTransports;
     SessionManager mSessions;
     CASEServer mCASEServer;
+    CASEClientPoolDelegate * mCASEClientPool         = nullptr;
+    OperationalDeviceProxyPoolDelegate * mDevicePool = nullptr;
     Messaging::ExchangeManager mExchangeMgr;
     FabricTable mFabrics;
     SessionIDAllocator mSessionIDAllocator;
@@ -157,8 +161,6 @@ class Server
     TestPersistentStorageDelegate mGroupsStorage;
     Credentials::GroupDataProviderImpl mGroupsProvider;
 
-    chip::OperationalDeviceProxy * mOperationalDeviceProxy = nullptr;
-
     // TODO @ceille: Maybe use OperationalServicePort and CommissionableServicePort
     uint16_t mSecuredServicePort;
     uint16_t mUnsecuredServicePort;
diff --git a/src/lib/core/CHIPError.h b/src/lib/core/CHIPError.h
index 656d8a505ebad8..f2b60acf39f611 100644
--- a/src/lib/core/CHIPError.h
+++ b/src/lib/core/CHIPError.h
@@ -2332,6 +2332,22 @@ using CHIP_ERROR = ::chip::ChipError;
  *   the required elements
  */
 #define CHIP_ERROR_IM_MALFORMED_DATA_VERSION_FILTER_IB             CHIP_CORE_ERROR(0xd7)
+/**
+ * @def CHIP_ERROR_INVALID_SCHEME_PREFIX
+ *
+ * @brief
+ *   The scheme field contains an invalid prefix
+ */
+#define CHIP_ERROR_INVALID_SCHEME_PREFIX             CHIP_CORE_ERROR(0xd6)
+
+/**
+ * @def CHIP_ERROR_MISSING_URI_SEPARATOR
+ *
+ * @brief
+ *   The URI separator is missing
+ */
+#define CHIP_ERROR_MISSING_URI_SEPARATOR             CHIP_CORE_ERROR(0xd7)
+
 /**
  *  @}
  */