pldm: Support password prompt for graphical SMS menu

libpldmresponder/meson.build

@@ -80,7 +80,11 @@ if get_option('oem-ibm').allowed()
     '../oem/ibm/libpldmresponder/file_io_type_vpd.cpp',
     '../oem/ibm/libpldmresponder/file_io_type_pcie.cpp',
     '../oem/ibm/libpldmresponder/file_io_type_lic.cpp',
+    '../oem/ibm/pfw-sms-utils/pfw_sms_menu.cpp',
+    '../oem/ibm/libpldmresponder/file_io_type_smsmenu.cpp',
   ]
+  libpam = cpp.find_library('pam', required: true)
+  libpldmresponder_deps += [libpam]
 endif
 
 libpldmresponder = library(

meson.build

@@ -213,6 +213,10 @@ subdir('pldmtool')
 
 subdir('configurations')
 
+if get_option('oem-ibm').enabled()
+  subdir('oem/ibm/pfw-sms-utils')
+endif
+
 if get_option('utilities').allowed()
   subdir('utilities')
 endif

oem/ibm/libpldmresponder/file_io.cpp

@@ -854,10 +854,10 @@ Response Handler::writeFile(const pldm_msg* request, size_t payloadLength)
     return response;
 }
 
-Response rwFileByTypeIntoMemory(uint8_t cmd, const pldm_msg* request,
-                                size_t payloadLength,
-                                oem_platform::Handler* oemPlatformHandler,
-                                SharedAIORespData& sharedAIORespDataobj)
+Response Handler::rwFileByTypeIntoMemory(
+    uint8_t cmd, const pldm_msg* request, size_t payloadLength,
+    oem_platform::Handler* oemPlatformHandler,
+    SharedAIORespData& sharedAIORespDataobj, pldm::InstanceIdDb* instanceIdDb)
 {
     Response response(
         sizeof(pldm_msg_hdr) + PLDM_RW_FILE_BY_TYPE_MEM_RESP_BYTES, 0);
@@ -906,7 +906,8 @@ Response rwFileByTypeIntoMemory(uint8_t cmd, const pldm_msg* request,
     std::shared_ptr<FileHandler> handler{};
     try
     {
-        handler = getSharedHandlerByType(fileType, fileHandle);
+        handler = getSharedHandlerByType(fileType, fileHandle, instanceIdDb,
+                                         Handler::handler);
     }
     catch (const InternalFailure& e)
     {
@@ -939,15 +940,38 @@ Response Handler::writeFileByTypeFromMemory(const pldm_msg* request,
 {
     return rwFileByTypeIntoMemory(PLDM_WRITE_FILE_BY_TYPE_FROM_MEMORY, request,
                                   payloadLength, oemPlatformHandler,
-                                  sharedAIORespDataobj);
+                                  sharedAIORespDataobj, instanceIdDb);
 }
 
 Response Handler::readFileByTypeIntoMemory(const pldm_msg* request,
                                            size_t payloadLength)
 {
     return rwFileByTypeIntoMemory(PLDM_READ_FILE_BY_TYPE_INTO_MEMORY, request,
                                   payloadLength, oemPlatformHandler,
-                                  sharedAIORespDataobj);
+                                  sharedAIORespDataobj, instanceIdDb);
+}
+
+void Handler::postWriteCallBack(
+    const uint16_t fileType, const uint32_t fileHandle,
+    const struct fileack_status_metadata& metaDataObj)
+{
+    smsEvent.reset();
+
+    std::unique_ptr<FileHandler> handler{};
+    try
+    {
+        handler = getHandlerByType(fileType, fileHandle, instanceIdDb,
+                                   Handler::handler);
+    }
+    catch (const InternalFailure& e)
+    {
+        error("post write call back failed with file type : {FILE_TYPE} and"
+              " error : {ERR_EXCEP}",
+              "FILE_TYPE", fileType, "ERR_EXCEP", e.what());
+        return;
+    }
+
+    handler->postWriteAction(fileType, fileHandle, metaDataObj);
 }
 
 Response Handler::writeFileByType(const pldm_msg* request, size_t payloadLength)
@@ -986,7 +1010,8 @@ Response Handler::writeFileByType(const pldm_msg* request, size_t payloadLength)
     std::unique_ptr<FileHandler> handler{};
     try
     {
-        handler = getHandlerByType(fileType, fileHandle);
+        handler = getHandlerByType(fileType, fileHandle, instanceIdDb,
+                                   Handler::handler);
     }
     catch (const InternalFailure& e)
     {
@@ -998,12 +1023,21 @@ Response Handler::writeFileByType(const pldm_msg* request, size_t payloadLength)
         return response;
     }
 
+    fileack_status_metadata metaDataObj;
     rc = handler->write(reinterpret_cast<const char*>(
                             request->payload + PLDM_RW_FILE_BY_TYPE_REQ_BYTES),
-                        offset, length, oemPlatformHandler);
+                        offset, length, oemPlatformHandler, metaDataObj);
     encodeRWTypeResponseHandler(request->hdr.instance_id,
                                 PLDM_WRITE_FILE_BY_TYPE, rc, length,
                                 responsePtr);
+
+    if (rc == PLDM_SUCCESS)
+    {
+        smsEvent = std::make_unique<sdeventplus::source::Defer>(
+            event, std::bind(&Handler::postWriteCallBack, this, fileType,
+                             fileHandle, metaDataObj));
+    }
+
     return response;
 }
 
