#pragma once #include #include #include "console_buffer.hpp" #include "session.hpp" #include "sol_context.hpp" namespace sol { constexpr size_t MAX_PAYLOAD_INSTANCES = 16; constexpr size_t MAX_PAYLOAD_SIZE = 255; constexpr uint8_t MAJOR_VERSION = 0x01; constexpr uint8_t MINOR_VERSION = 0x00; constexpr char CONSOLE_SOCKET_PATH[] = "\0obmc-console"; constexpr size_t CONSOLE_SOCKET_PATH_LEN = sizeof(CONSOLE_SOCKET_PATH) - 1; constexpr uint8_t accIntervalFactor = 5; constexpr uint8_t retryIntervalFactor = 10; using Instance = uint8_t; /** @struct CustomFD * * RAII wrapper for file descriptor. */ struct CustomFD { CustomFD(const CustomFD&) = delete; CustomFD& operator=(const CustomFD&) = delete; CustomFD(CustomFD&&) = delete; CustomFD& operator=(CustomFD&&) = delete; CustomFD(int fd) : fd(fd) {} ~CustomFD(); int operator()() const { return fd; } private: int fd = -1; }; using namespace std::chrono_literals; /** @class Manager * * Manager class acts a manager for the SOL payload instances and provides * interfaces to start a payload instance, stop a payload instance and get * reference to the context object. */ class Manager { public: /** @brief SOL Payload Instance is the key for the map, the value is the * SOL context. */ using SOLPayloadMap = std::map>; Manager() = default; ~Manager() = default; Manager(const Manager&) = delete; Manager& operator=(const Manager&) = delete; Manager(Manager&&) = default; Manager& operator=(Manager&&) = default; /** @brief Host Console Buffer. */ ConsoleData dataBuffer; /** @brief Set in Progress. * * This parameter is used to indicate when any of the SOL parameters * are being updated, and when the changes are completed. The bit is * primarily provided to alert software than some other software or * utility is in the process of making changes to the data. This field * is initialized to set complete. */ uint8_t progress = 0; /** @brief SOL enable * * This controls whether the SOL payload can be activated. By default * the SOL is enabled. */ bool enable = true; /** @brief SOL payload encryption. * * Force encryption: if the cipher suite for the session supports * encryption, then this setting will force the use of encryption for * all SOL payload data. Encryption controlled by remote console: * Whether SOL packets are encrypted or not is selectable by the remote * console at the time the payload is activated. The default is force * encryption. */ bool forceEncrypt = true; /** @brief SOL payload authentication. * * Force authentication: if the cipher suite for the session supports * authentication, then this setting will force the use of for * authentication for all SOL payload data. Authentication controlled * by remote console: Note that for the standard Cipher Suites, * if encryption is used authentication must also be used. Therefore, * while encryption is being used software will not be able to select * using unauthenticated payloads. */ bool forceAuth = true; /** @brief SOL privilege level. * * Sets the minimum operating privilege level that is required to be * able to activate SOL using the Activate Payload command. */ session::Privilege solMinPrivilege = session::Privilege::USER; /** @brief Character Accumulate Interval * * This sets the typical amount of time that the BMC will wait before * transmitting a partial SOL character data packet. (Where a partial * packet is defined as a packet that has fewer characters to transmit * than the number of characters specified by the character send * threshold. This parameter can be modified by the set SOL * configuration parameters command. The SOL configuration parameter, * Character Accumulate Interval is 5 ms increments, 1-based value. The * parameter value is accumulateInterval/5. The accumulateInterval * needs to be a multiple of 5. */ std::chrono::milliseconds accumulateInterval = 100ms; /** @brief Character Send Threshold * * The BMC will automatically send an SOL character data packet * containing this number of characters as soon as this number of * characters (or greater) has been accepted from the baseboard serial * controller into the BMC. This provides a mechanism to tune the * buffer to reduce latency to when the first characters are received * after an idle interval. In the degenerate case, setting this value * to a ‘1’ would cause the BMC to send a packet as soon as the first * character was received. This parameter can be modified by the set * SOL configuration parameters command. */ uint8_t sendThreshold = 1; /** @brief Retry Count * * 1-based. 0 = no retries after packet is transmitted. Packet will be * dropped if no ACK/NACK received by time retries expire. The maximum * value for retry count is 7. This parameter can be modified by the * set SOL configuration parameters command. */ uint8_t retryCount = 7; /** @brief Retry Interval * * Sets the time that the BMC will wait before the first retry and the * time between retries when sending SOL packets to the remote console. * This parameter can be modified by the set SOL configuration * parameters command. The SOL configuration parameter Retry Interval * is 10 ms increments, 1-based value. The parameter value is * retryInterval/10. The retryInterval needs to be a multiple of 10. */ std::chrono::milliseconds retryInterval = 100ms; /** @brief Start a SOL payload instance. * * Starting a payload instance involves creating the context object, * add the accumulate interval timer and retry interval timer to the * event loop. * * @param[in] payloadInstance - SOL payload instance. * @param[in] sessionID - BMC session ID. */ void startPayloadInstance(uint8_t payloadInstance, session::SessionID sessionID); /** @brief Stop SOL payload instance. * * Stopping a payload instance involves stopping and removing the * accumulate interval timer and retry interval timer from the event * loop, delete the context object. * * @param[in] payloadInstance - SOL payload instance */ void stopPayloadInstance(uint8_t payloadInstance); /** @brief Get SOL Context by Payload Instance. * * @param[in] payloadInstance - SOL payload instance. * * @return reference to the SOL payload context. */ Context& getContext(uint8_t payloadInstance) { auto iter = payloadMap.find(payloadInstance); if (iter != payloadMap.end()) { return *(iter->second); } std::string msg = "Invalid SOL payload instance " + payloadInstance; throw std::runtime_error(msg.c_str()); } /** @brief Get SOL Context by Session ID. * * @param[in] sessionID - IPMI Session ID. * * @return reference to the SOL payload context. */ Context& getContext(session::SessionID sessionID) { for (const auto& kv : payloadMap) { if (kv.second->sessionID == sessionID) { return *kv.second; } } std::string msg = "Invalid SOL SessionID " + sessionID; throw std::runtime_error(msg.c_str()); } /** @brief Check if SOL payload is active. * * @param[in] payloadInstance - SOL payload instance. * * @return true if the instance is active and false it is not active. */ auto isPayloadActive(uint8_t payloadInstance) const { return (0 != payloadMap.count(payloadInstance)); } /** @brief Write data to the host console unix socket. * * @param[in] input - Data from the remote console. * * @return 0 on success and errno on failure. */ int writeConsoleSocket(const Buffer& input) const; private: SOLPayloadMap payloadMap; /** @brief File descriptor for the host console. */ std::unique_ptr consoleFD = nullptr; /** @brief Initialize the host console file descriptor. */ void initHostConsoleFd(); }; } //namespace sol