windows-server-2003/inetcore/urlmon/download/softdist.cxx

// ===========================================================================
// File: SOFTDIST.CXX
//    Channel Software Distribution Unit Tag handler
//

#include <cdlpch.h>
#include <winineti.h>
#include <shlwapip.h>
#include <msxml.h>

LPCSTR szWinNT = "WinNT";
LPCSTR szWin95 = "Win95";

LPCSTR szPlatform = "Win32"; 

LPCOLESTR szMSInstallProgID = L"MSInstall.SoftDistExt";

const TCHAR c_szTrayUI[] = TEXT("MS_WebcheckMonitor");  // Do not change this string. LoadWC relies on it.
const TCHAR c_szTrayMenu[] = TEXT("TrayMenu");

const LPTSTR szControlSetup = _T("Status");
const DWORD dwStatusOK = 0;
const DWORD dwStatusSuspend = 1;
const DWORD dwStatusResume = 2;
const DWORD dwStatusAbort = 3;

const UM_NEEDREBOOT   = WM_USER + 16;

extern char *g_szProcessorTypes[];
extern char g_szBrowserLang[];
extern int g_lenBrowserLang;
extern char g_szBrowserPrimaryLang[];
extern int g_lenBrowserPrimaryLang;
extern LCID g_lcidBrowser;



#define ERROR_EXIT(cond) if (!(cond)) { \
        goto Exit;}

extern COleAutDll g_OleAutDll;

//REVIEW: This is located in cdl.cxx for page swapping reasons.  (OSD's are processed 
//        more than CDF/<SoftDist>'s?

HRESULT ProcessImplementation(IXMLElement *pConfig,
                              CList<CCodeBaseHold *, CCodeBaseHold *> *pcbhList,
                              LCID lcidOverride,
#ifdef WX86
                              CMultiArch *MultiArch,
#endif
                              LPWSTR szBaseURL);


HRESULT 
GetAbstract(HKEY hkeyAv, LPSTR *ppszAbstract)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "GetAbstract",
                "%#x, %#x",
                hkeyAv, ppszAbstract
                ));
                
    HRESULT hr = S_OK;
    DWORD Size,dwType;
    LONG lResult;

    if (ppszAbstract) {

        *ppszAbstract = NULL;

        if (RegQueryValueEx(hkeyAv, REGVAL_ABSTRACT_AVAILABLE, NULL, &dwType, 
            NULL, &Size) == ERROR_SUCCESS) {

            *ppszAbstract = new char[Size];

            if (!*ppszAbstract) {
                hr = E_OUTOFMEMORY;
                goto Exit;
            }
            if ((lResult = RegQueryValueEx(hkeyAv, REGVAL_ABSTRACT_AVAILABLE, NULL, &dwType, 
                (unsigned char *)*ppszAbstract, &Size) != ERROR_SUCCESS)) {

                hr = HRESULT_FROM_WIN32(lResult);
            }

        }
    }

Exit:

    DEBUG_LEAVE(hr);
    return hr;
}

BOOL
IsAbstractDifferent(HKEY hkeyAv, LPSTR szNewAbstract)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Bool,
                "IsAbstractDifferent",
                "%#x, %.80q",
                hkeyAv, szNewAbstract
                ));
                
    LPSTR pszOldAbstract = NULL;
    BOOL bDifferent = TRUE;

    if ((GetAbstract(hkeyAv, &pszOldAbstract) == S_OK) && pszOldAbstract) {

        if (szNewAbstract)
            bDifferent = lstrcmp(pszOldAbstract, szNewAbstract) != 0;

        delete pszOldAbstract;


    }
    
    DEBUG_LEAVE(bDifferent);
    return bDifferent;
}

/******************************************************************************
    Constructor, Destructor and helper methods
******************************************************************************/

CSoftDist::CSoftDist()
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                None,
                "CSoftDist::CSoftDist",
                "this=%#x",
                this
                ));
                
    DllAddRef();
    m_cRef = 1;
    m_szDistUnit = NULL;

    m_szCDFURL = NULL;

    m_szTitle = NULL;
    m_szAbstract = NULL;
    m_szHREF = NULL;

    m_szLanguages = NULL;

    m_dwVersionMS = m_dwVersionLS = 0;

    m_dwVersionAdvertisedMS = m_dwVersionAdvertisedLS = 0;
    m_dwAdState = SOFTDIST_ADSTATE_NONE;

    m_Style = STYLE_MSICD;
    
    m_sdMSInstall = NULL;
    m_pClientBSC = NULL;
    m_szBaseURL = NULL;

    memset(&m_distunitinst, 0, sizeof(DISTUNITINST));

    DetermineOSAndCPUVersion();
    
    DEBUG_LEAVE(0);
}

CSoftDist::~CSoftDist()
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                None,
                "CSoftDist::~CSoftDist",
                "this=%#x",
                this
                ));
                
    Assert(m_cRef == 0);

    SAFERELEASE(m_sdMSInstall);

    SAFEDELETE(m_szDistUnit);

    SAFEDELETE(m_szCDFURL);
    SAFEDELETE(m_szTitle);
    SAFEDELETE(m_szAbstract);
    SAFEDELETE(m_szHREF);
    SAFEDELETE(m_szLanguages);
    SAFEDELETE(m_pClientBSC);
    SAFEDELETE(m_szBaseURL);

    DllRelease();

    DEBUG_LEAVE(0);
}

/******************************************************************************
    IUnknown Methods
******************************************************************************/

STDMETHODIMP CSoftDist::QueryInterface(
                                                REFIID iid, 
                                                void** ppvObject)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::IUnknown::QueryInterface",
                "this=%#x, %#x, %#x",
                this, &iid, ppvObject
                ));
                
    *ppvObject = NULL;

    if (iid == IID_IUnknown)
    {
        *ppvObject = (void*)this;
    }
    else if (iid == IID_ISoftDistExt)
    {
        *ppvObject = (void*)(ISoftDistExt*)this;
    }

    if (*ppvObject) 
    {
        ((LPUNKNOWN)*ppvObject)->AddRef();
    
        DEBUG_LEAVE(S_OK);
        return S_OK;
    }

    DEBUG_LEAVE(E_NOINTERFACE);
    return E_NOINTERFACE;
}

STDMETHODIMP_(ULONG) CSoftDist::AddRef()
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Dword,
                "CSoftDist::IUnknown::AddRef",
                "this=%#x",
                this
                ));
                
    ULONG ulRet = ++m_cRef;

    DEBUG_LEAVE(ulRet);
    return ulRet;
}

STDMETHODIMP_(ULONG) CSoftDist::Release()
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Dword,
                "CSoftDist::IUnknown::Release",
                "this=%#x",
                this
                ));
                
    if (--m_cRef)
    {
        DEBUG_LEAVE(m_cRef);
        return m_cRef;
    }
    
    delete this;

    DEBUG_LEAVE(0);
    return 0;   
}


/******************************************************************************
    ISoftDistExt Methods
******************************************************************************/
/*
 * return values:
 *  All success codes indicate user should be notified through channel UI.
 *
 *  S_OK:       Locally not available, Send Email (Show in channel UI)
 *  S_FALSE:    Locally not available. Don't send Email. (But show in channel UI)
 *
 *  ERROR_ALREADY_EXISTS:Locally already installed. Don't send email/advertise.
 *  ERROR:               Processing error, fail.
 *
 *  For additional information on usage flags, set dwReserved to a valid pointer
 *  and it will set appropriate bit fields
 *
 */
STDMETHODIMP 
CSoftDist::ProcessSoftDist(LPCWSTR szCDFURL, IXMLElement *pSoftDist, LPSOFTDISTINFO psdi)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::ProcessSoftDist",
                "this=%#x, %.80wq, %#x, %#x",
                this, szCDFURL, pSoftDist, psdi
                ));
                
    HRESULT hr = S_FALSE;               // default: send email, no precache
    char szVersion[MAX_PATH];
    char szStyle[MAX_PATH];
    LPSTR szThisOS = NULL;
    LPWSTR szTitle = NULL;
    IXMLElement *pTitle = NULL, *pConfig = NULL, *pLang = NULL, 
                *pAbstract = NULL, *pUsage = NULL, *pDeleteOnInstall = NULL;
    IXMLElement *pParent = NULL;
    BOOL bPrecache = FALSE, bChannelUIOnly = FALSE, bAutoInstall = FALSE, 
         bIsPrecached = FALSE, bDeleteOnInstall = FALSE;
    BOOL fFoundConfig = FALSE;
    LPDWORD lpFlags = NULL;
    BOOL bIsValidCDF = FALSE;

    if (psdi) {
        if (psdi->cbSize < sizeof(SOFTDISTINFO))
        {
            DEBUG_LEAVE(E_INVALIDARG);
            return E_INVALIDARG;
        }
        
        psdi->dwFlags = 0;
    }

    if (szCDFURL && FAILED((hr=::Unicode2Ansi(szCDFURL, &m_szCDFURL))))
    {
        goto Exit;
    }

    // Try to use the BASE tag from the channel.

    // BUGBUG: This is a really convoluted way to get at the channel
    // BASE URL, but there is no way for webcheck to pass this
    // information to us w/o changing the ISoftDistExt interface.

    pSoftDist->get_parent(&pParent);
    if (pParent) {
        DupAttribute(pParent, CHANNEL_ATTRIB_BASE, &m_szBaseURL);
        SAFERELEASE(pParent);
    }

    hr = DupAttribute(pSoftDist, DU_ATTRIB_NAME, &m_szDistUnit);
    ERROR_EXIT(SUCCEEDED(hr));

    // code around assumes that MAX_PATH is MAX size of dist unit
    // we try to make a key name with the distunit and that limit is
    // now MAX_PATH. Hence the reasoning to limit this to MAX_PATH

    if (lstrlenW(m_szDistUnit) >= MAX_PATH) {
        hr = HRESULT_FROM_WIN32(ERROR_BUFFER_OVERFLOW);
        goto Exit;
    }

    hr = DupAttributeA(pSoftDist, DU_ATTRIB_HREF, &m_szHREF);
    ERROR_EXIT(SUCCEEDED(hr));
    if (psdi) {
        hr = Ansi2Unicode( m_szHREF, &psdi->szHREF );
        if ( FAILED(hr) )
            goto Exit;
    }

    hr = GetAttributeA(pSoftDist, DU_ATTRIB_VERSION, szVersion, MAX_PATH);
    ERROR_EXIT(SUCCEEDED(hr));

    if ( FAILED(GetVersionFromString(szVersion, &m_dwVersionMS, &m_dwVersionLS))){
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto Exit;
    }

    if (!(m_dwVersionMS | m_dwVersionLS)) {         // zero is invalid advt version

        hr = E_INVALIDARG;
        goto Exit;
    }

    if (psdi) {

        CHAR szTemp[MAX_PATH];
        psdi->dwFlags = 0;

        psdi->dwUpdateVersionMS = m_dwVersionMS;
        psdi->dwUpdateVersionLS = m_dwVersionLS;

        psdi->dwAdvertisedVersionMS = m_dwVersionAdvertisedMS;
        psdi->dwAdvertisedVersionLS = m_dwVersionAdvertisedLS;

        if (GetFirstChildTag(pSoftDist, DU_TAG_USAGE, &pUsage) == S_OK) {

            VARIANT vtVal;
            VariantInit(&vtVal);
            
            if (SUCCEEDED(pUsage->getAttribute(DU_ATTRIB_VALUE, &vtVal)) && (vtVal.vt == VT_BSTR)) {

                if (!StrCmpIW(vtVal.bstrVal, DU_ATTRIB_EMAIL))
                     psdi->dwFlags |= SOFTDIST_FLAG_USAGE_EMAIL;

//                SAFESYSFREESTRING(vtVal.bstrVal);
                 
            }
            VariantClear(&vtVal);
                
            SAFERELEASE(pUsage);
        }

        if (SUCCEEDED(GetAttributeA(pSoftDist, DU_ATTRIB_PRECACHE, szTemp, MAX_PATH))) {
        
            if (szTemp[0] == 'Y' || szTemp[0] == 'y') {
                psdi->dwFlags |= SOFTDIST_FLAG_USAGE_PRECACHE;
                bPrecache = TRUE;
            }
            
        }

        if (SUCCEEDED(GetAttributeA(pSoftDist, DU_ATTRIB_AUTOINSTALL, szTemp, MAX_PATH))) {
        
            if (szTemp[0] == 'Y' || szTemp[0] == 'y') {
                psdi->dwFlags |= SOFTDIST_FLAG_USAGE_AUTOINSTALL;
                bPrecache = TRUE;
                bAutoInstall = TRUE;
            }
            
        }
    
    }

    // get abstract
    if(GetFirstChildTag(pSoftDist,DU_TAG_ABSTRACT, &pAbstract) == S_OK) {
        
        BSTR bstrAbstract = NULL;
        hr = pAbstract->get_text(&bstrAbstract);
        ERROR_EXIT(SUCCEEDED(hr));

        if (FAILED(Unicode2Ansi(bstrAbstract, &m_szAbstract))) {
            hr = E_OUTOFMEMORY;
            SAFESYSFREESTRING(bstrAbstract);
            goto Exit;
        }

        if (psdi) {
            psdi->szAbstract = new WCHAR[lstrlenW(bstrAbstract)+1];
            if (!psdi->szAbstract) {
                hr = E_OUTOFMEMORY;
                SAFESYSFREESTRING(bstrAbstract);
                goto Exit;
            } else {
                StrCpyW(psdi->szAbstract, bstrAbstract);
            }
        }

        SAFESYSFREESTRING(bstrAbstract);
    }

    // get title
    if(GetFirstChildTag(pSoftDist,DU_TAG_TITLE, &pTitle) == S_OK) {
        BSTR bstrTitle = NULL;
        hr = pTitle->get_text(&bstrTitle);
        ERROR_EXIT(SUCCEEDED(hr));

        if (FAILED(Unicode2Ansi(bstrTitle, &m_szTitle))) {
            hr = E_OUTOFMEMORY;
            SAFESYSFREESTRING(bstrTitle);
            goto Exit;
        }

        if (psdi) {
            psdi->szTitle = new WCHAR[lstrlenW(bstrTitle)+1];
            if (!psdi->szTitle) {
                hr = E_OUTOFMEMORY;
                SAFESYSFREESTRING(bstrTitle);
                goto Exit;
            } else {
                StrCpyW(psdi->szTitle, bstrTitle);
            }
        }
        
        SAFESYSFREESTRING(bstrTitle);
    }

    // get langs available
    if(GetFirstChildTag(pSoftDist,DU_TAG_LANG, &pLang) == S_OK) {
        BSTR bstrLang = NULL;
        hr = pLang->get_text(&bstrLang);
        ERROR_EXIT(SUCCEEDED(hr));

        DWORD len = lstrlenW(bstrLang);
        m_szLanguages = new char [len+1];
        if (!m_szLanguages) {
            hr = E_OUTOFMEMORY;
            SAFESYSFREESTRING(bstrLang);
            goto Exit;
        }
        WideCharToMultiByte(CP_ACP, 0, bstrLang , -1, m_szLanguages,
                            len, NULL, NULL);

        SAFESYSFREESTRING(bstrLang);
    }

    // <deleteoninstall />
    if (GetFirstChildTag(pSoftDist, DU_TAG_DELETEONINSTALL, &pDeleteOnInstall) == S_OK) {
        SAFERELEASE(pDeleteOnInstall);
        bDeleteOnInstall = TRUE;
    }

    // style tells us who to ask
    // accomodate Darwin here
    if(SUCCEEDED(GetAttributeA(pSoftDist, DU_ATTRIB_STYLE, szStyle, MAX_PATH))){

        (void) GetStyleFromString(szStyle, &m_Style);

        if (m_Style == STYLE_UNKNOWN) {

            if (m_sdMSInstall == NULL) {

                CLSID clsidOther;
                LPWSTR wszStyle = NULL;

                if (FAILED(DupAttribute(pSoftDist, DU_ATTRIB_STYLE, &wszStyle)))
                    goto Exit;

                if (SUCCEEDED(CLSIDFromProgID(wszStyle, &clsidOther))) {
                    
                    if (FAILED(hr = CoCreateInstance(clsidOther, NULL, CLSCTX_INPROC_SERVER,
                                    IID_ISoftDistExt, (void **)&m_sdMSInstall)))
                        goto Exit;

                    m_Style = STYLE_OTHER;

                }
                // If failed, continue as normal.
            }
        }

        if (m_Style == STYLE_MSINSTALL) {
            
            if (m_sdMSInstall == NULL) {

                CLSID clsidMSInstall;

                if (FAILED(hr = CLSIDFromProgID(szMSInstallProgID, &clsidMSInstall)))
                    goto Exit;
                
                if (FAILED(hr = CoCreateInstance(clsidMSInstall, NULL, CLSCTX_INPROC_SERVER, 
                                    IID_ISoftDistExt, (void **)&m_sdMSInstall)))
                    goto Exit;

            }
        }

        if (m_sdMSInstall != NULL) {
            hr = m_sdMSInstall->ProcessSoftDist(szCDFURL, pSoftDist, psdi);
            goto Exit;
        }

    }

    // get list of available languages here

    hr = InitBrowserLangStrings();
    if (FAILED(hr))
        goto Exit;

    // check if software already locally installed
    hr = IsLocallyInstalled(m_szDistUnit, m_dwVersionMS, m_dwVersionLS, m_szLanguages, m_Style);

    if ( psdi != NULL )
    {
        if ( SUCCEEDED(hr) )
        {
            psdi->dwInstalledVersionMS = m_distunitinst.dwInstalledVersionMS;
            psdi->dwInstalledVersionLS = m_distunitinst.dwInstalledVersionLS;
        }
        else
        {
            // No version.
            psdi->dwInstalledVersionMS = 0xFFFFFFFF;
            psdi->dwInstalledVersionLS = 0xFFFFFFFF;
        }
    }

    if (hr != S_FALSE) {
        if (hr == S_OK) {            
            
            if (psdi && bDeleteOnInstall) {
                psdi->dwFlags |=  SOFTDIST_FLAG_DELETE_SUBSCRIPTION;
            }

            hr = HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS);
        }
        goto Exit;
    }

    // check here to see if Advertised already to avoid
    // processing filters?
    if (FAILED(hr = IsAdvertised(&bIsPrecached, &bIsValidCDF)))
        goto Exit;

    // If already advertised then only precache once.
    if (hr == S_OK) {
        if ((!bPrecache) || (!bAutoInstall && bPrecache && bIsPrecached)) {
            bChannelUIOnly = TRUE;
        }
    }

    // version doesn't already exist
    // process filters to see if we can Advertise this

    // look for dependency & config filters.  If either fails, then we don't do Channel UI or
    // email notification.

    if (FAILED(hr = CheckDependency(pSoftDist)))
        goto Exit;

    if (FAILED(hr = CheckConfig(pSoftDist)))
        goto Exit;

    if (bChannelUIOnly)
    {
        // we record advertise again to stomp the title & abstract
        if (bIsValidCDF) {
            
            hr = Advertise(/*bFullAdvt*/FALSE);
        }

        // We are already advertised, we want Channel UI but not email notification.
        hr = S_FALSE;
    }
    else
    {
        if (bIsValidCDF) {

            // Advertise software, mark as Advertised
            hr = Advertise(/*bFullAdvt*/TRUE);

            // We advertise in Channel UI and email notification.
            hr = S_OK;
        
        } else {
        
            // if not an authorized CDF then we can't trigger email notification or download
            hr = S_FALSE;
        }

    }

