#include "stdafx.h"
#include ".\serversocket.h"

//#include "stdafx.h"
#include <comdef.h>
#include <atlbase.h>
//#include "resource.h"
//#include "AboutBox.h"
#include "ThreadPool.hpp"
#include <strsafe.h>
#include "SysLib.h"
#include "ascprocess.h"
#include "VarProcess.h"
#include "rtuprocess.h"


const int SOCK_TCP  = SOCK_STREAM-1;
const int SOCK_UDP  = SOCK_DGRAM-1;
const int AF_IPV4   = 0;
const int AF_IPV6   = 1;

CServerSocket::CServerSocket(void)
{
	m_nSockType = SOCK_TCP;
	m_nMode = AF_IPV4;
	m_SocketServer.SetInterface(this);
}

CServerSocket::~CServerSocket(void)
{
}

///////////////////////////////////////////////////////////////////////////////

void CServerSocket::OnThreadBegin(CSocketHandle* pSH)
{
    ASSERT( pSH == m_SocketServer );
    (pSH);
    CString strAddr;
    SockAddrIn sockAddr;
    m_SocketServer->GetSockName(sockAddr);
    GetAddress( sockAddr, strAddr );
//    AppendText( _T("Server Running on: %s\r\n"), strAddr);
}

void CServerSocket::OnThreadExit(CSocketHandle* pSH)
{
    ASSERT( pSH == m_SocketServer );
    (pSH);
    //AppendText( _T("Server Down!\r\n"));
}

void CServerSocket::OnConnectionFailure(CSocketHandle* pSH, SOCKET newSocket)
{
    ASSERT( pSH == m_SocketServer );
    (pSH);
    CString strAddr;
    CSocketHandle sockHandle;
    SockAddrIn sockAddr;
    if (newSocket != INVALID_SOCKET)
    {
        sockHandle.Attach( newSocket );
        sockHandle.GetPeerName( sockAddr );
        GetAddress( sockAddr, strAddr );
        sockHandle.Close();
       // AppendText( _T("Connection abandoned: %s\r\n"), strAddr );
    }
    else
    {
        ;//AppendText( _T("Connection abandoned. Not a valid socket.\r\n"), strAddr );
    }
}

void CServerSocket::OnAddConnection(CSocketHandle* pSH, SOCKET newSocket)
{
    ASSERT( pSH == m_SocketServer );
    (pSH);
    CString strAddr;
    CSocketHandle sockHandle;
    SockAddrIn sockAddr;
	sockHandle.Attach( newSocket );
    sockHandle.GetPeerName( sockAddr );
    GetAddress( sockAddr, strAddr );
    sockHandle.Detach();
    //AppendText( _T("Connection established: %s\r\n"), strAddr );
}

void CServerSocket::OnDataReceived(CSocketHandle* pSH, const BYTE* pbData, DWORD dwCount, const SockAddrIn& addr)
{
    ASSERT( pSH == m_SocketServer );
    (pSH);
    //CString strAddr, strText;
    //USES_CONVERSION;
    //LPTSTR pszText = strText.GetBuffer(dwCount+1);
    //::StringCchCopyN(pszText, dwCount+1, A2CT(reinterpret_cast<LPCSTR>(pbData)), dwCount);
    //strText.ReleaseBuffer();
    //GetAddress( addr, strAddr );
	
	//int nBuffIndex = 0;
	////while (nBuffIndex<dwCount)
	////{
	//	ProtocolHeader *pHeader;// = (ProtocolHeader *)(char *)pszText;
	//	pHeader = ( ProtocolHeader* )&( ( unsigned char * )pbData )[ 0 ];
		//nBuffIndex++;
		//memcpy(*pHeader, (char *)pbData, dwCount);
	//}

//	memcpy(&Header, pbData, sizeof(ProtocolHeader));
	//TRACE("recv pack len = %d\r\n", dwCount); 
	CSocketHandle sockHandle;

	InitializeCriticalSection(&sockHandle.m_hClient2SrvSection);
	sockHandle.m_nPendingSize = 0;
	memset(sockHandle.m_PendingBuffer, 0, SOCKET_BUFFSIZE);

	BOOL bFind = FALSE;
	bFind = GetClientSocketHandle( sockHandle, addr );
	//OnCmdProcess( addr, pData, nLen );
	if( bFind )
	{
		ProcessData( sockHandle, pbData, dwCount );
		sockHandle.Detach();
	}

	DeleteCriticalSection(&sockHandle.m_hClient2SrvSection);
}

void CServerSocket::OnConnectionDropped(CSocketHandle* pSH)
{
    ASSERT( pSH == m_SocketServer );
    (pSH);
   // AppendText( _T("Connection lost with client.\r\n") );
}

