blob: a07189214bf5f7bdad3cb50f78fda973bdee3f00 [file] [log] [blame]
#pragma once
#include "console_buffer.hpp"
#include "session.hpp"
#include <boost/asio/io_context.hpp>
#include <boost/asio/steady_timer.hpp>
#include <cstddef>
namespace sol
{
/** @struct Outbound
*
* Operation/Status in an outbound SOL payload format(BMC to Remote Console).
*/
struct Outbound
{
#if BYTE_ORDER == LITTLE_ENDIAN
uint8_t testMode : 2; //!< Not supported.
uint8_t breakDetected : 1; //!< Not supported.
uint8_t transmitOverrun : 1; //!< Not supported.
uint8_t SOLDeactivating : 1; //!< 0 : SOL is active, 1 : SOL deactivated.
uint8_t charUnavailable : 1; //!< 0 : Available, 1 : Unavailable.
uint8_t ack : 1; //!< 0 : ACK, 1 : NACK.
uint8_t reserved : 1; //!< Reserved.
#endif
#if BYTE_ORDER == BIG_ENDIAN
uint8_t reserved : 1; //!< Reserved.
uint8_t ack : 1; //!< 0 : ACK, 1 : NACK.
uint8_t charUnavailable : 1; //!< 0 : Available, 1 : Unavailable.
uint8_t SOLDeactivating : 1; //!< 0 : SOL is active, 1 : SOL deactivated.
uint8_t transmitOverrun : 1; //!< Not supported.
uint8_t breakDetected : 1; //!< Not supported.
uint8_t testMode : 2; //!< Not supported.
#endif
} __attribute__((packed));
/** @struct Inbound
*
* Operation/Status in an Inbound SOL Payload format(Remote Console to BMC).
*/
struct Inbound
{
#if BYTE_ORDER == LITTLE_ENDIAN
uint8_t flushOut : 1; //!< Not supported.
uint8_t flushIn : 1; //!< Not supported.
uint8_t dcd : 1; //!< Not supported.
uint8_t cts : 1; //!< Not supported.
uint8_t generateBreak : 1; //!< Not supported.
uint8_t ring : 1; //!< Not supported.
uint8_t ack : 1; //!< 0 : ACK, 1 : NACK.
uint8_t reserved : 1; //!< Reserved.
#endif
#if BYTE_ORDER == BIG_ENDIAN
uint8_t reserved : 1; //!< Reserved.
uint8_t ack : 1; //!< 0 : ACK, 1 : NACK.
uint8_t ring : 1; //!< Not supported.
uint8_t generateBreak : 1; //!< Not supported.
uint8_t cts : 1; //!< Not supported.
uint8_t dcd : 1; //!< Not supported.
uint8_t flushIn : 1; //!< Not supported.
uint8_t flushOut : 1; //!< Not supported.
#endif
} __attribute__((packed));
/** @struct Payload
*
* SOL Payload Data Format.The following fields make up the SOL payload in an
* RMCP+ packet, followed by the console character data.
*/
struct Payload
{
uint8_t packetSeqNum; //!< Packet sequence number
uint8_t packetAckSeqNum; //!< Packet ACK/NACK sequence number
uint8_t acceptedCharCount; //!< Accepted character count
union
{
uint8_t operation; //!< Operation/Status
struct Outbound outOperation; //!< BMC to Remote Console
struct Inbound inOperation; //!< Remote Console to BMC
};
} __attribute__((packed));
namespace internal
{
/** @struct SequenceNumbers
*
* SOL sequence numbers. At the session level, SOL Payloads share the session
* sequence numbers for authenticated and unauthenticated packets with other
* packets under the IPMI session. At the payload level, SOL packets include
* their own message sequence numbers that are used for tracking missing and
* retried SOL messages. The sequence numbers must be non-zero. Retried
* packets use the same sequence number as the first packet.
*/
struct SequenceNumbers
{
static constexpr uint8_t MAX_SOL_SEQUENCE_NUMBER = 0x10;
/** @brief Get the SOL sequence number.
*
* @param[in] inbound - true for inbound sequence number and false for
* outbound sequence number
*
* @return sequence number
*/
auto get(bool inbound = true) const
{
return inbound ? in : out;
}
/** @brief Increment the inbound SOL sequence number. */
void incInboundSeqNum()
{
if ((++in) == MAX_SOL_SEQUENCE_NUMBER)
{
in = 1;
}
}
/** @brief Increment the outbound SOL sequence number.
*
* @return outbound sequence number to populate the SOL payload.
*/
auto incOutboundSeqNum()
{
if ((++out) == MAX_SOL_SEQUENCE_NUMBER)
{
out = 1;
}
return out;
}
private:
uint8_t in = 1; //!< Inbound sequence number.
uint8_t out = 0; //!< Outbound sequence number, since the first
//!< operation is increment, it is initialised to 0
};
} // namespace internal
/** @class Context
*
* Context keeps the state of the SOL session. The information needed to
* maintain the state of the SOL is part of this class. This class provides
* interfaces to handle incoming SOL payload, send response and send outbound
* SOL payload.
*/
class Context : public std::enable_shared_from_this<Context>
{
public:
Context() = delete;
~Context() = default;
Context(const Context&) = delete;
Context& operator=(const Context&) = delete;
Context(Context&&) = delete;
Context& operator=(Context&&) = delete;
/** @brief Context Factory
*
* This is called by the SOL Manager when a SOL payload instance is
* started for the activate payload command. Its purpose is to be able
* to perform post-creation tasks on the object without changing the
* code flow
*
* @param[in] io - boost::asio io context for event scheduling.
* @param[in] maxRetryCount - Retry count max value.
* @param[in] sendThreshold - Character send threshold.
* @param[in] instance - SOL payload instance.
* @param[in] sessionID - BMC session ID.
*/
static std::shared_ptr<Context>
makeContext(std::shared_ptr<boost::asio::io_context> io,
uint8_t maxRetryCount, uint8_t sendThreshold,
uint8_t instance, session::SessionID sessionID);
/** @brief Context Constructor.
*
* This should only be used by the Context factory makeContext
* or the accumulate timer will not be initialized properly
*
* @param[in] io - boost::asio io context for event scheduling.
* @param[in] maxRetryCount - Retry count max value.
* @param[in] sendThreshold - Character send threshold.
* @param[in] instance - SOL payload instance.
* @param[in] sessionID - BMC session ID.
*/
Context(std::shared_ptr<boost::asio::io_context> io, uint8_t maxRetryCount,
uint8_t sendThreshold, uint8_t instance,
session::SessionID sessionID);
static constexpr auto clear = true;
static constexpr auto noClear = false;
/** @brief accumulate timer */
boost::asio::steady_timer accumulateTimer;
/** @brief retry timer */
boost::asio::steady_timer retryTimer;
/** @brief Retry count max value. */
const uint8_t maxRetryCount = 0;
/** @brief Retry counter. */
uint8_t retryCounter = 0;
/** @brief Character send threshold. */
const uint8_t sendThreshold = 0;
/** @brief SOL payload instance. */
const uint8_t payloadInstance = 0;
/** @brief Session ID. */
const session::SessionID sessionID = 0;
/** @brief session pointer
*/
std::shared_ptr<session::Session> session;
/** @brief enable/disable accumulate timer
*
* The timeout interval is managed by the SOL Manager;
* this function only enables or disable the timer
*
* @param[in] enable - enable(true) or disable(false) accumulation timer
*/
void enableAccumulateTimer(bool enable);
/** @brief enable/disable retry timer
*
* The timeout interval is managed by the SOL Manager;
* this function only enables or disable the timer
*
* @param[in] enable - enable(true) or disable(false) retry timer
*/
void enableRetryTimer(bool enable);
/** @brief Process the Inbound SOL payload.
*
* The SOL payload from the remote console is processed and the
* acknowledgment handling is done.
*
* @param[in] seqNum - Packet sequence number.
* @param[in] ackSeqNum - Packet ACK/NACK sequence number.
* @param[in] count - Accepted character count.
* @param[in] operation - ACK is false, NACK is true
* @param[in] input - Incoming SOL character data.
*/
void processInboundPayload(uint8_t seqNum, uint8_t ackSeqNum, uint8_t count,
bool status, const std::vector<uint8_t>& input);
/** @brief Send the outbound SOL payload.
*
* @return zero on success and negative value if condition for sending
* the payload fails.
*/
int sendOutboundPayload();
/** @brief Resend the SOL payload.
*
* @param[in] clear - if true then send the payload and clear the
* cached payload, if false only send the payload.
*/
void resendPayload(bool clear);
/** @brief accumlate timer handler called by timer */
void charAccTimerHandler();
/** @brief retry timer handler called by timer */
void retryTimerHandler();
private:
/** @brief Expected character count.
*
* Expected Sequence number and expected character count is set before
* sending the SOL payload. The check is done against these values when
* an incoming SOL payload is received.
*/
size_t expectedCharCount = 0;
/** @brief Inbound and Outbound sequence numbers. */
internal::SequenceNumbers seqNums;
/** @brief Copy of the last sent SOL payload.
*
* A copy of the SOL payload is kept here, so that when a retry needs
* to be attempted the payload is sent again.
*/
std::vector<uint8_t> payloadCache;
/**
* @brief Send Response for Incoming SOL payload.
*
* @param[in] ackSeqNum - Packet ACK/NACK Sequence Number.
* @param[in] count - Accepted Character Count.
* @param[in] ack - Set ACK/NACK in the Operation.
*/
void prepareResponse(uint8_t ackSeqNum, uint8_t count, bool ack);
/** @brief Send the outgoing SOL payload.
*
* @param[in] out - buffer containing the SOL payload.
*/
void sendPayload(const std::vector<uint8_t>& out) const;
};
} // namespace sol