#include "StdAfx.h"
#include "DataProcess.h"
#include "SockProcess.h"
HANDLE g_hStdOut;

unsigned int CRunDataProcesser::s_nSndThreadSleepTime = 20;
extern bool g_ServerIsRunning;

//接收数据的线程
#ifdef _MSC_VER
VOID STDCALL CRunDataProcesser::RecvDataProcdaessRoutine(void *arg)
#else
VOID* CRunDataProcesser::RecvDataProcessRoutine(void *arg)
#endif
{	
	CRunDataProcesser * pRunData = (CRunDataProcesser *)arg;

	//LPCRITICAL_SECTION pQueueLock;
	CBaseList<LPVOID>  *pRecvList;
	PCLIENTRECVBUF *ppRecvBufs, pRecvBuf;
	PRUNGATEUSERSESSION pSession;
	INT_PTR nBufferCount;
	TICKCOUNT dwProcStartTick, dwLockDataTick, dwLockCheckTick, dwSendCheckTick, dwPerfDumpTick, dwSendGateUserInfo;

	//pQueueLock = &pRunData->m_RecvQueueLock;
	pRecvList  = pRunData->m_pRecvProcList;	
	pRunData->m_llSendKeepAliveTime = 0;
	dwLockDataTick = dwLockCheckTick = dwPerfDumpTick = dwSendGateUserInfo = _getTickCount();
	dwSendCheckTick = dwSendGateUserInfo + 2000;
	while ( !pRunData->m_boStoping )
	{		
		dwProcStartTick = _getTickCount();

		//发送网关自检
		if ( dwProcStartTick - dwSendCheckTick >= 2000 )
		{
			pRunData->SendCheck( GM_CHECKSERVER );
			dwSendCheckTick = dwProcStartTick;
			pRunData->m_llSendKeepAliveTime = dwSendCheckTick;			
		}

		// 发送网关用户数目，一分钟发一次
		if (dwProcStartTick - dwSendGateUserInfo >= 60000 )
		{
			pRunData->SendGateUserInfo();
			dwSendGateUserInfo = dwProcStartTick;
		}

		//检查会话关闭
		if ( dwProcStartTick - dwLockCheckTick >= 5000 )
		{
			if ( pRunData->CheckCloseSessions( dwProcStartTick - dwLockCheckTick >= 10000 ) )
			{
				dwProcStartTick = dwLockCheckTick = _getTickCount();
			}
		}
		// dump statistic
		if (dwProcStartTick - dwPerfDumpTick >= 120000)
		{
			CTimeProfMgr::getSingleton().dump();
			dwPerfDumpTick = dwProcStartTick;
		}

		//如果未能获得数据队列锁则让出本次CPU时间
		if ( !TryEnterCriticalSection( &pRunData->m_RecvQueueLock ) )
		{
			if ( dwProcStartTick - dwLockDataTick  < 60 )
			{
				Sleep( 1 );
				continue;
			}
			else
			{
				EnterCriticalSection( &pRunData->m_RecvQueueLock );
				dwProcStartTick = dwLockDataTick = _getTickCount();
			}
		}
		else dwLockDataTick = dwProcStartTick;

		//交换数据处理队列
		pRecvList = pRunData->m_pRecvAppendList;
		pRunData->m_pRecvAppendList = pRunData->m_pRecvProcList;
		pRunData->m_pRecvProcList = pRecvList;
		LeaveCriticalSection( &pRunData->m_RecvQueueLock );

		//如果没有待处理的数据则让出本次CPU时间
		nBufferCount = pRecvList->count();
		if ( !nBufferCount )
		{
			Sleep( 1 );
			continue;
		}

		ppRecvBufs = (PCLIENTRECVBUF*)(void**)(*pRecvList);
		while ( nBufferCount > 0 )
		{
			pRecvBuf = *ppRecvBufs;
			nBufferCount--;
			ppRecvBufs++;
			pSession = pRecvBuf->pSession;
			if ( pRecvBuf->nBufferSize > 0 )
			{
				//如果会话被关闭或效验过期则不予处理
				if ( pSession->nSocket != INVALID_SOCKET && pSession->nVerifyIdx == pRecvBuf->nVerify && !pSession->boMarkToClose && !pSession->boRemoteClosed )
				{
					pSession->dwClientMsgTick = dwProcStartTick;
					//OutputMsg( rmTip, "dwProcStartTick=%I64d",dwProcStartTick);
					pRunData->ProcessUserRecvPacket( pSession, (char*)(pRecvBuf + 1), pRecvBuf->nBufferSize );
					pSession->nRecvPacketCount++;
				}
			}
			free( pRecvBuf );
		}
		pRecvList->clear();
		pRunData->m_dwLastProcUsrMsgTime = _getTickCount() - dwProcStartTick;
		//循环小于指定时间则休眠一次
		//if ( pRunData->m_dwLastProcUsrMsgTime < 16 )
		if(TRUE)
		{
			Sleep ( 1 );
		}
	}
	ExitThread( 0 );
}

//发送数据的线程
#ifdef _MSC_VER
VOID STDCALL CRunDataProcesser::SendDataProcessRoutine(void* arg)
#else
VOID* CRunDataProcesser::SendDataProcessRoutine(void* arg)
#endif
{	
	PRUNDATASENDTHREAD pRunThread = (PRUNDATASENDTHREAD)arg;

	TICKCOUNT dwProcStartTick;
	CRunDataProcesser *pRunData;
	int nLockSendBufQLockFail = 0;
	pRunData = pRunThread->pRunData;
	
	while ( !pRunData->m_boStoping )
	{
		dwProcStartTick = _getTickCount();			
		if ( pRunData->CopyWaitSendBuffers( pRunThread, TRUE) )
			nLockSendBufQLockFail = 0;
		else nLockSendBufQLockFail ++;

		pRunData->CheckSendSessionBuffers( pRunThread );

		//循环小于指定时间则休眠一次
		pRunThread->dwProcTick = _getTickCount() - dwProcStartTick;
		//if ( pRunThread->dwProcTick < 20 )
		
		{			
			dwProcStartTick = _getTickCount();			
			Sleep(s_nSndThreadSleepTime);
			TICKCOUNT curTick = _getTickCount();			
			pRunThread->dwSleepTick = curTick - dwProcStartTick;
		}
		
		/*else 
			pRunThread->dwSleepTick = 0;*/
	}
	ExitThread( 0 );
}

//收到了服务器的数据,进行处理
//VOID CRunDataProcesser::ProcessRecvBuffers(const GateMsg* msg)
VOID CRunDataProcesser::ProcessRecvBuffers(const GATEMSGHDR* pHeader, LPCSTR pData, size_t nLen)
{
	Assert(pHeader->dwGateCode == RUNGATECODE);	
	/*if (msg->header.wIdent == GM_DATA)
		Assert(msg->header.wTemp == RUNTEMPCODE);*/
	if (s_nIgnoreDataPacket)
		return;
	//如果是关闭服务器的话
	if(pHeader->wIdent ==GM_CLOSE_SERVER)
	{
		OutputMsg(rmTip,"Back server close from back");
		g_ServerIsRunning = false;
		return;
	}
	else if (pHeader->wIdent == GM_APPBIGPACK)
	{
		char* pBuffEnd = (char *)pData + nLen;
		GATEMSGHDR* pCurHeader = (GATEMSGHDR *)pData;
		while ((char*)pCurHeader < pBuffEnd)
		{
			if (pCurHeader->dwGateCode != RUNGATECODE)
			{
				OutputMsg(rmError, _T("%s recv packet invalid..."), __FUNCTION__);
				break;
			}
			DispathRecvMessage(pCurHeader, (const char*)(pCurHeader+1), pCurHeader->nDataSize);
			pCurHeader = (GATEMSGHDR *)((char *)pCurHeader + (sizeof(GATEMSGHDR) + pCurHeader->nDataSize));
		}
	}
	else
		DispathRecvMessage((GATEMSGHDR * const)pHeader, pData, nLen);
}



