repos_ecs/Dll_Snmp/MyAgent_UTF8_发TRAP到LINIX/MyAgent.cpp

// MyAgent.cpp : Defines the entry point for the DLL application.
//

#include "stdafx.h"
#include <string>
#include "Mgmtapi.h"
#include <snmp.h>
#include <malloc.h>
//#include "Winsnmp.h"
#define OID_SIZEOF( Oid )      ( sizeof Oid / sizeof(UINT) )

#include "DllExcel.h"
#include "BasicExcelVC6.h"
using namespace YExcel;
//using namespace std;

//////////////////////////////////////////////////////////////////////////////////
#define			LEN_NUM_MAX			255
#define			OID_NUM_MAX			5000
// template MIB entry
struct MIB_ENTRY
{
	AsnObjectIdentifier asnOid;
	void *              pStorageValue;
	CHAR *              szStorageName;
	BYTE                chType;
	UINT                unAccess;
	MIB_ENTRY*			pMibNext;
};

// this is the our branch starting point (clled prefix)
//UINT g_unMyOIDPrefix[]	= {1,3,6,1,4,1,4320};//{1.3.6.1.4.1.4320};//
CHAR g_sOIDPrefix[LEN_NUM_MAX] = ".1.3.6.1.4.1.4320";
// this is the trap OID to send to client
UINT g_TrapOid[]		       = {1,3,6,1,4,1,4320};//{1.3.6.1.4.1.4320.0};//
//CHAR g_sTrapOid[255] = "1.3.6.1.4.1.16.0";

//AsnObjectIdentifier MIB_OidPrefix;

AsnObjectIdentifier MIB_OidPrefix;// = { OID_SIZEOF(g_unMyOIDPrefix), g_unMyOIDPrefix};

DWORD g_dwStartTime = 0;
HANDLE g_hSimulateTrap = NULL;
HANDLE g_hTrapGenThread = NULL;
unsigned long __stdcall TrapGenThread(void *lpVoid);

int GetRequest(SnmpVarBind *pVarBind);
int GetNextRequest(SnmpVarBind *pVarBind);
int SetRequest(SnmpVarBind *pVarBind);

UINT GetStoreVar(MIB_ENTRY* pMIB, AsnAny *pasnValue);
UINT SetStoreVar(MIB_ENTRY* pMIB, AsnAny asnValue);

void InitMibTable();
void ReadExcel();
/////////MIB Table ////////////////////////////////////////////////
CHAR g_sOID[OID_NUM_MAX][LEN_NUM_MAX];
//UINT g_unSubOid[] = {0,1};
//UINT g_unNameOid[] = {0,4};
//UINT g_unAgeOid[] = {1,3};

char *g_szAbout = NULL;
char *g_szName = NULL;
AsnInteger g_asnIntAge = 0;

char *g_sData[OID_NUM_MAX];
AsnInteger g_nData[OID_NUM_MAX];
int g_nIndex2Char=0;
int g_nIndex2Int=0;
/// This is the MIB table and its related variable store
//    here evry thing is hard-coded to demonstration perpose
//    Actualy it should be loaded from the registry or from some file
MIB_ENTRY g_MyMibTable[OID_NUM_MAX] ;
MIB_ENTRY g_MyMibTableResume[OID_NUM_MAX] ;//= {
//	{	
//		{OID_SIZEOF(g_unSubOid),g_unSubOid},
//		&g_szAbout,
//		"About",
//		ASN_OCTETSTRING,
//		SNMP_ACCESS_READ_ONLY,
//		&g_MyMibTable[1]
//	},
//	{
//		{OID_SIZEOF(g_unNameOid),g_unNameOid},
//		&g_szName,
//		"Name",
//		ASN_OCTETSTRING,
//		SNMP_ACCESS_READ_WRITE,
//		&g_MyMibTable[2]
//	},
//	{
//		{OID_SIZEOF(g_unAgeOid),g_unAgeOid},
//		&g_asnIntAge,
//		"Age",
//		ASN_INTEGER,
//		SNMP_ACCESS_READ_WRITE,
//		NULL
//	}
//};

UINT g_unMyMibCount = 0;//(sizeof(g_MyMibTable) / sizeof(MIB_ENTRY));
///////////////////////////////////////////////////////////////////
void WriteLog(CHAR csMsg[], DWORD dwSize ) 
{ 
	HANDLE hFile; 
	DWORD dwNumberOfBytesWritten; 
	// 必须指定 OPEN_ALWAYS 标志, 否则不会在原文件内容上添加 
	hFile = CreateFile( "C:\\Snmplog.txt", GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL ,NULL );//FILE_ATTRIBUTE_HIDDEN 
	if (hFile == INVALID_HANDLE_VALUE ) 
	{ 
		return ; 
	} 

	// 设置文件指针到文件结尾, 在 当前位置 FILE_END, 向后移动 0 字节 
	SetFilePointer( hFile , 0, NULL, FILE_END ); 

	// 这个 API 是设置当前的位置为文件的结尾 
	// SetEndOfFile( hFile); 

	BOOL BRet = WriteFile( hFile, csMsg, dwSize , &dwNumberOfBytesWritten, NULL); 

	CloseHandle( hFile ); 
} 
int FindChar(char ch,char str[],int n)
{
	int i=n-1;
	while(str[i]!=ch&&i>0)
		i--;
	if(i==0) i=-1;
		return i;
}

