extern "C" HRESULT MspEngineExecutePackage(
__in_opt HWND hwndParent,
__in BURN_EXECUTE_ACTION* pExecuteAction,
__in BURN_VARIABLES* pVariables,
__in BOOL fRollback,
__in PFN_MSIEXECUTEMESSAGEHANDLER pfnMessageHandler,
__in LPVOID pvContext,
__out BOOTSTRAPPER_APPLY_RESTART* pRestart
)
{
HRESULT hr = S_OK;
INSTALLUILEVEL uiLevel = pExecuteAction->mspTarget.pPackage->Msp.fDisplayInternalUI ? INSTALLUILEVEL_DEFAULT : static_cast<INSTALLUILEVEL>(INSTALLUILEVEL_NONE | INSTALLUILEVEL_SOURCERESONLY);
WIU_MSI_EXECUTE_CONTEXT context = { };
WIU_RESTART restart = WIU_RESTART_NONE;
LPWSTR sczCachedDirectory = NULL;
LPWSTR sczMspPath = NULL;
LPWSTR sczPatches = NULL;
LPWSTR sczProperties = NULL;
LPWSTR sczObfuscatedProperties = NULL;
// default to "verbose" logging
DWORD dwLogMode = WIU_LOG_DEFAULT | INSTALLLOGMODE_VERBOSE;
// get cached MSP paths
for (DWORD i = 0; i < pExecuteAction->mspTarget.cOrderedPatches; ++i)
{
LPCWSTR wzAppend = NULL;
BURN_PACKAGE* pMspPackage = pExecuteAction->mspTarget.rgOrderedPatches[i].pPackage;
AssertSz(BURN_PACKAGE_TYPE_MSP == pMspPackage->type, "Invalid package type added to ordered patches.");
if (BOOTSTRAPPER_ACTION_STATE_INSTALL == pExecuteAction->mspTarget.action)
{
hr = CacheGetCompletedPath(pMspPackage->fPerMachine, pMspPackage->sczCacheId, &sczCachedDirectory);
ExitOnFailure(hr, "Failed to get cached path for MSP package: %ls", pMspPackage->sczId);
// Best effort to set the execute package cache folder variable.
VariableSetString(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_CACHE_FOLDER, sczCachedDirectory, TRUE);
hr = PathConcat(sczCachedDirectory, pMspPackage->rgPayloads[0].pPayload->sczFilePath, &sczMspPath);
ExitOnFailure(hr, "Failed to build MSP path.");
wzAppend = sczMspPath;
}
else // uninstall
{
wzAppend = pMspPackage->Msp.sczPatchCode;
}
if (NULL != sczPatches)
{
hr = StrAllocConcat(&sczPatches, L";", 0);
ExitOnFailure(hr, "Failed to semi-colon delimit patches.");
}
hr = StrAllocConcat(&sczPatches, wzAppend, 0);
ExitOnFailure(hr, "Failed to append patch.");
}
// Wire up the external UI handler and logging.
hr = WiuInitializeExternalUI(pfnMessageHandler, uiLevel, hwndParent, pvContext, fRollback, &context);
ExitOnFailure(hr, "Failed to initialize external UI handler.");
//if (BURN_LOGGING_LEVEL_DEBUG == logLevel)
//{
// dwLogMode | INSTALLLOGMODE_EXTRADEBUG;
//}
if (pExecuteAction->mspTarget.sczLogPath && *pExecuteAction->mspTarget.sczLogPath)
{
hr = WiuEnableLog(dwLogMode, pExecuteAction->mspTarget.sczLogPath, 0);
ExitOnFailure(hr, "Failed to enable logging for package: %ls to: %ls", pExecuteAction->mspTarget.pPackage->sczId, pExecuteAction->mspTarget.sczLogPath);
}
// set up properties
hr = MsiEngineConcatProperties(pExecuteAction->mspTarget.pPackage->Msp.rgProperties, pExecuteAction->mspTarget.pPackage->Msp.cProperties, pVariables, fRollback, &sczProperties, FALSE);
ExitOnFailure(hr, "Failed to add properties to argument string.");
hr = MsiEngineConcatProperties(pExecuteAction->mspTarget.pPackage->Msp.rgProperties, pExecuteAction->mspTarget.pPackage->Msp.cProperties, pVariables, fRollback, &sczObfuscatedProperties, TRUE);
ExitOnFailure(hr, "Failed to add properties to obfuscated argument string.");
LogId(REPORT_STANDARD, MSG_APPLYING_PATCH_PACKAGE, pExecuteAction->mspTarget.pPackage->sczId, LoggingActionStateToString(pExecuteAction->mspTarget.action), sczPatches, sczObfuscatedProperties, pExecuteAction->mspTarget.sczTargetProductCode);
//
// Do the actual action.
//
switch (pExecuteAction->mspTarget.action)
{
case BOOTSTRAPPER_ACTION_STATE_INSTALL: __fallthrough;
case BOOTSTRAPPER_ACTION_STATE_REPAIR:
hr = StrAllocConcatSecure(&sczProperties, L" PATCH=\"", 0);
ExitOnFailure(hr, "Failed to add PATCH property on install.");
hr = StrAllocConcatSecure(&sczProperties, sczPatches, 0);
ExitOnFailure(hr, "Failed to add patches to PATCH property on install.");
hr = StrAllocConcatSecure(&sczProperties, L"\" REBOOT=ReallySuppress", 0);
ExitOnFailure(hr, "Failed to add reboot suppression property on install.");
hr = WiuConfigureProductEx(pExecuteAction->mspTarget.sczTargetProductCode, INSTALLLEVEL_DEFAULT, INSTALLSTATE_DEFAULT, sczProperties, &restart);
ExitOnFailure(hr, "Failed to install MSP package.");
break;
case BOOTSTRAPPER_ACTION_STATE_UNINSTALL:
hr = StrAllocConcatSecure(&sczProperties, L" REBOOT=ReallySuppress", 0);
ExitOnFailure(hr, "Failed to add reboot suppression property on uninstall.");
// Ignore all dependencies, since the Burn engine already performed the check.
hr = StrAllocFormattedSecure(&sczProperties, L"%ls %ls=ALL", sczProperties, DEPENDENCY_IGNOREDEPENDENCIES);
ExitOnFailure(hr, "Failed to add the list of dependencies to ignore to the properties.");
hr = WiuRemovePatches(sczPatches, pExecuteAction->mspTarget.sczTargetProductCode, sczProperties, &restart);
ExitOnFailure(hr, "Failed to uninstall MSP package.");
break;
}
LExit:
WiuUninitializeExternalUI(&context);
ReleaseStr(sczCachedDirectory);
ReleaseStr(sczMspPath);
StrSecureZeroFreeString(sczProperties);
ReleaseStr(sczObfuscatedProperties);
ReleaseStr(sczPatches);
switch (restart)
{
case WIU_RESTART_NONE:
*pRestart = BOOTSTRAPPER_APPLY_RESTART_NONE;
break;
case WIU_RESTART_REQUIRED:
*pRestart = BOOTSTRAPPER_APPLY_RESTART_REQUIRED;
break;
case WIU_RESTART_INITIATED:
*pRestart = BOOTSTRAPPER_APPLY_RESTART_INITIATED;
break;
}
// Best effort to clear the execute package cache folder variable.
VariableSetString(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_CACHE_FOLDER, NULL, TRUE);
return hr;
}
extern "C" HRESULT ExeEngineExecutePackage(
__in BURN_EXECUTE_ACTION* pExecuteAction,
__in BURN_VARIABLES* pVariables,
__in BOOL fRollback,
__in PFN_GENERICMESSAGEHANDLER pfnGenericMessageHandler,
__in LPVOID pvContext,
__out BOOTSTRAPPER_APPLY_RESTART* pRestart
)
{
HRESULT hr = S_OK;
WCHAR wzCurrentDirectory[MAX_PATH] = { };
BOOL fChangedCurrentDirectory = FALSE;
int nResult = IDNOACTION;
LPCWSTR wzArguments = NULL;
LPWSTR sczArgumentsFormatted = NULL;
LPWSTR sczArgumentsObfuscated = NULL;
LPWSTR sczCachedDirectory = NULL;
LPWSTR sczExecutablePath = NULL;
LPWSTR sczCommand = NULL;
LPWSTR sczCommandObfuscated = NULL;
STARTUPINFOW si = { };
PROCESS_INFORMATION pi = { };
DWORD dwExitCode = 0;
GENERIC_EXECUTE_MESSAGE message = { };
// get cached executable path
hr = CacheGetCompletedPath(pExecuteAction->exePackage.pPackage->fPerMachine, pExecuteAction->exePackage.pPackage->sczCacheId, &sczCachedDirectory);
ExitOnFailure1(hr, "Failed to get cached path for package: %ls", pExecuteAction->exePackage.pPackage->sczId);
// Best effort to set the execute package cache folder variable.
VariableSetString(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_CACHE_FOLDER, sczCachedDirectory, TRUE);
hr = PathConcat(sczCachedDirectory, pExecuteAction->exePackage.pPackage->rgPayloads[0].pPayload->sczFilePath, &sczExecutablePath);
ExitOnFailure(hr, "Failed to build executable path.");
// pick arguments
switch (pExecuteAction->exePackage.action)
{
case BOOTSTRAPPER_ACTION_STATE_INSTALL:
wzArguments = pExecuteAction->exePackage.pPackage->Exe.sczInstallArguments;
break;
case BOOTSTRAPPER_ACTION_STATE_UNINSTALL:
wzArguments = pExecuteAction->exePackage.pPackage->Exe.sczUninstallArguments;
break;
case BOOTSTRAPPER_ACTION_STATE_REPAIR:
wzArguments = pExecuteAction->exePackage.pPackage->Exe.sczRepairArguments;
break;
default:
hr = E_UNEXPECTED;
ExitOnFailure(hr, "Failed to get action arguments for executable package.");
}
// build command
if (wzArguments && *wzArguments)
{
hr = VariableFormatString(pVariables, wzArguments, &sczArgumentsFormatted, NULL);
ExitOnFailure(hr, "Failed to format argument string.");
hr = StrAllocFormattedSecure(&sczCommand, L"\"%ls\" %s", sczExecutablePath, sczArgumentsFormatted);
ExitOnFailure(hr, "Failed to create executable command.");
hr = VariableFormatStringObfuscated(pVariables, wzArguments, &sczArgumentsObfuscated, NULL);
ExitOnFailure(hr, "Failed to format obfuscated argument string.");
hr = StrAllocFormatted(&sczCommandObfuscated, L"\"%ls\" %s", sczExecutablePath, sczArgumentsObfuscated);
}
else
{
hr = StrAllocFormatted(&sczCommand, L"\"%ls\"", sczExecutablePath);
ExitOnFailure(hr, "Failed to create executable command.");
hr = StrAllocFormatted(&sczCommandObfuscated, L"\"%ls\"", sczExecutablePath);
}
ExitOnFailure(hr, "Failed to create obfuscated executable command.");
if (BURN_EXE_PROTOCOL_TYPE_BURN == pExecuteAction->exePackage.pPackage->Exe.protocol)
{
// Add the list of dependencies to ignore, if any, to the burn command line.
if (pExecuteAction->exePackage.sczIgnoreDependencies && BURN_EXE_PROTOCOL_TYPE_BURN == pExecuteAction->exePackage.pPackage->Exe.protocol)
{
hr = StrAllocFormattedSecure(&sczCommand, L"%ls -%ls=%ls", sczCommand, BURN_COMMANDLINE_SWITCH_IGNOREDEPENDENCIES, pExecuteAction->exePackage.sczIgnoreDependencies);
ExitOnFailure(hr, "Failed to append the list of dependencies to ignore to the command line.");
hr = StrAllocFormatted(&sczCommandObfuscated, L"%ls -%ls=%ls", sczCommandObfuscated, BURN_COMMANDLINE_SWITCH_IGNOREDEPENDENCIES, pExecuteAction->exePackage.sczIgnoreDependencies);
ExitOnFailure(hr, "Failed to append the list of dependencies to ignore to the obfuscated command line.");
}
// Add the list of ancestors, if any, to the burn command line.
if (pExecuteAction->exePackage.sczAncestors)
{
hr = StrAllocFormattedSecure(&sczCommand, L"%ls -%ls=%ls", sczCommand, BURN_COMMANDLINE_SWITCH_ANCESTORS, pExecuteAction->exePackage.sczAncestors);
ExitOnFailure(hr, "Failed to append the list of ancestors to the command line.");
hr = StrAllocFormatted(&sczCommandObfuscated, L"%ls -%ls=%ls", sczCommandObfuscated, BURN_COMMANDLINE_SWITCH_ANCESTORS, pExecuteAction->exePackage.sczAncestors);
ExitOnFailure(hr, "Failed to append the list of ancestors to the obfuscated command line.");
}
}
// Log before we add the secret pipe name and client token for embedded processes.
LogId(REPORT_STANDARD, MSG_APPLYING_PACKAGE, LoggingRollbackOrExecute(fRollback), pExecuteAction->exePackage.pPackage->sczId, LoggingActionStateToString(pExecuteAction->exePackage.action), sczExecutablePath, sczCommandObfuscated);
if (!pExecuteAction->exePackage.fFireAndForget && BURN_EXE_PROTOCOL_TYPE_BURN == pExecuteAction->exePackage.pPackage->Exe.protocol)
{
hr = EmbeddedRunBundle(sczExecutablePath, sczCommand, pfnGenericMessageHandler, pvContext, &dwExitCode);
ExitOnFailure1(hr, "Failed to run bundle as embedded from path: %ls", sczExecutablePath);
}
else if (!pExecuteAction->exePackage.fFireAndForget && BURN_EXE_PROTOCOL_TYPE_NETFX4 == pExecuteAction->exePackage.pPackage->Exe.protocol)
{
hr = NetFxRunChainer(sczExecutablePath, sczCommand, pfnGenericMessageHandler, pvContext, &dwExitCode);
ExitOnFailure1(hr, "Failed to run netfx chainer: %ls", sczExecutablePath);
}
else // create and wait for the executable process while sending fake progress to allow cancel.
{
// Make the cache location of the executable the current directory to help those executables
// that expect stuff to be relative to them.
if (::GetCurrentDirectoryW(countof(wzCurrentDirectory), wzCurrentDirectory))
{
fChangedCurrentDirectory = ::SetCurrentDirectoryW(sczCachedDirectory);
}
si.cb = sizeof(si); // TODO: hookup the stdin/stdout/stderr pipes for logging purposes?
if (!::CreateProcessW(sczExecutablePath, sczCommand, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi))
{
ExitWithLastError1(hr, "Failed to CreateProcess on path: %ls", sczExecutablePath);
}
if (pExecuteAction->exePackage.fFireAndForget)
{
::WaitForInputIdle(pi.hProcess, 5000);
ExitFunction();
}
do
{
message.type = GENERIC_EXECUTE_MESSAGE_PROGRESS;
message.dwAllowedResults = MB_OKCANCEL;
message.progress.dwPercentage = 50;
nResult = pfnGenericMessageHandler(&message, pvContext);
hr = (IDOK == nResult || IDNOACTION == nResult) ? S_OK : IDCANCEL == nResult ? HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT) : HRESULT_FROM_WIN32(ERROR_INSTALL_FAILURE);
ExitOnRootFailure(hr, "Bootstrapper application aborted during EXE progress.");
hr = ProcWaitForCompletion(pi.hProcess, 500, &dwExitCode);
if (HRESULT_FROM_WIN32(WAIT_TIMEOUT) != hr)
{
ExitOnFailure1(hr, "Failed to wait for executable to complete: %ls", sczExecutablePath);
}
} while (HRESULT_FROM_WIN32(WAIT_TIMEOUT) == hr);
}
hr = HandleExitCode(pExecuteAction->exePackage.pPackage, dwExitCode, pRestart);
ExitOnRootFailure1(hr, "Process returned error: 0x%x", dwExitCode);
LExit:
if (fChangedCurrentDirectory)
{
::SetCurrentDirectoryW(wzCurrentDirectory);
}
StrSecureZeroFreeString(sczArgumentsFormatted);
ReleaseStr(sczArgumentsObfuscated);
ReleaseStr(sczCachedDirectory);
ReleaseStr(sczExecutablePath);
StrSecureZeroFreeString(sczCommand);
ReleaseStr(sczCommandObfuscated);
ReleaseHandle(pi.hThread);
ReleaseHandle(pi.hProcess);
// Best effort to clear the execute package cache folder variable.
VariableSetString(pVariables, BURN_BUNDLE_EXECUTE_PACKAGE_CACHE_FOLDER, NULL, TRUE);
return hr;
}
extern "C" HRESULT MsuEngineExecutePackage(
__in BURN_EXECUTE_ACTION* pExecuteAction,
__in BOOL fRollback,
__in PFN_GENERICMESSAGEHANDLER pfnGenericMessageHandler,
__in LPVOID pvContext,
__out BOOTSTRAPPER_APPLY_RESTART* pRestart
)
{
HRESULT hr = S_OK;
int nResult = IDNOACTION;
LPWSTR sczCachedDirectory = NULL;
LPWSTR sczMsuPath = NULL;
LPWSTR sczSystemPath = NULL;
LPWSTR sczWusaPath = NULL;
LPWSTR sczCommand = NULL;
SC_HANDLE schWu = NULL;
BOOL fWuWasDisabled = FALSE;
STARTUPINFOW si = { };
PROCESS_INFORMATION pi = { };
GENERIC_EXECUTE_MESSAGE message = { };
DWORD dwExitCode = 0;
BOOL fDoDependency = FALSE;
// get wusa.exe path
hr = PathGetKnownFolder(CSIDL_SYSTEM, &sczSystemPath);
ExitOnFailure(hr, "Failed to find System32 directory.");
hr = PathConcat(sczSystemPath, L"wusa.exe", &sczWusaPath);
ExitOnFailure(hr, "Failed to allocate WUSA.exe path.");
// build command
switch (pExecuteAction->msuPackage.action)
{
case BOOTSTRAPPER_ACTION_STATE_INSTALL:
// get cached executable path
hr = CacheGetCompletedPath(TRUE, pExecuteAction->msuPackage.pPackage->sczCacheId, &sczCachedDirectory);
ExitOnFailure1(hr, "Failed to get cached path for package: %ls", pExecuteAction->msuPackage.pPackage->sczId);
hr = PathConcat(sczCachedDirectory, pExecuteAction->msuPackage.pPackage->rgPayloads[0].pPayload->sczFilePath, &sczMsuPath);
ExitOnFailure(hr, "Failed to build executable path.");
// format command
hr = StrAllocFormatted(&sczCommand, L"\"%ls\" \"%ls\" /quiet /norestart", sczWusaPath, sczMsuPath);
ExitOnFailure(hr, "Failed to format MSU install command.");
break;
case BOOTSTRAPPER_ACTION_STATE_UNINSTALL:
// format command
hr = StrAllocFormatted(&sczCommand, L"\"%ls\" /uninstall /kb:%ls /quiet /norestart", sczWusaPath, pExecuteAction->msuPackage.pPackage->Msu.sczKB);
ExitOnFailure(hr, "Failed to format MSU uninstall command.");
break;
default:
hr = E_UNEXPECTED;
ExitOnFailure(hr, "Failed to get action arguments for MSU package.");
}
if (pExecuteAction->msuPackage.sczLogPath && *pExecuteAction->msuPackage.sczLogPath)
{
hr = StrAllocConcat(&sczCommand, L" /log:", 0);
ExitOnFailure(hr, "Failed to append log switch to MSU command-line.");
hr = StrAllocConcat(&sczCommand, pExecuteAction->msuPackage.sczLogPath, 0);
ExitOnFailure(hr, "Failed to append log path to MSU command-line.");
}
LogId(REPORT_STANDARD, MSG_APPLYING_PACKAGE, LoggingRollbackOrExecute(fRollback), pExecuteAction->msuPackage.pPackage->sczId, LoggingActionStateToString(pExecuteAction->msuPackage.action), sczMsuPath ? sczMsuPath : pExecuteAction->msuPackage.pPackage->Msu.sczKB, sczCommand);
hr = EnsureWUServiceEnabled(&schWu, &fWuWasDisabled);
ExitOnFailure(hr, "Failed to ensure WU service was enabled to install MSU package.");
// create process
si.cb = sizeof(si);
if (!::CreateProcessW(sczWusaPath, sczCommand, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi))
{
ExitWithLastError1(hr, "Failed to CreateProcess on path: %ls", sczWusaPath);
}
do
{
message.type = GENERIC_EXECUTE_MESSAGE_PROGRESS;
message.dwAllowedResults = MB_OKCANCEL;
message.progress.dwPercentage = 50;
nResult = pfnGenericMessageHandler(&message, pvContext);
hr = (IDOK == nResult || IDNOACTION == nResult) ? S_OK : IDCANCEL == nResult ? HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT) : HRESULT_FROM_WIN32(ERROR_INSTALL_FAILURE);
ExitOnRootFailure(hr, "Bootstrapper application aborted during MSU progress.");
// wait for process to terminate
hr = ProcWaitForCompletion(pi.hProcess, 500, &dwExitCode);
if (HRESULT_FROM_WIN32(WAIT_TIMEOUT) != hr)
{
ExitOnFailure1(hr, "Failed to wait for executable to complete: %ls", sczWusaPath);
}
} while (HRESULT_FROM_WIN32(WAIT_TIMEOUT) == hr);
// get process exit code
if (!::GetExitCodeProcess(pi.hProcess, &dwExitCode))
{
ExitWithLastError(hr, "Failed to get process exit code.");
}
// We'll normalize the restart required error code from wusa.exe just in case. Most likely
// that on reboot we'll actually get WU_S_REBOOT_REQUIRED.
if (HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_REQUIRED) == static_cast<HRESULT>(dwExitCode))
{
dwExitCode = ERROR_SUCCESS_REBOOT_REQUIRED;
}
// handle exit code
switch (dwExitCode)
{
case S_OK: __fallthrough;
case WU_S_ALREADY_INSTALLED:
fDoDependency = TRUE;
__fallthrough;
case S_FALSE: __fallthrough;
case WU_E_NOT_APPLICABLE:
*pRestart = BOOTSTRAPPER_APPLY_RESTART_NONE;
hr = S_OK;
break;
case ERROR_SUCCESS_REBOOT_REQUIRED: __fallthrough;
case WU_S_REBOOT_REQUIRED:
fDoDependency = TRUE;
*pRestart = BOOTSTRAPPER_APPLY_RESTART_REQUIRED;
hr = S_OK;
break;
default:
hr = E_UNEXPECTED;
break;
}
if (fDoDependency)
{
if (BOOTSTRAPPER_ACTION_STATE_INSTALL == pExecuteAction->msuPackage.action)
{
hr = DependencyRegisterPackage(pExecuteAction->msuPackage.pPackage);
ExitOnFailure(hr, "Failed to register the package dependency providers.");
}
else if (BOOTSTRAPPER_ACTION_STATE_UNINSTALL == pExecuteAction->msuPackage.action)
{
hr = DependencyUnregisterPackage(pExecuteAction->msuPackage.pPackage);
ExitOnFailure(hr, "Failed to unregister the package dependency providers.");
}
}
LExit:
ReleaseStr(sczCachedDirectory);
ReleaseStr(sczMsuPath);
ReleaseStr(sczSystemPath);
ReleaseStr(sczWusaPath);
ReleaseStr(sczCommand);
ReleaseHandle(pi.hProcess);
ReleaseHandle(pi.hThread);
if (fWuWasDisabled)
{
SetServiceStartType(schWu, SERVICE_DISABLED);
}
return hr;
}
