blob: b74af346982593e878fd493690aa5202931e039f [file] [log] [blame]
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +01001/*
2// Copyright (c) 2018 Intel Corporation
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15*/
16#pragma once
17
Ed Tanous033f1e42022-08-15 09:47:37 -070018#include "utils/ip_utils.hpp"
19
John Edward Broadbent7e860f12021-04-08 15:57:16 -070020#include <app.hpp>
Ed Tanous11ba3972022-07-11 09:50:41 -070021#include <boost/algorithm/string/classification.hpp>
22#include <boost/algorithm/string/split.hpp>
Ed Tanous4a0cb852018-10-15 07:55:04 -070023#include <boost/container/flat_set.hpp>
Kowalski, Kamil179db1d2018-04-23 11:12:41 +020024#include <dbus_singleton.hpp>
Ed Tanous168e20c2021-12-13 14:39:53 -080025#include <dbus_utility.hpp>
Kowalski, Kamil588c3f02018-04-03 14:55:27 +020026#include <error_messages.hpp>
Ed Tanous45ca1b82022-03-25 13:07:27 -070027#include <query.hpp>
Ed Tanoused398212021-06-09 17:05:54 -070028#include <registries/privilege_registry.hpp>
Gunnar Mills1214b7e2020-06-04 10:11:30 -050029#include <utils/json_utils.hpp>
30
Ed Tanousa24526d2018-12-10 15:17:59 -080031#include <optional>
Joshi-Mansiab6554f2020-03-10 18:33:36 +053032#include <regex>
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010033
Ed Tanous1abe55e2018-09-05 08:30:59 -070034namespace redfish
35{
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010036
Ed Tanous4a0cb852018-10-15 07:55:04 -070037enum class LinkType
38{
39 Local,
40 Global
41};
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010042
43/**
44 * Structure for keeping IPv4 data required by Redfish
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010045 */
Ed Tanous1abe55e2018-09-05 08:30:59 -070046struct IPv4AddressData
47{
48 std::string id;
Ed Tanous4a0cb852018-10-15 07:55:04 -070049 std::string address;
50 std::string domain;
51 std::string gateway;
Ed Tanous1abe55e2018-09-05 08:30:59 -070052 std::string netmask;
53 std::string origin;
Ed Tanous4a0cb852018-10-15 07:55:04 -070054 LinkType linktype;
Sunitha Harish01c6e852020-03-20 05:04:09 -050055 bool isActive;
Ed Tanous4a0cb852018-10-15 07:55:04 -070056
Gunnar Mills1214b7e2020-06-04 10:11:30 -050057 bool operator<(const IPv4AddressData& obj) const
Ed Tanous1abe55e2018-09-05 08:30:59 -070058 {
Ed Tanous4a0cb852018-10-15 07:55:04 -070059 return id < obj.id;
Ed Tanous1abe55e2018-09-05 08:30:59 -070060 }
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010061};
62
63/**
Ravi Tejae48c0fc2019-04-16 08:37:20 -050064 * Structure for keeping IPv6 data required by Redfish
65 */
66struct IPv6AddressData
67{
68 std::string id;
69 std::string address;
70 std::string origin;
71 uint8_t prefixLength;
72
Gunnar Mills1214b7e2020-06-04 10:11:30 -050073 bool operator<(const IPv6AddressData& obj) const
Ravi Tejae48c0fc2019-04-16 08:37:20 -050074 {
75 return id < obj.id;
76 }
77};
78/**
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010079 * Structure for keeping basic single Ethernet Interface information
80 * available from DBus
81 */
Ed Tanous1abe55e2018-09-05 08:30:59 -070082struct EthernetInterfaceData
83{
Ed Tanous4a0cb852018-10-15 07:55:04 -070084 uint32_t speed;
Tejas Patil35fb5312021-09-20 15:35:20 +053085 size_t mtuSize;
Jiaqing Zhao82695a52022-04-14 15:15:59 +080086 bool autoNeg;
87 bool dnsEnabled;
88 bool ntpEnabled;
89 bool hostNameEnabled;
Johnathan Manteyaa05fb22020-01-08 12:08:44 -080090 bool linkUp;
Johnathan Manteyeeedda22019-10-29 16:09:52 -070091 bool nicEnabled;
Jiaqing Zhao82695a52022-04-14 15:15:59 +080092 std::string dhcpEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -070093 std::string operatingMode;
Jiaqing Zhao82695a52022-04-14 15:15:59 +080094 std::string hostName;
95 std::string defaultGateway;
96 std::string ipv6DefaultGateway;
97 std::string macAddress;
Jiaqing Zhao17e22022022-04-14 18:58:06 +080098 std::optional<uint32_t> vlanId;
manojkiran.eda@gmail.com0f6efdc2019-10-03 04:53:44 -050099 std::vector<std::string> nameServers;
100 std::vector<std::string> staticNameServers;
Jennifer Leed24bfc72019-03-05 13:03:37 -0800101 std::vector<std::string> domainnames;
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +0100102};
103
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700104struct DHCPParameters
105{
106 std::optional<bool> dhcpv4Enabled;
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800107 std::optional<bool> useDnsServers;
108 std::optional<bool> useNtpServers;
109 std::optional<bool> useDomainName;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700110 std::optional<std::string> dhcpv6OperatingMode;
111};
112
Ed Tanous4a0cb852018-10-15 07:55:04 -0700113// Helper function that changes bits netmask notation (i.e. /24)
114// into full dot notation
115inline std::string getNetmask(unsigned int bits)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700116{
Ed Tanous4a0cb852018-10-15 07:55:04 -0700117 uint32_t value = 0xffffffff << (32 - bits);
118 std::string netmask = std::to_string((value >> 24) & 0xff) + "." +
119 std::to_string((value >> 16) & 0xff) + "." +
120 std::to_string((value >> 8) & 0xff) + "." +
121 std::to_string(value & 0xff);
122 return netmask;
123}
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +0100124
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800125inline bool translateDhcpEnabledToBool(const std::string& inputDHCP,
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700126 bool isIPv4)
127{
128 if (isIPv4)
129 {
130 return (
131 (inputDHCP ==
132 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v4") ||
133 (inputDHCP ==
134 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.both"));
135 }
136 return ((inputDHCP ==
137 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v6") ||
138 (inputDHCP ==
139 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.both"));
140}
141
Ed Tanous2c70f802020-09-28 14:29:23 -0700142inline std::string getDhcpEnabledEnumeration(bool isIPv4, bool isIPv6)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700143{
144 if (isIPv4 && isIPv6)
145 {
146 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.both";
147 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700148 if (isIPv4)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700149 {
150 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v4";
151 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700152 if (isIPv6)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700153 {
154 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v6";
155 }
156 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.none";
157}
158
Ed Tanous4a0cb852018-10-15 07:55:04 -0700159inline std::string
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500160 translateAddressOriginDbusToRedfish(const std::string& inputOrigin,
Ed Tanous4a0cb852018-10-15 07:55:04 -0700161 bool isIPv4)
162{
163 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.Static")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700164 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700165 return "Static";
166 }
167 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.LinkLocal")
168 {
169 if (isIPv4)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700170 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700171 return "IPv4LinkLocal";
172 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700173 return "LinkLocal";
Ed Tanous4a0cb852018-10-15 07:55:04 -0700174 }
175 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.DHCP")
176 {
177 if (isIPv4)
178 {
179 return "DHCP";
180 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700181 return "DHCPv6";
Ed Tanous4a0cb852018-10-15 07:55:04 -0700182 }
183 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.SLAAC")
184 {
185 return "SLAAC";
186 }
187 return "";
188}
189
Ed Tanous02cad962022-06-30 16:50:15 -0700190inline bool extractEthernetInterfaceData(
191 const std::string& ethifaceId,
192 const dbus::utility::ManagedObjectType& dbusData,
193 EthernetInterfaceData& ethData)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700194{
Ed Tanous4c9afe42019-05-03 16:59:57 -0700195 bool idFound = false;
Ed Tanous02cad962022-06-30 16:50:15 -0700196 for (const auto& objpath : dbusData)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700197 {
Ed Tanous02cad962022-06-30 16:50:15 -0700198 for (const auto& ifacePair : objpath.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700199 {
Ed Tanous81ce6092020-12-17 16:54:55 +0000200 if (objpath.first == "/xyz/openbmc_project/network/" + ethifaceId)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700201 {
Ed Tanous4c9afe42019-05-03 16:59:57 -0700202 idFound = true;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700203 if (ifacePair.first == "xyz.openbmc_project.Network.MACAddress")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700204 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500205 for (const auto& propertyPair : ifacePair.second)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700206 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700207 if (propertyPair.first == "MACAddress")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700208 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500209 const std::string* mac =
Ed Tanousabf2add2019-01-22 16:40:12 -0800210 std::get_if<std::string>(&propertyPair.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700211 if (mac != nullptr)
212 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800213 ethData.macAddress = *mac;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700214 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700215 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700216 }
217 }
218 else if (ifacePair.first == "xyz.openbmc_project.Network.VLAN")
219 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500220 for (const auto& propertyPair : ifacePair.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700221 {
222 if (propertyPair.first == "Id")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700223 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500224 const uint32_t* id =
Ed Tanousabf2add2019-01-22 16:40:12 -0800225 std::get_if<uint32_t>(&propertyPair.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700226 if (id != nullptr)
227 {
Jiaqing Zhao17e22022022-04-14 18:58:06 +0800228 ethData.vlanId = *id;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700229 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700230 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700231 }
232 }
233 else if (ifacePair.first ==
234 "xyz.openbmc_project.Network.EthernetInterface")
235 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500236 for (const auto& propertyPair : ifacePair.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700237 {
238 if (propertyPair.first == "AutoNeg")
239 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700240 const bool* autoNeg =
Ed Tanousabf2add2019-01-22 16:40:12 -0800241 std::get_if<bool>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700242 if (autoNeg != nullptr)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700243 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800244 ethData.autoNeg = *autoNeg;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700245 }
246 }
247 else if (propertyPair.first == "Speed")
248 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500249 const uint32_t* speed =
Ed Tanousabf2add2019-01-22 16:40:12 -0800250 std::get_if<uint32_t>(&propertyPair.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700251 if (speed != nullptr)
252 {
253 ethData.speed = *speed;
254 }
255 }
Tejas Patil35fb5312021-09-20 15:35:20 +0530256 else if (propertyPair.first == "MTU")
257 {
258 const uint32_t* mtuSize =
259 std::get_if<uint32_t>(&propertyPair.second);
260 if (mtuSize != nullptr)
261 {
262 ethData.mtuSize = *mtuSize;
263 }
264 }
Johnathan Manteyaa05fb22020-01-08 12:08:44 -0800265 else if (propertyPair.first == "LinkUp")
266 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500267 const bool* linkUp =
Johnathan Manteyaa05fb22020-01-08 12:08:44 -0800268 std::get_if<bool>(&propertyPair.second);
269 if (linkUp != nullptr)
270 {
271 ethData.linkUp = *linkUp;
272 }
273 }
Johnathan Manteyeeedda22019-10-29 16:09:52 -0700274 else if (propertyPair.first == "NICEnabled")
275 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500276 const bool* nicEnabled =
Johnathan Manteyeeedda22019-10-29 16:09:52 -0700277 std::get_if<bool>(&propertyPair.second);
278 if (nicEnabled != nullptr)
279 {
280 ethData.nicEnabled = *nicEnabled;
281 }
282 }
RAJESWARAN THILLAIGOVINDANf85837b2019-04-04 05:18:53 -0500283 else if (propertyPair.first == "Nameservers")
Ed Tanous4a0cb852018-10-15 07:55:04 -0700284 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500285 const std::vector<std::string>* nameservers =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500286 std::get_if<std::vector<std::string>>(
Ed Tanous029573d2019-02-01 10:57:49 -0800287 &propertyPair.second);
288 if (nameservers != nullptr)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700289 {
Ed Tanousf23b7292020-10-15 09:41:17 -0700290 ethData.nameServers = *nameservers;
manojkiran.eda@gmail.com0f6efdc2019-10-03 04:53:44 -0500291 }
292 }
293 else if (propertyPair.first == "StaticNameServers")
294 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500295 const std::vector<std::string>* staticNameServers =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500296 std::get_if<std::vector<std::string>>(
manojkiran.eda@gmail.com0f6efdc2019-10-03 04:53:44 -0500297 &propertyPair.second);
298 if (staticNameServers != nullptr)
299 {
Ed Tanousf23b7292020-10-15 09:41:17 -0700300 ethData.staticNameServers = *staticNameServers;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700301 }
302 }
manojkiraneda2a133282019-02-19 13:09:43 +0530303 else if (propertyPair.first == "DHCPEnabled")
304 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700305 const std::string* dhcpEnabled =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700306 std::get_if<std::string>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700307 if (dhcpEnabled != nullptr)
manojkiraneda2a133282019-02-19 13:09:43 +0530308 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800309 ethData.dhcpEnabled = *dhcpEnabled;
manojkiraneda2a133282019-02-19 13:09:43 +0530310 }
311 }
Jennifer Leed24bfc72019-03-05 13:03:37 -0800312 else if (propertyPair.first == "DomainName")
313 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500314 const std::vector<std::string>* domainNames =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500315 std::get_if<std::vector<std::string>>(
Jennifer Leed24bfc72019-03-05 13:03:37 -0800316 &propertyPair.second);
317 if (domainNames != nullptr)
318 {
Ed Tanousf23b7292020-10-15 09:41:17 -0700319 ethData.domainnames = *domainNames;
Jennifer Leed24bfc72019-03-05 13:03:37 -0800320 }
321 }
Ravi Teja9010ec22019-08-01 23:30:25 -0500322 else if (propertyPair.first == "DefaultGateway")
323 {
324 const std::string* defaultGateway =
325 std::get_if<std::string>(&propertyPair.second);
326 if (defaultGateway != nullptr)
327 {
328 std::string defaultGatewayStr = *defaultGateway;
329 if (defaultGatewayStr.empty())
330 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800331 ethData.defaultGateway = "0.0.0.0";
Ravi Teja9010ec22019-08-01 23:30:25 -0500332 }
333 else
334 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800335 ethData.defaultGateway = defaultGatewayStr;
Ravi Teja9010ec22019-08-01 23:30:25 -0500336 }
337 }
338 }
339 else if (propertyPair.first == "DefaultGateway6")
340 {
341 const std::string* defaultGateway6 =
342 std::get_if<std::string>(&propertyPair.second);
343 if (defaultGateway6 != nullptr)
344 {
345 std::string defaultGateway6Str =
346 *defaultGateway6;
347 if (defaultGateway6Str.empty())
348 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800349 ethData.ipv6DefaultGateway =
Ravi Teja9010ec22019-08-01 23:30:25 -0500350 "0:0:0:0:0:0:0:0";
351 }
352 else
353 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800354 ethData.ipv6DefaultGateway =
Ravi Teja9010ec22019-08-01 23:30:25 -0500355 defaultGateway6Str;
356 }
357 }
358 }
Ed Tanous029573d2019-02-01 10:57:49 -0800359 }
360 }
361 }
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700362
363 if (objpath.first == "/xyz/openbmc_project/network/config/dhcp")
364 {
365 if (ifacePair.first ==
366 "xyz.openbmc_project.Network.DHCPConfiguration")
367 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500368 for (const auto& propertyPair : ifacePair.second)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700369 {
370 if (propertyPair.first == "DNSEnabled")
371 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700372 const bool* dnsEnabled =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700373 std::get_if<bool>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700374 if (dnsEnabled != nullptr)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700375 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800376 ethData.dnsEnabled = *dnsEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700377 }
378 }
379 else if (propertyPair.first == "NTPEnabled")
380 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700381 const bool* ntpEnabled =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700382 std::get_if<bool>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700383 if (ntpEnabled != nullptr)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700384 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800385 ethData.ntpEnabled = *ntpEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700386 }
387 }
388 else if (propertyPair.first == "HostNameEnabled")
389 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700390 const bool* hostNameEnabled =
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700391 std::get_if<bool>(&propertyPair.second);
Ed Tanous2c70f802020-09-28 14:29:23 -0700392 if (hostNameEnabled != nullptr)
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700393 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800394 ethData.hostNameEnabled = *hostNameEnabled;
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700395 }
396 }
Johnathan Mantey1f8c7b52019-06-18 12:44:21 -0700397 }
398 }
399 }
Ed Tanous029573d2019-02-01 10:57:49 -0800400 // System configuration shows up in the global namespace, so no need
401 // to check eth number
402 if (ifacePair.first ==
403 "xyz.openbmc_project.Network.SystemConfiguration")
404 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500405 for (const auto& propertyPair : ifacePair.second)
Ed Tanous029573d2019-02-01 10:57:49 -0800406 {
407 if (propertyPair.first == "HostName")
408 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500409 const std::string* hostname =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500410 std::get_if<std::string>(&propertyPair.second);
Ed Tanous029573d2019-02-01 10:57:49 -0800411 if (hostname != nullptr)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700412 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +0800413 ethData.hostName = *hostname;
Ed Tanous029573d2019-02-01 10:57:49 -0800414 }
415 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700416 }
417 }
418 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700419 }
Ed Tanous4c9afe42019-05-03 16:59:57 -0700420 return idFound;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700421}
422
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500423// Helper function that extracts data for single ethernet ipv6 address
Johnathan Mantey01784822019-06-18 12:44:21 -0700424inline void
Ed Tanous81ce6092020-12-17 16:54:55 +0000425 extractIPV6Data(const std::string& ethifaceId,
Ed Tanous711ac7a2021-12-20 09:34:41 -0800426 const dbus::utility::ManagedObjectType& dbusData,
Ed Tanous81ce6092020-12-17 16:54:55 +0000427 boost::container::flat_set<IPv6AddressData>& ipv6Config)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500428{
429 const std::string ipv6PathStart =
Ed Tanous81ce6092020-12-17 16:54:55 +0000430 "/xyz/openbmc_project/network/" + ethifaceId + "/ipv6/";
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500431
432 // Since there might be several IPv6 configurations aligned with
433 // single ethernet interface, loop over all of them
Ed Tanous81ce6092020-12-17 16:54:55 +0000434 for (const auto& objpath : dbusData)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500435 {
436 // Check if proper pattern for object path appears
Ed Tanous11ba3972022-07-11 09:50:41 -0700437 if (objpath.first.str.starts_with(ipv6PathStart))
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500438 {
Ed Tanous9eb808c2022-01-25 10:19:23 -0800439 for (const auto& interface : objpath.second)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500440 {
441 if (interface.first == "xyz.openbmc_project.Network.IP")
442 {
443 // Instance IPv6AddressData structure, and set as
444 // appropriate
445 std::pair<
446 boost::container::flat_set<IPv6AddressData>::iterator,
447 bool>
Ed Tanous81ce6092020-12-17 16:54:55 +0000448 it = ipv6Config.insert(IPv6AddressData{});
Ed Tanous2c70f802020-09-28 14:29:23 -0700449 IPv6AddressData& ipv6Address = *it.first;
450 ipv6Address.id =
Ed Tanous271584a2019-07-09 16:24:22 -0700451 objpath.first.str.substr(ipv6PathStart.size());
Ed Tanous9eb808c2022-01-25 10:19:23 -0800452 for (const auto& property : interface.second)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500453 {
454 if (property.first == "Address")
455 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500456 const std::string* address =
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500457 std::get_if<std::string>(&property.second);
458 if (address != nullptr)
459 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700460 ipv6Address.address = *address;
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500461 }
462 }
463 else if (property.first == "Origin")
464 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500465 const std::string* origin =
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500466 std::get_if<std::string>(&property.second);
467 if (origin != nullptr)
468 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700469 ipv6Address.origin =
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500470 translateAddressOriginDbusToRedfish(*origin,
471 false);
472 }
473 }
474 else if (property.first == "PrefixLength")
475 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500476 const uint8_t* prefix =
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500477 std::get_if<uint8_t>(&property.second);
478 if (prefix != nullptr)
479 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700480 ipv6Address.prefixLength = *prefix;
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500481 }
482 }
Asmitha Karunanithi889ff692021-11-29 08:43:30 -0600483 else if (property.first == "Type" ||
484 property.first == "Gateway")
485 {
486 // Type & Gateway is not used
487 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500488 else
489 {
490 BMCWEB_LOG_ERROR
491 << "Got extra property: " << property.first
492 << " on the " << objpath.first.str << " object";
493 }
494 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500495 }
496 }
497 }
498 }
499}
500
Ed Tanous4a0cb852018-10-15 07:55:04 -0700501// Helper function that extracts data for single ethernet ipv4 address
Johnathan Mantey01784822019-06-18 12:44:21 -0700502inline void
Ed Tanous81ce6092020-12-17 16:54:55 +0000503 extractIPData(const std::string& ethifaceId,
Ed Tanous711ac7a2021-12-20 09:34:41 -0800504 const dbus::utility::ManagedObjectType& dbusData,
Ed Tanous81ce6092020-12-17 16:54:55 +0000505 boost::container::flat_set<IPv4AddressData>& ipv4Config)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700506{
507 const std::string ipv4PathStart =
Ed Tanous81ce6092020-12-17 16:54:55 +0000508 "/xyz/openbmc_project/network/" + ethifaceId + "/ipv4/";
Ed Tanous4a0cb852018-10-15 07:55:04 -0700509
510 // Since there might be several IPv4 configurations aligned with
511 // single ethernet interface, loop over all of them
Ed Tanous81ce6092020-12-17 16:54:55 +0000512 for (const auto& objpath : dbusData)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700513 {
514 // Check if proper pattern for object path appears
Ed Tanous11ba3972022-07-11 09:50:41 -0700515 if (objpath.first.str.starts_with(ipv4PathStart))
Ed Tanous4a0cb852018-10-15 07:55:04 -0700516 {
Ed Tanous9eb808c2022-01-25 10:19:23 -0800517 for (const auto& interface : objpath.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700518 {
519 if (interface.first == "xyz.openbmc_project.Network.IP")
520 {
521 // Instance IPv4AddressData structure, and set as
522 // appropriate
523 std::pair<
524 boost::container::flat_set<IPv4AddressData>::iterator,
525 bool>
Ed Tanous81ce6092020-12-17 16:54:55 +0000526 it = ipv4Config.insert(IPv4AddressData{});
Ed Tanous2c70f802020-09-28 14:29:23 -0700527 IPv4AddressData& ipv4Address = *it.first;
528 ipv4Address.id =
Ed Tanous271584a2019-07-09 16:24:22 -0700529 objpath.first.str.substr(ipv4PathStart.size());
Ed Tanous9eb808c2022-01-25 10:19:23 -0800530 for (const auto& property : interface.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700531 {
532 if (property.first == "Address")
533 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500534 const std::string* address =
Ed Tanousabf2add2019-01-22 16:40:12 -0800535 std::get_if<std::string>(&property.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700536 if (address != nullptr)
537 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700538 ipv4Address.address = *address;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700539 }
540 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700541 else if (property.first == "Origin")
542 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500543 const std::string* origin =
Ed Tanousabf2add2019-01-22 16:40:12 -0800544 std::get_if<std::string>(&property.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700545 if (origin != nullptr)
546 {
Ed Tanous2c70f802020-09-28 14:29:23 -0700547 ipv4Address.origin =
Ed Tanous4a0cb852018-10-15 07:55:04 -0700548 translateAddressOriginDbusToRedfish(*origin,
549 true);
550 }
551 }
552 else if (property.first == "PrefixLength")
553 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500554 const uint8_t* mask =
Ed Tanousabf2add2019-01-22 16:40:12 -0800555 std::get_if<uint8_t>(&property.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700556 if (mask != nullptr)
557 {
558 // convert it to the string
Ed Tanous2c70f802020-09-28 14:29:23 -0700559 ipv4Address.netmask = getNetmask(*mask);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700560 }
561 }
Asmitha Karunanithi889ff692021-11-29 08:43:30 -0600562 else if (property.first == "Type" ||
563 property.first == "Gateway")
564 {
565 // Type & Gateway is not used
566 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700567 else
568 {
569 BMCWEB_LOG_ERROR
570 << "Got extra property: " << property.first
571 << " on the " << objpath.first.str << " object";
572 }
573 }
574 // Check if given address is local, or global
Ed Tanous2c70f802020-09-28 14:29:23 -0700575 ipv4Address.linktype =
Ed Tanous11ba3972022-07-11 09:50:41 -0700576 ipv4Address.address.starts_with("169.254.")
Johnathan Mantey18659d12019-06-07 10:26:29 -0700577 ? LinkType::Local
578 : LinkType::Global;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700579 }
580 }
581 }
582 }
583}
584
585/**
Johnathan Mantey01784822019-06-18 12:44:21 -0700586 * @brief Deletes given IPv4 interface
Ed Tanous4a0cb852018-10-15 07:55:04 -0700587 *
588 * @param[in] ifaceId Id of interface whose IP should be deleted
Ed Tanous4a0cb852018-10-15 07:55:04 -0700589 * @param[in] ipHash DBus Hash id of IP that should be deleted
590 * @param[io] asyncResp Response object that will be returned to client
591 *
592 * @return None
593 */
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500594inline void deleteIPv4(const std::string& ifaceId, const std::string& ipHash,
zhanghch058d1b46d2021-04-01 11:18:24 +0800595 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700596{
597 crow::connections::systemBus->async_method_call(
Johnathan Mantey286b9112019-06-10 13:38:04 -0700598 [asyncResp](const boost::system::error_code ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700599 if (ec)
600 {
601 messages::internalError(asyncResp->res);
602 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700603 },
604 "xyz.openbmc_project.Network",
605 "/xyz/openbmc_project/network/" + ifaceId + "/ipv4/" + ipHash,
606 "xyz.openbmc_project.Object.Delete", "Delete");
607}
Ed Tanous1abe55e2018-09-05 08:30:59 -0700608
Gunnar Mills244b6d52021-04-12 15:44:23 -0500609inline void updateIPv4DefaultGateway(
610 const std::string& ifaceId, const std::string& gateway,
611 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ravi Teja9010ec22019-08-01 23:30:25 -0500612{
613 crow::connections::systemBus->async_method_call(
614 [asyncResp](const boost::system::error_code ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700615 if (ec)
616 {
617 messages::internalError(asyncResp->res);
618 return;
619 }
620 asyncResp->res.result(boost::beast::http::status::no_content);
Ravi Teja9010ec22019-08-01 23:30:25 -0500621 },
622 "xyz.openbmc_project.Network",
623 "/xyz/openbmc_project/network/" + ifaceId,
624 "org.freedesktop.DBus.Properties", "Set",
625 "xyz.openbmc_project.Network.EthernetInterface", "DefaultGateway",
Ed Tanous168e20c2021-12-13 14:39:53 -0800626 dbus::utility::DbusVariantType(gateway));
Ravi Teja9010ec22019-08-01 23:30:25 -0500627}
Ed Tanous4a0cb852018-10-15 07:55:04 -0700628/**
Johnathan Mantey01784822019-06-18 12:44:21 -0700629 * @brief Creates a static IPv4 entry
Ed Tanous4a0cb852018-10-15 07:55:04 -0700630 *
Johnathan Mantey01784822019-06-18 12:44:21 -0700631 * @param[in] ifaceId Id of interface upon which to create the IPv4 entry
632 * @param[in] prefixLength IPv4 prefix syntax for the subnet mask
633 * @param[in] gateway IPv4 address of this interfaces gateway
634 * @param[in] address IPv4 address to assign to this interface
635 * @param[io] asyncResp Response object that will be returned to client
Ed Tanous4a0cb852018-10-15 07:55:04 -0700636 *
637 * @return None
638 */
Ed Tanouscb13a392020-07-25 19:02:03 +0000639inline void createIPv4(const std::string& ifaceId, uint8_t prefixLength,
640 const std::string& gateway, const std::string& address,
zhanghch058d1b46d2021-04-01 11:18:24 +0800641 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700642{
Ed Tanous002d39b2022-05-31 08:59:27 -0700643 auto createIpHandler =
644 [asyncResp, ifaceId, gateway](const boost::system::error_code ec) {
Ravi Teja9010ec22019-08-01 23:30:25 -0500645 if (ec)
646 {
647 messages::internalError(asyncResp->res);
648 return;
649 }
650 updateIPv4DefaultGateway(ifaceId, gateway, asyncResp);
651 };
652
Ed Tanous4a0cb852018-10-15 07:55:04 -0700653 crow::connections::systemBus->async_method_call(
Ravi Teja9010ec22019-08-01 23:30:25 -0500654 std::move(createIpHandler), "xyz.openbmc_project.Network",
Ed Tanous4a0cb852018-10-15 07:55:04 -0700655 "/xyz/openbmc_project/network/" + ifaceId,
656 "xyz.openbmc_project.Network.IP.Create", "IP",
Johnathan Mantey01784822019-06-18 12:44:21 -0700657 "xyz.openbmc_project.Network.IP.Protocol.IPv4", address, prefixLength,
Ed Tanous4a0cb852018-10-15 07:55:04 -0700658 gateway);
659}
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500660
661/**
Johnathan Mantey01784822019-06-18 12:44:21 -0700662 * @brief Deletes the IPv4 entry for this interface and creates a replacement
663 * static IPv4 entry
664 *
665 * @param[in] ifaceId Id of interface upon which to create the IPv4 entry
666 * @param[in] id The unique hash entry identifying the DBus entry
667 * @param[in] prefixLength IPv4 prefix syntax for the subnet mask
668 * @param[in] gateway IPv4 address of this interfaces gateway
669 * @param[in] address IPv4 address to assign to this interface
670 * @param[io] asyncResp Response object that will be returned to client
671 *
672 * @return None
673 */
zhanghch058d1b46d2021-04-01 11:18:24 +0800674inline void
675 deleteAndCreateIPv4(const std::string& ifaceId, const std::string& id,
676 uint8_t prefixLength, const std::string& gateway,
677 const std::string& address,
678 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Johnathan Mantey01784822019-06-18 12:44:21 -0700679{
680 crow::connections::systemBus->async_method_call(
681 [asyncResp, ifaceId, address, prefixLength,
682 gateway](const boost::system::error_code ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700683 if (ec)
684 {
685 messages::internalError(asyncResp->res);
686 return;
687 }
688
689 crow::connections::systemBus->async_method_call(
690 [asyncResp, ifaceId, gateway](const boost::system::error_code ec2) {
691 if (ec2)
Johnathan Mantey01784822019-06-18 12:44:21 -0700692 {
693 messages::internalError(asyncResp->res);
Ravi Teja9010ec22019-08-01 23:30:25 -0500694 return;
Johnathan Mantey01784822019-06-18 12:44:21 -0700695 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700696 updateIPv4DefaultGateway(ifaceId, gateway, asyncResp);
697 },
698 "xyz.openbmc_project.Network",
699 "/xyz/openbmc_project/network/" + ifaceId,
700 "xyz.openbmc_project.Network.IP.Create", "IP",
701 "xyz.openbmc_project.Network.IP.Protocol.IPv4", address,
702 prefixLength, gateway);
Johnathan Mantey01784822019-06-18 12:44:21 -0700703 },
704 "xyz.openbmc_project.Network",
705 +"/xyz/openbmc_project/network/" + ifaceId + "/ipv4/" + id,
706 "xyz.openbmc_project.Object.Delete", "Delete");
707}
708
709/**
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500710 * @brief Deletes given IPv6
711 *
712 * @param[in] ifaceId Id of interface whose IP should be deleted
713 * @param[in] ipHash DBus Hash id of IP that should be deleted
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500714 * @param[io] asyncResp Response object that will be returned to client
715 *
716 * @return None
717 */
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500718inline void deleteIPv6(const std::string& ifaceId, const std::string& ipHash,
zhanghch058d1b46d2021-04-01 11:18:24 +0800719 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500720{
721 crow::connections::systemBus->async_method_call(
Johnathan Mantey286b9112019-06-10 13:38:04 -0700722 [asyncResp](const boost::system::error_code ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700723 if (ec)
724 {
725 messages::internalError(asyncResp->res);
726 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500727 },
728 "xyz.openbmc_project.Network",
729 "/xyz/openbmc_project/network/" + ifaceId + "/ipv6/" + ipHash,
730 "xyz.openbmc_project.Object.Delete", "Delete");
731}
732
733/**
Johnathan Mantey01784822019-06-18 12:44:21 -0700734 * @brief Deletes the IPv6 entry for this interface and creates a replacement
735 * static IPv6 entry
736 *
737 * @param[in] ifaceId Id of interface upon which to create the IPv6 entry
738 * @param[in] id The unique hash entry identifying the DBus entry
739 * @param[in] prefixLength IPv6 prefix syntax for the subnet mask
740 * @param[in] address IPv6 address to assign to this interface
741 * @param[io] asyncResp Response object that will be returned to client
742 *
743 * @return None
744 */
zhanghch058d1b46d2021-04-01 11:18:24 +0800745inline void
746 deleteAndCreateIPv6(const std::string& ifaceId, const std::string& id,
747 uint8_t prefixLength, const std::string& address,
748 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Johnathan Mantey01784822019-06-18 12:44:21 -0700749{
750 crow::connections::systemBus->async_method_call(
751 [asyncResp, ifaceId, address,
752 prefixLength](const boost::system::error_code ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700753 if (ec)
754 {
755 messages::internalError(asyncResp->res);
756 }
757 crow::connections::systemBus->async_method_call(
758 [asyncResp](const boost::system::error_code ec2) {
759 if (ec2)
Johnathan Mantey01784822019-06-18 12:44:21 -0700760 {
761 messages::internalError(asyncResp->res);
762 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700763 },
764 "xyz.openbmc_project.Network",
765 "/xyz/openbmc_project/network/" + ifaceId,
766 "xyz.openbmc_project.Network.IP.Create", "IP",
767 "xyz.openbmc_project.Network.IP.Protocol.IPv6", address,
768 prefixLength, "");
Johnathan Mantey01784822019-06-18 12:44:21 -0700769 },
770 "xyz.openbmc_project.Network",
771 +"/xyz/openbmc_project/network/" + ifaceId + "/ipv6/" + id,
772 "xyz.openbmc_project.Object.Delete", "Delete");
773}
774
775/**
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500776 * @brief Creates IPv6 with given data
777 *
778 * @param[in] ifaceId Id of interface whose IP should be added
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500779 * @param[in] prefixLength Prefix length that needs to be added
780 * @param[in] address IP address that needs to be added
781 * @param[io] asyncResp Response object that will be returned to client
782 *
783 * @return None
784 */
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500785inline void createIPv6(const std::string& ifaceId, uint8_t prefixLength,
786 const std::string& address,
zhanghch058d1b46d2021-04-01 11:18:24 +0800787 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500788{
789 auto createIpHandler = [asyncResp](const boost::system::error_code ec) {
790 if (ec)
791 {
792 messages::internalError(asyncResp->res);
793 }
794 };
795 // Passing null for gateway, as per redfish spec IPv6StaticAddresses object
Gunnar Mills4e0453b2020-07-08 14:00:30 -0500796 // does not have associated gateway property
Ravi Tejae48c0fc2019-04-16 08:37:20 -0500797 crow::connections::systemBus->async_method_call(
798 std::move(createIpHandler), "xyz.openbmc_project.Network",
799 "/xyz/openbmc_project/network/" + ifaceId,
800 "xyz.openbmc_project.Network.IP.Create", "IP",
801 "xyz.openbmc_project.Network.IP.Protocol.IPv6", address, prefixLength,
802 "");
803}
804
Ed Tanous4a0cb852018-10-15 07:55:04 -0700805/**
806 * Function that retrieves all properties for given Ethernet Interface
807 * Object
808 * from EntityManager Network Manager
809 * @param ethiface_id a eth interface id to query on DBus
810 * @param callback a function that shall be called to convert Dbus output
811 * into JSON
812 */
813template <typename CallbackFunc>
Ed Tanous81ce6092020-12-17 16:54:55 +0000814void getEthernetIfaceData(const std::string& ethifaceId,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500815 CallbackFunc&& callback)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700816{
817 crow::connections::systemBus->async_method_call(
Ed Tanousf94c4ec2022-01-06 12:44:41 -0800818 [ethifaceId{std::string{ethifaceId}},
819 callback{std::forward<CallbackFunc>(callback)}](
Ed Tanous81ce6092020-12-17 16:54:55 +0000820 const boost::system::error_code errorCode,
Ed Tanous02cad962022-06-30 16:50:15 -0700821 const dbus::utility::ManagedObjectType& resp) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700822 EthernetInterfaceData ethData{};
823 boost::container::flat_set<IPv4AddressData> ipv4Data;
824 boost::container::flat_set<IPv6AddressData> ipv6Data;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700825
Ed Tanous002d39b2022-05-31 08:59:27 -0700826 if (errorCode)
827 {
828 callback(false, ethData, ipv4Data, ipv6Data);
829 return;
830 }
831
832 bool found = extractEthernetInterfaceData(ethifaceId, resp, ethData);
833 if (!found)
834 {
835 callback(false, ethData, ipv4Data, ipv6Data);
836 return;
837 }
838
839 extractIPData(ethifaceId, resp, ipv4Data);
840 // Fix global GW
841 for (IPv4AddressData& ipv4 : ipv4Data)
842 {
843 if (((ipv4.linktype == LinkType::Global) &&
844 (ipv4.gateway == "0.0.0.0")) ||
845 (ipv4.origin == "DHCP") || (ipv4.origin == "Static"))
Ed Tanous4a0cb852018-10-15 07:55:04 -0700846 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700847 ipv4.gateway = ethData.defaultGateway;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700848 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700849 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700850
Ed Tanous002d39b2022-05-31 08:59:27 -0700851 extractIPV6Data(ethifaceId, resp, ipv6Data);
852 // Finally make a callback with useful data
853 callback(true, ethData, ipv4Data, ipv6Data);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700854 },
855 "xyz.openbmc_project.Network", "/xyz/openbmc_project/network",
856 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
Ed Tanous271584a2019-07-09 16:24:22 -0700857}
Ed Tanous4a0cb852018-10-15 07:55:04 -0700858
859/**
860 * Function that retrieves all Ethernet Interfaces available through Network
861 * Manager
862 * @param callback a function that shall be called to convert Dbus output
863 * into JSON.
864 */
865template <typename CallbackFunc>
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500866void getEthernetIfaceList(CallbackFunc&& callback)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700867{
868 crow::connections::systemBus->async_method_call(
Ed Tanousf94c4ec2022-01-06 12:44:41 -0800869 [callback{std::forward<CallbackFunc>(callback)}](
Ed Tanous81ce6092020-12-17 16:54:55 +0000870 const boost::system::error_code errorCode,
Ed Tanous711ac7a2021-12-20 09:34:41 -0800871 dbus::utility::ManagedObjectType& resp) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700872 // Callback requires vector<string> to retrieve all available
873 // ethernet interfaces
874 boost::container::flat_set<std::string> ifaceList;
875 ifaceList.reserve(resp.size());
876 if (errorCode)
877 {
878 callback(false, ifaceList);
879 return;
880 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700881
Ed Tanous002d39b2022-05-31 08:59:27 -0700882 // Iterate over all retrieved ObjectPaths.
883 for (const auto& objpath : resp)
884 {
885 // And all interfaces available for certain ObjectPath.
886 for (const auto& interface : objpath.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700887 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700888 // If interface is
889 // xyz.openbmc_project.Network.EthernetInterface, this is
890 // what we're looking for.
891 if (interface.first ==
892 "xyz.openbmc_project.Network.EthernetInterface")
Ed Tanous4a0cb852018-10-15 07:55:04 -0700893 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700894 std::string ifaceId = objpath.first.filename();
895 if (ifaceId.empty())
Ed Tanous1abe55e2018-09-05 08:30:59 -0700896 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700897 continue;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700898 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700899 // and put it into output vector.
900 ifaceList.emplace(ifaceId);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700901 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700902 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700903 }
904 // Finally make a callback with useful data
905 callback(true, ifaceList);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700906 },
907 "xyz.openbmc_project.Network", "/xyz/openbmc_project/network",
908 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
Ed Tanous271584a2019-07-09 16:24:22 -0700909}
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +0100910
Ed Tanous4f48d5f2021-06-21 08:27:45 -0700911inline void
912 handleHostnamePatch(const std::string& hostname,
913 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700914{
Ed Tanousbf648f72021-06-03 15:00:14 -0700915 // SHOULD handle host names of up to 255 characters(RFC 1123)
916 if (hostname.length() > 255)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700917 {
Ed Tanousbf648f72021-06-03 15:00:14 -0700918 messages::propertyValueFormatError(asyncResp->res, hostname,
919 "HostName");
920 return;
921 }
922 crow::connections::systemBus->async_method_call(
923 [asyncResp](const boost::system::error_code ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700924 if (ec)
925 {
926 messages::internalError(asyncResp->res);
927 }
Ed Tanousbf648f72021-06-03 15:00:14 -0700928 },
929 "xyz.openbmc_project.Network", "/xyz/openbmc_project/network/config",
930 "org.freedesktop.DBus.Properties", "Set",
931 "xyz.openbmc_project.Network.SystemConfiguration", "HostName",
Ed Tanous168e20c2021-12-13 14:39:53 -0800932 dbus::utility::DbusVariantType(hostname));
Ed Tanousbf648f72021-06-03 15:00:14 -0700933}
934
Ed Tanous4f48d5f2021-06-21 08:27:45 -0700935inline void
Tejas Patil35fb5312021-09-20 15:35:20 +0530936 handleMTUSizePatch(const std::string& ifaceId, const size_t mtuSize,
937 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
938{
939 sdbusplus::message::object_path objPath =
940 "/xyz/openbmc_project/network/" + ifaceId;
941 crow::connections::systemBus->async_method_call(
942 [asyncResp](const boost::system::error_code ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700943 if (ec)
944 {
945 messages::internalError(asyncResp->res);
946 }
Tejas Patil35fb5312021-09-20 15:35:20 +0530947 },
948 "xyz.openbmc_project.Network", objPath,
949 "org.freedesktop.DBus.Properties", "Set",
950 "xyz.openbmc_project.Network.EthernetInterface", "MTU",
951 std::variant<size_t>(mtuSize));
952}
953
954inline void
Ed Tanous4f48d5f2021-06-21 08:27:45 -0700955 handleDomainnamePatch(const std::string& ifaceId,
956 const std::string& domainname,
957 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanousbf648f72021-06-03 15:00:14 -0700958{
959 std::vector<std::string> vectorDomainname = {domainname};
960 crow::connections::systemBus->async_method_call(
961 [asyncResp](const boost::system::error_code ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700962 if (ec)
963 {
964 messages::internalError(asyncResp->res);
965 }
Ed Tanousbf648f72021-06-03 15:00:14 -0700966 },
967 "xyz.openbmc_project.Network",
968 "/xyz/openbmc_project/network/" + ifaceId,
969 "org.freedesktop.DBus.Properties", "Set",
970 "xyz.openbmc_project.Network.EthernetInterface", "DomainName",
Ed Tanous168e20c2021-12-13 14:39:53 -0800971 dbus::utility::DbusVariantType(vectorDomainname));
Ed Tanousbf648f72021-06-03 15:00:14 -0700972}
973
Ed Tanous4f48d5f2021-06-21 08:27:45 -0700974inline bool isHostnameValid(const std::string& hostname)
Ed Tanousbf648f72021-06-03 15:00:14 -0700975{
976 // A valid host name can never have the dotted-decimal form (RFC 1123)
977 if (std::all_of(hostname.begin(), hostname.end(), ::isdigit))
978 {
979 return false;
980 }
981 // Each label(hostname/subdomains) within a valid FQDN
982 // MUST handle host names of up to 63 characters (RFC 1123)
983 // labels cannot start or end with hyphens (RFC 952)
984 // labels can start with numbers (RFC 1123)
985 const std::regex pattern(
986 "^[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]{0,61}[a-zA-Z0-9]$");
987
988 return std::regex_match(hostname, pattern);
989}
990
Ed Tanous4f48d5f2021-06-21 08:27:45 -0700991inline bool isDomainnameValid(const std::string& domainname)
Ed Tanousbf648f72021-06-03 15:00:14 -0700992{
993 // Can have multiple subdomains
994 // Top Level Domain's min length is 2 character
George Liu0fda0f12021-11-16 10:06:17 +0800995 const std::regex pattern(
996 "^([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 -0700997
998 return std::regex_match(domainname, pattern);
999}
1000
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001001inline void handleFqdnPatch(const std::string& ifaceId, const std::string& fqdn,
1002 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanousbf648f72021-06-03 15:00:14 -07001003{
1004 // Total length of FQDN must not exceed 255 characters(RFC 1035)
1005 if (fqdn.length() > 255)
1006 {
1007 messages::propertyValueFormatError(asyncResp->res, fqdn, "FQDN");
1008 return;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001009 }
1010
Ed Tanousbf648f72021-06-03 15:00:14 -07001011 size_t pos = fqdn.find('.');
1012 if (pos == std::string::npos)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001013 {
Ed Tanousbf648f72021-06-03 15:00:14 -07001014 messages::propertyValueFormatError(asyncResp->res, fqdn, "FQDN");
1015 return;
1016 }
zhanghch058d1b46d2021-04-01 11:18:24 +08001017
Ed Tanousbf648f72021-06-03 15:00:14 -07001018 std::string hostname;
1019 std::string domainname;
1020 domainname = (fqdn).substr(pos + 1);
1021 hostname = (fqdn).substr(0, pos);
1022
1023 if (!isHostnameValid(hostname) || !isDomainnameValid(domainname))
1024 {
1025 messages::propertyValueFormatError(asyncResp->res, fqdn, "FQDN");
1026 return;
1027 }
1028
1029 handleHostnamePatch(hostname, asyncResp);
1030 handleDomainnamePatch(ifaceId, domainname, asyncResp);
1031}
1032
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001033inline void
1034 handleMACAddressPatch(const std::string& ifaceId,
1035 const std::string& macAddress,
1036 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanousbf648f72021-06-03 15:00:14 -07001037{
Johnathan Mantey58283f42022-08-15 14:38:36 -07001038 static constexpr std::string_view dbusNotAllowedError =
1039 "xyz.openbmc_project.Common.Error.NotAllowed";
1040
Ed Tanousbf648f72021-06-03 15:00:14 -07001041 crow::connections::systemBus->async_method_call(
Johnathan Mantey58283f42022-08-15 14:38:36 -07001042 [asyncResp, macAddress](const boost::system::error_code ec,
Patrick Williams5b378542022-11-26 09:41:59 -06001043 const sdbusplus::message_t& msg) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001044 if (ec)
1045 {
Johnathan Mantey58283f42022-08-15 14:38:36 -07001046 const sd_bus_error* err = msg.get_error();
1047 if (err == nullptr)
1048 {
1049 messages::internalError(asyncResp->res);
1050 return;
1051 }
1052 if (err->name == dbusNotAllowedError)
1053 {
1054 messages::propertyNotWritable(asyncResp->res, "MACAddress");
1055 return;
1056 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001057 messages::internalError(asyncResp->res);
1058 return;
1059 }
Ed Tanousbf648f72021-06-03 15:00:14 -07001060 },
1061 "xyz.openbmc_project.Network",
1062 "/xyz/openbmc_project/network/" + ifaceId,
1063 "org.freedesktop.DBus.Properties", "Set",
1064 "xyz.openbmc_project.Network.MACAddress", "MACAddress",
Ed Tanous168e20c2021-12-13 14:39:53 -08001065 dbus::utility::DbusVariantType(macAddress));
Ed Tanousbf648f72021-06-03 15:00:14 -07001066}
1067
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001068inline void setDHCPEnabled(const std::string& ifaceId,
1069 const std::string& propertyName, const bool v4Value,
1070 const bool v6Value,
1071 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanousbf648f72021-06-03 15:00:14 -07001072{
1073 const std::string dhcp = getDhcpEnabledEnumeration(v4Value, v6Value);
1074 crow::connections::systemBus->async_method_call(
1075 [asyncResp](const boost::system::error_code ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001076 if (ec)
1077 {
1078 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec;
1079 messages::internalError(asyncResp->res);
1080 return;
1081 }
1082 messages::success(asyncResp->res);
Ed Tanousbf648f72021-06-03 15:00:14 -07001083 },
1084 "xyz.openbmc_project.Network",
1085 "/xyz/openbmc_project/network/" + ifaceId,
1086 "org.freedesktop.DBus.Properties", "Set",
1087 "xyz.openbmc_project.Network.EthernetInterface", propertyName,
Ed Tanous168e20c2021-12-13 14:39:53 -08001088 dbus::utility::DbusVariantType{dhcp});
Ed Tanousbf648f72021-06-03 15:00:14 -07001089}
1090
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001091inline void setEthernetInterfaceBoolProperty(
Ed Tanousbf648f72021-06-03 15:00:14 -07001092 const std::string& ifaceId, const std::string& propertyName,
1093 const bool& value, const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1094{
1095 crow::connections::systemBus->async_method_call(
1096 [asyncResp](const boost::system::error_code ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001097 if (ec)
1098 {
1099 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec;
1100 messages::internalError(asyncResp->res);
1101 return;
1102 }
Ed Tanousbf648f72021-06-03 15:00:14 -07001103 },
1104 "xyz.openbmc_project.Network",
1105 "/xyz/openbmc_project/network/" + ifaceId,
1106 "org.freedesktop.DBus.Properties", "Set",
1107 "xyz.openbmc_project.Network.EthernetInterface", propertyName,
Ed Tanous168e20c2021-12-13 14:39:53 -08001108 dbus::utility::DbusVariantType{value});
Ed Tanousbf648f72021-06-03 15:00:14 -07001109}
1110
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001111inline void setDHCPv4Config(const std::string& propertyName, const bool& value,
1112 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanousbf648f72021-06-03 15:00:14 -07001113{
1114 BMCWEB_LOG_DEBUG << propertyName << " = " << value;
1115 crow::connections::systemBus->async_method_call(
1116 [asyncResp](const boost::system::error_code ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001117 if (ec)
1118 {
1119 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec;
1120 messages::internalError(asyncResp->res);
1121 return;
1122 }
Ed Tanousbf648f72021-06-03 15:00:14 -07001123 },
1124 "xyz.openbmc_project.Network",
1125 "/xyz/openbmc_project/network/config/dhcp",
1126 "org.freedesktop.DBus.Properties", "Set",
1127 "xyz.openbmc_project.Network.DHCPConfiguration", propertyName,
Ed Tanous168e20c2021-12-13 14:39:53 -08001128 dbus::utility::DbusVariantType{value});
Ed Tanousbf648f72021-06-03 15:00:14 -07001129}
1130
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001131inline void handleDHCPPatch(const std::string& ifaceId,
1132 const EthernetInterfaceData& ethData,
1133 const DHCPParameters& v4dhcpParms,
1134 const DHCPParameters& v6dhcpParms,
1135 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanousbf648f72021-06-03 15:00:14 -07001136{
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001137 bool ipv4Active = translateDhcpEnabledToBool(ethData.dhcpEnabled, true);
1138 bool ipv6Active = translateDhcpEnabledToBool(ethData.dhcpEnabled, false);
Ed Tanousbf648f72021-06-03 15:00:14 -07001139
1140 bool nextv4DHCPState =
1141 v4dhcpParms.dhcpv4Enabled ? *v4dhcpParms.dhcpv4Enabled : ipv4Active;
1142
1143 bool nextv6DHCPState{};
1144 if (v6dhcpParms.dhcpv6OperatingMode)
1145 {
1146 if ((*v6dhcpParms.dhcpv6OperatingMode != "Stateful") &&
1147 (*v6dhcpParms.dhcpv6OperatingMode != "Stateless") &&
1148 (*v6dhcpParms.dhcpv6OperatingMode != "Disabled"))
1149 {
1150 messages::propertyValueFormatError(asyncResp->res,
1151 *v6dhcpParms.dhcpv6OperatingMode,
1152 "OperatingMode");
1153 return;
1154 }
1155 nextv6DHCPState = (*v6dhcpParms.dhcpv6OperatingMode == "Stateful");
1156 }
1157 else
1158 {
1159 nextv6DHCPState = ipv6Active;
1160 }
1161
1162 bool nextDNS{};
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001163 if (v4dhcpParms.useDnsServers && v6dhcpParms.useDnsServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001164 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001165 if (*v4dhcpParms.useDnsServers != *v6dhcpParms.useDnsServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001166 {
1167 messages::generalError(asyncResp->res);
1168 return;
1169 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001170 nextDNS = *v4dhcpParms.useDnsServers;
Ed Tanousbf648f72021-06-03 15:00:14 -07001171 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001172 else if (v4dhcpParms.useDnsServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001173 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001174 nextDNS = *v4dhcpParms.useDnsServers;
Ed Tanousbf648f72021-06-03 15:00:14 -07001175 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001176 else if (v6dhcpParms.useDnsServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001177 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001178 nextDNS = *v6dhcpParms.useDnsServers;
Ed Tanousbf648f72021-06-03 15:00:14 -07001179 }
1180 else
1181 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001182 nextDNS = ethData.dnsEnabled;
Ed Tanousbf648f72021-06-03 15:00:14 -07001183 }
1184
1185 bool nextNTP{};
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001186 if (v4dhcpParms.useNtpServers && v6dhcpParms.useNtpServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001187 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001188 if (*v4dhcpParms.useNtpServers != *v6dhcpParms.useNtpServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001189 {
1190 messages::generalError(asyncResp->res);
1191 return;
1192 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001193 nextNTP = *v4dhcpParms.useNtpServers;
Ed Tanousbf648f72021-06-03 15:00:14 -07001194 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001195 else if (v4dhcpParms.useNtpServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001196 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001197 nextNTP = *v4dhcpParms.useNtpServers;
Ed Tanousbf648f72021-06-03 15:00:14 -07001198 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001199 else if (v6dhcpParms.useNtpServers)
Ed Tanousbf648f72021-06-03 15:00:14 -07001200 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001201 nextNTP = *v6dhcpParms.useNtpServers;
Ed Tanousbf648f72021-06-03 15:00:14 -07001202 }
1203 else
1204 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001205 nextNTP = ethData.ntpEnabled;
Ed Tanousbf648f72021-06-03 15:00:14 -07001206 }
1207
1208 bool nextUseDomain{};
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001209 if (v4dhcpParms.useDomainName && v6dhcpParms.useDomainName)
Ed Tanousbf648f72021-06-03 15:00:14 -07001210 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001211 if (*v4dhcpParms.useDomainName != *v6dhcpParms.useDomainName)
Ed Tanousbf648f72021-06-03 15:00:14 -07001212 {
1213 messages::generalError(asyncResp->res);
1214 return;
1215 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001216 nextUseDomain = *v4dhcpParms.useDomainName;
Ed Tanousbf648f72021-06-03 15:00:14 -07001217 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001218 else if (v4dhcpParms.useDomainName)
Ed Tanousbf648f72021-06-03 15:00:14 -07001219 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001220 nextUseDomain = *v4dhcpParms.useDomainName;
Ed Tanousbf648f72021-06-03 15:00:14 -07001221 }
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001222 else if (v6dhcpParms.useDomainName)
Ed Tanousbf648f72021-06-03 15:00:14 -07001223 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001224 nextUseDomain = *v6dhcpParms.useDomainName;
Ed Tanousbf648f72021-06-03 15:00:14 -07001225 }
1226 else
1227 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001228 nextUseDomain = ethData.hostNameEnabled;
Ed Tanousbf648f72021-06-03 15:00:14 -07001229 }
1230
1231 BMCWEB_LOG_DEBUG << "set DHCPEnabled...";
1232 setDHCPEnabled(ifaceId, "DHCPEnabled", nextv4DHCPState, nextv6DHCPState,
1233 asyncResp);
1234 BMCWEB_LOG_DEBUG << "set DNSEnabled...";
1235 setDHCPv4Config("DNSEnabled", nextDNS, asyncResp);
1236 BMCWEB_LOG_DEBUG << "set NTPEnabled...";
1237 setDHCPv4Config("NTPEnabled", nextNTP, asyncResp);
1238 BMCWEB_LOG_DEBUG << "set HostNameEnabled...";
1239 setDHCPv4Config("HostNameEnabled", nextUseDomain, asyncResp);
1240}
1241
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001242inline boost::container::flat_set<IPv4AddressData>::const_iterator
Ed Tanousbf648f72021-06-03 15:00:14 -07001243 getNextStaticIpEntry(
1244 const boost::container::flat_set<IPv4AddressData>::const_iterator& head,
1245 const boost::container::flat_set<IPv4AddressData>::const_iterator& end)
1246{
1247 return std::find_if(head, end, [](const IPv4AddressData& value) {
1248 return value.origin == "Static";
1249 });
1250}
1251
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001252inline boost::container::flat_set<IPv6AddressData>::const_iterator
Ed Tanousbf648f72021-06-03 15:00:14 -07001253 getNextStaticIpEntry(
1254 const boost::container::flat_set<IPv6AddressData>::const_iterator& head,
1255 const boost::container::flat_set<IPv6AddressData>::const_iterator& end)
1256{
1257 return std::find_if(head, end, [](const IPv6AddressData& value) {
1258 return value.origin == "Static";
1259 });
1260}
1261
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001262inline void handleIPv4StaticPatch(
Ed Tanousbf648f72021-06-03 15:00:14 -07001263 const std::string& ifaceId, nlohmann::json& input,
1264 const boost::container::flat_set<IPv4AddressData>& ipv4Data,
1265 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1266{
1267 if ((!input.is_array()) || input.empty())
1268 {
1269 messages::propertyValueTypeError(
1270 asyncResp->res,
1271 input.dump(2, ' ', true, nlohmann::json::error_handler_t::replace),
1272 "IPv4StaticAddresses");
1273 return;
1274 }
1275
1276 unsigned entryIdx = 1;
1277 // Find the first static IP address currently active on the NIC and
1278 // match it to the first JSON element in the IPv4StaticAddresses array.
1279 // Match each subsequent JSON element to the next static IP programmed
1280 // into the NIC.
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001281 boost::container::flat_set<IPv4AddressData>::const_iterator nicIpEntry =
Ed Tanousbf648f72021-06-03 15:00:14 -07001282 getNextStaticIpEntry(ipv4Data.cbegin(), ipv4Data.cend());
1283
1284 for (nlohmann::json& thisJson : input)
1285 {
1286 std::string pathString =
1287 "IPv4StaticAddresses/" + std::to_string(entryIdx);
1288
1289 if (!thisJson.is_null() && !thisJson.empty())
1290 {
1291 std::optional<std::string> address;
1292 std::optional<std::string> subnetMask;
1293 std::optional<std::string> gateway;
1294
1295 if (!json_util::readJson(thisJson, asyncResp->res, "Address",
1296 address, "SubnetMask", subnetMask,
1297 "Gateway", gateway))
1298 {
1299 messages::propertyValueFormatError(
1300 asyncResp->res,
1301 thisJson.dump(2, ' ', true,
1302 nlohmann::json::error_handler_t::replace),
1303 pathString);
1304 return;
1305 }
1306
1307 // Find the address/subnet/gateway values. Any values that are
1308 // not explicitly provided are assumed to be unmodified from the
1309 // current state of the interface. Merge existing state into the
1310 // current request.
1311 const std::string* addr = nullptr;
1312 const std::string* gw = nullptr;
1313 uint8_t prefixLength = 0;
1314 bool errorInEntry = false;
1315 if (address)
1316 {
Ed Tanous033f1e42022-08-15 09:47:37 -07001317 if (ip_util::ipv4VerifyIpAndGetBitcount(*address))
Ed Tanousbf648f72021-06-03 15:00:14 -07001318 {
1319 addr = &(*address);
1320 }
1321 else
1322 {
1323 messages::propertyValueFormatError(asyncResp->res, *address,
1324 pathString + "/Address");
1325 errorInEntry = true;
1326 }
1327 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001328 else if (nicIpEntry != ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001329 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001330 addr = &(nicIpEntry->address);
Ed Tanousbf648f72021-06-03 15:00:14 -07001331 }
1332 else
1333 {
1334 messages::propertyMissing(asyncResp->res,
1335 pathString + "/Address");
1336 errorInEntry = true;
1337 }
1338
1339 if (subnetMask)
1340 {
Ed Tanous033f1e42022-08-15 09:47:37 -07001341 if (!ip_util::ipv4VerifyIpAndGetBitcount(*subnetMask,
1342 &prefixLength))
Ed Tanousbf648f72021-06-03 15:00:14 -07001343 {
1344 messages::propertyValueFormatError(
1345 asyncResp->res, *subnetMask,
1346 pathString + "/SubnetMask");
1347 errorInEntry = true;
1348 }
1349 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001350 else if (nicIpEntry != ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001351 {
Ed Tanous033f1e42022-08-15 09:47:37 -07001352 if (!ip_util::ipv4VerifyIpAndGetBitcount(nicIpEntry->netmask,
1353 &prefixLength))
Ed Tanousbf648f72021-06-03 15:00:14 -07001354 {
1355 messages::propertyValueFormatError(
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001356 asyncResp->res, nicIpEntry->netmask,
Ed Tanousbf648f72021-06-03 15:00:14 -07001357 pathString + "/SubnetMask");
1358 errorInEntry = true;
1359 }
1360 }
1361 else
1362 {
1363 messages::propertyMissing(asyncResp->res,
1364 pathString + "/SubnetMask");
1365 errorInEntry = true;
1366 }
1367
1368 if (gateway)
1369 {
Ed Tanous033f1e42022-08-15 09:47:37 -07001370 if (ip_util::ipv4VerifyIpAndGetBitcount(*gateway))
Ed Tanousbf648f72021-06-03 15:00:14 -07001371 {
1372 gw = &(*gateway);
1373 }
1374 else
1375 {
1376 messages::propertyValueFormatError(asyncResp->res, *gateway,
1377 pathString + "/Gateway");
1378 errorInEntry = true;
1379 }
1380 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001381 else if (nicIpEntry != ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001382 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001383 gw = &nicIpEntry->gateway;
Ed Tanousbf648f72021-06-03 15:00:14 -07001384 }
1385 else
1386 {
1387 messages::propertyMissing(asyncResp->res,
1388 pathString + "/Gateway");
1389 errorInEntry = true;
1390 }
1391
1392 if (errorInEntry)
1393 {
1394 return;
1395 }
1396
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001397 if (nicIpEntry != ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001398 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001399 deleteAndCreateIPv4(ifaceId, nicIpEntry->id, prefixLength, *gw,
Ed Tanousbf648f72021-06-03 15:00:14 -07001400 *addr, asyncResp);
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001401 nicIpEntry =
1402 getNextStaticIpEntry(++nicIpEntry, ipv4Data.cend());
Ed Tanousbf648f72021-06-03 15:00:14 -07001403 }
1404 else
1405 {
1406 createIPv4(ifaceId, prefixLength, *gateway, *address,
1407 asyncResp);
1408 }
1409 entryIdx++;
1410 }
1411 else
1412 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001413 if (nicIpEntry == ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001414 {
1415 // Requesting a DELETE/DO NOT MODIFY action for an item
1416 // that isn't present on the eth(n) interface. Input JSON is
1417 // in error, so bail out.
1418 if (thisJson.is_null())
1419 {
1420 messages::resourceCannotBeDeleted(asyncResp->res);
1421 return;
1422 }
1423 messages::propertyValueFormatError(
1424 asyncResp->res,
1425 thisJson.dump(2, ' ', true,
1426 nlohmann::json::error_handler_t::replace),
1427 pathString);
1428 return;
1429 }
1430
1431 if (thisJson.is_null())
1432 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001433 deleteIPv4(ifaceId, nicIpEntry->id, asyncResp);
Ed Tanousbf648f72021-06-03 15:00:14 -07001434 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001435 if (nicIpEntry != ipv4Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001436 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001437 nicIpEntry =
1438 getNextStaticIpEntry(++nicIpEntry, ipv4Data.cend());
Ed Tanousbf648f72021-06-03 15:00:14 -07001439 }
1440 entryIdx++;
1441 }
1442 }
1443}
1444
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001445inline void handleStaticNameServersPatch(
Ed Tanousbf648f72021-06-03 15:00:14 -07001446 const std::string& ifaceId,
1447 const std::vector<std::string>& updatedStaticNameServers,
1448 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1449{
1450 crow::connections::systemBus->async_method_call(
1451 [asyncResp](const boost::system::error_code ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001452 if (ec)
1453 {
1454 messages::internalError(asyncResp->res);
1455 return;
1456 }
Ed Tanousbf648f72021-06-03 15:00:14 -07001457 },
1458 "xyz.openbmc_project.Network",
1459 "/xyz/openbmc_project/network/" + ifaceId,
1460 "org.freedesktop.DBus.Properties", "Set",
1461 "xyz.openbmc_project.Network.EthernetInterface", "StaticNameServers",
Ed Tanous168e20c2021-12-13 14:39:53 -08001462 dbus::utility::DbusVariantType{updatedStaticNameServers});
Ed Tanousbf648f72021-06-03 15:00:14 -07001463}
1464
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001465inline void handleIPv6StaticAddressesPatch(
Ed Tanousbf648f72021-06-03 15:00:14 -07001466 const std::string& ifaceId, const nlohmann::json& input,
1467 const boost::container::flat_set<IPv6AddressData>& ipv6Data,
1468 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1469{
1470 if (!input.is_array() || input.empty())
1471 {
1472 messages::propertyValueTypeError(
1473 asyncResp->res,
1474 input.dump(2, ' ', true, nlohmann::json::error_handler_t::replace),
1475 "IPv6StaticAddresses");
1476 return;
1477 }
1478 size_t entryIdx = 1;
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001479 boost::container::flat_set<IPv6AddressData>::const_iterator nicIpEntry =
Ed Tanousbf648f72021-06-03 15:00:14 -07001480 getNextStaticIpEntry(ipv6Data.cbegin(), ipv6Data.cend());
1481 for (const nlohmann::json& thisJson : input)
1482 {
1483 std::string pathString =
1484 "IPv6StaticAddresses/" + std::to_string(entryIdx);
1485
1486 if (!thisJson.is_null() && !thisJson.empty())
1487 {
1488 std::optional<std::string> address;
1489 std::optional<uint8_t> prefixLength;
1490 nlohmann::json thisJsonCopy = thisJson;
1491 if (!json_util::readJson(thisJsonCopy, asyncResp->res, "Address",
1492 address, "PrefixLength", prefixLength))
1493 {
1494 messages::propertyValueFormatError(
1495 asyncResp->res,
1496 thisJson.dump(2, ' ', true,
1497 nlohmann::json::error_handler_t::replace),
1498 pathString);
1499 return;
1500 }
1501
Ed Tanous543f4402022-01-06 13:12:53 -08001502 const std::string* addr = nullptr;
1503 uint8_t prefix = 0;
Ed Tanousbf648f72021-06-03 15:00:14 -07001504
1505 // Find the address and prefixLength values. Any values that are
1506 // not explicitly provided are assumed to be unmodified from the
1507 // current state of the interface. Merge existing state into the
1508 // current request.
1509 if (address)
1510 {
1511 addr = &(*address);
1512 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001513 else if (nicIpEntry != ipv6Data.end())
Ed Tanousbf648f72021-06-03 15:00:14 -07001514 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001515 addr = &(nicIpEntry->address);
Ed Tanousbf648f72021-06-03 15:00:14 -07001516 }
1517 else
1518 {
1519 messages::propertyMissing(asyncResp->res,
1520 pathString + "/Address");
1521 return;
1522 }
1523
1524 if (prefixLength)
1525 {
1526 prefix = *prefixLength;
1527 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001528 else if (nicIpEntry != ipv6Data.end())
Ed Tanousbf648f72021-06-03 15:00:14 -07001529 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001530 prefix = nicIpEntry->prefixLength;
Ed Tanousbf648f72021-06-03 15:00:14 -07001531 }
1532 else
1533 {
1534 messages::propertyMissing(asyncResp->res,
1535 pathString + "/PrefixLength");
1536 return;
1537 }
1538
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001539 if (nicIpEntry != ipv6Data.end())
Ed Tanousbf648f72021-06-03 15:00:14 -07001540 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001541 deleteAndCreateIPv6(ifaceId, nicIpEntry->id, prefix, *addr,
Ed Tanousbf648f72021-06-03 15:00:14 -07001542 asyncResp);
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001543 nicIpEntry =
1544 getNextStaticIpEntry(++nicIpEntry, ipv6Data.cend());
Ed Tanousbf648f72021-06-03 15:00:14 -07001545 }
1546 else
1547 {
1548 createIPv6(ifaceId, *prefixLength, *addr, asyncResp);
1549 }
1550 entryIdx++;
1551 }
1552 else
1553 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001554 if (nicIpEntry == ipv6Data.end())
Ed Tanousbf648f72021-06-03 15:00:14 -07001555 {
1556 // Requesting a DELETE/DO NOT MODIFY action for an item
1557 // that isn't present on the eth(n) interface. Input JSON is
1558 // in error, so bail out.
1559 if (thisJson.is_null())
1560 {
1561 messages::resourceCannotBeDeleted(asyncResp->res);
1562 return;
1563 }
1564 messages::propertyValueFormatError(
1565 asyncResp->res,
1566 thisJson.dump(2, ' ', true,
1567 nlohmann::json::error_handler_t::replace),
1568 pathString);
1569 return;
1570 }
1571
1572 if (thisJson.is_null())
1573 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001574 deleteIPv6(ifaceId, nicIpEntry->id, asyncResp);
Ed Tanousbf648f72021-06-03 15:00:14 -07001575 }
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001576 if (nicIpEntry != ipv6Data.cend())
Ed Tanousbf648f72021-06-03 15:00:14 -07001577 {
Jiaqing Zhao85ffe862021-12-31 15:41:59 +08001578 nicIpEntry =
1579 getNextStaticIpEntry(++nicIpEntry, ipv6Data.cend());
Ed Tanousbf648f72021-06-03 15:00:14 -07001580 }
1581 entryIdx++;
1582 }
1583 }
1584}
1585
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001586inline void parseInterfaceData(
Ed Tanousbf648f72021-06-03 15:00:14 -07001587 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1588 const std::string& ifaceId, const EthernetInterfaceData& ethData,
1589 const boost::container::flat_set<IPv4AddressData>& ipv4Data,
1590 const boost::container::flat_set<IPv6AddressData>& ipv6Data)
1591{
1592 constexpr const std::array<const char*, 1> inventoryForEthernet = {
1593 "xyz.openbmc_project.Inventory.Item.Ethernet"};
1594
1595 nlohmann::json& jsonResponse = asyncResp->res.jsonValue;
1596 jsonResponse["Id"] = ifaceId;
1597 jsonResponse["@odata.id"] =
1598 "/redfish/v1/Managers/bmc/EthernetInterfaces/" + ifaceId;
1599 jsonResponse["InterfaceEnabled"] = ethData.nicEnabled;
1600
1601 auto health = std::make_shared<HealthPopulate>(asyncResp);
1602
1603 crow::connections::systemBus->async_method_call(
1604 [health](const boost::system::error_code ec,
Ed Tanousb9d36b42022-02-26 21:42:46 -08001605 const dbus::utility::MapperGetSubTreePathsResponse& resp) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001606 if (ec)
1607 {
1608 return;
1609 }
Ed Tanousbf648f72021-06-03 15:00:14 -07001610
Ed Tanous002d39b2022-05-31 08:59:27 -07001611 health->inventory = resp;
Ed Tanousbf648f72021-06-03 15:00:14 -07001612 },
1613 "xyz.openbmc_project.ObjectMapper",
1614 "/xyz/openbmc_project/object_mapper",
1615 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths", "/", int32_t(0),
1616 inventoryForEthernet);
1617
1618 health->populate();
1619
1620 if (ethData.nicEnabled)
1621 {
Johnathan Mantey0ef0e282022-11-15 12:15:02 -08001622 jsonResponse["LinkStatus"] = ethData.linkUp ? "LinkUp" : "LinkDown";
Ed Tanousbf648f72021-06-03 15:00:14 -07001623 jsonResponse["Status"]["State"] = "Enabled";
1624 }
1625 else
1626 {
1627 jsonResponse["LinkStatus"] = "NoLink";
1628 jsonResponse["Status"]["State"] = "Disabled";
1629 }
1630
Ed Tanousbf648f72021-06-03 15:00:14 -07001631 jsonResponse["SpeedMbps"] = ethData.speed;
Tejas Patil35fb5312021-09-20 15:35:20 +05301632 jsonResponse["MTUSize"] = ethData.mtuSize;
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001633 jsonResponse["MACAddress"] = ethData.macAddress;
Ed Tanousbf648f72021-06-03 15:00:14 -07001634 jsonResponse["DHCPv4"]["DHCPEnabled"] =
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001635 translateDhcpEnabledToBool(ethData.dhcpEnabled, true);
1636 jsonResponse["DHCPv4"]["UseNTPServers"] = ethData.ntpEnabled;
1637 jsonResponse["DHCPv4"]["UseDNSServers"] = ethData.dnsEnabled;
1638 jsonResponse["DHCPv4"]["UseDomainName"] = ethData.hostNameEnabled;
Ed Tanousbf648f72021-06-03 15:00:14 -07001639
1640 jsonResponse["DHCPv6"]["OperatingMode"] =
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001641 translateDhcpEnabledToBool(ethData.dhcpEnabled, false) ? "Stateful"
Ed Tanousbf648f72021-06-03 15:00:14 -07001642 : "Disabled";
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001643 jsonResponse["DHCPv6"]["UseNTPServers"] = ethData.ntpEnabled;
1644 jsonResponse["DHCPv6"]["UseDNSServers"] = ethData.dnsEnabled;
1645 jsonResponse["DHCPv6"]["UseDomainName"] = ethData.hostNameEnabled;
Ed Tanousbf648f72021-06-03 15:00:14 -07001646
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001647 if (!ethData.hostName.empty())
Ed Tanousbf648f72021-06-03 15:00:14 -07001648 {
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001649 jsonResponse["HostName"] = ethData.hostName;
Ed Tanousbf648f72021-06-03 15:00:14 -07001650
1651 // When domain name is empty then it means, that it is a network
1652 // without domain names, and the host name itself must be treated as
1653 // FQDN
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001654 std::string fqdn = ethData.hostName;
Ed Tanousbf648f72021-06-03 15:00:14 -07001655 if (!ethData.domainnames.empty())
1656 {
1657 fqdn += "." + ethData.domainnames[0];
1658 }
1659 jsonResponse["FQDN"] = fqdn;
1660 }
1661
Ed Tanous613dabe2022-07-09 11:17:36 -07001662 jsonResponse["VLANs"]["@odata.id"] =
1663 crow::utility::urlFromPieces("redfish", "v1", "Managers", "bmc",
1664 "EthernetInterfaces", ifaceId, "VLANs");
Ed Tanousbf648f72021-06-03 15:00:14 -07001665
1666 jsonResponse["NameServers"] = ethData.nameServers;
1667 jsonResponse["StaticNameServers"] = ethData.staticNameServers;
1668
1669 nlohmann::json& ipv4Array = jsonResponse["IPv4Addresses"];
1670 nlohmann::json& ipv4StaticArray = jsonResponse["IPv4StaticAddresses"];
1671 ipv4Array = nlohmann::json::array();
1672 ipv4StaticArray = nlohmann::json::array();
Ed Tanous9eb808c2022-01-25 10:19:23 -08001673 for (const auto& ipv4Config : ipv4Data)
Ed Tanousbf648f72021-06-03 15:00:14 -07001674 {
Ed Tanousbf648f72021-06-03 15:00:14 -07001675 std::string gatewayStr = ipv4Config.gateway;
1676 if (gatewayStr.empty())
1677 {
1678 gatewayStr = "0.0.0.0";
1679 }
Ed Tanous14766872022-03-15 10:44:42 -07001680 nlohmann::json::object_t ipv4;
1681 ipv4["AddressOrigin"] = ipv4Config.origin;
1682 ipv4["SubnetMask"] = ipv4Config.netmask;
1683 ipv4["Address"] = ipv4Config.address;
1684 ipv4["Gateway"] = gatewayStr;
Ed Tanousbf648f72021-06-03 15:00:14 -07001685
Ed Tanousbf648f72021-06-03 15:00:14 -07001686 if (ipv4Config.origin == "Static")
1687 {
Ed Tanous14766872022-03-15 10:44:42 -07001688 ipv4StaticArray.push_back(ipv4);
Ed Tanousbf648f72021-06-03 15:00:14 -07001689 }
Ed Tanous14766872022-03-15 10:44:42 -07001690
1691 ipv4Array.push_back(std::move(ipv4));
Ed Tanousbf648f72021-06-03 15:00:14 -07001692 }
1693
Jiaqing Zhao82695a52022-04-14 15:15:59 +08001694 std::string ipv6GatewayStr = ethData.ipv6DefaultGateway;
Ed Tanousbf648f72021-06-03 15:00:14 -07001695 if (ipv6GatewayStr.empty())
1696 {
1697 ipv6GatewayStr = "0:0:0:0:0:0:0:0";
1698 }
1699
1700 jsonResponse["IPv6DefaultGateway"] = ipv6GatewayStr;
1701
1702 nlohmann::json& ipv6Array = jsonResponse["IPv6Addresses"];
1703 nlohmann::json& ipv6StaticArray = jsonResponse["IPv6StaticAddresses"];
1704 ipv6Array = nlohmann::json::array();
1705 ipv6StaticArray = nlohmann::json::array();
1706 nlohmann::json& ipv6AddrPolicyTable =
1707 jsonResponse["IPv6AddressPolicyTable"];
1708 ipv6AddrPolicyTable = nlohmann::json::array();
Ed Tanous9eb808c2022-01-25 10:19:23 -08001709 for (const auto& ipv6Config : ipv6Data)
Ed Tanousbf648f72021-06-03 15:00:14 -07001710 {
Ed Tanous14766872022-03-15 10:44:42 -07001711 nlohmann::json::object_t ipv6;
1712 ipv6["Address"] = ipv6Config.address;
1713 ipv6["PrefixLength"] = ipv6Config.prefixLength;
1714 ipv6["AddressOrigin"] = ipv6Config.origin;
1715 ipv6["AddressState"] = nullptr;
1716 ipv6Array.push_back(std::move(ipv6));
Ed Tanousbf648f72021-06-03 15:00:14 -07001717 if (ipv6Config.origin == "Static")
1718 {
Ed Tanous14766872022-03-15 10:44:42 -07001719 nlohmann::json::object_t ipv6Static;
1720 ipv6Static["Address"] = ipv6Config.address;
1721 ipv6Static["PrefixLength"] = ipv6Config.prefixLength;
1722 ipv6StaticArray.push_back(std::move(ipv6Static));
Ed Tanousbf648f72021-06-03 15:00:14 -07001723 }
1724 }
1725}
1726
Ed Tanous4f48d5f2021-06-21 08:27:45 -07001727inline bool verifyNames(const std::string& parent, const std::string& iface)
Ed Tanousbf648f72021-06-03 15:00:14 -07001728{
Ed Tanous11ba3972022-07-11 09:50:41 -07001729 return iface.starts_with(parent + "_");
Ed Tanousbf648f72021-06-03 15:00:14 -07001730}
1731
1732inline void requestEthernetInterfacesRoutes(App& app)
1733{
1734 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/")
Ed Tanoused398212021-06-09 17:05:54 -07001735 .privileges(redfish::privileges::getEthernetInterfaceCollection)
Ed Tanous14766872022-03-15 10:44:42 -07001736 .methods(boost::beast::http::verb::get)(
1737 [&app](const crow::Request& req,
1738 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001739 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001740 {
1741 return;
1742 }
1743
1744 asyncResp->res.jsonValue["@odata.type"] =
1745 "#EthernetInterfaceCollection.EthernetInterfaceCollection";
1746 asyncResp->res.jsonValue["@odata.id"] =
1747 "/redfish/v1/Managers/bmc/EthernetInterfaces";
1748 asyncResp->res.jsonValue["Name"] =
1749 "Ethernet Network Interface Collection";
1750 asyncResp->res.jsonValue["Description"] =
1751 "Collection of EthernetInterfaces for this Manager";
1752
1753 // Get eth interface list, and call the below callback for JSON
1754 // preparation
1755 getEthernetIfaceList(
1756 [asyncResp](
1757 const bool& success,
1758 const boost::container::flat_set<std::string>& ifaceList) {
1759 if (!success)
1760 {
1761 messages::internalError(asyncResp->res);
1762 return;
1763 }
1764
1765 nlohmann::json& ifaceArray = asyncResp->res.jsonValue["Members"];
1766 ifaceArray = nlohmann::json::array();
1767 std::string tag = "_";
1768 for (const std::string& ifaceItem : ifaceList)
1769 {
1770 std::size_t found = ifaceItem.find(tag);
1771 if (found == std::string::npos)
Jason M. Billsf12894f2018-10-09 12:45:45 -07001772 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001773 nlohmann::json::object_t iface;
1774 iface["@odata.id"] =
1775 "/redfish/v1/Managers/bmc/EthernetInterfaces/" +
1776 ifaceItem;
1777 ifaceArray.push_back(std::move(iface));
Jason M. Billsf12894f2018-10-09 12:45:45 -07001778 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001779 }
Jason M. Billsf12894f2018-10-09 12:45:45 -07001780
Ed Tanous002d39b2022-05-31 08:59:27 -07001781 asyncResp->res.jsonValue["Members@odata.count"] = ifaceArray.size();
1782 asyncResp->res.jsonValue["@odata.id"] =
1783 "/redfish/v1/Managers/bmc/EthernetInterfaces";
1784 });
1785 });
Johnathan Mantey01784822019-06-18 12:44:21 -07001786
Ed Tanousbf648f72021-06-03 15:00:14 -07001787 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001788 .privileges(redfish::privileges::getEthernetInterface)
Ed Tanousbf648f72021-06-03 15:00:14 -07001789 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001790 [&app](const crow::Request& req,
1791 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1792 const std::string& ifaceId) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001793 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001794 {
1795 return;
1796 }
1797 getEthernetIfaceData(
1798 ifaceId,
1799 [asyncResp, ifaceId](
1800 const bool& success, const EthernetInterfaceData& ethData,
1801 const boost::container::flat_set<IPv4AddressData>& ipv4Data,
1802 const boost::container::flat_set<IPv6AddressData>& ipv6Data) {
1803 if (!success)
1804 {
1805 // TODO(Pawel)consider distinguish between non
1806 // existing object, and other errors
1807 messages::resourceNotFound(asyncResp->res, "EthernetInterface",
1808 ifaceId);
1809 return;
1810 }
Johnathan Mantey01784822019-06-18 12:44:21 -07001811
Jiaqing Zhao188cb622022-05-26 02:14:28 +08001812 // Keep using the v1.6.0 schema here as currently bmcweb have to use
1813 // "VLANs" property deprecated in v1.7.0 for VLAN creation/deletion.
Ed Tanous002d39b2022-05-31 08:59:27 -07001814 asyncResp->res.jsonValue["@odata.type"] =
Jiaqing Zhao188cb622022-05-26 02:14:28 +08001815 "#EthernetInterface.v1_6_0.EthernetInterface";
Ed Tanous002d39b2022-05-31 08:59:27 -07001816 asyncResp->res.jsonValue["Name"] = "Manager Ethernet Interface";
1817 asyncResp->res.jsonValue["Description"] =
1818 "Management Network Interface";
Ratan Guptaf476acb2019-03-02 16:46:57 +05301819
Ed Tanous002d39b2022-05-31 08:59:27 -07001820 parseInterfaceData(asyncResp, ifaceId, ethData, ipv4Data, ipv6Data);
Ed Tanousbf648f72021-06-03 15:00:14 -07001821 });
Ed Tanous002d39b2022-05-31 08:59:27 -07001822 });
Johnathan Mantey01784822019-06-18 12:44:21 -07001823
Ed Tanousbf648f72021-06-03 15:00:14 -07001824 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001825 .privileges(redfish::privileges::patchEthernetInterface)
Ed Tanousbf648f72021-06-03 15:00:14 -07001826 .methods(boost::beast::http::verb::patch)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001827 [&app](const crow::Request& req,
1828 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1829 const std::string& ifaceId) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001830 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001831 {
1832 return;
1833 }
1834 std::optional<std::string> hostname;
1835 std::optional<std::string> fqdn;
1836 std::optional<std::string> macAddress;
1837 std::optional<std::string> ipv6DefaultGateway;
1838 std::optional<nlohmann::json> ipv4StaticAddresses;
1839 std::optional<nlohmann::json> ipv6StaticAddresses;
1840 std::optional<std::vector<std::string>> staticNameServers;
1841 std::optional<nlohmann::json> dhcpv4;
1842 std::optional<nlohmann::json> dhcpv6;
1843 std::optional<bool> interfaceEnabled;
1844 std::optional<size_t> mtuSize;
1845 DHCPParameters v4dhcpParms;
1846 DHCPParameters v6dhcpParms;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001847
Ed Tanous002d39b2022-05-31 08:59:27 -07001848 if (!json_util::readJsonPatch(
1849 req, asyncResp->res, "HostName", hostname, "FQDN", fqdn,
1850 "IPv4StaticAddresses", ipv4StaticAddresses, "MACAddress",
1851 macAddress, "StaticNameServers", staticNameServers,
1852 "IPv6DefaultGateway", ipv6DefaultGateway, "IPv6StaticAddresses",
1853 ipv6StaticAddresses, "DHCPv4", dhcpv4, "DHCPv6", dhcpv6,
1854 "MTUSize", mtuSize, "InterfaceEnabled", interfaceEnabled))
1855 {
1856 return;
1857 }
1858 if (dhcpv4)
1859 {
1860 if (!json_util::readJson(*dhcpv4, asyncResp->res, "DHCPEnabled",
1861 v4dhcpParms.dhcpv4Enabled, "UseDNSServers",
1862 v4dhcpParms.useDnsServers, "UseNTPServers",
1863 v4dhcpParms.useNtpServers, "UseDomainName",
1864 v4dhcpParms.useDomainName))
1865 {
1866 return;
1867 }
1868 }
Johnathan Mantey01784822019-06-18 12:44:21 -07001869
Ed Tanous002d39b2022-05-31 08:59:27 -07001870 if (dhcpv6)
1871 {
1872 if (!json_util::readJson(*dhcpv6, asyncResp->res, "OperatingMode",
1873 v6dhcpParms.dhcpv6OperatingMode,
1874 "UseDNSServers", v6dhcpParms.useDnsServers,
1875 "UseNTPServers", v6dhcpParms.useNtpServers,
1876 "UseDomainName",
1877 v6dhcpParms.useDomainName))
1878 {
1879 return;
1880 }
1881 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001882
Ed Tanous002d39b2022-05-31 08:59:27 -07001883 // Get single eth interface data, and call the below callback
1884 // for JSON preparation
1885 getEthernetIfaceData(
1886 ifaceId,
1887 [asyncResp, ifaceId, hostname = std::move(hostname),
1888 fqdn = std::move(fqdn), macAddress = std::move(macAddress),
1889 ipv4StaticAddresses = std::move(ipv4StaticAddresses),
1890 ipv6DefaultGateway = std::move(ipv6DefaultGateway),
1891 ipv6StaticAddresses = std::move(ipv6StaticAddresses),
1892 staticNameServers = std::move(staticNameServers),
Ed Tanousbc200892022-06-30 17:49:12 -07001893 dhcpv4 = std::move(dhcpv4), dhcpv6 = std::move(dhcpv6), mtuSize,
1894 v4dhcpParms = std::move(v4dhcpParms),
Ed Tanous002d39b2022-05-31 08:59:27 -07001895 v6dhcpParms = std::move(v6dhcpParms), interfaceEnabled](
1896 const bool& success, const EthernetInterfaceData& ethData,
1897 const boost::container::flat_set<IPv4AddressData>& ipv4Data,
1898 const boost::container::flat_set<IPv6AddressData>& ipv6Data) {
1899 if (!success)
1900 {
1901 // ... otherwise return error
1902 // TODO(Pawel)consider distinguish between non
1903 // existing object, and other errors
Jiaqing Zhaod8a5d5d2022-08-05 16:21:51 +08001904 messages::resourceNotFound(asyncResp->res, "EthernetInterface",
Ed Tanous002d39b2022-05-31 08:59:27 -07001905 ifaceId);
1906 return;
1907 }
Ravi Tejae48c0fc2019-04-16 08:37:20 -05001908
Ed Tanous002d39b2022-05-31 08:59:27 -07001909 if (dhcpv4 || dhcpv6)
1910 {
1911 handleDHCPPatch(ifaceId, ethData, v4dhcpParms, v6dhcpParms,
Ed Tanousbf648f72021-06-03 15:00:14 -07001912 asyncResp);
Ed Tanous002d39b2022-05-31 08:59:27 -07001913 }
Tejas Patil35fb5312021-09-20 15:35:20 +05301914
Ed Tanous002d39b2022-05-31 08:59:27 -07001915 if (hostname)
1916 {
1917 handleHostnamePatch(*hostname, asyncResp);
1918 }
1919
1920 if (fqdn)
1921 {
1922 handleFqdnPatch(ifaceId, *fqdn, asyncResp);
1923 }
1924
1925 if (macAddress)
1926 {
1927 handleMACAddressPatch(ifaceId, *macAddress, asyncResp);
1928 }
1929
1930 if (ipv4StaticAddresses)
1931 {
1932 // TODO(ed) for some reason the capture of
1933 // ipv4Addresses above is returning a const value,
1934 // not a non-const value. This doesn't really work
1935 // for us, as we need to be able to efficiently move
1936 // out the intermedia nlohmann::json objects. This
1937 // makes a copy of the structure, and operates on
1938 // that, but could be done more efficiently
1939 nlohmann::json ipv4Static = *ipv4StaticAddresses;
1940 handleIPv4StaticPatch(ifaceId, ipv4Static, ipv4Data, asyncResp);
1941 }
1942
1943 if (staticNameServers)
1944 {
1945 handleStaticNameServersPatch(ifaceId, *staticNameServers,
1946 asyncResp);
1947 }
1948
1949 if (ipv6DefaultGateway)
1950 {
1951 messages::propertyNotWritable(asyncResp->res,
1952 "IPv6DefaultGateway");
1953 }
1954
1955 if (ipv6StaticAddresses)
1956 {
1957 const nlohmann::json& ipv6Static = *ipv6StaticAddresses;
1958 handleIPv6StaticAddressesPatch(ifaceId, ipv6Static, ipv6Data,
1959 asyncResp);
1960 }
1961
1962 if (interfaceEnabled)
1963 {
1964 setEthernetInterfaceBoolProperty(ifaceId, "NICEnabled",
1965 *interfaceEnabled, asyncResp);
1966 }
1967
1968 if (mtuSize)
1969 {
1970 handleMTUSizePatch(ifaceId, *mtuSize, asyncResp);
1971 }
Ed Tanousbf648f72021-06-03 15:00:14 -07001972 });
Ed Tanous002d39b2022-05-31 08:59:27 -07001973 });
manojkiraneda2a133282019-02-19 13:09:43 +05301974
Ed Tanousbf648f72021-06-03 15:00:14 -07001975 BMCWEB_ROUTE(
1976 app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001977 .privileges(redfish::privileges::getVLanNetworkInterface)
Ed Tanousbf648f72021-06-03 15:00:14 -07001978 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001979 [&app](const crow::Request& req,
1980 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1981 const std::string& parentIfaceId,
1982 const std::string& ifaceId) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001983 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001984 {
1985 return;
1986 }
1987 asyncResp->res.jsonValue["@odata.type"] =
1988 "#VLanNetworkInterface.v1_1_0.VLanNetworkInterface";
1989 asyncResp->res.jsonValue["Name"] = "VLAN Network Interface";
Ed Tanous0f74e642018-11-12 15:17:05 -08001990
Ed Tanous002d39b2022-05-31 08:59:27 -07001991 if (!verifyNames(parentIfaceId, ifaceId))
1992 {
1993 return;
1994 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001995
Ed Tanous002d39b2022-05-31 08:59:27 -07001996 // Get single eth interface data, and call the below callback
1997 // for JSON preparation
1998 getEthernetIfaceData(
1999 ifaceId,
2000 [asyncResp, parentIfaceId,
2001 ifaceId](const bool& success, const EthernetInterfaceData& ethData,
2002 const boost::container::flat_set<IPv4AddressData>&,
2003 const boost::container::flat_set<IPv6AddressData>&) {
2004 if (success && ethData.vlanId)
2005 {
Jiaqing Zhao22872ff2022-09-13 09:38:20 +08002006 asyncResp->res.jsonValue["Id"] = ifaceId;
2007 asyncResp->res.jsonValue["@odata.id"] =
2008 "/redfish/v1/Managers/bmc/EthernetInterfaces/" +
2009 parentIfaceId + "/VLANs/" + ifaceId;
2010
Jiaqing Zhao23a06312022-09-13 09:38:25 +08002011 asyncResp->res.jsonValue["VLANEnable"] = ethData.nicEnabled;
Jiaqing Zhao22872ff2022-09-13 09:38:20 +08002012 asyncResp->res.jsonValue["VLANId"] = *ethData.vlanId;
Ed Tanous002d39b2022-05-31 08:59:27 -07002013 }
2014 else
2015 {
2016 // ... otherwise return error
2017 // TODO(Pawel)consider distinguish between non
2018 // existing object, and other errors
2019 messages::resourceNotFound(asyncResp->res,
Jiaqing Zhaod8a5d5d2022-08-05 16:21:51 +08002020 "VLanNetworkInterface", ifaceId);
Ed Tanous002d39b2022-05-31 08:59:27 -07002021 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07002022 });
Ed Tanous002d39b2022-05-31 08:59:27 -07002023 });
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +01002024
Ed Tanousbf648f72021-06-03 15:00:14 -07002025 BMCWEB_ROUTE(
2026 app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/<str>/")
Abhishek Patel3d768a12021-07-31 16:44:51 -05002027 .privileges(redfish::privileges::patchVLanNetworkInterface)
Ed Tanousbf648f72021-06-03 15:00:14 -07002028 .methods(boost::beast::http::verb::patch)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002029 [&app](const crow::Request& req,
2030 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2031 const std::string& parentIfaceId,
2032 const std::string& ifaceId) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002033 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002034 {
2035 return;
2036 }
2037 if (!verifyNames(parentIfaceId, ifaceId))
2038 {
Jiaqing Zhaod8a5d5d2022-08-05 16:21:51 +08002039 messages::resourceNotFound(asyncResp->res, "VLanNetworkInterface",
Ed Tanous002d39b2022-05-31 08:59:27 -07002040 ifaceId);
2041 return;
2042 }
2043
2044 std::optional<bool> vlanEnable;
2045 std::optional<uint32_t> vlanId;
2046
2047 if (!json_util::readJsonPatch(req, asyncResp->res, "VLANEnable",
2048 vlanEnable, "VLANId", vlanId))
2049 {
2050 return;
2051 }
2052
2053 if (vlanId)
2054 {
2055 messages::propertyNotWritable(asyncResp->res, "VLANId");
2056 return;
2057 }
2058
2059 // Get single eth interface data, and call the below callback
2060 // for JSON preparation
2061 getEthernetIfaceData(
2062 ifaceId,
2063 [asyncResp, parentIfaceId, ifaceId, vlanEnable](
2064 const bool& success, const EthernetInterfaceData& ethData,
2065 const boost::container::flat_set<IPv4AddressData>&,
2066 const boost::container::flat_set<IPv6AddressData>&) {
2067 if (success && ethData.vlanId)
2068 {
Jiaqing Zhao23a06312022-09-13 09:38:25 +08002069 if (vlanEnable)
Ed Tanous45ca1b82022-03-25 13:07:27 -07002070 {
Ed Tanous002d39b2022-05-31 08:59:27 -07002071 crow::connections::systemBus->async_method_call(
Jiaqing Zhao23a06312022-09-13 09:38:25 +08002072 [asyncResp](const boost::system::error_code ec) {
2073 if (ec)
2074 {
2075 messages::internalError(asyncResp->res);
2076 return;
2077 }
2078 },
2079 "xyz.openbmc_project.Network",
2080 "/xyz/openbmc_project/network/" + ifaceId,
2081 "org.freedesktop.DBus.Properties", "Set",
2082 "xyz.openbmc_project.Network.EthernetInterface",
2083 "NICEnabled",
2084 dbus::utility::DbusVariantType(*vlanEnable));
Ed Tanous45ca1b82022-03-25 13:07:27 -07002085 }
Ed Tanous002d39b2022-05-31 08:59:27 -07002086 }
2087 else
2088 {
2089 // TODO(Pawel)consider distinguish between non
2090 // existing object, and other errors
2091 messages::resourceNotFound(asyncResp->res,
Jiaqing Zhaod8a5d5d2022-08-05 16:21:51 +08002092 "VLanNetworkInterface", ifaceId);
Ed Tanous002d39b2022-05-31 08:59:27 -07002093 return;
2094 }
Ed Tanousbf648f72021-06-03 15:00:14 -07002095 });
Ed Tanous002d39b2022-05-31 08:59:27 -07002096 });
Ed Tanousbf648f72021-06-03 15:00:14 -07002097
2098 BMCWEB_ROUTE(
2099 app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/<str>/")
Abhishek Patel3d768a12021-07-31 16:44:51 -05002100 .privileges(redfish::privileges::deleteVLanNetworkInterface)
Ed Tanousbf648f72021-06-03 15:00:14 -07002101 .methods(boost::beast::http::verb::delete_)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002102 [&app](const crow::Request& req,
2103 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2104 const std::string& parentIfaceId,
2105 const std::string& ifaceId) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002106 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002107 {
2108 return;
2109 }
2110 if (!verifyNames(parentIfaceId, ifaceId))
2111 {
Jiaqing Zhaod8a5d5d2022-08-05 16:21:51 +08002112 messages::resourceNotFound(asyncResp->res, "VLanNetworkInterface",
Ed Tanous002d39b2022-05-31 08:59:27 -07002113 ifaceId);
2114 return;
2115 }
Ed Tanousbf648f72021-06-03 15:00:14 -07002116
Ed Tanous002d39b2022-05-31 08:59:27 -07002117 // Get single eth interface data, and call the below callback
2118 // for JSON preparation
2119 getEthernetIfaceData(
2120 ifaceId,
2121 [asyncResp, parentIfaceId,
2122 ifaceId](const bool& success, const EthernetInterfaceData& ethData,
2123 const boost::container::flat_set<IPv4AddressData>&,
2124 const boost::container::flat_set<IPv6AddressData>&) {
2125 if (success && ethData.vlanId)
2126 {
2127 auto callback =
2128 [asyncResp](const boost::system::error_code ec) {
2129 if (ec)
2130 {
2131 messages::internalError(asyncResp->res);
2132 }
2133 };
2134 crow::connections::systemBus->async_method_call(
2135 std::move(callback), "xyz.openbmc_project.Network",
2136 std::string("/xyz/openbmc_project/network/") + ifaceId,
2137 "xyz.openbmc_project.Object.Delete", "Delete");
2138 }
2139 else
2140 {
2141 // ... otherwise return error
2142 // TODO(Pawel)consider distinguish between non
2143 // existing object, and other errors
2144 messages::resourceNotFound(asyncResp->res,
Jiaqing Zhaod8a5d5d2022-08-05 16:21:51 +08002145 "VLanNetworkInterface", ifaceId);
Ed Tanous002d39b2022-05-31 08:59:27 -07002146 }
Jason M. Billsf12894f2018-10-09 12:45:45 -07002147 });
Ed Tanous002d39b2022-05-31 08:59:27 -07002148 });
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002149
Ed Tanousbf648f72021-06-03 15:00:14 -07002150 BMCWEB_ROUTE(app,
2151 "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/")
Ed Tanoused398212021-06-09 17:05:54 -07002152
2153 .privileges(redfish::privileges::getVLanNetworkInterfaceCollection)
Ed Tanous14766872022-03-15 10:44:42 -07002154 .methods(boost::beast::http::verb::get)(
2155 [&app](const crow::Request& req,
2156 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2157 const std::string& rootInterfaceName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002158 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002159 {
2160 return;
2161 }
2162 // Get eth interface list, and call the below callback for JSON
2163 // preparation
2164 getEthernetIfaceList(
2165 [asyncResp, rootInterfaceName](
2166 const bool& success,
2167 const boost::container::flat_set<std::string>& ifaceList) {
2168 if (!success)
2169 {
2170 messages::internalError(asyncResp->res);
2171 return;
2172 }
2173
2174 if (ifaceList.find(rootInterfaceName) == ifaceList.end())
2175 {
2176 messages::resourceNotFound(asyncResp->res,
2177 "VLanNetworkInterfaceCollection",
2178 rootInterfaceName);
2179 return;
2180 }
2181
2182 asyncResp->res.jsonValue["@odata.type"] =
2183 "#VLanNetworkInterfaceCollection."
2184 "VLanNetworkInterfaceCollection";
2185 asyncResp->res.jsonValue["Name"] =
2186 "VLAN Network Interface Collection";
2187
2188 nlohmann::json ifaceArray = nlohmann::json::array();
2189
2190 for (const std::string& ifaceItem : ifaceList)
2191 {
Ed Tanous11ba3972022-07-11 09:50:41 -07002192 if (ifaceItem.starts_with(rootInterfaceName + "_"))
Ed Tanous1abe55e2018-09-05 08:30:59 -07002193 {
Ed Tanous002d39b2022-05-31 08:59:27 -07002194 std::string path =
2195 "/redfish/v1/Managers/bmc/EthernetInterfaces/";
2196 path += rootInterfaceName;
2197 path += "/VLANs/";
2198 path += ifaceItem;
2199 nlohmann::json::object_t iface;
2200 iface["@odata.id"] = std::move(path);
2201 ifaceArray.push_back(std::move(iface));
Ed Tanous1abe55e2018-09-05 08:30:59 -07002202 }
Ed Tanous002d39b2022-05-31 08:59:27 -07002203 }
Jason M. Billsf12894f2018-10-09 12:45:45 -07002204
Ed Tanous002d39b2022-05-31 08:59:27 -07002205 asyncResp->res.jsonValue["Members@odata.count"] = ifaceArray.size();
2206 asyncResp->res.jsonValue["Members"] = std::move(ifaceArray);
2207 asyncResp->res.jsonValue["@odata.id"] =
2208 "/redfish/v1/Managers/bmc/EthernetInterfaces/" +
2209 rootInterfaceName + "/VLANs";
2210 });
2211 });
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02002212
Ed Tanousbf648f72021-06-03 15:00:14 -07002213 BMCWEB_ROUTE(app,
2214 "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/")
Abhishek Patel3d768a12021-07-31 16:44:51 -05002215 .privileges(redfish::privileges::postVLanNetworkInterfaceCollection)
Ed Tanousbf648f72021-06-03 15:00:14 -07002216 .methods(boost::beast::http::verb::post)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002217 [&app](const crow::Request& req,
2218 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2219 const std::string& rootInterfaceName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002220 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002221 {
2222 return;
2223 }
2224 bool vlanEnable = false;
2225 uint32_t vlanId = 0;
2226 if (!json_util::readJsonPatch(req, asyncResp->res, "VLANId", vlanId,
2227 "VLANEnable", vlanEnable))
2228 {
2229 return;
2230 }
2231 // Need both vlanId and vlanEnable to service this request
2232 if (vlanId == 0U)
2233 {
2234 messages::propertyMissing(asyncResp->res, "VLANId");
2235 }
2236 if (!vlanEnable)
2237 {
2238 messages::propertyMissing(asyncResp->res, "VLANEnable");
2239 }
2240 if (static_cast<bool>(vlanId) ^ vlanEnable)
2241 {
2242 return;
2243 }
Sunitha Harishfda13ad2019-03-21 11:01:24 -05002244
Ed Tanous002d39b2022-05-31 08:59:27 -07002245 auto callback = [asyncResp](const boost::system::error_code ec) {
2246 if (ec)
2247 {
2248 // TODO(ed) make more consistent error messages
2249 // based on phosphor-network responses
2250 messages::internalError(asyncResp->res);
2251 return;
2252 }
2253 messages::created(asyncResp->res);
2254 };
2255 crow::connections::systemBus->async_method_call(
2256 std::move(callback), "xyz.openbmc_project.Network",
2257 "/xyz/openbmc_project/network",
2258 "xyz.openbmc_project.Network.VLAN.Create", "VLAN",
2259 rootInterfaceName, vlanId);
2260 });
Ed Tanousbf648f72021-06-03 15:00:14 -07002261}
2262
Ed Tanous1abe55e2018-09-05 08:30:59 -07002263} // namespace redfish