void CServerSocket::OnConnectionError(CSocketHandle* pSH, DWORD dwError)
{
    ASSERT( pSH == m_SocketServer );
    (pSH);
    _com_error err(dwError);
    //AppendText( _T("Communication Error:\r\n%s\r\n"), err.ErrorMessage() );
}

int CServerSocket::OnCmdProcess(CSocketHandle &sockHandle, void *pData)
{
	ProtocolHeader *pHeader = (ProtocolHeader *)pData;
	/*TRACE2("pack len = %d, pack cmd = %d\r\n", pHeader->nLen, pHeader->nCmd);
	unsigned int tmp = CalcCheckSum(pHeader, pHeader->nLen);
	if(tmp != pHeader->Verify)  
	{	
		return -1;
	}*/

	switch (pHeader->nCmd)              
    {

		case CMD_DEV_ONLINE:            //读设备在线状态
			ProcessResDevOnline(sockHandle, pHeader);
			//ProcessResDevOnline(s, pHeader);
			break;

		case CMD_SINGLE_VAR_ONLINE:		//读单个变量在线状态命令
			ProcessResSingleVarOnline(sockHandle, pHeader);
			break;

		case CMD_MUL_VAR_ONLINE:		//读多个变量在线状态命令
			ProcessResMulVarOnline(sockHandle, pHeader);
			break;

		case CMD_READ_SINGLE_VAR_DATA:  //读单个变量内容或报警状态
			ProcessResReadSingleVarData(sockHandle, pHeader);
			break;

		case CMD_READ_MUL_VAR_DATA:	    //读多个变量内容或报警状态
			ProcessResReadMulVarData(sockHandle, pHeader);
			break;

		case CMD_WRITE_SINGLE_VAR_DATA:	//设置单个变量值
			ProcessResWriteSingleVarData(sockHandle, pHeader);
			break;

		case CMD_WRITE_MUL_VAR_DATA:    //设置多个变量值
			PrcocessResWriteMulVarData(sockHandle, pHeader);
			break;

		case CMD_DOG_DATA:              //软件狗数据
			ProcessResSoftDog(sockHandle, pHeader);
			break;

		case CMD_ALARM_CONFIRM:         //读报警确认数据
			ProcessResAlarmConfirm(sockHandle, pHeader);
			break;
		
		//请求读特殊变量的数据
		case CMD_READ_SPECIAL_SINGLE_VAR_DATA:
			ProcessResReadSpecSingleVarData(sockHandle, pHeader);

        default: return 0;
    }
    return 0;
}

BOOL CServerSocket::GetClientSocketHandle(CSocketHandle &sockHandle, const SockAddrIn &addr)
{
	BOOL bFind = FALSE;
	if ( m_SocketServer.IsOpen() )
	{
		USES_CONVERSION;

		if (m_nSockType == SOCK_TCP)
		{
			// unsafe access to Socket list!
	#ifdef SOCKHANDLE_USE_OVERLAPPED
			const SocketBufferList& sl = m_SocketServer.GetSocketList();
			for(SocketBufferList::const_iterator citer = sl.begin(); citer != sl.end(); ++citer)
	#else
			const SocketList& sl = m_SocketServer.GetSocketList();
			for(SocketList::const_iterator citer = sl.begin(); citer != sl.end(); ++citer)
	#endif
			{
				sockHandle.Attach( (*citer) );
				SockAddrIn sockAddr;
				sockHandle.GetPeerName(sockAddr);
				if( sockAddr == addr )
				{
					bFind = TRUE;
				}
			}
		}
	}

	return bFind;
}

void CServerSocket::ProcessData(CSocketHandle &sockHandle, const BYTE* pData, DWORD nLen)
{
    DWORD nBuffIndex = 0;

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

        if ( nProcessedLen == 0 )
        {
            // 没有收够包头，认为是非法包，扔掉
			TRACE("没有收够包头，认为是非法包，扔掉\r\n");
            break;
        }

        if ( sockHandle.m_nPendingSize == 0 )
        {
            if ( pHeader->nLen > SOCKET_BUFFSIZE )
            {
                // 包长度超过限制
				TRACE("pHeader->nLen超过限制\r\n");
            }

			if(-1 == OnCmdProcess( sockHandle, pHeader ))
            {
                //MessageBox( NULL, "Error OnCmdProcess", NULL, MB_OK );
				TRACE("crc校验错误！\r\n");
                break;
            }
        }

        nBuffIndex += nProcessedLen;
	}

	LeaveCriticalSection( &(sockHandle.m_hClient2SrvSection) );
}

void CServerSocket::SocketStop()
{
    m_SocketServer.Terminate();
}

