registration.cpp

// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.

#include "precomp.h"


// constants

const LPCWSTR REGISTRY_RUN_ONCE_KEY = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce";
const LPCWSTR REGISTRY_BUNDLE_DISPLAY_ICON = L"DisplayIcon";
const LPCWSTR REGISTRY_BUNDLE_DISPLAY_VERSION = L"DisplayVersion";
const LPCWSTR REGISTRY_BUNDLE_ESTIMATED_SIZE = L"EstimatedSize";
const LPCWSTR REGISTRY_BUNDLE_INSTALL_DATE = L"InstallDate";
const LPCWSTR REGISTRY_BUNDLE_PUBLISHER = L"Publisher";
const LPCWSTR REGISTRY_BUNDLE_HELP_LINK = L"HelpLink";
const LPCWSTR REGISTRY_BUNDLE_HELP_TELEPHONE = L"HelpTelephone";
const LPCWSTR REGISTRY_BUNDLE_URL_INFO_ABOUT = L"URLInfoAbout";
const LPCWSTR REGISTRY_BUNDLE_URL_UPDATE_INFO = L"URLUpdateInfo";
const LPCWSTR REGISTRY_BUNDLE_PARENT_DISPLAY_NAME = L"ParentDisplayName";
const LPCWSTR REGISTRY_BUNDLE_PARENT_KEY_NAME = L"ParentKeyName";
const LPCWSTR REGISTRY_BUNDLE_COMMENTS = L"Comments";
const LPCWSTR REGISTRY_BUNDLE_CONTACT = L"Contact";
const LPCWSTR REGISTRY_BUNDLE_NO_MODIFY = L"NoModify";
const LPCWSTR REGISTRY_BUNDLE_MODIFY_PATH = L"ModifyPath";
const LPCWSTR REGISTRY_BUNDLE_NO_ELEVATE_ON_MODIFY = L"NoElevateOnModify";
const LPCWSTR REGISTRY_BUNDLE_NO_REMOVE = L"NoRemove";
const LPCWSTR REGISTRY_BUNDLE_SYSTEM_COMPONENT = L"SystemComponent";
const LPCWSTR REGISTRY_BUNDLE_QUIET_UNINSTALL_STRING = L"QuietUninstallString";
const LPCWSTR REGISTRY_BUNDLE_UNINSTALL_STRING = L"UninstallString";
const LPCWSTR REGISTRY_BUNDLE_RESUME_COMMAND_LINE = L"BundleResumeCommandLine";
const LPCWSTR REGISTRY_BUNDLE_VERSION_MAJOR = L"VersionMajor";
const LPCWSTR REGISTRY_BUNDLE_VERSION_MINOR = L"VersionMinor";
const LPCWSTR SWIDTAG_FOLDER = L"swidtag";
const LPCWSTR REGISTRY_BUNDLE_VARIABLE_KEY = L"variables";
const LPCWSTR REGISTRY_BUNDLE_INSTALLED = L"Installed";


// internal function declarations

static HRESULT ParseSoftwareTagsFromXml(
    __in IXMLDOMNode* pixnRegistrationNode,
    __out BURN_SOFTWARE_TAG** prgSoftwareTags,
    __out DWORD* pcSoftwareTags
    );
static HRESULT GetBundleManufacturer(
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_VARIABLES* pVariables,
    __out_z LPWSTR* psczBundleManufacturer
    );
static HRESULT GetBundleInProgressName(
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_VARIABLES* pVariables,
    __out_z LPWSTR* psczBundleName
    );
static HRESULT GetBundleName(
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_VARIABLES* pVariables,
    __out_z LPWSTR* psczBundleName
    );
static HRESULT EnsureRegistrationVariable(
    __in BURN_VARIABLES* pVariables,
    __in_z LPCWSTR wzVariable,
    __in_z LPCWSTR wzDefaultValue,
    __out_z LPWSTR* psczValue
    );
static HRESULT UpdateResumeMode(
    __in BURN_REGISTRATION* pRegistration,
    __in HKEY hkRegistration,
    __in BURN_RESUME_MODE resumeMode,
    __in BOOTSTRAPPER_REGISTRATION_TYPE registrationType,
    __in BOOL fRestartInitiated
    );
static HRESULT FormatUpdateRegistrationKey(
    __in BURN_REGISTRATION* pRegistration,
    __out_z LPWSTR* psczKey
    );
static HRESULT WriteSoftwareTags(
    __in BURN_VARIABLES* pVariables,
    __in BURN_SOFTWARE_TAGS* pSoftwareTags
    );
static HRESULT RemoveSoftwareTags(
    __in BURN_VARIABLES* pVariables,
    __in BURN_SOFTWARE_TAGS* pSoftwareTags
    );
static HRESULT WriteUpdateRegistration(
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_VARIABLES* pVariables
    );
static HRESULT RemoveUpdateRegistration(
    __in BURN_REGISTRATION* pRegistration
    );
static HRESULT RegWriteStringVariable(
    __in HKEY hkKey,
    __in BURN_VARIABLES* pVariables,
    __in LPCWSTR wzVariable,
    __in LPCWSTR wzName
    );
static HRESULT UpdateBundleNameRegistration(
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_VARIABLES* pVariables,
    __in HKEY hkRegistration,
    __in BOOL fInProgressRegistration
    );
static HRESULT UpdateEstimatedSize(
    __in HKEY hkRegistration,
    __in DWORD64 qwEstimatedSize
    );
static BOOL IsWuRebootPending();
static BOOL IsRegistryRebootPending();
static HRESULT RegistrationDetectResumeTypeByHive(
    __in HKEY hkRegistrationRoot,
    __in BURN_REGISTRATION* pRegistration,
    __out BOOTSTRAPPER_RESUME_TYPE* pResumeType
);
static HRESULT DetectInstalled(
    __in BURN_REGISTRATION* pRegistration,
    __in HKEY hkRoot
);

// function definitions

