snmp.cpp

我们的网管程序的后台软件,主要是网络方面的内容.

			}
			break;
		case SNMP_SYNTAX_UINT32:
		case SNMP_SYNTAX_CNTR32:
		case SNMP_SYNTAX_GAUGE32:
		case SNMP_SYNTAX_TIMETICKS:
			{
				smibindValue.value.sNumber = atol(pTemp->value);
			}
			break;
		case SNMP_SYNTAX_CNTR64:
			{
				smibindValue.value.sNumber = atol(pTemp->value);
			}
			break;
		case SNMP_SYNTAX_OCTETS:
			{
				smibindValue.value.string.len = strlen(pTemp->value);
				smibindValue.value.string.ptr = (unsigned char*)pTemp->value;
			}
			break;
	}
	if(pTemp->action == SNMP_PDU_GET)
	{
		smibindValue.syntax = SNMP_SYNTAX_NULL;
	}

	/* Create A Variable Binding List */
	if( (m_Vb = SnmpCreateVbl(m_SessionID , &m_OID , &smibindValue)) == SNMPAPI_FAILURE)
	{
		SnmpFreeEntity(srcEntity);
		SnmpFreeEntity(dstEntity);
		SnmpFreeContext(hView);

		SnmpFreeDescriptor(SNMP_SYNTAX_OID , (smiLPOPAQUE) &m_OID);

		ReportError(ERR_SNMP_PREPARE_SEND);

		return -1;
	}

	/* Create A SNMP PDU */
	if( (m_Pdu = SnmpCreatePdu(m_SessionID , pTemp->action , NULL , NULL , NULL , m_Vb)) == SNMPAPI_FAILURE)
	{
		SnmpFreePdu(m_Pdu);
		SnmpFreeEntity(srcEntity);
		SnmpFreeEntity(dstEntity);
		SnmpFreeContext(hView);

		SnmpFreeDescriptor(SNMP_SYNTAX_OID , (smiLPOPAQUE) &m_OID);

		ReportError(ERR_SNMP_PREPARE_SEND);

		return -1;
	}

	/* 
	*		Ok , 信息收集完毕，发送数据
	*/
	if( SnmpSendMsg(m_SessionID , srcEntity , dstEntity , hView , m_Pdu) == SNMPAPI_FAILURE)
	{
		ReportError(ERR_SNMP_SEND_OUT);
		return -1;
	}

	/*
	 *		 Avoid memory leak , Release memory
	*/

	SnmpFreeVbl(m_Vb);
	SnmpFreePdu(m_Pdu);
	SnmpFreeEntity(srcEntity);
	SnmpFreeEntity(dstEntity);
	SnmpFreeContext(hView);

	SnmpFreeDescriptor(SNMP_SYNTAX_OID , (smiLPOPAQUE) &m_OID);

	return 0;

}

/*-----------------------------------------------------------------*/
// Send Snmp Get/Set Return To Right Wnd/Thread

void CSnmp::SnmpPacketDispatch(PSnmpReturn sSend)
{
	/*
	 *		SnmpReturn == AnswerQuery
	*/

	AnswerQuery_S sAnSwerQuery = *(PSnmpReturn)sSend;

	sAnSwerQuery.snmp.error =  0;

	sAnSwerQuery.snmp.dSequence = gQueryQueue[m_SendPos].query.snmp_query.dSequence;

	/* Send */
	if(gQueryQueue[m_SendPos].cb_func != 0)
	{
		gQueryQueue[m_SendPos].cb_func(&sAnSwerQuery);
	}
	if(gQueryQueue[m_SendPos].hWnd != NULL)
	{
		::SendMessage(gQueryQueue[m_SendPos].hWnd , WM_QUERYCOMPELETE , 0 , (DWORD)(PAnswerQuery_S)&sAnSwerQuery);
	}

	memset(&gQueryQueue[m_SendPos] , 0 , sizeof(QueryNMS));

	m_SendPos = -1;
}

/*********************************************************
Description:    WM_QUERYSNMP 消息的处理函数－本消息由Snmp Wnd触发
			如果请求服务队列中存在等待服务的请求，则提供服务

Input	    :
				
				
Out			:
*********************************************************/