BOOL APIENTRY DllMain( HANDLE hModule,DWORD  ul_reason_for_call, LPVOID lpReserved)
{
	CHAR ss[] = "DllMain\r\n";
	//WriteLog( ss,strlen(ss) );
	switch (ul_reason_for_call)
	{
		case DLL_PROCESS_ATTACH:
			break;
		case DLL_THREAD_ATTACH:
			break;
		case DLL_THREAD_DETACH:
			break;
		case DLL_PROCESS_DETACH:
			TerminateThread(g_hTrapGenThread,0);
			CloseHandle(g_hTrapGenThread);
			CloseHandle(g_hSimulateTrap);
			break;
    }
    return TRUE;
}

// When exported funtion will be called during DLL loading and initialization
BOOL SNMP_FUNC_TYPE SnmpExtensionInit(DWORD dwUptimeReference,HANDLE *phSubagentTrapEvent, AsnObjectIdentifier *pFirstSupportedRegion)
{
	//DeleteFile( "C:\\Snmplog.txt" );

	CHAR ss[] = "SnmpExtensionInit\r\n";
	WriteLog( ss,strlen(ss) );
	
	SnmpMgrStrToOid( g_sOIDPrefix, &MIB_OidPrefix );
	// hard coded initialization
	g_szAbout = (char*)malloc(sizeof(char)*64);
	strcpy(g_szAbout,"Author : Ramanan.T");
	g_szName = (char*)malloc(sizeof(char)*64);
	strcpy(g_szName,"Your Name");
	g_asnIntAge = 125;

	g_sData[0] = (char*)malloc(sizeof(char)*64);
	strcpy( g_sData[0],"Author : Ramanan.T");
	g_sData[1] = (char*)malloc(sizeof(char)*64);
	strcpy( g_sData[1],"Your Name");
	g_nData[0] = 145;

	//g_nIndex2Char = 2;
	ReadExcel();
	//InitMibTable();

	g_hSimulateTrap = CreateEvent(NULL, FALSE, FALSE, NULL); // creaet this event for the trap

	*pFirstSupportedRegion = MIB_OidPrefix;
	*phSubagentTrapEvent = g_hSimulateTrap; // by assigning it pass it to the SNMP service
											// So when ever you set this event service will call 
											// SnmpExtensionTrap exported function
	
	// on loading the our SNMP DLL create the thread
	//g_hTrapGenThread = CreateThread(NULL,0,TrapGenThread,NULL,0,NULL);


	g_dwStartTime = GetTickCount();

	return SNMPAPI_NOERROR;
}
VOID SNMP_FUNC_TYPE SnmpExtensionClose()
{
	CHAR ss[255];// = "SnmpExtensionQuery\r\n";
	sprintf( ss,"SnmpExtensionClose\r\n" );
	WriteLog( ss,strlen(ss) );

	for( int i=0;i<g_nIndex2Char;i++ )
	{
		free( g_sData[i] );
	}

	//trap 用
	free( g_sData[4999] );
}
// this export is to query the MIB table and fields
BOOL SNMP_FUNC_TYPE SnmpExtensionQuery(BYTE bPduType, SnmpVarBindList *pVarBindList, AsnInteger32 *pErrorStatus, AsnInteger32 *pErrorIndex)
{
	int nRet = 0;
	AsnObjectName;
	
	*pErrorStatus = SNMP_ERRORSTATUS_NOERROR;
	*pErrorIndex = 0;

	CHAR ss[255];// = "SnmpExtensionQuery\r\n";
	//sprintf( ss,"SnmpExtensionQuery\r\n" );
	//WriteLog( ss,strlen(ss) );

	for(UINT i=0;i<pVarBindList->len;i++)
	{
		*pErrorStatus = SNMP_ERRORSTATUS_NOERROR;

		// what type of request we are getting?
		switch(bPduType)
		{
		case SNMP_PDU_GET:// // gets the variable value passed variable in pVarBindList
			*pErrorStatus = GetRequest(&pVarBindList->list[i]);
			if(*pErrorStatus != SNMP_ERRORSTATUS_NOERROR)
				*pErrorIndex++;

			//sprintf( ss,"SNMP_PDU_GET\r\n" );
			break;
		case SNMP_PDU_GETNEXT: // gets the next variable related to the passed variable in pVarBindList
			*pErrorStatus = GetNextRequest(&pVarBindList->list[i]);
			if(*pErrorStatus != SNMP_ERRORSTATUS_NOERROR)
				*pErrorIndex++;

			//sprintf( ss,"SNMP_PDU_GETNEXT\r\n" );
			break;
		case SNMP_PDU_SET: // sets a variable
			*pErrorStatus = SetRequest(&pVarBindList->list[i]);
			if(*pErrorStatus != SNMP_ERRORSTATUS_NOERROR)
				*pErrorIndex++;

			//sprintf( ss,"SNMP_PDU_SET\r\n" );
			break;
		default:
			*pErrorStatus = SNMP_ERRORSTATUS_NOSUCHNAME;
			*pErrorIndex++;
			//sprintf( ss,"default\r\n" );
		}
		
		//WriteLog( ss,strlen(ss) );
	}	

	return SNMPAPI_NOERROR;
}

