1 // Copyright 2021 Google LLC 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 #include "net_config.h" 16 17 #include <linux/if.h> 18 #include <net/if_arp.h> 19 #include <sys/ioctl.h> 20 #include <sys/types.h> 21 #include <sys/wait.h> 22 #include <unistd.h> 23 24 #include <sdbusplus/bus.hpp> 25 #include <stdplus/fd/create.hpp> 26 #include <stdplus/fd/ops.hpp> 27 #include <stdplus/print.hpp> 28 #include <stdplus/util/string.hpp> 29 30 #include <cstdio> 31 #include <cstring> 32 #include <filesystem> 33 #include <format> 34 #include <thread> 35 #include <utility> 36 #include <variant> 37 38 /* Most of the code for interacting with DBus is from 39 * phosphor-host-ipmid/utils.cpp 40 */ 41 42 namespace net 43 { 44 45 namespace 46 { 47 48 constexpr auto IFACE_ROOT = "/xyz/openbmc_project/network/"; 49 constexpr auto MAC_FORMAT = "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx"; 50 // 2 chars for every byte + 5 colons + Null byte 51 constexpr auto MAC_FORMAT_LENGTH = 6 * 2 + 5 + 1; 52 constexpr auto MAC_INTERFACE = "xyz.openbmc_project.Network.MACAddress"; 53 constexpr auto NETWORK_SERVICE = "xyz.openbmc_project.Network"; 54 constexpr auto PROP_INTERFACE = "org.freedesktop.DBus.Properties"; 55 56 std::string format_mac(const mac_addr_t& mac) 57 { 58 // 2 chars for every byte + 5 colons + Null byte 59 char mac_str[MAC_FORMAT_LENGTH]; 60 snprintf(mac_str, sizeof(mac_str), MAC_FORMAT, mac.octet[0], mac.octet[1], 61 mac.octet[2], mac.octet[3], mac.octet[4], mac.octet[5]); 62 63 return std::string{mac_str}; 64 } 65 66 } // namespace 67 68 PhosphorConfig::PhosphorConfig(const std::string& iface_name) : 69 iface_name_{iface_name}, iface_path_{std::string(IFACE_ROOT) + iface_name}, 70 shared_host_mac_(std::experimental::nullopt), 71 bus(sdbusplus::bus::new_default()) 72 {} 73 74 int PhosphorConfig::get_mac_addr(mac_addr_t* mac) 75 { 76 if (mac == nullptr) 77 { 78 stdplus::println(stderr, "mac is nullptr"); 79 return -1; 80 } 81 82 // Cache hit: we have stored host MAC. 83 if (shared_host_mac_) 84 { 85 *mac = shared_host_mac_.value(); 86 } 87 else // Cache miss: read from interface, cache it for future requests. 88 { 89 struct ifreq ifr = {}; 90 try 91 { 92 auto fd = stdplus::fd::socket(stdplus::fd::SocketDomain::INet6, 93 stdplus::fd::SocketType::Datagram, 94 stdplus::fd::SocketProto::IP); 95 call_nic(fd, ifr, SIOCGIFHWADDR); 96 } 97 catch (const std::exception& ex) 98 { 99 stdplus::println( 100 stderr, 101 "Failed to get MAC Addr for Interface {} writing file: {}", 102 iface_name_, ex.what()); 103 return -1; 104 } 105 std::copy_n(ifr.ifr_addr.sa_data, sizeof(*mac), mac->octet); 106 shared_host_mac_ = *mac; 107 } 108 return 0; 109 } 110 111 void PhosphorConfig::call_nic(auto fd, struct ifreq& ifr, int op) 112 { 113 std::copy_n(iface_name_.c_str(), iface_name_.size() + 1, ifr.ifr_name); 114 fd.ioctl(op, &ifr); 115 } 116 117 int PhosphorConfig::set_mac_addr(const mac_addr_t& mac) 118 { 119 std::variant<std::string> mac_value(format_mac(mac)); 120 struct ifreq ifr = {}; 121 short flags_copy; 122 123 try 124 { 125 auto netdir = std::format("/run/systemd/network/00-bmc-{}.network.d", 126 iface_name_); 127 std::filesystem::create_directories(netdir); 128 auto netfile = std::format("{}/60-ncsi-mac.conf", netdir); 129 auto fd = stdplus::fd::open( 130 netfile, 131 stdplus::fd::OpenFlags(stdplus::fd::OpenAccess::WriteOnly) 132 .set(stdplus::fd::OpenFlag::Create), 133 0644); 134 auto contents = std::format("[Link]\nMACAddress={}\n", 135 std::get<std::string>(mac_value)); 136 stdplus::fd::writeExact(fd, contents); 137 } 138 catch (const std::exception& ex) 139 { 140 stdplus::println(stderr, "Failed to set MAC Addr `{}` writing file: {}", 141 std::get<std::string>(mac_value), ex.what()); 142 return -1; 143 } 144 try 145 { 146 auto fd = stdplus::fd::socket(stdplus::fd::SocketDomain::INet6, 147 stdplus::fd::SocketType::Datagram, 148 stdplus::fd::SocketProto::IP); 149 // Try setting MAC Address directly without bringing interface down 150 try 151 { 152 std::copy_n(mac.octet, 6, ifr.ifr_hwaddr.sa_data); 153 call_nic(fd, ifr, SIOCSIFHWADDR); 154 } 155 catch (const std::exception& e) 156 { 157 // Regardless of error attempt to set MAC Address again after 158 // bringing interface down 159 stdplus::println( 160 stderr, 161 "Could not set MAC Address directly, retrying after bringing interface down, error = {}", 162 e.what()); 163 try 164 { 165 // Read interface flags configuration and store (once interface 166 // is brought down, existing state is lost) 167 call_nic(fd, ifr, SIOCGIFFLAGS); 168 flags_copy = ifr.ifr_flags; 169 // set interface down 170 ifr.ifr_flags &= ~IFF_UP; 171 call_nic(fd, ifr, SIOCSIFFLAGS); 172 // Wait for 1 milliseconds - sometimes interface is still 173 // going down 174 std::this_thread::sleep_for(std::chrono::milliseconds(1)); 175 // set MAC Address 176 ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER; 177 std::copy_n(mac.octet, 6, ifr.ifr_hwaddr.sa_data); 178 call_nic(fd, ifr, SIOCSIFHWADDR); 179 // set interface up with the flags state prior to bringing 180 // it down 181 ifr.ifr_flags = flags_copy | IFF_UP; 182 call_nic(fd, ifr, SIOCSIFFLAGS); 183 } 184 catch (const std::exception& e) 185 { 186 stdplus::println( 187 stderr, "Failed to set MAC Address {} writing file: {}", 188 std::get<std::string>(mac_value), e.what()); 189 return -1; 190 } 191 } 192 } 193 catch (const std::exception& e) 194 { 195 stdplus::println(stderr, "Error creating socket: {}", e.what()); 196 return -1; 197 } 198 stdplus::println(stderr, "Success setting Mac address for {}: {}", 199 iface_name_, std::get<std::string>(mac_value)); 200 shared_host_mac_ = std::experimental::nullopt; 201 return 0; 202 } 203 204 int PhosphorConfig::set_nic_hostless(bool is_nic_hostless) 205 { 206 // Ensure that we don't trigger the target multiple times. This is 207 // undesirable because it will cause any inactive services to re-trigger 208 // every time we run this code. Since the loop calling this executes this 209 // code every 1s, we don't want to keep re-executing services. A fresh 210 // start of the daemon will always trigger the service to ensure system 211 // consistency. 212 if (was_nic_hostless_ && is_nic_hostless == *was_nic_hostless_) 213 { 214 return 0; 215 } 216 217 static constexpr auto systemdService = "org.freedesktop.systemd1"; 218 static constexpr auto systemdRoot = "/org/freedesktop/systemd1"; 219 static constexpr auto systemdInterface = "org.freedesktop.systemd1.Manager"; 220 221 auto method = bus.new_method_call(systemdService, systemdRoot, 222 systemdInterface, "StartUnit"); 223 if (is_nic_hostless) 224 { 225 method.append( 226 stdplus::util::strCat("nic-hostless@", iface_name_, ".target")); 227 } 228 else 229 { 230 method.append( 231 stdplus::util::strCat("nic-hostful@", iface_name_, ".target")); 232 } 233 234 // Specify --job-mode (see systemctl(1) for detail). 235 method.append("replace"); 236 237 try 238 { 239 bus.call_noreply(method); 240 was_nic_hostless_ = is_nic_hostless; 241 return 0; 242 } 243 catch (const sdbusplus::exception::SdBusError& ex) 244 { 245 stdplus::println(stderr, "Failed to set systemd nic status: {}", 246 ex.what()); 247 return 1; 248 } 249 } 250 251 } // namespace net 252