smgapibase.cpp

中国移动的短信网关程序

#include "stdafx.h"
#include "TcpLib.h"
#include "SmgApi.h"
#include "DataQueue.h"

static int g_nSmgClientHandle = -1;
static CLIENT g_rSmgClient;
static SERVER g_rSmgServer;
static BOOL g_bSmgConnectActive = FALSE;
static char g_sSmgServerIp[18] = {0x00};
static int g_nPort;
static int g_nRegServNum = 0;

typedef CDataQueue<TSmgPacket> TSmgPacketQueue;

static TSmgPacketQueue g_rSmgPacketQueue;
char g_rRegGroup[32][128];

// begin define function for SMG client
static void OnSmgClientReceiveData(int nHandle,char *sIpAddr,int nPort,char *sBuf,unsigned short nLen)
{
	TSmgPacket rSmgPacket;
	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));
	if(nLen > sizeof(TSmgPacket))
		return;
	memcpy(&rSmgPacket, sBuf, nLen);

	rSmgPacket.rMsgHead.nLinkId = nHandle;
	strcpy(rSmgPacket.rMsgHead.sLinkIp, sIpAddr);
	rSmgPacket.rMsgHead.nPort = nPort;

	g_rSmgPacketQueue.WriteDataToQueue(&rSmgPacket);

}

static void OnSmgClientConnected(int nHandle,char *sIpAddr,unsigned short nPort)
{
	TSmgPacket rSmgPacket;

	rSmgPacket.rMsgHead.nLinkId = nHandle;
	rSmgPacket.rMsgHead.nCmdId = SMG_LinkUp;
	rSmgPacket.rMsgHead.nChannelId = 0;
	rSmgPacket.rMsgHead.nPort = nPort;
	strcpy(rSmgPacket.rMsgHead.sLinkIp, sIpAddr);

	g_rSmgPacketQueue.WriteDataToQueue(&rSmgPacket);
	g_bSmgConnectActive = TRUE;

}

static void OnSmgClientDisconnected(int nHandle,char *sIpAddr,unsigned short nPort)
{
	TSmgPacket rSmgPacket;

	rSmgPacket.rMsgHead.nLinkId = nHandle;
	rSmgPacket.rMsgHead.nCmdId = SMG_LinkDown;
	rSmgPacket.rMsgHead.nChannelId = 0;
	rSmgPacket.rMsgHead.nPort = nPort;
	strcpy(rSmgPacket.rMsgHead.sLinkIp, sIpAddr);

	g_rSmgPacketQueue.WriteDataToQueue(&rSmgPacket);
	g_bSmgConnectActive = FALSE;
}

static int SendPacketToSmg(char *sBuf, int nLen)
{
	int nRet = 0;
	nRet = g_rSmgClient.SendMsg(g_nSmgClientHandle, sBuf, nLen);
	if(nRet == 104)
		g_bSmgConnectActive = FALSE;
	return nRet;
}


int SMG_InitClient(char *sSmgServerIp, int nPort)
{
	if(sSmgServerIp == NULL)
		return -1;

    strcpy(g_sSmgServerIp, sSmgServerIp);
	g_nPort = nPort;

	g_rSmgClient.rCommFunc_.OnRecvData = OnSmgClientReceiveData;
    g_rSmgClient.rCommFunc_.OnConnected = OnSmgClientConnected;
    g_rSmgClient.rCommFunc_.OnDisconnected = OnSmgClientDisconnected;

	g_nSmgClientHandle = g_rSmgClient.InitClient(sSmgServerIp, nPort);
	if(g_nSmgClientHandle < 0)
		return -1;
	else
		return g_nSmgClientHandle;
}

