smgateway.cpp

中国移动的短信网关程序

#include "stdafx.h"
#include "SmGateway.h"
#include "TimerAdmin.h"
#include "windows.h"
#include "Winbase.h"
#define VERSION "1.0.0"

TSmscChannel g_rSmgChan[MAX_CHANNEL_NUM];
TMoClientTable g_rMoClientTab[MAX_SERVICE_NUM];
TMonitorClient g_rMonitorClient[MAX_MONITOR_CLIENT];

static char g_sIniFile[128] = {0x00};
static int g_nSmgPort=8000;
static char g_sSmsServerIP[18] = {0x00};
static time_t g_nSupportTime=1800;
static time_t g_tActiveTestBeginTime=0;
static int g_nSmsPort = 0;
static int g_nServiceType = 2;
static int g_nMoPort=9100;

unsigned char g_nSmgNodeId=1;

char g_sProcName[32] = {0x00};
char g_sSpId[32] = {0x00};
char g_sLoginName[32] = {0x00};
char g_sSpPwd[32] = {0x00};
char g_sSpNumber[32] = {0x00};  // customer service number
int g_nInterfaceType=1;
char g_sPrefixNumber[32] = {0x00};
char g_sTestNumber[32] = {0x00};
char g_sSupportTel[24] = {0x00};
char g_sFeeInfoFile[128] = {0x00};
char g_sChatNumber[24] = {0x00};  // 聊天业务特服号
int g_nInerChatUserBeginId = 500;    // 聊天业务内部用户起始ID
int g_nInerChatUserEndId = 12000;    // 聊天业务内部用户结束ID

char g_sMaskWord[MAX_MASK_WORD_NUM][MAX_MASK_WORD_LEN];
int  g_nMaskNum=0;

char g_sDefaultMsg[2][256];
UINT g_nMTCounts=0;
UINT g_nMOCounts=0;

char g_sHaveOpenService[1024] = {0x00};
int  g_nHaveOpenServiceNum=0;
char g_rHaveOpenService[MAX_SERVICE_NUM][16];

CTimerQueue g_rTimerQueue;

/*
 * this structure used to record a UNICODE table, the numbber of elements 
 * of the table is s_rUnicodeNum
 */
unsigned short g_rUnicodeTab[MAX_UNICODE_NUM] = {0x00}; 
unsigned short g_uUnicodeNum = 0;

static char g_sLogFile[128] = {0x00};
static int g_nLogFd;
static int g_nLogLine = 0;

static int g_nQueryLinkTime = 20;
static int g_nCurrTime;
static int g_nTryReconnectTimes=0;

static time_t g_lConfigFileTime=0;

static void SmgInitMoClientTable();
static int SmgInitUnicodeTable();
static int SmgReadIniFile(char *);
static int SmgLoginToSmsc();
static int SmgInitSmscClient(char *sSmscServerIp, int nPort);
static int SmgInitEnvironment(char *);
static int SmgInitProgram();
static int SmgRunProgram();
static void SmgCheckTimeoutEvent(int);
static void ProcessTimeoutEvent(TSmscChannel *prSmscChannel);
static void SmgReadMaskWord(char *);
static void ReloadConfigInfo();

extern void ProcessSmgEvent(TSmgPacket *prSmgPacket);
extern void SubmitPacketToMisc(int nIndex, TSmgSubmitReq rSmgSubmitReq);
extern void SendMonitorMsg(int nMoniType, char *sMonMsg);

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

extern BOOL g_bSmscConnectionActive;

int thread_main()
{
    int nRet = 0;
	
	g_tActiveTestBeginTime = time(NULL);

    nRet = SmgInitProgram();

    if(0 != nRet)
        CloseProgram(0);
    else
        SmgRunProgram();

    CloseProgram(1);

    return 0;
}

static int SmgInitEnvironment(char *sProgName)
{
    char sLogFile[128] = {0x00};
    time_t tTime;
    int i;
    
    sprintf(sLogFile, (char *)"Log\\%s.txt",sProgName);
	mkdir("Log");
    // open the log file
    if((g_nLogFd = OpenLogFile(sLogFile))==-1)
    {
        return -1000;
    }

    time(&tTime);
    SmgTrace(2, (char *)"%s start at %s", sProgName, ctime(&tTime));
    SmgTrace(2, (char *)"%s's Version: %s", sProgName, VERSION);

    SmgInitMoClientTable();

    for(i=0; i<MAX_CHANNEL_NUM; i++)
    {
		SmgInitSmscChannel(i);
    }

	// 初始化监控客户端记录
	for(i=0; i<MAX_MONITOR_CLIENT; i++)
	{
		g_rMonitorClient[i].bUse = FALSE;
		g_rMonitorClient[i].nHandle = -1;
		g_rMonitorClient[i].bSetMonitor = FALSE;
		strcpy(g_rMonitorClient[i].sIp, "");
	}

    return 0;
}

