// IOCPServer.cpp: implementation of the CIOCPServer class.
//
//////////////////////////////////////////////////////////////////////

#include "../stdafx.h"
#include "IOCPServer.h"
#include "../MainFrm.h"

#include "zlib/zlib.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

// Change at your Own Peril

#define HDR_SIZE	15

#define ZLIB_NO  0001		//数据包无压缩模式
#define ZLIB_OK  0002		//数据包为压缩模式

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::CIOCPServer
// 
// DESCRIPTION:	C'tor initializes Winsock2 and miscelleanous events etc.
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// 
////////////////////////////////////////////////////////////////////////////////
CIOCPServer::CIOCPServer()
{
	TRACE("CIOCPServer=%p\n",this);	
	
	WSADATA wsaData;
	WSAStartup(MAKEWORD(2,2), &wsaData);
	
	InitializeCriticalSection(&m_cs);
	
	m_hThread		= NULL;
	m_hKillEvent	= CreateEvent(NULL, TRUE, FALSE, NULL);
	m_socListen		= NULL;
	
	m_bTimeToKill		= false;
	m_bDisconnectAll	= false;
	
	m_hEvent		= NULL;
	m_hCompletionPort= NULL;
	
	m_bInit = false;
	
	m_nSendKbps = 0;
	m_nRecvKbps = 0;
	m_dwIndex   = 0;
	m_nMaxConnections = 10000;

	m_nKeepLiveTime = 1000 * 15;
	m_nIntervalTime = 1000 * 3;

	m_nHeartBeatTime = 0;

	// Packet Flag;
	BYTE bPacketFlag[] = {'c', 'a','s ',' y','b ',' k','q',' '};
	memcpy(m_bPacketFlag, bPacketFlag, sizeof(bPacketFlag));

	TRACE("--%d--\r\n",	m_listContexts.GetCount());
}


////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::CIOCPServer
// 
// DESCRIPTION:	Tidy up
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// 
////////////////////////////////////////////////////////////////////////////////
CIOCPServer::~CIOCPServer()
{
// 	try
// 	{
		Shutdown();
		::WSACleanup();
//	}catch(...){}
}

////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	Init
// 
// DESCRIPTION:	Starts listener into motion
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// 
////////////////////////////////////////////////////////////////////////////////
bool CIOCPServer::Initialize(NOTIFYPROC pNotifyProc, int nMaxConnections, int nPort)
{
	m_pNotifyProc	= pNotifyProc;
	m_nMaxConnections = nMaxConnections;
	m_socListen = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
	
	// 创建监听套节字，绑定到本地端口，进入监听模式
	if (m_socListen == INVALID_SOCKET)
	{
		TRACE(_T("Could not create listen socket %ld\n"),WSAGetLastError());
		return false;
	}
	
	// Event for handling Network IO
	m_hEvent = WSACreateEvent();
	
	if (m_hEvent == WSA_INVALID_EVENT)
	{
		TRACE(_T("WSACreateEvent() error %ld\n"),WSAGetLastError());
		closesocket(m_socListen);
		return false;
	}
	
	// The listener is ONLY interested in FD_ACCEPT
	// That is when a client connects to or IP/Port
	// Request async notification
	int nRet = WSAEventSelect(m_socListen,
						  m_hEvent,
						  FD_ACCEPT);
	
	if (nRet == SOCKET_ERROR)
	{
		TRACE(_T("WSAAsyncSelect() error %ld\n"),WSAGetLastError());
		closesocket(m_socListen);
		return false;
	}
	
	SOCKADDR_IN		saServer;		
	// Listen on our designated Port#
	saServer.sin_port = htons(nPort);
	
	// Fill in the rest of the address structure
	saServer.sin_family = AF_INET;
	saServer.sin_addr.s_addr = INADDR_ANY;
	
	// bind our name to the socket
	nRet = bind(m_socListen, 
		(LPSOCKADDR)&saServer, 
		sizeof(struct sockaddr));
	
	if (nRet == SOCKET_ERROR)
	{
		TRACE(_T("bind() error %ld\n"),WSAGetLastError());
		closesocket(m_socListen);
		return false;
	}
	
	// Set the socket to listen
	nRet = listen(m_socListen, SOMAXCONN);
	if (nRet == SOCKET_ERROR)
	{
		TRACE(_T("listen() error %ld\n"),WSAGetLastError());
		closesocket(m_socListen);
		return false;
	}
	
	
	////////////////////////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////////////////
	UINT	dwThreadId = 0;
	
	m_hThread =
		(HANDLE)_beginthreadex(NULL,				// Security
		0,					// Stack size - use default
		ListenThreadProc,  // Thread fn entry point
		(void*) this,	    
		0,					// Init flag
		&dwThreadId);	// Thread address
	
	if (m_hThread != INVALID_HANDLE_VALUE)
	{
		InitializeIOCP();
		m_bInit = true;
		return true;
	}
	
	
	
	return false;
}

