diff --git a/oem/ibm/libpldmresponder/file_io.hpp b/oem/ibm/libpldmresponder/file_io.hpp
index 430811e..10c6d47 100644
--- a/oem/ibm/libpldmresponder/file_io.hpp
+++ b/oem/ibm/libpldmresponder/file_io.hpp
@@ -10,6 +10,7 @@
 #include "oem/ibm/requester/dbus_to_file_handler.hpp"
 #include "oem_ibm_handler.hpp"
 #include "pldmd/handler.hpp"
+#include "requester/handler.hpp"
 
 #include <fcntl.h>
 #include <stdint.h>
@@ -166,10 +167,11 @@
 {
   public:
     Handler(oem_platform::Handler* oemPlatformHandler, int hostSockFd,
-            uint8_t hostEid, dbus_api::Requester* dbusImplReqester) :
+            uint8_t hostEid, dbus_api::Requester* dbusImplReqester,
+            pldm::requester::Handler<pldm::requester::Request>* handler) :
         oemPlatformHandler(oemPlatformHandler),
         hostSockFd(hostSockFd), hostEid(hostEid),
-        dbusImplReqester(dbusImplReqester)
+        dbusImplReqester(dbusImplReqester), handler(handler)
     {
         handlers.emplace(PLDM_READ_FILE_INTO_MEMORY,
                          [this](const pldm_msg* request, size_t payloadLength) {
@@ -231,8 +233,8 @@
             pldm::utils::DBusHandler::getBus(),
             sdbusplus::bus::match::rules::interfacesAdded() +
                 sdbusplus::bus::match::rules::argNpath(0, dumpObjPath),
-            [hostSockFd, hostEid,
-             dbusImplReqester](sdbusplus::message::message& msg) {
+            [this, hostSockFd, hostEid, dbusImplReqester,
+             &handler](sdbusplus::message::message& msg) {
                 std::map<
                     std::string,
                     std::map<std::string, std::variant<std::string, uint32_t>>>
@@ -259,11 +261,13 @@
                                     std::get<std::string>(property.second);
                             }
                         }
-                        auto dbusToFileHandler = std::make_unique<
-                            pldm::requester::oem_ibm::DbusToFileHandler>(
-                            hostSockFd, hostEid, dbusImplReqester, path);
-                        dbusToFileHandler->processNewResourceDump(vspstring,
-                                                                  password);
+                        dbusToFileHandlers
+                            .emplace_back(
+                                std::make_unique<pldm::requester::oem_ibm::
+                                                     DbusToFileHandler>(
+                                    hostSockFd, hostEid, dbusImplReqester, path,
+                                    handler))
+                            ->processNewResourceDump(vspstring, password);
                         break;
                     }
                 }
@@ -272,8 +276,8 @@
             pldm::utils::DBusHandler::getBus(),
             sdbusplus::bus::match::rules::interfacesAdded() +
                 sdbusplus::bus::match::rules::argNpath(0, certObjPath),
-            [hostSockFd, hostEid,
-             dbusImplReqester](sdbusplus::message::message& msg) {
+            [this, hostSockFd, hostEid, dbusImplReqester,
+             &handler](sdbusplus::message::message& msg) {
                 std::map<
                     std::string,
                     std::map<std::string, std::variant<std::string, uint32_t>>>
@@ -295,13 +299,13 @@
                                     sdbusplus::message::object_path(path)
                                         .filename();
 
-                                auto dbusToFileHandler =
-                                    std::make_unique<pldm::requester::oem_ibm::
-                                                         DbusToFileHandler>(
+                                dbusToFileHandlers
+                                    .emplace_back(std::make_unique<
+                                                  pldm::requester::oem_ibm::
+                                                      DbusToFileHandler>(
                                         hostSockFd, hostEid, dbusImplReqester,
-                                        path);
-                                dbusToFileHandler->newCsrFileAvailable(
-                                    csr, fileHandle);
+                                        path, handler))
+                                    ->newCsrFileAvailable(csr, fileHandle);
                                 break;
                             }
                         }
@@ -416,12 +420,18 @@
     using DBusInterfaceAdded = std::vector<std::pair<
         std::string,
         std::vector<std::pair<std::string, std::variant<std::string>>>>>;
+    std::unique_ptr<pldm::requester::oem_ibm::DbusToFileHandler>
+        dbusToFileHandler; //!< pointer to send request to Host
     std::unique_ptr<sdbusplus::bus::match::match>
         resDumpMatcher; //!< Pointer to capture the interface added signal
                         //!< for new resource dump
     std::unique_ptr<sdbusplus::bus::match::match>
         vmiCertMatcher; //!< Pointer to capture the interface added signal
                         //!< for new csr string
+    /** @brief PLDM request handler */
+    pldm::requester::Handler<pldm::requester::Request>* handler;
+    std::vector<std::unique_ptr<pldm::requester::oem_ibm::DbusToFileHandler>>
+        dbusToFileHandlers;
 };
 
 } // namespace oem_ibm
