blob: 476e03aff2443b359421237bf926119074bfd86f [file] [log] [blame]
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +01001/*
2// Copyright (c) 2018 Intel Corporation
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15*/
16#pragma once
17
Ed Tanous1abe55e2018-09-05 08:30:59 -070018#include <boost/container/flat_map.hpp>
Ed Tanous4a0cb852018-10-15 07:55:04 -070019#include <boost/container/flat_set.hpp>
Kowalski, Kamil179db1d2018-04-23 11:12:41 +020020#include <dbus_singleton.hpp>
Kowalski, Kamil588c3f02018-04-03 14:55:27 +020021#include <error_messages.hpp>
Kowalski, Kamil179db1d2018-04-23 11:12:41 +020022#include <node.hpp>
Ed Tanousa24526d2018-12-10 15:17:59 -080023#include <optional>
Kowalski, Kamil588c3f02018-04-03 14:55:27 +020024#include <utils/json_utils.hpp>
Ed Tanousabf2add2019-01-22 16:40:12 -080025#include <variant>
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010026
Ed Tanous1abe55e2018-09-05 08:30:59 -070027namespace redfish
28{
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010029
30/**
31 * DBus types primitives for several generic DBus interfaces
32 * TODO(Pawel) consider move this to separate file into boost::dbus
33 */
Ed Tanousaa2e59c2018-04-12 12:17:20 -070034using PropertiesMapType = boost::container::flat_map<
Ed Tanousabf2add2019-01-22 16:40:12 -080035 std::string, std::variant<std::string, bool, uint8_t, int16_t, uint16_t,
36 int32_t, uint32_t, int64_t, uint64_t, double>>;
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010037
Ed Tanous4a0cb852018-10-15 07:55:04 -070038using GetManagedObjects = std::vector<std::pair<
Ed Tanousaa2e59c2018-04-12 12:17:20 -070039 sdbusplus::message::object_path,
Ed Tanous4a0cb852018-10-15 07:55:04 -070040 std::vector<std::pair<
Ed Tanousaa2e59c2018-04-12 12:17:20 -070041 std::string,
42 boost::container::flat_map<
Ed Tanous029573d2019-02-01 10:57:49 -080043 std::string, sdbusplus::message::variant<
44 std::string, bool, uint8_t, int16_t, uint16_t,
45 int32_t, uint32_t, int64_t, uint64_t, double,
46 std::vector<std::string>>>>>>>;
Ed Tanous4a0cb852018-10-15 07:55:04 -070047
48enum class LinkType
49{
50 Local,
51 Global
52};
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010053
54/**
55 * Structure for keeping IPv4 data required by Redfish
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010056 */
Ed Tanous1abe55e2018-09-05 08:30:59 -070057struct IPv4AddressData
58{
59 std::string id;
Ed Tanous4a0cb852018-10-15 07:55:04 -070060 std::string address;
61 std::string domain;
62 std::string gateway;
Ed Tanous1abe55e2018-09-05 08:30:59 -070063 std::string netmask;
64 std::string origin;
Ed Tanous4a0cb852018-10-15 07:55:04 -070065 LinkType linktype;
66
Ed Tanous1abe55e2018-09-05 08:30:59 -070067 bool operator<(const IPv4AddressData &obj) const
68 {
Ed Tanous4a0cb852018-10-15 07:55:04 -070069 return id < obj.id;
Ed Tanous1abe55e2018-09-05 08:30:59 -070070 }
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010071};
72
73/**
74 * Structure for keeping basic single Ethernet Interface information
75 * available from DBus
76 */
Ed Tanous1abe55e2018-09-05 08:30:59 -070077struct EthernetInterfaceData
78{
Ed Tanous4a0cb852018-10-15 07:55:04 -070079 uint32_t speed;
80 bool auto_neg;
manojkiraneda2a133282019-02-19 13:09:43 +053081 bool DHCPEnabled;
Ed Tanous4a0cb852018-10-15 07:55:04 -070082 std::string hostname;
83 std::string default_gateway;
84 std::string mac_address;
Ed Tanousa24526d2018-12-10 15:17:59 -080085 std::optional<uint32_t> vlan_id;
Ed Tanous029573d2019-02-01 10:57:49 -080086 std::vector<std::string> nameservers;
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +010087};
88
Ed Tanous4a0cb852018-10-15 07:55:04 -070089// Helper function that changes bits netmask notation (i.e. /24)
90// into full dot notation
91inline std::string getNetmask(unsigned int bits)
Ed Tanous1abe55e2018-09-05 08:30:59 -070092{
Ed Tanous4a0cb852018-10-15 07:55:04 -070093 uint32_t value = 0xffffffff << (32 - bits);
94 std::string netmask = std::to_string((value >> 24) & 0xff) + "." +
95 std::to_string((value >> 16) & 0xff) + "." +
96 std::to_string((value >> 8) & 0xff) + "." +
97 std::to_string(value & 0xff);
98 return netmask;
99}
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +0100100
Ed Tanous4a0cb852018-10-15 07:55:04 -0700101inline std::string
102 translateAddressOriginDbusToRedfish(const std::string &inputOrigin,
103 bool isIPv4)
104{
105 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.Static")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700106 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700107 return "Static";
108 }
109 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.LinkLocal")
110 {
111 if (isIPv4)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700112 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700113 return "IPv4LinkLocal";
114 }
115 else
116 {
117 return "LinkLocal";
118 }
119 }
120 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.DHCP")
121 {
122 if (isIPv4)
123 {
124 return "DHCP";
125 }
126 else
127 {
128 return "DHCPv6";
129 }
130 }
131 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.SLAAC")
132 {
133 return "SLAAC";
134 }
135 return "";
136}
137
138inline std::string
139 translateAddressOriginRedfishToDbus(const std::string &inputOrigin)
140{
141 if (inputOrigin == "Static")
142 {
143 return "xyz.openbmc_project.Network.IP.AddressOrigin.Static";
144 }
145 if (inputOrigin == "DHCP" || inputOrigin == "DHCPv6")
146 {
147 return "xyz.openbmc_project.Network.IP.AddressOrigin.DHCP";
148 }
149 if (inputOrigin == "IPv4LinkLocal" || inputOrigin == "LinkLocal")
150 {
151 return "xyz.openbmc_project.Network.IP.AddressOrigin.LinkLocal";
152 }
153 if (inputOrigin == "SLAAC")
154 {
155 return "xyz.openbmc_project.Network.IP.AddressOrigin.SLAAC";
156 }
157 return "";
158}
159
160inline void extractEthernetInterfaceData(const std::string &ethiface_id,
161 const GetManagedObjects &dbus_data,
162 EthernetInterfaceData &ethData)
163{
164 for (const auto &objpath : dbus_data)
165 {
Ed Tanous029573d2019-02-01 10:57:49 -0800166 for (const auto &ifacePair : objpath.second)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700167 {
Ed Tanous029573d2019-02-01 10:57:49 -0800168 if (objpath.first == "/xyz/openbmc_project/network/" + ethiface_id)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700169 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700170 if (ifacePair.first == "xyz.openbmc_project.Network.MACAddress")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700171 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700172 for (const auto &propertyPair : ifacePair.second)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700173 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700174 if (propertyPair.first == "MACAddress")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700175 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700176 const std::string *mac =
Ed Tanousabf2add2019-01-22 16:40:12 -0800177 std::get_if<std::string>(&propertyPair.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700178 if (mac != nullptr)
179 {
180 ethData.mac_address = *mac;
181 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700182 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700183 }
184 }
185 else if (ifacePair.first == "xyz.openbmc_project.Network.VLAN")
186 {
187 for (const auto &propertyPair : ifacePair.second)
188 {
189 if (propertyPair.first == "Id")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700190 {
Ed Tanous1b6b96c2018-11-30 11:35:41 -0800191 const uint32_t *id =
Ed Tanousabf2add2019-01-22 16:40:12 -0800192 std::get_if<uint32_t>(&propertyPair.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700193 if (id != nullptr)
194 {
195 ethData.vlan_id = *id;
196 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700197 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700198 }
199 }
200 else if (ifacePair.first ==
201 "xyz.openbmc_project.Network.EthernetInterface")
202 {
203 for (const auto &propertyPair : ifacePair.second)
204 {
205 if (propertyPair.first == "AutoNeg")
206 {
207 const bool *auto_neg =
Ed Tanousabf2add2019-01-22 16:40:12 -0800208 std::get_if<bool>(&propertyPair.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700209 if (auto_neg != nullptr)
210 {
211 ethData.auto_neg = *auto_neg;
212 }
213 }
214 else if (propertyPair.first == "Speed")
215 {
216 const uint32_t *speed =
Ed Tanousabf2add2019-01-22 16:40:12 -0800217 std::get_if<uint32_t>(&propertyPair.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700218 if (speed != nullptr)
219 {
220 ethData.speed = *speed;
221 }
222 }
Ed Tanous029573d2019-02-01 10:57:49 -0800223 else if (propertyPair.first == "NameServers")
Ed Tanous4a0cb852018-10-15 07:55:04 -0700224 {
Ed Tanous029573d2019-02-01 10:57:49 -0800225 const std::vector<std::string> *nameservers =
226 sdbusplus::message::variant_ns::get_if<
227 std::vector<std::string>>(
228 &propertyPair.second);
229 if (nameservers != nullptr)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700230 {
Ed Tanous029573d2019-02-01 10:57:49 -0800231 ethData.nameservers = std::move(*nameservers);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700232 }
233 }
manojkiraneda2a133282019-02-19 13:09:43 +0530234 else if (propertyPair.first == "DHCPEnabled")
235 {
236 const bool *DHCPEnabled =
237 std::get_if<bool>(&propertyPair.second);
238 if (DHCPEnabled != nullptr)
239 {
240 ethData.DHCPEnabled = *DHCPEnabled;
241 }
242 }
Ed Tanous029573d2019-02-01 10:57:49 -0800243 }
244 }
245 }
246 // System configuration shows up in the global namespace, so no need
247 // to check eth number
248 if (ifacePair.first ==
249 "xyz.openbmc_project.Network.SystemConfiguration")
250 {
251 for (const auto &propertyPair : ifacePair.second)
252 {
253 if (propertyPair.first == "HostName")
254 {
255 const std::string *hostname =
256 sdbusplus::message::variant_ns::get_if<std::string>(
257 &propertyPair.second);
258 if (hostname != nullptr)
Ed Tanous4a0cb852018-10-15 07:55:04 -0700259 {
Ed Tanous029573d2019-02-01 10:57:49 -0800260 ethData.hostname = *hostname;
261 }
262 }
263 else if (propertyPair.first == "DefaultGateway")
264 {
265 const std::string *defaultGateway =
266 sdbusplus::message::variant_ns::get_if<std::string>(
267 &propertyPair.second);
268 if (defaultGateway != nullptr)
269 {
270 ethData.default_gateway = *defaultGateway;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700271 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700272 }
273 }
274 }
275 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700276 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700277}
278
279// Helper function that extracts data for single ethernet ipv4 address
280inline void
281 extractIPData(const std::string &ethiface_id,
282 const GetManagedObjects &dbus_data,
283 boost::container::flat_set<IPv4AddressData> &ipv4_config)
284{
285 const std::string ipv4PathStart =
286 "/xyz/openbmc_project/network/" + ethiface_id + "/ipv4/";
287
288 // Since there might be several IPv4 configurations aligned with
289 // single ethernet interface, loop over all of them
290 for (const auto &objpath : dbus_data)
291 {
292 // Check if proper pattern for object path appears
293 if (boost::starts_with(objpath.first.str, ipv4PathStart))
294 {
295 for (auto &interface : objpath.second)
296 {
297 if (interface.first == "xyz.openbmc_project.Network.IP")
298 {
299 // Instance IPv4AddressData structure, and set as
300 // appropriate
301 std::pair<
302 boost::container::flat_set<IPv4AddressData>::iterator,
303 bool>
304 it = ipv4_config.insert(
305 {objpath.first.str.substr(ipv4PathStart.size())});
306 IPv4AddressData &ipv4_address = *it.first;
307 for (auto &property : interface.second)
308 {
309 if (property.first == "Address")
310 {
311 const std::string *address =
Ed Tanousabf2add2019-01-22 16:40:12 -0800312 std::get_if<std::string>(&property.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700313 if (address != nullptr)
314 {
315 ipv4_address.address = *address;
316 }
317 }
318 else if (property.first == "Gateway")
319 {
320 const std::string *gateway =
Ed Tanousabf2add2019-01-22 16:40:12 -0800321 std::get_if<std::string>(&property.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700322 if (gateway != nullptr)
323 {
324 ipv4_address.gateway = *gateway;
325 }
326 }
327 else if (property.first == "Origin")
328 {
329 const std::string *origin =
Ed Tanousabf2add2019-01-22 16:40:12 -0800330 std::get_if<std::string>(&property.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700331 if (origin != nullptr)
332 {
333 ipv4_address.origin =
334 translateAddressOriginDbusToRedfish(*origin,
335 true);
336 }
337 }
338 else if (property.first == "PrefixLength")
339 {
340 const uint8_t *mask =
Ed Tanousabf2add2019-01-22 16:40:12 -0800341 std::get_if<uint8_t>(&property.second);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700342 if (mask != nullptr)
343 {
344 // convert it to the string
345 ipv4_address.netmask = getNetmask(*mask);
346 }
347 }
348 else
349 {
350 BMCWEB_LOG_ERROR
351 << "Got extra property: " << property.first
352 << " on the " << objpath.first.str << " object";
353 }
354 }
355 // Check if given address is local, or global
356 ipv4_address.linktype =
357 boost::starts_with(ipv4_address.address, "169.254.")
358 ? LinkType::Global
359 : LinkType::Local;
360 }
361 }
362 }
363 }
364}
365
366/**
367 * @brief Sets given Id on the given VLAN interface through D-Bus
368 *
369 * @param[in] ifaceId Id of VLAN interface that should be modified
370 * @param[in] inputVlanId New ID of the VLAN
371 * @param[in] callback Function that will be called after the operation
372 *
373 * @return None.
374 */
375template <typename CallbackFunc>
376void changeVlanId(const std::string &ifaceId, const uint32_t &inputVlanId,
377 CallbackFunc &&callback)
378{
379 crow::connections::systemBus->async_method_call(
380 callback, "xyz.openbmc_project.Network",
381 std::string("/xyz/openbmc_project/network/") + ifaceId,
382 "org.freedesktop.DBus.Properties", "Set",
383 "xyz.openbmc_project.Network.VLAN", "Id",
Ed Tanousabf2add2019-01-22 16:40:12 -0800384 std::variant<uint32_t>(inputVlanId));
Ed Tanous4a0cb852018-10-15 07:55:04 -0700385}
386
387/**
388 * @brief Helper function that verifies IP address to check if it is in
389 * proper format. If bits pointer is provided, also calculates active
390 * bit count for Subnet Mask.
391 *
392 * @param[in] ip IP that will be verified
393 * @param[out] bits Calculated mask in bits notation
394 *
395 * @return true in case of success, false otherwise
396 */
397inline bool ipv4VerifyIpAndGetBitcount(const std::string &ip,
398 uint8_t *bits = nullptr)
399{
400 std::vector<std::string> bytesInMask;
401
402 boost::split(bytesInMask, ip, boost::is_any_of("."));
Ed Tanous1abe55e2018-09-05 08:30:59 -0700403
404 static const constexpr int ipV4AddressSectionsCount = 4;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700405 if (bytesInMask.size() != ipV4AddressSectionsCount)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700406 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700407 return false;
408 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700409
Ed Tanous4a0cb852018-10-15 07:55:04 -0700410 if (bits != nullptr)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700411 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700412 *bits = 0;
413 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700414
Ed Tanous4a0cb852018-10-15 07:55:04 -0700415 char *endPtr;
416 long previousValue = 255;
417 bool firstZeroInByteHit;
418 for (const std::string &byte : bytesInMask)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700419 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700420 if (byte.empty())
421 {
422 return false;
423 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700424
Ed Tanous4a0cb852018-10-15 07:55:04 -0700425 // Use strtol instead of stroi to avoid exceptions
426 long value = std::strtol(byte.c_str(), &endPtr, 10);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700427
Ed Tanous4a0cb852018-10-15 07:55:04 -0700428 // endPtr should point to the end of the string, otherwise given string
429 // is not 100% number
430 if (*endPtr != '\0')
431 {
432 return false;
433 }
434
435 // Value should be contained in byte
436 if (value < 0 || value > 255)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700437 {
438 return false;
439 }
440
441 if (bits != nullptr)
442 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700443 // Mask has to be continuous between bytes
444 if (previousValue != 255 && value != 0)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700445 {
446 return false;
447 }
448
Ed Tanous4a0cb852018-10-15 07:55:04 -0700449 // Mask has to be continuous inside bytes
450 firstZeroInByteHit = false;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700451
Ed Tanous4a0cb852018-10-15 07:55:04 -0700452 // Count bits
453 for (int bitIdx = 7; bitIdx >= 0; bitIdx--)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700454 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700455 if (value & (1 << bitIdx))
Ed Tanous1abe55e2018-09-05 08:30:59 -0700456 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700457 if (firstZeroInByteHit)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700458 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700459 // Continuity not preserved
460 return false;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700461 }
462 else
463 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700464 (*bits)++;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700465 }
466 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700467 else
468 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700469 firstZeroInByteHit = true;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700470 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700471 }
472 }
473
474 previousValue = value;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700475 }
476
Ed Tanous4a0cb852018-10-15 07:55:04 -0700477 return true;
478}
479
480/**
481 * @brief Changes IPv4 address type property (Address, Gateway)
482 *
483 * @param[in] ifaceId Id of interface whose IP should be modified
484 * @param[in] ipIdx Index of IP in input array that should be modified
485 * @param[in] ipHash DBus Hash id of modified IP
486 * @param[in] name Name of field in JSON representation
487 * @param[in] newValue New value that should be written
488 * @param[io] asyncResp Response object that will be returned to client
489 *
490 * @return true if give IP is valid and has been sent do D-Bus, false
491 * otherwise
492 */
493inline void changeIPv4AddressProperty(
494 const std::string &ifaceId, int ipIdx, const std::string &ipHash,
495 const std::string &name, const std::string &newValue,
496 const std::shared_ptr<AsyncResp> asyncResp)
497{
498 auto callback = [asyncResp, ipIdx, name{std::string(name)},
499 newValue{std::move(newValue)}](
500 const boost::system::error_code ec) {
501 if (ec)
502 {
Jason M. Billsa08b46c2018-11-06 15:01:08 -0800503 messages::internalError(asyncResp->res);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700504 }
505 else
506 {
507 asyncResp->res.jsonValue["IPv4Addresses"][ipIdx][name] = newValue;
508 }
509 };
510
511 crow::connections::systemBus->async_method_call(
512 std::move(callback), "xyz.openbmc_project.Network",
513 "/xyz/openbmc_project/network/" + ifaceId + "/ipv4/" + ipHash,
514 "org.freedesktop.DBus.Properties", "Set",
515 "xyz.openbmc_project.Network.IP", name,
Ed Tanousabf2add2019-01-22 16:40:12 -0800516 std::variant<std::string>(newValue));
Ed Tanous4a0cb852018-10-15 07:55:04 -0700517}
518
519/**
520 * @brief Changes IPv4 address origin property
521 *
522 * @param[in] ifaceId Id of interface whose IP should be modified
523 * @param[in] ipIdx Index of IP in input array that should be
524 * modified
525 * @param[in] ipHash DBus Hash id of modified IP
526 * @param[in] newValue New value in Redfish format
527 * @param[in] newValueDbus New value in D-Bus format
528 * @param[io] asyncResp Response object that will be returned to client
529 *
530 * @return true if give IP is valid and has been sent do D-Bus, false
531 * otherwise
532 */
533inline void changeIPv4Origin(const std::string &ifaceId, int ipIdx,
534 const std::string &ipHash,
535 const std::string &newValue,
536 const std::string &newValueDbus,
537 const std::shared_ptr<AsyncResp> asyncResp)
538{
539 auto callback = [asyncResp, ipIdx, newValue{std::move(newValue)}](
540 const boost::system::error_code ec) {
541 if (ec)
542 {
Jason M. Billsa08b46c2018-11-06 15:01:08 -0800543 messages::internalError(asyncResp->res);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700544 }
545 else
546 {
547 asyncResp->res.jsonValue["IPv4Addresses"][ipIdx]["AddressOrigin"] =
548 newValue;
549 }
550 };
551
552 crow::connections::systemBus->async_method_call(
553 std::move(callback), "xyz.openbmc_project.Network",
554 "/xyz/openbmc_project/network/" + ifaceId + "/ipv4/" + ipHash,
555 "org.freedesktop.DBus.Properties", "Set",
556 "xyz.openbmc_project.Network.IP", "Origin",
Ed Tanousabf2add2019-01-22 16:40:12 -0800557 std::variant<std::string>(newValueDbus));
Ed Tanous4a0cb852018-10-15 07:55:04 -0700558}
559
560/**
561 * @brief Modifies SubnetMask for given IP
562 *
563 * @param[in] ifaceId Id of interface whose IP should be modified
564 * @param[in] ipIdx Index of IP in input array that should be
565 * modified
566 * @param[in] ipHash DBus Hash id of modified IP
567 * @param[in] newValueStr Mask in dot notation as string
568 * @param[in] newValue Mask as PrefixLength in bitcount
569 * @param[io] asyncResp Response object that will be returned to client
570 *
571 * @return None
572 */
573inline void changeIPv4SubnetMaskProperty(const std::string &ifaceId, int ipIdx,
574 const std::string &ipHash,
575 const std::string &newValueStr,
576 uint8_t &newValue,
577 std::shared_ptr<AsyncResp> asyncResp)
578{
579 auto callback = [asyncResp, ipIdx, newValueStr{std::move(newValueStr)}](
580 const boost::system::error_code ec) {
581 if (ec)
582 {
Jason M. Billsa08b46c2018-11-06 15:01:08 -0800583 messages::internalError(asyncResp->res);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700584 }
585 else
586 {
587 asyncResp->res.jsonValue["IPv4Addresses"][ipIdx]["SubnetMask"] =
588 newValueStr;
589 }
590 };
591
592 crow::connections::systemBus->async_method_call(
593 std::move(callback), "xyz.openbmc_project.Network",
594 "/xyz/openbmc_project/network/" + ifaceId + "/ipv4/" + ipHash,
595 "org.freedesktop.DBus.Properties", "Set",
596 "xyz.openbmc_project.Network.IP", "PrefixLength",
Ed Tanousabf2add2019-01-22 16:40:12 -0800597 std::variant<uint8_t>(newValue));
Ed Tanous4a0cb852018-10-15 07:55:04 -0700598}
599
600/**
Ed Tanous4a0cb852018-10-15 07:55:04 -0700601 * @brief Deletes given IPv4
602 *
603 * @param[in] ifaceId Id of interface whose IP should be deleted
604 * @param[in] ipIdx Index of IP in input array that should be deleted
605 * @param[in] ipHash DBus Hash id of IP that should be deleted
606 * @param[io] asyncResp Response object that will be returned to client
607 *
608 * @return None
609 */
610inline void deleteIPv4(const std::string &ifaceId, const std::string &ipHash,
611 unsigned int ipIdx,
612 const std::shared_ptr<AsyncResp> asyncResp)
613{
614 crow::connections::systemBus->async_method_call(
615 [ipIdx, asyncResp](const boost::system::error_code ec) {
Ed Tanous1abe55e2018-09-05 08:30:59 -0700616 if (ec)
617 {
Jason M. Billsa08b46c2018-11-06 15:01:08 -0800618 messages::internalError(asyncResp->res);
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +0100619 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700620 else
621 {
622 asyncResp->res.jsonValue["IPv4Addresses"][ipIdx] = nullptr;
623 }
624 },
625 "xyz.openbmc_project.Network",
626 "/xyz/openbmc_project/network/" + ifaceId + "/ipv4/" + ipHash,
627 "xyz.openbmc_project.Object.Delete", "Delete");
628}
Ed Tanous1abe55e2018-09-05 08:30:59 -0700629
Ed Tanous4a0cb852018-10-15 07:55:04 -0700630/**
631 * @brief Creates IPv4 with given data
632 *
633 * @param[in] ifaceId Id of interface whose IP should be deleted
634 * @param[in] ipIdx Index of IP in input array that should be deleted
635 * @param[in] ipHash DBus Hash id of IP that should be deleted
636 * @param[io] asyncResp Response object that will be returned to client
637 *
638 * @return None
639 */
640inline void createIPv4(const std::string &ifaceId, unsigned int ipIdx,
641 uint8_t subnetMask, const std::string &gateway,
642 const std::string &address,
643 std::shared_ptr<AsyncResp> asyncResp)
644{
Ed Tanous43b761d2019-02-13 20:10:56 -0800645 auto createIpHandler = [asyncResp](const boost::system::error_code ec) {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700646 if (ec)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700647 {
Jason M. Billsa08b46c2018-11-06 15:01:08 -0800648 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700649 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700650 };
651
Ed Tanous4a0cb852018-10-15 07:55:04 -0700652 crow::connections::systemBus->async_method_call(
653 std::move(createIpHandler), "xyz.openbmc_project.Network",
654 "/xyz/openbmc_project/network/" + ifaceId,
655 "xyz.openbmc_project.Network.IP.Create", "IP",
656 "xyz.openbmc_project.Network.IP.Protocol.IPv4", address, subnetMask,
657 gateway);
658}
manojkiraneda2a133282019-02-19 13:09:43 +0530659using GetAllPropertiesType =
660 boost::container::flat_map<std::string, sdbusplus::message::variant<bool>>;
661
662inline void getDHCPConfigData(const std::shared_ptr<AsyncResp> asyncResp)
663{
664 auto getConfig = [asyncResp](const boost::system::error_code error_code,
665 const GetAllPropertiesType &dbus_data) {
666 if (error_code)
667 {
668 BMCWEB_LOG_ERROR << "D-Bus response error: " << error_code;
669 messages::internalError(asyncResp->res);
670 return;
671 }
672 nlohmann::json &DHCPConfigTypeJson =
673 asyncResp->res.jsonValue["DHCPv4Configuration"];
674 for (const auto &property : dbus_data)
675 {
676 auto value =
677 sdbusplus::message::variant_ns::get_if<bool>(&property.second);
678
679 if (value == nullptr)
680 {
681 continue;
682 }
683 if (property.first == "DNSEnabled")
684 {
685 DHCPConfigTypeJson["UseDNSServers"] = *value;
686 }
687 else if (property.first == "HostNameEnabled")
688 {
689 DHCPConfigTypeJson["UseDomainName"] = *value;
690 }
691 else if (property.first == "NTPEnabled")
692 {
693 DHCPConfigTypeJson["UseNTPServers"] = *value;
694 }
695 }
696 };
697 crow::connections::systemBus->async_method_call(
698 std::move(getConfig), "xyz.openbmc_project.Network",
699 "/xyz/openbmc_project/network/config/dhcp",
700 "org.freedesktop.DBus.Properties", "GetAll",
701 "xyz.openbmc_project.Network.DHCPConfiguration");
702}
Ed Tanous1abe55e2018-09-05 08:30:59 -0700703
Ed Tanous4a0cb852018-10-15 07:55:04 -0700704/**
705 * Function that retrieves all properties for given Ethernet Interface
706 * Object
707 * from EntityManager Network Manager
708 * @param ethiface_id a eth interface id to query on DBus
709 * @param callback a function that shall be called to convert Dbus output
710 * into JSON
711 */
712template <typename CallbackFunc>
713void getEthernetIfaceData(const std::string &ethiface_id,
714 CallbackFunc &&callback)
715{
716 crow::connections::systemBus->async_method_call(
717 [ethiface_id{std::string{ethiface_id}}, callback{std::move(callback)}](
718 const boost::system::error_code error_code,
719 const GetManagedObjects &resp) {
720 EthernetInterfaceData ethData{};
721 boost::container::flat_set<IPv4AddressData> ipv4Data;
722
723 if (error_code)
724 {
725 callback(false, ethData, ipv4Data);
726 return;
727 }
728
729 extractEthernetInterfaceData(ethiface_id, resp, ethData);
730 extractIPData(ethiface_id, resp, ipv4Data);
731
732 // Fix global GW
733 for (IPv4AddressData &ipv4 : ipv4Data)
734 {
735 if ((ipv4.linktype == LinkType::Global) &&
736 (ipv4.gateway == "0.0.0.0"))
Ed Tanous1abe55e2018-09-05 08:30:59 -0700737 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700738 ipv4.gateway = ethData.default_gateway;
739 }
740 }
741
742 // Finally make a callback with usefull data
743 callback(true, ethData, ipv4Data);
744 },
745 "xyz.openbmc_project.Network", "/xyz/openbmc_project/network",
746 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
747};
748
749/**
750 * Function that retrieves all Ethernet Interfaces available through Network
751 * Manager
752 * @param callback a function that shall be called to convert Dbus output
753 * into JSON.
754 */
755template <typename CallbackFunc>
756void getEthernetIfaceList(CallbackFunc &&callback)
757{
758 crow::connections::systemBus->async_method_call(
759 [callback{std::move(callback)}](
760 const boost::system::error_code error_code,
761 GetManagedObjects &resp) {
762 // Callback requires vector<string> to retrieve all available
763 // ethernet interfaces
764 std::vector<std::string> iface_list;
765 iface_list.reserve(resp.size());
766 if (error_code)
767 {
768 callback(false, iface_list);
769 return;
770 }
771
772 // Iterate over all retrieved ObjectPaths.
773 for (const auto &objpath : resp)
774 {
775 // And all interfaces available for certain ObjectPath.
776 for (const auto &interface : objpath.second)
777 {
778 // If interface is
779 // xyz.openbmc_project.Network.EthernetInterface, this is
780 // what we're looking for.
781 if (interface.first ==
782 "xyz.openbmc_project.Network.EthernetInterface")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700783 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700784 // Cut out everyting until last "/", ...
785 const std::string &iface_id = objpath.first.str;
786 std::size_t last_pos = iface_id.rfind("/");
787 if (last_pos != std::string::npos)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700788 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700789 // and put it into output vector.
790 iface_list.emplace_back(
791 iface_id.substr(last_pos + 1));
Ed Tanous1abe55e2018-09-05 08:30:59 -0700792 }
793 }
794 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700795 }
796 // Finally make a callback with useful data
797 callback(true, iface_list);
798 },
799 "xyz.openbmc_project.Network", "/xyz/openbmc_project/network",
800 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +0100801};
802
803/**
804 * EthernetCollection derived class for delivering Ethernet Collection Schema
805 */
Ed Tanous1abe55e2018-09-05 08:30:59 -0700806class EthernetCollection : public Node
807{
808 public:
Ed Tanous4a0cb852018-10-15 07:55:04 -0700809 template <typename CrowApp>
Ed Tanous1abe55e2018-09-05 08:30:59 -0700810 EthernetCollection(CrowApp &app) :
Ed Tanous4a0cb852018-10-15 07:55:04 -0700811 Node(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/")
Ed Tanous1abe55e2018-09-05 08:30:59 -0700812 {
Ed Tanous1abe55e2018-09-05 08:30:59 -0700813 entityPrivileges = {
814 {boost::beast::http::verb::get, {{"Login"}}},
815 {boost::beast::http::verb::head, {{"Login"}}},
816 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
817 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
818 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
819 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
820 }
821
822 private:
823 /**
824 * Functions triggers appropriate requests on DBus
825 */
826 void doGet(crow::Response &res, const crow::Request &req,
827 const std::vector<std::string> &params) override
828 {
Ed Tanous0f74e642018-11-12 15:17:05 -0800829 res.jsonValue["@odata.type"] =
830 "#EthernetInterfaceCollection.EthernetInterfaceCollection";
831 res.jsonValue["@odata.context"] =
832 "/redfish/v1/"
833 "$metadata#EthernetInterfaceCollection.EthernetInterfaceCollection";
834 res.jsonValue["@odata.id"] =
835 "/redfish/v1/Managers/bmc/EthernetInterfaces";
836 res.jsonValue["Name"] = "Ethernet Network Interface Collection";
837 res.jsonValue["Description"] =
838 "Collection of EthernetInterfaces for this Manager";
839
Ed Tanous4a0cb852018-10-15 07:55:04 -0700840 // Get eth interface list, and call the below callback for JSON
Ed Tanous1abe55e2018-09-05 08:30:59 -0700841 // preparation
Jason M. Billsf12894f2018-10-09 12:45:45 -0700842 getEthernetIfaceList(
843 [&res](const bool &success,
844 const std::vector<std::string> &iface_list) {
845 if (!success)
846 {
847 messages::internalError(res);
848 res.end();
849 return;
850 }
851
852 nlohmann::json &iface_array = res.jsonValue["Members"];
853 iface_array = nlohmann::json::array();
854 for (const std::string &iface_item : iface_list)
855 {
856 iface_array.push_back(
857 {{"@odata.id",
858 "/redfish/v1/Managers/bmc/EthernetInterfaces/" +
859 iface_item}});
860 }
861
862 res.jsonValue["Members@odata.count"] = iface_array.size();
863 res.jsonValue["@odata.id"] =
864 "/redfish/v1/Managers/bmc/EthernetInterfaces";
Ed Tanous1abe55e2018-09-05 08:30:59 -0700865 res.end();
Jason M. Billsf12894f2018-10-09 12:45:45 -0700866 });
Ed Tanous4a0cb852018-10-15 07:55:04 -0700867 }
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +0100868};
869
870/**
871 * EthernetInterface derived class for delivering Ethernet Schema
872 */
Ed Tanous1abe55e2018-09-05 08:30:59 -0700873class EthernetInterface : public Node
874{
875 public:
876 /*
877 * Default Constructor
878 */
Ed Tanous4a0cb852018-10-15 07:55:04 -0700879 template <typename CrowApp>
Ed Tanous1abe55e2018-09-05 08:30:59 -0700880 EthernetInterface(CrowApp &app) :
Ed Tanous4a0cb852018-10-15 07:55:04 -0700881 Node(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/",
Ed Tanous1abe55e2018-09-05 08:30:59 -0700882 std::string())
883 {
Ed Tanous1abe55e2018-09-05 08:30:59 -0700884 entityPrivileges = {
885 {boost::beast::http::verb::get, {{"Login"}}},
886 {boost::beast::http::verb::head, {{"Login"}}},
887 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
888 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
889 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
890 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
Kowalski, Kamil588c3f02018-04-03 14:55:27 +0200891 }
892
Ed Tanous1abe55e2018-09-05 08:30:59 -0700893 // TODO(kkowalsk) Find a suitable class/namespace for this
Ed Tanous0627a2c2018-11-29 17:09:23 -0800894 static void handleVlanPatch(const std::string &ifaceId, bool vlanEnable,
895 uint64_t vlanId,
Ed Tanous4a0cb852018-10-15 07:55:04 -0700896 const EthernetInterfaceData &ethData,
897 const std::shared_ptr<AsyncResp> asyncResp)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700898 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700899 if (!ethData.vlan_id)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700900 {
901 // This interface is not a VLAN. Cannot do anything with it
902 // TODO(kkowalsk) Change this message
Jason M. Billsa08b46c2018-11-06 15:01:08 -0800903 messages::propertyNotWritable(asyncResp->res, "VLANEnable");
Ed Tanous1abe55e2018-09-05 08:30:59 -0700904
Ed Tanous1abe55e2018-09-05 08:30:59 -0700905 return;
906 }
907
908 // VLAN is configured on the interface
Ed Tanous0627a2c2018-11-29 17:09:23 -0800909 if (vlanEnable == true)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700910 {
911 // Change VLAN Id
Ed Tanous0627a2c2018-11-29 17:09:23 -0800912 asyncResp->res.jsonValue["VLANId"] = vlanId;
Ed Tanous4a0cb852018-10-15 07:55:04 -0700913 auto callback = [asyncResp](const boost::system::error_code ec) {
914 if (ec)
915 {
Jason M. Billsf12894f2018-10-09 12:45:45 -0700916 messages::internalError(asyncResp->res);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700917 }
918 else
919 {
920 asyncResp->res.jsonValue["VLANEnable"] = true;
921 }
922 };
923 crow::connections::systemBus->async_method_call(
924 std::move(callback), "xyz.openbmc_project.Network",
925 "/xyz/openbmc_project/network/" + ifaceId,
926 "org.freedesktop.DBus.Properties", "Set",
927 "xyz.openbmc_project.Network.VLAN", "Id",
Ed Tanousabf2add2019-01-22 16:40:12 -0800928 std::variant<uint32_t>(vlanId));
Ed Tanous1abe55e2018-09-05 08:30:59 -0700929 }
Ed Tanous4a0cb852018-10-15 07:55:04 -0700930 else
Ed Tanous1abe55e2018-09-05 08:30:59 -0700931 {
Ed Tanous4a0cb852018-10-15 07:55:04 -0700932 auto callback = [asyncResp](const boost::system::error_code ec) {
933 if (ec)
934 {
Jason M. Billsf12894f2018-10-09 12:45:45 -0700935 messages::internalError(asyncResp->res);
Ed Tanous4a0cb852018-10-15 07:55:04 -0700936 return;
937 }
938 asyncResp->res.jsonValue["VLANEnable"] = false;
939 };
940
941 crow::connections::systemBus->async_method_call(
942 std::move(callback), "xyz.openbmc_project.Network",
943 "/xyz/openbmc_project/network/" + ifaceId,
944 "xyz.openbmc_project.Object.Delete", "Delete");
Ed Tanous1abe55e2018-09-05 08:30:59 -0700945 }
946 }
947
948 private:
Ed Tanousbc0bd6e2018-12-10 14:07:55 -0800949 void handleHostnamePatch(const std::string &hostname,
Ed Tanous4a0cb852018-10-15 07:55:04 -0700950 const std::shared_ptr<AsyncResp> asyncResp)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700951 {
Ed Tanousbc0bd6e2018-12-10 14:07:55 -0800952 asyncResp->res.jsonValue["HostName"] = hostname;
953 crow::connections::systemBus->async_method_call(
954 [asyncResp](const boost::system::error_code ec) {
955 if (ec)
956 {
957 messages::internalError(asyncResp->res);
958 }
959 },
960 "xyz.openbmc_project.Network",
961 "/xyz/openbmc_project/network/config",
962 "org.freedesktop.DBus.Properties", "Set",
963 "xyz.openbmc_project.Network.SystemConfiguration", "HostName",
Ed Tanousabf2add2019-01-22 16:40:12 -0800964 std::variant<std::string>(hostname));
Ed Tanous1abe55e2018-09-05 08:30:59 -0700965 }
966
Ratan Guptad5776652019-03-03 08:47:22 +0530967 void handleMACAddressPatch(const std::string &ifaceId,
968 const std::string &macAddress,
969 const std::shared_ptr<AsyncResp> &asyncResp)
970 {
971 crow::connections::systemBus->async_method_call(
972 [asyncResp, macAddress](const boost::system::error_code ec) {
973 if (ec)
974 {
975 messages::internalError(asyncResp->res);
976 return;
977 }
978 asyncResp->res.jsonValue["MACAddress"] = std::move(macAddress);
979 },
980 "xyz.openbmc_project.Network",
981 "/xyz/openbmc_project/network/" + ifaceId,
982 "org.freedesktop.DBus.Properties", "Set",
983 "xyz.openbmc_project.Network.MACAddress", "MACAddress",
984 std::variant<std::string>(macAddress));
985 }
986
Ed Tanous4a0cb852018-10-15 07:55:04 -0700987 void handleIPv4Patch(
Ratan Guptaf476acb2019-03-02 16:46:57 +0530988 const std::string &ifaceId, nlohmann::json &input,
Ed Tanous4a0cb852018-10-15 07:55:04 -0700989 const boost::container::flat_set<IPv4AddressData> &ipv4Data,
990 const std::shared_ptr<AsyncResp> asyncResp)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700991 {
Ratan Guptaf476acb2019-03-02 16:46:57 +0530992 if (!input.is_array())
993 {
994 messages::propertyValueTypeError(asyncResp->res, input.dump(),
995 "IPv4Addresses");
996 return;
997 }
998
Ed Tanous4a0cb852018-10-15 07:55:04 -0700999 int entryIdx = 0;
1000 boost::container::flat_set<IPv4AddressData>::const_iterator thisData =
1001 ipv4Data.begin();
Ed Tanous537174c2018-12-10 15:09:31 -08001002 for (nlohmann::json &thisJson : input)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001003 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001004 std::string pathString =
Jason M. Billsa08b46c2018-11-06 15:01:08 -08001005 "IPv4Addresses/" + std::to_string(entryIdx);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001006
Ratan Guptaf476acb2019-03-02 16:46:57 +05301007 if (thisJson.is_null())
1008 {
1009 if (thisData != ipv4Data.end())
1010 {
1011 deleteIPv4(ifaceId, thisData->id, entryIdx, asyncResp);
1012 thisData++;
1013 }
1014 else
1015 {
1016 messages::propertyValueFormatError(
1017 asyncResp->res, input.dump(), pathString);
1018 return;
1019 // TODO(ratagupt) Not sure about the property where value is
1020 // list and if unable to update one of the
1021 // list value then should we proceed further or
1022 // break there, would ask in the redfish forum
1023 // till then we stop processing the next list item.
1024 }
1025 entryIdx++;
1026 continue; // not an error as per the redfish spec.
1027 }
1028
Ratan Gupta9474b372019-03-01 15:13:37 +05301029 if (thisJson.empty())
1030 {
1031 if (thisData != ipv4Data.end())
1032 {
1033 thisData++;
1034 }
1035 else
1036 {
1037 messages::propertyMissing(asyncResp->res,
1038 pathString + "/Address");
1039 return;
Ratan Guptaf476acb2019-03-02 16:46:57 +05301040 // TODO(ratagupt) Not sure about the property where value is
Ratan Gupta9474b372019-03-01 15:13:37 +05301041 // list and if unable to update one of the
1042 // list value then should we proceed further or
1043 // break there, would ask in the redfish forum
1044 // till then we stop processing the next list item.
1045 }
1046 entryIdx++;
1047 continue; // not an error as per the redfish spec.
1048 }
1049
Ed Tanous537174c2018-12-10 15:09:31 -08001050 std::optional<std::string> address;
1051 std::optional<std::string> addressOrigin;
1052 std::optional<std::string> subnetMask;
1053 std::optional<std::string> gateway;
1054
1055 if (!json_util::readJson(thisJson, asyncResp->res, "Address",
1056 address, "AddressOrigin", addressOrigin,
1057 "SubnetMask", subnetMask, "Gateway",
1058 gateway))
1059 {
1060 return;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001061 }
1062
Ed Tanous537174c2018-12-10 15:09:31 -08001063 if (address)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001064 {
Ed Tanous537174c2018-12-10 15:09:31 -08001065 if (!ipv4VerifyIpAndGetBitcount(*address))
Ed Tanous1abe55e2018-09-05 08:30:59 -07001066 {
Ed Tanous537174c2018-12-10 15:09:31 -08001067 messages::propertyValueFormatError(asyncResp->res, *address,
Jason M. Billsa08b46c2018-11-06 15:01:08 -08001068 pathString + "/Address");
Ed Tanous537174c2018-12-10 15:09:31 -08001069 return;
Ed Tanous4a0cb852018-10-15 07:55:04 -07001070 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001071 }
Ed Tanous4a0cb852018-10-15 07:55:04 -07001072
Ed Tanous537174c2018-12-10 15:09:31 -08001073 uint8_t prefixLength = 0;
1074 if (subnetMask)
Ed Tanous4a0cb852018-10-15 07:55:04 -07001075 {
Ed Tanous537174c2018-12-10 15:09:31 -08001076 if (!ipv4VerifyIpAndGetBitcount(*subnetMask, &prefixLength))
Ed Tanous4a0cb852018-10-15 07:55:04 -07001077 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001078 messages::propertyValueFormatError(
Ed Tanous537174c2018-12-10 15:09:31 -08001079 asyncResp->res, *subnetMask,
Ed Tanous4a0cb852018-10-15 07:55:04 -07001080 pathString + "/SubnetMask");
Ed Tanous537174c2018-12-10 15:09:31 -08001081 return;
Ed Tanous4a0cb852018-10-15 07:55:04 -07001082 }
1083 }
Ed Tanous4a0cb852018-10-15 07:55:04 -07001084 std::string addressOriginInDBusFormat;
Ed Tanous537174c2018-12-10 15:09:31 -08001085 if (addressOrigin)
Ed Tanous4a0cb852018-10-15 07:55:04 -07001086 {
Ed Tanous537174c2018-12-10 15:09:31 -08001087 // Get Address origin in proper format
1088 addressOriginInDBusFormat =
1089 translateAddressOriginRedfishToDbus(*addressOrigin);
1090 if (addressOriginInDBusFormat.empty())
Ed Tanous4a0cb852018-10-15 07:55:04 -07001091 {
Ed Tanous537174c2018-12-10 15:09:31 -08001092 messages::propertyValueNotInList(
1093 asyncResp->res, *addressOrigin,
Ed Tanous4a0cb852018-10-15 07:55:04 -07001094 pathString + "/AddressOrigin");
Ed Tanous537174c2018-12-10 15:09:31 -08001095 return;
Ed Tanous4a0cb852018-10-15 07:55:04 -07001096 }
1097 }
1098
Ed Tanous537174c2018-12-10 15:09:31 -08001099 if (gateway)
Ed Tanous4a0cb852018-10-15 07:55:04 -07001100 {
Ed Tanous537174c2018-12-10 15:09:31 -08001101 if (!ipv4VerifyIpAndGetBitcount(*gateway))
Ed Tanous4a0cb852018-10-15 07:55:04 -07001102 {
Ed Tanous537174c2018-12-10 15:09:31 -08001103 messages::propertyValueFormatError(asyncResp->res, *gateway,
1104 pathString + "/Gateway");
1105 return;
Ed Tanous4a0cb852018-10-15 07:55:04 -07001106 }
1107 }
1108
Ratan Guptaf476acb2019-03-02 16:46:57 +05301109 // if IP address exist then modify it.
Ed Tanous4a0cb852018-10-15 07:55:04 -07001110 if (thisData != ipv4Data.end())
Ed Tanous1abe55e2018-09-05 08:30:59 -07001111 {
Ratan Guptaf476acb2019-03-02 16:46:57 +05301112 // Apply changes
1113 if (address)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001114 {
Ratan Guptaf476acb2019-03-02 16:46:57 +05301115 auto callback = [asyncResp, entryIdx,
1116 address{std::string(*address)}](
Ed Tanous4a0cb852018-10-15 07:55:04 -07001117 const boost::system::error_code ec) {
1118 if (ec)
1119 {
Jason M. Billsa08b46c2018-11-06 15:01:08 -08001120 messages::internalError(asyncResp->res);
Ed Tanous4a0cb852018-10-15 07:55:04 -07001121 return;
1122 }
Ratan Guptaf476acb2019-03-02 16:46:57 +05301123 asyncResp->res
1124 .jsonValue["IPv4Addresses"][entryIdx]["Address"] =
1125 std::move(address);
Ed Tanous4a0cb852018-10-15 07:55:04 -07001126 };
Ratan Guptaf476acb2019-03-02 16:46:57 +05301127
Ed Tanous4a0cb852018-10-15 07:55:04 -07001128 crow::connections::systemBus->async_method_call(
1129 std::move(callback), "xyz.openbmc_project.Network",
1130 "/xyz/openbmc_project/network/" + ifaceId + "/ipv4/" +
1131 thisData->id,
Ratan Guptaf476acb2019-03-02 16:46:57 +05301132 "org.freedesktop.DBus.Properties", "Set",
1133 "xyz.openbmc_project.Network.IP", "Address",
1134 std::variant<std::string>(*address));
Ed Tanous1abe55e2018-09-05 08:30:59 -07001135 }
Ratan Guptaf476acb2019-03-02 16:46:57 +05301136
1137 if (subnetMask)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001138 {
Ratan Guptaf476acb2019-03-02 16:46:57 +05301139 changeIPv4SubnetMaskProperty(ifaceId, entryIdx,
1140 thisData->id, *subnetMask,
1141 prefixLength, asyncResp);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001142 }
Ratan Guptaf476acb2019-03-02 16:46:57 +05301143
1144 if (addressOrigin)
1145 {
1146 changeIPv4Origin(ifaceId, entryIdx, thisData->id,
1147 *addressOrigin, addressOriginInDBusFormat,
1148 asyncResp);
1149 }
1150
1151 if (gateway)
1152 {
1153 auto callback = [asyncResp, entryIdx,
1154 gateway{std::string(*gateway)}](
1155 const boost::system::error_code ec) {
1156 if (ec)
1157 {
1158 messages::internalError(asyncResp->res);
1159 return;
1160 }
1161 asyncResp->res
1162 .jsonValue["IPv4Addresses"][entryIdx]["Gateway"] =
1163 std::move(gateway);
1164 };
1165
1166 crow::connections::systemBus->async_method_call(
1167 std::move(callback), "xyz.openbmc_project.Network",
1168 "/xyz/openbmc_project/network/" + ifaceId + "/ipv4/" +
1169 thisData->id,
1170 "org.freedesktop.DBus.Properties", "Set",
1171 "xyz.openbmc_project.Network.IP", "Gateway",
1172 std::variant<std::string>(*gateway));
1173 }
1174
Ed Tanous4a0cb852018-10-15 07:55:04 -07001175 thisData++;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001176 }
Ed Tanous4a0cb852018-10-15 07:55:04 -07001177 else
1178 {
1179 // Create IPv4 with provided data
Ed Tanous537174c2018-12-10 15:09:31 -08001180 if (!gateway)
Ed Tanous4a0cb852018-10-15 07:55:04 -07001181 {
Jason M. Billsa08b46c2018-11-06 15:01:08 -08001182 messages::propertyMissing(asyncResp->res,
Jason M. Billsf12894f2018-10-09 12:45:45 -07001183 pathString + "/Gateway");
Ed Tanous4a0cb852018-10-15 07:55:04 -07001184 continue;
1185 }
1186
Ed Tanous537174c2018-12-10 15:09:31 -08001187 if (!address)
Ed Tanous4a0cb852018-10-15 07:55:04 -07001188 {
Jason M. Billsa08b46c2018-11-06 15:01:08 -08001189 messages::propertyMissing(asyncResp->res,
Jason M. Billsf12894f2018-10-09 12:45:45 -07001190 pathString + "/Address");
Ed Tanous4a0cb852018-10-15 07:55:04 -07001191 continue;
1192 }
1193
Ed Tanous537174c2018-12-10 15:09:31 -08001194 if (!subnetMask)
Ed Tanous4a0cb852018-10-15 07:55:04 -07001195 {
Jason M. Billsa08b46c2018-11-06 15:01:08 -08001196 messages::propertyMissing(asyncResp->res,
Jason M. Billsf12894f2018-10-09 12:45:45 -07001197 pathString + "/SubnetMask");
Ed Tanous4a0cb852018-10-15 07:55:04 -07001198 continue;
1199 }
1200
Ed Tanous537174c2018-12-10 15:09:31 -08001201 createIPv4(ifaceId, entryIdx, prefixLength, *gateway, *address,
1202 asyncResp);
Ratan Gupta95897b22019-03-07 18:25:57 +05301203
1204 nlohmann::json &ipv4AddressJson =
1205 asyncResp->res.jsonValue["IPv4Addresses"][entryIdx];
1206 ipv4AddressJson["Address"] = *address;
1207 ipv4AddressJson["SubnetMask"] = *subnetMask;
1208 ipv4AddressJson["Gateway"] = *gateway;
Ed Tanous4a0cb852018-10-15 07:55:04 -07001209 }
1210 entryIdx++;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001211 }
1212 }
1213
Ed Tanous0f74e642018-11-12 15:17:05 -08001214 void parseInterfaceData(
1215 nlohmann::json &json_response, const std::string &iface_id,
1216 const EthernetInterfaceData &ethData,
Ed Tanous4a0cb852018-10-15 07:55:04 -07001217 const boost::container::flat_set<IPv4AddressData> &ipv4Data)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001218 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001219 json_response["Id"] = iface_id;
1220 json_response["@odata.id"] =
1221 "/redfish/v1/Managers/bmc/EthernetInterfaces/" + iface_id;
Ed Tanous029573d2019-02-01 10:57:49 -08001222 json_response["InterfaceEnabled"] = true;
1223 if (ethData.speed == 0)
1224 {
1225 json_response["LinkStatus"] = "NoLink";
1226 json_response["Status"] = {
1227 {"Health", "OK"},
1228 {"State", "Disabled"},
1229 };
1230 }
1231 else
1232 {
1233 json_response["LinkStatus"] = "LinkUp";
1234 json_response["Status"] = {
1235 {"Health", "OK"},
1236 {"State", "Enabled"},
1237 };
1238 }
Ed Tanous4a0cb852018-10-15 07:55:04 -07001239 json_response["SpeedMbps"] = ethData.speed;
1240 json_response["MACAddress"] = ethData.mac_address;
manojkiraneda2a133282019-02-19 13:09:43 +05301241 json_response["DHCPv4Configuration"]["DHCPEnabled"] =
1242 ethData.DHCPEnabled;
1243
Ed Tanous4a0cb852018-10-15 07:55:04 -07001244 if (!ethData.hostname.empty())
Ed Tanous1abe55e2018-09-05 08:30:59 -07001245 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001246 json_response["HostName"] = ethData.hostname;
1247 }
1248
1249 nlohmann::json &vlanObj = json_response["VLAN"];
1250 if (ethData.vlan_id)
1251 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001252 vlanObj["VLANEnable"] = true;
Ed Tanous4a0cb852018-10-15 07:55:04 -07001253 vlanObj["VLANId"] = *ethData.vlan_id;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001254 }
1255 else
1256 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001257 vlanObj["VLANEnable"] = false;
1258 vlanObj["VLANId"] = 0;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001259 }
Ed Tanous029573d2019-02-01 10:57:49 -08001260 json_response["NameServers"] = ethData.nameservers;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001261
Ed Tanous4a0cb852018-10-15 07:55:04 -07001262 if (ipv4Data.size() > 0)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001263 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001264 nlohmann::json &ipv4_array = json_response["IPv4Addresses"];
1265 ipv4_array = nlohmann::json::array();
1266 for (auto &ipv4_config : ipv4Data)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001267 {
Ed Tanous029573d2019-02-01 10:57:49 -08001268 ipv4_array.push_back({{"AddressOrigin", ipv4_config.origin},
1269 {"SubnetMask", ipv4_config.netmask},
1270 {"Address", ipv4_config.address},
1271 {"Gateway", ipv4_config.gateway}});
Ed Tanous1abe55e2018-09-05 08:30:59 -07001272 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001273 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001274 }
1275
1276 /**
1277 * Functions triggers appropriate requests on DBus
1278 */
1279 void doGet(crow::Response &res, const crow::Request &req,
1280 const std::vector<std::string> &params) override
1281 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001282 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001283 if (params.size() != 1)
1284 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001285 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001286 return;
1287 }
1288
Ed Tanous4a0cb852018-10-15 07:55:04 -07001289 getEthernetIfaceData(
1290 params[0],
1291 [this, asyncResp, iface_id{std::string(params[0])}](
1292 const bool &success, const EthernetInterfaceData &ethData,
1293 const boost::container::flat_set<IPv4AddressData> &ipv4Data) {
1294 if (!success)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001295 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001296 // TODO(Pawel)consider distinguish between non existing
1297 // object, and other errors
Jason M. Billsf12894f2018-10-09 12:45:45 -07001298 messages::resourceNotFound(asyncResp->res,
1299 "EthernetInterface", iface_id);
Ed Tanous4a0cb852018-10-15 07:55:04 -07001300 return;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001301 }
Ed Tanous0f74e642018-11-12 15:17:05 -08001302 asyncResp->res.jsonValue["@odata.type"] =
1303 "#EthernetInterface.v1_2_0.EthernetInterface";
1304 asyncResp->res.jsonValue["@odata.context"] =
1305 "/redfish/v1/$metadata#EthernetInterface.EthernetInterface";
1306 asyncResp->res.jsonValue["Name"] = "Manager Ethernet Interface";
1307 asyncResp->res.jsonValue["Description"] =
1308 "Management Network Interface";
1309
1310 parseInterfaceData(asyncResp->res.jsonValue, iface_id, ethData,
1311 ipv4Data);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001312 });
manojkiraneda2a133282019-02-19 13:09:43 +05301313 getDHCPConfigData(asyncResp);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001314 }
1315
1316 void doPatch(crow::Response &res, const crow::Request &req,
1317 const std::vector<std::string> &params) override
1318 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001319 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001320 if (params.size() != 1)
1321 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001322 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001323 return;
1324 }
1325
Ed Tanous4a0cb852018-10-15 07:55:04 -07001326 const std::string &iface_id = params[0];
Ed Tanous1abe55e2018-09-05 08:30:59 -07001327
Ed Tanous0627a2c2018-11-29 17:09:23 -08001328 std::optional<nlohmann::json> vlan;
Ed Tanousbc0bd6e2018-12-10 14:07:55 -08001329 std::optional<std::string> hostname;
Ratan Guptad5776652019-03-03 08:47:22 +05301330 std::optional<std::string> macAddress;
Ratan Guptaf476acb2019-03-02 16:46:57 +05301331 std::optional<nlohmann::json> ipv4Addresses;
1332 std::optional<nlohmann::json> ipv6Addresses;
Ed Tanous0627a2c2018-11-29 17:09:23 -08001333
1334 if (!json_util::readJson(req, res, "VLAN", vlan, "HostName", hostname,
1335 "IPv4Addresses", ipv4Addresses,
Ratan Guptad5776652019-03-03 08:47:22 +05301336 "IPv6Addresses", ipv6Addresses, "MACAddress",
1337 macAddress))
Ed Tanous1abe55e2018-09-05 08:30:59 -07001338 {
1339 return;
1340 }
Ratan Guptaf15aad32019-03-01 13:41:13 +05301341
1342 std::optional<uint64_t> vlanId;
1343 std::optional<bool> vlanEnable;
1344
Ed Tanous0627a2c2018-11-29 17:09:23 -08001345 if (vlan)
1346 {
1347 if (!json_util::readJson(*vlan, res, "VLANEnable", vlanEnable,
1348 "VLANId", vlanId))
1349 {
1350 return;
1351 }
1352 // Need both vlanId and vlanEnable to service this request
1353 if (static_cast<bool>(vlanId) ^ static_cast<bool>(vlanEnable))
1354 {
1355 if (vlanId)
1356 {
1357 messages::propertyMissing(asyncResp->res, "VLANEnable");
1358 }
1359 else
1360 {
1361 messages::propertyMissing(asyncResp->res, "VLANId");
1362 }
1363
1364 return;
1365 }
1366 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001367
Ed Tanous4a0cb852018-10-15 07:55:04 -07001368 // Get single eth interface data, and call the below callback for JSON
Ed Tanous1abe55e2018-09-05 08:30:59 -07001369 // preparation
Ed Tanous4a0cb852018-10-15 07:55:04 -07001370 getEthernetIfaceData(
1371 iface_id,
Ed Tanous0627a2c2018-11-29 17:09:23 -08001372 [this, asyncResp, iface_id, vlanId, vlanEnable,
Ratan Guptad5776652019-03-03 08:47:22 +05301373 hostname = std::move(hostname), macAddress = std::move(macAddress),
Ed Tanous0627a2c2018-11-29 17:09:23 -08001374 ipv4Addresses = std::move(ipv4Addresses),
1375 ipv6Addresses = std::move(ipv6Addresses)](
Ed Tanous4a0cb852018-10-15 07:55:04 -07001376 const bool &success, const EthernetInterfaceData &ethData,
1377 const boost::container::flat_set<IPv4AddressData> &ipv4Data) {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001378 if (!success)
1379 {
1380 // ... otherwise return error
1381 // TODO(Pawel)consider distinguish between non existing
1382 // object, and other errors
Jason M. Billsf12894f2018-10-09 12:45:45 -07001383 messages::resourceNotFound(
1384 asyncResp->res, "VLAN Network Interface", iface_id);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001385 return;
1386 }
1387
Ed Tanous0f74e642018-11-12 15:17:05 -08001388 parseInterfaceData(asyncResp->res.jsonValue, iface_id, ethData,
1389 ipv4Data);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001390
Ed Tanous0627a2c2018-11-29 17:09:23 -08001391 if (vlanId && vlanEnable)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001392 {
Ed Tanous0627a2c2018-11-29 17:09:23 -08001393 handleVlanPatch(iface_id, *vlanId, *vlanEnable, ethData,
1394 asyncResp);
1395 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001396
Ed Tanous0627a2c2018-11-29 17:09:23 -08001397 if (hostname)
1398 {
1399 handleHostnamePatch(*hostname, asyncResp);
1400 }
1401
Ratan Guptad5776652019-03-03 08:47:22 +05301402 if (macAddress)
1403 {
1404 handleMACAddressPatch(iface_id, *macAddress, asyncResp);
1405 }
1406
Ed Tanous0627a2c2018-11-29 17:09:23 -08001407 if (ipv4Addresses)
1408 {
Ed Tanous537174c2018-12-10 15:09:31 -08001409 // TODO(ed) for some reason the capture of ipv4Addresses
1410 // above is returning a const value, not a non-const value.
1411 // This doesn't really work for us, as we need to be able to
1412 // efficiently move out the intermedia nlohmann::json
1413 // objects. This makes a copy of the structure, and operates
1414 // on that, but could be done more efficiently
Ratan Guptaf476acb2019-03-02 16:46:57 +05301415 nlohmann::json ipv4 = std::move(*ipv4Addresses);
Ed Tanous537174c2018-12-10 15:09:31 -08001416 handleIPv4Patch(iface_id, ipv4, ipv4Data, asyncResp);
Ed Tanous0627a2c2018-11-29 17:09:23 -08001417 }
1418
1419 if (ipv6Addresses)
1420 {
1421 // TODO(kkowalsk) IPv6 Not supported on D-Bus yet
1422 messages::propertyNotWritable(asyncResp->res,
1423 "IPv6Addresses");
Ed Tanous1abe55e2018-09-05 08:30:59 -07001424 }
1425 });
1426 }
Rapkiewicz, Pawel9391bb92018-03-20 03:12:18 +01001427};
1428
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02001429/**
Ed Tanous4a0cb852018-10-15 07:55:04 -07001430 * VlanNetworkInterface derived class for delivering VLANNetworkInterface
1431 * Schema
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02001432 */
Ed Tanous1abe55e2018-09-05 08:30:59 -07001433class VlanNetworkInterface : public Node
1434{
1435 public:
1436 /*
1437 * Default Constructor
1438 */
1439 template <typename CrowApp>
Ed Tanous1abe55e2018-09-05 08:30:59 -07001440 VlanNetworkInterface(CrowApp &app) :
Ed Tanous4a0cb852018-10-15 07:55:04 -07001441 Node(app,
Ed Tanous0f74e642018-11-12 15:17:05 -08001442 "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/<str>",
Ed Tanous4a0cb852018-10-15 07:55:04 -07001443 std::string(), std::string())
Ed Tanous1abe55e2018-09-05 08:30:59 -07001444 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001445 entityPrivileges = {
1446 {boost::beast::http::verb::get, {{"Login"}}},
1447 {boost::beast::http::verb::head, {{"Login"}}},
1448 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
1449 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
1450 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
1451 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02001452 }
1453
Ed Tanous1abe55e2018-09-05 08:30:59 -07001454 private:
Ed Tanous0f74e642018-11-12 15:17:05 -08001455 void parseInterfaceData(
1456 nlohmann::json &json_response, const std::string &parent_iface_id,
1457 const std::string &iface_id, const EthernetInterfaceData &ethData,
Ed Tanous4a0cb852018-10-15 07:55:04 -07001458 const boost::container::flat_set<IPv4AddressData> &ipv4Data)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001459 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001460 // Fill out obvious data...
Ed Tanous4a0cb852018-10-15 07:55:04 -07001461 json_response["Id"] = iface_id;
1462 json_response["@odata.id"] =
1463 "/redfish/v1/Managers/bmc/EthernetInterfaces/" + parent_iface_id +
1464 "/VLANs/" + iface_id;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001465
Ed Tanous4a0cb852018-10-15 07:55:04 -07001466 json_response["VLANEnable"] = true;
1467 if (ethData.vlan_id)
1468 {
1469 json_response["VLANId"] = *ethData.vlan_id;
1470 }
Ed Tanousa434f2b2018-07-27 13:04:22 -07001471 }
1472
Ed Tanous1abe55e2018-09-05 08:30:59 -07001473 bool verifyNames(crow::Response &res, const std::string &parent,
1474 const std::string &iface)
1475 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001476 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001477 if (!boost::starts_with(iface, parent + "_"))
1478 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001479 messages::resourceNotFound(asyncResp->res, "VLAN Network Interface",
1480 iface);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001481 return false;
1482 }
1483 else
1484 {
1485 return true;
1486 }
1487 }
1488
1489 /**
1490 * Functions triggers appropriate requests on DBus
1491 */
1492 void doGet(crow::Response &res, const crow::Request &req,
1493 const std::vector<std::string> &params) override
1494 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001495 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
1496 // TODO(Pawel) this shall be parameterized call (two params) to get
Ed Tanous1abe55e2018-09-05 08:30:59 -07001497 // EthernetInterfaces for any Manager, not only hardcoded 'openbmc'.
1498 // Check if there is required param, truly entering this shall be
1499 // impossible.
1500 if (params.size() != 2)
1501 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001502 messages::internalError(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001503 res.end();
Kowalski, Kamil927a5052018-07-03 14:16:46 +02001504 return;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001505 }
Kowalski, Kamil927a5052018-07-03 14:16:46 +02001506
Ed Tanous4a0cb852018-10-15 07:55:04 -07001507 const std::string &parent_iface_id = params[0];
1508 const std::string &iface_id = params[1];
Ed Tanous0f74e642018-11-12 15:17:05 -08001509 res.jsonValue["@odata.type"] =
1510 "#VLanNetworkInterface.v1_1_0.VLanNetworkInterface";
1511 res.jsonValue["@odata.context"] =
1512 "/redfish/v1/$metadata#VLanNetworkInterface.VLanNetworkInterface";
1513 res.jsonValue["Name"] = "VLAN Network Interface";
Kowalski, Kamil927a5052018-07-03 14:16:46 +02001514
Ed Tanous4a0cb852018-10-15 07:55:04 -07001515 if (!verifyNames(res, parent_iface_id, iface_id))
Ed Tanous1abe55e2018-09-05 08:30:59 -07001516 {
1517 return;
1518 }
Kowalski, Kamil927a5052018-07-03 14:16:46 +02001519
Ed Tanous1abe55e2018-09-05 08:30:59 -07001520 // Get single eth interface data, and call the below callback for JSON
1521 // preparation
Ed Tanous4a0cb852018-10-15 07:55:04 -07001522 getEthernetIfaceData(
1523 iface_id,
1524 [this, asyncResp, parent_iface_id, iface_id](
1525 const bool &success, const EthernetInterfaceData &ethData,
1526 const boost::container::flat_set<IPv4AddressData> &ipv4Data) {
1527 if (success && ethData.vlan_id)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001528 {
Ed Tanous0f74e642018-11-12 15:17:05 -08001529 parseInterfaceData(asyncResp->res.jsonValue,
1530 parent_iface_id, iface_id, ethData,
1531 ipv4Data);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001532 }
1533 else
1534 {
1535 // ... otherwise return error
1536 // TODO(Pawel)consider distinguish between non existing
1537 // object, and other errors
Jason M. Billsf12894f2018-10-09 12:45:45 -07001538 messages::resourceNotFound(
1539 asyncResp->res, "VLAN Network Interface", iface_id);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001540 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001541 });
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02001542 }
1543
Ed Tanous1abe55e2018-09-05 08:30:59 -07001544 void doPatch(crow::Response &res, const crow::Request &req,
1545 const std::vector<std::string> &params) override
1546 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001547 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001548 if (params.size() != 2)
1549 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001550 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001551 return;
1552 }
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02001553
Ed Tanous1abe55e2018-09-05 08:30:59 -07001554 const std::string &parentIfaceId = params[0];
1555 const std::string &ifaceId = params[1];
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02001556
Ed Tanous1abe55e2018-09-05 08:30:59 -07001557 if (!verifyNames(res, parentIfaceId, ifaceId))
1558 {
1559 return;
1560 }
1561
Ed Tanous0627a2c2018-11-29 17:09:23 -08001562 bool vlanEnable = false;
1563 uint64_t vlanId = 0;
1564
1565 if (!json_util::readJson(req, res, "VLANEnable", vlanEnable, "VLANId",
1566 vlanId))
Ed Tanous1abe55e2018-09-05 08:30:59 -07001567 {
1568 return;
1569 }
1570
1571 // Get single eth interface data, and call the below callback for JSON
1572 // preparation
Ed Tanous4a0cb852018-10-15 07:55:04 -07001573 getEthernetIfaceData(
Ed Tanous1abe55e2018-09-05 08:30:59 -07001574 ifaceId,
Ed Tanous0627a2c2018-11-29 17:09:23 -08001575 [this, asyncResp, parentIfaceId, ifaceId, vlanEnable, vlanId](
Ed Tanous4a0cb852018-10-15 07:55:04 -07001576 const bool &success, const EthernetInterfaceData &ethData,
1577 const boost::container::flat_set<IPv4AddressData> &ipv4Data) {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001578 if (!success)
1579 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001580 // TODO(Pawel)consider distinguish between non existing
1581 // object, and other errors
Jason M. Billsf12894f2018-10-09 12:45:45 -07001582 messages::resourceNotFound(
1583 asyncResp->res, "VLAN Network Interface", ifaceId);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001584
1585 return;
1586 }
1587
Ed Tanous0f74e642018-11-12 15:17:05 -08001588 parseInterfaceData(asyncResp->res.jsonValue, parentIfaceId,
1589 ifaceId, ethData, ipv4Data);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001590
Ed Tanous0627a2c2018-11-29 17:09:23 -08001591 EthernetInterface::handleVlanPatch(ifaceId, vlanId, vlanEnable,
1592 ethData, asyncResp);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001593 });
1594 }
1595
1596 void doDelete(crow::Response &res, const crow::Request &req,
1597 const std::vector<std::string> &params) override
1598 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001599 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001600 if (params.size() != 2)
1601 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001602 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001603 return;
1604 }
1605
1606 const std::string &parentIfaceId = params[0];
1607 const std::string &ifaceId = params[1];
1608
Ed Tanous4a0cb852018-10-15 07:55:04 -07001609 if (!verifyNames(asyncResp->res, parentIfaceId, ifaceId))
Ed Tanous1abe55e2018-09-05 08:30:59 -07001610 {
1611 return;
1612 }
1613
1614 // Get single eth interface data, and call the below callback for JSON
1615 // preparation
Jason M. Billsf12894f2018-10-09 12:45:45 -07001616 getEthernetIfaceData(
1617 ifaceId,
1618 [this, asyncResp, parentIfaceId{std::string(parentIfaceId)},
1619 ifaceId{std::string(ifaceId)}](
1620 const bool &success, const EthernetInterfaceData &ethData,
1621 const boost::container::flat_set<IPv4AddressData> &ipv4Data) {
1622 if (success && ethData.vlan_id)
1623 {
Ed Tanous0f74e642018-11-12 15:17:05 -08001624 parseInterfaceData(asyncResp->res.jsonValue, parentIfaceId,
1625 ifaceId, ethData, ipv4Data);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001626
Jason M. Billsf12894f2018-10-09 12:45:45 -07001627 auto callback =
1628 [asyncResp](const boost::system::error_code ec) {
1629 if (ec)
1630 {
1631 messages::internalError(asyncResp->res);
1632 }
1633 };
1634 crow::connections::systemBus->async_method_call(
1635 std::move(callback), "xyz.openbmc_project.Network",
1636 std::string("/xyz/openbmc_project/network/") + ifaceId,
1637 "xyz.openbmc_project.Object.Delete", "Delete");
1638 }
1639 else
1640 {
1641 // ... otherwise return error
1642 // TODO(Pawel)consider distinguish between non existing
1643 // object, and other errors
1644 messages::resourceNotFound(
1645 asyncResp->res, "VLAN Network Interface", ifaceId);
1646 }
1647 });
Ed Tanous1abe55e2018-09-05 08:30:59 -07001648 }
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02001649};
1650
1651/**
1652 * VlanNetworkInterfaceCollection derived class for delivering
1653 * VLANNetworkInterface Collection Schema
1654 */
Ed Tanous1abe55e2018-09-05 08:30:59 -07001655class VlanNetworkInterfaceCollection : public Node
1656{
1657 public:
1658 template <typename CrowApp>
Ed Tanous1abe55e2018-09-05 08:30:59 -07001659 VlanNetworkInterfaceCollection(CrowApp &app) :
Ed Tanous4a0cb852018-10-15 07:55:04 -07001660 Node(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/",
1661 std::string())
Ed Tanous1abe55e2018-09-05 08:30:59 -07001662 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001663 entityPrivileges = {
1664 {boost::beast::http::verb::get, {{"Login"}}},
1665 {boost::beast::http::verb::head, {{"Login"}}},
1666 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
1667 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
1668 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
1669 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02001670 }
1671
Ed Tanous1abe55e2018-09-05 08:30:59 -07001672 private:
1673 /**
1674 * Functions triggers appropriate requests on DBus
1675 */
1676 void doGet(crow::Response &res, const crow::Request &req,
1677 const std::vector<std::string> &params) override
1678 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001679 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001680 if (params.size() != 1)
1681 {
1682 // This means there is a problem with the router
Jason M. Billsf12894f2018-10-09 12:45:45 -07001683 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001684 return;
Ed Tanous8ceb2ec2018-08-13 11:11:56 -07001685 }
1686
Ed Tanous4a0cb852018-10-15 07:55:04 -07001687 const std::string &rootInterfaceName = params[0];
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02001688
Ed Tanous4a0cb852018-10-15 07:55:04 -07001689 // Get eth interface list, and call the below callback for JSON
Ed Tanous1abe55e2018-09-05 08:30:59 -07001690 // preparation
Jason M. Billsf12894f2018-10-09 12:45:45 -07001691 getEthernetIfaceList(
Ed Tanous43b761d2019-02-13 20:10:56 -08001692 [asyncResp, rootInterfaceName{std::string(rootInterfaceName)}](
Jason M. Billsf12894f2018-10-09 12:45:45 -07001693 const bool &success,
1694 const std::vector<std::string> &iface_list) {
1695 if (!success)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001696 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001697 messages::internalError(asyncResp->res);
1698 return;
Ed Tanous1abe55e2018-09-05 08:30:59 -07001699 }
Ed Tanous0f74e642018-11-12 15:17:05 -08001700 asyncResp->res.jsonValue["@odata.type"] =
1701 "#VLanNetworkInterfaceCollection."
1702 "VLanNetworkInterfaceCollection";
1703 asyncResp->res.jsonValue["@odata.context"] =
1704 "/redfish/v1/$metadata"
1705 "#VLanNetworkInterfaceCollection."
1706 "VLanNetworkInterfaceCollection";
1707 asyncResp->res.jsonValue["Name"] =
1708 "VLAN Network Interface Collection";
Ed Tanous4a0cb852018-10-15 07:55:04 -07001709
Jason M. Billsf12894f2018-10-09 12:45:45 -07001710 nlohmann::json iface_array = nlohmann::json::array();
1711
1712 for (const std::string &iface_item : iface_list)
1713 {
1714 if (boost::starts_with(iface_item, rootInterfaceName + "_"))
1715 {
1716 iface_array.push_back(
1717 {{"@odata.id",
1718 "/redfish/v1/Managers/bmc/EthernetInterfaces/" +
1719 rootInterfaceName + "/VLANs/" + iface_item}});
1720 }
1721 }
1722
1723 if (iface_array.empty())
1724 {
1725 messages::resourceNotFound(
1726 asyncResp->res, "EthernetInterface", rootInterfaceName);
1727 return;
1728 }
1729 asyncResp->res.jsonValue["Members@odata.count"] =
1730 iface_array.size();
1731 asyncResp->res.jsonValue["Members"] = std::move(iface_array);
1732 asyncResp->res.jsonValue["@odata.id"] =
1733 "/redfish/v1/Managers/bmc/EthernetInterfaces/" +
1734 rootInterfaceName + "/VLANs";
1735 });
Ed Tanous1abe55e2018-09-05 08:30:59 -07001736 }
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02001737
Ed Tanous1abe55e2018-09-05 08:30:59 -07001738 void doPost(crow::Response &res, const crow::Request &req,
1739 const std::vector<std::string> &params) override
1740 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001741 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001742 if (params.size() != 1)
1743 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001744 messages::internalError(asyncResp->res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001745 return;
1746 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001747
Ed Tanous0627a2c2018-11-29 17:09:23 -08001748 uint32_t vlanId = 0;
1749 if (!json_util::readJson(req, res, "VLANId", vlanId))
Ed Tanous1abe55e2018-09-05 08:30:59 -07001750 {
Ed Tanous4a0cb852018-10-15 07:55:04 -07001751 return;
1752 }
1753 const std::string &rootInterfaceName = params[0];
Ed Tanous4a0cb852018-10-15 07:55:04 -07001754 auto callback = [asyncResp](const boost::system::error_code ec) {
1755 if (ec)
1756 {
1757 // TODO(ed) make more consistent error messages based on
1758 // phosphor-network responses
Jason M. Billsf12894f2018-10-09 12:45:45 -07001759 messages::internalError(asyncResp->res);
Ed Tanous4a0cb852018-10-15 07:55:04 -07001760 return;
1761 }
Jason M. Billsf12894f2018-10-09 12:45:45 -07001762 messages::created(asyncResp->res);
Ed Tanous4a0cb852018-10-15 07:55:04 -07001763 };
1764 crow::connections::systemBus->async_method_call(
1765 std::move(callback), "xyz.openbmc_project.Network",
1766 "/xyz/openbmc_project/network",
1767 "xyz.openbmc_project.Network.VLAN.Create", "VLAN",
Ed Tanous0627a2c2018-11-29 17:09:23 -08001768 rootInterfaceName, vlanId);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001769 }
Kowalski, Kamile439f0f2018-05-21 08:13:57 +02001770};
Ed Tanous1abe55e2018-09-05 08:30:59 -07001771} // namespace redfish