unsigned CIOCPServer::ThreadHeartbeat (LPVOID thisContext)    
{
	// Get back our pointer to the class
	CIOCPServer* pThis = reinterpret_cast<CIOCPServer*>(thisContext);
	ASSERT(pThis);
	
	ClientContext* pContext = NULL;
	
	while (pThis->m_bTimeToKill == false) 
	{
		// 为了最快响应关闭IOCP消息, 检测间隔为1分钟
		for (int i = 0; i < 60 * pThis->m_nHeartBeatTime && pThis->m_bTimeToKill == false; i++)
			Sleep(1000);

		// Thread is Block waiting for IO completion
		POSITION pos  = pThis->m_listContexts.GetHeadPosition();
		while (pos)
		{
			pContext = pThis->m_listContexts.GetNext(pos);
			
			// 只对主socket进行心跳超时检测
			if (pContext->m_bIsMainSocket)
			{
				BYTE bToken = 0xFF;
				pThis->Send(pContext, &bToken, sizeof(bToken));
			}
		}
    }
	
   	return 0;
} 
////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::ListenThreadProc
// 
// DESCRIPTION:	Listens for incoming clients
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// 
////////////////////////////////////////////////////////////////////////////////
unsigned CIOCPServer::ListenThreadProc(LPVOID lParam)
{
	CIOCPServer* pThis = reinterpret_cast<CIOCPServer*>(lParam);
	
	WSANETWORKEVENTS events;
	
	while(1)
	{
		//
		// Wait for something to happen
		//
        if (WaitForSingleObject(pThis->m_hKillEvent, 100) == WAIT_OBJECT_0)
            break;
		
		DWORD dwRet;
		dwRet = WSAWaitForMultipleEvents(1,
			&pThis->m_hEvent,
			FALSE,
			100,
			FALSE);
		
		if (dwRet == WSA_WAIT_TIMEOUT)
			continue;
		
		//
		// Figure out what happened
		//
		int nRet = WSAEnumNetworkEvents(pThis->m_socListen,
			pThis->m_hEvent,
			&events);
		
		if (nRet == SOCKET_ERROR)
		{
			TRACE(_T("WSAEnumNetworkEvents error %ld\n"),WSAGetLastError());
			break;
		}
		
		// Handle Network events //
		// ACCEPT
		if (events.lNetworkEvents & FD_ACCEPT)
		{
			if (events.iErrorCode[FD_ACCEPT_BIT] == 0)
				pThis->OnAccept();
			else
			{
				TRACE(_T("Unknown network event error %ld\n"),WSAGetLastError());
				break;
			}
			
		}
		
	} // while....
	
	return 0; // Normal Thread Exit Code...
}
////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::OnAccept
// 
// DESCRIPTION:	Listens for incoming clients
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// Ulf Hedlund			 09072001			   Changes for OVERLAPPEDPLUS
////////////////////////////////////////////////////////////////////////////////
void CIOCPServer::OnAccept()
{
	SOCKADDR_IN	SockAddr;
	SOCKET		clientSocket;
	
	int			nRet;
	int			nLen;
	
	if (m_bTimeToKill || m_bDisconnectAll)
		return;
	
	//
	// accept the new socket descriptor
	//
	nLen = sizeof(SOCKADDR_IN);
	clientSocket = accept(m_socListen,
		(LPSOCKADDR)&SockAddr,
		&nLen); 
	
	if (clientSocket == SOCKET_ERROR)
	{
		nRet = WSAGetLastError();
		if (nRet != WSAEWOULDBLOCK)
		{
			//
			// Just log the error and return
			//
			TRACE(_T("accept() error\n"),WSAGetLastError());
			return;
		}
	}
	
	// Create the Client context to be associted with the completion port
	ClientContext* pContext = AllocateContext(clientSocket);
	// AllocateContext fail
	if (pContext == NULL)
		return;
	
	// Fix up In Buffer
	pContext->m_wsaInBuffer.buf = (char*)pContext->m_byInBuffer;
	pContext->m_wsaInBuffer.len = sizeof(pContext->m_byInBuffer);
	
	// Associate the new socket with a completion port.
	if (!AssociateSocketWithCompletionPort(clientSocket, m_hCompletionPort, (DWORD) pContext))
    {
        delete pContext;
		pContext = NULL;
		
        closesocket( clientSocket );
        closesocket( m_socListen );
        return;
    }
	
	CLock cs(m_cs, "OnAccept" );
	// Hold a reference to the context
	m_listContexts.AddTail(pContext);
	

	// Trigger first IO Completion Request
	// Otherwise the Worker thread will remain blocked waiting for GetQueuedCompletionStatus...
	// The first message that gets queued up is ClientIoInitializing - see ThreadPoolFunc and 
	// IO_MESSAGE_HANDLER
	
	
	OVERLAPPEDPLUS	*pOverlap = new OVERLAPPEDPLUS(IOInitialize);
	
	BOOL bSuccess = PostQueuedCompletionStatus(m_hCompletionPort, 0, (DWORD) pContext, &pOverlap->m_ol);
	
	if ( (!bSuccess && GetLastError( ) != ERROR_IO_PENDING))
	{            
        RemoveStaleClient(pContext,TRUE);
		if (pOverlap)
		{
			delete pOverlap;
		}
		return;
    }
	
	m_pNotifyProc( pContext, NC_CLIENT_CONNECT);
	
	// Post to WSARecv Next
	PostRecv(pContext);
}


