snmpdll.c

基于h323协议的软phone

#include <windows.h>
#include <snmp.h>
#include <process.h>
#include <stdio.h>

#include <rvh341agent.h>
#define     MM_VIEW_OFFSET       30
#define     WM_REGISTER_SUBAG    WM_USER+101
#define     WM_UNREGISTER_SUBAG    WM_USER+102


#define     WM_RETRIEVE_NEXT_INDEX   WM_USER+103
#define     WM_RETRIEVE_BY_INDEX   WM_USER+104
#define     WM_RETRIEVE             WM_USER+108
#define     WM_CHANGE_GLOBAL        WM_USER+106
#define     WM_SET_PARAMETER        WM_USER+107
#define     WM_RETRIEVE_MR          WM_USER+105

#define     noSuchWindow  50
#define     waitTimeout       50
#define     INSTANCE_NUMBER 5

#define     RequestNumber   40
typedef HANDLE h341SubAgentHandleT;
typedef DWORD   h341SubAgentIdT;


typedef struct
{
    h341SubAgentIdT h341SubAgentId; /* treadId of snmp instance thread*/
    h341SubAgentHandleT h341SubAgentHandle;       /* handle of event*/
    int                 h341SubAgentIndex;
}h341AgentRegT;
h341AgentRegT instReg[INSTANCE_NUMBER];



HANDLE mmhFile,hFile,hEvent,hEventWait;
LPVOID lpMapAddress;

/*
    winData2mibData transtates Windows data format mibDataT  format
*/
void   winData2mibData(AsnObjectSyntax *value,mibDataT *data)
{
    switch(value->asnType)
    {
    case ASN_INTEGER32:
        data->type=asnInt;
        data->valueSize = value->asnValue.number;
        break;
/*

    case  ASN_UNSIGNED32:
    case ASN_COUNTER64:
    case ASN_COUNTER32:
    case ASN_GAUGE32:
*/
    case ASN_OCTETSTRING:

        data->type=asnMibOctetString;
        data->value = value->asnValue.string.stream;
        data->valueSize = value->asnValue.string.length;
        break;
    case ASN_IPADDRESS:
        data->type=asnAddressString;
        data->value = value->asnValue.address.stream;
        data->valueSize = value->asnValue.address.length;
        break;
    default:
    break;
    }
}

/*
    Imitate Windows SendMessage function
*/
int snmpSendMessage(   HANDLE hHandle,
                    UINT uMsg,
                    WPARAM wParam,
                    LPARAM lParam)
{
    char *ptr;
    int res;
    ptr = lpMapAddress;

    ptr+=4;
    memcpy(ptr,(char *)&uMsg,sizeof(UINT));
    ptr+=sizeof(UINT);
    memcpy(ptr,(char *)&wParam,sizeof(WPARAM));
    ptr+=sizeof(WPARAM);
    memcpy(ptr,(char *)&lParam,sizeof(LPARAM));
    ptr+=sizeof(LPARAM);
    SetEvent(hHandle);

    res = WaitForSingleObject(hEventWait,INFINITE);
    if (res == WAIT_TIMEOUT)
        return waitTimeout;
    else
        return 0;

}

/*
    Callback function is called  to pass get and get Next
    request and corresponding data to instance.
*/

int h341MRRetrieve(h341RegisterHandleT regH,instanceRequestDataPtrT * instRequestsPtr,int reqNum)
{
    int ii;
    h341AgentRegT * reg = (h341AgentRegT *)regH;
    char * ptr;


    ptr = lpMapAddress;
    ptr+=MM_VIEW_OFFSET;

    memcpy(ptr,(char *)&reqNum,4);
    ptr = ptr+4;

    for (ii=0;ii<reqNum;ii++)
    {
        memcpy(ptr,(char *)&instRequestsPtr[ii]->reqType,4);
        ptr=ptr+4;
        memcpy(ptr,(char *)&instRequestsPtr[ii]->name,4);
        ptr=ptr+4;
        memcpy(ptr,(char *)&instRequestsPtr[ii]->indexSize,4);
        ptr=ptr+4;
        if (instRequestsPtr[ii]->indexSize)
        {
            memcpy(ptr,instRequestsPtr[ii]->index,instRequestsPtr[ii]->indexSize);
            ptr+=instRequestsPtr[ii]->indexSize;
        }

    }
    if (snmpSendMessage(   (HANDLE)reg->h341SubAgentHandle,WM_RETRIEVE_MR,0,0))
    {

        return waitTimeout;
    }

    ptr = lpMapAddress;
    ptr+=4;

    for (ii=0;ii<reqNum;ii++)
    {
        memcpy((char *)&instRequestsPtr[ii]->result,ptr,4);
        ptr+=4;

        if (!instRequestsPtr[ii]->result)
        {

            if (instRequestsPtr[ii]->reqType==retrieveNextIndex)
            {
                memcpy((char *)&instRequestsPtr[ii]->nextIndexSize,ptr,4);
                ptr+=4;
                memcpy(instRequestsPtr[ii]->nextIndex,ptr,instRequestsPtr[ii]->nextIndexSize);
                ptr+=instRequestsPtr[ii]->nextIndexSize;

            }

            memcpy((char *)&instRequestsPtr[ii]->pData.type,ptr,4);
            ptr+=4;
            if (instRequestsPtr[ii]->pData.type!=asnError)
            {
                memcpy((char *)&instRequestsPtr[ii]->pData.valueSize,ptr,4);
                ptr+=4;
                if((instRequestsPtr[ii]->pData.type==asnMibOctetString)||
                    (instRequestsPtr[ii]->pData.type==asnAddressString))
                {
                    memcpy(instRequestsPtr[ii]->pData.value,ptr,instRequestsPtr[ii]->pData.valueSize);
                    ptr+=instRequestsPtr[ii]->pData.valueSize;
                }
            }
        }
    }


    return 0;
}



