repos_ecs/Client_1.0.0.5/kernel/TcpParse.cpp

#include "stdafx.h"
#include "kernel.h"
#include "Client2SrvType.h"
#include "TcpParse.h"
#include "crc32.h"
#include "SocketHandle.h"
#include "Global.h"

CTcpParse::CTcpParse(void)
{

}

CTcpParse::~CTcpParse(void)
{

}

unsigned int CTcpParse::CalcCheckSum(void *pData, unsigned int nSize)
{
	unsigned int checksum = 0;
	if (nSize <= sizeof(ProtocolHeader))
	{
		return 0;
	}
	unsigned char *pBody = &((unsigned char*)pData)[sizeof(ProtocolHeader)];
	nSize -= sizeof(ProtocolHeader);

	checksum = crc32(0, pBody, nSize);

	return checksum;
}

void CTcpParse::ProcessDevOnline(void *pSocketHandle, void *pData, int nLen)
{
	ReqDevOnline *pReqDevOnline = (ReqDevOnline *)pData;
	CAnalog *pAnalog = pVariantsManager->FindAnalog(pReqDevOnline->nVarID);
	if (pAnalog == NULL)
		return;

	//if( pAnalog->m_nVarID==41 )
	//	LOG4C((LOG_NOTICE, "%s, 值: %d C", pAnalog->m_strDesc,(int)pAnalog->m_fData ));

	pAnalog->m_fData = (float)pReqDevOnline->nOnline;
}

void CTcpParse::ProcessHeart(void *pSocketHandle, void *pData, int nLen)
{
	((CSocketHandle *)pSocketHandle)->Write((const LPBYTE)pData, nLen, NULL);
}

void CTcpParse::ProcessSingleVarOnline(void *pSocketHandle, void *pData, int nLen)
{
}

void CTcpParse::ProcessMulVarOnline(void *pSocketHandle, void *pData, int nLen)
{
}

int CTcpParse::GetVarstatus(float fParaValue, int iUpperLimit, int iLowerLimit, int iNormalState)
{
	int iResult = iNormalState;
	if ((iUpperLimit > 0 || iLowerLimit > 0) && iUpperLimit > iLowerLimit)
	{
		//iResult = (iParaValue >= iUpperLimit || iParaValue <= iLowerLimit);	
		if (fParaValue > iUpperLimit)
		{
			iResult = UPPER_LIMIT_ID;		// 上限告警
		}
		if (fParaValue < iLowerLimit)
		{
			iResult = LOWER_LIMIT_ID;		// 下限告警
		}
		else
		{
			return iResult;
		}
	}
	else if ((int)fParaValue != iNormalState)
	{
		iResult = (int)fParaValue;
	}

	return iResult;
}

void CTcpParse::ProcessReadSingleVarData(void *pSocketHandle, void *pData, int nLen)
{
	ReqSingleVarData *pReqSingleVarData = (ReqSingleVarData *)pData;
	CAnalog *pAnalog = pVariantsManager->FindAnalog(pReqSingleVarData->nVarID);
	if (pAnalog == NULL)
		return;

	//if( pAnalog->m_nVarID==41 )
	//	LOG4C((LOG_NOTICE, "%s, 值: %d A", pAnalog->m_strDesc,(int)pAnalog->m_fData ));
	pAnalog->m_fData = (float)pReqSingleVarData->Data;

	//if( (int)pAnalog->m_fData==0 )
	//{
	//	CString s;s.Format( "%f",pAnalog->m_fData );
	//	if( -1 != s.Find("-") )
	//		pAnalog->m_fData = 0.0;
	//	//LOG4C((LOG_NOTICE, "%s, 值: %d %s ", pAnalog->m_strDesc,(int)pAnalog->m_fData,s ));
	//}
	//LOG4C(( LOG_NOTICE,"RRRRR var=%s %d m_fData=%d",pAnalog->m_strDesc,pAnalog->m_nVarTypeID,(int)pAnalog->m_fData ));
	//if( pReqSingleVarData->nVarID==19 )
	//{
	//	LOG4C((LOG_NOTICE, "%s  %d  %d",pReqSingleVarData->DevUid,pReqSingleVarData->nStatus,(int)pReqSingleVarData->Data));
	//}
}

void CTcpParse::ProcessReadSpecialMulVarData(void *pSocketHandle, void *pData, int nLen)
{
}

