blob: 056c3f590f09192f59627c7e064a5f81539e848f [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
William A. Kennington IIIc514d872019-04-06 18:19:38 -070060std::optional<ChannelParams> maybeGetChannelParams(sdbusplus::bus::bus& bus,
61 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);
128 return std::move(params);
129}
130
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700131ChannelParams getChannelParams(sdbusplus::bus::bus& bus, uint8_t channel)
132{
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
Johnathan Mantey65265362019-11-14 11:24:19 -0800165EthernetInterface::DHCPConf getDHCPProperty(sdbusplus::bus::bus& bus,
166 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 */
Johnathan Mantey65265362019-11-14 11:24:19 -0800183void setDHCPv4Property(sdbusplus::bus::bus& bus, const ChannelParams& params,
184 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
Johnathan Mantey65265362019-11-14 11:24:19 -0800221void setDHCPv6Property(sdbusplus::bus::bus& bus, const ChannelParams& params,
222 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 */
287ether_addr getMACProperty(sdbusplus::bus::bus& bus, const ChannelParams& params)
288{
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 */
300void setMACProperty(sdbusplus::bus::bus& bus, const ChannelParams& params,
301 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
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700308void deleteObjectIfExists(sdbusplus::bus::bus& bus, const std::string& service,
309 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 Williamsef1259b2021-09-02 09:12:33 -0500321 catch (const sdbusplus::exception::exception& 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>
343void createIfAddr(sdbusplus::bus::bus& bus, const ChannelParams& params,
344 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 */
363auto getIfAddr4(sdbusplus::bus::bus& 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 */
375void reconfigureIfAddr4(sdbusplus::bus::bus& bus, const ChannelParams& params,
376 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>
William A. Kennington III4bbc3db2019-04-15 00:02:10 -0700396std::optional<IfNeigh<family>> findGatewayNeighbor(sdbusplus::bus::bus& bus,
397 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>
410std::optional<IfNeigh<family>> getGatewayNeighbor(sdbusplus::bus::bus& bus,
411 const ChannelParams& params)
412{
413 ObjectLookupCache neighbors(bus, params, INTF_NEIGHBOR);
414 return findGatewayNeighbor<family>(bus, params, neighbors);
415}
416
417template <int family>
418void reconfigureGatewayMAC(sdbusplus::bus::bus& bus,
419 const ChannelParams& params, const ether_addr& mac)
420{
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 */
445void deconfigureIfAddr6(sdbusplus::bus::bus& bus, const ChannelParams& params,
446 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 */
463void reconfigureIfAddr6(sdbusplus::bus::bus& bus, const ChannelParams& params,
464 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 */
536uint16_t getVLANProperty(sdbusplus::bus::bus& bus, const ChannelParams& params)
537{
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 */
560void deconfigureChannel(sdbusplus::bus::bus& 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 */
596void createVLAN(sdbusplus::bus::bus& 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 */
618void reconfigureVLAN(sdbusplus::bus::bus& bus, ChannelParams& params,
619 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 */
740static bool getIPv6AcceptRA(sdbusplus::bus::bus& bus,
741 const ChannelParams& params)
742{
743 auto raEnabled =
744 std::get<bool>(getDbusProperty(bus, params.service, params.logicalPath,
745 INTF_ETHERNET, "IPv6AcceptRA"));
746 return raEnabled;
747}
748
749/** @brief Sets the IPv6AcceptRA flag
750 *
751 * @param[in] bus - The bus object used for lookups
752 * @param[in] params - The parameters for the channel
753 * @param[in] ipv6AcceptRA - boolean to enable/disable IPv6 Routing
754 * Advertisement
755 */
756void setIPv6AcceptRA(sdbusplus::bus::bus& bus, const ChannelParams& params,
757 const bool ipv6AcceptRA)
758{
759 setDbusProperty(bus, params.service, params.logicalPath, INTF_ETHERNET,
760 "IPv6AcceptRA", ipv6AcceptRA);
761}
762
Johnathan Manteyb87034e2019-09-16 10:50:50 -0700763/**
764 * Define placeholder command handlers for the OEM Extension bytes for the Set
765 * LAN Configuration Parameters and Get LAN Configuration Parameters
766 * commands. Using "weak" linking allows the placeholder setLanOem/getLanOem
767 * functions below to be overridden.
768 * To create handlers for your own proprietary command set:
769 * Create/modify a phosphor-ipmi-host Bitbake append file within your Yocto
770 * recipe
771 * Create C++ file(s) that define IPMI handler functions matching the
772 * function names below (i.e. setLanOem). The default name for the
773 * transport IPMI commands is transporthandler_oem.cpp.
774 * Add:
775 * EXTRA_OECONF_append = " --enable-transport-oem=yes"
776 * Create a do_compile_prepend()/do_install_append method in your
777 * bbappend file to copy the file to the build directory.
778 * Add:
779 * PROJECT_SRC_DIR := "${THISDIR}/${PN}"
780 * # Copy the "strong" functions into the working directory, overriding the
781 * # placeholder functions.
782 * do_compile_prepend(){
783 * cp -f ${PROJECT_SRC_DIR}/transporthandler_oem.cpp ${S}
784 * }
785 *
786 * # Clean up after complilation has completed
787 * do_install_append(){
788 * rm -f ${S}/transporthandler_oem.cpp
789 * }
790 *
791 */
792
793/**
794 * Define the placeholder OEM commands as having weak linkage. Create
795 * setLanOem, and getLanOem functions in the transporthandler_oem.cpp
796 * file. The functions defined there must not have the "weak" attribute
797 * applied to them.
798 */
799RspType<> setLanOem(uint8_t channel, uint8_t parameter, message::Payload& req)
800 __attribute__((weak));
801RspType<message::Payload> getLanOem(uint8_t channel, uint8_t parameter,
802 uint8_t set, uint8_t block)
803 __attribute__((weak));
804
805RspType<> setLanOem(uint8_t channel, uint8_t parameter, message::Payload& req)
806{
807 req.trailingOk = true;
808 return response(ccParamNotSupported);
809}
810
811RspType<message::Payload> getLanOem(uint8_t channel, uint8_t parameter,
812 uint8_t set, uint8_t block)
813{
814 return response(ccParamNotSupported);
815}
Rajashekar Gade Reddy0b993fd2019-12-24 16:37:15 +0530816/**
817 * @brief is MAC address valid.
818 *
819 * This function checks whether the MAC address is valid or not.
820 *
821 * @param[in] mac - MAC address.
822 * @return true if MAC address is valid else retun false.
823 **/
824bool isValidMACAddress(const ether_addr& mac)
825{
826 // check if mac address is empty
827 if (equal(mac, ether_addr{}))
828 {
829 return false;
830 }
831 // we accept only unicast MAC addresses and same thing has been checked in
832 // phosphor-network layer. If the least significant bit of the first octet
833 // is set to 1, it is multicast MAC else it is unicast MAC address.
834 if (mac.ether_addr_octet[0] & 1)
835 {
836 return false;
837 }
838 return true;
839}
Johnathan Manteyb87034e2019-09-16 10:50:50 -0700840
vijayabharathix shettycc769252020-02-27 17:52:20 +0000841RspType<> setLan(Context::ptr ctx, uint4_t channelBits, uint4_t reserved1,
842 uint8_t parameter, message::Payload& req)
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700843{
vijayabharathix shettycc769252020-02-27 17:52:20 +0000844 const uint8_t channel = convertCurrentChannelNum(
845 static_cast<uint8_t>(channelBits), ctx->channel);
846 if (reserved1 || !isValidChannel(channel))
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700847 {
vijayabharathix shettycc769252020-02-27 17:52:20 +0000848 log<level::ERR>("Set Lan - Invalid field in request");
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700849 req.trailingOk = true;
850 return responseInvalidFieldRequest();
851 }
852
853 switch (static_cast<LanParam>(parameter))
854 {
855 case LanParam::SetStatus:
856 {
857 uint2_t flag;
858 uint6_t rsvd;
859 if (req.unpack(flag, rsvd) != 0 || !req.fullyUnpacked())
860 {
861 return responseReqDataLenInvalid();
862 }
Johnathan Mantey4a156852019-12-11 13:47:43 -0800863 if (rsvd)
864 {
865 return responseInvalidFieldRequest();
866 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700867 auto status = static_cast<SetStatus>(static_cast<uint8_t>(flag));
868 switch (status)
869 {
870 case SetStatus::Complete:
871 {
872 getSetStatus(channel) = status;
873 return responseSuccess();
874 }
875 case SetStatus::InProgress:
876 {
877 auto& storedStatus = getSetStatus(channel);
878 if (storedStatus == SetStatus::InProgress)
879 {
880 return response(ccParamSetLocked);
881 }
882 storedStatus = status;
883 return responseSuccess();
884 }
885 case SetStatus::Commit:
886 if (getSetStatus(channel) != SetStatus::InProgress)
887 {
888 return responseInvalidFieldRequest();
889 }
890 return responseSuccess();
891 }
892 return response(ccParamNotSupported);
893 }
894 case LanParam::AuthSupport:
895 {
896 req.trailingOk = true;
897 return response(ccParamReadOnly);
898 }
899 case LanParam::AuthEnables:
900 {
901 req.trailingOk = true;
Johnathan Mantey76ce9c72019-11-14 14:41:46 -0800902 return response(ccParamReadOnly);
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700903 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800904 case LanParam::IP:
Hariharasubramanian R83951912016-01-20 07:06:36 -0600905 {
Johnathan Mantey65265362019-11-14 11:24:19 -0800906 EthernetInterface::DHCPConf dhcp =
907 channelCall<getDHCPProperty>(channel);
908 if ((dhcp == EthernetInterface::DHCPConf::v4) ||
909 (dhcp == EthernetInterface::DHCPConf::both))
Johnathan Mantey930104a2019-12-17 09:18:34 -0800910 {
911 return responseCommandNotAvailable();
912 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700913 in_addr ip;
914 std::array<uint8_t, sizeof(ip)> bytes;
915 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
916 {
917 return responseReqDataLenInvalid();
918 }
919 copyInto(ip, bytes);
920 channelCall<reconfigureIfAddr4>(channel, ip, std::nullopt);
921 return responseSuccess();
Ratan Guptab8e99552017-07-27 07:07:48 +0530922 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700923 case LanParam::IPSrc:
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530924 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700925 uint4_t flag;
926 uint4_t rsvd;
927 if (req.unpack(flag, rsvd) != 0 || !req.fullyUnpacked())
928 {
929 return responseReqDataLenInvalid();
930 }
Johnathan Mantey4a156852019-12-11 13:47:43 -0800931 if (rsvd)
932 {
933 return responseInvalidFieldRequest();
934 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700935 switch (static_cast<IPSrc>(static_cast<uint8_t>(flag)))
936 {
937 case IPSrc::DHCP:
938 {
Johnathan Mantey65265362019-11-14 11:24:19 -0800939 // The IPSrc IPMI command is only for IPv4
940 // management. Modifying IPv6 state is done using
941 // a completely different Set LAN Configuration
942 // subcommand.
943 channelCall<setDHCPv4Property>(
944 channel, EthernetInterface::DHCPConf::v4);
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700945 return responseSuccess();
946 }
947 case IPSrc::Unspecified:
948 case IPSrc::Static:
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700949 {
Johnathan Mantey65265362019-11-14 11:24:19 -0800950 channelCall<setDHCPv4Property>(
951 channel, EthernetInterface::DHCPConf::none);
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700952 return responseSuccess();
953 }
Rajashekar Gade Reddy8a860ea2019-12-24 11:31:19 +0530954 case IPSrc::BIOS:
955 case IPSrc::BMC:
956 {
957 return responseInvalidFieldRequest();
958 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700959 }
960 return response(ccParamNotSupported);
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530961 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800962 case LanParam::MAC:
Ratan Guptab8e99552017-07-27 07:07:48 +0530963 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700964 ether_addr mac;
965 std::array<uint8_t, sizeof(mac)> bytes;
966 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
Suryakanth Sekar0a327e12019-08-08 14:30:19 +0530967 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700968 return responseReqDataLenInvalid();
Suryakanth Sekar0a327e12019-08-08 14:30:19 +0530969 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700970 copyInto(mac, bytes);
Rajashekar Gade Reddy0b993fd2019-12-24 16:37:15 +0530971
972 if (!isValidMACAddress(mac))
973 {
974 return responseInvalidFieldRequest();
975 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700976 channelCall<setMACProperty>(channel, mac);
977 return responseSuccess();
Ratan Gupta533d03b2017-07-30 10:39:22 +0530978 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700979 case LanParam::SubnetMask:
Ratan Guptab8e99552017-07-27 07:07:48 +0530980 {
Johnathan Mantey65265362019-11-14 11:24:19 -0800981 EthernetInterface::DHCPConf dhcp =
982 channelCall<getDHCPProperty>(channel);
983 if ((dhcp == EthernetInterface::DHCPConf::v4) ||
984 (dhcp == EthernetInterface::DHCPConf::both))
Johnathan Mantey930104a2019-12-17 09:18:34 -0800985 {
986 return responseCommandNotAvailable();
987 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700988 in_addr netmask;
989 std::array<uint8_t, sizeof(netmask)> bytes;
990 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
Ratan Guptab8e99552017-07-27 07:07:48 +0530991 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700992 return responseReqDataLenInvalid();
Ratan Guptab8e99552017-07-27 07:07:48 +0530993 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700994 copyInto(netmask, bytes);
995 channelCall<reconfigureIfAddr4>(channel, std::nullopt,
996 netmaskToPrefix(netmask));
997 return responseSuccess();
Ratan Guptab8e99552017-07-27 07:07:48 +0530998 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -0700999 case LanParam::Gateway1:
Ratan Guptab8e99552017-07-27 07:07:48 +05301000 {
Johnathan Mantey65265362019-11-14 11:24:19 -08001001 EthernetInterface::DHCPConf dhcp =
1002 channelCall<getDHCPProperty>(channel);
1003 if ((dhcp == EthernetInterface::DHCPConf::v4) ||
1004 (dhcp == EthernetInterface::DHCPConf::both))
Johnathan Mantey930104a2019-12-17 09:18:34 -08001005 {
1006 return responseCommandNotAvailable();
1007 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001008 in_addr gateway;
1009 std::array<uint8_t, sizeof(gateway)> bytes;
1010 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
1011 {
1012 return responseReqDataLenInvalid();
1013 }
1014 copyInto(gateway, bytes);
1015 channelCall<setGatewayProperty<AF_INET>>(channel, gateway);
1016 return responseSuccess();
1017 }
William A. Kennington III4bbc3db2019-04-15 00:02:10 -07001018 case LanParam::Gateway1MAC:
1019 {
1020 ether_addr gatewayMAC;
1021 std::array<uint8_t, sizeof(gatewayMAC)> bytes;
1022 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
1023 {
1024 return responseReqDataLenInvalid();
1025 }
1026 copyInto(gatewayMAC, bytes);
1027 channelCall<reconfigureGatewayMAC<AF_INET>>(channel, gatewayMAC);
1028 return responseSuccess();
1029 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001030 case LanParam::VLANId:
1031 {
Suryakanth Sekar8e8c8e22019-08-30 11:54:20 +05301032 uint12_t vlanData = 0;
1033 uint3_t reserved = 0;
1034 bool vlanEnable = 0;
1035
1036 if (req.unpack(vlanData) || req.unpack(reserved) ||
1037 req.unpack(vlanEnable) || !req.fullyUnpacked())
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001038 {
1039 return responseReqDataLenInvalid();
1040 }
Suryakanth Sekar8e8c8e22019-08-30 11:54:20 +05301041
1042 if (reserved)
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001043 {
Suryakanth Sekar8e8c8e22019-08-30 11:54:20 +05301044 return responseInvalidFieldRequest();
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001045 }
Suryakanth Sekar8e8c8e22019-08-30 11:54:20 +05301046
1047 uint16_t vlan = static_cast<uint16_t>(vlanData);
1048
1049 if (!vlanEnable)
1050 {
1051 lastDisabledVlan[channel] = vlan;
1052 vlan = 0;
1053 }
jayaprakash Mutyala84c49dc2020-05-18 23:12:13 +00001054 else if (vlan == 0 || vlan == VLAN_VALUE_MASK)
1055 {
1056 return responseInvalidFieldRequest();
1057 }
Suryakanth Sekar8e8c8e22019-08-30 11:54:20 +05301058
jayaprakash Mutyala84c49dc2020-05-18 23:12:13 +00001059 channelCall<reconfigureVLAN>(channel, vlan);
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001060 return responseSuccess();
1061 }
1062 case LanParam::CiphersuiteSupport:
1063 case LanParam::CiphersuiteEntries:
William A. Kennington III16064aa2019-04-13 17:44:53 -07001064 case LanParam::IPFamilySupport:
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001065 {
1066 req.trailingOk = true;
1067 return response(ccParamReadOnly);
Ratan Guptab8e99552017-07-27 07:07:48 +05301068 }
William A. Kennington III16064aa2019-04-13 17:44:53 -07001069 case LanParam::IPFamilyEnables:
1070 {
1071 uint8_t enables;
1072 if (req.unpack(enables) != 0 || !req.fullyUnpacked())
1073 {
1074 return responseReqDataLenInvalid();
1075 }
1076 switch (static_cast<IPFamilyEnables>(enables))
1077 {
1078 case IPFamilyEnables::DualStack:
1079 return responseSuccess();
1080 case IPFamilyEnables::IPv4Only:
1081 case IPFamilyEnables::IPv6Only:
1082 return response(ccParamNotSupported);
1083 }
1084 return response(ccParamNotSupported);
1085 }
1086 case LanParam::IPv6Status:
1087 {
1088 req.trailingOk = true;
1089 return response(ccParamReadOnly);
1090 }
1091 case LanParam::IPv6StaticAddresses:
1092 {
1093 uint8_t set;
1094 uint7_t rsvd;
1095 bool enabled;
1096 in6_addr ip;
1097 std::array<uint8_t, sizeof(ip)> ipbytes;
1098 uint8_t prefix;
1099 uint8_t status;
1100 if (req.unpack(set, rsvd, enabled, ipbytes, prefix, status) != 0 ||
1101 !req.fullyUnpacked())
1102 {
1103 return responseReqDataLenInvalid();
1104 }
Johnathan Mantey4a156852019-12-11 13:47:43 -08001105 if (rsvd)
1106 {
1107 return responseInvalidFieldRequest();
1108 }
William A. Kennington III16064aa2019-04-13 17:44:53 -07001109 copyInto(ip, ipbytes);
1110 if (enabled)
1111 {
Johnathan Manteya291f492021-10-15 13:45:27 -07001112 try
1113 {
1114 channelCall<reconfigureIfAddr6>(channel, set, ip, prefix);
1115 }
1116 catch (const sdbusplus::exception::exception& e)
1117 {
1118 if (std::string_view err{
1119 "xyz.openbmc_project.Common.Error.InvalidArgument"};
1120 err == e.name())
1121 {
1122 return responseInvalidFieldRequest();
1123 }
1124 else
1125 {
1126 throw;
1127 }
1128 }
William A. Kennington III16064aa2019-04-13 17:44:53 -07001129 }
1130 else
1131 {
1132 channelCall<deconfigureIfAddr6>(channel, set);
1133 }
1134 return responseSuccess();
1135 }
1136 case LanParam::IPv6DynamicAddresses:
1137 {
1138 req.trailingOk = true;
1139 return response(ccParamReadOnly);
1140 }
1141 case LanParam::IPv6RouterControl:
1142 {
1143 std::bitset<8> control;
Johnathan Mantey3b7a4072021-01-26 14:24:53 -08001144 constexpr uint8_t reservedRACCBits = 0xfc;
William A. Kennington III16064aa2019-04-13 17:44:53 -07001145 if (req.unpack(control) != 0 || !req.fullyUnpacked())
1146 {
1147 return responseReqDataLenInvalid();
1148 }
Johnathan Mantey3b7a4072021-01-26 14:24:53 -08001149 if (std::bitset<8> expected(control &
1150 std::bitset<8>(reservedRACCBits));
1151 expected.any())
William A. Kennington III16064aa2019-04-13 17:44:53 -07001152 {
Johnathan Mantey3b7a4072021-01-26 14:24:53 -08001153 return response(ccParamNotSupported);
William A. Kennington III16064aa2019-04-13 17:44:53 -07001154 }
Johnathan Mantey3b7a4072021-01-26 14:24:53 -08001155
1156 bool enableRA = control[IPv6RouterControlFlag::Dynamic];
1157 channelCall<setIPv6AcceptRA>(channel, enableRA);
William A. Kennington III16064aa2019-04-13 17:44:53 -07001158 return responseSuccess();
1159 }
1160 case LanParam::IPv6StaticRouter1IP:
1161 {
1162 in6_addr gateway;
1163 std::array<uint8_t, sizeof(gateway)> bytes;
1164 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
1165 {
1166 return responseReqDataLenInvalid();
1167 }
1168 copyInto(gateway, bytes);
1169 channelCall<setGatewayProperty<AF_INET6>>(channel, gateway);
1170 return responseSuccess();
1171 }
1172 case LanParam::IPv6StaticRouter1MAC:
1173 {
1174 ether_addr mac;
1175 std::array<uint8_t, sizeof(mac)> bytes;
1176 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
1177 {
1178 return responseReqDataLenInvalid();
1179 }
1180 copyInto(mac, bytes);
1181 channelCall<reconfigureGatewayMAC<AF_INET6>>(channel, mac);
1182 return responseSuccess();
1183 }
1184 case LanParam::IPv6StaticRouter1PrefixLength:
1185 {
1186 uint8_t prefix;
1187 if (req.unpack(prefix) != 0 || !req.fullyUnpacked())
1188 {
1189 return responseReqDataLenInvalid();
1190 }
1191 if (prefix != 0)
1192 {
1193 return responseInvalidFieldRequest();
1194 }
1195 return responseSuccess();
1196 }
1197 case LanParam::IPv6StaticRouter1PrefixValue:
1198 {
1199 std::array<uint8_t, sizeof(in6_addr)> bytes;
1200 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
1201 {
1202 return responseReqDataLenInvalid();
1203 }
1204 // Accept any prefix value since our prefix length has to be 0
1205 return responseSuccess();
1206 }
jayaprakash Mutyalab741b992019-12-02 17:29:09 +00001207 case LanParam::cipherSuitePrivilegeLevels:
1208 {
1209 uint8_t reserved;
1210 std::array<uint4_t, ipmi::maxCSRecords> cipherSuitePrivs;
1211
1212 if (req.unpack(reserved, cipherSuitePrivs) || !req.fullyUnpacked())
1213 {
1214 return responseReqDataLenInvalid();
1215 }
1216
1217 if (reserved)
1218 {
1219 return responseInvalidFieldRequest();
1220 }
1221
1222 uint8_t resp =
1223 getCipherConfigObject(csPrivFileName, csPrivDefaultFileName)
1224 .setCSPrivilegeLevels(channel, cipherSuitePrivs);
1225 if (!resp)
1226 {
1227 return responseSuccess();
1228 }
1229 else
1230 {
1231 req.trailingOk = true;
1232 return response(resp);
1233 }
1234 }
Ratan Guptab8e99552017-07-27 07:07:48 +05301235 }
vishwa1eaea4f2016-02-26 11:57:40 -06001236
Johnathan Manteyb87034e2019-09-16 10:50:50 -07001237 if ((parameter >= oemCmdStart) && (parameter <= oemCmdEnd))
1238 {
1239 return setLanOem(channel, parameter, req);
1240 }
1241
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001242 req.trailingOk = true;
1243 return response(ccParamNotSupported);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001244}
1245
vijayabharathix shettycc769252020-02-27 17:52:20 +00001246RspType<message::Payload> getLan(Context::ptr ctx, uint4_t channelBits,
1247 uint3_t reserved, bool revOnly,
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001248 uint8_t parameter, uint8_t set, uint8_t block)
Ratan Guptab8e99552017-07-27 07:07:48 +05301249{
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001250 message::Payload ret;
1251 constexpr uint8_t current_revision = 0x11;
1252 ret.pack(current_revision);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001253
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001254 if (revOnly)
Suryakanth Sekare4054402019-08-08 15:16:52 +05301255 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001256 return responseSuccess(std::move(ret));
Suryakanth Sekare4054402019-08-08 15:16:52 +05301257 }
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001258
vijayabharathix shettycc769252020-02-27 17:52:20 +00001259 const uint8_t channel = convertCurrentChannelNum(
1260 static_cast<uint8_t>(channelBits), ctx->channel);
1261 if (reserved || !isValidChannel(channel))
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001262 {
vijayabharathix shettycc769252020-02-27 17:52:20 +00001263 log<level::ERR>("Get Lan - Invalid field in request");
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001264 return responseInvalidFieldRequest();
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001265 }
1266
Johnathan Manteyaffadb52019-10-07 10:13:53 -07001267 static std::vector<uint8_t> cipherList;
1268 static bool listInit = false;
1269 if (!listInit)
1270 {
1271 try
1272 {
1273 cipherList = cipher::getCipherList();
1274 listInit = true;
1275 }
1276 catch (const std::exception& e)
1277 {
1278 }
1279 }
1280
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001281 switch (static_cast<LanParam>(parameter))
Tom Josepha30c8d32018-03-22 02:15:03 +05301282 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001283 case LanParam::SetStatus:
Tom Josepha30c8d32018-03-22 02:15:03 +05301284 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001285 SetStatus status;
1286 try
1287 {
1288 status = setStatus.at(channel);
1289 }
1290 catch (const std::out_of_range&)
1291 {
1292 status = SetStatus::Complete;
1293 }
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001294 ret.pack(types::enum_cast<uint2_t>(status), uint6_t{});
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001295 return responseSuccess(std::move(ret));
Tom Josepha30c8d32018-03-22 02:15:03 +05301296 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001297 case LanParam::AuthSupport:
Tom Josepha30c8d32018-03-22 02:15:03 +05301298 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001299 std::bitset<6> support;
1300 ret.pack(support, uint2_t{});
1301 return responseSuccess(std::move(ret));
Tom Josepha30c8d32018-03-22 02:15:03 +05301302 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001303 case LanParam::AuthEnables:
vishwa1eaea4f2016-02-26 11:57:40 -06001304 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001305 std::bitset<6> enables;
1306 ret.pack(enables, uint2_t{}); // Callback
1307 ret.pack(enables, uint2_t{}); // User
1308 ret.pack(enables, uint2_t{}); // Operator
1309 ret.pack(enables, uint2_t{}); // Admin
1310 ret.pack(enables, uint2_t{}); // OEM
1311 return responseSuccess(std::move(ret));
William A. Kennington III39f94ef2018-11-19 22:36:16 -08001312 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -08001313 case LanParam::IP:
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001314 {
1315 auto ifaddr = channelCall<getIfAddr4>(channel);
1316 in_addr addr{};
1317 if (ifaddr)
1318 {
1319 addr = ifaddr->address;
1320 }
1321 ret.pack(dataRef(addr));
1322 return responseSuccess(std::move(ret));
1323 }
1324 case LanParam::IPSrc:
1325 {
1326 auto src = IPSrc::Static;
Johnathan Mantey65265362019-11-14 11:24:19 -08001327 EthernetInterface::DHCPConf dhcp =
1328 channelCall<getDHCPProperty>(channel);
1329 if ((dhcp == EthernetInterface::DHCPConf::v4) ||
1330 (dhcp == EthernetInterface::DHCPConf::both))
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001331 {
1332 src = IPSrc::DHCP;
1333 }
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001334 ret.pack(types::enum_cast<uint4_t>(src), uint4_t{});
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001335 return responseSuccess(std::move(ret));
1336 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -08001337 case LanParam::MAC:
William A. Kennington III39f94ef2018-11-19 22:36:16 -08001338 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001339 ether_addr mac = channelCall<getMACProperty>(channel);
1340 ret.pack(dataRef(mac));
1341 return responseSuccess(std::move(ret));
1342 }
1343 case LanParam::SubnetMask:
1344 {
1345 auto ifaddr = channelCall<getIfAddr4>(channel);
1346 uint8_t prefix = AddrFamily<AF_INET>::defaultPrefix;
1347 if (ifaddr)
Ratan Guptab8e99552017-07-27 07:07:48 +05301348 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001349 prefix = ifaddr->prefix;
1350 }
1351 in_addr netmask = prefixToNetmask(prefix);
1352 ret.pack(dataRef(netmask));
1353 return responseSuccess(std::move(ret));
1354 }
1355 case LanParam::Gateway1:
1356 {
1357 auto gateway =
1358 channelCall<getGatewayProperty<AF_INET>>(channel).value_or(
1359 in_addr{});
1360 ret.pack(dataRef(gateway));
1361 return responseSuccess(std::move(ret));
1362 }
William A. Kennington III4bbc3db2019-04-15 00:02:10 -07001363 case LanParam::Gateway1MAC:
1364 {
1365 ether_addr mac{};
1366 auto neighbor = channelCall<getGatewayNeighbor<AF_INET>>(channel);
1367 if (neighbor)
1368 {
1369 mac = neighbor->mac;
1370 }
1371 ret.pack(dataRef(mac));
1372 return responseSuccess(std::move(ret));
1373 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001374 case LanParam::VLANId:
1375 {
1376 uint16_t vlan = channelCall<getVLANProperty>(channel);
1377 if (vlan != 0)
1378 {
1379 vlan |= VLAN_ENABLE_FLAG;
Ratan Guptab8e99552017-07-27 07:07:48 +05301380 }
1381 else
1382 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001383 vlan = lastDisabledVlan[channel];
Ratan Guptab8e99552017-07-27 07:07:48 +05301384 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001385 ret.pack(vlan);
1386 return responseSuccess(std::move(ret));
Adriana Kobylak342df102016-02-10 13:48:16 -06001387 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001388 case LanParam::CiphersuiteSupport:
Johnathan Manteyaffadb52019-10-07 10:13:53 -07001389 {
srikanta mondal1d8579c2020-04-15 17:13:25 +00001390 if (getChannelSessionSupport(channel) ==
1391 EChannelSessSupported::none)
1392 {
1393 return responseInvalidFieldRequest();
1394 }
Johnathan Manteyaffadb52019-10-07 10:13:53 -07001395 if (!listInit)
1396 {
1397 return responseUnspecifiedError();
1398 }
1399 ret.pack(static_cast<uint8_t>(cipherList.size() - 1));
1400 return responseSuccess(std::move(ret));
1401 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001402 case LanParam::CiphersuiteEntries:
Johnathan Manteyaffadb52019-10-07 10:13:53 -07001403 {
srikanta mondal1d8579c2020-04-15 17:13:25 +00001404 if (getChannelSessionSupport(channel) ==
1405 EChannelSessSupported::none)
1406 {
1407 return responseInvalidFieldRequest();
1408 }
Johnathan Manteyaffadb52019-10-07 10:13:53 -07001409 if (!listInit)
1410 {
1411 return responseUnspecifiedError();
1412 }
1413 ret.pack(cipherList);
1414 return responseSuccess(std::move(ret));
1415 }
William A. Kennington III16064aa2019-04-13 17:44:53 -07001416 case LanParam::IPFamilySupport:
1417 {
1418 std::bitset<8> support;
1419 support[IPFamilySupportFlag::IPv6Only] = 0;
1420 support[IPFamilySupportFlag::DualStack] = 1;
1421 support[IPFamilySupportFlag::IPv6Alerts] = 1;
1422 ret.pack(support);
1423 return responseSuccess(std::move(ret));
1424 }
1425 case LanParam::IPFamilyEnables:
1426 {
1427 ret.pack(static_cast<uint8_t>(IPFamilyEnables::DualStack));
1428 return responseSuccess(std::move(ret));
1429 }
1430 case LanParam::IPv6Status:
1431 {
1432 ret.pack(MAX_IPV6_STATIC_ADDRESSES);
1433 ret.pack(MAX_IPV6_DYNAMIC_ADDRESSES);
1434 std::bitset<8> support;
1435 support[IPv6StatusFlag::DHCP] = 1;
1436 support[IPv6StatusFlag::SLAAC] = 1;
1437 ret.pack(support);
1438 return responseSuccess(std::move(ret));
1439 }
1440 case LanParam::IPv6StaticAddresses:
1441 {
1442 if (set >= MAX_IPV6_STATIC_ADDRESSES)
1443 {
1444 return responseParmOutOfRange();
1445 }
1446 getLanIPv6Address(ret, channel, set, originsV6Static);
1447 return responseSuccess(std::move(ret));
1448 }
1449 case LanParam::IPv6DynamicAddresses:
1450 {
1451 if (set >= MAX_IPV6_DYNAMIC_ADDRESSES)
1452 {
1453 return responseParmOutOfRange();
1454 }
1455 getLanIPv6Address(ret, channel, set, originsV6Dynamic);
1456 return responseSuccess(std::move(ret));
1457 }
1458 case LanParam::IPv6RouterControl:
1459 {
1460 std::bitset<8> control;
Johnathan Mantey3b7a4072021-01-26 14:24:53 -08001461 control[IPv6RouterControlFlag::Dynamic] =
1462 channelCall<getIPv6AcceptRA>(channel);
1463 control[IPv6RouterControlFlag::Static] = 1;
William A. Kennington III16064aa2019-04-13 17:44:53 -07001464 ret.pack(control);
1465 return responseSuccess(std::move(ret));
1466 }
1467 case LanParam::IPv6StaticRouter1IP:
1468 {
1469 in6_addr gateway{};
Johnathan Mantey65265362019-11-14 11:24:19 -08001470 EthernetInterface::DHCPConf dhcp =
1471 channelCall<getDHCPProperty>(channel);
1472 if ((dhcp == EthernetInterface::DHCPConf::v4) ||
1473 (dhcp == EthernetInterface::DHCPConf::none))
William A. Kennington III16064aa2019-04-13 17:44:53 -07001474 {
1475 gateway =
1476 channelCall<getGatewayProperty<AF_INET6>>(channel).value_or(
1477 in6_addr{});
1478 }
1479 ret.pack(dataRef(gateway));
1480 return responseSuccess(std::move(ret));
1481 }
1482 case LanParam::IPv6StaticRouter1MAC:
1483 {
1484 ether_addr mac{};
1485 auto neighbor = channelCall<getGatewayNeighbor<AF_INET6>>(channel);
1486 if (neighbor)
1487 {
1488 mac = neighbor->mac;
1489 }
1490 ret.pack(dataRef(mac));
1491 return responseSuccess(std::move(ret));
1492 }
1493 case LanParam::IPv6StaticRouter1PrefixLength:
1494 {
1495 ret.pack(UINT8_C(0));
1496 return responseSuccess(std::move(ret));
1497 }
1498 case LanParam::IPv6StaticRouter1PrefixValue:
1499 {
1500 in6_addr prefix{};
1501 ret.pack(dataRef(prefix));
1502 return responseSuccess(std::move(ret));
1503 }
jayaprakash Mutyalab741b992019-12-02 17:29:09 +00001504 case LanParam::cipherSuitePrivilegeLevels:
1505 {
1506 std::array<uint4_t, ipmi::maxCSRecords> csPrivilegeLevels;
1507
1508 uint8_t resp =
1509 getCipherConfigObject(csPrivFileName, csPrivDefaultFileName)
1510 .getCSPrivilegeLevels(channel, csPrivilegeLevels);
1511 if (!resp)
1512 {
1513 constexpr uint8_t reserved1 = 0x00;
1514 ret.pack(reserved1, csPrivilegeLevels);
1515 return responseSuccess(std::move(ret));
1516 }
1517 else
1518 {
1519 return response(resp);
1520 }
1521 }
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001522 }
1523
Johnathan Manteyb87034e2019-09-16 10:50:50 -07001524 if ((parameter >= oemCmdStart) && (parameter <= oemCmdEnd))
1525 {
1526 return getLanOem(channel, parameter, set, block);
1527 }
1528
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001529 return response(ccParamNotSupported);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001530}
1531
Jian Zhang23f44652022-03-17 17:13:10 +08001532constexpr const char* solInterface = "xyz.openbmc_project.Ipmi.SOL";
1533constexpr const char* solPath = "/xyz/openbmc_project/ipmi/sol/";
1534constexpr const uint16_t solDefaultPort = 623;
1535
1536RspType<> setSolConfParams(Context::ptr ctx, uint4_t channelBits,
1537 uint4_t reserved, uint8_t parameter,
1538 message::Payload& req)
1539{
1540 const uint8_t channel = convertCurrentChannelNum(
1541 static_cast<uint8_t>(channelBits), ctx->channel);
1542
1543 if (!isValidChannel(channel))
1544 {
1545 log<level::ERR>("Set Sol Config - Invalid channel in request");
1546 return responseInvalidFieldRequest();
1547 }
1548
1549 std::string solService{};
1550 std::string solPathWitheEthName = solPath + ipmi::getChannelName(channel);
1551
1552 if (ipmi::getService(ctx, solInterface, solPathWitheEthName, solService))
1553 {
1554 log<level::ERR>("Set Sol Config - Invalid solInterface",
1555 entry("SERVICE=%s", solService.c_str()),
1556 entry("OBJPATH=%s", solPathWitheEthName.c_str()),
1557 entry("INTERFACE=%s", solInterface));
1558 return responseInvalidFieldRequest();
1559 }
1560
1561 switch (static_cast<SolConfParam>(parameter))
1562 {
1563 case SolConfParam::Progress:
1564 {
1565 uint8_t progress;
1566 if (req.unpack(progress) != 0 || !req.fullyUnpacked())
1567 {
1568 return responseReqDataLenInvalid();
1569 }
1570
1571 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1572 solInterface, "Progress", progress))
1573 {
1574 return responseUnspecifiedError();
1575 }
1576 break;
1577 }
1578 case SolConfParam::Enable:
1579 {
1580 bool enable;
1581 uint7_t reserved2;
1582
1583 if (req.unpack(enable, reserved2) != 0 || !req.fullyUnpacked())
1584 {
1585 return responseReqDataLenInvalid();
1586 }
1587
1588 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1589 solInterface, "Enable", enable))
1590 {
1591 return responseUnspecifiedError();
1592 }
1593 break;
1594 }
1595 case SolConfParam::Authentication:
1596 {
1597 uint4_t privilegeBits{};
1598 uint2_t reserved2{};
1599 bool forceAuth = false;
1600 bool forceEncrypt = false;
1601
1602 if (req.unpack(privilegeBits, reserved2, forceAuth, forceEncrypt) !=
1603 0 ||
1604 !req.fullyUnpacked())
1605 {
1606 return responseReqDataLenInvalid();
1607 }
1608
1609 uint8_t privilege = static_cast<uint8_t>(privilegeBits);
1610 if (privilege < static_cast<uint8_t>(Privilege::None) ||
1611 privilege > static_cast<uint8_t>(Privilege::Oem))
1612 {
1613 return ipmi::responseInvalidFieldRequest();
1614 }
1615
1616 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1617 solInterface, "Privilege", privilege))
1618 {
1619 return responseUnspecifiedError();
1620 }
1621
1622 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1623 solInterface, "ForceEncryption",
1624 forceEncrypt))
1625 {
1626 return responseUnspecifiedError();
1627 }
1628
1629 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1630 solInterface, "ForceAuthentication",
1631 forceAuth))
1632 {
1633 return responseUnspecifiedError();
1634 }
1635 break;
1636 }
1637 case SolConfParam::Accumulate:
1638 {
1639 uint8_t interval;
1640 uint8_t threshold;
1641 if (req.unpack(interval, threshold) != 0 || !req.fullyUnpacked())
1642 {
1643 return responseReqDataLenInvalid();
1644 }
1645
1646 if (threshold == 0)
1647 {
1648 return responseInvalidFieldRequest();
1649 }
1650
1651 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1652 solInterface, "AccumulateIntervalMS",
1653 interval))
1654 {
1655 return responseUnspecifiedError();
1656 }
1657
1658 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1659 solInterface, "Threshold", threshold))
1660 {
1661 return responseUnspecifiedError();
1662 }
1663 break;
1664 }
1665 case SolConfParam::Retry:
1666 {
1667 uint3_t countBits;
1668 uint5_t reserved2;
1669 uint8_t interval;
1670
1671 if (req.unpack(countBits, reserved2, interval) != 0 ||
1672 !req.fullyUnpacked())
1673 {
1674 return responseReqDataLenInvalid();
1675 }
1676
1677 uint8_t count = static_cast<uint8_t>(countBits);
1678 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1679 solInterface, "RetryCount", count))
1680 {
1681 return responseUnspecifiedError();
1682 }
1683
1684 if (ipmi::setDbusProperty(ctx, solService, solPathWitheEthName,
1685 solInterface, "RetryIntervalMS",
1686 interval))
1687 {
1688 return responseUnspecifiedError();
1689 }
1690 break;
1691 }
1692 case SolConfParam::Port:
1693 {
1694 return response(ipmiCCWriteReadParameter);
1695 }
1696 case SolConfParam::NonVbitrate:
1697 case SolConfParam::Vbitrate:
1698 case SolConfParam::Channel:
1699 default:
1700 return response(ipmiCCParamNotSupported);
1701 }
1702 return responseSuccess();
1703}
1704
1705RspType<message::Payload> getSolConfParams(Context::ptr ctx,
1706 uint4_t channelBits,
1707 uint3_t reserved, bool revOnly,
1708 uint8_t parameter, uint8_t set,
1709 uint8_t block)
1710{
1711 message::Payload ret;
1712 constexpr uint8_t current_revision = 0x11;
1713 ret.pack(current_revision);
1714 if (revOnly)
1715 {
1716 return responseSuccess(std::move(ret));
1717 }
1718
1719 const uint8_t channel = convertCurrentChannelNum(
1720 static_cast<uint8_t>(channelBits), ctx->channel);
1721
1722 if (!isValidChannel(channel))
1723 {
1724 log<level::ERR>("Get Sol Config - Invalid channel in request");
1725 return responseInvalidFieldRequest();
1726 }
1727
1728 std::string solService{};
1729 std::string solPathWitheEthName = solPath + ipmi::getChannelName(channel);
1730
1731 if (ipmi::getService(ctx, solInterface, solPathWitheEthName, solService))
1732 {
1733 log<level::ERR>("Set Sol Config - Invalid solInterface",
1734 entry("SERVICE=%s", solService.c_str()),
1735 entry("OBJPATH=%s", solPathWitheEthName.c_str()),
1736 entry("INTERFACE=%s", solInterface));
1737 return responseInvalidFieldRequest();
1738 }
1739
1740 switch (static_cast<SolConfParam>(parameter))
1741 {
1742 case SolConfParam::Progress:
1743 {
1744 uint8_t progress;
1745 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1746 solInterface, "Progress", progress))
1747 {
1748 return responseUnspecifiedError();
1749 }
1750 ret.pack(progress);
1751 return responseSuccess(std::move(ret));
1752 }
1753 case SolConfParam::Enable:
1754 {
1755 bool enable{};
1756 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1757 solInterface, "Enable", enable))
1758 {
1759 return responseUnspecifiedError();
1760 }
1761 ret.pack(enable, uint7_t{});
1762 return responseSuccess(std::move(ret));
1763 }
1764 case SolConfParam::Authentication:
1765 {
1766 // 4bits, cast when pack
1767 uint8_t privilege;
1768 bool forceAuth = false;
1769 bool forceEncrypt = false;
1770
1771 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1772 solInterface, "Privilege", privilege))
1773 {
1774 return responseUnspecifiedError();
1775 }
1776
1777 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1778 solInterface, "ForceAuthentication",
1779 forceAuth))
1780 {
1781 return responseUnspecifiedError();
1782 }
1783
1784 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1785 solInterface, "ForceEncryption",
1786 forceEncrypt))
1787 {
1788 return responseUnspecifiedError();
1789 }
1790 ret.pack(uint4_t{privilege}, uint2_t{}, forceAuth, forceEncrypt);
1791 return responseSuccess(std::move(ret));
1792 }
1793 case SolConfParam::Accumulate:
1794 {
1795 uint8_t interval{}, threshold{};
1796
1797 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1798 solInterface, "AccumulateIntervalMS",
1799 interval))
1800 {
1801 return responseUnspecifiedError();
1802 }
1803
1804 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1805 solInterface, "Threshold", threshold))
1806 {
1807 return responseUnspecifiedError();
1808 }
1809 ret.pack(interval, threshold);
1810 return responseSuccess(std::move(ret));
1811 }
1812 case SolConfParam::Retry:
1813 {
1814 // 3bits, cast when cast
1815 uint8_t count{};
1816 uint8_t interval{};
1817
1818 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1819 solInterface, "RetryCount", count))
1820 {
1821 return responseUnspecifiedError();
1822 }
1823
1824 if (ipmi::getDbusProperty(ctx, solService, solPathWitheEthName,
1825 solInterface, "RetryIntervalMS",
1826 interval))
1827 {
1828 return responseUnspecifiedError();
1829 }
1830 ret.pack(uint3_t{count}, uint5_t{}, interval);
1831 return responseSuccess(std::move(ret));
1832 }
1833 case SolConfParam::Port:
1834 {
1835 auto port = solDefaultPort;
1836 ret.pack(static_cast<uint16_t>(port));
1837 return responseSuccess(std::move(ret));
1838 }
1839 case SolConfParam::Channel:
1840 {
1841 ret.pack(channel);
1842 return responseSuccess(std::move(ret));
1843 }
1844 case SolConfParam::NonVbitrate:
1845 case SolConfParam::Vbitrate:
1846 default:
1847 return response(ipmiCCParamNotSupported);
1848 }
1849
1850 return response(ccParamNotSupported);
1851}
1852
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001853} // namespace transport
1854} // namespace ipmi
Ratan Gupta1247e0b2018-03-07 10:47:25 +05301855
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001856void register_netfn_transport_functions() __attribute__((constructor));
Ratan Gupta1247e0b2018-03-07 10:47:25 +05301857
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001858void register_netfn_transport_functions()
1859{
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001860 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnTransport,
1861 ipmi::transport::cmdSetLanConfigParameters,
1862 ipmi::Privilege::Admin, ipmi::transport::setLan);
1863 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnTransport,
1864 ipmi::transport::cmdGetLanConfigParameters,
Johnathan Mantey34698d52019-11-19 14:47:30 -08001865 ipmi::Privilege::Operator, ipmi::transport::getLan);
Jian Zhang23f44652022-03-17 17:13:10 +08001866 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnTransport,
1867 ipmi::transport::cmdSetSolConfigParameters,
1868 ipmi::Privilege::Admin,
1869 ipmi::transport::setSolConfParams);
1870 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnTransport,
1871 ipmi::transport::cmdGetSolConfigParameters,
1872 ipmi::Privilege::User,
1873 ipmi::transport::getSolConfParams);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001874}