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

DAPI_(HRESULT) PathDirectoryContainsPath(    __in_z LPCWSTR wzDirectory,    __in_z LPCWSTR wzPath    ){    HRESULT hr = S_OK;    LPWSTR sczPath = NULL;    LPWSTR sczDirectory = NULL;    LPWSTR sczOriginalPath = NULL;    LPWSTR sczOriginalDirectory = NULL;    hr = PathCanonicalizePath(wzPath, &sczOriginalPath);    ExitOnFailure(hr, "Failed to canonicalize the path.");    hr = PathCanonicalizePath(wzDirectory, &sczOriginalDirectory);    ExitOnFailure(hr, "Failed to canonicalize the directory.");    if (!sczOriginalPath || !*sczOriginalPath)    {        ExitFunction1(hr = S_FALSE);    }    if (!sczOriginalDirectory || !*sczOriginalDirectory)    {        ExitFunction1(hr = S_FALSE);    }    sczPath = sczOriginalPath;    sczDirectory = sczOriginalDirectory;    for (; *sczDirectory;)    {        if (!*sczPath)        {            ExitFunction1(hr = S_FALSE);        }        if (CSTR_EQUAL != ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, sczDirectory, 1, sczPath, 1))        {            ExitFunction1(hr = S_FALSE);        }        ++sczDirectory;        ++sczPath;    }    --sczDirectory;    if (('//' == *sczDirectory && *sczPath) || '//' == *sczPath)    {        hr = S_OK;    }    else    {        hr = S_FALSE;    }LExit:    ReleaseStr(sczOriginalPath);    ReleaseStr(sczOriginalDirectory);    return hr;}

static HRESULT ReadFileAll(	HANDLE hFile,	PBYTE pbBuffer,	DWORD dwBufferLength	){	HRESULT hr = S_OK;	DWORD dwBytesRead;	while (dwBufferLength)	{		if (!::ReadFile(hFile, pbBuffer, dwBufferLength, &dwBytesRead, NULL))			ExitFunction1(hr = HRESULT_FROM_WIN32(::GetLastError()));		if (0 == dwBytesRead)			ExitFunction1(hr = HRESULT_FROM_WIN32(ERROR_HANDLE_EOF));		dwBufferLength -= dwBytesRead;		pbBuffer += dwBytesRead;	}	hr = S_OK;LExit:	return hr;}

extern "C" HRESULT DAPI PolcReadNumber(    __in_z LPCWSTR wzPolicyPath,    __in_z LPCWSTR wzPolicyName,    __in DWORD dwDefault,    __out DWORD* pdw    ){    HRESULT hr = S_OK;    HKEY hk = NULL;    hr = OpenPolicyKey(wzPolicyPath, &hk);    if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)    {        ExitFunction1(hr = S_FALSE);    }    ExitOnFailure1(hr, "Failed to open policy key: %ls", wzPolicyPath);    hr = RegReadNumber(hk, wzPolicyName, pdw);    if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)    {        ExitFunction1(hr = S_FALSE);    }    ExitOnFailure2(hr, "Failed to open policy key: %ls, name: %ls", wzPolicyPath, wzPolicyName);LExit:    ReleaseRegKey(hk);    if (S_FALSE == hr || FAILED(hr))    {        *pdw = dwDefault;    }    return hr;}

