xref: /openbmc/bmcweb/include/dbus_monitor.hpp (revision 4cee35e7) 
1 #pragma once
2 #include <app.hpp>
3 #include <async_resp.hpp>
4 #include <boost/container/flat_map.hpp>
5 #include <boost/container/flat_set.hpp>
6 #include <dbus_singleton.hpp>
7 #include <openbmc_dbus_rest.hpp>
8 #include <sdbusplus/bus/match.hpp>
9 #include <sdbusplus/message/types.hpp>
10 #include <websocket.hpp>
11 
12 #include <variant>
13 
14 namespace crow
15 {
16 namespace dbus_monitor
17 {
18 
19 struct DbusWebsocketSession
20 {
21     std::vector<std::unique_ptr<sdbusplus::bus::match::match>> matches;
22     boost::container::flat_set<std::string, std::less<>,
23                                std::vector<std::string>>
24         interfaces;
25 };
26 
27 static boost::container::flat_map<crow::websocket::Connection*,
28                                   DbusWebsocketSession>
29     sessions;
30 
31 inline int onPropertyUpdate(sd_bus_message* m, void* userdata,
32                             sd_bus_error* retError)
33 {
34     if (retError == nullptr || (sd_bus_error_is_set(retError) != 0))
35     {
36         BMCWEB_LOG_ERROR << "Got sdbus error on match";
37         return 0;
38     }
39     crow::websocket::Connection* connection =
40         static_cast<crow::websocket::Connection*>(userdata);
41     auto thisSession = sessions.find(connection);
42     if (thisSession == sessions.end())
43     {
44         BMCWEB_LOG_ERROR << "Couldn't find dbus connection " << connection;
45         return 0;
46     }
47     sdbusplus::message::message message(m);
48     nlohmann::json json;
49     json["event"] = message.get_member();
50     json["path"] = message.get_path();
51     if (strcmp(message.get_member(), "PropertiesChanged") == 0)
52     {
53         nlohmann::json data;
54         int r = openbmc_mapper::convertDBusToJSON("sa{sv}as", message, data);
55         if (r < 0)
56         {
57             BMCWEB_LOG_ERROR << "convertDBusToJSON failed with " << r;
58             return 0;
59         }
60         if (!data.is_array())
61         {
62             BMCWEB_LOG_ERROR << "No data in PropertiesChanged signal";
63             return 0;
64         }
65 
66         // data is type sa{sv}as and is an array[3] of string, object, array
67         json["interface"] = data[0];
68         json["properties"] = data[1];
69     }
70     else if (strcmp(message.get_member(), "InterfacesAdded") == 0)
71     {
72         nlohmann::json data;
73         int r = openbmc_mapper::convertDBusToJSON("oa{sa{sv}}", message, data);
74         if (r < 0)
75         {
76             BMCWEB_LOG_ERROR << "convertDBusToJSON failed with " << r;
77             return 0;
78         }
79 
80         if (!data.is_array())
81         {
82             BMCWEB_LOG_ERROR << "No data in InterfacesAdded signal";
83             return 0;
84         }
85 
86         // data is type oa{sa{sv}} which is an array[2] of string, object
87         for (auto& entry : data[1].items())
88         {
89             auto it = thisSession->second.interfaces.find(entry.key());
90             if (it != thisSession->second.interfaces.end())
91             {
92                 json["interfaces"][entry.key()] = entry.value();
93             }
94         }
95     }
96     else
97     {
98         BMCWEB_LOG_CRITICAL << "message " << message.get_member()
99                             << " was unexpected";
100         return 0;
101     }
102 
103     connection->sendText(
104         json.dump(2, ' ', true, nlohmann::json::error_handler_t::replace));
105     return 0;
106 }
107 
108 inline void requestRoutes(App& app)
109 {
110     BMCWEB_ROUTE(app, "/subscribe")
111         .privileges({{"Login"}})
112         .websocket()
113         .onopen([&](crow::websocket::Connection& conn) {
114             BMCWEB_LOG_DEBUG << "Connection " << &conn << " opened";
115             sessions.try_emplace(&conn);
116         })
117         .onclose([&](crow::websocket::Connection& conn, const std::string&) {
118             sessions.erase(&conn);
119         })
120         .onmessage([&](crow::websocket::Connection& conn,
121                        const std::string& data, bool) {
122             const auto sessionPair = sessions.find(&conn);
123             if (sessionPair == sessions.end())
124             {
125                 conn.close("Internal error");
126             }
127             DbusWebsocketSession& thisSession = sessionPair->second;
128             BMCWEB_LOG_DEBUG << "Connection " << &conn << " received " << data;
129             nlohmann::json j = nlohmann::json::parse(data, nullptr, false);
130             if (j.is_discarded())
131             {
132                 BMCWEB_LOG_ERROR << "Unable to parse json data for monitor";
133                 conn.close("Unable to parse json request");
134                 return;
135             }
136             nlohmann::json::iterator interfaces = j.find("interfaces");
137             if (interfaces != j.end())
138             {
139                 thisSession.interfaces.reserve(interfaces->size());
140                 for (auto& interface : *interfaces)
141                 {
142                     const std::string* str =
143                         interface.get_ptr<const std::string*>();
144                     if (str != nullptr)
145                     {
146                         thisSession.interfaces.insert(*str);
147                     }
148                 }
149             }
150 
151             nlohmann::json::iterator paths = j.find("paths");
152             if (paths == j.end())
153             {
154                 BMCWEB_LOG_ERROR << "Unable to find paths in json data";
155                 conn.close("Unable to find paths in json data");
156                 return;
157             }
158 
159             size_t interfaceCount = thisSession.interfaces.size();
160             if (interfaceCount == 0)
161             {
162                 interfaceCount = 1;
163             }
164             // Reserve our matches upfront.  For each path there is 1 for
165             // interfacesAdded, and InterfaceCount number for
166             // PropertiesChanged
167             thisSession.matches.reserve(thisSession.matches.size() +
168                                         paths->size() * (1U + interfaceCount));
169             std::string objectManagerMatchString;
170             std::string propertiesMatchString;
171             std::string objectManagerInterfacesMatchString;
172             // These regexes derived on the rules here:
173             // https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names
174             std::regex validPath("^/([A-Za-z0-9_]+/?)*$");
175             std::regex validInterface(
176                 "^[A-Za-z_][A-Za-z0-9_]*(\\.[A-Za-z_][A-Za-z0-9_]*)+$");
177 
178             for (const auto& thisPath : *paths)
179             {
180                 const std::string* thisPathString =
181                     thisPath.get_ptr<const std::string*>();
182                 if (thisPathString == nullptr)
183                 {
184                     BMCWEB_LOG_ERROR << "subscribe path isn't a string?";
185                     conn.close();
186                     return;
187                 }
188                 if (!std::regex_match(*thisPathString, validPath))
189                 {
190                     BMCWEB_LOG_ERROR << "Invalid path name " << *thisPathString;
191                     conn.close();
192                     return;
193                 }
194                 propertiesMatchString =
195                     ("type='signal',"
196                      "interface='org.freedesktop.DBus.Properties',"
197                      "path_namespace='" +
198                      *thisPathString +
199                      "',"
200                      "member='PropertiesChanged'");
201                 // If interfaces weren't specified, add a single match for all
202                 // interfaces
203                 if (thisSession.interfaces.empty())
204                 {
205                     BMCWEB_LOG_DEBUG << "Creating match "
206                                      << propertiesMatchString;
207 
208                     thisSession.matches.emplace_back(
209                         std::make_unique<sdbusplus::bus::match::match>(
210                             *crow::connections::systemBus,
211                             propertiesMatchString, onPropertyUpdate, &conn));
212                 }
213                 else
214                 {
215                     // If interfaces were specified, add a match for each
216                     // interface
217                     for (const std::string& interface : thisSession.interfaces)
218                     {
219                         if (!std::regex_match(interface, validInterface))
220                         {
221                             BMCWEB_LOG_ERROR << "Invalid interface name "
222                                              << interface;
223                             conn.close();
224                             return;
225                         }
226                         std::string ifaceMatchString = propertiesMatchString;
227                         ifaceMatchString += ",arg0='";
228                         ifaceMatchString += interface;
229                         ifaceMatchString += "'";
230                         BMCWEB_LOG_DEBUG << "Creating match "
231                                          << ifaceMatchString;
232                         thisSession.matches.emplace_back(
233                             std::make_unique<sdbusplus::bus::match::match>(
234                                 *crow::connections::systemBus, ifaceMatchString,
235                                 onPropertyUpdate, &conn));
236                     }
237                 }
238                 objectManagerMatchString =
239                     ("type='signal',"
240                      "interface='org.freedesktop.DBus.ObjectManager',"
241                      "path_namespace='" +
242                      *thisPathString +
243                      "',"
244                      "member='InterfacesAdded'");
245                 BMCWEB_LOG_DEBUG << "Creating match "
246                                  << objectManagerMatchString;
247                 thisSession.matches.emplace_back(
248                     std::make_unique<sdbusplus::bus::match::match>(
249                         *crow::connections::systemBus, objectManagerMatchString,
250                         onPropertyUpdate, &conn));
251             }
252         });
253 }
254 } // namespace dbus_monitor
255 } // namespace crow
256