pldmtool: Add file I/O and checksum options to mctpRaw

Enhance the `mctpRaw` subcommand with options to read request
data from a file (`--file-in`), write response data to a file
(`--file-out`), and append or validate checksum (`--checksum`).
These additions improve usability for large payloads and ensure
data integrity during raw MCTP transactions.

Contents of the file specified in option --file-in are appended
to the contents of the option --data.

pldmtool mctpRaw --help
send an MCTP raw request and print response
Usage: pldmtool mctpRaw [OPTIONS]

Options:
  -h,--help                   Print this help message and exit
  -m,--mctp_eid UINT          MCTP endpoint ID
  -v,--verbose
  -n,--retry-count UINT       Number of retry when PLDM request message is failed
  -e,--network-id UINT REQUIRED
                              MCTP NetworkId
  -d,--data UINT ... REQUIRED raw MCTP data
  -i,--file-in TEXT           Read in the file to be sent
  -o,--file-out TEXT          Write out the received file
  -c,--checksum               Append/Validate checksum
  -p,--prealloc-tag           use pre-allocated MCTP tag for this request

Example:
  pldmtool mctpRaw -m 21 -e 1 --data 0x7F 0x00 0x00 0x0E 0x78 0x80 0x02 --file-in req.bin --file-out resp.bin --checksum

Upstream-status: Inappropriate

Signed-off-by: Shirish Pargaonkar <Shirish.Pargaonkar@amd.com>

Author: spargaon

pldmtool/pldmtool.cpp

@@ -72,6 +72,30 @@ namespace
 std::vector<std::unique_ptr<CommandInterface>> commands;
 }
 
+/*
+ *   • The file size and CRC32 fields are always stored in **big-endian**
+ *     format regardless of host endianness.
+ *
+ *   • If checksum is disabled, the IC bit is cleared and the CRC32 field
+ *     is omitted.
+ *
+ *   • rawData[] is assembled in this exact order:
+ *
+ *       rawData = [Header] + [File Size] + [File Data] + [Optional CRC]
+ *
+ *   • The offsets DEVHDRSIZE and FSFIELD refer to the start of the file-size
+ *     field and help determine where payload sections begin.
+ *
+ *   • Header include AMD IANA number in big-endian format
+ *
+ */
+
+inline constexpr unsigned int DEVHDRSIZE = 8;
+inline constexpr unsigned int FSFIELD = 4;
+inline constexpr unsigned int CCODEBYTE = 6;
+inline constexpr unsigned int MAXFILESIZE = 0x4000;
+inline constexpr unsigned int AMD_IANA_NUM = 0xe78;
+
 class MctpRawOp : public CommandInterface
 {
   public:
@@ -90,23 +114,207 @@ class MctpRawOp : public CommandInterface
         app->add_option("-d,--data", rawData, "raw MCTP data")
             ->required()
             ->expected(-3);
+        app->add_option("-i,--file-in ", inFileName, "Read in the file to be sent");
+        app->add_option("-o,--file-out", outFileName, "Write out the received file");
+        app->add_flag("-c,--checksum", checksum, "Append/Validate checksum");
         app->add_flag("-p,--prealloc-tag", mctpPreAllocTag,
                       "use pre-allocated MCTP tag for this request");
     }
-    std::pair<int, std::vector<uint8_t>> createRequestMsg() override
-
-    {
-        return {PLDM_SUCCESS, rawData};
-    }
-
-    void parseResponseMsg(pldm_msg* /* responsePtr */,
-                          size_t /* payloadLength */) override
-    {}
 
+    const std::string getInFileName() const {return inFileName;}
+    const std::string getOutFileName() const {return outFileName;}
+    std::pair<int, std::vector<uint8_t>> createRequestMsg() override;
+    void parseResponseMsg(pldm_msg *, size_t) override;
   private:
     std::vector<uint8_t> rawData;
+    std::string outFileName{};
+    std::string inFileName{};
+    bool checksum{false};
+
+    void appendInfile();
 };
 