////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::InitializeIOCP
// 
// DESCRIPTION:	Create a dummy socket and associate a completion port with it.
//				once completion port is create we can dicard the socket
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// 
////////////////////////////////////////////////////////////////////////////////
bool CIOCPServer::InitializeIOCP(void)
{
    SOCKET s;
    DWORD i;
    UINT  nThreadID;
    SYSTEM_INFO systemInfo;
	
    //
    // First open a temporary socket that we will use to create the
    // completion port.  In NT 3.51 it will not be necessary to specify
    // the FileHandle parameter of CreateIoCompletionPort()--it will
    // be legal to specify FileHandle as NULL.  However, for NT 3.5
    // we need an overlapped file handle.
    //
	
    s = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    if ( s == INVALID_SOCKET ) 
        return false;
	
    // Create the completion port that will be used by all the worker
    // threads.
    m_hCompletionPort = CreateIoCompletionPort( (HANDLE)s, NULL, 0, 0 );
    if ( m_hCompletionPort == NULL ) 
	{
        closesocket( s );
        return false;
    }
	
    // Close the socket, we don't need it any longer.
    closesocket( s );
	
    // Determine how many processors are on the system.
    GetSystemInfo( &systemInfo );
	
    // We use two worker threads for eachprocessor on the system--this is choosen as a good balance
    // that ensures that there are a sufficient number of threads available to get useful work done 
	// but not too many that context switches consume significant overhead.
	UINT nWorkerCnt = systemInfo.dwNumberOfProcessors * 2 + 2;
	
	// We need to save the Handles for Later Termination...
	HANDLE hWorker;
	m_nWorkerCnt = 0;
	
    for ( i = 0; i < nWorkerCnt; i++ ) 
	{
		hWorker = (HANDLE)_beginthreadex(NULL,					// Security
			0,						// Stack size - use default
			ThreadPoolFunc,     		// Thread fn entry point
			(void*) this,			// Param for thread
			0,						// Init flag
			&nThreadID);			// Thread address
		
		
        if (hWorker == NULL ) 
		{
            CloseHandle( m_hCompletionPort );
            return false;
        }
		
		m_nWorkerCnt++;
		
		CloseHandle(hWorker);
    }
	
	if (m_nHeartBeatTime != 0)
	{
		hWorker = (HANDLE) _beginthreadex(NULL,					// Security
			0,						// Stack size - use default
			ThreadHeartbeat,     		// Thread fn entry point
			(void*) this,			// Param for thread
			0,						// Init flag
			&nThreadID);			// Thread address
		
		if (hWorker == NULL ) 
		{
			CloseHandle( m_hCompletionPort );
			return false;
		}
		
    	CloseHandle(hWorker);
	}

	return true;
} 

////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::ThreadPoolFunc 
// 
// DESCRIPTION:	This is the main worker routine for the worker threads.  
//				Worker threads wait on a completion port for I/O to complete.  
//				When it completes, the worker thread processes the I/O, then either pends 
//				new I/O or closes the client's connection.  When the service shuts 
//				down, other code closes the completion port which causes 
//				GetQueuedCompletionStatus() to wake up and the worker thread then 
//				exits.
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// Ulf Hedlund			 09062001              Changes for OVERLAPPEDPLUS
////////////////////////////////////////////////////////////////////////////////
unsigned CIOCPServer::ThreadPoolFunc (LPVOID thisContext)    
{
	// Get back our pointer to the class
	ULONG ulFlags = MSG_PARTIAL;
	CIOCPServer* pThis = reinterpret_cast<CIOCPServer*>(thisContext);
	ASSERT(pThis);
	
    HANDLE hCompletionPort = pThis->m_hCompletionPort;
    
    DWORD dwIoSize;
    LPOVERLAPPED lpOverlapped;
    ClientContext* lpClientContext;
	OVERLAPPEDPLUS*	pOverlapPlus;
	bool			bError;
	BOOL bIORet;
	
	//
    // Loop round and round servicing I/O completions.
	// 
	
	for (BOOL bStayInPool = TRUE; bStayInPool && pThis->m_bTimeToKill == false; ) 
	{
		pOverlapPlus	= NULL;
		lpClientContext = NULL;
		bError			= false;
		
		// Get a completed IO request.
		bIORet = GetQueuedCompletionStatus(
			hCompletionPort,
			&dwIoSize,
			(LPDWORD) &lpClientContext,
			&lpOverlapped, INFINITE);
		
		DWORD dwIOError = GetLastError();
		pOverlapPlus = CONTAINING_RECORD(lpOverlapped, OVERLAPPEDPLUS, m_ol);
		
		
        if (!bIORet && dwIOError != WAIT_TIMEOUT )
		{
			if (lpClientContext && pThis->m_bTimeToKill == false)
			{
				pThis->RemoveStaleClient(lpClientContext, FALSE);
			}
			
			// anyway, this was an error and we should exit
			bError = true;
		}
		
		//////////////////////////////////////////////////////////////////////////////////////////
		//////////////////////////////////////////////////////////////////////////////////////////
		if (!bError)
		{
			if(bIORet && NULL != pOverlapPlus && NULL != lpClientContext) 
			{
// 				try
// 				{
					pThis->ProcessIOMessage(pOverlapPlus->m_ioType, lpClientContext, dwIoSize);
// 				}
// 				catch (...) {}
			}
		}

		if(pOverlapPlus)
			delete pOverlapPlus; // from previous call
    }
	
	InterlockedDecrement(&pThis->m_nWorkerCnt);
	
   	return 0;
} 