// this function just simulate traps
//   Traps just a 2 variables value from MIB
//  Trap is kind of event from server to client
///         When ever the event is set service will call this function and gets the parameters filled.
//       After filling the parameters service willsend the trap to all the client connected
BOOL SNMP_FUNC_TYPE SnmpExtensionTrap(AsnObjectIdentifier *pEnterpriseOid, AsnInteger32 *pGenericTrapId, AsnInteger32 *pSpecificTrapId, AsnTimeticks *pTimeStamp, SnmpVarBindList *pVarBindList)
{
	static int nNoOfTraps = 1; // just ignore this, I introduced this to send meny traps at once
								// any way below we are generating one trap with two values
	CHAR ss[255];// = "SnmpExtensionQuery\r\n";
	
	SYSTEMTIME st;
	::GetLocalTime( &st );
	
	if(nNoOfTraps==1) // if it is zero don't send traps
	{
		//pEnterpriseOid->idLength = OID_SIZEOF(g_TrapOid);
		//pEnterpriseOid->ids = g_TrapOid;
		SnmpMgrStrToOid( g_sOIDPrefix, pEnterpriseOid );

		*pGenericTrapId		= SNMP_GENERICTRAP_ENTERSPECIFIC;
		*pSpecificTrapId	= 1;   // ToasterControl Up trap.
		*pTimeStamp			= GetTickCount() - g_dwStartTime;

		// Allocate space for the Variable Bindings.
		pVarBindList->list = (SnmpVarBind*)SnmpUtilMemAlloc(1*sizeof(SnmpVarBind));

		SnmpUtilOidCpy(&pVarBindList->list[0].name,&g_MyMibTable[4999].asnOid);//&MIB_OidPrefix);
		//SnmpUtilOidAppend(&pVarBindList->list[0].name,&g_MyMibTable[1].asnOid);
		pVarBindList->list[0].value.asnType = ASN_OCTETSTRING;
		pVarBindList->list[0].value.asnValue.string.dynamic = TRUE;
		pVarBindList->list[0].value.asnValue.string.length = strlen(*(LPSTR*)g_MyMibTable[4999].pStorageValue);
		pVarBindList->list[0].value.asnValue.string.stream =(unsigned char*)SnmpUtilMemAlloc(pVarBindList->list[0].value.asnValue.string.length * sizeof(char));
		memcpy(pVarBindList->list[0].value.asnValue.string.stream,*(LPSTR*)g_MyMibTable[4999].pStorageValue,pVarBindList->list[0].value.asnValue.string.length);
				
		//SnmpUtilOidCpy(&pVarBindList->list[0].name,&g_MyMibTable[2].asnOid);//&MIB_OidPrefix);
		////SnmpUtilOidAppend(&pVarBindList->list[1].name,&g_MyMibTable[2].asnOid);
		//pVarBindList->list[0].value.asnType = ASN_INTEGER;
		//pVarBindList->list[0].value.asnValue.number = *((AsnInteger32*)g_MyMibTable[2].pStorageValue);
		//sprintf( ss,"SnmpExtensionTrap  %02d:%02d:%02d =%s\r\n",st.wHour,st.wMinute,st.wSecond,&pVarBindList->list[0].name );
		//WriteLog( ss,strlen(ss) );
		pVarBindList->len = 1;

		nNoOfTraps--;
		// Indicate that valid trap data exists in the parameters.
		return TRUE;
	}
	nNoOfTraps = 1;
	//PulseEvent( g_hSimulateTrap );
	// Indicate that no more traps are available, and parameters do not refer to any valid data
	return FALSE;
}

// get the value of the variable pased
int GetRequest(SnmpVarBind *pVarBind)
{
	int nRet = SNMP_ERRORSTATUS_NOSUCHNAME;
	AsnObjectIdentifier  asnOidTemp;

	CHAR ss[255];// = "SnmpExtensionQuery\r\n";
	sprintf( ss,"g_unMyMibCount = %d\r\n",g_unMyMibCount );
	//WriteLog( ss,strlen(ss) );

	for(UINT i=0;i<g_unMyMibCount;i++)
	{
		SnmpUtilOidCpy(&asnOidTemp, &g_MyMibTable[i].asnOid);//&MIB_OidPrefix);
		//SnmpUtilOidAppend(&asnOidTemp, &g_MyMibTable[i].asnOid);
		if(SnmpUtilOidCmp(&asnOidTemp,&pVarBind->name) ==0)
		{
			SnmpUtilOidFree(&asnOidTemp);

			nRet = GetStoreVar(&g_MyMibTable[i],&pVarBind->value);
			break;
		}
		SnmpUtilOidFree(&asnOidTemp);
	}
	return nRet;
}