+/*
+ * @brief Append an input firmware file to the rawData buffer for transmission.
+ *
+ * This function:
+ *   1. Opens the input file specified by getInFileName().
+ *   2. Reads the entire file into memory.
+ *   3. Appends the file-size field (big-endian) to rawData.
+ *   4. Appends the file contents to rawData.
+ *   5. Clears the IC (Integrity Check) bit in the header, and if checksum
+ *      is enabled, sets it and appends a CRC32 checksum of the file.
+ *
+ * All errors (file open/read failures) are printed and cause an early return.
+ */
+
+void MctpRawOp::appendInfile()
+{
+	std::ifstream toDevice;
+
+	try {
+		toDevice.open(getInFileName(), std::ios::in | std::ios::binary | std::ios::ate);
+		if (!toDevice)
+			 throw std::runtime_error("Error opening file: " + getInFileName());
+	}
+
+	catch(const std::runtime_error & e) {
+		std::cout << e.what() << std::endl;
+		return;
+	}
+
+	std::streamsize fSize = toDevice.tellg(); // size of the file to be sent
+	toDevice.seekg(0);
+
+	std::vector<uint8_t> fData(fSize);	// for reading in the entire file
+
+	try {
+		toDevice.read(reinterpret_cast<char *>(fData.data()), fSize);
+		if (!toDevice)
+			throw std::runtime_error("Error reading file: " + getInFileName());
+	}
+
+	catch(const std::runtime_error & e) {
+		std::cout << e.what() << std::endl;
+		return;
+	}
+
+	uint32_t fsField{static_cast<uint32_t>(fSize)}; // size of the file
+	if constexpr (std::endian::native == std::endian::little)
+		fsField = std::byteswap(fsField);
+	const uint8_t * fsValue = reinterpret_cast<const uint8_t *>(&fsField);
+	rawData.insert(rawData.end(), fsValue, fsValue + sizeof(fsField));
+
+	rawData.insert(rawData.end(), fData.begin(), fData.end());
+
+	rawData[0] &= 0x7F; // clear the IC bit (bit 7 [0:7]) e.g. in case 0xFF, to 0x7F
+	if (checksum) {
+		rawData[0] |= 0x80; // set the IC bit (bit 7 [0:7]) e.g. 0x7F to 0xFF
+
+		uint32_t csField = pldm_edac_crc32(fData.data(), fData.size());
+		if constexpr (std::endian::native == std::endian::little)
+			csField = std::byteswap(csField);
+		const uint8_t * csValue = reinterpret_cast<const uint8_t *>(&csField);
+		rawData.insert(rawData.end(), csValue, csValue + sizeof(csField));
+	}
+}
+
+std::pair<int, std::vector<uint8_t>> MctpRawOp::createRequestMsg()
+{
+	if (!getInFileName().empty()) // only for the -i option
+		appendInfile();
+
+	return {PLDM_SUCCESS, rawData};
+}
+
+/*
+ * @brief Parse and process a PLDM response message received over MCTP.
+ *
+ * This function validates and extracts payload information from a raw PLDM
+ * response message. The following operations are performed:
+ *
+ *   1. Validate input pointer and minimum message size.
+ *   2. Check the PLDM completion code and abort on non-zero values.
+ *   3. Verify the 4-byte IANA number (big-endian) against the expected AMD
+ *      identifier.
+ *   4. Extract and validate the reported firmware file size.
+ *   5. If an output filename is specified, extract the firmware payload data.
+ *   6. If checksum validation is enabled, compute CRC32 of the payload and
+ *      validate it against the received checksum.
+ *   7. Write the received firmware data to the specified output file.
+ *
+ * Errors and validation failures are reported to stderr and result in an
+ * immediate return without modifying any output file.
+ *
+ * @param pmsg  Pointer to the raw PLDM message buffer.
+ * @param size  Total size of the PLDM message in bytes.
+ *
+ * @note The function expects the message to contain AMD-specific vendor data
+ *       with fields in big-endian format as defined by the device protocol.
+ */
+
+void MctpRawOp::parseResponseMsg(pldm_msg *pmsg, size_t size)
+{
+	if (!pmsg)
+		return;
+
+	if (size > DEVHDRSIZE) {
+		const uint8_t * msg{reinterpret_cast<uint8_t *>(pmsg)};
+
+		// Check Completion Code (byte)
+		if (msg[CCODEBYTE] != 0) {
+			std::cerr << "Non-zero completion code: " << msg[CCODEBYTE] << std::endl;
+			return;
+		}
+
+		// Extract four bytes of IANA number to verify
+		uint32_t iana;
+		memcpy(&iana, msg, sizeof(iana)); // IANA number in big endian format
+		if constexpr (std::endian::native == std::endian::little)
+			iana = std::byteswap(iana);
+		if (iana != AMD_IANA_NUM) {
+			std::cerr << std::showbase << std::hex << "Received IANA number: " << iana << " does not match with: " << AMD_IANA_NUM << std::endl;
+			return;
+		}
+
+		// Extract four bytes to obtain the received file size
+		uint32_t fSize;
+		memcpy(&fSize, msg + DEVHDRSIZE, sizeof(fSize)); // File size is in Big endian format as per spec
+		if constexpr (std::endian::native == std::endian::little)
+			fSize = std::byteswap(fSize);
+		try {
+			if (fSize > MAXFILESIZE)
+				throw std::runtime_error("Invalid file size in bytes: " + std::to_string(fSize));
+		}
+
+		catch(const std::runtime_error & e) {
+			std::cout << e.what() << std::endl;
+			return;
+		}
+
+		// Request for GETFWVERS without specifying option -o
+		if (getOutFileName().empty())
+			return;
+
+		std::vector<uint8_t> fData{msg + DEVHDRSIZE + FSFIELD, msg + DEVHDRSIZE + FSFIELD + fSize};
+
+		if (checksum) {
+			// Calculate checksum
+			const uint32_t crc = pldm_edac_crc32(fData.data(), fData.size());
+
+			// Extract four bytes of checksum
+			uint32_t checkSum;
+			memcpy(&checkSum, msg + DEVHDRSIZE + FSFIELD + fSize, sizeof(checkSum)); // Checksum is in Big endian format as per spec
+			if constexpr (std::endian::native == std::endian::little)
+				checkSum = std::byteswap(checkSum);
+
+			if (crc != checkSum) {
+				std::cerr << std::showbase << std::hex << "CRC: " << crc << " does not match the received CRC: " << checkSum << std::endl;
+				return;
+			}
+		}
+
+		std::ofstream fromFile;
+
+		try {
+			std::ofstream fromFile(getOutFileName(), std::ios::out | std::ios::binary);
+
+			if (!fromFile.is_open()) {
+				throw std::runtime_error("Error opening file: " + getOutFileName());
+			}
+
+			fromFile.write(reinterpret_cast<const char*>(fData.data()), fData.size());
+			if (!fromFile) {
+				throw std::runtime_error("Error writing to file: " + getOutFileName());
+			}
+		}
+
+		catch (const std::exception& e) {
+			std::cerr << e.what() << '\n';
+		}
+	}
+}
+
 void registerCommand(CLI::App& app)
 {
     auto mctpRaw = app.add_subcommand(