diff --git a/oem/ibm/libpldmresponder/oem_ibm_handler.cpp b/oem/ibm/libpldmresponder/oem_ibm_handler.cpp
index 7fa7570..9b64bd9 100644
--- a/oem/ibm/libpldmresponder/oem_ibm_handler.cpp
+++ b/oem/ibm/libpldmresponder/oem_ibm_handler.cpp
@@ -291,10 +291,8 @@
 }
 
 int pldm::responder::oem_ibm_platform::Handler::sendEventToHost(
-    std::vector<uint8_t>& requestMsg)
+    std::vector<uint8_t>& requestMsg, uint8_t instanceId)
 {
-    uint8_t* responseMsg = nullptr;
-    size_t responseMsgSize{};
     if (requestMsg.size())
     {
         std::ostringstream tempStream;
@@ -305,33 +303,29 @@
         }
         std::cout << tempStream.str() << std::endl;
     }
-
-    auto requesterRc =
-        pldm_send_recv(mctp_eid, mctp_fd, requestMsg.data(), requestMsg.size(),
-                       &responseMsg, &responseMsgSize);
-    std::unique_ptr<uint8_t, decltype(std::free)*> responseMsgPtr{responseMsg,
-                                                                  std::free};
-    if (requesterRc != PLDM_REQUESTER_SUCCESS)
+    auto oemPlatformEventMessageResponseHandler =
+        [](mctp_eid_t /*eid*/, const pldm_msg* response, size_t respMsgLen) {
+            uint8_t completionCode{};
+            uint8_t status{};
+            auto rc = decode_platform_event_message_resp(
+                response, respMsgLen, &completionCode, &status);
+            if (rc || completionCode)
+            {
+                std::cerr << "Failed to decode_platform_event_message_resp: "
+                          << " for code update event rc=" << rc
+                          << ", cc=" << static_cast<unsigned>(completionCode)
+                          << std::endl;
+            }
+        };
+    auto rc = handler->registerRequest(
+        mctp_eid, instanceId, PLDM_PLATFORM, PLDM_PLATFORM_EVENT_MESSAGE,
+        std::move(requestMsg),
+        std::move(oemPlatformEventMessageResponseHandler));
+    if (rc)
     {
-        std::cerr << "Failed to send message/receive response. RC = "
-                  << requesterRc << ", errno = " << errno
-                  << "for sending event to host \n";
-        return requesterRc;
+        std::cerr << "Failed to send BIOS attribute change event message \n";
     }
-    uint8_t completionCode{};
-    uint8_t status{};
-    auto responsePtr = reinterpret_cast<struct pldm_msg*>(responseMsgPtr.get());
-    auto rc = decode_platform_event_message_resp(
-        responsePtr, responseMsgSize - sizeof(pldm_msg_hdr), &completionCode,
-        &status);
 
-    if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
-    {
-        std::cerr << "Failure in decode platform event message response, rc= "
-                  << rc << " cc=" << static_cast<unsigned>(completionCode)
-                  << "\n";
-        return rc;
-    }
     return rc;
 }
 
