src/TortoiseProc/CheckForUpdatesDlg.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2008 - TortoiseSVN
   4 // Copyright (C) 2008-2012 - TortoiseGit
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 #include "stdafx.h"
  21 #include "TortoiseProc.h"
  22 #include "LoglistCommonResource.h"
  23 #include "..\version.h"
  24 #include "MessageBox.h"
  25 #include ".\checkforupdatesdlg.h"
  26 #include "Registry.h"
  27 #include "AppUtils.h"
  28 #include "TempFile.h"
  29 #include <wintrust.h>
  30 #include <Softpub.h>
  31 #include "SmartHandle.h"
  32 #include "SysInfo.h"
  33 #include "PathUtils.h"
  34 #include "DirFileEnum.h"
  35 #include "ProjectProperties.h"
  36
  37 // Link with Wintrust.lib
  38 #pragma comment (lib, "wintrust")
  39
  40 #define WM_USER_DISPLAYSTATUS   (WM_USER + 1)
  41 #define WM_USER_ENDDOWNLOAD             (WM_USER + 2)
  42 #define WM_USER_FILLCHANGELOG   (WM_USER + 3)
  43
  44 IMPLEMENT_DYNAMIC(CCheckForUpdatesDlg, CStandAloneDialog)
  45 CCheckForUpdatesDlg::CCheckForUpdatesDlg(CWnd* pParent /*=NULL*/)
  46         : CStandAloneDialog(CCheckForUpdatesDlg::IDD, pParent)
  47         , m_bShowInfo(FALSE)
  48         , m_bVisible(FALSE)
  49         , m_pDownloadThread(NULL)
  50 {
  51         m_sUpdateDownloadLink = _T("http://code.google.com/p/tortoisegit/wiki/Download?tm=2");
  52 }
  53
  54 CCheckForUpdatesDlg::~CCheckForUpdatesDlg()
  55 {
  56 }
  57
  58 void CCheckForUpdatesDlg::DoDataExchange(CDataExchange* pDX)
  59 {
  60         CStandAloneDialog::DoDataExchange(pDX);
  61         DDX_Control(pDX, IDC_LINK, m_link);
  62         DDX_Control(pDX, IDC_PROGRESSBAR, m_progress);
  63         DDX_Control(pDX, IDC_LIST_DOWNLOADS, m_ctrlFiles);
  64         DDX_Control(pDX, IDC_BUTTON_UPDATE, m_ctrlUpdate);
  65         DDX_Control(pDX, IDC_LOGMESSAGE, m_cLogMessage);
  66 }
  67
  68 BEGIN_MESSAGE_MAP(CCheckForUpdatesDlg, CStandAloneDialog)
  69         ON_STN_CLICKED(IDC_CHECKRESULT, OnStnClickedCheckresult)
  70         ON_WM_TIMER()
  71         ON_WM_WINDOWPOSCHANGING()
  72         ON_WM_SETCURSOR()
  73         ON_BN_CLICKED(IDC_BUTTON_UPDATE, OnBnClickedButtonUpdate)
  74         ON_MESSAGE(WM_USER_DISPLAYSTATUS, OnDisplayStatus)
  75         ON_MESSAGE(WM_USER_ENDDOWNLOAD, OnEndDownload)
  76         ON_MESSAGE(WM_USER_FILLCHANGELOG, OnFillChangelog)
  77 END_MESSAGE_MAP()
  78
  79 BOOL CCheckForUpdatesDlg::OnInitDialog()
  80 {
  81         CStandAloneDialog::OnInitDialog();
  82         CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
  83
  84         CString temp;
  85         temp.Format(IDS_CHECKNEWER_YOURVERSION, TGIT_VERMAJOR, TGIT_VERMINOR, TGIT_VERMICRO, TGIT_VERBUILD);
  86         SetDlgItemText(IDC_YOURVERSION, temp);
  87
  88         DialogEnableWindow(IDOK, FALSE);
  89
  90         // hide download controls
  91         m_ctrlFiles.ShowWindow(SW_HIDE);
  92         GetDlgItem(IDC_GROUP_DOWNLOADS)->ShowWindow(SW_HIDE);
  93         RECT rectWindow, rectGroupDownloads, rectOKButton;
  94         GetWindowRect(&rectWindow);
  95         GetDlgItem(IDC_GROUP_DOWNLOADS)->GetWindowRect(&rectGroupDownloads);
  96         GetDlgItem(IDOK)->GetWindowRect(&rectOKButton);
  97         LONG bottomDistance = rectWindow.bottom - rectOKButton.bottom;
  98         OffsetRect(&rectOKButton, 0, rectGroupDownloads.top - rectOKButton.top);
  99         rectWindow.bottom = rectOKButton.bottom + bottomDistance;
 100         MoveWindow(&rectWindow);
 101         ::MapWindowPoints(NULL, GetSafeHwnd(), (LPPOINT)&rectOKButton, 2);
 102         GetDlgItem(IDOK)->MoveWindow(&rectOKButton);
 103
 104         temp.LoadString(IDS_STATUSLIST_COLFILE);
 105         m_ctrlFiles.InsertColumn(0, temp, 0, -1);
 106         m_ctrlFiles.SetColumnWidth(0, LVSCW_AUTOSIZE_USEHEADER);
 107         m_ctrlFiles.SetExtendedStyle(LVS_EX_DOUBLEBUFFER | LVS_EX_CHECKBOXES);
 108
 109         ProjectProperties pp;
 110         pp.SetCheckRe(_T("[Ii]ssues?:?(\\s*(,|and)?\\s*#?\\d+)+"));
 111         pp.SetBugIDRe(_T("(\\d+)"));
 112         pp.sUrl = _T("http://code.google.com/p/tortoisegit/issues/detail?id=%BUGID%");
 113         m_cLogMessage.Init(pp);
 114         m_cLogMessage.SetFont((CString)CRegString(_T("Software\\TortoiseGit\\LogFontName"), _T("Courier New")), (DWORD)CRegDWORD(_T("Software\\TortoiseGit\\LogFontSize"), 8));
 115         m_cLogMessage.Call(SCI_SETREADONLY, TRUE);
 116
 117         if (AfxBeginThread(CheckThreadEntry, this)==NULL)
 118         {
 119                 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
 120         }
 121
 122         SetTimer(100, 1000, NULL);
 123         return TRUE;
 124 }
 125
 126 void CCheckForUpdatesDlg::OnOK()
 127 {
 128         if (m_bThreadRunning || m_pDownloadThread != NULL)
 129                 return; // Don't exit while downloading
 130
 131         CStandAloneDialog::OnOK();
 132 }
 133
 134 void CCheckForUpdatesDlg::OnCancel()
 135 {
 136         if (m_bThreadRunning || m_pDownloadThread != NULL)
 137                 return; // Don't exit while downloading
 138         CStandAloneDialog::OnCancel();
 139 }
 140
 141 UINT CCheckForUpdatesDlg::CheckThreadEntry(LPVOID pVoid)
 142 {
 143         return ((CCheckForUpdatesDlg*)pVoid)->CheckThread();
 144 }
 145
 146 UINT CCheckForUpdatesDlg::CheckThread()
 147 {
 148         m_bThreadRunning = TRUE;
 149
 150         CString temp;
 151         CString tempfile = CTempFiles::Instance().GetTempFilePath(true).GetWinPathString();
 152
 153         CRegString checkurluser = CRegString(_T("Software\\TortoiseGit\\UpdateCheckURL"), _T(""));
 154         CRegString checkurlmachine = CRegString(_T("Software\\TortoiseGit\\UpdateCheckURL"), _T(""), FALSE, HKEY_LOCAL_MACHINE);
 155         CString sCheckURL = checkurluser;
 156         if (sCheckURL.IsEmpty())
 157         {
 158                 sCheckURL = checkurlmachine;
 159                 if (sCheckURL.IsEmpty())
 160                         sCheckURL = _T("http://version.tortoisegit.googlecode.com/git/version.txt");
 161         }
 162         CoInitialize(NULL);
 163         HRESULT res = URLDownloadToFile(NULL, sCheckURL, tempfile, 0, NULL);
 164         if (res == S_OK)
 165         {
 166                 try
 167                 {
 168                         CStdioFile file(tempfile, CFile::modeRead | CFile::shareDenyWrite);
 169                         CString ver;
 170                         unsigned int major,minor,micro,build;
 171                         major=minor=micro=build=0;
 172                         unsigned __int64 version=0;
 173
 174                         if (file.ReadString(ver))
 175                         {
 176                                 CString vertemp = ver;
 177                                 major = _ttoi(vertemp);
 178                                 vertemp = vertemp.Mid(vertemp.Find('.')+1);
 179                                 minor = _ttoi(vertemp);
 180                                 vertemp = vertemp.Mid(vertemp.Find('.')+1);
 181                                 micro = _ttoi(vertemp);
 182                                 vertemp = vertemp.Mid(vertemp.Find('.')+1);
 183                                 build = _ttoi(vertemp);
 184                                 version = major;
 185                                 version <<= 16;
 186                                 version += minor;
 187                                 version <<= 16;
 188                                 version += micro;
 189                                 version <<= 16;
 190                                 version += build;
 191                         }
 192
 193                         {
 194                                 BOOL bNewer = FALSE;
 195                                 if (major > TGIT_VERMAJOR)
 196                                         bNewer = TRUE;
 197                                 else if ((minor > TGIT_VERMINOR)&&(major == TGIT_VERMAJOR))
 198                                         bNewer = TRUE;
 199                                 else if ((micro > TGIT_VERMICRO)&&(minor == TGIT_VERMINOR)&&(major == TGIT_VERMAJOR))
 200                                         bNewer = TRUE;
 201                                 else if ((build > TGIT_VERBUILD)&&(micro == TGIT_VERMICRO)&&(minor == TGIT_VERMINOR)&&(major == TGIT_VERMAJOR))
 202                                         bNewer = TRUE;
 203
 204                                 if (version != 0)
 205                                 {
 206                                         ver.Format(_T("%d.%d.%d.%d"),major,minor,micro,build);
 207                                         temp.Format(IDS_CHECKNEWER_CURRENTVERSION, (LPCTSTR)ver);
 208                                         SetDlgItemText(IDC_CURRENTVERSION, temp);
 209                                         temp.Format(_T("%d.%d.%d.%d"), TGIT_VERMAJOR, TGIT_VERMINOR, TGIT_VERMICRO, TGIT_VERBUILD);
 210                                 }
 211
 212                                 if (version == 0)
 213                                 {
 214                                         temp.LoadString(IDS_CHECKNEWER_NETERROR);
 215                                         SetDlgItemText(IDC_CHECKRESULT, temp);
 216                                 }
 217                                 else if (bNewer)
 218                                 {
 219                                         if(file.ReadString(temp) && !temp.IsEmpty())
 220                                         {       // Read the next line, it could contain a message for the user
 221                                                 CString tempLink;
 222                                                 if(file.ReadString(tempLink) && !tempLink.IsEmpty())
 223                                                 {       // Read another line to find out the download link-URL, if any
 224                                                         m_sUpdateDownloadLink = tempLink;
 225                                                 }
 226                                         }
 227                                         else
 228                                         {
 229                                                 temp.LoadString(IDS_CHECKNEWER_NEWERVERSIONAVAILABLE);
 230                                                 CString tempLink;
 231                                                 file.ReadString(tempLink);
 232                                         }
 233                                         SetDlgItemText(IDC_CHECKRESULT, temp);
 234                                         m_bShowInfo = TRUE;
 235
 236                                         FillChangelog(file);
 237                                         FillDownloads(file, ver);
 238
 239                                         // Show download controls
 240                                         RECT rectWindow, rectProgress, rectGroupDownloads, rectOKButton;
 241                                         GetWindowRect(&rectWindow);
 242                                         m_progress.GetWindowRect(&rectProgress);
 243                                         GetDlgItem(IDC_GROUP_DOWNLOADS)->GetWindowRect(&rectGroupDownloads);
 244                                         GetDlgItem(IDOK)->GetWindowRect(&rectOKButton);
 245                                         LONG bottomDistance = rectWindow.bottom - rectOKButton.bottom;
 246                                         OffsetRect(&rectOKButton, 0, (rectGroupDownloads.bottom + (rectGroupDownloads.bottom - rectProgress.bottom)) - rectOKButton.top);
 247                                         rectWindow.bottom = rectOKButton.bottom + bottomDistance;
 248                                         MoveWindow(&rectWindow);
 249                                         ::MapWindowPoints(NULL, GetSafeHwnd(), (LPPOINT)&rectOKButton, 2);
 250                                         GetDlgItem(IDOK)->MoveWindow(&rectOKButton);
 251                                         m_ctrlFiles.ShowWindow(SW_SHOW);
 252                                         GetDlgItem(IDC_GROUP_DOWNLOADS)->ShowWindow(SW_SHOW);
 253                                         CenterWindow();
 254                                 }
 255                                 else
 256                                 {
 257                                         temp.LoadString(IDS_CHECKNEWER_YOURUPTODATE);
 258                                         SetDlgItemText(IDC_CHECKRESULT, temp);
 259                                         file.ReadString(temp);
 260                                         file.ReadString(temp);
 261                                         FillChangelog(file);
 262                                 }
 263                         }
 264                 }
 265                 catch (CException * e)
 266                 {
 267                         e->Delete();
 268                         temp.LoadString(IDS_CHECKNEWER_NETERROR);
 269                         SetDlgItemText(IDC_CHECKRESULT, temp);
 270                 }
 271         }
 272         else
 273         {
 274                 // Try to cache web page;
 275
 276                 temp.LoadString(IDS_CHECKNEWER_NETERROR);
 277                 SetDlgItemText(IDC_CHECKRESULT, temp);
 278         }
 279         if (!m_sUpdateDownloadLink.IsEmpty())
 280         {
 281                 m_link.ShowWindow(SW_SHOW);
 282                 m_link.SetURL(m_sUpdateDownloadLink);
 283         }
 284
 285         DeleteFile(tempfile);
 286         m_bThreadRunning = FALSE;
 287         DialogEnableWindow(IDOK, TRUE);
 288         return 0;
 289 }
 290
 291 void CCheckForUpdatesDlg::FillDownloads(CStdioFile &file, CString version)
 292 {
 293 #if WIN64
 294         const CString x86x64 = _T("64");
 295 #else
 296         const CString x86x64 = _T("32");
 297 #endif
 298
 299         if (!file.ReadString(m_sFilesURL) || m_sFilesURL.IsEmpty())
 300                 m_sFilesURL = _T("http://tortoisegit.googlecode.com/files/");
 301
 302         m_ctrlFiles.InsertItem(0, _T("TortoiseGit"));
 303         CString filename;
 304         filename.Format(_T("TortoiseGit-%s-%sbit.msi"), version, x86x64);
 305         m_fileNames.push_back(filename);
 306         m_ctrlFiles.SetCheck(0 , TRUE);
 307
 308         std::vector<DWORD> m_installedLangs;
 309         {
 310                 // set up the language selecting combobox
 311                 CString path = CPathUtils::GetAppParentDirectory();
 312                 path = path + _T("Languages\\");
 313                 CSimpleFileFind finder(path, _T("*.dll"));
 314                 while (finder.FindNextFileNoDirectories())
 315                 {
 316                         CString file = finder.GetFilePath();
 317                         CString filename = finder.GetFileName();
 318                         if (filename.Left(12).CompareNoCase(_T("TortoiseProc")) == 0)
 319                         {
 320                                 CString sVer = _T(STRPRODUCTVER);
 321                                 sVer = sVer.Left(sVer.ReverseFind(','));
 322                                 CString sFileVer = CPathUtils::GetVersionFromFile(file);
 323                                 sFileVer = sFileVer.Left(sFileVer.ReverseFind(','));
 324                                 CString sLoc = filename.Mid(12);
 325                                 sLoc = sLoc.Left(sLoc.GetLength() - 4); // cut off ".dll"
 326                                 if ((sLoc.Left(2) == L"32") && (sLoc.GetLength() > 5))
 327                                         continue;
 328                                 DWORD loc = _tstoi(filename.Mid(12));
 329                                 m_installedLangs.push_back(loc);
 330                         }
 331                 }
 332         }
 333
 334         CString langs;
 335         while (file.ReadString(langs) && !langs.IsEmpty())
 336         {
 337                 CString sLang = _T("TortoiseGit Language Pack ");
 338
 339                 DWORD loc = _tstoi(langs.Mid(0, 4));
 340                 TCHAR buf[MAX_PATH];
 341                 GetLocaleInfo(loc, LOCALE_SNATIVELANGNAME, buf, _countof(buf));
 342                 sLang += buf;
 343                 GetLocaleInfo(loc, LOCALE_SNATIVECTRYNAME, buf, _countof(buf));
 344                 if (buf[0])
 345                 {
 346                         sLang += _T(" (");
 347                         sLang += buf;
 348                         sLang += _T(")");
 349                 }
 350
 351                 int pos = m_ctrlFiles.InsertItem(m_ctrlFiles.GetItemCount(), sLang);
 352
 353                 CString filename;
 354                 filename.Format(_T("TortoiseGit-LanguagePack-%s-%sbit-%s.msi"), version, x86x64, langs.Mid(5));
 355                 m_fileNames.push_back(filename);
 356
 357                 if (std::find(m_installedLangs.begin(), m_installedLangs.end(), loc) != m_installedLangs.end())
 358                         m_ctrlFiles.SetCheck(pos , TRUE);
 359         }
 360         DialogEnableWindow(IDC_BUTTON_UPDATE, TRUE);
 361 }
 362
 363 void CCheckForUpdatesDlg::FillChangelog(CStdioFile &file)
 364 {
 365         CString sChangelogURL;
 366         if (!file.ReadString(sChangelogURL) || sChangelogURL.IsEmpty())
 367                 sChangelogURL = _T("http://tortoisegit.googlecode.com/git/src/Changelog.txt");
 368
 369         CString tempchangelogfile = CTempFiles::Instance().GetTempFilePath(true).GetWinPathString();
 370         HRESULT res = URLDownloadToFile(NULL, sChangelogURL, tempchangelogfile, 0, NULL);
 371         if (SUCCEEDED(res))
 372         {
 373                 CString temp;
 374                 CStdioFile file(tempchangelogfile, CFile::modeRead|CFile::typeText);
 375                 CString str;
 376                 while (file.ReadString(str))
 377                 {
 378                         temp += str + _T("\n");
 379                 }
 380                 ::SendMessage(m_hWnd, WM_USER_FILLCHANGELOG, 0, reinterpret_cast<LPARAM>(temp.GetBuffer()));
 381         }
 382         else
 383                 ::SendMessage(m_hWnd, WM_USER_FILLCHANGELOG, 0, reinterpret_cast<LPARAM>(_T("Could not load changelog.")));
 384 }
 385
 386 void CCheckForUpdatesDlg::OnStnClickedCheckresult()
 387 {
 388         // user clicked on the label, start the browser with our web page
 389         HINSTANCE result = ShellExecute(NULL, _T("opennew"), m_sUpdateDownloadLink, NULL,NULL, SW_SHOWNORMAL);
 390         if ((UINT)result <= HINSTANCE_ERROR)
 391         {
 392                 result = ShellExecute(NULL, _T("open"), m_sUpdateDownloadLink, NULL,NULL, SW_SHOWNORMAL);
 393         }
 394 }
 395
 396 void CCheckForUpdatesDlg::OnTimer(UINT_PTR nIDEvent)
 397 {
 398         if (nIDEvent == 100)
 399         {
 400                 if (m_bThreadRunning == FALSE)
 401                 {
 402                         if (m_bShowInfo)
 403                         {
 404                                 m_bVisible = TRUE;
 405                                 ShowWindow(SW_SHOWNORMAL);
 406                         }
 407                         else
 408                         {
 409                                 EndDialog(0);
 410                         }
 411                 }
 412         }
 413         CStandAloneDialog::OnTimer(nIDEvent);
 414 }
 415
 416 void CCheckForUpdatesDlg::OnWindowPosChanging(WINDOWPOS* lpwndpos)
 417 {
 418         CStandAloneDialog::OnWindowPosChanging(lpwndpos);
 419         if (m_bVisible == FALSE)
 420                 lpwndpos->flags &= ~SWP_SHOWWINDOW;
 421 }
 422
 423 BOOL CCheckForUpdatesDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
 424 {
 425         if ((!m_sUpdateDownloadLink.IsEmpty())&&(pWnd)&&(pWnd == GetDlgItem(IDC_CHECKRESULT)))
 426         {
 427                 HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_HAND));
 428                 SetCursor(hCur);
 429                 return TRUE;
 430         }
 431
 432         HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW));
 433         SetCursor(hCur);
 434         return CStandAloneDialogTmpl<CDialog>::OnSetCursor(pWnd, nHitTest, message);
 435 }
 436
 437 void CCheckForUpdatesDlg::OnBnClickedButtonUpdate()
 438 {
 439         CString title;
 440         m_ctrlUpdate.GetWindowText(title);
 441         if (m_pDownloadThread == NULL && title == CString(MAKEINTRESOURCE(IDS_PROC_DOWNLOAD)))
 442         {
 443                 bool isOneSelected = false;
 444                 for (int i = 0; i < (int)m_ctrlFiles.GetItemCount(); i++)
 445                 {
 446                         if (m_ctrlFiles.GetCheck(i))
 447                         {
 448                                 isOneSelected = true;
 449                                 break;
 450                         }
 451                 }
 452                 if (!isOneSelected)
 453                         return;
 454
 455                 m_eventStop.ResetEvent();
 456
 457                 m_pDownloadThread = ::AfxBeginThread(DownloadThreadEntry, this, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED);
 458                 if (m_pDownloadThread != NULL)
 459                 {
 460                         m_pDownloadThread->m_bAutoDelete = FALSE;
 461                         m_pDownloadThread->ResumeThread();
 462
 463                         GetDlgItem(IDC_BUTTON_UPDATE)->SetWindowText(CString(MAKEINTRESOURCE(IDS_ABORTBUTTON)));
 464                 }
 465                 else
 466                 {
 467                         CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
 468                 }
 469         }
 470         else if (title == CString(MAKEINTRESOURCE(IDS_ABORTBUTTON)))
 471         {
 472                 // Abort
 473                 m_eventStop.SetEvent();
 474         }
 475         else
 476         {
 477                 CString folder = GetDownloadsDirectory();
 478                 if (m_ctrlUpdate.GetCurrentEntry() == 0)
 479                 {
 480                         for (int i = 0; i < (int)m_ctrlFiles.GetItemCount(); i++)
 481                         {
 482                                 if (m_ctrlFiles.GetCheck(i) == TRUE)
 483                                         ShellExecute(NULL, _T("open"), folder + m_fileNames[i], NULL, NULL, SW_SHOWNORMAL);
 484                         }
 485                         ExitProcess(0);
 486                 }
 487                 else if (m_ctrlUpdate.GetCurrentEntry() == 1)
 488                 {
 489                         ShellExecute(NULL, _T("open"), folder, NULL, NULL, SW_SHOWNORMAL);
 490                 }
 491
 492                 m_ctrlUpdate.SetCurrentEntry(0);
 493         }
 494 }
 495
 496 UINT CCheckForUpdatesDlg::DownloadThreadEntry(LPVOID pVoid)
 497 {
 498         return ((CCheckForUpdatesDlg*)pVoid)->DownloadThread();
 499 }
 500
 501 bool CCheckForUpdatesDlg::Download(CString filename)
 502 {
 503         CString destFilename = GetDownloadsDirectory() + filename;
 504         if (PathFileExists(destFilename))
 505         {
 506                 if (VerifySignature(destFilename))
 507                         return true;
 508                 else
 509                         DeleteFile(destFilename);
 510         }
 511
 512         CBSCallbackImpl bsc(this->GetSafeHwnd(), m_eventStop);
 513
 514         CString url = m_sFilesURL + filename;
 515
 516         m_progress.SetRange32(0, 1);
 517         m_progress.SetPos(0);
 518         m_progress.ShowWindow(SW_SHOW);
 519
 520         CString tempfile = CTempFiles::Instance().GetTempFilePath(true).GetWinPathString();
 521         HRESULT res = URLDownloadToFile(NULL, url, tempfile, 0, &bsc);
 522         if (res == S_OK)
 523         {
 524                 if (VerifySignature(tempfile))
 525                 {
 526                         if (PathFileExists(destFilename))
 527                                 DeleteFile(destFilename);
 528                         MoveFile(tempfile, destFilename);
 529                         return true;
 530                 }
 531         }
 532         return false;
 533 }
 534
 535 UINT CCheckForUpdatesDlg::DownloadThread()
 536 {
 537         m_ctrlFiles.SetExtendedStyle(m_ctrlFiles.GetExtendedStyle() & ~LVS_EX_CHECKBOXES);
 538
 539         BOOL result = TRUE;
 540         for (int i = 0; i < (int)m_ctrlFiles.GetItemCount(); i++)
 541         {
 542                 m_ctrlFiles.EnsureVisible(i, FALSE);
 543                 CRect rect;
 544                 m_ctrlFiles.GetItemRect(i, &rect, LVIR_BOUNDS);
 545                 if (m_ctrlFiles.GetCheck(i) == TRUE)
 546                 {
 547                         m_ctrlFiles.SetItemData(i, CUpdateListCtrl::STATUS_DOWNLOADING);
 548                         m_ctrlFiles.InvalidateRect(rect);
 549                         if (Download(m_fileNames[i]))
 550                                 m_ctrlFiles.SetItemData(i, CUpdateListCtrl::STATUS_SUCCESS);
 551                         else
 552                         {
 553                                 m_ctrlFiles.SetItemData(i, CUpdateListCtrl::STATUS_FAIL);
 554                                 result = FALSE;
 555                         }
 556                 }
 557                 else
 558                         m_ctrlFiles.SetItemData(i, CUpdateListCtrl::STATUS_IGNORE);
 559                 m_ctrlFiles.InvalidateRect(rect);
 560         }
 561
 562         ::PostMessage(GetSafeHwnd(), WM_USER_ENDDOWNLOAD, 0, 0);
 563
 564         return result;
 565 }
 566
 567 LRESULT CCheckForUpdatesDlg::OnEndDownload(WPARAM, LPARAM)
 568 {
 569         ASSERT(m_pDownloadThread != NULL);
 570
 571         // wait until the thread terminates
 572         DWORD dwExitCode;
 573         if (::GetExitCodeThread(m_pDownloadThread->m_hThread, &dwExitCode) && dwExitCode == STILL_ACTIVE)
 574                 ::WaitForSingleObject(m_pDownloadThread->m_hThread, INFINITE);
 575
 576         // make sure we always have the correct exit code
 577         ::GetExitCodeThread(m_pDownloadThread->m_hThread, &dwExitCode);
 578
 579         delete m_pDownloadThread;
 580         m_pDownloadThread = NULL;
 581
 582         m_progress.ShowWindow(SW_HIDE);
 583
 584         if (dwExitCode == TRUE)
 585         {
 586                 m_ctrlUpdate.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_INSTALL)));
 587                 m_ctrlUpdate.AddEntry(CString(MAKEINTRESOURCE(IDS_CHECKUPDATE_DESTFOLDER)));
 588                 m_ctrlUpdate.Invalidate();
 589         }
 590         else
 591         {
 592                 m_ctrlUpdate.SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_DOWNLOAD)));
 593                 CMessageBox::Show(NULL, IDS_ERR_FAILEDUPDATEDOWNLOAD, IDS_APPNAME, MB_ICONERROR);
 594         }
 595
 596         return 0;
 597 }
 598
 599 LRESULT CCheckForUpdatesDlg::OnFillChangelog(WPARAM, LPARAM lParam)
 600 {
 601         ASSERT(lParam != NULL);
 602
 603         TCHAR * changelog = reinterpret_cast<TCHAR *>(lParam);
 604         m_cLogMessage.Call(SCI_SETREADONLY, FALSE);
 605         m_cLogMessage.SetText(changelog);
 606         m_cLogMessage.Call(SCI_SETREADONLY, TRUE);
 607         m_cLogMessage.Call(SCI_GOTOPOS, 0);
 608
 609         return 0;
 610 }
 611
 612 CString CCheckForUpdatesDlg::GetDownloadsDirectory()
 613 {
 614         CString folder;
 615
 616         if (SysInfo::Instance().IsVistaOrLater())
 617         {
 618                 CAutoLibrary hShell = ::LoadLibrary(_T("shell32.dll"));
 619                 if (hShell)
 620                 {
 621                         typedef HRESULT STDAPICALLTYPE SHGetKnownFolderPathFN(__in REFKNOWNFOLDERID rfid, __in DWORD dwFlags, __in_opt HANDLE hToken, __deref_out PWSTR *ppszPath);
 622                         SHGetKnownFolderPathFN *pfnSHGetKnownFolderPath = (SHGetKnownFolderPathFN*)GetProcAddress(hShell, "SHGetKnownFolderPath");
 623                         if (pfnSHGetKnownFolderPath)
 624                         {
 625                                 wchar_t * wcharPtr = 0;
 626                                 HRESULT hr = pfnSHGetKnownFolderPath(FOLDERID_Downloads, KF_FLAG_CREATE, NULL, &wcharPtr);
 627                                 if (SUCCEEDED(hr))
 628                                 {
 629                                         folder = wcharPtr;
 630                                         CoTaskMemFree(static_cast<void*>(wcharPtr));
 631                                         return folder.TrimRight(_T("\\")) + _T("\\");
 632                                 }
 633                         }
 634                 }
 635         }
 636
 637         TCHAR szPath[MAX_PATH];
 638         if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_PERSONAL | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, szPath)))
 639                 folder = szPath;
 640         CString downloads = folder.TrimRight(_T("\\")) + _T("\\Downloads\\");
 641         if ((PathFileExists(downloads) && PathIsDirectory(downloads)) || (!PathFileExists(downloads) && CreateDirectory(downloads, NULL)))
 642                 return downloads;
 643
 644         return folder;
 645 }
 646
 647 LRESULT CCheckForUpdatesDlg::OnDisplayStatus(WPARAM, LPARAM lParam)
 648 {
 649         const DOWNLOADSTATUS *const pDownloadStatus = reinterpret_cast<DOWNLOADSTATUS *>(lParam);
 650         if (pDownloadStatus != NULL)
 651         {
 652                 ASSERT(::AfxIsValidAddress(pDownloadStatus, sizeof(DOWNLOADSTATUS)));
 653
 654                 m_progress.SetRange32(0, pDownloadStatus->ulProgressMax);
 655                 m_progress.SetPos(pDownloadStatus->ulProgress);
 656         }
 657
 658         return 0;
 659 }
 660
 661 CBSCallbackImpl::CBSCallbackImpl(HWND hWnd, HANDLE hEventStop)
 662 {
 663         m_hWnd = hWnd;
 664         m_hEventStop = hEventStop;
 665         m_ulObjRefCount = 1;
 666 }
 667
 668 // IUnknown
 669 STDMETHODIMP CBSCallbackImpl::QueryInterface(REFIID riid, void **ppvObject)
 670 {
 671         *ppvObject = NULL;
 672
 673         // IUnknown
 674         if (::IsEqualIID(riid, __uuidof(IUnknown)))
 675                 *ppvObject = this;
 676
 677         // IBindStatusCallback
 678         else if (::IsEqualIID(riid, __uuidof(IBindStatusCallback)))
 679                 *ppvObject = static_cast<IBindStatusCallback *>(this);
 680
 681         if (*ppvObject)
 682         {
 683                 (*reinterpret_cast<LPUNKNOWN *>(ppvObject))->AddRef();
 684                 return S_OK;
 685         }
 686
 687         return E_NOINTERFACE;
 688 }
 689
 690 STDMETHODIMP_(ULONG) CBSCallbackImpl::AddRef()
 691 {
 692         return ++m_ulObjRefCount;
 693 }
 694
 695 STDMETHODIMP_(ULONG) CBSCallbackImpl::Release()
 696 {
 697         return --m_ulObjRefCount;
 698 }
 699
 700 // IBindStatusCallback
 701 STDMETHODIMP CBSCallbackImpl::OnStartBinding(DWORD, IBinding *)
 702 {
 703         return S_OK;
 704 }
 705
 706 STDMETHODIMP CBSCallbackImpl::GetPriority(LONG *)
 707 {
 708         return E_NOTIMPL;
 709 }
 710 STDMETHODIMP CBSCallbackImpl::OnLowResource(DWORD)
 711 {
 712         return S_OK;
 713 }
 714
 715 STDMETHODIMP CBSCallbackImpl::OnProgress(ULONG ulProgress, ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR /* szStatusText */)
 716 {
 717         TRACE(_T("IBindStatusCallback::OnProgress\n"));
 718         TRACE(_T("ulProgress: %lu, ulProgressMax: %lu\n"), ulProgress, ulProgressMax);
 719         UNREFERENCED_PARAMETER(ulStatusCode);
 720         TRACE(_T("ulStatusCode: %lu "), ulStatusCode);
 721
 722         if (m_hWnd != NULL)
 723         {
 724                 // inform the dialog box to display current status,
 725                 // don't use PostMessage
 726                 CCheckForUpdatesDlg::DOWNLOADSTATUS downloadStatus = { ulProgress, ulProgressMax };
 727                 ::SendMessage(m_hWnd, WM_USER_DISPLAYSTATUS, 0, reinterpret_cast<LPARAM>(&downloadStatus));
 728         }
 729
 730         if (m_hEventStop != NULL && ::WaitForSingleObject(m_hEventStop, 0) == WAIT_OBJECT_0)
 731         {
 732                 return E_ABORT;  // canceled by the user
 733         }
 734
 735         return S_OK;
 736 }
 737
 738 STDMETHODIMP CBSCallbackImpl::OnStopBinding(HRESULT, LPCWSTR)
 739 {
 740         return S_OK;
 741 }
 742
 743 STDMETHODIMP CBSCallbackImpl::GetBindInfo(DWORD *, BINDINFO *)
 744 {
 745         return S_OK;
 746 }
 747
 748 STDMETHODIMP CBSCallbackImpl::OnDataAvailable(DWORD, DWORD, FORMATETC *, STGMEDIUM *)
 749 {
 750         return S_OK;
 751 }
 752
 753 STDMETHODIMP CBSCallbackImpl::OnObjectAvailable(REFIID, IUnknown *)
 754 {
 755         return S_OK;
 756 }
 757
 758 BOOL CCheckForUpdatesDlg::VerifySignature(CString fileName)
 759 {
 760         WINTRUST_FILE_INFO fileInfo;
 761         memset(&fileInfo, 0, sizeof(fileInfo));
 762         fileInfo.cbStruct = sizeof(WINTRUST_FILE_INFO);
 763         fileInfo.pcwszFilePath = fileName;
 764
 765         WINTRUST_DATA data;
 766         memset(&data, 0, sizeof(data));
 767         data.cbStruct = sizeof(data);
 768
 769         data.dwUIChoice = WTD_UI_NONE;
 770         data.fdwRevocationChecks = WTD_REVOKE_NONE;
 771         data.dwUnionChoice = WTD_CHOICE_FILE;
 772         data.pFile = &fileInfo;
 773
 774         GUID policyGUID = WINTRUST_ACTION_GENERIC_VERIFY_V2;
 775
 776         return (WinVerifyTrust(NULL, &policyGUID, &data) == ERROR_SUCCESS);
 777 }