int	CServerSocket::SvrStart(CString strPort)
{
	int nFamily = (m_nMode == AF_IPV4) ? AF_INET : AF_INET6;
    if (!m_SocketServer.StartServer(NULL, strPort, nFamily, (m_nSockType+1) ))
    {
		;//MessageBox(NULL,_T("Failed to start server."), NULL, MB_ICONSTOP);
    };
	return 0;
}

bool CServerSocket::GetDestination(SockAddrIn& addrIn) const
{
    CString strPort;
    //GetDlgItemText(IDC_SVR_PORT, strPort);
    int nFamily = (m_nMode == AF_IPV4) ? AF_INET : AF_INET6;
    return addrIn.CreateFrom(NULL, strPort, nFamily);
}

void CServerSocket::SocketSend(CSocketHandle &sockHandle, unsigned char *pMsg, int iLength)
{
	if ( m_SocketServer.IsOpen() )
	{
		USES_CONVERSION;

		if (m_nSockType == SOCK_TCP)
		{
			// unsafe access to Socket list!
			const LPBYTE lpbData = (const LPBYTE)(pMsg);
			sockHandle.Write(lpbData, iLength, NULL);
		}
		else
		{
			SockAddrIn servAddr, sockAddr;
			m_SocketServer->GetSockName(servAddr);
			GetDestination(sockAddr);
			if ( servAddr != sockAddr ) {
				m_SocketServer.Write((const LPBYTE)*pMsg, iLength, sockAddr);
			} else {
				//AppendText( _T("Please change the port number to send message to a client.\r\n") );
			}
		}
	}
	else
	{
		;//MessageBox(NULL,_T("Socket is not connected"), "TEST", MB_ICONSTOP);
	}
}

void CServerSocket::GetAddress(const SockAddrIn& addrIn, CString& rString) const
{
    TCHAR szIPAddr[MAX_PATH] = { 0 };
    CSocketHandle::FormatIP(szIPAddr, MAX_PATH, addrIn);
    rString.Format(_T("%s : %d"), szIPAddr, static_cast<int>(static_cast<UINT>(ntohs(addrIn.GetPort()))) );
}

int CServerSocket::ProcessResDevOnline(CSocketHandle &sockHandle, void *pBuffer)
{
	DevOnline *tmpDevOnline = (DevOnline *)pBuffer;
	ReqDevOnline tmpReqline = {0};
	tmpReqline.Header.nCmd = tmpDevOnline->Header.nCmd;
	tmpReqline.Header.nCmdType = tmpDevOnline->Header.nCmdType;
	memcpy(&tmpReqline.DevUid, tmpDevOnline->DevUid, sizeof(tmpDevOnline->DevUid));
	tmpReqline.nOnline = 0;
	tmpReqline.nStatus = 0;

	tmpReqline.Header.Verify = 0;
	tmpReqline.Header.nLen = 44;
	int nSendLen = tmpReqline.Header.nLen;
  
	tmpReqline.Header.Verify = CalcCheckSum( &tmpReqline, nSendLen );
	
	g_pTcpServer->SocketSend(sockHandle, (unsigned char *)&tmpReqline, nSendLen);

	return 0;

}

//单个变量应答设备在线状态
int CServerSocket::ProcessResSingleVarOnline(CSocketHandle &sockHandle, void *pBuffer)
{  
	SingleVarOnline *tmpSnVarline = (SingleVarOnline *)pBuffer;
	ReqSingleVarOnline tmpReqSnVarline;
	memset(&tmpReqSnVarline, 0, sizeof(ReqSingleVarOnline) );
	tmpReqSnVarline.Header.nCmd = tmpSnVarline->Header.nCmd;
	tmpReqSnVarline.Header.nCmdType = tmpSnVarline->Header.nCmdType;
	memcpy(&tmpReqSnVarline.DevUid, tmpSnVarline->DevUid, sizeof(tmpSnVarline->DevUid));
	
	tmpReqSnVarline.DevChildVar.nOnline = 0x01;
	tmpReqSnVarline.DevChildVar.nStatus = 0x02;
	//memcpy(tmpReqSnVarline.DevChildVar.pVarUid, tmpSnVarline->VarUid, sizeof(tmpSnVarline->VarUid));
	tmpReqSnVarline.DevChildVar.iVarid = tmpSnVarline->iVarid;

	tmpReqSnVarline.Header.Verify = 0;
	tmpReqSnVarline.Header.nLen = sizeof(ReqSingleVarOnline);
	int nSendLen = tmpReqSnVarline.Header.nLen;
	tmpReqSnVarline.Header.Verify = CalcCheckSum( &tmpReqSnVarline, nSendLen );

	g_pTcpServer->SocketSend(sockHandle, (unsigned char *)&tmpReqSnVarline, nSendLen);
	
	return 0;
}