extern int ReadServiceFeeInfoToMem(char *sFeeInfoFile);
static int SmgInitProgram()
{
    int nRet=0;

    strcpy(g_sProcName, "SmGateWay");

	strcpy(g_sIniFile, "SmGateWay.ini");

    SmgInitEnvironment(g_sProcName);

    nRet = SmgInitUnicodeTable();
    if(0 > nRet)
		return nRet;

    nRet = SmgReadIniFile(g_sIniFile);
    if(0 > nRet)
		return nRet;

	sprintf(g_sFeeInfoFile, "%s",CMPP_FEE_INFO_FILE);

    nRet = ReadServiceFeeInfoToMem(g_sFeeInfoFile);
    if(0 > nRet)
	{
		SmgTrace(2, (char *)"Error: fail to read %s", g_sFeeInfoFile);
		return nRet;
	}

    nRet = SmgInitSmscClient(g_sSmsServerIP, g_nSmsPort);
    if(0 > nRet)
		return nRet;

    nRet = SMG_InitServer(g_nSmgPort);
    if(0 > nRet)
		return nRet;

	return 0;
}

static int SmgReadIniFile(char *sIniFile)
{
	int i;
	struct stat rStat;
	char *p, *q;	
	char sSubServiceNumber[8] = {0x00};
	
	for(i=0; i<2; i++)
		memset(g_sDefaultMsg[i], 0x00, 256);

	SmgTrace(0, (char *)"Begin to read config file information!");

    g_nSmgPort=GetPrivateProfileInt((LPCTSTR)"MAIN",(LPCTSTR)"ServerPort", 8000,(LPCTSTR)sIniFile);
	g_nInterfaceType=GetPrivateProfileInt((LPCTSTR)"MAIN",(LPCTSTR)"InterfaceType", 0,(LPCTSTR)sIniFile); 
	g_nServiceType=GetPrivateProfileInt((LPCTSTR)"MAIN",(LPCTSTR)"ServiceType", 1,(LPCTSTR)sIniFile); 
	g_nSmgNodeId=GetPrivateProfileInt((LPCTSTR)"MAIN",(LPCTSTR)"SmgNodeId", 1,(LPCTSTR)sIniFile);
	g_nMoPort=GetPrivateProfileInt((LPCTSTR)"HOST",(LPCTSTR)"MoPort", 9100,(LPCTSTR)sIniFile); 

	GetPrivateProfileString((LPCTSTR)"CTRL",(LPCTSTR)"PrefixNumber",NULL,(LPTSTR )g_sPrefixNumber,32,(LPCTSTR)sIniFile);
	GetPrivateProfileString((LPCTSTR)"CTRL",(LPCTSTR)"TestNumber",NULL,(LPTSTR )g_sTestNumber,32,(LPCTSTR)sIniFile);
	GetPrivateProfileString((LPCTSTR)"CTRL",(LPCTSTR)"ChatNumber",NULL,(LPTSTR )g_sChatNumber,24,(LPCTSTR)sIniFile);

   	g_nInerChatUserBeginId=GetPrivateProfileInt((LPCTSTR)"CTRL",(LPCTSTR)"InerChatUserBeginId", 500,(LPCTSTR)sIniFile); 
   	g_nInerChatUserEndId=GetPrivateProfileInt((LPCTSTR)"CTRL",(LPCTSTR)"InerChatUserEndId", 12000,(LPCTSTR)sIniFile); 

	GetPrivateProfileString((LPCTSTR)"MAINTENANCE",(LPCTSTR)"Telephone",NULL,(LPTSTR)g_sSupportTel,24,(LPCTSTR)sIniFile);
	g_nSupportTime = GetPrivateProfileInt((LPCTSTR)"MAINTENANCE",(LPCTSTR)"ActiveTestTime", 1800,(LPCTSTR)sIniFile);

	GetPrivateProfileString((LPCTSTR)"DEFAULTMSG",(LPCTSTR)"DefaultMsg1",NULL,(LPTSTR )g_sChatNumber,256,(LPCTSTR)sIniFile);
	GetPrivateProfileString((LPCTSTR)"DEFAULTMSG",(LPCTSTR)"DefaultMsg2",NULL,(LPTSTR )g_sChatNumber,256,(LPCTSTR)sIniFile);

	GetPrivateProfileString((LPCTSTR)"SERVICE",(LPCTSTR)"HaveOpenService",NULL,(LPTSTR )g_sHaveOpenService,1024,(LPCTSTR)sIniFile);

	p = q = g_sHaveOpenService;
	while((p = strchr(q, ';')) != NULL)
	{
		strncpy(sSubServiceNumber, q, p-q);
		sprintf(g_rHaveOpenService[g_nHaveOpenServiceNum], "%s%s", g_sPrefixNumber, sSubServiceNumber);
		g_nHaveOpenServiceNum++;
		q = p+1;
	}

    if (GetPrivateProfileString((LPCTSTR)"HOST",(LPCTSTR)"HostAddr",NULL,(LPTSTR )g_sSmsServerIP,18,(LPCTSTR)sIniFile) == 0)
    {
		SmgTrace(2, (char *)"Error: failed to read HostAddr, maybe %s not exist", sIniFile);
		return -1003;
    }

    if((g_nSmsPort=GetPrivateProfileInt((LPCTSTR)"HOST",(LPCTSTR)"HostPort", 8801,(LPCTSTR)sIniFile))==0 )
    {
		SmgTrace(2, (char *)"Error: failed to read HostPort, maybe %s not exist", sIniFile);
		return -1004;
    }

    if (GetPrivateProfileString((LPCTSTR)"SP",(LPCTSTR)"Sp_Id",NULL,(LPTSTR )g_sSpId,32,(LPCTSTR)sIniFile) == 0)
    {
		SmgTrace(2, (char *)"Error: failed to read Sp_id, maybe %s not exist", sIniFile);
		return -1005;
    }

    if (GetPrivateProfileString((LPCTSTR)"SP",(LPCTSTR)"Sp_Pwd",NULL,(LPTSTR )g_sSpPwd,32,(LPCTSTR)sIniFile) == 0)
    {
		SmgTrace(2, (char *)"Error: failed to read Sp_Pwd, maybe %s not exist", sIniFile);
		return -1006;
    }
    if (GetPrivateProfileString((LPCTSTR)"SP",(LPCTSTR)"Sp_Num",NULL,(LPTSTR )g_sSpNumber,32,(LPCTSTR)sIniFile)	== 0)
    {
		SmgTrace(2, (char *)"Error: failed to read Sp_Num, maybe %s not exist", sIniFile);
		return -1007;
    }

    if (GetPrivateProfileString((LPCTSTR)"SP",(LPCTSTR)"Sp_Name",NULL,(LPTSTR )g_sLoginName,32,(LPCTSTR)sIniFile) == 0)
    {
		SmgTrace(2, (char *)"Error: failed to read Sp_Num, maybe %s not exist", sIniFile);
		return -1007;
    }

	SmgReadMaskWord(sIniFile);

	if(stat(sIniFile,&rStat)==0)
	{
		g_lConfigFileTime=rStat.st_mtime;
	}

	SmgTrace(0, (char *)"End to read config file information!");
    return 0;
}

