1 /*
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
18 #include "app.hpp"
19 #include "dbus_singleton.hpp"
20 #include "dbus_utility.hpp"
21 #include "error_messages.hpp"
22 #include "human_sort.hpp"
23 #include "query.hpp"
24 #include "registries/privilege_registry.hpp"
25 #include "utils/ip_utils.hpp"
26 #include "utils/json_utils.hpp"
27
28 #include <boost/system/error_code.hpp>
29 #include <boost/url/format.hpp>
30
31 #include <array>
32 #include <cstddef>
33 #include <memory>
34 #include <optional>
35 #include <ranges>
36 #include <regex>
37 #include <string_view>
38 #include <variant>
39 #include <vector>
40
41 namespace redfish
42 {
43
44 enum class LinkType
45 {
46 Local,
47 Global
48 };
49
50 enum class IpVersion
51 {
52 IpV4,
53 IpV6
54 };
55
56 /**
57 * Structure for keeping IPv4 data required by Redfish
58 */
59 struct IPv4AddressData
60 {
61 std::string id;
62 std::string address;
63 std::string domain;
64 std::string gateway;
65 std::string netmask;
66 std::string origin;
67 LinkType linktype{};
68 bool isActive{};
69 };
70
71 /**
72 * Structure for keeping IPv6 data required by Redfish
73 */
74 struct IPv6AddressData
75 {
76 std::string id;
77 std::string address;
78 std::string origin;
79 uint8_t prefixLength = 0;
80 };
81
82 /**
83 * Structure for keeping static route data required by Redfish
84 */
85 struct StaticGatewayData
86 {
87 std::string id;
88 std::string gateway;
89 size_t prefixLength = 0;
90 std::string protocol;
91 };
92
93 /**
94 * Structure for keeping basic single Ethernet Interface information
95 * available from DBus
96 */
97 struct EthernetInterfaceData
98 {
99 uint32_t speed;
100 size_t mtuSize;
101 bool autoNeg;
102 bool dnsv4Enabled;
103 bool dnsv6Enabled;
104 bool domainv4Enabled;
105 bool domainv6Enabled;
106 bool ntpv4Enabled;
107 bool ntpv6Enabled;
108 bool hostNamev4Enabled;
109 bool hostNamev6Enabled;
110 bool linkUp;
111 bool nicEnabled;
112 bool ipv6AcceptRa;
113 std::string dhcpEnabled;
114 std::string operatingMode;
115 std::string hostName;
116 std::string defaultGateway;
117 std::string ipv6DefaultGateway;
118 std::string ipv6StaticDefaultGateway;
119 std::string macAddress;
120 std::optional<uint32_t> vlanId;
121 std::vector<std::string> nameServers;
122 std::vector<std::string> staticNameServers;
123 std::vector<std::string> domainnames;
124 };
125
126 struct DHCPParameters
127 {
128 std::optional<bool> dhcpv4Enabled;
129 std::optional<bool> useDnsServers;
130 std::optional<bool> useNtpServers;
131 std::optional<bool> useDomainName;
132 std::optional<std::string> dhcpv6OperatingMode;
133 };
134
135 // Helper function that changes bits netmask notation (i.e. /24)
136 // into full dot notation
getNetmask(unsigned int bits)137 inline std::string getNetmask(unsigned int bits)
138 {
139 uint32_t value = 0xffffffff << (32 - bits);
140 std::string netmask = std::to_string((value >> 24) & 0xff) + "." +
141 std::to_string((value >> 16) & 0xff) + "." +
142 std::to_string((value >> 8) & 0xff) + "." +
143 std::to_string(value & 0xff);
144 return netmask;
145 }
146
translateDhcpEnabledToBool(const std::string & inputDHCP,bool isIPv4)147 inline bool translateDhcpEnabledToBool(const std::string& inputDHCP,
148 bool isIPv4)
149 {
150 if (isIPv4)
151 {
152 return (
153 (inputDHCP ==
154 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v4") ||
155 (inputDHCP ==
156 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.both"));
157 }
158 return ((inputDHCP ==
159 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v6") ||
160 (inputDHCP ==
161 "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.both"));
162 }
163
getDhcpEnabledEnumeration(bool isIPv4,bool isIPv6)164 inline std::string getDhcpEnabledEnumeration(bool isIPv4, bool isIPv6)
165 {
166 if (isIPv4 && isIPv6)
167 {
168 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.both";
169 }
170 if (isIPv4)
171 {
172 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v4";
173 }
174 if (isIPv6)
175 {
176 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.v6";
177 }
178 return "xyz.openbmc_project.Network.EthernetInterface.DHCPConf.none";
179 }
180
181 inline std::string
translateAddressOriginDbusToRedfish(const std::string & inputOrigin,bool isIPv4)182 translateAddressOriginDbusToRedfish(const std::string& inputOrigin,
183 bool isIPv4)
184 {
185 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.Static")
186 {
187 return "Static";
188 }
189 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.LinkLocal")
190 {
191 if (isIPv4)
192 {
193 return "IPv4LinkLocal";
194 }
195 return "LinkLocal";
196 }
197 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.DHCP")
198 {
199 if (isIPv4)
200 {
201 return "DHCP";
202 }
203 return "DHCPv6";
204 }
205 if (inputOrigin == "xyz.openbmc_project.Network.IP.AddressOrigin.SLAAC")
206 {
207 return "SLAAC";
208 }
209 return "";
210 }
211
extractEthernetInterfaceData(const std::string & ethifaceId,const dbus::utility::ManagedObjectType & dbusData,EthernetInterfaceData & ethData)212 inline bool extractEthernetInterfaceData(
213 const std::string& ethifaceId,
214 const dbus::utility::ManagedObjectType& dbusData,
215 EthernetInterfaceData& ethData)
216 {
217 bool idFound = false;
218 for (const auto& objpath : dbusData)
219 {
220 for (const auto& ifacePair : objpath.second)
221 {
222 if (objpath.first == "/xyz/openbmc_project/network/" + ethifaceId)
223 {
224 idFound = true;
225 if (ifacePair.first == "xyz.openbmc_project.Network.MACAddress")
226 {
227 for (const auto& propertyPair : ifacePair.second)
228 {
229 if (propertyPair.first == "MACAddress")
230 {
231 const std::string* mac =
232 std::get_if<std::string>(&propertyPair.second);
233 if (mac != nullptr)
234 {
235 ethData.macAddress = *mac;
236 }
237 }
238 }
239 }
240 else if (ifacePair.first == "xyz.openbmc_project.Network.VLAN")
241 {
242 for (const auto& propertyPair : ifacePair.second)
243 {
244 if (propertyPair.first == "Id")
245 {
246 const uint32_t* id =
247 std::get_if<uint32_t>(&propertyPair.second);
248 if (id != nullptr)
249 {
250 ethData.vlanId = *id;
251 }
252 }
253 }
254 }
255 else if (ifacePair.first ==
256 "xyz.openbmc_project.Network.EthernetInterface")
257 {
258 for (const auto& propertyPair : ifacePair.second)
259 {
260 if (propertyPair.first == "AutoNeg")
261 {
262 const bool* autoNeg =
263 std::get_if<bool>(&propertyPair.second);
264 if (autoNeg != nullptr)
265 {
266 ethData.autoNeg = *autoNeg;
267 }
268 }
269 else if (propertyPair.first == "Speed")
270 {
271 const uint32_t* speed =
272 std::get_if<uint32_t>(&propertyPair.second);
273 if (speed != nullptr)
274 {
275 ethData.speed = *speed;
276 }
277 }
278 else if (propertyPair.first == "MTU")
279 {
280 const size_t* mtuSize =
281 std::get_if<size_t>(&propertyPair.second);
282 if (mtuSize != nullptr)
283 {
284 ethData.mtuSize = *mtuSize;
285 }
286 }
287 else if (propertyPair.first == "LinkUp")
288 {
289 const bool* linkUp =
290 std::get_if<bool>(&propertyPair.second);
291 if (linkUp != nullptr)
292 {
293 ethData.linkUp = *linkUp;
294 }
295 }
296 else if (propertyPair.first == "NICEnabled")
297 {
298 const bool* nicEnabled =
299 std::get_if<bool>(&propertyPair.second);
300 if (nicEnabled != nullptr)
301 {
302 ethData.nicEnabled = *nicEnabled;
303 }
304 }
305 else if (propertyPair.first == "IPv6AcceptRA")
306 {
307 const bool* ipv6AcceptRa =
308 std::get_if<bool>(&propertyPair.second);
309 if (ipv6AcceptRa != nullptr)
310 {
311 ethData.ipv6AcceptRa = *ipv6AcceptRa;
312 }
313 }
314 else if (propertyPair.first == "Nameservers")
315 {
316 const std::vector<std::string>* nameservers =
317 std::get_if<std::vector<std::string>>(
318 &propertyPair.second);
319 if (nameservers != nullptr)
320 {
321 ethData.nameServers = *nameservers;
322 }
323 }
324 else if (propertyPair.first == "StaticNameServers")
325 {
326 const std::vector<std::string>* staticNameServers =
327 std::get_if<std::vector<std::string>>(
328 &propertyPair.second);
329 if (staticNameServers != nullptr)
330 {
331 ethData.staticNameServers = *staticNameServers;
332 }
333 }
334 else if (propertyPair.first == "DHCPEnabled")
335 {
336 const std::string* dhcpEnabled =
337 std::get_if<std::string>(&propertyPair.second);
338 if (dhcpEnabled != nullptr)
339 {
340 ethData.dhcpEnabled = *dhcpEnabled;
341 }
342 }
343 else if (propertyPair.first == "DomainName")
344 {
345 const std::vector<std::string>* domainNames =
346 std::get_if<std::vector<std::string>>(
347 &propertyPair.second);
348 if (domainNames != nullptr)
349 {
350 ethData.domainnames = *domainNames;
351 }
352 }
353 else if (propertyPair.first == "DefaultGateway")
354 {
355 const std::string* defaultGateway =
356 std::get_if<std::string>(&propertyPair.second);
357 if (defaultGateway != nullptr)
358 {
359 std::string defaultGatewayStr = *defaultGateway;
360 if (defaultGatewayStr.empty())
361 {
362 ethData.defaultGateway = "0.0.0.0";
363 }
364 else
365 {
366 ethData.defaultGateway = defaultGatewayStr;
367 }
368 }
369 }
370 else if (propertyPair.first == "DefaultGateway6")
371 {
372 const std::string* defaultGateway6 =
373 std::get_if<std::string>(&propertyPair.second);
374 if (defaultGateway6 != nullptr)
375 {
376 std::string defaultGateway6Str =
377 *defaultGateway6;
378 if (defaultGateway6Str.empty())
379 {
380 ethData.ipv6DefaultGateway =
381 "0:0:0:0:0:0:0:0";
382 }
383 else
384 {
385 ethData.ipv6DefaultGateway =
386 defaultGateway6Str;
387 }
388 }
389 }
390 }
391 }
392 }
393
394 sdbusplus::message::object_path path(
395 "/xyz/openbmc_project/network");
396 sdbusplus::message::object_path dhcp4Path = path / ethifaceId /
397 "dhcp4";
398
399 if (sdbusplus::message::object_path(objpath.first) == dhcp4Path)
400 {
401 if (ifacePair.first ==
402 "xyz.openbmc_project.Network.DHCPConfiguration")
403 {
404 for (const auto& propertyPair : ifacePair.second)
405 {
406 if (propertyPair.first == "DNSEnabled")
407 {
408 const bool* dnsEnabled =
409 std::get_if<bool>(&propertyPair.second);
410 if (dnsEnabled != nullptr)
411 {
412 ethData.dnsv4Enabled = *dnsEnabled;
413 }
414 }
415 else if (propertyPair.first == "DomainEnabled")
416 {
417 const bool* domainEnabled =
418 std::get_if<bool>(&propertyPair.second);
419 if (domainEnabled != nullptr)
420 {
421 ethData.domainv4Enabled = *domainEnabled;
422 }
423 }
424 else if (propertyPair.first == "NTPEnabled")
425 {
426 const bool* ntpEnabled =
427 std::get_if<bool>(&propertyPair.second);
428 if (ntpEnabled != nullptr)
429 {
430 ethData.ntpv4Enabled = *ntpEnabled;
431 }
432 }
433 else if (propertyPair.first == "HostNameEnabled")
434 {
435 const bool* hostNameEnabled =
436 std::get_if<bool>(&propertyPair.second);
437 if (hostNameEnabled != nullptr)
438 {
439 ethData.hostNamev4Enabled = *hostNameEnabled;
440 }
441 }
442 }
443 }
444 }
445
446 sdbusplus::message::object_path dhcp6Path = path / ethifaceId /
447 "dhcp6";
448
449 if (sdbusplus::message::object_path(objpath.first) == dhcp6Path)
450 {
451 if (ifacePair.first ==
452 "xyz.openbmc_project.Network.DHCPConfiguration")
453 {
454 for (const auto& propertyPair : ifacePair.second)
455 {
456 if (propertyPair.first == "DNSEnabled")
457 {
458 const bool* dnsEnabled =
459 std::get_if<bool>(&propertyPair.second);
460 if (dnsEnabled != nullptr)
461 {
462 ethData.dnsv6Enabled = *dnsEnabled;
463 }
464 }
465 if (propertyPair.first == "DomainEnabled")
466 {
467 const bool* domainEnabled =
468 std::get_if<bool>(&propertyPair.second);
469 if (domainEnabled != nullptr)
470 {
471 ethData.domainv6Enabled = *domainEnabled;
472 }
473 }
474 else if (propertyPair.first == "NTPEnabled")
475 {
476 const bool* ntpEnabled =
477 std::get_if<bool>(&propertyPair.second);
478 if (ntpEnabled != nullptr)
479 {
480 ethData.ntpv6Enabled = *ntpEnabled;
481 }
482 }
483 else if (propertyPair.first == "HostNameEnabled")
484 {
485 const bool* hostNameEnabled =
486 std::get_if<bool>(&propertyPair.second);
487 if (hostNameEnabled != nullptr)
488 {
489 ethData.hostNamev6Enabled = *hostNameEnabled;
490 }
491 }
492 }
493 }
494 }
495 // System configuration shows up in the global namespace, so no need
496 // to check eth number
497 if (ifacePair.first ==
498 "xyz.openbmc_project.Network.SystemConfiguration")
499 {
500 for (const auto& propertyPair : ifacePair.second)
501 {
502 if (propertyPair.first == "HostName")
503 {
504 const std::string* hostname =
505 std::get_if<std::string>(&propertyPair.second);
506 if (hostname != nullptr)
507 {
508 ethData.hostName = *hostname;
509 }
510 }
511 }
512 }
513 }
514 }
515 return idFound;
516 }
517
518 // Helper function that extracts data for single ethernet ipv6 address
extractIPV6Data(const std::string & ethifaceId,const dbus::utility::ManagedObjectType & dbusData,std::vector<IPv6AddressData> & ipv6Config)519 inline void extractIPV6Data(const std::string& ethifaceId,
520 const dbus::utility::ManagedObjectType& dbusData,
521 std::vector<IPv6AddressData>& ipv6Config)
522 {
523 const std::string ipPathStart = "/xyz/openbmc_project/network/" +
524 ethifaceId;
525
526 // Since there might be several IPv6 configurations aligned with
527 // single ethernet interface, loop over all of them
528 for (const auto& objpath : dbusData)
529 {
530 // Check if proper pattern for object path appears
531 if (objpath.first.str.starts_with(ipPathStart + "/"))
532 {
533 for (const auto& interface : objpath.second)
534 {
535 if (interface.first == "xyz.openbmc_project.Network.IP")
536 {
537 auto type = std::ranges::find_if(interface.second,
538 [](const auto& property) {
539 return property.first == "Type";
540 });
541 if (type == interface.second.end())
542 {
543 continue;
544 }
545
546 const std::string* typeStr =
547 std::get_if<std::string>(&type->second);
548
549 if (typeStr == nullptr ||
550 (*typeStr !=
551 "xyz.openbmc_project.Network.IP.Protocol.IPv6"))
552 {
553 continue;
554 }
555
556 // Instance IPv6AddressData structure, and set as
557 // appropriate
558 IPv6AddressData& ipv6Address = ipv6Config.emplace_back();
559 ipv6Address.id =
560 objpath.first.str.substr(ipPathStart.size());
561 for (const auto& property : interface.second)
562 {
563 if (property.first == "Address")
564 {
565 const std::string* address =
566 std::get_if<std::string>(&property.second);
567 if (address != nullptr)
568 {
569 ipv6Address.address = *address;
570 }
571 }
572 else if (property.first == "Origin")
573 {
574 const std::string* origin =
575 std::get_if<std::string>(&property.second);
576 if (origin != nullptr)
577 {
578 ipv6Address.origin =
579 translateAddressOriginDbusToRedfish(*origin,
580 false);
581 }
582 }
583 else if (property.first == "PrefixLength")
584 {
585 const uint8_t* prefix =
586 std::get_if<uint8_t>(&property.second);
587 if (prefix != nullptr)
588 {
589 ipv6Address.prefixLength = *prefix;
590 }
591 }
592 else if (property.first == "Type" ||
593 property.first == "Gateway")
594 {
595 // Type & Gateway is not used
596 }
597 else
598 {
599 BMCWEB_LOG_ERROR(
600 "Got extra property: {} on the {} object",
601 property.first, objpath.first.str);
602 }
603 }
604 }
605 }
606 }
607 }
608 }
609
610 // Helper function that extracts data for single ethernet ipv4 address
extractIPData(const std::string & ethifaceId,const dbus::utility::ManagedObjectType & dbusData,std::vector<IPv4AddressData> & ipv4Config)611 inline void extractIPData(const std::string& ethifaceId,
612 const dbus::utility::ManagedObjectType& dbusData,
613 std::vector<IPv4AddressData>& ipv4Config)
614 {
615 const std::string ipPathStart = "/xyz/openbmc_project/network/" +
616 ethifaceId;
617
618 // Since there might be several IPv4 configurations aligned with
619 // single ethernet interface, loop over all of them
620 for (const auto& objpath : dbusData)
621 {
622 // Check if proper pattern for object path appears
623 if (objpath.first.str.starts_with(ipPathStart + "/"))
624 {
625 for (const auto& interface : objpath.second)
626 {
627 if (interface.first == "xyz.openbmc_project.Network.IP")
628 {
629 auto type = std::ranges::find_if(interface.second,
630 [](const auto& property) {
631 return property.first == "Type";
632 });
633 if (type == interface.second.end())
634 {
635 continue;
636 }
637
638 const std::string* typeStr =
639 std::get_if<std::string>(&type->second);
640
641 if (typeStr == nullptr ||
642 (*typeStr !=
643 "xyz.openbmc_project.Network.IP.Protocol.IPv4"))
644 {
645 continue;
646 }
647
648 // Instance IPv4AddressData structure, and set as
649 // appropriate
650 IPv4AddressData& ipv4Address = ipv4Config.emplace_back();
651 ipv4Address.id =
652 objpath.first.str.substr(ipPathStart.size());
653 for (const auto& property : interface.second)
654 {
655 if (property.first == "Address")
656 {
657 const std::string* address =
658 std::get_if<std::string>(&property.second);
659 if (address != nullptr)
660 {
661 ipv4Address.address = *address;
662 }
663 }
664 else if (property.first == "Origin")
665 {
666 const std::string* origin =
667 std::get_if<std::string>(&property.second);
668 if (origin != nullptr)
669 {
670 ipv4Address.origin =
671 translateAddressOriginDbusToRedfish(*origin,
672 true);
673 }
674 }
675 else if (property.first == "PrefixLength")
676 {
677 const uint8_t* mask =
678 std::get_if<uint8_t>(&property.second);
679 if (mask != nullptr)
680 {
681 // convert it to the string
682 ipv4Address.netmask = getNetmask(*mask);
683 }
684 }
685 else if (property.first == "Type" ||
686 property.first == "Gateway")
687 {
688 // Type & Gateway is not used
689 }
690 else
691 {
692 BMCWEB_LOG_ERROR(
693 "Got extra property: {} on the {} object",
694 property.first, objpath.first.str);
695 }
696 }
697 // Check if given address is local, or global
698 ipv4Address.linktype =
699 ipv4Address.address.starts_with("169.254.")
700 ? LinkType::Local
701 : LinkType::Global;
702 }
703 }
704 }
705 }
706 }
707
708 /**
709 * @brief Modifies the default gateway assigned to the NIC
710 *
711 * @param[in] ifaceId Id of network interface whose default gateway is to be
712 * changed
713 * @param[in] gateway The new gateway value. Assigning an empty string
714 * causes the gateway to be deleted
715 * @param[io] asyncResp Response object that will be returned to client
716 *
717 * @return None
718 */
updateIPv4DefaultGateway(const std::string & ifaceId,const std::string & gateway,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)719 inline void updateIPv4DefaultGateway(
720 const std::string& ifaceId, const std::string& gateway,
721 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
722 {
723 setDbusProperty(
724 asyncResp, "Gateway", "xyz.openbmc_project.Network",
725 sdbusplus::message::object_path("/xyz/openbmc_project/network") /
726 ifaceId,
727 "xyz.openbmc_project.Network.EthernetInterface", "DefaultGateway",
728 gateway);
729 }
730
731 /**
732 * @brief Deletes given static IP address for the interface
733 *
734 * @param[in] ifaceId Id of interface whose IP should be deleted
735 * @param[in] ipHash DBus Hash id of IP that should be deleted
736 * @param[io] asyncResp Response object that will be returned to client
737 *
738 * @return None
739 */
deleteIPAddress(const std::string & ifaceId,const std::string & ipHash,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)740 inline void deleteIPAddress(const std::string& ifaceId,
741 const std::string& ipHash,
742 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
743 {
744 crow::connections::systemBus->async_method_call(
745 [asyncResp](const boost::system::error_code& ec) {
746 if (ec)
747 {
748 messages::internalError(asyncResp->res);
749 }
750 },
751 "xyz.openbmc_project.Network",
752 "/xyz/openbmc_project/network/" + ifaceId + ipHash,
753 "xyz.openbmc_project.Object.Delete", "Delete");
754 }
755
756 /**
757 * @brief Creates a static IPv4 entry
758 *
759 * @param[in] ifaceId Id of interface upon which to create the IPv4 entry
760 * @param[in] prefixLength IPv4 prefix syntax for the subnet mask
761 * @param[in] gateway IPv4 address of this interfaces gateway
762 * @param[in] address IPv4 address to assign to this interface
763 * @param[io] asyncResp Response object that will be returned to client
764 *
765 * @return None
766 */
createIPv4(const std::string & ifaceId,uint8_t prefixLength,const std::string & gateway,const std::string & address,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)767 inline void createIPv4(const std::string& ifaceId, uint8_t prefixLength,
768 const std::string& gateway, const std::string& address,
769 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
770 {
771 auto createIpHandler = [asyncResp, ifaceId,
772 gateway](const boost::system::error_code& ec) {
773 if (ec)
774 {
775 messages::internalError(asyncResp->res);
776 return;
777 }
778 };
779
780 crow::connections::systemBus->async_method_call(
781 std::move(createIpHandler), "xyz.openbmc_project.Network",
782 "/xyz/openbmc_project/network/" + ifaceId,
783 "xyz.openbmc_project.Network.IP.Create", "IP",
784 "xyz.openbmc_project.Network.IP.Protocol.IPv4", address, prefixLength,
785 gateway);
786 }
787
788 /**
789 * @brief Deletes the IP entry for this interface and creates a replacement
790 * static entry
791 *
792 * @param[in] ifaceId Id of interface upon which to create the IPv6 entry
793 * @param[in] id The unique hash entry identifying the DBus entry
794 * @param[in] prefixLength Prefix syntax for the subnet mask
795 * @param[in] address Address to assign to this interface
796 * @param[in] numStaticAddrs Count of IPv4 static addresses
797 * @param[io] asyncResp Response object that will be returned to client
798 *
799 * @return None
800 */
801
deleteAndCreateIPAddress(IpVersion version,const std::string & ifaceId,const std::string & id,uint8_t prefixLength,const std::string & address,const std::string & gateway,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)802 inline void deleteAndCreateIPAddress(
803 IpVersion version, const std::string& ifaceId, const std::string& id,
804 uint8_t prefixLength, const std::string& address,
805 const std::string& gateway,
806 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
807 {
808 crow::connections::systemBus->async_method_call(
809 [asyncResp, version, ifaceId, address, prefixLength,
810 gateway](const boost::system::error_code& ec) {
811 if (ec)
812 {
813 messages::internalError(asyncResp->res);
814 }
815 std::string protocol = "xyz.openbmc_project.Network.IP.Protocol.";
816 protocol += version == IpVersion::IpV4 ? "IPv4" : "IPv6";
817 crow::connections::systemBus->async_method_call(
818 [asyncResp](const boost::system::error_code& ec2) {
819 if (ec2)
820 {
821 messages::internalError(asyncResp->res);
822 }
823 },
824 "xyz.openbmc_project.Network",
825 "/xyz/openbmc_project/network/" + ifaceId,
826 "xyz.openbmc_project.Network.IP.Create", "IP", protocol, address,
827 prefixLength, gateway);
828 },
829 "xyz.openbmc_project.Network",
830 "/xyz/openbmc_project/network/" + ifaceId + id,
831 "xyz.openbmc_project.Object.Delete", "Delete");
832 }
833
extractIPv6DefaultGatewayData(const std::string & ethifaceId,const dbus::utility::ManagedObjectType & dbusData,std::vector<StaticGatewayData> & staticGatewayConfig)834 inline bool extractIPv6DefaultGatewayData(
835 const std::string& ethifaceId,
836 const dbus::utility::ManagedObjectType& dbusData,
837 std::vector<StaticGatewayData>& staticGatewayConfig)
838 {
839 std::string staticGatewayPathStart("/xyz/openbmc_project/network/");
840 staticGatewayPathStart += ethifaceId;
841
842 for (const auto& objpath : dbusData)
843 {
844 if (!std::string_view(objpath.first.str)
845 .starts_with(staticGatewayPathStart))
846 {
847 continue;
848 }
849 for (const auto& interface : objpath.second)
850 {
851 if (interface.first != "xyz.openbmc_project.Network.StaticGateway")
852 {
853 continue;
854 }
855 StaticGatewayData& staticGateway =
856 staticGatewayConfig.emplace_back();
857 staticGateway.id = objpath.first.filename();
858
859 bool success = sdbusplus::unpackPropertiesNoThrow(
860 redfish::dbus_utils::UnpackErrorPrinter(), interface.second,
861 "Gateway", staticGateway.gateway, "PrefixLength",
862 staticGateway.prefixLength, "ProtocolType",
863 staticGateway.protocol);
864 if (!success)
865 {
866 return false;
867 }
868 }
869 }
870 return true;
871 }
872
873 /**
874 * @brief Creates IPv6 with given data
875 *
876 * @param[in] ifaceId Id of interface whose IP should be added
877 * @param[in] prefixLength Prefix length that needs to be added
878 * @param[in] address IP address that needs to be added
879 * @param[io] asyncResp Response object that will be returned to client
880 *
881 * @return None
882 */
createIPv6(const std::string & ifaceId,uint8_t prefixLength,const std::string & address,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)883 inline void createIPv6(const std::string& ifaceId, uint8_t prefixLength,
884 const std::string& address,
885 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
886 {
887 sdbusplus::message::object_path path("/xyz/openbmc_project/network");
888 path /= ifaceId;
889
890 auto createIpHandler = [asyncResp,
891 address](const boost::system::error_code& ec) {
892 if (ec)
893 {
894 if (ec == boost::system::errc::io_error)
895 {
896 messages::propertyValueFormatError(asyncResp->res, address,
897 "Address");
898 }
899 else
900 {
901 messages::internalError(asyncResp->res);
902 }
903 }
904 };
905 // Passing null for gateway, as per redfish spec IPv6StaticAddresses
906 // object does not have associated gateway property
907 crow::connections::systemBus->async_method_call(
908 std::move(createIpHandler), "xyz.openbmc_project.Network", path,
909 "xyz.openbmc_project.Network.IP.Create", "IP",
910 "xyz.openbmc_project.Network.IP.Protocol.IPv6", address, prefixLength,
911 "");
912 }
913
914 /**
915 * @brief Deletes given IPv6 Static Gateway
916 *
917 * @param[in] ifaceId Id of interface whose IP should be deleted
918 * @param[in] ipHash DBus Hash id of IP that should be deleted
919 * @param[io] asyncResp Response object that will be returned to client
920 *
921 * @return None
922 */
923 inline void
deleteIPv6Gateway(std::string_view gatewayId,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)924 deleteIPv6Gateway(std::string_view gatewayId,
925 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
926 {
927 sdbusplus::message::object_path path("/xyz/openbmc_project/network");
928 path /= gatewayId;
929 crow::connections::systemBus->async_method_call(
930 [asyncResp](const boost::system::error_code& ec) {
931 if (ec)
932 {
933 messages::internalError(asyncResp->res);
934 }
935 },
936 "xyz.openbmc_project.Network", path,
937 "xyz.openbmc_project.Object.Delete", "Delete");
938 }
939
940 /**
941 * @brief Creates IPv6 static default gateway with given data
942 *
943 * @param[in] ifaceId Id of interface whose IP should be added
944 * @param[in] prefixLength Prefix length that needs to be added
945 * @param[in] gateway Gateway address that needs to be added
946 * @param[io] asyncResp Response object that will be returned to client
947 *
948 * @return None
949 */
createIPv6DefaultGateway(std::string_view ifaceId,size_t prefixLength,std::string_view gateway,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)950 inline void createIPv6DefaultGateway(
951 std::string_view ifaceId, size_t prefixLength, std::string_view gateway,
952 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
953 {
954 sdbusplus::message::object_path path("/xyz/openbmc_project/network");
955 path /= ifaceId;
956 auto createIpHandler = [asyncResp](const boost::system::error_code& ec) {
957 if (ec)
958 {
959 messages::internalError(asyncResp->res);
960 }
961 };
962 crow::connections::systemBus->async_method_call(
963 std::move(createIpHandler), "xyz.openbmc_project.Network", path,
964 "xyz.openbmc_project.Network.StaticGateway.Create", "StaticGateway",
965 gateway, prefixLength, "xyz.openbmc_project.Network.IP.Protocol.IPv6");
966 }
967
968 /**
969 * @brief Deletes the IPv6 default gateway entry for this interface and
970 * creates a replacement IPv6 default gateway entry
971 *
972 * @param[in] ifaceId Id of interface upon which to create the IPv6
973 * entry
974 * @param[in] gateway IPv6 gateway to assign to this interface
975 * @param[in] prefixLength IPv6 prefix syntax for the subnet mask
976 * @param[io] asyncResp Response object that will be returned to client
977 *
978 * @return None
979 */
deleteAndCreateIPv6DefaultGateway(std::string_view ifaceId,std::string_view gatewayId,std::string_view gateway,size_t prefixLength,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)980 inline void deleteAndCreateIPv6DefaultGateway(
981 std::string_view ifaceId, std::string_view gatewayId,
982 std::string_view gateway, size_t prefixLength,
983 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
984 {
985 sdbusplus::message::object_path path("/xyz/openbmc_project/network");
986 path /= gatewayId;
987 crow::connections::systemBus->async_method_call(
988 [asyncResp, ifaceId, gateway,
989 prefixLength](const boost::system::error_code& ec) {
990 if (ec)
991 {
992 messages::internalError(asyncResp->res);
993 return;
994 }
995 createIPv6DefaultGateway(ifaceId, prefixLength, gateway, asyncResp);
996 },
997 "xyz.openbmc_project.Network", path,
998 "xyz.openbmc_project.Object.Delete", "Delete");
999 }
1000
1001 /**
1002 * @brief Sets IPv6 default gateway with given data
1003 *
1004 * @param[in] ifaceId Id of interface whose gateway should be added
1005 * @param[in] input Contains address that needs to be added
1006 * @param[in] staticGatewayData Current static gateways in the system
1007 * @param[io] asyncResp Response object that will be returned to client
1008 *
1009 * @return None
1010 */
1011
handleIPv6DefaultGateway(const std::string & ifaceId,std::vector<std::variant<nlohmann::json::object_t,std::nullptr_t>> & input,const std::vector<StaticGatewayData> & staticGatewayData,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)1012 inline void handleIPv6DefaultGateway(
1013 const std::string& ifaceId,
1014 std::vector<std::variant<nlohmann::json::object_t, std::nullptr_t>>& input,
1015 const std::vector<StaticGatewayData>& staticGatewayData,
1016 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1017 {
1018 size_t entryIdx = 1;
1019 std::vector<StaticGatewayData>::const_iterator staticGatewayEntry =
1020 staticGatewayData.begin();
1021
1022 for (std::variant<nlohmann::json::object_t, std::nullptr_t>& thisJson :
1023 input)
1024 {
1025 // find the next gateway entry
1026 while (staticGatewayEntry != staticGatewayData.end())
1027 {
1028 if (staticGatewayEntry->protocol ==
1029 "xyz.openbmc_project.Network.IP.Protocol.IPv6")
1030 {
1031 break;
1032 }
1033 staticGatewayEntry++;
1034 }
1035 std::string pathString = "IPv6StaticDefaultGateways/" +
1036 std::to_string(entryIdx);
1037 nlohmann::json::object_t* obj =
1038 std::get_if<nlohmann::json::object_t>(&thisJson);
1039 if (obj == nullptr)
1040 {
1041 if (staticGatewayEntry == staticGatewayData.end())
1042 {
1043 messages::resourceCannotBeDeleted(asyncResp->res);
1044 return;
1045 }
1046 deleteIPv6Gateway(staticGatewayEntry->id, asyncResp);
1047 return;
1048 }
1049 if (obj->empty())
1050 {
1051 // Do nothing, but make sure the entry exists.
1052 if (staticGatewayEntry == staticGatewayData.end())
1053 {
1054 messages::propertyValueFormatError(asyncResp->res, *obj,
1055 pathString);
1056 return;
1057 }
1058 }
1059 std::optional<std::string> address;
1060 std::optional<size_t> prefixLength;
1061
1062 if (!json_util::readJsonObject(*obj, asyncResp->res, "Address", address,
1063 "PrefixLength", prefixLength))
1064 {
1065 return;
1066 }
1067 const std::string* addr = nullptr;
1068 size_t prefix = 0;
1069 if (address)
1070 {
1071 addr = &(*address);
1072 }
1073 else if (staticGatewayEntry != staticGatewayData.end())
1074 {
1075 addr = &(staticGatewayEntry->gateway);
1076 }
1077 else
1078 {
1079 messages::propertyMissing(asyncResp->res, pathString + "/Address");
1080 return;
1081 }
1082 if (prefixLength)
1083 {
1084 prefix = *prefixLength;
1085 }
1086 else if (staticGatewayEntry != staticGatewayData.end())
1087 {
1088 prefix = staticGatewayEntry->prefixLength;
1089 }
1090 else
1091 {
1092 messages::propertyMissing(asyncResp->res,
1093 pathString + "/PrefixLength");
1094 return;
1095 }
1096 if (staticGatewayEntry != staticGatewayData.end())
1097 {
1098 deleteAndCreateIPv6DefaultGateway(ifaceId, staticGatewayEntry->id,
1099 *addr, prefix, asyncResp);
1100 staticGatewayEntry++;
1101 }
1102 else
1103 {
1104 createIPv6DefaultGateway(ifaceId, prefix, *addr, asyncResp);
1105 }
1106 entryIdx++;
1107 }
1108 }
1109
1110 /**
1111 * Function that retrieves all properties for given Ethernet Interface
1112 * Object
1113 * from EntityManager Network Manager
1114 * @param ethiface_id a eth interface id to query on DBus
1115 * @param callback a function that shall be called to convert Dbus output
1116 * into JSON
1117 */
1118 template <typename CallbackFunc>
getEthernetIfaceData(const std::string & ethifaceId,CallbackFunc && callback)1119 void getEthernetIfaceData(const std::string& ethifaceId,
1120 CallbackFunc&& callback)
1121 {
1122 sdbusplus::message::object_path path("/xyz/openbmc_project/network");
1123 dbus::utility::getManagedObjects(
1124 "xyz.openbmc_project.Network", path,
1125 [ethifaceId{std::string{ethifaceId}},
1126 callback = std::forward<CallbackFunc>(callback)](
1127 const boost::system::error_code& ec,
1128 const dbus::utility::ManagedObjectType& resp) mutable {
1129 EthernetInterfaceData ethData{};
1130 std::vector<IPv4AddressData> ipv4Data;
1131 std::vector<IPv6AddressData> ipv6Data;
1132 std::vector<StaticGatewayData> ipv6GatewayData;
1133
1134 if (ec)
1135 {
1136 callback(false, ethData, ipv4Data, ipv6Data, ipv6GatewayData);
1137 return;
1138 }
1139
1140 bool found = extractEthernetInterfaceData(ethifaceId, resp, ethData);
1141 if (!found)
1142 {
1143 callback(false, ethData, ipv4Data, ipv6Data, ipv6GatewayData);
1144 return;
1145 }
1146
1147 extractIPData(ethifaceId, resp, ipv4Data);
1148 // Fix global GW
1149 for (IPv4AddressData& ipv4 : ipv4Data)
1150 {
1151 if (((ipv4.linktype == LinkType::Global) &&
1152 (ipv4.gateway == "0.0.0.0")) ||
1153 (ipv4.origin == "DHCP") || (ipv4.origin == "Static"))
1154 {
1155 ipv4.gateway = ethData.defaultGateway;
1156 }
1157 }
1158
1159 extractIPV6Data(ethifaceId, resp, ipv6Data);
1160 if (!extractIPv6DefaultGatewayData(ethifaceId, resp, ipv6GatewayData))
1161 {
1162 callback(false, ethData, ipv4Data, ipv6Data, ipv6GatewayData);
1163 }
1164 // Finally make a callback with useful data
1165 callback(true, ethData, ipv4Data, ipv6Data, ipv6GatewayData);
1166 });
1167 }
1168
1169 /**
1170 * Function that retrieves all Ethernet Interfaces available through Network
1171 * Manager
1172 * @param callback a function that shall be called to convert Dbus output
1173 * into JSON.
1174 */
1175 template <typename CallbackFunc>
getEthernetIfaceList(CallbackFunc && callback)1176 void getEthernetIfaceList(CallbackFunc&& callback)
1177 {
1178 sdbusplus::message::object_path path("/xyz/openbmc_project/network");
1179 dbus::utility::getManagedObjects(
1180 "xyz.openbmc_project.Network", path,
1181 [callback = std::forward<CallbackFunc>(callback)](
1182 const boost::system::error_code& ec,
1183 const dbus::utility::ManagedObjectType& resp) {
1184 // Callback requires vector<string> to retrieve all available
1185 // ethernet interfaces
1186 std::vector<std::string> ifaceList;
1187 ifaceList.reserve(resp.size());
1188 if (ec)
1189 {
1190 callback(false, ifaceList);
1191 return;
1192 }
1193
1194 // Iterate over all retrieved ObjectPaths.
1195 for (const auto& objpath : resp)
1196 {
1197 // And all interfaces available for certain ObjectPath.
1198 for (const auto& interface : objpath.second)
1199 {
1200 // If interface is
1201 // xyz.openbmc_project.Network.EthernetInterface, this is
1202 // what we're looking for.
1203 if (interface.first ==
1204 "xyz.openbmc_project.Network.EthernetInterface")
1205 {
1206 std::string ifaceId = objpath.first.filename();
1207 if (ifaceId.empty())
1208 {
1209 continue;
1210 }
1211 // and put it into output vector.
1212 ifaceList.emplace_back(ifaceId);
1213 }
1214 }
1215 }
1216
1217 std::ranges::sort(ifaceList, AlphanumLess<std::string>());
1218
1219 // Finally make a callback with useful data
1220 callback(true, ifaceList);
1221 });
1222 }
1223
1224 inline void
handleHostnamePatch(const std::string & hostname,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)1225 handleHostnamePatch(const std::string& hostname,
1226 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1227 {
1228 // SHOULD handle host names of up to 255 characters(RFC 1123)
1229 if (hostname.length() > 255)
1230 {
1231 messages::propertyValueFormatError(asyncResp->res, hostname,
1232 "HostName");
1233 return;
1234 }
1235 setDbusProperty(
1236 asyncResp, "HostName", "xyz.openbmc_project.Network",
1237 sdbusplus::message::object_path("/xyz/openbmc_project/network/config"),
1238 "xyz.openbmc_project.Network.SystemConfiguration", "HostName",
1239 hostname);
1240 }
1241
1242 inline void
handleMTUSizePatch(const std::string & ifaceId,const size_t mtuSize,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)1243 handleMTUSizePatch(const std::string& ifaceId, const size_t mtuSize,
1244 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1245 {
1246 sdbusplus::message::object_path objPath("/xyz/openbmc_project/network");
1247 objPath /= ifaceId;
1248 setDbusProperty(asyncResp, "MTUSize", "xyz.openbmc_project.Network",
1249 objPath, "xyz.openbmc_project.Network.EthernetInterface",
1250 "MTU", mtuSize);
1251 }
1252
1253 inline void
handleDomainnamePatch(const std::string & ifaceId,const std::string & domainname,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)1254 handleDomainnamePatch(const std::string& ifaceId,
1255 const std::string& domainname,
1256 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1257 {
1258 std::vector<std::string> vectorDomainname = {domainname};
1259 setDbusProperty(
1260 asyncResp, "FQDN", "xyz.openbmc_project.Network",
1261 sdbusplus::message::object_path("/xyz/openbmc_project/network") /
1262 ifaceId,
1263 "xyz.openbmc_project.Network.EthernetInterface", "DomainName",
1264 vectorDomainname);
1265 }
1266
isHostnameValid(const std::string & hostname)1267 inline bool isHostnameValid(const std::string& hostname)
1268 {
1269 // A valid host name can never have the dotted-decimal form (RFC 1123)
1270 if (std::ranges::all_of(hostname, ::isdigit))
1271 {
1272 return false;
1273 }
1274 // Each label(hostname/subdomains) within a valid FQDN
1275 // MUST handle host names of up to 63 characters (RFC 1123)
1276 // labels cannot start or end with hyphens (RFC 952)
1277 // labels can start with numbers (RFC 1123)
1278 const static std::regex pattern(
1279 "^[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]{0,61}[a-zA-Z0-9]$");
1280
1281 return std::regex_match(hostname, pattern);
1282 }
1283
isDomainnameValid(const std::string & domainname)1284 inline bool isDomainnameValid(const std::string& domainname)
1285 {
1286 // Can have multiple subdomains
1287 // Top Level Domain's min length is 2 character
1288 const static std::regex pattern(
1289 "^([A-Za-z0-9][a-zA-Z0-9\\-]{1,61}|[a-zA-Z0-9]{1,30}\\.)*[a-zA-Z]{2,}$");
1290
1291 return std::regex_match(domainname, pattern);
1292 }
1293
handleFqdnPatch(const std::string & ifaceId,const std::string & fqdn,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)1294 inline void handleFqdnPatch(const std::string& ifaceId, const std::string& fqdn,
1295 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1296 {
1297 // Total length of FQDN must not exceed 255 characters(RFC 1035)
1298 if (fqdn.length() > 255)
1299 {
1300 messages::propertyValueFormatError(asyncResp->res, fqdn, "FQDN");
1301 return;
1302 }
1303
1304 size_t pos = fqdn.find('.');
1305 if (pos == std::string::npos)
1306 {
1307 messages::propertyValueFormatError(asyncResp->res, fqdn, "FQDN");
1308 return;
1309 }
1310
1311 std::string hostname;
1312 std::string domainname;
1313 domainname = (fqdn).substr(pos + 1);
1314 hostname = (fqdn).substr(0, pos);
1315
1316 if (!isHostnameValid(hostname) || !isDomainnameValid(domainname))
1317 {
1318 messages::propertyValueFormatError(asyncResp->res, fqdn, "FQDN");
1319 return;
1320 }
1321
1322 handleHostnamePatch(hostname, asyncResp);
1323 handleDomainnamePatch(ifaceId, domainname, asyncResp);
1324 }
1325
1326 inline void
handleMACAddressPatch(const std::string & ifaceId,const std::string & macAddress,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)1327 handleMACAddressPatch(const std::string& ifaceId,
1328 const std::string& macAddress,
1329 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1330 {
1331 setDbusProperty(
1332 asyncResp, "MACAddress", "xyz.openbmc_project.Network",
1333 sdbusplus::message::object_path("/xyz/openbmc_project/network") /
1334 ifaceId,
1335 "xyz.openbmc_project.Network.MACAddress", "MACAddress", macAddress);
1336 }
1337
setDHCPEnabled(const std::string & ifaceId,const std::string & propertyName,const bool v4Value,const bool v6Value,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)1338 inline void setDHCPEnabled(const std::string& ifaceId,
1339 const std::string& propertyName, const bool v4Value,
1340 const bool v6Value,
1341 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1342 {
1343 const std::string dhcp = getDhcpEnabledEnumeration(v4Value, v6Value);
1344 setDbusProperty(
1345 asyncResp, "DHCPv4", "xyz.openbmc_project.Network",
1346 sdbusplus::message::object_path("/xyz/openbmc_project/network") /
1347 ifaceId,
1348 "xyz.openbmc_project.Network.EthernetInterface", propertyName, dhcp);
1349 }
1350
1351 enum class NetworkType
1352 {
1353 dhcp4,
1354 dhcp6
1355 };
1356
setDHCPConfig(const std::string & propertyName,const bool & value,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & ethifaceId,NetworkType type)1357 inline void setDHCPConfig(const std::string& propertyName, const bool& value,
1358 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1359 const std::string& ethifaceId, NetworkType type)
1360 {
1361 BMCWEB_LOG_DEBUG("{} = {}", propertyName, value);
1362 std::string redfishPropertyName;
1363 sdbusplus::message::object_path path("/xyz/openbmc_project/network/");
1364 path /= ethifaceId;
1365
1366 if (type == NetworkType::dhcp4)
1367 {
1368 path /= "dhcp4";
1369 redfishPropertyName = "DHCPv4";
1370 }
1371 else
1372 {
1373 path /= "dhcp6";
1374 redfishPropertyName = "DHCPv6";
1375 }
1376
1377 setDbusProperty(
1378 asyncResp, redfishPropertyName, "xyz.openbmc_project.Network", path,
1379 "xyz.openbmc_project.Network.DHCPConfiguration", propertyName, value);
1380 }
1381
handleSLAACAutoConfigPatch(const std::string & ifaceId,bool ipv6AutoConfigEnabled,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)1382 inline void handleSLAACAutoConfigPatch(
1383 const std::string& ifaceId, bool ipv6AutoConfigEnabled,
1384 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1385 {
1386 sdbusplus::message::object_path path("/xyz/openbmc_project/network");
1387 path /= ifaceId;
1388 setDbusProperty(asyncResp,
1389 "StatelessAddressAutoConfig/IPv6AutoConfigEnabled",
1390 "xyz.openbmc_project.Network", path,
1391 "xyz.openbmc_project.Network.EthernetInterface",
1392 "IPv6AcceptRA", ipv6AutoConfigEnabled);
1393 }
1394
handleDHCPPatch(const std::string & ifaceId,const EthernetInterfaceData & ethData,const DHCPParameters & v4dhcpParms,const DHCPParameters & v6dhcpParms,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)1395 inline void handleDHCPPatch(const std::string& ifaceId,
1396 const EthernetInterfaceData& ethData,
1397 const DHCPParameters& v4dhcpParms,
1398 const DHCPParameters& v6dhcpParms,
1399 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1400 {
1401 bool ipv4Active = translateDhcpEnabledToBool(ethData.dhcpEnabled, true);
1402 bool ipv6Active = translateDhcpEnabledToBool(ethData.dhcpEnabled, false);
1403
1404 if (ipv4Active)
1405 {
1406 updateIPv4DefaultGateway(ifaceId, "", asyncResp);
1407 }
1408 bool nextv4DHCPState =
1409 v4dhcpParms.dhcpv4Enabled ? *v4dhcpParms.dhcpv4Enabled : ipv4Active;
1410
1411 bool nextv6DHCPState{};
1412 if (v6dhcpParms.dhcpv6OperatingMode)
1413 {
1414 if ((*v6dhcpParms.dhcpv6OperatingMode != "Enabled") &&
1415 (*v6dhcpParms.dhcpv6OperatingMode != "Disabled"))
1416 {
1417 messages::propertyValueFormatError(asyncResp->res,
1418 *v6dhcpParms.dhcpv6OperatingMode,
1419 "OperatingMode");
1420 return;
1421 }
1422 nextv6DHCPState = (*v6dhcpParms.dhcpv6OperatingMode == "Enabled");
1423 }
1424 else
1425 {
1426 nextv6DHCPState = ipv6Active;
1427 }
1428
1429 bool nextDNSv4 = ethData.dnsv4Enabled;
1430 bool nextDNSv6 = ethData.dnsv6Enabled;
1431 if (v4dhcpParms.useDnsServers)
1432 {
1433 nextDNSv4 = *v4dhcpParms.useDnsServers;
1434 }
1435 if (v6dhcpParms.useDnsServers)
1436 {
1437 nextDNSv6 = *v6dhcpParms.useDnsServers;
1438 }
1439
1440 bool nextNTPv4 = ethData.ntpv4Enabled;
1441 bool nextNTPv6 = ethData.ntpv6Enabled;
1442 if (v4dhcpParms.useNtpServers)
1443 {
1444 nextNTPv4 = *v4dhcpParms.useNtpServers;
1445 }
1446 if (v6dhcpParms.useNtpServers)
1447 {
1448 nextNTPv6 = *v6dhcpParms.useNtpServers;
1449 }
1450
1451 bool nextUsev4Domain = ethData.domainv4Enabled;
1452 bool nextUsev6Domain = ethData.domainv6Enabled;
1453 if (v4dhcpParms.useDomainName)
1454 {
1455 nextUsev4Domain = *v4dhcpParms.useDomainName;
1456 }
1457 if (v6dhcpParms.useDomainName)
1458 {
1459 nextUsev6Domain = *v6dhcpParms.useDomainName;
1460 }
1461
1462 BMCWEB_LOG_DEBUG("set DHCPEnabled...");
1463 setDHCPEnabled(ifaceId, "DHCPEnabled", nextv4DHCPState, nextv6DHCPState,
1464 asyncResp);
1465 BMCWEB_LOG_DEBUG("set DNSEnabled...");
1466 setDHCPConfig("DNSEnabled", nextDNSv4, asyncResp, ifaceId,
1467 NetworkType::dhcp4);
1468 BMCWEB_LOG_DEBUG("set NTPEnabled...");
1469 setDHCPConfig("NTPEnabled", nextNTPv4, asyncResp, ifaceId,
1470 NetworkType::dhcp4);
1471 BMCWEB_LOG_DEBUG("set DomainEnabled...");
1472 setDHCPConfig("DomainEnabled", nextUsev4Domain, asyncResp, ifaceId,
1473 NetworkType::dhcp4);
1474 BMCWEB_LOG_DEBUG("set DNSEnabled for dhcp6...");
1475 setDHCPConfig("DNSEnabled", nextDNSv6, asyncResp, ifaceId,
1476 NetworkType::dhcp6);
1477 BMCWEB_LOG_DEBUG("set NTPEnabled for dhcp6...");
1478 setDHCPConfig("NTPEnabled", nextNTPv6, asyncResp, ifaceId,
1479 NetworkType::dhcp6);
1480 BMCWEB_LOG_DEBUG("set DomainEnabled for dhcp6...");
1481 setDHCPConfig("DomainEnabled", nextUsev6Domain, asyncResp, ifaceId,
1482 NetworkType::dhcp6);
1483 }
1484
getNextStaticIpEntry(const std::vector<IPv4AddressData>::const_iterator & head,const std::vector<IPv4AddressData>::const_iterator & end)1485 inline std::vector<IPv4AddressData>::const_iterator getNextStaticIpEntry(
1486 const std::vector<IPv4AddressData>::const_iterator& head,
1487 const std::vector<IPv4AddressData>::const_iterator& end)
1488 {
1489 return std::find_if(head, end, [](const IPv4AddressData& value) {
1490 return value.origin == "Static";
1491 });
1492 }
1493
getNextStaticIpEntry(const std::vector<IPv6AddressData>::const_iterator & head,const std::vector<IPv6AddressData>::const_iterator & end)1494 inline std::vector<IPv6AddressData>::const_iterator getNextStaticIpEntry(
1495 const std::vector<IPv6AddressData>::const_iterator& head,
1496 const std::vector<IPv6AddressData>::const_iterator& end)
1497 {
1498 return std::find_if(head, end, [](const IPv6AddressData& value) {
1499 return value.origin == "Static";
1500 });
1501 }
1502
handleIPv4StaticPatch(const std::string & ifaceId,std::vector<std::variant<nlohmann::json::object_t,std::nullptr_t>> & input,const EthernetInterfaceData & ethData,const std::vector<IPv4AddressData> & ipv4Data,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)1503 inline void handleIPv4StaticPatch(
1504 const std::string& ifaceId,
1505 std::vector<std::variant<nlohmann::json::object_t, std::nullptr_t>>& input,
1506 const EthernetInterfaceData& ethData,
1507 const std::vector<IPv4AddressData>& ipv4Data,
1508 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1509 {
1510 unsigned entryIdx = 1;
1511 // Find the first static IP address currently active on the NIC and
1512 // match it to the first JSON element in the IPv4StaticAddresses array.
1513 // Match each subsequent JSON element to the next static IP programmed
1514 // into the NIC.
1515 std::vector<IPv4AddressData>::const_iterator nicIpEntry =
1516 getNextStaticIpEntry(ipv4Data.cbegin(), ipv4Data.cend());
1517
1518 bool gatewayValueAssigned{};
1519 bool preserveGateway{};
1520 std::string activePath{};
1521 std::string activeGateway{};
1522 if (!ethData.defaultGateway.empty() && ethData.defaultGateway != "0.0.0.0")
1523 {
1524 // The NIC is already configured with a default gateway. Use this if
1525 // the leading entry in the PATCH is '{}', which is preserving an active
1526 // static address.
1527 activeGateway = ethData.defaultGateway;
1528 activePath = "IPv4StaticAddresses/1";
1529 gatewayValueAssigned = true;
1530 }
1531
1532 for (std::variant<nlohmann::json::object_t, std::nullptr_t>& thisJson :
1533 input)
1534 {
1535 std::string pathString = "IPv4StaticAddresses/" +
1536 std::to_string(entryIdx);
1537 nlohmann::json::object_t* obj =
1538 std::get_if<nlohmann::json::object_t>(&thisJson);
1539 if (obj == nullptr)
1540 {
1541 if (nicIpEntry != ipv4Data.cend())
1542 {
1543 deleteIPAddress(ifaceId, nicIpEntry->id, asyncResp);
1544 nicIpEntry = getNextStaticIpEntry(++nicIpEntry,
1545 ipv4Data.cend());
1546 if (!preserveGateway && (nicIpEntry == ipv4Data.cend()))
1547 {
1548 // All entries have been processed, and this last has
1549 // requested the IP address be deleted. No prior entry
1550 // performed an action that created or modified a
1551 // gateway. Deleting this IP address means the default
1552 // gateway entry has to be removed as well.
1553 updateIPv4DefaultGateway(ifaceId, "", asyncResp);
1554 }
1555 entryIdx++;
1556 continue;
1557 }
1558 // Received a DELETE action on an entry not assigned to the NIC
1559 messages::resourceCannotBeDeleted(asyncResp->res);
1560 return;
1561 }
1562
1563 // An Add/Modify action is requested
1564 if (!obj->empty())
1565 {
1566 std::optional<std::string> address;
1567 std::optional<std::string> subnetMask;
1568 std::optional<std::string> gateway;
1569
1570 if (!json_util::readJsonObject(*obj, asyncResp->res, "Address",
1571 address, "SubnetMask", subnetMask,
1572 "Gateway", gateway))
1573 {
1574 messages::propertyValueFormatError(asyncResp->res, *obj,
1575 pathString);
1576 return;
1577 }
1578
1579 // Find the address/subnet/gateway values. Any values that are
1580 // not explicitly provided are assumed to be unmodified from the
1581 // current state of the interface. Merge existing state into the
1582 // current request.
1583 if (address)
1584 {
1585 if (!ip_util::ipv4VerifyIpAndGetBitcount(*address))
1586 {
1587 messages::propertyValueFormatError(asyncResp->res, *address,
1588 pathString + "/Address");
1589 return;
1590 }
1591 }
1592 else if (nicIpEntry != ipv4Data.cend())
1593 {
1594 address = (nicIpEntry->address);
1595 }
1596 else
1597 {
1598 messages::propertyMissing(asyncResp->res,
1599 pathString + "/Address");
1600 return;
1601 }
1602
1603 uint8_t prefixLength = 0;
1604 if (subnetMask)
1605 {
1606 if (!ip_util::ipv4VerifyIpAndGetBitcount(*subnetMask,
1607 &prefixLength))
1608 {
1609 messages::propertyValueFormatError(
1610 asyncResp->res, *subnetMask,
1611 pathString + "/SubnetMask");
1612 return;
1613 }
1614 }
1615 else if (nicIpEntry != ipv4Data.cend())
1616 {
1617 if (!ip_util::ipv4VerifyIpAndGetBitcount(nicIpEntry->netmask,
1618 &prefixLength))
1619 {
1620 messages::propertyValueFormatError(
1621 asyncResp->res, nicIpEntry->netmask,
1622 pathString + "/SubnetMask");
1623 return;
1624 }
1625 }
1626 else
1627 {
1628 messages::propertyMissing(asyncResp->res,
1629 pathString + "/SubnetMask");
1630 return;
1631 }
1632
1633 if (gateway)
1634 {
1635 if (!ip_util::ipv4VerifyIpAndGetBitcount(*gateway))
1636 {
1637 messages::propertyValueFormatError(asyncResp->res, *gateway,
1638 pathString + "/Gateway");
1639 return;
1640 }
1641 }
1642 else if (nicIpEntry != ipv4Data.cend())
1643 {
1644 gateway = nicIpEntry->gateway;
1645 }
1646 else
1647 {
1648 messages::propertyMissing(asyncResp->res,
1649 pathString + "/Gateway");
1650 return;
1651 }
1652
1653 if (gatewayValueAssigned)
1654 {
1655 if (activeGateway != gateway)
1656 {
1657 // A NIC can only have a single active gateway value.
1658 // If any gateway in the array of static addresses
1659 // mismatch the PATCH is in error.
1660 std::string arg1 = pathString + "/Gateway";
1661 std::string arg2 = activePath + "/Gateway";
1662 messages::propertyValueConflict(asyncResp->res, arg1, arg2);
1663 return;
1664 }
1665 }
1666 else
1667 {
1668 // Capture the very first gateway value from the incoming
1669 // JSON record and use it at the default gateway.
1670 updateIPv4DefaultGateway(ifaceId, *gateway, asyncResp);
1671 activeGateway = *gateway;
1672 activePath = pathString;
1673 gatewayValueAssigned = true;
1674 }
1675
1676 if (nicIpEntry != ipv4Data.cend())
1677 {
1678 deleteAndCreateIPAddress(IpVersion::IpV4, ifaceId,
1679 nicIpEntry->id, prefixLength, *address,
1680 *gateway, asyncResp);
1681 nicIpEntry = getNextStaticIpEntry(++nicIpEntry,
1682 ipv4Data.cend());
1683 preserveGateway = true;
1684 }
1685 else
1686 {
1687 createIPv4(ifaceId, prefixLength, *gateway, *address,
1688 asyncResp);
1689 preserveGateway = true;
1690 }
1691 entryIdx++;
1692 }
1693 else
1694 {
1695 // Received {}, do not modify this address
1696 if (nicIpEntry != ipv4Data.cend())
1697 {
1698 nicIpEntry = getNextStaticIpEntry(++nicIpEntry,
1699 ipv4Data.cend());
1700 preserveGateway = true;
1701 entryIdx++;
1702 }
1703 else
1704 {
1705 // Requested a DO NOT MODIFY action on an entry not assigned
1706 // to the NIC
1707 messages::propertyValueFormatError(asyncResp->res, *obj,
1708 pathString);
1709 return;
1710 }
1711 }
1712 }
1713 }
1714
handleStaticNameServersPatch(const std::string & ifaceId,const std::vector<std::string> & updatedStaticNameServers,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)1715 inline void handleStaticNameServersPatch(
1716 const std::string& ifaceId,
1717 const std::vector<std::string>& updatedStaticNameServers,
1718 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1719 {
1720 setDbusProperty(
1721 asyncResp, "StaticNameServers", "xyz.openbmc_project.Network",
1722 sdbusplus::message::object_path("/xyz/openbmc_project/network") /
1723 ifaceId,
1724 "xyz.openbmc_project.Network.EthernetInterface", "StaticNameServers",
1725 updatedStaticNameServers);
1726 }
1727
handleIPv6StaticAddressesPatch(const std::string & ifaceId,std::vector<std::variant<nlohmann::json::object_t,std::nullptr_t>> & input,const std::vector<IPv6AddressData> & ipv6Data,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)1728 inline void handleIPv6StaticAddressesPatch(
1729 const std::string& ifaceId,
1730 std::vector<std::variant<nlohmann::json::object_t, std::nullptr_t>>& input,
1731 const std::vector<IPv6AddressData>& ipv6Data,
1732 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
1733 {
1734 size_t entryIdx = 1;
1735 std::vector<IPv6AddressData>::const_iterator nicIpEntry =
1736 getNextStaticIpEntry(ipv6Data.cbegin(), ipv6Data.cend());
1737 for (std::variant<nlohmann::json::object_t, std::nullptr_t>& thisJson :
1738 input)
1739 {
1740 std::string pathString = "IPv6StaticAddresses/" +
1741 std::to_string(entryIdx);
1742 nlohmann::json::object_t* obj =
1743 std::get_if<nlohmann::json::object_t>(&thisJson);
1744 if (obj != nullptr && !obj->empty())
1745 {
1746 std::optional<std::string> address;
1747 std::optional<uint8_t> prefixLength;
1748 nlohmann::json::object_t thisJsonCopy = *obj;
1749 if (!json_util::readJsonObject(thisJsonCopy, asyncResp->res,
1750 "Address", address, "PrefixLength",
1751 prefixLength))
1752 {
1753 messages::propertyValueFormatError(asyncResp->res, thisJsonCopy,
1754 pathString);
1755 return;
1756 }
1757
1758 // Find the address and prefixLength values. Any values that are
1759 // not explicitly provided are assumed to be unmodified from the
1760 // current state of the interface. Merge existing state into the
1761 // current request.
1762 if (!address)
1763 {
1764 if (nicIpEntry == ipv6Data.end())
1765 {
1766 messages::propertyMissing(asyncResp->res,
1767 pathString + "/Address");
1768 return;
1769 }
1770 address = nicIpEntry->address;
1771 }
1772
1773 if (!prefixLength)
1774 {
1775 if (nicIpEntry == ipv6Data.end())
1776 {
1777 messages::propertyMissing(asyncResp->res,
1778 pathString + "/PrefixLength");
1779 return;
1780 }
1781 prefixLength = nicIpEntry->prefixLength;
1782 }
1783
1784 if (nicIpEntry != ipv6Data.end())
1785 {
1786 deleteAndCreateIPAddress(IpVersion::IpV6, ifaceId,
1787 nicIpEntry->id, *prefixLength,
1788 *address, "", asyncResp);
1789 nicIpEntry = getNextStaticIpEntry(++nicIpEntry,
1790 ipv6Data.cend());
1791 }
1792 else
1793 {
1794 createIPv6(ifaceId, *prefixLength, *address, asyncResp);
1795 }
1796 entryIdx++;
1797 }
1798 else
1799 {
1800 if (nicIpEntry == ipv6Data.end())
1801 {
1802 // Requesting a DELETE/DO NOT MODIFY action for an item
1803 // that isn't present on the eth(n) interface. Input JSON is
1804 // in error, so bail out.
1805 if (obj == nullptr)
1806 {
1807 messages::resourceCannotBeDeleted(asyncResp->res);
1808 return;
1809 }
1810 messages::propertyValueFormatError(asyncResp->res, *obj,
1811 pathString);
1812 return;
1813 }
1814
1815 if (obj == nullptr)
1816 {
1817 deleteIPAddress(ifaceId, nicIpEntry->id, asyncResp);
1818 }
1819 if (nicIpEntry != ipv6Data.cend())
1820 {
1821 nicIpEntry = getNextStaticIpEntry(++nicIpEntry,
1822 ipv6Data.cend());
1823 }
1824 entryIdx++;
1825 }
1826 }
1827 }
1828
extractParentInterfaceName(const std::string & ifaceId)1829 inline std::string extractParentInterfaceName(const std::string& ifaceId)
1830 {
1831 std::size_t pos = ifaceId.find('_');
1832 return ifaceId.substr(0, pos);
1833 }
1834
1835 inline void
parseInterfaceData(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & ifaceId,const EthernetInterfaceData & ethData,const std::vector<IPv4AddressData> & ipv4Data,const std::vector<IPv6AddressData> & ipv6Data,const std::vector<StaticGatewayData> & ipv6GatewayData)1836 parseInterfaceData(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1837 const std::string& ifaceId,
1838 const EthernetInterfaceData& ethData,
1839 const std::vector<IPv4AddressData>& ipv4Data,
1840 const std::vector<IPv6AddressData>& ipv6Data,
1841 const std::vector<StaticGatewayData>& ipv6GatewayData)
1842 {
1843 nlohmann::json& jsonResponse = asyncResp->res.jsonValue;
1844 jsonResponse["Id"] = ifaceId;
1845 jsonResponse["@odata.id"] =
1846 boost::urls::format("/redfish/v1/Managers/{}/EthernetInterfaces/{}",
1847 BMCWEB_REDFISH_MANAGER_URI_NAME, ifaceId);
1848 jsonResponse["InterfaceEnabled"] = ethData.nicEnabled;
1849
1850 if (ethData.nicEnabled)
1851 {
1852 jsonResponse["LinkStatus"] = ethData.linkUp ? "LinkUp" : "LinkDown";
1853 jsonResponse["Status"]["State"] = "Enabled";
1854 }
1855 else
1856 {
1857 jsonResponse["LinkStatus"] = "NoLink";
1858 jsonResponse["Status"]["State"] = "Disabled";
1859 }
1860
1861 jsonResponse["SpeedMbps"] = ethData.speed;
1862 jsonResponse["MTUSize"] = ethData.mtuSize;
1863 jsonResponse["MACAddress"] = ethData.macAddress;
1864 jsonResponse["DHCPv4"]["DHCPEnabled"] =
1865 translateDhcpEnabledToBool(ethData.dhcpEnabled, true);
1866 jsonResponse["DHCPv4"]["UseNTPServers"] = ethData.ntpv4Enabled;
1867 jsonResponse["DHCPv4"]["UseDNSServers"] = ethData.dnsv4Enabled;
1868 jsonResponse["DHCPv4"]["UseDomainName"] = ethData.domainv4Enabled;
1869 jsonResponse["DHCPv6"]["OperatingMode"] =
1870 translateDhcpEnabledToBool(ethData.dhcpEnabled, false) ? "Enabled"
1871 : "Disabled";
1872 jsonResponse["DHCPv6"]["UseNTPServers"] = ethData.ntpv6Enabled;
1873 jsonResponse["DHCPv6"]["UseDNSServers"] = ethData.dnsv6Enabled;
1874 jsonResponse["DHCPv6"]["UseDomainName"] = ethData.domainv6Enabled;
1875 jsonResponse["StatelessAddressAutoConfig"]["IPv6AutoConfigEnabled"] =
1876 ethData.ipv6AcceptRa;
1877
1878 if (!ethData.hostName.empty())
1879 {
1880 jsonResponse["HostName"] = ethData.hostName;
1881
1882 // When domain name is empty then it means, that it is a network
1883 // without domain names, and the host name itself must be treated as
1884 // FQDN
1885 std::string fqdn = ethData.hostName;
1886 if (!ethData.domainnames.empty())
1887 {
1888 fqdn += "." + ethData.domainnames[0];
1889 }
1890 jsonResponse["FQDN"] = fqdn;
1891 }
1892
1893 if (ethData.vlanId)
1894 {
1895 jsonResponse["EthernetInterfaceType"] = "Virtual";
1896 jsonResponse["VLAN"]["VLANEnable"] = true;
1897 jsonResponse["VLAN"]["VLANId"] = *ethData.vlanId;
1898 jsonResponse["VLAN"]["Tagged"] = true;
1899
1900 nlohmann::json::array_t relatedInterfaces;
1901 nlohmann::json& parentInterface = relatedInterfaces.emplace_back();
1902 parentInterface["@odata.id"] =
1903 boost::urls::format("/redfish/v1/Managers/{}/EthernetInterfaces",
1904 BMCWEB_REDFISH_MANAGER_URI_NAME,
1905 extractParentInterfaceName(ifaceId));
1906 jsonResponse["Links"]["RelatedInterfaces"] =
1907 std::move(relatedInterfaces);
1908 }
1909 else
1910 {
1911 jsonResponse["EthernetInterfaceType"] = "Physical";
1912 }
1913
1914 jsonResponse["NameServers"] = ethData.nameServers;
1915 jsonResponse["StaticNameServers"] = ethData.staticNameServers;
1916
1917 nlohmann::json& ipv4Array = jsonResponse["IPv4Addresses"];
1918 nlohmann::json& ipv4StaticArray = jsonResponse["IPv4StaticAddresses"];
1919 ipv4Array = nlohmann::json::array();
1920 ipv4StaticArray = nlohmann::json::array();
1921 for (const auto& ipv4Config : ipv4Data)
1922 {
1923 std::string gatewayStr = ipv4Config.gateway;
1924 if (gatewayStr.empty())
1925 {
1926 gatewayStr = "0.0.0.0";
1927 }
1928 nlohmann::json::object_t ipv4;
1929 ipv4["AddressOrigin"] = ipv4Config.origin;
1930 ipv4["SubnetMask"] = ipv4Config.netmask;
1931 ipv4["Address"] = ipv4Config.address;
1932 ipv4["Gateway"] = gatewayStr;
1933
1934 if (ipv4Config.origin == "Static")
1935 {
1936 ipv4StaticArray.push_back(ipv4);
1937 }
1938
1939 ipv4Array.emplace_back(std::move(ipv4));
1940 }
1941
1942 std::string ipv6GatewayStr = ethData.ipv6DefaultGateway;
1943 if (ipv6GatewayStr.empty())
1944 {
1945 ipv6GatewayStr = "0:0:0:0:0:0:0:0";
1946 }
1947
1948 jsonResponse["IPv6DefaultGateway"] = ipv6GatewayStr;
1949
1950 nlohmann::json::array_t ipv6StaticGatewayArray;
1951 for (const auto& ipv6GatewayConfig : ipv6GatewayData)
1952 {
1953 nlohmann::json::object_t ipv6Gateway;
1954 ipv6Gateway["Address"] = ipv6GatewayConfig.gateway;
1955 ipv6Gateway["PrefixLength"] = ipv6GatewayConfig.prefixLength;
1956 ipv6StaticGatewayArray.emplace_back(std::move(ipv6Gateway));
1957 }
1958 jsonResponse["IPv6StaticDefaultGateways"] =
1959 std::move(ipv6StaticGatewayArray);
1960
1961 nlohmann::json& ipv6Array = jsonResponse["IPv6Addresses"];
1962 nlohmann::json& ipv6StaticArray = jsonResponse["IPv6StaticAddresses"];
1963 ipv6Array = nlohmann::json::array();
1964 ipv6StaticArray = nlohmann::json::array();
1965 nlohmann::json& ipv6AddrPolicyTable =
1966 jsonResponse["IPv6AddressPolicyTable"];
1967 ipv6AddrPolicyTable = nlohmann::json::array();
1968 for (const auto& ipv6Config : ipv6Data)
1969 {
1970 nlohmann::json::object_t ipv6;
1971 ipv6["Address"] = ipv6Config.address;
1972 ipv6["PrefixLength"] = ipv6Config.prefixLength;
1973 ipv6["AddressOrigin"] = ipv6Config.origin;
1974
1975 ipv6Array.emplace_back(std::move(ipv6));
1976 if (ipv6Config.origin == "Static")
1977 {
1978 nlohmann::json::object_t ipv6Static;
1979 ipv6Static["Address"] = ipv6Config.address;
1980 ipv6Static["PrefixLength"] = ipv6Config.prefixLength;
1981 ipv6StaticArray.emplace_back(std::move(ipv6Static));
1982 }
1983 }
1984 }
1985
afterDelete(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & ifaceId,const boost::system::error_code & ec,const sdbusplus::message_t & m)1986 inline void afterDelete(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1987 const std::string& ifaceId,
1988 const boost::system::error_code& ec,
1989 const sdbusplus::message_t& m)
1990 {
1991 if (!ec)
1992 {
1993 return;
1994 }
1995 const sd_bus_error* dbusError = m.get_error();
1996 if (dbusError == nullptr)
1997 {
1998 messages::internalError(asyncResp->res);
1999 return;
2000 }
2001 BMCWEB_LOG_DEBUG("DBus error: {}", dbusError->name);
2002
2003 if (std::string_view("org.freedesktop.DBus.Error.UnknownObject") ==
2004 dbusError->name)
2005 {
2006 messages::resourceNotFound(asyncResp->res, "EthernetInterface",
2007 ifaceId);
2008 return;
2009 }
2010 if (std::string_view("org.freedesktop.DBus.Error.UnknownMethod") ==
2011 dbusError->name)
2012 {
2013 messages::resourceCannotBeDeleted(asyncResp->res);
2014 return;
2015 }
2016 messages::internalError(asyncResp->res);
2017 }
2018
afterVlanCreate(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & parentInterfaceUri,const std::string & vlanInterface,const boost::system::error_code & ec,const sdbusplus::message_t & m)2019 inline void afterVlanCreate(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2020 const std::string& parentInterfaceUri,
2021 const std::string& vlanInterface,
2022 const boost::system::error_code& ec,
2023 const sdbusplus::message_t& m
2024
2025 )
2026 {
2027 if (ec)
2028 {
2029 const sd_bus_error* dbusError = m.get_error();
2030 if (dbusError == nullptr)
2031 {
2032 messages::internalError(asyncResp->res);
2033 return;
2034 }
2035 BMCWEB_LOG_DEBUG("DBus error: {}", dbusError->name);
2036
2037 if (std::string_view(
2038 "xyz.openbmc_project.Common.Error.ResourceNotFound") ==
2039 dbusError->name)
2040 {
2041 messages::propertyValueNotInList(
2042 asyncResp->res, parentInterfaceUri,
2043 "Links/RelatedInterfaces/0/@odata.id");
2044 return;
2045 }
2046 if (std::string_view(
2047 "xyz.openbmc_project.Common.Error.InvalidArgument") ==
2048 dbusError->name)
2049 {
2050 messages::resourceAlreadyExists(asyncResp->res, "EthernetInterface",
2051 "Id", vlanInterface);
2052 return;
2053 }
2054 messages::internalError(asyncResp->res);
2055 return;
2056 }
2057
2058 const boost::urls::url vlanInterfaceUri =
2059 boost::urls::format("/redfish/v1/Managers/{}/EthernetInterfaces/{}",
2060 BMCWEB_REDFISH_MANAGER_URI_NAME, vlanInterface);
2061 asyncResp->res.addHeader("Location", vlanInterfaceUri.buffer());
2062 }
2063
requestEthernetInterfacesRoutes(App & app)2064 inline void requestEthernetInterfacesRoutes(App& app)
2065 {
2066 BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/EthernetInterfaces/")
2067 .privileges(redfish::privileges::getEthernetInterfaceCollection)
2068 .methods(boost::beast::http::verb::get)(
2069 [&app](const crow::Request& req,
2070 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2071 const std::string& managerId) {
2072 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2073 {
2074 return;
2075 }
2076
2077 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
2078 {
2079 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
2080 return;
2081 }
2082
2083 asyncResp->res.jsonValue["@odata.type"] =
2084 "#EthernetInterfaceCollection.EthernetInterfaceCollection";
2085 asyncResp->res.jsonValue["@odata.id"] =
2086 boost::urls::format("/redfish/v1/Managers/{}/EthernetInterfaces",
2087 BMCWEB_REDFISH_MANAGER_URI_NAME);
2088 asyncResp->res.jsonValue["Name"] =
2089 "Ethernet Network Interface Collection";
2090 asyncResp->res.jsonValue["Description"] =
2091 "Collection of EthernetInterfaces for this Manager";
2092
2093 // Get eth interface list, and call the below callback for JSON
2094 // preparation
2095 getEthernetIfaceList(
2096 [asyncResp](const bool& success,
2097 const std::vector<std::string>& ifaceList) {
2098 if (!success)
2099 {
2100 messages::internalError(asyncResp->res);
2101 return;
2102 }
2103
2104 nlohmann::json& ifaceArray = asyncResp->res.jsonValue["Members"];
2105 ifaceArray = nlohmann::json::array();
2106 for (const std::string& ifaceItem : ifaceList)
2107 {
2108 nlohmann::json::object_t iface;
2109 iface["@odata.id"] = boost::urls::format(
2110 "/redfish/v1/Managers/{}/EthernetInterfaces/{}",
2111 BMCWEB_REDFISH_MANAGER_URI_NAME, ifaceItem);
2112 ifaceArray.push_back(std::move(iface));
2113 }
2114
2115 asyncResp->res.jsonValue["Members@odata.count"] = ifaceArray.size();
2116 asyncResp->res.jsonValue["@odata.id"] = boost::urls::format(
2117 "/redfish/v1/Managers/{}/EthernetInterfaces",
2118 BMCWEB_REDFISH_MANAGER_URI_NAME);
2119 });
2120 });
2121
2122 BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/EthernetInterfaces/")
2123 .privileges(redfish::privileges::postEthernetInterfaceCollection)
2124 .methods(boost::beast::http::verb::post)(
2125 [&app](const crow::Request& req,
2126 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2127 const std::string& managerId) {
2128 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2129 {
2130 return;
2131 }
2132
2133 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
2134 {
2135 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
2136 return;
2137 }
2138
2139 bool vlanEnable = false;
2140 uint32_t vlanId = 0;
2141 std::vector<nlohmann::json::object_t> relatedInterfaces;
2142
2143 if (!json_util::readJsonPatch(req, asyncResp->res, "VLAN/VLANEnable",
2144 vlanEnable, "VLAN/VLANId", vlanId,
2145 "Links/RelatedInterfaces",
2146 relatedInterfaces))
2147 {
2148 return;
2149 }
2150
2151 if (relatedInterfaces.size() != 1)
2152 {
2153 messages::arraySizeTooLong(asyncResp->res,
2154 "Links/RelatedInterfaces",
2155 relatedInterfaces.size());
2156 return;
2157 }
2158
2159 std::string parentInterfaceUri;
2160 if (!json_util::readJsonObject(relatedInterfaces[0], asyncResp->res,
2161 "@odata.id", parentInterfaceUri))
2162 {
2163 messages::propertyMissing(asyncResp->res,
2164 "Links/RelatedInterfaces/0/@odata.id");
2165 return;
2166 }
2167 BMCWEB_LOG_INFO("Parent Interface URI: {}", parentInterfaceUri);
2168
2169 boost::system::result<boost::urls::url_view> parsedUri =
2170 boost::urls::parse_relative_ref(parentInterfaceUri);
2171 if (!parsedUri)
2172 {
2173 messages::propertyValueFormatError(
2174 asyncResp->res, parentInterfaceUri,
2175 "Links/RelatedInterfaces/0/@odata.id");
2176 return;
2177 }
2178
2179 std::string parentInterface;
2180 if (!crow::utility::readUrlSegments(
2181 *parsedUri, "redfish", "v1", "Managers", "bmc",
2182 "EthernetInterfaces", std::ref(parentInterface)))
2183 {
2184 messages::propertyValueNotInList(
2185 asyncResp->res, parentInterfaceUri,
2186 "Links/RelatedInterfaces/0/@odata.id");
2187 return;
2188 }
2189
2190 if (!vlanEnable)
2191 {
2192 // In OpenBMC implementation, VLANEnable cannot be false on
2193 // create
2194 messages::propertyValueIncorrect(asyncResp->res, "VLAN/VLANEnable",
2195 "false");
2196 return;
2197 }
2198
2199 std::string vlanInterface = parentInterface + "_" +
2200 std::to_string(vlanId);
2201 crow::connections::systemBus->async_method_call(
2202 [asyncResp, parentInterfaceUri,
2203 vlanInterface](const boost::system::error_code& ec,
2204 const sdbusplus::message_t& m) {
2205 afterVlanCreate(asyncResp, parentInterfaceUri, vlanInterface, ec,
2206 m);
2207 },
2208 "xyz.openbmc_project.Network", "/xyz/openbmc_project/network",
2209 "xyz.openbmc_project.Network.VLAN.Create", "VLAN", parentInterface,
2210 vlanId);
2211 });
2212
2213 BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/EthernetInterfaces/<str>/")
2214 .privileges(redfish::privileges::getEthernetInterface)
2215 .methods(boost::beast::http::verb::get)(
2216 [&app](const crow::Request& req,
2217 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2218 const std::string& managerId, const std::string& ifaceId) {
2219 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2220 {
2221 return;
2222 }
2223
2224 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
2225 {
2226 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
2227 return;
2228 }
2229
2230 getEthernetIfaceData(
2231 ifaceId,
2232 [asyncResp,
2233 ifaceId](const bool& success, const EthernetInterfaceData& ethData,
2234 const std::vector<IPv4AddressData>& ipv4Data,
2235 const std::vector<IPv6AddressData>& ipv6Data,
2236 const std::vector<StaticGatewayData>& ipv6GatewayData) {
2237 if (!success)
2238 {
2239 // TODO(Pawel)consider distinguish between non
2240 // existing object, and other errors
2241 messages::resourceNotFound(asyncResp->res, "EthernetInterface",
2242 ifaceId);
2243 return;
2244 }
2245
2246 asyncResp->res.jsonValue["@odata.type"] =
2247 "#EthernetInterface.v1_9_0.EthernetInterface";
2248 asyncResp->res.jsonValue["Name"] = "Manager Ethernet Interface";
2249 asyncResp->res.jsonValue["Description"] =
2250 "Management Network Interface";
2251
2252 parseInterfaceData(asyncResp, ifaceId, ethData, ipv4Data, ipv6Data,
2253 ipv6GatewayData);
2254 });
2255 });
2256
2257 BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/EthernetInterfaces/<str>/")
2258 .privileges(redfish::privileges::patchEthernetInterface)
2259 .methods(boost::beast::http::verb::patch)(
2260 [&app](const crow::Request& req,
2261 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2262 const std::string& managerId, const std::string& ifaceId) {
2263 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2264 {
2265 return;
2266 }
2267
2268 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
2269 {
2270 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
2271 return;
2272 }
2273
2274 std::optional<std::string> hostname;
2275 std::optional<std::string> fqdn;
2276 std::optional<std::string> macAddress;
2277 std::optional<std::string> ipv6DefaultGateway;
2278 std::optional<
2279 std::vector<std::variant<nlohmann::json::object_t, std::nullptr_t>>>
2280 ipv4StaticAddresses;
2281 std::optional<
2282 std::vector<std::variant<nlohmann::json::object_t, std::nullptr_t>>>
2283 ipv6StaticAddresses;
2284 std::optional<
2285 std::vector<std::variant<nlohmann::json::object_t, std::nullptr_t>>>
2286 ipv6StaticDefaultGateways;
2287 std::optional<std::vector<std::string>> staticNameServers;
2288 std::optional<bool> ipv6AutoConfigEnabled;
2289 std::optional<bool> interfaceEnabled;
2290 std::optional<size_t> mtuSize;
2291 DHCPParameters v4dhcpParms;
2292 DHCPParameters v6dhcpParms;
2293 // clang-format off
2294 if (!json_util::readJsonPatch(req, asyncResp->res,
2295 "DHCPv4/DHCPEnabled", v4dhcpParms.dhcpv4Enabled,
2296 "DHCPv4/UseDNSServers", v4dhcpParms.useDnsServers,
2297 "DHCPv4/UseDomainName", v4dhcpParms.useDomainName,
2298 "DHCPv4/UseNTPServers", v4dhcpParms.useNtpServers,
2299 "DHCPv6/OperatingMode", v6dhcpParms.dhcpv6OperatingMode,
2300 "DHCPv6/UseDNSServers", v6dhcpParms.useDnsServers,
2301 "DHCPv6/UseDomainName", v6dhcpParms.useDomainName,
2302 "DHCPv6/UseNTPServers", v6dhcpParms.useNtpServers,
2303 "FQDN", fqdn,
2304 "HostName", hostname,
2305 "IPv4StaticAddresses", ipv4StaticAddresses,
2306 "IPv6DefaultGateway", ipv6DefaultGateway,
2307 "IPv6StaticAddresses", ipv6StaticAddresses,
2308 "IPv6StaticDefaultGateways", ipv6StaticDefaultGateways,
2309 "InterfaceEnabled", interfaceEnabled,
2310 "MACAddress", macAddress,
2311 "MTUSize", mtuSize,
2312 "StatelessAddressAutoConfig/IPv6AutoConfigEnabled", ipv6AutoConfigEnabled,
2313 "StaticNameServers", staticNameServers
2314 )
2315 )
2316 {
2317 return;
2318 }
2319 // clang-format on
2320
2321 // Get single eth interface data, and call the below callback
2322 // for JSON preparation
2323 getEthernetIfaceData(
2324 ifaceId,
2325 [asyncResp, ifaceId, hostname = std::move(hostname),
2326 fqdn = std::move(fqdn), macAddress = std::move(macAddress),
2327 ipv4StaticAddresses = std::move(ipv4StaticAddresses),
2328 ipv6DefaultGateway = std::move(ipv6DefaultGateway),
2329 ipv6StaticAddresses = std::move(ipv6StaticAddresses),
2330 ipv6StaticDefaultGateway = std::move(ipv6StaticDefaultGateways),
2331 staticNameServers = std::move(staticNameServers), mtuSize,
2332 ipv6AutoConfigEnabled, v4dhcpParms = std::move(v4dhcpParms),
2333 v6dhcpParms = std::move(v6dhcpParms), interfaceEnabled](
2334 const bool success, const EthernetInterfaceData& ethData,
2335 const std::vector<IPv4AddressData>& ipv4Data,
2336 const std::vector<IPv6AddressData>& ipv6Data,
2337 const std::vector<StaticGatewayData>& ipv6GatewayData) mutable {
2338 if (!success)
2339 {
2340 // ... otherwise return error
2341 // TODO(Pawel)consider distinguish between non
2342 // existing object, and other errors
2343 messages::resourceNotFound(asyncResp->res, "EthernetInterface",
2344 ifaceId);
2345 return;
2346 }
2347
2348 handleDHCPPatch(ifaceId, ethData, v4dhcpParms, v6dhcpParms,
2349 asyncResp);
2350
2351 if (hostname)
2352 {
2353 handleHostnamePatch(*hostname, asyncResp);
2354 }
2355
2356 if (ipv6AutoConfigEnabled)
2357 {
2358 handleSLAACAutoConfigPatch(ifaceId, *ipv6AutoConfigEnabled,
2359 asyncResp);
2360 }
2361
2362 if (fqdn)
2363 {
2364 handleFqdnPatch(ifaceId, *fqdn, asyncResp);
2365 }
2366
2367 if (macAddress)
2368 {
2369 handleMACAddressPatch(ifaceId, *macAddress, asyncResp);
2370 }
2371
2372 if (ipv4StaticAddresses)
2373 {
2374 handleIPv4StaticPatch(ifaceId, *ipv4StaticAddresses, ethData,
2375 ipv4Data, asyncResp);
2376 }
2377
2378 if (staticNameServers)
2379 {
2380 handleStaticNameServersPatch(ifaceId, *staticNameServers,
2381 asyncResp);
2382 }
2383
2384 if (ipv6DefaultGateway)
2385 {
2386 messages::propertyNotWritable(asyncResp->res,
2387 "IPv6DefaultGateway");
2388 }
2389
2390 if (ipv6StaticAddresses)
2391 {
2392 handleIPv6StaticAddressesPatch(ifaceId, *ipv6StaticAddresses,
2393 ipv6Data, asyncResp);
2394 }
2395
2396 if (ipv6StaticDefaultGateway)
2397 {
2398 handleIPv6DefaultGateway(ifaceId, *ipv6StaticDefaultGateway,
2399 ipv6GatewayData, asyncResp);
2400 }
2401
2402 if (interfaceEnabled)
2403 {
2404 setDbusProperty(asyncResp, "InterfaceEnabled",
2405 "xyz.openbmc_project.Network",
2406 sdbusplus::message::object_path(
2407 "/xyz/openbmc_project/network") /
2408 ifaceId,
2409 "xyz.openbmc_project.Network.EthernetInterface",
2410 "NICEnabled", *interfaceEnabled);
2411 }
2412
2413 if (mtuSize)
2414 {
2415 handleMTUSizePatch(ifaceId, *mtuSize, asyncResp);
2416 }
2417 });
2418 });
2419
2420 BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/EthernetInterfaces/<str>/")
2421 .privileges(redfish::privileges::deleteEthernetInterface)
2422 .methods(boost::beast::http::verb::delete_)(
2423 [&app](const crow::Request& req,
2424 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2425 const std::string& managerId, const std::string& ifaceId) {
2426 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2427 {
2428 return;
2429 }
2430
2431 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
2432 {
2433 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
2434 return;
2435 }
2436
2437 crow::connections::systemBus->async_method_call(
2438 [asyncResp, ifaceId](const boost::system::error_code& ec,
2439 const sdbusplus::message_t& m) {
2440 afterDelete(asyncResp, ifaceId, ec, m);
2441 },
2442 "xyz.openbmc_project.Network",
2443 std::string("/xyz/openbmc_project/network/") + ifaceId,
2444 "xyz.openbmc_project.Object.Delete", "Delete");
2445 });
2446 }
2447
2448 } // namespace redfish
2449