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

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

模拟服务器

开发平台：

C/C++

LoadHostList.cpp：源码内容
  1. //////////////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  FileName    :   LoadHostList.cpp
  4. //  Version     :   1.0
  5. //  Creater     :   Cheng Bitao
  6. //  Date        :   2002-1-7 16:26:05
  7. //  Comment     :   
  8. //
  9. //////////////////////////////////////////////////////////////////////////////////////
  11. #include "stdafx.h"
  12. #include "LoadHostList.h"
  13. #include "PublicFun.h"
  14. #include "Global.h"
  15. #include "DataDefine.h"
  16. #include "Resource.h"
  17. #include "UpdateData.h"
  19. extern KPATH_TABLE g_PathTable;
  20. extern KUPDATE_DATA g_UpdateData;
  22. int KHostList::SaveHostListFileInfo(const char cszDestFileName[], const char cszSrcFileName[])
  23. {
  24.     char szFileName[MAX_PATH]   = {0};
  25.     char szCRC32[20]            = {0};
  26.     UINT uCRC32                 = 0;
  27.     
  28.     strcpy(szFileName, g_PathTable.szModulePath);
  29.     strcat(szFileName, cszSrcFileName);
  30.     uCRC32 = GetFileCRC(szFileName);
  31.     sprintf(szCRC32, "%d", uCRC32);
  32.     WritePrivateProfileString(cszSrcFileName, "CRC32", szCRC32, cszDestFileName);
  33.  
  34.     return true;
  35. }
  37. int KHostList::IsHostListFileChanged(const char cszDestFileName[], const char cszSrcFileName[])
  38. {
  39.     char szFileName[MAX_PATH]   = {0};
  40.     int nRetCode                = 0;
  41.     UINT uCRC32                 = 0;
  42.     
  43.     strcpy(szFileName, g_PathTable.szModulePath);
  44.     strcat(szFileName, cszSrcFileName);
  45.     uCRC32 = GetPrivateProfileInt(cszSrcFileName, "CRC32", 0, cszDestFileName);
  47.     if (!FileExists(szFileName) && uCRC32)
  48.         return true;
  49.    
  50.     nRetCode = CheckFileCRC(uCRC32, szFileName);
  51.     if (nRetCode)
  52.         return false;
  53.     
  54.     return true;
  55. }
  57. void KHostList::AddHostList(KHOST_LIST *pSrcHostList, KHOST_LIST **ppDestHostList)
  58. {
  59.     KHOST_LIST *pHostList = NULL;
  61.     if (!ppDestHostList || !pSrcHostList)
  62.         return;
  64.     if ((*ppDestHostList) == NULL)
  65.     {
  66.         *ppDestHostList = pSrcHostList;
  67.     }
  68.     else
  69.     {
  70.         pHostList = *ppDestHostList;
  71.         while (pHostList->pNext)
  72.             pHostList = pHostList->pNext;
  74.         pHostList->pNext = pSrcHostList;        
  75.     }
  76. }
  78. int KHostList::LoadOrdHostList(const char cszFileName[], KHOST_LIST **ppListHost)
  79. {
  80.     int nResult = 0;
  81.     int i;
  82.     char szHostURLKey[10]       = {0};
  83.     char szHostNameKey[10]      = {0};
  84.     char szIndexKey[10]         = {0};
  85.     char szHostURL[MAX_PATH]    = {0};
  86.     char szHostName[MAX_PATH]   = {0};
  87.     int nIndex                  = 0;
  88.     DWORD dwSize                = 0;
  89.     DWORD dwRetCode             = 0;
  90.     KHOST_LIST *pHostNode       = NULL;
  93.     KAV_PROCESS_ERROR(ppListHost);        
  95.     if (FileExists(cszFileName))
  96.     {
  97.         for (i = 0; ; i++)
  98.         {
  99.             sprintf(szHostURLKey, "URL%d", i);
  100.             sprintf(szHostNameKey, "Name%d", i);
  101.             sprintf(szIndexKey, "Index%d", i);
  103.             dwSize = MAX_PATH;
  104.             dwRetCode = GetPrivateProfileString("HostList", szHostURLKey, "", szHostURL, dwSize, cszFileName);                    
  105.             if (*szHostURL == '')
  106.                 break;
  108.             dwSize = MAX_PATH;
  109.             dwRetCode = GetPrivateProfileString("HostList", szHostNameKey, "", szHostName, dwSize, cszFileName);
  110.             if (*szHostName == '')
  111.                 break;
  113.             nIndex = GetPrivateProfileInt("HostList", szIndexKey, 0, cszFileName);
  115.             // add to the list
  116.             pHostNode = new KHOST_LIST;
  117.             KAV_PROCESS_ERROR(pHostNode);
  118.             
  119.             pHostNode->nIndex = nIndex;
  120.             strcpy(pHostNode->szName, szHostName);
  121.             strcpy(pHostNode->szURL, szHostURL);
  122.             pHostNode->pNext = NULL;
  124.             AddHostList(pHostNode, ppListHost);
  126.             pHostNode = NULL;
  127.         }   
  128.     }
  130.     nResult = true;
  131. Exit0:
  132.     return nResult;
  133. }
  135. int KHostList::LoadSrcHostList(const char cszFileName[], KHOST_LIST **ppHostList)
  136. {
  137.     int nResult             = false;
  138.     CString szDubaUpdateName;
  139.     CString sPathName;
  140.     CStdioFile file;
  141.     KHOST_LIST *pHostNode   = NULL;
  143.     KAV_PROCESS_ERROR(ppHostList);
  145. // Read host information from Update.svr or Update.ext
  146.     if (g_PathTable.szModulePath[0] == '')
  147.         goto Exit0;
  149. sPathName = (CString)g_PathTable.szModulePath + cszFileName;
  150. if (!FileExists(sPathName))
  151.     {
  152.         if (stricmp(cszFileName, defHOST_LIST_FILE_EXT) != 0)
  153.         {
  154.             // Default Host
  155.             pHostNode = new KHOST_LIST;
  156.             KAV_PROCESS_ERROR(pHostNode);
  158.             pHostNode->pNext = NULL;
  159.             pHostNode->nIndex = -1;
  160.             strcpy(pHostNode->szName, g_UpdateData.szDefHostName);
  161.             strcpy(pHostNode->szURL, g_UpdateData.szDefHostURL);
  162.             
  163.             AddHostList(pHostNode, ppHostList);            
  164.         }
  165.         goto Exit1;
  166.     }         
  168. if (file.Open(sPathName, CFile::modeRead | CFile::typeText))
  169. {
  170. CString sName, sAddress;
  171.         int nIndex = 0;
  173. while (file.ReadString(sName))
  174. {
  175. sName.TrimLeft();
  176. sName.TrimRight();
  178. if (sName == "")
  179. continue;
  181.             while (file.ReadString(sAddress))
  182. {
  183. sAddress.TrimLeft();
  184. sAddress.TrimRight();
  186. if (sAddress == "")
  187. continue;
  189. pHostNode = new KHOST_LIST;
  190.                 KAV_PROCESS_ERROR(pHostNode);
  192.                 pHostNode->pNext = NULL;
  193.                 pHostNode->nIndex = -1;
  194.                 strcpy(pHostNode->szName, sName);
  195.                 strcpy(pHostNode->szURL, sAddress);
  197.                 AddHostList(pHostNode, ppHostList);            
  198.                 
  199.                 break;
  200. }
  201.             nIndex++;
  202. }
  204. file.Close();
  205. } 
  207. Exit1:
  208.     nResult = true;
  210. Exit0:
  211.     return nResult;
  212. }
  214. void KHostList::ReleaseHostList(KHOST_LIST **ppHostList)
  215. {
  216.     KHOST_LIST *pHostList = NULL;
  218.     if (ppHostList == NULL)
  219.         return;
  221.     pHostList = *ppHostList;
  222.     while (pHostList)
  223.     {
  224.         *ppHostList = (*ppHostList)->pNext;
  225.         delete pHostList;
  226.         
  227.         pHostList = *ppHostList;
  228.     }   
  230.     *ppHostList = NULL;
  231. }   
  233. KHostList::KHostList()
  234. {
  235.     m_nSVRChangedFlag   = 0;
  236.     m_nEXTChangedFlag   = 0;
  237.     *m_szFileName       = '';
  238.     m_pHostList         = NULL;
  239. }
  241. KHostList::KHostList(const char cszFileName[])
  242. {
  243.     LoadList(cszFileName);
  244. }
  246. KHostList::~KHostList()
  247. {
  248.     ReleaseList();
  249. }
  251. void KHostList::ReleaseList()
  252. {
  253.     ReleaseHostList(&m_pHostList);   
  254. }                
  256. int KHostList::LoadList(const char cszFileName[])
  257. {
  258.     strcpy(m_szFileName, cszFileName);
  259.     m_nSVRChangedFlag = IsHostListFileChanged(m_szFileName, defHOST_LIST_FILE_SVR);
  260.     m_nEXTChangedFlag = IsHostListFileChanged(m_szFileName, defHOST_LIST_FILE_EXT);
  262.     return LoadList();
  263. }
  265. int KHostList::LoadList()
  266. {
  267.     int nResult                 = false;
  268.     KHOST_LIST *pHostNode       = NULL;
  269.     KHOST_LIST *pHostList       = NULL;
  270.     KHOST_LIST *pOrdHostList    = NULL;
  271.     KHOST_LIST *pOrdHostNode    = NULL;
  272.     KHOST_LIST *pSrcHostList    = NULL;
  273.     int nRetCode                = 0;
  275.     
  276.     ReleaseList();
  278.     if (m_nSVRChangedFlag || m_nEXTChangedFlag)
  279.     {
  280.         nRetCode = LoadSrcHostList(defHOST_LIST_FILE_SVR, &m_pHostList);
  281.         KAV_PROCESS_ERROR(nRetCode);
  282.         nRetCode = LoadSrcHostList(defHOST_LIST_FILE_EXT, &m_pHostList);
  283.         KAV_PROCESS_ERROR(nRetCode);
  285.         nRetCode = LoadOrdHostList(m_szFileName, &pOrdHostList);
  286.         KAV_PROCESS_ERROR(nRetCode);
  288.         if (pOrdHostList)
  289.         {
  290.             pHostList = m_pHostList;
  291.             while (pHostList)
  292.             {
  293.                 pOrdHostNode = pOrdHostList;
  294.                 while (pOrdHostNode)
  295.                 {
  296.                     if (stricmp(pHostList->szURL, pOrdHostNode->szURL) == 0)
  297.                     {
  298.                         pHostList->nIndex = pOrdHostNode->nIndex;
  299.                         break;
  300.                     }
  301.                     pOrdHostNode = pOrdHostNode->pNext;
  302.                 }
  304.                 pHostList = pHostList->pNext;
  305.             }
  307.             ReleaseHostList(&pOrdHostList);
  308.         }
  309.     }
  310.     else
  311.     {
  312.         nRetCode = LoadOrdHostList(m_szFileName, &m_pHostList);
  313.         KAV_PROCESS_ERROR(nRetCode);
  314.     }
  316.     nResult = true;
  317. Exit0:
  318.     return nResult;
  319. }
  322. void KHostList::AddList(KHOST_LIST *pHostNode)
  323. {
  324.     AddHostList(pHostNode, &m_pHostList);
  325. }
  327. int KHostList::SaveList(char *pszFileName /* = NULL */)
  328. {
  329.     char *pszSaveFileName   = NULL;
  330.     KHOST_LIST *pHostList   = NULL;
  331.     char szHostURLKey[10]   = {0};
  332.     char szHostNameKey[10]  = {0};
  333.     char szIndexKey[10]     = {0};
  334.     char szIndex[10]        = {0};    
  335.     int i;
  338.     pszSaveFileName = pszFileName;
  339.     if (pszSaveFileName == NULL)
  340.         pszSaveFileName = m_szFileName;
  342.     DeleteFile(pszSaveFileName);
  344.     SaveHostListFileInfo(pszSaveFileName, defHOST_LIST_FILE_SVR);
  345.     SaveHostListFileInfo(pszSaveFileName, defHOST_LIST_FILE_EXT);
  347.     i = 0;
  348.     pHostList = m_pHostList;    
  349.     while (pHostList)
  350.     {
  351.         sprintf(szHostURLKey, "URL%d", i);
  352.         sprintf(szHostNameKey, "Name%d", i);
  353.         sprintf(szIndexKey, "Index%d", i);
  354.         
  355.         WritePrivateProfileString("HostList", szHostNameKey, pHostList->szName, pszSaveFileName);
  356.         WritePrivateProfileString("HostList", szHostURLKey, pHostList->szURL, pszSaveFileName);
  357.         sprintf(szIndex, "%d", pHostList->nIndex);
  358.         WritePrivateProfileString("HostList", szIndexKey, szIndex, pszSaveFileName);
  360.         i++;
  361.         pHostList = pHostList->pNext;        
  362.     }
  364.     return true;
  365. }
  367. int KHostList::IsHostListChanged()
  368. {
  369.     return (m_nSVRChangedFlag || m_nEXTChangedFlag);
  370. }