cmppmessage.cpp

CMPP3.0模拟网关

		index += DecodeData(in + index, (char &)m_nTP_udhi);

		index += DecodeData(in + index, (char &)m_nMsgFmt);
		index += DecodeData(in + index, m_sSource_Addr, 6);
		index += DecodeData(in + index, m_sFeeType,2);
		index += DecodeData(in + index, m_sFeeCode,6);
		index += DecodeData(in + index, m_sValidTime,17);
		index += DecodeData(in + index, m_sAtTime,17);
		index += DecodeData(in + index, m_sSrcTerminalID, 21);
		index += DecodeData(in + index, (char &)m_nDestUsrTl);
		for(i = 0; i < m_nDestUsrTl; i++)
			index += DecodeData(in + index, m_sDestTerminalIDs[i], 21);
		index += DecodeData(in + index, (char &)m_nMsgLength);
		index += DecodeData(in + index, m_sMsgContent, m_nMsgLength);
		index += DecodeData(in + index, reserve, 8);
		m_sMsgContent[m_nMsgLength] = 0;
		break;
	case CMPP_Fwd_REP:
		index += DecodeData(in + index, (__int64 &)m_nMsgID);
		index += DecodeData(in + index, (char &)m_nPKTotal);
		index += DecodeData(in + index, (char &)m_nPKNumber);
		index += DecodeData(in + index, (char &)m_nResult);
		break;
	default:
		return 1;
	}

	if (index == totallen) m_ValidMessage = true;
	return 1;
}

void CCmppMessage::Set_Connect(const char *icp_id, const char *AuthenticateICP,bool use_9_byte)
{
	m_nCommandID = CMPP_Connect;
	FillData(m_sSource_Addr, icp_id, 6);
	MakeAuthIcp(AuthenticateICP, use_9_byte);
}

void CCmppMessage::Set_Connect_REP(char status, const char *AuthenticateISMG)
{
	m_nCommandID = CMPP_Connect_REP;
	m_nStatus = status;
	MakeAuthISMG(AuthenticateISMG);
}

void CCmppMessage::Set_Terminate()
{
	m_nCommandID = CMPP_Terminate;
}

void CCmppMessage::Set_Terminate_REP()
{
	m_nCommandID = CMPP_Terminate_REP;
}

void CCmppMessage::Set_Submit(__int64 msg_id,
				    int pk_total,
					int pk_num,
					int msg_level, 
					const char *service_id,
					BYTE Fee_UserType,
					const char *Fee_terminal_id,
					int TP_pid,
					int TP_udhi,
					int msg_fmt,
					const char *icp_id,
					const char *fee_type,
					const char *fee_code,
					const char *valid_time,
					const char *at_time,
					const char *src_term_id,
					int dest_term_num,
					const char **dest_term_id,
					int msg_len,
					const char *msg,
					int regdelivery)
{
	m_nCommandID = CMPP_Submit;
	m_nMsgID = msg_id;
	m_nPKTotal = pk_total;
	m_nPKNumber = pk_num;
	m_nRegisteredDelivery = regdelivery;
	m_nMsgLevel = msg_level;
	FillData(m_sServiceID, service_id, 10);
	m_nFee_UserType = Fee_UserType;
	FillData(m_sFeeTerminalID, Fee_terminal_id, 21);
	m_nTP_pid = TP_pid;
	m_nTP_udhi = TP_udhi;
	m_nMsgFmt = msg_fmt;
	FillData(m_sSource_Addr, icp_id, 6);
	memcpy(m_sFeeType, fee_type, 2);
	memcpy(m_sFeeCode, fee_code, 6);
	
	if (valid_time != NULL && strlen(valid_time) != VALID_UTCTIMELENG)
		valid_time = "";
	if( at_time!=NULL&&strlen(at_time)!=VALID_UTCTIMELENG )
		at_time="";

	FillData(m_sValidTime, valid_time, 17);
	FillData(m_sAtTime, at_time, 17);

	FillData(m_sSrcTerminalID, src_term_id, 21);
	if (dest_term_num < 0) dest_term_num = 0;
	else if (dest_term_num > 100) dest_term_num = 100;
	m_nDestUsrTl = dest_term_num;
	for (int i = 0; i < dest_term_num; i++)
		FillData(m_sDestTerminalIDs[i], dest_term_id[i], 21);
	if (msg_len < 0) msg_len = 0;
	else if (msg_len > 140) msg_len = 140;
	m_nMsgLength = msg_len;
	memcpy(m_sMsgContent, msg, msg_len);
//	if(m_nUseUnicode)
//		LocalUnicodeOrder(m_nMsgFmt, m_sMsgContent, m_nMsgLength);
	m_sMsgContent[msg_len] = 0;
}

