bmssnmpagent.cpp

利用Windows自带的api采用snmp协议读取网络设备运行状态。

	if(this->GetRequest(asnOid,OidValues)!=0){
		return false;
	}
	SnmpUtilOidFree(&asnOid);
	return true;
}

int BmsSnmpAgent::GetRequest( AsnObjectIdentifier &asnOid ,std::string &OidValues)
{
	char *asciiStr, *tmpStr;
	AsnInteger	errorStatus=0;	// Error type that is returned if encountered
	AsnInteger	errorIndex=0;		// Works with variable above

	SnmpVarBindList snmpVarList;
	snmpVarList.list = NULL;
	snmpVarList.len = 0;

	snmpVarList.list = (SnmpVarBind *)SNMP_realloc(snmpVarList.list, sizeof(SnmpVarBind) *snmpVarList.len); 
	snmpVarList.len++;	

	// Assigning OID to variable bindings list
	SnmpUtilOidCpy(&snmpVarList.list[0].name,&asnOid);
	snmpVarList.list[0].value.asnType = ASN_NULL;

	// initiates the GET request
	if(!SnmpMgrRequest(m_lpMgrSession,SNMP_PDU_GET,&snmpVarList,&errorStatus,&errorIndex))
	{		
		SnmpUtilVarBindListFree(&snmpVarList);
		SnmpUtilOidFree(&asnOid);

		asciiStr = (char*)malloc(sizeof(char)*128);
		PrintStatusError(errorStatus,tmpStr);
		sprintf(asciiStr,"A Snmp Request Failed\nErrorStatus: %s  ErrorIndex: %d",tmpStr,errorIndex);
		m_lastErMsg = asciiStr;
		
		free(asciiStr);
		free(tmpStr);		
		return 1;
	}
	if(errorStatus > 0)
	{
		SnmpUtilVarBindListFree(&snmpVarList);
		SnmpUtilOidFree(&asnOid);

		asciiStr = (char*)malloc(sizeof(char)*128);
		PrintStatusError(errorStatus,tmpStr);
		sprintf(asciiStr,"B ErrorStatus: %s  ErrorIndex: %d",tmpStr,errorIndex);
		m_lastErMsg = asciiStr;
		free(asciiStr);
		free(tmpStr);
		return 2;
	}

	asciiStr = SNMP_AnyToStr(&snmpVarList.list[0].value);


	SnmpUtilVarBindListFree(&snmpVarList);	
	OidValues = asciiStr;

	if(asciiStr)
		SnmpUtilMemFree(asciiStr);

	return 0;

}

char * BmsSnmpAgent::SNMP_AnyToStr(AsnObjectSyntax *sAny)
{
	DWORD dwValue = 0;
	UINT uLen = 0;
	BYTE *puData = 0;
	char *pString = NULL;

	switch ( sAny->asnType )
	{
	case ASN_INTEGER:    
		pString = (char *) SnmpUtilMemAlloc(33);
		if(pString)
			ltoa(sAny->asnValue.number, pString, 10 );
		break;
	case ASN_RFC1155_COUNTER:
		dwValue = sAny->asnValue.counter;
		pString = (char *) SnmpUtilMemAlloc( 33 );
		if(pString)
			ultoa(dwValue, pString, 10);
		break;
	case ASN_RFC1155_GAUGE:
		dwValue = sAny->asnValue.gauge;
		pString = (char *) SnmpUtilMemAlloc(33);
		if (pString)
			ultoa(dwValue, pString, 10);
		break;
	case ASN_RFC1155_TIMETICKS:
		dwValue = sAny->asnValue.ticks;
		pString = (char *) SnmpUtilMemAlloc(33);
		if (pString)
			ultoa(dwValue, pString, 10);
		break;
	case ASN_OCTETSTRING:   /* Same as ASN_RFC1213_DISPSTRING */
		uLen = sAny->asnValue.string.length+1;
		puData = sAny->asnValue.string.stream;
		pString = (char *) SnmpUtilMemAlloc(uLen + 1);
		if(pString)
		{
			if (sAny->asnValue.arbitrary.length)
			{
				strncpy(pString, (const char*)puData, uLen -1);
				pString[uLen] = '\0';
			}
		}
		break;
	case ASN_SEQUENCE:      /* Same as ASN_SEQUENCEOF */
		uLen = sAny->asnValue.sequence.length;
		puData = sAny->asnValue.sequence.stream;
		if(pString)
		{
			if (sAny->asnValue.arbitrary.length)
			{
				strncpy(pString, (const char*)puData, uLen -1);
				pString[uLen] = '\0';
			}
		}
		break;
	case ASN_RFC1155_IPADDRESS:
		if (sAny->asnValue.address.length )
		{
			UINT i;
			char szBuf[17];

			uLen = sAny->asnValue.address.length;
			puData = sAny->asnValue.address.stream;

			pString = (char *) SnmpUtilMemAlloc( uLen * 4 );
			if(pString)
			{
				pString[0] = '\0';

				for (i = 0; i < uLen; i++)
				{
					lstrcat( pString, itoa( puData[i], szBuf, 10 ) );    
					if( i < uLen-1 )
						lstrcat( pString, "." );
				}
			}
		}
		else
			pString = NULL;
		break;
	case ASN_RFC1155_OPAQUE:
		if( sAny->asnValue.arbitrary.length )
		{
			uLen = sAny->asnValue.arbitrary.length;
			puData = sAny->asnValue.arbitrary.stream;
			pString = (char *) SnmpUtilMemAlloc(uLen + 1);
			if (pString)
			{
				if (sAny->asnValue.arbitrary.length)
				{
					strncpy(pString, (const char*)puData, uLen -1);
					pString[uLen] = '\0';
				}
			}
		}
		else
			pString = NULL;
		break;
	case ASN_OBJECTIDENTIFIER:
		if( sAny->asnValue.object.idLength )
		{
			pString = (char *) SnmpUtilMemAlloc( sAny->asnValue.object.idLength * 5 );
			if(pString)
			{
				UINT i;
				char szBuf[17];
				for( i = 0; i < sAny->asnValue.object.idLength; i++ )
				{
					lstrcat( pString, itoa( sAny->asnValue.object.ids[i], szBuf, 10 ) );    
					if(i < sAny->asnValue.object.idLength-1)
						lstrcat( pString, "." );
				}
			}
		}
		else
			pString = NULL;
		break;
	default:             /* Unrecognised data type */
		return( FALSE );
	}
	return(pString);
}

