applsnmp.c

基于h323协议的软phone

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

#include "applSnmpI.h"
#include "cm.h"



BOOL APIENTRY DllMain( HANDLE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    return TRUE;
}



h341InstanceHandle hSnmp=NULL;
HANDLE hMapFile,hEvent,stopEventSnmp,hEventWait,hEventUnreg;
LPVOID lpMapAddress;
DWORD treadId;
DWORD snmpThreadId;

void changeGlobals( h341AgentComHandle hAgentCom,h341ParameterName lParam,int wParam);


#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


/*
    h341InstanceWnd is called on receiving notification from subagent
    about new request,using event for synchronization,retrieves parameters
    and its values from mapped file,processes the request and puts response into
    the same mapped file, sets event to break waiting loop of subagent.

*/


LRESULT RVCALLCONV
		h341InstanceWnd(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
switch(uMsg)
{
            case WM_SET_PARAMETER:
                {
                char buff[1024];
                mibDataT data;
                int error;
                char * ptr;
                h341ParameterName name;
                int bufferSize=1024;
                data.value  = buff;
                ptr = lpMapAddress ;
                ptr=ptr+30;

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

                memcpy((char *)&data.type,ptr,4);
                ptr+=4;

                memcpy((char *)&data.valueSize,ptr,4);
                ptr+=4;

                if ((data.type == asnMibOctetString)||(data.type == asnAddressString))
                    memcpy(data.value,ptr,data.valueSize);

                error = h341InstSetRequest(hSnmp, name,&data);

                ptr = lpMapAddress ;
                ptr=ptr+30;

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

                }
            break;
            case WM_RETRIEVE_MR:
                {
                    char buff[1024];
                    char temp[2048];
                    char * ptr,*ptrTemp;
                    int res;
                    int reqNum,ii;

                    instanceRequestDataT instRequests;

                    mibDataT data;
                    ptrTemp = temp;

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

                    for(ii=0;ii<reqNum;ii++)
                    {
                        data.value=buff;
                        data.valueSize=1024;

                        memcpy((char *)&instRequests.reqType,ptr,4);
                        ptr+=4;
                        memcpy((char *)&instRequests.name,ptr,4);
                        ptr+=4;
                        memcpy((char *)&instRequests.indexSize,ptr,4);
                        ptr+=4;


                        if( instRequests.indexSize)
                        {
                            memcpy((char *)&instRequests.index,ptr,instRequests.indexSize);
                            ptr+=instRequests.indexSize;

                        }
                        if (instRequests.reqType==retrieveByIndex)
                        {
                            res=h341InstGetByIndex (hSnmp,instRequests.index,instRequests.indexSize,instRequests.name,&data);
                            memcpy(ptrTemp,(char *)&res,4);
                            ptrTemp +=4;
                            if(!res)
                            {
                                memcpy(ptrTemp,(char *)&data.type,4);
                                ptrTemp +=4;
                                if (data.type!=asnError)
                                {
                                    memcpy(ptrTemp,(char *)&data.valueSize,4);
                                    ptrTemp +=4;
                                    if ((data.type==asnMibOctetString)||(data.type==asnAddressString))
                                    {
                                        memcpy(ptrTemp,data.value,data.valueSize);
                                        ptrTemp+=data.valueSize;
                                    }
                                }
                            }

                        }
                        else
                            if (instRequests.reqType==retrieveParam)
                            {
                                res=h341InstGetParameter(hSnmp, instRequests.name,&data);
                                memcpy(ptrTemp,(char *)&res,4);
                                ptrTemp +=4;
                                if(!res)
                                {
                                    memcpy(ptrTemp,(char *)&data.type,4);
                                    ptrTemp +=4;
                                    if (data.type!=asnError)
                                    {
                                        memcpy(ptrTemp,(char *)&data.valueSize,4);
                                        ptrTemp +=4;
                                        if ((data.type==asnMibOctetString)||(data.type==asnAddressString))
                                        {
                                            memcpy(ptrTemp,data.value,data.valueSize);
                                            ptrTemp+=data.valueSize;
                                        }
                                    }
                                }

                            }
                            else if (instRequests.reqType==retrieveNextIndex)
                            {
                                res=h341InstGetNextIndex (hSnmp,instRequests.name,instRequests.index,instRequests.indexSize,instRequests.nextIndex,&instRequests.nextIndexSize,&data);
                                memcpy(ptrTemp,(char *)&res,4);
                                ptrTemp=ptrTemp+4;
                                if (!res)
                                {
                                    memcpy(ptrTemp,(char *)&instRequests.nextIndexSize,4);
                                    ptrTemp=ptrTemp+4;
                                    memcpy(ptrTemp,instRequests.nextIndex,instRequests.nextIndexSize);
                                    ptrTemp=ptrTemp+instRequests.nextIndexSize;

                                    memcpy(ptrTemp,(char *)&data.type,4);
                                    ptrTemp=ptrTemp+4;
                                    if (data.type!=asnError)
                                    {
                                        memcpy(ptrTemp,(char *)&data.valueSize,4);
                                        ptrTemp=ptrTemp+4;
                                        if ((data.type==asnMibOctetString)||(data.type==asnAddressString))
                                        {
                                            memcpy(ptrTemp,data.value,data.valueSize);
                                            ptrTemp+=data.valueSize;
                                        }
                                    }
                                }
                            }

                    }
                    ptr = lpMapAddress;
                    ptr+=4;
                    memcpy(ptr,temp,(ptrTemp-temp));
                }
                break;
            case WM_RETRIEVE_NEXT_INDEX:  /* send message */
            {
                char buff[1024];
                int res;
                h341ParameterName name;
                RvUint8 index[100],nextIndex[100];

                int indexSize,nextIndexSize;
                char *ptr;
                mibDataT data;
                data.value=buff;
                data.valueSize=1024;


                 ptr = lpMapAddress ;
                 ptr=ptr+30;
                 memcpy((char *)&name,ptr,4);
                 ptr+=4;
                 memcpy((char *)&indexSize,ptr,4);
                 ptr+=4;
                 memcpy(index,ptr,indexSize);
                 res=h341InstGetNextIndex (hSnmp,name,index,indexSize,nextIndex,&nextIndexSize,&data);
                 ptr = lpMapAddress;
                 ptr=ptr+4;
                 memcpy(ptr,(char *)&res,4);
                 ptr=ptr+4;
                 if (!res)
                 {
                    memcpy(ptr,(char *)&nextIndexSize,4);
                    ptr=ptr+4;
                    memcpy(ptr,nextIndex,nextIndexSize);
                    ptr=ptr+nextIndexSize;

                    memcpy(ptr,(char *)&data.type,4);
                    ptr=ptr+4;
                    if (data.type!=asnError)
                    {
                        memcpy(ptr,(char *)&data.valueSize,4);
                        ptr=ptr+4;
                        if ((data.type==asnMibOctetString)||(data.type==asnAddressString))
                            memcpy(ptr,data.value,data.valueSize);
                    }
                 }


            }
            break;
        case WM_RETRIEVE_BY_INDEX:
            {
                char buff[1024];

                int res;
                h341ParameterName name;
                RvUint8  index[100];
                int indexSize;
                mibDataT data;
                char *ptr;

                data.value=buff;
                data.valueSize=1024;


                 ptr = lpMapAddress ;
                 ptr=ptr+30;
                 memcpy((char *)&name,ptr,4);
                 ptr+=4;
                 memcpy((char *)&indexSize,ptr,4);
                 ptr+=4;
                 memcpy(index,ptr,indexSize);


                res=h341InstGetByIndex (hSnmp,index,indexSize,name,&data);


                 ptr = lpMapAddress;
                 ptr=ptr+4;
                 memcpy(ptr,(char *)&res,4);
                 ptr=ptr+4;
                 if (!res)
                 {
                    memcpy(ptr,(char *)&data.type,4);