/*******************************************************************
 RegistrationParseFromXml - Parses registration information from manifest.

*******************************************************************/
extern "C" HRESULT RegistrationParseFromXml(
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_CACHE* pCache,
    __in IXMLDOMNode* pixnBundle
    )
{
    HRESULT hr = S_OK;
    IXMLDOMNode* pixnRegistrationNode = NULL;
    IXMLDOMNode* pixnArpNode = NULL;
    IXMLDOMNode* pixnUpdateNode = NULL;
    LPWSTR scz = NULL;
    BOOL fFoundXml = FALSE;

    // select registration node
    hr = XmlSelectSingleNode(pixnBundle, L"Registration", &pixnRegistrationNode);
    ExitOnRequiredXmlQueryFailure(hr, "Failed to select registration node.");

    // @Code
    hr = XmlGetAttributeEx(pixnRegistrationNode, L"Code", &pRegistration->sczCode);
    ExitOnRequiredXmlQueryFailure(hr, "Failed to get @Code.");

    // @Tag
    hr = XmlGetAttributeEx(pixnRegistrationNode, L"Tag", &pRegistration->sczTag);
    ExitOnRequiredXmlQueryFailure(hr, "Failed to get @Tag.");

    // @PrimaryUpgradeCode
    hr = XmlGetAttributeEx(pixnRegistrationNode, L"PrimaryUpgradeCode", &pRegistration->sczPrimaryUpgradeCode);
    ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @PrimaryUpgradeCode.");

    hr = BundlePackageEngineParseRelatedCodes(pixnBundle, &pRegistration->rgsczDetectCodes, &pRegistration->cDetectCodes, &pRegistration->rgsczUpgradeCodes, &pRegistration->cUpgradeCodes, &pRegistration->rgsczAddonCodes, &pRegistration->cAddonCodes, &pRegistration->rgsczPatchCodes, &pRegistration->cPatchCodes);
    ExitOnFailure(hr, "Failed to parse related bundles");

    // @Version
    hr = XmlGetAttributeEx(pixnRegistrationNode, L"Version", &scz);
    ExitOnRequiredXmlQueryFailure(hr, "Failed to get @Version.");

    hr = VerParseVersion(scz, 0, FALSE, &pRegistration->pVersion);
    ExitOnFailure(hr, "Failed to parse @Version: %ls", scz);

    if (pRegistration->pVersion->fInvalid)
    {
        LogId(REPORT_WARNING, MSG_MANIFEST_INVALID_VERSION, scz);
    }

    // @ProviderKey
    hr = XmlGetAttributeEx(pixnRegistrationNode, L"ProviderKey", &pRegistration->sczProviderKey);
    ExitOnRequiredXmlQueryFailure(hr, "Failed to get @ProviderKey.");

    // @ExecutableName
    hr = XmlGetAttributeEx(pixnRegistrationNode, L"ExecutableName", &pRegistration->sczExecutableName);
    ExitOnRequiredXmlQueryFailure(hr, "Failed to get @ExecutableName.");

    // @Scope
    hr = PackageParseScopeFromXml(pixnRegistrationNode, &pRegistration->scope);
    ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @Scope.");

    // select ARP node
    hr = XmlSelectSingleNode(pixnRegistrationNode, L"Arp", &pixnArpNode);
    ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to select ARP node.");

    if (fFoundXml)
    {
        // @DisplayName
        hr = XmlGetAttributeEx(pixnArpNode, L"DisplayName", &pRegistration->sczDisplayName);
        ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @DisplayName.");

        // @InProgressDisplayName
        hr = XmlGetAttributeEx(pixnArpNode, L"InProgressDisplayName", &pRegistration->sczInProgressDisplayName);
        ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @InProgressDisplayName.");

        // @DisplayVersion
        hr = XmlGetAttributeEx(pixnArpNode, L"DisplayVersion", &pRegistration->sczDisplayVersion);
        ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @DisplayVersion.");

        // @Publisher
        hr = XmlGetAttributeEx(pixnArpNode, L"Publisher", &pRegistration->sczPublisher);
        ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @Publisher.");

        // @HelpLink
        hr = XmlGetAttributeEx(pixnArpNode, L"HelpLink", &pRegistration->sczHelpLink);
        ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @HelpLink.");

        // @HelpTelephone
        hr = XmlGetAttributeEx(pixnArpNode, L"HelpTelephone", &pRegistration->sczHelpTelephone);
        ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @HelpTelephone.");

        // @AboutUrl
        hr = XmlGetAttributeEx(pixnArpNode, L"AboutUrl", &pRegistration->sczAboutUrl);
        ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @AboutUrl.");

        // @UpdateUrl
        hr = XmlGetAttributeEx(pixnArpNode, L"UpdateUrl", &pRegistration->sczUpdateUrl);
        ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @UpdateUrl.");

        // @ParentDisplayName
        hr = XmlGetAttributeEx(pixnArpNode, L"ParentDisplayName", &pRegistration->sczParentDisplayName);
        ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @ParentDisplayName.");

        // @Comments
        hr = XmlGetAttributeEx(pixnArpNode, L"Comments", &pRegistration->sczComments);
        ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @Comments.");

        // @Contact
        hr = XmlGetAttributeEx(pixnArpNode, L"Contact", &pRegistration->sczContact);
        ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @Contact.");

        // @DisableModify
        hr = XmlGetAttributeEx(pixnArpNode, L"DisableModify", &scz);
        ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @DisableModify.");

        if (fFoundXml)
        {
            if (CSTR_EQUAL == ::CompareStringOrdinal(scz, -1, L"button", -1, FALSE))
            {
                pRegistration->modify = BURN_REGISTRATION_MODIFY_DISABLE_BUTTON;
            }
            else if (CSTR_EQUAL == ::CompareStringOrdinal(scz, -1, L"yes", -1, FALSE))
            {
                pRegistration->modify = BURN_REGISTRATION_MODIFY_DISABLE;
            }
            else if (CSTR_EQUAL == ::CompareStringOrdinal(scz, -1, L"no", -1, FALSE))
            {
                pRegistration->modify = BURN_REGISTRATION_MODIFY_ENABLED;
            }
            else
            {
                ExitWithRootFailure(hr, E_UNEXPECTED, "Invalid modify disabled type: %ls", scz);
            }
        }
        else
        {
            pRegistration->modify = BURN_REGISTRATION_MODIFY_ENABLED;
        }

        // @DisableRemove
        hr = XmlGetYesNoAttribute(pixnArpNode, L"DisableRemove", &pRegistration->fNoRemove);
        ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @DisableRemove.");
    }

    if (pRegistration->fNoRemove && BURN_REGISTRATION_MODIFY_ENABLED != pRegistration->modify)
    {
        pRegistration->fForceSystemComponent = TRUE;
    }

    hr = ParseSoftwareTagsFromXml(pixnRegistrationNode, &pRegistration->softwareTags.rgSoftwareTags, &pRegistration->softwareTags.cSoftwareTags);
    ExitOnFailure(hr, "Failed to parse software tag.");

    // select Update node
    hr = XmlSelectSingleNode(pixnRegistrationNode, L"Update", &pixnUpdateNode);
    ExitOnOptionalXmlQueryFailure(hr, pRegistration->update.fRegisterUpdate, "Failed to select Update node.");

    if (pRegistration->update.fRegisterUpdate)
    {
        // @Manufacturer
        hr = XmlGetAttributeEx(pixnUpdateNode, L"Manufacturer", &pRegistration->update.sczManufacturer);
        ExitOnRequiredXmlQueryFailure(hr, "Failed to get @Manufacturer.");

        // @Department
        hr = XmlGetAttributeEx(pixnUpdateNode, L"Department", &pRegistration->update.sczDepartment);
        ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @Department.");

        // @ProductFamily
        hr = XmlGetAttributeEx(pixnUpdateNode, L"ProductFamily", &pRegistration->update.sczProductFamily);
        ExitOnOptionalXmlQueryFailure(hr, fFoundXml, "Failed to get @ProductFamily.");

        // @Name
        hr = XmlGetAttributeEx(pixnUpdateNode, L"Name", &pRegistration->update.sczName);
        ExitOnRequiredXmlQueryFailure(hr, "Failed to get @Name.");

        // @Classification
        hr = XmlGetAttributeEx(pixnUpdateNode, L"Classification", &pRegistration->update.sczClassification);
        ExitOnRequiredXmlQueryFailure(hr, "Failed to get @Classification.");
    }

    // Handle the easy case of build-time bundle scope early.
    if (BOOTSTRAPPER_PACKAGE_SCOPE_PER_MACHINE == pRegistration->scope || BOOTSTRAPPER_PACKAGE_SCOPE_PER_USER == pRegistration->scope)
    {
        pRegistration->fPerMachine = BOOTSTRAPPER_PACKAGE_SCOPE_PER_MACHINE == pRegistration->scope;

        hr = RegistrationSetPaths(pRegistration, pCache);
        ExitOnFailure(hr, "Failed to set registration paths for fixed scope.");
    }
    else
    {
        pRegistration->hkRoot = reinterpret_cast<HKEY>(0ull);
    }

    // build uninstall registry key path
    hr = StrAllocFormatted(&pRegistration->sczRegistrationKey, L"%ls\\%ls", BURN_REGISTRATION_REGISTRY_UNINSTALL_KEY, pRegistration->sczCode);
    ExitOnFailure(hr, "Failed to build uninstall registry key path.");

LExit:
    ReleaseObject(pixnRegistrationNode);
    ReleaseObject(pixnArpNode);
    ReleaseObject(pixnUpdateNode);
    ReleaseStr(scz);

    return hr;
}

/*******************************************************************
 RegistrationUninitialize -

*******************************************************************/
extern "C" void RegistrationUninitialize(
    __in BURN_REGISTRATION* pRegistration
    )
{
    ReleaseStr(pRegistration->sczCode);
    ReleaseStr(pRegistration->sczTag);
    ReleaseStr(pRegistration->sczPrimaryUpgradeCode);
    
    for (DWORD i = 0; i < pRegistration->cDetectCodes; ++i)
    {
        ReleaseStr(pRegistration->rgsczDetectCodes[i]);
    }
    ReleaseMem(pRegistration->rgsczDetectCodes);

    for (DWORD i = 0; i < pRegistration->cUpgradeCodes; ++i)
    {
        ReleaseStr(pRegistration->rgsczUpgradeCodes[i]);
    }
    ReleaseMem(pRegistration->rgsczUpgradeCodes);

    for (DWORD i = 0; i < pRegistration->cAddonCodes; ++i)
    {
        ReleaseStr(pRegistration->rgsczAddonCodes[i]);
    }
    ReleaseMem(pRegistration->rgsczAddonCodes);

    for (DWORD i = 0; i < pRegistration->cPatchCodes; ++i)
    {
        ReleaseStr(pRegistration->rgsczPatchCodes[i]);
    }
    ReleaseMem(pRegistration->rgsczPatchCodes);

    ReleaseStr(pRegistration->sczProviderKey);
    ReleaseStr(pRegistration->sczExecutableName);

    ReleaseStr(pRegistration->sczRegistrationKey);
    ReleaseStr(pRegistration->sczCacheExecutablePath);
    ReleaseStr(pRegistration->sczResumeCommandLine);
    ReleaseStr(pRegistration->sczStateFile);

    ReleaseStr(pRegistration->sczDisplayName);
    ReleaseStr(pRegistration->sczInProgressDisplayName);
    ReleaseStr(pRegistration->sczDisplayVersion);
    ReleaseStr(pRegistration->sczPublisher);
    ReleaseStr(pRegistration->sczHelpLink);
    ReleaseStr(pRegistration->sczHelpTelephone);
    ReleaseStr(pRegistration->sczAboutUrl);
    ReleaseStr(pRegistration->sczUpdateUrl);
    ReleaseStr(pRegistration->sczParentDisplayName);
    ReleaseStr(pRegistration->sczComments);
    ReleaseStr(pRegistration->sczContact);

    ReleaseStr(pRegistration->update.sczManufacturer);
    ReleaseStr(pRegistration->update.sczDepartment);
    ReleaseStr(pRegistration->update.sczProductFamily);
    ReleaseStr(pRegistration->update.sczName);
    ReleaseStr(pRegistration->update.sczClassification);

    if (pRegistration->softwareTags.rgSoftwareTags)
    {
        for (DWORD i = 0; i < pRegistration->softwareTags.cSoftwareTags; ++i)
        {
            ReleaseStr(pRegistration->softwareTags.rgSoftwareTags[i].sczFilename);
            ReleaseStr(pRegistration->softwareTags.rgSoftwareTags[i].sczRegid);
            ReleaseStr(pRegistration->softwareTags.rgSoftwareTags[i].sczPath);
            ReleaseStr(pRegistration->softwareTags.rgSoftwareTags[i].sczTag);
        }

        MemFree(pRegistration->softwareTags.rgSoftwareTags);
    }

    ReleaseStr(pRegistration->sczDetectedProviderKeyBundleCode);
    ReleaseStr(pRegistration->sczBundlePackageAncestors);
    RelatedBundlesUninitialize(&pRegistration->relatedBundles);

    if (pRegistration->rgDependents)
    {
        ReleaseDependencyArray(pRegistration->rgDependents, pRegistration->cDependents);
    }
    // clear struct
    memset(pRegistration, 0, sizeof(BURN_REGISTRATION));
}