/// kind of custom FormatMessage api
void BmsSnmpAgent::PrintStatusError(int nErrorStatus, char *&szErrorMsg)
{
	szErrorMsg = (char*)malloc(sizeof(char)*64);
	switch(nErrorStatus)
	{
	case SNMP_ERRORSTATUS_NOERROR:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_NOERROR");
		break;
	case SNMP_ERRORSTATUS_TOOBIG:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_TOOBIG");
		break;
	case SNMP_ERRORSTATUS_NOSUCHNAME:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_NOSUCHNAME");
		break;
	case SNMP_ERRORSTATUS_BADVALUE:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_BADVALUE");
		break;
	case SNMP_ERRORSTATUS_READONLY:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_READONLY");
		break;
	case SNMP_ERRORSTATUS_GENERR:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_GENERR");
		break;
	case SNMP_ERRORSTATUS_NOACCESS:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_NOACCESS");
		break;
	case SNMP_ERRORSTATUS_WRONGTYPE:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_WRONGTYPE");
		break;
	case SNMP_ERRORSTATUS_WRONGLENGTH:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_WRONGLENGTH");
		break;
	case SNMP_ERRORSTATUS_WRONGENCODING:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_WRONGENCODING");
		break;
	case SNMP_ERRORSTATUS_WRONGVALUE:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_WRONGVALUE");
		break;
	case SNMP_ERRORSTATUS_NOCREATION:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_NOCREATION");
		break;
	case SNMP_ERRORSTATUS_INCONSISTENTVALUE:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_INCONSISTENTVALUE");
		break;
	case SNMP_ERRORSTATUS_RESOURCEUNAVAILABLE:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_RESOURCEUNAVAILABLE");
		break;
	case SNMP_ERRORSTATUS_COMMITFAILED:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_COMMITFAILED");
		break;
	case SNMP_ERRORSTATUS_UNDOFAILED:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_UNDOFAILED");
		break;
	case SNMP_ERRORSTATUS_AUTHORIZATIONERROR:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_AUTHORIZATIONERROR");
		break;
	case SNMP_ERRORSTATUS_NOTWRITABLE:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_NOTWRITABLE");
		break;
	case SNMP_ERRORSTATUS_INCONSISTENTNAME:
		strcpy(szErrorMsg,"SNMP_ERRORSTATUS_INCONSISTENTNAME");
		break;
	default:
		strcpy(szErrorMsg,"Unknown Error");
	}
}

bool BmsSnmpAgent::UpdateNodeMapOidValueByOid( BmsSnmpNodeMap& nodeMap)
{
	//check ini
	if(!this->m_isIni||!this->m_isConn)
		return false;
	//FIXME 这里没有考虑map的同步如果其他地方在改变map。呵呵结果不可知
	BmsSnmpNodeMap::iterator itr = nodeMap.begin(); 
	std::string oid(""),values("");
	while (itr!=nodeMap.end())
	{
		oid.clear();
		values.clear();
		oid = itr->second.getOid();
		this->getNodeValue(oid,values);
		itr->second.setValues(values);
		itr++;
	}
	return true;
}

void BmsSnmpAgent::EncodeNodeMapToJson( std::string &serStr ,BmsSnmpAgent::BmsSnmpNodeMap& nodeMap)
{
	serStr = "";
	BmsSnmpAgent::BmsSnmpNodeMap::iterator itr = nodeMap.begin();
	serStr.clear();

	//josn 数据返回
	serStr.append("{'ob':'UpsUL33'");
	while (itr!=nodeMap.end())
	{ 
		//ob body
		serStr.append(",'");
		serStr.append(itr->first);
		serStr.append("':");
		serStr.append("{");//begin ob body

		//Oid
		serStr.append("'oid':");
		serStr.append("'");
		serStr.append(itr->second.getOid());
		serStr.append("'");

		//Oidvalue
		serStr.append(",'values':");
		serStr.append("'");
		serStr.append(itr->second.getValues());
		serStr.append("'");

		serStr.append("}");//end ob body
		itr++;
	}
	serStr.append("}");
}

SnmpTableFiled::SnmpTableFiled()
:_Oid(""),_value("")
{

}

SnmpTableFiled::~SnmpTableFiled()
{
	_Oid.clear();
	_value.clear();
}

void SnmpTableFiled::setOid( std::string Oid )
{
	_Oid.clear();
	_Oid.append(Oid);
}

void SnmpTableFiled::setValues( std::string val )
{
	_value.clear();
	_value.append(val);
}

std::string& SnmpTableFiled::getOid()
{
	return _Oid;
}

std::string& SnmpTableFiled::getValues()
{
	return _value;
}