//应答多个变量在线状态
int CServerSocket::ProcessResMulVarOnline(CSocketHandle &sockHandle, void *pBuffer)
{
	char *pResBuffer = NULL;
	char *pVarUid = NULL;
	char *pDataBuffer =(char *)pBuffer;

	vector<ChildVar> vChildVar;
	ChildVar tmpChildVar={0};
	
	//取数据的包头，设备UID，变量的数量
	MulVarOnline tmpMulVarline = {0};
	memcpy(&tmpMulVarline, pDataBuffer, sizeof(MulVarOnline));
	
	//所有变量的ID的长度
	int iVarUidsLen = tmpMulVarline.nVarSum * sizeof(tmpChildVar.iVarid);
	pVarUid = new char[iVarUidsLen];

	//取所有变量的ID
	memcpy(pVarUid,( pDataBuffer + sizeof(MulVarOnline)), iVarUidsLen);

	for(int i = 0; i< tmpMulVarline.nVarSum; i++)
	{
		memcpy(&tmpChildVar.iVarid, pVarUid + i*sizeof(tmpChildVar.iVarid), sizeof(tmpChildVar.iVarid));
		tmpChildVar.nOnline = 1;
		tmpChildVar.nStatus = 2;
		vChildVar.push_back(tmpChildVar);
	}
	
	//求发送的应答数据包长度
	int nSendLen = tmpMulVarline.Header.nLen + 
					tmpMulVarline.nVarSum *(sizeof(tmpChildVar.nStatus) + 
					sizeof(tmpChildVar.nOnline));

	tmpMulVarline.Header.Verify = 0;
	
	tmpMulVarline.Header.nLen = nSendLen;

	pResBuffer = new char[nSendLen];
	
	//求校验位
	memcpy(pResBuffer, (char *)&tmpMulVarline, sizeof(MulVarOnline));

	for(int i = 0; i< tmpMulVarline.nVarSum; i++)
		memcpy(pResBuffer + sizeof(MulVarOnline) + i*sizeof(ChildVar), &vChildVar[i], sizeof(ChildVar));


	tmpMulVarline.Header.Verify = CalcCheckSum( &pResBuffer, nSendLen );
	
	//发送应答数据包
	memset(pResBuffer, 0, nSendLen);
	memcpy(pResBuffer, (char *)&tmpMulVarline, sizeof(MulVarOnline));

	for(int i = 0; i< tmpMulVarline.nVarSum; i++)
		memcpy(pResBuffer + sizeof(MulVarOnline) + i*sizeof(ChildVar), &vChildVar[i], sizeof(ChildVar));
		
	g_pTcpServer->SocketSend(sockHandle, (unsigned char *)pResBuffer, nSendLen);
	delete []pResBuffer;
	delete []pVarUid;
	
	return 0;

}

//读单个变量内容或报警状态
int CServerSocket::ProcessResReadSingleVarData(CSocketHandle &sockHandle, void *pBuffer)
{
	ReadSingleVarData *pReadSnVar = (ReadSingleVarData *)pBuffer;
	ReqSingleVarData tmpReqSnVar;
	
	memset(&tmpReqSnVar, 0, sizeof(ReqSingleVarData));
	tmpReqSnVar.Header.nCmd = pReadSnVar->Header.nCmd;
	tmpReqSnVar.Header.nCmdType = pReadSnVar->Header.nCmdType;
	memcpy(tmpReqSnVar.DevUid, pReadSnVar->DevUid, sizeof(pReadSnVar->DevUid));

	tmpReqSnVar.VarData.iVarid = pReadSnVar->iVarid;
	memset(&g_ReadOneData, 0, sizeof(READDEVREALDATA));

	SETBASEPARAM SetBasePara;
	char chDataLen[4] = {0};
	char chPort[4] = {0};
	char chAddr[4] = {0};
	char chSpecialdevice[2] = {0};

	GetOneVarProerty((char*)pReadSnVar->DevUid, pReadSnVar->iVarid,
		&SetBasePara, chDataLen, chPort, chAddr,chSpecialdevice);
	
	if (atoi(chSpecialdevice) == 0)
	{
		if (RtuRequestData(SetBasePara, chDataLen, chPort, chAddr)==0)
			RtuSingleResponseData((char*)pReadSnVar->DevUid, pReadSnVar->iVarid);
		else
			return -1;
	}
	else if (atoi(chSpecialdevice) == 1)
	{
		if (RequestData(SetBasePara, chDataLen, chPort, chAddr) == 0)
		{
			int nRet = SingleResponseData((char*)pReadSnVar->DevUid, pReadSnVar->iVarid);
			if( nRet != 0 )
			{
				return nRet;
			}
		}
		else
		{
			return ERR_CODE_MODBUS_ASC_COM_READ_NO_DATA;
		}
	}

	tmpReqSnVar.VarData.nStatus = g_ReadOneData.iStatus;
	tmpReqSnVar.VarData.Data = g_ReadOneData.dbData;

	tmpReqSnVar.Header.Verify = 0;
	tmpReqSnVar.Header.nLen = sizeof(ReqSingleVarData);
	int nSendLen = tmpReqSnVar.Header.nLen;

	tmpReqSnVar.Header.Verify = CalcCheckSum( &tmpReqSnVar, nSendLen );
	g_pTcpServer->SocketSend(sockHandle, (unsigned char *)&tmpReqSnVar, nSendLen);
	return 0;
}

