////////////////////////////////////////////////////////////////////////////////////////
//	CUDPSOCKET_CPP   2003斥 6巋 26老 格
//
//	by Mun Sung-hun (badajoa2002@hotmail.net)
//	Copyright(C) 2003
//
//
//
////////////////////////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "MapServerSocket.h"
#include "CUdpSocket.h"
#include "tgaBase.h"

#include "ServerMem.h"
#include "Party.h"


////////////////////////////////////////////////////////////////////////////////////////
//	Global Class or Value
////////////////////////////////////////////////////////////////////////////////////////
extern	Map				*g_pMap;
extern	ServerMem		*g_pServerMem;	
extern	MapServerSocket	*g_pServer;

ONUDPTRANSFUNC OnTransFunc[DEF_MAXCONTROLPACKET] ;

////////////////////////////////////////////////////////////////////////////////////////
//	UDP Listen Thread
//
////////////////////////////////////////////////////////////////////////////////////////
DWORD WINAPI CUdpSocket::ListenThreadRunner(LPVOID parameter)
{
	CUdpSocket * lpthread = static_cast < CUdpSocket * > (parameter);

	lpthread->ListenThreadProc();

	return 0;
}

////////////////////////////////////////////////////////////////////////////////////////
//	UDP Read Thread
//
////////////////////////////////////////////////////////////////////////////////////////
DWORD WINAPI CUdpSocket::ReadThreadRunner(LPVOID parameter)
{
	CUdpSocket * lpthread = static_cast < CUdpSocket * > (parameter);

	lpthread->ReadThreadProc();

	return 0;
}

////////////////////////////////////////////////////////////////////////////////////////
//
//
////////////////////////////////////////////////////////////////////////////////////////
CUdpSocket::CUdpSocket()
{
	m_lpRecvBuf = new char [sizeof(_UDPPACKET)+1] ;
	m_lpSendBuf = new char [sizeof(_UDPPACKET)+1] ;
	m_lpLogBuf  = new char [sizeof(_UDPPACKET)+1] ;

	::InitializeCriticalSectionAndSpinCount(&m_LogLock	, 2000 );

}

CUdpSocket::~CUdpSocket()
{
	
	bSendTo(_Module.m_szUdpIP, _Module.m_nMapPORT);
	
	WaitForSingleObject ( m_hUdpThreadEndEvent, INFINITE );

	SetEvent(m_hReadEventCompleted);

	CLOSEEVENT(m_hReadEventCompleted);

	CLOSESOCKET(m_SendSock);
	CLOSESOCKET(m_ListenSock);

	m_listReadCompleted.RemoveAll();

	SAFE_DELETE< CMemPool<_UDPPACKET> > (&m_pUDPIOPool) ;
	SAFE_DELETE< char > (&m_lpRecvBuf) ;
	
	SAFE_DELETE< char > (&m_lpSendBuf) ;
	SAFE_DELETE< char > (&m_lpLogBuf) ;

	::DeleteCriticalSection(&m_LogLock);
}

////////////////////////////////////////////////////////////////////////////////////////
//	輯滾甫 輛豐竅扁 困秦輯父 葷儈
//
////////////////////////////////////////////////////////////////////////////////////////
bool CUdpSocket::bSendTo(char * pIPAddr,int iPort)
{
	m_SendAddr.sin_port = htons(iPort);    

	if (NULL == pIPAddr)
	{
		m_SendAddr.sin_addr.s_addr =  ::htons(INADDR_ANY) ; 
	}
	else 
	{
		m_SendAddr.sin_addr.s_addr =  inet_addr(pIPAddr);
	}
   
	memset(m_lpSendBuf,0x0,sizeof(_UDPPACKET)) ;

	if ((m_nSendByte = sendto(m_SendSock, m_lpSendBuf, sizeof(_UDPPACKET), 0, 
	   (SOCKADDR *)&m_SendAddr, sizeof(m_SendAddr))) == SOCKET_ERROR)
	{
		wsprintf(m_cMsg,"ERROR: sendto failed with error %d\n", WSAGetLastError());
		OutputDebugString(m_cMsg);

		return false;
	}
     
	return true ;
}


