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