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

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

模拟服务器

开发平台：

C/C++

UpdateDLLImplement.cpp：源码内容
  1. //////////////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  FileName    :   UpdateDLLImplement.cpp
  4. //  Version     :   1.0
  5. //  Creater     :   Cheng Bitao
  6. //  Date        :   2002-9-25 15:43:50
  7. //  Comment     :   
  8. //
  9. //////////////////////////////////////////////////////////////////////////////////////
  10. #include "Stdafx.h"
  11. #include "UpdateDll.h"
  12. #include "UpdateData.h"
  13. #include "UpdateExport.h"
  15. #include "Global.h"
  16. #include "ProxyUtility.h"
  17. #include "publicfun.h"
  18. #include "UserCheck.h"
  19. #include "Sourcedef.h"
  21. extern KUPDATE_DATA g_UpdateData;
  22. extern CProcessIndex g_ProcessIndex;
  25. static const char *g_pszCheckHostArray[]= {
  26.     "www.duba.net",
  27.     "gz3.duba.net",
  28. "gz.duba.net",
  29.     "sh.duba.net",
  30.     "bj.duba.net",
  31.     "gz2.duba.net",
  32. "gz4.duba.net"
  34. };
  35. static const int   g_nCheckPortArray[]  = {
  36.     defCHECK_SERVER_PORT,
  37.     defCHECK_SERVER_PORT,
  38.     defCHECK_SERVER_PORT,
  39.     defCHECK_SERVER_PORT,
  40.     defCHECK_SERVER_PORT,
  41. defCHECK_SERVER_PORT,
  42. defCHECK_SERVER_PORT
  44. };
  46. static const int g_nCheckServerCount = sizeof(g_pszCheckHostArray)/sizeof(const char *);
  49. int CUpdateDLLApp::Init(CONST KUPDATE_SETTING& UpdateSetting)
  50. {
  51. int nRetCode = 0;  
  52.     RECT rect = { 0, 0, 100, 20};
  53. WORD wVersionRequested = 0;
  54. WSADATA wsaData         = {0};    
  55.     
  56.     m_pfnCallBackProc = UpdateSetting.pfnCallBackProc;
  57.     if (m_pfnCallBackProc)
  58.     {
  59.         m_pfnCallBackProc(defUPDATE_STATUS_INITIALIZING, 0);
  60.     }
  62. nRetCode = InitPaths();
  63. if (!nRetCode)
  64. {
  65. m_nResultCode = defUPDATE_RESULT_INIT_FAILED;
  66. goto Exit0;
  67. }
  68.      // get sock version
  69.     wVersionRequested = MAKEWORD(2, 2);
  70.     nRetCode = WSAStartup(wVersionRequested, &wsaData);
  71.     if (0 == nRetCode)
  72.     {
  73.         m_nInitWSA = true;
  74.     }
  75.     else
  76.     {
  77.         m_nResultCode = defUPDATE_RESULT_LOAD_SOCKET_ERROR;
  78.         goto Exit0;
  79.     }
  80.     InitUpdateData(UpdateSetting.bLog);
  82.     g_UpdateData.nMainVersion = UpdateSetting.nVersion;
  83.     g_UpdateData.nMethod = UpdateSetting.nUpdateMode;
  84.     strcpy(g_UpdateData.szHostURL, UpdateSetting.szUpdateSite);
  85.     strcpy(g_UpdateData.szDefHostURL, UpdateSetting.szUpdateSite);
  86.     g_UpdateData.ulTryTimes = UpdateSetting.ulTryTimes;
  87.     g_UpdateData.bAutoTryNextHost = UpdateSetting.bAutoTryNextHost;
  88.     g_UpdateData.bUseFastestHost = UpdateSetting.bUseFastestHost;
  89.     g_UpdateData.bUseVerify = UpdateSetting.bUseVerify;
  90.     strcpy(g_UpdateData.szVerifyInfo, UpdateSetting.szVerifyInfo);
  91.     // Setting the proxy setting
  92.     g_UpdateData.ProxySetting.nProxyMethod  = UpdateSetting.ProxySetting.nProxyMethod;
  93.     g_UpdateData.ProxySetting.nHostPort     = UpdateSetting.ProxySetting.nHostPort;
  94.     strcpy(g_UpdateData.ProxySetting.szHostAddr, UpdateSetting.ProxySetting.szHostAddr);
  95.     strcpy(g_UpdateData.ProxySetting.szPassword, UpdateSetting.ProxySetting.szPassword);
  96.     strcpy(g_UpdateData.ProxySetting.szUserName, UpdateSetting.ProxySetting.szUserName);
  97.     // setting the download destination directory
  98.     strcpy(g_PathTable.szDownloadDestPath, UpdateSetting.szDownloadPath);        
  99.     strcpy(g_UpdateData.szLocalPath, UpdateSetting.szDownloadPath);
  100.     // INitialize the Update destionation directory
  101.     strcpy(g_PathTable.szUpdateDestPath, UpdateSetting.szUpdatePath);
  103. strcpy(g_UpdateData.szExecuteProgram, UpdateSetting.szMainExecute);
  104.         
  105.     CDownNotify::SetNotifyMessage(WM_DOWNNOTIFY_DEFAULT);
  106.     
  107.     m_hExitNotify = CreateEvent(NULL, TRUE, FALSE, NULL);
  108.     
  109.     nRetCode = m_wndMessage.Create(
  110.         ::AfxRegisterWndClass(
  111.             CS_DBLCLKS | CS_VREDRAW,
  112.             0,
  113.             (HBRUSH)::GetStockObject(BLACK_BRUSH)),
  114.         "KingSoft Update Notify Window",
  115.         WS_OVERLAPPEDWINDOW & ~WS_VISIBLE,
  116.         rect,
  117.         CWnd::GetDesktopWindow(),
  118.         NULL
  119.     );
  120.     if (!nRetCode) 
  121.         goto Exit0; 
  122.     m_wndMessage.ShowWindow(SW_HIDE);
  123.     m_wndMessage.UpdateWindow();
  124.     
  125.     m_nInitFlag = true;
  126.     m_nResultCode = defUPDATE_RESULT_INIT_SUCCESS;
  127. if (m_pfnCallBackProc)
  128.     {
  129.         m_pfnCallBackProc(defUPDATE_STATUS_INITIALIZING, 100);
  130.     }
  131.     
  132. Exit0:
  133. return m_nResultCode;
  134. }
  136. int CUpdateDLLApp::UnInit()
  137. {
  138.     if (m_wndMessage.GetSafeHwnd() != NULL)
  139.         DestroyWindow(m_wndMessage.GetSafeHwnd());
  140.     
  141.     CDownNotify::SetNotifyMessage(0);
  142.     
  143.     if (m_hExitNotify != NULL)
  144.     {
  145.         CloseHandle(m_hExitNotify);
  146.         m_hExitNotify = NULL;
  147.     }
  149. if (m_nInitWSA)
  150.     {
  151.         WSACleanup();
  152.         m_nInitWSA = false;
  153.     }
  155.     UnInitCheckThread();
  157. return true;
  158. }
  160. int CUpdateDLLApp::UserVerify()
  161. {
  162.    int nRetCode = false;
  163.     int i = 0;
  165.     if (!m_nInitFlag)
  166. return defUPDATE_RESULT_INIT_FAILED;
  168.     if (!g_UpdateData.bUseVerify)
  169. {
  170. m_nResultCode = defUPDATE_RESULT_USER_VERIFY_SUCCESS;
  171. goto Exit1;
  172. }
  174.     if (m_bCheckUserOK)
  175.     {
  176.         m_nResultCode = defUPDATE_RESULT_USER_VERIFY_SUCCESS;
  177.         goto Exit1;
  178.     } 
  179.     
  180.     /*for (i = 0; i < g_nCheckServerCount; i++)
  181.     {
  182.         nRetCode = m_CheckThread.AddCheckServer(
  183.             g_pszCheckHostArray[i],
  184.             g_nCheckPortArray[i]
  185.         );
  186.         ASSERT(nRetCode);
  187.     }*/
  188.     
  189.     nRetCode = m_CheckThread.SetCheckCallback((IKCheckCallback *)this, 0);
  190.     ASSERT(nRetCode);
  192.     m_DownloadFile.SetNotifyWnd(m_wndMessage, WM_DOWNNOTIFY_DEFAULT);
  193.     nRetCode = SetDownloadProxy(m_DownloadFile, g_UpdateData.szHostURL);
  194.     if (nRetCode)
  195.         m_nProcessStep = DOWNINDEX_STEPCHKSNHTTP;
  196.     else
  197.     {
  198.         m_nProcessStep = DOWNINDEX_STEPCHKSNUDP;
  199.     
  200.         nRetCode = InitCheckThread();
  201.         if (!nRetCode)
  202.         {
  203.             m_nResultCode = defUPDATE_RESULT_USER_VERIFY_FAILED;
  204.             goto Exit1;
  205.         }
  206.     } 
  208.     ProcessNextStep(m_nProcessStep);
  210. Exit1:
  211.     return m_nResultCode;
  212. }
  214. int CUpdateDLLApp::CheckNeedUpdate()
  215. {
  216. char szFileName[MAX_PATH] = {0};
  217.     
  218.     int nRetCode = 0;
  219.     ULONG ulResult = 0;
  220.     
  221.     MSG stMsg = { 0 };
  222.     HWND hWnd = m_wndMessage.m_hWnd;
  223.     
  224. if (!m_nInitFlag)
  225. return defUPDATE_RESULT_INIT_FAILED;
  227.     if (g_UpdateData.nMethod == defUPDATE_METHOD_LAN)
  228.     {
  229. m_strIndexTempFile = (CString)g_PathTable.szDownloadDestPath + defINDEX_FILE_NAME;
  230.         nRetCode = ::ProcessIndexFile(m_strIndexTempFile);
  231. if (!nRetCode)
  232. {
  233. m_nResultCode = defUPDATE_RESULT_PROCESS_INDEX_FAILED;
  234. goto Exit0;
  235. }
  236. if(nRetCode == defVersionNotenough)
  237. {
  238. m_nResultCode = defUPDATE_RESULT_VERSION_NOT_ENOUGH;
  239. goto Exit0;
  241. }
  243.         m_nResultCode = defUPDATE_RESULT_PROCESS_INDEX_SUCCESS;
  244.         
  245. if (g_ProcessIndex.IsNotUpdateItem())
  246. m_nResultCode = defUPDATE_RESULT_NOT_UPDATE_FILE;
  247.         
  248.         goto Exit0;
  249.     }
  251.     m_nResultCode = defUPDATE_RESULT_DOWNLOAD_INDEX_FAILED;
  252.     
  253. ResetEvent(m_hExitNotify);
  254. // Download Index.dat
  255.     m_DownloadFile.SetNotifyWnd(m_wndMessage, WM_DOWNNOTIFY_DEFAULT);
  256.     SetDownloadProxy(m_DownloadFile, g_UpdateData.szHostURL);
  257. nRetCode = ProcessNextStep(DOWNINDEX_STEPINDEX);
  258. if (!nRetCode)
  259.     {
  260.         m_nResultCode = defUPDATE_RESULT_DOWNLOAD_INDEX_FAILED;
  261.         goto Exit0;
  262.     }
  263.     
  264.     do
  265.     {
  266.         nRetCode = ::WaitForSingleObject(m_hExitNotify, 0);
  267.         if (WAIT_OBJECT_0 == nRetCode)
  268.             break;
  269.         
  270.         nRetCode = ::PeekMessage(&stMsg, NULL, 0, 0, PM_REMOVE);
  271.         if (0 == nRetCode)
  272.             continue;
  273.         
  274.         if (WM_QUIT == stMsg.message)
  275.             break;
  276.         
  277.         if (-1 == nRetCode)
  278.         {
  279.             // handle the error and possibly exit
  280.         }
  281.         else
  282.         {
  283.             ::TranslateMessage(&stMsg); 
  284.             ::DispatchMessage(&stMsg); 
  285.         }
  286.     } while (true);
  287.     
  288. Exit0:
  289. m_DownloadFile.StopDownload();
  290. return m_nResultCode;
  291. }
  294. int CUpdateDLLApp::Download()
  295. {
  296. int nRetCode = 0;
  297.     MSG stMsg = { 0 };
  299.     if (!m_nInitFlag)
  300. return defUPDATE_RESULT_INIT_FAILED;
  302.     if (g_UpdateData.nMethod == defUPDATE_METHOD_LAN)
  303.         m_nResultCode = defUPDATE_RESULT_DOWNLOAD_SUCCESS;
  305. KUPDATE_ITEM* pDownItem = g_ProcessIndex.m_pUpdateItemList;
  306. while (pDownItem)
  307. {
  308. if (pDownItem->DownloadStatus != enumDOWNLOADSTATUS_DOWNLOADED)
  309. break;
  310. pDownItem = pDownItem->pNext;
  311. }
  313. if (pDownItem == NULL)
  314. m_nResultCode = defUPDATE_RESULT_DOWNLOAD_SUCCESS;
  316. ResetEvent(m_hExitNotify);
  318.     m_DownloadFile.SetNotifyWnd(m_wndMessage.GetSafeHwnd(), WM_DOWNNOTIFY_DEFAULT);
  319.     m_DownloadFile.SetSavePath((CString)g_PathTable.szDownloadDestPath);
  321.     SetDownloadProxy(m_DownloadFile, g_UpdateData.szHostURL);
  322.     m_nCurEnableResume = g_UpdateData.bAutoResume;
  323.     nRetCode = DownNextItem(false);
  324.     KAV_PROCESS_ERROR(nRetCode);
  325.     
  326.     do
  327.     {
  328.         nRetCode = ::WaitForSingleObject(m_hExitNotify, 0);
  329.         if (WAIT_OBJECT_0 == nRetCode)
  330.             break;
  331.         
  332.         nRetCode = ::PeekMessage(&stMsg, NULL, 0, 0, PM_REMOVE);
  333.         if (0 == nRetCode)
  334.             continue;
  335.         
  336.         if (WM_QUIT == stMsg.message)
  337.             break;
  338.         
  339.         if (-1 == nRetCode)
  340.         {
  341.             // handle the error and possibly exit
  342.         }
  343.         else
  344.         {
  345.             ::TranslateMessage(&stMsg); 
  346.             ::DispatchMessage(&stMsg); 
  347.         }
  348.     } while (true);
  349.     
  350. Exit0:
  351. m_DownloadFile.StopDownload();
  352.     return m_nResultCode;
  353. }  
  355. int CUpdateDLLApp::CancelDownload()
  356. {
  357.     if (!m_nInitFlag)
  358. return 0;
  360.     if (g_UpdateData.nMethod == defUPDATE_METHOD_LAN)
  361. return 0;
  363. m_DownloadFile.StopDownload();
  364. SetEvent(m_hExitNotify);
  365.     return 0;
  366. }  
  369. int CUpdateDLLApp::Update()
  370. {
  371. int m_nResultCode = defUPDATE_RESULT_UPDATE_SUCCESS;
  372. int nRetCode = 0;
  373. CString sMsg;
  374.                                                      
  376. if (!m_nInitFlag)
  377. return defUPDATE_RESULT_INIT_FAILED;
  378.     
  379.     nRetCode = UpdateFiles();
  380.     if (!nRetCode)
  381.     {
  382. sMsg = defIDS_UPDATE_FINISH_FAILED;
  383. m_nResultCode = defUPDATE_RESULT_UPDATE_FAILED;
  384. g_UpdateData.SaveLog.WriteLogString(sMsg, true);
  385. return m_nResultCode;
  386. }
  388.     sMsg = defIDS_UPDATE_FINISH_SUCCESS;
  389.     g_UpdateData.SaveLog.WriteLogString(sMsg, true);
  391.     if (g_UpdateData.bUpdateFailed)
  392.     {
  393.         sMsg = defIDS_NOTIFY_REUPDATE;
  394.         g_UpdateData.SaveLog.WriteLogString(sMsg, true);
  395. m_nResultCode = defUPDATE_RESULT_UPDATE_FAILED;
  396.     }   
  397. else
  398. {
  399. if (g_UpdateData.bNeedRebootFalg)
  400. {
  401. sMsg = defIDS_NEED_REBOOT;
  402. g_UpdateData.SaveLog.WriteLogString(sMsg, true);
  404. m_nResultCode = defUPDATE_RESULT_UPDATE_SUCCESS_NEED_REBOOT;
  405. }
  406. else if (g_UpdateData.bNeedUpdateSelfFirst)
  407. m_nResultCode = defUPDATE_RESULT_UPDATESELF_SUCCESS;
  408. else
  409. m_nResultCode = defUPDATE_RESULT_UPDATE_SUCCESS;
  410. }
  412. return m_nResultCode;
  413. }
  416. ULONG CUpdateDLLApp::OnDownResult(ULONG ulOverResult)
  417. {
  418.     ULONG ulResult = CDownNotify::OnDownResult(ulOverResult);
  419.     int nRetCode = false;   
  420. int nCurDownOK      = false;
  421. int nRedownCurrent  = false;
  422. CString sLog, sFormat;
  424.     if (DOWNINDEX_STEPCHKSNHTTP == m_nProcessStep)
  425.     {
  426.         ASSERT(!m_strCgiTempFile.IsEmpty());
  427.         
  428.         if (DOWN_RESULT_FAIL == ulOverResult)
  429.         {
  430.             ASSERT(!m_bCheckUserOK);
  431.             
  432.             //nRetCode = ProcessCheckFailed();
  433.             if (nRetCode)
  434.             {
  435.                 //nRetCode = ProcessNextStep(DOWNINDEX_STEPCHKSNHTTP);
  436.                 nRetCode = ProcessNextStep(DOWNINDEX_STEPCHKSNUDP);
  437.                 ASSERT(nRetCode);
  438.             }
  439.         }
  440.         goto Exit1;
  441.     }                 
  443.     if (DOWNINDEX_STEPINDEX == m_nProcessStep)
  444.     {
  445. if (DOWN_RESULT_SUCCESS == ulOverResult)
  446. {
  447. m_nResultCode = defUPDATE_RESULT_DOWNLOAD_INDEX_SUCCESS;
  448. nRetCode = ProcessNextStep(DOWNINDEX_STEPOVER);
  449. if(nRetCode == defVersionNotenough) {
  450. m_nResultCode = nRetCode;
  451. }
  452. PostQuitMessage(0);
  453. SetEvent(m_hExitNotify);
  454. goto Exit1;
  455. }
  456. else
  457. {
  458. m_nResultCode = defUPDATE_RESULT_DOWNLOAD_INDEX_FAILED;
  460.             if (!g_UpdateData.bAutoTryNextHost)
  461.             {
  462. PostQuitMessage(0);
  463. SetEvent(m_hExitNotify);
  464. goto Exit1;
  465. }
  467. // here to get Next host to download index
  468. //g_UpdateData.szHostURL
  469. SetDownloadProxy(m_DownloadFile, g_UpdateData.szHostURL);
  470. nRetCode = ProcessNextStep(DOWNINDEX_STEPINDEX);
  471. }
  472. }
  473. else
  474. {
  475. ASSERT(m_pCurDownItem != NULL);
  476.     
  477. m_nCurEnableResume = g_UpdateData.bAutoResume;
  478.     
  479. switch (ulOverResult)
  480. {
  481. case DOWN_RESULT_SUCCESS:
  482. case DOWN_RESULT_SAMEAS:
  483. m_pCurDownItem->DownloadStatus = enumDOWNLOADSTATUS_DOWNLOADED;
  484.         
  485. // Check file CRC
  486. nCurDownOK = CheckFileCRC(atoi(m_pCurDownItem->szCRC), m_pCurDownItem->szDownloadTmpFileName);
  487. if (!nCurDownOK)
  488. {
  489. if (!g_UpdateData.bAutoTryNextHost) //if (!ExistsOtherHost())
  490. {
  491. m_nResultCode = defUPDATE_RESULT_DOWNLOAD_FAILED;
  492. m_pCurDownItem->DownloadStatus = enumDOWNLOADSTATUS_ERROR;                
  493. sFormat = defIDS_DOWNLOAD_FILE_FAILED;
  494. sLog.Format(sFormat, m_pCurDownItem->szFileName, m_pCurDownItem->szDownloadTmpFileName);
  495. g_UpdateData.SaveLog.WriteLogString(sLog, true);
  496. if (!g_UpdateData.bDownloadFailed)
  497. g_UpdateData.bDownloadFailed = m_pCurDownItem->bNeedDownload;
  498. }
  499. else
  500. {
  501. //do not skip download this update file
  502. nRedownCurrent = true;
  503. m_pCurDownItem->DownloadStatus = enumDOWNLOADSTATUS_QUEUE;
  504. m_nCurEnableResume = false;
  505. }
  506. }
  507. else
  508. {
  509.                 m_nResultCode = defUPDATE_RESULT_DOWNLOAD_SUCCESS;
  510. sFormat = defIDS_DOWNLOAD_FILE_SUCCESSFUL;
  511. sLog.Format(sFormat, m_pCurDownItem->szFileName, m_pCurDownItem->szDownloadTmpFileName);
  512. g_UpdateData.SaveLog.WriteLogString(sLog, true);
  513. }
  514. break;
  515.         
  516. case DOWN_RESULT_FAIL:
  517. if (m_pCurDownItem->nDownTryTimes < (int)g_UpdateData.ulTryTimes)
  518. {
  519. nRedownCurrent = true;
  520. }
  521. if (!g_UpdateData.bAutoTryNextHost) //if (!ExistsOtherHost())
  522. {
  523. m_nResultCode = defUPDATE_RESULT_DOWNLOAD_FAILED;
  524. m_pCurDownItem->DownloadStatus = enumDOWNLOADSTATUS_ERROR;
  525. sFormat = defIDS_DOWNLOAD_FILE_FAILED;
  526. sLog.Format(sFormat, m_pCurDownItem->szFileName, m_pCurDownItem->szDownloadTmpFileName);
  527. g_UpdateData.SaveLog.WriteLogString(sLog, true);
  528. if (!g_UpdateData.bDownloadFailed)
  529. g_UpdateData.bDownloadFailed = m_pCurDownItem->bNeedDownload;
  530. }
  531. else
  532. {
  533. //do not skip download this update file
  534. nRedownCurrent = true;
  535. m_pCurDownItem->nDownTryTimes = 0;
  536. m_pCurDownItem->DownloadStatus = enumDOWNLOADSTATUS_QUEUE;
  537. }
  539. break;
  540.         
  541. default:
  542. ASSERT(FALSE);
  543. break;
  544. }
  545.     
  546. nRetCode = DownNextItem(nRedownCurrent);
  547. if (!nRetCode)
  548. {
  549. if (nRedownCurrent)
  550. ASSERT(FALSE);
  551. else
  552.             {                   
  553.                 PostQuitMessage(0);
  554. SetEvent(m_hExitNotify);
  555.                 goto Exit1;
  556.             }
  557.         }
  559.         if (m_nResultCode == defUPDATE_RESULT_CANCEL)
  560.         {
  561.         PostQuitMessage(0);
  562. SetEvent(m_hExitNotify);
  563. goto Exit1;
  564.         }
  565. }
  566.         
  567. Exit1:
  568.     return ulResult;
  569. }
  572. int CUpdateDLLApp::ProcessNextStep(int nDownStep)
  573. {
  574.     int nResult = false;
  575.     int nRetCode = false;
  576.     CString sMsg;
  577.     CString sTitle;
  578.     MSG stMsg = { 0 };
  579.     HANDLE Handle = NULL;
  581.     
  582.     CString strDownUrl;
  583.     
  584.     switch (nDownStep)
  585.     {
  586.     case DOWNINDEX_STEPCHKSNUDP:
  587.         m_strIndexTempFile.Empty();
  588.         
  589.         nRetCode = m_CheckThread.IsThreadOK();
  590.         if (nRetCode)
  591.         {
  592.             nRetCode = m_CheckThread.StopThread();
  593.             ASSERT(nRetCode);
  594.         }
  595.         nResult = m_CheckThread.StartThread();
  596.         
  597.         Handle = m_CheckThread.GetSafeHandle();
  598.         nRetCode = ::WaitForMultipleObjects(
  599.             1,
  600.             &Handle,
  601.             true,
  602.             INFINITE
  603.         );
  604.         if (WAIT_OBJECT_0 == nRetCode)
  605.             UnInitCheckThread();
  607.         break;
  608.         
  609.     case DOWNINDEX_STEPCHKSNHTTP:
  610.         m_strIndexTempFile.Empty();
  611.         
  612.         strDownUrl = defKAV_CHKSN_CGI_REQUEST;
  613.         strDownUrl += g_UpdateData.szVerifyInfo;
  614.         m_strCgiTempFile = g_PathTable.szTempPath;
  615.         m_strCgiTempFile += defKAV_CHKSN_CGI_TEMPFILE;
  616.         
  617.         m_DownloadFile.SetTimeout(10000, 24000, 24000);
  618.         nResult = m_DownloadFile.StartDownload(strDownUrl, false, m_strCgiTempFile);
  619.         
  620.         do
  621.         {
  622.             nRetCode = ::MsgWaitForMultipleObjects(
  623.                 1,
  624.                 &m_hExitNotify,
  625.                 false,
  626.                 INFINITE,
  627.                 QS_ALLINPUT
  628.             );
  629.             if (WAIT_OBJECT_0 == nRetCode)
  630.                 break;
  631.         
  632.             ASSERT((WAIT_OBJECT_0 + 1) == nRetCode);
  633.         
  634.             nRetCode = ::PeekMessage(&stMsg, NULL, 0, 0, PM_REMOVE);
  635.             if (0 == nRetCode)
  636.                 continue;
  637.         
  638.             if (WM_QUIT == stMsg.message)
  639.                 break;
  640.         
  641.             if (-1 == nRetCode)
  642.             {
  643.                 // handle the error and possibly exit
  644.             }
  645.             else
  646.             {
  647.                 ::TranslateMessage(&stMsg); 
  648.                 ::DispatchMessage(&stMsg); 
  649.             }
  650.         } while (true);      
  652.         break;
  654.     case DOWNINDEX_STEPINDEX:
  655.         strDownUrl = g_UpdateData.szHostURL;
  656.         strDownUrl += defINDEX_FILE_NAME;
  657.         
  658.         MkDirEx(g_PathTable.szDownloadDestPath);
  659.         m_strIndexTempFile = (CString)g_PathTable.szDownloadDestPath + defINDEX_FILE_NAME;
  660.         
  661.         m_DownloadFile.SetTimeout(10000, 24000, 24000);
  662.         nResult = m_DownloadFile.StartDownload(strDownUrl, false, m_strIndexTempFile);
  663.         break;
  664.         
  665.     case DOWNINDEX_STEPOVER:
  666.         if (m_pfnCallBackProc)
  667.         {
  668.             if (m_pfnCallBackProc(defUPDATE_STATUS_PROCESSING_INDEX, 0))
  669.             {
  670.                 m_nResultCode = defUPDATE_RESULT_CANCEL;
  671.         goto Exit0;
  672.             }
  673.         }
  675.         nRetCode = ::ProcessIndexFile(m_strIndexTempFile);
  676. if (!nRetCode)
  677. {
  678. m_nResultCode = defUPDATE_RESULT_PROCESS_INDEX_FAILED;
  679. goto Exit0;
  680. }
  681. if(nRetCode == defVersionNotenough) {
  682. // m_CheckThread.StopThread();
  683. return defVersionNotenough;
  684. }
  685. m_nResultCode = defUPDATE_RESULT_PROCESS_INDEX_SUCCESS;
  687. if (g_ProcessIndex.IsNotUpdateItem())
  688. m_nResultCode = defUPDATE_RESULT_NOT_UPDATE_FILE;
  689.         
  690.         break;
  691.         
  692.     default:
  693.         ASSERT(FALSE);
  694.         goto Exit0;
  695.     }
  696.     
  697.     m_nProcessStep = nDownStep;
  698.     nResult = true;
  699. Exit0:
  700.     return nResult;
  701. }
  704. int CUpdateDLLApp::DownNextItem(int nRedownCurrent /*=false*/)
  705. {
  706.     int nResult = false;
  707.     int nRetCode = false;
  708.     
  709.     if (nRedownCurrent)
  710.     {
  711.         if (NULL == m_pCurDownItem)
  712.         {
  713.             ASSERT(FALSE);
  714.             goto Exit0;
  715.         }
  716.         
  717.         ASSERT(m_pCurDownItem->DownloadStatus != enumDOWNLOADSTATUS_DOWNLOADED);
  718.     }
  719.     else
  720.     {
  721.         if (m_pCurDownItem != NULL)  
  722.             m_pCurDownItem = m_pCurDownItem->pNext;
  723.         
  724.         if (NULL == m_pCurDownItem)
  725.             m_pCurDownItem = g_ProcessIndex.m_pUpdateItemList;
  726.     }
  727.     
  728.     while (m_pCurDownItem != NULL)
  729.     {
  730.         switch (m_pCurDownItem->DownloadStatus)
  731.         {
  732.         case enumDOWNLOADSTATUS_ERROR:
  733.         case enumDOWNLOADSTATUS_DOWNLOADED:
  734.             if (!nRedownCurrent)
  735.             {
  736.                 m_pCurDownItem = m_pCurDownItem->pNext;
  737.                 continue;
  738.             }
  739.             break;
  740.             
  741.         case enumDOWNLOADSTATUS_QUEUE:
  742.             m_pCurDownItem->nDownTryTimes = 0;
  743.             break;
  744.             
  745.         default:
  746.             break;
  747.         }
  748.         
  749.         m_pCurDownItem->nDownTryTimes++;
  750.         break;
  751.     }
  752.     
  753.     if (m_pCurDownItem != NULL)
  754.     {
  755.         CString strDownUrlPath;
  756.         
  757.         strDownUrlPath = g_UpdateData.szHostURL;
  758.         strDownUrlPath += m_pCurDownItem->szRemotePath;
  759.         strDownUrlPath += m_pCurDownItem->szFileName;
  760.        
  761.         m_pCurDownItem->DownloadStatus = enumDOWNLOADSTATUS_DOWNLOADING;
  763. if (m_pfnCallBackProc)
  764. {
  765. KUPDATE_ITEM * pItem = g_ProcessIndex.m_pUpdateItemList;
  766. int nCount = 1;
  767. int nIndex = 1;
  768. while (pItem)
  769. {
  770. nCount++;
  771. if (m_pCurDownItem == pItem)
  772. {
  773. nIndex = nCount;
  774. }
  775. pItem = pItem->pNext;
  776. }
  778. if (m_pfnCallBackProc(defUPDATE_STATUS_DOWNLOADING, nIndex / nCount * 100))
  779. {
  780. m_nResultCode = defUPDATE_RESULT_CANCEL;
  781. goto Exit0;
  782. }
  783. }
  784.         
  785.         nRetCode = m_DownloadFile.StartDownload(
  786.             strDownUrlPath,
  787.             m_nCurEnableResume,
  788.             m_pCurDownItem->szDownloadTmpFileName
  789.         );
  790.         ASSERT(nRetCode);
  791.         
  792.         nResult = true;
  793.     }
  794.     
  795. Exit0:
  796.     return nResult;
  797. }
  799. int CUpdateDLLApp::GetCheckInfo(
  800.     ULONG   ulContextWith,
  801.     int     *pnSendSize,
  802.     unsigned char **ppbySendInfo
  803. )
  804. {
  805.     int nResult = false;
  806.     
  807.     ASSERT_POINTER(pnSendSize, int);
  808.     ASSERT_POINTER(ppbySendInfo, LPVOID);
  809.     
  810.     if (
  811.         (NULL == pnSendSize) || 
  812.         (NULL == ppbySendInfo)
  813.     )
  814.         goto Exit0;
  815.     
  816.     GetUserInfo(m_KavUserInfo, TRUE);
  817.     
  818.     *pnSendSize = sizeof(m_KavUserInfo);
  819.     *ppbySendInfo = (unsigned char *)&m_KavUserInfo;
  820.     
  821.     nResult = true;
  822.     
  823. Exit0:
  824.     return nResult;
  825. }
  827. int CUpdateDLLApp::CheckRecvInfo(
  828.     ULONG   ulContextWith,
  829.     int     nRecvSize,
  830.     unsigned char  *pbyRecvInfo
  831. )
  832. {
  833.     //int nResult = -1;
  834. int nResult = defConnectServerFailed - 1;
  835.     int nRetCode = 0;
  836.     SERVER_INFO *pServerInfo = NULL;
  837.     
  838.     if (nRecvSize < sizeof(SERVER_INFO))
  839.         goto Exit0;
  840.     
  841.     pServerInfo = (SERVER_INFO *)pbyRecvInfo;
  842.     
  843.     nRetCode = strncmp(
  844.         pServerInfo->szFlag,
  845.         defCHECK_CURRENT_SERVERFLAG,
  846.         sizeof(pServerInfo->szFlag)
  847.     );
  848.     if (nRetCode != 0)
  849.         goto Exit0;
  850.     
  851.     nResult = pServerInfo->nNumber;
  852.     
  853. Exit0:
  854.     return nResult;
  855. }
  857. void CUpdateDLLApp::CheckResult(
  858.     ULONG   ulContextWith,
  859.     int     nSvrResult
  860. )
  861. {
  862.     int nRetCode = false;
  863.     CString sMsg;
  864.     
  865.     if (m_nProcessStep != DOWNINDEX_STEPCHKSNUDP)
  866.     {
  867.         sMsg = defIDS_HTTP_CHECK_FAILED;
  868.         g_UpdateData.SaveLog.WriteLogString(sMsg, true);
  870.         ASSERT(false);
  871.         return;
  872.     }
  873.     
  874.     if (nSvrResult < defInhibitiveSerialNumber)
  875.     {
  876.         sMsg = defIDS_USE_HTTP_CHECK;
  877.         g_UpdateData.SaveLog.WriteLogString(sMsg, true);
  878.         
  879.         nRetCode = ProcessNextStep(DOWNINDEX_STEPCHKSNHTTP);
  880.         ASSERT(nRetCode);
  881.     }
  882.     else
  883.     {   
  884.         ProcessUserCheck(nSvrResult);
  885.     }
  886. }
  889. int CUpdateDLLApp::InitCheckThread()
  890. {
  891.     int nResult = false;
  892.     int nRetCode = false;
  893.     
  894.     if (m_nInitCheckThread)
  895.         goto Exit1;
  896.     
  897.     nRetCode = m_CheckThread.Create();
  898.     if (!nRetCode)
  899.     {
  900.         ASSERT(FALSE);
  901.         goto Exit0;
  902.     }
  903.     
  904. Exit1:
  905.     m_nInitCheckThread = true;
  906.     nResult = true;
  907.     
  908. Exit0:
  909.     return nResult;
  910. }
  912. int CUpdateDLLApp::UnInitCheckThread()
  913. {
  914.     int nResult = false;
  915.     int nRetCode = false;
  916.     
  917.     if (!m_nInitCheckThread)
  918.         goto Exit1;
  919.     
  920.     nRetCode = m_CheckThread.IsThreadOK();
  921.     if (nRetCode)
  922.     {
  923.         nRetCode = m_CheckThread.StopThread();
  924.         ASSERT(nRetCode);
  925.     }
  926.     
  927.     m_CheckThread.Destroy();
  928.     
  929. Exit1:
  930.     m_nInitCheckThread = false;
  931.     nResult = true;
  932.     
  933. //Exit0:
  934.     return nResult;
  935. }
  938. ULONG CUpdateDLLApp::OnStatusFileDowned(PDOWNLOADSTATUS pDownStatus)
  939. {
  940.     ULONG ulResult = 0;
  941.     
  942.     if (DOWNINDEX_STEPCHKSNHTTP == m_nProcessStep)
  943.     {
  944.         if (pDownStatus->dwFileDownloadedSize >= 20)
  945.         {
  946.             m_DownloadFile.StopDownload();
  947.             
  948.             int nRetCode = false;
  949.     
  950.             CFile file;
  951.             int nCheckOK = false;
  952.             HANDLE hCheckFile = INVALID_HANDLE_VALUE;
  953.     
  954.             char szCheckResult[256] = { 0 };
  955.     
  956.             nRetCode = m_strCgiTempFile.IsEmpty();
  957.             if (nRetCode)
  958.             {
  959.                 ASSERT(false);
  960.                 goto Exit0;
  961.             }
  962.     
  963.             TRY
  964.             {
  965.                 // Open the cgi url download temp file
  966.                 nRetCode = file.Open(m_strCgiTempFile + ".tmp", CFile::modeRead | CFile::shareDenyNone);
  967.                 if (!nRetCode)
  968.                 {
  969.                     nRetCode = file.Open(m_strCgiTempFile, CFile::modeRead | CFile::shareDenyNone);
  970.                     if (!nRetCode)
  971.                     {
  972.                         ASSERT(false);
  973.                         goto Exit0;
  974.                     }
  975.                 }
  976.         
  977.                 nRetCode = file.Read(szCheckResult, sizeof(szCheckResult) - 2);
  978.                 if (nRetCode <= 4)
  979.                 {
  980.                     ASSERT(false);
  981.                     goto Exit0;
  982.                 }
  983.             }
  984.             CATCH_ALL(pException)
  985.             {
  986.                 pException->Delete();
  987.                 goto Exit0;
  988.             }
  989.             END_CATCH_ALL;
  990.     
  991.             file.Close();
  992.     
  993.             nRetCode = (0 == ::strncmp(szCheckResult, "+OK", 3));
  994.     
  995.             ulResult = ProcessUserCheck(nRetCode);
  997.             PostQuitMessage(0);
  998.         }        
  999.     }
  1000. else if (DOWNINDEX_STEPOVER == m_nProcessStep)
  1001. {
  1002. if (m_pfnCallBackProc && pDownStatus)
  1003. {
  1004. DOWNLOADFILESTATUS info;
  1005. strncpy(info.strFileName, pDownStatus->strFileName, MAX_PATH);
  1006. info.dwFileSize = pDownStatus->dwFileSize;
  1007. info.dwFileDownloadedSize = pDownStatus->dwFileDownloadedSize;
  1008. m_pfnCallBackProc(defUPDATE_STATUS_DOWNLOADING_FILE, (long)&info);
  1009. }
  1010. }
  1012. Exit0:        
  1013.     return ulResult;
  1014. }           
  1016. int CUpdateDLLApp::ProcessUserCheck(int nCheckOK)
  1017. {
  1018.     int nResult = false;
  1019. int nRetCode = 0;
  1020.     CString sLog;
  1021. //int nMsgID = 0;
  1022.     
  1023.     if (nCheckOK >=0)
  1024.         m_bCheckUserOK = true;
  1025.     else 
  1026.         m_bCheckUserOK = false;
  1027.     
  1028.     if (nCheckOK >=0)
  1029.     {
  1030.         if (m_nProcessStep == DOWNINDEX_STEPCHKSNUDP)
  1031.         {
  1032.             sLog = defIDS_UDP_CHECK_SUCCESSFUL;
  1033.             g_UpdateData.SaveLog.WriteLogString(sLog, true);
  1034.         }
  1035.         else if (m_nProcessStep == DOWNINDEX_STEPCHKSNHTTP)
  1036.         {
  1037.             sLog = defIDS_HTTP_CHECK_SUCCESSFUL;
  1038.             g_UpdateData.SaveLog.WriteLogString(sLog, true);
  1039.         }
  1041.         m_nResultCode = defUPDATE_RESULT_USER_VERIFY_SUCCESS;
  1042.         nResult = true;
  1043.     }
  1044.     else
  1045.     {
  1046. switch (nCheckOK)
  1047. {
  1048. case defInvalidSerialNumber:
  1049. sLog = defIDS_INVALID_USERCHECK;
  1050.             m_nResultCode = defUPDATE_RESULT_INVALIDSN;
  1051. break;
  1052. case defPiraticSerialNumber:
  1053.             sLog = defIDS_PIRATIC_SERIAL_NUMBER;
  1054.             m_nResultCode = defUPDATE_RESULT_PIRATICSN;
  1055.             break;
  1056. case defInhibitiveSerialNumber:
  1057.      sLog = defIDS_INHIBITIVE_SERIAL_NUMBER;
  1058.             m_nResultCode = defUPDATE_RESULT_INHIBITIVESN;
  1059. break;
  1060. case defConnectServerFailed:
  1061. sLog = defIDS_CONNECT_SERVER_FAILED;
  1062.             m_nResultCode = defUPDATE_RESULT_CONNECT_SERVER_FAILED;
  1063. break;
  1064. default:
  1065. sLog = defIDS_CHECK_SERIAL_NUMBER_ERROR;
  1066.             m_nResultCode = defUPDATE_RESULT_ERRORSN;
  1067. }
  1068. g_UpdateData.SaveLog.WriteLogString(sLog, true);  
  1069.     }
  1070.     
  1071.     return nResult;
  1072. }