4905 lines
122 KiB
C++
4905 lines
122 KiB
C++
/*++
|
|
|
|
Copyright (c) 1996 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
autoprox.cxx
|
|
|
|
Abstract:
|
|
|
|
Contains class implementation for auto-proxy DLLs which can extent WININET's
|
|
abilities (logic) for deciding what proxies to use.
|
|
|
|
How auto-proxy works:
|
|
By offloading requests to a specialized Win32 Thread which picks
|
|
up queued up message requests for Queries, Shutdown, and Initialization
|
|
|
|
|
|
Contents:
|
|
InternetInitializeAutoProxyDll
|
|
AUTO_PROXY_DLLS::CheckForTimerConfigChanges
|
|
AUTO_PROXY_DLLS::DoNestedProxyInfoDownload
|
|
AUTO_PROXY_DLLS::SelectAutoProxyByMime
|
|
AUTO_PROXY_DLLS::SelectAutoProxyByFileExtension
|
|
AUTO_PROXY_DLLS::SelectAutoProxyByDefault
|
|
AUTO_PROXY_DLLS::ReadAutoProxyRegistrySettings
|
|
AUTO_PROXY_DLLS::IsAutoProxyEnabled
|
|
AUTO_PROXY_DLLS::IsAutoProxyGetProxyInfoCallNeeded
|
|
AUTO_PROXY_DLLS::QueueAsyncAutoProxyRequest
|
|
AUTO_PROXY_DLLS::ProcessProxyQueryForInfo
|
|
AUTO_PROXY_DLLS::SafeThreadShutdown
|
|
AUTO_PROXY_DLLS::DoThreadProcessing
|
|
AUTO_PROXY_DLLS::ProcessAsyncAutoProxyRequest
|
|
AUTO_PROXY_DLLS::SignalAsyncRequestCompleted
|
|
AUTO_PROXY_DLLS::FreeAutoProxyInfo
|
|
|
|
AUTO_PROXY_LIST_ENTRY::LoadEntry
|
|
AUTO_PROXY_LIST_ENTRY::GetProxyInfoEx
|
|
AUTO_PROXY_LIST_ENTRY::ProxyInfoInvalid
|
|
AUTO_PROXY_LIST_ENTRY::ProxyDllInit
|
|
AUTO_PROXY_LIST_ENTRY::ProxyDllDeInit
|
|
|
|
(MatchFileExtensionWithUrl)
|
|
(AutoProxyThreadFunc)
|
|
|
|
Author:
|
|
|
|
Arthur L Bierer (arthurbi) 17-Dec-1996
|
|
|
|
Revision History:
|
|
|
|
17-Dec-1996 arthurbi
|
|
Created
|
|
|
|
--*/
|
|
|
|
#include <wininetp.h>
|
|
#include "autodial.h"
|
|
#include "apdetect.h"
|
|
|
|
//
|
|
// definitions
|
|
//
|
|
|
|
#define DEFAULT_SCRIPT_BUFFER_SIZE 4000 // bytes.
|
|
|
|
//
|
|
// BUGBUG [arthurbi] This structures are shared between
|
|
// wininet.dll && jsproxy.dll, shouldn't we move them
|
|
// into a central file???
|
|
//
|
|
|
|
#define AUTO_PROXY_REG_FLAG_ALLOW_STRUC 0x0001
|
|
|
|
typedef struct {
|
|
|
|
//
|
|
// Size of struct
|
|
//
|
|
|
|
DWORD dwStructSize;
|
|
|
|
//
|
|
// Buffer to Pass
|
|
//
|
|
|
|
LPSTR lpszScriptBuffer;
|
|
|
|
//
|
|
// Size of buffer above
|
|
//
|
|
|
|
DWORD dwScriptBufferSize;
|
|
|
|
} AUTO_PROXY_EXTERN_STRUC, *LPAUTO_PROXY_EXTERN_STRUC;
|
|
|
|
|
|
//
|
|
// private templates
|
|
//
|
|
|
|
PRIVATE
|
|
BOOL
|
|
MatchFileExtensionWithUrl(
|
|
IN LPCSTR lpszFileExtensionList,
|
|
IN LPCSTR lpszUrl
|
|
);
|
|
|
|
|
|
//
|
|
// private vars
|
|
//
|
|
|
|
|
|
//
|
|
// functions
|
|
//
|
|
|
|
INTERNETAPI_(BOOL)
|
|
InternetInitializeAutoProxyDll(
|
|
DWORD dwReserved
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Stub to make INETCPL work. Since they expect to call this function.
|
|
|
|
Arguments:
|
|
|
|
none.
|
|
|
|
Return Value:
|
|
|
|
BOOL
|
|
TRUE - success
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
BOOL fSuccess;
|
|
DWORD error = ERROR_SUCCESS;
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Bool,
|
|
"InternetInitializeAutoProxyDll",
|
|
""
|
|
));
|
|
|
|
if (!GlobalDataInitialized) {
|
|
error = GlobalDataInitialize();
|
|
}
|
|
if (error == ERROR_SUCCESS) {
|
|
GlobalProxyInfo.ClearBadProxyList();
|
|
FixProxySettingsForCurrentConnection(TRUE);
|
|
GlobalProxyInfo.RefreshProxySettings(TRUE);
|
|
}
|
|
|
|
fSuccess = (error == ERROR_SUCCESS ) ? TRUE : FALSE;
|
|
|
|
DEBUG_LEAVE(fSuccess);
|
|
|
|
return fSuccess;
|
|
|
|
}
|
|
|
|
|
|
DWORD
|
|
WINAPI
|
|
AutoProxyThreadFunc(
|
|
LPVOID lpAutoProxyObject
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initialization Win32 Proc called when the auto-proxy thread is started.
|
|
|
|
Arguments:
|
|
|
|
none.
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
ERROR_SUCCESS - success
|
|
|
|
Win32 Error code - failure
|
|
|
|
--*/
|
|
|
|
{
|
|
return GlobalProxyInfo.DoThreadProcessing(lpAutoProxyObject);
|
|
}
|
|
|
|
|
|
//
|
|
// methods
|
|
//
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::CheckForTimerConfigChanges(
|
|
IN DWORD dwMinsToPoll
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Exames the registry to see if a timer has been turned so
|
|
that we poll auto-proxy every so often to check for updates
|
|
|
|
Arguments:
|
|
|
|
none.
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
ERROR_SUCCESS - success
|
|
|
|
Win32 Error code - failure
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD error = ERROR_SUCCESS;
|
|
DWORD dwReloadMins = dwMinsToPoll;
|
|
BOOL fEnableTimer = FALSE;
|
|
|
|
//
|
|
// Now check to determine if we have to enable the auto-proxy e
|
|
// this is used to force a re-download every "X" minutes.
|
|
//
|
|
|
|
if ( dwReloadMins != 0 )
|
|
{
|
|
if ( dwReloadMins > MAX_RELOAD_DELAY ) // too big?...
|
|
{
|
|
dwReloadMins = MAX_RELOAD_DELAY;
|
|
}
|
|
|
|
dwReloadMins *= ( 1000 * 60 ); // convert mins to miliseconds
|
|
fEnableTimer = TRUE;
|
|
}
|
|
|
|
//
|
|
// enable/disable timer for auto-proxy refresh.
|
|
//
|
|
|
|
ResetTimerCounter(
|
|
fEnableTimer, // TRUE/FALSE enable/disable
|
|
dwReloadMins // conv-ed already to msecs
|
|
);
|
|
|
|
error = ERROR_SUCCESS;
|
|
|
|
return error;
|
|
}
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::StartDownloadOfProxyInfo(
|
|
IN BOOL fForceRefresh
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Does the Overall download of proxy-information from an internally accessable Web Server.
|
|
Handles the case where we may have to redownload a secondary script also takes
|
|
care of launching detection for proxies.
|
|
|
|
Arguments:
|
|
|
|
fForceRefresh - TRUE if we are to attempt to refresh the auto-proxy URLs, and force a redection
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
ERROR_SUCCESS - success
|
|
|
|
Win32 Error code - failure
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD error = ERROR_SUCCESS;
|
|
BOOL fLocked = FALSE;
|
|
DWORD dwcbAutoConfigProxy = 0;
|
|
LPCSTR lpszAutoProxyUrl = NULL;
|
|
INTERNET_PROXY_INFO_EX ProxySettings;
|
|
BOOL fProxySettingsAlloced = FALSE;
|
|
BOOL fNeedRegWrite = FALSE;
|
|
BOOL fCachedDialupDetection = FALSE;
|
|
BOOL fNeedHostIPChk = FALSE;
|
|
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Dword,
|
|
"AUTO_PROXY_DLLS::StartDownloadOfProxyInfo",
|
|
"%B",
|
|
fForceRefresh
|
|
));
|
|
|
|
|
|
if ( IsOffline() )
|
|
{
|
|
error = ERROR_INTERNET_OFFLINE;
|
|
goto quit;
|
|
}
|
|
|
|
LockAutoProxy();
|
|
fLocked = TRUE;
|
|
|
|
error = GetProxySettings(&ProxySettings);
|
|
|
|
if (error != ERROR_SUCCESS ) {
|
|
goto quit;
|
|
}
|
|
|
|
fProxySettingsAlloced = TRUE;
|
|
|
|
//
|
|
// Now read from the registry, closing any stale stuff that we may still have
|
|
// around. Do we still really need this? Lets only do this for Refresh cases.
|
|
//
|
|
|
|
if ( fForceRefresh )
|
|
{
|
|
DestroyAutoProxyDll(TRUE); // unloads DLLs and frees up reg vars.
|
|
SelectAutoProxy(NULL);
|
|
|
|
_Error = ReadAutoProxyRegistrySettings();
|
|
error = _Error;
|
|
|
|
if (error != ERROR_SUCCESS ||
|
|
!IsConfigValidForAutoProxyThread() )
|
|
{
|
|
SetState(AUTO_PROXY_DISABLED);
|
|
goto quit;
|
|
}
|
|
|
|
if ( GetState() == AUTO_PROXY_DISABLED )
|
|
{
|
|
INET_ASSERT(FALSE); // do we need this code?
|
|
goto quit;
|
|
}
|
|
}
|
|
|
|
//INET_ASSERT(GetState() == AUTO_PROXY_BLOCKED ||
|
|
// GetState() == AUTO_PROXY_PENDING);
|
|
|
|
fLocked = FALSE;
|
|
UnlockAutoProxy();
|
|
|
|
//
|
|
// Now begin the work, we should no longer need to touch the Proxy_DLL object
|
|
// settings until we grab the AutoProxy Lock again.
|
|
//
|
|
|
|
do
|
|
{
|
|
if ( IsProxyAutoDetectEnabled(&ProxySettings) )
|
|
{
|
|
CHAR szUrl[1024];
|
|
BOOL fRet;
|
|
DWORD dwDetectFlags = PROXY_AUTO_DETECT_TYPE_DNS_A;
|
|
|
|
|
|
if ( fForceRefresh ||
|
|
IsProxyAutoDetectNeeded(&ProxySettings) )
|
|
{
|
|
|
|
//
|
|
// Release Old Auto-config URL
|
|
//
|
|
|
|
if ( ProxySettings.lpszLastKnownGoodAutoConfigUrl) {
|
|
FREE_MEMORY(ProxySettings.lpszLastKnownGoodAutoConfigUrl);
|
|
ProxySettings.lpszLastKnownGoodAutoConfigUrl = NULL;
|
|
}
|
|
|
|
// only do dhcp on net connections
|
|
if ( ProxySettings.lpszConnectionName == NULL ) {
|
|
dwDetectFlags |= PROXY_AUTO_DETECT_TYPE_DHCP;
|
|
}
|
|
|
|
//
|
|
// Save out the Host IP addresses, before we start the detection,
|
|
// after the detection is complete, we confirm that we're still
|
|
// on the same set of Host IPs, in case the user switched connections.
|
|
//
|
|
|
|
error = GetHostAddresses(&(ProxySettings.pdwDetectedInterfaceIp),
|
|
&(ProxySettings.dwDetectedInterfaceIpCount));
|
|
|
|
if ( error != ERROR_SUCCESS) {
|
|
goto quit;
|
|
}
|
|
|
|
fNeedHostIPChk = TRUE; // because we've saved our IPs
|
|
|
|
//
|
|
// Do the actual Detection work
|
|
//
|
|
|
|
fRet = DetectAutoProxyUrl(
|
|
szUrl,
|
|
ARRAY_ELEMENTS(szUrl),
|
|
dwDetectFlags
|
|
);
|
|
|
|
GetCurrentGmtTime(&ProxySettings.ftLastKnownDetectTime); // mark when detection was run.
|
|
|
|
//
|
|
// Process the Results of detection.
|
|
//
|
|
|
|
if ( fRet )
|
|
{
|
|
ProxySettings.dwAutoDiscoveryFlags |= AUTO_PROXY_FLAG_DETECTION_RUN;
|
|
|
|
ProxySettings.lpszLastKnownGoodAutoConfigUrl = NewString(szUrl);
|
|
if ( ProxySettings.lpszLastKnownGoodAutoConfigUrl == NULL )
|
|
{
|
|
error = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto quit;
|
|
}
|
|
|
|
SetExpiredUrl(szUrl);
|
|
fNeedRegWrite = TRUE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Disable auto-detection, if we failed
|
|
//
|
|
|
|
if ( ! (ProxySettings.dwAutoDiscoveryFlags & (AUTO_PROXY_FLAG_DETECTION_RUN | AUTO_PROXY_FLAG_USER_SET)) )
|
|
{
|
|
ProxySettings.dwFlags &= ~(PROXY_TYPE_AUTO_DETECT);
|
|
}
|
|
|
|
ProxySettings.dwAutoDiscoveryFlags |= AUTO_PROXY_FLAG_DETECTION_RUN;
|
|
fNeedRegWrite = TRUE;
|
|
}
|
|
}
|
|
else if ( ProxySettings.lpszLastKnownGoodAutoConfigUrl != NULL &&
|
|
ProxySettings.lpszConnectionName != NULL )
|
|
|
|
{
|
|
//
|
|
// If we're not doing any detection, and we're on a dial-up adapter,
|
|
// then we should remember that fact, since we may be called upon
|
|
// to actually force a detect, in case the cached URL was stale/bad.
|
|
//
|
|
|
|
INET_ASSERT(! fForceRefresh );
|
|
|
|
fCachedDialupDetection = TRUE;
|
|
}
|
|
|
|
lpszAutoProxyUrl = ProxySettings.lpszLastKnownGoodAutoConfigUrl;
|
|
}
|
|
|
|
//
|
|
// Falback if we are unable to detect something
|
|
//
|
|
|
|
if ( lpszAutoProxyUrl == NULL &&
|
|
IsProxyAutoConfigEnabled(&ProxySettings))
|
|
{
|
|
lpszAutoProxyUrl = ProxySettings.lpszAutoconfigUrl;
|
|
}
|
|
|
|
//
|
|
// Do the actual download of the file
|
|
//
|
|
|
|
if (lpszAutoProxyUrl != NULL)
|
|
{
|
|
error = DoNestedProxyInfoDownload(lpszAutoProxyUrl, &ProxySettings, fForceRefresh);
|
|
|
|
if ( error != ERROR_SUCCESS )
|
|
{
|
|
|
|
//
|
|
// If we're cached + on a dialup, and we fail with the URL,
|
|
// then perhaps the URL/net is really expired.
|
|
//
|
|
|
|
if ( fCachedDialupDetection &&
|
|
! fForceRefresh )
|
|
{
|
|
fForceRefresh = TRUE;
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Fallback to autoconfig if we failed and we were using
|
|
// auto-detect
|
|
//
|
|
|
|
if ( IsProxyAutoConfigEnabled(&ProxySettings) &&
|
|
lpszAutoProxyUrl != ProxySettings.lpszAutoconfigUrl &&
|
|
ProxySettings.lpszAutoconfigUrl != NULL )
|
|
{
|
|
lpszAutoProxyUrl = ProxySettings.lpszAutoconfigUrl;
|
|
error = DoNestedProxyInfoDownload(lpszAutoProxyUrl, &ProxySettings, fForceRefresh);
|
|
}
|
|
}
|
|
}
|
|
} while (FALSE);
|
|
|
|
LockAutoProxy();
|
|
fLocked = TRUE;
|
|
|
|
if (lpszAutoProxyUrl == NULL)
|
|
{
|
|
SetState(AUTO_PROXY_DISABLED);
|
|
goto quit;
|
|
}
|
|
else
|
|
{
|
|
// stamp version so we know we just ran detection
|
|
_dwUpdatedProxySettingsVersion =
|
|
ProxySettings.dwCurrentSettingsVersion;
|
|
SetState(AUTO_PROXY_ENABLED);
|
|
}
|
|
|
|
CheckForTimerConfigChanges(ProxySettings.dwAutoconfigReloadDelayMins);
|
|
|
|
quit:
|
|
|
|
if ( error != ERROR_SUCCESS )
|
|
{
|
|
if (!fLocked)
|
|
{
|
|
LockAutoProxy();
|
|
fLocked = TRUE;
|
|
}
|
|
|
|
SetState(AUTO_PROXY_DISABLED);
|
|
}
|
|
|
|
//
|
|
// Unlock the AutoProxy
|
|
//
|
|
|
|
if ( fLocked ) {
|
|
UnlockAutoProxy();
|
|
}
|
|
|
|
if ( fProxySettingsAlloced )
|
|
{
|
|
//
|
|
// We need to save results to registry,
|
|
// then stamp the version in our global we now we detected for this,
|
|
// and then finally clean up any allocated stuff.
|
|
//
|
|
|
|
SaveDetectedProxySettings(&ProxySettings, fNeedHostIPChk);
|
|
|
|
WipeProxySettings(&ProxySettings);
|
|
}
|
|
|
|
DEBUG_LEAVE(error);
|
|
|
|
return error;
|
|
}
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::DoNestedProxyInfoDownload(
|
|
IN LPCSTR lpszAutoProxy,
|
|
IN LPINTERNET_PROXY_INFO_EX lpProxySettings,
|
|
IN BOOL fForceRefresh
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Does the download of proxy-information from an internally accessable Web Server.
|
|
Handles the case where we may have to redownload a secondary script and then
|
|
calls on to DownloadProxyInfo to actually do the dirty work.
|
|
|
|
Arguments:
|
|
|
|
lpszAutoProxy - URL to download
|
|
|
|
lpProxySettings - active Proxy Settings Copy for auto-proxy thread.
|
|
|
|
fForceRefresh - force refresh of downloaded file
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
ERROR_SUCCESS - success
|
|
|
|
Win32 Error code - failure
|
|
|
|
--*/
|
|
|
|
{
|
|
LPCSTR lpszNestedAutoProxyUrl = NULL;
|
|
DWORD error;
|
|
|
|
_pTempProxySettings = lpProxySettings; // in case they reset proxy settings
|
|
|
|
if ( _fInAutoProxyThreadShutDown )
|
|
{
|
|
error = ERROR_INTERNET_SHUTDOWN;
|
|
goto quit;
|
|
|
|
}
|
|
|
|
//
|
|
// IEAK flag, don't retry INS file unless either one of the following:
|
|
// 1) INS URL is expired
|
|
// 2) caching INS run is disabled
|
|
// 3) we're not forcing a refresh
|
|
//
|
|
|
|
if ( !(lpProxySettings->dwAutoDiscoveryFlags & AUTO_PROXY_FLAG_CACHE_INIT_RUN ) ||
|
|
// !(ProxySettings.dwAutoDiscoveryFlags & AUTO_PROXY_FLAG_DETECTION_RUN ) ||
|
|
!fForceRefresh ||
|
|
IsExpiredUrl(lpszAutoProxy))
|
|
{
|
|
|
|
//
|
|
// Now do the actual download of the proxy info.
|
|
//
|
|
|
|
error =
|
|
DownloadProxyInfo(lpszAutoProxy, fForceRefresh);
|
|
|
|
if ( error != ERROR_SUCCESS )
|
|
{
|
|
goto quit;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now check to determine if we have an overriding Auto-Proxy that
|
|
// supersides the one we just download. If we do, we will
|
|
// need to redownload auto-proxy
|
|
//
|
|
lpszNestedAutoProxyUrl = lpProxySettings->lpszAutoconfigSecondaryUrl;
|
|
|
|
if ( lpszNestedAutoProxyUrl )
|
|
{
|
|
//
|
|
// Success - now restart the download process for this special Url
|
|
//
|
|
|
|
error = DownloadProxyInfo(
|
|
lpszNestedAutoProxyUrl,
|
|
fForceRefresh
|
|
);
|
|
}
|
|
|
|
// fall through even in error
|
|
|
|
error = ERROR_SUCCESS;
|
|
|
|
quit:
|
|
|
|
INET_ASSERT(_pTempProxySettings);
|
|
_pTempProxySettings = NULL;
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::DownloadProxyInfo(
|
|
IN LPCSTR lpszAutoProxy,
|
|
IN BOOL fForceRefresh
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Does the download of proxy-information from an internally accessable Web Server.
|
|
The data will be checked, written to a temp file, and then an associated
|
|
DLL will be called to handle it.
|
|
|
|
Arguments:
|
|
|
|
lpszUrl - The URL to download.
|
|
|
|
fForceRefresh - force file to be reloaded from the wire
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
ERROR_SUCCESS - success
|
|
|
|
Win32 Error code - failure
|
|
|
|
--*/
|
|
|
|
{
|
|
HINTERNET hInternet = NULL;
|
|
HINTERNET hRequest = NULL;
|
|
HANDLE hFile = NULL;
|
|
CHAR szTemporyFile[MAX_PATH+1];
|
|
DWORD dwTempFileSize;
|
|
|
|
HANDLE hLockHandle = NULL;
|
|
|
|
BOOL fSuccess;
|
|
DWORD error = ERROR_SUCCESS;
|
|
|
|
CHAR szBuffer[MAX_PATH+1];
|
|
DWORD dwBytesRead;
|
|
|
|
BOOL fCleanupFile = FALSE;
|
|
BOOL fLocked = FALSE;
|
|
BOOL fBuffering = FALSE;
|
|
|
|
LPSTR lpszScriptBuffer = NULL;
|
|
DWORD dwScriptBufferSize;
|
|
|
|
DWORD dwStatusCode = ERROR_SUCCESS;
|
|
DWORD cbSize = sizeof(DWORD);
|
|
int nRetries = 3; // Num auth attempts
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Dword,
|
|
"AUTO_PROXY_DLLS::DownloadProxyInfo",
|
|
"%q",
|
|
lpszAutoProxy
|
|
));
|
|
|
|
INET_ASSERT(lpszAutoProxy);
|
|
|
|
//
|
|
// Fire up a mini InternetOpen/InternetOpenUrl to download a
|
|
// config file found on some internal server.
|
|
//
|
|
|
|
hInternet = InternetOpen(
|
|
(_lpszUserAgent) ? _lpszUserAgent : gszDefaultUserAgent,
|
|
INTERNET_OPEN_TYPE_DIRECT,
|
|
NULL,
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
|
|
if ( !hInternet )
|
|
{
|
|
error = GetLastError();
|
|
INET_ASSERT(error != ERROR_SUCCESS);
|
|
goto quit;
|
|
}
|
|
|
|
|
|
do
|
|
{
|
|
hRequest = InternetOpenUrl(
|
|
hInternet,
|
|
lpszAutoProxy,
|
|
"Accept: */*\r\n",
|
|
(DWORD) -1,
|
|
(fForceRefresh ?
|
|
INTERNET_FLAG_RELOAD :
|
|
0) |
|
|
INTERNET_FLAG_NEED_FILE,
|
|
INTERNET_NO_CALLBACK
|
|
);
|
|
|
|
|
|
if ( !hRequest )
|
|
{
|
|
//error = ERROR_INTERNET_UNABLE_TO_DOWNLOAD_SCRIPT;
|
|
error = GetLastError();
|
|
if(GlobalDisplayScriptDownloadFailureUI && !GlobalIsProcessNtService)
|
|
{
|
|
InternetErrorDlg(
|
|
GetDesktopWindow(),
|
|
hRequest,
|
|
ERROR_INTERNET_UNABLE_TO_DOWNLOAD_SCRIPT,
|
|
FLAGS_ERROR_UI_FILTER_FOR_ERRORS,
|
|
NULL);
|
|
}
|
|
goto quit;
|
|
}
|
|
|
|
cbSize = sizeof(dwStatusCode);
|
|
if (HttpQueryInfo(
|
|
hRequest,
|
|
HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER,
|
|
(LPVOID) &dwStatusCode,
|
|
&cbSize,
|
|
NULL
|
|
) && HTTP_STATUS_DENIED == dwStatusCode)
|
|
{
|
|
if (GlobalIsProcessNtService)
|
|
{
|
|
error = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto quit;
|
|
}
|
|
|
|
// Check the status code and throw an InternetErrorDlg
|
|
// if auth is needed and try again.
|
|
if (InternetErrorDlg(
|
|
GetDesktopWindow(),
|
|
hRequest,
|
|
ERROR_INTERNET_INCORRECT_PASSWORD,
|
|
FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS,
|
|
NULL
|
|
) != ERROR_INTERNET_FORCE_RETRY)
|
|
{
|
|
nRetries = 0;
|
|
}
|
|
else
|
|
{
|
|
cbSize = sizeof(szBuffer);
|
|
HttpQueryInfo(
|
|
hRequest,
|
|
HTTP_QUERY_WWW_AUTHENTICATE,
|
|
(LPVOID) szBuffer,
|
|
&cbSize,
|
|
NULL
|
|
);
|
|
szBuffer[5]='\0';
|
|
if (!lstrcmpi(szBuffer, "Basic"))
|
|
{
|
|
HttpSendRequest(
|
|
hRequest,
|
|
"Accept: */*\r\n",
|
|
(DWORD)-1,
|
|
NULL,
|
|
0);
|
|
cbSize = sizeof(dwStatusCode);
|
|
if (HttpQueryInfo(
|
|
hRequest,
|
|
HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER,
|
|
(LPVOID) &dwStatusCode,
|
|
&cbSize,
|
|
NULL
|
|
) && HTTP_STATUS_DENIED == dwStatusCode)
|
|
{
|
|
InternetCloseHandle(hRequest);
|
|
}
|
|
else
|
|
{
|
|
GlobalAutoProxyNeedsInit = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
InternetCloseHandle(hRequest);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Call it good
|
|
GlobalAutoProxyNeedsInit = FALSE;
|
|
break;
|
|
}
|
|
} while ( --nRetries>0);
|
|
|
|
if(nRetries <= 0)
|
|
{
|
|
// Still haven't initialized.
|
|
GlobalAutoProxyNeedsInit = TRUE;
|
|
}
|
|
|
|
// Reset to success
|
|
error = ERROR_SUCCESS;
|
|
|
|
if(HTTP_STATUS_NOT_FOUND == dwStatusCode)
|
|
{
|
|
error = ERROR_INTERNET_UNABLE_TO_DOWNLOAD_SCRIPT;
|
|
if(GlobalDisplayScriptDownloadFailureUI && !GlobalIsProcessNtService)
|
|
{
|
|
InternetErrorDlg(
|
|
GetDesktopWindow(),
|
|
hRequest,
|
|
ERROR_INTERNET_UNABLE_TO_DOWNLOAD_SCRIPT,
|
|
FLAGS_ERROR_UI_FILTER_FOR_ERRORS,
|
|
NULL);
|
|
}
|
|
goto quit;
|
|
}
|
|
|
|
|
|
DWORD dwIndex;
|
|
DWORD dwTempSize;
|
|
|
|
dwIndex = 0;
|
|
dwTempSize = sizeof(dwScriptBufferSize);
|
|
|
|
dwScriptBufferSize = 0;
|
|
|
|
if ( ! HttpQueryInfo(hRequest,
|
|
(HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER),
|
|
(LPVOID) &dwScriptBufferSize,
|
|
&dwTempSize,
|
|
&dwIndex) )
|
|
{
|
|
// failure, just defaults
|
|
dwScriptBufferSize = DEFAULT_SCRIPT_BUFFER_SIZE;
|
|
fBuffering = TRUE;
|
|
}
|
|
else if ( dwScriptBufferSize > DEFAULT_SCRIPT_BUFFER_SIZE )
|
|
{
|
|
// success, but too big.
|
|
dwScriptBufferSize = DEFAULT_SCRIPT_BUFFER_SIZE;
|
|
fBuffering = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// success, and this one is just right.
|
|
fBuffering = TRUE;
|
|
}
|
|
|
|
lpszScriptBuffer = (LPSTR)
|
|
ALLOCATE_MEMORY(LMEM_FIXED, ((dwScriptBufferSize+1)
|
|
* sizeof(CHAR)));
|
|
|
|
if ( lpszScriptBuffer == NULL )
|
|
{
|
|
error = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto quit;
|
|
}
|
|
|
|
//
|
|
// pull down bytes, and write to file
|
|
//
|
|
|
|
DWORD dwBytes;
|
|
dwBytesRead = 0;
|
|
|
|
do
|
|
{
|
|
DWORD dwBytesLeft;
|
|
LPSTR lpszDest;
|
|
|
|
dwBytes = 0;
|
|
lpszDest = lpszScriptBuffer;
|
|
dwBytesLeft = dwScriptBufferSize;
|
|
|
|
fSuccess = InternetReadFile(
|
|
hRequest,
|
|
lpszDest,
|
|
dwBytesLeft,
|
|
&dwBytes
|
|
);
|
|
|
|
if ( ! fSuccess )
|
|
{
|
|
error = GetLastError();
|
|
goto quit;
|
|
}
|
|
|
|
if ( _fInAutoProxyThreadShutDown )
|
|
{
|
|
error = ERROR_INTERNET_SHUTDOWN;
|
|
goto quit;
|
|
}
|
|
|
|
if ( dwBytes > 0 )
|
|
{
|
|
if ( dwBytesRead > 0 )
|
|
{
|
|
fBuffering = FALSE;
|
|
}
|
|
|
|
dwBytesRead += dwBytes;
|
|
}
|
|
} while ( dwBytes != 0 );
|
|
|
|
//
|
|
// Figure out what kind of file we're dealing with.
|
|
// ONLY allow files with the correct extension or the correct MIME type.
|
|
//
|
|
|
|
szBuffer[0] = '\0';
|
|
dwBytes = ARRAY_ELEMENTS(szBuffer)-1;
|
|
|
|
fSuccess = HttpQueryInfo( hRequest,
|
|
HTTP_QUERY_CONTENT_TYPE,
|
|
szBuffer,
|
|
&dwBytes,
|
|
NULL );
|
|
|
|
fLocked = TRUE;
|
|
LockAutoProxy();
|
|
|
|
if ( !(fSuccess
|
|
&& SelectAutoProxyByMime(szBuffer)) )
|
|
{
|
|
if ( ! SelectAutoProxyByFileExtension(lpszAutoProxy) )
|
|
{
|
|
if ( ! SelectAutoProxyByDefault() )
|
|
{
|
|
//
|
|
// Could not find a registered handler for this data.
|
|
//
|
|
|
|
error = ERROR_INTERNET_BAD_AUTO_PROXY_SCRIPT;
|
|
goto quit;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now, launch the handler to tell them about the file.
|
|
// we downloaded it first.
|
|
//
|
|
|
|
AUTO_PROXY_LIST_ENTRY * papleAutoProxy;
|
|
AUTO_PROXY_EXTERN_STRUC apeStruct;
|
|
LPAUTO_PROXY_EXTERN_STRUC pExtraStruct;
|
|
|
|
|
|
papleAutoProxy = GetSelectedAutoProxyEntry();
|
|
pExtraStruct = NULL;
|
|
|
|
//
|
|
// Get a temp file from cache if we need it.
|
|
//
|
|
|
|
if ( fBuffering &&
|
|
(papleAutoProxy->_dwFlags & AUTO_PROXY_REG_FLAG_ALLOW_STRUC) &&
|
|
dwBytesRead > 0 )
|
|
{
|
|
// slam a \0 terminator
|
|
INET_ASSERT(dwBytesRead <= dwScriptBufferSize);
|
|
lpszScriptBuffer[dwBytesRead] = '\0';
|
|
|
|
pExtraStruct = &apeStruct;
|
|
apeStruct.dwStructSize = sizeof(AUTO_PROXY_EXTERN_STRUC);
|
|
apeStruct.lpszScriptBuffer = lpszScriptBuffer;
|
|
apeStruct.dwScriptBufferSize = dwBytesRead + 1;
|
|
}
|
|
else
|
|
{
|
|
fCleanupFile = TRUE;
|
|
|
|
//Qfe 3430: When parsing ins file, with reference to pac file, wininet needs to
|
|
//know the connectoid name in order to set the pac file correctly. Currently there
|
|
//is no way for wininet to pass the connectoid name to branding dll. To workaround
|
|
//this, we use the AUTO_PROXY_EXTERN_STRUC to pass the connectoid name in lpszScriptBuffer
|
|
//variable.
|
|
if(!(papleAutoProxy->_dwFlags & AUTO_PROXY_REG_FLAG_ALLOW_STRUC))
|
|
{
|
|
pExtraStruct = &apeStruct;
|
|
apeStruct.dwStructSize = sizeof(AUTO_PROXY_EXTERN_STRUC);
|
|
apeStruct.lpszScriptBuffer = GlobalProxyInfo.GetConnectionName();
|
|
}
|
|
|
|
if ( ! InternetLockRequestFile(hRequest, &hLockHandle) )
|
|
{
|
|
fCleanupFile = FALSE;
|
|
}
|
|
|
|
dwTempFileSize = MAX_PATH;
|
|
|
|
if ( ! InternetQueryOption(hRequest, INTERNET_OPTION_DATAFILE_NAME,
|
|
szTemporyFile, &dwTempFileSize ) ||
|
|
dwTempFileSize == 0 )
|
|
{
|
|
error = ERROR_INTERNET_BAD_AUTO_PROXY_SCRIPT;
|
|
goto quit;
|
|
}
|
|
}
|
|
|
|
//
|
|
// The loading and unloading of DLLs is owned/allowed
|
|
// only by the auto-proxy thread, ONCE THIS THREAD IS RUNNING
|
|
// so once we're here, we can be assured its safe to
|
|
// make the following calls without holding the crit sec.
|
|
//
|
|
|
|
INET_ASSERT(fLocked);
|
|
UnlockAutoProxy();
|
|
fLocked = FALSE;
|
|
fSuccess = TRUE;
|
|
|
|
//
|
|
// If we're not configured, or cannot match the URL
|
|
// with a Handler to actually run the script,
|
|
// then we need to error out
|
|
//
|
|
|
|
if ( papleAutoProxy == NULL)
|
|
{
|
|
error = ERROR_INTERNET_UNABLE_TO_DOWNLOAD_SCRIPT;
|
|
goto quit;
|
|
}
|
|
|
|
if ( ! papleAutoProxy->_hAutoConfigDLL )
|
|
{
|
|
if ( _fInAutoProxyThreadShutDown )
|
|
{
|
|
error = ERROR_INTERNET_SHUTDOWN;
|
|
goto quit;
|
|
}
|
|
|
|
error = papleAutoProxy->LoadEntry();
|
|
|
|
if ( error != ERROR_SUCCESS )
|
|
{
|
|
goto quit;
|
|
}
|
|
}
|
|
else if ( papleAutoProxy->_fInitializedSuccessfully &&
|
|
papleAutoProxy->_pProxyDllInit &&
|
|
papleAutoProxy->_pProxyDllDeInit )
|
|
{
|
|
//
|
|
// If this DLL has already been loaded,
|
|
// then unitialize it before re-initalizeing with
|
|
// new data, otherwise we risk leaking some its
|
|
// objects
|
|
//
|
|
|
|
papleAutoProxy->ProxyDllDeInit(
|
|
szBuffer,
|
|
0
|
|
);
|
|
INET_ASSERT(papleAutoProxy->_fUnInited);
|
|
}
|
|
|
|
//
|
|
// Make the call into the external DLL,
|
|
// and let it run, possibly initilization and doing a bunch
|
|
// of stuff.
|
|
//
|
|
|
|
|
|
fSuccess = papleAutoProxy->ProxyDllInit (
|
|
AUTO_PROXY_VERSION,
|
|
szTemporyFile, // temp file we down loaded
|
|
szBuffer, // mime
|
|
&_aphAutoProxyAPIs,
|
|
(DWORD_PTR) pExtraStruct
|
|
);
|
|
|
|
if ( _fInAutoProxyThreadShutDown )
|
|
{
|
|
error = ERROR_INTERNET_SHUTDOWN;
|
|
goto quit;
|
|
}
|
|
|
|
if ( ! fSuccess )
|
|
{
|
|
error = ERROR_INTERNET_BAD_AUTO_PROXY_SCRIPT;
|
|
goto quit;
|
|
}
|
|
|
|
|
|
if ( papleAutoProxy->IsGetProxyInfoEx() ||
|
|
papleAutoProxy->IsGetProxyInfo() )
|
|
{
|
|
SetState(AUTO_PROXY_ENABLED);
|
|
}
|
|
else
|
|
{
|
|
SetState(AUTO_PROXY_DISABLED);
|
|
}
|
|
|
|
quit:
|
|
|
|
if ( error != ERROR_SUCCESS )
|
|
{
|
|
if (!fLocked)
|
|
{
|
|
LockAutoProxy();
|
|
fLocked = TRUE;
|
|
}
|
|
|
|
SetState(AUTO_PROXY_DISABLED);
|
|
}
|
|
|
|
if ( fLocked )
|
|
{
|
|
UnlockAutoProxy();
|
|
}
|
|
|
|
if ( fCleanupFile )
|
|
{
|
|
InternetUnlockRequestFile(hLockHandle);
|
|
}
|
|
|
|
if ( lpszScriptBuffer )
|
|
{
|
|
FREE_MEMORY(lpszScriptBuffer);
|
|
}
|
|
|
|
if ( hRequest )
|
|
{
|
|
InternetCloseHandle(hRequest);
|
|
}
|
|
|
|
if ( hInternet )
|
|
{
|
|
InternetCloseHandle(hInternet);
|
|
}
|
|
|
|
SetAbortHandle(NULL);
|
|
|
|
DEBUG_LEAVE(error);
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
AUTO_PROXY_DLLS::IsAutoProxyEnabled(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Determines whether the auto-proxy thread is enabled and ready
|
|
to accept async proxy requests. This is needed to prevent
|
|
senceless calls to the auto-proxy thread when the request
|
|
could made more directly to the PROXY_INFO object.
|
|
|
|
Return Value:
|
|
|
|
BOOL
|
|
TRUE - the AutoProxy thread is accepting async requests
|
|
|
|
FALSE - the AutoProxy thread is refusung async requests.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL fIsGetProxyCallProxyNeeded = FALSE;
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Bool,
|
|
"AUTO_PROXY_DLLS::IsAutoProxyEnabled",
|
|
""
|
|
));
|
|
|
|
|
|
LockAutoProxy();
|
|
|
|
//
|
|
// If we're downloading new information, OR we have a async thread ready to process
|
|
// autoproxy queries, then go async and do the request. The worst case will
|
|
// result in the async thread being created and then returning the request
|
|
// unprocessed ( the FSM will resubmit it to the general proxy code )
|
|
//
|
|
|
|
if ( GetState() == AUTO_PROXY_ENABLED ||
|
|
GetState() == AUTO_PROXY_BLOCKED ||
|
|
GetState() == AUTO_PROXY_PENDING )
|
|
{
|
|
fIsGetProxyCallProxyNeeded = TRUE;
|
|
}
|
|
else
|
|
{
|
|
fIsGetProxyCallProxyNeeded = FALSE;
|
|
}
|
|
|
|
UnlockAutoProxy();
|
|
|
|
DEBUG_LEAVE(fIsGetProxyCallProxyNeeded);
|
|
|
|
return fIsGetProxyCallProxyNeeded;
|
|
}
|
|
|
|
|
|
BOOL
|
|
AUTO_PROXY_DLLS::IsAutoProxyGetProxyInfoCallNeeded(
|
|
IN AUTO_PROXY_ASYNC_MSG *pQueryForInfo
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Wrapper for IsAutoProxyEnabled, verifies that the message object (pQueryForInfo)
|
|
in question is capible of going async.
|
|
|
|
Arguments:
|
|
|
|
pQueryForInfo - Pointer to Message object that contains state information
|
|
used in the query.
|
|
|
|
Return Value:
|
|
|
|
BOOL
|
|
TRUE - the AutoProxy thread is accepting async requests
|
|
|
|
FALSE - the AutoProxy thread is refusung async requests.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
INET_ASSERT(pQueryForInfo);
|
|
|
|
//
|
|
// The caller has explicitly banned auto-proxy calls.
|
|
//
|
|
|
|
if ( pQueryForInfo->IsAvoidAsyncCall() )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// We cannot process this request to auto-proxy unless we have an URL
|
|
//
|
|
|
|
if ( ! pQueryForInfo->IsUrl() )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Now check to see if its really enabled.
|
|
//
|
|
|
|
return IsAutoProxyEnabled();
|
|
|
|
}
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::QueueAsyncAutoProxyRequest(
|
|
IN OUT AUTO_PROXY_ASYNC_MSG **ppQueryForInfo
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Submits the *ppQueryForInfo Object on the async queue for processing
|
|
by the async auto-proxy thread.
|
|
|
|
Arguments:
|
|
|
|
ppQueryForInfo - Pointer to pointer to Message object that contains state information
|
|
used in the query. If the object needs to be allocated on the heap
|
|
then the pointer will change to reflect the new object ptr.
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
Success - ERROR_SUCCESS
|
|
|
|
Failure -
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
LPINTERNET_THREAD_INFO lpThreadInfo = InternetGetThreadInfo();
|
|
BOOL fLocked = FALSE;
|
|
DWORD error = ERROR_SUCCESS;
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Dword,
|
|
"AUTO_PROXY_DLLS::QueueAsyncAutoProxyRequest",
|
|
"%x",
|
|
ppQueryForInfo
|
|
));
|
|
|
|
|
|
//
|
|
// First allocate an object, if its not allocated,
|
|
// cause we can't pass local stack vars to another thread (duh..)
|
|
//
|
|
|
|
if ( ! (*ppQueryForInfo)->IsAlloced() )
|
|
{
|
|
*ppQueryForInfo = new AUTO_PROXY_ASYNC_MSG(*ppQueryForInfo);
|
|
|
|
if ( *ppQueryForInfo == NULL )
|
|
{
|
|
error = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto quit;
|
|
}
|
|
}
|
|
|
|
LockAutoProxy(); // lock object to prevent anyone messing with thread handles
|
|
fLocked = TRUE;
|
|
|
|
//
|
|
// Busy wait for thread to be shutdown before restarting.
|
|
//
|
|
|
|
while ( _fInAutoProxyThreadShutDown )
|
|
{
|
|
UnlockAutoProxy();
|
|
Sleep(100);
|
|
LockAutoProxy();
|
|
}
|
|
|
|
if ( _hAutoProxyThread == NULL )
|
|
{
|
|
|
|
_hAutoProxyThreadEvent = CreateEvent(
|
|
NULL, // pointer to security attributes
|
|
FALSE, // flag for manual-reset event
|
|
TRUE, // flag for initial state
|
|
NULL // event-object name
|
|
);
|
|
|
|
|
|
if ( _hAutoProxyThreadEvent == NULL )
|
|
{
|
|
error = GetLastError();
|
|
goto quit;
|
|
}
|
|
|
|
//
|
|
// We block on this event until the thread is actually running,
|
|
// otherwise we may PROCESS_DETEACH while the auto-proxy
|
|
// thread is in this quasi-state of having been created, but not actually run.
|
|
//
|
|
|
|
_hAutoProxyStartEvent = CreateEvent(
|
|
NULL, // pointer to security attributes
|
|
TRUE, // flag for manual-reset event
|
|
FALSE, // flag for initial state
|
|
NULL // event-object name
|
|
);
|
|
|
|
|
|
if ( _hAutoProxyStartEvent == NULL )
|
|
{
|
|
error = GetLastError();
|
|
goto quit;
|
|
}
|
|
|
|
ResetEvent(_hAutoProxyStartEvent);
|
|
|
|
_hAutoProxyThread = CreateThread(
|
|
NULL, // pointer to thread security attributes
|
|
0, // starting stack size
|
|
AutoProxyThreadFunc,
|
|
this, // argument
|
|
0, // flags
|
|
&_dwAutoProxyThreadId
|
|
);
|
|
|
|
|
|
if ( _hAutoProxyThread == NULL )
|
|
{
|
|
error = GetLastError();
|
|
CloseHandle(_hAutoProxyThreadEvent);
|
|
CloseHandle(_hAutoProxyStartEvent);
|
|
_hAutoProxyThreadEvent = NULL;
|
|
_hAutoProxyStartEvent = NULL;
|
|
goto quit;
|
|
}
|
|
|
|
const HANDLE aWaitHandles[2] = {_hAutoProxyStartEvent, _hAutoProxyThread};
|
|
|
|
// wait on the thread handle too in case it terminates for some unknown reason
|
|
error = WaitForMultipleObjects(ARRAYSIZE(aWaitHandles),
|
|
aWaitHandles,
|
|
FALSE,
|
|
INFINITE);
|
|
if ( error != WAIT_OBJECT_0 )
|
|
{
|
|
INET_ASSERT(FALSE);
|
|
TerminateThread(_hAutoProxyThread, ERROR_SUCCESS);
|
|
|
|
CloseHandle(_hAutoProxyThreadEvent);
|
|
CloseHandle(_hAutoProxyStartEvent);
|
|
CloseHandle(_hAutoProxyThread);
|
|
_hAutoProxyStartEvent = NULL;
|
|
_hAutoProxyThread = NULL;
|
|
_hAutoProxyThreadEvent = NULL;
|
|
_dwAutoProxyThreadId = NULL;
|
|
|
|
error = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto quit;
|
|
}
|
|
else
|
|
{
|
|
CloseHandle(_hAutoProxyStartEvent);
|
|
_hAutoProxyStartEvent = NULL;
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Now Block the Thread we're on...
|
|
//
|
|
|
|
if ( (*ppQueryForInfo)->IsBlockUntilCompletetion() )
|
|
{
|
|
if ( lpThreadInfo &&
|
|
lpThreadInfo->Fsm &&
|
|
lpThreadInfo->IsAsyncWorkerThread &&
|
|
!(lpThreadInfo->Fsm->IsBlocking()))
|
|
{
|
|
//
|
|
// In a FSM, use FSM - thread pool handler to block this.
|
|
//
|
|
|
|
(*ppQueryForInfo)->SetBlockedOnFsm(TRUE);
|
|
|
|
lpThreadInfo->Fsm->SetState(FSM_STATE_CONTINUE);
|
|
lpThreadInfo->Fsm->SetNextState(FSM_STATE_CONTINUE);
|
|
|
|
error = BlockWorkItem(
|
|
lpThreadInfo->Fsm,
|
|
(DWORD_PTR) *ppQueryForInfo, // block the FSM on ourselves
|
|
INFINITE // we block foreever
|
|
);
|
|
|
|
|
|
if ( error != ERROR_SUCCESS )
|
|
{
|
|
goto quit;
|
|
}
|
|
|
|
InsertAtTailOfSerializedList(&_AsyncQueueList, &(*ppQueryForInfo)->_List);
|
|
SetEvent(_hAutoProxyThreadEvent);
|
|
|
|
error = ERROR_IO_PENDING;
|
|
}
|
|
else
|
|
{
|
|
AcquireBlockedRequestQueue();
|
|
|
|
InsertAtTailOfSerializedList(&_AsyncQueueList, &(*ppQueryForInfo)->_List);
|
|
SetEvent(_hAutoProxyThreadEvent);
|
|
|
|
UnlockAutoProxy();
|
|
fLocked = FALSE;
|
|
|
|
error = BlockThreadOnEvent(
|
|
(DWORD_PTR) *ppQueryForInfo,
|
|
INFINITE, // we need to block forever !
|
|
TRUE // release BlockedRequestQueue
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
InsertAtTailOfSerializedList(&_AsyncQueueList, &(*ppQueryForInfo)->_List);
|
|
SetEvent(_hAutoProxyThreadEvent);
|
|
}
|
|
|
|
quit:
|
|
|
|
if ( fLocked )
|
|
{
|
|
UnlockAutoProxy();
|
|
fLocked = FALSE;
|
|
}
|
|
|
|
DEBUG_LEAVE(error);
|
|
|
|
return error;
|
|
}
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::ProcessProxyQueryForInfo(
|
|
IN OUT AUTO_PROXY_ASYNC_MSG **ppQueryForInfo
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Performs a query for proxy information using an external DLL's entry points to
|
|
anwser our query. If we are not on the correct thread, we call QueueAsyncAutoProxyRequest
|
|
to marshall our call across to it.
|
|
|
|
Arguments:
|
|
|
|
ppQueryForInfo - Pointer to pointer to Message object that contains state information
|
|
used in the query. If the object needs to be allocated on the heap
|
|
then the pointer will change to reflect the new object ptr.
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
Success - ERROR_SUCCESS
|
|
|
|
Failure -
|
|
|
|
--*/
|
|
|
|
{
|
|
AUTO_PROXY_LIST_ENTRY * papleAutoProxy;
|
|
DWORD error = ERROR_SUCCESS;
|
|
BOOL fUnlocked = FALSE;
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Dword,
|
|
"AUTO_PROXY_DLLS::ProcessProxyQueryForInfo",
|
|
"%x",
|
|
ppQueryForInfo
|
|
));
|
|
|
|
|
|
INET_ASSERT(ppQueryForInfo);
|
|
INET_ASSERT(*ppQueryForInfo);
|
|
INET_ASSERT((*ppQueryForInfo)->QueryForInfoMessage() == PROXY_MSG_GET_PROXY_INFO);
|
|
INET_ASSERT(IsOnAsyncAutoProxyThread());
|
|
|
|
LockAutoProxy();
|
|
|
|
//
|
|
// this function should only ever be executed on the auto-proxy thread
|
|
//
|
|
|
|
if ( GetState() == AUTO_PROXY_DISABLED )
|
|
{
|
|
//
|
|
// Fall back to a normal proxy query.
|
|
//
|
|
|
|
(*ppQueryForInfo)->SetAvoidAsyncCall(TRUE);
|
|
goto quit;
|
|
}
|
|
|
|
papleAutoProxy =
|
|
GetSelectedAutoProxyEntry();
|
|
|
|
//
|
|
// We should be the only ones to create or destroy
|
|
// auto-proxy info, therefore we release the holly
|
|
// lock of auto-proxy. If I'm wrong another thread
|
|
// could cause us trouble ...
|
|
//
|
|
|
|
UnlockAutoProxy();
|
|
fUnlocked = TRUE;
|
|
|
|
if ( papleAutoProxy )
|
|
{
|
|
//
|
|
// If GetProxyInfoEx is supported, we defer to it to handle
|
|
// everything.
|
|
//
|
|
|
|
if ( papleAutoProxy->IsGetProxyInfoEx() )
|
|
{
|
|
error = papleAutoProxy->GetProxyInfoEx(
|
|
*ppQueryForInfo
|
|
);
|
|
|
|
goto quit;
|
|
}
|
|
else if ( papleAutoProxy->IsGetProxyInfo() )
|
|
{
|
|
error = papleAutoProxy->GetProxyInfo(
|
|
*ppQueryForInfo
|
|
);
|
|
|
|
goto quit;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Fall back to a normal proxy query.
|
|
//
|
|
|
|
(*ppQueryForInfo)->SetAvoidAsyncCall(TRUE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Fall back to a normal proxy query.
|
|
//
|
|
|
|
(*ppQueryForInfo)->SetAvoidAsyncCall(TRUE);
|
|
}
|
|
|
|
|
|
quit:
|
|
|
|
if ( !fUnlocked )
|
|
{
|
|
UnlockAutoProxy();
|
|
}
|
|
|
|
DEBUG_LEAVE(error);
|
|
|
|
return error;
|
|
}
|
|
|
|
VOID
|
|
AUTO_PROXY_DLLS::SafeThreadShutdown(
|
|
BOOL fItsTheFinalShutDown
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Performs a shutdown of the auto-proxy thread by the auto-proxy thread itself.
|
|
|
|
Arguments:
|
|
|
|
fItsTheFinalShutDown - TRUE, if we are shutting down at the end of a process
|
|
|
|
Return Value:
|
|
|
|
none.
|
|
|
|
--*/
|
|
{
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
None,
|
|
"AUTO_PROXY_DLLS::SafeThreadShutdown",
|
|
"%B",
|
|
fItsTheFinalShutDown
|
|
));
|
|
|
|
|
|
//
|
|
// Attempt to Shut down thread due to no-activity OR
|
|
// due to process shutdown.
|
|
//
|
|
|
|
LockAutoProxy();
|
|
|
|
if ( IsSerializedListEmpty(&_AsyncQueueList) ||
|
|
fItsTheFinalShutDown )
|
|
{
|
|
//HANDLE hAutoProxyThreadEvent = _hAutoProxyThreadEvent;
|
|
//HANDLE hAutoProxyThread = _hAutoProxyThread;
|
|
|
|
//_hAutoProxyThread = NULL;
|
|
//_hAutoProxyThreadEvent = NULL;
|
|
_dwAutoProxyThreadId = 0;
|
|
|
|
//CloseHandle(hAutoProxyThreadEvent);
|
|
//CloseHandle(hAutoProxyThread);
|
|
|
|
UnlockAutoProxy();
|
|
|
|
if ( fItsTheFinalShutDown )
|
|
{
|
|
//DestroyAutoProxyMsgQueue();
|
|
DestroyAutoProxyDll(TRUE); // unloads DLLs and frees up reg vars
|
|
}
|
|
|
|
DEBUG_LEAVE(0);
|
|
|
|
ExitThread(ERROR_SUCCESS);
|
|
|
|
INET_ASSERT(FALSE); //we will never get here...
|
|
}
|
|
|
|
UnlockAutoProxy();
|
|
|
|
DEBUG_LEAVE(0);
|
|
|
|
}
|
|
|
|
#define NLA_ERROR_RETRY_INTERVAL (5*60*1000)
|
|
|
|
class NLA_NET_CHANGE {
|
|
private:
|
|
HANDLE _hLookup;
|
|
WSAOVERLAPPED _ovlp;
|
|
DWORD _lastInitAttempt;
|
|
|
|
BOOLEAN
|
|
Initialize ();
|
|
|
|
BOOLEAN
|
|
EnumerateNetChanges ();
|
|
|
|
public:
|
|
NLA_NET_CHANGE () {
|
|
_ovlp.hEvent = NULL;
|
|
if (GlobalPlatformWhistler &&
|
|
_I_WSALookupServiceBeginW!=NULL) {
|
|
_hLookup = NULL;
|
|
_lastInitAttempt = GetTickCount ()-NLA_ERROR_RETRY_INTERVAL-1;
|
|
}
|
|
else {
|
|
#if DBG
|
|
dprintf ("NLA not available: whistler-%ld, lookup:-%#x\n",
|
|
GlobalPlatformWhistler, _I_WSALookupServiceBeginW);
|
|
#endif
|
|
_hLookup = INVALID_HANDLE_VALUE;
|
|
}
|
|
};
|
|
|
|
~NLA_NET_CHANGE () {
|
|
if (_hLookup!=NULL && _hLookup!=INVALID_HANDLE_VALUE) {
|
|
#if DBG
|
|
dprintf ("NLA - cleaning up");
|
|
#endif
|
|
_I_WSALookupServiceEnd (_hLookup);
|
|
CloseHandle (_ovlp.hEvent);
|
|
}
|
|
};
|
|
|
|
BOOLEAN
|
|
IsNetChanged () {
|
|
if (_hLookup!=INVALID_HANDLE_VALUE) {
|
|
if ((_hLookup!=NULL) ||
|
|
( ((GetTickCount ()-_lastInitAttempt)
|
|
>NLA_ERROR_RETRY_INTERVAL) &&
|
|
Initialize () ) ) {
|
|
if (HasOverlappedIoCompleted (&_ovlp)) {
|
|
#if DBG
|
|
dprintf ("NLA change detected, status:%lx\n",
|
|
_ovlp.Internal);
|
|
#endif
|
|
return EnumerateNetChanges ();
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
};
|
|
|
|
HANDLE
|
|
GetChangeEvent () {
|
|
return _ovlp.hEvent;
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
BOOLEAN
|
|
NLA_NET_CHANGE::Initialize (
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initializes Network Location Awareness lookup query.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
TRUE - succes
|
|
FALSE - failure
|
|
|
|
--*/
|
|
{
|
|
WSAQUERYSETW qset;
|
|
GUID nlaServiceClassId = NLA_SERVICE_CLASS_GUID;
|
|
DWORD qSize;
|
|
INT error;
|
|
|
|
INET_ASSERT (_ovlp.hEvent==NULL);
|
|
INET_ASSERT (_hLookup==NULL);
|
|
|
|
//
|
|
// Create event for async notifications.
|
|
//
|
|
_ovlp.hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
|
|
if (_ovlp.hEvent!=NULL) {
|
|
|
|
ZeroMemory (&qset, sizeof (qset));
|
|
qset.dwSize = sizeof (qset);
|
|
qset.lpServiceClassId = &nlaServiceClassId;
|
|
qset.dwNameSpace = NS_NLA;
|
|
|
|
if (_I_WSALookupServiceBeginW (
|
|
&qset,
|
|
LUP_RETURN_NAME|LUP_RETURN_BLOB,
|
|
&_hLookup)!=SOCKET_ERROR) {
|
|
DEBUG_PRINT (PROXY, INFO, ("Nla Lookup created\n"));
|
|
#if DBG
|
|
dprintf ("NLA Lookup created, handle:%#x\n", _hLookup);
|
|
#endif
|
|
|
|
//
|
|
// Just walk through the net list and setup notification.
|
|
//
|
|
return EnumerateNetChanges ();
|
|
|
|
}
|
|
else {
|
|
error = GetLastError ();
|
|
DEBUG_PRINT (PROXY, ERROR,
|
|
("NLA Lookup creation failed, err: %ld\n",
|
|
error));
|
|
#if DBG
|
|
dprintf ("NLA Lookup creation failed, err: %ld\n",error);
|
|
#endif
|
|
}
|
|
_hLookup = NULL;
|
|
CloseHandle (_ovlp.hEvent);
|
|
_ovlp.hEvent = NULL;
|
|
}
|
|
else {
|
|
error = GetLastError ();
|
|
DEBUG_PRINT (PROXY, ERROR,
|
|
("NLA notification event creation failed, err: %ld\n",
|
|
error));
|
|
#if DBG
|
|
dprintf ("NLA notification event creation failed, err: %ld\n",
|
|
error);
|
|
#endif
|
|
}
|
|
|
|
INET_ASSERT (error!=NO_ERROR);
|
|
|
|
//
|
|
// Remember when we failed, so we do not retry very often.
|
|
//
|
|
_lastInitAttempt = GetTickCountWrap ();
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
NLA_NET_CHANGE::EnumerateNetChanges (
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Enumerates Network entries returned by the NLA query.
|
|
If this is called after change notification, only
|
|
changes since last enumeration are returned.
|
|
|
|
Arguments:
|
|
None.
|
|
|
|
Return Value:
|
|
TRUE - there were any relevant changes
|
|
FALSE - no relevant changes.
|
|
|
|
--*/
|
|
{
|
|
DWORD error = NO_ERROR;
|
|
|
|
// Stack buffer which should be sufficient for most cases.
|
|
struct {
|
|
WSAQUERYSETW set;
|
|
WCHAR name[128];
|
|
NLA_BLOB blob;
|
|
} q;
|
|
LPWSAQUERYSETW pqSet = &q.set;
|
|
DWORD qSize = sizeof (q), retSize;
|
|
BOOLEAN changed = FALSE;
|
|
|
|
INET_ASSERT (_hLookup!=NULL && _hLookup!=INVALID_HANDLE_VALUE);
|
|
INET_ASSERT (_ovlp.hEvent!=NULL);
|
|
INET_ASSERT (HasOverlappedIoCompleted (&_ovlp));
|
|
|
|
do {// Outer loop - keep calling while we are getting notifications.
|
|
|
|
do {// Inner loop - keep calling while enumerating through networks.
|
|
retSize = qSize;
|
|
error = _I_WSALookupServiceNextW (
|
|
_hLookup,
|
|
0,
|
|
&retSize,
|
|
pqSet);
|
|
if (error!=SOCKET_ERROR) {
|
|
INET_ASSERT (error==NO_ERROR);
|
|
//
|
|
// Success, see if results in this query are relevant
|
|
//
|
|
DEBUG_PRINT (PROXY, INFO,
|
|
("NLA change for %ws-%lx\n",
|
|
pqSet->lpszServiceInstanceName,
|
|
pqSet->dwOutputFlags));
|
|
#if DBG
|
|
dprintf ("NLA change for %ws-%lx\n",
|
|
pqSet->lpszServiceInstanceName,
|
|
pqSet->dwOutputFlags);
|
|
#endif
|
|
if ((pqSet->lpBlob!=NULL) &&
|
|
(pqSet->lpBlob->pBlobData!=NULL) &&
|
|
(((LPNLA_BLOB)pqSet->lpBlob->pBlobData)->header.type==NLA_INTERFACE) ) {
|
|
#if DBG
|
|
dprintf (" type:%ld, speed:%ld, name: %s\n",
|
|
((LPNLA_BLOB)pqSet->lpBlob->pBlobData)->data.interfaceData.dwType,
|
|
((LPNLA_BLOB)pqSet->lpBlob->pBlobData)->data.interfaceData.dwSpeed,
|
|
((LPNLA_BLOB)pqSet->lpBlob->pBlobData)->data.interfaceData.adapterName);
|
|
#endif
|
|
changed = TRUE;
|
|
}
|
|
}
|
|
else {
|
|
error = GetLastError ();
|
|
INET_ASSERT (error!=NO_ERROR);
|
|
if (error==WSAEFAULT) {
|
|
|
|
INET_ASSERT (qSize<retSize);
|
|
|
|
//
|
|
// Not enough space for query results.
|
|
// Allocate whatever is requested.
|
|
// First free what we have know is necessary.
|
|
//
|
|
if (pqSet!=NULL && pqSet!=&q.set) {
|
|
FREE_MEMORY (pqSet);
|
|
}
|
|
pqSet = (LPWSAQUERYSETW)ALLOCATE_MEMORY (LMEM_FIXED, retSize);
|
|
if (pqSet!=NULL) {
|
|
qSize = retSize;
|
|
error = NO_ERROR;
|
|
}
|
|
else {
|
|
DEBUG_PRINT (PROXY, ERROR,
|
|
("NLA - Failed to allocate %ld bytes for query\n",
|
|
retSize));
|
|
#if DBG
|
|
dprintf
|
|
("NLA - Failed to allocate %ld bytes for query\n",
|
|
retSize);
|
|
#endif
|
|
error = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
while ( error==NO_ERROR );
|
|
|
|
if (error == WSA_E_NO_MORE) {
|
|
WSACOMPLETION wsacmpl;
|
|
DWORD count;
|
|
|
|
//
|
|
// This is expected error indicating that we got all that
|
|
// was available at the moment. Set up new notification.
|
|
//
|
|
wsacmpl.Type = NSP_NOTIFY_EVENT;
|
|
wsacmpl.Parameters.Event.lpOverlapped = &_ovlp;
|
|
error = _I_WSANSPIoctl (_hLookup, SIO_NSP_NOTIFY_CHANGE, NULL, 0, NULL, 0, &count, &wsacmpl);
|
|
if (error!=SOCKET_ERROR) {
|
|
//
|
|
// Something has changed, we need to enumerate again.
|
|
//
|
|
INET_ASSERT (error==NO_ERROR);
|
|
#if DBG
|
|
dprintf ("NLA notification signaled immediately");
|
|
#endif
|
|
}
|
|
else {
|
|
//
|
|
// Failure, get the error and get out.
|
|
//
|
|
error = GetLastError ();
|
|
INET_ASSERT (error!=NO_ERROR);
|
|
}
|
|
}
|
|
}
|
|
while (error==NO_ERROR);
|
|
|
|
if (pqSet!=NULL && pqSet!=&q.set) {
|
|
FREE_MEMORY (pqSet);
|
|
}
|
|
else {
|
|
INET_ASSERT (qSize==sizeof (q));
|
|
}
|
|
|
|
if (error!=WSA_IO_PENDING) {
|
|
DEBUG_PRINT (PROXY, ERROR,
|
|
("NLA - Failed to setup notification, error: %ld\n",
|
|
error));
|
|
#if DBG
|
|
dprintf (
|
|
"NLA - Failed to setup notification, error: %ld\n",
|
|
error);
|
|
#endif
|
|
//
|
|
// Error other then pending means that we failed.
|
|
// Cleanup everything - query will get recreated
|
|
// next time someone asks for changes.
|
|
//
|
|
CloseHandle (_ovlp.hEvent);
|
|
_ovlp.hEvent = NULL;
|
|
_I_WSALookupServiceEnd (_hLookup);
|
|
_hLookup = NULL;
|
|
//
|
|
// Remember when we failed, so we do not retry very often.
|
|
//
|
|
_lastInitAttempt = GetTickCountWrap ();
|
|
}
|
|
|
|
|
|
return changed;
|
|
}
|
|
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::DoThreadProcessing(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Main function for the auto-proxy thread, maintains a generic loop
|
|
that dispatchs events/messages sent to our thread for processing
|
|
|
|
Arguments:
|
|
|
|
none.
|
|
|
|
Return Value:
|
|
|
|
none.
|
|
|
|
--*/
|
|
{
|
|
DWORD error = ERROR_SUCCESS;
|
|
LPINTERNET_THREAD_INFO lpThreadInfo;
|
|
HANDLE EventArray[2];
|
|
NLA_NET_CHANGE nlaChange;
|
|
BOOLEAN needRefresh;
|
|
|
|
EventArray[0] = _hAutoProxyThreadEvent;
|
|
|
|
INET_ASSERT(IsOnAsyncAutoProxyThread());
|
|
INET_ASSERT(_hAutoProxyStartEvent);
|
|
|
|
SetEvent(_hAutoProxyStartEvent);
|
|
|
|
lpThreadInfo = InternetGetThreadInfo();
|
|
|
|
if (lpThreadInfo == NULL) {
|
|
error = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto quit;
|
|
}
|
|
|
|
//
|
|
// Mark ourselves as the Auto-proxy thread...
|
|
//
|
|
|
|
_InternetSetAutoProxy(lpThreadInfo);
|
|
|
|
while ( TRUE )
|
|
{
|
|
BOOLEAN networkChanged;
|
|
//
|
|
// 1. Check for shut down.
|
|
//
|
|
|
|
if ( _fInAutoProxyThreadShutDown )
|
|
{
|
|
SafeThreadShutdown(GlobalDynaUnload);
|
|
}
|
|
|
|
|
|
//
|
|
// 2. Check for timer causing a refresh of registry settings
|
|
// and network location changes,
|
|
// thus causing a redownload of settings
|
|
// Be carefull to call both functions since they have side-effects.
|
|
//
|
|
|
|
needRefresh = nlaChange.IsNetChanged ();
|
|
needRefresh = ChkForAndUpdateTimerCounter() || needRefresh;
|
|
if (needRefresh)
|
|
{
|
|
|
|
//
|
|
// Finally, start a download of the new stuff.
|
|
//
|
|
|
|
error = StartDownloadOfProxyInfo(FALSE /*full refresh*/);
|
|
}
|
|
|
|
//
|
|
// 3. Wait for new messages to come in,
|
|
// for shutdown we should pass right past it
|
|
//
|
|
|
|
|
|
error = WaitForMultipleObjects(
|
|
(EventArray[1]=nlaChange.GetChangeEvent())==NULL ? 1 : 2,
|
|
EventArray,
|
|
FALSE,
|
|
_dwWaitTimeOut
|
|
);
|
|
if (error==WAIT_OBJECT_0+1) {
|
|
//
|
|
// NLA change identified, skip processing, just redownload.
|
|
//
|
|
#if DBG
|
|
dprintf ("NLA change event signalled\n");
|
|
#endif
|
|
continue;
|
|
}
|
|
|
|
|
|
//
|
|
// 4. Check to see if we're ready to shut down the thread,
|
|
// due to a process termination or whatnot.
|
|
//
|
|
|
|
if ( _fInAutoProxyThreadShutDown )
|
|
{
|
|
SafeThreadShutdown(TRUE);
|
|
}
|
|
|
|
GlobalProxyInfo.CheckForExpiredEntries();
|
|
|
|
//
|
|
// 5. If we've idled let us shut down until we're needed again
|
|
//
|
|
|
|
//
|
|
// BUGBUG [arthurbi] Theoredically this should work,
|
|
// and the thread should shutdown on idle, too risky?
|
|
//
|
|
|
|
//if ( error == WAIT_FAILED && GetLastError() == WAIT_TIMEOUT)
|
|
//{
|
|
//SafeThreadShutdown(FALSE);
|
|
//}
|
|
|
|
//
|
|
// 6. Walk and process the list the messages to our thread asking for
|
|
// information or reinitalization
|
|
//
|
|
|
|
error = ProcessAsyncAutoProxyRequest();
|
|
|
|
INET_ASSERT( (error == ERROR_INTERNET_SHUTDOWN) ? _fInAutoProxyThreadShutDown : TRUE );
|
|
}
|
|
|
|
quit:
|
|
|
|
return error;
|
|
}
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::ProcessAsyncAutoProxyRequest(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Walks the list of queued messages and processes them one by one by
|
|
either rerunning the download/initalization or executing a query for
|
|
proxy information
|
|
|
|
Arguments:
|
|
|
|
none.
|
|
|
|
Return Value:
|
|
|
|
none.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
DWORD error = ERROR_SUCCESS;
|
|
BOOL fForceRefresh;
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Dword,
|
|
"AUTO_PROXY_DLLS::ProcessAsyncAutoProxyRequest",
|
|
""
|
|
));
|
|
|
|
while (!IsSerializedListEmpty(&_AsyncQueueList)) {
|
|
|
|
//
|
|
// If we're shuting down, then quit right away
|
|
//
|
|
|
|
if ( _fInAutoProxyThreadShutDown )
|
|
{
|
|
error = ERROR_INTERNET_SHUTDOWN;
|
|
goto quit;
|
|
|
|
}
|
|
|
|
LPVOID entry = SlDequeueHead(&_AsyncQueueList);
|
|
AUTO_PROXY_ASYNC_MSG *pQueryForInfo =
|
|
CONTAINING_RECORD(entry, AUTO_PROXY_ASYNC_MSG, _List);
|
|
|
|
|
|
//
|
|
// If the request has been unblocked, then destroy
|
|
// the request. ( this is typically due to cancel )
|
|
//
|
|
|
|
if ( pQueryForInfo->IsBlockUntilCompletetion() )
|
|
{
|
|
DWORD dwBlockCnt;
|
|
|
|
if ( pQueryForInfo->IsBlockedOnFsm() )
|
|
{
|
|
|
|
dwBlockCnt = CheckForBlockedWorkItems(
|
|
1,
|
|
(DWORD_PTR) pQueryForInfo // blocked on message
|
|
);
|
|
|
|
if ( dwBlockCnt == 0 )
|
|
{
|
|
delete pQueryForInfo;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
switch ( pQueryForInfo->QueryForInfoMessage() )
|
|
{
|
|
case PROXY_MSG_INIT:
|
|
|
|
fForceRefresh = pQueryForInfo->IsForceRefresh();
|
|
|
|
//
|
|
// First peak ahead to make sure we're not asked to download
|
|
// the same darn thing over and over again.
|
|
//
|
|
|
|
while (!IsSerializedListEmpty(&_AsyncQueueList))
|
|
{
|
|
|
|
LPVOID entry = SlDequeueHead(&_AsyncQueueList);
|
|
AUTO_PROXY_ASYNC_MSG *pQueryForInfo =
|
|
CONTAINING_RECORD(entry, AUTO_PROXY_ASYNC_MSG, _List);
|
|
|
|
if ( pQueryForInfo->QueryForInfoMessage() == PROXY_MSG_INIT )
|
|
{
|
|
INET_ASSERT(!pQueryForInfo->IsBlockUntilCompletetion());
|
|
if ( pQueryForInfo->IsForceRefresh() ) {
|
|
fForceRefresh = TRUE;
|
|
}
|
|
delete pQueryForInfo;
|
|
}
|
|
else
|
|
{
|
|
InsertAtHeadOfSerializedList(&_AsyncQueueList, &pQueryForInfo->_List);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Finally, start a download of the new stuff.
|
|
//
|
|
|
|
if ( error == ERROR_SUCCESS )
|
|
{
|
|
error = StartDownloadOfProxyInfo(fForceRefresh);
|
|
}
|
|
|
|
if ( error == ERROR_INTERNET_SHUTDOWN )
|
|
{
|
|
goto quit;
|
|
}
|
|
|
|
break;
|
|
|
|
case PROXY_MSG_SELF_DESTRUCT:
|
|
|
|
//
|
|
// Destroy ourselves and AUTO_PROXY_DLLS object.
|
|
//
|
|
//
|
|
|
|
SafeThreadShutdown(TRUE);
|
|
|
|
INET_ASSERT(FALSE); // never returns...
|
|
|
|
break;
|
|
|
|
|
|
case PROXY_MSG_GET_PROXY_INFO:
|
|
|
|
//
|
|
// If we've been updated then we need refresh settings from
|
|
// the net.
|
|
//
|
|
|
|
if ( (_dwUpdatedProxySettingsVersion != _ProxySettings.dwCurrentSettingsVersion) )
|
|
{
|
|
error = StartDownloadOfProxyInfo(FALSE /* no full refresh*/);
|
|
}
|
|
|
|
|
|
//
|
|
// The strait call into GetProxyInfo
|
|
//
|
|
|
|
error = ProcessProxyQueryForInfo(
|
|
&pQueryForInfo
|
|
);
|
|
|
|
if ( error == ERROR_INTERNET_SHUTDOWN )
|
|
{
|
|
goto quit;
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
case PROXY_MSG_SET_BAD_PROXY:
|
|
case PROXY_MSG_DEINIT:
|
|
case PROXY_MSG_INVALID:
|
|
default:
|
|
|
|
INET_ASSERT(FALSE);
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Wake up the caller if they are blocking on this completeion
|
|
//
|
|
|
|
if ( pQueryForInfo->IsBlockUntilCompletetion() )
|
|
{
|
|
SignalAsyncRequestCompleted(pQueryForInfo); // the thread that gets woken up now owns the object
|
|
}
|
|
else
|
|
{
|
|
delete pQueryForInfo;
|
|
}
|
|
}
|
|
|
|
quit:
|
|
|
|
DEBUG_LEAVE(error);
|
|
|
|
return error;
|
|
}
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::SignalAsyncRequestCompleted(
|
|
IN AUTO_PROXY_ASYNC_MSG *pQueryForInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Notifies a blocked thread or FSM that we have completed its message based request and
|
|
it now can continue.
|
|
|
|
Arguments:
|
|
|
|
pQueryForInfo - the orginating request
|
|
|
|
Return Value:
|
|
|
|
none.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD dwCntUnBlocked;
|
|
|
|
INET_ASSERT ( pQueryForInfo );
|
|
|
|
if ( pQueryForInfo->IsBlockedOnFsm() )
|
|
{
|
|
dwCntUnBlocked = UnblockWorkItems(
|
|
1,
|
|
(DWORD_PTR) pQueryForInfo, // blocked on message
|
|
ERROR_SUCCESS,
|
|
TP_NO_PRIORITY_CHANGE
|
|
);
|
|
|
|
//
|
|
// If we were unable to unblock it, then we need to free it.
|
|
//
|
|
|
|
if ( dwCntUnBlocked == 0 )
|
|
{
|
|
delete pQueryForInfo;
|
|
pQueryForInfo = NULL;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
dwCntUnBlocked = SignalThreadOnEvent(
|
|
(DWORD_PTR) pQueryForInfo, // blocked on message
|
|
1, // should only be one item thats blocked by us
|
|
ERROR_SUCCESS
|
|
);
|
|
|
|
//if ( dwCntUnBlocked == 0 )
|
|
//{
|
|
// delete pQueryForInfo;
|
|
// pQueryForInfo = NULL;
|
|
//}
|
|
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
VOID
|
|
AUTO_PROXY_DLLS::WipeProxySettings(
|
|
LPINTERNET_PROXY_INFO_EX lpProxySettings
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Frees proxy settings
|
|
|
|
Arguments:
|
|
|
|
lpProxySettings - pointer to listing of proxy settings
|
|
|
|
Return Value:
|
|
|
|
none.
|
|
|
|
--*/
|
|
|
|
{
|
|
if ( lpProxySettings )
|
|
{
|
|
if ( lpProxySettings->lpszConnectionName ) {
|
|
FREE_MEMORY(lpProxySettings->lpszConnectionName);
|
|
}
|
|
|
|
if ( lpProxySettings->lpszProxy ) {
|
|
FREE_MEMORY(lpProxySettings->lpszProxy);
|
|
}
|
|
|
|
if ( lpProxySettings->lpszProxyBypass ) {
|
|
FREE_MEMORY(lpProxySettings->lpszProxyBypass);
|
|
}
|
|
|
|
if ( lpProxySettings->lpszLastKnownGoodAutoConfigUrl ) {
|
|
FREE_MEMORY(lpProxySettings->lpszLastKnownGoodAutoConfigUrl);
|
|
}
|
|
|
|
if (lpProxySettings->lpszAutoconfigUrl) {
|
|
FREE_MEMORY(lpProxySettings->lpszAutoconfigUrl);
|
|
}
|
|
|
|
if (lpProxySettings->lpszAutoconfigSecondaryUrl) {
|
|
FREE_MEMORY(lpProxySettings->lpszAutoconfigSecondaryUrl);
|
|
}
|
|
|
|
if (lpProxySettings->pdwDetectedInterfaceIp) {
|
|
FREE_MEMORY(lpProxySettings->pdwDetectedInterfaceIp);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::SetProxySettings(
|
|
IN LPINTERNET_PROXY_INFO_EX lpProxySettings,
|
|
IN BOOL fModifiedInProcess,
|
|
IN BOOL fAllowOverwrite
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Write Auto-proxy Settings on the current auto-proxy object,
|
|
this writes the settings into the object, but does not
|
|
refresh it.
|
|
|
|
Arguments:
|
|
|
|
lpProxySettings - List of new settings that we'd like to write
|
|
|
|
fAllowOverwrite - Allow update of the settings in the object even if the version counter
|
|
hasn't changed
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
ERROR_SUCCESS - if we have a valid proxy config
|
|
|
|
other-errors - if we were not able to make the settings
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
DWORD error = ERROR_SUCCESS;
|
|
BOOL fGoPending = FALSE;
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Dword,
|
|
"AUTO_PROXY_DLLS::SetProxySettings",
|
|
"%x %B, %B",
|
|
lpProxySettings,
|
|
fModifiedInProcess,
|
|
fAllowOverwrite
|
|
));
|
|
|
|
LockAutoProxy();
|
|
|
|
if ( fAllowOverwrite ||
|
|
lpProxySettings->dwCurrentSettingsVersion == _ProxySettings.dwCurrentSettingsVersion )
|
|
{
|
|
BOOL fConnectionNameChange = FALSE;
|
|
|
|
_fModifiedInProcess = fModifiedInProcess;
|
|
|
|
UPDATE_GLOBAL_PROXY_VERSION();
|
|
|
|
//
|
|
// Check to see if we're changing the connection name,
|
|
// if so than this means we should plan on resetting
|
|
// the version below, so that we can redetect the new
|
|
// connection.
|
|
//
|
|
|
|
if ( ! IsConnectionMatch(
|
|
_ProxySettings.lpszConnectionName,
|
|
lpProxySettings->lpszConnectionName))
|
|
{
|
|
fConnectionNameChange = TRUE;
|
|
}
|
|
|
|
WipeProxySettings();
|
|
|
|
_ProxySettings = *lpProxySettings;
|
|
|
|
if ( fModifiedInProcess ) {
|
|
// update version, only if we don't plan to write out these settings
|
|
_ProxySettings.dwCurrentSettingsVersion++;
|
|
}
|
|
|
|
//
|
|
// minus -1 so that when we get to the auto-proxy thread,
|
|
// we can reload/detect or do what's needed to keep settings current
|
|
//
|
|
|
|
if ( _dwUpdatedProxySettingsVersion != _ProxySettings.dwCurrentSettingsVersion ||
|
|
_dwUpdatedProxySettingsVersion == 0 /* init state */ ||
|
|
fConnectionNameChange /* connection switch */ )
|
|
{
|
|
_dwUpdatedProxySettingsVersion = (DWORD) (_ProxySettings.dwCurrentSettingsVersion - 1);
|
|
fGoPending = TRUE;
|
|
}
|
|
|
|
//
|
|
// we shouldn't care about these settings,
|
|
// but we need to copy them anyway in
|
|
// case we save the stuff to the registry store
|
|
//
|
|
|
|
_ProxySettings.lpszProxy =
|
|
lpProxySettings->lpszProxy ?
|
|
NewString(lpProxySettings->lpszProxy) :
|
|
NULL;
|
|
|
|
_ProxySettings.lpszProxyBypass =
|
|
lpProxySettings->lpszProxyBypass ?
|
|
NewString(lpProxySettings->lpszProxyBypass) :
|
|
NULL;
|
|
|
|
_ProxySettings.lpszConnectionName =
|
|
lpProxySettings->lpszConnectionName ?
|
|
NewString(lpProxySettings->lpszConnectionName) :
|
|
NULL;
|
|
|
|
|
|
//
|
|
// Copy strings, cause we may be on another thread
|
|
//
|
|
|
|
_ProxySettings.lpszAutoconfigUrl =
|
|
lpProxySettings->lpszAutoconfigUrl ?
|
|
NewString(lpProxySettings->lpszAutoconfigUrl) :
|
|
NULL;
|
|
|
|
_ProxySettings.lpszAutoconfigSecondaryUrl =
|
|
lpProxySettings->lpszAutoconfigSecondaryUrl ?
|
|
NewString(lpProxySettings->lpszAutoconfigSecondaryUrl) :
|
|
NULL;
|
|
|
|
_ProxySettings.lpszLastKnownGoodAutoConfigUrl =
|
|
lpProxySettings->lpszLastKnownGoodAutoConfigUrl ?
|
|
NewString(lpProxySettings->lpszLastKnownGoodAutoConfigUrl) :
|
|
NULL;
|
|
|
|
//
|
|
// Copy of IP host addresses from last detection
|
|
//
|
|
|
|
if ( lpProxySettings->dwDetectedInterfaceIpCount > 0 &&
|
|
lpProxySettings->pdwDetectedInterfaceIp != NULL )
|
|
{
|
|
_ProxySettings.pdwDetectedInterfaceIp = (LPDWORD)
|
|
ALLOCATE_MEMORY(LMEM_FIXED, lpProxySettings->dwDetectedInterfaceIpCount
|
|
* sizeof(DWORD));
|
|
|
|
if (_ProxySettings.pdwDetectedInterfaceIp == NULL )
|
|
{
|
|
error = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto quit;
|
|
}
|
|
|
|
memcpy(_ProxySettings.pdwDetectedInterfaceIp, lpProxySettings->pdwDetectedInterfaceIp,
|
|
lpProxySettings->dwDetectedInterfaceIpCount * sizeof(DWORD));
|
|
}
|
|
|
|
|
|
if (fGoPending &&
|
|
IsConfigValidForAutoProxyThread())
|
|
{
|
|
//
|
|
// Enable a forced refresh if the user orders it through the UI,
|
|
// for unknown new connections we don't block the user on auto-detect,
|
|
// since he didn't really order it
|
|
//
|
|
|
|
if ( IsStaticFallbackEnabled() ) {
|
|
SetState(AUTO_PROXY_PENDING);
|
|
} else {
|
|
SetState(AUTO_PROXY_BLOCKED);
|
|
}
|
|
}
|
|
}
|
|
|
|
quit:
|
|
|
|
UnlockAutoProxy();
|
|
|
|
DEBUG_LEAVE(error);
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::GetProxySettings(
|
|
OUT LPINTERNET_PROXY_INFO_EX lpProxySettings,
|
|
IN BOOL fCheckVersion
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Reads Auto-proxy Settings off the current auto-proxy object,
|
|
this allocates individual fields as needed to store the result
|
|
|
|
Arguments:
|
|
|
|
lpProxySettings - Returns the result of the auto-proxy settings
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
ERROR_SUCCESS - if we have a valid proxy config
|
|
|
|
other-errors - if we were not able to make the settings
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD error = ERROR_SUCCESS;
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Dword,
|
|
"AUTO_PROXY_DLLS::GetProxySettings",
|
|
"%x %B",
|
|
lpProxySettings
|
|
));
|
|
|
|
LockAutoProxy();
|
|
|
|
if ( fCheckVersion &&
|
|
lpProxySettings->dwCurrentSettingsVersion == _ProxySettings.dwCurrentSettingsVersion )
|
|
{
|
|
goto quit; // no change
|
|
}
|
|
|
|
|
|
*lpProxySettings = _ProxySettings;
|
|
|
|
//
|
|
// Copy strings, cause we may be on another thread
|
|
//
|
|
|
|
lpProxySettings->lpszProxy =
|
|
_ProxySettings.lpszProxy ?
|
|
NewString(_ProxySettings.lpszProxy) :
|
|
NULL;
|
|
|
|
lpProxySettings->lpszProxyBypass =
|
|
_ProxySettings.lpszProxyBypass ?
|
|
NewString(_ProxySettings.lpszProxyBypass) :
|
|
NULL;
|
|
|
|
lpProxySettings->lpszConnectionName =
|
|
_ProxySettings.lpszConnectionName ?
|
|
NewString(_ProxySettings.lpszConnectionName) :
|
|
NULL;
|
|
|
|
lpProxySettings->lpszAutoconfigUrl =
|
|
_ProxySettings.lpszAutoconfigUrl ?
|
|
NewString(_ProxySettings.lpszAutoconfigUrl) :
|
|
NULL;
|
|
|
|
lpProxySettings->lpszAutoconfigSecondaryUrl =
|
|
_ProxySettings.lpszAutoconfigSecondaryUrl ?
|
|
NewString(_ProxySettings.lpszAutoconfigSecondaryUrl) :
|
|
NULL;
|
|
|
|
lpProxySettings->lpszLastKnownGoodAutoConfigUrl =
|
|
_ProxySettings.lpszLastKnownGoodAutoConfigUrl ?
|
|
NewString(_ProxySettings.lpszLastKnownGoodAutoConfigUrl) :
|
|
NULL;
|
|
|
|
//
|
|
// Copy of IP host addresses from last detection
|
|
//
|
|
|
|
if ( _ProxySettings.dwDetectedInterfaceIpCount > 0 &&
|
|
_ProxySettings.pdwDetectedInterfaceIp != NULL )
|
|
{
|
|
lpProxySettings->pdwDetectedInterfaceIp = (LPDWORD)
|
|
ALLOCATE_MEMORY(LMEM_FIXED, _ProxySettings.dwDetectedInterfaceIpCount
|
|
* sizeof(DWORD));
|
|
|
|
if (lpProxySettings->pdwDetectedInterfaceIp == NULL )
|
|
{
|
|
error = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto quit;
|
|
}
|
|
|
|
memcpy(lpProxySettings->pdwDetectedInterfaceIp, _ProxySettings.pdwDetectedInterfaceIp,
|
|
_ProxySettings.dwDetectedInterfaceIpCount * sizeof(DWORD));
|
|
}
|
|
|
|
quit:
|
|
|
|
UnlockAutoProxy();
|
|
|
|
DEBUG_LEAVE(error);
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::RefreshProxySettings(
|
|
IN BOOL fForceRefresh
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Syncronizes the Auto-Proxy engine with the state of the various settings,
|
|
and updates the various state keepers of the results.
|
|
|
|
- If there is no proxy settings, or auto-proxy is not needed or not detected,
|
|
we disable the auto-proxy system.
|
|
|
|
- If we have auto-proxy information or need to detect for some, then we fire up
|
|
the auto-proxy thread and send it a message to initalize itself.
|
|
|
|
Arguments:
|
|
|
|
none.
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
ERROR_SUCCESS - success
|
|
|
|
Win32 Error code - failure
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
DWORD error = ERROR_SUCCESS;
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Dword,
|
|
"AUTO_PROXY_DLLS::RefreshProxySettings",
|
|
"%B",
|
|
fForceRefresh
|
|
));
|
|
|
|
LockAutoProxy();
|
|
|
|
if (! IsOnAsyncAutoProxyThread() )
|
|
{
|
|
AUTO_PROXY_ASYNC_MSG *pQueryForInfo;
|
|
|
|
error = _Error;
|
|
if ( error != ERROR_SUCCESS)
|
|
{
|
|
goto quit; // obj is not initalized properly
|
|
}
|
|
|
|
if (!IsConfigValidForAutoProxyThread() )
|
|
{
|
|
goto quit; // disable & bail, we're not setup for this
|
|
}
|
|
|
|
pQueryForInfo = new AUTO_PROXY_ASYNC_MSG(PROXY_MSG_INIT);
|
|
|
|
if (pQueryForInfo == NULL )
|
|
{
|
|
error = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto quit;
|
|
}
|
|
|
|
//
|
|
// Enabled a forced refresh if the user orders it through the UI,
|
|
// for unknown new connections we don't block the user on auto-detect,
|
|
// since he didn't really order it
|
|
//
|
|
|
|
pQueryForInfo->SetForceRefresh(fForceRefresh);
|
|
|
|
if ( !fForceRefresh && IsStaticFallbackEnabled() ) {
|
|
SetState(AUTO_PROXY_PENDING);
|
|
} else {
|
|
SetState(AUTO_PROXY_BLOCKED);
|
|
}
|
|
|
|
error = QueueAsyncAutoProxyRequest(
|
|
&pQueryForInfo // don't worry, this request won't block us.
|
|
);
|
|
}
|
|
|
|
quit:
|
|
|
|
if ( error != ERROR_SUCCESS &&
|
|
error != ERROR_IO_PENDING )
|
|
{
|
|
SetState(AUTO_PROXY_DISABLED); // disable in case something critical happens
|
|
}
|
|
|
|
UnlockAutoProxy();
|
|
|
|
DEBUG_LEAVE(error);
|
|
|
|
return error;
|
|
}
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::StartBackroundDetectionIfNeeded(
|
|
VOID
|
|
)
|
|
{
|
|
DWORD error = ERROR_SUCCESS;
|
|
|
|
LockAutoProxy();
|
|
if ( _hAutoProxyThread == NULL ) {
|
|
error = RefreshProxySettings(FALSE);
|
|
}
|
|
UnlockAutoProxy();
|
|
|
|
return error;
|
|
}
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::QueryProxySettings(
|
|
IN OUT AUTO_PROXY_ASYNC_MSG **ppQueryForInfo
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Performs a query for proxy information using auto-proxy to anwser our query.
|
|
|
|
Assumes this is not called from auto-proxy thread/
|
|
|
|
Arguments:
|
|
|
|
ppQueryForInfo - Pointer to pointer to Message object that contains state information
|
|
used in the query. If the object needs to be allocated on the heap
|
|
then the pointer will change to reflect the new object ptr.
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
Success - ERROR_SUCCESS
|
|
|
|
Failure -
|
|
|
|
--*/
|
|
|
|
{
|
|
AUTO_PROXY_LIST_ENTRY * papleAutoProxy;
|
|
DWORD error = ERROR_SUCCESS;
|
|
BOOL fUnlocked = FALSE;
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Dword,
|
|
"AUTO_PROXY_DLLS::QueryProxySettings",
|
|
"%x",
|
|
ppQueryForInfo
|
|
));
|
|
|
|
|
|
INET_ASSERT(ppQueryForInfo);
|
|
INET_ASSERT(*ppQueryForInfo);
|
|
INET_ASSERT((*ppQueryForInfo)->QueryForInfoMessage() == PROXY_MSG_GET_PROXY_INFO);
|
|
//INET_ASSERT(!IsOnAsyncAutoProxyThread());
|
|
|
|
LockAutoProxy();
|
|
|
|
//
|
|
// ALWAYS force this function to exec it auto-proxy calls on the
|
|
// async auto-proxy thread.
|
|
//
|
|
|
|
if ( IsAutoProxy() &&
|
|
!IsOnAsyncAutoProxyThread() &&
|
|
IsAutoProxyGetProxyInfoCallNeeded(*ppQueryForInfo))
|
|
{
|
|
if ( GetState() == AUTO_PROXY_PENDING )
|
|
{
|
|
|
|
//
|
|
// If we're doing a pending detection, then
|
|
// fallback to standby settings, and if we fail
|
|
// with standby settings, we should get re-called to here
|
|
// and if we're then still detecting, then
|
|
// we'll block on the detection result
|
|
//
|
|
|
|
if ( ! (*ppQueryForInfo)->IsBackroundDetectionPending() )
|
|
{
|
|
error = StartBackroundDetectionIfNeeded();
|
|
if (error != ERROR_SUCCESS ) {
|
|
goto quit;
|
|
}
|
|
(*ppQueryForInfo)->SetBackroundDetectionPending(TRUE);
|
|
if ( ! (*ppQueryForInfo)->IsAlloced() )
|
|
{
|
|
*ppQueryForInfo = new AUTO_PROXY_ASYNC_MSG(*ppQueryForInfo);
|
|
|
|
if ( *ppQueryForInfo == NULL ) {
|
|
error = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
}
|
|
goto quit;
|
|
}
|
|
}
|
|
else if (!(_ProxySettings.dwAutoDiscoveryFlags & AUTO_PROXY_FLAG_DONT_CACHE_PROXY_RESULT) &&
|
|
GlobalAutoProxyCacheEnable)
|
|
{
|
|
(*ppQueryForInfo)->SetCanCacheResult(TRUE);
|
|
}
|
|
|
|
//
|
|
// If we need to show indication during detection,
|
|
// then do so now before we block
|
|
//
|
|
|
|
if ( (*ppQueryForInfo)->IsShowIndication() &&
|
|
(GetState() == AUTO_PROXY_PENDING ||
|
|
GetState() == AUTO_PROXY_BLOCKED))
|
|
{
|
|
UnlockAutoProxy();
|
|
fUnlocked = TRUE;
|
|
|
|
InternetIndicateStatus(INTERNET_STATUS_DETECTING_PROXY, NULL, 0);
|
|
}
|
|
else
|
|
{
|
|
UnlockAutoProxy();
|
|
fUnlocked = TRUE;
|
|
}
|
|
|
|
// always disable unless we're ready to renter on a failure
|
|
(*ppQueryForInfo)->SetBackroundDetectionPending(FALSE);
|
|
|
|
error = QueueAsyncAutoProxyRequest(ppQueryForInfo);
|
|
goto quit;
|
|
}
|
|
|
|
// always disabled it unless we're ready to reenter on a failure
|
|
(*ppQueryForInfo)->SetBackroundDetectionPending(FALSE);
|
|
|
|
quit:
|
|
|
|
if ( !fUnlocked )
|
|
{
|
|
UnlockAutoProxy();
|
|
}
|
|
|
|
DEBUG_LEAVE(error);
|
|
|
|
return error;
|
|
}
|
|
|
|
BOOL
|
|
AUTO_PROXY_DLLS::IsConfigValidForAutoProxyThread(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Decide if we need the auto-thread to either download auto-proxy ot
|
|
go off and detect for auto-proxy on the network
|
|
|
|
Arguments:
|
|
|
|
none.
|
|
|
|
Return Value:
|
|
|
|
BOOL
|
|
TRUE - if we have a valid proxy config
|
|
|
|
FALSE - if we not valid
|
|
|
|
--*/
|
|
|
|
{
|
|
LPINTERNET_PROXY_INFO_EX lpProxySettings = &_ProxySettings;
|
|
|
|
if ( (lpProxySettings->dwFlags & PROXY_TYPE_AUTO_PROXY_URL) &&
|
|
lpProxySettings->lpszAutoconfigUrl != NULL &&
|
|
*lpProxySettings->lpszAutoconfigUrl != '\0' )
|
|
{
|
|
return TRUE; // old behavior for auto-proxy URL config
|
|
}
|
|
|
|
if ( IsProxyAutoDetectEnabled(lpProxySettings))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE; // do nothing
|
|
}
|
|
|
|
BOOL
|
|
AUTO_PROXY_DLLS::IsStaticFallbackEnabled(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Decide if we need to block on the auto-proxy information,
|
|
or if we can fallback to static settings when auto-proxy is initalizing/detecting.
|
|
|
|
Arguments:
|
|
|
|
none.
|
|
|
|
Return Value:
|
|
|
|
BOOL
|
|
TRUE - if we keep going with static settings
|
|
|
|
FALSE - we'll need to block requests until auto-proxy is intialized
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
if ( (_ProxySettings.dwFlags & PROXY_TYPE_AUTO_PROXY_URL) &&
|
|
_ProxySettings.lpszAutoconfigUrl != NULL &&
|
|
*_ProxySettings.lpszAutoconfigUrl != '\0' )
|
|
{
|
|
return FALSE; // block, don't bypass, this is old behavior for Auto-proxy URLs
|
|
}
|
|
|
|
if ( IsProxyAutoDetectEnabled() )
|
|
|
|
{
|
|
if ( !(_ProxySettings.dwAutoDiscoveryFlags & (AUTO_PROXY_FLAG_DETECTION_RUN | AUTO_PROXY_FLAG_USER_SET)) ) {
|
|
return TRUE; // detection SHOULD NOT BLOCK THE FIRST TIME, in case it doesn't work
|
|
}
|
|
|
|
if ( _ProxySettings.lpszConnectionName != NULL )
|
|
{
|
|
if ( _ProxySettings.lpszLastKnownGoodAutoConfigUrl == NULL )
|
|
{
|
|
return TRUE; // detection SHOULD NOT BE DEPENDED upon with Dialup, unless it has something
|
|
}
|
|
|
|
if ( _ProxySettings.dwAutoDiscoveryFlags & AUTO_PROXY_FLAG_DETECTION_SUSPECT)
|
|
{
|
|
return TRUE; // detection should not block when we're in a hosed state.
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
return FALSE; // block
|
|
}
|
|
|
|
VOID
|
|
AUTO_PROXY_DLLS::SetExpiredUrl(
|
|
LPCSTR lpszUrl
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sets default expiry time on the if none is specified on the cached URL.
|
|
|
|
Arguments:
|
|
|
|
lpszUrl -
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
ERROR_SUCCESS - success
|
|
|
|
Win32 Error code - failure
|
|
|
|
--*/
|
|
{
|
|
CACHE_ENTRY_INFOEX Cei;
|
|
DWORD dwCeiSize = sizeof(INTERNET_CACHE_ENTRY_INFOA);
|
|
BOOL fRet;
|
|
|
|
fRet = GetUrlCacheEntryInfoExA(
|
|
lpszUrl,
|
|
(INTERNET_CACHE_ENTRY_INFOA *) &Cei,
|
|
&dwCeiSize,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
INTERNET_CACHE_FLAG_GET_STRUCT_ONLY
|
|
);
|
|
|
|
|
|
if ( fRet &&
|
|
(FT2LL(Cei.ExpireTime) == LONGLONG_ZERO))
|
|
{
|
|
//
|
|
// Set default expiry as: current time + some default expiry
|
|
//
|
|
|
|
GetCurrentGmtTime(&Cei.ExpireTime);
|
|
|
|
*(LONGLONG *) &(Cei.ExpireTime) += (12 * (24 * ONE_HOUR_DELTA));
|
|
|
|
//
|
|
// Re-Save Cache entry with updated default expiry time for PAC/INS file.
|
|
//
|
|
|
|
SetUrlCacheEntryInfoA(
|
|
lpszUrl,
|
|
(INTERNET_CACHE_ENTRY_INFOA *) &Cei,
|
|
CACHE_ENTRY_EXPTIME_FC
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
BOOL
|
|
AUTO_PROXY_DLLS::IsExpiredUrl(
|
|
LPCSTR lpszUrl
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Is Url Expired? If it isn't don't force a reload/update of data
|
|
|
|
Arguments:
|
|
|
|
lpszUrl -
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
ERROR_SUCCESS - success
|
|
|
|
Win32 Error code - failure
|
|
|
|
--*/
|
|
{
|
|
CACHE_ENTRY_INFOEX Cei;
|
|
DWORD dwCeiSize = sizeof(INTERNET_CACHE_ENTRY_INFOA);
|
|
BOOL fRet;
|
|
|
|
fRet = GetUrlCacheEntryInfoExA(
|
|
lpszUrl,
|
|
(INTERNET_CACHE_ENTRY_INFOA *) &Cei,
|
|
&dwCeiSize,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
INTERNET_CACHE_FLAG_GET_STRUCT_ONLY
|
|
);
|
|
|
|
if (!fRet) {
|
|
return TRUE; // expired, not in the cache
|
|
}
|
|
|
|
if ( IsExpired(&Cei, 0, &fRet) )
|
|
{
|
|
return TRUE; // expired, like really it is
|
|
}
|
|
|
|
return FALSE; // not expired
|
|
}
|
|
|
|
|
|
BOOL
|
|
AUTO_PROXY_DLLS::IsProxyAutoDetectNeeded(
|
|
LPINTERNET_PROXY_INFO_EX lpProxySettings
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Detects whether we need to actually run a detection on the network,
|
|
or whether we can resuse current results from previous runs
|
|
|
|
Arguments:
|
|
|
|
lpProxySettings - structure to fill
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
ERROR_SUCCESS - success
|
|
|
|
Win32 Error code - failure
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD addressCount;
|
|
LPDWORD * addressList;
|
|
LPHOSTENT lpHostent;
|
|
BOOL fSuspectBadDetect = FALSE;
|
|
|
|
INET_ASSERT(IsProxyAutoDetectEnabled(lpProxySettings));
|
|
|
|
// we haven't detected before on this connection, so we need to do it.
|
|
if ( !(lpProxySettings->dwAutoDiscoveryFlags & AUTO_PROXY_FLAG_DETECTION_RUN) ) {
|
|
return TRUE; // detect needed
|
|
}
|
|
|
|
// if we're flagged to ALWAYS force detection, then do this
|
|
if (lpProxySettings->dwAutoDiscoveryFlags & AUTO_PROXY_FLAG_ALWAYS_DETECT) {
|
|
return TRUE; // detect needed
|
|
}
|
|
|
|
//
|
|
// Check for an expired detected Url, detect it its expired
|
|
// Since this is RAS we can't rely on the host IP staying
|
|
// the same everytime.
|
|
//
|
|
|
|
if ( lpProxySettings->lpszLastKnownGoodAutoConfigUrl &&
|
|
lpProxySettings->lpszConnectionName &&
|
|
! IsExpiredUrl(lpProxySettings->lpszLastKnownGoodAutoConfigUrl))
|
|
{
|
|
// if we're suspecting bad settings, make sure to redirect.
|
|
if ( ! (lpProxySettings->dwAutoDiscoveryFlags & AUTO_PROXY_FLAG_DETECTION_SUSPECT) ) {
|
|
return FALSE;
|
|
}
|
|
|
|
//otherwise, we'll be careful
|
|
fSuspectBadDetect = TRUE;
|
|
}
|
|
|
|
//
|
|
// Check for IP addresses that no longer match, indicating a network change
|
|
//
|
|
|
|
__try
|
|
{
|
|
lpHostent = _I_gethostbyname(NULL);
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
g_fGetHostByNameNULLFails = TRUE;
|
|
lpHostent = NULL;
|
|
}
|
|
ENDEXCEPT
|
|
|
|
if (lpHostent &&
|
|
lpProxySettings->pdwDetectedInterfaceIp == NULL)
|
|
{
|
|
return TRUE; // detect needed, no current IPs saved from last run
|
|
}
|
|
|
|
if ( lpHostent != NULL &&
|
|
lpProxySettings->pdwDetectedInterfaceIp != NULL)
|
|
{
|
|
|
|
for ( addressCount = 0;
|
|
lpHostent->h_addr_list[addressCount] != NULL;
|
|
addressCount++ ); // gather count
|
|
|
|
if ( addressCount != lpProxySettings->dwDetectedInterfaceIpCount ) {
|
|
return TRUE; // detect needed, the IP count is different
|
|
}
|
|
|
|
if ( fSuspectBadDetect) {
|
|
return FALSE; // detect NOT needed, because the IP addresses may change from dialup/to dialup
|
|
}
|
|
|
|
for (DWORD i = 0; i < addressCount; i++)
|
|
{
|
|
//dwAddress[iCount] = *((LPDWORD)(ph->h_addr_list[iCount]));
|
|
|
|
if ( *((LPDWORD)(lpHostent->h_addr_list[i])) != lpProxySettings->pdwDetectedInterfaceIp[i] ) {
|
|
return TRUE; // detect needed, mismatched values
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return FALSE; // default, do not need to redetect
|
|
}
|
|
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::GetHostAddresses(
|
|
DWORD ** ppdwDetectedInterfaceIp,
|
|
DWORD * pdwDetectedInterfaceIpCount
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Copies out the current host information into an
|
|
a array/ProxyInfoStruct for later comparision.
|
|
|
|
Arguments:
|
|
|
|
lpProxySettings - structure to fill
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
ERROR_SUCCESS - success
|
|
|
|
Win32 Error code - failure
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD addressCount;
|
|
LPDWORD * addressList;
|
|
LPHOSTENT lpHostent;
|
|
DWORD error = ERROR_SUCCESS;
|
|
|
|
*pdwDetectedInterfaceIpCount = 0;
|
|
|
|
if ( *ppdwDetectedInterfaceIp )
|
|
{
|
|
FREE_MEMORY(*ppdwDetectedInterfaceIp);
|
|
*ppdwDetectedInterfaceIp = NULL;
|
|
}
|
|
|
|
//
|
|
// Gather IP addresses and start copying them over
|
|
//
|
|
|
|
__try
|
|
{
|
|
lpHostent = _I_gethostbyname(NULL);
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
g_fGetHostByNameNULLFails = TRUE;
|
|
lpHostent = NULL;
|
|
}
|
|
ENDEXCEPT
|
|
|
|
if (lpHostent == NULL ) {
|
|
goto quit;
|
|
}
|
|
|
|
for ( addressCount = 0;
|
|
lpHostent->h_addr_list[addressCount] != NULL;
|
|
addressCount++ ); // gather count
|
|
|
|
*ppdwDetectedInterfaceIp = (LPDWORD)
|
|
ALLOCATE_MEMORY(LMEM_FIXED, addressCount
|
|
* sizeof(DWORD));
|
|
|
|
if ( *ppdwDetectedInterfaceIp == NULL )
|
|
{
|
|
error = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto quit;
|
|
}
|
|
|
|
if ( *ppdwDetectedInterfaceIp != NULL)
|
|
{
|
|
*pdwDetectedInterfaceIpCount = addressCount;
|
|
|
|
for (DWORD i = 0; i < addressCount; i++)
|
|
{
|
|
(*ppdwDetectedInterfaceIp)[i] =
|
|
*((LPDWORD)(lpHostent->h_addr_list[i]));
|
|
}
|
|
}
|
|
|
|
quit:
|
|
return error;
|
|
}
|
|
|
|
|
|
VOID
|
|
AUTO_PROXY_DLLS::FreeAutoProxyInfo(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Attempts to shutdown the auto-proxy thread (from outside of it), by first signalling
|
|
it with an event and boolean, and then if that fails, forcibly forcing a shutdown
|
|
with TerminateThread.
|
|
|
|
Arguments:
|
|
|
|
none.
|
|
|
|
Return Value:
|
|
|
|
none.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD dwError;
|
|
|
|
LockAutoProxy();
|
|
|
|
if ( _hAutoProxyThread != NULL &&
|
|
! IsOnAsyncAutoProxyThread() )
|
|
{
|
|
HANDLE hAutoProxyThread;
|
|
BOOL fAlreadyInShutDown;
|
|
|
|
fAlreadyInShutDown =
|
|
InterlockedExchange((LPLONG)&_fInAutoProxyThreadShutDown, TRUE);
|
|
|
|
INET_ASSERT ( ! fAlreadyInShutDown );
|
|
|
|
SetEvent(_hAutoProxyThreadEvent);
|
|
|
|
if ( _hInternetAbortHandle != NULL )
|
|
{
|
|
InternetCloseHandle(_hInternetAbortHandle);
|
|
}
|
|
|
|
hAutoProxyThread = _hAutoProxyThread;
|
|
|
|
UnlockAutoProxy();
|
|
|
|
//
|
|
// Wait for shutdown of auto-proxy thread.
|
|
//
|
|
|
|
if ( hAutoProxyThread )
|
|
{
|
|
dwError = WaitForSingleObject(hAutoProxyThread,
|
|
GlobalIsProcessNtService? INFINITE : 60000);
|
|
|
|
if ( dwError != WAIT_OBJECT_0 )
|
|
{
|
|
INET_ASSERT(FALSE);
|
|
// Whistler bug #124628: delete the autoproxy critical section
|
|
// before terminating the autoproxy thread in case the thread
|
|
// is holding the CS.
|
|
SuspendThread(hAutoProxyThread);
|
|
DeleteCriticalSection(&_CritSec);
|
|
|
|
// reinitialize cs since it will be deleted in the destructor
|
|
memset((LPVOID) &_CritSec, 0, sizeof(CRITICAL_SECTION));
|
|
InitializeCriticalSection(&_CritSec);
|
|
|
|
TerminateThread(hAutoProxyThread,ERROR_SUCCESS);
|
|
|
|
_hAutoProxyThreadEvent = NULL;
|
|
_hAutoProxyThread = NULL;
|
|
|
|
InterlockedExchange((LPLONG)&_fInAutoProxyThreadShutDown, FALSE);
|
|
return;
|
|
}
|
|
}
|
|
|
|
LockAutoProxy();
|
|
|
|
CloseHandle(_hAutoProxyThread);
|
|
CloseHandle(_hAutoProxyThreadEvent);
|
|
|
|
_hAutoProxyThreadEvent = NULL;
|
|
_hAutoProxyThread = NULL;
|
|
|
|
InterlockedExchange((LPLONG)&_fInAutoProxyThreadShutDown, FALSE);
|
|
|
|
UnlockAutoProxy();
|
|
}
|
|
else
|
|
{
|
|
UnlockAutoProxy();
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
AUTO_PROXY_LIST_ENTRY::ProxyInfoInvalid(
|
|
IN LPSTR lpszMime,
|
|
IN LPSTR lpszUrl,
|
|
IN DWORD dwUrlLength,
|
|
IN LPSTR lpszProxyHostName,
|
|
IN DWORD dwProxyHostNameLength
|
|
)
|
|
{
|
|
BOOL success = TRUE; // don't care if it doesn't succeed
|
|
|
|
if ( ! _hAutoConfigDLL )
|
|
{
|
|
if ( LoadEntry() != ERROR_SUCCESS )
|
|
return FALSE;
|
|
}
|
|
|
|
if ( ! _fInitializedSuccessfully )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( _pProxyInfoInvalid )
|
|
{
|
|
|
|
INET_ASSERT(_hAutoConfigDLL);
|
|
INET_ASSERT(!IsBadCodePtr((FARPROC)_pProxyInfoInvalid));
|
|
|
|
success = (_pProxyInfoInvalid) ( lpszMime,
|
|
lpszUrl,
|
|
dwUrlLength,
|
|
lpszProxyHostName,
|
|
dwProxyHostNameLength
|
|
);
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
AUTO_PROXY_LIST_ENTRY::ProxyDllDeInit(
|
|
IN LPSTR lpszMime,
|
|
IN DWORD dwReserved
|
|
)
|
|
{
|
|
BOOL success = TRUE; // don't care if it doesn't succeed
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Bool,
|
|
"AUTO_PROXY_LIST_ENTRY::ProxyDllDeInit",
|
|
"%s, %u",
|
|
lpszMime,
|
|
dwReserved
|
|
));
|
|
|
|
|
|
INET_ASSERT(_hAutoConfigDLL);
|
|
|
|
if ( !_hAutoConfigDLL )
|
|
{
|
|
DEBUG_LEAVE(FALSE);
|
|
return FALSE;
|
|
}
|
|
|
|
if ( ! _fInitializedSuccessfully )
|
|
{
|
|
DEBUG_LEAVE(FALSE);
|
|
return FALSE;
|
|
}
|
|
|
|
if ( _pProxyDllDeInit )
|
|
{
|
|
|
|
INET_ASSERT(_hAutoConfigDLL);
|
|
INET_ASSERT(!IsBadCodePtr((FARPROC)_pProxyDllDeInit));
|
|
#ifdef INET_DEBUG
|
|
INET_ASSERT(!_fUnInited);
|
|
|
|
_fUnInited = TRUE;
|
|
#endif
|
|
|
|
success = (_pProxyDllDeInit) ( lpszMime,
|
|
dwReserved
|
|
);
|
|
}
|
|
|
|
DEBUG_LEAVE(success);
|
|
return success;
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
AUTO_PROXY_LIST_ENTRY::GetProxyInfoEx(
|
|
IN AUTO_PROXY_ASYNC_MSG *pQueryForProxyInfo
|
|
)
|
|
{
|
|
BOOL success = FALSE;
|
|
DWORD error = ERROR_SUCCESS;
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Dword,
|
|
"AUTO_PROXY_LIST_ENTRY::GetProxyInfoEx",
|
|
"%x [%s, %s, %u, %s, %d, %x, %x]",
|
|
pQueryForProxyInfo,
|
|
InternetMapScheme(pQueryForProxyInfo->_tUrlProtocol),
|
|
pQueryForProxyInfo->_lpszUrl,
|
|
pQueryForProxyInfo->_dwUrlLength,
|
|
pQueryForProxyInfo->_lpszUrlHostName,
|
|
pQueryForProxyInfo->_dwUrlHostNameLength,
|
|
pQueryForProxyInfo->_lpszProxyHostName,
|
|
&pQueryForProxyInfo->_dwProxyHostNameLength
|
|
));
|
|
|
|
//if ( ! _hAutoConfigDLL )
|
|
//{
|
|
// if ( LoadEntry() != ERROR_SUCCESS )
|
|
// {
|
|
// DEBUG_LEAVE(FALSE);
|
|
// return FALSE;
|
|
// }
|
|
//}
|
|
|
|
if ( ! _fInitializedSuccessfully )
|
|
{
|
|
DEBUG_LEAVE(FALSE);
|
|
error = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto quit;
|
|
}
|
|
|
|
INET_ASSERT(_hAutoConfigDLL);
|
|
INET_ASSERT(_pGetProxyInfoEx);
|
|
INET_ASSERT(!IsBadCodePtr((FARPROC)_pGetProxyInfoEx));
|
|
|
|
success = (_pGetProxyInfoEx) ( pQueryForProxyInfo->_tUrlProtocol,
|
|
pQueryForProxyInfo->_lpszUrl,
|
|
pQueryForProxyInfo->_dwUrlLength,
|
|
pQueryForProxyInfo->_lpszUrlHostName,
|
|
pQueryForProxyInfo->_dwUrlHostNameLength,
|
|
pQueryForProxyInfo->_nUrlPort,
|
|
&(pQueryForProxyInfo->_tProxyScheme),
|
|
&(pQueryForProxyInfo->_lpszProxyHostName),
|
|
&(pQueryForProxyInfo->_dwProxyHostNameLength),
|
|
&(pQueryForProxyInfo->_nProxyHostPort)
|
|
);
|
|
|
|
quit:
|
|
|
|
pQueryForProxyInfo->_dwQueryResult = (DWORD) success;
|
|
|
|
DEBUG_LEAVE(error);
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
AUTO_PROXY_LIST_ENTRY::GetProxyInfo(
|
|
IN AUTO_PROXY_ASYNC_MSG *pQueryForProxyInfo
|
|
)
|
|
{
|
|
BOOL success = FALSE;
|
|
DWORD error = ERROR_SUCCESS;
|
|
LPSTR lpszAutoProxyReturnInfo;
|
|
DWORD dwAutoProxyReturnInfoSize;
|
|
|
|
INET_ASSERT(pQueryForProxyInfo);
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Dword,
|
|
"AUTO_PROXY_LIST_ENTRY::GetProxyInfo",
|
|
"%x [%s, %u, %s, %d, %x, %x]",
|
|
pQueryForProxyInfo,
|
|
pQueryForProxyInfo->_lpszUrl,
|
|
pQueryForProxyInfo->_dwUrlLength,
|
|
pQueryForProxyInfo->_lpszUrlHostName,
|
|
pQueryForProxyInfo->_dwUrlHostNameLength,
|
|
pQueryForProxyInfo->_lpszProxyHostName,
|
|
&pQueryForProxyInfo->_dwProxyHostNameLength
|
|
));
|
|
|
|
//if ( ! _hAutoConfigDLL )
|
|
//{
|
|
// if ( LoadEntry() != ERROR_SUCCESS )
|
|
// {
|
|
// DEBUG_LEAVE(FALSE);
|
|
// return FALSE;
|
|
// }
|
|
//}
|
|
|
|
if ( ! _fInitializedSuccessfully )
|
|
{
|
|
DEBUG_LEAVE(FALSE);
|
|
error = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto quit;
|
|
}
|
|
|
|
INET_ASSERT ( _pGetProxyInfo );
|
|
INET_ASSERT(_hAutoConfigDLL);
|
|
INET_ASSERT(!IsBadCodePtr((FARPROC)_pGetProxyInfo));
|
|
|
|
success = (_pGetProxyInfo) ( pQueryForProxyInfo->_lpszUrl,
|
|
pQueryForProxyInfo->_dwUrlLength,
|
|
pQueryForProxyInfo->_lpszUrlHostName,
|
|
pQueryForProxyInfo->_dwUrlHostNameLength,
|
|
&lpszAutoProxyReturnInfo,
|
|
&dwAutoProxyReturnInfoSize
|
|
);
|
|
|
|
|
|
if ( success )
|
|
{
|
|
if ( pQueryForProxyInfo->_tUrlProtocol == INTERNET_SCHEME_HTTPS )
|
|
{
|
|
pQueryForProxyInfo->_tProxyScheme = INTERNET_SCHEME_HTTPS;
|
|
}
|
|
else
|
|
{
|
|
pQueryForProxyInfo->_tProxyScheme = INTERNET_SCHEME_HTTP;
|
|
}
|
|
|
|
INET_ASSERT(pQueryForProxyInfo->_pProxyState == NULL);
|
|
|
|
pQueryForProxyInfo->_pProxyState = new PROXY_STATE(lpszAutoProxyReturnInfo,
|
|
dwAutoProxyReturnInfoSize,
|
|
TRUE, // parse netscape-style proxy list
|
|
pQueryForProxyInfo->_tProxyScheme,
|
|
pQueryForProxyInfo->_nProxyHostPort
|
|
);
|
|
|
|
|
|
INET_ASSERT(lpszAutoProxyReturnInfo);
|
|
GlobalFree(lpszAutoProxyReturnInfo); // clean up jsproxy.dll return string
|
|
|
|
if ( pQueryForProxyInfo->_pProxyState == NULL )
|
|
{
|
|
error = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto quit;
|
|
}
|
|
|
|
error = pQueryForProxyInfo->_pProxyState->GetError();
|
|
|
|
if ( error != ERROR_SUCCESS )
|
|
{
|
|
goto quit;
|
|
}
|
|
}
|
|
|
|
|
|
quit:
|
|
|
|
pQueryForProxyInfo->_dwQueryResult = (DWORD) success;
|
|
|
|
DEBUG_LEAVE(error);
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
BOOL
|
|
AUTO_PROXY_LIST_ENTRY::ProxyDllInit (
|
|
IN DWORD dwVersion,
|
|
IN LPSTR lpszDownloadedTempFile,
|
|
IN LPSTR lpszMime,
|
|
IN AUTO_PROXY_HELPER_APIS *pAutoProxyCallbacks,
|
|
IN DWORD_PTR dwReserved
|
|
)
|
|
{
|
|
BOOL success = FALSE;
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Bool,
|
|
"AUTO_PROXY_LIST_ENTRY::ProxyDllInit",
|
|
"%u, %s, %s, %x, %u",
|
|
dwVersion,
|
|
lpszDownloadedTempFile,
|
|
lpszMime,
|
|
pAutoProxyCallbacks,
|
|
dwReserved
|
|
));
|
|
|
|
|
|
INET_ASSERT ( _hAutoConfigDLL );
|
|
|
|
if ( _pProxyDllInit )
|
|
{
|
|
|
|
INET_ASSERT(_hAutoConfigDLL);
|
|
INET_ASSERT(!IsBadCodePtr((FARPROC)_pProxyDllInit));
|
|
|
|
success = (_pProxyDllInit) ( dwVersion,
|
|
lpszDownloadedTempFile,
|
|
lpszMime,
|
|
pAutoProxyCallbacks,
|
|
dwReserved
|
|
);
|
|
|
|
#ifdef INET_DEBUG
|
|
_fUnInited = FALSE;
|
|
#endif
|
|
_fInitializedSuccessfully = success;
|
|
|
|
}
|
|
|
|
DEBUG_LEAVE(success);
|
|
return success;
|
|
}
|
|
|
|
VOID
|
|
AUTO_PROXY_LIST_ENTRY::UnloadEntry(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Unloads the DLL function entry points for an Auto-Proxy DLL.
|
|
|
|
WARNING: Must be called only on Auto-proxy thread context!
|
|
|
|
Arguments:
|
|
|
|
none.
|
|
|
|
Return Value:
|
|
|
|
none.
|
|
|
|
--*/
|
|
|
|
{
|
|
DEBUG_ENTER((DBG_OBJECTS,
|
|
None,
|
|
"AUTO_PROXY_LIST_ENTRY::UnloadEntry",
|
|
NULL
|
|
));
|
|
|
|
|
|
if ( _fInitializedSuccessfully &&
|
|
_pProxyDllDeInit )
|
|
{
|
|
ProxyDllDeInit(
|
|
_lpszMimeType,
|
|
0
|
|
);
|
|
}
|
|
|
|
if ( _hAutoConfigDLL )
|
|
{
|
|
// HACK HACK This call will block an dll unload time because of the
|
|
// loader critical section. Ideally we should move this free to the
|
|
// main thread, but since we are in the midst of IE5 RC's we are doing
|
|
// the least risky change i.e. leaking jsproxy.dll in the process.
|
|
if (!GlobalDynaUnload)
|
|
{
|
|
FreeLibrary(_hAutoConfigDLL);
|
|
}
|
|
|
|
_pGetProxyInfo = NULL;
|
|
_pGetProxyInfoEx = NULL;
|
|
_pProxyDllInit = NULL;
|
|
_pProxyDllDeInit = NULL;
|
|
_pProxyInfoInvalid = NULL;
|
|
}
|
|
|
|
DEBUG_LEAVE(0);
|
|
}
|
|
|
|
|
|
DWORD
|
|
AUTO_PROXY_LIST_ENTRY::LoadEntry(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads the DLL function entry points for an Auto-Proxy DLL.
|
|
|
|
Arguments:
|
|
|
|
none.
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
ERROR_SUCCESS - success
|
|
|
|
Win32 Error code - failure
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD error = ERROR_SUCCESS;
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Dword,
|
|
"AUTO_PROXY_LIST_ENTRY::LoadEntry",
|
|
""
|
|
));
|
|
|
|
if ( _lpszFileExtensions == NULL ||
|
|
_lpszDllFilePath == NULL )
|
|
{
|
|
error = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto quit;
|
|
}
|
|
|
|
_pGetProxyInfo = NULL;
|
|
_pProxyInfoInvalid = NULL;
|
|
_pProxyDllDeInit = NULL;
|
|
_pProxyDllInit = NULL;
|
|
_pGetProxyInfoEx = NULL;
|
|
|
|
if ( _hAutoConfigDLL )
|
|
{
|
|
FreeLibrary(_hAutoConfigDLL);
|
|
_hAutoConfigDLL = NULL;
|
|
}
|
|
|
|
_hAutoConfigDLL = LoadLibrary(_lpszDllFilePath);
|
|
|
|
if ( _hAutoConfigDLL == NULL )
|
|
{
|
|
error = GetLastError();
|
|
goto quit;
|
|
}
|
|
|
|
|
|
|
|
_pGetProxyInfo = (GET_PROXY_INFO_FN)
|
|
GetProcAddress(_hAutoConfigDLL, GET_PROXY_INFO_FN_NAME);
|
|
|
|
|
|
_pGetProxyInfoEx = (GET_PROXY_INFO_EX_FN)
|
|
GetProcAddress(_hAutoConfigDLL, GET_PROXY_INFO_EX_FN_NAME);
|
|
|
|
|
|
_pProxyInfoInvalid = (PROXY_INFO_INVALID_FN)
|
|
GetProcAddress(_hAutoConfigDLL, PROXY_INFO_INVALID_FN_NAME);
|
|
|
|
|
|
_pProxyDllDeInit = (PROXY_DLL_DEINIT_FN)
|
|
GetProcAddress(_hAutoConfigDLL, PROXY_DLL_DEINIT_FN_NAME);
|
|
|
|
|
|
_pProxyDllInit = (PROXY_DLL_INIT_FN)
|
|
GetProcAddress(_hAutoConfigDLL, PROXY_DLL_INIT_FN_NAME );
|
|
|
|
|
|
if ( !_pProxyDllInit && !_pProxyDllDeInit && !_pProxyInfoInvalid && !_pGetProxyInfo && !_pGetProxyInfoEx)
|
|
{
|
|
error = GetLastError();
|
|
goto quit;
|
|
}
|
|
|
|
if ( !_pProxyDllInit )
|
|
{
|
|
//
|
|
// If they don't export this entry point, than we can't initialize them, so
|
|
// we pretend to have initialized them.
|
|
//
|
|
|
|
_fInitializedSuccessfully = TRUE;
|
|
}
|
|
|
|
quit:
|
|
|
|
DEBUG_LEAVE(error);
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
BOOL
|
|
AUTO_PROXY_DLLS::SelectAutoProxyByMime(
|
|
IN LPSTR lpszMimeType
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sets an internal pointer inside the object to point to a found auto-proxy DLL.
|
|
The MIME type given is used to find the match.
|
|
|
|
Arguments:
|
|
|
|
lpszMimeType - The Mime type to search on.
|
|
|
|
Return Value:
|
|
|
|
BOOL
|
|
TRUE - success
|
|
|
|
FALSE - failure
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Bool,
|
|
"AUTO_PROXY_DLLS::SelectAutoProxyByMime",
|
|
"%s",
|
|
lpszMimeType
|
|
));
|
|
|
|
BOOL found = FALSE;
|
|
AUTO_PROXY_LIST_ENTRY * info = NULL;
|
|
|
|
LockAutoProxy();
|
|
|
|
LockSerializedList(&_List);
|
|
|
|
for (PLIST_ENTRY entry = HeadOfSerializedList(&_List);
|
|
entry != (PLIST_ENTRY)SlSelf(&_List);
|
|
entry = entry->Flink)
|
|
{
|
|
info = CONTAINING_RECORD(entry, AUTO_PROXY_LIST_ENTRY, _List);
|
|
|
|
if (info->_lpszMimeType && lstrcmpi(lpszMimeType, info->_lpszMimeType) == 0 )
|
|
{
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
UnlockSerializedList(&_List);
|
|
|
|
if ( found )
|
|
{
|
|
SelectAutoProxy(info);
|
|
}
|
|
|
|
UnlockAutoProxy();
|
|
|
|
DEBUG_LEAVE(found);
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
BOOL
|
|
AUTO_PROXY_DLLS::SelectAutoProxyByDefault(
|
|
VOID
|
|
)
|
|
{
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Bool,
|
|
"AUTO_PROXY_DLLS::SelectAutoProxyByDefault",
|
|
NULL
|
|
));
|
|
|
|
BOOL found = FALSE;
|
|
AUTO_PROXY_LIST_ENTRY * info = NULL;
|
|
|
|
LockAutoProxy();
|
|
|
|
LockSerializedList(&_List);
|
|
|
|
for (PLIST_ENTRY entry = HeadOfSerializedList(&_List);
|
|
entry != (PLIST_ENTRY)SlSelf(&_List);
|
|
entry = entry->Flink)
|
|
{
|
|
info = CONTAINING_RECORD(entry, AUTO_PROXY_LIST_ENTRY, _List);
|
|
|
|
if (info->IsDefault() )
|
|
{
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
UnlockSerializedList(&_List);
|
|
|
|
if ( found )
|
|
{
|
|
SelectAutoProxy(info);
|
|
}
|
|
|
|
DEBUG_LEAVE(found);
|
|
|
|
UnlockAutoProxy();
|
|
|
|
return found;
|
|
}
|
|
|
|
BOOL
|
|
AUTO_PROXY_DLLS::SelectAutoProxyByFileExtension(
|
|
LPCSTR lpszAutoProxyPath
|
|
)
|
|
{
|
|
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Bool,
|
|
"AUTO_PROXY_DLLS::SelectAutoProxyByFileExtension",
|
|
"%s",
|
|
lpszAutoProxyPath
|
|
));
|
|
|
|
BOOL found = FALSE;
|
|
AUTO_PROXY_LIST_ENTRY * info = NULL;
|
|
|
|
LockAutoProxy();
|
|
|
|
LockSerializedList(&_List);
|
|
|
|
for (PLIST_ENTRY entry = HeadOfSerializedList(&_List);
|
|
entry != (PLIST_ENTRY)SlSelf(&_List);
|
|
entry = entry->Flink)
|
|
{
|
|
info = CONTAINING_RECORD(entry, AUTO_PROXY_LIST_ENTRY, _List);
|
|
|
|
if (info->_lpszFileExtensions &&
|
|
MatchFileExtensionWithUrl(info->_lpszFileExtensions, lpszAutoProxyPath) )
|
|
{
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
UnlockSerializedList(&_List);
|
|
|
|
if ( found )
|
|
{
|
|
SelectAutoProxy(info);
|
|
}
|
|
|
|
UnlockAutoProxy();
|
|
|
|
DEBUG_LEAVE(found);
|
|
|
|
return found;
|
|
}
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::GetAutoProxyStringEntry(
|
|
IN LPSTR lpszRegName,
|
|
IN OUT LPSTR * lplpszAllocatedRegValue
|
|
)
|
|
{
|
|
DWORD dwcbNewValue = 0;
|
|
DWORD error = ERROR_SUCCESS;
|
|
|
|
if ( *lplpszAllocatedRegValue )
|
|
{
|
|
FREE_MEMORY(*lplpszAllocatedRegValue);
|
|
*lplpszAllocatedRegValue = NULL;
|
|
}
|
|
|
|
error =
|
|
InternetReadRegistryString(
|
|
lpszRegName,
|
|
NULL,
|
|
&dwcbNewValue
|
|
);
|
|
|
|
if ( error == ERROR_SUCCESS )
|
|
{
|
|
dwcbNewValue++;
|
|
*lplpszAllocatedRegValue = (LPSTR) ALLOCATE_MEMORY(LMEM_FIXED, dwcbNewValue);
|
|
|
|
if ( *lplpszAllocatedRegValue == NULL )
|
|
{
|
|
error = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto quit;
|
|
}
|
|
|
|
error =
|
|
InternetReadRegistryString(
|
|
lpszRegName,
|
|
*lplpszAllocatedRegValue,
|
|
&dwcbNewValue
|
|
);
|
|
|
|
if ( error != ERROR_SUCCESS )
|
|
{
|
|
INET_ASSERT((error == ERROR_SUCCESS));
|
|
FREE_MEMORY(*lplpszAllocatedRegValue);
|
|
*lplpszAllocatedRegValue = NULL;
|
|
}
|
|
}
|
|
|
|
quit:
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
AUTO_PROXY_DLLS::ReadAutoProxyRegistrySettings(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Scans Registry for, and builds linked list of AutoProxy DLLs.
|
|
|
|
Return Value:
|
|
|
|
Success - ERROR_SUCCESS
|
|
|
|
Failure -
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY hkSecurity = NULL; // main security key
|
|
DWORD error = ERROR_SUCCESS;
|
|
DWORD dwcbAutoConfigProxy = 0;
|
|
HKEY hkSPMKey = NULL;
|
|
const static CHAR cszMainSecKey[]
|
|
= CSZMAINSECKEY;
|
|
DEBUG_ENTER((DBG_PROXY,
|
|
Dword,
|
|
"AUTO_PROXY_DLLS::ReadAutoProxyRegistrySettings",
|
|
""
|
|
));
|
|
|
|
LockAutoProxy();
|
|
|
|
//
|
|
// QFE 1169: Use the HKCU value as the user agent string if told to do so.
|
|
// Yes this looks ugly, but it's just to prevent a whole bunch
|
|
// of ifs and handlers for failures.
|
|
|
|
DWORD dwcbBufLen = 0;
|
|
|
|
if (ERROR_SUCCESS == InternetReadRegistryDwordKey(
|
|
HKEY_CURRENT_USER,
|
|
"AutoConfigCustomUA",
|
|
&dwcbBufLen) &&
|
|
dwcbBufLen)
|
|
{
|
|
if (NULL == _hInstUrlmon)
|
|
{
|
|
_hInstUrlmon = LoadLibrary("Urlmon.dll");
|
|
}
|
|
if (_hInstUrlmon)
|
|
{
|
|
typedef HRESULT (*PFNOBTAINUA)(DWORD, LPSTR, DWORD*);
|
|
CHAR lpszUserAgent[MAX_PATH];
|
|
DWORD cbSize = MAX_PATH;
|
|
|
|
PFNOBTAINUA pfnUA = (PFNOBTAINUA)GetProcAddress(_hInstUrlmon,"ObtainUserAgentString");
|
|
if (pfnUA)
|
|
{
|
|
HRESULT hr = (*pfnUA)(0, lpszUserAgent, &cbSize);
|
|
if(S_OK == hr)
|
|
{
|
|
if ( _lpszUserAgent && (lstrcmpi(_lpszUserAgent, lpszUserAgent) != 0) )
|
|
{
|
|
_lpszUserAgent = (LPSTR)
|
|
FREE_MEMORY(_lpszUserAgent);
|
|
}
|
|
if ( _lpszUserAgent == NULL )
|
|
{
|
|
_lpszUserAgent = NewString(lpszUserAgent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (REGOPENKEY( HKEY_CLASSES_ROOT, cszMainSecKey, &hkSecurity ) != ERROR_SUCCESS)
|
|
{
|
|
error = GetLastError();
|
|
goto quit;
|
|
}
|
|
|
|
|
|
DWORD dwIndex;
|
|
dwIndex = 0;
|
|
|
|
do
|
|
{
|
|
CHAR szMime[256];
|
|
#ifdef unix
|
|
CHAR szUnixHackMime[256];
|
|
#endif /* unix */
|
|
if ( hkSPMKey != NULL )
|
|
{
|
|
REGCLOSEKEY(hkSPMKey);
|
|
hkSPMKey = NULL;
|
|
}
|
|
|
|
//
|
|
// Enumerate a List of MIME types, that we accept for auto-proxy
|
|
//
|
|
|
|
if (RegEnumKey( hkSecurity, dwIndex, szMime, sizeof(szMime)) != ERROR_SUCCESS )
|
|
{
|
|
goto quit;
|
|
}
|
|
|
|
dwIndex++;
|
|
|
|
//
|
|
// Open a potential MIME type entry.
|
|
//
|
|
|
|
if (REGOPENKEY( hkSecurity, szMime, &hkSPMKey ) != ERROR_SUCCESS)
|
|
{
|
|
INET_ASSERT(0);
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Grab the DLL file name
|
|
//
|
|
|
|
DWORD dwType, cbBuf;
|
|
|
|
char szDll[MAX_PATH];
|
|
cbBuf = sizeof(szDll);
|
|
if (ERROR_SUCCESS != RegQueryValueEx
|
|
(hkSPMKey, "DllFile", NULL, &dwType, (LPBYTE) szDll, &cbBuf)
|
|
|| ((dwType != REG_SZ) && (dwType != REG_EXPAND_SZ)) )
|
|
{
|
|
continue; // no DLL name
|
|
}
|
|
|
|
|
|
if ( dwType == REG_EXPAND_SZ )
|
|
{
|
|
DWORD dwSize;
|
|
char szDllPathBeforeExpansion[MAX_PATH];
|
|
|
|
lstrcpy(szDllPathBeforeExpansion, szDll);
|
|
|
|
dwSize = ExpandEnvironmentStrings(szDllPathBeforeExpansion, szDll, ARRAY_ELEMENTS(szDll));
|
|
|
|
if (dwSize > ARRAY_ELEMENTS(szDll) || dwSize == 0 )
|
|
{
|
|
INET_ASSERT(FALSE);
|
|
continue; // not enough room to expand vars?
|
|
}
|
|
}
|
|
|
|
//
|
|
// Grab the list of File extensions that are permitted for this Mime Type
|
|
//
|
|
|
|
|
|
char szFileExtensions[MAX_PATH];
|
|
cbBuf = sizeof(szFileExtensions);
|
|
if (ERROR_SUCCESS != RegQueryValueEx
|
|
(hkSPMKey, "FileExtensions", NULL, &dwType, (LPBYTE) szFileExtensions, &cbBuf)
|
|
|| (dwType != REG_SZ))
|
|
{
|
|
continue; // no DLL name
|
|
}
|
|
|
|
|
|
//
|
|
// Determine whether its the defaut entry.
|
|
//
|
|
|
|
DWORD fIsDefault;
|
|
cbBuf = sizeof(fIsDefault);
|
|
if (ERROR_SUCCESS != RegQueryValueEx
|
|
(hkSPMKey, "Default", NULL, &dwType, (LPBYTE) &fIsDefault, &cbBuf)
|
|
|| ((dwType != REG_DWORD) && (dwType != REG_BINARY)))
|
|
{
|
|
INET_ASSERT (cbBuf == sizeof(DWORD));
|
|
fIsDefault = 0;
|
|
}
|
|
|
|
//
|
|
// Determine whether we have any Flags that need to be read
|
|
// from the registry.
|
|
//
|
|
|
|
DWORD dwFlags;
|
|
|
|
cbBuf = sizeof(dwFlags);
|
|
if (ERROR_SUCCESS != RegQueryValueEx
|
|
(hkSPMKey, "Flags", NULL, &dwType, (LPBYTE) &dwFlags, &cbBuf)
|
|
|| ((dwType != REG_DWORD) && (dwType != REG_BINARY)))
|
|
{
|
|
dwFlags = 0;
|
|
}
|
|
|
|
|
|
//
|
|
// Now build an entry for it, and add it to our list.
|
|
//
|
|
#ifndef unix
|
|
AUTO_PROXY_LIST_ENTRY *apleAutoProxy
|
|
= new AUTO_PROXY_LIST_ENTRY(szDll, szFileExtensions, szMime, fIsDefault, dwFlags);
|
|
#else
|
|
strcpy(szUnixHackMime,"application/");
|
|
strcat(szUnixHackMime,szMime);
|
|
AUTO_PROXY_LIST_ENTRY *apleAutoProxy
|
|
= new AUTO_PROXY_LIST_ENTRY(szDll, szFileExtensions, szUnixHackMime, fIsDefault, dwFlags);
|
|
#endif /* unix */
|
|
if (!apleAutoProxy)
|
|
{
|
|
error = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto quit;
|
|
}
|
|
|
|
if (fIsDefault)
|
|
{
|
|
InsertAtTailOfSerializedList(&_List, &apleAutoProxy->_List);
|
|
}
|
|
else
|
|
{
|
|
InsertAtHeadOfSerializedList(&_List, &apleAutoProxy->_List);
|
|
}
|
|
|
|
} while (1);
|
|
|
|
error = ERROR_SUCCESS;
|
|
|
|
quit:
|
|
|
|
if ( hkSPMKey != NULL )
|
|
{
|
|
REGCLOSEKEY(hkSPMKey);
|
|
}
|
|
|
|
if ( hkSecurity != NULL )
|
|
{
|
|
REGCLOSEKEY(hkSecurity);
|
|
}
|
|
|
|
UnlockAutoProxy();
|
|
|
|
DEBUG_LEAVE(error);
|
|
|
|
return error;
|
|
}
|
|
|
|
AUTO_PROXY_ASYNC_MSG::AUTO_PROXY_ASYNC_MSG(
|
|
IN INTERNET_SCHEME isUrlScheme,
|
|
IN LPSTR lpszUrl,
|
|
IN LPSTR lpszUrlHostName,
|
|
IN DWORD dwUrlHostNameLength
|
|
)
|
|
{
|
|
URL_COMPONENTS urlComponents;
|
|
|
|
Initalize();
|
|
|
|
if ( lpszUrl )
|
|
{
|
|
_lpszUrl = lpszUrl;
|
|
_dwUrlLength = lstrlen(lpszUrl);
|
|
_tUrlProtocol = isUrlScheme;
|
|
_pmProxyQuery = PROXY_MSG_GET_PROXY_INFO;
|
|
_pmaAllocMode = MSG_ALLOC_STACK_ONLY;
|
|
|
|
memset(&urlComponents, 0, sizeof(urlComponents));
|
|
urlComponents.dwStructSize = sizeof(urlComponents);
|
|
urlComponents.lpszHostName = lpszUrlHostName;
|
|
urlComponents.dwHostNameLength = dwUrlHostNameLength;
|
|
|
|
//
|
|
// parse out the host name and port. The host name will be decoded; the
|
|
// original URL will not be modified
|
|
//
|
|
|
|
if (InternetCrackUrl(lpszUrl, 0, ICU_DECODE, &urlComponents))
|
|
{
|
|
_nUrlPort = urlComponents.nPort;
|
|
_lpszUrlHostName = urlComponents.lpszHostName;
|
|
_dwUrlHostNameLength = urlComponents.dwHostNameLength;
|
|
|
|
if ( _tUrlProtocol == INTERNET_SCHEME_UNKNOWN )
|
|
{
|
|
_tUrlProtocol = urlComponents.nScheme;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
_Error = GetLastError();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_Error = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
}
|
|
|
|
AUTO_PROXY_ASYNC_MSG::AUTO_PROXY_ASYNC_MSG(
|
|
IN INTERNET_SCHEME isUrlScheme,
|
|
IN LPSTR lpszUrlHostName,
|
|
IN DWORD dwUrlHostNameLength
|
|
)
|
|
{
|
|
|
|
Initalize();
|
|
|
|
_tUrlProtocol = isUrlScheme;
|
|
_pmProxyQuery = PROXY_MSG_GET_PROXY_INFO;
|
|
_pmaAllocMode = MSG_ALLOC_STACK_ONLY;
|
|
_lpszUrlHostName = lpszUrlHostName;
|
|
_dwUrlHostNameLength = dwUrlHostNameLength;
|
|
}
|
|
|
|
AUTO_PROXY_ASYNC_MSG::AUTO_PROXY_ASYNC_MSG(
|
|
IN INTERNET_SCHEME isUrlScheme,
|
|
IN LPSTR lpszUrl,
|
|
IN DWORD dwUrlLength,
|
|
IN LPSTR lpszUrlHostName,
|
|
IN DWORD dwUrlHostNameLength,
|
|
IN INTERNET_PORT nUrlPort
|
|
)
|
|
{
|
|
Initalize();
|
|
|
|
_tUrlProtocol = isUrlScheme;
|
|
_pmProxyQuery = PROXY_MSG_GET_PROXY_INFO;
|
|
_pmaAllocMode = MSG_ALLOC_STACK_ONLY;
|
|
_nUrlPort = nUrlPort;
|
|
_lpszUrlHostName = lpszUrlHostName;
|
|
_dwUrlHostNameLength = dwUrlHostNameLength;
|
|
_lpszUrl = lpszUrl;
|
|
_dwUrlLength = dwUrlLength;
|
|
|
|
}
|
|
|
|
VOID
|
|
AUTO_PROXY_ASYNC_MSG::SetProxyMsg(
|
|
IN INTERNET_SCHEME isUrlScheme,
|
|
IN LPSTR lpszUrl,
|
|
IN DWORD dwUrlLength,
|
|
IN LPSTR lpszUrlHostName,
|
|
IN DWORD dwUrlHostNameLength,
|
|
IN INTERNET_PORT nUrlPort
|
|
)
|
|
{
|
|
_tUrlProtocol = isUrlScheme;
|
|
_pmProxyQuery = PROXY_MSG_GET_PROXY_INFO;
|
|
_pmaAllocMode = MSG_ALLOC_STACK_ONLY;
|
|
_nUrlPort = nUrlPort;
|
|
_lpszUrlHostName = lpszUrlHostName;
|
|
_dwUrlHostNameLength = dwUrlHostNameLength;
|
|
_lpszUrl = lpszUrl;
|
|
_dwUrlLength = dwUrlLength;
|
|
}
|
|
|
|
|
|
AUTO_PROXY_ASYNC_MSG::AUTO_PROXY_ASYNC_MSG(
|
|
IN PROXY_MESSAGE_TYPE pmProxyQuery
|
|
)
|
|
{
|
|
Initalize();
|
|
|
|
_pmaAllocMode = MSG_ALLOC_HEAP_MSG_OBJ_OWNS;
|
|
_pmProxyQuery = pmProxyQuery;
|
|
}
|
|
|
|
AUTO_PROXY_ASYNC_MSG::AUTO_PROXY_ASYNC_MSG(
|
|
IN AUTO_PROXY_ASYNC_MSG *pStaticAutoProxy
|
|
)
|
|
{
|
|
Initalize();
|
|
|
|
_tUrlProtocol = pStaticAutoProxy->_tUrlProtocol;
|
|
_lpszUrl = (pStaticAutoProxy->_lpszUrl) ? NewString(pStaticAutoProxy->_lpszUrl) : NULL;
|
|
_dwUrlLength = pStaticAutoProxy->_dwUrlLength;
|
|
_lpszUrlHostName =
|
|
(pStaticAutoProxy->_lpszUrlHostName ) ?
|
|
NewString(pStaticAutoProxy->_lpszUrlHostName, pStaticAutoProxy->_dwUrlHostNameLength) :
|
|
NULL;
|
|
_dwUrlHostNameLength = pStaticAutoProxy->_dwUrlHostNameLength;
|
|
_nUrlPort = pStaticAutoProxy->_nUrlPort;
|
|
_tProxyScheme = pStaticAutoProxy->_tProxyScheme;
|
|
|
|
//
|
|
// ProxyHostName is something that is generated by the request,
|
|
// therefore it should not be copied OR freed.
|
|
//
|
|
|
|
INET_ASSERT( pStaticAutoProxy->_lpszProxyHostName == NULL );
|
|
//_lpszProxyHostName = (pStaticAutoProxy->_lpszProxyHostName ) ? NewString(pStaticAutoProxy->_lpszProxyHostName) : NULL;
|
|
|
|
|
|
_dwProxyHostNameLength = pStaticAutoProxy->_dwProxyHostNameLength;
|
|
_nProxyHostPort = pStaticAutoProxy->_nProxyHostPort;
|
|
_pmProxyQuery = pStaticAutoProxy->_pmProxyQuery;
|
|
_pmaAllocMode = MSG_ALLOC_HEAP_MSG_OBJ_OWNS;
|
|
_pProxyState = pStaticAutoProxy->_pProxyState;
|
|
|
|
INET_ASSERT(_pProxyState == NULL);
|
|
|
|
_dwQueryResult = pStaticAutoProxy->_dwQueryResult;
|
|
_Error = pStaticAutoProxy->_Error;
|
|
_MessageFlags.Dword = pStaticAutoProxy->_MessageFlags.Dword;
|
|
_dwProxyVersion = pStaticAutoProxy->_dwProxyVersion;
|
|
}
|
|
|
|
AUTO_PROXY_ASYNC_MSG::~AUTO_PROXY_ASYNC_MSG(
|
|
VOID
|
|
)
|
|
{
|
|
DEBUG_ENTER((DBG_OBJECTS,
|
|
None,
|
|
"~AUTO_PROXY_ASYNC_MSG",
|
|
NULL
|
|
));
|
|
|
|
if ( IsAlloced() )
|
|
{
|
|
DEBUG_PRINT(OBJECTS,
|
|
INFO,
|
|
("Freeing Allocated MSG ptr=%x\n",
|
|
this
|
|
));
|
|
|
|
|
|
if ( _lpszUrl )
|
|
{
|
|
//DEBUG_PRINT(OBJECTS,
|
|
// INFO,
|
|
// ("Url ptr=%x, %q\n",
|
|
// _lpszUrl,
|
|
// _lpszUrl
|
|
// ));
|
|
|
|
FREE_MEMORY(_lpszUrl);
|
|
}
|
|
|
|
if ( _lpszUrlHostName )
|
|
{
|
|
FREE_MEMORY(_lpszUrlHostName);
|
|
}
|
|
|
|
|
|
if ( _pProxyState )
|
|
{
|
|
delete _pProxyState;
|
|
}
|
|
}
|
|
if (_bFreeProxyHostName && (_lpszProxyHostName != NULL)) {
|
|
FREE_MEMORY(_lpszProxyHostName);
|
|
}
|
|
|
|
DEBUG_LEAVE(0);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// functions
|
|
//
|
|
|
|
|
|
PRIVATE
|
|
BOOL
|
|
MatchFileExtensionWithUrl(
|
|
IN LPCSTR lpszFileExtensionList,
|
|
IN LPCSTR lpszUrl
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Matches a Url with a string of externsions (looks like ".ins;.jv").
|
|
Confims the Url is using one the approved externsions.
|
|
|
|
Arguments:
|
|
|
|
lpszFileExtensionList - the list of file extensions to check the Url against.
|
|
|
|
lpszUrl - the url to examine.
|
|
|
|
Return Value:
|
|
|
|
BOOL
|
|
TRUE - success
|
|
|
|
FALSE - the Url does not contain any of the extensions.
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
|
|
LPCSTR lpszExtension, lpszExtensionOffset;
|
|
LPCSTR lpszQuestion;
|
|
|
|
//
|
|
// We need to be careful about checking for a period on the end of an URL
|
|
// Example: if we have: "http://auto-proxy-srv/fooboo.exe?autogenator.com.ex" ?
|
|
//
|
|
|
|
lpszQuestion = strchr( lpszUrl, '?' );
|
|
|
|
lpszUrl = ( lpszQuestion ) ? lpszQuestion : lpszUrl;
|
|
|
|
lpszExtension = strrchr( lpszUrl, '.' );
|
|
|
|
|
|
if ( lpszExtension )
|
|
{
|
|
lpszExtensionOffset = lpszExtension;
|
|
BOOL fMatching = FALSE;
|
|
BOOL fCurrentMatch = FALSE;
|
|
BOOL fFirstByte = TRUE;
|
|
|
|
while ( *lpszFileExtensionList && *lpszExtensionOffset )
|
|
{
|
|
|
|
if ( toupper(*lpszFileExtensionList) == toupper(*lpszExtensionOffset) )
|
|
{
|
|
fCurrentMatch = TRUE;
|
|
}
|
|
else
|
|
{
|
|
fCurrentMatch = FALSE;
|
|
}
|
|
|
|
if ( *lpszFileExtensionList == ';')
|
|
{
|
|
lpszExtensionOffset = lpszExtension-1;
|
|
fFirstByte = TRUE;
|
|
|
|
if ( fMatching )
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
else if ( fFirstByte || fMatching )
|
|
{
|
|
fMatching = fCurrentMatch;
|
|
fFirstByte = FALSE;
|
|
}
|
|
|
|
lpszExtensionOffset++;
|
|
lpszFileExtensionList++;
|
|
|
|
if ( *lpszExtensionOffset == '\0' )
|
|
{
|
|
lpszExtensionOffset = lpszExtension;
|
|
}
|
|
}
|
|
|
|
if ( fMatching )
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
#ifdef unix
|
|
static BOOL fForceAutoProxSync = TRUE;
|
|
extern "C"
|
|
void unixForceAutoProxSync()
|
|
{
|
|
if(fForceAutoProxSync)
|
|
{
|
|
if (!GlobalDataInitialized)
|
|
GlobalDataInitialize();
|
|
|
|
if (GlobalDataInitialized)
|
|
{
|
|
GlobalProxyInfo.SetRefreshDisabled(FALSE);
|
|
FixProxySettingsForCurrentConnection(TRUE);
|
|
GlobalProxyInfo.ReleaseQueuedRefresh();
|
|
fForceAutoProxSync = FALSE;
|
|
}
|
|
}
|
|
}
|
|
#endif /* unix */
|
|
|