void CTcpParse::ProcessReadSpecialSingleVarData(void *pSocketHandle, void *pData, int nLen)
{
	ReqSingleSpecialVarData *pReqSingleSpecialVarData = (ReqSingleSpecialVarData *)pData;
	CAnalog *pAnalog = pVariantsManager->FindAnalog(pReqSingleSpecialVarData->iVarid);
	if (pAnalog == NULL)
		return;

	//if( pAnalog->m_nVarID==41 )
	//	LOG4C((LOG_NOTICE, "%s, 值: %d B", pAnalog->m_strDesc,(int)pAnalog->m_fData ));
	pAnalog->m_fData = (float)pReqSingleSpecialVarData->Data;

	//if( (int)pAnalog->m_fData==0 )
	//{
	//	CString s;s.Format( "%f",pAnalog->m_fData );
	//	if( -1 != s.Find("-") )
	//		pAnalog->m_fData = 0.0;
	//	//LOG4C((LOG_NOTICE, "%s, 值: %d %s ", pAnalog->m_strDesc,(int)pAnalog->m_fData,s ));
	//}
	//LOG4C(( LOG_NOTICE,"RRRRR var=%s %d m_fData=%d",pAnalog->m_strDesc,pAnalog->m_nVarTypeID,(int)pAnalog->m_fData ));
	//if( pReqSingleSpecialVarData->iVarid==19 )
	//{
	//	LOG4C((LOG_NOTICE, "%s  %d  %d",pReqSingleSpecialVarData->DevUid,pReqSingleSpecialVarData->nStatus,(int)pReqSingleSpecialVarData->Data));
	//}
}

void CTcpParse::ProcessReadMulVarData(void *pSocketHandle, void *pData, int nLen)
{
}

void CTcpParse::ProcessWriteSingleVarData(void *pSocketHandle, void *pData, int nLen)
{
	ReqWrSingleVarData *pReqWrSingleVarData = (ReqWrSingleVarData*)pData;
	CAnalog *pAnalog = pVariantsManager->FindAnalog(pReqWrSingleVarData->iVarid);
	if (pAnalog == NULL)
		return;
}

void CTcpParse::ProcessWriteMulVarData(void *pSocketHandle, void *pData, int nLen)
{
}

void CTcpParse::ProcessDogData(void *pSocketHandle, void *pData, int nLen)
{
	ReqDogData *pReqDogData = (ReqDogData *)pData;

	if (pReqDogData->nPastDue == 1)
		pDevicesManager->m_bIsPastDue = true;
	else
		pDevicesManager->m_bIsPastDue = false;

	pDevicesManager->m_nSlaveVersion = pReqDogData->SlaveVersion;

	pDevicesManager->m_sPassDueInfo.Format("%s", pReqDogData->ErrorInfo);
}

void CTcpParse::ProcessAlarmConfirm(void *pSocketHandle, void *pData, int nLen)
{
	ReqAlarmConfirm *pReqAlarmConfig = (ReqAlarmConfirm *)pData;

	pEventServer->SetEventStatus2Config(pReqAlarmConfig->DevUid, pReqAlarmConfig->iVarid, pReqAlarmConfig->nAlarmIndex);
}

int CTcpParse::OnCmdProcess(void *pSocketHandle, void *pData)
{
	ProtocolHeader *pHeader = (ProtocolHeader *)pData;

	if (pHeader == NULL) return -1;
	if (pHeader->nLen < 0 || pHeader->nLen > 65535) return -1;
	unsigned int tmp = CalcCheckSum(pHeader, pHeader->nLen);
	if (tmp != pHeader->Verify)
	{
		return -1;
	}

	switch (pHeader->nCmd)
	{
	case CMD_DEV_ONLINE:				// 请求设备在线回应
		ProcessDevOnline(pSocketHandle, pData, pHeader->nLen);
		break;
	case CMD_SINGLE_VAR_ONLINE:			// 请求单个变量在线回应
		ProcessSingleVarOnline(pSocketHandle, pData, pHeader->nLen);
		break;
	case CMD_MUL_VAR_ONLINE:			// 请求多个变量在线回应
		ProcessMulVarOnline(pSocketHandle, pData, pHeader->nLen);
		break;
	case CMD_READ_SINGLE_VAR_DATA:		// 请求单个变量内容回应
		ProcessReadSingleVarData(pSocketHandle, pData, pHeader->nLen);
		break;
	case CMD_READ_MUL_VAR_DATA:			// 请求多个变量内容回应
		ProcessReadMulVarData(pSocketHandle, pData, pHeader->nLen);
		break;
	case CMD_WRITE_SINGLE_VAR_DATA:		// 请求写单个变量回应
		ProcessWriteSingleVarData(pSocketHandle, pData, pHeader->nLen);
		break;
	case CMD_WRITE_MUL_VAR_DATA:		// 请求写多个变量回应
		ProcessWriteMulVarData(pSocketHandle, pData, pHeader->nLen);
		break;
	case CMD_READ_SPECIAL_SINGLE_VAR_DATA:
		ProcessReadSpecialSingleVarData(pSocketHandle, pData, pHeader->nLen);
		break;
	case CMD_READ_SPECIAL_MUL_VAR_DATA:
		ProcessReadSpecialMulVarData(pSocketHandle, pData, pHeader->nLen);
		break;
	case CMD_DOG_DATA:					// 请求狗数据回应
		ProcessDogData(pSocketHandle, pData, pHeader->nLen);
		break;
	case CMD_ALARM_CONFIRM:				// 报警确认
		ProcessAlarmConfirm(pSocketHandle, pData, pHeader->nLen);
		break;
	case CMD_HEART:
		ProcessHeart(pSocketHandle, pData, pHeader->nLen);
		break;
	case CMD_ALARM_VAR_DATA:			// 有通知产生
		ProcessAlarmData(pSocketHandle, pData, pHeader->nLen);
		break;
	case CMD_GET_SERVER_VAR:
		ProcessServerVer(pSocketHandle, pData, pHeader->nLen);
		break;
	case CMD_OTHER_INFO:
		ProcessOtherInfo(pSocketHandle, pData, pHeader->nLen);
		break;
	}

	return 0;
}

