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 (int bitIdx = 7; bitIdx >= 0; bitIdx--) 673 { 674 if (value & (1 << 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 ec) { 781 if (ec) 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 ec) { 847 if (ec) 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 template <typename CrowApp> 1007 EthernetCollection(CrowApp& app) : 1008 Node(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/") 1009 { 1010 entityPrivileges = { 1011 {boost::beast::http::verb::get, {{"Login"}}}, 1012 {boost::beast::http::verb::head, {{"Login"}}}, 1013 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}}, 1014 {boost::beast::http::verb::put, {{"ConfigureComponents"}}}, 1015 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}}, 1016 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; 1017 } 1018 1019 private: 1020 /** 1021 * Functions triggers appropriate requests on DBus 1022 */ 1023 void doGet(crow::Response& res, const crow::Request& req, 1024 const std::vector<std::string>& params) override 1025 { 1026 res.jsonValue["@odata.type"] = 1027 "#EthernetInterfaceCollection.EthernetInterfaceCollection"; 1028 res.jsonValue["@odata.id"] = 1029 "/redfish/v1/Managers/bmc/EthernetInterfaces"; 1030 res.jsonValue["Name"] = "Ethernet Network Interface Collection"; 1031 res.jsonValue["Description"] = 1032 "Collection of EthernetInterfaces for this Manager"; 1033 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res); 1034 // Get eth interface list, and call the below callback for JSON 1035 // preparation 1036 getEthernetIfaceList( 1037 [asyncResp]( 1038 const bool& success, 1039 const boost::container::flat_set<std::string>& iface_list) { 1040 if (!success) 1041 { 1042 messages::internalError(asyncResp->res); 1043 return; 1044 } 1045 1046 nlohmann::json& iface_array = 1047 asyncResp->res.jsonValue["Members"]; 1048 iface_array = nlohmann::json::array(); 1049 std::string tag = "_"; 1050 for (const std::string& iface_item : iface_list) 1051 { 1052 std::size_t found = iface_item.find(tag); 1053 if (found == std::string::npos) 1054 { 1055 iface_array.push_back( 1056 {{"@odata.id", 1057 "/redfish/v1/Managers/bmc/EthernetInterfaces/" + 1058 iface_item}}); 1059 } 1060 } 1061 1062 asyncResp->res.jsonValue["Members@odata.count"] = 1063 iface_array.size(); 1064 asyncResp->res.jsonValue["@odata.id"] = 1065 "/redfish/v1/Managers/bmc/EthernetInterfaces"; 1066 }); 1067 } 1068 }; 1069 1070 /** 1071 * EthernetInterface derived class for delivering Ethernet Schema 1072 */ 1073 class EthernetInterface : public Node 1074 { 1075 public: 1076 /* 1077 * Default Constructor 1078 */ 1079 template <typename CrowApp> 1080 EthernetInterface(CrowApp& app) : 1081 Node(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/", 1082 std::string()) 1083 { 1084 entityPrivileges = { 1085 {boost::beast::http::verb::get, {{"Login"}}}, 1086 {boost::beast::http::verb::head, {{"Login"}}}, 1087 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}}, 1088 {boost::beast::http::verb::put, {{"ConfigureComponents"}}}, 1089 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}}, 1090 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; 1091 } 1092 1093 private: 1094 void handleHostnamePatch(const std::string& hostname, 1095 const std::shared_ptr<AsyncResp> asyncResp) 1096 { 1097 // SHOULD handle host names of up to 255 characters(RFC 1123) 1098 if (hostname.length() > 255) 1099 { 1100 messages::propertyValueFormatError(asyncResp->res, hostname, 1101 "HostName"); 1102 return; 1103 } 1104 crow::connections::systemBus->async_method_call( 1105 [asyncResp](const boost::system::error_code ec) { 1106 if (ec) 1107 { 1108 messages::internalError(asyncResp->res); 1109 } 1110 }, 1111 "xyz.openbmc_project.Network", 1112 "/xyz/openbmc_project/network/config", 1113 "org.freedesktop.DBus.Properties", "Set", 1114 "xyz.openbmc_project.Network.SystemConfiguration", "HostName", 1115 std::variant<std::string>(hostname)); 1116 } 1117 1118 void handleDomainnamePatch(const std::string& ifaceId, 1119 const std::string& domainname, 1120 const std::shared_ptr<AsyncResp> asyncResp) 1121 { 1122 std::vector<std::string> vectorDomainname = {domainname}; 1123 crow::connections::systemBus->async_method_call( 1124 [asyncResp](const boost::system::error_code ec) { 1125 if (ec) 1126 { 1127 messages::internalError(asyncResp->res); 1128 } 1129 }, 1130 "xyz.openbmc_project.Network", 1131 "/xyz/openbmc_project/network/" + ifaceId, 1132 "org.freedesktop.DBus.Properties", "Set", 1133 "xyz.openbmc_project.Network.EthernetInterface", "DomainName", 1134 std::variant<std::vector<std::string>>(vectorDomainname)); 1135 } 1136 1137 void handleFqdnPatch(const std::string& ifaceId, const std::string& fqdn, 1138 const std::shared_ptr<AsyncResp> asyncResp) 1139 { 1140 // Total length of FQDN must not exceed 255 characters(RFC 1035) 1141 if (fqdn.length() > 255) 1142 { 1143 messages::propertyValueFormatError(asyncResp->res, fqdn, "FQDN"); 1144 return; 1145 } 1146 1147 size_t pos = fqdn.find('.'); 1148 if (pos == std::string::npos) 1149 { 1150 messages::propertyValueFormatError(asyncResp->res, fqdn, "FQDN"); 1151 return; 1152 } 1153 1154 std::string hostname; 1155 std::string domainname; 1156 domainname = (fqdn).substr(pos + 1); 1157 hostname = (fqdn).substr(0, pos); 1158 1159 if (!isHostnameValid(hostname) || !isDomainnameValid(domainname)) 1160 { 1161 messages::propertyValueFormatError(asyncResp->res, fqdn, "FQDN"); 1162 return; 1163 } 1164 1165 handleHostnamePatch(hostname, asyncResp); 1166 handleDomainnamePatch(ifaceId, domainname, asyncResp); 1167 } 1168 1169 bool isHostnameValid(const std::string& hostname) 1170 { 1171 // A valid host name can never have the dotted-decimal form (RFC 1123) 1172 if (std::all_of(hostname.begin(), hostname.end(), ::isdigit)) 1173 { 1174 return false; 1175 } 1176 // Each label(hostname/subdomains) within a valid FQDN 1177 // MUST handle host names of up to 63 characters (RFC 1123) 1178 // labels cannot start or end with hyphens (RFC 952) 1179 // labels can start with numbers (RFC 1123) 1180 const std::regex pattern( 1181 "^[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]{0,61}[a-zA-Z0-9]$"); 1182 1183 return std::regex_match(hostname, pattern); 1184 } 1185 1186 bool isDomainnameValid(const std::string& domainname) 1187 { 1188 // Can have multiple subdomains 1189 // Top Level Domain's min length is 2 character 1190 const std::regex pattern("^([A-Za-z0-9][a-zA-Z0-9\\-]{1,61}|[a-zA-Z0-9]" 1191 "{1,30}\\.)*[a-zA-Z]{2,}$"); 1192 1193 return std::regex_match(domainname, pattern); 1194 } 1195 1196 void handleMACAddressPatch(const std::string& ifaceId, 1197 const std::string& macAddress, 1198 const std::shared_ptr<AsyncResp>& asyncResp) 1199 { 1200 crow::connections::systemBus->async_method_call( 1201 [asyncResp, macAddress](const boost::system::error_code ec) { 1202 if (ec) 1203 { 1204 messages::internalError(asyncResp->res); 1205 return; 1206 } 1207 }, 1208 "xyz.openbmc_project.Network", 1209 "/xyz/openbmc_project/network/" + ifaceId, 1210 "org.freedesktop.DBus.Properties", "Set", 1211 "xyz.openbmc_project.Network.MACAddress", "MACAddress", 1212 std::variant<std::string>(macAddress)); 1213 } 1214 1215 void setDHCPEnabled(const std::string& ifaceId, 1216 const std::string& propertyName, const bool v4Value, 1217 const bool v6Value, 1218 const std::shared_ptr<AsyncResp> asyncResp) 1219 { 1220 const std::string dhcp = GetDHCPEnabledEnumeration(v4Value, v6Value); 1221 crow::connections::systemBus->async_method_call( 1222 [asyncResp](const boost::system::error_code ec) { 1223 if (ec) 1224 { 1225 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec; 1226 messages::internalError(asyncResp->res); 1227 return; 1228 } 1229 }, 1230 "xyz.openbmc_project.Network", 1231 "/xyz/openbmc_project/network/" + ifaceId, 1232 "org.freedesktop.DBus.Properties", "Set", 1233 "xyz.openbmc_project.Network.EthernetInterface", propertyName, 1234 std::variant<std::string>{dhcp}); 1235 } 1236 1237 void setEthernetInterfaceBoolProperty( 1238 const std::string& ifaceId, const std::string& propertyName, 1239 const bool& value, const std::shared_ptr<AsyncResp> asyncResp) 1240 { 1241 crow::connections::systemBus->async_method_call( 1242 [asyncResp](const boost::system::error_code ec) { 1243 if (ec) 1244 { 1245 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec; 1246 messages::internalError(asyncResp->res); 1247 return; 1248 } 1249 }, 1250 "xyz.openbmc_project.Network", 1251 "/xyz/openbmc_project/network/" + ifaceId, 1252 "org.freedesktop.DBus.Properties", "Set", 1253 "xyz.openbmc_project.Network.EthernetInterface", propertyName, 1254 std::variant<bool>{value}); 1255 } 1256 1257 void setDHCPv4Config(const std::string& propertyName, const bool& value, 1258 const std::shared_ptr<AsyncResp> asyncResp) 1259 { 1260 BMCWEB_LOG_DEBUG << propertyName << " = " << value; 1261 crow::connections::systemBus->async_method_call( 1262 [asyncResp](const boost::system::error_code ec) { 1263 if (ec) 1264 { 1265 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec; 1266 messages::internalError(asyncResp->res); 1267 return; 1268 } 1269 }, 1270 "xyz.openbmc_project.Network", 1271 "/xyz/openbmc_project/network/config/dhcp", 1272 "org.freedesktop.DBus.Properties", "Set", 1273 "xyz.openbmc_project.Network.DHCPConfiguration", propertyName, 1274 std::variant<bool>{value}); 1275 } 1276 1277 void handleDHCPPatch(const std::string& ifaceId, 1278 const EthernetInterfaceData& ethData, 1279 DHCPParameters v4dhcpParms, DHCPParameters v6dhcpParms, 1280 const std::shared_ptr<AsyncResp> asyncResp) 1281 { 1282 bool ipv4Active = translateDHCPEnabledToBool(ethData.DHCPEnabled, true); 1283 bool ipv6Active = 1284 translateDHCPEnabledToBool(ethData.DHCPEnabled, false); 1285 1286 bool nextv4DHCPState = 1287 v4dhcpParms.dhcpv4Enabled ? *v4dhcpParms.dhcpv4Enabled : ipv4Active; 1288 1289 bool nextv6DHCPState{}; 1290 if (v6dhcpParms.dhcpv6OperatingMode) 1291 { 1292 if ((*v6dhcpParms.dhcpv6OperatingMode != "Stateful") && 1293 (*v6dhcpParms.dhcpv6OperatingMode != "Stateless") && 1294 (*v6dhcpParms.dhcpv6OperatingMode != "Disabled")) 1295 { 1296 messages::propertyValueFormatError( 1297 asyncResp->res, *v6dhcpParms.dhcpv6OperatingMode, 1298 "OperatingMode"); 1299 return; 1300 } 1301 nextv6DHCPState = (*v6dhcpParms.dhcpv6OperatingMode == "Stateful"); 1302 } 1303 else 1304 { 1305 nextv6DHCPState = ipv6Active; 1306 } 1307 1308 bool nextDNS{}; 1309 if (v4dhcpParms.useDNSServers && v6dhcpParms.useDNSServers) 1310 { 1311 if (*v4dhcpParms.useDNSServers != *v6dhcpParms.useDNSServers) 1312 { 1313 messages::generalError(asyncResp->res); 1314 return; 1315 } 1316 nextDNS = *v4dhcpParms.useDNSServers; 1317 } 1318 else if (v4dhcpParms.useDNSServers) 1319 { 1320 nextDNS = *v4dhcpParms.useDNSServers; 1321 } 1322 else if (v6dhcpParms.useDNSServers) 1323 { 1324 nextDNS = *v6dhcpParms.useDNSServers; 1325 } 1326 else 1327 { 1328 nextDNS = ethData.DNSEnabled; 1329 } 1330 1331 bool nextNTP{}; 1332 if (v4dhcpParms.useNTPServers && v6dhcpParms.useNTPServers) 1333 { 1334 if (*v4dhcpParms.useNTPServers != *v6dhcpParms.useNTPServers) 1335 { 1336 messages::generalError(asyncResp->res); 1337 return; 1338 } 1339 nextNTP = *v4dhcpParms.useNTPServers; 1340 } 1341 else if (v4dhcpParms.useNTPServers) 1342 { 1343 nextNTP = *v4dhcpParms.useNTPServers; 1344 } 1345 else if (v6dhcpParms.useNTPServers) 1346 { 1347 nextNTP = *v6dhcpParms.useNTPServers; 1348 } 1349 else 1350 { 1351 nextNTP = ethData.NTPEnabled; 1352 } 1353 1354 bool nextUseDomain{}; 1355 if (v4dhcpParms.useUseDomainName && v6dhcpParms.useUseDomainName) 1356 { 1357 if (*v4dhcpParms.useUseDomainName != *v6dhcpParms.useUseDomainName) 1358 { 1359 messages::generalError(asyncResp->res); 1360 return; 1361 } 1362 nextUseDomain = *v4dhcpParms.useUseDomainName; 1363 } 1364 else if (v4dhcpParms.useUseDomainName) 1365 { 1366 nextUseDomain = *v4dhcpParms.useUseDomainName; 1367 } 1368 else if (v6dhcpParms.useUseDomainName) 1369 { 1370 nextUseDomain = *v6dhcpParms.useUseDomainName; 1371 } 1372 else 1373 { 1374 nextUseDomain = ethData.HostNameEnabled; 1375 } 1376 1377 BMCWEB_LOG_DEBUG << "set DHCPEnabled..."; 1378 setDHCPEnabled(ifaceId, "DHCPEnabled", nextv4DHCPState, nextv6DHCPState, 1379 asyncResp); 1380 BMCWEB_LOG_DEBUG << "set DNSEnabled..."; 1381 setDHCPv4Config("DNSEnabled", nextDNS, asyncResp); 1382 BMCWEB_LOG_DEBUG << "set NTPEnabled..."; 1383 setDHCPv4Config("NTPEnabled", nextNTP, asyncResp); 1384 BMCWEB_LOG_DEBUG << "set HostNameEnabled..."; 1385 setDHCPv4Config("HostNameEnabled", nextUseDomain, asyncResp); 1386 } 1387 1388 boost::container::flat_set<IPv4AddressData>::const_iterator 1389 GetNextStaticIPEntry( 1390 boost::container::flat_set<IPv4AddressData>::const_iterator head, 1391 boost::container::flat_set<IPv4AddressData>::const_iterator end) 1392 { 1393 for (; head != end; head++) 1394 { 1395 if (head->origin == "Static") 1396 { 1397 return head; 1398 } 1399 } 1400 return end; 1401 } 1402 1403 boost::container::flat_set<IPv6AddressData>::const_iterator 1404 GetNextStaticIPEntry( 1405 boost::container::flat_set<IPv6AddressData>::const_iterator head, 1406 boost::container::flat_set<IPv6AddressData>::const_iterator end) 1407 { 1408 for (; head != end; head++) 1409 { 1410 if (head->origin == "Static") 1411 { 1412 return head; 1413 } 1414 } 1415 return end; 1416 } 1417 1418 void handleIPv4StaticPatch( 1419 const std::string& ifaceId, nlohmann::json& input, 1420 const boost::container::flat_set<IPv4AddressData>& ipv4Data, 1421 const std::shared_ptr<AsyncResp> asyncResp) 1422 { 1423 if ((!input.is_array()) || input.empty()) 1424 { 1425 messages::propertyValueTypeError(asyncResp->res, input.dump(), 1426 "IPv4StaticAddresses"); 1427 return; 1428 } 1429 1430 unsigned entryIdx = 1; 1431 // Find the first static IP address currently active on the NIC and 1432 // match it to the first JSON element in the IPv4StaticAddresses array. 1433 // Match each subsequent JSON element to the next static IP programmed 1434 // into the NIC. 1435 boost::container::flat_set<IPv4AddressData>::const_iterator NICIPentry = 1436 GetNextStaticIPEntry(ipv4Data.cbegin(), ipv4Data.cend()); 1437 1438 for (nlohmann::json& thisJson : input) 1439 { 1440 std::string pathString = 1441 "IPv4StaticAddresses/" + std::to_string(entryIdx); 1442 1443 if (!thisJson.is_null() && !thisJson.empty()) 1444 { 1445 std::optional<std::string> address; 1446 std::optional<std::string> subnetMask; 1447 std::optional<std::string> gateway; 1448 1449 if (!json_util::readJson(thisJson, asyncResp->res, "Address", 1450 address, "SubnetMask", subnetMask, 1451 "Gateway", gateway)) 1452 { 1453 messages::propertyValueFormatError( 1454 asyncResp->res, thisJson.dump(), pathString); 1455 return; 1456 } 1457 1458 // Find the address/subnet/gateway values. Any values that are 1459 // not explicitly provided are assumed to be unmodified from the 1460 // current state of the interface. Merge existing state into the 1461 // current request. 1462 const std::string* addr = nullptr; 1463 const std::string* gw = nullptr; 1464 uint8_t prefixLength = 0; 1465 bool errorInEntry = false; 1466 if (address) 1467 { 1468 if (ipv4VerifyIpAndGetBitcount(*address)) 1469 { 1470 addr = &(*address); 1471 } 1472 else 1473 { 1474 messages::propertyValueFormatError( 1475 asyncResp->res, *address, pathString + "/Address"); 1476 errorInEntry = true; 1477 } 1478 } 1479 else if (NICIPentry != ipv4Data.cend()) 1480 { 1481 addr = &(NICIPentry->address); 1482 } 1483 else 1484 { 1485 messages::propertyMissing(asyncResp->res, 1486 pathString + "/Address"); 1487 errorInEntry = true; 1488 } 1489 1490 if (subnetMask) 1491 { 1492 if (!ipv4VerifyIpAndGetBitcount(*subnetMask, &prefixLength)) 1493 { 1494 messages::propertyValueFormatError( 1495 asyncResp->res, *subnetMask, 1496 pathString + "/SubnetMask"); 1497 errorInEntry = true; 1498 } 1499 } 1500 else if (NICIPentry != ipv4Data.cend()) 1501 { 1502 if (!ipv4VerifyIpAndGetBitcount(NICIPentry->netmask, 1503 &prefixLength)) 1504 { 1505 messages::propertyValueFormatError( 1506 asyncResp->res, NICIPentry->netmask, 1507 pathString + "/SubnetMask"); 1508 errorInEntry = true; 1509 } 1510 } 1511 else 1512 { 1513 messages::propertyMissing(asyncResp->res, 1514 pathString + "/SubnetMask"); 1515 errorInEntry = true; 1516 } 1517 1518 if (gateway) 1519 { 1520 if (ipv4VerifyIpAndGetBitcount(*gateway)) 1521 { 1522 gw = &(*gateway); 1523 } 1524 else 1525 { 1526 messages::propertyValueFormatError( 1527 asyncResp->res, *gateway, pathString + "/Gateway"); 1528 errorInEntry = true; 1529 } 1530 } 1531 else if (NICIPentry != ipv4Data.cend()) 1532 { 1533 gw = &NICIPentry->gateway; 1534 } 1535 else 1536 { 1537 messages::propertyMissing(asyncResp->res, 1538 pathString + "/Gateway"); 1539 errorInEntry = true; 1540 } 1541 1542 if (errorInEntry) 1543 { 1544 return; 1545 } 1546 1547 if (NICIPentry != ipv4Data.cend()) 1548 { 1549 deleteAndCreateIPv4(ifaceId, NICIPentry->id, prefixLength, 1550 *gw, *addr, asyncResp); 1551 NICIPentry = 1552 GetNextStaticIPEntry(++NICIPentry, ipv4Data.cend()); 1553 } 1554 else 1555 { 1556 createIPv4(ifaceId, entryIdx, prefixLength, *gateway, 1557 *address, asyncResp); 1558 } 1559 entryIdx++; 1560 } 1561 else 1562 { 1563 if (NICIPentry == ipv4Data.cend()) 1564 { 1565 // Requesting a DELETE/DO NOT MODIFY action for an item 1566 // that isn't present on the eth(n) interface. Input JSON is 1567 // in error, so bail out. 1568 if (thisJson.is_null()) 1569 { 1570 messages::resourceCannotBeDeleted(asyncResp->res); 1571 return; 1572 } 1573 else 1574 { 1575 messages::propertyValueFormatError( 1576 asyncResp->res, thisJson.dump(), pathString); 1577 return; 1578 } 1579 } 1580 1581 if (thisJson.is_null()) 1582 { 1583 deleteIPv4(ifaceId, NICIPentry->id, asyncResp); 1584 } 1585 if (NICIPentry != ipv4Data.cend()) 1586 { 1587 NICIPentry = 1588 GetNextStaticIPEntry(++NICIPentry, ipv4Data.cend()); 1589 } 1590 entryIdx++; 1591 } 1592 } 1593 } 1594 1595 void handleStaticNameServersPatch( 1596 const std::string& ifaceId, 1597 const std::vector<std::string>& updatedStaticNameServers, 1598 const std::shared_ptr<AsyncResp>& asyncResp) 1599 { 1600 crow::connections::systemBus->async_method_call( 1601 [asyncResp](const boost::system::error_code ec) { 1602 if (ec) 1603 { 1604 messages::internalError(asyncResp->res); 1605 return; 1606 } 1607 }, 1608 "xyz.openbmc_project.Network", 1609 "/xyz/openbmc_project/network/" + ifaceId, 1610 "org.freedesktop.DBus.Properties", "Set", 1611 "xyz.openbmc_project.Network.EthernetInterface", 1612 "StaticNameServers", 1613 std::variant<std::vector<std::string>>{updatedStaticNameServers}); 1614 } 1615 1616 void handleIPv6StaticAddressesPatch( 1617 const std::string& ifaceId, nlohmann::json& input, 1618 const boost::container::flat_set<IPv6AddressData>& ipv6Data, 1619 const std::shared_ptr<AsyncResp> asyncResp) 1620 { 1621 if (!input.is_array() || input.empty()) 1622 { 1623 messages::propertyValueTypeError(asyncResp->res, input.dump(), 1624 "IPv6StaticAddresses"); 1625 return; 1626 } 1627 size_t entryIdx = 1; 1628 boost::container::flat_set<IPv6AddressData>::const_iterator NICIPentry = 1629 GetNextStaticIPEntry(ipv6Data.cbegin(), ipv6Data.cend()); 1630 for (nlohmann::json& thisJson : input) 1631 { 1632 std::string pathString = 1633 "IPv6StaticAddresses/" + std::to_string(entryIdx); 1634 1635 if (!thisJson.is_null() && !thisJson.empty()) 1636 { 1637 std::optional<std::string> address; 1638 std::optional<uint8_t> prefixLength; 1639 1640 if (!json_util::readJson(thisJson, asyncResp->res, "Address", 1641 address, "PrefixLength", prefixLength)) 1642 { 1643 messages::propertyValueFormatError( 1644 asyncResp->res, thisJson.dump(), pathString); 1645 return; 1646 } 1647 1648 const std::string* addr; 1649 uint8_t prefix; 1650 1651 // Find the address and prefixLength values. Any values that are 1652 // not explicitly provided are assumed to be unmodified from the 1653 // current state of the interface. Merge existing state into the 1654 // current request. 1655 if (address) 1656 { 1657 addr = &(*address); 1658 } 1659 else if (NICIPentry != ipv6Data.end()) 1660 { 1661 addr = &(NICIPentry->address); 1662 } 1663 else 1664 { 1665 messages::propertyMissing(asyncResp->res, 1666 pathString + "/Address"); 1667 return; 1668 } 1669 1670 if (prefixLength) 1671 { 1672 prefix = *prefixLength; 1673 } 1674 else if (NICIPentry != ipv6Data.end()) 1675 { 1676 prefix = NICIPentry->prefixLength; 1677 } 1678 else 1679 { 1680 messages::propertyMissing(asyncResp->res, 1681 pathString + "/PrefixLength"); 1682 return; 1683 } 1684 1685 if (NICIPentry != ipv6Data.end()) 1686 { 1687 deleteAndCreateIPv6(ifaceId, NICIPentry->id, prefix, *addr, 1688 asyncResp); 1689 NICIPentry = 1690 GetNextStaticIPEntry(++NICIPentry, ipv6Data.cend()); 1691 } 1692 else 1693 { 1694 createIPv6(ifaceId, *prefixLength, *addr, asyncResp); 1695 } 1696 entryIdx++; 1697 } 1698 else 1699 { 1700 if (NICIPentry == ipv6Data.end()) 1701 { 1702 // Requesting a DELETE/DO NOT MODIFY action for an item 1703 // that isn't present on the eth(n) interface. Input JSON is 1704 // in error, so bail out. 1705 if (thisJson.is_null()) 1706 { 1707 messages::resourceCannotBeDeleted(asyncResp->res); 1708 return; 1709 } 1710 else 1711 { 1712 messages::propertyValueFormatError( 1713 asyncResp->res, thisJson.dump(), pathString); 1714 return; 1715 } 1716 } 1717 1718 if (thisJson.is_null()) 1719 { 1720 deleteIPv6(ifaceId, NICIPentry->id, asyncResp); 1721 } 1722 if (NICIPentry != ipv6Data.cend()) 1723 { 1724 NICIPentry = 1725 GetNextStaticIPEntry(++NICIPentry, ipv6Data.cend()); 1726 } 1727 entryIdx++; 1728 } 1729 } 1730 } 1731 1732 void parseInterfaceData( 1733 std::shared_ptr<AsyncResp> asyncResp, const std::string& iface_id, 1734 const EthernetInterfaceData& ethData, 1735 const boost::container::flat_set<IPv4AddressData>& ipv4Data, 1736 const boost::container::flat_set<IPv6AddressData>& ipv6Data) 1737 { 1738 constexpr const std::array<const char*, 1> inventoryForEthernet = { 1739 "xyz.openbmc_project.Inventory.Item.Ethernet"}; 1740 1741 nlohmann::json& json_response = asyncResp->res.jsonValue; 1742 json_response["Id"] = iface_id; 1743 json_response["@odata.id"] = 1744 "/redfish/v1/Managers/bmc/EthernetInterfaces/" + iface_id; 1745 json_response["InterfaceEnabled"] = ethData.nicEnabled; 1746 1747 auto health = std::make_shared<HealthPopulate>(asyncResp); 1748 1749 crow::connections::systemBus->async_method_call( 1750 [health](const boost::system::error_code ec, 1751 std::vector<std::string>& resp) { 1752 if (ec) 1753 { 1754 return; 1755 } 1756 1757 health->inventory = std::move(resp); 1758 }, 1759 "xyz.openbmc_project.ObjectMapper", 1760 "/xyz/openbmc_project/object_mapper", 1761 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths", "/", 1762 int32_t(0), inventoryForEthernet); 1763 1764 health->populate(); 1765 1766 if (ethData.nicEnabled) 1767 { 1768 json_response["LinkStatus"] = "LinkUp"; 1769 json_response["Status"]["State"] = "Enabled"; 1770 } 1771 else 1772 { 1773 json_response["LinkStatus"] = "NoLink"; 1774 json_response["Status"]["State"] = "Disabled"; 1775 } 1776 1777 json_response["LinkStatus"] = ethData.linkUp ? "LinkUp" : "LinkDown"; 1778 json_response["SpeedMbps"] = ethData.speed; 1779 json_response["MACAddress"] = ethData.mac_address; 1780 json_response["DHCPv4"]["DHCPEnabled"] = 1781 translateDHCPEnabledToBool(ethData.DHCPEnabled, true); 1782 json_response["DHCPv4"]["UseNTPServers"] = ethData.NTPEnabled; 1783 json_response["DHCPv4"]["UseDNSServers"] = ethData.DNSEnabled; 1784 json_response["DHCPv4"]["UseDomainName"] = ethData.HostNameEnabled; 1785 1786 json_response["DHCPv6"]["OperatingMode"] = 1787 translateDHCPEnabledToBool(ethData.DHCPEnabled, false) ? "Stateful" 1788 : "Disabled"; 1789 json_response["DHCPv6"]["UseNTPServers"] = ethData.NTPEnabled; 1790 json_response["DHCPv6"]["UseDNSServers"] = ethData.DNSEnabled; 1791 json_response["DHCPv6"]["UseDomainName"] = ethData.HostNameEnabled; 1792 1793 if (!ethData.hostname.empty()) 1794 { 1795 json_response["HostName"] = ethData.hostname; 1796 1797 // When domain name is empty then it means, that it is a network 1798 // without domain names, and the host name itself must be treated as 1799 // FQDN 1800 std::string FQDN = std::move(ethData.hostname); 1801 if (!ethData.domainnames.empty()) 1802 { 1803 FQDN += "." + ethData.domainnames[0]; 1804 } 1805 json_response["FQDN"] = FQDN; 1806 } 1807 1808 json_response["VLANs"] = { 1809 {"@odata.id", "/redfish/v1/Managers/bmc/EthernetInterfaces/" + 1810 iface_id + "/VLANs"}}; 1811 1812 json_response["NameServers"] = ethData.nameServers; 1813 json_response["StaticNameServers"] = ethData.staticNameServers; 1814 1815 nlohmann::json& ipv4_array = json_response["IPv4Addresses"]; 1816 nlohmann::json& ipv4_static_array = 1817 json_response["IPv4StaticAddresses"]; 1818 ipv4_array = nlohmann::json::array(); 1819 ipv4_static_array = nlohmann::json::array(); 1820 for (auto& ipv4_config : ipv4Data) 1821 { 1822 1823 std::string gatewayStr = ipv4_config.gateway; 1824 if (gatewayStr.empty()) 1825 { 1826 gatewayStr = "0.0.0.0"; 1827 } 1828 1829 ipv4_array.push_back({{"AddressOrigin", ipv4_config.origin}, 1830 {"SubnetMask", ipv4_config.netmask}, 1831 {"Address", ipv4_config.address}, 1832 {"Gateway", gatewayStr}}); 1833 if (ipv4_config.origin == "Static") 1834 { 1835 ipv4_static_array.push_back( 1836 {{"AddressOrigin", ipv4_config.origin}, 1837 {"SubnetMask", ipv4_config.netmask}, 1838 {"Address", ipv4_config.address}, 1839 {"Gateway", gatewayStr}}); 1840 } 1841 } 1842 1843 json_response["IPv6DefaultGateway"] = ethData.ipv6_default_gateway; 1844 1845 nlohmann::json& ipv6_array = json_response["IPv6Addresses"]; 1846 nlohmann::json& ipv6_static_array = 1847 json_response["IPv6StaticAddresses"]; 1848 ipv6_array = nlohmann::json::array(); 1849 ipv6_static_array = nlohmann::json::array(); 1850 nlohmann::json& ipv6AddrPolicyTable = 1851 json_response["IPv6AddressPolicyTable"]; 1852 ipv6AddrPolicyTable = nlohmann::json::array(); 1853 for (auto& ipv6_config : ipv6Data) 1854 { 1855 ipv6_array.push_back({{"Address", ipv6_config.address}, 1856 {"PrefixLength", ipv6_config.prefixLength}, 1857 {"AddressOrigin", ipv6_config.origin}, 1858 {"AddressState", nullptr}}); 1859 if (ipv6_config.origin == "Static") 1860 { 1861 ipv6_static_array.push_back( 1862 {{"Address", ipv6_config.address}, 1863 {"PrefixLength", ipv6_config.prefixLength}, 1864 {"AddressOrigin", ipv6_config.origin}, 1865 {"AddressState", nullptr}}); 1866 } 1867 } 1868 } 1869 1870 /** 1871 * Functions triggers appropriate requests on DBus 1872 */ 1873 void doGet(crow::Response& res, const crow::Request& req, 1874 const std::vector<std::string>& params) override 1875 { 1876 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res); 1877 if (params.size() != 1) 1878 { 1879 messages::internalError(asyncResp->res); 1880 return; 1881 } 1882 1883 getEthernetIfaceData( 1884 params[0], 1885 [this, asyncResp, iface_id{std::string(params[0])}]( 1886 const bool& success, const EthernetInterfaceData& ethData, 1887 const boost::container::flat_set<IPv4AddressData>& ipv4Data, 1888 const boost::container::flat_set<IPv6AddressData>& ipv6Data) { 1889 if (!success) 1890 { 1891 // TODO(Pawel)consider distinguish between non existing 1892 // object, and other errors 1893 messages::resourceNotFound(asyncResp->res, 1894 "EthernetInterface", iface_id); 1895 return; 1896 } 1897 1898 asyncResp->res.jsonValue["@odata.type"] = 1899 "#EthernetInterface.v1_4_1.EthernetInterface"; 1900 asyncResp->res.jsonValue["Name"] = "Manager Ethernet Interface"; 1901 asyncResp->res.jsonValue["Description"] = 1902 "Management Network Interface"; 1903 1904 parseInterfaceData(asyncResp, iface_id, ethData, ipv4Data, 1905 ipv6Data); 1906 }); 1907 } 1908 1909 void doPatch(crow::Response& res, const crow::Request& req, 1910 const std::vector<std::string>& params) override 1911 { 1912 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res); 1913 if (params.size() != 1) 1914 { 1915 messages::internalError(asyncResp->res); 1916 return; 1917 } 1918 1919 const std::string& iface_id = params[0]; 1920 1921 std::optional<std::string> hostname; 1922 std::optional<std::string> fqdn; 1923 std::optional<std::string> macAddress; 1924 std::optional<std::string> ipv6DefaultGateway; 1925 std::optional<nlohmann::json> ipv4StaticAddresses; 1926 std::optional<nlohmann::json> ipv6StaticAddresses; 1927 std::optional<std::vector<std::string>> staticNameServers; 1928 std::optional<nlohmann::json> dhcpv4; 1929 std::optional<nlohmann::json> dhcpv6; 1930 std::optional<bool> interfaceEnabled; 1931 DHCPParameters v4dhcpParms; 1932 DHCPParameters v6dhcpParms; 1933 1934 if (!json_util::readJson( 1935 req, res, "HostName", hostname, "FQDN", fqdn, 1936 "IPv4StaticAddresses", ipv4StaticAddresses, "MACAddress", 1937 macAddress, "StaticNameServers", staticNameServers, 1938 "IPv6DefaultGateway", ipv6DefaultGateway, "IPv6StaticAddresses", 1939 ipv6StaticAddresses, "DHCPv4", dhcpv4, "DHCPv6", dhcpv6, 1940 "InterfaceEnabled", interfaceEnabled)) 1941 { 1942 return; 1943 } 1944 if (dhcpv4) 1945 { 1946 if (!json_util::readJson(*dhcpv4, res, "DHCPEnabled", 1947 v4dhcpParms.dhcpv4Enabled, "UseDNSServers", 1948 v4dhcpParms.useDNSServers, "UseNTPServers", 1949 v4dhcpParms.useNTPServers, "UseDomainName", 1950 v4dhcpParms.useUseDomainName)) 1951 { 1952 return; 1953 } 1954 } 1955 1956 if (dhcpv6) 1957 { 1958 if (!json_util::readJson(*dhcpv6, res, "OperatingMode", 1959 v6dhcpParms.dhcpv6OperatingMode, 1960 "UseDNSServers", v6dhcpParms.useDNSServers, 1961 "UseNTPServers", v6dhcpParms.useNTPServers, 1962 "UseDomainName", 1963 v6dhcpParms.useUseDomainName)) 1964 { 1965 return; 1966 } 1967 } 1968 1969 // Get single eth interface data, and call the below callback for 1970 // JSON preparation 1971 getEthernetIfaceData( 1972 iface_id, 1973 [this, asyncResp, iface_id, hostname = std::move(hostname), 1974 fqdn = std::move(fqdn), macAddress = std::move(macAddress), 1975 ipv4StaticAddresses = std::move(ipv4StaticAddresses), 1976 ipv6DefaultGateway = std::move(ipv6DefaultGateway), 1977 ipv6StaticAddresses = std::move(ipv6StaticAddresses), 1978 staticNameServers = std::move(staticNameServers), 1979 dhcpv4 = std::move(dhcpv4), dhcpv6 = std::move(dhcpv6), 1980 v4dhcpParms = std::move(v4dhcpParms), 1981 v6dhcpParms = std::move(v6dhcpParms), 1982 interfaceEnabled = std::move(interfaceEnabled)]( 1983 const bool& success, const EthernetInterfaceData& ethData, 1984 const boost::container::flat_set<IPv4AddressData>& ipv4Data, 1985 const boost::container::flat_set<IPv6AddressData>& ipv6Data) { 1986 if (!success) 1987 { 1988 // ... otherwise return error 1989 // TODO(Pawel)consider distinguish between non existing 1990 // object, and other errors 1991 messages::resourceNotFound(asyncResp->res, 1992 "Ethernet Interface", iface_id); 1993 return; 1994 } 1995 1996 if (dhcpv4 || dhcpv6) 1997 { 1998 handleDHCPPatch(iface_id, ethData, std::move(v4dhcpParms), 1999 std::move(v6dhcpParms), asyncResp); 2000 } 2001 2002 if (hostname) 2003 { 2004 handleHostnamePatch(*hostname, asyncResp); 2005 } 2006 2007 if (fqdn) 2008 { 2009 handleFqdnPatch(iface_id, *fqdn, asyncResp); 2010 } 2011 2012 if (macAddress) 2013 { 2014 handleMACAddressPatch(iface_id, *macAddress, asyncResp); 2015 } 2016 2017 if (ipv4StaticAddresses) 2018 { 2019 // TODO(ed) for some reason the capture of ipv4Addresses 2020 // above is returning a const value, not a non-const 2021 // value. This doesn't really work for us, as we need to 2022 // be able to efficiently move out the intermedia 2023 // nlohmann::json objects. This makes a copy of the 2024 // structure, and operates on that, but could be done 2025 // more efficiently 2026 nlohmann::json ipv4Static = std::move(*ipv4StaticAddresses); 2027 handleIPv4StaticPatch(iface_id, ipv4Static, ipv4Data, 2028 asyncResp); 2029 } 2030 2031 if (staticNameServers) 2032 { 2033 handleStaticNameServersPatch(iface_id, *staticNameServers, 2034 asyncResp); 2035 } 2036 2037 if (ipv6DefaultGateway) 2038 { 2039 messages::propertyNotWritable(asyncResp->res, 2040 "IPv6DefaultGateway"); 2041 } 2042 2043 if (ipv6StaticAddresses) 2044 { 2045 nlohmann::json ipv6Static = std::move(*ipv6StaticAddresses); 2046 handleIPv6StaticAddressesPatch(iface_id, ipv6Static, 2047 ipv6Data, asyncResp); 2048 } 2049 2050 if (interfaceEnabled) 2051 { 2052 setEthernetInterfaceBoolProperty( 2053 iface_id, "NICEnabled", *interfaceEnabled, asyncResp); 2054 } 2055 }); 2056 } 2057 }; 2058 2059 /** 2060 * VlanNetworkInterface derived class for delivering VLANNetworkInterface 2061 * Schema 2062 */ 2063 class VlanNetworkInterface : public Node 2064 { 2065 public: 2066 /* 2067 * Default Constructor 2068 */ 2069 template <typename CrowApp> 2070 VlanNetworkInterface(CrowApp& app) : 2071 Node(app, 2072 "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/<str>/", 2073 std::string(), std::string()) 2074 { 2075 entityPrivileges = { 2076 {boost::beast::http::verb::get, {{"Login"}}}, 2077 {boost::beast::http::verb::head, {{"Login"}}}, 2078 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}}, 2079 {boost::beast::http::verb::put, {{"ConfigureComponents"}}}, 2080 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}}, 2081 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; 2082 } 2083 2084 private: 2085 void parseInterfaceData( 2086 nlohmann::json& json_response, const std::string& parent_iface_id, 2087 const std::string& iface_id, const EthernetInterfaceData& ethData, 2088 const boost::container::flat_set<IPv4AddressData>& ipv4Data, 2089 const boost::container::flat_set<IPv6AddressData>& ipv6Data) 2090 { 2091 // Fill out obvious data... 2092 json_response["Id"] = iface_id; 2093 json_response["@odata.id"] = 2094 "/redfish/v1/Managers/bmc/EthernetInterfaces/" + parent_iface_id + 2095 "/VLANs/" + iface_id; 2096 2097 json_response["VLANEnable"] = true; 2098 if (!ethData.vlan_id.empty()) 2099 { 2100 json_response["VLANId"] = ethData.vlan_id.back(); 2101 } 2102 } 2103 2104 bool verifyNames(const std::string& parent, const std::string& iface) 2105 { 2106 if (!boost::starts_with(iface, parent + "_")) 2107 { 2108 return false; 2109 } 2110 else 2111 { 2112 return true; 2113 } 2114 } 2115 2116 /** 2117 * Functions triggers appropriate requests on DBus 2118 */ 2119 void doGet(crow::Response& res, const crow::Request& req, 2120 const std::vector<std::string>& params) override 2121 { 2122 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res); 2123 // TODO(Pawel) this shall be parameterized call (two params) to get 2124 // EthernetInterfaces for any Manager, not only hardcoded 'openbmc'. 2125 // Check if there is required param, truly entering this shall be 2126 // impossible. 2127 if (params.size() != 2) 2128 { 2129 messages::internalError(res); 2130 res.end(); 2131 return; 2132 } 2133 2134 const std::string& parent_iface_id = params[0]; 2135 const std::string& iface_id = params[1]; 2136 res.jsonValue["@odata.type"] = 2137 "#VLanNetworkInterface.v1_1_0.VLanNetworkInterface"; 2138 res.jsonValue["Name"] = "VLAN Network Interface"; 2139 2140 if (!verifyNames(parent_iface_id, iface_id)) 2141 { 2142 return; 2143 } 2144 2145 // Get single eth interface data, and call the below callback for 2146 // JSON preparation 2147 getEthernetIfaceData( 2148 params[1], 2149 [this, asyncResp, parent_iface_id{std::string(params[0])}, 2150 iface_id{std::string(params[1])}]( 2151 const bool& success, const EthernetInterfaceData& ethData, 2152 const boost::container::flat_set<IPv4AddressData>& ipv4Data, 2153 const boost::container::flat_set<IPv6AddressData>& ipv6Data) { 2154 if (success && ethData.vlan_id.size() != 0) 2155 { 2156 parseInterfaceData(asyncResp->res.jsonValue, 2157 parent_iface_id, iface_id, ethData, 2158 ipv4Data, ipv6Data); 2159 } 2160 else 2161 { 2162 // ... otherwise return error 2163 // TODO(Pawel)consider distinguish between non existing 2164 // object, and other errors 2165 messages::resourceNotFound( 2166 asyncResp->res, "VLAN Network Interface", iface_id); 2167 } 2168 }); 2169 } 2170 2171 void doPatch(crow::Response& res, const crow::Request& req, 2172 const std::vector<std::string>& params) override 2173 { 2174 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res); 2175 if (params.size() != 2) 2176 { 2177 messages::internalError(asyncResp->res); 2178 return; 2179 } 2180 2181 const std::string& parentIfaceId = params[0]; 2182 const std::string& ifaceId = params[1]; 2183 2184 if (!verifyNames(parentIfaceId, ifaceId)) 2185 { 2186 messages::resourceNotFound(asyncResp->res, "VLAN Network Interface", 2187 ifaceId); 2188 return; 2189 } 2190 2191 bool vlanEnable = false; 2192 uint32_t vlanId = 0; 2193 2194 if (!json_util::readJson(req, res, "VLANEnable", vlanEnable, "VLANId", 2195 vlanId)) 2196 { 2197 return; 2198 } 2199 2200 // Get single eth interface data, and call the below callback for 2201 // JSON preparation 2202 getEthernetIfaceData( 2203 params[1], 2204 [asyncResp, parentIfaceId{std::string(params[0])}, 2205 ifaceId{std::string(params[1])}, &vlanEnable, &vlanId]( 2206 const bool& success, const EthernetInterfaceData& ethData, 2207 const boost::container::flat_set<IPv4AddressData>& ipv4Data, 2208 const boost::container::flat_set<IPv6AddressData>& ipv6Data) { 2209 if (success && !ethData.vlan_id.empty()) 2210 { 2211 auto callback = 2212 [asyncResp](const boost::system::error_code ec) { 2213 if (ec) 2214 { 2215 messages::internalError(asyncResp->res); 2216 } 2217 }; 2218 2219 if (vlanEnable == true) 2220 { 2221 crow::connections::systemBus->async_method_call( 2222 std::move(callback), "xyz.openbmc_project.Network", 2223 "/xyz/openbmc_project/network/" + ifaceId, 2224 "org.freedesktop.DBus.Properties", "Set", 2225 "xyz.openbmc_project.Network.VLAN", "Id", 2226 std::variant<uint32_t>(vlanId)); 2227 } 2228 else 2229 { 2230 BMCWEB_LOG_DEBUG << "vlanEnable is false. Deleting the " 2231 "vlan interface"; 2232 crow::connections::systemBus->async_method_call( 2233 std::move(callback), "xyz.openbmc_project.Network", 2234 std::string("/xyz/openbmc_project/network/") + 2235 ifaceId, 2236 "xyz.openbmc_project.Object.Delete", "Delete"); 2237 } 2238 } 2239 else 2240 { 2241 // TODO(Pawel)consider distinguish between non existing 2242 // object, and other errors 2243 messages::resourceNotFound( 2244 asyncResp->res, "VLAN Network Interface", ifaceId); 2245 return; 2246 } 2247 }); 2248 } 2249 2250 void doDelete(crow::Response& res, const crow::Request& req, 2251 const std::vector<std::string>& params) override 2252 { 2253 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res); 2254 if (params.size() != 2) 2255 { 2256 messages::internalError(asyncResp->res); 2257 return; 2258 } 2259 2260 const std::string& parentIfaceId = params[0]; 2261 const std::string& ifaceId = params[1]; 2262 2263 if (!verifyNames(parentIfaceId, ifaceId)) 2264 { 2265 messages::resourceNotFound(asyncResp->res, "VLAN Network Interface", 2266 ifaceId); 2267 return; 2268 } 2269 2270 // Get single eth interface data, and call the below callback for 2271 // JSON preparation 2272 getEthernetIfaceData( 2273 params[1], 2274 [asyncResp, parentIfaceId{std::string(params[0])}, 2275 ifaceId{std::string(params[1])}]( 2276 const bool& success, const EthernetInterfaceData& ethData, 2277 const boost::container::flat_set<IPv4AddressData>& ipv4Data, 2278 const boost::container::flat_set<IPv6AddressData>& ipv6Data) { 2279 if (success && !ethData.vlan_id.empty()) 2280 { 2281 auto callback = 2282 [asyncResp](const boost::system::error_code ec) { 2283 if (ec) 2284 { 2285 messages::internalError(asyncResp->res); 2286 } 2287 }; 2288 crow::connections::systemBus->async_method_call( 2289 std::move(callback), "xyz.openbmc_project.Network", 2290 std::string("/xyz/openbmc_project/network/") + ifaceId, 2291 "xyz.openbmc_project.Object.Delete", "Delete"); 2292 } 2293 else 2294 { 2295 // ... otherwise return error 2296 // TODO(Pawel)consider distinguish between non existing 2297 // object, and other errors 2298 messages::resourceNotFound( 2299 asyncResp->res, "VLAN Network Interface", ifaceId); 2300 } 2301 }); 2302 } 2303 }; 2304 2305 /** 2306 * VlanNetworkInterfaceCollection derived class for delivering 2307 * VLANNetworkInterface Collection Schema 2308 */ 2309 class VlanNetworkInterfaceCollection : public Node 2310 { 2311 public: 2312 template <typename CrowApp> 2313 VlanNetworkInterfaceCollection(CrowApp& app) : 2314 Node(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/", 2315 std::string()) 2316 { 2317 entityPrivileges = { 2318 {boost::beast::http::verb::get, {{"Login"}}}, 2319 {boost::beast::http::verb::head, {{"Login"}}}, 2320 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}}, 2321 {boost::beast::http::verb::put, {{"ConfigureComponents"}}}, 2322 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}}, 2323 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; 2324 } 2325 2326 private: 2327 /** 2328 * Functions triggers appropriate requests on DBus 2329 */ 2330 void doGet(crow::Response& res, const crow::Request& req, 2331 const std::vector<std::string>& params) override 2332 { 2333 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res); 2334 if (params.size() != 1) 2335 { 2336 // This means there is a problem with the router 2337 messages::internalError(asyncResp->res); 2338 return; 2339 } 2340 2341 const std::string& rootInterfaceName = params[0]; 2342 2343 // Get eth interface list, and call the below callback for JSON 2344 // preparation 2345 getEthernetIfaceList( 2346 [asyncResp, rootInterfaceName{std::string(rootInterfaceName)}]( 2347 const bool& success, 2348 const boost::container::flat_set<std::string>& iface_list) { 2349 if (!success) 2350 { 2351 messages::internalError(asyncResp->res); 2352 return; 2353 } 2354 2355 if (iface_list.find(rootInterfaceName) == iface_list.end()) 2356 { 2357 messages::resourceNotFound(asyncResp->res, 2358 "VLanNetworkInterfaceCollection", 2359 rootInterfaceName); 2360 return; 2361 } 2362 2363 asyncResp->res.jsonValue["@odata.type"] = 2364 "#VLanNetworkInterfaceCollection." 2365 "VLanNetworkInterfaceCollection"; 2366 asyncResp->res.jsonValue["Name"] = 2367 "VLAN Network Interface Collection"; 2368 2369 nlohmann::json iface_array = nlohmann::json::array(); 2370 2371 for (const std::string& iface_item : iface_list) 2372 { 2373 if (boost::starts_with(iface_item, rootInterfaceName + "_")) 2374 { 2375 iface_array.push_back( 2376 {{"@odata.id", 2377 "/redfish/v1/Managers/bmc/EthernetInterfaces/" + 2378 rootInterfaceName + "/VLANs/" + iface_item}}); 2379 } 2380 } 2381 2382 asyncResp->res.jsonValue["Members@odata.count"] = 2383 iface_array.size(); 2384 asyncResp->res.jsonValue["Members"] = std::move(iface_array); 2385 asyncResp->res.jsonValue["@odata.id"] = 2386 "/redfish/v1/Managers/bmc/EthernetInterfaces/" + 2387 rootInterfaceName + "/VLANs"; 2388 }); 2389 } 2390 2391 void doPost(crow::Response& res, const crow::Request& req, 2392 const std::vector<std::string>& params) override 2393 { 2394 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res); 2395 if (params.size() != 1) 2396 { 2397 messages::internalError(asyncResp->res); 2398 return; 2399 } 2400 bool vlanEnable = false; 2401 uint32_t vlanId = 0; 2402 if (!json_util::readJson(req, res, "VLANId", vlanId, "VLANEnable", 2403 vlanEnable)) 2404 { 2405 return; 2406 } 2407 // Need both vlanId and vlanEnable to service this request 2408 if (!vlanId) 2409 { 2410 messages::propertyMissing(asyncResp->res, "VLANId"); 2411 } 2412 if (!vlanEnable) 2413 { 2414 messages::propertyMissing(asyncResp->res, "VLANEnable"); 2415 } 2416 if (static_cast<bool>(vlanId) ^ vlanEnable) 2417 { 2418 return; 2419 } 2420 2421 const std::string& rootInterfaceName = params[0]; 2422 auto callback = [asyncResp](const boost::system::error_code ec) { 2423 if (ec) 2424 { 2425 // TODO(ed) make more consistent error messages based on 2426 // phosphor-network responses 2427 messages::internalError(asyncResp->res); 2428 return; 2429 } 2430 messages::created(asyncResp->res); 2431 }; 2432 crow::connections::systemBus->async_method_call( 2433 std::move(callback), "xyz.openbmc_project.Network", 2434 "/xyz/openbmc_project/network", 2435 "xyz.openbmc_project.Network.VLAN.Create", "VLAN", 2436 rootInterfaceName, vlanId); 2437 } 2438 }; 2439 } // namespace redfish 2440