/****************************************************************** 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;}

HRESULT CpiReadRollbackDataList(	HANDLE hFile,	CPI_ROLLBACK_DATA** pprdList	){	HRESULT hr = S_OK;	int iCount;	CPI_ROLLBACK_DATA* pItm = NULL;	// read count	hr = ReadFileAll(hFile, (PBYTE)&iCount, sizeof(int));	if (HRESULT_FROM_WIN32(ERROR_HANDLE_EOF) == hr)		ExitFunction1(hr = S_OK); // EOF reached, nothing left to read	ExitOnFailure(hr, "Failed to read count");	for (int i = 0; i < iCount; i++)	{		// allocate new element		pItm = (CPI_ROLLBACK_DATA*)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CPI_ROLLBACK_DATA));		if (!pItm)			ExitFunction1(hr = E_OUTOFMEMORY);		// read from file		hr = ReadFileAll(hFile, (PBYTE)pItm->wzKey, MAX_DARWIN_KEY * sizeof(WCHAR));		if (HRESULT_FROM_WIN32(ERROR_HANDLE_EOF) == hr)			break; // EOF reached, nothing left to read		ExitOnFailure(hr, "Failed to read key");		hr = ReadFileAll(hFile, (PBYTE)&pItm->iStatus, sizeof(int));		if (HRESULT_FROM_WIN32(ERROR_HANDLE_EOF) == hr)			pItm->iStatus = 0; // EOF reached, the operation was interupted; set status to zero		else			ExitOnFailure(hr, "Failed to read status");		// add to list		if (*pprdList)			pItm->pNext = *pprdList;		*pprdList = pItm;		pItm = NULL;	}	hr = S_OK;LExit:	// clean up	if (pItm)		CpiFreeRollbackDataList(pItm);	return hr;}

static HRESULT RemoveApplicationRole(    CPI_APPLICATION_ROLE_ATTRIBUTES* pAttrs    ){    HRESULT hr = S_OK;    ICatalogCollection* piRolesColl = NULL;    long lChanges = 0;    // log    WcaLog(LOGMSG_VERBOSE, "Removing application role, key: %S", pAttrs->pwzKey);    // get roles collection    hr = CpiGetRolesCollection(pAttrs->pwzPartID, pAttrs->pwzAppID, &piRolesColl);    ExitOnFailure(hr, "Failed to get roles collection");    if (S_FALSE == hr)    {        // roles collection not found        WcaLog(LOGMSG_VERBOSE, "Unable to retrieve roles collection, nothing to delete, key: %S", pAttrs->pwzKey);        ExitFunction1(hr = S_OK);    }    // remove    hr = CpiRemoveCollectionObject(piRolesColl, NULL, pAttrs->pwzName, FALSE);    ExitOnFailure(hr, "Failed to remove role");    if (S_FALSE == hr)    {        // role not found        WcaLog(LOGMSG_VERBOSE, "Role not found, nothing to delete, key: %S", pAttrs->pwzKey);        ExitFunction1(hr = S_OK);    }    // save changes    hr = piRolesColl->SaveChanges(&lChanges);    if (COMADMIN_E_OBJECTERRORS == hr)        CpiLogCatalogErrorInfo();    ExitOnFailure(hr, "Failed to save changes");    // log    WcaLog(LOGMSG_VERBOSE, "%d changes saved to catalog, key: %S", lChanges, pAttrs->pwzKey);    hr = S_OK;LExit:    // clean up    ReleaseObject(piRolesColl);    return hr;}

DAPI_(HRESULT) SrpCreateRestorePoint(    __in_z LPCWSTR wzApplicationName,    __in SRP_ACTION action    ){    HRESULT hr = S_OK;    RESTOREPOINTINFOW restorePoint = { };    STATEMGRSTATUS status = { };    if (!vpfnSRSetRestorePointW)    {        ExitFunction1(hr = E_NOTIMPL);    }    restorePoint.dwEventType = BEGIN_SYSTEM_CHANGE;    restorePoint.dwRestorePtType = (SRP_ACTION_INSTALL == action) ? APPLICATION_INSTALL : (SRP_ACTION_UNINSTALL == action) ? APPLICATION_UNINSTALL : MODIFY_SETTINGS;    ::StringCbCopyW(restorePoint.szDescription, sizeof(restorePoint.szDescription), wzApplicationName);    if (!vpfnSRSetRestorePointW(&restorePoint, &status))    {        ExitOnWin32Error(status.nStatus, hr, "Failed to create system restore point.");    }LExit:    return hr;}

extern "C" HRESULT ApprovedExesFindById(    __in BURN_APPROVED_EXES* pApprovedExes,    __in_z LPCWSTR wzId,    __out BURN_APPROVED_EXE** ppApprovedExe    ){    HRESULT hr = S_OK;    BURN_APPROVED_EXE* pApprovedExe = NULL;    for (DWORD i = 0; i < pApprovedExes->cApprovedExes; ++i)    {        pApprovedExe = &pApprovedExes->rgApprovedExes[i];        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pApprovedExe->sczId, -1, wzId, -1))        {            *ppApprovedExe = pApprovedExe;            ExitFunction1(hr = S_OK);        }    }    hr = E_NOTFOUND;LExit:    return hr;}

/********************************************************************StrMaxLength - returns maximum number of characters that can be stored in dynamic string pNOTE:  assumes Unicode string********************************************************************/extern "C" HRESULT DAPI StrMaxLength(	__in LPVOID p,	__out DWORD_PTR* pcch	){	Assert(pcch);	HRESULT hr = S_OK;	if (p)	{		*pcch = MemSize(p);   // get size of entire buffer		if (-1 == *pcch)		{			ExitFunction1(hr = E_FAIL);		}		*pcch /= sizeof(WCHAR);   // reduce to count of characters	}	else	{		*pcch = 0;	}	Assert(S_OK == hr);LExit:	return hr;}

/********************************************************************ConfigureSmb - CUSTOM ACTION ENTRY POINT for installing fileshare settings********************************************************************/extern "C" UINT __stdcall ConfigureSmbUninstall(    __in MSIHANDLE hInstall    ){    HRESULT hr = S_OK;    UINT er = ERROR_SUCCESS;    SCA_SMB* pssList = NULL;    // initialize    hr = WcaInitialize(hInstall, "ConfigureSmbUninstall");    ExitOnFailure(hr, "Failed to initialize");    // check to see if necessary tables are specified    if (WcaTableExists(L"FileShare") != S_OK)    {        WcaLog(LOGMSG_VERBOSE, "Skipping SMB CustomAction, no FileShare table");        ExitFunction1(hr = S_FALSE);    }    hr = ScaSmbRead(&pssList);    ExitOnFailure(hr, "failed to read FileShare table");    hr = ScaSmbUninstall(pssList);    ExitOnFailure(hr, "failed to uninstall FileShares");LExit:    if (pssList)        ScaSmbFreeList(pssList);    er = SUCCEEDED(hr) ? ERROR_SUCCESS : ERROR_INSTALL_FAILURE;    return WcaFinalize(er);}

static HRESULT FindEmbeddedBySourcePath(    __in BURN_PAYLOADS* pPayloads,    __in_opt BURN_CONTAINER* pContainer,    __in_z LPCWSTR wzStreamName,    __out BURN_PAYLOAD** ppPayload    ){    HRESULT hr = S_OK;    for (DWORD i = 0; i < pPayloads->cPayloads; ++i)    {        BURN_PAYLOAD* pPayload = &pPayloads->rgPayloads[i];        if (BURN_PAYLOAD_PACKAGING_EMBEDDED == pPayload->packaging && (!pContainer || pPayload->pContainer == pContainer))        {            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pPayload->sczSourcePath, -1, wzStreamName, -1))            {                *ppPayload = pPayload;                ExitFunction1(hr = S_OK);            }        }    }    hr = E_NOTFOUND;LExit:    return hr;}

extern "C" HRESULT PayloadFindEmbeddedBySourcePath(    __in BURN_PAYLOADS* pPayloads,    __in_z LPCWSTR wzStreamName,    __out BURN_PAYLOAD** ppPayload    ){    HRESULT hr = S_OK;    BURN_PAYLOAD* pPayload = NULL;    for (DWORD i = 0; i < pPayloads->cPayloads; ++i)    {        pPayload = &pPayloads->rgPayloads[i];        if (BURN_PAYLOAD_PACKAGING_EMBEDDED == pPayload->packaging)        {            if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pPayload->sczSourcePath, -1, wzStreamName, -1))            {                *ppPayload = pPayload;                ExitFunction1(hr = S_OK);            }        }    }    hr = E_NOTFOUND;LExit:    return hr;}

