Category

Development Platform
Home > SourceCode/Document > Game Program > Game Server Simulator > View Code
UpdatePublic.cpp
Package: SwordOnline.rar　[view]
Upload User: dzyhzl
Upload Date: 2019-04-29
Package Size: 56270k
Code Size: 35k
Category:

Game Server Simulator

Development Platform:

C/C++

UpdatePublic.cpp：Code Content
  1. //////////////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  FileName    :   UpdatePublic.cpp
  4. //  Version     :   1.0
  5. //  Creater     :   Cheng Bitao
  6. //  Date        :   2002-1-17 11:15:44
  7. //  Comment     :   Inplement the comment interface of update system
  8. //
  9. //////////////////////////////////////////////////////////////////////////////////////
  10.                         
  11. #include "Stdafx.h"    
  12. #include "Global.h"
  13. #include "UpdatePublic.h"
  14. #include "SaveLog.h"
  15. #include "UpdateSelf.h"
  17. #include "KAVStrTranslate.h"
  18. #include "GenKAVMoveProgram.h"
  19. #include "GetVersion.h"
  20. #include "GetFilesVersion.h"
  22. #include "PublicFun.h"
  23. #include "ProcessIndex.h"
  24. #include "UpdateData.h"
  25. #include "Resource.h"
  26. #include "SourceDef.h"
  28. CProcessIndex g_ProcessIndex;
  29. extern KUPDATE_DATA g_UpdateData;
  31. ///////////////////////////////////////////////////////////////////////////////
  32. //更新包合并 Add By Fellow 2003.08.11
  33. #define MAX_FILE 2004800 //最多20万个文件
  35. char temp_buffer[MAX_FILE] = {0};
  37. int getIndex(t_index_info* IndexList,int Count, unsigned long id)
  38. {//二分法找到指定的索引
  39. int nBegin, nEnd, nMid;
  40. nBegin = 0;
  41. nEnd = Count;
  42. while (nBegin <= nEnd) {
  43. nMid = (nBegin + nEnd) / 2;
  44. if (id == IndexList[nMid].id) break;
  45. if (id < IndexList[nMid].id) nEnd = nMid - 1;
  46. else nBegin = nMid + 1;
  47. }
  48. if(id != IndexList[nMid].id) return -1; //数据文件里面也没有
  49. return nMid;
  51. }
  52. void GetHeader(t_pack_header* aHeader, FILE* aFile)
  53. {
  54. fseek(aFile,0,SEEK_SET);
  55. fread(aHeader,1,sizeof(t_pack_header),aFile);
  56. }
  58. void GetIndexInfo(t_index_info* aIndexInfo, const t_pack_header* aHeader, FILE* aFile)
  59. {
  60. fseek(aFile,aHeader->index_offset,SEEK_SET);
  61. fread(aIndexInfo, sizeof(t_index_info), aHeader->count, aFile);
  62. }
  64. bool PackComb(const char* stdFilePath,const char* addFilePath)
  65. {//合并文件
  66. t_pack_header stdHeader;
  67. t_pack_header addHeader;
  68. unsigned long offset;
  69. t_index_info* stdIndex;
  70. t_index_info* addIndex;
  71. //打开资源源文件
  72. FILE* stdFile =NULL;
  73. stdFile = fopen(stdFilePath, "r+b");
  74. if(stdFile == NULL)
  75. {
  76. return false;
  77. }
  78. GetHeader(&stdHeader, stdFile);
  80. //打开资源新增加文件
  81. FILE* addFile =NULL;
  82. addFile = fopen(addFilePath, "rb");
  83. if(addFile == NULL)
  84. {
  85. return false;
  86. }
  87. GetHeader(&addHeader, addFile);
  89. stdIndex =  new t_index_info[stdHeader.count + addHeader.count];
  90. memset(stdIndex,0,sizeof(t_index_info) * (stdHeader.count + addHeader.count));
  91. GetIndexInfo(stdIndex, &stdHeader, stdFile);
  93. addIndex =  new t_index_info[addHeader.count];
  94. memset(addIndex,0,sizeof(t_index_info) * addHeader.count);
  95. //如果addFile里面没有需要增加的数据就直接完成
  96. if (addHeader.count == 0)
  97. {//关闭文件
  98. fclose(stdFile);
  99. fclose(addFile);
  100. return true;
  101. }
  102. GetIndexInfo(addIndex, &addHeader, addFile);
  104. //copy增加的数据到源文件中
  105. int DataSize = addHeader.index_offset - addHeader.data_offset;
  106. char* DataBuffer = new char[DataSize];
  107. fseek(addFile,addHeader.data_offset,SEEK_SET);
  108. fread(DataBuffer, 1, DataSize, addFile);
  110. fseek(stdFile,0,SEEK_END);
  111. offset = ftell(stdFile);
  112. char *ptr = DataBuffer;
  113. while(DataSize > 0) {
  114. int result;
  115. if(DataSize > 0x100000) result = fwrite(ptr ,1,0x100000,stdFile);
  116. else result = fwrite(ptr ,1, DataSize,stdFile);
  117. DataSize -= result;
  118. ptr += result;
  119. }
  120. //重新建立index
  121. int i,j;
  122. for(i = 0; i < addHeader.count; i++)
  123. {
  124. t_index_info* index = &addIndex[i];
  125. for(j = 0; j < stdHeader.count; j++) {
  126. if(index->id < stdIndex[j].id)
  127. { //索引排序
  128. memcpy(temp_buffer, (char *)&stdIndex[j], (stdHeader.count - j) * sizeof(t_index_info));
  129. memcpy((char *)&stdIndex[j + 1], temp_buffer, (stdHeader.count - j) * sizeof(t_index_info));
  130. //添加新索引
  131. memcpy(&stdIndex[j], index, sizeof(t_index_info));
  132. stdIndex[j].offset = offset + index->offset - sizeof(t_pack_header);
  133. ++stdHeader.count;
  134. break;
  135. }
  136. else if(index->id == stdIndex[j].id)
  137. { //新索引替换旧索引
  138. stdIndex[j].offset = offset + index->offset - sizeof(t_pack_header);
  139. stdIndex[j].size = index->size;
  140. stdIndex[j].compress_size = index->compress_size;
  141. break;
  142. }
  143. }
  144. if(j == stdHeader.count) {
  145. memcpy(&stdIndex[j], index, sizeof(t_index_info));
  146. stdIndex[j].offset = offset + index->offset - sizeof(t_pack_header);//Add By Fellow 09.04
  147. stdHeader.count++;
  148. }
  149. }
  151. //写入新的index
  152. fseek(stdFile,0,SEEK_END);
  153. offset = ftell(stdFile);
  154. fwrite(stdIndex,sizeof(t_index_info),stdHeader.count,stdFile);
  155. //写入header
  156. stdHeader.index_offset = offset;
  157. fseek(stdFile,0,SEEK_SET);
  158. fwrite(&stdHeader,sizeof(t_pack_header),1,stdFile);
  160. //关闭文件
  161. delete [] DataBuffer;
  162. delete [] stdIndex;
  163. delete [] addIndex;
  164. fclose(stdFile);
  165. fclose(addFile);
  166. return true;
  167. }
  169. ////////////////////////////////////////////////////////////////////////////////
  171. static int _SetRebootProcess_WINME()
  172. {
  173.     char szFileName[MAX_PATH]       = {0};
  174.     char szTempName[MAX_PATH]       = {0};
  175.     char szShortFileName[MAX_PATH]  = {0};
  176.     char szWinINIFileName[MAX_PATH] = {0};
  177.     
  178.     ::GetShortPathName(g_PathTable.szTempPath, szShortFileName, MAX_PATH);
  179.     strcat(szShortFileName, defUPDATE_FILE_EXE_FILE_NAME_ME);
  180.     strcpy(szFileName, szShortFileName);
  182.     if (!GenCopyFileProgram(szFileName))
  183.         return false;
  184.     
  185.     strcpy(szWinINIFileName, g_PathTable.szWindowsPath);
  186.     strcat(szWinINIFileName, "Win.ini");
  188.     ::WritePrivateProfileString("windows", "Run", szFileName, szWinINIFileName);
  190.     return true;
  191. }
  194. //--------------------------------------------------------------------------------------
  196. int ProcessIndexFile(const char cszFileName[])
  197. {
  198.     int nResult                     = false;
  199.     int nRetCode                    = 0;
  200.     char szIndexTxtFile[MAX_PATH]   = {0};
  201.     CString sLog                    = "";
  203.     if (g_UpdateData.nMethod == defUPDATE_METHOD_LAN)
  204.         strcpy(szIndexTxtFile, g_PathTable.szTempPath);
  205.     else
  206.         strcpy(szIndexTxtFile, g_PathTable.szDownloadDestPath);
  207.     strcat(szIndexTxtFile, defINDEX_TXT_FILE_NAME);
  209.     nRetCode = g_ProcessIndex.Init(cszFileName, szIndexTxtFile);
  210.     if (!nRetCode)
  211.     {
  212.         if (g_UpdateData.nMethod == defUPDATE_METHOD_LAN)
  213.             sLog = defIDS_ERROR_INDEX;
  214.         else 
  215.             sLog = defIDS_INDEX_ERROR;
  217.         g_UpdateData.SaveLog.WriteLogString(sLog, true);
  219.         goto Exit0;
  220.     }
  221.     
  222.     nRetCode = g_ProcessIndex.AnalysisUpdateFiles(        
  223.         g_UpdateData.nMethod,                  
  224.         g_UpdateData.szLocalPath, 
  225.         g_UpdateData.nMainVersion
  226.     );
  227.     if (!nRetCode)
  228.     {
  229.          if (g_UpdateData.nMethod == defUPDATE_METHOD_LAN)
  230.             sLog = defIDS_ERROR_INDEX;
  231.         else 
  232.             sLog = defIDS_INDEX_ERROR;
  234.         g_UpdateData.SaveLog.WriteLogString(sLog, true);
  236.         goto Exit0;
  237.     }
  238.   
  239. if(nRetCode ==defVersionNotenough || nRetCode ==defVersionMore)
  240. {
  241. return nRetCode;
  242. }
  244.     g_UpdateData.bNeedUpdateSelfFirst   = g_ProcessIndex.IsNeedUpdateSelf();
  245.     g_UpdateData.bVersionError      = g_ProcessIndex.IsVersionError();
  247.     g_UpdateData.sAnnounce      = g_ProcessIndex.GetAnnounce();
  248.     g_UpdateData.sReadme        = g_ProcessIndex.GetReadme();
  250.     // Count file size of Program or engie and sign or tools and help         
  252.     nResult = true;
  254. Exit0:    
  255.     return nResult;
  256. }
  258. //////////////////////////////////////////////////////////////////////////////////
  259. // Update file to local
  260. //////////////////////////////////////////////////////////////////////////////////
  261. int inline _GetTempFileName(char szFileName[])
  262. {
  263.     int i               = 0;
  264.     int nFileNameLen    = 0;
  265.     int nStrSize        = 0;
  266.     char *pszStr        = NULL;
  267.     int nRetCode        = 0;
  268.     
  269.     nFileNameLen    = strlen(szFileName);
  270.     pszStr          = szFileName + nFileNameLen;
  271.     nStrSize        = MAX_PATH - nFileNameLen;   
  273.     while (i < INT_MAX)
  274.     {
  275.         _IntToStr(i, nStrSize, pszStr);
  276.         nRetCode = FileExists(szFileName);
  277.         if (!nRetCode)
  278.             break;
  279.         i++;
  280.     }
  281.     
  282.     return true;
  283. }
  285. static int inline _GetOSPlatformVersion()
  286. {
  287.     OSVERSIONINFOEX     osVersionInfo;  
  288.     int nRetCode = 0;
  289.     int nResult  = -1;
  291.     ZeroMemory(&osVersionInfo, sizeof(OSVERSIONINFOEX));
  292.     osVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
  294.     nRetCode = ::GetVersionEx((OSVERSIONINFO *)&osVersionInfo);
  295.     if (!nRetCode)
  296.     {
  297.         osVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  298.         nRetCode = ::GetVersionEx((OSVERSIONINFO *)&osVersionInfo);
  299.         KAV_PROCESS_ERROR(nRetCode);
  300.     }
  301.   
  302.     switch(osVersionInfo.dwPlatformId)
  303.     {
  304.     case VER_PLATFORM_WIN32_NT:
  305.         nResult = defOSPLATFORM_WINNT;
  306.         break;
  307.     case VER_PLATFORM_WIN32_WINDOWS:
  308.         if (((osVersionInfo.dwBuildNumber >> 16) & 0x0000FFFF) < 0x045A)
  309.             nResult = defOSPLATFORM_WIN9598;
  310.         else 
  311.             nResult = defOSPLATFORM_WINME;
  312.         break;
  313.     default:
  314.         nResult = 0;
  315.         break;
  316.     }
  317.     
  318. Exit0:
  319.     return nResult;
  320. }
  322. int CloseProgram(const char cszFileName[])
  323. {
  324.     int nResult = false;
  325.     int nRetCode = 0;
  326.     KModuleExitInfo ModuleExitInfo;
  327.     KBaseClosedProgram *pClosedProgram = NULL;
  328.     KProcessInfo ProcessInfo;
  331.     ModuleExitInfo.nExitType = -1;
  332.     strcpy(ModuleExitInfo.szFileName, cszFileName);
  333.     ModuleExitInfo.uID = 0;
  334.     ModuleExitInfo.szStartParam[0] = '';
  335.     ModuleExitInfo.szStopParam[0] = '';
  336. ModuleExitInfo.szReleaseFileName[0] = '';
  338.     nRetCode = g_ProcessIndex.GetExitType(&ModuleExitInfo);    
  339.     KAV_PROCESS_ERROR(nRetCode);
  340.     
  341.     ProcessInfo.uID = ModuleExitInfo.uID;
  342.     strcpy(ProcessInfo.szFileName, ModuleExitInfo.szReleaseFileName);
  343.     strcpy(ProcessInfo.szStartParam, ModuleExitInfo.szStartParam);
  344.     strcpy(ProcessInfo.szCloseParam, ModuleExitInfo.szStopParam);
  347.     switch (ModuleExitInfo.nExitType)
  348.     {
  349.     case defEXIT_TYPE_DIRECTORY:
  350.         pClosedProgram = new KClosedProgram(ProcessInfo);
  351.         KAV_PROCESS_ERROR(pClosedProgram);   
  353.         break;
  355.     default:
  356.         goto Exit0;
  357.     }
  358.     
  359.     nRetCode = g_UpdateData.CloseProgramMgr.AddClosedProgram(pClosedProgram);
  360.     if (!nRetCode)
  361.     {
  362.         delete pClosedProgram;
  363.         pClosedProgram = NULL;
  364.     }
  365.     nResult = pClosedProgram->CloseProgram();
  366.     
  367. Exit0:
  368.     return nResult;
  369. }
  371. int CloseCalledPrograms(const char cszCallByNames[])
  372. {
  373.     char szCallBy[MAX_PATH] = {0};
  374.     char *pszCallBy = NULL;
  375.     char *pszTemp = NULL;
  376.     char *pszPointer = NULL;
  379.     strcpy(szCallBy, cszCallByNames);
  380.     pszTemp = szCallBy;
  382.     while (*pszTemp != '')
  383.     {
  384.         pszCallBy = pszTemp;
  385.         pszPointer = strchr(pszTemp, ',');
  386.         if (pszPointer)
  387.         {
  388.             pszTemp = pszPointer + 1;
  389.             *pszPointer = '';
  390.             CloseProgram(pszCallBy);  
  391.         }
  392.         else
  393.         {
  394.             CloseProgram(pszCallBy);
  395.             break;
  396.         }         
  397.     }   
  399.     return true;
  400. }
  402. BOOL AddRenameSectionContent(CString sPathName, CString sContent)
  403. {
  404.     CFile file;
  405.     CString sOld, sNew, sPart1, sPart2;
  407.     if (FileExists(sPathName))
  408.     {
  409.         if (file.Open(sPathName, CFile::modeRead | CFile::shareDenyNone))
  410.         {
  411.             int nLen = file.GetLength();
  412.             char *pBuf = new char [nLen + 1];
  414.             file.Read(pBuf, nLen);
  415.             pBuf[nLen] = '';
  417.             sOld = pBuf;
  418.             KAV_DELETE_ARRAY(pBuf);
  420.             file.Close();
  421.         }
  422.         else
  423.             return FALSE;
  424.     }
  425.     else
  426.     {
  427.         sOld = "";
  428.     }
  429.     CString sTemp = sOld;
  430.     CString sTemp2 = sContent;
  431.     
  432.     sTemp.MakeLower();
  433.     sTemp2.MakeLower();
  434.     
  435.     if (sTemp.Find(sTemp2) != -1)
  436.         return true;
  437.     
  438.     int nPos = sTemp.Find("[rename]rn");
  439.     if (nPos != -1)
  440.     {
  441.         sPart1 = sOld.Left(nPos + 10);
  442.         sPart2 = sOld.Mid(nPos + 10);
  443.         if (sContent.Right(2) != "rn")
  444.             sContent += "rn";
  446.         sNew = sPart1 + sContent + sPart2;
  447.     }
  448.     else
  449.     {
  450.         sPart1 = sOld;
  451.         sPart2 = "rn[rename]rn";
  452.         
  453.         sNew = sPart1 + sPart2 + sContent;
  454.     }
  456.     if (file.Open(sPathName, CFile::modeCreate | CFile::modeWrite))
  457.     {
  458.         file.Write(sNew, sNew.GetLength());
  460.         file.Close();
  461.     }
  462.     else
  463.         return FALSE;
  465.     return TRUE;
  466. }
  469. int KAVSetupInstallFile(const char cszCleanedFileName[], const char cszLockedFileName[])
  470. {
  471.     int nResult = false;
  472.     int nRetCode = false;
  473.     char szTempFileName[MAX_PATH] = {0};
  474.     char szTemp[MAX_PATH] = {0};
  475.     CString szWININITFileName;
  476.     char *pszPos = NULL;
  477.     CString szBuf;
  478.     char szCleanedFileShortName[MAX_PATH] = {0};
  479.     char szLockedFileShortName[MAX_PATH] = {0};
  481.     ::GetShortPathName(cszCleanedFileName, szCleanedFileShortName, MAX_PATH);
  482.     ::GetShortPathName(cszLockedFileName, szLockedFileShortName, MAX_PATH);
  484.     strcpy(szTempFileName, szLockedFileShortName);
  485.     pszPos = strrchr(szTempFileName, '.');
  486.     pszPos++;
  487.     *pszPos = '';
  488.     strcat(pszPos, "TMP");
  489.     
  490.     nRetCode = ::CopyFile(szCleanedFileShortName, szTempFileName, FALSE);
  491.     KAV_PROCESS_ERROR(nRetCode);
  492.     
  493.     szBuf = "";
  494.     szBuf += "NUL=" + (CString)szLockedFileShortName + "rn";
  495.     szBuf += (CString)szLockedFileShortName + "=" + (CString)szTempFileName + "rn";
  498.     ::GetShortPathName(g_PathTable.szWindowsPath, szTemp, MAX_PATH);
  499.     szWININITFileName = szTemp;
  500.     szWININITFileName += "Wininit.ini";
  502.     ::AddRenameSectionContent(szWININITFileName, szBuf);
  503.     
  504.     nResult = true;
  506. Exit0:
  507.     return nResult;
  508. }
  511. // cszDestFileName : Dest file name, need update
  512. // cszTempFileName : temp file
  513. int ProcessSharingFile(const char cszDestFileName[], const char cszTempFileName[])
  514. {
  515.     int nResult                         = false;
  516.     int nRetCode                        = 0;
  517.     char szLocalTempFileName[MAX_PATH]  = {0};
  518.     char szLockedFileShortName[MAX_PATH]= {0};
  519.     HANDLE hFile                        = INVALID_HANDLE_VALUE;
  520.     int nWritten                        = 0;
  521.     char szBuf[MAX_PATH]                = {0};
  522.     CString szCopyIniFileName;    
  523.     CFile File;
  524.     CString sAttrib_FileName;
  525.     CString sKAVMOVE_BAT_FileName;
  526.     CString sKAVMove_EXE_FileName;
  527.     CString sCleanedFileShortName;
  528.     CString sLockedFileShortName;
  529.     CString sExeFilePathShort;
  530.     CString sBuffer;
  531.     int nCount = 0;
  533.     if (g_UpdateData.nOSPlatVersion == -1)        // Get the operation system platform ID
  534.         g_UpdateData.nOSPlatVersion = _GetOSPlatformVersion();
  536.     switch (g_UpdateData.nOSPlatVersion)
  537.     {
  538.     case defOSPLATFORM_WINNT:                 // WINNT/Windows2000
  539.         nRetCode = ::SetFileAttributes(cszDestFileName, FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_NORMAL);
  540.         KAV_PROCESS_ERROR(nRetCode);
  541.         
  542.         strcpy(szLocalTempFileName, cszDestFileName);
  543.         _GetTempFileName(szLocalTempFileName); 
  544.         nRetCode = ::CopyFile(cszTempFileName, szLocalTempFileName, false);
  545.         KAV_PROCESS_ERROR(nRetCode);
  546.             
  547.         //::DeleteFile(cszTempFileName);
  549.         nRetCode = ::MoveFileEx(
  550.             szLocalTempFileName, cszDestFileName, 
  551.             MOVEFILE_REPLACE_EXISTING | MOVEFILE_DELAY_UNTIL_REBOOT
  552.         );
  553.         KAV_PROCESS_ERROR(nRetCode);
  555.         break;
  557.     case defOSPLATFORM_WIN9598:        // Windows 95/98/ME  
  558.     case defOSPLATFORM_WINME:          // Windows ME
  559.         if (strlen(strrchr(cszTempFileName, '\')) <= 13)
  560.         {
  561.             nRetCode = KAVSetupInstallFile(cszTempFileName, cszDestFileName);
  562.             KAV_PROCESS_ERROR(nRetCode);
  563.             break;
  564.         }
  566.         if (g_UpdateData.nOSPlatVersion == defOSPLATFORM_WIN9598)
  567.         {
  568.             ::SetFileAttributes(cszDestFileName, FILE_ATTRIBUTE_NORMAL);
  570.             ::GetShortPathName((CString)g_PathTable.szWindowsPath, szBuf, MAX_PATH);
  571.             sExeFilePathShort = szBuf;
  572.             sExeFilePathShort += "Command\";
  573.             sAttrib_FileName = sExeFilePathShort + "Attrib";
  575.             ::GetShortPathName(g_PathTable.szTempPath, szBuf, MAX_PATH);
  576.             AddPathChar(szBuf);
  577.             sExeFilePathShort = szBuf;
  578.             sKAVMOVE_BAT_FileName = sExeFilePathShort + defUPDATE_FILE_BAT_FILE_NAME;
  579.             sKAVMove_EXE_FileName = sExeFilePathShort + defUPDATE_FILE_EXE_FILE_NAME;             
  581.             if (!FileExists(sKAVMove_EXE_FileName))
  582.                 GenKAVMoveProgram(sKAVMove_EXE_FileName);
  584.             GetShortPathName(cszDestFileName, szBuf, MAX_PATH);
  585.             sLockedFileShortName = szBuf;
  587.             nRetCode = File.Open(sKAVMOVE_BAT_FileName, CFile::modeCreate | CFile::modeReadWrite | CFile::modeNoTruncate, NULL);
  588.             KAV_PROCESS_ERROR(nRetCode);
  590.             File.SeekToEnd();
  592.             ::GetShortPathName(cszTempFileName, szBuf, MAX_PATH);
  593.             sCleanedFileShortName = szBuf;
  595.             if (FileExists(sKAVMove_EXE_FileName))
  596.             {
  597.                 if (cszTempFileName[0] != '')
  598.                     sBuffer = "@if exist " + sKAVMove_EXE_FileName + " " + sKAVMove_EXE_FileName + " " + sCleanedFileShortName + " " + sLockedFileShortName + "rn";
  599.                 else 
  600.                     sBuffer = "@if exist " + sKAVMove_EXE_FileName + " " + sKAVMove_EXE_FileName + " " + sLockedFileShortName + "rn";
  601.             }
  602.             else
  603.             {
  604.                 if (cszTempFileName[0] != '')
  605.                 {
  606.                     sBuffer = "@if exist " + sLockedFileShortName + " " + sAttrib_FileName + " -s -h -r " + sLockedFileShortName + "rn";
  607.                     sBuffer += "@if exist " + sCleanedFileShortName + " copy /y " + sCleanedFileShortName + " " + sLockedFileShortName + "rn";
  608.                     sBuffer += "@if exist " + sCleanedFileShortName + " del " + sCleanedFileShortName + "rn";
  609.                 }
  610.                 else 
  611.                 {
  612.                     sBuffer = "if exist " + sLockedFileShortName + " " + sAttrib_FileName + " -s -h -r " + sLockedFileShortName + "rn";
  613.                     sBuffer += "@if exist " + sLockedFileShortName + " del " + sLockedFileShortName + "rn";
  614.                 }
  615.             }
  616.             nCount = sBuffer.GetLength();
  617.             File.Write(sBuffer, nCount);
  619.             File.Close();
  620.         }
  621.         else
  622.         {
  623.             ::SetFileAttributes(cszDestFileName, FILE_ATTRIBUTE_NORMAL);
  624.             szCopyIniFileName = (CString)g_PathTable.szTempPath + defUPDATE_FILES_INI_FILE_NAME;
  626.             strcpy(szLockedFileShortName, strrchr(cszDestFileName, '\') + 1);                
  627.             if (cszTempFileName)
  628.             {
  629.                 ::WritePrivateProfileString(szLockedFileShortName, "src", cszTempFileName, szCopyIniFileName);
  630.                 ::WritePrivateProfileString(szLockedFileShortName, "dst", cszDestFileName, szCopyIniFileName);
  631.             }
  632.             else 
  633.             {
  634.                 ::WritePrivateProfileString(szLockedFileShortName, "src", cszDestFileName, szCopyIniFileName);
  635.             }
  636.         }
  637.         
  638.         break;
  640.     }       // End of switch
  641.     
  642.     nResult = true;
  644. Exit0:    
  645.     return nResult;
  646. }
  648. int UpdateSelf()
  649. {
  650.     int nResult                         = false;
  651.     int nRetCode                        = 0;
  652.     char szUpdateSelfFile[MAX_PATH]     = {0};
  653.     char szUpdateSelfInfoFile[MAX_PATH] = {0};
  654.     char szParameter[MAX_PATH]          = {0};
  655.     char szDstFile[MAX_PATH]            = {0};
  656.     char szKeyName[30]                  = {0};
  657.     CString sLog                        = "";
  658.     PKUPDATE_ITEM pUpdateItem           = NULL;
  659.     int nNum                            = 0;
  662.     if (!g_UpdateData.bNeedUpdateSelfFirst)
  663.         goto Exit0;
  665.     // Get full path name for the Update Self information file
  666.     strcpy(szUpdateSelfInfoFile, g_PathTable.szDownloadDestPath);  
  667. MkDirEx(szUpdateSelfInfoFile);
  668.     strcat(szUpdateSelfInfoFile, defUPDATE_SELF_INFO_FILE);
  671.     // Delete the old information file
  672.     ::DeleteFile(szUpdateSelfInfoFile);
  673.     
  674.     nNum = 0;
  675.     pUpdateItem = g_ProcessIndex.m_pUpdateItemList;
  676.     while (pUpdateItem)
  677.     {
  678.         // Download temp file (srcfile)
  679.         sprintf(szKeyName, "SrcFile%d", nNum);
  680.         WritePrivateProfileString(
  681.             "UpdateSelf",
  682.         szKeyName,
  683.         pUpdateItem->szDownloadTmpFileName,
  684.         szUpdateSelfInfoFile
  685.         );
  686.         
  687.         //  DestFile
  688.         sprintf(szKeyName, "DesFile%d", nNum);
  689.         strcpy(szDstFile, pUpdateItem->szLocalPath);
  690.         strcat(szDstFile, pUpdateItem->szFileName);
  691.         WritePrivateProfileString(
  692.         "UpdateSelf",
  693.         szKeyName,
  694.         szDstFile,
  695.         szUpdateSelfInfoFile
  696.         );
  698.         pUpdateItem = pUpdateItem->pNext;
  699.         nNum++;
  700.     }
  702.     // Parameter
  703.     strcpy(szParameter, "/CONTINUE");
  704.     strcat(szParameter, " ");
  705.     strcat(szParameter, g_UpdateData.szParameter);
  706.     WritePrivateProfileString(
  707. "UpdateSelf",
  708. "Parameter",
  709. szParameter,
  710. szUpdateSelfInfoFile
  711.     );
  713.     strcpy(szDstFile, g_PathTable.szUpdateDestPath);
  714.     strcat(szDstFile, g_UpdateData.szExecuteProgram);
  715.     WritePrivateProfileString(
  716. "UpdateSelf",
  717. "FullPathName",
  718. szDstFile,
  719. szUpdateSelfInfoFile
  720.     );
  722.     // Create UpdateSelf.DAT file for Update self
  723.     strcpy(szUpdateSelfFile, g_PathTable.szDownloadDestPath);
  724.     strcat(szUpdateSelfFile, defUPDATE_SELF_FILE);
  725.     nRetCode = CreateUpdateSelfFile(szUpdateSelfFile);        
  726.     if (nRetCode)
  727. {
  728. sLog = defIDS_UPDATE_SELF_SUCCESS;
  729. nResult = true;
  730. }
  731.     else
  732. {
  733. sLog = defIDS_UPDATE_SELF_FAILED;
  734. }
  736.     g_UpdateData.SaveLog.WriteLogString(sLog, true);
  738. Exit0:
  740.     return nResult;
  741. }
  743. int UpdateFile_Copy(const KUPDATE_ITEM& UpdateItem)
  744. {
  745.     int nResult                         = false;
  746.     int nRetCode                        = false;
  747.     char szLocalFileName[MAX_PATH]      = {0};
  748.     char szLocalTempFileName[MAX_PATH]  = {0};
  749.     CString sLog;
  750.     CString sFormat;
  751.     DWORD dwFileAttribute               = 0;
  753.     strcpy(szLocalFileName, UpdateItem.szLocalPath);
  754.     strcat(szLocalFileName, UpdateItem.szFileName); 
  755.     MkDirEx(UpdateItem.szLocalPath);
  756. TRACE1("%s is copiedn", szLocalFileName);
  758.     dwFileAttribute = GetFileAttributes(szLocalFileName);
  759.     dwFileAttribute &= ~dwFileAttribute;
  760.     SetFileAttributes(szLocalFileName, dwFileAttribute);
  761. dwFileAttribute = GetFileAttributes(UpdateItem.szDownloadTmpFileName);
  762. dwFileAttribute &= ~dwFileAttribute;
  763. SetFileAttributes(UpdateItem.szDownloadTmpFileName, dwFileAttribute);
  765.     nRetCode = ::CopyFile(UpdateItem.szDownloadTmpFileName, szLocalFileName, false);
  766.     if (nRetCode)
  767.     {
  768.         nResult = CheckFileCRC(atoi(UpdateItem.szCRC), szLocalFileName);        
  769.         if (!nResult)
  770.         {
  771.             g_UpdateData.bUpdateFailed = true;
  772.             sFormat = defIDS_UPDATE_FAILED;
  773.             goto Exit0;
  774.         }
  775.         if (UpdateItem.nReboot)
  776.         {
  777.             g_UpdateData.bNeedRebootFalg = true;
  779.             sFormat = defIDS_NEED_RESET;
  780.         }
  781.         else
  782.         {
  783.             sFormat = defIDS_UPDATE_SUCCESS;
  784.         }     
  786. ::DeleteFile(UpdateItem.szDownloadTmpFileName);
  788.         goto Exit0;
  789.     }
  791.     // Update after reset computer 
  792.     strcpy(szLocalTempFileName, g_PathTable.szTempPath);
  793.     strcat(szLocalTempFileName, UpdateItem.szFileName);
  794.     _GetTempFileName(szLocalTempFileName);
  795.     nRetCode = ::CopyFile(UpdateItem.szDownloadTmpFileName, szLocalTempFileName, false);
  796.     if (!nRetCode)
  797.     {
  798.         sFormat = defIDS_COPY_TEMPFILE_FAILED;        
  799.         g_UpdateData.bUpdateFailed = true;
  800.         goto Exit0;
  801.     }
  802.     
  803.     nRetCode = ProcessSharingFile(szLocalFileName, szLocalTempFileName);
  804.     if (!nRetCode)
  805.     {
  806.         sFormat = defIDS_PROCESS_SHARING_FAILED;
  807.         
  808.         g_UpdateData.bUpdateFailed = true;
  809.         goto Exit0;
  810.     }
  811.     
  812.     nResult = CheckFileCRC(atoi(UpdateItem.szCRC), szLocalTempFileName);
  813.     if (!nResult)
  814.     {
  815.         g_UpdateData.bUpdateFailed = true;
  816.         sFormat = defIDS_UPDATE_FAILED;
  817.         goto Exit0;
  818.     }
  819.     
  820.     g_UpdateData.bRebootFinishUpdateFlag = true;
  822.     if (UpdateItem.nSharedNeedReboot || UpdateItem.nReboot)
  823.     {
  824.         sFormat = defIDS_UPDATE_SUCCESS_NEED_RESET;
  825.         g_UpdateData.bNeedRebootFalg = true;
  826.     }
  827.     else
  828.     {
  829.         sFormat = defIDS_UPDATE_SHARING_SUCCESS;
  830.     }    
  831.     
  833. Exit0:
  835.     sLog.Format(sFormat, UpdateItem.szFileName, UpdateItem.szLocalPath);
  836.     g_UpdateData.SaveLog.WriteLogString(sLog, true);
  838.     return nResult;
  839. }
  841. int UpdateFile_Package(const KUPDATE_ITEM& UpdateItem)
  842. {
  843. int nResult = false;
  845. char szLocalFileName[MAX_PATH]      = {0};
  846. DWORD dwFileAttribute               = 0;
  848. strcpy(szLocalFileName, UpdateItem.szLocalPath);
  849. strcat(szLocalFileName, UpdateItem.szFileName); 
  850. MkDirEx(UpdateItem.szLocalPath);
  851. TRACE1("%s is packagedn", szLocalFileName);
  853. dwFileAttribute = GetFileAttributes(szLocalFileName);
  854. dwFileAttribute &= ~dwFileAttribute;
  855. SetFileAttributes(szLocalFileName, dwFileAttribute);
  856. dwFileAttribute = GetFileAttributes(UpdateItem.szDownloadTmpFileName);
  857. dwFileAttribute &= ~dwFileAttribute;
  858. SetFileAttributes(UpdateItem.szDownloadTmpFileName, dwFileAttribute);
  860. if (FileExists(szLocalFileName))
  861. {
  862. typedef int (__stdcall *COMBINAPACKAGE)(const char*, char*);
  863. HMODULE hModule = LoadLibrary("ExpandPackage.dll");
  864. CString sFormat = defIDS_UPDATE_FAILED;
  865. if (hModule)
  866. {
  867. COMBINAPACKAGE pFunCombinaPackage = (COMBINAPACKAGE)GetProcAddress(hModule, "CombinatPackage");
  868. if (pFunCombinaPackage)
  869. {
  870. //nResult = pFunCombinaPackage(UpdateItem.szDownloadTmpFileName, szLocalFileName);
  871. nResult = PackComb(static_cast<const char *>(szLocalFileName),
  872. static_cast<const char *>(UpdateItem.szDownloadTmpFileName));
  873. if (!nResult)
  874. {
  875. g_UpdateData.bUpdateFailed = true;
  876. sFormat = defIDS_UPDATE_FAILED;
  877. }
  878. else
  879. {
  880. if (UpdateItem.nReboot)
  881. {
  882. g_UpdateData.bNeedRebootFalg = true;
  884. sFormat = defIDS_NEED_RESET;
  885. }
  886. else
  887. {
  888. sFormat = defIDS_UPDATE_SUCCESS;
  889. }
  890. ::DeleteFile(UpdateItem.szDownloadTmpFileName);
  891. }
  892. }
  894. ::FreeLibrary(hModule);
  895. }
  896. else
  897. {
  898. g_UpdateData.bUpdateFailed = true;
  899. sFormat = defIDS_UPDATE_FAILED;
  900. }
  902. CString sLog;
  903. sLog.Format(sFormat, UpdateItem.szDownloadTmpFileName, szLocalFileName);
  904. g_UpdateData.SaveLog.WriteLogString(sLog, true);
  905. }
  906. else
  907. {
  908. nResult = UpdateFile_Copy(UpdateItem);
  909. }
  911. return nResult;
  912. }
  914. int UpdateFile(KUPDATE_ITEM& UpdateItem)
  915. {
  916. char szMethod[MAX_PATH];
  917. strncpy(szMethod, UpdateItem.szUpdateFileMethod, MAX_PATH);
  918. char *pMethod = szMethod;
  919. int i = 0;
  920. int l = strlen(szMethod);
  921. while (i <= l)
  922. {
  923. if (szMethod[i] == ';' || szMethod[i] == 0)
  924. {
  925. *(pMethod + i) = 0;
  926. if (*pMethod == 0)
  927. break;
  928. if (strnicmp(pMethod, "Copy", 4) == 0)
  929. UpdateFile_Copy(UpdateItem);
  930. else if (strnicmp(pMethod, "Package", 7) == 0)
  931. {
  932. if (*(pMethod + 7) == '(')
  933. {
  934. int x = 8;
  935. while(*(pMethod + x) != ')')
  936. {
  937. UpdateItem.szFileName[x - 8] = *(pMethod + x);
  938. x++;
  939. }
  940. UpdateItem.szFileName[x - 8] = 0;
  941. }
  942. UpdateFile_Package(UpdateItem);
  943. }
  944. else
  945. ASSERT(0);
  947. pMethod = szMethod + i + 1;
  948. }
  949. i++;
  950. }
  951. return true;
  952. }
  955. int _DeleteSignFileInWin9X()
  956. {
  957.     int nRetCode = 0;
  958.     int nMaxSignFileNum = 0;
  959.     char szFileName[MAX_PATH];
  960.     char szShortFileName[MAX_PATH];
  961.     int nFileNameLen = 0;
  962.     CString sBuf;
  963.     int i;
  965.     // Delete redundent sign file
  966.     nMaxSignFileNum = GetLocalDatFileNumber();     // Get Max sign file number
  968.     strcpy(szFileName, g_PathTable.szUpdateDestPath);
  969.     strcat(szFileName, defBASE_SIGN_FILENAME);
  970.     nFileNameLen = strlen(szFileName);
  971.     nFileNameLen -= 9;
  972.     sBuf = "";
  973.     for (i = 0; i < nMaxSignFileNum; i++)
  974.     {
  975.         _IntToNStr(i, szFileName + nFileNameLen, 5);
  976.         nRetCode = FileExists(szFileName);
  977.         if (nRetCode)
  978.         {
  979.             ::GetShortPathName(szFileName, szShortFileName, MAX_PATH);
  980.             sBuf += "NUL=" + (CString)szShortFileName + "rn";            
  981.         } 
  982.     }
  984.     strcpy(szFileName, g_PathTable.szUpdateDestPath);
  985.     strcat(szFileName, defBASE_SIGN_UPDNAME);
  986.     nFileNameLen = strlen(szFileName);
  987.     nFileNameLen -= 9;
  989.     for (i = 0; i <= nMaxSignFileNum; i++)
  990.     {
  991.         _IntToNStr(i, szFileName + nFileNameLen, 5);
  992.         nRetCode = FileExists(szFileName);
  993.         if (nRetCode)
  994.         {
  995.             ::GetShortPathName(szFileName, szShortFileName, MAX_PATH);
  996.             sBuf += "NUL=" + (CString)szShortFileName + "rn"; 
  997.         }               
  998.     } 
  1000.     strcpy(szFileName, g_PathTable.szWindowsPath);
  1001.     strcat(szFileName, "Wininit.ini");
  1002.     ::GetShortPathName(szFileName, szShortFileName, MAX_PATH);
  1003.     
  1004.     VERIFY(AddRenameSectionContent(szShortFileName, sBuf));  
  1006.     return true;
  1007. }
  1009. static int _SetRebootProcess_WIN9X()
  1010. {
  1011.     int nRetCode = 0;
  1012.     DWORD dwFileLen = 0;
  1013.     CString sProcessFileArray[2];
  1014.     CString sExeFilePathShort;
  1015.     CString sKAVMOVE_BAT_FileName;
  1016.     CString sKAVMOVE_EXE_FileName;
  1018.     CString sCommandString;
  1019.     CString sStartFileStrings;
  1020.     CFile File;
  1021.     char szBuf[MAX_PATH];
  1022.     char *pszBuffer = NULL;
  1023.     HANDLE Handle = INVALID_HANDLE_VALUE;
  1025.     sProcessFileArray[0] = "C:\Autoexec.bat";
  1026.     sProcessFileArray[1] = (CString)g_PathTable.szWindowsPath + "WinStart.bat";
  1027.      
  1028.     ::GetShortPathName((CString)g_PathTable.szTempPath, szBuf, MAX_PATH);
  1029.     AddPathChar(szBuf);
  1030.     sExeFilePathShort       = szBuf;
  1031.     sKAVMOVE_BAT_FileName   = sExeFilePathShort + defUPDATE_FILE_BAT_FILE_NAME;
  1032.     sKAVMOVE_EXE_FileName   = sExeFilePathShort + defUPDATE_FILE_EXE_FILE_NAME;
  1034.     sCommandString = "rn@if exist " + sKAVMOVE_BAT_FileName + " call " + sKAVMOVE_BAT_FileName + "rn";
  1035.     sCommandString += "if exist " + sKAVMOVE_BAT_FileName + " del " + sKAVMOVE_BAT_FileName + "rn";
  1036.     sCommandString += "if exist " + sKAVMOVE_EXE_FileName + " del " + sKAVMOVE_EXE_FileName + "rn";
  1038.     if (!FileExists(sKAVMOVE_EXE_FileName))
  1039.         GenKAVMoveProgram(sKAVMOVE_EXE_FileName);
  1041.     for (int i = 0; i < 2; i++)
  1042.     {
  1043.         nRetCode = File.Open(sProcessFileArray[i], CFile::modeNoTruncate | CFile::modeCreate | CFile::modeReadWrite, NULL);
  1044.         if (nRetCode)
  1045.         {
  1046.             sStartFileStrings.Empty();
  1047.             dwFileLen = File.GetLength();
  1048.             if (dwFileLen > 0)
  1049.             {
  1050.                 pszBuffer = new char[dwFileLen + 1];
  1051.                 if (pszBuffer)
  1052.                 {
  1053.                     nRetCode = File.Read(pszBuffer, dwFileLen);
  1054.                     if ((DWORD)nRetCode == dwFileLen)
  1055.                         sStartFileStrings = pszBuffer;
  1057.                     KAV_DELETE_ARRAY(pszBuffer);
  1058.                 }
  1059.             }
  1060.             nRetCode = sStartFileStrings.Find(sCommandString, 0);
  1061.             if (nRetCode == -1)
  1062.             {
  1063.                 File.SeekToEnd();
  1064.                 File.Write(sCommandString, sCommandString.GetLength());
  1065.             }
  1067.             File.Close();
  1068.         }
  1069.     }   // End of for    
  1070.     
  1071.     return true;
  1072. }
  1075. void _DeleteSignFileInWinNT()
  1076. {
  1077.     int nRetCode                = 0;
  1078.     int nMaxSignFileNum         = 0;
  1079.     int i                       = 0;
  1080.     int nSignFileNum            = 0;
  1081.     int nFileNameLen            = 0;
  1082.     char szFileName[MAX_PATH]   = {0};
  1083.     char szTemp[MAX_PATH]       = {0};
  1084.     KUPDATE_ITEM *pUpdateItem   = NULL;
  1085.     CString szPathName;
  1087.     nMaxSignFileNum = GetLocalDatFileNumber();     // Get Max sign file number
  1089.     strcpy(szTemp, g_PathTable.szUpdateDestPath);
  1090.     ::GetShortPathName(szTemp, szFileName, MAX_PATH);
  1091.     strcat(szFileName, defBASE_SIGN_FILENAME);
  1092.     nFileNameLen = strlen(szFileName);
  1093.     nFileNameLen -= 9;
  1095.     for (i = 0; i < nMaxSignFileNum; i++)
  1096.     {
  1097.         _IntToNStr(i, szFileName + nFileNameLen, 5);
  1098.         nRetCode = FileExists(szFileName);
  1099.         if (nRetCode)
  1100.             ::MoveFileEx(szFileName, NULL, MOVEFILE_DELAY_UNTIL_REBOOT);
  1101.     }
  1103.     ::GetShortPathName(szTemp, szFileName, MAX_PATH);
  1104.     strcat(szFileName, defBASE_SIGN_UPDNAME);
  1105.     nFileNameLen = strlen(szFileName);
  1106.     nFileNameLen -= 9;
  1108.     for (i = 0; i <= nMaxSignFileNum; i++)
  1109.     {
  1110.         _IntToNStr(i, szFileName + nFileNameLen, 5);
  1111.         nRetCode = FileExists(szFileName);
  1112.         if (nRetCode)
  1113.             ::MoveFileEx(szFileName, NULL, MOVEFILE_DELAY_UNTIL_REBOOT);
  1114.     }
  1115. }
  1117. int UpdateFiles()
  1118. {
  1119.     KUPDATE_ITEM *pUpdateItem   = NULL;
  1120.     int nRetCode                = 1;
  1122.     if (g_UpdateData.bNeedUpdateSelfFirst)
  1123.     {
  1124.         nRetCode = UpdateSelf();         
  1125.         return nRetCode;
  1126.     }
  1128.     pUpdateItem = g_ProcessIndex.m_pUpdateItemList;
  1129. if (pUpdateItem) // Close program before update file
  1130. CloseCalledPrograms(g_ProcessIndex.m_szCallBy);
  1132. KUPDATE_ITEM *pLastUpdateItem  = NULL;
  1134.     while (pUpdateItem)
  1135.     {
  1136.         if (
  1137.             (pUpdateItem->DownloadStatus == enumDOWNLOADSTATUS_DOWNLOADED) &&
  1138.             pUpdateItem->bNeedUpdate
  1139.         )
  1140. {
  1141. if (strnicmp(pUpdateItem->szUpdateFileMethod, "Last;", 5) == 0 &&
  1142. pLastUpdateItem == NULL) //the first last copy
  1143. {
  1144. pLastUpdateItem = pUpdateItem;
  1145. memmove(pLastUpdateItem->szUpdateFileMethod, pLastUpdateItem->szUpdateFileMethod + 5, MAX_PATH - 5);
  1146. }
  1147.             else if (!UpdateFile(*pUpdateItem))
  1148. nRetCode = 0;
  1149. }
  1151.         pUpdateItem = pUpdateItem->pNext;
  1152.     }
  1154. if (pLastUpdateItem && !g_UpdateData.bUpdateFailed)
  1155. {
  1156. if (!UpdateFile(*pLastUpdateItem))
  1157. nRetCode = 0;
  1158. }
  1160.     if (g_UpdateData.bRebootFinishUpdateFlag)
  1161.     {
  1162.         if ((g_UpdateData.nOSPlatVersion == defOSPLATFORM_WIN9598) || 
  1163.             (g_UpdateData.nOSPlatVersion == defOSPLATFORM_WINME)
  1164.         )
  1165.         {
  1166.             if (g_UpdateData.nOSPlatVersion == defOSPLATFORM_WIN9598)
  1167.                 _SetRebootProcess_WIN9X();
  1168.             else
  1169.                 _SetRebootProcess_WINME();
  1170.         }
  1171.     }
  1173.     return nRetCode;
  1174. }
  1176. int GetHostURL(const char cszFileName[], const char cszHostName[], char szHostURL[])
  1177. {
  1178. CStdioFile file;
  1179. int nResult = false;
  1182. if (file.Open(cszFileName, CFile::modeRead | CFile::typeText))
  1183. {
  1184. CString sName, sAddress;
  1186. while (file.ReadString(sName))
  1187. {
  1188. sName.TrimLeft();
  1189. sName.TrimRight();
  1191. if (sName == "")
  1192. continue;
  1194.             while (file.ReadString(sAddress))
  1195. {
  1196. sAddress.TrimLeft();
  1197. sAddress.TrimRight();
  1199. if (sAddress == "")
  1200. continue;
  1202. if (stricmp(cszHostName, sName) == 0)
  1203. {
  1204. strcpy(szHostURL, sAddress);
  1205. nResult = true;
  1206. break;
  1207. }
  1209.                 break;
  1210. }
  1211. }
  1213. file.Close();
  1214. } 
  1216. return nResult;
  1217. }