////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::Stop
// 
// DESCRIPTION:	Signal the listener to quit his thread
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// 
////////////////////////////////////////////////////////////////////////////////
void CIOCPServer::Stop()
{
    ::SetEvent(m_hKillEvent);
    WaitForSingleObject(m_hThread, INFINITE);
	CloseHandle(m_hThread);
    CloseHandle(m_hKillEvent);
}

////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::GetHostName
// 
// DESCRIPTION:	Get the host name of the connect client
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// 
////////////////////////////////////////////////////////////////////////////////
CString CIOCPServer::GetHostName(SOCKET socket)
{
	sockaddr_in  sockAddr;
	memset(&sockAddr, 0, sizeof(sockAddr));
	
	int nSockAddrLen = sizeof(sockAddr);
	
	BOOL bResult = getpeername(socket,(SOCKADDR*)&sockAddr, &nSockAddrLen);
	
	return bResult != INVALID_SOCKET ? inet_ntoa(sockAddr.sin_addr) : "";
}

void CIOCPServer::PostRecv(ClientContext* pContext)
{
	// issue a read request 
	OVERLAPPEDPLUS * pOverlap = new OVERLAPPEDPLUS(IORead);
	ULONG			ulFlags = MSG_PARTIAL;
	DWORD			dwNumberOfBytesRecvd;
	UINT nRetVal = WSARecv(pContext->m_Socket, 
		&pContext->m_wsaInBuffer,
		1,
		&dwNumberOfBytesRecvd, 
		&ulFlags,
		&pOverlap->m_ol, 
		NULL);
	
	if ( nRetVal == SOCKET_ERROR && WSAGetLastError() != WSA_IO_PENDING) 
	{
		RemoveStaleClient(pContext, FALSE);
		if (pOverlap)
		{
			delete pOverlap;
		}
	}
}
////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::Send
// 
// DESCRIPTION:	Posts a Write + Data to IO CompletionPort for transfer
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// Ulf Hedlund			 09062001			   Changes for OVERLAPPEDPLUS
////////////////////////////////////////////////////////////////////////////////
// char* MyEncode(char *data,int len)
// {
// 	for (int i = 0; i < len; i++)
// 	{
// 		data[i] ^= 0x19;
// 		data[i] -= 0x86;
// 	}
// 	return data;
// }

char* encrypt( char *arr,  int len)
{

    for( int i = 0; i < len; i++)
	{
		arr[i] ^= 0xfe,0xf1,0x98,0xf1,0x56;0x12,0xf6;	
		arr[i] -= 0x66,0xf7,0x67,0xf5,0x25,0xfa,0xf4;

    }
	return arr;
	
}