void CTcpParse::ProcessData(void *pSocketHandle, const BYTE* pData, DWORD nLen)
{
	DWORD nBuffIndex = 0;

	CSocketHandle* pSH = (CSocketHandle *)pSocketHandle;
	EnterCriticalSection(&(pSH->m_hClient2SrvSection));
	while (nBuffIndex < nLen)
	{
		//LOG4C((LOG_NOTICE, "接收长度=%d, 处理长度=%d, PendingSize=%d", nLen, nBuffIndex, pSH->m_nPendingSize)); 
		ProtocolHeader *pHeader;   //当前协议包头
		DWORD nProcessedLen = 0; //当前循环处理了多少个字节
		if (pSH->m_nPendingSize > 0)		// 开始组包
		{
			//LOG4C((LOG_NOTICE, "开始组包"));
			pHeader = (ProtocolHeader *)pSH->m_PendingBuffer;
			if (pSH->m_nPendingSize < sizeof(ProtocolHeader))	//上一次接收到的长度小于包头
			{
				DWORD nLinkHeaderLen = sizeof(ProtocolHeader) - pSH->m_nPendingSize;
				if (nLinkHeaderLen <= nLen)		//这次可以收完包头	
				{
					memcpy(&pSH->m_PendingBuffer[pSH->m_nPendingSize], pData, nLinkHeaderLen);   //这里已经收完Header
					nProcessedLen = pHeader->nLen - pSH->m_nPendingSize;
					if (nProcessedLen <= nLen)  //如果所需处理的长度小于等于当前包长度
					{
						memcpy(&pSH->m_PendingBuffer[sizeof(ProtocolHeader)],
							&((char *)pData)[nLinkHeaderLen],
							pHeader->nLen - sizeof(ProtocolHeader));
						//LOG4C((LOG_NOTICE, "收完所需的包"));
						pSH->m_nPendingSize = 0;		// 收完所需的包，置m_nPendingSize为0
					}
					else
					{
						int nTemp = nLen - nLinkHeaderLen; //除去头剩余部分的长度
						if (nTemp > 0)	//刚好是Header的长度，不用拷贝内存，所以这里加了>0的判断
						{
							memcpy(&pSH->m_PendingBuffer[sizeof(ProtocolHeader)],
								&((char *)pData)[nLinkHeaderLen],
								nTemp);
						}
						pSH->m_nPendingSize += nLen;
					}
				}
				else   //这次还是没有收完包头， 继续Pending
				{
					//LOG4C((LOG_NOTICE, "这次还是没有收完包头， 继续Pending"));
					memcpy(&pSH->m_PendingBuffer[pSH->m_nPendingSize], pData, nLen);
					pSH->m_nPendingSize += nLen;
					nProcessedLen = nLen;
				}
			}
			else //Header部分已经在阻塞的缓冲区中
			{
				nProcessedLen = pHeader->nLen - pSH->m_nPendingSize;
				if (nProcessedLen <= nLen) //如果需要处理的长度小于现有包的长度
				{
					memcpy(&pSH->m_PendingBuffer[pSH->m_nPendingSize], pData, nProcessedLen);
					pSH->m_nPendingSize = 0;
				}
				else //否则要继续阻塞
				{
					memcpy(&pSH->m_PendingBuffer[pSH->m_nPendingSize], pData, nLen);
					pSH->m_nPendingSize += nLen;
				}
			}
		}
		else	//第一次接包
		{
			//LOG4C((LOG_NOTICE, "第一次接包"));
			pHeader = (ProtocolHeader *)&((unsigned char *)pData)[nBuffIndex];
			if (nLen - nBuffIndex < sizeof(ProtocolHeader))	// 没有收够包头，先记录当前收到的Buffer 
			{
				//如果第一次接包就没有收够包头，认为是非法包，扔掉，就是说已处理的长度nProcessedLen = 0
				pSH->m_nPendingSize = nLen - nBuffIndex;
				memcpy(pSH->m_PendingBuffer, pHeader, pSH->m_nPendingSize);
				LOG4C((LOG_NOTICE, "第一次接包就没有收够包头，认为是非法包，扔掉"));
			}
			else
			{
				nProcessedLen = pHeader->nLen;
				if ((int)pHeader->nLen > nLen - nBuffIndex)
				{
					memcpy(pSH->m_PendingBuffer, pHeader, nLen - nBuffIndex);
					//如果第一次接包，pHeader->nLen大于当前包的总长，认为是非法包，扔掉
					if (nBuffIndex == 0)
					{
						//组包错误，则扔掉当前包
						LOG4C((LOG_NOTICE, "第一次接包，服务器pHeader->nLen大于当前包的总长，认为是非法包，扔掉\r\n"));
					}
					pSH->m_nPendingSize = nLen - nBuffIndex;
					nProcessedLen = nLen - nBuffIndex;
				}
				else
				{
					//LOG4C((LOG_NOTICE, "正常包"));
					pSH->m_nPendingSize = 0;
				}
			}
		}

		if (nProcessedLen == 0)
		{
			// 没有收够包头，认为是非法包，扔掉
			LOG4C((LOG_NOTICE, "没有收够包头，认为是非法包，扔掉"));
			break;
		}

		if (pSH->m_nPendingSize == 0)
		{
			if (pHeader->nLen > SOCKET_BUFFSIZE)
			{
				// 包长度超过限制
				LOG4C((LOG_NOTICE, "pHeader->nLen超过限制"));
			}

			if (-1 == OnCmdProcess(pSocketHandle, pHeader))
			{
				//MessageBox( NULL, "Error OnCmdProcess", NULL, MB_OK );
				LOG4C((LOG_NOTICE, "Error OnCmdProcess"));
				break;
			}
		}

		nBuffIndex += nProcessedLen;
	}

	LeaveCriticalSection(&(pSH->m_hClient2SrvSection));
}