int SMG_GetSmgClientEvent(TSmgPacket *prSmgPacket)
{
	int nCmdId;

	g_rSmgClient.RunClient();

	if(g_bSmgConnectActive == FALSE)
	{
		while(!g_bSmgConnectActive)
		{
			if(SMG_InitClient(g_sSmgServerIp, g_nPort) > 0)
			{
				for(int i=0; i<g_nRegServNum; i++)
				{
					SendPacketToSmg((char *)g_rRegGroup[i], sizeof(TSmgRegisterReq));
				}
				break;
			}
#ifndef	_OS_UNIX
			Sleep(1000);
#else
			sleep(1);
#endif
		}
	}

	if(prSmgPacket == NULL)
		return -1;
	if(g_rSmgPacketQueue.ReadDataFromQueue(prSmgPacket) == 0)
	{
		nCmdId = prSmgPacket->rMsgHead.nCmdId;
		return nCmdId;
	}
	else
		return -1;
}

void SMG_CloseClient()
{
	g_rSmgClient.CloseClient();
}

int SMG_SendRegisterReq(TMsgHead rMsgHead, TSmgRegisterReq rSmgRegisterReq)
{
	TSmgPacket rSmgPacket;
	unsigned short nLen;
	
	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));
	if(rMsgHead.nCmdId != SMG_RegisterReq)
		return -1;
	memcpy(&rSmgPacket.rMsgHead, &rMsgHead, sizeof(TMsgHead));
	memcpy(&rSmgPacket.rMsgBody, &rSmgRegisterReq, sizeof(TSmgRegisterReq));

	nLen = sizeof(TMsgHead) + sizeof(TSmgRegisterReq);

	memcpy(g_rRegGroup[g_nRegServNum], &rSmgPacket, nLen);
	g_nRegServNum++;
	if(g_nRegServNum >32)
		g_nRegServNum = 32;

	return SendPacketToSmg((char *)&rSmgPacket, nLen);
}

int SMG_SendUnRegisterReq(TMsgHead rMsgHead, TSmgUnRegisterReq rSmgUnRegisterReq)
{
	TSmgPacket rSmgPacket;
	unsigned short nLen;
	
	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));
	if(rMsgHead.nCmdId != SMG_UnRegisterReq)
		return -1;
	memcpy(&rSmgPacket.rMsgHead, &rMsgHead, sizeof(TMsgHead));
	memcpy(&rSmgPacket.rMsgBody, &rSmgUnRegisterReq, sizeof(TSmgUnRegisterReq));

	nLen = sizeof(TMsgHead) + sizeof(TSmgUnRegisterReq);

	return SendPacketToSmg((char *)&rSmgPacket, nLen);
}
int SMG_SendDeliverRep(TMsgHead rMsgHead, TSmgDeliverRep rSmgDeliverRep)
{
	TSmgPacket rSmgPacket;
	unsigned short nLen;
	
	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));
	if(rMsgHead.nCmdId != SMG_DeliverRep)
		return -1;
	memcpy(&rSmgPacket.rMsgHead, &rMsgHead, sizeof(TMsgHead));
	memcpy(&rSmgPacket.rMsgBody, &rSmgDeliverRep, sizeof(TSmgDeliverRep));

	nLen = sizeof(TMsgHead) + sizeof(TSmgDeliverRep);

	return SendPacketToSmg((char *)&rSmgPacket, nLen);
}
int SMG_SendSubmitReq(TMsgHead rMsgHead, TSmgSubmitReq rSmgSubmitReq)
{
	TSmgPacket rSmgPacket;
	unsigned short nLen;
	
	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));
	if(rMsgHead.nCmdId != SMG_SubmitReq)
		return -1;
	memcpy(&rSmgPacket.rMsgHead, &rMsgHead, sizeof(TMsgHead));
	memcpy(&rSmgPacket.rMsgBody, &rSmgSubmitReq, sizeof(TSmgSubmitReq));

	nLen = sizeof(TMsgHead) + sizeof(TSmgSubmitReq);

	return SendPacketToSmg((char *)&rSmgPacket, nLen);
}

