944 lines
22 KiB
C++
944 lines
22 KiB
C++
/*****************************************************************************\
|
|
* MODULE: inetwrap.c
|
|
*
|
|
* This module contains wrapper routines to translate internet calls from
|
|
* Unicode to Ansi. This is necessary right now since the WININET routines
|
|
* do not support Unicode for Windows NT.
|
|
*
|
|
*
|
|
* Copyright (C) 1996-1997 Microsoft Corporation
|
|
* Copyright (C) 1996-1997 Hewlett Packard
|
|
*
|
|
* History:
|
|
* 07-Oct-1996 HWP-Guys Initiated port from win95 to winNT
|
|
* 15-Jul-1998 v-chrisw Allow safe DelayLoad of wininet.
|
|
*
|
|
\*****************************************************************************/
|
|
|
|
#include "precomp.h"
|
|
#include "priv.h"
|
|
|
|
/*****************************************************************************\
|
|
* wrapInternetOpen
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
HINTERNET wrapInternetOpen(
|
|
LPCTSTR lpszAgent,
|
|
DWORD dwAccess,
|
|
LPCTSTR lpszProxyName,
|
|
LPCTSTR lpszProxyBypass,
|
|
DWORD dwFlags)
|
|
{
|
|
HINTERNET hRet = NULL;
|
|
|
|
#ifdef UNICODE
|
|
|
|
UINT uSize;
|
|
LPSTR lpszAnsiAgent = NULL;
|
|
LPSTR lpszAnsiProxyName = NULL;
|
|
LPSTR lpszAnsiProxyBypass = NULL;
|
|
BOOL bRet = TRUE;
|
|
|
|
|
|
if (lpszAgent && (uSize = WCtoMB(lpszAgent, NULL, 0))) {
|
|
|
|
if (lpszAnsiAgent = new CHAR[uSize])
|
|
bRet = WCtoMB(lpszAgent, lpszAnsiAgent, uSize);
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
|
|
|
|
if (bRet && lpszProxyName && (uSize = WCtoMB(lpszProxyName, NULL, 0))) {
|
|
|
|
if (lpszAnsiProxyName = new CHAR[uSize])
|
|
bRet = WCtoMB(lpszProxyName, lpszAnsiProxyName, uSize);
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet && lpszProxyBypass && (uSize = WCtoMB(lpszProxyBypass, NULL, 0))) {
|
|
|
|
if (lpszAnsiProxyBypass = new CHAR[uSize])
|
|
bRet = WCtoMB(lpszProxyBypass, lpszAnsiProxyBypass, uSize);
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet) {
|
|
|
|
__try {
|
|
|
|
hRet = g_pfnInternetOpen((LPCTSTR)lpszAnsiAgent,
|
|
dwAccess,
|
|
(LPCTSTR)lpszAnsiProxyName,
|
|
(LPCTSTR)lpszAnsiProxyBypass,
|
|
dwFlags);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : InternetOpen exception!")));
|
|
|
|
hRet = NULL;
|
|
}
|
|
}
|
|
|
|
if (lpszAnsiAgent)
|
|
delete [](lpszAnsiAgent);
|
|
|
|
if (lpszAnsiProxyName)
|
|
delete [](lpszAnsiProxyName);
|
|
|
|
if (lpszAnsiProxyBypass)
|
|
delete [](lpszAnsiProxyBypass);
|
|
|
|
#else
|
|
|
|
__try {
|
|
|
|
hRet = g_pfnInternetOpen(lpszAgent,
|
|
dwAccess,
|
|
lpszProxyName,
|
|
lpszProxyBypass,
|
|
dwFlags);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : InternetOpen exception!")));
|
|
|
|
hRet = NULL;
|
|
}
|
|
|
|
#endif
|
|
|
|
return hRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* wrapInternetOpenUrl
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
HINTERNET wrapInternetOpenUrl(
|
|
HINTERNET hInternet,
|
|
LPCTSTR lpszUrl,
|
|
LPCTSTR lpszHeaders,
|
|
DWORD dwHeaderLen,
|
|
DWORD dwFlags,
|
|
DWORD_PTR dwContext)
|
|
{
|
|
HINTERNET hRet = NULL;
|
|
|
|
#ifdef UNICODE
|
|
|
|
UINT uSize;
|
|
LPSTR lpszAnsiUrl = NULL;
|
|
LPSTR lpszAnsiHeaders = NULL;
|
|
BOOL bRet = TRUE;
|
|
|
|
|
|
if (lpszUrl && (uSize = WCtoMB(lpszUrl, NULL, 0))) {
|
|
|
|
if (lpszAnsiUrl = new CHAR[uSize])
|
|
bRet = WCtoMB(lpszUrl, lpszAnsiUrl, uSize);
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet && lpszHeaders && (uSize = WCtoMB(lpszHeaders, NULL, 0))) {
|
|
|
|
if (lpszAnsiHeaders = new CHAR[uSize])
|
|
bRet = WCtoMB(lpszHeaders, lpszAnsiHeaders, uSize);
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet) {
|
|
|
|
__try {
|
|
|
|
hRet = g_pfnInternetOpenUrl(hInternet,
|
|
(LPCTSTR)lpszAnsiUrl,
|
|
(LPCTSTR)lpszAnsiHeaders,
|
|
dwHeaderLen,
|
|
dwFlags,
|
|
dwContext);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : InternetOpenUrl exception!")));
|
|
|
|
hRet = NULL;
|
|
}
|
|
}
|
|
|
|
if (lpszAnsiUrl)
|
|
delete [](lpszAnsiUrl);
|
|
|
|
if (lpszAnsiHeaders)
|
|
delete [](lpszAnsiHeaders);
|
|
|
|
#else
|
|
|
|
__try {
|
|
|
|
hRet = g_pfnInternetOpenUrl(hInternet,
|
|
lpszUrl,
|
|
lpszHeaders,
|
|
dwHeaderLen,
|
|
dwFlags,
|
|
dwContext);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : InternetOpenUrl exception!")));
|
|
|
|
hRet = NULL;
|
|
}
|
|
|
|
#endif
|
|
|
|
return hRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* wrapInternetConnect
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
HINTERNET wrapInternetConnect(
|
|
HINTERNET hSession,
|
|
LPCTSTR lpszServerName,
|
|
INTERNET_PORT nServerPort,
|
|
LPCTSTR lpszUserName,
|
|
LPCTSTR lpszPassword,
|
|
DWORD dwService,
|
|
DWORD dwFlags,
|
|
DWORD_PTR dwContext)
|
|
{
|
|
HINTERNET hRet = NULL;
|
|
|
|
#ifdef UNICODE
|
|
|
|
UINT uSize;
|
|
LPSTR lpszAnsiServerName = NULL;
|
|
LPSTR lpszAnsiUserName = NULL;
|
|
LPSTR lpszAnsiPassword = NULL;
|
|
BOOL bRet = TRUE;
|
|
|
|
|
|
if (lpszServerName && (uSize = WCtoMB(lpszServerName, NULL, 0))) {
|
|
|
|
if (lpszAnsiServerName = new CHAR[uSize])
|
|
bRet = WCtoMB(lpszServerName, lpszAnsiServerName, uSize);
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet && lpszUserName && (uSize = WCtoMB(lpszUserName, NULL, 0))) {
|
|
|
|
if (lpszAnsiUserName = new CHAR[uSize])
|
|
bRet = WCtoMB(lpszUserName, lpszAnsiUserName, uSize);
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet && lpszPassword && (uSize = WCtoMB(lpszPassword, NULL, 0))) {
|
|
|
|
if (lpszAnsiPassword = new CHAR[uSize])
|
|
bRet = WCtoMB(lpszPassword, lpszAnsiPassword, uSize);
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet) {
|
|
|
|
__try {
|
|
|
|
hRet = g_pfnInternetConnect(hSession,
|
|
(LPCTSTR)lpszAnsiServerName,
|
|
nServerPort,
|
|
(LPCTSTR)lpszAnsiUserName,
|
|
(LPCTSTR)lpszAnsiPassword,
|
|
dwService,
|
|
dwFlags,
|
|
dwContext);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : InternetConnect exception!")));
|
|
|
|
hRet = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
if (lpszAnsiServerName)
|
|
delete [](lpszAnsiServerName);
|
|
|
|
if (lpszAnsiUserName)
|
|
delete [](lpszAnsiUserName);
|
|
|
|
if (lpszAnsiPassword)
|
|
delete [](lpszAnsiPassword);
|
|
|
|
#else
|
|
|
|
__try {
|
|
|
|
hRet = g_pfnInternetConnect(hSession,
|
|
lpszServerName,
|
|
nServerPort,
|
|
lpszUserName,
|
|
lpszPassword,
|
|
dwService,
|
|
dwFlags,
|
|
dwContext);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : InternetConnect exception!")));
|
|
|
|
hRet = NULL;
|
|
}
|
|
|
|
#endif
|
|
|
|
return hRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* wrapHttpQueryInfo
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL wrapHttpQueryInfo(
|
|
HINTERNET hRequest,
|
|
DWORD dwInfoLevel,
|
|
LPVOID lpvBuffer,
|
|
LPDWORD lpdwBufferLen,
|
|
LPDWORD lpdwIndex)
|
|
{
|
|
BOOL bRet;
|
|
|
|
|
|
__try {
|
|
|
|
bRet = g_pfnHttpQueryInfo(hRequest,
|
|
dwInfoLevel,
|
|
lpvBuffer,
|
|
lpdwBufferLen,
|
|
lpdwIndex);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : HttpQueryInfo exception!")));
|
|
|
|
bRet = FALSE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* wrapHttpSendRequest
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL wrapHttpSendRequest(
|
|
HINTERNET hRequest,
|
|
LPCTSTR lpszHeaders,
|
|
DWORD dwHeaderLen,
|
|
LPVOID lpvOptional,
|
|
DWORD dwOptionalLen)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
|
|
#ifdef UNICODE
|
|
|
|
UINT uSize;
|
|
LPSTR lpszAnsiHeaders = NULL;
|
|
|
|
|
|
if (lpszHeaders && (uSize = WCtoMB(lpszHeaders, NULL, 0))) {
|
|
|
|
if (lpszAnsiHeaders = new CHAR[uSize])
|
|
bRet = WCtoMB(lpszHeaders, lpszAnsiHeaders, uSize);
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet) {
|
|
|
|
__try {
|
|
|
|
bRet = g_pfnHttpSendRequest(hRequest,
|
|
(LPCTSTR)lpszAnsiHeaders,
|
|
dwHeaderLen,
|
|
lpvOptional,
|
|
dwOptionalLen);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : HttpSendRequest exception!")));
|
|
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
|
|
if (lpszAnsiHeaders)
|
|
delete [](lpszAnsiHeaders);
|
|
|
|
#else
|
|
|
|
__try {
|
|
|
|
bRet = g_pfnHttpSendRequest(hRequest,
|
|
lpszHeaders,
|
|
dwHeaderLen,
|
|
lpvOptional,
|
|
dwOptionalLen);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : HttpSendRequest exception!")));
|
|
|
|
bRet = FALSE;
|
|
}
|
|
|
|
#endif
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* wrapHttpSendRequestEx
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL wrapHttpSendRequestEx(
|
|
HINTERNET hRequest,
|
|
LPINTERNET_BUFFERS lpBufIn,
|
|
LPINTERNET_BUFFERS lpBufOut,
|
|
DWORD dwFlags,
|
|
DWORD_PTR dwContext)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
|
|
|
|
// NOTE : This now works for Header values defined in lpBufIn and lpBufOut, we assume that
|
|
// the "size" of the header in the structure is not set by the calling routine, if it is we
|
|
// overwrite the size when we convert it....
|
|
//
|
|
// NOTE2: We do not support linked Buffer Strucures, only 1!!!!!
|
|
// NOTE3: We do not support lpBufOut to return values. It must be NULL
|
|
|
|
#ifdef UNICODE
|
|
UINT uSize = 0;
|
|
LPSTR lpszAnsiHeaders = NULL;
|
|
LPCWSTR lpcszHeader;
|
|
INTERNET_BUFFERSA ConvertBuf;
|
|
|
|
DBG_ASSERT((lpBufOut == NULL) , (TEXT("inetwrap : We do not support output buffers!")));
|
|
DBG_ASSERT((lpBufIn->Next == NULL) , (TEXT("inetwrap : We do not support chained input buffers!")));
|
|
|
|
lpcszHeader = lpBufIn->lpcszHeader;
|
|
|
|
if (lpcszHeader && (uSize = WCtoMB(lpcszHeader, NULL, 0))) {
|
|
if (lpszAnsiHeaders = new CHAR[uSize])
|
|
bRet = WCtoMB(lpcszHeader, lpszAnsiHeaders, uSize--);
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet) {
|
|
ConvertBuf.dwStructSize = sizeof(ConvertBuf);
|
|
ConvertBuf.Next = NULL;
|
|
ConvertBuf.lpcszHeader = lpszAnsiHeaders;
|
|
ConvertBuf.dwHeadersLength = (DWORD)uSize;
|
|
ConvertBuf.dwHeadersTotal = lpBufIn->dwHeadersTotal;
|
|
ConvertBuf.lpvBuffer = lpBufIn->lpvBuffer;
|
|
ConvertBuf.dwBufferLength = lpBufIn->dwBufferLength;
|
|
ConvertBuf.dwBufferTotal = lpBufIn->dwBufferTotal;
|
|
ConvertBuf.dwOffsetLow = lpBufIn->dwOffsetLow;
|
|
ConvertBuf.dwOffsetHigh = lpBufIn->dwOffsetHigh;
|
|
|
|
__try {
|
|
|
|
bRet = g_pfnHttpSendRequestEx(hRequest,
|
|
&ConvertBuf,
|
|
lpBufOut,
|
|
dwFlags,
|
|
dwContext);
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : HttpSendRequestEx exception!")));
|
|
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
|
|
if (lpszAnsiHeaders)
|
|
delete [](lpszAnsiHeaders);
|
|
|
|
#else
|
|
__try {
|
|
|
|
bRet = g_pfnHttpSendRequestEx(hRequest,
|
|
lpBufIn,
|
|
lpBufOut,
|
|
dwFlags,
|
|
dwContext);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : HttpSendRequestEx exception!")));
|
|
|
|
bRet = FALSE;
|
|
}
|
|
#endif
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* wrapHttpOpenRequest
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
HINTERNET wrapHttpOpenRequest(
|
|
HINTERNET hConnect,
|
|
LPCTSTR lpszVerb,
|
|
LPCTSTR lpszObjectName,
|
|
LPCTSTR lpszVersion,
|
|
LPCTSTR lpszReferer,
|
|
LPCTSTR *lplpszAccept,
|
|
DWORD dwFlags,
|
|
DWORD_PTR dwContext)
|
|
{
|
|
HINTERNET hRet = NULL;
|
|
|
|
#ifdef UNICODE
|
|
|
|
UINT uSize;
|
|
LPSTR lpszAnsiVerb = NULL;
|
|
LPSTR lpszAnsiObjectName = NULL;
|
|
LPSTR lpszAnsiVersion = NULL;
|
|
LPSTR lpszAnsiReferer = NULL;
|
|
BOOL bRet = TRUE;
|
|
|
|
|
|
if (lpszVerb && (uSize = WCtoMB(lpszVerb, NULL, 0))) {
|
|
|
|
if (lpszAnsiVerb = new CHAR[uSize])
|
|
bRet = WCtoMB(lpszVerb, lpszAnsiVerb, uSize);
|
|
}
|
|
|
|
if (bRet && lpszObjectName && (uSize = WCtoMB(lpszObjectName, NULL, 0))) {
|
|
|
|
if (lpszAnsiObjectName = new CHAR[uSize])
|
|
bRet = WCtoMB(lpszObjectName, lpszAnsiObjectName, uSize);
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet && lpszVersion && (uSize = WCtoMB(lpszVersion, NULL, 0))) {
|
|
|
|
if (lpszAnsiVersion = new CHAR[uSize])
|
|
bRet = WCtoMB(lpszVersion, lpszAnsiVersion, uSize);
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet && lpszReferer && (uSize = WCtoMB(lpszReferer, NULL, 0))) {
|
|
|
|
if (lpszAnsiReferer = new CHAR[uSize])
|
|
bRet = WCtoMB(lpszReferer, lpszAnsiReferer, uSize);
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet) {
|
|
|
|
__try {
|
|
|
|
hRet = g_pfnHttpOpenRequest(hConnect,
|
|
(LPCTSTR)lpszAnsiVerb,
|
|
(LPCTSTR)lpszAnsiObjectName,
|
|
(LPCTSTR)lpszAnsiVersion,
|
|
(LPCTSTR)lpszAnsiReferer,
|
|
(LPCTSTR *)lplpszAccept,
|
|
dwFlags,
|
|
dwContext);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : HttpOpenRequest exception!")));
|
|
|
|
hRet = NULL;
|
|
}
|
|
}
|
|
|
|
if (lpszAnsiVerb)
|
|
delete [](lpszAnsiVerb);
|
|
|
|
if (lpszAnsiObjectName)
|
|
delete [](lpszAnsiObjectName);
|
|
|
|
if (lpszAnsiVersion)
|
|
delete [](lpszAnsiVersion);
|
|
|
|
if (lpszAnsiReferer)
|
|
delete [](lpszAnsiReferer);
|
|
|
|
#else
|
|
|
|
|
|
__try {
|
|
|
|
hRet = g_pfnHttpOpenRequest(hConnect,
|
|
lpszVerb,
|
|
lpszObjectName,
|
|
lpszVersion,
|
|
lpszReferer,
|
|
lplpszAccept,
|
|
dwFlags,
|
|
dwContext);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : HttpOpenRequest exception!")));
|
|
|
|
hRet = NULL;
|
|
}
|
|
|
|
#endif
|
|
|
|
return hRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* wrapHttpAddRequestHeaders
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL wrapHttpAddRequestHeaders(
|
|
HINTERNET hRequest,
|
|
LPCTSTR lpszHeaders,
|
|
DWORD cbLength,
|
|
DWORD dwModifiers)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
|
|
#ifdef UNICODE
|
|
|
|
UINT uSize;
|
|
LPSTR lpszAnsiHeaders = NULL;
|
|
|
|
|
|
if (lpszHeaders && (uSize = WCtoMB(lpszHeaders, NULL, 0))) {
|
|
|
|
if (lpszAnsiHeaders = new CHAR[uSize])
|
|
WCtoMB(lpszHeaders, lpszAnsiHeaders, uSize);
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet) {
|
|
|
|
__try {
|
|
|
|
bRet = g_pfnHttpAddRequestHeaders(hRequest,
|
|
(LPCTSTR)lpszAnsiHeaders,
|
|
cbLength,
|
|
dwModifiers);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : HttpAddRequestHeaders exception!")));
|
|
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
|
|
if (lpszAnsiHeaders)
|
|
delete [](lpszAnsiHeaders);
|
|
|
|
#else
|
|
|
|
__try {
|
|
|
|
bRet = g_pfnHttpAddRequestHeaders(hRequest,
|
|
lpszHeaders,
|
|
cbLength,
|
|
dwModifiers);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : HttpAdRequestHeaders exception!")));
|
|
|
|
bRet = FALSE;
|
|
}
|
|
|
|
#endif
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* wrapHttpEndRequest
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL wrapHttpEndRequest(
|
|
HINTERNET hRequest,
|
|
LPINTERNET_BUFFERS lpBuf,
|
|
DWORD dwFlags,
|
|
DWORD_PTR dwContext)
|
|
{
|
|
BOOL bRet;
|
|
|
|
|
|
__try {
|
|
|
|
#ifdef UNICODE
|
|
|
|
DBG_ASSERT((lpBuf == NULL), (TEXT("Assert: NULL Buffer is only support")));
|
|
|
|
bRet = g_pfnHttpEndRequest(hRequest, lpBuf, dwFlags, dwContext);
|
|
|
|
#else
|
|
|
|
bRet = g_pfnHttpEndRequest(hRequest, lpBuf, dwFlags, dwContext);
|
|
|
|
#endif
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : HttpOpenRequest exception!")));
|
|
|
|
bRet = FALSE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* wrapInternetSetOption
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL wrapInternetSetOption(
|
|
HINTERNET hRequest,
|
|
IN DWORD dwOption,
|
|
IN LPVOID lpBuffer,
|
|
IN DWORD dwBufferLength)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
|
|
#ifdef UNICODE
|
|
|
|
UINT uSize;
|
|
LPSTR lpszAnsiBuffer = NULL;
|
|
|
|
|
|
switch (dwOption) {
|
|
|
|
case INTERNET_OPTION_USERNAME:
|
|
case INTERNET_OPTION_PASSWORD:
|
|
case INTERNET_OPTION_PROXY_USERNAME:
|
|
case INTERNET_OPTION_PROXY_PASSWORD:
|
|
|
|
if (lpBuffer && (uSize = WCtoMB(lpBuffer, NULL, 0))) {
|
|
|
|
if (lpszAnsiBuffer = new CHAR[uSize])
|
|
bRet = WCtoMB(lpBuffer, lpszAnsiBuffer, uSize);
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
|
|
if (bRet) {
|
|
|
|
__try {
|
|
|
|
bRet = g_pfnInternetSetOption(hRequest,
|
|
dwOption,
|
|
lpszAnsiBuffer,
|
|
dwBufferLength);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : InternetSetOption exception!")));
|
|
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
|
|
if (lpszAnsiBuffer)
|
|
delete [](lpszAnsiBuffer);
|
|
break;
|
|
|
|
default:
|
|
|
|
__try {
|
|
|
|
bRet = g_pfnInternetSetOption(hRequest,
|
|
dwOption,
|
|
lpBuffer,
|
|
dwBufferLength);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : InternetSetOption exception!")));
|
|
|
|
bRet = FALSE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
#else
|
|
|
|
__try {
|
|
|
|
bRet = g_pfnInternetSetOption(hRequest,
|
|
dwOption,
|
|
lpBuffer,
|
|
dwBufferLength);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : InternetSetOption exception!")));
|
|
|
|
bRet = FALSE;
|
|
}
|
|
|
|
#endif
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************\
|
|
* wrapInternetCloseHandle
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL wrapInternetCloseHandle(
|
|
HINTERNET hHandle)
|
|
{
|
|
BOOL bRet;
|
|
|
|
|
|
__try {
|
|
|
|
bRet = g_pfnInternetCloseHandle(hHandle);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : InternetCloseHandle exception!")));
|
|
|
|
bRet = FALSE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* wrapInternetReadFile
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL wrapInternetReadFile(
|
|
HINTERNET hReq,
|
|
LPVOID lpvBuffer,
|
|
DWORD cbBuffer,
|
|
LPDWORD lpcbRd)
|
|
{
|
|
BOOL bRet;
|
|
|
|
|
|
__try {
|
|
|
|
bRet = g_pfnInternetReadFile(hReq, lpvBuffer, cbBuffer, lpcbRd);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : InternetReadFile exception!")));
|
|
|
|
bRet = FALSE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* wrapInternetWriteFile
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL wrapInternetWriteFile(
|
|
HINTERNET hReq,
|
|
LPVOID lpvBuffer,
|
|
DWORD cbBuffer,
|
|
LPDWORD lpcbWr)
|
|
{
|
|
BOOL bRet;
|
|
|
|
|
|
__try {
|
|
|
|
bRet = g_pfnInternetWriteFile(hReq, lpvBuffer, cbBuffer, lpcbWr);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : InternetWriteFile exception!")));
|
|
|
|
bRet = FALSE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* wrapInternetErrorDlg
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
DWORD wrapInternetErrorDlg(
|
|
HWND hWnd,
|
|
HINTERNET hReq,
|
|
DWORD dwError,
|
|
DWORD dwFlags,
|
|
LPVOID pvParam)
|
|
{
|
|
DWORD dwRet;
|
|
|
|
|
|
__try {
|
|
|
|
dwRet = g_pfnInternetErrorDlg(hWnd, hReq, dwError, dwFlags, pvParam);
|
|
|
|
} __except(1) {
|
|
|
|
DBG_ASSERT(FALSE, (TEXT("inetwrap : InternetErrorDlg exception!")));
|
|
|
|
dwRet = 0;
|
|
}
|
|
|
|
return dwRet;
|
|
}
|