// get the next variable & value related to the passed variable
int GetNextRequest(SnmpVarBind *pVarBind)
{
	int nRet = SNMP_ERRORSTATUS_NOSUCHNAME;
	int nResult = 0;
	AsnObjectIdentifier  asnOidTemp;

	for(UINT i=0;i<g_unMyMibCount;i++)
	{
		SnmpUtilOidCpy(&asnOidTemp, &g_MyMibTable[i].asnOid);//&MIB_OidPrefix);
		//SnmpUtilOidAppend(&asnOidTemp, &g_MyMibTable[i].asnOid);

		nResult = SnmpUtilOidCmp(&asnOidTemp,&pVarBind->name);
		if(nResult>0)
		{
			SnmpUtilOidFree(&pVarBind->name);

			// kind of memcpy
			SnmpUtilOidCpy(&pVarBind->name, &asnOidTemp);

			nRet = GetStoreVar(&g_MyMibTable[i],&pVarBind->value);
			SnmpUtilOidFree(&asnOidTemp);
			nRet = SNMP_ERRORSTATUS_NOERROR;
			break;
		}
		else if(nResult == 0)
		{
			SnmpUtilOidFree(&asnOidTemp);
			if(g_MyMibTable[i].pMibNext == NULL)
				break;
			// king of mem free
			SnmpUtilOidFree(&pVarBind->name);			

			// kind of memcpy :)
			SnmpUtilOidCpy(&pVarBind->name,  &g_MyMibTable[i].pMibNext->asnOid);//&MIB_OidPrefix);

			// kind of strcat
			//SnmpUtilOidAppend(&pVarBind->name, &g_MyMibTable[i].pMibNext->asnOid);

			nRet = GetStoreVar(g_MyMibTable[i].pMibNext,&pVarBind->value);
			break;
		}
		SnmpUtilOidFree(&asnOidTemp);
	}
	return nRet;
}
LPSTR Convert(LPCSTR str, int sourceCodepage, int targetCodepage,int &iTargetLen)
{
	//int len=_tcslen(str);
	int unicodeLen=MultiByteToWideChar(sourceCodepage,0,str,-1,NULL,0);
	wchar_t* pUnicode;
	pUnicode=new wchar_t[unicodeLen+1];
	memset(pUnicode,0,(unicodeLen+1)*sizeof(wchar_t));
	  
	MultiByteToWideChar(sourceCodepage,0,str,-1,(LPWSTR)pUnicode,unicodeLen);
	 
	BYTE * pTargetData;
	int targetLen=WideCharToMultiByte(targetCodepage,0,(LPWSTR)pUnicode,-1,(char *)pTargetData,0,NULL,NULL);
	iTargetLen = targetLen;
	pTargetData=new BYTE[targetLen+1];
	memset(pTargetData,0,targetLen+1);
	 
	WideCharToMultiByte(targetCodepage,0,(LPWSTR)pUnicode,-1,(char *)pTargetData,targetLen,NULL,NULL);
	 
	LPSTR szResult=new TCHAR[targetLen+1];
	wsprintf(szResult,"%s",pTargetData);
	 
	delete[] pUnicode;
	delete[] pTargetData;
	return szResult;
}
// if it is a writable variable passed value will be copied to it
int SetRequest(SnmpVarBind *pVarBind)
{
	int nRet = SNMP_ERRORSTATUS_NOSUCHNAME;
	AsnObjectIdentifier  asnOidTemp;

	for(UINT i=0;i<g_unMyMibCount;i++)
	{
		// kind of memcpy ;), any way you can't use memcpy 
		SnmpUtilOidCpy(&asnOidTemp, &g_MyMibTable[i].asnOid);//&MIB_OidPrefix);
		
		// kind of strcat ;)
		//SnmpUtilOidAppend(&asnOidTemp, &g_MyMibTable[i].asnOid);
		
		if(SnmpUtilOidCmp(&asnOidTemp,&pVarBind->name) ==0)
		{
			CHAR src[255],des[255],ss[255];
			memset( src,0,255 );
			memset( des,0,255 );
			memset( ss,0,255 );

			sprintf( src,"%s",pVarBind->value.asnValue.string );
			char *cPosA = strstr( src,"警" );
			char *cPosN = strstr( src,"恢复正常" );
			int nPosA = FindChar( 'A',src,strlen(src) );
			int nPosN = FindChar( 'N',src,strlen(src) );

			//sprintf( ss,"src=%s,cPosA=%d,cPosN=%d,nPosA=%d,nPosN=%d\r\n",src,cPosA,cPosN,nPosA,nPosN );
			//WriteLog( ss,strlen(ss) );
	
			if( cPosA==NULL && cPosN==NULL )
			{
				//WriteLog( src,strlen(src) );
				SnmpUtilOidFree(&asnOidTemp);
				nRet = SetStoreVar(&g_MyMibTable[i],pVarBind->value);
			}
			else if( cPosA )
			{
				sprintf( ss,"src=%s,cPosA=%d,cPosN=%d,nPosA=%d,nPosN=%d\r\n",src,cPosA,cPosN,nPosA,nPosN );
				WriteLog( ss,strlen(ss) );

				memcpy(des,src + 0,nPosA-1 );

				//memset( src,0,255 );
				//sprintf( src,"%s 111111111\r\n",des );
				//WriteLog( src,strlen(src) );

				int nTargetLen=0;
				LPSTR strTarget = Convert( des,936,CP_UTF8,nTargetLen);

				SnmpUtilMemFree( pVarBind->value.asnValue.string.stream );
				pVarBind->value.asnType = ASN_OCTETSTRING;
				pVarBind->value.asnValue.string.dynamic = TRUE;
				pVarBind->value.asnValue.string.length = nTargetLen;//nPosA-1;
				pVarBind->value.asnValue.string.stream =(unsigned char*)SnmpUtilMemAlloc( nTargetLen/*(nPosN-1)*/ * sizeof(char));
				memcpy( pVarBind->value.asnValue.string.stream,strTarget,nTargetLen );
				//memcpy( pVarBind->value.asnValue.string.stream,Convert( des,936,CP_UTF8),nPosA-1 );

				//memset( src,0,255 );
				//sprintf( src,"%s 发生报警\r\n",pVarBind->value.asnValue.string );
				//WriteLog( src,strlen(src) );

				SnmpUtilOidFree(&asnOidTemp);
				nRet = SetStoreVar(&g_MyMibTable[i],pVarBind->value);

				g_MyMibTable[4999].asnOid			= g_MyMibTable[i].asnOid;
				g_MyMibTable[4999].unAccess			= g_MyMibTable[i].unAccess;
				g_MyMibTable[4999].chType			= g_MyMibTable[i].chType;
				g_MyMibTable[4999].pStorageValue	= g_MyMibTable[i].pStorageValue;//Convert( g_MyMibTable[i].pStorageValue,936,CP_UTF8);//
				g_MyMibTable[4999].szStorageName	= g_MyMibTable[i].szStorageName;//"发生报警";//
				//SetStoreVar(&g_MyMibTable[4999],pVarBind->value);
				SetEvent(g_hSimulateTrap);
			}
			else if( cPosN )
			{
				memcpy(des,src + 0,nPosN-1 );

				//memset( src,0,255 );
				//sprintf( src,"%s 111111111\r\n",des );
				//WriteLog( src,strlen(src) );

				int nTargetLen=0;
				LPSTR strTarget = Convert( des,936,CP_UTF8,nTargetLen);

				SnmpUtilMemFree( pVarBind->value.asnValue.string.stream );
				pVarBind->value.asnType = ASN_OCTETSTRING;
				pVarBind->value.asnValue.string.dynamic = TRUE;
				pVarBind->value.asnValue.string.length = nTargetLen;//nPosA-1;
				pVarBind->value.asnValue.string.stream =(unsigned char*)SnmpUtilMemAlloc( nTargetLen/*(nPosN-1)*/ * sizeof(char));
				memcpy( pVarBind->value.asnValue.string.stream,strTarget,nTargetLen );

				//memset( src,0,255 );
				//sprintf( src,"%s 回复正常\r\n",pVarBind->value.asnValue.string );
				//WriteLog( src,strlen(src) );

				SnmpUtilOidFree(&asnOidTemp);
				nRet = SetStoreVar(&g_MyMibTable[i],pVarBind->value);

				g_MyMibTable[4999].asnOid			= g_MyMibTableResume[i].asnOid;
				g_MyMibTable[4999].unAccess			= g_MyMibTable[i].unAccess;
				g_MyMibTable[4999].chType			= g_MyMibTable[i].chType;
				g_MyMibTable[4999].pStorageValue	= g_MyMibTable[i].pStorageValue;
				g_MyMibTable[4999].szStorageName	= g_MyMibTable[i].szStorageName;//"回复正常";//
				//SetStoreVar(&g_MyMibTable[4999],pVarBind->value);
				SetEvent(g_hSimulateTrap);
			}
			break;
		}
		SnmpUtilOidFree(&asnOidTemp);
	}
	return nRet;
}

