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 // Only set mac address on interface once the
235 // firstboot file does not exist or it is being
236 // FORCE_SYNC_MAC_FROM_INVENTORY
237 if (FORCE_SYNC_MAC_FROM_INVENTORY ||
238 !std::filesystem::exists(
239 firstBootPath + pattern.key()))
240 {
241 setFirstBootMACOnInterface(
242 pattern.key(),
243 std::get<std::string>(property.second));
244 }
245 break;
246 }
247 }
248 break;
249 }
250 }
251 }
252 }
253 };
254
255 MacAddressMatch = std::make_unique<sdbusplus::bus::match_t>(
256 bus,
257 "interface='org.freedesktop.DBus.ObjectManager',type='signal',"
258 "member='InterfacesAdded',path='/xyz/openbmc_project/"
259 "inventory'",
260 callback);
261 }
262
watchEthernetInterface(sdbusplus::bus_t & bus)263 void watchEthernetInterface(sdbusplus::bus_t& bus)
264 {
265 auto handle_interface = [&](auto infname) {
266 if (configJson.find(infname) == configJson.end())
267 {
268 // ethernet interface not found in configJSON
269 // check if it is not sit0 interface, as it is
270 // expected.
271 if (infname != "sit0")
272 {
273 lg2::error("Wrong Interface Name in Config Json");
274 }
275 }
276 else
277 {
278 registerSignals(bus);
279
280 if (setInventoryMACOnSystem(bus, infname))
281 {
282 MacAddressMatch = nullptr;
283 }
284 }
285 };
286
287 auto mycallback = [&, handle_interface](sdbusplus::message_t& m) {
288 std::map<DbusObjectPath,
289 std::map<DbusInterface, std::variant<PropertyValue>>>
290 interfacesProperties;
291
292 sdbusplus::message::object_path objPath;
293 std::pair<std::string, std::string> ethPair;
294 m.read(objPath, interfacesProperties);
295
296 for (const auto& interfaces : interfacesProperties)
297 {
298 lg2::info("Check {DBUS_INTF} for sdbus response", "DBUS_INTF",
299 interfaces.first);
300 if (interfaces.first ==
301 "xyz.openbmc_project.Network.EthernetInterface")
302 {
303 for (const auto& property : interfaces.second)
304 {
305 if (property.first == "InterfaceName")
306 {
307 handle_interface(
308 std::get<std::string>(property.second));
309
310 break;
311 }
312 }
313 break;
314 }
315 }
316 };
317
318 // The VPD may already have been assigned because phosphor-inventory-manager
319 // started ahead of the network service. Read the VPD directly and assign
320 // the MAC address despite this possibility.
321
322 for (const auto& interfaceString : configJson.items())
323 {
324 if (FORCE_SYNC_MAC_FROM_INVENTORY ||
325 !std::filesystem::exists(firstBootPath + interfaceString.key()))
326 {
327 lg2::info("Check VPD for MAC: {REASON}", "REASON",
328 (FORCE_SYNC_MAC_FROM_INVENTORY)
329 ? "Force sync enabled"
330 : "First boot file is not present");
331 EthInterfaceMatch = std::make_unique<sdbusplus::bus::match_t>(
332 bus,
333 "interface='org.freedesktop.DBus.ObjectManager',type='signal',"
334 "member='InterfacesAdded',path='/xyz/openbmc_project/network'",
335 mycallback);
336
337 for (const auto& intf : manager->interfaces)
338 {
339 if (intf.first == interfaceString.key())
340 {
341 handle_interface(intf.first);
342 }
343 }
344 }
345 }
346 }
347
watch(stdplus::PinnedRef<sdbusplus::bus_t> bus,stdplus::PinnedRef<Manager> m)348 std::unique_ptr<Runtime> watch(stdplus::PinnedRef<sdbusplus::bus_t> bus,
349 stdplus::PinnedRef<Manager> m)
350 {
351 manager = &m.get();
352 std::ifstream in(configFile);
353 in >> configJson;
354 watchEthernetInterface(bus);
355 return nullptr;
356 }
357
358 } // namespace phosphor::network::inventory
359