sgip.c

SGIP协议封装

	char ppdu[SGIP_PDU_SIZE], *ptr;
	unsigned int len;
	unsigned char var8;
	unsigned long var32;
	
	if (sockfd == INVALID_SOCKET)
		return -1;

	if (SequenceNumber == NULL || pBody == NULL)
		return -1;

	memset(ppdu, 0, sizeof(ppdu));
	ptr = ppdu;

	// 消息头
	ptr += 4;
	
	var32 = htonl(SGIP_REPORT_RESP);
	memcpy(ptr, &var32, 4);
	ptr += 4;
	
	var32 = htonl(SequenceNumber[0]);
	memcpy(ptr, &var32, 4);
	ptr += 4;
	
	var32 = htonl(SequenceNumber[1]);
	memcpy(ptr, &var32, 4);
	ptr += 4;
	
	var32 = htonl(SequenceNumber[2]);
	memcpy(ptr, &var32, 4);
	ptr += 4;

	// 消息体
	var8 = pBody->Result;
	len = 1;
	memcpy(ptr, &var8, len);
	ptr += len;
	
	len = sizeof(pBody->Reserve) - 1;
	memcpy(ptr, pBody->Reserve, len);
	ptr += len;
	
	// 修改消息头中长度
	len = ptr - ppdu;
	var32 = htonl(len);
	memcpy(ppdu, &var32, 4);

	// 发送数据包
	if (send(sockfd, ppdu, (int)len, 0) != (int)len) 
	{
		closesocket(sockfd);
		return -1;
	}
	
	return 0;
}

int sgipEnquireLink(SOCKET sockfd, 
	const unsigned long *SequenceNumber)
{
	char ppdu[SGIP_PDU_SIZE], *ptr;
	unsigned int len;
	unsigned long var32;
	
	if (sockfd == INVALID_SOCKET)
		return -1;

	if (SequenceNumber == NULL)
		return -1;

	memset(ppdu, 0, sizeof(ppdu));
	ptr = ppdu;

	// 消息头
	ptr += 4;
	
	var32 = htonl(SGIP_ENQUIRELINK);
	memcpy(ptr, &var32, 4);
	ptr += 4;
	
	var32 = htonl(SequenceNumber[0]);
	memcpy(ptr, &var32, 4);
	ptr += 4;
	
	var32 = htonl(SequenceNumber[1]);
	memcpy(ptr, &var32, 4);
	ptr += 4;
	
	var32 = htonl(SequenceNumber[2]);
	memcpy(ptr, &var32, 4);
	ptr += 4;

	// 修改消息头中长度
	len = ptr - ppdu;
	var32 = htonl(len);
	memcpy(ppdu, &var32, 4);

	// 发送数据包
	if (send(sockfd, ppdu, (int)len, 0) != (int)len) 
	{
		closesocket(sockfd);
		return -1;
	}
	
	return 0;
}

int sgipEnquireLinkResp(SOCKET sockfd, 
	const unsigned long *SequenceNumber)
{
	char ppdu[SGIP_PDU_SIZE], *ptr;
	unsigned int len;
	unsigned long var32;
	
	if (sockfd == INVALID_SOCKET)
		return -1;

	if (SequenceNumber == NULL)
		return -1;

	memset(ppdu, 0, sizeof(ppdu));
	ptr = ppdu;	
	
	// 消息头
	ptr += 4;
	
	var32 = htonl(SGIP_ENQUIRELINK_RESP);
	memcpy(ptr, &var32, 4);
	ptr += 4;
	
	var32 = htonl(SequenceNumber[0]);
	memcpy(ptr, &var32, 4);
	ptr += 4;
	
	var32 = htonl(SequenceNumber[1]);
	memcpy(ptr, &var32, 4);
	ptr += 4;
	
	var32 = htonl(SequenceNumber[2]);
	memcpy(ptr, &var32, 4);
	ptr += 4;

	// 修改消息头中长度
	len = ptr - ppdu;
	var32 = htonl(len);
	memcpy(ppdu, &var32, 4);

	// 发送数据包
	if (send(sockfd, ppdu, (int)len, 0) != (int)len) 
	{
		closesocket(sockfd);
		return -1;
	}
	
	return 0;
}

