| /* |
| * Copyright (c) 2008, 2009, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| #if _MSC_VER > 1000 |
| #pragma once |
| #endif // _MSC_VER > 1000 |
| |
| #define STRICT |
| #ifndef _WIN32_WINNT |
| /* REMIND : 0x500 means Windows 2000 .. seems like we can update |
| * for Windows XP when we move the SDK and build platform |
| */ |
| #define _WIN32_WINNT 0x0500 |
| #endif |
| #define _ATL_APARTMENT_THREADED |
| |
| |
| #include <atlbase.h> |
| //You may derive a class from CComModule and use it if you want to override |
| //something, but do not change the name of _Module |
| extern CComModule _Module; |
| #include <atlcom.h> |
| #include <atlwin.h> |
| |
| #include <atlhost.h> |
| #include <commdlg.h> |
| #include <commctrl.h> |
| #include <windowsx.h> |
| #include <urlmon.h> |
| #include <wininet.h> |
| #include <shellapi.h> |
| #include <time.h> |
| #include <math.h> |
| #include <stdio.h> |
| |
| #include <jni.h> |
| |
| #include "resource.h" // main symbols |
| #include "DownloadHelper.h" |
| |
| DownloadHelper::DownloadHelper() { |
| |
| m_showProgressDialog = TRUE; |
| m_pszURL = NULL; |
| m_pszFileName = NULL; |
| m_pszNameText = NULL; |
| } |
| |
| DownloadHelper::~DownloadHelper() { |
| |
| } |
| |
| HRESULT DownloadHelper::doDownload() { |
| return DownloadFile(m_pszURL, m_pszFileName, FALSE, m_showProgressDialog); |
| } |
| |
| HRESULT DownloadHelper::DownloadFile(const TCHAR* szURL, |
| const TCHAR* szLocalFile, BOOL bResumable, BOOL bUIFeedback) { |
| HINTERNET hOpen = NULL; |
| HINTERNET hConnect = NULL; |
| HINTERNET hRequest = NULL; |
| HANDLE hFile = INVALID_HANDLE_VALUE; |
| DWORD dwDownloadError = 0; |
| DWORD nContentLength = 0; |
| |
| /* Some of error messages use drive letter. |
| Result is something like "(C:)". |
| NB: Parentheses are added here because in some other places |
| we same message but can not provide disk label info */ |
| TCHAR drivePath[5]; |
| /* assuming szLocalFile is not NULL */ |
| _sntprintf(drivePath, 5, "(%c:)", szLocalFile[0]); |
| WCHAR* wName = CT2CW(drivePath); |
| |
| __try { |
| m_csDownload.Lock(); |
| |
| time(&m_startTime); |
| |
| } |
| __finally { |
| m_csDownload.Unlock(); |
| } |
| |
| __try { |
| // block potential security hole |
| if (strstr(szURL, TEXT("file://")) != NULL) { |
| dwDownloadError = 1; |
| __leave; |
| } |
| |
| HWND hProgressInfo = NULL; |
| TCHAR szStatus[BUFFER_SIZE]; |
| |
| if (bUIFeedback) { |
| // init download dialg text |
| m_dlg->initDialogText(m_pszURL, m_pszNameText); |
| } |
| |
| // Open Internet Call |
| hOpen = ::InternetOpen("deployHelper", INTERNET_OPEN_TYPE_PRECONFIG, |
| NULL, NULL, NULL); |
| |
| if (hOpen == NULL) { |
| dwDownloadError = 1; |
| __leave; |
| } |
| |
| // URL components |
| URL_COMPONENTS url_components; |
| ::ZeroMemory(&url_components, sizeof(URL_COMPONENTS)); |
| |
| TCHAR szHostName[BUFFER_SIZE], szUrlPath[BUFFER_SIZE], |
| szExtraInfo[BUFFER_SIZE]; |
| url_components.dwStructSize = sizeof(URL_COMPONENTS); |
| url_components.lpszHostName = szHostName; |
| url_components.dwHostNameLength = BUFFER_SIZE; |
| url_components.nPort = NULL; |
| url_components.lpszUrlPath = szUrlPath; |
| url_components.dwUrlPathLength = BUFFER_SIZE; |
| url_components.lpszExtraInfo = szExtraInfo; |
| url_components.dwExtraInfoLength = BUFFER_SIZE; |
| |
| // Crack the URL into pieces |
| ::InternetCrackUrl(szURL, lstrlen(szURL), NULL, &url_components); |
| |
| // Open Internet Connection |
| hConnect = ::InternetConnect(hOpen, url_components.lpszHostName, |
| url_components.nPort, "", "", INTERNET_SERVICE_HTTP, NULL, |
| NULL); |
| |
| if (hConnect == NULL) { |
| dwDownloadError = 1; |
| __leave; |
| } |
| |
| // Determine the relative URL path by combining |
| // Path and ExtraInfo |
| char szURL[4096]; |
| |
| if (url_components.dwUrlPathLength != 0) |
| lstrcpy(szURL, url_components.lpszUrlPath); |
| else |
| lstrcpy(szURL, "/"); |
| |
| if (url_components.dwExtraInfoLength != 0) |
| lstrcat(szURL, url_components.lpszExtraInfo); |
| |
| BOOL bRetryHttpRequest = FALSE; |
| int numberOfRetry = 0; |
| long secondsToWait = 60; |
| |
| do { |
| bRetryHttpRequest = FALSE; |
| |
| // Make a HTTP GET request |
| hRequest = ::HttpOpenRequest(hConnect, "GET", szURL, "HTTP/1.1", |
| "", NULL, |
| INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_DONT_CACHE, |
| 0); |
| |
| if (hRequest == NULL) { |
| dwDownloadError = 1; |
| __leave; |
| } |
| |
| // Create or open existing destination file |
| hFile = ::CreateFile(szLocalFile, GENERIC_WRITE, 0, NULL, |
| OPEN_ALWAYS, FILE_ATTRIBUTE_ARCHIVE, NULL); |
| |
| if (hFile == INVALID_HANDLE_VALUE) { |
| if (bUIFeedback) { |
| if (IDRETRY == m_dlg->SafeMessageBox( |
| IDS_DISK_WRITE_ERROR, |
| IDS_DISK_WRITE_ERROR_CAPTION, |
| IDS_ERROR_CAPTION, |
| DIALOG_ERROR_RETRYCANCEL, |
| wName)) { |
| bRetryHttpRequest = TRUE; |
| continue; |
| } |
| } |
| dwDownloadError = 1; |
| __leave; |
| } |
| DWORD fileSize = GetFileSize(hFile, NULL); |
| |
| // Check if resumable download is enabled |
| if (bResumable == FALSE) { |
| // Start from scratch |
| fileSize = 0; |
| } |
| |
| FILETIME tWrite; |
| BOOL rangereq = FALSE; |
| if ((fileSize != 0) && (fileSize != 0xFFFFFFFF) && |
| GetFileTime(hFile, NULL, NULL, &tWrite)) { |
| char szHead[100]; |
| SYSTEMTIME tLocal; |
| char buf[INTERNET_RFC1123_BUFSIZE]; |
| |
| FileTimeToSystemTime(&tWrite, &tLocal); |
| InternetTimeFromSystemTime(&tLocal, INTERNET_RFC1123_FORMAT, |
| buf, INTERNET_RFC1123_BUFSIZE); |
| sprintf(szHead, "Range: bytes=%d-\r\nIf-Range: %s\r\n", |
| fileSize, buf); |
| HttpAddRequestHeaders(hRequest, szHead, lstrlen(szHead), |
| HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE); |
| rangereq = TRUE; |
| } |
| |
| // This is a loop to handle various potential error when the |
| // connection is made |
| BOOL bCont = TRUE; |
| |
| while ((FALSE == ::HttpSendRequest(hRequest, NULL, NULL, NULL, NULL)) |
| && bCont ) { |
| // We might have an invalid CA. |
| DWORD dwErrorCode = GetLastError(); |
| |
| switch(dwErrorCode) { |
| case E_JDHELPER_TIMEOUT: |
| case E_JDHELPER_NAME_NOT_RESOLVED: |
| case E_JDHELPER_CANNOT_CONNECT: { |
| bCont = FALSE; |
| // Display the information dialog |
| if (bUIFeedback) { |
| // decrement download counter to prevent progress |
| // dialog from popping up while the message box is |
| // up |
| m_dlg->bundleInstallComplete(); |
| if (dwErrorCode == E_JDHELPER_TIMEOUT) { |
| bRetryHttpRequest = |
| (IDRETRY == m_dlg->SafeMessageBox( |
| IDS_HTTP_STATUS_REQUEST_TIMEOUT, |
| IDS_HTTP_INSTRUCTION_REQUEST_TIMEOUT, |
| IDS_ERROR_CAPTION, |
| DIALOG_ERROR_RETRYCANCEL)); |
| } else { |
| bRetryHttpRequest = |
| (IDRETRY == m_dlg->SafeMessageBox( |
| IDS_HTTP_STATUS_SERVER_NOT_REACHABLE, |
| IDS_HTTP_INSTRUCTION_SERVER_NOT_REACHABLE, |
| IDS_ERROR_CAPTION, |
| DIALOG_ERROR_RETRYCANCEL)); |
| } |
| // re-increment counter because it will be decremented |
| // again upon return |
| m_dlg->bundleInstallStart(); |
| bCont = bRetryHttpRequest; |
| } |
| break; |
| } |
| case ERROR_INTERNET_INVALID_CA: |
| case ERROR_INTERNET_SEC_CERT_CN_INVALID: |
| case ERROR_INTERNET_SEC_CERT_DATE_INVALID: |
| case ERROR_INTERNET_HTTP_TO_HTTPS_ON_REDIR: |
| case ERROR_INTERNET_INCORRECT_PASSWORD: |
| case ERROR_INTERNET_CLIENT_AUTH_CERT_NEEDED: |
| default: { |
| // Unless the user agrees to continue, we just |
| // abandon now ! |
| bCont = FALSE; |
| |
| // Make sure to test the return code from |
| // InternetErrorDlg user may click OK or Cancel. In |
| // case of Cancel, request should not be resubmitted |
| if (bUIFeedback) { |
| if (ERROR_SUCCESS == ::InternetErrorDlg( |
| NULL, hRequest, |
| dwErrorCode, |
| FLAGS_ERROR_UI_FILTER_FOR_ERRORS | |
| FLAGS_ERROR_UI_FLAGS_GENERATE_DATA | |
| FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS, |
| NULL)) |
| bCont = TRUE; |
| } |
| } |
| } |
| } |
| |
| if (bCont == FALSE) { |
| // User has denied the request |
| dwDownloadError = 1; |
| __leave; |
| } |
| |
| // |
| // Read HTTP status code |
| // |
| DWORD dwErrorCode = GetLastError(); |
| DWORD dwStatus=0; |
| DWORD dwStatusSize = sizeof(DWORD); |
| |
| if (FALSE == ::HttpQueryInfo(hRequest, HTTP_QUERY_FLAG_NUMBER | |
| HTTP_QUERY_STATUS_CODE, &dwStatus, &dwStatusSize, NULL)) { |
| dwErrorCode = GetLastError(); |
| } |
| |
| bCont = TRUE; |
| while ((dwStatus == HTTP_STATUS_PROXY_AUTH_REQ || |
| dwStatus == HTTP_STATUS_DENIED) && |
| bCont) { |
| int result = ::InternetErrorDlg(GetDesktopWindow(), hRequest, ERROR_INTERNET_INCORRECT_PASSWORD, |
| FLAGS_ERROR_UI_FILTER_FOR_ERRORS | |
| FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS | |
| FLAGS_ERROR_UI_FLAGS_GENERATE_DATA, |
| NULL); |
| if (ERROR_CANCELLED == result) { |
| bCont = FALSE; |
| } |
| else { |
| ::HttpSendRequest(hRequest, NULL, 0, NULL, 0); |
| |
| // Reset buffer length |
| dwStatusSize = sizeof(DWORD); |
| |
| ::HttpQueryInfo(hRequest, HTTP_QUERY_FLAG_NUMBER | |
| HTTP_QUERY_STATUS_CODE, &dwStatus, &dwStatusSize, |
| NULL); |
| } |
| } |
| |
| if (dwStatus == HTTP_STATUS_OK || |
| dwStatus == HTTP_STATUS_PARTIAL_CONTENT) { |
| // Determine content length, so we may show the progress bar |
| // meaningfully |
| // |
| nContentLength = 0; |
| DWORD nLengthSize = sizeof(DWORD); |
| ::HttpQueryInfo(hRequest, |
| HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, |
| &nContentLength, &nLengthSize, NULL); |
| |
| if (nContentLength <= 0) { |
| // If can't estimate content length, estimate it |
| // to be 6MB |
| nContentLength = 15000000; |
| } |
| else if (rangereq && (fileSize != 0) && |
| (nContentLength == fileSize)) { |
| // If the file is already downloaded completely and then |
| // we send a range request, the whole file is sent instead |
| // of nothing. So avoid downloading again. |
| // Some times return value is 206, even when whole file |
| // is sent. So check if "Content-range:" is present in the |
| // reply |
| char buffer[256]; |
| DWORD length = sizeof(buffer); |
| if(!HttpQueryInfo(hRequest, HTTP_QUERY_CONTENT_RANGE, |
| buffer, &length, NULL)) { |
| if(HttpQueryInfo(hRequest, HTTP_QUERY_LAST_MODIFIED, |
| buffer, &length, NULL)) { |
| SYSTEMTIME systime; |
| FILETIME filtime; |
| InternetTimeToSystemTime(buffer, &systime, NULL); |
| SystemTimeToFileTime(&systime, &filtime); |
| if ((CompareFileTime(&tWrite, &filtime)) == 1) { |
| // no need to download |
| dwDownloadError = 0; |
| __leave; |
| } |
| } |
| else { |
| ::SetFilePointer(hFile, 0, 0, FILE_BEGIN); |
| ::SetEndOfFile(hFile); // truncate the file |
| } |
| } |
| |
| } |
| |
| TCHAR szBuffer[8096]; |
| DWORD dwBufferSize = 8096; |
| |
| // Read from HTTP connection and write into |
| // destination file |
| // |
| DWORD nRead = 0; |
| DWORD dwTotalRead = 0; |
| BOOL bCancel = FALSE; |
| |
| if (dwStatus == HTTP_STATUS_PARTIAL_CONTENT) { |
| // If we are using resumable download, fake |
| // start time so it looks like we have begun |
| // the download several minutes again. |
| // |
| m_startTime = m_startTime - 100; |
| |
| ::SetFilePointer(hFile, 0, 0, FILE_END); // seek to end |
| } |
| else { |
| ::SetFilePointer(hFile, 0, 0, FILE_BEGIN); |
| ::SetEndOfFile(hFile); // truncate the file |
| } |
| |
| do { |
| nRead=0; |
| |
| if (::InternetReadFile(hRequest, szBuffer, dwBufferSize, |
| &nRead)) { |
| if (nRead) { |
| DWORD dwNumberOfBytesWritten = NULL; |
| |
| BOOL ret = WriteFile(hFile, szBuffer, nRead, |
| &dwNumberOfBytesWritten, NULL); |
| |
| if (!ret) { |
| // WriteFile failed |
| if (bUIFeedback) { |
| if (GetLastError() == ERROR_DISK_FULL) { |
| bRetryHttpRequest = |
| (IDRETRY == m_dlg->SafeMessageBox( |
| IDS_DISK_FULL_ERROR, |
| IDS_DISK_FULL_ERROR_CAPTION, |
| IDS_ERROR_CAPTION, |
| DIALOG_ERROR_RETRYCANCEL, |
| wName)); |
| } else { |
| bRetryHttpRequest = |
| (IDRETRY == m_dlg->SafeMessageBox( |
| IDS_DISK_WRITE_ERROR, |
| IDS_DISK_WRITE_ERROR_CAPTION, |
| IDS_ERROR_CAPTION, |
| DIALOG_ERROR_RETRYCANCEL, |
| wName)); |
| } |
| if (!bRetryHttpRequest) { |
| dwDownloadError = 1; |
| break; |
| } |
| } |
| continue; |
| } |
| } |
| |
| dwTotalRead += nRead; |
| |
| // update download progress dialog |
| m_dlg->OnProgress(nRead); |
| // Check if download has been cancelled |
| if (m_dlg->isDownloadCancelled()) { |
| m_dlg->decrementProgressMax(nContentLength, |
| dwTotalRead); |
| bCancel = TRUE; |
| break; |
| } |
| |
| } |
| else { |
| bCancel = TRUE; |
| break; |
| } |
| } |
| while (nRead); |
| |
| |
| if (bCancel) { |
| // User has cancelled the operation or InternetRead failed |
| // don't do return here, we need to cleanup |
| dwDownloadError = 1; |
| __leave; |
| } |
| } |
| else if (dwStatus == 416 && (fileSize != 0) && |
| (fileSize != 0xFFFFFFFF)) { |
| // This error could be returned, When the full file exists |
| // and a range request is sent with range beyond filessize. |
| // The best way to fix this is in future is, to send HEAD |
| // request and get filelength before sending range request. |
| dwDownloadError = 0; |
| __leave; |
| } |
| else if (dwStatus == 403) { // Forbidden from Akamai means we need to get a new download token |
| JNIEnv *env = m_dlg->getJNIEnv(); |
| jclass exceptionClass = env->FindClass("java/net/HttpRetryException"); |
| if (exceptionClass == NULL) { |
| /* Unable to find the exception class, give up. */ |
| __leave; |
| } |
| jmethodID constructor; |
| constructor = env->GetMethodID(exceptionClass, |
| "<init>", "(Ljava/lang/String;I)V"); |
| if (constructor != NULL) { |
| jobject exception = env->NewObject(exceptionClass, |
| constructor, env->NewStringUTF("Forbidden"), |
| 403); |
| env->Throw((jthrowable) exception); |
| } |
| __leave; |
| } |
| else if(dwStatus >= 400 && dwStatus < 600) { |
| /* NB: Following case seems to be never used! |
| |
| HTTP_STATUS_FORBIDDEN is the same as 403 and |
| 403 was specially handled few lines above! */ |
| if (dwStatus == HTTP_STATUS_FORBIDDEN) { |
| if (bUIFeedback) { |
| bRetryHttpRequest = (IDRETRY == m_dlg->SafeMessageBox( |
| IDS_HTTP_STATUS_FORBIDDEN, |
| IDS_HTTP_INSTRUCTION_FORBIDDEN, |
| IDS_ERROR_CAPTION, |
| DIALOG_ERROR_RETRYCANCEL, |
| L"403")); |
| } |
| } |
| else if (dwStatus == HTTP_STATUS_SERVER_ERROR) { |
| if (bUIFeedback) { |
| bRetryHttpRequest = (IDRETRY == m_dlg->SafeMessageBox( |
| IDS_HTTP_STATUS_SERVER_ERROR, |
| IDS_HTTP_INSTRUCTION_UNKNOWN_ERROR, |
| IDS_ERROR_CAPTION, |
| DIALOG_ERROR_RETRYCANCEL, |
| L"500")); |
| } |
| } |
| else if (dwStatus == HTTP_STATUS_SERVICE_UNAVAIL) { |
| if (numberOfRetry < 5) { |
| // If the server is busy, automatically retry |
| |
| // We wait couple seconds before retry to avoid |
| // congestion |
| for (long i = (long) secondsToWait; i >= 0; i--) { |
| // Update status |
| if (bUIFeedback) { |
| char szBuffer[BUFFER_SIZE]; |
| ::LoadString(_Module.GetResourceInstance(), |
| IDS_DOWNLOAD_STATUS_RETRY, szStatus, |
| BUFFER_SIZE); |
| wsprintf(szBuffer, szStatus, i); |
| |
| ::SetWindowText(hProgressInfo, szBuffer); |
| } |
| |
| // Sleep 1 second |
| ::Sleep(1000); |
| } |
| |
| // We use a semi-binary backoff algorithm to |
| // determine seconds to wait |
| numberOfRetry += 1; |
| secondsToWait = secondsToWait + 30; |
| bRetryHttpRequest = TRUE; |
| |
| continue; |
| } |
| else { |
| if (bUIFeedback) { |
| bRetryHttpRequest = (IDRETRY == m_dlg->SafeMessageBox( |
| IDS_HTTP_STATUS_SERVICE_UNAVAIL, |
| IDS_HTTP_INSTRUCTION_SERVICE_UNAVAIL, |
| IDS_ERROR_CAPTION, |
| DIALOG_ERROR_RETRYCANCEL, |
| L"503")); |
| |
| if (bRetryHttpRequest) { |
| numberOfRetry = 0; |
| secondsToWait = 60; |
| continue; |
| } |
| } |
| } |
| } |
| else { |
| if (bUIFeedback) { |
| WCHAR szBuffer[10]; |
| _snwprintf(szBuffer, 10, L"%d", dwStatus); |
| bRetryHttpRequest = (IDRETRY == m_dlg->SafeMessageBox( |
| IDS_HTTP_STATUS_OTHER, |
| IDS_HTTP_INSTRUCTION_UNKNOWN_ERROR, |
| IDS_ERROR_CAPTION, |
| DIALOG_ERROR_RETRYCANCEL, |
| szBuffer)); |
| } |
| } |
| if (!bRetryHttpRequest) { |
| dwDownloadError = 1; |
| } |
| } |
| else { |
| if (bUIFeedback) { |
| WCHAR szBuffer[10]; |
| _snwprintf(szBuffer, 10, L"%d", dwStatus); |
| bRetryHttpRequest = (IDRETRY == m_dlg->SafeMessageBox( |
| IDS_HTTP_STATUS_OTHER, |
| IDS_HTTP_INSTRUCTION_UNKNOWN_ERROR, |
| IDS_ERROR_CAPTION, |
| DIALOG_ERROR_RETRYCANCEL, |
| szBuffer)); |
| } |
| if (!bRetryHttpRequest) { |
| dwDownloadError = 1; |
| } |
| } |
| |
| |
| |
| // Close HTTP request |
| // |
| // This is necessary if the HTTP request |
| // is retried |
| if (hRequest) |
| ::InternetCloseHandle(hRequest); |
| if (hFile != INVALID_HANDLE_VALUE) { |
| ::CloseHandle(hFile); |
| hFile = INVALID_HANDLE_VALUE; |
| } |
| } |
| while (bRetryHttpRequest); |
| } |
| __finally { |
| if (hRequest) |
| ::InternetCloseHandle(hRequest); |
| |
| if (hConnect) |
| ::InternetCloseHandle(hConnect); |
| |
| if (hOpen) |
| ::InternetCloseHandle(hOpen); |
| |
| if (hFile != INVALID_HANDLE_VALUE) |
| ::CloseHandle(hFile); |
| } |
| |
| |
| |
| // Exit dialog |
| if (dwDownloadError == 0) { |
| return S_OK; |
| } else { |
| DeleteFile(szLocalFile); |
| return E_FAIL; |
| } |
| } |
