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-2017 - 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 "Git.h"
  23 #include "LoglistCommonResource.h"
  24 #include "../version.h"
  25 #include "MessageBox.h"
  26 #include "CheckForUpdatesDlg.h"
  27 #include "registry.h"
  28 #include "AppUtils.h"
  29 #include "TempFile.h"
  30 #include "SmartHandle.h"
  31 #include "SysInfo.h"
  32 #include "PathUtils.h"
  33 #include "DirFileEnum.h"
  34 #include "UnicodeUtils.h"
  35 #include "UpdateCrypto.h"
  36 #include <MsiDefs.h>
  37 #include <MsiQuery.h>
  38
  39 #pragma comment(lib, "msi.lib")
  40
  41 #define SIGNATURE_FILE_ENDING L".rsa.asc"
  42
  43 #define WM_USER_DISPLAYSTATUS   (WM_USER + 1)
  44 #define WM_USER_ENDDOWNLOAD             (WM_USER + 2)
  45 #define WM_USER_FILLCHANGELOG   (WM_USER + 3)
  46
  47 IMPLEMENT_DYNAMIC(CCheckForUpdatesDlg, CResizableStandAloneDialog)
  48 CCheckForUpdatesDlg::CCheckForUpdatesDlg(CWnd* pParent /*=nullptr*/)
  49         : CResizableStandAloneDialog(CCheckForUpdatesDlg::IDD, pParent)
  50         , m_bShowInfo(FALSE)
  51         , m_bForce(FALSE)
  52         , m_bVisible(FALSE)
  53         , m_pDownloadThread(nullptr)
  54         , m_bThreadRunning(FALSE)
  55         , m_updateDownloader(nullptr)
  56         , m_sUpdateDownloadLink(L"https://tortoisegit.org/download")
  57 {
  58 }
  59
  60 CCheckForUpdatesDlg::~CCheckForUpdatesDlg()
  61 {
  62 }
  63
  64 void CCheckForUpdatesDlg::DoDataExchange(CDataExchange* pDX)
  65 {
  66         CResizableStandAloneDialog::DoDataExchange(pDX);
  67         DDX_Control(pDX, IDC_LINK, m_link);
  68         DDX_Control(pDX, IDC_PROGRESSBAR, m_progress);
  69         DDX_Control(pDX, IDC_LIST_DOWNLOADS, m_ctrlFiles);
  70         DDX_Control(pDX, IDC_BUTTON_UPDATE, m_ctrlUpdate);
  71         DDX_Control(pDX, IDC_LOGMESSAGE, m_cLogMessage);
  72 }
  73
  74 BEGIN_MESSAGE_MAP(CCheckForUpdatesDlg, CResizableStandAloneDialog)
  75         ON_WM_TIMER()
  76         ON_WM_WINDOWPOSCHANGING()
  77         ON_WM_SETCURSOR()
  78         ON_WM_DESTROY()
  79         ON_WM_SYSCOLORCHANGE()
  80         ON_BN_CLICKED(IDC_BUTTON_UPDATE, OnBnClickedButtonUpdate)
  81         ON_MESSAGE(WM_USER_DISPLAYSTATUS, OnDisplayStatus)
  82         ON_MESSAGE(WM_USER_ENDDOWNLOAD, OnEndDownload)
  83         ON_MESSAGE(WM_USER_FILLCHANGELOG, OnFillChangelog)
  84         ON_REGISTERED_MESSAGE(TaskBarButtonCreated, OnTaskbarBtnCreated)
  85         ON_BN_CLICKED(IDC_DONOTASKAGAIN, &CCheckForUpdatesDlg::OnBnClickedDonotaskagain)
  86 END_MESSAGE_MAP()
  87
  88 BOOL CCheckForUpdatesDlg::OnInitDialog()
  89 {
  90         CResizableStandAloneDialog::OnInitDialog();
  91         CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
  92
  93         CString temp;
  94         temp.Format(IDS_CHECKNEWER_YOURVERSION, TGIT_VERMAJOR, TGIT_VERMINOR, TGIT_VERMICRO, TGIT_VERBUILD);
  95         SetDlgItemText(IDC_YOURVERSION, temp);
  96
  97         DialogEnableWindow(IDOK, FALSE);
  98
  99         m_pTaskbarList.Release();
 100         if (FAILED(m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList)))
 101                 m_pTaskbarList = nullptr;
 102
 103         // hide download controls
 104         m_ctrlFiles.ShowWindow(SW_HIDE);
 105         GetDlgItem(IDC_GROUP_DOWNLOADS)->ShowWindow(SW_HIDE);
 106         RECT rectWindow, rectGroupDownloads, rectOKButton;
 107         GetWindowRect(&rectWindow);
 108         GetDlgItem(IDC_GROUP_DOWNLOADS)->GetWindowRect(&rectGroupDownloads);
 109         GetDlgItem(IDOK)->GetWindowRect(&rectOKButton);
 110         LONG bottomDistance = rectWindow.bottom - rectOKButton.bottom;
 111         OffsetRect(&rectOKButton, 0, rectGroupDownloads.top - rectOKButton.top);
 112         rectWindow.bottom = rectOKButton.bottom + bottomDistance;
 113         SetMinTrackSize(CSize(rectWindow.right - rectWindow.left, rectWindow.bottom - rectWindow.top));
 114         MoveWindow(&rectWindow);
 115         ::MapWindowPoints(nullptr, GetSafeHwnd(), (LPPOINT)&rectOKButton, 2);
 116         GetDlgItem(IDOK)->MoveWindow(&rectOKButton);
 117
 118         temp.LoadString(IDS_STATUSLIST_COLFILE);
 119         m_ctrlFiles.InsertColumn(0, temp, 0, -1);
 120         m_ctrlFiles.InsertColumn(1, temp, 0, -1);
 121         m_ctrlFiles.SetExtendedStyle(LVS_EX_DOUBLEBUFFER | LVS_EX_CHECKBOXES);
 122         m_ctrlFiles.SetColumnWidth(0, 350);
 123         m_ctrlFiles.SetColumnWidth(1, 200);
 124
 125         m_cLogMessage.Init(-1);
 126         m_cLogMessage.SetFont(CAppUtils::GetLogFontName(), CAppUtils::GetLogFontSize());
 127         m_cLogMessage.Call(SCI_SETREADONLY, TRUE);
 128
 129         m_updateDownloader = new CUpdateDownloader(GetSafeHwnd(), m_bForce == TRUE, WM_USER_DISPLAYSTATUS, &m_eventStop);
 130
 131         if (!AfxBeginThread(CheckThreadEntry, this))
 132         {
 133                 CMessageBox::Show(GetSafeHwnd(), IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
 134         }
 135
 136         AddAnchor(IDC_YOURVERSION, TOP_LEFT, TOP_RIGHT);
 137         AddAnchor(IDC_CURRENTVERSION, TOP_LEFT, TOP_RIGHT);
 138         AddAnchor(IDC_CHECKRESULT, TOP_LEFT, TOP_RIGHT);
 139         AddAnchor(IDC_LINK, TOP_LEFT, TOP_RIGHT);
 140         AddAnchor(IDC_GROUP_CHANGELOG, TOP_LEFT, BOTTOM_RIGHT);
 141         AddAnchor(IDC_LOGMESSAGE, TOP_LEFT, BOTTOM_RIGHT);
 142         AddAnchor(IDC_GROUP_DOWNLOADS, BOTTOM_LEFT, BOTTOM_RIGHT);
 143         AddAnchor(IDC_LIST_DOWNLOADS, BOTTOM_LEFT, BOTTOM_RIGHT);
 144         AddAnchor(IDC_PROGRESSBAR, BOTTOM_LEFT, BOTTOM_RIGHT);
 145         AddAnchor(IDC_BUTTON_UPDATE, BOTTOM_RIGHT);
 146         AddAnchor(IDOK, BOTTOM_CENTER);
 147
 148         SetTimer(100, 1000, nullptr);
 149         return TRUE;
 150 }
 151
 152 void CCheckForUpdatesDlg::OnDestroy()
 153 {
 154         for (int i = 0; i < m_ctrlFiles.GetItemCount(); ++i)
 155                 delete (CUpdateListCtrl::Entry *)m_ctrlFiles.GetItemData(i);
 156
 157         delete m_updateDownloader;
 158
 159         CResizableStandAloneDialog::OnDestroy();
 160 }
 161
 162 void CCheckForUpdatesDlg::OnOK()
 163 {
 164         if (m_bThreadRunning || m_pDownloadThread)
 165                 return; // Don't exit while downloading
 166
 167         CResizableStandAloneDialog::OnOK();
 168 }
 169
 170 void CCheckForUpdatesDlg::OnCancel()
 171 {
 172         if (m_bThreadRunning || m_pDownloadThread)
 173                 return; // Don't exit while downloading
 174         CResizableStandAloneDialog::OnCancel();
 175 }
 176
 177 UINT CCheckForUpdatesDlg::CheckThreadEntry(LPVOID pVoid)
 178 {
 179         return reinterpret_cast<CCheckForUpdatesDlg*>(pVoid)->CheckThread();
 180 }
 181
 182 UINT CCheckForUpdatesDlg::CheckThread()
 183 {
 184         m_bThreadRunning = TRUE;
 185
 186         CString temp;
 187         CString tempfile = CTempFiles::Instance().GetTempFilePath(true).GetWinPathString();
 188
 189         bool official = false;
 190
 191         CRegString checkurluser = CRegString(L"Software\\TortoiseGit\\UpdateCheckURL", L"");
 192         CRegString checkurlmachine = CRegString(L"Software\\TortoiseGit\\UpdateCheckURL", L"", FALSE, HKEY_LOCAL_MACHINE);
 193         CString sCheckURL = checkurluser;
 194         if (sCheckURL.IsEmpty())
 195         {
 196                 sCheckURL = checkurlmachine;
 197                 if (sCheckURL.IsEmpty())
 198                 {
 199                         official = true;
 200                         bool checkPreview = false;
 201 #if PREVIEW
 202                         checkPreview = true;
 203 #else
 204                         CRegStdDWORD regCheckPreview(L"Software\\TortoiseGit\\VersionCheckPreview", FALSE);
 205                         if (DWORD(regCheckPreview))
 206                                 checkPreview = true;
 207 #endif
 208                         if (checkPreview)
 209                         {
 210                                 sCheckURL = L"https://versioncheck.tortoisegit.org/version-preview.txt";
 211                                 SetDlgItemText(IDC_SOURCE, L"Using preview release channel");
 212                         }
 213                         else
 214                                 sCheckURL = L"https://versioncheck.tortoisegit.org/version.txt";
 215                 }
 216         }
 217
 218         if (!official && CStringUtils::StartsWith(sCheckURL, L"https://versioncheck.tortoisegit.org/"))
 219                 official = true;
 220
 221         if (!official)
 222                 SetDlgItemText(IDC_SOURCE, L"Using (unofficial) release channel: " + sCheckURL);
 223
 224         CString errorText;
 225         CVersioncheckParser versioncheck;
 226         CVersioncheckParser::Version version;
 227         DWORD ret = m_updateDownloader->DownloadFile(sCheckURL, tempfile, false);
 228         if (!ret && official)
 229         {
 230                 CString signatureTempfile = CTempFiles::Instance().GetTempFilePath(true).GetWinPathString();
 231                 ret = m_updateDownloader->DownloadFile(sCheckURL + SIGNATURE_FILE_ENDING, signatureTempfile, false);
 232                 if (ret || VerifyIntegrity(tempfile, signatureTempfile, m_updateDownloader))
 233                 {
 234                         CString error = L"Could not verify digital signature.";
 235                         if (ret)
 236                                 error += L"\r\nError: " + GetWinINetError(ret) + L" (on " + sCheckURL + SIGNATURE_FILE_ENDING + L")";
 237                         SetDlgItemText(IDC_CHECKRESULT, error);
 238                         DeleteUrlCacheEntry(sCheckURL);
 239                         DeleteUrlCacheEntry(sCheckURL + SIGNATURE_FILE_ENDING);
 240                         goto finish;
 241                 }
 242         }
 243         else if (ret)
 244         {
 245                 DeleteUrlCacheEntry(sCheckURL);
 246                 if (CRegDWORD(L"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\GlobalUserOffline", 0))
 247                         errorText.LoadString(IDS_OFFLINEMODE); // offline mode enabled
 248                 else
 249                         errorText.Format(IDS_CHECKNEWER_NETERROR_FORMAT, (LPCTSTR)(GetWinINetError(ret) + L" URL: " + sCheckURL), ret);
 250                 SetDlgItemText(IDC_CHECKRESULT, errorText);
 251                 goto finish;
 252         }
 253
 254         if (!versioncheck.Load(tempfile, errorText))
 255         {
 256                 if (!errorText.IsEmpty())
 257                         SetDlgItemText(IDC_CHECKRESULT, errorText);
 258                 else
 259                 {
 260                         temp.LoadString(IDS_CHECKNEWER_NETERROR);
 261                         SetDlgItemText(IDC_CHECKRESULT, temp);
 262                 }
 263                 DeleteUrlCacheEntry(sCheckURL);
 264                 goto finish;
 265         }
 266
 267         version = versioncheck.GetTortoiseGitVersion();
 268         {
 269                 BOOL bNewer = FALSE;
 270                 if (m_bForce)
 271                         bNewer = TRUE;
 272                 else if (version.major > TGIT_VERMAJOR)
 273                         bNewer = TRUE;
 274                 else if ((version.minor > TGIT_VERMINOR) && (version.major == TGIT_VERMAJOR))
 275                         bNewer = TRUE;
 276                 else if ((version.micro > TGIT_VERMICRO) && (version.minor == TGIT_VERMINOR) && (version.major == TGIT_VERMAJOR))
 277                         bNewer = TRUE;
 278                 else if ((version.build > TGIT_VERBUILD) && (version.micro == TGIT_VERMICRO) && (version.minor == TGIT_VERMINOR) && (version.major == TGIT_VERMAJOR))
 279                         bNewer = TRUE;
 280
 281                 m_sNewVersionNumber.Format(L"%u.%u.%u.%u", version.major, version.minor, version.micro, version.build);
 282                 if (m_sNewVersionNumber != version.version_for_filename)
 283                 {
 284                         CString versionstr = m_sNewVersionNumber + L" (" + version.version_for_filename + L")";
 285                         temp.Format(IDS_CHECKNEWER_CURRENTVERSION, (LPCTSTR)versionstr);
 286                 }
 287                 else
 288                         temp.Format(IDS_CHECKNEWER_CURRENTVERSION, (LPCTSTR)m_sNewVersionNumber);
 289                 SetDlgItemText(IDC_CURRENTVERSION, temp);
 290
 291                 if (bNewer)
 292                 {
 293                         temp = versioncheck.GetTortoiseGitInfoText();
 294                         if (!temp.IsEmpty())
 295                         {
 296                                 CString tempLink = versioncheck.GetTortoiseGitInfoTextURL();
 297                                 if (!tempLink.IsEmpty()) // find out the download link-URL, if any
 298                                         m_sUpdateDownloadLink = tempLink;
 299                         }
 300                         else
 301                                 temp.LoadString(IDS_CHECKNEWER_NEWERVERSIONAVAILABLE);
 302                         SetDlgItemText(IDC_CHECKRESULT, temp);
 303
 304                         FillChangelog(versioncheck, official);
 305                         FillDownloads(versioncheck);
 306
 307                         RemoveAnchor(IDC_GROUP_CHANGELOG);
 308                         RemoveAnchor(IDC_LOGMESSAGE);
 309                         RemoveAnchor(IDC_GROUP_DOWNLOADS);
 310                         RemoveAnchor(IDC_LIST_DOWNLOADS);
 311                         RemoveAnchor(IDC_PROGRESSBAR);
 312                         RemoveAnchor(IDC_DONOTASKAGAIN);
 313                         RemoveAnchor(IDC_BUTTON_UPDATE);
 314                         RemoveAnchor(IDOK);
 315
 316                         // Show download controls
 317                         RECT rectWindow, rectProgress, rectGroupDownloads, rectOKButton;
 318                         GetWindowRect(&rectWindow);
 319                         m_progress.GetWindowRect(&rectProgress);
 320                         GetDlgItem(IDC_GROUP_DOWNLOADS)->GetWindowRect(&rectGroupDownloads);
 321                         GetDlgItem(IDOK)->GetWindowRect(&rectOKButton);
 322                         LONG bottomDistance = rectWindow.bottom - rectOKButton.bottom;
 323                         OffsetRect(&rectOKButton, 0, (rectGroupDownloads.bottom + (rectGroupDownloads.bottom - rectProgress.bottom)) - rectOKButton.top);
 324                         rectWindow.bottom = rectOKButton.bottom + bottomDistance;
 325                         SetMinTrackSize(CSize(rectWindow.right - rectWindow.left, rectWindow.bottom - rectWindow.top));
 326                         MoveWindow(&rectWindow);
 327                         ::MapWindowPoints(nullptr, GetSafeHwnd(), (LPPOINT)&rectOKButton, 2);
 328                         if (CRegDWORD(L"Software\\TortoiseGit\\VersionCheck", TRUE) != FALSE && !m_bForce && !m_bShowInfo)
 329                         {
 330                                 GetDlgItem(IDC_DONOTASKAGAIN)->ShowWindow(SW_SHOW);
 331                                 rectOKButton.left += 60;
 332                                 temp.LoadString(IDS_REMINDMELATER);
 333                                 GetDlgItem(IDOK)->SetWindowText(temp);
 334                                 rectOKButton.right += 160;
 335                         }
 336                         GetDlgItem(IDOK)->MoveWindow(&rectOKButton);
 337                         AddAnchor(IDC_GROUP_CHANGELOG, TOP_LEFT, BOTTOM_RIGHT);
 338                         AddAnchor(IDC_LOGMESSAGE, TOP_LEFT, BOTTOM_RIGHT);
 339                         AddAnchor(IDC_GROUP_DOWNLOADS, BOTTOM_LEFT, BOTTOM_RIGHT);
 340                         AddAnchor(IDC_LIST_DOWNLOADS, BOTTOM_LEFT, BOTTOM_RIGHT);
 341                         AddAnchor(IDC_PROGRESSBAR, BOTTOM_LEFT, BOTTOM_RIGHT);
 342                         AddAnchor(IDC_DONOTASKAGAIN, BOTTOM_CENTER);
 343                         AddAnchor(IDC_BUTTON_UPDATE, BOTTOM_RIGHT);
 344                         AddAnchor(IDOK, BOTTOM_CENTER);
 345                         m_ctrlFiles.ShowWindow(SW_SHOW);
 346                         GetDlgItem(IDC_GROUP_DOWNLOADS)->ShowWindow(SW_SHOW);
 347                         CenterWindow();
 348                         m_bShowInfo = TRUE;
 349                 }
 350                 else if (m_bShowInfo)
 351                 {
 352                         temp.LoadString(IDS_CHECKNEWER_YOURUPTODATE);
 353                         SetDlgItemText(IDC_CHECKRESULT, temp);
 354                         FillChangelog(versioncheck, official);
 355                 }
 356         }
 357
 358 finish:
 359         if (!m_sUpdateDownloadLink.IsEmpty())
 360         {
 361                 m_link.ShowWindow(SW_SHOW);
 362                 m_link.SetURL(m_sUpdateDownloadLink);
 363         }
 364         m_bThreadRunning = FALSE;
 365         DialogEnableWindow(IDOK, TRUE);
 366         return 0;
 367 }
 368
 369 void CCheckForUpdatesDlg::FillDownloads(CVersioncheckParser& versioncheck)
 370 {
 371         m_sFilesURL = versioncheck.GetTortoiseGitBaseURL();
 372
 373         bool isHotfix = versioncheck.GetTortoiseGitIsHotfix();
 374         if (isHotfix)
 375                 m_ctrlFiles.InsertItem(0, L"TortoiseGit Hotfix");
 376         else
 377                 m_ctrlFiles.InsertItem(0, L"TortoiseGit");
 378         CString filenameMain = versioncheck.GetTortoiseGitMainfilename();
 379         m_ctrlFiles.SetItemData(0, (DWORD_PTR)(new CUpdateListCtrl::Entry(filenameMain, CUpdateListCtrl::STATUS_NONE)));
 380         m_ctrlFiles.SetCheck(0 , TRUE);
 381
 382         if (isHotfix)
 383         {
 384                 DialogEnableWindow(IDC_BUTTON_UPDATE, TRUE);
 385                 return;
 386         }
 387
 388         struct LangPack
 389         {
 390                 CVersioncheckParser::LanguagePack languagepack;
 391                 bool m_Installed;
 392         };
 393         std::vector<LangPack> availableLangs;
 394         std::vector<DWORD> installedLangs;
 395         {
 396                 // set up the language selecting combobox
 397                 CString path = CPathUtils::GetAppParentDirectory();
 398                 path = path + L"Languages\\";
 399                 CSimpleFileFind finder(path, L"*.dll");
 400                 while (finder.FindNextFileNoDirectories())
 401                 {
 402                         CString file = finder.GetFilePath();
 403                         CString filename = finder.GetFileName();
 404                         if (CStringUtils::StartsWithI(filename, L"TortoiseProc"))
 405                         {
 406                                 CString sVer = _T(STRPRODUCTVER);
 407                                 sVer = sVer.Left(sVer.ReverseFind('.'));
 408                                 CString sFileVer = CPathUtils::GetVersionFromFile(file);
 409                                 sFileVer = sFileVer.Left(sFileVer.ReverseFind('.'));
 410                                 CString sLoc = filename.Mid(12);
 411                                 sLoc = sLoc.Left(sLoc.GetLength() - 4); // cut off ".dll"
 412                                 if (CStringUtils::StartsWith(sLoc, L"32") && (sLoc.GetLength() > 5))
 413                                         continue;
 414                                 DWORD loc = _wtoi(filename.Mid(12));
 415                                 installedLangs.push_back(loc);
 416                         }
 417                 }
 418         }
 419
 420         for (auto& languagepack : versioncheck.GetTortoiseGitLanguagePacks())
 421         {
 422                 bool installed = std::find(installedLangs.cbegin(), installedLangs.cend(), languagepack.m_LocaleID) != installedLangs.cend();
 423                 LangPack pack = { languagepack, installed };
 424                 availableLangs.push_back(pack);
 425         }
 426         std::stable_sort(availableLangs.begin(), availableLangs.end(), [&](const LangPack& a, const LangPack& b) -> int
 427         {
 428                 return (a.m_Installed && !b.m_Installed) ? 1 : (!a.m_Installed && b.m_Installed) ? 0 : (a.languagepack.m_PackName.Compare(b.languagepack.m_PackName) < 0);
 429         });
 430         for (const auto& langs : availableLangs)
 431         {
 432                 int pos = m_ctrlFiles.InsertItem(m_ctrlFiles.GetItemCount(), langs.languagepack.m_PackName);
 433                 m_ctrlFiles.SetItemText(pos, 1, langs.languagepack.m_LangName);
 434                 m_ctrlFiles.SetItemData(pos, (DWORD_PTR)(new CUpdateListCtrl::Entry(langs.languagepack.m_filename, CUpdateListCtrl::STATUS_NONE)));
 435
 436                 if (langs.m_Installed)
 437                         m_ctrlFiles.SetCheck(pos , TRUE);
 438         }
 439         DialogEnableWindow(IDC_BUTTON_UPDATE, TRUE);
 440 }
 441
 442 void CCheckForUpdatesDlg::FillChangelog(CVersioncheckParser& versioncheck, bool official)
 443 {
 444         ProjectProperties pp;
 445         pp.lProjectLanguage = -1;
 446         pp.sUrl = versioncheck.GetTortoiseGitIssuesURL();
 447         if (!pp.sUrl.IsEmpty())
 448         {
 449                 pp.SetCheckRe(L"[Ii]ssues?:?(\\s*(,|and)?\\s*#?\\d+)+");
 450                 pp.SetBugIDRe(L"(\\d+)");
 451         }
 452         m_cLogMessage.Init(pp);
 453
 454         CString sChangelogURL;
 455         sChangelogURL.FormatMessage(versioncheck.GetTortoiseGitChangelogURL(), TGIT_VERMAJOR, TGIT_VERMINOR, TGIT_VERMICRO, (LPCTSTR)m_updateDownloader->m_sWindowsPlatform, (LPCTSTR)m_updateDownloader->m_sWindowsVersion, (LPCTSTR)m_updateDownloader->m_sWindowsServicePack);
 456
 457         CString tempchangelogfile = CTempFiles::Instance().GetTempFilePath(true).GetWinPathString();
 458         DWORD err;
 459         if ((err = m_updateDownloader->DownloadFile(sChangelogURL, tempchangelogfile, false)) != ERROR_SUCCESS)
 460         {
 461                 CString msg = L"Could not load changelog.\r\nError: " + GetWinINetError(err) + L" (on " + sChangelogURL + L")";
 462                 ::SendMessage(m_hWnd, WM_USER_FILLCHANGELOG, 0, reinterpret_cast<LPARAM>((LPCTSTR)msg));
 463                 return;
 464         }
 465         if (official)
 466         {
 467                 CString signatureTempfile = CTempFiles::Instance().GetTempFilePath(true).GetWinPathString();
 468                 if ((err = m_updateDownloader->DownloadFile(sChangelogURL + SIGNATURE_FILE_ENDING, signatureTempfile, false)) != ERROR_SUCCESS || VerifyIntegrity(tempchangelogfile, signatureTempfile, m_updateDownloader))
 469                 {
 470                         CString error = L"Could not verify digital signature.";
 471                         if (err)
 472                                 error += L"\r\nError: " + GetWinINetError(err) + L" (on " + sChangelogURL + SIGNATURE_FILE_ENDING + L")";
 473                         ::SendMessage(m_hWnd, WM_USER_FILLCHANGELOG, 0, reinterpret_cast<LPARAM>((LPCTSTR)error));
 474                         DeleteUrlCacheEntry(sChangelogURL);
 475                         DeleteUrlCacheEntry(sChangelogURL + SIGNATURE_FILE_ENDING);
 476                         return;
 477                 }
 478         }
 479
 480         CString temp;
 481         CStdioFile file;
 482         if (file.Open(tempchangelogfile, CFile::modeRead | CFile::typeBinary))
 483         {
 484                 auto buf = std::make_unique<BYTE[]>((UINT)file.GetLength());
 485                 UINT read = file.Read(buf.get(), (UINT)file.GetLength());
 486                 bool skipBom = read >= 3 && buf[0] == 0xEF && buf[1] == 0xBB && buf[2] == 0xBF;
 487                 CGit::StringAppend(&temp, buf.get() + (skipBom ? 3 : 0), CP_UTF8, read - (skipBom ? 3 : 0));
 488         }
 489         else
 490                 temp = L"Could not open downloaded changelog file.";
 491         ::SendMessage(m_hWnd, WM_USER_FILLCHANGELOG, 0, reinterpret_cast<LPARAM>((LPCTSTR)temp));
 492 }
 493
 494 void CCheckForUpdatesDlg::OnTimer(UINT_PTR nIDEvent)
 495 {
 496         if (nIDEvent == 100)
 497         {
 498                 if (m_bThreadRunning == FALSE)
 499                 {
 500                         KillTimer(100);
 501                         if (m_bShowInfo)
 502                         {
 503                                 m_bVisible = TRUE;
 504                                 ShowWindow(SW_SHOWNORMAL);
 505                         }
 506                         else
 507                                 EndDialog(0);
 508                 }
 509         }
 510         CResizableStandAloneDialog::OnTimer(nIDEvent);
 511 }
 512
 513 void CCheckForUpdatesDlg::OnWindowPosChanging(WINDOWPOS* lpwndpos)
 514 {
 515         CResizableStandAloneDialog::OnWindowPosChanging(lpwndpos);
 516         if (m_bVisible == FALSE)
 517                 lpwndpos->flags &= ~SWP_SHOWWINDOW;
 518 }
 519
 520 BOOL CCheckForUpdatesDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
 521 {
 522         HCURSOR hCur = LoadCursor(nullptr, IDC_ARROW);
 523         SetCursor(hCur);
 524         return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);
 525 }
 526
 527 void CCheckForUpdatesDlg::OnBnClickedButtonUpdate()
 528 {
 529         CString title;
 530         m_ctrlUpdate.GetWindowText(title);
 531         if (!m_pDownloadThread && title == CString(MAKEINTRESOURCE(IDS_PROC_DOWNLOAD)))
 532         {
 533                 bool isOneSelected = false;
 534                 for (int i = 0; i < (int)m_ctrlFiles.GetItemCount(); ++i)
 535                 {
 536                         if (m_ctrlFiles.GetCheck(i))
 537                         {
 538                                 isOneSelected = true;
 539                                 break;
 540                         }
 541                 }
 542                 if (!isOneSelected)
 543                         return;
 544
 545                 m_eventStop.ResetEvent();
 546
 547                 m_pDownloadThread = ::AfxBeginThread(DownloadThreadEntry, this, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED);
 548                 if (m_pDownloadThread)
 549                 {
 550                         m_pDownloadThread->m_bAutoDelete = FALSE;
 551                         m_pDownloadThread->ResumeThread();
 552
 553                         GetDlgItem(IDC_BUTTON_UPDATE)->SetWindowText(CString(MAKEINTRESOURCE(IDS_ABORTBUTTON)));
 554                 }
 555                 else
 556                         CMessageBox::Show(GetSafeHwnd(), IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
 557         }
 558         else if (title == CString(MAKEINTRESOURCE(IDS_ABORTBUTTON)))
 559         {
 560                 // Abort
 561                 m_eventStop.SetEvent();
 562         }
 563         else
 564         {
 565                 CString folder = GetDownloadsDirectory();
 566                 if (m_ctrlUpdate.GetCurrentEntry() == 0)
 567                 {
 568                         for (int i = 0; i < (int)m_ctrlFiles.GetItemCount(); ++i)
 569                         {
 570                                 CUpdateListCtrl::Entry *data = (CUpdateListCtrl::Entry *)m_ctrlFiles.GetItemData(i);
 571                                 if (m_ctrlFiles.GetCheck(i) == TRUE)
 572                                         ShellExecute(GetSafeHwnd(), L"open", folder + data->m_filename, nullptr, nullptr, SW_SHOWNORMAL);
 573                         }
 574                         CResizableStandAloneDialog::OnOK();
 575                 }
 576                 else if (m_ctrlUpdate.GetCurrentEntry() == 1)
 577                         ShellExecute(GetSafeHwnd(), L"open", folder, nullptr, nullptr, SW_SHOWNORMAL);
 578
 579                 m_ctrlUpdate.SetCurrentEntry(0);
 580         }
 581 }
 582
 583 UINT CCheckForUpdatesDlg::DownloadThreadEntry(LPVOID pVoid)
 584 {
 585         return reinterpret_cast<CCheckForUpdatesDlg*>(pVoid)->DownloadThread();
 586 }
 587
 588 bool CCheckForUpdatesDlg::VerifyUpdateFile(const CString& filename, const CString& filenameSignature, const CString& reportingFilename)
 589 {
 590         if (VerifyIntegrity(filename, filenameSignature, m_updateDownloader) != 0)
 591         {
 592                 m_sErrors += reportingFilename + SIGNATURE_FILE_ENDING + L": Invalid digital signature.\r\n";
 593                 return false;
 594         }
 595
 596         MSIHANDLE hSummary;
 597         DWORD ret = 0;
 598         if ((ret = MsiGetSummaryInformation(NULL, filename, 0, &hSummary)) != 0)
 599         {
 600                 CString sFileVer = CPathUtils::GetVersionFromFile(filename);
 601                 sFileVer.Trim();
 602                 if (sFileVer.IsEmpty())
 603                 {
 604                         m_sErrors.AppendFormat(L"%s: Invalid filetype found (neither executable nor MSI).\r\n", (LPCTSTR)reportingFilename);
 605                         CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": MsiGetSummaryInformation reported: %s\n", (LPCTSTR)CFormatMessageWrapper(ret));
 606                         return false;
 607                 }
 608                 else if (sFileVer == m_sNewVersionNumber)
 609                         return true;
 610
 611                 m_sErrors.AppendFormat(L"%s: Version number of downloaded file doesn't match (expected: \"%s\", got: \"%s\").\r\n", (LPCTSTR)reportingFilename, (LPCTSTR)m_sNewVersionNumber, (LPCTSTR)sFileVer);
 612                 return false;
 613         }
 614         SCOPE_EXIT{ MsiCloseHandle(hSummary); };
 615
 616         UINT uiDataType = 0;
 617         DWORD cchValue = 4096;
 618         CString buffer;
 619         int intValue;
 620         if (MsiSummaryInfoGetProperty(hSummary, PID_SUBJECT, &uiDataType, &intValue, nullptr, CStrBuf(buffer, cchValue + 1), &cchValue))
 621         {
 622                 m_sErrors.AppendFormat(L"%s: Error obtaining version of MSI file (%s).\r\n", (LPCTSTR)reportingFilename, (LPCTSTR)CFormatMessageWrapper(ret));
 623                 return false;
 624         }
 625
 626         if (VT_LPSTR != uiDataType)
 627         {
 628                 m_sErrors.AppendFormat(L"%s: Error obtaining version of MSI file (invalid data type returned).\r\n", (LPCTSTR)reportingFilename);
 629                 return false;
 630         }
 631
 632         CString sFileVer = buffer.Right(m_sNewVersionNumber.GetLength() + 1);
 633         if (sFileVer != L"v" + m_sNewVersionNumber)
 634         {
 635                 m_sErrors.AppendFormat(L"%s: Version number of downloaded file doesn't match (expected: \"v%s\", got: \"%s\").\r\n", (LPCTSTR)reportingFilename, (LPCTSTR)m_sNewVersionNumber, (LPCTSTR)sFileVer);
 636                 return false;
 637         }
 638
 639         return true;
 640 }
 641
 642 bool CCheckForUpdatesDlg::Download(CString filename)
 643 {
 644         CString url = m_sFilesURL + filename;
 645         CString destFilename = GetDownloadsDirectory() + filename;
 646         if (PathFileExists(destFilename) && PathFileExists(destFilename + SIGNATURE_FILE_ENDING))
 647         {
 648                 if (VerifyUpdateFile(destFilename, destFilename + SIGNATURE_FILE_ENDING, destFilename))
 649                         return true;
 650                 else
 651                 {
 652                         DeleteFile(destFilename);
 653                         DeleteFile(destFilename + SIGNATURE_FILE_ENDING);
 654                         DeleteUrlCacheEntry(url);
 655                         DeleteUrlCacheEntry(url + SIGNATURE_FILE_ENDING);
 656                 }
 657         }
 658
 659         m_progress.SetRange32(0, 1);
 660         m_progress.SetPos(0);
 661         m_progress.ShowWindow(SW_SHOW);
 662         if (m_pTaskbarList)
 663         {
 664                 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
 665                 m_pTaskbarList->SetProgressValue(m_hWnd, 0, 1);
 666         }
 667
 668         CString tempfile = CTempFiles::Instance().GetTempFilePath(true).GetWinPathString();
 669         CString signatureTempfile = CTempFiles::Instance().GetTempFilePath(true).GetWinPathString();
 670         DWORD ret = m_updateDownloader->DownloadFile(url, tempfile, true);
 671         if (!ret)
 672         {
 673                 ret = m_updateDownloader->DownloadFile(url + SIGNATURE_FILE_ENDING, signatureTempfile, true);
 674                 if (ret)
 675                         m_sErrors += url + SIGNATURE_FILE_ENDING + L": " + GetWinINetError(ret) + L"\r\n";
 676                 m_progress.SetPos(m_progress.GetPos() + 1);
 677                 if (m_pTaskbarList)
 678                 {
 679                         m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
 680                         int minValue, maxValue;
 681                         m_progress.GetRange(minValue, maxValue);
 682                         m_pTaskbarList->SetProgressValue(m_hWnd, m_progress.GetPos(), maxValue);
 683                 }
 684         }
 685         else
 686                 m_sErrors += url + L": " + GetWinINetError(ret) + L"\r\n";
 687         if (!ret)
 688         {
 689                 if (VerifyUpdateFile(tempfile, signatureTempfile, url))
 690                 {
 691                         DeleteFile(destFilename);
 692                         DeleteFile(destFilename + SIGNATURE_FILE_ENDING);
 693                         if (!MoveFile(tempfile, destFilename))
 694                         {
 695                                 m_sErrors.AppendFormat(L"Could not move \"%s\" to \"%s\".\r\n", (LPCTSTR)tempfile, (LPCTSTR)destFilename);
 696                                 return false;
 697                         }
 698                         if (!MoveFile(signatureTempfile, destFilename + SIGNATURE_FILE_ENDING))
 699                         {
 700                                 m_sErrors.AppendFormat(L"Could not move \"%s\" to \"%s\".\r\n", (LPCTSTR)signatureTempfile, (LPCTSTR)(destFilename + SIGNATURE_FILE_ENDING));
 701                                 return false;
 702                         }
 703                         return true;
 704                 }
 705                 DeleteUrlCacheEntry(url);
 706                 DeleteUrlCacheEntry(url + SIGNATURE_FILE_ENDING);
 707         }
 708         return false;
 709 }
 710
 711 UINT CCheckForUpdatesDlg::DownloadThread()
 712 {
 713         m_ctrlFiles.SetExtendedStyle(m_ctrlFiles.GetExtendedStyle() & ~LVS_EX_CHECKBOXES);
 714         m_sErrors.Empty();
 715         BOOL result = TRUE;
 716         for (int i = 0; i < (int)m_ctrlFiles.GetItemCount(); ++i)
 717         {
 718                 m_ctrlFiles.EnsureVisible(i, FALSE);
 719                 CRect rect;
 720                 m_ctrlFiles.GetItemRect(i, &rect, LVIR_BOUNDS);
 721                 CUpdateListCtrl::Entry *data = (CUpdateListCtrl::Entry *)m_ctrlFiles.GetItemData(i);
 722                 if (m_ctrlFiles.GetCheck(i) == TRUE)
 723                 {
 724                         data->m_status = CUpdateListCtrl::STATUS_DOWNLOADING;
 725                         m_ctrlFiles.InvalidateRect(rect);
 726                         if (Download(data->m_filename))
 727                                 data->m_status = CUpdateListCtrl::STATUS_SUCCESS;
 728                         else
 729                         {
 730                                 data->m_status = CUpdateListCtrl::STATUS_FAIL;
 731                                 result = FALSE;
 732                         }
 733                 }
 734                 else
 735                         data->m_status = CUpdateListCtrl::STATUS_IGNORE;
 736                 m_ctrlFiles.InvalidateRect(rect);
 737         }
 738
 739         ::PostMessage(GetSafeHwnd(), WM_USER_ENDDOWNLOAD, 0, 0);
 740
 741         return result;
 742 }
 743
 744 LRESULT CCheckForUpdatesDlg::OnEndDownload(WPARAM, LPARAM)
 745 {
 746         ASSERT(m_pDownloadThread);
 747
 748         // wait until the thread terminates
 749         DWORD dwExitCode;
 750         if (::GetExitCodeThread(m_pDownloadThread->m_hThread, &dwExitCode) && dwExitCode == STILL_ACTIVE)
 751                 ::WaitForSingleObject(m_pDownloadThread->m_hThread, INFINITE);
 752
 753         // make sure we always have the correct exit code
 754         ::GetExitCodeThread(m_pDownloadThread->m_hThread, &dwExitCode);
 755
 756         delete m_pDownloadThread;
 757         m_pDownloadThread = nullptr;
 758
 759         m_progress.ShowWindow(SW_HIDE);
 760
 761         if (dwExitCode == TRUE)
 762         {
 763                 m_ctrlUpdate.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_INSTALL)));
 764                 m_ctrlUpdate.AddEntry(CString(MAKEINTRESOURCE(IDS_CHECKUPDATE_DESTFOLDER)));
 765                 m_ctrlUpdate.Invalidate();
 766                 if (m_pTaskbarList)
 767                         m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS);
 768         }
 769         else
 770         {
 771                 m_ctrlUpdate.SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_DOWNLOAD)));
 772                 if (m_pTaskbarList)
 773                         m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
 774                 CString tmp;
 775                 tmp.LoadString(IDS_ERR_FAILEDUPDATEDOWNLOAD);
 776                 if (!m_sErrors.IsEmpty())
 777                         tmp += L"\r\n\r\nErrors:\r\n" + m_sErrors;
 778                 CMessageBox::Show(GetSafeHwnd(), tmp, L"TortoiseGit", MB_ICONERROR);
 779                 if (m_pTaskbarList)
 780                         m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS);
 781         }
 782
 783         return 0;
 784 }
 785
 786 LRESULT CCheckForUpdatesDlg::OnFillChangelog(WPARAM, LPARAM lParam)
 787 {
 788         ASSERT(lParam);
 789
 790         LPCTSTR changelog = reinterpret_cast<LPCTSTR>(lParam);
 791         m_cLogMessage.Call(SCI_SETREADONLY, FALSE);
 792         m_cLogMessage.SetText(changelog);
 793         m_cLogMessage.Call(SCI_SETREADONLY, TRUE);
 794         m_cLogMessage.Call(SCI_GOTOPOS, 0);
 795         m_cLogMessage.Call(SCI_SETWRAPSTARTINDENT, 3);
 796
 797         return 0;
 798 }
 799
 800 CString CCheckForUpdatesDlg::GetDownloadsDirectory()
 801 {
 802         CString folder;
 803
 804         PWSTR wcharPtr = nullptr;
 805         if (SUCCEEDED(SHGetKnownFolderPath(FOLDERID_Downloads, KF_FLAG_CREATE, nullptr, &wcharPtr)))
 806         {
 807                 folder = wcharPtr;
 808                 CoTaskMemFree(wcharPtr);
 809                 return folder.TrimRight(L'\\') + L'\\';
 810         }
 811
 812         return folder;
 813 }
 814
 815 LRESULT CCheckForUpdatesDlg::OnDisplayStatus(WPARAM, LPARAM lParam)
 816 {
 817         const CUpdateDownloader::DOWNLOADSTATUS *const pDownloadStatus = reinterpret_cast<CUpdateDownloader::DOWNLOADSTATUS *>(lParam);
 818         if (pDownloadStatus)
 819         {
 820                 ASSERT(::AfxIsValidAddress(pDownloadStatus, sizeof(CUpdateDownloader::DOWNLOADSTATUS)));
 821
 822                 m_progress.SetRange32(0, pDownloadStatus->ulProgressMax);
 823                 m_progress.SetPos(pDownloadStatus->ulProgress);
 824                 if (m_pTaskbarList)
 825                 {
 826                         m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
 827                         m_pTaskbarList->SetProgressValue(m_hWnd, pDownloadStatus->ulProgress, pDownloadStatus->ulProgressMax);
 828                 }
 829         }
 830
 831         return 0;
 832 }
 833
 834 LRESULT CCheckForUpdatesDlg::OnTaskbarBtnCreated(WPARAM /*wParam*/, LPARAM /*lParam*/)
 835 {
 836         m_pTaskbarList.Release();
 837         m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
 838         return 0;
 839 }
 840
 841 CString CCheckForUpdatesDlg::GetWinINetError(DWORD err)
 842 {
 843         CString readableError = CFormatMessageWrapper(err);
 844         if (readableError.IsEmpty())
 845         {
 846                 for (const CString& module : { L"wininet.dll", L"urlmon.dll" })
 847                 {
 848                         LPTSTR buffer;
 849                         FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_HMODULE, GetModuleHandle(module), err, 0, (LPTSTR)&buffer, 0, nullptr);
 850                         readableError = buffer;
 851                         LocalFree(buffer);
 852                         if (!readableError.IsEmpty())
 853                                 break;
 854                 }
 855         }
 856         return readableError.Trim();
 857 }
 858
 859 void CCheckForUpdatesDlg::OnBnClickedDonotaskagain()
 860 {
 861         if (CMessageBox::Show(GetSafeHwnd(), IDS_DISABLEUPDATECHECKS, IDS_APPNAME, 2, IDI_QUESTION, IDS_DISABLEUPDATECHECKSBUTTON, IDS_ABORTBUTTON) == 1)
 862         {
 863                 CRegDWORD(L"Software\\TortoiseGit\\VersionCheck") = FALSE;
 864                 OnOK();
 865         }
 866 }
 867
 868 void CCheckForUpdatesDlg::OnSysColorChange()
 869 {
 870         __super::OnSysColorChange();
 871         m_cLogMessage.SetColors(true);
 872         m_cLogMessage.SetFont(CAppUtils::GetLogFontName(), CAppUtils::GetLogFontSize());
 873 }