开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
main.cpp
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：14k
源码类别：

模拟服务器

开发平台：

C/C++

main.cpp：源码内容
  1. #include "stdlib.h"
  2. #include "stdio.h"
  3. #include "KStdAfx.h"
  4. #include "S3PDBSocketPool.h"
  5. #include "S3PDBConnectionPool.h"
  6. #include "GlobalFun.h"
  8. #include <process.h>
  10. #include "../../../Headers/ServerPort.h"
  12. #include "resource.h"
  14. #include <initguid.h>  // Include only once in your application
  15. #define _WIN32_DCOM
  16. #include "../../Multiserver/Heaven/Interface/IServer.h"
  18. #include "adoid.h"     // ADO GUID's
  19. #include "adoint.h"
  21. #include "time.h"
  23. #include "LogFile.h"
  26. const char log_directory[] = "relayserver_log";
  27. const size_t log_threshold = 1024 * 1024;
  29. static CLogFile gs_LogFile;
  32. typedef HRESULT ( __stdcall * pfnCreateServerInterface )(
  33. REFIID riid,
  34. void **ppv
  35. );
  37. void __stdcall ServerEventNotify(
  38. LPVOID lpParam,
  39. const unsigned long &ulnID,
  40. const unsigned long &ulnEventType )
  41. {
  42. S3PDBSocketPool *pSocketPool = (S3PDBSocketPool *)lpParam;
  43. switch( ulnEventType )
  44. {
  45. case enumClientConnectCreate:
  46. pSocketPool->AddUserClientID(ulnID);
  47. break;
  48. case enumClientConnectClose:
  49. pSocketPool->RemoveUserClientID(ulnID);
  50. break;
  51. }
  52. }
  55. static inline sLogProgram(BOOL bEnter)
  56. {
  57. SYSTEMTIME systm;
  58. ::GetLocalTime(&systm);
  59. TCHAR buff[256];
  60. int len = 0;
  62. if (bEnter)
  63. len = _stprintf(buff, "rn*rn***** S3RelayServer Start (@ %04d/%02d/%02d %02d:%02d:%02d.%03d) >>>>>rn*rnrn",
  64. systm.wYear, systm.wMonth, systm.wDay, systm.wHour, systm.wMinute, systm.wSecond, systm.wMilliseconds);
  65. else
  66. len = _stprintf(buff, "rn*rn***** S3RelayServer Stop (@ %04d/%02d/%02d %02d:%02d:%02d.%03d) <<<<<rn*rnrn",
  67. systm.wYear, systm.wMonth, systm.wDay, systm.wHour, systm.wMinute, systm.wSecond, systm.wMilliseconds);
  69. gs_LogFile.TraceLog(buff, len * sizeof(TCHAR));
  70. }
  73. ATOM RegisterSysClass(HINSTANCE hInstance);
  74. BOOL InitInstance(HINSTANCE hInstance, int nCmdShow, int nLogTime);
  75. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
  76. char g_szWindowClass[MAX_PATH];
  78. int APIENTRY WinMain(HINSTANCE hInstance,
  79.                      HINSTANCE hPrevInstance,
  80.                      LPSTR     lpCmdLine,
  81.                      int       nCmdShow)
  82. {
  83. TCHAR szExePath[MAX_PATH + 1];
  84. KPIGetExePath( szExePath, MAX_PATH );
  86. TCHAR szLogDir[MAX_PATH + 1];
  87. _tcscpy(szLogDir, szExePath);
  88. _tcscat(szLogDir, log_directory);
  89. ::CreateDirectory(szLogDir, NULL);
  90. if (!gs_LogFile.Initialize(szLogDir, log_threshold))
  91. {
  92. ::MessageBox(NULL, "Initializing LogFile fail", "error", MB_OK|MB_ICONERROR);
  93. return FALSE;
  94. }
  95. sLogProgram(TRUE);
  98. TCHAR szINIPath[MAX_PATH + 1];
  99. _tcscpy(szINIPath, szExePath);
  100. _tcscat(szINIPath, "relay_setup.ini");
  101. TCHAR szPort[32];
  102. sprintf(szPort, "%d", RELAY_ROUTE_PORT);
  103. DWORD dwResult = KPIGetPrivateProfileString("Local",
  104. "port",
  105. szPort,
  106. szPort,
  107. 31,
  108. szINIPath);
  109. short siPort = atoi(szPort);
  110. dwResult = KPIGetPrivateProfileString("Local",
  111. "maxconnect",
  112. "10",
  113. szPort,
  114. 31,
  115. szINIPath);
  116. int snMaxPlayerCount = atoi(szPort);
  117. dwResult = KPIGetPrivateProfileString("Local",
  118. "precision",
  119. "1",
  120. szPort,
  121. 31,
  122. szINIPath);
  123. int snPrecision = atoi(szPort);
  124. dwResult = KPIGetPrivateProfileString("Local",
  125. "maxbuffer",
  126. "15",
  127. szPort,
  128. 31,
  129. szINIPath);
  130. int snMaxBuffer = atoi(szPort);
  131. dwResult = KPIGetPrivateProfileString("Local",
  132. "sizebuffer",
  133. "1048576",
  134. szPort,
  135. 31,
  136. szINIPath);
  137. int snBufferSize = atoi(szPort);
  139. dwResult = KPIGetPrivateProfileString("Local",
  140. "timelog",
  141. "3000",
  142. szPort,
  143. 31,
  144. szINIPath);
  145. int nTimelog = atoi(szPort);
  147. IServer *pServer = NULL;
  149. HMODULE hModule = ::LoadLibrary("heaven.dll");
  151. if (hModule)
  152. {
  153. pfnCreateServerInterface pFactroyFun = (pfnCreateServerInterface)GetProcAddress(hModule, "CreateInterface");
  155. IServerFactory *pServerFactory = NULL;
  157. if (SUCCEEDED( pFactroyFun( IID_IServerFactory, reinterpret_cast< void ** >(&pServerFactory ))))
  158. {
  159. pServerFactory->SetEnvironment(snMaxPlayerCount, snPrecision, snMaxBuffer, snBufferSize);
  161. pServerFactory->CreateServerInterface(IID_IIOCPServer, reinterpret_cast< void ** >(&pServer));
  163. pServerFactory->Release();
  164. }
  165. }
  167. _tcscpy(szINIPath, szExePath);
  168. _tcscat(szINIPath, "DataBase.ini");
  170. dwResult = KPIGetPrivateProfileString("Local",
  171. "DBConnects",
  172. "5",
  173. szPort,
  174. 31,
  175. szINIPath);
  176. int nDBConns = atoi(szPort);
  177. S3PDBConnectionPool * pConnectPool = S3PDBConnectionPool::Instance();
  178. S3PDBSocketPool *pSocketPool = S3PDBSocketPool::Instance();
  180. if (pServer == NULL)
  181. {
  182. ::MessageBox(NULL, "heaven Error!", "error", MB_OK | MB_ICONERROR);
  183. goto Exit0;
  184. }
  185. if (!pConnectPool->Init(szINIPath, "account", nDBConns))
  186. {
  187. ::MessageBox(NULL, "Connect DB Error!", "error", MB_OK | MB_ICONERROR);
  188. goto Exit0;
  189. }
  191. pSocketPool->Start(pServer);
  193. pServer->Startup();
  195. pServer->RegisterMsgFilter((LPVOID)pSocketPool, ServerEventNotify);
  196. pServer->OpenService(INADDR_ANY, siPort);
  198. MSG msg;
  199. LoadString(hInstance, IDC_S3RELAYSYS, g_szWindowClass, MAX_PATH);
  201. RegisterSysClass(hInstance);
  203. // Perform application initialization:
  204. if (InitInstance(hInstance, nCmdShow, nTimelog)) 
  205. {
  206. //hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_S3RELAY);
  208. // Main message loop:
  209. while (GetMessage(&msg, NULL, 0, 0)) 
  210. {
  211. //if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
  212. {
  213. TranslateMessage(&msg);
  214. DispatchMessage(&msg);
  215. }
  216. }
  217. }
  219. pSocketPool->Stop();
  221. Exit0:
  222. S3PDBSocketPool::ReleaseInstance();
  223. S3PDBConnectionPool::ReleaseInstance();
  225. if (pServer)
  226. {
  227. pServer->CloseService();
  228. pServer->Cleanup();
  229. pServer->Release();
  230. }
  232. if (hModule)
  233. ::FreeLibrary(hModule);
  235. sLogProgram(FALSE);
  236. gs_LogFile.Uninitialize();
  238. return 0;
  239. }
  241. //  FUNCTION: RegisterSysClass()
  242. //
  243. //  PURPOSE: Registers the window class.
  244. //
  245. //  COMMENTS:
  246. //
  247. //    This function and its usage is only necessary if you want this code
  248. //    to be compatible with Win32 systems prior to the 'RegisterClassEx'
  249. //    function that was added to Windows 95. It is important to call this function
  250. //    so that the application will get 'well formed' small icons associated
  251. //    with it.
  252. //
  253. ATOM RegisterSysClass(HINSTANCE hInstance)
  254. {
  255. WNDCLASSEX wcex;
  257. wcex.cbSize = sizeof(WNDCLASSEX); 
  259. wcex.style = CS_HREDRAW | CS_VREDRAW;
  260. wcex.lpfnWndProc = (WNDPROC)WndProc;
  261. wcex.cbClsExtra = 0;
  262. wcex.cbWndExtra = 0;
  263. wcex.hInstance = hInstance;
  264. wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_MAIN);
  265. wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
  266. wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
  267. wcex.lpszMenuName = (LPCSTR)IDC_S3RELAYSYS;
  268. wcex.lpszClassName = g_szWindowClass;
  269. wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
  271. return RegisterClassEx(&wcex);
  272. }
  274. class TwoFixBuffer
  275. {
  276. protected:
  277. #define MAX_BUFFER_LEN 1024 * 1024
  278. struct CSBuffer
  279. {
  280. BYTE buff[MAX_BUFFER_LEN + sizeof(DWORD)];
  281. DWORD nInfoStart;
  282. };
  284. CSBuffer m_RW_Buffer[2];
  285. int m_nRead;
  286. int m_nWrite;
  287. CRITICAL_SECTION m_switchsect;
  288. BOOL HasWriteInfo()
  289. {
  290. return m_RW_Buffer[m_nWrite].nInfoStart > 0;
  291. }
  292. BOOL HasReadInfo()
  293. {
  294. DWORD* pLen = (DWORD*)(m_RW_Buffer[m_nRead].buff + m_RW_Buffer[m_nRead].nInfoStart);
  295. return  *pLen != 0;
  296. }
  298. public:
  299. TwoFixBuffer()
  300. {
  301. ::InitializeCriticalSection(&m_switchsect);
  302. for (int n = 0; n < 2; n++)
  303. {
  304. memset(m_RW_Buffer[n].buff, 0, MAX_BUFFER_LEN + sizeof(DWORD));
  305. m_RW_Buffer[n].nInfoStart = 0;
  306. }
  307. m_nRead = 0;
  308. m_nWrite = 1;
  309. }
  310. ~TwoFixBuffer()
  311. {
  312. ::LeaveCriticalSection(&m_switchsect);
  313. ::DeleteCriticalSection(&m_switchsect);
  314. }
  316. //WriteInfo可以多个线程使用
  317. //其中nLen指内存长度
  318. BOOL WriteInfo(BYTE* szInfo, DWORD nLen)
  319. {
  320. if (nLen <= 0 || szInfo == NULL)
  321. return FALSE;
  322. ::EnterCriticalSection(&m_switchsect);
  323. BOOL bCanAdd = FALSE;
  324. DWORD nMemLen = nLen + sizeof(DWORD);
  325. DWORD nInfoStart = m_RW_Buffer[m_nWrite].nInfoStart;
  326. if (nInfoStart < MAX_BUFFER_LEN - nMemLen)
  327. {
  328. memcpy(m_RW_Buffer[m_nWrite].buff + nInfoStart, &nLen, sizeof(DWORD));
  329. memcpy(m_RW_Buffer[m_nWrite].buff + nInfoStart + sizeof(DWORD), szInfo, nLen);
  330. m_RW_Buffer[m_nWrite].nInfoStart += nMemLen;
  331. bCanAdd = TRUE;
  332. DWORD* pLen = (DWORD*)(m_RW_Buffer[m_nWrite].buff + nInfoStart + nMemLen);
  333. *pLen = 0;
  334. }
  335. ::LeaveCriticalSection(&m_switchsect);
  336. return bCanAdd;
  337. }
  339. //ReadInfo只能一个线程访问
  340. BYTE* ReadInfo()
  341. {
  342. BYTE* pInfo = NULL;
  343. if (HasReadInfo())
  344. {
  345. pInfo = m_RW_Buffer[m_nRead].buff + m_RW_Buffer[m_nRead].nInfoStart;
  346. DWORD nLen = *((DWORD*)pInfo);
  347. m_RW_Buffer[m_nRead].nInfoStart += nLen + sizeof(DWORD);
  348. }
  349. return pInfo;
  350. }
  351. void SwitchReadWrite()
  352. {
  353. if (!HasReadInfo() && HasWriteInfo())
  354. {
  355. ::EnterCriticalSection(&m_switchsect);
  356. //first clear read buffer
  357. m_RW_Buffer[m_nRead].nInfoStart = 0;
  358. DWORD* pLen = (DWORD*)m_RW_Buffer[m_nRead].buff;
  359. *pLen = 0;
  360. //switch read buffer and write buffer
  361. DWORD nTemp = m_nRead;
  362. m_nRead = m_nWrite;
  363. m_nWrite = nTemp;
  364. //read from head
  365. m_RW_Buffer[m_nRead].nInfoStart = 0;
  366. ::LeaveCriticalSection(&m_switchsect);
  367. }
  368. }
  369. };
  372. TwoFixBuffer g_TraceBuffer;
  373. HWND g_listwnd = NULL;
  374. long g_cnt = 0;
  377. int gTrace(LPCSTR fmt, ...)
  378. {
  379. if (g_listwnd == NULL)
  380. return -1;
  382. TCHAR tempbuff[256];
  384. g_cnt++;
  385. sprintf(tempbuff, "%d -- ", g_cnt);
  386. int n = strlen(tempbuff);
  388. va_list marker;
  389. va_start( marker, fmt );
  391. _vstprintf(tempbuff + n, fmt, marker);
  393. va_end( marker );
  395. n = strlen(tempbuff);
  397. g_TraceBuffer.WriteInfo((BYTE*)tempbuff, n + 1); //带0写入
  398. return 0;
  399. }
  401. int gTimeStamp(char* sDest, char* pTail)
  402. {
  403. assert(sDest);
  404. time_t curtm = ::time(NULL);
  405. struct tm* ptm = localtime(&curtm);
  406. return sprintf(sDest, "[%04d/%02d/%02d %02d:%02d:%02d]%s",
  407. ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec, pTail);
  408. }
  410. void gTraceLogFile(LPCTSTR pBuffer, long nLen)
  411. {
  412. if (!gs_LogFile.BeginBatch())
  413. return;
  415. char szTime[128];
  416. int nTime = gTimeStamp(szTime, " ");
  417. gs_LogFile.TraceLog(szTime, nTime);
  418. gs_LogFile.TraceLog(pBuffer, nLen);
  419. gs_LogFile.TraceLog(_T("rn"), 2 * sizeof(TCHAR));
  421. gs_LogFile.EndBatch();
  422. }
  424. void gClearTrace()
  425. {
  426. if (g_listwnd)
  427. ::SendMessage(g_listwnd, LB_RESETCONTENT, 0, 0);
  428. }
  430. void gShowTrace()
  431. {
  432. if (!g_listwnd)
  433. return;
  435. static BOOL bLastRead = FALSE;
  436. char* pBuff = NULL;
  437. DWORD* pMem = NULL;
  438. int nPercent = 0;
  439. int n1 = ::SendMessage(g_listwnd, LB_GETCOUNT, 0, 0);
  440. int n = n1;
  441. while (1)
  442. {
  443. pMem = (DWORD*)g_TraceBuffer.ReadInfo();
  444. if (pMem)
  445. {
  446. pBuff = (char*)(pMem + 1);
  448. if (n > 0 && n % 8100 == 0)
  449. {
  450. ::SendMessage(g_listwnd, LB_DELETESTRING, 0, NULL);
  451. n = 0;
  452. }
  454. if (::SendMessage(g_listwnd, LB_ADDSTRING, 0, (LPARAM)pBuff) >= 0)
  455. n++;
  457. gTraceLogFile(pBuff, (*pMem) - 1); //去0写文件
  458. }
  459. else
  460. break;
  461. }
  462. if (n != n1)
  463. {
  464. ::SendMessage(g_listwnd, LB_SETCURSEL, (WPARAM)n - 1, 0);
  465. }
  466. g_TraceBuffer.SwitchReadWrite();
  467. }
  469. HINSTANCE g_hInst = 0;
  470. int g_nShowTime = 0;
  472. BOOL InitInstance(HINSTANCE hInstance, int nCmdShow, int nLogTime)
  473. {
  474. HWND hWnd;
  475.  
  476. hWnd = CreateWindow(g_szWindowClass, g_szWindowClass, WS_OVERLAPPEDWINDOW,
  477.   CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
  479. if (!hWnd)
  480. {
  481.   return FALSE;
  482. }
  484. RECT rc = {0};
  485. GetClientRect(hWnd, &rc);
  486. g_listwnd = ::CreateWindow("ListBox", "Out", WS_CHILD|WS_VISIBLE|WS_VSCROLL|WS_HSCROLL|LBS_NOINTEGRALHEIGHT, 0, 0, rc.right, rc.bottom, hWnd, NULL, hInstance, NULL);
  487. if (!g_listwnd)
  488.    return FALSE;
  490. ShowWindow(hWnd, nCmdShow);
  491. UpdateWindow(hWnd);
  493. g_nShowTime = SetTimer(hWnd, 1, nLogTime, NULL);
  494. g_hInst = hInstance;
  496. return TRUE;
  497. }
  499. // Mesage handler for about box.
  500. LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  501. {
  502. switch (message)
  503. {
  504. case WM_INITDIALOG:
  505. return TRUE;
  507. case WM_COMMAND:
  508. if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) 
  509. {
  510. EndDialog(hDlg, LOWORD(wParam));
  511. return TRUE;
  512. }
  513. break;
  514. }
  515.     return FALSE;
  516. }
  518. //
  519. //  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
  520. //
  521. //  PURPOSE:  Processes messages for the main window.
  522. //
  523. //  WM_COMMAND - process the application menu
  524. //  WM_PAINT - Paint the main window
  525. //  WM_DESTROY - post a quit message and return
  526. //
  527. //
  528. LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  529. {
  530. int wmId, wmEvent;
  531. PAINTSTRUCT ps;
  532. HDC hdc;
  534. switch (message) 
  535. {
  536. case WM_COMMAND:
  537. wmId    = LOWORD(wParam); 
  538. wmEvent = HIWORD(wParam); 
  539. // Parse the menu selections:
  540. switch (wmId)
  541. {
  542. case IDM_ABOUT:
  543.    DialogBox(g_hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
  544.    break;
  545. case IDM_EXIT:
  546.    SendMessage(hWnd, WM_CLOSE, 0, 0);
  547.    break;
  548. case IDM_CLEARLOG:
  549.    gClearTrace();
  550.    break;
  551. case IDM_SHOWINFO:
  552. {
  553. S3PDBSocketPool* p = S3PDBSocketPool::Instance();
  554. if (p)
  555. p->ShowAllClientInfo();
  556. }
  557. break;
  558. default:
  559.    return DefWindowProc(hWnd, message, wParam, lParam);
  560. }
  561. break;
  562. case WM_PAINT:
  563. hdc = BeginPaint(hWnd, &ps);
  564. EndPaint(hWnd, &ps);
  565. break;
  566. case WM_DESTROY:
  567. if (g_nShowTime)
  568. KillTimer(hWnd, g_nShowTime);
  569. PostQuitMessage(0);
  570. break;
  571. case WM_CLOSE:
  572. if (::MessageBox(hWnd, "Are you sure ?", "warning", MB_YESNO) == IDYES)
  573. {
  574. DestroyWindow(hWnd);
  575. }
  576. break;
  577. case WM_SIZE:
  578. {
  579. RECT rc;
  580. GetClientRect(hWnd, &rc);
  581. MoveWindow(g_listwnd, 0, 0, rc.right, rc.bottom, TRUE);
  582. }
  583. break;
  584. case WM_TIMER:
  585. if (wParam == 1)
  586. gShowTrace();
  587. break;
  588. default:
  589. return DefWindowProc(hWnd, message, wParam, lParam);
  590.    }
  591.    return 0;
  592. }