diff --git a/oem/ibm/libpldmresponder/file_io.cpp b/oem/ibm/libpldmresponder/file_io.cpp
index d0595e3..6b963d0 100644
--- a/oem/ibm/libpldmresponder/file_io.cpp
+++ b/oem/ibm/libpldmresponder/file_io.cpp
@@ -4,9 +4,9 @@
 
 #include "libpldm/base.h"
 
-#include "common/utils.hpp"
 #include "file_io_by_type.hpp"
 #include "file_table.hpp"
+#include "utils.hpp"
 #include "xyz/openbmc_project/Common/error.hpp"
 
 #include <fcntl.h>
@@ -22,7 +22,7 @@
 
 namespace pldm
 {
-
+using namespace pldm::responder::utils;
 using namespace sdbusplus::xyz::openbmc_project::Common::Error;
 
 namespace responder
@@ -49,6 +49,71 @@
 
 constexpr auto xdmaDev = "/dev/aspeed-xdma";
 
+int DMA::transferHostDataToSocket(int fd, uint32_t length, uint64_t address)
+{
+    static const size_t pageSize = getpagesize();
+    uint32_t numPages = length / pageSize;
+    uint32_t pageAlignedLength = numPages * pageSize;
+
+    if (length > pageAlignedLength)
+    {
+        pageAlignedLength += pageSize;
+    }
+
+    auto mmapCleanup = [pageAlignedLength](void* vgaMem) {
+        munmap(vgaMem, pageAlignedLength);
+    };
+
+    int dmaFd = -1;
+    int rc = 0;
+    dmaFd = open(xdmaDev, O_RDWR);
+    if (dmaFd < 0)
+    {
+        rc = -errno;
+        std::cerr << "Failed to open the XDMA device, RC=" << rc << "\n";
+        return rc;
+    }
+
+    pldm::utils::CustomFD xdmaFd(dmaFd);
+
+    void* vgaMem;
+    vgaMem =
+        mmap(nullptr, pageAlignedLength, PROT_READ, MAP_SHARED, xdmaFd(), 0);
+    if (MAP_FAILED == vgaMem)
+    {
+        rc = -errno;
+        std::cerr << "Failed to mmap the XDMA device, RC=" << rc << "\n";
+        return rc;
+    }
+
+    std::unique_ptr<void, decltype(mmapCleanup)> vgaMemPtr(vgaMem, mmapCleanup);
+
+    AspeedXdmaOp xdmaOp;
+    xdmaOp.upstream = 0;
+    xdmaOp.hostAddr = address;
+    xdmaOp.len = length;
+
+    rc = write(xdmaFd(), &xdmaOp, sizeof(xdmaOp));
+    if (rc < 0)
+    {
+        rc = -errno;
+        std::cerr << "Failed to execute the DMA operation, RC=" << rc
+                  << " ADDRESS=" << address << " LENGTH=" << length << "\n";
+        return rc;
+    }
+
+    rc = writeToUnixSocket(fd, static_cast<const char*>(vgaMemPtr.get()),
+                           length);
+    if (rc < 0)
+    {
+        rc = -errno;
+        close(fd);
+        std::cerr << "closing socket" << std::endl;
+        return rc;
+    }
+    return 0;
+}
+
 int DMA::transferDataHost(int fd, uint32_t offset, uint32_t length,
                           uint64_t address, bool upstream)
 {
diff --git a/oem/ibm/libpldmresponder/file_io.hpp b/oem/ibm/libpldmresponder/file_io.hpp
index aba70ba..771d038 100644
--- a/oem/ibm/libpldmresponder/file_io.hpp
+++ b/oem/ibm/libpldmresponder/file_io.hpp
@@ -58,6 +58,16 @@
      */
     int transferDataHost(int fd, uint32_t offset, uint32_t length,
                          uint64_t address, bool upstream);
+
+    /** @brief API to transfer data on to unix socket from host using DMA
+     *
+     * @param[in] path     - pathname of the file to transfer data from or to
+     * @param[in] length   - length of the data to transfer
+     * @param[in] address  - DMA address on the host
+     *
+     * @return returns 0 on success, negative errno on failure
+     */
+    int transferHostDataToSocket(int fd, uint32_t length, uint64_t address);
 };
 
 /** @brief Transfer the data between BMC and host using DMA.
diff --git a/oem/ibm/libpldmresponder/file_io_by_type.cpp b/oem/ibm/libpldmresponder/file_io_by_type.cpp
index d6367ba..43c2b91 100644
--- a/oem/ibm/libpldmresponder/file_io_by_type.cpp
+++ b/oem/ibm/libpldmresponder/file_io_by_type.cpp
@@ -51,6 +51,25 @@
     return rc < 0 ? PLDM_ERROR : PLDM_SUCCESS;
 }
 
+int FileHandler::transferFileDataToSocket(int32_t fd, uint32_t& length,
+                                          uint64_t address)
+{
+    dma::DMA xdmaInterface;
+    while (length > dma::maxSize)
+    {
+        auto rc =
+            xdmaInterface.transferHostDataToSocket(fd, dma::maxSize, address);
+        if (rc < 0)
+        {
+            return PLDM_ERROR;
+        }
+        length -= dma::maxSize;
+        address += dma::maxSize;
+    }
+    auto rc = xdmaInterface.transferHostDataToSocket(fd, length, address);
+    return rc < 0 ? PLDM_ERROR : PLDM_SUCCESS;
+}
+
 int FileHandler::transferFileData(const fs::path& path, bool upstream,
                                   uint32_t offset, uint32_t& length,
                                   uint64_t address)
diff --git a/oem/ibm/libpldmresponder/file_io_by_type.hpp b/oem/ibm/libpldmresponder/file_io_by_type.hpp
index 73f27d8..6bb87c6 100644
--- a/oem/ibm/libpldmresponder/file_io_by_type.hpp
+++ b/oem/ibm/libpldmresponder/file_io_by_type.hpp
@@ -98,6 +98,9 @@
     virtual int transferFileData(int fd, bool upstream, uint32_t offset,
                                  uint32_t& length, uint64_t address);
 
+    virtual int transferFileDataToSocket(int fd, uint32_t& length,
+                                         uint64_t address);
+
     /** @brief Constructor to create a FileHandler object
      */
     FileHandler(uint32_t fileHandle) : fileHandle(fileHandle)
diff --git a/oem/ibm/libpldmresponder/file_io_type_dump.cpp b/oem/ibm/libpldmresponder/file_io_type_dump.cpp
index 7fe4944..38647ab 100644
--- a/oem/ibm/libpldmresponder/file_io_type_dump.cpp
+++ b/oem/ibm/libpldmresponder/file_io_type_dump.cpp
@@ -4,6 +4,7 @@
 #include "oem/ibm/libpldm/file_io.h"
 
 #include "common/utils.hpp"
+#include "utils.hpp"
 #include "xyz/openbmc_project/Common/error.hpp"
 
 #include <stdint.h>
@@ -17,6 +18,7 @@
 #include <filesystem>
 #include <iostream>
 
+using namespace pldm::responder::utils;
 using namespace pldm::utils;
 
 namespace pldm
@@ -24,10 +26,8 @@
 namespace responder
 {
 
-static constexpr auto nbdInterfaceDefault = "/dev/nbd1";
 static constexpr auto dumpEntry = "xyz.openbmc_project.Dump.Entry";
 static constexpr auto dumpObjPath = "/xyz/openbmc_project/dump/system";
-
 int DumpHandler::fd = -1;
 
 static std::string findDumpObjPath(uint32_t fileHandle)
@@ -106,11 +106,13 @@
         return {};
     }
 
-    std::string nbdInterface{};
+    std::string socketInterface{};
+
     try
     {
-        nbdInterface = pldm::utils::DBusHandler().getDbusProperty<std::string>(
-            path.c_str(), "OffloadUri", dumpEntry);
+        socketInterface =
+            pldm::utils::DBusHandler().getDbusProperty<std::string>(
+                path.c_str(), "OffloadUri", dumpEntry);
     }
     catch (const std::exception& e)
     {
@@ -118,74 +120,45 @@
                   << e.what() << "\n";
     }
 
-    if (nbdInterface == "")
-    {
-        nbdInterface = nbdInterfaceDefault;
-    }
-
-    return nbdInterface;
+    return socketInterface;
 }
 