// retrieves the value from the MIB table
//  Imagine AsnAny is like VARIANT structure to populate that you need to go through the types
UINT GetStoreVar(MIB_ENTRY* pMIB, AsnAny *pasnValue)
{
	// check rights is there to access
	if((pMIB->unAccess != SNMP_ACCESS_READ_ONLY)&&(pMIB->unAccess != SNMP_ACCESS_READ_WRITE)&&(pMIB->unAccess != SNMP_ACCESS_READ_CREATE))
		return SNMP_ERRORSTATUS_GENERR;

	// set the type
	pasnValue->asnType = pMIB->chType;
	
	switch(pasnValue->asnType)
	{
	case ASN_INTEGER:
		pasnValue->asnValue.number = *(AsnInteger32*)pMIB->pStorageValue;
		break;
	case ASN_COUNTER32:
	case ASN_GAUGE32:
	case ASN_TIMETICKS:
	case ASN_UNSIGNED32:
		pasnValue->asnValue.unsigned32 = *(AsnUnsigned32*)pMIB->pStorageValue;
		break;
	case ASN_OCTETSTRING:
		pasnValue->asnValue.string.length = strlen(*(LPSTR*)pMIB->pStorageValue);
		pasnValue->asnValue.string.stream =(unsigned char*)SnmpUtilMemAlloc(pasnValue->asnValue.string.length * sizeof(char));

		memcpy(pasnValue->asnValue.string.stream,*(LPSTR*)pMIB->pStorageValue,pasnValue->asnValue.string.length);
		pasnValue->asnValue.string.dynamic = TRUE;
		break;
	case ASN_COUNTER64:
		pasnValue->asnValue.counter64 = *(AsnCounter64*)pMIB->pStorageValue;
		break;
	case ASN_OBJECTIDENTIFIER:
		SnmpUtilOidCpy(&pasnValue->asnValue.object,(AsnObjectIdentifier*)pMIB->pStorageValue);
		break;
	case ASN_IPADDRESS:
		pasnValue->asnValue.address.length = 4;
		pasnValue->asnValue.string.dynamic = TRUE;

		pasnValue->asnValue.address.stream[0] = ((char*)pMIB->pStorageValue)[0];
		pasnValue->asnValue.address.stream[1] = ((char*)pMIB->pStorageValue)[1];
		pasnValue->asnValue.address.stream[2] = ((char*)pMIB->pStorageValue)[2];
		pasnValue->asnValue.address.stream[3] = ((char*)pMIB->pStorageValue)[3];
		break;
	case ASN_OPAQUE:
		AsnSequence;
		break;
	case ASN_BITS:
		break;	
	case ASN_SEQUENCE:
		break;	
	case ASN_NULL:
	default:
		return SNMP_ERRORSTATUS_GENERR;	
	}
	return SNMP_ERRORSTATUS_NOERROR;
}

