blob: f6748656e71fc4fe4c4f34e94f3ad6f5d05a135d [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 {
230 if ((currentDhcp == EthernetInterface::DHCPConf::v4) &&
231 (requestedDhcp == EthernetInterface::DHCPConf::v6))
232 {
233 nextDhcp = EthernetInterface::DHCPConf::both;
234 }
235 else if ((currentDhcp == EthernetInterface::DHCPConf::none) &&
236 (requestedDhcp == EthernetInterface::DHCPConf::v6))
237
238 {
239 nextDhcp = requestedDhcp;
240 }
241 else if (requestedDhcp == EthernetInterface::DHCPConf::none)
242 {
243 if (currentDhcp == EthernetInterface::DHCPConf::both)
244 {
245 nextDhcp = EthernetInterface::DHCPConf::v4;
246 }
247 else if (currentDhcp == EthernetInterface::DHCPConf::v6)
248 {
249 nextDhcp = EthernetInterface::DHCPConf::none;
250 }
251 }
252 else
253 {
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 }
321 catch (const sdbusplus::exception::SdBusError& e)
322 {
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{};
510 uint8_t prefix = AddrFamily<AF_INET6>::defaultPrefix;
511 auto status = IPv6AddressStatus::Disabled;
512
513 auto ifaddr = channelCall<getIfAddr<AF_INET6>>(channel, set, origins);
514 if (ifaddr)
515 {
516 source = originToSourceType(ifaddr->origin);
517 enabled = true;
518 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 {
1112 channelCall<reconfigureIfAddr6>(channel, set, ip, prefix);
1113 }
1114 else
1115 {
1116 channelCall<deconfigureIfAddr6>(channel, set);
1117 }
1118 return responseSuccess();
1119 }
1120 case LanParam::IPv6DynamicAddresses:
1121 {
1122 req.trailingOk = true;
1123 return response(ccParamReadOnly);
1124 }
1125 case LanParam::IPv6RouterControl:
1126 {
1127 std::bitset<8> control;
Johnathan Mantey3b7a4072021-01-26 14:24:53 -08001128 constexpr uint8_t reservedRACCBits = 0xfc;
William A. Kennington III16064aa2019-04-13 17:44:53 -07001129 if (req.unpack(control) != 0 || !req.fullyUnpacked())
1130 {
1131 return responseReqDataLenInvalid();
1132 }
Johnathan Mantey3b7a4072021-01-26 14:24:53 -08001133 if (std::bitset<8> expected(control &
1134 std::bitset<8>(reservedRACCBits));
1135 expected.any())
William A. Kennington III16064aa2019-04-13 17:44:53 -07001136 {
Johnathan Mantey3b7a4072021-01-26 14:24:53 -08001137 return response(ccParamNotSupported);
William A. Kennington III16064aa2019-04-13 17:44:53 -07001138 }
Johnathan Mantey3b7a4072021-01-26 14:24:53 -08001139
1140 bool enableRA = control[IPv6RouterControlFlag::Dynamic];
1141 channelCall<setIPv6AcceptRA>(channel, enableRA);
William A. Kennington III16064aa2019-04-13 17:44:53 -07001142 return responseSuccess();
1143 }
1144 case LanParam::IPv6StaticRouter1IP:
1145 {
1146 in6_addr gateway;
1147 std::array<uint8_t, sizeof(gateway)> bytes;
1148 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
1149 {
1150 return responseReqDataLenInvalid();
1151 }
1152 copyInto(gateway, bytes);
1153 channelCall<setGatewayProperty<AF_INET6>>(channel, gateway);
1154 return responseSuccess();
1155 }
1156 case LanParam::IPv6StaticRouter1MAC:
1157 {
1158 ether_addr mac;
1159 std::array<uint8_t, sizeof(mac)> bytes;
1160 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
1161 {
1162 return responseReqDataLenInvalid();
1163 }
1164 copyInto(mac, bytes);
1165 channelCall<reconfigureGatewayMAC<AF_INET6>>(channel, mac);
1166 return responseSuccess();
1167 }
1168 case LanParam::IPv6StaticRouter1PrefixLength:
1169 {
1170 uint8_t prefix;
1171 if (req.unpack(prefix) != 0 || !req.fullyUnpacked())
1172 {
1173 return responseReqDataLenInvalid();
1174 }
1175 if (prefix != 0)
1176 {
1177 return responseInvalidFieldRequest();
1178 }
1179 return responseSuccess();
1180 }
1181 case LanParam::IPv6StaticRouter1PrefixValue:
1182 {
1183 std::array<uint8_t, sizeof(in6_addr)> bytes;
1184 if (req.unpack(bytes) != 0 || !req.fullyUnpacked())
1185 {
1186 return responseReqDataLenInvalid();
1187 }
1188 // Accept any prefix value since our prefix length has to be 0
1189 return responseSuccess();
1190 }
jayaprakash Mutyalab741b992019-12-02 17:29:09 +00001191 case LanParam::cipherSuitePrivilegeLevels:
1192 {
1193 uint8_t reserved;
1194 std::array<uint4_t, ipmi::maxCSRecords> cipherSuitePrivs;
1195
1196 if (req.unpack(reserved, cipherSuitePrivs) || !req.fullyUnpacked())
1197 {
1198 return responseReqDataLenInvalid();
1199 }
1200
1201 if (reserved)
1202 {
1203 return responseInvalidFieldRequest();
1204 }
1205
1206 uint8_t resp =
1207 getCipherConfigObject(csPrivFileName, csPrivDefaultFileName)
1208 .setCSPrivilegeLevels(channel, cipherSuitePrivs);
1209 if (!resp)
1210 {
1211 return responseSuccess();
1212 }
1213 else
1214 {
1215 req.trailingOk = true;
1216 return response(resp);
1217 }
1218 }
Ratan Guptab8e99552017-07-27 07:07:48 +05301219 }
vishwa1eaea4f2016-02-26 11:57:40 -06001220
Johnathan Manteyb87034e2019-09-16 10:50:50 -07001221 if ((parameter >= oemCmdStart) && (parameter <= oemCmdEnd))
1222 {
1223 return setLanOem(channel, parameter, req);
1224 }
1225
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001226 req.trailingOk = true;
1227 return response(ccParamNotSupported);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001228}
1229
vijayabharathix shettycc769252020-02-27 17:52:20 +00001230RspType<message::Payload> getLan(Context::ptr ctx, uint4_t channelBits,
1231 uint3_t reserved, bool revOnly,
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001232 uint8_t parameter, uint8_t set, uint8_t block)
Ratan Guptab8e99552017-07-27 07:07:48 +05301233{
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001234 message::Payload ret;
1235 constexpr uint8_t current_revision = 0x11;
1236 ret.pack(current_revision);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001237
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001238 if (revOnly)
Suryakanth Sekare4054402019-08-08 15:16:52 +05301239 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001240 return responseSuccess(std::move(ret));
Suryakanth Sekare4054402019-08-08 15:16:52 +05301241 }
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001242
vijayabharathix shettycc769252020-02-27 17:52:20 +00001243 const uint8_t channel = convertCurrentChannelNum(
1244 static_cast<uint8_t>(channelBits), ctx->channel);
1245 if (reserved || !isValidChannel(channel))
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001246 {
vijayabharathix shettycc769252020-02-27 17:52:20 +00001247 log<level::ERR>("Get Lan - Invalid field in request");
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001248 return responseInvalidFieldRequest();
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001249 }
1250
Johnathan Manteyaffadb52019-10-07 10:13:53 -07001251 static std::vector<uint8_t> cipherList;
1252 static bool listInit = false;
1253 if (!listInit)
1254 {
1255 try
1256 {
1257 cipherList = cipher::getCipherList();
1258 listInit = true;
1259 }
1260 catch (const std::exception& e)
1261 {
1262 }
1263 }
1264
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001265 switch (static_cast<LanParam>(parameter))
Tom Josepha30c8d32018-03-22 02:15:03 +05301266 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001267 case LanParam::SetStatus:
Tom Josepha30c8d32018-03-22 02:15:03 +05301268 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001269 SetStatus status;
1270 try
1271 {
1272 status = setStatus.at(channel);
1273 }
1274 catch (const std::out_of_range&)
1275 {
1276 status = SetStatus::Complete;
1277 }
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001278 ret.pack(types::enum_cast<uint2_t>(status), uint6_t{});
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001279 return responseSuccess(std::move(ret));
Tom Josepha30c8d32018-03-22 02:15:03 +05301280 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001281 case LanParam::AuthSupport:
Tom Josepha30c8d32018-03-22 02:15:03 +05301282 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001283 std::bitset<6> support;
1284 ret.pack(support, uint2_t{});
1285 return responseSuccess(std::move(ret));
Tom Josepha30c8d32018-03-22 02:15:03 +05301286 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001287 case LanParam::AuthEnables:
vishwa1eaea4f2016-02-26 11:57:40 -06001288 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001289 std::bitset<6> enables;
1290 ret.pack(enables, uint2_t{}); // Callback
1291 ret.pack(enables, uint2_t{}); // User
1292 ret.pack(enables, uint2_t{}); // Operator
1293 ret.pack(enables, uint2_t{}); // Admin
1294 ret.pack(enables, uint2_t{}); // OEM
1295 return responseSuccess(std::move(ret));
William A. Kennington III39f94ef2018-11-19 22:36:16 -08001296 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -08001297 case LanParam::IP:
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001298 {
1299 auto ifaddr = channelCall<getIfAddr4>(channel);
1300 in_addr addr{};
1301 if (ifaddr)
1302 {
1303 addr = ifaddr->address;
1304 }
1305 ret.pack(dataRef(addr));
1306 return responseSuccess(std::move(ret));
1307 }
1308 case LanParam::IPSrc:
1309 {
1310 auto src = IPSrc::Static;
Johnathan Mantey65265362019-11-14 11:24:19 -08001311 EthernetInterface::DHCPConf dhcp =
1312 channelCall<getDHCPProperty>(channel);
1313 if ((dhcp == EthernetInterface::DHCPConf::v4) ||
1314 (dhcp == EthernetInterface::DHCPConf::both))
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001315 {
1316 src = IPSrc::DHCP;
1317 }
William A. Kennington III7a0e5df2021-05-19 13:31:29 -07001318 ret.pack(types::enum_cast<uint4_t>(src), uint4_t{});
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001319 return responseSuccess(std::move(ret));
1320 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -08001321 case LanParam::MAC:
William A. Kennington III39f94ef2018-11-19 22:36:16 -08001322 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001323 ether_addr mac = channelCall<getMACProperty>(channel);
1324 ret.pack(dataRef(mac));
1325 return responseSuccess(std::move(ret));
1326 }
1327 case LanParam::SubnetMask:
1328 {
1329 auto ifaddr = channelCall<getIfAddr4>(channel);
1330 uint8_t prefix = AddrFamily<AF_INET>::defaultPrefix;
1331 if (ifaddr)
Ratan Guptab8e99552017-07-27 07:07:48 +05301332 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001333 prefix = ifaddr->prefix;
1334 }
1335 in_addr netmask = prefixToNetmask(prefix);
1336 ret.pack(dataRef(netmask));
1337 return responseSuccess(std::move(ret));
1338 }
1339 case LanParam::Gateway1:
1340 {
1341 auto gateway =
1342 channelCall<getGatewayProperty<AF_INET>>(channel).value_or(
1343 in_addr{});
1344 ret.pack(dataRef(gateway));
1345 return responseSuccess(std::move(ret));
1346 }
William A. Kennington III4bbc3db2019-04-15 00:02:10 -07001347 case LanParam::Gateway1MAC:
1348 {
1349 ether_addr mac{};
1350 auto neighbor = channelCall<getGatewayNeighbor<AF_INET>>(channel);
1351 if (neighbor)
1352 {
1353 mac = neighbor->mac;
1354 }
1355 ret.pack(dataRef(mac));
1356 return responseSuccess(std::move(ret));
1357 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001358 case LanParam::VLANId:
1359 {
1360 uint16_t vlan = channelCall<getVLANProperty>(channel);
1361 if (vlan != 0)
1362 {
1363 vlan |= VLAN_ENABLE_FLAG;
Ratan Guptab8e99552017-07-27 07:07:48 +05301364 }
1365 else
1366 {
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001367 vlan = lastDisabledVlan[channel];
Ratan Guptab8e99552017-07-27 07:07:48 +05301368 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001369 ret.pack(vlan);
1370 return responseSuccess(std::move(ret));
Adriana Kobylak342df102016-02-10 13:48:16 -06001371 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001372 case LanParam::CiphersuiteSupport:
Johnathan Manteyaffadb52019-10-07 10:13:53 -07001373 {
srikanta mondal1d8579c2020-04-15 17:13:25 +00001374 if (getChannelSessionSupport(channel) ==
1375 EChannelSessSupported::none)
1376 {
1377 return responseInvalidFieldRequest();
1378 }
Johnathan Manteyaffadb52019-10-07 10:13:53 -07001379 if (!listInit)
1380 {
1381 return responseUnspecifiedError();
1382 }
1383 ret.pack(static_cast<uint8_t>(cipherList.size() - 1));
1384 return responseSuccess(std::move(ret));
1385 }
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001386 case LanParam::CiphersuiteEntries:
Johnathan Manteyaffadb52019-10-07 10:13:53 -07001387 {
srikanta mondal1d8579c2020-04-15 17:13:25 +00001388 if (getChannelSessionSupport(channel) ==
1389 EChannelSessSupported::none)
1390 {
1391 return responseInvalidFieldRequest();
1392 }
Johnathan Manteyaffadb52019-10-07 10:13:53 -07001393 if (!listInit)
1394 {
1395 return responseUnspecifiedError();
1396 }
1397 ret.pack(cipherList);
1398 return responseSuccess(std::move(ret));
1399 }
William A. Kennington III16064aa2019-04-13 17:44:53 -07001400 case LanParam::IPFamilySupport:
1401 {
1402 std::bitset<8> support;
1403 support[IPFamilySupportFlag::IPv6Only] = 0;
1404 support[IPFamilySupportFlag::DualStack] = 1;
1405 support[IPFamilySupportFlag::IPv6Alerts] = 1;
1406 ret.pack(support);
1407 return responseSuccess(std::move(ret));
1408 }
1409 case LanParam::IPFamilyEnables:
1410 {
1411 ret.pack(static_cast<uint8_t>(IPFamilyEnables::DualStack));
1412 return responseSuccess(std::move(ret));
1413 }
1414 case LanParam::IPv6Status:
1415 {
1416 ret.pack(MAX_IPV6_STATIC_ADDRESSES);
1417 ret.pack(MAX_IPV6_DYNAMIC_ADDRESSES);
1418 std::bitset<8> support;
1419 support[IPv6StatusFlag::DHCP] = 1;
1420 support[IPv6StatusFlag::SLAAC] = 1;
1421 ret.pack(support);
1422 return responseSuccess(std::move(ret));
1423 }
1424 case LanParam::IPv6StaticAddresses:
1425 {
1426 if (set >= MAX_IPV6_STATIC_ADDRESSES)
1427 {
1428 return responseParmOutOfRange();
1429 }
1430 getLanIPv6Address(ret, channel, set, originsV6Static);
1431 return responseSuccess(std::move(ret));
1432 }
1433 case LanParam::IPv6DynamicAddresses:
1434 {
1435 if (set >= MAX_IPV6_DYNAMIC_ADDRESSES)
1436 {
1437 return responseParmOutOfRange();
1438 }
1439 getLanIPv6Address(ret, channel, set, originsV6Dynamic);
1440 return responseSuccess(std::move(ret));
1441 }
1442 case LanParam::IPv6RouterControl:
1443 {
1444 std::bitset<8> control;
Johnathan Mantey3b7a4072021-01-26 14:24:53 -08001445 control[IPv6RouterControlFlag::Dynamic] =
1446 channelCall<getIPv6AcceptRA>(channel);
1447 control[IPv6RouterControlFlag::Static] = 1;
William A. Kennington III16064aa2019-04-13 17:44:53 -07001448 ret.pack(control);
1449 return responseSuccess(std::move(ret));
1450 }
1451 case LanParam::IPv6StaticRouter1IP:
1452 {
1453 in6_addr gateway{};
Johnathan Mantey65265362019-11-14 11:24:19 -08001454 EthernetInterface::DHCPConf dhcp =
1455 channelCall<getDHCPProperty>(channel);
1456 if ((dhcp == EthernetInterface::DHCPConf::v4) ||
1457 (dhcp == EthernetInterface::DHCPConf::none))
William A. Kennington III16064aa2019-04-13 17:44:53 -07001458 {
1459 gateway =
1460 channelCall<getGatewayProperty<AF_INET6>>(channel).value_or(
1461 in6_addr{});
1462 }
1463 ret.pack(dataRef(gateway));
1464 return responseSuccess(std::move(ret));
1465 }
1466 case LanParam::IPv6StaticRouter1MAC:
1467 {
1468 ether_addr mac{};
1469 auto neighbor = channelCall<getGatewayNeighbor<AF_INET6>>(channel);
1470 if (neighbor)
1471 {
1472 mac = neighbor->mac;
1473 }
1474 ret.pack(dataRef(mac));
1475 return responseSuccess(std::move(ret));
1476 }
1477 case LanParam::IPv6StaticRouter1PrefixLength:
1478 {
1479 ret.pack(UINT8_C(0));
1480 return responseSuccess(std::move(ret));
1481 }
1482 case LanParam::IPv6StaticRouter1PrefixValue:
1483 {
1484 in6_addr prefix{};
1485 ret.pack(dataRef(prefix));
1486 return responseSuccess(std::move(ret));
1487 }
jayaprakash Mutyalab741b992019-12-02 17:29:09 +00001488 case LanParam::cipherSuitePrivilegeLevels:
1489 {
1490 std::array<uint4_t, ipmi::maxCSRecords> csPrivilegeLevels;
1491
1492 uint8_t resp =
1493 getCipherConfigObject(csPrivFileName, csPrivDefaultFileName)
1494 .getCSPrivilegeLevels(channel, csPrivilegeLevels);
1495 if (!resp)
1496 {
1497 constexpr uint8_t reserved1 = 0x00;
1498 ret.pack(reserved1, csPrivilegeLevels);
1499 return responseSuccess(std::move(ret));
1500 }
1501 else
1502 {
1503 return response(resp);
1504 }
1505 }
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001506 }
1507
Johnathan Manteyb87034e2019-09-16 10:50:50 -07001508 if ((parameter >= oemCmdStart) && (parameter <= oemCmdEnd))
1509 {
1510 return getLanOem(channel, parameter, set, block);
1511 }
1512
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001513 return response(ccParamNotSupported);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001514}
1515
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001516} // namespace transport
1517} // namespace ipmi
Ratan Gupta1247e0b2018-03-07 10:47:25 +05301518
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001519void register_netfn_transport_functions() __attribute__((constructor));
Ratan Gupta1247e0b2018-03-07 10:47:25 +05301520
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001521void register_netfn_transport_functions()
1522{
William A. Kennington IIIc514d872019-04-06 18:19:38 -07001523 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnTransport,
1524 ipmi::transport::cmdSetLanConfigParameters,
1525 ipmi::Privilege::Admin, ipmi::transport::setLan);
1526 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnTransport,
1527 ipmi::transport::cmdGetLanConfigParameters,
Johnathan Mantey34698d52019-11-19 14:47:30 -08001528 ipmi::Privilege::Operator, ipmi::transport::getLan);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -05001529}