blob: cd0584cc024369a207c209ced662628c4295edc2 [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 {
Ed Tanous71f52d92021-02-19 08:51:17 -08001406 messages::propertyValueTypeError(
1407 asyncResp->res,
1408 input.dump(2, ' ', true,
1409 nlohmann::json::error_handler_t::replace),
1410 "IPv4StaticAddresses");
Ratan Guptaf476acb2019-03-02 16:46:57 +05301411 return;
1412 }
1413
Ed Tanous271584a2019-07-09 16:24:22 -07001414 unsigned entryIdx = 1;
Johnathan Mantey01784822019-06-18 12:44:21 -07001415 // Find the first static IP address currently active on the NIC and
1416 // match it to the first JSON element in the IPv4StaticAddresses array.
1417 // Match each subsequent JSON element to the next static IP programmed
1418 // into the NIC.
Ed Tanous2c70f802020-09-28 14:29:23 -07001419 boost::container::flat_set<IPv4AddressData>::const_iterator niciPentry =
1420 getNextStaticIpEntry(ipv4Data.cbegin(), ipv4Data.cend());
Johnathan Mantey01784822019-06-18 12:44:21 -07001421
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001422 for (nlohmann::json& thisJson : input)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001423 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001424 std::string pathString =
Ravi Tejad1d50812019-06-23 16:20:27 -05001425 "IPv4StaticAddresses/" + std::to_string(entryIdx);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001426
Johnathan Mantey01784822019-06-18 12:44:21 -07001427 if (!thisJson.is_null() && !thisJson.empty())
Ratan Guptaf476acb2019-03-02 16:46:57 +05301428 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001429 std::optional<std::string> address;
1430 std::optional<std::string> subnetMask;
1431 std::optional<std::string> gateway;
1432
1433 if (!json_util::readJson(thisJson, asyncResp->res, "Address",
1434 address, "SubnetMask", subnetMask,
1435 "Gateway", gateway))
Ratan Guptaf476acb2019-03-02 16:46:57 +05301436 {
1437 messages::propertyValueFormatError(
Ed Tanous71f52d92021-02-19 08:51:17 -08001438 asyncResp->res,
1439 thisJson.dump(2, ' ', true,
1440 nlohmann::json::error_handler_t::replace),
1441 pathString);
Ratan Guptaf476acb2019-03-02 16:46:57 +05301442 return;
Ratan Guptaf476acb2019-03-02 16:46:57 +05301443 }
Ratan Guptaf476acb2019-03-02 16:46:57 +05301444
Johnathan Mantey01784822019-06-18 12:44:21 -07001445 // Find the address/subnet/gateway values. Any values that are
1446 // not explicitly provided are assumed to be unmodified from the
1447 // current state of the interface. Merge existing state into the
1448 // current request.
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001449 const std::string* addr = nullptr;
1450 const std::string* gw = nullptr;
Johnathan Mantey01784822019-06-18 12:44:21 -07001451 uint8_t prefixLength = 0;
1452 bool errorInEntry = false;
1453 if (address)
Ratan Gupta9474b372019-03-01 15:13:37 +05301454 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001455 if (ipv4VerifyIpAndGetBitcount(*address))
1456 {
1457 addr = &(*address);
1458 }
1459 else
1460 {
1461 messages::propertyValueFormatError(
1462 asyncResp->res, *address, pathString + "/Address");
1463 errorInEntry = true;
1464 }
1465 }
Ed Tanous2c70f802020-09-28 14:29:23 -07001466 else if (niciPentry != ipv4Data.cend())
Johnathan Mantey01784822019-06-18 12:44:21 -07001467 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001468 addr = &(niciPentry->address);
Ratan Gupta9474b372019-03-01 15:13:37 +05301469 }
1470 else
1471 {
1472 messages::propertyMissing(asyncResp->res,
1473 pathString + "/Address");
Johnathan Mantey01784822019-06-18 12:44:21 -07001474 errorInEntry = true;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001475 }
Ratan Guptaf476acb2019-03-02 16:46:57 +05301476
1477 if (subnetMask)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001478 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001479 if (!ipv4VerifyIpAndGetBitcount(*subnetMask, &prefixLength))
1480 {
1481 messages::propertyValueFormatError(
1482 asyncResp->res, *subnetMask,
1483 pathString + "/SubnetMask");
1484 errorInEntry = true;
1485 }
1486 }
Ed Tanous2c70f802020-09-28 14:29:23 -07001487 else if (niciPentry != ipv4Data.cend())
Johnathan Mantey01784822019-06-18 12:44:21 -07001488 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001489 if (!ipv4VerifyIpAndGetBitcount(niciPentry->netmask,
Johnathan Mantey01784822019-06-18 12:44:21 -07001490 &prefixLength))
1491 {
1492 messages::propertyValueFormatError(
Ed Tanous2c70f802020-09-28 14:29:23 -07001493 asyncResp->res, niciPentry->netmask,
Johnathan Mantey01784822019-06-18 12:44:21 -07001494 pathString + "/SubnetMask");
1495 errorInEntry = true;
1496 }
1497 }
1498 else
1499 {
1500 messages::propertyMissing(asyncResp->res,
1501 pathString + "/SubnetMask");
1502 errorInEntry = true;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001503 }
Ratan Guptaf476acb2019-03-02 16:46:57 +05301504
Ratan Guptaf476acb2019-03-02 16:46:57 +05301505 if (gateway)
1506 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001507 if (ipv4VerifyIpAndGetBitcount(*gateway))
1508 {
1509 gw = &(*gateway);
1510 }
1511 else
1512 {
1513 messages::propertyValueFormatError(
1514 asyncResp->res, *gateway, pathString + "/Gateway");
1515 errorInEntry = true;
1516 }
Ratan Guptaf476acb2019-03-02 16:46:57 +05301517 }
Ed Tanous2c70f802020-09-28 14:29:23 -07001518 else if (niciPentry != ipv4Data.cend())
Johnathan Mantey01784822019-06-18 12:44:21 -07001519 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001520 gw = &niciPentry->gateway;
Johnathan Mantey01784822019-06-18 12:44:21 -07001521 }
1522 else
Ed Tanous4a0cb852018-10-15 07:55:04 -07001523 {
Jason M. Billsa08b46c2018-11-06 15:01:08 -08001524 messages::propertyMissing(asyncResp->res,
Jason M. Billsf12894f2018-10-09 12:45:45 -07001525 pathString + "/Gateway");
Johnathan Mantey01784822019-06-18 12:44:21 -07001526 errorInEntry = true;
Ed Tanous4a0cb852018-10-15 07:55:04 -07001527 }
1528
Johnathan Mantey01784822019-06-18 12:44:21 -07001529 if (errorInEntry)
Ed Tanous4a0cb852018-10-15 07:55:04 -07001530 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001531 return;
Ed Tanous4a0cb852018-10-15 07:55:04 -07001532 }
1533
Ed Tanous2c70f802020-09-28 14:29:23 -07001534 if (niciPentry != ipv4Data.cend())
Ed Tanous4a0cb852018-10-15 07:55:04 -07001535 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001536 deleteAndCreateIPv4(ifaceId, niciPentry->id, prefixLength,
Johnathan Mantey01784822019-06-18 12:44:21 -07001537 *gw, *addr, asyncResp);
Ed Tanous2c70f802020-09-28 14:29:23 -07001538 niciPentry =
1539 getNextStaticIpEntry(++niciPentry, ipv4Data.cend());
Ed Tanous4a0cb852018-10-15 07:55:04 -07001540 }
Johnathan Mantey01784822019-06-18 12:44:21 -07001541 else
1542 {
Ed Tanouscb13a392020-07-25 19:02:03 +00001543 createIPv4(ifaceId, prefixLength, *gateway, *address,
1544 asyncResp);
Johnathan Mantey01784822019-06-18 12:44:21 -07001545 }
1546 entryIdx++;
Ed Tanous4a0cb852018-10-15 07:55:04 -07001547 }
Johnathan Mantey01784822019-06-18 12:44:21 -07001548 else
1549 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001550 if (niciPentry == ipv4Data.cend())
Johnathan Mantey01784822019-06-18 12:44:21 -07001551 {
1552 // Requesting a DELETE/DO NOT MODIFY action for an item
1553 // that isn't present on the eth(n) interface. Input JSON is
1554 // in error, so bail out.
1555 if (thisJson.is_null())
1556 {
1557 messages::resourceCannotBeDeleted(asyncResp->res);
1558 return;
1559 }
Ed Tanous3174e4d2020-10-07 11:41:22 -07001560 messages::propertyValueFormatError(
Ed Tanous71f52d92021-02-19 08:51:17 -08001561 asyncResp->res,
1562 thisJson.dump(2, ' ', true,
1563 nlohmann::json::error_handler_t::replace),
1564 pathString);
Ed Tanous3174e4d2020-10-07 11:41:22 -07001565 return;
Johnathan Mantey01784822019-06-18 12:44:21 -07001566 }
1567
1568 if (thisJson.is_null())
1569 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001570 deleteIPv4(ifaceId, niciPentry->id, asyncResp);
Johnathan Mantey01784822019-06-18 12:44:21 -07001571 }
Ed Tanous2c70f802020-09-28 14:29:23 -07001572 if (niciPentry != ipv4Data.cend())
Johnathan Mantey01784822019-06-18 12:44:21 -07001573 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001574 niciPentry =
1575 getNextStaticIpEntry(++niciPentry, ipv4Data.cend());
Johnathan Mantey01784822019-06-18 12:44:21 -07001576 }
1577 entryIdx++;
1578 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001579 }
1580 }
1581
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05001582 void handleStaticNameServersPatch(
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001583 const std::string& ifaceId,
1584 const std::vector<std::string>& updatedStaticNameServers,
1585 const std::shared_ptr<AsyncResp>& asyncResp)
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05001586 {
1587 crow::connections::systemBus->async_method_call(
Johnathan Mantey286b9112019-06-10 13:38:04 -07001588 [asyncResp](const boost::system::error_code ec) {
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05001589 if (ec)
1590 {
1591 messages::internalError(asyncResp->res);
1592 return;
1593 }
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05001594 },
1595 "xyz.openbmc_project.Network",
1596 "/xyz/openbmc_project/network/" + ifaceId,
1597 "org.freedesktop.DBus.Properties", "Set",
manojkiran.eda@gmail.com0f6efdc2019-10-03 04:53:44 -05001598 "xyz.openbmc_project.Network.EthernetInterface",
1599 "StaticNameServers",
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05001600 std::variant<std::vector<std::string>>{updatedStaticNameServers});
1601 }
1602
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001603 void handleIPv6StaticAddressesPatch(
Ed Tanousf23b7292020-10-15 09:41:17 -07001604 const std::string& ifaceId, const nlohmann::json& input,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001605 const boost::container::flat_set<IPv6AddressData>& ipv6Data,
Ed Tanousb5a76932020-09-29 16:16:58 -07001606 const std::shared_ptr<AsyncResp>& asyncResp)
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001607 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001608 if (!input.is_array() || input.empty())
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001609 {
Ed Tanous71f52d92021-02-19 08:51:17 -08001610 messages::propertyValueTypeError(
1611 asyncResp->res,
1612 input.dump(2, ' ', true,
1613 nlohmann::json::error_handler_t::replace),
1614 "IPv6StaticAddresses");
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001615 return;
1616 }
Ed Tanous271584a2019-07-09 16:24:22 -07001617 size_t entryIdx = 1;
Ed Tanous2c70f802020-09-28 14:29:23 -07001618 boost::container::flat_set<IPv6AddressData>::const_iterator niciPentry =
1619 getNextStaticIpEntry(ipv6Data.cbegin(), ipv6Data.cend());
Ed Tanousf23b7292020-10-15 09:41:17 -07001620 for (const nlohmann::json& thisJson : input)
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001621 {
1622 std::string pathString =
1623 "IPv6StaticAddresses/" + std::to_string(entryIdx);
1624
Johnathan Mantey01784822019-06-18 12:44:21 -07001625 if (!thisJson.is_null() && !thisJson.empty())
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001626 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001627 std::optional<std::string> address;
1628 std::optional<uint8_t> prefixLength;
Ed Tanousf23b7292020-10-15 09:41:17 -07001629 nlohmann::json thisJsonCopy = thisJson;
1630 if (!json_util::readJson(thisJsonCopy, asyncResp->res,
1631 "Address", address, "PrefixLength",
1632 prefixLength))
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001633 {
1634 messages::propertyValueFormatError(
Ed Tanous71f52d92021-02-19 08:51:17 -08001635 asyncResp->res,
1636 thisJson.dump(2, ' ', true,
1637 nlohmann::json::error_handler_t::replace),
1638 pathString);
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001639 return;
1640 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001641
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001642 const std::string* addr;
Johnathan Mantey01784822019-06-18 12:44:21 -07001643 uint8_t prefix;
1644
1645 // Find the address and prefixLength values. Any values that are
1646 // not explicitly provided are assumed to be unmodified from the
1647 // current state of the interface. Merge existing state into the
1648 // current request.
1649 if (address)
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001650 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001651 addr = &(*address);
1652 }
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 addr = &(niciPentry->address);
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001656 }
1657 else
1658 {
1659 messages::propertyMissing(asyncResp->res,
1660 pathString + "/Address");
1661 return;
1662 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001663
1664 if (prefixLength)
1665 {
Johnathan Mantey01784822019-06-18 12:44:21 -07001666 prefix = *prefixLength;
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001667 }
Ed Tanous2c70f802020-09-28 14:29:23 -07001668 else if (niciPentry != ipv6Data.end())
Johnathan Mantey01784822019-06-18 12:44:21 -07001669 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001670 prefix = niciPentry->prefixLength;
Johnathan Mantey01784822019-06-18 12:44:21 -07001671 }
1672 else
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001673 {
1674 messages::propertyMissing(asyncResp->res,
1675 pathString + "/PrefixLength");
Johnathan Mantey01784822019-06-18 12:44:21 -07001676 return;
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001677 }
1678
Ed Tanous2c70f802020-09-28 14:29:23 -07001679 if (niciPentry != ipv6Data.end())
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001680 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001681 deleteAndCreateIPv6(ifaceId, niciPentry->id, prefix, *addr,
Johnathan Mantey01784822019-06-18 12:44:21 -07001682 asyncResp);
Ed Tanous2c70f802020-09-28 14:29:23 -07001683 niciPentry =
1684 getNextStaticIpEntry(++niciPentry, ipv6Data.cend());
Johnathan Mantey01784822019-06-18 12:44:21 -07001685 }
1686 else
1687 {
1688 createIPv6(ifaceId, *prefixLength, *addr, asyncResp);
1689 }
1690 entryIdx++;
1691 }
1692 else
1693 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001694 if (niciPentry == ipv6Data.end())
Johnathan Mantey01784822019-06-18 12:44:21 -07001695 {
1696 // Requesting a DELETE/DO NOT MODIFY action for an item
1697 // that isn't present on the eth(n) interface. Input JSON is
1698 // in error, so bail out.
1699 if (thisJson.is_null())
1700 {
1701 messages::resourceCannotBeDeleted(asyncResp->res);
1702 return;
1703 }
Ed Tanous3174e4d2020-10-07 11:41:22 -07001704 messages::propertyValueFormatError(
Ed Tanous71f52d92021-02-19 08:51:17 -08001705 asyncResp->res,
1706 thisJson.dump(2, ' ', true,
1707 nlohmann::json::error_handler_t::replace),
1708 pathString);
Ed Tanous3174e4d2020-10-07 11:41:22 -07001709 return;
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001710 }
1711
Johnathan Mantey01784822019-06-18 12:44:21 -07001712 if (thisJson.is_null())
1713 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001714 deleteIPv6(ifaceId, niciPentry->id, asyncResp);
Johnathan Mantey01784822019-06-18 12:44:21 -07001715 }
Ed Tanous2c70f802020-09-28 14:29:23 -07001716 if (niciPentry != ipv6Data.cend())
Johnathan Mantey01784822019-06-18 12:44:21 -07001717 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001718 niciPentry =
1719 getNextStaticIpEntry(++niciPentry, ipv6Data.cend());
Johnathan Mantey01784822019-06-18 12:44:21 -07001720 }
1721 entryIdx++;
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001722 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001723 }
1724 }
1725
Ed Tanous0f74e642018-11-12 15:17:05 -08001726 void parseInterfaceData(
Ed Tanous81ce6092020-12-17 16:54:55 +00001727 const std::shared_ptr<AsyncResp>& asyncResp, const std::string& ifaceId,
1728 const EthernetInterfaceData& ethData,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001729 const boost::container::flat_set<IPv4AddressData>& ipv4Data,
1730 const boost::container::flat_set<IPv6AddressData>& ipv6Data)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001731 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001732 constexpr const std::array<const char*, 1> inventoryForEthernet = {
Johnathan Manteyeeedda22019-10-29 16:09:52 -07001733 "xyz.openbmc_project.Inventory.Item.Ethernet"};
1734
Ed Tanous2c70f802020-09-28 14:29:23 -07001735 nlohmann::json& jsonResponse = asyncResp->res.jsonValue;
Ed Tanous81ce6092020-12-17 16:54:55 +00001736 jsonResponse["Id"] = ifaceId;
Ed Tanous2c70f802020-09-28 14:29:23 -07001737 jsonResponse["@odata.id"] =
Ed Tanous81ce6092020-12-17 16:54:55 +00001738 "/redfish/v1/Managers/bmc/EthernetInterfaces/" + ifaceId;
Ed Tanous2c70f802020-09-28 14:29:23 -07001739 jsonResponse["InterfaceEnabled"] = ethData.nicEnabled;
Johnathan Manteyeeedda22019-10-29 16:09:52 -07001740
1741 auto health = std::make_shared<HealthPopulate>(asyncResp);
1742
1743 crow::connections::systemBus->async_method_call(
1744 [health](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001745 std::vector<std::string>& resp) {
Johnathan Manteyeeedda22019-10-29 16:09:52 -07001746 if (ec)
1747 {
1748 return;
1749 }
1750
1751 health->inventory = std::move(resp);
1752 },
1753 "xyz.openbmc_project.ObjectMapper",
1754 "/xyz/openbmc_project/object_mapper",
1755 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths", "/",
1756 int32_t(0), inventoryForEthernet);
1757
1758 health->populate();
1759
1760 if (ethData.nicEnabled)
Ed Tanous029573d2019-02-01 10:57:49 -08001761 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001762 jsonResponse["LinkStatus"] = "LinkUp";
1763 jsonResponse["Status"]["State"] = "Enabled";
Ed Tanous029573d2019-02-01 10:57:49 -08001764 }
1765 else
1766 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001767 jsonResponse["LinkStatus"] = "NoLink";
1768 jsonResponse["Status"]["State"] = "Disabled";
Ed Tanous029573d2019-02-01 10:57:49 -08001769 }
Johnathan Manteyaa05fb22020-01-08 12:08:44 -08001770
Ed Tanous2c70f802020-09-28 14:29:23 -07001771 jsonResponse["LinkStatus"] = ethData.linkUp ? "LinkUp" : "LinkDown";
1772 jsonResponse["SpeedMbps"] = ethData.speed;
1773 jsonResponse["MACAddress"] = ethData.mac_address;
1774 jsonResponse["DHCPv4"]["DHCPEnabled"] =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001775 translateDHCPEnabledToBool(ethData.DHCPEnabled, true);
Ed Tanous2c70f802020-09-28 14:29:23 -07001776 jsonResponse["DHCPv4"]["UseNTPServers"] = ethData.NTPEnabled;
1777 jsonResponse["DHCPv4"]["UseDNSServers"] = ethData.DNSEnabled;
1778 jsonResponse["DHCPv4"]["UseDomainName"] = ethData.HostNameEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001779
Ed Tanous2c70f802020-09-28 14:29:23 -07001780 jsonResponse["DHCPv6"]["OperatingMode"] =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001781 translateDHCPEnabledToBool(ethData.DHCPEnabled, false) ? "Stateful"
1782 : "Disabled";
Ed Tanous2c70f802020-09-28 14:29:23 -07001783 jsonResponse["DHCPv6"]["UseNTPServers"] = ethData.NTPEnabled;
1784 jsonResponse["DHCPv6"]["UseDNSServers"] = ethData.DNSEnabled;
1785 jsonResponse["DHCPv6"]["UseDomainName"] = ethData.HostNameEnabled;
manojkiraneda2a133282019-02-19 13:09:43 +05301786
Ed Tanous4a0cb852018-10-15 07:55:04 -07001787 if (!ethData.hostname.empty())
Ed Tanous1abe55e2018-09-05 08:30:59 -07001788 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001789 jsonResponse["HostName"] = ethData.hostname;
Joshi-Mansiab6554f2020-03-10 18:33:36 +05301790
1791 // When domain name is empty then it means, that it is a network
1792 // without domain names, and the host name itself must be treated as
1793 // FQDN
Ed Tanousf23b7292020-10-15 09:41:17 -07001794 std::string fqdn = ethData.hostname;
Jennifer Leed24bfc72019-03-05 13:03:37 -08001795 if (!ethData.domainnames.empty())
1796 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001797 fqdn += "." + ethData.domainnames[0];
Jennifer Leed24bfc72019-03-05 13:03:37 -08001798 }
Ed Tanous2c70f802020-09-28 14:29:23 -07001799 jsonResponse["FQDN"] = fqdn;
Ed Tanous4a0cb852018-10-15 07:55:04 -07001800 }
1801
Ed Tanous2c70f802020-09-28 14:29:23 -07001802 jsonResponse["VLANs"] = {
Sunitha Harishfda13ad2019-03-21 11:01:24 -05001803 {"@odata.id", "/redfish/v1/Managers/bmc/EthernetInterfaces/" +
Ed Tanous81ce6092020-12-17 16:54:55 +00001804 ifaceId + "/VLANs"}};
Sunitha Harishfda13ad2019-03-21 11:01:24 -05001805
Ed Tanous2c70f802020-09-28 14:29:23 -07001806 jsonResponse["NameServers"] = ethData.nameServers;
1807 jsonResponse["StaticNameServers"] = ethData.staticNameServers;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001808
Ed Tanous2c70f802020-09-28 14:29:23 -07001809 nlohmann::json& ipv4Array = jsonResponse["IPv4Addresses"];
1810 nlohmann::json& ipv4StaticArray = jsonResponse["IPv4StaticAddresses"];
1811 ipv4Array = nlohmann::json::array();
1812 ipv4StaticArray = nlohmann::json::array();
1813 for (auto& ipv4Config : ipv4Data)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001814 {
Ravi Tejad1d50812019-06-23 16:20:27 -05001815
Ed Tanous2c70f802020-09-28 14:29:23 -07001816 std::string gatewayStr = ipv4Config.gateway;
Ravi Tejad1d50812019-06-23 16:20:27 -05001817 if (gatewayStr.empty())
Ed Tanous1abe55e2018-09-05 08:30:59 -07001818 {
Ravi Tejad1d50812019-06-23 16:20:27 -05001819 gatewayStr = "0.0.0.0";
Ed Tanous1abe55e2018-09-05 08:30:59 -07001820 }
Ravi Tejad1d50812019-06-23 16:20:27 -05001821
Ed Tanous2c70f802020-09-28 14:29:23 -07001822 ipv4Array.push_back({{"AddressOrigin", ipv4Config.origin},
1823 {"SubnetMask", ipv4Config.netmask},
1824 {"Address", ipv4Config.address},
1825 {"Gateway", gatewayStr}});
1826 if (ipv4Config.origin == "Static")
Ravi Tejad1d50812019-06-23 16:20:27 -05001827 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001828 ipv4StaticArray.push_back({{"AddressOrigin", ipv4Config.origin},
1829 {"SubnetMask", ipv4Config.netmask},
1830 {"Address", ipv4Config.address},
1831 {"Gateway", gatewayStr}});
Ravi Tejad1d50812019-06-23 16:20:27 -05001832 }
Ravi Tejad1d50812019-06-23 16:20:27 -05001833 }
1834
Ravi Teja7ea79e52021-03-02 08:38:05 +05301835 std::string ipv6GatewayStr = ethData.ipv6_default_gateway;
1836 if (ipv6GatewayStr.empty())
1837 {
1838 ipv6GatewayStr = "0:0:0:0:0:0:0:0";
1839 }
1840
1841 jsonResponse["IPv6DefaultGateway"] = ipv6GatewayStr;
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001842
Ed Tanous2c70f802020-09-28 14:29:23 -07001843 nlohmann::json& ipv6Array = jsonResponse["IPv6Addresses"];
1844 nlohmann::json& ipv6StaticArray = jsonResponse["IPv6StaticAddresses"];
1845 ipv6Array = nlohmann::json::array();
1846 ipv6StaticArray = nlohmann::json::array();
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001847 nlohmann::json& ipv6AddrPolicyTable =
Ed Tanous2c70f802020-09-28 14:29:23 -07001848 jsonResponse["IPv6AddressPolicyTable"];
Johnathan Mantey7f2e23e2020-05-14 13:36:52 -07001849 ipv6AddrPolicyTable = nlohmann::json::array();
Ed Tanous2c70f802020-09-28 14:29:23 -07001850 for (auto& ipv6Config : ipv6Data)
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001851 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001852 ipv6Array.push_back({{"Address", ipv6Config.address},
1853 {"PrefixLength", ipv6Config.prefixLength},
1854 {"AddressOrigin", ipv6Config.origin},
1855 {"AddressState", nullptr}});
1856 if (ipv6Config.origin == "Static")
Johnathan Mantey01784822019-06-18 12:44:21 -07001857 {
Ed Tanous2c70f802020-09-28 14:29:23 -07001858 ipv6StaticArray.push_back(
1859 {{"Address", ipv6Config.address},
1860 {"PrefixLength", ipv6Config.prefixLength},
1861 {"AddressOrigin", ipv6Config.origin},
Johnathan Mantey5fd16e42020-05-13 15:14:47 -07001862 {"AddressState", nullptr}});
Johnathan Mantey01784822019-06-18 12:44:21 -07001863 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001864 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001865 }
1866
1867 /**
1868 * Functions triggers appropriate requests on DBus
1869 */
Ed Tanouscb13a392020-07-25 19:02:03 +00001870 void doGet(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001871 const std::vector<std::string>& params) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07001872 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001873 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001874 if (params.size() != 1)
1875 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001876 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001877 return;
1878 }
1879
Ed Tanous4a0cb852018-10-15 07:55:04 -07001880 getEthernetIfaceData(
1881 params[0],
Ed Tanous2c70f802020-09-28 14:29:23 -07001882 [this, asyncResp, ifaceId{std::string(params[0])}](
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001883 const bool& success, const EthernetInterfaceData& ethData,
1884 const boost::container::flat_set<IPv4AddressData>& ipv4Data,
1885 const boost::container::flat_set<IPv6AddressData>& ipv6Data) {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001886 if (!success)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001887 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001888 // TODO(Pawel)consider distinguish between non existing
1889 // object, and other errors
Jason M. Billsf12894f2018-10-09 12:45:45 -07001890 messages::resourceNotFound(asyncResp->res,
Ed Tanous2c70f802020-09-28 14:29:23 -07001891 "EthernetInterface", ifaceId);
Ed Tanous4a0cb852018-10-15 07:55:04 -07001892 return;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001893 }
Ed Tanous4c9afe42019-05-03 16:59:57 -07001894
Ed Tanous0f74e642018-11-12 15:17:05 -08001895 asyncResp->res.jsonValue["@odata.type"] =
Sunitha Harishfda13ad2019-03-21 11:01:24 -05001896 "#EthernetInterface.v1_4_1.EthernetInterface";
Ed Tanous0f74e642018-11-12 15:17:05 -08001897 asyncResp->res.jsonValue["Name"] = "Manager Ethernet Interface";
1898 asyncResp->res.jsonValue["Description"] =
1899 "Management Network Interface";
1900
Ed Tanous2c70f802020-09-28 14:29:23 -07001901 parseInterfaceData(asyncResp, ifaceId, ethData, ipv4Data,
Johnathan Manteyeeedda22019-10-29 16:09:52 -07001902 ipv6Data);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001903 });
1904 }
1905
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001906 void doPatch(crow::Response& res, const crow::Request& req,
1907 const std::vector<std::string>& params) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07001908 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001909 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001910 if (params.size() != 1)
1911 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001912 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001913 return;
1914 }
1915
Ed Tanous2c70f802020-09-28 14:29:23 -07001916 const std::string& ifaceId = params[0];
Ed Tanous1abe55e2018-09-05 08:30:59 -07001917
Ed Tanousbc0bd6e2018-12-10 14:07:55 -08001918 std::optional<std::string> hostname;
Joshi-Mansiab6554f2020-03-10 18:33:36 +05301919 std::optional<std::string> fqdn;
Ratan Guptad5776652019-03-03 08:47:22 +05301920 std::optional<std::string> macAddress;
Ravi Teja9a6fc6f2019-04-16 02:43:13 -05001921 std::optional<std::string> ipv6DefaultGateway;
Ravi Tejad1d50812019-06-23 16:20:27 -05001922 std::optional<nlohmann::json> ipv4StaticAddresses;
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001923 std::optional<nlohmann::json> ipv6StaticAddresses;
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05001924 std::optional<std::vector<std::string>> staticNameServers;
Jennifer Leeda131a92019-04-24 15:13:55 -07001925 std::optional<nlohmann::json> dhcpv4;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001926 std::optional<nlohmann::json> dhcpv6;
Johnathan Manteyeeedda22019-10-29 16:09:52 -07001927 std::optional<bool> interfaceEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001928 DHCPParameters v4dhcpParms;
1929 DHCPParameters v6dhcpParms;
Ed Tanous0627a2c2018-11-29 17:09:23 -08001930
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001931 if (!json_util::readJson(
Joshi-Mansiab6554f2020-03-10 18:33:36 +05301932 req, res, "HostName", hostname, "FQDN", fqdn,
1933 "IPv4StaticAddresses", ipv4StaticAddresses, "MACAddress",
1934 macAddress, "StaticNameServers", staticNameServers,
1935 "IPv6DefaultGateway", ipv6DefaultGateway, "IPv6StaticAddresses",
1936 ipv6StaticAddresses, "DHCPv4", dhcpv4, "DHCPv6", dhcpv6,
1937 "InterfaceEnabled", interfaceEnabled))
Ed Tanous1abe55e2018-09-05 08:30:59 -07001938 {
1939 return;
1940 }
Jennifer Leeda131a92019-04-24 15:13:55 -07001941 if (dhcpv4)
1942 {
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001943 if (!json_util::readJson(*dhcpv4, res, "DHCPEnabled",
1944 v4dhcpParms.dhcpv4Enabled, "UseDNSServers",
1945 v4dhcpParms.useDNSServers, "UseNTPServers",
1946 v4dhcpParms.useNTPServers, "UseDomainName",
1947 v4dhcpParms.useUseDomainName))
1948 {
1949 return;
1950 }
1951 }
1952
1953 if (dhcpv6)
1954 {
1955 if (!json_util::readJson(*dhcpv6, res, "OperatingMode",
1956 v6dhcpParms.dhcpv6OperatingMode,
1957 "UseDNSServers", v6dhcpParms.useDNSServers,
1958 "UseNTPServers", v6dhcpParms.useNTPServers,
1959 "UseDomainName",
1960 v6dhcpParms.useUseDomainName))
1961 {
1962 return;
1963 }
Jennifer Leeda131a92019-04-24 15:13:55 -07001964 }
1965
Johnathan Mantey01784822019-06-18 12:44:21 -07001966 // Get single eth interface data, and call the below callback for
1967 // JSON preparation
Ed Tanous4a0cb852018-10-15 07:55:04 -07001968 getEthernetIfaceData(
Ed Tanous2c70f802020-09-28 14:29:23 -07001969 ifaceId,
1970 [this, asyncResp, ifaceId, hostname = std::move(hostname),
Joshi-Mansiab6554f2020-03-10 18:33:36 +05301971 fqdn = std::move(fqdn), macAddress = std::move(macAddress),
Ravi Tejad1d50812019-06-23 16:20:27 -05001972 ipv4StaticAddresses = std::move(ipv4StaticAddresses),
Ravi Teja9a6fc6f2019-04-16 02:43:13 -05001973 ipv6DefaultGateway = std::move(ipv6DefaultGateway),
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001974 ipv6StaticAddresses = std::move(ipv6StaticAddresses),
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001975 staticNameServers = std::move(staticNameServers),
1976 dhcpv4 = std::move(dhcpv4), dhcpv6 = std::move(dhcpv6),
1977 v4dhcpParms = std::move(v4dhcpParms),
Ed Tanousf23b7292020-10-15 09:41:17 -07001978 v6dhcpParms = std::move(v6dhcpParms), interfaceEnabled](
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001979 const bool& success, const EthernetInterfaceData& ethData,
1980 const boost::container::flat_set<IPv4AddressData>& ipv4Data,
1981 const boost::container::flat_set<IPv6AddressData>& ipv6Data) {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001982 if (!success)
1983 {
1984 // ... otherwise return error
1985 // TODO(Pawel)consider distinguish between non existing
1986 // object, and other errors
Sunitha Harishfda13ad2019-03-21 11:01:24 -05001987 messages::resourceNotFound(asyncResp->res,
Ed Tanous2c70f802020-09-28 14:29:23 -07001988 "Ethernet Interface", ifaceId);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001989 return;
1990 }
1991
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001992 if (dhcpv4 || dhcpv6)
1993 {
Ed Tanousf23b7292020-10-15 09:41:17 -07001994 handleDHCPPatch(ifaceId, ethData, v4dhcpParms, v6dhcpParms,
1995 asyncResp);
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -07001996 }
1997
Ed Tanous0627a2c2018-11-29 17:09:23 -08001998 if (hostname)
1999 {
2000 handleHostnamePatch(*hostname, asyncResp);
2001 }
2002
Joshi-Mansiab6554f2020-03-10 18:33:36 +05302003 if (fqdn)
2004 {
Ed Tanous2c70f802020-09-28 14:29:23 -07002005 handleFqdnPatch(ifaceId, *fqdn, asyncResp);
Joshi-Mansiab6554f2020-03-10 18:33:36 +05302006 }
2007
Ratan Guptad5776652019-03-03 08:47:22 +05302008 if (macAddress)
2009 {
Ed Tanous2c70f802020-09-28 14:29:23 -07002010 handleMACAddressPatch(ifaceId, *macAddress, asyncResp);
Ratan Guptad5776652019-03-03 08:47:22 +05302011 }
2012
Ravi Tejad1d50812019-06-23 16:20:27 -05002013 if (ipv4StaticAddresses)
2014 {
Ed Tanous537174c2018-12-10 15:09:31 -08002015 // TODO(ed) for some reason the capture of ipv4Addresses
Johnathan Mantey01784822019-06-18 12:44:21 -07002016 // above is returning a const value, not a non-const
2017 // value. This doesn't really work for us, as we need to
2018 // be able to efficiently move out the intermedia
2019 // nlohmann::json objects. This makes a copy of the
2020 // structure, and operates on that, but could be done
2021 // more efficiently
Ed Tanousf23b7292020-10-15 09:41:17 -07002022 nlohmann::json ipv4Static = *ipv4StaticAddresses;
Ed Tanous2c70f802020-09-28 14:29:23 -07002023 handleIPv4StaticPatch(ifaceId, ipv4Static, ipv4Data,
Ravi Tejad1d50812019-06-23 16:20:27 -05002024 asyncResp);
Ed Tanous0627a2c2018-11-29 17:09:23 -08002025 }
2026
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05002027 if (staticNameServers)
2028 {
Ed Tanous2c70f802020-09-28 14:29:23 -07002029 handleStaticNameServersPatch(ifaceId, *staticNameServers,
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -05002030 asyncResp);
2031 }
Ravi Teja9a6fc6f2019-04-16 02:43:13 -05002032
2033 if (ipv6DefaultGateway)
2034 {
2035 messages::propertyNotWritable(asyncResp->res,
2036 "IPv6DefaultGateway");
2037 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002038
2039 if (ipv6StaticAddresses)
2040 {
Ed Tanousf23b7292020-10-15 09:41:17 -07002041 nlohmann::json ipv6Static = *ipv6StaticAddresses;
Ed Tanous2c70f802020-09-28 14:29:23 -07002042 handleIPv6StaticAddressesPatch(ifaceId, ipv6Static,
Johnathan Mantey01784822019-06-18 12:44:21 -07002043 ipv6Data, asyncResp);
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002044 }
Johnathan Manteyeeedda22019-10-29 16:09:52 -07002045
2046 if (interfaceEnabled)
2047 {
2048 setEthernetInterfaceBoolProperty(
Ed Tanous2c70f802020-09-28 14:29:23 -07002049 ifaceId, "NICEnabled", *interfaceEnabled, asyncResp);
Johnathan Manteyeeedda22019-10-29 16:09:52 -07002050 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07002051 });
2052 }
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +01002053};
2054
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002055/**
Ed Tanous4a0cb852018-10-15 07:55:04 -07002056 * VlanNetworkInterface derived class for delivering VLANNetworkInterface
2057 * Schema
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002058 */
Ed Tanous1abe55e2018-09-05 08:30:59 -07002059class VlanNetworkInterface : public Node
2060{
2061 public:
2062 /*
2063 * Default Constructor
2064 */
Ed Tanous52cc1122020-07-18 13:51:21 -07002065 VlanNetworkInterface(App& app) :
Ed Tanous4a0cb852018-10-15 07:55:04 -07002066 Node(app,
Gunnar Mills7af91512020-04-14 22:16:57 -05002067 "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/<str>/",
Ed Tanous4a0cb852018-10-15 07:55:04 -07002068 std::string(), std::string())
Ed Tanous1abe55e2018-09-05 08:30:59 -07002069 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07002070 entityPrivileges = {
2071 {boost::beast::http::verb::get, {{"Login"}}},
2072 {boost::beast::http::verb::head, {{"Login"}}},
2073 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
2074 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
2075 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
2076 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002077 }
2078
Ed Tanous1abe55e2018-09-05 08:30:59 -07002079 private:
Ed Tanous81ce6092020-12-17 16:54:55 +00002080 void parseInterfaceData(nlohmann::json& jsonResponse,
2081 const std::string& parentIfaceId,
2082 const std::string& ifaceId,
Ed Tanouscb13a392020-07-25 19:02:03 +00002083 const EthernetInterfaceData& ethData)
Ed Tanous1abe55e2018-09-05 08:30:59 -07002084 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07002085 // Fill out obvious data...
Ed Tanous81ce6092020-12-17 16:54:55 +00002086 jsonResponse["Id"] = ifaceId;
2087 jsonResponse["@odata.id"] =
2088 "/redfish/v1/Managers/bmc/EthernetInterfaces/" + parentIfaceId +
2089 "/VLANs/" + ifaceId;
Ed Tanous1abe55e2018-09-05 08:30:59 -07002090
Ed Tanous81ce6092020-12-17 16:54:55 +00002091 jsonResponse["VLANEnable"] = true;
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002092 if (!ethData.vlan_id.empty())
Ed Tanous4a0cb852018-10-15 07:55:04 -07002093 {
Ed Tanous81ce6092020-12-17 16:54:55 +00002094 jsonResponse["VLANId"] = ethData.vlan_id.back();
Ed Tanous4a0cb852018-10-15 07:55:04 -07002095 }
Ed Tanousa434f2b2018-07-27 13:04:22 -07002096 }
2097
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002098 bool verifyNames(const std::string& parent, const std::string& iface)
Ed Tanous1abe55e2018-09-05 08:30:59 -07002099 {
2100 if (!boost::starts_with(iface, parent + "_"))
2101 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07002102 return false;
2103 }
Ed Tanous3174e4d2020-10-07 11:41:22 -07002104 return true;
Ed Tanous1abe55e2018-09-05 08:30:59 -07002105 }
2106
2107 /**
2108 * Functions triggers appropriate requests on DBus
2109 */
Ed Tanouscb13a392020-07-25 19:02:03 +00002110 void doGet(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002111 const std::vector<std::string>& params) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07002112 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07002113 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
2114 // TODO(Pawel) this shall be parameterized call (two params) to get
Ed Tanous1abe55e2018-09-05 08:30:59 -07002115 // EthernetInterfaces for any Manager, not only hardcoded 'openbmc'.
2116 // Check if there is required param, truly entering this shall be
2117 // impossible.
2118 if (params.size() != 2)
2119 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002120 messages::internalError(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002121 res.end();
Kowalski, Kamil927a5052018-07-03 14:16:46 +02002122 return;
Ed Tanous1abe55e2018-09-05 08:30:59 -07002123 }
Kowalski, Kamil927a5052018-07-03 14:16:46 +02002124
Ed Tanous2c70f802020-09-28 14:29:23 -07002125 const std::string& parentIfaceId = params[0];
2126 const std::string& ifaceId = params[1];
Ed Tanous0f74e642018-11-12 15:17:05 -08002127 res.jsonValue["@odata.type"] =
2128 "#VLanNetworkInterface.v1_1_0.VLanNetworkInterface";
Ed Tanous0f74e642018-11-12 15:17:05 -08002129 res.jsonValue["Name"] = "VLAN Network Interface";
Kowalski, Kamil927a5052018-07-03 14:16:46 +02002130
Ed Tanous2c70f802020-09-28 14:29:23 -07002131 if (!verifyNames(parentIfaceId, ifaceId))
Ed Tanous1abe55e2018-09-05 08:30:59 -07002132 {
2133 return;
2134 }
Kowalski, Kamil927a5052018-07-03 14:16:46 +02002135
Johnathan Mantey01784822019-06-18 12:44:21 -07002136 // Get single eth interface data, and call the below callback for
2137 // JSON preparation
Ed Tanous4a0cb852018-10-15 07:55:04 -07002138 getEthernetIfaceData(
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002139 params[1],
Ed Tanous2c70f802020-09-28 14:29:23 -07002140 [this, asyncResp, parentIfaceId{std::string(params[0])},
2141 ifaceId{std::string(params[1])}](
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002142 const bool& success, const EthernetInterfaceData& ethData,
Ed Tanouscb13a392020-07-25 19:02:03 +00002143 const boost::container::flat_set<IPv4AddressData>&,
2144 const boost::container::flat_set<IPv6AddressData>&) {
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002145 if (success && ethData.vlan_id.size() != 0)
Ed Tanous1abe55e2018-09-05 08:30:59 -07002146 {
Ed Tanous2c70f802020-09-28 14:29:23 -07002147 parseInterfaceData(asyncResp->res.jsonValue, parentIfaceId,
2148 ifaceId, ethData);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002149 }
2150 else
2151 {
2152 // ... otherwise return error
2153 // TODO(Pawel)consider distinguish between non existing
2154 // object, and other errors
Jason M. Billsf12894f2018-10-09 12:45:45 -07002155 messages::resourceNotFound(
Ed Tanous2c70f802020-09-28 14:29:23 -07002156 asyncResp->res, "VLAN Network Interface", ifaceId);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002157 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07002158 });
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002159 }
2160
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002161 void doPatch(crow::Response& res, const crow::Request& req,
2162 const std::vector<std::string>& params) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07002163 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07002164 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002165 if (params.size() != 2)
2166 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002167 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002168 return;
2169 }
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002170
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002171 const std::string& parentIfaceId = params[0];
2172 const std::string& ifaceId = params[1];
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002173
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002174 if (!verifyNames(parentIfaceId, ifaceId))
Ed Tanous1abe55e2018-09-05 08:30:59 -07002175 {
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002176 messages::resourceNotFound(asyncResp->res, "VLAN Network Interface",
2177 ifaceId);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002178 return;
2179 }
2180
Ed Tanous0627a2c2018-11-29 17:09:23 -08002181 bool vlanEnable = false;
Andrew Geissler38268fa2020-05-16 14:22:18 -05002182 uint32_t vlanId = 0;
Ed Tanous0627a2c2018-11-29 17:09:23 -08002183
2184 if (!json_util::readJson(req, res, "VLANEnable", vlanEnable, "VLANId",
2185 vlanId))
Ed Tanous1abe55e2018-09-05 08:30:59 -07002186 {
2187 return;
2188 }
2189
Johnathan Mantey01784822019-06-18 12:44:21 -07002190 // Get single eth interface data, and call the below callback for
2191 // JSON preparation
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002192 getEthernetIfaceData(
2193 params[1],
Ed Tanous271584a2019-07-09 16:24:22 -07002194 [asyncResp, parentIfaceId{std::string(params[0])},
Ed Tanouscb13a392020-07-25 19:02:03 +00002195 ifaceId{std::string(params[1])}, &vlanEnable,
2196 &vlanId](const bool& success, const EthernetInterfaceData& ethData,
2197 const boost::container::flat_set<IPv4AddressData>&,
2198 const boost::container::flat_set<IPv6AddressData>&) {
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002199 if (success && !ethData.vlan_id.empty())
Sunitha Harish08244d02019-04-01 03:57:25 -05002200 {
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002201 auto callback =
2202 [asyncResp](const boost::system::error_code ec) {
2203 if (ec)
2204 {
2205 messages::internalError(asyncResp->res);
2206 }
2207 };
2208
2209 if (vlanEnable == true)
2210 {
2211 crow::connections::systemBus->async_method_call(
2212 std::move(callback), "xyz.openbmc_project.Network",
2213 "/xyz/openbmc_project/network/" + ifaceId,
2214 "org.freedesktop.DBus.Properties", "Set",
2215 "xyz.openbmc_project.Network.VLAN", "Id",
2216 std::variant<uint32_t>(vlanId));
2217 }
2218 else
2219 {
2220 BMCWEB_LOG_DEBUG << "vlanEnable is false. Deleting the "
2221 "vlan interface";
2222 crow::connections::systemBus->async_method_call(
2223 std::move(callback), "xyz.openbmc_project.Network",
2224 std::string("/xyz/openbmc_project/network/") +
2225 ifaceId,
2226 "xyz.openbmc_project.Object.Delete", "Delete");
2227 }
Sunitha Harish08244d02019-04-01 03:57:25 -05002228 }
2229 else
2230 {
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002231 // TODO(Pawel)consider distinguish between non existing
2232 // object, and other errors
2233 messages::resourceNotFound(
2234 asyncResp->res, "VLAN Network Interface", ifaceId);
2235 return;
Sunitha Harish08244d02019-04-01 03:57:25 -05002236 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002237 });
Ed Tanous1abe55e2018-09-05 08:30:59 -07002238 }
2239
Ed Tanouscb13a392020-07-25 19:02:03 +00002240 void doDelete(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002241 const std::vector<std::string>& params) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07002242 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07002243 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002244 if (params.size() != 2)
2245 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002246 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002247 return;
2248 }
2249
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002250 const std::string& parentIfaceId = params[0];
2251 const std::string& ifaceId = params[1];
Ed Tanous1abe55e2018-09-05 08:30:59 -07002252
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002253 if (!verifyNames(parentIfaceId, ifaceId))
Ed Tanous1abe55e2018-09-05 08:30:59 -07002254 {
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002255 messages::resourceNotFound(asyncResp->res, "VLAN Network Interface",
2256 ifaceId);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002257 return;
2258 }
2259
Johnathan Mantey01784822019-06-18 12:44:21 -07002260 // Get single eth interface data, and call the below callback for
2261 // JSON preparation
Jason M. Billsf12894f2018-10-09 12:45:45 -07002262 getEthernetIfaceData(
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002263 params[1],
Ed Tanous271584a2019-07-09 16:24:22 -07002264 [asyncResp, parentIfaceId{std::string(params[0])},
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002265 ifaceId{std::string(params[1])}](
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002266 const bool& success, const EthernetInterfaceData& ethData,
Ed Tanouscb13a392020-07-25 19:02:03 +00002267 const boost::container::flat_set<IPv4AddressData>&,
2268 const boost::container::flat_set<IPv6AddressData>&) {
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002269 if (success && !ethData.vlan_id.empty())
Jason M. Billsf12894f2018-10-09 12:45:45 -07002270 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002271 auto callback =
2272 [asyncResp](const boost::system::error_code ec) {
2273 if (ec)
2274 {
2275 messages::internalError(asyncResp->res);
2276 }
2277 };
2278 crow::connections::systemBus->async_method_call(
2279 std::move(callback), "xyz.openbmc_project.Network",
2280 std::string("/xyz/openbmc_project/network/") + ifaceId,
2281 "xyz.openbmc_project.Object.Delete", "Delete");
2282 }
2283 else
2284 {
2285 // ... otherwise return error
2286 // TODO(Pawel)consider distinguish between non existing
2287 // object, and other errors
2288 messages::resourceNotFound(
2289 asyncResp->res, "VLAN Network Interface", ifaceId);
2290 }
2291 });
Ed Tanous1abe55e2018-09-05 08:30:59 -07002292 }
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002293};
2294
2295/**
2296 * VlanNetworkInterfaceCollection derived class for delivering
2297 * VLANNetworkInterface Collection Schema
2298 */
Ed Tanous1abe55e2018-09-05 08:30:59 -07002299class VlanNetworkInterfaceCollection : public Node
2300{
2301 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002302 VlanNetworkInterfaceCollection(App& app) :
Ed Tanous4a0cb852018-10-15 07:55:04 -07002303 Node(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/",
2304 std::string())
Ed Tanous1abe55e2018-09-05 08:30:59 -07002305 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07002306 entityPrivileges = {
2307 {boost::beast::http::verb::get, {{"Login"}}},
2308 {boost::beast::http::verb::head, {{"Login"}}},
2309 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
2310 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
2311 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
2312 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002313 }
2314
Ed Tanous1abe55e2018-09-05 08:30:59 -07002315 private:
2316 /**
2317 * Functions triggers appropriate requests on DBus
2318 */
Ed Tanouscb13a392020-07-25 19:02:03 +00002319 void doGet(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002320 const std::vector<std::string>& params) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07002321 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07002322 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002323 if (params.size() != 1)
2324 {
2325 // This means there is a problem with the router
Jason M. Billsf12894f2018-10-09 12:45:45 -07002326 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002327 return;
Ed Tanous8ceb2ec2018-08-13 11:11:56 -07002328 }
2329
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002330 const std::string& rootInterfaceName = params[0];
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002331
Ed Tanous4a0cb852018-10-15 07:55:04 -07002332 // Get eth interface list, and call the below callback for JSON
Ed Tanous1abe55e2018-09-05 08:30:59 -07002333 // preparation
Jason M. Billsf12894f2018-10-09 12:45:45 -07002334 getEthernetIfaceList(
Ed Tanous43b761d2019-02-13 20:10:56 -08002335 [asyncResp, rootInterfaceName{std::string(rootInterfaceName)}](
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002336 const bool& success,
Ed Tanous81ce6092020-12-17 16:54:55 +00002337 const boost::container::flat_set<std::string>& ifaceList) {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002338 if (!success)
Ed Tanous1abe55e2018-09-05 08:30:59 -07002339 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002340 messages::internalError(asyncResp->res);
2341 return;
Ed Tanous1abe55e2018-09-05 08:30:59 -07002342 }
Ed Tanous4c9afe42019-05-03 16:59:57 -07002343
Ed Tanous81ce6092020-12-17 16:54:55 +00002344 if (ifaceList.find(rootInterfaceName) == ifaceList.end())
Ed Tanous4c9afe42019-05-03 16:59:57 -07002345 {
2346 messages::resourceNotFound(asyncResp->res,
2347 "VLanNetworkInterfaceCollection",
2348 rootInterfaceName);
2349 return;
2350 }
2351
Ed Tanous0f74e642018-11-12 15:17:05 -08002352 asyncResp->res.jsonValue["@odata.type"] =
2353 "#VLanNetworkInterfaceCollection."
2354 "VLanNetworkInterfaceCollection";
Ed Tanous0f74e642018-11-12 15:17:05 -08002355 asyncResp->res.jsonValue["Name"] =
2356 "VLAN Network Interface Collection";
Ed Tanous4a0cb852018-10-15 07:55:04 -07002357
Ed Tanous2c70f802020-09-28 14:29:23 -07002358 nlohmann::json ifaceArray = nlohmann::json::array();
Jason M. Billsf12894f2018-10-09 12:45:45 -07002359
Ed Tanous81ce6092020-12-17 16:54:55 +00002360 for (const std::string& ifaceItem : ifaceList)
Jason M. Billsf12894f2018-10-09 12:45:45 -07002361 {
Ed Tanous2c70f802020-09-28 14:29:23 -07002362 if (boost::starts_with(ifaceItem, rootInterfaceName + "_"))
Jason M. Billsf12894f2018-10-09 12:45:45 -07002363 {
Ed Tanousf23b7292020-10-15 09:41:17 -07002364 std::string path =
2365 "/redfish/v1/Managers/bmc/EthernetInterfaces/";
2366 path += rootInterfaceName;
2367 path += "/VLANs/";
2368 path += ifaceItem;
2369 ifaceArray.push_back({{"@odata.id", std::move(path)}});
Jason M. Billsf12894f2018-10-09 12:45:45 -07002370 }
2371 }
2372
Jason M. Billsf12894f2018-10-09 12:45:45 -07002373 asyncResp->res.jsonValue["Members@odata.count"] =
Ed Tanous2c70f802020-09-28 14:29:23 -07002374 ifaceArray.size();
2375 asyncResp->res.jsonValue["Members"] = std::move(ifaceArray);
Jason M. Billsf12894f2018-10-09 12:45:45 -07002376 asyncResp->res.jsonValue["@odata.id"] =
2377 "/redfish/v1/Managers/bmc/EthernetInterfaces/" +
2378 rootInterfaceName + "/VLANs";
2379 });
Ed Tanous1abe55e2018-09-05 08:30:59 -07002380 }
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002381
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002382 void doPost(crow::Response& res, const crow::Request& req,
2383 const std::vector<std::string>& params) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07002384 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07002385 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002386 if (params.size() != 1)
2387 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002388 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002389 return;
2390 }
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002391 bool vlanEnable = false;
Ed Tanous0627a2c2018-11-29 17:09:23 -08002392 uint32_t vlanId = 0;
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002393 if (!json_util::readJson(req, res, "VLANId", vlanId, "VLANEnable",
2394 vlanEnable))
Ed Tanous1abe55e2018-09-05 08:30:59 -07002395 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07002396 return;
2397 }
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002398 // Need both vlanId and vlanEnable to service this request
2399 if (!vlanId)
2400 {
2401 messages::propertyMissing(asyncResp->res, "VLANId");
2402 }
2403 if (!vlanEnable)
2404 {
2405 messages::propertyMissing(asyncResp->res, "VLANEnable");
2406 }
Ed Tanous271584a2019-07-09 16:24:22 -07002407 if (static_cast<bool>(vlanId) ^ vlanEnable)
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002408 {
2409 return;
2410 }
2411
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002412 const std::string& rootInterfaceName = params[0];
Ed Tanous4a0cb852018-10-15 07:55:04 -07002413 auto callback = [asyncResp](const boost::system::error_code ec) {
2414 if (ec)
2415 {
2416 // TODO(ed) make more consistent error messages based on
2417 // phosphor-network responses
Jason M. Billsf12894f2018-10-09 12:45:45 -07002418 messages::internalError(asyncResp->res);
Ed Tanous4a0cb852018-10-15 07:55:04 -07002419 return;
2420 }
Jason M. Billsf12894f2018-10-09 12:45:45 -07002421 messages::created(asyncResp->res);
Ed Tanous4a0cb852018-10-15 07:55:04 -07002422 };
2423 crow::connections::systemBus->async_method_call(
2424 std::move(callback), "xyz.openbmc_project.Network",
2425 "/xyz/openbmc_project/network",
2426 "xyz.openbmc_project.Network.VLAN.Create", "VLAN",
Ed Tanous0627a2c2018-11-29 17:09:23 -08002427 rootInterfaceName, vlanId);
Ed Tanous1abe55e2018-09-05 08:30:59 -07002428 }
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002429};
Ed Tanous1abe55e2018-09-05 08:30:59 -07002430} // namespace redfish