1 #include "dbus_to_event_handler.hpp"
2 
3 #include "libpldm/requester/pldm.h"
4 
5 #include "libpldmresponder/pdr.hpp"
6 
7 namespace pldm
8 {
9 
10 using namespace pldm::dbus_api;
11 using namespace pldm::responder;
12 using namespace pldm::responder::pdr;
13 using namespace pldm::responder::pdr_utils;
14 using namespace pldm::utils;
15 using namespace sdbusplus::bus::match::rules;
16 
17 namespace state_sensor
18 {
19 const std::vector<uint8_t> pdrTypes{PLDM_STATE_SENSOR_PDR};
20 
21 DbusToPLDMEvent::DbusToPLDMEvent(
22     int mctp_fd, uint8_t mctp_eid, Requester& requester,
23     pldm::requester::Handler<pldm::requester::Request>* handler) :
24     mctp_fd(mctp_fd),
25     mctp_eid(mctp_eid), requester(requester), handler(handler)
26 {}
27 
28 void DbusToPLDMEvent::sendEventMsg(uint8_t eventType,
29                                    const std::vector<uint8_t>& eventDataVec)
30 {
31     auto instanceId = requester.getInstanceId(mctp_eid);
32     std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
33                                     PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
34                                     eventDataVec.size());
35     auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
36 
37     auto rc = encode_platform_event_message_req(
38         instanceId, 1 /*formatVersion*/, 0 /*tId*/, eventType,
39         eventDataVec.data(), eventDataVec.size(), request,
40         eventDataVec.size() + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES);
41     if (rc != PLDM_SUCCESS)
42     {
43         requester.markFree(mctp_eid, instanceId);
44         std::cerr << "Failed to encode_platform_event_message_req, rc = " << rc
45                   << std::endl;
46         return;
47     }
48 
49     auto platformEventMessageResponseHandler = [](mctp_eid_t /*eid*/,
50                                                   const pldm_msg* response,
51                                                   size_t respMsgLen) {
52         if (response == nullptr || !respMsgLen)
53         {
54             std::cerr
55                 << "Failed to receive response for platform event message \n";
56             return;
57         }
58         uint8_t completionCode{};
59         uint8_t status{};
60         auto rc = decode_platform_event_message_resp(response, respMsgLen,
61                                                      &completionCode, &status);
62         if (rc || completionCode)
63         {
64             std::cerr << "Failed to decode_platform_event_message_resp: "
65                       << "rc=" << rc
66                       << ", cc=" << static_cast<unsigned>(completionCode)
67                       << std::endl;
68         }
69     };
70 
71     rc = handler->registerRequest(
72         mctp_eid, instanceId, PLDM_PLATFORM, PLDM_PLATFORM_EVENT_MESSAGE,
73         std::move(requestMsg), std::move(platformEventMessageResponseHandler));
74     if (rc)
75     {
76         std::cerr << "Failed to send the platform event message \n";
77     }
78 }
79 
80 void DbusToPLDMEvent::sendStateSensorEvent(SensorId sensorId,
81                                            const DbusObjMaps& dbusMaps)
82 {
83     // Encode PLDM platform event msg to indicate a state sensor change.
84     // DSP0248_1.2.0 Table 19
85     if (!dbusMaps.contains(sensorId))
86     {
87         // this is not an error condition, if we end up here
88         // that means that the sensor with the sensor id has
89         // custom behaviour(or probably an oem sensor) in
90         // sending events that cannot be captured via standard
91         // dbus-json infastructure
92         return;
93     }
94 
95     size_t sensorEventSize = PLDM_SENSOR_EVENT_DATA_MIN_LENGTH + 1;
96     const auto& [dbusMappings, dbusValMaps] = dbusMaps.at(sensorId);
97     for (uint8_t offset = 0; offset < dbusMappings.size(); ++offset)
98     {
99         std::vector<uint8_t> sensorEventDataVec{};
100         sensorEventDataVec.resize(sensorEventSize);
101         auto eventData = reinterpret_cast<struct pldm_sensor_event_data*>(
102             sensorEventDataVec.data());
103         eventData->sensor_id = sensorId;
104         eventData->sensor_event_class_type = PLDM_STATE_SENSOR_STATE;
105         eventData->event_class[0] = offset;
106         eventData->event_class[1] = PLDM_SENSOR_UNKNOWN;
107         eventData->event_class[2] = PLDM_SENSOR_UNKNOWN;
108 
109         const auto& dbusMapping = dbusMappings[offset];
110         const auto& dbusValueMapping = dbusValMaps[offset];
111         auto stateSensorMatch = std::make_unique<sdbusplus::bus::match::match>(
112             pldm::utils::DBusHandler::getBus(),
113             propertiesChanged(dbusMapping.objectPath.c_str(),
114                               dbusMapping.interface.c_str()),
115             [this, sensorEventDataVec, dbusValueMapping,
116              dbusMapping](auto& msg) mutable {
117                 DbusChangedProps props{};
118                 std::string intf;
119                 msg.read(intf, props);
120                 if (!props.contains(dbusMapping.propertyName))
121                 {
122                     return;
123                 }
124                 for (const auto& itr : dbusValueMapping)
125                 {
126                     if (itr.second == props.at(dbusMapping.propertyName))
127                     {
128                         auto eventData =
129                             reinterpret_cast<struct pldm_sensor_event_data*>(
130                                 sensorEventDataVec.data());
131                         eventData->event_class[1] = itr.first;
132                         eventData->event_class[2] = itr.first;
133                         this->sendEventMsg(PLDM_SENSOR_EVENT,
134                                            sensorEventDataVec);
135                     }
136                 }
137             });
138         stateSensorMatchs.emplace_back(std::move(stateSensorMatch));
139     }
140 }
141 
142 void DbusToPLDMEvent::listenSensorEvent(const pdr_utils::Repo& repo,
143                                         const DbusObjMaps& dbusMaps)
144 {
145     const std::map<Type, sensorEvent> sensorHandlers = {
146         {PLDM_STATE_SENSOR_PDR,
147          [this](SensorId sensorId, const DbusObjMaps& dbusMaps) {
148              this->sendStateSensorEvent(sensorId, dbusMaps);
149          }}};
150 
151     pldm_state_sensor_pdr* pdr = nullptr;
152     std::unique_ptr<pldm_pdr, decltype(&pldm_pdr_destroy)> sensorPdrRepo(
153         pldm_pdr_init(), pldm_pdr_destroy);
154 
155     for (auto pdrType : pdrTypes)
156     {
157         Repo sensorPDRs(sensorPdrRepo.get());
158         getRepoByType(repo, sensorPDRs, pdrType);
159         if (sensorPDRs.empty())
160         {
161             return;
162         }
163 
164         PdrEntry pdrEntry{};
165         auto pdrRecord = sensorPDRs.getFirstRecord(pdrEntry);
166         while (pdrRecord)
167         {
168             pdr = reinterpret_cast<pldm_state_sensor_pdr*>(pdrEntry.data);
169             SensorId sensorId = LE16TOH(pdr->sensor_id);
170             if (sensorHandlers.contains(pdrType))
171             {
172                 sensorHandlers.at(pdrType)(sensorId, dbusMaps);
173             }
174 
175             pdrRecord = sensorPDRs.getNextRecord(pdrRecord, pdrEntry);
176         }
177     }
178 }
179 
180 } // namespace state_sensor
181 } // namespace pldm
182