VOID CRunDataProcesser::DispathRecvMessage(const PGATEMSGHDR pMsgHdr, const char *pBuffer, SIZE_T nBufSize)
{
		PRUNGATEUSERSESSION pSession;
		/*
		if(GM_DATA ==pMsgHdr->wIdent)
		{
			OutputMsg(rmTip,  _T("收到后台数据,cmd=%d,wSessionIdx=%d,wServerIdx=%d,socket=%d\n"), 
				pMsgHdr->wIdent, pMsgHdr->wSessionIdx,pMsgHdr->wServerIdx,pMsgHdr->nSocket);
		}
		*/
		switch ( pMsgHdr->wIdent )
		{
		case GM_CLOSE:
			if ( pMsgHdr->wSessionIdx < m_nMaxSessionCount )
			{
				pSession = &m_Sessions[pMsgHdr->wSessionIdx];
	
				if ( pSession->nSocket == pMsgHdr->nSocket && !pSession->boMarkToClose && !pSession->boRemoteClosed )
				{
					SendCloseSession( pSession, FALSE, enReasonGM  );
				}
				else 
				{
					OutputMsg( rmWaning, _T("GM_CLOSE socket不匹配  wSessionIdx=%d,本地Socket=%d,后台的为%d"),
						pMsgHdr->wSessionIdx, pSession->nSocket, pMsgHdr->nSocket );
				}
			
			}
			break;
		case GM_CHECKCLIENT:
			{
				// 保存服务器的时间
				if (m_llSendKeepAliveTime > 0)
				{
					if (m_nCheckTimeCount < 10)
					{				
						TICKCOUNT nTimeDiff = pMsgHdr->tickCount - _getTickCount();
						m_llOccuTimeDiff += nTimeDiff;				
						m_nCheckTimeCount++;
						m_llSvrTimeDiff = (long long)(m_llOccuTimeDiff / (float)m_nCheckTimeCount);
						OutputMsg(rmNormal, _T("timediff=%lld,result dif=%lld,checkTimecount=%d"), 
							nTimeDiff, 
							m_llSvrTimeDiff, 
							m_nCheckTimeCount);
					}
				}
				/*OutputMsg(rmNormal, _T("------logicSvrTime=%I64d  gateTime=%I64d, timeDif=%I64d"), pMsgHdr->tickCount, nCurrTick, m_llSvrTimeDiff);*/
			}
			break;
		case GM_APPKEEPALIVE:
			{
				// 给服务器会应答消息			
				pSession = &m_Sessions[pMsgHdr->wSessionIdx];
				if ( pSession->nSocket == pMsgHdr->nSocket && !pSession->boMarkToClose && !pSession->boRemoteClosed )
				{
					SendKeepAliveAck( pSession, pBuffer, nBufSize);
				}
				break;
			}
		case GM_SERVERUSERINDEX:
			if ( pMsgHdr->wSessionIdx < m_nMaxSessionCount )
			{
				pSession = &m_Sessions[pMsgHdr->wSessionIdx];
				if ( pSession->nSocket == pMsgHdr->nSocket && !pSession->boMarkToClose && !pSession->boRemoteClosed )
				{
					pSession->nServerIdx = pMsgHdr->wServerIdx;
					OutputMsg(rmNormal, _T("recv GM_ServerIndex msg. socket=%d, sessionId=%d, set serverIdx=%d"), 
						(int)pSession->nSocket, (int)pSession->nIndex, pSession->nServerIdx);
				}
				else
				{
					OutputMsg(rmError, _T("GM_ServerIndex Error, session closed or socket unmatch(session socket=%d, sessionId=%d, msghdr socket=%d"),
						(int)pSession->nSocket, (int)pSession->nIndex, (int)pMsgHdr->nSocket);
				}
			}
			break;
		
		case GM_DATA:
			if ( pMsgHdr->wSessionIdx < m_nMaxSessionCount )
			{
				pSession = &m_Sessions[pMsgHdr->wSessionIdx];
				if ( !pSession->boMarkToClose && !pSession->boRemoteClosed )
				{
					if ( pSession->nSocket == pMsgHdr->nSocket )
					{
						PostUserServerData( pSession, pBuffer, (INT)nBufSize, TRUE, TRUE, (TICKCOUNT)pMsgHdr->tickCount);
					}
					else
					{
						OutputMsg( rmWaning, "GM_DATA 会话(%d:%s)套接字不匹配，data Socket=%d,local socket=%d", pMsgHdr->wSessionIdx, pSession->sLoginCharName, pMsgHdr->nSocket,pSession->nSocket );
						//SendCloseSession((SOCKET)pMsgHdr->nSocket); //如果套接字不匹配
						//SendCloseSession( pSession, TRUE, enReasonAllSessionClose  );
					}
				
				}
				else 
				{
					OutputMsg( rmWaning, "GM_DATA 会话(%d:%s,%d,%d)已关闭", pMsgHdr->wSessionIdx, pSession->sLoginCharName,
						(int)(pSession->boMarkToClose),(int)(pSession->boRemoteClosed));
					//这种情况下再次向逻辑发送关闭连接
					//SendCloseSession((SOCKET)pMsgHdr->nSocket);
				}
			}
			else OutputMsg( rmWaning, "GM_DATA 会话ID无效(%d)", pMsgHdr->wSessionIdx );
			break;
			
		default:
			{
				GotError( __FUNCTION__, _T("无效的消息序列"), pMsgHdr->wIdent );
			}
			break;
		}
	
}

VOID CRunDataProcesser::OnConnected()
{
	Inherited::OnConnected();
	m_llSendKeepAliveTime = 0;
	m_nCheckTimeCount = 0;
	m_llOccuTimeDiff = 0;
	OutputMsg(rmTip, _T("BackServer Connected"));
}

VOID CRunDataProcesser::OnClosed()
{
	Inherited::OnClosed();
	CloseAllSessions(true);
}

VOID CRunDataProcesser::OnError(int errorCode)
{
	OutputError(errorCode, _T("BackServer Socket Error "));
}

VOID CRunDataProcesser::OnDisconnected()
{
	m_llSvrTimeDiff		= 0;
	m_nCheckTimeCount	= 0;
	m_llOccuTimeDiff	= 0;	
	OutputMsg(rmWaning, _T("BackServer Connection Closed"));
}

CRunDataProcesser::CRunDataProcesser(const int nMaxSessionCount)
	:Inherited()
{
	m_nActiveUser = 0;
	m_boStoping	  = FALSE;
	m_boStarted	  = FALSE;

	m_DataProcessType	= dp_Default;

	/*
	m_hPipe = INVALID_HANDLE_VALUE;
	strcpy( m_sPipeName, "\\\\.\\pipe\\default" );

	sprintf( m_sGateName, "游戏网关%d", _getTickCount() % 100 );
	*/

	m_hProcRecvThread	= NULL;
	ZeroMemory( m_SendThreads, sizeof(m_SendThreads) );

	m_nSendThreadCount	= 2;
	m_nMaxSessionCount	= nMaxSessionCount;  // 默认值: 16384
	m_Sessions	= NULL;
	m_pSockProcesser = NULL;

	InitializeCriticalSection( &m_SessionLock );
	if ( m_Sessions ) ZeroMemory( m_Sessions, sizeof(m_Sessions) );


	InitializeCriticalSection( &m_RecvQueueLock );
	m_pRecvAppendList = &m_RecvQueue[0];
	m_pRecvProcList	  = &m_RecvQueue[1];

	m_ServerBuf.lpBuffer= NULL;
	m_ServerBuf.nSize	= 0;
	m_ServerBuf.nOffset	= 0;

	m_nUserVerify		= 1;
	m_dwProcessRecvSize = 0;

	m_boPrintC2SMsg = FALSE;
	m_boPrintS2CMsg = FALSE;

	m_llSvrTimeDiff = 0;
	m_nCheckTimeCount = 0;
	m_llOccuTimeDiff = 0;
	InitSendThreadData();
	//m_DataPacker.SetNeedEncrypt(true); //需要加密
}

CRunDataProcesser::~CRunDataProcesser()
{
	Stop();
	UninitSendThreadData();
	DeleteCriticalSection( &m_RecvQueueLock );
	DeleteCriticalSection( &m_SessionLock );
}

VOID CRunDataProcesser::InitSessions()
{
	int i;
	PRUNGATEUSERSESSION pSession;

	EnterCriticalSection( &m_SessionLock );
	if ( !m_Sessions )
	{
		m_Sessions = (PRUNGATEUSERSESSION)malloc(sizeof(m_Sessions[0]) * m_nMaxSessionCount);
		ZeroMemory( m_Sessions, sizeof(m_Sessions[0]) * m_nMaxSessionCount );
	}
	pSession = m_Sessions;
	for ( i=0; i<m_nMaxSessionCount; ++i )
	{
		pSession->nIndex	= i;
		pSession->nSocket	= INVALID_SOCKET;
#ifdef WIN32
		pSession->Overlapped.pUser = pSession;
#endif
		pSession->nServerIdx		= 0;
		pSession->btPacketIdx		= 0;
		pSession->wPacketError		= 0;
		pSession->nRecvPacketCount	= 0;
		pSession->nSendPacketCount	= 0;
		pSession->boMarkToClose		= false;
		pSession->boRemoteClosed	= false;
		pSession->boSendAvaliable	= true;
		INIT_SESSION_SEND( pSession );
		pSession++;
	}
	LeaveCriticalSection( &m_SessionLock );
}

VOID CRunDataProcesser::UninitSessions()
{
	int i;
	PRUNGATEUSERSESSION pSession;

	if ( !m_Sessions ) return;
	EnterCriticalSection( &m_SessionLock );
	pSession = m_Sessions;
	for ( i=0; i<m_nMaxSessionCount; ++i )
	{
		if ( pSession->RecvBuf.lpBuffer )
		{
			free( pSession->RecvBuf.lpBuffer );
			pSession->RecvBuf.lpBuffer = NULL;
			pSession->RecvBuf.nSize = pSession->RecvBuf.nOffset = 0;
		}
		if ( pSession->SendBuf.lpBuffer )
		{
			free( pSession->SendBuf.lpBuffer );
			pSession->SendBuf.lpBuffer = NULL;
			pSession->SendBuf.nSize = pSession->SendBuf.nOffset = 0;
		}
		UNINIT_SESSION_SEND( pSession );
		pSession++;
	}
	free( m_Sessions );
	m_Sessions = NULL;
	LeaveCriticalSection( &m_SessionLock );
}

VOID CRunDataProcesser::FreeRecvBuffers()
{
	INT_PTR i;
	void **pBuffers;
	EnterCriticalSection( &m_RecvQueueLock );

	pBuffers = *m_pRecvAppendList;
	for ( i=m_pRecvAppendList->count()-1; i>-1; --i )
	{
		free( pBuffers[i] );
	}
	m_pRecvAppendList->clear();

	
	pBuffers = *m_pRecvProcList;
	for ( i=m_pRecvProcList->count()-1; i>-1; --i )
	{
		free( pBuffers[i] );
	}
	m_pRecvProcList->clear();

	LeaveCriticalSection( &m_RecvQueueLock );
}

VOID CRunDataProcesser::FreeSendBuffers(PRUNDATASENDTHREAD pSendThread)
{
	INT_PTR i;
	void **pBuffers;
	EnterCriticalSection( &pSendThread->SendQueueLock );

	pBuffers = *pSendThread->pSendAppendList;
	for ( i=pSendThread->pSendAppendList->count()-1; i>-1; --i )
	{
		free( pBuffers[i] );
	}
	pSendThread->pSendAppendList->clear();

	
	pBuffers = *pSendThread->pSendProcList;
	for ( i=pSendThread->pSendProcList->count()-1; i>-1; --i )
	{
		free( pBuffers[i] );
	}
	pSendThread->pSendProcList->clear();

	LeaveCriticalSection( &pSendThread->SendQueueLock );
}
/*
BOOL CRunDataProcesser::OpenServerPipe()
{
	int nErr;

	while ( TRUE )
	{
		m_hPipe = CreateFile( m_sPipeName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL );
		if ( m_hPipe != INVALID_HANDLE_VALUE )
			return TRUE;

		nErr = GetLastError();
		if ( nErr != ERROR_PIPE_BUSY )
		{
			GotError( __FUNCTION__, "CreateFile", nErr );
			break;
		}
		
		if ( !WaitNamedPipe( m_sPipeName, 10000 ) )
		{
			nErr = GetLastError();
			GotError( __FUNCTION__, "WaitNamedPipe", nErr );
			break;
		}
	}

	return FALSE;
}



VOID CRunDataProcesser::CloseServerPipe()
{
	if ( m_hPipe != INVALID_HANDLE_VALUE )
	{
		CloseHandle( m_hPipe );
		m_hPipe = INVALID_HANDLE_VALUE;
	}
}

VOID CRunDataProcesser::ServerPipeError()
{
	if ( m_hPipe != INVALID_HANDLE_VALUE )
	{
		CancelRemainSendSessionBuffers();
		CloseHandle( m_hPipe );
		m_hPipe = INVALID_HANDLE_VALUE;
		//CloseAllSessions 必须在CloseHandle之后调用，否则CloseAllSessions->SendServerMessage->ServerPipeError 造成栈溢出
		CloseAllSessions( TRUE );
	}
}
*/