void CCmppMessage::Set_Submit_REP(__int64 msg_id, int result)
{
	m_nCommandID = CMPP_Submit_REP;
	m_nMsgID = msg_id;
//	m_nTLSAVailable = use_tls;
	m_nResult = result;
}

void CCmppMessage::Set_Query(const char *time1, int query_type, const char *query_code)
{
	m_nCommandID = CMPP_Query;
//	m_nTLSAVailable = use_tls;
	FillData(m_sTime, time1, 8);
	m_nQueryType = query_type;
	FillData(m_sQueryCode, query_code, 10);
}

void CCmppMessage::Set_Query_REP(const char *time1, int query_type, const char *query_code,
		long mt_tlmsg, long mt_tlusr, long mt_scs, long mt_wt, long mt_fl,
		long mo_scs, long mo_wt, long mo_fl)
{
	m_nCommandID = CMPP_Query_REP;
//	m_nTLSAVailable = use_tls;
	FillData(m_sTime, time1, 8);
	m_nQueryType = query_type;
	FillData(m_sQueryCode, query_code, 10);
	m_nMT_TLMsg = mt_tlmsg;
	m_nMT_TLUsr = mt_tlusr;
	m_nMT_Scs = mt_scs;
	m_nMT_WT = mt_wt;
	m_nMT_FL = mt_fl;
	m_nMO_Scs = mo_scs;
	m_nMO_WT = mo_wt;
	m_nMO_FL = mo_fl;
}

void CCmppMessage::Set_Deliver(__int64 msg_id, const char *Destnationid, const char *service_id, 
		int TP_pid, int TP_udhi, int msg_fmt, const char *src_term_id, int msg_len, const char *msg)
{
	m_nCommandID = CMPP_Deliver;
	m_nMsgID = msg_id;
	FillData(m_sDestnation_id, Destnationid, 21);

	FillData(m_sServiceID, service_id, 10);
//	FillData(m_sSrcTerminalID, src_term_id, 21);
	m_nTP_pid = TP_pid;
	m_nTP_udhi = TP_udhi;
	m_nMsgFmt = msg_fmt;
	FillData(m_sSrcTerminalID, src_term_id, 21);
	m_nRegisteredDelivery=0;

	if (msg_len < 0) msg_len = 0;
	else if (msg_len > 140) msg_len = 140;
	m_nMsgLength = msg_len;
	memcpy(m_sMsgContent, msg, msg_len);
	m_sMsgContent[msg_len] = 0;
}

