repos_ecs/源数据/PC环境监控/tryto v1.0.0.3/演示IDE/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 );
	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 );
	pAnalog->m_fData = (float)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 );
	pAnalog->m_fData = (float)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 );
}

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;
}

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

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;
	}

	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::GetDogInfo( void *pSocketHandle )
{
	if( pSocketHandle==NULL )
		return FALSE;

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

	tag.Header.nLen = nLen;
	tag.Header.nCmd = CMD_DOG_DATA;
	tag.Header.nCmdType = 0;
	
	tag.nPastDue = 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;
	
	pEventServer->AddAlarmEvent(
		pAlarmData->DevUid,
		pAlarmData->nVarID,
		pAlarmData->nStatus,
		pAlarmData->sContent,
		pAlarmData->Data,
		pAlarmData->nUpperLimit,
		pAlarmData->nLowerLimit,
		pAlarmData->nNormalState,
		pAlarmData->nAlarmState,
		pAlarmData->nAlarmIndex
		);
}