/*******************************************************************
 RegistrationSetVariables - Initializes bundle variables that map to
                            registration entities.

*******************************************************************/
extern "C" HRESULT RegistrationSetVariables(
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_VARIABLES* pVariables
    )
{
    HRESULT hr = S_OK;
    LPWSTR scz = NULL;

    // Ensure the registration bundle name is updated.
    hr = GetBundleInProgressName(pRegistration, pVariables, &scz);
    ExitOnFailure(hr, "Failed to initialize bundle name.");

    hr = GetBundleName(pRegistration, pVariables, &scz);
    ExitOnFailure(hr, "Failed to initialize bundle name.");

    hr = GetBundleManufacturer(pRegistration, pVariables, &scz);
    ExitOnFailure(hr, "Failed to initialize bundle manufacturer.");

    hr = VariableSetString(pVariables, BURN_BUNDLE_PROVIDER_KEY, pRegistration->sczProviderKey, TRUE, FALSE);
    ExitOnFailure(hr, "Failed to overwrite the bundle provider key built-in variable.");

    hr = VariableSetString(pVariables, BURN_BUNDLE_TAG, pRegistration->sczTag, TRUE, FALSE);
    ExitOnFailure(hr, "Failed to overwrite the bundle tag built-in variable.");

    hr = VariableSetVersion(pVariables, BURN_BUNDLE_VERSION, pRegistration->pVersion, TRUE);
    ExitOnFailure(hr, "Failed to overwrite the bundle version built-in variable.");

    hr = VariableSetNumeric(pVariables, BURN_BUNDLE_AUTHORED_SCOPE, pRegistration->scope, TRUE);
    ExitOnFailure(hr, "Failed to set the bundle authored scope built-in variable.");

LExit:
    ReleaseStr(scz);

    return hr;
}

/*******************************************************************
 RegistrationSetDynamicVariables - Initializes bundle variables that
     map to registration entities that can change during execution.

*******************************************************************/
extern "C" HRESULT RegistrationSetDynamicVariables(
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_VARIABLES* pVariables
    )
{
    HRESULT hr = S_OK;
    LONGLONG llInstalled = 0;

    // Detect if bundle is already installed.
    hr = RegistrationDetectInstalled(pRegistration);
    ExitOnFailure(hr, "Failed to detect bundle install state.");

    llInstalled = BOOTSTRAPPER_REGISTRATION_TYPE_FULL == pRegistration->detectedRegistrationType ? 1 : 0;

    hr = VariableSetNumeric(pVariables, BURN_BUNDLE_INSTALLED, llInstalled, TRUE);
    ExitOnFailure(hr, "Failed to set the bundle installed built-in variable.");

    hr = VariableSetNumeric(pVariables, BURN_BUNDLE_DETECTED_SCOPE, pRegistration->detectedScope, TRUE);
    ExitOnFailure(hr, "Failed to set the bundle detected scope built-in variable.");

    hr = VariableSetNumeric(pVariables, VARIABLE_REBOOTPENDING, IsWuRebootPending() || IsRegistryRebootPending(), TRUE);
    ExitOnFailure(hr, "Failed to overwrite the bundle reboot-pending built-in variable.");

LExit:
    return hr;
}

extern "C" HRESULT RegistrationDetectInstalled(
    __in BURN_REGISTRATION* pRegistration
)
{
    HRESULT hr = S_OK;

    if (pRegistration->hkRoot)
    {
        hr = DetectInstalled(pRegistration, pRegistration->hkRoot);
    }
    else
    {
        // For PUOM/PMOU bundles, check per-machine then fall back to per-user.
        hr = DetectInstalled(pRegistration, HKEY_LOCAL_MACHINE);

        if (FAILED(hr))
        {
            hr = DetectInstalled(pRegistration, HKEY_CURRENT_USER);
        }
    }

//LExit:
    // Not finding the key or value is okay.
    if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)
    {
        hr = S_OK;
    }

    return hr;
}

/*******************************************************************
 RegistrationDetectResumeMode - Detects registration information on the system
                                to determine if a resume is taking place.

*******************************************************************/
extern "C" HRESULT RegistrationDetectResumeType(
    __in BURN_REGISTRATION* pRegistration,
    __out BOOTSTRAPPER_RESUME_TYPE* pResumeType
)
{
    HRESULT hr = S_OK;

    if (pRegistration->hkRoot)
    {
        hr = RegistrationDetectResumeTypeByHive(pRegistration->hkRoot, pRegistration, pResumeType);
    }
    else
    {
        hr = RegistrationDetectResumeTypeByHive(HKEY_LOCAL_MACHINE, pRegistration, pResumeType);

        if (BOOTSTRAPPER_RESUME_TYPE_NONE == *pResumeType)
        {
            hr = RegistrationDetectResumeTypeByHive(HKEY_CURRENT_USER, pRegistration, pResumeType);
        }
    }
    ExitOnFailure(hr, "Failed to find bundle registration: %ls", pRegistration->sczRegistrationKey);

LExit:
    return hr;
}

/*******************************************************************
 RegistrationDetectRelatedBundles - finds the bundles with same
  upgrade/detect/addon/patch codes.

*******************************************************************/
extern "C" HRESULT RegistrationDetectRelatedBundles(
    __in BURN_REGISTRATION* pRegistration
    )
{
    HRESULT hr = S_OK;

    hr = RelatedBundlesInitializeForScope(TRUE, pRegistration, &pRegistration->relatedBundles);
    ExitOnFailure(hr, "Failed to initialize per-machine related bundles.");

    hr = RelatedBundlesInitializeForScope(FALSE, pRegistration, &pRegistration->relatedBundles);
    ExitOnFailure(hr, "Failed to initialize per-user related bundles.");

    RelatedBundlesSortDetect(&pRegistration->relatedBundles);

LExit:
    return hr;
}

extern "C" HRESULT RegistrationPlanInitialize(
    __in BURN_REGISTRATION* pRegistration
    )
{
    HRESULT hr = S_OK;

    if (pRegistration->relatedBundles.cRelatedBundles && !pRegistration->relatedBundles.rgpPlanSortedRelatedBundles)
    {
        hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pRegistration->relatedBundles.rgpPlanSortedRelatedBundles), pRegistration->relatedBundles.cRelatedBundles, sizeof(BURN_RELATED_BUNDLE*), 5);
        ExitOnFailure(hr, "Failed to initialize plan related bundles array.");

        for (DWORD i = 0; i < pRegistration->relatedBundles.cRelatedBundles; ++i)
        {
            pRegistration->relatedBundles.rgpPlanSortedRelatedBundles[i] = pRegistration->relatedBundles.rgRelatedBundles + i;
        }
    }

LExit:
    return hr;
}

