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