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