Exit:
    SAFERELEASE(pLang);
    SAFERELEASE(pAbstract);
    SAFERELEASE(pTitle);

    DEBUG_LEAVE(hr);
    return hr;
}

STDMETHODIMP
CSoftDist::GetFirstCodeBase(LPWSTR *szCodeBase, LPDWORD lpdwSize)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::GetFirstCodeBase",
                "this=%#x, %#x, %#x",
                this, szCodeBase, lpdwSize
                ));
                
    HRESULT hr;
    if (m_sdMSInstall != NULL)
    {
        hr = m_sdMSInstall->GetFirstCodeBase(szCodeBase, lpdwSize);

        DEBUG_LEAVE(hr);
        return hr;
    }
    m_curPos = m_cbh.GetHeadPosition();
    hr = GetNextCodeBase(szCodeBase, lpdwSize);

    DEBUG_LEAVE(hr);
    return hr;
}

STDMETHODIMP
CSoftDist::GetNextCodeBase(LPWSTR *szCodeBase, LPDWORD lpdwSize)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::GetNextCodeBase",
                "this=%#x, %#x, %#x",
                this, szCodeBase, lpdwSize
                ));
                
    HRESULT hr = S_OK;
    CCodeBaseHold *cbh = NULL;

    if (m_sdMSInstall != NULL)
    {
        hr = m_sdMSInstall->GetNextCodeBase(szCodeBase, lpdwSize);

        DEBUG_LEAVE(hr);
        return hr;
    }
    if (szCodeBase == NULL || lpdwSize == NULL) {
        hr = E_INVALIDARG;
        goto Exit;
    }

    *szCodeBase = NULL;
    *lpdwSize = 0;

    if (m_curPos == NULL) {
        hr = E_FAIL;
        goto Exit;
    }

    cbh = m_cbh.GetNext(m_curPos);

    hr = CDLDupWStr( szCodeBase, cbh->wszCodeBase );
    *lpdwSize = cbh->dwSize;
    
Exit:

    DEBUG_LEAVE(hr);
    return hr;
}

STDMETHODIMP 
CSoftDist::AsyncInstallDistributionUnit(IBindCtx *pbc, LPVOID pvReserved, DWORD dwFlags, LPCODEBASEHOLD lpcbh)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::AsyncInstallDistributionUnit",
                "this=%#x, %#x, %#x, %#x, %#x",
                this, pbc, pvReserved, dwFlags, lpcbh
                ));
                
    HRESULT                   hr = S_OK;
    LPWSTR                    szCodeBase = NULL;
    DWORD                     dwSize;

    
    if ((lpcbh) && (lpcbh->cbSize == sizeof(CODEBASEHOLD)))
    {
        hr = ::AsyncInstallDistributionUnit(
                            lpcbh->szDistUnit,
                            NULL,
                            NULL,
                            lpcbh->dwVersionMS,
                            lpcbh->dwVersionLS,
                            lpcbh->szCodeBase,            // URL of code base
                            pbc,
                            NULL,
                            0);

    } else if (m_Style == STYLE_MSICD) {

        if (SUCCEEDED(GetFirstCodeBase(&szCodeBase, &dwSize))) {
            CCodeBaseHold *pcbh;

            pcbh = m_cbh.GetHead();
            pcbh->dwFlags |= CBH_FLAGS_DOWNLOADED;
            hr = ::AsyncInstallDistributionUnit(
                            m_szDistUnit,
                            NULL,
                            NULL,
                            m_dwVersionMS,
                            m_dwVersionLS,
                            szCodeBase,            // URL of code base
                            pbc,
                            NULL,
                            0);

            // NOTE: EAX should be MK_S_ASYNC (0x401E8)

        } else
            hr = E_FAIL;

        // Return successful no matter what

    } else if (m_Style == STYLE_MSINSTALL || m_Style == STYLE_OTHER) {

        if (m_sdMSInstall == NULL) {

            hr = E_FAIL;                    // Interfaces should be here but aren't.

        } else {
        
            hr = m_sdMSInstall->AsyncInstallDistributionUnit(pbc, pvReserved, dwFlags, lpcbh);

        }

    } else if (m_Style == STYLE_ACTIVE_SETUP) {

        if (SUCCEEDED(GetFirstCodeBase(&szCodeBase, &dwSize))) {

            CActiveSetupBinding *pasb = NULL;
            IBindStatusCallback *pbsc = NULL;

            if (SUCCEEDED(pbc->GetObjectParam(REG_BSCB_HOLDER, (IUnknown **)&pbsc))) {

                pasb = new CActiveSetupBinding(pbc, pbsc, szCodeBase, m_szDistUnit, &hr);
                if (pasb && FAILED(hr)) {
    
                    SAFERELEASE(pasb);          // deletes itself

                }

                SAFERELEASE(pbsc);

                // NOTE: This is not a memory leak, the object will clean itself up when it
                //       is done the binding operation.

            }
            else
                hr = E_FAIL;
        }
        else
            hr = E_FAIL;

    } else if (m_Style == STYLE_LOGO3) {
        CCodeBaseHold          *pcbhCur = NULL;

        m_curPos = m_cbh.GetHeadPosition();
        if (m_curPos == 0) {
            goto Exit;
        }
        pcbhCur = m_cbh.GetAt(m_curPos);
        if (pcbhCur == NULL) {
            goto Exit;
        }

        CDLDupWStr(&szCodeBase, pcbhCur->wszCodeBase);
        dwSize = pcbhCur->dwSize;
        pcbhCur->dwFlags |= CBH_FLAGS_DOWNLOADED;

        if (pbc != NULL) {
            pbc->GetObjectParam(REG_BSCB_HOLDER, (IUnknown **)&m_pClientBSC);
        }
        
        hr = Logo3Download(szCodeBase);

    } else {

        hr = E_NOTIMPL;

    }
    
Exit:

    SAFEDELETE(szCodeBase);

    DEBUG_LEAVE(hr);
    return hr;
}

/******************************************************************************
    CheckDependency
******************************************************************************/
/* This checks for filter criteria in <Config> tags.
 *
 * <!ELEMENT Dependency (SoftDist)* | Language | Processor | Platform>
 *
 * Returns: E_ERROR code if Dependency check fails or badly formatted.
 *
 */
HRESULT
CSoftDist::CheckDependency(IXMLElement *pSoftDist)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::CheckDependency",
                "this=%#x, %#x",
                this, pSoftDist
                ));
                
    int nLastChildTag = -1;
    LPSTR szLanguages = NULL;
    LPWSTR szCoreDist = NULL;
    IXMLElement *pDepend = NULL, *pCoreDist = NULL;
    IXMLElement *pProcessor = NULL, *pPlatform = NULL, *pLang = NULL;
    HRESULT hr = S_OK;
    DWORD style;

    while (GetNextChildTag(pSoftDist, DU_TAG_DEPENDENCY, &pDepend, nLastChildTag) == S_OK) {

        LPWSTR szCoreDist = NULL;
        union {
            char szVersion[MAX_PATH];
            char szStyle[MAX_PATH];
            char szProcessor[MAX_PATH];
            char szPlatformAttr[MAX_PATH];
        };

        // check for 'softdist' tag and version info.
        int nLastSoftDist = -1;
        while (GetNextChildTag(pDepend, DU_TAG_SOFTDIST, &pCoreDist, nLastSoftDist) == S_OK) {

            // default values if attributes are not specified.
            DWORD dwVersionMS = 0, dwVersionLS = 0, style = m_Style;

            // look for language tag (if present), otherwise NULL.
            SAFEDELETE(szLanguages);
            if (GetFirstChildTag(pCoreDist, DU_TAG_LANG, &pLang) == S_OK) {
                BSTR bstrLang = NULL;
                pLang->get_text(&bstrLang);

                DWORD len = lstrlenW(bstrLang);
                szLanguages = new char[len+1];
                if (!szLanguages) {
                    hr = E_OUTOFMEMORY;
                    SAFESYSFREESTRING(bstrLang);
                    goto Exit;
                }
                WideCharToMultiByte(CP_ACP, 0, bstrLang , -1, szLanguages,
                                    len, NULL, NULL);

                SAFESYSFREESTRING(bstrLang);
            }

            if (FAILED(hr = DupAttribute(pCoreDist, DU_ATTRIB_NAME, &szCoreDist)))
                goto Exit;

            if (SUCCEEDED(GetAttributeA(pCoreDist, DU_ATTRIB_VERSION, szVersion, MAX_PATH))) {
                
                if (FAILED(GetVersionFromString(szVersion, &dwVersionMS, &dwVersionLS))) {
                    hr = HRESULT_FROM_WIN32(GetLastError());
                    goto Exit;
                }
         
            }

            if (SUCCEEDED(GetAttributeA(pCoreDist, DU_ATTRIB_STYLE, szStyle, MAX_PATH))) {

                // return is not required
                (void) GetStyleFromString(szStyle, &style);

            }

            hr = IsLocallyInstalled(szCoreDist, dwVersionMS, dwVersionLS,
                                szLanguages != NULL ? szLanguages : m_szLanguages, style);
            SAFEDELETE(szCoreDist);

            // core product doesn't exist, or version is lower than required.
            if (hr != S_OK)  {
                 hr = HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND);
                 goto Exit;
            }
            SAFERELEASE(pCoreDist);

        } // while for softdist

        // check processor
        if (GetFirstChildTag(pDepend, DU_TAG_PROCESSOR, &pProcessor) == S_OK) {

            if (FAILED(hr = GetAttributeA(pProcessor, DU_ATTRIB_VALUE, szProcessor, MAX_PATH)))
                goto Exit;

#ifdef WX86
            char *szPreferredArch;
            char *szAlternateArch;
            HRESULT hrArch;

            GetMultiArch()->SelectArchitecturePreferences(
                        g_szProcessorTypes[g_CPUType],
                        g_szProcessorTypes[PROCESSOR_ARCHITECTURE_INTEL],
                        &szPreferredArch,
                        &szAlternateArch);

            if (lstrcmpi(szPreferredArch, szProcessor) == 0) {
                hrArch = GetMultiArch()->RequirePrimaryArch();
                Assert(SUCCEEDED(hrArch));
            } else if (szAlternateArch && lstrcmpi(szAlternateArch, szProcessor) == 0) {
                hrArch = GetMultiArch()->RequireAlternateArch();
                Assert(SUCCEEDED(hrArch));
            } else {
                //
                // Processor type is neither perferred nor alternate.
                //
                hr = HRESULT_FROM_WIN32(ERROR_EXE_MACHINE_TYPE_MISMATCH);
                goto Exit;
            }
#else
	    if (lstrcmpi(g_szProcessorTypes[g_CPUType],szProcessor) != 0) {
                hr = HRESULT_FROM_WIN32(ERROR_EXE_MACHINE_TYPE_MISMATCH);
                goto Exit;
            }
#endif
        }

        // check platform
        if (GetFirstChildTag(pDepend, DU_TAG_PLATFORM, &pPlatform) == S_OK) {

            if (FAILED(hr = GetAttributeA(pPlatform, DU_ATTRIB_VALUE, szPlatformAttr, MAX_PATH)))
                goto Exit;

            if (lstrcmpi(szPlatform, szPlatformAttr) != 0) {
                hr = HRESULT_FROM_WIN32(ERROR_EXE_MACHINE_TYPE_MISMATCH);
                goto Exit;
            }

        }

        SAFERELEASE(pDepend);

    } // dependency check loop
Exit:
    SAFERELEASE(pDepend);
    SAFERELEASE(pCoreDist);
    SAFERELEASE(pProcessor);
    SAFERELEASE(pPlatform);
    SAFERELEASE(pLang);

    SAFEDELETE(szLanguages);
    SAFEDELETE(szCoreDist);

    DEBUG_LEAVE(hr);
    return hr;
}

/******************************************************************************
    CheckConfig
******************************************************************************/
/* This checks for filter criteria in <Config> tags.
 *
 * <!ELEMENT Config (CodeBase)*>
 * <!ATTLIST Config Language CDATA #IMPLIED>
 * <!ATTLIST Config (OS OSVersion) CDATA #IMPLIED>
 * <!ATTLIST Config Processor CDATA #IMPLIED>
 */
HRESULT
CSoftDist::CheckConfig(IXMLElement *pSoftDist)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::CheckConfig",
                "this=%#x, %#x",
                this, pSoftDist
                ));
                
    IXMLElement *pConfig = NULL;
    IXMLElement *pCodeBase = NULL;
    BOOL fFoundMatchingConfig = FALSE;
    BOOL fFoundAnyConfig = FALSE;
    HRESULT hr = S_OK;
    int nLastChildTag = -1;
    int nLastChildCodeBase = -1;
    WCHAR szResult[INTERNET_MAX_URL_LENGTH];
    DWORD dwSize = 0;

    // Process CONFIG tags 
    while (GetNextChildTag(pSoftDist, DU_TAG_CONFIG, &pConfig, nLastChildTag) == S_OK) {

        fFoundAnyConfig = TRUE;

        if (ProcessImplementation(pConfig, &m_cbh, GetThreadLocale(),
#ifdef WX86
                                  GetMultiArch(),
#endif
                                  m_szBaseURL) == S_OK) {
            fFoundMatchingConfig = TRUE;
            break;
        }

        SAFERELEASE(pConfig);
    }

    // if at least one config and none match, return with error.
    if (fFoundAnyConfig && !fFoundMatchingConfig) {
        hr = HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND);
        goto Exit;
    }

Exit:
    SAFERELEASE(pConfig);
    SAFERELEASE(pCodeBase);

    DEBUG_LEAVE(hr);
    return hr;
}

typedef HRESULT (STDAPICALLTYPE *PFNLCIDTORFC1766)(LCID, LPSTR, DWORD);

HRESULT
GetLangStringMod(HMODULE hMod, LCID localeID, char *szThisLang, int iLen)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "GetLangStringMod",
                "%#x, %#x, %.80q",
                hMod, localeID, szThisLang
                ));
                
    PFNLCIDTORFC1766 pfnLCIDToRFC1766 = NULL;
    HRESULT hr = S_OK;

#ifdef UNICODE
    pfnLCIDToRFC1766 = (PFNLCIDTORFC1766)GetProcAddress(hMod, "LcidToRfc1766W");
#else
    pfnLCIDToRFC1766 = (PFNLCIDTORFC1766)GetProcAddress(hMod, "LcidToRfc1766A");
#endif

    if (pfnLCIDToRFC1766) {

        hr = pfnLCIDToRFC1766(localeID, szThisLang, iLen);

    } else {
        hr = E_UNEXPECTED;
    } 

    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT
