repos_ecs/Dll_Snmp/MyAgent/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 <io.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] ;//= {
//	{	
//		{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;
}
/*从中部截取字符串 */
char *STRmid(char *dst,char *src,int n,int m)
{
	char *p=src;
	char *q=dst;
	//int len=strlen(src);
	//if(n>len) n=len-m;
	//if(m>0) 
	//	return NULL;
	p += n;
		
	while(m>n) 
	{
		*(q++) = *(p++);
		n++;
	}
		
	*(q++)='\0';
		
	return dst;
}
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 3.0.4.0\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);
		//sprintf( ss,"SnmpExtensionTrap  %s\r\n",&(pVarBindList->list[0].name) );
		//WriteLog( ss,strlen(ss) );
		//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 长度%d \r\n",st.wHour,st.wMinute,st.wSecond,pVarBindList->list[0].value.asnValue.string.length );
		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
// 客户通过OID读取时，该函数执行
int GetRequest(SnmpVarBind *pVarBind)
{
	int nRet = SNMP_ERRORSTATUS_NOSUCHNAME;
	AsnObjectIdentifier  asnOidTemp;

	CHAR ss[255];sprintf( ss,"GetRequest\r\n" );
	//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
// 客户通过OID读取下个数据时，该函数执行
int GetNextRequest(SnmpVarBind *pVarBind)
{
	int nRet = SNMP_ERRORSTATUS_NOSUCHNAME;
	//int nResult = 0;(M2)163845=11(M3)274568=11()=00
	//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 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);
	 
	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
// 客户通过OID设置时，该函数执行
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],sData[255],sContent[255];
			memset( src,0,255 );
			memset( des,0,255 );
			memset( ss,0,255 );

			int nType = 0;

			sprintf( src,"%s",pVarBind->value.asnValue.string );
			char *cPos = strstr( src,"*" );
			int nPos1 = -1;
			int nPos2 = -1;

			/*sprintf( ss,"SetRequest=%s   %s\r\n",src,cPos );
			WriteLog( ss,strlen(ss) );*/

			if( cPos )
			{
				nPos1 = FindChar( '*',src,strlen(src) );
				nPos2 = FindChar( '#',src,strlen(src) );

				STRmid( ss,src,0,nPos1 );
				nType = atoi( ss );
				STRmid( sData,src,nPos1+1,nPos2 );
				STRmid( sContent,src,nPos2+1,strlen(src) );

				//sprintf( ss,"nType=%d  sData=%s  sContent=%s\r\n",nType,sData,sContent );
				//WriteLog( ss,strlen(ss) );
			}
			else
			{
				sprintf( sData,"%s",pVarBind->value.asnValue.string );
			}
	
			if( cPos==NULL )
			{
				SnmpUtilOidFree(&asnOidTemp);
				nRet = SetStoreVar(&g_MyMibTable[i],pVarBind->value);
			}
			else 
			{
				SnmpUtilMemFree( pVarBind->value.asnValue.string.stream );
				pVarBind->value.asnType = ASN_OCTETSTRING;
				pVarBind->value.asnValue.string.dynamic = TRUE;
				pVarBind->value.asnValue.string.length = strlen(sData);
				pVarBind->value.asnValue.string.stream =(unsigned char*)SnmpUtilMemAlloc( strlen(sData) * sizeof(char));
				memcpy( pVarBind->value.asnValue.string.stream,sData,strlen(sData) );

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

				if( nType!=0 )
				{
					g_MyMibTable[4999].asnOid			= g_MyMibTable[i].asnOid;
					g_MyMibTable[4999].unAccess			= g_MyMibTable[i].unAccess;
					g_MyMibTable[4999].chType			= ASN_OCTETSTRING;//g_MyMibTable[i].chType;
					memcpy(*(LPSTR*)(g_MyMibTable[4999].pStorageValue),&sContent,strlen(sContent) );
					//g_MyMibTable[4999].pStorageValue	= &sContent[0];
					//g_MyMibTable[4999].pStorageValue	= &sContent;//g_MyMibTable[i].pStorageValue;
					//memcpy( g_MyMibTable[4999].pStorageValue,sContent,strlen(sContent) );
					//memcpy(*(LPSTR*)(g_MyMibTable[4999].pStorageValue),sContent,strlen(sContent) );
					g_MyMibTable[4999].szStorageName	= "测试";//Convert( sContent,936,CP_UTF8);//g_MyMibTable[i].szStorageName;//"发生报警";//
					//SetStoreVar(&g_MyMibTable[4999],pVarBind->value);
					
					sprintf( ss,"类型=%d  值=%s  内容=%s  长度=%d \r\n",nType,sData,sContent,strlen(sContent) );
					WriteLog( ss,strlen(ss) );

					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 ReadExcel()
{
	CHAR ss[255];// = "SnmpExtensionQuery\r\n";
	if( -1==access("C:\\OID-斯特纽有限公司.xls",0) )
	{
		sprintf( ss,"OID-斯特纽有限公司.xls 不存在 \r\n" );
		WriteLog( ss,strlen(ss) );
		return;
	}

	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) );

	for( int i=0;i<nCount;i++ )
	{
		SnmpMgrStrToOid( array1[i], &g_MyMibTable[g_unMyMibCount].asnOid );//oid
		
		g_MyMibTable[g_unMyMibCount].unAccess = SNMP_ACCESS_READ_WRITE;//读写权限
		sprintf( ss,"read-write\r\n" );
	
		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 );

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

		g_MyMibTable[g_unMyMibCount].szStorageName = array6[i];
		
		g_MyMibTable[g_unMyMibCount].pMibNext = &g_MyMibTable[g_unMyMibCount+1];

		g_unMyMibCount++;
	}

	g_MyMibTable[g_unMyMibCount].pMibNext = NULL;

	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);
	g_MyMibTable[4999].pStorageValue = &g_sData[4999];

	sprintf( ss,"ReadExcel out \r\n" );
	WriteLog( ss,strlen(ss) );
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	CHAR sContent[255];
//	memset( sContent,0,255 );
//	sprintf( sContent,"值内容" );
//	//WriteLog( sContent,strlen(sContent) );
//	sprintf( ss," g_unMyMibCount=%d\r\n",g_unMyMibCount );
//	WriteLog( ss,strlen(ss) );
//
//	g_MyMibTable[4999].asnOid			= g_MyMibTable[0].asnOid; 
//	g_MyMibTable[4999].unAccess			= SNMP_ACCESS_READ_WRITE;  
//	g_MyMibTable[4999].chType			= ASN_OCTETSTRING;  
//	//g_MyMibTable[4999].pStorageValue	= &sContent[0];
//	//g_MyMibTable[4999].pStorageValue	= &sContent;//g_MyMibTable[i].pStorageValue;
//	//memcpy( g_MyMibTable[4999].pStorageValue,sContent,strlen(sContent) );
//	memcpy(*(LPSTR*)(g_MyMibTable[4999].pStorageValue),&sContent,strlen(sContent)-0 );
//	//g_MyMibTable[4999].szStorageName	= sContent;//"测试";//Convert( sContent,936,CP_UTF8);//g_MyMibTable[i].szStorageName;//"发生报警";//
//	//SetStoreVar(&g_MyMibTable[4999],pVarBind->value);
//
//	int nLen = strlen(*(LPSTR*)g_MyMibTable[4999].pStorageValue);
//	sprintf( ss,"%s    长度1=%d \r\n",*(LPSTR*)(g_MyMibTable[4999].pStorageValue),nLen );
//	WriteLog( ss,strlen(ss) );
//
//	SnmpVarBindList *pVarBindList = new SnmpVarBindList;
//
//	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);
//			
//	nLen = pVarBindList->list[0].value.asnValue.string.length;
//	sprintf( ss,"%s    长度2=%d \r\n",(pVarBindList->list[0].value.asnValue.string.stream),nLen );
//	WriteLog( ss,strlen(ss) );
}