/*******************************************************************
 RegistrationSessionBegin - Registers a run session on the system.

*******************************************************************/
extern "C" HRESULT RegistrationSessionBegin(
    __in_z LPCWSTR wzEngineWorkingPath,
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_CACHE* pCache,
    __in BURN_VARIABLES* pVariables,
    __in DWORD dwRegistrationOptions,
    __in DWORD64 qwEstimatedSize,
    __in BOOTSTRAPPER_REGISTRATION_TYPE registrationType
    )
{
    HRESULT hr = S_OK;
    HKEY hkRegistration = NULL;
    BOOL fCreated = FALSE;
    LPWSTR sczPublisher = NULL;
    SYSTEMTIME systime = { };
    DWORD er = ERROR_SUCCESS;

    AssertSz(BOOTSTRAPPER_REGISTRATION_TYPE_NONE != registrationType, "Registration type can't be NONE");

    LogId(REPORT_VERBOSE, MSG_SESSION_BEGIN, pRegistration->sczRegistrationKey, LoggingInstallScopeToString(pRegistration->fPerMachine), dwRegistrationOptions, LoggingBoolToString(pRegistration->fDisableResume));

    // Cache bundle executable.
    if (dwRegistrationOptions & BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE)
    {
        hr = CacheCompleteBundle(pCache, pRegistration->fPerMachine, pRegistration->sczExecutableName, pRegistration->sczCode, wzEngineWorkingPath
#ifdef DEBUG
                        , pRegistration->sczCacheExecutablePath
#endif
                        );
        ExitOnFailure(hr, "Failed to cache bundle from path: %ls", wzEngineWorkingPath);
    }

    // create registration key
    hr = RegCreateEx(pRegistration->hkRoot, pRegistration->sczRegistrationKey, KEY_WRITE, REG_KEY_DEFAULT, FALSE, NULL, &hkRegistration, &fCreated);
    ExitOnFailure(hr, "Failed to create registration key.");

    // Write any ARP values and software tags.
    hr = RegWriteString(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_CACHE_PATH, pRegistration->sczCacheExecutablePath);
    ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_CACHE_PATH);

    hr = RegWriteStringArray(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_UPGRADE_CODE, pRegistration->rgsczUpgradeCodes, pRegistration->cUpgradeCodes);
    ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_UPGRADE_CODE);

    hr = RegWriteStringArray(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_ADDON_CODE, pRegistration->rgsczAddonCodes, pRegistration->cAddonCodes);
    ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_ADDON_CODE);

    hr = RegWriteStringArray(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_DETECT_CODE, pRegistration->rgsczDetectCodes, pRegistration->cDetectCodes);
    ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_DETECT_CODE);

    hr = RegWriteStringArray(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_PATCH_CODE, pRegistration->rgsczPatchCodes, pRegistration->cPatchCodes);
    ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_PATCH_CODE);

    hr = RegWriteString(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_VERSION, pRegistration->pVersion->sczVersion);
    ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_VERSION);

    hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_VERSION_MAJOR, pRegistration->pVersion->dwMajor);
    ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_VERSION_MAJOR);

    hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_VERSION_MINOR, pRegistration->pVersion->dwMinor);
    ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_VERSION_MINOR);

    if (pRegistration->sczProviderKey)
    {
        hr = RegWriteString(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_PROVIDER_KEY, pRegistration->sczProviderKey);
        ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_PROVIDER_KEY);
    }

    if (pRegistration->sczTag)
    {
        hr = RegWriteString(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_TAG, pRegistration->sczTag);
        ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_TAG);
    }

    hr = RegWriteStringFormatted(hkRegistration, BURN_REGISTRATION_REGISTRY_ENGINE_VERSION, L"%hs", szVerMajorMinorBuild);
    ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_ENGINE_VERSION);

    hr = RegWriteNumber(hkRegistration, BURN_REGISTRATION_REGISTRY_ENGINE_PROTOCOL_VERSION, BURN_PROTOCOL_VERSION);
    ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_ENGINE_PROTOCOL_VERSION);

    // DisplayIcon: [path to exe] and ",0" to refer to the first icon in the executable.
    hr = RegWriteStringFormatted(hkRegistration, REGISTRY_BUNDLE_DISPLAY_ICON, L"%s,0", pRegistration->sczCacheExecutablePath);
    ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_DISPLAY_ICON);

    hr = RegWriteNumber(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_SCOPE, pRegistration->fPerMachine ? BOOTSTRAPPER_SCOPE_PER_MACHINE : BOOTSTRAPPER_SCOPE_PER_USER);
    ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_SCOPE);

    // update display name
    hr = UpdateBundleNameRegistration(pRegistration, pVariables, hkRegistration, BOOTSTRAPPER_REGISTRATION_TYPE_INPROGRESS == registrationType);
    ExitOnFailure(hr, "Failed to update name and publisher.");

    // DisplayVersion: provided by UI
    if (pRegistration->sczDisplayVersion)
    {
        hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_DISPLAY_VERSION, pRegistration->sczDisplayVersion);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_DISPLAY_VERSION);
    }

    // Publisher: provided by UI
    hr = GetBundleManufacturer(pRegistration, pVariables, &sczPublisher);
    hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_PUBLISHER, SUCCEEDED(hr) ? sczPublisher : pRegistration->sczPublisher);
    ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_PUBLISHER);

    // HelpLink: provided by UI
    if (pRegistration->sczHelpLink)
    {
        hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_HELP_LINK, pRegistration->sczHelpLink);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_HELP_LINK);
    }

    // HelpTelephone: provided by UI
    if (pRegistration->sczHelpTelephone)
    {
        hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_HELP_TELEPHONE, pRegistration->sczHelpTelephone);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_HELP_TELEPHONE);
    }

    // URLInfoAbout, provided by UI
    if (pRegistration->sczAboutUrl)
    {
        hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_URL_INFO_ABOUT, pRegistration->sczAboutUrl);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_URL_INFO_ABOUT);
    }

    // URLUpdateInfo, provided by UI
    if (pRegistration->sczUpdateUrl)
    {
        hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_URL_UPDATE_INFO, pRegistration->sczUpdateUrl);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_URL_UPDATE_INFO);
    }

    // ParentDisplayName
    if (pRegistration->sczParentDisplayName)
    {
        hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_PARENT_DISPLAY_NAME, pRegistration->sczParentDisplayName);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_PARENT_DISPLAY_NAME);

        // Need to write the ParentKeyName but can be set to anything.
        hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_PARENT_KEY_NAME, pRegistration->sczParentDisplayName);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_PARENT_KEY_NAME);
    }

    // Comments, provided by UI
    if (pRegistration->sczComments)
    {
        hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_COMMENTS, pRegistration->sczComments);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_COMMENTS);
    }

    // Contact, provided by UI
    if (pRegistration->sczContact)
    {
        hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_CONTACT, pRegistration->sczContact);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_CONTACT);
    }

    // InstallLocation: provided by UI
    // TODO: need to figure out what "InstallLocation" means in a chainer. <smile/>

    // NoModify
    if (BURN_REGISTRATION_MODIFY_DISABLE == pRegistration->modify)
    {
        hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_NO_MODIFY, 1);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_NO_MODIFY);
    }
    else if (BURN_REGISTRATION_MODIFY_DISABLE_BUTTON != pRegistration->modify) // if support modify (aka: did not disable anything)
    {
        // ModifyPath: [path to exe] /modify
        hr = RegWriteStringFormatted(hkRegistration, REGISTRY_BUNDLE_MODIFY_PATH, L"\"%ls\" /modify", pRegistration->sczCacheExecutablePath);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_MODIFY_PATH);

        // NoElevateOnModify: 1
        hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_NO_ELEVATE_ON_MODIFY, 1);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_NO_ELEVATE_ON_MODIFY);
    }

    // NoRemove: should this be allowed?
    if (pRegistration->fNoRemove)
    {
        hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_NO_REMOVE, 1);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_NO_REMOVE);
    }

    // Conditionally hide the ARP entry.
    if (pRegistration->fForceSystemComponent || (dwRegistrationOptions & BURN_REGISTRATION_ACTION_OPERATIONS_ARP_SYSTEM_COMPONENT))
    {
        hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_SYSTEM_COMPONENT, 1);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_SYSTEM_COMPONENT);
    }
    else
    {
        er = ::RegDeleteValueW(hkRegistration, REGISTRY_BUNDLE_SYSTEM_COMPONENT);
        if (ERROR_FILE_NOT_FOUND == er || ERROR_PATH_NOT_FOUND == er)
        {
            er = ERROR_SUCCESS;
        }
        ExitOnWin32Error(er, hr, "Failed to delete %ls value.", REGISTRY_BUNDLE_SYSTEM_COMPONENT);
    }

    // QuietUninstallString: [path to exe] /uninstall /quiet
    hr = RegWriteStringFormatted(hkRegistration, REGISTRY_BUNDLE_QUIET_UNINSTALL_STRING, L"\"%ls\" /uninstall /quiet", pRegistration->sczCacheExecutablePath);
    ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_QUIET_UNINSTALL_STRING);

    // UninstallString, [path to exe]
    // If the modify button is to be disabled, we'll add "/modify" to the uninstall string because the button is "Uninstall/Change". Otherwise,
    // it's just the "Uninstall" button so we add "/uninstall" to make the program just go away.
    LPCWSTR wzUninstallParameters = (BURN_REGISTRATION_MODIFY_DISABLE_BUTTON == pRegistration->modify) ? L"/modify" : L" /uninstall";
    hr = RegWriteStringFormatted(hkRegistration, REGISTRY_BUNDLE_UNINSTALL_STRING, L"\"%ls\" %ls", pRegistration->sczCacheExecutablePath, wzUninstallParameters);
    ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_UNINSTALL_STRING);

    if (pRegistration->softwareTags.cSoftwareTags)
    {
        hr = WriteSoftwareTags(pVariables, &pRegistration->softwareTags);
        ExitOnFailure(hr, "Failed to write software tags.");
    }

    // Only set install date and initial estimated size here for the first time.
    // Estimated size will always get updated at the end of the session.
    if (fCreated)
    {
        // Write the install date.
        ::GetLocalTime(&systime);

        hr = RegWriteStringFormatted(hkRegistration, REGISTRY_BUNDLE_INSTALL_DATE, L"%04u%02u%02u", systime.wYear, systime.wMonth, systime.wDay);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_INSTALL_DATE);

        // Write the initial estimated size.
        hr = UpdateEstimatedSize(hkRegistration, qwEstimatedSize);
        ExitOnFailure(hr, "Failed to update estimated size.");
    }

    // Register the bundle dependency key.
    if (dwRegistrationOptions & BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY)
    {
        hr = DependencyRegisterBundle(pRegistration);
        ExitOnFailure(hr, "Failed to register the bundle dependency key.");
    }

    // update resume mode
    hr = UpdateResumeMode(pRegistration, hkRegistration, BURN_RESUME_MODE_ACTIVE, registrationType, FALSE);
    ExitOnFailure(hr, "Failed to update resume mode.");

LExit:
    ReleaseStr(sczPublisher);
    ReleaseRegKey(hkRegistration);

    return hr;
}


/*******************************************************************
 RegistrationSessionEnd - Unregisters a run session from the system.

 *******************************************************************/
