自学教程：C++ ExitFunction函数代码示例

BOOL CompareBinding(    __in IAppHostElement* pBinding,    __in LPVOID pContext    ){    BOOL fFound = FALSE;    HRESULT hr = S_OK;    LPWSTR pwzBindingInfo = NULL;    SCA_WEB7* psw = (SCA_WEB7*)pContext;    hr = Iis7GetPropertyString(pBinding, IIS_CONFIG_BINDINGINFO, &pwzBindingInfo);    ExitOnFailure(hr, "Failed to get bindinginfo for binding element");    LPWSTR pwzExists = pwzBindingInfo;    // Break down the address into its constituent parts (IP:Port:Header).    // Taken from IIS6 CA code for compatibility    while (S_OK == hr && *pwzExists)    {        LPCWSTR pwzIPExists = pwzExists;        pwzExists = const_cast<LPWSTR>(wcsstr(pwzIPExists, L":"));        if (NULL == pwzExists)        {            ExitFunction();        }        *pwzExists = L'/0';        LPCWSTR pwzPortExists = pwzExists + 1;        pwzExists = const_cast<LPWSTR>(wcsstr(pwzPortExists, L":"));        if (NULL == pwzExists)        {            ExitFunction();        }        *pwzExists = L'/0';        int iPortExists = wcstol(pwzPortExists, NULL, 10);        LPCWSTR pwzHeaderExists = pwzExists + 1;        BOOL fIpMatches = (0 == lstrcmpW(psw->swaBinding.wzIP, pwzIPExists));   // Explicit IP match        fIpMatches |= (0 == lstrcmpW(psw->swaBinding.wzIP, L"*"));              // Authored * matches any IP        fIpMatches |= ('/0' != psw->swaBinding.wzIP) &&                         // Unauthored IP                      (0 == lstrcmpW(pwzIPExists, L"*"));                       // matches the All Unassigned IP : '*'        // compare the passed in address with the address listed for this web        if (fIpMatches && psw->swaBinding.iPort == iPortExists &&            0 == lstrcmpW(psw->swaBinding.wzHeader, pwzHeaderExists))        {            fFound = TRUE;            break;        }        // move to the next block of data, this may move beyond the available        // data and exit the while loop above.        pwzExists = const_cast<LPWSTR>(pwzHeaderExists + lstrlenW(pwzHeaderExists));    }LExit:    WcaLog(LOGMSG_VERBOSE, "Site with binding %ls %s a match", pwzBindingInfo, fFound ? "is" : "is not");    ReleaseNullStr(pwzBindingInfo);    return fFound;}

/****************************************************************** GetCurrentFirewallProfile - get the active firewall profile as an   INetFwProfile, which owns the lists of exceptions we're    updating.********************************************************************/static HRESULT GetCurrentFirewallProfile(    __in BOOL fIgnoreFailures,    __out INetFwProfile** ppfwProfile    ){    HRESULT hr = S_OK;    INetFwMgr* pfwMgr = NULL;    INetFwPolicy* pfwPolicy = NULL;    INetFwProfile* pfwProfile = NULL;    *ppfwProfile = NULL;        do    {        ReleaseNullObject(pfwPolicy);        ReleaseNullObject(pfwMgr);        ReleaseNullObject(pfwProfile);        if (SUCCEEDED(hr = ::CoCreateInstance(__uuidof(NetFwMgr), NULL, CLSCTX_INPROC_SERVER, __uuidof(INetFwMgr), (void**)&pfwMgr)) &&            SUCCEEDED(hr = pfwMgr->get_LocalPolicy(&pfwPolicy)) &&            SUCCEEDED(hr = pfwPolicy->get_CurrentProfile(&pfwProfile)))        {            break;        }        else if (fIgnoreFailures)        {            ExitFunction1(hr = S_FALSE);        }        else        {            WcaLog(LOGMSG_STANDARD, "Failed to connect to Windows Firewall");            UINT er = WcaErrorMessage(msierrFirewallCannotConnect, hr, INSTALLMESSAGE_ERROR | MB_ABORTRETRYIGNORE, 0);            switch (er)            {            case IDABORT: // exit with the current HRESULT                ExitFunction();            case IDRETRY: // clean up and retry the loop                hr = S_FALSE;                break;            case IDIGNORE: // pass S_FALSE back to the caller, who knows how to ignore the failure                ExitFunction1(hr = S_FALSE);            default: // No UI, so default is to fail.                ExitFunction();            }        }    } while (S_FALSE == hr);    *ppfwProfile = pfwProfile;    pfwProfile = NULL;    LExit:    ReleaseObject(pfwPolicy);    ReleaseObject(pfwMgr);    ReleaseObject(pfwProfile);    return hr;}

static HRESULT DAPI RedirectLoggingOverPipe(    __in_z LPCSTR szString,    __in_opt LPVOID pvContext    ){    static BOOL s_fCurrentlyLoggingToPipe = FALSE;    HRESULT hr = S_OK;    BURN_ENGINE_STATE* pEngineState = static_cast<BURN_ENGINE_STATE*>(pvContext);    BOOL fStartedLogging = FALSE;    HANDLE hPipe = INVALID_HANDLE_VALUE;    BYTE* pbData = NULL;    SIZE_T cbData = 0;    DWORD dwResult = 0;    // Prevent this function from being called recursively.    if (s_fCurrentlyLoggingToPipe)    {        ExitFunction();    }    s_fCurrentlyLoggingToPipe = TRUE;    fStartedLogging = TRUE;    // Make sure the current thread set the pipe in TLS.    hPipe = ::TlsGetValue(pEngineState->dwElevatedLoggingTlsId);    if (!hPipe || INVALID_HANDLE_VALUE == hPipe)    {        hr = HRESULT_FROM_WIN32(ERROR_PIPE_NOT_CONNECTED);        ExitFunction();    }    // Do not log or use ExitOnFailure() macro here because they will be discarded    // by the recursive block at the top of this function.    hr = BuffWriteStringAnsi(&pbData, &cbData, szString);    if (SUCCEEDED(hr))    {        hr = PipeSendMessage(hPipe, static_cast<DWORD>(BURN_PIPE_MESSAGE_TYPE_LOG), pbData, cbData, NULL, NULL, &dwResult);        if (SUCCEEDED(hr))        {            hr = (HRESULT)dwResult;        }    }LExit:    ReleaseBuffer(pbData);    // We started logging so remember to say we are no longer logging.    if (fStartedLogging)    {        s_fCurrentlyLoggingToPipe = FALSE;    }    return hr;}

extern "C" HRESULT ApprovedExesVerifySecureLocation(    __in BURN_VARIABLES* pVariables,    __in BURN_LAUNCH_APPROVED_EXE* pLaunchApprovedExe    ){    HRESULT hr = S_OK;    LPWSTR scz = NULL;    const LPCWSTR vrgSecureFolderVariables[] = {        L"ProgramFiles64Folder",        L"ProgramFilesFolder",    };    for (DWORD i = 0; i < countof(vrgSecureFolderVariables); ++i)    {        LPCWSTR wzSecureFolderVariable = vrgSecureFolderVariables[i];        hr = VariableGetString(pVariables, wzSecureFolderVariable, &scz);        if (SUCCEEDED(hr))        {            hr = PathDirectoryContainsPath(scz, pLaunchApprovedExe->sczExecutablePath);            if (S_OK == hr)            {                ExitFunction();            }        }        else if (E_NOTFOUND != hr)        {            ExitOnFailure1(hr, "Failed to get the variable: %ls", wzSecureFolderVariable);        }    }    // The problem with using a Variable for the root package cache folder is that it might not have been secured yet.    // Getting it through CacheGetRootCompletedPath makes sure it has been secured.    hr = CacheGetRootCompletedPath(TRUE, TRUE, &scz);    ExitOnFailure(hr, "Failed to get the root package cache folder.");    hr = PathDirectoryContainsPath(scz, pLaunchApprovedExe->sczExecutablePath);    if (S_OK == hr)    {        ExitFunction();    }    hr = S_FALSE;LExit:    ReleaseStr(scz);    return hr;}

DAPI_(HRESULT) JsonReadNext(    __in JSON_READER* pReader,    __out JSON_TOKEN* pToken,    __out JSON_VALUE* pValue    ){    HRESULT hr = S_OK;    //WCHAR wz;    //JSON_TOKEN token = JSON_TOKEN_NONE;    ::EnterCriticalSection(&pReader->cs);    hr = NextToken(pReader, pToken);    if (E_NOMOREITEMS == hr)    {        ExitFunction();    }    ExitOnFailure(hr, "Failed to get next token.");    if (JSON_TOKEN_VALUE == *pToken)    {        hr = JsonReadValue(pReader, pValue);    }    else    {        ++pReader->pwz;    }LExit:    ::LeaveCriticalSection(&pReader->cs);    return hr;}

HRESULT CpiRemoveUserCollectionObject(	ICatalogCollection* piColl,	PSID pSid	){	HRESULT hr = S_OK;	int i = 0;	// find index	hr = FindUserCollectionObjectIndex(piColl, pSid, &i);	ExitOnFailure(hr, "Failed to find user collection index");	if (S_FALSE == hr)		ExitFunction(); // not found, exit with hr = S_FALSE	// remove object	hr = piColl->Remove(i);	ExitOnFailure(hr, "Failed to remove object from collection");	hr = S_OK;LExit:	return hr;}

static HRESULT FindObjectForApplicationRole(    CPI_APPLICATION_ROLE* pItm,    ICatalogObject** ppiRoleObj    ){    HRESULT hr = S_OK;    ICatalogCollection* piRoleColl = NULL;    // get roles collection    hr = CpiGetRolesCollForApplication(pItm->pApplication, &piRoleColl);    ExitOnFailure(hr, "Failed to get collection");    if (S_FALSE == hr)        ExitFunction(); // exit with hr = S_FALSE    // find role object    hr = CpiFindCollectionObject(piRoleColl, NULL, pItm->wzName, ppiRoleObj);    ExitOnFailure(hr, "Failed to find object");    // exit with hr from CpiFindCollectionObject()LExit:    // clean up    ReleaseObject(piRoleColl);    return hr;}

static HRESULT FindObjectForSubscription(    CPI_SUBSCRIPTION* pItm,    BOOL fFindId,    BOOL fFindName,    ICatalogObject** ppiSubsObj    ){    HRESULT hr = S_OK;    ICatalogCollection* piSubsColl = NULL;    // get applications collection    hr = CpiGetSubscriptionsCollForComponent(pItm->pAssembly, pItm->pComponent, &piSubsColl);    ExitOnFailure(hr, "Failed to get collection");    if (S_FALSE == hr)        ExitFunction(); // exit with hr = S_FALSE    // find application object    hr = CpiFindCollectionObject(piSubsColl, fFindId ? pItm->wzID : NULL, fFindName ? pItm->wzName : NULL, ppiSubsObj);    ExitOnFailure(hr, "Failed to find object");    // exit with hr from CpiFindCollectionObject()LExit:    // clean up    ReleaseObject(piSubsColl);    return hr;}

HRESULT DatabaseListFind(    __in CFGDB_STRUCT *pcdb,    __in LPCWSTR wzFriendlyName,    __out SCE_ROW_HANDLE *pSceRow    ){    HRESULT hr = S_OK;    SCE_QUERY_HANDLE sqhHandle = NULL;    hr = SceBeginQuery(pcdb->psceDb, DATABASE_INDEX_TABLE, 1, &sqhHandle);    ExitOnFailure(hr, "Failed to begin query into database index table");    hr = SceSetQueryColumnString(sqhHandle, wzFriendlyName);    ExitOnFailure(hr, "Failed to set query column name string to: %ls", wzFriendlyName);    hr = SceRunQueryExact(&sqhHandle, pSceRow);    if (E_NOTFOUND == hr)    {        // Don't pollute our log with unnecessary messages        ExitFunction();    }    ExitOnFailure(hr, "Failed to query for database '%ls' in database list", wzFriendlyName);LExit:    ReleaseSceQuery(sqhHandle);    return hr;}

/****************************************************************** RemoveApplicationExceptionFromCurrentProfile********************************************************************/static HRESULT RemoveApplicationExceptionFromCurrentProfile(    __in LPCWSTR wzFile,     __in BOOL fIgnoreFailures    ){    HRESULT hr = S_OK;    INetFwProfile* pfwProfile = NULL;    INetFwAuthorizedApplications* pfwApps = NULL;    // convert to BSTRs to make COM happy    BSTR bstrFile = ::SysAllocString(wzFile);    ExitOnNull(bstrFile, hr, E_OUTOFMEMORY, "failed SysAllocString for path");    // get the firewall profile, which is our entry point for removing exceptions    hr = GetCurrentFirewallProfile(fIgnoreFailures, &pfwProfile);    ExitOnFailure(hr, "failed to get firewall profile");    if (S_FALSE == hr) // user or package author chose to ignore missing firewall    {        ExitFunction();    }    // now get the list of app exceptions and remove the one    hr = pfwProfile->get_AuthorizedApplications(&pfwApps);    ExitOnFailure(hr, "failed to get list of authorized apps");    hr = pfwApps->Remove(bstrFile);    ExitOnFailure(hr, "failed to remove authorized app");LExit:    ReleaseBSTR(bstrFile);    ReleaseObject(pfwApps);    ReleaseObject(pfwProfile);    return fIgnoreFailures ? S_OK : hr;}

/****************************************************************** RemovePortExceptionFromCurrentProfile********************************************************************/static HRESULT RemovePortExceptionFromCurrentProfile(    __in int iPort,    __in int iProtocol,    __in BOOL fIgnoreFailures    ){    HRESULT hr = S_OK;    INetFwProfile* pfwProfile = NULL;    INetFwOpenPorts* pfwPorts = NULL;    // get the firewall profile, which is our entry point for adding exceptions    hr = GetCurrentFirewallProfile(fIgnoreFailures, &pfwProfile);    ExitOnFailure(hr, "failed to get firewall profile");    if (S_FALSE == hr) // user or package author chose to ignore missing firewall    {        ExitFunction();    }    hr = pfwProfile->get_GloballyOpenPorts(&pfwPorts);    ExitOnFailure(hr, "failed to get open ports");    hr = pfwPorts->Remove(iPort, static_cast<NET_FW_IP_PROTOCOL>(iProtocol));    ExitOnFailure2(hr, "failed to remove open port %d, protocol %d", iPort, iProtocol);LExit:    return fIgnoreFailures ? S_OK : hr;}

extern "C" HRESULT DatabaseListDelete(    __in CFGDB_STRUCT *pcdb,    __in LPCWSTR wzFriendlyName    ){    HRESULT hr = S_OK;    SCE_QUERY_HANDLE sqhHandle = NULL;    SCE_ROW_HANDLE sceRow = NULL;    hr = DatabaseListFind(pcdb, wzFriendlyName, &sceRow);    if (E_NOTFOUND == hr)    {        ExitFunction();    }    ExitOnFailure(hr, "Failed to search for database '%ls' in database list", wzFriendlyName);    hr = SceDeleteRow(&sceRow);    ExitOnFailure(hr, "Failed to delete database '%ls' from database list", wzFriendlyName);LExit:    ReleaseSceRow(sceRow);    ReleaseSceQuery(sqhHandle);    return hr;}

/****************************************************************** RemoveException - Removes the exception rule with the given name.********************************************************************/static HRESULT RemoveException(    __in LPCWSTR wzName,     __in BOOL fIgnoreFailures    ){    HRESULT hr = S_OK;;    INetFwRules* pNetFwRules = NULL;    // convert to BSTRs to make COM happy    BSTR bstrName = ::SysAllocString(wzName);    ExitOnNull(bstrName, hr, E_OUTOFMEMORY, "failed SysAllocString for path");    // get the collection of firewall rules    hr = GetFirewallRules(fIgnoreFailures, &pNetFwRules);    ExitOnFailure(hr, "failed to get firewall rules object");    if (S_FALSE == hr) // user or package author chose to ignore missing firewall    {        ExitFunction();    }    hr = pNetFwRules->Remove(bstrName);    ExitOnFailure(hr, "failed to remove authorized app");LExit:    ReleaseBSTR(bstrName);    ReleaseObject(pNetFwRules);    return fIgnoreFailures ? S_OK : hr;}

/****************************************************************** AddPortException********************************************************************/static HRESULT AddPortException(    __in LPCWSTR wzName,    __in int iProfile,    __in_opt LPCWSTR wzRemoteAddresses,    __in BOOL fIgnoreFailures,    __in LPCWSTR wzPort,    __in int iProtocol,    __in LPCWSTR wzDescription    ){    HRESULT hr = S_OK;    BSTR bstrName = NULL;    INetFwRules* pNetFwRules = NULL;    INetFwRule* pNetFwRule = NULL;    // convert to BSTRs to make COM happy    bstrName = ::SysAllocString(wzName);    ExitOnNull(bstrName, hr, E_OUTOFMEMORY, "failed SysAllocString for name");    // get the collection of firewall rules    hr = GetFirewallRules(fIgnoreFailures, &pNetFwRules);    ExitOnFailure(hr, "failed to get firewall rules object");    if (S_FALSE == hr) // user or package author chose to ignore missing firewall    {        ExitFunction();    }    // try to find it (i.e., support reinstall)    hr = pNetFwRules->Item(bstrName, &pNetFwRule);    if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr)    {        hr = CreateFwRuleObject(bstrName, iProfile, wzRemoteAddresses, wzPort, iProtocol, wzDescription, &pNetFwRule);        ExitOnFailure(hr, "failed to create FwRule object");        // enable it        hr = pNetFwRule->put_Enabled(VARIANT_TRUE);        ExitOnFailure(hr, "failed to to enable port exception");        // add it to the list of authorized ports        hr = pNetFwRules->Add(pNetFwRule);        ExitOnFailure(hr, "failed to add app to the authorized ports list");    }    else    {        // we found an existing port exception (if we succeeded, that is)        ExitOnFailure(hr, "failed trying to find existing port rule");        // enable it (just in case it was disabled)        pNetFwRule->put_Enabled(VARIANT_TRUE);    }LExit:    ReleaseBSTR(bstrName);    ReleaseObject(pNetFwRules);    ReleaseObject(pNetFwRule);    return fIgnoreFailures ? S_OK : hr;}

extern "C" HRESULT CatalogsParseFromXml(    __in BURN_CATALOGS* pCatalogs,    __in IXMLDOMNode* pixnBundle    ){    HRESULT hr = S_OK;    IXMLDOMNodeList* pixnNodes = NULL;    IXMLDOMNode* pixnNode = NULL;    DWORD cNodes = 0;    LPWSTR scz = NULL;    // select catalog nodes    hr = XmlSelectNodes(pixnBundle, L"Catalog", &pixnNodes);    ExitOnFailure(hr, "Failed to select catalog nodes.");    // get catalog node count    hr = pixnNodes->get_length((long*)&cNodes);    ExitOnFailure(hr, "Failed to get payload node count.");    if (!cNodes)    {        ExitFunction();    }    // allocate memory for catalogs    pCatalogs->rgCatalogs = (BURN_CATALOG*)MemAlloc(sizeof(BURN_CATALOG) * cNodes, TRUE);    ExitOnNull(pCatalogs->rgCatalogs, hr, E_OUTOFMEMORY, "Failed to allocate memory for payload structs.");    pCatalogs->cCatalogs = cNodes;    // parse catalog elements    for (DWORD i = 0; i < cNodes; ++i)    {        BURN_CATALOG* pCatalog = &pCatalogs->rgCatalogs[i];        pCatalog->hFile = INVALID_HANDLE_VALUE;        hr = XmlNextElement(pixnNodes, &pixnNode, NULL);        ExitOnFailure(hr, "Failed to get next node.");        // @Id        hr = XmlGetAttributeEx(pixnNode, L"Id", &pCatalog->sczKey);        ExitOnFailure(hr, "Failed to get @Id.");        // @Payload        hr = XmlGetAttributeEx(pixnNode, L"Payload", &pCatalog->sczPayload);        ExitOnFailure(hr, "Failed to get @Payload.");        // prepare next iteration        ReleaseNullObject(pixnNode);    }LExit:    ReleaseObject(pixnNodes);    ReleaseObject(pixnNode);    ReleaseStr(scz);    return hr;}

/******************************************************************** MessageQueuingExecuteInstall - CUSTOM ACTION ENTRY POINT  Input:  deferred CustomActionData - MessageQueuingExecuteInstall********************************************************************/extern "C" UINT __stdcall MessageQueuingExecuteInstall(MSIHANDLE hInstall){    HRESULT hr = S_OK;    UINT er = ERROR_SUCCESS;    LPWSTR pwzCustomActionData = NULL;    LPWSTR pwzData = NULL;    // initialize    hr = WcaInitialize(hInstall, "MessageQueuingExecuteInstall");    ExitOnFailure(hr, "Failed to initialize MessageQueuingExecuteInstall");    hr = MqiInitialize();    ExitOnFailure(hr, "Failed to initialize");    // get custom action data    hr = WcaGetProperty(L"CustomActionData", &pwzCustomActionData);    ExitOnFailure(hr, "Failed to get CustomActionData");    pwzData = pwzCustomActionData;    // create message queues    hr = MqiCreateMessageQueues(&pwzData);    ExitOnFailure(hr, "Failed to create message queues");    if (S_FALSE == hr) ExitFunction();    // add message queue permissions    hr = MqiAddMessageQueuePermissions(&pwzData);    ExitOnFailure(hr, "Failed to add message queue permissions");    if (S_FALSE == hr) ExitFunction();    hr = S_OK;LExit:    // clean up    ReleaseStr(pwzCustomActionData);    // uninitialize    MqiUninitialize();    er = SUCCEEDED(hr) ? ERROR_SUCCESS : ERROR_INSTALL_FAILURE;    return WcaFinalize(er);}

void				LibES::Abort			(const std::string& aMessage){	printf("ABORT: %s/n", aMessage.c_str());		if(ExitFunction)	{		ExitFunction();	}		abort();}

/********************************************************************WcaGetRecordFormattedString() - gets formatted string filed from record********************************************************************/extern "C" HRESULT WIXAPI WcaGetRecordFormattedString(    __in MSIHANDLE hRec,    __in UINT uiField,    __inout LPWSTR* ppwzData    ){    if (!hRec || !ppwzData)    {        return E_INVALIDARG;    }    HRESULT hr = S_OK;    UINT er;    DWORD_PTR cch = 0;    PMSIHANDLE hRecFormat;    // get the format string    hr = WcaGetRecordString(hRec, uiField, ppwzData);    ExitOnFailure(hr, "failed to get string from record");    if (!**ppwzData)    {        ExitFunction();    }    // hide the nulls '[~]' so we can get them back after formatting    HideNulls(*ppwzData);    // set up the format record    hRecFormat = ::MsiCreateRecord(1);    ExitOnNull(hRecFormat, hr, E_UNEXPECTED, "Failed to create record to format string");    hr = WcaSetRecordString(hRecFormat, 0, *ppwzData);    ExitOnFailure(hr, "failed to set string to format record");    // format the string    hr = StrMaxLength(*ppwzData, &cch);    ExitOnFailure(hr, "failed to get max length of string");    er = ::MsiFormatRecordW(WcaGetInstallHandle(), hRecFormat, *ppwzData, (DWORD*)&cch);    if (ERROR_MORE_DATA == er)    {        hr = StrAlloc(ppwzData, ++cch);        ExitOnFailure(hr, "Failed to allocate memory for record string");        er = ::MsiFormatRecordW(WcaGetInstallHandle(), hRecFormat, *ppwzData, (DWORD*)&cch);    }    ExitOnWin32Error(er, hr, "Failed to format string");    // put the nulls back    RevealNulls(*ppwzData);LExit:    return hr;}

HRESULT ProductSet(    __in CFGDB_STRUCT *pcdb,    __in_z LPCWSTR wzProductName,    __in_z LPCWSTR wzVersion,    __in_z LPCWSTR wzPublicKey,    __in BOOL fDontCreate,    __out_opt BOOL *pfLegacy    ){    HRESULT hr = S_OK;    SCE_ROW_HANDLE sceRow = NULL;    pcdb->fProductSet = FALSE;    pcdb->fProductIsLegacy = FALSE;    pcdb->dwAppID = DWORD_MAX;    if (fDontCreate)    {        // Just query for an existing product - if it exists, we'll use it        hr = ProductFindRow(pcdb, PRODUCT_INDEX_TABLE, wzProductName, wzVersion, wzPublicKey, &sceRow);        if (E_NOTFOUND == hr)        {            ExitFunction();        }        ExitOnFailure(hr, "Failed to query for product");        hr = SceGetColumnDword(sceRow, PRODUCT_ID, &pcdb->dwAppID);        ExitOnFailure(hr, "Failed to get App ID of application");        hr = SceGetColumnBool(sceRow, PRODUCT_IS_LEGACY, &pcdb->fProductIsLegacy);        ExitOnFailure(hr, "Failed to get IsLegacy flag of application");    }    else    {        hr = ProductEnsureCreated(pcdb, wzProductName, wzVersion, wzPublicKey, &pcdb->dwAppID, &pcdb->fProductIsLegacy);        ExitOnFailure(hr, "Failed to ensure product exists: %ls", wzProductName);    }    // Get the AppID (of either the found row, or the recently created row)    hr = StrAllocString(&pcdb->sczProductName, wzProductName, 0);    ExitOnFailure(hr, "Failed to copy product name string");    if (pfLegacy)    {        *pfLegacy = pcdb->fProductIsLegacy;    }    pcdb->fProductSet = TRUE;LExit:    ReleaseSceRow(sceRow);    return hr;}

extern "C" HRESULT WINAPI UpdateThreadCheck(    __in LPCWSTR wzAppId,    __in BOOL fTryExecuteUpdate    ){    HRESULT hr = S_OK;    BOOL fLocked = FALSE;    BACKGROUND_UPDATE_THREAD_CONTEXT* pContext = NULL;    ::EnterCriticalSection(&vUpdateThreadLock);    fLocked = TRUE;    if (vhUpdateThread)    {        DWORD er = ::WaitForSingleObject(vhUpdateThread, 0);        if (WAIT_OBJECT_0 == er)        {            ::CloseHandle(vhUpdateThread);            vhUpdateThread = NULL;        }        else        {            hr = S_FALSE;            ExitFunction();        }    }    pContext = static_cast<BACKGROUND_UPDATE_THREAD_CONTEXT*>(MemAlloc(sizeof(BACKGROUND_UPDATE_THREAD_CONTEXT), TRUE));    ExitOnNull(pContext, hr, E_OUTOFMEMORY, "Failed to allocate memory for context.");    hr= StrAllocString(&pContext->pwzApplicationId, wzAppId, 0);    ExitOnFailure(hr, "Failed to copy app id into context.");    pContext->fExecuteUpdate = fTryExecuteUpdate;    vhUpdateThread = ::CreateThread(NULL, 0, BackgroundUpdateThread, reinterpret_cast<LPVOID>(pContext), 0, NULL);    ExitOnNullWithLastError(vhUpdateThread, hr, "Failed to create background update thread.");    pContext = NULL;LExit:    if (pContext)    {        ReleaseStr(pContext->pwzApplicationId);        MemFree(pContext);    }    if (fLocked)    {        ::LeaveCriticalSection(&vUpdateThreadLock);    }   return hr;}

volatile bool		LibES::WantToDie		(){	want_to_die = LibESPlatform::WantToDie();	if(want_to_die && ExitFunction)	{		ExitFunction();		exit(1);	}		return want_to_die;}

HRESULT CpiGetSubscriptionsCollection(	LPCWSTR pwzPartID,	LPCWSTR pwzAppID,	LPCWSTR pwzCompCLSID,	ICatalogCollection** ppiSubsColl	){	HRESULT hr = S_OK;	ICatalogCollection* piCompColl = NULL;	ICatalogObject* piCompObj = NULL;	// get components collection	hr = CpiGetComponentsCollection(pwzPartID, pwzAppID, &piCompColl);	ExitOnFailure(hr, "Failed to get components collection");	if (S_FALSE == hr)		ExitFunction(); // components collection not found, exit with hr = S_FALSE	// find object	hr = CpiFindCollectionObjectByStringKey(piCompColl, pwzCompCLSID, &piCompObj);	ExitOnFailure(hr, "Failed to find collection object");	if (S_FALSE == hr)		ExitFunction(); // component not found, exit with hr = S_FALSE	// get subscriptions collection	hr = CpiGetCatalogCollection(piCompColl, piCompObj, L"SubscriptionsForComponent", ppiSubsColl);	ExitOnFailure(hr, "Failed to get catalog collection");	hr = S_OK;LExit:	// clean up	ReleaseObject(piCompColl);	ReleaseObject(piCompObj);	return hr;}

HRESULT CpiGetUsersInRoleCollection(	LPCWSTR pwzPartID,	LPCWSTR pwzAppID,	LPCWSTR pwzRoleName,	ICatalogCollection** ppiUsrInRoleColl	){	HRESULT hr = S_OK;	ICatalogCollection* piRoleColl = NULL;	ICatalogObject* piRoleObj = NULL;	// get roles collection	hr = CpiGetRolesCollection(pwzPartID, pwzAppID, &piRoleColl);	ExitOnFailure(hr, "Failed to get roles collection");	if (S_FALSE == hr)		ExitFunction(); // roles collection not found, exit with hr = S_FALSE	// find object	hr = CpiFindCollectionObjectByName(piRoleColl, pwzRoleName, &piRoleObj);	ExitOnFailure(hr, "Failed to find collection object");	if (S_FALSE == hr)		ExitFunction(); // role not found, exit with hr = S_FALSE	// get roles collection	hr = CpiGetCatalogCollection(piRoleColl, piRoleObj, L"UsersInRole", ppiUsrInRoleColl);	ExitOnFailure(hr, "Failed to get catalog collection");	hr = S_OK;LExit:	// clean up	ReleaseObject(piRoleColl);	ReleaseObject(piRoleObj);	return hr;}

HRESULT ScaFiltersInstall7(    __in SCA_FILTER* psfList    ){    HRESULT hr = S_OK;    SCA_FILTER* psf = psfList;    if (!psf)    {        ExitFunction();    }    //write global filters    hr = ScaWriteConfigID(IIS_FILTER_GLOBAL_BEGIN);    ExitOnFailure(hr, "Failed to write filter begin ID");    while (psf)    {        if (WcaIsInstalling(psf->isInstalled, psf->isAction))        {            if (0 == wcscmp(psf->wzFilterRoot, L"/"))            {                hr = WriteFilter(psf);            }        }        psf = psf->psfNext;    }    hr = ScaWriteConfigID(IIS_FILTER_END);    ExitOnFailure(hr, "Failed to write filter ID");    psf = psfList;    //Write Web Site Filters    hr = ScaWriteConfigID(IIS_FILTER_BEGIN);    ExitOnFailure(hr, "Failed to write filter begin ID");    while (psf)    {        if (WcaIsInstalling(psf->isInstalled, psf->isAction))        {            if (0 != wcscmp(psf->wzFilterRoot, L"/"))            {                hr = WriteFilter(psf);            }        }        psf = psf->psfNext;    }    hr = ScaWriteConfigID(IIS_FILTER_END);    ExitOnFailure(hr, "Failed to write filter ID");LExit:    return hr;}

HRESULT ScaWebAppExtensionsWrite(IMSAdminBase* piMetabase, LPCWSTR wzRootOfWeb,                                 SCA_WEB_APPLICATION_EXTENSION* pswappextList                                ){    HRESULT hr = S_OK;    LPWSTR wzAppExt = NULL;    DWORD cchAppExt;    WCHAR wzAppExtension[1024];    WCHAR wzAppExtensions[65536];    SCA_WEB_APPLICATION_EXTENSION* pswappext = NULL;    if (!pswappextList)        ExitFunction();    ::ZeroMemory(wzAppExtensions, sizeof(wzAppExtensions));    wzAppExt = wzAppExtensions;    cchAppExt = countof(wzAppExtensions);    pswappext = pswappextList;    while (pswappext)    {        if (0 == lstrcmpW(wzAppExtension, L"*"))            StringCchPrintfW(wzAppExtension, countof(wzAppExtension), L"*,%s,%d", pswappext->wzExecutable, pswappext->iAttributes);        else if (*pswappext->wzExtension)            StringCchPrintfW(wzAppExtension, countof(wzAppExtension), L".%s,%s,%d", pswappext->wzExtension, pswappext->wzExecutable, pswappext->iAttributes);        else   // blank means "*" (all)            StringCchPrintfW(wzAppExtension, countof(wzAppExtension), L"*,%s,%d", pswappext->wzExecutable, pswappext->iAttributes);        // if verbs were specified and not the keyword "all"        if (pswappext->wzVerbs[0] && CSTR_EQUAL != CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, pswappext->wzVerbs, -1, L"all", -1))        {            StringCchCatW(wzAppExtension, countof(wzAppExtension), L",");            StringCchCatW(wzAppExtension, countof(wzAppExtension), pswappext->wzVerbs);        }        StringCchCopyW(wzAppExt, cchAppExt, wzAppExtension);        wzAppExt += lstrlenW(wzAppExtension) + 1;        cchAppExt -= lstrlenW(wzAppExtension) + 1;        pswappext = pswappext->pswappextNext;    }    if (*wzAppExtensions)    {        hr = ScaWriteMetabaseValue(piMetabase, wzRootOfWeb, NULL, MD_SCRIPT_MAPS, METADATA_INHERIT, IIS_MD_UT_FILE, MULTISZ_METADATA, wzAppExtensions);        ExitOnFailure1(hr, "Failed to write AppExtension: '%S'", wzAppExtension);    }LExit:    return hr;}

HRESULT CpiGetRolesCollection(	LPCWSTR pwzPartID,	LPCWSTR pwzAppID,	ICatalogCollection** ppiRolesColl	){	HRESULT hr = S_OK;	ICatalogCollection* piAppColl = NULL;	ICatalogObject* piAppObj = NULL;	// get applications collection	hr = CpiGetApplicationsCollection(pwzPartID, &piAppColl);	ExitOnFailure(hr, "Failed to get applications collection");	if (S_FALSE == hr)		ExitFunction(); // applications collection not found, exit with hr = S_FALSE	// find object	hr = CpiFindCollectionObjectByStringKey(piAppColl, pwzAppID, &piAppObj);	ExitOnFailure(hr, "Failed to find collection object");	if (S_FALSE == hr)		ExitFunction(); // application not found, exit with hr = S_FALSE	// get roles collection	hr = CpiGetCatalogCollection(piAppColl, piAppObj, L"Roles", ppiRolesColl);	ExitOnFailure(hr, "Failed to catalog collection");	hr = S_OK;LExit:	// clean up	ReleaseObject(piAppColl);	ReleaseObject(piAppObj);	return hr;}

/******************************************************************** XmlInitialize - finds an appropriate version of the XML DOM*********************************************************************/extern "C" HRESULT DAPI XmlInitialize(    ){    HRESULT hr = S_OK;    if (!fComInitialized)    {        hr = ::CoInitialize(0);        if (RPC_E_CHANGED_MODE != hr)        {            ExitOnFailure(hr, "failed to initialize COM");            fComInitialized = TRUE;        }    }    LONG cInitialized = ::InterlockedIncrement(&vcXmlInitialized);    if (1 == cInitialized)    {        // NOTE: 4.0 behaves differently than 3.0 so there may be problems doing this#if 0        hr = ::CLSIDFromProgID(L"Msxml2.DOMDocument.4.0", &vclsidXMLDOM);        if (S_OK == hr)        {            vfMsxml40 = TRUE;            Trace(REPORT_VERBOSE, "found Msxml2.DOMDocument.4.0");            ExitFunction();        }#endif        hr = ::CLSIDFromProgID(L"Msxml2.DOMDocument", &vclsidXMLDOM);        if (FAILED(hr))        {            // try to fall back to old MSXML            hr = ::CLSIDFromProgID(L"MSXML.DOMDocument", &vclsidXMLDOM);        }        ExitOnFailure(hr, "failed to get CLSID for XML DOM");        Assert(IsEqualCLSID(vclsidXMLDOM, XmlUtil_CLSID_DOMDocument) ||               IsEqualCLSID(vclsidXMLDOM, XmlUtil_CLSID_DOMDocument20) ||               IsEqualCLSID(vclsidXMLDOM, XmlUtil_CLSID_DOMDocument26) ||               IsEqualCLSID(vclsidXMLDOM, XmlUtil_CLSID_DOMDocument30) ||               IsEqualCLSID(vclsidXMLDOM, XmlUtil_CLSID_DOMDocument40) ||               IsEqualCLSID(vclsidXMLDOM, XmlUtil_CLSID_DOMDocument50) ||               IsEqualCLSID(vclsidXMLDOM, XmlUtil_CLSID_DOMDocument60));    }    hr = S_OK;LExit:    return hr;}

HRESULT CpiGetApplicationsCollForPartition(    CPI_PARTITION* pPart,    ICatalogCollection** ppiAppColl    ){    HRESULT hr = S_OK;    ICatalogCollection* piPartColl = NULL;    ICatalogObject* piPartObj = NULL;    // if a previous attempt to locate the collection object failed    if (pPart->fObjectNotFound)        ExitFunction1(hr = S_FALSE);    // get applications collection    if (!pPart->piApplicationsColl)    {        // get partitions collection from catalog        hr = CpiGetPartitionsCollection(&piPartColl);        ExitOnFailure(hr, "Failed to get partitions collection");        // find application object        hr = CpiFindCollectionObject(piPartColl, pPart->wzID, *pPart->wzID ? NULL : pPart->wzName, &piPartObj);        ExitOnFailure(hr, "Failed to find partition object");        if (S_FALSE == hr)        {            pPart->fObjectNotFound = TRUE;            ExitFunction(); // exit with hr = S_FALSE        }        // get roles collection        hr = CpiGetCatalogCollection(piPartColl, piPartObj, L"Applications", &pPart->piApplicationsColl);        ExitOnFailure(hr, "Failed to get applications collection");    }    // return value    *ppiAppColl = pPart->piApplicationsColl;    (*ppiAppColl)->AddRef();    hr = S_OK;LExit:    // clean up    ReleaseObject(piPartColl);    ReleaseObject(piPartObj);    return hr;}

static HRESULT ReadDirWriteLegacyDb(    __in CFGDB_STRUCT *pcdb,    __in LEGACY_SYNC_PRODUCT_SESSION *pSyncProductSession,    __in LEGACY_FILE *pFile,    __in_z LPCWSTR wzSubDir    ){    HRESULT hr = S_OK;    LPWSTR sczFullPathToVirtualDirectory = NULL;    LPWSTR wzFullPathBackup = pFile->sczExpandedPath;    BOOL fWritePermission = TRUE;    hr = UtilTestWriteAccess(pcdb->hToken, wzSubDir);    if (E_ACCESSDENIED == hr || E_PATHNOTFOUND == hr)    {        fWritePermission = FALSE;        hr = S_OK;    }    ExitOnFailure(hr, "Failed to check for write access to directory: %ls", wzSubDir);    if (!fWritePermission)    {        // If we don't have write permission to the directory, prefer files in virtualstore        hr = UtilConvertToVirtualStorePath(wzSubDir, &sczFullPathToVirtualDirectory);        ExitOnFailure(hr, "Failed to get path equivalent under virtualstore for directory: %ls", sczFullPathToVirtualDirectory);        // Make the LEGACY_FILE struct temporarily appear as though its natural base path was under virtualstore        pFile->sczExpandedPath = sczFullPathToVirtualDirectory;        hr = ReadDirWriteLegacyDbHelp(pcdb, pSyncProductSession, pFile, sczFullPathToVirtualDirectory);        ExitOnFailure(hr, "Failed to read files out of virtual store subdirectory: %ls", sczFullPathToVirtualDirectory);        // Restore it back so it isn't pointing to virtualstore anymore        pFile->sczExpandedPath = wzFullPathBackup;    }    hr = ReadDirWriteLegacyDbHelp(pcdb, pSyncProductSession, pFile, wzSubDir);    if (E_PATHNOTFOUND == hr)    {        ExitFunction();    }    ExitOnFailure(hr, "Failed to read files out of subdirectory: %ls", wzSubDir);LExit:    ReleaseStr(sczFullPathToVirtualDirectory);    pFile->sczExpandedPath = wzFullPathBackup;    return hr;}

extern "C" HRESULT LoggingSetPackageVariable(    __in BURN_PACKAGE* pPackage,    __in_z_opt LPCWSTR wzSuffix,    __in BOOL fRollback,    __in BURN_LOGGING* pLog,    __in BURN_VARIABLES* pVariables,    __out_opt LPWSTR* psczLogPath    ){    HRESULT hr = S_OK;    LPWSTR sczLogPath = NULL;    if (BURN_LOGGING_STATE_DISABLED == pLog->state)    {        if (psczLogPath)        {            *psczLogPath = NULL;        }        ExitFunction();    }    if ((!fRollback && pPackage->sczLogPathVariable && *pPackage->sczLogPathVariable) ||        (fRollback && pPackage->sczRollbackLogPathVariable && *pPackage->sczRollbackLogPathVariable))    {        hr = StrAllocFormatted(&sczLogPath, L"%ls%hs%ls_%03u_%ls%ls.%ls", pLog->sczPrefix, wzSuffix && *wzSuffix ? "_" : "", wzSuffix && *wzSuffix ? wzSuffix : L"", vdwPackageSequence, pPackage->sczId, fRollback ? L"_rollback" : L"", pLog->sczExtension);        ExitOnFailure(hr, "Failed to allocate path for package log.");        hr = VariableSetString(pVariables, fRollback ? pPackage->sczRollbackLogPathVariable : pPackage->sczLogPathVariable, sczLogPath, FALSE);        ExitOnFailure(hr, "Failed to set log path into variable.");        if (psczLogPath)        {            hr = StrAllocString(psczLogPath, sczLogPath, 0);            ExitOnFailure(hr, "Failed to copy package log path.");        }    }LExit:    ReleaseStr(sczLogPath);    return hr;}