BOOL CRunDataProcesser::CopyWaitSendBuffers(PRUNDATASENDTHREAD pSendThread, BOOL boForceCopy)
{
	PSENDCLIENTBUF pSendBuf, *ppBufers;
	CBaseList<LPVOID> *pBufferList;
	PRUNGATEUSERSESSION pSession;
	INT_PTR nCount, nSize, nTotalSize, nAppendSize;
	TICKCOUNT dwMsgTick;

	if ( !boForceCopy )
		boForceCopy = TryEnterCriticalSection( &pSendThread->SendQueueLock );
	else EnterCriticalSection( &pSendThread->SendQueueLock );
	
	if ( boForceCopy )
	{
		pBufferList = pSendThread->pSendAppendList;
		pSendThread->pSendAppendList = pSendThread->pSendProcList;
		pSendThread->pSendProcList = pBufferList;
		LeaveCriticalSection( &pSendThread->SendQueueLock );

		nCount = pBufferList->count();
		if ( nCount > 0 )
		{
			dwMsgTick = _getTickCount();
			ppBufers = (PSENDCLIENTBUF*)(void**)(*pBufferList);
			nTotalSize = 0;
			nAppendSize = 0;
			do
			{
				pSendBuf = *ppBufers;
				ppBufers++;
				nCount--;

				pSession = pSendBuf->pSession;
				if ( pSession->nSocket != INVALID_SOCKET && !pSession->boMarkToClose && !pSession->boRemoteClosed )
				{
					nSize = pSession->SendBuf.nOffset + pSendBuf->nBufferSize + 1;
					if ( pSession->SendBuf.nSize < nSize )
					{
						nSize = (nSize / SESSION_DATAGROW_SIZE + 1) * SESSION_DATAGROW_SIZE;
						pSession->SendBuf.nSize = (INT)nSize;
						pSession->SendBuf.lpBuffer = (char*)realloc( pSession->SendBuf.lpBuffer, nSize );
					}
					memcpy( &pSession->SendBuf.lpBuffer[pSession->SendBuf.nOffset], pSendBuf + 1, pSendBuf->nBufferSize );
					pSession->SendBuf.nOffset += pSendBuf->nBufferSize;
					pSession->SendBuf.lpBuffer[pSession->SendBuf.nOffset] = 0;
					pSession->dwServerMsgTick = dwMsgTick;
					nAppendSize += pSendBuf->nBufferSize;
				}
				nTotalSize += pSendBuf->nBufferSize;
				free( pSendBuf );
			}
			while ( nCount > 0 );
			pBufferList->clear();

			// 原子操作
			InterlockedExchangeAdd( (LONG*)&m_dwWaitSendUserSize, (LONG)nAppendSize );
			InterlockedExchangeAdd( (LONG*)&m_dwWaitSendQueueSize, -(INT)nTotalSize );
		}
	}

	return boForceCopy;
}

VOID CRunDataProcesser::GetSessionLoginInfo(PRUNGATEUSERSESSION pSession, char *sBuffer, int nBufferSize)
{
}


VOID CRunDataProcesser::GotError(LPCSTR sErrFn, LPCSTR sErrApi, int nErr)
{
	OutputMsg( rmError, _T("CRunDataProcesser::%s Got Error %d on api \"%s\""), sErrFn, nErr, sErrApi );
}

VOID CRunDataProcesser::InitSendThreadData()
{
	int i;

	for ( i=0; i<m_nSendThreadCount; ++i )
	{
		InitializeCriticalSection( &m_SendThreads[i].SendQueueLock );
		m_SendThreads[i].pRunData = this;
		m_SendThreads[i].nThreadIdx = i;
		m_SendThreads[i].boSendEWouldBlock = false;
		m_SendThreads[i].boSendFewBuffer = false;
		m_SendThreads[i].pSendAppendList = new CBaseList<LPVOID>();
		m_SendThreads[i].pSendProcList = new CBaseList<LPVOID>();		
	}
}

VOID CRunDataProcesser::UninitSendThreadData()
{
	int i;

	for ( i=0; i<m_nSendThreadCount; ++i )
	{
		SafeDelete( m_SendThreads[i].pSendAppendList );
		SafeDelete( m_SendThreads[i].pSendProcList );
		DeleteCriticalSection( &m_SendThreads[i].SendQueueLock );
	}
}

VOID CRunDataProcesser::SendCheck(int nIdent)
{
	SendServerMessage( nIdent, 0, 0, 0, m_sGateName, (int)strlen(m_sGateName) + 1 );
}

VOID CRunDataProcesser::SendGateUserInfo()
{
	GATEUSERINFO gi;
	gi.nUserCount = GetActiveUserCount();
	gi.nGatePort = GetRunSockProcesser()->GetBindPort();
	SendServerMessage(GM_GATEUSERINFO, 0, 0, 0, (char *)&gi, sizeof(GATEUSERINFO));
}

VOID CRunDataProcesser::SendOpenSession(PRUNGATEUSERSESSION pSession)
{
	char sRemoteAddr[32];
	strcpy( sRemoteAddr, inet_ntoa( pSession->SockAddr.sin_addr ) );
	SendServerMessage( GM_OPEN, pSession->nIndex, pSession->nSocket, 0, sRemoteAddr, (int)strlen(sRemoteAddr) + 1 );
	OutputMsg(rmTip, _T("SendOpenSession: socket=%d sessionId=%d, remoteAddr=%s"), (int)pSession->nSocket, (int)pSession->nIndex, sRemoteAddr);
}

VOID CRunDataProcesser::SendCloseSession(PRUNGATEUSERSESSION pSession, BOOL boCloseOnServer, INT nReason)
{
	PCLIENTRECVBUF pRecvBuf;
	int nSocket;

	if ( !pSession->boMarkToClose && pSession->nSocket != INVALID_SOCKET )
	{
		OutputMsg( rmWaning, "关闭会话 socket=%d, sessionId=%d, serverId=%d,reasonId=%d,nVerifyIdx=%ld", (int)pSession->nSocket, 
			(int)pSession->nIndex, (int)pSession->nServerIdx, nReason, pSession->nVerifyIdx );
		
		pSession->boMarkToClose = true;

		nSocket = (int)pSession->nSocket;
		pSession->nSocket = INVALID_SOCKET;
		pSession->dwCloseTick = _getTickCount();
		pSession->nVerifyIdx = 0;
		bool isInCommu =( pSession->nSessionSatus == enCommunication); //当前是否在通信状态
		pSession->nSessionSatus = enSessionStatusIdle;  //初始化状态

		if (nSocket!=INVALID_SOCKET) closesocket( nSocket );

		//如果需要向服务器发送关闭用户的消息则将消息添加到队列
		//并且需要通信状态了，否则不需要发包，说明还没有通过验证
		if ( boCloseOnServer  && isInCommu )
		{
			SendServerMessage( GM_CLOSE, 0, nSocket, 0, NULL, 0 );
		}
		m_nActiveUser--;
	}
}

VOID CRunDataProcesser::SendKeepAliveAck(PRUNGATEUSERSESSION pSession, const char *pBuffer, SIZE_T nBufSize)
{	
	SendServerMessage(GM_APPKEEPALIVEACK, pSession->nIndex, pSession->nSocket, pSession->nServerIdx, (char *)pBuffer, (int)nBufSize);
}


VOID CRunDataProcesser::CloseAllSessions(BOOL boForceClose)
{
	int i;
	TICKCOUNT dwCurTick;
	PRUNGATEUSERSESSION pSession;

	if ( !m_Sessions ) return;
	pSession = m_Sessions;
	EnterCriticalSection( &m_SessionLock );
	EnterCriticalSection( &m_RecvQueueLock );
	for ( i=0; i<m_nSendThreadCount; ++i )
	{
		EnterCriticalSection( &m_SendThreads[i].SendQueueLock );
	}
	Sleep( 3000 );//休眠以等待数据接收以及各发送线程被阻塞

	dwCurTick = _getTickCount();
	for ( i=0; i<m_nMaxSessionCount; ++i )
	{
		if ( pSession->nSocket != INVALID_SOCKET )
		{
			if ( boForceClose )
			{
				OutputMsg(rmTip,_T("CRunDataProcesser::CloseAllSessions close socket=%d"),(int)pSession->nSocket);
				SendCloseSession( pSession, TRUE, enReasonAllSessionClose  );
				//closesocket( pSession->nSocket );
				pSession->boMarkToClose = true;
				pSession->boRemoteClosed = true;
				pSession->dwCloseTick = 0;
				pSession->nSocket = INVALID_SOCKET;
				pSession->nVerifyIdx = 0;
				m_nActiveUser--;

				if ( pSession->RecvBuf.lpBuffer )
				{
					free( pSession->RecvBuf.lpBuffer );
					pSession->RecvBuf.lpBuffer = NULL;
				}
				pSession->RecvBuf.nSize = pSession->RecvBuf.nOffset = 0;
				if ( pSession->SendBuf.lpBuffer )
				{
					free( pSession->SendBuf.lpBuffer );
					pSession->SendBuf.lpBuffer = NULL;
				}
				pSession->SendBuf.nSize = pSession->SendBuf.nOffset = 0;
			}
			else SendCloseSession( pSession, TRUE, enReasonAllSessionClose  );
		}
		pSession++;
	}

	for ( i=0; i<m_nSendThreadCount; ++i )
	{
		LeaveCriticalSection( &m_SendThreads[i].SendQueueLock );
	}
	LeaveCriticalSection( &m_RecvQueueLock );
	LeaveCriticalSection( &m_SessionLock );
}