void CCmppMessage::Set_DeliverStatus(__int64 msg_id, const char *Destnationid, const char *service_id, 
		int TP_pid, int TP_udhi, int msg_fmt, const char *src_term_id, int msg_len, __int64 MsgID,
		const char* status , const char* sTimeSend,const char* sTimeDone, const char* sDestterminalid, int nSmscSequence)
{
	m_nCommandID = CMPP_Deliver;
	m_nMsgID = msg_id;
	FillData(m_sDestnation_id, Destnationid, 21);//have bingo
	FillData(m_sServiceID, service_id, 10);
	FillData(m_sSrcTerminalID, src_term_id, 21);
	m_nTP_pid = TP_pid;
	m_nTP_udhi = TP_udhi;
	m_nMsgFmt = msg_fmt;
	m_nRegisteredDelivery=1;

	if (msg_len < 0) msg_len = 0;
	else if (msg_len > 140) msg_len = 140;
	m_nMsgLength = msg_len;	//FillData(m_sMsgContent, msg, msg_len);
	m_nMsgIDForStatus = MsgID;
	FillData(m_sMTStatus, status, 7);
	FillData(m_sSendtime, sTimeSend, 10);
	FillData(m_sDonetime, sTimeDone, 10);
	FillData(m_sDest_terminal_id, sDestterminalid, 21);
	m_nSMSC_sequence = nSmscSequence;

}

void CCmppMessage::Set_Deliver_REP(__int64 msg_id, int result)
{
	m_nCommandID = CMPP_Deliver_REP;
	m_nMsgID = msg_id;
//	m_nTLSAVailable = use_tls;
	m_nResult = result;
}

void CCmppMessage::Set_Cancel(__int64 msg_id)
{
	m_nCommandID = CMPP_Cancel;
	m_nMsgID = msg_id;
//	m_nTLSAVailable = use_tls;
}

void CCmppMessage::Set_Cancel_REP(int success_id)
{
	m_nCommandID = CMPP_Cancel_REP;
//	m_nTLSAVailable = use_tls;
	m_nSuccessID = success_id;
}

void CCmppMessage::Set_Active_Test() 
{
	m_nCommandID = CMPP_Active_Test;
	//m_nTLSAVailable = use_tls;
}

void CCmppMessage::Set_Active_Test_REP(int success_id)//bool use_tls, int success_id)
{
	m_nCommandID = CMPP_Active_Test_REP;
	//m_nTLSAVailable = use_tls;
	m_nSuccessID = success_id;
}

void CCmppMessage::Set_Fwd(const char *src_id, const char *dst_id, int nodes_cnt, int msg_fwd_type, 
		__int64 msg_id, int pk_total, int pk_num, int reg_delivery, int msg_level, const char *service_id,
		int fee_usertype, const char *fee_terminal_id, int TP_pid, int TP_udhi,
		int msg_fmt, const char *src_term_id, int dest_term_num, const char **dest_term_id,
		const char *msg_src, const char *fee_type, const char *fee_code, const char *valid_time,
		const char *at_time, int msg_len, const char *msg)
{
	m_nCommandID = CMPP_Fwd;
	FillData(m_sSourceID, src_id, 4);
	FillData(m_sDestID, dst_id, 4);
	m_nNodesCount = nodes_cnt;
	m_nMsg_Fwd_Type = msg_fwd_type;
	m_nMsgID = msg_id;
	m_nPKTotal = pk_total;
	m_nPKNumber = pk_num;
	m_nRegisteredDelivery = reg_delivery;
	m_nMsgLevel = msg_level;
	FillData(m_sServiceID, service_id, 10);
	m_nFee_UserType = fee_usertype;
	FillData(m_sFeeTerminalID, fee_terminal_id, 21);
	m_nTP_pid = TP_pid;
	m_nTP_udhi = TP_udhi;

//	m_nTLSAVailable = use_tls;
	m_nMsgFmt = msg_fmt;
	FillData(m_sFeeType, fee_type, 2);
	FillData(m_sFeeCode, fee_code, 6);

	if( valid_time!=NULL&&strlen(valid_time)!=VALID_UTCTIMELENG )
		valid_time="";
	if( at_time!=NULL&&strlen(at_time)!=VALID_UTCTIMELENG )
		at_time="";
	
	FillData(m_sValidTime, valid_time, 17);
	FillData(m_sAtTime, at_time, 17);
	
	FillData(m_sSrcTerminalID, src_term_id, 21);
	if (dest_term_num < 0) dest_term_num = 0;
	else if (dest_term_num > 100) dest_term_num = 100;
	m_nDestUsrTl = dest_term_num;
	for (int i = 0; i < dest_term_num; i++)
		FillData(m_sDestTerminalIDs[i], dest_term_id[i], 21);
	if (msg_len < 0) msg_len = 0;
	else if (msg_len > 140) msg_len = 140;
	m_nMsgLength = msg_len;
	memcpy(m_sMsgContent, msg, msg_len);
	m_sMsgContent[msg_len] = 0;
}