extern "C" HRESULT RegistrationSessionEnd(
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_CACHE* pCache,
    __in BURN_VARIABLES* pVariables,
    __in BURN_PACKAGES* pPackages,
    __in BURN_RESUME_MODE resumeMode,
    __in BOOTSTRAPPER_APPLY_RESTART restart,
    __in DWORD64 qwEstimatedSize,
    __in BOOTSTRAPPER_REGISTRATION_TYPE registrationType
    )
{
    HRESULT hr = S_OK;
    HKEY hkRegistration = NULL;
    BOOL fDeleted = FALSE;

    // If no resume mode, then remove the bundle registration.
    if (BURN_RESUME_MODE_NONE == resumeMode)
    {
        AssertSz(BOOTSTRAPPER_REGISTRATION_TYPE_NONE == registrationType, "Registration type must be NONE if resume mode is NONE");

        // Remove the bundle dependencies.
        DependencyUnregisterBundle(pRegistration, pPackages);

        // Delete update registration key.
        if (pRegistration->update.fRegisterUpdate)
        {
            RemoveUpdateRegistration(pRegistration);
        }

        RemoveSoftwareTags(pVariables, &pRegistration->softwareTags);

        // Delete registration key.
        hr = RegDelete(pRegistration->hkRoot, pRegistration->sczRegistrationKey, REG_KEY_DEFAULT, TRUE);
        ExitOnPathFailure(hr, fDeleted, "Failed to delete registration key: %ls", pRegistration->sczRegistrationKey);

        CacheRemoveBundle(pCache, pRegistration->fPerMachine, pRegistration->sczCode);
    }
    else // the mode needs to be updated so open the registration key.
    {
        AssertSz(BOOTSTRAPPER_REGISTRATION_TYPE_NONE != registrationType, "Registration type must not be NONE if resume mode is not NONE");

        // Open registration key.
        hr = RegOpen(pRegistration->hkRoot, pRegistration->sczRegistrationKey, KEY_WRITE, &hkRegistration);
        ExitOnFailure(hr, "Failed to open registration key for ending session.");

        // update display name
        hr = UpdateBundleNameRegistration(pRegistration, pVariables, hkRegistration, BOOTSTRAPPER_REGISTRATION_TYPE_INPROGRESS == registrationType);
        ExitOnFailure(hr, "Failed to update name and publisher.");

        hr = UpdateEstimatedSize(hkRegistration, qwEstimatedSize);
        ExitOnFailure(hr, "Failed to update estimated size.");

        // Update registration.
        if (pRegistration->update.fRegisterUpdate)
        {
            hr = WriteUpdateRegistration(pRegistration, pVariables);
            ExitOnFailure(hr, "Failed to write update registration.");
        }
    }

    // Update resume mode.
    hr = UpdateResumeMode(pRegistration, hkRegistration, resumeMode, registrationType, BOOTSTRAPPER_APPLY_RESTART_INITIATED == restart);
    ExitOnFailure(hr, "Failed to update resume mode.");

LExit:
    ReleaseRegKey(hkRegistration);

    return hr;
}

/*******************************************************************
 RegistrationSaveState - Saves an engine state BLOB for retreval after a resume.

*******************************************************************/
extern "C" HRESULT RegistrationSaveState(
    __in BURN_REGISTRATION* pRegistration,
    __in_bcount(cbBuffer) BYTE* pbBuffer,
    __in SIZE_T cbBuffer
    )
{
    HRESULT hr = S_OK;
    BURN_VARIABLES variables = { };
    SIZE_T iBuffer_Unused = 0;
    HKEY hkRegistration = NULL;
    LPWSTR sczVariableKey = NULL;
    LPWSTR sczVariableValue = NULL;
    LPWSTR sczValueName = NULL;
    DWORD dwType = 0;
    DWORD dwNumberOfExistingValues = 0;
    DWORD er = ERROR_SUCCESS;


    // write data to file
    hr = FileWrite(pRegistration->sczStateFile, FILE_ATTRIBUTE_NORMAL, pbBuffer, cbBuffer, NULL);
    if (E_PATHNOTFOUND == hr)
    {
        // TODO: should we log that the bundle's cache folder was not present so the state file wasn't created either?
        hr = S_OK;
    }
    ExitOnFailure(hr, "Failed to write state to file: %ls", pRegistration->sczStateFile);

    ::InitializeCriticalSection(&variables.csAccess);

    hr = VariableDeserialize(&variables, TRUE, pbBuffer, cbBuffer, &iBuffer_Unused);
    ExitOnFailure(hr, "Failed to read variables.");

    // build variable registry key path
    hr = StrAllocFormatted(&sczVariableKey, L"%s\\%s", pRegistration->sczRegistrationKey, REGISTRY_BUNDLE_VARIABLE_KEY);
    ExitOnFailure(hr, "Failed to build variable registry key path.");

    // open registration variable key
    hr = RegCreate(pRegistration->hkRoot, sczVariableKey, KEY_WRITE | KEY_QUERY_VALUE, &hkRegistration);
    ExitOnFailure(hr, "Failed to create registration variable key.");

    hr = RegQueryInfoKey(hkRegistration, 0, 0, 0, 0, 0, 0, &dwNumberOfExistingValues, 0, 0, 0, 0);
    ExitOnFailure(hr, "Failed to query registration variable count.");

    for (DWORD i = dwNumberOfExistingValues; i >= 0; --i)
    {
        hr = RegValueEnum(hkRegistration, i, &sczValueName, &dwType);

        if (E_NOMOREITEMS == hr)
        {
            hr = S_OK;
            break;
        }

        ExitOnFailure(hr, "Failed to enumerate value %u", i);

        er = ::RegDeleteValueW(hkRegistration, sczValueName);
        if (ERROR_FILE_NOT_FOUND != er)
        {
            ExitOnWin32Error(er, hr, "Failed to delete registration variable value.");
        }
    }

    // Write variables.
    for (DWORD i = 0; i < variables.cVariables; ++i)
    {
        BURN_VARIABLE* pVariable = &variables.rgVariables[i];

        // Write variable value.
        switch (pVariable->Value.Type)
        {
        case BURN_VARIANT_TYPE_NONE:
            hr = RegWriteNone(hkRegistration, pVariable->sczName);
            ExitOnFailure(hr, "Failed to set variable value.");
            break;
        case BURN_VARIANT_TYPE_NUMERIC: __fallthrough;
        case BURN_VARIANT_TYPE_VERSION: __fallthrough;
        case BURN_VARIANT_TYPE_FORMATTED: __fallthrough;
        case BURN_VARIANT_TYPE_STRING:
            hr = BVariantGetString(&pVariable->Value, &sczVariableValue);
            ExitOnFailure(hr, "Failed to get variable value.");

            hr = RegWriteString(hkRegistration, pVariable->sczName, sczVariableValue);
            ExitOnFailure(hr, "Failed to set variable value.");

            ReleaseNullStrSecure(sczVariableValue);

            break;
        default:
            hr = E_INVALIDARG;
            ExitOnFailure(hr, "Unsupported variable type.");
        }

    }
LExit:
    VariablesUninitialize(&variables);
    ReleaseStr(sczValueName);
    ReleaseStr(sczVariableValue);
    ReleaseStr(sczVariableKey);
    ReleaseRegKey(hkRegistration);

    return hr;
}

/*******************************************************************
 RegistrationLoadState - Loads a previously stored engine state BLOB.

*******************************************************************/
extern "C" HRESULT RegistrationLoadState(
    __in BURN_REGISTRATION* pRegistration,
    __out_bcount(*pcbBuffer) BYTE** ppbBuffer,
    __out SIZE_T* pcbBuffer
    )
{
    // read data from file
    HRESULT hr = FileRead(ppbBuffer, pcbBuffer, pRegistration->sczStateFile);
    return hr;
}

/*******************************************************************
RegistrationGetResumeCommandLine - Gets the resume command line from the registry

*******************************************************************/
extern "C" HRESULT RegistrationGetResumeCommandLine(
    __in const BURN_REGISTRATION* pRegistration,
    __deref_out_z LPWSTR* psczResumeCommandLine
    )
{
    HRESULT hr = S_OK;
    HKEY hkRegistration = NULL;

    // open registration key
    hr = RegOpen(pRegistration->hkRoot, pRegistration->sczRegistrationKey, KEY_QUERY_VALUE, &hkRegistration);
    if (SUCCEEDED(hr))
    {
        hr = RegReadString(hkRegistration, REGISTRY_BUNDLE_RESUME_COMMAND_LINE, psczResumeCommandLine);
    }

    // Not finding the key or value is okay.
    if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)
    {
        hr = S_OK;
    }

    ReleaseRegKey(hkRegistration);

    return hr;
}

extern "C" HRESULT RegistrationSetPaths(
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_CACHE* pCache
    )
{
    HRESULT hr = S_OK;
    LPWSTR sczCacheDirectory = NULL;

    // save registration key root
    pRegistration->hkRoot = pRegistration->fPerMachine ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;

    // build cache directory
    hr = CacheGetCompletedPath(pCache, pRegistration->fPerMachine, pRegistration->sczCode, &sczCacheDirectory);
    ExitOnFailure(hr, "Failed to build cache directory.");

    // build cached executable path
    hr = PathConcatRelativeToFullyQualifiedBase(sczCacheDirectory, pRegistration->sczExecutableName, &pRegistration->sczCacheExecutablePath);
    ExitOnFailure(hr, "Failed to build cached executable path.");

    // build state file path
    hr = StrAllocFormatted(&pRegistration->sczStateFile, L"%ls\\state.rsm", sczCacheDirectory);
    ExitOnFailure(hr, "Failed to build state file path.");

LExit:
    ReleaseStr(sczCacheDirectory);

    return hr;
}