GetLangString(LCID localeID, char *szThisLang, int iLen)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "GetLangString",
                "%#x, %.80q",
                localeID, szThisLang
                ));
                
    HRESULT hr = S_OK;
    HMODULE hMod = 0;
    LCID lcidPrimaryBrowser = PRIMARYLANGID(LANGIDFROMLCID(g_lcidBrowser));


    // use cached copies of browser lang string
    if ( (localeID == g_lcidBrowser) && g_szBrowserLang[0] ) {

        StrNCpy(szThisLang, g_szBrowserLang, iLen);
        goto Exit;

    }

    if ( (localeID == lcidPrimaryBrowser) && g_szBrowserPrimaryLang[0] ) {

        StrNCpy(szThisLang, g_szBrowserPrimaryLang, iLen);
        goto Exit;

    }

    hMod = LoadLibrary("mlang.dll");

    if (!hMod) {
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto Exit;
    }


    hr = GetLangStringMod(hMod, localeID, szThisLang, iLen);

Exit:

    if (hMod)
        FreeLibrary(hMod);

    DEBUG_LEAVE(hr);
    return hr;
}

// globals for code downloader
extern CMutexSem g_mxsCodeDownloadGlobals;
BOOL g_bLangInit = FALSE;

HRESULT
InitBrowserLangStrings()
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "InitBrowserLangStrings",
                NULL
                ));
                
    HRESULT hr = S_OK;
    CLock lck(g_mxsCodeDownloadGlobals);
    static const char *cszSHDOCVW = "\\shdocvw.dll";

    if (g_bLangInit)
    {
        DEBUG_LEAVE(hr);
        return hr;
    }
    
    g_bLangInit = TRUE;

    CLocalComponentInfo lci;
    DWORD dwVerMS, dwVerLS;

    GetSystemDirectory(lci.szExistingFileName, MAX_PATH);

    StrCatBuff(lci.szExistingFileName, cszSHDOCVW, sizeof(lci.szExistingFileName));
    if (SUCCEEDED(GetFileVersion(&lci, &dwVerMS, &dwVerLS))) {
        if (lci.lcid) {

            g_lcidBrowser = lci.lcid;

        }
    }

    HMODULE hMod = LoadLibrary("mlang.dll");
    LCID lcidPrimaryBrowser = PRIMARYLANGID(LANGIDFROMLCID(g_lcidBrowser));

    if (hMod) {

        hr = GetLangStringMod(hMod, g_lcidBrowser, g_szBrowserLang, g_lenBrowserLang);
        hr = GetLangStringMod(hMod, lcidPrimaryBrowser, g_szBrowserPrimaryLang, g_lenBrowserPrimaryLang);
        FreeLibrary(hMod);
    } else {

        hr = HRESULT_FROM_WIN32(GetLastError());
    }

    DEBUG_LEAVE(hr);
    return hr;
}

/******************************************************************************
    CheckLanguage
******************************************************************************/
/* The languages string is of the form,
 *  lang1;lang2;lang3;...
 *
 *  OR = '*' (the first character is an asterick).
 *
 * This routine will scan the LocaleID string (as saved from registry, GetLocaleInfo)
 * for an occurrence in the szLanguage string.  If found, it returns true.  If '*'
 * is specified, the result is always true.  Regular expressions are otherwise
 * not supported.
 *
 */
HRESULT CheckLanguage(LCID localeID, LPTSTR szLanguage)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CheckLanguage",
                "%#x, %.80q",
                localeID, szLanguage
                ));
                
    LCID lcidPrimaryBrowser = PRIMARYLANGID(LANGIDFROMLCID(g_lcidBrowser));
    CHAR szThisLang[MAX_PATH];
    int i;
    HRESULT hr = S_OK;

    if (szLanguage == NULL)
    {
        DEBUG_LEAVE(S_OK);
        return S_OK;
    }
    if (*szLanguage == '*')
    {
        DEBUG_LEAVE(S_OK);
        return S_OK;
    }
    hr = GetLangString(localeID, (char *)szThisLang, sizeof(szThisLang));

    if (FAILED(hr)) {
        DEBUG_LEAVE(hr);
        return hr;
    }

    if (AreAllLanguagesPresent((char *)szThisLang, szLanguage)) {
        DEBUG_LEAVE(S_OK);
        return S_OK;
    }           
    
    // check with primary language
    localeID = PRIMARYLANGID(LANGIDFROMLCID(localeID));

    hr = GetLangString(localeID, (char *)szThisLang, sizeof(szThisLang));

    if (FAILED(hr)) {
        DEBUG_LEAVE(hr);
        return hr;
    }

    if (AreAllLanguagesPresent((char *)szThisLang, szLanguage)) {
        DEBUG_LEAVE(S_OK);
        return S_OK;
    }           


    hr = HRESULT_FROM_WIN32(ERROR_RESOURCE_LANG_NOT_FOUND);
    
    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT
CSoftDist::IsLocallyInstalled(LPCWSTR szDistUnit, DWORD dwVersionMS, DWORD dwVersionLS, LPCSTR szLanguages, DWORD Style)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::IsLocallyInstalled",
                "this=%#x, %.80wq, %#x, %#x, %.80q, %#x",
                this, szDistUnit, dwVersionMS, dwVersionLS, szLanguages, Style
                ));
                
    Assert(szDistUnit);
    HRESULT hr = S_OK;
    if (Style == STYLE_MSICD)
        hr = IsICDLocallyInstalled(szDistUnit, dwVersionMS, dwVersionLS, szLanguages);
    else if (Style == STYLE_ACTIVE_SETUP)
        hr = IsActSetupLocallyInstalled(szDistUnit, dwVersionMS, dwVersionLS, szLanguages);
    else if (Style == STYLE_LOGO3)
        hr = IsLogo3LocallyInstalled(szDistUnit, dwVersionMS, dwVersionLS, szLanguages);
    else
        hr = E_UNEXPECTED;
    
    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT
CSoftDist::IsLogo3LocallyInstalled(LPCWSTR szDistUnit, DWORD dwVersionMS, DWORD dwVersionLS, LPCSTR szLanguages)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::IsLogo3LocallyInstalled",
                "this=%#x, %.80wq, %#x, %#x, %.80q",
                this, szDistUnit, dwVersionMS, dwVersionLS, szLanguages
                ));
                
    HRESULT                hr = S_OK; 
    DWORD                  dwInstVersionMS = 0;
    DWORD                  dwInstVersionLS = 0;
    DWORD                  dwType = 0;
    DWORD                  dwLen = 0;
    LPSTR                  szDU = NULL;
    HKEY                   hkeyLogo3 = 0;
    HKEY                   hkeyDist = 0;

// No LOGO3 language information is stored, so language checking is not
// possible yet.

    Assert(szDistUnit);
    if (!szDistUnit) {
        hr = E_INVALIDARG;
        goto Exit;
    }

    dwLen = WideCharToMultiByte(CP_ACP,0, szDistUnit, -1, NULL, 0, NULL, NULL);
    szDU = new char [dwLen];
    if (szDU == NULL) {
        hr = E_OUTOFMEMORY;
        goto Exit;
    }

    WideCharToMultiByte(CP_ACP, 0, szDistUnit , -1, szDU,
                        dwLen, NULL, NULL);

    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGSTR_PATH_LOGO3_SETTINGS,
                     0, KEY_READ, &hkeyLogo3) != ERROR_SUCCESS) {
        hr = E_FAIL;
        goto Exit;
    }

    if (RegOpenKeyEx(hkeyLogo3, szDU, 0, KEY_READ, &hkeyDist) != ERROR_SUCCESS) {
        hr = S_FALSE;
        goto Exit;
    }

    dwLen = sizeof(DWORD);
    if (RegQueryValueEx(hkeyDist, REGVAL_LOGO3_MAJORVERSION, 0, &dwType,
                        (LPBYTE)&dwInstVersionMS, &dwLen) != ERROR_SUCCESS) {
        hr = S_FALSE;
        goto Exit;
    }

    dwLen = sizeof(DWORD);
    if (RegQueryValueEx(hkeyDist, REGVAL_LOGO3_MINORVERSION, 0, &dwType,
                        (LPBYTE)&dwInstVersionLS, &dwLen) != ERROR_SUCCESS) {
        hr = S_FALSE;
        goto Exit;
    }

    m_distunitinst.dwInstalledVersionMS = dwInstVersionMS;
    m_distunitinst.dwInstalledVersionLS = dwInstVersionLS;

    if (dwInstVersionMS > dwVersionMS ||
        (dwInstVersionMS == dwVersionMS && dwInstVersionLS >= dwVersionLS)) {
        hr = S_OK;
    } else {
        hr = S_FALSE;
    }

Exit:

    if (hkeyLogo3) {
        RegCloseKey(hkeyLogo3);
    }

    if (hkeyDist) {
        RegCloseKey(hkeyDist);
    }

    if (szDU) {
        delete [] szDU;
    }
    
    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT
CSoftDist::IsICDLocallyInstalled(LPCWSTR szDistUnit, DWORD dwVersionMS, DWORD dwVersionLS, LPCSTR szLanguages)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::IsICDLocallyInstalled",
                "this=%#x, %.80wq, %#x, %#x, %.80q",
                this, szDistUnit, dwVersionMS, dwVersionLS, szLanguages
                ));
                
    Assert(szDistUnit);
    CLSID inclsid = CLSID_NULL;
    HRESULT hr = S_OK;

    CLocalComponentInfo* plci = NULL;

    plci = new CLocalComponentInfo();
    if(!plci) {
        hr = E_OUTOFMEMORY;
        goto Exit;
    }

     // if fails szDistUnit is not clsid
    CLSIDFromString((LPOLESTR)szDistUnit, &inclsid);

    // check to see if locally installed.
    if ((hr = IsControlLocallyInstalled(NULL,
            (LPCLSID)&inclsid, szDistUnit,
            dwVersionMS, dwVersionLS, plci, NULL)) != S_FALSE) {

        // S_OK if local version OK
        // ERROR, fail
        goto Exit;

    }

    // check for other hooks like Active Setup, Add/Remove Programs here

Exit:
    if (plci)
    {
        m_distunitinst.dwInstalledVersionMS = plci->dwLocFVMS;
        m_distunitinst.dwInstalledVersionLS = plci->dwLocFVLS;
    }

    SAFEDELETE(plci);
    
    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT
CSoftDist::IsAdvertised(LPBOOL lpfIsPrecached, LPBOOL lpfIsAuthorizedCDF)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::IsAdvertised",
                "this=%#x, %#x, %#x",
                this, lpfIsPrecached, lpfIsAuthorizedCDF
                ));
                
    HRESULT hr = S_OK;
    if (m_Style == STYLE_MSICD)
        hr = IsICDAdvertised(lpfIsPrecached, lpfIsAuthorizedCDF);
    else if (m_Style == STYLE_ACTIVE_SETUP)
        hr = IsActSetupAdvertised(lpfIsPrecached, lpfIsAuthorizedCDF);
    else if (m_Style == STYLE_LOGO3)
        hr = IsLogo3Advertised(lpfIsPrecached, lpfIsAuthorizedCDF);
    else
        hr = E_UNEXPECTED;
    
    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT
CSoftDist::IsLogo3Advertised(LPBOOL lpfIsPrecached, LPBOOL lpfIsAuthorizedCDF)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::IsLogo3Advertised",
                "this=%#x, %#x, %#x",
                this, lpfIsPrecached, lpfIsAuthorizedCDF
                ));
                
    HRESULT                       hr = S_OK;
    HKEY                          hkeyDistInfo = 0;
    HKEY                          hkeyAdvertisedVersion = 0;
    HKEY                          hkeyAuthCDF = 0;
    HKEY                          hkeyLogo3 = 0;
    DWORD                         lResult = 0;
    DWORD                         dwSize = 0;
    DWORD                         dwType;
    LPSTR                         szDU = NULL;
    DWORD                         dwLen = 0;
    DWORD                         dwCurAdvMS = 0;
    DWORD                         dwCurAdvLS = 0;
    char                          szBuffer[MAX_REGSTR_LEN];
    char                          szVersionBuf[MAX_PATH];
    static const char            *szPrecache = "Precache";
    static const char            *szAbstract = "Abstract";
    static const char            *szAuthorizedCDF = "AuthorizedCDFPrefix";
    static const char            *szHREF = "HREF";
    static const char            *szTITLE = "TITLE";

    ASSERT(lpfIsPrecached && lpfIsAuthorizedCDF);

    if (!lpfIsPrecached || !lpfIsAuthorizedCDF) {
        hr = E_INVALIDARG;
        goto Exit;
    }

    *lpfIsPrecached = FALSE;
    *lpfIsAuthorizedCDF = FALSE;

    if (m_szDistUnit) {
        if (FAILED(Unicode2Ansi(m_szDistUnit, &szDU))) {
            hr = E_OUTOFMEMORY;
            goto Exit;
        }
    }
    else {
        hr = E_INVALIDARG;
        goto Exit;
    }

    wnsprintf(szBuffer, sizeof(szBuffer)-1, "%s\\%s", REGSTR_PATH_LOGO3_SETTINGS, szDU);

    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szBuffer, 0, KEY_READ,
                     &hkeyLogo3) != ERROR_SUCCESS) {
        hr = S_FALSE;
        goto Exit;
    }

    *lpfIsAuthorizedCDF = IsAuthorizedCDF(hkeyLogo3);

    if (RegOpenKeyEx(hkeyLogo3, "AvailableVersion", 0, KEY_READ,
                     &hkeyDistInfo) != ERROR_SUCCESS) {
        hr = S_FALSE;
        goto Exit;
    }

    dwSize = sizeof(DWORD);
    if (RegQueryValueEx(hkeyDistInfo, szPrecache, 0, &dwType,
                        (unsigned char *)&lResult, &dwSize) == ERROR_SUCCESS) {
        // Precached value was the code download HR
        *lpfIsPrecached = (SUCCEEDED(lResult)) ? (TRUE) : (FALSE);
    }

    // This key is optionally present.
    dwSize = MAX_PATH;
    if (RegQueryValueEx(hkeyDistInfo, REGSTR_LOGO3_ADVERTISED_VERSION, NULL, &dwType,
                        (unsigned char *)szVersionBuf, &dwSize) == ERROR_SUCCESS)
    {
        GetVersionFromString(szVersionBuf, &m_dwVersionAdvertisedMS, &m_dwVersionAdvertisedLS);
    }

    // Get the AdState, if any
    dwSize = sizeof(DWORD);
    RegQueryValueEx(hkeyDistInfo, REGVAL_ADSTATE, NULL, NULL, (LPBYTE)&m_dwAdState, &dwSize);

    if (!m_szAbstract) {
        if (RegQueryValueEx(hkeyDistInfo, szAbstract, NULL, &dwType,
            NULL, &dwSize) == ERROR_SUCCESS) {

            m_szAbstract = new char[dwSize];
            if (!m_szAbstract) {
                hr = E_OUTOFMEMORY;
                goto Exit;
            }

            if (RegQueryValueEx(hkeyDistInfo, szAbstract, NULL, &dwType,
                (unsigned char *)m_szAbstract, &dwSize) != ERROR_SUCCESS) {

                hr = HRESULT_FROM_WIN32(GetLastError());
                goto Exit;
            }

        }
    }

    if (!m_szHREF) {
        if (RegQueryValueEx(hkeyDistInfo, szHREF, NULL, &dwType,
            NULL, &dwSize) == ERROR_SUCCESS) {

            m_szHREF = new char[dwSize];
            if (!m_szHREF) {
                hr = E_OUTOFMEMORY;
                goto Exit;
            }

            if (RegQueryValueEx(hkeyDistInfo, szHREF, NULL, &dwType,
                (unsigned char *)m_szHREF, &dwSize) != ERROR_SUCCESS) {

                hr = HRESULT_FROM_WIN32(GetLastError());
                goto Exit;
            }

        }
    }

    if (!m_szTitle) {
        if (RegQueryValueEx(hkeyDistInfo, szTITLE, NULL, &dwType,
            NULL, &dwSize) == ERROR_SUCCESS) {

            m_szTitle = new char[dwSize];
            if (!m_szHREF) {
                hr = E_OUTOFMEMORY;
                goto Exit;
            }

            if (RegQueryValueEx(hkeyDistInfo, szTITLE, NULL, &dwType,
                (unsigned char *)m_szTitle, &dwSize) != ERROR_SUCCESS) {

                hr = HRESULT_FROM_WIN32(GetLastError());
                goto Exit;
            }

        }
    }

    dwSize = MAX_PATH;
    if (RegQueryValueEx(hkeyDistInfo, NULL, NULL, &dwType,
                        (unsigned char *)szVersionBuf, &dwSize) != ERROR_SUCCESS) {
        hr = S_FALSE;
        goto Exit;
    }

    if ( FAILED(GetVersionFromString(szVersionBuf, &dwCurAdvMS, &dwCurAdvLS))){
        hr = S_FALSE;
        goto Exit;
    }

    if (!(m_dwVersionMS|m_dwVersionLS)) {
        m_dwVersionMS = dwCurAdvMS;
        m_dwVersionLS = dwCurAdvLS;
    }

    if (IsCDFNewerVersion(dwCurAdvMS, dwCurAdvLS)) {
        hr = S_FALSE;
    }
    else {
        hr = S_OK;
    }

