forked from LosaDev/ls-2019-source
LosaDev source snapshot 2019
This commit is contained in:
LosaDev committed
commit
c198676e97
20588 files changed
+8812878
No files matched your search
@@ -0,0 +1,858 @@
|
||||
/**
|
||||
* Copyright 2008-2010 Cheng Shi. All rights reserved.
|
||||
* Email: [email protected]
|
||||
*/
|
||||
|
||||
#ifndef WINHTTPCLIENT_H
|
||||
#define WINHTTPCLIENT_H
|
||||
|
||||
#pragma comment(lib, "Winhttp.lib")
|
||||
|
||||
#include "RegExp.h"
|
||||
#include "StringProcess.h"
|
||||
#include <comutil.h>
|
||||
#include <windows.h>
|
||||
#include <Winhttp.h>
|
||||
#include <string>
|
||||
using namespace std;
|
||||
|
||||
typedef bool (*PROGRESSPROC)(double);
|
||||
|
||||
static const unsigned int INT_RETRYTIMES = 3;
|
||||
static wchar_t *SZ_AGENT = L"WinHttpClient";
|
||||
static const int INT_BUFFERSIZE = 10240; // Initial 10 KB temporary buffer, double if it is not enough.
|
||||
|
||||
class WinHttpClient
|
||||
{
|
||||
public:
|
||||
inline WinHttpClient(PROGRESSPROC progressProc = NULL);
|
||||
inline ~WinHttpClient(void);
|
||||
|
||||
void Init();
|
||||
void Destroy();
|
||||
|
||||
public:
|
||||
// It is a synchronized method and may take a long time to finish.
|
||||
inline bool SendHttpRequest(const wstring &httpVerb = L"GET", bool disableAutoRedirect = false);
|
||||
inline wstring GetResponseHeader(void);
|
||||
inline wstring GetResponseContent(void);
|
||||
inline wstring GetResponseCharset(void);
|
||||
inline wstring GetResponseStatusCode(void);
|
||||
inline wstring GetResponseLocation(void);
|
||||
inline wstring GetRequestHost(void);
|
||||
inline const BYTE *GetRawResponseContent(void);
|
||||
inline unsigned int GetRawResponseContentLength(void);
|
||||
inline unsigned int GetRawResponseReceivedContentLength(void);
|
||||
inline bool SaveResponseToFile(const wstring &filePath);
|
||||
inline wstring GetResponseCookies(void);
|
||||
inline bool SetAdditionalRequestCookies(const wstring &cookies);
|
||||
inline bool SetAdditionalDataToSend(BYTE *data, unsigned int dataSize);
|
||||
inline bool UpdateUrl(const wstring &url);
|
||||
inline bool ResetAdditionalDataToSend(void);
|
||||
inline bool SetAdditionalRequestHeaders(const wstring &additionalRequestHeaders);
|
||||
inline bool SetRequireValidSslCertificates(bool require);
|
||||
inline bool SetProxy(const wstring &proxy);
|
||||
inline DWORD GetLastError(void);
|
||||
inline bool SetUserAgent(const wstring &userAgent);
|
||||
inline bool SetForceCharset(const wstring &charset);
|
||||
inline bool SetProxyUsername(const wstring &username);
|
||||
inline bool SetProxyPassword(const wstring &password);
|
||||
inline bool SetTimeouts(unsigned int resolveTimeout = 0,
|
||||
unsigned int connectTimeout = 60000,
|
||||
unsigned int sendTimeout = 30000,
|
||||
unsigned int receiveTimeout = 30000);
|
||||
|
||||
private:
|
||||
inline WinHttpClient(const WinHttpClient &other);
|
||||
inline WinHttpClient &operator =(const WinHttpClient &other);
|
||||
inline bool SetProgress(unsigned int byteCountReceived);
|
||||
|
||||
HINTERNET m_sessionHandle;
|
||||
bool m_requireValidSsl;
|
||||
wstring m_requestURL;
|
||||
wstring m_requestHost;
|
||||
wstring m_responseHeader;
|
||||
wstring m_responseContent;
|
||||
wstring m_responseCharset;
|
||||
BYTE *m_pResponse;
|
||||
unsigned int m_responseByteCountReceived; // Up to 4GB.
|
||||
PROGRESSPROC m_pfProcessProc;
|
||||
unsigned int m_responseByteCount;
|
||||
wstring m_responseCookies;
|
||||
wstring m_additionalRequestCookies;
|
||||
BYTE *m_pDataToSend;
|
||||
unsigned int m_dataToSendSize;
|
||||
wstring m_additionalRequestHeaders;
|
||||
wstring m_proxy;
|
||||
DWORD m_dwLastError;
|
||||
wstring m_statusCode;
|
||||
wstring m_userAgent;
|
||||
bool m_bForceCharset;
|
||||
wstring m_proxyUsername;
|
||||
wstring m_proxyPassword;
|
||||
wstring m_location;
|
||||
unsigned int m_resolveTimeout;
|
||||
unsigned int m_connectTimeout;
|
||||
unsigned int m_sendTimeout;
|
||||
unsigned int m_receiveTimeout;
|
||||
};
|
||||
|
||||
WinHttpClient::WinHttpClient(PROGRESSPROC progressProc)
|
||||
: m_sessionHandle(NULL),
|
||||
m_requireValidSsl(false),
|
||||
m_responseHeader(L""),
|
||||
m_responseContent(L""),
|
||||
m_responseCharset(L""),
|
||||
m_requestHost(L""),
|
||||
m_pResponse(NULL),
|
||||
m_responseByteCountReceived(0),
|
||||
m_pfProcessProc(progressProc),
|
||||
m_responseByteCount(0),
|
||||
m_responseCookies(L""),
|
||||
m_additionalRequestCookies(L""),
|
||||
m_pDataToSend(NULL),
|
||||
m_dataToSendSize(0),
|
||||
m_proxy(L""),
|
||||
m_dwLastError(0),
|
||||
m_statusCode(L""),
|
||||
m_userAgent(SZ_AGENT),
|
||||
m_bForceCharset(false),
|
||||
m_proxyUsername(L""),
|
||||
m_proxyPassword(L""),
|
||||
m_location(L""),
|
||||
m_resolveTimeout(0),
|
||||
m_connectTimeout(60000),
|
||||
m_sendTimeout(30000),
|
||||
m_receiveTimeout(30000)
|
||||
{
|
||||
Init();
|
||||
}
|
||||
|
||||
WinHttpClient::~WinHttpClient(void)
|
||||
{
|
||||
Destroy();
|
||||
}
|
||||
|
||||
void WinHttpClient::Init()
|
||||
{
|
||||
m_requestURL = L"";
|
||||
}
|
||||
|
||||
void WinHttpClient::Destroy()
|
||||
{
|
||||
if (m_pResponse != NULL)
|
||||
{
|
||||
delete[] m_pResponse;
|
||||
}
|
||||
if (m_pDataToSend != NULL)
|
||||
{
|
||||
delete[] m_pDataToSend;
|
||||
}
|
||||
|
||||
if (m_sessionHandle != NULL)
|
||||
{
|
||||
::WinHttpCloseHandle(m_sessionHandle);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
bool WinHttpClient::SendHttpRequest(const wstring &httpVerb, bool disableAutoRedirect)
|
||||
{
|
||||
if (m_requestURL.size() <= 0)
|
||||
{
|
||||
m_dwLastError = ERROR_PATH_NOT_FOUND;
|
||||
return false;
|
||||
}
|
||||
// Make verb uppercase.
|
||||
wstring verb = httpVerb;
|
||||
if (_wcsicmp(httpVerb.c_str(), L"GET") == 0)
|
||||
{
|
||||
verb = L"GET";
|
||||
}
|
||||
else if (_wcsicmp(verb.c_str(), L"POST") == 0)
|
||||
{
|
||||
verb = L"POST";
|
||||
}
|
||||
else
|
||||
{
|
||||
m_dwLastError = ERROR_INVALID_PARAMETER;
|
||||
return false;
|
||||
}
|
||||
bool bRetVal = true;
|
||||
|
||||
if (m_sessionHandle == NULL)
|
||||
{
|
||||
m_sessionHandle = ::WinHttpOpen(m_userAgent.c_str(),
|
||||
WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
|
||||
WINHTTP_NO_PROXY_NAME,
|
||||
WINHTTP_NO_PROXY_BYPASS,
|
||||
0);
|
||||
if (m_sessionHandle == NULL)
|
||||
{
|
||||
m_dwLastError = ::GetLastError();
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
::WinHttpSetTimeouts(m_sessionHandle,
|
||||
m_resolveTimeout,
|
||||
m_connectTimeout,
|
||||
m_sendTimeout,
|
||||
m_receiveTimeout);
|
||||
|
||||
wchar_t szHostName[MAX_PATH] = L"";
|
||||
wchar_t szURLPath[MAX_PATH * 5] = L"";
|
||||
URL_COMPONENTS urlComp;
|
||||
memset(&urlComp, 0, sizeof(urlComp));
|
||||
urlComp.dwStructSize = sizeof(urlComp);
|
||||
urlComp.lpszHostName = szHostName;
|
||||
urlComp.dwHostNameLength = MAX_PATH;
|
||||
urlComp.lpszUrlPath = szURLPath;
|
||||
urlComp.dwUrlPathLength = MAX_PATH * 5;
|
||||
urlComp.dwSchemeLength = 1; // None zero
|
||||
|
||||
if (::WinHttpCrackUrl(m_requestURL.c_str(), m_requestURL.size(), 0, &urlComp))
|
||||
{
|
||||
m_requestHost = szHostName;
|
||||
HINTERNET hConnect = NULL;
|
||||
hConnect = ::WinHttpConnect(m_sessionHandle, szHostName, urlComp.nPort, 0);
|
||||
if (hConnect != NULL)
|
||||
{
|
||||
DWORD dwOpenRequestFlag = (urlComp.nScheme == INTERNET_SCHEME_HTTPS) ? WINHTTP_FLAG_SECURE : 0;
|
||||
HINTERNET hRequest = NULL;
|
||||
hRequest = ::WinHttpOpenRequest(hConnect,
|
||||
verb.c_str(),
|
||||
urlComp.lpszUrlPath,
|
||||
NULL,
|
||||
WINHTTP_NO_REFERER,
|
||||
WINHTTP_DEFAULT_ACCEPT_TYPES,
|
||||
dwOpenRequestFlag);
|
||||
if (hRequest != NULL)
|
||||
{
|
||||
// If HTTPS, then client is very susceptable to invalid certificates
|
||||
// Easiest to accept anything for now
|
||||
if (!m_requireValidSsl && urlComp.nScheme == INTERNET_SCHEME_HTTPS)
|
||||
{
|
||||
DWORD options = SECURITY_FLAG_IGNORE_CERT_CN_INVALID
|
||||
| SECURITY_FLAG_IGNORE_CERT_DATE_INVALID
|
||||
| SECURITY_FLAG_IGNORE_UNKNOWN_CA;
|
||||
::WinHttpSetOption(hRequest,
|
||||
WINHTTP_OPTION_SECURITY_FLAGS,
|
||||
(LPVOID)&options,
|
||||
sizeof(DWORD));
|
||||
}
|
||||
|
||||
bool bGetReponseSucceed = false;
|
||||
unsigned int iRetryTimes = 0;
|
||||
|
||||
// Retry for several times if fails.
|
||||
while (!bGetReponseSucceed && iRetryTimes++ < INT_RETRYTIMES)
|
||||
{
|
||||
if (m_additionalRequestHeaders.size() > 0)
|
||||
{
|
||||
if (!::WinHttpAddRequestHeaders(hRequest, m_additionalRequestHeaders.c_str(), m_additionalRequestHeaders.size(), WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON))
|
||||
{
|
||||
m_dwLastError = ::GetLastError();
|
||||
}
|
||||
}
|
||||
if (m_additionalRequestCookies.size() > 0)
|
||||
{
|
||||
wstring cookies = L"Cookie: ";
|
||||
cookies += m_additionalRequestCookies;
|
||||
if (!::WinHttpAddRequestHeaders(hRequest, cookies.c_str(), cookies.size(), WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON))
|
||||
{
|
||||
m_dwLastError = ::GetLastError();
|
||||
}
|
||||
}
|
||||
if (m_proxy.size() > 0)
|
||||
{
|
||||
WINHTTP_PROXY_INFO proxyInfo;
|
||||
memset(&proxyInfo, 0, sizeof(proxyInfo));
|
||||
proxyInfo.dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
|
||||
wchar_t szProxy[MAX_PATH] = L"";
|
||||
wcscpy_s(szProxy, MAX_PATH, m_proxy.c_str());
|
||||
proxyInfo.lpszProxy = szProxy;
|
||||
|
||||
if (!::WinHttpSetOption(hRequest, WINHTTP_OPTION_PROXY, &proxyInfo, sizeof(proxyInfo)))
|
||||
{
|
||||
m_dwLastError = ::GetLastError();
|
||||
}
|
||||
|
||||
if (m_proxyUsername.size() > 0)
|
||||
{
|
||||
if (!::WinHttpSetOption(hRequest, WINHTTP_OPTION_PROXY_USERNAME, (LPVOID)m_proxyUsername.c_str(), m_proxyUsername.size() * sizeof(wchar_t)))
|
||||
{
|
||||
m_dwLastError = ::GetLastError();
|
||||
}
|
||||
if (m_proxyPassword.size() > 0)
|
||||
{
|
||||
if (!::WinHttpSetOption(hRequest, WINHTTP_OPTION_PROXY_PASSWORD, (LPVOID)m_proxyPassword.c_str(), m_proxyPassword.size() * sizeof(wchar_t)))
|
||||
{
|
||||
m_dwLastError = ::GetLastError();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (disableAutoRedirect)
|
||||
{
|
||||
DWORD dwDisableFeature = WINHTTP_DISABLE_REDIRECTS;
|
||||
if (!::WinHttpSetOption(hRequest, WINHTTP_OPTION_DISABLE_FEATURE, &dwDisableFeature, sizeof(dwDisableFeature)))
|
||||
{
|
||||
m_dwLastError = ::GetLastError();
|
||||
}
|
||||
}
|
||||
bool bSendRequestSucceed = false;
|
||||
if (::WinHttpSendRequest(hRequest,
|
||||
WINHTTP_NO_ADDITIONAL_HEADERS,
|
||||
0,
|
||||
WINHTTP_NO_REQUEST_DATA,
|
||||
0,
|
||||
0,
|
||||
NULL))
|
||||
{
|
||||
bSendRequestSucceed = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Query the proxy information from IE setting and set the proxy if any.
|
||||
WINHTTP_CURRENT_USER_IE_PROXY_CONFIG proxyConfig;
|
||||
memset(&proxyConfig, 0, sizeof(proxyConfig));
|
||||
if (::WinHttpGetIEProxyConfigForCurrentUser(&proxyConfig))
|
||||
{
|
||||
if (proxyConfig.lpszAutoConfigUrl != NULL)
|
||||
{
|
||||
WINHTTP_AUTOPROXY_OPTIONS autoProxyOptions;
|
||||
memset(&autoProxyOptions, 0, sizeof(autoProxyOptions));
|
||||
autoProxyOptions.dwFlags = WINHTTP_AUTOPROXY_AUTO_DETECT | WINHTTP_AUTOPROXY_CONFIG_URL;
|
||||
autoProxyOptions.dwAutoDetectFlags = WINHTTP_AUTO_DETECT_TYPE_DHCP;
|
||||
autoProxyOptions.lpszAutoConfigUrl = proxyConfig.lpszAutoConfigUrl;
|
||||
autoProxyOptions.fAutoLogonIfChallenged = TRUE;
|
||||
autoProxyOptions.dwReserved = 0;
|
||||
autoProxyOptions.lpvReserved = NULL;
|
||||
|
||||
WINHTTP_PROXY_INFO proxyInfo;
|
||||
memset(&proxyInfo, 0, sizeof(proxyInfo));
|
||||
|
||||
if (::WinHttpGetProxyForUrl(m_sessionHandle, m_requestURL.c_str(), &autoProxyOptions, &proxyInfo))
|
||||
{
|
||||
if (::WinHttpSetOption(hRequest, WINHTTP_OPTION_PROXY, &proxyInfo, sizeof(proxyInfo)))
|
||||
{
|
||||
if (::WinHttpSendRequest(hRequest,
|
||||
WINHTTP_NO_ADDITIONAL_HEADERS,
|
||||
0,
|
||||
WINHTTP_NO_REQUEST_DATA,
|
||||
0,
|
||||
0,
|
||||
NULL))
|
||||
{
|
||||
bSendRequestSucceed = true;
|
||||
}
|
||||
}
|
||||
if (proxyInfo.lpszProxy != NULL)
|
||||
{
|
||||
::GlobalFree(proxyInfo.lpszProxy);
|
||||
}
|
||||
if (proxyInfo.lpszProxyBypass != NULL)
|
||||
{
|
||||
::GlobalFree(proxyInfo.lpszProxyBypass);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_dwLastError = ::GetLastError();
|
||||
}
|
||||
}
|
||||
else if (proxyConfig.lpszProxy != NULL)
|
||||
{
|
||||
WINHTTP_PROXY_INFO proxyInfo;
|
||||
memset(&proxyInfo, 0, sizeof(proxyInfo));
|
||||
proxyInfo.dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
|
||||
wchar_t szProxy[MAX_PATH] = L"";
|
||||
wcscpy_s(szProxy, MAX_PATH, proxyConfig.lpszProxy);
|
||||
proxyInfo.lpszProxy = szProxy;
|
||||
|
||||
if (proxyConfig.lpszProxyBypass != NULL)
|
||||
{
|
||||
wchar_t szProxyBypass[MAX_PATH] = L"";
|
||||
wcscpy_s(szProxyBypass, MAX_PATH, proxyConfig.lpszProxyBypass);
|
||||
proxyInfo.lpszProxyBypass = szProxyBypass;
|
||||
}
|
||||
|
||||
if (!::WinHttpSetOption(hRequest, WINHTTP_OPTION_PROXY, &proxyInfo, sizeof(proxyInfo)))
|
||||
{
|
||||
m_dwLastError = ::GetLastError();
|
||||
}
|
||||
}
|
||||
|
||||
if (proxyConfig.lpszAutoConfigUrl != NULL)
|
||||
{
|
||||
::GlobalFree(proxyConfig.lpszAutoConfigUrl);
|
||||
}
|
||||
if (proxyConfig.lpszProxy != NULL)
|
||||
{
|
||||
::GlobalFree(proxyConfig.lpszProxy);
|
||||
}
|
||||
if (proxyConfig.lpszProxyBypass != NULL)
|
||||
{
|
||||
::GlobalFree(proxyConfig.lpszProxyBypass);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_dwLastError = ::GetLastError();
|
||||
}
|
||||
}
|
||||
if (bSendRequestSucceed)
|
||||
{
|
||||
if (m_pDataToSend != NULL)
|
||||
{
|
||||
DWORD dwWritten = 0;
|
||||
if (!::WinHttpWriteData(hRequest,
|
||||
m_pDataToSend,
|
||||
m_dataToSendSize,
|
||||
&dwWritten))
|
||||
{
|
||||
m_dwLastError = ::GetLastError();
|
||||
}
|
||||
}
|
||||
if (::WinHttpReceiveResponse(hRequest, NULL))
|
||||
{
|
||||
DWORD dwSize = 0;
|
||||
BOOL bResult = FALSE;
|
||||
bResult = ::WinHttpQueryHeaders(hRequest,
|
||||
WINHTTP_QUERY_RAW_HEADERS_CRLF,
|
||||
WINHTTP_HEADER_NAME_BY_INDEX,
|
||||
NULL,
|
||||
&dwSize,
|
||||
WINHTTP_NO_HEADER_INDEX);
|
||||
if (bResult || (!bResult && (::GetLastError() == ERROR_INSUFFICIENT_BUFFER)))
|
||||
{
|
||||
wchar_t *szHeader = new wchar_t[dwSize];
|
||||
if (szHeader != NULL)
|
||||
{
|
||||
memset(szHeader, 0, dwSize* sizeof(wchar_t));
|
||||
if (::WinHttpQueryHeaders(hRequest,
|
||||
WINHTTP_QUERY_RAW_HEADERS_CRLF,
|
||||
WINHTTP_HEADER_NAME_BY_INDEX,
|
||||
szHeader,
|
||||
&dwSize,
|
||||
WINHTTP_NO_HEADER_INDEX))
|
||||
{
|
||||
m_responseHeader.assign(szHeader);
|
||||
vector<wstring> result;
|
||||
wstring regExp = L"";
|
||||
if (!m_bForceCharset)
|
||||
{
|
||||
regExp = L"charset={[A-Za-z0-9\\-_]+}";
|
||||
if (ParseRegExp(regExp, false, 1, m_responseHeader, result) && result.size() > 0)
|
||||
{
|
||||
m_responseCharset = result[0];
|
||||
}
|
||||
}
|
||||
regExp = L"Content-Length: {[0-9]+}";
|
||||
if (ParseRegExp(regExp, false, 1, m_responseHeader, result) && result.size() > 0)
|
||||
{
|
||||
m_responseByteCount = (unsigned int)_wtoi(result[0].c_str());
|
||||
}
|
||||
regExp = L"Location: {[0-9]+}";
|
||||
if (ParseRegExp(regExp, false, 1, m_responseHeader, result) && result.size() > 0)
|
||||
{
|
||||
m_location = result[0];
|
||||
}
|
||||
regExp = L"Set-Cookie:\\b*{.+?}\\n";
|
||||
if (ParseRegExp(regExp, false, 1, m_responseHeader, result) && result.size() > 0)
|
||||
{
|
||||
for (vector<wstring>::size_type i = 0; i < result.size(); i++)
|
||||
{
|
||||
m_responseCookies += result[i];
|
||||
if (i != result.size() - 1)
|
||||
{
|
||||
m_responseCookies += L"; ";
|
||||
}
|
||||
}
|
||||
m_responseCookies = Trim(m_responseCookies, L" ");
|
||||
if (m_responseCookies.size() > 0 && m_responseCookies[m_responseCookies.size() - 1] != L';')
|
||||
{
|
||||
m_responseCookies += L";";
|
||||
}
|
||||
}
|
||||
}
|
||||
delete[] szHeader;
|
||||
}
|
||||
}
|
||||
|
||||
dwSize = 0;
|
||||
bResult = ::WinHttpQueryHeaders(hRequest,
|
||||
WINHTTP_QUERY_STATUS_CODE,
|
||||
WINHTTP_HEADER_NAME_BY_INDEX,
|
||||
NULL,
|
||||
&dwSize,
|
||||
WINHTTP_NO_HEADER_INDEX);
|
||||
if (bResult || (!bResult && (::GetLastError() == ERROR_INSUFFICIENT_BUFFER)))
|
||||
{
|
||||
wchar_t *szStatusCode = new wchar_t[dwSize];
|
||||
if (szStatusCode != NULL)
|
||||
{
|
||||
memset(szStatusCode, 0, dwSize* sizeof(wchar_t));
|
||||
if (::WinHttpQueryHeaders(hRequest,
|
||||
WINHTTP_QUERY_STATUS_CODE,
|
||||
WINHTTP_HEADER_NAME_BY_INDEX,
|
||||
szStatusCode,
|
||||
&dwSize,
|
||||
WINHTTP_NO_HEADER_INDEX))
|
||||
{
|
||||
m_statusCode = szStatusCode;
|
||||
}
|
||||
delete[] szStatusCode;
|
||||
}
|
||||
}
|
||||
|
||||
unsigned int iMaxBufferSize = INT_BUFFERSIZE;
|
||||
unsigned int iCurrentBufferSize = 0;
|
||||
if (m_pResponse != NULL)
|
||||
{
|
||||
delete[] m_pResponse;
|
||||
m_pResponse = NULL;
|
||||
}
|
||||
m_pResponse = new BYTE[iMaxBufferSize];
|
||||
if (m_pResponse == NULL)
|
||||
{
|
||||
bRetVal = false;
|
||||
break;
|
||||
}
|
||||
memset(m_pResponse, 0, iMaxBufferSize);
|
||||
do
|
||||
{
|
||||
dwSize = 0;
|
||||
if (::WinHttpQueryDataAvailable(hRequest, &dwSize))
|
||||
{
|
||||
SetProgress(iCurrentBufferSize);
|
||||
BYTE *pResponse = new BYTE[dwSize + 1];
|
||||
if (pResponse != NULL)
|
||||
{
|
||||
memset(pResponse, 0, (dwSize + 1)*sizeof(BYTE));
|
||||
DWORD dwRead = 0;
|
||||
if (::WinHttpReadData(hRequest,
|
||||
pResponse,
|
||||
dwSize,
|
||||
&dwRead))
|
||||
{
|
||||
if (dwRead + iCurrentBufferSize > iMaxBufferSize)
|
||||
{
|
||||
BYTE *pOldBuffer = m_pResponse;
|
||||
m_pResponse = new BYTE[iMaxBufferSize * 2];
|
||||
if (m_pResponse == NULL)
|
||||
{
|
||||
m_pResponse = pOldBuffer;
|
||||
bRetVal = false;
|
||||
break;
|
||||
}
|
||||
iMaxBufferSize *= 2;
|
||||
memset(m_pResponse, 0, iMaxBufferSize);
|
||||
memcpy(m_pResponse, pOldBuffer, iCurrentBufferSize);
|
||||
delete[] pOldBuffer;
|
||||
}
|
||||
memcpy(m_pResponse + iCurrentBufferSize, pResponse, dwRead);
|
||||
iCurrentBufferSize += dwRead;
|
||||
}
|
||||
delete[] pResponse;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_dwLastError = ::GetLastError();
|
||||
}
|
||||
}
|
||||
while (dwSize > 0);
|
||||
SetProgress(iCurrentBufferSize);
|
||||
m_responseByteCountReceived = iCurrentBufferSize;
|
||||
|
||||
UINT codePage = CP_ACP;
|
||||
DWORD dwFlag = MB_PRECOMPOSED;
|
||||
if (_wcsnicmp(m_responseCharset.c_str(), L"utf-8", 5) == 0)
|
||||
{
|
||||
codePage = CP_UTF8;
|
||||
dwFlag = 0;
|
||||
}
|
||||
int iLength = ::MultiByteToWideChar(codePage,
|
||||
dwFlag,
|
||||
(LPCSTR)m_pResponse,
|
||||
m_responseByteCountReceived + 1,
|
||||
NULL,
|
||||
0);
|
||||
if (iLength <= 0)
|
||||
{
|
||||
// Use CP_ACP if UTF-8 fail
|
||||
codePage = CP_ACP;
|
||||
dwFlag = MB_PRECOMPOSED;
|
||||
iLength = ::MultiByteToWideChar(codePage,
|
||||
dwFlag,
|
||||
(LPCSTR)m_pResponse,
|
||||
m_responseByteCountReceived + 1,
|
||||
NULL,
|
||||
0);
|
||||
}
|
||||
if (iLength > 0)
|
||||
{
|
||||
wchar_t *wideChar = new wchar_t[iLength];
|
||||
if (wideChar != NULL)
|
||||
{
|
||||
memset(wideChar, 0, iLength * sizeof(wchar_t));
|
||||
iLength = ::MultiByteToWideChar(codePage,
|
||||
dwFlag,
|
||||
(LPCSTR)m_pResponse,
|
||||
m_responseByteCountReceived + 1,
|
||||
wideChar,
|
||||
iLength);
|
||||
if (iLength > 0)
|
||||
{
|
||||
m_responseContent = wideChar;
|
||||
}
|
||||
delete[] wideChar;
|
||||
}
|
||||
}
|
||||
bGetReponseSucceed = true;
|
||||
|
||||
// If the resposne html web page size is less than 200, retry.
|
||||
if (verb == L"GET" && !disableAutoRedirect)
|
||||
{
|
||||
wstring regExp = L"{<html>}";
|
||||
vector<wstring> result;
|
||||
if (ParseRegExp(regExp, false, 1, m_responseContent, result) && result.size() > 0)
|
||||
{
|
||||
regExp = L"{</html>}";
|
||||
if (!ParseRegExp(regExp, false, 1, m_responseContent, result) || result.size() <= 0)
|
||||
{
|
||||
m_dwLastError = ERROR_INVALID_DATA;
|
||||
bGetReponseSucceed = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_dwLastError = ::GetLastError();
|
||||
}
|
||||
}
|
||||
} // while
|
||||
if (!bGetReponseSucceed)
|
||||
{
|
||||
bRetVal = false;
|
||||
}
|
||||
|
||||
::WinHttpCloseHandle(hRequest);
|
||||
}
|
||||
::WinHttpCloseHandle(hConnect);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return bRetVal;
|
||||
}
|
||||
|
||||
wstring WinHttpClient::GetResponseHeader(void)
|
||||
{
|
||||
return m_responseHeader;
|
||||
}
|
||||
|
||||
wstring WinHttpClient::GetResponseContent(void)
|
||||
{
|
||||
return m_responseContent;
|
||||
}
|
||||
|
||||
wstring WinHttpClient::GetResponseCharset(void)
|
||||
{
|
||||
return m_responseCharset;
|
||||
}
|
||||
|
||||
wstring WinHttpClient::GetRequestHost(void)
|
||||
{
|
||||
return m_requestHost;
|
||||
}
|
||||
|
||||
bool WinHttpClient::SaveResponseToFile(const wstring &filePath)
|
||||
{
|
||||
if (m_pResponse == NULL || m_responseByteCountReceived <= 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
FILE *f = NULL;
|
||||
int iResult = _wfopen_s(&f, filePath.c_str(), L"wb");
|
||||
if (iResult == 0 && f != NULL)
|
||||
{
|
||||
fwrite(m_pResponse, m_responseByteCountReceived, 1, f);
|
||||
fclose(f);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool WinHttpClient::SetProgress(unsigned int byteCountReceived)
|
||||
{
|
||||
bool bReturn = false;
|
||||
if (m_pfProcessProc != NULL && m_responseByteCount > 0)
|
||||
{
|
||||
double dProgress = (double)byteCountReceived * 100 / m_responseByteCount;
|
||||
m_pfProcessProc(dProgress);
|
||||
bReturn = true;
|
||||
}
|
||||
|
||||
return bReturn;
|
||||
}
|
||||
|
||||
wstring WinHttpClient::GetResponseCookies(void)
|
||||
{
|
||||
return m_responseCookies;
|
||||
}
|
||||
|
||||
bool WinHttpClient::SetAdditionalRequestCookies(const wstring &cookies)
|
||||
{
|
||||
m_additionalRequestCookies = cookies;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool WinHttpClient::SetAdditionalDataToSend(BYTE *data, unsigned int dataSize)
|
||||
{
|
||||
if (data == NULL || dataSize < 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (m_pDataToSend != NULL)
|
||||
{
|
||||
delete[] m_pDataToSend;
|
||||
}
|
||||
m_pDataToSend = NULL;
|
||||
m_pDataToSend = new BYTE[dataSize];
|
||||
if (m_pDataToSend != NULL)
|
||||
{
|
||||
memcpy(m_pDataToSend, data, dataSize);
|
||||
m_dataToSendSize = dataSize;
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// Reset additional data fields
|
||||
bool WinHttpClient::ResetAdditionalDataToSend(void)
|
||||
{
|
||||
if (m_pDataToSend != NULL)
|
||||
{
|
||||
delete[] m_pDataToSend;
|
||||
}
|
||||
|
||||
m_pDataToSend = NULL;
|
||||
m_dataToSendSize = 0;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// Allow us to reset the url on subsequent requests
|
||||
bool WinHttpClient::UpdateUrl(const wstring &url)
|
||||
{
|
||||
m_requestURL = url;
|
||||
ResetAdditionalDataToSend();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool WinHttpClient::SetAdditionalRequestHeaders(const wstring &additionalRequestHeaders)
|
||||
{
|
||||
m_additionalRequestHeaders = additionalRequestHeaders;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool WinHttpClient::SetProxy(const wstring &proxy)
|
||||
{
|
||||
m_proxy = proxy;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// If we don't require valid SSL Certs then accept any
|
||||
// certificate on an SSL connection
|
||||
bool WinHttpClient::SetRequireValidSslCertificates(bool require)
|
||||
{
|
||||
m_requireValidSsl = require;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
const BYTE *WinHttpClient::GetRawResponseContent(void)
|
||||
{
|
||||
return m_pResponse;
|
||||
}
|
||||
|
||||
unsigned int WinHttpClient::GetRawResponseContentLength(void)
|
||||
{
|
||||
return m_responseByteCount;
|
||||
}
|
||||
|
||||
unsigned int WinHttpClient::GetRawResponseReceivedContentLength(void)
|
||||
{
|
||||
return m_responseByteCountReceived;
|
||||
}
|
||||
|
||||
DWORD WinHttpClient::GetLastError(void)
|
||||
{
|
||||
return m_dwLastError;
|
||||
}
|
||||
|
||||
wstring WinHttpClient::GetResponseStatusCode(void)
|
||||
{
|
||||
return m_statusCode;
|
||||
}
|
||||
|
||||
bool WinHttpClient::SetUserAgent(const wstring &userAgent)
|
||||
{
|
||||
m_userAgent = userAgent;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool WinHttpClient::SetForceCharset(const wstring &charset)
|
||||
{
|
||||
m_responseCharset = charset;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool WinHttpClient::SetProxyUsername(const wstring &username)
|
||||
{
|
||||
m_proxyUsername = username;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool WinHttpClient::SetProxyPassword(const std::wstring &password)
|
||||
{
|
||||
m_proxyPassword = password;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
wstring WinHttpClient::GetResponseLocation(void)
|
||||
{
|
||||
return m_location;
|
||||
}
|
||||
|
||||
bool WinHttpClient::SetTimeouts(unsigned int resolveTimeout,
|
||||
unsigned int connectTimeout,
|
||||
unsigned int sendTimeout,
|
||||
unsigned int receiveTimeout)
|
||||
{
|
||||
m_resolveTimeout = resolveTimeout;
|
||||
m_connectTimeout = connectTimeout;
|
||||
m_sendTimeout = sendTimeout;
|
||||
m_receiveTimeout = receiveTimeout;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif // WINHTTPCLIENT_H
|
||||
Reference in new issue
Block a user