windows-xp/Source/XPSP1/NT/enduser/windows.com/lib/download/dlhttp.cpp

#include <windows.h>
#include <winhttp.h>
#include <shlwapi.h>
#include <logging.h>
#include "iucommon.h"
#include "download.h"
#include "dllite.h"
#include "dlutil.h"
#include "malloc.h"

#include "trust.h"
#include "fileutil.h"
#include "dlcache.h"
#include "wusafefn.h"

///////////////////////////////////////////////////////////////////////////////
// typedefs


// winhttp
extern "C"
{
typedef BOOL      (WINAPI *pfn_WinHttpCrackUrl)(LPCWSTR, DWORD, DWORD, LPURL_COMPONENTS);
typedef HINTERNET (WINAPI *pfn_WinHttpOpen)(LPCWSTR, DWORD, LPCWSTR, LPCWSTR, DWORD);
typedef HINTERNET (WINAPI *pfn_WinHttpConnect)(HINTERNET, LPCWSTR, INTERNET_PORT, DWORD);
typedef HINTERNET (WINAPI *pfn_WinHttpOpenRequest)(HINTERNET, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR FAR *, DWORD);
typedef BOOL      (WINAPI *pfn_WinHttpSendRequest)(HINTERNET, LPCWSTR, DWORD, LPVOID, DWORD, DWORD, DWORD_PTR);
typedef BOOL      (WINAPI *pfn_WinHttpReceiveResponse)(HINTERNET, LPVOID);
typedef BOOL      (WINAPI *pfn_WinHttpQueryHeaders)(HINTERNET, DWORD, LPCWSTR, LPVOID, LPDWORD, LPDWORD);
typedef BOOL      (WINAPI *pfn_WinHttpReadData)(HINTERNET, LPVOID, DWORD, LPDWORD);
typedef BOOL      (WINAPI *pfn_WinHttpCloseHandle)(HINTERNET);
typedef BOOL      (WINAPI *pfn_WinHttpGetIEProxyConfigForCurrentUser)(WINHTTP_CURRENT_USER_IE_PROXY_CONFIG *);
typedef BOOL      (WINAPI *pfn_WinHttpGetProxyForUrl)(HINTERNET, LPCWSTR, WINHTTP_AUTOPROXY_OPTIONS *, WINHTTP_PROXY_INFO *);
typedef BOOL      (WINAPI *pfn_WinHttpSetOption)(HINTERNET, DWORD, LPVOID, DWORD);
}

struct SWinHTTPFunctions
{
    pfn_WinHttpGetIEProxyConfigForCurrentUser   pfnWinHttpGetIEProxyConfigForCurrentUser;
    pfn_WinHttpGetProxyForUrl   pfnWinHttpGetProxyForUrl;
    pfn_WinHttpCrackUrl         pfnWinHttpCrackUrl;
    pfn_WinHttpOpen             pfnWinHttpOpen;
    pfn_WinHttpConnect          pfnWinHttpConnect;
    pfn_WinHttpOpenRequest      pfnWinHttpOpenRequest;
    pfn_WinHttpSendRequest      pfnWinHttpSendRequest;
    pfn_WinHttpReceiveResponse  pfnWinHttpReceiveResponse;
    pfn_WinHttpQueryHeaders     pfnWinHttpQueryHeaders;
    pfn_WinHttpReadData         pfnWinHttpReadData;
    pfn_WinHttpCloseHandle      pfnWinHttpCloseHandle;
    pfn_WinHttpSetOption        pfnWinHttpSetOption;
    HMODULE                     hmod;
};

typedef struct tagSAUProxyInfo
{
    WINHTTP_PROXY_INFO  ProxyInfo;
    LPWSTR              wszProxyOrig;
    LPWSTR              *rgwszProxies;
    DWORD               cProxies;
    DWORD               iProxy;
} SAUProxyInfo;

typedef enum tagETransportUsed
{
    etuNone = 0,
    etuWinHttp,
    etuWinInet,
} ETransportUsed;

#define SafeWinHTTPCloseHandle(sfns, x) if (NULL != x) { (*sfns.pfnWinHttpCloseHandle)(x); x = NULL; }
#define StringOrConstW(wsz, wszConst) (((wsz) != NULL) ? (wsz) : (wszConst))


///////////////////////////////////////////////////////////////////////////////
// globals

#if defined(UNICODE)

CWUDLProxyCache g_wudlProxyCache;
CAutoCritSec    g_csCache;

#endif

HMODULE         g_hmodWinHttp = NULL;
HMODULE         g_hmodWinInet = NULL;

///////////////////////////////////////////////////////////////////////////////
// utility functions

// **************************************************************************
static
LPTSTR MakeFullLocalFilePath(LPCTSTR szUrl, 
                             LPCTSTR szFileName, 
                             LPCTSTR szPath)
{
    LOG_Block("MakeFullLocalFilePath()");

    HRESULT hr = NOERROR;
    LPTSTR  pszRet, pszFileNameToUse = NULL, pszQuery = NULL;
    LPTSTR  pszFullPath = NULL;
    DWORD   cchFile;
    TCHAR   chTemp = _T('\0');

    // if we got a local filename passed to us, use it.
    if (szFileName != NULL)
    {
        pszFileNameToUse = (LPTSTR)szFileName;
    } 

    // otherwise, parse the filename out of the URL & use it instead
    else
    {
        // first get a pointer to the querystring, if any
        pszQuery = _tcschr(szUrl, _T('?'));

        // next, find the last slash before the start of the querystring
        pszFileNameToUse = StrRChr(szUrl, pszQuery, _T('/'));

        // if we don't have a filename at this point, we can't continue
        //  cuz there's nowhere to download the file to.
        if (pszFileNameToUse == NULL)
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            goto done;
        }
        
        pszFileNameToUse++;

        // temporarily NULL out the first character of the querystring, if
        //  we have a querystring.  This makes the end of the filename the
        //  end of the string.
        if (pszQuery != NULL)
        {
            chTemp = *pszQuery;
            *pszQuery  = _T('\0');
        }
    }

    // add 2 for a possible backslash & the null terminator
    cchFile = 2 + _tcslen(szPath) + _tcslen(pszFileNameToUse);

    pszFullPath = (LPTSTR)HeapAlloc(GetProcessHeap(), 0, cchFile * sizeof(TCHAR));
    if (pszFullPath == NULL)
    {
        SetLastError(ERROR_OUTOFMEMORY);
        if (pszQuery != NULL)
            *pszQuery = chTemp;
        goto done;
    }

    // construct the path
    hr = SafePathCombine(pszFullPath, cchFile, szPath, pszFileNameToUse, 0);

    // if we nuked the first character of the querystring, restore it.
    if (pszQuery != NULL)
        *pszQuery = chTemp;

    if (FAILED(hr))
    {
		SetLastError(HRESULT_CODE(hr));
		SafeHeapFree(pszFullPath);
		goto done;
    }

done:
    return pszFullPath;
}