@@ -376,15 +370,15 @@
     {
         std::cerr << "Failed to encode state sensor event, rc = " << rc
                   << std::endl;
+        requester.markFree(mctp_eid, instanceId);
         return;
     }
-    rc = sendEventToHost(requestMsg);
+    rc = sendEventToHost(requestMsg, instanceId);
     if (rc != PLDM_SUCCESS)
     {
         std::cerr << "Failed to send event to host: "
                   << "rc=" << rc << std::endl;
     }
-    requester.markFree(mctp_eid, instanceId);
     return;
 }
 
diff --git a/oem/ibm/libpldmresponder/oem_ibm_handler.hpp b/oem/ibm/libpldmresponder/oem_ibm_handler.hpp
index ee1081e..a713980 100644
--- a/oem/ibm/libpldmresponder/oem_ibm_handler.hpp
+++ b/oem/ibm/libpldmresponder/oem_ibm_handler.hpp
@@ -6,6 +6,7 @@
 #include "libpldmresponder/oem_handler.hpp"
 #include "libpldmresponder/pdr_utils.hpp"
 #include "libpldmresponder/platform.hpp"
+#include "requester/handler.hpp"
 
 namespace pldm
 {
@@ -51,10 +52,11 @@
   public:
     Handler(const pldm::utils::DBusHandler* dBusIntf,
             pldm::responder::CodeUpdate* codeUpdate, int mctp_fd,
-            uint8_t mctp_eid, Requester& requester, sdeventplus::Event& event) :
+            uint8_t mctp_eid, Requester& requester, sdeventplus::Event& event,
+            pldm::requester::Handler<pldm::requester::Request>* handler) :
         oem_platform::Handler(dBusIntf),
         codeUpdate(codeUpdate), platformHandler(nullptr), mctp_fd(mctp_fd),
-        mctp_eid(mctp_eid), requester(requester), event(event)
+        mctp_eid(mctp_eid), requester(requester), event(event), handler(handler)
     {
         codeUpdate->setVersions();
     }
@@ -116,9 +118,10 @@
 
     /** @brief Method to send encoded request msg of code update event to host
      *  @param[in] requestMsg - encoded request msg
+     *  @param[in] instanceId - instance id of the message
      *  @return PLDM status code
      */
-    int sendEventToHost(std::vector<uint8_t>& requestMsg);
+    int sendEventToHost(std::vector<uint8_t>& requestMsg, uint8_t instanceId);
 
     /** @brief _processEndUpdate processes the actual work that needs
      *  to be carried out after EndUpdate effecter is set. This is done async
@@ -170,6 +173,9 @@
   private:
     /** @brief D-Bus property changed signal match for CurrentPowerState*/
     std::unique_ptr<sdbusplus::bus::match::match> chassisOffMatch;
