sgip.cpp

1、自己编写的遵循SGIP1.1的短信网关模拟程序。仅供测试、学习。 2、该程序只实现了SGIP1.1协议的一部分。

// Sgip.cpp: implementation of the CSgip class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "SgipServiceDemo.h"
#include "Sgip.h"
#include "Parsecstring.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

extern unsigned long CreateGlobalCycleNo();
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CSgip::CSgip()
{

}

CSgip::~CSgip()
{

}

//////////////////////////////////////////////////////////////////
//some functions for packaging

unsigned long CSgip::SetTimeItem()
{
	CTime tm = CTime::GetCurrentTime();
	int iMonth = tm.GetMonth();
	int iDay = tm.GetDay();
	int iHour = tm.GetHour();
	int iMinute = tm.GetMinute();
	int iSecond = tm.GetSecond();
	return (iMonth * 100000000 + iDay * 1000000 + iHour * 10000 + iMinute * 100 + iSecond);
}

long CSgip::SetHeadData(int iCommand, int iContentLen, long lCycleNo)
{
	int iLen;
	m_Head_def.Command_id = htonl(iCommand);
	m_Head_def.Sequence_number.ulSourceID = htonl(m_ulSourceID);
	m_Head_def.Sequence_number.ulTime = htonl(SetTimeItem());
	m_Head_def.Sequence_number.ulCycle = htonl(CreateGlobalCycleNo());
	switch (iCommand)
	{
	case SGIP_bind:
		iLen = sizeof(t_HEAD_DEF) + sizeof(t_BIND_DEF);
		break;
	case SGIP_unbind:
		iLen = sizeof(t_HEAD_DEF);
		break;
	case SGIP_submit_sm:
		iLen = sizeof(t_HEAD_DEF) + sizeof(t_SUBMIT_SM_DEF) + iContentLen + 8;
		m_Head_def.Sequence_number.ulCycle = htonl(lCycleNo);
		break;
	case SGIP_deliver_sm_resp:
		iLen = sizeof(t_HEAD_DEF) + sizeof(t_RESP_DEF);
		break;
	case SGIP_report_resp:
		iLen = sizeof(t_HEAD_DEF) + sizeof(t_RESP_DEF);
		break;
	}
	m_Head_def.Command_length = htonl(iLen);
	return iLen;
}

long CSgip::SetBindPDU()
{
	int iLen = SetHeadData(SGIP_bind);

	t_BIND_DEF t_Bind;
	memset(&t_Bind, 0, sizeof(t_BIND_DEF));
	t_Bind.LoginType = 2;
	strcpy(t_Bind.LoginName, m_strLoginName);
	strcpy(t_Bind.LoginPassword, m_strLoginPassword);

	memcpy(m_szContent, &m_Head_def, sizeof(t_HEAD_DEF));
	memmove(m_szContent + sizeof(t_HEAD_DEF), &t_Bind, sizeof(t_BIND_DEF));
	return iLen;
}

long CSgip::SetUnbindPDU()
{
	int iLen = SetHeadData(SGIP_unbind);
	memset(m_szContent, 0, sizeof(m_szContent));
	memcpy(m_szContent, &m_Head_def, sizeof(t_HEAD_DEF));
	return iLen;
}