//读多个变量内容或报警状态
int CServerSocket::ProcessResReadMulVarData(CSocketHandle &sockHandle, void *pBuffer)
{
	char* pResBuffer =NULL;
	MulVarData tmpMulVarData = {0};

	vector<ChildVarData> vChild_varData;
	ChildVarData tmpchildData = {0};

	char* pDataBuff = (char*)pBuffer;
	
	memcpy(&tmpMulVarData, pDataBuff, sizeof(MulVarData));
	
	//取所有变量的ID
	for(int i =0; i< tmpMulVarData.nVarSum; i++)
	{
		int iPos = sizeof(MulVarData) +i*sizeof(tmpchildData.iVarid);

		memcpy(&tmpchildData.iVarid, pDataBuff + iPos, sizeof(tmpchildData.iVarid));
		memset(&g_ReadOneData, 0, sizeof(READDEVREALDATA));

		SETBASEPARAM SetBasePara;
		char chDataLen[4] = {0};
		char chPort[4] = {0};
		char chAddr[4] = {0};
		char chSpecialdevice[2] = {0};

		GetOneVarProerty((char*)tmpMulVarData.DevUid, tmpchildData.iVarid, &SetBasePara,
			chDataLen, chPort, chAddr, chSpecialdevice);

		if (atoi(chSpecialdevice) == 0)
		{
			if (RtuRequestData(SetBasePara, chDataLen, chPort, chAddr)==0)
				RtuSingleResponseData((char*)tmpMulVarData.DevUid, tmpchildData.iVarid);
			else
				return -1;
		}
		else if (atoi(chSpecialdevice) == 1)
		{

			if (RequestData(SetBasePara, chDataLen, chPort, chAddr)==0)
				SingleResponseData((char*)tmpMulVarData.DevUid, tmpchildData.iVarid);
			else
				return -1;
			
		}
		
		tmpchildData.Data = g_ReadOneData.dbData;//2.2;
		tmpchildData.nStatus = g_ReadOneData.iStatus;

		vChild_varData.push_back(tmpchildData);

	}
	
	//求发送的应答数据包长度
	int nSendLen = tmpMulVarData.Header.nLen + 
					tmpMulVarData.nVarSum *(sizeof(tmpchildData.nStatus) + 
					sizeof(tmpchildData.Data));

	tmpMulVarData.Header.Verify = 0;
	
	tmpMulVarData.Header.nLen = nSendLen;

	pResBuffer = new char[nSendLen];
	
	//求校验位
	memcpy(pResBuffer, (char *)&tmpMulVarData, sizeof(MulVarData));

	for(int i = 0; i< tmpMulVarData.nVarSum; i++)
		memcpy(pResBuffer + sizeof(MulVarData) + i*sizeof(ChildVarData), &vChild_varData[i], sizeof(ChildVarData));


	tmpMulVarData.Header.Verify = CalcCheckSum( &pResBuffer, nSendLen );
	
	//发送应答数据包
	memset(pResBuffer, 0, nSendLen);
	memcpy(pResBuffer, (char *)&tmpMulVarData, sizeof(MulVarData));

	for(int i = 0; i< tmpMulVarData.nVarSum; i++)
		memcpy(pResBuffer + sizeof(MulVarData) + i*sizeof(ChildVarData), &vChild_varData[i], sizeof(ChildVarData));
		
	g_pTcpServer->SocketSend(sockHandle, (unsigned char *)pResBuffer, nSendLen);
	delete []pResBuffer;

	return 0;	
}

