xref: /openbmc/pldm/pldmd/pldmd.cpp (revision e7e46f58f1870bd46114bec316c4d770e2053d72)
1 #include "libpldm/base.h"
2 #include "libpldm/bios.h"
3 #include "libpldm/pdr.h"
4 #include "libpldm/platform.h"
5 
6 #include "common/utils.hpp"
7 #include "dbus_impl_pdr.hpp"
8 #include "dbus_impl_requester.hpp"
9 #include "host-bmc/dbus_to_event_handler.hpp"
10 #include "host-bmc/dbus_to_host_effecters.hpp"
11 #include "host-bmc/host_pdr_handler.hpp"
12 #include "invoker.hpp"
13 #include "libpldmresponder/base.hpp"
14 #include "libpldmresponder/bios.hpp"
15 #include "libpldmresponder/fru.hpp"
16 #include "libpldmresponder/oem_handler.hpp"
17 #include "libpldmresponder/platform.hpp"
18 #include "xyz/openbmc_project/PLDM/Event/server.hpp"
19 
20 #include <err.h>
21 #include <getopt.h>
22 #include <poll.h>
23 #include <stdlib.h>
24 #include <sys/socket.h>
25 #include <sys/types.h>
26 #include <sys/un.h>
27 #include <unistd.h>
28 
29 #include <sdeventplus/event.hpp>
30 #include <sdeventplus/source/io.hpp>
31 
32 #include <cstdio>
33 #include <cstring>
34 #include <fstream>
35 #include <iomanip>
36 #include <iostream>
37 #include <iterator>
38 #include <memory>
39 #include <sstream>
40 #include <stdexcept>
41 #include <string>
42 #include <vector>
43 
44 #ifdef OEM_IBM
45 #include "libpldmresponder/file_io.hpp"
46 #include "libpldmresponder/oem_ibm_handler.hpp"
47 #endif
48 
49 constexpr uint8_t MCTP_MSG_TYPE_PLDM = 1;
50 
51 using namespace pldm::responder;
52 using namespace pldm;
53 using namespace sdeventplus;
54 using namespace sdeventplus::source;
55 using namespace pldm::state_sensor;
56 
57 static Response processRxMsg(const std::vector<uint8_t>& requestMsg,
58                              Invoker& invoker, dbus_api::Requester& requester)
59 {
60 
61     Response response;
62     uint8_t eid = requestMsg[0];
63     uint8_t type = requestMsg[1];
64     pldm_header_info hdrFields{};
65     auto hdr = reinterpret_cast<const pldm_msg_hdr*>(
66         requestMsg.data() + sizeof(eid) + sizeof(type));
67     if (PLDM_SUCCESS != unpack_pldm_header(hdr, &hdrFields))
68     {
69         std::cerr << "Empty PLDM request header \n";
70     }
71     else if (PLDM_RESPONSE != hdrFields.msg_type)
72     {
73         auto request = reinterpret_cast<const pldm_msg*>(hdr);
74         size_t requestLen = requestMsg.size() - sizeof(struct pldm_msg_hdr) -
75                             sizeof(eid) - sizeof(type);
76         try
77         {
78             response = invoker.handle(hdrFields.pldm_type, hdrFields.command,
79                                       request, requestLen);
80         }
81         catch (const std::out_of_range& e)
82         {
83             uint8_t completion_code = PLDM_ERROR_UNSUPPORTED_PLDM_CMD;
84             response.resize(sizeof(pldm_msg_hdr));
85             auto responseHdr = reinterpret_cast<pldm_msg_hdr*>(response.data());
86             pldm_header_info header{};
87             header.msg_type = PLDM_RESPONSE;
88             header.instance = hdrFields.instance;
89             header.pldm_type = hdrFields.pldm_type;
90             header.command = hdrFields.command;
91             auto result = pack_pldm_header(&header, responseHdr);
92             if (PLDM_SUCCESS != result)
93             {
94                 std::cerr << "Failed adding response header \n";
95             }
96             response.insert(response.end(), completion_code);
97         }
98     }
99     else
100     {
101         requester.markFree(eid, hdr->instance_id);
102     }
103     return response;
104 }
105 
106 void printBuffer(const std::vector<uint8_t>& buffer)
107 {
108     std::ostringstream tempStream;
109     tempStream << "Buffer Data: ";
110     if (!buffer.empty())
111     {
112         for (int byte : buffer)
113         {
114             tempStream << std::setfill('0') << std::setw(2) << std::hex << byte
115                        << " ";
116         }
117     }
118     std::cout << tempStream.str().c_str() << std::endl;
119 }
120 
121 void optionUsage(void)
122 {
123     std::cerr << "Usage: pldmd [options]\n";
124     std::cerr << "Options:\n";
125     std::cerr
126         << "  --verbose=<0/1>  0 - Disable verbosity, 1 - Enable verbosity\n";
127     std::cerr << "Defaulted settings:  --verbose=0 \n";
128 }
129 
130 int main(int argc, char** argv)
131 {
132 
133     bool verbose = false;
134     static struct option long_options[] = {
135         {"verbose", required_argument, 0, 'v'}, {0, 0, 0, 0}};
136 
137     auto argflag = getopt_long(argc, argv, "v:", long_options, nullptr);
138     switch (argflag)
139     {
140         case 'v':
141             switch (std::stoi(optarg))
142             {
143                 case 0:
144                     verbose = false;
145                     break;
146                 case 1:
147                     verbose = true;
148                     break;
149                 default:
150                     optionUsage();
151                     break;
152             }
153             break;
154         default:
155             optionUsage();
156             break;
157     }
158 
159     /* Create local socket. */
160     int returnCode = 0;
161     int sockfd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
162     if (-1 == sockfd)
163     {
164         returnCode = -errno;
165         std::cerr << "Failed to create the socket, RC= " << returnCode << "\n";
166         exit(EXIT_FAILURE);
167     }
168 
169     auto event = Event::get_default();
170     std::unique_ptr<pldm_pdr, decltype(&pldm_pdr_destroy)> pdrRepo(
171         pldm_pdr_init(), pldm_pdr_destroy);
172     std::unique_ptr<pldm_entity_association_tree,
173                     decltype(&pldm_entity_association_tree_destroy)>
174         entityTree(pldm_entity_association_tree_init(),
175                    pldm_entity_association_tree_destroy);
176     auto& bus = pldm::utils::DBusHandler::getBus();
177     dbus_api::Requester dbusImplReq(bus, "/xyz/openbmc_project/pldm");
178     std::unique_ptr<HostPDRHandler> hostPDRHandler;
179     std::unique_ptr<pldm::host_effecters::HostEffecterParser>
180         hostEffecterParser;
181     std::unique_ptr<DbusToPLDMEvent> dbusToPLDMEventHandler;
182     auto dbusHandler = std::make_unique<DBusHandler>();
183     auto hostEID = pldm::utils::readHostEID();
184     if (hostEID)
185     {
186         hostPDRHandler = std::make_unique<HostPDRHandler>(
187             sockfd, hostEID, event, pdrRepo.get(), EVENTS_JSONS_DIR,
188             entityTree.get(), dbusImplReq);
189         hostEffecterParser =
190             std::make_unique<pldm::host_effecters::HostEffecterParser>(
191                 &dbusImplReq, sockfd, pdrRepo.get(), dbusHandler.get(),
192                 HOST_JSONS_DIR, verbose);
193         dbusToPLDMEventHandler =
194             std::make_unique<DbusToPLDMEvent>(sockfd, hostEID, dbusImplReq);
195     }
196 
197     Invoker invoker{};
198     std::unique_ptr<oem_platform::Handler> oemPlatformHandler{};
199 
200 #ifdef OEM_IBM
201     std::unique_ptr<pldm::responder::CodeUpdate> codeUpdate =
202         std::make_unique<pldm::responder::CodeUpdate>(dbusHandler.get());
203     codeUpdate->clearDirPath(LID_STAGING_DIR);
204     oemPlatformHandler = std::make_unique<oem_ibm_platform::Handler>(
205         dbusHandler.get(), codeUpdate.get(), sockfd, hostEID, dbusImplReq,
206         event);
207     codeUpdate->setOemPlatformHandler(oemPlatformHandler.get());
208     invoker.registerHandler(
209         PLDM_OEM, std::make_unique<oem_ibm::Handler>(oemPlatformHandler.get()));
210 #endif
211     invoker.registerHandler(PLDM_BASE, std::make_unique<base::Handler>());
212     invoker.registerHandler(PLDM_BIOS, std::make_unique<bios::Handler>(
213                                            sockfd, hostEID, &dbusImplReq));
214     auto fruHandler = std::make_unique<fru::Handler>(
215         FRU_JSONS_DIR, pdrRepo.get(), entityTree.get());
216     // FRU table is built lazily when a FRU command or Get PDR command is
217     // handled. To enable building FRU table, the FRU handler is passed to the
218     // Platform handler.
219     auto platformHandler = std::make_unique<platform::Handler>(
220         dbusHandler.get(), PDR_JSONS_DIR, pdrRepo.get(), hostPDRHandler.get(),
221         dbusToPLDMEventHandler.get(), fruHandler.get(),
222         oemPlatformHandler.get(), true);
223 #ifdef OEM_IBM
224     pldm::responder::oem_ibm_platform::Handler* oemIbmPlatformHandler =
225         dynamic_cast<pldm::responder::oem_ibm_platform::Handler*>(
226             oemPlatformHandler.get());
227     oemIbmPlatformHandler->setPlatformHandler(platformHandler.get());
228 #endif
229 
230     invoker.registerHandler(PLDM_PLATFORM, std::move(platformHandler));
231     invoker.registerHandler(PLDM_FRU, std::move(fruHandler));
232 
233     pldm::utils::CustomFD socketFd(sockfd);
234 
235     struct sockaddr_un addr
236     {};
237     addr.sun_family = AF_UNIX;
238     const char path[] = "\0mctp-mux";
239     memcpy(addr.sun_path, path, sizeof(path) - 1);
240     int result = connect(socketFd(), reinterpret_cast<struct sockaddr*>(&addr),
241                          sizeof(path) + sizeof(addr.sun_family) - 1);
242     if (-1 == result)
243     {
244         returnCode = -errno;
245         std::cerr << "Failed to connect to the socket, RC= " << returnCode
246                   << "\n";
247         exit(EXIT_FAILURE);
248     }
249 
250     result = write(socketFd(), &MCTP_MSG_TYPE_PLDM, sizeof(MCTP_MSG_TYPE_PLDM));
251     if (-1 == result)
252     {
253         returnCode = -errno;
254         std::cerr << "Failed to send message type as pldm to mctp, RC= "
255                   << returnCode << "\n";
256         exit(EXIT_FAILURE);
257     }
258 
259     dbus_api::Pdr dbusImplPdr(bus, "/xyz/openbmc_project/pldm", pdrRepo.get());
260     sdbusplus::xyz::openbmc_project::PLDM::server::Event dbusImplEvent(
261         bus, "/xyz/openbmc_project/pldm");
262     auto callback = [verbose, &invoker, &dbusImplReq](IO& io, int fd,
263                                                       uint32_t revents) {
264         if (!(revents & EPOLLIN))
265         {
266             return;
267         }
268 
269         // Outgoing message.
270         struct iovec iov[2]{};
271 
272         // This structure contains the parameter information for the response
273         // message.
274         struct msghdr msg
275         {};
276 
277         int returnCode = 0;
278         ssize_t peekedLength = recv(fd, nullptr, 0, MSG_PEEK | MSG_TRUNC);
279         if (0 == peekedLength)
280         {
281             // MCTP daemon has closed the socket this daemon is connected to.
282             // This may or may not be an error scenario, in either case the
283             // recovery mechanism for this daemon is to restart, and hence exit
284             // the event loop, that will cause this daemon to exit with a
285             // failure code.
286             io.get_event().exit(0);
287         }
288         else if (peekedLength <= -1)
289         {
290             returnCode = -errno;
291             std::cerr << "recv system call failed, RC= " << returnCode << "\n";
292         }
293         else
294         {
295             std::vector<uint8_t> requestMsg(peekedLength);
296             auto recvDataLength = recv(
297                 fd, static_cast<void*>(requestMsg.data()), peekedLength, 0);
298             if (recvDataLength == peekedLength)
299             {
300                 if (verbose)
301                 {
302                     std::cout << "Received Msg" << std::endl;
303                     printBuffer(requestMsg);
304                 }
305                 if (MCTP_MSG_TYPE_PLDM != requestMsg[1])
306                 {
307                     // Skip this message and continue.
308                     std::cerr << "Encountered Non-PLDM type message"
309                               << "\n";
310                 }
311                 else
312                 {
313                     // process message and send response
314                     auto response =
315                         processRxMsg(requestMsg, invoker, dbusImplReq);
316                     if (!response.empty())
317                     {
318                         if (verbose)
319                         {
320                             std::cout << "Sending Msg" << std::endl;
321                             printBuffer(response);
322                         }
323 
324                         iov[0].iov_base = &requestMsg[0];
325                         iov[0].iov_len =
326                             sizeof(requestMsg[0]) + sizeof(requestMsg[1]);
327                         iov[1].iov_base = response.data();
328                         iov[1].iov_len = response.size();
329 
330                         msg.msg_iov = iov;
331                         msg.msg_iovlen = sizeof(iov) / sizeof(iov[0]);
332 
333                         int result = sendmsg(fd, &msg, 0);
334                         if (-1 == result)
335                         {
336                             returnCode = -errno;
337                             std::cerr << "sendto system call failed, RC= "
338                                       << returnCode << "\n";
339                         }
340                     }
341                 }
342             }
343             else
344             {
345                 std::cerr
346                     << "Failure to read peeked length packet. peekedLength= "
347                     << peekedLength << " recvDataLength=" << recvDataLength
348                     << "\n";
349             }
350         }
351     };
352 
353     bus.attach_event(event.get(), SD_EVENT_PRIORITY_NORMAL);
354     bus.request_name("xyz.openbmc_project.PLDM");
355     IO io(event, socketFd(), EPOLLIN, std::move(callback));
356     event.loop();
357 
358     result = shutdown(sockfd, SHUT_RDWR);
359     if (-1 == result)
360     {
361         returnCode = -errno;
362         std::cerr << "Failed to shutdown the socket, RC=" << returnCode << "\n";
363         exit(EXIT_FAILURE);
364     }
365     exit(EXIT_FAILURE);
366 }
367