//////////////////////////////////////////////////////////
//new setsubmitpdu(for sgipservice version2.0)
//retval: -1:error
/////////////////////////////////////////////////////////////////////
int CSgip::SetSubmitPDU(unsigned long ulSgipSerialNo, unsigned long ulSgipSerialTime, CString strChargeNum, 
						int iUserCount, CString strUserNum,
						CString strContent, CString strExpireTime,
						CString strSheduleTime, int iReportFlag,
						int iMsgCoding)
{
	//ASSERT( 0<iUserCount>=100);
	//++验证数据!!!

	int iAllLen;
	int iSubBodyLen;
	int iContentLen;
	char szTemp[2048];
	switch(iMsgCoding)
	{
	case MsgCode_ASCII://not suport,make default
		iContentLen = strContent.GetLength();
		strcpy(m_szBuffer, strContent);
		break;
	case MsgCode_WriteSIM://not suport,make default
		iContentLen = strContent.GetLength();
		strcpy(m_szBuffer, strContent);
		break;
	case MsgCode_Binary:
		if ((iContentLen = TransStr2Bin(strContent)) == -1)
			return -1;	//有字符不在'0' - 'F'
		break;
	case MsgCode_UCS2://not suport,make default
		iContentLen = strContent.GetLength();
		strcpy(m_szBuffer, strContent);
		break;
	case MsgCode_GBK://not suport,make default
		iContentLen = strContent.GetLength();
		strcpy(m_szBuffer, strContent);
		break;
	default://unknow,make default
		iContentLen = strContent.GetLength();
		strcpy(m_szBuffer, strContent);
		break;
	}
	iSubBodyLen = 21+21+1+iUserCount*21+5+10+1+6+6+1+1+1+16+16+1+1+1+1+1+4+iContentLen+8;
	//set head data
	m_Head_def.Command_id = htonl(SGIP_submit_sm);
	m_Head_def.Sequence_number.ulSourceID = htonl(m_ulSourceID);
	m_Head_def.Sequence_number.ulTime = htonl(ulSgipSerialTime);
	m_Head_def.Sequence_number.ulCycle = htonl(ulSgipSerialNo);
	iAllLen = sizeof(t_HEAD_DEF) + iSubBodyLen;
	m_Head_def.Command_length = htonl(iAllLen);

	memcpy(m_szContent, &m_Head_def, sizeof(t_HEAD_DEF));

	int iOffset;
	char SPNumber[21];
	memset(SPNumber, 0, 21);
	itoa(m_lSPNumber, szTemp, 10);
	strcpy(SPNumber, szTemp);
	memmove(m_szContent + sizeof(t_HEAD_DEF), SPNumber, 21);
	iOffset = 21;

	char ChargeNumber[21];
	memset(ChargeNumber, 0, 21);
	CString str;
	str = strChargeNum;
	strcpy(ChargeNumber, str);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, ChargeNumber, 21);
	iOffset = iOffset + 21;

	BYTE UserCount;
	memset(&UserCount, 0, 1);
	UserCount = iUserCount;
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, &UserCount, 1);
	iOffset = iOffset + 1;

	//打包目的手机号!
	CParsecstring parcstr(&strUserNum);
	CString strnextphone;
	int i;
	for(i = 0; i <UserCount ; i++)
	{
		if(parcstr.GetNextStr(strnextphone) != -1)
		{
			strnextphone = "86" + strnextphone;
			memset(szTemp,0,21);
			strcpy(szTemp,strnextphone);
			memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset,szTemp,21);
			iOffset = iOffset + 21;
		}
		else
		{//UserCount 不与 strUserNum的个数符合!
		 //(这个前面已经有验证过了,应该不会再发生!)
			TRACE("SetSubmitPDU: UserCount 不与 strUserNum的个数符合!");
		}
	}

	char CorpId[5];
	memset(CorpId, 0, 5);
	sprintf(CorpId, "%d", m_lCorpID);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, CorpId, 5);
	iOffset = iOffset + 5;

	char ServiceType[10];
	memset(ServiceType, 0, 10);
	sprintf(ServiceType, "%d", 1);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, ServiceType, 10);
	iOffset = iOffset + 10;
	
	BYTE FeeType;
	memset(&FeeType, 0, 1);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, &FeeType, 1);
	iOffset = iOffset + 1;

	char FeeValue[6];
	memset(FeeValue, 0, 6);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, FeeValue, 6);
	iOffset = iOffset + 6;

	char GivenValue[6];
	memset(GivenValue, 0, 6);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, GivenValue, 6);
	iOffset = iOffset + 6;

	BYTE AgentFlag;
	memset(&AgentFlag, 0, 1);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, &AgentFlag, 1);
	iOffset = iOffset + 1;

	BYTE MorelateoMTFlag;
	memset(&MorelateoMTFlag, 0, 1);
	MorelateoMTFlag = 2;
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, &MorelateoMTFlag, 1);
	iOffset = iOffset + 1;

	BYTE Priority;
	memset(&Priority, 0, 1);
	Priority = 0;
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, &Priority, 1);
	iOffset = iOffset + 1;

	char ExpireTime[16];
	memset(ExpireTime, 0, 16);
	if(strExpireTime != "")
	{
		strcpy(ExpireTime, strExpireTime);
	}
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, ExpireTime, 16);
	iOffset = iOffset + 16;

	char SheduleTime[16];
	memset(SheduleTime, 0, 16);
	if(strSheduleTime != "")
	{
		strcpy(SheduleTime, strSheduleTime);
	}
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, SheduleTime, 16);
	iOffset = iOffset + 16;

	BYTE ReportFlag;
	memset(&ReportFlag, 0, 1);
	ReportFlag = iReportFlag;
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, &ReportFlag, 1);
	iOffset = iOffset + 1;

	BYTE TP_pid;
	memset(&TP_pid, 0, 1);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, &TP_pid, 1);
	iOffset = iOffset + 1;

	BYTE TP_udhi;
	memset(&TP_udhi, 0, 1);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, &TP_udhi, 1);
	iOffset = iOffset + 1;

	BYTE MessageCoding; 
	memset(&MessageCoding, 0, 1);
	MessageCoding = iMsgCoding;
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, &MessageCoding, 1);
	iOffset = iOffset + 1;

	BYTE MessageType;
	memset(&MessageType, 0, 1);
	MessageType = 0;
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, &MessageType, 1);
	iOffset = iOffset + 1;

	long  MessageLength;
	memset(&MessageLength, 0, 4);
	MessageLength = htonl(iContentLen);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, &MessageLength, 4);
	iOffset = iOffset + 4;

	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset,m_szBuffer, iContentLen);
	iOffset = iOffset + iContentLen;

	char szReserve[8];
	memset(szReserve, 0, 8);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset,szReserve, 8);
	return iAllLen;
}

