interface.c

使用标准C开发的同时支持CMPP3.0 和 CMPP2.0 的SP短信网关程序

/**
 *@brief  与管理平台的接口实现
 *@file interface.c
 *@date 2008/06/22
 *@version 1.0.0.0
 *@author spirit
 *
 *	
*/

#include <time.h>
#include <windows.h>
#include <stdio.h>
#include "vscp_os.h"
#include "iblock.h"
#include "smctimer.h"
#include "./coding/coding.h"
#include "spsms.h"
#include "interface.h"
#include "inifile.h"

extern unsigned int GetMesQCount(void);

/**
 *@brief 在标准输出打印信息
 *
 * 
 *@param ret [in] 发送函数调用返回的值，0为正常
 *@param pBuffer [in] 要发送的信息
 *@return
*/
void PrintLog(int ret, char* pBuffer)
{
	int nLen, i;
	if (0 != ret && -1 == ret)
	{
		printf("Send To %d Error. Error Code:%d\n", 0, ret);
	}
	else if (0 == ret)
	{
		nLen = *(unsigned short*)pBuffer;
		printf("Send Msg:");
		for(i=0; i<nLen; i++)
		{
			//printf("%02x", *(char*)(pBuffer + i));
			printf("%c", *(char*)(pBuffer + i));
		}
		printf("\n");
	}
}

/**
*@brief 查看网络状态
*
* 查看所有与该节点相连接的网络节点的链接状态
*@param 
*@return
*/
void CheckLinkStatus(NODE* nodestatus)
{
	int nNodeNum = 0, i = 0;
	memset(nodestatus, -2, sizeof(NODE));
	
	nNodeNum = commx_getNodeNum();
	
	for (i = 0; i < nNodeNum; i++)
	{
		if( GetNodeAvailableStatus(i) == TRUE )
		{
			nodestatus->status[i] = (char) commx_getNodeStatus(i);
		}
		else
		{
			nodestatus->status[i] = -1;
		}
	}
	
}

/**
 *@brief 查询SMC配置
 *
 * 
 *@param source [in] 消息的发送者
 *@param pBuffer [in] 消息的内容
 *@return
*/
void QuerySetParamRequest(char source, char* pBuffer)
{
	SMC_ATTR smcAttibution;
	short	 nLen = sizeof(SMC_ATTR);
	char	 sBuf[sizeof(SMC_ATTR) + 2];

	*(unsigned short*)sBuf = nLen;
	memset(&smcAttibution, 0, nLen);

	strcpy(smcAttibution.sGWIP, SpSmc.ismgip);
	strcpy(smcAttibution.sAccessID, SpSmc.spid);

	memcpy(sBuf + 2, &smcAttibution, nLen);

	QuerySetParamAck(source, sBuf);

}
int QuerySetParamAck(char des, char* pBuffer)
{
	int ret = -1;

	ret = CodePrim(SMCPP|2, des, pBuffer);

	PrintLog(ret, pBuffer);
	return ret;
}

/**
 *@brief 修改SMC配置
 *
 * 
 *@param source [in] 消息的发送者
 *@param pBuffer [in] 消息的内容
 *@return
*/
void ModiSetParamRequest(char source, char* pBuffer)
{
	SMC_ATTR*	smcAttibution;
	RESULT		result;
	short		nLen = 0;
	char		sBuf[sizeof(RESULT) + 2] = {0};

	const char sFileName[MAX_STRING_LEN] = "setting.ini";
	const char sSection[MAX_STRING_LEN] = "SP";
	const char sKey[MAX_SET_PARAM_NUM][MAX_STRING_LEN] = {"localip", "ismgip", "spid", "sppwd"};
	
	memset(&result, 0, sizeof(result));

	smcAttibution = (SMC_ATTR*)pBuffer;
	result.cResult = 0;

	if (!write_profile_string(sSection, sKey[1], smcAttibution->sGWIP, sFileName))
	{
		result.cResult = -1;
	}
	if (!write_profile_string(sSection, sKey[2], smcAttibution->sAccessID, sFileName))
	{
		result.cResult = -1;
	}


	nLen = sizeof(RESULT);
	*(unsigned short*)sBuf = nLen;
	memcpy(sBuf + 2, &result, nLen);
	
	ModiSetParamAck(source, sBuf);

}
int ModiSetParamAck(char des, char* pBuffer)
{
	int ret;
	
	ret = CodePrim(SMCPP|3, des, pBuffer);
	PrintLog(ret, pBuffer);
	return ret;
}