// **************************************************************************
static
ETransportUsed LoadTransportDll(SWinHTTPFunctions *psfns, HMODULE *phmod, 
                                  DWORD dwFlags)
{
    LOG_Block("LoadTransportDll()");

    ETransportUsed  etu = etuNone;
    HMODULE hmod = NULL;
    HRESULT hr = NOERROR;
    BOOL    fAllowWininet;
    BOOL    fAllowWinhttp;
    BOOL    fPersistTrans = ((dwFlags & WUDF_PERSISTTRANSPORTDLL) != 0);

    if (psfns == NULL || phmod == NULL || 
        (dwFlags & WUDF_TRANSPORTMASK) == WUDF_TRANSPORTMASK)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        goto done;
    }

    dwFlags = GetAllowedDownloadTransport(dwFlags);
    fAllowWininet = ((dwFlags & WUDF_ALLOWWINHTTPONLY) == 0);
    fAllowWinhttp = ((dwFlags & WUDF_ALLOWWININETONLY) == 0);

    ZeroMemory(psfns, sizeof(SWinHTTPFunctions));
    *phmod = NULL;

    // first try to load the winhttp dll
    if (fAllowWinhttp)
    {
        if (g_hmodWinHttp == NULL)
        {
            hmod = LoadLibraryFromSystemDir(c_szWinHttpDll);
            
            if (hmod != NULL && fPersistTrans && 
                InterlockedCompareExchangePointer((LPVOID *)&g_hmodWinHttp,
                                                  hmod, NULL) != NULL)
            {
                FreeLibrary(hmod);
                hmod = g_hmodWinHttp;
            }
        }
        else
        {
            hmod = g_hmodWinHttp;
        }
    }
    if (hmod != NULL)
    {
        psfns->hmod                      = hmod;
        psfns->pfnWinHttpGetProxyForUrl  = (pfn_WinHttpGetProxyForUrl)GetProcAddress(hmod, "WinHttpGetProxyForUrl");
        psfns->pfnWinHttpCrackUrl        = (pfn_WinHttpCrackUrl)GetProcAddress(hmod, "WinHttpCrackUrl");
        psfns->pfnWinHttpOpen            = (pfn_WinHttpOpen)GetProcAddress(hmod, "WinHttpOpen");
        psfns->pfnWinHttpConnect         = (pfn_WinHttpConnect)GetProcAddress(hmod, "WinHttpConnect");
        psfns->pfnWinHttpOpenRequest     = (pfn_WinHttpOpenRequest)GetProcAddress(hmod, "WinHttpOpenRequest");
        psfns->pfnWinHttpSendRequest     = (pfn_WinHttpSendRequest)GetProcAddress(hmod, "WinHttpSendRequest");
        psfns->pfnWinHttpReceiveResponse = (pfn_WinHttpReceiveResponse)GetProcAddress(hmod, "WinHttpReceiveResponse");
        psfns->pfnWinHttpQueryHeaders    = (pfn_WinHttpQueryHeaders)GetProcAddress(hmod, "WinHttpQueryHeaders");
        psfns->pfnWinHttpReadData        = (pfn_WinHttpReadData)GetProcAddress(hmod, "WinHttpReadData");
        psfns->pfnWinHttpCloseHandle     = (pfn_WinHttpCloseHandle)GetProcAddress(hmod, "WinHttpCloseHandle");
        psfns->pfnWinHttpSetOption       = (pfn_WinHttpSetOption)GetProcAddress(hmod, "WinHttpSetOption");
        psfns->pfnWinHttpGetIEProxyConfigForCurrentUser = (pfn_WinHttpGetIEProxyConfigForCurrentUser)GetProcAddress(hmod, "WinHttpGetIEProxyConfigForCurrentUser");
        if (psfns->pfnWinHttpCrackUrl == NULL || 
            psfns->pfnWinHttpOpen == NULL ||
            psfns->pfnWinHttpConnect == NULL || 
            psfns->pfnWinHttpOpenRequest == NULL ||
            psfns->pfnWinHttpSendRequest == NULL || 
            psfns->pfnWinHttpReceiveResponse == NULL ||
            psfns->pfnWinHttpQueryHeaders == NULL || 
            psfns->pfnWinHttpReadData == NULL ||
            psfns->pfnWinHttpCloseHandle == NULL || 
            psfns->pfnWinHttpGetProxyForUrl == NULL ||
            psfns->pfnWinHttpGetIEProxyConfigForCurrentUser == NULL || 
            psfns->pfnWinHttpSetOption == NULL)
        {
            // do this logging here cuz we'll try wininet afterward & we want
            //  to make sure to log this error as well
            LOG_ErrorMsg(ERROR_PROC_NOT_FOUND);
            SetLastError(ERROR_PROC_NOT_FOUND);
            
            ZeroMemory(psfns, sizeof(SWinHTTPFunctions));
            FreeLibrary(hmod);
            hmod = NULL;
        }
        else
        {
            LOG_Internet(_T("Successfully loaded WinHttp.dll"));
            
            etu     = etuWinHttp;
            *phmod  = hmod;
        }
    }

    // if hmod is NULL at this point, then try to fall back to wininet.  If
    //  that fails, we can only bail...
    if (fAllowWininet && hmod == NULL)
    {
        if (g_hmodWinInet == NULL)
        {
            hmod = LoadLibraryFromSystemDir(c_szWinInetDll);
            if (hmod == NULL)
                goto done;

            if (fPersistTrans &&
                InterlockedCompareExchangePointer((LPVOID *)&g_hmodWinInet, 
                                                  hmod, NULL) != NULL)
            {
                FreeLibrary(hmod);
                hmod = g_hmodWinInet;
            }
        }

        LOG_Internet(_T("Successfully loaded WinInet.dll (no functions yet)"));

        etu    = etuWinInet;
        *phmod = hmod;
    }

done:    
    return etu;
}

// **************************************************************************
static
BOOL UnloadTransportDll(SWinHTTPFunctions *psfns, HMODULE hmod)
{
    LOG_Block("UnloadTransportDll()");

    if (hmod != NULL && hmod != g_hmodWinHttp && hmod != g_hmodWinInet)
        FreeLibrary(hmod);

    if (psfns != NULL)
        ZeroMemory(psfns, sizeof(SWinHTTPFunctions));

    return TRUE;
}

// we only care about winhttp on unicode platforms!
#if defined(UNICODE)

// **************************************************************************
static
BOOL ProxyListToArray(LPWSTR wszProxy, LPWSTR **prgwszProxies, DWORD *pcProxies)
{
    LPWSTR  pwszProxy = wszProxy;
    LPWSTR  *rgwszProxies = NULL;
    DWORD   cProxies = 0, iProxy;
    BOOL    fRet = FALSE;

    if (prgwszProxies == NULL || pcProxies == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        goto done;
    }

    *prgwszProxies = NULL;
    *pcProxies     = 0;

    if (wszProxy == NULL || *wszProxy == L'\0')
        goto done;
    
    // walk the string & count how many proxies we have
    for(;;)
    {
        for(;
            *pwszProxy != L';' && *pwszProxy != L'\0';
            pwszProxy++);

        cProxies++;

        if (*pwszProxy == L'\0')
            break;
        else
            pwszProxy++;
    }

    // alloc an array to hold 'em
    rgwszProxies = (LPWSTR *)GlobalAlloc(GPTR, sizeof(LPWSTR) * cProxies);
    if (rgwszProxies == NULL)
    {
        SetLastError(ERROR_OUTOFMEMORY);
        goto done;
    }

    // fill the array
    pwszProxy = wszProxy;
    for(iProxy = 0; iProxy < cProxies; iProxy++)
    {
        rgwszProxies[iProxy] = pwszProxy;

        for(;
            *pwszProxy != L';' && *pwszProxy != L'\0';
            pwszProxy++);


        if (*pwszProxy == L'\0')
        {
            break;
        }
        else
        {
            *pwszProxy = L'\0';
            pwszProxy++;
        }
    }
        
    *prgwszProxies = rgwszProxies;
    *pcProxies     = cProxies;

    rgwszProxies   = NULL;

    fRet = TRUE;

done:
    if (rgwszProxies != NULL)
        GlobalFree(rgwszProxies);

    return fRet;    
}

// **************************************************************************
static
DWORD GetInitialProxyIndex(DWORD cProxies)
{
    SYSTEMTIME  st;
    DWORD       iProxy;

    GetSystemTime(&st);

    // this would be incredibly weird, but it's easy to deal with so do so
    if (st.wMilliseconds >= 1000)
        st.wMilliseconds = st.wMilliseconds % 1000;

    // so we don't have to use the crt random number generator, just fake it
    return (st.wMilliseconds * cProxies) / 1000;
}