+
+    /** @brief PLDM request handler */
+    pldm::requester::Handler<pldm::requester::Request>* handler;
 };
 
 /** @brief Method to encode code update event msg
diff --git a/oem/ibm/libpldmresponder/platform_oem_ibm.cpp b/oem/ibm/libpldmresponder/platform_oem_ibm.cpp
index d5c6528..0ae1adb 100644
--- a/oem/ibm/libpldmresponder/platform_oem_ibm.cpp
+++ b/oem/ibm/libpldmresponder/platform_oem_ibm.cpp
@@ -15,9 +15,10 @@
 namespace platform
 {
 
-int sendBiosAttributeUpdateEvent(int fd, uint8_t eid,
-                                 dbus_api::Requester* requester,
-                                 const std::vector<uint16_t>& handles)
+int sendBiosAttributeUpdateEvent(
+    uint8_t eid, dbus_api::Requester* requester,
+    const std::vector<uint16_t>& handles,
+    pldm::requester::Handler<pldm::requester::Request>* handler)
 {
     constexpr auto hostStatePath = "/xyz/openbmc_project/state/host0";
     constexpr auto hostStateInterface =
@@ -77,50 +78,40 @@
         std::cout << tempStream.str() << std::endl;
     }
 
-    uint8_t* responseMsg = nullptr;
-    size_t responseMsgSize{};
-
-    rc = pldm_send_recv(eid, fd, requestMsg.data(), requestMsg.size(),
-                        &responseMsg, &responseMsgSize);
-    std::unique_ptr<uint8_t, decltype(std::free)*> responseMsgPtr{responseMsg,
-                                                                  std::free};
-    requester->markFree(eid, instanceId);
-
-    if (rc != PLDM_REQUESTER_SUCCESS)
+    auto platformEventMessageResponseHandler = [](mctp_eid_t /*eid*/,
+                                                  const pldm_msg* response,
+                                                  size_t respMsgLen) {
+        if (response == nullptr || !respMsgLen)
+        {
+            std::cerr
+                << "Failed to receive response for platform event message \n";
+            return;
+        }
+        uint8_t completionCode{};
+        uint8_t status{};
+        auto rc = decode_platform_event_message_resp(response, respMsgLen,
+                                                     &completionCode, &status);
+        if (rc || completionCode)
+        {
+            std::cerr << "Failed to decode_platform_event_message_resp: "
+                      << "rc=" << rc
+                      << ", cc=" << static_cast<unsigned>(completionCode)
+                      << std::endl;
+        }
+    };
+    rc = handler->registerRequest(
+        eid, instanceId, PLDM_PLATFORM, PLDM_PLATFORM_EVENT_MESSAGE,
+        std::move(requestMsg), std::move(platformEventMessageResponseHandler));
+    if (rc)
     {
-        std::cerr << "Failed to send BIOS attribute update event. RC = " << rc
-                  << ", errno = " << errno << "\n";
-        pldm::utils::reportError(
-            "xyz.openbmc_project.bmc.pldm.InternalFailure");
-        return rc;
+        std::cerr << "Failed to send the platform event message \n";
     }
 
-    auto responsePtr = reinterpret_cast<struct pldm_msg*>(responseMsgPtr.get());
-    uint8_t completionCode{};
-    uint8_t status{};
-    rc = decode_platform_event_message_resp(
-        responsePtr, responseMsgSize - sizeof(pldm_msg_hdr), &completionCode,
-        &status);
-    if (rc != PLDM_SUCCESS)
-    {
-        std::cerr << "Failed to decode PlatformEventMessage response, rc = "
-                  << rc << "\n";
-        return rc;
-    }
-
-    if (completionCode != PLDM_SUCCESS)
-    {
-        std::cerr << "Failed to send the BIOS attribute update event, rc = "
-                  << (uint32_t)completionCode << "\n";
-        pldm::utils::reportError(
-            "xyz.openbmc_project.bmc.pldm.InternalFailure");
-    }
-
-    return completionCode;
+    return rc;
 }
 
 } // namespace platform
 
 } // namespace responder
 
-} // namespace pldm
\ No newline at end of file
+} // namespace pldm
diff --git a/oem/ibm/libpldmresponder/platform_oem_ibm.hpp b/oem/ibm/libpldmresponder/platform_oem_ibm.hpp
index 639f1d5..6f3a320 100644
--- a/oem/ibm/libpldmresponder/platform_oem_ibm.hpp
+++ b/oem/ibm/libpldmresponder/platform_oem_ibm.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "pldmd/dbus_impl_requester.hpp"
+#include "requester/handler.hpp"
 
 #include <vector>
 
@@ -18,14 +19,15 @@
  *  PLDM_EVENT_TYPE_OEM_EVENT_BIOS_ATTRIBUTE_UPDATE is send to host with the
  *  list of BIOS attribute handles.
  *
- *  @param[in] fd - socket descriptor to communicate to host
  *  @param[in] eid - MCTP EID of host firmware
  *  @param[in] requester - pointer to Requester object
  *  @param[in] handles - List of BIOS attribute handles
+ *  @param[in] handler - PLDM request handler
  */
