/******************************************************************
AddPortException
********************************************************************/
static HRESULT AddPortException(
__in LPCWSTR wzName,
__in int iProfile,
__in_opt LPCWSTR wzRemoteAddresses,
__in BOOL fIgnoreFailures,
__in LPCWSTR wzPort,
__in int iProtocol,
__in LPCWSTR wzDescription
)
{
HRESULT hr = S_OK;
BSTR bstrName = NULL;
INetFwRules* pNetFwRules = NULL;
INetFwRule* pNetFwRule = NULL;
// convert to BSTRs to make COM happy
bstrName = ::SysAllocString(wzName);
ExitOnNull(bstrName, hr, E_OUTOFMEMORY, "failed SysAllocString for name");
// get the collection of firewall rules
hr = GetFirewallRules(fIgnoreFailures, &pNetFwRules);
ExitOnFailure(hr, "failed to get firewall rules object");
if (S_FALSE == hr) // user or package author chose to ignore missing firewall
{
ExitFunction();
}
// try to find it (i.e., support reinstall)
hr = pNetFwRules->Item(bstrName, &pNetFwRule);
if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr)
{
hr = CreateFwRuleObject(bstrName, iProfile, wzRemoteAddresses, wzPort, iProtocol, wzDescription, &pNetFwRule);
ExitOnFailure(hr, "failed to create FwRule object");
// enable it
hr = pNetFwRule->put_Enabled(VARIANT_TRUE);
ExitOnFailure(hr, "failed to to enable port exception");
// add it to the list of authorized ports
hr = pNetFwRules->Add(pNetFwRule);
ExitOnFailure(hr, "failed to add app to the authorized ports list");
}
else
{
// we found an existing port exception (if we succeeded, that is)
ExitOnFailure(hr, "failed trying to find existing port rule");
// enable it (just in case it was disabled)
pNetFwRule->put_Enabled(VARIANT_TRUE);
}
LExit:
ReleaseBSTR(bstrName);
ReleaseObject(pNetFwRules);
ReleaseObject(pNetFwRule);
return fIgnoreFailures ? S_OK : hr;
}
void CpiFinalize()
{
// collections
ReleaseObject(gpiCatalog);
ReleaseObject(gpiPartColl);
ReleaseObject(gpiAppColl);
}
MaterialDemo::~MaterialDemo()
{
DeleteObject(mBasicMaterial);
DeleteObject(mBasicEffect);
ReleaseObject(mVertexBuffer);
ReleaseObject(mIndexBuffer);
}
static HRESULT GetShellDispatchFromView(
__in IShellView *psv,
__in REFIID riid,
__out void **ppv
)
{
HRESULT hr = S_OK;
IDispatch *pdispBackground = NULL;
IShellFolderViewDual *psfvd = NULL;
IDispatch *pdisp = NULL;
// From a shell view object, gets its automation interface and from that get the shell
// application object that implements IShellDispatch2 and related interfaces.
hr = psv->GetItemObject(SVGIO_BACKGROUND, IID_PPV_ARGS(&pdispBackground));
ExitOnFailure(hr, "Failed to get the automation interface for shell.");
hr = pdispBackground->QueryInterface(IID_PPV_ARGS(&psfvd));
ExitOnFailure(hr, "Failed to get shell folder view dual.");
hr = psfvd->get_Application(&pdisp);
ExitOnFailure(hr, "Failed to application object.");
hr = pdisp->QueryInterface(riid, ppv);
ExitOnFailure(hr, "Failed to get IShellDispatch2.");
LExit:
ReleaseObject(pdisp);
ReleaseObject(psfvd);
ReleaseObject(pdispBackground);
return hr;
}
/******************************************************************
RemoveApplicationExceptionFromCurrentProfile
********************************************************************/
static HRESULT RemoveApplicationExceptionFromCurrentProfile(
__in LPCWSTR wzFile,
__in BOOL fIgnoreFailures
)
{
HRESULT hr = S_OK;
INetFwProfile* pfwProfile = NULL;
INetFwAuthorizedApplications* pfwApps = NULL;
// convert to BSTRs to make COM happy
BSTR bstrFile = ::SysAllocString(wzFile);
ExitOnNull(bstrFile, hr, E_OUTOFMEMORY, "failed SysAllocString for path");
// get the firewall profile, which is our entry point for removing exceptions
hr = GetCurrentFirewallProfile(fIgnoreFailures, &pfwProfile);
ExitOnFailure(hr, "failed to get firewall profile");
if (S_FALSE == hr) // user or package author chose to ignore missing firewall
{
ExitFunction();
}
// now get the list of app exceptions and remove the one
hr = pfwProfile->get_AuthorizedApplications(&pfwApps);
ExitOnFailure(hr, "failed to get list of authorized apps");
hr = pfwApps->Remove(bstrFile);
ExitOnFailure(hr, "failed to remove authorized app");
LExit:
ReleaseBSTR(bstrFile);
ReleaseObject(pfwApps);
ReleaseObject(pfwProfile);
return fIgnoreFailures ? S_OK : hr;
}
RenderStateHelper::~RenderStateHelper()
{
ReleaseObject(mRasterizerState);
ReleaseObject(mBlendState);
ReleaseObject(mDepthStencilState);
DeleteObject(mBlendFactor);
}
extern "C" HRESULT CatalogsParseFromXml(
__in BURN_CATALOGS* pCatalogs,
__in IXMLDOMNode* pixnBundle
)
{
HRESULT hr = S_OK;
IXMLDOMNodeList* pixnNodes = NULL;
IXMLDOMNode* pixnNode = NULL;
DWORD cNodes = 0;
LPWSTR scz = NULL;
// select catalog nodes
hr = XmlSelectNodes(pixnBundle, L"Catalog", &pixnNodes);
ExitOnFailure(hr, "Failed to select catalog nodes.");
// get catalog node count
hr = pixnNodes->get_length((long*)&cNodes);
ExitOnFailure(hr, "Failed to get payload node count.");
if (!cNodes)
{
ExitFunction();
}
// allocate memory for catalogs
pCatalogs->rgCatalogs = (BURN_CATALOG*)MemAlloc(sizeof(BURN_CATALOG) * cNodes, TRUE);
ExitOnNull(pCatalogs->rgCatalogs, hr, E_OUTOFMEMORY, "Failed to allocate memory for payload structs.");
pCatalogs->cCatalogs = cNodes;
// parse catalog elements
for (DWORD i = 0; i < cNodes; ++i)
{
BURN_CATALOG* pCatalog = &pCatalogs->rgCatalogs[i];
pCatalog->hFile = INVALID_HANDLE_VALUE;
hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
ExitOnFailure(hr, "Failed to get next node.");
// @Id
hr = XmlGetAttributeEx(pixnNode, L"Id", &pCatalog->sczKey);
ExitOnFailure(hr, "Failed to get @Id.");
// @Payload
hr = XmlGetAttributeEx(pixnNode, L"Payload", &pCatalog->sczPayload);
ExitOnFailure(hr, "Failed to get @Payload.");
// prepare next iteration
ReleaseNullObject(pixnNode);
}
LExit:
ReleaseObject(pixnNodes);
ReleaseObject(pixnNode);
ReleaseStr(scz);
return hr;
}
static HRESULT CreatePartition(
CPI_PARTITION_ATTRIBUTES* pAttrs
)
{
HRESULT hr = S_OK;
ICatalogCollection* piPartColl = NULL;
ICatalogObject* piPartObj = NULL;
long lChanges = 0;
// log
WcaLog(LOGMSG_VERBOSE, "Creating partition, key: %S", pAttrs->pwzKey);
// get partitions collection
hr = CpiGetPartitionsCollection(&piPartColl);
ExitOnFailure(hr, "Failed to get partitions collection");
// check if partition exists
hr = CpiFindCollectionObjectByStringKey(piPartColl, pAttrs->pwzID, &piPartObj);
ExitOnFailure(hr, "Failed to find partition");
if (S_FALSE == hr)
{
// create partition
hr = CpiAddCollectionObject(piPartColl, &piPartObj);
ExitOnFailure(hr, "Failed to add partition to collection");
hr = CpiPutCollectionObjectValue(piPartObj, L"ID", pAttrs->pwzID);
ExitOnFailure(hr, "Failed to set partition id property");
hr = CpiPutCollectionObjectValue(piPartObj, L"Name", pAttrs->pwzName);
ExitOnFailure(hr, "Failed to set partition name property");
}
// properties
hr = CpiPutCollectionObjectValues(piPartObj, pAttrs->pPropList);
ExitOnFailure(hr, "Failed to write properties");
// save changes
hr = piPartColl->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(piPartColl);
ReleaseObject(piPartObj);
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;
}
/******************************************************************
GetCurrentFirewallProfile - get the active firewall profile as an
INetFwProfile, which owns the lists of exceptions we're
updating.
********************************************************************/
static HRESULT GetCurrentFirewallProfile(
__in BOOL fIgnoreFailures,
__out INetFwProfile** ppfwProfile
)
{
HRESULT hr = S_OK;
INetFwMgr* pfwMgr = NULL;
INetFwPolicy* pfwPolicy = NULL;
INetFwProfile* pfwProfile = NULL;
*ppfwProfile = NULL;
do
{
ReleaseNullObject(pfwPolicy);
ReleaseNullObject(pfwMgr);
ReleaseNullObject(pfwProfile);
if (SUCCEEDED(hr = ::CoCreateInstance(__uuidof(NetFwMgr), NULL, CLSCTX_INPROC_SERVER, __uuidof(INetFwMgr), (void**)&pfwMgr)) &&
SUCCEEDED(hr = pfwMgr->get_LocalPolicy(&pfwPolicy)) &&
SUCCEEDED(hr = pfwPolicy->get_CurrentProfile(&pfwProfile)))
{
break;
}
else if (fIgnoreFailures)
{
ExitFunction1(hr = S_FALSE);
}
else
{
WcaLog(LOGMSG_STANDARD, "Failed to connect to Windows Firewall");
UINT er = WcaErrorMessage(msierrFirewallCannotConnect, hr, INSTALLMESSAGE_ERROR | MB_ABORTRETRYIGNORE, 0);
switch (er)
{
case IDABORT: // exit with the current HRESULT
ExitFunction();
case IDRETRY: // clean up and retry the loop
hr = S_FALSE;
break;
case IDIGNORE: // pass S_FALSE back to the caller, who knows how to ignore the failure
ExitFunction1(hr = S_FALSE);
default: // No UI, so default is to fail.
ExitFunction();
}
}
} while (S_FALSE == hr);
*ppfwProfile = pfwProfile;
pfwProfile = NULL;
LExit:
ReleaseObject(pfwPolicy);
ReleaseObject(pfwMgr);
ReleaseObject(pfwProfile);
return hr;
}
static HRESULT CreateApplicationRole(
CPI_APPLICATION_ROLE_ATTRIBUTES* pAttrs
)
{
HRESULT hr = S_OK;
ICatalogCollection* piRolesColl = NULL;
ICatalogObject* piRoleObj = NULL;
long lChanges = 0;
// log
WcaLog(LOGMSG_VERBOSE, "Creating application role, key: %S", pAttrs->pwzKey);
// get roles collection
hr = CpiGetRolesCollection(pAttrs->pwzPartID, pAttrs->pwzAppID, &piRolesColl);
if (S_FALSE == hr)
hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
ExitOnFailure(hr, "Failed to get roles collection");
// check if role exists
hr = CpiFindCollectionObjectByName(piRolesColl, pAttrs->pwzName, &piRoleObj);
ExitOnFailure(hr, "Failed to find role");
if (S_FALSE == hr)
{
// create role
hr = CpiAddCollectionObject(piRolesColl, &piRoleObj);
ExitOnFailure(hr, "Failed to add role to collection");
hr = CpiPutCollectionObjectValue(piRoleObj, L"Name", pAttrs->pwzName);
ExitOnFailure(hr, "Failed to set role name property");
}
// properties
hr = CpiPutCollectionObjectValues(piRoleObj, pAttrs->pPropList);
ExitOnFailure(hr, "Failed to write properties");
// 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);
ReleaseObject(piRoleObj);
return hr;
}
void plDXTextFont::DestroyObjects()
{
ReleaseObject(fOldStateBlock);
ReleaseObject(fTextStateBlock);
ReleaseObject(fD3DTexture);
fOldStateBlock = fTextStateBlock = 0;
fD3DTexture = nil;
fInitialized = false;
}
static HRESULT GetDesktopShellView(
__in REFIID riid,
__out void **ppv
)
{
HRESULT hr = S_OK;
IShellWindows* psw = NULL;
HWND hwnd = NULL;
IDispatch* pdisp = NULL;
VARIANT vEmpty = {}; // VT_EMPTY
IShellBrowser* psb = NULL;
IShellFolder* psf = NULL;
IShellView* psv = NULL;
// use the shell view for the desktop using the shell windows automation to find the
// desktop web browser and then grabs its view
// returns IShellView, IFolderView and related interfaces
hr = ::CoCreateInstance(CLSID_ShellWindows, NULL, CLSCTX_LOCAL_SERVER, IID_PPV_ARGS(&psw));
ExitOnFailure(hr, "Failed to get shell view.");
hr = psw->FindWindowSW(&vEmpty, &vEmpty, SWC_DESKTOP, (long*)&hwnd, SWFO_NEEDDISPATCH, &pdisp);
if (S_OK == hr)
{
hr = IUnknown_QueryService(pdisp, SID_STopLevelBrowser, IID_PPV_ARGS(&psb));
ExitOnFailure(hr, "Failed to get desktop window.");
hr = psb->QueryActiveShellView(&psv);
ExitOnFailure(hr, "Failed to get active shell view.");
hr = psv->QueryInterface(riid, ppv);
ExitOnFailure(hr, "Failed to query for the desktop shell view.");
}
else if (S_FALSE == hr)
{
//Windows XP
hr = SHGetDesktopFolder(&psf);
ExitOnFailure(hr, "Failed to get desktop folder.");
hr = psf->CreateViewObject(NULL, IID_IShellView, ppv);
ExitOnFailure(hr, "Failed to query for the desktop shell view.");
}
else
{
ExitOnFailure(hr, "Failed to get desktop window.");
}
LExit:
ReleaseObject(psv);
ReleaseObject(psb);
ReleaseObject(psf);
ReleaseObject(pdisp);
ReleaseObject(psw);
return hr;
}
/********************************************************************
SqlCommandExecuteQuery - executes a SQL command and returns the results if desired
NOTE: ppirs and pcRoes are optional
********************************************************************/
extern "C" HRESULT DAPI SqlCommandExecuteQuery(
__in IDBCreateCommand* pidbCommand,
__in __sql_command LPCWSTR wzSql,
__out IRowset** ppirs,
__out DBROWCOUNT* pcRows
)
{
Assert(pidbCommand);
HRESULT hr = S_OK;
ICommandText* picmdText = NULL;
ICommand* picmd = NULL;
DBROWCOUNT cRows = 0;
if (pcRows)
{
*pcRows = NULL;
}
//
// create the command
//
hr = pidbCommand->CreateCommand(NULL, IID_ICommand, (IUnknown**)&picmd);
ExitOnFailure(hr, "failed to create command to execute session");
//
// set the sql text into the command
//
hr = picmd->QueryInterface(IID_ICommandText, (LPVOID*)&picmdText);
ExitOnFailure(hr, "failed to get command text object for command");
hr = picmdText->SetCommandText(DBGUID_DEFAULT , wzSql);
ExitOnFailure1(hr, "failed to set SQL string: %ls", wzSql);
//
// execute the command
//
hr = picmd->Execute(NULL, (ppirs) ? IID_IRowset : IID_NULL, NULL, &cRows, reinterpret_cast<IUnknown**>(ppirs));
ExitOnFailure1(hr, "failed to execute SQL string: %ls", wzSql);
if (DB_S_ERRORSOCCURRED == hr)
{
hr = E_FAIL;
}
if (pcRows)
{
*pcRows = cRows;
}
LExit:
ReleaseObject(picmd);
ReleaseObject(picmdText);
return hr;
}
static void FreePartition(
CPI_PARTITION* pItm
)
{
if (pItm->pProperties)
CpiPropertiesFreeList(pItm->pProperties);
ReleaseObject(pItm->piApplicationsColl);
ReleaseObject(pItm->piRolesColl);
::HeapFree(::GetProcessHeap(), 0, pItm);
}
HRESULT CpiGetCatalogCollection(
ICatalogCollection* piColl,
ICatalogObject* piObj,
LPCWSTR pwzName,
ICatalogCollection** ppiColl
)
{
HRESULT hr = S_OK;
ICOMAdminCatalog* piCatalog = NULL;
IDispatch* piDisp = NULL;
BSTR bstrName = NULL;
VARIANT vtKey;
::VariantInit(&vtKey);
// copy name string
bstrName = ::SysAllocString(pwzName);
ExitOnNull(bstrName, hr, E_OUTOFMEMORY, "Failed to allocate BSTR for collection name");
// get catalog
hr = CpiGetAdminCatalog(&piCatalog);
ExitOnFailure(hr, "Failed to get COM+ admin catalog");
// get key
hr = piObj->get_Key(&vtKey);
ExitOnFailure(hr, "Failed to get object key");
// get collecton from catalog
hr = piColl->GetCollection(bstrName, vtKey, &piDisp);
ExitOnFailure(hr, "Failed to get collection");
hr = piDisp->QueryInterface(IID_ICatalogCollection, (void**)ppiColl);
ExitOnFailure(hr, "Failed to get IID_ICatalogCollection interface");
// populate collection
hr = (*ppiColl)->Populate();
if (COMADMIN_E_OBJECTERRORS == hr)
CpiLogCatalogErrorInfo();
ExitOnFailure(hr, "Failed to populate collection");
hr = S_OK;
LExit:
// clean up
ReleaseObject(piCatalog);
ReleaseObject(piDisp);
ReleaseBSTR(bstrName);
::VariantClear(&vtKey);
return hr;
}
static HRESULT ParseWxlControls(
__in IXMLDOMElement* pElement,
__in WIX_LOCALIZATION* pWixLoc
)
{
HRESULT hr = S_OK;
IXMLDOMNode* pixn = NULL;
IXMLDOMNodeList* pixnl = NULL;
DWORD dwIdx = 0;
hr = XmlSelectNodes(pElement, L"UI|Control", &pixnl);
ExitOnLastError(hr, "Failed to get UI child nodes of Wxl File.");
hr = pixnl->get_length(reinterpret_cast<long*>(&pWixLoc->cLocControls));
ExitOnLastError(hr, "Failed to get number of UI child nodes in Wxl File.");
if (0 < pWixLoc->cLocControls)
{
pWixLoc->rgLocControls = static_cast<LOC_CONTROL*>(MemAlloc(sizeof(LOC_CONTROL) * pWixLoc->cLocControls, TRUE));
ExitOnNull(pWixLoc->rgLocControls, hr, E_OUTOFMEMORY, "Failed to allocate memory for localized controls.");
while (S_OK == (hr = XmlNextElement(pixnl, &pixn, NULL)))
{
hr = ParseWxlControl(pixn, dwIdx, pWixLoc);
ExitOnFailure(hr, "Failed to parse localized control.");
++dwIdx;
ReleaseNullObject(pixn);
}
hr = S_OK;
ExitOnFailure(hr, "Failed to enumerate all localized controls.");
}
LExit:
if (FAILED(hr) && pWixLoc->rgLocControls)
{
for (DWORD idx = 0; idx < pWixLoc->cLocControls; ++idx)
{
ReleaseStr(pWixLoc->rgLocControls[idx].wzControl);
ReleaseStr(pWixLoc->rgLocControls[idx].wzText);
}
ReleaseMem(pWixLoc->rgLocControls);
}
ReleaseObject(pixn);
ReleaseObject(pixnl);
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;
}
TextureModelDemo::~TextureModelDemo()
{
ReleaseObject(mColorTextureVariable);
ReleaseObject(mTextureShaderResourceView);
ReleaseObject(mWvpVariable);
ReleaseObject(mPass);
ReleaseObject(mTechnique);
ReleaseObject(mEffect);
ReleaseObject(mInputLayout);
ReleaseObject(mVertexBuffer);
ReleaseObject(mIndexBuffer);
}
/********************************************************************
SqlDropDatabase - removes a database from a server if it exists
NOTE: wzInstance is optional
if fIntegratedAuth is set then wzUser and wzPassword are ignored
********************************************************************/
extern "C" HRESULT DAPI SqlDropDatabase(
__in_z LPCWSTR wzServer,
__in_z LPCWSTR wzInstance,
__in_z LPCWSTR wzDatabase,
__in BOOL fIntegratedAuth,
__in_z LPCWSTR wzUser,
__in_z LPCWSTR wzPassword,
__out_opt BSTR* pbstrErrorDescription
)
{
Assert(wzServer && wzDatabase && *wzDatabase);
HRESULT hr = S_OK;
IDBCreateSession* pidbSession = NULL;
//
// connect to the master database to search for wzDatabase
//
hr = SqlConnectDatabase(wzServer, wzInstance, L"master", fIntegratedAuth, wzUser, wzPassword, &pidbSession);
ExitOnFailure(hr, "Failed to connect to 'master' database");
hr = SqlSessionDropDatabase(pidbSession, wzDatabase, pbstrErrorDescription);
LExit:
ReleaseObject(pidbSession);
return hr;
}
/********************************************************************
SqlCreateDatabase - creates a database on the server
NOTE: wzInstance is optional
if fIntegratedAuth is set then wzUser and wzPassword are ignored
********************************************************************/
extern "C" HRESULT DAPI SqlCreateDatabase(
__in_z LPCWSTR wzServer,
__in_z LPCWSTR wzInstance,
__in_z LPCWSTR wzDatabase,
__in BOOL fIntegratedAuth,
__in_z LPCWSTR wzUser,
__in_z LPCWSTR wzPassword,
__in_opt const SQL_FILESPEC* psfDatabase,
__in_opt const SQL_FILESPEC* psfLog,
__out_opt BSTR* pbstrErrorDescription
)
{
Assert(wzServer && wzDatabase && *wzDatabase);
HRESULT hr = S_OK;
IDBCreateSession* pidbSession = NULL;
//
// connect to the master database to create the new database
//
hr = SqlConnectDatabase(wzServer, wzInstance, L"master", fIntegratedAuth, wzUser, wzPassword, &pidbSession);
ExitOnFailure1(hr, "failed to connect to 'master' database on server %ls", wzServer);
hr = SqlSessionCreateDatabase(pidbSession, wzDatabase, psfDatabase, psfLog, pbstrErrorDescription);
ExitOnFailure1(hr, "failed to create database: %ls", wzDatabase);
Assert(S_OK == hr);
LExit:
ReleaseObject(pidbSession);
return hr;
}
/********************************************************************
SqlDatabaseExists - determines if database exists
NOTE: wzInstance is optional
if fIntegratedAuth is set then wzUser and wzPassword are ignored
returns S_OK if database exist
returns S_FALSE if database does not exist
returns E_* on error
********************************************************************/
extern "C" HRESULT DAPI SqlDatabaseExists(
__in_z LPCWSTR wzServer,
__in_z LPCWSTR wzInstance,
__in_z LPCWSTR wzDatabase,
__in BOOL fIntegratedAuth,
__in_z LPCWSTR wzUser,
__in_z LPCWSTR wzPassword,
__out_opt BSTR* pbstrErrorDescription
)
{
Assert(wzServer && wzDatabase && *wzDatabase);
HRESULT hr = S_OK;
IDBCreateSession* pidbSession = NULL;
hr = SqlConnectDatabase(wzServer, wzInstance, L"master", fIntegratedAuth, wzUser, wzPassword, &pidbSession);
ExitOnFailure1(hr, "failed to connect to 'master' database on server %ls", wzServer);
hr = SqlSessionDatabaseExists(pidbSession, wzDatabase, pbstrErrorDescription);
LExit:
ReleaseObject(pidbSession);
return hr;
}
void CleanupObjects (void)
{
CObject *objP, *nextObjP = NULL;
int nLocalDeadPlayerObj = -1;
for (objP = gameData.objs.lists.all.head; objP; objP = nextObjP) {
nextObjP = objP->Links (0).next;
if (objP->info.nType == OBJ_NONE)
continue;
if (!(objP->info.nFlags & OF_SHOULD_BE_DEAD))
continue;
Assert ((objP->info.nType != OBJ_FIREBALL) || (objP->cType.explInfo.nDeleteTime == -1));
if (objP->info.nType != OBJ_PLAYER)
ReleaseObject (objP->Index ());
else {
if (objP->info.nId == gameData.multiplayer.nLocalPlayer) {
if (nLocalDeadPlayerObj == -1) {
StartPlayerDeathSequence (objP);
nLocalDeadPlayerObj = objP->Index ();
}
else
Int3 ();
}
}
}
}
extern "C" HRESULT DAPI LocLoadFromResource(
__in HMODULE hModule,
__in_z LPCSTR szResource,
__out WIX_LOCALIZATION** ppWixLoc
)
{
HRESULT hr = S_OK;
LPVOID pvResource = NULL;
DWORD cbResource = 0;
LPWSTR sczXml = NULL;
IXMLDOMDocument* pixd = NULL;
hr = ResReadData(hModule, szResource, &pvResource, &cbResource);
ExitOnFailure(hr, "Failed to read theme from resource.");
hr = StrAllocStringAnsi(&sczXml, reinterpret_cast<LPCSTR>(pvResource), cbResource, CP_UTF8);
ExitOnFailure(hr, "Failed to convert XML document data from UTF-8 to unicode string.");
hr = XmlLoadDocument(sczXml, &pixd);
ExitOnFailure(hr, "Failed to load theme resource as XML document.");
hr = ParseWxl(pixd, ppWixLoc);
ExitOnFailure(hr, "Failed to parse WXL.");
LExit:
ReleaseObject(pixd);
ReleaseStr(sczXml);
return hr;
}
// Create an SoH Processor object.
HRESULT CreateInputSoHProcessor(
_Outref_ INapSoHProcessor* &pISohProcessor,
_Out_ SystemHealthEntityId &systemHealthId,
_In_ BOOL sohType,
_In_ SoH *pInputSoh)
{
HRESULT hr = S_OK;
//
// Create the SoH processor that will be used for this input SoH.
//
pISohProcessor = NULL;
hr = CreateSoHProcessor(pISohProcessor);
if ( FAILED(hr) )
{
DebugPrintfW(L" --- SdkCommon - CreateInputSoHProcessor(): failed on call to CreateSoHProcessor (error = 0x%08x)" ,hr);
goto Cleanup;
}
// Initialize the SoH Processor, as specified by the caller.
hr = pISohProcessor->Initialize(pInputSoh, sohType, &systemHealthId);
if ( FAILED(hr) )
{
DebugPrintfW(L" --- SdkCommon - CreateInputSoHProcessor(): failed on call to Initialize (error = 0x%08x)" ,hr);
ReleaseObject(pISohProcessor);
}
Cleanup:
return hr;
}
// Create an SoH Constructor object.
HRESULT CreateOutputSoHConstructor(
_Outref_ INapSoHConstructor* &pISohConstructor,
_In_ SystemHealthEntityId systemHealthId,
_In_ BOOL sohType)
{
HRESULT hr = S_OK;
//
// Create an empty SoH Constructor for this client.
//
pISohConstructor = NULL;
hr = CreateSoHConstructor(pISohConstructor);
if ( FAILED(hr) )
{
DebugPrintfW(L" --- SdkCommon - CreateOutputSoHConstructor(): failed on call to CreateSoHConstructor (error = 0x%08x)" ,hr);
goto Cleanup;
}
// Initialize the SoH Constructor, as specified by the caller.
hr = pISohConstructor->Initialize(systemHealthId, sohType);
if ( FAILED(hr) )
{
DebugPrintfW(L" --- SdkCommon - CreateOutputSoHConstructor(): failed on call to Initialize (error = 0x%08x)" ,hr);
ReleaseObject(pISohConstructor);
}
Cleanup:
return hr;
}
void RemoveMonsterball (void)
{
if (gameData.hoard.monsterballP) {
ReleaseObject (OBJ_IDX (gameData.hoard.monsterballP));
gameData.hoard.monsterballP = NULL;
}
}
static HRESULT FindObjectForApplicationRole(
CPI_APPLICATION_ROLE* pItm,
ICatalogObject** ppiRoleObj
)
{
HRESULT hr = S_OK;
ICatalogCollection* piRoleColl = NULL;
// get roles collection
hr = CpiGetRolesCollForApplication(pItm->pApplication, &piRoleColl);
ExitOnFailure(hr, "Failed to get collection");
if (S_FALSE == hr)
ExitFunction(); // exit with hr = S_FALSE
// find role object
hr = CpiFindCollectionObject(piRoleColl, NULL, pItm->wzName, ppiRoleObj);
ExitOnFailure(hr, "Failed to find object");
// exit with hr from CpiFindCollectionObject()
LExit:
// clean up
ReleaseObject(piRoleColl);
return hr;
}
extern "C" HRESULT DAPI Iis7GetPropertyVariant(
__in IAppHostElement *pElement,
__in LPCWSTR wzPropName,
__in VARIANT* vtGet
)
{
HRESULT hr = S_OK;
IAppHostProperty *pProperty = NULL;
BSTR bstrPropName = NULL;
bstrPropName = ::SysAllocString(wzPropName);
ExitOnNull(bstrPropName, hr, E_OUTOFMEMORY, "failed SysAllocString");
hr = pElement->GetPropertyByName(bstrPropName, &pProperty);
ExitOnFailure1(hr, "Failed to get property object for %ls", wzPropName);
hr = pProperty->get_Value(vtGet);
ExitOnFailure1(hr, "Failed to get property value for %ls", wzPropName);
LExit:
ReleaseBSTR(bstrPropName);
// caller responsible for cleaning up variant vtGet
ReleaseObject(pProperty);
return hr;
}
/******************************************************************
RemoveException - Removes the exception rule with the given name.
********************************************************************/
static HRESULT RemoveException(
__in LPCWSTR wzName,
__in BOOL fIgnoreFailures
)
{
HRESULT hr = S_OK;;
INetFwRules* pNetFwRules = NULL;
// convert to BSTRs to make COM happy
BSTR bstrName = ::SysAllocString(wzName);
ExitOnNull(bstrName, hr, E_OUTOFMEMORY, "failed SysAllocString for path");
// get the collection of firewall rules
hr = GetFirewallRules(fIgnoreFailures, &pNetFwRules);
ExitOnFailure(hr, "failed to get firewall rules object");
if (S_FALSE == hr) // user or package author chose to ignore missing firewall
{
ExitFunction();
}
hr = pNetFwRules->Remove(bstrName);
ExitOnFailure(hr, "failed to remove authorized app");
LExit:
ReleaseBSTR(bstrName);
ReleaseObject(pNetFwRules);
return fIgnoreFailures ? S_OK : hr;
}
