smgapi.cpp

中国移动的短信网关程序

			SmgInitSmscChannel(nIndex);
			return;
		}
	}
	
	memcpy(rSmgSubmitReq.sSrcAddr, g_sTestNumber, strlen(g_sTestNumber));
	
	if(rSmgSubmitReq.ucRegister != 2)
		rSmgSubmitReq.ucRegister = 1;  //每条MT都需要状态报告返回
	
	//处理短消息内容大于74个汉字   ---by yrx
	char acTmp[256];
	int iTmp = rSmgSubmitReq.ucMsgLen;
	for(int iTop = 0; iTop <= rSmgSubmitReq.ucMsgLen/MAXLEN; iTop++)
	{
		strncpy(acTmp, rSmgSubmitReq.sMsgContext+(iTop * MAXLEN), MAXLEN);
		int iLen;
		if(iTmp >= MAXLEN)
			iLen = MAXLEN;
		else
			iLen = iTmp;
		iTmp -= MAXLEN;

		nRet = CMPP_SendSubmitReq(&nSeqId, 
			rSmgSubmitReq.sMsgId, 
			rSmgSubmitReq.nMsgCounts,
			rSmgSubmitReq.nMsgNumber,
			rSmgSubmitReq.ucRegister, // Registered
			9, // MsgLevel
			sServiceId,
			rSmgSubmitReq.ucFeeUserType,
			rSmgSubmitReq.sFeeAddr,
			0, // FeeTerminalType
			0, // TPPid
			0, 
			rSmgSubmitReq.ucMsgFmt,
			g_sSpId,
			atoi(sFeeType),
			sFeeCode,
			rSmgSubmitReq.sSrcAddr,
			1,
			rSmgSubmitReq.sDstAddr,
			0, //DstTerminalType,
			iLen,//rSmgSubmitReq.ucMsgLen,
			acTmp, //rSmgSubmitReq.sMsgContext,
			rSmgSubmitReq.sLinkId);
		if(nRet != 0)
			break;
	}
	if(rSmgSubmitReq.ucRegister == 2) // 兼容监控显示计费类型，
		strcpy(sDisplayFeeType, "00");
	else
		strcpy(sDisplayFeeType, sFeeType);
	
	p = q = rSmgSubmitReq.sMsgContext;
	while((q = strchr(p, '\n')) != NULL) // 修改写MT日志时，检测MT消息中是否后回车，如有回车，则去之。
	{
		c = q-1; 
		if(*c == '\r')
		{
			strncat(sMsg, p, q-p-1);
			strcat(sMsg, "[0d][0a]");
		}
		else
		{
			strncat(sMsg, p, q-p);
			strcat(sMsg, "[0d]");
		}
		p = q+1;
	}
	strcat(sMsg,p);
	sprintf(g_rSmgChan[nIndex].sMTCDR, "MT:%d%s%s%s%s%s%s%s%d%s%d%s%s%s%s%s%d%s%s%s%d%s%s",
		nSeqId, SPACE_MARK, rSmgSubmitReq.sSrcAddr, SPACE_MARK,
		rSmgSubmitReq.sDstAddr, SPACE_MARK, sServiceId, SPACE_MARK,
		rSmgSubmitReq.ucMsgFmt, SPACE_MARK, rSmgSubmitReq.ucMsgLen, SPACE_MARK,
		sDisplayFeeType, SPACE_MARK, sFeeCode, SPACE_MARK,
		rSmgSubmitReq.ucFeeUserType, SPACE_MARK, rSmgSubmitReq.sFeeAddr, SPACE_MARK,
		time(NULL), SPACE_MARK, sMsg);
	
	g_rSmgChan[nIndex].nSeqId = nSeqId;
	
	if(0 != nRet)
	{
		SmgTrace(0, (char *)"Error: CMPP_Submit() failed: <%d>.", nRet );
		memset(&rMsgHead, 0x00, sizeof(TMsgHead));
		memset(&rSmgSubmitRep, 0x00, sizeof(TSmgSubmitRep));
		rMsgHead.nCmdId = SMG_SubmitRep;
		rMsgHead.nChannelId = nIndex ;
		rSmgSubmitRep.ucActionType = g_rSmgChan[nIndex].ucActionType;
		rMsgHead.nLinkId = g_rSmgChan[nIndex].nHandle;
		rSmgSubmitRep.ucResult = 9;
		
		nRet = SMG_SendSubmitRep(rMsgHead, rSmgSubmitRep);
		if(0 < nRet)
			SmgTrace(0, (char *)"Error: failed to send SMG_SubmitRep to client: <%d>.", nRet);
		SmgInitSmscChannel(nIndex);
	}
	else
	{
		FindClientByServiceNumberAndAddMtCount(rSmgSubmitReq.sSrcAddr);
		SmgTrace(0, (char *)"ID-%03d: Send CMPP_SUBMIT event to SMSC SeqId=0x%08x", nIndex, g_rSmgChan[nIndex].nSeqId);
		g_rSmgChan[nIndex].ucChildStat = WAIT_SUBMIT_REP;
		g_rSmgChan[nIndex].nTimeval = WAIT_SUBMIT_REP_TIME;
		g_rTimerQueue.AddTimerQueue(&g_rSmgChan[nIndex]);
	}
}

