blob: 1d2c988c7c242b676d299d224c99f4ccb0e9fdc6 [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 {
1236 messages::propertyValueTypeError(
1237 asyncResp->res,
Ed Tanousddd70dc2023-03-01 16:00:27 -08001238 nlohmann::json(input).dump(
1239 2, ' ', true, nlohmann::json::error_handler_t::replace),
Ed Tanousbf648f72021-06-03 15:00:14 -07001240 "IPv4StaticAddresses");
1241 return;
1242 }
1243
1244 unsigned entryIdx = 1;
1245 // Find the first static IP address currently active on the NIC and
1246 // match it to the first JSON element in the IPv4StaticAddresses array.
1247 // Match each subsequent JSON element to the next static IP programmed
1248 // into the NIC.
Ed Tanous77179532023-02-28 10:45:28 -08001249 std::vector<IPv4AddressData>::const_iterator nicIpEntry =
Ed Tanousbf648f72021-06-03 15:00:14 -07001250 getNextStaticIpEntry(ipv4Data.cbegin(), ipv4Data.cend());
1251
1252 for (nlohmann::json& thisJson : input)
1253 {
Patrick Williams89492a12023-05-10 07:51:34 -05001254 std::string pathString = "IPv4StaticAddresses/" +
1255 std::to_string(entryIdx);
Ed Tanousbf648f72021-06-03 15:00:14 -07001256
1257 if (!thisJson.is_null() && !thisJson.empty())
1258 {
1259 std::optional<std::string> address;
1260 std::optional<std::string> subnetMask;
1261 std::optional<std::string> gateway;
1262
1263 if (!json_util::readJson(thisJson, asyncResp->res, "Address",
1264 address, "SubnetMask", subnetMask,
1265 "Gateway", gateway))
1266 {
1267 messages::propertyValueFormatError(
1268 asyncResp->res,
1269 thisJson.dump(2, ' ', true,
1270 nlohmann::json::error_handler_t::replace),
1271 pathString);
1272 return;
1273 }
1274
1275 // Find the address/subnet/gateway values. Any values that are
1276 // not explicitly provided are assumed to be unmodified from the
1277 // current state of the interface. Merge existing state into the
1278 // current request.
1279 const std::string* addr = nullptr;
1280 const std::string* gw = nullptr;
1281 uint8_t prefixLength = 0;
1282 bool errorInEntry = false;
1283 if (address)
1284 {
Ed Tanous033f1e42022-08-15 09:47:37 -07001285 if (ip_util::ipv4VerifyIpAndGetBitcount(*address))
Ed Tanousbf648f72021-06-03 15:00:14 -07001286 {
1287 addr = &(*address);
1288 }
1289 else
1290 {
1291 messages::propertyValueFormatError(asyncResp->res, *address,
1292 pathString + "/Address");
1293 errorInEntry = true;
1294 }
1295 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001296 else if (nicIpEntry != ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001297 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001298 addr = &(nicIpEntry->address);
Ed Tanousbf648f72021-06-03 15:00:14 -07001299 }
1300 else
1301 {
1302 messages::propertyMissing(asyncResp->res,
1303 pathString + "/Address");
1304 errorInEntry = true;
1305 }
1306
1307 if (subnetMask)
1308 {
Ed Tanous033f1e42022-08-15 09:47:37 -07001309 if (!ip_util::ipv4VerifyIpAndGetBitcount(*subnetMask,
1310 &prefixLength))
Ed Tanousbf648f72021-06-03 15:00:14 -07001311 {
1312 messages::propertyValueFormatError(
1313 asyncResp->res, *subnetMask,
1314 pathString + "/SubnetMask");
1315 errorInEntry = true;
1316 }
1317 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001318 else if (nicIpEntry != ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001319 {
Ed Tanous033f1e42022-08-15 09:47:37 -07001320 if (!ip_util::ipv4VerifyIpAndGetBitcount(nicIpEntry->netmask,
1321 &prefixLength))
Ed Tanousbf648f72021-06-03 15:00:14 -07001322 {
1323 messages::propertyValueFormatError(
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001324 asyncResp->res, nicIpEntry->netmask,
Ed Tanousbf648f72021-06-03 15:00:14 -07001325 pathString + "/SubnetMask");
1326 errorInEntry = true;
1327 }
1328 }
1329 else
1330 {
1331 messages::propertyMissing(asyncResp->res,
1332 pathString + "/SubnetMask");
1333 errorInEntry = true;
1334 }
1335
1336 if (gateway)
1337 {
Ed Tanous033f1e42022-08-15 09:47:37 -07001338 if (ip_util::ipv4VerifyIpAndGetBitcount(*gateway))
Ed Tanousbf648f72021-06-03 15:00:14 -07001339 {
1340 gw = &(*gateway);
1341 }
1342 else
1343 {
1344 messages::propertyValueFormatError(asyncResp->res, *gateway,
1345 pathString + "/Gateway");
1346 errorInEntry = true;
1347 }
1348 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001349 else if (nicIpEntry != ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001350 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001351 gw = &nicIpEntry->gateway;
Ed Tanousbf648f72021-06-03 15:00:14 -07001352 }
1353 else
1354 {
1355 messages::propertyMissing(asyncResp->res,
1356 pathString + "/Gateway");
1357 errorInEntry = true;
1358 }
1359
1360 if (errorInEntry)
1361 {
1362 return;
1363 }
1364
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001365 if (nicIpEntry != ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001366 {
Ravi Teja9c5e5852023-02-26 21:33:52 -06001367 deleteAndCreateIPAddress(IpVersion::IpV4, ifaceId,
1368 nicIpEntry->id, prefixLength, *gw,
1369 *addr, asyncResp);
Patrick Williams89492a12023-05-10 07:51:34 -05001370 nicIpEntry = getNextStaticIpEntry(++nicIpEntry,
1371 ipv4Data.cend());
Ed Tanousbf648f72021-06-03 15:00:14 -07001372 }
1373 else
1374 {
1375 createIPv4(ifaceId, prefixLength, *gateway, *address,
1376 asyncResp);
1377 }
1378 entryIdx++;
1379 }
1380 else
1381 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001382 if (nicIpEntry == ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001383 {
1384 // Requesting a DELETE/DO NOT MODIFY action for an item
1385 // that isn't present on the eth(n) interface. Input JSON is
1386 // in error, so bail out.
1387 if (thisJson.is_null())
1388 {
1389 messages::resourceCannotBeDeleted(asyncResp->res);
1390 return;
1391 }
1392 messages::propertyValueFormatError(
1393 asyncResp->res,
1394 thisJson.dump(2, ' ', true,
1395 nlohmann::json::error_handler_t::replace),
1396 pathString);
1397 return;
1398 }
1399
1400 if (thisJson.is_null())
1401 {
Ravi Teja9c5e5852023-02-26 21:33:52 -06001402 deleteIPAddress(ifaceId, nicIpEntry->id, asyncResp);
Ed Tanousbf648f72021-06-03 15:00:14 -07001403 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001404 if (nicIpEntry != ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001405 {
Patrick Williams89492a12023-05-10 07:51:34 -05001406 nicIpEntry = getNextStaticIpEntry(++nicIpEntry,
1407 ipv4Data.cend());
Ed Tanousbf648f72021-06-03 15:00:14 -07001408 }
1409 entryIdx++;
1410 }
1411 }
1412}
1413
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001414inline void handleStaticNameServersPatch(
Ed Tanousbf648f72021-06-03 15:00:14 -07001415 const std::string& ifaceId,
1416 const std::vector<std::string>& updatedStaticNameServers,
1417 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1418{
1419 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001420 [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001421 if (ec)
1422 {
1423 messages::internalError(asyncResp->res);
1424 return;
1425 }
Ed Tanousbf648f72021-06-03 15:00:14 -07001426 },
1427 "xyz.openbmc_project.Network",
1428 "/xyz/openbmc_project/network/" + ifaceId,
1429 "org.freedesktop.DBus.Properties", "Set",
1430 "xyz.openbmc_project.Network.EthernetInterface", "StaticNameServers",
Ed Tanous168e20c2021-12-13 14:39:53 -08001431 dbus::utility::DbusVariantType{updatedStaticNameServers});
Ed Tanousbf648f72021-06-03 15:00:14 -07001432}
1433
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001434inline void handleIPv6StaticAddressesPatch(
Ed Tanousddd70dc2023-03-01 16:00:27 -08001435 const std::string& ifaceId, const nlohmann::json::array_t& input,
Ed Tanous77179532023-02-28 10:45:28 -08001436 const std::vector<IPv6AddressData>& ipv6Data,
Ed Tanousbf648f72021-06-03 15:00:14 -07001437 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1438{
Ed Tanousddd70dc2023-03-01 16:00:27 -08001439 if (input.empty())
Ed Tanousbf648f72021-06-03 15:00:14 -07001440 {
1441 messages::propertyValueTypeError(
1442 asyncResp->res,
Ed Tanousddd70dc2023-03-01 16:00:27 -08001443 nlohmann::json(input).dump(
1444 2, ' ', true, nlohmann::json::error_handler_t::replace),
Ed Tanousbf648f72021-06-03 15:00:14 -07001445 "IPv6StaticAddresses");
1446 return;
1447 }
1448 size_t entryIdx = 1;
Ed Tanous77179532023-02-28 10:45:28 -08001449 std::vector<IPv6AddressData>::const_iterator nicIpEntry =
Ed Tanousbf648f72021-06-03 15:00:14 -07001450 getNextStaticIpEntry(ipv6Data.cbegin(), ipv6Data.cend());
1451 for (const nlohmann::json& thisJson : input)
1452 {
Patrick Williams89492a12023-05-10 07:51:34 -05001453 std::string pathString = "IPv6StaticAddresses/" +
1454 std::to_string(entryIdx);
Ed Tanousbf648f72021-06-03 15:00:14 -07001455
1456 if (!thisJson.is_null() && !thisJson.empty())
1457 {
1458 std::optional<std::string> address;
1459 std::optional<uint8_t> prefixLength;
1460 nlohmann::json thisJsonCopy = thisJson;
1461 if (!json_util::readJson(thisJsonCopy, asyncResp->res, "Address",
1462 address, "PrefixLength", prefixLength))
1463 {
1464 messages::propertyValueFormatError(
1465 asyncResp->res,
1466 thisJson.dump(2, ' ', true,
1467 nlohmann::json::error_handler_t::replace),
1468 pathString);
1469 return;
1470 }
1471
Ed Tanous543f4402022-01-06 13:12:53 -08001472 const std::string* addr = nullptr;
1473 uint8_t prefix = 0;
Ed Tanousbf648f72021-06-03 15:00:14 -07001474
1475 // Find the address and prefixLength values. Any values that are
1476 // not explicitly provided are assumed to be unmodified from the
1477 // current state of the interface. Merge existing state into the
1478 // current request.
1479 if (address)
1480 {
1481 addr = &(*address);
1482 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001483 else if (nicIpEntry != ipv6Data.end())
Ed Tanousbf648f72021-06-03 15:00:14 -07001484 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001485 addr = &(nicIpEntry->address);
Ed Tanousbf648f72021-06-03 15:00:14 -07001486 }
1487 else
1488 {
1489 messages::propertyMissing(asyncResp->res,
1490 pathString + "/Address");
1491 return;
1492 }
1493
1494 if (prefixLength)
1495 {
1496 prefix = *prefixLength;
1497 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001498 else if (nicIpEntry != ipv6Data.end())
Ed Tanousbf648f72021-06-03 15:00:14 -07001499 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001500 prefix = nicIpEntry->prefixLength;
Ed Tanousbf648f72021-06-03 15:00:14 -07001501 }
1502 else
1503 {
1504 messages::propertyMissing(asyncResp->res,
1505 pathString + "/PrefixLength");
1506 return;
1507 }
1508
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001509 if (nicIpEntry != ipv6Data.end())
Ed Tanousbf648f72021-06-03 15:00:14 -07001510 {
Ravi Teja9c5e5852023-02-26 21:33:52 -06001511 deleteAndCreateIPAddress(IpVersion::IpV6, ifaceId,
1512 nicIpEntry->id, prefix, "", *addr,
1513 asyncResp);
Patrick Williams89492a12023-05-10 07:51:34 -05001514 nicIpEntry = getNextStaticIpEntry(++nicIpEntry,
1515 ipv6Data.cend());
Ed Tanousbf648f72021-06-03 15:00:14 -07001516 }
1517 else
1518 {
1519 createIPv6(ifaceId, *prefixLength, *addr, asyncResp);
1520 }
1521 entryIdx++;
1522 }
1523 else
1524 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001525 if (nicIpEntry == ipv6Data.end())
Ed Tanousbf648f72021-06-03 15:00:14 -07001526 {
1527 // Requesting a DELETE/DO NOT MODIFY action for an item
1528 // that isn't present on the eth(n) interface. Input JSON is
1529 // in error, so bail out.
1530 if (thisJson.is_null())
1531 {
1532 messages::resourceCannotBeDeleted(asyncResp->res);
1533 return;
1534 }
1535 messages::propertyValueFormatError(
1536 asyncResp->res,
1537 thisJson.dump(2, ' ', true,
1538 nlohmann::json::error_handler_t::replace),
1539 pathString);
1540 return;
1541 }
1542
1543 if (thisJson.is_null())
1544 {
Ravi Teja9c5e5852023-02-26 21:33:52 -06001545 deleteIPAddress(ifaceId, nicIpEntry->id, asyncResp);
Ed Tanousbf648f72021-06-03 15:00:14 -07001546 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001547 if (nicIpEntry != ipv6Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001548 {
Patrick Williams89492a12023-05-10 07:51:34 -05001549 nicIpEntry = getNextStaticIpEntry(++nicIpEntry,
1550 ipv6Data.cend());
Ed Tanousbf648f72021-06-03 15:00:14 -07001551 }
1552 entryIdx++;
1553 }
1554 }
1555}
1556
Jiaqing Zhao7857cb82023-03-03 11:23:08 +08001557inline std::string extractParentInterfaceName(const std::string& ifaceId)
1558{
1559 std::size_t pos = ifaceId.find('_');
1560 return ifaceId.substr(0, pos);
1561}
1562
Ed Tanous77179532023-02-28 10:45:28 -08001563inline void
1564 parseInterfaceData(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1565 const std::string& ifaceId,
1566 const EthernetInterfaceData& ethData,
1567 const std::vector<IPv4AddressData>& ipv4Data,
1568 const std::vector<IPv6AddressData>& ipv6Data)
Ed Tanousbf648f72021-06-03 15:00:14 -07001569{
Ed Tanousbf648f72021-06-03 15:00:14 -07001570 nlohmann::json& jsonResponse = asyncResp->res.jsonValue;
1571 jsonResponse["Id"] = ifaceId;
Ed Tanousef4c65b2023-04-24 15:28:50 -07001572 jsonResponse["@odata.id"] = boost::urls::format(
1573 "/redfish/v1/Managers/bmc/EthernetInterfaces/{}", ifaceId);
Ed Tanousbf648f72021-06-03 15:00:14 -07001574 jsonResponse["InterfaceEnabled"] = ethData.nicEnabled;
1575
Willy Tu13451e32023-05-24 16:08:18 -07001576 if constexpr (bmcwebEnableHealthPopulate)
1577 {
1578 constexpr std::array<std::string_view, 1> inventoryForEthernet = {
1579 "xyz.openbmc_project.Inventory.Item.Ethernet"};
1580 auto health = std::make_shared<HealthPopulate>(asyncResp);
1581 dbus::utility::getSubTreePaths(
1582 "/", 0, inventoryForEthernet,
1583 [health](const boost::system::error_code& ec,
1584 const dbus::utility::MapperGetSubTreePathsResponse& resp) {
1585 if (ec)
1586 {
1587 return;
1588 }
Ed Tanousbf648f72021-06-03 15:00:14 -07001589
Willy Tu13451e32023-05-24 16:08:18 -07001590 health->inventory = resp;
1591 });
Ed Tanousbf648f72021-06-03 15:00:14 -07001592
Willy Tu13451e32023-05-24 16:08:18 -07001593 health->populate();
1594 }
Ed Tanousbf648f72021-06-03 15:00:14 -07001595
1596 if (ethData.nicEnabled)
1597 {
Johnathan Mantey0ef0e282022-11-15 12:15:02 -08001598 jsonResponse["LinkStatus"] = ethData.linkUp ? "LinkUp" : "LinkDown";
Ed Tanousbf648f72021-06-03 15:00:14 -07001599 jsonResponse["Status"]["State"] = "Enabled";
1600 }
1601 else
1602 {
1603 jsonResponse["LinkStatus"] = "NoLink";
1604 jsonResponse["Status"]["State"] = "Disabled";
1605 }
1606
Ed Tanousbf648f72021-06-03 15:00:14 -07001607 jsonResponse["SpeedMbps"] = ethData.speed;
Tejas Patil35fb5312021-09-20 15:35:20 +05301608 jsonResponse["MTUSize"] = ethData.mtuSize;
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001609 jsonResponse["MACAddress"] = ethData.macAddress;
Ed Tanousbf648f72021-06-03 15:00:14 -07001610 jsonResponse["DHCPv4"]["DHCPEnabled"] =
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001611 translateDhcpEnabledToBool(ethData.dhcpEnabled, true);
1612 jsonResponse["DHCPv4"]["UseNTPServers"] = ethData.ntpEnabled;
1613 jsonResponse["DHCPv4"]["UseDNSServers"] = ethData.dnsEnabled;
1614 jsonResponse["DHCPv4"]["UseDomainName"] = ethData.hostNameEnabled;
Ed Tanousbf648f72021-06-03 15:00:14 -07001615
1616 jsonResponse["DHCPv6"]["OperatingMode"] =
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001617 translateDhcpEnabledToBool(ethData.dhcpEnabled, false) ? "Stateful"
Ed Tanousbf648f72021-06-03 15:00:14 -07001618 : "Disabled";
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001619 jsonResponse["DHCPv6"]["UseNTPServers"] = ethData.ntpEnabled;
1620 jsonResponse["DHCPv6"]["UseDNSServers"] = ethData.dnsEnabled;
1621 jsonResponse["DHCPv6"]["UseDomainName"] = ethData.hostNameEnabled;
Ed Tanousbf648f72021-06-03 15:00:14 -07001622
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001623 if (!ethData.hostName.empty())
Ed Tanousbf648f72021-06-03 15:00:14 -07001624 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001625 jsonResponse["HostName"] = ethData.hostName;
Ed Tanousbf648f72021-06-03 15:00:14 -07001626
1627 // When domain name is empty then it means, that it is a network
1628 // without domain names, and the host name itself must be treated as
1629 // FQDN
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001630 std::string fqdn = ethData.hostName;
Ed Tanousbf648f72021-06-03 15:00:14 -07001631 if (!ethData.domainnames.empty())
1632 {
1633 fqdn += "." + ethData.domainnames[0];
1634 }
1635 jsonResponse["FQDN"] = fqdn;
1636 }
1637
Jiaqing Zhao7857cb82023-03-03 11:23:08 +08001638 if (ethData.vlanId)
1639 {
1640 jsonResponse["EthernetInterfaceType"] = "Virtual";
1641 jsonResponse["VLAN"]["VLANEnable"] = true;
1642 jsonResponse["VLAN"]["VLANId"] = *ethData.vlanId;
1643 jsonResponse["VLAN"]["Tagged"] = true;
1644
1645 nlohmann::json::array_t relatedInterfaces;
1646 nlohmann::json& parentInterface = relatedInterfaces.emplace_back();
1647 parentInterface["@odata.id"] =
1648 boost::urls::format("/redfish/v1/Managers/bmc/EthernetInterfaces",
1649 extractParentInterfaceName(ifaceId));
1650 jsonResponse["Links"]["RelatedInterfaces"] =
1651 std::move(relatedInterfaces);
1652 }
1653 else
1654 {
1655 jsonResponse["EthernetInterfaceType"] = "Physical";
1656 }
1657
Ed Tanousbf648f72021-06-03 15:00:14 -07001658 jsonResponse["NameServers"] = ethData.nameServers;
1659 jsonResponse["StaticNameServers"] = ethData.staticNameServers;
1660
1661 nlohmann::json& ipv4Array = jsonResponse["IPv4Addresses"];
1662 nlohmann::json& ipv4StaticArray = jsonResponse["IPv4StaticAddresses"];
1663 ipv4Array = nlohmann::json::array();
1664 ipv4StaticArray = nlohmann::json::array();
Ed Tanous9eb808c2022-01-25 10:19:23 -08001665 for (const auto& ipv4Config : ipv4Data)
Ed Tanousbf648f72021-06-03 15:00:14 -07001666 {
Ed Tanousbf648f72021-06-03 15:00:14 -07001667 std::string gatewayStr = ipv4Config.gateway;
1668 if (gatewayStr.empty())
1669 {
1670 gatewayStr = "0.0.0.0";
1671 }
Ed Tanous14766872022-03-15 10:44:42 -07001672 nlohmann::json::object_t ipv4;
1673 ipv4["AddressOrigin"] = ipv4Config.origin;
1674 ipv4["SubnetMask"] = ipv4Config.netmask;
1675 ipv4["Address"] = ipv4Config.address;
1676 ipv4["Gateway"] = gatewayStr;
Ed Tanousbf648f72021-06-03 15:00:14 -07001677
Ed Tanousbf648f72021-06-03 15:00:14 -07001678 if (ipv4Config.origin == "Static")
1679 {
Ed Tanous14766872022-03-15 10:44:42 -07001680 ipv4StaticArray.push_back(ipv4);
Ed Tanousbf648f72021-06-03 15:00:14 -07001681 }
Ed Tanous14766872022-03-15 10:44:42 -07001682
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001683 ipv4Array.emplace_back(std::move(ipv4));
Ed Tanousbf648f72021-06-03 15:00:14 -07001684 }
1685
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001686 std::string ipv6GatewayStr = ethData.ipv6DefaultGateway;
Ed Tanousbf648f72021-06-03 15:00:14 -07001687 if (ipv6GatewayStr.empty())
1688 {
1689 ipv6GatewayStr = "0:0:0:0:0:0:0:0";
1690 }
1691
1692 jsonResponse["IPv6DefaultGateway"] = ipv6GatewayStr;
1693
1694 nlohmann::json& ipv6Array = jsonResponse["IPv6Addresses"];
1695 nlohmann::json& ipv6StaticArray = jsonResponse["IPv6StaticAddresses"];
1696 ipv6Array = nlohmann::json::array();
1697 ipv6StaticArray = nlohmann::json::array();
1698 nlohmann::json& ipv6AddrPolicyTable =
1699 jsonResponse["IPv6AddressPolicyTable"];
1700 ipv6AddrPolicyTable = nlohmann::json::array();
Ed Tanous9eb808c2022-01-25 10:19:23 -08001701 for (const auto& ipv6Config : ipv6Data)
Ed Tanousbf648f72021-06-03 15:00:14 -07001702 {
Ed Tanous14766872022-03-15 10:44:42 -07001703 nlohmann::json::object_t ipv6;
1704 ipv6["Address"] = ipv6Config.address;
1705 ipv6["PrefixLength"] = ipv6Config.prefixLength;
1706 ipv6["AddressOrigin"] = ipv6Config.origin;
Sunitha Harishf8361272023-03-16 03:23:59 -05001707
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001708 ipv6Array.emplace_back(std::move(ipv6));
Ed Tanousbf648f72021-06-03 15:00:14 -07001709 if (ipv6Config.origin == "Static")
1710 {
Ed Tanous14766872022-03-15 10:44:42 -07001711 nlohmann::json::object_t ipv6Static;
1712 ipv6Static["Address"] = ipv6Config.address;
1713 ipv6Static["PrefixLength"] = ipv6Config.prefixLength;
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001714 ipv6StaticArray.emplace_back(std::move(ipv6Static));
Ed Tanousbf648f72021-06-03 15:00:14 -07001715 }
1716 }
1717}
1718
Jiaqing Zhaoe7caf252023-03-09 11:14:44 +08001719inline void afterDelete(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1720 const std::string& ifaceId,
1721 const boost::system::error_code& ec,
1722 const sdbusplus::message_t& m)
1723{
1724 if (!ec)
1725 {
1726 return;
1727 }
1728 const sd_bus_error* dbusError = m.get_error();
1729 if (dbusError == nullptr)
1730 {
1731 messages::internalError(asyncResp->res);
1732 return;
1733 }
1734 BMCWEB_LOG_DEBUG << "DBus error: " << dbusError->name;
1735
1736 if (std::string_view("org.freedesktop.DBus.Error.UnknownObject") ==
1737 dbusError->name)
1738 {
1739 messages::resourceNotFound(asyncResp->res, "EthernetInterface",
1740 ifaceId);
1741 return;
1742 }
1743 if (std::string_view("org.freedesktop.DBus.Error.UnknownMethod") ==
1744 dbusError->name)
1745 {
1746 messages::resourceCannotBeDeleted(asyncResp->res);
1747 return;
1748 }
1749 messages::internalError(asyncResp->res);
1750}
1751
Jiaqing Zhaob5ca3fd2023-03-08 15:14:58 +08001752inline void afterVlanCreate(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1753 const std::string& parentInterfaceUri,
1754 const std::string& vlanInterface,
1755 const boost::system::error_code& ec,
1756 const sdbusplus::message_t& m
1757
1758)
1759{
1760 if (ec)
1761 {
1762 const sd_bus_error* dbusError = m.get_error();
1763 if (dbusError == nullptr)
1764 {
1765 messages::internalError(asyncResp->res);
1766 return;
1767 }
1768 BMCWEB_LOG_DEBUG << "DBus error: " << dbusError->name;
1769
1770 if (std::string_view(
1771 "xyz.openbmc_project.Common.Error.ResourceNotFound") ==
1772 dbusError->name)
1773 {
1774 messages::propertyValueNotInList(
1775 asyncResp->res, parentInterfaceUri,
1776 "Links/RelatedInterfaces/0/@odata.id");
1777 return;
1778 }
1779 if (std::string_view(
1780 "xyz.openbmc_project.Common.Error.InvalidArgument") ==
1781 dbusError->name)
1782 {
1783 messages::resourceAlreadyExists(asyncResp->res, "EthernetInterface",
1784 "Id", vlanInterface);
1785 return;
1786 }
1787 messages::internalError(asyncResp->res);
1788 return;
1789 }
1790
1791 const boost::urls::url vlanInterfaceUri = boost::urls::format(
1792 "/redfish/v1/Managers/bmc/EthernetInterfaces/{}", vlanInterface);
1793 asyncResp->res.addHeader("Location", vlanInterfaceUri.buffer());
1794}
1795
Ed Tanousbf648f72021-06-03 15:00:14 -07001796inline void requestEthernetInterfacesRoutes(App& app)
1797{
1798 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/")
Ed Tanoused398212021-06-09 17:05:54 -07001799 .privileges(redfish::privileges::getEthernetInterfaceCollection)
Ed Tanous14766872022-03-15 10:44:42 -07001800 .methods(boost::beast::http::verb::get)(
1801 [&app](const crow::Request& req,
1802 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001803 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001804 {
1805 return;
1806 }
1807
1808 asyncResp->res.jsonValue["@odata.type"] =
1809 "#EthernetInterfaceCollection.EthernetInterfaceCollection";
1810 asyncResp->res.jsonValue["@odata.id"] =
1811 "/redfish/v1/Managers/bmc/EthernetInterfaces";
1812 asyncResp->res.jsonValue["Name"] =
1813 "Ethernet Network Interface Collection";
1814 asyncResp->res.jsonValue["Description"] =
1815 "Collection of EthernetInterfaces for this Manager";
1816
1817 // Get eth interface list, and call the below callback for JSON
1818 // preparation
1819 getEthernetIfaceList(
Ed Tanous77179532023-02-28 10:45:28 -08001820 [asyncResp](const bool& success,
1821 const std::vector<std::string>& ifaceList) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001822 if (!success)
1823 {
1824 messages::internalError(asyncResp->res);
1825 return;
1826 }
1827
1828 nlohmann::json& ifaceArray = asyncResp->res.jsonValue["Members"];
1829 ifaceArray = nlohmann::json::array();
Ed Tanous002d39b2022-05-31 08:59:27 -07001830 for (const std::string& ifaceItem : ifaceList)
1831 {
Jiaqing Zhao7857cb82023-03-03 11:23:08 +08001832 nlohmann::json::object_t iface;
1833 iface["@odata.id"] = boost::urls::format(
1834 "/redfish/v1/Managers/bmc/EthernetInterfaces/{}",
1835 ifaceItem);
1836 ifaceArray.push_back(std::move(iface));
Ed Tanous002d39b2022-05-31 08:59:27 -07001837 }
Jason M. Billsf12894f2018-10-09 12:45:45 -07001838
Ed Tanous002d39b2022-05-31 08:59:27 -07001839 asyncResp->res.jsonValue["Members@odata.count"] = ifaceArray.size();
1840 asyncResp->res.jsonValue["@odata.id"] =
1841 "/redfish/v1/Managers/bmc/EthernetInterfaces";
1842 });
1843 });
Johnathan Mantey01784822019-06-18 12:44:21 -07001844
Jiaqing Zhaob5ca3fd2023-03-08 15:14:58 +08001845 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/")
1846 .privileges(redfish::privileges::postEthernetInterfaceCollection)
1847 .methods(boost::beast::http::verb::post)(
1848 [&app](const crow::Request& req,
1849 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
1850 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1851 {
1852 return;
1853 }
1854
1855 bool vlanEnable = false;
1856 uint32_t vlanId = 0;
1857 nlohmann::json::array_t relatedInterfaces;
1858
1859 if (!json_util::readJsonPatch(req, asyncResp->res, "VLAN/VLANEnable",
1860 vlanEnable, "VLAN/VLANId", vlanId,
1861 "Links/RelatedInterfaces",
1862 relatedInterfaces))
1863 {
1864 return;
1865 }
1866
1867 if (relatedInterfaces.size() != 1)
1868 {
1869 messages::arraySizeTooLong(asyncResp->res,
1870 "Links/RelatedInterfaces",
1871 relatedInterfaces.size());
1872 return;
1873 }
1874
1875 std::string parentInterfaceUri;
1876 if (!json_util::readJson(relatedInterfaces[0], asyncResp->res,
1877 "@odata.id", parentInterfaceUri))
1878 {
1879 messages::propertyMissing(asyncResp->res,
1880 "Links/RelatedInterfaces/0/@odata.id");
1881 return;
1882 }
1883 BMCWEB_LOG_INFO << "Parent Interface URI: " << parentInterfaceUri;
1884
1885 boost::urls::result<boost::urls::url_view> parsedUri =
1886 boost::urls::parse_relative_ref(parentInterfaceUri);
1887 if (!parsedUri)
1888 {
1889 messages::propertyValueFormatError(
1890 asyncResp->res, parentInterfaceUri,
1891 "Links/RelatedInterfaces/0/@odata.id");
1892 return;
1893 }
1894
1895 std::string parentInterface;
1896 if (!crow::utility::readUrlSegments(
1897 *parsedUri, "redfish", "v1", "Managers", "bmc",
1898 "EthernetInterfaces", std::ref(parentInterface)))
1899 {
1900 messages::propertyValueNotInList(
1901 asyncResp->res, parentInterfaceUri,
1902 "Links/RelatedInterfaces/0/@odata.id");
1903 return;
1904 }
1905
1906 if (!vlanEnable)
1907 {
1908 // In OpenBMC implementation, VLANEnable cannot be false on
1909 // create
1910 messages::propertyValueIncorrect(asyncResp->res, "VLAN/VLANEnable",
1911 "false");
1912 return;
1913 }
1914
1915 std::string vlanInterface = parentInterface + "_" +
1916 std::to_string(vlanId);
1917 crow::connections::systemBus->async_method_call(
1918 [asyncResp, parentInterfaceUri,
1919 vlanInterface](const boost::system::error_code& ec,
1920 const sdbusplus::message_t& m) {
1921 afterVlanCreate(asyncResp, parentInterfaceUri, vlanInterface, ec,
1922 m);
1923 },
1924 "xyz.openbmc_project.Network", "/xyz/openbmc_project/network",
1925 "xyz.openbmc_project.Network.VLAN.Create", "VLAN", parentInterface,
1926 vlanId);
1927 });
1928
Ed Tanousbf648f72021-06-03 15:00:14 -07001929 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001930 .privileges(redfish::privileges::getEthernetInterface)
Ed Tanousbf648f72021-06-03 15:00:14 -07001931 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001932 [&app](const crow::Request& req,
1933 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1934 const std::string& ifaceId) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001935 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001936 {
1937 return;
1938 }
1939 getEthernetIfaceData(
1940 ifaceId,
Ed Tanous77179532023-02-28 10:45:28 -08001941 [asyncResp, ifaceId](const bool& success,
1942 const EthernetInterfaceData& ethData,
1943 const std::vector<IPv4AddressData>& ipv4Data,
1944 const std::vector<IPv6AddressData>& ipv6Data) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001945 if (!success)
1946 {
1947 // TODO(Pawel)consider distinguish between non
1948 // existing object, and other errors
1949 messages::resourceNotFound(asyncResp->res, "EthernetInterface",
1950 ifaceId);
1951 return;
1952 }
Johnathan Mantey01784822019-06-18 12:44:21 -07001953
Ed Tanous002d39b2022-05-31 08:59:27 -07001954 asyncResp->res.jsonValue["@odata.type"] =
Jiaqing Zhao93bbc952023-02-23 14:11:20 +08001955 "#EthernetInterface.v1_9_0.EthernetInterface";
Ed Tanous002d39b2022-05-31 08:59:27 -07001956 asyncResp->res.jsonValue["Name"] = "Manager Ethernet Interface";
1957 asyncResp->res.jsonValue["Description"] =
1958 "Management Network Interface";
Ratan Guptaf476acb2019-03-02 16:46:57 +05301959
Ed Tanous002d39b2022-05-31 08:59:27 -07001960 parseInterfaceData(asyncResp, ifaceId, ethData, ipv4Data, ipv6Data);
Ed Tanousbf648f72021-06-03 15:00:14 -07001961 });
Ed Tanous002d39b2022-05-31 08:59:27 -07001962 });
Johnathan Mantey01784822019-06-18 12:44:21 -07001963
Ed Tanousbf648f72021-06-03 15:00:14 -07001964 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001965 .privileges(redfish::privileges::patchEthernetInterface)
Ed Tanousbf648f72021-06-03 15:00:14 -07001966 .methods(boost::beast::http::verb::patch)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001967 [&app](const crow::Request& req,
1968 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1969 const std::string& ifaceId) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001970 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001971 {
1972 return;
1973 }
1974 std::optional<std::string> hostname;
1975 std::optional<std::string> fqdn;
1976 std::optional<std::string> macAddress;
1977 std::optional<std::string> ipv6DefaultGateway;
Ed Tanousddd70dc2023-03-01 16:00:27 -08001978 std::optional<nlohmann::json::array_t> ipv4StaticAddresses;
1979 std::optional<nlohmann::json::array_t> ipv6StaticAddresses;
Ed Tanous002d39b2022-05-31 08:59:27 -07001980 std::optional<std::vector<std::string>> staticNameServers;
1981 std::optional<nlohmann::json> dhcpv4;
1982 std::optional<nlohmann::json> dhcpv6;
1983 std::optional<bool> interfaceEnabled;
1984 std::optional<size_t> mtuSize;
1985 DHCPParameters v4dhcpParms;
1986 DHCPParameters v6dhcpParms;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001987
Ed Tanous002d39b2022-05-31 08:59:27 -07001988 if (!json_util::readJsonPatch(
1989 req, asyncResp->res, "HostName", hostname, "FQDN", fqdn,
1990 "IPv4StaticAddresses", ipv4StaticAddresses, "MACAddress",
1991 macAddress, "StaticNameServers", staticNameServers,
1992 "IPv6DefaultGateway", ipv6DefaultGateway, "IPv6StaticAddresses",
1993 ipv6StaticAddresses, "DHCPv4", dhcpv4, "DHCPv6", dhcpv6,
1994 "MTUSize", mtuSize, "InterfaceEnabled", interfaceEnabled))
1995 {
1996 return;
1997 }
1998 if (dhcpv4)
1999 {
2000 if (!json_util::readJson(*dhcpv4, asyncResp->res, "DHCPEnabled",
2001 v4dhcpParms.dhcpv4Enabled, "UseDNSServers",
2002 v4dhcpParms.useDnsServers, "UseNTPServers",
2003 v4dhcpParms.useNtpServers, "UseDomainName",
2004 v4dhcpParms.useDomainName))
2005 {
2006 return;
2007 }
2008 }
Johnathan Mantey01784822019-06-18 12:44:21 -07002009
Ed Tanous002d39b2022-05-31 08:59:27 -07002010 if (dhcpv6)
2011 {
2012 if (!json_util::readJson(*dhcpv6, asyncResp->res, "OperatingMode",
2013 v6dhcpParms.dhcpv6OperatingMode,
2014 "UseDNSServers", v6dhcpParms.useDnsServers,
2015 "UseNTPServers", v6dhcpParms.useNtpServers,
2016 "UseDomainName",
2017 v6dhcpParms.useDomainName))
2018 {
2019 return;
2020 }
2021 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002022
Ed Tanous002d39b2022-05-31 08:59:27 -07002023 // Get single eth interface data, and call the below callback
2024 // for JSON preparation
2025 getEthernetIfaceData(
2026 ifaceId,
2027 [asyncResp, ifaceId, hostname = std::move(hostname),
2028 fqdn = std::move(fqdn), macAddress = std::move(macAddress),
2029 ipv4StaticAddresses = std::move(ipv4StaticAddresses),
2030 ipv6DefaultGateway = std::move(ipv6DefaultGateway),
2031 ipv6StaticAddresses = std::move(ipv6StaticAddresses),
2032 staticNameServers = std::move(staticNameServers),
Ed Tanousbc200892022-06-30 17:49:12 -07002033 dhcpv4 = std::move(dhcpv4), dhcpv6 = std::move(dhcpv6), mtuSize,
2034 v4dhcpParms = std::move(v4dhcpParms),
Ed Tanous002d39b2022-05-31 08:59:27 -07002035 v6dhcpParms = std::move(v6dhcpParms), interfaceEnabled](
2036 const bool& success, const EthernetInterfaceData& ethData,
Ed Tanous77179532023-02-28 10:45:28 -08002037 const std::vector<IPv4AddressData>& ipv4Data,
2038 const std::vector<IPv6AddressData>& ipv6Data) {
Ed Tanous002d39b2022-05-31 08:59:27 -07002039 if (!success)
2040 {
2041 // ... otherwise return error
2042 // TODO(Pawel)consider distinguish between non
2043 // existing object, and other errors
Jiaqing Zhaod8a5d5d2022-08-05 16:21:51 +08002044 messages::resourceNotFound(asyncResp->res, "EthernetInterface",
Ed Tanous002d39b2022-05-31 08:59:27 -07002045 ifaceId);
2046 return;
2047 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05002048
Ed Tanous002d39b2022-05-31 08:59:27 -07002049 if (dhcpv4 || dhcpv6)
2050 {
2051 handleDHCPPatch(ifaceId, ethData, v4dhcpParms, v6dhcpParms,
Ed Tanousbf648f72021-06-03 15:00:14 -07002052 asyncResp);
Ed Tanous002d39b2022-05-31 08:59:27 -07002053 }
Tejas Patil35fb5312021-09-20 15:35:20 +05302054
Ed Tanous002d39b2022-05-31 08:59:27 -07002055 if (hostname)
2056 {
2057 handleHostnamePatch(*hostname, asyncResp);
2058 }
2059
2060 if (fqdn)
2061 {
2062 handleFqdnPatch(ifaceId, *fqdn, asyncResp);
2063 }
2064
2065 if (macAddress)
2066 {
2067 handleMACAddressPatch(ifaceId, *macAddress, asyncResp);
2068 }
2069
2070 if (ipv4StaticAddresses)
2071 {
2072 // TODO(ed) for some reason the capture of
2073 // ipv4Addresses above is returning a const value,
2074 // not a non-const value. This doesn't really work
2075 // for us, as we need to be able to efficiently move
2076 // out the intermedia nlohmann::json objects. This
2077 // makes a copy of the structure, and operates on
2078 // that, but could be done more efficiently
Ed Tanousddd70dc2023-03-01 16:00:27 -08002079 nlohmann::json::array_t ipv4Static = *ipv4StaticAddresses;
Ed Tanous002d39b2022-05-31 08:59:27 -07002080 handleIPv4StaticPatch(ifaceId, ipv4Static, ipv4Data, asyncResp);
2081 }
2082
2083 if (staticNameServers)
2084 {
2085 handleStaticNameServersPatch(ifaceId, *staticNameServers,
2086 asyncResp);
2087 }
2088
2089 if (ipv6DefaultGateway)
2090 {
2091 messages::propertyNotWritable(asyncResp->res,
2092 "IPv6DefaultGateway");
2093 }
2094
2095 if (ipv6StaticAddresses)
2096 {
Ed Tanousddd70dc2023-03-01 16:00:27 -08002097 handleIPv6StaticAddressesPatch(ifaceId, *ipv6StaticAddresses,
2098 ipv6Data, asyncResp);
Ed Tanous002d39b2022-05-31 08:59:27 -07002099 }
2100
2101 if (interfaceEnabled)
2102 {
2103 setEthernetInterfaceBoolProperty(ifaceId, "NICEnabled",
2104 *interfaceEnabled, asyncResp);
2105 }
2106
2107 if (mtuSize)
2108 {
2109 handleMTUSizePatch(ifaceId, *mtuSize, asyncResp);
2110 }
Ed Tanousbf648f72021-06-03 15:00:14 -07002111 });
Ed Tanous002d39b2022-05-31 08:59:27 -07002112 });
Jiaqing Zhaoe7caf252023-03-09 11:14:44 +08002113
2114 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/")
2115 .privileges(redfish::privileges::deleteEthernetInterface)
2116 .methods(boost::beast::http::verb::delete_)(
2117 [&app](const crow::Request& req,
2118 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2119 const std::string& ifaceId) {
2120 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2121 {
2122 return;
2123 }
2124
2125 crow::connections::systemBus->async_method_call(
2126 [asyncResp, ifaceId](const boost::system::error_code& ec,
2127 const sdbusplus::message_t& m) {
2128 afterDelete(asyncResp, ifaceId, ec, m);
2129 },
2130 "xyz.openbmc_project.Network",
2131 std::string("/xyz/openbmc_project/network/") + ifaceId,
2132 "xyz.openbmc_project.Object.Delete", "Delete");
2133 });
Ed Tanousbf648f72021-06-03 15:00:14 -07002134}
2135
Ed Tanous1abe55e2018-09-05 08:30:59 -07002136} // namespace redfish