// to store the value to the MIB table
//  Imagine AsnAny is like VARIANT structure to populate that you need to go through the types
UINT SetStoreVar(MIB_ENTRY* pMIB, AsnAny asnValue)
{
	// check whether rights is there to access
	if((pMIB->unAccess != SNMP_ACCESS_READ_WRITE)&&(pMIB->unAccess != SNMP_ACCESS_READ_CREATE))
		return SNMP_ERRORSTATUS_READONLY;

	// check type matches with the table type
	if(pMIB->chType != asnValue.asnType)
		return SNMP_ERRORSTATUS_BADVALUE;

	switch(asnValue.asnType)
	{
	case ASN_INTEGER:
		*(AsnInteger *)(pMIB->pStorageValue) = asnValue.asnValue.number;
		break;
	case ASN_COUNTER32:
	case ASN_GAUGE32:
	case ASN_TIMETICKS:
	case ASN_UNSIGNED32:
		*(AsnInteger *)(pMIB->pStorageValue) = asnValue.asnValue.unsigned32;
		break;
	case ASN_OCTETSTRING:
		free(*(LPSTR*)(pMIB->pStorageValue));
		*(LPSTR*)(pMIB->pStorageValue) = (LPSTR)malloc((asnValue.asnValue.string.length+1) * sizeof(char));
		memcpy(*(LPSTR*)(pMIB->pStorageValue), asnValue.asnValue.string.stream,asnValue.asnValue.string.length);
		(*(LPSTR*)pMIB->pStorageValue)[asnValue.asnValue.string.length] = '\0';
		break;
	case ASN_COUNTER64:
		*(AsnCounter64*)pMIB->pStorageValue = asnValue.asnValue.counter64;
		break;
	case ASN_OBJECTIDENTIFIER:
		SnmpUtilOidCpy((AsnObjectIdentifier*)pMIB->pStorageValue,&asnValue.asnValue.object);
		break;

	case ASN_IPADDRESS:
		((char*)pMIB->pStorageValue)[0] = asnValue.asnValue.address.stream[0];
		((char*)pMIB->pStorageValue)[1] = asnValue.asnValue.address.stream[1];
		((char*)pMIB->pStorageValue)[2] = asnValue.asnValue.address.stream[2];
		((char*)pMIB->pStorageValue)[3] = asnValue.asnValue.address.stream[3];
		break;
	case ASN_OPAQUE:
		AsnSequence;
		break;
	case ASN_BITS:
		break;	
	case ASN_SEQUENCE:
		break;	
	case ASN_NULL:
		break;
	default:
		return SNMP_ERRORSTATUS_GENERR;	
	}
	return SNMP_ERRORSTATUS_NOERROR;
}

// simple trap generation thread
//   I'm sending traps in a loops in 15 second intervals
unsigned long __stdcall TrapGenThread(void *lpVoid)
{
	for(;;)
	{
		Sleep(5000);//Sleep(15000);
		SetEvent(g_hSimulateTrap);
	}
	return 0;
}