BOOL CTcpParse::SendNoticeToServer(void *pSocketHandle, int iCmd, int iOperateType, CString sUserName, CString sUID, int iVarID)
{
	if (pSocketHandle == NULL)
		return FALSE;

	switch (iCmd)
	{
	case 5004:
	{
		NoticeReadVar tag;
		int nLen = sizeof(NoticeReadVar);
		memset(&tag, 0, nLen);

		tag.Header.nLen = nLen;
		tag.Header.nCmd = iCmd;
		tag.Header.nCmdType = 0;

		strcpy((char *)tag.DevUid, (char *)(LPCTSTR)sUID);
		tag.iVarid = iVarID;
		tag.iOperateType = iOperateType;

		tag.Header.Verify = CalcCheckSum((void *)&tag, nLen);

		((CSocketHandle *)pSocketHandle)->Write((const LPBYTE)&tag, nLen, NULL);
	}
	break;
	case 5005:
	{
		NoticeReadDev tag;
		int nLen = sizeof(NoticeReadDev);
		memset(&tag, 0, nLen);

		tag.Header.nLen = nLen;
		tag.Header.nCmd = iCmd;
		tag.Header.nCmdType = 0;

		strcpy((char *)tag.DevUid, (char *)(LPCTSTR)sUID);
		tag.iOperateType = iOperateType;

		tag.Header.Verify = CalcCheckSum((void *)&tag, nLen);

		((CSocketHandle *)pSocketHandle)->Write((const LPBYTE)&tag, nLen, NULL);
	}
	break;
	case 5006:
	{
		NoticeReadUser tag;
		int nLen = sizeof(NoticeReadUser);
		memset(&tag, 0, nLen);

		tag.Header.nLen = nLen;
		tag.Header.nCmd = iCmd;
		tag.Header.nCmdType = 0;

		strcpy((char *)tag.UserName, (char *)(LPCTSTR)sUserName);
		tag.iOperateType = iOperateType;

		tag.Header.Verify = CalcCheckSum((void *)&tag, nLen);

		((CSocketHandle *)pSocketHandle)->Write((const LPBYTE)&tag, nLen, NULL);
	}
	break;
	}

	return true;
}

