sgippdu.cpp

一个用vc开发的Sgip通讯程序

#include "stdafx.h"
#include "SGipPdu.h"

extern char SGIP_INI_FILE[100];
extern char SGIP_LOG_FILE[100];
extern char TPLS_LOG_FILE[100];

//短信拆分长度
int    SHORT_MESSAGE_SPLIT_LENGTH;

CSGipPdu::CSGipPdu()
{
	m_nSequenceNumber          = 0;
	SHORT_MESSAGE_SPLIT_LENGTH = 70;
}

CSGipPdu::~CSGipPdu()
{
}

void CSGipPdu::InitData(int nSourceNode,const char* szSPNumber,const char* szCorpId)
{
	m_nSourceNode = nSourceNode;
	m_strSPNumber.Format("%s",szSPNumber); //SP的接入号码
	m_strCorpId.Format("%s",szCorpId);     //企业代码（0-99999） 
	
}

unsigned char* CSGipPdu::GetBuffer()
{
	return (unsigned char*)m_szBuffer;
}

int CSGipPdu::GetLen()
{
	return m_nTotalLen;
}

void CSGipPdu::GetHeaderInfo(const char *szBuf,int &nCommandID,int &nSequence1,int &nSequence2,int &nSequence3)
{
	SSGipPduHeader *pstHeader;

	pstHeader =(SSGipPduHeader *)szBuf;
	nCommandID = ntohl(pstHeader->iCommandId);
	nSequence1 = ntohl(pstHeader->iSequenceNumber1);
	nSequence2 = ntohl(pstHeader->iSequenceNumber2);
	nSequence3 = ntohl(pstHeader->iSequenceNumber3);
}

char CSGipPdu::GetBindRespResult(const char *szBuf)
{
	SSGipBindResp stBindResp;

	memcpy(&stBindResp,szBuf +PDU_HEADER_SIZE,sizeof(SSGipBindResp));
	return stBindResp.cResult;
}

char CSGipPdu::GetSubmitRespResult(const char *szBuf)
{
	SSGipSubmitResp stSubmitResp;

	memcpy(&stSubmitResp,szBuf +PDU_HEADER_SIZE,sizeof(SSGipSubmitResp));
	return stSubmitResp.cResult;
}

void CSGipPdu::PacketHeader(int nCommandId,int nTotalLen)
{
	SSGipPduHeader stHeader;
	int nTime;
	char szTime[20];
	CTime stCurTime;

	memset(m_szBuffer,'\0',MAX_PACKET_SIZE);
	memset(&stHeader,'\0',PDU_HEADER_SIZE);
	stCurTime = CTime::GetCurrentTime();
	sprintf(szTime,"%02d%02d%02d%02d%02d",stCurTime.GetMonth(),stCurTime.GetDay(),
		stCurTime.GetHour(),stCurTime.GetMinute(),stCurTime.GetSecond());
	nTime = atol(szTime);
	stHeader.iMessageLength = htonl(nTotalLen);
	stHeader.iCommandId = htonl(nCommandId);
	stHeader.iSequenceNumber1 = htonl(m_nSourceNode);
	stHeader.iSequenceNumber2 = htonl(nTime);
	stHeader.iSequenceNumber3 = htonl(m_nSequenceNumber);
	m_iSequenceNumber1 = m_nSourceNode;
	m_iSequenceNumber2 = nTime;
	m_iSequenceNumber3 = m_nSequenceNumber;
	if ( m_nSequenceNumber != 0xffffffff )
		m_nSequenceNumber ++;
	else // Reset Serial Number 
		m_nSequenceNumber = 0;

	memcpy(m_szBuffer,&stHeader,PDU_HEADER_SIZE);
}

void CSGipPdu::PacketRespHeader(const char* szBuf,int nCommandId,int nTotalLen)
{
	SSGipPduHeader *pstHeader;

	pstHeader =(SSGipPduHeader *)szBuf;
	memset(m_szBuffer,'\0',MAX_PACKET_SIZE);
	pstHeader->iMessageLength = htonl(nTotalLen);
	pstHeader->iCommandId = htonl(nCommandId);

	memcpy(m_szBuffer,pstHeader,PDU_HEADER_SIZE);
}

