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