//设置单个变量值
int CServerSocket::ProcessResWriteSingleVarData(CSocketHandle &sockHandle, void *pBuffer)
{
	//30 00 00 00 0E 00 00 00 00 00 00 00 00 00 00 00 31 2E 31 2E 31 2E 31
	//00 00 00 00 00 00 00 00 00 00 00 00 00 01 00 00 00   9A 99 99 99 99 99 01 40
	
	WrSingleVarData *pWrSnVarData = (WrSingleVarData*)pBuffer;//请求数据包
	ReqWrSingleVarData tmpReqWrSnVar;//应答数据包
	
	//设置命令、命令类型、设备UID、变量UID
	memset(&tmpReqWrSnVar, 0, sizeof(ReqWrSingleVarData));
	tmpReqWrSnVar.Header.nCmd = pWrSnVarData->Header.nCmd;
	tmpReqWrSnVar.Header.nCmdType = pWrSnVarData->Header.nCmdType;
	memcpy(tmpReqWrSnVar.DevUid, pWrSnVarData->DevUid, sizeof(pWrSnVarData->DevUid));

	tmpReqWrSnVar.ReqVarData.iVarid = pWrSnVarData->VarData.iVarid;
	//memcpy(tmpReqWrSnVar.ReqVarData.iVarid, pWrSnVarData->VarData.iVarid, sizeof(pWrSnVarData->VarData.VarUid)); 
	
	//pWrSnVarData->VarData.Data = 13.5;
	//g_ReadOneData.dbData = pWrSnVarData->VarData.Data;//数据
	//char tmpdata[4] = {'0','1','0','3'};
	//pWrSnVarData->VarData.Data = atof(tmpdata);
	memset(&g_ReadOneData, 0, sizeof(READDEVREALDATA));
	if (RequestWrData((char*)tmpReqWrSnVar.DevUid, 
		tmpReqWrSnVar.ReqVarData.iVarid, pWrSnVarData->VarData.Data) == 0)
	{
		SingleResponseWriteData((char*)tmpReqWrSnVar.DevUid,tmpReqWrSnVar.ReqVarData.iVarid);
		if (g_ReadOneData.dbData != pWrSnVarData->VarData.Data)//判断设置数据是否一致
			tmpReqWrSnVar.ReqVarData.nStatus = -1;
	}
	else
	{
		tmpReqWrSnVar.ReqVarData.nStatus = -1;
	}


	tmpReqWrSnVar.Header.Verify = 0;//校验码
	tmpReqWrSnVar.Header.nLen = sizeof(ReqWrSingleVarData);//数据包长度
	int nSendLen = tmpReqWrSnVar.Header.nLen;

	tmpReqWrSnVar.Header.Verify = CalcCheckSum( &tmpReqWrSnVar, nSendLen );//进行校验

	//通过COM232设置变量值
	//pWrSnVarData->VarData.Data
	//........

	//SendMsgToClient(s, &tmpReqWrSnVar, nSendLen);//发送命令包
	g_pTcpServer->SocketSend(sockHandle, (unsigned char *)&tmpReqWrSnVar, nSendLen);
	
	return 0;
}

int CServerSocket::PrcocessResWriteMulVarData(CSocketHandle &sockHandle, void *pBuffer)
{
	char* pResBuffer = NULL;
	WrMulVarData tmpWrMulVarData = {0};

	vector <ChildWrVarData> vChildWrData;
	vector <ChildReqWrVarData> vChildReqWrVarData;

	ChildWrVarData tmpChildvarData = {0};
	ChildReqWrVarData tmpChildReqVarData = {0};

	char* pDataBuffer = (char*)pBuffer;

	memset(&tmpWrMulVarData, 0, sizeof(WrMulVarData));

	memcpy(&tmpWrMulVarData, pDataBuffer, sizeof(WrMulVarData));

	ASSERT(tmpWrMulVarData.nVarSum > 0);

	for(int i=0; i< tmpWrMulVarData.nVarSum; i++)
	{
		int iPos = sizeof(WrMulVarData) + i*sizeof(ChildWrVarData);
		memcpy(&tmpChildvarData, pDataBuffer + iPos, sizeof(ChildWrVarData));
		
		tmpChildReqVarData.iVarid = tmpChildvarData.iVarid;
		//memcpy(&tmpChildReqVarData.VarUid, tmpChildvarData.VarUid, sizeof(tmpChildvarData.VarUid));
		
		tmpChildReqVarData.nStatus = 1;

		vChildWrData.push_back(tmpChildvarData);
		vChildReqWrVarData.push_back(tmpChildReqVarData);
	}
	
	//包长度
	int nSendLen = sizeof(WrMulVarData) + tmpWrMulVarData.nVarSum *(sizeof(tmpChildReqVarData.nStatus) + 
					sizeof(tmpChildReqVarData.iVarid));	
	tmpWrMulVarData.Header.nLen = nSendLen;

	pResBuffer = new char[nSendLen];


	//求校验位
	memcpy(pResBuffer, (char *)&tmpWrMulVarData, sizeof(WrMulVarData));

	for(int i = 0; i< tmpWrMulVarData.nVarSum; i++)
	{
		int iPos = sizeof(WrMulVarData) + i*sizeof(ChildReqWrVarData);
		memcpy(pResBuffer + iPos, &vChildReqWrVarData[i], sizeof(ChildReqWrVarData));

	}
	tmpWrMulVarData.Header.Verify = CalcCheckSum( &pResBuffer, nSendLen );
	
	//发送应答数据包
	memset(pResBuffer, 0, nSendLen);

	memcpy(pResBuffer, (char *)&tmpWrMulVarData, sizeof(WrMulVarData));
	for(int i = 0; i< tmpWrMulVarData.nVarSum; i++)
	{
		int iPos = sizeof(WrMulVarData) + i*sizeof(ChildReqWrVarData);
		memcpy(pResBuffer + iPos, &vChildReqWrVarData[i], sizeof(ChildReqWrVarData));

	}

	g_pTcpServer->SocketSend(sockHandle, (unsigned char *)pResBuffer, nSendLen);
	delete []pResBuffer;


	return 0;

}