void CSGipPdu::Bind(int cLoginType,const char* szLoginName,const char* szLoginPassword)
{
	SSGipBind stBind;

	m_nTotalLen = PDU_HEADER_SIZE + sizeof(SSGipBind);
	PacketHeader(SGIP_BIND,m_nTotalLen);

	memset(&stBind,'\0',sizeof(SSGipBind));
	stBind.cLoginType = cLoginType;
	strncpy(stBind.szLoginName,szLoginName,16);
	strncpy(stBind.szLoginPassword,szLoginPassword,16);

	memcpy(m_szBuffer + PDU_HEADER_SIZE ,&stBind,sizeof(SSGipBind));
}

void CSGipPdu::UnBind()
{
	m_nTotalLen = PDU_HEADER_SIZE;
	PacketHeader(SGIP_UNBIND,m_nTotalLen);
}

void CSGipPdu::BindResp(const char* szBuf,char cResult)
{
	SSGipBindResp stBindResp;

	m_nTotalLen = PDU_HEADER_SIZE + sizeof(SSGipBindResp);
	PacketRespHeader(szBuf,SGIP_BIND_RESP,m_nTotalLen);

	memset(&stBindResp,'\0',sizeof(SSGipBindResp));
	stBindResp.cResult = cResult;

	memcpy(m_szBuffer + PDU_HEADER_SIZE ,&stBindResp,sizeof(SSGipBindResp));
}

void CSGipPdu::UnBindResp(const char* szBuf)
{
	m_nTotalLen = PDU_HEADER_SIZE;
	PacketRespHeader(szBuf,SGIP_UNBIND_RESP,m_nTotalLen);
}

void CSGipPdu::SubmitSingle(const char* szUserNumber,const char* szMessageContent,const char* szChargeNumber,
							const char* szSender,const char* szServiceType,const char* szLinkID,char cFeeType,const char *szFeeValue,const char* szGivenValue,
							const char* szScheduleTime,char cMessageCoding,char cMOrelatetoMTFlag,int iReportFlag,int iPriority,int iTP_pid,int iTP_udhi,int iExpireTimeSpan)
{
	//短消息
	SSGipSubmitSingle stSubmit;

/*  // modify by ycf 20021008
	if(iReportFlag<0 || iReportFlag>2)
	{
		iReportFlag=0;
	}
*/
	m_nTotalLen = PDU_HEADER_SIZE + sizeof(SSGipSubmitSingle) + strlen(szMessageContent) - MAX_MESSAGE_LENGTH  ;
	PacketHeader(SGIP_SUBMIT,m_nTotalLen);

	memset(&stSubmit,'\0',sizeof(SSGipSubmitSingle));
	strcpy(stSubmit.szSPNumber,szSender);						//SP的接入号码//m_strSPNumber
	stSubmit.szSPNumber[21]='\0';
	strncpy(stSubmit.szChargeNumber,szChargeNumber,21);		//付费号码，手机号码前加“86”国别标志。若为空，则该条消息的费用由
															//UserNumber代表的用户支付，如果为全零字符串“000000000000000000000”，则费用由SP支付。
	stSubmit.cUserCount =1;									//接收短消息的手机数量（1--100）
	strncpy(stSubmit.szUserNumber,szUserNumber,21);			//接收短消息的手机号码，手机号码前加“86”
	strncpy(stSubmit.szCorpId,m_strCorpId,5);				//企业代码（0-99999）
	strncpy(stSubmit.szServiceType,szServiceType,10);		//业务代码，由SP定义
	stSubmit.cFeeType = cFeeType;							//计费类型
	strncpy(stSubmit.szFeeValue,szFeeValue,6);				//该条短消息的收费值，单位为分，由SP定义，对于包月制收费的用户，该值为月租费的值（范围0-99999）
	strncpy(stSubmit.szGivenValue,szGivenValue,6);			//赠送用户的话费，单位为分，由SP定义，特指由SP向用户发送广告时的赠送话费
	stSubmit.cAgentFlag = 0;								//代收费标志，0：应收；1：实收
	stSubmit.cMorelatetoMTFlag = cMOrelatetoMTFlag;			//引起MT消息的原因 0-MO点播引起的第一条MT消息；
															//1-MO点播引起的第一条MT消息；2-非MO点播引起的MT消息；3-系统反馈引起的MT消息
	stSubmit.cPriority = iPriority;									//优先级0-9从低到高，默认为0
//------------------------------------------------------------------------------
	//add by gyh 2003-7-11
	if( iExpireTimeSpan > 0 ){
		CTime tCurTime ;
		tCurTime = CTime::GetCurrentTime() ;
		CTime t ;
		CTimeSpan ts( iExpireTimeSpan ); // seconds
		t = tCurTime + ts ;
		char szTime[20] ;
		int iYear = t.GetYear() %100 ;
		sprintf(szTime,"%02d%02d%02d%02d%02d%02d032+",
			iYear,t.GetMonth(),t.GetDay(),t.GetHour(),t.GetMinute(),t.GetSecond() );
		strncpy(stSubmit.szExpireTime,szTime,16);			  //短消息寿命的终止时间，如果为空，表示使用短消息中心的缺省值。
															  //时间内容为16个字符，格式为"yymmddhhmmsstnnp" ，其中"tnnp"取固定值"032+"，即默认系统为北京时间
	}
//------------------------------------------------------------------------------
	if(szScheduleTime != NULL && strlen(szScheduleTime)>0)
	{
		char szTime[20];
		sprintf(szTime,"%s032+",szScheduleTime);
		strncpy(stSubmit.szScheduleTime,szTime,16);			//短消息定时发送的时间，如果为空，表示立刻发送该短消息。时间内容为16个字符，格式为"yymmddhhmmsstnnp" ，其中"tnnp"取固定值"032+"，即默认系统为北京时间
	}

	stSubmit.cReportFlag =iReportFlag;		  /* 状态报告标记 
											  0-该条消息只有最后出错时要返回状态报告
											  1-该条消息无论最后是否成功都要返回状态报告
											  2-该条消息不需要返回状态报告
											  其它-保留
											缺省设置为0
												*/
	stSubmit.cTP_pid  = iTP_pid;			  //GSM协议类型。详细解释请参考GSM03.40中的9.2.3.9
	stSubmit.cTP_udhi = iTP_udhi;			  //GSM协议类型。详细解释请参考GSM03.40中的9.2.3.23,仅使用1位，右对齐
	stSubmit.cMessageCoding = cMessageCoding;  
	stSubmit.cMessageType = 0;		  //信息类型：0-短消息信息;其它：待定
	stSubmit.nMessageLength = htonl(strlen(szMessageContent));	  //短消息的长度
//	strncpy(stSubmit.szMessageContent,szMessageContent,MAX_MESSAGE_LENGTH);
	strncpy(stSubmit.szMessageContent,szMessageContent,strlen(szMessageContent));
	strcat(stSubmit.szMessageContent,szLinkID);
//	strncpy(stSubmit.szReserve,szLinkID,8);					//MO和MT之间一一对应的LinkID

	memcpy(m_szBuffer + PDU_HEADER_SIZE ,&stSubmit,m_nTotalLen - PDU_HEADER_SIZE);
}