// internal helper functions

static HRESULT ParseSoftwareTagsFromXml(
    __in IXMLDOMNode* pixnRegistrationNode,
    __out BURN_SOFTWARE_TAG** prgSoftwareTags,
    __out DWORD* pcSoftwareTags
    )
{
    HRESULT hr = S_OK;
    IXMLDOMNodeList* pixnNodes = NULL;
    IXMLDOMNode* pixnNode = NULL;
    DWORD cNodes = 0;

    BURN_SOFTWARE_TAG* pSoftwareTags = NULL;
    BSTR bstrTagXml = NULL;

    // select tag nodes
    hr = XmlSelectNodes(pixnRegistrationNode, L"SoftwareTag", &pixnNodes);
    ExitOnFailure(hr, "Failed to select software tag nodes.");

    // get tag node count
    hr = pixnNodes->get_length((long*)&cNodes);
    ExitOnFailure(hr, "Failed to get software tag count.");

    if (cNodes)
    {
        pSoftwareTags = (BURN_SOFTWARE_TAG*)MemAlloc(sizeof(BURN_SOFTWARE_TAG) * cNodes, TRUE);
        ExitOnNull(pSoftwareTags, hr, E_OUTOFMEMORY, "Failed to allocate memory for software tag structs.");

        for (DWORD i = 0; i < cNodes; ++i)
        {
            BURN_SOFTWARE_TAG* pSoftwareTag = &pSoftwareTags[i];

            hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
            ExitOnRequiredXmlQueryFailure(hr, "Failed to get next node.");

            hr = XmlGetAttributeEx(pixnNode, L"Filename", &pSoftwareTag->sczFilename);
            ExitOnRequiredXmlQueryFailure(hr, "Failed to get @Filename.");

            hr = XmlGetAttributeEx(pixnNode, L"Regid", &pSoftwareTag->sczRegid);
            ExitOnRequiredXmlQueryFailure(hr, "Failed to get @Regid.");

            hr = XmlGetAttributeEx(pixnNode, L"Path", &pSoftwareTag->sczPath);
            ExitOnRequiredXmlQueryFailure(hr, "Failed to get @Path.");

            hr = XmlGetText(pixnNode, &bstrTagXml);
            ExitOnRequiredXmlQueryFailure(hr, "Failed to get SoftwareTag text.");

            hr = StrAnsiAllocString(&pSoftwareTag->sczTag, bstrTagXml, 0, CP_UTF8);
            ExitOnFailure(hr, "Failed to convert SoftwareTag text to UTF-8");

            // prepare next iteration
            ReleaseNullBSTR(bstrTagXml);
            ReleaseNullObject(pixnNode);
        }
    }

    *pcSoftwareTags = cNodes;
    *prgSoftwareTags = pSoftwareTags;
    pSoftwareTags = NULL;

    hr = S_OK;

LExit:
    ReleaseBSTR(bstrTagXml);
    ReleaseObject(pixnNode);
    ReleaseObject(pixnNodes);
    ReleaseMem(pSoftwareTags);

    return hr;
}

static HRESULT GetBundleManufacturer(
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_VARIABLES* pVariables,
    __out_z LPWSTR* psczBundleManufacturer
    )
{
    HRESULT hr = S_OK;
    LPCWSTR wzPublisher = pRegistration->sczPublisher ? pRegistration->sczPublisher : L"";

    hr = EnsureRegistrationVariable(pVariables, BURN_BUNDLE_MANUFACTURER, wzPublisher, psczBundleManufacturer);
    ExitOnFailure(hr, "Failed to get bundle manufacturer.");

LExit:
    return hr;
}

static HRESULT GetBundleInProgressName(
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_VARIABLES* pVariables,
    __out_z LPWSTR* psczInProgressBundleName
    )
{
    HRESULT hr = S_OK;
    LPCWSTR wzInProgressDisplayName = pRegistration->sczInProgressDisplayName ? pRegistration->sczInProgressDisplayName : L"";

    hr = EnsureRegistrationVariable(pVariables, BURN_BUNDLE_INPROGRESS_NAME, wzInProgressDisplayName, psczInProgressBundleName);
    ExitOnFailure(hr, "Failed to ensure in-progress bundle name.");

LExit:
    return hr;
}

static HRESULT GetBundleName(
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_VARIABLES* pVariables,
    __out_z LPWSTR* psczBundleName
    )
{
    HRESULT hr = S_OK;
    LPCWSTR wzDisplayName = pRegistration->sczDisplayName ? pRegistration->sczDisplayName : L"";

    hr = EnsureRegistrationVariable(pVariables, BURN_BUNDLE_NAME, wzDisplayName, psczBundleName);
    ExitOnFailure(hr, "Failed to ensure bundle name.");

LExit:
    return hr;
}

static HRESULT EnsureRegistrationVariable(
    __in BURN_VARIABLES* pVariables,
    __in_z LPCWSTR wzVariable,
    __in_z LPCWSTR wzDefaultValue,
    __out_z LPWSTR* psczValue
    )
{
    HRESULT hr = S_OK;

    hr = VariableGetString(pVariables, wzVariable, psczValue);
    if (E_NOTFOUND == hr)
    {
        hr = VariableSetString(pVariables, wzVariable, wzDefaultValue, FALSE, FALSE);
        ExitOnFailure(hr, "Failed to set registration variable.");

        hr = StrAllocString(psczValue, wzDefaultValue, 0);
    }
    ExitOnFailure(hr, "Failed to get registration variable.");

LExit:
    return hr;
}

static HRESULT UpdateResumeMode(
    __in BURN_REGISTRATION* pRegistration,
    __in HKEY hkRegistration,
    __in BURN_RESUME_MODE resumeMode,
    __in BOOTSTRAPPER_REGISTRATION_TYPE registrationType,
    __in BOOL fRestartInitiated
    )
{
    HRESULT hr = S_OK;
    DWORD er = ERROR_SUCCESS;
    HKEY hkRun = NULL;
    LPWSTR sczRunOnceCommandLine = NULL;
    LPCWSTR sczResumeKey = REGISTRY_RUN_ONCE_KEY;

    LogId(REPORT_STANDARD, MSG_SESSION_UPDATE, pRegistration->sczRegistrationKey, LoggingInstallScopeToString(pRegistration->fPerMachine), LoggingResumeModeToString(resumeMode), LoggingBoolToString(fRestartInitiated), LoggingBoolToString(pRegistration->fDisableResume));

    // write resume information
    if (hkRegistration)
    {
        // write Resume value
        hr = RegWriteNumber(hkRegistration, L"Resume", (DWORD)resumeMode);
        ExitOnFailure(hr, "Failed to write Resume value.");

        // Write Installed value.
        hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_INSTALLED, BOOTSTRAPPER_REGISTRATION_TYPE_FULL == registrationType ? 1 : 0);
        ExitOnFailure(hr, "Failed to write Installed value.");
    }

    // If the engine is active write the run key so we resume if there is an unexpected
    // power loss. Also, if a restart was initiated in the middle of the chain then
    // ensure the run key exists (it should since going active would have written it).
    // Do not write the run key when embedded since the containing bundle
    // is expected to detect for and restart the embedded bundle.
    if ((BURN_RESUME_MODE_ACTIVE == resumeMode || fRestartInitiated) && !pRegistration->fDisableResume)
    {
        // append RunOnce switch
        hr = StrAllocFormatted(&sczRunOnceCommandLine, L"\"%ls\" /%ls", pRegistration->sczCacheExecutablePath, BURN_COMMANDLINE_SWITCH_RUNONCE);
        ExitOnFailure(hr, "Failed to format resume command line for RunOnce.");

        // write run key
        hr = RegCreate(pRegistration->hkRoot, sczResumeKey, KEY_WRITE, &hkRun);
        ExitOnFailure(hr, "Failed to create run key.");

        hr = RegWriteString(hkRun, pRegistration->sczCode, sczRunOnceCommandLine);
        ExitOnFailure(hr, "Failed to write run key value.");

        hr = RegWriteString(hkRegistration, REGISTRY_BUNDLE_RESUME_COMMAND_LINE, pRegistration->sczResumeCommandLine);
        ExitOnFailure(hr, "Failed to write resume command line value.");
    }
    else // delete run key value
    {
        hr = RegOpen(pRegistration->hkRoot, sczResumeKey, KEY_WRITE, &hkRun);
        if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)
        {
            hr = S_OK;
        }
        else
        {
            ExitOnFailure(hr, "Failed to open run key.");

            er = ::RegDeleteValueW(hkRun, pRegistration->sczCode);
            if (ERROR_FILE_NOT_FOUND == er)
            {
                er = ERROR_SUCCESS;
            }
            ExitOnWin32Error(er, hr, "Failed to delete run key value.");
        }

        if (hkRegistration)
        {
            er = ::RegDeleteValueW(hkRegistration, REGISTRY_BUNDLE_RESUME_COMMAND_LINE);
            if (ERROR_FILE_NOT_FOUND == er)
            {
                er = ERROR_SUCCESS;
            }
            ExitOnWin32Error(er, hr, "Failed to delete resume command line value.");
        }
    }

