smgateway.cpp

中国移动的短信网关程序

		memset(g_rMoClientTab[i].sServiceNumber, 0x00, 32);
		for(j=0; j<MAX_CLIENT_FOR_SERVICE; j++)
		{
			g_rMoClientTab[i].rClientInfo[j].nHandle = -1;
			g_rMoClientTab[i].rClientInfo[j].nNoProcess = 0;
			g_rMoClientTab[i].rClientInfo[j].bHaveSendAlarm = FALSE;
			memset(g_rMoClientTab[i].rClientInfo[j].sIp, 0x00, 18);
		}
    }
}

void SendAlarmMsgToSupporter(char *sDstAddr, char *sServiceId, char *sContent, int nMsgLen)
{
	int nIndex=0;
	TSmgPacket rPacket;
	char sSrcAddr[24] = {0x00};

	memset(&rPacket, 0x00, sizeof(TSmgPacket));

	rPacket.rMsgHead.nCmdId = SMG_SubmitReq;
	rPacket.rMsgHead.nChannelId = nIndex;
	rPacket.rMsgBody.rSmgSubmitReq.ucActionType = MT_ACTION;
	rPacket.rMsgBody.rSmgSubmitReq.nMsgCounts = 1;
	rPacket.rMsgBody.rSmgSubmitReq.nMsgNumber = 1;
	rPacket.rMsgBody.rSmgSubmitReq.nClientSeqId = 1;
	strcpy(rPacket.rMsgBody.rSmgSubmitReq.sDstAddr, sDstAddr);
	sprintf(sSrcAddr, "%s", g_sPrefixNumber);
	strcpy(rPacket.rMsgBody.rSmgSubmitReq.sSrcAddr, sSrcAddr);
	rPacket.rMsgBody.rSmgSubmitReq.ucMsgFmt = 15;
	rPacket.rMsgBody.rSmgSubmitReq.ucFeeUserType = 0;
	strcpy(rPacket.rMsgBody.rSmgSubmitReq.sMsgContext, sContent);
	rPacket.rMsgBody.rSmgSubmitReq.ucMsgLen = nMsgLen;
	
	strcpy(rPacket.rMsgBody.rSmgSubmitReq.sServiceId, sServiceId);
	rPacket.rMsgHead.nLinkId = 1024;
	g_rSmgChan[nIndex].rSubmitReqQueue.WriteDataToQueue(&rPacket);
}

void SmgInitSmscChannel(int nIndex)
{
    g_rSmgChan[nIndex].ucStat = IDLE;
    g_rSmgChan[nIndex].ucChildStat = WAIT_NULL;
	g_rSmgChan[nIndex].nIndex = nIndex;
    g_rSmgChan[nIndex].nMsgCounts = 0;
    g_rSmgChan[nIndex].nMsgNumber = 0;
    g_rSmgChan[nIndex].nTimeval = 0;

	memset(g_rSmgChan[nIndex].sLinkId, 0x00, 20);
	memset(g_rSmgChan[nIndex].sMsgId, 0x00, 16);
	
	g_rTimerQueue.RemoveTimerQueue(&g_rSmgChan[nIndex]);
}


/*
 * nMode = 0, display the message to screen
 * nMode = 1, write the message to log file
 * nMode = 2, display the message to screen and write the message to log file
 */
void SmgTrace(int nMode, char *szFormat, ...)
{
    va_list pArguments;
    char szBuffer[1024] = {0x00};


    va_start(pArguments, szFormat);
    vsprintf(szBuffer, szFormat, pArguments);
    va_end(pArguments);
    if(0 == nMode)
    {
        WriteLog(g_nLogFd, szBuffer);
    }
    else if(1 == nMode)
        printf("%s\n", szBuffer);
    else if(2 == nMode) 
    {
        WriteLog(g_nLogFd, szBuffer);
        printf("%s\n", szBuffer);
    }
}


int FindIdleSmscChannel()
{
    int i;
    for(i=0; i<MAX_CHANNEL_NUM; i++)
    {
	if(IDLE == g_rSmgChan[i].ucStat)
	{
	    g_rSmgChan[i].ucStat = OCCUPY;
	    return i;
	}
    }
    return -1;
}