Exit:

    if (hkeyDistInfo) {
        RegCloseKey(hkeyDistInfo);
    }

    if (hkeyAdvertisedVersion) {
        RegCloseKey(hkeyAdvertisedVersion);
    }

    if (hkeyLogo3) {
        RegCloseKey(hkeyLogo3);
    }

    if (hkeyAuthCDF) {
        RegCloseKey(hkeyAuthCDF);
    }

    SAFEDELETE(szDU);
    
    DEBUG_LEAVE(hr);
    return hr;
}

// **** IsICDAdvertised ****
// returns: S_FALSE for not advertised (or newest version not advertised)
//          S_OK for advertised

HRESULT
CSoftDist::IsICDAdvertised(LPBOOL lpfIsPrecached, LPBOOL lpfIsAuthorizedCDF)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::IsICDAdvertised",
                "this=%#x, %#x, %#x",
                this, lpfIsPrecached, lpfIsAuthorizedCDF
                ));
                
    HRESULT hr = S_OK;
    LONG lResult = ERROR_SUCCESS;
    HKEY hkeyDist =0;
    HKEY hkeyThisDist = 0;
    HKEY hkeyVersion = 0;
    HKEY hkeyAdvertisedVersion = 0;
    DWORD Size = MAX_PATH;
    DWORD SizeDword = sizeof(DWORD);
    DWORD dwType;

    DWORD dwCurAdvMS = 0;
    DWORD dwCurAdvLS = 0;

    const static char * szAvailableVersion = "AvailableVersion";
    const static char * szHREF = "HREF";
    const static char * szABSTRACT = "Abstract";
    const static char * szPrecache = "Precache";
    const static char * szAuthorizedCDF = "AuthorizedCDFPrefix";

    LPSTR pszDist = NULL;

    char szVersionBuf[MAX_PATH];

    ASSERT(lpfIsPrecached && lpfIsAuthorizedCDF);
    if (!lpfIsPrecached || !lpfIsAuthorizedCDF) {
        hr = E_INVALIDARG;
        goto Exit;
    }

    *lpfIsPrecached = FALSE;
    *lpfIsAuthorizedCDF = TRUE;

    if ((lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE, REGSTR_PATH_DIST_UNITS,
                        0, KEY_ALL_ACCESS, &hkeyDist)) != ERROR_SUCCESS) {

        hr = S_FALSE;
        goto Exit;
    }

    if (FAILED((hr=::Unicode2Ansi(m_szDistUnit, &pszDist))))
    {
        goto Exit;
    }

    // open the dist unit key for this dist unit.
    if (RegOpenKeyEx( hkeyDist, pszDist,
            0, KEY_ALL_ACCESS, &hkeyThisDist) != ERROR_SUCCESS) {
        hr = S_FALSE;
        goto Exit;
    }

    *lpfIsAuthorizedCDF = IsAuthorizedCDF(hkeyThisDist, /*bOptional*/TRUE);

    if (RegOpenKeyEx( hkeyThisDist, szAvailableVersion,
            0, KEY_ALL_ACCESS, &hkeyVersion) != ERROR_SUCCESS) {
        hr = S_FALSE;
        goto Exit;
    }

    if (RegQueryValueEx(hkeyVersion, szPrecache, 0, &dwType, 
        (unsigned char *)&lResult, &SizeDword) == ERROR_SUCCESS) {

        // check for success or common error conditions which indicate we have bits.
        if (SUCCEEDED(lResult)) {
            *lpfIsPrecached = TRUE;
        } else {
            *lpfIsPrecached = FALSE;
        }
    }

    // This key is optionally present.
    if ( RegOpenKeyEx( hkeyThisDist, REGKEY_MSICD_ADVERTISED_VERSION,
            0, KEY_ALL_ACCESS, &hkeyAdvertisedVersion) == ERROR_SUCCESS )
    {
        Size = MAX_PATH;

        if (RegQueryValueEx(hkeyAdvertisedVersion, NULL, NULL, &dwType, 
                (unsigned char *)szVersionBuf, &Size) == ERROR_SUCCESS)
            GetVersionFromString(szVersionBuf, &m_dwVersionAdvertisedMS, &m_dwVersionAdvertisedLS);
        // Get the AdState, if any
        SizeDword = sizeof(DWORD);
        RegQueryValueEx( hkeyAdvertisedVersion, REGVAL_ADSTATE, NULL, NULL, (LPBYTE)&m_dwAdState, &SizeDword);
    }

    // save away the advt info like Title, href, abstract
    // if called from GetDistributionUnitAdvt()
    if (!m_szTitle) {
        if (RegQueryValueEx(hkeyThisDist, NULL, NULL, &dwType, 
            NULL, &Size) == ERROR_SUCCESS) {

            m_szTitle = new char[Size];

            if (!m_szTitle) {
                hr = E_OUTOFMEMORY;
                goto Exit;
            }
            if (RegQueryValueEx(hkeyThisDist, NULL, NULL, &dwType, 
                (unsigned char *)m_szTitle, &Size) != ERROR_SUCCESS) {

                hr = HRESULT_FROM_WIN32(GetLastError());
                goto Exit;
            }

        }
    }

    if (!m_szAbstract) {
        if (RegQueryValueEx(hkeyVersion, szABSTRACT, NULL, &dwType, 
            NULL, &Size) == ERROR_SUCCESS) {

            m_szAbstract = new char[Size];

            if (!m_szAbstract) {
                hr = E_OUTOFMEMORY;
                goto Exit;
            }
            if (RegQueryValueEx(hkeyVersion, szABSTRACT, NULL, &dwType, 
                (unsigned char *)m_szAbstract, &Size) != ERROR_SUCCESS) {

                hr = HRESULT_FROM_WIN32(GetLastError());
                goto Exit;
            }

        }
    }

    if (!m_szHREF) {
        if (RegQueryValueEx(hkeyVersion, szHREF, NULL, &dwType, 
            NULL, &Size) == ERROR_SUCCESS) {

            m_szHREF = new char[Size];

            if (!m_szHREF) {
                hr = E_OUTOFMEMORY;
                goto Exit;
            }
            if (RegQueryValueEx(hkeyVersion, szHREF, NULL, &dwType, 
                (unsigned char *)m_szHREF, &Size) != ERROR_SUCCESS) {

                hr = HRESULT_FROM_WIN32(GetLastError());
                goto Exit;
            }

        }
    }

    if (RegQueryValueEx(hkeyVersion, NULL, NULL, &dwType, 
            (unsigned char *)szVersionBuf, &Size) != ERROR_SUCCESS) {
        hr = S_FALSE;
        goto Exit;
    }

    if ( FAILED(GetVersionFromString(szVersionBuf, &dwCurAdvMS, &dwCurAdvLS))){
        hr = S_FALSE;
        goto Exit;
    }

    if (!(m_dwVersionMS|m_dwVersionLS)) {
        m_dwVersionMS = dwCurAdvMS;
        m_dwVersionLS = dwCurAdvLS;
    }

    if (IsCDFNewerVersion(dwCurAdvMS, dwCurAdvLS))
        hr = S_FALSE;
    else 
        hr = S_OK;

Exit:
    SAFEDELETE(pszDist);

    SAFEREGCLOSEKEY(hkeyVersion);
    SAFEREGCLOSEKEY(hkeyAdvertisedVersion);
    SAFEREGCLOSEKEY(hkeyDist);
    SAFEREGCLOSEKEY(hkeyThisDist);
    
    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT
CSoftDist::Advertise(BOOL bFullAdvt)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::Advertise",
                "this=%#x, %B",
                this, bFullAdvt
                ));
                
    HRESULT hr = S_OK;
    if (m_Style == STYLE_MSICD)
        hr = ICDAdvertise(bFullAdvt);
    else if (m_Style == STYLE_ACTIVE_SETUP)
        hr = ActSetupAdvertise(bFullAdvt);
    else if (m_Style == STYLE_LOGO3)
        hr = Logo3Advertise(bFullAdvt);
    else
        hr = E_UNEXPECTED;
    
    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT
CSoftDist::Logo3Advertise(BOOL bFullAdvt)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::Logo3Advertise",
                "this=%#x, %B",
                this, bFullAdvt
                ));
                
    HRESULT                  hr = S_OK;
    DWORD                    dwLen = 0;
    DWORD                    lResult = 0;
    LPSTR                    szDU = NULL;
    HKEY                     hkeyLogo3 = 0;
    HKEY                     hkeyDist = 0;
    HKEY                     hkeyAvailVersion = 0;
    DWORD                    dwAdState;
    static const char       *szAvailableVersion = "AvailableVersion";
    static const char       *szPrecache = "Precache";
    static const char       *szHREF = "HREF";
    static const char       *szTitle = "Title";
    char                     szVersionBuf[MAX_PATH];


    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGSTR_PATH_LOGO3_SETTINGS,
                     0, KEY_ALL_ACCESS, &hkeyLogo3) != ERROR_SUCCESS) {
        hr = E_FAIL;
        goto Exit;
    }

    dwLen = WideCharToMultiByte(CP_ACP,0, m_szDistUnit, -1, NULL, 0, NULL, NULL);
    szDU = new char [dwLen];
    if (szDU == NULL) {
        hr = E_OUTOFMEMORY;
        goto Exit;
    }

    WideCharToMultiByte(CP_ACP, 0, m_szDistUnit , -1, szDU, dwLen, NULL, NULL);

    if (RegOpenKeyEx(hkeyLogo3, szDU, 0, KEY_ALL_ACCESS, &hkeyDist) != ERROR_SUCCESS) {
        // Create key if it doesn't exist
        if ((lResult = RegCreateKey(hkeyLogo3, szDU, &hkeyDist)) != ERROR_SUCCESS) {
            hr = HRESULT_FROM_WIN32(lResult);
            goto Exit;
        }
    }

    if (RegOpenKeyEx(hkeyDist, szAvailableVersion, 0, KEY_ALL_ACCESS,
                     &hkeyAvailVersion) != ERROR_SUCCESS) {
        if ((lResult = RegCreateKey(hkeyDist, szAvailableVersion, &hkeyAvailVersion)) != ERROR_SUCCESS) {
            hr = HRESULT_FROM_WIN32(lResult);
            goto Exit;
        }
    }

    wsprintf(szVersionBuf, "%d,%d,%d,%d",
            (m_dwVersionMS & 0xffff0000)>>16,
            (m_dwVersionMS & 0xffff),
            (m_dwVersionLS & 0xffff0000)>>16,
            (m_dwVersionLS & 0xffff));

    lResult = ::RegSetValueEx(hkeyAvailVersion, NULL, NULL, REG_SZ,
                              (unsigned char *)szVersionBuf,
                              lstrlen(szVersionBuf) + 1);

    if (bFullAdvt || IsAbstractDifferent(hkeyAvailVersion, m_szAbstract)) {
        // Clear previous AdState, if any
        dwAdState = SOFTDIST_ADSTATE_NONE;
        // Don't panic if this fails
        lResult = ::RegSetValueEx(hkeyAvailVersion, REGVAL_ADSTATE, NULL,
                        REG_DWORD, (unsigned char *)&dwAdState, sizeof(DWORD));

        // save HREF
        if ((lResult == ERROR_SUCCESS) && m_szHREF) {
            lResult = ::RegSetValueEx(hkeyAvailVersion, szHREF, NULL, REG_SZ,
                                      (unsigned char *)m_szHREF,
                                      lstrlen(m_szHREF) + 1);
        }

        // save Abstract
        if ((lResult == ERROR_SUCCESS) && m_szAbstract) {
            lResult = RegSetValueEx(hkeyAvailVersion, REGVAL_ABSTRACT_AVAILABLE,
                        NULL, REG_SZ, (unsigned char *)m_szAbstract,
                            lstrlen(m_szAbstract) + 1);
        }

        // save Title
        if ((lResult == ERROR_SUCCESS) && m_szTitle) {
            lResult = ::RegSetValueEx(hkeyAvailVersion, szTitle, NULL, REG_SZ,
                                      (unsigned char *)m_szTitle,
                                      lstrlen(m_szTitle) + 1);

        }

    }

    if (lResult != ERROR_SUCCESS) {
        hr = HRESULT_FROM_WIN32(lResult);
        goto Exit;
    }

    // new advertisement, remove old precache
    if (bFullAdvt)
        ::RegDeleteValue(hkeyAvailVersion, szPrecache);


Exit:

    if (hkeyLogo3) {
        RegCloseKey(hkeyLogo3);
    }

    if (hkeyDist) {
        RegCloseKey(hkeyDist);
    }

    if (hkeyAvailVersion) {
        RegCloseKey(hkeyAvailVersion);
    }

    if (szDU) {
        delete [] szDU;
    }

    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT
CSoftDist::ICDAdvertise(BOOL bFullAdvt)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::ICDAdvertise",
                "this=%#x, %B",
                this, bFullAdvt
                ));
                
    HRESULT hr = S_OK;
    LONG lResult = ERROR_SUCCESS;
    HKEY hkeyDist =0;
    HKEY hkeyThisDist = 0;
    HKEY hkeyDownloadInfo = 0;

    HKEY hkeyVersion = 0;
    HKEY hkeyAdvertisedVersion = 0;

    const static char * szAvailableVersion = "AvailableVersion";
    const static char * szDownloadInfo = "DownloadInformation";
    const static char * szCODEBASE = "CODEBASE";
    const static char * szLOCALCDF = "CDF";
    const static char * szINSTALLER = "Installer";
    const static char * szMSICD = "MSICD";
    const static char * szHREF = "HREF";
    const static char * szPrecache = "Precache";
    char szTmpCodeBase[MAX_PATH+sizeof(szCODEBASE)+5];    
    LPSTR pszCodeBase = NULL;
    int numCodeBase;
    POSITION pos;

    LPSTR pszDist = NULL;

    char szVersionBuf[MAX_PATH];

    if ((lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE, REGSTR_PATH_DIST_UNITS,
                        0, KEY_ALL_ACCESS, &hkeyDist)) != ERROR_SUCCESS) {
        if ((lResult = RegCreateKey( HKEY_LOCAL_MACHINE,
                   REGSTR_PATH_DIST_UNITS, &hkeyDist)) != ERROR_SUCCESS) {
            hr = HRESULT_FROM_WIN32(lResult);
            goto Exit;
        }
    }

    if (FAILED((hr=::Unicode2Ansi(m_szDistUnit, &pszDist))))
    {
        goto Exit;
    }

    // open/create the dist unit key for this dist unit.
    if (RegOpenKeyEx( hkeyDist, pszDist,
            0, KEY_ALL_ACCESS, &hkeyThisDist) != ERROR_SUCCESS) {
        if ((lResult = RegCreateKey( hkeyDist,
                   pszDist, &hkeyThisDist)) != ERROR_SUCCESS) {
            hr = HRESULT_FROM_WIN32(lResult);
            goto Exit;
            }
    }

    if (m_szTitle && 
        ((lResult = ::RegSetValueEx(hkeyThisDist, NULL, NULL, REG_SZ, 
                (unsigned char *)m_szTitle,
                lstrlen(m_szTitle)+1)) != ERROR_SUCCESS)){

        hr = HRESULT_FROM_WIN32(lResult);
        goto Exit;
    }

    lResult = ::RegSetValueEx(hkeyThisDist, szINSTALLER, NULL, REG_SZ, 
                        (unsigned char *)szMSICD, sizeof(szMSICD)+1);

    if (lResult != ERROR_SUCCESS) {
        hr = HRESULT_FROM_WIN32(lResult);
        goto Exit;
    }


    // open/create the download info key for this dist unit.
    if (RegOpenKeyEx( hkeyThisDist, szDownloadInfo,
            0, KEY_ALL_ACCESS, &hkeyDownloadInfo) != ERROR_SUCCESS) {
        if ((lResult = RegCreateKey( hkeyThisDist,
                   szDownloadInfo, &hkeyDownloadInfo)) != ERROR_SUCCESS) {
            hr = HRESULT_FROM_WIN32(lResult);
            goto Exit;
            }
    }

    // set download info params
    if (GetCDF() &&  (lResult = ::RegSetValueEx(hkeyDownloadInfo, 
        szLOCALCDF, NULL, REG_SZ, (unsigned char *)GetCDF(), lstrlen(GetCDF())+1)) != ERROR_SUCCESS) {

        hr = HRESULT_FROM_WIN32(lResult);
        goto Exit;
    }

    pos = m_cbh.GetHeadPosition();
    numCodeBase = 1;
    while (pos != NULL) {

        CCodeBaseHold *cbh = m_cbh.GetNext(pos);
        if (numCodeBase <= 1)
            lstrcpy((char *)szTmpCodeBase, szCODEBASE);
        else
            wsprintf(szTmpCodeBase, "%s%d", szCODEBASE, numCodeBase);

        if (FAILED(::Unicode2Ansi(cbh->wszCodeBase,&pszCodeBase))) {
            hr = E_OUTOFMEMORY;
            goto Exit;
        }

        if ((lResult = ::RegSetValueEx(hkeyDownloadInfo, szTmpCodeBase,
            NULL, REG_SZ, (unsigned char *)pszCodeBase, strlen(pszCodeBase))) != ERROR_SUCCESS) {
            
            SAFEDELETE(pszCodeBase);
            hr = HRESULT_FROM_WIN32(lResult);
            goto Exit;
        }

        SAFEDELETE(pszCodeBase);
        numCodeBase ++;
    }

    // Note Version
    wsprintf(szVersionBuf, "%d,%d,%d,%d",
            (m_dwVersionMS & 0xffff0000)>>16,
            (m_dwVersionMS & 0xffff),
            (m_dwVersionLS & 0xffff0000)>>16,
            (m_dwVersionLS & 0xffff));

    if (RegOpenKeyEx( hkeyThisDist, szAvailableVersion,
            0, KEY_ALL_ACCESS, &hkeyVersion) != ERROR_SUCCESS) {
        if ((lResult = RegCreateKey( hkeyThisDist,
                   szAvailableVersion, &hkeyVersion)) != ERROR_SUCCESS) {
            hr = HRESULT_FROM_WIN32(lResult);
            goto Exit;
            }
    }

    if (bFullAdvt || IsAbstractDifferent(hkeyVersion, m_szAbstract)) {

        // Clear previous AdState, if any
        if (RegOpenKey(hkeyThisDist, REGKEY_MSICD_ADVERTISED_VERSION, &hkeyAdvertisedVersion) == ERROR_SUCCESS)
        {
            DWORD dwAdState = SOFTDIST_ADSTATE_NONE;

            // Don't panic if this fails
            lResult = ::RegSetValueEx(hkeyAdvertisedVersion, REGVAL_ADSTATE, NULL, REG_DWORD, 
                                      (unsigned char *)&dwAdState, sizeof(DWORD) );
        }
    }

    // new advertisement, remove old precache
    if (bFullAdvt)
        ::RegDeleteValue(hkeyVersion, szPrecache);
  
    lResult = ::RegSetValueEx(hkeyVersion, NULL, NULL, REG_SZ, 
                        (unsigned char *)szVersionBuf, lstrlen(szVersionBuf)+1);
    // save HREF
    if ( (lResult == ERROR_SUCCESS) && m_szHREF)
        lResult = ::RegSetValueEx(hkeyVersion, szHREF, NULL, REG_SZ, 
                        (unsigned char *)m_szHREF, lstrlen(m_szHREF)+1);
    // save Abstract
    if ( (lResult == ERROR_SUCCESS) && m_szAbstract)
        lResult = ::RegSetValueEx(hkeyVersion, REGVAL_ABSTRACT_AVAILABLE, NULL, REG_SZ, 
                        (unsigned char *)m_szAbstract, lstrlen(m_szAbstract)+1);

    if (lResult != ERROR_SUCCESS) {
        hr = HRESULT_FROM_WIN32(lResult);
        goto Exit;
    }

