blob: 159eda243328d03b77cb19a5f3734dad3d3ac143 [file] [log] [blame]
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +01001/*
2// Copyright (c) 2018 Intel Corporation
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15*/
16#pragma once
17
Ed Tanous1abe55e2018-09-05 08:30:59 -070018#include <boost/container/flat_map.hpp>
Ed Tanous4a0cb852018-10-15 07:55:04 -070019#include <boost/container/flat_set.hpp>
Kowalski, Kamil179db1d2018-04-23 11:12:41 +020020#include <dbus_singleton.hpp>
Kowalski, Kamil588c3f02018-04-03 14:55:27 +020021#include <error_messages.hpp>
Kowalski, Kamil179db1d2018-04-23 11:12:41 +020022#include <node.hpp>
Gunnar Mills1214b7e2020-06-04 10:11:30 -050023#include <utils/json_utils.hpp>
24
Ed Tanousa24526d2018-12-10 15:17:59 -080025#include <optional>
Joshi-Mansiab6554f2020-03-10 18:33:36 +053026#include <regex>
Ed Tanousabf2add2019-01-22 16:40:12 -080027#include <variant>
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010028
Ed Tanous1abe55e2018-09-05 08:30:59 -070029namespace redfish
30{
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010031
32/**
33 * DBus types primitives for several generic DBus interfaces
34 * TODO(Pawel) consider move this to separate file into boost::dbus
35 */
Ed Tanousaa2e59c2018-04-12 12:17:20 -070036using PropertiesMapType = boost::container::flat_map<
Ed Tanousabf2add2019-01-22 16:40:12 -080037 std::string, std::variant<std::string, bool, uint8_t, int16_t, uint16_t,
38 int32_t, uint32_t, int64_t, uint64_t, double>>;
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010039
Ed Tanous4a0cb852018-10-15 07:55:04 -070040using GetManagedObjects = std::vector<std::pair<
Ed Tanousaa2e59c2018-04-12 12:17:20 -070041 sdbusplus::message::object_path,
Ed Tanous4a0cb852018-10-15 07:55:04 -070042 std::vector<std::pair<
Ed Tanousaa2e59c2018-04-12 12:17:20 -070043 std::string,
44 boost::container::flat_map<
Patrick Williams19bd78d2020-05-13 17:38:24 -050045 std::string,
46 std::variant<std::string, bool, uint8_t, int16_t, uint16_t, int32_t,
47 uint32_t, int64_t, uint64_t, double,
48 std::vector<std::string>>>>>>>;
Ed Tanous4a0cb852018-10-15 07:55:04 -070049
50enum class LinkType
51{
52 Local,
53 Global
54};
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010055
56/**
57 * Structure for keeping IPv4 data required by Redfish
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010058 */
Ed Tanous1abe55e2018-09-05 08:30:59 -070059struct IPv4AddressData
60{
61 std::string id;
Ed Tanous4a0cb852018-10-15 07:55:04 -070062 std::string address;
63 std::string domain;
64 std::string gateway;
Ed Tanous1abe55e2018-09-05 08:30:59 -070065 std::string netmask;
66 std::string origin;
Ed Tanous4a0cb852018-10-15 07:55:04 -070067 LinkType linktype;
Sunitha Harish01c6e852020-03-20 05:04:09 -050068 bool isActive;
Ed Tanous4a0cb852018-10-15 07:55:04 -070069
Gunnar Mills1214b7e2020-06-04 10:11:30 -050070 bool operator<(const IPv4AddressData& obj) const
Ed Tanous1abe55e2018-09-05 08:30:59 -070071 {
Ed Tanous4a0cb852018-10-15 07:55:04 -070072 return id < obj.id;
Ed Tanous1abe55e2018-09-05 08:30:59 -070073 }
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010074};
75
76/**
Ravi Tejae48c0fc2019-04-16 08:37:20 -050077 * Structure for keeping IPv6 data required by Redfish
78 */
79struct IPv6AddressData
80{
81 std::string id;
82 std::string address;
83 std::string origin;
84 uint8_t prefixLength;
85
Gunnar Mills1214b7e2020-06-04 10:11:30 -050086 bool operator<(const IPv6AddressData& obj) const
Ravi Tejae48c0fc2019-04-16 08:37:20 -050087 {
88 return id < obj.id;
89 }
90};
91/**
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010092 * Structure for keeping basic single Ethernet Interface information
93 * available from DBus
94 */
Ed Tanous1abe55e2018-09-05 08:30:59 -070095struct EthernetInterfaceData
96{
Ed Tanous4a0cb852018-10-15 07:55:04 -070097 uint32_t speed;
98 bool auto_neg;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -070099 bool DNSEnabled;
100 bool NTPEnabled;
101 bool HostNameEnabled;
102 bool SendHostNameEnabled;
Johnathan Manteyaa05fb22020-01-08 12:08:44 -0800103 bool linkUp;
Johnathan Manteyeeedda22019-10-29 16:09:52 -0700104 bool nicEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700105 std::string DHCPEnabled;
106 std::string operatingMode;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700107 std::string hostname;
108 std::string default_gateway;
Ravi Teja9a6fc6f2019-04-16 02:43:13 -0500109 std::string ipv6_default_gateway;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700110 std::string mac_address;
Sunitha Harishfda13ad2019-03-21 11:01:24 -0500111 std::vector<std::uint32_t> vlan_id;
manojkiran.eda@gmail.com0f6efdc2019-10-03 04:53:44 -0500112 std::vector<std::string> nameServers;
113 std::vector<std::string> staticNameServers;
Jennifer Leed24bfc72019-03-05 13:03:37 -0800114 std::vector<std::string> domainnames;
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +0100115};
116
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700117struct DHCPParameters
118{
119 std::optional<bool> dhcpv4Enabled;
120 std::optional<bool> useDNSServers;
121 std::optional<bool> useNTPServers;
122 std::optional<bool> useUseDomainName;
123 std::optional<std::string> dhcpv6OperatingMode;
124};
125
Ed Tanous4a0cb852018-10-15 07:55:04 -0700126// Helper function that changes bits netmask notation (i.e. /24)
127// into full dot notation
128inline std::string getNetmask(unsigned int bits)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700129{
Ed Tanous4a0cb852018-10-15 07:55:04 -0700130 uint32_t value = 0xffffffff << (32 - bits);
131 std::string netmask = std::to_string((value >> 24) & 0xff) + "." +
132 std::to_string((value >> 16) & 0xff) + "." +
133 std::to_string((value >> 8) & 0xff) + "." +
134 std::to_string(value & 0xff);
135 return netmask;
136}
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +0100137
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500138inline bool translateDHCPEnabledToBool(const std::string& inputDHCP,
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700139 bool isIPv4)
140{
141 if (isIPv4)
142 {
143 return (
144 (inputDHCP ==
145 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v4") ||
146 (inputDHCP ==
147 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.both"));
148 }
149 return ((inputDHCP ==
150 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v6") ||
151 (inputDHCP ==
152 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.both"));
153}
154
Ed Tanous2c70f802020-09-28 14:29:23 -0700155inline std::string getDhcpEnabledEnumeration(bool isIPv4, bool isIPv6)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700156{
157 if (isIPv4 && isIPv6)
158 {
159 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.both";
160 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700161 if (isIPv4)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700162 {
163 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v4";
164 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700165 if (isIPv6)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700166 {
167 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v6";
168 }
169 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.none";
170}
171
Ed Tanous4a0cb852018-10-15 07:55:04 -0700172inline std::string
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500173 translateAddressOriginDbusToRedfish(const std::string& inputOrigin,
Ed Tanous4a0cb852018-10-15 07:55:04 -0700174 bool isIPv4)
175{
176 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.Static")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700177 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700178 return "Static";
179 }
180 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.LinkLocal")
181 {
182 if (isIPv4)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700183 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700184 return "IPv4LinkLocal";
185 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700186 return "LinkLocal";
Ed Tanous4a0cb852018-10-15 07:55:04 -0700187 }
188 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.DHCP")
189 {
190 if (isIPv4)
191 {
192 return "DHCP";
193 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700194 return "DHCPv6";
Ed Tanous4a0cb852018-10-15 07:55:04 -0700195 }
196 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.SLAAC")
197 {
198 return "SLAAC";
199 }
200 return "";
201}
202
Ed Tanous81ce6092020-12-17 16:54:55 +0000203inline bool extractEthernetInterfaceData(const std::string& ethifaceId,
204 GetManagedObjects& dbusData,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500205 EthernetInterfaceData& ethData)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700206{
Ed Tanous4c9afe42019-05-03 16:59:57 -0700207 bool idFound = false;
Ed Tanous81ce6092020-12-17 16:54:55 +0000208 for (auto& objpath : dbusData)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700209 {
Ed Tanousf23b7292020-10-15 09:41:17 -0700210 for (auto& ifacePair : objpath.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700211 {
Ed Tanous81ce6092020-12-17 16:54:55 +0000212 if (objpath.first == "/xyz/openbmc_project/network/" + ethifaceId)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700213 {
Ed Tanous4c9afe42019-05-03 16:59:57 -0700214 idFound = true;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700215 if (ifacePair.first == "xyz.openbmc_project.Network.MACAddress")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700216 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500217 for (const auto& propertyPair : ifacePair.second)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700218 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700219 if (propertyPair.first == "MACAddress")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700220 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500221 const std::string* mac =
Ed Tanousabf2add2019-01-22 16:40:12 -0800222 std::get_if<std::string>(&propertyPair.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700223 if (mac != nullptr)
224 {
225 ethData.mac_address = *mac;
226 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700227 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700228 }
229 }
230 else if (ifacePair.first == "xyz.openbmc_project.Network.VLAN")
231 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500232 for (const auto& propertyPair : ifacePair.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700233 {
234 if (propertyPair.first == "Id")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700235 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500236 const uint32_t* id =
Ed Tanousabf2add2019-01-22 16:40:12 -0800237 std::get_if<uint32_t>(&propertyPair.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700238 if (id != nullptr)
239 {
Sunitha Harishfda13ad2019-03-21 11:01:24 -0500240 ethData.vlan_id.push_back(*id);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700241 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700242 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700243 }
244 }
245 else if (ifacePair.first ==
246 "xyz.openbmc_project.Network.EthernetInterface")
247 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500248 for (const auto& propertyPair : ifacePair.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700249 {
250 if (propertyPair.first == "AutoNeg")
251 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700252 const bool* autoNeg =
Ed Tanousabf2add2019-01-22 16:40:12 -0800253 std::get_if<bool>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700254 if (autoNeg != nullptr)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700255 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700256 ethData.auto_neg = *autoNeg;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700257 }
258 }
259 else if (propertyPair.first == "Speed")
260 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500261 const uint32_t* speed =
Ed Tanousabf2add2019-01-22 16:40:12 -0800262 std::get_if<uint32_t>(&propertyPair.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700263 if (speed != nullptr)
264 {
265 ethData.speed = *speed;
266 }
267 }
Johnathan Manteyaa05fb22020-01-08 12:08:44 -0800268 else if (propertyPair.first == "LinkUp")
269 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500270 const bool* linkUp =
Johnathan Manteyaa05fb22020-01-08 12:08:44 -0800271 std::get_if<bool>(&propertyPair.second);
272 if (linkUp != nullptr)
273 {
274 ethData.linkUp = *linkUp;
275 }
276 }
Johnathan Manteyeeedda22019-10-29 16:09:52 -0700277 else if (propertyPair.first == "NICEnabled")
278 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500279 const bool* nicEnabled =
Johnathan Manteyeeedda22019-10-29 16:09:52 -0700280 std::get_if<bool>(&propertyPair.second);
281 if (nicEnabled != nullptr)
282 {
283 ethData.nicEnabled = *nicEnabled;
284 }
285 }
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -0500286 else if (propertyPair.first == "Nameservers")
Ed Tanous4a0cb852018-10-15 07:55:04 -0700287 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500288 const std::vector<std::string>* nameservers =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500289 std::get_if<std::vector<std::string>>(
Ed Tanous029573d2019-02-01 10:57:49 -0800290 &propertyPair.second);
291 if (nameservers != nullptr)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700292 {
Ed Tanousf23b7292020-10-15 09:41:17 -0700293 ethData.nameServers = *nameservers;
manojkiran.eda@gmail.com0f6efdc2019-10-03 04:53:44 -0500294 }
295 }
296 else if (propertyPair.first == "StaticNameServers")
297 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500298 const std::vector<std::string>* staticNameServers =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500299 std::get_if<std::vector<std::string>>(
manojkiran.eda@gmail.com0f6efdc2019-10-03 04:53:44 -0500300 &propertyPair.second);
301 if (staticNameServers != nullptr)
302 {
Ed Tanousf23b7292020-10-15 09:41:17 -0700303 ethData.staticNameServers = *staticNameServers;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700304 }
305 }
manojkiraneda2a133282019-02-19 13:09:43 +0530306 else if (propertyPair.first == "DHCPEnabled")
307 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700308 const std::string* dhcpEnabled =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700309 std::get_if<std::string>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700310 if (dhcpEnabled != nullptr)
manojkiraneda2a133282019-02-19 13:09:43 +0530311 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700312 ethData.DHCPEnabled = *dhcpEnabled;
manojkiraneda2a133282019-02-19 13:09:43 +0530313 }
314 }
Jennifer Leed24bfc72019-03-05 13:03:37 -0800315 else if (propertyPair.first == "DomainName")
316 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500317 const std::vector<std::string>* domainNames =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500318 std::get_if<std::vector<std::string>>(
Jennifer Leed24bfc72019-03-05 13:03:37 -0800319 &propertyPair.second);
320 if (domainNames != nullptr)
321 {
Ed Tanousf23b7292020-10-15 09:41:17 -0700322 ethData.domainnames = *domainNames;
Jennifer Leed24bfc72019-03-05 13:03:37 -0800323 }
324 }
Ed Tanous029573d2019-02-01 10:57:49 -0800325 }
326 }
327 }
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700328
329 if (objpath.first == "/xyz/openbmc_project/network/config/dhcp")
330 {
331 if (ifacePair.first ==
332 "xyz.openbmc_project.Network.DHCPConfiguration")
333 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500334 for (const auto& propertyPair : ifacePair.second)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700335 {
336 if (propertyPair.first == "DNSEnabled")
337 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700338 const bool* dnsEnabled =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700339 std::get_if<bool>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700340 if (dnsEnabled != nullptr)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700341 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700342 ethData.DNSEnabled = *dnsEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700343 }
344 }
345 else if (propertyPair.first == "NTPEnabled")
346 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700347 const bool* ntpEnabled =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700348 std::get_if<bool>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700349 if (ntpEnabled != nullptr)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700350 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700351 ethData.NTPEnabled = *ntpEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700352 }
353 }
354 else if (propertyPair.first == "HostNameEnabled")
355 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700356 const bool* hostNameEnabled =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700357 std::get_if<bool>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700358 if (hostNameEnabled != nullptr)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700359 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700360 ethData.HostNameEnabled = *hostNameEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700361 }
362 }
363 else if (propertyPair.first == "SendHostNameEnabled")
364 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700365 const bool* sendHostNameEnabled =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700366 std::get_if<bool>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700367 if (sendHostNameEnabled != nullptr)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700368 {
369 ethData.SendHostNameEnabled =
Ed Tanous2c70f802020-09-28 14:29:23 -0700370 *sendHostNameEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700371 }
372 }
373 }
374 }
375 }
Ed Tanous029573d2019-02-01 10:57:49 -0800376 // System configuration shows up in the global namespace, so no need
377 // to check eth number
378 if (ifacePair.first ==
379 "xyz.openbmc_project.Network.SystemConfiguration")
380 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500381 for (const auto& propertyPair : ifacePair.second)
Ed Tanous029573d2019-02-01 10:57:49 -0800382 {
383 if (propertyPair.first == "HostName")
384 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500385 const std::string* hostname =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500386 std::get_if<std::string>(&propertyPair.second);
Ed Tanous029573d2019-02-01 10:57:49 -0800387 if (hostname != nullptr)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700388 {
Ed Tanous029573d2019-02-01 10:57:49 -0800389 ethData.hostname = *hostname;
390 }
391 }
392 else if (propertyPair.first == "DefaultGateway")
393 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500394 const std::string* defaultGateway =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500395 std::get_if<std::string>(&propertyPair.second);
Ed Tanous029573d2019-02-01 10:57:49 -0800396 if (defaultGateway != nullptr)
397 {
398 ethData.default_gateway = *defaultGateway;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700399 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700400 }
Ravi Teja9a6fc6f2019-04-16 02:43:13 -0500401 else if (propertyPair.first == "DefaultGateway6")
402 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500403 const std::string* defaultGateway6 =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500404 std::get_if<std::string>(&propertyPair.second);
Ravi Teja9a6fc6f2019-04-16 02:43:13 -0500405 if (defaultGateway6 != nullptr)
406 {
407 ethData.ipv6_default_gateway = *defaultGateway6;
408 }
409 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700410 }
411 }
412 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700413 }
Ed Tanous4c9afe42019-05-03 16:59:57 -0700414 return idFound;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700415}
416
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500417// Helper function that extracts data for single ethernet ipv6 address
Johnathan Mantey01784822019-06-18 12:44:21 -0700418inline void
Ed Tanous81ce6092020-12-17 16:54:55 +0000419 extractIPV6Data(const std::string& ethifaceId,
420 const GetManagedObjects& dbusData,
421 boost::container::flat_set<IPv6AddressData>& ipv6Config)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500422{
423 const std::string ipv6PathStart =
Ed Tanous81ce6092020-12-17 16:54:55 +0000424 "/xyz/openbmc_project/network/" + ethifaceId + "/ipv6/";
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500425
426 // Since there might be several IPv6 configurations aligned with
427 // single ethernet interface, loop over all of them
Ed Tanous81ce6092020-12-17 16:54:55 +0000428 for (const auto& objpath : dbusData)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500429 {
430 // Check if proper pattern for object path appears
431 if (boost::starts_with(objpath.first.str, ipv6PathStart))
432 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500433 for (auto& interface : objpath.second)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500434 {
435 if (interface.first == "xyz.openbmc_project.Network.IP")
436 {
437 // Instance IPv6AddressData structure, and set as
438 // appropriate
439 std::pair<
440 boost::container::flat_set<IPv6AddressData>::iterator,
441 bool>
Ed Tanous81ce6092020-12-17 16:54:55 +0000442 it = ipv6Config.insert(IPv6AddressData{});
Ed Tanous2c70f802020-09-28 14:29:23 -0700443 IPv6AddressData& ipv6Address = *it.first;
444 ipv6Address.id =
Ed Tanous271584a2019-07-09 16:24:22 -0700445 objpath.first.str.substr(ipv6PathStart.size());
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500446 for (auto& property : interface.second)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500447 {
448 if (property.first == "Address")
449 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500450 const std::string* address =
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500451 std::get_if<std::string>(&property.second);
452 if (address != nullptr)
453 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700454 ipv6Address.address = *address;
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500455 }
456 }
457 else if (property.first == "Origin")
458 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500459 const std::string* origin =
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500460 std::get_if<std::string>(&property.second);
461 if (origin != nullptr)
462 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700463 ipv6Address.origin =
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500464 translateAddressOriginDbusToRedfish(*origin,
465 false);
466 }
467 }
468 else if (property.first == "PrefixLength")
469 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500470 const uint8_t* prefix =
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500471 std::get_if<uint8_t>(&property.second);
472 if (prefix != nullptr)
473 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700474 ipv6Address.prefixLength = *prefix;
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500475 }
476 }
477 else
478 {
479 BMCWEB_LOG_ERROR
480 << "Got extra property: " << property.first
481 << " on the " << objpath.first.str << " object";
482 }
483 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500484 }
485 }
486 }
487 }
488}
489
Ed Tanous4a0cb852018-10-15 07:55:04 -0700490// Helper function that extracts data for single ethernet ipv4 address
Johnathan Mantey01784822019-06-18 12:44:21 -0700491inline void
Ed Tanous81ce6092020-12-17 16:54:55 +0000492 extractIPData(const std::string& ethifaceId,
493 const GetManagedObjects& dbusData,
494 boost::container::flat_set<IPv4AddressData>& ipv4Config)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700495{
496 const std::string ipv4PathStart =
Ed Tanous81ce6092020-12-17 16:54:55 +0000497 "/xyz/openbmc_project/network/" + ethifaceId + "/ipv4/";
Ed Tanous4a0cb852018-10-15 07:55:04 -0700498
499 // Since there might be several IPv4 configurations aligned with
500 // single ethernet interface, loop over all of them
Ed Tanous81ce6092020-12-17 16:54:55 +0000501 for (const auto& objpath : dbusData)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700502 {
503 // Check if proper pattern for object path appears
504 if (boost::starts_with(objpath.first.str, ipv4PathStart))
505 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500506 for (auto& interface : objpath.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700507 {
508 if (interface.first == "xyz.openbmc_project.Network.IP")
509 {
510 // Instance IPv4AddressData structure, and set as
511 // appropriate
512 std::pair<
513 boost::container::flat_set<IPv4AddressData>::iterator,
514 bool>
Ed Tanous81ce6092020-12-17 16:54:55 +0000515 it = ipv4Config.insert(IPv4AddressData{});
Ed Tanous2c70f802020-09-28 14:29:23 -0700516 IPv4AddressData& ipv4Address = *it.first;
517 ipv4Address.id =
Ed Tanous271584a2019-07-09 16:24:22 -0700518 objpath.first.str.substr(ipv4PathStart.size());
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500519 for (auto& property : interface.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700520 {
521 if (property.first == "Address")
522 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500523 const std::string* address =
Ed Tanousabf2add2019-01-22 16:40:12 -0800524 std::get_if<std::string>(&property.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700525 if (address != nullptr)
526 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700527 ipv4Address.address = *address;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700528 }
529 }
530 else if (property.first == "Gateway")
531 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500532 const std::string* gateway =
Ed Tanousabf2add2019-01-22 16:40:12 -0800533 std::get_if<std::string>(&property.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700534 if (gateway != nullptr)
535 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700536 ipv4Address.gateway = *gateway;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700537 }
538 }
539 else if (property.first == "Origin")
540 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500541 const std::string* origin =
Ed Tanousabf2add2019-01-22 16:40:12 -0800542 std::get_if<std::string>(&property.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700543 if (origin != nullptr)
544 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700545 ipv4Address.origin =
Ed Tanous4a0cb852018-10-15 07:55:04 -0700546 translateAddressOriginDbusToRedfish(*origin,
547 true);
548 }
549 }
550 else if (property.first == "PrefixLength")
551 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500552 const uint8_t* mask =
Ed Tanousabf2add2019-01-22 16:40:12 -0800553 std::get_if<uint8_t>(&property.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700554 if (mask != nullptr)
555 {
556 // convert it to the string
Ed Tanous2c70f802020-09-28 14:29:23 -0700557 ipv4Address.netmask = getNetmask(*mask);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700558 }
559 }
560 else
561 {
562 BMCWEB_LOG_ERROR
563 << "Got extra property: " << property.first
564 << " on the " << objpath.first.str << " object";
565 }
566 }
567 // Check if given address is local, or global
Ed Tanous2c70f802020-09-28 14:29:23 -0700568 ipv4Address.linktype =
569 boost::starts_with(ipv4Address.address, "169.254.")
Johnathan Mantey18659d12019-06-07 10:26:29 -0700570 ? LinkType::Local
571 : LinkType::Global;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700572 }
573 }
574 }
575 }
576}
577
578/**
579 * @brief Sets given Id on the given VLAN interface through D-Bus
580 *
581 * @param[in] ifaceId Id of VLAN interface that should be modified
582 * @param[in] inputVlanId New ID of the VLAN
583 * @param[in] callback Function that will be called after the operation
584 *
585 * @return None.
586 */
587template <typename CallbackFunc>
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500588void changeVlanId(const std::string& ifaceId, const uint32_t& inputVlanId,
589 CallbackFunc&& callback)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700590{
591 crow::connections::systemBus->async_method_call(
592 callback, "xyz.openbmc_project.Network",
593 std::string("/xyz/openbmc_project/network/") + ifaceId,
594 "org.freedesktop.DBus.Properties", "Set",
595 "xyz.openbmc_project.Network.VLAN", "Id",
Ed Tanousabf2add2019-01-22 16:40:12 -0800596 std::variant<uint32_t>(inputVlanId));
Ed Tanous4a0cb852018-10-15 07:55:04 -0700597}
598
599/**
600 * @brief Helper function that verifies IP address to check if it is in
601 * proper format. If bits pointer is provided, also calculates active
602 * bit count for Subnet Mask.
603 *
604 * @param[in] ip IP that will be verified
605 * @param[out] bits Calculated mask in bits notation
606 *
607 * @return true in case of success, false otherwise
608 */
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500609inline bool ipv4VerifyIpAndGetBitcount(const std::string& ip,
610 uint8_t* bits = nullptr)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700611{
612 std::vector<std::string> bytesInMask;
613
614 boost::split(bytesInMask, ip, boost::is_any_of("."));
Ed Tanous1abe55e2018-09-05 08:30:59 -0700615
616 static const constexpr int ipV4AddressSectionsCount = 4;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700617 if (bytesInMask.size() != ipV4AddressSectionsCount)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700618 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700619 return false;
620 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700621
Ed Tanous4a0cb852018-10-15 07:55:04 -0700622 if (bits != nullptr)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700623 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700624 *bits = 0;
625 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700626
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500627 char* endPtr;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700628 long previousValue = 255;
629 bool firstZeroInByteHit;
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500630 for (const std::string& byte : bytesInMask)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700631 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700632 if (byte.empty())
633 {
634 return false;
635 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700636
Ed Tanous4a0cb852018-10-15 07:55:04 -0700637 // Use strtol instead of stroi to avoid exceptions
638 long value = std::strtol(byte.c_str(), &endPtr, 10);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700639
Ed Tanous4a0cb852018-10-15 07:55:04 -0700640 // endPtr should point to the end of the string, otherwise given string
641 // is not 100% number
642 if (*endPtr != '\0')
643 {
644 return false;
645 }
646
647 // Value should be contained in byte
648 if (value < 0 || value > 255)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700649 {
650 return false;
651 }
652
653 if (bits != nullptr)
654 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700655 // Mask has to be continuous between bytes
656 if (previousValue != 255 && value != 0)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700657 {
658 return false;
659 }
660
Ed Tanous4a0cb852018-10-15 07:55:04 -0700661 // Mask has to be continuous inside bytes
662 firstZeroInByteHit = false;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700663
Ed Tanous4a0cb852018-10-15 07:55:04 -0700664 // Count bits
Ed Tanous23a21a12020-07-25 04:45:05 +0000665 for (long bitIdx = 7; bitIdx >= 0; bitIdx--)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700666 {
Ed Tanous23a21a12020-07-25 04:45:05 +0000667 if (value & (1L << bitIdx))
Ed Tanous1abe55e2018-09-05 08:30:59 -0700668 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700669 if (firstZeroInByteHit)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700670 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700671 // Continuity not preserved
672 return false;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700673 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700674 (*bits)++;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700675 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700676 else
677 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700678 firstZeroInByteHit = true;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700679 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700680 }
681 }
682
683 previousValue = value;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700684 }
685
Ed Tanous4a0cb852018-10-15 07:55:04 -0700686 return true;
687}
688
689/**
Johnathan Mantey01784822019-06-18 12:44:21 -0700690 * @brief Deletes given IPv4 interface
Ed Tanous4a0cb852018-10-15 07:55:04 -0700691 *
692 * @param[in] ifaceId Id of interface whose IP should be deleted
Ed Tanous4a0cb852018-10-15 07:55:04 -0700693 * @param[in] ipHash DBus Hash id of IP that should be deleted
694 * @param[io] asyncResp Response object that will be returned to client
695 *
696 * @return None
697 */
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500698inline void deleteIPv4(const std::string& ifaceId, const std::string& ipHash,
Ed Tanousb5a76932020-09-29 16:16:58 -0700699 const std::shared_ptr<AsyncResp>& asyncResp)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700700{
701 crow::connections::systemBus->async_method_call(
Johnathan Mantey286b9112019-06-10 13:38:04 -0700702 [asyncResp](const boost::system::error_code ec) {
Ed Tanous1abe55e2018-09-05 08:30:59 -0700703 if (ec)
704 {
Jason M. Billsa08b46c2018-11-06 15:01:08 -0800705 messages::internalError(asyncResp->res);
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +0100706 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700707 },
708 "xyz.openbmc_project.Network",
709 "/xyz/openbmc_project/network/" + ifaceId + "/ipv4/" + ipHash,
710 "xyz.openbmc_project.Object.Delete", "Delete");
711}
Ed Tanous1abe55e2018-09-05 08:30:59 -0700712
Ed Tanous4a0cb852018-10-15 07:55:04 -0700713/**
Johnathan Mantey01784822019-06-18 12:44:21 -0700714 * @brief Creates a static IPv4 entry
Ed Tanous4a0cb852018-10-15 07:55:04 -0700715 *
Johnathan Mantey01784822019-06-18 12:44:21 -0700716 * @param[in] ifaceId Id of interface upon which to create the IPv4 entry
717 * @param[in] prefixLength IPv4 prefix syntax for the subnet mask
718 * @param[in] gateway IPv4 address of this interfaces gateway
719 * @param[in] address IPv4 address to assign to this interface
720 * @param[io] asyncResp Response object that will be returned to client
Ed Tanous4a0cb852018-10-15 07:55:04 -0700721 *
722 * @return None
723 */
Ed Tanouscb13a392020-07-25 19:02:03 +0000724inline void createIPv4(const std::string& ifaceId, uint8_t prefixLength,
725 const std::string& gateway, const std::string& address,
Ed Tanousb5a76932020-09-29 16:16:58 -0700726 const std::shared_ptr<AsyncResp>& asyncResp)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700727{
Ed Tanous4a0cb852018-10-15 07:55:04 -0700728 crow::connections::systemBus->async_method_call(
Johnathan Mantey01784822019-06-18 12:44:21 -0700729 [asyncResp](const boost::system::error_code ec) {
730 if (ec)
731 {
732 messages::internalError(asyncResp->res);
733 }
734 },
735 "xyz.openbmc_project.Network",
Ed Tanous4a0cb852018-10-15 07:55:04 -0700736 "/xyz/openbmc_project/network/" + ifaceId,
737 "xyz.openbmc_project.Network.IP.Create", "IP",
Johnathan Mantey01784822019-06-18 12:44:21 -0700738 "xyz.openbmc_project.Network.IP.Protocol.IPv4", address, prefixLength,
Ed Tanous4a0cb852018-10-15 07:55:04 -0700739 gateway);
740}
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500741
742/**
Johnathan Mantey01784822019-06-18 12:44:21 -0700743 * @brief Deletes the IPv4 entry for this interface and creates a replacement
744 * static IPv4 entry
745 *
746 * @param[in] ifaceId Id of interface upon which to create the IPv4 entry
747 * @param[in] id The unique hash entry identifying the DBus entry
748 * @param[in] prefixLength IPv4 prefix syntax for the subnet mask
749 * @param[in] gateway IPv4 address of this interfaces gateway
750 * @param[in] address IPv4 address to assign to this interface
751 * @param[io] asyncResp Response object that will be returned to client
752 *
753 * @return None
754 */
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500755inline void deleteAndCreateIPv4(const std::string& ifaceId,
756 const std::string& id, uint8_t prefixLength,
757 const std::string& gateway,
758 const std::string& address,
Ed Tanousb5a76932020-09-29 16:16:58 -0700759 const std::shared_ptr<AsyncResp>& asyncResp)
Johnathan Mantey01784822019-06-18 12:44:21 -0700760{
761 crow::connections::systemBus->async_method_call(
762 [asyncResp, ifaceId, address, prefixLength,
763 gateway](const boost::system::error_code ec) {
764 if (ec)
765 {
766 messages::internalError(asyncResp->res);
767 }
768 crow::connections::systemBus->async_method_call(
Ed Tanous23a21a12020-07-25 04:45:05 +0000769 [asyncResp](const boost::system::error_code ec2) {
770 if (ec2)
Johnathan Mantey01784822019-06-18 12:44:21 -0700771 {
772 messages::internalError(asyncResp->res);
773 }
774 },
775 "xyz.openbmc_project.Network",
776 "/xyz/openbmc_project/network/" + ifaceId,
777 "xyz.openbmc_project.Network.IP.Create", "IP",
778 "xyz.openbmc_project.Network.IP.Protocol.IPv4", address,
779 prefixLength, gateway);
780 },
781 "xyz.openbmc_project.Network",
782 +"/xyz/openbmc_project/network/" + ifaceId + "/ipv4/" + id,
783 "xyz.openbmc_project.Object.Delete", "Delete");
784}
785
786/**
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500787 * @brief Deletes given IPv6
788 *
789 * @param[in] ifaceId Id of interface whose IP should be deleted
790 * @param[in] ipHash DBus Hash id of IP that should be deleted
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500791 * @param[io] asyncResp Response object that will be returned to client
792 *
793 * @return None
794 */
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500795inline void deleteIPv6(const std::string& ifaceId, const std::string& ipHash,
Ed Tanousb5a76932020-09-29 16:16:58 -0700796 const std::shared_ptr<AsyncResp>& asyncResp)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500797{
798 crow::connections::systemBus->async_method_call(
Johnathan Mantey286b9112019-06-10 13:38:04 -0700799 [asyncResp](const boost::system::error_code ec) {
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500800 if (ec)
801 {
802 messages::internalError(asyncResp->res);
803 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500804 },
805 "xyz.openbmc_project.Network",
806 "/xyz/openbmc_project/network/" + ifaceId + "/ipv6/" + ipHash,
807 "xyz.openbmc_project.Object.Delete", "Delete");
808}
809
810/**
Johnathan Mantey01784822019-06-18 12:44:21 -0700811 * @brief Deletes the IPv6 entry for this interface and creates a replacement
812 * static IPv6 entry
813 *
814 * @param[in] ifaceId Id of interface upon which to create the IPv6 entry
815 * @param[in] id The unique hash entry identifying the DBus entry
816 * @param[in] prefixLength IPv6 prefix syntax for the subnet mask
817 * @param[in] address IPv6 address to assign to this interface
818 * @param[io] asyncResp Response object that will be returned to client
819 *
820 * @return None
821 */
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500822inline void deleteAndCreateIPv6(const std::string& ifaceId,
823 const std::string& id, uint8_t prefixLength,
824 const std::string& address,
Ed Tanousb5a76932020-09-29 16:16:58 -0700825 const std::shared_ptr<AsyncResp>& asyncResp)
Johnathan Mantey01784822019-06-18 12:44:21 -0700826{
827 crow::connections::systemBus->async_method_call(
828 [asyncResp, ifaceId, address,
829 prefixLength](const boost::system::error_code ec) {
830 if (ec)
831 {
832 messages::internalError(asyncResp->res);
833 }
834 crow::connections::systemBus->async_method_call(
Ed Tanous23a21a12020-07-25 04:45:05 +0000835 [asyncResp](const boost::system::error_code ec2) {
836 if (ec2)
Johnathan Mantey01784822019-06-18 12:44:21 -0700837 {
838 messages::internalError(asyncResp->res);
839 }
840 },
841 "xyz.openbmc_project.Network",
842 "/xyz/openbmc_project/network/" + ifaceId,
843 "xyz.openbmc_project.Network.IP.Create", "IP",
844 "xyz.openbmc_project.Network.IP.Protocol.IPv6", address,
845 prefixLength, "");
846 },
847 "xyz.openbmc_project.Network",
848 +"/xyz/openbmc_project/network/" + ifaceId + "/ipv6/" + id,
849 "xyz.openbmc_project.Object.Delete", "Delete");
850}
851
852/**
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500853 * @brief Creates IPv6 with given data
854 *
855 * @param[in] ifaceId Id of interface whose IP should be added
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500856 * @param[in] prefixLength Prefix length that needs to be added
857 * @param[in] address IP address that needs to be added
858 * @param[io] asyncResp Response object that will be returned to client
859 *
860 * @return None
861 */
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500862inline void createIPv6(const std::string& ifaceId, uint8_t prefixLength,
863 const std::string& address,
Ed Tanousb5a76932020-09-29 16:16:58 -0700864 const std::shared_ptr<AsyncResp>& asyncResp)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500865{
866 auto createIpHandler = [asyncResp](const boost::system::error_code ec) {
867 if (ec)
868 {
869 messages::internalError(asyncResp->res);
870 }
871 };
872 // Passing null for gateway, as per redfish spec IPv6StaticAddresses object
Gunnar Mills4e0453b2020-07-08 14:00:30 -0500873 // does not have associated gateway property
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500874 crow::connections::systemBus->async_method_call(
875 std::move(createIpHandler), "xyz.openbmc_project.Network",
876 "/xyz/openbmc_project/network/" + ifaceId,
877 "xyz.openbmc_project.Network.IP.Create", "IP",
878 "xyz.openbmc_project.Network.IP.Protocol.IPv6", address, prefixLength,
879 "");
880}
881
Ed Tanous4a0cb852018-10-15 07:55:04 -0700882/**
883 * Function that retrieves all properties for given Ethernet Interface
884 * Object
885 * from EntityManager Network Manager
886 * @param ethiface_id a eth interface id to query on DBus
887 * @param callback a function that shall be called to convert Dbus output
888 * into JSON
889 */
890template <typename CallbackFunc>
Ed Tanous81ce6092020-12-17 16:54:55 +0000891void getEthernetIfaceData(const std::string& ethifaceId,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500892 CallbackFunc&& callback)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700893{
894 crow::connections::systemBus->async_method_call(
Ed Tanous81ce6092020-12-17 16:54:55 +0000895 [ethifaceId{std::string{ethifaceId}}, callback{std::move(callback)}](
896 const boost::system::error_code errorCode,
Ed Tanousf23b7292020-10-15 09:41:17 -0700897 GetManagedObjects& resp) {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700898 EthernetInterfaceData ethData{};
899 boost::container::flat_set<IPv4AddressData> ipv4Data;
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500900 boost::container::flat_set<IPv6AddressData> ipv6Data;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700901
Ed Tanous81ce6092020-12-17 16:54:55 +0000902 if (errorCode)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700903 {
Johnathan Mantey01784822019-06-18 12:44:21 -0700904 callback(false, ethData, ipv4Data, ipv6Data);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700905 return;
906 }
907
Ed Tanous4c9afe42019-05-03 16:59:57 -0700908 bool found =
Ed Tanous2c70f802020-09-28 14:29:23 -0700909 extractEthernetInterfaceData(ethifaceId, resp, ethData);
Ed Tanous4c9afe42019-05-03 16:59:57 -0700910 if (!found)
911 {
Johnathan Mantey01784822019-06-18 12:44:21 -0700912 callback(false, ethData, ipv4Data, ipv6Data);
Ed Tanous4c9afe42019-05-03 16:59:57 -0700913 return;
914 }
915
Ed Tanous2c70f802020-09-28 14:29:23 -0700916 extractIPData(ethifaceId, resp, ipv4Data);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700917 // Fix global GW
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500918 for (IPv4AddressData& ipv4 : ipv4Data)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700919 {
Ravi Tejac6191412019-07-30 00:53:50 -0500920 if (((ipv4.linktype == LinkType::Global) &&
921 (ipv4.gateway == "0.0.0.0")) ||
922 (ipv4.origin == "DHCP"))
Ed Tanous1abe55e2018-09-05 08:30:59 -0700923 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700924 ipv4.gateway = ethData.default_gateway;
925 }
926 }
927
Ed Tanous2c70f802020-09-28 14:29:23 -0700928 extractIPV6Data(ethifaceId, resp, ipv6Data);
Gunnar Mills4e0453b2020-07-08 14:00:30 -0500929 // Finally make a callback with useful data
Johnathan Mantey01784822019-06-18 12:44:21 -0700930 callback(true, ethData, ipv4Data, ipv6Data);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700931 },
932 "xyz.openbmc_project.Network", "/xyz/openbmc_project/network",
933 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
Ed Tanous271584a2019-07-09 16:24:22 -0700934}
Ed Tanous4a0cb852018-10-15 07:55:04 -0700935
936/**
937 * Function that retrieves all Ethernet Interfaces available through Network
938 * Manager
939 * @param callback a function that shall be called to convert Dbus output
940 * into JSON.
941 */
942template <typename CallbackFunc>
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500943void getEthernetIfaceList(CallbackFunc&& callback)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700944{
945 crow::connections::systemBus->async_method_call(
946 [callback{std::move(callback)}](
Ed Tanous81ce6092020-12-17 16:54:55 +0000947 const boost::system::error_code errorCode,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500948 GetManagedObjects& resp) {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700949 // Callback requires vector<string> to retrieve all available
950 // ethernet interfaces
Ed Tanous2c70f802020-09-28 14:29:23 -0700951 boost::container::flat_set<std::string> ifaceList;
952 ifaceList.reserve(resp.size());
Ed Tanous81ce6092020-12-17 16:54:55 +0000953 if (errorCode)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700954 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700955 callback(false, ifaceList);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700956 return;
957 }
958
959 // Iterate over all retrieved ObjectPaths.
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500960 for (const auto& objpath : resp)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700961 {
962 // And all interfaces available for certain ObjectPath.
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500963 for (const auto& interface : objpath.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700964 {
965 // If interface is
966 // xyz.openbmc_project.Network.EthernetInterface, this is
967 // what we're looking for.
968 if (interface.first ==
969 "xyz.openbmc_project.Network.EthernetInterface")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700970 {
Ed Tanous2dfd18e2020-12-18 00:41:31 +0000971 std::string ifaceId = objpath.first.filename();
972 if (ifaceId.empty())
Ed Tanous1abe55e2018-09-05 08:30:59 -0700973 {
Ed Tanous2dfd18e2020-12-18 00:41:31 +0000974 continue;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700975 }
Ed Tanous2dfd18e2020-12-18 00:41:31 +0000976 // and put it into output vector.
977 ifaceList.emplace(ifaceId);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700978 }
979 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700980 }
981 // Finally make a callback with useful data
Ed Tanous2c70f802020-09-28 14:29:23 -0700982 callback(true, ifaceList);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700983 },
984 "xyz.openbmc_project.Network", "/xyz/openbmc_project/network",
985 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
Ed Tanous271584a2019-07-09 16:24:22 -0700986}
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +0100987
988/**
989 * EthernetCollection derived class for delivering Ethernet Collection Schema
990 */
Ed Tanous1abe55e2018-09-05 08:30:59 -0700991class EthernetCollection : public Node
992{
993 public:
Ed Tanous52cc1122020-07-18 13:51:21 -0700994 EthernetCollection(App& app) :
Ed Tanous4a0cb852018-10-15 07:55:04 -0700995 Node(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700996 {
Ed Tanous1abe55e2018-09-05 08:30:59 -0700997 entityPrivileges = {
998 {boost::beast::http::verb::get, {{"Login"}}},
999 {boost::beast::http::verb::head, {{"Login"}}},
1000 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
1001 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
1002 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
1003 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
1004 }
1005
1006 private:
1007 /**
1008 * Functions triggers appropriate requests on DBus
1009 */
Ed Tanouscb13a392020-07-25 19:02:03 +00001010 void doGet(crow::Response& res, const crow::Request&,
1011 const std::vector<std::string>&) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07001012 {
Ed Tanous0f74e642018-11-12 15:17:05 -08001013 res.jsonValue["@odata.type"] =
1014 "#EthernetInterfaceCollection.EthernetInterfaceCollection";
Ed Tanous0f74e642018-11-12 15:17:05 -08001015 res.jsonValue["@odata.id"] =
1016 "/redfish/v1/Managers/bmc/EthernetInterfaces";
1017 res.jsonValue["Name"] = "Ethernet Network Interface Collection";
1018 res.jsonValue["Description"] =
1019 "Collection of EthernetInterfaces for this Manager";
Ed Tanous4c9afe42019-05-03 16:59:57 -07001020 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous4a0cb852018-10-15 07:55:04 -07001021 // Get eth interface list, and call the below callback for JSON
Ed Tanous1abe55e2018-09-05 08:30:59 -07001022 // preparation
Jason M. Billsf12894f2018-10-09 12:45:45 -07001023 getEthernetIfaceList(
Ed Tanous4c9afe42019-05-03 16:59:57 -07001024 [asyncResp](
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001025 const bool& success,
Ed Tanous81ce6092020-12-17 16:54:55 +00001026 const boost::container::flat_set<std::string>& ifaceList) {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001027 if (!success)
1028 {
Ed Tanous4c9afe42019-05-03 16:59:57 -07001029 messages::internalError(asyncResp->res);
Jason M. Billsf12894f2018-10-09 12:45:45 -07001030 return;
1031 }
1032
Ed Tanous2c70f802020-09-28 14:29:23 -07001033 nlohmann::json& ifaceArray =
Ed Tanous4c9afe42019-05-03 16:59:57 -07001034 asyncResp->res.jsonValue["Members"];
Ed Tanous2c70f802020-09-28 14:29:23 -07001035 ifaceArray = nlohmann::json::array();
Sunitha Harishfda13ad2019-03-21 11:01:24 -05001036 std::string tag = "_";
Ed Tanous81ce6092020-12-17 16:54:55 +00001037 for (const std::string& ifaceItem : ifaceList)
Jason M. Billsf12894f2018-10-09 12:45:45 -07001038 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001039 std::size_t found = ifaceItem.find(tag);
Sunitha Harishfda13ad2019-03-21 11:01:24 -05001040 if (found == std::string::npos)
1041 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001042 ifaceArray.push_back(
Sunitha Harishfda13ad2019-03-21 11:01:24 -05001043 {{"@odata.id",
1044 "/redfish/v1/Managers/bmc/EthernetInterfaces/" +
Ed Tanous2c70f802020-09-28 14:29:23 -07001045 ifaceItem}});
Sunitha Harishfda13ad2019-03-21 11:01:24 -05001046 }
Jason M. Billsf12894f2018-10-09 12:45:45 -07001047 }
1048
Ed Tanous4c9afe42019-05-03 16:59:57 -07001049 asyncResp->res.jsonValue["Members@odata.count"] =
Ed Tanous2c70f802020-09-28 14:29:23 -07001050 ifaceArray.size();
Ed Tanous4c9afe42019-05-03 16:59:57 -07001051 asyncResp->res.jsonValue["@odata.id"] =
Jason M. Billsf12894f2018-10-09 12:45:45 -07001052 "/redfish/v1/Managers/bmc/EthernetInterfaces";
Jason M. Billsf12894f2018-10-09 12:45:45 -07001053 });
Ed Tanous4a0cb852018-10-15 07:55:04 -07001054 }
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +01001055};
1056
1057/**
1058 * EthernetInterface derived class for delivering Ethernet Schema
1059 */
Ed Tanous1abe55e2018-09-05 08:30:59 -07001060class EthernetInterface : public Node
1061{
1062 public:
1063 /*
1064 * Default Constructor
1065 */
Ed Tanous52cc1122020-07-18 13:51:21 -07001066 EthernetInterface(App& app) :
Ed Tanous4a0cb852018-10-15 07:55:04 -07001067 Node(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/",
Ed Tanous1abe55e2018-09-05 08:30:59 -07001068 std::string())
1069 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001070 entityPrivileges = {
1071 {boost::beast::http::verb::get, {{"Login"}}},
1072 {boost::beast::http::verb::head, {{"Login"}}},
1073 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
1074 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
1075 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
1076 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
Kowalski, Kamil588c3f02018-04-03 14:55:27 +02001077 }
1078
Ed Tanous1abe55e2018-09-05 08:30:59 -07001079 private:
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001080 void handleHostnamePatch(const std::string& hostname,
Ed Tanousb5a76932020-09-29 16:16:58 -07001081 const std::shared_ptr<AsyncResp>& asyncResp)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001082 {
Joshi-Mansiab6554f2020-03-10 18:33:36 +05301083 // SHOULD handle host names of up to 255 characters(RFC 1123)
1084 if (hostname.length() > 255)
1085 {
1086 messages::propertyValueFormatError(asyncResp->res, hostname,
1087 "HostName");
1088 return;
1089 }
Ed Tanousbc0bd6e2018-12-10 14:07:55 -08001090 crow::connections::systemBus->async_method_call(
1091 [asyncResp](const boost::system::error_code ec) {
1092 if (ec)
1093 {
1094 messages::internalError(asyncResp->res);
1095 }
1096 },
1097 "xyz.openbmc_project.Network",
1098 "/xyz/openbmc_project/network/config",
1099 "org.freedesktop.DBus.Properties", "Set",
1100 "xyz.openbmc_project.Network.SystemConfiguration", "HostName",
Ed Tanousabf2add2019-01-22 16:40:12 -08001101 std::variant<std::string>(hostname));
Ed Tanous1abe55e2018-09-05 08:30:59 -07001102 }
1103
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001104 void handleDomainnamePatch(const std::string& ifaceId,
1105 const std::string& domainname,
Ed Tanousb5a76932020-09-29 16:16:58 -07001106 const std::shared_ptr<AsyncResp>& asyncResp)
Joshi-Mansiab6554f2020-03-10 18:33:36 +05301107 {
1108 std::vector<std::string> vectorDomainname = {domainname};
1109 crow::connections::systemBus->async_method_call(
1110 [asyncResp](const boost::system::error_code ec) {
1111 if (ec)
1112 {
1113 messages::internalError(asyncResp->res);
1114 }
1115 },
1116 "xyz.openbmc_project.Network",
1117 "/xyz/openbmc_project/network/" + ifaceId,
1118 "org.freedesktop.DBus.Properties", "Set",
1119 "xyz.openbmc_project.Network.EthernetInterface", "DomainName",
1120 std::variant<std::vector<std::string>>(vectorDomainname));
1121 }
1122
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001123 void handleFqdnPatch(const std::string& ifaceId, const std::string& fqdn,
Ed Tanousb5a76932020-09-29 16:16:58 -07001124 const std::shared_ptr<AsyncResp>& asyncResp)
Joshi-Mansiab6554f2020-03-10 18:33:36 +05301125 {
1126 // Total length of FQDN must not exceed 255 characters(RFC 1035)
1127 if (fqdn.length() > 255)
1128 {
1129 messages::propertyValueFormatError(asyncResp->res, fqdn, "FQDN");
1130 return;
1131 }
1132
1133 size_t pos = fqdn.find('.');
1134 if (pos == std::string::npos)
1135 {
1136 messages::propertyValueFormatError(asyncResp->res, fqdn, "FQDN");
1137 return;
1138 }
1139
1140 std::string hostname;
1141 std::string domainname;
1142 domainname = (fqdn).substr(pos + 1);
1143 hostname = (fqdn).substr(0, pos);
1144
1145 if (!isHostnameValid(hostname) || !isDomainnameValid(domainname))
1146 {
1147 messages::propertyValueFormatError(asyncResp->res, fqdn, "FQDN");
1148 return;
1149 }
1150
1151 handleHostnamePatch(hostname, asyncResp);
1152 handleDomainnamePatch(ifaceId, domainname, asyncResp);
1153 }
1154
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001155 bool isHostnameValid(const std::string& hostname)
Joshi-Mansiab6554f2020-03-10 18:33:36 +05301156 {
1157 // A valid host name can never have the dotted-decimal form (RFC 1123)
1158 if (std::all_of(hostname.begin(), hostname.end(), ::isdigit))
1159 {
1160 return false;
1161 }
1162 // Each label(hostname/subdomains) within a valid FQDN
1163 // MUST handle host names of up to 63 characters (RFC 1123)
1164 // labels cannot start or end with hyphens (RFC 952)
1165 // labels can start with numbers (RFC 1123)
1166 const std::regex pattern(
1167 "^[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]{0,61}[a-zA-Z0-9]$");
1168
1169 return std::regex_match(hostname, pattern);
1170 }
1171
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001172 bool isDomainnameValid(const std::string& domainname)
Joshi-Mansiab6554f2020-03-10 18:33:36 +05301173 {
1174 // Can have multiple subdomains
1175 // Top Level Domain's min length is 2 character
1176 const std::regex pattern("^([A-Za-z0-9][a-zA-Z0-9\\-]{1,61}|[a-zA-Z0-9]"
1177 "{1,30}\\.)*[a-zA-Z]{2,}$");
1178
1179 return std::regex_match(domainname, pattern);
1180 }
1181
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001182 void handleMACAddressPatch(const std::string& ifaceId,
1183 const std::string& macAddress,
1184 const std::shared_ptr<AsyncResp>& asyncResp)
Ratan Guptad5776652019-03-03 08:47:22 +05301185 {
1186 crow::connections::systemBus->async_method_call(
1187 [asyncResp, macAddress](const boost::system::error_code ec) {
1188 if (ec)
1189 {
1190 messages::internalError(asyncResp->res);
1191 return;
1192 }
Ratan Guptad5776652019-03-03 08:47:22 +05301193 },
1194 "xyz.openbmc_project.Network",
1195 "/xyz/openbmc_project/network/" + ifaceId,
1196 "org.freedesktop.DBus.Properties", "Set",
1197 "xyz.openbmc_project.Network.MACAddress", "MACAddress",
1198 std::variant<std::string>(macAddress));
1199 }
Johnathan Mantey286b9112019-06-10 13:38:04 -07001200
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001201 void setDHCPEnabled(const std::string& ifaceId,
1202 const std::string& propertyName, const bool v4Value,
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001203 const bool v6Value,
Ed Tanousb5a76932020-09-29 16:16:58 -07001204 const std::shared_ptr<AsyncResp>& asyncResp)
Jennifer Leeda131a92019-04-24 15:13:55 -07001205 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001206 const std::string dhcp = getDhcpEnabledEnumeration(v4Value, v6Value);
Jennifer Leeda131a92019-04-24 15:13:55 -07001207 crow::connections::systemBus->async_method_call(
1208 [asyncResp](const boost::system::error_code ec) {
1209 if (ec)
1210 {
1211 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec;
1212 messages::internalError(asyncResp->res);
1213 return;
1214 }
1215 },
1216 "xyz.openbmc_project.Network",
1217 "/xyz/openbmc_project/network/" + ifaceId,
1218 "org.freedesktop.DBus.Properties", "Set",
1219 "xyz.openbmc_project.Network.EthernetInterface", propertyName,
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001220 std::variant<std::string>{dhcp});
Jennifer Leeda131a92019-04-24 15:13:55 -07001221 }
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001222
Johnathan Manteyeeedda22019-10-29 16:09:52 -07001223 void setEthernetInterfaceBoolProperty(
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001224 const std::string& ifaceId, const std::string& propertyName,
Ed Tanousb5a76932020-09-29 16:16:58 -07001225 const bool& value, const std::shared_ptr<AsyncResp>& asyncResp)
Johnathan Manteyeeedda22019-10-29 16:09:52 -07001226 {
1227 crow::connections::systemBus->async_method_call(
1228 [asyncResp](const boost::system::error_code ec) {
1229 if (ec)
1230 {
1231 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec;
1232 messages::internalError(asyncResp->res);
1233 return;
1234 }
1235 },
1236 "xyz.openbmc_project.Network",
1237 "/xyz/openbmc_project/network/" + ifaceId,
1238 "org.freedesktop.DBus.Properties", "Set",
1239 "xyz.openbmc_project.Network.EthernetInterface", propertyName,
1240 std::variant<bool>{value});
1241 }
1242
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001243 void setDHCPv4Config(const std::string& propertyName, const bool& value,
Ed Tanousb5a76932020-09-29 16:16:58 -07001244 const std::shared_ptr<AsyncResp>& asyncResp)
Jennifer Leeda131a92019-04-24 15:13:55 -07001245 {
1246 BMCWEB_LOG_DEBUG << propertyName << " = " << value;
1247 crow::connections::systemBus->async_method_call(
1248 [asyncResp](const boost::system::error_code ec) {
1249 if (ec)
1250 {
1251 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec;
1252 messages::internalError(asyncResp->res);
1253 return;
1254 }
1255 },
1256 "xyz.openbmc_project.Network",
1257 "/xyz/openbmc_project/network/config/dhcp",
1258 "org.freedesktop.DBus.Properties", "Set",
1259 "xyz.openbmc_project.Network.DHCPConfiguration", propertyName,
1260 std::variant<bool>{value});
1261 }
Ratan Guptad5776652019-03-03 08:47:22 +05301262
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001263 void handleDHCPPatch(const std::string& ifaceId,
1264 const EthernetInterfaceData& ethData,
Ed Tanousf23b7292020-10-15 09:41:17 -07001265 const DHCPParameters& v4dhcpParms,
1266 const DHCPParameters& v6dhcpParms,
Ed Tanousb5a76932020-09-29 16:16:58 -07001267 const std::shared_ptr<AsyncResp>& asyncResp)
Jennifer Leeda131a92019-04-24 15:13:55 -07001268 {
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001269 bool ipv4Active = translateDHCPEnabledToBool(ethData.DHCPEnabled, true);
1270 bool ipv6Active =
1271 translateDHCPEnabledToBool(ethData.DHCPEnabled, false);
Jennifer Leeda131a92019-04-24 15:13:55 -07001272
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001273 bool nextv4DHCPState =
1274 v4dhcpParms.dhcpv4Enabled ? *v4dhcpParms.dhcpv4Enabled : ipv4Active;
1275
1276 bool nextv6DHCPState{};
1277 if (v6dhcpParms.dhcpv6OperatingMode)
Jennifer Leeda131a92019-04-24 15:13:55 -07001278 {
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001279 if ((*v6dhcpParms.dhcpv6OperatingMode != "Stateful") &&
1280 (*v6dhcpParms.dhcpv6OperatingMode != "Stateless") &&
1281 (*v6dhcpParms.dhcpv6OperatingMode != "Disabled"))
1282 {
1283 messages::propertyValueFormatError(
1284 asyncResp->res, *v6dhcpParms.dhcpv6OperatingMode,
1285 "OperatingMode");
1286 return;
1287 }
1288 nextv6DHCPState = (*v6dhcpParms.dhcpv6OperatingMode == "Stateful");
1289 }
1290 else
1291 {
1292 nextv6DHCPState = ipv6Active;
Jennifer Leeda131a92019-04-24 15:13:55 -07001293 }
1294
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001295 bool nextDNS{};
1296 if (v4dhcpParms.useDNSServers && v6dhcpParms.useDNSServers)
Jennifer Leeda131a92019-04-24 15:13:55 -07001297 {
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001298 if (*v4dhcpParms.useDNSServers != *v6dhcpParms.useDNSServers)
1299 {
1300 messages::generalError(asyncResp->res);
1301 return;
1302 }
1303 nextDNS = *v4dhcpParms.useDNSServers;
1304 }
1305 else if (v4dhcpParms.useDNSServers)
1306 {
1307 nextDNS = *v4dhcpParms.useDNSServers;
1308 }
1309 else if (v6dhcpParms.useDNSServers)
1310 {
1311 nextDNS = *v6dhcpParms.useDNSServers;
1312 }
1313 else
1314 {
1315 nextDNS = ethData.DNSEnabled;
Jennifer Leeda131a92019-04-24 15:13:55 -07001316 }
1317
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001318 bool nextNTP{};
1319 if (v4dhcpParms.useNTPServers && v6dhcpParms.useNTPServers)
Jennifer Leeda131a92019-04-24 15:13:55 -07001320 {
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001321 if (*v4dhcpParms.useNTPServers != *v6dhcpParms.useNTPServers)
1322 {
1323 messages::generalError(asyncResp->res);
1324 return;
1325 }
1326 nextNTP = *v4dhcpParms.useNTPServers;
1327 }
1328 else if (v4dhcpParms.useNTPServers)
1329 {
1330 nextNTP = *v4dhcpParms.useNTPServers;
1331 }
1332 else if (v6dhcpParms.useNTPServers)
1333 {
1334 nextNTP = *v6dhcpParms.useNTPServers;
1335 }
1336 else
1337 {
1338 nextNTP = ethData.NTPEnabled;
Jennifer Leeda131a92019-04-24 15:13:55 -07001339 }
1340
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001341 bool nextUseDomain{};
1342 if (v4dhcpParms.useUseDomainName && v6dhcpParms.useUseDomainName)
Jennifer Leeda131a92019-04-24 15:13:55 -07001343 {
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001344 if (*v4dhcpParms.useUseDomainName != *v6dhcpParms.useUseDomainName)
1345 {
1346 messages::generalError(asyncResp->res);
1347 return;
1348 }
1349 nextUseDomain = *v4dhcpParms.useUseDomainName;
1350 }
1351 else if (v4dhcpParms.useUseDomainName)
1352 {
1353 nextUseDomain = *v4dhcpParms.useUseDomainName;
1354 }
1355 else if (v6dhcpParms.useUseDomainName)
1356 {
1357 nextUseDomain = *v6dhcpParms.useUseDomainName;
1358 }
1359 else
1360 {
1361 nextUseDomain = ethData.HostNameEnabled;
Jennifer Leeda131a92019-04-24 15:13:55 -07001362 }
1363
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001364 BMCWEB_LOG_DEBUG << "set DHCPEnabled...";
1365 setDHCPEnabled(ifaceId, "DHCPEnabled", nextv4DHCPState, nextv6DHCPState,
1366 asyncResp);
1367 BMCWEB_LOG_DEBUG << "set DNSEnabled...";
1368 setDHCPv4Config("DNSEnabled", nextDNS, asyncResp);
1369 BMCWEB_LOG_DEBUG << "set NTPEnabled...";
1370 setDHCPv4Config("NTPEnabled", nextNTP, asyncResp);
1371 BMCWEB_LOG_DEBUG << "set HostNameEnabled...";
1372 setDHCPv4Config("HostNameEnabled", nextUseDomain, asyncResp);
Jennifer Leeda131a92019-04-24 15:13:55 -07001373 }
Johnathan Mantey01784822019-06-18 12:44:21 -07001374
1375 boost::container::flat_set<IPv4AddressData>::const_iterator
Ed Tanous2c70f802020-09-28 14:29:23 -07001376 getNextStaticIpEntry(
Manojkiran Eda17a897d2020-09-12 15:31:58 +05301377 const boost::container::flat_set<IPv4AddressData>::const_iterator&
1378 head,
Ed Tanousb5a76932020-09-29 16:16:58 -07001379 const boost::container::flat_set<IPv4AddressData>::const_iterator&
1380 end)
Johnathan Mantey01784822019-06-18 12:44:21 -07001381 {
Manojkiran Eda17a897d2020-09-12 15:31:58 +05301382 return std::find_if(head, end, [](const IPv4AddressData& value) {
1383 return value.origin == "Static";
1384 });
Johnathan Mantey01784822019-06-18 12:44:21 -07001385 }
1386
1387 boost::container::flat_set<IPv6AddressData>::const_iterator
Ed Tanous2c70f802020-09-28 14:29:23 -07001388 getNextStaticIpEntry(
Manojkiran Eda17a897d2020-09-12 15:31:58 +05301389 const boost::container::flat_set<IPv6AddressData>::const_iterator&
1390 head,
Ed Tanousb5a76932020-09-29 16:16:58 -07001391 const boost::container::flat_set<IPv6AddressData>::const_iterator&
1392 end)
Johnathan Mantey01784822019-06-18 12:44:21 -07001393 {
Manojkiran Eda17a897d2020-09-12 15:31:58 +05301394 return std::find_if(head, end, [](const IPv6AddressData& value) {
1395 return value.origin == "Static";
1396 });
Johnathan Mantey01784822019-06-18 12:44:21 -07001397 }
1398
Ravi Tejad1d50812019-06-23 16:20:27 -05001399 void handleIPv4StaticPatch(
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001400 const std::string& ifaceId, nlohmann::json& input,
1401 const boost::container::flat_set<IPv4AddressData>& ipv4Data,
Ed Tanousb5a76932020-09-29 16:16:58 -07001402 const std::shared_ptr<AsyncResp>& asyncResp)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001403 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001404 if ((!input.is_array()) || input.empty())
Ratan Guptaf476acb2019-03-02 16:46:57 +05301405 {
1406 messages::propertyValueTypeError(asyncResp->res, input.dump(),
Ravi Tejad1d50812019-06-23 16:20:27 -05001407 "IPv4StaticAddresses");
Ratan Guptaf476acb2019-03-02 16:46:57 +05301408 return;
1409 }
1410
Ed Tanous271584a2019-07-09 16:24:22 -07001411 unsigned entryIdx = 1;
Johnathan Mantey01784822019-06-18 12:44:21 -07001412 // Find the first static IP address currently active on the NIC and
1413 // match it to the first JSON element in the IPv4StaticAddresses array.
1414 // Match each subsequent JSON element to the next static IP programmed
1415 // into the NIC.
Ed Tanous2c70f802020-09-28 14:29:23 -07001416 boost::container::flat_set<IPv4AddressData>::const_iterator niciPentry =
1417 getNextStaticIpEntry(ipv4Data.cbegin(), ipv4Data.cend());
Johnathan Mantey01784822019-06-18 12:44:21 -07001418
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001419 for (nlohmann::json& thisJson : input)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001420 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001421 std::string pathString =
Ravi Tejad1d50812019-06-23 16:20:27 -05001422 "IPv4StaticAddresses/" + std::to_string(entryIdx);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001423
Johnathan Mantey01784822019-06-18 12:44:21 -07001424 if (!thisJson.is_null() && !thisJson.empty())
Ratan Guptaf476acb2019-03-02 16:46:57 +05301425 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001426 std::optional<std::string> address;
1427 std::optional<std::string> subnetMask;
1428 std::optional<std::string> gateway;
1429
1430 if (!json_util::readJson(thisJson, asyncResp->res, "Address",
1431 address, "SubnetMask", subnetMask,
1432 "Gateway", gateway))
Ratan Guptaf476acb2019-03-02 16:46:57 +05301433 {
1434 messages::propertyValueFormatError(
Johnathan Mantey01784822019-06-18 12:44:21 -07001435 asyncResp->res, thisJson.dump(), pathString);
Ratan Guptaf476acb2019-03-02 16:46:57 +05301436 return;
Ratan Guptaf476acb2019-03-02 16:46:57 +05301437 }
Ratan Guptaf476acb2019-03-02 16:46:57 +05301438
Johnathan Mantey01784822019-06-18 12:44:21 -07001439 // Find the address/subnet/gateway values. Any values that are
1440 // not explicitly provided are assumed to be unmodified from the
1441 // current state of the interface. Merge existing state into the
1442 // current request.
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001443 const std::string* addr = nullptr;
1444 const std::string* gw = nullptr;
Johnathan Mantey01784822019-06-18 12:44:21 -07001445 uint8_t prefixLength = 0;
1446 bool errorInEntry = false;
1447 if (address)
Ratan Gupta9474b372019-03-01 15:13:37 +05301448 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001449 if (ipv4VerifyIpAndGetBitcount(*address))
1450 {
1451 addr = &(*address);
1452 }
1453 else
1454 {
1455 messages::propertyValueFormatError(
1456 asyncResp->res, *address, pathString + "/Address");
1457 errorInEntry = true;
1458 }
1459 }
Ed Tanous2c70f802020-09-28 14:29:23 -07001460 else if (niciPentry != ipv4Data.cend())
Johnathan Mantey01784822019-06-18 12:44:21 -07001461 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001462 addr = &(niciPentry->address);
Ratan Gupta9474b372019-03-01 15:13:37 +05301463 }
1464 else
1465 {
1466 messages::propertyMissing(asyncResp->res,
1467 pathString + "/Address");
Johnathan Mantey01784822019-06-18 12:44:21 -07001468 errorInEntry = true;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001469 }
Ratan Guptaf476acb2019-03-02 16:46:57 +05301470
1471 if (subnetMask)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001472 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001473 if (!ipv4VerifyIpAndGetBitcount(*subnetMask, &prefixLength))
1474 {
1475 messages::propertyValueFormatError(
1476 asyncResp->res, *subnetMask,
1477 pathString + "/SubnetMask");
1478 errorInEntry = true;
1479 }
1480 }
Ed Tanous2c70f802020-09-28 14:29:23 -07001481 else if (niciPentry != ipv4Data.cend())
Johnathan Mantey01784822019-06-18 12:44:21 -07001482 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001483 if (!ipv4VerifyIpAndGetBitcount(niciPentry->netmask,
Johnathan Mantey01784822019-06-18 12:44:21 -07001484 &prefixLength))
1485 {
1486 messages::propertyValueFormatError(
Ed Tanous2c70f802020-09-28 14:29:23 -07001487 asyncResp->res, niciPentry->netmask,
Johnathan Mantey01784822019-06-18 12:44:21 -07001488 pathString + "/SubnetMask");
1489 errorInEntry = true;
1490 }
1491 }
1492 else
1493 {
1494 messages::propertyMissing(asyncResp->res,
1495 pathString + "/SubnetMask");
1496 errorInEntry = true;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001497 }
Ratan Guptaf476acb2019-03-02 16:46:57 +05301498
Ratan Guptaf476acb2019-03-02 16:46:57 +05301499 if (gateway)
1500 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001501 if (ipv4VerifyIpAndGetBitcount(*gateway))
1502 {
1503 gw = &(*gateway);
1504 }
1505 else
1506 {
1507 messages::propertyValueFormatError(
1508 asyncResp->res, *gateway, pathString + "/Gateway");
1509 errorInEntry = true;
1510 }
Ratan Guptaf476acb2019-03-02 16:46:57 +05301511 }
Ed Tanous2c70f802020-09-28 14:29:23 -07001512 else if (niciPentry != ipv4Data.cend())
Johnathan Mantey01784822019-06-18 12:44:21 -07001513 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001514 gw = &niciPentry->gateway;
Johnathan Mantey01784822019-06-18 12:44:21 -07001515 }
1516 else
Ed Tanous4a0cb852018-10-15 07:55:04 -07001517 {
Jason M. Billsa08b46c2018-11-06 15:01:08 -08001518 messages::propertyMissing(asyncResp->res,
Jason M. Billsf12894f2018-10-09 12:45:45 -07001519 pathString + "/Gateway");
Johnathan Mantey01784822019-06-18 12:44:21 -07001520 errorInEntry = true;
Ed Tanous4a0cb852018-10-15 07:55:04 -07001521 }
1522
Johnathan Mantey01784822019-06-18 12:44:21 -07001523 if (errorInEntry)
Ed Tanous4a0cb852018-10-15 07:55:04 -07001524 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001525 return;
Ed Tanous4a0cb852018-10-15 07:55:04 -07001526 }
1527
Ed Tanous2c70f802020-09-28 14:29:23 -07001528 if (niciPentry != ipv4Data.cend())
Ed Tanous4a0cb852018-10-15 07:55:04 -07001529 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001530 deleteAndCreateIPv4(ifaceId, niciPentry->id, prefixLength,
Johnathan Mantey01784822019-06-18 12:44:21 -07001531 *gw, *addr, asyncResp);
Ed Tanous2c70f802020-09-28 14:29:23 -07001532 niciPentry =
1533 getNextStaticIpEntry(++niciPentry, ipv4Data.cend());
Ed Tanous4a0cb852018-10-15 07:55:04 -07001534 }
Johnathan Mantey01784822019-06-18 12:44:21 -07001535 else
1536 {
Ed Tanouscb13a392020-07-25 19:02:03 +00001537 createIPv4(ifaceId, prefixLength, *gateway, *address,
1538 asyncResp);
Johnathan Mantey01784822019-06-18 12:44:21 -07001539 }
1540 entryIdx++;
Ed Tanous4a0cb852018-10-15 07:55:04 -07001541 }
Johnathan Mantey01784822019-06-18 12:44:21 -07001542 else
1543 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001544 if (niciPentry == ipv4Data.cend())
Johnathan Mantey01784822019-06-18 12:44:21 -07001545 {
1546 // Requesting a DELETE/DO NOT MODIFY action for an item
1547 // that isn't present on the eth(n) interface. Input JSON is
1548 // in error, so bail out.
1549 if (thisJson.is_null())
1550 {
1551 messages::resourceCannotBeDeleted(asyncResp->res);
1552 return;
1553 }
Ed Tanous3174e4d2020-10-07 11:41:22 -07001554 messages::propertyValueFormatError(
1555 asyncResp->res, thisJson.dump(), pathString);
1556 return;
Johnathan Mantey01784822019-06-18 12:44:21 -07001557 }
1558
1559 if (thisJson.is_null())
1560 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001561 deleteIPv4(ifaceId, niciPentry->id, asyncResp);
Johnathan Mantey01784822019-06-18 12:44:21 -07001562 }
Ed Tanous2c70f802020-09-28 14:29:23 -07001563 if (niciPentry != ipv4Data.cend())
Johnathan Mantey01784822019-06-18 12:44:21 -07001564 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001565 niciPentry =
1566 getNextStaticIpEntry(++niciPentry, ipv4Data.cend());
Johnathan Mantey01784822019-06-18 12:44:21 -07001567 }
1568 entryIdx++;
1569 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001570 }
1571 }
1572
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05001573 void handleStaticNameServersPatch(
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001574 const std::string& ifaceId,
1575 const std::vector<std::string>& updatedStaticNameServers,
1576 const std::shared_ptr<AsyncResp>& asyncResp)
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05001577 {
1578 crow::connections::systemBus->async_method_call(
Johnathan Mantey286b9112019-06-10 13:38:04 -07001579 [asyncResp](const boost::system::error_code ec) {
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05001580 if (ec)
1581 {
1582 messages::internalError(asyncResp->res);
1583 return;
1584 }
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05001585 },
1586 "xyz.openbmc_project.Network",
1587 "/xyz/openbmc_project/network/" + ifaceId,
1588 "org.freedesktop.DBus.Properties", "Set",
manojkiran.eda@gmail.com0f6efdc2019-10-03 04:53:44 -05001589 "xyz.openbmc_project.Network.EthernetInterface",
1590 "StaticNameServers",
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05001591 std::variant<std::vector<std::string>>{updatedStaticNameServers});
1592 }
1593
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001594 void handleIPv6StaticAddressesPatch(
Ed Tanousf23b7292020-10-15 09:41:17 -07001595 const std::string& ifaceId, const nlohmann::json& input,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001596 const boost::container::flat_set<IPv6AddressData>& ipv6Data,
Ed Tanousb5a76932020-09-29 16:16:58 -07001597 const std::shared_ptr<AsyncResp>& asyncResp)
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001598 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001599 if (!input.is_array() || input.empty())
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001600 {
1601 messages::propertyValueTypeError(asyncResp->res, input.dump(),
1602 "IPv6StaticAddresses");
1603 return;
1604 }
Ed Tanous271584a2019-07-09 16:24:22 -07001605 size_t entryIdx = 1;
Ed Tanous2c70f802020-09-28 14:29:23 -07001606 boost::container::flat_set<IPv6AddressData>::const_iterator niciPentry =
1607 getNextStaticIpEntry(ipv6Data.cbegin(), ipv6Data.cend());
Ed Tanousf23b7292020-10-15 09:41:17 -07001608 for (const nlohmann::json& thisJson : input)
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001609 {
1610 std::string pathString =
1611 "IPv6StaticAddresses/" + std::to_string(entryIdx);
1612
Johnathan Mantey01784822019-06-18 12:44:21 -07001613 if (!thisJson.is_null() && !thisJson.empty())
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001614 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001615 std::optional<std::string> address;
1616 std::optional<uint8_t> prefixLength;
Ed Tanousf23b7292020-10-15 09:41:17 -07001617 nlohmann::json thisJsonCopy = thisJson;
1618 if (!json_util::readJson(thisJsonCopy, asyncResp->res,
1619 "Address", address, "PrefixLength",
1620 prefixLength))
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001621 {
1622 messages::propertyValueFormatError(
Johnathan Mantey01784822019-06-18 12:44:21 -07001623 asyncResp->res, thisJson.dump(), pathString);
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001624 return;
1625 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001626
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001627 const std::string* addr;
Johnathan Mantey01784822019-06-18 12:44:21 -07001628 uint8_t prefix;
1629
1630 // Find the address and prefixLength values. Any values that are
1631 // not explicitly provided are assumed to be unmodified from the
1632 // current state of the interface. Merge existing state into the
1633 // current request.
1634 if (address)
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001635 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001636 addr = &(*address);
1637 }
Ed Tanous2c70f802020-09-28 14:29:23 -07001638 else if (niciPentry != ipv6Data.end())
Johnathan Mantey01784822019-06-18 12:44:21 -07001639 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001640 addr = &(niciPentry->address);
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001641 }
1642 else
1643 {
1644 messages::propertyMissing(asyncResp->res,
1645 pathString + "/Address");
1646 return;
1647 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001648
1649 if (prefixLength)
1650 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001651 prefix = *prefixLength;
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001652 }
Ed Tanous2c70f802020-09-28 14:29:23 -07001653 else if (niciPentry != ipv6Data.end())
Johnathan Mantey01784822019-06-18 12:44:21 -07001654 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001655 prefix = niciPentry->prefixLength;
Johnathan Mantey01784822019-06-18 12:44:21 -07001656 }
1657 else
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001658 {
1659 messages::propertyMissing(asyncResp->res,
1660 pathString + "/PrefixLength");
Johnathan Mantey01784822019-06-18 12:44:21 -07001661 return;
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001662 }
1663
Ed Tanous2c70f802020-09-28 14:29:23 -07001664 if (niciPentry != ipv6Data.end())
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001665 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001666 deleteAndCreateIPv6(ifaceId, niciPentry->id, prefix, *addr,
Johnathan Mantey01784822019-06-18 12:44:21 -07001667 asyncResp);
Ed Tanous2c70f802020-09-28 14:29:23 -07001668 niciPentry =
1669 getNextStaticIpEntry(++niciPentry, ipv6Data.cend());
Johnathan Mantey01784822019-06-18 12:44:21 -07001670 }
1671 else
1672 {
1673 createIPv6(ifaceId, *prefixLength, *addr, asyncResp);
1674 }
1675 entryIdx++;
1676 }
1677 else
1678 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001679 if (niciPentry == ipv6Data.end())
Johnathan Mantey01784822019-06-18 12:44:21 -07001680 {
1681 // Requesting a DELETE/DO NOT MODIFY action for an item
1682 // that isn't present on the eth(n) interface. Input JSON is
1683 // in error, so bail out.
1684 if (thisJson.is_null())
1685 {
1686 messages::resourceCannotBeDeleted(asyncResp->res);
1687 return;
1688 }
Ed Tanous3174e4d2020-10-07 11:41:22 -07001689 messages::propertyValueFormatError(
1690 asyncResp->res, thisJson.dump(), pathString);
1691 return;
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001692 }
1693
Johnathan Mantey01784822019-06-18 12:44:21 -07001694 if (thisJson.is_null())
1695 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001696 deleteIPv6(ifaceId, niciPentry->id, asyncResp);
Johnathan Mantey01784822019-06-18 12:44:21 -07001697 }
Ed Tanous2c70f802020-09-28 14:29:23 -07001698 if (niciPentry != ipv6Data.cend())
Johnathan Mantey01784822019-06-18 12:44:21 -07001699 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001700 niciPentry =
1701 getNextStaticIpEntry(++niciPentry, ipv6Data.cend());
Johnathan Mantey01784822019-06-18 12:44:21 -07001702 }
1703 entryIdx++;
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001704 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001705 }
1706 }
1707
Ed Tanous0f74e642018-11-12 15:17:05 -08001708 void parseInterfaceData(
Ed Tanous81ce6092020-12-17 16:54:55 +00001709 const std::shared_ptr<AsyncResp>& asyncResp, const std::string& ifaceId,
1710 const EthernetInterfaceData& ethData,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001711 const boost::container::flat_set<IPv4AddressData>& ipv4Data,
1712 const boost::container::flat_set<IPv6AddressData>& ipv6Data)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001713 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001714 constexpr const std::array<const char*, 1> inventoryForEthernet = {
Johnathan Manteyeeedda22019-10-29 16:09:52 -07001715 "xyz.openbmc_project.Inventory.Item.Ethernet"};
1716
Ed Tanous2c70f802020-09-28 14:29:23 -07001717 nlohmann::json& jsonResponse = asyncResp->res.jsonValue;
Ed Tanous81ce6092020-12-17 16:54:55 +00001718 jsonResponse["Id"] = ifaceId;
Ed Tanous2c70f802020-09-28 14:29:23 -07001719 jsonResponse["@odata.id"] =
Ed Tanous81ce6092020-12-17 16:54:55 +00001720 "/redfish/v1/Managers/bmc/EthernetInterfaces/" + ifaceId;
Ed Tanous2c70f802020-09-28 14:29:23 -07001721 jsonResponse["InterfaceEnabled"] = ethData.nicEnabled;
Johnathan Manteyeeedda22019-10-29 16:09:52 -07001722
1723 auto health = std::make_shared<HealthPopulate>(asyncResp);
1724
1725 crow::connections::systemBus->async_method_call(
1726 [health](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001727 std::vector<std::string>& resp) {
Johnathan Manteyeeedda22019-10-29 16:09:52 -07001728 if (ec)
1729 {
1730 return;
1731 }
1732
1733 health->inventory = std::move(resp);
1734 },
1735 "xyz.openbmc_project.ObjectMapper",
1736 "/xyz/openbmc_project/object_mapper",
1737 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths", "/",
1738 int32_t(0), inventoryForEthernet);
1739
1740 health->populate();
1741
1742 if (ethData.nicEnabled)
Ed Tanous029573d2019-02-01 10:57:49 -08001743 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001744 jsonResponse["LinkStatus"] = "LinkUp";
1745 jsonResponse["Status"]["State"] = "Enabled";
Ed Tanous029573d2019-02-01 10:57:49 -08001746 }
1747 else
1748 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001749 jsonResponse["LinkStatus"] = "NoLink";
1750 jsonResponse["Status"]["State"] = "Disabled";
Ed Tanous029573d2019-02-01 10:57:49 -08001751 }
Johnathan Manteyaa05fb22020-01-08 12:08:44 -08001752
Ed Tanous2c70f802020-09-28 14:29:23 -07001753 jsonResponse["LinkStatus"] = ethData.linkUp ? "LinkUp" : "LinkDown";
1754 jsonResponse["SpeedMbps"] = ethData.speed;
1755 jsonResponse["MACAddress"] = ethData.mac_address;
1756 jsonResponse["DHCPv4"]["DHCPEnabled"] =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001757 translateDHCPEnabledToBool(ethData.DHCPEnabled, true);
Ed Tanous2c70f802020-09-28 14:29:23 -07001758 jsonResponse["DHCPv4"]["UseNTPServers"] = ethData.NTPEnabled;
1759 jsonResponse["DHCPv4"]["UseDNSServers"] = ethData.DNSEnabled;
1760 jsonResponse["DHCPv4"]["UseDomainName"] = ethData.HostNameEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001761
Ed Tanous2c70f802020-09-28 14:29:23 -07001762 jsonResponse["DHCPv6"]["OperatingMode"] =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001763 translateDHCPEnabledToBool(ethData.DHCPEnabled, false) ? "Stateful"
1764 : "Disabled";
Ed Tanous2c70f802020-09-28 14:29:23 -07001765 jsonResponse["DHCPv6"]["UseNTPServers"] = ethData.NTPEnabled;
1766 jsonResponse["DHCPv6"]["UseDNSServers"] = ethData.DNSEnabled;
1767 jsonResponse["DHCPv6"]["UseDomainName"] = ethData.HostNameEnabled;
manojkiraneda2a133282019-02-19 13:09:43 +05301768
Ed Tanous4a0cb852018-10-15 07:55:04 -07001769 if (!ethData.hostname.empty())
Ed Tanous1abe55e2018-09-05 08:30:59 -07001770 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001771 jsonResponse["HostName"] = ethData.hostname;
Joshi-Mansiab6554f2020-03-10 18:33:36 +05301772
1773 // When domain name is empty then it means, that it is a network
1774 // without domain names, and the host name itself must be treated as
1775 // FQDN
Ed Tanousf23b7292020-10-15 09:41:17 -07001776 std::string fqdn = ethData.hostname;
Jennifer Leed24bfc72019-03-05 13:03:37 -08001777 if (!ethData.domainnames.empty())
1778 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001779 fqdn += "." + ethData.domainnames[0];
Jennifer Leed24bfc72019-03-05 13:03:37 -08001780 }
Ed Tanous2c70f802020-09-28 14:29:23 -07001781 jsonResponse["FQDN"] = fqdn;
Ed Tanous4a0cb852018-10-15 07:55:04 -07001782 }
1783
Ed Tanous2c70f802020-09-28 14:29:23 -07001784 jsonResponse["VLANs"] = {
Sunitha Harishfda13ad2019-03-21 11:01:24 -05001785 {"@odata.id", "/redfish/v1/Managers/bmc/EthernetInterfaces/" +
Ed Tanous81ce6092020-12-17 16:54:55 +00001786 ifaceId + "/VLANs"}};
Sunitha Harishfda13ad2019-03-21 11:01:24 -05001787
Ed Tanous2c70f802020-09-28 14:29:23 -07001788 jsonResponse["NameServers"] = ethData.nameServers;
1789 jsonResponse["StaticNameServers"] = ethData.staticNameServers;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001790
Ed Tanous2c70f802020-09-28 14:29:23 -07001791 nlohmann::json& ipv4Array = jsonResponse["IPv4Addresses"];
1792 nlohmann::json& ipv4StaticArray = jsonResponse["IPv4StaticAddresses"];
1793 ipv4Array = nlohmann::json::array();
1794 ipv4StaticArray = nlohmann::json::array();
1795 for (auto& ipv4Config : ipv4Data)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001796 {
Ravi Tejad1d50812019-06-23 16:20:27 -05001797
Ed Tanous2c70f802020-09-28 14:29:23 -07001798 std::string gatewayStr = ipv4Config.gateway;
Ravi Tejad1d50812019-06-23 16:20:27 -05001799 if (gatewayStr.empty())
Ed Tanous1abe55e2018-09-05 08:30:59 -07001800 {
Ravi Tejad1d50812019-06-23 16:20:27 -05001801 gatewayStr = "0.0.0.0";
Ed Tanous1abe55e2018-09-05 08:30:59 -07001802 }
Ravi Tejad1d50812019-06-23 16:20:27 -05001803
Ed Tanous2c70f802020-09-28 14:29:23 -07001804 ipv4Array.push_back({{"AddressOrigin", ipv4Config.origin},
1805 {"SubnetMask", ipv4Config.netmask},
1806 {"Address", ipv4Config.address},
1807 {"Gateway", gatewayStr}});
1808 if (ipv4Config.origin == "Static")
Ravi Tejad1d50812019-06-23 16:20:27 -05001809 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001810 ipv4StaticArray.push_back({{"AddressOrigin", ipv4Config.origin},
1811 {"SubnetMask", ipv4Config.netmask},
1812 {"Address", ipv4Config.address},
1813 {"Gateway", gatewayStr}});
Ravi Tejad1d50812019-06-23 16:20:27 -05001814 }
Ravi Tejad1d50812019-06-23 16:20:27 -05001815 }
1816
Ed Tanous2c70f802020-09-28 14:29:23 -07001817 jsonResponse["IPv6DefaultGateway"] = ethData.ipv6_default_gateway;
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001818
Ed Tanous2c70f802020-09-28 14:29:23 -07001819 nlohmann::json& ipv6Array = jsonResponse["IPv6Addresses"];
1820 nlohmann::json& ipv6StaticArray = jsonResponse["IPv6StaticAddresses"];
1821 ipv6Array = nlohmann::json::array();
1822 ipv6StaticArray = nlohmann::json::array();
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001823 nlohmann::json& ipv6AddrPolicyTable =
Ed Tanous2c70f802020-09-28 14:29:23 -07001824 jsonResponse["IPv6AddressPolicyTable"];
Johnathan Mantey7f2e23e2020-05-14 13:36:52 -07001825 ipv6AddrPolicyTable = nlohmann::json::array();
Ed Tanous2c70f802020-09-28 14:29:23 -07001826 for (auto& ipv6Config : ipv6Data)
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001827 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001828 ipv6Array.push_back({{"Address", ipv6Config.address},
1829 {"PrefixLength", ipv6Config.prefixLength},
1830 {"AddressOrigin", ipv6Config.origin},
1831 {"AddressState", nullptr}});
1832 if (ipv6Config.origin == "Static")
Johnathan Mantey01784822019-06-18 12:44:21 -07001833 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001834 ipv6StaticArray.push_back(
1835 {{"Address", ipv6Config.address},
1836 {"PrefixLength", ipv6Config.prefixLength},
1837 {"AddressOrigin", ipv6Config.origin},
Johnathan Mantey5fd16e42020-05-13 15:14:47 -07001838 {"AddressState", nullptr}});
Johnathan Mantey01784822019-06-18 12:44:21 -07001839 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001840 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001841 }
1842
1843 /**
1844 * Functions triggers appropriate requests on DBus
1845 */
Ed Tanouscb13a392020-07-25 19:02:03 +00001846 void doGet(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001847 const std::vector<std::string>& params) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07001848 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001849 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001850 if (params.size() != 1)
1851 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001852 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001853 return;
1854 }
1855
Ed Tanous4a0cb852018-10-15 07:55:04 -07001856 getEthernetIfaceData(
1857 params[0],
Ed Tanous2c70f802020-09-28 14:29:23 -07001858 [this, asyncResp, ifaceId{std::string(params[0])}](
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001859 const bool& success, const EthernetInterfaceData& ethData,
1860 const boost::container::flat_set<IPv4AddressData>& ipv4Data,
1861 const boost::container::flat_set<IPv6AddressData>& ipv6Data) {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001862 if (!success)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001863 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001864 // TODO(Pawel)consider distinguish between non existing
1865 // object, and other errors
Jason M. Billsf12894f2018-10-09 12:45:45 -07001866 messages::resourceNotFound(asyncResp->res,
Ed Tanous2c70f802020-09-28 14:29:23 -07001867 "EthernetInterface", ifaceId);
Ed Tanous4a0cb852018-10-15 07:55:04 -07001868 return;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001869 }
Ed Tanous4c9afe42019-05-03 16:59:57 -07001870
Ed Tanous0f74e642018-11-12 15:17:05 -08001871 asyncResp->res.jsonValue["@odata.type"] =
Sunitha Harishfda13ad2019-03-21 11:01:24 -05001872 "#EthernetInterface.v1_4_1.EthernetInterface";
Ed Tanous0f74e642018-11-12 15:17:05 -08001873 asyncResp->res.jsonValue["Name"] = "Manager Ethernet Interface";
1874 asyncResp->res.jsonValue["Description"] =
1875 "Management Network Interface";
1876
Ed Tanous2c70f802020-09-28 14:29:23 -07001877 parseInterfaceData(asyncResp, ifaceId, ethData, ipv4Data,
Johnathan Manteyeeedda22019-10-29 16:09:52 -07001878 ipv6Data);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001879 });
1880 }
1881
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001882 void doPatch(crow::Response& res, const crow::Request& req,
1883 const std::vector<std::string>& params) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07001884 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001885 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001886 if (params.size() != 1)
1887 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001888 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001889 return;
1890 }
1891
Ed Tanous2c70f802020-09-28 14:29:23 -07001892 const std::string& ifaceId = params[0];
Ed Tanous1abe55e2018-09-05 08:30:59 -07001893
Ed Tanousbc0bd6e2018-12-10 14:07:55 -08001894 std::optional<std::string> hostname;
Joshi-Mansiab6554f2020-03-10 18:33:36 +05301895 std::optional<std::string> fqdn;
Ratan Guptad5776652019-03-03 08:47:22 +05301896 std::optional<std::string> macAddress;
Ravi Teja9a6fc6f2019-04-16 02:43:13 -05001897 std::optional<std::string> ipv6DefaultGateway;
Ravi Tejad1d50812019-06-23 16:20:27 -05001898 std::optional<nlohmann::json> ipv4StaticAddresses;
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001899 std::optional<nlohmann::json> ipv6StaticAddresses;
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05001900 std::optional<std::vector<std::string>> staticNameServers;
Jennifer Leeda131a92019-04-24 15:13:55 -07001901 std::optional<nlohmann::json> dhcpv4;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001902 std::optional<nlohmann::json> dhcpv6;
Johnathan Manteyeeedda22019-10-29 16:09:52 -07001903 std::optional<bool> interfaceEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001904 DHCPParameters v4dhcpParms;
1905 DHCPParameters v6dhcpParms;
Ed Tanous0627a2c2018-11-29 17:09:23 -08001906
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001907 if (!json_util::readJson(
Joshi-Mansiab6554f2020-03-10 18:33:36 +05301908 req, res, "HostName", hostname, "FQDN", fqdn,
1909 "IPv4StaticAddresses", ipv4StaticAddresses, "MACAddress",
1910 macAddress, "StaticNameServers", staticNameServers,
1911 "IPv6DefaultGateway", ipv6DefaultGateway, "IPv6StaticAddresses",
1912 ipv6StaticAddresses, "DHCPv4", dhcpv4, "DHCPv6", dhcpv6,
1913 "InterfaceEnabled", interfaceEnabled))
Ed Tanous1abe55e2018-09-05 08:30:59 -07001914 {
1915 return;
1916 }
Jennifer Leeda131a92019-04-24 15:13:55 -07001917 if (dhcpv4)
1918 {
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001919 if (!json_util::readJson(*dhcpv4, res, "DHCPEnabled",
1920 v4dhcpParms.dhcpv4Enabled, "UseDNSServers",
1921 v4dhcpParms.useDNSServers, "UseNTPServers",
1922 v4dhcpParms.useNTPServers, "UseDomainName",
1923 v4dhcpParms.useUseDomainName))
1924 {
1925 return;
1926 }
1927 }
1928
1929 if (dhcpv6)
1930 {
1931 if (!json_util::readJson(*dhcpv6, res, "OperatingMode",
1932 v6dhcpParms.dhcpv6OperatingMode,
1933 "UseDNSServers", v6dhcpParms.useDNSServers,
1934 "UseNTPServers", v6dhcpParms.useNTPServers,
1935 "UseDomainName",
1936 v6dhcpParms.useUseDomainName))
1937 {
1938 return;
1939 }
Jennifer Leeda131a92019-04-24 15:13:55 -07001940 }
1941
Johnathan Mantey01784822019-06-18 12:44:21 -07001942 // Get single eth interface data, and call the below callback for
1943 // JSON preparation
Ed Tanous4a0cb852018-10-15 07:55:04 -07001944 getEthernetIfaceData(
Ed Tanous2c70f802020-09-28 14:29:23 -07001945 ifaceId,
1946 [this, asyncResp, ifaceId, hostname = std::move(hostname),
Joshi-Mansiab6554f2020-03-10 18:33:36 +05301947 fqdn = std::move(fqdn), macAddress = std::move(macAddress),
Ravi Tejad1d50812019-06-23 16:20:27 -05001948 ipv4StaticAddresses = std::move(ipv4StaticAddresses),
Ravi Teja9a6fc6f2019-04-16 02:43:13 -05001949 ipv6DefaultGateway = std::move(ipv6DefaultGateway),
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001950 ipv6StaticAddresses = std::move(ipv6StaticAddresses),
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001951 staticNameServers = std::move(staticNameServers),
1952 dhcpv4 = std::move(dhcpv4), dhcpv6 = std::move(dhcpv6),
1953 v4dhcpParms = std::move(v4dhcpParms),
Ed Tanousf23b7292020-10-15 09:41:17 -07001954 v6dhcpParms = std::move(v6dhcpParms), interfaceEnabled](
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001955 const bool& success, const EthernetInterfaceData& ethData,
1956 const boost::container::flat_set<IPv4AddressData>& ipv4Data,
1957 const boost::container::flat_set<IPv6AddressData>& ipv6Data) {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001958 if (!success)
1959 {
1960 // ... otherwise return error
1961 // TODO(Pawel)consider distinguish between non existing
1962 // object, and other errors
Sunitha Harishfda13ad2019-03-21 11:01:24 -05001963 messages::resourceNotFound(asyncResp->res,
Ed Tanous2c70f802020-09-28 14:29:23 -07001964 "Ethernet Interface", ifaceId);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001965 return;
1966 }
1967
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001968 if (dhcpv4 || dhcpv6)
1969 {
Ed Tanousf23b7292020-10-15 09:41:17 -07001970 handleDHCPPatch(ifaceId, ethData, v4dhcpParms, v6dhcpParms,
1971 asyncResp);
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001972 }
1973
Ed Tanous0627a2c2018-11-29 17:09:23 -08001974 if (hostname)
1975 {
1976 handleHostnamePatch(*hostname, asyncResp);
1977 }
1978
Joshi-Mansiab6554f2020-03-10 18:33:36 +05301979 if (fqdn)
1980 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001981 handleFqdnPatch(ifaceId, *fqdn, asyncResp);
Joshi-Mansiab6554f2020-03-10 18:33:36 +05301982 }
1983
Ratan Guptad5776652019-03-03 08:47:22 +05301984 if (macAddress)
1985 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001986 handleMACAddressPatch(ifaceId, *macAddress, asyncResp);
Ratan Guptad5776652019-03-03 08:47:22 +05301987 }
1988
Ravi Tejad1d50812019-06-23 16:20:27 -05001989 if (ipv4StaticAddresses)
1990 {
Ed Tanous537174c2018-12-10 15:09:31 -08001991 // TODO(ed) for some reason the capture of ipv4Addresses
Johnathan Mantey01784822019-06-18 12:44:21 -07001992 // above is returning a const value, not a non-const
1993 // value. This doesn't really work for us, as we need to
1994 // be able to efficiently move out the intermedia
1995 // nlohmann::json objects. This makes a copy of the
1996 // structure, and operates on that, but could be done
1997 // more efficiently
Ed Tanousf23b7292020-10-15 09:41:17 -07001998 nlohmann::json ipv4Static = *ipv4StaticAddresses;
Ed Tanous2c70f802020-09-28 14:29:23 -07001999 handleIPv4StaticPatch(ifaceId, ipv4Static, ipv4Data,
Ravi Tejad1d50812019-06-23 16:20:27 -05002000 asyncResp);
Ed Tanous0627a2c2018-11-29 17:09:23 -08002001 }
2002
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05002003 if (staticNameServers)
2004 {
Ed Tanous2c70f802020-09-28 14:29:23 -07002005 handleStaticNameServersPatch(ifaceId, *staticNameServers,
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05002006 asyncResp);
2007 }
Ravi Teja9a6fc6f2019-04-16 02:43:13 -05002008
2009 if (ipv6DefaultGateway)
2010 {
2011 messages::propertyNotWritable(asyncResp->res,
2012 "IPv6DefaultGateway");
2013 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002014
2015 if (ipv6StaticAddresses)
2016 {
Ed Tanousf23b7292020-10-15 09:41:17 -07002017 nlohmann::json ipv6Static = *ipv6StaticAddresses;
Ed Tanous2c70f802020-09-28 14:29:23 -07002018 handleIPv6StaticAddressesPatch(ifaceId, ipv6Static,
Johnathan Mantey01784822019-06-18 12:44:21 -07002019 ipv6Data, asyncResp);
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002020 }
Johnathan Manteyeeedda22019-10-29 16:09:52 -07002021
2022 if (interfaceEnabled)
2023 {
2024 setEthernetInterfaceBoolProperty(
Ed Tanous2c70f802020-09-28 14:29:23 -07002025 ifaceId, "NICEnabled", *interfaceEnabled, asyncResp);
Johnathan Manteyeeedda22019-10-29 16:09:52 -07002026 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07002027 });
2028 }
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +01002029};
2030
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002031/**
Ed Tanous4a0cb852018-10-15 07:55:04 -07002032 * VlanNetworkInterface derived class for delivering VLANNetworkInterface
2033 * Schema
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002034 */
Ed Tanous1abe55e2018-09-05 08:30:59 -07002035class VlanNetworkInterface : public Node
2036{
2037 public:
2038 /*
2039 * Default Constructor
2040 */
Ed Tanous52cc1122020-07-18 13:51:21 -07002041 VlanNetworkInterface(App& app) :
Ed Tanous4a0cb852018-10-15 07:55:04 -07002042 Node(app,
Gunnar Mills7af91512020-04-14 22:16:57 -05002043 "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/<str>/",
Ed Tanous4a0cb852018-10-15 07:55:04 -07002044 std::string(), std::string())
Ed Tanous1abe55e2018-09-05 08:30:59 -07002045 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07002046 entityPrivileges = {
2047 {boost::beast::http::verb::get, {{"Login"}}},
2048 {boost::beast::http::verb::head, {{"Login"}}},
2049 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
2050 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
2051 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
2052 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002053 }
2054
Ed Tanous1abe55e2018-09-05 08:30:59 -07002055 private:
Ed Tanous81ce6092020-12-17 16:54:55 +00002056 void parseInterfaceData(nlohmann::json& jsonResponse,
2057 const std::string& parentIfaceId,
2058 const std::string& ifaceId,
Ed Tanouscb13a392020-07-25 19:02:03 +00002059 const EthernetInterfaceData& ethData)
Ed Tanous1abe55e2018-09-05 08:30:59 -07002060 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07002061 // Fill out obvious data...
Ed Tanous81ce6092020-12-17 16:54:55 +00002062 jsonResponse["Id"] = ifaceId;
2063 jsonResponse["@odata.id"] =
2064 "/redfish/v1/Managers/bmc/EthernetInterfaces/" + parentIfaceId +
2065 "/VLANs/" + ifaceId;
Ed Tanous1abe55e2018-09-05 08:30:59 -07002066
Ed Tanous81ce6092020-12-17 16:54:55 +00002067 jsonResponse["VLANEnable"] = true;
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002068 if (!ethData.vlan_id.empty())
Ed Tanous4a0cb852018-10-15 07:55:04 -07002069 {
Ed Tanous81ce6092020-12-17 16:54:55 +00002070 jsonResponse["VLANId"] = ethData.vlan_id.back();
Ed Tanous4a0cb852018-10-15 07:55:04 -07002071 }
Ed Tanousa434f2b2018-07-27 13:04:22 -07002072 }
2073
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002074 bool verifyNames(const std::string& parent, const std::string& iface)
Ed Tanous1abe55e2018-09-05 08:30:59 -07002075 {
2076 if (!boost::starts_with(iface, parent + "_"))
2077 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07002078 return false;
2079 }
Ed Tanous3174e4d2020-10-07 11:41:22 -07002080 return true;
Ed Tanous1abe55e2018-09-05 08:30:59 -07002081 }
2082
2083 /**
2084 * Functions triggers appropriate requests on DBus
2085 */
Ed Tanouscb13a392020-07-25 19:02:03 +00002086 void doGet(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002087 const std::vector<std::string>& params) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07002088 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07002089 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
2090 // TODO(Pawel) this shall be parameterized call (two params) to get
Ed Tanous1abe55e2018-09-05 08:30:59 -07002091 // EthernetInterfaces for any Manager, not only hardcoded 'openbmc'.
2092 // Check if there is required param, truly entering this shall be
2093 // impossible.
2094 if (params.size() != 2)
2095 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002096 messages::internalError(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002097 res.end();
Kowalski, Kamil927a5052018-07-03 14:16:46 +02002098 return;
Ed Tanous1abe55e2018-09-05 08:30:59 -07002099 }
Kowalski, Kamil927a5052018-07-03 14:16:46 +02002100
Ed Tanous2c70f802020-09-28 14:29:23 -07002101 const std::string& parentIfaceId = params[0];
2102 const std::string& ifaceId = params[1];
Ed Tanous0f74e642018-11-12 15:17:05 -08002103 res.jsonValue["@odata.type"] =
2104 "#VLanNetworkInterface.v1_1_0.VLanNetworkInterface";
Ed Tanous0f74e642018-11-12 15:17:05 -08002105 res.jsonValue["Name"] = "VLAN Network Interface";
Kowalski, Kamil927a5052018-07-03 14:16:46 +02002106
Ed Tanous2c70f802020-09-28 14:29:23 -07002107 if (!verifyNames(parentIfaceId, ifaceId))
Ed Tanous1abe55e2018-09-05 08:30:59 -07002108 {
2109 return;
2110 }
Kowalski, Kamil927a5052018-07-03 14:16:46 +02002111
Johnathan Mantey01784822019-06-18 12:44:21 -07002112 // Get single eth interface data, and call the below callback for
2113 // JSON preparation
Ed Tanous4a0cb852018-10-15 07:55:04 -07002114 getEthernetIfaceData(
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002115 params[1],
Ed Tanous2c70f802020-09-28 14:29:23 -07002116 [this, asyncResp, parentIfaceId{std::string(params[0])},
2117 ifaceId{std::string(params[1])}](
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002118 const bool& success, const EthernetInterfaceData& ethData,
Ed Tanouscb13a392020-07-25 19:02:03 +00002119 const boost::container::flat_set<IPv4AddressData>&,
2120 const boost::container::flat_set<IPv6AddressData>&) {
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002121 if (success && ethData.vlan_id.size() != 0)
Ed Tanous1abe55e2018-09-05 08:30:59 -07002122 {
Ed Tanous2c70f802020-09-28 14:29:23 -07002123 parseInterfaceData(asyncResp->res.jsonValue, parentIfaceId,
2124 ifaceId, ethData);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002125 }
2126 else
2127 {
2128 // ... otherwise return error
2129 // TODO(Pawel)consider distinguish between non existing
2130 // object, and other errors
Jason M. Billsf12894f2018-10-09 12:45:45 -07002131 messages::resourceNotFound(
Ed Tanous2c70f802020-09-28 14:29:23 -07002132 asyncResp->res, "VLAN Network Interface", ifaceId);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002133 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07002134 });
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002135 }
2136
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002137 void doPatch(crow::Response& res, const crow::Request& req,
2138 const std::vector<std::string>& params) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07002139 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07002140 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002141 if (params.size() != 2)
2142 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002143 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002144 return;
2145 }
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002146
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002147 const std::string& parentIfaceId = params[0];
2148 const std::string& ifaceId = params[1];
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002149
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002150 if (!verifyNames(parentIfaceId, ifaceId))
Ed Tanous1abe55e2018-09-05 08:30:59 -07002151 {
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002152 messages::resourceNotFound(asyncResp->res, "VLAN Network Interface",
2153 ifaceId);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002154 return;
2155 }
2156
Ed Tanous0627a2c2018-11-29 17:09:23 -08002157 bool vlanEnable = false;
Andrew Geissler38268fa2020-05-16 14:22:18 -05002158 uint32_t vlanId = 0;
Ed Tanous0627a2c2018-11-29 17:09:23 -08002159
2160 if (!json_util::readJson(req, res, "VLANEnable", vlanEnable, "VLANId",
2161 vlanId))
Ed Tanous1abe55e2018-09-05 08:30:59 -07002162 {
2163 return;
2164 }
2165
Johnathan Mantey01784822019-06-18 12:44:21 -07002166 // Get single eth interface data, and call the below callback for
2167 // JSON preparation
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002168 getEthernetIfaceData(
2169 params[1],
Ed Tanous271584a2019-07-09 16:24:22 -07002170 [asyncResp, parentIfaceId{std::string(params[0])},
Ed Tanouscb13a392020-07-25 19:02:03 +00002171 ifaceId{std::string(params[1])}, &vlanEnable,
2172 &vlanId](const bool& success, const EthernetInterfaceData& ethData,
2173 const boost::container::flat_set<IPv4AddressData>&,
2174 const boost::container::flat_set<IPv6AddressData>&) {
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002175 if (success && !ethData.vlan_id.empty())
Sunitha Harish08244d02019-04-01 03:57:25 -05002176 {
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002177 auto callback =
2178 [asyncResp](const boost::system::error_code ec) {
2179 if (ec)
2180 {
2181 messages::internalError(asyncResp->res);
2182 }
2183 };
2184
2185 if (vlanEnable == true)
2186 {
2187 crow::connections::systemBus->async_method_call(
2188 std::move(callback), "xyz.openbmc_project.Network",
2189 "/xyz/openbmc_project/network/" + ifaceId,
2190 "org.freedesktop.DBus.Properties", "Set",
2191 "xyz.openbmc_project.Network.VLAN", "Id",
2192 std::variant<uint32_t>(vlanId));
2193 }
2194 else
2195 {
2196 BMCWEB_LOG_DEBUG << "vlanEnable is false. Deleting the "
2197 "vlan interface";
2198 crow::connections::systemBus->async_method_call(
2199 std::move(callback), "xyz.openbmc_project.Network",
2200 std::string("/xyz/openbmc_project/network/") +
2201 ifaceId,
2202 "xyz.openbmc_project.Object.Delete", "Delete");
2203 }
Sunitha Harish08244d02019-04-01 03:57:25 -05002204 }
2205 else
2206 {
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002207 // TODO(Pawel)consider distinguish between non existing
2208 // object, and other errors
2209 messages::resourceNotFound(
2210 asyncResp->res, "VLAN Network Interface", ifaceId);
2211 return;
Sunitha Harish08244d02019-04-01 03:57:25 -05002212 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002213 });
Ed Tanous1abe55e2018-09-05 08:30:59 -07002214 }
2215
Ed Tanouscb13a392020-07-25 19:02:03 +00002216 void doDelete(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002217 const std::vector<std::string>& params) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07002218 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07002219 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002220 if (params.size() != 2)
2221 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002222 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002223 return;
2224 }
2225
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002226 const std::string& parentIfaceId = params[0];
2227 const std::string& ifaceId = params[1];
Ed Tanous1abe55e2018-09-05 08:30:59 -07002228
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002229 if (!verifyNames(parentIfaceId, ifaceId))
Ed Tanous1abe55e2018-09-05 08:30:59 -07002230 {
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002231 messages::resourceNotFound(asyncResp->res, "VLAN Network Interface",
2232 ifaceId);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002233 return;
2234 }
2235
Johnathan Mantey01784822019-06-18 12:44:21 -07002236 // Get single eth interface data, and call the below callback for
2237 // JSON preparation
Jason M. Billsf12894f2018-10-09 12:45:45 -07002238 getEthernetIfaceData(
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002239 params[1],
Ed Tanous271584a2019-07-09 16:24:22 -07002240 [asyncResp, parentIfaceId{std::string(params[0])},
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002241 ifaceId{std::string(params[1])}](
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002242 const bool& success, const EthernetInterfaceData& ethData,
Ed Tanouscb13a392020-07-25 19:02:03 +00002243 const boost::container::flat_set<IPv4AddressData>&,
2244 const boost::container::flat_set<IPv6AddressData>&) {
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002245 if (success && !ethData.vlan_id.empty())
Jason M. Billsf12894f2018-10-09 12:45:45 -07002246 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002247 auto callback =
2248 [asyncResp](const boost::system::error_code ec) {
2249 if (ec)
2250 {
2251 messages::internalError(asyncResp->res);
2252 }
2253 };
2254 crow::connections::systemBus->async_method_call(
2255 std::move(callback), "xyz.openbmc_project.Network",
2256 std::string("/xyz/openbmc_project/network/") + ifaceId,
2257 "xyz.openbmc_project.Object.Delete", "Delete");
2258 }
2259 else
2260 {
2261 // ... otherwise return error
2262 // TODO(Pawel)consider distinguish between non existing
2263 // object, and other errors
2264 messages::resourceNotFound(
2265 asyncResp->res, "VLAN Network Interface", ifaceId);
2266 }
2267 });
Ed Tanous1abe55e2018-09-05 08:30:59 -07002268 }
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002269};
2270
2271/**
2272 * VlanNetworkInterfaceCollection derived class for delivering
2273 * VLANNetworkInterface Collection Schema
2274 */
Ed Tanous1abe55e2018-09-05 08:30:59 -07002275class VlanNetworkInterfaceCollection : public Node
2276{
2277 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002278 VlanNetworkInterfaceCollection(App& app) :
Ed Tanous4a0cb852018-10-15 07:55:04 -07002279 Node(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/",
2280 std::string())
Ed Tanous1abe55e2018-09-05 08:30:59 -07002281 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07002282 entityPrivileges = {
2283 {boost::beast::http::verb::get, {{"Login"}}},
2284 {boost::beast::http::verb::head, {{"Login"}}},
2285 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
2286 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
2287 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
2288 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002289 }
2290
Ed Tanous1abe55e2018-09-05 08:30:59 -07002291 private:
2292 /**
2293 * Functions triggers appropriate requests on DBus
2294 */
Ed Tanouscb13a392020-07-25 19:02:03 +00002295 void doGet(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002296 const std::vector<std::string>& params) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07002297 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07002298 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002299 if (params.size() != 1)
2300 {
2301 // This means there is a problem with the router
Jason M. Billsf12894f2018-10-09 12:45:45 -07002302 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002303 return;
Ed Tanous8ceb2ec2018-08-13 11:11:56 -07002304 }
2305
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002306 const std::string& rootInterfaceName = params[0];
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002307
Ed Tanous4a0cb852018-10-15 07:55:04 -07002308 // Get eth interface list, and call the below callback for JSON
Ed Tanous1abe55e2018-09-05 08:30:59 -07002309 // preparation
Jason M. Billsf12894f2018-10-09 12:45:45 -07002310 getEthernetIfaceList(
Ed Tanous43b761d2019-02-13 20:10:56 -08002311 [asyncResp, rootInterfaceName{std::string(rootInterfaceName)}](
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002312 const bool& success,
Ed Tanous81ce6092020-12-17 16:54:55 +00002313 const boost::container::flat_set<std::string>& ifaceList) {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002314 if (!success)
Ed Tanous1abe55e2018-09-05 08:30:59 -07002315 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002316 messages::internalError(asyncResp->res);
2317 return;
Ed Tanous1abe55e2018-09-05 08:30:59 -07002318 }
Ed Tanous4c9afe42019-05-03 16:59:57 -07002319
Ed Tanous81ce6092020-12-17 16:54:55 +00002320 if (ifaceList.find(rootInterfaceName) == ifaceList.end())
Ed Tanous4c9afe42019-05-03 16:59:57 -07002321 {
2322 messages::resourceNotFound(asyncResp->res,
2323 "VLanNetworkInterfaceCollection",
2324 rootInterfaceName);
2325 return;
2326 }
2327
Ed Tanous0f74e642018-11-12 15:17:05 -08002328 asyncResp->res.jsonValue["@odata.type"] =
2329 "#VLanNetworkInterfaceCollection."
2330 "VLanNetworkInterfaceCollection";
Ed Tanous0f74e642018-11-12 15:17:05 -08002331 asyncResp->res.jsonValue["Name"] =
2332 "VLAN Network Interface Collection";
Ed Tanous4a0cb852018-10-15 07:55:04 -07002333
Ed Tanous2c70f802020-09-28 14:29:23 -07002334 nlohmann::json ifaceArray = nlohmann::json::array();
Jason M. Billsf12894f2018-10-09 12:45:45 -07002335
Ed Tanous81ce6092020-12-17 16:54:55 +00002336 for (const std::string& ifaceItem : ifaceList)
Jason M. Billsf12894f2018-10-09 12:45:45 -07002337 {
Ed Tanous2c70f802020-09-28 14:29:23 -07002338 if (boost::starts_with(ifaceItem, rootInterfaceName + "_"))
Jason M. Billsf12894f2018-10-09 12:45:45 -07002339 {
Ed Tanousf23b7292020-10-15 09:41:17 -07002340 std::string path =
2341 "/redfish/v1/Managers/bmc/EthernetInterfaces/";
2342 path += rootInterfaceName;
2343 path += "/VLANs/";
2344 path += ifaceItem;
2345 ifaceArray.push_back({{"@odata.id", std::move(path)}});
Jason M. Billsf12894f2018-10-09 12:45:45 -07002346 }
2347 }
2348
Jason M. Billsf12894f2018-10-09 12:45:45 -07002349 asyncResp->res.jsonValue["Members@odata.count"] =
Ed Tanous2c70f802020-09-28 14:29:23 -07002350 ifaceArray.size();
2351 asyncResp->res.jsonValue["Members"] = std::move(ifaceArray);
Jason M. Billsf12894f2018-10-09 12:45:45 -07002352 asyncResp->res.jsonValue["@odata.id"] =
2353 "/redfish/v1/Managers/bmc/EthernetInterfaces/" +
2354 rootInterfaceName + "/VLANs";
2355 });
Ed Tanous1abe55e2018-09-05 08:30:59 -07002356 }
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002357
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002358 void doPost(crow::Response& res, const crow::Request& req,
2359 const std::vector<std::string>& params) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07002360 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07002361 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002362 if (params.size() != 1)
2363 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002364 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002365 return;
2366 }
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002367 bool vlanEnable = false;
Ed Tanous0627a2c2018-11-29 17:09:23 -08002368 uint32_t vlanId = 0;
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002369 if (!json_util::readJson(req, res, "VLANId", vlanId, "VLANEnable",
2370 vlanEnable))
Ed Tanous1abe55e2018-09-05 08:30:59 -07002371 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07002372 return;
2373 }
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002374 // Need both vlanId and vlanEnable to service this request
2375 if (!vlanId)
2376 {
2377 messages::propertyMissing(asyncResp->res, "VLANId");
2378 }
2379 if (!vlanEnable)
2380 {
2381 messages::propertyMissing(asyncResp->res, "VLANEnable");
2382 }
Ed Tanous271584a2019-07-09 16:24:22 -07002383 if (static_cast<bool>(vlanId) ^ vlanEnable)
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002384 {
2385 return;
2386 }
2387
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002388 const std::string& rootInterfaceName = params[0];
Ed Tanous4a0cb852018-10-15 07:55:04 -07002389 auto callback = [asyncResp](const boost::system::error_code ec) {
2390 if (ec)
2391 {
2392 // TODO(ed) make more consistent error messages based on
2393 // phosphor-network responses
Jason M. Billsf12894f2018-10-09 12:45:45 -07002394 messages::internalError(asyncResp->res);
Ed Tanous4a0cb852018-10-15 07:55:04 -07002395 return;
2396 }
Jason M. Billsf12894f2018-10-09 12:45:45 -07002397 messages::created(asyncResp->res);
Ed Tanous4a0cb852018-10-15 07:55:04 -07002398 };
2399 crow::connections::systemBus->async_method_call(
2400 std::move(callback), "xyz.openbmc_project.Network",
2401 "/xyz/openbmc_project/network",
2402 "xyz.openbmc_project.Network.VLAN.Create", "VLAN",
Ed Tanous0627a2c2018-11-29 17:09:23 -08002403 rootInterfaceName, vlanId);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002404 }
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002405};
Ed Tanous1abe55e2018-09-05 08:30:59 -07002406} // namespace redfish