// **************************************************************************
static
BOOL GetWinHTTPProxyInfo(SWinHTTPFunctions &sfns, BOOL fCacheResults,
                         HINTERNET hInternet, LPCWSTR wszURL, LPCWSTR wszSrv,
                         SAUProxyInfo *pAUProxyInfo)
{
    LOG_Block("GetWinHTTPProxyInfo()");

    WINHTTP_CURRENT_USER_IE_PROXY_CONFIG    IEProxyCfg;
    WINHTTP_AUTOPROXY_OPTIONS               AutoProxyOpt;
    DWORD                                   dwErr = ERROR_SUCCESS;
    BOOL                                    fUseAutoProxy = FALSE;
    BOOL                                    fGotProxy = FALSE;
    BOOL                                    fRet = FALSE;
    
    ZeroMemory(&IEProxyCfg, sizeof(IEProxyCfg));
    ZeroMemory(&AutoProxyOpt, sizeof(AutoProxyOpt));

    // only need to acquire the CS if we're caching results
    if (fCacheResults)
        g_csCache.Lock();
    
    if (pAUProxyInfo == NULL || hInternet == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        goto done;
    }
    
    ZeroMemory(pAUProxyInfo, sizeof(SAUProxyInfo));

    // if we're not caching results, skip directly to the proxy fetch
    if (fCacheResults && 
        g_wudlProxyCache.Find(wszSrv, &pAUProxyInfo->ProxyInfo.lpszProxy,
                              &pAUProxyInfo->ProxyInfo.lpszProxyBypass,
                              &pAUProxyInfo->ProxyInfo.dwAccessType))
    {
        LOG_Internet(_T("WinHttp: Cached proxy settings Proxy: %ls | Bypass: %ls | AccessType: %d"),
                     StringOrConstW(pAUProxyInfo->ProxyInfo.lpszProxy, L"(none)"),
                     StringOrConstW(pAUProxyInfo->ProxyInfo.lpszProxyBypass, L"(none)"),
                     pAUProxyInfo->ProxyInfo.dwAccessType);

        pAUProxyInfo->wszProxyOrig = pAUProxyInfo->ProxyInfo.lpszProxy;

        // we'll deal with this function failing later on when we cycle thru
        //  the proxies.  We'll basically only use the first and never cycle
        if (ProxyListToArray(pAUProxyInfo->wszProxyOrig,
                             &pAUProxyInfo->rgwszProxies,
                             &pAUProxyInfo->cProxies))
        {
            DWORD iProxy;
            
            iProxy = GetInitialProxyIndex(pAUProxyInfo->cProxies);
            pAUProxyInfo->ProxyInfo.lpszProxy = pAUProxyInfo->rgwszProxies[iProxy];
            pAUProxyInfo->iProxy              = iProxy;
            
        }
        
        goto done;
    }
        
    // first try to get the current user's IE configuration
    fRet = (*sfns.pfnWinHttpGetIEProxyConfigForCurrentUser)(&IEProxyCfg);
    if (fRet)
    {
        LOG_Internet(_T("WinHttp: Read IE user proxy settings"));
        
        if (IEProxyCfg.fAutoDetect)
        {
            AutoProxyOpt.dwFlags           = WINHTTP_AUTOPROXY_AUTO_DETECT;
            AutoProxyOpt.dwAutoDetectFlags = WINHTTP_AUTO_DETECT_TYPE_DHCP |
                                             WINHTTP_AUTO_DETECT_TYPE_DNS_A;
            fUseAutoProxy = TRUE;
        }

        if (IEProxyCfg.lpszAutoConfigUrl != NULL)
        {
            AutoProxyOpt.dwFlags           |= WINHTTP_AUTOPROXY_CONFIG_URL;
            AutoProxyOpt.lpszAutoConfigUrl = IEProxyCfg.lpszAutoConfigUrl;
            fUseAutoProxy = TRUE;
        }

        AutoProxyOpt.fAutoLogonIfChallenged = TRUE;
        
    }

    // couldn't get current user's config options, so just try autoproxy
    else 
    {
        AutoProxyOpt.dwFlags           = WINHTTP_AUTOPROXY_AUTO_DETECT;
        AutoProxyOpt.dwAutoDetectFlags = WINHTTP_AUTO_DETECT_TYPE_DHCP |
                                         WINHTTP_AUTO_DETECT_TYPE_DNS_A;
        AutoProxyOpt.fAutoLogonIfChallenged = TRUE;

        fUseAutoProxy = TRUE;
    }

    if (fUseAutoProxy)
    {
        LOG_Internet(_T("WinHttp: Doing autoproxy detection"));

        fGotProxy = (*sfns.pfnWinHttpGetProxyForUrl)(hInternet, wszURL, 
                                                     &AutoProxyOpt, 
                                                     &pAUProxyInfo->ProxyInfo);
    }

    // if we didn't try to autoconfigure the proxy or we did & it failed, then
    //  check and see if we had one defined by the user
    if ((fUseAutoProxy == FALSE || fGotProxy == FALSE) && 
        IEProxyCfg.lpszProxy != NULL)
    {
        // the empty string and L':' are not valid server names, so skip them
        //  if they are what is set for the proxy
        if (!(IEProxyCfg.lpszProxy[0] == L'\0' ||
              (IEProxyCfg.lpszProxy[0] == L':' && 
               IEProxyCfg.lpszProxy[1] == L'\0')))
        {
            pAUProxyInfo->ProxyInfo.dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
            pAUProxyInfo->ProxyInfo.lpszProxy    = IEProxyCfg.lpszProxy;
            IEProxyCfg.lpszProxy                 = NULL;
        }
        
        // the empty string and L':' are not valid server names, so skip them
        //  if they are what is set for the proxy bypass
        if (IEProxyCfg.lpszProxyBypass != NULL && 
            !(IEProxyCfg.lpszProxyBypass[0] == L'\0' ||
              (IEProxyCfg.lpszProxyBypass[0] == L':' && 
               IEProxyCfg.lpszProxyBypass[1] == L'\0')))
        {
            pAUProxyInfo->ProxyInfo.lpszProxyBypass = IEProxyCfg.lpszProxyBypass;
            IEProxyCfg.lpszProxyBypass              = NULL;
        }
    }

    LOG_Internet(_T("WinHttp: Proxy settings Proxy: %ls | Bypass: %ls | AccessType: %d"),
                 StringOrConstW(pAUProxyInfo->ProxyInfo.lpszProxy, L"(none)"),
                 StringOrConstW(pAUProxyInfo->ProxyInfo.lpszProxyBypass, L"(none)"),
                 pAUProxyInfo->ProxyInfo.dwAccessType);

    // don't really care if this fails.  It'll just mean a perf hit the next
    //  time we go fetch the proxy info
    if (fCacheResults &&
        g_wudlProxyCache.Set(wszSrv, pAUProxyInfo->ProxyInfo.lpszProxy,
                             pAUProxyInfo->ProxyInfo.lpszProxyBypass,
                             pAUProxyInfo->ProxyInfo.dwAccessType) == FALSE)
    {
        LOG_Internet(_T("WinHttp: Attempt to cache proxy info failed: %d"), 
                     GetLastError());
    }

    pAUProxyInfo->wszProxyOrig = pAUProxyInfo->ProxyInfo.lpszProxy;

    // we'll deal with this function failing later on when we cycle thru the
    //  proxies.  We'll basically only use the first and never cycle
    // Note that this function call has to be AFTER the cache call since we 
    //  modify the proxy list by embedding null terminators in it in place of
    //  the separating semicolons.
    if (ProxyListToArray(pAUProxyInfo->wszProxyOrig, &pAUProxyInfo->rgwszProxies,
                         &pAUProxyInfo->cProxies))
    {
        DWORD iProxy;
        
        iProxy = GetInitialProxyIndex(pAUProxyInfo->cProxies);
        pAUProxyInfo->ProxyInfo.lpszProxy = pAUProxyInfo->rgwszProxies[iProxy];
        pAUProxyInfo->iProxy              = iProxy;
        
    }

    fRet = TRUE;

done:
    // only need to release the CS if we're caching results
    if (fCacheResults)
        g_csCache.Unlock();
    
    dwErr = GetLastError();
    
    if (IEProxyCfg.lpszAutoConfigUrl != NULL)
        GlobalFree(IEProxyCfg.lpszAutoConfigUrl);
    if (IEProxyCfg.lpszProxy != NULL)
        GlobalFree(IEProxyCfg.lpszProxy);
    if (IEProxyCfg.lpszProxyBypass != NULL)
        GlobalFree(IEProxyCfg.lpszProxyBypass);

    SetLastError(dwErr);

    return fRet;
}