VOID CRunDataProcesser::CancelRemainSendSessionBuffers()
{
	PSENDCLIENTBUF pSendBuf, *ppBufers;
	CBaseList<LPVOID> *pBufferList;
	INT_PTR i, nCount, nTotalSize;

	nTotalSize = 0;
	for ( i=0; i<m_nSendThreadCount; ++i )
	{
		EnterCriticalSection( &m_SendThreads[i].SendQueueLock );
		
		pBufferList = m_SendThreads[i].pSendProcList;
		nCount = pBufferList->count();
		if ( nCount )
		{
			ppBufers = (PSENDCLIENTBUF*)(void**)(*pBufferList);
			do
			{
				pSendBuf = *ppBufers;
				ppBufers++;
				nCount--;
				nTotalSize += pSendBuf->nBufferSize;
				free( pSendBuf );
			}
			while ( nCount > 0 );
			pBufferList->clear();
		}

		pBufferList = m_SendThreads[i].pSendAppendList;
		nCount = pBufferList->count();
		if ( nCount )
		{
			ppBufers = (PSENDCLIENTBUF*)(void**)(*pBufferList);
			do
			{
				pSendBuf = *ppBufers;
				ppBufers++;
				nCount--;
				nTotalSize += pSendBuf->nBufferSize;
				free( pSendBuf );
			}
			while ( nCount > 0 );
			pBufferList->clear();
		}

		LeaveCriticalSection( &m_SendThreads[i].SendQueueLock );
	}

	InterlockedExchangeAdd( (LONG*)&m_dwWaitSendQueueSize, -(INT)nTotalSize );
}

BOOL CRunDataProcesser::CheckCloseSessions(BOOL boForceCheck)
{
	static const DWORD dwCloseIdleSessionLong = 10 * 60 * 1000;
	int i, boResult;
	TICKCOUNT dwCurTick;
	PRUNGATEUSERSESSION pSession;

	if ( boForceCheck )
	{
		EnterCriticalSection( &m_SessionLock );
		boResult = TRUE;
	}
	else  boResult = TryEnterCriticalSection( &m_SessionLock );

	if ( boResult )
	{
		dwCurTick = _getTickCount();
		pSession = m_Sessions - 1;

		for ( i=0; i<m_nMaxSessionCount; ++i )
		{
			pSession++;

			if ( pSession->boMarkToClose || pSession->boRemoteClosed )
			{
				//加上pSession->dwCloseTick非0判断，防止内存错误
				//可能的原因是标记pSession->boMarkToClose或pSession->boRemoteClosed为true的线程尚未来得及
				//给pSession->dwCloseTick赋值，而此线程恰好已经执行到此处对pSession的资源进行释放，从而
				//造成内存错误。
				if ( pSession->dwCloseTick && dwCurTick - pSession->dwCloseTick >= 10 * 1000 )
				{
					if(pSession->nSocket != INVALID_SOCKET)
					{
						OutputMsg( rmWaning, "Socket%d 标记为删除",(int)pSession->nSocket );
					}
					
					LOCK_SESSION_SEND( pSession );
					pSession->nSocket = INVALID_SOCKET;
					pSession->nVerifyIdx = 0;

					if ( pSession->RecvBuf.lpBuffer )
					{
						free( pSession->RecvBuf.lpBuffer );
						pSession->RecvBuf.lpBuffer = NULL;
					}

					pSession->RecvBuf.nSize = pSession->RecvBuf.nOffset = 0;
					if ( pSession->SendBuf.lpBuffer )
					{
						free( pSession->SendBuf.lpBuffer );
						pSession->SendBuf.lpBuffer = NULL;
					}
					pSession->SendBuf.nSize = 0;//SendBuf.nOffset值由发送线程维护

					pSession->boMarkToClose = false;
					pSession->boRemoteClosed = false;
					pSession->dwCloseTick = 0;
					UNLOCK_SESSION_SEND( pSession );
				}
			}
			else if ( pSession->nSocket != INVALID_SOCKET )
			{
				if (dwCurTick - pSession->dwClientMsgTick >= dwCloseIdleSessionLong)
				{
					OutputMsg( rmWaning, "客户端Idle，dwCurTick=%ld,dwClientMsgTick=%ld",(long long)dwCurTick, (long)pSession->dwClientMsgTick);
					SendCloseSession( pSession, TRUE, enReasonIdle );
				}
				if(dwCurTick - pSession->dwServerMsgTick >= dwCloseIdleSessionLong)
				{
					//OutputMsg( rmWaning, "服务器较长时间处于非活动状态的会话，关闭会话" );
					//OutputMsg( rmWaning, "服务器端idle，dwCurTick=%I64d,dwClientMsgTick=%I64d",(long long)dwCurTick, (long long)pSession->dwServerMsgTick);					
					//SendCloseSession( pSession, TRUE, enReasonIdle   );
				}
			}
		}
		LeaveCriticalSection( &m_SessionLock );
	}

	return boResult;
}

char* getDescBySysId(int id)
{
	switch (id)
	{
	case 0:
		return "默认系统";
		break;
	case 1:
		return "移动系统";
		break;
	case 2:
		return "属性系统";
		break;
	case 3:
		return "观察系统";
		break;
	case 4:
		return "Buff系统";
		break;
	case 5:
		return "技能系统";
		break;
	case 6:
		return "任务系统";
		break;
	case 7:
		return "装备系统";
		break;
	case 8:
		return "背包系统";
		break;
	case 9:
		return "聊天系统";
		break;
	case 10:
		return "帮会系统";
		break;
	case 11:
		return "技能标记";
		break;
	case 12:
		return "商城系统";
		break;
	case 13:
		return "交易系统";
		break;
	case 14:
		return "玩家变量";
		break;
	case 15:
		return "拾取系统";
		break;
	case 16:
		return "队伍系统";
		break;
	case 17:
		return "操练系统";
		break;
	case 18:
		return "兵魂系统";
		break;
	case 20:
		return "副本系统";
		break;
	case 21:
		return "交互系统";
		break;
	case 22:
		return "消息系统";
		break;
	case 23:
		return "仓库系统";
		break;
	case 24:
		return "PK系统";
		break;
	case 26:
		return "杂七杂八";
		break;
	case 27:
		return "交易行";
		break;
	case 28:
		return "成就系统";
		break;
	case 30:
		return "特效系统";
		break;
	case 34:
		return "宠物系统";
		break;
	case 35:
		return "交通工具";
		break;
	case 36:
		return "盗梦空间";
		break;
	case 39:
		return "摆摊系统";
		break;
	case 41:
		return "好友系统";
		break;
	case 43:
		return "宝石系统";
		break;
	case 44:
		return "英雄系统";
		break;
	case 45:
		return "载具系统";
		break;
	case 49:
		return "BOSS系统";
		break;
	case 50:
		return "邮件系统";
		break;
	case 51:
		return "衣橱系统";
		break;
	case 52:
		return "加速外挂";
		break;
	case 54:
		return "新头衔";
		break;
	case 57:
		return "职业竞技";
		break;

	case 128:
		return "脚本";
		break;
	case 129:
		return "NPC交易";
		break;
	case 130:
		return "装备修理";
		break;
	case 134:
		return "技能快捷键";
		break;
	case 137:
		return "内劲系统";
		break;
	case 138:
		return "福利系统";
		break;
	case 139:
		return "脚本乱七八糟";
		break;
	case 140:
		return "功勋系统";
		break;
	case 145:
		return "活动系统";
		break;
	case 255:
		return "登陆系统";
		break;
	default:
		return "错误！";
		break;
	}
}

