1 #include "config.h"
2 
3 #include "inventory_mac.hpp"
4 
5 #include "network_manager.hpp"
6 #include "types.hpp"
7 
8 #include <nlohmann/json.hpp>
9 #include <phosphor-logging/elog-errors.hpp>
10 #include <phosphor-logging/lg2.hpp>
11 #include <sdbusplus/bus.hpp>
12 #include <sdbusplus/bus/match.hpp>
13 #include <stdplus/str/maps.hpp>
14 #include <xyz/openbmc_project/Common/error.hpp>
15 
16 #include <filesystem>
17 #include <fstream>
18 #include <memory>
19 #include <string>
20 #include <vector>
21 
22 namespace phosphor::network::inventory
23 {
24 
25 using phosphor::logging::elog;
26 using sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
27 
28 using DbusObjectPath = std::string;
29 using DbusInterface = std::string;
30 using PropertyValue = std::string;
31 using DbusService = std::string;
32 using ObjectTree =
33     stdplus::string_umap<stdplus::string_umap<std::vector<std::string>>>;
34 
35 constexpr auto firstBootPath = "/var/lib/network/firstBoot_";
36 constexpr auto configFile = "/usr/share/network/config.json";
37 
38 constexpr auto invNetworkIntf =
39     "xyz.openbmc_project.Inventory.Item.NetworkInterface";
40 constexpr auto invRoot = "/xyz/openbmc_project/inventory";
41 constexpr auto mapperBus = "xyz.openbmc_project.ObjectMapper";
42 constexpr auto mapperObj = "/xyz/openbmc_project/object_mapper";
43 constexpr auto mapperIntf = "xyz.openbmc_project.ObjectMapper";
44 constexpr auto propIntf = "org.freedesktop.DBus.Properties";
45 constexpr auto methodGet = "Get";
46 
47 Manager* manager = nullptr;
48 std::unique_ptr<sdbusplus::bus::match_t> EthInterfaceMatch = nullptr;
49 std::unique_ptr<sdbusplus::bus::match_t> MacAddressMatch = nullptr;
50 std::vector<std::string> first_boot_status;
51 nlohmann::json configJson;
52 
setFirstBootMACOnInterface(const std::string & intf,const std::string & mac)53 void setFirstBootMACOnInterface(const std::string& intf, const std::string& mac)
54 {
55     for (const auto& interface : manager->interfaces)
56     {
57         if (interface.first == intf)
58         {
59             auto returnMAC = interface.second->macAddress(mac);
60             if (returnMAC == mac)
61             {
62                 lg2::info("Setting MAC {NET_MAC} on interface {NET_INTF}",
63                           "NET_MAC", mac, "NET_INTF", intf);
64                 std::error_code ec;
65                 if (std::filesystem::is_directory("/var/lib/network", ec))
66                 {
67                     std::ofstream persistentFile(firstBootPath + intf);
68                 }
69                 break;
70             }
71             else
72             {
73                 lg2::info("MAC is Not Set on ethernet Interface");
74             }
75         }
76     }
77 }
78 
getfromInventory(sdbusplus::bus_t & bus,const std::string & intfName)79 stdplus::EtherAddr getfromInventory(sdbusplus::bus_t& bus,
80                                     const std::string& intfName)
81 {
82     std::string interfaceName = configJson[intfName];
83 
84     std::vector<DbusInterface> interfaces;
85     interfaces.emplace_back(invNetworkIntf);
86 
87     auto depth = 0;
88 
89     auto mapperCall =
90         bus.new_method_call(mapperBus, mapperObj, mapperIntf, "GetSubTree");
91 
92     mapperCall.append(invRoot, depth, interfaces);
93 
94     auto mapperReply = bus.call(mapperCall);
95     if (mapperReply.is_method_error())
96     {
97         lg2::error("Error in mapper call");
98         elog<InternalFailure>();
99     }
100 
101     ObjectTree objectTree;
102     mapperReply.read(objectTree);
103 
104     if (objectTree.empty())
105     {
106         lg2::error("No Object has implemented the interface {NET_INTF}",
107                    "NET_INTF", invNetworkIntf);
108         elog<InternalFailure>();
109     }
110 
111     DbusObjectPath objPath;
112     DbusService service;
113 
114     if (1 == objectTree.size())
115     {
116         objPath = objectTree.begin()->first;
117         service = objectTree.begin()->second.begin()->first;
118     }
119     else
120     {
121         // If there are more than 2 objects, object path must contain the
122         // interface name
123         for (const auto& object : objectTree)
124         {
125             lg2::info("Get info on interface {NET_INTF}, object {OBJ}",
126                       "NET_INTF", interfaceName, "OBJ", object.first);
127 
128             if (std::string::npos != object.first.find(interfaceName.c_str()))
129             {
130                 objPath = object.first;
131                 service = object.second.begin()->first;
132                 break;
133             }
134         }
135 
136         if (objPath.empty())
137         {
138             lg2::error("Can't find the object for the interface {NET_INTF}",
139                        "NET_INTF", interfaceName);
140             elog<InternalFailure>();
141         }
142     }
143 
144     auto method = bus.new_method_call(service.c_str(), objPath.c_str(),
145                                       propIntf, methodGet);
146 
147     method.append(invNetworkIntf, "MACAddress");
148 
149     auto reply = bus.call(method);
150     if (reply.is_method_error())
151     {
152         lg2::error(
153             "Failed to get MACAddress for path {DBUS_PATH} interface {DBUS_INTF}",
154             "DBUS_PATH", objPath, "DBUS_INTF", invNetworkIntf);
155         elog<InternalFailure>();
156     }
157 
158     std::variant<std::string> value;
159     reply.read(value);
160     return stdplus::fromStr<stdplus::EtherAddr>(std::get<std::string>(value));
161 }
162 
setInventoryMACOnSystem(sdbusplus::bus_t & bus,const std::string & intfname)163 bool setInventoryMACOnSystem(sdbusplus::bus_t& bus, const std::string& intfname)
164 {
165     try
166     {
167         auto inventoryMAC = getfromInventory(bus, intfname);
168         if (inventoryMAC != stdplus::EtherAddr{})
169         {
170             auto macStr = stdplus::toStr(inventoryMAC);
171             lg2::info(
172                 "Mac Address {NET_MAC} in Inventory on Interface {NET_INTF}",
173                 "NET_MAC", macStr, "NET_INTF", intfname);
174             setFirstBootMACOnInterface(intfname, macStr);
175             first_boot_status.push_back(intfname);
176             bool status = true;
177             for (const auto& keys : configJson.items())
178             {
179                 if (!(std::find(first_boot_status.begin(),
180                                 first_boot_status.end(), keys.key()) !=
181                       first_boot_status.end()))
182                 {
183                     lg2::info("Interface {NET_INTF} MAC is NOT set from VPD",
184                               "NET_INTF", keys.key());
185                     status = false;
186                 }
187             }
188             if (status)
189             {
190                 lg2::info("Removing the match for ethernet interfaces");
191                 EthInterfaceMatch = nullptr;
192             }
193         }
194         else
195         {
196             lg2::info("Nothing is present in Inventory");
197             return false;
198         }
199     }
200     catch (const std::exception& e)
201     {
202         lg2::error("Exception occurred during getting of MAC "
203                    "address from Inventory");
204         return false;
205     }
206     return true;
207 }
208 
209 // register the matches to be monitored from inventory manager
registerSignals(sdbusplus::bus_t & bus)210 void registerSignals(sdbusplus::bus_t& bus)
211 {
212     lg2::info("Registering the Inventory Signals Matcher");
213 
214     auto callback = [&](sdbusplus::message_t& m) {
215         std::map<DbusObjectPath,
216                  std::map<DbusInterface, std::variant<PropertyValue>>>
217             interfacesProperties;
218 
219         sdbusplus::message::object_path objPath;
220         m.read(objPath, interfacesProperties);
221 
222         for (const auto& pattern : configJson.items())
223         {
224             if (objPath.str.find(pattern.value()) != std::string::npos)
225             {
226                 for (auto& interface : interfacesProperties)
227                 {
228                     if (interface.first == invNetworkIntf)
229                     {
230                         for (const auto& property : interface.second)
231                         {
232                             if (property.first == "MACAddress")
233                             {
234                                 setFirstBootMACOnInterface(
235                                     pattern.key(),
236                                     std::get<std::string>(property.second));
237                                 break;
238                             }
239                         }
240                         break;
241                     }
242                 }
243             }
244         }
245     };
246 
247     MacAddressMatch = std::make_unique<sdbusplus::bus::match_t>(
248         bus,
249         "interface='org.freedesktop.DBus.ObjectManager',type='signal',"
250         "member='InterfacesAdded',path='/xyz/openbmc_project/"
251         "inventory'",
252         callback);
253 }
254 
watchEthernetInterface(sdbusplus::bus_t & bus)255 void watchEthernetInterface(sdbusplus::bus_t& bus)
256 {
257     auto handle_interface = [&](auto infname) {
258         if (configJson.find(infname) == configJson.end())
259         {
260             // ethernet interface not found in configJSON
261             // check if it is not sit0 interface, as it is
262             // expected.
263             if (infname != "sit0")
264             {
265                 lg2::error("Wrong Interface Name in Config Json");
266             }
267         }
268         else
269         {
270             registerSignals(bus);
271 
272             if (setInventoryMACOnSystem(bus, infname))
273             {
274                 MacAddressMatch = nullptr;
275             }
276         }
277     };
278 
279     auto mycallback = [&, handle_interface](sdbusplus::message_t& m) {
280         std::map<DbusObjectPath,
281                  std::map<DbusInterface, std::variant<PropertyValue>>>
282             interfacesProperties;
283 
284         sdbusplus::message::object_path objPath;
285         std::pair<std::string, std::string> ethPair;
286         m.read(objPath, interfacesProperties);
287 
288         for (const auto& interfaces : interfacesProperties)
289         {
290             lg2::info("Check {DBUS_INTF} for sdbus response", "DBUS_INTF",
291                       interfaces.first);
292             if (interfaces.first ==
293                 "xyz.openbmc_project.Network.EthernetInterface")
294             {
295                 for (const auto& property : interfaces.second)
296                 {
297                     if (property.first == "InterfaceName")
298                     {
299                         handle_interface(
300                             std::get<std::string>(property.second));
301 
302                         break;
303                     }
304                 }
305                 break;
306             }
307         }
308     };
309 
310     // The VPD may already have been assigned because phosphor-inventory-manager
311     // started ahead of the network service. Read the VPD directly and assign
312     // the MAC address despite this possibility.
313 
314     for (const auto& interfaceString : configJson.items())
315     {
316         if (FORCE_SYNC_MAC_FROM_INVENTORY ||
317             !std::filesystem::exists(firstBootPath + interfaceString.key()))
318         {
319             lg2::info("Check VPD for MAC: {REASON}", "REASON",
320                       (FORCE_SYNC_MAC_FROM_INVENTORY)
321                           ? "Force sync enabled"
322                           : "First boot file is not present");
323             EthInterfaceMatch = std::make_unique<sdbusplus::bus::match_t>(
324                 bus,
325                 "interface='org.freedesktop.DBus.ObjectManager',type='signal',"
326                 "member='InterfacesAdded',path='/xyz/openbmc_project/network'",
327                 mycallback);
328 
329             for (const auto& intf : manager->interfaces)
330             {
331                 if (intf.first == interfaceString.key())
332                 {
333                     handle_interface(intf.first);
334                 }
335             }
336         }
337     }
338 }
339 
watch(stdplus::PinnedRef<sdbusplus::bus_t> bus,stdplus::PinnedRef<Manager> m)340 std::unique_ptr<Runtime> watch(stdplus::PinnedRef<sdbusplus::bus_t> bus,
341                                stdplus::PinnedRef<Manager> m)
342 {
343     manager = &m.get();
344     std::ifstream in(configFile);
345     in >> configJson;
346     watchEthernetInterface(bus);
347     return nullptr;
348 }
349 
350 } // namespace phosphor::network::inventory
351