Exit:
    SAFEDELETE(pszDist);
    SAFEDELETE(pszCodeBase);
    SAFEREGCLOSEKEY(hkeyDownloadInfo);
    SAFEREGCLOSEKEY(hkeyVersion);
    SAFEREGCLOSEKEY(hkeyDist);
    SAFEREGCLOSEKEY(hkeyThisDist);
    SAFEREGCLOSEKEY(hkeyAdvertisedVersion);
    
    DEBUG_LEAVE(hr);
    return hr;
}

BOOL
CSoftDist::IsAuthorizedCDF(HKEY hkeyRootDU, BOOL bOptional)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Bool,
                "CSoftDist::IsAuthorizedCDF",
                "this=%#x, %#x, %B",
                this, hkeyRootDU, bOptional
                ));
                
    const static char *szAuthorizedCDF="AuthorizedCDFPrefix";
    BOOL fResult = FALSE;
    HRESULT hr;
    int iValue = 0;
    CHAR szEnumCDF[MAX_PATH];
    DWORD dwValueSize = MAX_PATH;
    LPWSTR wzCDFURL = 0;
    IInternetSecurityManager *pism = 0;
    DWORD dwZone = 0, dwType = 0;
    HKEY hkeyAuthCDF = 0;
    DWORD                         dwPolicy = 0;
    DWORD                         dwContext = 0;

    if (!hkeyRootDU) {
        goto Exit;
    }

    if (!m_szCDFURL) {
        goto Exit;
    }

    if (FAILED(CoInternetCreateSecurityManager(NULL, &pism, 0)) || !pism) {
        goto Exit;
    }

    if (FAILED(Ansi2Unicode(m_szCDFURL, &wzCDFURL))) {
        goto Exit;
    }

    pism->ProcessUrlAction(wzCDFURL, URLACTION_CHANNEL_SOFTDIST_PERMISSIONS,
               (BYTE *)&dwPolicy, sizeof(dwPolicy),
               (BYTE *)&dwContext, sizeof(dwContext),
               PUAF_NOUI, 0);

    if (dwPolicy == URLPOLICY_CHANNEL_SOFTDIST_AUTOINSTALL)
    {
        fResult = TRUE;
        goto Exit;
    }

    // if no "AuthorizedCDF" key exists we don't do any prefix checking
    if (RegOpenKeyEx( hkeyRootDU, szAuthorizedCDF,
            0, KEY_READ, &hkeyAuthCDF) != ERROR_SUCCESS) {

        if (bOptional)
            fResult = TRUE;
        goto Exit;
    }

    iValue = 0;
    while (RegEnumValue(hkeyAuthCDF, iValue++, 
           szEnumCDF, &dwValueSize, 0, &dwType, NULL, NULL) == ERROR_SUCCESS) {

        dwValueSize = MAX_PATH; // reset

        // check for partial match, if found return true.
        if (StrCmpNI(szEnumCDF, m_szCDFURL, min(lstrlenA(szEnumCDF), lstrlenA(m_szCDFURL))) == 0) {
            fResult = TRUE;
            goto Exit;
        }
    }

Exit:
    SAFERELEASE(pism);
    SAFEDELETE(wzCDFURL);

    if (hkeyAuthCDF)
        RegCloseKey(hkeyAuthCDF);

    DEBUG_LEAVE(fResult);
    return fResult;
}

BOOL
CSoftDist::IsCDFNewerVersion(DWORD dwLocFVMS, DWORD dwLocFVLS)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Bool,
                "CSoftDist::IsCDFNewerVersion",
                "this=%#x, %#x, %#x",
                this, dwLocFVMS, dwLocFVLS
                ));
                
    BOOL fRet = ((m_dwVersionMS > dwLocFVMS) ||
                    ((m_dwVersionMS == dwLocFVMS) &&
                        (m_dwVersionLS > dwLocFVLS)));

    DEBUG_LEAVE(fRet);
    return fRet;
}


HRESULT
CSoftDist::IsActSetupLocallyInstalled(LPCWSTR szDistUnit, DWORD dwVersionMS, DWORD dwVersionLS, LPCSTR szLanguages)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::IsActSetupLocallyInstalled",
                "this=%#x, %.80wq, %#x, %#x, %.80q",
                this, szDistUnit, dwVersionMS, dwVersionLS, szLanguages
                ));
                
    Assert(szDistUnit);
    HRESULT hr = S_FALSE, hr2;       // Not installed by active setup.
    LONG    lResult = ERROR_SUCCESS;
    LPSTR  pszKey = NULL;
    BOOL   bAllocedKey = FALSE;
    int        nKey;

    //we've done this at THREE other places in the code, so let's raise this from 1 to 2 *MAX_PATH
    char    szKey[2*MAX_PATH];
    char    szVersion[MAX_PATH];
    HKEY    hKey    = NULL;
    DWORD   dwSize;
    DWORD   dwValue;
    DWORD   dwType;
    BOOL    fIsInstalled = FALSE;
    WORD    wVersion[4];
    LPSTR   pszDist = NULL;
    DWORD   dwCurMS = 0;
    DWORD   dwCurLS = 0;

    const static char * szLocale = "Locale";
    const static char * szIsInstalled = "IsInstalled";
    const static char * szActVersion = "Version";

    if (FAILED((hr2=::Unicode2Ansi(szDistUnit, &pszDist))))
    {
        hr = hr2;
        goto Exit;
    }

    ULONG ulenDist = lstrlenA(pszDist);
    //sizeof counts terminating NULL also, so subtract 2, and add 1 for the final NULL
    ULONG ulenConst = sizeof(REGKEY_ACTIVESETUP_COMPONENTS)/sizeof(CHAR) + sizeof("\\")/sizeof(CHAR) - 2 + 1;
    
    if ((ulenDist+ulenConst)  > sizeof(szKey))
    {
    	pszKey = new CHAR[ulenDist+ulenConst];
    }

    if  (pszKey)
    {
    	bAllocedKey = TRUE;
    	nKey = ulenDist+ulenConst;
    }
    else
    {
    	pszKey = szKey;
    	nKey = sizeof(szKey);
    }

    StrNCpy(pszKey, REGKEY_ACTIVESETUP_COMPONENTS, nKey);
    StrCatBuff(pszKey, "\\", nKey);
    StrCatBuff(pszKey, pszDist, nKey);

    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, pszKey, 0, KEY_READ, &hKey) == ERROR_SUCCESS)
    {
        // Check for the installed language. And see if it fits the availabel szLanguages
        dwSize = sizeof(szVersion);
        if (RegQueryValueEx( hKey, szLocale, NULL, NULL, (LPBYTE)szVersion, &dwSize) == ERROR_SUCCESS)
        {
            if (szLanguages && !AreAllLanguagesPresent(szVersion, szLanguages))
                goto Exit;
        }

        dwSize = sizeof(dwValue);
        // Old format of the Installed components did not have the IsInstalled value.
        if (RegQueryValueEx( hKey, szIsInstalled, NULL, NULL, (LPBYTE)&dwValue, &dwSize) != ERROR_SUCCESS)
        {
            dwValue = 0;
        }
        fIsInstalled = (dwValue != 0);
        if (fIsInstalled)
        {
            dwSize = sizeof(szVersion);
            if ( (lResult = RegQueryValueEx(hKey, szActVersion, NULL, &dwType, (LPBYTE)szVersion, &dwSize)) == ERROR_SUCCESS )
            {
                if (dwType == REG_SZ)
                {
                    if ( SUCCEEDED(GetVersionFromString(szVersion, &dwCurMS, &dwCurLS)))
                    {
                        m_distunitinst.dwInstalledVersionMS = dwCurMS;
                        m_distunitinst.dwInstalledVersionLS = dwCurLS;

                        if (dwCurMS > dwVersionMS ||
                         (dwCurMS == dwVersionMS && dwCurLS >= dwVersionLS)) {
                            hr = S_OK;
                        } else {
                            hr = S_FALSE;
                        }

                    }
                }
                else
                {
                    dwSize = 4 * sizeof(WORD);
                    if ( (lResult = RegQueryValueEx(hKey, szActVersion, NULL, NULL, (LPBYTE)wVersion, &dwSize)) == ERROR_SUCCESS )
                    {
                        // The registry version number is saved hi-word MS lo-word MS hi-word LS lo-word LS
                        // therefore we need to put the data manualy into the DWORDs
                        dwCurMS = (DWORD)wVersion[0] << 16;    // Make hi word of MS version
                        dwCurMS += (DWORD)wVersion[1];         // Make lo word of MS version
                        dwCurLS = (DWORD)wVersion[2] << 16;    // Make hi word of LS version
                        dwCurLS += (DWORD)wVersion[3];         // Make lo word of LS version
                        if (dwCurMS > dwVersionMS ||
                         (dwCurMS == dwVersionMS && dwCurLS >= dwVersionLS)) {
                            hr = S_OK;
                        } else {
                            hr = S_FALSE;
                        }

                    }
                    else
                        hr = HRESULT_FROM_WIN32(lResult);
                }
            }
            // If "Version" doesn't exist we assume its been advertised
            // but not locally installed.

        }
    }

Exit:

    if (bAllocedKey)
    {
    	delete [] pszKey;
    }
    
    SAFEREGCLOSEKEY(hKey);
    SAFEDELETE(pszDist);
    
    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT CSoftDist::ActSetupAdvertise(BOOL bFullAdvt)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::ActSetupAdvertise",
                "this=%#x, %B",
                this, bFullAdvt
                ));

    LPSTR  pszKey = NULL;
    BOOL   bAllocedKey = FALSE;
    int        nKey;

    char    szKey[2*MAX_PATH];
    HKEY    hKey;
    HRESULT hr = S_OK;
    LPSTR   pszDist = NULL;
    LONG    lResult = ERROR_SUCCESS;
    static const char            *szPrecache = "Precache";

    if (FAILED((hr=::Unicode2Ansi(m_szDistUnit, &pszDist))))
    {
        goto Exit;
    }

    ULONG ulenDist = lstrlenA(pszDist);
    //sizeof counts terminating NULL also, so subtract 2, and add 1 for the final NULL
    ULONG ulenConst = sizeof(REGKEY_ACTIVESETUP_COMPONENTS)/sizeof(CHAR) + sizeof("\\")/sizeof(CHAR) - 2 + 1;
    
    if ((ulenDist+ulenConst)  > sizeof(szKey))
    {
    	pszKey = new CHAR[ulenDist+ulenConst];
    }

    if (pszKey)
    {
    	bAllocedKey = TRUE;
    	nKey = ulenDist + ulenConst;
    }
    else
    {
    	pszKey = szKey;
    	nKey = sizeof(szKey);
    }

    StrNCpy(pszKey, REGKEY_ACTIVESETUP_COMPONENTS, nKey);
    StrCatBuff(pszKey, "\\", nKey);
    StrCatBuff(pszKey, pszDist, nKey);

    if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, pszKey, 0, NULL, REG_OPTION_NON_VOLATILE, 
                    KEY_READ|KEY_SET_VALUE, NULL, &hKey, NULL) == ERROR_SUCCESS)
    {
        DWORD dwAdStateInit = SOFTDIST_ADSTATE_NONE;

        // Note Version
        wsprintf(pszKey, "%d,%d,%d,%d",
                (m_dwVersionMS & 0xffff0000)>>16,
                (m_dwVersionMS & 0xffff),
                (m_dwVersionLS & 0xffff0000)>>16,
                (m_dwVersionLS & 0xffff));
        lResult = ::RegSetValueEx(hKey, REGVAL_VERSION_AVAILABLE, NULL, REG_SZ, 
                            (unsigned char *)pszKey, lstrlen(pszKey)+1);

        if (bFullAdvt || IsAbstractDifferent(hKey, m_szAbstract)) {
                // (re)set the ad state
                lResult = ::RegSetValueEx(hKey, REGVAL_ADSTATE, NULL, REG_DWORD, 
                                (unsigned char *)&dwAdStateInit, sizeof(DWORD) );


            if( (lResult == ERROR_SUCCESS) && m_szTitle)
                lResult=RegSetValueEx(hKey,REGVAL_TITLE_AVAILABLE, NULL, REG_SZ, 
                            (unsigned char *)m_szTitle, lstrlen(m_szTitle)+1);

            if( (lResult == ERROR_SUCCESS) && m_szAbstract)
                lResult=RegSetValueEx(hKey,REGVAL_ABSTRACT_AVAILABLE, NULL,
                            REG_SZ, (unsigned char *)m_szAbstract, lstrlen(m_szAbstract)+1);

            if( (lResult == ERROR_SUCCESS) && m_szHREF) {
                //
                // Check if this is the IE4 GUID. If so, change IE's
                // First Home Page to point to this HREF.
    /*
                // This is no longer being used because we pop up a dialog instead

                if (lstrcmpi(pszDist, DISTUNIT_NAME_IE4) == 0) {
                    HKEY hKeyIE = 0;
                    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGSTR_PATH_IE_MAIN, 0, KEY_SET_VALUE, &hKeyIE) == ERROR_SUCCESS) {

                        RegSetValueEx(hKeyIE,REGVAL_FIRST_HOME_PAGE, NULL,
                            REG_SZ, (unsigned char *)m_szHREF, lstrlen(m_szHREF)+1);
                        RegCloseKey(hKeyIE);
                    }
                }
    */

                lResult =RegSetValueEx(hKey,REGVAL_HREF_AVAILABLE, NULL, REG_SZ, 
                                (unsigned char *)m_szHREF, lstrlen(m_szHREF)+1);
            }

        }

        if (lResult != ERROR_SUCCESS) 
        {
            hr = HRESULT_FROM_WIN32(lResult);
        }

        // new advertisement, remove old precache
        if (bFullAdvt)
            ::RegDeleteValue(hKey, szPrecache);

        RegCloseKey(hKey);

    }

