/** * 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; }