smgapi.cpp

中国移动的短信网关程序

#include "stdafx.h"
#include "SmGateway.h"
#include "TimerAdmin.h"

#define MAXLEN  148

	    
extern BOOL g_bMiscConnectionActive;
extern CTimerQueue g_rTimerQueue;
extern int g_nInterfaceType;
extern char g_sPrefixNumber[];
extern char g_sTestNumber[];

extern char g_sMaskWord[MAX_MASK_WORD_NUM][MAX_MASK_WORD_LEN];
extern int  g_nMaskNum;
extern char g_sSupportTel[];
extern char g_sHaveOpenService[];

extern UINT g_nMTCounts;
extern UINT g_nMOCounts;



void UnRegisterService(int);
void ProcessSmgEvent(TSmgPacket *prSmgPacket);
void SubmitPacketToSmsc(int nIndex, TSmgSubmitReq rSmgSubmitReq);
void SendMonitorMsg(int nMoniType, char *sMonMsg);
static void ProcessSmgSubmitReq(int nIndex, TSmgSubmitReq rSmgSubmitReq);
static void ProcessSmgDeliverRep(int nIndex, char *sBuf);
static void ProcessSmgRegisterReq(TSmgPacket *prSmgPacket);
static void ProcessMonitorClientRegister(TSmgPacket *prSmgPacket);
static void ProcessMonitorClientUnRegister(int);
static void ProcessSmgOpationRep(TSmgPacket *prSmgPacket);
static void ProcessSmgOpationUnRep(TSmgPacket *prSmgPacket);

static void ProcessMonitorAction(int nHandle, TMonitorMesg rMonitorMesg);

static void CheckServiceFlow(char *sServiceNumber, int nHandle);

extern void SendAlarmMsgToSupporter(char *sDstAddr, char* sServiceId, char *sContent, int nMsgLen);

void ProcessSmgEvent(TSmgPacket *prSmgPacket)
{
    int nIndex;
    int nCmdId;
    TMsgHead rMsgHead;
    TSmgSubmitReq rSmgSubmitReq;
	TSmgUnRegisterRep rSmgUnRegisterRep;
	TMonitorMesg rMonitorMesg;
	char *sBuf;

	if(prSmgPacket == NULL)
		return;
	sBuf = (char *)prSmgPacket;

    memset(&rMsgHead, 0x00, sizeof(TMsgHead));
    memcpy(&rMsgHead, prSmgPacket, sizeof(TMsgHead));

    nCmdId = rMsgHead.nCmdId;
    nIndex = rMsgHead.nChannelId;
	
	sBuf += sizeof(TMsgHead);

    switch(nCmdId)
    {
		//增加手机业务注册与注销
    case SMG_OpationRep:
			ProcessSmgOpationRep(prSmgPacket);	
	    break;
	
	case SMG_OpationUnRep:
			ProcessSmgOpationUnRep(prSmgPacket);
		break;

    case SMG_RegisterReq:
		if(strcmp(sBuf, "moni") == 0)
			ProcessMonitorClientRegister(prSmgPacket);
		else
			ProcessSmgRegisterReq(prSmgPacket);
		break;

	case SMG_UnRegisterReq:
		SmgTrace(0, (char *)"Received SMG_UnRegisterReq from %s, ServiceNumber=%s", rMsgHead.sLinkIp, sBuf);
		strcpy(rSmgUnRegisterRep.sServiceNumber, sBuf);
		rSmgUnRegisterRep.ucResult = 0;
		rMsgHead.nCmdId = SMG_UnRegisterRep;
		if(strcmp(sBuf, "moni") == 0)
			ProcessMonitorClientUnRegister(rMsgHead.nLinkId);
		else
			UnRegisterService(rMsgHead.nLinkId);
		SMG_SendUnRegisterRep(rMsgHead, rSmgUnRegisterRep);
		break;

    case SMG_SubmitReq:
		nIndex = 0;
		memset(&rSmgSubmitReq, 0x00, sizeof(TSmgSubmitReq));
		memcpy(&rSmgSubmitReq, sBuf, sizeof(TSmgSubmitReq));
		g_rSmgChan[nIndex].ucActionType = rSmgSubmitReq.ucActionType;
        g_rSmgChan[nIndex].nHandle = rMsgHead.nLinkId;
        strcpy(g_rSmgChan[nIndex].sSmscClientIp, rMsgHead.sLinkIp);
		ProcessSmgSubmitReq(nIndex, rSmgSubmitReq);
		break;

 	case SMG_DeliverRep:
        if(0 > nIndex || MAX_CHANNEL_NUM <= nIndex)
        {
			SmgTrace(0, (char *)"Error: received SMG_DeliverRep from %s, but ChannelId error", rMsgHead.sLinkIp);
			return;
        }
        g_rSmgChan[nIndex].nHandle = rMsgHead.nLinkId;
		strcpy(g_rSmgChan[nIndex].sSmscClientIp, rMsgHead.sLinkIp);
		ProcessSmgDeliverRep(nIndex, sBuf);
		break;

    case SMG_CancelReq:
		break;

	case SMG_LinkUp:
		SmgTrace(2, (char *)"The Client connected, IP=%s, Handle=%d, Port=%d",
			rMsgHead.sLinkIp, rMsgHead.nLinkId, rMsgHead.nPort);
		break;

	case SMG_LinkDown:
		SmgTrace(2, (char *)"The Client disconnected, IP=%s, Handle=%d, Port=%d",
			rMsgHead.sLinkIp, rMsgHead.nLinkId, rMsgHead.nPort);
		UnRegisterService(rMsgHead.nLinkId);	// 注销短信业务
		ProcessMonitorClientUnRegister(rMsgHead.nLinkId); // 注销监控业务
		break;

	case SMG_Monitor:
		memset(&rMonitorMesg, 0x00, sizeof(TMonitorMesg));
		memcpy(&rMonitorMesg, sBuf, sizeof(TMonitorMesg));
		ProcessMonitorAction(rMsgHead.nLinkId, rMonitorMesg);
		break;
    default:
		SmgTrace(0, (char *)"Error: received error message from client %s, CmdId=0x%04x", rMsgHead.sLinkIp, nCmdId);
		break;
    }
}

