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

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

模拟服务器

开发平台：

C/C++

PublicFun.cpp：源码内容
  1. //////////////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  FileName    :   PublicFun.cpp
  4. //  Version     :   1.0
  5. //  Creater     :   Cheng Bitao
  6. //  Date        :   2002-4-8 16:42:22
  7. //  Comment     :   
  8. //
  9. //////////////////////////////////////////////////////////////////////////////////////
  11. #include "stdafx.h"
  12. #include "PublicFun.h"
  13. #include "Direct.h"
  14. #include "winsvc.h"
  15. #include "KString.h"
  17. void AddPathChar(char szPath[])
  18. {
  19.     int nPathLen = strlen(szPath);
  21.     if (szPath[nPathLen - 1] != '\')
  22.         memcpy(&szPath[nPathLen], "\", 2);
  23. }
  25. void AddPathChar(char szPath[], char chPathChar)
  26. {
  27.     int nPathLen = 0;
  28.   
  29.     //ASSERT(*szPath);
  31. if (szPath[0] == '')
  32. return;
  34.     nPathLen = strlen(szPath);
  35.     if (szPath[nPathLen - 1] != chPathChar)
  36.     {
  37.         szPath[nPathLen] = chPathChar;
  38.         szPath[nPathLen + 1] = '';
  39.     }
  40. }
  43. void MkDirEx(const char cszPathDir[])
  44. {
  45.     char szDir[MAX_PATH]    = {0};
  46.     char szTemp[MAX_PATH]   = {0};
  47.     char *pszPos            = NULL;
  48.     char *pszTemp           = NULL;
  49.     int nLen                = 0;
  51.     
  52.     strcpy(szTemp, cszPathDir);
  53.     pszPos = strchr(szTemp, '\');
  54.     pszTemp = szTemp;
  56. while(pszPos != NULL)
  57. {
  58. if (*szDir == '')
  59.             strncpy(szDir, pszTemp, pszPos - pszTemp);
  60.         else
  61.             strncat(szDir, pszTemp, pszPos - pszTemp);
  63.         pszTemp = pszPos + 1;        
  65.         nLen = strlen(szDir);
  66. if (szDir[nLen - 1] != ':')//such as "c:"
  67. _mkdir(szDir);
  69. strcat(szDir, "\");
  71. pszPos = strchr(pszTemp, '\');
  72. }
  74.     if (*szDir == '')
  75.         strcpy(szDir, pszTemp);
  76.     else
  77.         strcat(szDir, pszTemp);
  79. _mkdir(szDir);
  80. }
  82.  
  83. // Check file exists
  84. int FileExists(LPCTSTR lpszFileName)
  85. {
  86.     int nResult                     = false;
  87.     HANDLE hFind                    = INVALID_HANDLE_VALUE;
  88.     WIN32_FIND_DATA *pFindFileData  = NULL;
  91.     pFindFileData = new WIN32_FIND_DATA;
  92.     KAV_PROCESS_ERROR(pFindFileData);
  94.     hFind = ::FindFirstFile(lpszFileName, pFindFileData);
  95.     if (INVALID_HANDLE_VALUE != hFind)
  96.     {
  97.         if (!((pFindFileData->dwFileAttributes) & FILE_ATTRIBUTE_DIRECTORY))
  98.             nResult = true;
  99.      
  100.         ::FindClose(hFind);
  101.         hFind = INVALID_HANDLE_VALUE;
  102.     }
  104. Exit0:
  105.     KAV_DELETE(pFindFileData);
  107.     return nResult;
  108. }
  111. int CopyDir(const char cszSource[], const char cszDest[], int nFailedIfExist)
  112. {
  113.     WIN32_FIND_DATA FindFileData;
  114.     HANDLE Handle;
  115.     char szSource[MAX_PATH];
  116.     char szSourceFile[MAX_PATH];
  117.     char szDest[MAX_PATH];
  119.     strcpy(szSource, cszSource);
  120.     AddPathChar(szSource, '\');
  121.     strcat(szSource, "*.*");
  123.     MkDirEx(cszDest);
  125.     Handle = ::FindFirstFile(szSource, &FindFileData);
  126.     if (Handle != INVALID_HANDLE_VALUE)
  127.     {
  128.         do
  129.         {   
  130.             strcpy(szDest, cszDest);
  131.             AddPathChar(szDest);
  132.             strcat(szDest, FindFileData.cFileName);
  134.             strcpy(szSourceFile, cszSource);
  135.             AddPathChar(szSourceFile);
  136.             strcat(szSourceFile, FindFileData.cFileName);
  138.             if (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
  139.             {
  140.                 if ((strcmp(FindFileData.cFileName, ".") != 0) && (strcmp(FindFileData.cFileName, "..") != 0))
  141.                     CopyDir(szSourceFile, szDest, nFailedIfExist);
  142.                 continue;
  143.             }                   
  145.             ::CopyFile(szSourceFile, szDest, nFailedIfExist);            
  146.         }
  147.         while(::FindNextFile(Handle, &FindFileData));
  149.         ::FindClose(Handle);
  150.     }
  152.     return true;
  153. }
  155. // Return  1 : Exist process and exit successfully
  156. //         0 : Exist process but exit failed
  157. //        -1 : Not exist process
  158. int StopAService(const char cszServiceName[])
  159. {
  160.     int nResult                 = -1;
  161.     SC_HANDLE SCMgrHandle       = NULL;
  162.     SC_HANDLE SCServiceHandle   = NULL;
  163.     SERVICE_STATUS ssStatus;
  164.     DWORD dwErrorCode           = 0;
  166. DWORD dwOldCheckPoint; 
  167.     DWORD dwStartTickCount;
  168.     DWORD dwWaitTime;
  170.     SCMgrHandle = OpenSCManager(NULL, SERVICES_ACTIVE_DATABASE, SC_MANAGER_ALL_ACCESS);
  171.     KAV_PROCESS_ERROR(SCMgrHandle);
  173.     SCServiceHandle = OpenService(SCMgrHandle, cszServiceName, SC_MANAGER_ALL_ACCESS);
  174.     if (!SCServiceHandle)
  175.     {
  176.         dwErrorCode = GetLastError();
  177.         if ((dwErrorCode == ERROR_SERVICE_DOES_NOT_EXIST) || (dwErrorCode == ERROR_INVALID_NAME))
  178.             nResult = -1;
  180.         goto Exit0;
  181.     }
  183.     if (!ControlService(SCServiceHandle, SERVICE_CONTROL_STOP, &ssStatus))
  184.     {
  185. nResult = 0;
  186. goto Exit0;
  187. }
  189. // Check the status until the service is no longer start pending. 
  190.     if (!QueryServiceStatus( 
  191. SCServiceHandle,   // handle to service 
  192. &ssStatus) 
  193. )  // address of status information structure
  194.     {
  195. nResult = 0;
  196. goto Exit0;
  197. }
  198.  
  199.     // Save the tick count and initial checkpoint.
  200.     dwStartTickCount = GetTickCount();
  201.     dwOldCheckPoint = ssStatus.dwCheckPoint;
  203.     while (ssStatus.dwCurrentState == SERVICE_STOP_PENDING) 
  204.     { 
  205.         // Do not wait longer than the wait hint. A good interval is 
  206.         // one tenth the wait hint, but no less than 1 second and no 
  207.         // more than 10 seconds. 
  208.  
  209.         dwWaitTime = ssStatus.dwWaitHint / 10;
  211.         if(dwWaitTime < 1000)
  212.             dwWaitTime = 1000;
  213.         else if (dwWaitTime > 10000)
  214.             dwWaitTime = 10000;
  216.         Sleep(dwWaitTime);
  218.         // Check the status again. 
  219.  
  220.         if (!QueryServiceStatus( 
  221.             SCServiceHandle,   // handle to service 
  222.             &ssStatus)
  223. )  // address of structure
  224.             break; 
  225.  
  226.         if (ssStatus.dwCheckPoint > dwOldCheckPoint)
  227.         {
  228.             // The service is making progress.
  230.             dwStartTickCount = GetTickCount();
  231.             dwOldCheckPoint = ssStatus.dwCheckPoint;
  232.         }
  233.         else
  234.         {
  235.             if(GetTickCount()-dwStartTickCount > ssStatus.dwWaitHint)
  236.             {
  237.                 // No progress made within the wait hint
  238.                 break;
  239.             }
  240.         }
  241.     } 
  243.     if (ssStatus.dwCurrentState == SERVICE_STOPPED) 
  244. nResult = 1;
  245. else 
  246. nResult = 0;
  248. Exit0:
  249.     if (SCServiceHandle)
  250.     {
  251.         CloseServiceHandle(SCServiceHandle);
  252.         SCServiceHandle = NULL;
  253.     }
  255.     if (SCMgrHandle)
  256.     {
  257.         CloseServiceHandle(SCMgrHandle);
  258.         SCMgrHandle = NULL;
  259.     }
  261.     return nResult;
  262. }
  265. int StartAService(const char cszServiceName[])
  266. {
  267.     int nResult                 = false;
  268. int nRetCode = 0;
  269.     SC_HANDLE SCMgrHandle       = NULL;
  270.     SC_HANDLE SCServiceHandle   = NULL;
  272.     SERVICE_STATUS ssStatus;
  273. DWORD dwOldCheckPoint; 
  274.     DWORD dwStartTickCount;
  275.     DWORD dwWaitTime;
  276.     
  278.     SCMgrHandle = OpenSCManager(NULL, SERVICES_ACTIVE_DATABASE, SC_MANAGER_ALL_ACCESS);
  279.     KAV_PROCESS_ERROR(SCMgrHandle);
  281.     SCServiceHandle = OpenService(SCMgrHandle, cszServiceName, SC_MANAGER_ALL_ACCESS);
  282.     KAV_PROCESS_ERROR(SCServiceHandle);
  284.     nRetCode = StartService(SCServiceHandle, 0, NULL);    
  285. KAV_PROCESS_ERROR(nRetCode);
  287. // Check the status until the service is no longer start pending. 
  288.     if (!QueryServiceStatus( 
  289. SCServiceHandle,   // handle to service 
  290.         &ssStatus)
  291. )  // address of status information structure
  292.         goto Exit0;
  293.  
  294.     // Save the tick count and initial checkpoint.
  296.     dwStartTickCount = GetTickCount();
  297.     dwOldCheckPoint = ssStatus.dwCheckPoint;
  299.     while (ssStatus.dwCurrentState == SERVICE_START_PENDING) 
  300.     { 
  301.         // Do not wait longer than the wait hint. A good interval is 
  302.         // one tenth the wait hint, but no less than 1 second and no 
  303.         // more than 10 seconds. 
  304.  
  305.         dwWaitTime = ssStatus.dwWaitHint / 10;
  307.         if(dwWaitTime < 1000)
  308.             dwWaitTime = 1000;
  309.         else if (dwWaitTime > 10000)
  310.             dwWaitTime = 10000;
  312.         Sleep(dwWaitTime);
  314.         // Check the status again. 
  315.  
  316.         if (!QueryServiceStatus( 
  317.             SCServiceHandle,   // handle to service 
  318.             &ssStatus) 
  319. )  // address of structure
  320.             break; 
  321.  
  322.         if (ssStatus.dwCheckPoint > dwOldCheckPoint)
  323.         {
  324.             // The service is making progress.
  326.             dwStartTickCount = GetTickCount();
  327.             dwOldCheckPoint = ssStatus.dwCheckPoint;
  328.         }
  329.         else
  330.         {
  331.             if(GetTickCount()-dwStartTickCount > ssStatus.dwWaitHint)
  332.             {
  333.                 // No progress made within the wait hint
  334.                 break;
  335.             }
  336.         }
  337.     } 
  339.     if (ssStatus.dwCurrentState == SERVICE_RUNNING) 
  340. nResult = true;
  342. Exit0:
  343.     if (SCServiceHandle)
  344.     {
  345.         CloseServiceHandle(SCServiceHandle);
  346.         SCServiceHandle = NULL;
  347.     }
  349.     if (SCMgrHandle)
  350.     {
  351.         CloseServiceHandle(SCMgrHandle);
  352.         SCMgrHandle = NULL;
  353.     }
  355.     return nResult;
  356. }
  358. //Commented by LiuHaifeng
  359. //When compile KavRunPlus, we must comment following
  361. int GetExitCommandLineParameter()
  362. {
  363. int nResult  = false;
  364.     int nRetCode = false;
  365.     CWinApp *pWinApp    = NULL;
  366.     char *pszParam      = NULL;
  367.     char *pszParamSet   = NULL;
  368.     char *pszPos        = NULL;
  369.     
  370.     pWinApp = ::AfxGetApp();
  371.     if (pWinApp == NULL)
  372.         goto Exit0;
  373.     
  374.     pszParamSet = pWinApp->m_lpCmdLine;
  375.     
  376.     while (pszParamSet)
  377.     {
  378.         pszParam = pszParamSet;
  379.         
  380.         pszPos = strchr(pszParamSet, ' ');
  381.         if (pszPos)
  382.         {
  383.             *pszPos = '';
  384.             pszParamSet = pszPos + 1; 
  385.         }
  386.         else 
  387.         {
  388.             pszParamSet = NULL;
  389.         }
  390.         
  391.         if ((*pszParam == '-') || (*pszParam == '/'))
  392.         {
  393.             pszParam++;
  394.             
  395.             nRetCode = stricmp(pszParam, "QUIT");
  396.             if (!nRetCode)
  397.             {
  398.                 nResult = TRUE;
  399.                 
  400.                 break;
  401.             }
  402.         }
  403.     }
  404.     
  405. Exit0:
  406.     
  407.     return nResult;
  408. }
  411. void StrAddStr(char szStr1[], const char cszStr2[])
  412. {
  413. char szTemp1[2048] = {0};
  414. char szTemp2[2048] = {0};
  416. strcpy(szTemp1, szStr1);
  417. strcpy(szTemp2, cszStr2);
  419. //Commented by LiuHaifeng
  420.     //When compile KavRunPlus, we must comment following
  421.     StrUpper(szTemp1);
  422. StrUpper(szTemp2);
  424. if (strstr(szTemp1, szTemp2) == NULL)
  425. strcat(szStr1, cszStr2);
  426. }
  429. int GetRegKeyValueByKey(HKEY hKey, const char cszRegKey[], const char cszKeyName[], char szValue[], int nSize)
  430. {
  431. HKEY Key;
  432. int nRetCode = -1;
  433. DWORD dwCount = nSize;
  434. LONG lRetCode = 0;
  436. lRetCode = RegOpenKeyEx(hKey, cszRegKey, 0, KEY_READ, &Key);
  437. if (ERROR_SUCCESS == lRetCode)
  438. {
  439. nRetCode = 0;
  440. lRetCode = RegQueryValueEx(Key, cszKeyName, NULL, NULL, (LPBYTE)szValue, &dwCount);
  441. if (ERROR_SUCCESS == lRetCode)
  442. nRetCode = 1;
  444. RegCloseKey(Key);
  445. }
  447. return nRetCode;
  448. }
  451. int GetRegKeyValue(const char cszRegKey[], const char cszKeyName[], char szValue[], int nSize)
  452. {
  453. int nRetCode = 0;
  455. nRetCode = GetRegKeyValueByKey(HKEY_CURRENT_USER, cszRegKey, cszKeyName, szValue, nSize);
  456. if (0 >= nRetCode)
  457. nRetCode = GetRegKeyValueByKey(HKEY_LOCAL_MACHINE, cszRegKey, cszKeyName, szValue, nSize);
  459. return nRetCode;
  460. }