/**
 *@brief 修改SMC企业密码
 *
 * 
 *@param source [in] 消息的发送者
 *@param pBuffer [in] 消息的内容
 *@return
*/
void ModiPwdRequest(char source, char* pBuffer)
{
	SMC_PWD*	smcPwd;
	RESULT		result;
	short		nLen = 0;
	char		sBuf[sizeof(RESULT) + 2] = {0};
	
	const char sFileName[MAX_STRING_LEN] = "setting.ini";
	const char sSection[MAX_STRING_LEN] = "SP";
	const char sKey[MAX_SET_PARAM_NUM][MAX_STRING_LEN] = {"localip", "ismgip", "spid", "sppwd"};
	
	memset(&result, 0, sizeof(result));

	smcPwd = (SMC_PWD*)pBuffer;
	result.cResult = 0;
	if (!write_profile_string(sSection, sKey[3], smcPwd->sAccessPWD, sFileName))
	{
		result.cResult = -1;
	}


	nLen = sizeof(RESULT);
	*(unsigned short*)sBuf = nLen;
	memcpy(sBuf + 2, &result, nLen);

	ModiPwdAck(source, sBuf);
}
int ModiPwdAck(char des, char* pBuffer)
{
	int ret;
	
	ret = CodePrim(SMCPP|4, des, pBuffer);
		
	PrintLog(ret, pBuffer);
	return ret;
}

/**
 *@brief 查询SMC资源
 *
 * 
 *@param source [in] 消息的发送者
 *@param pBuffer [in] 消息的内容
 *@return
*/
void QuerySMCSourceRequest(char source, char* pBuffer)
{
	SMCSOURCE	smcSource;
	short		nLen = sizeof(SMCSOURCE);
	char		sBuf[sizeof(SMCSOURCE) + 2] = {0};
	
	*(unsigned short*)sBuf = nLen;
	memset(&smcSource, 0, nLen);

	smcSource.nQueenNum = GetMesQCount();
	smcSource.nSysTimer = SysTestTv.Value;
	smcSource.nSysStatus = SmcCheckStatus();			

	memcpy(sBuf + 2, &smcSource, nLen);
	
	QuerySMCSourceAck(source, sBuf);
}
int QuerySMCSourceAck(char des, char* pBuffer)
{
	int ret;
	
	ret = CodePrim(SMCPP|5, des, pBuffer);

	PrintLog(ret, pBuffer);
	return ret;
}

/**
 *@brief 修改SMC系统定时器值
 *
 * 
 *@param source [in] 消息的发送者
 *@param pBuffer [in] 消息的内容
 *@return
*/
void ModiSMCSysTimerRequest(char source, char* pBuffer)
{
	TIMER*	smcTimer;
	RESULT	result;
	short	nLen = 0;
	char	sBuf[sizeof(RESULT) + 2] = {0};

	memset(&result, 0, sizeof(result));

	smcTimer = (TIMER*)pBuffer;
	result.cResult = 0;
	if (8 !=smcTimer->nTimerFlag)
	{
		result.cResult = -1;
	}
	else
	{
		SysTestTv.Value = smcTimer->nTimer;	
	}


	nLen = sizeof(RESULT);
	*(unsigned short*)sBuf = nLen;
	memcpy(sBuf + 2, &result, nLen);

	ModiSMCSysTimerAck(source, sBuf);
}
int ModiSMCSysTimerAck(char des, char* pBuffer)
{
	int ret;
	
	ret = CodePrim(SMCPP|6, des, pBuffer);

	PrintLog(ret, pBuffer);
	return ret;
}


/**
 *@brief 复位SMC定时器
 *
 *@param source [in] 消息的发送者
 *@param pBuffer [in] 消息的内容
*/
void ResetSMCSysTimerRequest(char source, char* pBuffer)
{
	RESULT result;
	short  nLen = sizeof(RESULT);
	char   sBuf[sizeof(RESULT) + 2] = {0};

	memset(&result, 0, nLen);

	if (0 == SmcTimerNull())
	{
		result.cResult = 0;
	}
	else
	{
		result.cResult = SmcReleaseTimer(&SysTestTv);
	}

	*(unsigned short*)sBuf = nLen;
	memcpy(sBuf + 2, &result, nLen);

	ResetSMCSysTimerAck(source, sBuf);
}
int ResetSMCSysTimerAck(char des, char* pBuffer)
{
	int ret;
	
	ret = CodePrim(SMCPP|7, des, pBuffer);

	PrintLog(ret, pBuffer);
	return ret;
}