void CIOCPServer::Send(ClientContext* pContext, LPBYTE lpData, UINT nSize, BOOL bZlib)
{
	if (pContext == NULL)
		return;
	else
	  TRACE("Send 开始 开始检测缓冲区释放堆积\r\n");

	if(pContext->m_WriteBuffer.GetBufferLen() != 0)
	{
		TRACE("Send 缓存区堆积 不能执行\r\n");
		return;
	}
	TRACE("Send 缓存区正常 NEXT 临界区\r\n");
	CLock cs(pContext->m_SndLock, "Send");
	TRACE("临界区 OK \r\n");
/*
	// Wait for Data Ready signal to become available
	WaitForSingleObject(pContext->m_hWriteComplete, INFINITE);
*/

	try
	{
		if (nSize > 0)
		{
			// Compress data
			unsigned long	destLen = (double)nSize * 1.001  + 12;
			LPBYTE			pDest = new BYTE[destLen];

			if (pDest == NULL)
				return;
			
			if(bZlib == TRUE)  //发送数据需要压缩
			{
				//分配压缩数据的空间
				bZlib = ZLIB_OK;  //压缩数据
				int	nRet = compress(pDest, &destLen, lpData, nSize);                      //压缩数据
				if (nRet != Z_OK)
				{
					delete [] pDest;
					return;
				}
			}
			else   //发送数据不需要压缩
			{
				bZlib = ZLIB_NO;  //无压缩数据
				destLen = nSize;
				CopyMemory(pDest,lpData, nSize);
			}
			//////////////////////////////////////////////////////////////////////////
			LONG nBufLen = destLen + HDR_SIZE;
			// 5 bytes packet flag
			pContext->m_WriteBuffer.Write(m_bPacketFlag, sizeof(m_bPacketFlag));
			// 4 byte header [Size of Entire Packet]
			pContext->m_WriteBuffer.Write((PBYTE) &nBufLen, sizeof(nBufLen));
			// 4 byte header [Size of UnCompress Entire Packet]
			pContext->m_WriteBuffer.Write((PBYTE) &nSize, sizeof(nSize));
			// Writ  Zlib nFalg
			pContext->m_WriteBuffer.Write((PBYTE) &bZlib, sizeof(BOOL));             //写入数据是否压缩标志
			// Write Data
			pContext->m_WriteBuffer.Write(pDest, destLen);
			
			delete [] pDest;
			
			
			// 如果当前缓冲区无数据堆积，执行PostSend
			if (pContext->m_WriteBuffer.GetBufferLen() == nBufLen)
			{
				encrypt((char *)pContext->m_WriteBuffer.GetBuffer(),pContext->m_WriteBuffer.GetBufferLen());//加密
				PostSend(pContext);
			}
			else
			{
				TRACE("我操 卡了卡了 快看\r\n");
				return;
			}
			// 发送完后，再备份数据, 因为有可能是m_ResendWriteBuffer本身在发送,所以不直接写入
			LPBYTE lpResendWriteBuffer = new BYTE[nSize];
			if(lpResendWriteBuffer == NULL)  return;
			CopyMemory(lpResendWriteBuffer, lpData, nSize);
			pContext->m_ResendWriteBuffer.ClearBuffer();
			pContext->m_ResendWriteBuffer.Write(lpResendWriteBuffer, nSize);	// 备份发送的数据
			delete [] lpResendWriteBuffer;
		}
		else // 要求重发
		{
			pContext->m_WriteBuffer.Write(m_bPacketFlag, sizeof(m_bPacketFlag));
			pContext->m_ResendWriteBuffer.ClearBuffer();
			pContext->m_ResendWriteBuffer.Write(m_bPacketFlag, sizeof(m_bPacketFlag));	// 备份发送的数据	
		}
		
	}catch(...)
	{
		TRACE("Send Catch......\r\n");
	}
}


////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CClientListener::OnClientInitializing
// 
// DESCRIPTION:	Called when client is initailizing
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// Ulf Hedlund           09062001		       Changes for OVERLAPPEDPLUS
////////////////////////////////////////////////////////////////////////////////
bool CIOCPServer::OnClientInitializing(ClientContext* pContext, DWORD dwIoSize)
{
	// We are not actually doing anything here, but we could for instance make
	// a call to Send() to send a greeting message or something
	
	return true;		// make sure to issue a read after this
}

////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::OnClientReading
// 
// DESCRIPTION:	Called when client is reading 
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// Ulf Hedlund           09062001		       Changes for OVERLAPPEDPLUS
////////////////////////////////////////////////////////////////////////////////

// char* MyDecode(char *data,int len)
// {
// 	for (int i = 0; i < len; i++)
// 	{
// 		data[i] += 0x86;
// 		data[i] ^= 0x19;
// 	}
// 	return data;
// }



char* decrypt( char *arr,  int len)
{

    for( int i = 0; i < len; i++)
	{	
		arr[i] += 0x66,0xf7,0x67,0xf5,0x25,0xfa,0xf4;
		arr[i] ^= 0xfe,0xf1,0x98,0xf1,0x56;0x12,0xf6;	

    }
	return arr;
	
}

