cmpp.c

移动短信网关协议CMPPv2.0的封装实现

	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	memcpy(&var8, ptr, 1);
	msgBody->TP_pid = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	memcpy(&var8, ptr, 1);
	msgBody->TP_udhi = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	memcpy(&var8, ptr, 1);
	msgBody->Msg_Fmt = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	sum = sizeof(msgBody->Msg_src) - 1;
	memcpy(msgBody->Msg_src, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	sum = sizeof(msgBody->FeeType) - 1;
	memcpy(msgBody->FeeType, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	sum = sizeof(msgBody->FeeCode) - 1;
	memcpy(msgBody->FeeCode, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	sum = sizeof(msgBody->Valid_Time) - 1;
	memcpy(msgBody->Valid_Time, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	sum = sizeof(msgBody->At_Time) - 1;
	memcpy(msgBody->At_Time, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	sum = sizeof(msgBody->Src_Id) - 1;
	memcpy(msgBody->Src_Id, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	memcpy(&var8, ptr, 1);
	if (var8 < 1 || var8 > 100)
		return -1;
	msgBody->DestUsr_tl = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	for (i = 0; i < var8; i++)
	{
		sum = sizeof(msgBody->Dest_terminal_Id[i]) - 1;
		memcpy(msgBody->Dest_terminal_Id[i], ptr, sum);
		ptr = ptr + sum;
		if ((unsigned int)(ptr - rawBody) >= len)
			return -1;
	}

	memcpy(&var8, ptr, 1);
	msgBody->Msg_Length = var8;
	if (msgBody->Msg_Length > (unsigned char)(sizeof(msgBody->Msg_Content) - 1))
		msgBody->Msg_Length = (unsigned char)(sizeof(msgBody->Msg_Content) - 1);
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	sum = (unsigned int)var8;
	memcpy(msgBody->Msg_Content, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	sum = sizeof(msgBody->Reserve) - 1;
	memcpy(msgBody->Reserve, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) > len)
		return -1;

	return 0;
}

static int cmppDecodeSubmitResp(const char *rawBody, unsigned int len, CMPP_BODY_SUBMIT_RESP *msgBody)
{
	unsigned int sum = 0;
	unsigned char var8;
	unsigned long var32;
	const char *ptr = rawBody;

	if (rawBody == NULL || msgBody == NULL)
		return -1;
		
	memset(msgBody, 0, sizeof(*msgBody));

	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->Msg_Id1 = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->Msg_Id2 = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->Result = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) > len)
		return -1;
	
	return 0;
}

static int cmppDecodeDeliver(const char *rawBody, unsigned int len, CMPP_BODY_DELIVER *msgBody)
{
	unsigned int sum = 0;
	unsigned char var8;
	unsigned long var32;
	const char *ptr = rawBody;

	if (rawBody == NULL || msgBody == NULL)
		return -1;
		
	memset(msgBody, 0, sizeof(*msgBody));

	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->Msg_Id1 = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->Msg_Id2 = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->Dest_Id) - 1;
	memcpy(msgBody->Dest_Id, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->Service_Id) - 1;
	memcpy(msgBody->Service_Id, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->TP_pid = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->TP_udhi = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->Msg_Fmt = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->Src_terminal_Id) - 1;
	memcpy(msgBody->Src_terminal_Id, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->Registered_Delivery = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->Msg_Length = var8;
	if (msgBody->Msg_Length > (unsigned char)(sizeof(msgBody->Msg_Content) - 1))
		msgBody->Msg_Length = (unsigned char)(sizeof(msgBody->Msg_Content) - 1);
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = (unsigned int)var8;
	memcpy(msgBody->Msg_Content, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	sum = sizeof(msgBody->Reserve) - 1;
	memcpy(msgBody->Reserve, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) > len)
		return -1;
	
	return 0;
}

static int cmppDecodeDeliverResp(const char *rawBody, unsigned int len, CMPP_BODY_DELIVER_RESP *msgBody)
{
	unsigned int sum = 0;
	unsigned char var8;
	unsigned long var32;
	const char *ptr = rawBody;

	if (rawBody == NULL || msgBody == NULL)
		return -1;
		
	memset(msgBody, 0, sizeof(*msgBody));

	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->Msg_Id1 = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->Msg_Id2 = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->Result = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) > len)
		return -1;
	
	return 0;
}

static int cmppDecodeQuery(const char *rawBody, unsigned int len, CMPP_BODY_QUERY *msgBody)
{
	unsigned int sum = 0;
	unsigned char var8;
	const char *ptr = rawBody;

	if (rawBody == NULL || msgBody == NULL)
		return -1;
		
	memset(msgBody, 0, sizeof(*msgBody));

	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->Time) - 1;
	memcpy(msgBody->Time, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->Query_Type = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->Query_Code) - 1;
	memcpy(msgBody->Query_Code, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->Reserve) - 1;
	memcpy(msgBody->Reserve, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) > len)
		return -1;
	
	return 0;
}