int CServerSocket::ProcessResSoftDog(CSocketHandle &sockHandle, void *pBuffer)
{
	//char* pResBuffer = NULL;
	
	//char *pDevUid = NULL;
	//char *pDataBuffer =(char *)pBuffer;

	//Dog_Data tmpDogData = {0};
	//ReqDogData tmpReqDogData = {0};

	//vector <ChildDogData> vChildDog;
	//ChildDogData tmpChildDog;

	//memcpy(&tmpDogData, pDataBuffer, sizeof(Dog_Data));

	//for (int i=0; i<tmpDogData.nDevSum; i++)
	//{
	//	memcpy(tmpChildDog.DevUid, pDataBuffer, );

	//}
	return 0;
}

int CServerSocket::ProcessResAlarmConfirm(CSocketHandle &sockHandle, void *pBuffer)
{
	AlarmConfirm *tmpaLarmConfirm = (AlarmConfirm *) pBuffer;
	ReqAlarmConfirm tmpReqAlarmConfirm = {0};

	tmpReqAlarmConfirm.Header.nCmd = tmpaLarmConfirm->Header.nCmd;
	tmpReqAlarmConfirm.Header.nCmdType = tmpaLarmConfirm->Header.nCmdType;

	memcpy(&tmpReqAlarmConfirm.DevUid, tmpaLarmConfirm->DevUid, sizeof(tmpaLarmConfirm->DevUid));
	tmpReqAlarmConfirm.iVarid = tmpaLarmConfirm->iVarid;
	//memcpy(&tmpReqAlarmConfirm.VarUid, tmpaLarmConfirm->VarUid, sizeof(tmpaLarmConfirm->VarUid));
	tmpReqAlarmConfirm.nStauts = 1;

	tmpReqAlarmConfirm.Header.nLen = sizeof(ReqAlarmConfirm);
	
	tmpReqAlarmConfirm.Header.Verify = CalcCheckSum(&tmpReqAlarmConfirm, tmpReqAlarmConfirm.Header.nLen);

	g_pTcpServer->SocketSend(sockHandle, (unsigned char *)&tmpReqAlarmConfirm, tmpReqAlarmConfirm.Header.nLen);

	return 0;
}

//请求读特殊变量的数据
int CServerSocket::ProcessResReadSpecSingleVarData(CSocketHandle &sockHandle, void *pBuffer)
{
	ReadSingleSpecialVarData *pReadSpecSnVar = (ReadSingleSpecialVarData *)pBuffer;
	ReqSingleSpecialVarData tmpReqSpecSnVar;
	
	memset(&tmpReqSpecSnVar, 0, sizeof(ReqSingleSpecialVarData));
	tmpReqSpecSnVar.Header.nCmd = pReadSpecSnVar->Header.nCmd;
	tmpReqSpecSnVar.Header.nCmdType = pReadSpecSnVar->Header.nCmdType;
	memcpy(tmpReqSpecSnVar.DevUid, pReadSpecSnVar->DevUid, sizeof(pReadSpecSnVar->DevUid));
	tmpReqSpecSnVar.iSpecialFlag = pReadSpecSnVar->iSpecialFlag;
	tmpReqSpecSnVar.VarData.iVarid = pReadSpecSnVar->iVarid;

	memset(&g_ReadOneData, 0, sizeof(READDEVREALDATA));
	if (RequestSpecData((char*)pReadSpecSnVar->DevUid, pReadSpecSnVar->iVarid, pReadSpecSnVar->iSpecialFlag) == 0)
	{
		int nRet = SingleResponseSpecialVarData((char*)pReadSpecSnVar->DevUid, pReadSpecSnVar->iVarid, pReadSpecSnVar->iSpecialFlag);
		if( nRet != 0 )
		{
			return nRet;
		}
	}
	else
	{
		return ERR_CODE_MODBUS_ASC_COM_READ_NO_DATA;
	}

	tmpReqSpecSnVar.VarData.nStatus = g_ReadOneData.iStatus;
	tmpReqSpecSnVar.VarData.Data = g_ReadOneData.dbData;

	tmpReqSpecSnVar.Header.Verify = 0;
	tmpReqSpecSnVar.Header.nLen = sizeof(ReqSingleSpecialVarData);
	int nSendLen = tmpReqSpecSnVar.Header.nLen;

	tmpReqSpecSnVar.Header.Verify = CalcCheckSum( &tmpReqSpecSnVar, nSendLen );
	g_pTcpServer->SocketSend(sockHandle, (unsigned char *)&tmpReqSpecSnVar, nSendLen);
	return 0;
}