static void ProcessSmgDeliverRep(int nIndex, char *sBuf)
{
    TSmgDeliverRep rSmgDeliverRep;

    if(0 > nIndex || MAX_CHANNEL_NUM <= nIndex)
		return;
    if(NULL == sBuf)
		return;
    memset(&rSmgDeliverRep, 0x00, sizeof(TSmgDeliverRep));
    memcpy(&rSmgDeliverRep, sBuf, sizeof(TSmgDeliverRep));

    SmgTrace(0, (char *)"ID-%03d: Received SMG_DeliverRep from %s, Result=%d", 
		nIndex, g_rSmgChan[nIndex].sSmscClientIp, rSmgDeliverRep.ucResult);
/*
    if(g_rSmgChan[nIndex].ucStat == IDLE)
    {
		SmgTrace(0, (char *)"Error: ID-%03d is in idle stat",nIndex);
		return;
    }

    // contruct the RecCDeliverRep and send to SMSC

    SmgTrace(0, (char *)"ID-%03d: Send CMPP_DELIVER_REP event to SMSC", nIndex);
	g_rSmgChan[nIndex].ucChildStat = WAIT_SUBMIT_REQ;
	g_rSmgChan[nIndex].nTimeval = WAIT_SUBMIT_REQ_TIME;
    g_rTimerQueue.AddTimerQueue(&g_rSmgChan[nIndex]);
*/
}
void UnRegisterService(int nHandle)
{
    int i, j;
	char sContent[160] = {0x00};

    for(i=0; i<MAX_SERVICE_NUM; i++)
    {
		if(g_rMoClientTab[i].bRegister == TRUE)
		{
			for(j=0; j<MAX_CLIENT_FOR_SERVICE; j++)
			{
				if(g_rMoClientTab[i].rClientInfo[j].nHandle == nHandle)
				{
					sprintf(sContent, "告警信息：IP：%s业务号码：%s的业务程序注销或退出，请到现场维护！", 
						g_rMoClientTab[i].rClientInfo[j].sIp, g_rMoClientTab[i].sServiceNumber);
//					SendAlarmMsgToSupporter(g_sSupportTel, "-HTERR", sContent, strlen(sContent));
					sprintf(sContent, "%s;IP:%s,业务号码:%s的业务程序注销或退出!!!", 
						g_rMoClientTab[i].sServiceNumber, g_rMoClientTab[i].rClientInfo[j].sIp, g_rMoClientTab[i].sServiceNumber);
					SendMonitorMsg(MONI_SERVICE_LOGOUT, sContent);
					
					g_rMoClientTab[i].rClientInfo[j].nHandle = -1;
					memset(g_rMoClientTab[i].rClientInfo[j].sIp, 0x00, 18);
					g_rMoClientTab[i].nClientCount--;
					if(g_rMoClientTab[i].nClientCount <= 0)
						g_rMoClientTab[i].bRegister = FALSE;
				}
			}
		}
    }
}