void CSGipPdu::DeliverResp(const char* szBuf,char cResult)
{
	SSGipDeliverResp stDeliverResp;

	m_nTotalLen = PDU_HEADER_SIZE + sizeof(SSGipDeliverResp);
	PacketRespHeader(szBuf,SGIP_DELIVER_RESP,m_nTotalLen);

	memset(&stDeliverResp,'\0',sizeof(SSGipDeliverResp));
	stDeliverResp.cResult = cResult;

	memcpy(m_szBuffer + PDU_HEADER_SIZE ,&stDeliverResp,sizeof(SSGipDeliverResp));
}

void CSGipPdu::ReportResp(const char* szBuf,char cResult)
{
	SSGipReportResp stReportResp;

	m_nTotalLen = PDU_HEADER_SIZE + sizeof(SSGipReportResp);
	PacketRespHeader(szBuf,SGIP_REPORT_RESP,m_nTotalLen);

	memset(&stReportResp,'\0',sizeof(SSGipReportResp));
	stReportResp.cResult = cResult;

	memcpy(m_szBuffer + PDU_HEADER_SIZE ,&stReportResp,sizeof(SSGipReportResp));
}

void GetStatusMessage(unsigned long status,char * szMessage)
{
  switch(status)
  {
  case SGIP_OK:
	  strcpy(szMessage,"[返回状态]无错误，命令正确接收");
	  break;
  case SGIP_ERRLOGIN:
	  strcpy(szMessage,"[返回状态]非法登录，如登录名、口令出错、登录名与口令不符等。");
	  break;
  case SGIP_DUPLOGIN:
	  strcpy(szMessage,"[返回状态]重复登录，如在同一TCP/IP连接中连续两次以上请求登录。");
	  break;
  case SGIP_CONNECTIONTOOMUCH:
	  strcpy(szMessage,"[返回状态]连接过多，指单个节点要求同时建立的连接数过多。");
	  break;
  case SGIP_ERRLOGINTYPE:
	  strcpy(szMessage,"[返回状态]登录类型错，指bind命令中的logintype字段出错。");
	  break;
  case SGIP_ERRPARAM:
	  strcpy(szMessage,"[返回状态]参数格式错，指命令中参数值与参数类型不符或与协议规定的范围不符。");
	  break;
  case SGIP_ERRMOBILENUMBER:
	  strcpy(szMessage,"[返回状态]非法手机号码，协议中所有手机号码字段出现非86130号码或手机号码前未加“86”时都应报错。");
	  break;
  case SGIP_ERRCOMMANDID:
	  strcpy(szMessage,"[返回状态]消息ID错");
	  break;
  case SGIP_ERRMSGLENGTH:
	  strcpy(szMessage,"[返回状态]信息长度错");
	  break;
  case SGIP_ERRSEQUENCE:
	  strcpy(szMessage,"[返回状态]非法序列号，包括序列号重复、序列号格式错误等");
	  break;
  case SGIP_ERROPERATORGNS:
	  strcpy(szMessage,"[返回状态]非法操作GNS");
	  break;
  case SGIP_ERRTODEST:
	  strcpy(szMessage,"[返回状态]目的地址不可达，指路由表存在路由且消息路由正确但被路由的节点暂时不能提供服务的情况");
	  break;
  case SGIP_ERRROUTE:
	  strcpy(szMessage,"[返回状态]路由错，指路由表存在路由但消息路由出错的情况，如转错SMG等");
	  break;
  case SGIP_ROUTENOTEXIST:
	  strcpy(szMessage,"[返回状态]路由不存在，指消息路由的节点在路由表中不存在");
	  break;
  case SGIP_ERRCHARGENUMBER:
	  strcpy(szMessage,"[返回状态]计费号码无效，鉴权不成功时反馈的错误信息");
	  break;
  case SGIP_CANNOTCOMMUNITE:
	  strcpy(szMessage,"[返回状态]用户不能通信（如不在服务区、未开机等情况）");
	  break;
  case SGIP_MEMORYFULL:
	  strcpy(szMessage,"[返回状态]手机内存不足");
	  break;
  case SGIP_NOTSUPPORTSHORTMSG:
	  strcpy(szMessage,"[返回状态]手机不支持短消息");
	  break;
  case SGIP_RECVSHORTMSGERR:
	  strcpy(szMessage,"[返回状态]手机接收短消息出现错误");
	  break;
  case SGIP_UNKNOWNUSER:
	  strcpy(szMessage,"[返回状态]不知道的用户");
	  break;
  case SGIP_NOFUNCTION:
	  strcpy(szMessage,"[返回状态]不提供此功能");
	  break;
  case SGIP_INVALIDDEVICE:
	  strcpy(szMessage,"[返回状态]非法设备");
	  break;
  case SGIP_SYSTEMFAILED:
	  strcpy(szMessage,"[返回状态]系统失败");
	  break;
  default:
	  strcpy(szMessage,"[返回状态]未知的错误");
	  break;
  }
}

BOOL IsDigital(char cSrc)
{
	if((cSrc>='0')&&(cSrc<='9'))
        return true;
	else
		return false;
}

CString LeftTChar(CString kk, int length, int pos, int &back)
{//把字母数字空格等单字节的字符当作双字节，一个汉字为双字节，因此这里定义两个字节为一个汉字
	long  size = kk.GetLength();
	CString NullStr("") ;
	if (!size || pos>size || pos<0) return NullStr;//当源字串为空或起始位置非法时,返回空串
	char *m_newBuffer = new char [size];////////
    LPSTR newTempPtr = m_newBuffer;
	int iCounter;
	char TCharbuf[255];
    //以防止将一半汉字分为两行
	unsigned short halfChinese=0;
	int i=pos;
    iCounter = 0 ;
	while(i<size && iCounter<length){
		*newTempPtr = kk.GetAt(i);
		//大于0xa1的字节为汉字字节
		if((unsigned char)*newTempPtr >= 0xa1)
			halfChinese++;