void SwitchMenuItem(BOOL fFlag)
{
HMENU hMainMenu = GetMenu(g_hMainWnd);
HMENU hMenu = GetSubMenu(hMainMenu, 0);
if (fFlag)
{
EnableMenuItem(hMenu, IDM_STARTSERVICE, MF_GRAYED|MF_BYCOMMAND);
EnableMenuItem(hMenu, IDM_STOPSERVICE, MF_ENABLED|MF_BYCOMMAND);
SendMessage(g_hToolBar, TB_SETSTATE, (WPARAM)IDM_STARTSERVICE, (LPARAM)MAKELONG(TBSTATE_INDETERMINATE, 0));
SendMessage(g_hToolBar, TB_SETSTATE, (WPARAM)IDM_STOPSERVICE, (LPARAM)MAKELONG(TBSTATE_ENABLED, 0));
InsertLogMsg(IDS_STARTSERVICE);
}
else
{
EnableMenuItem(hMenu, IDM_STARTSERVICE, MF_ENABLED|MF_BYCOMMAND);
EnableMenuItem(hMenu, IDM_STOPSERVICE, MF_GRAYED|MF_BYCOMMAND);
SendMessage(g_hToolBar, TB_SETSTATE, (WPARAM)IDM_STARTSERVICE, (LPARAM)MAKELONG(TBSTATE_ENABLED, 0));
SendMessage(g_hToolBar, TB_SETSTATE, (WPARAM)IDM_STOPSERVICE, (LPARAM)MAKELONG(TBSTATE_INDETERMINATE, 0));
InsertLogMsg(IDS_STOPSERVICE);
}
}
LRESULT OnSockMsg(WPARAM wParam, LPARAM lParam)
{
switch (WSAGETSELECTEVENT(lParam))
{
case FD_CONNECT:
{
InsertLogMsg(_T("로그인 게이트 서버와 접속 되었습니다."));
break;
}
case FD_CLOSE:
{
break;
}
case FD_READ:
{
char szMsg[4096];
int nLen = recv((SOCKET)wParam, szMsg, sizeof(szMsg), 0);
szMsg[nLen] = '\0';
InsertLogMsg(szMsg);
break;
}
}
return 0;
}
void __cbDBMsg( char *pState, int nNativeCode, char *pDesc )
{
static TCHAR szState[256], szDesc[2048];
static TCHAR szMsg[2048];
MultiByteToWideChar( CP_ACP, 0, pState, -1, szState, sizeof( szState ) / sizeof( TCHAR ) );
MultiByteToWideChar( CP_ACP, 0, pDesc, -1, szDesc, sizeof( szDesc ) / sizeof( TCHAR ) );
wsprintf( szMsg, _T("ODBC MsgID: %s(%d)"), szState, nNativeCode );
InsertLogMsg( szMsg );
wsprintf( szMsg, _T("%s"), szDesc );
InsertLogMsg( szMsg );
}
VOID WINAPI OnTimerProc(HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
switch (idEvent)
{
case _ID_TIMER_KEEPALIVE:
{
if (g_csock != INVALID_SOCKET)
{
SendExToServer(PACKET_KEEPALIVE);
SendMessage(g_hStatusBar, SB_SETTEXT, MAKEWORD(2, 0), (LPARAM)_TEXT("Check Activity"));
}
break;
}
case _ID_TIMER_CONNECTSERVER:
{
if (g_csock == INVALID_SOCKET)
{
DWORD dwIP = 0;
int nPort = 0;
InsertLogMsg(IDS_APPLY_RECONNECT);
jRegGetKey(_SELGATE_SERVER_REGISTRY, _TEXT("RemoteIP"), (LPBYTE)&dwIP);
if (!jRegGetKey(_SELGATE_SERVER_REGISTRY, _TEXT("RemotePort"), (LPBYTE)&nPort))
nPort = 5000;
ConnectToServer(g_csock, &g_caddr, _IDM_CLIENTSOCK_MSG, NULL, dwIP, nPort, FD_CONNECT|FD_READ|FD_CLOSE);
}
break;
}
}
}
void LoadCharacterRecords()
{
InsertLogMsg(IDS_LOADACCOUNTRECORDS);
CRecordset *pRec = GetDBManager()->CreateRecordset();
if ( pRec->Execute( "SELECT * FROM TBL_GAMEGATEINFO" ) )
{
GAMESERVERINFO *pServerInfo;
while ( pRec->Fetch() )
{
pServerInfo = new GAMESERVERINFO;
if ( !pServerInfo )
break;
pServerInfo->index = atoi( pRec->Get( "FLD_SERVERIDX" ) );
strcpy( pServerInfo->name, pRec->Get( "FLD_SERVERNAME" ) );
strcpy( pServerInfo->ip, pRec->Get( "FLD_SERVERIP" ) );
pServerInfo->connCnt = 0;
g_xGameServerList.AddNewNode( pServerInfo );
}
}
GetDBManager()->DestroyRecordset( pRec );
}
UINT WINAPI LoadAccountRecords(LPVOID lpParameter)
{
InsertLogMsg(IDS_LOADACCOUNTRECORDS);
CRecordset *pRec = GetDBManager()->CreateRecordset();
pRec->Execute( "UPDATE TBL_ACCOUNT SET FLD_CERTIFICATION=0 WHERE FLD_CERTIFICATION >= 30" );
GetDBManager()->DestroyRecordset( pRec );
// ----------------------------------------------------------------------------------------
GAMESERVERINFO *pServerInfo;
pRec = GetDBManager()->CreateRecordset();
if ( pRec->Execute( "SELECT * FROM TBL_SERVERINFO" ) )
{
while ( pRec->Fetch() )
{
pServerInfo = new GAMESERVERINFO;
if ( !pServerInfo )
break;
pServerInfo->index = atoi( pRec->Get( "FLD_SERVERIDX" ) );
strcpy( pServerInfo->name, pRec->Get( "FLD_SERVERNAME" ) );
strcpy( pServerInfo->ip, pRec->Get( "FLD_SERVERIP" ) );
pServerInfo->connCnt = 0;
g_xGameServerList.AddNewNode( pServerInfo );
}
}
GetDBManager()->DestroyRecordset( pRec );
char szTmp[64];
for ( PLISTNODE pNode = g_xGameServerList.GetHead(); pNode; pNode = g_xGameServerList.GetNext( pNode ) )
{
pServerInfo = g_xGameServerList.GetData( pNode );
sprintf( szTmp, "%d,%s,", pServerInfo->index, pServerInfo->name );
strcat( g_szServerList, szTmp );
}
// ----------------------------------------------------------------------------------------
InitServerThreadForMsg();
if (InitServerSocket(g_gcSock, &g_gcAddr, _IDM_GATECOMMSOCK_MSG, 5500, 1))
SwitchMenuItem(TRUE);
return 0L;
}
BOOL CWHAbusive::LoadAbusiveList()
{
FILE *stream = fopen("Abusive.txt", "r");
if (stream)
{
while(!feof(stream))
{
fscanf(stream, "%s", m_szAbusiveList[m_nCount]);
m_nCount++;
}
fclose(stream);
InsertLogMsgParam(IDS_LOAD_ABUSIVE, &m_nCount, LOGPARAM_INT);
return TRUE;
}
else
InsertLogMsg(IDS_LOADFAIL_ABUSIVE);
return FALSE;
}
LPARAM OnClientSockMsg(WPARAM wParam, LPARAM lParam)
{
switch (WSAGETSELECTEVENT(lParam))
{
case FD_CONNECT:
{
if (CheckSocketError(lParam))
{
if (InitServerThreadForMsg())
{
g_nRemainBuffLen = 0;
KillTimer(g_hMainWnd, _ID_TIMER_CONNECTSERVER);
SetTimer(g_hMainWnd, _ID_TIMER_KEEPALIVE, 50000, (TIMERPROC)OnTimerProc);
// SetTimer(g_hMainWnd, _ID_TIMER_KEEPALIVE, 1000, (TIMERPROC)OnTimerProc);
InsertLogMsg(IDS_CONNECT_LOGINSERVER);
SendMessage(g_hStatusBar, SB_SETTEXT, MAKEWORD(1, 0), (LPARAM)_TEXT("Connected"));
//
UINT dwThreadIDForMsg = 0;
unsigned long hThreadForMsg = 0;
g_ClientIoEvent = WSACreateEvent();
//hThreadForMsg = _beginthreadex(NULL, 0, ClientWorkerThread, NULL, 0, &dwThreadIDForMsg);
}
}
else
{
closesocket(g_csock);
g_csock = INVALID_SOCKET;
SetTimer(g_hMainWnd, _ID_TIMER_CONNECTSERVER, 10000, (TIMERPROC)OnTimerProc);
}
break;
}
/* case FD_CLOSE:
{
closesocket(g_csock);
g_csock = INVALID_SOCKET;
KillTimer(g_hMainWnd, _ID_TIMER_KEEPALIVE);
SetTimer(g_hMainWnd, _ID_TIMER_CONNECTSERVER, 10000, (TIMERPROC)OnTimerProc);
InsertLogMsg(IDS_DISCONNECT_LOGINSERVER);
SendMessage(g_hStatusBar, SB_SETTEXT, MAKEWORD(1, 0), (LPARAM)_TEXT("Not Connected"));
break;
}
case FD_READ:
{
char szPacket[1024];
int nRecv = recv((SOCKET)wParam, szPacket, sizeof(szPacket), 0);
szPacket[nRecv] = '\0';
ProcReceiveBuffer(szPacket, nRecv);
break;
}
*/ }
return 0L;
}
DWORD WINAPI ServerWorkerThread(LPVOID CompletionPortID)
{
DWORD dwBytesTransferred;
CServerInfo* pServerInfo;
LPOVERLAPPED lpOverlapped;
DWORD dwFlags;
DWORD dwRecvBytes;
char szBuff[DATA_BUFSIZE];
int nBuffLen;
char *pszFirst, *pszEnd, *pszDivide;
LONG lValid;
WORD w1, w2;
char szCC[32];
int nPos;
while (TRUE)
{
GetQueuedCompletionStatus((HANDLE)CompletionPortID, &dwBytesTransferred, (LPDWORD)&pServerInfo, (LPOVERLAPPED *)&lpOverlapped, INFINITE);
if (g_fTerminated) return 0L;
if (dwBytesTransferred == 0)
{
closesocket(pServerInfo->m_sock);
if (pServerInfo) GlobalFree(pServerInfo);
UpdateStatusBarSession(FALSE);
continue;
}
if (pServerInfo->nOvFlag == OVERLAPPED_RECV)
{
if (pServerInfo->nRemainBuffLen)
{
memmove(szBuff, pServerInfo->RemainBuff, pServerInfo->nRemainBuffLen); // Copy previous remain data in szBuff
memmove(&szBuff[pServerInfo->nRemainBuffLen], pServerInfo->Buffer, dwBytesTransferred + 1); // Append new received data in szBuff
nBuffLen = pServerInfo->nRemainBuffLen + dwBytesTransferred;
pszEnd = &szBuff[0];
}
else
{
pszEnd = &pServerInfo->Buffer[0];
nBuffLen = dwBytesTransferred;
}
while (nBuffLen)
{
if ((pszFirst = (char *)memchr(pszEnd, '#', nBuffLen)) && (pszEnd = (char *)memchr(pszFirst, '!', nBuffLen)))
{
*pszEnd++ = '\0';
if (pszDivide = (char *)memchr(pszFirst, '/', pszEnd - pszFirst))
{
*pszDivide++ = '\0';
_LPTSENDBUFF lpSendUserData = new _TSENDBUFF;
if (lpSendUserData)
{
lpSendUserData->nCertification = AnsiStrToVal(pszFirst + 1);
w1 = lpSendUserData->nCertification ^ 0xAA;
w2 = memlen(pszDivide) - 1;
lValid = MAKELONG(w1, w2);
nPos = fnEncode6BitBufA((unsigned char *)&lValid, szCC, sizeof(LONG), sizeof(szCC));
szCC[nPos] = '\0';
if (memcmp((pszEnd - nPos - 1), szCC, nPos) == 0)
{
fnDecodeMessageA(&lpSendUserData->DefMsg, pszDivide);
*(pszEnd - nPos - 1) = '\0';
if (lpSendUserData->DefMsg.wIdent >= 100 && lpSendUserData->DefMsg.wIdent <= 200)
{
lpSendUserData->pServerInfo = pServerInfo;
switch (lpSendUserData->DefMsg.wIdent)
{
case DB_MAKEITEMRCD2:
{
lpSendUserData->lpbtAddData = new BYTE[sizeof(_TMAKEITEMRCD)];
fnDecode6BitBufA((pszDivide + DEFBLOCKSIZE), (char *)lpSendUserData->lpbtAddData, sizeof(_TMAKEITEMRCD));
lpSendUserData->lpbtAddData2 = NULL;
break;
}
default:
{
nPos = fnDecode6BitBufA((pszDivide + DEFBLOCKSIZE), (char *)&lpSendUserData->HumanLoad, sizeof(lpSendUserData->HumanLoad));
switch (lpSendUserData->DefMsg.wIdent)
{
case DB_MAKEITEMRCD:
{
lpSendUserData->lpbtAddData = new BYTE[sizeof(_TMAKEITEMRCD)];
fnDecode6BitBufA((pszDivide + DEFBLOCKSIZE + 75), (char *)lpSendUserData->lpbtAddData, sizeof(_TMAKEITEMRCD));
lpSendUserData->lpbtAddData2 = NULL;
break;
}
case DB_SAVEHUMANRCD:
{
lpSendUserData->lpbtAddData = new BYTE[sizeof(_THUMANRCD)];
fnDecode6BitBufA((pszDivide + DEFBLOCKSIZE + 75), (char *)lpSendUserData->lpbtAddData, sizeof(_THUMANRCD));
int nRemainLen = (int)(pszEnd - pszFirst) - (DEFBLOCKSIZE + 75 + HUMANRCDBLOCKSIZE);
lpSendUserData->lpbtAddData2 = new BYTE[nRemainLen + 1];
memcpy(lpSendUserData->lpbtAddData2, (pszDivide + DEFBLOCKSIZE + 75 + HUMANRCDBLOCKSIZE), nRemainLen);
lpSendUserData->lpbtAddData2[nRemainLen] = '\0';
break;
}
default:
lpSendUserData->lpbtAddData = NULL;
lpSendUserData->lpbtAddData2 = NULL;
}
break;
}
}
g_DBMsgQ.PushQ((BYTE *)lpSendUserData);
}
else
g_ServerMsgQ.PushQ((BYTE *)lpSendUserData);
}
else
delete lpSendUserData;
}
}
nBuffLen -= (pszEnd - pszFirst);
}
else
break;
} // while
if (pszFirst && nBuffLen)
{
memmove(pServerInfo->RemainBuff, pszFirst, nBuffLen);
pServerInfo->nRemainBuffLen = nBuffLen;
#ifdef _DEBUG
_RPT2(_CRT_WARN, "Remain Packet : %d, %s\n", nBuffLen, pszFirst);
#endif
}
else
pServerInfo->nRemainBuffLen = 0;
// Set next overlapped Process
dwFlags = 0;
ZeroMemory(&(pServerInfo->Overlapped), sizeof(OVERLAPPED));
pServerInfo->DataBuf.len = DATA_BUFSIZE;
pServerInfo->DataBuf.buf = pServerInfo->Buffer;
pServerInfo->nOvFlag = OVERLAPPED_RECV;
if (WSARecv(pServerInfo->m_sock, &(pServerInfo->DataBuf), 1, &dwRecvBytes, &dwFlags, &(pServerInfo->Overlapped), NULL) == SOCKET_ERROR)
{
if (WSAGetLastError() != ERROR_IO_PENDING)
{
InsertLogMsg(_T("WSARecv() failed"));
// CloseSession(pServerInfo);
continue;
}
}
} // if (OVERLAPPED_RECV)
}
return 0;
}
DWORD WINAPI ServerWorkerThread(LPVOID CompletionPortID)
{
DWORD dwBytesTransferred = 0;
CSessionInfo* pSessionInfo = NULL;
_LPTCOMPLETIONPORT lpPerIoData = NULL;
char szPacket[DATA_BUFSIZE * 2];
char szMsg[32];
char *pszPos;
while (TRUE)
{
if ( GetQueuedCompletionStatus(
(HANDLE)CompletionPortID,
&dwBytesTransferred,
(LPDWORD)&pSessionInfo,
(LPOVERLAPPED *)&lpPerIoData,
INFINITE) == 0)
{
if (g_fTerminated)
return 0;
if (pSessionInfo)
{
szMsg[0] = '%';
szMsg[1] = 'X';
char *pszPos = ValToAnsiStr((int)pSessionInfo->sock, &szMsg[2]);
*pszPos++ = '$';
*pszPos = '\0';
SendExToServer(szMsg);
g_xSessionList.RemoveNodeByData(pSessionInfo);
closesocket(pSessionInfo->sock);
pSessionInfo->sock = INVALID_SOCKET;
UpdateStatusBar(FALSE);
GlobalFree(pSessionInfo);
}
continue;
}
if (g_fTerminated)
return 0;
if (dwBytesTransferred == 0)
{
szMsg[0] = '%';
szMsg[1] = 'X';
char *pszPos = ValToAnsiStr((int)pSessionInfo->sock, &szMsg[2]);
*pszPos++ = '$';
*pszPos = '\0';
SendExToServer(szMsg);
g_xSessionList.RemoveNodeByData(pSessionInfo);
closesocket(pSessionInfo->sock);
pSessionInfo->sock = INVALID_SOCKET;
UpdateStatusBar(FALSE);
GlobalFree(pSessionInfo);
continue;
}
// ORZ:
pSessionInfo->bufLen += dwBytesTransferred;
while ( pSessionInfo->HasCompletionPacket() )
{
szPacket[0] = '%';
szPacket[1] = 'A';
pszPos = ValToAnsiStr( (int) pSessionInfo->sock, &szPacket[2] );
*pszPos++ = '/';
pszPos = pSessionInfo->ExtractPacket( pszPos );
*pszPos++ = '$';
*pszPos = '\0';
SendExToServer( szPacket );
}
// ORZ:
if ( pSessionInfo->Recv() == SOCKET_ERROR && WSAGetLastError() != ERROR_IO_PENDING )
{
InsertLogMsg(_TEXT("WSARecv() failed"));
CloseSession(pSessionInfo->sock);
continue;
}
}
return 0;
}
DWORD WINAPI ServerWorkerThread(LPVOID CompletionPortID)
{
DWORD dwBytesTransferred;
CGateInfo* pGateInfo;
LPOVERLAPPEDEX lpOverlapped;
_LPTMSGHEADER pMsgHeader;
char completionPacket[DATA_BUFSIZE];
while (TRUE)
{
GetQueuedCompletionStatus((HANDLE)CompletionPortID, &dwBytesTransferred, (LPDWORD)&pGateInfo, (LPOVERLAPPED *)&lpOverlapped, INFINITE);
if (g_fTerminated) return 0L;
if (dwBytesTransferred == 0)
{
if (g_xUserInfoList.GetCount())
{
PLISTNODE pListNode = g_xUserInfoList.GetHead();
while (pListNode)
{
CUserInfo *pUserInfo = g_xUserInfoList.GetData(pListNode);
if (pUserInfo->m_pGateInfo == pGateInfo)
{
pUserInfo->Lock();
pUserInfo->m_bEmpty = true;
pUserInfo->Unlock();
// °íÃÄ¾ß µÊ
if (pUserInfo->m_pxPlayerObject)
pUserInfo->m_pxPlayerObject->m_pMap->RemoveObject(pUserInfo->m_pxPlayerObject->m_nCurrX,
pUserInfo->m_pxPlayerObject->m_nCurrY,
OS_MOVINGOBJECT,
pUserInfo->m_pxPlayerObject);
pListNode = g_xUserInfoList.RemoveNode(pListNode);
UpdateStatusBarUsers(FALSE);
}
else
pListNode = g_xUserInfoList.GetNext(pListNode);
}
}
closesocket(pGateInfo->m_sock);
g_xGateList.RemoveNodeByData(pGateInfo);
if (pGateInfo) delete pGateInfo;
continue;
}
if (lpOverlapped->nOvFlag == OVERLAPPED_RECV)
{
static DWORD nLastTick = GetTickCount();
static DWORD nBytes = 0;
nBytes += dwBytesTransferred;
if ( GetTickCount() - nLastTick >= 1000)
{
TCHAR buf[256];
wsprintf( buf, _T("R: %d bytes/sec"), nBytes );
nLastTick = GetTickCount();
nBytes = 0;
SendMessage(g_hStatusBar, SB_SETTEXT, MAKEWORD(3, 0), (LPARAM)buf);
}
pGateInfo->OverlappedEx[0].bufLen += dwBytesTransferred;
while ( pGateInfo->HasCompletionPacket() )
{
*(pGateInfo->ExtractPacket( completionPacket )) = '\0';
pMsgHeader = (_LPTMSGHEADER) completionPacket;
if ( pMsgHeader->nCode != 0xAA55AA55 )
continue;
switch ( pMsgHeader->wIdent )
{
case GM_OPEN:
{
pGateInfo->OpenNewUser( completionPacket );
break;
}
case GM_CLOSE:
{
CUserInfo *pUserInfo = &g_xUserInfoArr[ pMsgHeader->wUserListIndex ];
if (pUserInfo)
{
pUserInfo->m_btCurrentMode = USERMODE_LOGOFF;
g_xLoginOutUserInfo.AddNewNode(pUserInfo);
}
break;
}
case GM_CHECKCLIENT:
{
pGateInfo->SendGateCheck();
break;
}
case GM_RECEIVE_OK:
{
break;
}
case GM_DATA:
{
CUserInfo *pUserInfo = &g_xUserInfoArr[ pMsgHeader->wUserListIndex ];
if ( !pUserInfo->IsEmpty() )
{
if ( pUserInfo->m_btCurrentMode == USERMODE_PLAYGAME)
{
if ( pMsgHeader->nSocket == pUserInfo->m_sock )
pUserInfo->ProcessUserMessage(completionPacket + sizeof( _TMSGHEADER ) );
}
else
{
pUserInfo->Lock();
pUserInfo->DoClientCertification( completionPacket + sizeof( _TMSGHEADER ) + sizeof(_TDEFAULTMESSAGE) );
pUserInfo->Unlock();
}
}
break;
}
} // switch
} // while
if ( pGateInfo->Recv() == SOCKET_ERROR && WSAGetLastError() != ERROR_IO_PENDING )
InsertLogMsg( _T("WSARecv() failed") );
} // if (OVERLAPPED_RECV)
else if (lpOverlapped->nOvFlag == OVERLAPPED_SEND)
{
static DWORD nLastTick = GetTickCount();
static DWORD nBytes = 0;
nBytes += dwBytesTransferred;
if ( GetTickCount() - nLastTick >= 1000)
{
TCHAR buf[256];
wsprintf( buf, _T("S: %d bytes/sec"), nBytes );
nLastTick = GetTickCount();
nBytes = 0;
SendMessage(g_hStatusBar, SB_SETTEXT, MAKEWORD(4, 0), (LPARAM)buf);
}
/* fprintf( fp, "sended\r\n" );
pGateInfo->m_fDoSending = FALSE;
if ( pGateInfo->Send( NULL ) == SOCKET_ERROR && WSAGetLastError() != ERROR_IO_PENDING )
InsertLogMsg( _T("WSASend() failed") ); */
}
}
return 0;
}
DWORD WINAPI ServerWorkerThread(LPVOID CompletionPortID)
{
DWORD dwBytesTransferred = 0;
CGateInfo* pGateInfo = NULL;
LPOVERLAPPED lpOverlapped = NULL;
char szTmp[DATA_BUFSIZE];
while (TRUE)
{
if ( GetQueuedCompletionStatus(
(HANDLE)CompletionPortID,
&dwBytesTransferred,
(LPDWORD)&pGateInfo,
(LPOVERLAPPED *)&lpOverlapped,
INFINITE) == 0 )
{
return 0;
}
if (g_fTerminated)
{
PLISTNODE pListNode;
if (g_xGateList.GetCount())
{
pListNode = g_xGateList.GetHead();
while (pListNode)
{
pGateInfo = g_xGateList.GetData(pListNode);
if (pGateInfo)
pGateInfo->Close();
delete pGateInfo;
pGateInfo = NULL;
pListNode = g_xGateList.RemoveNode(pListNode);
}
}
return 0;
}
if ( dwBytesTransferred == 0 )
{
pGateInfo->Close();
continue;
}
pGateInfo->bufLen += dwBytesTransferred;
while ( pGateInfo->HasCompletionPacket() )
{
*(pGateInfo->ExtractPacket( szTmp ) - 1) = '\0';
switch ( szTmp[1] )
{
case '-':
pGateInfo->SendKeepAlivePacket();
break;
case 'A':
pGateInfo->ReceiveSendUser(&szTmp[2]);
break;
case 'O':
pGateInfo->ReceiveOpenUser(&szTmp[2]);
break;
case 'X':
pGateInfo->ReceiveCloseUser(&szTmp[2]);
break;
case 'S':
pGateInfo->ReceiveServerMsg(&szTmp[2]);
break;
case 'M':
pGateInfo->MakeNewUser(&szTmp[2]);
break;
}
}
if ( pGateInfo->Recv() == SOCKET_ERROR && WSAGetLastError() != ERROR_IO_PENDING )
{
InsertLogMsg(_TEXT("WSARecv() failed"));
continue;
}
}
return 0;
}
LPARAM OnClientSockMsg(WPARAM wParam, LPARAM lParam)
{
switch (WSAGETSELECTEVENT(lParam))
{
case FD_CONNECT:
{
if (CheckSocketError(lParam))
{
InsertLogMsg(IDS_CONNECT_DBSERVER);
KillTimer(g_hMainWnd, _ID_TIMER_CONNECTSERVER);
UINT dwThreadIDForMsg = 0;
unsigned long hThreadForMsg = 0;
// SetTimer(g_hMainWnd, _ID_TIMER_PROCESSUSERHUMAN, 1, (TIMERPROC)OnProcessUserHuman);
if (hThreadForMsg = _beginthreadex(NULL, 0, ProcessLogin, NULL, 0, &dwThreadIDForMsg))
{
// SetThreadPriority((HANDLE)hThreadForMsg, THREAD_PRIORITY_HIGHEST);
hThreadForMsg = _beginthreadex(NULL, 0, ProcessUserHuman, NULL, 0, &dwThreadIDForMsg);
hThreadForMsg = _beginthreadex(NULL, 0, ProcessMonster, NULL, 0, &dwThreadIDForMsg);
hThreadForMsg = _beginthreadex(NULL, 0, ProcessNPC, NULL, 0, &dwThreadIDForMsg);
}
int nPort;
if (!jRegGetKey(_GAME_SERVER_REGISTRY, _TEXT("LocalPort"), (LPBYTE)&nPort))
nPort = 5000;
InitServerSocket(g_ssock, &g_saddr, _IDM_SERVERSOCK_MSG, nPort, 1);
InsertLogMsg(IDS_STARTSERVICE);
SendMessage(g_hStatusBar, SB_SETTEXT, MAKEWORD(0, 0), (LPARAM)_T("Ready"));
}
else
{
closesocket(g_csock);
g_csock = INVALID_SOCKET;
SetTimer(g_hMainWnd, _ID_TIMER_CONNECTSERVER, 10000, (TIMERPROC)OnTimerProc);
}
break;
}
case FD_CLOSE:
{
closesocket(g_csock);
g_csock = INVALID_SOCKET;
InsertLogMsg(IDS_DISCONNECT_DBSERVER);
break;
}
case FD_READ:
{
char szPacket[8096];
int nRecv = recv((SOCKET)wParam, szPacket, sizeof(szPacket), 0);
#ifdef _DEBUG
_RPT1(_CRT_WARN, "ClientSockMsg[FD_READ]:%d\n", nRecv);
#endif
szPacket[nRecv] = '\0';
ProcReceiveBuffer(szPacket, nRecv);
break;
}
}
return 0L;
}
void OnCommand(WPARAM wParam, LPARAM lParam)
{
switch (LOWORD(wParam))
{
case IDM_STARTSERVICE:
{
//开始服务器
DWORD dwIP = 0;
int nPort = 0;
g_fTerminated = FALSE;
g_pRandom.Random_Seed(0);
//初始化等待ip
ENGINE_COMPONENT_INFO info = g_SeverConfig.getLoginGateInfo();
nPort = info.extport?info.extport:7000;
//初始化完成端口
InitServerSocket(g_ssock, &g_saddr, _IDM_SERVERSOCK_MSG, nPort, FD_ACCEPT);
//初始化等待ip
ENGINE_COMPONENT_INFO loginsrvinfo = g_SeverConfig.getLoginSrvInfo();
nPort = loginsrvinfo.intport?loginsrvinfo.intport:5500;
//连接loginsrv
ConnectToServer(g_csock, &g_caddr, _IDM_CLIENTSOCK_MSG, loginsrvinfo.intip.c_str(), dwIP, nPort, FD_CONNECT|FD_READ|FD_CLOSE);
HMENU hMainMenu = GetMenu(g_hMainWnd);
HMENU hMenu = GetSubMenu(hMainMenu, 0);
EnableMenuItem(hMenu, IDM_STARTSERVICE, MF_GRAYED|MF_BYCOMMAND);
EnableMenuItem(hMenu, IDM_STOPSERVICE, MF_ENABLED|MF_BYCOMMAND);
SendMessage(g_hToolBar, TB_SETSTATE, (WPARAM)IDM_STARTSERVICE, (LPARAM)MAKELONG(TBSTATE_INDETERMINATE, 0));
SendMessage(g_hToolBar, TB_SETSTATE, (WPARAM)IDM_STOPSERVICE, (LPARAM)MAKELONG(TBSTATE_ENABLED, 0));
InsertLogMsg(IDS_STARTSERVICE);
SendMessage(g_hStatusBar, SB_SETTEXT, MAKEWORD(0, 0), (LPARAM)_TEXT("Ready"));
return;
}
case IDM_STOPSERVICE:
{
g_fTerminated = TRUE;
/* if (g_hAcceptThread != INVALID_HANDLE_VALUE)
{
TerminateThread(g_hAcceptThread, 0);
WaitForSingleObject(g_hAcceptThread, INFINITE);
CloseHandle(g_hAcceptThread);
g_hAcceptThread = INVALID_HANDLE_VALUE;
}
if (g_hMsgThread != INVALID_HANDLE_VALUE)
{
TerminateThread(g_hMsgThread, 0);
WaitForSingleObject(g_hMsgThread, INFINITE);
CloseHandle(g_hMsgThread);
g_hMsgThread = INVALID_HANDLE_VALUE;
}
*/
ClearSocket(g_ssock);
ClearSocket(g_csock);
CloseHandle(g_hIOCP);
HMENU hMainMenu = GetMenu(g_hMainWnd);
HMENU hMenu = GetSubMenu(hMainMenu, 0);
EnableMenuItem(hMenu, IDM_STARTSERVICE, MF_ENABLED|MF_BYCOMMAND);
EnableMenuItem(hMenu, IDM_STOPSERVICE, MF_GRAYED|MF_BYCOMMAND);
SendMessage(g_hToolBar, TB_SETSTATE, (WPARAM)IDM_STARTSERVICE, (LPARAM)MAKELONG(TBSTATE_ENABLED, 0));
SendMessage(g_hToolBar, TB_SETSTATE, (WPARAM)IDM_STOPSERVICE, (LPARAM)MAKELONG(TBSTATE_INDETERMINATE, 0));
InsertLogMsg(IDS_STOPSERVICE);
SendMessage(g_hStatusBar, SB_SETTEXT, MAKEWORD(0, 0), (LPARAM)_TEXT("Not Ready"));
return;
}
// ORZ:
case IDM_FONTCOLOR:
SetFontColor();
return;
case IDM_BACKCOLOR:
SetBackColor();
return;
case IDM_CONFIG:
{
DialogBox(g_hInst, MAKEINTRESOURCE(IDD_CONFIGDLG), g_hMainWnd, (DLGPROC)ConfigDlgFunc);
return;
}
}
}
LPARAM OnClientSockMsg(WPARAM wParam, LPARAM lParam)
{
switch (WSAGETSELECTEVENT(lParam))
{
case FD_CONNECT:
{
DWORD dwThreadIDForMsg = 0;
if (CheckSocketError(lParam))
{
dwThreadIDForMsg = 0;
if (InitThread(ThreadFuncForMsg))
{
KillTimer(g_hMainWnd, _ID_TIMER_CONNECTSERVER);
SetTimer(g_hMainWnd, _ID_TIMER_KEEPALIVE, 5000, (TIMERPROC)OnTimerProc);
InsertLogMsg(IDS_CONNECT_LOGINSERVER);
SendMessage(g_hStatusBar, SB_SETTEXT, MAKEWORD(1, 0), (LPARAM)_TEXT("Connected"));
}
}
else
{
closesocket(g_csock);
g_csock = INVALID_SOCKET;
SetTimer(g_hMainWnd, _ID_TIMER_CONNECTSERVER, 10000, (TIMERPROC)OnTimerProc);
}
break;
}
case FD_CLOSE:
{
closesocket(g_csock);
g_csock = INVALID_SOCKET;
OnCommand(IDM_STOPSERVICE, 0);
break;
}
case FD_READ:
{
int nSocket = 0;
char *pszFirst = NULL, *pszEnd = NULL;
UINT nRecv = 0;
ioctlsocket((SOCKET)wParam, FIONREAD, (u_long *)&nRecv);
if (nRecv)
{
char *pszPacket = new char[nRecv + 1];
nRecv = recv((SOCKET)wParam, pszPacket, nRecv, 0);
pszPacket[nRecv] = '\0';
if (!(g_xMsgQueue.PushQ((BYTE *)pszPacket)))
InsertLogMsg(_TEXT("[INFO] Not enough queue(g_xMsgQueue) buffer."));
}
break;
}
}
return 0L;
}
