HRESULT ScaDbsUninstall(
__in SCA_DB* psdList
)
{
HRESULT hr = S_FALSE; // assume nothing will be done
SCA_DB* psd = NULL;
for (psd = psdList; psd; psd = psd->psdNext)
{
if (psd->fHasComponent)
{
// if we need to drop do that first
if ((psd->iAttributes & SCADB_DROP_ON_UNINSTALL) && WcaIsUninstalling(psd->isInstalled, psd->isAction))
{
hr = SchedDropDatabase(psd->wzKey, psd->wzServer, psd->wzInstance, psd->wzDatabase, psd->iAttributes, psd->fUseIntegratedAuth, psd->scau.wzName, psd->scau.wzPassword);
ExitOnFailure1(hr, "Failed to drop database %ls", psd->wzKey);
}
// install the db
if ((psd->iAttributes & SCADB_CREATE_ON_UNINSTALL) && WcaIsUninstalling(psd->isInstalled, psd->isAction))
{
hr = SchedCreateDatabase(psd);
ExitOnFailure1(hr, "Failed to ensure database %ls exists", psd->wzKey);
}
}
}
LExit:
return hr;
}
HRESULT CpiApplicationRolesVerifyUninstall(
CPI_APPLICATION_ROLE_LIST* pList
)
{
HRESULT hr = S_OK;
for (CPI_APPLICATION_ROLE* pItm = pList->pFirst; pItm; pItm = pItm->pNext)
{
// referenced locaters or roles that are being installed
if (!pItm->fReferencedForUninstall && !(pItm->fHasComponent && WcaIsUninstalling(pItm->isInstalled, pItm->isAction)))
continue;
// get collection object for role
hr = FindObjectForApplicationRole(pItm, NULL);
ExitOnFailure(hr, "Failed to find collection object for role");
// if the role was not found
if (S_FALSE == hr)
{
pItm->fObjectNotFound = TRUE;
if (pItm->fHasComponent)
pList->iUninstallCount--; // elements with the fObjectNotFound flag set will not be scheduled for uninstall
}
}
hr = S_OK;
LExit:
return hr;
}
HRESULT ScaVirtualDirsUninstall(
__in IMSAdminBase* piMetabase,
__in SCA_VDIR* psvdList
)
{
Assert(piMetabase);
HRESULT hr = S_OK;
SCA_VDIR* psvd = psvdList;
while (psvd)
{
if (WcaIsUninstalling(psvd->isInstalled, psvd->isAction))
{
// delete the application for this virtual directory
if (psvd->fHasApplication)
{
hr = ScaDeleteApp(piMetabase, psvd->wzVDirRoot);
ExitOnFailure(hr, "Failed to remove application for WebVDir");
}
if (0 != lstrlenW(psvd->wzVDirRoot))
{
hr = ScaDeleteMetabaseKey(piMetabase, psvd->wzVDirRoot, L"");
ExitOnFailure1(hr, "Failed to remove VirtualDir '%ls' from metabase", psvd->wzKey);
}
}
psvd = psvd->psvdNext;
}
LExit:
return hr;
}
HRESULT MqiMessageQueueUninstall(
MQI_MESSAGE_QUEUE_LIST* pList,
BOOL fRollback,
LPWSTR* ppwzActionData
)
{
HRESULT hr = S_OK;
// add count to action data
hr = WcaWriteIntegerToCaData(pList->iUninstallCount, ppwzActionData);
ExitOnFailure(hr, "Failed to add count to custom action data");
for (MQI_MESSAGE_QUEUE* pItm = pList->pFirst; pItm; pItm = pItm->pNext)
{
// queues that are being uninstalled only
if (!WcaIsUninstalling(pItm->isInstalled, pItm->isAction))
continue;
// if we did not create the queue we should not try to delete it
if (pItm->fExists && fRollback)
{
continue;
}
// add message queue to action data
hr = AddMessageQueueToActionData(pItm, ppwzActionData);
ExitOnFailure(hr, "Failed to add message queue to action data");
}
hr = S_OK;
LExit:
return hr;
}
/********************************************************************
WcaGetComponentToDo() - gets a component's install states and
determines if they mean install, uninstall, or reinstall.
********************************************************************/
extern "C" WCA_TODO WIXAPI WcaGetComponentToDo(
__in_z LPCWSTR wzComponentId
)
{
INSTALLSTATE isInstalled = INSTALLSTATE_UNKNOWN;
INSTALLSTATE isAction = INSTALLSTATE_UNKNOWN;
if (ERROR_SUCCESS != ::MsiGetComponentStateW(WcaGetInstallHandle(), wzComponentId, &isInstalled, &isAction))
{
return WCA_TODO_UNKNOWN;
}
if (WcaIsReInstalling(isInstalled, isAction))
{
return WCA_TODO_REINSTALL;
}
else if (WcaIsUninstalling(isInstalled, isAction))
{
return WCA_TODO_UNINSTALL;
}
else if (WcaIsInstalling(isInstalled, isAction))
{
return WCA_TODO_INSTALL;
}
else
{
return WCA_TODO_UNKNOWN;
}
}
HRESULT ScaWebDirsUninstall(IMSAdminBase* piMetabase, SCA_WEBDIR* pswdList)
{
Assert(piMetabase);
HRESULT hr = S_OK;
SCA_WEBDIR* pswd = pswdList;
while (pswd)
{
if (WcaIsUninstalling(pswd->isInstalled, pswd->isAction))
{
// remove the application from this web directory
if (pswd->fHasApplication)
{
hr = ScaDeleteApp(piMetabase, pswd->wzWebDirRoot);
ExitOnFailure(hr, "Failed to remove application for WebDir");
}
hr = ScaDeleteMetabaseKey(piMetabase, pswd->wzWebDirRoot, L"");
ExitOnFailure1(hr, "Failed to remove WebDir '%ls' from metabase", pswd->wzKey);
}
pswd = pswd->pswdNext;
}
LExit:
return hr;
}
HRESULT MqiMessageQueuePermissionUninstall(
MQI_MESSAGE_QUEUE_PERMISSION_LIST* pList,
LPWSTR* ppwzActionData
)
{
HRESULT hr = S_OK;
// add count to action data
hr = WcaWriteIntegerToCaData(pList->iUninstallCount, ppwzActionData);
ExitOnFailure(hr, "Failed to add count to custom action data");
for (MQI_MESSAGE_QUEUE_PERMISSION* pItm = pList->pFirst; pItm; pItm = pItm->pNext)
{
// queue permissions that are being uninstalled only
if (!WcaIsUninstalling(pItm->isInstalled, pItm->isAction))
continue;
// add message queue permission to action data
hr = AddMessageQueuePermissionToActionData(pItm, ppwzActionData);
ExitOnFailure(hr, "Failed to add message queue permission to action data");
}
hr = S_OK;
LExit:
return hr;
}
BOOL CpiWillBeInstalled(
INSTALLSTATE isInstalled,
INSTALLSTATE isAction
)
{
return WcaIsInstalling(isInstalled, isAction) ||
(CpiIsInstalled(isInstalled) && !WcaIsUninstalling(isInstalled, isAction));
}
HRESULT ScaVirtualDirsUninstall7(
__in SCA_VDIR7* psvdList
)
{
HRESULT hr = S_OK;
SCA_VDIR7* psvd = psvdList;
LPWSTR wzPath = NULL;
while (psvd)
{
if (WcaIsUninstalling(psvd->isInstalled, psvd->isAction))
{
//init path
hr = StrAllocFormatted(&wzPath, L"/%s", psvd->wzVDirRoot);
ExitOnFailure(hr, "Failed to create vdir path");
if (psvd->fHasApplication)
{
//delete Application
hr = ScaWriteConfigID(IIS_APPLICATION);
ExitOnFailure(hr, "Failed to write app ID ");
hr = ScaWriteConfigID(IIS_DELETE);
ExitOnFailure(hr, "Failed to write delete app ID ");
#pragma prefast(suppress:26037, "Source string is null terminated - it is populated as target of ::StringCchCopyW")
hr = ScaWriteConfigString(psvd->wzWebName); //site name key
ExitOnFailure(hr, "Failed to write App site Name");
#pragma prefast(suppress:26037, "Source string is null terminated - it is populated as target of ::StringCchCopyW")
hr = ScaWriteConfigString(wzPath); // App Path
ExitOnFailure(hr, "Failed to write app path root ");
hr = ScaWriteConfigString(L"NOP"); // App pool
ExitOnFailure(hr, "Failed to write app path app pool ");
}
else
{
//delete VDir
hr = ScaWriteConfigID(IIS_VDIR);
ExitOnFailure(hr, "Failed to write vDir ID ");
hr = ScaWriteConfigID(IIS_DELETE);
#pragma prefast(suppress:26037, "Source string is null terminated - it is populated as target of ::StringCchCopyW")
hr = ScaWriteConfigString(psvd->wzWebName); //site name key
ExitOnFailure(hr, "Failed to write App site Name");
hr = ScaWriteConfigString(wzPath); // Vdir Path
ExitOnFailure(hr, "Failed to write app vdir ");
hr = ScaWriteConfigString(L"NOP"); // Phy Path
ExitOnFailure(hr, "Failed to write vdir path");
}
ExitOnFailure(hr, "Failed to remove VirtualDir '%ls' from config", psvd->wzKey);
}
psvd = psvd->psvdNext;
}
LExit:
ReleaseStr(wzPath);
return hr;
}
HRESULT CpiPartitionsVerifyUninstall(
CPI_PARTITION_LIST* pList
)
{
HRESULT hr = S_OK;
ICatalogCollection* piPartColl = NULL;
ICatalogObject* piPartObj = NULL;
for (CPI_PARTITION* pItm = pList->pFirst; pItm; pItm = pItm->pNext)
{
// referenced locaters or partitions that are being uninstalled
if (!pItm->fReferencedForUninstall && !(pItm->fHasComponent && WcaIsUninstalling(pItm->isInstalled, pItm->isAction)))
continue;
// get partitions collection
if (!piPartColl)
{
hr = CpiGetPartitionsCollection(&piPartColl);
ExitOnFailure(hr, "Failed to get partitions collection");
}
// get collection object for partition
hr = CpiFindCollectionObject(piPartColl, pItm->wzID, *pItm->wzID ? NULL : pItm->wzName, &piPartObj);
ExitOnFailure(hr, "Failed to find collection object for partition");
// if the partition was found
if (S_OK == hr)
{
// if we don't have an id, copy id from object
if (!*pItm->wzID)
{
hr = CpiGetKeyForObject(piPartObj, pItm->wzID, countof(pItm->wzID));
ExitOnFailure(hr, "Failed to get id");
}
}
// if the partition was not found
else
{
pItm->fObjectNotFound = TRUE;
if (pItm->fHasComponent)
pList->iUninstallCount--; // elements with the fObjectNotFound flag set will not be scheduled for uninstall
}
// clean up
ReleaseNullObject(piPartObj);
}
hr = S_OK;
LExit:
// clean up
ReleaseObject(piPartColl);
ReleaseObject(piPartObj);
return hr;
}
HRESULT CpiSubscriptionsVerifyUninstall(
CPI_SUBSCRIPTION_LIST* pList
)
{
HRESULT hr = S_OK;
UINT er = ERROR_SUCCESS;
ICatalogObject* piSubsObj = NULL;
for (CPI_SUBSCRIPTION* pItm = pList->pFirst; pItm; pItm = pItm->pNext)
{
// subscriptions that are being installed
if (!WcaIsUninstalling(pItm->isInstalled, pItm->isAction))
continue;
// find subscriptions with conflicting name
hr = FindObjectForSubscription(pItm, 0 != *pItm->wzID, 0 == *pItm->wzID, &piSubsObj);
ExitOnFailure(hr, "Failed to find collection object for subscription");
// if the subscription was found
if (S_OK == hr)
{
// if we don't have an id, copy id from object
if (!*pItm->wzID)
{
hr = CpiGetKeyForObject(piSubsObj, pItm->wzID, countof(pItm->wzID));
ExitOnFailure(hr, "Failed to get id");
}
}
// if the subscription was not found
else
{
pItm->fObjectNotFound = TRUE;
pList->iUninstallCount--; // elements with the fObjectNotFound flag set will not be scheduled for uninstall
}
// clean up
ReleaseNullObject(piSubsObj);
}
hr = S_OK;
LExit:
// clean up
ReleaseObject(piSubsObj);
return hr;
}
HRESULT CpiUsersInApplicationRolesUninstall(
CPI_USER_IN_APPLICATION_ROLE_LIST* pList,
int iRunMode,
LPWSTR* ppwzActionData,
int* piProgress
)
{
HRESULT hr = S_OK;
int iActionType;
// add action text
hr = CpiAddActionTextToActionData(L"RemoveUsersFromComPlusAppRoles", ppwzActionData);
ExitOnFailure(hr, "Failed to add action text to custom action data");
// add count to action data
hr = WcaWriteIntegerToCaData(pList->iUninstallCount, ppwzActionData);
ExitOnFailure(hr, "Failed to add count to custom action data");
// add roles to custom action data
for (CPI_USER_IN_APPLICATION_ROLE* pItm = pList->pFirst; pItm; pItm = pItm->pNext)
{
// roles that are being uninstalled only
if (!WcaIsUninstalling(pItm->isInstalled, pItm->isAction))
continue;
// action type
if (rmRollback == iRunMode)
iActionType = atCreate;
else
iActionType = atRemove;
// add to action data
hr = AddUserInApplicationRoleToActionData(pItm, iActionType, COST_USER_IN_APPLICATION_ROLE_DELETE, ppwzActionData);
ExitOnFailure1(hr, "Failed to add user in application role to custom action data, key: %S", pItm->wzKey);
}
// add progress tics
if (piProgress)
*piProgress += COST_USER_IN_APPLICATION_ROLE_DELETE * pList->iUninstallCount;
hr = S_OK;
LExit:
return hr;
}
HRESULT CpiPartitionUsersUninstall(
CPI_PARTITION_USER_LIST* pList,
int iRunMode,
LPWSTR* ppwzActionData,
int* piProgress
)
{
HRESULT hr = S_OK;
int iActionType;
// add action text
hr = CpiAddActionTextToActionData(L"RemoveComPlusPartitionUsers", ppwzActionData);
ExitOnFailure(hr, "Failed to add action text to custom action data");
// add partition count to action data
hr = WcaWriteIntegerToCaData(pList->iUninstallCount, ppwzActionData);
ExitOnFailure(hr, "Failed to add count to custom action data");
// add partitions to custom action data
for (CPI_PARTITION_USER* pItm = pList->pFirst; pItm; pItm = pItm->pNext)
{
// partitions that are being uninstalled only
if (!WcaIsUninstalling(pItm->isInstalled, pItm->isAction))
continue;
// action type
if (rmRollback == iRunMode)
iActionType = atCreate;
else
iActionType = atRemove;
// add to action data
hr = AddPartitionUserToActionData(pItm, iActionType, COST_PARTITION_USER_DELETE, ppwzActionData);
ExitOnFailure(hr, "Failed to add partition user to custom action data, key: %S", pItm->wzKey);
}
// add progress tics
if (piProgress)
*piProgress += COST_PARTITION_USER_DELETE * pList->iUninstallCount;
hr = S_OK;
LExit:
return hr;
}
HRESULT CpiSubscriptionsUninstall(
CPI_SUBSCRIPTION_LIST* pList,
int iRunMode,
LPWSTR* ppwzActionData,
int* piProgress
)
{
HRESULT hr = S_OK;
int iActionType;
// add action text
hr = CpiAddActionTextToActionData(L"RemoveSubscrComPlusComponents", ppwzActionData);
ExitOnFailure(hr, "Failed to add action text to custom action data");
// add subscription count to action data
hr = WcaWriteIntegerToCaData(pList->iUninstallCount, ppwzActionData);
ExitOnFailure(hr, "Failed to add count to custom action data");
// add assemblies to custom action data in reverse order
for (CPI_SUBSCRIPTION* pItm = pList->pFirst; pItm; pItm = pItm->pNext)
{
// roles that are being uninstalled only
if (pItm->fObjectNotFound || !WcaIsUninstalling(pItm->isInstalled, pItm->isAction))
continue;
// action type
if (rmRollback == iRunMode)
iActionType = atCreate;
else
iActionType = atRemove;
// add to action data
hr = AddSubscriptionToActionData(pItm, iActionType, COST_SUBSCRIPTION_DELETE, ppwzActionData);
ExitOnFailure1(hr, "Failed to add subscription to custom action data, key: %S", pItm->wzKey);
}
// add progress tics
if (piProgress)
*piProgress += COST_SUBSCRIPTION_DELETE * pList->iUninstallCount;
hr = S_OK;
LExit:
return hr;
}
HRESULT ScaPropertyUninstall(
IMSAdminBase* piMetabase,
SCA_PROPERTY* pspList
)
{
Assert(piMetabase);
HRESULT hr = S_OK;
for (SCA_PROPERTY* psp = pspList; psp; psp = psp->pspNext)
{
// if we are uninstalling the web site
if (WcaIsUninstalling(psp->isInstalled, psp->isAction))
{
hr = ScaRemoveProperty(piMetabase, psp);
ExitOnFailure1(hr, "Failed to remove Property '%ls' from metabase", psp->wzProperty);
}
}
LExit:
return hr;
}
HRESULT ScaFiltersUninstall(IMSAdminBase* piMetabase, SCA_FILTER* psfList)
{
HRESULT hr = S_OK;
SCA_FILTER* psf = psfList;
while (psf)
{
if (WcaIsUninstalling(psf->isInstalled, psf->isAction))
{
hr = ScaRemoveFilterFromLoadOrder(piMetabase, psf->wzFilterRoot, psf->wzKey);
ExitOnFailure1(hr, "Failed to remove filter '%S' from load order", psf->wzKey);
// remove the filter from the load order and remove the filter's key
hr = ScaDeleteMetabaseKey(piMetabase, psf->wzFilterRoot, psf->wzKey);
ExitOnFailure1(hr, "Failed to remove web '%S' from metabase", psf->wzKey);
}
psf = psf->psfNext;
}
LExit:
return hr;
}
HRESULT ScaVirtualDirsUninstall(
__in IMSAdminBase* piMetabase,
__in SCA_VDIR* psvdList
)
{
Assert(piMetabase);
HRESULT hr = S_OK;
SCA_VDIR* psvd = psvdList;
while (psvd)
{
if (WcaIsUninstalling(psvd->isInstalled, psvd->isAction))
{
hr = ScaDeleteMetabaseKey(piMetabase, psvd->wzVDirRoot, L"");
ExitOnFailure1(hr, "Failed to remove VirtualDir '%S' from metabase", psvd->wzKey);
}
psvd = psvd->psvdNext;
}
LExit:
return hr;
}
HRESULT CpiApplicationRolesRead(
CPI_APPLICATION_LIST* pAppList,
CPI_APPLICATION_ROLE_LIST* pAppRoleList
)
{
HRESULT hr = S_OK;
UINT er = ERROR_SUCCESS;
PMSIHANDLE hView, hRec;
CPI_APPLICATION_ROLE* pItm = NULL;
LPWSTR pwzData = NULL;
BOOL fMatchingArchitecture = FALSE;
// loop through all application roles
hr = WcaOpenExecuteView(vcsApplicationRoleQuery, &hView);
ExitOnFailure(hr, "Failed to execute view on ComPlusApplicationRole table");
while (S_OK == (hr = WcaFetchRecord(hView, &hRec)))
{
// get component
hr = WcaGetRecordString(hRec, arqComponent, &pwzData);
ExitOnFailure(hr, "Failed to get component");
// check if the component is our processor architecture
if (pwzData && *pwzData)
{
hr = CpiVerifyComponentArchitecure(pwzData, &fMatchingArchitecture);
ExitOnFailure(hr, "Failed to get component architecture.");
if (!fMatchingArchitecture)
{
continue; // not the same architecture, ignore
}
}
// create entry
pItm = (CPI_APPLICATION_ROLE*)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CPI_APPLICATION_ROLE));
if (!pItm)
ExitFunction1(hr = E_OUTOFMEMORY);
// get component install state
if (pwzData && *pwzData)
{
pItm->fHasComponent = TRUE;
er = ::MsiGetComponentStateW(WcaGetInstallHandle(), pwzData, &pItm->isInstalled, &pItm->isAction);
ExitOnFailure(hr = HRESULT_FROM_WIN32(er), "Failed to get component state");
}
// get key
hr = WcaGetRecordString(hRec, arqApplicationRole, &pwzData);
ExitOnFailure(hr, "Failed to get key");
StringCchCopyW(pItm->wzKey, countof(pItm->wzKey), pwzData);
// get application
hr = WcaGetRecordString(hRec, arqApplication, &pwzData);
ExitOnFailure(hr, "Failed to get application");
hr = CpiApplicationFindByKey(pAppList, pwzData, &pItm->pApplication);
if (S_FALSE == hr)
hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
ExitOnFailure1(hr, "Failed to find application, key: %S", pwzData);
// get name
hr = WcaGetRecordFormattedString(hRec, arqName, &pwzData);
ExitOnFailure(hr, "Failed to get name");
StringCchCopyW(pItm->wzName, countof(pItm->wzName), pwzData);
// get properties
if (CpiTableExists(cptComPlusApplicationRoleProperty))
{
hr = CpiPropertiesRead(vcsApplicationRolePropertyQuery, pItm->wzKey, pdlApplicationRoleProperties, &pItm->pProperties, &pItm->iPropertyCount);
ExitOnFailure(hr, "Failed to get properties");
}
// set references & increment counters
if (pItm->fHasComponent)
{
if (WcaIsInstalling(pItm->isInstalled, pItm->isAction))
{
CpiApplicationAddReferenceInstall(pItm->pApplication);
pAppRoleList->iInstallCount++;
}
if (WcaIsUninstalling(pItm->isInstalled, pItm->isAction))
{
CpiApplicationAddReferenceUninstall(pItm->pApplication);
pAppRoleList->iUninstallCount++;
}
}
// add entry
if (pAppRoleList->pFirst)
pItm->pNext = pAppRoleList->pFirst;
pAppRoleList->pFirst = pItm;
pItm = NULL;
}
if (E_NOMOREITEMS == hr)
hr = S_OK;
LExit:
// clean up
if (pItm)
FreeApplicationRole(pItm);
ReleaseStr(pwzData);
return hr;
}
HRESULT __stdcall ScaVirtualDirsRead7(
__in SCA_WEB7* pswList,
__in SCA_VDIR7** ppsvdList,
__in SCA_MIMEMAP** ppsmmList,
__in SCA_HTTP_HEADER** ppshhList,
__in SCA_WEB_ERROR** ppsweList,
__in WCA_WRAPQUERY_HANDLE hUserQuery,
__in WCA_WRAPQUERY_HANDLE /*hWebBaseQuery*/,
__in WCA_WRAPQUERY_HANDLE hWebDirPropQuery,
__in WCA_WRAPQUERY_HANDLE hWebAppQuery,
__in WCA_WRAPQUERY_HANDLE hWebAppExtQuery,
__inout LPWSTR *ppwzCustomActionData
)
{
Assert(ppsvdList);
HRESULT hr = S_OK;
MSIHANDLE hRec;
SCA_VDIR7* pvdir = NULL;
LPWSTR pwzData = NULL;
WCA_WRAPQUERY_HANDLE hWrapQuery = NULL;
hr = WcaBeginUnwrapQuery(&hWrapQuery, ppwzCustomActionData);
ExitOnFailure(hr, "Failed to unwrap query for ScaAppPoolRead");
if (0 == WcaGetQueryRecords(hWrapQuery))
{
WcaLog(LOGMSG_VERBOSE, "Skipping ScaVirtualDirsRead() because IIsWebVirtualDir table not present");
ExitFunction1(hr = S_FALSE);
}
// loop through all the vdirs
while (S_OK == (hr = WcaFetchWrappedRecord(hWrapQuery, &hRec)))
{
// Add this record's information into the list of things to process.
hr = AddVirtualDirToList7(ppsvdList);
ExitOnFailure(hr, "failed to add vdir to vdir list");
pvdir = *ppsvdList;
// get the darwin information
hr = WcaGetRecordString(hRec, vdqComponent, &pwzData);
ExitOnFailure(hr, "failed to get IIsWebVirtualDir.Component");
hr = WcaGetRecordInteger(hRec, vdqInstalled, (int *)&pvdir->isInstalled);
ExitOnFailure(hr, "Failed to get Component installed state for virtual dir");
hr = WcaGetRecordInteger(hRec, vdqAction, (int *)&pvdir->isAction);
ExitOnFailure(hr, "Failed to get Component action state for virtual dir");
// get vdir properties
hr = ::StringCchCopyW(pvdir->wzComponent, countof(pvdir->wzComponent), pwzData);
ExitOnFailure(hr, "failed to copy vdir component name: %ls", pwzData);
hr = WcaGetRecordString(hRec, vdqWeb, &pwzData);
ExitOnFailure(hr, "Failed to get Web for VirtualDir");
hr = ScaWebsGetBase7(pswList, pwzData, pvdir->wzWebName , countof(pvdir->wzWebName));
if (S_FALSE == hr)
{
hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
ExitOnFailure(hr, "Failed to get Web Base for VirtualDir");
}
if (WcaIsUninstalling(pvdir->isInstalled, pvdir->isAction))
{
// If we're uninstalling, ignore any failure to find the existing web
hr = S_OK;
}
hr = WcaGetRecordString(hRec, vdqAlias, &pwzData);
ExitOnFailure(hr, "Failed to get Alias for VirtualDir");
hr = ::StringCchCopyW(pvdir->wzVDirRoot, countof(pvdir->wzVDirRoot), pwzData);
ExitOnFailure(hr, "Failed to set VDirRoot for VirtualDir");
// get the vdir's directory
hr = WcaGetRecordString(hRec, vdqDirectory, &pwzData);
ExitOnFailure(hr, "Failed to get Directory for VirtualDir");
// get the web's directory
if (INSTALLSTATE_SOURCE == pvdir->isAction)
{
hr = WcaGetRecordString(hRec, vdqSourcePath, &pwzData);
}
else
{
hr = WcaGetRecordString(hRec, vdqTargetPath, &pwzData);
}
ExitOnFailure(hr, "Failed to get Source/TargetPath for Directory");
// remove trailing backslash(es)
while (lstrlenW(pwzData) > 0 && pwzData[lstrlenW(pwzData)-1] == L'\\')
{
pwzData[lstrlenW(pwzData)-1] = 0;
}
hr = ::StringCchCopyW(pvdir->wzDirectory, countof(pvdir->wzDirectory), pwzData);
ExitOnFailure(hr, "Failed to copy directory string to vdir object");
// get the security information for this web
hr = WcaGetRecordString(hRec, vdqProperties, &pwzData);
ExitOnFailure(hr, "Failed to get web directory identifier for VirtualDir");
if (*pwzData)
{
hr = ScaGetWebDirProperties(pwzData, hUserQuery, hWebDirPropQuery, &pvdir->swp);
ExitOnFailure(hr, "Failed to get web directory for VirtualDir");
pvdir->fHasProperties = TRUE;
}
// get the application information for this web
hr = WcaGetRecordString(hRec, vdqApplication, &pwzData);
ExitOnFailure(hr, "Failed to get application identifier for VirtualDir");
if (*pwzData)
{
hr = ScaGetWebApplication(NULL, pwzData, hWebAppQuery, hWebAppExtQuery, &pvdir->swapp);
ExitOnFailure(hr, "Failed to get application for VirtualDir");
pvdir->fHasApplication = TRUE;
}
hr = WcaGetRecordString(hRec, vdqVDir, &pwzData);
ExitOnFailure(hr, "Failed to get VDir for VirtualDir");
if (*pwzData && *ppsmmList)
{
hr = ScaGetMimeMap(mmptVDir, pwzData, ppsmmList, &pvdir->psmm);
ExitOnFailure(hr, "Failed to get mimemap for VirtualDir");
}
if (*pwzData && *ppshhList)
{
hr = ScaGetHttpHeader(hhptVDir, pwzData, ppshhList, &pvdir->pshh);
ExitOnFailure(hr, "Failed to get custom HTTP headers for VirtualDir: %ls", pwzData);
}
if (*pwzData && *ppsweList)
{
hr = ScaGetWebError(weptVDir, pwzData, ppsweList, &pvdir->pswe);
ExitOnFailure(hr, "Failed to get custom web errors for VirtualDir: %ls", pwzData);
}
}
if (E_NOMOREITEMS == hr)
{
hr = S_OK;
}
ExitOnFailure(hr, "Failure while processing VirtualDirs");
LExit:
WcaFinishUnwrapQuery(hWrapQuery);
ReleaseStr(pwzData);
return hr;
}
/* ****************************************************************
ScaUserExecute - Schedules user account creation or removal based on
component state.
******************************************************************/
HRESULT ScaUserExecute(
__in SCA_USER *psuList
)
{
HRESULT hr = S_OK;
DWORD er = 0;
PDOMAIN_CONTROLLER_INFOW pDomainControllerInfo = NULL;
USER_INFO_0 *pUserInfo = NULL;
LPWSTR pwzActionData = NULL;
LPWSTR pwzRollbackData = NULL;
for (SCA_USER *psu = psuList; psu; psu = psu->psuNext)
{
USER_EXISTS ueUserExists = USER_EXISTS_INDETERMINATE;
// Always put the User Name and Domain plus Attributes on the front of the CustomAction
// data. Sometimes we'll add more data.
Assert(psu->wzName);
hr = WcaWriteStringToCaData(psu->wzName, &pwzActionData);
ExitOnFailure1(hr, "Failed to add user name to custom action data: %ls", psu->wzName);
hr = WcaWriteStringToCaData(psu->wzDomain, &pwzActionData);
ExitOnFailure1(hr, "Failed to add user domain to custom action data: %ls", psu->wzDomain);
hr = WcaWriteIntegerToCaData(psu->iAttributes, &pwzActionData);
ExitOnFailure1(hr, "failed to add user attributes to custom action data for user: %ls", psu->wzKey);
// Check to see if the user already exists since we have to be very careful when adding
// and removing users. Note: MSDN says that it is safe to call these APIs from any
// user, so we should be safe calling it during immediate mode.
er = ::NetApiBufferAllocate(sizeof(USER_INFO_0), reinterpret_cast<LPVOID*>(&pUserInfo));
hr = HRESULT_FROM_WIN32(er);
ExitOnFailure1(hr, "Failed to allocate memory to check existence of user: %ls", psu->wzName);
LPCWSTR wzDomain = psu->wzDomain;
if (wzDomain && *wzDomain)
{
er = ::DsGetDcNameW(NULL, wzDomain, NULL, NULL, NULL, &pDomainControllerInfo);
if (HRESULT_FROM_WIN32(er) == RPC_S_SERVER_UNAVAILABLE)
{
// MSDN says, if we get the above error code, try again with the "DS_FORCE_REDISCOVERY" flag
er = ::DsGetDcNameW(NULL, wzDomain, NULL, NULL, DS_FORCE_REDISCOVERY, &pDomainControllerInfo);
}
if (ERROR_SUCCESS == er)
{
wzDomain = pDomainControllerInfo->DomainControllerName + 2; //Add 2 so that we don't get the \\ prefix
}
}
er = ::NetUserGetInfo(wzDomain, psu->wzName, 0, reinterpret_cast<LPBYTE*>(pUserInfo));
if (NERR_Success == er)
{
ueUserExists = USER_EXISTS_YES;
}
else if (NERR_UserNotFound == er)
{
ueUserExists = USER_EXISTS_NO;
}
else
{
ueUserExists = USER_EXISTS_INDETERMINATE;
hr = HRESULT_FROM_WIN32(er);
WcaLog(LOGMSG_VERBOSE, "Failed to check existence of domain: %ls, user: %ls (error code 0x%x) - continuing", wzDomain, psu->wzName, hr);
}
if (WcaIsInstalling(psu->isInstalled, psu->isAction))
{
// If the user exists, check to see if we are supposed to fail if user the exists before
// the install.
if (USER_EXISTS_YES == ueUserExists)
{
// Reinstalls will always fail if we don't remove the check for "fail if exists".
if (WcaIsReInstalling(psu->isInstalled, psu->isAction))
{
psu->iAttributes &= ~SCAU_FAIL_IF_EXISTS;
}
if ((SCAU_FAIL_IF_EXISTS & (psu->iAttributes)) && !(SCAU_UPDATE_IF_EXISTS & (psu->iAttributes)))
{
hr = HRESULT_FROM_WIN32(NERR_UserExists);
MessageExitOnFailure1(hr, msierrUSRFailedUserCreateExists, "Failed to create user: %ls because user already exists.", psu->wzName);
}
}
// Rollback only if the user already exists, we couldn't determine if the user exists, or we are going to create the user
if ((USER_EXISTS_YES == ueUserExists) || (USER_EXISTS_INDETERMINATE == ueUserExists) || !(psu->iAttributes & SCAU_DONT_CREATE_USER))
{
INT iRollbackUserAttributes = psu->iAttributes;
// If the user already exists, ensure this is accounted for in rollback
if (USER_EXISTS_YES == ueUserExists)
{
iRollbackUserAttributes |= SCAU_DONT_CREATE_USER;
}
else
{
iRollbackUserAttributes &= ~SCAU_DONT_CREATE_USER;
}
hr = WcaWriteStringToCaData(psu->wzName, &pwzRollbackData);
ExitOnFailure1(hr, "Failed to add user name to rollback custom action data: %ls", psu->wzName);
hr = WcaWriteStringToCaData(psu->wzDomain, &pwzRollbackData);
ExitOnFailure1(hr, "Failed to add user domain to rollback custom action data: %ls", psu->wzDomain);
hr = WcaWriteIntegerToCaData(iRollbackUserAttributes, &pwzRollbackData);
ExitOnFailure1(hr, "failed to add user attributes to rollback custom action data for user: %ls", psu->wzKey);
// If the user already exists, add relevant group information to rollback data
if (USER_EXISTS_YES == ueUserExists || USER_EXISTS_INDETERMINATE == ueUserExists)
{
hr = WriteGroupRollbackInfo(psu->wzName, psu->wzDomain, psu->psgGroups, &pwzRollbackData);
ExitOnFailure(hr, "failed to add group information to rollback custom action data");
}
hr = WcaDoDeferredAction(PLATFORM_DECORATION(L"CreateUserRollback"), pwzRollbackData, COST_USER_DELETE);
ExitOnFailure(hr, "failed to schedule CreateUserRollback");
}
//
// Schedule the creation now.
//
hr = WcaWriteStringToCaData(psu->wzPassword, &pwzActionData);
ExitOnFailure1(hr, "failed to add user password to custom action data for user: %ls", psu->wzKey);
// Add user's group information to custom action data
hr = WriteGroupInfo(psu->psgGroups, &pwzActionData);
ExitOnFailure(hr, "failed to add group information to custom action data");
hr = WcaDoDeferredAction(PLATFORM_DECORATION(L"CreateUser"), pwzActionData, COST_USER_ADD);
ExitOnFailure(hr, "failed to schedule CreateUser");
}
else if (((USER_EXISTS_YES == ueUserExists) || (USER_EXISTS_INDETERMINATE == ueUserExists)) && WcaIsUninstalling(psu->isInstalled, psu->isAction) && !(psu->iAttributes & SCAU_DONT_REMOVE_ON_UNINSTALL))
{
// Add user's group information - this will ensure the user can be removed from any groups they were added to, if the user isn't be deleted
hr = WriteGroupInfo(psu->psgGroups, &pwzActionData);
ExitOnFailure(hr, "failed to add group information to custom action data");
//
// Schedule the removal because the user exists and we don't have any flags set
// that say, don't remove the user on uninstall.
//
// Note: We can't rollback the removal of a user which is why RemoveUser is a commit
// CustomAction.
hr = WcaDoDeferredAction(PLATFORM_DECORATION(L"RemoveUser"), pwzActionData, COST_USER_DELETE);
ExitOnFailure(hr, "failed to schedule RemoveUser");
}
ReleaseNullStr(pwzActionData);
ReleaseNullStr(pwzRollbackData);
if (pUserInfo)
{
::NetApiBufferFree(static_cast<LPVOID>(pUserInfo));
pUserInfo = NULL;
}
if (pDomainControllerInfo)
{
::NetApiBufferFree(static_cast<LPVOID>(pDomainControllerInfo));
pDomainControllerInfo = NULL;
}
}
LExit:
ReleaseStr(pwzActionData);
ReleaseStr(pwzRollbackData);
if (pUserInfo)
{
::NetApiBufferFree(static_cast<LPVOID>(pUserInfo));
}
if (pDomainControllerInfo)
{
::NetApiBufferFree(static_cast<LPVOID>(pDomainControllerInfo));
}
return hr;
}
HRESULT ScaUserRead(
__out SCA_USER** ppsuList
)
{
//Assert(FALSE);
Assert(ppsuList);
HRESULT hr = S_OK;
UINT er = ERROR_SUCCESS;
PMSIHANDLE hView, hRec, hUserRec, hUserGroupView;
LPWSTR pwzData = NULL;
BOOL fUserGroupExists = FALSE;
SCA_USER *psu = NULL;
INSTALLSTATE isInstalled, isAction;
if (S_OK != WcaTableExists(L"User"))
{
WcaLog(LOGMSG_VERBOSE, "User Table does not exist, exiting");
ExitFunction1(hr = S_FALSE);
}
if (S_OK == WcaTableExists(L"UserGroup"))
{
fUserGroupExists = TRUE;
}
//
// loop through all the users
//
hr = WcaOpenExecuteView(vActionableQuery, &hView);
ExitOnFailure(hr, "failed to open view on User table");
while (S_OK == (hr = WcaFetchRecord(hView, &hRec)))
{
hr = WcaGetRecordString(hRec, vaqComponent, &pwzData);
ExitOnFailure(hr, "failed to get User.Component");
er = ::MsiGetComponentStateW(WcaGetInstallHandle(), pwzData, &isInstalled, &isAction);
hr = HRESULT_FROM_WIN32(er);
ExitOnFailure(hr, "failed to get Component state for User");
// don't bother if we aren't installing or uninstalling this component
if (WcaIsInstalling(isInstalled, isAction) || WcaIsUninstalling(isInstalled, isAction))
{
//
// Add the user to the list and populate it's values
//
hr = AddUserToList(ppsuList);
ExitOnFailure(hr, "failed to add user to list");
psu = *ppsuList;
psu->isInstalled = isInstalled;
psu->isAction = isAction;
hr = ::StringCchCopyW(psu->wzComponent, countof(psu->wzComponent), pwzData);
ExitOnFailure1(hr, "failed to copy component name: %ls", pwzData);
hr = WcaGetRecordString(hRec, vaqUser, &pwzData);
ExitOnFailure(hr, "failed to get User.User");
hr = ::StringCchCopyW(psu->wzKey, countof(psu->wzKey), pwzData);
ExitOnFailure1(hr, "failed to copy user key: %ls", pwzData);
hr = WcaGetRecordFormattedString(hRec, vaqName, &pwzData);
ExitOnFailure(hr, "failed to get User.Name");
hr = ::StringCchCopyW(psu->wzName, countof(psu->wzName), pwzData);
ExitOnFailure1(hr, "failed to copy user name: %ls", pwzData);
hr = WcaGetRecordFormattedString(hRec, vaqDomain, &pwzData);
ExitOnFailure(hr, "failed to get User.Domain");
hr = ::StringCchCopyW(psu->wzDomain, countof(psu->wzDomain), pwzData);
ExitOnFailure1(hr, "failed to copy user domain: %ls", pwzData);
hr = WcaGetRecordFormattedString(hRec, vaqPassword, &pwzData);
ExitOnFailure(hr, "failed to get User.Password");
hr = ::StringCchCopyW(psu->wzPassword, countof(psu->wzPassword), pwzData);
ExitOnFailure(hr, "failed to copy user password");
hr = WcaGetRecordInteger(hRec, vaqAttributes, &psu->iAttributes);
ExitOnFailure(hr, "failed to get User.Attributes");
// Check if this user is to be added to any groups
if (fUserGroupExists)
{
hUserRec = ::MsiCreateRecord(1);
hr = WcaSetRecordString(hUserRec, 1, psu->wzKey);
ExitOnFailure(hr, "Failed to create user record for querying UserGroup table");
hr = WcaOpenView(vcsUserGroupQuery, &hUserGroupView);
ExitOnFailure1(hr, "Failed to open view on UserGroup table for user %ls", psu->wzKey);
hr = WcaExecuteView(hUserGroupView, hUserRec);
ExitOnFailure1(hr, "Failed to execute view on UserGroup table for user: %ls", psu->wzKey);
while (S_OK == (hr = WcaFetchRecord(hUserGroupView, &hRec)))
{
hr = WcaGetRecordString(hRec, vugqGroup, &pwzData);
ExitOnFailure(hr, "failed to get UserGroup.Group");
hr = AddGroupToList(&(psu->psgGroups));
ExitOnFailure(hr, "failed to add group to list");
hr = ScaGetGroup(pwzData, psu->psgGroups);
ExitOnFailure1(hr, "failed to get information for group: %ls", pwzData);
}
if (E_NOMOREITEMS == hr)
{
hr = S_OK;
}
ExitOnFailure(hr, "failed to enumerate selected rows from UserGroup table");
}
}
}
if (E_NOMOREITEMS == hr)
{
hr = S_OK;
}
ExitOnFailure(hr, "failed to enumerate selected rows from User table");
LExit:
ReleaseStr(pwzData);
return hr;
}
HRESULT MqiMessageQueueRead(
MQI_MESSAGE_QUEUE_LIST* pList
)
{
HRESULT hr = S_OK;
UINT er = ERROR_SUCCESS;
PMSIHANDLE hView, hRec;
MQI_MESSAGE_QUEUE* pItm = NULL;
LPWSTR pwzData = NULL;
// loop through all partitions
hr = WcaOpenExecuteView(vcsMessageQueueQuery, &hView);
ExitOnFailure(hr, "Failed to execute view on MessageQueue table");
while (S_OK == (hr = WcaFetchRecord(hView, &hRec)))
{
// create entry
pItm = (MQI_MESSAGE_QUEUE*)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MQI_MESSAGE_QUEUE));
if (!pItm)
ExitFunction1(hr = E_OUTOFMEMORY);
// get key
hr = WcaGetRecordString(hRec, mqqMessageQueue, &pwzData);
ExitOnFailure(hr, "Failed to get key");
StringCchCopyW(pItm->wzKey, countof(pItm->wzKey), pwzData);
// get component install state
hr = WcaGetRecordString(hRec, mqqComponent, &pwzData);
ExitOnFailure(hr, "Failed to get component");
// get component install state
er = ::MsiGetComponentStateW(WcaGetInstallHandle(), pwzData, &pItm->isInstalled, &pItm->isAction);
ExitOnFailure(hr = HRESULT_FROM_WIN32(er), "Failed to get component state");
// get base priority
hr = WcaGetRecordInteger(hRec, mqqBasePriority, &pItm->iBasePriority);
ExitOnFailure(hr, "Failed to get base priority");
// get journal quota
hr = WcaGetRecordInteger(hRec, mqqJournalQuota, &pItm->iJournalQuota);
ExitOnFailure(hr, "Failed to get journal quota");
// get label
hr = WcaGetRecordFormattedString(hRec, mqqLabel, &pwzData);
ExitOnFailure(hr, "Failed to get label");
StringCchCopyW(pItm->wzLabel, countof(pItm->wzLabel), pwzData);
// get multicast address
hr = WcaGetRecordFormattedString(hRec, mqqMulticastAddress, &pwzData);
ExitOnFailure(hr, "Failed to get multicast address");
StringCchCopyW(pItm->wzMulticastAddress, countof(pItm->wzMulticastAddress), pwzData);
// get path name
hr = WcaGetRecordFormattedString(hRec, mqqPathName, &pwzData);
ExitOnFailure(hr, "Failed to get path name");
StringCchCopyW(pItm->wzPathName, countof(pItm->wzPathName), pwzData);
// get privacy level
hr = WcaGetRecordInteger(hRec, mqqPrivLevel, &pItm->iPrivLevel);
ExitOnFailure(hr, "Failed to get privacy level");
// get quota
hr = WcaGetRecordInteger(hRec, mqqQuota, &pItm->iQuota);
ExitOnFailure(hr, "Failed to get quota");
// get service type guid
hr = WcaGetRecordFormattedString(hRec, mqqServiceTypeGuid, &pwzData);
ExitOnFailure(hr, "Failed to get service type guid");
StringCchCopyW(pItm->wzServiceTypeGuid, countof(pItm->wzServiceTypeGuid), pwzData);
// get attributes
hr = WcaGetRecordInteger(hRec, mqqAttributes, &pItm->iAttributes);
ExitOnFailure(hr, "Failed to get attributes");
// increment counters
if (WcaIsInstalling(pItm->isInstalled, pItm->isAction))
pList->iInstallCount++;
if (WcaIsUninstalling(pItm->isInstalled, pItm->isAction))
pList->iUninstallCount++;
// add entry
pItm->pNext = pList->pFirst;
pList->pFirst = pItm;
pItm = NULL;
}
if (E_NOMOREITEMS == hr)
hr = S_OK;
LExit:
// clean up
if (pItm)
::HeapFree(::GetProcessHeap(), 0, pItm);
ReleaseStr(pwzData);
return hr;
}
static HRESULT MessageQueueTrusteePermissionsRead(
LPCWSTR pwzQuery,
MQI_MESSAGE_QUEUE_LIST* pMessageQueueList,
MQI_MESSAGE_QUEUE_PERMISSION_LIST* pList
)
{
HRESULT hr = S_OK;
UINT er = ERROR_SUCCESS;
PMSIHANDLE hView, hRec;
LPWSTR pwzData = NULL;
MQI_MESSAGE_QUEUE_PERMISSION* pItm = NULL;
// loop through all application roles
hr = WcaOpenExecuteView(pwzQuery, &hView);
ExitOnFailure(hr, "Failed to execute view on table");
while (S_OK == (hr = WcaFetchRecord(hView, &hRec)))
{
// create entry
pItm = (MQI_MESSAGE_QUEUE_PERMISSION*)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MQI_MESSAGE_QUEUE_PERMISSION));
if (!pItm)
ExitFunction1(hr = E_OUTOFMEMORY);
// get key
hr = WcaGetRecordString(hRec, mqpqMessageQueuePermission, &pwzData);
ExitOnFailure(hr, "Failed to get key");
StringCchCopyW(pItm->wzKey, countof(pItm->wzKey), pwzData);
// get component
hr = WcaGetRecordString(hRec, mqpqComponent, &pwzData);
ExitOnFailure(hr, "Failed to get component");
// get component install state
er = ::MsiGetComponentStateW(WcaGetInstallHandle(), pwzData, &pItm->isInstalled, &pItm->isAction);
ExitOnFailure(hr = HRESULT_FROM_WIN32(er), "Failed to get component state");
// get message queue
hr = WcaGetRecordString(hRec, mqpqMessageQueue, &pwzData);
ExitOnFailure(hr, "Failed to get application role");
hr = MqiMessageQueueFindByKey(pMessageQueueList, pwzData, &pItm->pMessageQueue);
if (S_FALSE == hr)
hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
ExitOnFailure(hr, "Failed to find message queue, key: %S", pwzData);
// get user domain
hr = WcaGetRecordFormattedString(hRec, mqpqDomain, &pwzData);
ExitOnFailure(hr, "Failed to get domain");
StringCchCopyW(pItm->wzDomain, countof(pItm->wzDomain), pwzData);
// get user name
hr = WcaGetRecordFormattedString(hRec, mqpqName, &pwzData);
ExitOnFailure(hr, "Failed to get name");
StringCchCopyW(pItm->wzName, countof(pItm->wzName), pwzData);
// get permissions
hr = WcaGetRecordInteger(hRec, mqpqPermissions, &pItm->iPermissions);
ExitOnFailure(hr, "Failed to get permissions");
// set references & increment counters
if (WcaIsInstalling(pItm->isInstalled, pItm->isAction))
pList->iInstallCount++;
if (WcaIsUninstalling(pItm->isInstalled, pItm->isAction))
pList->iUninstallCount++;
// add entry
if (pList->pFirst)
pItm->pNext = pList->pFirst;
pList->pFirst = pItm;
pItm = NULL;
}
if (E_NOMOREITEMS == hr)
hr = S_OK;
LExit:
// clean up
ReleaseStr(pwzData);
if (pItm)
::HeapFree(::GetProcessHeap(), 0, pItm);
return hr;
}
HRESULT ScaSqlStrsRead(
__inout SCA_SQLSTR** ppsssList,
__in SCA_ACTION saAction
)
{
HRESULT hr = S_OK;
UINT er = ERROR_SUCCESS;
PMSIHANDLE hView, hRec;
PMSIHANDLE hViewUser, hRecUser;
LPWSTR pwzComponent = NULL;
LPWSTR pwzData = NULL;
SCA_SQLSTR* psss = NULL;
if (S_OK != WcaTableExists(L"SqlString") || S_OK != WcaTableExists(L"SqlDatabase"))
{
WcaLog(LOGMSG_VERBOSE, "Skipping ScaSqlStrsRead() - SqlString and/or SqlDatabase table not present");
ExitFunction1(hr = S_FALSE);
}
// loop through all the sql strings
hr = WcaOpenExecuteView(vcsSqlStringQuery, &hView);
ExitOnFailure(hr, "Failed to open view on SqlString table");
while (S_OK == (hr = WcaFetchRecord(hView, &hRec)))
{
INSTALLSTATE isInstalled = INSTALLSTATE_UNKNOWN;
INSTALLSTATE isAction = INSTALLSTATE_UNKNOWN;
hr = WcaGetRecordString(hRec, ssqComponent, &pwzComponent);
ExitOnFailure(hr, "Failed to get Component for SQL String.");
er = ::MsiGetComponentStateW(WcaGetInstallHandle(), pwzComponent, &isInstalled, &isAction);
hr = HRESULT_FROM_WIN32(er);
ExitOnFailure1(hr, "Failed to get state for component: %ls", pwzComponent);
// If we're doing install but the Component is not being installed or we're doing
// uninstall but the Component is not being uninstalled, skip it.
if ((WcaIsInstalling(isInstalled, isAction) && SCA_ACTION_INSTALL != saAction) ||
(WcaIsUninstalling(isInstalled, isAction) && SCA_ACTION_UNINSTALL != saAction))
{
continue;
}
hr = NewSqlStr(&psss);
ExitOnFailure(hr, "failed to allocation new sql string element");
psss->isInstalled = isInstalled;
psss->isAction = isAction;
hr = WcaGetRecordString(hRec, ssqSqlString, &pwzData);
ExitOnFailure(hr, "Failed to get SqlString.String");
hr = ::StringCchCopyW(psss->wzKey, countof(psss->wzKey), pwzData);
ExitOnFailure1(hr, "Failed to copy SqlString.String: %ls", pwzData);
// find the database information for this string
hr = WcaGetRecordString(hRec, ssqSqlDb, &pwzData);
ExitOnFailure1(hr, "Failed to get SqlString.SqlDb_ for SqlString '%ls'", psss->wzKey);
hr = ::StringCchCopyW(psss->wzSqlDb, countof(psss->wzSqlDb), pwzData);
ExitOnFailure1(hr, "Failed to copy SqlString.SqlDb_: %ls", pwzData);
hr = WcaGetRecordInteger(hRec, ssqAttributes, &psss->iAttributes);
ExitOnFailure1(hr, "Failed to get SqlString.Attributes for SqlString '%ls'", psss->wzKey);
//get the sequence number for the string (note that this will be sequenced with scripts too)
hr = WcaGetRecordInteger(hRec, ssqSequence, &psss->iSequence);
ExitOnFailure1(hr, "Failed to get SqlString.Sequence for SqlString '%ls'", psss->wzKey);
// execute SQL
hr = WcaGetRecordFormattedString(hRec, ssqSQL, &pwzData);
ExitOnFailure1(hr, "Failed to get SqlString.SQL for SqlString '%ls'", psss->wzKey);
Assert(!psss->pwzSql);
hr = StrAllocString(&psss->pwzSql, pwzData, 0);
ExitOnFailure1(hr, "Failed to alloc string for SqlString '%ls'", psss->wzKey);
*ppsssList = AddSqlStrToList(*ppsssList, psss);
psss = NULL; // set the sss to NULL so it doesn't get freed below
}
if (E_NOMOREITEMS == hr)
{
hr = S_OK;
}
ExitOnFailure(hr, "Failure occured while reading SqlString table");
LExit:
// if anything was left over after an error clean it all up
if (psss)
{
ScaSqlStrsFreeList(psss);
}
ReleaseStr(pwzData);
ReleaseStr(pwzComponent);
return hr;
}
HRESULT CpiPartitionsRead(
CPI_PARTITION_LIST* pPartList
)
{
HRESULT hr = S_OK;
UINT er = ERROR_SUCCESS;
PMSIHANDLE hView, hRec;
CPI_PARTITION* pItm = NULL;
LPWSTR pwzData = NULL;
BOOL fMatchingArchitecture = FALSE;
// loop through all partitions
hr = WcaOpenExecuteView(vcsPartitionQuery, &hView);
ExitOnFailure(hr, "Failed to execute view on ComPlusPartition table");
while (S_OK == (hr = WcaFetchRecord(hView, &hRec)))
{
// get component
hr = WcaGetRecordString(hRec, pqComponent, &pwzData);
ExitOnFailure(hr, "Failed to get component");
// check if the component is our processor architecture
if (pwzData && *pwzData)
{
hr = CpiVerifyComponentArchitecure(pwzData, &fMatchingArchitecture);
ExitOnFailure(hr, "Failed to get component architecture.");
if (!fMatchingArchitecture)
{
continue; // not the same architecture, ignore
}
}
// create entry
pItm = (CPI_PARTITION*)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CPI_PARTITION));
if (!pItm)
ExitFunction1(hr = E_OUTOFMEMORY);
// get component install state
if (pwzData && *pwzData)
{
pItm->fHasComponent = TRUE;
er = ::MsiGetComponentStateW(WcaGetInstallHandle(), pwzData, &pItm->isInstalled, &pItm->isAction);
ExitOnFailure(hr = HRESULT_FROM_WIN32(er), "Failed to get component state");
}
// get key
hr = WcaGetRecordString(hRec, pqPartition, &pwzData);
ExitOnFailure(hr, "Failed to get key");
StringCchCopyW(pItm->wzKey, countof(pItm->wzKey), pwzData);
// get id
hr = WcaGetRecordFormattedString(hRec, pqID, &pwzData);
ExitOnFailure(hr, "Failed to get id");
if (pwzData && *pwzData)
{
hr = PcaGuidToRegFormat(pwzData, pItm->wzID, countof(pItm->wzID));
ExitOnFailure(hr, "Failed to parse id guid value, key: %S, value: '%S'", pItm->wzKey, pwzData);
}
// get name
hr = WcaGetRecordFormattedString(hRec, pqName, &pwzData);
ExitOnFailure(hr, "Failed to get name");
StringCchCopyW(pItm->wzName, countof(pItm->wzName), pwzData);
// if partition is a locater, either an id or a name must be provided
if (!pItm->fHasComponent && !*pItm->wzID && !*pItm->wzName)
ExitOnFailure(hr = E_FAIL, "A partition locater must have either an id or a name associated, key: %S", pItm->wzKey);
// if partition is not a locater, an name must be provided
if (pItm->fHasComponent && !*pItm->wzName)
ExitOnFailure(hr = E_FAIL, "A partition must have a name associated, key: %S", pItm->wzKey);
// get properties
if (CpiTableExists(cptComPlusPartitionProperty) && pItm->fHasComponent)
{
hr = CpiPropertiesRead(vcsPartitionPropertyQuery, pItm->wzKey, pdlPartitionProperties, &pItm->pProperties, &pItm->iPropertyCount);
ExitOnFailure(hr, "Failed to get properties");
}
// increment counters
if (pItm->fHasComponent && WcaIsInstalling(pItm->isInstalled, pItm->isAction))
pPartList->iInstallCount++;
if (pItm->fHasComponent && WcaIsUninstalling(pItm->isInstalled, pItm->isAction))
pPartList->iUninstallCount++;
// add entry
if (pPartList->pFirst)
pItm->pNext = pPartList->pFirst;
pPartList->pFirst = pItm;
pItm = NULL;
}
if (E_NOMOREITEMS == hr)
hr = S_OK;
LExit:
// clean up
if (pItm)
FreePartition(pItm);
ReleaseStr(pwzData);
return hr;
}
static HRESULT ExecuteStrings(
__in SCA_DB* psdList,
__in SCA_SQLSTR* psssList,
__in BOOL fInstall
)
{
HRESULT hr = S_FALSE; // assume nothing will be done
int iRollback = -1;
int iOldRollback = iRollback;
LPCWSTR wzOldDb = NULL;
UINT uiCost = 0;
WCHAR* pwzCustomActionData = NULL;
WCHAR wzNumber[64];
// loop through all sql strings
for (SCA_SQLSTR* psss = psssList; psss; psss = psss->psssNext)
{
// if installing this component
if ((fInstall && (psss->iAttributes & SCASQL_EXECUTE_ON_INSTALL) && WcaIsInstalling(psss->isInstalled, psss->isAction) && !WcaIsReInstalling(psss->isInstalled, psss->isAction)) ||
(fInstall && (psss->iAttributes & SCASQL_EXECUTE_ON_REINSTALL) && WcaIsReInstalling(psss->isInstalled, psss->isAction)) ||
(!fInstall && (psss->iAttributes & SCASQL_EXECUTE_ON_UNINSTALL) && WcaIsUninstalling(psss->isInstalled, psss->isAction)))
{
// determine if this is a rollback scheduling or normal deferred scheduling
if (psss->iAttributes & SCASQL_ROLLBACK)
{
iRollback = 1;
}
else
{
iRollback = 0;
}
// if we need to create a connection to a new server\database
if (!wzOldDb || 0 != lstrcmpW(wzOldDb, psss->wzSqlDb) || iOldRollback != iRollback)
{
const SCA_DB* psd = ScaDbsFindDatabase(psss->wzSqlDb, psdList);
if (!psd)
{
ExitOnFailure1(hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND), "failed to find data for Database: %ls", psss->wzSqlDb);
}
if (-1 == iOldRollback)
{
iOldRollback = iRollback;
}
Assert(0 == iOldRollback || 1 == iOldRollback);
// if there was custom action data before, schedule the action to write it
if (pwzCustomActionData && *pwzCustomActionData)
{
Assert(pwzCustomActionData && *pwzCustomActionData && uiCost);
hr = WcaDoDeferredAction(1 == iOldRollback ? L"RollbackExecuteSqlStrings" : L"ExecuteSqlStrings", pwzCustomActionData, uiCost);
ExitOnFailure1(hr, "failed to schedule ExecuteSqlStrings action, rollback: %d", iOldRollback);
iOldRollback = iRollback;
*pwzCustomActionData = L'\0';
uiCost = 0;
}
Assert(!pwzCustomActionData || (pwzCustomActionData && 0 == *pwzCustomActionData) && 0 == uiCost);
hr = WcaWriteStringToCaData(psd->wzKey, &pwzCustomActionData);
ExitOnFailure1(hr, "Failed to add SQL Server Database String to CustomActionData for Database String: %ls", psd->wzKey);
hr = WcaWriteStringToCaData(psd->wzServer, &pwzCustomActionData);
ExitOnFailure1(hr, "Failed to add SQL Server to CustomActionData for Database String: %ls", psd->wzKey);
hr = WcaWriteStringToCaData(psd->wzInstance, &pwzCustomActionData);
ExitOnFailure1(hr, "Failed to add SQL Instance to CustomActionData for Database String: %ls", psd->wzKey);
hr = WcaWriteStringToCaData(psd->wzDatabase, &pwzCustomActionData);
ExitOnFailure1(hr, "Failed to add SQL Database to CustomActionData for Database String: %ls", psd->wzKey);
hr = ::StringCchPrintfW(wzNumber, countof(wzNumber), L"%d", psd->iAttributes);
ExitOnFailure(hr, "Failed to format attributes integer value to string");
hr = WcaWriteStringToCaData(wzNumber, &pwzCustomActionData);
ExitOnFailure1(hr, "Failed to add SQL Attributes to CustomActionData for Database String: %ls", psd->wzKey);
hr = ::StringCchPrintfW(wzNumber, countof(wzNumber), L"%d", psd->fUseIntegratedAuth);
ExitOnFailure(hr, "Failed to format UseIntegratedAuth integer value to string");
hr = WcaWriteStringToCaData(wzNumber, &pwzCustomActionData);
ExitOnFailure1(hr, "Failed to add SQL IntegratedAuth flag to CustomActionData for Database String: %ls", psd->wzKey);
hr = WcaWriteStringToCaData(psd->scau.wzName, &pwzCustomActionData);
ExitOnFailure1(hr, "Failed to add SQL UserName to CustomActionData for Database String: %ls", psd->wzKey);
hr = WcaWriteStringToCaData(psd->scau.wzPassword, &pwzCustomActionData);
ExitOnFailure1(hr, "Failed to add SQL Password to CustomActionData for Database String: %ls", psd->wzKey);
uiCost += COST_SQL_CONNECTDB;
wzOldDb = psss->wzSqlDb;
}
WcaLog(LOGMSG_VERBOSE, "Scheduling SQL string: %ls", psss->pwzSql);
hr = WcaWriteStringToCaData(psss->wzKey, &pwzCustomActionData);
ExitOnFailure1(hr, "Failed to add SQL Key to CustomActionData for SQL string: %ls", psss->wzKey);
hr = WcaWriteIntegerToCaData(psss->iAttributes, &pwzCustomActionData);
ExitOnFailure1(hr, "failed to add attributes to CustomActionData for SQL string: %ls", psss->wzKey);
hr = WcaWriteStringToCaData(psss->pwzSql, &pwzCustomActionData);
ExitOnFailure1(hr, "Failed to to add SQL Query to CustomActionData for SQL string: %ls", psss->wzKey);
uiCost += COST_SQL_STRING;
}
}
if (pwzCustomActionData && *pwzCustomActionData)
{
Assert(pwzCustomActionData && *pwzCustomActionData && uiCost);
hr = WcaDoDeferredAction(1 == iRollback ? L"RollbackExecuteSqlStrings" : L"ExecuteSqlStrings", pwzCustomActionData, uiCost);
ExitOnFailure(hr, "Failed to schedule ExecuteSqlStrings action");
*pwzCustomActionData = L'\0';
uiCost = 0;
}
LExit:
ReleaseStr(pwzCustomActionData);
return hr;
}
HRESULT CpiPartitionUsersRead(
CPI_PARTITION_LIST* pPartList,
CPI_PARTITION_USER_LIST* pPartUsrList
)
{
HRESULT hr = S_OK;
UINT er = ERROR_SUCCESS;
PMSIHANDLE hView, hRec;
CPI_PARTITION_USER* pItm = NULL;
LPWSTR pwzData = NULL;
LPWSTR pwzDomain = NULL;
LPWSTR pwzName = NULL;
BOOL fMatchingArchitecture = FALSE;
// loop through all partition users
hr = WcaOpenExecuteView(vcsPartitionUserQuery, &hView);
ExitOnFailure(hr, "Failed to execute view on ComPlusPartitionUser table");
while (S_OK == (hr = WcaFetchRecord(hView, &hRec)))
{
// get component
hr = WcaGetRecordString(hRec, puqComponent, &pwzData);
ExitOnFailure(hr, "Failed to get component");
// check if the component is our processor architecture
hr = CpiVerifyComponentArchitecure(pwzData, &fMatchingArchitecture);
ExitOnFailure(hr, "Failed to get component architecture.");
if (!fMatchingArchitecture)
{
continue; // not the same architecture, ignore
}
// create entry
pItm = (CPI_PARTITION_USER*)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CPI_PARTITION_USER));
if (!pItm)
ExitFunction1(hr = E_OUTOFMEMORY);
// get component install state
er = ::MsiGetComponentStateW(WcaGetInstallHandle(), pwzData, &pItm->isInstalled, &pItm->isAction);
ExitOnFailure(hr = HRESULT_FROM_WIN32(er), "Failed to get component state");
// get key
hr = WcaGetRecordString(hRec, puqPartitionUser, &pwzData);
ExitOnFailure(hr, "Failed to get key");
StringCchCopyW(pItm->wzKey, countof(pItm->wzKey), pwzData);
// get partition
hr = WcaGetRecordString(hRec, puqPartition, &pwzData);
ExitOnFailure(hr, "Failed to get partition");
hr = CpiPartitionFindByKey(pPartList, pwzData, &pItm->pPartition);
if (S_FALSE == hr)
hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
ExitOnFailure(hr, "Failed to find partition, key: %S", pwzData);
// get user domain
hr = WcaGetRecordFormattedString(hRec, puqDomain, &pwzDomain);
ExitOnFailure(hr, "Failed to get user domain");
// get user name
hr = WcaGetRecordFormattedString(hRec, puqName, &pwzName);
ExitOnFailure(hr, "Failed to get user name");
// build account name
hr = CpiBuildAccountName(pwzDomain, pwzName, &pItm->pwzAccount);
ExitOnFailure(hr, "Failed to build account name");
// set references & increment counters
if (WcaIsInstalling(pItm->isInstalled, pItm->isAction))
{
pItm->pPartition->fReferencedForInstall = TRUE;
pPartUsrList->iInstallCount++;
}
if (WcaIsUninstalling(pItm->isInstalled, pItm->isAction))
{
pItm->pPartition->fReferencedForUninstall = TRUE;
pPartUsrList->iUninstallCount++;
}
// add entry
if (pPartUsrList->pFirst)
pItm->pNext = pPartUsrList->pFirst;
pPartUsrList->pFirst = pItm;
pItm = NULL;
}
if (E_NOMOREITEMS == hr)
hr = S_OK;
LExit:
// clean up
if (pItm)
FreePartitionUser(pItm);
ReleaseStr(pwzData);
ReleaseStr(pwzDomain);
ReleaseStr(pwzName);
return hr;
}
HRESULT __stdcall ScaVirtualDirsRead(
__in IMSAdminBase* piMetabase,
__in SCA_WEB* pswList,
__in SCA_VDIR** ppsvdList,
__in SCA_MIMEMAP** ppsmmList,
__in SCA_HTTP_HEADER** ppshhList,
__in SCA_WEB_ERROR** ppsweList,
__in WCA_WRAPQUERY_HANDLE hUserQuery,
__in WCA_WRAPQUERY_HANDLE hWebBaseQuery,
__in WCA_WRAPQUERY_HANDLE hWebDirPropQuery,
__in WCA_WRAPQUERY_HANDLE hWebAppQuery,
__in WCA_WRAPQUERY_HANDLE hWebAppExtQuery,
__inout LPWSTR *ppwzCustomActionData
)
{
Assert(piMetabase && ppsvdList);
HRESULT hr = S_OK;
MSIHANDLE hRec;
INSTALLSTATE isInstalled = INSTALLSTATE_UNKNOWN;
INSTALLSTATE isAction = INSTALLSTATE_UNKNOWN;
SCA_VDIR* pvdir = NULL;
LPWSTR pwzData = NULL;
WCA_WRAPQUERY_HANDLE hWrapQuery = NULL;
hr = WcaBeginUnwrapQuery(&hWrapQuery, ppwzCustomActionData);
ExitOnFailure(hr, "Failed to unwrap query for ScaAppPoolRead");
if (0 == WcaGetQueryRecords(hWrapQuery))
{
WcaLog(LOGMSG_VERBOSE, "Skipping ScaVirtualDirsRead() because IIsWebVirtualDir table not present");
ExitFunction1(hr = S_FALSE);
}
// loop through all the vdirs
while (S_OK == (hr = WcaFetchWrappedRecord(hWrapQuery, &hRec)))
{
// Get the Component first. If there is a Component and it is not being modified during
// this transaction, skip processing this whole record.
hr = WcaGetRecordString(hRec, vdqComponent, &pwzData);
ExitOnFailure(hr, "failed to get IIsWebVirtualDir.Component");
hr = WcaGetRecordInteger(hRec, vdqInstalled, (int *)&isInstalled);
ExitOnFailure(hr, "Failed to get Component installed state for virtual dir");
hr = WcaGetRecordInteger(hRec, vdqAction, (int *)&isAction);
ExitOnFailure(hr, "Failed to get Component action state for virtual dir");
if (!WcaIsInstalling(isInstalled, isAction) &&
!WcaIsReInstalling(isInstalled, isAction) &&
!WcaIsUninstalling(isInstalled, isAction))
{
continue; // skip this record.
}
hr = AddVirtualDirToList(ppsvdList);
ExitOnFailure(hr, "failed to add virtual dir to list");
pvdir = *ppsvdList;
hr = ::StringCchCopyW(pvdir->wzComponent, countof(pvdir->wzComponent), pwzData);
ExitOnFailure1(hr, "failed to copy component name: %ls", pwzData);
pvdir->isInstalled = isInstalled;
pvdir->isAction = isAction;
// get the web key
hr = WcaGetRecordString(hRec, vdqWeb, &pwzData);
ExitOnFailure(hr, "Failed to get Web for VirtualDir");
hr = ScaWebsGetBase(piMetabase, pswList, pwzData, pvdir->wzWebBase, countof(pvdir->wzWebBase), hWebBaseQuery);
if (WcaIsUninstalling(isInstalled, isAction))
{
// If we're uninstalling, ignore any failure to find the existing web
hr = S_OK;
}
ExitOnFailure1(hr, "Failed to get base of web: %ls for VirtualDir", pwzData);
hr = WcaGetRecordString(hRec, vdqAlias, &pwzData);
ExitOnFailure(hr, "Failed to get Alias for VirtualDir");
if (0 != lstrlenW(pvdir->wzWebBase))
{
hr = ::StringCchPrintfW(pvdir->wzVDirRoot, countof(pvdir->wzVDirRoot), L"%s/Root/%s", pvdir->wzWebBase, pwzData);
ExitOnFailure(hr, "Failed to set VDirRoot for VirtualDir");
}
// get the vdir's directory
hr = WcaGetRecordString(hRec, vdqDirectory, &pwzData);
ExitOnFailure(hr, "Failed to get Directory for VirtualDir");
// get the web's directory
if (INSTALLSTATE_SOURCE == pvdir->isAction)
{
hr = WcaGetRecordString(hRec, vdqSourcePath, &pwzData);
}
else
{
hr = WcaGetRecordString(hRec, vdqTargetPath, &pwzData);
}
ExitOnFailure(hr, "Failed to get Source/TargetPath for Directory");
// remove trailing backslash(es)
while (lstrlenW(pwzData) > 0 && pwzData[lstrlenW(pwzData)-1] == L'\\')
{
pwzData[lstrlenW(pwzData)-1] = 0;
}
hr = ::StringCchCopyW(pvdir->wzDirectory, countof(pvdir->wzDirectory), pwzData);
ExitOnFailure(hr, "Failed to copy directory string to vdir object");
// get the security information for this web
hr = WcaGetRecordString(hRec, vdqProperties, &pwzData);
ExitOnFailure(hr, "Failed to get web directory identifier for VirtualDir");
if (*pwzData)
{
hr = ScaGetWebDirProperties(pwzData, hUserQuery, hWebDirPropQuery, &pvdir->swp);
ExitOnFailure(hr, "Failed to get web directory for VirtualDir");
pvdir->fHasProperties = TRUE;
}
// get the application information for this web
hr = WcaGetRecordString(hRec, vdqApplication, &pwzData);
ExitOnFailure(hr, "Failed to get application identifier for VirtualDir");
if (*pwzData)
{
hr = ScaGetWebApplication(NULL, pwzData, hWebAppQuery, hWebAppExtQuery, &pvdir->swapp);
ExitOnFailure(hr, "Failed to get application for VirtualDir");
pvdir->fHasApplication = TRUE;
}
hr = WcaGetRecordString(hRec, vdqVDir, &pwzData);
ExitOnFailure(hr, "Failed to get VDir for VirtualDir");
if (*pwzData && *ppsmmList)
{
hr = ScaGetMimeMap(mmptVDir, pwzData, ppsmmList, &pvdir->psmm);
ExitOnFailure(hr, "Failed to get mimemap for VirtualDir");
}
if (*pwzData && *ppshhList)
{
hr = ScaGetHttpHeader(hhptVDir, pwzData, ppshhList, &pvdir->pshh);
ExitOnFailure1(hr, "Failed to get custom HTTP headers for VirtualDir: %ls", pwzData);
}
if (*pwzData && *ppsweList)
{
hr = ScaGetWebError(weptVDir, pwzData, ppsweList, &pvdir->pswe);
ExitOnFailure1(hr, "Failed to get custom web errors for VirtualDir: %ls", pwzData);
}
}
if (E_NOMOREITEMS == hr)
{
hr = S_OK;
}
ExitOnFailure(hr, "Failure while processing VirtualDirs");
LExit:
WcaFinishUnwrapQuery(hWrapQuery);
ReleaseStr(pwzData);
return hr;
}
HRESULT ScaWebsRead(
__in IMSAdminBase* piMetabase,
__in SCA_MIMEMAP** ppsmmList,
__in SCA_WEB** ppswList,
__in SCA_HTTP_HEADER** ppshhList,
__in SCA_WEB_ERROR** ppsweList,
__in WCA_WRAPQUERY_HANDLE hUserQuery,
__in WCA_WRAPQUERY_HANDLE hWebDirPropQuery,
__in WCA_WRAPQUERY_HANDLE hSslCertQuery,
__in WCA_WRAPQUERY_HANDLE hWebLogQuery,
__in WCA_WRAPQUERY_HANDLE hWebAppQuery,
__in WCA_WRAPQUERY_HANDLE hWebAppExtQuery,
__inout LPWSTR *ppwzCustomActionData
)
{
Assert(piMetabase && ppswList);
HRESULT hr = S_OK;
MSIHANDLE hRec;
MSIHANDLE hRecAddresses;
SCA_WEB* psw = NULL;
LPWSTR pwzData = NULL;
int iSiteId;
DWORD dwLen = 0;
WCA_WRAPQUERY_HANDLE hQueryWebSite = NULL;
WCA_WRAPQUERY_HANDLE hQueryWebAddress = NULL;
hr = WcaBeginUnwrapQuery(&hQueryWebSite, ppwzCustomActionData);
ExitOnFailure(hr, "Failed to unwrap query for ScaWebsRead");
hr = WcaBeginUnwrapQuery(&hQueryWebAddress, ppwzCustomActionData);
ExitOnFailure(hr, "Failed to unwrap query for ScaWebsRead");
if (0 == WcaGetQueryRecords(hQueryWebSite))
{
WcaLog(LOGMSG_VERBOSE, "Required tables not present");
ExitFunction1(hr = S_FALSE);
}
// loop through all the webs
while (S_OK == (hr = WcaFetchWrappedRecord(hQueryWebSite, &hRec)))
{
psw = NewWeb();
ExitOnNull(psw, hr, E_OUTOFMEMORY, "Failed to allocate memory for web object in memory");
// get the darwin information
hr = WcaGetRecordString(hRec, wqWeb, &pwzData);
ExitOnFailure(hr, "Failed to get Web");
hr = ::StringCchCopyW(psw->wzKey, countof(psw->wzKey), pwzData);
ExitOnFailure(hr, "Failed to copy key string to web object");
if (*pwzData && *ppsmmList)
{
hr = ScaGetMimeMap(mmptWeb, pwzData, ppsmmList, &psw->psmm);
ExitOnFailure(hr, "Failed to get mimemap for VirtualDir");
}
// get component install state
hr = WcaGetRecordString(hRec, wqComponent, &pwzData);
ExitOnFailure(hr, "Failed to get Component for Web");
hr = ::StringCchCopyW(psw->wzComponent, countof(psw->wzComponent), pwzData);
ExitOnFailure(hr, "Failed to copy component string to web object");
if (*(psw->wzComponent))
{
psw->fHasComponent = TRUE;
hr = WcaGetRecordInteger(hRec, wqInstalled, (int *)&psw->isInstalled);
ExitOnFailure(hr, "Failed to get web Component's installed state");
WcaGetRecordInteger(hRec, wqAction, (int *)&psw->isAction);
ExitOnFailure(hr, "Failed to get web Component's action state");
if (!WcaIsInstalling(psw->isInstalled, psw->isAction) && !WcaIsUninstalling(psw->isInstalled, psw->isAction)
&& !WcaIsReInstalling(psw->isInstalled, psw->isAction))
{
FreeWeb(psw);
psw = NULL;
continue; // If we aren't acting on this component, skip it
}
}
hr = WcaGetRecordInteger(hRec, wqId, &iSiteId);
ExitOnFailure(hr, "Failed to get SiteId for Web");
// Get the web's key address.
hr = WcaGetRecordString(hRec, wqAddress, &pwzData);
ExitOnFailure(hr, "Failed to get Address for Web");
hr = ::StringCchCopyW(psw->swaKey.wzKey, countof(psw->swaKey.wzKey), pwzData);
ExitOnFailure(hr, "Failed to copy key string to web object");
hr = WcaGetRecordString(hRec, wqIP, &pwzData);
ExitOnFailure(hr, "Failed to get IP for Web");
hr = ::StringCchCopyW(psw->swaKey.wzIP, countof(psw->swaKey.wzIP), pwzData);
ExitOnFailure(hr, "Failed to copy IP string to web object");
hr = WcaGetRecordString(hRec, wqPort, &pwzData);
ExitOnFailure(hr, "Failed to get Web Address port");
psw->swaKey.iPort = wcstol(pwzData, NULL, 10);
hr = WcaGetRecordString(hRec, wqHeader, &pwzData);
ExitOnFailure(hr, "Failed to get Header for Web");
hr = ::StringCchCopyW(psw->swaKey.wzHeader, countof(psw->swaKey.wzHeader), pwzData);
ExitOnFailure(hr, "Failed to copy header string to web object");
hr = WcaGetRecordInteger(hRec, wqSecure, &psw->swaKey.fSecure);
ExitOnFailure(hr, "Failed to get if Web is secure");
if (S_FALSE == hr)
{
psw->swaKey.fSecure = FALSE;
}
// Get the web's description.
hr = WcaGetRecordString(hRec, wqDescription, &pwzData);
ExitOnFailure(hr, "Failed to get Description for Web");
hr = ::StringCchCopyW(psw->wzDescription, countof(psw->wzDescription), pwzData);
ExitOnFailure(hr, "Failed to copy description string to web object");
// Try to find the web root in case it already exists.
dwLen = METADATA_MAX_NAME_LEN;
hr = ScaWebFindBase(piMetabase, *ppswList,
psw->wzKey,
iSiteId,
psw->swaKey.wzIP,
psw->swaKey.iPort,
psw->swaKey.wzHeader,
psw->swaKey.fSecure,
psw->wzDescription,
psw->wzWebBase, dwLen);
if (S_OK == hr)
{
psw->fBaseExists = TRUE;
}
else if (S_FALSE == hr) // didn't find the web site.
{
psw->fBaseExists = FALSE;
// If we're actually configuring the web site.
if (psw->fHasComponent)
{
if (WcaIsInstalling(psw->isInstalled, psw->isAction))
{
hr = ScaWebFindFreeBase(piMetabase, *ppswList, iSiteId, psw->wzDescription, psw->wzWebBase, countof(psw->wzWebBase));
ExitOnFailure(hr, "Failed to find free web root.");
}
else if (WcaIsUninstalling(psw->isInstalled, psw->isAction))
{
WcaLog(LOGMSG_VERBOSE, "Web site: '%ls' was already removed, skipping.", psw->wzKey);
hr = S_OK;
continue;
}
}
}
ExitOnFailure(hr, "Failed to find web root");
// get any extra web addresses
WcaFetchWrappedReset(hQueryWebAddress);
while (S_OK == (hr = WcaFetchWrappedRecordWhereString(hQueryWebAddress, 2, psw->wzKey, &hRecAddresses)))
{
if (MAX_ADDRESSES_PER_WEB <= psw->cExtraAddresses)
{
hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
ExitOnFailure(hr, "Failure to get more extra web addresses, max exceeded.");
}
hr = WcaGetRecordString(hRecAddresses, waqAddress, &pwzData);
ExitOnFailure(hr, "Failed to get extra web Address");
// if this isn't the key address add it
if (0 != lstrcmpW(pwzData, psw->swaKey.wzKey))
{
hr = ::StringCchCopyW(psw->swaExtraAddresses[psw->cExtraAddresses].wzKey, countof(psw->swaExtraAddresses[psw->cExtraAddresses].wzKey), pwzData);
ExitOnFailure(hr, "Failed to copy extra addresses key string to web object");
hr = WcaGetRecordString(hRecAddresses, waqIP, &pwzData);
ExitOnFailure(hr, "Failed to get extra web IP");
hr = ::StringCchCopyW(psw->swaExtraAddresses[psw->cExtraAddresses].wzIP, countof(psw->swaExtraAddresses[psw->cExtraAddresses].wzIP), pwzData);
ExitOnFailure(hr, "Failed to copy extra addresses IP string to web object");
hr = WcaGetRecordString(hRecAddresses, waqPort, &pwzData);
ExitOnFailure(hr, "Failed to get port for extra web IP");
psw->swaExtraAddresses[psw->cExtraAddresses].iPort= wcstol(pwzData, NULL, 10);
hr = WcaGetRecordString(hRecAddresses, waqHeader, &pwzData);
ExitOnFailure(hr, "Failed to get header for extra web IP");
hr = ::StringCchCopyW(psw->swaExtraAddresses[psw->cExtraAddresses].wzHeader, countof(psw->swaExtraAddresses[psw->cExtraAddresses].wzHeader), pwzData);
ExitOnFailure(hr, "Failed to copy extra addresses header string to web object");
hr = WcaGetRecordInteger(hRecAddresses, waqSecure, &psw->swaExtraAddresses[psw->cExtraAddresses].fSecure);
ExitOnFailure(hr, "Failed to get if secure extra web IP");
if (S_FALSE == hr)
psw->swaExtraAddresses[psw->cExtraAddresses].fSecure = FALSE;
++psw->cExtraAddresses;
}
}
if (E_NOMOREITEMS == hr)
hr = S_OK;
ExitOnFailure(hr, "Failure occured while getting extra web addresses");
hr = WcaGetRecordInteger(hRec, wqConnectionTimeout, &psw->iConnectionTimeout);
ExitOnFailure(hr, "Failed to get connection timeout for Web");
if (psw->fHasComponent) // If we're installing it, it needs a dir
{
// get the web's directory
if (INSTALLSTATE_SOURCE == psw->isAction)
{
hr = WcaGetRecordString(hRec, wqSourcePath, &pwzData);
}
else
{
hr = WcaGetRecordString(hRec, wqTargetPath, &pwzData);
}
ExitOnFailure(hr, "Failed to get Source/TargetPath for Directory");
// remove trailing backslashes
while (lstrlenW(pwzData) > 0 && pwzData[lstrlenW(pwzData)-1] == L'\\')
{
pwzData[lstrlenW(pwzData)-1] = 0;
}
hr = ::StringCchCopyW(psw->wzDirectory, countof(psw->wzDirectory), pwzData);
ExitOnFailure(hr, "Failed to copy directory string to web object");
}
hr = WcaGetRecordInteger(hRec, wqState, &psw->iState);
ExitOnFailure(hr, "Failed to get state for Web");
hr = WcaGetRecordInteger(hRec, wqAttributes, &psw->iAttributes);
ExitOnFailure(hr, "Failed to get attributes for Web");
// get the dir properties for this web
hr = WcaGetRecordString(hRec, wqProperties, &pwzData);
ExitOnFailure(hr, "Failed to get directory property record for Web");
if (*pwzData)
{
hr = ScaGetWebDirProperties(pwzData, hUserQuery, hWebDirPropQuery, &psw->swp);
ExitOnFailure(hr, "Failed to get directory properties for Web");
psw->fHasProperties = TRUE;
}
// get the application information for this web
hr = WcaGetRecordString(hRec, wqApplication, &pwzData);
ExitOnFailure(hr, "Failed to get application identifier for Web");
if (*pwzData)
{
hr = ScaGetWebApplication(NULL, pwzData, hWebAppQuery, hWebAppExtQuery, &psw->swapp);
ExitOnFailure(hr, "Failed to get application for Web");
psw->fHasApplication = TRUE;
}
// get the SSL certificates
hr = ScaSslCertificateRead(psw->wzKey, hSslCertQuery, &(psw->pswscList));
ExitOnFailure(hr, "Failed to get SSL Certificates.");
// get the custom headers
if (*ppshhList)
{
hr = ScaGetHttpHeader(hhptWeb, psw->wzKey, ppshhList, &(psw->pshhList));
ExitOnFailure(hr, "Failed to get Custom HTTP Headers");
}
// get the errors
if (*ppsweList)
{
hr = ScaGetWebError(weptWeb, psw->wzKey, ppsweList, &(psw->psweList));
ExitOnFailure(hr, "Failed to get Custom Errors");
}
// get the log information for this web
hr = WcaGetRecordString(hRec, wqLog, &pwzData);
ExitOnFailure(hr, "Failed to get log identifier for Web");
if (*pwzData)
{
hr = ScaGetWebLog(piMetabase, pwzData, hWebLogQuery, &psw->swl);
ExitOnFailure(hr, "Failed to get Log for Web.");
psw->fHasLog = TRUE;
}
*ppswList = AddWebToList(*ppswList, psw);
psw = NULL; // set the web NULL so it doesn't accidentally get freed below
}
if (E_NOMOREITEMS == hr)
{
hr = S_OK;
}
LExit:
// if anything was left over after an error clean it all up
WcaFinishUnwrapQuery(hQueryWebSite);
WcaFinishUnwrapQuery(hQueryWebAddress);
if (psw)
{
ScaWebsFreeList(psw);
}
ReleaseStr(pwzData);
return hr;
}
static HRESULT TrusteesInApplicationRolesRead(
LPCWSTR pwzQuery,
CPI_APPLICATION_ROLE_LIST* pAppRoleList,
CPI_USER_IN_APPLICATION_ROLE_LIST* pUsrInAppRoleList
)
{
HRESULT hr = S_OK;
UINT er = ERROR_SUCCESS;
PMSIHANDLE hView, hRec;
CPI_USER_IN_APPLICATION_ROLE* pItm = NULL;
LPWSTR pwzData = NULL;
LPWSTR pwzDomain = NULL;
LPWSTR pwzName = NULL;
BOOL fMatchingArchitecture = FALSE;
// loop through all application roles
hr = WcaOpenExecuteView(pwzQuery, &hView);
ExitOnFailure(hr, "Failed to execute view on table");
while (S_OK == (hr = WcaFetchRecord(hView, &hRec)))
{
// get component
hr = WcaGetRecordString(hRec, tiarqComponent, &pwzData);
ExitOnFailure(hr, "Failed to get component");
// check if the component is our processor architecture
hr = CpiVerifyComponentArchitecure(pwzData, &fMatchingArchitecture);
ExitOnFailure(hr, "Failed to get component architecture.");
if (!fMatchingArchitecture)
{
continue; // not the same architecture, ignore
}
// create entry
pItm = (CPI_USER_IN_APPLICATION_ROLE*)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CPI_USER_IN_APPLICATION_ROLE));
if (!pItm)
ExitFunction1(hr = E_OUTOFMEMORY);
// get component install state
er = ::MsiGetComponentStateW(WcaGetInstallHandle(), pwzData, &pItm->isInstalled, &pItm->isAction);
ExitOnFailure(hr = HRESULT_FROM_WIN32(er), "Failed to get component state");
// get key
hr = WcaGetRecordString(hRec, tiarqUserInApplicationRole, &pwzData);
ExitOnFailure(hr, "Failed to get key");
StringCchCopyW(pItm->wzKey, countof(pItm->wzKey), pwzData);
// get application role
hr = WcaGetRecordString(hRec, tiarqApplicationRole, &pwzData);
ExitOnFailure(hr, "Failed to get application role");
hr = CpiApplicationRoleFindByKey(pAppRoleList, pwzData, &pItm->pApplicationRole);
if (S_FALSE == hr)
hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
ExitOnFailure1(hr, "Failed to find application role, key: %S", pwzData);
// get user domain
hr = WcaGetRecordFormattedString(hRec, tiarqDomain, &pwzDomain);
ExitOnFailure(hr, "Failed to get domain");
// get user name
hr = WcaGetRecordFormattedString(hRec, tiarqName, &pwzName);
ExitOnFailure(hr, "Failed to get name");
// build account name
hr = CpiBuildAccountName(pwzDomain, pwzName, &pItm->pwzAccount);
ExitOnFailure(hr, "Failed to build account name");
// set references & increment counters
if (WcaIsInstalling(pItm->isInstalled, pItm->isAction))
{
CpiApplicationRoleAddReferenceInstall(pItm->pApplicationRole);
pUsrInAppRoleList->iInstallCount++;
}
if (WcaIsUninstalling(pItm->isInstalled, pItm->isAction))
{
CpiApplicationRoleAddReferenceUninstall(pItm->pApplicationRole);
pUsrInAppRoleList->iUninstallCount++;
}
// add entry
if (pUsrInAppRoleList->pFirst)
pItm->pNext = pUsrInAppRoleList->pFirst;
pUsrInAppRoleList->pFirst = pItm;
pItm = NULL;
}
if (E_NOMOREITEMS == hr)
hr = S_OK;
LExit:
// clean up
if (pItm)
FreeUserInApplicationRole(pItm);
ReleaseStr(pwzData);
ReleaseStr(pwzDomain);
ReleaseStr(pwzName);
return hr;
}