bool CIOCPServer::OnClientReading(ClientContext* pContext, DWORD dwIoSize)
{
	CLock cs(CIOCPServer::m_cs, "OnClientReading");
	try
	{
		if (dwIoSize == 0)
		{
			RemoveStaleClient(pContext, FALSE);
			return false;
		}

		//////////////////////////////////////////////////////////////////////////
		static DWORD nLastTick = GetTickCount();
		static DWORD nBytes = 0;
		nBytes += dwIoSize;
		
		if (GetTickCount() - nLastTick >= 1000)
		{
			nLastTick = GetTickCount();
			InterlockedExchange((LPLONG)&(m_nRecvKbps), nBytes);
			nBytes = 0;
		}
		//////////////////////////////////////////////////////////////////////////
		
		// 解密数据
		decrypt((char *)pContext->m_byInBuffer,dwIoSize);
		
		// 要求重新发送
		if (dwIoSize == FLAG_SIZE && memcmp(pContext->m_byInBuffer, m_bPacketFlag, FLAG_SIZE) == 0)
		{
			Send(pContext, pContext->m_ResendWriteBuffer.GetBuffer(), pContext->m_ResendWriteBuffer.GetBufferLen());
			// 必须再投递一个接收请求
			PostRecv(pContext);
			return true;
		}
		
		// 备份原始数据
		pContext->m_CompressionBuffer.Write(pContext->m_byInBuffer,dwIoSize);
		
		m_pNotifyProc(pContext, NC_RECEIVE);
		
		// 检测数据大小
		while (pContext->m_CompressionBuffer.GetBufferLen() > HDR_SIZE)
		{
			BYTE bPacketFlag[FLAG_SIZE];
			CopyMemory(bPacketFlag, pContext->m_CompressionBuffer.GetBuffer(), sizeof(bPacketFlag));
			
			if (memcmp(m_bPacketFlag, bPacketFlag, sizeof(m_bPacketFlag)) != 0)
			{
				CString str;
				str.Format("数据头不对 IP:%s  T下线\r\n",GetHostName(pContext->m_Socket));
				TRACE(str);
				RemoveStaleClient(pContext, FALSE);
				return false;
				throw "bad buffer";
			}

			int nSize = 0;
			CopyMemory(&nSize, pContext->m_CompressionBuffer.GetBuffer(FLAG_SIZE), sizeof(int));
			
			// Update Process Variable
			pContext->m_nTransferProgress = pContext->m_CompressionBuffer.GetBufferLen() * 100 / nSize;
			
			if (nSize && (pContext->m_CompressionBuffer.GetBufferLen()) >= nSize)
			{
				BOOL bZilb = FALSE;
				int nUnCompressLength = 0;
				// Read off header
				pContext->m_CompressionBuffer.Read((PBYTE) bPacketFlag, sizeof(bPacketFlag));
				pContext->m_CompressionBuffer.Read((PBYTE) &nSize, sizeof(int));
				pContext->m_CompressionBuffer.Read((PBYTE) &nUnCompressLength, sizeof(int));
				pContext->m_CompressionBuffer.Read((PBYTE) &bZilb, sizeof(BOOL));             //读取数据是否压缩
				
				////////////////////////////////////////////////////////
				////////////////////////////////////////////////////////
				// SO you would process your data here
				// 
				// I'm just going to post message so we can see the data
				int	nCompressLength = nSize - HDR_SIZE;
				PBYTE pData = new BYTE[nCompressLength];
				if (pData == NULL )
					throw "bad Allocate";
				
				pContext->m_CompressionBuffer.Read(pData, nCompressLength);
				//////////////////////////////////////////////////////////////////////////
				unsigned long	destLen = nUnCompressLength;
				if(bZilb == ZLIB_OK)   //数据需要解压缩
				{
					PBYTE pDeCompressionData = new BYTE[nUnCompressLength];
					if(pDeCompressionData == NULL)
						throw "bad Allocate";

					int nRet = uncompress(pDeCompressionData, &destLen, pData, nCompressLength);
					//////////////////////////////////////////////////////////////////////////
					if (nRet == Z_OK)
					{
						pContext->m_DeCompressionBuffer.ClearBuffer();
						pContext->m_DeCompressionBuffer.Write(pDeCompressionData, destLen);
						m_pNotifyProc( pContext, NC_RECEIVE_COMPLETE);
					}
					else
					{
						delete [] pDeCompressionData;

						throw "bad buffer";
					}
					delete [] pDeCompressionData;
				}
				else if(bZilb == ZLIB_NO)   //数据不需要解压缩
				{
					pContext->m_DeCompressionBuffer.ClearBuffer();
					pContext->m_DeCompressionBuffer.Write(pData, destLen);
					m_pNotifyProc( pContext, NC_RECEIVE_COMPLETE);
				}
				else
					throw "bad Buffer";
				
				delete [] pData;
			}
			else
				break;
			
		}
		// Post to WSARecv Next
		PostRecv(pContext);
 }
 catch (...)
 {
	 pContext->m_CompressionBuffer.ClearBuffer();
	 // 要求重发，就发送0, 内核自动添加数包标志
	 Send(pContext, NULL, 0, TRUE);
	 PostRecv(pContext);
 }
 
 return true;
}

////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::OnClientWriting
// 
// DESCRIPTION:	Called when client is writing
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// Ulf Hedlund           09062001		       Changes for OVERLAPPEDPLUS
////////////////////////////////////////////////////////////////////////////////