void CCmppMessage::Set_Fwd_REP(__int64 msg_id, int pk_total, int pk_num, int result)
{
	m_nCommandID = CMPP_Fwd_REP;
	m_nMsgID = msg_id;
	m_nPKTotal = pk_total;
	m_nPKNumber = pk_num;
//	m_nTLSAVailable = use_tls;
	m_nResult = result;
}

//*****************************************************************
void CCmppMessage::Set_Route(bool new_gate, bool request_multi, const char *service_type, int service_code, const char *icp_id)
{
	m_nCommandID = CMPP_Route;
	m_nNewGate = new_gate;
	m_nRequestTotal = request_multi;
	FillData(m_sServiceType, service_type, 10);
	m_nServiceCode = service_code;
	FillData(m_sSource_Addr, icp_id, 6);
}

void CCmppMessage::Set_Route_REP(int req_num, const char *service_type, int *service_code_start, 
	int *service_code_end, const char *icp_id, const char *ismg_id)
{
	m_nCommandID = CMPP_Route_REP;
	if (req_num < 0) req_num = 0;
	else if (req_num > MAX_ROUTE_NUM) req_num = MAX_ROUTE_NUM;
	m_RequestNumber = req_num;
	for (int i = 0; i < req_num; i++)
	{
		FillData(m_sServiceTypes[i], service_type, 10);
		m_nServiceCodeStarts[i] = service_code_start[i];
		m_nServiceCodeEnds[i] = service_code_end[i];
		FillData(m_sICPIDs[i], icp_id, 6);
		FillData(m_sISMGIDs[i], ismg_id, 4);
		service_type += 10;
		icp_id += 6;
		ismg_id += 4;
	}
}

void CCmppMessage::MakeAuthIcp(const char *secret, bool use_9_byte)
{
	char src[400];
	char m_sStamp[11];
	FillData(src, m_sSource_Addr, 6);

	CTime t = CTime::GetCurrentTime();
	sprintf(m_sStamp, "%s", t.Format("%m%d%H%M%S"));
	m_nTimeStamp = atoi(m_sStamp);
	if (use_9_byte)
	{
		memset(src + 6, 0, 9);
		strcpy(src + 6 + 9, secret);
		strcpy(src + 15 + strlen(secret), m_sStamp);
		UTIL_MD5Checksum::GetMD5((BYTE *)src, 15 + strlen(secret) + 10, (BYTE *)m_AuthenticatorICP);
	}
	else
	{
		memset(src + 6, 0, 9*4);
		strcpy(src + 6 + 9 * 4, secret);
		strcpy(src + 42 + strlen(secret), m_sStamp);
		UTIL_MD5Checksum::GetMD5((BYTE *)src, 42 + strlen(secret) + 10, (BYTE *)m_AuthenticatorICP);
//		UTIL_MD5Checksum::GetMD5((BYTE *)src, 6 + 9 * 4 + strlen(secret), (BYTE *)m_AuthenticatorIcp);
	}


	/*
	memset(src + 6, 0, 9);
	strcpy(src + 15, secret);
	UTIL_MD5Checksum::GetMD5((BYTE *)src, 15 + strlen(secret), (BYTE *)m_AuthenticatorICP);
	*/
}