int SMG_SendCancleReq(TMsgHead rMsgHead, TSmgCancelReq rSmgCancelReq)
{
	TSmgPacket rSmgPacket;
	unsigned short nLen;
	
	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));
	if(rMsgHead.nCmdId != SMG_CancelReq)
		return -1;
	memcpy(&rSmgPacket.rMsgHead, &rMsgHead, sizeof(TMsgHead));
	memcpy(&rSmgPacket.rMsgBody, &rSmgCancelReq, sizeof(TSmgCancelReq));

	nLen = sizeof(TMsgHead) + sizeof(TSmgCancelReq);

	return SendPacketToSmg((char *)&rSmgPacket, nLen);
}

int SMG_SendMonitorAction(int nLinkId, int nActType, char *sMsg)
{
	TSmgPacket rSmgPacket;
	unsigned short nLen;
	
	TMsgHead rMsgHead;
	TMonitorMesg rMoniMesg;

	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));
	memset(&rMsgHead, 0x00, sizeof(TMsgHead));
	memset(&rMoniMesg, 0x00, sizeof(TMonitorMesg));

	rMsgHead.nLinkId = nLinkId;
	rMsgHead.nCmdId = SMG_Monitor;

	rMoniMesg.nMoniType = nActType;
	if(sMsg != NULL)
		strcpy(rMoniMesg.sMoniMsg, sMsg);


	memcpy(&rSmgPacket.rMsgHead, &rMsgHead, sizeof(TMsgHead));
	memcpy(&rSmgPacket.rMsgBody, &rMoniMesg, sizeof(TMonitorMesg));
	nLen = sizeof(TMsgHead) + sizeof(TMonitorMesg);

	return SendPacketToSmg((char *)&rSmgPacket, nLen);

}
// end define function for SMG client


/****************************************************************************************/

// begin define function for SMG server

static void OnSmgServerReceiveData(int nHandle,char *sIpAddr,int nPort,char *sBuf,unsigned short nLen)
{
	TSmgPacket rSmgPacket;
	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));
	if(nLen > sizeof(TSmgPacket))
		return;

	memcpy(&rSmgPacket, sBuf, nLen);

	rSmgPacket.rMsgHead.nLinkId = nHandle;
	strcpy(rSmgPacket.rMsgHead.sLinkIp, sIpAddr);
	rSmgPacket.rMsgHead.nPort = nPort;

	g_rSmgPacketQueue.WriteDataToQueue(&rSmgPacket);
}

static void OnSmgServerConnected(int nHandle,char *sIpAddr,unsigned short nPort)
{
	TSmgPacket rSmgPacket;

	rSmgPacket.rMsgHead.nLinkId = nHandle;
	rSmgPacket.rMsgHead.nCmdId = SMG_LinkUp;
	rSmgPacket.rMsgHead.nChannelId = 0;
	rSmgPacket.rMsgHead.nPort = nPort;
	strcpy(rSmgPacket.rMsgHead.sLinkIp, sIpAddr);

	g_rSmgPacketQueue.WriteDataToQueue(&rSmgPacket);
}

static void OnSmgServerDisconnected(int nHandle,char *sIpAddr,unsigned short nPort)
{
	TSmgPacket rSmgPacket;

	rSmgPacket.rMsgHead.nLinkId = nHandle;
	rSmgPacket.rMsgHead.nCmdId = SMG_LinkDown;
	rSmgPacket.rMsgHead.nChannelId = 0;
	rSmgPacket.rMsgHead.nPort = nPort;
	strcpy(rSmgPacket.rMsgHead.sLinkIp, sIpAddr);

	g_rSmgPacketQueue.WriteDataToQueue(&rSmgPacket);
}

int SMG_InitServer(int nPort)
{
	int nRet = 0;
    g_rSmgServer.rCommFunc_.OnRecvData = OnSmgServerReceiveData;
    g_rSmgServer.rCommFunc_.OnConnected = OnSmgServerConnected;
    g_rSmgServer.rCommFunc_.OnDisconnected = OnSmgServerDisconnected;

    if ( (nRet = g_rSmgServer.InitServer(nPort)) < 0 )
    {
		return -1;
    }
    return 0;
}