/**
 *@brief 查看ISMG网关连接状态
 *
 *@param source [in] 消息的发送者
 *@param pBuffer [in] 消息的内容
*/
void QueryISMGStatusRequest(char source, char* pBuffer)
{
	ISMGSTATUS	status;
	short		nLen = sizeof(ISMGSTATUS);
	char		sBuf[sizeof(ISMGSTATUS) + 2] = {0};

	memset(&status, 0, nLen);

	if (SPSMC_ISMGOK == SpSmc.state)
	{
		status.nIsmgStatus = 0;
	}
	else if (SPSMC_ISMGNOOK == SpSmc.state)
	{
		status.nIsmgStatus = -1;
	}
	status.nIsmgTimer = SysTestResTv.Value;
	*(unsigned short*)sBuf = nLen;
	memcpy(sBuf + 2, &status, nLen);

	QueryISMGStatusAck(source, sBuf);
}
int QueryISMGStatusAck(char des, char* pBuffer)
{
	int ret;
	
	ret = CodePrim(SMCPP|8, des, pBuffer);
	
	PrintLog(ret, pBuffer);
	return ret;
}

/**
 *@brief SMC告警
 *
 * 当count持续时间超过WARNEXPIRETIME时，向管理平台发送告警
 *@param count [in] count表示出现问题的持续时间，以秒为单位。
 *@return
*/
void ReportWarning(short* count1, short* count2, short* count3)
{
	/*
	系统消息队列告警				0x15
	ISMG链接告警					0x16
	系统定时器队列告警				0x17
	*/
	SMCWARN		smcWarning;
	short		nLen = sizeof(SMCWARN);
	char		sBuf[sizeof(SMCWARN) + 2] = {0};

	memset(&smcWarning, 0, nLen);
	if (MAX_SMC_MSGLEN <= GetMesQCount())
	{
		*count1++;
		smcWarning.kind = 21;
		strcpy(smcWarning.WarnInfo, "SMC系统消息队列大小超过队列上限。");
		if (*count1 == WARNEXPIRETIME)
		{
			*count1 = 0;
			*(unsigned short*)sBuf = nLen;
			memcpy(sBuf, &smcWarning, nLen);
	
			ReportWarningAck(target.TT_CCENTER, sBuf);
			return;
		}
	}
	else if (SPSMC_ISMGNOOK == SpSmc.state)
	{
		*count2++;
		smcWarning.kind = 22;
		strcpy(smcWarning.WarnInfo, "ISMG链接断开");
		if (*count2 == WARNEXPIRETIME)
		{
			*count2 = 0;
			*(unsigned short*)sBuf = nLen;
			memcpy(sBuf, &smcWarning, nLen);
			
			ReportWarningAck(target.TT_CCENTER, sBuf);
			return;
		}

	}
	else if (MAX_SMC_TIMERLEN <= SmcTimerLen())
	{
		*count3++;
		smcWarning.kind = 23;
		strcpy(smcWarning.WarnInfo, "SMC系统定时器队列大小超过队列上限。");
		if (*count3 == WARNEXPIRETIME)
		{
			*count3 = 0;
			*(unsigned short*)sBuf = nLen;
			memcpy(sBuf, &smcWarning, nLen);
			
			ReportWarningAck(target.TT_CCENTER, sBuf);
			return;
		}
	}

}
int ReportWarningAck(char des, char* pBuffer)
{
	int ret;
	
	ret = CodePrim(SMCPP|9, des, pBuffer);

	PrintLog(ret, pBuffer);
	return ret;
}

/**
 *@brief 监控程序测试请求
 *
 * 监控程序不断的发送该请求，然后向监控程序返回消息，用以判断该程序是否有响应
 *@param source [in] 消息的发送者
 *@param pBuffer [in] 消息的内容
*/
void WatchRestartRequest(char source, char* pBuffer)
{

	int nLen = sizeof(WRESULT);
	WRESULT result = {0};
	char pBuf[32] = {0};
	*(unsigned short*)pBuf = nLen;
	
	result.nAppNo = GetWhoAmI();
	result.nresult = 1;
	
	memcpy(pBuf + 2, &result, nLen);
	
	WatchRestartAck(source, pBuf);
}
int WatchRestartAck(char dest, char* pBuffer)
{
	int ret;
	
	ret = CodePrim(SMCPP|10, dest, pBuffer);
	
	PrintLog(ret, pBuffer);
	return ret;
}

/**
 *@brief 检查网络节点的连接状态
 *
 * 
 *@param source [in] 消息的发送者
 *@param pBuffer [in] 消息的内容
*/
void CheckLinkStatusRequest(char source, char* pBuffer)
{
	int nLen = sizeof(NODE);
	NODE linkNode;
	char pAckBuffer[1024] = {0};
	*(unsigned short*)pAckBuffer = nLen;

	CheckLinkStatus(&linkNode);
	
	memcpy(pAckBuffer + 2, &linkNode, nLen);
	CheckLinkStatusAck(source, pAckBuffer);
}
int CheckLinkStatusAck(char des, char* pBuffer)
{
	int ret;

	ret = CodePrim(SMCPP|11, des, pBuffer);

	PrintLog(ret, pBuffer);
	return ret;
}