/*
    Callback function is called  to pass set request and corresponding data to
    instance.
*/
h341ErrorT hAppl341SetParameter(h341RegisterHandleT regH,h341ParameterName name,mibDataT * data)
{
    h341AgentRegT * reg = (h341AgentRegT *)regH;
    char *ptr;
    h341ErrorT res;

    ptr = lpMapAddress;
    ptr+=MM_VIEW_OFFSET;
    memcpy(ptr,(char *)&name,4);
    ptr = ptr+4;
    memcpy(ptr,(char *)&data->type,4);
    ptr=ptr+4;
    memcpy(ptr,(char *)&data->valueSize,4);
    ptr=ptr+4;
    if ((data->type == asnMibOctetString)||(data->type == asnAddressString))
        memcpy(ptr,data->value,data->valueSize);

    if (snmpSendMessage(   (HANDLE)reg->h341SubAgentHandle,WM_SET_PARAMETER,0,0))
        return waitTimeout;
    ptr = lpMapAddress;
    ptr+=MM_VIEW_OFFSET;
    memcpy((char *)&res,ptr,4);

    return res;
}



LRESULT RVCALLCONV
h341AgentWnd(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam);

void WINAPI SnmpExtensionClose();



HINSTANCE hinst;
int count;
h341AgentHandleT hAgent;

BOOL WINAPI DLLMain(
                    HINSTANCE hinstDLL,
                    DWORD  dwReason,
                    LPVOID lpReserved)
{
    hinst = hinstDLL;
    switch(dwReason)
    {
    case DLL_PROCESS_ATTACH:

        break;
    case DLL_PROCESS_DETACH:

        SnmpExtensionClose();

        break;
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    default:
        break;

    } // end switch()

    return TRUE;

}




/*
    SnmpExtensionInitEx is called by NT SNMP for retrieving all mib subtrees,
    supprted by present extension subagent.

*/
BOOL WINAPI SnmpExtensionInitEx(
                                AsnObjectIdentifier *pNextSupportedRegion  )
{
    snmpObjectT * subtrees;
    int size;
    subtrees = h341AgentGetSubTrees(hAgent,&size);
    if (count==size)
        return FALSE;
    pNextSupportedRegion->ids = subtrees[count].id;
    pNextSupportedRegion->idLength = subtrees[count].length;


    count++;
    return TRUE;

}

/*
    Thread function, waiting notifications from the instances.
*/
unsigned __stdcall theStackThread(void*v)
{
    int res;
    MSG msg;
    DWORD threadId;
    threadId = GetCurrentThreadId();

    memcpy(lpMapAddress ,(char *)&threadId,sizeof(DWORD));
    while(GetMessage(&msg,NULL,0,0))
    {
        if(msg.hwnd==NULL)
        {
            res=h341AgentWnd(NULL,msg.message,msg.wParam,msg.lParam);
            if(!res)
            {
                h341AgentWnd(NULL,WM_UNREGISTER_SUBAG,msg.wParam,msg.lParam);
            }
        }
        else
            DispatchMessage(&msg);
    }

return 0;
}

void WINAPI SnmpExtensionClose()
{
        UnmapViewOfFile(lpMapAddress);
        CloseHandle(mmhFile);
        CloseHandle(hFile);
        CloseHandle(hEventWait);
        h341AgentEnd(hAgent);

}
/*
SnmpExtensionInit is called by NT SNMP service during initialization.
Initialization of snmp subagent module and all handles,using for
syncronization and communication with subinstances is perfomed here.
*/
BOOL WINAPI  SnmpExtensionInit(
                               IN  DWORD               dwTimeZeroReference,
                               OUT HANDLE              *hPollForTrapEvent,
                               OUT AsnObjectIdentifier *supportedView)
{

    int size,res;
    int ii;
    snmpObjectT * subtrees;
    char szTmpFile[256];
    char szMMFile[256];
    HANDLE hFile;

    SECURITY_DESCRIPTOR SD;
    SECURITY_ATTRIBUTES sa;


    if (!InitializeSecurityDescriptor(&SD, SECURITY_DESCRIPTOR_REVISION))
        return FALSE;


    if (!SetSecurityDescriptorDacl(&SD, TRUE, (PACL) NULL, FALSE))
        return FALSE;

    sa.nLength = sizeof(sa);
    sa.lpSecurityDescriptor = &SD;
    sa.bInheritHandle = TRUE;



    count = 0;

    for (ii = 0;ii< INSTANCE_NUMBER;ii++)
        memset(&instReg[ii],0,sizeof(h341AgentRegT));
    /*
        Initialization of  subAgent module.
        hAppl341SetParameter,h341MRRetrieve - callback functions to communicate
        with instances.

    */
    res =  h341AgentInit(RequestNumber,INSTANCE_NUMBER,
                            hAppl341SetParameter,h341MRRetrieve,&hAgent);