int SMG_GetServerEvent(TSmgPacket *prSmgPacket)
{
	int nCmdId;

	g_rSmgServer.RunServer();

	if(prSmgPacket == NULL)
		return -1;
	if(g_rSmgPacketQueue.ReadDataFromQueue(prSmgPacket) == 0)
	{
		nCmdId = prSmgPacket->rMsgHead.nCmdId;
		return nCmdId;
	}
	else
		return -1;
}

void SMG_CloseServer()
{
	g_rSmgServer.CloseServer();
}

int SMG_SendRegisterRep(TMsgHead rMsgHead, TSmgRegisterRep rSmgRegisterRep)
{
	TSmgPacket rSmgPacket;
	unsigned short nLen;
	
	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));
	if(rMsgHead.nCmdId != SMG_RegisterRep)
		return -1;
	memcpy(&rSmgPacket.rMsgHead, &rMsgHead, sizeof(TMsgHead));
	memcpy(&rSmgPacket.rMsgBody, &rSmgRegisterRep, sizeof(TSmgRegisterRep));

	nLen = sizeof(TMsgHead) + sizeof(TSmgRegisterRep);

	return g_rSmgServer.SendMsg(rMsgHead.nLinkId, (char *)&rSmgPacket, nLen);
}
int SMG_SendUnRegisterRep(TMsgHead rMsgHead, TSmgUnRegisterRep rSmgUnRegisterRep)
{
	TSmgPacket rSmgPacket;
	unsigned short nLen;
	
	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));
	if(rMsgHead.nCmdId != SMG_UnRegisterRep)
		return -1;
	memcpy(&rSmgPacket.rMsgHead, &rMsgHead, sizeof(TMsgHead));
	memcpy(&rSmgPacket.rMsgBody, &rSmgUnRegisterRep, sizeof(TSmgUnRegisterRep));

	nLen = sizeof(TMsgHead) + sizeof(TSmgUnRegisterRep);

	return g_rSmgServer.SendMsg(rMsgHead.nLinkId, (char *)&rSmgPacket, nLen);
}

int SMG_SendDeliverReq(TMsgHead rMsgHead, TSmgDeliverReq rSmgDeliverReq)
{
	TSmgPacket rSmgPacket;
	unsigned short nLen;
	
	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));
	if(rMsgHead.nCmdId != SMG_DeliverReq)
		return -1;
	memcpy(&rSmgPacket.rMsgHead, &rMsgHead, sizeof(TMsgHead));
	memcpy(&rSmgPacket.rMsgBody, &rSmgDeliverReq, sizeof(TSmgDeliverReq));

	nLen = sizeof(TMsgHead) + sizeof(TSmgDeliverReq);

	return g_rSmgServer.SendMsg(rMsgHead.nLinkId, (char *)&rSmgPacket, nLen);
}

int SMG_SendSubmitRep(TMsgHead rMsgHead, TSmgSubmitRep rSmgSubmitRep)
{
	TSmgPacket rSmgPacket;
	unsigned short nLen;
	
	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));
	if(rMsgHead.nCmdId != SMG_SubmitRep)
		return -1;
	memcpy(&rSmgPacket.rMsgHead, &rMsgHead, sizeof(TMsgHead));
	memcpy(&rSmgPacket.rMsgBody, &rSmgSubmitRep, sizeof(TSmgSubmitRep));

	nLen = sizeof(TMsgHead) + sizeof(TSmgSubmitRep);

	return g_rSmgServer.SendMsg(rMsgHead.nLinkId, (char *)&rSmgPacket, nLen);
}

int SMG_SendCancleRep(TMsgHead rMsgHead, TSmgCancelRep rSmgCancelRep)
{
	TSmgPacket rSmgPacket;
	unsigned short nLen;
	
	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));
	if(rMsgHead.nCmdId != SMG_CancelRep)
		return -1;
	memcpy(&rSmgPacket.rMsgHead, &rMsgHead, sizeof(TMsgHead));
	memcpy(&rSmgPacket.rMsgBody, &rSmgCancelRep, sizeof(TSmgCancelRep));

	nLen = sizeof(TMsgHead) + sizeof(TSmgCancelRep);

	return g_rSmgServer.SendMsg(rMsgHead.nLinkId, (char *)&rSmgPacket, nLen);
}

