blob: ba4e4b0f4ee5fbba49874f29d1f2e1c2a200061f [file] [log] [blame]
Patrick Venture690a2342020-05-17 11:51:31 -07001#include "transporthandler.hpp"
2
William A. Kennington IIIc514d872019-04-06 18:19:38 -07003using phosphor::logging::commit;
4using phosphor::logging::elog;
5using phosphor::logging::entry;
6using phosphor::logging::level;
7using phosphor::logging::log;
8using sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
Johnathan Mantey65265362019-11-14 11:24:19 -08009using sdbusplus::xyz::openbmc_project::Network::server::EthernetInterface;
William A. Kennington IIIc514d872019-04-06 18:19:38 -070010using sdbusplus::xyz::openbmc_project::Network::server::IP;
William A. Kennington III4bbc3db2019-04-15 00:02:10 -070011using sdbusplus::xyz::openbmc_project::Network::server::Neighbor;
William A. Kennington IIIc514d872019-04-06 18:19:38 -070012
Johnathan Manteyaffadb52019-10-07 10:13:53 -070013namespace cipher
14{
15
16std::vector<uint8_t> getCipherList()
17{
18 std::vector<uint8_t> cipherList;
19
20 std::ifstream jsonFile(cipher::configFile);
21 if (!jsonFile.is_open())
22 {
23 log<level::ERR>("Channel Cipher suites file not found");
24 elog<InternalFailure>();
25 }
26
27 auto data = Json::parse(jsonFile, nullptr, false);
28 if (data.is_discarded())
29 {
30 log<level::ERR>("Parsing channel cipher suites JSON failed");
31 elog<InternalFailure>();
32 }
33
34 // Byte 1 is reserved
35 cipherList.push_back(0x00);
36
37 for (const auto& record : data)
38 {
39 cipherList.push_back(record.value(cipher, 0));
40 }
41
42 return cipherList;
43}
44} // namespace cipher
45
46namespace ipmi
47{
48namespace transport
49{
50
William A. Kennington IIIc514d872019-04-06 18:19:38 -070051/** @brief Valid address origins for IPv4 */
52const std::unordered_set<IP::AddressOrigin> originsV4 = {
53 IP::AddressOrigin::Static,
54 IP::AddressOrigin::DHCP,
55};
56
Johnathan Manteyb87034e2019-09-16 10:50:50 -070057static constexpr uint8_t oemCmdStart = 192;
58static constexpr uint8_t oemCmdEnd = 255;
59
Patrick Williams5d82f472022-07-22 19:26:53 -050060std::optional<ChannelParams> maybeGetChannelParams(sdbusplus::bus_t& bus,
William A. Kennington IIIc514d872019-04-06 18:19:38 -070061 uint8_t channel)
62{
63 auto ifname = getChannelName(channel);
64 if (ifname.empty())
Patrick Venturec7c1c3c2017-11-15 14:29:18 -080065 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -070066 return std::nullopt;
Patrick Venturec7c1c3c2017-11-15 14:29:18 -080067 }
Patrick Venturec7c1c3c2017-11-15 14:29:18 -080068
William A. Kennington IIIc514d872019-04-06 18:19:38 -070069 // Enumerate all VLAN + ETHERNET interfaces
70 auto req = bus.new_method_call(MAPPER_BUS_NAME, MAPPER_OBJ, MAPPER_INTF,
71 "GetSubTree");
72 req.append(PATH_ROOT, 0,
73 std::vector<std::string>{INTF_VLAN, INTF_ETHERNET});
74 auto reply = bus.call(req);
75 ObjectTree objs;
76 reply.read(objs);
77
78 ChannelParams params;
79 for (const auto& [path, impls] : objs)
80 {
81 if (path.find(ifname) == path.npos)
82 {
83 continue;
84 }
85 for (const auto& [service, intfs] : impls)
86 {
87 bool vlan = false;
88 bool ethernet = false;
89 for (const auto& intf : intfs)
90 {
91 if (intf == INTF_VLAN)
92 {
93 vlan = true;
94 }
95 else if (intf == INTF_ETHERNET)
96 {
97 ethernet = true;
98 }
99 }
100 if (params.service.empty() && (vlan || ethernet))
101 {
102 params.service = service;
103 }
104 if (params.ifPath.empty() && !vlan && ethernet)
105 {
106 params.ifPath = path;
107 }
108 if (params.logicalPath.empty() && vlan)
109 {
110 params.logicalPath = path;
111 }
112 }
113 }
114
115 // We must have a path for the underlying interface
116 if (params.ifPath.empty())
117 {
118 return std::nullopt;
119 }
120 // We don't have a VLAN so the logical path is the same
121 if (params.logicalPath.empty())
122 {
123 params.logicalPath = params.ifPath;
124 }
125
126 params.id = channel;
127 params.ifname = std::move(ifname);
Willy Tu11d68892022-01-20 10:37:34 -0800128 return params;
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700129}
130
Patrick Williams5d82f472022-07-22 19:26:53 -0500131ChannelParams getChannelParams(sdbusplus::bus_t& bus, uint8_t channel)
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700132{
133 auto params = maybeGetChannelParams(bus, channel);
134 if (!params)
135 {
136 log<level::ERR>("Failed to get channel params",
137 entry("CHANNEL=%" PRIu8, channel));
138 elog<InternalFailure>();
139 }
140 return std::move(*params);
141}
142
143/** @brief Wraps the phosphor logging method to insert some additional metadata
144 *
145 * @param[in] params - The parameters for the channel
146 * ...
147 */
148template <auto level, typename... Args>
149auto logWithChannel(const ChannelParams& params, Args&&... args)
150{
151 return log<level>(std::forward<Args>(args)...,
152 entry("CHANNEL=%d", params.id),
153 entry("IFNAME=%s", params.ifname.c_str()));
154}
155template <auto level, typename... Args>
156auto logWithChannel(const std::optional<ChannelParams>& params, Args&&... args)
157{
158 if (params)
159 {
160 return logWithChannel<level>(*params, std::forward<Args>(args)...);
161 }
162 return log<level>(std::forward<Args>(args)...);
163}
164
Patrick Williams5d82f472022-07-22 19:26:53 -0500165EthernetInterface::DHCPConf getDHCPProperty(sdbusplus::bus_t& bus,
Johnathan Mantey65265362019-11-14 11:24:19 -0800166 const ChannelParams& params)
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700167{
Johnathan Mantey65265362019-11-14 11:24:19 -0800168 std::string dhcpstr = std::get<std::string>(getDbusProperty(
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700169 bus, params.service, params.logicalPath, INTF_ETHERNET, "DHCPEnabled"));
Johnathan Mantey65265362019-11-14 11:24:19 -0800170 return EthernetInterface::convertDHCPConfFromString(dhcpstr);
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700171}
172
Johnathan Mantey65265362019-11-14 11:24:19 -0800173/** @brief Sets the DHCP v4 state on the given interface
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700174 *
Johnathan Mantey65265362019-11-14 11:24:19 -0800175 * @param[in] bus - The bus object used for lookups
176 * @param[in] params - The parameters for the channel
177 * @param[in] requestedDhcp - DHCP state to assign
178 * (EthernetInterface::DHCPConf::none,
179 * EthernetInterface::DHCPConf::v4,
180 * EthernetInterface::DHCPConf::v6,
181 * EthernetInterface::DHCPConf::both)
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700182 */
Patrick Williams5d82f472022-07-22 19:26:53 -0500183void setDHCPv4Property(sdbusplus::bus_t& bus, const ChannelParams& params,
Johnathan Mantey65265362019-11-14 11:24:19 -0800184 const EthernetInterface::DHCPConf requestedDhcp)
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700185{
Johnathan Mantey65265362019-11-14 11:24:19 -0800186 EthernetInterface::DHCPConf currentDhcp = getDHCPProperty(bus, params);
187 EthernetInterface::DHCPConf nextDhcp = EthernetInterface::DHCPConf::none;
188
Tony Leed5967af2021-07-06 15:49:11 +0800189 // When calling setDHCPv4Property, requestedDhcp only has "v4" and "none".
190 // setDHCPv4Property is only for IPv4 management. It should not modify
191 // IPv6 state.
192 if (requestedDhcp == EthernetInterface::DHCPConf::v4)
Johnathan Mantey65265362019-11-14 11:24:19 -0800193 {
Tony Leed5967af2021-07-06 15:49:11 +0800194 if ((currentDhcp == EthernetInterface::DHCPConf::v6) ||
195 (currentDhcp == EthernetInterface::DHCPConf::both))
196 nextDhcp = EthernetInterface::DHCPConf::both;
197 else if ((currentDhcp == EthernetInterface::DHCPConf::v4) ||
198 (currentDhcp == EthernetInterface::DHCPConf::none))
199 nextDhcp = EthernetInterface::DHCPConf::v4;
Johnathan Mantey65265362019-11-14 11:24:19 -0800200 }
201 else if (requestedDhcp == EthernetInterface::DHCPConf::none)
202 {
Tony Leed5967af2021-07-06 15:49:11 +0800203 if ((currentDhcp == EthernetInterface::DHCPConf::v6) ||
204 (currentDhcp == EthernetInterface::DHCPConf::both))
Johnathan Mantey65265362019-11-14 11:24:19 -0800205 nextDhcp = EthernetInterface::DHCPConf::v6;
Tony Leed5967af2021-07-06 15:49:11 +0800206 else if ((currentDhcp == EthernetInterface::DHCPConf::v4) ||
207 (currentDhcp == EthernetInterface::DHCPConf::none))
Johnathan Mantey65265362019-11-14 11:24:19 -0800208 nextDhcp = EthernetInterface::DHCPConf::none;
Johnathan Mantey65265362019-11-14 11:24:19 -0800209 }
Tony Leed5967af2021-07-06 15:49:11 +0800210 else // Stay the same.
Johnathan Mantey65265362019-11-14 11:24:19 -0800211 {
212 nextDhcp = currentDhcp;
213 }
214 std::string newDhcp =
215 sdbusplus::xyz::openbmc_project::Network::server::convertForMessage(
216 nextDhcp);
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700217 setDbusProperty(bus, params.service, params.logicalPath, INTF_ETHERNET,
Johnathan Mantey65265362019-11-14 11:24:19 -0800218 "DHCPEnabled", newDhcp);
219}
220
Patrick Williams5d82f472022-07-22 19:26:53 -0500221void setDHCPv6Property(sdbusplus::bus_t& bus, const ChannelParams& params,
Johnathan Mantey65265362019-11-14 11:24:19 -0800222 const EthernetInterface::DHCPConf requestedDhcp,
223 const bool defaultMode = true)
224{
225 EthernetInterface::DHCPConf currentDhcp = getDHCPProperty(bus, params);
226 EthernetInterface::DHCPConf nextDhcp = EthernetInterface::DHCPConf::none;
227
228 if (defaultMode)
229 {
Jiaqing Zhaod385b5a2021-12-29 18:31:49 +0800230 // When calling setDHCPv6Property, requestedDhcp only has "v6" and
231 // "none".
232 // setDHCPv6Property is only for IPv6 management. It should not modify
233 // IPv4 state.
234 if (requestedDhcp == EthernetInterface::DHCPConf::v6)
Johnathan Mantey65265362019-11-14 11:24:19 -0800235 {
Jiaqing Zhaod385b5a2021-12-29 18:31:49 +0800236 if ((currentDhcp == EthernetInterface::DHCPConf::v4) ||
237 (currentDhcp == EthernetInterface::DHCPConf::both))
238 nextDhcp = EthernetInterface::DHCPConf::both;
239 else if ((currentDhcp == EthernetInterface::DHCPConf::v6) ||
240 (currentDhcp == EthernetInterface::DHCPConf::none))
241 nextDhcp = EthernetInterface::DHCPConf::v6;
Johnathan Mantey65265362019-11-14 11:24:19 -0800242 }
243 else if (requestedDhcp == EthernetInterface::DHCPConf::none)
244 {
Jiaqing Zhaod385b5a2021-12-29 18:31:49 +0800245 if ((currentDhcp == EthernetInterface::DHCPConf::v4) ||
246 (currentDhcp == EthernetInterface::DHCPConf::both))
Johnathan Mantey65265362019-11-14 11:24:19 -0800247 nextDhcp = EthernetInterface::DHCPConf::v4;
Jiaqing Zhaod385b5a2021-12-29 18:31:49 +0800248 else if ((currentDhcp == EthernetInterface::DHCPConf::v6) ||
249 (currentDhcp == EthernetInterface::DHCPConf::none))
Johnathan Mantey65265362019-11-14 11:24:19 -0800250 nextDhcp = EthernetInterface::DHCPConf::none;
Johnathan Mantey65265362019-11-14 11:24:19 -0800251 }
Jiaqing Zhaod385b5a2021-12-29 18:31:49 +0800252 else // Stay the same.
Johnathan Mantey65265362019-11-14 11:24:19 -0800253 {
254 nextDhcp = currentDhcp;
255 }
256 }
257 else
258 {
259 // allow the v6 call to set any value
260 nextDhcp = requestedDhcp;
261 }
262
263 std::string newDhcp =
264 sdbusplus::xyz::openbmc_project::Network::server::convertForMessage(
265 nextDhcp);
266 setDbusProperty(bus, params.service, params.logicalPath, INTF_ETHERNET,
267 "DHCPEnabled", newDhcp);
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700268}
269
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700270ether_addr stringToMAC(const char* mac)
271{
272 const ether_addr* ret = ether_aton(mac);
273 if (ret == nullptr)
274 {
275 log<level::ERR>("Invalid MAC Address", entry("MAC=%s", mac));
276 elog<InternalFailure>();
277 }
278 return *ret;
279}
280
281/** @brief Determines the MAC of the ethernet interface
282 *
283 * @param[in] bus - The bus object used for lookups
284 * @param[in] params - The parameters for the channel
285 * @return The configured mac address
286 */
Patrick Williams5d82f472022-07-22 19:26:53 -0500287ether_addr getMACProperty(sdbusplus::bus_t& bus, const ChannelParams& params)
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700288{
289 auto macStr = std::get<std::string>(getDbusProperty(
290 bus, params.service, params.ifPath, INTF_MAC, "MACAddress"));
291 return stringToMAC(macStr.c_str());
292}
293
294/** @brief Sets the system value for MAC address on the given interface
295 *
296 * @param[in] bus - The bus object used for lookups
297 * @param[in] params - The parameters for the channel
298 * @param[in] mac - MAC address to apply
299 */
Patrick Williams5d82f472022-07-22 19:26:53 -0500300void setMACProperty(sdbusplus::bus_t& bus, const ChannelParams& params,
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700301 const ether_addr& mac)
302{
303 std::string macStr = ether_ntoa(&mac);
304 setDbusProperty(bus, params.service, params.ifPath, INTF_MAC, "MACAddress",
305 macStr);
306}
307
Patrick Williams5d82f472022-07-22 19:26:53 -0500308void deleteObjectIfExists(sdbusplus::bus_t& bus, const std::string& service,
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700309 const std::string& path)
310{
311 if (path.empty())
312 {
313 return;
314 }
Ratan Guptab8e99552017-07-27 07:07:48 +0530315 try
tomjose26e17732016-03-03 08:52:51 -0600316 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700317 auto req = bus.new_method_call(service.c_str(), path.c_str(),
318 ipmi::DELETE_INTERFACE, "Delete");
319 bus.call_noreply(req);
320 }
Patrick Williams5d82f472022-07-22 19:26:53 -0500321 catch (const sdbusplus::exception_t& e)
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700322 {
jayaprakash Mutyala84c49dc2020-05-18 23:12:13 +0000323 if (strcmp(e.name(),
324 "xyz.openbmc_project.Common.Error.InternalFailure") != 0 &&
325 strcmp(e.name(), "org.freedesktop.DBus.Error.UnknownObject") != 0)
tomjose26e17732016-03-03 08:52:51 -0600326 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700327 // We want to rethrow real errors
328 throw;
tomjose26e17732016-03-03 08:52:51 -0600329 }
330 }
tomjose26e17732016-03-03 08:52:51 -0600331}
332
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700333/** @brief Sets the address info configured for the interface
334 * If a previous address path exists then it will be removed
335 * before the new address is added.
336 *
337 * @param[in] bus - The bus object used for lookups
338 * @param[in] params - The parameters for the channel
339 * @param[in] address - The address of the new IP
340 * @param[in] prefix - The prefix of the new IP
341 */
342template <int family>
Patrick Williams5d82f472022-07-22 19:26:53 -0500343void createIfAddr(sdbusplus::bus_t& bus, const ChannelParams& params,
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700344 const typename AddrFamily<family>::addr& address,
345 uint8_t prefix)
Tom Josepha30c8d32018-03-22 02:15:03 +0530346{
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700347 auto newreq =
348 bus.new_method_call(params.service.c_str(), params.logicalPath.c_str(),
349 INTF_IP_CREATE, "IP");
350 std::string protocol =
351 sdbusplus::xyz::openbmc_project::Network::server::convertForMessage(
352 AddrFamily<family>::protocol);
353 newreq.append(protocol, addrToString<family>(address), prefix, "");
354 bus.call_noreply(newreq);
355}
Tom Josepha30c8d32018-03-22 02:15:03 +0530356
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700357/** @brief Trivial helper for getting the IPv4 address from getIfAddrs()
358 *
359 * @param[in] bus - The bus object used for lookups
360 * @param[in] params - The parameters for the channel
361 * @return The address and prefix if found
362 */
Patrick Williams5d82f472022-07-22 19:26:53 -0500363auto getIfAddr4(sdbusplus::bus_t& bus, const ChannelParams& params)
Tom Josepha30c8d32018-03-22 02:15:03 +0530364{
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700365 return getIfAddr<AF_INET>(bus, params, 0, originsV4);
366}
Tom Josepha30c8d32018-03-22 02:15:03 +0530367
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700368/** @brief Reconfigures the IPv4 address info configured for the interface
369 *
370 * @param[in] bus - The bus object used for lookups
371 * @param[in] params - The parameters for the channel
372 * @param[in] address - The new address if specified
373 * @param[in] prefix - The new address prefix if specified
374 */
Patrick Williams5d82f472022-07-22 19:26:53 -0500375void reconfigureIfAddr4(sdbusplus::bus_t& bus, const ChannelParams& params,
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700376 const std::optional<in_addr>& address,
377 std::optional<uint8_t> prefix)
378{
379 auto ifaddr = getIfAddr4(bus, params);
380 if (!ifaddr && !address)
Tom Josepha30c8d32018-03-22 02:15:03 +0530381 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700382 log<level::ERR>("Missing address for IPv4 assignment");
Tom Josepha30c8d32018-03-22 02:15:03 +0530383 elog<InternalFailure>();
384 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700385 uint8_t fallbackPrefix = AddrFamily<AF_INET>::defaultPrefix;
386 if (ifaddr)
Tom Josepha30c8d32018-03-22 02:15:03 +0530387 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700388 fallbackPrefix = ifaddr->prefix;
389 deleteObjectIfExists(bus, params.service, ifaddr->path);
390 }
391 createIfAddr<AF_INET>(bus, params, address.value_or(ifaddr->address),
392 prefix.value_or(fallbackPrefix));
393}
394
William A. Kennington III4bbc3db2019-04-15 00:02:10 -0700395template <int family>
Patrick Williams5d82f472022-07-22 19:26:53 -0500396std::optional<IfNeigh<family>> findGatewayNeighbor(sdbusplus::bus_t& bus,
William A. Kennington III4bbc3db2019-04-15 00:02:10 -0700397 const ChannelParams& params,
398 ObjectLookupCache& neighbors)
399{
400 auto gateway = getGatewayProperty<family>(bus, params);
401 if (!gateway)
402 {
403 return std::nullopt;
404 }
405
406 return findStaticNeighbor<family>(bus, params, *gateway, neighbors);
407}
408
409template <int family>
Patrick Williams5d82f472022-07-22 19:26:53 -0500410std::optional<IfNeigh<family>> getGatewayNeighbor(sdbusplus::bus_t& bus,
William A. Kennington III4bbc3db2019-04-15 00:02:10 -0700411 const ChannelParams& params)
412{
413 ObjectLookupCache neighbors(bus, params, INTF_NEIGHBOR);
414 return findGatewayNeighbor<family>(bus, params, neighbors);
415}
416
417template <int family>
Patrick Williams5d82f472022-07-22 19:26:53 -0500418void reconfigureGatewayMAC(sdbusplus::bus_t& bus, const ChannelParams& params,
419 const ether_addr& mac)
William A. Kennington III4bbc3db2019-04-15 00:02:10 -0700420{
421 auto gateway = getGatewayProperty<family>(bus, params);
422 if (!gateway)
423 {
424 log<level::ERR>("Tried to set Gateway MAC without Gateway");
425 elog<InternalFailure>();
426 }
427
428 ObjectLookupCache neighbors(bus, params, INTF_NEIGHBOR);
429 auto neighbor =
430 findStaticNeighbor<family>(bus, params, *gateway, neighbors);
431 if (neighbor)
432 {
433 deleteObjectIfExists(bus, params.service, neighbor->path);
434 }
435
436 createNeighbor<family>(bus, params, *gateway, mac);
437}
438
William A. Kennington III16064aa2019-04-13 17:44:53 -0700439/** @brief Deconfigures the IPv6 address info configured for the interface
440 *
441 * @param[in] bus - The bus object used for lookups
442 * @param[in] params - The parameters for the channel
443 * @param[in] idx - The address index to operate on
444 */
Patrick Williams5d82f472022-07-22 19:26:53 -0500445void deconfigureIfAddr6(sdbusplus::bus_t& bus, const ChannelParams& params,
William A. Kennington III16064aa2019-04-13 17:44:53 -0700446 uint8_t idx)
447{
448 auto ifaddr = getIfAddr<AF_INET6>(bus, params, idx, originsV6Static);
449 if (ifaddr)
450 {
451 deleteObjectIfExists(bus, params.service, ifaddr->path);
452 }
453}
454
455/** @brief Reconfigures the IPv6 address info configured for the interface
456 *
457 * @param[in] bus - The bus object used for lookups
458 * @param[in] params - The parameters for the channel
459 * @param[in] idx - The address index to operate on
460 * @param[in] address - The new address
461 * @param[in] prefix - The new address prefix
462 */
Patrick Williams5d82f472022-07-22 19:26:53 -0500463void reconfigureIfAddr6(sdbusplus::bus_t& bus, const ChannelParams& params,
William A. Kennington III16064aa2019-04-13 17:44:53 -0700464 uint8_t idx, const in6_addr& address, uint8_t prefix)
465{
466 deconfigureIfAddr6(bus, params, idx);
467 createIfAddr<AF_INET6>(bus, params, address, prefix);
468}
469
470/** @brief Converts the AddressOrigin into an IPv6Source
471 *
472 * @param[in] origin - The DBus Address Origin to convert
473 * @return The IPv6Source version of the origin
474 */
475IPv6Source originToSourceType(IP::AddressOrigin origin)
476{
477 switch (origin)
478 {
479 case IP::AddressOrigin::Static:
480 return IPv6Source::Static;
481 case IP::AddressOrigin::DHCP:
482 return IPv6Source::DHCP;
483 case IP::AddressOrigin::SLAAC:
484 return IPv6Source::SLAAC;
485 default:
486 {
487 auto originStr = sdbusplus::xyz::openbmc_project::Network::server::
488 convertForMessage(origin);
489 log<level::ERR>(
490 "Invalid IP::AddressOrigin conversion to IPv6Source",
491 entry("ORIGIN=%s", originStr.c_str()));
492 elog<InternalFailure>();
493 }
494 }
495}
496
497/** @brief Packs the IPMI message response with IPv6 address data
498 *
499 * @param[out] ret - The IPMI response payload to be packed
500 * @param[in] channel - The channel id corresponding to an ethernet interface
501 * @param[in] set - The set selector for determining address index
502 * @param[in] origins - Set of valid origins for address filtering
503 */
504void getLanIPv6Address(message::Payload& ret, uint8_t channel, uint8_t set,
505 const std::unordered_set<IP::AddressOrigin>& origins)
506{
507 auto source = IPv6Source::Static;
508 bool enabled = false;
509 in6_addr addr{};
Johnathan Mantey5aae0922021-10-21 13:05:36 -0700510 uint8_t prefix{};
William A. Kennington III16064aa2019-04-13 17:44:53 -0700511 auto status = IPv6AddressStatus::Disabled;
512
513 auto ifaddr = channelCall<getIfAddr<AF_INET6>>(channel, set, origins);
514 if (ifaddr)
515 {
516 source = originToSourceType(ifaddr->origin);
Johnathan Mantey846af862021-10-21 12:48:54 -0700517 enabled = (origins == originsV6Static);
William A. Kennington III16064aa2019-04-13 17:44:53 -0700518 addr = ifaddr->address;
519 prefix = ifaddr->prefix;
520 status = IPv6AddressStatus::Active;
521 }
522
523 ret.pack(set);
William A. Kennington III7a0e5df2021-05-19 13:31:29 -0700524 ret.pack(types::enum_cast<uint4_t>(source), uint3_t{}, enabled);
William A. Kennington III16064aa2019-04-13 17:44:53 -0700525 ret.pack(std::string_view(reinterpret_cast<char*>(&addr), sizeof(addr)));
526 ret.pack(prefix);
William A. Kennington III7a0e5df2021-05-19 13:31:29 -0700527 ret.pack(types::enum_cast<uint8_t>(status));
William A. Kennington III16064aa2019-04-13 17:44:53 -0700528}
529
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700530/** @brief Gets the vlan ID configured on the interface
531 *
532 * @param[in] bus - The bus object used for lookups
533 * @param[in] params - The parameters for the channel
534 * @return VLAN id or the standard 0 for no VLAN
535 */
Patrick Williams5d82f472022-07-22 19:26:53 -0500536uint16_t getVLANProperty(sdbusplus::bus_t& bus, const ChannelParams& params)
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700537{
538 // VLAN devices will always have a separate logical object
539 if (params.ifPath == params.logicalPath)
540 {
541 return 0;
542 }
543
544 auto vlan = std::get<uint32_t>(getDbusProperty(
545 bus, params.service, params.logicalPath, INTF_VLAN, "Id"));
546 if ((vlan & VLAN_VALUE_MASK) != vlan)
547 {
548 logWithChannel<level::ERR>(params, "networkd returned an invalid vlan",
549 entry("VLAN=%" PRIu32, vlan));
Tom Josepha30c8d32018-03-22 02:15:03 +0530550 elog<InternalFailure>();
551 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700552 return vlan;
Tom Josepha30c8d32018-03-22 02:15:03 +0530553}
554
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700555/** @brief Deletes all of the possible configuration parameters for a channel
556 *
557 * @param[in] bus - The bus object used for lookups
558 * @param[in] params - The parameters for the channel
559 */
Patrick Williams5d82f472022-07-22 19:26:53 -0500560void deconfigureChannel(sdbusplus::bus_t& bus, ChannelParams& params)
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500561{
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700562 // Delete all objects associated with the interface
563 auto objreq = bus.new_method_call(MAPPER_BUS_NAME, MAPPER_OBJ, MAPPER_INTF,
564 "GetSubTree");
565 objreq.append(PATH_ROOT, 0, std::vector<std::string>{DELETE_INTERFACE});
566 auto objreply = bus.call(objreq);
567 ObjectTree objs;
568 objreply.read(objs);
569 for (const auto& [path, impls] : objs)
570 {
571 if (path.find(params.ifname) == path.npos)
572 {
573 continue;
574 }
575 for (const auto& [service, intfs] : impls)
576 {
577 deleteObjectIfExists(bus, service, path);
578 }
579 // Update params to reflect the deletion of vlan
580 if (path == params.logicalPath)
581 {
582 params.logicalPath = params.ifPath;
583 }
584 }
585
586 // Clear out any settings on the lower physical interface
Johnathan Mantey65265362019-11-14 11:24:19 -0800587 setDHCPv6Property(bus, params, EthernetInterface::DHCPConf::none, false);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500588}
589
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700590/** @brief Creates a new VLAN on the specified interface
591 *
592 * @param[in] bus - The bus object used for lookups
593 * @param[in] params - The parameters for the channel
594 * @param[in] vlan - The id of the new vlan
595 */
Patrick Williams5d82f472022-07-22 19:26:53 -0500596void createVLAN(sdbusplus::bus_t& bus, ChannelParams& params, uint16_t vlan)
Ratan Guptab8e99552017-07-27 07:07:48 +0530597{
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700598 if (vlan == 0)
Richard Marian Thomaiyar75b480b2019-01-22 00:20:15 +0530599 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700600 return;
Richard Marian Thomaiyar75b480b2019-01-22 00:20:15 +0530601 }
602
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700603 auto req = bus.new_method_call(params.service.c_str(), PATH_ROOT,
604 INTF_VLAN_CREATE, "VLAN");
605 req.append(params.ifname, static_cast<uint32_t>(vlan));
606 auto reply = bus.call(req);
607 sdbusplus::message::object_path newPath;
608 reply.read(newPath);
609 params.logicalPath = std::move(newPath);
Richard Marian Thomaiyar75b480b2019-01-22 00:20:15 +0530610}
611
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700612/** @brief Performs the necessary reconfiguration to change the VLAN
613 *
614 * @param[in] bus - The bus object used for lookups
615 * @param[in] params - The parameters for the channel
616 * @param[in] vlan - The new vlan id to use
617 */
Patrick Williams5d82f472022-07-22 19:26:53 -0500618void reconfigureVLAN(sdbusplus::bus_t& bus, ChannelParams& params,
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700619 uint16_t vlan)
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500620{
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700621 // Unfortunatetly we don't have built-in functions to migrate our interface
622 // customizations to new VLAN interfaces, or have some kind of decoupling.
623 // We therefore must retain all of our old information, setup the new VLAN
624 // configuration, then restore the old info.
Nan Li3d0df912016-10-18 19:51:41 +0800625
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700626 // Save info from the old logical interface
627 ObjectLookupCache ips(bus, params, INTF_IP);
628 auto ifaddr4 = findIfAddr<AF_INET>(bus, params, 0, originsV4, ips);
William A. Kennington III16064aa2019-04-13 17:44:53 -0700629 std::vector<IfAddr<AF_INET6>> ifaddrs6;
630 for (uint8_t i = 0; i < MAX_IPV6_STATIC_ADDRESSES; ++i)
631 {
632 auto ifaddr6 =
633 findIfAddr<AF_INET6>(bus, params, i, originsV6Static, ips);
634 if (!ifaddr6)
635 {
636 break;
637 }
638 ifaddrs6.push_back(std::move(*ifaddr6));
639 }
Johnathan Mantey65265362019-11-14 11:24:19 -0800640 EthernetInterface::DHCPConf dhcp = getDHCPProperty(bus, params);
William A. Kennington III4bbc3db2019-04-15 00:02:10 -0700641 ObjectLookupCache neighbors(bus, params, INTF_NEIGHBOR);
642 auto neighbor4 = findGatewayNeighbor<AF_INET>(bus, params, neighbors);
William A. Kennington III16064aa2019-04-13 17:44:53 -0700643 auto neighbor6 = findGatewayNeighbor<AF_INET6>(bus, params, neighbors);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500644
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700645 deconfigureChannel(bus, params);
646 createVLAN(bus, params, vlan);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500647
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700648 // Re-establish the saved settings
Johnathan Mantey65265362019-11-14 11:24:19 -0800649 setDHCPv6Property(bus, params, dhcp, false);
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700650 if (ifaddr4)
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800651 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700652 createIfAddr<AF_INET>(bus, params, ifaddr4->address, ifaddr4->prefix);
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800653 }
William A. Kennington III16064aa2019-04-13 17:44:53 -0700654 for (const auto& ifaddr6 : ifaddrs6)
655 {
656 createIfAddr<AF_INET6>(bus, params, ifaddr6.address, ifaddr6.prefix);
657 }
William A. Kennington III4bbc3db2019-04-15 00:02:10 -0700658 if (neighbor4)
659 {
660 createNeighbor<AF_INET>(bus, params, neighbor4->ip, neighbor4->mac);
661 }
William A. Kennington III16064aa2019-04-13 17:44:53 -0700662 if (neighbor6)
663 {
664 createNeighbor<AF_INET6>(bus, params, neighbor6->ip, neighbor6->mac);
665 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700666}
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800667
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700668/** @brief Turns a prefix into a netmask
669 *
670 * @param[in] prefix - The prefix length
671 * @return The netmask
672 */
673in_addr prefixToNetmask(uint8_t prefix)
674{
675 if (prefix > 32)
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500676 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700677 log<level::ERR>("Invalid prefix", entry("PREFIX=%" PRIu8, prefix));
678 elog<InternalFailure>();
679 }
680 if (prefix == 0)
681 {
682 // Avoids 32-bit lshift by 32 UB
683 return {};
684 }
685 return {htobe32(~UINT32_C(0) << (32 - prefix))};
686}
687
688/** @brief Turns a a netmask into a prefix length
689 *
690 * @param[in] netmask - The netmask in byte form
691 * @return The prefix length
692 */
693uint8_t netmaskToPrefix(in_addr netmask)
694{
695 uint32_t x = be32toh(netmask.s_addr);
696 if ((~x & (~x + 1)) != 0)
697 {
698 char maskStr[INET_ADDRSTRLEN];
699 inet_ntop(AF_INET, &netmask, maskStr, sizeof(maskStr));
700 log<level::ERR>("Invalid netmask", entry("NETMASK=%s", maskStr));
701 elog<InternalFailure>();
702 }
Johnathan Mantey62c05dd2019-11-20 14:07:44 -0800703 return static_cast<bool>(x)
704 ? AddrFamily<AF_INET>::defaultPrefix - __builtin_ctz(x)
705 : 0;
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700706}
707
708// We need to store this value so it can be returned to the client
709// It is volatile so safe to store in daemon memory.
710static std::unordered_map<uint8_t, SetStatus> setStatus;
711
712// Until we have good support for fixed versions of IPMI tool
713// we need to return the VLAN id for disabled VLANs. The value is only
714// used for verification that a disable operation succeeded and will only
715// be sent if our system indicates that vlans are disabled.
716static std::unordered_map<uint8_t, uint16_t> lastDisabledVlan;
717
718/** @brief Gets the set status for the channel if it exists
719 * Otherise populates and returns the default value.
720 *
721 * @param[in] channel - The channel id corresponding to an ethernet interface
722 * @return A reference to the SetStatus for the channel
723 */
724SetStatus& getSetStatus(uint8_t channel)
725{
726 auto it = setStatus.find(channel);
727 if (it != setStatus.end())
728 {
729 return it->second;
730 }
731 return setStatus[channel] = SetStatus::Complete;
732}
733
Johnathan Mantey3b7a4072021-01-26 14:24:53 -0800734/** @brief Gets the IPv6 Router Advertisement value
735 *
736 * @param[in] bus - The bus object used for lookups
737 * @param[in] params - The parameters for the channel
738 * @return networkd IPV6AcceptRA value
739 */
Patrick Williams5d82f472022-07-22 19:26:53 -0500740static bool getIPv6AcceptRA(sdbusplus::bus_t& bus, const ChannelParams& params)
Johnathan Mantey3b7a4072021-01-26 14:24:53 -0800741{
742 auto raEnabled =
743 std::get<bool>(getDbusProperty(bus, params.service, params.logicalPath,
744 INTF_ETHERNET, "IPv6AcceptRA"));
745 return raEnabled;
746}
747
748/** @brief Sets the IPv6AcceptRA flag
749 *
750 * @param[in] bus - The bus object used for lookups
751 * @param[in] params - The parameters for the channel
752 * @param[in] ipv6AcceptRA - boolean to enable/disable IPv6 Routing
753 * Advertisement
754 */
Patrick Williams5d82f472022-07-22 19:26:53 -0500755void setIPv6AcceptRA(sdbusplus::bus_t& bus, const ChannelParams& params,
Johnathan Mantey3b7a4072021-01-26 14:24:53 -0800756 const bool ipv6AcceptRA)
757{
758 setDbusProperty(bus, params.service, params.logicalPath, INTF_ETHERNET,
759 "IPv6AcceptRA", ipv6AcceptRA);
760}
761
Johnathan Manteyb87034e2019-09-16 10:50:50 -0700762/**
763 * Define placeholder command handlers for the OEM Extension bytes for the Set
764 * LAN Configuration Parameters and Get LAN Configuration Parameters
765 * commands. Using "weak" linking allows the placeholder setLanOem/getLanOem
766 * functions below to be overridden.
767 * To create handlers for your own proprietary command set:
768 * Create/modify a phosphor-ipmi-host Bitbake append file within your Yocto
769 * recipe
770 * Create C++ file(s) that define IPMI handler functions matching the
771 * function names below (i.e. setLanOem). The default name for the
772 * transport IPMI commands is transporthandler_oem.cpp.
773 * Add:
774 * EXTRA_OECONF_append = " --enable-transport-oem=yes"
775 * Create a do_compile_prepend()/do_install_append method in your
776 * bbappend file to copy the file to the build directory.
777 * Add:
778 * PROJECT_SRC_DIR := "${THISDIR}/${PN}"
779 * # Copy the "strong" functions into the working directory, overriding the
780 * # placeholder functions.
781 * do_compile_prepend(){
782 * cp -f ${PROJECT_SRC_DIR}/transporthandler_oem.cpp ${S}
783 * }
784 *
785 * # Clean up after complilation has completed
786 * do_install_append(){
787 * rm -f ${S}/transporthandler_oem.cpp
788 * }
789 *
790 */
791
792/**
793 * Define the placeholder OEM commands as having weak linkage. Create
794 * setLanOem, and getLanOem functions in the transporthandler_oem.cpp
795 * file. The functions defined there must not have the "weak" attribute
796 * applied to them.
797 */
798RspType<> setLanOem(uint8_t channel, uint8_t parameter, message::Payload& req)
799 __attribute__((weak));
800RspType<message::Payload> getLanOem(uint8_t channel, uint8_t parameter,
801 uint8_t set, uint8_t block)
802 __attribute__((weak));
803
Willy Tu11d68892022-01-20 10:37:34 -0800804RspType<> setLanOem(uint8_t, uint8_t, message::Payload& req)
Johnathan Manteyb87034e2019-09-16 10:50:50 -0700805{
806 req.trailingOk = true;
807 return response(ccParamNotSupported);
808}
809
Willy Tu11d68892022-01-20 10:37:34 -0800810RspType<message::Payload> getLanOem(uint8_t, uint8_t, uint8_t, uint8_t)
Johnathan Manteyb87034e2019-09-16 10:50:50 -0700811{
812 return response(ccParamNotSupported);
813}
Rajashekar Gade Reddy0b993fd2019-12-24 16:37:15 +0530814/**
815 * @brief is MAC address valid.
816 *
817 * This function checks whether the MAC address is valid or not.
818 *
819 * @param[in] mac - MAC address.
820 * @return true if MAC address is valid else retun false.
821 **/
822bool isValidMACAddress(const ether_addr& mac)
823{
824 // check if mac address is empty
825 if (equal(mac, ether_addr{}))
826 {
827 return false;
828 }
829 // we accept only unicast MAC addresses and same thing has been checked in
830 // phosphor-network layer. If the least significant bit of the first octet
831 // is set to 1, it is multicast MAC else it is unicast MAC address.
832 if (mac.ether_addr_octet[0] & 1)
833 {
834 return false;
835 }
836 return true;
837}
Johnathan Manteyb87034e2019-09-16 10:50:50 -0700838
vijayabharathix shettycc769252020-02-27 17:52:20 +0000839RspType<> setLan(Context::ptr ctx, uint4_t channelBits, uint4_t reserved1,
840 uint8_t parameter, message::Payload& req)
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700841{
vijayabharathix shettycc769252020-02-27 17:52:20 +0000842 const uint8_t channel = convertCurrentChannelNum(
843 static_cast<uint8_t>(channelBits), ctx->channel);
844 if (reserved1 || !isValidChannel(channel))
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700845 {
vijayabharathix shettycc769252020-02-27 17:52:20 +0000846 log<level::ERR>("Set Lan - Invalid field in request");
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700847 req.trailingOk = true;
848 return responseInvalidFieldRequest();
849 }
850
851 switch (static_cast<LanParam>(parameter))
852 {
853 case LanParam::SetStatus:
854 {
855 uint2_t flag;
856 uint6_t rsvd;
857 if (req.unpack(flag, rsvd) != 0 || !req.fullyUnpacked())
858 {
859 return responseReqDataLenInvalid();
860 }
Johnathan Mantey4a156852019-12-11 13:47:43 -0800861 if (rsvd)
862 {
863 return responseInvalidFieldRequest();
864 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700865 auto status = static_cast<SetStatus>(static_cast<uint8_t>(flag));
866 switch (status)
867 {
868 case SetStatus::Complete:
869 {
870 getSetStatus(channel) = status;
871 return responseSuccess();
872 }
873 case SetStatus::InProgress:
874 {
875 auto& storedStatus = getSetStatus(channel);
876 if (storedStatus == SetStatus::InProgress)
877 {
878 return response(ccParamSetLocked);
879 }
880 storedStatus = status;
881 return responseSuccess();
882 }
883 case SetStatus::Commit:
884 if (getSetStatus(channel) != SetStatus::InProgress)
885 {
886 return responseInvalidFieldRequest();
887 }
888 return responseSuccess();
889 }
890 return response(ccParamNotSupported);
891 }
892 case LanParam::AuthSupport:
893 {
894 req.trailingOk = true;
895 return response(ccParamReadOnly);
896 }
897 case LanParam::AuthEnables:
898 {
899 req.trailingOk = true;
Johnathan Mantey76ce9c72019-11-14 14:41:46 -0800900 return response(ccParamReadOnly);
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700901 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800902 case LanParam::IP:
Hariharasubramanian R83951912016-01-20 07:06:36 -0600903 {
Johnathan Mantey65265362019-11-14 11:24:19 -0800904 EthernetInterface::DHCPConf dhcp =
905 channelCall<getDHCPProperty>(channel);
906 if ((dhcp == EthernetInterface::DHCPConf::v4) ||
907 (dhcp == EthernetInterface::DHCPConf::both))
Johnathan Mantey930104a2019-12-17 09:18:34 -0800908 {
909 return responseCommandNotAvailable();
910 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700911 in_addr ip;
912 std::array<uint8_t, sizeof(ip)> bytes;
913 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
914 {
915 return responseReqDataLenInvalid();
916 }
917 copyInto(ip, bytes);
918 channelCall<reconfigureIfAddr4>(channel, ip, std::nullopt);
919 return responseSuccess();
Ratan Guptab8e99552017-07-27 07:07:48 +0530920 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700921 case LanParam::IPSrc:
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530922 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700923 uint4_t flag;
924 uint4_t rsvd;
925 if (req.unpack(flag, rsvd) != 0 || !req.fullyUnpacked())
926 {
927 return responseReqDataLenInvalid();
928 }
Johnathan Mantey4a156852019-12-11 13:47:43 -0800929 if (rsvd)
930 {
931 return responseInvalidFieldRequest();
932 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700933 switch (static_cast<IPSrc>(static_cast<uint8_t>(flag)))
934 {
935 case IPSrc::DHCP:
936 {
Johnathan Mantey65265362019-11-14 11:24:19 -0800937 // The IPSrc IPMI command is only for IPv4
938 // management. Modifying IPv6 state is done using
939 // a completely different Set LAN Configuration
940 // subcommand.
941 channelCall<setDHCPv4Property>(
942 channel, EthernetInterface::DHCPConf::v4);
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700943 return responseSuccess();
944 }
945 case IPSrc::Unspecified:
946 case IPSrc::Static:
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700947 {
Johnathan Mantey65265362019-11-14 11:24:19 -0800948 channelCall<setDHCPv4Property>(
949 channel, EthernetInterface::DHCPConf::none);
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700950 return responseSuccess();
951 }
Rajashekar Gade Reddy8a860ea2019-12-24 11:31:19 +0530952 case IPSrc::BIOS:
953 case IPSrc::BMC:
954 {
955 return responseInvalidFieldRequest();
956 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700957 }
958 return response(ccParamNotSupported);
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530959 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800960 case LanParam::MAC:
Ratan Guptab8e99552017-07-27 07:07:48 +0530961 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700962 ether_addr mac;
963 std::array<uint8_t, sizeof(mac)> bytes;
964 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
Suryakanth Sekar0a327e12019-08-08 14:30:19 +0530965 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700966 return responseReqDataLenInvalid();
Suryakanth Sekar0a327e12019-08-08 14:30:19 +0530967 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700968 copyInto(mac, bytes);
Rajashekar Gade Reddy0b993fd2019-12-24 16:37:15 +0530969
970 if (!isValidMACAddress(mac))
971 {
972 return responseInvalidFieldRequest();
973 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700974 channelCall<setMACProperty>(channel, mac);
975 return responseSuccess();
Ratan Gupta533d03b2017-07-30 10:39:22 +0530976 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700977 case LanParam::SubnetMask:
Ratan Guptab8e99552017-07-27 07:07:48 +0530978 {
Johnathan Mantey65265362019-11-14 11:24:19 -0800979 EthernetInterface::DHCPConf dhcp =
980 channelCall<getDHCPProperty>(channel);
981 if ((dhcp == EthernetInterface::DHCPConf::v4) ||
982 (dhcp == EthernetInterface::DHCPConf::both))
Johnathan Mantey930104a2019-12-17 09:18:34 -0800983 {
984 return responseCommandNotAvailable();
985 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700986 in_addr netmask;
987 std::array<uint8_t, sizeof(netmask)> bytes;
988 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
Ratan Guptab8e99552017-07-27 07:07:48 +0530989 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700990 return responseReqDataLenInvalid();
Ratan Guptab8e99552017-07-27 07:07:48 +0530991 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700992 copyInto(netmask, bytes);
Jiaqing Zhao6d4a44e2022-01-24 15:04:00 +0800993 uint8_t prefix = netmaskToPrefix(netmask);
994 if (prefix < MIN_IPV4_PREFIX_LENGTH)
995 {
996 return responseInvalidFieldRequest();
997 }
998 channelCall<reconfigureIfAddr4>(channel, std::nullopt, prefix);
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700999 return responseSuccess();
Ratan Guptab8e99552017-07-27 07:07:48 +05301000 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001001 case LanParam::Gateway1:
Ratan Guptab8e99552017-07-27 07:07:48 +05301002 {
Johnathan Mantey65265362019-11-14 11:24:19 -08001003 EthernetInterface::DHCPConf dhcp =
1004 channelCall<getDHCPProperty>(channel);
1005 if ((dhcp == EthernetInterface::DHCPConf::v4) ||
1006 (dhcp == EthernetInterface::DHCPConf::both))
Johnathan Mantey930104a2019-12-17 09:18:34 -08001007 {
1008 return responseCommandNotAvailable();
1009 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001010 in_addr gateway;
1011 std::array<uint8_t, sizeof(gateway)> bytes;
1012 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
1013 {
1014 return responseReqDataLenInvalid();
1015 }
1016 copyInto(gateway, bytes);
1017 channelCall<setGatewayProperty<AF_INET>>(channel, gateway);
1018 return responseSuccess();
1019 }
William A. Kennington III4bbc3db2019-04-15 00:02:10 -07001020 case LanParam::Gateway1MAC:
1021 {
1022 ether_addr gatewayMAC;
1023 std::array<uint8_t, sizeof(gatewayMAC)> bytes;
1024 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
1025 {
1026 return responseReqDataLenInvalid();
1027 }
1028 copyInto(gatewayMAC, bytes);
1029 channelCall<reconfigureGatewayMAC<AF_INET>>(channel, gatewayMAC);
1030 return responseSuccess();
1031 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001032 case LanParam::VLANId:
1033 {
Suryakanth Sekar8e8c8e22019-08-30 11:54:20 +05301034 uint12_t vlanData = 0;
1035 uint3_t reserved = 0;
1036 bool vlanEnable = 0;
1037
1038 if (req.unpack(vlanData) || req.unpack(reserved) ||
1039 req.unpack(vlanEnable) || !req.fullyUnpacked())
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001040 {
1041 return responseReqDataLenInvalid();
1042 }
Suryakanth Sekar8e8c8e22019-08-30 11:54:20 +05301043
1044 if (reserved)
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001045 {
Suryakanth Sekar8e8c8e22019-08-30 11:54:20 +05301046 return responseInvalidFieldRequest();
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001047 }
Suryakanth Sekar8e8c8e22019-08-30 11:54:20 +05301048
1049 uint16_t vlan = static_cast<uint16_t>(vlanData);
1050
1051 if (!vlanEnable)
1052 {
1053 lastDisabledVlan[channel] = vlan;
1054 vlan = 0;
1055 }
jayaprakash Mutyala84c49dc2020-05-18 23:12:13 +00001056 else if (vlan == 0 || vlan == VLAN_VALUE_MASK)
1057 {
1058 return responseInvalidFieldRequest();
1059 }
Suryakanth Sekar8e8c8e22019-08-30 11:54:20 +05301060
jayaprakash Mutyala84c49dc2020-05-18 23:12:13 +00001061 channelCall<reconfigureVLAN>(channel, vlan);
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001062 return responseSuccess();
1063 }
1064 case LanParam::CiphersuiteSupport:
1065 case LanParam::CiphersuiteEntries:
William A. Kennington III16064aa2019-04-13 17:44:53 -07001066 case LanParam::IPFamilySupport:
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001067 {
1068 req.trailingOk = true;
1069 return response(ccParamReadOnly);
Ratan Guptab8e99552017-07-27 07:07:48 +05301070 }
William A. Kennington III16064aa2019-04-13 17:44:53 -07001071 case LanParam::IPFamilyEnables:
1072 {
1073 uint8_t enables;
1074 if (req.unpack(enables) != 0 || !req.fullyUnpacked())
1075 {
1076 return responseReqDataLenInvalid();
1077 }
1078 switch (static_cast<IPFamilyEnables>(enables))
1079 {
1080 case IPFamilyEnables::DualStack:
1081 return responseSuccess();
1082 case IPFamilyEnables::IPv4Only:
1083 case IPFamilyEnables::IPv6Only:
1084 return response(ccParamNotSupported);
1085 }
1086 return response(ccParamNotSupported);
1087 }
1088 case LanParam::IPv6Status:
1089 {
1090 req.trailingOk = true;
1091 return response(ccParamReadOnly);
1092 }
1093 case LanParam::IPv6StaticAddresses:
1094 {
1095 uint8_t set;
1096 uint7_t rsvd;
1097 bool enabled;
1098 in6_addr ip;
1099 std::array<uint8_t, sizeof(ip)> ipbytes;
1100 uint8_t prefix;
1101 uint8_t status;
1102 if (req.unpack(set, rsvd, enabled, ipbytes, prefix, status) != 0 ||
1103 !req.fullyUnpacked())
1104 {
1105 return responseReqDataLenInvalid();
1106 }
Johnathan Mantey4a156852019-12-11 13:47:43 -08001107 if (rsvd)
1108 {
1109 return responseInvalidFieldRequest();
1110 }
William A. Kennington III16064aa2019-04-13 17:44:53 -07001111 copyInto(ip, ipbytes);
1112 if (enabled)
1113 {
Jiaqing Zhao6d4a44e2022-01-24 15:04:00 +08001114 if (prefix < MIN_IPV6_PREFIX_LENGTH ||
1115 prefix > MAX_IPV6_PREFIX_LENGTH)
1116 {
1117 return responseParmOutOfRange();
1118 }
Johnathan Manteya291f492021-10-15 13:45:27 -07001119 try
1120 {
1121 channelCall<reconfigureIfAddr6>(channel, set, ip, prefix);
1122 }
Patrick Williams5d82f472022-07-22 19:26:53 -05001123 catch (const sdbusplus::exception_t& e)
Johnathan Manteya291f492021-10-15 13:45:27 -07001124 {
1125 if (std::string_view err{
1126 "xyz.openbmc_project.Common.Error.InvalidArgument"};
1127 err == e.name())
1128 {
1129 return responseInvalidFieldRequest();
1130 }
1131 else
1132 {
1133 throw;
1134 }
1135 }
William A. Kennington III16064aa2019-04-13 17:44:53 -07001136 }
1137 else
1138 {
1139 channelCall<deconfigureIfAddr6>(channel, set);
1140 }
1141 return responseSuccess();
1142 }
1143 case LanParam::IPv6DynamicAddresses:
1144 {
1145 req.trailingOk = true;
1146 return response(ccParamReadOnly);
1147 }
1148 case LanParam::IPv6RouterControl:
1149 {
1150 std::bitset<8> control;
Johnathan Mantey3b7a4072021-01-26 14:24:53 -08001151 constexpr uint8_t reservedRACCBits = 0xfc;
William A. Kennington III16064aa2019-04-13 17:44:53 -07001152 if (req.unpack(control) != 0 || !req.fullyUnpacked())
1153 {
1154 return responseReqDataLenInvalid();
1155 }
Johnathan Mantey3b7a4072021-01-26 14:24:53 -08001156 if (std::bitset<8> expected(control &
1157 std::bitset<8>(reservedRACCBits));
1158 expected.any())
William A. Kennington III16064aa2019-04-13 17:44:53 -07001159 {
Johnathan Mantey3b7a4072021-01-26 14:24:53 -08001160 return response(ccParamNotSupported);
William A. Kennington III16064aa2019-04-13 17:44:53 -07001161 }
Johnathan Mantey3b7a4072021-01-26 14:24:53 -08001162
1163 bool enableRA = control[IPv6RouterControlFlag::Dynamic];
1164 channelCall<setIPv6AcceptRA>(channel, enableRA);
William A. Kennington III16064aa2019-04-13 17:44:53 -07001165 return responseSuccess();
1166 }
1167 case LanParam::IPv6StaticRouter1IP:
1168 {
1169 in6_addr gateway;
1170 std::array<uint8_t, sizeof(gateway)> bytes;
1171 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
1172 {
1173 return responseReqDataLenInvalid();
1174 }
1175 copyInto(gateway, bytes);
1176 channelCall<setGatewayProperty<AF_INET6>>(channel, gateway);
1177 return responseSuccess();
1178 }
1179 case LanParam::IPv6StaticRouter1MAC:
1180 {
1181 ether_addr mac;
1182 std::array<uint8_t, sizeof(mac)> bytes;
1183 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
1184 {
1185 return responseReqDataLenInvalid();
1186 }
1187 copyInto(mac, bytes);
1188 channelCall<reconfigureGatewayMAC<AF_INET6>>(channel, mac);
1189 return responseSuccess();
1190 }
1191 case LanParam::IPv6StaticRouter1PrefixLength:
1192 {
1193 uint8_t prefix;
1194 if (req.unpack(prefix) != 0 || !req.fullyUnpacked())
1195 {
1196 return responseReqDataLenInvalid();
1197 }
1198 if (prefix != 0)
1199 {
1200 return responseInvalidFieldRequest();
1201 }
1202 return responseSuccess();
1203 }
1204 case LanParam::IPv6StaticRouter1PrefixValue:
1205 {
1206 std::array<uint8_t, sizeof(in6_addr)> bytes;
1207 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
1208 {
1209 return responseReqDataLenInvalid();
1210 }
1211 // Accept any prefix value since our prefix length has to be 0
1212 return responseSuccess();
1213 }
jayaprakash Mutyalab741b992019-12-02 17:29:09 +00001214 case LanParam::cipherSuitePrivilegeLevels:
1215 {
1216 uint8_t reserved;
1217 std::array<uint4_t, ipmi::maxCSRecords> cipherSuitePrivs;
1218
1219 if (req.unpack(reserved, cipherSuitePrivs) || !req.fullyUnpacked())
1220 {
1221 return responseReqDataLenInvalid();
1222 }
1223
1224 if (reserved)
1225 {
1226 return responseInvalidFieldRequest();
1227 }
1228
1229 uint8_t resp =
1230 getCipherConfigObject(csPrivFileName, csPrivDefaultFileName)
1231 .setCSPrivilegeLevels(channel, cipherSuitePrivs);
1232 if (!resp)
1233 {
1234 return responseSuccess();
1235 }
1236 else
1237 {
1238 req.trailingOk = true;
1239 return response(resp);
1240 }
1241 }
Ratan Guptab8e99552017-07-27 07:07:48 +05301242 }
vishwa1eaea4f2016-02-26 11:57:40 -06001243
Johnathan Manteyb87034e2019-09-16 10:50:50 -07001244 if ((parameter >= oemCmdStart) && (parameter <= oemCmdEnd))
1245 {
1246 return setLanOem(channel, parameter, req);
1247 }
1248
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001249 req.trailingOk = true;
1250 return response(ccParamNotSupported);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001251}
1252
vijayabharathix shettycc769252020-02-27 17:52:20 +00001253RspType<message::Payload> getLan(Context::ptr ctx, uint4_t channelBits,
1254 uint3_t reserved, bool revOnly,
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001255 uint8_t parameter, uint8_t set, uint8_t block)
Ratan Guptab8e99552017-07-27 07:07:48 +05301256{
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001257 message::Payload ret;
1258 constexpr uint8_t current_revision = 0x11;
1259 ret.pack(current_revision);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001260
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001261 if (revOnly)
Suryakanth Sekare4054402019-08-08 15:16:52 +05301262 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001263 return responseSuccess(std::move(ret));
Suryakanth Sekare4054402019-08-08 15:16:52 +05301264 }
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001265
vijayabharathix shettycc769252020-02-27 17:52:20 +00001266 const uint8_t channel = convertCurrentChannelNum(
1267 static_cast<uint8_t>(channelBits), ctx->channel);
1268 if (reserved || !isValidChannel(channel))
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001269 {
vijayabharathix shettycc769252020-02-27 17:52:20 +00001270 log<level::ERR>("Get Lan - Invalid field in request");
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001271 return responseInvalidFieldRequest();
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001272 }
1273
Johnathan Manteyaffadb52019-10-07 10:13:53 -07001274 static std::vector<uint8_t> cipherList;
1275 static bool listInit = false;
1276 if (!listInit)
1277 {
1278 try
1279 {
1280 cipherList = cipher::getCipherList();
1281 listInit = true;
1282 }
1283 catch (const std::exception& e)
1284 {
1285 }
1286 }
1287
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001288 switch (static_cast<LanParam>(parameter))
Tom Josepha30c8d32018-03-22 02:15:03 +05301289 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001290 case LanParam::SetStatus:
Tom Josepha30c8d32018-03-22 02:15:03 +05301291 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001292 SetStatus status;
1293 try
1294 {
1295 status = setStatus.at(channel);
1296 }
1297 catch (const std::out_of_range&)
1298 {
1299 status = SetStatus::Complete;
1300 }
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001301 ret.pack(types::enum_cast<uint2_t>(status), uint6_t{});
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001302 return responseSuccess(std::move(ret));
Tom Josepha30c8d32018-03-22 02:15:03 +05301303 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001304 case LanParam::AuthSupport:
Tom Josepha30c8d32018-03-22 02:15:03 +05301305 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001306 std::bitset<6> support;
1307 ret.pack(support, uint2_t{});
1308 return responseSuccess(std::move(ret));
Tom Josepha30c8d32018-03-22 02:15:03 +05301309 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001310 case LanParam::AuthEnables:
vishwa1eaea4f2016-02-26 11:57:40 -06001311 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001312 std::bitset<6> enables;
1313 ret.pack(enables, uint2_t{}); // Callback
1314 ret.pack(enables, uint2_t{}); // User
1315 ret.pack(enables, uint2_t{}); // Operator
1316 ret.pack(enables, uint2_t{}); // Admin
1317 ret.pack(enables, uint2_t{}); // OEM
1318 return responseSuccess(std::move(ret));
William A. Kennington III39f94ef2018-11-19 22:36:16 -08001319 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -08001320 case LanParam::IP:
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001321 {
1322 auto ifaddr = channelCall<getIfAddr4>(channel);
1323 in_addr addr{};
1324 if (ifaddr)
1325 {
1326 addr = ifaddr->address;
1327 }
1328 ret.pack(dataRef(addr));
1329 return responseSuccess(std::move(ret));
1330 }
1331 case LanParam::IPSrc:
1332 {
1333 auto src = IPSrc::Static;
Johnathan Mantey65265362019-11-14 11:24:19 -08001334 EthernetInterface::DHCPConf dhcp =
1335 channelCall<getDHCPProperty>(channel);
1336 if ((dhcp == EthernetInterface::DHCPConf::v4) ||
1337 (dhcp == EthernetInterface::DHCPConf::both))
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001338 {
1339 src = IPSrc::DHCP;
1340 }
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001341 ret.pack(types::enum_cast<uint4_t>(src), uint4_t{});
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001342 return responseSuccess(std::move(ret));
1343 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -08001344 case LanParam::MAC:
William A. Kennington III39f94ef2018-11-19 22:36:16 -08001345 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001346 ether_addr mac = channelCall<getMACProperty>(channel);
1347 ret.pack(dataRef(mac));
1348 return responseSuccess(std::move(ret));
1349 }
1350 case LanParam::SubnetMask:
1351 {
1352 auto ifaddr = channelCall<getIfAddr4>(channel);
1353 uint8_t prefix = AddrFamily<AF_INET>::defaultPrefix;
1354 if (ifaddr)
Ratan Guptab8e99552017-07-27 07:07:48 +05301355 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001356 prefix = ifaddr->prefix;
1357 }
1358 in_addr netmask = prefixToNetmask(prefix);
1359 ret.pack(dataRef(netmask));
1360 return responseSuccess(std::move(ret));
1361 }
1362 case LanParam::Gateway1:
1363 {
1364 auto gateway =
1365 channelCall<getGatewayProperty<AF_INET>>(channel).value_or(
1366 in_addr{});
1367 ret.pack(dataRef(gateway));
1368 return responseSuccess(std::move(ret));
1369 }
William A. Kennington III4bbc3db2019-04-15 00:02:10 -07001370 case LanParam::Gateway1MAC:
1371 {
1372 ether_addr mac{};
1373 auto neighbor = channelCall<getGatewayNeighbor<AF_INET>>(channel);
1374 if (neighbor)
1375 {
1376 mac = neighbor->mac;
1377 }
1378 ret.pack(dataRef(mac));
1379 return responseSuccess(std::move(ret));
1380 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001381 case LanParam::VLANId:
1382 {
1383 uint16_t vlan = channelCall<getVLANProperty>(channel);
1384 if (vlan != 0)
1385 {
1386 vlan |= VLAN_ENABLE_FLAG;
Ratan Guptab8e99552017-07-27 07:07:48 +05301387 }
1388 else
1389 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001390 vlan = lastDisabledVlan[channel];
Ratan Guptab8e99552017-07-27 07:07:48 +05301391 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001392 ret.pack(vlan);
1393 return responseSuccess(std::move(ret));
Adriana Kobylak342df102016-02-10 13:48:16 -06001394 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001395 case LanParam::CiphersuiteSupport:
Johnathan Manteyaffadb52019-10-07 10:13:53 -07001396 {
srikanta mondal1d8579c2020-04-15 17:13:25 +00001397 if (getChannelSessionSupport(channel) ==
1398 EChannelSessSupported::none)
1399 {
1400 return responseInvalidFieldRequest();
1401 }
Johnathan Manteyaffadb52019-10-07 10:13:53 -07001402 if (!listInit)
1403 {
1404 return responseUnspecifiedError();
1405 }
1406 ret.pack(static_cast<uint8_t>(cipherList.size() - 1));
1407 return responseSuccess(std::move(ret));
1408 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001409 case LanParam::CiphersuiteEntries:
Johnathan Manteyaffadb52019-10-07 10:13:53 -07001410 {
srikanta mondal1d8579c2020-04-15 17:13:25 +00001411 if (getChannelSessionSupport(channel) ==
1412 EChannelSessSupported::none)
1413 {
1414 return responseInvalidFieldRequest();
1415 }
Johnathan Manteyaffadb52019-10-07 10:13:53 -07001416 if (!listInit)
1417 {
1418 return responseUnspecifiedError();
1419 }
1420 ret.pack(cipherList);
1421 return responseSuccess(std::move(ret));
1422 }
William A. Kennington III16064aa2019-04-13 17:44:53 -07001423 case LanParam::IPFamilySupport:
1424 {
1425 std::bitset<8> support;
1426 support[IPFamilySupportFlag::IPv6Only] = 0;
1427 support[IPFamilySupportFlag::DualStack] = 1;
1428 support[IPFamilySupportFlag::IPv6Alerts] = 1;
1429 ret.pack(support);
1430 return responseSuccess(std::move(ret));
1431 }
1432 case LanParam::IPFamilyEnables:
1433 {
1434 ret.pack(static_cast<uint8_t>(IPFamilyEnables::DualStack));
1435 return responseSuccess(std::move(ret));
1436 }
1437 case LanParam::IPv6Status:
1438 {
1439 ret.pack(MAX_IPV6_STATIC_ADDRESSES);
1440 ret.pack(MAX_IPV6_DYNAMIC_ADDRESSES);
1441 std::bitset<8> support;
1442 support[IPv6StatusFlag::DHCP] = 1;
1443 support[IPv6StatusFlag::SLAAC] = 1;
1444 ret.pack(support);
1445 return responseSuccess(std::move(ret));
1446 }
1447 case LanParam::IPv6StaticAddresses:
1448 {
1449 if (set >= MAX_IPV6_STATIC_ADDRESSES)
1450 {
1451 return responseParmOutOfRange();
1452 }
1453 getLanIPv6Address(ret, channel, set, originsV6Static);
1454 return responseSuccess(std::move(ret));
1455 }
1456 case LanParam::IPv6DynamicAddresses:
1457 {
1458 if (set >= MAX_IPV6_DYNAMIC_ADDRESSES)
1459 {
1460 return responseParmOutOfRange();
1461 }
1462 getLanIPv6Address(ret, channel, set, originsV6Dynamic);
1463 return responseSuccess(std::move(ret));
1464 }
1465 case LanParam::IPv6RouterControl:
1466 {
1467 std::bitset<8> control;
Johnathan Mantey3b7a4072021-01-26 14:24:53 -08001468 control[IPv6RouterControlFlag::Dynamic] =
1469 channelCall<getIPv6AcceptRA>(channel);
1470 control[IPv6RouterControlFlag::Static] = 1;
William A. Kennington III16064aa2019-04-13 17:44:53 -07001471 ret.pack(control);
1472 return responseSuccess(std::move(ret));
1473 }
1474 case LanParam::IPv6StaticRouter1IP:
1475 {
1476 in6_addr gateway{};
Johnathan Mantey65265362019-11-14 11:24:19 -08001477 EthernetInterface::DHCPConf dhcp =
1478 channelCall<getDHCPProperty>(channel);
1479 if ((dhcp == EthernetInterface::DHCPConf::v4) ||
1480 (dhcp == EthernetInterface::DHCPConf::none))
William A. Kennington III16064aa2019-04-13 17:44:53 -07001481 {
1482 gateway =
1483 channelCall<getGatewayProperty<AF_INET6>>(channel).value_or(
1484 in6_addr{});
1485 }
1486 ret.pack(dataRef(gateway));
1487 return responseSuccess(std::move(ret));
1488 }
1489 case LanParam::IPv6StaticRouter1MAC:
1490 {
1491 ether_addr mac{};
1492 auto neighbor = channelCall<getGatewayNeighbor<AF_INET6>>(channel);
1493 if (neighbor)
1494 {
1495 mac = neighbor->mac;
1496 }
1497 ret.pack(dataRef(mac));
1498 return responseSuccess(std::move(ret));
1499 }
1500 case LanParam::IPv6StaticRouter1PrefixLength:
1501 {
1502 ret.pack(UINT8_C(0));
1503 return responseSuccess(std::move(ret));
1504 }
1505 case LanParam::IPv6StaticRouter1PrefixValue:
1506 {
1507 in6_addr prefix{};
1508 ret.pack(dataRef(prefix));
1509 return responseSuccess(std::move(ret));
1510 }
jayaprakash Mutyalab741b992019-12-02 17:29:09 +00001511 case LanParam::cipherSuitePrivilegeLevels:
1512 {
1513 std::array<uint4_t, ipmi::maxCSRecords> csPrivilegeLevels;
1514
1515 uint8_t resp =
1516 getCipherConfigObject(csPrivFileName, csPrivDefaultFileName)
1517 .getCSPrivilegeLevels(channel, csPrivilegeLevels);
1518 if (!resp)
1519 {
1520 constexpr uint8_t reserved1 = 0x00;
1521 ret.pack(reserved1, csPrivilegeLevels);
1522 return responseSuccess(std::move(ret));
1523 }
1524 else
1525 {
1526 return response(resp);
1527 }
1528 }
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001529 }
1530
Johnathan Manteyb87034e2019-09-16 10:50:50 -07001531 if ((parameter >= oemCmdStart) && (parameter <= oemCmdEnd))
1532 {
1533 return getLanOem(channel, parameter, set, block);
1534 }
1535
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001536 return response(ccParamNotSupported);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001537}
1538
Jian Zhang23f44652022-03-17 17:13:10 +08001539constexpr const char* solInterface = "xyz.openbmc_project.Ipmi.SOL";
1540constexpr const char* solPath = "/xyz/openbmc_project/ipmi/sol/";
1541constexpr const uint16_t solDefaultPort = 623;
1542
1543RspType<> setSolConfParams(Context::ptr ctx, uint4_t channelBits,
Willy Tu11d68892022-01-20 10:37:34 -08001544 uint4_t /*reserved*/, uint8_t parameter,
Jian Zhang23f44652022-03-17 17:13:10 +08001545 message::Payload& req)
1546{
1547 const uint8_t channel = convertCurrentChannelNum(
1548 static_cast<uint8_t>(channelBits), ctx->channel);
1549
1550 if (!isValidChannel(channel))
1551 {
1552 log<level::ERR>("Set Sol Config - Invalid channel in request");
1553 return responseInvalidFieldRequest();
1554 }
1555
1556 std::string solService{};
1557 std::string solPathWitheEthName = solPath + ipmi::getChannelName(channel);
1558
1559 if (ipmi::getService(ctx, solInterface, solPathWitheEthName, solService))
1560 {
1561 log<level::ERR>("Set Sol Config - Invalid solInterface",
1562 entry("SERVICE=%s", solService.c_str()),
1563 entry("OBJPATH=%s", solPathWitheEthName.c_str()),
1564 entry("INTERFACE=%s", solInterface));
1565 return responseInvalidFieldRequest();
1566 }
1567
1568 switch (static_cast<SolConfParam>(parameter))
1569 {
1570 case SolConfParam::Progress:
1571 {
1572 uint8_t progress;
1573 if (req.unpack(progress) != 0 || !req.fullyUnpacked())
1574 {
1575 return responseReqDataLenInvalid();
1576 }
1577
1578 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1579 solInterface, "Progress", progress))
1580 {
1581 return responseUnspecifiedError();
1582 }
1583 break;
1584 }
1585 case SolConfParam::Enable:
1586 {
1587 bool enable;
1588 uint7_t reserved2;
1589
1590 if (req.unpack(enable, reserved2) != 0 || !req.fullyUnpacked())
1591 {
1592 return responseReqDataLenInvalid();
1593 }
1594
1595 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1596 solInterface, "Enable", enable))
1597 {
1598 return responseUnspecifiedError();
1599 }
1600 break;
1601 }
1602 case SolConfParam::Authentication:
1603 {
1604 uint4_t privilegeBits{};
1605 uint2_t reserved2{};
1606 bool forceAuth = false;
1607 bool forceEncrypt = false;
1608
1609 if (req.unpack(privilegeBits, reserved2, forceAuth, forceEncrypt) !=
1610 0 ||
1611 !req.fullyUnpacked())
1612 {
1613 return responseReqDataLenInvalid();
1614 }
1615
1616 uint8_t privilege = static_cast<uint8_t>(privilegeBits);
1617 if (privilege < static_cast<uint8_t>(Privilege::None) ||
1618 privilege > static_cast<uint8_t>(Privilege::Oem))
1619 {
1620 return ipmi::responseInvalidFieldRequest();
1621 }
1622
1623 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1624 solInterface, "Privilege", privilege))
1625 {
1626 return responseUnspecifiedError();
1627 }
1628
1629 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1630 solInterface, "ForceEncryption",
1631 forceEncrypt))
1632 {
1633 return responseUnspecifiedError();
1634 }
1635
1636 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1637 solInterface, "ForceAuthentication",
1638 forceAuth))
1639 {
1640 return responseUnspecifiedError();
1641 }
1642 break;
1643 }
1644 case SolConfParam::Accumulate:
1645 {
1646 uint8_t interval;
1647 uint8_t threshold;
1648 if (req.unpack(interval, threshold) != 0 || !req.fullyUnpacked())
1649 {
1650 return responseReqDataLenInvalid();
1651 }
1652
1653 if (threshold == 0)
1654 {
1655 return responseInvalidFieldRequest();
1656 }
1657
1658 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1659 solInterface, "AccumulateIntervalMS",
1660 interval))
1661 {
1662 return responseUnspecifiedError();
1663 }
1664
1665 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1666 solInterface, "Threshold", threshold))
1667 {
1668 return responseUnspecifiedError();
1669 }
1670 break;
1671 }
1672 case SolConfParam::Retry:
1673 {
1674 uint3_t countBits;
1675 uint5_t reserved2;
1676 uint8_t interval;
1677
1678 if (req.unpack(countBits, reserved2, interval) != 0 ||
1679 !req.fullyUnpacked())
1680 {
1681 return responseReqDataLenInvalid();
1682 }
1683
1684 uint8_t count = static_cast<uint8_t>(countBits);
1685 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1686 solInterface, "RetryCount", count))
1687 {
1688 return responseUnspecifiedError();
1689 }
1690
1691 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1692 solInterface, "RetryIntervalMS",
1693 interval))
1694 {
1695 return responseUnspecifiedError();
1696 }
1697 break;
1698 }
1699 case SolConfParam::Port:
1700 {
1701 return response(ipmiCCWriteReadParameter);
1702 }
1703 case SolConfParam::NonVbitrate:
1704 case SolConfParam::Vbitrate:
1705 case SolConfParam::Channel:
1706 default:
1707 return response(ipmiCCParamNotSupported);
1708 }
1709 return responseSuccess();
1710}
1711
1712RspType<message::Payload> getSolConfParams(Context::ptr ctx,
1713 uint4_t channelBits,
Willy Tu11d68892022-01-20 10:37:34 -08001714 uint3_t /*reserved*/, bool revOnly,
1715 uint8_t parameter, uint8_t /*set*/,
1716 uint8_t /*block*/)
Jian Zhang23f44652022-03-17 17:13:10 +08001717{
1718 message::Payload ret;
1719 constexpr uint8_t current_revision = 0x11;
1720 ret.pack(current_revision);
1721 if (revOnly)
1722 {
1723 return responseSuccess(std::move(ret));
1724 }
1725
1726 const uint8_t channel = convertCurrentChannelNum(
1727 static_cast<uint8_t>(channelBits), ctx->channel);
1728
1729 if (!isValidChannel(channel))
1730 {
1731 log<level::ERR>("Get Sol Config - Invalid channel in request");
1732 return responseInvalidFieldRequest();
1733 }
1734
1735 std::string solService{};
1736 std::string solPathWitheEthName = solPath + ipmi::getChannelName(channel);
1737
1738 if (ipmi::getService(ctx, solInterface, solPathWitheEthName, solService))
1739 {
1740 log<level::ERR>("Set Sol Config - Invalid solInterface",
1741 entry("SERVICE=%s", solService.c_str()),
1742 entry("OBJPATH=%s", solPathWitheEthName.c_str()),
1743 entry("INTERFACE=%s", solInterface));
1744 return responseInvalidFieldRequest();
1745 }
1746
1747 switch (static_cast<SolConfParam>(parameter))
1748 {
1749 case SolConfParam::Progress:
1750 {
1751 uint8_t progress;
1752 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1753 solInterface, "Progress", progress))
1754 {
1755 return responseUnspecifiedError();
1756 }
1757 ret.pack(progress);
1758 return responseSuccess(std::move(ret));
1759 }
1760 case SolConfParam::Enable:
1761 {
1762 bool enable{};
1763 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1764 solInterface, "Enable", enable))
1765 {
1766 return responseUnspecifiedError();
1767 }
1768 ret.pack(enable, uint7_t{});
1769 return responseSuccess(std::move(ret));
1770 }
1771 case SolConfParam::Authentication:
1772 {
1773 // 4bits, cast when pack
1774 uint8_t privilege;
1775 bool forceAuth = false;
1776 bool forceEncrypt = false;
1777
1778 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1779 solInterface, "Privilege", privilege))
1780 {
1781 return responseUnspecifiedError();
1782 }
1783
1784 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1785 solInterface, "ForceAuthentication",
1786 forceAuth))
1787 {
1788 return responseUnspecifiedError();
1789 }
1790
1791 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1792 solInterface, "ForceEncryption",
1793 forceEncrypt))
1794 {
1795 return responseUnspecifiedError();
1796 }
1797 ret.pack(uint4_t{privilege}, uint2_t{}, forceAuth, forceEncrypt);
1798 return responseSuccess(std::move(ret));
1799 }
1800 case SolConfParam::Accumulate:
1801 {
1802 uint8_t interval{}, threshold{};
1803
1804 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1805 solInterface, "AccumulateIntervalMS",
1806 interval))
1807 {
1808 return responseUnspecifiedError();
1809 }
1810
1811 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1812 solInterface, "Threshold", threshold))
1813 {
1814 return responseUnspecifiedError();
1815 }
1816 ret.pack(interval, threshold);
1817 return responseSuccess(std::move(ret));
1818 }
1819 case SolConfParam::Retry:
1820 {
1821 // 3bits, cast when cast
1822 uint8_t count{};
1823 uint8_t interval{};
1824
1825 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1826 solInterface, "RetryCount", count))
1827 {
1828 return responseUnspecifiedError();
1829 }
1830
1831 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1832 solInterface, "RetryIntervalMS",
1833 interval))
1834 {
1835 return responseUnspecifiedError();
1836 }
1837 ret.pack(uint3_t{count}, uint5_t{}, interval);
1838 return responseSuccess(std::move(ret));
1839 }
1840 case SolConfParam::Port:
1841 {
1842 auto port = solDefaultPort;
1843 ret.pack(static_cast<uint16_t>(port));
1844 return responseSuccess(std::move(ret));
1845 }
1846 case SolConfParam::Channel:
1847 {
1848 ret.pack(channel);
1849 return responseSuccess(std::move(ret));
1850 }
1851 case SolConfParam::NonVbitrate:
1852 case SolConfParam::Vbitrate:
1853 default:
1854 return response(ipmiCCParamNotSupported);
1855 }
1856
1857 return response(ccParamNotSupported);
1858}
1859
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001860} // namespace transport
1861} // namespace ipmi
Ratan Gupta1247e0b2018-03-07 10:47:25 +05301862
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001863void register_netfn_transport_functions() __attribute__((constructor));
Ratan Gupta1247e0b2018-03-07 10:47:25 +05301864
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001865void register_netfn_transport_functions()
1866{
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001867 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnTransport,
1868 ipmi::transport::cmdSetLanConfigParameters,
1869 ipmi::Privilege::Admin, ipmi::transport::setLan);
1870 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnTransport,
1871 ipmi::transport::cmdGetLanConfigParameters,
Johnathan Mantey34698d52019-11-19 14:47:30 -08001872 ipmi::Privilege::Operator, ipmi::transport::getLan);
Jian Zhang23f44652022-03-17 17:13:10 +08001873 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnTransport,
1874 ipmi::transport::cmdSetSolConfigParameters,
1875 ipmi::Privilege::Admin,
1876 ipmi::transport::setSolConfParams);
1877 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnTransport,
1878 ipmi::transport::cmdGetSolConfigParameters,
1879 ipmi::Privilege::User,
1880 ipmi::transport::getSolConfParams);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001881}