BOOL CTcpParse::GetServerVer(void *pSocketHandle)
{
	if (pSocketHandle == NULL)
		return FALSE;

	ServerVer tag;
	int nLen = sizeof(ServerVer);
	memset(&tag, 0, nLen);

	tag.Header.nLen = nLen;
	tag.Header.nCmd = CMD_GET_SERVER_VAR;
	tag.Header.nCmdType = 0;

	tag.Header.Verify = CalcCheckSum((void *)&tag, nLen);

	((CSocketHandle *)pSocketHandle)->Write((const LPBYTE)&tag, nLen, NULL);

	return TRUE;
}

BOOL CTcpParse::TestAlarm(void *pSocketHandle)
{
	if (pSocketHandle == NULL)
		return FALSE;

	ProtocolHeader Header;
	int nLen = sizeof(ProtocolHeader);
	memset(&Header, 0, nLen);

	Header.nLen = nLen;
	Header.nCmd = 5007;
	Header.nCmdType = 0;

	Header.Verify = CalcCheckSum((void *)&Header, nLen);

	((CSocketHandle *)pSocketHandle)->Write((const LPBYTE)&Header, nLen, NULL);

	return TRUE;
}

BOOL CTcpParse::ConfigAlarm(void *pSocketHandle, CString sUID, int iVarID, int iStatus, int iAlarmIndex)
{
	AlarmConfirm tag;
	int nLen = sizeof(AlarmConfirm);
	memset(&tag, 0, nLen);

	tag.Header.nLen = nLen;
	tag.Header.nCmd = CMD_ALARM_CONFIRM;
	tag.Header.nCmdType = 0;

	strcpy((char *)tag.DevUid, (char *)(LPCTSTR)sUID);
	tag.iVarid = iVarID;
	tag.nStauts = iStatus;
	tag.nAlarmIndex = iAlarmIndex;

	tag.Header.Verify = CalcCheckSum((void *)&tag, nLen);

	((CSocketHandle *)pSocketHandle)->Write((const LPBYTE)&tag, nLen, NULL);

	return TRUE;
}

void CTcpParse::ProcessAlarmData(void *pSocketHandle, void *pData, int nLen)
{
	AutoSendAlarmData *pAlarmData = (AutoSendAlarmData *)pData;

	CString sUid, str;
	sUid.Format("%s", pAlarmData->DevUid);

	if (pVariantsManager->m_SADeviceUid.GetCount() > 0)
	{
		bool bExist = false;
		for (int i = 0; i < pVariantsManager->m_SADeviceUid.GetCount(); i++)
		{
			str = pVariantsManager->m_SADeviceUid.GetAt(i);
			if (str.Find(sUid) != -1)
			{
				bExist = true;
				break;
			}
		}

		if (!bExist)
		{
			LOG4C((LOG_NOTICE, "设备%s 不是本地区的，不在本客户端显示", sUid));
			return;
		}
	}

	pEventServer->AddAlarmEvent(
		pAlarmData->DevUid,
		pAlarmData->nVarID,
		pAlarmData->nStatus,
		pAlarmData->sContent,
		pAlarmData->Data,
		pAlarmData->nUpperLimit,
		pAlarmData->nLowerLimit,
		pAlarmData->nNormalState,
		pAlarmData->nAlarmState,
		pAlarmData->nWarningLevel,
		pAlarmData->nAlarmIndex,
		pAlarmData->nNoticeDelay,
		pAlarmData->sWarningTime
		);
}

void CTcpParse::ProcessServerVer(void *pSocketHandle, void *pData, int nLen)
{
	ServerVer *tag = (ServerVer *)pData;
	pDevicesManager->m_sServerVer.Format("%s", tag->Ver);
}

void CTcpParse::ProcessOtherInfo(void *pSocketHandle, void *pData, int nLen)
{
	OtherInfo *tag = (OtherInfo *)pData;

	if (tag->nMainType == 1 && (tag->nSlaveType == 0 || tag->nSlaveType == 1))//手机卡和试用期共用
	{
		pDevicesManager->m_bIsBlanceSmall = false;
		pDevicesManager->m_sBanceContent.Format("%s", tag->sData1);
	}

	//pDevicesManager->m_sServerVer.Format( "%s",tag->Ver );
}