extern "C" HRESULT PayloadFindById(    __in BURN_PAYLOADS* pPayloads,    __in_z LPCWSTR wzId,    __out BURN_PAYLOAD** ppPayload    ){    HRESULT hr = S_OK;    BURN_PAYLOAD* pPayload = NULL;    for (DWORD i = 0; i < pPayloads->cPayloads; ++i)    {        pPayload = &pPayloads->rgPayloads[i];        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pPayload->sczKey, -1, wzId, -1))        {            *ppPayload = pPayload;            ExitFunction1(hr = S_OK);        }    }    hr = E_NOTFOUND;LExit:    return hr;}

/********************************************************************DetectWDDMDriver Set a property if the driver on the machine is a WDDM driver. One reliable way to detect the presence of a WDDM driver is to try and use the Direct3DCreate9Ex() function. This method attempts that then sets the property appropriately.********************************************************************/static HRESULT DetectWDDMDriver(){    HRESULT hr = S_OK;    HMODULE hModule = NULL;    // Manually load the d3d9.dll library. If the library couldn't be loaded then we obviously won't be able    // to try calling the function so just return.    hr = LoadSystemLibrary(L"d3d9.dll", &hModule);    if (E_MODNOTFOUND == hr)    {        TraceError(hr, "Unable to load DirectX APIs, skipping WDDM driver check.");        ExitFunction1(hr = S_OK);    }    ExitOnFailure(hr, "Failed to the load the existing DirectX APIs.");    // Obtain the address of the Direct3DCreate9Ex function. If this fails we know it isn't a WDDM    // driver so just exit.    const void* Direct3DCreate9ExPtr = ::GetProcAddress(hModule, "Direct3DCreate9Ex");    ExitOnNull(Direct3DCreate9ExPtr, hr, S_OK, "Unable to load Direct3DCreateEx function, so the driver is not a WDDM driver.");    // At this point we know it's a WDDM driver so set the property.    hr = WcaSetIntProperty(L"WIX_WDDM_DRIVER_PRESENT", 1);    ExitOnFailure(hr, "Failed write property");LExit:    if (NULL != hModule)    {        FreeLibrary(hModule);    }    return hr;}

extern "C" HRESULT DAPI LocGetControl(    __in const WIX_LOCALIZATION* pWixLoc,    __in_z LPCWSTR wzId,    __out LOC_CONTROL** ppLocControl    ){    HRESULT hr = S_OK;    LOC_CONTROL* pLocControl = NULL;    for (DWORD i = 0; i < pWixLoc->cLocControls; ++i)    {        pLocControl = &pWixLoc->rgLocControls[i];        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pLocControl->wzControl, -1, wzId, -1))        {            *ppLocControl = pLocControl;            ExitFunction1(hr = S_OK);        }    }    hr = E_NOTFOUND;LExit:    return hr;}

    virtual STDMETHODIMP QueryInterface(        __in const IID& riid,        __out void** ppvObject        )    {        HRESULT hr = S_OK;        ExitOnNull(ppvObject, hr, E_INVALIDARG, "Invalid argument ppvObject");        *ppvObject = NULL;        if (::IsEqualIID(__uuidof(IBackgroundCopyCallback), riid))        {            *ppvObject = static_cast<IBackgroundCopyCallback*>(this);        }        else if (::IsEqualIID(IID_IUnknown, riid))        {            *ppvObject = reinterpret_cast<IUnknown*>(this);        }        else // no interface for requested iid        {            ExitFunction1(hr = E_NOINTERFACE);        }        AddRef();    LExit:        return hr;    }

/******************************************************************** ScaDropSmb - delete this file share from this computer********************************************************************/HRESULT ScaDropSmb(SCA_SMBP* pssp){    HRESULT hr = S_OK;    NET_API_STATUS s;    hr = DoesShareExist(pssp->wzKey);    if (E_FILENOTFOUND == hr)    {        WcaLog(LOGMSG_VERBOSE, "Share doesn't exist, share removal skipped. (%ls)", pssp->wzKey);        ExitFunction1(hr = S_OK);    }    ExitOnFailure1(hr, "Unable to detect share. (%ls)", pssp->wzKey);    s = ::NetShareDel(NULL, pssp->wzKey, 0);    if (NERR_Success != s)    {        hr = E_FAIL;        ExitOnFailure1(hr, "Failed to remove file share: Err: %d", s);    }LExit:    return hr;}

/******************************************************************** RegValueEnum - enumerates a registry value.*********************************************************************/HRESULT DAPI RegValueEnum(    __in HKEY hk,    __in DWORD dwIndex,    __deref_out_z LPWSTR* psczName,    __out_opt DWORD *pdwType    ){    HRESULT hr = S_OK;    DWORD er = ERROR_SUCCESS;    DWORD cbValueName = 0;    er = vpfnRegQueryInfoKeyW(hk, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &cbValueName, NULL, NULL, NULL);    ExitOnWin32Error(er, hr, "Failed to get max size of value name under registry key.");    // Add one for null terminator    ++cbValueName;    hr = StrAlloc(psczName, cbValueName);    ExitOnFailure(hr, "Failed to allocate array for registry value name");    er = vpfnRegEnumValueW(hk, dwIndex, *psczName, &cbValueName, NULL, pdwType, NULL, NULL);    if (ERROR_NO_MORE_ITEMS == er)    {        ExitFunction1(hr = E_NOMOREITEMS);    }    ExitOnWin32Error(er, hr, "Failed to enumerate registry value");LExit:    return hr;}

extern "C" HRESULT CatalogFindById(    __in BURN_CATALOGS* pCatalogs,    __in_z LPCWSTR wzId,    __out BURN_CATALOG** ppCatalog    ){    HRESULT hr = S_OK;    BURN_CATALOG* pCatalog = NULL;    for (DWORD i = 0; i < pCatalogs->cCatalogs; ++i)    {        pCatalog = &pCatalogs->rgCatalogs[i];        if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, pCatalog->sczKey, -1, wzId, -1))        {            *ppCatalog = pCatalog;            ExitFunction1(hr = S_OK);        }    }    hr = E_NOTFOUND;LExit:    return hr;}