void CCmppMessage::MakeAuthISMG(const char *secret)
{
	char src[400];
	src[0] = m_nStatus;
	memcpy(src + 1, m_AuthenticatorICP, 16);
	strcpy(src + 17, secret);
	UTIL_MD5Checksum::GetMD5((BYTE *)src, 17 + strlen(secret), (BYTE *)m_AuthenticatorISMG);
}
//have bigo
bool CCmppMessage::ValidAuthIcp(const char *secret, bool use_9_byte) const
{
	char src[400];
	FillData(src, m_sSource_Addr, 6);
	// previous version of gateway is fill 9 bytes zero to make MD5, and it is wrong
	// we make it for version compatible
	BYTE md5[16];
	char m_sStamp[10];
	if(m_nTimeStamp < 1000000000)
		sprintf(m_sStamp,"%0%d",m_nTimeStamp);
	else
		sprintf(m_sStamp, "%d", m_nTimeStamp);
	if (use_9_byte)
	{
		memset(src + 6, 0, 9);
		strcpy(src + 6 + 9, secret);
		strcpy(src + 15 + strlen(secret), m_sStamp);
		UTIL_MD5Checksum::GetMD5((BYTE *)src, 15 + strlen(secret) + 10, md5);
//		UTIL_MD5Checksum::GetMD5((BYTE *)src, 6 + 9 + strlen(secret), md5);
		return memcmp(m_AuthenticatorICP, md5, 16) == 0;
	}
	else
	{
		memset(src + 6, 0, 9*4);
		strcpy(src + 6 + 9*4, secret);
		strcpy(src + 42 + strlen(secret), m_sStamp);
		UTIL_MD5Checksum::GetMD5((BYTE *)src, 6 + 9*4 + strlen(secret)+10, md5);
		return memcmp(m_AuthenticatorICP, md5, 16) == 0;
	}
	
/***********************	
	char src[400];
	char md5[16];
	FillData(src, m_sSource_Addr, 6);
	memset(src + 6, 0, 9);
	strcpy(src + 15, secret);
	UTIL_MD5Checksum::GetMD5((BYTE *)src, 15 + strlen(secret), (BYTE *)md5);
	return memcmp(m_AuthenticatorICP, md5, 16) == 0;
	******************************/
}

bool CCmppMessage::ValidAuthISMG(const char *secret) const
{
	char src[400];
	BYTE md5[16];
	src[0] = m_nStatus;
	memcpy(src + 1, m_AuthenticatorICP, 16);
//	src[17] = m_nTLSAVailable;
	strcpy(src + 18, secret);
	UTIL_MD5Checksum::GetMD5((BYTE *)src, 18 + strlen(secret), (BYTE *)md5);
	return memcmp(m_AuthenticatorISMG, md5, 16) == 0;
}

//???????????????????????????????????????
void CCmppMessage::CopySubmit(const CCmppMessage* msg)
{
	m_nCommandID = msg->m_nCommandID;
	m_nSequenceID = msg->m_nSequenceID;
	m_nMsgID = msg->m_nMsgID;
	m_nPKTotal = msg->m_nPKTotal;
	m_nPKNumber = msg->m_nPKNumber;
	memcpy(m_sServiceID,msg->m_sServiceID,10);
	m_nMsgFmt = msg->m_nMsgFmt;
	m_nMsgLevel = msg->m_nMsgLevel;
	memcpy(m_sFeeType,msg->m_sFeeType,2);
	memcpy(m_sFeeCode,msg->m_sFeeCode,6);
	memcpy(m_sValidTime,msg->m_sValidTime,17);
	memcpy(m_sAtTime,msg->m_sAtTime,17);
	memcpy(m_sSrcTerminalID,msg->m_sSrcTerminalID,21);
//	m_nDestUsrTl = msg->m_nDestUsrTl;
	int i;
	for(i=0;i<m_nDestUsrTl;i++)
		memcpy(m_sDestTerminalIDs[i],msg->m_sDestTerminalIDs[i],21);
	m_nMsgLength = msg->m_nMsgLength;
	memcpy(m_sMsgContent,msg->m_sMsgContent,m_nMsgLength+1);
}