/**
 *@brief 向数据库发送用户注册消息
 *
 * 
 *@param buf [in] 格式为2Byte+SrcNumber+2Byte+DestNumber
 *@return 发送成功与否
*/
int SendRegToDB(char* buf)
{
	return CodePrim(SMCPP|0, target.TT_VDB, buf);
}

/**
 *@brief 向数据库发送用户注销消息
 *
 * 
 *@param buf [in] 格式为2Byte+SrcNumber+2Byte+DestNumber
 *@return 发送成功与否
*/
int SendUnRegToDB(char* buf)
{
	return CodePrim(SMCPP|1, target.TT_VDB, buf);
}


/**
 *@brief 扫描告警信息的线程处理函数
 *
 * 
 *@param param [in]此处未使用
 *@return
*/
DWORD WINAPI QueryWarning(PVOID param)
{
	short	count[3] = {0};
	
	while (1)
	{
		ReportWarning(&count[0], &count[1], &count[2]);


		Sleep(5000);
	}
}

/**
 *@brief 从tcp.ini中读入所有节点的编码值，tcp.ini中的顺序和标识应该和tcpip.ini一致
 *
 * 
 *@param 
 *@return 0:正确读取 -1:读取出错
*/
int GetTargetInfo()
{
	memset(&target, 0, sizeof(target));
	target.TT_VSCP = read_profile_int("target", "VSCP", 0, "tcp.ini");
	target.TT_ASR = read_profile_int("target", "ASR", 0, "tcp.ini");
	target.TT_SMC = read_profile_int("target", "SMC", 0, "tcp.ini");
	target.TT_SMSSERVER = read_profile_int("target", "SMSSERVER", 0, "tcp.ini");
	target.TT_YFWEBSERVER = read_profile_int("target", "YFWEBSERVER", 0, "tcp.ini");
	target.TT_VDB = read_profile_int("target", "VDB", 0, "tcp.ini");
	target.TT_CDB = read_profile_int("target", "CDB", 0, "tcp.ini");
	target.TT_CCENTER = read_profile_int("target", "CCENTER", 0, "tcp.ini");
	target.TT_WATCH = read_profile_int("target", "WATCH", 0, "tcp.ini");
	
	return 0;
}



void QuerySetParamReq(REQUESTDATA* req)
{
	if (req ==  NULL)
	{
		return;
	}

	QuerySetParamRequest(target.TT_CCENTER, req->ptr->pBuffer);

	PutIdleBlock(&req);
}

void ModiSetParamReq(REQUESTDATA* req)
{
	if (req ==  NULL)
	{
		return;
	}
	
	ModiSetParamRequest(target.TT_CCENTER, req->ptr->pBuffer);
	
	PutIdleBlock(&req);
}	

void ModiPwdReq(REQUESTDATA* req)
{
	if (req ==  NULL)
	{
		return;
	}
	
	ModiPwdRequest(target.TT_CCENTER, req->ptr->pBuffer);
	
	PutIdleBlock(&req);
}	
			
void QuerySMCSourceReq(REQUESTDATA* req)
{
	if (req ==  NULL)
	{
		return;
	}
	
	QuerySMCSourceRequest(target.TT_CCENTER, req->ptr->pBuffer);
	
 	PutIdleBlock(&req);
}		

void ModiSMCSysTimerReq(REQUESTDATA* req)
{
	if (req ==  NULL)
	{
		return;
	}
	
	ModiSMCSysTimerRequest(target.TT_CCENTER, req->ptr->pBuffer);
	
	PutIdleBlock(&req);
}	

void ResetSMCSysTimerReq(REQUESTDATA* req)
{
	if (req ==  NULL)
	{
		return;
	}
	
	ResetSMCSysTimerRequest(target.TT_CCENTER, req->ptr->pBuffer);
	
	PutIdleBlock(&req);
}

void QueryISMGStatusReq(REQUESTDATA* req)
{
	if (req ==  NULL)
	{
		return;
	}
	
	QueryISMGStatusRequest(target.TT_CCENTER, req->ptr->pBuffer);
	
	PutIdleBlock(&req);
}

void WatchRestartReq(REQUESTDATA* req)
{
	if (req == NULL)
	{
		return;
	}

	WatchRestartRequest(target.TT_WATCH, req->ptr->pBuffer);
	PutIdleBlock(&req);
}

void CheckLinkStatusReq(REQUESTDATA* req)
{
	if (req == NULL)
	{
		return;
	}

	CheckLinkStatusRequest(target.TT_CCENTER, req->ptr->pBuffer);
	PutIdleBlock(&req);
}