VOID CRunDataProcesser::CheckSendSessionBuffers(PRUNDATASENDTHREAD pSendThread)
{
	DECLARE_FUN_TIME_PROF();
	static char sSendCheckBuf[RUNGATE_ONCESENDUSE_LIMIT];

	int nErr, nRemainSize;
	char *pBuffer;
	PRUNGATEUSERSESSION pSession = &m_Sessions[pSendThread->nThreadIdx];

	pSendThread->boSendEWouldBlock = false;
	pSendThread->boSendFewBuffer = false;

	for ( ;pSession <= &m_Sessions[m_nMaxSessionCount-1]; pSession += m_nSendThreadCount )
	{
		if ( pSession->nSocket != INVALID_SOCKET && !pSession->boMarkToClose && !pSession->boRemoteClosed )
		{
			if ( !pSession->boSendAvaliable )
			{
				if ( _getTickCount() >= pSession->dwSendTimeOut )
				{
					pSession->boSendAvaliable = true;
					pSession->dwSendTimeOut = 0;
				}
				else continue;
			}

			if ( TRYLOCK_SESSION_SEND( pSession ) )
			{
				nRemainSize = pSession->SendBuf.nOffset;
				if ( nRemainSize > 4096 * 1024 )
				{
					SendCloseSession( pSession, TRUE, enReasonSenderBuffLarge   );
					nRemainSize = 0;
					OutputMsg( rmWaning, "关闭了一个发送数据队列大于4MB的连接。" );
				}
				if ( nRemainSize )
				{
					pBuffer = pSession->SendBuf.lpBuffer;					
					if ( nRemainSize >= MAXINT )//不让它执行这段代码
					{
						sSendCheckBuf[0] = '*';
						memcpy( &sSendCheckBuf[1], pBuffer, RUNGATE_ONCESENDUSE_LIMIT -1 );
						nErr = ::send( pSession->nSocket, sSendCheckBuf, RUNGATE_ONCESENDUSE_LIMIT, 0 );
						if ( nErr > 0 )
						{
							if ( nErr != RUNGATE_ONCESENDUSE_LIMIT )
								pSendThread->boSendFewBuffer = true;
							InterlockedExchangeAdd( (LONG*)&m_dwWaitSendUserSize, -(nErr - 1) );
							InterlockedExchangeAdd( (LONG*)&m_dwSendUserSize, nErr );
							nRemainSize -= nErr - 1;
							memcpy( pBuffer, &pBuffer[nErr - 1], nRemainSize );
							pSession->SendBuf.nOffset = nRemainSize;
							pBuffer[nRemainSize] = 0;
							pSession->nSendPacketCount++;
						}
						else if ( !nErr || WSAGetLastError() != WSAEWOULDBLOCK )
						{
							InterlockedExchangeAdd( (LONG*)&m_dwWaitSendUserSize, -pSession->SendBuf.nOffset );
							pSession->boRemoteClosed = true;
							pSession->SendBuf.nOffset = 0;
							SendCloseSession( pSession, TRUE, enReasonSocketError  );
						}
						else 
						{
							pSession->boSendAvaliable = false;
							pSession->dwSendTimeOut = _getTickCount() + RUNGATE_SENDCHECK_TIMEOUT;
							pSendThread->boSendEWouldBlock = true;
						}
					}
					else
					{
						TICKCOUNT nCurTick = _getTickCount();
						if (nCurTick < pSession->nLastSendPacketTime)
							pSession->nLastSendPacketTime = 0;
						if (nCurTick - pSession->nLastSendPacketTime >= 15)
						{
							pSession->nLastSendPacketTime = nCurTick;
							nErr = ::send( pSession->nSocket, pBuffer, nRemainSize, 0 );
							if ( nErr > 0 )
							{	
								pSession->nSendPacketCount++;
								InterlockedExchangeAdd( (LONG*)&m_dwWaitSendUserSize, -nErr );
								InterlockedExchangeAdd( (LONG*)&m_dwSendUserSize, nErr );
								if ( nErr < nRemainSize )
								{
									pSendThread->boSendFewBuffer = true;
									memcpy( pBuffer, &pBuffer[nErr], nRemainSize - nErr );
									nRemainSize -= nErr;
									pBuffer[nRemainSize] = 0;
									pSession->SendBuf.nOffset = nRemainSize;
									pSession->nTimeStampOffset = nRemainSize;
								}
								else
								{
									pBuffer[0] = 0;
									pSession->SendBuf.nOffset = 0;
									pSession->nTimeStampOffset = 0;
								}

#ifdef _DEBUG_GATEMSG
								char * pIp = inet_ntoa(pSession->SockAddr.sin_addr);
								OutputMsg( rmTip, "[%s]Idx=%d: 发到客户端, 已发长度%d, 剩余待发%d;", 
									pIp, pSession->nVerifyIdx, nErr, pSession->SendBuf.nOffset);
#endif
							}
							else
							{
								int nErrorId = WSAGetLastError();
								if ( !nErr || nErrorId != WSAEWOULDBLOCK )
								{
									OutputMsg(rmWaning,"Socket =%d,send fail, errorid=%d ",(int)pSession->nSocket,nErrorId);

									InterlockedExchangeAdd( (LONG*)&m_dwWaitSendUserSize, -nRemainSize );
									InterlockedExchangeAdd( (LONG*)&m_dwSendUserSize, nRemainSize );
									pBuffer[0] = 0;
									pSession->SendBuf.nOffset = 0;
								}
								else
								{
									pSession->boSendAvaliable = false;
									pSession->dwSendTimeOut = _getTickCount() + RUNGATE_SENDCHECK_TIMEOUT;
									pSendThread->boSendEWouldBlock = true;
								}
							}
						}
					}
				}
				UNLOCK_SESSION_SEND( pSession );
			}
		}
		else
		{
			//会话关闭后减少待发送数据统计值
			if ( nRemainSize = pSession->SendBuf.nOffset )
			{
				InterlockedExchangeAdd( (LONG*)&m_dwWaitSendUserSize, -nRemainSize );
				pSession->SendBuf.nOffset = 0;
			}
		}
	}




}
//发送数据到服务器
VOID CRunDataProcesser::SendServerMessage(int nIdent, int nSessionIdx, SOCKET nSocket, int nServerIdx, char *pBuffer, int nBufSize)
{	
	if ( !connected() )
		return;

	PutMessage(nIdent, nSessionIdx, nSocket, nServerIdx, m_llSvrTimeDiff, pBuffer, nBufSize);
	/*
	if (GM_CHECKCLIENT != nIdent && GM_CHECKSERVER != nIdent  && GM_DATA != nIdent)
	{
		TRACE(  _T("向后台发送命令CMD=%d,socketID=%d,nSessionIdx=%d,nServerIdx=%d\n"), nIdent,nSocket,nSessionIdx,nServerIdx);
	}
	
	if (nIdent == GM_DATA)
	{
		OutputMsg( rmTip, _T("向后台发送数据size=%d,nSocket=%d,nSessionIdx=%d,nServerIdx=%d"),nBufSize,nSocket,nSessionIdx,nServerIdx);
	}
	*/
	/* --begin 老的发送给服务器数据代码
	//这个是消息头
	RUNGATEMSGHDR Hdr;
	Hdr.dwGateCode	= RUNGATECODE;
	Hdr.nSocket		= nSocket;
	Hdr.wSessionIdx = nSessionIdx;
	Hdr.wIdent		= nIdent;
	Hdr.wServerIdx	= nServerIdx;
	Hdr.nDataSize	= nBufSize;
	Hdr.tickCount = m_llSvrTimeDiff + _getTickCount();

	SIZE_T headSize =  sizeof(Hdr);

	CDataPacket &packet = allocSendPacket();
	packet << Hdr;
	packet.writeBuf(pBuffer, nBufSize);
	flushSendPacket(packet);
	---end of 老的发送数据给服务器代码
	*/

	/*
	char buff [MAX_SEND_BUFF_SIZE]; 
	
	size_t headSize =  sizeof(Hdr);
	size_t totalSize = headSize + nBufSize;
	if  (totalSize > MAX_SEND_BUFF_SIZE)
	{
		GotError( __FUNCTION__, _T("发送包的长度过大"), nBufSize );
		return;
	}
	memcpy(buff,&Hdr,headSize);
	memcpy((buff+headSize),pBuffer,nBufSize);
	*/
	//AppendSendBuffer(&Hdr,headSize );
	//AppendSendBuffer(pBuffer,nBufSize );

	/* 这里使用的是pipe,修改为socket发送
	RUNGATEMSGHDR Hdr;
	DWORD dwBytesWriten;
	if ( m_hPipe != INVALID_HANDLE_VALUE )
	{
		Hdr.dwGateCode	= RUNGATECODE;
		Hdr.nSocket		= nSocket;
		Hdr.wSessionIdx = nSessionIdx;
		Hdr.wIdent		= nIdent;
		Hdr.wServerIdx	= nServerIdx;
		Hdr.nDataSize	= nBufSize;

		
#pragma __CPMSG__("----------------修改此处WriteFile为Socket的AppendSendData")
		if ( !WriteFile( m_hPipe, &Hdr, sizeof(Hdr), &dwBytesWriten, NULL ) )
		{
			GotError( __FUNCTION__, "WriteFile", GetLastError() );
			ServerPipeError();
		}
		else if ( nBufSize > 0 && !WriteFile( m_hPipe, pBuffer, nBufSize, &dwBytesWriten, NULL ) )
		{
			GotError( __FUNCTION__, "WriteFile", GetLastError() );
			ServerPipeError();
		}
	}
	*/
}

/*
* 解包WebSocket数据
* param[in] pSession 用户会话
* param[] pInBuff 输入的数据包
* param[] nInSize 输入的数据包的长度
* param[] pOutBuff 输出的数据包指针
* param[] nOutSize 输出的数据包的长度
* param[] nInProcessSize  输入的数据包处理了的长度，如果大于0，那么前面的这个字节的数据包可以丢弃了
* param[] nOutProcessSize 处理好的数据长度，处理好的数据放在pOutBuff里
* ret  如果进行了数据处理返回true，否则返回false。数据处理包括发现前面有无效数字，拷贝了一个完整的数据包，丢弃一些字节等
*/
static bool WebSocketDataUnpack(PRUNGATEUSERSESSION pSession, 
	char* pInBuff, 	SIZE_T nInSize, 
	char* pOutBuff, SIZE_T nOutSize, 
	SIZE_T& nInProcessSize,	SIZE_T& nOutProcessSize)
{
	pSession->webSocketHead.reset();

	nInProcessSize = 0;
	nOutProcessSize = 0;
	if (NULL == pInBuff || NULL == pOutBuff) return false;

	char* pdata = pInBuff;
	SIZE_T nLeftSize = nInSize;
	#define WEBSOCKET_READ(_TYPE) *((_TYPE*)pdata); nLeftSize -= sizeof(_TYPE); pdata += sizeof(_TYPE)

	//读取websocket固定包头
	if (!pSession->webSocketHead.rh)
	{
		//长度不满足
		if (nLeftSize < 2) return false;

		//读取
		uint8_t head = WEBSOCKET_READ(uint8_t);
		pSession->webSocketHead.fin = head >> 7;
		pSession->webSocketHead.opcode = emOpcode(head & 0xF);
		head = WEBSOCKET_READ(uint8_t);
		pSession->webSocketHead.len = head & 0x7F;
		pSession->webSocketHead.mask = head >> 7;
		pSession->webSocketHead.rh = 1;//标记头部读取完成

		nInProcessSize += 2;//记录处理长度
	}

	//读取长度
	if (!pSession->webSocketHead.rl)
	{
		uint8_t nsize = pSession->webSocketHead.GetLenNeedByte();
		if (nsize) 
		{
			//这个包不够一个长度
			if (nLeftSize < nsize) return false;

			if (nsize == 2) {
				pSession->webSocketHead.ex_len.v16 = WEBSOCKET_READ(uint16_t);
				pSession->webSocketHead.ex_len.v16 = ntohs(pSession->webSocketHead.ex_len.v16);
				nInProcessSize += 2; //记录处理长度
			} else {
				pSession->webSocketHead.ex_len.v64 = WEBSOCKET_READ(uint64_t);
				pSession->webSocketHead.ex_len.v64 = ntohl((u_long)pSession->webSocketHead.ex_len.v64);
				nInProcessSize += 8; //记录处理长度
			}
		}
		pSession->webSocketHead.rl = 1;
	}

	//读取MKEY
	if (!pSession->webSocketHead.rk)
	{
		if (pSession->webSocketHead.mask) {

			//这个包不够一个key长度
			if (nLeftSize < 4) return false;

			pSession->webSocketHead.mkey[0] = WEBSOCKET_READ(uint8_t);
			pSession->webSocketHead.mkey[1] = WEBSOCKET_READ(uint8_t);
			pSession->webSocketHead.mkey[2] = WEBSOCKET_READ(uint8_t);
			pSession->webSocketHead.mkey[3] = WEBSOCKET_READ(uint8_t);
			nInProcessSize += 4; //记录处理长度
		}
		pSession->webSocketHead.rk = 1;
	}

	//读取数据段
	uint64_t data_len = pSession->webSocketHead.GetLen();
	if (nLeftSize < data_len) return false;

	// 掩码处理
	if (pSession->webSocketHead.mask)
	{
		char* dptr = pdata;
		for (size_t i = 0; i < data_len; ++i) {
			dptr[i] = dptr[i] ^ pSession->webSocketHead.mkey[i % 4];
		}
	}

	memcpy(pOutBuff,(void *)(pInBuff + nInProcessSize), data_len);
	//OutputMsg( rmTip, "Websocket数据(头长:%ld, 数据长:%ld)", nInProcessSize, data_len, *((int*)pInBuff));
	nInProcessSize += data_len;
	nOutProcessSize = data_len;
	return true;
}