void InitMibTable()
{
	//sprintf( g_sOID[0],".1.3.6.1.4.1.4320.1" );
	//sprintf( g_sOID[1],".1.3.6.1.4.1.4320.2" );
	//sprintf( g_sOID[2],".1.3.6.1.4.1.4320.3" );

	//CHAR sTemp[7][LEN_NUM_MAX];
	////g_unMyMibCount = 3;//(sizeof(g_MyMibTable) / sizeof(MIB_ENTRY));

	//CHAR ss[255];// = "SnmpExtensionQuery\r\n";
	//sprintf( ss,"InitMibTable\r\n" );
	////WriteLog( ss,strlen(ss) );

	//BasicExcel e;
	//e.Load("C:\\OID-斯特纽有限公司.xls");	
	//BasicExcelWorksheet* sheet1 = e.GetWorksheet("StoneU");

	//if (sheet1)
	//{
	//	size_t maxRows = sheet1->GetTotalRows();
	//	size_t maxCols = sheet1->GetTotalCols();

	//	sprintf( ss,"Excel maxRows=%d,maxCols=%d  \r\n",maxRows,maxCols );
	//	WriteLog( ss,strlen(ss) );

	//	for (size_t r=2; r<maxRows; ++r)
	//	{
	//		for (size_t c=0; c<maxCols; c++)
	//		{
	//			BasicExcelCell* cell = sheet1->Cell(r,c);
	//			switch (c)
	//			{
	//				case 0://OID
	//					sprintf( sTemp[c],"%s",cell->GetString());
	//					break;
	//				case 1://变量
	//					sprintf( sTemp[c],"%s",cell->GetString());
	//					break;
	//				case 2://ACCESS
	//					sprintf( sTemp[c],"%s",cell->GetString());
	//					break;
	//				case 3://数据类型
	//					sprintf( sTemp[c],"%s",cell->GetString());
	//					break;
	//				case 4://初始化 ("%10.6lf", cell->GetDouble())<<"      ";
	//					sprintf( sTemp[c],"%10.4lf",cell->GetDouble());
	//					break;
	//				case 5://DESCRIPTION
	//					sprintf( sTemp[c],"%s",cell->GetString());
	//					break;
	//				default:
	//					break;
	//			}
	//		}

	//		if( sTemp[0]!="" )
	//		{
	//			SnmpMgrStrToOid( sTemp[0], &g_MyMibTable[g_unMyMibCount].asnOid );
	//			
	//			if( 0==strcmp(sTemp[2],"read-write") )
	//			{
	//				g_MyMibTable[g_unMyMibCount].unAccess = SNMP_ACCESS_READ_WRITE;
	//				sprintf( ss,"read-write\r\n" );
	//			}
	//			else if( 0==strcmp(sTemp[2],"read-only") )
	//			{
	//				g_MyMibTable[g_unMyMibCount].unAccess = SNMP_ACCESS_READ_ONLY;
	//				sprintf( ss,"read-only\r\n" );
	//			}
	//			else if( 0==strcmp(sTemp[2],"not-accessible") )
	//			{
	//				g_MyMibTable[g_unMyMibCount].unAccess = SNMP_ACCESS_NONE;
	//				sprintf( ss,"not-accessible\r\n" );
	//			}
	//			//WriteLog( ss,strlen(ss) );
	//			if( 0==strcmp(sTemp[3],"ASN_OCTETSTRING") )
	//			{
	//				g_MyMibTable[g_unMyMibCount].chType = ASN_OCTETSTRING;
	//				
	//				g_sData[g_nIndex2Char] = (char*)malloc(sizeof(char)*64);
	//				strcpy( g_sData[g_nIndex2Char],sTemp[4] );
	//				g_MyMibTable[g_unMyMibCount].pStorageValue = &g_sData[g_nIndex2Char];
	//				g_nIndex2Char++;
	//				sprintf( ss,"ASN_OCTETSTRING  g_nIndex2Char=%d\r\n",g_nIndex2Char );
	//			}
	//			else if( 0==strcmp(sTemp[3],"ASN_INTEGER") )
	//			{
	//				g_MyMibTable[g_unMyMibCount].chType = ASN_INTEGER;
	//				
	//				g_nData[g_nIndex2Int] = atoi(sTemp[4]);
	//				g_MyMibTable[g_unMyMibCount].pStorageValue = &g_nData[g_nIndex2Int];
	//				g_nIndex2Int++;
	//				sprintf( ss,"ASN_INTEGER\r\n" );
	//			}
	//			else if( 0==strcmp(sTemp[3],"ASN_NULL") )
	//			{
	//				g_MyMibTable[g_unMyMibCount].chType = ASN_NULL;
	//				sprintf( ss,"ASN_NULL\r\n" );
	//			}

	//			//WriteLog( ss,strlen(ss) );
	//			
	//			g_MyMibTable[g_unMyMibCount].szStorageName = "TEST";
	//			
	//			g_MyMibTable[g_unMyMibCount].pMibNext = &g_MyMibTable[g_unMyMibCount+1];

	//			g_unMyMibCount++;
	//		}
	//	}
	//}
}