////////////////////////////////////////////////////////////////////////////////////////
//
////////////////////////////////////////////////////////////////////////////////////////
void CUdpSocket::ListenThreadProc()
{

	SOCKADDR_IN          SenderAddr;
	int                  SenderAddrSize = sizeof(SenderAddr);
	_LPUDPPACKET  cTmpIO ;

	while( _Module.m_bService)
	{

		if ((m_nRecvByte =  recvfrom(m_ListenSock, m_lpRecvBuf, sizeof(_UDPPACKET), 0,
		   (SOCKADDR *)&SenderAddr, &SenderAddrSize)) == SOCKET_ERROR)
		{
			wsprintf(m_cMsg,"ERROR: recvfrom failed with error %d\n", WSAGetLastError());
			OutputDebugString(m_cMsg);
		}
		
		if( !_Module.m_bService )	break;				//	橇肺弊伐 輛豐

		cTmpIO = m_pUDPIOPool->Alloc() ;

		memcpy(cTmpIO,m_lpRecvBuf,sizeof(_UDPPACKET)) ;

		m_listReadCompleted.AddTail( cTmpIO );

		SetEvent( m_hReadEventCompleted );
	}

	SetEvent(m_hUdpThreadEndEvent);

	return ;
}

////////////////////////////////////////////////////////////////////////////////////////
//	Thread Start
//
////////////////////////////////////////////////////////////////////////////////////////
bool CUdpSocket::bStartThread()
{
	//	TODO: Add your control notification handler code here
	int             i = 0;
	DWORD           ThreadID;
	HANDLE hHandle = NULL ;

	hHandle = (HANDLE) _beginthreadex( NULL, 0, (unsigned(__stdcall*)(void*)) ListenThreadRunner, 
											this, 0, (unsigned int *)&ThreadID );

	SetThreadPriority( hHandle, THREAD_PRIORITY_BELOW_NORMAL );		
	
	if (hHandle == NULL) return false ;
	CloseHandle(hHandle) ;
	
	hHandle = (HANDLE) _beginthreadex( NULL, 0, (unsigned(__stdcall*)(void*)) ReadThreadRunner, 
			                                 this, 0, (unsigned int *)&ThreadID );

	SetThreadPriority( hHandle, THREAD_PRIORITY_BELOW_NORMAL );

	if (hHandle == NULL) return false ;
	CloseHandle(hHandle) ;

	
	m_hReadEventCompleted = CreateEvent(NULL, FALSE, FALSE, NULL);

	if( !m_hReadEventCompleted )
	{
		TRACE(TEXT("Error m_hReadEventCompleted Create. Error code = %d\n"),GetLastError());
		return false;
	}

	m_hUdpThreadEndEvent = CreateEvent( NULL, FALSE, FALSE, NULL);

	if( !m_hUdpThreadEndEvent )
	{
		TRACE(TEXT("Error IOCompletedEvent Create. Error code = %d"),GetLastError());
		return FALSE;
	}

	return true ;
}


////////////////////////////////////////////////////////////////////////////////////////
//	UDP Packet 貿府
//
////////////////////////////////////////////////////////////////////////////////////////
void CUdpSocket::ReadPacket( _LPUDPPACKET pUDPPacket)
{

	//	--------------------------------------------------------------------------------
	//	傾遏登瘤 臼籃 皋技瘤綽 芭何
	//	--------------------------------------------------------------------------------
	if ( pUDPPacket->dwCommand < 0 || pUDPPacket->dwCommand >= DEF_MAXCONTROLPACKET )
	{
		m_pUDPIOPool->Free(pUDPPacket) ;
		return ;
	}

	try{
		OnTransFunc[ pUDPPacket->dwCommand].proc(this,  pUDPPacket );
	}
	catch(...)
	{
		static int x = 0;
		wsprintf(m_cMsg,"(X) UDP (%d) Unhandled msg[%d] ",x++, pUDPPacket->dwCommand ) ;
#if defined(_DEBUG) || defined(DEF_BUGTRACE)
		ErrorMsg(m_cMsg) ;
#else 
		_Module.LogEvent(m_cMsg) ;
#endif
	}

	m_pUDPIOPool->Free( pUDPPacket ) ;
}