static void ProcessMonitorClientRegister(TSmgPacket *prSmgPacket)
{
	int i;
	TSmgRegisterRep rSmgRegisterRep;
	TMsgHead rMsgHead;
	TMonitorMesg rMonitorMesg;

	memset(&rMonitorMesg, 0x00, sizeof(TMonitorMesg));

	memcpy(&rMsgHead, prSmgPacket, sizeof(TMsgHead));
	rMsgHead.nCmdId = SMG_RegisterRep;
	rMsgHead.nLinkId = prSmgPacket->rMsgHead.nLinkId;

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

	strcpy(rSmgRegisterRep.sServiceNumber, prSmgPacket->rMsgBody.rSmgRegisterReq.sServiceNumber);

	for(i=0; i<MAX_MONITOR_CLIENT; i++)
	{
		if(g_rMonitorClient[i].bUse != TRUE)
		{
			g_rMonitorClient[i].bUse = TRUE;
			g_rMonitorClient[i].bSetMonitor = TRUE;
			g_rMonitorClient[i].nHandle = prSmgPacket->rMsgHead.nLinkId;
			strcpy(g_rMonitorClient[i].sIp, prSmgPacket->rMsgHead.sLinkIp);
			rSmgRegisterRep.ucResult = 0;
			SMG_SendRegisterRep(rMsgHead, rSmgRegisterRep);

			rMonitorMesg.nMoniType = MONI_OPNE_SERVICE_INFO;
			strcpy(rMonitorMesg.sMoniMsg, g_sHaveOpenService);
			SMG_SendMonitorMsg(g_rMonitorClient[i].nHandle, (char *)&rMonitorMesg, sizeof(TMonitorMesg));

			rMonitorMesg.nMoniType = MONI_SMG_MOMT_QUERY;
			sprintf(rMonitorMesg.sMoniMsg, "%d;%d", g_nMOCounts, g_nMTCounts);
			SMG_SendMonitorMsg(g_rMonitorClient[i].nHandle, (char *)&rMonitorMesg, sizeof(TMonitorMesg));
			return;
		}
	}
	rSmgRegisterRep.ucResult = 1;
	SMG_SendRegisterRep(prSmgPacket->rMsgHead, rSmgRegisterRep);
}

static void ProcessMonitorClientUnRegister(int nHandle)
{
	int i;

	for(i=0; i<MAX_MONITOR_CLIENT; i++)
	{
		if(g_rMonitorClient[i].nHandle == nHandle)
		{
			g_rMonitorClient[i].bUse = FALSE;
			g_rMonitorClient[i].nHandle = -1;
			g_rMonitorClient[i].bSetMonitor = FALSE;
			strcpy(g_rMonitorClient[i].sIp, "");
			return;
		}
	}
}