static int sgipDecodeBind(const char *rawBody, unsigned int len, SGIP_BODY_BIND *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->LoginType = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->LoginName) - 1;
	memcpy(msgBody->LoginName, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->LoginPassword) - 1;
	memcpy(msgBody->LoginPassword, 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 sgipDecodeBindResp(const char *rawBody, unsigned int len, SGIP_BODY_BIND_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->Result = var8;
	ptr = ptr + 1;
	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 sgipDecodeSubmit(const char *rawBody, unsigned int len, SGIP_BODY_SUBMIT *msgBody)
{
	unsigned int sum = 0;
	unsigned char i, 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->SPNumber) - 1;
	memcpy(msgBody->SPNumber, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->ChargeNumber) - 1;
	memcpy(msgBody->ChargeNumber, 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->UserCount = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	for (i = 0; i < var8; i++)
	{
		sum = sizeof(msgBody->UserNumber[i]) - 1;
		memcpy(msgBody->UserNumber[i], ptr, sum);
		ptr = ptr + sum;
		if ((unsigned int)(ptr - rawBody) >= len)
			return -1;
	}
	
	sum = sizeof(msgBody->CorpId) - 1;
	memcpy(msgBody->CorpId, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->ServiceType) - 1;
	memcpy(msgBody->ServiceType, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->FeeType = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->FeeValue) - 1;
	memcpy(msgBody->FeeValue, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->GivenValue) - 1;
	memcpy(msgBody->GivenValue, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->AgentFlag = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->MOrelatetoMTFlag = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->Priority = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->ExpireTime) - 1;
	memcpy(msgBody->ExpireTime, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->ScheduleTime) - 1;
	memcpy(msgBody->ScheduleTime, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->ReportFlag = var8;
	ptr = ptr + 1;
	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->MessageCoding = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->MessageType = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->MessageLength = var32;
	if (msgBody->MessageLength > (sizeof(msgBody->MessageContent) - 1))
		msgBody->MessageLength = sizeof(msgBody->MessageContent) - 1;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = var32;
	memcpy(msgBody->MessageContent, ptr, msgBody->MessageLength);
	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 sgipDecodeSubmitResp(const char *rawBody, unsigned int len, SGIP_BODY_SUBMIT_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->Result = var8;
	ptr = ptr + 1;
	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 sgipDecodeDeliver(const char *rawBody, unsigned int len, SGIP_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;
	
	sum = sizeof(msgBody->UserNumber) - 1;
	memcpy(msgBody->UserNumber, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->SPNumber) - 1;
	memcpy(msgBody->SPNumber, 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->MessageCoding = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->MessageLength = var32;
	if (msgBody->MessageLength > (sizeof(msgBody->MessageContent) - 1))
		msgBody->MessageLength = sizeof(msgBody->MessageContent) - 1;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = var32;
	memcpy(msgBody->MessageContent, ptr, msgBody->MessageLength);
	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 sgipDecodeDeliverResp(const char *rawBody, unsigned int len, SGIP_BODY_DELIVER_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->Result = var8;
	ptr = ptr + 1;
	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 sgipDecodeReport(const char *rawBody, unsigned int len, SGIP_BODY_REPORT *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->SubmitSequenceNumber[0] = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->SubmitSequenceNumber[1] = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
		
	memcpy(&var32, ptr, 4);
	var32 = ntohl(var32);
	msgBody->SubmitSequenceNumber[2] = var32;
	ptr = ptr + 4;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->ReportType = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	sum = sizeof(msgBody->UserNumber) - 1;
	memcpy(msgBody->UserNumber, ptr, sum);
	ptr = ptr + sum;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;
	
	memcpy(&var8, ptr, 1);
	msgBody->State = var8;
	ptr = ptr + 1;
	if ((unsigned int)(ptr - rawBody) >= len)
		return -1;

	memcpy(&var8, ptr, 1);
	msgBody->ErrorCode = var8;
	ptr = ptr + 1;
	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 sgipDecodeReportResp(const char *rawBody, unsigned int len, SGIP_BODY_REPORT_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->Result = var8;
	ptr = ptr + 1;
	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;
}

int sgipDecode(const char *pszPDU, SGIP_MSG *pMsg)
{
	char PDU[SGIP_PDU_SIZE];
	unsigned long var32, len;
	int ret;

	if (pszPDU == NULL || pMsg == NULL)
		return -1;

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

	memcpy(&var32, PDU + 0, 4);
	pMsg->MessageLength = ntohl(var32);
	memcpy(&var32, PDU + 4, 4);
	pMsg->CommandID = ntohl(var32);
	memcpy(&var32, PDU + 8, 4);
	pMsg->SequenceNumber[0] = ntohl(var32);
	memcpy(&var32, PDU + 12, 4);
	pMsg->SequenceNumber[1] = ntohl(var32);
	memcpy(&var32, PDU + 16, 4);
	pMsg->SequenceNumber[2] = ntohl(var32);

	ret = 0;
	switch (pMsg->CommandID)
	{
	case SGIP_BIND :
		ret = sgipDecodeBind(PDU + 20, (unsigned int)(len - 20), &(pMsg->body.bind));
		break;	
		
	case SGIP_BIND_RESP :
		ret = sgipDecodeBindResp(PDU + 20, (unsigned int)(len - 20), &(pMsg->body.bind_resp));
		break;

	case SGIP_SUBMIT :
		ret = sgipDecodeSubmit(PDU + 20, (unsigned int)(len - 20), &pMsg->body.submit);
		break;
	
	case SGIP_SUBMIT_RESP :
		ret = sgipDecodeSubmitResp(PDU + 20, (unsigned int)(len - 20), &pMsg->body.submit_resp);
		break;

	case SGIP_DELIVER :
		ret = sgipDecodeDeliver(PDU + 20, (unsigned int)(len - 20), &pMsg->body.deliver);
		break;
	
	case SGIP_DELIVER_RESP :
		ret = sgipDecodeDeliverResp(PDU + 20, (unsigned int)(len - 20), &pMsg->body.deliver_resp);
		break;

	case SGIP_REPORT :
		ret = sgipDecodeReport(PDU + 20, (unsigned int)(len - 20), &pMsg->body.report);
		break;
	
	case SGIP_REPORT_RESP :
		ret = sgipDecodeReportResp(PDU + 20, (unsigned int)(len - 20), &pMsg->body.report_resp);
		break;
		
	case SGIP_UNBIND :
		break;
		
	case SGIP_UNBIND_RESP :
		break;

	case SGIP_ENQUIRELINK :
		break;
		
	case SGIP_ENQUIRELINK_RESP :
		break;

	default :
		ret = -1;
	}

	return ret;
}