@@ -1043,7 +1077,8 @@ Response Handler::readFileByType(const pldm_msg* request, size_t payloadLength)
     std::unique_ptr<FileHandler> handler{};
     try
     {
-        handler = getHandlerByType(fileType, fileHandle);
+        handler = getHandlerByType(fileType, fileHandle, instanceIdDb,
+                                   Handler::handler);
     }
     catch (const InternalFailure& e)
     {
@@ -1092,7 +1127,8 @@ Response Handler::fileAck(const pldm_msg* request, size_t payloadLength)
     std::unique_ptr<FileHandler> handler{};
     try
     {
-        handler = getHandlerByType(fileType, fileHandle);
+        handler = getHandlerByType(fileType, fileHandle, instanceIdDb,
+                                   Handler::handler);
     }
 
     catch (const InternalFailure& e)
@@ -1186,7 +1222,8 @@ Response Handler::newFileAvailable(const pldm_msg* request,
     std::unique_ptr<FileHandler> handler{};
     try
     {
-        handler = getHandlerByType(fileType, fileHandle);
+        handler = getHandlerByType(fileType, fileHandle, instanceIdDb,
+                                   Handler::handler);
     }
     catch (const InternalFailure& e)
     {
@@ -1238,7 +1275,8 @@ Response Handler::newFileAvailableWithMetaData(const pldm_msg* request,
     std::unique_ptr<FileHandler> handler{};
     try
     {
-        handler = getHandlerByType(fileType, fileHandle);
+        handler = getHandlerByType(fileType, fileHandle, instanceIdDb,
+                                   Handler::handler);
     }
     catch (const InternalFailure& e)
     {
@@ -1287,7 +1325,8 @@ Response Handler::fileAckWithMetaData(const pldm_msg* request,
     std::unique_ptr<FileHandler> handler{};
     try
     {
-        handler = getHandlerByType(fileType, fileHandle);
+        handler = getHandlerByType(fileType, fileHandle, instanceIdDb,
+                                   Handler::handler);
     }
     catch (const InternalFailure& e)
     {

oem/ibm/libpldmresponder/file_io.hpp

@@ -658,10 +658,11 @@ class Handler : public CmdHandler
     Handler(oem_platform::Handler* oemPlatformHandler, int hostSockFd,
             uint8_t hostEid, pldm::InstanceIdDb* instanceIdDb,
             pldm::requester::Handler<pldm::requester::Request>* handler,
-            pldm::response_api::AltResponse* respInterface) :
+            pldm::response_api::AltResponse* respInterface,
+            sdeventplus::Event& event) :
         oemPlatformHandler(oemPlatformHandler), hostSockFd(hostSockFd),
         hostEid(hostEid), instanceIdDb(instanceIdDb), handler(handler),
-        sharedAIORespDataobj({0, 0, nullptr, 0, respInterface})
+        sharedAIORespDataobj({0, 0, nullptr, 0, respInterface}), event(event)
     {
         handlers.emplace(
             PLDM_READ_FILE_INTO_MEMORY,
@@ -993,6 +994,31 @@ class Handler : public CmdHandler
      */
     Response fileAckWithMetaData(const pldm_msg* request, size_t payloadLength);
 
+    /** @brief Handler for read/write file by type into memory command
+     *
+     *  @param[in] request - PLDM read/write command
+     *  @param[in] request - PLDM request msg
+     *  @param[in] payloadLength - length of the message payload
+     *  @param[in] oemPlatformHandler - oem platform handler
+     *  @param[in] instanceIdDb - pldm instance DB requester
+     *
+     *  @return PLDM response messsage
+     */
+    Response rwFileByTypeIntoMemory(uint8_t cmd, const pldm_msg* request,
+                                    size_t payloadLength,
+                                    oem_platform::Handler* oemPlatformHandler,
+                                    SharedAIORespData& sharedAIORespDataobj,
+                                    pldm::InstanceIdDb* instanceIdDb);
+
+    /** @brief Execute the post write call back actions after sending back the
+     *  write command response to the host
+     *  @param[in] fileType - type of the file
+     *  @param[in] fileHandle - file handle
+     *  @param[in] metaDataObj - file ack meta data status and values
+     */
+    void postWriteCallBack(const uint16_t fileType, const uint32_t fileHandle,
+                           const struct fileack_status_metadata& metaDataObj);
+
   private:
     oem_platform::Handler* oemPlatformHandler;
     int hostSockFd;
@@ -1017,6 +1043,11 @@ class Handler : public CmdHandler
     std::vector<std::unique_ptr<pldm::requester::oem_ibm::DbusToFileHandler>>
         dbusToFileHandlers;
     SharedAIORespData sharedAIORespDataobj;
+
+    /** @brief sdeventplus event */
+    sdeventplus::Event& event;
+    /** @brief sdeventplus defer event source */
+    std::unique_ptr<sdeventplus::source::Defer> smsEvent;
 };
 
 } // namespace oem_ibm

oem/ibm/libpldmresponder/file_io_by_type.cpp

@@ -8,6 +8,7 @@
 #include "file_io_type_pcie.hpp"
 #include "file_io_type_pel.hpp"
 #include "file_io_type_progress_src.hpp"
+#include "file_io_type_smsmenu.hpp"
 #include "file_io_type_vpd.hpp"
 #include "xyz/openbmc_project/Common/error.hpp"
 
@@ -414,8 +415,9 @@ void FileHandler::transferFileData(const fs::path& path, bool upstream,
                      sharedAIORespDataobj, event);
 }
 
-std::unique_ptr<FileHandler> getHandlerByType(uint16_t fileType,
-                                              uint32_t fileHandle)
+std::unique_ptr<FileHandler> getHandlerByType(
+    uint16_t fileType, uint32_t fileHandle, pldm::InstanceIdDb* instanceIdDb,
+    pldm::requester::Handler<pldm::requester::Request>* handler)
 {
     switch (fileType)
     {
@@ -479,6 +481,12 @@ std::unique_ptr<FileHandler> getHandlerByType(uint16_t fileType,
         {
             return std::make_unique<ChapHandler>(fileHandle, fileType);
         }
+        case PLDM_FILE_TYPE_USER_PASSWORD_AUTHENTICATION:
+        case PLDM_FILE_TYPE_USER_PASSWORD_CHANGE:
+        {
+            return std::make_unique<SmsMenuHandler>(fileHandle, fileType,
+                                                    instanceIdDb, handler);
+        }
         default:
         {
             throw InternalFailure();
@@ -488,8 +496,9 @@ std::unique_ptr<FileHandler> getHandlerByType(uint16_t fileType,
     return nullptr;
 }
 
-std::shared_ptr<FileHandler> getSharedHandlerByType(uint16_t fileType,
-                                                    uint32_t fileHandle)
+std::shared_ptr<FileHandler> getSharedHandlerByType(
+    uint16_t fileType, uint32_t fileHandle, pldm::InstanceIdDb* instanceIdDb,
+    pldm::requester::Handler<pldm::requester::Request>* handler)
 {
     switch (fileType)
     {
@@ -549,6 +558,12 @@ std::shared_ptr<FileHandler> getSharedHandlerByType(uint16_t fileType,
         {
             return std::make_shared<keywordHandler>(fileHandle, fileType);
         }
+        case PLDM_FILE_TYPE_USER_PASSWORD_AUTHENTICATION:
+        case PLDM_FILE_TYPE_USER_PASSWORD_CHANGE:
+        {
+            return std::make_unique<SmsMenuHandler>(fileHandle, fileType,
+                                                    instanceIdDb, handler);
+        }
         default:
         {
             throw InternalFailure();

oem/ibm/libpldmresponder/file_io_by_type.hpp

@@ -154,10 +154,22 @@ class FileHandler
      *  @param[in/out] length - length to be written
      *  @param[in] oemPlatformHandler - oem handler for PLDM platform related
      *                                  tasks
+     *  @param[out] metaDataObj - file ack meta data status and values
      *  @return PLDM status code
      */
     virtual int write(const char* buffer, uint32_t offset, uint32_t& length,
-                      oem_platform::Handler* oemPlatformHandler) = 0;
+                      oem_platform::Handler* oemPlatformHandler,
+                      struct fileack_status_metadata& metaDataObj) = 0;
+
+    /** @brief Execute the post actions after sending back the write command
+     *  response to the host
+     *  @param[in] fileType - type of the file
+     *  @param[in] fileHandle - file handle
+     *  @param[in] metaDataObj - file ack meta data status and values
+     */
+    virtual void
+        postWriteAction(const uint16_t fileType, const uint32_t fileHandle,
+                        const struct fileack_status_metadata& metaDataObj) = 0;
 
     virtual int fileAck(uint8_t fileStatus) = 0;
 
@@ -282,17 +294,25 @@ class FileHandler
  *
  *  @param[in] fileType - type of file
  *  @param[in] fileHandle - file handle
+ *  @param[in] instanceIdDb - pldm instance DB requester
+ *  @param[in] handler - pldm request handler
+ *
+ *  @return Unique file handler
  */
 
-std::unique_ptr<FileHandler> getHandlerByType(uint16_t fileType,
-                                              uint32_t fileHandle);
+std::unique_ptr<FileHandler> getHandlerByType(
+    uint16_t fileType, uint32_t fileHandle, pldm::InstanceIdDb* instanceIdDb,
+    pldm::requester::Handler<pldm::requester::Request>* handler);
 
 /** @brief Method to create shared file handler objects based on file type
  *
  *  @param[in] fileType - type of file
  *  @param[in] fileHandle - file handle
+ *  @param[in] instanceIdDb - pldm instance DB requester
+ *  @param[in] handler - pldm request handler
  */
-std::shared_ptr<FileHandler> getSharedHandlerByType(uint16_t fileType,
-                                                    uint32_t fileHandle);
+std::shared_ptr<FileHandler> getSharedHandlerByType(
+    uint16_t fileType, uint32_t fileHandle, pldm::InstanceIdDb* instanceIdDb,
+    pldm::requester::Handler<pldm::requester::Request>* handler);
 } // namespace responder
 } // namespace pldm

oem/ibm/libpldmresponder/file_io_type_cert.cpp

@@ -112,7 +112,8 @@ int CertHandler::read(uint32_t offset, uint32_t& length, Response& response,
 }
 
 int CertHandler::write(const char* buffer, uint32_t offset, uint32_t& length,
-                       oem_platform::Handler* /*oemPlatformHandler*/)
+                       oem_platform::Handler* /*oemPlatformHandler*/,
+                       struct fileack_status_metadata& /*metaDataObj*/)
 {
     auto it = certMap.find(certType);
     if (it == certMap.end())

oem/ibm/libpldmresponder/file_io_type_cert.hpp

@@ -42,7 +42,8 @@ class CertHandler : public FileHandler
                      oem_platform::Handler* /*oemPlatformHandler*/);
 
     virtual int write(const char* buffer, uint32_t offset, uint32_t& length,
-                      oem_platform::Handler* /*oemPlatformHandler*/);
+                      oem_platform::Handler* /*oemPlatformHandler*/,
+                      struct fileack_status_metadata& /*metaDataObj*/);
 
     virtual int fileAck(uint8_t /*fileStatus*/)
     {
@@ -65,6 +66,10 @@ class CertHandler : public FileHandler
 
     virtual int postDataTransferCallBack(bool IsWriteToMemOp, uint32_t length);
 
+    virtual void postWriteAction(
+        const uint16_t /*fileType*/, const uint32_t /*fileHandle*/,
+        const struct fileack_status_metadata& /*metaDataObj*/) {};
+
     /** @brief CertHandler destructor
      */
     ~CertHandler() {}

oem/ibm/libpldmresponder/file_io_type_chap.hpp

@@ -48,7 +48,8 @@ class ChapHandler : public FileHandler
 
     virtual int write(const char* /*buffer*/, uint32_t /*offset*/,
                       uint32_t& /*length*/,
-                      oem_platform::Handler* /*oemPlatformHandler*/)
+                      oem_platform::Handler* /*oemPlatformHandler*/,
+                      struct fileack_status_metadata& /*metaDataObj*/)
     {
         return PLDM_ERROR_UNSUPPORTED_PLDM_CMD;
     }
@@ -84,6 +85,10 @@ class ChapHandler : public FileHandler
         return PLDM_ERROR_UNSUPPORTED_PLDM_CMD;
     }
 
+    virtual void postWriteAction(
+        const uint16_t /*fileType*/, const uint32_t /*fileHandle*/,
+        const struct fileack_status_metadata& /*metaDataObj*/) {};
+
     /** @brief ChapHandler destructor
      */
     ~ChapHandler() {}