static void ProcessSmgOpationRep(TSmgPacket* prSmgPacket)
{
	char sMsg[256];

	if(prSmgPacket->rMsgBody.rSmgOpationRegisterRep.ucResult == 0)
		sprintf(sMsg, "您订阅%s服务成功！",  prSmgPacket->rMsgBody.rSmgOpationRegisterRep.sServiceNumber);
	else
		sprintf(sMsg, "您订阅%s服务失败！",  prSmgPacket->rMsgBody.rSmgOpationRegisterRep.sServiceNumber);

	SendAlarmMsgToSupporter(prSmgPacket->rMsgBody.rSmgOpationRegisterRep.sSrcAddr, 
		prSmgPacket->rMsgBody.rSmgOpationRegisterRep.sServiceNumber, sMsg, strlen(sMsg));
}

static void ProcessSmgOpationUnRep(TSmgPacket* prSmgPacket)
{
	char sMsg[256];

	if(prSmgPacket->rMsgBody.rSmgOpationUnRegisterRep.ucResult == 0)
		sprintf(sMsg, "您取消%s服务成功！",  prSmgPacket->rMsgBody.rSmgOpationUnRegisterRep.sServiceNumber);
	else
		sprintf(sMsg, "您取消%s服务失败！",  prSmgPacket->rMsgBody.rSmgOpationUnRegisterRep.sServiceNumber);

	SendAlarmMsgToSupporter(prSmgPacket->rMsgBody.rSmgOpationUnRegisterRep.sSrcAddr, 
		prSmgPacket->rMsgBody.rSmgOpationUnRegisterRep.sServiceNumber, sMsg, strlen(sMsg));
}

