smgp.cpp

短信防伪系统服务器端

// Smgp.cpp: implementation of the CSmgp class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "EasyTradeService.h"
#include "Smgp.h"
#include "md5.h"

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////


void PK_SMGP(SMGP_SUBMIT * pSubmit,
               int*  pk_len,
               char* srcTermid,
               char* destTermid,
               char* chargeTermid,
               int   subType,
               char* feeType,
               char* feecode,
               char* serviceid,
               int   msgFormat,
               int   msgLength,
               char* msgContent)
               
{
    memset(pSubmit, 0, sizeof(SMGP_SUBMIT)); 
    pSubmit->nNeedReport=1;
    pSubmit->nDestTermIdCount= 1;
    pSubmit->nMsgFormat   = msgFormat;
    pSubmit->nMsgLength   = msgLength;
    pSubmit->nMsgType     = subType;
    memcpy(pSubmit->sFeeType, feeType,sizeof(pSubmit->sFeeType)); 
    memcpy(pSubmit->sFeeCode, feecode,sizeof(pSubmit->sFeeCode)); 
    strcpy(pSubmit->sServerId, serviceid); 
    strcpy(pSubmit->sReplyPath,srcTermid);
    strcpy(pSubmit->sDestTermId,destTermid);
    strcpy(pSubmit->sChargeTermId,chargeTermid);
    memcpy(pSubmit->sMsgContent,msgContent,msgLength);
    *pk_len=sizeof(SMGP_HEAD)+sizeof(SMGP_SUBMIT);
    *pk_len= *pk_len- (sizeof(pSubmit->sMsgContent)-msgLength);
}

CSmgp::CSmgp()
{

}

