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