int FindSmscChannelBySeqId(int nSeqId)
{
    int i;
    for(i=0; i<MAX_CHANNEL_NUM; i++)
    {
	if(nSeqId == g_rSmgChan[i].nSeqId)
	    return i;
    }
    return -1;
}

int  FindClientByServiceNumber(char *sServiceNumber, char *sClientIp, char *sDstAddr)
{
	int i, j;
	int nHandle = -1;
	char sMsgContent[256] = {0x00};
	char sAlarmMsg[256] = {0x00};
	char sSubServiceNumber[8] = {0x00}; // 去掉接入号码前缀的业务号码

	if(sServiceNumber == NULL || sClientIp == NULL || sDstAddr == NULL)
		return -1;

	for(i=0; i<MAX_SERVICE_NUM; i++)
	{
		if(g_rMoClientTab[i].bRegister == TRUE)
		{
			if(strstr(sServiceNumber, g_rMoClientTab[i].sServiceNumber))
			{
				++g_rMoClientTab[i].nMOCounts;
				for(j=0; j<MAX_CLIENT_FOR_SERVICE; j++)
				{
					if((nHandle = g_rMoClientTab[i].rClientInfo[g_rMoClientTab[i].nLable].nHandle) > 0)
					{
						if(g_rMoClientTab[i].rClientInfo[g_rMoClientTab[i].nLable].nNoProcess >= 3)
						{
							sprintf(sAlarmMsg, "%s:%s", 
								g_rMoClientTab[i].rClientInfo[g_rMoClientTab[i].nLable].sIp,
								g_rMoClientTab[i].sServiceNumber);
							g_rMoClientTab[i].rClientInfo[g_rMoClientTab[i].nLable].bHaveSendAlarm = TRUE;
							SendMonitorMsg(MONI_SERVICE_FLOW_SET, sAlarmMsg);
						}
						else
						{
							if(g_rMoClientTab[i].rClientInfo[g_rMoClientTab[i].nLable].bHaveSendAlarm == TRUE)
							{
								sprintf(sAlarmMsg, "%s:%s", 
									g_rMoClientTab[i].rClientInfo[g_rMoClientTab[i].nLable].sIp,
									g_rMoClientTab[i].sServiceNumber);
								g_rMoClientTab[i].rClientInfo[g_rMoClientTab[i].nLable].bHaveSendAlarm = FALSE;
								SendMonitorMsg(MONI_SERVICE_FLOW_CANCEL, sAlarmMsg);
							}
						}
						g_rMoClientTab[i].rClientInfo[g_rMoClientTab[i].nLable].nNoProcess++;

						strcpy(sClientIp, g_rMoClientTab[i].rClientInfo[g_rMoClientTab[i].nLable].sIp);
						g_rMoClientTab[i].nLable++;
						if(g_rMoClientTab[i].nLable >= MAX_CLIENT_FOR_SERVICE)
							g_rMoClientTab[i].nLable = 0;
						return nHandle;
					}
					g_rMoClientTab[i].nLable++;
					if(g_rMoClientTab[i].nLable >= MAX_CLIENT_FOR_SERVICE)
						g_rMoClientTab[i].nLable = 0;
				}
			}
		}
    }/*	for(i=0; i<MAX_SERVICE_NUM; i++)*/

	
/*	if(strcmp(sServiceNumber, g_sPrefixNumber) == 0)
	{
		SendAlarmMsgToSupporter(sDstAddr, "-HTERR", g_sDefaultMsg[0], strlen(g_sDefaultMsg[0]));
		SendAlarmMsgToSupporter(sDstAddr, "-HTERR", g_sDefaultMsg[1], strlen(g_sDefaultMsg[1]));
		return -1;
	}*/

	// 判断是否已经开通的业务
	for(i=0; i<g_nHaveOpenServiceNum; i++)
	{
		if(strstr(sServiceNumber, g_rHaveOpenService[i]) != NULL)
		{
			sprintf(sMsgContent, 
				"用户您好,您所拨业务%s正在维护或升级中,请您稍后再拨,给您造成不便敬请原谅,谢谢您的支持!",
				sServiceNumber);
			SendAlarmMsgToSupporter(sDstAddr, "-HTERR", sMsgContent, strlen(sMsgContent));
			SendMonitorMsg(MONI_SERVICE_NO_FIND, sServiceNumber);
			return -2;
		}
	}

    return -3;
}