LExit:
    ReleaseStr(sczRunOnceCommandLine);
    ReleaseRegKey(hkRun);

    return hr;
}

static HRESULT FormatUpdateRegistrationKey(
    __in BURN_REGISTRATION* pRegistration,
    __out_z LPWSTR* psczKey
    )
{
    HRESULT hr = S_OK;
    LPWSTR sczKey = NULL;

    hr = StrAllocFormatted(&sczKey, L"SOFTWARE\\%ls\\Updates\\", pRegistration->update.sczManufacturer);
    ExitOnFailure(hr, "Failed to format the key path for update registration.");

    if (pRegistration->update.sczProductFamily)
    {
        hr = StrAllocFormatted(&sczKey, L"%ls%ls\\", sczKey, pRegistration->update.sczProductFamily);
        ExitOnFailure(hr, "Failed to format the key path for update registration.");
    }

    hr = StrAllocConcat(&sczKey, pRegistration->update.sczName, 0);
    ExitOnFailure(hr, "Failed to format the key path for update registration.");

    *psczKey = sczKey;
    sczKey = NULL;

LExit:
    ReleaseStr(sczKey);

    return hr;
}

static HRESULT WriteSoftwareTags(
    __in BURN_VARIABLES* pVariables,
    __in BURN_SOFTWARE_TAGS* pSoftwareTags
    )
{
    HRESULT hr = S_OK;
    LPWSTR sczRootFolder = NULL;
    LPWSTR sczTagFolder = NULL;
    LPWSTR sczPath = NULL;

    for (DWORD iTag = 0; iTag < pSoftwareTags->cSoftwareTags; ++iTag)
    {
        BURN_SOFTWARE_TAG* pSoftwareTag = pSoftwareTags->rgSoftwareTags + iTag;

        hr = VariableFormatString(pVariables, pSoftwareTag->sczPath, &sczRootFolder, NULL);
        ExitOnFailure(hr, "Failed to format tag folder path.");

        hr = PathConcat(sczRootFolder, SWIDTAG_FOLDER, &sczTagFolder);
        ExitOnFailure(hr, "Failed to allocate regid folder path.");

        hr = PathConcatRelativeToFullyQualifiedBase(sczTagFolder, pSoftwareTag->sczFilename, &sczPath);
        ExitOnFailure(hr, "Failed to allocate regid file path.");

        hr = DirEnsureExists(sczTagFolder, NULL);
        ExitOnFailure(hr, "Failed to create regid folder: %ls", sczTagFolder);

        hr = FileWrite(sczPath, FILE_ATTRIBUTE_NORMAL, reinterpret_cast<LPBYTE>(pSoftwareTag->sczTag), lstrlenA(pSoftwareTag->sczTag), NULL);
        ExitOnFailure(hr, "Failed to write tag xml to file: %ls", sczPath);
    }

LExit:
    ReleaseStr(sczPath);
    ReleaseStr(sczTagFolder);
    ReleaseStr(sczRootFolder);

    return hr;
}

static HRESULT RemoveSoftwareTags(
    __in BURN_VARIABLES* pVariables,
    __in BURN_SOFTWARE_TAGS* pSoftwareTags
    )
{
    HRESULT hr = S_OK;
    LPWSTR sczRootFolder = NULL;
    LPWSTR sczTagFolder = NULL;
    LPWSTR sczPath = NULL;

    for (DWORD iTag = 0; iTag < pSoftwareTags->cSoftwareTags; ++iTag)
    {
        BURN_SOFTWARE_TAG* pSoftwareTag = pSoftwareTags->rgSoftwareTags + iTag;

        hr = VariableFormatString(pVariables, pSoftwareTag->sczPath, &sczRootFolder, NULL);
        ExitOnFailure(hr, "Failed to format tag folder path.");

        hr = PathConcat(sczRootFolder, SWIDTAG_FOLDER, &sczTagFolder);
        ExitOnFailure(hr, "Failed to allocate regid folder path.");

        hr = PathConcatRelativeToFullyQualifiedBase(sczTagFolder, pSoftwareTag->sczFilename, &sczPath);
        ExitOnFailure(hr, "Failed to allocate regid file path.");

        // Best effort to delete the software tag file and the regid folder.
        FileEnsureDelete(sczPath);

        DirDeleteEmptyDirectoriesToRoot(sczTagFolder, 0);
    }

LExit:
    ReleaseStr(sczPath);
    ReleaseStr(sczTagFolder);
    ReleaseStr(sczRootFolder);

    return hr;
}

static HRESULT WriteUpdateRegistration(
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_VARIABLES* pVariables
    )
{
    HRESULT hr = S_OK;
    LPWSTR sczKey = NULL;
    HKEY hkKey = NULL;

    hr = FormatUpdateRegistrationKey(pRegistration, &sczKey);
    ExitOnFailure(hr, "Failed to get the formatted key path for update registration.");

    hr = RegCreate(pRegistration->hkRoot, sczKey, KEY_WRITE, &hkKey);
    ExitOnFailure(hr, "Failed to create the key for update registration.");

    hr = RegWriteString(hkKey, L"ThisVersionInstalled", L"Y");
    ExitOnFailure(hr, "Failed to write %ls value.", L"ThisVersionInstalled");

    hr = RegWriteString(hkKey, L"PackageName", pRegistration->sczDisplayName);
    ExitOnFailure(hr, "Failed to write %ls value.", L"PackageName");

    hr = RegWriteString(hkKey, L"PackageVersion", pRegistration->sczDisplayVersion);
    ExitOnFailure(hr, "Failed to write %ls value.", L"PackageVersion");

    hr = RegWriteString(hkKey, L"Publisher", pRegistration->sczPublisher);
    ExitOnFailure(hr, "Failed to write %ls value.", L"Publisher");

    if (pRegistration->update.sczDepartment)
    {
        hr = RegWriteString(hkKey, L"PublishingGroup", pRegistration->update.sczDepartment);
        ExitOnFailure(hr, "Failed to write %ls value.", L"PublishingGroup");
    }

    hr = RegWriteString(hkKey, L"ReleaseType", pRegistration->update.sczClassification);
    ExitOnFailure(hr, "Failed to write %ls value.", L"ReleaseType");

    hr = RegWriteStringVariable(hkKey, pVariables, VARIABLE_LOGONUSER, L"InstalledBy");
    ExitOnFailure(hr, "Failed to write %ls value.", L"InstalledBy");

    hr = RegWriteStringVariable(hkKey, pVariables, VARIABLE_DATE, L"InstalledDate");
    ExitOnFailure(hr, "Failed to write %ls value.", L"InstalledDate");

    hr = RegWriteStringVariable(hkKey, pVariables, VARIABLE_INSTALLERNAME, L"InstallerName");
    ExitOnFailure(hr, "Failed to write %ls value.", L"InstallerName");

    hr = RegWriteStringVariable(hkKey, pVariables, VARIABLE_INSTALLERVERSION, L"InstallerVersion");
    ExitOnFailure(hr, "Failed to write %ls value.", L"InstallerVersion");

LExit:
    ReleaseRegKey(hkKey);
    ReleaseStr(sczKey);

    return hr;
}

static HRESULT RemoveUpdateRegistration(
    __in BURN_REGISTRATION* pRegistration
    )
{
    HRESULT hr = S_OK;
    LPWSTR sczKey = NULL;
    LPWSTR sczPackageVersion = NULL;
    HKEY hkKey = NULL;
    BOOL fDeleteRegKey = TRUE;
    BOOL fDeleted = FALSE;

    hr = FormatUpdateRegistrationKey(pRegistration, &sczKey);
    ExitOnFailure(hr, "Failed to format key for update registration.");

    // Only delete if the uninstalling bundle's PackageVersion is the same as the
    // PackageVersion in the update registration key.
    // This is to support build to build upgrades
    hr = RegOpen(pRegistration->hkRoot, sczKey, KEY_QUERY_VALUE, &hkKey);
    if (SUCCEEDED(hr))
    {
        hr = RegReadString(hkKey, L"PackageVersion", &sczPackageVersion);
        if (SUCCEEDED(hr))
        {
            if (CSTR_EQUAL != ::CompareStringOrdinal(sczPackageVersion, -1, pRegistration->sczDisplayVersion, -1, FALSE))
            {
                fDeleteRegKey = FALSE;
            }
        }
        ReleaseRegKey(hkKey);
    }

    // Unable to open the key or read the value is okay.
    hr = S_OK;

    if (fDeleteRegKey)
    {
        hr = RegDelete(pRegistration->hkRoot, sczKey, REG_KEY_DEFAULT, FALSE);
        ExitOnPathFailure(hr, fDeleted, "Failed to remove update registration key: %ls", sczKey);
    }

LExit:
    ReleaseStr(sczPackageVersion);
    ReleaseStr(sczKey);

    return hr;
}

static HRESULT RegWriteStringVariable(
    __in HKEY hk,
    __in BURN_VARIABLES* pVariables,
    __in LPCWSTR wzVariable,
    __in LPCWSTR wzName
    )
{
    HRESULT hr = S_OK;
    LPWSTR sczValue = NULL;

    hr = VariableGetString(pVariables, wzVariable, &sczValue);
    ExitOnFailure(hr, "Failed to get the %ls variable.", wzVariable);

    hr = RegWriteString(hk, wzName, sczValue);
    ExitOnFailure(hr, "Failed to write %ls value.", wzName);

LExit:
    StrSecureZeroFreeString(sczValue);

    return hr;
}