// **************************************************************************
static
HRESULT MakeRequest(SWinHTTPFunctions   &sfns,
                    HINTERNET hConnect, 
                    HINTERNET hRequest,
                    LPCWSTR wszSrv,
                    LPCWSTR wszVerb, 
                    LPCWSTR wszObject, 
                    SAUProxyInfo *pAUProxyInfo, 
                    HANDLE *rghEvents, 
                    DWORD cEvents, 
                    HINTERNET *phRequest)
{
    LOG_Block("MakeRequest()");

    HINTERNET   hOpenRequest = hRequest;
    LPCWSTR     wszAcceptTypes[] = {L"*/*", NULL};
    HRESULT     hr = S_OK;
    DWORD       iProxy = 0, dwErr;
    BOOL        fProxy, fContinue = TRUE;

    fProxy = (pAUProxyInfo != NULL && pAUProxyInfo->ProxyInfo.lpszProxy != NULL);

    LOG_Internet(_T("WinHttp: Making %ls request for %ls"), wszVerb, wszObject);

    // if we were passed in a request handle, then use it.  Otherwise, gotta 
    //  open one
    if (hOpenRequest == NULL)
    {
        hOpenRequest = (*sfns.pfnWinHttpOpenRequest)(hConnect, wszVerb, wszObject, 
                                                     NULL, NULL, wszAcceptTypes, 0);
        if (hOpenRequest == NULL)
        {
            hr = HRESULT_FROM_WIN32(GetLastError());
            LOG_ErrorMsg(hr);
            goto done;
        }
    }

    if (HandleEvents(rghEvents, cEvents) == FALSE)
    {
        hr = E_ABORT;
        goto done;
    }
    
    // if we have a list of proxies & the first one is bad, winhttp won't try
    //  any others.  So we have to do it ourselves.  That is the purpose of this 
    //  loop.
    if (fProxy && 
        pAUProxyInfo->cProxies > 1 && pAUProxyInfo->rgwszProxies != NULL)
        iProxy = (pAUProxyInfo->iProxy + 1) % pAUProxyInfo->cProxies;
    for(;;)
    {
        
       if (fProxy)
       {
            LOG_Internet(_T("WinHttp: Using proxy: Proxy: %ls | Bypass %ls | AccessType: %d"),
                         StringOrConstW(pAUProxyInfo->ProxyInfo.lpszProxy, L"(none)"),
                         StringOrConstW(pAUProxyInfo->ProxyInfo.lpszProxyBypass, L"(none)"),
                         pAUProxyInfo->ProxyInfo.dwAccessType);

            if ((*sfns.pfnWinHttpSetOption)(hOpenRequest, WINHTTP_OPTION_PROXY, 
                                            &pAUProxyInfo->ProxyInfo, 
                                            sizeof(WINHTTP_PROXY_INFO)) == FALSE)
            {
                hr = HRESULT_FROM_WIN32(GetLastError());
                LOG_ErrorMsg(hr);
                goto done;
            }
        }

        hr = S_OK;
        SetLastError(ERROR_SUCCESS);
        
        if ((*sfns.pfnWinHttpSendRequest)(hOpenRequest, NULL, 0, NULL, 0, 0, 0) == FALSE)
        {
//            dwErr = GetLastError();
//            LOG_Internet(_T("WinHttp: WinHttpSendRequest failed: %d.  Request object at: 0x%x"), 
//                         dwErr, hOpenRequest);
//            SetLastError(dwErr);

            goto loopDone;
        }
        
        if ((*sfns.pfnWinHttpReceiveResponse)(hOpenRequest, 0) == FALSE)
        {
//            dwErr = GetLastError();
//            LOG_Internet(_T("WinHttp: WinHttpReceiveResponse failed: %d.  Request object at: 0x%x"), 
//                         dwErr, hOpenRequest);
//            SetLastError(dwErr);

            goto loopDone;
        }

loopDone:
        fContinue = FALSE;
        dwErr = GetLastError();
        if (dwErr != ERROR_SUCCESS)
            hr = HRESULT_FROM_WIN32(dwErr);
        else
            hr = S_OK;

        // if we succeeded, then we're done here...
        if (SUCCEEDED(hr))
        {
            if (fProxy)
            {
                if (g_csCache.Lock() == FALSE)
                {
                    hr = E_FAIL;
                    goto done;
                }
                
                g_wudlProxyCache.SetLastGoodProxy(wszSrv, pAUProxyInfo->iProxy);
   
                // Unlock returns FALSE as well, but we should never get here cuz 
                //  we should not have been able to take the lock above.
                g_csCache.Unlock();
            }
            
            break;
        }
        
        LOG_ErrorMsg(hr);

        // we only care about retrying if we have a proxy server & get a 
        //  'cannot connect' error.
        if (fProxy && 
            (dwErr == ERROR_WINHTTP_CANNOT_CONNECT ||
             dwErr == ERROR_WINHTTP_CONNECTION_ERROR ||
             dwErr == ERROR_WINHTTP_NAME_NOT_RESOLVED ||
             dwErr == ERROR_WINHTTP_TIMEOUT))
        {
            LOG_Internet(_T("WinHttp: Connection failure: %d"), dwErr);
            if (pAUProxyInfo->cProxies > 1 && pAUProxyInfo->rgwszProxies != NULL && 
                iProxy != pAUProxyInfo->iProxy)
            {
                pAUProxyInfo->ProxyInfo.lpszProxy = pAUProxyInfo->rgwszProxies[iProxy];
                iProxy = (iProxy + 1) % pAUProxyInfo->cProxies;
                fContinue = TRUE;
            }
            else
            {
                LOG_Internet(_T("WinHttp: No proxies left.  Failing download."));
            }
        }

        if (fContinue == FALSE)
            goto done;
    }

    
    if (FAILED(hr))
        goto done;


    if (HandleEvents(rghEvents, cEvents) == FALSE)
    {
        hr = E_ABORT;
        goto done;
    }

    *phRequest   = hOpenRequest;
    hOpenRequest = NULL;
    
done:
    // don't want to free the handle if we didn't open it.
    if (hRequest != hOpenRequest)
        SafeWinHTTPCloseHandle(sfns, hOpenRequest);
    return hr;
}

// **************************************************************************
static
HRESULT CheckFileHeader(SWinHTTPFunctions   &sfns,
                        HINTERNET hOpenRequest, 
                        HANDLE *rghEvents, 
                        DWORD cEvents, 
                        LPCWSTR wszFile,
                        DWORD *pcbFile,
                        FILETIME *pft)
{
    LOG_Block("CheckFileHeader()");

    SYSTEMTIME  st;
    FILETIME    ft;
    HRESULT     hr = S_OK;
    DWORD       dwLength, dwStatus, dwFileSize, dwErr;

    dwLength = sizeof(st);
    if ((*sfns.pfnWinHttpQueryHeaders)(hOpenRequest, 
                                       WINHTTP_QUERY_LAST_MODIFIED | WINHTTP_QUERY_FLAG_SYSTEMTIME, 
                                       NULL, (LPVOID)&st, &dwLength, NULL) == FALSE)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        LOG_ErrorMsg(hr);
        goto done;
    }

    SystemTimeToFileTime(&st, &ft);

    // Now Get the FileSize information from the Server
    dwLength = sizeof(dwFileSize);
    if ((*sfns.pfnWinHttpQueryHeaders)(hOpenRequest, 
                                       WINHTTP_QUERY_CONTENT_LENGTH | WINHTTP_QUERY_FLAG_NUMBER, 
                                       NULL, (LPVOID)&dwFileSize, &dwLength, NULL) == FALSE)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        LOG_ErrorMsg(hr);
        goto done;
    }
    
    if (HandleEvents(rghEvents, cEvents) == FALSE)
    {
        hr = E_ABORT;
        goto done;
    }

    if (pcbFile != NULL)
        *pcbFile = dwFileSize;
    if (pft != NULL)
        CopyMemory(pft, &ft, sizeof(FILETIME));

    hr = IsServerFileDifferentW(ft, dwFileSize, wszFile) ? S_OK : S_FALSE;

done:
    return hr;
}

// **************************************************************************
static
HRESULT GetContentTypeHeader(SWinHTTPFunctions &sfns,
                             HINTERNET hOpenRequest,
                             LPWSTR *pwszContentType)
{
    LOG_Block("GetContentTypeHeader()");

    HRESULT hr = S_OK;
    LPWSTR  wszContentType = NULL;
    DWORD   dwLength, dwErr;
    BOOL    fRet;

    *pwszContentType = NULL;

    dwLength = 0;
    fRet = (*sfns.pfnWinHttpQueryHeaders)(hOpenRequest, 
                                          WINHTTP_QUERY_CONTENT_TYPE, 
                                          NULL, (LPVOID)NULL, &dwLength, 
                                          NULL);
    if (fRet == FALSE && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        LOG_ErrorMsg(hr);
        goto done;
    }

    if (dwLength == 0)
    {
        hr = HRESULT_FROM_WIN32(ERROR_WINHTTP_HEADER_NOT_FOUND);
        goto done;
    }

    wszContentType = (LPWSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 
                                       dwLength);
    if (wszContentType == NULL)
    {
        hr = E_INVALIDARG;
        LOG_ErrorMsg(hr);
        goto done;
    }

    if ((*sfns.pfnWinHttpQueryHeaders)(hOpenRequest, 
                                       WINHTTP_QUERY_CONTENT_TYPE, 
                                       NULL, (LPVOID)wszContentType, &dwLength, 
                                       NULL) == FALSE)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        LOG_ErrorMsg(hr);
        goto done;
    }

    *pwszContentType = wszContentType;
    wszContentType   = NULL;

done:
    SafeHeapFree(wszContentType);

    return hr;
}