static void ProcessMonitorAction(int nHandle, TMonitorMesg rMonitorMesg)
{
	int nIndex=0;
	char sMsg[256] = {0x00};
	char sServiceNumber[32] = {0x00};
	int i;

	switch(rMonitorMesg.nMoniType)
	{
	case MONI_SET://	0x100d // 对网关设置监控
		for(i=0; i<MAX_MONITOR_CLIENT; i++)
		{
			if(g_rMonitorClient[i].nHandle == nHandle && g_rMonitorClient[i].bUse == TRUE)
			{
				g_rMonitorClient[i].bSetMonitor = TRUE;
			}
		}
		break;
	case MONI_CANCEL:// 0x100e // 对网关取消监控
		for(i=0; i<MAX_MONITOR_CLIENT; i++)
		{
			if(g_rMonitorClient[i].nHandle == nHandle && g_rMonitorClient[i].bUse == TRUE)
			{
				g_rMonitorClient[i].bSetMonitor = FALSE;
			}
		}
		break;
	case MONI_SMG_MOMT_QUERY:// 0x100f // 查询短信网关当天MOMT的数量
		sprintf(sMsg, "%d;%d", g_nMOCounts, g_nMTCounts);
		SendMonitorMsg(MONI_SMG_MOMT_QUERY, sMsg);
		break;
	case MONI_SERV_MOMT_QUERY:// 0x1010 // 查询单项业务当天的MOMT数量
		strcpy(sServiceNumber, rMonitorMesg.sMoniMsg);
		nIndex = FindClientByServiceNumberIndex(sServiceNumber);
		if(nIndex == -1)
			return;
		sprintf(sMsg, "%d;%d;%s",
			g_rMoClientTab[nIndex].nMOCounts, g_rMoClientTab[nIndex].nMTCounts,
			sServiceNumber);
		SendMonitorMsg(MONI_SERV_MOMT_QUERY, sMsg);
		break;
	case MONI_SMG_QUIT:
		CloseProgram(1);
		break;
	case MONI_SERV_RELOAD_DATA:
		strcpy(sServiceNumber, rMonitorMesg.sMoniMsg);
		nIndex = FindClientByServiceNumberIndex(sServiceNumber);
		if(nIndex == -1)
			return;
		for(i=0; i<MAX_CLIENT_FOR_SERVICE; i++)
		{
			if(g_rMoClientTab[nIndex].rClientInfo[i].nHandle != -1)
				SMG_SendReloadData(g_rMoClientTab[nIndex].rClientInfo[i].nHandle);
		}
		break;
	case MONI_SERV_RELOAD_CONFIG:
		strcpy(sServiceNumber, rMonitorMesg.sMoniMsg);
		nIndex = FindClientByServiceNumberIndex(sServiceNumber);
		if(nIndex == -1)
			return;
		for(i=0; i<MAX_CLIENT_FOR_SERVICE; i++)
		{
			if(g_rMoClientTab[nIndex].rClientInfo[i].nHandle != -1)
				SMG_SendReloadConfig(g_rMoClientTab[nIndex].rClientInfo[i].nHandle);
		}
		
		break;
	case MONI_SERV_QUIT:
		strcpy(sServiceNumber, rMonitorMesg.sMoniMsg);
		nIndex = FindClientByServiceNumberIndex(sServiceNumber);
		if(nIndex == -1)
			return;
		for(i=0; i<MAX_CLIENT_FOR_SERVICE; i++)
		{
			if(g_rMoClientTab[nIndex].rClientInfo[i].nHandle != -1)
				SMG_SendServiceExit(g_rMoClientTab[nIndex].rClientInfo[i].nHandle);
		}
		break;
	default:
		break;
	}
}

void SendMonitorMsg(int nMoniType, char *sMonMsg)
{
	int i;
	TMonitorMesg rMonitorMesg;


	memset(&rMonitorMesg, 0x00, sizeof(TMonitorMesg));

	rMonitorMesg.nMoniType = nMoniType;
	if(sMonMsg != NULL)
		strcpy(rMonitorMesg.sMoniMsg, sMonMsg);
	
	for(i=0; i<MAX_MONITOR_CLIENT; i++)
	{
		if(g_rMonitorClient[i].bUse == TRUE && g_rMonitorClient[i].bSetMonitor == TRUE)
		{
			SMG_SendMonitorMsg(g_rMonitorClient[i].nHandle, (char *)&rMonitorMesg, sizeof(TMonitorMesg));
		}
	}
}


static void CheckServiceFlow(char *sServiceNumber, int nHandle)
{
	int i, j;
	if(sServiceNumber == NULL)
		return;
    for(i=0; i<MAX_SERVICE_NUM; i++)
    {
		if(g_rMoClientTab[i].bRegister == TRUE)
		{
		    if(strstr(sServiceNumber, g_rMoClientTab[i].sServiceNumber))
		    {
				for(j=0; j<MAX_CLIENT_FOR_SERVICE; j++)
				{
					if(nHandle == g_rMoClientTab[i].rClientInfo[j].nHandle)
					{
						g_rMoClientTab[i].rClientInfo[j].nNoProcess--;
					}
				}
			}
		}
    }	
}