blob: 411659d248ac74c3e8105ba5fd6dae216f5a44b6 [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
Willy Tu13451e32023-05-24 16:08:18 -070018#include "bmcweb_config.h"
19
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080020#include "app.hpp"
21#include "dbus_singleton.hpp"
George Liu7a1dbc42022-12-07 16:03:22 +080022#include "dbus_utility.hpp"
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080023#include "error_messages.hpp"
24#include "health.hpp"
Ed Tanous2c5875a2023-05-15 09:56:06 -070025#include "human_sort.hpp"
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080026#include "query.hpp"
27#include "registries/privilege_registry.hpp"
Ed Tanous033f1e42022-08-15 09:47:37 -070028#include "utils/ip_utils.hpp"
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080029#include "utils/json_utils.hpp"
Ed Tanous033f1e42022-08-15 09:47:37 -070030
Ed Tanous11ba3972022-07-11 09:50:41 -070031#include <boost/algorithm/string/classification.hpp>
32#include <boost/algorithm/string/split.hpp>
Ed Tanousef4c65b2023-04-24 15:28:50 -070033#include <boost/url/format.hpp>
Gunnar Mills1214b7e2020-06-04 10:11:30 -050034
George Liu7a1dbc42022-12-07 16:03:22 +080035#include <array>
Ed Tanousa24526d2018-12-10 15:17:59 -080036#include <optional>
Joshi-Mansiab6554f2020-03-10 18:33:36 +053037#include <regex>
George Liu7a1dbc42022-12-07 16:03:22 +080038#include <string_view>
Ed Tanous77179532023-02-28 10:45:28 -080039#include <vector>
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010040
Ed Tanous1abe55e2018-09-05 08:30:59 -070041namespace redfish
42{
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010043
Ed Tanous4a0cb852018-10-15 07:55:04 -070044enum class LinkType
45{
46 Local,
47 Global
48};
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010049
50/**
51 * Structure for keeping IPv4 data required by Redfish
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010052 */
Ed Tanous1abe55e2018-09-05 08:30:59 -070053struct IPv4AddressData
54{
55 std::string id;
Ed Tanous4a0cb852018-10-15 07:55:04 -070056 std::string address;
57 std::string domain;
58 std::string gateway;
Ed Tanous1abe55e2018-09-05 08:30:59 -070059 std::string netmask;
60 std::string origin;
Ed Tanous77179532023-02-28 10:45:28 -080061 LinkType linktype{};
62 bool isActive{};
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010063};
64
65/**
Ravi Tejae48c0fc2019-04-16 08:37:20 -050066 * Structure for keeping IPv6 data required by Redfish
67 */
68struct IPv6AddressData
69{
70 std::string id;
71 std::string address;
72 std::string origin;
Ed Tanous77179532023-02-28 10:45:28 -080073 uint8_t prefixLength = 0;
Ravi Tejae48c0fc2019-04-16 08:37:20 -050074};
75/**
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010076 * Structure for keeping basic single Ethernet Interface information
77 * available from DBus
78 */
Ed Tanous1abe55e2018-09-05 08:30:59 -070079struct EthernetInterfaceData
80{
Ed Tanous4a0cb852018-10-15 07:55:04 -070081 uint32_t speed;
Tejas Patil35fb5312021-09-20 15:35:20 +053082 size_t mtuSize;
Jiaqing Zhao82695a52022-04-14 15:15:59 +080083 bool autoNeg;
84 bool dnsEnabled;
85 bool ntpEnabled;
86 bool hostNameEnabled;
Johnathan Manteyaa05fb22020-01-08 12:08:44 -080087 bool linkUp;
Johnathan Manteyeeedda22019-10-29 16:09:52 -070088 bool nicEnabled;
Jiaqing Zhao82695a52022-04-14 15:15:59 +080089 std::string dhcpEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -070090 std::string operatingMode;
Jiaqing Zhao82695a52022-04-14 15:15:59 +080091 std::string hostName;
92 std::string defaultGateway;
93 std::string ipv6DefaultGateway;
94 std::string macAddress;
Jiaqing Zhao17e22022022-04-14 18:58:06 +080095 std::optional<uint32_t> vlanId;
manojkiran.eda@gmail.com0f6efdc2019-10-03 04:53:44 -050096 std::vector<std::string> nameServers;
97 std::vector<std::string> staticNameServers;
Jennifer Leed24bfc72019-03-05 13:03:37 -080098 std::vector<std::string> domainnames;
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010099};
100
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700101struct DHCPParameters
102{
103 std::optional<bool> dhcpv4Enabled;
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800104 std::optional<bool> useDnsServers;
105 std::optional<bool> useNtpServers;
106 std::optional<bool> useDomainName;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700107 std::optional<std::string> dhcpv6OperatingMode;
108};
109
Ed Tanous4a0cb852018-10-15 07:55:04 -0700110// Helper function that changes bits netmask notation (i.e. /24)
111// into full dot notation
112inline std::string getNetmask(unsigned int bits)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700113{
Ed Tanous4a0cb852018-10-15 07:55:04 -0700114 uint32_t value = 0xffffffff << (32 - bits);
115 std::string netmask = std::to_string((value >> 24) & 0xff) + "." +
116 std::to_string((value >> 16) & 0xff) + "." +
117 std::to_string((value >> 8) & 0xff) + "." +
118 std::to_string(value & 0xff);
119 return netmask;
120}
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +0100121
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800122inline bool translateDhcpEnabledToBool(const std::string& inputDHCP,
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700123 bool isIPv4)
124{
125 if (isIPv4)
126 {
127 return (
128 (inputDHCP ==
129 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v4") ||
130 (inputDHCP ==
131 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.both"));
132 }
133 return ((inputDHCP ==
134 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v6") ||
135 (inputDHCP ==
136 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.both"));
137}
138
Ed Tanous2c70f802020-09-28 14:29:23 -0700139inline std::string getDhcpEnabledEnumeration(bool isIPv4, bool isIPv6)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700140{
141 if (isIPv4 && isIPv6)
142 {
143 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.both";
144 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700145 if (isIPv4)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700146 {
147 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v4";
148 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700149 if (isIPv6)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700150 {
151 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v6";
152 }
153 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.none";
154}
155
Ed Tanous4a0cb852018-10-15 07:55:04 -0700156inline std::string
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500157 translateAddressOriginDbusToRedfish(const std::string& inputOrigin,
Ed Tanous4a0cb852018-10-15 07:55:04 -0700158 bool isIPv4)
159{
160 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.Static")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700161 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700162 return "Static";
163 }
164 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.LinkLocal")
165 {
166 if (isIPv4)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700167 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700168 return "IPv4LinkLocal";
169 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700170 return "LinkLocal";
Ed Tanous4a0cb852018-10-15 07:55:04 -0700171 }
172 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.DHCP")
173 {
174 if (isIPv4)
175 {
176 return "DHCP";
177 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700178 return "DHCPv6";
Ed Tanous4a0cb852018-10-15 07:55:04 -0700179 }
180 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.SLAAC")
181 {
182 return "SLAAC";
183 }
184 return "";
185}
186
Ed Tanous02cad962022-06-30 16:50:15 -0700187inline bool extractEthernetInterfaceData(
188 const std::string& ethifaceId,
189 const dbus::utility::ManagedObjectType& dbusData,
190 EthernetInterfaceData& ethData)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700191{
Ed Tanous4c9afe42019-05-03 16:59:57 -0700192 bool idFound = false;
Ed Tanous02cad962022-06-30 16:50:15 -0700193 for (const auto& objpath : dbusData)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700194 {
Ed Tanous02cad962022-06-30 16:50:15 -0700195 for (const auto& ifacePair : objpath.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700196 {
Ed Tanous81ce6092020-12-17 16:54:55 +0000197 if (objpath.first == "/xyz/openbmc_project/network/" + ethifaceId)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700198 {
Ed Tanous4c9afe42019-05-03 16:59:57 -0700199 idFound = true;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700200 if (ifacePair.first == "xyz.openbmc_project.Network.MACAddress")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700201 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500202 for (const auto& propertyPair : ifacePair.second)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700203 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700204 if (propertyPair.first == "MACAddress")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700205 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500206 const std::string* mac =
Ed Tanousabf2add2019-01-22 16:40:12 -0800207 std::get_if<std::string>(&propertyPair.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700208 if (mac != nullptr)
209 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800210 ethData.macAddress = *mac;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700211 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700212 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700213 }
214 }
215 else if (ifacePair.first == "xyz.openbmc_project.Network.VLAN")
216 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500217 for (const auto& propertyPair : ifacePair.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700218 {
219 if (propertyPair.first == "Id")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700220 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500221 const uint32_t* id =
Ed Tanousabf2add2019-01-22 16:40:12 -0800222 std::get_if<uint32_t>(&propertyPair.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700223 if (id != nullptr)
224 {
Jiaqing Zhao17e22022022-04-14 18:58:06 +0800225 ethData.vlanId = *id;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700226 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700227 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700228 }
229 }
230 else if (ifacePair.first ==
231 "xyz.openbmc_project.Network.EthernetInterface")
232 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500233 for (const auto& propertyPair : ifacePair.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700234 {
235 if (propertyPair.first == "AutoNeg")
236 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700237 const bool* autoNeg =
Ed Tanousabf2add2019-01-22 16:40:12 -0800238 std::get_if<bool>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700239 if (autoNeg != nullptr)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700240 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800241 ethData.autoNeg = *autoNeg;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700242 }
243 }
244 else if (propertyPair.first == "Speed")
245 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500246 const uint32_t* speed =
Ed Tanousabf2add2019-01-22 16:40:12 -0800247 std::get_if<uint32_t>(&propertyPair.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700248 if (speed != nullptr)
249 {
250 ethData.speed = *speed;
251 }
252 }
Tejas Patil35fb5312021-09-20 15:35:20 +0530253 else if (propertyPair.first == "MTU")
254 {
255 const uint32_t* mtuSize =
256 std::get_if<uint32_t>(&propertyPair.second);
257 if (mtuSize != nullptr)
258 {
259 ethData.mtuSize = *mtuSize;
260 }
261 }
Johnathan Manteyaa05fb22020-01-08 12:08:44 -0800262 else if (propertyPair.first == "LinkUp")
263 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500264 const bool* linkUp =
Johnathan Manteyaa05fb22020-01-08 12:08:44 -0800265 std::get_if<bool>(&propertyPair.second);
266 if (linkUp != nullptr)
267 {
268 ethData.linkUp = *linkUp;
269 }
270 }
Johnathan Manteyeeedda22019-10-29 16:09:52 -0700271 else if (propertyPair.first == "NICEnabled")
272 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500273 const bool* nicEnabled =
Johnathan Manteyeeedda22019-10-29 16:09:52 -0700274 std::get_if<bool>(&propertyPair.second);
275 if (nicEnabled != nullptr)
276 {
277 ethData.nicEnabled = *nicEnabled;
278 }
279 }
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -0500280 else if (propertyPair.first == "Nameservers")
Ed Tanous4a0cb852018-10-15 07:55:04 -0700281 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500282 const std::vector<std::string>* nameservers =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500283 std::get_if<std::vector<std::string>>(
Ed Tanous029573d2019-02-01 10:57:49 -0800284 &propertyPair.second);
285 if (nameservers != nullptr)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700286 {
Ed Tanousf23b7292020-10-15 09:41:17 -0700287 ethData.nameServers = *nameservers;
manojkiran.eda@gmail.com0f6efdc2019-10-03 04:53:44 -0500288 }
289 }
290 else if (propertyPair.first == "StaticNameServers")
291 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500292 const std::vector<std::string>* staticNameServers =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500293 std::get_if<std::vector<std::string>>(
manojkiran.eda@gmail.com0f6efdc2019-10-03 04:53:44 -0500294 &propertyPair.second);
295 if (staticNameServers != nullptr)
296 {
Ed Tanousf23b7292020-10-15 09:41:17 -0700297 ethData.staticNameServers = *staticNameServers;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700298 }
299 }
manojkiraneda2a133282019-02-19 13:09:43 +0530300 else if (propertyPair.first == "DHCPEnabled")
301 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700302 const std::string* dhcpEnabled =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700303 std::get_if<std::string>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700304 if (dhcpEnabled != nullptr)
manojkiraneda2a133282019-02-19 13:09:43 +0530305 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800306 ethData.dhcpEnabled = *dhcpEnabled;
manojkiraneda2a133282019-02-19 13:09:43 +0530307 }
308 }
Jennifer Leed24bfc72019-03-05 13:03:37 -0800309 else if (propertyPair.first == "DomainName")
310 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500311 const std::vector<std::string>* domainNames =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500312 std::get_if<std::vector<std::string>>(
Jennifer Leed24bfc72019-03-05 13:03:37 -0800313 &propertyPair.second);
314 if (domainNames != nullptr)
315 {
Ed Tanousf23b7292020-10-15 09:41:17 -0700316 ethData.domainnames = *domainNames;
Jennifer Leed24bfc72019-03-05 13:03:37 -0800317 }
318 }
Ravi Teja9010ec22019-08-01 23:30:25 -0500319 else if (propertyPair.first == "DefaultGateway")
320 {
321 const std::string* defaultGateway =
322 std::get_if<std::string>(&propertyPair.second);
323 if (defaultGateway != nullptr)
324 {
325 std::string defaultGatewayStr = *defaultGateway;
326 if (defaultGatewayStr.empty())
327 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800328 ethData.defaultGateway = "0.0.0.0";
Ravi Teja9010ec22019-08-01 23:30:25 -0500329 }
330 else
331 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800332 ethData.defaultGateway = defaultGatewayStr;
Ravi Teja9010ec22019-08-01 23:30:25 -0500333 }
334 }
335 }
336 else if (propertyPair.first == "DefaultGateway6")
337 {
338 const std::string* defaultGateway6 =
339 std::get_if<std::string>(&propertyPair.second);
340 if (defaultGateway6 != nullptr)
341 {
342 std::string defaultGateway6Str =
343 *defaultGateway6;
344 if (defaultGateway6Str.empty())
345 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800346 ethData.ipv6DefaultGateway =
Ravi Teja9010ec22019-08-01 23:30:25 -0500347 "0:0:0:0:0:0:0:0";
348 }
349 else
350 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800351 ethData.ipv6DefaultGateway =
Ravi Teja9010ec22019-08-01 23:30:25 -0500352 defaultGateway6Str;
353 }
354 }
355 }
Ed Tanous029573d2019-02-01 10:57:49 -0800356 }
357 }
358 }
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700359
Jian Zhang1e3f85e2022-12-13 13:50:35 +0800360 if (objpath.first == "/xyz/openbmc_project/network/dhcp")
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700361 {
362 if (ifacePair.first ==
363 "xyz.openbmc_project.Network.DHCPConfiguration")
364 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500365 for (const auto& propertyPair : ifacePair.second)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700366 {
367 if (propertyPair.first == "DNSEnabled")
368 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700369 const bool* dnsEnabled =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700370 std::get_if<bool>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700371 if (dnsEnabled != nullptr)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700372 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800373 ethData.dnsEnabled = *dnsEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700374 }
375 }
376 else if (propertyPair.first == "NTPEnabled")
377 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700378 const bool* ntpEnabled =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700379 std::get_if<bool>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700380 if (ntpEnabled != nullptr)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700381 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800382 ethData.ntpEnabled = *ntpEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700383 }
384 }
385 else if (propertyPair.first == "HostNameEnabled")
386 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700387 const bool* hostNameEnabled =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700388 std::get_if<bool>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700389 if (hostNameEnabled != nullptr)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700390 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800391 ethData.hostNameEnabled = *hostNameEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700392 }
393 }
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700394 }
395 }
396 }
Ed Tanous029573d2019-02-01 10:57:49 -0800397 // System configuration shows up in the global namespace, so no need
398 // to check eth number
399 if (ifacePair.first ==
400 "xyz.openbmc_project.Network.SystemConfiguration")
401 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500402 for (const auto& propertyPair : ifacePair.second)
Ed Tanous029573d2019-02-01 10:57:49 -0800403 {
404 if (propertyPair.first == "HostName")
405 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500406 const std::string* hostname =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500407 std::get_if<std::string>(&propertyPair.second);
Ed Tanous029573d2019-02-01 10:57:49 -0800408 if (hostname != nullptr)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700409 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800410 ethData.hostName = *hostname;
Ed Tanous029573d2019-02-01 10:57:49 -0800411 }
412 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700413 }
414 }
415 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700416 }
Ed Tanous4c9afe42019-05-03 16:59:57 -0700417 return idFound;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700418}
419
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500420// Helper function that extracts data for single ethernet ipv6 address
Ed Tanous77179532023-02-28 10:45:28 -0800421inline void extractIPV6Data(const std::string& ethifaceId,
422 const dbus::utility::ManagedObjectType& dbusData,
423 std::vector<IPv6AddressData>& ipv6Config)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500424{
Patrick Williams89492a12023-05-10 07:51:34 -0500425 const std::string ipPathStart = "/xyz/openbmc_project/network/" +
426 ethifaceId;
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500427
428 // Since there might be several IPv6 configurations aligned with
429 // single ethernet interface, loop over all of them
Ed Tanous81ce6092020-12-17 16:54:55 +0000430 for (const auto& objpath : dbusData)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500431 {
432 // Check if proper pattern for object path appears
Tony Lee353163e2022-11-23 11:06:10 +0800433 if (objpath.first.str.starts_with(ipPathStart + "/"))
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500434 {
Ed Tanous9eb808c2022-01-25 10:19:23 -0800435 for (const auto& interface : objpath.second)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500436 {
437 if (interface.first == "xyz.openbmc_project.Network.IP")
438 {
Tony Lee353163e2022-11-23 11:06:10 +0800439 auto type = std::find_if(interface.second.begin(),
440 interface.second.end(),
441 [](const auto& property) {
442 return property.first == "Type";
443 });
444 if (type == interface.second.end())
445 {
446 continue;
447 }
448
449 const std::string* typeStr =
450 std::get_if<std::string>(&type->second);
451
452 if (typeStr == nullptr ||
453 (*typeStr !=
454 "xyz.openbmc_project.Network.IP.Protocol.IPv6"))
455 {
456 continue;
457 }
458
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500459 // Instance IPv6AddressData structure, and set as
460 // appropriate
Ed Tanous77179532023-02-28 10:45:28 -0800461 IPv6AddressData& ipv6Address = ipv6Config.emplace_back();
Ed Tanous2c70f802020-09-28 14:29:23 -0700462 ipv6Address.id =
Tony Lee353163e2022-11-23 11:06:10 +0800463 objpath.first.str.substr(ipPathStart.size());
Ed Tanous9eb808c2022-01-25 10:19:23 -0800464 for (const auto& property : interface.second)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500465 {
466 if (property.first == "Address")
467 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500468 const std::string* address =
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500469 std::get_if<std::string>(&property.second);
470 if (address != nullptr)
471 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700472 ipv6Address.address = *address;
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500473 }
474 }
475 else if (property.first == "Origin")
476 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500477 const std::string* origin =
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500478 std::get_if<std::string>(&property.second);
479 if (origin != nullptr)
480 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700481 ipv6Address.origin =
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500482 translateAddressOriginDbusToRedfish(*origin,
483 false);
484 }
485 }
486 else if (property.first == "PrefixLength")
487 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500488 const uint8_t* prefix =
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500489 std::get_if<uint8_t>(&property.second);
490 if (prefix != nullptr)
491 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700492 ipv6Address.prefixLength = *prefix;
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500493 }
494 }
Asmitha Karunanithi889ff692021-11-29 08:43:30 -0600495 else if (property.first == "Type" ||
496 property.first == "Gateway")
497 {
498 // Type & Gateway is not used
499 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500500 else
501 {
502 BMCWEB_LOG_ERROR
503 << "Got extra property: " << property.first
504 << " on the " << objpath.first.str << " object";
505 }
506 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500507 }
508 }
509 }
510 }
511}
512
Ed Tanous4a0cb852018-10-15 07:55:04 -0700513// Helper function that extracts data for single ethernet ipv4 address
Ed Tanous77179532023-02-28 10:45:28 -0800514inline void extractIPData(const std::string& ethifaceId,
515 const dbus::utility::ManagedObjectType& dbusData,
516 std::vector<IPv4AddressData>& ipv4Config)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700517{
Patrick Williams89492a12023-05-10 07:51:34 -0500518 const std::string ipPathStart = "/xyz/openbmc_project/network/" +
519 ethifaceId;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700520
521 // Since there might be several IPv4 configurations aligned with
522 // single ethernet interface, loop over all of them
Ed Tanous81ce6092020-12-17 16:54:55 +0000523 for (const auto& objpath : dbusData)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700524 {
525 // Check if proper pattern for object path appears
Tony Lee353163e2022-11-23 11:06:10 +0800526 if (objpath.first.str.starts_with(ipPathStart + "/"))
Ed Tanous4a0cb852018-10-15 07:55:04 -0700527 {
Ed Tanous9eb808c2022-01-25 10:19:23 -0800528 for (const auto& interface : objpath.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700529 {
530 if (interface.first == "xyz.openbmc_project.Network.IP")
531 {
Tony Lee353163e2022-11-23 11:06:10 +0800532 auto type = std::find_if(interface.second.begin(),
533 interface.second.end(),
534 [](const auto& property) {
535 return property.first == "Type";
536 });
537 if (type == interface.second.end())
538 {
539 continue;
540 }
541
542 const std::string* typeStr =
543 std::get_if<std::string>(&type->second);
544
545 if (typeStr == nullptr ||
546 (*typeStr !=
547 "xyz.openbmc_project.Network.IP.Protocol.IPv4"))
548 {
549 continue;
550 }
551
Ed Tanous4a0cb852018-10-15 07:55:04 -0700552 // Instance IPv4AddressData structure, and set as
553 // appropriate
Ed Tanous77179532023-02-28 10:45:28 -0800554 IPv4AddressData& ipv4Address = ipv4Config.emplace_back();
Ed Tanous2c70f802020-09-28 14:29:23 -0700555 ipv4Address.id =
Tony Lee353163e2022-11-23 11:06:10 +0800556 objpath.first.str.substr(ipPathStart.size());
Ed Tanous9eb808c2022-01-25 10:19:23 -0800557 for (const auto& property : interface.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700558 {
559 if (property.first == "Address")
560 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500561 const std::string* address =
Ed Tanousabf2add2019-01-22 16:40:12 -0800562 std::get_if<std::string>(&property.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700563 if (address != nullptr)
564 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700565 ipv4Address.address = *address;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700566 }
567 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700568 else if (property.first == "Origin")
569 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500570 const std::string* origin =
Ed Tanousabf2add2019-01-22 16:40:12 -0800571 std::get_if<std::string>(&property.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700572 if (origin != nullptr)
573 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700574 ipv4Address.origin =
Ed Tanous4a0cb852018-10-15 07:55:04 -0700575 translateAddressOriginDbusToRedfish(*origin,
576 true);
577 }
578 }
579 else if (property.first == "PrefixLength")
580 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500581 const uint8_t* mask =
Ed Tanousabf2add2019-01-22 16:40:12 -0800582 std::get_if<uint8_t>(&property.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700583 if (mask != nullptr)
584 {
585 // convert it to the string
Ed Tanous2c70f802020-09-28 14:29:23 -0700586 ipv4Address.netmask = getNetmask(*mask);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700587 }
588 }
Asmitha Karunanithi889ff692021-11-29 08:43:30 -0600589 else if (property.first == "Type" ||
590 property.first == "Gateway")
591 {
592 // Type & Gateway is not used
593 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700594 else
595 {
596 BMCWEB_LOG_ERROR
597 << "Got extra property: " << property.first
598 << " on the " << objpath.first.str << " object";
599 }
600 }
601 // Check if given address is local, or global
Ed Tanous2c70f802020-09-28 14:29:23 -0700602 ipv4Address.linktype =
Ed Tanous11ba3972022-07-11 09:50:41 -0700603 ipv4Address.address.starts_with("169.254.")
Johnathan Mantey18659d12019-06-07 10:26:29 -0700604 ? LinkType::Local
605 : LinkType::Global;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700606 }
607 }
608 }
609 }
610}
611
612/**
Johnathan Mantey01784822019-06-18 12:44:21 -0700613 * @brief Deletes given IPv4 interface
Ed Tanous4a0cb852018-10-15 07:55:04 -0700614 *
615 * @param[in] ifaceId Id of interface whose IP should be deleted
Ed Tanous4a0cb852018-10-15 07:55:04 -0700616 * @param[in] ipHash DBus Hash id of IP that should be deleted
617 * @param[io] asyncResp Response object that will be returned to client
618 *
619 * @return None
620 */
Ravi Teja9c5e5852023-02-26 21:33:52 -0600621inline void deleteIPAddress(const std::string& ifaceId,
622 const std::string& ipHash,
623 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700624{
625 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800626 [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700627 if (ec)
628 {
629 messages::internalError(asyncResp->res);
630 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700631 },
632 "xyz.openbmc_project.Network",
Ravi Teja9c5e5852023-02-26 21:33:52 -0600633 "/xyz/openbmc_project/network/" + ifaceId + ipHash,
Ed Tanous4a0cb852018-10-15 07:55:04 -0700634 "xyz.openbmc_project.Object.Delete", "Delete");
635}
Ed Tanous1abe55e2018-09-05 08:30:59 -0700636
Gunnar Mills244b6d52021-04-12 15:44:23 -0500637inline void updateIPv4DefaultGateway(
638 const std::string& ifaceId, const std::string& gateway,
639 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ravi Teja9010ec22019-08-01 23:30:25 -0500640{
641 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800642 [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700643 if (ec)
644 {
645 messages::internalError(asyncResp->res);
646 return;
647 }
648 asyncResp->res.result(boost::beast::http::status::no_content);
Ravi Teja9010ec22019-08-01 23:30:25 -0500649 },
650 "xyz.openbmc_project.Network",
651 "/xyz/openbmc_project/network/" + ifaceId,
652 "org.freedesktop.DBus.Properties", "Set",
653 "xyz.openbmc_project.Network.EthernetInterface", "DefaultGateway",
Ed Tanous168e20c2021-12-13 14:39:53 -0800654 dbus::utility::DbusVariantType(gateway));
Ravi Teja9010ec22019-08-01 23:30:25 -0500655}
Ed Tanous4a0cb852018-10-15 07:55:04 -0700656/**
Johnathan Mantey01784822019-06-18 12:44:21 -0700657 * @brief Creates a static IPv4 entry
Ed Tanous4a0cb852018-10-15 07:55:04 -0700658 *
Johnathan Mantey01784822019-06-18 12:44:21 -0700659 * @param[in] ifaceId Id of interface upon which to create the IPv4 entry
660 * @param[in] prefixLength IPv4 prefix syntax for the subnet mask
661 * @param[in] gateway IPv4 address of this interfaces gateway
662 * @param[in] address IPv4 address to assign to this interface
663 * @param[io] asyncResp Response object that will be returned to client
Ed Tanous4a0cb852018-10-15 07:55:04 -0700664 *
665 * @return None
666 */
Ed Tanouscb13a392020-07-25 19:02:03 +0000667inline void createIPv4(const std::string& ifaceId, uint8_t prefixLength,
668 const std::string& gateway, const std::string& address,
zhanghch058d1b46d2021-04-01 11:18:24 +0800669 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700670{
Ed Tanous002d39b2022-05-31 08:59:27 -0700671 auto createIpHandler =
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800672 [asyncResp, ifaceId, gateway](const boost::system::error_code& ec) {
Ravi Teja9010ec22019-08-01 23:30:25 -0500673 if (ec)
674 {
675 messages::internalError(asyncResp->res);
676 return;
677 }
678 updateIPv4DefaultGateway(ifaceId, gateway, asyncResp);
679 };
680
Ed Tanous4a0cb852018-10-15 07:55:04 -0700681 crow::connections::systemBus->async_method_call(
Ravi Teja9010ec22019-08-01 23:30:25 -0500682 std::move(createIpHandler), "xyz.openbmc_project.Network",
Ed Tanous4a0cb852018-10-15 07:55:04 -0700683 "/xyz/openbmc_project/network/" + ifaceId,
684 "xyz.openbmc_project.Network.IP.Create", "IP",
Johnathan Mantey01784822019-06-18 12:44:21 -0700685 "xyz.openbmc_project.Network.IP.Protocol.IPv4", address, prefixLength,
Ed Tanous4a0cb852018-10-15 07:55:04 -0700686 gateway);
687}
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500688
689/**
Johnathan Mantey01784822019-06-18 12:44:21 -0700690 * @brief Deletes the IPv6 entry for this interface and creates a replacement
691 * static IPv6 entry
692 *
693 * @param[in] ifaceId Id of interface upon which to create the IPv6 entry
694 * @param[in] id The unique hash entry identifying the DBus entry
695 * @param[in] prefixLength IPv6 prefix syntax for the subnet mask
696 * @param[in] address IPv6 address to assign to this interface
697 * @param[io] asyncResp Response object that will be returned to client
698 *
699 * @return None
700 */
Ravi Teja9c5e5852023-02-26 21:33:52 -0600701
702enum class IpVersion
703{
704 IpV4,
705 IpV6
706};
707
708inline void deleteAndCreateIPAddress(
709 IpVersion version, const std::string& ifaceId, const std::string& id,
710 uint8_t prefixLength, const std::string& address,
711 const std::string& gateway,
712 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Johnathan Mantey01784822019-06-18 12:44:21 -0700713{
714 crow::connections::systemBus->async_method_call(
Ravi Teja9c5e5852023-02-26 21:33:52 -0600715 [asyncResp, version, ifaceId, address, prefixLength,
716 gateway](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700717 if (ec)
718 {
719 messages::internalError(asyncResp->res);
720 }
Ravi Teja9c5e5852023-02-26 21:33:52 -0600721 std::string protocol = "xyz.openbmc_project.Network.IP.Protocol.";
722 protocol += version == IpVersion::IpV4 ? "IPv4" : "IPv6";
Ed Tanous002d39b2022-05-31 08:59:27 -0700723 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800724 [asyncResp](const boost::system::error_code& ec2) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700725 if (ec2)
Johnathan Mantey01784822019-06-18 12:44:21 -0700726 {
727 messages::internalError(asyncResp->res);
728 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700729 },
730 "xyz.openbmc_project.Network",
731 "/xyz/openbmc_project/network/" + ifaceId,
Ravi Teja9c5e5852023-02-26 21:33:52 -0600732 "xyz.openbmc_project.Network.IP.Create", "IP", protocol, address,
733 prefixLength, gateway);
Johnathan Mantey01784822019-06-18 12:44:21 -0700734 },
735 "xyz.openbmc_project.Network",
Ravi Teja9c5e5852023-02-26 21:33:52 -0600736 "/xyz/openbmc_project/network/" + ifaceId + id,
Johnathan Mantey01784822019-06-18 12:44:21 -0700737 "xyz.openbmc_project.Object.Delete", "Delete");
738}
739
740/**
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500741 * @brief Creates IPv6 with given data
742 *
743 * @param[in] ifaceId Id of interface whose IP should be added
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500744 * @param[in] prefixLength Prefix length that needs to be added
745 * @param[in] address IP address that needs to be added
746 * @param[io] asyncResp Response object that will be returned to client
747 *
748 * @return None
749 */
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500750inline void createIPv6(const std::string& ifaceId, uint8_t prefixLength,
751 const std::string& address,
zhanghch058d1b46d2021-04-01 11:18:24 +0800752 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500753{
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800754 auto createIpHandler = [asyncResp](const boost::system::error_code& ec) {
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500755 if (ec)
756 {
757 messages::internalError(asyncResp->res);
758 }
759 };
760 // Passing null for gateway, as per redfish spec IPv6StaticAddresses object
Gunnar Mills4e0453b2020-07-08 14:00:30 -0500761 // does not have associated gateway property
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500762 crow::connections::systemBus->async_method_call(
763 std::move(createIpHandler), "xyz.openbmc_project.Network",
764 "/xyz/openbmc_project/network/" + ifaceId,
765 "xyz.openbmc_project.Network.IP.Create", "IP",
766 "xyz.openbmc_project.Network.IP.Protocol.IPv6", address, prefixLength,
767 "");
768}
769
Ed Tanous4a0cb852018-10-15 07:55:04 -0700770/**
771 * Function that retrieves all properties for given Ethernet Interface
772 * Object
773 * from EntityManager Network Manager
774 * @param ethiface_id a eth interface id to query on DBus
775 * @param callback a function that shall be called to convert Dbus output
776 * into JSON
777 */
778template <typename CallbackFunc>
Ed Tanous81ce6092020-12-17 16:54:55 +0000779void getEthernetIfaceData(const std::string& ethifaceId,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500780 CallbackFunc&& callback)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700781{
George Liuf5892d02023-03-01 10:37:08 +0800782 sdbusplus::message::object_path path("/xyz/openbmc_project/network");
783 dbus::utility::getManagedObjects(
784 "xyz.openbmc_project.Network", path,
Ed Tanousf94c4ec2022-01-06 12:44:41 -0800785 [ethifaceId{std::string{ethifaceId}},
786 callback{std::forward<CallbackFunc>(callback)}](
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800787 const boost::system::error_code& errorCode,
Ed Tanous02cad962022-06-30 16:50:15 -0700788 const dbus::utility::ManagedObjectType& resp) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700789 EthernetInterfaceData ethData{};
Ed Tanous77179532023-02-28 10:45:28 -0800790 std::vector<IPv4AddressData> ipv4Data;
791 std::vector<IPv6AddressData> ipv6Data;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700792
Ed Tanous002d39b2022-05-31 08:59:27 -0700793 if (errorCode)
794 {
795 callback(false, ethData, ipv4Data, ipv6Data);
796 return;
797 }
798
799 bool found = extractEthernetInterfaceData(ethifaceId, resp, ethData);
800 if (!found)
801 {
802 callback(false, ethData, ipv4Data, ipv6Data);
803 return;
804 }
805
806 extractIPData(ethifaceId, resp, ipv4Data);
807 // Fix global GW
808 for (IPv4AddressData& ipv4 : ipv4Data)
809 {
810 if (((ipv4.linktype == LinkType::Global) &&
811 (ipv4.gateway == "0.0.0.0")) ||
812 (ipv4.origin == "DHCP") || (ipv4.origin == "Static"))
Ed Tanous4a0cb852018-10-15 07:55:04 -0700813 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700814 ipv4.gateway = ethData.defaultGateway;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700815 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700816 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700817
Ed Tanous002d39b2022-05-31 08:59:27 -0700818 extractIPV6Data(ethifaceId, resp, ipv6Data);
819 // Finally make a callback with useful data
820 callback(true, ethData, ipv4Data, ipv6Data);
George Liuf5892d02023-03-01 10:37:08 +0800821 });
Ed Tanous271584a2019-07-09 16:24:22 -0700822}
Ed Tanous4a0cb852018-10-15 07:55:04 -0700823
824/**
825 * Function that retrieves all Ethernet Interfaces available through Network
826 * Manager
827 * @param callback a function that shall be called to convert Dbus output
828 * into JSON.
829 */
830template <typename CallbackFunc>
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500831void getEthernetIfaceList(CallbackFunc&& callback)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700832{
George Liuf5892d02023-03-01 10:37:08 +0800833 sdbusplus::message::object_path path("/xyz/openbmc_project/network");
834 dbus::utility::getManagedObjects(
835 "xyz.openbmc_project.Network", path,
Ed Tanousf94c4ec2022-01-06 12:44:41 -0800836 [callback{std::forward<CallbackFunc>(callback)}](
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800837 const boost::system::error_code& errorCode,
George Liuf5892d02023-03-01 10:37:08 +0800838 const dbus::utility::ManagedObjectType& resp) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700839 // Callback requires vector<string> to retrieve all available
840 // ethernet interfaces
Ed Tanous77179532023-02-28 10:45:28 -0800841 std::vector<std::string> ifaceList;
Ed Tanous002d39b2022-05-31 08:59:27 -0700842 ifaceList.reserve(resp.size());
843 if (errorCode)
844 {
845 callback(false, ifaceList);
846 return;
847 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700848
Ed Tanous002d39b2022-05-31 08:59:27 -0700849 // Iterate over all retrieved ObjectPaths.
850 for (const auto& objpath : resp)
851 {
852 // And all interfaces available for certain ObjectPath.
853 for (const auto& interface : objpath.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700854 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700855 // If interface is
856 // xyz.openbmc_project.Network.EthernetInterface, this is
857 // what we're looking for.
858 if (interface.first ==
859 "xyz.openbmc_project.Network.EthernetInterface")
Ed Tanous4a0cb852018-10-15 07:55:04 -0700860 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700861 std::string ifaceId = objpath.first.filename();
862 if (ifaceId.empty())
Ed Tanous1abe55e2018-09-05 08:30:59 -0700863 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700864 continue;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700865 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700866 // and put it into output vector.
Ed Tanous77179532023-02-28 10:45:28 -0800867 ifaceList.emplace_back(ifaceId);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700868 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700869 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700870 }
Ed Tanous2c5875a2023-05-15 09:56:06 -0700871
872 std::sort(ifaceList.begin(), ifaceList.end(),
873 AlphanumLess<std::string>());
874
Ed Tanous002d39b2022-05-31 08:59:27 -0700875 // Finally make a callback with useful data
876 callback(true, ifaceList);
George Liuf5892d02023-03-01 10:37:08 +0800877 });
Ed Tanous271584a2019-07-09 16:24:22 -0700878}
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +0100879
Ed Tanous4f48d5f2021-06-21 08:27:45 -0700880inline void
881 handleHostnamePatch(const std::string& hostname,
882 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700883{
Ed Tanousbf648f72021-06-03 15:00:14 -0700884 // SHOULD handle host names of up to 255 characters(RFC 1123)
885 if (hostname.length() > 255)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700886 {
Ed Tanousbf648f72021-06-03 15:00:14 -0700887 messages::propertyValueFormatError(asyncResp->res, hostname,
888 "HostName");
889 return;
890 }
891 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800892 [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700893 if (ec)
894 {
895 messages::internalError(asyncResp->res);
896 }
Ed Tanousbf648f72021-06-03 15:00:14 -0700897 },
898 "xyz.openbmc_project.Network", "/xyz/openbmc_project/network/config",
899 "org.freedesktop.DBus.Properties", "Set",
900 "xyz.openbmc_project.Network.SystemConfiguration", "HostName",
Ed Tanous168e20c2021-12-13 14:39:53 -0800901 dbus::utility::DbusVariantType(hostname));
Ed Tanousbf648f72021-06-03 15:00:14 -0700902}
903
Ed Tanous4f48d5f2021-06-21 08:27:45 -0700904inline void
Tejas Patil35fb5312021-09-20 15:35:20 +0530905 handleMTUSizePatch(const std::string& ifaceId, const size_t mtuSize,
906 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
907{
Patrick Williams89492a12023-05-10 07:51:34 -0500908 sdbusplus::message::object_path objPath = "/xyz/openbmc_project/network/" +
909 ifaceId;
Tejas Patil35fb5312021-09-20 15:35:20 +0530910 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800911 [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700912 if (ec)
913 {
914 messages::internalError(asyncResp->res);
915 }
Tejas Patil35fb5312021-09-20 15:35:20 +0530916 },
917 "xyz.openbmc_project.Network", objPath,
918 "org.freedesktop.DBus.Properties", "Set",
919 "xyz.openbmc_project.Network.EthernetInterface", "MTU",
920 std::variant<size_t>(mtuSize));
921}
922
923inline void
Ed Tanous4f48d5f2021-06-21 08:27:45 -0700924 handleDomainnamePatch(const std::string& ifaceId,
925 const std::string& domainname,
926 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanousbf648f72021-06-03 15:00:14 -0700927{
928 std::vector<std::string> vectorDomainname = {domainname};
929 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800930 [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700931 if (ec)
932 {
933 messages::internalError(asyncResp->res);
934 }
Ed Tanousbf648f72021-06-03 15:00:14 -0700935 },
936 "xyz.openbmc_project.Network",
937 "/xyz/openbmc_project/network/" + ifaceId,
938 "org.freedesktop.DBus.Properties", "Set",
939 "xyz.openbmc_project.Network.EthernetInterface", "DomainName",
Ed Tanous168e20c2021-12-13 14:39:53 -0800940 dbus::utility::DbusVariantType(vectorDomainname));
Ed Tanousbf648f72021-06-03 15:00:14 -0700941}
942
Ed Tanous4f48d5f2021-06-21 08:27:45 -0700943inline bool isHostnameValid(const std::string& hostname)
Ed Tanousbf648f72021-06-03 15:00:14 -0700944{
945 // A valid host name can never have the dotted-decimal form (RFC 1123)
946 if (std::all_of(hostname.begin(), hostname.end(), ::isdigit))
947 {
948 return false;
949 }
950 // Each label(hostname/subdomains) within a valid FQDN
951 // MUST handle host names of up to 63 characters (RFC 1123)
952 // labels cannot start or end with hyphens (RFC 952)
953 // labels can start with numbers (RFC 1123)
Ed Tanous4b242742023-05-11 09:51:51 -0700954 const static std::regex pattern(
Ed Tanousbf648f72021-06-03 15:00:14 -0700955 "^[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]{0,61}[a-zA-Z0-9]$");
956
957 return std::regex_match(hostname, pattern);
958}
959
Ed Tanous4f48d5f2021-06-21 08:27:45 -0700960inline bool isDomainnameValid(const std::string& domainname)
Ed Tanousbf648f72021-06-03 15:00:14 -0700961{
962 // Can have multiple subdomains
963 // Top Level Domain's min length is 2 character
Ed Tanous4b242742023-05-11 09:51:51 -0700964 const static std::regex pattern(
George Liu0fda0f12021-11-16 10:06:17 +0800965 "^([A-Za-z0-9][a-zA-Z0-9\\-]{1,61}|[a-zA-Z0-9]{1,30}\\.)*[a-zA-Z]{2,}$");
Ed Tanousbf648f72021-06-03 15:00:14 -0700966
967 return std::regex_match(domainname, pattern);
968}
969
Ed Tanous4f48d5f2021-06-21 08:27:45 -0700970inline void handleFqdnPatch(const std::string& ifaceId, const std::string& fqdn,
971 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanousbf648f72021-06-03 15:00:14 -0700972{
973 // Total length of FQDN must not exceed 255 characters(RFC 1035)
974 if (fqdn.length() > 255)
975 {
976 messages::propertyValueFormatError(asyncResp->res, fqdn, "FQDN");
977 return;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700978 }
979
Ed Tanousbf648f72021-06-03 15:00:14 -0700980 size_t pos = fqdn.find('.');
981 if (pos == std::string::npos)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700982 {
Ed Tanousbf648f72021-06-03 15:00:14 -0700983 messages::propertyValueFormatError(asyncResp->res, fqdn, "FQDN");
984 return;
985 }
zhanghch058d1b46d2021-04-01 11:18:24 +0800986
Ed Tanousbf648f72021-06-03 15:00:14 -0700987 std::string hostname;
988 std::string domainname;
989 domainname = (fqdn).substr(pos + 1);
990 hostname = (fqdn).substr(0, pos);
991
992 if (!isHostnameValid(hostname) || !isDomainnameValid(domainname))
993 {
994 messages::propertyValueFormatError(asyncResp->res, fqdn, "FQDN");
995 return;
996 }
997
998 handleHostnamePatch(hostname, asyncResp);
999 handleDomainnamePatch(ifaceId, domainname, asyncResp);
1000}
1001
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001002inline void
1003 handleMACAddressPatch(const std::string& ifaceId,
1004 const std::string& macAddress,
1005 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanousbf648f72021-06-03 15:00:14 -07001006{
Johnathan Mantey58283f42022-08-15 14:38:36 -07001007 static constexpr std::string_view dbusNotAllowedError =
1008 "xyz.openbmc_project.Common.Error.NotAllowed";
1009
Ed Tanousbf648f72021-06-03 15:00:14 -07001010 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001011 [asyncResp, macAddress](const boost::system::error_code& ec,
Patrick Williams5b378542022-11-26 09:41:59 -06001012 const sdbusplus::message_t& msg) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001013 if (ec)
1014 {
Johnathan Mantey58283f42022-08-15 14:38:36 -07001015 const sd_bus_error* err = msg.get_error();
1016 if (err == nullptr)
1017 {
1018 messages::internalError(asyncResp->res);
1019 return;
1020 }
1021 if (err->name == dbusNotAllowedError)
1022 {
1023 messages::propertyNotWritable(asyncResp->res, "MACAddress");
1024 return;
1025 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001026 messages::internalError(asyncResp->res);
1027 return;
1028 }
Ed Tanousbf648f72021-06-03 15:00:14 -07001029 },
1030 "xyz.openbmc_project.Network",
1031 "/xyz/openbmc_project/network/" + ifaceId,
1032 "org.freedesktop.DBus.Properties", "Set",
1033 "xyz.openbmc_project.Network.MACAddress", "MACAddress",
Ed Tanous168e20c2021-12-13 14:39:53 -08001034 dbus::utility::DbusVariantType(macAddress));
Ed Tanousbf648f72021-06-03 15:00:14 -07001035}
1036
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001037inline void setDHCPEnabled(const std::string& ifaceId,
1038 const std::string& propertyName, const bool v4Value,
1039 const bool v6Value,
1040 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanousbf648f72021-06-03 15:00:14 -07001041{
1042 const std::string dhcp = getDhcpEnabledEnumeration(v4Value, v6Value);
1043 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001044 [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001045 if (ec)
1046 {
1047 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec;
1048 messages::internalError(asyncResp->res);
1049 return;
1050 }
1051 messages::success(asyncResp->res);
Ed Tanousbf648f72021-06-03 15:00:14 -07001052 },
1053 "xyz.openbmc_project.Network",
1054 "/xyz/openbmc_project/network/" + ifaceId,
1055 "org.freedesktop.DBus.Properties", "Set",
1056 "xyz.openbmc_project.Network.EthernetInterface", propertyName,
Ed Tanous168e20c2021-12-13 14:39:53 -08001057 dbus::utility::DbusVariantType{dhcp});
Ed Tanousbf648f72021-06-03 15:00:14 -07001058}
1059
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001060inline void setEthernetInterfaceBoolProperty(
Ed Tanousbf648f72021-06-03 15:00:14 -07001061 const std::string& ifaceId, const std::string& propertyName,
1062 const bool& value, const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1063{
1064 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001065 [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001066 if (ec)
1067 {
1068 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec;
1069 messages::internalError(asyncResp->res);
1070 return;
1071 }
Ed Tanousbf648f72021-06-03 15:00:14 -07001072 },
1073 "xyz.openbmc_project.Network",
1074 "/xyz/openbmc_project/network/" + ifaceId,
1075 "org.freedesktop.DBus.Properties", "Set",
1076 "xyz.openbmc_project.Network.EthernetInterface", propertyName,
Ed Tanous168e20c2021-12-13 14:39:53 -08001077 dbus::utility::DbusVariantType{value});
Ed Tanousbf648f72021-06-03 15:00:14 -07001078}
1079
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001080inline void setDHCPv4Config(const std::string& propertyName, const bool& value,
1081 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanousbf648f72021-06-03 15:00:14 -07001082{
1083 BMCWEB_LOG_DEBUG << propertyName << " = " << value;
1084 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001085 [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001086 if (ec)
1087 {
1088 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec;
1089 messages::internalError(asyncResp->res);
1090 return;
1091 }
Ed Tanousbf648f72021-06-03 15:00:14 -07001092 },
Jian Zhang1e3f85e2022-12-13 13:50:35 +08001093 "xyz.openbmc_project.Network", "/xyz/openbmc_project/network/dhcp",
Ed Tanousbf648f72021-06-03 15:00:14 -07001094 "org.freedesktop.DBus.Properties", "Set",
1095 "xyz.openbmc_project.Network.DHCPConfiguration", propertyName,
Ed Tanous168e20c2021-12-13 14:39:53 -08001096 dbus::utility::DbusVariantType{value});
Ed Tanousbf648f72021-06-03 15:00:14 -07001097}
1098
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001099inline void handleDHCPPatch(const std::string& ifaceId,
1100 const EthernetInterfaceData& ethData,
1101 const DHCPParameters& v4dhcpParms,
1102 const DHCPParameters& v6dhcpParms,
1103 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanousbf648f72021-06-03 15:00:14 -07001104{
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001105 bool ipv4Active = translateDhcpEnabledToBool(ethData.dhcpEnabled, true);
1106 bool ipv6Active = translateDhcpEnabledToBool(ethData.dhcpEnabled, false);
Ed Tanousbf648f72021-06-03 15:00:14 -07001107
1108 bool nextv4DHCPState =
1109 v4dhcpParms.dhcpv4Enabled ? *v4dhcpParms.dhcpv4Enabled : ipv4Active;
1110
1111 bool nextv6DHCPState{};
1112 if (v6dhcpParms.dhcpv6OperatingMode)
1113 {
1114 if ((*v6dhcpParms.dhcpv6OperatingMode != "Stateful") &&
1115 (*v6dhcpParms.dhcpv6OperatingMode != "Stateless") &&
1116 (*v6dhcpParms.dhcpv6OperatingMode != "Disabled"))
1117 {
1118 messages::propertyValueFormatError(asyncResp->res,
1119 *v6dhcpParms.dhcpv6OperatingMode,
1120 "OperatingMode");
1121 return;
1122 }
1123 nextv6DHCPState = (*v6dhcpParms.dhcpv6OperatingMode == "Stateful");
1124 }
1125 else
1126 {
1127 nextv6DHCPState = ipv6Active;
1128 }
1129
1130 bool nextDNS{};
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001131 if (v4dhcpParms.useDnsServers && v6dhcpParms.useDnsServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001132 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001133 if (*v4dhcpParms.useDnsServers != *v6dhcpParms.useDnsServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001134 {
1135 messages::generalError(asyncResp->res);
1136 return;
1137 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001138 nextDNS = *v4dhcpParms.useDnsServers;
Ed Tanousbf648f72021-06-03 15:00:14 -07001139 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001140 else if (v4dhcpParms.useDnsServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001141 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001142 nextDNS = *v4dhcpParms.useDnsServers;
Ed Tanousbf648f72021-06-03 15:00:14 -07001143 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001144 else if (v6dhcpParms.useDnsServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001145 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001146 nextDNS = *v6dhcpParms.useDnsServers;
Ed Tanousbf648f72021-06-03 15:00:14 -07001147 }
1148 else
1149 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001150 nextDNS = ethData.dnsEnabled;
Ed Tanousbf648f72021-06-03 15:00:14 -07001151 }
1152
1153 bool nextNTP{};
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001154 if (v4dhcpParms.useNtpServers && v6dhcpParms.useNtpServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001155 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001156 if (*v4dhcpParms.useNtpServers != *v6dhcpParms.useNtpServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001157 {
1158 messages::generalError(asyncResp->res);
1159 return;
1160 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001161 nextNTP = *v4dhcpParms.useNtpServers;
Ed Tanousbf648f72021-06-03 15:00:14 -07001162 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001163 else if (v4dhcpParms.useNtpServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001164 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001165 nextNTP = *v4dhcpParms.useNtpServers;
Ed Tanousbf648f72021-06-03 15:00:14 -07001166 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001167 else if (v6dhcpParms.useNtpServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001168 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001169 nextNTP = *v6dhcpParms.useNtpServers;
Ed Tanousbf648f72021-06-03 15:00:14 -07001170 }
1171 else
1172 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001173 nextNTP = ethData.ntpEnabled;
Ed Tanousbf648f72021-06-03 15:00:14 -07001174 }
1175
1176 bool nextUseDomain{};
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001177 if (v4dhcpParms.useDomainName && v6dhcpParms.useDomainName)
Ed Tanousbf648f72021-06-03 15:00:14 -07001178 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001179 if (*v4dhcpParms.useDomainName != *v6dhcpParms.useDomainName)
Ed Tanousbf648f72021-06-03 15:00:14 -07001180 {
1181 messages::generalError(asyncResp->res);
1182 return;
1183 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001184 nextUseDomain = *v4dhcpParms.useDomainName;
Ed Tanousbf648f72021-06-03 15:00:14 -07001185 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001186 else if (v4dhcpParms.useDomainName)
Ed Tanousbf648f72021-06-03 15:00:14 -07001187 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001188 nextUseDomain = *v4dhcpParms.useDomainName;
Ed Tanousbf648f72021-06-03 15:00:14 -07001189 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001190 else if (v6dhcpParms.useDomainName)
Ed Tanousbf648f72021-06-03 15:00:14 -07001191 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001192 nextUseDomain = *v6dhcpParms.useDomainName;
Ed Tanousbf648f72021-06-03 15:00:14 -07001193 }
1194 else
1195 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001196 nextUseDomain = ethData.hostNameEnabled;
Ed Tanousbf648f72021-06-03 15:00:14 -07001197 }
1198
1199 BMCWEB_LOG_DEBUG << "set DHCPEnabled...";
1200 setDHCPEnabled(ifaceId, "DHCPEnabled", nextv4DHCPState, nextv6DHCPState,
1201 asyncResp);
1202 BMCWEB_LOG_DEBUG << "set DNSEnabled...";
1203 setDHCPv4Config("DNSEnabled", nextDNS, asyncResp);
1204 BMCWEB_LOG_DEBUG << "set NTPEnabled...";
1205 setDHCPv4Config("NTPEnabled", nextNTP, asyncResp);
1206 BMCWEB_LOG_DEBUG << "set HostNameEnabled...";
1207 setDHCPv4Config("HostNameEnabled", nextUseDomain, asyncResp);
1208}
1209
Ed Tanous77179532023-02-28 10:45:28 -08001210inline std::vector<IPv4AddressData>::const_iterator getNextStaticIpEntry(
1211 const std::vector<IPv4AddressData>::const_iterator& head,
1212 const std::vector<IPv4AddressData>::const_iterator& end)
Ed Tanousbf648f72021-06-03 15:00:14 -07001213{
1214 return std::find_if(head, end, [](const IPv4AddressData& value) {
1215 return value.origin == "Static";
1216 });
1217}
1218
Ed Tanous77179532023-02-28 10:45:28 -08001219inline std::vector<IPv6AddressData>::const_iterator getNextStaticIpEntry(
1220 const std::vector<IPv6AddressData>::const_iterator& head,
1221 const std::vector<IPv6AddressData>::const_iterator& end)
Ed Tanousbf648f72021-06-03 15:00:14 -07001222{
1223 return std::find_if(head, end, [](const IPv6AddressData& value) {
1224 return value.origin == "Static";
1225 });
1226}
1227
Ed Tanous77179532023-02-28 10:45:28 -08001228inline void
Ed Tanousddd70dc2023-03-01 16:00:27 -08001229 handleIPv4StaticPatch(const std::string& ifaceId,
1230 nlohmann::json::array_t& input,
Ed Tanous77179532023-02-28 10:45:28 -08001231 const std::vector<IPv4AddressData>& ipv4Data,
1232 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanousbf648f72021-06-03 15:00:14 -07001233{
Ed Tanousddd70dc2023-03-01 16:00:27 -08001234 if (input.empty())
Ed Tanousbf648f72021-06-03 15:00:14 -07001235 {
Ed Tanous2e8c4bd2022-06-27 12:59:12 -07001236 messages::propertyValueTypeError(asyncResp->res, input,
1237 "IPv4StaticAddresses");
Ed Tanousbf648f72021-06-03 15:00:14 -07001238 return;
1239 }
1240
1241 unsigned entryIdx = 1;
1242 // Find the first static IP address currently active on the NIC and
1243 // match it to the first JSON element in the IPv4StaticAddresses array.
1244 // Match each subsequent JSON element to the next static IP programmed
1245 // into the NIC.
Ed Tanous77179532023-02-28 10:45:28 -08001246 std::vector<IPv4AddressData>::const_iterator nicIpEntry =
Ed Tanousbf648f72021-06-03 15:00:14 -07001247 getNextStaticIpEntry(ipv4Data.cbegin(), ipv4Data.cend());
1248
1249 for (nlohmann::json& thisJson : input)
1250 {
Patrick Williams89492a12023-05-10 07:51:34 -05001251 std::string pathString = "IPv4StaticAddresses/" +
1252 std::to_string(entryIdx);
Ed Tanousbf648f72021-06-03 15:00:14 -07001253
1254 if (!thisJson.is_null() && !thisJson.empty())
1255 {
1256 std::optional<std::string> address;
1257 std::optional<std::string> subnetMask;
1258 std::optional<std::string> gateway;
1259
1260 if (!json_util::readJson(thisJson, asyncResp->res, "Address",
1261 address, "SubnetMask", subnetMask,
1262 "Gateway", gateway))
1263 {
1264 messages::propertyValueFormatError(
1265 asyncResp->res,
1266 thisJson.dump(2, ' ', true,
1267 nlohmann::json::error_handler_t::replace),
1268 pathString);
1269 return;
1270 }
1271
1272 // Find the address/subnet/gateway values. Any values that are
1273 // not explicitly provided are assumed to be unmodified from the
1274 // current state of the interface. Merge existing state into the
1275 // current request.
1276 const std::string* addr = nullptr;
1277 const std::string* gw = nullptr;
1278 uint8_t prefixLength = 0;
1279 bool errorInEntry = false;
1280 if (address)
1281 {
Ed Tanous033f1e42022-08-15 09:47:37 -07001282 if (ip_util::ipv4VerifyIpAndGetBitcount(*address))
Ed Tanousbf648f72021-06-03 15:00:14 -07001283 {
1284 addr = &(*address);
1285 }
1286 else
1287 {
1288 messages::propertyValueFormatError(asyncResp->res, *address,
1289 pathString + "/Address");
1290 errorInEntry = true;
1291 }
1292 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001293 else if (nicIpEntry != ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001294 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001295 addr = &(nicIpEntry->address);
Ed Tanousbf648f72021-06-03 15:00:14 -07001296 }
1297 else
1298 {
1299 messages::propertyMissing(asyncResp->res,
1300 pathString + "/Address");
1301 errorInEntry = true;
1302 }
1303
1304 if (subnetMask)
1305 {
Ed Tanous033f1e42022-08-15 09:47:37 -07001306 if (!ip_util::ipv4VerifyIpAndGetBitcount(*subnetMask,
1307 &prefixLength))
Ed Tanousbf648f72021-06-03 15:00:14 -07001308 {
1309 messages::propertyValueFormatError(
1310 asyncResp->res, *subnetMask,
1311 pathString + "/SubnetMask");
1312 errorInEntry = true;
1313 }
1314 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001315 else if (nicIpEntry != ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001316 {
Ed Tanous033f1e42022-08-15 09:47:37 -07001317 if (!ip_util::ipv4VerifyIpAndGetBitcount(nicIpEntry->netmask,
1318 &prefixLength))
Ed Tanousbf648f72021-06-03 15:00:14 -07001319 {
1320 messages::propertyValueFormatError(
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001321 asyncResp->res, nicIpEntry->netmask,
Ed Tanousbf648f72021-06-03 15:00:14 -07001322 pathString + "/SubnetMask");
1323 errorInEntry = true;
1324 }
1325 }
1326 else
1327 {
1328 messages::propertyMissing(asyncResp->res,
1329 pathString + "/SubnetMask");
1330 errorInEntry = true;
1331 }
1332
1333 if (gateway)
1334 {
Ed Tanous033f1e42022-08-15 09:47:37 -07001335 if (ip_util::ipv4VerifyIpAndGetBitcount(*gateway))
Ed Tanousbf648f72021-06-03 15:00:14 -07001336 {
1337 gw = &(*gateway);
1338 }
1339 else
1340 {
1341 messages::propertyValueFormatError(asyncResp->res, *gateway,
1342 pathString + "/Gateway");
1343 errorInEntry = true;
1344 }
1345 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001346 else if (nicIpEntry != ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001347 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001348 gw = &nicIpEntry->gateway;
Ed Tanousbf648f72021-06-03 15:00:14 -07001349 }
1350 else
1351 {
1352 messages::propertyMissing(asyncResp->res,
1353 pathString + "/Gateway");
1354 errorInEntry = true;
1355 }
1356
1357 if (errorInEntry)
1358 {
1359 return;
1360 }
1361
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001362 if (nicIpEntry != ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001363 {
Ravi Teja9c5e5852023-02-26 21:33:52 -06001364 deleteAndCreateIPAddress(IpVersion::IpV4, ifaceId,
1365 nicIpEntry->id, prefixLength, *gw,
1366 *addr, asyncResp);
Patrick Williams89492a12023-05-10 07:51:34 -05001367 nicIpEntry = getNextStaticIpEntry(++nicIpEntry,
1368 ipv4Data.cend());
Ed Tanousbf648f72021-06-03 15:00:14 -07001369 }
1370 else
1371 {
1372 createIPv4(ifaceId, prefixLength, *gateway, *address,
1373 asyncResp);
1374 }
1375 entryIdx++;
1376 }
1377 else
1378 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001379 if (nicIpEntry == ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001380 {
1381 // Requesting a DELETE/DO NOT MODIFY action for an item
1382 // that isn't present on the eth(n) interface. Input JSON is
1383 // in error, so bail out.
1384 if (thisJson.is_null())
1385 {
1386 messages::resourceCannotBeDeleted(asyncResp->res);
1387 return;
1388 }
1389 messages::propertyValueFormatError(
1390 asyncResp->res,
1391 thisJson.dump(2, ' ', true,
1392 nlohmann::json::error_handler_t::replace),
1393 pathString);
1394 return;
1395 }
1396
1397 if (thisJson.is_null())
1398 {
Ravi Teja9c5e5852023-02-26 21:33:52 -06001399 deleteIPAddress(ifaceId, nicIpEntry->id, asyncResp);
Ed Tanousbf648f72021-06-03 15:00:14 -07001400 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001401 if (nicIpEntry != ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001402 {
Patrick Williams89492a12023-05-10 07:51:34 -05001403 nicIpEntry = getNextStaticIpEntry(++nicIpEntry,
1404 ipv4Data.cend());
Ed Tanousbf648f72021-06-03 15:00:14 -07001405 }
1406 entryIdx++;
1407 }
1408 }
1409}
1410
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001411inline void handleStaticNameServersPatch(
Ed Tanousbf648f72021-06-03 15:00:14 -07001412 const std::string& ifaceId,
1413 const std::vector<std::string>& updatedStaticNameServers,
1414 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1415{
1416 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001417 [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001418 if (ec)
1419 {
1420 messages::internalError(asyncResp->res);
1421 return;
1422 }
Ed Tanousbf648f72021-06-03 15:00:14 -07001423 },
1424 "xyz.openbmc_project.Network",
1425 "/xyz/openbmc_project/network/" + ifaceId,
1426 "org.freedesktop.DBus.Properties", "Set",
1427 "xyz.openbmc_project.Network.EthernetInterface", "StaticNameServers",
Ed Tanous168e20c2021-12-13 14:39:53 -08001428 dbus::utility::DbusVariantType{updatedStaticNameServers});
Ed Tanousbf648f72021-06-03 15:00:14 -07001429}
1430
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001431inline void handleIPv6StaticAddressesPatch(
Ed Tanousddd70dc2023-03-01 16:00:27 -08001432 const std::string& ifaceId, const nlohmann::json::array_t& input,
Ed Tanous77179532023-02-28 10:45:28 -08001433 const std::vector<IPv6AddressData>& ipv6Data,
Ed Tanousbf648f72021-06-03 15:00:14 -07001434 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1435{
Ed Tanousddd70dc2023-03-01 16:00:27 -08001436 if (input.empty())
Ed Tanousbf648f72021-06-03 15:00:14 -07001437 {
Ed Tanous2e8c4bd2022-06-27 12:59:12 -07001438 messages::propertyValueTypeError(asyncResp->res, input,
1439 "IPv6StaticAddresses");
Ed Tanousbf648f72021-06-03 15:00:14 -07001440 return;
1441 }
1442 size_t entryIdx = 1;
Ed Tanous77179532023-02-28 10:45:28 -08001443 std::vector<IPv6AddressData>::const_iterator nicIpEntry =
Ed Tanousbf648f72021-06-03 15:00:14 -07001444 getNextStaticIpEntry(ipv6Data.cbegin(), ipv6Data.cend());
1445 for (const nlohmann::json& thisJson : input)
1446 {
Patrick Williams89492a12023-05-10 07:51:34 -05001447 std::string pathString = "IPv6StaticAddresses/" +
1448 std::to_string(entryIdx);
Ed Tanousbf648f72021-06-03 15:00:14 -07001449
1450 if (!thisJson.is_null() && !thisJson.empty())
1451 {
1452 std::optional<std::string> address;
1453 std::optional<uint8_t> prefixLength;
1454 nlohmann::json thisJsonCopy = thisJson;
1455 if (!json_util::readJson(thisJsonCopy, asyncResp->res, "Address",
1456 address, "PrefixLength", prefixLength))
1457 {
1458 messages::propertyValueFormatError(
1459 asyncResp->res,
1460 thisJson.dump(2, ' ', true,
1461 nlohmann::json::error_handler_t::replace),
1462 pathString);
1463 return;
1464 }
1465
Ed Tanous543f4402022-01-06 13:12:53 -08001466 const std::string* addr = nullptr;
1467 uint8_t prefix = 0;
Ed Tanousbf648f72021-06-03 15:00:14 -07001468
1469 // Find the address and prefixLength values. Any values that are
1470 // not explicitly provided are assumed to be unmodified from the
1471 // current state of the interface. Merge existing state into the
1472 // current request.
1473 if (address)
1474 {
1475 addr = &(*address);
1476 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001477 else if (nicIpEntry != ipv6Data.end())
Ed Tanousbf648f72021-06-03 15:00:14 -07001478 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001479 addr = &(nicIpEntry->address);
Ed Tanousbf648f72021-06-03 15:00:14 -07001480 }
1481 else
1482 {
1483 messages::propertyMissing(asyncResp->res,
1484 pathString + "/Address");
1485 return;
1486 }
1487
1488 if (prefixLength)
1489 {
1490 prefix = *prefixLength;
1491 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001492 else if (nicIpEntry != ipv6Data.end())
Ed Tanousbf648f72021-06-03 15:00:14 -07001493 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001494 prefix = nicIpEntry->prefixLength;
Ed Tanousbf648f72021-06-03 15:00:14 -07001495 }
1496 else
1497 {
1498 messages::propertyMissing(asyncResp->res,
1499 pathString + "/PrefixLength");
1500 return;
1501 }
1502
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001503 if (nicIpEntry != ipv6Data.end())
Ed Tanousbf648f72021-06-03 15:00:14 -07001504 {
Ravi Teja9c5e5852023-02-26 21:33:52 -06001505 deleteAndCreateIPAddress(IpVersion::IpV6, ifaceId,
1506 nicIpEntry->id, prefix, "", *addr,
1507 asyncResp);
Patrick Williams89492a12023-05-10 07:51:34 -05001508 nicIpEntry = getNextStaticIpEntry(++nicIpEntry,
1509 ipv6Data.cend());
Ed Tanousbf648f72021-06-03 15:00:14 -07001510 }
1511 else
1512 {
1513 createIPv6(ifaceId, *prefixLength, *addr, asyncResp);
1514 }
1515 entryIdx++;
1516 }
1517 else
1518 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001519 if (nicIpEntry == ipv6Data.end())
Ed Tanousbf648f72021-06-03 15:00:14 -07001520 {
1521 // Requesting a DELETE/DO NOT MODIFY action for an item
1522 // that isn't present on the eth(n) interface. Input JSON is
1523 // in error, so bail out.
1524 if (thisJson.is_null())
1525 {
1526 messages::resourceCannotBeDeleted(asyncResp->res);
1527 return;
1528 }
1529 messages::propertyValueFormatError(
1530 asyncResp->res,
1531 thisJson.dump(2, ' ', true,
1532 nlohmann::json::error_handler_t::replace),
1533 pathString);
1534 return;
1535 }
1536
1537 if (thisJson.is_null())
1538 {
Ravi Teja9c5e5852023-02-26 21:33:52 -06001539 deleteIPAddress(ifaceId, nicIpEntry->id, asyncResp);
Ed Tanousbf648f72021-06-03 15:00:14 -07001540 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001541 if (nicIpEntry != ipv6Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001542 {
Patrick Williams89492a12023-05-10 07:51:34 -05001543 nicIpEntry = getNextStaticIpEntry(++nicIpEntry,
1544 ipv6Data.cend());
Ed Tanousbf648f72021-06-03 15:00:14 -07001545 }
1546 entryIdx++;
1547 }
1548 }
1549}
1550
Jiaqing Zhao7857cb82023-03-03 11:23:08 +08001551inline std::string extractParentInterfaceName(const std::string& ifaceId)
1552{
1553 std::size_t pos = ifaceId.find('_');
1554 return ifaceId.substr(0, pos);
1555}
1556
Ed Tanous77179532023-02-28 10:45:28 -08001557inline void
1558 parseInterfaceData(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1559 const std::string& ifaceId,
1560 const EthernetInterfaceData& ethData,
1561 const std::vector<IPv4AddressData>& ipv4Data,
1562 const std::vector<IPv6AddressData>& ipv6Data)
Ed Tanousbf648f72021-06-03 15:00:14 -07001563{
Ed Tanousbf648f72021-06-03 15:00:14 -07001564 nlohmann::json& jsonResponse = asyncResp->res.jsonValue;
1565 jsonResponse["Id"] = ifaceId;
Ed Tanousef4c65b2023-04-24 15:28:50 -07001566 jsonResponse["@odata.id"] = boost::urls::format(
1567 "/redfish/v1/Managers/bmc/EthernetInterfaces/{}", ifaceId);
Ed Tanousbf648f72021-06-03 15:00:14 -07001568 jsonResponse["InterfaceEnabled"] = ethData.nicEnabled;
1569
Willy Tu13451e32023-05-24 16:08:18 -07001570 if constexpr (bmcwebEnableHealthPopulate)
1571 {
1572 constexpr std::array<std::string_view, 1> inventoryForEthernet = {
1573 "xyz.openbmc_project.Inventory.Item.Ethernet"};
1574 auto health = std::make_shared<HealthPopulate>(asyncResp);
1575 dbus::utility::getSubTreePaths(
1576 "/", 0, inventoryForEthernet,
1577 [health](const boost::system::error_code& ec,
1578 const dbus::utility::MapperGetSubTreePathsResponse& resp) {
1579 if (ec)
1580 {
1581 return;
1582 }
Ed Tanousbf648f72021-06-03 15:00:14 -07001583
Willy Tu13451e32023-05-24 16:08:18 -07001584 health->inventory = resp;
1585 });
Ed Tanousbf648f72021-06-03 15:00:14 -07001586
Willy Tu13451e32023-05-24 16:08:18 -07001587 health->populate();
1588 }
Ed Tanousbf648f72021-06-03 15:00:14 -07001589
1590 if (ethData.nicEnabled)
1591 {
Johnathan Mantey0ef0e282022-11-15 12:15:02 -08001592 jsonResponse["LinkStatus"] = ethData.linkUp ? "LinkUp" : "LinkDown";
Ed Tanousbf648f72021-06-03 15:00:14 -07001593 jsonResponse["Status"]["State"] = "Enabled";
1594 }
1595 else
1596 {
1597 jsonResponse["LinkStatus"] = "NoLink";
1598 jsonResponse["Status"]["State"] = "Disabled";
1599 }
1600
Ed Tanousbf648f72021-06-03 15:00:14 -07001601 jsonResponse["SpeedMbps"] = ethData.speed;
Tejas Patil35fb5312021-09-20 15:35:20 +05301602 jsonResponse["MTUSize"] = ethData.mtuSize;
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001603 jsonResponse["MACAddress"] = ethData.macAddress;
Ed Tanousbf648f72021-06-03 15:00:14 -07001604 jsonResponse["DHCPv4"]["DHCPEnabled"] =
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001605 translateDhcpEnabledToBool(ethData.dhcpEnabled, true);
1606 jsonResponse["DHCPv4"]["UseNTPServers"] = ethData.ntpEnabled;
1607 jsonResponse["DHCPv4"]["UseDNSServers"] = ethData.dnsEnabled;
1608 jsonResponse["DHCPv4"]["UseDomainName"] = ethData.hostNameEnabled;
Ed Tanousbf648f72021-06-03 15:00:14 -07001609
1610 jsonResponse["DHCPv6"]["OperatingMode"] =
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001611 translateDhcpEnabledToBool(ethData.dhcpEnabled, false) ? "Stateful"
Ed Tanousbf648f72021-06-03 15:00:14 -07001612 : "Disabled";
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001613 jsonResponse["DHCPv6"]["UseNTPServers"] = ethData.ntpEnabled;
1614 jsonResponse["DHCPv6"]["UseDNSServers"] = ethData.dnsEnabled;
1615 jsonResponse["DHCPv6"]["UseDomainName"] = ethData.hostNameEnabled;
Ed Tanousbf648f72021-06-03 15:00:14 -07001616
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001617 if (!ethData.hostName.empty())
Ed Tanousbf648f72021-06-03 15:00:14 -07001618 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001619 jsonResponse["HostName"] = ethData.hostName;
Ed Tanousbf648f72021-06-03 15:00:14 -07001620
1621 // When domain name is empty then it means, that it is a network
1622 // without domain names, and the host name itself must be treated as
1623 // FQDN
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001624 std::string fqdn = ethData.hostName;
Ed Tanousbf648f72021-06-03 15:00:14 -07001625 if (!ethData.domainnames.empty())
1626 {
1627 fqdn += "." + ethData.domainnames[0];
1628 }
1629 jsonResponse["FQDN"] = fqdn;
1630 }
1631
Jiaqing Zhao7857cb82023-03-03 11:23:08 +08001632 if (ethData.vlanId)
1633 {
1634 jsonResponse["EthernetInterfaceType"] = "Virtual";
1635 jsonResponse["VLAN"]["VLANEnable"] = true;
1636 jsonResponse["VLAN"]["VLANId"] = *ethData.vlanId;
1637 jsonResponse["VLAN"]["Tagged"] = true;
1638
1639 nlohmann::json::array_t relatedInterfaces;
1640 nlohmann::json& parentInterface = relatedInterfaces.emplace_back();
1641 parentInterface["@odata.id"] =
1642 boost::urls::format("/redfish/v1/Managers/bmc/EthernetInterfaces",
1643 extractParentInterfaceName(ifaceId));
1644 jsonResponse["Links"]["RelatedInterfaces"] =
1645 std::move(relatedInterfaces);
1646 }
1647 else
1648 {
1649 jsonResponse["EthernetInterfaceType"] = "Physical";
1650 }
1651
Ed Tanousbf648f72021-06-03 15:00:14 -07001652 jsonResponse["NameServers"] = ethData.nameServers;
1653 jsonResponse["StaticNameServers"] = ethData.staticNameServers;
1654
1655 nlohmann::json& ipv4Array = jsonResponse["IPv4Addresses"];
1656 nlohmann::json& ipv4StaticArray = jsonResponse["IPv4StaticAddresses"];
1657 ipv4Array = nlohmann::json::array();
1658 ipv4StaticArray = nlohmann::json::array();
Ed Tanous9eb808c2022-01-25 10:19:23 -08001659 for (const auto& ipv4Config : ipv4Data)
Ed Tanousbf648f72021-06-03 15:00:14 -07001660 {
Ed Tanousbf648f72021-06-03 15:00:14 -07001661 std::string gatewayStr = ipv4Config.gateway;
1662 if (gatewayStr.empty())
1663 {
1664 gatewayStr = "0.0.0.0";
1665 }
Ed Tanous14766872022-03-15 10:44:42 -07001666 nlohmann::json::object_t ipv4;
1667 ipv4["AddressOrigin"] = ipv4Config.origin;
1668 ipv4["SubnetMask"] = ipv4Config.netmask;
1669 ipv4["Address"] = ipv4Config.address;
1670 ipv4["Gateway"] = gatewayStr;
Ed Tanousbf648f72021-06-03 15:00:14 -07001671
Ed Tanousbf648f72021-06-03 15:00:14 -07001672 if (ipv4Config.origin == "Static")
1673 {
Ed Tanous14766872022-03-15 10:44:42 -07001674 ipv4StaticArray.push_back(ipv4);
Ed Tanousbf648f72021-06-03 15:00:14 -07001675 }
Ed Tanous14766872022-03-15 10:44:42 -07001676
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001677 ipv4Array.emplace_back(std::move(ipv4));
Ed Tanousbf648f72021-06-03 15:00:14 -07001678 }
1679
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001680 std::string ipv6GatewayStr = ethData.ipv6DefaultGateway;
Ed Tanousbf648f72021-06-03 15:00:14 -07001681 if (ipv6GatewayStr.empty())
1682 {
1683 ipv6GatewayStr = "0:0:0:0:0:0:0:0";
1684 }
1685
1686 jsonResponse["IPv6DefaultGateway"] = ipv6GatewayStr;
1687
1688 nlohmann::json& ipv6Array = jsonResponse["IPv6Addresses"];
1689 nlohmann::json& ipv6StaticArray = jsonResponse["IPv6StaticAddresses"];
1690 ipv6Array = nlohmann::json::array();
1691 ipv6StaticArray = nlohmann::json::array();
1692 nlohmann::json& ipv6AddrPolicyTable =
1693 jsonResponse["IPv6AddressPolicyTable"];
1694 ipv6AddrPolicyTable = nlohmann::json::array();
Ed Tanous9eb808c2022-01-25 10:19:23 -08001695 for (const auto& ipv6Config : ipv6Data)
Ed Tanousbf648f72021-06-03 15:00:14 -07001696 {
Ed Tanous14766872022-03-15 10:44:42 -07001697 nlohmann::json::object_t ipv6;
1698 ipv6["Address"] = ipv6Config.address;
1699 ipv6["PrefixLength"] = ipv6Config.prefixLength;
1700 ipv6["AddressOrigin"] = ipv6Config.origin;
Sunitha Harishf8361272023-03-16 03:23:59 -05001701
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001702 ipv6Array.emplace_back(std::move(ipv6));
Ed Tanousbf648f72021-06-03 15:00:14 -07001703 if (ipv6Config.origin == "Static")
1704 {
Ed Tanous14766872022-03-15 10:44:42 -07001705 nlohmann::json::object_t ipv6Static;
1706 ipv6Static["Address"] = ipv6Config.address;
1707 ipv6Static["PrefixLength"] = ipv6Config.prefixLength;
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001708 ipv6StaticArray.emplace_back(std::move(ipv6Static));
Ed Tanousbf648f72021-06-03 15:00:14 -07001709 }
1710 }
1711}
1712
Jiaqing Zhaoe7caf252023-03-09 11:14:44 +08001713inline void afterDelete(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1714 const std::string& ifaceId,
1715 const boost::system::error_code& ec,
1716 const sdbusplus::message_t& m)
1717{
1718 if (!ec)
1719 {
1720 return;
1721 }
1722 const sd_bus_error* dbusError = m.get_error();
1723 if (dbusError == nullptr)
1724 {
1725 messages::internalError(asyncResp->res);
1726 return;
1727 }
1728 BMCWEB_LOG_DEBUG << "DBus error: " << dbusError->name;
1729
1730 if (std::string_view("org.freedesktop.DBus.Error.UnknownObject") ==
1731 dbusError->name)
1732 {
1733 messages::resourceNotFound(asyncResp->res, "EthernetInterface",
1734 ifaceId);
1735 return;
1736 }
1737 if (std::string_view("org.freedesktop.DBus.Error.UnknownMethod") ==
1738 dbusError->name)
1739 {
1740 messages::resourceCannotBeDeleted(asyncResp->res);
1741 return;
1742 }
1743 messages::internalError(asyncResp->res);
1744}
1745
Jiaqing Zhaob5ca3fd2023-03-08 15:14:58 +08001746inline void afterVlanCreate(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1747 const std::string& parentInterfaceUri,
1748 const std::string& vlanInterface,
1749 const boost::system::error_code& ec,
1750 const sdbusplus::message_t& m
1751
1752)
1753{
1754 if (ec)
1755 {
1756 const sd_bus_error* dbusError = m.get_error();
1757 if (dbusError == nullptr)
1758 {
1759 messages::internalError(asyncResp->res);
1760 return;
1761 }
1762 BMCWEB_LOG_DEBUG << "DBus error: " << dbusError->name;
1763
1764 if (std::string_view(
1765 "xyz.openbmc_project.Common.Error.ResourceNotFound") ==
1766 dbusError->name)
1767 {
1768 messages::propertyValueNotInList(
1769 asyncResp->res, parentInterfaceUri,
1770 "Links/RelatedInterfaces/0/@odata.id");
1771 return;
1772 }
1773 if (std::string_view(
1774 "xyz.openbmc_project.Common.Error.InvalidArgument") ==
1775 dbusError->name)
1776 {
1777 messages::resourceAlreadyExists(asyncResp->res, "EthernetInterface",
1778 "Id", vlanInterface);
1779 return;
1780 }
1781 messages::internalError(asyncResp->res);
1782 return;
1783 }
1784
1785 const boost::urls::url vlanInterfaceUri = boost::urls::format(
1786 "/redfish/v1/Managers/bmc/EthernetInterfaces/{}", vlanInterface);
1787 asyncResp->res.addHeader("Location", vlanInterfaceUri.buffer());
1788}
1789
Ed Tanousbf648f72021-06-03 15:00:14 -07001790inline void requestEthernetInterfacesRoutes(App& app)
1791{
1792 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/")
Ed Tanoused398212021-06-09 17:05:54 -07001793 .privileges(redfish::privileges::getEthernetInterfaceCollection)
Ed Tanous14766872022-03-15 10:44:42 -07001794 .methods(boost::beast::http::verb::get)(
1795 [&app](const crow::Request& req,
1796 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001797 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001798 {
1799 return;
1800 }
1801
1802 asyncResp->res.jsonValue["@odata.type"] =
1803 "#EthernetInterfaceCollection.EthernetInterfaceCollection";
1804 asyncResp->res.jsonValue["@odata.id"] =
1805 "/redfish/v1/Managers/bmc/EthernetInterfaces";
1806 asyncResp->res.jsonValue["Name"] =
1807 "Ethernet Network Interface Collection";
1808 asyncResp->res.jsonValue["Description"] =
1809 "Collection of EthernetInterfaces for this Manager";
1810
1811 // Get eth interface list, and call the below callback for JSON
1812 // preparation
1813 getEthernetIfaceList(
Ed Tanous77179532023-02-28 10:45:28 -08001814 [asyncResp](const bool& success,
1815 const std::vector<std::string>& ifaceList) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001816 if (!success)
1817 {
1818 messages::internalError(asyncResp->res);
1819 return;
1820 }
1821
1822 nlohmann::json& ifaceArray = asyncResp->res.jsonValue["Members"];
1823 ifaceArray = nlohmann::json::array();
Ed Tanous002d39b2022-05-31 08:59:27 -07001824 for (const std::string& ifaceItem : ifaceList)
1825 {
Jiaqing Zhao7857cb82023-03-03 11:23:08 +08001826 nlohmann::json::object_t iface;
1827 iface["@odata.id"] = boost::urls::format(
1828 "/redfish/v1/Managers/bmc/EthernetInterfaces/{}",
1829 ifaceItem);
1830 ifaceArray.push_back(std::move(iface));
Ed Tanous002d39b2022-05-31 08:59:27 -07001831 }
Jason M. Billsf12894f2018-10-09 12:45:45 -07001832
Ed Tanous002d39b2022-05-31 08:59:27 -07001833 asyncResp->res.jsonValue["Members@odata.count"] = ifaceArray.size();
1834 asyncResp->res.jsonValue["@odata.id"] =
1835 "/redfish/v1/Managers/bmc/EthernetInterfaces";
1836 });
1837 });
Johnathan Mantey01784822019-06-18 12:44:21 -07001838
Jiaqing Zhaob5ca3fd2023-03-08 15:14:58 +08001839 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/")
1840 .privileges(redfish::privileges::postEthernetInterfaceCollection)
1841 .methods(boost::beast::http::verb::post)(
1842 [&app](const crow::Request& req,
1843 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
1844 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1845 {
1846 return;
1847 }
1848
1849 bool vlanEnable = false;
1850 uint32_t vlanId = 0;
1851 nlohmann::json::array_t relatedInterfaces;
1852
1853 if (!json_util::readJsonPatch(req, asyncResp->res, "VLAN/VLANEnable",
1854 vlanEnable, "VLAN/VLANId", vlanId,
1855 "Links/RelatedInterfaces",
1856 relatedInterfaces))
1857 {
1858 return;
1859 }
1860
1861 if (relatedInterfaces.size() != 1)
1862 {
1863 messages::arraySizeTooLong(asyncResp->res,
1864 "Links/RelatedInterfaces",
1865 relatedInterfaces.size());
1866 return;
1867 }
1868
1869 std::string parentInterfaceUri;
1870 if (!json_util::readJson(relatedInterfaces[0], asyncResp->res,
1871 "@odata.id", parentInterfaceUri))
1872 {
1873 messages::propertyMissing(asyncResp->res,
1874 "Links/RelatedInterfaces/0/@odata.id");
1875 return;
1876 }
1877 BMCWEB_LOG_INFO << "Parent Interface URI: " << parentInterfaceUri;
1878
1879 boost::urls::result<boost::urls::url_view> parsedUri =
1880 boost::urls::parse_relative_ref(parentInterfaceUri);
1881 if (!parsedUri)
1882 {
1883 messages::propertyValueFormatError(
1884 asyncResp->res, parentInterfaceUri,
1885 "Links/RelatedInterfaces/0/@odata.id");
1886 return;
1887 }
1888
1889 std::string parentInterface;
1890 if (!crow::utility::readUrlSegments(
1891 *parsedUri, "redfish", "v1", "Managers", "bmc",
1892 "EthernetInterfaces", std::ref(parentInterface)))
1893 {
1894 messages::propertyValueNotInList(
1895 asyncResp->res, parentInterfaceUri,
1896 "Links/RelatedInterfaces/0/@odata.id");
1897 return;
1898 }
1899
1900 if (!vlanEnable)
1901 {
1902 // In OpenBMC implementation, VLANEnable cannot be false on
1903 // create
1904 messages::propertyValueIncorrect(asyncResp->res, "VLAN/VLANEnable",
1905 "false");
1906 return;
1907 }
1908
1909 std::string vlanInterface = parentInterface + "_" +
1910 std::to_string(vlanId);
1911 crow::connections::systemBus->async_method_call(
1912 [asyncResp, parentInterfaceUri,
1913 vlanInterface](const boost::system::error_code& ec,
1914 const sdbusplus::message_t& m) {
1915 afterVlanCreate(asyncResp, parentInterfaceUri, vlanInterface, ec,
1916 m);
1917 },
1918 "xyz.openbmc_project.Network", "/xyz/openbmc_project/network",
1919 "xyz.openbmc_project.Network.VLAN.Create", "VLAN", parentInterface,
1920 vlanId);
1921 });
1922
Ed Tanousbf648f72021-06-03 15:00:14 -07001923 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001924 .privileges(redfish::privileges::getEthernetInterface)
Ed Tanousbf648f72021-06-03 15:00:14 -07001925 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001926 [&app](const crow::Request& req,
1927 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1928 const std::string& ifaceId) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001929 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001930 {
1931 return;
1932 }
1933 getEthernetIfaceData(
1934 ifaceId,
Ed Tanous77179532023-02-28 10:45:28 -08001935 [asyncResp, ifaceId](const bool& success,
1936 const EthernetInterfaceData& ethData,
1937 const std::vector<IPv4AddressData>& ipv4Data,
1938 const std::vector<IPv6AddressData>& ipv6Data) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001939 if (!success)
1940 {
1941 // TODO(Pawel)consider distinguish between non
1942 // existing object, and other errors
1943 messages::resourceNotFound(asyncResp->res, "EthernetInterface",
1944 ifaceId);
1945 return;
1946 }
Johnathan Mantey01784822019-06-18 12:44:21 -07001947
Ed Tanous002d39b2022-05-31 08:59:27 -07001948 asyncResp->res.jsonValue["@odata.type"] =
Jiaqing Zhao93bbc952023-02-23 14:11:20 +08001949 "#EthernetInterface.v1_9_0.EthernetInterface";
Ed Tanous002d39b2022-05-31 08:59:27 -07001950 asyncResp->res.jsonValue["Name"] = "Manager Ethernet Interface";
1951 asyncResp->res.jsonValue["Description"] =
1952 "Management Network Interface";
Ratan Guptaf476acb2019-03-02 16:46:57 +05301953
Ed Tanous002d39b2022-05-31 08:59:27 -07001954 parseInterfaceData(asyncResp, ifaceId, ethData, ipv4Data, ipv6Data);
Ed Tanousbf648f72021-06-03 15:00:14 -07001955 });
Ed Tanous002d39b2022-05-31 08:59:27 -07001956 });
Johnathan Mantey01784822019-06-18 12:44:21 -07001957
Ed Tanousbf648f72021-06-03 15:00:14 -07001958 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001959 .privileges(redfish::privileges::patchEthernetInterface)
Ed Tanousbf648f72021-06-03 15:00:14 -07001960 .methods(boost::beast::http::verb::patch)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001961 [&app](const crow::Request& req,
1962 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1963 const std::string& ifaceId) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001964 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001965 {
1966 return;
1967 }
1968 std::optional<std::string> hostname;
1969 std::optional<std::string> fqdn;
1970 std::optional<std::string> macAddress;
1971 std::optional<std::string> ipv6DefaultGateway;
Ed Tanousddd70dc2023-03-01 16:00:27 -08001972 std::optional<nlohmann::json::array_t> ipv4StaticAddresses;
1973 std::optional<nlohmann::json::array_t> ipv6StaticAddresses;
Ed Tanous002d39b2022-05-31 08:59:27 -07001974 std::optional<std::vector<std::string>> staticNameServers;
1975 std::optional<nlohmann::json> dhcpv4;
1976 std::optional<nlohmann::json> dhcpv6;
1977 std::optional<bool> interfaceEnabled;
1978 std::optional<size_t> mtuSize;
1979 DHCPParameters v4dhcpParms;
1980 DHCPParameters v6dhcpParms;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001981
Ed Tanous002d39b2022-05-31 08:59:27 -07001982 if (!json_util::readJsonPatch(
1983 req, asyncResp->res, "HostName", hostname, "FQDN", fqdn,
1984 "IPv4StaticAddresses", ipv4StaticAddresses, "MACAddress",
1985 macAddress, "StaticNameServers", staticNameServers,
1986 "IPv6DefaultGateway", ipv6DefaultGateway, "IPv6StaticAddresses",
1987 ipv6StaticAddresses, "DHCPv4", dhcpv4, "DHCPv6", dhcpv6,
1988 "MTUSize", mtuSize, "InterfaceEnabled", interfaceEnabled))
1989 {
1990 return;
1991 }
1992 if (dhcpv4)
1993 {
1994 if (!json_util::readJson(*dhcpv4, asyncResp->res, "DHCPEnabled",
1995 v4dhcpParms.dhcpv4Enabled, "UseDNSServers",
1996 v4dhcpParms.useDnsServers, "UseNTPServers",
1997 v4dhcpParms.useNtpServers, "UseDomainName",
1998 v4dhcpParms.useDomainName))
1999 {
2000 return;
2001 }
2002 }
Johnathan Mantey01784822019-06-18 12:44:21 -07002003
Ed Tanous002d39b2022-05-31 08:59:27 -07002004 if (dhcpv6)
2005 {
2006 if (!json_util::readJson(*dhcpv6, asyncResp->res, "OperatingMode",
2007 v6dhcpParms.dhcpv6OperatingMode,
2008 "UseDNSServers", v6dhcpParms.useDnsServers,
2009 "UseNTPServers", v6dhcpParms.useNtpServers,
2010 "UseDomainName",
2011 v6dhcpParms.useDomainName))
2012 {
2013 return;
2014 }
2015 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002016
Ed Tanous002d39b2022-05-31 08:59:27 -07002017 // Get single eth interface data, and call the below callback
2018 // for JSON preparation
2019 getEthernetIfaceData(
2020 ifaceId,
2021 [asyncResp, ifaceId, hostname = std::move(hostname),
2022 fqdn = std::move(fqdn), macAddress = std::move(macAddress),
2023 ipv4StaticAddresses = std::move(ipv4StaticAddresses),
2024 ipv6DefaultGateway = std::move(ipv6DefaultGateway),
2025 ipv6StaticAddresses = std::move(ipv6StaticAddresses),
2026 staticNameServers = std::move(staticNameServers),
Ed Tanousbc200892022-06-30 17:49:12 -07002027 dhcpv4 = std::move(dhcpv4), dhcpv6 = std::move(dhcpv6), mtuSize,
2028 v4dhcpParms = std::move(v4dhcpParms),
Ed Tanous002d39b2022-05-31 08:59:27 -07002029 v6dhcpParms = std::move(v6dhcpParms), interfaceEnabled](
2030 const bool& success, const EthernetInterfaceData& ethData,
Ed Tanous77179532023-02-28 10:45:28 -08002031 const std::vector<IPv4AddressData>& ipv4Data,
2032 const std::vector<IPv6AddressData>& ipv6Data) {
Ed Tanous002d39b2022-05-31 08:59:27 -07002033 if (!success)
2034 {
2035 // ... otherwise return error
2036 // TODO(Pawel)consider distinguish between non
2037 // existing object, and other errors
Jiaqing Zhaod8a5d5d2022-08-05 16:21:51 +08002038 messages::resourceNotFound(asyncResp->res, "EthernetInterface",
Ed Tanous002d39b2022-05-31 08:59:27 -07002039 ifaceId);
2040 return;
2041 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002042
Ed Tanous002d39b2022-05-31 08:59:27 -07002043 if (dhcpv4 || dhcpv6)
2044 {
2045 handleDHCPPatch(ifaceId, ethData, v4dhcpParms, v6dhcpParms,
Ed Tanousbf648f72021-06-03 15:00:14 -07002046 asyncResp);
Ed Tanous002d39b2022-05-31 08:59:27 -07002047 }
Tejas Patil35fb5312021-09-20 15:35:20 +05302048
Ed Tanous002d39b2022-05-31 08:59:27 -07002049 if (hostname)
2050 {
2051 handleHostnamePatch(*hostname, asyncResp);
2052 }
2053
2054 if (fqdn)
2055 {
2056 handleFqdnPatch(ifaceId, *fqdn, asyncResp);
2057 }
2058
2059 if (macAddress)
2060 {
2061 handleMACAddressPatch(ifaceId, *macAddress, asyncResp);
2062 }
2063
2064 if (ipv4StaticAddresses)
2065 {
2066 // TODO(ed) for some reason the capture of
2067 // ipv4Addresses above is returning a const value,
2068 // not a non-const value. This doesn't really work
2069 // for us, as we need to be able to efficiently move
2070 // out the intermedia nlohmann::json objects. This
2071 // makes a copy of the structure, and operates on
2072 // that, but could be done more efficiently
Ed Tanousddd70dc2023-03-01 16:00:27 -08002073 nlohmann::json::array_t ipv4Static = *ipv4StaticAddresses;
Ed Tanous002d39b2022-05-31 08:59:27 -07002074 handleIPv4StaticPatch(ifaceId, ipv4Static, ipv4Data, asyncResp);
2075 }
2076
2077 if (staticNameServers)
2078 {
2079 handleStaticNameServersPatch(ifaceId, *staticNameServers,
2080 asyncResp);
2081 }
2082
2083 if (ipv6DefaultGateway)
2084 {
2085 messages::propertyNotWritable(asyncResp->res,
2086 "IPv6DefaultGateway");
2087 }
2088
2089 if (ipv6StaticAddresses)
2090 {
Ed Tanousddd70dc2023-03-01 16:00:27 -08002091 handleIPv6StaticAddressesPatch(ifaceId, *ipv6StaticAddresses,
2092 ipv6Data, asyncResp);
Ed Tanous002d39b2022-05-31 08:59:27 -07002093 }
2094
2095 if (interfaceEnabled)
2096 {
2097 setEthernetInterfaceBoolProperty(ifaceId, "NICEnabled",
2098 *interfaceEnabled, asyncResp);
2099 }
2100
2101 if (mtuSize)
2102 {
2103 handleMTUSizePatch(ifaceId, *mtuSize, asyncResp);
2104 }
Ed Tanousbf648f72021-06-03 15:00:14 -07002105 });
Ed Tanous002d39b2022-05-31 08:59:27 -07002106 });
Jiaqing Zhaoe7caf252023-03-09 11:14:44 +08002107
2108 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/")
2109 .privileges(redfish::privileges::deleteEthernetInterface)
2110 .methods(boost::beast::http::verb::delete_)(
2111 [&app](const crow::Request& req,
2112 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2113 const std::string& ifaceId) {
2114 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2115 {
2116 return;
2117 }
2118
2119 crow::connections::systemBus->async_method_call(
2120 [asyncResp, ifaceId](const boost::system::error_code& ec,
2121 const sdbusplus::message_t& m) {
2122 afterDelete(asyncResp, ifaceId, ec, m);
2123 },
2124 "xyz.openbmc_project.Network",
2125 std::string("/xyz/openbmc_project/network/") + ifaceId,
2126 "xyz.openbmc_project.Object.Delete", "Delete");
2127 });
Ed Tanousbf648f72021-06-03 15:00:14 -07002128}
2129
Ed Tanous1abe55e2018-09-05 08:30:59 -07002130} // namespace redfish