sgip.cpp

短信防伪系统服务器端

// Sgip.cpp: implementation of the CSgip class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "EasyTradeService.h"
#include "Sgip.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
void PK_SGIP(SGIP_SUBMIT * pSubmit,
               int*  pk_len,
               char *corpId,
               char* srcTermid,
               char* destTermid,
               char* chargeTermid,
               int   feeuserType,
               int   moRelatetoMTFlag,
               char* feeType,
               char* feecode,
               char* serviceid,
               int   msgFormat,
               int   msgLength,
               char* msgContent,
               char* linkId)
               
               
{
    memset(pSubmit, 0, sizeof(SGIP_SUBMIT)); 
    pSubmit->cMorelatetoMTFlag= moRelatetoMTFlag;
    pSubmit->cReportFlag=1;
    pSubmit->cUserCount= 1;
    pSubmit->cMessageCoding   = msgFormat;
    pSubmit->nMsgLen   =  htonl(msgLength);
    pSubmit->cFeeType  =  atoi(feeType); 
    memcpy(pSubmit->sCorpId,corpId,sizeof(pSubmit->sCorpId));
    memcpy(pSubmit->sFeeValue, feecode,sizeof(pSubmit->sFeeValue)); 
    strcpy(pSubmit->sServiceType, serviceid); 
    strcpy(pSubmit->sSPNumber,srcTermid);
    if(strnicmp(pSubmit->sUserNumber,"86",2)!=0)
    {
        pSubmit->sUserNumber[0]='8';
        pSubmit->sUserNumber[1]='6';
        strcpy(pSubmit->sUserNumber+2,destTermid);
    }
    else
    {
        strcpy(pSubmit->sUserNumber,destTermid);
    }
    strcpy(pSubmit->sChargeNumber,chargeTermid);
    memcpy(pSubmit->sMsgContent,msgContent,msgLength);
    if(linkId) strcpy(pSubmit->sMsgContent + msgLength, linkId);
    *pk_len=sizeof(SGIP_HEAD)+sizeof(SGIP_SUBMIT);
    *pk_len= *pk_len- (sizeof(pSubmit->sMsgContent)-msgLength);
}

CSgip::CSgip()
{
    m_hListenThread=0;
}