static int SmgInitSmscClient(char *sSmscServerIp, int nPort)
{
	int nRet=0;

	if(sSmscServerIp == NULL)
		return -1000;

	nRet = CMPP_InitClient(sSmscServerIp, nPort);
	if(nRet < 0)
		return -1001;
 
	if((nRet = SmgLoginToSmsc()) <0)
		return -1002;
	
    return nRet;
}

/*--------------------------------------------------------------*
 * Name: initUnicodeTable                                       *
 * Inpt: read file UNICODE_DICT, read UNICODE table to memery   *
 * Retn: success return 0 , else return -1002;                  *
 *--------------------------------------------------------------*/
#define UNICODE_DICT    "unicode.txt"
static int SmgInitUnicodeTable()
{
    FILE *fp;
    char sUniCode[32];
	char sUniCodeFile[256] = {0x00};

	sprintf(sUniCodeFile, UNICODE_DICT);
 
    if ( (fp = fopen( sUniCodeFile, "r")) == NULL)
    {
		SmgTrace(2, (char *)"Error: SmgInitUnicodeTable() failed: no unicode.txt file");
        return -1002;
    }

    g_uUnicodeNum = 0 ;
    while( fscanf(fp, "%s", sUniCode) == 1 )
    {
         g_rUnicodeTab[g_uUnicodeNum] = (unsigned short)atoi(sUniCode);
         g_uUnicodeNum ++;
    }
    fclose(fp);
    return 0;
}

/*--------------------------------------------------------------*
 * Name: ConvertToUnicodeAscStr                                 *
 * Desc: input a mem-string <sRcvStr>, length in <nRcvLen>      *
 *       covert it to Unicode asc string, and put them to       *
 *       sResultStr, length equal nResultLen                    *
 * Retn: success return 0 , else return -1;                     *
 *--------------------------------------------------------------*/
int ConvertToUnicodeAscStr( char sRcvStr[], int nRcvLen, char sResultStr[], int *nResultLen)
{
    u_short  uHighByte =0;
    u_short  uLowByte =0;
    int  uUnicodeIndex =0;
    char     *p = sRcvStr;
    char     *q = sResultStr;
    int      i=0;

    if(sRcvStr == (char *) NULL)
	return -1;
    (*nResultLen) = 0;
    while ( i < nRcvLen  && (*nResultLen) < 4096)
    {
        if (*p == '\0')   /* not allow zero in sRcvStr */
            return -1;
        if ( ((unsigned char)*p) >= 128 )   /* found a Hz high byte */
        {
            uHighByte = (unsigned char )*p;
            if ( i+1 >= nRcvLen ) /* This byte is the tail of sRcvStr */
                return -1;

            /* now find the LowByte of a HZ */
            p++;
            if( ((unsigned char)*p)<128) /* Only Highbyte, No lowbyte */
				continue;
            uLowByte = (unsigned char )*p;

            /* find unicode of this HZ, and put it to sResultStr */
            uUnicodeIndex = ( uHighByte -UNICODE_OFFSET)*94
                            + uLowByte - UNICODE_OFFSET;
            if( uUnicodeIndex >= g_uUnicodeNum || uUnicodeIndex < 0 )
                return -1;
            *q++ = (unsigned char) ( (g_rUnicodeTab[uUnicodeIndex]&0xFF00) >>8);
            *q++ = (unsigned char) (g_rUnicodeTab[uUnicodeIndex] & 0x00FF);
            (*nResultLen) += 2;
           
            /*
             * had checked Two Byte,Note, p had +=1, q had += 2, 
             */
            p++;
            i+=2;
        }
        else // found a ASCII character
		{   
            *q++ = '\0';
			*q++ = (unsigned char ) *p;
            (*nResultLen) += 2;
            p++;
            i++;
        }
    }
    return 0;
}