HRESULT CpiPartitionRolesRead(    CPI_PARTITION_LIST* pPartList,    CPI_PARTITION_ROLE_LIST* pPartRoleList    ){    HRESULT hr = S_OK;    PMSIHANDLE hView, hRec;    CPI_PARTITION_ROLE* pItm = NULL;    LPWSTR pwzData = NULL;    // loop through all application roles    hr = WcaOpenExecuteView(vcsPartitionRoleQuery, &hView);    ExitOnFailure(hr, "Failed to execute view on ComPlusPartitionRole table");    while (S_OK == (hr = WcaFetchRecord(hView, &hRec)))    {        // create entry        pItm = (CPI_PARTITION_ROLE*)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CPI_PARTITION_ROLE));        if (!pItm)            ExitFunction1(hr = E_OUTOFMEMORY);        // get key        hr = WcaGetRecordString(hRec, prqPartitionRole, &pwzData);        ExitOnFailure(hr, "Failed to get key");        StringCchCopyW(pItm->wzKey, countof(pItm->wzKey), pwzData);        // get partition        hr = WcaGetRecordString(hRec, prqPartition, &pwzData);        ExitOnFailure(hr, "Failed to get application");        hr = CpiPartitionFindByKey(pPartList, pwzData, &pItm->pPartition);        if (S_FALSE == hr)            hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);        ExitOnFailure1(hr, "Failed to find partition, key: %S", pwzData);        // get name        hr = WcaGetRecordFormattedString(hRec, prqName, &pwzData);        ExitOnFailure(hr, "Failed to get name");        StringCchCopyW(pItm->wzName, countof(pItm->wzName), pwzData);        // add entry        if (pPartRoleList->pFirst)            pItm->pNext = pPartRoleList->pFirst;        pPartRoleList->pFirst = pItm;        pItm = NULL;    }    if (E_NOMOREITEMS == hr)        hr = S_OK;LExit:    // clean up    if (pItm)        FreePartitionRole(pItm);    ReleaseStr(pwzData);    return hr;}

HRESULT HandleEnsureSummaryDataTable(    __in CFGDB_STRUCT *pcdb    ){    HRESULT hr = S_OK;    BOOL fInSceTransaction = FALSE;    BOOL fEmpty = FALSE;    SCE_ROW_HANDLE sceRow = NULL;    hr = SceGetFirstRow(pcdb->psceDb, SUMMARY_DATA_TABLE, &sceRow);    if (E_NOTFOUND == hr)    {        fEmpty = TRUE;        hr = S_OK;    }    ExitOnFailure(hr, "Failed to get first row of summary data table");    if (fEmpty)    {        hr = GuidCreate(&pcdb->sczGuid);        ExitOnRootFailure(hr, "Failed to generate guid string");        hr = SceBeginTransaction(pcdb->psceDb);        ExitOnFailure(hr, "Failed to begin transaction");        fInSceTransaction = TRUE;        hr = ScePrepareInsert(pcdb->psceDb, SUMMARY_DATA_TABLE, &sceRow);        ExitOnFailure(hr, "Failed to prepare for insert");        hr = SceSetColumnString(sceRow, SUMMARY_GUID, pcdb->sczGuid);        ExitOnFailure(hr, "Failed to set column string of summary data table guid");        hr = SceFinishUpdate(sceRow);        ExitOnFailure(hr, "Failed to finish insert into summary data table");        hr = SceCommitTransaction(pcdb->psceDb);        ExitOnFailure(hr, "Failed to commit transaction");        fInSceTransaction = FALSE;        ExitFunction1(hr = S_OK);    }    ExitOnFailure(hr, "Failed to move to first row in SummaryData table");    hr = SceGetColumnString(sceRow, SUMMARY_GUID, &pcdb->sczGuid);    ExitOnFailure(hr, "Failed to get GUID from summary data table");LExit:    ReleaseSceRow(sceRow);    if (fInSceTransaction)    {        SceRollbackTransaction(pcdb->psceDb);    }    if (FAILED(hr))    {        ReleaseNullStr(pcdb->sczGuid);    }    return hr;}

HRESULT ScaWebAppExtensionsWrite7(    __in_z LPCWSTR wzWebName,    __in_z LPCWSTR wzRootOfWeb,    __in SCA_WEB_APPLICATION_EXTENSION* pswappextList    ){    HRESULT hr = S_OK;    SCA_WEB_APPLICATION_EXTENSION* pswappext = NULL;    if (!pswappextList)    {        ExitFunction1(hr = S_OK);    }    //create the Extension for this vdir application    //all go to same web/root location tag    hr = ScaWriteConfigID(IIS_APPEXT_BEGIN);    ExitOnFailure(hr, "Failed to write webappext begin id");    hr = ScaWriteConfigString(wzWebName);                //site name key    ExitOnFailure(hr, "Failed to write app web key");    hr = ScaWriteConfigString(wzRootOfWeb);               //app path key    ExitOnFailure(hr, "Failed to write app web key");    pswappext = pswappextList;    while (pswappext)    {        //create the Extension for this vdir application        hr = ScaWriteConfigID(IIS_APPEXT);        ExitOnFailure(hr, "Failed to write webappext begin id");        if (*pswappext->wzExtension)        {            hr = ScaWriteConfigString(pswappext->wzExtension);        }        else   // blank means "*" (all)        {            hr = ScaWriteConfigString(L"*");        }        ExitOnFailure(hr, "Failed to write extension");        hr = ScaWriteConfigString(pswappext->wzExecutable);        ExitOnFailure(hr, "Failed to write extension executable");        hr = ScaWriteConfigString(pswappext->wzVerbs);        ExitOnFailure(hr, "Failed to write extension verbs");        pswappext = pswappext->pswappextNext;    }    hr = ScaWriteConfigID(IIS_APPEXT_END);    ExitOnFailure(hr, "Failed to write webappext begin id");LExit:    return hr;}

DAPI_(HRESULT) BalInfoAddRelatedBundleAsPackage(    __in BAL_INFO_PACKAGES* pPackages,    __in LPCWSTR wzId,    __in BOOTSTRAPPER_RELATION_TYPE relationType,    __in BOOL /*fPerMachine*/    ){    HRESULT hr = S_OK;    BAL_INFO_PACKAGE_TYPE type = BAL_INFO_PACKAGE_TYPE_UNKNOWN;    BAL_INFO_PACKAGE* pPackage = NULL;    // Ensure we have a supported relation type.    switch (relationType)    {    case BOOTSTRAPPER_RELATION_ADDON:        type = BAL_INFO_PACKAGE_TYPE_BUNDLE_ADDON;        break;    case BOOTSTRAPPER_RELATION_PATCH:        type = BAL_INFO_PACKAGE_TYPE_BUNDLE_PATCH;        break;    case BOOTSTRAPPER_RELATION_UPGRADE:        type = BAL_INFO_PACKAGE_TYPE_BUNDLE_UPGRADE;        break;    default:        ExitOnFailure1(hr = E_INVALIDARG, "Unknown related bundle type: %u", relationType);    }    // Check to see if the bundle is already in the list of packages.    for (DWORD i = 0; i < pPackages->cPackages; ++i)    {        if (CSTR_EQUAL == ::CompareStringW(LOCALE_NEUTRAL, 0, wzId, -1, pPackages->rgPackages[i].sczId, -1))        {            ExitFunction1(hr = HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS));        }    }    // Add the related bundle as a package.    hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pPackages->rgPackages), pPackages->cPackages + 1, sizeof(BAL_INFO_PACKAGE), 2);    ExitOnFailure(hr, "Failed to allocate memory for related bundle package information.");    pPackage = pPackages->rgPackages + pPackages->cPackages;    ++pPackages->cPackages;    hr = StrAllocString(&pPackage->sczId, wzId, 0);    ExitOnFailure(hr, "Failed to copy related bundle package id.");    pPackage->type = type;    // TODO: try to look up the DisplayName and Description in Add/Remove Programs with the wzId.LExit:    return hr;}

static HRESULT ConfigureSqlData(    __in SCA_ACTION saAction    ){    //AssertSz(FALSE, "debug ConfigureSqlData()");    HRESULT hr = S_OK;    SCA_DB* psdList = NULL;    SCA_SQLSTR* psssList = NULL;    // check for the prerequsite tables    if (S_OK != WcaTableExists(L"SqlDatabase"))    {        WcaLog(LOGMSG_VERBOSE, "skipping SQL CustomAction, no SqlDatabase table");        ExitFunction1(hr = S_FALSE);    }    // read tables    hr = ScaDbsRead(&psdList, saAction);    ExitOnFailure(hr, "failed to read SqlDatabase table");    hr = ScaSqlStrsRead(&psssList, saAction);    ExitOnFailure(hr, "failed to read SqlStrings table");    hr = ScaSqlStrsReadScripts(&psssList, saAction);    ExitOnFailure(hr, "failed to read SqlScripts table");    if (SCA_ACTION_UNINSTALL == saAction)    {        // do uninstall actions (order is important!)        hr = ScaSqlStrsUninstall(psdList, psssList);        ExitOnFailure(hr, "failed to execute uninstall SQL strings");        hr = ScaDbsUninstall(psdList);        ExitOnFailure(hr, "failed to uninstall databases");    }    else    {        // do install actions (order is important!)        hr = ScaDbsInstall(psdList);        ExitOnFailure(hr, "failed to install databases");        hr = ScaSqlStrsInstall(psdList, psssList);        ExitOnFailure(hr, "failed to execute install SQL strings, length may be too long, try add GO to break up");    }LExit:    if (psssList)        ScaSqlStrsFreeList(psssList);    if (psdList)        ScaDbsFreeList(psdList);    return hr;}

HRESULT CpiReadPropertyList(	LPWSTR* ppwzData,	CPI_PROPERTY** ppPropList	){	HRESULT hr = S_OK;	CPI_PROPERTY* pItm = NULL;	LPWSTR pwzName = NULL;	// clear list if it already contains items	if (*ppPropList)		CpiFreePropertyList(*ppPropList);	*ppPropList = NULL;	// read property count	int iPropCnt = 0;	hr = WcaReadIntegerFromCaData(ppwzData, &iPropCnt);	ExitOnFailure(hr, "Failed to read property count");	for (int i = 0; i < iPropCnt; i++)	{		// allocate new element		pItm = (CPI_PROPERTY*)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CPI_PROPERTY));		if (!pItm)			ExitFunction1(hr = E_OUTOFMEMORY);		// Name		hr = WcaReadStringFromCaData(ppwzData, &pwzName);		ExitOnFailure(hr, "Failed to read name");		StringCchCopyW(pItm->wzName, countof(pItm->wzName), pwzName);		// Value		hr = WcaReadStringFromCaData(ppwzData, &pItm->pwzValue);		ExitOnFailure(hr, "Failed to read property value");		// add to list		if (*ppPropList)			pItm->pNext = *ppPropList;		*ppPropList = pItm;		pItm = NULL;	}	hr = S_OK;LExit:	// clean up	ReleaseStr(pwzName);	if (pItm)		CpiFreePropertyList(pItm);	return hr;}

extern "C" HRESULT DAPI PolcReadString(    __in_z LPCWSTR wzPolicyPath,    __in_z LPCWSTR wzPolicyName,    __in_z_opt LPCWSTR wzDefault,    __deref_out_z LPWSTR* pscz    ){    HRESULT hr = S_OK;    HKEY hk = NULL;    hr = OpenPolicyKey(wzPolicyPath, &hk);    if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)    {        ExitFunction1(hr = S_FALSE);    }    ExitOnFailure1(hr, "Failed to open policy key: %ls", wzPolicyPath);    hr = RegReadString(hk, wzPolicyName, pscz);    if (E_FILENOTFOUND == hr || E_PATHNOTFOUND == hr)    {        ExitFunction1(hr = S_FALSE);    }    ExitOnFailure2(hr, "Failed to open policy key: %ls, name: %ls", wzPolicyPath, wzPolicyName);LExit:    ReleaseRegKey(hk);    if (S_FALSE == hr || FAILED(hr))    {        if (NULL == wzDefault)        {            ReleaseNullStr(*pscz);        }        else        {            hr = StrAllocString(pscz, wzDefault, 0);        }    }    return hr;}

/******************************************************************** RegKeyEnum - enumerates a registry key.*********************************************************************/extern "C" HRESULT DAPI RegKeyEnum(    __in HKEY hk,    __in DWORD dwIndex,    __deref_out_z LPWSTR* psczKey    ){    HRESULT hr = S_OK;    DWORD er = ERROR_SUCCESS;    DWORD cch = 0;    if (psczKey && *psczKey)    {        hr = StrMaxLength(*psczKey, reinterpret_cast<DWORD_PTR*>(&cch));        ExitOnFailure(hr, "Failed to determine length of string.");    }    if (2 > cch)    {        cch = 2;        hr = StrAlloc(psczKey, cch);        ExitOnFailure(hr, "Failed to allocate string to minimum size.");    }    er = vpfnRegEnumKeyExW(hk, dwIndex, *psczKey, &cch, NULL, NULL, NULL, NULL);    if (ERROR_MORE_DATA == er)    {        er = vpfnRegQueryInfoKeyW(hk, NULL, NULL, NULL, NULL, &cch, NULL, NULL, NULL, NULL, NULL, NULL);        ExitOnWin32Error(er, hr, "Failed to get max size of subkey name under registry key.");        ++cch; // add one because RegQueryInfoKeyW() returns the length of the subkeys without the null terminator.        hr = StrAlloc(psczKey, cch);        ExitOnFailure(hr, "Failed to allocate string bigger for enum registry key.");        er = vpfnRegEnumKeyExW(hk, dwIndex, *psczKey, &cch, NULL, NULL, NULL, NULL);    }    else if (ERROR_NO_MORE_ITEMS == er)    {        ExitFunction1(hr = E_NOMOREITEMS);    }    ExitOnWin32Error(er, hr, "Failed to enum registry key.");    // Always ensure the registry key name is null terminated.#pragma prefast(push)#pragma prefast(disable:26018)    (*psczKey)[cch] = L'/0'; // note that cch will always be one less than the size of the buffer because that's how RegEnumKeyExW() works.#pragma prefast(pop)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;}

/******************************************************************* DirEnsureExists*******************************************************************/extern "C" HRESULT DAPI DirEnsureExists(	__in LPCWSTR wzPath,	__in_opt LPSECURITY_ATTRIBUTES psa	){	HRESULT hr = S_OK;	UINT er;	// try to create this directory	if (!::CreateDirectoryW(wzPath, psa))	{		// if the directory already exists, bail		er = ::GetLastError();		if (ERROR_ALREADY_EXISTS == er)			ExitFunction1(hr = S_OK);		// get the parent path and try to create it		LPWSTR pwzLastSlash = NULL;		for (LPWSTR pwz = const_cast<LPWSTR>(wzPath); *pwz; pwz++)			if (*pwz == L'//')				pwzLastSlash = pwz;		// if there is no parent directory fail		ExitOnNullDebugTrace(pwzLastSlash, hr, HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "cannot find parent path");		*pwzLastSlash = L'/0';	// null terminate the parent path		hr = DirEnsureExists(wzPath, psa);   // recurse!		*pwzLastSlash = L'//';  // put the slash back		ExitOnFailureDebugTrace1(hr, "failed to create path: %S", wzPath);		// try to create the directory now that all parents are created		if (!::CreateDirectoryW(wzPath, psa))		{			// if the directory already exists for some reason no error			er = ::GetLastError();			if (ERROR_ALREADY_EXISTS == er)				hr = S_FALSE;			else				hr = HRESULT_FROM_WIN32(er);		}		else			hr = S_OK;	}LExit:	return hr;}