static void ProcessSmgRegisterReq(TSmgPacket *prSmgPacket)
{
    int i, j;
	TMsgHead rMsgHead;
    TSmgRegisterRep rRegisterRep;
    char sServiceNumber[32] = {0x00};
	char sMonitorMsg[128] = {0x00};

	if(prSmgPacket == NULL)
		return;

	memset(&rMsgHead, 0x00, sizeof(TMsgHead));
    memset(&rRegisterRep, 0x00, sizeof(TSmgRegisterRep));

	memcpy(&rMsgHead, &(prSmgPacket->rMsgHead), sizeof(TMsgHead));
    sprintf(sServiceNumber, "%s%s", g_sPrefixNumber, prSmgPacket->rMsgBody.rSmgRegisterReq.sServiceNumber);

    SmgTrace(0,(char *)"Received SMG_RegisterReq from SMG client,IP=%s,Handle=%d",
		prSmgPacket->rMsgHead.sLinkIp,prSmgPacket->rMsgHead.nLinkId);
    SmgTrace(0,(char *)"    ServiceNumber = %s", sServiceNumber);


    rMsgHead.nCmdId = SMG_RegisterRep;
	
    for(i=0; i<MAX_SERVICE_NUM; i++)
    {
		if(g_rMoClientTab[i].bRegister == TRUE)
		{
			if(strstr(sServiceNumber, g_rMoClientTab[i].sServiceNumber) 
				|| strstr(g_rMoClientTab[i].sServiceNumber, sServiceNumber))
			{
				if(g_rMoClientTab[i].nClientCount < MAX_CLIENT_FOR_SERVICE)
				{
					for(j=0; j<MAX_CLIENT_FOR_SERVICE; j++)    
					{
						if(g_rMoClientTab[i].rClientInfo[j].nHandle == -1)
						{
							g_rMoClientTab[i].rClientInfo[j].nHandle = rMsgHead.nLinkId;
							strcpy(g_rMoClientTab[i].rClientInfo[j].sIp, prSmgPacket->rMsgHead.sLinkIp);
							g_rMoClientTab[i].nClientCount++;
							rRegisterRep.ucResult = 0;
							SmgTrace(0,(char *)"Send SMG_RegisterRep to client,IP=%s,Result=%d",
								prSmgPacket->rMsgHead.sLinkIp,rRegisterRep.ucResult);
							SMG_SendRegisterRep(rMsgHead, rRegisterRep);
							sprintf(sMonitorMsg, "%s;%s;", sServiceNumber, prSmgPacket->rMsgHead.sLinkIp);
							SendMonitorMsg(MONI_SERVICE_LOGON, sMonitorMsg);
							return;
						}
					}
				}
				else
				{
					rRegisterRep.ucResult = 1;
					SmgTrace(0,(char *)"Send SMG_RegisterRep to client,IP=%s,Result=%d",
						prSmgPacket->rMsgHead.sLinkIp,rRegisterRep.ucResult);
					SMG_SendRegisterRep(rMsgHead, rRegisterRep);
					return;
				}
			}
		}
	}

    for(i=0; i<MAX_SERVICE_NUM; i++)
    {
		if(g_rMoClientTab[i].bRegister != TRUE)
		{
			g_rMoClientTab[i].bRegister = TRUE;
			g_rMoClientTab[i].rClientInfo[0].nHandle = rMsgHead.nLinkId;
			strcpy(g_rMoClientTab[i].rClientInfo[0].sIp, prSmgPacket->rMsgHead.sLinkIp);
			g_rMoClientTab[i].nClientCount = 1;
			strcpy(g_rMoClientTab[i].sServiceNumber, sServiceNumber);
    	    rRegisterRep.ucResult = 0;
			SmgTrace(0,(char *)"Send SMG_RegisterRep to client,IP=%s,Result=%d",
				prSmgPacket->rMsgHead.sLinkIp,rRegisterRep.ucResult);
			SMG_SendRegisterRep(rMsgHead, rRegisterRep);
			sprintf(sMonitorMsg, "%s;%s;", sServiceNumber, prSmgPacket->rMsgHead.sLinkIp);
			SendMonitorMsg(MONI_SERVICE_LOGON, sMonitorMsg);
			return;
		}
    }
    rRegisterRep.ucResult = 2;
	SmgTrace(0,(char *)"Send SMG_RegisterRep to client,IP=%s,Result=%d",
		prSmgPacket->rMsgHead.sLinkIp,rRegisterRep.ucResult);
	SMG_SendRegisterRep(rMsgHead, rRegisterRep);
    return;
}

static void ProcessSmgSubmitReq(int nIndex, TSmgSubmitReq rSmgSubmitReq)
{
	TSmgPacket rSmgPacket;
	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));

    if(0 > nIndex || MAX_CHANNEL_NUM <= nIndex)
		return;

	rSmgPacket.rMsgHead.nChannelId = nIndex;
	rSmgPacket.rMsgHead.nCmdId = SMG_SubmitReq;
	strcpy(rSmgPacket.rMsgHead.sLinkIp, g_rSmgChan[nIndex].sSmscClientIp);
	rSmgPacket.rMsgHead.nLinkId = g_rSmgChan[nIndex].nHandle;
	memcpy(&(rSmgPacket.rMsgBody.rSmgSubmitReq),&rSmgSubmitReq, sizeof(TSmgSubmitReq));
	g_rSmgChan[nIndex].rSubmitReqQueue.WriteDataToQueue(&rSmgPacket);
	SmgTrace(0, (char *)"ID-%03d: Put the SubmitReq to data queue", nIndex);
}

