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

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

模拟服务器

开发平台：

C/C++

S3Relay.cpp：源码内容
  1. // S3Relay.cpp : Defines the entry point for the application.
  2. //
  4. #include "stdafx.h"
  6. #include <objbase.h>
  7. #include <initguid.h>  // Include only once in your application
  8. #include "../../Multiserver/Heaven/Interface/IServer.h"
  9. #include "../../Multiserver/Rainbow/Interface/IClient.h"
  11. #include "S3Relay.h"
  12. #include "Global.h"
  14. #include "time.h"
  16. #include "LogFile.h"
  20. static CLockSRSW gs_lockRecv;
  21. static CLockSRSW gs_lockSend;
  22. static size_t gs_recvdatasize = 0;
  23. static size_t gs_senddatasize = 0;
  25. static BOOL gs_initialized = FALSE;
  27. static CLogFile gs_LogFile;
  29. /////////////////////////////////////////////////
  32. const char log_directory[] = "relay_log";
  33. const size_t log_threshold = 1024 * 1024;
  36. const UINT elapse_log = 3000;
  39. /////////////////////////////////////////////////
  42. void gTrackRecvData(const void* pData, size_t size)
  43. {
  44. AUTOLOCKWRITE(gs_lockRecv);
  45. gs_recvdatasize += size;
  46. }
  47. void gTrackSendData(const void* pData, size_t size)
  48. {
  49. AUTOLOCKWRITE(gs_lockSend);
  50. gs_senddatasize += size;
  51. }
  52. size_t gGetRecvDataSize()
  53. {
  54. AUTOLOCKREAD(gs_lockRecv);
  55. return gs_recvdatasize;
  56. }
  57. size_t gGetSendDataSize()
  58. {
  59. AUTOLOCKREAD(gs_lockSend);
  60. return gs_senddatasize;
  61. }
  66. #define MAX_LOADSTRING 100
  68. // Global Variables:
  69. HINSTANCE hInst; // current instance
  70. TCHAR szTitle[MAX_LOADSTRING]; // The title bar text
  71. TCHAR szWindowClass[MAX_LOADSTRING]; // The title bar text
  73. // Foward declarations of functions included in this code module:
  74. ATOM MyRegisterClass(HINSTANCE hInstance);
  75. BOOL InitInstance(HINSTANCE, int);
  76. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
  77. LRESULT CALLBACK About(HWND, UINT, WPARAM, LPARAM);
  78. LRESULT CALLBACK Login(HWND, UINT, WPARAM, LPARAM);
  81. std::_tstring g_rootloginname;
  82. std::_tstring g_rootloginpswd;
  83. BOOL g_interrupt = FALSE;
  85. HWND g_mainwnd = NULL;
  86. HWND g_listwnd = NULL;
  90. static inline sLogProgram(BOOL bEnter)
  91. {
  92. SYSTEMTIME systm;
  93. ::GetLocalTime(&systm);
  94. TCHAR buff[256];
  95. int len = 0;
  97. if (bEnter)
  98. len = _stprintf(buff, "rn*rn***** S3Relay Start (@ %04d/%02d/%02d %02d:%02d:%02d.%03d) >>>>>rn*rnrn",
  99. systm.wYear, systm.wMonth, systm.wDay, systm.wHour, systm.wMinute, systm.wSecond, systm.wMilliseconds);
  100. else
  101. len = _stprintf(buff, "rn*rn***** S3Relay Stop (@ %04d/%02d/%02d %02d:%02d:%02d.%03d) <<<<<rn*rnrn",
  102. systm.wYear, systm.wMonth, systm.wDay, systm.wHour, systm.wMinute, systm.wSecond, systm.wMilliseconds);
  104. gs_LogFile.TraceLog(buff, len * sizeof(TCHAR));
  105. }
  108. int APIENTRY WinMain(HINSTANCE hInstance,
  109.                      HINSTANCE hPrevInstance,
  110.                      LPSTR     lpCmdLine,
  111.                      int       nCmdShow)
  112. {
  113. try
  114. {
  115. //user input root login name & pswd
  116. ::DialogBox(hInstance, (LPCTSTR)IDD_DIALOG_ROOTLOGIN, NULL, (DLGPROC)Login);
  117. if (g_interrupt)
  118. return FALSE;
  120. std::_tstring strLogDir = gGetLocateDirectory() + log_directory;
  121. ::CreateDirectory(strLogDir.c_str(), NULL);
  122. if (!gs_LogFile.Initialize(strLogDir, log_threshold))
  123. {
  124. ::MessageBox(NULL, "Initializing LogFile fail", "error", MB_OK|MB_ICONERROR);
  125. return FALSE;
  126. }
  129. //the program enter
  130. sLogProgram(TRUE);
  133.   // TODO: Place code here.
  134. int retMain = 0;
  136. MSG msg;
  137. HACCEL hAccelTable;
  138. // Initialize global strings
  139. LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
  140. LoadString(hInstance, IDC_S3RELAY, szWindowClass, MAX_LOADSTRING);
  141. MyRegisterClass(hInstance);
  143. if (InitInstance (hInstance, nCmdShow))
  144. {
  145. // Perform application initialization:
  146. {
  147. hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_S3RELAY);
  149. // Main message loop:
  150. while (GetMessage(&msg, NULL, 0, 0)) 
  151. {
  152. if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
  153. {
  154. TranslateMessage(&msg);
  155. DispatchMessage(&msg);
  156. }
  157. }
  158. }
  160. retMain = msg.wParam;
  162. }
  165. //the program exit
  166. sLogProgram(FALSE);
  169. gs_LogFile.Uninitialize();
  171. return retMain;
  172. }
  173. catch (...)
  174. {
  175. ::MessageBox(NULL, "X state occur !", "error", MB_OK|MB_ICONERROR);
  177. return FALSE;
  178. }
  179. }
  181. class TwoFixBuffer
  182. {
  183. protected:
  184. #define MAX_BUFFER_LEN 1024 * 1024
  185. struct CSBuffer
  186. {
  187. BYTE buff[MAX_BUFFER_LEN + sizeof(DWORD)];
  188. DWORD nInfoStart;
  189. };
  191. CSBuffer m_RW_Buffer[2];
  192. int m_nRead;
  193. int m_nWrite;
  194. CRITICAL_SECTION m_switchsect;
  195. BOOL HasWriteInfo()
  196. {
  197. return m_RW_Buffer[m_nWrite].nInfoStart > 0;
  198. }
  199. BOOL HasReadInfo()
  200. {
  201. DWORD* pLen = (DWORD*)(m_RW_Buffer[m_nRead].buff + m_RW_Buffer[m_nRead].nInfoStart);
  202. return  *pLen != 0;
  203. }
  205. public:
  206. TwoFixBuffer()
  207. {
  208. ::InitializeCriticalSection(&m_switchsect);
  209. for (int n = 0; n < 2; n++)
  210. {
  211. memset(m_RW_Buffer[n].buff, 0, MAX_BUFFER_LEN + sizeof(DWORD));
  212. m_RW_Buffer[n].nInfoStart = 0;
  213. }
  214. m_nRead = 0;
  215. m_nWrite = 1;
  216. }
  217. ~TwoFixBuffer()
  218. {
  219. ::LeaveCriticalSection(&m_switchsect);
  220. ::DeleteCriticalSection(&m_switchsect);
  221. }
  223. //WriteInfo可以多个线程使用
  224. //其中nLen指内存长度
  225. BOOL WriteInfo(BYTE* szInfo, DWORD nLen)
  226. {
  227. if (nLen <= 0 || szInfo == NULL)
  228. return FALSE;
  229. ::EnterCriticalSection(&m_switchsect);
  230. BOOL bCanAdd = FALSE;
  231. DWORD nMemLen = nLen + sizeof(DWORD);
  232. DWORD nInfoStart = m_RW_Buffer[m_nWrite].nInfoStart;
  233. if (nInfoStart < MAX_BUFFER_LEN - nMemLen)
  234. {
  235. memcpy(m_RW_Buffer[m_nWrite].buff + nInfoStart, &nLen, sizeof(DWORD));
  236. memcpy(m_RW_Buffer[m_nWrite].buff + nInfoStart + sizeof(DWORD), szInfo, nLen);
  237. m_RW_Buffer[m_nWrite].nInfoStart += nMemLen;
  238. bCanAdd = TRUE;
  239. DWORD* pLen = (DWORD*)(m_RW_Buffer[m_nWrite].buff + nInfoStart + nMemLen);
  240. *pLen = 0;
  241. }
  242. ::LeaveCriticalSection(&m_switchsect);
  243. return bCanAdd;
  244. }
  246. //ReadInfo只能一个线程访问
  247. BYTE* ReadInfo()
  248. {
  249. BYTE* pInfo = NULL;
  250. if (HasReadInfo())
  251. {
  252. pInfo = m_RW_Buffer[m_nRead].buff + m_RW_Buffer[m_nRead].nInfoStart;
  253. DWORD nLen = *((DWORD*)pInfo);
  254. m_RW_Buffer[m_nRead].nInfoStart += nLen + sizeof(DWORD);
  255. }
  256. return pInfo;
  257. }
  258. void SwitchReadWrite()
  259. {
  260. if (!HasReadInfo() && HasWriteInfo())
  261. {
  262. ::EnterCriticalSection(&m_switchsect);
  263. //first clear read buffer
  264. m_RW_Buffer[m_nRead].nInfoStart = 0;
  265. DWORD* pLen = (DWORD*)m_RW_Buffer[m_nRead].buff;
  266. *pLen = 0;
  267. //switch read buffer and write buffer
  268. DWORD nTemp = m_nRead;
  269. m_nRead = m_nWrite;
  270. m_nWrite = nTemp;
  271. //read from head
  272. m_RW_Buffer[m_nRead].nInfoStart = 0;
  273. ::LeaveCriticalSection(&m_switchsect);
  274. }
  275. }
  276. };
  278. TwoFixBuffer g_TraceBuffer;
  279. long g_cnt = 0;
  281. int gTrace(LPCSTR fmt, ...)
  282. {
  283. if (g_listwnd == NULL)
  284. return -1;
  286. TCHAR tempbuff[256];
  288. g_cnt++;
  289. sprintf(tempbuff, "%d -- ", g_cnt);
  290. int n = strlen(tempbuff);
  292. va_list marker;
  293. va_start( marker, fmt );
  295. _vstprintf(tempbuff + n, fmt, marker);
  297. va_end( marker );
  299. n = strlen(tempbuff);
  301. g_TraceBuffer.WriteInfo((BYTE*)tempbuff, n + 1); //带0写入
  302. return 0;
  303. }
  305. //
  306. //  FUNCTION: MyRegisterClass()
  307. //
  308. //  PURPOSE: Registers the window class.
  309. //
  310. //  COMMENTS:
  311. //
  312. //    This function and its usage is only necessary if you want this code
  313. //    to be compatible with Win32 systems prior to the 'RegisterClassEx'
  314. //    function that was added to Windows 95. It is important to call this function
  315. //    so that the application will get 'well formed' small icons associated
  316. //    with it.
  317. //
  318. ATOM MyRegisterClass(HINSTANCE hInstance)
  319. {
  320. WNDCLASSEX wcex;
  322. wcex.cbSize = sizeof(WNDCLASSEX); 
  324. wcex.style = CS_HREDRAW | CS_VREDRAW;
  325. wcex.lpfnWndProc = (WNDPROC)WndProc;
  326. wcex.cbClsExtra = 0;
  327. wcex.cbWndExtra = 0;
  328. wcex.hInstance = hInstance;
  329. wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_S3RELAY);
  330. wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
  331. wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
  332. wcex.lpszMenuName = (LPCSTR)IDC_S3RELAY;
  333. wcex.lpszClassName = szWindowClass;
  334. wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
  336. return RegisterClassEx(&wcex);
  337. }
  339. int gTimeStamp(char* sDest, char* pTail)
  340. {
  341. assert(sDest);
  342. time_t curtm = ::time(NULL);
  343. struct tm* ptm = localtime(&curtm);
  344. return sprintf(sDest, "[%04d/%02d/%02d %02d:%02d:%02d]%s",
  345. ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec, pTail);
  346. }
  348. void gTraceLogFile(LPCTSTR pBuffer, long nLen)
  349. {
  350. if (!gs_LogFile.BeginBatch())
  351. return;
  353. char szTime[128];
  354. int nTime = gTimeStamp(szTime, " ");
  355. gs_LogFile.TraceLog(szTime, nTime);
  356. gs_LogFile.TraceLog(pBuffer, nLen);
  357. gs_LogFile.TraceLog(_T("rn"), 2 * sizeof(TCHAR));
  359. gs_LogFile.EndBatch();
  360. }
  362. void gClearTrace()
  363. {
  364. if (g_listwnd)
  365. ::SendMessage(g_listwnd, LB_RESETCONTENT, 0, 0);
  366. }
  368. void gShowTrace()
  369. {
  370. if (!g_listwnd)
  371. return;
  373. static BOOL bLastRead = FALSE;
  374. char* pBuff = NULL;
  375. DWORD* pMem = NULL;
  376. int nPercent = 0;
  377. int n1 = ::SendMessage(g_listwnd, LB_GETCOUNT, 0, 0);
  378. int cursel = ::SendMessage(g_listwnd, LB_GETCURSEL, 0, 0);
  379. BOOL isTrack = cursel < 0 || cursel + 1 >= n1;
  381. int n = n1;
  382. while (1)
  383. {
  384. pMem = (DWORD*)g_TraceBuffer.ReadInfo();
  385. if (pMem)
  386. {
  387. pBuff = (char*)(pMem + 1);
  389. if (n > 0 && n % 8100 == 0)
  390. {
  391. ::SendMessage(g_listwnd, LB_DELETESTRING, 0, NULL);
  392. }
  394. if (::SendMessage(g_listwnd, LB_ADDSTRING, 0, (LPARAM)pBuff) >= 0)
  395. n++;
  397. gTraceLogFile(pBuff, (*pMem) - 1); //去0写文件
  398. }
  399. else
  400. break;
  401. }
  402. if (isTrack && n > n1)
  403. {
  404. ::SendMessage(g_listwnd, LB_SETCURSEL, (WPARAM)n - 1, 0);
  405. }
  406. g_TraceBuffer.SwitchReadWrite();
  407. }
  409. int g_nShowTime = 0;
  411. //
  412. //   FUNCTION: InitInstance(HANDLE, int)
  413. //
  414. //   PURPOSE: Saves instance handle and creates main window
  415. //
  416. //   COMMENTS:
  417. //
  418. //        In this function, we save the instance handle in a global variable and
  419. //        create and display the main program window.
  420. //
  421. BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
  422. {
  423.    hInst = hInstance; // Store instance handle in our global variable
  425.    g_mainwnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
  426.       CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
  428.    if (!g_mainwnd)
  429.    {
  430.       return FALSE;
  431.    }
  433.    RECT rc = {0};
  434.    GetClientRect(g_mainwnd, &rc);
  435.    g_listwnd = ::CreateWindow("ListBox", "Out", WS_CHILD|WS_VISIBLE|WS_VSCROLL|WS_HSCROLL|LBS_NOINTEGRALHEIGHT, 0, 0, rc.right, rc.bottom, g_mainwnd, NULL, hInst, NULL);
  436.    if (!g_listwnd)
  437.    return FALSE;
  439.    ShowWindow(g_mainwnd, nCmdShow);
  440.    UpdateWindow(g_mainwnd);
  442. //gTraceLogFile(tempbuff, strlen(tempbuff));
  444. g_nShowTime = SetTimer(g_mainwnd, timer_log, elapse_log, NULL);
  446. //auto startup
  447. ::SendMessage(g_mainwnd, WM_COMMAND, MAKEWPARAM(IDM_STARTUP, 0), NULL);
  448. gShowTrace();
  449. gShowTrace();
  451.    return TRUE;
  452. }
  454. //
  455. //  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
  456. //
  457. //  PURPOSE:  Processes messages for the main window.
  458. //
  459. //  WM_COMMAND - process the application menu
  460. //  WM_PAINT - Paint the main window
  461. //  WM_DESTROY - post a quit message and return
  462. //
  463. //
  464. LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  465. {
  466. int wmId, wmEvent;
  467. PAINTSTRUCT ps;
  468. HDC hdc;
  469. TCHAR szHello[MAX_LOADSTRING];
  470. LoadString(hInst, IDS_HELLO, szHello, MAX_LOADSTRING);
  472. switch (message) 
  473. {
  474. case WM_COMMAND:
  475. wmId    = LOWORD(wParam); 
  476. wmEvent = HIWORD(wParam); 
  477. // Parse the menu selections:
  478. switch (wmId)
  479. {
  480. case IDM_ABOUT:
  481.    DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
  482.    break;
  483. case IDM_EXIT:
  484.    SendMessage(hWnd, WM_CLOSE, 0, 0);
  485.    break;
  486. case IDM_CLEAR_TRACE:
  487. ::SendMessage(g_listwnd, LB_RESETCONTENT, 0, 0);
  488. break;
  489. case IDM_UPDATE_TRACE:
  490. gShowTrace();
  491. gShowTrace();
  492. break;
  494. case IDM_TRACE_HOSTSERVER: g_HostServer.TraceInfo(); break;
  495. case IDM_TRACE_CHATSERVER: g_ChatServer.TraceInfo(); break;
  496. case IDM_TRACE_TONGSERVER: g_TongServer.TraceInfo(); break;
  497. case IDM_TRACE_RELAYSERVER: g_RelayServer.TraceInfo(); break;
  499. case IDM_TRACE_ROOTCENTER: g_RootCenter.TraceInfo(); break;
  500. case IDM_TRACE_GATEWAYCENTER: g_GatewayCenter.TraceInfo(); break;
  501. case IDM_TRACE_DBROLECENTER: g_DBCenter.TraceInfo(); break;
  502. case IDM_TRACE_RELAYCENTER: g_RelayCenter.TraceInfo(); break;
  504. case IDM_TRACE_PLAYER_DETAIL: g_HostServer.TracePlayer(); break;
  505. case IDM_TRACE_PLAYER:
  506. rTRACE("message: online player total: %d", g_HostServer.GetPlayerCount());
  507. break;
  509. case IDM_TRACE_FRIENDPLAYER:
  510. rTRACE("message: friend player total: %d", g_FriendMgr.GetPlayerCount());
  511. break;
  513. case IDM_TRACE_FRIENDAFQS:
  514. rTRACE("message: friend AFQS: %d", g_FriendMgr.GetAFQSize());
  515. break;
  517. case IDM_TRACE_STATUS:
  518. rTRACE("message: [0] RootClient: %d, GatewayClient: %d, DBRoleClient: %d",
  519. g_RootCenter.GetClientCount(), g_GatewayCenter.GetClientCount(), g_DBCenter.GetClientCount());
  520. rTRACE("message: [1] RelayClient: %d, RelayConnect: %d",
  521. g_RelayCenter.GetClientCount(), g_RelayServer.GetConnectCount());
  522. rTRACE("message: [2] HostConnect: %d, ChatConnect: %d, TongConnect: %d",
  523. g_HostServer.GetConnectCount(), g_ChatServer.GetConnectCount(), g_TongServer.GetConnectCount());
  524. break;
  525. case IDM_TRACE_SOCKTHREAD:
  526. g_threadSock.TraceInfo();
  527. break;
  528. case IDM_TRACE_DATASIZE:
  529. dTRACE("message: recvsum: %ld B, sendsum: %ld B", gGetRecvDataSize(), gGetSendDataSize());
  530. break;
  531. case IDM_TRACE_MAC:
  532. {{
  533. std::_tstring descLocal;
  534. {{
  535. size_t lenLocal = 0;
  536. const UCHAR* macLocal = gGetHostMac(local_adapt, &lenLocal);
  537. for (int i = 0; i < lenLocal; i++)
  538. {
  539. char buff[3];
  540. _stprintf(buff, "%02X", macLocal[i]);
  541. if (i > 0)
  542. descLocal += '-';
  543. descLocal += buff;
  544. }
  545. }}
  546. std::_tstring descGlobal;
  547. {{
  548. size_t lenGlobal = 0;
  549. const UCHAR* macGlobal = gGetHostMac(global_adapt, &lenGlobal);
  550. for (int i = 0; i < lenGlobal; i++)
  551. {
  552. char buff[3];
  553. _stprintf(buff, "%02X", macGlobal[i]);
  554. if (i > 0)
  555. descGlobal += '-';
  556. descGlobal += buff;
  557. }
  558. }}
  560. rTRACE("message: localMAC: %s, globalMAC: %s", descLocal.c_str(), descGlobal.c_str());
  561. }}
  562. break;
  563. case IDM_TRACE_IP:
  564. rTRACE("message: localIP: 0x%08X (%s), globalIP: 0x%08X (%s)", gGetHostIP(local_adapt), std::_tstring(_ip2a(gGetHostIP(local_adapt))).c_str(), gGetHostIP(global_adapt), std::_tstring(_ip2a(gGetHostIP(global_adapt))).c_str());
  565. break;
  566. case IDM_STARTUP:
  567. if (gs_initialized)
  568. rTRACE("waring: already Initialized");
  569. else
  570. {
  571. rTRACE("Initializing ...");
  572. if (gInitialize())
  573. {
  574. gs_initialized = TRUE;
  575. rTRACE("Initialize OK");
  576. }
  577. else
  578. {
  579. gUninitialize();
  580. rTRACE("error: Initialize FAIL");
  581. }
  582. }
  583. break;
  584. case IDM_SHUTDOWN:
  585. if (!gs_initialized)
  586. {
  587. rTRACE("waring: already Uninitialized");
  588. gUninitialize();
  589. }
  590. else
  591. {
  592. rTRACE("Uninitializing ...");
  593. gUninitialize();
  594. gs_initialized = FALSE;
  595. rTRACE("Uninitialize OK");
  596. }
  597. break;
  598. default:
  599.    return DefWindowProc(hWnd, message, wParam, lParam);
  600. }
  601. break;
  602. case WM_PAINT:
  603. hdc = BeginPaint(hWnd, &ps);
  604. EndPaint(hWnd, &ps);
  605. break;
  606. case WM_DESTROY:
  607. //auto shutdown
  608. ::SendMessage(hWnd, WM_COMMAND, MAKEWPARAM(IDM_SHUTDOWN, 0), NULL);
  609. if (g_nShowTime)
  610. KillTimer(hWnd, g_nShowTime);
  611. gShowTrace();
  612. gShowTrace();
  614. PostQuitMessage(0);
  615. break;
  616. case WM_CLOSE:
  617. if (::MessageBox(hWnd, "Are you sure ?", "warning", MB_YESNO) == IDYES)
  618. {
  619. DestroyWindow(hWnd);
  620. }
  621. break;
  622. case WM_SIZE:
  623. {
  624. RECT rc;
  625. GetClientRect(hWnd, &rc);
  626. MoveWindow(g_listwnd, 0, 0, rc.right, rc.bottom, TRUE);
  627. }
  628. break;
  629. case WM_TIMER:
  630. switch (wParam)
  631. {
  632. case timer_log: gShowTrace(); break;
  633. case timer_rootclient: gReOneClient(oneclient_root); break;
  634. case timer_gatewayclient: gReOneClient(oneclient_gateway); break;
  635. case timer_dbclient: gReOneClient(oneclient_db); break;
  636. case timer_friendudtdb: gFriendTimingUpdateDB(); break;
  637. default: break;
  638. }
  639. break;
  640. case UM_CONSIGNCLIENTSD:
  641. {{
  642. IClient* pClient = (IClient*)wParam;
  643. if (pClient)
  644. {
  645. //pClient->Shutdown();
  646. pClient->Cleanup();
  647. pClient->Release();
  648. }
  649. }}
  650. break;
  651. default:
  652. return DefWindowProc(hWnd, message, wParam, lParam);
  653.    }
  654.    return 0;
  655. }
  657. // Mesage handler for about box.
  658. LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  659. {
  660. switch (message)
  661. {
  662. case WM_INITDIALOG:
  663. return TRUE;
  665. case WM_COMMAND:
  666. if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) 
  667. {
  668. EndDialog(hDlg, LOWORD(wParam));
  669. return TRUE;
  670. }
  671. break;
  672. }
  673.     return FALSE;
  674. }
  676. // Mesage handler for login box.
  677. LRESULT CALLBACK Login(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  678. {
  679. switch (message)
  680. {
  681. case WM_INITDIALOG:
  682. return TRUE;
  684. case WM_COMMAND:
  685. {{
  686. TCHAR buffer[_MAX_PATH];
  687. switch (wParam)
  688. {
  689. case IDOK:
  690. ::GetDlgItemText(hDlg, IDC_EDIT_NAME, buffer, _MAX_PATH);
  691. g_rootloginname = buffer;
  692. ::GetDlgItemText(hDlg, IDC_EDIT_PSWD, buffer, _MAX_PATH);
  693. g_rootloginpswd = buffer;
  694. EndDialog(hDlg, LOWORD(wParam));
  695. return TRUE;
  696. case IDCANCEL:
  697. g_interrupt = TRUE;
  698. EndDialog(hDlg, LOWORD(wParam));
  699. return TRUE;
  700. }
  701. }}
  702. break;
  703. }
  704.     return FALSE;
  705. }
  707. HWND gGetMainWnd()
  708. {
  709. return g_mainwnd;
  710. }
  712. HWND gGetListBox()
  713. {
  714. return g_listwnd;
  715. }