void CSnmp::OnQueryNMS(WPARAM wParam, LPARAM lParam)
{
	PQueryNMS	spQueryNMS=NULL;
	
	SendSnmp	sSnmp;

	if( (m_SendPos >= 0) && ( m_SendPos < MAX_SNMP_QUEUE_NUMBER) )
	{
		return ;
	}

	for(int i=0; i<=MAX_SNMP_QUEUE_NUMBER; i++)
	{
		if(i >= MAX_SNMP_QUEUE_NUMBER)
		{
			return ;
		}
		if( (gQueryQueue[i].hWnd != 0) ||  (gQueryQueue[i].cb_func != 0) )
		{
			/* 请求服务队列有新的请求 */
			spQueryNMS = &gQueryQueue[i];
			m_SendPos = i;
			break;
		}
	}

	/*
	 *		其他线程、进程不必包含winsnmp.h
	*/
	/* Action Type */
	switch(spQueryNMS->query.snmp_query.action)
	{
	case ACTION_MIB_GET:
		{
			sSnmp.action = SNMP_PDU_GET;
		}
		break;
	case ACTION_MIB_SET:
		{
			sSnmp.action = SNMP_PDU_SET;
		}
		break;
	default:
		{
			sSnmp.action = SNMP_PDU_GET;
		}
		break;
	}

	/* Value Type */
	switch(spQueryNMS->query.snmp_query.value_type)
	{
	case SNMP_TYPE_STRING:
		{
			sSnmp.value_type = SNMP_SYNTAX_OCTETS;
		}
		break;
	case SNMP_TYPE_INT:
		{
			sSnmp.value_type = SNMP_SYNTAX_INT;
		}
		break;
	default:
		{
			sSnmp.value_type = SNMP_SYNTAX_OCTETS;
		}
		break;
	}

	/* Value */
	memcpy( sSnmp.value	, spQueryNMS->query.snmp_query.value , MAX_VALUE_LEN);

	/* MIB OID */
	memcpy( sSnmp.oid , spQueryNMS->query.snmp_query.oid , MAX_OID_LEN);

	/* Target IP */
	memcpy( sSnmp.target_ip , spQueryNMS->query.snmp_query.gw_ip , MAX_IP_LEN);

	/* 网元代理端口 */
	sSnmp.target_port = spQueryNMS->query.snmp_query.listen_port;

	
	/* Snmp Community */
	if( sSnmp.action == SNMP_PDU_GET)
	{
		strcpy( sSnmp.community , "public");
	}
	else
	{
		strcpy( sSnmp.community , "private");
	}

	/* Send out Snmp Packet */
	SendSnmpPacket((PSendSnmp)&sSnmp);
}

/*********************************************************
Description:	此函数由需要Snmp服务的Wnd/Thread调用,将请求放进
			请求服务队列。等候服务
Input	    :
				
				
Out			:
*********************************************************/

int CSnmp::SnmpQueryNMS(PQueryNMS spQueryNMS)
{
	WaitForSingleObject(hInUse , INFINITE);
	::ResetEvent(hInUse);

	int		ret=0;

	for(int i=0; i<MAX_SNMP_QUEUE_NUMBER; i++)
	{
		if( gQueryQueue[i].hWnd == 0 &&  gQueryQueue[i].cb_func == 0)
		{
			gQueryQueue[i] = *spQueryNMS;
			PostMessage(hMsgWnd , WM_QUERYSNMP , 0 , 0);
			break;
		}
	}
	
	if(i >= MAX_SNMP_QUEUE_NUMBER)
	{
		ret = -1;
	}

	::SetEvent(hInUse);

	return ret;
}

/*-----------------------------------------------------------------*/

void CSnmp::ReportError(int ErrNo)
{
	AnswerQuery_S sAnSwerQuery;

	memset(&sAnSwerQuery , 0 , sizeof(AnswerQuery_S));

	if( (m_SendPos >= 0) && ( m_SendPos < MAX_CMD_QUEUE_NUMBER) )
	{
		sAnSwerQuery.snmp.error =  ErrNo;
		sAnSwerQuery.snmp.dSequence = gQueryQueue[m_SendPos].query.snmp_query.dSequence;

		if(gQueryQueue[m_SendPos].cb_func != 0)
		{
			gQueryQueue[m_SendPos].cb_func(&sAnSwerQuery);
		}
		if(gQueryQueue[m_SendPos].hWnd != NULL)
		{
			::SendMessage(gQueryQueue[m_SendPos].hWnd , WM_QUERYCOMPELETE , 0 , (DWORD)(PAnswerQuery_S)&sAnSwerQuery);
		}

		memset(&gQueryQueue[m_SendPos] , 0 , sizeof(QueryNMS));

		m_SendPos = -1;

		/*
		 *		请求服务队列中还有需要服务的吗？
		*/
		SendMessage(hMsgWnd , WM_QUERYSNMP , 0 , 0);
	}

	m_SendPos = -1;
}