//请求读特殊变量的数据
int CServerSocket::ProcessResReadSpecMulVarData(CSocketHandle &sockHandle, void *pBuffer)
{
	char* pResBuffer =NULL;
	MulSpecialVarData tmpMulVarData = {0};
	 

	vector<ChildVarData> vChild_varData;
	ChildVarData tmpchildData = {0};

	char* pDataBuff = (char*)pBuffer;
	
	memcpy(&tmpMulVarData, pDataBuff, sizeof(MulSpecialVarData));
	
	//取所有变量的ID
	for(int i =0; i< tmpMulVarData.nVarSum; i++)
	{
		int iPos = sizeof(MulSpecialVarData) +i*sizeof(tmpchildData.iVarid);

		memcpy(&tmpchildData.iVarid, pDataBuff + iPos, sizeof(tmpchildData.iVarid));
		memset(&g_ReadOneData, 0, sizeof(READDEVREALDATA));

		SETBASEPARAM SetBasePara;
		char chDataLen[4] = {0};
		char chPort[4] = {0};
		char chAddr[4] = {0};
		char chSpecialdevice[2] = {0};

		GetOneVarProerty((char*)tmpMulVarData.DevUid, tmpchildData.iVarid, &SetBasePara,
			chDataLen, chPort, chAddr, chSpecialdevice);

		if (atoi(chSpecialdevice) == 0)
		{
			if (RtuRequestData(SetBasePara, chDataLen, chPort, chAddr)==0)
				RtuSingleResponseData((char*)tmpMulVarData.DevUid, tmpchildData.iVarid);
			else
				return -1;

		}
		else if (atoi(chSpecialdevice) == 1)
		{
			if (RequestData(SetBasePara, chDataLen, chPort, chAddr)==0)
				SingleResponseData((char*)tmpMulVarData.DevUid, tmpchildData.iVarid);
			else
				return -1;
		}

		tmpchildData.Data = g_ReadOneData.dbData;//2.2;
		tmpchildData.nStatus = g_ReadOneData.iStatus;

		vChild_varData.push_back(tmpchildData);

	}
	
	//求发送的应答数据包长度
	int nSendLen = tmpMulVarData.Header.nLen + 
					tmpMulVarData.nVarSum *(sizeof(tmpchildData.nStatus) + 
					sizeof(tmpchildData.Data));

	tmpMulVarData.Header.Verify = 0;
	
	tmpMulVarData.Header.nLen = nSendLen;

	pResBuffer = new char[nSendLen];
	
	//求校验位
	memcpy(pResBuffer, (char *)&tmpMulVarData, sizeof(MulSpecialVarData));

	for(int i = 0; i< tmpMulVarData.nVarSum; i++)
		memcpy(pResBuffer + sizeof(MulVarData) + i*sizeof(ChildVarData), &vChild_varData[i], sizeof(ChildVarData));


	tmpMulVarData.Header.Verify = CalcCheckSum( &pResBuffer, nSendLen );
	
	//发送应答数据包
	memset(pResBuffer, 0, nSendLen);
	memcpy(pResBuffer, (char *)&tmpMulVarData, sizeof(MulSpecialVarData));

	for(int i = 0; i< tmpMulVarData.nVarSum; i++)
		memcpy(pResBuffer + sizeof(MulSpecialVarData) + i*sizeof(ChildVarData), &vChild_varData[i], sizeof(ChildVarData));
		
	g_pTcpServer->SocketSend(sockHandle, (unsigned char *)pResBuffer, nSendLen);
	delete []pResBuffer;

	return 0;	
}