// **************************************************************************
static
HRESULT StartWinHttpDownload(SWinHTTPFunctions &sfns,
                             LPCWSTR wszUrl, 
                             LPCWSTR wszLocalFile,
                             DWORD   *pcbDownloaded,
                             HANDLE  *rghQuitEvents,
                             UINT    cQuitEvents,
                             PFNDownloadCallback pfnCallback,
                             LPVOID  pvCallbackData,
                             DWORD   dwFlags,
                             DWORD   cbDownloadBuffer)
{
    LOG_Block("StartWinHttpDownload()");

    URL_COMPONENTS  UrlComponents;
    SAUProxyInfo    AUProxyInfo;

    HINTERNET   hInternet = NULL;
    HINTERNET   hConnect = NULL;
    HINTERNET   hOpenRequest = NULL;
    DWORD       dwStatus, dwAccessType;

    LPWSTR      wszServerName = NULL;
    LPWSTR      wszObject = NULL;
    LPWSTR      wszContentType = NULL;
    WCHAR       wszUserName[UNLEN + 1];
    WCHAR       wszPasswd[UNLEN + 1];
    WCHAR       wszScheme[32];

    // NULL (equivalent to "GET") MUST be the last verb in the list
    LPCWSTR     rgwszVerbs[] = { L"HEAD", NULL };
    DWORD       iVerb;

    HRESULT     hr = S_OK, hrToReturn = S_OK;
    BOOL        fRet = TRUE;

    FILETIME    ft;
    HANDLE      hFile = INVALID_HANDLE_VALUE;
    DWORD       cbRemoteFile;

    DWORD       dwLength;
    DWORD       dwTickStart = 0, dwTickEnd = 0;

    int         iRetryCounter = -1;         // non-negative during download mode

    BOOL        fAllowProxy = ((dwFlags & WUDF_DONTALLOWPROXY) == 0);
    BOOL        fCheckStatusOnly = ((dwFlags & WUDF_CHECKREQSTATUSONLY) != 0);
    BOOL        fAppendCacheBreaker = ((dwFlags & WUDF_APPENDCACHEBREAKER) != 0);
    BOOL        fSkipDownloadRetry = ((dwFlags & WUDF_DODOWNLOADRETRY) == 0);
    BOOL        fDoCabValidation = ((dwFlags & WUDF_SKIPCABVALIDATION) == 0);
    BOOL        fCacheProxyInfo = ((dwFlags & WUDF_SKIPAUTOPROXYCACHE) == 0);

    ZeroMemory(&AUProxyInfo, sizeof(AUProxyInfo));

    if ((wszUrl == NULL) || 
        (wszLocalFile == NULL && fCheckStatusOnly == FALSE))
    {
        LOG_ErrorMsg(E_INVALIDARG);
        return E_INVALIDARG;
    }

    if (pcbDownloaded != NULL)
        *pcbDownloaded = 0;

    wszServerName = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, c_cchMaxURLSize * sizeof(WCHAR));
    wszObject     = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, c_cchMaxURLSize * sizeof(WCHAR));
    if (wszServerName == NULL || wszObject == NULL)
    {
        LOG_ErrorMsg(E_OUTOFMEMORY);
        hr = E_OUTOFMEMORY;
        goto CleanUp;
    }

    wszServerName[0] = L'\0';
    wszObject[0]     = L'\0';
    wszUserName[0]   = L'\0';
    wszPasswd[0]     = L'\0';

    if (HandleEvents(rghQuitEvents, cQuitEvents) == FALSE)
    {
        hr = E_ABORT;
        goto CleanUp;
    }

    // Break down the URL into its various components for the InternetAPI calls.
    //  Specifically we need the server name, object to download, username and 
    //  password information.
    ZeroMemory(&UrlComponents, sizeof(UrlComponents));
    UrlComponents.dwStructSize     = sizeof(UrlComponents);
    UrlComponents.lpszHostName     = wszServerName;
    UrlComponents.dwHostNameLength = c_cchMaxURLSize;
    UrlComponents.lpszUrlPath      = wszObject;
    UrlComponents.dwUrlPathLength  = c_cchMaxURLSize;
    UrlComponents.lpszUserName     = wszUserName;
    UrlComponents.dwUserNameLength = ARRAYSIZE(wszUserName);
    UrlComponents.lpszPassword     = wszPasswd;
    UrlComponents.dwPasswordLength = ARRAYSIZE(wszPasswd);
    UrlComponents.lpszScheme       = wszScheme;
    UrlComponents.dwSchemeLength   = ARRAYSIZE(wszScheme);

    LOG_Internet(_T("WinHttp: Downloading URL %ls to FILE %ls"), wszUrl, wszLocalFile);

    if ((*sfns.pfnWinHttpCrackUrl)(wszUrl, 0, 0, &UrlComponents) == FALSE)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        LOG_ErrorMsg(hr);
        goto CleanUp;
    }

    if (wszUrl[0] == L'\0' || wszScheme[0] == L'\0' || wszServerName[0] == L'\0' ||
        _wcsicmp(wszScheme, L"http") != 0)
    {
        LOG_ErrorMsg(E_INVALIDARG);
        hr = E_INVALIDARG;
        goto CleanUp;
    }

    if (fAppendCacheBreaker)
    {
        SYSTEMTIME  stCB;
        WCHAR       wszCacheBreaker[12];
        
        GetSystemTime(&stCB);
        hr = StringCchPrintfExW(wszCacheBreaker, ARRAYSIZE(wszCacheBreaker),
                                NULL, NULL, MISTSAFE_STRING_FLAGS,
                                L"?%02d%02d%02d%02d%02d", 
                                stCB.wYear % 100,
                                stCB.wMonth,
                                stCB.wDay,
                                stCB.wHour,
                                stCB.wMinute);
        if (FAILED(hr))
            goto CleanUp;

        hr = StringCchCatExW(wszObject, c_cchMaxURLSize, wszCacheBreaker, 
                             NULL, NULL, MISTSAFE_STRING_FLAGS);
        if (FAILED(hr))
            goto CleanUp;
    }

    if (fAllowProxy)
        dwAccessType = WINHTTP_ACCESS_TYPE_DEFAULT_PROXY;
    else
        dwAccessType = WINHTTP_ACCESS_TYPE_NO_PROXY;
    
    dwTickStart = GetTickCount();
    
