1 #include "processing.hpp"
2 
3 #include <algorithm>
4 #include <array>
5 #include <iostream>
6 #include <string>
7 #include <string_view>
8 
getWellKnown(const boost::container::flat_map<std::string,std::string> & owners,const std::string & request,std::string & wellKnown)9 bool getWellKnown(
10     const boost::container::flat_map<std::string, std::string>& owners,
11     const std::string& request, std::string& wellKnown)
12 {
13     // If it's already a well known name, just return
14     if (!request.starts_with(":"))
15     {
16         wellKnown = request;
17         return true;
18     }
19 
20     auto it = owners.find(request);
21     if (it == owners.end())
22     {
23         return false;
24     }
25     wellKnown = it->second;
26     return true;
27 }
28 
needToIntrospect(const std::string & processName)29 bool needToIntrospect(const std::string& processName)
30 {
31     using namespace std::string_view_literals;
32     static constexpr std::array<std::string_view, 2> skipNamespaces{
33         ":"sv, "org.freedesktop"sv};
34 
35     auto inSkipList = std::find_if(skipNamespaces.begin(), skipNamespaces.end(),
36                                    [&processName](auto prefix) {
37                                        return processName.starts_with(prefix);
38                                    }) != skipNamespaces.end();
39     return !(inSkipList || processName.empty());
40 }
41 
processNameChangeDelete(boost::asio::io_context & io,boost::container::flat_map<std::string,std::string> & nameOwners,const std::string & wellKnown,const std::string & oldOwner,InterfaceMapType & interfaceMap,AssociationMaps & assocMaps,sdbusplus::asio::object_server & server)42 void processNameChangeDelete(
43     boost::asio::io_context& io,
44     boost::container::flat_map<std::string, std::string>& nameOwners,
45     const std::string& wellKnown, const std::string& oldOwner,
46     InterfaceMapType& interfaceMap, AssociationMaps& assocMaps,
47     sdbusplus::asio::object_server& server)
48 {
49     if (oldOwner.starts_with(":"))
50     {
51         auto it = nameOwners.find(oldOwner);
52         if (it != nameOwners.end())
53         {
54             nameOwners.erase(it);
55         }
56     }
57     // Connection removed
58     InterfaceMapType::iterator pathIt = interfaceMap.begin();
59     while (pathIt != interfaceMap.end())
60     {
61         // If an associations interface is being removed,
62         // also need to remove the corresponding associations
63         // objects and properties.
64         auto ifaces = pathIt->second.find(wellKnown);
65         if (ifaces != pathIt->second.end())
66         {
67             auto assoc = std::find(ifaces->second.begin(), ifaces->second.end(),
68                                    assocDefsInterface);
69             if (assoc != ifaces->second.end())
70             {
71                 removeAssociation(io, pathIt->first, wellKnown, server,
72                                   assocMaps);
73             }
74 
75             // Instead of checking if every single path is the endpoint of an
76             // association that needs to be moved to pending, only check when
77             // we own this path as well, which would be because of an
78             // association.
79             if ((pathIt->second.size() == 2) &&
80                 (pathIt->second.find("xyz.openbmc_project.ObjectMapper") !=
81                  pathIt->second.end()))
82             {
83                 // Remove the 2 association D-Bus paths and move the
84                 // association to pending.
85                 moveAssociationToPending(io, pathIt->first, assocMaps, server);
86             }
87         }
88         pathIt->second.erase(wellKnown);
89         if (pathIt->second.empty())
90         {
91             // If the last connection to the object is gone,
92             // delete the top level object
93             pathIt = interfaceMap.erase(pathIt);
94             continue;
95         }
96         pathIt++;
97     }
98 }
99 
processInterfaceAdded(boost::asio::io_context & io,InterfaceMapType & interfaceMap,const sdbusplus::message::object_path & objPath,const InterfacesAdded & intfAdded,const std::string & wellKnown,AssociationMaps & assocMaps,sdbusplus::asio::object_server & server)100 void processInterfaceAdded(
101     boost::asio::io_context& io, InterfaceMapType& interfaceMap,
102     const sdbusplus::message::object_path& objPath,
103     const InterfacesAdded& intfAdded, const std::string& wellKnown,
104     AssociationMaps& assocMaps, sdbusplus::asio::object_server& server)
105 {
106     auto& ifaceList = interfaceMap[objPath.str];
107 
108     for (const auto& interfacePair : intfAdded)
109     {
110         ifaceList[wellKnown].emplace(interfacePair.first);
111 
112         if (interfacePair.first == assocDefsInterface)
113         {
114             const std::variant<std::vector<Association>>* variantAssociations =
115                 nullptr;
116             for (const auto& interface : interfacePair.second)
117             {
118                 if (interface.first == assocDefsProperty)
119                 {
120                     variantAssociations = &(interface.second);
121                 }
122             }
123             if (variantAssociations == nullptr)
124             {
125                 std::cerr << "Illegal association found on " << wellKnown
126                           << "\n";
127                 continue;
128             }
129             std::vector<Association> associations =
130                 std::get<std::vector<Association>>(*variantAssociations);
131             associationChanged(io, server, associations, objPath.str, wellKnown,
132                                interfaceMap, assocMaps);
133         }
134     }
135 
136     // To handle the case where an object path is being created
137     // with 2 or more new path segments, check if the parent paths
138     // of this path are already in the interface map, and add them
139     // if they aren't with just the default freedesktop interfaces.
140     // This would be done via introspection if they would have
141     // already existed at startup.  While we could also introspect
142     // them now to do the work, we know there aren't any other
143     // interfaces or we would have gotten signals for them as well,
144     // so take a shortcut to speed things up.
145     //
146     // This is all needed so that mapper operations can be done
147     // on the new parent paths.
148     using iface_map_iterator = InterfaceMapType::iterator;
149     using name_map_iterator = InterfaceMapType::mapped_type::iterator;
150 
151     static const InterfaceNames defaultIfaces{
152         "org.freedesktop.DBus.Introspectable", "org.freedesktop.DBus.Peer",
153         "org.freedesktop.DBus.Properties"};
154 
155     std::string parent = objPath.str;
156     auto pos = parent.find_last_of('/');
157 
158     while (pos != std::string::npos)
159     {
160         parent = parent.substr(0, pos);
161 
162         std::pair<iface_map_iterator, bool> parentEntry =
163             interfaceMap.try_emplace(parent);
164 
165         std::pair<name_map_iterator, bool> ifaceEntry =
166             parentEntry.first->second.try_emplace(wellKnown, defaultIfaces);
167 
168         if (!ifaceEntry.second)
169         {
170             // Entry was already there for this name so done.
171             break;
172         }
173 
174         pos = parent.find_last_of('/');
175     }
176 
177     // The new interface might have an association pending
178     checkIfPendingAssociation(io, objPath.str, interfaceMap, assocMaps, server);
179 }
180