int CSgip::SetDeliverPDU(unsigned long ulSgipSerialNo, unsigned long ulSgipSerialTime, CString strUserNum, CString strContent, int iMsgCoding)
{
	int iAllLen;
	int iSubBodyLen;
	int iContentLen;
	char szTemp[2048];
	switch(iMsgCoding)
	{
	case MsgCode_ASCII://not suport,make default
		iContentLen = strContent.GetLength();
		strcpy(m_szBuffer, strContent);
		break;
	case MsgCode_WriteSIM://not suport,make default
		iContentLen = strContent.GetLength();
		strcpy(m_szBuffer, strContent);
		break;
	case MsgCode_Binary:
		if ((iContentLen = TransStr2Bin(strContent)) == -1)
			return -1;	//有字符不在'0' - 'F'
		break;
	case MsgCode_UCS2://not suport,make default
		iContentLen = strContent.GetLength();
		strcpy(m_szBuffer, strContent);
		break;
	case MsgCode_GBK://not suport,make default
		iContentLen = strContent.GetLength();
		strcpy(m_szBuffer, strContent);
		break;
	default://unknow,make default
		iContentLen = strContent.GetLength();
		strcpy(m_szBuffer, strContent);
		break;
	}
	iSubBodyLen = 21+21+1+1+1+4+iContentLen+8;
	//set head data
	m_Head_def.Command_id = htonl(SGIP_deliver_sm);
	m_Head_def.Sequence_number.ulSourceID = htonl(m_ulSourceID);
	m_Head_def.Sequence_number.ulTime = htonl(ulSgipSerialTime);
	m_Head_def.Sequence_number.ulCycle = htonl(ulSgipSerialNo);
	iAllLen = sizeof(t_HEAD_DEF) + iSubBodyLen;
	m_Head_def.Command_length = htonl(iAllLen);

	memcpy(m_szContent, &m_Head_def, sizeof(t_HEAD_DEF));

	int iOffset;
	char UserNumber[21];
	memset(UserNumber, 0, 21);
	CString str;
	str = strUserNum;
	strcpy(UserNumber, str);
	memmove(m_szContent + sizeof(t_HEAD_DEF) , UserNumber, 21);
	iOffset = 21;

	char SPNumber[21];
	memset(SPNumber, 0, 21);
	itoa(m_lSPNumber, szTemp, 10);
	strcpy(SPNumber, szTemp);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, SPNumber, 21);
	iOffset = iOffset + 21;

	BYTE IP_pid;
	memset(&IP_pid, 0, 1);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, &IP_pid, 1);
	iOffset = iOffset + 1;

	BYTE IP_udhi;
	memset(&IP_udhi, 0, 1);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, &IP_udhi, 1);
	iOffset = iOffset + 1;

	BYTE MessageCoding; 
	memset(&MessageCoding, 0, 1);
	MessageCoding = iMsgCoding;
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, &MessageCoding, 1);
	iOffset = iOffset + 1;

	long  MessageLength;
	memset(&MessageLength, 0, 4);
	MessageLength = htonl(iContentLen);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset, &MessageLength, 4);
	iOffset = iOffset + 4;

	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset,m_szBuffer, iContentLen);
	iOffset = iOffset + iContentLen;

	char szReserve[8];
	memset(szReserve, 0, 8);
	memmove(m_szContent + sizeof(t_HEAD_DEF) + iOffset,szReserve, 8);
	return iAllLen;
}
//////////////////////////////////////////////////////
//ENCODE STR FUNCTION
int CSgip::TransStr2Bin(CString str)
{
	int iLen = str.GetLength();
	if (iLen % 2)
	{
		str += "F";
		iLen++;
	}
	int j = 0;
	unsigned char sz1, sz2;
	for (int i = 0; i < iLen; i++)
	{
		sz1 = Hex2Dec(str.GetAt(i++));
		sz2 = Hex2Dec(str.GetAt(i));
		if (sz1 > 16 || sz2 > 16)
			return -1;
		m_szBuffer[j++] = (sz1 << 4) + sz2;
	}
	return iLen / 2 ;
}

CString CSgip::TransBin2Str(char* szBuff, int iLen)
{
	CString strRet;
	char sz[4096];
	char* psz = szBuff;
	int j = 0;
	for( int i = 0; i < iLen; i++)
	{
		sz[j++] = DecToHex(((*psz) & 0xf0) >> 4);
		sz[j++] = DecToHex(((*psz++) & 0x0f));
	}
	if (sz[j - 1] == 'F')
		sz[j - 1] = 0;
	else
		sz[j] = 0;	
	strRet = sz;
	return strRet;
}

void CSgip::TransUCS2(char* szBuff)
{
	char sz1, sz2, *sz;
	char* p = szBuff;
	while(1)
	{
		sz1 = *(p++);
		sz2 = *(p++);
		sz = p;
		if (sz1 != 0 || sz2 != 0)
		{
			*(--sz) = sz1;
			*(--sz) = sz2;
		}
		else 
		{
			break;
		}
	}
}

int CSgip::TransStr2UCS2(CString str)
{
	int iLen = str.GetLength() * 2;
	BSTR bstr;
	bstr = str.AllocSysString();
	memcpy(m_szBuffer, bstr, iLen);
	TransUCS2(m_szBuffer);
	return iLen;
}