IPMIHost.cpp

/*
 * IPMIHost.cpp
 *
 *  Created on: 18 Jan 2017
 *      Author: ottmi
 */

#include "IPMIHost.h"
#include "timestamp.h"

#include <cstdio>
#include <cstdlib>
#include <cerrno>
#include <cstring>
#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <exception>

#include <freeipmi/freeipmi.h>
#include <freeipmi/api/ipmi-api.h>
#include <freeipmi/sensor-read/ipmi-sensor-read.h>

#define RETRIES 2

IPMIHost::IPMIHost() {
	_ipmiCtx = nullptr;
	_sensorReadCtx = nullptr;
	_hostName = "";
	_userName = std::string("admin");
	_password = std::string("admin");
	_cache = "";
	_auth = IPMI_AUTHENTICATION_TYPE_MD5;
	_priv = IPMI_PRIVILEGE_LEVEL_ADMIN;
	_cipher = 3;
	_ipmiVersion = 1;
	_mqttPart = "";
	_retransmissionTimeout = 0;
	_sessionTimeout = 0;
	_strand = nullptr;
	_errorCount = 0;
	_delayNextReadUntil = 0;
}

IPMIHost::~IPMIHost() {
	if (_strand) {
		delete _strand;
	}
}

int IPMIHost::connect() {
	if (_ipmiCtx) {
		return 0;
	}
	
	if (!(_ipmiCtx = ipmi_ctx_create())) {
		_errorMsg = "Error creating IPMI context" + std::string(strerror(errno));
		return 1;
	}

	int workaround_flags = 0;
	int flags = IPMI_FLAGS_DEFAULT;
	int rc;
	if (_ipmiVersion == 1) {
		rc = ipmi_ctx_open_outofband(_ipmiCtx, _hostName.c_str(), _userName.c_str(), _password.c_str(), _auth, _priv, _sessionTimeout, _retransmissionTimeout, workaround_flags, flags); 
	} else {
		rc = ipmi_ctx_open_outofband_2_0(_ipmiCtx, _hostName.c_str(), _userName.c_str(), _password.c_str(), NULL, 0, _priv, _cipher, _sessionTimeout, _retransmissionTimeout, workaround_flags, flags);
	}
	if (rc < 0) {
		_errorMsg = "Error opening IPMI connection: " + std::string(ipmi_ctx_errormsg(_ipmiCtx));
		ipmi_ctx_close(_ipmiCtx);
		ipmi_ctx_destroy(_ipmiCtx);
		_ipmiCtx = NULL;
		return 2;
	}

	return 0;
}

int IPMIHost::disconnect() {
	if (_sensorReadCtx) {
		ipmi_sensor_read_ctx_destroy(_sensorReadCtx);
		_sensorReadCtx = NULL;
	}
	
	if (_ipmiCtx) {
		ipmi_ctx_close(_ipmiCtx);
		ipmi_ctx_destroy(_ipmiCtx);
		_ipmiCtx = NULL;
		return 0;
	}
	return 1;
}

bool IPMIHost::getSdrRecord(uint16_t recordId, std::vector<uint8_t>& record) {
	ipmi_sdr_ctx_t	sdrCtx = ipmi_sdr_ctx_create();
	if (!sdrCtx) {
		throw std::runtime_error("Error creating SDR context: " + std::string(strerror(errno)));
		return false;
	}
	
	bool success = false;
	int retries = RETRIES;
	while (retries-- && !success) {
		if (connect() == 0) {
			if (ipmi_sdr_cache_open(sdrCtx, _ipmiCtx, _cache.c_str()) < 0) {
				if ((ipmi_sdr_ctx_errnum(sdrCtx) == IPMI_SDR_ERR_CACHE_READ_CACHE_DOES_NOT_EXIST) || (ipmi_sdr_ctx_errnum(sdrCtx) == IPMI_SDR_ERR_CACHE_INVALID) || (ipmi_sdr_ctx_errnum(sdrCtx) == IPMI_SDR_ERR_CACHE_OUT_OF_DATE)) {
					if ((ipmi_sdr_ctx_errnum(sdrCtx) == IPMI_SDR_ERR_CACHE_INVALID) || (ipmi_sdr_ctx_errnum(sdrCtx) == IPMI_SDR_ERR_CACHE_OUT_OF_DATE)) {
						LOG(debug) << _hostName << "Deleting SDR cache " << _cache;
						ipmi_sdr_cache_close(sdrCtx);
						ipmi_sdr_cache_delete(sdrCtx, _cache.c_str());
					}
					if (ipmi_sdr_cache_create(sdrCtx, _ipmiCtx, _cache.c_str(), IPMI_SDR_CACHE_CREATE_FLAGS_DEFAULT, NULL, NULL) == 0) {
						LOG(debug) << _hostName << ": Created new SDR cache " << _cache;
					} else {
						LOG(debug) << _hostName << ": Error creating new SDR cache " << _cache;
					}
				} else {
					_errorMsg = "Error opening SDR cache: " + std::string(ipmi_sdr_ctx_errormsg(sdrCtx));
					increaseErrorCount();
					disconnect();
				}
			} else {
				int recordLength = 0;
				uint8_t recordBuf[IPMI_SDR_MAX_RECORD_LENGTH];
		
				if (ipmi_sdr_cache_search_record_id(sdrCtx, recordId) < 0) {
					_errorMsg = "Error searching SDR record: " + std::string(ipmi_sdr_ctx_errormsg(sdrCtx));
				} else {
					if ((recordLength = ipmi_sdr_cache_record_read(sdrCtx, recordBuf, IPMI_SDR_MAX_RECORD_LENGTH)) < 0) {
						_errorMsg = "Error reading SDR record: " + std::string(ipmi_sdr_ctx_errormsg(sdrCtx));
					} else {
						record.insert(record.end(), &recordBuf[0], &recordBuf[recordLength]);
						success = true;
					}
				}
				ipmi_sdr_cache_close(sdrCtx);
			}
		} else {
			increaseErrorCount();
			disconnect();
		}
	}
	
	ipmi_sdr_ctx_destroy(sdrCtx);

	if (!success) {
		throw std::runtime_error(_errorMsg);
	}
	return success;
}
	