START_INTERNET:
    // start to deal with Internet    
    iRetryCounter++; 
    
    // If the connection has already been established re-use it.
    hInternet = (*sfns.pfnWinHttpOpen)(c_wszUserAgent, dwAccessType, NULL, NULL, 0);
    if (hInternet == NULL)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        LOG_ErrorMsg(hr);
        goto CleanUp;
    }

    if (fAllowProxy != NULL)
    {
        GetWinHTTPProxyInfo(sfns, fCacheProxyInfo, hInternet, wszUrl, 
                            wszServerName, &AUProxyInfo);
    }

    hConnect = (*sfns.pfnWinHttpConnect)(hInternet, wszServerName, INTERNET_DEFAULT_HTTP_PORT, 0);
    if (hConnect == NULL)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        LOG_ErrorMsg(hr);
        goto CleanUp;
    }

    // if we're only doing a status check, then may as well just make a GET 
    //  request
    iVerb = (DWORD)((fCheckStatusOnly) ? ARRAYSIZE(rgwszVerbs) - 1 : 0);
    for(; iVerb < ARRAYSIZE(rgwszVerbs); iVerb++)
    {
        SafeWinHTTPCloseHandle(sfns, hOpenRequest);

        hr = MakeRequest(sfns, hConnect, NULL, wszServerName, rgwszVerbs[iVerb], 
                         wszObject, ((fAllowProxy) ? &AUProxyInfo : NULL),
                         rghQuitEvents, cQuitEvents, &hOpenRequest);
        if (FAILED(hr))
            goto CleanUp;
        
        dwLength = sizeof(dwStatus);
        if ((*sfns.pfnWinHttpQueryHeaders)(hOpenRequest, 
                                           WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, 
                                           NULL, (LPVOID)&dwStatus, &dwLength, NULL) == FALSE)
        {
            hr = HRESULT_FROM_WIN32(GetLastError());
            LOG_ErrorMsg(hr);
            goto CleanUp;
        }

        LOG_Internet(_T("WinHttp: Request result: %d"), dwStatus);

        if (dwStatus == HTTP_STATUS_OK || dwStatus == HTTP_STATUS_PARTIAL_CONTENT)
        {
            break;
        }
        else
        {
            // since a server result is not a proper win32 error code, we can't 
            //  really do a HRESULT_FROM_WIN32 here.  Otherwise, we'd return
            //  a bogus code.  However, we do want to pass an error HRESULT back
            //  that contains this code.
            hr = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_HTTP, dwStatus);
            LOG_Error(_T("WinHttp: got failed status code from server %d\n"), dwStatus);

            // if it's the last verb in the list, then bail...
            if (rgwszVerbs[iVerb] == NULL)
                goto CleanUp;
        }
    }

    // if we made it here & we're only trying to check status, then we're done
    if (fCheckStatusOnly)
    {
        LOG_Internet(_T("WinHttp: Only checking status.  Exiting before header check and download."));
        hr = S_OK;
        goto CleanUp;
    }

    // CheckFileHeader will return S_OK if we need to download the file, S_FALSE
    //  if we don't, and some other HRESULT if a failure occurred
    hr = CheckFileHeader(sfns, hOpenRequest, rghQuitEvents, cQuitEvents, 
                         wszLocalFile, &cbRemoteFile, &ft);
    if (FAILED(hr))
        goto CleanUp;

    // unless we have a flag that explicitly allows it, do not retry downloads 
    //  here.  The reasoning is that we could be in the middle of a large 
    //  download and have it fail...
    if (fSkipDownloadRetry)
        iRetryCounter = c_cMaxRetries;

    if (hr == S_OK)
    {
        DWORD cbDownloaded;
        BOOL  fCheckForHTML = fDoCabValidation;

        LOG_Internet(_T("WinHttp: Server file was newer.  Downloading file"));
        
        // if we didn't open with a GET request above, then we gotta open a new
        //  request.  Otherwise, can reuse the request object...
        if (rgwszVerbs[iVerb] != NULL)
            SafeWinHTTPCloseHandle(sfns, hOpenRequest);

        // now we know we need to download this file
        hr = MakeRequest(sfns, hConnect, hOpenRequest, wszServerName, NULL, 
                         wszObject, ((fAllowProxy) ? &AUProxyInfo : NULL), 
                         rghQuitEvents, cQuitEvents, &hOpenRequest);
        if (FAILED(hr))
            goto CleanUp;

        // sometimes, we can get fancy error pages back from the site instead of 
        //  a nice nifty HTML error code, so check & see if we got back a html
        //  file when we were expecting a cab.
        if (fCheckForHTML)
        {
            hr = GetContentTypeHeader(sfns, hOpenRequest, &wszContentType);
            if (SUCCEEDED(hr) && wszContentType != NULL)
            {
                fCheckForHTML = FALSE;
                if (_wcsicmp(wszContentType, L"text/html") == 0)
                {
                    LOG_Internet(_T("WinHttp: Content-Type header is text/html.  Bailing."));
                    hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
                    goto CleanUp;
                }
                else
                {
                    LOG_Internet(_T("WinHttp: Content-Type header is %ls.  Continuing."), wszContentType);
                }
            }

            hr = NOERROR;
        }

        // open the file we're gonna spew into
        hFile = CreateFileW(wszLocalFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 
                            FILE_ATTRIBUTE_NORMAL, NULL);
        if (hFile == INVALID_HANDLE_VALUE)
        {
            hr = HRESULT_FROM_WIN32(GetLastError());
            LOG_ErrorMsg(hr);
            goto CleanUp;
        }

        LOG_Internet(_T("WinHttp: downloading to FILE %ls"), wszLocalFile);

        // bring down the bits
        hr = PerformDownloadToFile(sfns.pfnWinHttpReadData, hOpenRequest, 
                                   hFile, cbRemoteFile,
                                   cbDownloadBuffer, 
                                   rghQuitEvents, cQuitEvents, 
                                   pfnCallback, pvCallbackData, &cbDownloaded);
        if (FAILED(hr))
        {
            LOG_Internet(_T("WinHttp: Download failed: hr: 0x%08x"), hr);
            SafeCloseInvalidHandle(hFile);
            DeleteFileW(wszLocalFile);
            goto CleanUp;
        }

        LOG_Internet(_T("WinHttp: Download succeeded"));

        // set the file time to match the server file time since we just 
        //  downloaded it. If we don't do this the file time will be set 
        //  to the current system time.
        SetFileTime(hFile, &ft, NULL, NULL);
        SafeCloseInvalidHandle(hFile);

        if (pcbDownloaded != NULL)
            *pcbDownloaded = cbRemoteFile;

        // sometimes, we can get fancy error pages back from the site instead of 
        //  a nice nifty HTML error code, so check & see if we got back a html
        //  file when we were expecting a cab.
        if (fCheckForHTML)
        {
            hr = IsFileHtml(wszLocalFile);
            if (SUCCEEDED(hr))
            {
                if (hr == S_FALSE)
                {
                    LOG_Internet(_T("WinHttp: Download is not a html file"));
                    hr = S_OK;
                }
                else
                {
                    LOG_Internet(_T("WinHttp: Download is a html file.  Failing download."));
                    hr = HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
                    DeleteFileW(wszLocalFile);
                    goto CleanUp;
                }
            }
            else
            {
                LOG_Internet(_T("WinHttp: Unable to determine if download is a html file or not.  Failing download."));
            }
        }
        else if (fDoCabValidation == FALSE)
        {
            LOG_Internet(_T("WinHttp: Skipping cab validation."));
        }
    }
    else
    {
        hr = S_OK;
        
        LOG_Internet(_T("WinHttp: Server file is not newer.  Skipping download."));
        
        // The server ain't newer & the file is already on machine, so
        //  send progress callback indicating file downloadeded ok
        if (pfnCallback != NULL)
        {
            // fpnCallback(pCallbackData, DOWNLOAD_STATUS_FILECOMPLETE, dwFileSize, dwFileSize, NULL, NULL);
            pfnCallback(pvCallbackData, DOWNLOAD_STATUS_OK, cbRemoteFile, cbRemoteFile, NULL, NULL);
        }
    }

CleanUp:
    SafeWinHTTPCloseHandle(sfns, hOpenRequest);
    SafeWinHTTPCloseHandle(sfns, hConnect);
    SafeWinHTTPCloseHandle(sfns, hInternet);

    SafeHeapFree(wszContentType);

    // free up the proxy strings- they were allocated by WinHttp
    if (AUProxyInfo.ProxyInfo.lpszProxyBypass != NULL)
        GlobalFree(AUProxyInfo.ProxyInfo.lpszProxyBypass);
    if (AUProxyInfo.wszProxyOrig != NULL)
        GlobalFree(AUProxyInfo.wszProxyOrig);
    if (AUProxyInfo.rgwszProxies != NULL)
        GlobalFree(AUProxyInfo.rgwszProxies);
    ZeroMemory(&AUProxyInfo, sizeof(AUProxyInfo));
    
    // if we failed, see if it's ok to continue (quit events) and whether
    //  we've tried enuf times yet.
    if (FAILED(hr) &&
        HandleEvents(rghQuitEvents, cQuitEvents) &&
        iRetryCounter >= 0 && iRetryCounter < c_cMaxRetries)
    {
        DWORD dwElapsedTime;

        dwTickEnd = GetTickCount();
        if (dwTickEnd > dwTickStart)   
            dwElapsedTime = dwTickEnd - dwTickStart;
        else
            dwElapsedTime = (0xFFFFFFFF - dwTickStart) + dwTickEnd;
        
        // We haven't hit our retry limit, so log & error and go again
        if (dwElapsedTime < c_dwRetryTimeLimitInmsWinHttp)
        {
            LogError(hr, "Library download error. Will retry.");

            // in the case where we're gonna retry, keep track of the very first
            //  error we encoutered cuz the ops guys say that this is the most
            //  useful error to know about.
            if (iRetryCounter == 0)
            {
                LOG_Internet(_T("First download error saved: 0x%08x."), hr);
                hrToReturn = hr;
            }
            else
            {
                LOG_Internet(_T("Subsequent download error: 0x%08x."), hr);
            }
            hr = S_OK;
            goto START_INTERNET;
        }

        // We've completely timed out, so bail
        else
        {
            LogError(hr, "Library download error and timed out (%d ms). Will not retry.", dwElapsedTime);
        }
    }
    
    // make a callback indicating a download error
    if (FAILED(hr) && pfnCallback != NULL)
        pfnCallback(pvCallbackData, DOWNLOAD_STATUS_ERROR, cbRemoteFile, 0, NULL, NULL);

    // if we haven't saved off an error, just use the current error.  We can't
    //  have set hrToReturn previously if we didn't fail and want to attempt 
    //  a retry.
    // However, if we've got a success from this pass, be sure to return that 
    //  and not a fail code.
    if (FAILED(hr) && SUCCEEDED(hrToReturn))
        hrToReturn = hr;
    else if (SUCCEEDED(hr) && FAILED(hrToReturn))
        hrToReturn = hr;

    SafeHeapFree(wszServerName);
    SafeHeapFree(wszObject);
    
    return hrToReturn;
}

#endif // defined(UNICODE)

///////////////////////////////////////////////////////////////////////////////
// exported functions

#if defined(UNICODE)