extern TServiceFeeTable g_rServiceFeeTable[];
void SubmitPacketToSmsc(int nIndex, TSmgSubmitReq rSmgSubmitReq)
{
    int nRet;
	TMsgHead rMsgHead;
    TSmgSubmitRep rSmgSubmitRep;
	u_char ucMsgFmt;
	int i;
	int nProvince=0;
	char sFeeCode[MAX_FEECODE_LEN] = "00"; //默认1角钱收费
	char sFeeType[MAX_FEETYPE_LEN] = "02"; //默认按条收费
	char sServiceId[MAX_SERVICEID_LEN] = "03_JXT";
	int  nServd=0; // for 10109，0 success serverd， 1 fail serverd
	char *p, *q, *c;
	char sMsg[1024] = {0x00};
	char sDisplayFeeType[MAX_FEETYPE_LEN] = {0x00};
	unsigned int nSeqId = 0;

	SmgTrace(0, (char *)"ID-%03d: Received SMG_SubmitReq from %s", 
		nIndex, g_rSmgChan[nIndex].sSmscClientIp);
    SmgTrace(0, (char *)"    SrcAddr=%s,DstAddr=%s,FeeAddr=%s", 
		rSmgSubmitReq.sSrcAddr,
		rSmgSubmitReq.sDstAddr,
		rSmgSubmitReq.sFeeAddr);
    SmgTrace(0, (char *)"    ServiceId=%s,MsgFmt=%d,MsgLen=%d,ActionType=%d", 
		rSmgSubmitReq.sServiceId,
		rSmgSubmitReq.ucMsgFmt,
		rSmgSubmitReq.ucMsgLen,
		rSmgSubmitReq.ucActionType);
    SmgTrace(0, (char *)"    MsgCounts=%d,MsgNumber=%d,FeeUserType=%d,ClientSeqId=%d",
		rSmgSubmitReq.nMsgCounts,
		rSmgSubmitReq.nMsgNumber,
		rSmgSubmitReq.ucFeeUserType,
		rSmgSubmitReq.nClientSeqId);

    g_rSmgChan[nIndex].ucActionType = rSmgSubmitReq.ucActionType;
    g_rSmgChan[nIndex].nClientSeqId = rSmgSubmitReq.nClientSeqId;

    ucMsgFmt = rSmgSubmitReq.ucMsgFmt;
	g_rSmgChan[nIndex].nMsgCounts = rSmgSubmitReq.nMsgCounts;
	g_rSmgChan[nIndex].nMsgNumber = rSmgSubmitReq.nMsgNumber;

	CheckServiceFlow(rSmgSubmitReq.sSrcAddr, g_rSmgChan[nIndex].nHandle); // 检查是否有业务流量

	//SmgTrace(0, (char *)"rSmgSubmitReq.sServiceId=%s",rSmgSubmitReq.sServiceId);


	for(i=0; i<MAX_SERVICE_ID; i++)
	{
		//SmgTrace(0, (char *)"g_rServiceFeeTable[i].sServiceId=%s",g_rServiceFeeTable[i].sServiceId);

		if(rSmgSubmitReq.sServiceId[0] != '\0' && strcmp(rSmgSubmitReq.sServiceId, g_rServiceFeeTable[i].sServiceId) == 0)
		{
			nProvince = 0;
			if(nProvince<0 || nProvince > MAX_PROVINCE_NUM)
				return;
	
            //SmgTrace(0, (char *)"g_rServiceFeeTable[i].sServiceId=%s",g_rServiceFeeTable[i].sServiceId);

			strcpy(sServiceId, g_rServiceFeeTable[i].sServiceType);
			sprintf(g_rSmgChan[nIndex].sMTCDR, "sServiceId=%s", sServiceId);
			strcpy(sFeeType, g_rServiceFeeTable[i].rProviceFeeInfo[nProvince].rFeeInfo.sFeeType);
			strcpy(sFeeCode, g_rServiceFeeTable[i].rProviceFeeInfo[nProvince].rFeeInfo.sFeeCode);
			break;
		}
	}

	//SmgTrace(0, (char *)"sServiceId=%s",sServiceId);

	for(i=0; i<g_nMaskNum; i++)   // 非法信息屏蔽
	{
		if(strstr(rSmgSubmitReq.sMsgContext, g_sMaskWord[i]) != NULL)
		{
			SmgTrace(0, (char *)"Error: message content not invalid!");
			memset(&rMsgHead, 0x00, sizeof(TMsgHead));
			memset(&rSmgSubmitRep, 0x00, sizeof(TSmgSubmitRep));
    	
			rMsgHead.nCmdId = SMG_SubmitRep;
			rMsgHead.nChannelId = nIndex;
			rMsgHead.nLinkId = g_rSmgChan[nIndex].nHandle;
			rSmgSubmitRep.ucResult = 10;
			rSmgSubmitRep.ucActionType = g_rSmgChan[nIndex].ucActionType;
			nRet = SMG_SendSubmitRep(rMsgHead, rSmgSubmitRep);
			if(0 < nRet)
				SmgTrace(0, (char *)"Error: failed to send SMG_SubmitRep to client: <%d>.", nRet);