Exit:

    if (bAllocedKey)
    {
    	 delete [] pszKey;
    }

    SAFEDELETE(pszDist);
    
    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT CSoftDist::IsActSetupAdvertised(LPBOOL lpfIsPrecached, LPBOOL lpfIsAuthorized)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::IsActSetupAdvertised",
                "this=%#x, %#x, %#x",
                this, lpfIsPrecached, lpfIsAuthorized
                ));
                
    HKEY    hKey;

    LPSTR pszTmp = NULL;
    BOOL  bAllocedTmp = FALSE;
    int       nTmp;
    
    char    szTmp[2*MAX_PATH];
    DWORD   dwSize;
    DWORD   dwCurAdvMS = 0;
    DWORD   dwCurAdvLS = 0;
    HRESULT hr = S_FALSE, hr2;
    LPSTR   pszDist = NULL;
    LONG    lResult = ERROR_SUCCESS;
    
    const static char * szPrecache = "Precache";

    ASSERT(lpfIsPrecached && lpfIsAuthorized);
    if (!lpfIsPrecached || !lpfIsAuthorized) {
        hr = E_INVALIDARG;
        goto Exit;
    }

    *lpfIsPrecached = FALSE;
    *lpfIsAuthorized = TRUE;

    if (FAILED((hr2=::Unicode2Ansi(m_szDistUnit, &pszDist))))
    {
        hr = hr2;
        goto Exit;
    }

    hr = S_FALSE;   // reset: assume not advertised

    ULONG ulenDist = lstrlenA(pszDist);
    //sizeof counts terminating NULL also, so subtract 2, and add 1 for the final NULL
    ULONG ulenConst = sizeof(REGKEY_ACTIVESETUP_COMPONENTS)/sizeof(CHAR) + sizeof("\\")/sizeof(CHAR) - 2 + 1;
    
    if ((ulenDist+ulenConst)  > sizeof(szTmp))
    {
    	pszTmp = new CHAR[ulenDist+ulenConst];
    }

    if (pszTmp)
    {
    	bAllocedTmp = TRUE;
    	nTmp = ulenDist + ulenConst;
    }
    else
    {
    	pszTmp = szTmp;
    	nTmp = sizeof(szTmp);
    }

    StrNCpy(pszTmp, REGKEY_ACTIVESETUP_COMPONENTS, nTmp);
    StrCatBuff(pszTmp, "\\", nTmp);
    StrCatBuff(pszTmp, pszDist, nTmp);

    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, pszTmp, 0, KEY_READ, &hKey) == ERROR_SUCCESS)
    {
        *lpfIsAuthorized = IsAuthorizedCDF(hKey);

        dwSize = sizeof(szTmp);
        if (RegQueryValueEx( hKey, REGVAL_VERSION_AVAILABLE, NULL, NULL, (LPBYTE)szTmp, &dwSize) == ERROR_SUCCESS)
        {
            DWORD Size;
            DWORD dwType;
            char  szVersionAdvertised[MAX_PATH];
            DWORD SizeDword = sizeof(DWORD);

            // check for precache registry key
            if (RegQueryValueEx(hKey, szPrecache, 0, &dwType, 
                (unsigned char *)&lResult, &SizeDword) == ERROR_SUCCESS) {

                // check for success or common error conditions which indicate we have bits.
                if (SUCCEEDED(lResult)) {
                    *lpfIsPrecached = TRUE;
                } else {
                    *lpfIsPrecached = FALSE;
                }

            }
            
            dwSize = sizeof(szVersionAdvertised);
            m_dwVersionAdvertisedMS = 0;
            m_dwVersionAdvertisedLS = 0;
            // read in the advertised version, if any
            if (RegQueryValueEx( hKey, REGVAL_VERSION_ADVERTISED, NULL, NULL,
                                 (LPBYTE)szVersionAdvertised, &dwSize) == ERROR_SUCCESS)
            {
                if ( SUCCEEDED(GetVersionFromString(szTmp, &dwCurAdvMS, &dwCurAdvLS)))
                {
                    m_dwVersionAdvertisedMS = dwCurAdvMS;
                    m_dwVersionAdvertisedLS = dwCurAdvLS;
                }
                SizeDword = sizeof(DWORD);
                RegQueryValueEx( hKey, REGVAL_ADSTATE, NULL, NULL, (LPBYTE)&m_dwAdState, &SizeDword);
            }

            dwCurAdvMS = 0;
            dwCurAdvLS = 0;

            // save away the advt info like Title, href, abstract
            // if called from GetDistributionUnitAdvt()
            if (!m_szHREF) {
                if (RegQueryValueEx(hKey, REGVAL_HREF_AVAILABLE, NULL, &dwType, 
                    NULL, &Size) == ERROR_SUCCESS) {

                    m_szHREF = new char[Size];

                    if (!m_szHREF) {
                        hr = E_OUTOFMEMORY;
                        goto Exit;
                    }
                    if (RegQueryValueEx(hKey, REGVAL_HREF_AVAILABLE, NULL, &dwType, 
                        (unsigned char *)m_szHREF, &Size) != ERROR_SUCCESS) {

                        hr = HRESULT_FROM_WIN32(GetLastError());
                        goto Exit;
                    }

                }
            }
            if (!m_szTitle) {
                if (RegQueryValueEx(hKey, REGVAL_TITLE_AVAILABLE, NULL, &dwType, 
                    NULL, &Size) == ERROR_SUCCESS) {

                    m_szTitle = new char[Size];

                    if (!m_szTitle) {
                        hr = E_OUTOFMEMORY;
                        goto Exit;
                    }
                    if (RegQueryValueEx(hKey, REGVAL_TITLE_AVAILABLE, NULL, &dwType, 
                        (unsigned char *)m_szTitle, &Size) != ERROR_SUCCESS) {

                        hr = HRESULT_FROM_WIN32(GetLastError());
                        goto Exit;
                    }

                }
            }
            if (!m_szAbstract) {
                if (RegQueryValueEx(hKey, REGVAL_ABSTRACT_AVAILABLE, NULL, &dwType, 
                    NULL, &Size) == ERROR_SUCCESS) {

                    m_szAbstract = new char[Size];

                    if (!m_szAbstract) {
                        hr = E_OUTOFMEMORY;
                        goto Exit;
                    }
                    if (RegQueryValueEx(hKey, REGVAL_ABSTRACT_AVAILABLE, NULL, &dwType, 
                        (unsigned char *)m_szAbstract, &Size) != ERROR_SUCCESS) {

                        hr = HRESULT_FROM_WIN32(GetLastError());
                        goto Exit;
                    }

                }
            }
            // If we have a Version available, we are done.
            if ( SUCCEEDED(GetVersionFromString(szTmp, &dwCurAdvMS, &dwCurAdvLS)))
            {
                if (!(m_dwVersionMS|m_dwVersionLS)) {
                    m_dwVersionMS = dwCurAdvMS;
                    m_dwVersionLS = dwCurAdvLS;
                }   

                if (IsCDFNewerVersion(dwCurAdvMS, dwCurAdvLS)) {
                    hr = S_FALSE;
                } else {
                    hr = S_OK;
                }
            }
        }
    }
Exit:

    if (bAllocedTmp)
    {
    	delete [] pszTmp;
    }
    
    SAFEDELETE(pszDist);
    
    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT
CSoftDist::GetSoftwareUpdateInfo( LPCWSTR szDistUnit, LPSOFTDISTINFO psdi )
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::GetSoftwareUpdateInfo",
                "this=%#x, %.80wq, %#x",
                this, szDistUnit, psdi
                ));
                
    HRESULT hr = S_OK;
    DWORD dwStyle = STYLE_MSICD;
    BOOL bIsPrecached = FALSE;
    BOOL bIsAuthorized = FALSE;

    if ( psdi != NULL )
    {
        psdi->szTitle = NULL;
        psdi->szAbstract = NULL;
        psdi->szHREF = NULL;
    }

    hr = PrepSoftwareUpdate( szDistUnit, &dwStyle );
    if ( FAILED(hr) )
        goto Exit;

    if (dwStyle == STYLE_MSICD) {
        hr = IsICDAdvertised(&bIsPrecached, &bIsAuthorized);
    } else if (dwStyle == STYLE_LOGO3) {
        hr = IsLogo3Advertised(&bIsPrecached, &bIsAuthorized);
    } else {
        hr = IsActSetupAdvertised(&bIsPrecached, &bIsAuthorized);
    }

    if ( hr == S_OK ) {
        BOOL bUpdateIsNewer = IsCDFNewerVersion(m_distunitinst.dwInstalledVersionMS, m_distunitinst.dwInstalledVersionLS);
 
        if ( psdi != NULL )
        {
            psdi->dwFlags = 0;
            psdi->dwInstalledVersionMS = m_distunitinst.dwInstalledVersionMS;
            psdi->dwInstalledVersionLS = m_distunitinst.dwInstalledVersionLS;
            psdi->dwUpdateVersionMS = m_dwVersionMS;
            psdi->dwUpdateVersionLS = m_dwVersionLS;
            psdi->dwAdvertisedVersionMS = m_dwVersionAdvertisedMS;
            psdi->dwAdvertisedVersionLS = m_dwVersionAdvertisedLS;
            psdi->dwAdState = m_dwAdState;
            // conjure up the flags
            // Note: we never set the e-mail flag.
            if ( bIsPrecached )
                psdi->dwFlags |= SOFTDIST_FLAG_USAGE_PRECACHE;

            // REVIEW: Is this true?
            // If we're precached and the update version matches the installed version,
            // then we've already auto-installed, or close enough for the purposes of
            // advertisement.
            if ( psdi->dwInstalledVersionMS == psdi->dwUpdateVersionMS &&
                 psdi->dwInstalledVersionLS == psdi->dwUpdateVersionLS )
                psdi->dwFlags |= SOFTDIST_FLAG_USAGE_AUTOINSTALL;

            if (m_szTitle)
            {
                hr = Ansi2Unicode( m_szTitle, &psdi->szTitle );
                if (FAILED(hr))
                    goto Exit;
            }
    
            if (m_szAbstract)
            {
                hr = Ansi2Unicode( m_szAbstract, &psdi->szAbstract );
                if (FAILED(hr))
                    goto Exit;
            }
    
            if (m_szHREF)
            {
                hr = Ansi2Unicode( m_szHREF,  &psdi->szHREF );
                if (FAILED(hr))
                    goto Exit;
            }
        } // if caller wants SOFTDISTINFO

        if ( bUpdateIsNewer )
            hr = S_OK;
        else
            hr = S_FALSE;
    }
    else
    {
        // return at least the current version in this situation
        if ( psdi != NULL )
        {
            psdi->dwFlags = 0;
            psdi->dwInstalledVersionMS = m_distunitinst.dwInstalledVersionMS;
            psdi->dwInstalledVersionLS = m_distunitinst.dwInstalledVersionLS;
            psdi->dwUpdateVersionMS = 0;
            psdi->dwUpdateVersionLS = 0;
            psdi->dwAdvertisedVersionMS = 0;
            psdi->dwAdvertisedVersionLS = 0;
            psdi->dwAdState = 0;
        }

        hr = E_INVALIDARG; // szDistUnit has no advertising data, not subscribed?
    // BUGBUG: we want to be able to populate the SOFTDISTINFO before the first 
    //         advertised update, but this class won't scoop up the necessary goo
    //         prior.

    }

Exit:

    if ( FAILED(hr) && psdi != NULL )
    {
        SAFEDELETE(psdi->szTitle);
        SAFEDELETE(psdi->szAbstract);
        SAFEDELETE(psdi->szHREF);
    }
    
    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT
CSoftDist::SetSoftwareUpdateAdvertisementState( LPCWSTR szDistUnit,
                                                 DWORD dwAdState,
                                                 DWORD dwAdvertisedVersionMS,
                                                 DWORD dwAdvertisedVersionLS )
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::SetSoftwareUpdateAdvertisementState",
                "this=%#x, %.80wq, %#x, %#x, %#x",
                this, szDistUnit, dwAdState, dwAdvertisedVersionMS, dwAdvertisedVersionLS
                ));
                
    HRESULT hr = S_OK;
    DWORD dwStyle;
    TCHAR *pszDU = NULL;

    hr = Unicode2Ansi( szDistUnit, &pszDU );

    // code around assumes that MAX_PATH is MAX size of dist unit
    // we try to make a key name with the distunit and that limit is
    // now MAX_PATH. Hence the reasoning to limit this to MAX_PATH
    if (FAILED(hr) || (lstrlenW(szDistUnit) > MAX_PATH)) {
        if (SUCCEEDED(hr)) {
            hr = HRESULT_FROM_WIN32(ERROR_BUFFER_OVERFLOW);
        }
        goto Exit;
    }


    // BUFFER OVERRUN : limit size in of distunit
    hr = PrepSoftwareUpdate( szDistUnit, &dwStyle );

    if ( SUCCEEDED(hr) )
    {
        if (dwStyle == STYLE_MSICD)
        {
            LONG lResult = ERROR_SUCCESS;
            HKEY hkeyDist =0;
            HKEY hkeyThisDist = 0;
            HKEY hkeyAdvertisedVersion = 0;

            char szTmp[2*MAX_PATH];
            wnsprintf( szTmp, sizeof(szTmp)-1, "%s\\%s\\%s", REGSTR_PATH_DIST_UNITS, pszDU, REGKEY_MSICD_ADVERTISED_VERSION );

            if (RegCreateKey(HKEY_LOCAL_MACHINE, szTmp, &hkeyAdvertisedVersion) == ERROR_SUCCESS)
            {
                // Note Version
                wsprintf(szTmp, "%d,%d,%d,%d",
                        (dwAdvertisedVersionMS & 0xffff0000)>>16,
                        (dwAdvertisedVersionMS & 0xffff),
                        (dwAdvertisedVersionLS & 0xffff0000)>>16,
                        (dwAdvertisedVersionLS & 0xffff));
                lResult = ::RegSetValueEx(hkeyAdvertisedVersion, NULL, NULL, REG_SZ, 
                                    (unsigned char *)szTmp, lstrlen(szTmp)+1);
                if ( lResult == ERROR_SUCCESS )
                {
                    lResult = ::RegSetValueEx(hkeyAdvertisedVersion, REGVAL_ADSTATE, NULL, REG_DWORD, 
                                              (unsigned char *)&dwAdState, sizeof(DWORD) );
                    if ( lResult != ERROR_SUCCESS )
                        hr = HRESULT_FROM_WIN32( lResult );
                }
                else
                    hr = HRESULT_FROM_WIN32( lResult );

                RegCloseKey( hkeyAdvertisedVersion );
            }
        }
        else if (dwStyle == STYLE_LOGO3)
        {
            LONG lResult = ERROR_SUCCESS;
            HKEY hkeyDist =0;
            HKEY hkeyThisDist = 0;
            HKEY hkeyAvailableVersion = 0;

            char szTmp[2*MAX_PATH];
            wnsprintf( szTmp, sizeof(szTmp)-1, "%s\\%s\\%s", REGSTR_PATH_LOGO3_SETTINGS, pszDU, REGKEY_LOGO3_AVAILABLE_VERSION );

            if (RegCreateKey(HKEY_LOCAL_MACHINE, szTmp, &hkeyAvailableVersion) == ERROR_SUCCESS)
            {
                // Note Version
                wsprintf(szTmp, "%d,%d,%d,%d",
                        (dwAdvertisedVersionMS & 0xffff0000)>>16,
                        (dwAdvertisedVersionMS & 0xffff),
                        (dwAdvertisedVersionLS & 0xffff0000)>>16,
                        (dwAdvertisedVersionLS & 0xffff));
                lResult = ::RegSetValueEx(hkeyAvailableVersion, REGSTR_LOGO3_ADVERTISED_VERSION, NULL, REG_SZ,
                                    (unsigned char *)szTmp, lstrlen(szTmp)+1);
                if ( lResult == ERROR_SUCCESS )
                {
                    lResult = ::RegSetValueEx(hkeyAvailableVersion, REGVAL_ADSTATE, NULL, REG_DWORD,
                                              (unsigned char *)&dwAdState, sizeof(DWORD) );
                    if ( lResult != ERROR_SUCCESS )
                        hr = HRESULT_FROM_WIN32( lResult );
                }
                else
                    hr = HRESULT_FROM_WIN32( lResult );

                RegCloseKey( hkeyAvailableVersion );
            }
        }
        else
        {
            LPSTR    pszKey = NULL;
            BOOL     bAllocedKey = FALSE;
            int         nKey;
            
            CHAR   szKey[2*MAX_PATH];  
            HKEY    hKey;
            LONG    lResult = ERROR_SUCCESS;

	    ULONG ulenDist = lstrlenA(pszDU);
	    //sizeof counts terminating NULL also, so subtract 2, and add 1 for the final NULL
	    ULONG ulenConst = sizeof(REGKEY_ACTIVESETUP_COMPONENTS)/sizeof(CHAR) + sizeof("\\")/sizeof(CHAR) - 2 + 1;
	    
	    if ((ulenDist+ulenConst)  > sizeof(szKey))
	    {
	    	pszKey = new CHAR[ulenDist+ulenConst];
	    }

	    if (pszKey)
	    {
	    	bAllocedKey = TRUE;
	    	nKey = ulenDist + ulenConst;
	    }
	    else
	    {
	    	pszKey = szKey;
	    	nKey = sizeof(szKey);
	    }

            StrNCpy(pszKey, REGKEY_ACTIVESETUP_COMPONENTS, nKey);
            StrCatBuff(pszKey, "\\", nKey);
            StrCatBuff(pszKey, pszDU, nKey);
            if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, pszKey, 0, KEY_WRITE , &hKey ) == ERROR_SUCCESS)
            {
                // Note Version
                wsprintf(pszKey, "%d,%d,%d,%d",
                        (dwAdvertisedVersionMS & 0xffff0000)>>16,
                        (dwAdvertisedVersionMS & 0xffff),
                        (dwAdvertisedVersionLS & 0xffff0000)>>16,
                        (dwAdvertisedVersionLS & 0xffff));
                lResult = ::RegSetValueEx(hKey, REGVAL_VERSION_ADVERTISED, NULL, REG_SZ, 
                                    (unsigned char *)pszKey, lstrlen(pszKey)+1);
                if ( lResult == ERROR_SUCCESS )
                {
                    lResult = ::RegSetValueEx(hKey, REGVAL_ADSTATE, NULL, REG_DWORD, 
                                              (unsigned char *)&dwAdState, sizeof(DWORD) );
                    if ( lResult != ERROR_SUCCESS )
                        hr = HRESULT_FROM_WIN32( lResult );
                }
                else
                    hr = HRESULT_FROM_WIN32( lResult );

                RegCloseKey( hKey );
            }

            if (bAllocedKey)
            {
            	delete [] pszKey;
            }
        }
    }