-int DumpHandler::writeFromMemory(uint32_t offset, uint32_t length,
-                                 uint64_t address)
+int DumpHandler::writeFromMemory(uint32_t, uint32_t length, uint64_t address)
 {
-    auto nbdInterface = getOffloadUri(fileHandle);
-    if (nbdInterface.empty())
-    {
-        return PLDM_ERROR;
-    }
-
-    int flags = O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE;
     if (DumpHandler::fd == -1)
     {
-        DumpHandler::fd = open(nbdInterface.c_str(), flags);
-        if (DumpHandler::fd == -1)
+        auto socketInterface = getOffloadUri(fileHandle);
+        int sock = setupUnixSocket(socketInterface);
+        if (sock < 0)
         {
-            std::cerr << "NBD file does not exist at " << nbdInterface
-                      << " ERROR=" << errno << "\n";
+            sock = -errno;
+            close(DumpHandler::fd);
+            std::cerr
+                << "DumpHandler::writeFromMemory: setupUnixSocket() failed"
+                << std::endl;
+            std::remove(socketInterface.c_str());
             return PLDM_ERROR;
         }
-    }
 
-    return transferFileData(DumpHandler::fd, false, offset, length, address);
+        DumpHandler::fd = sock;
+    }
+    return transferFileDataToSocket(DumpHandler::fd, length, address);
 }
 
