blob: 88938b16b32781aadfcbd82f847b321e319851bb [file] [log] [blame]
Patrick Venture586d35b2018-09-07 19:56:18 -07001#include "transporthandler.hpp"
2
Patrick Venture3a5071a2018-09-12 13:27:42 -07003#include "app/channel.hpp"
4#include "ipmid.hpp"
5#include "net.hpp"
Patrick Venture3a5071a2018-09-12 13:27:42 -07006#include "utils.hpp"
7
Patrick Venture0b02be92018-08-31 11:55:55 -07008#include <arpa/inet.h>
Patrick Venture3a5071a2018-09-12 13:27:42 -07009#include <host-ipmid/ipmid-api.h>
Patrick Venture0b02be92018-08-31 11:55:55 -070010
11#include <chrono>
12#include <fstream>
Patrick Venture3a5071a2018-09-12 13:27:42 -070013#include <phosphor-logging/elog-errors.hpp>
14#include <phosphor-logging/log.hpp>
William A. Kennington III4c008022018-10-12 17:18:14 -070015#include <sdbusplus/message/types.hpp>
Vernon Mauery1181af72018-10-08 12:05:00 -070016#include <sdbusplus/timer.hpp>
tomjose26e17732016-03-03 08:52:51 -060017#include <string>
Patrick Venture3a5071a2018-09-12 13:27:42 -070018#include <xyz/openbmc_project/Common/error.hpp>
19
20#define SYSTEMD_NETWORKD_DBUS 1
21
22#ifdef SYSTEMD_NETWORKD_DBUS
23#include <mapper.h>
24#include <systemd/sd-bus.h>
25#endif
Patrick Venture586d35b2018-09-07 19:56:18 -070026
Vernon Mauery185b9f82018-07-20 10:52:36 -070027#if __has_include(<filesystem>)
28#include <filesystem>
29#elif __has_include(<experimental/filesystem>)
Ratan Guptacc6cdbf2017-09-01 23:06:25 +053030#include <experimental/filesystem>
Patrick Venture0b02be92018-08-31 11:55:55 -070031namespace std
32{
33// splice experimental::filesystem into std
34namespace filesystem = std::experimental::filesystem;
35} // namespace std
Vernon Mauery185b9f82018-07-20 10:52:36 -070036#else
Patrick Venture0b02be92018-08-31 11:55:55 -070037#error filesystem not available
Vernon Mauery185b9f82018-07-20 10:52:36 -070038#endif
Adriana Kobylak5d6481f2015-10-29 21:44:55 -050039
Vernon Mauery1181af72018-10-08 12:05:00 -070040extern std::unique_ptr<phosphor::Timer> networkTimer;
Ratan Gupta1247e0b2018-03-07 10:47:25 +053041
Patrick Venture0b02be92018-08-31 11:55:55 -070042const int SIZE_MAC = 18; // xx:xx:xx:xx:xx:xx
Ratan Gupta1247e0b2018-03-07 10:47:25 +053043constexpr auto ipv4Protocol = "xyz.openbmc_project.Network.IP.Protocol.IPv4";
Adriana Kobylake08fbc62016-02-09 16:17:23 -060044
Patrick Venturec7c1c3c2017-11-15 14:29:18 -080045std::map<int, std::unique_ptr<struct ChannelConfig_t>> channelConfig;
Hariharasubramanian R83951912016-01-20 07:06:36 -060046
Ratan Guptab8e99552017-07-27 07:07:48 +053047using namespace phosphor::logging;
48using namespace sdbusplus::xyz::openbmc_project::Common::Error;
Ratan Gupta7a7f0122018-03-07 12:31:05 +053049
Vernon Mauery185b9f82018-07-20 10:52:36 -070050namespace fs = std::filesystem;
William A. Kennington III4c008022018-10-12 17:18:14 -070051namespace variant_ns = sdbusplus::message::variant_ns;
Hariharasubramanian R83951912016-01-20 07:06:36 -060052
Adriana Kobylak5d6481f2015-10-29 21:44:55 -050053void register_netfn_transport_functions() __attribute__((constructor));
54
Patrick Venturec7c1c3c2017-11-15 14:29:18 -080055struct ChannelConfig_t* getChannelConfig(int channel)
56{
57 auto item = channelConfig.find(channel);
58 if (item == channelConfig.end())
59 {
60 channelConfig[channel] = std::make_unique<struct ChannelConfig_t>();
61 }
62
63 return channelConfig[channel].get();
64}
65
Patrick Venture0b02be92018-08-31 11:55:55 -070066// Helper Function to get IP Address/NetMask/Gateway/MAC Address from Network
67// Manager or Cache based on Set-In-Progress State
Patrick Venturec7c1c3c2017-11-15 14:29:18 -080068ipmi_ret_t getNetworkData(uint8_t lan_param, uint8_t* data, int channel)
tomjose26e17732016-03-03 08:52:51 -060069{
tomjose26e17732016-03-03 08:52:51 -060070 ipmi_ret_t rc = IPMI_CC_OK;
Ratan Guptab8e99552017-07-27 07:07:48 +053071 sdbusplus::bus::bus bus(ipmid_get_sd_bus_connection());
Ratan Gupta533d03b2017-07-30 10:39:22 +053072
Patrick Venturec7c1c3c2017-11-15 14:29:18 -080073 auto ethdevice = ipmi::network::ChanneltoEthernet(channel);
74 // if ethdevice is an empty string they weren't expecting this channel.
75 if (ethdevice.empty())
76 {
77 // TODO: return error from getNetworkData()
78 return IPMI_CC_INVALID_FIELD_REQUEST;
79 }
80 auto ethIP = ethdevice + "/" + ipmi::network::IP_TYPE;
81 auto channelConf = getChannelConfig(channel);
82
Ratan Guptab8e99552017-07-27 07:07:48 +053083 try
tomjose26e17732016-03-03 08:52:51 -060084 {
William A. Kennington IIIaab20232018-11-19 18:20:39 -080085 switch (static_cast<LanParam>(lan_param))
tomjose26e17732016-03-03 08:52:51 -060086 {
William A. Kennington IIIaab20232018-11-19 18:20:39 -080087 case LanParam::IP:
Ratan Guptab8e99552017-07-27 07:07:48 +053088 {
89 std::string ipaddress;
Patrick Venturec7c1c3c2017-11-15 14:29:18 -080090 if (channelConf->lan_set_in_progress == SET_COMPLETE)
Ratan Guptab8e99552017-07-27 07:07:48 +053091 {
Ratan Guptacc6cdbf2017-09-01 23:06:25 +053092 try
93 {
Patrick Venture0b02be92018-08-31 11:55:55 -070094 auto ipObjectInfo =
95 ipmi::getIPObject(bus, ipmi::network::IP_INTERFACE,
96 ipmi::network::ROOT, ethIP);
Ratan Guptadd646202017-11-21 17:46:59 +053097
98 auto properties = ipmi::getAllDbusProperties(
Patrick Venture0b02be92018-08-31 11:55:55 -070099 bus, ipObjectInfo.second, ipObjectInfo.first,
100 ipmi::network::IP_INTERFACE);
Ratan Guptadd646202017-11-21 17:46:59 +0530101
William A. Kennington III4c008022018-10-12 17:18:14 -0700102 ipaddress =
103 variant_ns::get<std::string>(properties["Address"]);
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530104 }
Gunnar Millsc9fa69e2018-04-08 16:35:25 -0500105 // ignore the exception, as it is a valid condition that
106 // the system is not configured with any IP.
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530107 catch (InternalFailure& e)
108 {
109 // nothing to do.
110 }
Ratan Guptab8e99552017-07-27 07:07:48 +0530111 }
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800112 else if (channelConf->lan_set_in_progress == SET_IN_PROGRESS)
Ratan Guptab8e99552017-07-27 07:07:48 +0530113 {
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800114 ipaddress = channelConf->ipaddr;
Ratan Guptab8e99552017-07-27 07:07:48 +0530115 }
116
117 inet_pton(AF_INET, ipaddress.c_str(),
118 reinterpret_cast<void*>(data));
119 }
120 break;
121
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800122 case LanParam::IPSRC:
Ratan Guptab8e99552017-07-27 07:07:48 +0530123 {
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530124 std::string networkInterfacePath;
125
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800126 if (channelConf->lan_set_in_progress == SET_COMPLETE)
Ratan Guptab8e99552017-07-27 07:07:48 +0530127 {
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530128 try
129 {
130 ipmi::ObjectTree ancestorMap;
131 // if the system is having ip object,then
132 // get the IP object.
133 auto ipObject = ipmi::getDbusObject(
Patrick Venture0b02be92018-08-31 11:55:55 -0700134 bus, ipmi::network::IP_INTERFACE,
135 ipmi::network::ROOT, ethIP);
Ratan Guptab8e99552017-07-27 07:07:48 +0530136
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530137 // Get the parent interface of the IP object.
138 try
139 {
140 ipmi::InterfaceList interfaces;
141 interfaces.emplace_back(
Patrick Venture0b02be92018-08-31 11:55:55 -0700142 ipmi::network::ETHERNET_INTERFACE);
Ratan Guptab8e99552017-07-27 07:07:48 +0530143
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530144 ancestorMap = ipmi::getAllAncestors(
Patrick Venture0b02be92018-08-31 11:55:55 -0700145 bus, ipObject.first, std::move(interfaces));
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530146 }
147 catch (InternalFailure& e)
148 {
149 // if unable to get the parent interface
150 // then commit the error and return.
Patrick Venture0b02be92018-08-31 11:55:55 -0700151 log<level::ERR>(
152 "Unable to get the parent interface",
153 entry("PATH=%s", ipObject.first.c_str()),
154 entry("INTERFACE=%s",
155 ipmi::network::ETHERNET_INTERFACE));
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530156 break;
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530157 }
158 // for an ip object there would be single parent
159 // interface.
160 networkInterfacePath = ancestorMap.begin()->first;
161 }
162 catch (InternalFailure& e)
163 {
164 // if there is no ip configured on the system,then
165 // get the network interface object.
166 auto networkInterfaceObject = ipmi::getDbusObject(
Patrick Venture0b02be92018-08-31 11:55:55 -0700167 bus, ipmi::network::ETHERNET_INTERFACE,
168 ipmi::network::ROOT, ethdevice);
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530169
170 networkInterfacePath = networkInterfaceObject.first;
171 }
172
173 auto variant = ipmi::getDbusProperty(
Patrick Venture0b02be92018-08-31 11:55:55 -0700174 bus, ipmi::network::SERVICE, networkInterfacePath,
175 ipmi::network::ETHERNET_INTERFACE, "DHCPEnabled");
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530176
William A. Kennington III4c008022018-10-12 17:18:14 -0700177 auto dhcpEnabled = variant_ns::get<bool>(variant);
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530178 // As per IPMI spec 2=>DHCP, 1=STATIC
Patrick Venture0b02be92018-08-31 11:55:55 -0700179 auto ipsrc = dhcpEnabled ? ipmi::network::IPOrigin::DHCP
180 : ipmi::network::IPOrigin::STATIC;
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530181
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700182 std::memcpy(data, &ipsrc, ipmi::network::IPSRC_SIZE_BYTE);
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530183 }
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800184 else if (channelConf->lan_set_in_progress == SET_IN_PROGRESS)
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530185 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700186 std::memcpy(data, &(channelConf->ipsrc),
187 ipmi::network::IPSRC_SIZE_BYTE);
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530188 }
189 }
190 break;
191
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800192 case LanParam::SUBNET:
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530193 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700194 unsigned long mask{};
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800195 if (channelConf->lan_set_in_progress == SET_COMPLETE)
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530196 {
197 try
198 {
Ratan Guptadd646202017-11-21 17:46:59 +0530199 auto ipObjectInfo = ipmi::getIPObject(
Patrick Venture0b02be92018-08-31 11:55:55 -0700200 bus, ipmi::network::IP_INTERFACE,
201 ipmi::network::ROOT, ipmi::network::IP_TYPE);
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530202
203 auto properties = ipmi::getAllDbusProperties(
Patrick Venture0b02be92018-08-31 11:55:55 -0700204 bus, ipObjectInfo.second, ipObjectInfo.first,
205 ipmi::network::IP_INTERFACE);
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530206
William A. Kennington III4c008022018-10-12 17:18:14 -0700207 auto prefix = variant_ns::get<uint8_t>(
208 properties["PrefixLength"]);
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530209 mask = ipmi::network::MASK_32_BIT;
210 mask = htonl(mask << (ipmi::network::BITS_32 - prefix));
211 }
Gunnar Millsc9fa69e2018-04-08 16:35:25 -0500212 // ignore the exception, as it is a valid condition that
213 // the system is not configured with any IP.
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530214 catch (InternalFailure& e)
215 {
216 // nothing to do
217 }
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700218 std::memcpy(data, &mask,
219 ipmi::network::IPV4_ADDRESS_SIZE_BYTE);
Ratan Guptab8e99552017-07-27 07:07:48 +0530220 }
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800221 else if (channelConf->lan_set_in_progress == SET_IN_PROGRESS)
Ratan Guptab8e99552017-07-27 07:07:48 +0530222 {
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800223 inet_pton(AF_INET, channelConf->netmask.c_str(),
Ratan Guptab8e99552017-07-27 07:07:48 +0530224 reinterpret_cast<void*>(data));
Ratan Guptab8e99552017-07-27 07:07:48 +0530225 }
Ratan Guptab8e99552017-07-27 07:07:48 +0530226 }
227 break;
228
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800229 case LanParam::GATEWAY:
Ratan Guptab8e99552017-07-27 07:07:48 +0530230 {
231 std::string gateway;
232
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800233 if (channelConf->lan_set_in_progress == SET_COMPLETE)
Ratan Guptab8e99552017-07-27 07:07:48 +0530234 {
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530235 try
236 {
237 auto systemObject = ipmi::getDbusObject(
Patrick Venture0b02be92018-08-31 11:55:55 -0700238 bus, ipmi::network::SYSTEMCONFIG_INTERFACE,
239 ipmi::network::ROOT);
Ratan Guptab8e99552017-07-27 07:07:48 +0530240
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530241 auto systemProperties = ipmi::getAllDbusProperties(
Patrick Venture0b02be92018-08-31 11:55:55 -0700242 bus, systemObject.second, systemObject.first,
243 ipmi::network::SYSTEMCONFIG_INTERFACE);
Ratan Guptab8e99552017-07-27 07:07:48 +0530244
William A. Kennington III4c008022018-10-12 17:18:14 -0700245 gateway = variant_ns::get<std::string>(
246 systemProperties["DefaultGateway"]);
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530247 }
Gunnar Millsc9fa69e2018-04-08 16:35:25 -0500248 // ignore the exception, as it is a valid condition that
249 // the system is not configured with any IP.
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530250 catch (InternalFailure& e)
251 {
252 // nothing to do
253 }
Ratan Guptab8e99552017-07-27 07:07:48 +0530254 }
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800255 else if (channelConf->lan_set_in_progress == SET_IN_PROGRESS)
Ratan Guptab8e99552017-07-27 07:07:48 +0530256 {
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800257 gateway = channelConf->gateway;
Ratan Guptab8e99552017-07-27 07:07:48 +0530258 }
259
260 inet_pton(AF_INET, gateway.c_str(),
261 reinterpret_cast<void*>(data));
Ratan Guptab8e99552017-07-27 07:07:48 +0530262 }
263 break;
264
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800265 case LanParam::MAC:
Ratan Guptab8e99552017-07-27 07:07:48 +0530266 {
267 std::string macAddress;
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800268 if (channelConf->lan_set_in_progress == SET_COMPLETE)
Ratan Guptab8e99552017-07-27 07:07:48 +0530269 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700270 auto macObjectInfo =
271 ipmi::getDbusObject(bus, ipmi::network::MAC_INTERFACE,
272 ipmi::network::ROOT, ethdevice);
Ratan Guptab8e99552017-07-27 07:07:48 +0530273
274 auto variant = ipmi::getDbusProperty(
Patrick Venture0b02be92018-08-31 11:55:55 -0700275 bus, macObjectInfo.second, macObjectInfo.first,
276 ipmi::network::MAC_INTERFACE, "MACAddress");
Ratan Guptab8e99552017-07-27 07:07:48 +0530277
William A. Kennington III4c008022018-10-12 17:18:14 -0700278 macAddress = variant_ns::get<std::string>(variant);
Ratan Guptab8e99552017-07-27 07:07:48 +0530279 }
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800280 else if (channelConf->lan_set_in_progress == SET_IN_PROGRESS)
Ratan Guptab8e99552017-07-27 07:07:48 +0530281 {
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800282 macAddress = channelConf->macAddress;
Ratan Guptab8e99552017-07-27 07:07:48 +0530283 }
284
285 sscanf(macAddress.c_str(), ipmi::network::MAC_ADDRESS_FORMAT,
Patrick Venture0b02be92018-08-31 11:55:55 -0700286 (data), (data + 1), (data + 2), (data + 3), (data + 4),
Ratan Guptab8e99552017-07-27 07:07:48 +0530287 (data + 5));
288 }
289 break;
290
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800291 case LanParam::VLAN:
Ratan Gupta533d03b2017-07-30 10:39:22 +0530292 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700293 uint16_t vlanID{};
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800294 if (channelConf->lan_set_in_progress == SET_COMPLETE)
Ratan Gupta533d03b2017-07-30 10:39:22 +0530295 {
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530296 try
Ratan Gupta533d03b2017-07-30 10:39:22 +0530297 {
Ratan Guptadd646202017-11-21 17:46:59 +0530298 auto ipObjectInfo = ipmi::getIPObject(
Patrick Venture0b02be92018-08-31 11:55:55 -0700299 bus, ipmi::network::IP_INTERFACE,
300 ipmi::network::ROOT, ipmi::network::IP_TYPE);
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530301
302 vlanID = static_cast<uint16_t>(
Patrick Venture0b02be92018-08-31 11:55:55 -0700303 ipmi::network::getVLAN(ipObjectInfo.first));
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530304
305 vlanID = htole16(vlanID);
306
307 if (vlanID)
308 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700309 // Enable the 16th bit
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530310 vlanID |= htole16(ipmi::network::VLAN_ENABLE_MASK);
311 }
312 }
Gunnar Millsc9fa69e2018-04-08 16:35:25 -0500313 // ignore the exception, as it is a valid condition that
314 // the system is not configured with any IP.
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530315 catch (InternalFailure& e)
316 {
317 // nothing to do
Ratan Gupta533d03b2017-07-30 10:39:22 +0530318 }
319
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700320 std::memcpy(data, &vlanID, ipmi::network::VLAN_SIZE_BYTE);
Ratan Gupta533d03b2017-07-30 10:39:22 +0530321 }
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800322 else if (channelConf->lan_set_in_progress == SET_IN_PROGRESS)
Ratan Gupta533d03b2017-07-30 10:39:22 +0530323 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700324 std::memcpy(data, &(channelConf->vlanID),
325 ipmi::network::VLAN_SIZE_BYTE);
Ratan Gupta533d03b2017-07-30 10:39:22 +0530326 }
327 }
328 break;
329
Ratan Guptab8e99552017-07-27 07:07:48 +0530330 default:
331 rc = IPMI_CC_PARM_OUT_OF_RANGE;
tomjose26e17732016-03-03 08:52:51 -0600332 }
333 }
Ratan Guptab8e99552017-07-27 07:07:48 +0530334 catch (InternalFailure& e)
tomjose26e17732016-03-03 08:52:51 -0600335 {
Ratan Guptab8e99552017-07-27 07:07:48 +0530336 commit<InternalFailure>();
337 rc = IPMI_CC_UNSPECIFIED_ERROR;
338 return rc;
tomjose26e17732016-03-03 08:52:51 -0600339 }
tomjose26e17732016-03-03 08:52:51 -0600340 return rc;
341}
342
Tom Josepha30c8d32018-03-22 02:15:03 +0530343namespace cipher
344{
345
346std::vector<uint8_t> getCipherList()
347{
348 std::vector<uint8_t> cipherList;
349
350 std::ifstream jsonFile(configFile);
351 if (!jsonFile.is_open())
352 {
353 log<level::ERR>("Channel Cipher suites file not found");
354 elog<InternalFailure>();
355 }
356
357 auto data = Json::parse(jsonFile, nullptr, false);
358 if (data.is_discarded())
359 {
360 log<level::ERR>("Parsing channel cipher suites JSON failed");
361 elog<InternalFailure>();
362 }
363
364 // Byte 1 is reserved
365 cipherList.push_back(0x00);
366
367 for (const auto& record : data)
368 {
369 cipherList.push_back(record.value(cipher, 0));
370 }
371
372 return cipherList;
373}
374
Patrick Venture0b02be92018-08-31 11:55:55 -0700375} // namespace cipher
Tom Josepha30c8d32018-03-22 02:15:03 +0530376
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500377ipmi_ret_t ipmi_transport_wildcard(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
Patrick Venture0b02be92018-08-31 11:55:55 -0700378 ipmi_request_t request,
379 ipmi_response_t response,
380 ipmi_data_len_t data_len,
381 ipmi_context_t context)
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500382{
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500383 // Status code.
Nan Li70aa8d92016-08-29 00:11:10 +0800384 ipmi_ret_t rc = IPMI_CC_INVALID;
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500385 *data_len = 0;
386 return rc;
387}
388
Ratan Guptab8e99552017-07-27 07:07:48 +0530389struct set_lan_t
390{
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500391 uint8_t channel;
392 uint8_t parameter;
393 uint8_t data[8]; // Per IPMI spec, not expecting more than this size
Patrick Venture0b02be92018-08-31 11:55:55 -0700394} __attribute__((packed));
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500395
Patrick Venture0b02be92018-08-31 11:55:55 -0700396ipmi_ret_t ipmi_transport_set_lan(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
Ratan Guptab8e99552017-07-27 07:07:48 +0530397 ipmi_request_t request,
398 ipmi_response_t response,
399 ipmi_data_len_t data_len,
400 ipmi_context_t context)
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500401{
402 ipmi_ret_t rc = IPMI_CC_OK;
403 *data_len = 0;
Nan Li3d0df912016-10-18 19:51:41 +0800404
Ratan Gupta7a7f0122018-03-07 12:31:05 +0530405 using namespace std::chrono_literals;
406
407 // time to wait before applying the network changes.
408 constexpr auto networkTimeout = 10000000us; // 10 sec
409
Ratan Guptab8e99552017-07-27 07:07:48 +0530410 char ipaddr[INET_ADDRSTRLEN];
411 char netmask[INET_ADDRSTRLEN];
412 char gateway[INET_ADDRSTRLEN];
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500413
Ratan Guptab8e99552017-07-27 07:07:48 +0530414 auto reqptr = reinterpret_cast<const set_lan_t*>(request);
415 sdbusplus::bus::bus bus(ipmid_get_sd_bus_connection());
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500416
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800417 // channel number is the lower nibble
418 int channel = reqptr->channel & CHANNEL_MASK;
419 auto ethdevice = ipmi::network::ChanneltoEthernet(channel);
420 if (ethdevice.empty())
421 {
422 return IPMI_CC_INVALID_FIELD_REQUEST;
423 }
424 auto channelConf = getChannelConfig(channel);
425
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800426 switch (static_cast<LanParam>(reqptr->parameter))
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500427 {
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800428 case LanParam::IP:
Hariharasubramanian R83951912016-01-20 07:06:36 -0600429 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700430 std::snprintf(ipaddr, INET_ADDRSTRLEN,
431 ipmi::network::IP_ADDRESS_FORMAT, reqptr->data[0],
432 reqptr->data[1], reqptr->data[2], reqptr->data[3]);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500433
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800434 channelConf->ipaddr.assign(ipaddr);
Ratan Guptab8e99552017-07-27 07:07:48 +0530435 }
436 break;
437
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800438 case LanParam::IPSRC:
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530439 {
440 uint8_t ipsrc{};
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700441 std::memcpy(&ipsrc, reqptr->data, ipmi::network::IPSRC_SIZE_BYTE);
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800442 channelConf->ipsrc = static_cast<ipmi::network::IPOrigin>(ipsrc);
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530443 }
444 break;
445
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800446 case LanParam::MAC:
Ratan Guptab8e99552017-07-27 07:07:48 +0530447 {
448 char mac[SIZE_MAC];
449
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700450 std::snprintf(mac, SIZE_MAC, ipmi::network::MAC_ADDRESS_FORMAT,
451 reqptr->data[0], reqptr->data[1], reqptr->data[2],
452 reqptr->data[3], reqptr->data[4], reqptr->data[5]);
Ratan Guptab8e99552017-07-27 07:07:48 +0530453
Patrick Venture0b02be92018-08-31 11:55:55 -0700454 auto macObjectInfo =
455 ipmi::getDbusObject(bus, ipmi::network::MAC_INTERFACE,
456 ipmi::network::ROOT, ethdevice);
Ratan Guptab8e99552017-07-27 07:07:48 +0530457
Patrick Venture0b02be92018-08-31 11:55:55 -0700458 ipmi::setDbusProperty(
459 bus, macObjectInfo.second, macObjectInfo.first,
460 ipmi::network::MAC_INTERFACE, "MACAddress", std::string(mac));
Ratan Guptab8e99552017-07-27 07:07:48 +0530461
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800462 channelConf->macAddress = mac;
Ratan Guptab8e99552017-07-27 07:07:48 +0530463 }
464 break;
465
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800466 case LanParam::SUBNET:
Ratan Guptab8e99552017-07-27 07:07:48 +0530467 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700468 std::snprintf(netmask, INET_ADDRSTRLEN,
469 ipmi::network::IP_ADDRESS_FORMAT, reqptr->data[0],
470 reqptr->data[1], reqptr->data[2], reqptr->data[3]);
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800471 channelConf->netmask.assign(netmask);
Ratan Guptab8e99552017-07-27 07:07:48 +0530472 }
473 break;
474
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800475 case LanParam::GATEWAY:
Ratan Guptab8e99552017-07-27 07:07:48 +0530476 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700477 std::snprintf(gateway, INET_ADDRSTRLEN,
478 ipmi::network::IP_ADDRESS_FORMAT, reqptr->data[0],
479 reqptr->data[1], reqptr->data[2], reqptr->data[3]);
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800480 channelConf->gateway.assign(gateway);
Ratan Guptab8e99552017-07-27 07:07:48 +0530481 }
482 break;
483
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800484 case LanParam::VLAN:
Ratan Gupta533d03b2017-07-30 10:39:22 +0530485 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700486 uint16_t vlan{};
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700487 std::memcpy(&vlan, reqptr->data, ipmi::network::VLAN_SIZE_BYTE);
Ratan Gupta533d03b2017-07-30 10:39:22 +0530488 // We are not storing the enable bit
489 // We assume that ipmitool always send enable
490 // bit as 1.
491 vlan = le16toh(vlan);
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800492 channelConf->vlanID = vlan;
Ratan Gupta533d03b2017-07-30 10:39:22 +0530493 }
494 break;
495
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800496 case LanParam::INPROGRESS:
Ratan Guptab8e99552017-07-27 07:07:48 +0530497 {
498 if (reqptr->data[0] == SET_COMPLETE)
499 {
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800500 channelConf->lan_set_in_progress = SET_COMPLETE;
Ratan Guptab8e99552017-07-27 07:07:48 +0530501
Patrick Venture0b02be92018-08-31 11:55:55 -0700502 log<level::INFO>(
503 "Network data from Cache",
504 entry("PREFIX=%s", channelConf->netmask.c_str()),
505 entry("ADDRESS=%s", channelConf->ipaddr.c_str()),
506 entry("GATEWAY=%s", channelConf->gateway.c_str()),
507 entry("VLAN=%d", channelConf->vlanID));
Ratan Guptab8e99552017-07-27 07:07:48 +0530508
Ratan Gupta7a7f0122018-03-07 12:31:05 +0530509 if (!networkTimer)
510 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700511 log<level::ERR>("Network timer is not instantiated");
512 return IPMI_CC_UNSPECIFIED_ERROR;
Ratan Gupta7a7f0122018-03-07 12:31:05 +0530513 }
514
515 // start/restart the timer
Vernon Mauery1181af72018-10-08 12:05:00 -0700516 networkTimer->start(networkTimeout);
Ratan Guptab8e99552017-07-27 07:07:48 +0530517 }
518 else if (reqptr->data[0] == SET_IN_PROGRESS) // Set In Progress
519 {
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800520 channelConf->lan_set_in_progress = SET_IN_PROGRESS;
Ratan Gupta7a7f0122018-03-07 12:31:05 +0530521 channelConf->flush = true;
Ratan Guptab8e99552017-07-27 07:07:48 +0530522 }
Ratan Guptab8e99552017-07-27 07:07:48 +0530523 }
524 break;
525
526 default:
527 {
Ratan Guptab8e99552017-07-27 07:07:48 +0530528 rc = IPMI_CC_PARM_NOT_SUPPORTED;
529 }
Ratan Guptab8e99552017-07-27 07:07:48 +0530530 }
vishwa1eaea4f2016-02-26 11:57:40 -0600531
tomjose26e17732016-03-03 08:52:51 -0600532 return rc;
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500533}
534
Ratan Guptab8e99552017-07-27 07:07:48 +0530535struct get_lan_t
536{
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500537 uint8_t rev_channel;
538 uint8_t parameter;
539 uint8_t parameter_set;
540 uint8_t parameter_block;
Patrick Venture0b02be92018-08-31 11:55:55 -0700541} __attribute__((packed));
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500542
Patrick Venture0b02be92018-08-31 11:55:55 -0700543ipmi_ret_t ipmi_transport_get_lan(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
Ratan Guptab8e99552017-07-27 07:07:48 +0530544 ipmi_request_t request,
545 ipmi_response_t response,
546 ipmi_data_len_t data_len,
547 ipmi_context_t context)
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500548{
549 ipmi_ret_t rc = IPMI_CC_OK;
550 *data_len = 0;
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500551 const uint8_t current_revision = 0x11; // Current rev per IPMI Spec 2.0
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500552
Patrick Venture0b02be92018-08-31 11:55:55 -0700553 get_lan_t* reqptr = (get_lan_t*)request;
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800554 // channel number is the lower nibble
555 int channel = reqptr->rev_channel & CHANNEL_MASK;
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500556
557 if (reqptr->rev_channel & 0x80) // Revision is bit 7
558 {
559 // Only current revision was requested
560 *data_len = sizeof(current_revision);
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700561 std::memcpy(response, &current_revision, *data_len);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500562 return IPMI_CC_OK;
563 }
564
Tom Josepha30c8d32018-03-22 02:15:03 +0530565 static std::vector<uint8_t> cipherList;
566 static auto listInit = false;
567
568 if (!listInit)
569 {
570 try
571 {
572 cipherList = cipher::getCipherList();
573 listInit = true;
574 }
Patrick Venture0b02be92018-08-31 11:55:55 -0700575 catch (const std::exception& e)
Tom Josepha30c8d32018-03-22 02:15:03 +0530576 {
577 return IPMI_CC_UNSPECIFIED_ERROR;
578 }
579 }
580
Patrick Venturec7c1c3c2017-11-15 14:29:18 -0800581 auto ethdevice = ipmi::network::ChanneltoEthernet(channel);
582 if (ethdevice.empty())
583 {
584 return IPMI_CC_INVALID_FIELD_REQUEST;
585 }
586 auto channelConf = getChannelConfig(channel);
587
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800588 LanParam param = static_cast<LanParam>(reqptr->parameter);
589 switch (param)
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500590 {
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800591 case LanParam::INPROGRESS:
vishwa1eaea4f2016-02-26 11:57:40 -0600592 {
William A. Kennington III39f94ef2018-11-19 22:36:16 -0800593 uint8_t buf[] = {current_revision,
594 channelConf->lan_set_in_progress};
595 *data_len = sizeof(buf);
596 std::memcpy(response, &buf, *data_len);
597 break;
598 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800599 case LanParam::AUTHSUPPORT:
William A. Kennington III39f94ef2018-11-19 22:36:16 -0800600 {
601 uint8_t buf[] = {current_revision, 0x04};
602 *data_len = sizeof(buf);
603 std::memcpy(response, &buf, *data_len);
604 break;
605 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800606 case LanParam::AUTHENABLES:
William A. Kennington III39f94ef2018-11-19 22:36:16 -0800607 {
608 uint8_t buf[] = {current_revision, 0x04, 0x04, 0x04, 0x04, 0x04};
609 *data_len = sizeof(buf);
610 std::memcpy(response, &buf, *data_len);
611 break;
612 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800613 case LanParam::IP:
614 case LanParam::SUBNET:
615 case LanParam::GATEWAY:
616 case LanParam::MAC:
William A. Kennington III39f94ef2018-11-19 22:36:16 -0800617 {
618 uint8_t buf[ipmi::network::MAC_ADDRESS_SIZE_BYTE + 1] = {};
619
620 *data_len = sizeof(current_revision);
621 std::memcpy(buf, &current_revision, *data_len);
622
623 if (getNetworkData(reqptr->parameter, &buf[1], channel) ==
624 IPMI_CC_OK)
Ratan Guptab8e99552017-07-27 07:07:48 +0530625 {
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800626 if (param == LanParam::MAC)
William A. Kennington III39f94ef2018-11-19 22:36:16 -0800627 {
628 *data_len = sizeof(buf);
629 }
630 else
631 {
632 *data_len = ipmi::network::IPV4_ADDRESS_SIZE_BYTE + 1;
633 }
634 std::memcpy(response, &buf, *data_len);
Ratan Guptab8e99552017-07-27 07:07:48 +0530635 }
636 else
637 {
William A. Kennington III39f94ef2018-11-19 22:36:16 -0800638 rc = IPMI_CC_UNSPECIFIED_ERROR;
Ratan Guptab8e99552017-07-27 07:07:48 +0530639 }
William A. Kennington III39f94ef2018-11-19 22:36:16 -0800640 break;
Adriana Kobylak342df102016-02-10 13:48:16 -0600641 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800642 case LanParam::VLAN:
Hariharasubramanian R83951912016-01-20 07:06:36 -0600643 {
William A. Kennington III39f94ef2018-11-19 22:36:16 -0800644 uint8_t buf[ipmi::network::VLAN_SIZE_BYTE + 1] = {};
Ratan Gupta533d03b2017-07-30 10:39:22 +0530645
William A. Kennington III39f94ef2018-11-19 22:36:16 -0800646 *data_len = sizeof(current_revision);
647 std::memcpy(buf, &current_revision, *data_len);
648 if (getNetworkData(reqptr->parameter, &buf[1], channel) ==
649 IPMI_CC_OK)
650 {
651 *data_len = sizeof(buf);
652 std::memcpy(response, &buf, *data_len);
653 }
654 break;
Ratan Gupta533d03b2017-07-30 10:39:22 +0530655 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800656 case LanParam::IPSRC:
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530657 {
William A. Kennington III39f94ef2018-11-19 22:36:16 -0800658 uint8_t buff[ipmi::network::IPSRC_SIZE_BYTE + 1] = {};
659 *data_len = sizeof(current_revision);
660 std::memcpy(buff, &current_revision, *data_len);
661 if (getNetworkData(reqptr->parameter, &buff[1], channel) ==
662 IPMI_CC_OK)
663 {
664 *data_len = sizeof(buff);
665 std::memcpy(response, &buff, *data_len);
666 }
667 break;
Ratan Guptacc6cdbf2017-09-01 23:06:25 +0530668 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800669 case LanParam::CIPHER_SUITE_COUNT:
William A. Kennington III39f94ef2018-11-19 22:36:16 -0800670 {
671 *(static_cast<uint8_t*>(response)) = current_revision;
672 // Byte 1 is reserved byte and does not indicate a cipher suite ID,
673 // so no of cipher suite entry count is one less than the size of
674 // the vector
675 auto count = static_cast<uint8_t>(cipherList.size() - 1);
676 *(static_cast<uint8_t*>(response) + 1) = count;
677 *data_len = sizeof(current_revision) + sizeof(count);
678 break;
679 }
William A. Kennington IIIaab20232018-11-19 18:20:39 -0800680 case LanParam::CIPHER_SUITE_ENTRIES:
William A. Kennington III39f94ef2018-11-19 22:36:16 -0800681 {
682 *(static_cast<uint8_t*>(response)) = current_revision;
683 // Byte 1 is reserved
684 std::copy_n(cipherList.data(), cipherList.size(),
685 static_cast<uint8_t*>(response) + 1);
686 *data_len = sizeof(current_revision) +
687 static_cast<uint8_t>(cipherList.size());
688 break;
689 }
690 default:
691 log<level::ERR>("Unsupported parameter",
692 entry("PARAMETER=0x%x", reqptr->parameter));
693 rc = IPMI_CC_PARM_NOT_SUPPORTED;
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500694 }
695
696 return rc;
697}
698
Ratan Gupta7a7f0122018-03-07 12:31:05 +0530699void applyChanges(int channel)
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530700{
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530701 std::string ipaddress;
702 std::string gateway;
Patrick Venture0b02be92018-08-31 11:55:55 -0700703 uint8_t prefix{};
704 uint32_t vlanID{};
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530705 std::string networkInterfacePath;
706 ipmi::DbusObjectInfo ipObject;
707 ipmi::DbusObjectInfo systemObject;
708
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530709 auto ethdevice = ipmi::network::ChanneltoEthernet(channel);
710 if (ethdevice.empty())
711 {
Ratan Gupta7a7f0122018-03-07 12:31:05 +0530712 log<level::ERR>("Unable to get the interface name",
713 entry("CHANNEL=%d", channel));
714 return;
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530715 }
716 auto ethIp = ethdevice + "/" + ipmi::network::IP_TYPE;
717 auto channelConf = getChannelConfig(channel);
718
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530719 try
720 {
721 sdbusplus::bus::bus bus(ipmid_get_sd_bus_connection());
722
723 log<level::INFO>("Network data from Cache",
724 entry("PREFIX=%s", channelConf->netmask.c_str()),
725 entry("ADDRESS=%s", channelConf->ipaddr.c_str()),
726 entry("GATEWAY=%s", channelConf->gateway.c_str()),
727 entry("VLAN=%d", channelConf->vlanID),
728 entry("IPSRC=%d", channelConf->ipsrc));
729 if (channelConf->vlanID != ipmi::network::VLAN_ID_MASK)
730 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700731 // get the first twelve bits which is vlan id
732 // not interested in rest of the bits.
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530733 channelConf->vlanID = le32toh(channelConf->vlanID);
734 vlanID = channelConf->vlanID & ipmi::network::VLAN_ID_MASK;
735 }
736
737 // if the asked ip src is DHCP then not interested in
738 // any given data except vlan.
739 if (channelConf->ipsrc != ipmi::network::IPOrigin::DHCP)
740 {
741 // always get the system object
Patrick Venture0b02be92018-08-31 11:55:55 -0700742 systemObject =
743 ipmi::getDbusObject(bus, ipmi::network::SYSTEMCONFIG_INTERFACE,
744 ipmi::network::ROOT);
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530745
746 // the below code is to determine the mode of the interface
747 // as the handling is same, if the system is configured with
748 // DHCP or user has given all the data.
749 try
750 {
751 ipmi::ObjectTree ancestorMap;
752
Patrick Venture0b02be92018-08-31 11:55:55 -0700753 ipmi::InterfaceList interfaces{
754 ipmi::network::ETHERNET_INTERFACE};
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530755
756 // if the system is having ip object,then
757 // get the IP object.
Patrick Venture0b02be92018-08-31 11:55:55 -0700758 ipObject = ipmi::getIPObject(bus, ipmi::network::IP_INTERFACE,
759 ipmi::network::ROOT, ethIp);
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530760
761 // Get the parent interface of the IP object.
762 try
763 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700764 ancestorMap = ipmi::getAllAncestors(bus, ipObject.first,
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530765 std::move(interfaces));
766 }
767 catch (InternalFailure& e)
768 {
769 // if unable to get the parent interface
770 // then commit the error and return.
771 log<level::ERR>("Unable to get the parent interface",
772 entry("PATH=%s", ipObject.first.c_str()),
773 entry("INTERFACE=%s",
774 ipmi::network::ETHERNET_INTERFACE));
775 commit<InternalFailure>();
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530776 channelConf->clear();
Ratan Gupta7a7f0122018-03-07 12:31:05 +0530777 return;
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530778 }
779
780 networkInterfacePath = ancestorMap.begin()->first;
781 }
782 catch (InternalFailure& e)
783 {
784 // TODO Currently IPMI supports single interface,need to handle
785 // Multiple interface through
786 // https://github.com/openbmc/openbmc/issues/2138
787
788 // if there is no ip configured on the system,then
789 // get the network interface object.
Patrick Venture0b02be92018-08-31 11:55:55 -0700790 auto networkInterfaceObject =
791 ipmi::getDbusObject(bus, ipmi::network::ETHERNET_INTERFACE,
792 ipmi::network::ROOT, ethdevice);
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530793
794 networkInterfacePath = std::move(networkInterfaceObject.first);
795 }
796
797 // get the configured mode on the system.
William A. Kennington III4c008022018-10-12 17:18:14 -0700798 auto enableDHCP = variant_ns::get<bool>(ipmi::getDbusProperty(
799 bus, ipmi::network::SERVICE, networkInterfacePath,
800 ipmi::network::ETHERNET_INTERFACE, "DHCPEnabled"));
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530801
802 // if ip address source is not given then get the ip source mode
803 // from the system so that it can be applied later.
804 if (channelConf->ipsrc == ipmi::network::IPOrigin::UNSPECIFIED)
805 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700806 channelConf->ipsrc = (enableDHCP)
807 ? ipmi::network::IPOrigin::DHCP
808 : ipmi::network::IPOrigin::STATIC;
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530809 }
810
811 // check whether user has given all the data
812 // or the configured system interface is dhcp enabled,
813 // in both of the cases get the values from the cache.
814 if ((!channelConf->ipaddr.empty() &&
815 !channelConf->netmask.empty() &&
816 !channelConf->gateway.empty()) ||
817 (enableDHCP)) // configured system interface mode = DHCP
818 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700819 // convert mask into prefix
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530820 ipaddress = channelConf->ipaddr;
821 prefix = ipmi::network::toPrefix(AF_INET, channelConf->netmask);
822 gateway = channelConf->gateway;
823 }
824 else // asked ip src = static and configured system src = static
Patrick Venture0b02be92018-08-31 11:55:55 -0700825 // or partially given data.
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530826 {
827 // We have partial filled cache so get the remaining
828 // info from the system.
829
830 // Get the network data from the system as user has
831 // not given all the data then use the data fetched from the
832 // system but it is implementation dependent,IPMI spec doesn't
833 // force it.
834
835 // if system is not having any ip object don't throw error,
836 try
837 {
838 auto properties = ipmi::getAllDbusProperties(
Patrick Venture0b02be92018-08-31 11:55:55 -0700839 bus, ipObject.second, ipObject.first,
840 ipmi::network::IP_INTERFACE);
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530841
Patrick Venture0b02be92018-08-31 11:55:55 -0700842 ipaddress = channelConf->ipaddr.empty()
William A. Kennington III4c008022018-10-12 17:18:14 -0700843 ? variant_ns::get<std::string>(
844 properties["Address"])
Patrick Venture0b02be92018-08-31 11:55:55 -0700845 : channelConf->ipaddr;
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530846
Patrick Venture0b02be92018-08-31 11:55:55 -0700847 prefix = channelConf->netmask.empty()
William A. Kennington III4c008022018-10-12 17:18:14 -0700848 ? variant_ns::get<uint8_t>(
849 properties["PrefixLength"])
Patrick Venture0b02be92018-08-31 11:55:55 -0700850 : ipmi::network::toPrefix(
851 AF_INET, channelConf->netmask);
852 }
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530853 catch (InternalFailure& e)
854 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700855 log<level::INFO>(
856 "Failed to get IP object which matches",
857 entry("INTERFACE=%s", ipmi::network::IP_INTERFACE),
858 entry("MATCH=%s", ethIp.c_str()));
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530859 }
860
861 auto systemProperties = ipmi::getAllDbusProperties(
Patrick Venture0b02be92018-08-31 11:55:55 -0700862 bus, systemObject.second, systemObject.first,
863 ipmi::network::SYSTEMCONFIG_INTERFACE);
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530864
William A. Kennington III4c008022018-10-12 17:18:14 -0700865 gateway = channelConf->gateway.empty()
866 ? variant_ns::get<std::string>(
867 systemProperties["DefaultGateway"])
868 : channelConf->gateway;
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530869 }
870 }
871
872 // Currently network manager doesn't support purging of all the
873 // ip addresses and the vlan interfaces from the parent interface,
874 // TODO once the support is there, will make the change here.
875 // https://github.com/openbmc/openbmc/issues/2141.
876
877 // TODO Currently IPMI supports single interface,need to handle
878 // Multiple interface through
879 // https://github.com/openbmc/openbmc/issues/2138
880
881 // instead of deleting all the vlan interfaces and
882 // all the ipv4 address,we will call reset method.
Patrick Venture0b02be92018-08-31 11:55:55 -0700883 // delete all the vlan interfaces
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530884
Patrick Venture0b02be92018-08-31 11:55:55 -0700885 ipmi::deleteAllDbusObjects(bus, ipmi::network::ROOT,
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530886 ipmi::network::VLAN_INTERFACE);
887
888 // set the interface mode to static
Patrick Venture0b02be92018-08-31 11:55:55 -0700889 auto networkInterfaceObject =
890 ipmi::getDbusObject(bus, ipmi::network::ETHERNET_INTERFACE,
891 ipmi::network::ROOT, ethdevice);
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530892
893 // setting the physical interface mode to static.
Patrick Venture0b02be92018-08-31 11:55:55 -0700894 ipmi::setDbusProperty(
895 bus, ipmi::network::SERVICE, networkInterfaceObject.first,
896 ipmi::network::ETHERNET_INTERFACE, "DHCPEnabled", false);
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530897
898 networkInterfacePath = networkInterfaceObject.first;
899
Patrick Venture0b02be92018-08-31 11:55:55 -0700900 // delete all the ipv4 addresses
901 ipmi::deleteAllDbusObjects(bus, ipmi::network::ROOT,
902 ipmi::network::IP_INTERFACE, ethIp);
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530903
904 if (vlanID)
905 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700906 ipmi::network::createVLAN(bus, ipmi::network::SERVICE,
907 ipmi::network::ROOT, ethdevice, vlanID);
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530908
909 auto networkInterfaceObject = ipmi::getDbusObject(
Patrick Venture0b02be92018-08-31 11:55:55 -0700910 bus, ipmi::network::VLAN_INTERFACE, ipmi::network::ROOT);
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530911
Patrick Venture0b02be92018-08-31 11:55:55 -0700912 networkInterfacePath = networkInterfaceObject.first;
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530913 }
914
915 if (channelConf->ipsrc == ipmi::network::IPOrigin::DHCP)
916 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700917 ipmi::setDbusProperty(
918 bus, ipmi::network::SERVICE, networkInterfacePath,
919 ipmi::network::ETHERNET_INTERFACE, "DHCPEnabled", true);
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530920 }
921 else
922 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700923 // change the mode to static
924 ipmi::setDbusProperty(
925 bus, ipmi::network::SERVICE, networkInterfacePath,
926 ipmi::network::ETHERNET_INTERFACE, "DHCPEnabled", false);
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530927
928 if (!ipaddress.empty())
929 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700930 ipmi::network::createIP(bus, ipmi::network::SERVICE,
931 networkInterfacePath, ipv4Protocol,
932 ipaddress, prefix);
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530933 }
934
935 if (!gateway.empty())
936 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700937 ipmi::setDbusProperty(bus, systemObject.second,
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530938 systemObject.first,
939 ipmi::network::SYSTEMCONFIG_INTERFACE,
Patrick Venture0b02be92018-08-31 11:55:55 -0700940 "DefaultGateway", std::string(gateway));
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530941 }
942 }
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530943 }
944 catch (InternalFailure& e)
945 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700946 log<level::ERR>(
947 "Failed to set network data", entry("PREFIX=%d", prefix),
948 entry("ADDRESS=%s", ipaddress.c_str()),
949 entry("GATEWAY=%s", gateway.c_str()), entry("VLANID=%d", vlanID),
950 entry("IPSRC=%d", channelConf->ipsrc));
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530951
952 commit<InternalFailure>();
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530953 }
954
955 channelConf->clear();
Ratan Gupta7a7f0122018-03-07 12:31:05 +0530956}
957
958void commitNetworkChanges()
959{
Patrick Venture0b02be92018-08-31 11:55:55 -0700960 for (const auto& channel : channelConfig)
Ratan Gupta7a7f0122018-03-07 12:31:05 +0530961 {
962 if (channel.second->flush)
963 {
964 applyChanges(channel.first);
965 }
966 }
967}
968
969void createNetworkTimer()
970{
971 if (!networkTimer)
972 {
973 std::function<void()> networkTimerCallback(
Patrick Venture0b02be92018-08-31 11:55:55 -0700974 std::bind(&commitNetworkChanges));
Ratan Gupta7a7f0122018-03-07 12:31:05 +0530975
Vernon Mauery1181af72018-10-08 12:05:00 -0700976 networkTimer = std::make_unique<phosphor::Timer>(networkTimerCallback);
Ratan Gupta7a7f0122018-03-07 12:31:05 +0530977 }
Ratan Gupta1247e0b2018-03-07 10:47:25 +0530978}
979
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500980void register_netfn_transport_functions()
981{
Ratan Gupta7a7f0122018-03-07 12:31:05 +0530982 // As this timer is only for transport handler
983 // so creating it here.
984 createNetworkTimer();
Tom05732372016-09-06 17:21:23 +0530985 // <Wildcard Command>
Patrick Venture0b02be92018-08-31 11:55:55 -0700986 ipmi_register_callback(NETFUN_TRANSPORT, IPMI_CMD_WILDCARD, NULL,
987 ipmi_transport_wildcard, PRIVILEGE_USER);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500988
Tom05732372016-09-06 17:21:23 +0530989 // <Set LAN Configuration Parameters>
Patrick Venture0b02be92018-08-31 11:55:55 -0700990 ipmi_register_callback(NETFUN_TRANSPORT, IPMI_CMD_SET_LAN, NULL,
991 ipmi_transport_set_lan, PRIVILEGE_ADMIN);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500992
Tom05732372016-09-06 17:21:23 +0530993 // <Get LAN Configuration Parameters>
Patrick Venture0b02be92018-08-31 11:55:55 -0700994 ipmi_register_callback(NETFUN_TRANSPORT, IPMI_CMD_GET_LAN, NULL,
995 ipmi_transport_get_lan, PRIVILEGE_OPERATOR);
Adriana Kobylak5d6481f2015-10-29 21:44:55 -0500996
997 return;
998}