Exit:

    SAFEDELETE(pszDU);

    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT
CSoftDist::PrepSoftwareUpdate( LPCWSTR szDistUnit, DWORD *pdwStyle )
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::PrepSoftwareUpdate",
                "this=%#x, %.80wq, %#x",
                this, szDistUnit, pdwStyle
                ));
                
    HRESULT hr = S_OK;
    *pdwStyle = STYLE_MSICD;

    hr = CDLDupWStr( &m_szDistUnit, szDistUnit );
    if ( FAILED(hr) )
        goto Exit;

    hr = IsICDLocallyInstalled(m_szDistUnit, m_dwVersionMS, m_dwVersionLS, m_szLanguages);
    if (FAILED(hr))
        goto Exit;

    if (!IsAnyInstalled()) {

        hr = IsActSetupLocallyInstalled(m_szDistUnit, m_dwVersionMS, m_dwVersionLS, m_szLanguages);
        if (FAILED(hr))
        {
            goto Exit;
        }
        else if (hr == S_OK)
        {
            *pdwStyle = STYLE_ACTIVE_SETUP;
            goto Exit;
        }

        if (!IsAnyInstalled()) {
            hr = IsLogo3LocallyInstalled(m_szDistUnit, m_dwVersionMS, m_dwVersionLS, m_szLanguages);

            if (FAILED(hr))
            {
                if (!IsAnyInstalled()) {
                    // some prev version must be installed for this to succeed
                    hr = HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND);
                    goto Exit;
                }
            }
            else if (hr == S_OK)
            {
                *pdwStyle = STYLE_LOGO3;
            }
        }

    }

Exit:
    
    DEBUG_LEAVE(hr);
    return hr;
}

STDMETHODIMP CSoftDist::Logo3DownloadNext()
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::Logo3DownloadNext",
                "this=%#x",
                this
                ));
                
    HRESULT                        hr = S_FALSE;
    FILETIME                       ftExpireTime;
    FILETIME                       ftTime;
    LPWSTR                         wszCodeBase = NULL;
    LPSTR                          szDownloadedCodeBase = NULL;
    LPSTR                          szMainCodeBase = NULL;
    LPSTR                          szDownloadedFile = NULL;
    LPSTR                          pszExtn = NULL;
    DWORD                          dwSize = 0;
    DWORD                          dwBytes;
    CCodeBaseHold                 *pcbhPrev = NULL;
    CCodeBaseHold                 *pcbhCur = NULL;
    LISTPOSITION                   lpos = 0, lposOld = 0;
    BOOL                           bFound = FALSE;
    BOOL                           bFakeCacheEntry;
    TCHAR                          achFileName[MAX_PATH];
    LPINTERNET_CACHE_ENTRY_INFO    lpCacheEntryInfo = NULL;
    char                           achBuffer[MAX_CACHE_ENTRY_INFO_SIZE];
    
    pcbhPrev = m_cbh.GetAt(m_curPos);
    Assert(pcbhPrev);

    if (FAILED(hr = Unicode2Ansi(pcbhPrev->wszCodeBase, &szDownloadedCodeBase))) {
        goto Exit;
    }


    lpCacheEntryInfo = (LPINTERNET_CACHE_ENTRY_INFO)achBuffer;
    dwSize = MAX_CACHE_ENTRY_INFO_SIZE;
    if (!GetUrlCacheEntryInfo(szDownloadedCodeBase, lpCacheEntryInfo, &dwSize)) {
        // this should never happen
        hr = E_FAIL;
        goto Exit;
    }

    szDownloadedFile = new char[lstrlen(lpCacheEntryInfo->lpszLocalFileName) + 1];
    if (szDownloadedFile == NULL) {
        hr = E_OUTOFMEMORY;
        goto Exit;
    }
    lstrcpy(szDownloadedFile, lpCacheEntryInfo->lpszLocalFileName);

    GetSystemTimeAsFileTime(&ftTime);
    ftExpireTime.dwLowDateTime = (DWORD)0;
    ftExpireTime.dwHighDateTime = (DWORD)0;

    // Mark all CCodeBaseHold's with same group as downloaded and find
    // main codebase

    bFakeCacheEntry = TRUE;
    szMainCodeBase = NULL;
    lpos = m_cbh.GetHeadPosition();
    while (lpos) {
        pcbhCur = m_cbh.GetNext(lpos);

        if (pcbhCur->dwFlags & CBH_FLAGS_MAIN_CODEBASE) {
            Assert(szMainCodeBase == NULL); // we should only get here once
            if (FAILED(Unicode2Ansi(pcbhCur->wszCodeBase, &szMainCodeBase))) {
                hr = E_FAIL;
                goto Exit;
            }
            if (pcbhCur == pcbhPrev || StrCmpW(pcbhCur->wszDLGroup, pcbhPrev->wszDLGroup)) {
                bFakeCacheEntry = FALSE;
            }
        }
        
        if (pcbhCur == pcbhPrev) {
            continue;
        }
        if (!StrCmpW(pcbhPrev->wszDLGroup, pcbhCur->wszDLGroup)) {
            pcbhCur->dwFlags |= CBH_FLAGS_DOWNLOADED;
        }
    }

    // Fake a cache entry for this
    if (bFakeCacheEntry) {
        Assert(szMainCodeBase != NULL);

        lpCacheEntryInfo = (LPINTERNET_CACHE_ENTRY_INFO)achBuffer;
        dwSize = MAX_CACHE_ENTRY_INFO_SIZE;
        if (!GetUrlCacheEntryInfo(szMainCodeBase, lpCacheEntryInfo, &dwSize)) {
            pszExtn = PathFindExtension(szMainCodeBase) + 1;
            if (CreateUrlCacheEntry((LPCSTR)szMainCodeBase, 0, pszExtn,
                                    achFileName, 0)) {
                CopyFile(szDownloadedFile, achFileName, FALSE);
                CommitUrlCacheEntry(szMainCodeBase, achFileName, ftExpireTime,
                                    ftTime, NORMAL_CACHE_ENTRY, NULL, 0,
                                    pszExtn, szDownloadedCodeBase);
            }
        }
    }

    // Iterate list until we get a new group

    pcbhCur = NULL;
    lpos = m_cbh.GetHeadPosition();
    while (lpos) {
        lposOld = lpos;
        pcbhCur = m_cbh.GetNext(lpos);

        if (!(pcbhCur->dwFlags & CBH_FLAGS_DOWNLOADED)) {
            m_curPos = lposOld;
            bFound = TRUE;
            pcbhCur->dwFlags |= CBH_FLAGS_DOWNLOADED;
            hr = CDLDupWStr(&wszCodeBase, pcbhCur->wszCodeBase);
            break;
        }
    }

    hr = (bFound) ? (Logo3Download(wszCodeBase)) : (S_FALSE);

Exit:

    SAFEDELETE(szDownloadedCodeBase);
    SAFEDELETE(szDownloadedFile);
    SAFEDELETE(szMainCodeBase);
    
    DEBUG_LEAVE(hr);
    return hr;    
}

STDMETHODIMP CSoftDist::Logo3DownloadRedundant()
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::Logo3DownloadRedundant",
                "this=%#x",
                this
                ));
                
    HRESULT                        hr = S_FALSE;
    LPWSTR                         szCodeBase = NULL;
    DWORD                          dwSize = 0;
    CCodeBaseHold                 *pcbhPrev = NULL;
    CCodeBaseHold                 *pcbhCur = NULL;
    LISTPOSITION                   lpos = 0, lposOld = 0;
    BOOL                           bFound = FALSE;
    
    pcbhPrev = m_cbh.GetAt(m_curPos);
    Assert(pcbhPrev);

    // Find first undownloaded codebase of the same group

    lpos = m_cbh.GetHeadPosition();
    while (lpos) {
        lposOld = lpos;
        pcbhCur = m_cbh.GetNext(lpos);
        if (!(pcbhCur->dwFlags & CBH_FLAGS_DOWNLOADED) &&
            !StrCmpW(pcbhCur->wszDLGroup, pcbhPrev->wszDLGroup)) {
            bFound = TRUE;
            m_curPos = lposOld;
            pcbhCur->dwFlags |= CBH_FLAGS_DOWNLOADED;
            hr = CDLDupWStr(&szCodeBase, pcbhCur->wszCodeBase);
            dwSize = pcbhCur->dwSize;
            break;
        }
    }

    hr = (bFound) ? (Logo3Download(szCodeBase)) : (S_FALSE);
    
    DEBUG_LEAVE(hr);
    return hr;    
}

STDMETHODIMP CSoftDist::Logo3Download(LPWSTR szCodeBase)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CSoftDist::Logo3Download",
                "this=%#x, %.80wq",
                szCodeBase
                ));
                
    HRESULT                   hr = S_OK;
    DWORD                     dwLen = 0;
    char                      achCodeBase[INTERNET_MAX_PATH_LENGTH];
    IMoniker                 *pmk = NULL;
    Logo3CodeDLBSC           *pCDLBSC = NULL;
    IBindCtx                 *pabc = NULL;
    IBindStatusCallback      *pbscOld = NULL;
    IUnknown                 *pUnk = NULL;

    hr = CreateURLMoniker(NULL, szCodeBase, &pmk);
    if (SUCCEEDED(hr))
    {
        dwLen = INTERNET_MAX_PATH_LENGTH;
        WideCharToMultiByte(CP_ACP, 0, szCodeBase , -1, achCodeBase,
                            dwLen, NULL, NULL);

        Assert(m_pClientBSC);

        pCDLBSC = new Logo3CodeDLBSC(this, m_pClientBSC, achCodeBase,
                                     m_szDistUnit);
    if (pCDLBSC == NULL)
        {
            hr = E_OUTOFMEMORY;
            SAFERELEASE(pmk);
            m_pClientBSC->Release();
            goto Exit;
        }
        

        hr = CreateBindCtx(0, &pabc);
        if (SUCCEEDED(hr))
        {
            hr = RegisterBindStatusCallback(pabc, pCDLBSC, &pbscOld, 0);
        }

        if (SUCCEEDED(hr))
        {
            pCDLBSC->SetBindCtx(pabc);
            hr = pmk->BindToStorage(pabc, NULL, IID_IUnknown, (void **)&pUnk);
            if (FAILED(hr) && hr != E_PENDING)
            {
                RevokeBindStatusCallback(pabc, pCDLBSC);
            }
        }

        if (pUnk) {
            pUnk->Release();
        }
    }
    
Exit:

    SAFERELEASE(pCDLBSC);
    SAFERELEASE(pabc);
    SAFERELEASE(pbscOld);
    SAFERELEASE(pmk);
    
    DEBUG_LEAVE(hr);
    return hr;
}

// Replace the ';' separator with '\0' and count the number of languages in the string.
void PrepareLanguage(LPSTR lpLang)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                None,
                "PrepareLanguage",
                "%.80q",
                lpLang
                ));
                
    LPSTR lpTmp;
    int index = 0;

    if (lpLang)
    {
        index = 1;
        lpTmp = lpLang;
        while (*lpTmp)
        {
            if (*lpTmp == ';')
            {
                *lpTmp = '\0';
                index++;
            }
            lpTmp = CharNext(lpTmp);
        }
    }
    
    DEBUG_LEAVE(0);
    return;
}

// Checks if all languages in the semicolon separated list of lpszLang1 are also in lpszLang2
BOOL AreAllLanguagesPresent(LPCSTR lpszLang1, LPCSTR lpszLang2)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Bool,
                "AreAllLanguagesPresent",
                "%.80q, %.80q",
                lpszLang1, lpszLang2
                ));
                
    LPSTR lpLang1 = NULL;
    LPSTR lpLang2 = NULL;
    LPSTR lpTmp1;           // Pointer into lpLang1
    LPSTR lpTmp2;           // pointer into lpLang2
    BOOL  bAllPresent = FALSE;
    BOOL  bFoundOne = TRUE;

    if (lpszLang2 == NULL)      // No language in the CDF, assume all languages are OK
    {
        DEBUG_LEAVE(TRUE);
        return TRUE;
    }
    
    // Make a copy of the language strings
    lpLang1 = new char[lstrlen(lpszLang1) + 2];
    lpLang2 = new char[lstrlen(lpszLang2) + 2];

    if ((lpLang1) && (lpLang2))
    {
        strcpy(lpLang1, lpszLang1);
        strcpy(lpLang2, lpszLang2);
        PrepareLanguage(lpLang1);
        PrepareLanguage(lpLang2);
        lpTmp1 = lpLang1;
        while ((*lpTmp1) && (bFoundOne))
        {
            lpTmp2 = lpLang2;
            bFoundOne = FALSE;
            while ((*lpTmp2) && !bFoundOne)
            {
                bFoundOne = (lstrcmpi(lpTmp1, lpTmp2) == 0);
                lpTmp2 += lstrlen(lpTmp2) + 1;
            }
            lpTmp1 += lstrlen(lpTmp1) + 1;
        }
        bAllPresent = bFoundOne;
    }

    SAFEDELETE(lpLang1);
    SAFEDELETE(lpLang2);
    
    DEBUG_LEAVE(bAllPresent);
    return bAllPresent;
}

STDAPI GetSoftwareUpdateInfo( LPCWSTR szDistUnit, LPSOFTDISTINFO psdi )
{
    DEBUG_ENTER_API((DBG_DOWNLOAD,
                    Hresult,
                    "GetSoftwareUpdateInfo",
                    "%.80wq, %#x",
                    szDistUnit, psdi
                    ));

    HRESULT hr = S_OK;

    if ( psdi == NULL ||
         (psdi->cbSize == sizeof(SOFTDISTINFO) && psdi->dwReserved == 0) )
    {
        CSoftDist *pSoftDist = new CSoftDist();

        if (!pSoftDist) {
            hr = E_OUTOFMEMORY;
            goto Exit;
        }

        hr = pSoftDist->GetSoftwareUpdateInfo(szDistUnit, psdi);

        SAFERELEASE(pSoftDist);

    }
    else
        hr = E_INVALIDARG;

Exit:
    
    DEBUG_LEAVE_API(hr);
    return hr;
}


STDAPI SetSoftwareUpdateAdvertisementState( LPCWSTR szDistUnit,
                                             DWORD dwAdState,
                                             DWORD dwAdvertisedVersionMS,
                                             DWORD dwAdvertisedVersionLS )
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "SetSoftwareUpdateAdvertisementState",
                "%.80wq, %#x, %#x, %#x",
                szDistUnit, dwAdState, dwAdvertisedVersionMS, dwAdvertisedVersionLS
                ));

    HRESULT hr = S_OK;
    CSoftDist *pSoftDist = new CSoftDist();

    if (!pSoftDist) {
        hr = E_OUTOFMEMORY;
        goto Exit;
    }

    hr = pSoftDist->SetSoftwareUpdateAdvertisementState( szDistUnit,
                                                        dwAdState,
                                                        dwAdvertisedVersionMS,
                                                        dwAdvertisedVersionLS );
    SAFERELEASE(pSoftDist);

Exit:
    
    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT GetStyleFromString(LPSTR szStyle, LPDWORD lpdwStyle)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "GetStyleFromString",
                "%.80q, %#x",
                szStyle, lpdwStyle
                ));
                
    HRESULT hr = S_OK;
  
    if (szStyle == NULL || lpdwStyle == NULL) {
        hr = E_INVALIDARG;
    } else if (lstrcmpi(szStyle,DU_STYLE_MSICD) == 0) {
        *lpdwStyle = STYLE_MSICD;
    } else if (lstrcmpi(szStyle,DU_STYLE_ACTIVE_SETUP) == 0) {
        *lpdwStyle = STYLE_ACTIVE_SETUP;
    } else if (lstrcmpi(szStyle,DU_STYLE_MSINSTALL) == 0) {
        *lpdwStyle = STYLE_MSINSTALL;
    } else if (lstrcmpi(szStyle,DU_STYLE_LOGO3) == 0 ) {
        *lpdwStyle = STYLE_LOGO3;
    } else {
        *lpdwStyle = STYLE_UNKNOWN;
        hr = E_UNEXPECTED;
    }
    
    DEBUG_LEAVE(hr);
    return hr;
}

