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