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

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

模拟服务器

开发平台：

C/C++

CheckThread.cpp：源码内容
  1. ////////////////////////////////////////////////////////////////////////////////
  2. //  
  3. //  FileName    :   CheckThread.cpp
  4. //  Version     :   1.0
  5. //  Creater     :   Linsuyi
  6. //  Date        :   2002-01-17  10:37:18
  7. //  Comment     :   KAVuser-net check thread source file
  8. //  
  9. ////////////////////////////////////////////////////////////////////////////////
  11. #include "Stdafx.h"
  12. #include "CheckThread.h"
  13. #include "DataDefine.h"
  14. #include "UdpSocket.h"
  16. //////////////////////////////////////////////////////////////////////
  17. // Construction/Destruction
  18. //////////////////////////////////////////////////////////////////////
  20. CCheckThread::CCheckThread()
  21. {
  22.     m_nTimeOut = defCHECK_TIME_OUT;
  23.     m_nTryTimes = defCHECK_TRY_TIMES;
  24.     
  25.     m_ulContextWith = 0;
  26.     m_piCallback = NULL;
  27.     
  28.     m_hKillEvent = NULL;
  29. }
  31. CCheckThread::~CCheckThread()
  32. {
  33. }
  35. int CCheckThread::SetCheckCallback(IKCheckCallback *piCallback, ULONG ulContextWith)
  36. {
  37.     int nResult = false;
  38.     int nRetCode = false;
  39.     
  40.     nRetCode = CBusyThread::IsThreadOK();
  41.     if (nRetCode)
  42.         goto Exit0;
  43.     
  44.     ulContextWith = ulContextWith;
  45.     m_piCallback = piCallback;
  46.     
  47.     nResult = true;
  48.     
  49. Exit0:
  50.     return nResult;
  51. }
  53. int CCheckThread::AddCheckServer(const char *pcszCheckServer, int nCheckPort)
  54. {
  55.     int nResult = false;
  56.     int nAddServer = -1;
  57.     
  58.     TRY
  59.     {
  60.         nAddServer = m_paServerAddress.Add((void *)pcszCheckServer);
  61.         
  62.         m_waServerPort.Add((WORD)nCheckPort);
  63.     }
  64.     CATCH_ALL(pException);
  65.     {
  66.         pException->Delete();
  67.         goto Exit0;
  68.     }
  69.     END_CATCH_ALL;
  70.     
  71.     nResult = true;
  72.     
  73. Exit0:
  74.     if ((!nResult) && (nAddServer != -1))
  75.     {
  76.         m_paServerAddress.RemoveAt(nAddServer);
  77.     }
  78.     return nResult;
  79. }
  81. int CCheckThread::Create()
  82. {
  83.     int nResult = false;
  84.     int nRetCode = false;
  85.     
  86.     nRetCode = IsThreadOK();
  87.     if (nRetCode)
  88.         goto Exit0;
  89.     
  90. ASSERT(NULL == m_hKillEvent);
  91.     
  92.     m_hKillEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
  93.     if (NULL == m_hKillEvent)
  94.     {
  95.         ASSERT(FALSE);
  96.         goto Exit0;
  97.     }
  98.     
  99.     nResult = true;
  100.     
  101. Exit0:
  102.     return nResult;
  103. }
  105. void CCheckThread::Destroy()
  106. {
  107.     ASSERT(!IsThreadOK());
  108.     
  109.     if (m_hKillEvent != NULL)
  110.     {
  111.         ::CloseHandle(m_hKillEvent);
  112.         m_hKillEvent = NULL;
  113.     }
  114. }
  116. int CCheckThread::StartThread()
  117. {
  118.     int nResult = false;
  119.     ULONG ulRetCode = 0;
  120.     
  121.     if (
  122.         (NULL == m_hKillEvent) || 
  123.         (NULL == m_piCallback)
  124.     )
  125.     {
  126.         ASSERT(FALSE);
  127.         goto Exit0;
  128.     }
  129.     
  130.     ulRetCode = ::WaitForSingleObject(m_hKillEvent, 0);
  131.     if (WAIT_OBJECT_0 == ulRetCode)
  132.         ::ResetEvent(m_hKillEvent);
  133.     
  134.     nResult = CBusyThread::StartThread();
  135.     
  136. Exit0:
  137.     return nResult;
  138. }
  140. int CCheckThread::QueryStop()
  141. {
  142.     int nResult = false;
  143.     ULONG ulRetCode = 0;
  144.     
  145.     ASSERT(m_hKillEvent != NULL);
  147.     if (m_hKillEvent != NULL)
  148.     {
  149.         ulRetCode = ::WaitForSingleObject(m_hKillEvent, 0);
  150.         
  151.         nResult = (WAIT_OBJECT_0 == ulRetCode);
  152.     }
  153.     
  154.     return nResult;
  155. }
  157. int CCheckThread::RemindStop()
  158. {
  159.     int nResult = false;
  160.     
  161.     if (m_hKillEvent != NULL)
  162.     {
  163.         nResult = ::SetEvent(m_hKillEvent);
  164.     }
  165.     
  166.     return nResult;
  167. }
  169. ULONG CCheckThread::MainExecution()
  170. {
  171.     ULONG ulResult = 0;
  172.     int nRetCode = 0;
  173.     int nDataReady = false;
  174.     int nExitDirect = false;    
  175.     CUdpSocket CheckSocket;
  176.     
  177.     int nAddrIndex = 0;
  178.     int nCheckResult = defConnectServerFailed - 1;
  179.     
  180.     int nCheckServerPort = 0;
  181.     const char *pcszCheckServerAddr = NULL;
  182.     
  183.     int nTimeOut = 0;
  184.     int nTryTimes = 0;
  185.     int nCheckServerCount = 0;
  186.     
  187.     int nSendBufSize;
  188.     unsigned char *pbySendBuffer = NULL;
  189.     
  190.     int nRecvBufSize = defCHECK_RECEIVE_MAX_SIZE;
  191.     unsigned char byRecvBuffer[defCHECK_RECEIVE_MAX_SIZE];
  192.     
  193.     if (NULL == m_piCallback)
  194.         goto Exit0;
  195.     
  196.     nRetCode = m_piCallback->GetCheckInfo(
  197.         m_ulContextWith,
  198.         &nSendBufSize,
  199.         &pbySendBuffer
  200.     );
  201.     if (
  202.         (!nRetCode) ||
  203.         (nSendBufSize <= 0) ||
  204.         (NULL == pbySendBuffer)
  205.     )
  206.         goto Exit0;
  207.     
  208.     nRetCode = QueryStop();
  209.     if (nRetCode)
  210.     {
  211.         nExitDirect = true;
  212.         goto Exit0;
  213.     }
  214.     
  215.     nRetCode = CheckSocket.Create();
  216.     if (!nRetCode)
  217.         goto Exit0;
  218.     
  219.     nCheckServerCount = m_paServerAddress.GetSize();
  220.     for (nAddrIndex = 0; nAddrIndex < nCheckServerCount; nAddrIndex++)
  221.     {
  222.         nRetCode = QueryStop();
  223.         if (nRetCode)
  224.         {
  225.             nExitDirect = true;
  226.             goto Exit0;
  227.         }
  228.         
  229.         nCheckServerPort = m_waServerPort.GetAt(nAddrIndex);
  230.         if (nCheckServerPort <= 0)
  231.             nCheckServerPort = defCHECK_SERVER_PORT;
  232.         pcszCheckServerAddr = (const char *)m_paServerAddress.GetAt(nAddrIndex);
  233.         
  234.         nRetCode = CheckSocket.SetRemoteAddress(pcszCheckServerAddr, nCheckServerPort);
  235.         if (!nRetCode)
  236.             continue;
  237.         
  238.         nTimeOut = m_nTimeOut;
  239.         nTryTimes = m_nTryTimes;
  240.         
  241.         while (nTryTimes-- > 0)
  242.         {
  243.             int nSeparate = defCHECK_TIME_SEP;
  244.             
  245.             nRetCode = QueryStop();
  246.             if (nRetCode)
  247.             {
  248.                 nExitDirect = true;
  249.                 goto Exit0;
  250.             }
  251.             
  252.             nRetCode = CheckSocket.Send(nSendBufSize, pbySendBuffer);
  253.             if (nRetCode <= 0)
  254.             {
  255.                 ASSERT(FALSE);
  256.                 continue;
  257.             }
  258.             
  259.             nTimeOut /= nSeparate;
  260.             while (nSeparate-- > 0)
  261.             {
  262.                 nDataReady = CheckSocket.Select(true, false, false, nTimeOut);
  263.                 if (SOCKET_ERROR == nDataReady)
  264.                     break;
  266.                 nRetCode = QueryStop();
  267.                 if (nRetCode)
  268.                 {
  269.                     nExitDirect = true;
  270.                     goto Exit0; 
  271.                 }
  273.                 if (nDataReady <= 0)
  274.                     continue;
  275.                 
  276.                 break;
  277.             }
  278.             if (SOCKET_ERROR == nDataReady)
  279.                 break;
  280.             
  281.             if (nDataReady > 0)
  282.             {
  283.                 ZeroMemory(byRecvBuffer, nRecvBufSize);
  284.                 nRetCode = CheckSocket.ReceiveFrom(nRecvBufSize, byRecvBuffer);
  285.                 if (nRetCode <= 0)
  286.                     break;
  287.                 
  288.                 nCheckResult = m_piCallback->CheckRecvInfo(
  289.                     m_ulContextWith,
  290.                     nRetCode,
  291.                     byRecvBuffer
  292.                 );
  293.                 if (nCheckResult >= defInhibitiveSerialNumber)
  294.                     goto Exit1;
  295.             }
  296.         }
  297.     }
  298.     
  299. Exit1:
  300.     ulResult = true;
  301.     
  302. Exit0:
  303.     if (!nExitDirect && (m_piCallback != NULL))
  304.     {
  305.         m_piCallback->CheckResult(m_ulContextWith, nCheckResult);
  306.     }
  307.     
  308.     nRetCode = CheckSocket.IsSocketOK();
  309.     if (nRetCode)
  310.         CheckSocket.Destroy();
  311.     
  312.     return ulResult;
  313. }