CSgip::~CSgip()
{
    if(m_hListenThread)
    {
        ::CloseHandle(m_hListenThread);
    }
}
unsigned long _stdcall CSgip:: ListenThreadProc(void * lpvoid)
{
    CSgip *pThis=(CSgip *)lpvoid;
    pThis->AddThreadPoolInstance();
    pThis->OnListen();
    pThis->ReleaseThreadPoolInstance();
    return 0;
}
void  CSgip:: OnListen()
{
	int ret,index=0,eventTotal=0,len,ncmdid;
	WSANETWORKEVENTS networkEvents;
	SOCKET   sockaccept, accept_socks[WSA_MAXIMUM_WAIT_EVENTS];
	WSAEVENT newevent  , accept_events[WSA_MAXIMUM_WAIT_EVENTS];
	newevent=WSACreateEvent();
	::WSAEventSelect(m_socklisten,newevent,FD_ACCEPT|FD_CLOSE);
    accept_socks[eventTotal]=m_socklisten;
	accept_events[eventTotal]=newevent;
	eventTotal++;
    SGIP_DELIVER   *pDeliver;
    SGIP_REPORT    *pReport;
    DELIVER_SMS    deliverSMS;
    MTREPORT_SMS   reportSMS;
    SGIP_HEAD head;
    char      recvbuff[512];
	while(!m_bQuit)
	{
		ret=WSAWaitForMultipleEvents(eventTotal,accept_events,false,1000,false);
        if(ret==WSA_WAIT_TIMEOUT||ret==WSA_WAIT_FAILED)   
        {
            continue;
        }
		index=ret-WSA_WAIT_EVENT_0 ;
        for(int i=index;i< eventTotal ;i++)
        {
            ret=WSAWaitForMultipleEvents(1,&accept_events[i],true,0,false);
            if(ret==WSA_WAIT_EVENT_0 )
            {
 		        ::WSAEnumNetworkEvents(accept_socks[i],accept_events[i],&networkEvents);
		        if(networkEvents.lNetworkEvents & FD_ACCEPT)
		        {
			        if(networkEvents.iErrorCode[FD_ACCEPT_BIT]!=0) 
                    {
                        continue;
                    }
                    sockaccept=accept(accept_socks[i],NULL,NULL);
			        if(eventTotal==WSA_MAXIMUM_WAIT_EVENTS)
			        {
				        closesocket(sockaccept);
				        continue;
			        }
			        newevent=WSACreateEvent();
			        ::WSAEventSelect(sockaccept,newevent,FD_READ|FD_CLOSE);
			        accept_socks[eventTotal]=sockaccept;
       		        accept_events[eventTotal]=newevent;
			        eventTotal++;
		        }
                else if (networkEvents.lNetworkEvents & FD_CLOSE)
		        {
			        closesocket(accept_socks[i]);
			        CloseHandle(accept_events[i]);
			        for(int j=i;j<eventTotal-1;j++)
			        {
				        accept_socks[j]=accept_socks[j+1];
                        accept_events[j]=accept_events[j+1];
			        }
			        eventTotal--;
		        }
                else if (networkEvents.lNetworkEvents & FD_READ)
		        {
			        if(networkEvents.iErrorCode[FD_READ_BIT]!=0) 
                    {
                        continue;
                    }
                    ret = ::recv( accept_socks[i], (char*)&head, sizeof(head), 0);
			        if(ret!=sizeof(head))     
                    {
                        continue;
                    }
                    len=ntohl(head.size)-sizeof(head);
                    if(len)
                    {
                        ret = ::recv( accept_socks[i],recvbuff,len, 0);
			            if(ret!=len) 
                        {
                            continue;
                        }
                    }
			        ncmdid=ntohl(head.cmdid);
                    if( ncmdid==nSGIP_UNBIND)
		            {
			            head.cmdid=htonl(nSGIP_UNBIND_RESP); 
			            send(accept_socks[i],(char *)&head,sizeof(head),0);
			            closesocket(accept_socks[i]);
			            CloseHandle(accept_events[i]);
			            for(int j=i;j<eventTotal-1;j++)
			            {
				            accept_socks[j]=accept_socks[j+1];
                            accept_events[j]=accept_events[j+1];
			            }
			            eventTotal--;
		            }
                    else if ( ncmdid==nSGIP_BIND)
                    {
                        SGIP_BIND_RESP bindResp;
                        head.cmdid=htonl(nSGIP_BIND_RESP);
				        bindResp.cResult=0;
                        len= sizeof(SGIP_HEAD)+sizeof(SGIP_BIND_RESP);
				        head.size=htonl(len);
				        ret=send(accept_socks[i],(char *)&head,sizeof(SGIP_HEAD),0);
                        if(ret==sizeof(SGIP_HEAD) )
                        {
                            len= len- sizeof(SGIP_HEAD) ;
                            ret=send(accept_socks[i],(char *)&bindResp,len ,0);
                        }
                    }
                    else if ( ncmdid==nSGIP_DELIVER)
                    {
                        SGIP_DELIVER_RESP deliverResp;
                        head.cmdid=htonl(nSGIP_DELIVER_RESP);
				        deliverResp.cResult=0;
                        len= sizeof(SGIP_HEAD)+sizeof(SGIP_DELIVER_RESP);
				        head.size=htonl(len);
				        ret=send(accept_socks[i],(char *)&head,sizeof(SGIP_HEAD),0);
                        if(ret==sizeof(SGIP_HEAD) )
                        {
                            len= len- sizeof(SGIP_HEAD) ;
                            ret=send(accept_socks[i],(char *)&deliverResp,len ,0);
                            if(ret==len)
                            {
                                pDeliver= (SGIP_DELIVER *) recvbuff;
                                deliverSMS.protrol=1;
                                strcpy(deliverSMS.corpId,m_szCorpId);
                                deliverSMS.msgFormat=pDeliver->cMessageCoding;
                                strcpy(deliverSMS.srcTermid,pDeliver->sUserNumber);
                                strcpy(deliverSMS.destTermid,pDeliver->sSPNumber);
                                pDeliver->nMsgLen=ntohl(pDeliver->nMsgLen);
                                memcpy(deliverSMS.msgContent,pDeliver->sMsgContent,pDeliver->nMsgLen);
                                deliverSMS.msgContent[pDeliver->nMsgLen]=0;
                                memcpy(deliverSMS.linkId, pDeliver->sMsgContent + pDeliver->nMsgLen, sizeof(pDeliver->sReserved));
                                sprintf(deliverSMS.smgMsgId,"%0X%0X", ntohl(head.seqid.nSeq2), ntohl(head.seqid.nSeq3));
                                OnDeliverSMS(&deliverSMS);
                            }
                        }
                    }
                    else if ( ncmdid==nSGIP_REPORT )
                    {
                        SGIP_REPORT_RESP reportResp;
                        head.cmdid=htonl(nSGIP_REPORT_RESP);
				        reportResp.cResult=0;
                        len= sizeof(SGIP_HEAD)+sizeof(SGIP_REPORT_RESP);
				        head.size=htonl(len);
				        ret=send(accept_socks[i],(char *)&head,sizeof(SGIP_HEAD),0);
                        if(ret==sizeof(SGIP_HEAD) )
                        {
                            len= len- sizeof(SGIP_HEAD) ;
                            ret=send(accept_socks[i],(char *)&reportResp,len ,0);
                            if(ret==len)
                            {
                                pReport=(SGIP_REPORT*)recvbuff;
                                reportSMS.protrol=1;
                                strcpy(reportSMS.corpId,m_szCorpId);