1 /** 2 * Copyright © 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 #include "config.h" 17 18 #include "settings.hpp" 19 20 #include <dlfcn.h> 21 22 #include <boost/algorithm/string.hpp> 23 #include <boost/asio/io_context.hpp> 24 #include <host-cmd-manager.hpp> 25 #include <ipmid-host/cmd.hpp> 26 #include <ipmid/api.hpp> 27 #include <ipmid/handler.hpp> 28 #include <ipmid/message.hpp> 29 #include <ipmid/oemrouter.hpp> 30 #include <ipmid/types.hpp> 31 #include <phosphor-logging/lg2.hpp> 32 #include <sdbusplus/asio/connection.hpp> 33 #include <sdbusplus/asio/object_server.hpp> 34 #include <sdbusplus/asio/sd_event.hpp> 35 #include <sdbusplus/bus.hpp> 36 #include <sdbusplus/bus/match.hpp> 37 #include <sdbusplus/timer.hpp> 38 39 #include <algorithm> 40 #include <any> 41 #include <exception> 42 #include <filesystem> 43 #include <forward_list> 44 #include <map> 45 #include <memory> 46 #include <optional> 47 #include <tuple> 48 #include <unordered_map> 49 #include <utility> 50 #include <vector> 51 52 namespace fs = std::filesystem; 53 54 using namespace phosphor::logging; 55 56 // IPMI Spec, shared Reservation ID. 57 static unsigned short selReservationID = 0xFFFF; 58 static bool selReservationValid = false; 59 60 unsigned short reserveSel(void) 61 { 62 // IPMI spec, Reservation ID, the value simply increases against each 63 // execution of the Reserve SEL command. 64 if (++selReservationID == 0) 65 { 66 selReservationID = 1; 67 } 68 selReservationValid = true; 69 return selReservationID; 70 } 71 72 bool checkSELReservation(unsigned short id) 73 { 74 return (selReservationValid && selReservationID == id); 75 } 76 77 void cancelSELReservation(void) 78 { 79 selReservationValid = false; 80 } 81 82 EInterfaceIndex getInterfaceIndex(void) 83 { 84 return interfaceKCS; 85 } 86 87 sd_bus* bus; 88 sd_event* events = nullptr; 89 sd_event* ipmid_get_sd_event_connection(void) 90 { 91 return events; 92 } 93 sd_bus* ipmid_get_sd_bus_connection(void) 94 { 95 return bus; 96 } 97 98 namespace ipmi 99 { 100 101 static inline unsigned int makeCmdKey(unsigned int cluster, unsigned int cmd) 102 { 103 return (cluster << 8) | cmd; 104 } 105 106 using HandlerTuple = std::tuple<int, /* prio */ 107 Privilege, HandlerBase::ptr /* handler */ 108 >; 109 110 /* map to handle standard registered commands */ 111 static std::unordered_map<unsigned int, /* key is NetFn/Cmd */ 112 HandlerTuple> 113 handlerMap; 114 115 /* special map for decoding Group registered commands (NetFn 2Ch) */ 116 static std::unordered_map<unsigned int, /* key is Group/Cmd (NetFn is 2Ch) */ 117 HandlerTuple> 118 groupHandlerMap; 119 120 /* special map for decoding OEM registered commands (NetFn 2Eh) */ 121 static std::unordered_map<unsigned int, /* key is Iana/Cmd (NetFn is 2Eh) */ 122 HandlerTuple> 123 oemHandlerMap; 124 125 using FilterTuple = std::tuple<int, /* prio */ 126 FilterBase::ptr /* filter */ 127 >; 128 129 /* list to hold all registered ipmi command filters */ 130 static std::forward_list<FilterTuple> filterList; 131 132 namespace impl 133 { 134 /* common function to register all standard IPMI handlers */ 135 bool registerHandler(int prio, NetFn netFn, Cmd cmd, Privilege priv, 136 HandlerBase::ptr handler) 137 { 138 // check for valid NetFn: even; 00-0Ch, 30-3Eh 139 if (netFn & 1 || (netFn > netFnTransport && netFn < netFnGroup) || 140 netFn > netFnOemEight) 141 { 142 return false; 143 } 144 145 // create key and value for this handler 146 unsigned int netFnCmd = makeCmdKey(netFn, cmd); 147 HandlerTuple item(prio, priv, handler); 148 149 // consult the handler map and look for a match 150 auto& mapCmd = handlerMap[netFnCmd]; 151 if (!std::get<HandlerBase::ptr>(mapCmd) || std::get<int>(mapCmd) <= prio) 152 { 153 mapCmd = item; 154 return true; 155 } 156 return false; 157 } 158 159 /* common function to register all Group IPMI handlers */ 160 bool registerGroupHandler(int prio, Group group, Cmd cmd, Privilege priv, 161 HandlerBase::ptr handler) 162 { 163 // create key and value for this handler 164 unsigned int netFnCmd = makeCmdKey(group, cmd); 165 HandlerTuple item(prio, priv, handler); 166 167 // consult the handler map and look for a match 168 auto& mapCmd = groupHandlerMap[netFnCmd]; 169 if (!std::get<HandlerBase::ptr>(mapCmd) || std::get<int>(mapCmd) <= prio) 170 { 171 mapCmd = item; 172 return true; 173 } 174 return false; 175 } 176 177 /* common function to register all OEM IPMI handlers */ 178 bool registerOemHandler(int prio, Iana iana, Cmd cmd, Privilege priv, 179 HandlerBase::ptr handler) 180 { 181 // create key and value for this handler 182 unsigned int netFnCmd = makeCmdKey(iana, cmd); 183 HandlerTuple item(prio, priv, handler); 184 185 // consult the handler map and look for a match 186 auto& mapCmd = oemHandlerMap[netFnCmd]; 187 if (!std::get<HandlerBase::ptr>(mapCmd) || std::get<int>(mapCmd) <= prio) 188 { 189 mapCmd = item; 190 lg2::debug("registered OEM Handler: NetFn/Cmd={NETFNCMD}", "IANA", 191 lg2::hex, iana, "CMD", lg2::hex, cmd, "NETFNCMD", lg2::hex, 192 netFnCmd); 193 return true; 194 } 195 196 lg2::warning("could not register OEM Handler: NetFn/Cmd={NETFNCMD}", "IANA", 197 lg2::hex, iana, "CMD", lg2::hex, cmd, "NETFNCMD", lg2::hex, 198 netFnCmd); 199 return false; 200 } 201 202 /* common function to register all IPMI filter handlers */ 203 void registerFilter(int prio, FilterBase::ptr filter) 204 { 205 // check for initial placement 206 if (filterList.empty() || std::get<int>(filterList.front()) < prio) 207 { 208 filterList.emplace_front(std::make_tuple(prio, filter)); 209 return; 210 } 211 // walk the list and put it in the right place 212 auto j = filterList.begin(); 213 for (auto i = j; i != filterList.end() && std::get<int>(*i) > prio; i++) 214 { 215 j = i; 216 } 217 filterList.emplace_after(j, std::make_tuple(prio, filter)); 218 } 219 220 } // namespace impl 221 222 message::Response::ptr filterIpmiCommand(message::Request::ptr request) 223 { 224 // pass the command through the filter mechanism 225 // This can be the firmware firewall or any OEM mechanism like 226 // whitelist filtering based on operational mode 227 for (auto& item : filterList) 228 { 229 FilterBase::ptr filter = std::get<FilterBase::ptr>(item); 230 ipmi::Cc cc = filter->call(request); 231 if (ipmi::ccSuccess != cc) 232 { 233 return errorResponse(request, cc); 234 } 235 } 236 return message::Response::ptr(); 237 } 238 239 message::Response::ptr executeIpmiCommandCommon( 240 std::unordered_map<unsigned int, HandlerTuple>& handlers, 241 unsigned int keyCommon, message::Request::ptr request) 242 { 243 // filter the command first; a non-null message::Response::ptr 244 // means that the message has been rejected for some reason 245 message::Response::ptr filterResponse = filterIpmiCommand(request); 246 247 Cmd cmd = request->ctx->cmd; 248 unsigned int key = makeCmdKey(keyCommon, cmd); 249 auto cmdIter = handlers.find(key); 250 if (cmdIter != handlers.end()) 251 { 252 // only return the filter response if the command is found 253 if (filterResponse) 254 { 255 lg2::debug("request for NetFn/Cmd {NETFN}/{CMD} has been filtered", 256 "NETFN", lg2::hex, keyCommon, "CMD", lg2::hex, cmd); 257 return filterResponse; 258 } 259 HandlerTuple& chosen = cmdIter->second; 260 if (request->ctx->priv < std::get<Privilege>(chosen)) 261 { 262 return errorResponse(request, ccInsufficientPrivilege); 263 } 264 return std::get<HandlerBase::ptr>(chosen)->call(request); 265 } 266 else 267 { 268 unsigned int wildcard = makeCmdKey(keyCommon, cmdWildcard); 269 cmdIter = handlers.find(wildcard); 270 if (cmdIter != handlers.end()) 271 { 272 // only return the filter response if the command is found 273 if (filterResponse) 274 { 275 lg2::debug( 276 "request for NetFn/Cmd {NETFN}/{CMD} has been filtered", 277 "NETFN", lg2::hex, keyCommon, "CMD", lg2::hex, cmd); 278 return filterResponse; 279 } 280 HandlerTuple& chosen = cmdIter->second; 281 if (request->ctx->priv < std::get<Privilege>(chosen)) 282 { 283 return errorResponse(request, ccInsufficientPrivilege); 284 } 285 return std::get<HandlerBase::ptr>(chosen)->call(request); 286 } 287 } 288 return errorResponse(request, ccInvalidCommand); 289 } 290 291 message::Response::ptr executeIpmiGroupCommand(message::Request::ptr request) 292 { 293 // look up the group for this request 294 uint8_t bytes; 295 if (0 != request->payload.unpack(bytes)) 296 { 297 return errorResponse(request, ccReqDataLenInvalid); 298 } 299 auto group = static_cast<Group>(bytes); 300 message::Response::ptr response = 301 executeIpmiCommandCommon(groupHandlerMap, group, request); 302 ipmi::message::Payload prefix; 303 prefix.pack(bytes); 304 response->prepend(prefix); 305 return response; 306 } 307 308 message::Response::ptr executeIpmiOemCommand(message::Request::ptr request) 309 { 310 // look up the iana for this request 311 uint24_t bytes; 312 if (0 != request->payload.unpack(bytes)) 313 { 314 return errorResponse(request, ccReqDataLenInvalid); 315 } 316 auto iana = static_cast<Iana>(bytes); 317 318 lg2::debug("unpack IANA {IANA}", "IANA", lg2::hex, iana); 319 320 message::Response::ptr response = 321 executeIpmiCommandCommon(oemHandlerMap, iana, request); 322 ipmi::message::Payload prefix; 323 prefix.pack(bytes); 324 response->prepend(prefix); 325 return response; 326 } 327 328 message::Response::ptr executeIpmiCommand(message::Request::ptr request) 329 { 330 NetFn netFn = request->ctx->netFn; 331 if (netFnGroup == netFn) 332 { 333 return executeIpmiGroupCommand(request); 334 } 335 else if (netFnOem == netFn) 336 { 337 return executeIpmiOemCommand(request); 338 } 339 return executeIpmiCommandCommon(handlerMap, netFn, request); 340 } 341 342 namespace utils 343 { 344 template <typename AssocContainer, typename UnaryPredicate> 345 void assoc_erase_if(AssocContainer& c, UnaryPredicate p) 346 { 347 typename AssocContainer::iterator next = c.begin(); 348 typename AssocContainer::iterator last = c.end(); 349 while ((next = std::find_if(next, last, p)) != last) 350 { 351 c.erase(next++); 352 } 353 } 354 } // namespace utils 355 356 namespace 357 { 358 std::unordered_map<std::string, uint8_t> uniqueNameToChannelNumber; 359 360 // sdbusplus::bus::match::rules::arg0namespace() wants the prefix 361 // to match without any trailing '.' 362 constexpr const char ipmiDbusChannelMatch[] = 363 "xyz.openbmc_project.Ipmi.Channel"; 364 void updateOwners(sdbusplus::asio::connection& conn, const std::string& name) 365 { 366 conn.async_method_call( 367 [name](const boost::system::error_code ec, 368 const std::string& nameOwner) { 369 if (ec) 370 { 371 lg2::error("Error getting dbus owner for {INTERFACE}", 372 "INTERFACE", name); 373 return; 374 } 375 // start after ipmiDbusChannelPrefix (after the '.') 376 std::string chName = 377 name.substr(std::strlen(ipmiDbusChannelMatch) + 1); 378 try 379 { 380 uint8_t channel = getChannelByName(chName); 381 uniqueNameToChannelNumber[nameOwner] = channel; 382 lg2::info( 383 "New interface mapping: {INTERFACE} -> channel {CHANNEL}", 384 "INTERFACE", name, "CHANNEL", channel); 385 } 386 catch (const std::exception& e) 387 { 388 lg2::info("Failed interface mapping, no such name: {INTERFACE}", 389 "INTERFACE", name); 390 } 391 }, 392 "org.freedesktop.DBus", "/", "org.freedesktop.DBus", "GetNameOwner", 393 name); 394 } 395 396 void doListNames(boost::asio::io_context& io, sdbusplus::asio::connection& conn) 397 { 398 conn.async_method_call( 399 [&io, &conn](const boost::system::error_code ec, 400 std::vector<std::string> busNames) { 401 if (ec) 402 { 403 lg2::error("Error getting dbus names: {ERROR}", "ERROR", 404 ec.message()); 405 std::exit(EXIT_FAILURE); 406 return; 407 } 408 // Try to make startup consistent 409 std::sort(busNames.begin(), busNames.end()); 410 411 const std::string channelPrefix = 412 std::string(ipmiDbusChannelMatch) + "."; 413 for (const std::string& busName : busNames) 414 { 415 if (busName.find(channelPrefix) == 0) 416 { 417 updateOwners(conn, busName); 418 } 419 } 420 }, 421 "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", 422 "ListNames"); 423 } 424 425 void nameChangeHandler(sdbusplus::message_t& message) 426 { 427 std::string name; 428 std::string oldOwner; 429 std::string newOwner; 430 431 message.read(name, oldOwner, newOwner); 432 433 if (!oldOwner.empty()) 434 { 435 if (boost::starts_with(oldOwner, ":")) 436 { 437 // Connection removed 438 auto it = uniqueNameToChannelNumber.find(oldOwner); 439 if (it != uniqueNameToChannelNumber.end()) 440 { 441 uniqueNameToChannelNumber.erase(it); 442 } 443 } 444 } 445 if (!newOwner.empty()) 446 { 447 // start after ipmiDbusChannelMatch (and after the '.') 448 std::string chName = name.substr(std::strlen(ipmiDbusChannelMatch) + 1); 449 try 450 { 451 uint8_t channel = getChannelByName(chName); 452 uniqueNameToChannelNumber[newOwner] = channel; 453 lg2::info("New interface mapping: {INTERFACE} -> channel {CHANNEL}", 454 "INTERFACE", name, "CHANNEL", channel); 455 } 456 catch (const std::exception& e) 457 { 458 lg2::info("Failed interface mapping, no such name: {INTERFACE}", 459 "INTERFACE", name); 460 } 461 } 462 }; 463 464 } // anonymous namespace 465 466 static constexpr const char intraBmcName[] = "INTRABMC"; 467 uint8_t channelFromMessage(sdbusplus::message_t& msg) 468 { 469 // channel name for ipmitool to resolve to 470 std::string sender = msg.get_sender(); 471 auto chIter = uniqueNameToChannelNumber.find(sender); 472 if (chIter != uniqueNameToChannelNumber.end()) 473 { 474 return chIter->second; 475 } 476 // FIXME: currently internal connections are ephemeral and hard to pin down 477 try 478 { 479 return getChannelByName(intraBmcName); 480 } 481 catch (const std::exception& e) 482 { 483 return invalidChannel; 484 } 485 } // namespace ipmi 486 487 /* called from sdbus async server context */ 488 auto executionEntry(boost::asio::yield_context yield, sdbusplus::message_t& m, 489 NetFn netFn, uint8_t lun, Cmd cmd, ipmi::SecureBuffer& data, 490 std::map<std::string, ipmi::Value>& options) 491 { 492 const auto dbusResponse = 493 [netFn, lun, cmd](Cc cc, const ipmi::SecureBuffer& data = {}) { 494 constexpr uint8_t netFnResponse = 0x01; 495 uint8_t retNetFn = netFn | netFnResponse; 496 return std::make_tuple(retNetFn, lun, cmd, cc, data); 497 }; 498 std::string sender = m.get_sender(); 499 Privilege privilege = Privilege::None; 500 int rqSA = 0; 501 int hostIdx = 0; 502 uint8_t userId = 0; // undefined user 503 uint32_t sessionId = 0; 504 505 // figure out what channel the request came in on 506 uint8_t channel = channelFromMessage(m); 507 if (channel == invalidChannel) 508 { 509 // unknown sender channel; refuse to service the request 510 lg2::error("ERROR determining source IPMI channel from " 511 "{SENDER} NetFn/Cmd {NETFN}/{CMD}", 512 "SENDER", sender, "NETFN", lg2::hex, netFn, "CMD", lg2::hex, 513 cmd); 514 return dbusResponse(ipmi::ccDestinationUnavailable); 515 } 516 517 // session-based channels are required to provide userId, privilege and 518 // sessionId 519 if (getChannelSessionSupport(channel) != EChannelSessSupported::none) 520 { 521 try 522 { 523 Value requestPriv = options.at("privilege"); 524 Value requestUserId = options.at("userId"); 525 Value requestSessionId = options.at("currentSessionId"); 526 privilege = static_cast<Privilege>(std::get<int>(requestPriv)); 527 userId = static_cast<uint8_t>(std::get<int>(requestUserId)); 528 sessionId = 529 static_cast<uint32_t>(std::get<uint32_t>(requestSessionId)); 530 } 531 catch (const std::exception& e) 532 { 533 lg2::error("ERROR determining IPMI session credentials on " 534 "channel {CHANNEL} for userid {USERID}", 535 "CHANNEL", channel, "USERID", userId, "NETFN", lg2::hex, 536 netFn, "CMD", lg2::hex, cmd); 537 return dbusResponse(ipmi::ccUnspecifiedError); 538 } 539 } 540 else 541 { 542 // get max privilege for session-less channels 543 // For now, there is not a way to configure this, default to Admin 544 privilege = Privilege::Admin; 545 546 // ipmb should supply rqSA 547 ChannelInfo chInfo; 548 getChannelInfo(channel, chInfo); 549 if (static_cast<EChannelMediumType>(chInfo.mediumType) == 550 EChannelMediumType::ipmb) 551 { 552 const auto iter = options.find("rqSA"); 553 if (iter != options.end()) 554 { 555 if (std::holds_alternative<int>(iter->second)) 556 { 557 rqSA = std::get<int>(iter->second); 558 } 559 } 560 const auto iteration = options.find("hostId"); 561 if (iteration != options.end()) 562 { 563 if (std::holds_alternative<int>(iteration->second)) 564 { 565 hostIdx = std::get<int>(iteration->second); 566 } 567 } 568 } 569 } 570 // check to see if the requested priv/username is valid 571 lg2::debug("Set up ipmi context: Ch:NetFn/Cmd={CHANNEL}:{NETFN}/{CMD}", 572 "SENDER", sender, "NETFN", lg2::hex, netFn, "LUN", lg2::hex, lun, 573 "CMD", lg2::hex, cmd, "CHANNEL", channel, "USERID", userId, 574 "SESSIONID", lg2::hex, sessionId, "PRIVILEGE", 575 static_cast<uint8_t>(privilege), "RQSA", lg2::hex, rqSA); 576 577 auto ctx = std::make_shared<ipmi::Context>( 578 getSdBus(), netFn, lun, cmd, channel, userId, sessionId, privilege, 579 rqSA, hostIdx, yield); 580 auto request = std::make_shared<ipmi::message::Request>( 581 ctx, std::forward<ipmi::SecureBuffer>(data)); 582 message::Response::ptr response = executeIpmiCommand(request); 583 584 return dbusResponse(response->cc, response->payload.raw); 585 } 586 587 /** @struct IpmiProvider 588 * 589 * RAII wrapper for dlopen so that dlclose gets called on exit 590 */ 591 struct IpmiProvider 592 { 593 public: 594 /** @brief address of the opened library */ 595 void* addr; 596 std::string name; 597 598 IpmiProvider() = delete; 599 IpmiProvider(const IpmiProvider&) = delete; 600 IpmiProvider& operator=(const IpmiProvider&) = delete; 601 IpmiProvider(IpmiProvider&&) = delete; 602 IpmiProvider& operator=(IpmiProvider&&) = delete; 603 604 /** @brief dlopen a shared object file by path 605 * @param[in] filename - path of shared object to open 606 */ 607 explicit IpmiProvider(const char* fname) : addr(nullptr), name(fname) 608 { 609 lg2::debug("Open IPMI provider library: {PROVIDER}", "PROVIDER", name); 610 try 611 { 612 addr = dlopen(name.c_str(), RTLD_NOW); 613 } 614 catch (const std::exception& e) 615 { 616 lg2::error("ERROR opening IPMI provider {PROVIDER}: {ERROR}", 617 "PROVIDER", name, "ERROR", e); 618 } 619 catch (...) 620 { 621 const char* what = currentExceptionType(); 622 lg2::error("ERROR opening IPMI provider {PROVIDER}: {ERROR}", 623 "PROVIDER", name, "ERROR", what); 624 } 625 if (!isOpen()) 626 { 627 lg2::error("ERROR opening IPMI provider {PROVIDER}: {ERROR}", 628 "PROVIDER", name, "ERROR", dlerror()); 629 } 630 } 631 632 ~IpmiProvider() 633 { 634 if (isOpen()) 635 { 636 dlclose(addr); 637 } 638 } 639 bool isOpen() const 640 { 641 return (nullptr != addr); 642 } 643 }; 644 645 // Plugin libraries need to contain .so either at the end or in the middle 646 constexpr const char ipmiPluginExtn[] = ".so"; 647 648 /* return a list of self-closing library handles */ 649 std::forward_list<IpmiProvider> loadProviders(const fs::path& ipmiLibsPath) 650 { 651 std::vector<fs::path> libs; 652 for (const auto& libPath : fs::directory_iterator(ipmiLibsPath)) 653 { 654 std::error_code ec; 655 fs::path fname = libPath.path(); 656 if (fs::is_symlink(fname, ec) || ec) 657 { 658 // it's a symlink or some other error; skip it 659 continue; 660 } 661 while (fname.has_extension()) 662 { 663 fs::path extn = fname.extension(); 664 if (extn == ipmiPluginExtn) 665 { 666 libs.push_back(libPath.path()); 667 break; 668 } 669 fname.replace_extension(); 670 } 671 } 672 std::sort(libs.begin(), libs.end()); 673 674 std::forward_list<IpmiProvider> handles; 675 for (auto& lib : libs) 676 { 677 #ifdef __IPMI_DEBUG__ 678 lg2::debug("Registering handler {HANDLER}", "HANDLER", lib); 679 #endif 680 handles.emplace_front(lib.c_str()); 681 } 682 return handles; 683 } 684 685 } // namespace ipmi 686 687 #ifdef ALLOW_DEPRECATED_API 688 /* legacy registration */ 689 void ipmi_register_callback(ipmi_netfn_t netFn, ipmi_cmd_t cmd, 690 ipmi_context_t context, ipmid_callback_t handler, 691 ipmi_cmd_privilege_t priv) 692 { 693 auto h = ipmi::makeLegacyHandler(handler, context); 694 // translate priv from deprecated enum to current 695 ipmi::Privilege realPriv; 696 switch (priv) 697 { 698 case PRIVILEGE_CALLBACK: 699 realPriv = ipmi::Privilege::Callback; 700 break; 701 case PRIVILEGE_USER: 702 realPriv = ipmi::Privilege::User; 703 break; 704 case PRIVILEGE_OPERATOR: 705 realPriv = ipmi::Privilege::Operator; 706 break; 707 case PRIVILEGE_ADMIN: 708 realPriv = ipmi::Privilege::Admin; 709 break; 710 case PRIVILEGE_OEM: 711 realPriv = ipmi::Privilege::Oem; 712 break; 713 case SYSTEM_INTERFACE: 714 realPriv = ipmi::Privilege::Admin; 715 break; 716 default: 717 realPriv = ipmi::Privilege::Admin; 718 break; 719 } 720 // The original ipmi_register_callback allowed for group OEM handlers 721 // to be registered via this same interface. It just so happened that 722 // all the handlers were part of the DCMI group, so default to that. 723 if (netFn == NETFUN_GRPEXT) 724 { 725 ipmi::impl::registerGroupHandler(ipmi::prioOpenBmcBase, ipmi::groupDCMI, 726 cmd, realPriv, h); 727 } 728 else 729 { 730 ipmi::impl::registerHandler(ipmi::prioOpenBmcBase, netFn, cmd, realPriv, 731 h); 732 } 733 } 734 735 namespace oem 736 { 737 738 class LegacyRouter : public oem::Router 739 { 740 public: 741 virtual ~LegacyRouter() {} 742 743 /// Enable message routing to begin. 744 void activate() override {} 745 746 void registerHandler(Number oen, ipmi_cmd_t cmd, Handler handler) override 747 { 748 auto h = ipmi::makeLegacyHandler(std::forward<Handler>(handler)); 749 ipmi::impl::registerOemHandler(ipmi::prioOpenBmcBase, oen, cmd, 750 ipmi::Privilege::Admin, h); 751 } 752 }; 753 static LegacyRouter legacyRouter; 754 755 Router* mutableRouter() 756 { 757 return &legacyRouter; 758 } 759 760 } // namespace oem 761 762 /* legacy alternative to executionEntry */ 763 void handleLegacyIpmiCommand(sdbusplus::message_t& m) 764 { 765 // make a copy so the next two moves don't wreak havoc on the stack 766 sdbusplus::message_t b{m}; 767 boost::asio::spawn( 768 *getIoContext(), 769 [b = std::move(b)](boost::asio::yield_context yield) { 770 sdbusplus::message_t m{std::move(b)}; 771 unsigned char seq = 0, netFn = 0, lun = 0, cmd = 0; 772 ipmi::SecureBuffer data; 773 774 m.read(seq, netFn, lun, cmd, data); 775 std::shared_ptr<sdbusplus::asio::connection> bus = getSdBus(); 776 auto ctx = std::make_shared<ipmi::Context>( 777 bus, netFn, lun, cmd, 0, 0, 0, ipmi::Privilege::Admin, 0, 0, 778 yield); 779 auto request = std::make_shared<ipmi::message::Request>( 780 ctx, std::forward<ipmi::SecureBuffer>(data)); 781 ipmi::message::Response::ptr response = 782 ipmi::executeIpmiCommand(request); 783 784 // Responses in IPMI require a bit set. So there ya go... 785 netFn |= 0x01; 786 787 const char *dest, *path; 788 constexpr const char* DBUS_INTF = "org.openbmc.HostIpmi"; 789 790 dest = m.get_sender(); 791 path = m.get_path(); 792 boost::system::error_code ec; 793 bus->yield_method_call(yield, ec, dest, path, DBUS_INTF, 794 "sendMessage", seq, netFn, lun, cmd, 795 response->cc, response->payload.raw); 796 if (ec) 797 { 798 lg2::error( 799 "Failed to send response to requestor ({NETFN}/{CMD}): {ERROR}", 800 "ERROR", ec.message(), "SENDER", dest, "NETFN", lg2::hex, 801 netFn, "CMD", lg2::hex, cmd); 802 } 803 }, 804 {}); 805 } 806 807 #endif /* ALLOW_DEPRECATED_API */ 808 809 // Calls host command manager to do the right thing for the command 810 using CommandHandler = phosphor::host::command::CommandHandler; 811 std::unique_ptr<phosphor::host::command::Manager> cmdManager; 812 void ipmid_send_cmd_to_host(CommandHandler&& cmd) 813 { 814 cmdManager->execute(std::forward<CommandHandler>(cmd)); 815 } 816 817 std::unique_ptr<phosphor::host::command::Manager>& ipmid_get_host_cmd_manager() 818 { 819 return cmdManager; 820 } 821 822 // These are symbols that are present in libipmid, but not expected 823 // to be used except here (or maybe a unit test), so declare them here 824 extern void setIoContext(std::shared_ptr<boost::asio::io_context>& newIo); 825 extern void setSdBus(std::shared_ptr<sdbusplus::asio::connection>& newBus); 826 827 int main(int argc, char* argv[]) 828 { 829 // Connect to system bus 830 auto io = std::make_shared<boost::asio::io_context>(); 831 setIoContext(io); 832 if (argc > 1 && std::string(argv[1]) == "-session") 833 { 834 sd_bus_default_user(&bus); 835 } 836 else 837 { 838 sd_bus_default_system(&bus); 839 } 840 auto sdbusp = std::make_shared<sdbusplus::asio::connection>(*io, bus); 841 setSdBus(sdbusp); 842 843 // TODO: Hack to keep the sdEvents running.... Not sure why the sd_event 844 // queue stops running if we don't have a timer that keeps re-arming 845 sdbusplus::Timer t2([]() { ; }); 846 t2.start(std::chrono::microseconds(500000), true); 847 848 // TODO: Remove all vestiges of sd_event from phosphor-host-ipmid 849 // until that is done, add the sd_event wrapper to the io object 850 sdbusplus::asio::sd_event_wrapper sdEvents(*io); 851 852 cmdManager = std::make_unique<phosphor::host::command::Manager>(*sdbusp); 853 854 // Register all command providers and filters 855 std::forward_list<ipmi::IpmiProvider> providers = 856 ipmi::loadProviders(HOST_IPMI_LIB_PATH); 857 858 #ifdef ALLOW_DEPRECATED_API 859 // listen on deprecated signal interface for kcs/bt commands 860 constexpr const char* FILTER = "type='signal',interface='org.openbmc." 861 "HostIpmi',member='ReceivedMessage'"; 862 sdbusplus::bus::match_t oldIpmiInterface(*sdbusp, FILTER, 863 handleLegacyIpmiCommand); 864 #endif /* ALLOW_DEPRECATED_API */ 865 866 // set up bus name watching to match channels with bus names 867 sdbusplus::bus::match_t nameOwnerChanged( 868 *sdbusp, 869 sdbusplus::bus::match::rules::nameOwnerChanged() + 870 sdbusplus::bus::match::rules::arg0namespace( 871 ipmi::ipmiDbusChannelMatch), 872 ipmi::nameChangeHandler); 873 ipmi::doListNames(*io, *sdbusp); 874 875 int exitCode = 0; 876 // set up boost::asio signal handling 877 std::function<SignalResponse(int)> stopAsioRunLoop = [&io, &exitCode]( 878 int signalNumber) { 879 lg2::info("Received signal {SIGNAL}; quitting", "SIGNAL", signalNumber); 880 io->stop(); 881 exitCode = signalNumber; 882 return SignalResponse::breakExecution; 883 }; 884 registerSignalHandler(ipmi::prioOpenBmcBase, SIGINT, stopAsioRunLoop); 885 registerSignalHandler(ipmi::prioOpenBmcBase, SIGTERM, stopAsioRunLoop); 886 887 sdbusp->request_name("xyz.openbmc_project.Ipmi.Host"); 888 // Add bindings for inbound IPMI requests 889 auto server = sdbusplus::asio::object_server(sdbusp); 890 auto iface = server.add_interface("/xyz/openbmc_project/Ipmi", 891 "xyz.openbmc_project.Ipmi.Server"); 892 iface->register_method("execute", ipmi::executionEntry); 893 iface->initialize(); 894 895 io->run(); 896 897 // destroy all the IPMI handlers so the providers can unload safely 898 ipmi::handlerMap.clear(); 899 ipmi::groupHandlerMap.clear(); 900 ipmi::oemHandlerMap.clear(); 901 ipmi::filterList.clear(); 902 // unload the provider libraries 903 providers.clear(); 904 905 std::exit(exitCode); 906 } 907