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