-int sendBiosAttributeUpdateEvent(int fd, uint8_t eid,
-                                 dbus_api::Requester* requester,
-                                 const std::vector<uint16_t>& handles);
+int sendBiosAttributeUpdateEvent(
+    uint8_t eid, dbus_api::Requester* requester,
+    const std::vector<uint16_t>& handles,
+    pldm::requester::Handler<pldm::requester::Request>* handler);
 
 } // namespace platform
 
diff --git a/oem/ibm/requester/dbus_to_file_handler.cpp b/oem/ibm/requester/dbus_to_file_handler.cpp
index e256bc8..44eb5f7 100644
--- a/oem/ibm/requester/dbus_to_file_handler.cpp
+++ b/oem/ibm/requester/dbus_to_file_handler.cpp
@@ -25,10 +25,11 @@
 
 DbusToFileHandler::DbusToFileHandler(
     int mctp_fd, uint8_t mctp_eid, dbus_api::Requester* requester,
-    sdbusplus::message::object_path resDumpCurrentObjPath) :
+    sdbusplus::message::object_path resDumpCurrentObjPath,
+    pldm::requester::Handler<pldm::requester::Request>* handler) :
     mctp_fd(mctp_fd),
     mctp_eid(mctp_eid), requester(requester),
-    resDumpCurrentObjPath(resDumpCurrentObjPath)
+    resDumpCurrentObjPath(resDumpCurrentObjPath), handler(handler)
 {}
 
 void DbusToFileHandler::sendNewFileAvailableCmd(uint64_t fileSize)
@@ -58,60 +59,54 @@
         return;
     }
 
-    uint8_t* responseMsg = nullptr;
-    size_t responseMsgSize{};
-
-    auto requesterRc =
-        pldm_send_recv(mctp_eid, mctp_fd, requestMsg.data(), requestMsg.size(),
-                       &responseMsg, &responseMsgSize);
-
-    std::unique_ptr<uint8_t, decltype(std::free)*> responseMsgPtr{responseMsg,
-                                                                  std::free};
-
-    requester->markFree(mctp_eid, instanceId);
-    bool isDecodeNewFileRespFailed = false;
-    if (requesterRc != PLDM_REQUESTER_SUCCESS)
-    {
-        std::cerr << "Failed to send resource dump parameters, rc = "
-                  << requesterRc << std::endl;
-    }
-    else
-    {
+    auto newFileAvailableRespHandler = [this](mctp_eid_t /*eid*/,
+                                              const pldm_msg* response,
+                                              size_t respMsgLen) {
+        if (response == nullptr || !respMsgLen)
+        {
+            std::cerr
+                << "Failed to receive response for NewFileAvailable command \n";
+            return;
+        }
         uint8_t completionCode{};
-        auto responsePtr =
-            reinterpret_cast<struct pldm_msg*>(responseMsgPtr.get());
-
-        rc = decode_new_file_resp(responsePtr, PLDM_NEW_FILE_RESP_BYTES,
-                                  &completionCode);
-
-        if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
+        auto rc = decode_new_file_resp(response, respMsgLen, &completionCode);
+        if (rc || completionCode)
         {
-            std::cerr << "Failed to decode_new_file_resp: "
-                      << "rc=" << rc
+            std::cerr << "Failed to decode_new_file_resp or"
+                      << " Host returned error for new_file_available"
+                      << " rc=" << rc
                       << ", cc=" << static_cast<unsigned>(completionCode)
-                      << std::endl;
-            isDecodeNewFileRespFailed = true;
+                      << "\n";
+            reportResourceDumpFailure();
         }
-    }
-
-    if ((requesterRc != PLDM_REQUESTER_SUCCESS) || (isDecodeNewFileRespFailed))
+    };
+    rc = handler->registerRequest(
+        mctp_eid, instanceId, PLDM_OEM, PLDM_NEW_FILE_AVAILABLE,
+        std::move(requestMsg), std::move(newFileAvailableRespHandler));
+    if (rc)
     {
-        pldm::utils::reportError(
-            "xyz.openbmc_project.bmc.pldm.InternalFailure");
+        std::cerr << "Failed to send NewFileAvailable Request to Host \n";
+        reportResourceDumpFailure();
+    }
+}
 
