/**
* snmp_bc_manage_snmp_open:
* @hnd: Pointer to handler structure.
*
* .
*
* Returns:
* SA_OK - able to open a snmp session
**/
SaErrorT snmp_bc_manage_snmp_open(struct snmp_bc_hnd *custom_handle, SaHpiBoolT recovery_requested)
{
SaErrorT rv;
rv = SA_OK;
/* Windows32 specific net-snmp initialization (noop on unix) */
SOCK_STARTUP;
custom_handle->sessp = snmp_sess_open(&(custom_handle->session));
if (custom_handle->sessp == NULL) {
// snmp_perror("ack");
// snmp_log(LOG_ERR, "Something horrible happened!!!\n");
if (recovery_requested) {
rv = snmp_bc_recover_snmp_session(custom_handle);
} else {
rv = SA_ERR_HPI_NO_RESPONSE;
}
}
if (rv == SA_OK)
custom_handle->ss = snmp_sess_session(custom_handle->sessp);
return(rv);
}
int snmp_sess_synch_response(void * sessp,
struct snmp_pdu *PDU,
struct snmp_pdu **ResponsePDUP)
{
struct snmp_session *Session;
struct synch_state *state;
// int numfds, count;
// fd_set fdset;
// struct timeval timeout, *tvp;
// int block;
DWORD dwStart;
Session = snmp_sess_session(sessp);
state = Session->snmp_synch_state;
state->reqid = snmp_sess_send(sessp, PDU);
if (state->reqid == 0) {
*ResponsePDUP = NULL;
snmp_free_pdu(PDU);
return STAT_ERROR;
}
state->waiting = 1;
dwStart = GetTickCount();
while(state->waiting) {
// this does the timeout...
if( ( GetTickCount() - dwStart ) > 5000 ) break; // and fail...
Sleep( 10 ); // let the rest of the box run for a while...
}
*ResponsePDUP = state->pdu;
return state->status;
}
/** Write on/off status
*/
double setMainSwitch(HSNMP m_sessp,float value) {
struct snmp_pdu* pdu = snmp_pdu_create(SNMP_MSG_SET); // prepare set-request pdu
pdu->community = (u_char*)strdup(writeCommunity);
pdu->community_len = strlen(writeCommunity);
// for(each SET request to one crate) {
int v = (int) value;
snmp_pdu_add_variable(pdu,oidSysMainSwitch,lengthSysMainSwitch,ASN_INTEGER,(u_char*)&v,sizeof(v));
// } // endfor
struct snmp_pdu* response;
int status = snmp_sess_synch_response(m_sessp,pdu,&response);
/*
* Process the response.
*/
if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
/*
* SUCCESS: Print the result variables
*/
struct variable_list *vars;
// debug print
//for(vars = response->variables; vars; vars = vars->next_variable)
// print_variable(vars->name, vars->name_length, vars);
/* manipuate the information ourselves */
for(vars = response->variables; vars; vars = vars->next_variable) {
if (vars->type == ASN_OPAQUE_FLOAT) { // 0x78
value = *vars->val.floatVal;
}
else if (vars->type == ASN_OPAQUE_DOUBLE) { // 0x79
value = *vars->val.doubleVal;
}
else if(vars->type == ASN_INTEGER) { // 0x02
value = (double)*vars->val.integer;
}
}
} else {
/*
* FAILURE: print what went wrong!
*/
if (status == STAT_SUCCESS)
fprintf(stderr, "Error in packet\nReason: %s\n",
snmp_errstring(response->errstat));
else
snmp_sess_perror("snmpget",snmp_sess_session(m_sessp));
return 0;
}
snmp_free_pdu(response);
return value;
}
/** Get current from power supply
*/
double getCurrentMeasurement(HSNMP m_sessp, int channel) {
double value;
struct snmp_pdu* pdu = snmp_pdu_create(SNMP_MSG_GET); // prepare get-request pdu
// for(each GET request to one crate) {
snmp_add_null_var(pdu,oidOutputMeasurementCurrent[channel],lengthOutputMeasurementCurrent[channel]); // generate request data
// } // endfor
struct snmp_pdu* response;
int status = snmp_sess_synch_response(m_sessp,pdu,&response);
/*
* Process the response.
*/
if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
/*
* SUCCESS: Print the result variables
*/
struct variable_list *vars;
// debug print
//for(vars = response->variables; vars; vars = vars->next_variable)
// print_variable(vars->name, vars->name_length, vars);
/* manipuate the information ourselves */
for(vars = response->variables; vars; vars = vars->next_variable) {
if (vars->type == ASN_OPAQUE_FLOAT) { // 0x78
value = *vars->val.floatVal;
}
else if (vars->type == ASN_OPAQUE_DOUBLE) { // 0x79
value = *vars->val.doubleVal;
}
else if(vars->type == ASN_INTEGER) { // 0x02
value = (double)*vars->val.integer;
}
}
} else {
/*
* FAILURE: print what went wrong!
*/
if (status == STAT_SUCCESS)
fprintf(stderr, "Error in packet\nReason: %s\n",
snmp_errstring(response->errstat));
else
snmp_sess_perror("snmpget",snmp_sess_session(m_sessp));
return 0;
}
snmp_free_pdu(response);
return value;
}
// Creates a SNMP session
void snmpDeliverTrap_netsnmp::_createSession(
const String& targetHost,
Uint16 targetHostFormat,
Uint32 portNumber,
const String& securityName,
void*& sessionHandle,
snmp_session*& sessionPtr)
{
PEG_METHOD_ENTER(TRC_IND_HANDLER,
"snmpDeliverTrap_netsnmp::_createSession");
Sint32 libErr, sysErr;
char* errStr;
String exceptionStr;
struct snmp_session snmpSession;
{
AutoMutex autoMut(_sessionInitMutex);
snmp_sess_init(&snmpSession);
CString targetHostCStr = targetHost.getCString();
// peername has format: targetHost:portNumber
snmpSession.peername =
(char*)malloc((size_t)(strlen(targetHostCStr) + 1 + 32));
if (targetHostFormat == _IPV6_ADDRESS)
{
sprintf(snmpSession.peername, "udp6:[%s]:%u",
(const char*)targetHostCStr,
portNumber);
}
else
{
sprintf(snmpSession.peername, "%s:%u",
(const char*)targetHostCStr,
portNumber);
}
sessionHandle = snmp_sess_open(&snmpSession);
}
if (sessionHandle == NULL)
{
exceptionStr = _MSG_SESSION_OPEN_FAILED;
// Get library, system errno
snmp_error(&snmpSession, &libErr, &sysErr, &errStr);
exceptionStr.append(errStr);
free(errStr);
free(snmpSession.peername);
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
MessageLoaderParms(_MSG_SESSION_OPEN_FAILED_KEY, exceptionStr));
}
try
{
// get the snmp_session pointer
sessionPtr = snmp_sess_session(sessionHandle);
if (sessionPtr == NULL)
{
exceptionStr = _MSG_GET_SESSION_POINT_FAILED;
// Get library, system errno
snmp_sess_error(&snmpSession, &libErr, &sysErr, &errStr);
exceptionStr.append(errStr);
free(errStr);
free(snmpSession.peername);
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
_MSG_GET_SESSION_POINTER_FAILED_KEY,
exceptionStr));
}
// Community Name, default is public
String communityName;
if (securityName.size() == 0)
{
communityName.assign("public");
}
else
{
communityName = securityName;
}
free(snmpSession.peername);
free(sessionPtr->community);
CString communityNameCStr = communityName.getCString();
size_t communityNameLen = strlen(communityNameCStr);
sessionPtr->community = (u_char*)malloc(communityNameLen);
memcpy(sessionPtr->community, (const char*)communityNameCStr,
communityNameLen);
sessionPtr->community_len = communityNameLen;
}
catch (...)
{
_destroySession(sessionHandle);
PEG_METHOD_EXIT();
throw;
}
PEG_METHOD_EXIT();
}
/**
* snmp_bc_open:
* @handler_config: Pointer to hash table (passed by infrastructure)
*
* Open an SNMP BladeCenter/RSA plugin handler instance.
*
* Returns:
* Plugin handle - normal operation.
* NULL - on error.
**/
void *snmp_bc_open(GHashTable *handler_config)
{
struct oh_handler_state *handle;
struct snmp_bc_hnd *custom_handle;
char *hostname, *version, *sec_level, *authtype, *user, *pass, *community;
char *root_tuple;
root_tuple = (char *)g_hash_table_lookup(handler_config, "entity_root");
if (!root_tuple) {
dbg("Cannot find \"entity_root\" configuration parameter.");
return NULL;
}
hostname = (char *)g_hash_table_lookup(handler_config, "host");
if (!hostname) {
dbg("Cannot find \"host\" configuration parameter.");
return NULL;
}
handle = (struct oh_handler_state *)g_malloc0(sizeof(struct oh_handler_state));
custom_handle = (struct snmp_bc_hnd *)g_malloc0(sizeof(struct snmp_bc_hnd));
if (!handle || !custom_handle) {
dbg("Out of memory.");
return NULL;
}
handle->data = custom_handle;
handle->config = handler_config;
/* Initialize the lock */
/* g_static_rec_mutex_init(&handle->handler_lock); */
g_static_rec_mutex_init(&custom_handle->snmp_bc_hlock.lock);
custom_handle->snmp_bc_hlock.count = 0;
/* Initialize RPT cache */
handle->rptcache = (RPTable *)g_malloc0(sizeof(RPTable));
oh_init_rpt(handle->rptcache);
/* Initialize event log cache */
handle->elcache = oh_el_create(BC_EL_MAX_SIZE);
handle->elcache->gentimestamp = FALSE;
/* Initialize simulator tables */
if (is_simulator()) {
custom_handle->ss = NULL;
sim_init();
}
else {
/* Initialize SNMP library */
init_snmp("oh_snmp_bc");
snmp_sess_init(&(custom_handle->session));
custom_handle->session.peername = hostname;
/* Set retries/timeouts - based on testing with BC/BCT MM SNMP V3 agent */
custom_handle->session.retries = 3;
custom_handle->session.timeout = 5000000; /* in microseconds */
version = (char *)g_hash_table_lookup(handle->config, "version");
if (!version) {
dbg("Cannot find \"version\" configuration parameter.");
return NULL;
}
sec_level = (char *)g_hash_table_lookup(handle->config, "security_level");
authtype = (char *)g_hash_table_lookup(handle->config, "auth_type");
user = (char *)g_hash_table_lookup(handle->config, "security_name");
pass = (char *)g_hash_table_lookup(handle->config, "passphrase");
community = (char *)g_hash_table_lookup(handle->config, "community");
/* Configure SNMP V3 session */
if (!strcmp(version, "3")) {
if (!user) {
dbg("Cannot find \"security_name\" configuration parameter.");
return NULL;
}
custom_handle->session.version = SNMP_VERSION_3;
custom_handle->session.securityName = user;
custom_handle->session.securityNameLen = strlen(user);
custom_handle->session.securityLevel = SNMP_SEC_LEVEL_NOAUTH;
if (!strncmp(sec_level, "auth", 4)) { /* If using password */
if (!pass) {
dbg("Cannot find \"passphrase\" configuration parameter.");
return NULL;
}
custom_handle->session.securityLevel = SNMP_SEC_LEVEL_AUTHNOPRIV;
if (!authtype || !strcmp(authtype,"MD5")) {
custom_handle->session.securityAuthProto = usmHMACMD5AuthProtocol;
custom_handle->session.securityAuthProtoLen = USM_AUTH_PROTO_MD5_LEN;
} else if (!strcmp(authtype,"SHA")) {
custom_handle->session.securityAuthProto = usmHMACSHA1AuthProtocol;
custom_handle->session.securityAuthProtoLen = USM_AUTH_PROTO_SHA_LEN;
} else {
dbg("Unrecognized authenication type=%s.", authtype);
return NULL;
}
custom_handle->session.securityAuthKeyLen = USM_AUTH_KU_LEN;
if (generate_Ku(custom_handle->session.securityAuthProto,
custom_handle->session.securityAuthProtoLen,
(u_char *) pass, strlen(pass),
custom_handle->session.securityAuthKey,
&(custom_handle->session.securityAuthKeyLen)) != SNMPERR_SUCCESS) {
snmp_perror("snmp_bc");
snmp_log(LOG_ERR,
"Error generating Ku from authentication passphrase.\n");
dbg("Unable to establish SNMP authnopriv session.");
return NULL;
}
if (!strcmp(sec_level, "authPriv")) { /* if using encryption */
custom_handle->session.securityLevel = SNMP_SEC_LEVEL_AUTHPRIV;
custom_handle->session.securityPrivProto = usmDESPrivProtocol;
custom_handle->session.securityPrivProtoLen = USM_PRIV_PROTO_DES_LEN;
custom_handle->session.securityPrivKeyLen = USM_PRIV_KU_LEN;
if (generate_Ku(custom_handle->session.securityAuthProto,
custom_handle->session.securityAuthProtoLen,
(u_char *) pass, strlen(pass),
custom_handle->session.securityPrivKey,
&(custom_handle->session.securityPrivKeyLen)) != SNMPERR_SUCCESS) {
snmp_perror("snmp_bc");
snmp_log(LOG_ERR,
"Error generating Ku from private passphrase.\n");
dbg("Unable to establish SNMP authpriv session.");
return NULL;
}
}
}
/* Configure SNMP V1 session */
} else if (!strcmp(version, "1")) {
if (!community) {
dbg("Cannot find \"community\" configuration parameter.");
return NULL;
}
custom_handle->session.version = SNMP_VERSION_1;
custom_handle->session.community = (u_char *)community;
custom_handle->session.community_len = strlen(community);
} else {
dbg("Unrecognized SNMP version=%s.", version);
return NULL;
}
/* Windows32 specific net-snmp initialization (noop on unix) */
SOCK_STARTUP;
custom_handle->sessp = snmp_sess_open(&(custom_handle->session));
if (!custom_handle->sessp) {
snmp_perror("ack");
snmp_log(LOG_ERR, "Something horrible happened!!!\n");
dbg("Unable to open SNMP session.");
return NULL;
}
custom_handle->ss = snmp_sess_session(custom_handle->sessp);
}
/* Determine platform type and daylight savings time */
{
const char *oid;
struct snmp_value get_value;
SaErrorT err;
err = snmp_bc_snmp_get(custom_handle, SNMP_BC_PLATFORM_OID_RSA, &get_value, SAHPI_FALSE);
if (err == SA_OK) {
trace("Found RSA");
custom_handle->platform = SNMP_BC_PLATFORM_RSA;
}
else {
err = snmp_bc_snmp_get(custom_handle, SNMP_BC_PLATFORM_OID_BCT, &get_value, SAHPI_FALSE);
if (err == SA_OK) {
trace("Found BCT");
custom_handle->platform = SNMP_BC_PLATFORM_BCT;
}
else {
err = snmp_bc_snmp_get(custom_handle, SNMP_BC_PLATFORM_OID_BC, &get_value, SAHPI_FALSE);
if (err == SA_OK) {
trace("Found BC");
custom_handle->platform = SNMP_BC_PLATFORM_BC;
}
else {
dbg("Cannot read model type=%s; Error=%d.",
SNMP_BC_PLATFORM_OID_BCT, err);
return NULL;
}
}
}
/* DST */
if (custom_handle->platform == SNMP_BC_PLATFORM_RSA) { oid = SNMP_BC_DST_RSA; }
else { oid = SNMP_BC_DST; }
err = snmp_bc_snmp_get(custom_handle, oid, &get_value, SAHPI_TRUE);
if (err == SA_OK) {
strcpy(custom_handle->handler_timezone, get_value.string);
}
else {
dbg("Cannot read DST=%s; Error=%d.", oid, get_value.type);
return NULL;
}
}
/* Initialize "String to Event" mapping hash table */
if (errlog2event_hash_use_count == 0) {
if (errlog2event_hash_init(custom_handle)) {
dbg("Out of memory.");
return NULL;
}
}
errlog2event_hash_use_count++;
/* Initialize "Event Number to HPI Event" mapping hash table */
if (event2hpi_hash_init(handle)) {
dbg("Out of memory.");
return NULL;
}
if (is_simulator()) {
sim_banner(custom_handle);
}
return handle;
}
/**
* snmp_bc_open:
* @handler_config: Pointer to hash table (passed by infrastructure)
*
* Open an SNMP BladeCenter/RSA plugin handler instance.
*
* Returns:
* Plugin handle - normal operation.
* NULL - on error.
**/
void *snmp_bc_open(GHashTable *handler_config)
{
struct oh_handler_state *handle;
struct snmp_bc_hnd *custom_handle;
char *hostname, *version, *sec_level,
*authtype, *user, *pass, *community,
*context_name, *count_per_getbulk,
*privacy_passwd, *privacy_protocol;
char *root_tuple;
if (!handler_config) {
dbg("INVALID PARM - NULL handler_config pointer.");
return NULL;
}
root_tuple = (char *)g_hash_table_lookup(handler_config, "entity_root");
if (!root_tuple) {
dbg("Cannot find \"entity_root\" configuration parameter.");
return NULL;
}
hostname = (char *)g_hash_table_lookup(handler_config, "host");
if (!hostname) {
dbg("Cannot find \"host\" configuration parameter.");
return NULL;
}
handle = (struct oh_handler_state *)g_malloc0(sizeof(struct oh_handler_state));
custom_handle = (struct snmp_bc_hnd *)g_malloc0(sizeof(struct snmp_bc_hnd));
if (!handle || !custom_handle) {
dbg("Out of memory.");
return NULL;
}
handle->data = custom_handle;
handle->config = handler_config;
/* Initialize the lock */
/* g_static_rec_mutex_init(&handle->handler_lock); */
g_static_rec_mutex_init(&custom_handle->snmp_bc_hlock.lock);
custom_handle->snmp_bc_hlock.count = 0;
/* Initialize resource masks */
/* Set all masks and counts to zero's */
custom_handle->max_pb_supported = 0; /* pb - processor blade */
custom_handle->max_blower_supported = 0; /* blower - fan/blower */
custom_handle->max_pm_supported = 0; /* pm - power module */
custom_handle->max_sm_supported = 0; /* sm - switch module */
custom_handle->max_mm_supported = 0; /* mm - management module */
custom_handle->max_mt_supported = 0; /* mt - media tray */
memset(&custom_handle->installed_pb_mask, '\0', SNMP_BC_MAX_RESOURCES_MASK);
memset(&custom_handle->installed_blower_mask, '\0', SNMP_BC_MAX_RESOURCES_MASK);
memset(&custom_handle->installed_pm_mask, '\0', SNMP_BC_MAX_RESOURCES_MASK);
memset(&custom_handle->installed_sm_mask, '\0', SNMP_BC_MAX_RESOURCES_MASK);
memset(&custom_handle->installed_mm_mask, '\0', SNMP_BC_MAX_RESOURCES_MASK);
custom_handle->installed_mt_mask = 0;
/* Indicate this is the 1st discovery (T0 discovery) */
/* Use to see if we need to create events for log entries. */
/* Do not report any event from event log entries, for */
/* entries that are created before this instance of OpenHPI */
custom_handle->isFirstDiscovery = SAHPI_TRUE;
/* Initialize RPT cache */
handle->rptcache = (RPTable *)g_malloc0(sizeof(RPTable));
oh_init_rpt(handle->rptcache);
/* Initialize event log cache */
handle->elcache = oh_el_create(BC_EL_MAX_SIZE);
handle->elcache->gentimestamp = FALSE;
/* Initialize simulator tables */
if (is_simulator()) {
custom_handle->ss = NULL;
sim_init();
}
else {
/* Initialize SNMP library */
init_snmp("oh_snmp_bc");
snmp_sess_init(&(custom_handle->session));
custom_handle->session.peername = hostname;
/* Set retries/timeouts - based on testing with BC/BCT MM SNMP V3 agent */
custom_handle->session.retries = 3;
custom_handle->session.timeout = 5000000; /* in microseconds */
version = (char *)g_hash_table_lookup(handle->config, "version");
if (!version) {
dbg("Cannot find \"version\" configuration parameter.");
return NULL;
}
sec_level = (char *)g_hash_table_lookup(handle->config, "security_level");
authtype = (char *)g_hash_table_lookup(handle->config, "auth_type");
user = (char *)g_hash_table_lookup(handle->config, "security_name");
pass = (char *)g_hash_table_lookup(handle->config, "passphrase");
community = (char *)g_hash_table_lookup(handle->config, "community");
context_name = (char *)g_hash_table_lookup(handle->config, "context_name");
count_per_getbulk = (char *)g_hash_table_lookup(handle->config, "count_per_getbulk");
privacy_passwd = (char *)g_hash_table_lookup(handle->config, "privacy_passwd");
privacy_protocol = (char *)g_hash_table_lookup(handle->config, "privacy_protocol");
/* Configure SNMP V3 session */
if (!strcmp(version, "3")) {
if (!user) {
dbg("Cannot find \"security_name\" configuration parameter.");
return NULL;
}
custom_handle->session.version = SNMP_VERSION_3;
custom_handle->session.securityName = user;
custom_handle->session.securityNameLen = strlen(user);
custom_handle->session.securityLevel = SNMP_SEC_LEVEL_NOAUTH;
if (!strncmp(sec_level, "auth", 4)) { /* If using password */
if (!pass) {
dbg("Cannot find \"passphrase\" configuration parameter.");
return NULL;
}
custom_handle->session.securityLevel = SNMP_SEC_LEVEL_AUTHNOPRIV;
if (!authtype || !strcmp(authtype,"MD5")) {
custom_handle->session.securityAuthProto = usmHMACMD5AuthProtocol;
custom_handle->session.securityAuthProtoLen = USM_AUTH_PROTO_MD5_LEN;
} else if (!strcmp(authtype,"SHA")) {
custom_handle->session.securityAuthProto = usmHMACSHA1AuthProtocol;
custom_handle->session.securityAuthProtoLen = USM_AUTH_PROTO_SHA_LEN;
} else {
dbg("Unrecognized authenication type=%s.", authtype);
return NULL;
}
custom_handle->session.securityAuthKeyLen = USM_AUTH_KU_LEN;
if (generate_Ku(custom_handle->session.securityAuthProto,
custom_handle->session.securityAuthProtoLen,
(u_char *) pass, strlen(pass),
custom_handle->session.securityAuthKey,
&(custom_handle->session.securityAuthKeyLen)) != SNMPERR_SUCCESS) {
snmp_perror("snmp_bc");
snmp_log(LOG_ERR,
"Error generating Ku from authentication passphrase.\n");
dbg("Unable to establish SNMP authnopriv session.");
return NULL;
}
if (!strcmp(sec_level, "authPriv")) { /* if using encryption */
if (!privacy_passwd) {
dbg("Cannot find \"privacy_passwd\" configuration parameter.");
return NULL;
}
custom_handle->session.securityLevel = SNMP_SEC_LEVEL_AUTHPRIV;
custom_handle->session.securityPrivProto = usmDESPrivProtocol;
custom_handle->session.securityPrivProtoLen = USM_PRIV_PROTO_DES_LEN;
custom_handle->session.securityPrivKeyLen = USM_PRIV_KU_LEN;
if (generate_Ku(custom_handle->session.securityAuthProto,
custom_handle->session.securityAuthProtoLen,
(u_char *) privacy_passwd, strlen(privacy_passwd),
custom_handle->session.securityPrivKey,
&(custom_handle->session.securityPrivKeyLen)) != SNMPERR_SUCCESS) {
snmp_perror("snmp_bc");
snmp_log(LOG_ERR,
"Error generating Ku from private passphrase.\n");
dbg("Unable to establish SNMP authpriv session.");
return NULL;
}
}
if (count_per_getbulk != NULL)
{
custom_handle->count_per_getbulk = atoi((char *)count_per_getbulk);
if (custom_handle->count_per_getbulk <= 10) {
custom_handle->count_per_getbulk = 10;
}
} else {
custom_handle->count_per_getbulk = SNMP_BC_BULK_DEFAULT;
}
if (context_name != NULL)
{
custom_handle->session.contextName = (char *)context_name;
custom_handle->session.contextNameLen = strlen(context_name);
}
}
/* Configure SNMP V1 session */
} else if (!strcmp(version, "1")) {
if (!community) {
dbg("Cannot find \"community\" configuration parameter.");
return NULL;
}
custom_handle->session.version = SNMP_VERSION_1;
custom_handle->session.community = (u_char *)community;
custom_handle->session.community_len = strlen(community);
} else {
dbg("Unrecognized SNMP version=%s.", version);
return NULL;
}
/* Windows32 specific net-snmp initialization (noop on unix) */
SOCK_STARTUP;
custom_handle->sessp = snmp_sess_open(&(custom_handle->session));
if (!custom_handle->sessp) {
snmp_perror("ack");
snmp_log(LOG_ERR, "Something horrible happened!!!\n");
dbg("Unable to open SNMP session.");
return NULL;
}
custom_handle->ss = snmp_sess_session(custom_handle->sessp);
}
/* Determine BladeCenter chassis type */
{
const char *oid;
struct snmp_value get_value;
SaErrorT err;
do {
err = snmp_bc_snmp_get(custom_handle, SNMP_BC_CHASSIS_TYPE_OID, &get_value, SAHPI_FALSE);
if (err == SA_OK) {
int chassis_type, chassis_subtype;
chassis_type = get_value.integer;
err = snmp_bc_snmp_get(custom_handle, SNMP_BC_CHASSIS_SUBTYPE_OID, &get_value, SAHPI_FALSE);
if (err) {
dbg("Cannot read model subtype");
return NULL;
}
chassis_subtype = get_value.integer;
if (chassis_type == SNMP_BC_CHASSIS_TYPE_BC &&
chassis_subtype == SNMP_BC_CHASSIS_SUBTYPE_ORIG) {
trace("Found BC");
custom_handle->platform = SNMP_BC_PLATFORM_BC;
break;
}
if (chassis_type == SNMP_BC_CHASSIS_TYPE_BC &&
chassis_subtype == SNMP_BC_CHASSIS_SUBTYPE_H) {
trace("Found BCH");
custom_handle->platform = SNMP_BC_PLATFORM_BCH;
break;
}
if (chassis_type == SNMP_BC_CHASSIS_TYPE_BCT &&
chassis_subtype == SNMP_BC_CHASSIS_SUBTYPE_ORIG) {
trace("Found BCT");
custom_handle->platform = SNMP_BC_PLATFORM_BCT;
break;
}
dbg("Unknown BladeCenter model");
return NULL;
}
else { /* Older MM software doesn't support chassis type and subtype OIDs */
err = snmp_bc_snmp_get(custom_handle, SNMP_BC_PLATFORM_OID_BCT, &get_value, SAHPI_FALSE);
if (err == SA_OK) {
trace("Found BCT");
custom_handle->platform = SNMP_BC_PLATFORM_BCT;
break;
}
err = snmp_bc_snmp_get(custom_handle, SNMP_BC_PLATFORM_OID_BC, &get_value, SAHPI_FALSE);
if (err == SA_OK) {
trace("Found BC");
custom_handle->platform = SNMP_BC_PLATFORM_BC;
break;
}
err = snmp_bc_snmp_get(custom_handle, SNMP_BC_PLATFORM_OID_RSA, &get_value, SAHPI_FALSE);
if (err == SA_OK) {
trace("Found RSA");
custom_handle->platform = SNMP_BC_PLATFORM_RSA;
break;
}
dbg("Unknown BladeCenter model");
return NULL;
}
} while(0);
/* Determine if daylight savings time (DST) is enabled */
if (custom_handle->platform == SNMP_BC_PLATFORM_RSA) { oid = SNMP_BC_DST_RSA; }
else { oid = SNMP_BC_DST; }
err = snmp_bc_snmp_get(custom_handle, oid, &get_value, SAHPI_TRUE);
if (err == SA_OK) {
strcpy(custom_handle->handler_timezone, get_value.string);
}
else {
dbg("Cannot read DST=%s; Error=%d.", oid, get_value.type);
return NULL;
}
}
/* Initialize "String to Event" mapping hash table */
if (errlog2event_hash_use_count == 0) {
if (errlog2event_hash_init(custom_handle)) {
dbg("Out of memory.");
return NULL;
}
}
errlog2event_hash_use_count++;
/* Initialize "Event Number to HPI Event" mapping hash table */
if (event2hpi_hash_init(handle)) {
dbg("Out of memory.");
return NULL;
}
if (is_simulator()) {
sim_banner(custom_handle);
}
return handle;
}
int
snmp_sess_synch_response(void *sessp,
netsnmp_pdu *pdu, netsnmp_pdu **response)
{
netsnmp_session *ss;
struct synch_state lstate, *state;
snmp_callback cbsav;
void *cbmagsav;
int numfds, count;
fd_set fdset;
struct timeval timeout, *tvp;
int block;
ss = snmp_sess_session(sessp);
memset((void *) &lstate, 0, sizeof(lstate));
state = &lstate;
cbsav = ss->callback;
cbmagsav = ss->callback_magic;
ss->callback = snmp_synch_input;
ss->callback_magic = (void *) state;
if ((state->reqid = snmp_sess_send(sessp, pdu)) == 0) {
snmp_free_pdu(pdu);
state->status = STAT_ERROR;
} else
state->waiting = 1;
while (state->waiting) {
numfds = 0;
FD_ZERO(&fdset);
block = SNMPBLOCK;
tvp = &timeout;
timerclear(tvp);
snmp_sess_select_info(sessp, &numfds, &fdset, tvp, &block);
if (block == 1)
tvp = NULL; /* block without timeout */
count = select(numfds, &fdset, 0, 0, tvp);
if (count > 0) {
snmp_sess_read(sessp, &fdset);
} else
switch (count) {
case 0:
snmp_sess_timeout(sessp);
break;
case -1:
if (errno == EINTR) {
continue;
} else {
snmp_errno = SNMPERR_GENERR;
/*
* CAUTION! if another thread closed the socket(s)
* waited on here, the session structure was freed.
* It would be nice, but we can't rely on the pointer.
* ss->s_snmp_errno = SNMPERR_GENERR;
* ss->s_errno = errno;
*/
snmp_set_detail(strerror(errno));
}
/*
* FALLTHRU
*/
default:
state->status = STAT_ERROR;
state->waiting = 0;
}
}
*response = state->pdu;
ss->callback = cbsav;
ss->callback_magic = cbmagsav;
return state->status;
}
/**
* snmp_get
* @ss: a handle to the snmp session needed to make an
* snmp transaction.
* @objid: string containing the OID entry.
* @value: the value received from snmp will be put in this union.
*
* Gets a single value indicated by the objectid using snmp.
* In the case of multiple values being returned, the type in @value will be
* ASN_NULL (0x05). Nothing else in @value will be filled in.
*
* Returns: 0 if successful, <0 if there was an error.
**/
SaErrorT snmp_get( void *sessp,
const char *objid,
struct snmp_value *value)
{
struct snmp_pdu *pdu;
struct snmp_pdu *response;
struct snmp_session *session;
oid anOID[MAX_OID_LEN];
size_t anOID_len = MAX_OID_LEN;
struct variable_list *vars;
SaErrorT returncode = SA_OK;
int status;
/*
* Create the PDU for the data for our request.
*/
pdu = snmp_pdu_create(SNMP_MSG_GET);
read_objid(objid, anOID, &anOID_len);
snmp_add_null_var(pdu, anOID, anOID_len);
/*
* Send the Request out.
*/
status = snmp_sess_synch_response(sessp, pdu, &response);
/*
* Process the response.
*/
if (status == STAT_SUCCESS) {
if(response->errstat == SNMP_ERR_NOERROR) {
vars = response->variables;
value->type = vars->type;
if (vars->next_variable != NULL) {
/* There are more values, set return type to null. */
value->type = ASN_NULL;
} else if ( !(CHECK_END(vars->type)) ) {
/* This is one of the exception condition */
returncode = SA_ERR_HPI_NOT_PRESENT;
dbg("snmp exception %d \n",vars->type);
dbg("OID=%s", objid);
} else if ( (vars->type == ASN_INTEGER) ||
(vars->type == ASN_COUNTER) ||
(vars->type == ASN_UNSIGNED) ) {
value->integer = *(vars->val.integer);
} else {
value->str_len = vars->val_len;
if (value->str_len >= MAX_ASN_STR_LEN)
value->str_len = MAX_ASN_STR_LEN;
else value->string[value->str_len] = '\0';
memcpy(value->string, vars->val.string, value->str_len);
}
} else {
dbg("Error in packet %s\nReason: %s\n",
objid, snmp_errstring(response->errstat));
returncode = errstat2hpi(response->errstat);
}
} else {
value->type = (u_char)0x00;
session = snmp_sess_session(sessp);
snmp_sess_perror("snmpget", session);
dbg("OID=%s", objid);
returncode = snmpstat2hpi(status);
}
/* Clean up: free the response */
if (response) snmp_free_pdu(response);
return (returncode);
}
/**
* snmp_set2: Gets a single value indicated by the objectid
* using snmp.
* @handle: a handle to the snmp session needed to make an
* snmp transaction.
* @objid: string containing the OID entry.
* @value: the value received from snmp will be put in this union.
*
* In the case of multiple values being returned, the type in 'value' will be
* ASN_NULL (0x05). Nothing else in 'value' will be filled in.
* Use snmp_get_all for doing gets that return multiple values.
*
* Return value: Returns 0 if successful, -1 if there was an error.
**/
SaErrorT snmp_set2(void *sessp,
oid *objid,
size_t objid_len,
struct snmp_value *value)
{
struct snmp_pdu *pdu;
struct snmp_pdu *response;
struct variable_list *vars;
struct snmp_session *session;
void *dataptr = NULL;
int status = 0;
SaErrorT rtncode = SA_OK; /* Default - All is OK */
/*
* Create the PDU for the data for our request.
*/
pdu = snmp_pdu_create(SNMP_MSG_SET);
switch (value->type)
{
case ASN_INTEGER:
case ASN_UNSIGNED:
case ASN_COUNTER:
dataptr = &value->integer;
break;
case ASN_OCTET_STR:
dataptr = value->string;
break;
default:
rtncode = SA_ERR_HPI_INVALID_PARAMS;
dbg("datatype %c not yet supported by snmp_set2()",
value->type);
break;
}
if (rtncode == SA_OK) {
/*
* Set the data to send out
*/
/* Old code - snmp_add_var(pdu, objid, objid_len, datatype, dataptr); */
//int retcode = snmp_add_var(pdu, objid, objid_len, datatype, dataptr);
snmp_pdu_add_variable(pdu, objid, objid_len, value->type, dataptr, value->str_len);
/*
* Send the Request out.
*/
status = snmp_sess_synch_response(sessp, pdu, &response);
/*
* Process the response.
*/
if (status == STAT_SUCCESS) {
vars = response->variables;
if (response->errstat == SNMP_ERR_NOERROR) {
/* display data */
#ifdef DEBUG
fprintf(stderr, "*** snmp_set2 ******************************************\n");
if (CHECK_END(response->variables->type)) {
fprint_variable(stderr,
response->variables->name,
response->variables->name_length,
response->variables);
} else
fprintf(stderr, "snmp_set2(): No idea.\n");
fprintf(stderr, "********************************************************\n");
#endif
if (!(CHECK_END(response->variables->type)) ) {
/* This is one of the exception condition */
rtncode = SA_ERR_HPI_NOT_PRESENT;
dbg("snmp exception %d \n",vars->type);
}
} else {
dbg("snmp_set2: Error in packet, Reason: %s",
snmp_errstring(response->errstat));
rtncode = errstat2hpi(response->errstat);
}
} else {
session = snmp_sess_session(sessp);
snmp_sess_perror("snmpset", session);
rtncode = snmpstat2hpi(status);
}
/* Clean up: free the response */
if (response) snmp_free_pdu(response);
}
return rtncode;
}
/**
* snmp_get2: Gets a single value indicated by the objectid
* using snmp.
* @handle: a handle to the snmp session needed to make an
* snmp transaction.
* @objid: string containing the OID entry.
* @value: the value received from snmp will be put in this union.
*
* In the case of multiple values being returned, the type in 'value' will be
* ASN_NULL (0x05). Nothing else in 'value' will be filled in.
* Use snmp_get_all for doing gets that return multiple values.
*
* Return value: Returns 0 if successful, <0 if there was an error.
**/
SaErrorT snmp_get2(void *sessp,
oid *objid,
size_t objid_len,
struct snmp_value *value)
{
struct snmp_pdu *pdu;
struct snmp_pdu *response;
struct snmp_session *session;
struct variable_list *vars;
SaErrorT returncode = SA_OK;
int i;
int status;
/*
* Create the PDU for the data for our request.
*/
pdu = snmp_pdu_create(SNMP_MSG_GET);
snmp_add_null_var(pdu, objid, objid_len);
/*
* Send the Request out.
*/
status = snmp_sess_synch_response(sessp, pdu, &response);
/*
* Process the response.
*/
if (status == STAT_SUCCESS) {
if (response->errstat == SNMP_ERR_NOERROR) {
vars = response->variables;
value->type = vars->type;
if (vars->next_variable != NULL) {
/* If there are more values, set return type to null. */
value->type = ASN_NULL;
} else if ( !(CHECK_END(vars->type)) ) {
/* This is one of the exception condition */
returncode = SA_ERR_HPI_NOT_PRESENT;
dbg("snmp exception %d \n",vars->type);
} else if ( (vars->type == ASN_INTEGER) ||
(vars->type == ASN_COUNTER) ||
(vars->type == ASN_UNSIGNED) ) {
value->integer = *(vars->val.integer);
} else {
value->str_len = vars->val_len;
if (value->str_len >= MAX_ASN_STR_LEN)
value->str_len = MAX_ASN_STR_LEN;
else value->string[value->str_len] = '\0';
memcpy(value->string, vars->val.string, value->str_len);
}
/* display data */
#ifdef DEBUG
if (CHECK_END(vars->type)) {
fprintf(stderr, "*** snmp_get2 ******************************************\n");
fprint_variable(stderr,
vars->name,
vars->name_length,
vars);
fprintf(stderr, "********************************************************\n");
} else {
dbg("snmp_get2(): No idea.Unknown Type: %X", vars->type);
fprint_variable(stderr,
vars->name,
vars->name_length,
vars);
}
#endif
} else {
dbg("Error, Reason: %s",
snmp_errstring(response->errstat));
fprintf(stderr, "objid: ");
for(i = 0; i<objid_len; i++ )
fprintf(stderr, "%d.", (int)objid[i]);
fprintf(stderr, "\n");
returncode = errstat2hpi(response->errstat); }
} else {
session = snmp_sess_session(sessp);
snmp_sess_perror("snmpget", session);
returncode = snmpstat2hpi(status);
}
/* Clean up: free the response */
sc_free_pdu(&response);
return (returncode);
}
/**
* snmp_set
* @ss: a handle to the snmp session needed to make an snmp transaction.
* @objid: string containing the OID to set.
* @value: the value to set the oid with.
*
* Sets a value where indicated by the objectid
* using snmp.
*
* Returns: 0 if Success, less than 0 if Failure.
**/
SaErrorT snmp_set(
void *sessp,
char *objid,
struct snmp_value value)
{
struct snmp_pdu *pdu;
struct snmp_pdu *response;
struct snmp_session *session;
oid anOID[MAX_OID_LEN];
size_t anOID_len = MAX_OID_LEN;
void *dataptr = NULL;
int status = 0;
SaErrorT rtncode = 0;
/*
* Create the PDU for the data for our request.
*/
pdu = snmp_pdu_create(SNMP_MSG_SET);
read_objid(objid, anOID, &anOID_len);
rtncode = 0; /* Default - All is OK */
switch (value.type)
{
case ASN_INTEGER:
case ASN_UNSIGNED:
case ASN_COUNTER:
dataptr = &value.integer;
break;
case ASN_OCTET_STR:
dataptr = value.string;
break;
default:
rtncode = SA_ERR_HPI_INVALID_PARAMS;
dbg("datatype %c not yet supported by snmp_set()\n", value.type);
break;
}
if (rtncode == 0) {
/*
* Set the data to send out
*/
/* Old code - int rc = snmp_add_var(pdu, objid, objid_len, datatype, dataptr) */
/* was missing checking for rc, so there was no OID and no data was */
/* included in the package. */
/* Since snmp_add_var() converts input data to string then call */
/* snmp_pdu_add_variable(), we stick with add_variable() for efficiency */
snmp_pdu_add_variable(pdu, anOID, anOID_len, value.type, dataptr, value.str_len);
/*
* Send the Request out.
*/
status = snmp_sess_synch_response(sessp, pdu, &response);
/*
* Process the response.
*/
if (status == STAT_SUCCESS)
rtncode = errstat2hpi(response->errstat);
else {
session = snmp_sess_session(sessp);
snmp_sess_perror("snmpset", session);
rtncode = snmpstat2hpi(status);;
}
/* Clean up: free the response */
if (response) snmp_free_pdu(response);
}
return rtncode;
}