static void SmgReadMaskWord(char *sIniFile)
{
	int i;
	char sTemp[MAX_MASK_WORD_LEN*MAX_MASK_WORD_NUM] = {0x00};
	char *p, *q;
	int nLen=0;

	g_nMaskNum = 0;

	if(sIniFile == NULL)
		return;
	for(i=0; i<MAX_MASK_WORD_NUM; i++)
		memset(g_sMaskWord[i], 0x00, MAX_MASK_WORD_LEN);

	GetPrivateProfileString((LPCTSTR)"MASKWORD",(LPCTSTR)"MaskWord",NULL,(LPTSTR )sTemp,MAX_MASK_WORD_LEN*MAX_MASK_WORD_NUM,(LPCTSTR)sIniFile);

	p = q = sTemp;
	while((p=strchr(q, ';')) != NULL)
	{
		nLen = p-q;
		strncpy(g_sMaskWord[g_nMaskNum++], q, nLen>MAX_MASK_WORD_LEN ? MAX_MASK_WORD_LEN-1 : nLen);
		q = p+1;
	}
}

static int SmgLoginToSmsc()
{
    int nRet;

	g_nTryReconnectTimes = 0;
   
    SmgTrace(2, (char *)"Begin login to MISC......");
	nRet = CMPP_Connect(g_sSpId, g_sSpPwd);
    SmgTrace(2, (char *)"Send login message to MISC");
   return nRet;
}