-int DumpHandler::write(const char* buffer, uint32_t offset, uint32_t& length)
+int DumpHandler::write(const char* buffer, uint32_t, uint32_t& length)
 {
-    auto nbdInterface = getOffloadUri(fileHandle);
-    if (nbdInterface.empty())
+    int rc = writeToUnixSocket(DumpHandler::fd, buffer, length);
+    if (rc < 0)
     {
+        rc = -errno;
+        close(DumpHandler::fd);
+        auto socketInterface = getOffloadUri(fileHandle);
+        std::remove(socketInterface.c_str());
+        std::cerr << "DumpHandler::write: writeToUnixSocket() failed"
+                  << std::endl;
         return PLDM_ERROR;
     }
 
-    int flags = O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE;
-    if (DumpHandler::fd == -1)
-    {
-        DumpHandler::fd = open(nbdInterface.c_str(), flags);
-        if (DumpHandler::fd == -1)
-        {
-            std::cerr << "NBD file does not exist at " << nbdInterface
-                      << " ERROR=" << errno << "\n";
-            return PLDM_ERROR;
-        }
-    }
-
-    int rc = lseek(DumpHandler::fd, offset, SEEK_SET);
-    if (rc == -1)
-    {
-        std::cerr << "lseek failed, ERROR=" << errno << ", OFFSET=" << offset
-                  << "\n";
-        return PLDM_ERROR;
-    }
-    rc = ::write(DumpHandler::fd, buffer, length);
-    if (rc == -1)
-    {
-        std::cerr << "file write failed, ERROR=" << errno
-                  << ", LENGTH=" << length << ", OFFSET=" << offset << "\n";
-        return PLDM_ERROR;
-    }
-    length = rc;
-
     return PLDM_SUCCESS;
 }
 
@@ -208,7 +181,10 @@
                     << "failed to make a d-bus call to DUMP manager, ERROR="
                     << e.what() << "\n";
             }
+
             close(DumpHandler::fd);
+            auto socketInterface = getOffloadUri(fileHandle);
+            std::remove(socketInterface.c_str());
             DumpHandler::fd = -1;
             return PLDM_SUCCESS;
         }