CSmgp::~CSmgp()
{

}
char *CSmgp::BCDToString(char *src,int len, char *dest)
{
    char *decode="0123456789ABCDEF";
    for(int i=0;i<len;i++)
    {
        dest[i*2]=decode[src[i]>>4];
        dest[i*2+1]=decode[src[i]&0X0F];
    }
    dest[i*2]='\0';
    return dest;
}
void CSmgp::OnRecv()
{ 
	int	ret,len,cmdid=0;
	FD_SET	fdset;
	TIMEVAL	timeout;
	timeout.tv_sec = 1;
	timeout.tv_usec= 0;    
    SMGP_HEAD          head; 
    char               recvbuff[512];
    char               szMsgId[24];
    char               szResp[64];
    SMGP_SUBMIT_RESP  *pSubmitResp=0;
    SMGP_DELIVER      *pDeliver=0;
    SMGP_DELIVER_RESP *pDeliverResp=0;
    DELIVER_SMS        deliverSMS;
    MTREPORT_SMS       reportSMS;  
	while(!m_bQuit)
	{
        FD_ZERO( &fdset);
        FD_SET(m_Socket, &fdset);
		ret = select(0,&fdset,NULL,NULL,&timeout);
		if( ret == SOCKET_ERROR)
        {
		     OnSocketError();
             continue;
        }
		if( ret == 0)
        {
            continue; 
        }
        ret =::recv( m_Socket ,(char*)&head, sizeof( SMGP_HEAD ) ,0); 
		if( ret != sizeof( SMGP_HEAD))
        {
            if(ret==0||ret== SOCKET_ERROR)
            {
                OnSocketError();
            }
			continue;
        }
		len= ntohl(head.size ) - sizeof( SMGP_HEAD );
        ret =::recv(m_Socket, recvbuff, len ,0 );
		if( ret != len )
        {  
            if(ret==0||ret==SOCKET_ERROR)
            {
                OnSocketError();
            }
			continue;
        }
		int cmdid=ntohl(head.cmdid);
        switch(cmdid)
        {
            case nSMGP_SUBMIT_RESP: 
                pSubmitResp= (SMGP_SUBMIT_RESP*)recvbuff;
                BCDToString(pSubmitResp->sMsgId, 10, szMsgId);
                OnSubmitResp(ntohl(head.seqid),ntohl(pSubmitResp->nResult),szMsgId);
                break;
            case nSMGP_DELIVER:
                pDeliver=(SMGP_DELIVER*)recvbuff;
                *((SMGP_HEAD *)szResp)=head;
                len=  sizeof( SMGP_HEAD) + sizeof(SMGP_DELIVER_RESP);
                ((SMGP_HEAD *)szResp)->size=htonl(len);
                ((SMGP_HEAD *)szResp)->cmdid=htonl(nSMGP_DELIVER_RESP);
                ((SMGP_DELIVER_RESP *)(szResp+ sizeof( SMGP_HEAD)))->nResult=0;
                memcpy(((SMGP_DELIVER_RESP *)(szResp+ sizeof( SMGP_HEAD)))->sMsgId, pDeliver->sMsgId,10);
                ret=Send(szResp,len);
                if(ret==len)
                {
                    if(pDeliver->nIsReport)      //状态报告
                    {
                        int nPos=0;char *p=recvbuff; 
                        p=p+3;
                        BCDToString(p,10, reportSMS.smgMsgId);
                        p=p+10;
	                    //p=strstr(p,"submit date:");
                        p=p+12+10;
	                    //p=strstr(p,"done date:");
                        p=p+10+10;
	                    p=strstr(p,"stat:");
                        memcpy(reportSMS.state,p+5,7);p=p+6+7;
	                    p=strstr(p,"err:");           p=p+4;
                        *(p+3)=0;reportSMS.errorCode=atoi(p);      
                        reportSMS.protrol=3;
                        strcpy(reportSMS.corpId,m_szCorpId);
                        strcpy(reportSMS.srcTermid,pDeliver->sSrcTermId);
                        strcpy(reportSMS.destTermid,pDeliver->sDestTermId);
                        OnMTReportSMS(&reportSMS);
                    }
                    else
                    {
                        deliverSMS.protrol=3;
                        strcpy(deliverSMS.corpId,m_szCorpId);
                        deliverSMS.msgFormat=pDeliver->nMsgFormat;
                        strcpy(deliverSMS.srcTermid,pDeliver->sSrcTermId);
                        strcpy(deliverSMS.destTermid,pDeliver->sDestTermId);
                        memcpy(deliverSMS.msgContent,pDeliver->sMsgContent,pDeliver->nMsgLength);
                        deliverSMS.msgContent[pDeliver->nMsgLength]=0;
                        BCDToString(deliverSMS.smgMsgId,10,pDeliver->sMsgId);
                        OnDeliverSMS(&deliverSMS);
                    }
                }
                else
                {
                    if(ret==0||ret==SOCKET_ERROR)
                    {
                        OnSocketError();
                    }
                }
                break;
		    case nSMGP_ACTIVE_TEST:
                head.cmdid=htonl(nSMGP_ACTIVE_TEST_RESP);
                ret=Send((char*)&head,sizeof(SMGP_HEAD));
                if(ret==0||ret==SOCKET_ERROR)
                {
                    OnSocketError();
                }
               break;
            default:
			    break;
        }
    }
}
int CSmgp:: SubmitSMS(SUBMIT_SMS *p ,int len,int seqid)
{
    ((SMGP_HEAD * )(p->pkg))->cmdid = htonl(nSMGP_SUBMIT);
    ((SMGP_HEAD * )(p->pkg))->size  = htonl( len );
    ((SMGP_HEAD * )(p->pkg))->seqid = htonl( seqid );
    return Send(p->pkg,len);
}
void CSmgp::OnSocketError()
{
    int ret;
    EnterCriticalSection( &m_csSocket);
    ret=Connect();
    if(ret==0)
    {
        char szbuff[64];
        char authsrc[24]={0}, szTimeStamp[12]={0};
	    int  nsize = sizeof( SMGP_HEAD) + sizeof( SMGP_LOGIN);
	    ((SMGP_HEAD * )szbuff)->size  = htonl( nsize);
        ((SMGP_HEAD * )szbuff)->cmdid = htonl( nSMGP_LOGIN);
        ((SMGP_HEAD * )szbuff)->seqid = htonl(GetSeqid(0));
        GetTimeStamp(szTimeStamp);
        strcpy(((SMGP_LOGIN*)(szbuff+sizeof( SMGP_HEAD)))->sUser, m_szUser);
        MD5 ctx;
        ctx.update((unsigned char *)m_szUser, strlen(m_szUser));
        ctx.update((unsigned char *)"\0\0\0\0\0\0\0", 7);
        ctx.update((unsigned char *)m_szPwd, strlen(m_szPwd));
        ctx.update((unsigned char *)szTimeStamp, 10);
        ctx.finalize();
        ctx.raw_digest((unsigned char *)((SMGP_LOGIN*)(szbuff+sizeof( SMGP_HEAD)))->sAuthenMD5);
        ((SMGP_LOGIN*)(szbuff+sizeof( SMGP_HEAD)))->nVersion=0x13;
        ((SMGP_LOGIN*)(szbuff+sizeof( SMGP_HEAD)))->nLoginMode=m_nLoginMode;
        ((SMGP_LOGIN*)(szbuff+sizeof( SMGP_HEAD)))->nTimeStamp=htonl(atol(szTimeStamp));
        ret=::send(m_Socket,szbuff, nsize,0 );
    }
    LeaveCriticalSection( &m_csSocket);
}
int  CSmgp::Login()
{
    char szbuff[64];
    char authsrc[24]={0}, szTimeStamp[12]={0};
	int  nsize = sizeof( SMGP_HEAD) + sizeof( SMGP_LOGIN);
	((SMGP_HEAD * )szbuff)->size  = htonl( nsize);
    ((SMGP_HEAD * )szbuff)->cmdid = htonl( nSMGP_LOGIN);
    ((SMGP_HEAD * )szbuff)->seqid = htonl(GetSeqid(0));
    GetTimeStamp(szTimeStamp);
    strcpy(((SMGP_LOGIN*)(szbuff+sizeof( SMGP_HEAD)))->sUser, m_szUser);
    MD5 ctx;
    ctx.update((unsigned char *)m_szUser, strlen(m_szUser));
    ctx.update((unsigned char *)"\0\0\0\0\0\0\0", 7);
    ctx.update((unsigned char *)m_szPwd, strlen(m_szPwd));
    ctx.update((unsigned char *)szTimeStamp, 10);
    ctx.finalize();
    ctx.raw_digest((unsigned char *)((SMGP_LOGIN*)(szbuff+sizeof( SMGP_HEAD)))->sAuthenMD5);
    ((SMGP_LOGIN*)(szbuff+sizeof( SMGP_HEAD)))->nVersion=0x13;
    ((SMGP_LOGIN*)(szbuff+sizeof( SMGP_HEAD)))->nLoginMode=m_nLoginMode;
    ((SMGP_LOGIN*)(szbuff+sizeof( SMGP_HEAD)))->nTimeStamp=htonl(atol(szTimeStamp));
    int ret=Send(szbuff, nsize);
    if(ret== nsize)
    {   
        nsize= sizeof( SMGP_HEAD) + sizeof(SMGP_LOGIN_RESP);
        ret=recv(m_Socket,szbuff,nsize,0);
        if(ret==nsize)
        {
            return ntohl(((SMGP_LOGIN_RESP * )(szbuff + sizeof( SMGP_HEAD)))->nResult); 
        }
        else
        {
            return WSAGetLastError();
        }
    }
    return WSAGetLastError();
}
int  CSmgp::Logout()
{
    SMGP_HEAD head;
    head.size=htonl(sizeof(SMGP_HEAD));
    head.cmdid=htonl(nSMGP_EXIT);
    head.seqid=htonl(GetSeqid(0));
    int ret=Send((char *)&head,sizeof(SMGP_HEAD));
    return 0;
}
int CSmgp::Startup(char *szIp,int port, int login_mode,
            char *szUser,char *szPwd,
            char *szCorpId, char *szSeverNumber,char *szSpNode,
            int  threadpool,int wndsize,
            int  timeout,int trys,
            void (*OnDeliverSMS)(DELIVER_SMS   *pDeliver),
            void (*OnMTReportSMS)(MTREPORT_SMS *pReport),
            void (*OnSubmitedSMS)(SUBMIT_SMS   *pSubmited))
{
    m_OnDeliverSMS=OnDeliverSMS;
    m_OnMTReportSMS=OnMTReportSMS;
    m_OnSubmitedSMS=OnSubmitedSMS;
    strcpy(m_szIp, szIp);
    m_nPort=port ;
    m_nLoginMode= login_mode;
    strcpy(m_szUser,szUser) ;
    strcpy(m_szPwd,szPwd) ;
    if(szCorpId)      strcpy(m_szCorpId, szCorpId);
    if(szSeverNumber) strcpy(m_szSeverNumber,szSeverNumber);
    if(szSpNode)      strcpy(m_szSpNode,szSpNode);
    int ret=Connect();
    if(ret==0)
    {
        ret=Login();
    }
    Initialize(threadpool,wndsize,timeout,trys);
    return ret;
}
int CSmgp::Cleanup()
{
    Logout();
    Close();
    return 0;
}
void CSmgp::OnActive()
{
    int timeActive=0;
    SMGP_HEAD  head;
    while(!m_bQuit)
    {
        Sleep(1000);
        if(timeActive++>= 60 )
        {
            head.cmdid= htonl(nSMGP_ACTIVE_TEST);
            head.seqid= htonl(GetSeqid(0));
            head.size= htonl(sizeof(SMGP_HEAD));
            Send((char *)&head,sizeof(SMGP_HEAD));
            timeActive=0;
        }
    }
}