//收到用户的数据包
VOID CRunDataProcesser::ProcessUserRecvPacket(PRUNGATEUSERSESSION pSession, char *pBuffer, int nBufferSize)
{
	DECLARE_FUN_TIME_PROF();
	//static const char szFlashSocketPolicyRequest[]     = "<policy-file-request/>";
	//static const char szFlashSocketPolicyRequestReply[]= "<?xml version=\"1.0\"?><cross-domain-policy><allow-access-from domain=\"*\" to-ports=\"*\"/></cross-domain-policy>";
	//static int  s_policyStrLen = (int)strlen(szFlashSocketPolicyRequest) +1; //请求安全策略文件的长度，后面都是以\0结尾的
	//static int  s_policyReplyStrLen = (int)strlen(szFlashSocketPolicyRequestReply) +1;//回复安全策略文件的长度
	
	InterlockedExchangeAdd( (LONG*)&m_dwProcessRecvSize, nBufferSize );

	//session中已缓存的数据（剩下待处理的数据）
	int nLeftDataSize = pSession->RecvBuf.nOffset + nBufferSize + 1;
	if ( pSession->RecvBuf.nSize < nLeftDataSize )
	{
		pSession->RecvBuf.nSize = (nLeftDataSize / SESSION_DATAGROW_SIZE + 1) * SESSION_DATAGROW_SIZE;
		pSession->RecvBuf.lpBuffer = (char*)realloc( pSession->RecvBuf.lpBuffer, pSession->RecvBuf.nSize );
	}
	nLeftDataSize--;

	//将数据拷贝过来
	char *pDataBuffer;
	pDataBuffer = pSession->RecvBuf.lpBuffer;
	memcpy( &pDataBuffer[pSession->RecvBuf.nOffset], pBuffer, nBufferSize );
	pSession->RecvBuf.nOffset = nLeftDataSize;
	pDataBuffer[nLeftDataSize] = 0;

	//如果剩余数据超过峰值则丢弃
	if ( pSession->RecvBuf.nOffset >= SESSION_MAX_RECVPROC_SIZE )
	{
		pSession->RecvBuf.nOffset = 0;
		SendCloseSession( pSession, TRUE, enReasonLargePackLeft  );
		return;
	}

	//输出日志
#ifdef _DEBUG_GATEMSG
		//char * pIp = inet_ntoa(pSession->SockAddr.sin_addr);
		OutputMsg( rmTip, "Idx=%ld: 准备处理socket数据, session状态为%d, 当前接收缓存为%d;", 
			pSession->nVerifyIdx, pSession->nSessionSatus, nLeftDataSize);
#endif

	//SIZE_T nPolicyStrSize = (int)strlen(szFlashSocketPolicyRequest);

	//处理Session的buffer
	char pDataProcBuf[MAX_SEND_BUFF_SIZE];
	#ifdef _DEBUG_GATEMSG
		memset(pDataProcBuf, 0, MAX_SEND_BUFF_SIZE);
	#endif
	while ( nLeftDataSize > 0 )
	{
		if ( pSession->wPacketError >= SESSION_PACKETERR_MAX )
		{
			nLeftDataSize = 0;
			SendCloseSession( pSession, TRUE, enReasonRecvLargerPack );
			OutputMsg( rmWaning, "wPacketError=%d,超出了",pSession->wPacketError);
			break;
		}
		if ( pSession->boMarkToClose || pSession->boRemoteClosed )
		{
			OutputMsg( rmTip, "远程关闭，不处理数据");
			break;
		}
		SIZE_T nBuffSize  = pSession->RecvBuf.nOffset ;

		//正常通信状态，这个最多放前面
		if (pSession->nSessionSatus != enSessionStatusIdle)
		{
			SIZE_T nInprocessSize =0 ,nOutProcessSize =0;

			// Websocket数据解包处理
			if (WebSocketDataUnpack(pSession, pDataBuffer, nLeftDataSize,
				pDataProcBuf, MAX_SEND_BUFF_SIZE, nInprocessSize, nOutProcessSize))
			{
				// 调整已处理过的字节
				if  (nInprocessSize > 0)
				{
					nLeftDataSize -=  (INT)nInprocessSize;
					if (nLeftDataSize < 0)
					{
						nLeftDataSize = 0;
					}
					else
					{
						pDataBuffer = (char *)(pDataBuffer + nInprocessSize);
					}
				}
		
#ifdef _DEBUG_GATEMSG
				OutputMsg( rmTip, "Idx=%ld: 已处理%d, 协议有效长%d, 当前接收缓存为%d;", 
					pSession->nVerifyIdx, nInprocessSize, nOutProcessSize, nLeftDataSize);
#endif
				
				// 将输出的数据要传递到LogicServer
				if (nOutProcessSize > 0)
				{
					//正常通讯
					if (pSession->nSessionSatus == enCommunication)
					{
						//检查退出
						if (pSession->webSocketHead.opcode == emOpcode(0x8))
						{
							OutputMsg( rmTip, "远程关闭，不处理数据");
							SendCloseSession(pSession, TRUE, 1);
							return;
						}

						//检查服务端key
						if (nOutProcessSize >= 2)
						{
							unsigned short tag = *((unsigned short*)pDataProcBuf);
							if(tag != pSession->nKey)
							{
								SendCloseSession(pSession, TRUE, 2);
								return;
							}

							//截去key
							char* pOutData = (char*)pDataProcBuf + sizeof(unsigned short);
							nOutProcessSize -= sizeof(unsigned short);

							//截去验证
							uint32_t check = *((uint32_t*)pOutData);
							pOutData = pOutData + sizeof(uint32_t);
							nOutProcessSize -= sizeof(uint32_t);

							//测试代码,数据转发给客户端
							//PostUserServerData(pSession, pOutData, (INT)nOutProcessSize, TRUE, TRUE);

#ifdef _DEBUG_GATEMSG
							OutputMsg( rmTip, "Idx=%ld: 准备发服务器 [%s] SysID:%d, CmdID:%d;", 
								pSession->nVerifyIdx, getDescBySysId(*((unsigned char*)pOutData)), *((unsigned char*)pOutData), *((unsigned char*)pOutData + 1));
#endif

							//把数据发到服务器
							SendServerMessage(GM_DATA, pSession->nIndex, pSession->nSocket,
								pSession->nServerIdx, pOutData, (INT)nOutProcessSize);
							//OutputMsg( rmTip, "systemID = %d", *((char*)(pOutData)));
							//OutputMsg( rmTip, "cmdID = %d", *((char*)(pOutData + 1)));
						}
					}
					//刚连上来
					else if(pSession->nSessionSatus == enConn)
					{
						pSession->nKey = (unsigned short)wrand(INT_MAX);
						PostUserServerData(pSession, (char *)&pSession->nKey, 2);
						pSession->nSessionSatus = enCommunication;
						OutputMsg( rmTip, "=================================================Finish");
					}
				}
			}
			else
			{
				OutputMsg( rmTip, "消息长度不够，等待下一次组包");
				break;
			}
		}
	}

	//修正Session的buffer
	if (pSession->RecvBuf.lpBuffer != NULL)
	{
		if ( nLeftDataSize > 0 )
		{
			if ( pDataBuffer != pSession->RecvBuf.lpBuffer )
			{
				memcpy( pSession->RecvBuf.lpBuffer, &pSession->RecvBuf.lpBuffer[pSession->RecvBuf.nOffset - nLeftDataSize], nLeftDataSize );
				pSession->RecvBuf.lpBuffer[nLeftDataSize] = 0;
				pSession->RecvBuf.nOffset = nLeftDataSize;
			}
		}
		else 
		{
			pSession->RecvBuf.lpBuffer[0] = 0;
			pSession->RecvBuf.nOffset = 0;
		}
	}
}

int CRunDataProcesser::s_nIgnoreDataPacket = 0;
VOID CRunDataProcesser::PostUserServerData(PRUNGATEUSERSESSION pSession, const char *pBuffer, int nBufferSize, BOOL boWriteWsHdr, BOOL boWriteProtoHdr, TICKCOUNT nSendTime)
{
	/*if (s_nIgnoreDataPacket)
	{		
		return;
	}	*/

	//OutputMsg( rmTip, "向玩家发送%d个字节数据",nBufferSize);
	DECLARE_FUN_TIME_PROF();
	char *pDataPtr;
	PRUNDATASENDTHREAD pSendThread;
	PSENDCLIENTBUF pSendBuf;
	PDATAHEADER pProtoHdr;
	static char sPrintS2CBuffer[81920];

	pSendThread = &m_SendThreads[pSession->nIndex % m_nSendThreadCount];
	pSendBuf = (PSENDCLIENTBUF)malloc( nBufferSize + sizeof(*pSendBuf) + 4 + sizeof(*pProtoHdr) + 16);
	pSendBuf->pSession = pSession;

	
	int wsheaderLength = 0;
	pDataPtr = (char*)(pSendBuf + 1);
	CDataPacket pack(pDataPtr, nBufferSize + 4 + sizeof(*pProtoHdr) + 16);
	pack.setPosition(0);

	// 写入websocket头部	
	if( boWriteWsHdr )
	{
		int totallen = boWriteProtoHdr ? nBufferSize + sizeof(uint16_t) : nBufferSize;
		pack << (uint8_t)0x82;//写头部
		//写长度
		if (totallen >= 126) {//7位放不下
			if (totallen <= 0xFFFF) {//16位放
				pack << (uint8_t)126;
				pack << (uint16_t)htons((u_short)totallen);
			} else {//64位放
				pack << (uint8_t)127;
				pack << (uint64_t)OrderSwap64(totallen);
			}
		} else {
			pack << (uint8_t)totallen;
		}
	}

	// 写入协议头部
	if ( boWriteProtoHdr )
	{
		//DATAHEADER ProtoHd;
		//ProtoHd.tag = DEFAULT_TAG_VALUE;
		//ProtoHd.len = nBufferSize;
		//ProtoHd.u.tp = nSendTime - m_llSvrTimeDiff;	// 网关收到来自服务器的数据包，盖上时间戳
		//ProtoHd.u.tp = __max(0, _getTickCount() - (nSendTime - m_llSvrTimeDiff));	
		//pack.writeBuf(&ProtoHd, sizeof(DATAHEADER));	
		
		//写数据
		pack << (uint16_t)pSession->nKey;
	}

	//写数据
	pack.writeBuf(pBuffer, nBufferSize);

	// 写入数据总长度
	pack.setPosition(0);
	pSendBuf->nBufferSize = pack.getAvaliableLength();

#ifdef _DEBUG_GATEMSG
	OutputMsg( rmTip, "Idx=%d: 准备发客户端 [%s] SysID:%d, CmdID:%d, 数据长:%d, 协议有效长:%d", 
		pSession->nVerifyIdx, getDescBySysId(*((unsigned char*)pBuffer)), *((unsigned char*)pBuffer), *((unsigned char*)pBuffer + 1), pSendBuf->nBufferSize, nBufferSize);
#endif

	InterlockedExchangeAdd( (LONG*)&m_dwWaitSendQueueSize, nBufferSize );
	EnterCriticalSection( &pSendThread->SendQueueLock );
	pSendThread->pSendAppendList->add( pSendBuf );
	LeaveCriticalSection( &pSendThread->SendQueueLock );
}