void CIOCPServer::PostSend(ClientContext* pContext)
{	
	OVERLAPPEDPLUS * pOverlap = new OVERLAPPEDPLUS(IOWrite);
	
	ULONG ulFlags = MSG_PARTIAL;
	
	m_pNotifyProc( pContext, NC_TRANSMIT);
	
	pContext->m_wsaOutBuffer.buf = (char*) pContext->m_WriteBuffer.GetBuffer();
	pContext->m_wsaOutBuffer.len = pContext->m_WriteBuffer.GetBufferLen();
		
	int  nRetVal = WSASend(pContext->m_Socket, 
		&pContext->m_wsaOutBuffer,
		1,
		&pContext->m_wsaOutBuffer.len, 
		ulFlags,
		&pOverlap->m_ol, 
		NULL);
	
	if (nRetVal == SOCKET_ERROR && WSAGetLastError() != WSA_IO_PENDING)
	{
		TRACE("发送失败\r\n");
		RemoveStaleClient( pContext, FALSE );
		if (pOverlap)	
			delete pOverlap;
	}
	
}

bool CIOCPServer::OnClientWriting(ClientContext* pContext, DWORD dwIoSize)
{
	try
	{
		//////////////////////////////////////////////////////////////////////////
		static DWORD nLastTick = GetTickCount();
		static DWORD nBytes = 0;
		
		nBytes += dwIoSize;
		
		if (GetTickCount() - nLastTick >= 1000)
		{
			nLastTick = GetTickCount();
			InterlockedExchange((LPLONG)&(m_nSendKbps), nBytes);
			nBytes = 0;
		}
		//////////////////////////////////////////////////////////////////////////
		// Finished writing - tidy up
		if (dwIoSize > 0)// Finished writing - tidy up
		{
			pContext->m_WriteBuffer.Delete(dwIoSize);
			
			if (pContext->m_WriteBuffer.GetBufferLen() > 0)
			{
				TRACE("数据堆积 继续投递\n");
				PostSend(pContext);
			}
			else
			{
				TRACE("发送完成 清空Buffer\n");
				pContext->m_WriteBuffer.ClearBuffer();
			}
//			SetEvent(pContext->m_hWriteComplete);
			
			return true;
		}
		
	}catch(...){}
	return false;			// issue new read after this one
}

////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::CloseCompletionPort
// 
// DESCRIPTION:	Close down the IO Complete Port, queue and associated client context structs
//				which in turn will close the sockets...
//				
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// 
////////////////////////////////////////////////////////////////////////////////
void CIOCPServer::CloseCompletionPort()
{
	
	while (m_nWorkerCnt)
	{
		PostQueuedCompletionStatus(m_hCompletionPort, 0, (DWORD) NULL, NULL);
		Sleep(100);
	}
	
	// Close the CompletionPort and stop any more requests
	CloseHandle(m_hCompletionPort);
	
	ClientContext* pContext = NULL;
	
	do 
	{
		POSITION pos  = m_listContexts.GetHeadPosition();
		if (pos)
		{
			pContext = m_listContexts.GetNext(pos);			
			RemoveStaleClient(pContext, FALSE);
		}
	}
	while (!m_listContexts.IsEmpty());
	
	m_listContexts.RemoveAll();	
}


BOOL CIOCPServer::AssociateSocketWithCompletionPort(SOCKET socket, HANDLE hCompletionPort, DWORD dwCompletionKey)
{
	HANDLE h = CreateIoCompletionPort((HANDLE) socket, hCompletionPort, dwCompletionKey, 0);
	return h == hCompletionPort;
}

////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::RemoveStaleClient
// 
// DESCRIPTION:	Client has died on us, close socket and remove context from our list
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// 
////////////////////////////////////////////////////////////////////////////////
void CIOCPServer::RemoveStaleClient(ClientContext* pContext, BOOL bGraceful)
{
    CLock cs(m_cs, "RemoveStaleClient");
	
	TRACE("CIOCPServer::RemoveStaleClient\n");
	
    LINGER lingerStruct;
	
	
    //
    // If we're supposed to abort the connection, set the linger value
    // on the socket to 0.
    //
	
    if ( !bGraceful ) 
	{
		
        lingerStruct.l_onoff = 1;
        lingerStruct.l_linger = 0;
        setsockopt( pContext->m_Socket, SOL_SOCKET, SO_LINGER,
			(char *)&lingerStruct, sizeof(lingerStruct) );
    }
	
    //
    // Free context structures
	if (m_listContexts.Find(pContext)) 
	{
		
		//
		// Now close the socket handle.  This will do an abortive or  graceful close, as requested.  
		CancelIo((HANDLE) pContext->m_Socket);
		
		closesocket( pContext->m_Socket );
		pContext->m_Socket = INVALID_SOCKET;
		
        while (!HasOverlappedIoCompleted((LPOVERLAPPED)pContext)) 
			Sleep(0);
		
		m_pNotifyProc(pContext, NC_CLIENT_DISCONNECT);

		MoveToFreePool(pContext);
	}
}

void CIOCPServer::Shutdown()
{
	if (m_bInit == false)
		return;
	
	m_bInit = false;
	m_bTimeToKill = true;
	
	// Stop the listener
	Stop();
	
	
	closesocket(m_socListen);	
	WSACloseEvent(m_hEvent);
	
	
	CloseCompletionPort();

	
	while (!m_listFreePool.IsEmpty())
		delete m_listFreePool.RemoveTail();
	DeleteCriticalSection(&m_cs);

}