diff --git a/oem/ibm/libpldmresponder/utils.cpp b/oem/ibm/libpldmresponder/utils.cpp
new file mode 100644
index 0000000..b8bbdf0
--- /dev/null
+++ b/oem/ibm/libpldmresponder/utils.cpp
@@ -0,0 +1,146 @@
+#include "utils.hpp"
+
+#include "libpldm/base.h"
+
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include <iostream>
+
+namespace pldm
+{
+namespace responder
+{
+namespace utils
+{
+
+int setupUnixSocket(const std::string& socketInterface)
+{
+    int sock;
+    struct sockaddr_un addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sun_family = AF_UNIX;
+    if (strnlen(socketInterface.c_str(), sizeof(addr.sun_path)) ==
+        sizeof(addr.sun_path))
+    {
+        std::cerr << "setupUnixSocket: UNIX socket path too long" << std::endl;
+        return -1;
+    }
+
+    strncpy(addr.sun_path, socketInterface.c_str(), sizeof(addr.sun_path) - 1);
+
+    if ((sock = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0)) == -1)
+    {
+        std::cerr << "setupUnixSocket: socket() call failed" << std::endl;
+        return -1;
+    }
+
+    if (bind(sock, (struct sockaddr*)&addr, sizeof(addr)) == -1)
+    {
+        std::cerr << "setupUnixSocket: bind() call failed" << std::endl;
+        close(sock);
+        return -1;
+    }
+
+    if (listen(sock, 1) == -1)
+    {
+        std::cerr << "setupUnixSocket: listen() call failed" << std::endl;
+        close(sock);
+        return -1;
+    }
+
+    fd_set rfd;
+    struct timeval tv;
+    tv.tv_sec = 1;
+    tv.tv_usec = 0;
+
+    FD_ZERO(&rfd);
+    FD_SET(sock, &rfd);
+    int nfd = sock + 1;
+    int fd;
+
+    int retval = select(nfd, &rfd, NULL, NULL, &tv);
+    if (retval < 0)
+    {
+        std::cerr << "setupUnixSocket: select call failed " << errno
+                  << std::endl;
+        close(sock);
+        return -1;
+    }
+
+    if ((retval > 0) && (FD_ISSET(sock, &rfd)))
+    {
+        fd = accept(sock, NULL, NULL);
+        if (fd < 0)
+        {
+            std::cerr << "setupUnixSocket: accept() call failed " << errno
+                      << std::endl;
+            close(sock);
+            return -1;
+        }
+        close(sock);
+    }
+    return fd;
+}
+
+int writeToUnixSocket(const int sock, const char* buf, const uint64_t blockSize)
+{
+    uint64_t i;
+    int nwrite = 0;
+
+    for (i = 0; i < blockSize; i = i + nwrite)
+    {
+
+        fd_set wfd;
+        struct timeval tv;
+        tv.tv_sec = 1;
+        tv.tv_usec = 0;
+
+        FD_ZERO(&wfd);
+        FD_SET(sock, &wfd);
+        int nfd = sock + 1;
+
+        int retval = select(nfd, NULL, &wfd, NULL, &tv);
+        if (retval < 0)
+        {
+            std::cerr << "writeToUnixSocket: select call failed " << errno
+                      << std::endl;
+            close(sock);
+            return -1;
+        }
+        if (retval == 0)
+        {
+            nwrite = 0;
+            continue;
+        }
+        if ((retval > 0) && (FD_ISSET(sock, &wfd)))
+        {
+            nwrite = write(sock, buf + i, blockSize - i);
+            if (nwrite < 0)
+            {
+                if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
+                {
+                    std::cerr << "writeToUnixSocket: Write call failed with "
+                                 "EAGAIN or EWOULDBLOCK or EINTR"
+                              << std::endl;
+                    nwrite = 0;
+                    continue;
+                }
+                std::cerr << "writeToUnixSocket: Failed to write" << std::endl;
+                close(sock);
+                return -1;
+            }
+        }
+        else
+        {
+            nwrite = 0;
+        }
+    }
+    return 0;
+}
+
+} // namespace utils
+} // namespace responder
+} // namespace pldm
diff --git a/oem/ibm/libpldmresponder/utils.hpp b/oem/ibm/libpldmresponder/utils.hpp
new file mode 100644
index 0000000..8f9ac47
--- /dev/null
+++ b/oem/ibm/libpldmresponder/utils.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <string>
+
+namespace pldm
+{
+namespace responder
+{
+namespace utils
+{
+
+/** @brief Setup UNIX socket
+ *  This function creates listening socket in non-blocking mode and allows only
+ *  one socket connection. returns accepted socket after accepting connection
+ *  from peer.
+ *
+ *  @param[in] socketInterface - unix socket path
+ *  @return   on success returns accepted socket fd
+ *            on failure returns -1
+ */
+int setupUnixSocket(const std::string& socketInterface);
+
+/** @brief Write data on UNIX socket
+ *  This function writes given data to a non-blocking socket.
+ *  Irrespective of block size, this function make sure of writing given data
+ *  on unix socket.
+ *
+ *  @param[in] sock - unix socket
+ *  @param[in] buf -  data buffer
+ *  @param[in] blockSize - size of data to write
+ *  @return   on success retruns  0
+ *            on failure returns -1
+
+ */
+int writeToUnixSocket(const int sock, const char* buf,
+                      const uint64_t blockSize);
+} // namespace utils
+} // namespace responder
+} // namespace pldm