// **************************************************************************
HRESULT  GetAUProxySettings(LPCWSTR wszUrl, SAUProxySettings *paups)
{
    LOG_Block("GetAUProxySettings()");

    URL_COMPONENTS      UrlComponents;
    LPWSTR              wszServerName = NULL;
    LPWSTR              wszObject = NULL;
    WCHAR               wszUserName[UNLEN + 1];
    WCHAR               wszPasswd[UNLEN + 1];
    WCHAR               wszScheme[32];

    SWinHTTPFunctions   sfns;
    ETransportUsed      etu;
    HMODULE             hmod = NULL;
    HRESULT             hr = S_OK;
    BOOL                fRet, fLocked = FALSE;

    if (wszUrl == NULL || paups == NULL)
    {
        hr = E_INVALIDARG;
        goto done;
    }

    ZeroMemory(paups, sizeof(SAUProxySettings));

    etu = LoadTransportDll(&sfns, &hmod, WUDF_ALLOWWINHTTPONLY);
    if (etu == etuNone)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        LOG_ErrorMsg(hr);
        goto done;
    }
    else if (etu != etuWinHttp)
    {
        hr = E_FAIL;
        LOG_Internet(_T("GetAUProxySettings called when in WinInet mode."));
        goto done;
    }

    wszServerName = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, c_cchMaxURLSize * sizeof(WCHAR));
    wszObject     = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, c_cchMaxURLSize * sizeof(WCHAR));
    if (wszServerName == NULL || wszObject == NULL)
    {
        LOG_ErrorMsg(E_OUTOFMEMORY);
        hr = E_OUTOFMEMORY;
        goto done;
    }

    ZeroMemory(&UrlComponents, sizeof(UrlComponents));
    UrlComponents.dwStructSize     = sizeof(UrlComponents);
    UrlComponents.lpszHostName     = wszServerName;
    UrlComponents.dwHostNameLength = c_cchMaxURLSize;
    UrlComponents.lpszUrlPath      = wszObject;
    UrlComponents.dwUrlPathLength  = c_cchMaxURLSize;
    UrlComponents.lpszUserName     = wszUserName;
    UrlComponents.dwUserNameLength = ARRAYSIZE(wszUserName);
    UrlComponents.lpszPassword     = wszPasswd;
    UrlComponents.dwPasswordLength = ARRAYSIZE(wszPasswd);
    UrlComponents.lpszScheme       = wszScheme;
    UrlComponents.dwSchemeLength   = ARRAYSIZE(wszScheme);
    
    if ((*sfns.pfnWinHttpCrackUrl)(wszUrl, 0, 0, &UrlComponents) == FALSE)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        LOG_ErrorMsg(hr);
        goto done;
    }

    if (wszUrl[0] == L'\0' || wszScheme[0] == L'\0' || wszServerName[0] == L'\0' ||
        (_wcsicmp(wszScheme, L"http") != 0 && _wcsicmp(wszScheme, L"https") != 0))
    {
        LOG_ErrorMsg(E_INVALIDARG);
        hr = E_INVALIDARG;
        goto done;
    }
   
    if (g_csCache.Lock() == FALSE)
    {
        hr = E_FAIL;
        goto done;
    }
    fLocked = TRUE;

    // get the proxy list 
    if (g_wudlProxyCache.GetLastGoodProxy(wszServerName, paups) == FALSE)
    {
        
        // proxy was not in list
        if (GetLastError() == ERROR_FILE_NOT_FOUND)
        {
            SAUProxyInfo    aupi;
            HINTERNET       hInternet = NULL;

            LOG_Internet(_T("GetLastGoodProxy did not find a proxy object.  Doing autodetect."));
            
            hInternet = (*sfns.pfnWinHttpOpen)(c_wszUserAgent, 
                                               WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, 
                                               NULL, NULL, 0);
            if (hInternet == NULL)
            {
                hr = HRESULT_FROM_WIN32(GetLastError());
                LOG_ErrorMsg(hr);
                goto done;
            }

            fRet = GetWinHTTPProxyInfo(sfns, TRUE, hInternet, wszUrl, 
                                       wszServerName, &aupi);
            (*sfns.pfnWinHttpCloseHandle)(hInternet);
            if (fRet == FALSE)
            {
                hr = HRESULT_FROM_WIN32(GetLastError());
                LOG_ErrorMsg(hr);
                goto done;
            }

            paups->wszProxyOrig = aupi.wszProxyOrig;
            paups->wszBypass    = aupi.ProxyInfo.lpszProxyBypass;
            paups->dwAccessType = aupi.ProxyInfo.dwAccessType;
            paups->cProxies     = aupi.cProxies;
            paups->rgwszProxies = aupi.rgwszProxies;
            paups->iProxy       = (DWORD)-1;

            SetLastError(ERROR_SUCCESS);
            
        }
        else
        {
            LOG_Internet(_T("GetLastGoodProxy failed..."));
            hr = HRESULT_FROM_WIN32(GetLastError());
            LOG_ErrorMsg(hr);
            goto done;
        }
    }
    else
    {
        if (paups->wszProxyOrig != NULL)
        {
            // break it up into an array
            if (ProxyListToArray(paups->wszProxyOrig, &paups->rgwszProxies,
                                &paups->cProxies) == FALSE)
            {
                hr = HRESULT_FROM_WIN32(GetLastError());
                LOG_ErrorMsg(hr);
                goto done;
            }
        }
        else
        {
            paups->iProxy       = (DWORD)-1;
        }
    }
       
done:
    // Unlock returns FALSE as well, but we should never get here cuz we should
    //  not have been able to take the lock above.
    if (fLocked)
        g_csCache.Unlock();
    if (wszServerName != NULL)
        HeapFree(GetProcessHeap(), 0, wszServerName);
    if (wszObject != NULL)
        HeapFree(GetProcessHeap(), 0, wszObject);
        
    if (hmod != NULL)
        UnloadTransportDll(&sfns, hmod);
    
    return hr;
}

// **************************************************************************
HRESULT FreeAUProxySettings(SAUProxySettings *paups)
{
    LOG_Block("FreeAUProxySettings()");

    if (paups == NULL)
        goto done;
    
    if (paups->rgwszProxies != NULL)
        GlobalFree(paups->rgwszProxies);
    if (paups->wszBypass != NULL)
        GlobalFree(paups->wszBypass);
    if (paups->wszProxyOrig != NULL)
        GlobalFree(paups->wszProxyOrig);

done:
    return S_OK;
}

// **************************************************************************
HRESULT CleanupDownloadLib(void)
{
    LOG_Block("CleanupDownloadLib()");

    HRESULT hr = S_OK;

    if (g_hmodWinHttp != NULL)
    {
        FreeLibrary(g_hmodWinHttp);
        g_hmodWinHttp = NULL;        
    }

    if (g_hmodWinInet != NULL)
    {
        FreeLibrary(g_hmodWinInet);
        g_hmodWinInet = NULL;        
    }

    if (g_csCache.Lock() == FALSE)
        return E_FAIL;

    __try { g_wudlProxyCache.Empty(); }
    __except(EXCEPTION_EXECUTE_HANDLER) { hr = E_FAIL; }

    // this returns FALSE as well, but we should never get here cuz we should
    //  not have been able to take the lock above.
    g_csCache.Unlock();

    return hr;
}

// **************************************************************************
HRESULT DownloadFile(
            LPCWSTR wszServerUrl,            // full http url
            LPCWSTR wszLocalPath,            // local directory to download file to
            LPCWSTR wszLocalFileName,        // optional local file name to rename the downloaded file to if pszLocalPath does not contain file name
            PDWORD  pdwDownloadedBytes,      // bytes downloaded for this file
            HANDLE  *hQuitEvents,            // optional events causing this function to abort
            UINT    nQuitEventCount,         // number of quit events, must be 0 if array is NULL
            PFNDownloadCallback fpnCallback, // optional call back function
            VOID*   pCallbackData,           // parameter for call back function to use
            DWORD   dwFlags
)
{
    LOG_Block("DownloadFile()");

    SWinHTTPFunctions   sfns;
    ETransportUsed      etu;
    HMODULE             hmod = NULL;
    HRESULT             hr = S_OK;
    LPWSTR              wszLocalFile = NULL;
    DWORD               dwFlagsToUse;

    // for full download, disable cache breaker.
    dwFlagsToUse = dwFlags & ~WUDF_APPENDCACHEBREAKER;
    
    ZeroMemory(&sfns, sizeof(sfns));

    if (wszServerUrl == NULL || wszLocalPath == NULL)
    {
        LOG_ErrorMsg(ERROR_INVALID_PARAMETER);
        hr = E_INVALIDARG;
        goto done;
    }

    etu = LoadTransportDll(&sfns, &hmod, dwFlagsToUse);
    if (etu == etuNone)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        LOG_ErrorMsg(hr);
        goto done;
    }

    else if (etu != etuWinHttp && etu != etuWinInet)
    {
        hr = E_FAIL;
        LogError(hr, "Unexpected answer from LoadTransportDll(): %d", etu);
        goto done;
    }

    // Since StartDownload just takes a full path to the file to download, build
    //  it here...  
    // Note that we don't need to do this if we're just in status 
    //  checking mode)
    if ((dwFlags & WUDF_CHECKREQSTATUSONLY) == 0)
    {
        wszLocalFile = MakeFullLocalFilePath(wszServerUrl, wszLocalFileName, 
                                             wszLocalPath);
        if (wszLocalFile == NULL)
        {
            hr = HRESULT_FROM_WIN32(GetLastError());
            LOG_ErrorMsg(hr);
            goto done;
        }
    }

    if (etu == etuWinHttp)
    {
        hr = StartWinHttpDownload(sfns, wszServerUrl, wszLocalFile, 
                                  pdwDownloadedBytes, hQuitEvents, nQuitEventCount,
                                  fpnCallback, pCallbackData, dwFlagsToUse,
                                  c_cbDownloadBuffer);
    }

    else
    {
        hr = StartWinInetDownload(hmod, wszServerUrl, wszLocalFile, 
                                  pdwDownloadedBytes, hQuitEvents, nQuitEventCount, 
                                  fpnCallback, pCallbackData, dwFlagsToUse,
                                  c_cbDownloadBuffer);
    }