////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::MoveToFreePool
// 
// DESCRIPTION:	Checks free pool otherwise allocates a context
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// 
////////////////////////////////////////////////////////////////////////////////
void CIOCPServer::MoveToFreePool(ClientContext *pContext)
{
	CLock cs(m_cs, "MoveToFreePool");
    // Free context structures
	POSITION pos = m_listContexts.Find(pContext);
	if (pos) 
	{
		pContext->m_CompressionBuffer.ClearBuffer();
		pContext->m_WriteBuffer.ClearBuffer();
		pContext->m_DeCompressionBuffer.ClearBuffer();
		pContext->m_ResendWriteBuffer.ClearBuffer();
		DeleteCriticalSection(&pContext->m_SndLock);
		m_listFreePool.AddTail(pContext);
		m_listContexts.RemoveAt(pos);
	}
}



////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::MoveToFreePool
// 
// DESCRIPTION:	Moves an 'used/stale' Context to the free pool for reuse
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// 
////////////////////////////////////////////////////////////////////////////////
ClientContext*  CIOCPServer::AllocateContext(SOCKET clientSocket)
{
	ClientContext* pContext = NULL;
	
	CLock cs(CIOCPServer::m_cs, "AllocateContext");
	
	if (!m_listFreePool.IsEmpty())
	{
		pContext = m_listFreePool.RemoveHead();
	}
	else
	{
		pContext = new ClientContext;
	}
	
	ASSERT(pContext);
	
	if (pContext != NULL)
	{
		// 设置保活
		SetKeepAlive(clientSocket, m_nKeepLiveTime, m_nIntervalTime);

		ZeroMemory(pContext, sizeof(ClientContext));
		pContext->m_Socket = clientSocket;
		pContext->m_bIsMainSocket = FALSE;
		pContext->m_Dialog[0] = 0;
		pContext->m_Dialog[1] = NULL;
//		pContext->m_hWriteComplete = CreateEvent(0,FALSE,TRUE,0);//修改的
		InitializeCriticalSection(&pContext->m_SndLock);

		pContext->dwID=m_dwIndex++;
		if (m_dwIndex==10000) m_dwIndex=0;
		pContext->dwID=m_dwIndex++;
		pContext->m_bProxyConnected=0;
	}
	return pContext;
}


void CIOCPServer::ResetConnection(ClientContext* pContext)
{
	
	CString strHost;
	ClientContext* pCompContext = NULL;
	
	CLock cs(CIOCPServer::m_cs, "ResetConnection");
	
	POSITION pos  = m_listContexts.GetHeadPosition();
	while (pos)
	{
		pCompContext = m_listContexts.GetNext(pos);			
		if (pCompContext == pContext)
		{
			RemoveStaleClient(pContext, TRUE);
			break;
		}
	}
}

void CIOCPServer::DisconnectAll()
{
	m_bDisconnectAll = true;
	CString strHost;
	ClientContext* pContext = NULL;
	
	CLock cs(CIOCPServer::m_cs, "DisconnectAll");
	
	POSITION pos  = m_listContexts.GetHeadPosition();
	while (pos)
	{
		pContext = m_listContexts.GetNext(pos);			
		RemoveStaleClient(pContext, TRUE);
	}
	m_bDisconnectAll = false;
}

bool CIOCPServer::IsRunning()
{
	return m_bInit;
}

BOOL CIOCPServer::SetKeepAlive( SOCKET Socket, UINT nKeepTime /* = 10 * 1000 */, UINT nKeepInterval /* = 3000 */ )
{
	BOOL   bConditionalAccept=TRUE;   
	if (setsockopt(Socket, SOL_SOCKET, SO_KEEPALIVE, (const   char*)&bConditionalAccept, sizeof(BOOL)) != 0)
	{ 
		TRACE(_T("setsockopt(SO_UPDATE_ACCEPT_CONTEXT)")); 
		return FALSE;
	}
	
	// 设置超时详细信息 socket的keep alive   Vista之前默认5次 之后默认发10次
	DWORD dwBytes;
	tcp_keepalive	klive	= {0};
	klive.onoff				= 1;			// 开启keepalive
	klive.keepalivetime		= nKeepTime;	// 多长时间没有数据就开始发送心跳包 5 * 1000
	klive.keepaliveinterval	= nKeepInterval;// 每隔多长时间发送一个心跳包 1000
	
	if (WSAIoctl(Socket, SIO_KEEPALIVE_VALS, &klive, sizeof(tcp_keepalive), NULL, 0, &dwBytes, 0, NULL) != 0)
	{
		TRACE(_T("WSAIoctl(SIO_KEEPALIVE_VALS)"));
		return FALSE;
	}
	return TRUE;
}