/*********************************************************
Description:    Recv Trap & Decode Trap & Send Trap To DataBase

Input	    :   
				
				
Out			:   
*********************************************************/
void CSnmp::OnTrapCome(WPARAM wParam, LPARAM lParam) 
{
	/* 插口有数据报到来 */
	struct		sockaddr_in from;

	unsigned long	nRead = 0;
	int				tmp , iRecv;

	HSNMP_ENTITY    dstEntity;
	HSNMP_ENTITY	srcEntity;
	HSNMP_CONTEXT	hContext;
	HSNMP_PDU		hPdu;
	HSNMP_VBL		hvb;

	smiOCTETS 		Octet ;
	smiOCTETS 		Communitity;

	smiINT			PduType;
	smiOID			RecvOid;
	smiVALUE		RecvSnmpValue;
	smiINT32		RequestID;      // request_id field of the PDU 
	smiINT			ErrorStatus;    // error_status field of the PDU 
	smiINT			ErrorIndex;     // error_index field of the PDU 

	SNMPAPI_STATUS Status;

	char			chTrapRecvBuf[MAX_TRAP_LEN + 1];

	memset(chTrapRecvBuf , 0 , sizeof(chTrapRecvBuf));

	/* 插口有多少 Bytes 可读 */
	if( ioctlsocket (CTrap::sockfd , FIONREAD , &nRead) == SOCKET_ERROR)
	{
		return ;
	}

	/* 接收 */
	tmp = sizeof(struct sockaddr_in);
	iRecv = recvfrom(CTrap::sockfd , (char*)chTrapRecvBuf , nRead , 0 , (SOCKADDR*)&from , &tmp);
	if( (iRecv == 0) || (iRecv == SOCKET_ERROR ) )
	{
		return ;
	}

	/* 验证发送者IP */
	//if(! pApp->GetSubnet(from.sin_addr.S_un.S_un_b) )
	{
		;
	}

	/* 解包 */
	Octet.len = nRead;
	Octet.ptr = (unsigned char* )chTrapRecvBuf;

	if( SnmpDecodeMsg(m_SessionID , &srcEntity ,
		&dstEntity , &hContext , &hPdu ,&Octet) == SNMPAPI_FAILURE)
	{
		Status = SnmpGetLastError(m_SessionID);
		return ; 
	}

	/* Get Pdu */
	Status = SnmpGetPduData(hPdu , &PduType , &RequestID ,&ErrorStatus ,
			&ErrorIndex , &hvb) ;

	if( (Status == SNMPAPI_FAILURE) || (PduType != SNMP_PDU_V1TRAP) )
	{
		SnmpFreeVbl(hvb);
		SnmpFreePdu(hPdu);
		SnmpFreeEntity(srcEntity);
		SnmpFreeEntity(dstEntity);
		SnmpFreeContext(hContext);

		return ;
	}

	/* Get VB */
	Status = SnmpGetVb(hvb , 1 , &RecvOid , &RecvSnmpValue);
	if(Status == SNMPAPI_FAILURE) 
	{
		SnmpFreeVbl(hvb);
		SnmpFreePdu(hPdu);
		SnmpFreeEntity(srcEntity);
		SnmpFreeEntity(dstEntity);
		SnmpFreeContext(hContext);

		return ;
	}

	/* 共同体 */
	Status = SnmpContextToStr(hContext , &Communitity);
	if(Status == SNMPAPI_FAILURE)
	{
		SnmpFreeVbl(hvb);
		SnmpFreePdu(hPdu);
		SnmpFreeEntity(srcEntity);
		SnmpFreeEntity(dstEntity);
		SnmpFreeContext(hContext);

		return ;
	}
	
	/* OID */
    //Status = SnmpOidToStr( &RecvOid , MAX_DOTTED_OID_SIZE , RecvBuf);
	
	/* 预定义RecvSnmpValue的值为字符串--告警/性能都为字符串 */
	if( RecvSnmpValue.syntax != SNMP_SYNTAX_OCTETS)
	{
		return ;								/* 认定错误发生 */
	}
	
	// strcpy(chTrapRecvBuf , RecvSnmpValue.value.string);

	pApp->pThreadTrap->m_pTrapWnd->SendTrapToDateBase(&from , (char*)RecvSnmpValue.value.string.ptr);

	SnmpFreeVbl(hvb);
	SnmpFreePdu(hPdu);
	SnmpFreeEntity(srcEntity);
	SnmpFreeEntity(dstEntity);
	SnmpFreeContext(hContext);

	SnmpFreeDescriptor(SNMP_SYNTAX_OID , (smiLPOPAQUE) &RecvOid);
	SnmpFreeDescriptor(SNMP_SYNTAX_OCTETS , (smiLPOPAQUE) &Communitity);

	if(RecvSnmpValue.syntax == SNMP_SYNTAX_OID)
	{
		SnmpFreeDescriptor( SNMP_SYNTAX_OID, (smiLPOPAQUE) &RecvSnmpValue.value);
	}
	else if(RecvSnmpValue.syntax == SNMP_SYNTAX_OCTETS)
	{
		SnmpFreeDescriptor( SNMP_SYNTAX_OCTETS, (smiLPOPAQUE) &RecvSnmpValue.value);
	}
	else ;
}