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