1 #include "dbus_to_event_handler.hpp"
2 
3 #include "libpldmresponder/pdr.hpp"
4 
5 #include <phosphor-logging/lg2.hpp>
6 
7 PHOSPHOR_LOG2_USING;
8 
9 namespace pldm
10 {
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, pldm::InstanceIdDb& instanceIdDb,
23     pldm::requester::Handler<pldm::requester::Request>* handler) :
24     mctp_fd(mctp_fd),
25     mctp_eid(mctp_eid), instanceIdDb(instanceIdDb), handler(handler)
26 {}
27 
28 void DbusToPLDMEvent::sendEventMsg(uint8_t eventType,
29                                    const std::vector<uint8_t>& eventDataVec)
30 {
31     auto instanceId = instanceIdDb.next(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*/, TERMINUS_ID /*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         instanceIdDb.free(mctp_eid, instanceId);
44         error("Failed to encode_platform_event_message_req, rc = {RC}", "RC",
45               rc);
46         return;
47     }
48 
49     auto platformEventMessageResponseHandler =
50         [](mctp_eid_t /*eid*/, const pldm_msg* response, size_t respMsgLen) {
51         if (response == nullptr || !respMsgLen)
52         {
53             error("Failed to receive response for platform event message");
54             return;
55         }
56         uint8_t completionCode{};
57         uint8_t status{};
58         auto rc = decode_platform_event_message_resp(response, respMsgLen,
59                                                      &completionCode, &status);
60         if (rc || completionCode)
61         {
62             error(
63                 "Failed to decode_platform_event_message_resp: rc = {RC}, cc = {CC}",
64                 "RC", rc, "CC", static_cast<unsigned>(completionCode));
65         }
66     };
67 
68     rc = handler->registerRequest(
69         mctp_eid, instanceId, PLDM_PLATFORM, PLDM_PLATFORM_EVENT_MESSAGE,
70         std::move(requestMsg), std::move(platformEventMessageResponseHandler));
71     if (rc)
72     {
73         error("Failed to send the platform event message");
74     }
75 }
76 
77 void DbusToPLDMEvent::sendStateSensorEvent(SensorId sensorId,
78                                            const DbusObjMaps& dbusMaps)
79 {
80     // Encode PLDM platform event msg to indicate a state sensor change.
81     // DSP0248_1.2.0 Table 19
82     if (!dbusMaps.contains(sensorId))
83     {
84         // this is not an error condition, if we end up here
85         // that means that the sensor with the sensor id has
86         // custom behaviour(or probably an oem sensor) in
87         // sending events that cannot be captured via standard
88         // dbus-json infastructure
89         return;
90     }
91 
92     size_t sensorEventSize = PLDM_SENSOR_EVENT_DATA_MIN_LENGTH + 1;
93     const auto& [dbusMappings, dbusValMaps] = dbusMaps.at(sensorId);
94     for (uint8_t offset = 0; offset < dbusMappings.size(); ++offset)
95     {
96         std::vector<uint8_t> sensorEventDataVec{};
97         sensorEventDataVec.resize(sensorEventSize);
98         auto eventData = reinterpret_cast<struct pldm_sensor_event_data*>(
99             sensorEventDataVec.data());
100         eventData->sensor_id = sensorId;
101         eventData->sensor_event_class_type = PLDM_STATE_SENSOR_STATE;
102         eventData->event_class[0] = offset;
103         eventData->event_class[1] = PLDM_SENSOR_UNKNOWN;
104         eventData->event_class[2] = PLDM_SENSOR_UNKNOWN;
105 
106         const auto& dbusMapping = dbusMappings[offset];
107         const auto& dbusValueMapping = dbusValMaps[offset];
108         auto stateSensorMatch = std::make_unique<sdbusplus::bus::match_t>(
109             pldm::utils::DBusHandler::getBus(),
110             propertiesChanged(dbusMapping.objectPath.c_str(),
111                               dbusMapping.interface.c_str()),
112             [this, sensorEventDataVec, dbusValueMapping,
113              dbusMapping](auto& msg) mutable {
114             DbusChangedProps props{};
115             std::string intf;
116             msg.read(intf, props);
117             if (!props.contains(dbusMapping.propertyName))
118             {
119                 return;
120             }
121             for (const auto& itr : dbusValueMapping)
122             {
123                 bool findValue = false;
124                 if (dbusMapping.propertyType == "string")
125                 {
126                     std::string src = std::get<std::string>(itr.second);
127                     std::string dst = std::get<std::string>(
128                         props.at(dbusMapping.propertyName));
129 
130                     auto values = pldm::utils::split(src, "||", " ");
131                     for (auto& value : values)
132                     {
133                         if (value == dst)
134                         {
135                             findValue = true;
136                             break;
137                         }
138                     }
139                 }
140                 else
141                 {
142                     findValue = itr.second == props.at(dbusMapping.propertyName)
143                                     ? true
144                                     : false;
145                 }
146 
147                 if (findValue)
148                 {
149                     auto eventData =
150                         reinterpret_cast<struct pldm_sensor_event_data*>(
151                             sensorEventDataVec.data());
152                     eventData->event_class[1] = itr.first;
153                     eventData->event_class[2] = itr.first;
154                     this->sendEventMsg(PLDM_SENSOR_EVENT, sensorEventDataVec);
155                     break;
156                 }
157             }
158         });
159         stateSensorMatchs.emplace_back(std::move(stateSensorMatch));
160     }
161 }
162 
163 void DbusToPLDMEvent::listenSensorEvent(const pdr_utils::Repo& repo,
164                                         const DbusObjMaps& dbusMaps)
165 {
166     const std::map<Type, sensorEvent> sensorHandlers = {
167         {PLDM_STATE_SENSOR_PDR,
168          [this](SensorId sensorId, const DbusObjMaps& dbusMaps) {
169         this->sendStateSensorEvent(sensorId, dbusMaps);
170     }}};
171 
172     pldm_state_sensor_pdr* pdr = nullptr;
173     std::unique_ptr<pldm_pdr, decltype(&pldm_pdr_destroy)> sensorPdrRepo(
174         pldm_pdr_init(), pldm_pdr_destroy);
175     if (!sensorPdrRepo)
176     {
177         throw std::runtime_error("Unable to instantiate sensor PDR repository");
178     }
179 
180     for (auto pdrType : pdrTypes)
181     {
182         Repo sensorPDRs(sensorPdrRepo.get());
183         getRepoByType(repo, sensorPDRs, pdrType);
184         if (sensorPDRs.empty())
185         {
186             return;
187         }
188 
189         PdrEntry pdrEntry{};
190         auto pdrRecord = sensorPDRs.getFirstRecord(pdrEntry);
191         while (pdrRecord)
192         {
193             pdr = reinterpret_cast<pldm_state_sensor_pdr*>(pdrEntry.data);
194             SensorId sensorId = LE16TOH(pdr->sensor_id);
195             if (sensorHandlers.contains(pdrType))
196             {
197                 sensorHandlers.at(pdrType)(sensorId, dbusMaps);
198             }
199 
200             pdrRecord = sensorPDRs.getNextRecord(pdrRecord, pdrEntry);
201         }
202     }
203 }
204 
205 } // namespace state_sensor
206 } // namespace pldm
207