-        PropertyValue value{resDumpStatus};
-        DBusMapping dbusMapping{resDumpCurrentObjPath, resDumpProgressIntf,
-                                "Status", "string"};
-        try
-        {
-            pldm::utils::DBusHandler().setDbusProperty(dbusMapping, value);
-        }
-        catch (const std::exception& e)
-        {
-            std::cerr << "failed to set resource dump operation status, "
-                         "ERROR="
-                      << e.what() << "\n";
-        }
+void DbusToFileHandler::reportResourceDumpFailure()
+{
+
+    pldm::utils::reportError("xyz.openbmc_project.bmc.pldm.InternalFailure");
+
+    PropertyValue value{resDumpStatus};
+    DBusMapping dbusMapping{resDumpCurrentObjPath, resDumpProgressIntf,
+                            "Status", "string"};
+    try
+    {
+        pldm::utils::DBusHandler().setDbusProperty(dbusMapping, value);
+    }
+    catch (const std::exception& e)
+    {
+        std::cerr << "failed to set resource dump operation status, "
+                     "ERROR="
+                  << e.what() << "\n";
     }
 }
 
@@ -249,48 +244,35 @@
         std::cerr << "Failed to encode_new_file_req, rc = " << rc << std::endl;
         return;
     }
-
-    uint8_t* responseMsg = nullptr;
-    size_t responseMsgSize{};
-
-    auto requesterRc =
-        pldm_send_recv(mctp_eid, mctp_fd, requestMsg.data(), requestMsg.size(),
-                       &responseMsg, &responseMsgSize);
-
-    std::unique_ptr<uint8_t, decltype(std::free)*> responseMsgPtr{responseMsg,
-                                                                  std::free};
-
-    requester->markFree(mctp_eid, instanceId);
-    bool isDecodeNewFileRespFailed = false;
-    if (requesterRc != PLDM_REQUESTER_SUCCESS)
-    {
-        std::cerr << "Failed to send file to host, rc = " << requesterRc
-                  << std::endl;
-    }
-    else
-    {
-        uint8_t completionCode{};
-        auto responsePtr =
-            reinterpret_cast<struct pldm_msg*>(responseMsgPtr.get());
-
-        rc = decode_new_file_resp(responsePtr, PLDM_NEW_FILE_RESP_BYTES,
-                                  &completionCode);
-
-        std::vector<uint8_t> responseMsgVec;
-        responseMsgVec.resize(responseMsgSize);
-        memcpy(responseMsgVec.data(), responseMsg, responseMsgVec.size());
-
-        if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
+    auto newFileAvailableRespHandler = [](mctp_eid_t /*eid*/,
+                                          const pldm_msg* response,
+                                          size_t respMsgLen) {
+        if (response == nullptr || !respMsgLen)
         {
-            std::cerr << "Failed to decode_new_file_resp: "
-                      << "rc=" << rc
-                      << ", cc=" << static_cast<unsigned>(completionCode)
-                      << std::endl;
-            isDecodeNewFileRespFailed = true;
+            std::cerr << "Failed to receive response for NewFileAvailable "
+                         "command for vmi \n";
+            return;
         }
-    }
-    if ((requesterRc != PLDM_REQUESTER_SUCCESS) || (isDecodeNewFileRespFailed))
+        uint8_t completionCode{};
+        auto rc = decode_new_file_resp(response, respMsgLen, &completionCode);
+        if (rc || completionCode)
+        {
+            std::cerr << "Failed to decode_new_file_resp for vmi, or"
+                      << " Host returned error for new_file_available"
+                      << " rc=" << rc
+                      << ", cc=" << static_cast<unsigned>(completionCode)
+                      << "\n";
+            pldm::utils::reportError(
+                "xyz.openbmc_project.bmc.pldm.InternalFailure");
+        }
+    };
+    rc = handler->registerRequest(
+        mctp_eid, instanceId, PLDM_OEM, PLDM_NEW_FILE_AVAILABLE,
+        std::move(requestMsg), std::move(newFileAvailableRespHandler));
+    if (rc)
     {
+        std::cerr
+            << "Failed to send NewFileAvailable Request to Host for vmi \n";
         pldm::utils::reportError(
             "xyz.openbmc_project.bmc.pldm.InternalFailure");
     }
