651 lines
17 KiB
C++
651 lines
17 KiB
C++
#include "sgu_stdafx.h"
|
|
#include "sgu_download_ant.h"
|
|
#include "sgu_utils.h"
|
|
|
|
#include "libEncrypt_MD5.h"
|
|
|
|
#define debugLog(...) __noop
|
|
|
|
bool parseURL(const wchar_t* pstrURL, INTERNET_SCHEME& schemeType, wchar_t* strServer, wchar_t* strObject, INTERNET_PORT& nPort);
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
CDownloadAnt::CDownloadAnt()
|
|
{
|
|
m_hThread = 0;
|
|
|
|
m_theStateCategory = IDLE;
|
|
m_theState = IDLE_NOTINIT;
|
|
|
|
m_wszURLToDownload[0] = 0;
|
|
m_wszFileToDownloadInto[0] = 0;
|
|
|
|
m_pOwner = NULL;
|
|
|
|
m_schemeType = INTERNET_SCHEME_UNKNOWN;
|
|
m_wszServer[0] = 0;
|
|
m_wszObject[0] = 0;
|
|
m_nPort = 80;
|
|
|
|
m_hInternetSession = NULL;
|
|
m_hHttpConnection = NULL;
|
|
m_hHttpFile = NULL;
|
|
|
|
m_dwUserCmd = MANAGER_CMD_CONTINUE;
|
|
m_nOverTime = INFINITE;
|
|
|
|
m_bGotFileSize = FALSE;
|
|
m_dwFileSizeTotal = 0;
|
|
m_dwFileSizeRead = 0;
|
|
m_fpFileToWrite = NULL;
|
|
|
|
UserCallBack = NULL;
|
|
|
|
m_wszStatusInfor[0] = 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
CDownloadAnt::~CDownloadAnt()
|
|
{
|
|
//关闭
|
|
UserCallBack = NULL;
|
|
if (m_hHttpFile)
|
|
{
|
|
::InternetCloseHandle(m_hHttpFile);
|
|
m_hHttpFile = NULL;
|
|
}
|
|
if (m_hHttpConnection)
|
|
{
|
|
::InternetCloseHandle(m_hHttpConnection);
|
|
m_hHttpConnection = NULL;
|
|
}
|
|
if (m_hInternetSession)
|
|
{
|
|
::InternetCloseHandle(m_hInternetSession);
|
|
m_hInternetSession = NULL;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
bool CDownloadAnt::init(const wchar_t* wszURLToDownload, const wchar_t* wszFileToDownloadInto,
|
|
DOWNANT_STATUS_CALLBACK funcUserCallBack, void* pOwner, unsigned int nOverTime)
|
|
{
|
|
assert(m_theStateCategory != BUSY);
|
|
assert(wszURLToDownload && wszFileToDownloadInto);
|
|
|
|
StringCchCopyW(m_wszURLToDownload, INTERNET_MAX_URL_LENGTH, wszURLToDownload);
|
|
StringCchCopyW(m_wszFileToDownloadInto, MAX_PATH, wszFileToDownloadInto);
|
|
|
|
debugLog(L"build ant download \"%s\" to \"%s\"", m_wszURLToDownload, m_wszFileToDownloadInto);
|
|
|
|
m_pOwner = pOwner;
|
|
UserCallBack = funcUserCallBack;
|
|
|
|
if (wcslen(m_wszURLToDownload) > 0 && wcslen(m_wszFileToDownloadInto) > 0)
|
|
{
|
|
if (!parseURL(m_wszURLToDownload, m_schemeType, m_wszServer, m_wszObject, m_nPort) ||
|
|
m_schemeType == INTERNET_SCHEME_UNKNOWN)
|
|
{
|
|
const wchar_t* wsz = L"Parser URL Error: %s";
|
|
StringCchPrintfW(m_wszStatusInfor, MAX_PATH, L"Parser URL Error: %s", m_wszURLToDownload);
|
|
setStatus(IDLE_INIT_FAILED);
|
|
return FALSE;
|
|
}
|
|
setStatus(IDLE_INIT_SUCCESS);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
StringCchPrintfW(m_wszStatusInfor, MAX_PATH, L"url and local file address can't be empty!");
|
|
setStatus(IDLE_INIT_FAILED);
|
|
return FALSE;
|
|
}
|
|
|
|
m_nOverTime = nOverTime;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
void CDownloadAnt::begin(bool bBlock)
|
|
{
|
|
assert(m_theState == IDLE_INIT_SUCCESS);
|
|
|
|
UINT nThreadID;
|
|
m_hThread = (HANDLE)::_beginthreadex(NULL, 0, _downloadThread, this, CREATE_SUSPENDED, &nThreadID);
|
|
|
|
if (m_hThread == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
setStatus(BUSY_BEGIN_THREAD);
|
|
m_beginTime = ::GetTickCount64();
|
|
ResumeThread(m_hThread);
|
|
|
|
if (bBlock)
|
|
{
|
|
::WaitForSingleObject(m_hThread, INFINITE);
|
|
//关闭句柄
|
|
CloseHandle(m_hThread); m_hThread = 0;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
UINT CDownloadAnt::_downloadThread(void* pParam)
|
|
{
|
|
CDownloadAnt* pAnt = (CDownloadAnt*)pParam;
|
|
assert(pAnt);
|
|
|
|
try
|
|
{
|
|
pAnt->downloadThread();
|
|
}
|
|
catch (...)
|
|
{
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
void CDownloadAnt::downloadThread(void)
|
|
{
|
|
assert(m_theState == BUSY_BEGIN_THREAD);
|
|
assert(m_hInternetSession == NULL);
|
|
assert(m_fpFileToWrite == NULL);
|
|
assert(m_hHttpConnection == NULL);
|
|
assert(m_hHttpFile == NULL);
|
|
|
|
_wfopen_s(&m_fpFileToWrite, m_wszFileToDownloadInto, L"wb");
|
|
if (m_fpFileToWrite == NULL)
|
|
{
|
|
StringCchPrintfW(m_wszStatusInfor, MAX_PATH, L"Create local file error: %s, Error:%d", m_wszFileToDownloadInto, ::GetLastError());
|
|
setStatus(FINISH_ERROR_TRY_OPEN_LOCALFILE);
|
|
return;
|
|
}
|
|
|
|
//打开Internet句柄
|
|
m_hInternetSession = InternetOpenW(NULL, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
|
|
if (m_hInternetSession == NULL)
|
|
{
|
|
StringCchPrintfW(m_wszStatusInfor, MAX_PATH, L"(::InternetOpen) Error:%d\n", ::GetLastError());
|
|
setStatus(FINISH_ERROR_INTERNET_OPEN);
|
|
return;
|
|
}
|
|
if (_checkAbort()) return;
|
|
|
|
DWORD dwTemp = 0, dwSize = sizeof(DWORD);
|
|
BOOL bRet = InternetQueryOptionW(m_hInternetSession, INTERNET_OPTION_MAX_CONNS_PER_SERVER, &dwTemp, &dwSize);
|
|
DWORD dwErr = GetLastError();
|
|
|
|
//设置状态回调函数
|
|
if (::InternetSetStatusCallbackW(m_hInternetSession, _onWininetStatusCallBack) == INTERNET_INVALID_STATUS_CALLBACK)
|
|
{
|
|
StringCchPrintfW(m_wszStatusInfor, MAX_PATH, L"(::InternetSetStatusCallback), Error:%d\n", ::GetLastError());
|
|
setStatus(FINISH_ERROR_SETSTATUSCALLBACK);
|
|
return;
|
|
}
|
|
if (_checkAbort()) return;
|
|
|
|
DWORD serviceType = 0;
|
|
if(m_schemeType == INTERNET_SCHEME_HTTP||m_schemeType== INTERNET_SCHEME_HTTPS)
|
|
{
|
|
serviceType = INTERNET_SERVICE_HTTP;
|
|
}
|
|
else if (m_schemeType == INTERNET_SCHEME_FTP)
|
|
{
|
|
serviceType = INTERNET_SERVICE_FTP;
|
|
}
|
|
else
|
|
{
|
|
StringCchPrintfW(m_wszStatusInfor, MAX_PATH, L"Unsupported scheme type: %d", m_schemeType);
|
|
setStatus(FINISH_ERROR_UNSUPPORTED_SCHEME);
|
|
return;
|
|
}
|
|
|
|
//打开Internet连接
|
|
m_hHttpConnection = InternetConnectW(m_hInternetSession, m_wszServer, m_nPort, NULL,
|
|
NULL, serviceType, 0, (DWORD_PTR)this);
|
|
|
|
if (m_hHttpConnection == NULL)
|
|
{
|
|
StringCchPrintfW(m_wszStatusInfor, MAX_PATH, L"(::InternetConnect), Error:%d\n", ::GetLastError());
|
|
setStatus(FINISH_ERROR_INTERNETCONNECT);
|
|
return;
|
|
}
|
|
if (_checkAbort()) return;
|
|
|
|
//生成Request
|
|
const wchar_t* ppszAcceptTypes[2];
|
|
ppszAcceptTypes[0] = L"*/*";
|
|
ppszAcceptTypes[1] = NULL;
|
|
|
|
DWORD dwFlags = INTERNET_FLAG_RELOAD | INTERNET_FLAG_NO_CACHE_WRITE | INTERNET_FLAG_NO_COOKIES;
|
|
if(serviceType==INTERNET_SERVICE_HTTP && m_schemeType == INTERNET_SCHEME_HTTPS)
|
|
{
|
|
dwFlags |= INTERNET_FLAG_SECURE;
|
|
}
|
|
|
|
m_hHttpFile = HttpOpenRequestW(m_hHttpConnection,
|
|
L"GET", m_wszObject, NULL, NULL, ppszAcceptTypes,
|
|
dwFlags,
|
|
(DWORD_PTR)this);
|
|
if (m_hHttpFile == NULL)
|
|
{
|
|
StringCchPrintfW(m_wszStatusInfor, MAX_PATH, L"(::HttpOpenRequest), Error:%d\n", ::GetLastError());
|
|
setStatus(FINISH_ERROR_OPENREQUEST);
|
|
return;
|
|
}
|
|
if (_checkAbort()) return;
|
|
setStatus(BUSY_OPEN_REQUEST);
|
|
|
|
//发送Request
|
|
BOOL bSend = HttpSendRequestW(m_hHttpFile, NULL, 0, NULL, 0);
|
|
if (!bSend)
|
|
{
|
|
StringCchPrintfW(m_wszStatusInfor, MAX_PATH, L"(::HttpSendRequest), Error:%d\n", ::GetLastError());
|
|
setStatus(FINISH_ERROR_SENDREQUEST);
|
|
return;
|
|
}
|
|
if (_checkAbort()) return;
|
|
|
|
//查询状态
|
|
DWORD dwInfoSize = 64;
|
|
CHAR szStatusCode[64] = { 0 };
|
|
if (!::HttpQueryInfoW(m_hHttpFile, HTTP_QUERY_STATUS_CODE, szStatusCode, &dwInfoSize, NULL))
|
|
{
|
|
StringCchPrintfW(m_wszStatusInfor, MAX_PATH, L"Failed in call to HttpQueryInfo for HTTP query status code, Error:%d\n", ::GetLastError());
|
|
setStatus(FINISH_ERROR_QUERYINFO);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
long nStatusCode = atoi(szStatusCode);
|
|
|
|
if (nStatusCode != HTTP_STATUS_OK)
|
|
{
|
|
m_theState = FINISH_ERROR_INVALID_HTTP_RESPONSE;
|
|
|
|
if (nStatusCode == HTTP_STATUS_PROXY_AUTH_REQ)
|
|
{
|
|
StringCchPrintfW(m_wszStatusInfor, MAX_PATH, L"Authentication errors, Status Code:%d\n", nStatusCode);
|
|
setStatus(FINISH_ERROR_NEED_PROXY_AUTH_REQ);
|
|
return;
|
|
}
|
|
else if (nStatusCode == HTTP_STATUS_DENIED)
|
|
{
|
|
StringCchPrintfW(m_wszStatusInfor, MAX_PATH, L"Authentication errors, Status Code:%d\n", nStatusCode);
|
|
setStatus(FINISH_ERROR_DENIED);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (_checkAbort()) return;
|
|
|
|
// 取得文件大小
|
|
dwInfoSize = 64;
|
|
wchar_t wszContentLength[64] = { 0 };
|
|
if (HttpQueryInfoW(m_hHttpFile, HTTP_QUERY_CONTENT_LENGTH, wszContentLength, &dwInfoSize, NULL))
|
|
{
|
|
m_bGotFileSize = TRUE;
|
|
m_dwFileSizeTotal = _wtoi64(wszContentLength);
|
|
StringCchPrintfW(m_wszStatusInfor, MAX_PATH, L"FileSize: %I64d", m_dwFileSizeTotal);
|
|
}
|
|
|
|
debugLog(L"Get file size %I64d, begin download...", m_dwFileSizeTotal);
|
|
//得到文件大小，让Manager处理位置
|
|
setStatus(BUSY_GET_FILE_INFORMATION);
|
|
if (_checkAbort()) return;
|
|
|
|
//开始下载
|
|
ULONGLONG startTicks = ::GetTickCount64();
|
|
DWORD dwBytesRead = 0;
|
|
char szReadBuf[DOWNANT_MINSIZE] = { 0 };
|
|
DWORD dwBytesToRead = DOWNANT_MINSIZE;
|
|
m_dwFileSizeRead = 0;
|
|
|
|
MD5Context md5Ctx;
|
|
md5Init(&md5Ctx);
|
|
|
|
setStatus(BUSY_BEGIN_DOWNFILE);
|
|
do
|
|
{
|
|
if (!InternetReadFile(m_hHttpFile, szReadBuf, dwBytesToRead, &dwBytesRead))
|
|
{
|
|
StringCchPrintfW(m_wszStatusInfor, MAX_PATH, L"(::InternetReadFile), Error:%d\n", ::GetLastError());
|
|
setStatus(FINISH_ERROR_READFILE);
|
|
return;
|
|
}
|
|
else if (dwBytesRead && m_dwUserCmd == MANAGER_CMD_CONTINUE)
|
|
{
|
|
try
|
|
{
|
|
if (dwBytesRead != ::fwrite(szReadBuf, 1, dwBytesRead, m_fpFileToWrite))
|
|
{
|
|
throw FINISH_ERROR_EXCEPTION;
|
|
}
|
|
|
|
md5Update(&md5Ctx, (unsigned char*)szReadBuf, dwBytesRead);
|
|
}
|
|
catch (...)
|
|
{
|
|
StringCchPrintfW(m_wszStatusInfor, MAX_PATH, L"write local file error!, Error:%d", ::GetLastError());
|
|
setStatus(FINISH_ERROR_EXCEPTION);
|
|
return;
|
|
}
|
|
|
|
m_dwFileSizeRead += dwBytesRead;
|
|
onStatusCallback();
|
|
}
|
|
|
|
if (_checkAbort())
|
|
{
|
|
if (m_fpFileToWrite)::fclose(m_fpFileToWrite);
|
|
m_fpFileToWrite = NULL;
|
|
return;
|
|
}
|
|
} while (dwBytesRead && m_dwUserCmd == MANAGER_CMD_CONTINUE);
|
|
|
|
//生成MD5
|
|
m_fileMD5 = md5Finalize(&md5Ctx);
|
|
|
|
if (m_fpFileToWrite)::fclose(m_fpFileToWrite);
|
|
m_fpFileToWrite = NULL;
|
|
|
|
debugLog(L"Download success over!");
|
|
|
|
setStatus(FINISH_SUCCESS_OVER);
|
|
return;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
bool CDownloadAnt::checkMD5(const char* md5_string) const
|
|
{
|
|
MD5Digest md5;
|
|
if (!string2MD5(md5_string, md5)) return false;
|
|
|
|
return (0 == memcmp(&md5, &m_fileMD5, md5.size()));
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
void CALLBACK CDownloadAnt::_onWininetStatusCallBack(HINTERNET hInternet, DWORD_PTR dwContext, DWORD dwInternetStatus,
|
|
LPVOID lpvStatusInformation, DWORD dwStatusInformationLength)
|
|
{
|
|
CDownloadAnt* pDownMan = (CDownloadAnt*)dwContext;
|
|
assert(pDownMan);
|
|
|
|
pDownMan->onWininetStatusCallBack(hInternet, dwInternetStatus, lpvStatusInformation, dwStatusInformationLength);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
void CDownloadAnt::onWininetStatusCallBack(HINTERNET /*hInternet*/, DWORD dwInternetStatus,
|
|
LPVOID lpvStatusInformation, DWORD /*dwStatusInformationLength*/)
|
|
{
|
|
switch (dwInternetStatus)
|
|
{
|
|
case INTERNET_STATUS_RESOLVING_NAME:
|
|
{
|
|
StringCchCopyW(m_wszStatusInfor, MAX_PATH, (LPCWSTR)lpvStatusInformation);
|
|
setStatus(BUSY_RESOLVING_NAME);
|
|
break;
|
|
}
|
|
case INTERNET_STATUS_NAME_RESOLVED:
|
|
{
|
|
StringCchCopyW(m_wszStatusInfor, MAX_PATH, (LPCWSTR)lpvStatusInformation);
|
|
setStatus(BUSY_RESOLVED_NAME);
|
|
break;
|
|
}
|
|
case INTERNET_STATUS_CONNECTING_TO_SERVER:
|
|
{
|
|
StringCchCopyW(m_wszStatusInfor, MAX_PATH, (LPCWSTR)lpvStatusInformation);
|
|
setStatus(BUSY_CONNECTING);
|
|
break;
|
|
}
|
|
case INTERNET_STATUS_CONNECTED_TO_SERVER:
|
|
{
|
|
StringCchCopyW(m_wszStatusInfor, MAX_PATH, (LPCWSTR)lpvStatusInformation);
|
|
setStatus(BUSY_CONNECTED);
|
|
break;
|
|
}
|
|
case INTERNET_STATUS_REDIRECT:
|
|
{
|
|
StringCchCopyW(m_wszStatusInfor, MAX_PATH, (LPCWSTR)lpvStatusInformation);
|
|
setStatus(BUSY_REDIRECTING);
|
|
break;
|
|
}
|
|
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
void CDownloadAnt::setStatus(CDownloadAnt::DOWN_STATE newState)
|
|
{
|
|
m_theState = newState;
|
|
onStatusCallback();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
void CDownloadAnt::onStatusCallback(void)
|
|
{
|
|
switch (m_theState)
|
|
{
|
|
case IDLE_NOTINIT:
|
|
case IDLE_INIT_SUCCESS:
|
|
case IDLE_INIT_FAILED:
|
|
{
|
|
m_theStateCategory = IDLE;
|
|
}
|
|
break;
|
|
|
|
case BUSY_BEGIN_THREAD:
|
|
case BUSY_OPEN_REQUEST:
|
|
case BUSY_RESOLVING_NAME:
|
|
case BUSY_RESOLVED_NAME:
|
|
case BUSY_CONNECTING:
|
|
case BUSY_CONNECTED:
|
|
case BUSY_REDIRECTING:
|
|
case BUSY_GET_FILE_INFORMATION:
|
|
case BUSY_BEGIN_DOWNFILE:
|
|
{
|
|
m_theStateCategory = BUSY;
|
|
}
|
|
break;
|
|
|
|
case FINISH_SUCCESS_OVER:
|
|
case FINISH_SUCCESS_STOPHERE:
|
|
{
|
|
m_theStateCategory = FINISH_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case FINISH_FORCEABORT:
|
|
case FINISH_ERROR_TIMEOUT:
|
|
case FINISH_ERROR_TRY_OPEN_LOCALFILE:
|
|
case FINISH_ERROR_INTERNET_OPEN:
|
|
case FINISH_ERROR_SETSTATUSCALLBACK:
|
|
case FINISH_ERROR_INTERNETCONNECT:
|
|
case FINISH_ERROR_OPENREQUEST:
|
|
case FINISH_ERROR_SENDREQUEST:
|
|
case FINISH_ERROR_QUERYINFO:
|
|
case FINISH_ERROR_NEED_PROXY_AUTH_REQ:
|
|
case FINISH_ERROR_DENIED:
|
|
case FINISH_ERROR_INVALID_HTTP_RESPONSE:
|
|
case FINISH_ERROR_READFILE:
|
|
case FINISH_ERROR_EXCEPTION:
|
|
{
|
|
m_theStateCategory = FINISH_NOT_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
assert(false);
|
|
break;
|
|
}
|
|
|
|
if (m_theStateCategory == FINISH_SUCCESS || m_theStateCategory == FINISH_NOT_SUCCESS)
|
|
{
|
|
if (m_fpFileToWrite)
|
|
{
|
|
::fclose(m_fpFileToWrite);
|
|
m_fpFileToWrite = NULL;
|
|
}
|
|
|
|
if (m_hHttpFile)
|
|
{
|
|
::InternetCloseHandle(m_hHttpFile);
|
|
m_hHttpFile = NULL;
|
|
}
|
|
if (m_hHttpConnection)
|
|
{
|
|
::InternetCloseHandle(m_hHttpConnection);
|
|
m_hHttpConnection = NULL;
|
|
}
|
|
if (m_hInternetSession)
|
|
{
|
|
::InternetCloseHandle(m_hInternetSession);
|
|
m_hInternetSession = NULL;
|
|
}
|
|
}
|
|
|
|
if (UserCallBack)
|
|
{
|
|
m_dwUserCmd = UserCallBack(m_pOwner, this);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
BOOL CDownloadAnt::_checkAbort(void)
|
|
{
|
|
HANDLE hCloseMutex = OpenMutexW(SYNCHRONIZE, FALSE, L"Global\\8e931dcb-868e-4ba6-aff4-d1a22bc9d476");
|
|
if (hCloseMutex != 0)
|
|
{
|
|
CloseHandle(hCloseMutex);
|
|
debugLog(L"[ANT]Receive autoclose signal, quit!");
|
|
return TRUE;
|
|
}
|
|
|
|
if (MANAGER_CMD_FORCEABORT == m_dwUserCmd)
|
|
{
|
|
setStatus(FINISH_FORCEABORT);
|
|
return TRUE;
|
|
}
|
|
if (MANAGER_CMD_STOPHERE == m_dwUserCmd)
|
|
{
|
|
setStatus(FINISH_SUCCESS_STOPHERE);
|
|
return TRUE;
|
|
}
|
|
|
|
if (m_nOverTime != INFINITE && m_theStateCategory == BUSY)
|
|
{
|
|
ULONGLONG timeNow = ::GetTickCount64();
|
|
ULONGLONG timeRun;
|
|
if (timeNow >= m_beginTime) timeRun = timeNow - m_beginTime;
|
|
else timeRun = timeNow + (0XFFFFFFFFFFFFFFFFULL - m_beginTime);
|
|
|
|
if (timeRun > m_nOverTime * 1000ULL)
|
|
{
|
|
setStatus(FINISH_ERROR_TIMEOUT);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL MyAfxIsValidAddress(const void* lp, UINT nBytes, BOOL bReadWrite /* = TRUE */)
|
|
{
|
|
// simple version using Win-32 APIs for pointer validation.
|
|
return (lp != NULL && !IsBadReadPtr(lp, nBytes) &&
|
|
(!bReadWrite || !IsBadWritePtr((LPVOID)lp, nBytes)));
|
|
}
|
|
|
|
bool _AfxParseURLWorker(const wchar_t* pstrURL, LPURL_COMPONENTSW lpComponents,
|
|
INTERNET_SCHEME& schemeType, INTERNET_PORT& nPort, DWORD dwFlags)
|
|
{
|
|
// this function will return bogus stuff if lpComponents
|
|
// isn't set up to copy the components
|
|
|
|
assert(lpComponents != NULL && pstrURL != NULL);
|
|
if (lpComponents == NULL || pstrURL == NULL)
|
|
return FALSE;
|
|
assert(lpComponents->dwHostNameLength == 0 ||
|
|
lpComponents->lpszHostName != NULL);
|
|
assert(lpComponents->dwUrlPathLength == 0 ||
|
|
lpComponents->lpszUrlPath != NULL);
|
|
assert(lpComponents->dwUserNameLength == 0 ||
|
|
lpComponents->lpszUserName != NULL);
|
|
assert(lpComponents->dwPasswordLength == 0 ||
|
|
lpComponents->lpszPassword != NULL);
|
|
|
|
assert(MyAfxIsValidAddress(lpComponents, sizeof(URL_COMPONENTS), TRUE));
|
|
|
|
wchar_t* pstrCanonicalizedURL;
|
|
wchar_t szCanonicalizedURL[INTERNET_MAX_URL_LENGTH];
|
|
DWORD dwNeededLength = INTERNET_MAX_URL_LENGTH;
|
|
BOOL bRetVal;
|
|
BOOL bMustFree = FALSE;
|
|
DWORD dwCanonicalizeFlags = dwFlags &
|
|
(ICU_NO_ENCODE | ICU_DECODE | ICU_NO_META |
|
|
ICU_ENCODE_SPACES_ONLY | ICU_BROWSER_MODE);
|
|
DWORD dwCrackFlags = dwFlags & (ICU_ESCAPE | ICU_USERNAME);
|
|
|
|
bRetVal = InternetCanonicalizeUrlW(pstrURL, szCanonicalizedURL,
|
|
&dwNeededLength, dwCanonicalizeFlags);
|
|
|
|
if (!bRetVal)
|
|
{
|
|
if (::GetLastError() != ERROR_INSUFFICIENT_BUFFER)
|
|
return FALSE;
|
|
|
|
pstrCanonicalizedURL = new wchar_t[dwNeededLength];
|
|
bMustFree = TRUE;
|
|
bRetVal = InternetCanonicalizeUrlW(pstrURL, pstrCanonicalizedURL,
|
|
&dwNeededLength, dwCanonicalizeFlags);
|
|
if (!bRetVal)
|
|
{
|
|
delete[] pstrCanonicalizedURL;
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
pstrCanonicalizedURL = szCanonicalizedURL;
|
|
|
|
// now that it's safely canonicalized, crack it
|
|
bRetVal = InternetCrackUrlW(pstrCanonicalizedURL, 0, dwCrackFlags, lpComponents);
|
|
if (bMustFree)
|
|
delete[] pstrCanonicalizedURL;
|
|
|
|
if (bRetVal)
|
|
{
|
|
nPort = lpComponents->nPort;
|
|
schemeType = lpComponents->nScheme;
|
|
}
|
|
else
|
|
{
|
|
schemeType = INTERNET_SCHEME_UNKNOWN;
|
|
}
|
|
|
|
return bRetVal == TRUE;
|
|
}
|
|
|
|
bool parseURL(const wchar_t* pstrURL, INTERNET_SCHEME& schemeType, wchar_t* strServer, wchar_t* strObject, INTERNET_PORT& nPort)
|
|
{
|
|
schemeType = INTERNET_SCHEME_UNKNOWN;
|
|
|
|
assert(pstrURL != NULL);
|
|
if (pstrURL == NULL)
|
|
return FALSE;
|
|
|
|
URL_COMPONENTSW urlComponents;
|
|
memset(&urlComponents, 0, sizeof(URL_COMPONENTS));
|
|
urlComponents.dwStructSize = sizeof(URL_COMPONENTS);
|
|
|
|
urlComponents.dwHostNameLength = MAX_PATH;
|
|
urlComponents.lpszHostName = strServer;
|
|
urlComponents.dwUrlPathLength = INTERNET_MAX_URL_LENGTH;
|
|
urlComponents.lpszUrlPath = strObject;
|
|
|
|
return _AfxParseURLWorker(pstrURL, &urlComponents, schemeType, nPort, ICU_BROWSER_MODE);
|
|
}
|
|
|