//*******************************************************************************************
// CActiveSetupBinding : Wrapper class to simulate control over client binding operation when
//                       we are actually dealing with an EXE.
//*******************************************************************************************
DWORD WINAPI StartActiveSetup(void *dwArg)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Dword,
                "StartActiveSetup",
                "%#x",
                dwArg
                ));
                
    CActiveSetupBinding *pasb = (CActiveSetupBinding *)dwArg;
    
    ASSERT(pasb);
    pasb->StartActiveSetup();

    // Should never return.
    ASSERT(FALSE);
    
    DEBUG_LEAVE(-1);
    return -1;
}

CActiveSetupBinding::CActiveSetupBinding(IBindCtx *pbc, 
           IBindStatusCallback *pbsc, LPWSTR szCodeBase, 
           LPWSTR szDistUnit, HRESULT *phr)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                None,
                "CActiveSetupBinding::CActiveSetupBinding",
                "this=%#x, %#x, %#x, %.80wq, %.80wq, %#x",
                this, pbc, pbsc, szCodeBase, szDistUnit, phr
                ));
                
    HKEY hkAppPath = NULL;

    ASSERT(pbc);
    ASSERT(pbsc);
    ASSERT(phr);

    *phr = S_OK;
    fSilent = FALSE;
    
    m_pbc = pbc;
    m_pbc->AddRef();
    m_pbsc = pbsc;
    m_pbsc->AddRef();

    m_dwRef = 1;
    m_hWaitThread = NULL;
    memset(&m_piChild, 0, sizeof(m_piChild));

    if (FAILED(Unicode2Ansi(szCodeBase, &m_szCodeBase)))
        goto Exit;
    
    if (FAILED(Unicode2Ansi(szDistUnit, &m_szDistUnit)))
        goto Exit;

    ASSERT(m_szCodeBase);
  
    // Get actsetup.exe path.
    if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, 
                     "Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\IEXPLORE.EXE",
                     0, KEY_READ, &hkAppPath) == ERROR_SUCCESS)  {
    
        long dwSize = MAX_PATH;
        m_szActSetupPath[0] = '\0';

        if (RegQueryValueA(hkAppPath, NULL, (LPSTR)m_szActSetupPath, &dwSize) == ERROR_SUCCESS) {
           
            if ((dwSize <= 1)  || (m_szActSetupPath[0] == '\0'))
                goto Exit;
            
            LPSTR szCur = &m_szActSetupPath[dwSize-2];      // points to last character
            while (szCur>m_szActSetupPath) {
                if (*szCur == '\\')
                    break;
                szCur--;
            }

            *(++szCur) = '\0';      // Prematurely truncate string (chop off IEXPLORE.EXE)

        } else
            goto Exit;
        
    } else 
        goto Exit;
    
    // Create thread to monitor status of Active Setup executable.
    m_hWaitThread = CreateThread(NULL, 0, &(::StartActiveSetup), (LPVOID)this, 0, &dwThreadID);

Exit:
    *phr = (m_hWaitThread != NULL) ? S_OK : E_FAIL;

    SAFEREGCLOSEKEY(hkAppPath);

    DEBUG_LEAVE(0);
}

CActiveSetupBinding::~CActiveSetupBinding() 
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                None,
                "CActiveSetupBinding::~CActiveSetupBinding",
                "this=%#x",
                this
                ));
                
    ASSERT(m_dwRef == 0);

    SAFERELEASE(m_pbsc);
    SAFERELEASE(m_pbc);
    SAFEDELETE(m_szCodeBase);
    SAFEDELETE(m_szDistUnit);

    if (m_hWaitThread)
        CloseHandle(m_hWaitThread);

    if (m_piChild.hProcess)
        CloseHandle(m_piChild.hProcess);
    
    if (m_piChild.hThread)
        CloseHandle(m_piChild.hThread);

    DEBUG_LEAVE(0);
}

void CActiveSetupBinding::StartActiveSetup(void)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                None,
                "CActiveSetupBinding::StartActiveSetup",
                "this=%#x",
                this
                ));
                
    CHAR szCmdLine[2*MAX_PATH];
    STARTUPINFO si;
    DWORD dwResult;
    LPSTR szSite;

    //REVIEW: Change to some other suitable value?
    const DWORD dwTimeOut = 100*60*5;   // every 5 minutes

    memset(&si, 0, sizeof(si));
    si.cb = sizeof(STARTUPINFO);    // ActSetup.Exe can take care of itself.

    BINDINFO bi;
    DWORD dwBindf = 0;
    memset(&bi, 0, sizeof(BINDINFO));
    bi.cbSize = sizeof(BINDINFO);

    m_pbsc->GetBindInfo(&dwBindf, &bi);
    fSilent = (dwBindf & BINDF_SILENTOPERATION) ? TRUE : FALSE;

    szSite = StrChr(m_szCodeBase, ';');
    if (szSite) {
        *szSite = '\0';
        szSite++;
        SetDefaultDownloadSite(szSite);
    }

    // compose the pathname for actsetup.exe and then check for
    // file existence before spawning process
    wnsprintfA(szCmdLine, sizeof(szCmdLine)-1, "%sactsetup.exe", m_szActSetupPath);

    if (GetFileAttributes(szCmdLine) == -1) {
        DoCleanUp(E_NOTIMPL); // auto install or pre download not impl
        delete this;
        goto Exit;
    }

    // Create proper command line

    // /r:n   - no reboot
    // /d     - download only
    // /q     - silent mode (does not require user input)

    wnsprintfA(szCmdLine, sizeof(szCmdLine)-1, "\"%sactsetup.exe\" /J:job.ie4 /r:n /q %s /s:\"%s\" ", 
        m_szActSetupPath, fSilent ? "/d" : "", m_szCodeBase);

    // Use ansi version since Win95 doesn't support unicode version.

    if (!CreateProcessA(NULL,           // lpApplicationName
                  szCmdLine,            // lpCommandLine
                  NULL,                 // lpProcessAttributes
                  NULL,                 // lpThreadAttributes
                  FALSE,                // Inherit Handles
                  0,                    // dwCreationFlags
                  NULL,                 // Environment block (inherit callers)
                  NULL,                 // Current directory
                  &si,                  // STARTUPINFO record
                  &m_piChild)) {        // PROCESSINFOMRATION record

        delete this;
        goto Exit;
    }

    // REVIEW: Localize status messages?  Messages aren't currently used for anything useful.

    if (FAILED(m_pbsc->OnStartBinding(0,(IBinding *)this)))
        goto Exit;

    while ((dwResult = WaitForSingleObject(m_piChild.hProcess, dwTimeOut)) == WAIT_TIMEOUT) {

        (void) m_pbsc->OnProgress(0,0,BINDSTATUS_DOWNLOADINGDATA, L"ActiveSetup Running");

    }
    ASSERT(dwResult == WAIT_OBJECT_O);

    if (GetExitCodeProcess(m_piChild.hProcess, &dwResult)) {

        //REVIEW: Check for partial return codes.

        SaveHresult(dwResult);

        if (SUCCEEDED(dwResult)) {

            (void) m_pbsc->OnStopBinding(S_OK, NULL);
            
        } else {

            DoCleanUp(dwResult);
            goto Exit;

        }
        
    } else {

        // Install failed, abort process.
        DoCleanUp(E_FAIL);
        goto Exit;
    }

    delete this;

Exit:
    //  BINDINFO_FIX(LaszloG) 8/15/96
    ReleaseBindInfo(&bi);

    DEBUG_LEAVE(0);
    ExitThread(-1);
}

STDMETHODIMP CActiveSetupBinding::QueryInterface(REFIID riid,void ** ppv)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CActiveSetupBinding::IUnknown::QueryInterface",
                "this=%#x, %#x, %#x",
                this, &riid, ppv
                ));
                
    if ((riid == IID_IUnknown) || (riid == IID_IBinding))
    {
        *ppv = (IBinding *) this;
        AddRef();
    
        DEBUG_LEAVE(S_OK);
        return S_OK;
    }
    else
    {
        DEBUG_LEAVE(E_NOINTERFACE);
        return E_NOINTERFACE;
    }
}

STDMETHODIMP_(ULONG) CActiveSetupBinding::AddRef()
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Dword,
                "CActiveSetupBinding::IUnknown::AddRef",
                "this=%#x",
                this
                ));
                
    ULONG ulRet = m_dwRef++;
    
    DEBUG_LEAVE(ulRet);
    return ulRet;
}

STDMETHODIMP_(ULONG) CActiveSetupBinding::Release()
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Dword,
                "CActiveSetupBinding::IUnknown::Release",
                "this=%#x",
                this
                ));
                
    if (--m_dwRef == 0) {
        delete this;
    
        DEBUG_LEAVE(0);
        return 0;
    }

    DEBUG_LEAVE(m_dwRef);
    return m_dwRef;
}

HRESULT CActiveSetupBinding::SetDefaultDownloadSite(LPSTR szSite)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CActiveSetupBinding::SetDefaultDownloadSite",
                "this=%#x, %.80q",
                this, szSite
                ));
                
    HRESULT hr = S_OK;
    const static char * szRegion = "DownloadSiteRegion";
    CHAR szTmp[MAX_PATH];
    DWORD dwSize = 0, dwType = REG_SZ, dwResult;
    HKEY hKey = 0;

    //static known sizes of buffers.
    
    lstrcpy(szTmp, REGKEY_ACTIVESETUP);
    lstrcat(szTmp, "\\Jobs\\Job.IE4");

    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szTmp, 0, KEY_ALL_ACCESS, &hKey) == ERROR_SUCCESS)
    {

        if (RegQueryValueEx(hKey, szRegion, 0, &dwType, NULL, &dwSize) != ERROR_SUCCESS)
        {
            hr = RegSetValueEx(hKey, szRegion, 0, REG_SZ, (LPBYTE)szSite, strlen(szSite));
        }

        ::RegCloseKey(hKey);
    }
    
    DEBUG_LEAVE(hr);
    return hr;
}

STDMETHODIMP CActiveSetupBinding::Abort(void)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CActiveSetupBinding::IBinding::Abort",
                "this=%#x",
                this
                ));
                
    HRESULT hr = E_FAIL;
    DWORD dwSize, dwResult;
    HKEY hKey = 0;

    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGKEY_ACTIVESETUP, 0, KEY_ALL_ACCESS, &hKey) == ERROR_SUCCESS)
    {
        hr = RegSetValueEx(hKey, szControlSetup, 0, REG_DWORD, (LPBYTE)&dwStatusAbort, sizeof(DWORD));
        
        ::RegCloseKey(hKey);
    }

    if (SUCCEEDED(hr) && m_hWaitThread)
    {
        // The child thread will terminate when Active Setup finishes and post message
        // to tray agent to terminate.
    }
    else
    {
        // terminate waiting thread
        TerminateThread(m_hWaitThread, E_ABORT);

        // terminate active setup process
        TerminateProcess(m_piChild.hProcess, E_ABORT);

        DoCleanUp(E_ABORT);
    }
    
    DEBUG_LEAVE(hr);
    return hr;
}

HRESULT CActiveSetupBinding::SaveHresult(HRESULT hrResult)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CActiveSetupBinding::SaveHresult",
                "this=%#x, %#x",
                this, hrResult
                ));
                
    HRESULT hr = S_OK;
    const static char * szPrecache = "Precache";
    HKEY hKey = 0;
    LPSTR pszTmp = NULL;
    BOOL  bAllocedTmp = FALSE;
    int       nTmp;
    CHAR szTmp[2*MAX_PATH];
    DWORD dwSize;
    HWND hwnd = 0;

    ULONG ulenDist = lstrlenA(m_szDistUnit);
    //sizeof counts terminating NULL also, so subtract 2, and add 1 for the final NULL
    ULONG ulenConst = sizeof(REGKEY_ACTIVESETUP_COMPONENTS)/sizeof(CHAR) + sizeof("\\")/sizeof(CHAR) - 2 + 1;
    
    if ((ulenDist+ulenConst)  > sizeof(szTmp))
    {
    	pszTmp = new CHAR[ulenDist+ulenConst];
    }

    if (pszTmp)
    {
    	bAllocedTmp = TRUE;
    	nTmp = ulenDist + ulenConst;
    }
    else
    {
    	pszTmp = szTmp;
    	nTmp = sizeof(szTmp);
    }

    StrNCpy(pszTmp, REGKEY_ACTIVESETUP_COMPONENTS, nTmp);
    StrCatBuff(pszTmp, "\\", nTmp);
    StrCatBuff(pszTmp, m_szDistUnit, nTmp);

    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, pszTmp, 0, KEY_ALL_ACCESS, &hKey) == ERROR_SUCCESS)
    {
        // if silent mode or autoinstall / failed then record as precache attempt

        if (fSilent || (!fSilent && FAILED(hrResult)))
        {
            // for silent (download only), record precache result
            hr = RegSetValueEx(hKey, szPrecache, 0, REG_DWORD, (LPBYTE)&hrResult, sizeof(HRESULT));
        }
        else
        {
            // for non-silent (autoinstall), kill the precache key
            hr = RegDeleteValue(hKey, szPrecache);
        }

        ::RegCloseKey(hKey);
    }

    // if reboot required, post a message to tray agent message pump if we can find it.
    if (hrResult == ERROR_SUCCESS_REBOOT_REQUIRED)
    {
        hwnd = FindWindow(c_szTrayUI, NULL);
        if (hwnd)
        {
             (void) SendNotifyMessage(hwnd, WM_USER, 0, UM_NEEDREBOOT);
        }
    }

    if (bAllocedTmp)
    {
    	delete [] pszTmp;
    }
    
    DEBUG_LEAVE(hr);
    return hr;
}

void CActiveSetupBinding::DoCleanUp(DWORD dwExitCode)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                None,
                "CActiveSetupBinding::DoCleanUp",
                "this=%#x, %#x",
                this, dwExitCode
                ));
                
    m_pbsc->OnStopBinding(dwExitCode, NULL);

    SAFERELEASE(m_pbsc);
    SAFERELEASE(m_pbc);

    // at this point, BindCtx loses all references, deletes itself and
    // its reference to BindStatusCallback.  BSC loses all references are
    // deletes its reference to us, so we have no more references &
    // this invokes our destructor which cleans up by closing handles,
    // then do returns on stack to calling point.

    // we should be implicitly history at this point.

    DEBUG_LEAVE(0);
}


STDMETHODIMP CActiveSetupBinding::Suspend(void)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CActiveSetupBinding::IBinding::Suspend",
                "this=%#x",
                this
                ));
                
    HRESULT hr = S_OK;
    DWORD dwSize;
    HKEY hKey = 0;

    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGKEY_ACTIVESETUP, 0, KEY_ALL_ACCESS, &hKey) == ERROR_SUCCESS)
    {
        hr = RegSetValueEx(hKey, szControlSetup, 0, REG_DWORD, (LPBYTE)&dwStatusSuspend, sizeof(DWORD));

        ::RegCloseKey(hKey);
    }
    
    DEBUG_LEAVE(hr);
    return hr;
}

STDMETHODIMP CActiveSetupBinding::Resume(void)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CActiveSetupBinding::IBinding::Resume",
                "this=%#x",
                this
                ));
                
    HRESULT hr = S_OK;
    DWORD dwSize;
    HKEY hKey = 0;

    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGKEY_ACTIVESETUP, 0, KEY_ALL_ACCESS, &hKey) == ERROR_SUCCESS)
    {
        hr = RegSetValueEx(hKey, szControlSetup, 0, REG_DWORD, (LPBYTE)&dwStatusResume, sizeof(DWORD));

        ::RegCloseKey(hKey);
    }
    
    DEBUG_LEAVE(hr);
    return hr;
}

STDMETHODIMP CActiveSetupBinding::SetPriority(LONG nPriority)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CActiveSetupBinding::IBinding::SetPriority",
                "this=%#x, %#x",
                this, nPriority
                ));
    
    DEBUG_LEAVE(E_NOTIMPL);               
    return E_NOTIMPL;
}

STDMETHODIMP CActiveSetupBinding::GetPriority(LONG *pnPriority)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CActiveSetupBinding::IBinding::GetPriority",
                "this=%#x, %#x",
                this, pnPriority
                ));

    DEBUG_LEAVE(E_NOTIMPL);
    return E_NOTIMPL;
}

STDMETHODIMP CActiveSetupBinding::GetBindResult(CLSID *pclsidProtocol, 
                    DWORD *pdwResult, LPWSTR *pszResult,DWORD *pdwReserved)
{
    DEBUG_ENTER((DBG_DOWNLOAD,
                Hresult,
                "CActiveSetupBinding::IBinding::GetBindResult",
                "this=%#x, %#x, %#x, %#x, %#x",
                this, pclsidProtocol, pdwResult, pszResult, pdwReserved
                ));
                
    HRESULT hr = NOERROR;

    if (!pdwResult || !pszResult || pdwReserved)
    {
        hr = E_INVALIDARG;
    }
    else
    {
        *pdwResult = NOERROR;
        *pszResult = NULL;
    }
    
    DEBUG_LEAVE(hr);
    return hr;
}