extern void ReloadServiceFeeInfo();
extern void SubmitPacketToSmsc(int nIndex, TSmgSubmitReq rSmgSubmitReq);
static int SmgRunProgram()
{
	int nIndex=0;
    TSmscChannel *prSmscChannel;
  	int nSmgCmdId;
	TSmgPacket rSmgPacket;
	time_t tCurTime = 0;
	char sContent[256] = {0x00};

    while(1)
    {

		tCurTime = time(NULL);

		CMPP_GetClientEvent();
		
		if((nSmgCmdId = SMG_GetServerEvent(&rSmgPacket)) > 0)
		    ProcessSmgEvent(&rSmgPacket);

		
		if((prSmscChannel = g_rTimerQueue.CheckTimeoutTimerNode()) != NULL)
			ProcessTimeoutEvent(prSmscChannel);
		
		ReloadServiceFeeInfo();

		ReloadConfigInfo();
		
		if(g_bSmscConnectionActive == TRUE)
		{
			nIndex = 0;
			if(g_rSmgChan[nIndex].ucStat == IDLE)
			{
				if(g_rSmgChan[nIndex].rSubmitReqQueue.ReadDataFromQueue(&rSmgPacket) == 0)
				{
					g_rSmgChan[nIndex].ucStat = OCCUPY;
					SmgTrace(0, (char *)"ID-%03d: Read SubmitReq from data queue and send to MISC", nIndex);
					g_rSmgChan[nIndex].nHandle = rSmgPacket.rMsgHead.nLinkId;
					strcpy(g_rSmgChan[nIndex].sSmscClientIp, rSmgPacket.rMsgHead.sLinkIp);
					SubmitPacketToSmsc(nIndex, rSmgPacket.rMsgBody.rSmgSubmitReq);
				}
			}
		}
		Sleep(1);
	}
}

static void ProcessTimeoutEvent(TSmscChannel *prSmscChannel)
{
    int nRet;
    int i;
	TMsgHead rMsgHead;
    TSmgSubmitRep rSubmitRep;
	char sTmp[1024] = {0x00};
    if(prSmscChannel == NULL)
	return;

    i = prSmscChannel->nIndex;
	
    switch(prSmscChannel->ucChildStat)
    {
    case WAIT_DELIVER_REP:
        SmgTrace(0,(char *)"ID-%03d: Occured a WAIT_DELIVER_REP timeout event",i);
		SmgInitSmscChannel(i);
		break;
    case WAIT_SUBMIT_REP:
		SmgTrace(0, (char *)"ID-%03d: Occured a WAIT_SUBMIT_REP timeout event", i);
		memset(&rSubmitRep, 0x00, sizeof(TSmgSubmitRep));
    	rMsgHead.nCmdId = SMG_SubmitRep;
    	rMsgHead.nChannelId = i;
		rMsgHead.nLinkId = prSmscChannel->nHandle;
    	rSubmitRep.ucResult = 9;
		rSubmitRep.ucActionType = prSmscChannel->ucActionType;
		sprintf(sTmp, "%s%s%d", prSmscChannel->sMTCDR, SPACE_MARK, rSubmitRep.ucResult);
		WriteSmsCDR(sTmp);
//		SendMonitorMsg(MONI_CDR_INFO, sTmp);

		nRet = SMG_SendSubmitRep(rMsgHead, rSubmitRep);
    	if(0 < nRet)
			SmgTrace(0, (char *)"Error: failed to send Smsc_SubmitRep to client: <%d>.", nRet);
	
		SmgInitSmscChannel(i);
		break;
    case WAIT_SUBMIT_REQ:
		SmgTrace(0, (char *)"ID-%03d: Occured a WAIT_SUBMIT_REQ timeout event", i);
		SmgInitSmscChannel(i);
		break;
    case WAIT_NEXT_SUBMIT_REQ:
        SmgTrace(0, (char *)"ID-%03d: Occured a WAIT_NEXT_SUBMIT_REQ timeout event", i);
		SmgInitSmscChannel(i);
		break;
    default:
		SmgInitSmscChannel(i);
		break;
    }
    return;
}


void CloseProgram(int nSignal)
{
    time_t tTime;

    time(&tTime);
    if(nSignal != 0)
    {
		CMPP_CloseClient();
        SMG_CloseServer();
    }

    SmgTrace(2, (char *)"Program exit at %s", ctime(&tTime)); 
	CloseLogFile(g_nLogFd);
    exit(0);
}

static void SmgInitMoClientTable()
{
    int i;
    int j;
    for(i=0; i<MAX_SERVICE_NUM; i++)
    {
		strcpy(g_rHaveOpenService[i], "");
		g_rMoClientTab[i].bRegister = FALSE;
		g_rMoClientTab[i].nMOCounts = 0;
		g_rMoClientTab[i].nMTCounts = 0;