diff --git a/oem/ibm/requester/dbus_to_file_handler.hpp b/oem/ibm/requester/dbus_to_file_handler.hpp
index bd7b3c6..739e864 100644
--- a/oem/ibm/requester/dbus_to_file_handler.hpp
+++ b/oem/ibm/requester/dbus_to_file_handler.hpp
@@ -3,6 +3,7 @@
 #include "libpldm/platform.h"
 
 #include "pldmd/dbus_impl_requester.hpp"
+#include "requester/handler.hpp"
 
 #include <filesystem>
 #include <fstream>
@@ -36,10 +37,12 @@
      *  @param[in] mctp_eid - MCTP EID of host firmware
      *  @param[in] requester - pointer to a Requester object
      *  @param[in] resDumpCurrentObjPath - resource dump current object path
+     *  @param[in] handler - PLDM request handler
      */
-    DbusToFileHandler(int mctp_fd, uint8_t mctp_eid,
-                      dbus_api::Requester* requester,
-                      sdbusplus::message::object_path resDumpCurrentObjPath);
+    DbusToFileHandler(
+        int mctp_fd, uint8_t mctp_eid, dbus_api::Requester* requester,
+        sdbusplus::message::object_path resDumpCurrentObjPath,
+        pldm::requester::Handler<pldm::requester::Request>* handler);
 
     /** @brief Process the new resource dump request
      *  @param[in] vspString - vsp string
@@ -70,6 +73,10 @@
                                     const uint32_t fileHandle,
                                     const uint16_t type);
 
+    /** @brief report failure that a resource dump has failed
+     */
+    void reportResourceDumpFailure();
+
     /** @brief fd of MCTP communications socket */
     int mctp_fd;
 
@@ -83,6 +90,9 @@
 
     /** @brief Hold the current resource dump object path */
     sdbusplus::message::object_path resDumpCurrentObjPath;
+
+    /** @brief PLDM request handler */
+    pldm::requester::Handler<pldm::requester::Request>* handler;
 };
 
 } // namespace oem_ibm