static int cmppDecodeQueryResp(const char *rawBody, unsigned int len, CMPP_BODY_QUERY_RESP *msgBody)
{
	unsigned int sum = 0;
	unsigned char var8;
	unsigned long var32;
	const char *ptr = rawBody;

	if (rawBody == NULL || msgBody == NULL)
		return -1;
		
	memset(msgBody, 0, sizeof(*msgBody));

	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->Time) - 1;
	memcpy(msgBody->Time, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->Query_Type = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->Query_Code) - 1;
	memcpy(msgBody->Query_Code, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->MT_TLMsg = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->MT_Tlusr = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->MT_Scs = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->MT_WT = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->MT_FL = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->MO_Scs = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->MO_WT = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->MO_FL = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) > len)
		return -1;
	
	return 0;
}

static int cmppDecodeCancel(const char *rawBody, unsigned int len, CMPP_BODY_CANCEL *msgBody)
{
	unsigned int sum = 0;
	unsigned long var32;
	const char *ptr = rawBody;

	if (rawBody == NULL || msgBody == NULL)
		return -1;
		
	memset(msgBody, 0, sizeof(*msgBody));

	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->Msg_Id1 = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->Msg_Id2 = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) > len)
		return -1;
	
	return 0;
}

static int cmppDecodeCancelResp(const char *rawBody, unsigned int len, CMPP_BODY_CANCEL_RESP *msgBody)
{
	unsigned int sum = 0;
	unsigned char var8;
	const char *ptr = rawBody;

	if (rawBody == NULL || msgBody == NULL)
		return -1;
		
	memset(msgBody, 0, sizeof(*msgBody));

	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->Success_Id = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) > len)
		return -1;
	
	return 0;
}

static int cmppDecodeActiveTestResp(const char *rawBody, unsigned int len, CMPP_BODY_ACTIVE_TEST_RESP *msgBody)
{
	unsigned int sum = 0;
	unsigned char var8;
	const char *ptr = rawBody;

	if (rawBody == NULL || msgBody == NULL)
		return -1;
		
	memset(msgBody, 0, sizeof(*msgBody));

	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->Reserve = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) > len)
		return -1;
	
	return 0;
}

int cmppDecode(const char *pszPDU, CMPP_MSG *pMsg)
{
	char PDU[CMPP_PDU_SIZE];
	unsigned long var32, len;
	int ret;

	memset(PDU, 0, sizeof(PDU));
	memcpy(&var32, pszPDU, 4);
	var32 = ntohl(var32);
	if (var32 < 12 || var32 > sizeof(PDU))
		return -1;
	len = var32;
	memcpy(PDU, pszPDU, len);

	memcpy(&var32, PDU + 0, 4);
	pMsg->Total_Length = ntohl(var32);
	memcpy(&var32, PDU + 4, 4);
	pMsg->Command_Id = ntohl(var32);
	memcpy(&var32, PDU + 8, 4);
	pMsg->Sequence_Id = ntohl(var32);

	ret = 0;
	switch (pMsg->Command_Id)
	{
	case CMPP_CONNECT :
		ret = cmppDecodeConnect(PDU + 12, (unsigned int)(len - 12), &(pMsg->body.connect));
		break;	
	
	case CMPP_CONNECT_RESP :
		ret = cmppDecodeConnectResp(PDU + 12, (unsigned int)(len - 12), &(pMsg->body.connect_resp));
		break;	

	case CMPP_SUBMIT :
		ret = cmppDecodeSubmit(PDU + 12, (unsigned int)(len - 12), &(pMsg->body.submit));
		break;	

	case CMPP_SUBMIT_RESP :
		ret = cmppDecodeSubmitResp(PDU + 12, (unsigned int)(len - 12), &(pMsg->body.submit_resp));
		break;	

	case CMPP_DELIVER :
		ret = cmppDecodeDeliver(PDU + 12, (unsigned int)(len - 12), &(pMsg->body.deliver));
		break;	

	case CMPP_DELIVER_RESP :
		ret = cmppDecodeDeliverResp(PDU + 12, (unsigned int)(len - 12), &(pMsg->body.deliver_resp));
		break;	

	case CMPP_QUERY :
		ret = cmppDecodeQuery(PDU + 12, (unsigned int)(len - 12), &(pMsg->body.query));
		break;	

	case CMPP_QUERY_RESP :
		ret = cmppDecodeQueryResp(PDU + 12, (unsigned int)(len - 12), &(pMsg->body.query_resp));
		break;	

	case CMPP_CANCEL :
		ret = cmppDecodeCancel(PDU + 12, (unsigned int)(len - 12), &(pMsg->body.cancel));
		break;	

	case CMPP_CANCEL_RESP :
		ret = cmppDecodeCancelResp(PDU + 12, (unsigned int)(len - 12), &(pMsg->body.cancel_resp));
		break;	

	case CMPP_TERMINATE :
		break;
		
	case CMPP_TERMINATE_RESP :
		break;

	case CMPP_ACTIVE_TEST :
		break;

	case CMPP_ACTIVE_TEST_RESP :
		ret = cmppDecodeActiveTestResp(PDU + 12, (unsigned int)(len - 12), &(pMsg->body.active_test_resp));
		break;

	default :
		ret = -1;
	}

	return ret;
}