static HRESULT UpdateBundleNameRegistration(
    __in BURN_REGISTRATION* pRegistration,
    __in BURN_VARIABLES* pVariables,
    __in HKEY hkRegistration,
    __in BOOL fInProgressRegistration
    )
{
    HRESULT hr = S_OK;
    LPWSTR sczDisplayName = NULL;

    if (fInProgressRegistration)
    {
        hr = GetBundleInProgressName(pRegistration, pVariables, &sczDisplayName);
        ExitOnFailure(hr, "Failed to get bundle in-progress name.");
    }

    if (!sczDisplayName || !*sczDisplayName)
    {
        hr = GetBundleName(pRegistration, pVariables, &sczDisplayName);
        ExitOnFailure(hr, "Failed to get bundle name.");
    }

    hr = RegWriteString(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_DISPLAY_NAME, sczDisplayName);
    ExitOnFailure(hr, "Failed to write %ls value.", BURN_REGISTRATION_REGISTRY_BUNDLE_DISPLAY_NAME);

LExit:
    ReleaseStr(sczDisplayName);

    return hr;
}

static HRESULT UpdateEstimatedSize(
    __in HKEY hkRegistration,
    __in DWORD64 qwEstimatedSize
    )
{
    HRESULT hr = S_OK;
    DWORD dwSize = 0;

    qwEstimatedSize /= 1024; // Convert bytes to KB
    if (0 < qwEstimatedSize)
    {
        if (DWORD_MAX < qwEstimatedSize)
        {
            // ARP doesn't support QWORDs here
            dwSize = DWORD_MAX;
        }
        else
        {
            dwSize = static_cast<DWORD>(qwEstimatedSize);
        }

        hr = RegWriteNumber(hkRegistration, REGISTRY_BUNDLE_ESTIMATED_SIZE, dwSize);
        ExitOnFailure(hr, "Failed to write %ls value.", REGISTRY_BUNDLE_ESTIMATED_SIZE);
    }

LExit:
    return hr;
}

static BOOL IsWuRebootPending()
{
    HRESULT hr = S_OK;
    BOOL fUninitializeCom = FALSE;
    BOOL fRebootPending = FALSE;

    // Do a best effort to ask WU if a reboot is required. If anything goes
    // wrong then let's pretend a reboot is not required.
    hr = ::CoInitialize(NULL);
    fUninitializeCom = SUCCEEDED(hr);
    if (fUninitializeCom || RPC_E_CHANGED_MODE == hr)
    {
        hr = WuaRestartRequired(&fRebootPending);
        if (FAILED(hr))
        {
            fRebootPending = FALSE;
        }

        if (fUninitializeCom)
        {
            ::CoUninitialize();
        }
    }

    return fRebootPending;
}

static BOOL IsRegistryRebootPending()
{
    HRESULT hr = S_OK;
    DWORD dwValue;
    HKEY hk = NULL;
    BOOL fRebootPending = FALSE;

    hr = RegKeyReadNumber(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\ServerManager", L"CurrentRebootAttempts", REG_KEY_DEFAULT, &dwValue);
    fRebootPending = SUCCEEDED(hr) && 0 < dwValue;

    if (!fRebootPending)
    {
        hr = RegKeyReadNumber(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Updates", L"UpdateExeVolatile", REG_KEY_DEFAULT, &dwValue);
        fRebootPending = SUCCEEDED(hr) && 0 < dwValue;

        if (!fRebootPending)
        {
            fRebootPending = RegValueExists(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Component Based Servicing\\RebootPending", NULL, REG_KEY_DEFAULT);

            if (!fRebootPending)
            {
                fRebootPending = RegValueExists(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Component Based Servicing\\RebootInProgress", NULL, REG_KEY_DEFAULT);

                if (!fRebootPending)
                {
                    hr = RegKeyReadNumber(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\WindowsUpdate\\Auto Update", L"AUState", REG_KEY_DEFAULT, &dwValue);
                    fRebootPending = SUCCEEDED(hr) && 8 == dwValue;

                    if (!fRebootPending)
                    {
                        fRebootPending = RegValueExists(HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Control\\Session Manager", L"PendingFileRenameOperations", REG_KEY_DEFAULT);

                        if (!fRebootPending)
                        {
                            fRebootPending = RegValueExists(HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Control\\Session Manager", L"PendingFileRenameOperations2", REG_KEY_DEFAULT);

                            if (!fRebootPending)
                            {
                                hr = RegOpenEx(HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Control\\Session Manager\\FileRenameOperations", KEY_READ, REG_KEY_DEFAULT, &hk);
                                if (SUCCEEDED(hr))
                                {
                                    DWORD cSubKeys = 0;
                                    DWORD cValues = 0;
                                    hr = RegQueryKey(hk, &cSubKeys, &cValues);
                                    fRebootPending = SUCCEEDED(hr) && (0 < cSubKeys || 0 < cValues);
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    ReleaseRegKey(hk);

    return fRebootPending;
}

static HRESULT RegistrationDetectResumeTypeByHive(
    __in HKEY hkRegistrationRoot,
    __in BURN_REGISTRATION* pRegistration,
    __out BOOTSTRAPPER_RESUME_TYPE* pResumeType
)
{
    HRESULT hr = S_OK;
    HKEY hkRegistration = NULL;
    BOOL fExists = FALSE;
    DWORD dwResume = 0;

    *pResumeType = BOOTSTRAPPER_RESUME_TYPE_NONE;

    // open registration key
    hr = RegOpen(hkRegistrationRoot, pRegistration->sczRegistrationKey, KEY_QUERY_VALUE, &hkRegistration);
    ExitOnPathFailure(hr, fExists, "Failed to open registration key.");

    if (!fExists)
    {
        *pResumeType = BOOTSTRAPPER_RESUME_TYPE_NONE;
        ExitFunction();
    }

    // read Resume value
    hr = RegReadNumber(hkRegistration, L"Resume", &dwResume);
    ExitOnPathFailure(hr, fExists, "Failed to read Resume value.");

    if (!fExists)
    {
        *pResumeType = BOOTSTRAPPER_RESUME_TYPE_INVALID;
        ExitFunction();
    }

    switch (dwResume)
    {
    case BURN_RESUME_MODE_ACTIVE:
        // a previous run was interrupted
        *pResumeType = BOOTSTRAPPER_RESUME_TYPE_INTERRUPTED;
        break;

    case BURN_RESUME_MODE_SUSPEND:
        *pResumeType = BOOTSTRAPPER_RESUME_TYPE_SUSPEND;
        break;

    case BURN_RESUME_MODE_ARP:
        *pResumeType = BOOTSTRAPPER_RESUME_TYPE_ARP;
        break;

    case BURN_RESUME_MODE_REBOOT_PENDING:
        // The volatile pending registry doesn't exist (checked above) which means
        // the system was successfully restarted.
        *pResumeType = BOOTSTRAPPER_RESUME_TYPE_REBOOT;
        break;

    default:
        // the value stored in the registry is not valid
        *pResumeType = BOOTSTRAPPER_RESUME_TYPE_INVALID;
        break;
    }

LExit:
    ReleaseRegKey(hkRegistration);

    return hr;
}

static HRESULT DetectInstalled(
    __in BURN_REGISTRATION* pRegistration,
    __in HKEY hkRoot
)
{
    HRESULT hr = S_OK;
    HKEY hkRegistration = NULL;
    DWORD dwInstalled = 0;
    DWORD dwScope = 0;

    pRegistration->fCached = pRegistration->sczCacheExecutablePath && FileExistsEx(pRegistration->sczCacheExecutablePath, NULL);
    pRegistration->detectedRegistrationType = BOOTSTRAPPER_REGISTRATION_TYPE_NONE;
    pRegistration->detectedScope = BOOTSTRAPPER_SCOPE_DEFAULT;

    // open registration key
    hr = RegOpen(hkRoot, pRegistration->sczRegistrationKey, KEY_QUERY_VALUE, &hkRegistration);
    if (SUCCEEDED(hr))
    {
        hr = RegReadNumber(hkRegistration, REGISTRY_BUNDLE_INSTALLED, &dwInstalled);
        ExitOnFailure(hr, "Failed to read registration %ls@%ls.", pRegistration->sczRegistrationKey, REGISTRY_BUNDLE_INSTALLED);

        pRegistration->detectedRegistrationType = (1 == dwInstalled) ? BOOTSTRAPPER_REGISTRATION_TYPE_FULL : BOOTSTRAPPER_REGISTRATION_TYPE_INPROGRESS;

        hr = RegReadNumber(hkRegistration, BURN_REGISTRATION_REGISTRY_BUNDLE_SCOPE, &dwScope);
        ExitOnFailure(hr, "Failed to read registration %ls@%ls.", pRegistration->sczRegistrationKey, BURN_REGISTRATION_REGISTRY_BUNDLE_SCOPE);

        pRegistration->detectedScope = static_cast<BOOTSTRAPPER_SCOPE>(dwScope);
    }

LExit:
    ReleaseRegKey(hkRegistration);

    return hr;
}