xref: /openbmc/phosphor-networkd/src/system_queries.cpp (revision 1aeacc90018165f79b3c23e90f096e85fb405ca7)
1 #include "system_queries.hpp"
2 
3 #include "netlink.hpp"
4 #include "rtnetlink.hpp"
5 
6 #include <fmt/format.h>
7 #include <linux/ethtool.h>
8 #include <linux/sockios.h>
9 #include <net/if.h>
10 
11 #include <algorithm>
12 #include <optional>
13 #include <phosphor-logging/log.hpp>
14 #include <stdexcept>
15 #include <stdplus/fd/create.hpp>
16 #include <stdplus/raw.hpp>
17 #include <stdplus/util/cexec.hpp>
18 #include <string_view>
19 #include <system_error>
20 
21 namespace phosphor::network::system
22 {
23 
24 using std::literals::string_view_literals::operator""sv;
25 using phosphor::logging::entry;
26 using phosphor::logging::level;
27 using phosphor::logging::log;
28 
29 static stdplus::Fd& getIFSock()
30 {
31     using namespace stdplus::fd;
32     static auto fd =
33         socket(SocketDomain::INet, SocketType::Datagram, SocketProto::IP);
34     return fd;
35 }
36 
37 static ifreq makeIFReq(std::string_view ifname)
38 {
39     ifreq ifr = {};
40     const auto copied = std::min<std::size_t>(ifname.size(), IFNAMSIZ - 1);
41     std::copy_n(ifname.begin(), copied, ifr.ifr_name);
42     return ifr;
43 }
44 
45 static ifreq executeIFReq(std::string_view ifname, unsigned long cmd,
46                           void* data = nullptr)
47 {
48     ifreq ifr = makeIFReq(ifname);
49     ifr.ifr_data = reinterpret_cast<char*>(data);
50     getIFSock().ioctl(cmd, &ifr);
51     return ifr;
52 }
53 
54 inline auto optionalIFReq(stdplus::zstring_view ifname, unsigned long long cmd,
55                           std::string_view cmdname, auto&& complete,
56                           void* data = nullptr)
57 {
58     ifreq ifr;
59     std::optional<decltype(complete(ifr))> ret;
60     auto ukey = std::make_tuple(std::string(ifname), cmd);
61     static std::unordered_set<std::tuple<std::string, unsigned long long>>
62         unsupported;
63     try
64     {
65         ifr = executeIFReq(ifname, cmd, data);
66     }
67     catch (const std::system_error& e)
68     {
69         if (e.code() == std::errc::operation_not_supported)
70         {
71             if (unsupported.find(ukey) == unsupported.end())
72             {
73                 unsupported.emplace(std::move(ukey));
74                 auto msg =
75                     fmt::format("{} not supported on {}", cmdname, ifname);
76                 log<level::INFO>(msg.c_str(),
77                                  entry("INTERFACE=%s", ifname.c_str()));
78             }
79             return ret;
80         }
81         throw;
82     }
83     unsupported.erase(ukey);
84     ret.emplace(complete(ifr));
85     return ret;
86 }
87 
88 EthInfo getEthInfo(stdplus::zstring_view ifname)
89 {
90     ethtool_cmd edata = {};
91     edata.cmd = ETHTOOL_GSET;
92     return optionalIFReq(
93                ifname, SIOCETHTOOL, "ETHTOOL"sv,
94                [&](const ifreq&) {
95                    return EthInfo{.autoneg = edata.autoneg != 0,
96                                   .speed = edata.speed};
97                },
98                &edata)
99         .value_or(EthInfo{});
100 }
101 
102 bool intfIsRunning(std::string_view ifname)
103 {
104     return executeIFReq(ifname, SIOCGIFFLAGS).ifr_flags & IFF_RUNNING;
105 }
106 
107 std::optional<unsigned> getMTU(stdplus::zstring_view ifname)
108 {
109     return optionalIFReq(ifname, SIOCGIFMTU, "GMTU",
110                          [](const ifreq& ifr) { return ifr.ifr_mtu; });
111 }
112 
113 void setMTU(std::string_view ifname, unsigned mtu)
114 {
115     auto ifr = makeIFReq(ifname);
116     ifr.ifr_mtu = mtu;
117     getIFSock().ioctl(SIOCSIFMTU, &ifr);
118 }
119 
120 void setNICUp(std::string_view ifname, bool up)
121 {
122     ifreq ifr = executeIFReq(ifname, SIOCGIFFLAGS);
123     ifr.ifr_flags &= ~IFF_UP;
124     ifr.ifr_flags |= up ? IFF_UP : 0;
125     getIFSock().ioctl(SIOCSIFFLAGS, &ifr);
126 }
127 
128 bool detail::validateNewAddr(const AddressInfo& info,
129                              const AddressFilter& filter) noexcept
130 {
131     if (filter.ifidx != 0 && filter.ifidx != info.ifidx)
132     {
133         return false;
134     }
135     return true;
136 }
137 
138 bool detail::validateNewNeigh(const NeighborInfo& info,
139                               const NeighborFilter& filter) noexcept
140 {
141     if (filter.ifidx != 0 && filter.ifidx != info.ifidx)
142     {
143         return false;
144     }
145     return true;
146 }
147 
148 std::vector<InterfaceInfo> getInterfaces()
149 {
150     std::vector<InterfaceInfo> ret;
151     auto cb = [&](const nlmsghdr&, std::string_view msg) {
152         try
153         {
154             ret.emplace_back(netlink::intfFromRtm(msg));
155         }
156         catch (const std::exception& e)
157         {
158             auto msg = fmt::format("Failed parsing interface: {}", e.what());
159             log<level::ERR>(msg.c_str());
160         }
161     };
162     ifinfomsg msg{};
163     netlink::performRequest(NETLINK_ROUTE, RTM_GETLINK, NLM_F_DUMP, msg, cb);
164     return ret;
165 }
166 
167 std::vector<AddressInfo> getAddresses(const AddressFilter& filter)
168 {
169     std::vector<AddressInfo> ret;
170     auto cb = [&](const nlmsghdr&, std::string_view msg) {
171         try
172         {
173             auto info = netlink::addrFromRtm(msg);
174             if (detail::validateNewAddr(info, filter))
175             {
176                 ret.emplace_back(std::move(info));
177             }
178         }
179         catch (const std::exception& e)
180         {
181             auto msg = fmt::format("Failed parsing address for ifidx {}: {}",
182                                    filter.ifidx, e.what());
183             log<level::ERR>(msg.c_str());
184         }
185     };
186     ifaddrmsg msg{};
187     msg.ifa_index = filter.ifidx;
188     netlink::performRequest(NETLINK_ROUTE, RTM_GETADDR, NLM_F_DUMP, msg, cb);
189     return ret;
190 }
191 
192 std::vector<NeighborInfo> getNeighbors(const NeighborFilter& filter)
193 {
194     std::vector<NeighborInfo> ret;
195     auto cb = [&](const nlmsghdr&, std::string_view msg) {
196         try
197         {
198             auto info = netlink::neighFromRtm(msg);
199             if (detail::validateNewNeigh(info, filter))
200             {
201                 ret.push_back(std::move(info));
202             }
203         }
204         catch (const std::exception& e)
205         {
206             auto msg = fmt::format("Failed parsing neighbor for ifidx {}: {}",
207                                    filter.ifidx, e.what());
208             log<level::ERR>(msg.c_str());
209         }
210     };
211     ndmsg msg{};
212     msg.ndm_ifindex = filter.ifidx;
213     netlink::performRequest(NETLINK_ROUTE, RTM_GETNEIGH, NLM_F_DUMP, msg, cb);
214     return ret;
215 }
216 
217 } // namespace phosphor::network::system
218