reactos/base/applications/rapps/loaddlg.cpp

   1 /* PROJECT:     ReactOS Applications Manager
   2  * LICENSE:     GPL - See COPYING in the top level directory
   3  * FILE:        base/applications/rapps/loaddlg.cpp
   4  * PURPOSE:     Displaying a download dialog
   5  * COPYRIGHT:   Copyright 2001 John R. Sheets             (for CodeWeavers)
   6  *              Copyright 2004 Mike McCormack             (for CodeWeavers)
   7  *              Copyright 2005 Ge van Geldorp             (gvg@reactos.org)
   8  *              Copyright 2009 Dmitry Chapyshev           (dmitry@reactos.org)
   9  *              Copyright 2015 Ismael Ferreras Morezuelas (swyterzone+ros@gmail.com)
  10  *              Copyright 2017 Alexander Shaposhnikov     (chaez.san@gmail.com)
  11  */
  12
  13 /*
  14  * Based on Wine dlls/shdocvw/shdocvw_main.c
  15  *
  16  * This library is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU Lesser General Public
  18  * License as published by the Free Software Foundation; either
  19  * version 2.1 of the License, or (at your option) any later version.
  20  *
  21  * This library is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24  * Lesser General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU Lesser General Public
  27  * License along with this library; if not, write to the Free Software
  28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  29  */
  30
  31 #include "rapps.h"
  32
  33 #include <shlobj_undoc.h>
  34 #include <shlguid_undoc.h>
  35
  36 #include <atlbase.h>
  37 #include <atlcom.h>
  38 #include <wininet.h>
  39 #include <shellutils.h>
  40 #include <windowsx.h>
  41
  42 static PAPPLICATION_INFO AppInfo;
  43
  44 class CDownloadDialog :
  45     public CComObjectRootEx<CComMultiThreadModelNoCS>,
  46     public IBindStatusCallback
  47 {
  48     HWND m_hDialog;
  49     PBOOL m_pbCancelled;
  50     BOOL m_UrlHasBeenCopied;
  51
  52 public:
  53     ~CDownloadDialog()
  54     {
  55         DestroyWindow(m_hDialog);
  56     }
  57
  58     HRESULT Initialize(HWND Dlg, BOOL *pbCancelled)
  59     {
  60         m_hDialog = Dlg;
  61         m_pbCancelled = pbCancelled;
  62         m_UrlHasBeenCopied = FALSE;
  63         return S_OK;
  64     }
  65
  66     virtual HRESULT STDMETHODCALLTYPE OnStartBinding(
  67         DWORD dwReserved,
  68         IBinding *pib)
  69     {
  70         return S_OK;
  71     }
  72
  73     virtual HRESULT STDMETHODCALLTYPE GetPriority(
  74         LONG *pnPriority)
  75     {
  76         return S_OK;
  77     }
  78
  79     virtual HRESULT STDMETHODCALLTYPE OnLowResource(
  80         DWORD reserved)
  81     {
  82         return S_OK;
  83     }
  84
  85     virtual HRESULT STDMETHODCALLTYPE OnProgress(
  86         ULONG ulProgress,
  87         ULONG ulProgressMax,
  88         ULONG ulStatusCode,
  89         LPCWSTR szStatusText)
  90     {
  91         HWND Item;
  92         LONG r;
  93
  94         Item = GetDlgItem(m_hDialog, IDC_DOWNLOAD_PROGRESS);
  95         if (Item && ulProgressMax)
  96         {
  97             WCHAR szProgress[100];
  98             WCHAR szProgressMax[100];
  99             UINT uiPercentage = ((ULONGLONG) ulProgress * 100) / ulProgressMax;
 100
 101             /* send the current progress to the progress bar */
 102             SendMessageW(Item, PBM_SETPOS, uiPercentage, 0);
 103
 104             /* format the bits and bytes into pretty and accessible units... */
 105             StrFormatByteSizeW(ulProgress, szProgress, _countof(szProgress));
 106             StrFormatByteSizeW(ulProgressMax, szProgressMax, _countof(szProgressMax));
 107
 108             /* ...and post all of it to our subclassed progress bar text subroutine */
 109             ATL::CStringW m_ProgressText;
 110             m_ProgressText.Format(L"%u%% \x2014 %ls / %ls",
 111                                   uiPercentage,
 112                                   szProgress,
 113                                   szProgressMax);
 114             SendMessageW(Item, WM_SETTEXT, 0, (LPARAM) m_ProgressText.GetBuffer());
 115             m_ProgressText.ReleaseBuffer();
 116         }
 117
 118         Item = GetDlgItem(m_hDialog, IDC_DOWNLOAD_STATUS);
 119         if (Item && szStatusText && wcslen(szStatusText) > 0 && m_UrlHasBeenCopied == FALSE)
 120         {
 121             DWORD len = wcslen(szStatusText) + 1;
 122             ATL::CStringW buf;
 123
 124             /* beautify our url for display purposes */
 125             if (!InternetCanonicalizeUrlW(szStatusText, buf.GetBuffer(len), &len, ICU_DECODE | ICU_NO_ENCODE))
 126             {
 127                 /* just use the original */
 128                 buf.ReleaseBuffer();
 129                 buf = szStatusText;
 130             }
 131             else
 132             {
 133                 buf.ReleaseBuffer();
 134             }
 135
 136             /* paste it into our dialog and don't do it again in this instance */
 137             SendMessageW(Item, WM_SETTEXT, 0, (LPARAM) buf.GetBuffer());
 138             buf.ReleaseBuffer();
 139             m_UrlHasBeenCopied = TRUE;
 140         }
 141
 142         SetLastError(0);
 143         r = GetWindowLongPtrW(m_hDialog, GWLP_USERDATA);
 144         if (0 != r || 0 != GetLastError())
 145         {
 146             *m_pbCancelled = TRUE;
 147             return E_ABORT;
 148         }
 149
 150         return S_OK;
 151     }
 152
 153     virtual HRESULT STDMETHODCALLTYPE OnStopBinding(
 154         HRESULT hresult,
 155         LPCWSTR szError)
 156     {
 157         return S_OK;
 158     }
 159
 160     virtual HRESULT STDMETHODCALLTYPE GetBindInfo(
 161         DWORD *grfBINDF,
 162         BINDINFO *pbindinfo)
 163     {
 164         return S_OK;
 165     }
 166
 167     virtual HRESULT STDMETHODCALLTYPE OnDataAvailable(
 168         DWORD grfBSCF,
 169         DWORD dwSize,
 170         FORMATETC *pformatetc,
 171         STGMEDIUM *pstgmed)
 172     {
 173         return S_OK;
 174     }
 175
 176     virtual HRESULT STDMETHODCALLTYPE OnObjectAvailable(
 177         REFIID riid,
 178         IUnknown *punk)
 179     {
 180         return S_OK;
 181     }
 182
 183     BEGIN_COM_MAP(CDownloadDialog)
 184         COM_INTERFACE_ENTRY_IID(IID_IBindStatusCallback, IBindStatusCallback)
 185     END_COM_MAP()
 186 };
 187
 188 extern "C"
 189 HRESULT WINAPI CDownloadDialog_Constructor(HWND Dlg, BOOL *pbCancelled, REFIID riid, LPVOID *ppv)
 190 {
 191     return ShellObjectCreatorInit<CDownloadDialog>(Dlg, pbCancelled, riid, ppv);
 192 }
 193
 194 #ifdef USE_CERT_PINNING
 195 static BOOL CertIsValid(HINTERNET hInternet, LPWSTR lpszHostName)
 196 {
 197     HINTERNET hConnect;
 198     HINTERNET hRequest;
 199     DWORD certInfoLength;
 200     BOOL Ret = FALSE;
 201     INTERNET_CERTIFICATE_INFOW certInfo;
 202
 203     hConnect = InternetConnectW(hInternet, lpszHostName, INTERNET_DEFAULT_HTTPS_PORT, NULL, NULL, INTERNET_SERVICE_HTTP, INTERNET_FLAG_SECURE, 0);
 204     if (hConnect)
 205     {
 206         hRequest = HttpOpenRequestW(hConnect, L"HEAD", NULL, NULL, NULL, NULL, INTERNET_FLAG_SECURE, 0);
 207         if (hRequest != NULL)
 208         {
 209             Ret = HttpSendRequestW(hRequest, L"", 0, NULL, 0);
 210             if (Ret)
 211             {
 212                 certInfoLength = sizeof(certInfo);
 213                 Ret = InternetQueryOptionW(hRequest,
 214                                            INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT,
 215                                            &certInfo,
 216                                            &certInfoLength);
 217                 if (Ret)
 218                 {
 219                     if (certInfo.lpszEncryptionAlgName)
 220                         LocalFree(certInfo.lpszEncryptionAlgName);
 221                     if (certInfo.lpszIssuerInfo)
 222                     {
 223                         if (strcmp((LPSTR) certInfo.lpszIssuerInfo, CERT_ISSUER_INFO) != 0)
 224                             Ret = FALSE;
 225                         LocalFree(certInfo.lpszIssuerInfo);
 226                     }
 227                     if (certInfo.lpszProtocolName)
 228                         LocalFree(certInfo.lpszProtocolName);
 229                     if (certInfo.lpszSignatureAlgName)
 230                         LocalFree(certInfo.lpszSignatureAlgName);
 231                     if (certInfo.lpszSubjectInfo)
 232                     {
 233                         if (strcmp((LPSTR) certInfo.lpszSubjectInfo, CERT_SUBJECT_INFO) != 0)
 234                             Ret = FALSE;
 235                         LocalFree(certInfo.lpszSubjectInfo);
 236                     }
 237                 }
 238             }
 239             InternetCloseHandle(hRequest);
 240         }
 241         InternetCloseHandle(hConnect);
 242     }
 243     return Ret;
 244 }
 245 #endif
 246
 247 inline VOID
 248 MessageBox_LoadString(HWND hMainWnd, INT StringID)
 249 {
 250     ATL::CString szMsgText;
 251     if (szMsgText.LoadStringW(hInst, StringID))
 252         MessageBoxW(hMainWnd, szMsgText.GetString(), NULL, MB_OK | MB_ICONERROR);
 253 }
 254
 255 static
 256 DWORD WINAPI
 257 ThreadFunc(LPVOID Context)
 258 {
 259     CComPtr<IBindStatusCallback> dl;
 260     ATL::CStringW Path;
 261     PWSTR p, q;
 262     HWND Dlg = (HWND) Context;
 263     ULONG dwContentLen, dwBytesWritten, dwBytesRead, dwStatus;
 264     ULONG dwCurrentBytesRead = 0;
 265     ULONG dwStatusLen = sizeof(dwStatus);
 266     BOOL bCancelled = FALSE;
 267     BOOL bTempfile = FALSE;
 268     BOOL bCab = FALSE;
 269     HINTERNET hOpen = NULL;
 270     HINTERNET hFile = NULL;
 271     HANDLE hOut = INVALID_HANDLE_VALUE;
 272     unsigned char lpBuffer[4096];
 273     LPCWSTR lpszAgent = L"RApps/1.0";
 274     URL_COMPONENTS urlComponents;
 275     size_t urlLength, filenameLength;
 276
 277     /* build the path for the download */
 278     p = wcsrchr(AppInfo->szUrlDownload, L'/');
 279     q = wcsrchr(AppInfo->szUrlDownload, L'?');
 280
 281     /* do we have a final slash separator? */
 282     if (!p)
 283         goto end;
 284
 285     /* prepare the tentative length of the filename, maybe we've to remove part of it later on */
 286     filenameLength = wcslen(p) * sizeof(WCHAR);
 287
 288     /* do we have query arguments in the target URL after the filename? account for them
 289       (e.g. https://example.org/myfile.exe?no_adware_plz) */
 290     if (q && q > p && (q - p) > 0)
 291         filenameLength -= wcslen(q - 1) * sizeof(WCHAR);
 292
 293     /* is this URL an update package for RAPPS? if so store it in a different place */
 294     if (AppInfo->szUrlDownload == APPLICATION_DATABASE_URL)
 295     {
 296         bCab = TRUE;
 297         if (!GetStorageDirectory(Path))
 298             goto end;
 299     }
 300     else
 301     {
 302         Path = SettingsInfo.szDownloadDir;
 303     }
 304
 305     /* is the path valid? can we access it? */
 306     if (GetFileAttributesW(Path.GetString()) == INVALID_FILE_ATTRIBUTES)
 307     {
 308         if (!CreateDirectoryW(Path.GetString(), NULL))
 309             goto end;
 310     }
 311
 312     /* append a \ to the provided file system path, and the filename portion from the URL after that */
 313     Path.Format(L"\\%ls", (p + 1));
 314
 315     if (!bCab && AppInfo->szSHA1[0] && GetFileAttributesW(Path.GetString()) != INVALID_FILE_ATTRIBUTES)
 316     {
 317         /* only open it in case of total correctness */
 318         if (VerifyInteg(AppInfo->szSHA1, Path))
 319             goto run;
 320     }
 321
 322     /* download it */
 323     bTempfile = TRUE;
 324     CDownloadDialog_Constructor(Dlg, &bCancelled, IID_PPV_ARG(IBindStatusCallback, &dl));
 325
 326     if (dl == NULL)
 327         goto end;
 328
 329     /* FIXME: this should just be using the system-wide proxy settings */
 330     switch (SettingsInfo.Proxy)
 331     {
 332     case 0: /* preconfig */
 333         hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
 334         break;
 335     case 1: /* direct (no proxy) */
 336         hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
 337         break;
 338     case 2: /* use proxy */
 339         hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_PROXY, SettingsInfo.szProxyServer, SettingsInfo.szNoProxyFor, 0);
 340         break;
 341     default: /* preconfig */
 342         hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
 343         break;
 344     }
 345
 346     if (!hOpen)
 347         goto end;
 348
 349     hFile = InternetOpenUrlW(hOpen, AppInfo->szUrlDownload, NULL, 0, INTERNET_FLAG_PRAGMA_NOCACHE | INTERNET_FLAG_KEEP_CONNECTION, 0);
 350     if (!hFile)
 351     {
 352         MessageBox_LoadString(hMainWnd, IDS_UNABLE_TO_DOWNLOAD2);
 353         goto end;
 354     }
 355
 356     if (!HttpQueryInfoW(hFile, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &dwStatus, &dwStatusLen, NULL))
 357         goto end;
 358
 359     if (dwStatus != HTTP_STATUS_OK)
 360     {
 361         MessageBox_LoadString(hMainWnd, IDS_UNABLE_TO_DOWNLOAD);
 362         goto end;
 363     }
 364
 365     dwStatusLen = sizeof(dwStatus);
 366
 367     memset(&urlComponents, 0, sizeof(urlComponents));
 368     urlComponents.dwStructSize = sizeof(urlComponents);
 369
 370     urlLength = AppInfo->szUrlDownload.GetLength();
 371     urlComponents.dwSchemeLength = urlLength + 1;
 372     urlComponents.lpszScheme = (LPWSTR) malloc(urlComponents.dwSchemeLength * sizeof(WCHAR));
 373     urlComponents.dwHostNameLength = urlLength + 1;
 374     urlComponents.lpszHostName = (LPWSTR) malloc(urlComponents.dwHostNameLength * sizeof(WCHAR));
 375
 376     if (!InternetCrackUrlW(AppInfo->szUrlDownload, urlLength + 1, ICU_DECODE | ICU_ESCAPE, &urlComponents))
 377         goto end;
 378
 379     if (urlComponents.nScheme == INTERNET_SCHEME_HTTP || urlComponents.nScheme == INTERNET_SCHEME_HTTPS)
 380         HttpQueryInfo(hFile, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, &dwContentLen, &dwStatus, 0);
 381
 382     if (urlComponents.nScheme == INTERNET_SCHEME_FTP)
 383         dwContentLen = FtpGetFileSize(hFile, &dwStatus);
 384
 385 #ifdef USE_CERT_PINNING
 386     /* are we using HTTPS to download the RAPPS update package? check if the certificate is original */
 387     if ((urlComponents.nScheme == INTERNET_SCHEME_HTTPS) &&
 388         (wcscmp(AppInfo->szUrlDownload, APPLICATION_DATABASE_URL) == 0) &&
 389         (!CertIsValid(hOpen, urlComponents.lpszHostName)))
 390     {
 391         MessageBox_LoadString(hMainWnd, IDS_CERT_DOES_NOT_MATCH);
 392         goto end;
 393     }
 394 #endif
 395
 396     free(urlComponents.lpszScheme);
 397     free(urlComponents.lpszHostName);
 398
 399     hOut = CreateFileW(Path.GetString(), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, NULL);
 400
 401     if (hOut == INVALID_HANDLE_VALUE)
 402         goto end;
 403
 404     do
 405     {
 406         if (!InternetReadFile(hFile, lpBuffer, _countof(lpBuffer), &dwBytesRead))
 407         {
 408             MessageBox_LoadString(hMainWnd, IDS_INTERRUPTED_DOWNLOAD);
 409             goto end;
 410         }
 411
 412         if (!WriteFile(hOut, &lpBuffer[0], dwBytesRead, &dwBytesWritten, NULL))
 413         {
 414             MessageBox_LoadString(hMainWnd, IDS_UNABLE_TO_WRITE);
 415             goto end;
 416         }
 417
 418         dwCurrentBytesRead += dwBytesRead;
 419         dl->OnProgress(dwCurrentBytesRead, dwContentLen, 0, AppInfo->szUrlDownload);
 420     } while (dwBytesRead && !bCancelled);
 421
 422     CloseHandle(hOut);
 423     hOut = INVALID_HANDLE_VALUE;
 424
 425     if (bCancelled)
 426         goto end;
 427
 428     /* if this thing isn't a RAPPS update and it has a SHA-1 checksum
 429        verify its integrity by using the native advapi32.A_SHA1 functions */
 430     if (!bCab && AppInfo->szSHA1[0] != 0)
 431     {
 432         ATL::CStringW szMsgText;
 433
 434         /* change a few strings in the download dialog to reflect the verification process */
 435         if (!szMsgText.LoadStringW(hInst, IDS_INTEG_CHECK_TITLE))
 436             goto end;
 437
 438         SetWindowText(Dlg, szMsgText.GetString());
 439         SendMessageW(GetDlgItem(Dlg, IDC_DOWNLOAD_STATUS), WM_SETTEXT, 0, (LPARAM) Path.GetBuffer());
 440         Path.ReleaseBuffer();
 441
 442         /* this may take a while, depending on the file size */
 443         if (!VerifyInteg(AppInfo->szSHA1, Path.GetString()))
 444         {
 445             if (!szMsgText.LoadStringW(hInst, IDS_INTEG_CHECK_FAIL))
 446                 goto end;
 447
 448             MessageBoxW(Dlg, szMsgText.GetString(), NULL, MB_OK | MB_ICONERROR);
 449             goto end;
 450         }
 451     }
 452
 453     ShowWindow(Dlg, SW_HIDE);
 454
 455 run:
 456     /* run it */
 457     if (!bCab)
 458         ShellExecuteW(NULL, L"open", Path.GetString(), NULL, NULL, SW_SHOWNORMAL);
 459
 460 end:
 461     if (hOut != INVALID_HANDLE_VALUE)
 462         CloseHandle(hOut);
 463
 464     InternetCloseHandle(hFile);
 465     InternetCloseHandle(hOpen);
 466
 467     if (bTempfile)
 468     {
 469         if (bCancelled || (SettingsInfo.bDelInstaller && !bCab))
 470             DeleteFileW(Path.GetString());
 471     }
 472
 473     EndDialog(Dlg, 0);
 474
 475     return 0;
 476 }
 477
 478
 479 LRESULT CALLBACK
 480 DownloadProgressProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
 481 {
 482     static ATL::CStringW szProgressText;
 483
 484     switch (uMsg)
 485     {
 486     case WM_SETTEXT:
 487     {
 488         if (lParam)
 489         {
 490             szProgressText = (PCWSTR) lParam;
 491         }
 492         return TRUE;
 493     }
 494
 495     case WM_ERASEBKGND:
 496     case WM_PAINT:
 497     {
 498         PAINTSTRUCT  ps;
 499         HDC hDC = BeginPaint(hWnd, &ps), hdcMem;
 500         HBITMAP hbmMem;
 501         HANDLE hOld;
 502         RECT myRect;
 503         UINT win_width, win_height;
 504
 505         GetClientRect(hWnd, &myRect);
 506
 507         /* grab the progress bar rect size */
 508         win_width = myRect.right - myRect.left;
 509         win_height = myRect.bottom - myRect.top;
 510
 511         /* create an off-screen DC for double-buffering */
 512         hdcMem = CreateCompatibleDC(hDC);
 513         hbmMem = CreateCompatibleBitmap(hDC, win_width, win_height);
 514
 515         hOld = SelectObject(hdcMem, hbmMem);
 516
 517         /* call the original draw code and redirect it to our memory buffer */
 518         DefSubclassProc(hWnd, uMsg, (WPARAM) hdcMem, lParam);
 519
 520         /* draw our nifty progress text over it */
 521         SelectFont(hdcMem, GetStockFont(DEFAULT_GUI_FONT));
 522         DrawShadowText(hdcMem, szProgressText.GetString(), szProgressText.GetLength(),
 523                        &myRect,
 524                        DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE,
 525                        GetSysColor(COLOR_CAPTIONTEXT),
 526                        GetSysColor(COLOR_3DSHADOW),
 527                        1, 1);
 528
 529         /* transfer the off-screen DC to the screen */
 530         BitBlt(hDC, 0, 0, win_width, win_height, hdcMem, 0, 0, SRCCOPY);
 531
 532         /* free the off-screen DC */
 533         SelectObject(hdcMem, hOld);
 534         DeleteObject(hbmMem);
 535         DeleteDC(hdcMem);
 536
 537         EndPaint(hWnd, &ps);
 538         return 0;
 539     }
 540
 541     /* Raymond Chen says that we should safely unsubclass all the things!
 542       (http://blogs.msdn.com/b/oldnewthing/archive/2003/11/11/55653.aspx) */
 543     case WM_NCDESTROY:
 544     {
 545         szProgressText.Empty();
 546         RemoveWindowSubclass(hWnd, DownloadProgressProc, uIdSubclass);
 547     }
 548     /* Fall-through */
 549     default:
 550         return DefSubclassProc(hWnd, uMsg, wParam, lParam);
 551     }
 552 }
 553
 554 static
 555 INT_PTR CALLBACK
 556 DownloadDlgProc(HWND Dlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
 557 {
 558     HANDLE Thread;
 559     DWORD ThreadId;
 560     HWND Item;
 561
 562     switch (uMsg)
 563     {
 564     case WM_INITDIALOG:
 565     {
 566         HICON hIconSm = NULL, hIconBg = NULL;
 567
 568         hIconBg = (HICON) GetClassLongPtr(hMainWnd, GCLP_HICON);
 569         hIconSm = (HICON) GetClassLongPtr(hMainWnd, GCLP_HICONSM);
 570
 571         if (hIconBg && hIconSm)
 572         {
 573             SendMessageW(Dlg, WM_SETICON, ICON_BIG, (LPARAM) hIconBg);
 574             SendMessageW(Dlg, WM_SETICON, ICON_SMALL, (LPARAM) hIconSm);
 575         }
 576
 577         SetWindowLongPtrW(Dlg, GWLP_USERDATA, 0);
 578         Item = GetDlgItem(Dlg, IDC_DOWNLOAD_PROGRESS);
 579         if (Item)
 580         {
 581             /* initialize the default values for our nifty progress bar
 582                and subclass it so that it learns to print a status text */
 583             SendMessageW(Item, PBM_SETRANGE, 0, MAKELPARAM(0, 100));
 584             SendMessageW(Item, PBM_SETPOS, 0, 0);
 585
 586             SetWindowSubclass(Item, DownloadProgressProc, 0, 0);
 587         }
 588
 589         /* add a neat placeholder until the download URL is retrieved */
 590         Item = GetDlgItem(Dlg, IDC_DOWNLOAD_STATUS);
 591         SendMessageW(Item, WM_SETTEXT, 0, (LPARAM) L"\x2022 \x2022 \x2022");
 592
 593         Thread = CreateThread(NULL, 0, ThreadFunc, Dlg, 0, &ThreadId);
 594         if (!Thread)
 595             return FALSE;
 596         CloseHandle(Thread);
 597         return TRUE;
 598     }
 599     case WM_COMMAND:
 600         if (wParam == IDCANCEL)
 601         {
 602             SetWindowLongPtrW(Dlg, GWLP_USERDATA, 1);
 603             PostMessageW(Dlg, WM_CLOSE, 0, 0);
 604         }
 605         return FALSE;
 606
 607     case WM_CLOSE:
 608         EndDialog(Dlg, 0);
 609         return TRUE;
 610
 611     default:
 612         return FALSE;
 613     }
 614 }
 615
 616 BOOL
 617 DownloadApplication(INT Index)
 618 {
 619     if (!IS_AVAILABLE_ENUM(SelectedEnumType))
 620         return FALSE;
 621
 622     AppInfo = (PAPPLICATION_INFO) ListViewGetlParam(Index);
 623     if (!AppInfo)
 624         return FALSE;
 625
 626     WriteLogMessage(EVENTLOG_SUCCESS, MSG_SUCCESS_INSTALL, AppInfo->szName.GetString());
 627
 628     DialogBoxW(hInst,
 629                MAKEINTRESOURCEW(IDD_DOWNLOAD_DIALOG),
 630                hMainWnd,
 631                DownloadDlgProc);
 632
 633     return TRUE;
 634 }
 635
 636 VOID
 637 DownloadApplicationsDB(LPCWSTR lpUrl)
 638 {
 639     APPLICATION_INFO IntInfo;
 640     IntInfo.szUrlDownload = lpUrl;
 641
 642     AppInfo = &IntInfo;
 643
 644     DialogBoxW(hInst,
 645                MAKEINTRESOURCEW(IDD_DOWNLOAD_DIALOG),
 646                hMainWnd,
 647                DownloadDlgProc);
 648 }