////////////////////////////////////////////////////////////////////////////////////////
//	Read Function
//
////////////////////////////////////////////////////////////////////////////////////////
void CUdpSocket::ReadThreadProc()
{

	_LPUDPPACKET cTmpIO ;

	while( _Module.m_bService)
	{
		//	----------------------------------------------------------------------------
		//	list 絕瀾 措扁
		//	----------------------------------------------------------------------------
		if(m_listReadCompleted.IsEmpty())	
			WaitForSingleObject (m_hReadEventCompleted,INFINITE);
			
		if( !_Module.m_bService )	break;				//	橇肺弊伐 輛豐
				
		if(m_listReadCompleted.IsEmpty())	continue;	//	List Checking

		cTmpIO = (_LPUDPPACKET) m_listReadCompleted.RemoveHead() ;

		ReadPacket(cTmpIO) ;
	}
	
	return ;
}



////////////////////////////////////////////////////////////////////////////////////////
//	UDP	SEND Function
//
////////////////////////////////////////////////////////////////////////////////////////
void CUdpSocket::SendtoPacket(_LPUDPPACKET lpUdpPacket)
{
	memcpy(m_lpSendBuf , lpUdpPacket, sizeof(_UDPPACKET))  ;

	if ((m_nSendByte = sendto(m_SendSock, m_lpSendBuf, sizeof(_UDPPACKET), 0, 
	   (SOCKADDR *)&m_SendAddr, sizeof(m_SendAddr))) == SOCKET_ERROR)
	{
	  wsprintf(m_cMsg,"ERROR: sendto failed with error %d\n", WSAGetLastError());
	  OutputDebugString(m_cMsg);
	}

	m_pUDPIOPool->Free(lpUdpPacket) ;

	return  ;
}


////////////////////////////////////////////////////////////////////////////////////////
//
//
////////////////////////////////////////////////////////////////////////////////////////
void CUdpSocket::SendToLogPacket(_LPUDPPACKET lpUdpPacket)
{
	::EnterCriticalSection(&m_LogLock);

		memcpy(m_lpLogBuf , lpUdpPacket, sizeof(_UDPPACKET))  ;

		if ((m_nSendByte = sendto(m_SendSock, m_lpLogBuf, sizeof(_UDPPACKET), 0, 
		   (SOCKADDR *)&m_LogAddr, sizeof(m_LogAddr))) == SOCKET_ERROR)
		{
		  wsprintf(m_cMsg,"ERROR: sendto failed with error %d\n", WSAGetLastError());
		  OutputDebugString(m_cMsg);
		}

	::LeaveCriticalSection(&m_LogLock);

	m_pUDPIOPool->Free(lpUdpPacket) ;

	return  ;
}



////////////////////////////////////////////////////////////////////////////////////////
//
//
////////////////////////////////////////////////////////////////////////////////////////
bool CUdpSocket::bCreateSock()
{
	m_ListenSock = WSASocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);

	if (INVALID_SOCKET == m_ListenSock)
	{
		wsprintf(m_cMsg,"WSASocket(g_sdListen): %d\n", WSAGetLastError());
		OutputDebugString(m_cMsg);
		return (false);
	}
	
	m_SendSock = WSASocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
	if (INVALID_SOCKET == m_SendSock)
	{
		wsprintf(m_cMsg,"WSASocket(g_sdListen): %d\n", WSAGetLastError());
		OutputDebugString(m_cMsg);
		return (false);
	}
	
	return true ;
}


////////////////////////////////////////////////////////////////////////////////////////
//	World Server俊 UDP Message傈價
//
//
////////////////////////////////////////////////////////////////////////////////////////
void CUdpSocket::SendtoWorldServer( _LPUDPPACKET pUDPPacket )
{
	memcpy( pUDPPacket->cIP,_Module.m_szUdpIP ,20) ;	//	Map Server IP Address
	pUDPPacket->wPort = _Module.m_nMapPORT;				//	Map Server Port