Refactor DMA function and add responder for WriteFileFromMemory command

The WriteFileFromMemory command transfers data to the BMC from the Host
using DMA. Refactor the DMA transfer function so that the code between
the read and write file commands is common.

Signed-off-by: Eddie James <eajames@us.ibm.com>
Change-Id: I1ce5739c312c4789b882bff04f0e686cc438ab52
diff --git a/test/libpldm_fileio_test.cpp b/test/libpldm_fileio_test.cpp
index 4968d39..2a5dce1 100644
--- a/test/libpldm_fileio_test.cpp
+++ b/test/libpldm_fileio_test.cpp
@@ -7,9 +7,9 @@
 
 #include <gtest/gtest.h>
 
-TEST(ReadFileIntoMemory, testGoodDecodeRequest)
+TEST(ReadWriteFileMemory, testGoodDecodeRequest)
 {
-    std::array<uint8_t, PLDM_READ_FILE_MEM_REQ_BYTES> requestMsg{};
+    std::array<uint8_t, PLDM_RW_FILE_MEM_REQ_BYTES> requestMsg{};
 
     // Random value for fileHandle, offset, length, address
     uint32_t fileHandle = 0x12345678;
@@ -31,9 +31,9 @@
     uint64_t retAddress = 0;
 
     // Invoke decode the read file memory request
-    auto rc = decode_read_file_memory_req(requestMsg.data(), requestMsg.size(),
-                                          &retFileHandle, &retOffset,
-                                          &retLength, &retAddress);
+    auto rc = decode_rw_file_memory_req(requestMsg.data(), requestMsg.size(),
+                                        &retFileHandle, &retOffset, &retLength,
+                                        &retAddress);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(fileHandle, retFileHandle);
@@ -42,7 +42,7 @@
     ASSERT_EQ(address, retAddress);
 }
 
-TEST(ReadFileIntoMemory, testBadDecodeRequest)
+TEST(ReadWriteFileMemory, testBadDecodeRequest)
 {
     uint32_t fileHandle = 0;
     uint32_t offset = 0;
@@ -50,31 +50,33 @@
     uint64_t address = 0;
 
     // Request payload message is missing
-    auto rc = decode_read_file_memory_req(NULL, 0, &fileHandle, &offset,
-                                          &length, &address);
+    auto rc = decode_rw_file_memory_req(NULL, 0, &fileHandle, &offset, &length,
+                                        &address);
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 
-    std::array<uint8_t, PLDM_READ_FILE_MEM_REQ_BYTES> requestMsg{};
+    std::array<uint8_t, PLDM_RW_FILE_MEM_REQ_BYTES> requestMsg{};
 
     // Address is NULL
-    rc = decode_read_file_memory_req(requestMsg.data(), requestMsg.size(),
-                                     &fileHandle, &offset, &length, NULL);
+    rc = decode_rw_file_memory_req(requestMsg.data(), requestMsg.size(),
+                                   &fileHandle, &offset, &length, NULL);
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 
     // Payload length is invalid
-    rc = decode_read_file_memory_req(requestMsg.data(), 0, &fileHandle, &offset,
-                                     &length, &address);
+    rc = decode_rw_file_memory_req(requestMsg.data(), 0, &fileHandle, &offset,
+                                   &length, &address);
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
 }
 
-TEST(ReadFileIntoMemory, testGoodEncodeResponse)
+TEST(ReadWriteFileMemory, testGoodEncodeResponse)
 {
-    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_READ_FILE_MEM_RESP_BYTES>
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_RW_FILE_MEM_RESP_BYTES>
         responseMsg{};
     uint32_t length = 0xFF00EE11;
     pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
 
-    auto rc = encode_read_file_memory_resp(0, PLDM_SUCCESS, length, response);
+    // ReadFileIntoMemory
+    auto rc = encode_rw_file_memory_resp(0, PLDM_READ_FILE_INTO_MEMORY,
+                                         PLDM_SUCCESS, length, response);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
@@ -84,16 +86,31 @@
     ASSERT_EQ(response->payload[0], PLDM_SUCCESS);
     ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]),
                         &length, sizeof(length)));
+
+    // WriteFileFromMemory
+    rc = encode_rw_file_memory_resp(0, PLDM_WRITE_FILE_FROM_MEMORY,
+                                    PLDM_SUCCESS, length, response);
+
+    ASSERT_EQ(rc, PLDM_SUCCESS);
+    ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
+    ASSERT_EQ(response->hdr.instance_id, 0);
+    ASSERT_EQ(response->hdr.type, PLDM_IBM_OEM_TYPE);
+    ASSERT_EQ(response->hdr.command, PLDM_WRITE_FILE_FROM_MEMORY);
+    ASSERT_EQ(response->payload[0], PLDM_SUCCESS);
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]),
+                        &length, sizeof(length)));
 }
 
-TEST(ReadFileIntoMemory, testBadEncodeResponse)
+TEST(ReadWriteFileMemory, testBadEncodeResponse)
 {
-    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_READ_FILE_MEM_RESP_BYTES>
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_RW_FILE_MEM_RESP_BYTES>
         responseMsg{};
     uint32_t length = 0;
     pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
 
-    auto rc = encode_read_file_memory_resp(0, PLDM_ERROR, length, response);
+    // ReadFileIntoMemory
+    auto rc = encode_rw_file_memory_resp(0, PLDM_READ_FILE_INTO_MEMORY,
+                                         PLDM_ERROR, length, response);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
@@ -101,4 +118,15 @@
     ASSERT_EQ(response->hdr.type, PLDM_IBM_OEM_TYPE);
     ASSERT_EQ(response->hdr.command, PLDM_READ_FILE_INTO_MEMORY);
     ASSERT_EQ(response->payload[0], PLDM_ERROR);
+
+    // WriteFileFromMemory
+    rc = encode_rw_file_memory_resp(0, PLDM_WRITE_FILE_FROM_MEMORY, PLDM_ERROR,
+                                    length, response);
+
+    ASSERT_EQ(rc, PLDM_SUCCESS);
+    ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
+    ASSERT_EQ(response->hdr.instance_id, 0);
+    ASSERT_EQ(response->hdr.type, PLDM_IBM_OEM_TYPE);
+    ASSERT_EQ(response->hdr.command, PLDM_WRITE_FILE_FROM_MEMORY);
+    ASSERT_EQ(response->payload[0], PLDM_ERROR);
 }