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 if (object.first.ends_with("/" + interfaceName))
128 {
129 objPath = object.first;
130 service = object.second.begin()->first;
131 break;
132 }
133 }
134
135 if (objPath.empty())
136 {
137 lg2::error("Can't find the object for the interface {NET_INTF}",
138 "NET_INTF", interfaceName);
139 elog<InternalFailure>();
140 }
141 }
142
143 auto method = bus.new_method_call(service.c_str(), objPath.c_str(),
144 propIntf, methodGet);
145
146 method.append(invNetworkIntf, "MACAddress");
147
148 auto reply = bus.call(method);
149 if (reply.is_method_error())
150 {
151 lg2::error(
152 "Failed to get MACAddress for path {DBUS_PATH} interface {DBUS_INTF}",
153 "DBUS_PATH", objPath, "DBUS_INTF", invNetworkIntf);
154 elog<InternalFailure>();
155 }
156
157 std::variant<std::string> value;
158 reply.read(value);
159 return stdplus::fromStr<stdplus::EtherAddr>(std::get<std::string>(value));
160 }
161
setInventoryMACOnSystem(sdbusplus::bus_t & bus,const std::string & intfname)162 bool setInventoryMACOnSystem(sdbusplus::bus_t& bus, const std::string& intfname)
163 {
164 try
165 {
166 auto inventoryMAC = getfromInventory(bus, intfname);
167 if (inventoryMAC != stdplus::EtherAddr{})
168 {
169 auto macStr = stdplus::toStr(inventoryMAC);
170 lg2::info(
171 "Mac Address {NET_MAC} in Inventory on Interface {NET_INTF}",
172 "NET_MAC", macStr, "NET_INTF", intfname);
173 setFirstBootMACOnInterface(intfname, macStr);
174 first_boot_status.push_back(intfname);
175 bool status = true;
176 for (const auto& keys : configJson.items())
177 {
178 if (!(std::find(first_boot_status.begin(),
179 first_boot_status.end(), keys.key()) !=
180 first_boot_status.end()))
181 {
182 lg2::info("Interface {NET_INTF} MAC is NOT set from VPD",
183 "NET_INTF", keys.key());
184 status = false;
185 }
186 }
187 if (status)
188 {
189 lg2::info("Removing the match for ethernet interfaces");
190 EthInterfaceMatch = nullptr;
191 }
192 }
193 else
194 {
195 lg2::info("Nothing is present in Inventory");
196 return false;
197 }
198 }
199 catch (const std::exception& e)
200 {
201 lg2::error("Exception occurred during getting of MAC "
202 "address from Inventory");
203 return false;
204 }
205 return true;
206 }
207
208 // register the matches to be monitored from inventory manager
registerSignals(sdbusplus::bus_t & bus)209 void registerSignals(sdbusplus::bus_t& bus)
210 {
211 lg2::info("Registering the Inventory Signals Matcher");
212
213 auto callback = [&](sdbusplus::message_t& m) {
214 std::map<DbusObjectPath,
215 std::map<DbusInterface, std::variant<PropertyValue>>>
216 interfacesProperties;
217
218 sdbusplus::message::object_path objPath;
219 m.read(objPath, interfacesProperties);
220
221 for (const auto& pattern : configJson.items())
222 {
223 if (objPath.str.ends_with("/" + pattern.value().get<std::string>()))
224 {
225 for (auto& interface : interfacesProperties)
226 {
227 if (interface.first == invNetworkIntf)
228 {
229 for (const auto& property : interface.second)
230 {
231 if (property.first == "MACAddress")
232 {
233 // Only set mac address on interface once the
234 // firstboot file does not exist or it is being
235 // FORCE_SYNC_MAC_FROM_INVENTORY
236 if (FORCE_SYNC_MAC_FROM_INVENTORY ||
237 !std::filesystem::exists(
238 firstBootPath + pattern.key()))
239 {
240 setFirstBootMACOnInterface(
241 pattern.key(),
242 std::get<std::string>(property.second));
243 }
244 break;
245 }
246 }
247 break;
248 }
249 }
250 }
251 }
252 };
253
254 MacAddressMatch = std::make_unique<sdbusplus::bus::match_t>(
255 bus,
256 "interface='org.freedesktop.DBus.ObjectManager',type='signal',"
257 "member='InterfacesAdded',path='/xyz/openbmc_project/"
258 "inventory'",
259 callback);
260 }
261
watchEthernetInterface(sdbusplus::bus_t & bus)262 void watchEthernetInterface(sdbusplus::bus_t& bus)
263 {
264 auto handle_interface = [&](auto infname) {
265 if (configJson.find(infname) == configJson.end())
266 {
267 // ethernet interface not found in configJSON
268 // check if it is not sit0 interface, as it is
269 // expected.
270 if (infname != "sit0")
271 {
272 lg2::error("Wrong Interface Name in Config Json");
273 }
274 }
275 else
276 {
277 registerSignals(bus);
278
279 if (setInventoryMACOnSystem(bus, infname))
280 {
281 MacAddressMatch = nullptr;
282 }
283 }
284 };
285
286 auto mycallback = [&, handle_interface](sdbusplus::message_t& m) {
287 std::map<DbusObjectPath,
288 std::map<DbusInterface, std::variant<PropertyValue>>>
289 interfacesProperties;
290
291 sdbusplus::message::object_path objPath;
292 std::pair<std::string, std::string> ethPair;
293 m.read(objPath, interfacesProperties);
294
295 for (const auto& interfaces : interfacesProperties)
296 {
297 lg2::info("Check {DBUS_INTF} for sdbus response", "DBUS_INTF",
298 interfaces.first);
299 if (interfaces.first ==
300 "xyz.openbmc_project.Network.EthernetInterface")
301 {
302 for (const auto& property : interfaces.second)
303 {
304 if (property.first == "InterfaceName")
305 {
306 handle_interface(
307 std::get<std::string>(property.second));
308
309 break;
310 }
311 }
312 break;
313 }
314 }
315 };
316
317 // The VPD may already have been assigned because phosphor-inventory-manager
318 // started ahead of the network service. Read the VPD directly and assign
319 // the MAC address despite this possibility.
320
321 for (const auto& interfaceString : configJson.items())
322 {
323 if (FORCE_SYNC_MAC_FROM_INVENTORY ||
324 !std::filesystem::exists(firstBootPath + interfaceString.key()))
325 {
326 lg2::info("Check VPD for MAC: {REASON}", "REASON",
327 (FORCE_SYNC_MAC_FROM_INVENTORY)
328 ? "Force sync enabled"
329 : "First boot file is not present");
330 EthInterfaceMatch = std::make_unique<sdbusplus::bus::match_t>(
331 bus,
332 "interface='org.freedesktop.DBus.ObjectManager',type='signal',"
333 "member='InterfacesAdded',path='/xyz/openbmc_project/network'",
334 mycallback);
335
336 for (const auto& intf : manager->interfaces)
337 {
338 if (intf.first == interfaceString.key())
339 {
340 handle_interface(intf.first);
341 }
342 }
343 }
344 }
345 }
346
watch(stdplus::PinnedRef<sdbusplus::bus_t> bus,stdplus::PinnedRef<Manager> m)347 std::unique_ptr<Runtime> watch(stdplus::PinnedRef<sdbusplus::bus_t> bus,
348 stdplus::PinnedRef<Manager> m)
349 {
350 manager = &m.get();
351 std::ifstream in(configFile);
352 in >> configJson;
353 watchEthernetInterface(bus);
354 return nullptr;
355 }
356
357 } // namespace phosphor::network::inventory
358