done:
    if (hmod != NULL)
        UnloadTransportDll(&sfns, hmod);
    SafeHeapFree(wszLocalFile);
    return hr;
}

// **************************************************************************
HRESULT DownloadFileLite(LPCWSTR wszDownloadUrl, 
                         LPCWSTR wszLocalFile,  
                         HANDLE hQuitEvent,
                         DWORD dwFlags)
{
    LOG_Block("DownloadFileLite()");

    SWinHTTPFunctions   sfns;
    ETransportUsed      etu;
    HMODULE             hmod = NULL;
    HRESULT             hr = S_OK;
    DWORD               dwFlagsToUse;


    // for lite download, force cache breaker & download retry
    dwFlagsToUse = dwFlags | WUDF_APPENDCACHEBREAKER | WUDF_DODOWNLOADRETRY;

    ZeroMemory(&sfns, sizeof(sfns));

    etu = LoadTransportDll(&sfns, &hmod, dwFlagsToUse);

    switch (etu)
    {
        case etuNone:
            LOG_ErrorMsg(GetLastError());
            hr = HRESULT_FROM_WIN32(GetLastError());
            goto done;

        case etuWinHttp:
            hr = StartWinHttpDownload(sfns, wszDownloadUrl, wszLocalFile, 
                                      NULL, 
                                      ((hQuitEvent != NULL) ? &hQuitEvent : NULL),
                                      ((hQuitEvent != NULL) ? 1 : 0),
                                      NULL, NULL, dwFlagsToUse,
                                      c_cbDownloadBuffer);
            break;

        case etuWinInet:
            hr = StartWinInetDownload(hmod, wszDownloadUrl, wszLocalFile,  
                                      NULL, 
                                      ((hQuitEvent != NULL) ? &hQuitEvent : NULL),
                                      ((hQuitEvent != NULL) ? 1 : 0),
                                      NULL, NULL, dwFlagsToUse,
                                      c_cbDownloadBuffer);
            break;
            
        default:
            LogError(hr, "Unexpected answer from LoadTransportDll(): %d", etu);
            hr = HRESULT_FROM_WIN32(GetLastError());
            goto done;
    }

done:
    if (hmod != NULL)
        UnloadTransportDll(&sfns, hmod);
    return hr;
}

#else // !defined(UNICODE)

// **************************************************************************
HRESULT  GetAUProxySettings(LPCWSTR wszUrl, SAUProxySettings *paups)
{
    return E_NOTIMPL;
}

// **************************************************************************
HRESULT FreeAUProxySettings(SAUProxySettings *paups)
{
    return E_NOTIMPL;
}

// **************************************************************************
HRESULT CleanupDownloadLib(void)
{
    if (g_hmodWinInet != NULL)
    {
        FreeLibrary(g_hmodWinInet);
        g_hmodWinInet = NULL;        
    }
    
    return NOERROR;
}

// **************************************************************************
HRESULT DownloadFile(
            LPCSTR  pszServerUrl,            // full http url
            LPCSTR  pszLocalPath,            // local directory to download file to
            LPCSTR  pszLocalFileName,        // optional local file name to rename the downloaded file to if pszLocalPath does not contain file name
            PDWORD  pdwDownloadedBytes,      // bytes downloaded for this file
            HANDLE  *hQuitEvents,            // optional events causing this function to abort
            UINT    nQuitEventCount,         // number of quit events, must be 0 if array is NULL
            PFNDownloadCallback fpnCallback, // optional call back function
            VOID*   pCallbackData,            // parameter for call back function to use
            DWORD   dwFlags
)
{
    LOG_Block("DownloadFile()");

    SWinHTTPFunctions   sfns;
    ETransportUsed      etu;
    HMODULE             hmod = NULL;
    HRESULT             hr = S_OK;
    LPSTR               pszLocalFile = NULL;
    DWORD               dwFlagsToUse;

    // for ansi, force wininet & disable any request to force winhttp 
    // for full download, disable cache breaker.
    dwFlagsToUse = dwFlags | WUDF_ALLOWWININETONLY;
    dwFlagsToUse &= ~(WUDF_ALLOWWINHTTPONLY | WUDF_APPENDCACHEBREAKER);

    ZeroMemory(&sfns, sizeof(sfns));

    etu = LoadTransportDll(&sfns, &hmod, dwFlagsToUse);
    if (etu == etuNone)
    {
        LOG_ErrorMsg(GetLastError());
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto done;
    }

    else if (etu != etuWinInet)
    {
        hr = E_FAIL;
        LogError(hr, "Unexpected answer from LoadTransportDll(): %d", etu);
        goto done;
    }

    // Since StartDownload just takes a full path to the file to download, build
    //  it here...  
    // Note that we don't need to do this if we're just in status 
    //  checking mode)
    if ((dwFlags & WUDF_CHECKREQSTATUSONLY) == 0)
    {
        pszLocalFile = MakeFullLocalFilePath(pszServerUrl, pszLocalFileName, 
                                             pszLocalPath);
        if (pszLocalFile == NULL)
        {
            LOG_ErrorMsg(GetLastError());
            hr = HRESULT_FROM_WIN32(GetLastError());
            goto done;
        }
    }

    hr = StartWinInetDownload(hmod, pszServerUrl, pszLocalFile, 
                              pdwDownloadedBytes, hQuitEvents, nQuitEventCount, 
                              fpnCallback, pCallbackData, dwFlagsToUse,
                              c_cbDownloadBuffer);

done:
    if (hmod != NULL)
        UnloadTransportDll(&sfns, hmod);
    SafeHeapFree(pszLocalFile);
    
    return hr;
}

// **************************************************************************
HRESULT DownloadFileLite(LPCSTR pszDownloadUrl, 
                         LPCSTR pszLocalFile,  
                         HANDLE hQuitEvent,
                         DWORD dwFlags)

{
    LOG_Block("DownloadFileLite()");

    SWinHTTPFunctions   sfns;
    ETransportUsed      etu;
    HMODULE             hmod = NULL;
    HRESULT             hr = S_OK;
    DWORD               dwFlagsToUse;

    // for ansi, force wininet & disable any request to force winhttp 
    // for lite download, force cache breaker & download retry
    dwFlagsToUse = dwFlags | WUDF_APPENDCACHEBREAKER | WUDF_ALLOWWININETONLY |
                   WUDF_DODOWNLOADRETRY;
    dwFlagsToUse &= ~WUDF_ALLOWWINHTTPONLY;
    
    ZeroMemory(&sfns, sizeof(sfns));

    etu = LoadTransportDll(&sfns, &hmod, dwFlagsToUse);
    switch (etu)
    {
        case etuNone:
            LOG_ErrorMsg(GetLastError());
            hr = HRESULT_FROM_WIN32(GetLastError());
            goto done;

        case etuWinInet:
            hr = StartWinInetDownload(hmod, pszDownloadUrl, pszLocalFile,  
                                      NULL, 
                                      ((hQuitEvent != NULL) ? &hQuitEvent : NULL),
                                      ((hQuitEvent != NULL) ? 1 : 0),
                                      NULL, NULL, dwFlagsToUse,
                                      c_cbDownloadBuffer);
            break;
            
        default:
        case etuWinHttp:
            LogError(hr, "Unexpected answer from LoadTransportDll(): %d", etu);
            hr = HRESULT_FROM_WIN32(GetLastError());
            goto done;
    }

done:
    if (hmod != NULL)
        UnloadTransportDll(&sfns, hmod);
    return hr;
}

#endif // defined(UNICODE)