int64_t IPMIHost::sendRawCmd(const std::vector<uint8_t>& rawCmd, uint8_t lsb, uint8_t msb) {
	uint8_t buf[256];
	int len = -1;
	int i;

	if (!IPMI_NET_FN_RQ_VALID(rawCmd[1])) {
		throw std::runtime_error("Error sending raw IPMI command: Invalid netfn value");
		return 0;
	}
	
	bool success = false;
	int retries = RETRIES;
	while (retries-- && !success) {
		if (connect() == 0) {
			if ((len = ipmi_cmd_raw(_ipmiCtx, rawCmd[0], rawCmd[1], &rawCmd[2],	rawCmd.size() - 2, buf, sizeof(buf))) < 0) {
				_errorMsg = "Error sending IPMI raw command: " + std::string(ipmi_ctx_errormsg(_ipmiCtx));
				increaseErrorCount();
				disconnect();
			} else {
				success = true;
			}
		} else {
			increaseErrorCount();
			disconnect();
		}
	}

#if 0
	std::cout << "IPMIHost::sendRawCmd() received " << len << " bytes: " << std::setw(2) << std::setfill('0') << std::hex;
	for (i = 0; i < len; i++) {
		std::cout << (unsigned) buf[i] << " ";
	}
	std::cout << std::dec << std::endl;
#endif

	if (!success) {
		throw std::runtime_error(_errorMsg);
		return 0;
	}

	std::stringstream ss;
	if (msb > len) {
		ss << "Error processing IPMI raw data: msb=" << msb << " > len=" << len;
	} else if (lsb > len) {
		ss << "Error processing IPMI raw data: lsb=" << lsb << " > len=" << len;
	}
	if (ss.gcount() > 0) {
		throw std::runtime_error(ss.str());
		return 0;
	}

	_errorCount = 0;
	
	int64_t val = 0;
	if (msb > lsb) {
		for (i = lsb; i <= msb; i++) {
			val |= ((int64_t) buf[i]) << (msb - i) * 8;
		}
	} else {
		for (i = lsb; i >= msb; i--) {
			val |= ((int64_t) buf[i]) << (i-msb) * 8;
		}
	}

	return val;
}
	
double IPMIHost::readSensorRecord(std::vector<uint8_t>& record) {
	uint8_t rawReading = 0;
	double *reading = NULL;
	uint16_t eventBitmask = 0;

	bool success = false;
	int retries = RETRIES;
	while (retries-- && !success) {
		if (connect() == 0) {
			if (!_sensorReadCtx) {
				_sensorReadCtx = ipmi_sensor_read_ctx_create(_ipmiCtx);
			}
			
			if (_sensorReadCtx) {
				if (ipmi_sensor_read(_sensorReadCtx, &record[0], record.size(), 0, &rawReading, &reading, &eventBitmask) < 0) {
					_errorMsg = "Error reading IPMI record: " + std::string(ipmi_sensor_read_ctx_errormsg(_sensorReadCtx));
					increaseErrorCount();
					disconnect();
				} else {
					success = true;
				}
			} else {
				_errorMsg = "Error creating sensor context: " + std::string(ipmi_ctx_errormsg(_ipmiCtx));
			}
		} else {
			increaseErrorCount();
			disconnect();
		}
	}

	double ret = .0;
	if (success && reading) {
		_errorCount = 0;
		ret = *reading;
		free(reading);
	} else {
		throw std::runtime_error(_errorMsg);
	}
	
	return ret;
}

void IPMIHost::increaseErrorCount() {
	uint64_t now = getTimestamp();
	if (_errorCount < 25) {
		_errorCount++;
	}
	if (_errorCount > 5) {
		_delayNextReadUntil = now + MS_TO_NS(500 * (_errorCount - 5));
	}
}

void IPMIHost::initializeStrand(boost::asio::io_service& io) {
	if (!_strand) {
		_strand = new boost::asio::io_service::strand(io);
	}
}

void IPMIHost::printConfig(LOG_LEVEL ll) {
  LOG_VAR(ll) << "  IPMIHost: " << _hostName;
  LOG_VAR(ll) << "   UserName:     " << _userName;
#ifdef DEBUG
  LOG_VAR(ll) << "   Password:     " << _password;
#else
  LOG_VAR(ll) << "   Password not shown";
#endif
  LOG_VAR(ll) << "   Cache:        " << _cache;
  LOG_VAR(ll) << "   Auth:         " << _auth;
  LOG_VAR(ll) << "   Priv:         " << _priv;
  LOG_VAR(ll) << "   Cipher:       " << _cipher;
  LOG_VAR(ll) << "   IPMI Version: " << _ipmiVersion;
  LOG_VAR(ll) << "   MQTT Part:    " << _mqttPart;
  LOG_VAR(ll) << "   Session Timeout:        " << _sessionTimeout;
  LOG_VAR(ll) << "   Retransmission Timeout: " << _retransmissionTimeout;
}