/*
VOID CRunDataProcesser::PostUserServerRawData(PRUNGATEUSERSESSION pSession, const char *pBuffer, DWORD dwBufferSize)
{
	char *pDataPtr;
	PRUNDATASENDTHREAD pSendThread;
	PSENDCLIENTBUF pSendBuf;

	pSendThread = &m_SendThreads[pSession->nIndex % m_nSendThreadCount];
	
	if (dwBufferSize > 0)
	{

		pSendBuf = (PSENDCLIENTBUF)malloc( sizeof(*pSendBuf) + dwBufferSize + 1 );
		pSendBuf->pSession = pSession;

		pDataPtr = (char*)(pSendBuf + 1);
		memcpy( pDataPtr, pBuffer, dwBufferSize );
		pDataPtr[dwBufferSize] = 0;

		pSendBuf->nBufferSize = dwBufferSize;
		InterlockedExchangeAdd( (LONG*)&m_dwWaitSendQueueSize, dwBufferSize );
	}
	EnterCriticalSection( &pSendThread->SendQueueLock );
	pSendThread->pSendAppendList->add( pSendBuf );
	LeaveCriticalSection( &pSendThread->SendQueueLock );
}
*/


INT CRunDataProcesser::GetActiveUserCount()
{
	return m_nActiveUser;
}

VOID CRunDataProcesser::SetName(LPCSTR sName)
{
	ZeroMemory( m_sGateName, sizeof(m_sGateName) );
	strncpy( m_sGateName, sName, __min(sizeof(m_sGateName)-1, strlen(sName)) );
	SetClientName(sName);
}
/*
VOID CRunDataProcesser::SetPipeName(LPCSTR sPipeName)
{
	ZeroMemory( m_sPipeName, sizeof(m_sPipeName) );
	strncpy( m_sPipeName, sPipeName, __min(sizeof(m_sPipeName)-1, strlen(sPipeName)) );
}
*/

INT CRunDataProcesser::GetSendThreadCount()
{
	return m_nSendThreadCount;
}

VOID CRunDataProcesser::SetSendThreadCount(INT ThreadCount)
{
	if ( !m_boStarted && ThreadCount > 0 && ThreadCount <= RUNDATA_MAX_SENDTHREAD )
	{
		m_nSendThreadCount = ThreadCount;
	}
}

DATAPROCESSERTYPE	CRunDataProcesser::GetDataProcessType()
{
	return m_DataProcessType;
}

VOID CRunDataProcesser::SetDataProcessType(DATAPROCESSERTYPE Type)
{
	m_DataProcessType = Type;
}

VOID CRunDataProcesser::SetRunSockProcesser(CRunSockProcesser* pSockProcesser)
{
	m_pSockProcesser = pSockProcesser;
}

INT CRunDataProcesser::GetMaxSessionCount()
{
	return m_nMaxSessionCount;
}

PRUNDATASENDTHREAD	CRunDataProcesser::GetSendThreadInfo(INT ThreadIdx)
{
	if ( ThreadIdx >= 0 && ThreadIdx < RUNDATA_MAX_SENDTHREAD )
	{
		if ( m_SendThreads[ThreadIdx].hThread )
			return &m_SendThreads[ThreadIdx];
	}
	return NULL;
}

PRUNGATEUSERSESSION	CRunDataProcesser::GetFirstSession()
{
	return m_Sessions;
}

VOID	CRunDataProcesser::SetPrintC2SMessage(const BOOL boPrint)
{
	m_boPrintC2SMsg = boPrint;
}

VOID	CRunDataProcesser::SetPrintS2CMessage(const BOOL boPrint)
{
	m_boPrintS2CMsg = boPrint;
}



BOOL CRunDataProcesser::Startup()
{
	int i;

	m_boStoping = FALSE;

	m_dwWaitSendUserSize = 0;
	m_dwWaitSendQueueSize = 0;
	m_dwLastProcUsrMsgTime = 0;
	m_dwLastProcSrvMsgTime = 0;
	m_dwLastRecvSrvMsgTime = 0;
	m_dwRecvSeverSize = 0;
	m_dwSendUserSize = 0;
	m_dwProcSrvThreadSleep = 0;
	m_dwSendQueueSize = 0;

	//初始化会话队列
	InitSessions();

	//创建用户数据处理线程
#ifdef _MSC_VER
	m_hProcRecvThread = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)RecvDataProcessRoutine, this, 0, NULL );
	if ( !m_hProcRecvThread )
	{
		GotError( __FUNCTION__, _T("CreateThread"), GetLastError() );
		return FALSE;
	}
#else
	if (pthread_create(&m_hProcRecvThread, NULL, RecvDataProcessRoutine, this)) {
		return FALSE;
	}
#endif
	
	//创建用户数据发送线程
	for ( i=0; i<m_nSendThreadCount; ++i )
	{
		m_SendThreads[i].pRunData = this;
		m_SendThreads[i].nThreadIdx = i;
		m_SendThreads[i].boSendEWouldBlock = false;
		m_SendThreads[i].boSendFewBuffer = false;
#ifdef _MSC_VER
		m_SendThreads[i].hThread = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)SendDataProcessRoutine, &m_SendThreads[i], 0, &m_SendThreads[i].dwThreadId );
		if ( !m_SendThreads[i].hThread )
		{
			GotError( __FUNCTION__, _T("CreateThread"), GetLastError() );
			return FALSE;
		}
#else
		if (pthread_create(&(m_SendThreads[i].hThread), NULL, SendDataProcessRoutine, &m_SendThreads[i])) {
			return FALSE;
		}
#endif
	}

	if ( Inherited::Startup() )
	{
		m_boStarted = TRUE;
		return TRUE;
	}
	else return FALSE;
}


int CRunDataProcesser::ChangeConsoleLine(int nLine, int nPos, LPCSTR sFormat, ...)
{
	COORD cPos;
	va_list	args;

	cPos.X = nPos;
	cPos.Y = nLine;
#ifdef _MSC_VER
	SetConsoleCursorPosition( g_hStdOut, cPos );
#endif
	va_start(args, sFormat);
	cPos.X = vfprintf( stdout, sFormat, args );
	va_end(args);

	return cPos.X;
}

VOID  CRunDataProcesser::ShowGateStatus(CRunDataProcesser *pRunData)
{
	int i, nLine = 0;
	PRUNDATASENDTHREAD pSendThread;

	ChangeConsoleLine( nLine, 0, "---------------------网关状态[%s]-----------------\n", pRunData->GetName());
	nLine++;

	ChangeConsoleLine( nLine, 0, "活动连接数:%d      \n",  pRunData->GetActiveUserCount() );
	nLine++;

	ChangeConsoleLine( nLine, 0, "接收用户数据: %dB 发送用户数据: %dKB 待发用户数据: %dKB 待发用户队列: %dKB \n", 
		pRunData->m_dwProcessRecvSize, pRunData->m_dwSendUserSize / 1024, pRunData->m_dwWaitSendUserSize / 1024, 
		pRunData->m_dwSendQueueSize / 1024 );
	nLine++;

	ChangeConsoleLine( nLine, 0, "接收引擎数据: %dKB 接收数据时间: %d毫秒 引擎数据处理: %d毫秒 用户数据处理: %d毫秒 \n", 
		pRunData->m_dwRecvSeverSize / 1024, pRunData->m_dwLastRecvSrvMsgTime, pRunData->m_dwLastProcSrvMsgTime,
		pRunData->m_dwLastProcUsrMsgTime );
	nLine++;

	for ( i=0; i<RUNDATA_MAX_SENDTHREAD; ++i )
	{
		pSendThread = pRunData->GetSendThreadInfo( i );
		if ( !pSendThread )
			continue;
		ChangeConsoleLine( nLine, 0, "发送线程%d[数据处理: %d毫秒 休眠时间: %d毫秒 标志:%d/%d] \n", 
			i, pSendThread->dwProcTick, pSendThread->dwSleepTick, pSendThread->boSendEWouldBlock, pSendThread->boSendFewBuffer );
		nLine++;
		InterlockedExchange( (LONG*)&pSendThread->dwProcTick, 0 );
		InterlockedExchange( (LONG*)&pSendThread->dwSleepTick, 0 );
	}

	ChangeConsoleLine( nLine, 0, "服务器数据处理线程休眠: %d毫秒\n", 
		pRunData->m_dwProcSrvThreadSleep );
	nLine++;

	ChangeConsoleLine( nLine, 0, "----------------------------------------------------------------\n" );
	nLine++;
	pRunData->Dump();
	InterlockedExchange( (LONG*)&pRunData->m_dwProcessRecvSize, 0 );
	InterlockedExchange( (LONG*)&pRunData->m_dwSendUserSize, 0 );
	InterlockedExchange( (LONG*)&pRunData->m_dwRecvSeverSize, 0 );
	
}

