From fdd47bab30235f62a8bcc7a5a88c6d69267046aa Mon Sep 17 00:00:00 2001 From: Sean Hall Date: Tue, 17 Nov 2020 18:53:13 -0600 Subject: Consolidate the code for the BA and bext engines. --- src/engine/EngineForApplication.cpp | 528 ++----------------------- src/engine/EngineForExtension.cpp | 191 +-------- src/engine/externalengine.cpp | 760 ++++++++++++++++++++++++++++++++++++ src/engine/externalengine.h | 154 ++++++++ src/engine/pseudobundle.cpp | 4 +- src/engine/pseudobundle.h | 4 +- 6 files changed, 956 insertions(+), 685 deletions(-) diff --git a/src/engine/EngineForApplication.cpp b/src/engine/EngineForApplication.cpp index e3ce7670..361e0f4e 100644 --- a/src/engine/EngineForApplication.cpp +++ b/src/engine/EngineForApplication.cpp @@ -3,12 +3,6 @@ #include "precomp.h" -static HRESULT CopyStringToBA( - __in LPWSTR wzValue, - __in_opt LPWSTR wzBuffer, - __inout DWORD* pcchBuffer - ); - static HRESULT BAEngineGetPackageCount( __in BOOTSTRAPPER_ENGINE_CONTEXT* pContext, __in const LPVOID pvArgs, @@ -18,9 +12,8 @@ static HRESULT BAEngineGetPackageCount( HRESULT hr = S_OK; ValidateMessageArgs(hr, pvArgs, BAENGINE_GETPACKAGECOUNT_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_GETPACKAGECOUNT_RESULTS, pResults); - DWORD* pcPackages = &pResults->cPackages; - *pcPackages = pContext->pEngineState->packages.cPackages; + ExternalEngineGetPackageCount(pContext->pEngineState, &pResults->cPackages); LExit: return hr; @@ -35,17 +28,8 @@ static HRESULT BAEngineGetVariableNumeric( HRESULT hr = S_OK; ValidateMessageArgs(hr, pvArgs, BAENGINE_GETVARIABLENUMERIC_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_GETVARIABLENUMERIC_RESULTS, pResults); - LPCWSTR wzVariable = pArgs->wzVariable; - LONGLONG* pllValue = &pResults->llValue; - if (wzVariable && *wzVariable) - { - hr = VariableGetNumeric(&pContext->pEngineState->variables, wzVariable, pllValue); - } - else - { - hr = E_INVALIDARG; - } + hr = ExternalEngineGetVariableNumeric(pContext->pEngineState, pArgs->wzVariable, &pResults->llValue); LExit: return hr; @@ -58,28 +42,12 @@ static HRESULT BAEngineGetVariableString( ) { HRESULT hr = S_OK; - LPWSTR sczValue = NULL; ValidateMessageArgs(hr, pvArgs, BAENGINE_GETVARIABLESTRING_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_GETVARIABLESTRING_RESULTS, pResults); - LPCWSTR wzVariable = pArgs->wzVariable; - LPWSTR wzValue = pResults->wzValue; - DWORD* pcchValue = &pResults->cchValue; - if (wzVariable && *wzVariable) - { - hr = VariableGetString(&pContext->pEngineState->variables, wzVariable, &sczValue); - if (SUCCEEDED(hr)) - { - hr = CopyStringToBA(sczValue, wzValue, pcchValue); - } - } - else - { - hr = E_INVALIDARG; - } + hr = ExternalEngineGetVariableString(pContext->pEngineState, pArgs->wzVariable, pResults->wzValue, &pResults->cchValue); LExit: - StrSecureZeroFreeString(sczValue); return hr; } @@ -90,29 +58,12 @@ static HRESULT BAEngineGetVariableVersion( ) { HRESULT hr = S_OK; - VERUTIL_VERSION* pVersion = NULL; ValidateMessageArgs(hr, pvArgs, BAENGINE_GETVARIABLEVERSION_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_GETVARIABLEVERSION_RESULTS, pResults); - LPCWSTR wzVariable = pArgs->wzVariable; - LPWSTR wzValue = pResults->wzValue; - DWORD* pcchValue = &pResults->cchValue; - if (wzVariable && *wzVariable) - { - hr = VariableGetVersion(&pContext->pEngineState->variables, wzVariable, &pVersion); - if (SUCCEEDED(hr)) - { - hr = CopyStringToBA(pVersion->sczVersion, wzValue, pcchValue); - } - } - else - { - hr = E_INVALIDARG; - } + hr = ExternalEngineGetVariableVersion(pContext->pEngineState, pArgs->wzVariable, pResults->wzValue, &pResults->cchValue); LExit: - ReleaseVerutilVersion(pVersion); - return hr; } @@ -123,28 +74,12 @@ static HRESULT BAEngineFormatString( ) { HRESULT hr = S_OK; - LPWSTR sczValue = NULL; ValidateMessageArgs(hr, pvArgs, BAENGINE_FORMATSTRING_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_FORMATSTRING_RESULTS, pResults); - LPCWSTR wzIn = pArgs->wzIn; - LPWSTR wzOut = pResults->wzOut; - DWORD* pcchOut = &pResults->cchOut; - if (wzIn && *wzIn) - { - hr = VariableFormatString(&pContext->pEngineState->variables, wzIn, &sczValue, NULL); - if (SUCCEEDED(hr)) - { - hr = CopyStringToBA(sczValue, wzOut, pcchOut); - } - } - else - { - hr = E_INVALIDARG; - } + hr = ExternalEngineFormatString(pContext->pEngineState, pArgs->wzIn, pResults->wzOut, &pResults->cchOut); LExit: - StrSecureZeroFreeString(sczValue); return hr; } @@ -155,28 +90,12 @@ static HRESULT BAEngineEscapeString( ) { HRESULT hr = S_OK; - LPWSTR sczValue = NULL; ValidateMessageArgs(hr, pvArgs, BAENGINE_ESCAPESTRING_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_ESCAPESTRING_RESULTS, pResults); - LPCWSTR wzIn = pArgs->wzIn; - LPWSTR wzOut = pResults->wzOut; - DWORD* pcchOut = &pResults->cchOut; - if (wzIn && *wzIn) - { - hr = VariableEscapeString(wzIn, &sczValue); - if (SUCCEEDED(hr)) - { - hr = CopyStringToBA(sczValue, wzOut, pcchOut); - } - } - else - { - hr = E_INVALIDARG; - } + hr = ExternalEngineEscapeString(pArgs->wzIn, pResults->wzOut, &pResults->cchOut); LExit: - StrSecureZeroFreeString(sczValue); return hr; } @@ -189,17 +108,8 @@ static HRESULT BAEngineEvaluateCondition( HRESULT hr = S_OK; ValidateMessageArgs(hr, pvArgs, BAENGINE_EVALUATECONDITION_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_EVALUATECONDITION_RESULTS, pResults); - LPCWSTR wzCondition = pArgs->wzCondition; - BOOL* pf = &pResults->f; - if (wzCondition && *wzCondition) - { - hr = ConditionEvaluate(&pContext->pEngineState->variables, wzCondition, pf); - } - else - { - hr = E_INVALIDARG; - } + hr = ExternalEngineEvaluateCondition(pContext->pEngineState, pArgs->wzCondition, &pResults->f); LExit: return hr; @@ -212,13 +122,11 @@ static HRESULT BAEngineLog( ) { HRESULT hr = S_OK; + REPORT_LEVEL rl = REPORT_NONE; ValidateMessageArgs(hr, pvArgs, BAENGINE_LOG_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_LOG_RESULTS, pResults); - REPORT_LEVEL rl = REPORT_NONE; - BOOTSTRAPPER_LOG_LEVEL level = pArgs->level; - LPCWSTR wzMessage = pArgs->wzMessage; - switch (level) + switch (pArgs->level) { case BOOTSTRAPPER_LOG_LEVEL_STANDARD: rl = REPORT_STANDARD; @@ -240,7 +148,7 @@ static HRESULT BAEngineLog( ExitFunction1(hr = E_INVALIDARG); } - hr = LogStringLine(rl, "%ls", wzMessage); + hr = ExternalEngineLog(rl, pArgs->wzMessage); ExitOnFailure(hr, "Failed to log BA message."); LExit: @@ -254,38 +162,12 @@ static HRESULT BAEngineSendEmbeddedError( ) { HRESULT hr = S_OK; - BYTE* pbData = NULL; - DWORD cbData = 0; - DWORD dwResult = 0; ValidateMessageArgs(hr, pvArgs, BAENGINE_SENDEMBEDDEDERROR_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_SENDEMBEDDEDERROR_RESULTS, pResults); - DWORD dwErrorCode = pArgs->dwErrorCode; - LPCWSTR wzMessage = pArgs->wzMessage; - DWORD dwUIHint = pArgs->dwUIHint; - int* pnResult = &pResults->nResult; - - if (BURN_MODE_EMBEDDED != pContext->pEngineState->mode) - { - hr = HRESULT_FROM_WIN32(ERROR_INVALID_STATE); - ExitOnRootFailure(hr, "BA requested to send embedded message when not in embedded mode."); - } - - hr = BuffWriteNumber(&pbData, &cbData, dwErrorCode); - ExitOnFailure(hr, "Failed to write error code to message buffer."); - hr = BuffWriteString(&pbData, &cbData, wzMessage ? wzMessage : L""); - ExitOnFailure(hr, "Failed to write message string to message buffer."); - - hr = BuffWriteNumber(&pbData, &cbData, dwUIHint); - ExitOnFailure(hr, "Failed to write UI hint to message buffer."); - - hr = PipeSendMessage(pContext->pEngineState->embeddedConnection.hPipe, BURN_EMBEDDED_MESSAGE_TYPE_ERROR, pbData, cbData, NULL, NULL, &dwResult); - ExitOnFailure(hr, "Failed to send embedded message over pipe."); - - *pnResult = static_cast(dwResult); + hr = ExternalEngineSendEmbeddedError(pContext->pEngineState, pArgs->dwErrorCode, pArgs->wzMessage, pArgs->dwUIHint, &pResults->nResult); LExit: - ReleaseBuffer(pbData); return hr; } @@ -296,34 +178,12 @@ static HRESULT BAEngineSendEmbeddedProgress( ) { HRESULT hr = S_OK; - BYTE* pbData = NULL; - DWORD cbData = 0; - DWORD dwResult = 0; ValidateMessageArgs(hr, pvArgs, BAENGINE_SENDEMBEDDEDPROGRESS_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_SENDEMBEDDEDPROGRESS_RESULTS, pResults); - DWORD dwProgressPercentage = pArgs->dwProgressPercentage; - DWORD dwOverallProgressPercentage = pArgs->dwOverallProgressPercentage; - int* pnResult = &pResults->nResult; - - if (BURN_MODE_EMBEDDED != pContext->pEngineState->mode) - { - hr = HRESULT_FROM_WIN32(ERROR_INVALID_STATE); - ExitOnRootFailure(hr, "BA requested to send embedded progress message when not in embedded mode."); - } - - hr = BuffWriteNumber(&pbData, &cbData, dwProgressPercentage); - ExitOnFailure(hr, "Failed to write progress percentage to message buffer."); - - hr = BuffWriteNumber(&pbData, &cbData, dwOverallProgressPercentage); - ExitOnFailure(hr, "Failed to write overall progress percentage to message buffer."); - - hr = PipeSendMessage(pContext->pEngineState->embeddedConnection.hPipe, BURN_EMBEDDED_MESSAGE_TYPE_PROGRESS, pbData, cbData, NULL, NULL, &dwResult); - ExitOnFailure(hr, "Failed to send embedded progress message over pipe."); - *pnResult = static_cast(dwResult); + hr = ExternalEngineSendEmbeddedProgress(pContext->pEngineState, pArgs->dwProgressPercentage, pArgs->dwOverallProgressPercentage, &pResults->nResult); LExit: - ReleaseBuffer(pbData); return hr; } @@ -334,81 +194,12 @@ static HRESULT BAEngineSetUpdate( ) { HRESULT hr = S_OK; - LPCWSTR sczId = NULL; - LPWSTR sczLocalSource = NULL; - LPWSTR sczCommandline = NULL; - UUID guid = { }; - WCHAR wzGuid[39]; - RPC_STATUS rs = RPC_S_OK; ValidateMessageArgs(hr, pvArgs, BAENGINE_SETUPDATE_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_SETUPDATE_RESULTS, pResults); - LPCWSTR wzLocalSource = pArgs->wzLocalSource; - LPCWSTR wzDownloadSource = pArgs->wzDownloadSource; - DWORD64 qwSize = pArgs->qwSize; - BOOTSTRAPPER_UPDATE_HASH_TYPE hashType = pArgs->hashType; - BYTE* rgbHash = pArgs->rgbHash; - DWORD cbHash = pArgs->cbHash; - ::EnterCriticalSection(&pContext->pEngineState->csActive); - - if ((!wzLocalSource || !*wzLocalSource) && (!wzDownloadSource || !*wzDownloadSource)) - { - UpdateUninitialize(&pContext->pEngineState->update); - } - else if (BOOTSTRAPPER_UPDATE_HASH_TYPE_NONE == hashType && (0 != cbHash || rgbHash)) - { - hr = E_INVALIDARG; - } - else if (BOOTSTRAPPER_UPDATE_HASH_TYPE_SHA1 == hashType && (SHA1_HASH_LEN != cbHash || !rgbHash)) - { - hr = E_INVALIDARG; - } - else - { - UpdateUninitialize(&pContext->pEngineState->update); - - if (!wzLocalSource || !*wzLocalSource) - { - hr = StrAllocFormatted(&sczLocalSource, L"update\\%ls", pContext->pEngineState->registration.sczExecutableName); - ExitOnFailure(hr, "Failed to default local update source"); - } - - hr = CoreRecreateCommandLine(&sczCommandline, BOOTSTRAPPER_ACTION_INSTALL, pContext->pEngineState->command.display, pContext->pEngineState->command.restart, BOOTSTRAPPER_RELATION_NONE, FALSE, pContext->pEngineState->registration.sczActiveParent, pContext->pEngineState->registration.sczAncestors, NULL, pContext->pEngineState->command.wzCommandLine); - ExitOnFailure(hr, "Failed to recreate command-line for update bundle."); - - // Per-user bundles would fail to use the downloaded update bundle, as the existing install would already be cached - // at the registration id's location. Here I am generating a random guid, but in the future it would be nice if the - // feed would provide the ID of the update. - if (!pContext->pEngineState->registration.fPerMachine) - { - rs = ::UuidCreate(&guid); - hr = HRESULT_FROM_RPC(rs); - ExitOnFailure(hr, "Failed to create bundle update guid."); - - if (!::StringFromGUID2(guid, wzGuid, countof(wzGuid))) - { - hr = E_OUTOFMEMORY; - ExitOnRootFailure(hr, "Failed to convert bundle update guid into string."); - } - - sczId = wzGuid; - } - else - { - sczId = pContext->pEngineState->registration.sczId; - } - - hr = PseudoBundleInitialize(FILEMAKEVERSION(rmj, rmm, rup, rpr), &pContext->pEngineState->update.package, FALSE, sczId, BOOTSTRAPPER_RELATION_UPDATE, BOOTSTRAPPER_PACKAGE_STATE_ABSENT, pContext->pEngineState->registration.sczExecutableName, sczLocalSource ? sczLocalSource : wzLocalSource, wzDownloadSource, qwSize, TRUE, sczCommandline, NULL, NULL, NULL, rgbHash, cbHash); - ExitOnFailure(hr, "Failed to set update bundle."); - - pContext->pEngineState->update.fUpdateAvailable = TRUE; - } + hr = ExternalEngineSetUpdate(pContext->pEngineState, pArgs->wzLocalSource, pArgs->wzDownloadSource, pArgs->qwSize, pArgs->hashType, pArgs->rgbHash, pArgs->cbHash); LExit: - ::LeaveCriticalSection(&pContext->pEngineState->csActive); - - ReleaseStr(sczCommandline); - ReleaseStr(sczLocalSource); return hr; } @@ -419,51 +210,12 @@ static HRESULT BAEngineSetLocalSource( ) { HRESULT hr = S_OK; - BURN_CONTAINER* pContainer = NULL; - BURN_PAYLOAD* pPayload = NULL; ValidateMessageArgs(hr, pvArgs, BAENGINE_SETLOCALSOURCE_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_SETLOCALSOURCE_RESULTS, pResults); - LPCWSTR wzPackageOrContainerId = pArgs->wzPackageOrContainerId; - LPCWSTR wzPayloadId = pArgs->wzPayloadId; - LPCWSTR wzPath = pArgs->wzPath; - - ::EnterCriticalSection(&pContext->pEngineState->csActive); - hr = UserExperienceEnsureEngineInactive(&pContext->pEngineState->userExperience); - ExitOnFailure(hr, "Engine is active, cannot change engine state."); - - if (!wzPath || !*wzPath) - { - hr = E_INVALIDARG; - } - else if (wzPayloadId && * wzPayloadId) - { - hr = PayloadFindById(&pContext->pEngineState->payloads, wzPayloadId, &pPayload); - ExitOnFailure(hr, "BA requested unknown payload with id: %ls", wzPayloadId); - - if (BURN_PAYLOAD_PACKAGING_EMBEDDED == pPayload->packaging) - { - hr = HRESULT_FROM_WIN32(ERROR_INVALID_OPERATION); - ExitOnFailure(hr, "BA denied while trying to set source on embedded payload: %ls", wzPayloadId); - } - hr = StrAllocString(&pPayload->sczSourcePath, wzPath, 0); - ExitOnFailure(hr, "Failed to set source path for payload."); - } - else if (wzPackageOrContainerId && *wzPackageOrContainerId) - { - hr = ContainerFindById(&pContext->pEngineState->containers, wzPackageOrContainerId, &pContainer); - ExitOnFailure(hr, "BA requested unknown container with id: %ls", wzPackageOrContainerId); - - hr = StrAllocString(&pContainer->sczSourcePath, wzPath, 0); - ExitOnFailure(hr, "Failed to set source path for container."); - } - else - { - hr = E_INVALIDARG; - } + hr = ExternalEngineSetLocalSource(pContext->pEngineState, pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->wzPath); LExit: - ::LeaveCriticalSection(&pContext->pEngineState->csActive); return hr; } @@ -474,82 +226,12 @@ static HRESULT BAEngineSetDownloadSource( ) { HRESULT hr = S_OK; - BURN_CONTAINER* pContainer = NULL; - BURN_PAYLOAD* pPayload = NULL; - DOWNLOAD_SOURCE* pDownloadSource = NULL; ValidateMessageArgs(hr, pvArgs, BAENGINE_SETDOWNLOADSOURCE_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_SETDOWNLOADSOURCE_RESULTS, pResults); - LPCWSTR wzPackageOrContainerId = pArgs->wzPackageOrContainerId; - LPCWSTR wzPayloadId = pArgs->wzPayloadId; - LPCWSTR wzUrl = pArgs->wzUrl; - LPCWSTR wzUser = pArgs->wzUser; - LPCWSTR wzPassword = pArgs->wzPassword; - ::EnterCriticalSection(&pContext->pEngineState->csActive); - hr = UserExperienceEnsureEngineInactive(&pContext->pEngineState->userExperience); - ExitOnFailure(hr, "Engine is active, cannot change engine state."); - - if (wzPayloadId && *wzPayloadId) - { - hr = PayloadFindById(&pContext->pEngineState->payloads, wzPayloadId, &pPayload); - ExitOnFailure(hr, "BA requested unknown payload with id: %ls", wzPayloadId); - - if (BURN_PAYLOAD_PACKAGING_EMBEDDED == pPayload->packaging) - { - hr = HRESULT_FROM_WIN32(ERROR_INVALID_OPERATION); - ExitOnFailure(hr, "BA denied while trying to set download URL on embedded payload: %ls", wzPayloadId); - } - - pDownloadSource = &pPayload->downloadSource; - } - else if (wzPackageOrContainerId && *wzPackageOrContainerId) - { - hr = ContainerFindById(&pContext->pEngineState->containers, wzPackageOrContainerId, &pContainer); - ExitOnFailure(hr, "BA requested unknown container with id: %ls", wzPackageOrContainerId); - - pDownloadSource = &pContainer->downloadSource; - } - else - { - hr = E_INVALIDARG; - ExitOnFailure(hr, "BA did not provide container or payload id."); - } - - if (wzUrl && *wzUrl) - { - hr = StrAllocString(&pDownloadSource->sczUrl, wzUrl, 0); - ExitOnFailure(hr, "Failed to set download URL."); - - if (wzUser && *wzUser) - { - hr = StrAllocString(&pDownloadSource->sczUser, wzUser, 0); - ExitOnFailure(hr, "Failed to set download user."); - - if (wzPassword && *wzPassword) - { - hr = StrAllocString(&pDownloadSource->sczPassword, wzPassword, 0); - ExitOnFailure(hr, "Failed to set download password."); - } - else // no password. - { - ReleaseNullStr(pDownloadSource->sczPassword); - } - } - else // no user means no password either. - { - ReleaseNullStr(pDownloadSource->sczUser); - ReleaseNullStr(pDownloadSource->sczPassword); - } - } - else // no URL provided means clear out the whole download source. - { - ReleaseNullStr(pDownloadSource->sczUrl); - ReleaseNullStr(pDownloadSource->sczUser); - ReleaseNullStr(pDownloadSource->sczPassword); - } + hr = ExternalEngineSetDownloadSource(pContext->pEngineState, pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->wzUrl, pArgs->wzUser, pArgs->wzPassword); LExit: - ::LeaveCriticalSection(&pContext->pEngineState->csActive); return hr; } @@ -562,19 +244,8 @@ static HRESULT BAEngineSetVariableNumeric( HRESULT hr = S_OK; ValidateMessageArgs(hr, pvArgs, BAENGINE_SETVARIABLENUMERIC_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_SETVARIABLENUMERIC_RESULTS, pResults); - LPCWSTR wzVariable = pArgs->wzVariable; - LONGLONG llValue = pArgs->llValue; - if (wzVariable && *wzVariable) - { - hr = VariableSetNumeric(&pContext->pEngineState->variables, wzVariable, llValue, FALSE); - ExitOnFailure(hr, "Failed to set numeric variable."); - } - else - { - hr = E_INVALIDARG; - ExitOnFailure(hr, "BA did not provide variable name."); - } + hr = ExternalEngineSetVariableNumeric(pContext->pEngineState, pArgs->wzVariable, pArgs->llValue); LExit: return hr; @@ -589,19 +260,8 @@ static HRESULT BAEngineSetVariableString( HRESULT hr = S_OK; ValidateMessageArgs(hr, pvArgs, BAENGINE_SETVARIABLESTRING_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_SETVARIABLESTRING_RESULTS, pResults); - LPCWSTR wzVariable = pArgs->wzVariable; - LPCWSTR wzValue = pArgs->wzValue; - if (wzVariable && *wzVariable) - { - hr = VariableSetString(&pContext->pEngineState->variables, wzVariable, wzValue, FALSE, pArgs->fFormatted); - ExitOnFailure(hr, "Failed to set string variable."); - } - else - { - hr = E_INVALIDARG; - ExitOnFailure(hr, "BA did not provide variable name."); - } + hr = ExternalEngineSetVariableString(pContext->pEngineState, pArgs->wzVariable, pArgs->wzValue, pArgs->fFormatted); LExit: return hr; @@ -614,32 +274,12 @@ static HRESULT BAEngineSetVariableVersion( ) { HRESULT hr = S_OK; - VERUTIL_VERSION* pVersion = NULL; ValidateMessageArgs(hr, pvArgs, BAENGINE_SETVARIABLEVERSION_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_SETVARIABLEVERSION_RESULTS, pResults); - LPCWSTR wzVariable = pArgs->wzVariable; - LPCWSTR wzValue = pArgs->wzValue; - if (wzVariable && *wzVariable) - { - if (wzValue) - { - hr = VerParseVersion(wzValue, 0, FALSE, &pVersion); - ExitOnFailure(hr, "Failed to parse new version value."); - } - - hr = VariableSetVersion(&pContext->pEngineState->variables, wzVariable, pVersion, FALSE); - ExitOnFailure(hr, "Failed to set version variable."); - } - else - { - hr = E_INVALIDARG; - ExitOnFailure(hr, "BA did not provide variable name."); - } + hr = ExternalEngineSetVariableVersion(pContext->pEngineState, pArgs->wzVariable, pArgs->wzValue); LExit: - ReleaseVerutilVersion(pVersion); - return hr; } @@ -653,11 +293,7 @@ static HRESULT BAEngineCloseSplashScreen( ValidateMessageArgs(hr, pvArgs, BAENGINE_CLOSESPLASHSCREEN_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_CLOSESPLASHSCREEN_RESULTS, pResults); - // If the splash screen is still around, close it. - if (::IsWindow(pContext->pEngineState->command.hwndSplashScreen)) - { - ::PostMessageW(pContext->pEngineState->command.hwndSplashScreen, WM_CLOSE, 0, 0); - } + ExternalEngineCloseSplashScreen(pContext->pEngineState); LExit: return hr; @@ -672,11 +308,8 @@ static HRESULT BAEngineCompareVersions( HRESULT hr = S_OK; ValidateMessageArgs(hr, pvArgs, BAENGINE_COMPAREVERSIONS_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_COMPAREVERSIONS_RESULTS, pResults); - LPCWSTR wzVersion1 = pArgs->wzVersion1; - LPCWSTR wzVersion2 = pArgs->wzVersion2; - int* pnResult = &pResults->nResult; - hr = VerCompareStringVersions(wzVersion1, wzVersion2, FALSE, pnResult); + hr = ExternalEngineCompareVersions(pArgs->wzVersion1, pArgs->wzVersion2, &pResults->nResult); LExit: return hr; @@ -692,10 +325,7 @@ static HRESULT BAEngineDetect( ValidateMessageArgs(hr, pvArgs, BAENGINE_DETECT_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_DETECT_RESULTS, pResults); - if (!::PostThreadMessageW(pContext->dwThreadId, WM_BURN_DETECT, 0, reinterpret_cast(pArgs->hwndParent))) - { - ExitWithLastError(hr, "Failed to post detect message."); - } + hr = ExternalEngineDetect(pContext->dwThreadId, pArgs->hwndParent); LExit: return hr; @@ -710,12 +340,8 @@ static HRESULT BAEnginePlan( HRESULT hr = S_OK; ValidateMessageArgs(hr, pvArgs, BAENGINE_PLAN_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_PLAN_RESULTS, pResults); - BOOTSTRAPPER_ACTION action = pArgs->action; - if (!::PostThreadMessageW(pContext->dwThreadId, WM_BURN_PLAN, 0, action)) - { - ExitWithLastError(hr, "Failed to post plan message."); - } + hr = ExternalEnginePlan(pContext->dwThreadId, pArgs->action); LExit: return hr; @@ -731,14 +357,7 @@ static HRESULT BAEngineElevate( ValidateMessageArgs(hr, pvArgs, BAENGINE_ELEVATE_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_ELEVATE_RESULTS, pResults); - if (INVALID_HANDLE_VALUE != pContext->pEngineState->companionConnection.hPipe) - { - hr = HRESULT_FROM_WIN32(ERROR_ALREADY_INITIALIZED); - } - else if (!::PostThreadMessageW(pContext->dwThreadId, WM_BURN_ELEVATE, 0, reinterpret_cast(pArgs->hwndParent))) - { - ExitWithLastError(hr, "Failed to post elevate message."); - } + hr = ExternalEngineElevate(pContext->pEngineState, pContext->dwThreadId, pArgs->hwndParent); LExit: return hr; @@ -754,16 +373,7 @@ static HRESULT BAEngineApply( ValidateMessageArgs(hr, pvArgs, BAENGINE_APPLY_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_APPLY_RESULTS, pResults); - ExitOnNull(pArgs->hwndParent, hr, E_INVALIDARG, "BA passed NULL hwndParent to Apply."); - if (!::IsWindow(pArgs->hwndParent)) - { - ExitOnFailure(hr = E_INVALIDARG, "BA passed invalid hwndParent to Apply."); - } - - if (!::PostThreadMessageW(pContext->dwThreadId, WM_BURN_APPLY, 0, reinterpret_cast(pArgs->hwndParent))) - { - ExitWithLastError(hr, "Failed to post apply message."); - } + hr = ExternalEngineApply(pContext->dwThreadId, pArgs->hwndParent); LExit: return hr; @@ -779,10 +389,7 @@ static HRESULT BAEngineQuit( ValidateMessageArgs(hr, pvArgs, BAENGINE_QUIT_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_QUIT_RESULTS, pResults); - if (!::PostThreadMessageW(pContext->dwThreadId, WM_BURN_QUIT, static_cast(pArgs->dwExitCode), 0)) - { - ExitWithLastError(hr, "Failed to post shutdown message."); - } + hr = ExternalEngineQuit(pContext->dwThreadId, pArgs->dwExitCode); LExit: return hr; @@ -795,64 +402,12 @@ static HRESULT BAEngineLaunchApprovedExe( ) { HRESULT hr = S_OK; - BURN_APPROVED_EXE* pApprovedExe = NULL; - BOOL fLeaveCriticalSection = FALSE; - BURN_LAUNCH_APPROVED_EXE* pLaunchApprovedExe = NULL; ValidateMessageArgs(hr, pvArgs, BAENGINE_LAUNCHAPPROVEDEXE_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BAENGINE_LAUNCHAPPROVEDEXE_RESULTS, pResults); - HWND hwndParent = pArgs->hwndParent; - LPCWSTR wzApprovedExeForElevationId = pArgs->wzApprovedExeForElevationId; - LPCWSTR wzArguments = pArgs->wzArguments; - DWORD dwWaitForInputIdleTimeout = pArgs->dwWaitForInputIdleTimeout; - pLaunchApprovedExe = (BURN_LAUNCH_APPROVED_EXE*)MemAlloc(sizeof(BURN_LAUNCH_APPROVED_EXE), TRUE); - ExitOnNull(pLaunchApprovedExe, hr, E_OUTOFMEMORY, "Failed to alloc BURN_LAUNCH_APPROVED_EXE"); - - ::EnterCriticalSection(&pContext->pEngineState->csActive); - fLeaveCriticalSection = TRUE; - hr = UserExperienceEnsureEngineInactive(&pContext->pEngineState->userExperience); - ExitOnFailure(hr, "Engine is active, cannot change engine state."); - - if (!wzApprovedExeForElevationId || !*wzApprovedExeForElevationId) - { - ExitFunction1(hr = E_INVALIDARG); - } - - hr = ApprovedExesFindById(&pContext->pEngineState->approvedExes, wzApprovedExeForElevationId, &pApprovedExe); - ExitOnFailure(hr, "BA requested unknown approved exe with id: %ls", wzApprovedExeForElevationId); - - ::LeaveCriticalSection(&pContext->pEngineState->csActive); - fLeaveCriticalSection = FALSE; - - hr = StrAllocString(&pLaunchApprovedExe->sczId, wzApprovedExeForElevationId, NULL); - ExitOnFailure(hr, "Failed to copy the id."); - - if (wzArguments) - { - hr = StrAllocString(&pLaunchApprovedExe->sczArguments, wzArguments, NULL); - ExitOnFailure(hr, "Failed to copy the arguments."); - } - - pLaunchApprovedExe->dwWaitForInputIdleTimeout = dwWaitForInputIdleTimeout; - - pLaunchApprovedExe->hwndParent = hwndParent; - - if (!::PostThreadMessageW(pContext->dwThreadId, WM_BURN_LAUNCH_APPROVED_EXE, 0, reinterpret_cast(pLaunchApprovedExe))) - { - ExitWithLastError(hr, "Failed to post launch approved exe message."); - } + hr = ExternalEngineLaunchApprovedExe(pContext->pEngineState, pContext->dwThreadId, pArgs->hwndParent, pArgs->wzApprovedExeForElevationId, pArgs->wzArguments, pArgs->dwWaitForInputIdleTimeout); LExit: - if (fLeaveCriticalSection) - { - ::LeaveCriticalSection(&pContext->pEngineState->csActive); - } - - if (FAILED(hr)) - { - ApprovedExesUninitializeLaunch(pLaunchApprovedExe); - } - return hr; } @@ -953,34 +508,3 @@ HRESULT WINAPI EngineForApplicationProc( LExit: return hr; } - -static HRESULT CopyStringToBA( - __in LPWSTR wzValue, - __in_opt LPWSTR wzBuffer, - __inout DWORD* pcchBuffer - ) -{ - HRESULT hr = S_OK; - BOOL fTooSmall = !wzBuffer; - - if (!fTooSmall) - { - hr = ::StringCchCopyExW(wzBuffer, *pcchBuffer, wzValue, NULL, NULL, STRSAFE_FILL_BEHIND_NULL); - if (STRSAFE_E_INSUFFICIENT_BUFFER == hr) - { - fTooSmall = TRUE; - } - } - - if (fTooSmall) - { - hr = ::StringCchLengthW(wzValue, STRSAFE_MAX_CCH, reinterpret_cast(pcchBuffer)); - if (SUCCEEDED(hr)) - { - hr = E_MOREDATA; - *pcchBuffer += 1; // null terminator. - } - } - - return hr; -} diff --git a/src/engine/EngineForExtension.cpp b/src/engine/EngineForExtension.cpp index 29b6a6b3..2e1c98fd 100644 --- a/src/engine/EngineForExtension.cpp +++ b/src/engine/EngineForExtension.cpp @@ -3,12 +3,6 @@ #include "precomp.h" -static HRESULT CopyStringToBE( - __in LPWSTR wzValue, - __in LPWSTR wzBuffer, - __inout DWORD* pcchBuffer - ); - static HRESULT BEEngineEscapeString( __in BURN_EXTENSION_ENGINE_CONTEXT* /*pContext*/, __in const LPVOID pvArgs, @@ -16,28 +10,12 @@ static HRESULT BEEngineEscapeString( ) { HRESULT hr = S_OK; - LPWSTR sczValue = NULL; ValidateMessageArgs(hr, pvArgs, BUNDLE_EXTENSION_ENGINE_ESCAPESTRING_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BUNDLE_EXTENSION_ENGINE_ESCAPESTRING_RESULTS, pResults); - LPCWSTR wzIn = pArgs->wzIn; - LPWSTR wzOut = pResults->wzOut; - DWORD* pcchOut = &pResults->cchOut; - if (wzIn && *wzIn) - { - hr = VariableEscapeString(wzIn, &sczValue); - if (SUCCEEDED(hr)) - { - hr = CopyStringToBE(sczValue, wzOut, pcchOut); - } - } - else - { - hr = E_INVALIDARG; - } + hr = ExternalEngineEscapeString(pArgs->wzIn, pResults->wzOut, &pResults->cchOut); LExit: - StrSecureZeroFreeString(sczValue); return hr; } @@ -50,17 +28,8 @@ static HRESULT BEEngineEvaluateCondition( HRESULT hr = S_OK; ValidateMessageArgs(hr, pvArgs, BUNDLE_EXTENSION_ENGINE_EVALUATECONDITION_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BUNDLE_EXTENSION_ENGINE_EVALUATECONDITION_RESULTS, pResults); - LPCWSTR wzCondition = pArgs->wzCondition; - BOOL* pf = &pResults->f; - if (wzCondition && *wzCondition) - { - hr = ConditionEvaluate(&pContext->pEngineState->variables, wzCondition, pf); - } - else - { - hr = E_INVALIDARG; - } + hr = ExternalEngineEvaluateCondition(pContext->pEngineState, pArgs->wzCondition, &pResults->f); LExit: return hr; @@ -73,28 +42,12 @@ static HRESULT BEEngineFormatString( ) { HRESULT hr = S_OK; - LPWSTR sczValue = NULL; ValidateMessageArgs(hr, pvArgs, BUNDLE_EXTENSION_ENGINE_FORMATSTRING_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BUNDLE_EXTENSION_ENGINE_FORMATSTRING_RESULTS, pResults); - LPCWSTR wzIn = pArgs->wzIn; - LPWSTR wzOut = pResults->wzOut; - DWORD* pcchOut = &pResults->cchOut; - if (wzIn && *wzIn) - { - hr = VariableFormatString(&pContext->pEngineState->variables, wzIn, &sczValue, NULL); - if (SUCCEEDED(hr)) - { - hr = CopyStringToBE(sczValue, wzOut, pcchOut); - } - } - else - { - hr = E_INVALIDARG; - } + hr = ExternalEngineFormatString(pContext->pEngineState, pArgs->wzIn, pResults->wzOut, &pResults->cchOut); LExit: - StrSecureZeroFreeString(sczValue); return hr; } @@ -107,17 +60,8 @@ static HRESULT BEEngineGetVariableNumeric( HRESULT hr = S_OK; ValidateMessageArgs(hr, pvArgs, BUNDLE_EXTENSION_ENGINE_GETVARIABLENUMERIC_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BUNDLE_EXTENSION_ENGINE_GETVARIABLENUMERIC_RESULTS, pResults); - LPCWSTR wzVariable = pArgs->wzVariable; - LONGLONG* pllValue = &pResults->llValue; - if (wzVariable && *wzVariable) - { - hr = VariableGetNumeric(&pContext->pEngineState->variables, wzVariable, pllValue); - } - else - { - hr = E_INVALIDARG; - } + hr = ExternalEngineGetVariableNumeric(pContext->pEngineState, pArgs->wzVariable, &pResults->llValue); LExit: return hr; @@ -130,28 +74,12 @@ static HRESULT BEEngineGetVariableString( ) { HRESULT hr = S_OK; - LPWSTR sczValue = NULL; ValidateMessageArgs(hr, pvArgs, BUNDLE_EXTENSION_ENGINE_GETVARIABLESTRING_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BUNDLE_EXTENSION_ENGINE_GETVARIABLESTRING_RESULTS, pResults); - LPCWSTR wzVariable = pArgs->wzVariable; - LPWSTR wzValue = pResults->wzValue; - DWORD* pcchValue = &pResults->cchValue; - if (wzVariable && *wzVariable) - { - hr = VariableGetString(&pContext->pEngineState->variables, wzVariable, &sczValue); - if (SUCCEEDED(hr)) - { - hr = CopyStringToBE(sczValue, wzValue, pcchValue); - } - } - else - { - hr = E_INVALIDARG; - } + hr = ExternalEngineGetVariableString(pContext->pEngineState, pArgs->wzVariable, pResults->wzValue, &pResults->cchValue); LExit: - StrSecureZeroFreeString(sczValue); return hr; } @@ -162,29 +90,12 @@ static HRESULT BEEngineGetVariableVersion( ) { HRESULT hr = S_OK; - VERUTIL_VERSION* pVersion = NULL; ValidateMessageArgs(hr, pvArgs, BUNDLE_EXTENSION_ENGINE_GETVARIABLEVERSION_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BUNDLE_EXTENSION_ENGINE_GETVARIABLEVERSION_RESULTS, pResults); - LPCWSTR wzVariable = pArgs->wzVariable; - LPWSTR wzValue = pResults->wzValue; - DWORD* pcchValue = &pResults->cchValue; - if (wzVariable && *wzVariable) - { - hr = VariableGetVersion(&pContext->pEngineState->variables, wzVariable, &pVersion); - if (SUCCEEDED(hr)) - { - hr = CopyStringToBE(pVersion->sczVersion, wzValue, pcchValue); - } - } - else - { - hr = E_INVALIDARG; - } + hr = ExternalEngineGetVariableVersion(pContext->pEngineState, pArgs->wzVariable, pResults->wzValue, &pResults->cchValue); LExit: - ReleaseVerutilVersion(pVersion); - return hr; } @@ -198,10 +109,8 @@ static HRESULT BEEngineLog( REPORT_LEVEL rl = REPORT_NONE; ValidateMessageArgs(hr, pvArgs, BUNDLE_EXTENSION_ENGINE_LOG_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BUNDLE_EXTENSION_ENGINE_LOG_RESULTS, pResults); - BUNDLE_EXTENSION_LOG_LEVEL level = pArgs->level; - LPCWSTR wzMessage = pArgs->wzMessage; - switch (level) + switch (pArgs->level) { case BUNDLE_EXTENSION_LOG_LEVEL_STANDARD: rl = REPORT_STANDARD; @@ -223,7 +132,7 @@ static HRESULT BEEngineLog( ExitFunction1(hr = E_INVALIDARG); } - hr = LogStringLine(rl, "%ls", wzMessage); + hr = ExternalEngineLog(rl, pArgs->wzMessage); ExitOnFailure(hr, "Failed to log Bundle Extension message."); LExit: @@ -239,19 +148,8 @@ static HRESULT BEEngineSetVariableNumeric( HRESULT hr = S_OK; ValidateMessageArgs(hr, pvArgs, BUNDLE_EXTENSION_ENGINE_SETVARIABLENUMERIC_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BUNDLE_EXTENSION_ENGINE_SETVARIABLENUMERIC_RESULTS, pResults); - LPCWSTR wzVariable = pArgs->wzVariable; - LONGLONG llValue = pArgs->llValue; - if (wzVariable && *wzVariable) - { - hr = VariableSetNumeric(&pContext->pEngineState->variables, wzVariable, llValue, FALSE); - ExitOnFailure(hr, "Failed to set numeric variable."); - } - else - { - hr = E_INVALIDARG; - ExitOnFailure(hr, "Bundle Extension did not provide variable name."); - } + hr = ExternalEngineSetVariableNumeric(pContext->pEngineState, pArgs->wzVariable, pArgs->llValue); LExit: return hr; @@ -266,19 +164,8 @@ static HRESULT BEEngineSetVariableString( HRESULT hr = S_OK; ValidateMessageArgs(hr, pvArgs, BUNDLE_EXTENSION_ENGINE_SETVARIABLESTRING_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BUNDLE_EXTENSION_ENGINE_SETVARIABLESTRING_RESULTS, pResults); - LPCWSTR wzVariable = pArgs->wzVariable; - LPCWSTR wzValue = pArgs->wzValue; - if (wzVariable && *wzVariable) - { - hr = VariableSetString(&pContext->pEngineState->variables, wzVariable, wzValue, FALSE, pArgs->fFormatted); - ExitOnFailure(hr, "Failed to set string variable."); - } - else - { - hr = E_INVALIDARG; - ExitOnFailure(hr, "Bundle Extension did not provide variable name."); - } + hr = ExternalEngineSetVariableString(pContext->pEngineState, pArgs->wzVariable, pArgs->wzValue, pArgs->fFormatted); LExit: return hr; @@ -291,32 +178,12 @@ static HRESULT BEEngineSetVariableVersion( ) { HRESULT hr = S_OK; - VERUTIL_VERSION* pVersion = NULL; ValidateMessageArgs(hr, pvArgs, BUNDLE_EXTENSION_ENGINE_SETVARIABLEVERSION_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BUNDLE_EXTENSION_ENGINE_SETVARIABLEVERSION_RESULTS, pResults); - LPCWSTR wzVariable = pArgs->wzVariable; - LPCWSTR wzValue = pArgs->wzValue; - if (wzVariable && *wzVariable) - { - if (wzValue) - { - hr = VerParseVersion(wzValue, 0, FALSE, &pVersion); - ExitOnFailure(hr, "Failed to parse new version value."); - } - - hr = VariableSetVersion(&pContext->pEngineState->variables, wzVariable, pVersion, FALSE); - ExitOnFailure(hr, "Failed to set version variable."); - } - else - { - hr = E_INVALIDARG; - ExitOnFailure(hr, "Bundle Extension did not provide variable name."); - } + hr = ExternalEngineSetVariableVersion(pContext->pEngineState, pArgs->wzVariable, pArgs->wzValue); LExit: - ReleaseVerutilVersion(pVersion); - return hr; } @@ -329,11 +196,8 @@ static HRESULT BEEngineCompareVersions( HRESULT hr = S_OK; ValidateMessageArgs(hr, pvArgs, BUNDLE_EXTENSION_ENGINE_COMPAREVERSIONS_ARGS, pArgs); ValidateMessageResults(hr, pvResults, BUNDLE_EXTENSION_ENGINE_COMPAREVERSIONS_RESULTS, pResults); - LPCWSTR wzVersion1 = pArgs->wzVersion1; - LPCWSTR wzVersion2 = pArgs->wzVersion2; - int* pnResult = &pResults->nResult; - hr = VerCompareStringVersions(wzVersion1, wzVersion2, FALSE, pnResult); + hr = ExternalEngineCompareVersions(pArgs->wzVersion1, pArgs->wzVersion2, &pResults->nResult); LExit: return hr; @@ -397,34 +261,3 @@ HRESULT WINAPI EngineForExtensionProc( LExit: return hr; } - -static HRESULT CopyStringToBE( - __in LPWSTR wzValue, - __in LPWSTR wzBuffer, - __inout DWORD* pcchBuffer - ) -{ - HRESULT hr = S_OK; - BOOL fTooSmall = !wzBuffer; - - if (!fTooSmall) - { - hr = ::StringCchCopyExW(wzBuffer, *pcchBuffer, wzValue, NULL, NULL, STRSAFE_FILL_BEHIND_NULL); - if (STRSAFE_E_INSUFFICIENT_BUFFER == hr) - { - fTooSmall = TRUE; - } - } - - if (fTooSmall) - { - hr = ::StringCchLengthW(wzValue, STRSAFE_MAX_CCH, reinterpret_cast(pcchBuffer)); - if (SUCCEEDED(hr)) - { - hr = E_MOREDATA; - *pcchBuffer += 1; // null terminator. - } - } - - return hr; -} diff --git a/src/engine/externalengine.cpp b/src/engine/externalengine.cpp index ef4f931d..3d5b3696 100644 --- a/src/engine/externalengine.cpp +++ b/src/engine/externalengine.cpp @@ -3,8 +3,737 @@ #include "precomp.h" +static HRESULT CopyStringToExternal( + __in_z LPWSTR wzValue, + __in_z_opt LPWSTR wzBuffer, + __inout DWORD* pcchBuffer + ); + // function definitions +void ExternalEngineGetPackageCount( + __in BURN_ENGINE_STATE* pEngineState, + __out DWORD* pcPackages + ) +{ + *pcPackages = pEngineState->packages.cPackages; +} + +HRESULT ExternalEngineGetVariableNumeric( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzVariable, + __out LONGLONG* pllValue + ) +{ + HRESULT hr = S_OK; + + if (wzVariable && *wzVariable) + { + hr = VariableGetNumeric(&pEngineState->variables, wzVariable, pllValue); + } + else + { + *pllValue = 0; + hr = E_INVALIDARG; + } + + return hr; +} + +HRESULT ExternalEngineGetVariableString( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzVariable, + __out_ecount_opt(*pcchValue) LPWSTR wzValue, + __inout DWORD* pcchValue + ) +{ + HRESULT hr = S_OK; + LPWSTR sczValue = NULL; + + if (wzVariable && *wzVariable) + { + hr = VariableGetString(&pEngineState->variables, wzVariable, &sczValue); + if (SUCCEEDED(hr)) + { + hr = CopyStringToExternal(sczValue, wzValue, pcchValue); + } + } + else + { + hr = E_INVALIDARG; + } + + StrSecureZeroFreeString(sczValue); + + return hr; +} + +HRESULT ExternalEngineGetVariableVersion( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzVariable, + __out_ecount_opt(*pcchValue) LPWSTR wzValue, + __inout DWORD* pcchValue + ) +{ + HRESULT hr = S_OK; + VERUTIL_VERSION* pVersion = NULL; + + if (wzVariable && *wzVariable) + { + hr = VariableGetVersion(&pEngineState->variables, wzVariable, &pVersion); + if (SUCCEEDED(hr)) + { + hr = CopyStringToExternal(pVersion->sczVersion, wzValue, pcchValue); + } + } + else + { + hr = E_INVALIDARG; + } + + ReleaseVerutilVersion(pVersion); + + return hr; +} + +HRESULT ExternalEngineFormatString( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzIn, + __out_ecount_opt(*pcchOut) LPWSTR wzOut, + __inout DWORD* pcchOut + ) +{ + HRESULT hr = S_OK; + LPWSTR sczValue = NULL; + + if (wzIn && *wzIn) + { + hr = VariableFormatString(&pEngineState->variables, wzIn, &sczValue, NULL); + if (SUCCEEDED(hr)) + { + hr = CopyStringToExternal(sczValue, wzOut, pcchOut); + } + } + else + { + hr = E_INVALIDARG; + } + + StrSecureZeroFreeString(sczValue); + + return hr; +} + +HRESULT ExternalEngineEscapeString( + __in_z LPCWSTR wzIn, + __out_ecount_opt(*pcchOut) LPWSTR wzOut, + __inout DWORD* pcchOut + ) +{ + HRESULT hr = S_OK; + LPWSTR sczValue = NULL; + + if (wzIn && *wzIn) + { + hr = VariableEscapeString(wzIn, &sczValue); + if (SUCCEEDED(hr)) + { + hr = CopyStringToExternal(sczValue, wzOut, pcchOut); + } + } + else + { + hr = E_INVALIDARG; + } + + StrSecureZeroFreeString(sczValue); + + return hr; +} + +HRESULT ExternalEngineEvaluateCondition( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzCondition, + __out BOOL* pf + ) +{ + HRESULT hr = S_OK; + + if (wzCondition && *wzCondition) + { + hr = ConditionEvaluate(&pEngineState->variables, wzCondition, pf); + } + else + { + *pf = FALSE; + hr = E_INVALIDARG; + } + + return hr; +} + +HRESULT ExternalEngineLog( + __in REPORT_LEVEL rl, + __in_z LPCWSTR wzMessage + ) +{ + HRESULT hr = S_OK; + + hr = LogStringLine(rl, "%ls", wzMessage); + + return hr; +} + +HRESULT ExternalEngineSendEmbeddedError( + __in BURN_ENGINE_STATE* pEngineState, + __in const DWORD dwErrorCode, + __in_z LPCWSTR wzMessage, + __in const DWORD dwUIHint, + __out int* pnResult + ) +{ + HRESULT hr = S_OK; + BYTE* pbData = NULL; + DWORD cbData = 0; + DWORD dwResult = *pnResult = 0; + + if (BURN_MODE_EMBEDDED != pEngineState->mode) + { + hr = HRESULT_FROM_WIN32(ERROR_INVALID_STATE); + ExitOnRootFailure(hr, "BA requested to send embedded message when not in embedded mode."); + } + + hr = BuffWriteNumber(&pbData, &cbData, dwErrorCode); + ExitOnFailure(hr, "Failed to write error code to message buffer."); + + hr = BuffWriteString(&pbData, &cbData, wzMessage ? wzMessage : L""); + ExitOnFailure(hr, "Failed to write message string to message buffer."); + + hr = BuffWriteNumber(&pbData, &cbData, dwUIHint); + ExitOnFailure(hr, "Failed to write UI hint to message buffer."); + + hr = PipeSendMessage(pEngineState->embeddedConnection.hPipe, BURN_EMBEDDED_MESSAGE_TYPE_ERROR, pbData, cbData, NULL, NULL, &dwResult); + ExitOnFailure(hr, "Failed to send embedded message over pipe."); + + *pnResult = static_cast(dwResult); + +LExit: + ReleaseBuffer(pbData); + + return hr; +} + +HRESULT ExternalEngineSendEmbeddedProgress( + __in BURN_ENGINE_STATE* pEngineState, + __in const DWORD dwProgressPercentage, + __in const DWORD dwOverallProgressPercentage, + __out int* pnResult + ) +{ + HRESULT hr = S_OK; + BYTE* pbData = NULL; + DWORD cbData = 0; + DWORD dwResult = *pnResult = 0; + + if (BURN_MODE_EMBEDDED != pEngineState->mode) + { + hr = HRESULT_FROM_WIN32(ERROR_INVALID_STATE); + ExitOnRootFailure(hr, "BA requested to send embedded progress message when not in embedded mode."); + } + + hr = BuffWriteNumber(&pbData, &cbData, dwProgressPercentage); + ExitOnFailure(hr, "Failed to write progress percentage to message buffer."); + + hr = BuffWriteNumber(&pbData, &cbData, dwOverallProgressPercentage); + ExitOnFailure(hr, "Failed to write overall progress percentage to message buffer."); + + hr = PipeSendMessage(pEngineState->embeddedConnection.hPipe, BURN_EMBEDDED_MESSAGE_TYPE_PROGRESS, pbData, cbData, NULL, NULL, &dwResult); + ExitOnFailure(hr, "Failed to send embedded progress message over pipe."); + + *pnResult = static_cast(dwResult); + +LExit: + ReleaseBuffer(pbData); + + return hr; +} + +HRESULT ExternalEngineSetUpdate( + __in BURN_ENGINE_STATE* pEngineState, + __in_z_opt LPCWSTR wzLocalSource, + __in_z_opt LPCWSTR wzDownloadSource, + __in const DWORD64 qwSize, + __in const BOOTSTRAPPER_UPDATE_HASH_TYPE hashType, + __in_opt const BYTE* rgbHash, + __in const DWORD cbHash + ) +{ + HRESULT hr = S_OK; + LPCWSTR sczId = NULL; + LPWSTR sczLocalSource = NULL; + LPWSTR sczCommandline = NULL; + UUID guid = { }; + WCHAR wzGuid[39]; + RPC_STATUS rs = RPC_S_OK; + + ::EnterCriticalSection(&pEngineState->csActive); + + if ((!wzLocalSource || !*wzLocalSource) && (!wzDownloadSource || !*wzDownloadSource)) + { + UpdateUninitialize(&pEngineState->update); + } + else if (BOOTSTRAPPER_UPDATE_HASH_TYPE_NONE == hashType && (0 != cbHash || rgbHash)) + { + hr = E_INVALIDARG; + } + else if (BOOTSTRAPPER_UPDATE_HASH_TYPE_SHA1 == hashType && (SHA1_HASH_LEN != cbHash || !rgbHash)) + { + hr = E_INVALIDARG; + } + else + { + UpdateUninitialize(&pEngineState->update); + + if (!wzLocalSource || !*wzLocalSource) + { + hr = StrAllocFormatted(&sczLocalSource, L"update\\%ls", pEngineState->registration.sczExecutableName); + ExitOnFailure(hr, "Failed to default local update source"); + } + + hr = CoreRecreateCommandLine(&sczCommandline, BOOTSTRAPPER_ACTION_INSTALL, pEngineState->command.display, pEngineState->command.restart, BOOTSTRAPPER_RELATION_NONE, FALSE, pEngineState->registration.sczActiveParent, pEngineState->registration.sczAncestors, NULL, pEngineState->command.wzCommandLine); + ExitOnFailure(hr, "Failed to recreate command-line for update bundle."); + + // Per-user bundles would fail to use the downloaded update bundle, as the existing install would already be cached + // at the registration id's location. Here I am generating a random guid, but in the future it would be nice if the + // feed would provide the ID of the update. + if (!pEngineState->registration.fPerMachine) + { + rs = ::UuidCreate(&guid); + hr = HRESULT_FROM_RPC(rs); + ExitOnFailure(hr, "Failed to create bundle update guid."); + + if (!::StringFromGUID2(guid, wzGuid, countof(wzGuid))) + { + hr = E_OUTOFMEMORY; + ExitOnRootFailure(hr, "Failed to convert bundle update guid into string."); + } + + sczId = wzGuid; + } + else + { + sczId = pEngineState->registration.sczId; + } + + hr = PseudoBundleInitialize(FILEMAKEVERSION(rmj, rmm, rup, rpr), &pEngineState->update.package, FALSE, sczId, BOOTSTRAPPER_RELATION_UPDATE, BOOTSTRAPPER_PACKAGE_STATE_ABSENT, pEngineState->registration.sczExecutableName, sczLocalSource ? sczLocalSource : wzLocalSource, wzDownloadSource, qwSize, TRUE, sczCommandline, NULL, NULL, NULL, rgbHash, cbHash); + ExitOnFailure(hr, "Failed to set update bundle."); + + pEngineState->update.fUpdateAvailable = TRUE; + } + +LExit: + ::LeaveCriticalSection(&pEngineState->csActive); + + ReleaseStr(sczCommandline); + ReleaseStr(sczLocalSource); + + return hr; +} + +HRESULT ExternalEngineSetLocalSource( + __in BURN_ENGINE_STATE* pEngineState, + __in_z_opt LPCWSTR wzPackageOrContainerId, + __in_z_opt LPCWSTR wzPayloadId, + __in_z LPCWSTR wzPath + ) +{ + HRESULT hr = S_OK; + BURN_CONTAINER* pContainer = NULL; + BURN_PAYLOAD* pPayload = NULL; + + ::EnterCriticalSection(&pEngineState->csActive); + hr = UserExperienceEnsureEngineInactive(&pEngineState->userExperience); + ExitOnFailure(hr, "Engine is active, cannot change engine state."); + + if (!wzPath || !*wzPath) + { + hr = E_INVALIDARG; + } + else if (wzPayloadId && *wzPayloadId) + { + hr = PayloadFindById(&pEngineState->payloads, wzPayloadId, &pPayload); + ExitOnFailure(hr, "BA requested unknown payload with id: %ls", wzPayloadId); + + if (BURN_PAYLOAD_PACKAGING_EMBEDDED == pPayload->packaging) + { + hr = HRESULT_FROM_WIN32(ERROR_INVALID_OPERATION); + ExitOnFailure(hr, "BA denied while trying to set source on embedded payload: %ls", wzPayloadId); + } + + hr = StrAllocString(&pPayload->sczSourcePath, wzPath, 0); + ExitOnFailure(hr, "Failed to set source path for payload."); + } + else if (wzPackageOrContainerId && *wzPackageOrContainerId) + { + hr = ContainerFindById(&pEngineState->containers, wzPackageOrContainerId, &pContainer); + ExitOnFailure(hr, "BA requested unknown container with id: %ls", wzPackageOrContainerId); + + hr = StrAllocString(&pContainer->sczSourcePath, wzPath, 0); + ExitOnFailure(hr, "Failed to set source path for container."); + } + else + { + hr = E_INVALIDARG; + } + +LExit: + ::LeaveCriticalSection(&pEngineState->csActive); + + return hr; +} + +HRESULT ExternalEngineSetDownloadSource( + __in BURN_ENGINE_STATE* pEngineState, + __in_z_opt LPCWSTR wzPackageOrContainerId, + __in_z_opt LPCWSTR wzPayloadId, + __in_z_opt LPCWSTR wzUrl, + __in_z_opt LPCWSTR wzUser, + __in_z_opt LPCWSTR wzPassword + ) +{ + HRESULT hr = S_OK; + BURN_CONTAINER* pContainer = NULL; + BURN_PAYLOAD* pPayload = NULL; + DOWNLOAD_SOURCE* pDownloadSource = NULL; + + ::EnterCriticalSection(&pEngineState->csActive); + hr = UserExperienceEnsureEngineInactive(&pEngineState->userExperience); + ExitOnFailure(hr, "Engine is active, cannot change engine state."); + + if (wzPayloadId && *wzPayloadId) + { + hr = PayloadFindById(&pEngineState->payloads, wzPayloadId, &pPayload); + ExitOnFailure(hr, "BA requested unknown payload with id: %ls", wzPayloadId); + + if (BURN_PAYLOAD_PACKAGING_EMBEDDED == pPayload->packaging) + { + hr = HRESULT_FROM_WIN32(ERROR_INVALID_OPERATION); + ExitOnFailure(hr, "BA denied while trying to set download URL on embedded payload: %ls", wzPayloadId); + } + + pDownloadSource = &pPayload->downloadSource; + } + else if (wzPackageOrContainerId && *wzPackageOrContainerId) + { + hr = ContainerFindById(&pEngineState->containers, wzPackageOrContainerId, &pContainer); + ExitOnFailure(hr, "BA requested unknown container with id: %ls", wzPackageOrContainerId); + + pDownloadSource = &pContainer->downloadSource; + } + else + { + hr = E_INVALIDARG; + ExitOnFailure(hr, "BA did not provide container or payload id."); + } + + if (wzUrl && *wzUrl) + { + hr = StrAllocString(&pDownloadSource->sczUrl, wzUrl, 0); + ExitOnFailure(hr, "Failed to set download URL."); + + if (wzUser && *wzUser) + { + hr = StrAllocString(&pDownloadSource->sczUser, wzUser, 0); + ExitOnFailure(hr, "Failed to set download user."); + + if (wzPassword && *wzPassword) + { + hr = StrAllocString(&pDownloadSource->sczPassword, wzPassword, 0); + ExitOnFailure(hr, "Failed to set download password."); + } + else // no password. + { + ReleaseNullStr(pDownloadSource->sczPassword); + } + } + else // no user means no password either. + { + ReleaseNullStr(pDownloadSource->sczUser); + ReleaseNullStr(pDownloadSource->sczPassword); + } + } + else // no URL provided means clear out the whole download source. + { + ReleaseNullStr(pDownloadSource->sczUrl); + ReleaseNullStr(pDownloadSource->sczUser); + ReleaseNullStr(pDownloadSource->sczPassword); + } + +LExit: + ::LeaveCriticalSection(&pEngineState->csActive); + + return hr; +} + +HRESULT ExternalEngineSetVariableNumeric( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzVariable, + __in const LONGLONG llValue + ) +{ + HRESULT hr = S_OK; + + if (wzVariable && *wzVariable) + { + hr = VariableSetNumeric(&pEngineState->variables, wzVariable, llValue, FALSE); + ExitOnFailure(hr, "Failed to set numeric variable."); + } + else + { + hr = E_INVALIDARG; + ExitOnFailure(hr, "SetVariableNumeric did not provide variable name."); + } + +LExit: + return hr; +} + +HRESULT ExternalEngineSetVariableString( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzVariable, + __in_z_opt LPCWSTR wzValue, + __in const BOOL fFormatted + ) +{ + HRESULT hr = S_OK; + + if (wzVariable && *wzVariable) + { + hr = VariableSetString(&pEngineState->variables, wzVariable, wzValue, FALSE, fFormatted); + ExitOnFailure(hr, "Failed to set string variable."); + } + else + { + hr = E_INVALIDARG; + ExitOnFailure(hr, "SetVariableString did not provide variable name."); + } + +LExit: + return hr; +} + +HRESULT ExternalEngineSetVariableVersion( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzVariable, + __in_z_opt LPCWSTR wzValue + ) +{ + HRESULT hr = S_OK; + VERUTIL_VERSION* pVersion = NULL; + + if (wzVariable && *wzVariable) + { + if (wzValue) + { + hr = VerParseVersion(wzValue, 0, FALSE, &pVersion); + ExitOnFailure(hr, "Failed to parse new version value."); + } + + hr = VariableSetVersion(&pEngineState->variables, wzVariable, pVersion, FALSE); + ExitOnFailure(hr, "Failed to set version variable."); + } + else + { + hr = E_INVALIDARG; + ExitOnFailure(hr, "SetVariableVersion did not provide variable name."); + } + +LExit: + ReleaseVerutilVersion(pVersion); + + return hr; +} + +void ExternalEngineCloseSplashScreen( + __in BURN_ENGINE_STATE* pEngineState + ) +{ + // If the splash screen is still around, close it. + if (::IsWindow(pEngineState->command.hwndSplashScreen)) + { + ::PostMessageW(pEngineState->command.hwndSplashScreen, WM_CLOSE, 0, 0); + } +} + +HRESULT ExternalEngineCompareVersions( + __in_z LPCWSTR wzVersion1, + __in_z LPCWSTR wzVersion2, + __out int* pnResult + ) +{ + HRESULT hr = S_OK; + + hr = VerCompareStringVersions(wzVersion1, wzVersion2, FALSE, pnResult); + + return hr; +} + +HRESULT ExternalEngineDetect( + __in const DWORD dwThreadId, + __in_opt const HWND hwndParent + ) +{ + HRESULT hr = S_OK; + + if (!::PostThreadMessageW(dwThreadId, WM_BURN_DETECT, 0, reinterpret_cast(hwndParent))) + { + ExitWithLastError(hr, "Failed to post detect message."); + } + +LExit: + return hr; +} + +HRESULT ExternalEnginePlan( + __in const DWORD dwThreadId, + __in const BOOTSTRAPPER_ACTION action + ) +{ + HRESULT hr = S_OK; + + if (!::PostThreadMessageW(dwThreadId, WM_BURN_PLAN, 0, action)) + { + ExitWithLastError(hr, "Failed to post plan message."); + } + +LExit: + return hr; +} + +HRESULT ExternalEngineElevate( + __in BURN_ENGINE_STATE* pEngineState, + __in const DWORD dwThreadId, + __in_opt const HWND hwndParent + ) +{ + HRESULT hr = S_OK; + + if (INVALID_HANDLE_VALUE != pEngineState->companionConnection.hPipe) + { + hr = HRESULT_FROM_WIN32(ERROR_ALREADY_INITIALIZED); + } + else if (!::PostThreadMessageW(dwThreadId, WM_BURN_ELEVATE, 0, reinterpret_cast(hwndParent))) + { + ExitWithLastError(hr, "Failed to post elevate message."); + } + +LExit: + return hr; +} + +HRESULT ExternalEngineApply( + __in const DWORD dwThreadId, + __in_opt const HWND hwndParent + ) +{ + HRESULT hr = S_OK; + + ExitOnNull(hwndParent, hr, E_INVALIDARG, "BA passed NULL hwndParent to Apply."); + if (!::IsWindow(hwndParent)) + { + ExitOnFailure(hr = E_INVALIDARG, "BA passed invalid hwndParent to Apply."); + } + + if (!::PostThreadMessageW(dwThreadId, WM_BURN_APPLY, 0, reinterpret_cast(hwndParent))) + { + ExitWithLastError(hr, "Failed to post apply message."); + } + +LExit: + return hr; +} + +HRESULT ExternalEngineQuit( + __in const DWORD dwThreadId, + __in const DWORD dwExitCode + ) +{ + HRESULT hr = S_OK; + + if (!::PostThreadMessageW(dwThreadId, WM_BURN_QUIT, static_cast(dwExitCode), 0)) + { + ExitWithLastError(hr, "Failed to post shutdown message."); + } + +LExit: + return hr; +} + +HRESULT ExternalEngineLaunchApprovedExe( + __in BURN_ENGINE_STATE* pEngineState, + __in const DWORD dwThreadId, + __in_opt const HWND hwndParent, + __in_z LPCWSTR wzApprovedExeForElevationId, + __in_z_opt LPCWSTR wzArguments, + __in const DWORD dwWaitForInputIdleTimeout + ) +{ + HRESULT hr = S_OK; + BURN_APPROVED_EXE* pApprovedExe = NULL; + BOOL fLeaveCriticalSection = FALSE; + BURN_LAUNCH_APPROVED_EXE* pLaunchApprovedExe = NULL; + + pLaunchApprovedExe = (BURN_LAUNCH_APPROVED_EXE*)MemAlloc(sizeof(BURN_LAUNCH_APPROVED_EXE), TRUE); + ExitOnNull(pLaunchApprovedExe, hr, E_OUTOFMEMORY, "Failed to alloc BURN_LAUNCH_APPROVED_EXE"); + + ::EnterCriticalSection(&pEngineState->csActive); + fLeaveCriticalSection = TRUE; + hr = UserExperienceEnsureEngineInactive(&pEngineState->userExperience); + ExitOnFailure(hr, "Engine is active, cannot change engine state."); + + if (!wzApprovedExeForElevationId || !*wzApprovedExeForElevationId) + { + ExitFunction1(hr = E_INVALIDARG); + } + + hr = ApprovedExesFindById(&pEngineState->approvedExes, wzApprovedExeForElevationId, &pApprovedExe); + ExitOnFailure(hr, "BA requested unknown approved exe with id: %ls", wzApprovedExeForElevationId); + + ::LeaveCriticalSection(&pEngineState->csActive); + fLeaveCriticalSection = FALSE; + + hr = StrAllocString(&pLaunchApprovedExe->sczId, wzApprovedExeForElevationId, NULL); + ExitOnFailure(hr, "Failed to copy the id."); + + if (wzArguments) + { + hr = StrAllocString(&pLaunchApprovedExe->sczArguments, wzArguments, NULL); + ExitOnFailure(hr, "Failed to copy the arguments."); + } + + pLaunchApprovedExe->dwWaitForInputIdleTimeout = dwWaitForInputIdleTimeout; + + pLaunchApprovedExe->hwndParent = hwndParent; + + if (!::PostThreadMessageW(dwThreadId, WM_BURN_LAUNCH_APPROVED_EXE, 0, reinterpret_cast(pLaunchApprovedExe))) + { + ExitWithLastError(hr, "Failed to post launch approved exe message."); + } + +LExit: + if (fLeaveCriticalSection) + { + ::LeaveCriticalSection(&pEngineState->csActive); + } + + if (FAILED(hr)) + { + ApprovedExesUninitializeLaunch(pLaunchApprovedExe); + } + + return hr; +} + // TODO: callers need to provide the original size (at the time of first public release) of the struct instead of the current size. HRESULT WINAPI ExternalEngineValidateMessageParameter( __in_opt const LPVOID pv, @@ -28,3 +757,34 @@ HRESULT WINAPI ExternalEngineValidateMessageParameter( LExit: return hr; } + +static HRESULT CopyStringToExternal( + __in_z LPWSTR wzValue, + __in_z_opt LPWSTR wzBuffer, + __inout DWORD* pcchBuffer + ) +{ + HRESULT hr = S_OK; + BOOL fTooSmall = !wzBuffer; + + if (!fTooSmall) + { + hr = ::StringCchCopyExW(wzBuffer, *pcchBuffer, wzValue, NULL, NULL, STRSAFE_FILL_BEHIND_NULL); + if (STRSAFE_E_INSUFFICIENT_BUFFER == hr) + { + fTooSmall = TRUE; + } + } + + if (fTooSmall) + { + hr = ::StringCchLengthW(wzValue, STRSAFE_MAX_CCH, reinterpret_cast(pcchBuffer)); + if (SUCCEEDED(hr)) + { + hr = E_MOREDATA; + *pcchBuffer += 1; // null terminator. + } + } + + return hr; +} diff --git a/src/engine/externalengine.h b/src/engine/externalengine.h index 7910b224..3f7bc8c8 100644 --- a/src/engine/externalengine.h +++ b/src/engine/externalengine.h @@ -11,6 +11,160 @@ extern "C" { #endif +void ExternalEngineGetPackageCount( + __in BURN_ENGINE_STATE* pEngineState, + __out DWORD* pcPackages + ); + +HRESULT ExternalEngineGetVariableNumeric( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzVariable, + __out LONGLONG* pllValue + ); + +HRESULT ExternalEngineGetVariableString( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzVariable, + __out_ecount_opt(*pcchValue) LPWSTR wzValue, + __inout DWORD* pcchValue + ); + +HRESULT ExternalEngineGetVariableVersion( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzVariable, + __out_ecount_opt(*pcchValue) LPWSTR wzValue, + __inout DWORD* pcchValue + ); + +HRESULT ExternalEngineFormatString( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzIn, + __out_ecount_opt(*pcchOut) LPWSTR wzOut, + __inout DWORD* pcchOut + ); + +HRESULT ExternalEngineEscapeString( + __in_z LPCWSTR wzIn, + __out_ecount_opt(*pcchOut) LPWSTR wzOut, + __inout DWORD* pcchOut + ); + +HRESULT ExternalEngineEvaluateCondition( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzCondition, + __out BOOL* pf + ); + +HRESULT ExternalEngineLog( + __in REPORT_LEVEL rl, + __in_z LPCWSTR wzMessage + ); + +HRESULT ExternalEngineSendEmbeddedError( + __in BURN_ENGINE_STATE* pEngineState, + __in const DWORD dwErrorCode, + __in_z LPCWSTR wzMessage, + __in const DWORD dwUIHint, + __out int* pnResult + ); + +HRESULT ExternalEngineSendEmbeddedProgress( + __in BURN_ENGINE_STATE* pEngineState, + __in const DWORD dwProgressPercentage, + __in const DWORD dwOverallProgressPercentage, + __out int* pnResult + ); + +HRESULT ExternalEngineSetUpdate( + __in BURN_ENGINE_STATE* pEngineState, + __in_z_opt LPCWSTR wzLocalSource, + __in_z_opt LPCWSTR wzDownloadSource, + __in const DWORD64 qwSize, + __in const BOOTSTRAPPER_UPDATE_HASH_TYPE hashType, + __in_opt const BYTE* rgbHash, + __in const DWORD cbHash + ); + +HRESULT ExternalEngineSetLocalSource( + __in BURN_ENGINE_STATE* pEngineState, + __in_z_opt LPCWSTR wzPackageOrContainerId, + __in_z_opt LPCWSTR wzPayloadId, + __in_z LPCWSTR wzPath + ); + +HRESULT ExternalEngineSetDownloadSource( + __in BURN_ENGINE_STATE* pEngineState, + __in_z_opt LPCWSTR wzPackageOrContainerId, + __in_z_opt LPCWSTR wzPayloadId, + __in_z_opt LPCWSTR wzUrl, + __in_z_opt LPCWSTR wzUser, + __in_z_opt LPCWSTR wzPassword + ); + +HRESULT ExternalEngineSetVariableNumeric( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzVariable, + __in const LONGLONG llValue + ); + +HRESULT ExternalEngineSetVariableString( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzVariable, + __in_z_opt LPCWSTR wzValue, + __in const BOOL fFormatted + ); + +HRESULT ExternalEngineSetVariableVersion( + __in BURN_ENGINE_STATE* pEngineState, + __in_z LPCWSTR wzVariable, + __in_z_opt LPCWSTR wzValue + ); + +void ExternalEngineCloseSplashScreen( + __in BURN_ENGINE_STATE* pEngineState + ); + +HRESULT ExternalEngineCompareVersions( + __in_z LPCWSTR wzVersion1, + __in_z LPCWSTR wzVersion2, + __out int* pnResult + ); + +HRESULT ExternalEngineDetect( + __in const DWORD dwThreadId, + __in_opt const HWND hwndParent + ); + +HRESULT ExternalEnginePlan( + __in const DWORD dwThreadId, + __in const BOOTSTRAPPER_ACTION action + ); + +HRESULT ExternalEngineElevate( + __in BURN_ENGINE_STATE* pEngineState, + __in const DWORD dwThreadId, + __in_opt const HWND hwndParent + ); + +HRESULT ExternalEngineApply( + __in const DWORD dwThreadId, + __in_opt const HWND hwndParent + ); + +HRESULT ExternalEngineQuit( + __in const DWORD dwThreadId, + __in const DWORD dwExitCode + ); + +HRESULT ExternalEngineLaunchApprovedExe( + __in BURN_ENGINE_STATE* pEngineState, + __in const DWORD dwThreadId, + __in_opt const HWND hwndParent, + __in_z LPCWSTR wzApprovedExeForElevationId, + __in_z_opt LPCWSTR wzArguments, + __in const DWORD dwWaitForInputIdleTimeout + ); + HRESULT WINAPI ExternalEngineValidateMessageParameter( __in_opt const LPVOID pv, __in SIZE_T cbSizeOffset, diff --git a/src/engine/pseudobundle.cpp b/src/engine/pseudobundle.cpp index 70f93701..0864be3a 100644 --- a/src/engine/pseudobundle.cpp +++ b/src/engine/pseudobundle.cpp @@ -19,8 +19,8 @@ extern "C" HRESULT PseudoBundleInitialize( __in_z_opt LPCWSTR wzRepairArguments, __in_z_opt LPCWSTR wzUninstallArguments, __in_opt BURN_DEPENDENCY_PROVIDER* pDependencyProvider, - __in_opt BYTE* pbHash, - __in DWORD cbHash + __in_opt const BYTE* pbHash, + __in const DWORD cbHash ) { HRESULT hr = S_OK; diff --git a/src/engine/pseudobundle.h b/src/engine/pseudobundle.h index 144f6880..4d3d3052 100644 --- a/src/engine/pseudobundle.h +++ b/src/engine/pseudobundle.h @@ -22,8 +22,8 @@ HRESULT PseudoBundleInitialize( __in_z_opt LPCWSTR wzRepairArguments, __in_z_opt LPCWSTR wzUninstallArguments, __in_opt BURN_DEPENDENCY_PROVIDER* pDependencyProvider, - __in_opt BYTE* pbHash, - __in DWORD cbHash + __in_opt const BYTE* pbHash, + __in const DWORD cbHash ); HRESULT PseudoBundleInitializePassthrough( __in BURN_PACKAGE* pPassthroughPackage, -- cgit v1.2.3-55-g6feb