int SMG_SendMonitorMsg(int nLinkId, char *sMonMsg, unsigned short nLen)
{
	TMsgHead rMsgHead;
	char  sTmp[4096] = {0x00};

	int nMsgHeadLen = sizeof(TMsgHead);
	
	memset(&rMsgHead, 0x00, nMsgHeadLen);

	rMsgHead.nLinkId = nLinkId;
	rMsgHead.nCmdId = SMG_Monitor;

	memcpy(sTmp, &rMsgHead, nMsgHeadLen);
	memcpy(sTmp+nMsgHeadLen, sMonMsg, nLen);


	return g_rSmgServer.SendMsg(nLinkId, sTmp, nLen+nMsgHeadLen);
}

int SMG_SendReloadConfig(int nLinkId)
{
	TMsgHead rMsgHead;
	memset(&rMsgHead, 0x00, sizeof(TMsgHead));
	
	rMsgHead.nLinkId = nLinkId;

	rMsgHead.nCmdId = SMG_ReloadConfig;

	return g_rSmgServer.SendMsg(rMsgHead.nLinkId, (char *)&rMsgHead, sizeof(TMsgHead));
}

int SMG_SendReloadData(int nLinkId)
{
	TMsgHead rMsgHead;
	memset(&rMsgHead, 0x00, sizeof(TMsgHead));

	rMsgHead.nLinkId = nLinkId;
	rMsgHead.nCmdId = SMG_ReloadData;

	return g_rSmgServer.SendMsg(rMsgHead.nLinkId, (char *)&rMsgHead, sizeof(TMsgHead));
}

int SMG_SendServiceExit(int nLinkId)
{
	TMsgHead rMsgHead;
	memset(&rMsgHead, 0x00, sizeof(TMsgHead));

	rMsgHead.nLinkId = nLinkId;
	rMsgHead.nCmdId = SMG_ServiceExit;

	return g_rSmgServer.SendMsg(rMsgHead.nLinkId, (char *)&rMsgHead, sizeof(TMsgHead));
}


int SMG_SendOpationRegisterReq(TMsgHead rMsgHead, TSmgOpationRegisterReq rRegisterReq)
{
	TSmgPacket rSmgPacket;
	unsigned short nLen;
	
	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));
	if(rMsgHead.nCmdId != SMG_OpationReq)
		return -1;

	memcpy(&rSmgPacket.rMsgHead, &rMsgHead, sizeof(TMsgHead));
	memcpy(&rSmgPacket.rMsgBody, &rRegisterReq, sizeof(TSmgOpationRegisterReq));
	
	nLen = sizeof(TMsgHead) + sizeof(TSmgOpationRegisterReq);
	
	return g_rSmgServer.SendMsg(rMsgHead.nLinkId, (char *)&rSmgPacket, nLen);
}

int SMG_SendOpationUnRegisterReq(TMsgHead rMsgHead, TSmgOpationUnRegisterReq rUnRegisterReq)
{
	TSmgPacket rSmgPacket;
	unsigned short nLen;
	
	memset(&rSmgPacket, 0x00, sizeof(TSmgPacket));
	if(rMsgHead.nCmdId != SMG_OpationUnReq)
		return -1;

	memcpy(&rSmgPacket.rMsgHead, &rMsgHead, sizeof(TMsgHead));
	memcpy(&rSmgPacket.rMsgBody, &rUnRegisterReq, sizeof(TSmgOpationUnRegisterReq));
	
	nLen = sizeof(TMsgHead) + sizeof(TSmgOpationUnRegisterReq);
	
	return g_rSmgServer.SendMsg(rMsgHead.nLinkId, (char *)&rSmgPacket, nLen);
}
// end define function for SMG server