VOID CRunDataProcesser::Stop()
{
	int i;
	m_boStoping = TRUE;

	Inherited::Stop();

	CloseThread( m_hProcRecvThread );
	for ( i=0; i<m_nSendThreadCount; ++i )
	{
		if ( m_SendThreads[i].hThread )
		{
			CloseThread( m_SendThreads[i].hThread );
			FreeSendBuffers( &m_SendThreads[i] );
		}
	}

	//CloseServerPipe();


	if ( m_ServerBuf.lpBuffer )
	{
		free( m_ServerBuf.lpBuffer );
		m_ServerBuf.lpBuffer = NULL;
	}
	m_ServerBuf.nOffset = m_ServerBuf.nSize = 0;

	FreeRecvBuffers();

	//FreeSendBuffers();

	CancelRemainSendSessionBuffers();

	CloseAllSessions( TRUE );

	UninitSessions();

	m_boStarted = FALSE;
}

//创建一个Session
PRUNGATEUSERSESSION CRunDataProcesser::NewSession(SOCKET nSocket, SOCKADDRIN RemoteAddr)
{
	if (!connected())
	{
		return NULL;
	}
	
	int i;
	PRUNGATEUSERSESSION pSession, pNewSession = NULL;
	/*
	if ( m_hPipe == INVALID_HANDLE_VALUE )
		return NULL;
	*/
	OutputMsg( rmTip, "=================================================Begin");
	OutputMsg( rmTip, "开始接入新的socket=%d", (int)nSocket);
	EnterCriticalSection( &m_SessionLock );
	pSession = m_Sessions;
	for ( i=0; i<m_nMaxSessionCount; ++i )
	{
		//这里安潮发现一个问题，在多线程的情况下一个线程要了一个session,然后睡眠了，另外一个线程可能依然获得这个session
		if ( pSession->nSocket == INVALID_SOCKET && 
			!pSession->boMarkToClose && 
			!pSession->boRemoteClosed && 
			!pSession->dwCloseTick  && 
			pSession->nSessionSatus ==enSessionStatusIdle)
		{
			pNewSession = pSession;
			pNewSession->SendBuf.nOffset = 0;
			pNewSession->dwCloseTick = 0;
			pNewSession->boMarkToClose = false;
			pNewSession->boRemoteClosed = false;
			pNewSession->nSessionSatus = enConn;
			break;
		}
		pSession++;
	}
	LeaveCriticalSection( &m_SessionLock );

	if ( pNewSession )
	{
		pNewSession->SockAddr		= RemoteAddr;
		pNewSession->nServerIdx		= 0;
		pNewSession->btPacketIdx	= 0;
		pNewSession->wPacketError	= 0;
		pNewSession->nRecvPacketCount=0;
		pNewSession->nSendPacketCount=0;
		pNewSession->boMarkToClose  = false;
		pNewSession->boRemoteClosed = false;
		pNewSession->boSendAvaliable= true;
		pNewSession->dwSendTimeOut	= 0;
		pNewSession->dwCloseTick	= 0;
		pNewSession->dwConnectTick	= _getTickCount();	
		pNewSession->dwClientMsgTick= pNewSession->dwConnectTick;
		pNewSession->dwServerMsgTick= pNewSession->dwConnectTick;
		pNewSession->nVerifyIdx		= InterlockedIncrement( (unsigned long long*)&m_nUserVerify ); 
		pNewSession->webSocketHead.reset();
		pNewSession->webSocketShakeHand = false;
		pNewSession->sLoginAccount[0] = 0;
		pNewSession->sLoginCharName[0]= 0;
		//pNewSession->nSessionId		= 0;
		if ( !pNewSession->RecvBuf.lpBuffer )
		{ 
			pNewSession->RecvBuf.nSize = SESSION_RECV_BUFSIZE ;
			pNewSession->RecvBuf.lpBuffer = (char*)malloc( pNewSession->RecvBuf.nSize );
		}
		pNewSession->RecvBuf.nOffset = 0;
		#ifdef WIN32
		pNewSession->Overlapped.WSABuf.buf = pNewSession->sRecvBuf;
		pNewSession->Overlapped.WSABuf.len = sizeof(pNewSession->sRecvBuf) - 1;
		#endif
		pNewSession->sRecvBuf[sizeof(pNewSession->sRecvBuf)] = 0;

		if ( !pNewSession->SendBuf.lpBuffer )
		{ 
			pNewSession->SendBuf.nSize = SESSION_SEND_BUFSIZE ;
			pNewSession->SendBuf.lpBuffer = (char*)malloc( pNewSession->SendBuf.nSize );
		}
		pNewSession->SendBuf.nOffset = 0;
		//最后设置会话的nSocket成员数据，
		//以防止其他线程通过nSocket != INVALID_SOCKET判断后对一个尚为初始化完毕的会话进行操作！
		pNewSession->nSocket = nSocket;
		pNewSession->nSessionSatus = enConn; //开始处于连接状态
		char * pIp = inet_ntoa(RemoteAddr.sin_addr);
	
		OutputMsg( rmTip, "[%s]接入新的socket=%d 完毕,nVerifyIdx=%ld",pIp, (int)nSocket,pNewSession->nVerifyIdx);

		m_nActiveUser++;	//增加活动用户计数

		struct timeval tv_timeout;
		tv_timeout.tv_sec = 10;
		tv_timeout.tv_usec = 0;
		setsockopt(nSocket,SOL_SOCKET,SO_RCVTIMEO,&tv_timeout, sizeof(tv_timeout));
		setsockopt(nSocket,SOL_SOCKET,SO_SNDLOWAT,&tv_timeout, sizeof(tv_timeout));

		int nErr = ::recv(pNewSession->nSocket, pNewSession->sRecvBuf, sizeof(pNewSession->sRecvBuf)-1, 0);
		if ( nErr > 0 )
		{
			pNewSession->sRecvBuf[nErr] = 0;
			AddRecvBuf( pNewSession, pNewSession->nVerifyIdx, pNewSession->sRecvBuf, nErr );
		}
		else if (nErr == SOCKET_ERROR)
		{
			pNewSession->boRemoteClosed = true;
			SendCloseSession( pNewSession, TRUE, 2002 );
		}
	}
	return pNewSession;
}

static bool gFindHttpParam(const char * param, const char * buf) {
	while (*param == *buf) {
		if (*(param + 1) == '\0') return true;
		++param; ++buf;
	}
	return false;
}


#define WEB_SOCKET_HANDS_RE "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: %s\r\n\r\n"
#define MAGIC_KEY "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
VOID CRunDataProcesser::ShakeHandsHandle(PRUNGATEUSERSESSION pSession, char* pBuffer, int BufferSize) {
	char key[512]; memset(key, 0, 512);
	for (int i = 0; i < BufferSize; ++i)
	{
		if (gFindHttpParam("Sec-WebSocket-Key", pBuffer+i)) {
			short k = i + 17, ki = 0;
			while(*(pBuffer + k) != '\r' && *(pBuffer + k) != '\n') {
				if (*(pBuffer + k) == ':' || *(pBuffer + k) == ' '){
					++k; continue;
				} else {
					key[ki++] = *(pBuffer + k);
				}
				++k;
			}
			break;
		}
	}
	
	//MSG_LOG("key:%s...", key);
	memcpy(key + strlen(key), MAGIC_KEY, sizeof(MAGIC_KEY));
	//MSG_LOG("megerkey:%s...", key);
	
	//求哈希1
	SHA1 sha;
	unsigned int message_digest[5];
	sha.Reset();
	sha << key;
	sha.Result(message_digest);
	for (int i = 0; i < 5; i++) {
		message_digest[i] = htonl(message_digest[i]);
	}

	memset(key, 0, 512);
	base64_encode(key, reinterpret_cast<const char*>(message_digest), 20);
	char http_res[512] = "";
	sprintf(http_res, WEB_SOCKET_HANDS_RE, key);
	PostUserServerData(pSession, http_res, strlen(http_res), false, false);
	//MSG_LOG("res:%s...",http_res);//fkYTdNEVkParesYkrM4S
	pSession->webSocketShakeHand = true;

	char * pIp = inet_ntoa(pSession->SockAddr.sin_addr);
	OutputMsg( rmTip, "[%s]握手完毕,nVerifyIdx=%ld",pIp,  pSession->nVerifyIdx);	

}

VOID CRunDataProcesser::AddRecvBuf(PRUNGATEUSERSESSION pSession,unsigned long long nVerify, char *pBuffer, int BufferSize)
{
	PCLIENTRECVBUF pRecvBuf;
	char *pData;

	if ( pSession->nSocket == INVALID_SOCKET || pSession->boMarkToClose || pSession->boRemoteClosed || !nVerify || pSession->nVerifyIdx != nVerify )
		return;

	//--pSession->boSendAvaliable = true;
	char * pIp = inet_ntoa(pSession->SockAddr.sin_addr);

	// 未进行websocket握手，则先握手
	if (pSession->webSocketShakeHand)
	{
#ifdef _DEBUG_GATEMSG
		OutputMsg( rmNormal, "");
		OutputMsg( rmTip, "[%s]Idx=%ld: 接收socket数据, 长度为%d, session状态为%d", 
			pIp, pSession->nVerifyIdx, BufferSize, pSession->nSessionSatus);
#endif
		pRecvBuf = (PCLIENTRECVBUF)malloc( sizeof(*pRecvBuf) + BufferSize + 1 );
		pRecvBuf->pSession	= pSession;
		pRecvBuf->nVerify	  = nVerify;
		pRecvBuf->nBufferSize = BufferSize;
		pData = (char*)(pRecvBuf + 1);

		memcpy( pData, pBuffer, BufferSize );
		pData[BufferSize] = 0;

		EnterCriticalSection( &m_RecvQueueLock );
		m_pRecvAppendList->add( pRecvBuf );
		LeaveCriticalSection( &m_RecvQueueLock );
	} else {
		OutputMsg( rmTip, "[%s]进行握手, 长度为%d, session状态为%d, nVerifyIdx=%ld", 
			pIp, BufferSize, pSession->nSessionSatus, pSession->nVerifyIdx);
		//OutputMsg( rmTip, "握手数据：\n%s", pBuffer);
		ShakeHandsHandle(pSession, pBuffer, BufferSize);
		SendOpenSession(pSession);//发送到LogicServer新增连接
	}


}