void ReadExcel()
{
	CHAR ss[255];// = "SnmpExtensionQuery\r\n";
	sprintf( ss,"ReadExcel in \r\n" );
	WriteLog( ss,strlen(ss) );

	int i;
	const long DIM1 = OID_NUM_MAX;
	const long DIM2 = 255;

	char   **array1,**array2,**array3,**array4,**array5,**array6; 

    array1   =   new   char   *[DIM1];  
	array2   =   new   char   *[DIM1];
	array3   =   new   char   *[DIM1];
	array4   =   new   char   *[DIM1];
	array5   =   new   char   *[DIM1];
	array6   =   new   char   *[DIM1];
    for(i=0;i<DIM1;++i)  
	{
        array1[i]   =   new   char[DIM2];  
		array2[i]   =   new   char[DIM2]; 
		array3[i]   =   new   char[DIM2]; 
		array4[i]   =   new   char[DIM2]; 
		array5[i]   =   new   char[DIM2]; 
		array6[i]   =   new   char[DIM2]; 
	}

	CDllExcel DllExcel;
	long nCount=0;
	DllExcel.Excel_Open( "C:\\OID-斯特纽有限公司.xls","StoneU",array1,array2,array3,array4,array5,array6,nCount );

	sprintf( ss,"ReadExcel nCount = %d \r\n",nCount );
	WriteLog( ss,strlen(ss) );
	//CString str;
	for( int i=0;i<nCount;i++ )
	{
		SnmpMgrStrToOid( array1[i], &g_MyMibTable[g_unMyMibCount].asnOid );
		CHAR temp[255];
		sprintf( temp,"%s.1",array1[i] );
		//WriteLog( temp,strlen(temp) );
		SnmpMgrStrToOid( temp, &g_MyMibTableResume[g_unMyMibCount].asnOid );
		
		//if( 0==strcmp(array3[i],"read-write") )
		{
			g_MyMibTable[g_unMyMibCount].unAccess = SNMP_ACCESS_READ_WRITE;
			sprintf( ss,"read-write\r\n" );
		}
		//else if( 0==strcmp(array3[i],"read-only") )
		//{
		//	g_MyMibTable[g_unMyMibCount].unAccess = SNMP_ACCESS_READ_ONLY;
		//	sprintf( ss,"read-only\r\n" );
		//}
		//else if( 0==strcmp(array3[i],"not-accessible") )
		//{
		//	g_MyMibTable[g_unMyMibCount].unAccess = SNMP_ACCESS_NONE;
		//	sprintf( ss,"not-accessible\r\n" );
		//}
		//WriteLog( ss,strlen(ss) );
		//if( 0==strcmp(array4[i],"ASN_STRING") )
		{
			g_MyMibTable[g_unMyMibCount].chType = ASN_OCTETSTRING;
			
			g_sData[g_nIndex2Char] = (char*)malloc(sizeof(char)*64);
			strcpy( g_sData[g_nIndex2Char],array5[i] );
			g_MyMibTable[g_unMyMibCount].pStorageValue = &g_sData[g_nIndex2Char];
			g_nIndex2Char++;
			sprintf( ss,"ASN_OCTETSTRING  g_nIndex2Char=%d\r\n",g_nIndex2Char );
		}
		//else if( 0==strcmp(array4[i],"ASN_INTEGER") )
		//{
		//	g_MyMibTable[g_unMyMibCount].chType = ASN_INTEGER;
		//	
		//	g_nData[g_nIndex2Int] = atoi(array5[i]);
		//	g_MyMibTable[g_unMyMibCount].pStorageValue = &g_nData[g_nIndex2Int];
		//	g_nIndex2Int++;
		//	sprintf( ss,"ASN_INTEGER\r\n" );
		//}
		//else if( 0==strcmp(array4[i],"ASN_NULL") )
		//{
		//	g_MyMibTable[g_unMyMibCount].chType = ASN_NULL;
		//	sprintf( ss,"ASN_NULL\r\n" );
		//}

		//WriteLog( ss,strlen(ss) );
		
		g_MyMibTable[g_unMyMibCount].szStorageName = array6[i];
		
		g_MyMibTable[g_unMyMibCount].pMibNext = &g_MyMibTable[g_unMyMibCount+1];

		g_unMyMibCount++;
	}

	for(int i=0;i<DIM1;++i)  
	{
        delete[]   array1[i];  
		delete[]   array2[i];  
		delete[]   array3[i];  
		delete[]   array4[i];  
		delete[]   array5[i];  
		delete[]   array6[i];  
	}
    delete[]   array1;  
	delete[]   array2; 
	delete[]   array3; 
	delete[]   array4; 
	delete[]   array5; 
	delete[]   array6; 

	//trap 用
	g_sData[4999] = (char*)malloc(sizeof(char)*64);

	sprintf( ss,"ReadExcel out \r\n" );
	WriteLog( ss,strlen(ss) );
	//CHAR ss[255];// = "SnmpExtensionQuery\r\n";

	//BasicExcel e;
	//e.Load("C:\\test.xls");	
	//BasicExcelWorksheet* sheet1 = e.GetWorksheet("test");

	//if (sheet1)
	//{
	//	size_t maxRows = sheet1->GetTotalRows();
	//	size_t maxCols = sheet1->GetTotalCols();

	//	for (size_t r=1; r<maxRows; ++r)
	//	{
	//		//filetxt<<("%10d", r+1)<<"     ";
	//		for (size_t c=0; c<maxCols; ++c)
	//		{
	//			BasicExcelCell* cell = sheet1->Cell(r,c);
	//			switch (cell->Type())
	//			{
	//				case BasicExcelCell::UNDEFINED:
	//					//filetxt<<"          ";
	//					sprintf( ss,"ReadExcel* \r\n");
	//					break;
	//				case BasicExcelCell::INT:
	//					//filetxt<<("%10d", cell->GetInteger())<<"      ";
	//					sprintf( ss,"ReadExcel* %10d\r\n", cell->GetInteger());
	//					break;
	//				case BasicExcelCell::DOUBLE:
	//					//filetxt<<("%10.6lf", cell->GetDouble())<<"      ";
	//					sprintf( ss,"ReadExcel* %10.6lf\r\n", cell->GetDouble());
	//					break;
	//				case BasicExcelCell::STRING:
	//					//filetxt<<("%10s", cell->GetString())<<"      ";
	//					sprintf( ss,"ReadExcel* %10s\r\n", cell->GetString());
	//					break;
	//				case BasicExcelCell::WSTRING:
	//					//filetxt<<(L"%s", cell->GetWString())<<"      ";
	//					//sprintf( ss,"ReadExcel %s\r\n", cell->GetWString());
	//					break;
	//				default:
	//					break;
	//			}

	//			WriteLog( ss,strlen(ss) );
	//		}
	//	}
	//}
}