char * findAsciByMark( unsigned int nUnicodeIndex)
{
 	int i;
	static char sAsci[3];
	
	for(i = 0 ; i< g_uUnicodeNum; i++)
	{
		if(g_rUnicodeTab[i] == nUnicodeIndex)
		{
			sAsci[0] = ( (int) (i/94) ) + UNICODE_OFFSET;
			sAsci[1] = i % 94 + UNICODE_OFFSET;
			sAsci[2] = '\0';
			return sAsci;
		}
	}
	sAsci[0] = '*';
	sAsci[1] = '*';
	sAsci[2] = '\0';
	return sAsci;
}	/* end char * findAsciByMark(int nUnicodeIndex) */

int ConvertUnicodeToAsci(char sRcvStr[], int nRecvLen, char sResultStr[],
	 int *nResultLen)
{
	char *psInItem, *psOutItem, *psTmp;
	unsigned int  nUnicodeMark ;

	if(sRcvStr==(char *)NULL || nRecvLen<=0 || sResultStr==(char *)NULL)
	{
		return -1;
	}
	psInItem = sRcvStr; psOutItem = sResultStr;
	*nResultLen = 0;
	while ( nRecvLen >= 2)
	{
		nUnicodeMark = ( (unsigned char ) *psInItem ) * 0x100 + (unsigned char ) *(psInItem +1);
		nRecvLen -= 2;
		psInItem += 2; 
		if(nUnicodeMark < 129 )
		{
			*psOutItem = nUnicodeMark; psOutItem ++;
			(*nResultLen) ++;
			continue;
		}
		else if( (psTmp = findAsciByMark(nUnicodeMark) )!= (char *)NULL )
		{
			*psOutItem = * psTmp;
			psOutItem ++; psTmp ++;
			*psOutItem = * psTmp; psOutItem ++;	
			(*nResultLen) += 2; 
		}
		
	}	// while()
	*psOutItem = '\0';
	return 0;
}	/* end convertUnicodeToAsci() */

static void ReloadConfigInfo()
{
	static time_t lOldTime=0;
	time_t lNewTime;
	struct stat rStat;

	time(&lNewTime);

	if((lNewTime-lOldTime)>=CHECK_CONFIGINFO_TIMEVAL)
	{
		lOldTime=lNewTime;

		if(stat(g_sIniFile,&rStat)==0)
		{
			if(rStat.st_mtime!=g_lConfigFileTime)
				SmgReadIniFile(g_sIniFile);
		}
	}
}

void ClearMoAndMtCounts()
{
	int i;
	g_nMTCounts = 0;
	g_nMOCounts = 0;
	for(i=0; i<MAX_SERVICE_NUM; i++)
    {
		g_rMoClientTab[i].nMOCounts = 0;
		g_rMoClientTab[i].nMTCounts = 0;
	}
	
}


// 对每项业务当天的MT计数
void FindClientByServiceNumberAndAddMtCount(char *sServiceNumber)
{
    int i;

    if(sServiceNumber == NULL)
		return;

	++g_nMTCounts;

    for(i=0; i<MAX_SERVICE_NUM; i++)
    {
		if(g_rMoClientTab[i].bRegister == TRUE)
 		{
			if(strstr(sServiceNumber, g_rMoClientTab[i].sServiceNumber))
			{
				++g_rMoClientTab[i].nMTCounts;
			}
		}
	}
}

int FindClientByServiceNumberIndex(char *sServiceNumber)
{
    int i;

    if(sServiceNumber == NULL)
		return -1;

    for(i=0; i<MAX_SERVICE_NUM; i++)
    {
		if(g_rMoClientTab[i].bRegister == TRUE)
 		{
			if(strstr(sServiceNumber, g_rMoClientTab[i].sServiceNumber))
			{
				return i;
			}
		}
	}
	return -1;
}