diff --git a/oem/ibm/test/libpldmresponder_fileio_test.cpp b/oem/ibm/test/libpldmresponder_fileio_test.cpp
index e7a5945..0c0492a 100644
--- a/oem/ibm/test/libpldmresponder_fileio_test.cpp
+++ b/oem/ibm/test/libpldmresponder_fileio_test.cpp
@@ -226,7 +226,7 @@
     // Pass invalid payload length
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.readFileIntoMemory(request, 0);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     ASSERT_EQ(responsePtr->payload[0], PLDM_ERROR_INVALID_LENGTH);
@@ -260,7 +260,7 @@
 
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.readFileIntoMemory(request, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     ASSERT_EQ(responsePtr->payload[0], PLDM_INVALID_FILE_HANDLE);
@@ -295,7 +295,7 @@
 
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.readFileIntoMemory(request, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     ASSERT_EQ(responsePtr->payload[0], PLDM_DATA_OUT_OF_RANGE);
@@ -330,7 +330,7 @@
 
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.readFileIntoMemory(request, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     ASSERT_EQ(responsePtr->payload[0], PLDM_ERROR_INVALID_LENGTH);
@@ -368,7 +368,7 @@
 
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.readFileIntoMemory(request, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     ASSERT_EQ(responsePtr->payload[0], PLDM_ERROR_INVALID_LENGTH);
@@ -400,7 +400,7 @@
     // Pass invalid payload length
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.writeFileFromMemory(request, 0);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     ASSERT_EQ(responsePtr->payload[0], PLDM_ERROR_INVALID_LENGTH);
@@ -439,7 +439,7 @@
 
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.writeFileFromMemory(request, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     ASSERT_EQ(responsePtr->payload[0], PLDM_INVALID_FILE_HANDLE);
@@ -475,7 +475,7 @@
 
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.writeFileFromMemory(request, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     ASSERT_EQ(responsePtr->payload[0], PLDM_DATA_OUT_OF_RANGE);
@@ -548,7 +548,7 @@
 
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.getFileTable(requestMsgPtr, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     ASSERT_EQ(responsePtr->payload[0], PLDM_SUCCESS);
@@ -575,7 +575,7 @@
     // Pass invalid command payload length
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.getFileTable(request, 0);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     ASSERT_EQ(responsePtr->payload[0], PLDM_ERROR_INVALID_LENGTH);
@@ -601,7 +601,7 @@
 
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.getFileTable(requestMsgPtr, requestPayloadLength);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     ASSERT_EQ(responsePtr->payload[0], PLDM_INVALID_FILE_TABLE_TYPE);
@@ -633,7 +633,7 @@
     // Invalid payload length
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.readFile(requestMsgPtr, 0);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     ASSERT_EQ(responsePtr->payload[0], PLDM_ERROR_INVALID_LENGTH);
@@ -687,7 +687,7 @@
 
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto responseMsg = handler.readFile(requestMsgPtr, payload_length);
     auto response = reinterpret_cast<pldm_read_file_resp*>(
         responseMsg.data() + sizeof(pldm_msg_hdr));
@@ -741,7 +741,7 @@
     // Invalid payload length
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.writeFile(requestMsgPtr, 0);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     ASSERT_EQ(responsePtr->payload[0], PLDM_ERROR_INVALID_LENGTH);
@@ -792,7 +792,7 @@
 
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto responseMsg = handler.writeFile(requestMsgPtr, payload_length);
     auto response = reinterpret_cast<pldm_read_file_resp*>(
         responseMsg.data() + sizeof(pldm_msg_hdr));
@@ -830,7 +830,7 @@
 
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.writeFileByTypeFromMemory(req, 0);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
 
@@ -910,7 +910,7 @@
 
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.readFileByTypeIntoMemory(req, 0);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     struct pldm_read_write_file_by_type_memory_resp* resp =
@@ -952,7 +952,7 @@
 
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
     oem_ibm::Handler handler(oemPlatformHandler.get(), hostSocketFd, host_eid,
-                             nullptr);
+                             nullptr, nullptr);
     auto response = handler.readFileByType(req, 0);
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     struct pldm_read_write_file_by_type_resp* resp =
diff --git a/oem/ibm/test/libpldmresponder_oem_platform_test.cpp b/oem/ibm/test/libpldmresponder_oem_platform_test.cpp
index aa986f4..8108713 100644
--- a/oem/ibm/test/libpldmresponder_oem_platform_test.cpp
+++ b/oem/ibm/test/libpldmresponder_oem_platform_test.cpp
@@ -37,7 +37,7 @@
                            uint8_t mctp_eid, Requester& requester,
                            sdeventplus::Event& event) :
         oem_ibm_platform::Handler(dBusIntf, codeUpdate, mctp_fd, mctp_eid,
-                                  requester, event)
+                                  requester, event, nullptr)
     {}
     MOCK_METHOD(uint16_t, getNextEffecterId, ());
     MOCK_METHOD(uint16_t, getNextSensorId, ());
@@ -61,8 +61,8 @@
     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
 
     oemPlatformHandler = std::make_unique<oem_ibm_platform::Handler>(
-        mockDbusHandler.get(), mockCodeUpdate.get(), 0x1, 0x9, requester,
-        event);
+        mockDbusHandler.get(), mockCodeUpdate.get(), 0x1, 0x9, requester, event,
+        nullptr);
 
     auto rc = oemPlatformHandler->getOemStateSensorReadingsHandler(
         entityID_, entityInstance_, stateSetId_, compSensorCnt_, stateField);