1 #include "config.h" 2 3 #include "util.hpp" 4 5 #include "config_parser.hpp" 6 #include "types.hpp" 7 8 #include <fmt/compile.h> 9 #include <fmt/format.h> 10 #include <sys/wait.h> 11 12 #include <phosphor-logging/elog-errors.hpp> 13 #include <phosphor-logging/lg2.hpp> 14 #include <stdplus/numeric/str.hpp> 15 #include <xyz/openbmc_project/Common/error.hpp> 16 17 #include <cctype> 18 #include <string> 19 #include <string_view> 20 21 namespace phosphor 22 { 23 namespace network 24 { 25 26 using std::literals::string_view_literals::operator""sv; 27 using namespace phosphor::logging; 28 using namespace sdbusplus::xyz::openbmc_project::Common::Error; 29 30 namespace internal 31 { 32 33 void executeCommandinChildProcess(stdplus::const_zstring path, char** args) 34 { 35 using namespace std::string_literals; 36 pid_t pid = fork(); 37 38 if (pid == 0) 39 { 40 execv(path.c_str(), args); 41 exit(255); 42 } 43 else if (pid < 0) 44 { 45 auto error = errno; 46 lg2::error("Error occurred during fork: {ERRNO}", "ERRNO", error); 47 elog<InternalFailure>(); 48 } 49 else if (pid > 0) 50 { 51 int status; 52 while (waitpid(pid, &status, 0) == -1) 53 { 54 if (errno != EINTR) 55 { 56 status = -1; 57 break; 58 } 59 } 60 61 if (status < 0) 62 { 63 fmt::memory_buffer buf; 64 fmt::format_to(fmt::appender(buf), "`{}`", path); 65 for (size_t i = 0; args[i] != nullptr; ++i) 66 { 67 fmt::format_to(fmt::appender(buf), " `{}`", args[i]); 68 } 69 buf.push_back('\0'); 70 lg2::error("Unable to execute the command {CMD}: {STATUS}", "CMD", 71 buf.data(), "STATUS", status); 72 elog<InternalFailure>(); 73 } 74 } 75 } 76 77 /** @brief Get ignored interfaces from environment */ 78 std::string_view getIgnoredInterfacesEnv() 79 { 80 auto r = std::getenv("IGNORED_INTERFACES"); 81 if (r == nullptr) 82 { 83 return ""; 84 } 85 return r; 86 } 87 88 /** @brief Parse the comma separated interface names */ 89 std::unordered_set<std::string_view> 90 parseInterfaces(std::string_view interfaces) 91 { 92 std::unordered_set<std::string_view> result; 93 while (true) 94 { 95 auto sep = interfaces.find(','); 96 auto interface = interfaces.substr(0, sep); 97 while (!interface.empty() && std::isspace(interface.front())) 98 { 99 interface.remove_prefix(1); 100 } 101 while (!interface.empty() && std::isspace(interface.back())) 102 { 103 interface.remove_suffix(1); 104 } 105 if (!interface.empty()) 106 { 107 result.insert(interface); 108 } 109 if (sep == interfaces.npos) 110 { 111 break; 112 } 113 interfaces = interfaces.substr(sep + 1); 114 } 115 return result; 116 } 117 118 /** @brief Get the ignored interfaces */ 119 const std::unordered_set<std::string_view>& getIgnoredInterfaces() 120 { 121 static auto ignoredInterfaces = parseInterfaces(getIgnoredInterfacesEnv()); 122 return ignoredInterfaces; 123 } 124 125 } // namespace internal 126 127 std::optional<std::string> interfaceToUbootEthAddr(std::string_view intf) 128 { 129 constexpr auto pfx = "eth"sv; 130 if (!intf.starts_with(pfx)) 131 { 132 return std::nullopt; 133 } 134 intf.remove_prefix(pfx.size()); 135 unsigned idx; 136 try 137 { 138 idx = stdplus::StrToInt<10, unsigned>{}(intf); 139 } 140 catch (...) 141 { 142 return std::nullopt; 143 } 144 if (idx == 0) 145 { 146 return "ethaddr"; 147 } 148 return fmt::format(FMT_COMPILE("eth{}addr"), idx); 149 } 150 151 static std::optional<DHCPVal> systemdParseDHCP(std::string_view str) 152 { 153 if (config::icaseeq(str, "ipv4")) 154 { 155 return DHCPVal{.v4 = true, .v6 = false}; 156 } 157 if (config::icaseeq(str, "ipv6")) 158 { 159 return DHCPVal{.v4 = false, .v6 = true}; 160 } 161 if (auto b = config::parseBool(str); b) 162 { 163 return DHCPVal{.v4 = *b, .v6 = *b}; 164 } 165 return std::nullopt; 166 } 167 168 inline auto systemdParseLast(const config::Parser& config, 169 std::string_view section, std::string_view key, 170 auto&& fun) 171 { 172 if (!config.getFileExists()) 173 {} 174 else if (auto str = config.map.getLastValueString(section, key); 175 str == nullptr) 176 { 177 lg2::notice( 178 "Unable to get the value of {CFG_SEC}[{CFG_KEY}] from {CFG_FILE}", 179 "CFG_SEC", section, "CFG_KEY", key, "CFG_FILE", 180 config.getFilename()); 181 } 182 else if (auto val = fun(*str); !val) 183 { 184 lg2::notice( 185 "Invalid value of {CFG_SEC}[{CFG_KEY}] from {CFG_FILE}: {CFG_VAL}", 186 "CFG_SEC", section, "CFG_KEY", key, "CFG_FILE", 187 config.getFilename(), "CFG_VAL", *str); 188 } 189 else 190 { 191 return val; 192 } 193 return decltype(fun(std::string_view{}))(std::nullopt); 194 } 195 196 bool getIPv6AcceptRA(const config::Parser& config) 197 { 198 #ifdef ENABLE_IPV6_ACCEPT_RA 199 constexpr bool def = true; 200 #else 201 constexpr bool def = false; 202 #endif 203 return systemdParseLast(config, "Network", "IPv6AcceptRA", 204 config::parseBool) 205 .value_or(def); 206 } 207 208 DHCPVal getDHCPValue(const config::Parser& config) 209 { 210 return systemdParseLast(config, "Network", "DHCP", systemdParseDHCP) 211 .value_or(DHCPVal{.v4 = true, .v6 = true}); 212 } 213 214 bool getDHCPProp(const config::Parser& config, std::string_view key) 215 { 216 return systemdParseLast(config, "DHCP", key, config::parseBool) 217 .value_or(true); 218 } 219 220 } // namespace network 221 } // namespace phosphor 222