blob: 4e2af4fa2a1ae3b659a29ffbb6330957535b38d1 [file] [log] [blame]
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +05301#pragma once
2
Deepak Kodihalli4c164b02020-03-07 03:23:31 -06003#include "config.h"
4
Deepak Kodihallid130e1a2020-06-17 05:55:32 -05005#include "common/utils.hpp"
Jayashankar Padathdb124362021-01-28 21:12:34 -06006#include "oem/ibm/requester/dbus_to_file_handler.hpp"
Sampa Misraaea5dde2020-08-31 08:33:47 -05007#include "oem_ibm_handler.hpp"
Deepak Kodihalli1521f6d2020-06-16 08:51:02 -05008#include "pldmd/handler.hpp"
Sampa Misrac0c79482021-06-02 08:01:54 -05009#include "requester/handler.hpp"
Deepak Kodihallibc669f12019-11-28 08:52:07 -060010
Deepak Kodihalli15211b42019-12-14 02:24:49 -060011#include <fcntl.h>
George Liuc453e162022-12-21 17:16:23 +080012#include <libpldm/base.h>
13#include <libpldm/file_io.h>
14#include <libpldm/host.h>
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +053015#include <stdint.h>
Deepak Kodihalli15211b42019-12-14 02:24:49 -060016#include <sys/stat.h>
17#include <sys/types.h>
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +053018#include <unistd.h>
19
Riya Dixit49cfb132023-03-02 04:26:53 -060020#include <phosphor-logging/lg2.hpp>
21
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +053022#include <filesystem>
Deepak Kodihalli15211b42019-12-14 02:24:49 -060023#include <iostream>
Priyanga8b976652019-06-27 11:30:33 -050024#include <vector>
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +053025
Riya Dixit49cfb132023-03-02 04:26:53 -060026PHOSPHOR_LOG2_USING;
27
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +053028namespace pldm
29{
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +053030namespace responder
31{
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +053032namespace dma
33{
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +053034// The minimum data size of dma transfer in bytes
35constexpr uint32_t minSize = 16;
36
Deepak Kodihalli4c164b02020-03-07 03:23:31 -060037constexpr size_t maxSize = DMA_MAXSIZE;
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +053038
39namespace fs = std::filesystem;
40
41/**
42 * @class DMA
43 *
44 * Expose API to initiate transfer of data by DMA
45 *
46 * This class only exposes the public API transferDataHost to transfer data
47 * between BMC and host using DMA. This allows for mocking the transferDataHost
48 * for unit testing purposes.
49 */
50class DMA
51{
52 public:
53 /** @brief API to transfer data between BMC and host using DMA
54 *
55 * @param[in] path - pathname of the file to transfer data from or to
56 * @param[in] offset - offset in the file
57 * @param[in] length - length of the data to transfer
58 * @param[in] address - DMA address on the host
59 * @param[in] upstream - indicates direction of the transfer; true indicates
60 * transfer to the host
61 *
62 * @return returns 0 on success, negative errno on failure
63 */
Deepak Kodihalli15211b42019-12-14 02:24:49 -060064 int transferDataHost(int fd, uint32_t offset, uint32_t length,
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +053065 uint64_t address, bool upstream);
Ravi Tejace1c96f2020-10-05 23:13:01 -050066
67 /** @brief API to transfer data on to unix socket from host using DMA
68 *
69 * @param[in] path - pathname of the file to transfer data from or to
70 * @param[in] length - length of the data to transfer
71 * @param[in] address - DMA address on the host
72 *
73 * @return returns 0 on success, negative errno on failure
74 */
75 int transferHostDataToSocket(int fd, uint32_t length, uint64_t address);
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +053076};
77
78/** @brief Transfer the data between BMC and host using DMA.
79 *
80 * There is a max size for each DMA operation, transferAll API abstracts this
81 * and the requested length is broken down into multiple DMA operations if the
82 * length exceed max size.
83 *
84 * @tparam[in] T - DMA interface type
85 * @param[in] intf - interface passed to invoke DMA transfer
86 * @param[in] command - PLDM command
87 * @param[in] path - pathname of the file to transfer data from or to
88 * @param[in] offset - offset in the file
89 * @param[in] length - length of the data to transfer
90 * @param[in] address - DMA address on the host
91 * @param[in] upstream - indicates direction of the transfer; true indicates
92 * transfer to the host
Jinu Joy Thomas33705fd2019-07-02 16:03:05 +053093 * @param[in] instanceId - Message's instance id
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +053094 * @return PLDM response message
95 */
96
97template <class DMAInterface>
98Response transferAll(DMAInterface* intf, uint8_t command, fs::path& path,
99 uint32_t offset, uint32_t length, uint64_t address,
Jinu Joy Thomas33705fd2019-07-02 16:03:05 +0530100 bool upstream, uint8_t instanceId)
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +0530101{
102 uint32_t origLength = length;
103 Response response(sizeof(pldm_msg_hdr) + PLDM_RW_FILE_MEM_RESP_BYTES, 0);
104 auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
105
Deepak Kodihalli15211b42019-12-14 02:24:49 -0600106 int flags{};
107 if (upstream)
108 {
109 flags = O_RDONLY;
110 }
111 else if (fs::exists(path))
112 {
113 flags = O_RDWR;
114 }
115 else
116 {
117 flags = O_WRONLY;
118 }
119 int file = open(path.string().c_str(), flags);
120 if (file == -1)
121 {
Riya Dixit49cfb132023-03-02 04:26:53 -0600122 error("File does not exist, path = {FILE_PATH}", "FILE_PATH",
123 path.string());
Deepak Kodihalli15211b42019-12-14 02:24:49 -0600124 encode_rw_file_memory_resp(instanceId, command, PLDM_ERROR, 0,
125 responsePtr);
126 return response;
127 }
George Liu83409572019-12-24 18:42:54 +0800128 pldm::utils::CustomFD fd(file);
Deepak Kodihalli15211b42019-12-14 02:24:49 -0600129
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +0530130 while (length > dma::maxSize)
131 {
Deepak Kodihalli15211b42019-12-14 02:24:49 -0600132 auto rc = intf->transferDataHost(fd(), offset, dma::maxSize, address,
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +0530133 upstream);
134 if (rc < 0)
135 {
Jinu Joy Thomas33705fd2019-07-02 16:03:05 +0530136 encode_rw_file_memory_resp(instanceId, command, PLDM_ERROR, 0,
137 responsePtr);
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +0530138 return response;
139 }
140
141 offset += dma::maxSize;
142 length -= dma::maxSize;
143 address += dma::maxSize;
144 }
145
Deepak Kodihalli15211b42019-12-14 02:24:49 -0600146 auto rc = intf->transferDataHost(fd(), offset, length, address, upstream);
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +0530147 if (rc < 0)
148 {
Jinu Joy Thomas33705fd2019-07-02 16:03:05 +0530149 encode_rw_file_memory_resp(instanceId, command, PLDM_ERROR, 0,
150 responsePtr);
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +0530151 return response;
152 }
153
Jinu Joy Thomas33705fd2019-07-02 16:03:05 +0530154 encode_rw_file_memory_resp(instanceId, command, PLDM_SUCCESS, origLength,
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +0530155 responsePtr);
156 return response;
157}
158
159} // namespace dma
160
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600161namespace oem_ibm
162{
Jayashankar Padathdb124362021-01-28 21:12:34 -0600163static constexpr auto dumpObjPath = "/xyz/openbmc_project/dump/resource/entry/";
164static constexpr auto resDumpEntry = "com.ibm.Dump.Entry.Resource";
Varsha Kaverappa219ace92021-04-01 02:50:11 -0500165
166static constexpr auto certObjPath = "/xyz/openbmc_project/certs/ca/";
167static constexpr auto certAuthority =
168 "xyz.openbmc_project.PLDM.Provider.Certs.Authority.CSR";
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600169class Handler : public CmdHandler
170{
171 public:
Jayashankar Padathdb124362021-01-28 21:12:34 -0600172 Handler(oem_platform::Handler* oemPlatformHandler, int hostSockFd,
Sampa Misrac0c79482021-06-02 08:01:54 -0500173 uint8_t hostEid, dbus_api::Requester* dbusImplReqester,
174 pldm::requester::Handler<pldm::requester::Request>* handler) :
Jayashankar Padathdb124362021-01-28 21:12:34 -0600175 oemPlatformHandler(oemPlatformHandler),
176 hostSockFd(hostSockFd), hostEid(hostEid),
Sampa Misrac0c79482021-06-02 08:01:54 -0500177 dbusImplReqester(dbusImplReqester), handler(handler)
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600178 {
179 handlers.emplace(PLDM_READ_FILE_INTO_MEMORY,
180 [this](const pldm_msg* request, size_t payloadLength) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500181 return this->readFileIntoMemory(request, payloadLength);
182 });
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600183 handlers.emplace(PLDM_WRITE_FILE_FROM_MEMORY,
184 [this](const pldm_msg* request, size_t payloadLength) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500185 return this->writeFileFromMemory(request, payloadLength);
186 });
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600187 handlers.emplace(PLDM_WRITE_FILE_BY_TYPE_FROM_MEMORY,
188 [this](const pldm_msg* request, size_t payloadLength) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500189 return this->writeFileByTypeFromMemory(request, payloadLength);
190 });
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600191 handlers.emplace(PLDM_READ_FILE_BY_TYPE_INTO_MEMORY,
192 [this](const pldm_msg* request, size_t payloadLength) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500193 return this->readFileByTypeIntoMemory(request, payloadLength);
194 });
195 handlers.emplace(PLDM_READ_FILE_BY_TYPE,
196 [this](const pldm_msg* request, size_t payloadLength) {
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600197 return this->readFileByType(request, payloadLength);
198 });
Sampa Misra18967162020-01-14 02:31:41 -0600199 handlers.emplace(PLDM_WRITE_FILE_BY_TYPE,
200 [this](const pldm_msg* request, size_t payloadLength) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500201 return this->writeFileByType(request, payloadLength);
202 });
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600203 handlers.emplace(PLDM_GET_FILE_TABLE,
204 [this](const pldm_msg* request, size_t payloadLength) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500205 return this->getFileTable(request, payloadLength);
206 });
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600207 handlers.emplace(PLDM_READ_FILE,
208 [this](const pldm_msg* request, size_t payloadLength) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500209 return this->readFile(request, payloadLength);
210 });
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600211 handlers.emplace(PLDM_WRITE_FILE,
212 [this](const pldm_msg* request, size_t payloadLength) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500213 return this->writeFile(request, payloadLength);
214 });
Deepak Kodihalli2da1bfe2019-12-14 08:28:09 -0600215 handlers.emplace(PLDM_FILE_ACK,
216 [this](const pldm_msg* request, size_t payloadLength) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500217 return this->fileAck(request, payloadLength);
218 });
George Liu89aad712020-03-12 13:34:51 +0800219 handlers.emplace(PLDM_HOST_GET_ALERT_STATUS,
220 [this](const pldm_msg* request, size_t payloadLength) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500221 return this->getAlertStatus(request, payloadLength);
222 });
Sampa Misra18967162020-01-14 02:31:41 -0600223 handlers.emplace(PLDM_NEW_FILE_AVAILABLE,
224 [this](const pldm_msg* request, size_t payloadLength) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500225 return this->newFileAvailable(request, payloadLength);
226 });
Jayashankar Padathdb124362021-01-28 21:12:34 -0600227
Patrick Williams84b790c2022-07-22 19:26:56 -0500228 resDumpMatcher = std::make_unique<sdbusplus::bus::match_t>(
Jayashankar Padathdb124362021-01-28 21:12:34 -0600229 pldm::utils::DBusHandler::getBus(),
230 sdbusplus::bus::match::rules::interfacesAdded() +
231 sdbusplus::bus::match::rules::argNpath(0, dumpObjPath),
Sampa Misrac0c79482021-06-02 08:01:54 -0500232 [this, hostSockFd, hostEid, dbusImplReqester,
Patrick Williams84b790c2022-07-22 19:26:56 -0500233 handler](sdbusplus::message_t& msg) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500234 std::map<std::string,
235 std::map<std::string, std::variant<std::string, uint32_t>>>
236 interfaces;
237 sdbusplus::message::object_path path;
238 msg.read(path, interfaces);
239 std::string vspstring;
240 std::string password;
Jayashankar Padathdb124362021-01-28 21:12:34 -0600241
Patrick Williams6da4f912023-05-10 07:50:53 -0500242 for (auto& interface : interfaces)
243 {
244 if (interface.first == resDumpEntry)
Jayashankar Padathdb124362021-01-28 21:12:34 -0600245 {
Patrick Williams6da4f912023-05-10 07:50:53 -0500246 for (const auto& property : interface.second)
Jayashankar Padathdb124362021-01-28 21:12:34 -0600247 {
Patrick Williams6da4f912023-05-10 07:50:53 -0500248 if (property.first == "VSPString")
Jayashankar Padathdb124362021-01-28 21:12:34 -0600249 {
Patrick Williams6da4f912023-05-10 07:50:53 -0500250 vspstring = std::get<std::string>(property.second);
Jayashankar Padathdb124362021-01-28 21:12:34 -0600251 }
Patrick Williams6da4f912023-05-10 07:50:53 -0500252 else if (property.first == "Password")
253 {
254 password = std::get<std::string>(property.second);
255 }
Jayashankar Padathdb124362021-01-28 21:12:34 -0600256 }
Patrick Williams6da4f912023-05-10 07:50:53 -0500257 dbusToFileHandlers
258 .emplace_back(
259 std::make_unique<
260 pldm::requester::oem_ibm::DbusToFileHandler>(
261 hostSockFd, hostEid, dbusImplReqester, path,
262 handler))
263 ->processNewResourceDump(vspstring, password);
264 break;
Jayashankar Padathdb124362021-01-28 21:12:34 -0600265 }
Patrick Williams6da4f912023-05-10 07:50:53 -0500266 }
Jayashankar Padathdb124362021-01-28 21:12:34 -0600267 });
Patrick Williams84b790c2022-07-22 19:26:56 -0500268 vmiCertMatcher = std::make_unique<sdbusplus::bus::match_t>(
Varsha Kaverappa219ace92021-04-01 02:50:11 -0500269 pldm::utils::DBusHandler::getBus(),
270 sdbusplus::bus::match::rules::interfacesAdded() +
271 sdbusplus::bus::match::rules::argNpath(0, certObjPath),
Sampa Misrac0c79482021-06-02 08:01:54 -0500272 [this, hostSockFd, hostEid, dbusImplReqester,
Patrick Williams84b790c2022-07-22 19:26:56 -0500273 handler](sdbusplus::message_t& msg) {
Patrick Williams6da4f912023-05-10 07:50:53 -0500274 std::map<std::string,
275 std::map<std::string, std::variant<std::string, uint32_t>>>
276 interfaces;
277 sdbusplus::message::object_path path;
278 msg.read(path, interfaces);
279 std::string csr;
Varsha Kaverappa219ace92021-04-01 02:50:11 -0500280
Patrick Williams6da4f912023-05-10 07:50:53 -0500281 for (auto& interface : interfaces)
282 {
283 if (interface.first == certAuthority)
Varsha Kaverappa219ace92021-04-01 02:50:11 -0500284 {
Patrick Williams6da4f912023-05-10 07:50:53 -0500285 for (const auto& property : interface.second)
Varsha Kaverappa219ace92021-04-01 02:50:11 -0500286 {
Patrick Williams6da4f912023-05-10 07:50:53 -0500287 if (property.first == "CSR")
Varsha Kaverappa219ace92021-04-01 02:50:11 -0500288 {
Patrick Williams6da4f912023-05-10 07:50:53 -0500289 csr = std::get<std::string>(property.second);
290 auto fileHandle =
291 sdbusplus::message::object_path(path)
292 .filename();
Varsha Kaverappa219ace92021-04-01 02:50:11 -0500293
Patrick Williams6da4f912023-05-10 07:50:53 -0500294 dbusToFileHandlers
295 .emplace_back(
296 std::make_unique<pldm::requester::oem_ibm::
297 DbusToFileHandler>(
Varsha Kaverappa219ace92021-04-01 02:50:11 -0500298 hostSockFd, hostEid, dbusImplReqester,
Sampa Misrac0c79482021-06-02 08:01:54 -0500299 path, handler))
Patrick Williams6da4f912023-05-10 07:50:53 -0500300 ->newCsrFileAvailable(csr, fileHandle);
301 break;
Varsha Kaverappa219ace92021-04-01 02:50:11 -0500302 }
Varsha Kaverappa219ace92021-04-01 02:50:11 -0500303 }
Patrick Williams6da4f912023-05-10 07:50:53 -0500304 break;
Varsha Kaverappa219ace92021-04-01 02:50:11 -0500305 }
Patrick Williams6da4f912023-05-10 07:50:53 -0500306 }
Varsha Kaverappa219ace92021-04-01 02:50:11 -0500307 });
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600308 }
Tom Joseph0c6d22c2019-06-26 09:58:41 +0530309
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600310 /** @brief Handler for readFileIntoMemory command
311 *
312 * @param[in] request - pointer to PLDM request payload
313 * @param[in] payloadLength - length of the message
314 *
315 * @return PLDM response message
316 */
317 Response readFileIntoMemory(const pldm_msg* request, size_t payloadLength);
Sampa Misra854e61f2019-08-22 04:36:47 -0500318
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600319 /** @brief Handler for writeFileIntoMemory command
320 *
321 * @param[in] request - pointer to PLDM request payload
322 * @param[in] payloadLength - length of the message
323 *
324 * @return PLDM response message
325 */
326 Response writeFileFromMemory(const pldm_msg* request, size_t payloadLength);
Sampa Misra854e61f2019-08-22 04:36:47 -0500327
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600328 /** @brief Handler for writeFileByTypeFromMemory command
329 *
330 * @param[in] request - pointer to PLDM request payload
331 * @param[in] payloadLength - length of the message
332 *
333 * @return PLDM response message
334 */
Deepak Kodihallif6d3a832019-11-19 07:00:29 -0600335
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600336 Response writeFileByTypeFromMemory(const pldm_msg* request,
337 size_t payloadLength);
Deepak Kodihalli75e02f82019-11-20 02:51:05 -0600338
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600339 /** @brief Handler for readFileByTypeIntoMemory command
340 *
341 * @param[in] request - pointer to PLDM request payload
342 * @param[in] payloadLength - length of the message
343 *
344 * @return PLDM response message
345 */
346 Response readFileByTypeIntoMemory(const pldm_msg* request,
347 size_t payloadLength);
vkaverap5b914c32019-06-30 22:23:54 -0500348
Sampa Misra18967162020-01-14 02:31:41 -0600349 /** @brief Handler for writeFileByType command
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600350 *
351 * @param[in] request - pointer to PLDM request payload
352 * @param[in] payloadLength - length of the message
353 *
354 * @return PLDM response message
355 */
356 Response readFileByType(const pldm_msg* request, size_t payloadLength);
vkaverap5b914c32019-06-30 22:23:54 -0500357
Sampa Misra18967162020-01-14 02:31:41 -0600358 Response writeFileByType(const pldm_msg* request, size_t payloadLength);
359
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600360 /** @brief Handler for GetFileTable command
361 *
362 * @param[in] request - pointer to PLDM request payload
363 * @param[in] payloadLength - length of the message payload
364 *
365 * @return PLDM response message
366 */
367 Response getFileTable(const pldm_msg* request, size_t payloadLength);
368
369 /** @brief Handler for readFile command
370 *
371 * @param[in] request - PLDM request msg
372 * @param[in] payloadLength - length of the message payload
373 *
374 * @return PLDM response message
375 */
376 Response readFile(const pldm_msg* request, size_t payloadLength);
377
378 /** @brief Handler for writeFile command
379 *
380 * @param[in] request - PLDM request msg
381 * @param[in] payloadLength - length of the message payload
382 *
383 * @return PLDM response message
384 */
385 Response writeFile(const pldm_msg* request, size_t payloadLength);
Deepak Kodihalli2da1bfe2019-12-14 08:28:09 -0600386
387 Response fileAck(const pldm_msg* request, size_t payloadLength);
George Liu89aad712020-03-12 13:34:51 +0800388
389 /** @brief Handler for getAlertStatus command
390 *
391 * @param[in] request - PLDM request msg
392 * @param[in] payloadLength - length of the message payload
393 *
394 * @return PLDM response message
395 */
396 Response getAlertStatus(const pldm_msg* request, size_t payloadLength);
Sampa Misra18967162020-01-14 02:31:41 -0600397
398 /** @brief Handler for newFileAvailable command
399 *
400 * @param[in] request - PLDM request msg
401 * @param[in] payloadLength - length of the message payload
402 *
403 * @return PLDM response message
404 */
405 Response newFileAvailable(const pldm_msg* request, size_t payloadLength);
Sampa Misraaea5dde2020-08-31 08:33:47 -0500406
407 private:
408 oem_platform::Handler* oemPlatformHandler;
Jayashankar Padathdb124362021-01-28 21:12:34 -0600409 int hostSockFd;
410 uint8_t hostEid;
411 dbus_api::Requester* dbusImplReqester;
412 using DBusInterfaceAdded = std::vector<std::pair<
413 std::string,
414 std::vector<std::pair<std::string, std::variant<std::string>>>>>;
Sampa Misrac0c79482021-06-02 08:01:54 -0500415 std::unique_ptr<pldm::requester::oem_ibm::DbusToFileHandler>
416 dbusToFileHandler; //!< pointer to send request to Host
Patrick Williams84b790c2022-07-22 19:26:56 -0500417 std::unique_ptr<sdbusplus::bus::match_t>
Patrick Williams6da4f912023-05-10 07:50:53 -0500418 resDumpMatcher; //!< Pointer to capture the interface added signal
419 //!< for new resource dump
Patrick Williams84b790c2022-07-22 19:26:56 -0500420 std::unique_ptr<sdbusplus::bus::match_t>
Patrick Williams6da4f912023-05-10 07:50:53 -0500421 vmiCertMatcher; //!< Pointer to capture the interface added signal
422 //!< for new csr string
Sampa Misrac0c79482021-06-02 08:01:54 -0500423 /** @brief PLDM request handler */
424 pldm::requester::Handler<pldm::requester::Request>* handler;
425 std::vector<std::unique_ptr<pldm::requester::oem_ibm::DbusToFileHandler>>
426 dbusToFileHandlers;
Deepak Kodihallibc669f12019-11-28 08:52:07 -0600427};
428
429} // namespace oem_ibm
Jinu Joy Thomas7f57f442019-06-13 20:38:49 +0530430} // namespace responder
431} // namespace pldm